toolbox 是自己整理的一些脚本库，将平时用的多的常用操作固定成脚本，可追踪可维护，减少重复劳动。主要有脚本、Shell命令和docker-compose配置三块。

脚本

• 增加了 install-python.sh 脚本，方便编译安装对应的 Python 版本
• 统一了脚本文件名，依照动词+用途命名，例如 install-XXX、set-XXX
• Shebang 均使用 #!/usr/bin/env bash 提高兼容性
• 更新、删除了一些失效脚本

docker-compose配置

简单更新了一下镜像版本。

其他的遇到了一个有意思的问题，如何在 Jenkins 的容器内继续使用 Docker。参考 Using docker in a dockerized Jenkins container 更新编排文件。

21世纪的第三个十年，加油！

看到一则新闻，Linux QQ全新回归，号称“从心出发·趣无止境”。官网：https://im.qq.com/linuxqq/

1
2
3
4
5

Linux QQ 2.0.0 Beta（New）2019/10/24
    - Linux QQ全新回归
    - 支持x64、ARM64、MIPS64三种架构
    - 优化消息体验，完善消息收发能力
    - 性能优化

高中竞赛的时候 QQ 有 Linux 版本，可惜后面不维护，再后面就没了。现在重新发布，第一时间下载体验。很遗憾，这个复古的界面效果，和十年前的界面没太多的区别。deepin 深色主题下，聊天框背景还都是黑的，很难看清聊天窗口。

麻利的卸载，继续打开了 Tim，感谢 deepin 商店配置的 wine Tim。希望腾讯继续努力，以后 Linux 原生版本的体验能达到正常水平。

总则

除非项目有自己的约定，默认应该遵循 PEP8 和 Google Python 风格指南 的要求。在开始编写代码前，请阅读并了解这两个文档。

项目约定

代码布局

风格

• list，tuple，dict 多行定义的时候，每行结尾增加,，用于减少 git diff 时候的变动。

行长度

最大行长度180，推荐不超过120。

推荐在 PyCharm 内设置 Wrapping and braces，Visual guides设置为 120, 180。

格式化

使用 format 函数进行格式化，不使用 % 的方式。

导入格式

导入超过一行的情况下，使用括号包住引入模块。左括号后直接换行，右括号前不加内容。如下：

1
2
3

from package_name import (
    module_1, module_2, module_3, module_4, module_5
)

嵌套函数（Nested function）

• 嵌套函数声明在使用的代码之前的地方
• 嵌套函数必须以_前缀开头

函数命名

• 判断检查类型逻辑的函数以 is_ 或 has_ 前缀开头，返回值应该是 bool 类型
• 验证校验类型逻辑的函数以 check_ 或 validate_ 前缀开头，返回值可以包括相关的对象
• 进行操作的函数应该以动词开头，如 set_、get_、process_、enable_、disable_ 等

接入新客户的数据，处理的数据量比之前上了一个量级。以前的索引数据库用的 PostgreSQL ，客户端代码暂时没空修改，为了支持这批数据，打算迁移到 Greenplum。

Greenplum 是先进的基于 PostgreSQL 的开源分布式数据库之一。因为兼容 PostgreSQL 的接口，客户端无需做太多的修改就可以使用。本身是基于MPP架构设计的一套数据分析系统，方便扩展，系统稳定，很适合我们的场景。Greenplum是Pivotal旗下的产品，有商业公司开发和维护，会有更好的技术支持和服务。

架构

Greenplum基于MPP架构，如上。 Master 节点作为系统的入口，处理SQL请求。 Segment 节点存储和处理数据。 Master 和 Segment 之间通过 Interconnect 这个网络层连接起来。

一个SQL查询到 Master 节点， Master 会分发到 Segment 节点进行计算，计算结果最后再汇总到 Master 节点，处理好之后返回数据。 Master 和 Segment 分别通过 StandBy Master 和 Mirror 节点提供高可用。 Segment 节点之间并没有太多的数据交互。这种架构好处是简单，好扩展，但是感觉 Master 节点容易成为系统的瓶颈。整个系统的入口和数据最后的汇总都在 Master 节点上，负载可不轻松。

安装

Greenplum提供了详细的安装文档， 6.0 新版本刚发布，我直接使用的新版本。

主要安装步骤如下：

1. 检查系统、硬件是否满足条件
2. 操作系统配置修改
3. Greenplum 用户创建
4. Greenplum 系统安装
5. Greenplum 系统初始化

