基本概念

官方文档参考：

https://docs.ansible.com/ansible/latest/user_guide/playbooks_strategies.html

strategy

单个 play 级的调度策略，定义执行实例是否有步骤锁，即单个 task 是否等待其他实例执行完成。具体有两种方式：

• linear

Task execution is in lockstep per host batch as defined by serial (default all). Up to the fork limit of hosts will execute each task at the same time and then the next series of hosts until the batch is done, before going on to the next task.

默认值。在一个实例分组(serial)内，开始执行下一个任务需要等待所有实例上一个任务执行完成。

• free

Task execution is as fast as possible per batch as defined by serial (default all). Ansible will not wait for other hosts to finish the current task before queuing more tasks for other hosts. All hosts are still attempted for the current task, but it prevents blocking new tasks for hosts that have already finished.
With the free strategy, unlike the default linear strategy, a host that is slow or stuck on a specific task won’t hold up the rest of the hosts and tasks.

非默认值。在一个实例分组(serial)内，开始执行下一个任务需要两个条件：

• 本实例上一个任务执行完成，
• 下一个任务的并发数(forks)有冗余。

forks

Maximum number of simultaneous connections Ansible made on each Task.

并发数。在单个分组和单个任务中，同时执行任务的最大实例数。

serial

默认值为 all 。定义单轮执行实例的数量。当一轮实例全部执行完成后，下一轮的实例才会执行。

举例说明

定义5个实例数和2个任务，每个任务耗时5s:

• Node: C1\C2\C3\C4\C5
• Task:T1(5s), T2(5s)

先看看不同 strategy 场景：

场景1：strategy=linear, forks=5, (serial=all)

T1: C1-C2-C3-C4-C5 （5s）
T2: C1-C2-C3-C4-C5 （5s）

总耗时 10s

场景2: strategy=free, forks=5, (serial=all)

C1: T1->T2, 同时 C2: T1-> T2，同时 C3: T1->T2，同时 C4: T1->T2，同时 C5：T1->T2

总耗时 10s

在这个基础上修改 forks 数量，再看看不同 strategy 场景

场景3：strategy=linear, forks=3, (serial=all)

C1: T1->T2, 同时 C2: T1-> T2，同时 C3: T1->T2
C4: T1->T2，同时 C5：T1->T2

总耗时 20s

场景4：strategy=free, forks=3, (serial=all)

T1: C1-C2-C3 （5s）
T1: C4-C5 （5s）
T2: C1-C2-C3 （5s）
T2: C4-C5 （5s）

和场景3一样：20s
场景4和场景3表现一致：虽然单个实例之间互相无关联，但 C1-C2-C3 执行完 T1 前，T1最大 forks 为3，C4和C5需要等当前 T1 forks 有冗余时才能继续执行。

在 forks 为5时，修改 serial 的值：

场景5：strategy=linear, forks=5, serial=3

T1: C1-C2-C3 （5s）
T2: C1-C2-C3 （5s）
T1: C4-C5 （5s）
T2: C4-C5 （5s）

总耗时 20s

场景6：strategy=free, forks=5, serial=3

T1: C1-C2-C3 （5s）
T2: C1-C2-C3 （5s）
T1: C4-C5 （5s）
T2: C4-C5 （5s）

总耗时 20s

当 forks=3，serial=3 时：

场景7：strategy=linear, forks=3, serial=3

和场景5一致。

场景8：strategy=free, forks=3, serial=3

和场景6一致。

当 forks 小于 serial 时：

场景9：strategy=linear, forks=2, serial=3

T1: C1-C2 (5s)
T1: C3 （5s）
T2: C1-C2 （5s）
T2: C3 （5s）
T1: C4-C5 (5s)
T2: C4-C5 (5s)

总耗时 30s

场景10：strategy=free, forks=2, serial=3

T1: C1-C2 (5s)
T2: C1-C2 (5s)
T1: C3 （5s）
T2: C3 （5s）
T1: C4-C5 (5s)
T2: C4-C5 (5s)

