0X00 前言

本篇文章是这篇「使用 git stash save 将暂存区命名」的重置版。因为根据 Google 的统计数据我得知某些问题的关键词搜索出来之后我的博客排行会比较靠前，所以把最容易被各位点击到的文章做了个重置计划，改进之前的一些不足，争取能够说的更清楚一些，也能节省各位一点点时间，希望能真正的帮助到从搜索引擎点进来的各位~

0X01 极度精炼的使用说明

可以使用 git stash save "message" 的方式为 stash 起来的变动命名，方便后面再次使用。

stash 起来过后可以使用 git stash list 来查看已经被 stash 的列表，这里可以看到已经有两条了，值得注意的是 stash 的 id 每次都在更新，最近 stash 的是 0，1 就是上次 stash 的，以此类推

如果需要从新应用某个 stash 的改动，可以使用 git stash apply STASH_ID 的方式，例如使用 git stash apply 1 就可以重新应用 id 为 1 的这个 stash。如果要丢弃掉某个 stash 的话使用 git stash drop STASH_ID 就可以了

0X00 换个方式定义函数

本篇内容不严格区分 function 与 method 🥹

我们都知道在 Python 中如何定义一个函数，只需要 def foo(arg_1, arg_2, *args, **kwargs)
就足够了。知道的稍微多一些呢可能知道「Python 中万物皆对象，所以函数的调用也只是调用了函数对象中的 __call__
方法」，所以我们可以尝试用这种方式调用一个函数

1
2
3
4
5
6
7

def say_hello():
    print('hello, world')

say_hello.__call__()

# output
# hello, world

既然可以这样调用了，我们也就可以用类似的方法来定义一个假的
function，可以发现我们自定义了随便一个类，但是只要它实现了 __call__ 方法就可以被当做函数一样调用

1
2
3
4
5
6
7
8

class Foo:
    def __call__(self):
        print('hello, world')

foo = Foo()foo()

# output
# hello, world

0X01 callable

根据上面的方法可知我们可以用 hasattr(obj, '__call__')
来判断某个对象是不是函数，事实上我也确实在同事的代码里看到过这样用的。其实 Python 内置了一个名为 callable
的函数可以用，不过跟 hasattr(obj, '__call__') 并不完全一致

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class Foo:
    pass


class Bar:
    def __call__(self):
        pass

func = lambda x : x


print(hasattr(Foo, '__call__'), callable(Foo))
# output: (False, True)

print(hasattr(Foo(), '__call__'), callable(Foo()))
# output: (False, False)

print(hasattr(Bar, '__call__'), callable(Bar))
# output: (True, True)

print(hasattr(Bar(), '__call__'), callable(Bar()))
# output: (True, True)

print(hasattr(func, '__call__'), callable(func))
# output: (True, True)

测试代码的第一行 Foo 类因为没有实现 __call__ 方法所以 hasattr 返回的是
False，而它是一个类，调用它就会实例化一个对象出来，所以它是可调用的，所以 callable 就返回了 True；第二行
Foo 类也没有实现 __call__ 方法所以 hasattr 返回的是 False，而且它又只是个普通对象，不是一个 class
所以导致 callable 也返回了 False；第三行因为 Bar 类实现了 __call__ 方法所以 hasattr 和 callable
都返回了 True；第四行也同理；第五行本是一个函数，所以也都返回了 True。

需要注意的是官方文档提到「callable 返回了 True 的不一定真的能调用成功，但是返回 False
的一定不能成功」，比如你强行给某个类设置了一个 __call__
但是又不是函数，可能就会出现这样的问题。不过你非要这么写的话，小心被同事打死噢 🤔

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Foo:
    def __init__(self):
        self.__call__ = '???'

foo = Foo()print(hasattr(foo, '__call__'))
print(callable(foo))
foo()

# output
# True
# True
# Traceback (most recent call last):
#   File "hello.py", line 8, in <module>
#     foo()
# TypeError: 'str' object is not callable