提供了 ansible 脚本：https://gpdb.docs.pivotal.io/6-0/install_guide/ansible-example.html

软硬件要求

• 主流的操作系统都行
• 必须使用 XFS 文件系统 实测其他的也行，不过最好按照官方文档用XFS，其他可能影响性能
• 内存 16G +，硬盘要求导入数据后可用空间大于30% 实测够用就行
• 10Gbps 内网宽带 不满足也能用

操作系统配置修改

主要三个：

1. 关闭 SELinux： 在 /etc/selinux/config 中设置 SELINUX=disabled，重启即可
2. 关闭防火墙：CentOS firewalld / Ubuntu ufw
3. 同步系统时间：系统NTP服务需要打开，时间必须一致

Greenplum 用户创建

也是三个，首先创建 gpadmin 用户和用户组

1
2

sudo groupadd gpadmin
sudo useradd gpadmin -r -m -g gpadmin

再生成密钥对

1
2
3
4

sudo su gpadmin
chsh -s /bin/bash
ssh-keygen -o -a 100 -t ed25519
cp .ssh/id_ed25519.pub .ssh/authorized_keys

最后将管理用户设置为 sudo 免密，方便以后自己操作

1

echo 'pgadmin ALL=(ALL) NOPASSWD: ALL' | EDITOR='tee -a' visudo

Greenplum 系统安装

Ubuntu 系统有现成的PPA源，Pivotal也提供编译好的二进制包。我选择的是最新版本的 greenplum-db。

1
2

sudo add-apt-repository ppa:greenplum/db
sudo apt install greenplum-db

Greenplum 系统初始化

文档在此，需要在 master 节点上操作。

创建用于初始化的 host 文件

创建 hostfile_gpinitsystem 包括所有 segment 节点的地址，不包括 master 和 standby master。更改配置文件，确保 master 到各个 segment 节点的连接正确。

1
2

ssh-keyscan -f hostfile_gpinitsystem || sudo tee -a /etc/ssh/ssh_known_hosts
gpssh-exkeys -f hostfile_gpinitsystem

创建 Greenplum 数据库配置文件

1
2

source /opt/greenplum-db-6.0.1/greenplum_path.sh
cp /opt/greenplum-db-6.0.1/docs/cli_help/gpconfigs/gpinitsystem_config /home/gpadmin/gpinitsystem_config

主要修改的几个参数按照文档要求的填对就行。

创建数据存储区域

需要在各个类型的节点上创建 Greenplum 用于存储数据的路径，并配置好权限。数据存储路径需要和配置文件的保持一致。可以利用 Greenplum 提供的工具在 master 节点操作整个网络。

Master

1
2

mkdir -p /data/master
chown gpadmin:gpadmin /data/master

Standby master

1
2
3

source /opt/greenplum-db-6.0.1/greenplum_path.sh
gpssh -h smdw -e 'mkdir -p /data/master'
gpssh -h smdw -e 'chown gpadmin:gpadmin /data/master'

Segment

1
2
3
4
5

source /opt/greenplum-db-6.0.1/greenplum_path.sh
gpssh -f hostfile_gpinitsystem -e 'mkdir -p /data/data-1'
gpssh -f hostfile_gpinitsystem -e 'mkdir -p /data/data-2'
gpssh -f hostfile_gpinitsystem -e 'mkdir -p /data/data-3'
gpssh -f hostfile_gpinitsystem -e 'chown -R gpadmin:gpadmin /data/data-*'

Mirror

1
2
3
4
5

source /opt/greenplum-db-6.0.1/greenplum_path.sh
gpssh -f hostfile_gpinitsystem -e 'mkdir -p /data/mirror-1'
gpssh -f hostfile_gpinitsystem -e 'mkdir -p /data/mirror-2'
gpssh -f hostfile_gpinitsystem -e 'mkdir -p /data/mirror-3'
gpssh -f hostfile_gpinitsystem -e 'chown -R gpadmin:gpadmin /data/mirror-*'

初始化数据库

上面都整好了，就可以执行命令初始化数据库了。

1

gpinitsystem -c gpinitsystem_config -h hostfile_gpinitsystem

为了方便以后的操作，可以增加下面内容到 .bashrc，不用每次 source 引入环境变量。

1
2

source /opt/greenplum-db-6.0.1/greenplum_path.sh
export MASTER_DATA_DIRECTORY=/data/master/gpseg-1