总耗时 30s

工作

结束了一段 3 年的岗位，如愿以偿地到了某 E 厂。
尽管岗位有点不太理想，但也算是到了新环境，看到了很多新鲜的事情（But fresh not means good)。
回顾上一份工作的收获，应该是让我找到了自己的定位，或者说要努力的方向。毕业后糊里糊涂地过了 5 年，然后又经历了 2 年才看到自己尚且可做且还有些喜欢的一条路，可能浪费的时间有点多。但之前的经验是，每一份不起眼或者当时觉得无用的经历其实都是某种成长，在之后某个时刻一定会成为你脚下的基石。
迷茫的时候请认真做好现在每一件能做的事情，并且踏实地做到极致。
在这个基础上再去反思自己是否有更好的方向。

Time is short 。

且先扎实一年看看。

电影

因为疫情的原因今年去电影院看电影的次数屈指可数，基本是在手机、电视或者电脑上完成观影。
节奏也还 OK，在慢慢清理一部分之前某个人给我列的清单，大概看完也这样了。
是不是每次看完电影后写个双向链接笔记，做一些自我回顾和写作，前期可以一个月至少一次？
我觉得可以有。
慢慢在补一些之前没来得及或者因为懒癌发作而错过的日常番。

游戏

似乎今年玩游戏的整体时间少了很多，但有时候还是会放纵自己，比如今年国庆期间的 5 天假期，一个人宅家里昏天黑地地一直撸无主之地3，等日子过去了才想打脸：干点啥不好？
明年期待的是怪物猎人新作，其他时间尽量在手机上打发，这样还可以陪陪老婆（笑）。
总的来讲还是要继续减少游戏时间……

健康

体重悄无声息地往上走，但我最不能忍的是肚子竟然变大了……为此焦虑了好一段时间，并买了升降电脑桌。
健身环和有氧拳击玩了一段时间后没有再继续，是时候继续捡起来，不能再放任自己的腹部继续膨胀……
比如先从每周玩个三次，再增加到四次，或者早上起来锻炼？
为了管理体态请对自己狠一点……

关系

要更关爱家人，每周主动给爸妈打个电话。
明年买好房子，然后把关系定下来？

逝者不可追。

总（抄）结（袭）了一些好用的自定义方法，让 dataclass 用起来更舒服。

返回所有非 None 元素作为字典

from dataclasses import dataclass, asdict, fields


def factory_filter(data: list) -> dict:
    return dict(duple_item for duple_item in data if duple_item[1] is not None)


@dataclass
class BaseDataClass:
    """基础数据类"""

    def get_data(self) -> dict:
        """返回所有非 None 元素的字典"""
        return asdict(self, dict_factory=factory_filter)

测试：

@dataclass
class Person(BaseDataClass):
    name: str
    age: str
    sex: str = None


peter = Person(name="peter", age=17)
peter.get_data()

输出:

{'name': 'peter', 'age': 17}

工厂方法：自动忽略未定义的传入变量

如果用传入未定义的变量，那么会自动出错，比如：

peter = Person(name="peter", age=17, job='student')
---------------------------------------------------------------------------
TypeError  Traceback (most recent call last)
<ipython-input-4-948a3ccfe901> in <module>
      6 
      7 
----> 8 peter = Person(name="peter", age=17, job='student')

TypeError: __init__() got an unexpected keyword argument 'job'

还是上面的 BaseDataClass， 添加类方法：

    @classmethod
    def create_from_dict(cls, **dict_) -> dataclass:
        """工厂方法，自动忽略非 dataclass 参数"""
        class_fields = {f.name for f in fields(cls)}
        return cls(**{k: v for k, v in dict_.items() if k in class_fields})

再试一次：

peter = Person(name="peter", age=17)
print(Person.create_from_dict(name="peter", age=17, job='student').get_data())

输出:

{'name': 'peter', 'age': 17}