相关的官方文档：https://docs.python.org/3/library/functions.html#callable

0X00 可以被强制转换的自定义类

但凡写过 Python
的人应该都用过int()这个函数了，而且也都知道这个是将其他类型转换成int类型的内置方法，稍微用的多一点的还会知道这个方法如果传入不能被强制转换的数据时会抛出TypeError的异常。那你知道如何让自己定义的类可以被强制转换吗？

1
2
3
4
5
6
7
8
9
10
11
12
13

#!/usr/bin/env python3


class A:
    def __int__(self):
        return 233


a = A()
print(int(a))

# output
# 233

而且按照官方文档来说的话，如果你的class定义了__int__()方法，则int(your_obj)则会返回__int__()的值，如果定义了__index__()则会返回__index__()，如果定义了__trunc__()也会返回__trunc__()。当然是有优先级的，优先级`int

index > trunc`，可以使用如下代码分别注释这些方法测试一下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#!/usr/bin/env python3


class A:
    def __int__(self):
        return 1

    def __index__(self):
        return 2

    def __trunc__(self):
        return 3


a = A()
print(int(a))

0X01 int 的第二个参数

那你知道它其实还能接收第二个参数吗？其实 int()
方法可以接受第二个参数的，也就是用于进制转换的参数。换言说就是可以用内置的int()方法将其他进制的字符串数据转换成10进制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#!/usr/bin/env python3


print(int('12345'))  # 将字符串格式10进制数字转为整型
print(int('12345', base=10))  # base 默认就是10
print(int('12345', base=8))   # 8进制的12345转成10进制
print(int('FFFFF', base=16))  # 16进制的转成10进制
print(int('0XDEADBEEF', 16))  # 当然可以带对应的0X前缀
print(int('011111', 2))       # 将2进制的数字转成10进制

# output
# 12345
# 12345
# 5349
# 1048575
# 3735928559
# 31

0X02 hex、 bin 等其他转换方法

上面提到了进制转换，这里也就顺便说一下这两个方法好了。其中hex可以将整型数字转成0x开头的16进制字符串，bin可以将整形数字转成0b开头的2进制字符串

1
2
3
4
5
6
7

#!/usr/bin/env python3


print(hex(12345))
print(hex(3735928559))
print(bin(12345))
print(bin(23333))

还有几个之前从来不知道，这次写博客才在官方文档看到的用法，不仅可以控制大小写还能控制是否展示0X这种标记

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

In [1]: '%#x' % 255, '%x' % 255, '%X' % 255
Out[1]: ('0xff', 'ff', 'FF')

In [2]: format(255, '#x'), format(255, 'x'), format(255, 'X')
Out[2]: ('0xff', 'ff', 'FF')

In [3]: f'{255:#x}', f'{255:x}', f'{255:X}'
Out[3]: ('0xff', 'ff', 'FF')

In [4]: format(14, '#b'), format(14, 'b')
Out[4]: ('0b1110', '1110')

In [5]: f'{14:#b}', f'{14:b}'
Out[5]: ('0b1110', '1110')

In [6]: '%#o' % 10, '%o' % 10
Out[6]: ('0o12', '12')

In [7]: format(10, '#o'), format(10, 'o')
Out[7]: ('0o12', '12')

In [8]: f'{10:#o}', f'{10:o}'
Out[8]: ('0o12', '12')

官方文档参考：

https://docs.python.org/zh-cn/3/library/functions.html#int

https://docs.python.org/zh-cn/3/library/functions.html#hex

https://docs.python.org/zh-cn/3/library/functions.html#bin

https://docs.python.org/zh-cn/3/library/functions.html#oct

0X00 最常见的持久化方式：挂载出来