迁移

生产环境使用的 PostgreSQL 11，使用了很多新特性，包括BRIN等。Greenplum 6 还是基于 PG 9.4 版本，一些东西老版本的不支持，需要特别注意，处理一下。

迁移使用PG自带的工具 pg_dump 和 psql ，很快可以灌入数据。

碰到的问题

小问题就不提了，看 log 和文档定位到修改就好了，说一个奇葩的问题。

查询一个SQL语句，只要带 Group By 就无法返回结果，而 sum 却可以拿到结果。查看日志没有报错。查询就是等待返回数据，非常诡异。master 和 segment 节点是有超时设置的，如果是 segment 查询超时，应该会有错误日志，但是很诡异，就是没有详细的异常日志。根据Greenplum的架构图，猜测应该是 master 节点处理的问题，但是继续检查配置文件、检查Log，依旧找不到问题。

搜索结果中看到了三罐可乐带你读懂Greenplum的interconnect，可能是 Greenplum 的 interconnect 导致 master 对 segment 返回的结果处理有奇怪的逻辑。整个网络状态是正常的，端口监听也正常。反思整个部署过程，打开了 /etc/hosts 文件。

1
2
3
4
5

127.0.0.1``````hostname1

172.31.0.2``````hostname1
172.31.0.3``````hostname2
172.31.0.4``````hostname3

云服务器的系统会在 hosts 文件将自己的 hostname 配置成 127.0.0.1，搭建 Greenplum 集群的时候设置的 hosts 添加在这一行下面。删除本机 127.0.0.1 的配置，重启系统，恢复正常。

深度操作系统V15.11已经发布，发行标记见：深度操作系统 V15.11——心随意动 畅享云端

这个版本一个大的变化是早先的 unstable 版本已正式停止技术支持，所有 unstable 用户需要重新下载安装 stable 版本。个人觉得这是个非常不友好的变动，无论如何，重新安装系统成本都是非常巨大的。早先 deepin 切换到基于 debian 时的一个目标就是学习 Arch 的滚动升级策略，复杂升级不再需要重装系统，现在看未实现这个功能。

桌面环境的一个变动是从之前的 dde-wm 升级到了 dde-kwin，目的主要是通过使用新的 kwin 来支持 Wayland。但是新开发一套桌面的窗口管理系统是很麻烦的，需要时间来完善。目前的 dde-kwin 很多功能还是缺失的，右键菜单刚支持极少的功能。Firefox 浏览器上因为 dde-kwin 带来的窗口条无法隐藏，严重影响美观。

其他主要是一些内置软件的功能更新和BUG修复。这类内置软件，我的态度是够用就行，美观最好。这里就不再赘述了。

deepin 是国内最用心的在做 Linux 操作系统的厂商，这一点指的表扬和尊敬。但是人是要恰饭的，公司是要盈利的。现在王勇离开，企业被360收购，前途多了一些不确定。希望未来 deepin 能在进一步商业化探索的同时，保持自己的初心。

今晚打开 readfree 的网站，不再是熟悉的界面，而是一封告别辞。

随着国内版权意识或主动、或被动的提高，我迎来了 readfree 的告别。在以前 readfree 可以正常访问的时候，我就不止一次的想过这个问题：虽然我方便的找到了书籍，但是很这明显侵权了书籍的版权，这个网站真的可以这么正常的存活在中国的互联网上么？现实给予了答案。

但是无论如何，我从 readfree 获益良多，感谢网站管理员以前的辛苦付出。尊重知识产权是读书之人应有之意，我相信管理员顺应大势，做出了一个正确的选择。感谢 readfree 多年以来的陪伴，它实现了他最初的愿景，希望未来的某一天，会以一个更加合适的方式归来。

结尾附上 readfree 告别辞。

最近整理博客，发现很大一部人都是新手教程性质的“How to”类，内容主要是记录怎么手把手解决事情。没什么难度，非常简单，都是查询官方文档或者Google搜索出的解决方案。考虑到国内很多人其实只会用百度，看CSDN来工作的现实，我这类“How to”类的小笔记是有意义和有价值的。比那些不知道经过多少手的“资料”，自己的一手小笔记更加准确。我是个喜欢整理的人，这类小笔记，以后打算做成一个系列，名称会以how-to开头，也都会带上how-to的标签。以前有一个换灯泡作为“伪”第一篇，这个作为“真”第一篇。