对比

namedtuple

用起来像是对 tuple 类添加了类似 index 或者 iterm name 的访问方式。

# 定义一个namedtuple类型User，并包含name，sex和age属性。
User = namedtuple('User', ['name', 'sex', 'age'])

# 创建一个User对象
user = User(name='kongxx', sex='male', age=21)

# 也可以通过一个list来创建一个User对象，这里注意需要使用"_make"方法
user = User._make(['kongxx', 'male', 21])

print(user)
# User(name='user1', sex='male', age=21)

# 获取用户的属性
print(user.name)
print(user.sex)
print(user.age)

# 修改对象属性，注意要使用"_replace"方法，看起来很不优雅
user = user._replace(age=22)
print(user)
# User(name='user1', sex='male', age=21)

# 将User对象转换成字典，注意要使用"_asdict"
print(user._asdict())
# OrderedDict([('name', 'kongxx'), ('sex', 'male'), ('age', 22)])

dataclass

官方文档链接： https://docs.python.org/3/library/dataclasses.html

简单用法如下，用 py3 function annotion 的语法来创建属性

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost(self) -> float:
        return self.unit_price * self.quantity_on_hand

有一个扑克牌的例子写得很好： https://juejin.im/post/6844903853700153357

from decorator import decorator
import time


@decorator
def time_counter(func, ignore: bool = False, *args, **kwargs):
    start = time.time()
    if ignore:
        result = False
    else:
        result = func(*args, **kwargs)
    end = time.time()
    delta = end - start
    print(f"The function runs {delta} seconds.")
    return result


@time_counter
def do_sleep(secondes):
    time.sleep(secondes)
    return True


@time_counter(ignore=True)
def do_nothing(secondes):
    time.sleep(secondes)
    return True


if do_sleep(4.5):
    print("Take a sleep :)")
if not do_nothing(4.5):
    print("Doing nothing :(")

