IT博客-魔のkyo的工作室

Blog迁移公告

魔のkyo — Tue, 12 Apr 2022 07:10:00 GMT

个人博客已迁移到：www.kyo86.com
新博文将发布在新地址，旧博文会陆续迁移至新地址

魔のkyo 2022-04-12 15:10 发表评论

docker常用命令

魔のkyo — Mon, 28 Mar 2022 08:57:00 GMT

启动一个容器
docker run -h 容器主机名 --name 容器名 -Pdit 镜像名
启动一个新的bash进行管理
docker exec -it 容器名 bash

其他常用命令

	镜像	容器
创建	build -t/commit	create/run
删除	rmi	rm
重命名	tag+rmi	rename
查看列表	images	ps/ps -a/ps -l -q
运行状态	stats	top
查看日志	history	logs
拉取	pull
推送	push
查找	search
查看容器信息		inspect
发信号		kill
附到主进程		attach
执行新进程		exec

docker run 常用参数
-d # 后台运行
-it # 打开STDIN，支持终端登录
--name <容器名>
-h <主机名>
-P # 随机映射所有配置在EXPOSE中的端口
-p [<宿主端口>:]<容器端口> # 指定映射一个端口，不指定宿主端口时表示随机
-v <宿主路径>:<容器路径>[:ro|:rw] # 卷映射，容器路径不存在时自动创建，ro表示只读，默认是rw表示读写
--volumes-from <容器名> # 指定容器里的所有卷都将加入到新创建的容器里
--network <网络名> # 默认bridge，同一个非默认网络下的容器可以使用主机名相互访问
--link <容器名>:<主机名> # 在新创建的容器里可以通过主机名访问另一个运行中的容器
--add-host <主机名>: # 指定主机名解析添加到/etc/hosts文件
--env <环境变量名>=<环境变量值> # 设置环境变量，-e 选项可以重复多次
--env-file <环境变量文件> # 指定环境变量文件，换行符分割
--user <用户名>
--workdir <工作目录>
--mac-address="xx:xx:xx:xx:xx:xx" # 指定MAC地址
关于资源限制的参数：
--cpuset-cpus="1,3" 限制在核1、3上运行
--memory=1G 限制内存最大使用1G
--device-read-bps /dev/sdd:40mb 限制读取sdd的速度最大40mb
--device-write-bps /dev/sdd:30mb 限制写入sdd的速度最大30mb
（机械硬盘读写速度是60-80MB，固态硬盘读写速度是130~300MB，都是写慢读快）

docker network 常用参数
create 创建一个新的网络
connect 向一个网络中添加一个容器
disconnect 从一个网络中移除一个容器
inspect 查看指定网络详细信息
ls 查看网络列表
rm 删除指定网络
prune 删除所有未使用的网络

docker inspect
--format format的用法比较复杂，用3个逐级深入的例子演示

docker_id 查看容器的Id
docker inspect --format='{{.Id}}' 容器名

docker_ip 查看容器在所有网络中分配的所有的ip
docker inspect --format='{{range .NetworkSettings.Networks}}{{println .IPAddress}}{{end}}' 容器名

docker_port 查看容器所有的端口映射情况，用docker inspect实现 docker port命令
docker inspect --format='{{range $p, $conf := .NetworkSettings.Ports}}{{range $conf}}{{$p}} -> {{.HostIp}}:{{.HostPort}}{{println}}{{end}}{{end}}' 容器名

魔のkyo 2022-03-28 16:57 发表评论

Linux中查看文件创建时间的脚本

魔のkyo — Fri, 25 Mar 2022 11:52:00 GMT

#!/bin/bash