最近重装了 deepin 系统，版本号重装前和重装后系统版本都是15.10,但是系统依赖却有了很大的不同。之前的版本是滚动升级上来的，基于 Debian 的测试源，deepin 自己的代号panda，发行版名称deepin unstable。重新安装之后，变成了 Debian 的稳定版，deepin 代号 lion，发行版名称deepin stable。panda下可以直接从源安装Python3.6，升级之后因为基于 Debian 稳定版，源里移除了。好在编译安装也不麻烦，下面就是正常的从源代码编译安装的步骤。

下面的方法在 deepin 上测试通过，应该同样适用于 Debian、Ubuntu。

0x0 升级系统 & 安装依赖

打算编译安装以前，首先升级系统，安装必要的依赖。这样可以避免之后安装 Python 时缺少第三方库的问题。

1
2
3
4

sudo apt update
sudo apt install -y make build-essential libssl-dev zlib1g-dev
sudo apt install -y libbz2-dev libreadline-dev libsqlite3-dev liblzma-dev wget curl llvm
sudo apt install -y libncurses5-dev libncursesw5-dev xz-utils tk-dev

0x1 下载 Python 包并编译安装

这次计划安装 Python 3.6.8，相关页面：https://www.python.org/downloads/release/python-368/

1

wget https://www.python.org/ftp/python/3.6.8/Python-3.6.8.tgz

从压缩包解压源代码：

1

tar xvf Python-3.6.8.tgz

进入目录，执行 ./configure 配置构建文件:

1
2

cd Python-3.6.8
./configure --enable-optimizations

编译并安装：

1

make -j8 && sudo make altinstall

0x2 收尾工作

1

sudo make clean

至此 Python3.6 已经安装完成，可以在命令行执行python3.6查看效果，pipenv创建当前版本的环境也会自动调用。

参考资料

• How to Install Python 3.6.4 on Debian 9

思路

题目地址：Vijos P1005 超长数字串

想法一

最直接的做法，是维护一个字符串，枚举这个无限长的S字符串。然后直接在S中寻找第一次出现位置。空间是有限的，所以我们不可能无限制枚举。可以根据内存限制和测试点范围，估计一个大概的长度，然后填满这个有限长度的S。依照这个想法快速写出代码，可以：

• 能提交一个部分AC的程序，捞到保底分
• 方便构造复杂一点的测试用例

想法二

上面这样当然没法得到全部的正确答案。这个题目很明显，A的长度不超过200，这个长度为 200 的数，假设为 N，一定会出现在 S 中。知道某个 N，我们是可以根据规律直接计算出他出现的位置。所以这个问题就转化成求最小的 N，最小的 N 是可以通过枚举 N 的位数来直接尝试出的。

按照这个思路，可以得到求解方式为：

1. 从 1 到 len(A) 枚举 N 的长度 L
2. 对于每个长度 L，在 A 中从后往前构造长度为 L 的数 M，检测 M 构造的数是否满足 A
3. 对于每个长度 L，不停的用 M 更新 N，求出最小的 N 值，记录 N 值在字符串 A 的偏移量
4. 根据 N 和偏移量计算位置
5. S 从 1 开始编号，所以需要位置 +1 得到答案

不考虑数据大小，这个方式是正确的思路，稍微注意边界条件，可以得到正确的结果。边界条件包括：

• 字符串 A 全为 0，直接在前面补 1 得到 N，然后使用偏移量 -1 进行计算
• 每一个构造的 M 不能以 0 开头，如果是，直接跳过
• 在 A 中构造 L 长度的数值 M。如果 M 的位数不够，需要从前面的内容填充
• 如果前面 (L - 缺失位数)的内容全为 9，M 需要填充(L - 缺失位数)的 0
• 否则填充 (L - 缺失位数) 长度的 A中当前枚举位置前(L - 缺失位数)的值加 1

用一个例子来验证思路，假如输入数据是 0000。

1. 直接补 1，得到最小的 N 为 10000。
2. 10000是5位数，L=5。计算1-4位的值，再加上第5位的值，减去 N 在 A 的偏移量 -1，就是位置。
3. 位置 +1 得到答案

每个长度为 L 的数在 S 中消耗的位数为 L * 9 * 10^(L-1)，可以得出

第五位的偏移量为 5*(10000-10000)=0，位置为 9+180+2700+36000+0-(-1)=38890，+1 得到答案 38891。

想法三