$ python3 de_func.py
The function runs 4.505078077316284 seconds.
Take a sleep :)
The function runs 0.0 seconds.
Doing nothing :(

偷懒是人类进步的阶梯

今天看到一个概念，不是新的，但之前却很奇怪地完全没有接触过。

Docker multi-stage builds

简单来说，就是 Dockerfile 支持多次 build，然后把上一次 build 产生的文件直接 COPY 到下一次的 build 过程中。

相当于第二次的 build 里只执行了一次 COPY，省去中间很多下载、安装、编译的过程。

优点

• 把 build + run 过程分离，让 run 只负责 run；
• 大幅度减少 run 镜像的层数，从而压缩 run 环境的分发和更新时间；

缺点

• 对于动态语言来说（比如 SRE 工程师最爱的 Python），依赖环境较难处理，需要用额外的打包工具；
• 打包后镜像只有 run 环境，出问题的时候不方便进行 debug；

从上面的优缺点可以看到，对静态语言，尤其是最后可以打包成二进制的文件来说，多阶段构建的好处是显而易见的，对动态语言来说，就需要各种尝试，确认打包后程序的稳定性。

例子

这里摘抄两个在网上看到的 python 的例子：

使用 wheel

FROM python:2.7-alpine as base
RUN mkdir /svc
COPY . /svc
WORKDIR /svc
RUN apk add --update \
    postgresql-dev \
    gcc \
    musl-dev \
    linux-headers
RUN pip install wheel && pip wheel . --wheel-dir=/svc/wheels

FROM python:2.7-alpine
COPY --from=base /svc /svc
WORKDIR /svc
RUN pip install --no-index --find-links=/svc/wheels -r requirements.txt

使用 pyinstaller

FROM python:3.6 as build-env
WORKDIR /app/
ADD . /app/
ADD https://github.com/pyinstaller/pyinstaller/archive/develop.zip /app/pyinstaller-develop.zip
RUN pip install -r requirements.txt && \
    pip install pyinstaller-develop.zip
RUN pyinstaller --hidden-import=tornado --onefile -d -y run.py
 
FROM frolvlad/alpine-glibc
WORKDIR /app/
COPY --from=build-env /app/dist/run .
ENTRYPOINT ["./run"]

"Shit moutain."

项目地址

https://github.com/pyenv/pyenv

安装

brew install pyenv

命令

列出当前已安装的 python 版本

pyenv version

列出可安装版本

pyenv install --list

列出当前可用的虚拟环境

pyenv  virtualenvs

创建虚拟环境

pyenv virtualenv <Python 版本号> <虚拟环境名称>

激活虚拟环境

pyenv activate <虚拟环境名称>

退出虚拟环境

pyenv deactivate

删除虚拟环境

pyenv uninstall <虚拟环境名称>

Vscode

把工作区配置文件里的 "python.pythonPath" 换成 pyenv which python 打印的路径。

今天的对象：

• @classmethod 类方法；
• @staticmethod 静态方法；
• 普通实例方法；

1. 基本类

先写从普通的一个类写起：

class Fruit(object):

    def __init__(self, name):
        self.name = name

apple = Fruit('apple')

这个时候，我们称Fruit为class（类），apple为instance（实例）。

2. 实例方法

接下来再添加一个值price和方法show_price：

class Fruit(object):

    def __init__(self, name, price):
        self.name = name
        self.price = price

    def show_price(self):
        print(f'The price is {self.price}')

apple = Fruit('apple', 7.0)
apple.show_price()

这个时候，apple.show_price就是apple这个实例的instance method（实例方法）。
直接用 Fruit.show_price() 调用会出错，从两个概念上说：

• instance method是实例方法，只能由实例调用，不能由类调用。show_price(self)的第一个参数是实例。
• 水果没有价格的概念，苹果才有。

3. 类方法

继续添加一个方法eat()：

class Fruit(object):

    def __init__(self, name, price):
        self.name = name
        self.price = price

    def show_price(self):
        print(f'The price is {self.price}')

    @classmethod
    def eat(cls):
        print("Enjoy.")

apple = Fruit('apple', 7.0)
apple.show_price()
Fruit.eat()
apple.eat()

同样，我们从两个纬度理解：

• eat(cls)的参数是 cls，即类是它的参数，因此可以从类直接调用。实例也是类，因此实例也可以调用。类方法主要用于一些不需要实例化类就能调用的方法。
• 绝大部分水果具有可以食用的属性，因此说吃水果和吃苹果在逻辑上都成立。

4. 静态方法

这次我们添加一个静态方法 will_go_bad() 和一个外部的静态变量 BAD_WEATHER

BAD_WEATHER = True

class Fruit(object):

    def __init__(self, name, price):
        self.name = name
        self.price = price

    def show_price(self):
        print(f'The price is {self.price}')

    @classmethod
    def eat(cls):
        print("Enjoy.")

    @staticmethod
    def will_go_bad():
        if BAD_WEATHER:
            return True

apple = Fruit('apple', 7.0)
apple.will_go_bad()
Fruit.will_go_bad()

• 从空间上理解，静态方法 will_go_bad() 只是定义在类这个空间（类命名空间）中，没有任何特殊的cls 或者self 的绑定，它也不能访问类里任何的对象或者方法。和全局函数不同的是，它只能通过访问类这个空间来调用。静态方法用于处理类外部依赖的交互。
• 从逻辑上理解，坏天气会影响水果的好坏；但坏天气和水果之间是不能互相访问的，只能通过某种逻辑进行关联。

PIP 官方项目地址

https://pypi.org/project/manage.py/ （含官方用例）

安装

pip install mange.py

使用

1.创建命令

from manager import Manager

manager_echo = Manager()


@manager_echo.command
def echo_with_no_args():
    """Command description, will show on command line.
    """
    print("Hello")


if __name__ == '__main__':
    manager_echo.main()

$ python3 cli_sample.py
usage: cli_sample.py <command> [<args>]

positional arguments:
  command     the command to run

optional arguments:
  -h, --help  show this help message and exit

available commands:
  echo_with_no_args        Command description, will show on command line.

$ python3 cli_sample.py echo_with_no_args
Hello

2. 多重 namepspace 管理

from manager import Manager
import time

manager_echo = Manager()
manager_ops = Manager()
manager_main = Manager()

manager_main.merge(manager_echo, namespace='echo')
manager_main.merge(manager_ops, namespace='ops')


@manager_echo.command
def echo_with_no_args():
    """Command description, will show on command line.
    """
    print("Hello")


@manager_ops.command
def ops_with_no_args():
    """Do some operation without args.
    """
    print(time.time() + 1.0)


manager_main.merge(manager_echo, namespace='echo')
manager_main.merge(manager_ops, namespace='ops')

if __name__ == '__main__':
    manager_main.main()

python3 cli_sample.py
usage: cli_sample.py [<namespace>.]<command> [<args>]

positional arguments:
  command     the command to run

optional arguments:
  -h, --help  show this help message and exit

available commands:

  [echo]
    echo_with_no_args      Command description, will show on command line.


  [ops]
    ops_with_no_args       Do some operation without args.

python3 cli_sample.py ops.ops_with_no_args
1603078473.9244218

3.不带提示、按照顺序输入的参数

@manager_echo.command
def echo_with_args(name, pid):
    """Echo given <params>
    """
    print(f'Name is {name}, PID is {pid}')

$ python3 cli_sample.py echo.echo_with_args  test 77
Name is test, PID is 77

4.带提示的顺序输入的参数

@manager_echo.arg('name', help='User\'s name')
@manager_echo.arg('pid', help='App\'s PID')
@manager_echo.command
def echo_with_args(name, pid):
    """Echo given <params>
    """
    print(f'Name is {name}, PID is {pid}')

$ python3 cli_sample.py echo.echo_with_args -h
usage: cli_sample.py echo.echo_with_args [-h] name pid

Echo given <params>

positional arguments:
  name        User's name
  pid         App's PID

optional arguments:
  -h, --help  show this help message and exit

5. 必要参数和非必要参数的提示输入

@manager_echo.arg('name', help='User\'s name')
@manager_echo.arg('pid', help='App\'s PID')
@manager_echo.command
def echo_with_args(name, pid=''):
    """Echo given <params>
    """
    print(f'Name is {name}, PID is {pid}')

$ python3 cli_sample.py echo.echo_with_args -h
usage: cli_sample.py echo.echo_with_args [-h] [--name NAME] [--pid PID]

Echo given <params>

optional arguments:
  -h, --help   show this help message and exit
  --name NAME  User's name
  --pid PID    App's PID

$ temp python3 cli_sample.py echo.echo_with_args 123
Name is 123, PID is
$ temp python3 cli_sample.py echo.echo_with_args 123 --pid 777
Name is 123, PID is 777

或者作为布尔值使用：

@manager_echo.arg('name', help='User\'s name')
@manager_echo.arg('pid', help='App\'s PID')
@manager_echo.command
def echo_with_args(name, pid=False):
    """Echo given <params>
    """
    if pid:
        print(f'Name is {name}, PID exists')
    else:
        print(f'Name is {name}, PID not exists')

$ python3 cli_sample.py echo.echo_with_args batman
Name is batman, PID not exists
$ python3 cli_sample.py echo.echo_with_args batman --pid
Name is batman, PID exists

6.参数 shortcuts

@manager_echo.arg('name', shortcut='n', help='User\'s name')
@manager_echo.arg('pid', shortcut='p', help='App\'s PID')
@manager_echo.command
def echo_with_args(name, pid=False):
    """Echo given <params>
    """
    if pid:
        print(f'Name is {name}, PID exists')
    else:
        print(f'Name is {name}, PID not exists')

$ python3 cli_sample.py echo.echo_with_args batman --p
Name is batman, PID exists