[ $# -ne 1 ] && echo "Usage:     $0 {FILENAME}" && exit 1

INODE=`ls -i $1 |awk '{print $1}'`
FILENAME=$1

#如果传入参数带/，则获取这个传入参数的目录路径并进入目录
`echo $FILENAME |grep / 1> /dev/null`  &&  { FPWD=${FILENAME%/*};FPWD=${FPWD:=/};cd ${FPWD};FPWD=`pwd`; }  || FPWD=`pwd`

array=(`echo ${FPWD} | sed 's@/@ @g'`)
array_length=${#array[@]}

for ((i=${array_length};i>=0;i--))
do
  unset array[$i]
  SUBPWD=`echo " "${array[@]} | sed 's@ @/@g'`
  DISK=`df -h |grep ${SUBPWD}$ |awk '{print $1}'`
  [[ -n $DISK ]] && break
done

#不是ext4就退出
[[ "`mount |grep ${DISK} |awk '{print $5}'`" != "ext4" ]] && { echo ${DISK} is not mount on type ext4! Only ext4 file system support!;exit 2; }

debugfs -R "stat <${INODE}>" ${DISK}

魔のkyo 2022-03-25 19:52 发表评论

在Shell脚本输入密码

魔のkyo — Mon, 21 Feb 2022 10:44:00 GMT

首先在Shell脚本中使用sudo不是一个好主意。
可以考虑的替代方案有，
1. 在脚本中去掉sudo，而要求在运行脚本时使用sudo。
2. 如果是任务计划，考虑配置在root用户下。
如果确实确定要在Shell中sudo，可以使用如下方式

echo '密码' | sudo -S 命令

如果是通过SSH建立远程连接，考虑用SSH密钥登录。搜索SSH秘钥，ssh-keygen，ssh-copy-id
如果是其他程序需要输入密码，可以用expect工具
expect在shell脚本中的用法

#!/bin/bash

passwd='123456'

/usr/bin/expect <<-EOF

set time 10
spawn ssh saneri@192.168.56.103 df -Th
expect {
"*yes/no" { send "yes\r"; exp_continue }
"*password:" { send "$passwd\r" }
}
expect eof
EOF

魔のkyo 2022-02-21 18:44 发表评论

迁移git项目

魔のkyo — Tue, 08 Feb 2022 10:42:00 GMT

git clone --mirror <原地址> # 会取得项目名.git 的目录，里面是包含了提交历史、分支等的完整项目库
cd <项目目录>
git remote set-url --push origin <新地址> # 新地址是提前创建好的（空白的）新项目库路径
git push --mirror

告知其他合作开发者修改远程库路径到新地址
git remote set-url origin <新地址>
git remote -v # 可以查看当前设置的地址

魔のkyo 2022-02-08 18:42 发表评论

pandas df.to_excel 设置列宽遇到 AttributeError: 'Worksheet' object has no attribute 'column_dimensions'

魔のkyo — Thu, 23 Dec 2021 02:11:00 GMT

df.to_excel底层默认优先用的是xlsxwriter，sheet对象的类型是 xlsxwriter.worksheet.Worksheet，它没有column_dimensions属性。
可以通过在创建ExcelWriter的时候指定engine="openpyxl"让底层使用openpyxl，sheet对象的类型会变成openpyxl.worksheet.worksheet.Worksheet，它是有column_dimensions属性的。
网上的代码没有指定engine仍然可以工作可能是因为他们的环境没有安装xlwt只安装了openpyxl。

with pd.ExcelWriter(f"./净值列表{datetime.datetime.now().date()} ({i}).xlsx",
                    engine="openpyxl",
                    date_format="YYYY-MM-DD",
                    datetime_format="YYYY-MM-DD HH:MM:SS"
                    ) as writer:
    df.to_excel(writer)
    sheet = writer.sheets["Sheet1"]
    # 设置列宽
    sheet.column_dimensions['A'].width = 12.5
    # 设置行高
    sheet.row_dimensions[1].height = 72
    # 设置表头（第一行）自动换行
    r = sheet[1]
    for c in r:
        c.alignment = openpyxl.styles.Alignment(wrapText=True)
    # 设置表体数字格式显示4位小数
    for i, r in enumerate(sheet):
        for j, c in enumerate(r):
            if i != 0 and j != 0:
                c.number_format = "0.0000"

魔のkyo 2021-12-23 10:11 发表评论

用PyArrow序列化和反序列化pd.DataFrame

魔のkyo — Thu, 11 Nov 2021 09:27:00 GMT

import pyarrow as pa
import zlib

class PyArrowEncoder:
    def __init__(self, compress_level=-1):
        self.compress_level = compress_level

    def serialize(self, df):
        table = pa.Table.from_pandas(df)
        sink = pa.BufferOutputStream()
        with pa.ipc.new_stream(sink, table.schema) as writer:
            writer.write_table(table)
        buf = sink.getvalue()
        pybytes = buf.to_pybytes()
        return zlib.compress(pybytes, self.compress_level)

    def deserialize(self, data):
        with pa.ipc.open_stream(zlib.decompress(data)) as reader:
            df = reader.read_pandas()
            return df

魔のkyo 2021-11-11 17:27 发表评论

记一次Linux因硬盘设备编号错位挂载失败引起启动失败的解决过程

魔のkyo — Mon, 25 Oct 2021 05:54:00 GMT

问题描述
周末办公楼电力系统维护停电3小时，服务器关机，电力恢复后服务器启动失败，现象是启动报错，提示让输入密码进入紧急模式。
看到主要的错误描述是：
CIFS VFS: ioctl error in smb2_get_dfs_refer rc=-5
怀疑和mount有关。
输入密码进入紧急模式，输入命令mount -a，即根据配置文件/etc/fstab进行挂载(正常启动时也是根据此文件进行挂载)
其中/etc/fstab的内容如下

省略若干
/dev/md126p1 /data ext4 defaults 0 0
/dev/sdd1 /data2 ext4 defaults 0 0
省略若干

执行后看到了具体的挂载错误条目是找不到设备 /dev/sdd1
使用命令
fdisk -l
可以看到存在/dev/sdd和/dev/sdd1

Disk /dev/sdd: 3.7 TiB, 4000787030016 bytes, 7814037168 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: gpt
Disk identifier: 737D5D12-456A-414A-86DC-0F8279EDA29B

Device Start End Sectors Size Type
/dev/sdd1 2048 4294969343 4294967296 2T Linux filesystem

使用lsblk，看到

NAME        MAJ:MIN RM   SIZE RO TYPE  MOUNTPOINT
loop0         7:0    0  99.4M  1 loop  /snap/core/11993
loop1         7:1    0  99.5M  1 loop  /snap/core/11798
sda           8:0    0 931.5G  0 disk
├─sda1        8:1    0   512M  0 part
└─sda2        8:2    0   931G  0 part
sdb           8:16   0   1.8T  0 disk
├─sdb1        8:17   0   512M  0 part  /boot/efi
└─sdb2        8:18   0   1.8T  0 part  /
sdc           8:32   0   1.8T  0 disk
└─sdc1        8:33   0   1.8T  0 part  /data2
sdd           8:48   0   3.7T  0 disk
└─md126       9:126  0   3.7T  0 raid0
  └─md126p1 259:0    0     2T  0 md    /data
sr0          11:0    1  1024M  0 rom

发现sdd下面是md126 md126p1，想起来有一块盘做成了raid0，挂载时不能按照sda、sdb、sdc的命名方式挂载，需要用/dev/md126p1，但这不是问题，因为fstab文件中确实使用了/dev/md126p1，但不应该挂载/dev/sdd1了啊，其实是这次重启之后原来的sdd1变成了现在的sdc1，可能因为上次的磁盘是热插入的，重启之后根据插入口的顺序重新分配了设备名，把fstab文件中的sdd1改成sdc1，重新mount -a成功，进入/data2查看文件，确实是之前sdd1上的。

重启会重新分配设备名导致挂载失败的问题，根据linux下磁盘sda,Linux下磁盘设备文件（sda,sdb,sdc….）变化问题_林声飘扬的博客-CSDN博客这篇博文的说法，目前没有办法直接解决，但是可以通过指定id和uuid的方式挂载而不使用sda、sdb这种名称来绕过这个问题
使用

ls -la /dev/disk/by-id

ls -la /dev/disk/by-uuid

可以看到这些id和uuid就是指向sda、sdb之类的软连接，而id和uuid每次启动是固定的，那么这些软连接应该是在启动过程中生成的。
最后保险起见，我将fstab文件中的挂载设备改成了id表示

# /dev/sdc1 /data2 ext4 defaults 0 0
/dev/disk/by-id/ata-ST2000NM0055-1V4104_ZC20W9TN-part1 /data2 ext4 defaults 0 0

魔のkyo 2021-10-25 13:54 发表评论

Python实现的瓶颈分析计时

魔のkyo — Fri, 08 Oct 2021 02:45:00 GMT

import time

class PerfCounter():
    def get_time(self):
        return time.perf_counter()

class Node:
    clock = None

    def __init__(self, name, parent):
        # 带父节点的孩子兄弟树结构字段
        self.parent = parent
        self.child = None
        self.sibling = None

        self.name = name
        self.total_calls = 0
        self.recursion_counter = 0
        self.total_ticks = 0

    def __del__(self):
        if self.child:
            del self.child
            self.child = None
        if self.sibling:
            del self.sibling
            self.sibling = None

    def get_child(self, name):
        child = self.child
        while child:
            if child.name == name:
                return child
            child = child.sibling

        # 如果没有找到就新建结点，并插入作为第一个孩子
        node = Node(name=name, parent=self)
        node.sibling = self.child
        self.child = node
        return node

    def reset(self):
        self.total_calls = 0
        self.total_ticks = 0
        if self.child:
            self.child.reset()
        if self.sibling:
            self.sibling.reset()

    def enter(self):
        self.total_calls += 1
        self.recursion_counter += 1
        if self.recursion_counter == 1:
            self.start_tick = self.clock.get_time()

    def exit(self):
        self.recursion_counter -= 1
        if self.recursion_counter == 0 and self.total_calls != 0:
            tick = self.clock.get_time() - self.start_tick;
            self.total_ticks += tick;
        return (self.recursion_counter == 0)

class Profiler:
    def __init__(self, clock=None):
        Node.clock = clock or PerfCounter()
        self.root = Node("", None)
        self.current_node = self.root
        self.root.enter()

    def __del__(self):
        if self.root:
            del self.root

    def set_clock(self, clock):
        Node.clock = clock

    def reset(self):
        self.root.reset()
        self.root.enter()

    def enter(self, name):
        if name != self.current_node.name:
            self.current_node = self.current_node.get_child(name)
        self.current_node.enter()

    def exit(self):
        if self.current_node.exit():
            self.current_node = self.current_node.parent

profiler = Profiler()

def time_me(fn, profiler=profiler):
    def wrapper(*args, **kw):
        profiler.enter(fn.__name__)
        ret = fn(*args, **kw)
        profiler.exit()
        return ret
    return wrapper

def enter_region(name, profiler=profiler):
    profiler.enter(name)

def exit_region(profiler=profiler):
    profiler.exit()

def dfs(node, depth, cb):
    cb(node, depth)
    node = node.child
    while node:
        dfs(node, depth+1, cb)
        node = node.sibling

def travel(cb, profiler=profiler):
    if profiler.root:
        profiler.root.exit()
    dfs(profiler.root, 0, cb)

def view(node, depth):
    print("{space}[{name}] {calls} times {ticks:.3f} seconds {rate:.2f}%".format(
        space=" "*depth, name=node.name, calls=node.total_calls, ticks=node.total_ticks, rate=node.total_ticks*100/(node.parent and node.parent.total_ticks or node.total_ticks) ))

if __name__ == '__main__':
    @time_me
    def func1():
        time.sleep(0.5)
        func3()

    @time_me
    def func2(n):
        if n <= 2:
            func3()
            return 1
        else:
            return func2(n-1) + func2(n-2)

    @time_me
    def func3():
        enter_region("func3 sleep")
        time.sleep(0.1)
        exit_region()

    func1()
    for i in range(1, 5):
        print(func2(i))
    func1()
    travel(view)

魔のkyo 2021-10-08 10:45 发表评论

解决matplotlib中文乱码

魔のkyo — Wed, 25 Aug 2021 09:25:00 GMT

import matplotlib.pyplot as plt
plt.rcParams["font.sans-serif"]=["SimHei"]
plt.rcParams["axes.unicode_minus"]=False

魔のkyo 2021-08-25 17:25 发表评论

SSH Tunnel

魔のkyo — Thu, 18 Feb 2021 11:02:00 GMT

SSH Tunnel解决的问题是让原本不能访问的端口（通常是因为在不同局域网）可以访问。

假设A要访问D:6379，A、D在不同局域网，最简单方法是在D所在的局域网网关上配置端口映射把D:6379映射到公网，但是很多时候出于某些因素（例如：安全考量、没有配置网关的权限、服务本身配置了只允许本地访问），不希望或无法通过把D:6379映射到公网解决，就可以考虑使用SSH Tunnel。

情形1：D所在的局域网有主机C的22端口是被映射到公网的，不妨假设映射成了X:30022，X是C和D所在局域网网关在公网的IP地址，那么可以在主机A上通过命令

HostA$ ssh -L 36379:D:6379 root@X -p 30022

把D:6379映射成了A:36379，特别情况C和D是同一台主机，D可以写成localhost。

情形2：A所在的局域网有主机B的22端口是被映射到公网的，不妨假设映射成了X:30022，X是A和B所在局域网网关在公网的IP地址，那么可以在主机D上通过命令

HostD$ ssh -g -R 36379:D:6379 root@X -p 30022

把D:6379映射成了B:36379，而A和B是同一局域网的，因此A可以访问到B:36379。

按理说上面的命令加了-g参数，B:36379应该被绑定在0.0.0.0:36379，但实际测试发现绑定在了127.0.0.1:36379，导致无法在A上访问，原因暂时未知（确定不是因为redis配置了保护模式），不过可以通过类似情形1的方式再把B:36379映射成A:36379，这样A就可以访问了。

HostA$ ssh -L 36379:localhost:36379 root@B

情形3：A和D所在局域网都没有主机的ssh端口被映射到公网，但我有另一台具有公网IP的主机，不妨假设为X开启着22端口，类似情形2通过命令

HostD$ ssh -R 36379:D:6379 root@X

HostA$ ssh -L 36379:localhost:36379 root@X

之后让A访问A:36379即可。

通过命令建立SSH Tunnel之后会登录到作为跳板的机器，通常我们是不需要使用这个控制台的，因此可以通过-f参数让ssh在后台运行，需要关闭tunnel时直接杀死进程。

其他常用选项：

C表示压缩数据传输

f表示后台用户验证,这个选项很有用,没有shell的不可登陆账号也能使用.

N表示不执行脚本或命令

g表示允许远程主机连接转发端口

例如情形1中的命令可以写成

ssh -CfNg -L 36379:D:6379 root@X -p 30022

通过

ps -ef|grep ssh -CfNg

可以查看打开的tunnel。

当网络不稳定时，ssh tunnel会自动断开，如果是前台的运行方式，会自动退出远程控制台，回到本地控制台提示符，如果是后台运行方式，进程会自动结束，这时候可以使用autossh工具来帮助自动重连。

只需要把ssh命令中的ssh换成autossh -M 

例如情形1中的命令可以写成

autossh -M 46379 -CfNg -L 36379:D:6379 root@X -p 30022

-M 后面的端口号是用来监视连接状态的，允许指定为0，这里指定为0是否可以正常监视重连以及如何监视有待研究。

另外autossh不支持输入密码，可以配合expect脚本自动输入密码或者通过密钥登录，更推荐使用密钥方式。

先在本地生成密钥

ssh-keygen -t rsa

会询问将密钥放在何处，默认即可。然后是输入密码，留空(否则你登录不仅需要私钥还要输入密码)。

完成后在~/.ssh目录下会生成另个文件id_rsa和id_rsa.pub，一个私钥一个公钥。

然后将公钥写入远程用户家目录下的~/.ssh/authorized_keys文件中，通过ssh-copy-id命令可以帮我们实现这一操作（相当于把公钥复制过去再追加到authorized_keys的尾部）

ssh-copy-id [-p SSH端口默认22] [user@]hostname

参考：

https://blog.csdn.net/wxqee/article/details/49234595

https://www.cnblogs.com/youxin/p/5220916.html

https://blog.csdn.net/wesleyflagon/article/details/85304336

魔のkyo 2021-02-18 19:02 发表评论

Linux限制目录大小

魔のkyo — Tue, 02 Feb 2021 07:36:00 GMT

需求情景：存放日志或接收并存储数据的目录，为了防止程序出错时疯狂写日志硬盘被日志或存储的数据塞满。

原理，创建一个固定大小的img文件，映射成一个目录

# 创建Log.img大小1G
dd if=/dev/zero of=./Log.img bs=1M count=1024
# 格式化 ext4
mkfs.ext4 ./Log.img
# 创建挂载目录
mkdir ./Log
# 挂载
sudo mount -o loop ./Log.img ./Log
# 修改权限
sudo chown daimingzhuang:daimingzhuang ./Log

魔のkyo 2021-02-02 15:36 发表评论

Vue.js前端跨域请求代理设置方法

魔のkyo — Tue, 02 Feb 2021 06:59:00 GMT

开发环境下通过 config/index.js 配置代理

// see http://vuejs-templates.github.io/webpack for documentation.
var path = require('path')

module.exports = {
    build: {
        env: require('./prod.env'),
        index: path.resolve(__dirname, '../dist/index.html'),
        assetsRoot: path.resolve(__dirname, '../dist'),
        assetsSubDirectory: 'static',
        assetsPublicPath: '/view/',
        productionSourceMap: true,
        // Gzip off by default as many popular static hosts such as
        // Surge or Netlify already gzip all static assets for you.
        // Before setting to `true`, make sure to:
        // npm install --save-dev compression-webpack-plugin
        productionGzip: false,
        productionGzipExtensions: ['js', 'css'],
        // Run the build command with an extra argument to
        // View the bundle analyzer report after build finishes:
        // `npm run build --report`
        // Set to `true` or `false` to always turn it on or off
        bundleAnalyzerReport: process.env.npm_config_report
    },
    dev: {
        env: require('./dev.env'),
        port: 8080,
        autoOpenBrowser: true,
        assetsSubDirectory: 'static',
        assetsPublicPath: '/',
        proxyTable: {
            '/api': {
                target: "http://backend-server:30101", // 测试环境下配置端口转发
                changeOrigin: true,
                pathRewrite: {
                    "^/api": "", // 重写路径，去掉前缀api
                }
            }
        },
        // CSS Sourcemaps off by default because relative paths are "buggy"
        // with this option, according to the CSS-Loader README
        // (https://github.com/webpack/css-loader#sourcemaps)
        // In our experience, they generally work as expected,
        // just be aware of this issue when enabling this option.
        cssSourceMap: false
    }
}

生产环境下通过前端所在服务器上的Nginx配置代理在
/etc/nginx/sites-enabled/default
中添加 location ^~/api/ 对应的块

server {

    #

    location / {
        # First attempt to serve request as file, then
        # as directory, then fall back to displaying a 404.
        try_files $uri $uri/ =404;
    }

    location ^~/api/ {
        proxy_set_header Host $host;
        proxy_set_header  X-Real-IP        $remote_addr;
        proxy_set_header  X-Forwarded-For  $proxy_add_x_forwarded_for;
        proxy_set_header X-NginX-Proxy true;

        rewrite ^/api/(.*)$ /$1 break;
        proxy_pass http://backend-server:30101/;
    }

    #
}

检验配置文件是否正确

nginx -t

重启（重新读取配置）

nginx -s reload

或 serivice nginx restart

当我们在前端通过axios请求地址 /api/Token 时，就会被转发到 http://backend-server:30101/Token

魔のkyo 2021-02-02 14:59 发表评论

Ubuntu下使用PPTPD搭建VPN

魔のkyo — Mon, 01 Feb 2021 07:17:00 GMT

Ubuntu PPTP服务器

参考：https://blog.csdn.net/sanve/article/details/80882731

安装

apt install pptpd 

配置IP

vim /etc/pptpd.conf 

解开这3处的注释并修改相应配置

#bcrelay eth1 
#localip 192.168.10.1
#remoteip 192.168.10.234-238,192.168.10.245

bcrelay的意思我理解是来自虚拟局域网的广播要从哪个物理网卡转发出去

localip的意思本机是VPN服务器的IP地址

remoteip的意思是当有远程VPN客户端连接上来时被分配的IP段

我认为应该把虚拟局域网的网段和物理局域网分开，而且localip和remoteip应该在同一个网段，网上有localip和remoteip不应该在同一个网段的说法我并不认同。

配置DNS

vim /etc/ppp/pptpd-options 

找到ms-dns解开注释并修改相应配置

ms-dns 114.114.114.114
ms-dns 8.8.8.8

配置用户名密码

vim /etc/ppp/chap-secrets 

# Secrets for authentication using CHAP
# client           server     secret                  IP addresses
   pptpd                   *

修改配置后重启PPTP服务器

service pptpd restart 

打开IPv4转发

vim /etc/sysctl.conf 

找到并修改或添加

net.ipv4.ip_forward = 1 

使配置生效

sysctl -p service
procps restart 

在需要通过VPN访问的机器上添加指向VPN网段的路由的下一跳地址是VPN服务器

ip route add 192.168.10.0/24 via 192.168.1.99 

192.168.1.99 是VPN Server的内网IP地址，只有它知道VPN所在网段的的IP地址应该如何发送。

或者直接把静态路由设置在网关上，设置下一跳地址为VPN服务器的IP，这样整个局域网都是可以通过VPN正常访问的。

Ubuntu PPTP客户端

参考：https://www.jianshu.com/p/1680c721f397 http://www.linuxfly.org/post/641/

pptpsetup --create 连接名 --server VPN服务器地址 --username 用户名 --password 密码 --encrypt 

启动VPN连接

pon 连接名

关闭VPN连接

poff 连接名

查看路由表

route -n

添加路由，将通过VPN接入的物理局域网网段路由指定通过ppp0网口转发

route add -net 192.168.1.0 netmask 255.255.255.0 dev ppp0 

每次重连后路由会丢失，需要重新配置，可以用下面的方法在ppp0 up时自动添加路由

pptp连接时自启动添加路由

参考：https://blog.csdn.net/qq_27434019/article/details/102920504

vim /etc/ppp/peers/连接名 

增加ipparam一行

ipparam 连接名 

======下面这步似乎不必要，不清楚作用======

vim /etc/network/interfaces 

增加

auto tunnel
iface tunnel inet ppp
provider 连接名

======================================

新建脚本文件并修改权限

touch /etc/ppp/ip-up.d/连接名
chmod a+x /etc/ppp/ip-up.d/连接名

编辑脚本

vim /etc/ppp/ip-up.d/连接名 

在脚本中加入添加路由的语句

route add -net 192.168.1.0 netmask 255.255.255.0 dev ppp0

可以poff 再 pon 再 route -n 看看路由是否自动添加

魔のkyo 2021-02-01 15:17 发表评论

记一次硬盘IO占用过高排查

魔のkyo — Fri, 04 Dec 2020 04:00:00 GMT

通过sar -d -p 3命令发现硬盘占用率比较高

通过 iotop命令发现主要是被一个名为  [jbd2/sda2-8] 的进程占用

网上说法是 (13条消息) 性能分析之IO分析-jbd2引起的IO高_hualusiyu的专栏-CSDN博客

jbd2的全称是journaling block driver 。这个进程实现的是文件系统的日志功能，磁盘使用日志功能来保证数据的完整性。这个需要评估一下安全和性能哪个更重要，解决方案是升级内核或者牺牲完整性来换性能。

差点被误导。

而使用命令 atop -d 发现其实是 snapd 占用

和这篇帖子情况一样 snapd持续运行，引起jbd2/sda2-8持续访问硬盘，占用大量io - Ubuntu中文论坛

snapd持续运行，引起jbd2/sda2-8持续访问硬盘，占用大量io

#6

帖子 由 sffred » 2020-06-06 16:04

我最终解决这个问题的方式是卸载snapd。反正我也用不着

了解到snapd是ubuntu预装的一个软件包管理工具。

使用snap list发现只有一个core，也就是我没有基于snap安装过软件包。

通过 service snapd stop 关闭snapd，在通过sar -d -p 3观察硬盘占用，已经完全正常

至此确定是由snapd引发.

通过service snapd start 启动snapd，观察硬盘占用，先是再次上升数十秒后回到了正常。

如果下次再出现占用过高准备禁用或卸载snap。

禁用 systemctl disable snapd.service 卸载 apt purge snapd 

魔のkyo 2020-12-04 12:00 发表评论

Python实现滚动数组，Python特殊方法的使用，Python运算符重载

魔のkyo — Mon, 07 Sep 2020 07:48:00 GMT

# -*- coding: utf-8 -*-

class RollArray:
    class Iterator:
        def __init__(self, subject):
            self.subject = subject
            self.start = self.subject.idx
            self.i = 0

        def __next__(self):
            while self.i < self.subject.capability:
                if self.start + self.i in self.subject:
                    o = self.subject[self.start + self.i]
                    self.i += 1
                    return o
                else:
                    self.i += 1
            raise StopIteration()

    def __init__(self, capability, items=[]):
        self.data = [None] * capability
        self.used = [False] * capability
        self.idx = 0
        self.capability = capability
        for e in items:
            self.append(e)

    def append(self, obj):
        self.data[self.idx] = obj
        self.used[self.idx] = True
        self.idx = (self.idx + 1) % 10

    # 重载 for e in x:
    def __iter__(self):
        return RollArray.Iterator(self)

    # 重载 [] const
    def __getitem__(self, i):
        if self.used[i%self.capability]:
            return self.data[i%self.capability]
        else:
            raise IndexError()

    # 重载 []
    def __setitem__(self, i, v):
        self.data[i%self.capability] = v
        self.used[i%self.capability] = True
        return v

    # 重载 del x[]
    def __delitem__(self, i):
        self.used[i%self.capability] = False

    # 重载 if e in x:
    def __contains__(self, i):
        return self.used[i%self.capability]

    def tolist(self):
        l = []
        for e in self:
            l.append(e)
        return l

    def __repr__(self):
        return f"{self.__class__.__name__}({self.capability}, items={self.tolist()})"

if __name__ == '__main__':
    arr = RollArray(10, range(5))
    del arr[3]
    print(arr)

    for i in range(5, 11):
        arr.append(i)

    print(arr)

    arr[11] = 11
    print(arr)

    for e in arr:
        print(e)

魔のkyo 2020-09-07 15:48 发表评论

通用的插入更新(Upsert)实现

魔のkyo — Mon, 31 Aug 2020 10:31:00 GMT

# -*- coding: utf-8 -*-

import math
import datetime
import numpy as np
import pandas as pd
import sqlalchemy

'''
engine: SQLAlchemy Engine
buffer_size: 缓存条目数，当缓存满时自动flush
update_on_duplicate: 当唯一键重复时的行为，默认是update，设置为False表示不更新，即忽略插入失败。
'''
def create_upsert_handler(engine, buffer_size=5000, update_on_duplicate=True):
    if engine.dialect.name.lower().find("mysql") != -1:
        return MySQLUpsertHandler(engine, buffer_size, update_on_duplicate)
    elif engine.dialect.name.lower().find("postgresql") != -1:
        return PSQLUpsertHandler(engine, buffer_size, update_on_duplicate)
    else:
        print(f"没有为{engine.dialect.name}实现特殊的Upsert，使用默认版本，请确认可以正常工作，建议特化一个专门版本")
        return UpsertHandlerBase(engine, buffer_size, update_on_duplicate)

def is_duplicate_key(e):
    for T in UpsertHandlerBase.__subclasses__():
        if T.is_duplicate_key(e):
            return True
    return UpsertHandlerBase.is_duplicate_key(e)

'''
class UpsertHandler:

    # 传入的engine类型应该和使用的UpsertHandler支持的数据库类型相匹配
    # buffer_size表示插入或更新数据缓存到多少才flush(即向数据库插入或更新)，None表示在析构时flush，0表示不缓存
    # update_on_duplicate当唯一键重复时的行为，默认是update，设置为False表示不更新，即忽略插入失败。
    def __init__(self, engine, buffer_size=None, update_on_duplicate=True):
        pass

    # tablename为数据库表名
    # pk为主键的元组，可以不是真正的表主键，但是可以用来判重决定insert还是update，例如('exchange_id', 'trade_id')
    # data为单条数据，dict的形式，例如{'exchange_id': 'DCE', 'trade_id': '  1', 'price': 1.2, 'volume': 1}
    def upsert(self, tablename, pk, data):
        pass

    # 立即把缓冲器的数据推到数据库，会在buffer_size满了或者析构时自动调用，也可以手动调用
    def flush(self):
        pass
'''
class UpsertHandlerBase:
    def __init__(self, engine, buffer_size=None, update_on_duplicate=True):
        self.engine = engine
        self.tablename2pk = {}
        self.tablename2datas = {}
        self.buffer_size = buffer_size
        self.update_on_duplicate = update_on_duplicate

    def __del__(self):
        self.flush()

    def flush(self):
        for (tablename, pk) in self.tablename2pk.items():
            datas = self.tablename2datas[tablename]
            if len(datas) > 0:
                with self.engine.connect() as conn:
                    self._flush(conn, tablename, pk, datas)
                self.tablename2datas[tablename] = []

    def _flush(self, conn, tablename, pk, datas):
        columns = datas[0].keys()
        sql = f"""INSERT INTO {tablename}({", ".join(columns)}) VALUES\n"""
        for i, data in enumerate(datas):
            if i != len(datas) - 1:
                sql += f"""  ({self._format_values(data.values())}),\n"""
            else:
                sql += f"""  ({self._format_values(data.values())});\n"""
        try:
            conn.execute(sql)
        except sqlalchemy.exc.IntegrityError as e:
            if self.is_duplicate_key(e):
                # 插入遇到重复KEY
                if len(datas) <= 500:
                    for data in datas:
                        self.upsert_one(conn, tablename, pk, data)
                else:
                    l = len(datas)
                    p = int(l // 2)
                    self._flush(conn, tablename, pk, datas[:p])
                    self._flush(conn, tablename, pk, datas[p:])
            else:
                raise e

    def upsert_one(self, conn, tablename, pk, data):
        r = None
        if self.update_on_duplicate:
            update_str = self._format_update_values(pk, data)
        if self.update_on_duplicate and update_str.strip():
            r = conn.execute(f"UPDATE {tablename} SET {update_str} WHERE {self._format_update_conditions(pk, data)}")
        if not r or r.rowcount == 0:
            try:
                r = conn.execute(f"INSERT INTO {tablename}({', '.join(data.keys())}) VALUES({self._format_values(data.values())})")
            except sqlalchemy.exc.IntegrityError as e:
                if self.is_duplicate_key(e):
                    pass
                else:
                    raise e

    @staticmethod
    def is_duplicate_key(e):
        if type(e) != sqlalchemy.exc.IntegrityError:
            return False
        return (str(e.orig).lower().find("duplicate") != -1)

    def _isinf(self, x):
        return x>=9223372036854775807 or x<=-9223372036854775808

    def _format_value(self, v):
        if v is None:
            return "null"
        elif type(v) == float:
            if math.isnan(v) or math.isinf(v) or self._isinf(v):
                return "null"
            else:
                return f"{v}"
        elif type(v) == int:
            if self._isinf(v):
                return "null"
            else:
                return f"{v}"
        elif type(v) == datetime.datetime:
            return "'"+v.strftime("%Y-%m-%d %H:%M:%S")+"'"
        elif type(v) == datetime.date:
            return "'"+v.strftime("%Y-%m-%d")+"'"
        elif type(v) == pd.Timestamp:
            return "'"+v.strftime("%Y-%m-%d %H:%M:%S")+"'"
        elif type(v) == str:
            return f"'{v}'"
        else:
            return f"'{v}'"

    def _format_values(self, data):
        s = ''
        for i, e in enumerate(data):
            s += self._format_value(e)
            s += ', '
        return s[:-2]

    def _format_update_values(self, pk, data):
        s = ''
        for i, (k, v) in enumerate(data.items()):
            if k not in pk:
                s += f"{k}={self._format_value(v)}, "
        return s[:-2]

    def _format_update_conditions(self, pk, data):
        s = ''
        for i, (k, v) in enumerate(data.items()):
            if k in pk:
                s += f"{k}={self._format_value(v)} and "
        return s[:-4]

    def upsert(self, tablename, pk, data):
        if self.buffer_size is not None and self.buffer_size == 0:
            with self.engine.connect() as conn:
                self.upsert_one(conn, tablename, pk, data)
        else:
            if pk:
                self.tablename2pk[tablename] = pk
            if tablename not in self.tablename2datas:
                self.tablename2datas[tablename] = []
            self.tablename2datas[tablename].append(data)

            if self.buffer_size is not None and len(self.tablename2datas[tablename]) >= self.buffer_size:
                with self.engine.connect() as conn:
                    self._flush(conn, tablename, self.tablename2pk[tablename], self.tablename2datas[tablename])
                self.tablename2datas[tablename] = []

    def upsert_dataframe(self, tablename, pk, df):
        if len(df) <= 2000:
            with self.engine.connect() as conn:
                for index, row in df.iterrows():
                    self.upsert_one(conn, tablename, pk, row.to_dict())
        else:
            l = len(df)
            p = int(l // 2)
            self.upsert_dataframe(tablename, pk, df[:p])
            self.upsert_dataframe(tablename, pk, df[p:])

class MySQLUpsertHandler(UpsertHandlerBase):
    def __init__(self, engine, buffer_size=None, update_on_duplicate=True):
        super().__init__(engine, buffer_size, update_on_duplicate)

    def __del__(self):
        super().__del__()

    @staticmethod
    def is_duplicate_key(e):
        if type(e) != sqlalchemy.exc.IntegrityError:
            return False
        if len(e.orig.args) > 1 and str(e.orig.args[1]).startswith("Duplicate entry"):
            return True
        return False

    def upsert_one(self, conn, tablename, pk, data):
        if self.update_on_duplicate:
            update_str = self._format_update_values(pk, data)
        if self.update_on_duplicate and update_str.strip():
            duplicate_do_str = f"UPDATE {update_str}"
        else:
            duplicate_do_str = f"UPDATE {pk[0]}=VALUES({pk[0]})"  # 等价于do nothing
        sql = f"""INSERT INTO {tablename}({", ".join(data.keys())}) VALUES
            ({self._format_values(data.values())})
            ON DUPLICATE KEY
            {duplicate_do_str}\n"""
        conn.execute(sql)

class PSQLUpsertHandler(UpsertHandlerBase):
    def __init__(self, engine, buffer_size=None, update_on_duplicate=True):
        super().__init__(engine, buffer_size, update_on_duplicate)

    def __del__(self):
        super().__del__()

    @staticmethod
    def is_duplicate_key(e):
        if type(e) != sqlalchemy.exc.IntegrityError:
            return False
        if str(e.orig).startswith("duplicate key"):
            return True
        return False

    def upsert_one(self, conn, tablename, pk, data):
        if self.update_on_duplicate:
            update_str = self._format_update_values(pk, data)
        if self.update_on_duplicate and update_str.strip():
            duplicate_do_str = f"do update set {update_str}"
        else:
            duplicate_do_str = f"do nothing"
        sql = f"""INSERT INTO {tablename}({", ".join(data.keys())}) VALUES
            ({self._format_values(data.values())})
            on conflict ({", ".join(pk)})
            {duplicate_do_str}\n"""
        conn.execute(sql)

魔のkyo 2020-08-31 18:31 发表评论

Linux配置共享目录

魔のkyo — Thu, 27 Aug 2020 09:20:00 GMT

在需要被挂载的服务器上安装nfs-kernel-server

apt install nfs-kernel-server

编辑

sudo vim /etc/exports

样例

# /etc/exports: the access control list for filesystems which may be exported
#               to NFS clients.  See exports(5).
#
# Example for NFSv2 and NFSv3:
# /srv/homes       hostname1(rw,sync,no_subtree_check) hostname2(ro,sync,no_subtree_check)
#
# Example for NFSv4:
# /srv/nfs4        gss/krb5i(rw,sync,fsid=0,crossmnt,no_subtree_check)
# /srv/nfs4/homes  gss/krb5i(rw,sync,no_subtree_check)
/data 192.168.1.150(rw,sync,no_root_squash)
/home/data_manager/database 192.168.1.157(rw,sync,no_root_squash) *(ro,async,root_squash)

把共享目录的owner改成 nobody:nogroup

sudo chown nobody:nogroup <共享路径>

设置共享目录的权限

sudo chmod 777 <共享路径>

重新加载配置文件

sudo exportfs -a

在需要挂载的服务器需要安装nfs-common

apt install nfs-common

挂载命令样例 ，把140上的/data共享目录挂载到本地/mnt/140data

mount 192.168.1.140:/data /mnt/140data

使用到的端口，如果有防火墙需要设置

111/tcp+udp

825/tcp

2049/tcp

4046/udp

如果希望系统启动时自动加载文件系统，则还需要在 /etc/fstab 中添加内容：

192.168.1.140:/data /mnt/140data nfs defaults 0 0

其中nfs是被挂载的路径的类型

常用的类型有：

nfs表示远程linux的共享路径

cifs表示远程windows的共享路径

ext4表示本地ext4路径

魔のkyo 2020-08-27 17:20 发表评论

PostgreSQL 10 主从同步配置

魔のkyo — Thu, 27 Aug 2020 09:06:00 GMT

我进行的配置有：

改大wal_keep_segments值到64，即保留1GB的WAL缓存

主库的postgresql.conf文件中：

archive_mode = on

archive_command = 'rsync -zaq %p postgres@pg-slave:/var/lib/postgresql/wal_restore/%f && test ! -f /var/lib/postgresql/archivedir/%f && cp %p /var/lib/postgresql/archivedir/%f'

备库的recovery.conf文件中：

结尾追加

restore_command = 'cp /var/lib/postgresql/wal_restore/%f %p'

archive_cleanup_command = 'pg_archivecleanup /var/lib/postgresql/wal_restore/ %r'

归档命令不加入rsync也可以，只需要在建立主从同步时手动把完整同步之后的归档复制到从库，比如复制最近一天内修改过的归档

cd /var/lib/postgresql/archivedir find -mtime -1|xargs -n 1 -I{} scp /var/lib/postgresql/archivedir/{} postgres@192.168.1.150:/var/lib/postgresql/wal_restore/ 

其中核心就是红字部分，即用主库的归档来还原从库

相当于整体上从库建立起同步需要的数据 = 完整备份 + 归档文件 + WAL缓存主服务器：192.168.1.99

从服务器：192.168.1.150

在主服务器上：

在主服务器创建repl用户

CREATE ROLE repl login replication password 'd71ea3'; 

配置repl用户访问权限

vim /etc/postgresql/10/main/pg_hba.conf

host    replication     repl            192.168.1.150/32               md5 

配置主服务器

vim /etc/postgresql/10/main/postgresql.conf

wal_level = replica max_wal_senders = 10 wal_keep_segments = 16 wal_sender_timeout = 60s 

重启服务

service postgresql restart

在从服务器上：

停止服务

service postgresql stop

删除所有数据

cd /var/lib/postgresql/10/main

rm -rf *

配置从服务器

vim /etc/postgresql/10/main/postgresql.conf

hot_standby = on 

切换到postgres用户

sudo su - postgres

从主服务器创建初始备份，上面切换用户就不用调整文件权限了

pg_basebackup -h 192.168.1.99 -U repl -D /var/lib/postgresql/10/main -F p -X stream -P -R -p 5432

Password: d71ea3

会自动生成 recovery.conf 启动之后会读取里面的配置进行主从同步

切回root

sudo su -

启动服务

service postgresql start

补充：

FATAL: requested WAL segment00800002A0 has already been removed

我进行的配置有：
改大wal_keep_segments值到64，即保留1GB的WAL缓存
主库的postgresql.conf文件中：
archive_mode = on
archive_command = 'rsync -zaq %p postgres@pg-slave:/var/lib/postgresql/wal_restore/%f && test ! -f /var/lib/postgresql/archivedir/%f && cp %p /var/lib/postgresql/archivedir/%f'
备库的recovery.conf文件中：
结尾追加
restore_command = 'cp /var/lib/postgresql/wal_restore/%f %p'
archive_cleanup_command = 'pg_archivecleanup /var/lib/postgresql/wal_restore/ %r'
归档命令不加入rsync也可以，只需要在建立主从同步时手动把完整同步之后的归档复制到从库，比如复制最近一天内修改过的归档
cd /var/lib/postgresql/archivedir
find -mtime -1|xargs -n 1 -I{} scp /var/lib/postgresql/archivedir/{} postgres@192.168.1.150:/var/lib/postgresql/wal_restore/
其中核心就是红字部分，即用主库的归档来还原从库
相当于整体上从库建立起同步需要的数据 = 完整备份 + 归档文件 + WAL缓存

魔のkyo 2020-08-27 17:06 发表评论

Linux .service文件创建服务、配置服务自启动

魔のkyo — Sun, 28 Jun 2020 01:53:00 GMT

查看系统进程运行状态，包括服务

systemctl status

所有可用的单元文件存放在 /lib/systemd/system/ 和 /etc/systemd/system/ 目录。

根据我的实验情况是我们应该在/lib/systemd/system/ 下存放.service文件，当设置了自启动后，会自动在 /etc/systemd/system/ 下创建一个软链接指向 /lib/systemd/system/ 下的文件。

查看所有已安装服务：

systemctl list-units --type=service

通过服务状态可以查看启动服务的.service配置文件

例如

service mongodb status

可以看到

/lib/systemd/system/mongodb.service

最重要的，运行命令，

ExecStart=/usr/bin/mongod --unixSocketPrefix=${SOCKETPATH} --config ${CONF} $DAEMON_OPTS

PS:要注意的是ExecStart指定的是一个阻塞的程序，不需要后台执行，如果不阻塞，服务会认为程序执行完了，认为服务不在启动状态。

以Kafka为例

[Unit]
Description=Kafka Server
After=network.target zookeeper.service

[Service]
Type=simple
ExecStart=/opt/kafka_2.12-2.3.1/bin/kafka-server-start.sh /opt/kafka_2.12-2.3.1/config/server.properties
Restart=on-failure
RestartPreventExitStatus=255

[Install]
WantedBy=multi-user.target
Alias=kafka.service

详细的.service文件编写方法可以参考 http://www.jinbuguo.com/systemd/systemd.service.html

修改服务配置文件后需要

systemctl daemon-reload

设置服务开机自启动

systemctl enable postgresql.service

查询是否自启动服务

systemctl is-enabled postgresql.service

取消服务器开机自启动

systemctl disable postgresql.service

魔のkyo 2020-06-28 09:53 发表评论