按照思路二，写成了新的代码。但是还不能通过全部的点。A 长度最多为 200，这个范围肯定是超过最大的整型了，需要高精度。

如果是以前竞赛的时候，时间不够了，估计用 Int64 整完想法二的代码，差不多这个题就这么提交了。但是，现在，是为了学习 Go 来做题的，Go 有处理大数据的 math/big！

将想法二的代码，涉及到计算的地方都使用现成的big.Int相关的方法替换，出来的结果就是能支持 200 位 N 的结果计算的正确代码。

几个测试点

代码

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

/*
ZHOU Cheng <c.zhou@live.com>
2019-5-18 22:48:21
*/
package main

import (
    "fmt"
    "math/big"
    "regexp"
    "strings"
)

var zero = big.NewInt(0)
var one = big.NewInt(1)
var ten = big.NewInt(10)

func getBigInt(s string) *big.Int {
    i, _ := new(big.Int).SetString(s, 10)
    return i
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}

// 获取填充 0 的长度为 n 的数值字符串
func getZeroString(value *big.Int, n int) string {
    s := value.String()
    for n = n - len(s); n > 0; n-- {
        s = "0" + s
    }
    return s
}

// 长度为 bit，在 a 中偏移量为 offset 的 num 是否符合条件。不符合返回 zero
func validateBitAndOffset(bit, offset int, a string) *big.Int {
    // 零开头的，不符合要求，直接返回 zero
    if strings.HasPrefix(a[offset:], "0") {
        return zero
    }

    // 当目前的长度少于期望的长度，使用前面的值来填充
    if offset+bit > len(a) {
        missBit := offset + bit - len(a)
        prevStr := a[offset-missBit : offset]
        p := new(big.Int)
        // 全 9 特殊处理，填充 0
        if match, _ := regexp.MatchString("^9*$", prevStr); match {
            p.SetInt64(0)
        } else {
            p.SetString(prevStr, 10)
            p.Add(p, one)
        }
        a += getZeroString(p, missBit)
    }

    num := getBigInt(a[offset : offset+bit])
    n := new(big.Int)
    var left, right int
    // 检测左边是否满足条件
    n.Sub(num, one)
    right = offset
    for right > 0 {
        if n.Cmp(one) < 0 {
            return zero
        }
        nStr := n.String()
        left = max(0, right-len(nStr))
        if a[left:right] != nStr[len(nStr)-(right-left):] {
            return zero
        }
        right -= len(nStr)
        n.Sub(n, one)
    }
    // 检测右边是否满足条件
    n.Add(num, one)
    left = offset + bit
    length := len(a)
    for left < length {
        nStr := n.String()
        right = min(length, left+len(nStr))
        if a[left:right] != nStr[0:right-left] {
            return zero
        }
        left += len(nStr)
        n.Add(n, one)
    }
    return num
}

// 计算数字出现的位置
func getNumberPosition(num *big.Int, offset int) *big.Int {
    result := big.NewInt(0 - int64(offset))
    if num.Cmp(ten) < 0 {
        result.Add(result, num)
        return result
    }

    length := len(num.String())
    start := big.NewInt(1)
    for i := 1; i < length; i++ {
        count := big.NewInt(9)
        count.Mul(count, start)
        count.Mul(count, big.NewInt(int64(i)))
        result.Add(result, count)
        start.Mul(start, ten)
    }

    start.Sub(num, start)
    curr := big.NewInt(int64(length))
    curr.Mul(curr, start)
    curr.Add(curr, big.NewInt(1))
    result.Add(result, curr)
    return result
}

func main() {
    var a string
    _, _ = fmt.Scanf("%s", &a)

    // 全 0 特殊处理
    if match, _ := regexp.MatchString("^0*$", a); match {
        num := getBigInt("1" + a)
        fmt.Println(getNumberPosition(num, -1))
        return
    }

    best := big.NewInt(0)
    for i, j := 1, len(a); i <= j; i++ {
        for offset := i - 1; offset >= 0; offset-- {
            num := validateBitAndOffset(i, offset, a)
            if num.Cmp(zero) > 0 {
                curr := getNumberPosition(num, offset)
                if best.Cmp(zero) == 0 || best.Cmp(curr) > 0 {
                    best = curr
                }
            }
        }
        // 当前位数寻找到最优结果，打印并结束循环
        if best.Cmp(zero) > 0 {
            fmt.Println(best.String())
            break
        }
    }
}