相信各位学习使用 Docker 的时候都会出现过好不容易用 Docker 启动了个数据库容器，然后发现只要容器消失之后数据也就一起消失了的情况。然后通常来说会使用这么一个方法来解决问题：将宿主机的某个目录挂载到容器里，这样一来那个数据库容器就可以将数据内容和配置持久化地存储下来了。一般会使用这么一个方法将某个目录挂载到容器内部 docker run -dit --name new_container --mount type=bind,source=/Users/shawn/Downloads/test/test_dir,target=/test_dir alpine 。

下面图中首先创建了一个名为 this_container 的容器，并将其 /test_dir 目录和宿主机的 /Users/shawn/Downloads/test/test_dir 目录绑定到一起了。然后在容器里向 /test_dir 写入文件之后发现在宿主机的对应位置也是可以看到的，并且文件不会因为容器的生命周期结束而被删除（如果数据在容器内部的话当容器被删除后自然也就不在了）。

这种方式其实更适合宿主机和容器需要共享一些文件的时候使用，例如我本地的开发环境在容器里但是代码又在宿主机上的情况就很适合这种方案。当然也可以将数据文件、配置文件等通过这种方式挂载出来。一般使用 Docker 部署各类服务的时候，都会将配置文件通过这种方式共享出来，方便我们在宿主机上修改配置然后在容器内部生效。

0X01 另一种持久化的方式：卷

说来惭愧，我一直以为只有上面一种数据持久化的方式，直到昨天看书的时候才知道 Docker 还有一种叫做 Volume 的存在。如果说上面说的将数据挂载出来到宿主机的方式有点类似与宿主机与虚拟机共享目录的话，那通过 Volume 持久化文件就类似于给虚拟机挂载一个虚拟磁盘了。

我们首先可以通过 docker volume ls 的方式检查一下当前环境是不是存在已经创建好了的 Volume，通常来说如果你的 Docker 环境已经用过一段时间并且创建过各种不同的容器的话那很有可能已经有存在的 Volume 了。接下来我们通过 docker run -dit --name volatiner --mount source=bizvol,target=/vol alpine 来启动一个容器，后面 mount 的参数就是将名为 bizvol 的 Volume 挂载到容器的 /vol 目录上。这里值得注意的一点是即使你没有手动创建这个名为 bizvol 的 Volume 也是可以正常启动这个容器的，Docker 会为我们自动创建这个 bizvol Volume 的。接下来再使用 docker volume ls 就可以看到这个被创建好了的 Volume 了，我们尝试着向其中写入一点点数据，然后删除这个容器，可以发现这个 Volume 还是健在的，此时我们再启动一个新的容器使用这个 Volume 是没问题的，甚至启动多个容器同时挂载都是可以的，这些容器里都能正常读写该 Volume 的数据。

关于 Volume 有如下几个命令，这里简单介绍一下

1
2
3
4
5

docker volume create    # 创建 Volume
docekr volume ls        # 查看当前存在的 Volume
docker volume inspect   # 检查 Volume 的详细信息
docker volume prune     # 删除未被容器或服务使用的全部 Volume
docker volume rm        # 删除指定 Volume

0X00 前言 & 简介

说起来但凡各位用过 Linux 就应该用过 ssh 了吧，所以怎么使用 ssh 去连接一台服务器、怎么去配置 key 登陆而非密码、怎么允许/禁止 root 用户使用这种问题就不再过多讨论了，这篇文章来介绍一下 ssh隧道 这个东西。

说起来各位在生活工作中肯定遇到过这么一个情况，如图所示：我（A）自己想要访问一台机器（C）但是A和C是不通的，这时候有一台中间的机器（B），A可以访问到B且B和C也是通的（比如说梯子的应用场景）。r当然了你在中间的B机器上开一个 OpenVPN 肯定是可行的，但是一旦你的A连上了 VPN 之后所有流量也就都从B上走了，绝大多数情况下我们其实并不是很需要一个 VPN 而是需要一个轻量化的解决方案。这时候 ssh 隧道就是我们的一个很好的比较轻量化的解决方案，首先它不需要你在客户端和服务器上安装额外的软件（如果你连 ssh 都没装那就不说了）；其次它不需要配置文件，为数不多的配置直接写在命令行里；最后它不需要额外的守护进程，你不用了就直接 Ctrl + C 干掉当前进程就行了。

ssh 隧道其实本质上来说就是转发，那我们来依次介绍一下这四种隧道（转发）方法

0X01 动态转发

动态转发是在本地建立一个通往另一台机器的隧道，然后网络监听在本地的某端口，使用 socks5 协议。使用对应的协议和端口的出口流量都会被转发到另一台机器，再由它访问后转发给你。比如你在墙内是无法访问 wikipedia 的，但是你“恰好”有一台在海外的服务器，那么你就可以通过这种方式建立一个简单且临时的小梯子。

命令格式是：ssh -D local-port username@tunnel-host -N，比如说 ssh -D 1080 shawn@123.1.2.3 -N

-D 是绑定后面的本地端口
-N 是说非交互环境，不需要执行命令，挂着就好

这样一来就可以在浏览器上配置代理了，配上 socks5://127.0.0.1:1080 之后就可以访问更广阔的互联网了 YOU ARE FREEDOM !!!

这种动态转发其实平时用到的机会并没有很多，因为开发过程中用代理还是比较麻烦的，并不是所有软件/工具都支持独立配置代理，直接配置在浏览器或者操作系统上的话又很容易误伤到其他的进程。如果想要更细致的管理还是需要用下面的本地和远程转发方案。

0X02 本地转发

本地转发也是在本地建立隧道，监听在本地端口，一切发往本地该端口的流量都会根据配置转发到另一台机器上。比如我前几天工作中遇到的一个情景：开发机是 macOS 的，客户用来联调的服务器在他们内网需要 VPN 才行，但是他们用的 VPN 客户端没有 macOS的。所以我在 macOS 上装了个虚拟机，虚拟机起连上了他们的 VPN 也就可以访问联调环境了，但是我的 macOS 还是不能直接访问。这时候就可以用 ssh 隧道来解决问题了。

命令格式是：ssh -L local-port:target-host:target-port username@tunnel-host，比如说 ssh -L 8080:123.123.123.123:80 shawn@123.1.2.3

-L 指的是建立一条本地隧道 local

这样一来我再curl -XGET http://127.0.0.1:8080的时候，流量就会顺着 ssh 的隧道一路直接到最终客户的联调环境了。这种本地转发的情况是非常常用的，这样一来本来没有通的两个机器也就通过这样一条隧道连接起来了。最重要的是我们只占用了本地机器的一个端口，并不影响其他任何的系统配置和任何进程。

0X03 远程转发

远程转发是在中转的服务器上建立隧道，跟本地转发最大的不同是：本地转发只是本地用户自己建立了一条隧道给自己用，但是远程转发可以将端口共享出来给多台设备使用。还是说上面我的那个联调环境，如果说只有我一个人自己联调就用本地转发是刚刚好的，而且不用再登录到远程环境上去，也不需要远程用户比较高的权限。但是说如果我们全公司都在进行这个联调，那就可以用远程转发，在中转服务器上把自己的端口开放出来让所有用户一起使用。

命令格式是：ssh -R local-port:target-host:target-port -N local，例如 ssh -R 8080:123.123.123.123:80 -N local

-R 建立一条远程隧道 remote

这样建立起来的隧道就可以给其他机器使用了，现在所有可以访问中转机的机器都可以通过中转机的 8080 端口访问到客户的联调机。所以说这里的远程转发和本地转发除了命令执行地不同、可用的机器不同以外就没有什么比较大的区别了。

0X04 其它参数

这里再介绍几个额外的参数

-f 后台运行，这样 ssh 隧道就不用占用你当前的 shell 了
-C 压缩内容，原则上就是用 CPU 换带宽
-g 开放本地端口，如果本地转发的时候加了这个参数，那就跟远程转发差不多了