发表于 |

趁着春节 7 天假期，把 18年所有的年假都请了下来，计划在家里待 20多天，这次假期最大的感受就是父母不懂得拒绝，或者说他们不想拒绝。

我小时候也是这样，可能是因为父母的关系，我一直处于一个周围同学中的“好人”状态，有事情要找人帮忙，一般都会找到我这来，因为我不拒绝。这也给我自身造成了一种假象：“我跟周围的关系不错”。那么我不拒绝的原因是什么呢？

最早可能是我不会拒绝，觉得拒绝会让对方难堪；之后可能是我觉得这段关系是我所看重的，所以我为了维持关系不拒绝，但是根本原因还是第一条；最终可能是我懒。（？

不拒绝，不想拒绝或者说不懂得拒绝，给我造成了很多的困扰，很被动。我这个人是一个喜欢计划的人，无论是生活还是工作，我都希望能够按照我的计划进行（当然如果出现计划外的事情往往我会比较懊恼。但是又因为我不拒绝，导致我的计划经常被中断，甚至是有些时效性的事情，就被彻底的终止了。可能这件事情对我比较重要，但是因为不拒绝，导致事情没完成。

那么我是从什么开始学会拒绝的呢？准确的说是同事教我的（虽然现在这位同事经常被我拒绝 - - 。在 2017年，我负责的工作准确的说是一半在公司内部，另一半在与公司外部的合作上。公司外部的工作优先级比较高，当我在做公司内部工作的时候，经常性的被打断，去处理优先级比较高的工作，造成我的整体工作效率不高，甚至说很低，哪怕我已经尽可能的考虑到部分原因，但是计划永远赶不上变化，我们要针对不同的事情去拒绝，比如当我正在处理公司外部的工作 A，我的老板让我立即做公司内部工作 B，自我评估优先级之后，我们决定是否接受 B，而不是因为那是我的老板，我就毫不犹豫的接受，因为当时接受的结果很有可能会造成 A & B 都做不好。

亲戚、朋友甚至是恋人关系也是一样，这种与工作关系不同，在让你帮忙时，他们往往会带上“情感”上的束缚，会利用“情感”关系去控制你，仿佛你不做这段关系就到此为止一样，这种是最可怕的，要学会拒绝，避免深陷。

当然我现在的拒绝可能比较生硬，导致不愉快，但是终究对我来说是个好事，期望后续能够通过阅读《情感勒索》这部书来改善。

发表于 |

ISO 9660

ISO 9660，也被一些硬件和软件供应商称作CDFS（光盘文件系统），是一个由国际标准化组织（ISO）为光盘介质发布的文件系统。其目标是能够在不同的操作系统如Windows、Mac OS以及类Unix系统上交换数据。

我们平时接触到的 ISO 格式文件均为 ISO 9660，我们可以通过 file 命令进行查看，以 RedHat 发行版为例：

1
2
[root@node redhat]# file rhel-server-7.6-x86_64-dvd.iso 
rhel-server-7.6-x86_64-dvd.iso: ISO 9660 CD-ROM filesystem data 'RHEL-7.6 Server.x86_64         ' (bootable)

用途

  1. 安装操作系统，我们可以通过将 ISO 挂载到物理服务器/PC 上，从 ISO 启动进行操作系统的安装；
  2. 作为软件安装源，比如红帽系列的版本，在 ISO 中，通常会有 Packages 路径，下面包含了当前版本完整的软件源，我们可以通过本地挂载的方式使用；
  3. 作为软件发行方式，常见的有 VMware vmtools, KVM Virtio 等统一打包方式；
  4. …

制作方式

  1. genisoimage
  2. mkisofs

第一种方式不常用，主要使用第二种方式进行使用，之前的文章中提到过 LiveCD 制作方式也是通过 mkisofs 命令继续构建的。

这里我们可以参考 VMware 官方文档了解如何定制自己的 ISO。

说一下何时需要定制我们自己的 ISO。当我们获取到各个发行版本的 ISO 后，我们可以正常使用进行安装，但是都是交互式安装，需要我们通过图形化界面/命令行交互的方式进行配置确认及参数设置。如果我们想要 ISO 支持静默安装，那么就需要我们自己定制属于自己的 KickStart 脚本，然后放置到 ISO 中并设置为默认执行项。
此场景对于 *nix 系统均适用。

当前路径结构

1
2
3
4
5
6
7
8
9
10
11
12
13
test/
├── a.b00
├── ata_liba.v00
|...
├── char_ran.v00
├── efi
│   └── boot
│       ├── boot.cfg
│       ├── bootia32.efi
│       └── bootx64.efi
├── efiboot.img
├── hid_hid.v00
|...

执行 mkisofs 命令，指定 ISO 源文件路径，指定目标 ISO 名称，即可构建。

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
[root@installer mnt]# mkisofs -relaxed-filenames -J -R -o custom_esxi.iso -b isolinux.bin -c boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table  test/
Warning: creating filesystem that does not conform to ISO-9660.
I: -input-charset not specified, using utf-8 (detected in locale settings)
Size of boot image is 4 sectors -> No emulation
  2.89% done, estimate finish Sat Jan 12 21:56:27 2019
  5.78% done, estimate finish Sat Jan 12 21:56:27 2019
  8.66% done, estimate finish Sat Jan 12 21:56:27 2019
 11.55% done, estimate finish Sat Jan 12 21:56:27 2019
 14.44% done, estimate finish Sat Jan 12 21:56:27 2019
 17.33% done, estimate finish Sat Jan 12 21:56:27 2019
 20.21% done, estimate finish Sat Jan 12 21:56:27 2019
 23.10% done, estimate finish Sat Jan 12 21:56:27 2019
 25.98% done, estimate finish Sat Jan 12 21:56:27 2019
 28.88% done, estimate finish Sat Jan 12 21:56:27 2019
 31.76% done, estimate finish Sat Jan 12 21:56:27 2019
 34.65% done, estimate finish Sat Jan 12 21:56:27 2019
 37.53% done, estimate finish Sat Jan 12 21:56:27 2019
 40.42% done, estimate finish Sat Jan 12 21:56:27 2019
 43.31% done, estimate finish Sat Jan 12 21:56:27 2019
 46.20% done, estimate finish Sat Jan 12 21:56:27 2019
 49.08% done, estimate finish Sat Jan 12 21:56:27 2019
 51.97% done, estimate finish Sat Jan 12 21:56:27 2019
 54.85% done, estimate finish Sat Jan 12 21:56:27 2019
 57.74% done, estimate finish Sat Jan 12 21:56:27 2019
 60.63% done, estimate finish Sat Jan 12 21:56:27 2019
 63.52% done, estimate finish Sat Jan 12 21:56:27 2019
 66.40% done, estimate finish Sat Jan 12 21:56:27 2019
 69.29% done, estimate finish Sat Jan 12 21:56:27 2019
 72.17% done, estimate finish Sat Jan 12 21:56:27 2019
 75.06% done, estimate finish Sat Jan 12 21:56:27 2019
 77.95% done, estimate finish Sat Jan 12 21:56:27 2019
 80.84% done, estimate finish Sat Jan 12 21:56:27 2019
 83.72% done, estimate finish Sat Jan 12 21:56:27 2019
 86.61% done, estimate finish Sat Jan 12 21:56:27 2019
 89.49% done, estimate finish Sat Jan 12 21:56:27 2019
 92.39% done, estimate finish Sat Jan 12 21:56:27 2019
 95.27% done, estimate finish Sat Jan 12 21:56:27 2019
 98.16% done, estimate finish Sat Jan 12 21:56:27 2019
Total translation table size: 2048
Total rockridge attributes bytes: 14593
Total directory bytes: 6144
Path table size(bytes): 50
Max brk space used 25000
173203 extents written (338 MB)

使用 file 命令查看构建结果：

1
2
[root@installer mnt]# file custom_esxi.iso 
custom_esxi.iso: # ISO 9660 CD-ROM filesystem data 'CDROM' (bootable)

定制 ISO 信息

通过上面的命令，我们构建了属于我们自己的 ISO，但是这时候出现一个需求，如果我们要对我们定制的 ISO 进行版本管理，要求可以通过 ISO 自动升级，那么我们在需要有渠道/方式获取 ISO 属性信息，比如：release date，size，dependency… 我们如何管理这些属性信息呢？

最简单的方式肯定是直接再编写一个文件，与 ISO 一一匹配，在文件中记录 ISO 相应信息，比如：

1
2
3
4
{"md5": "04db3dc9d872c382b1f42c9741815138",
"size": 354719744,
"dependency": ["yiran1", "yiran2", "yiran3"]
}

这样虽然简单实现了，但是很不方便管理，通过查看 ISO 9660 维基百科中的描述，可以看到有一个特性：

最开始的32768字节没有被ISO 9660数据结构使用，因此可以有其他用处，例如：CD-ROM可以在此区包含一个替代文件系统描述信息块，通常被混合光盘(Hybrid CD)用于提供Mac OS特定的内容。此未用块后面跟着一连串卷描述符，详细记录了该磁盘上的内容和类型信息（类似被FAT和NTFS格式磁盘使用的BIOS参数块）。

可以看到 ISO 前 32KiB 空间未被使用，Mac OS 早就利用这个空间来进行信息记录了，那么我们可以通过 dd 的方式来将二进制的信息写入 ISO 前 32KiB 空间中。
这样就避免了同时维护 ISO 及 ISO 对应 metadata 文件，管理起来更加方便。

参考链接

发表于 |

背景

在 Shell 中保存文件可以通过 echo 保存一个字符串， cat 保存一个字符片段，最近在用 cat 编写 Nginx 配置文件的时候，想要写入 $test 类似字段，但是 Shell 会自动将其识别为变量而忽略，记录下该方式。

cat 编写文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
root@yiran-30-250:/tmp
 $ cat cat.sh
#!/usr/bin/env bash
cat << EOF > /tmp/yiran
aaa
bbb
ccc
ddd
$eee
$fff
EOF
root@yiran-30-250:/tmp
 $ bash cat.sh
root@yiran-30-250:/tmp
 $ cat yiran
aaa
bbb
ccc
ddd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
root@yiran-30-250:/tmp
 $ cat cat2.sh
#!/usr/bin/env bash
cat << 'EOF' > /tmp/yiran
aaa
bbb
ccc
ddd
$eee
$fff
EOF
root@yiran-30-250:/tmp
 $ bash cat2.sh
root@yiran-30-250:/tmp
 $ cat yiran
aaa
bbb
ccc
ddd
$eee
$fff

发表于 |

背景

最近在看 《Wireshark网络分析就这么简单》，目前读了 1/3，觉得作为一本工具介绍书籍还是不错的，至少可以让我更关注网络相关知识。
书中有大量的实例来讲解 Wireshark 的使用，及网络基础，在阅读的过程中，需要实际动手操作下，由于搜到的教程中没有正确操作的步骤，特此记录。

环境信息

  • 个人 PC
    • Windows 10
  • 服务器
    • CentOS 7

操作流程

(1)个人 PC

  1. 登陆 Wireshark 官网，下载最新版本软件包并安装
  2. 打开 Wireshark ，选择本机的网卡，并进行抓取，验证软件是否正常工作
PC1 PC2

(2)服务器

验证个人 PC 上软件正常后，我们需要在服务器安装 rpcapd，以便让 Wireshark 连接该服务器。

  1. 访问 rpcapd github
  2. 克隆相应代码 cd /tmp; git clone https://github.com/rpcapd-linux/rpcapd-linux
  3. 安装相应依赖 yum install glibc-static flex binutils
  4. 编译安装 libpcap cd /tmp/rpcapd-linux/libpcap ; ./configure && make
  5. 编译安装 rpcapd ，注意 README 中的 libcrypt.a in glibc-static is broken in ,remove -static in Makefile ，需要先将 Makefile 中的 -static 删掉，执行 make 即可
  6. 执行 ./rpcapd -n 可以看到程序正在运行：
1
2
3
4
root@yiran-30-250:/tmp/rpcapd-linux 
master ✗ $ ./rpcapd -n
Press CTRL + C to stop the server...
bind(): Address already in use (code 98)

(3)个人 PC

  1. 打开 Wireshark，点击 Capture –> Options –> Manage Interfaces –> Remote interfaces –> + –> 在 Host 输入对应服务器 IP 即可PC3
  2. 在 Wireshark 首页上我们可以看到服务器上的相应网卡列表，选择我们想要抓取的网卡，即可抓取。

发表于 |

年终总结

  • 计划 30 本，实际25本。

根据 2017 和 2018 两年的状态来看，平均 20本左右是正常状态了，平时很少有长时间的阅读时间，今天这种元旦假期无人打扰的阅读时间更是少的可怜，还是要学会利用片段阅读。
调整下阅读策略，把想读的书调整为 1 本，防止过度堆积导致无法进行，希望 19 年可以有所改变。

“总要有点进步嘛”。

已读

  1. 《区块链》
  2. 《人工智能》
  3. 《哲学家们都干了些什么》
  4. 《大数据时代 : 生活、工作与思维的大变革》
  5. 《鞋狗 : 耐克创始人菲尔·奈特亲笔自传》
  6. 《大话存储（终极版） : 存储系统底层架构原理极限剖析》
  7. 《魔法时刻》
  8. 《大规模分布式存储系统 : 原理解析与架构实战》
  9. 《Python 自动化运维 : 技术与最佳实践》
  10. 《支付战争 : 互联网金融创世纪》
  11. 《遗落的南境1：湮灭》
  12. 《Effective Python : 编写高质量Python代码的59个有效方法》
  13. 《精通VMware vSphere 5》
  14. 《写给大家看的设计书（第3版）》
  15. 《算法图解》
  16. 《Fluent Python》
  17. 《C 程序设计语言》
  18. 《The Hitchhiker’s Guide to Python》
  19. 《Python Cookbook》
  20. 《高效程序员的45个习惯 : 敏捷开发修炼之道》
  21. 《Docker 进阶与实战》
  22. 《动物农场》
  23. 《爆款文案》
  24. 《Selenium 2自动化测试实战 : 基于Python语言》
  25. 《重新定义公司 : 谷歌是如何运营的》

在读

  • 《HTTP权威指南》
  • 《Go 语言圣经》

想读

  • 《大话数据结构》

发表于 |

cgroup 资源预留

背景

在之前的博客中，提到了 cgroup 中如何为自己的服务配置资源限制，比如 CPU，内存等，当时以为在 cgroup.conf 中配置的服务，那么相应绑定的 CPU 就归属于该服务，也就是资源预留，今天发现并不是这样，记录下如何通过 cgroup 做资源预留。

资源预留

在之前提到的博客中关于资源限制是这么配置的：

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
[root@node 20:56:49 ~]$cat /etc/cgconfig.conf
# yiran cgroups configuration
group . {
    cpuset {
        cpuset.memory_pressure_enabled = "1";
    }
}
group yiran {
    cpuset {
        cpuset.cpus = "0,1,2,3,4,5";
        cpuset.mems = "0-1";
        cpuset.cpu_exclusive = "1";
        cpuset.mem_hardwall = "1";
    }
}
group yiran/test {
    cpuset {
        cpuset.cpus = "0";
        cpuset.mems = "0-1";
        cpuset.cpu_exclusive = "1";
        cpuset.mem_hardwall = "1";
    }
}

我为 yiran 这个服务做了限制，其中分配给 yiran/test 的 CPU 是 0，并且配置了 cpuset.cpu_exclusive 选项。注意，这里的 exclusive 的意思并不是说分配到 yiran/test 中的服务独自占用该线程，而是说分配到 yiran/test 中的服务只会占用该线程，不会侵入到其他线程中，也就是通常我们说的 Limit。
可以通过 stress 命令来进行验证：

1
2
3
# 对一台配置好 cgroup 的物理服务器 CPU 加压
[root@node 21:05:37 ~]$stress -c 24
stress: info: [4033] dispatching hogs: 24 cpu, 0 io, 0 vm, 0 hdd

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
# 新开终端，执行 top 命令查看 CPU 情况
[root@node 21:05:37 ~]$top
top - 21:06:35 up 5 days,  9:03,  3 users,  load average: 32.58, 19.04, 15.43
Tasks: 449 total,  36 running, 412 sleeping,   0 stopped,   1 zombie
%Cpu0  : 89.0 us,  8.6 sy,  0.0 ni,  2.3 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu1  : 99.7 us,  0.3 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu2  : 90.4 us,  8.9 sy,  0.0 ni,  0.3 id,  0.3 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu3  : 95.4 us,  4.6 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu4  : 84.4 us, 13.6 sy,  0.3 ni,  1.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu5  : 46.5 us, 36.0 sy,  1.7 ni, 15.8 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu6  : 93.4 us,  6.6 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu7  : 94.4 us,  5.6 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu8  : 88.0 us, 12.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu9  : 88.7 us, 11.3 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu10 : 88.4 us, 10.9 sy,  0.0 ni,  0.3 id,  0.0 wa,  0.0 hi,  0.3 si,  0.0 st
%Cpu11 : 85.4 us, 13.9 sy,  0.7 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu12 : 98.7 us,  1.3 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu13 : 39.0 us, 12.0 sy,  0.0 ni, 49.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu14 : 92.7 us,  6.9 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.3 si,  0.0 st
%Cpu15 : 98.7 us,  1.3 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu16 : 97.0 us,  3.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu17 : 97.0 us,  2.3 sy,  0.0 ni,  0.3 id,  0.0 wa,  0.0 hi,  0.3 si,  0.0 st
%Cpu18 :100.0 us,  0.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu19 : 93.7 us,  6.3 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu20 : 88.4 us, 11.6 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu21 : 89.4 us, 10.6 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu22 : 88.1 us, 11.9 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu23 : 90.4 us,  9.6 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st

那么我们如何确保自己的服务有足够的资源运行呢？ 比如像 vSphere ESXi 上面可以针对某些虚拟机进行具体的资源预留（CPU，内存，磁盘等）。
其实只要将其他资源也限制在一个 cgroup 中就可以了。

  1. 在 /etc/cgconfig.conf 中创建一个新的 cgroup，将系统上其余的资源分配给该 group，如创建 yiran/others 并分配 3个 线程；
  2. 修改 /etc/cgrules.conf ，将系统其它所有服务分配到步骤1创建的 group 中，如：
    1
    *       cpuset       yiran/others

修改配置完成后，分别重启 cgred 和 cgconfig 使配置生效：

1
2
systemctl restart cgred
systemctl restart cgconfig

此时我们再通过 stress 进行验证

1
2
[root@node 21:09:29 ~]$stress -c 24
stress: info: [12475] dispatching hogs: 24 cpu, 0 io, 0 vm, 0 hdd

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
top - 21:11:58 up 5 days,  9:09,  3 users,  load average: 38.11, 30.37, 21.48
Tasks: 445 total,  38 running, 406 sleeping,   0 stopped,   1 zombie
%Cpu0  :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu1  :100.0 us,  0.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu2  :  0.0 us,  0.0 sy,  0.3 ni, 99.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu3  :  0.0 us,  0.3 sy,  0.0 ni, 99.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu4  : 88.1 us, 11.9 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu5  : 81.9 us, 16.1 sy,  1.6 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.3 si,  0.0 st
%Cpu6  :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu7  :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu8  :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu9  :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu10 :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu11 :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu12 :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu13 :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu14 :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu15 :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu16 :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu17 :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu18 :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu19 :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu20 :  0.0 us,  0.0 sy,  0.3 ni, 99.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu21 :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu22 :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu23 :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem : 13174792+total, 11522948+free,  6439344 used, 10079088 buff/cache
KiB Swap:        0 total,        0 free,        0 used. 12406676+avail Mem

我在 yiran/others 中配置了 3 个线程，那么此时哪怕我执行 stress worker 为 24，也只会在这3个线程中，不会对其他 cgroup 服务产生干扰，从而达到了资源预留的效果。

发表于 |

反转链表

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
class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None
def reverse_list(list_head):
    if not list_head or not list_head.next:
        return list_head
    reverse_node = None
    node_pre = None
    node = list_head
    while node:
        node_next = node.next
        if node_next == None:
            reverse_node = node
        node.next = node_pre
        node_pre = node
        node = node_next
    return reverse_node
node1 = ListNode(10)
node2 = ListNode(11)
node3 = ListNode(13)
node1.next = node2
node2.next = node3
reverse_list(node1)

合并两个排序的链表

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
class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None
def merge_link(head1, head2):
    if not head1:
        return head2
    if not head2:
        return head1
    if head1.val <= head2.val:
        ret = head1
        ret.next = merge_link(head1.next, head2)
    else:
        ret = head2
        ret.next = merge_link(head1, head2.next)
    return ret
node1 = ListNode(10)
node2 = ListNode(15)
node3 = ListNode(18)
node1.next = node2
node2.next = node3
node4 = ListNode(11)
node5 = ListNode(16)
node6 = ListNode(19)
node4.next = node5
node5.next = node6
a = merge_link(node1, node2)
print a.next.next.val

树的子结构

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
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Solution:
    def HasSubtree(self, pRoot1, pRoot2):
        result = False
        if pRoot1 and pRoot2:
            if pRoot1.val == pRoot2.val:
                result = self.DoesTree1haveTree2(pRoot1, pRoot2)
            if not result:
                result = self.HasSubtree(pRoot1.left, pRoot2) or self.HasSubtree(pRoot1.right, pRoot2)
        return result
    def DoesTree1haveTree2(self, pRoot1, pRoot2):
        if not pRoot2:
            return True
        if not pRoot1:
            return False
        if pRoot1.val != pRoot2.val:
            return False
        return self.DoesTree1haveTree2(pRoot1.left, pRoot2.left) and self.DoesTree1haveTree2(pRoot1.right, pRoot2.right)
pRoot1 = TreeNode(8)
pRoot2 = TreeNode(8)
pRoot3 = TreeNode(7)
pRoot4 = TreeNode(9)
pRoot5 = TreeNode(2)
pRoot6 = TreeNode(4)
pRoot7 = TreeNode(7)
pRoot1.left = pRoot2
pRoot1.right = pRoot3
pRoot2.left = pRoot4
pRoot2.right = pRoot5
pRoot5.left = pRoot6
pRoot5.right = pRoot7
pRoot8 = TreeNode(8)
pRoot9 = TreeNode(9)
pRoot10 = TreeNode(2)
pRoot8.left = pRoot9
pRoot8.right = pRoot10
S = Solution()
print(S.HasSubtree(pRoot1, pRoot8))

二叉树镜像

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
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Solution:
    def Mirror(self, root):
        if not root:
            return
        if not root.left and not root.right:
            return root
        pTemp = root.left
        root.left = root.right
        root.right = pTemp
        self.Mirror(root.left)
        self.Mirror(root.right)
    def Mirror2(self, root):
        if not root:
            return
        stackNode = []
        stackNode.append(root)
        while len(stackNode) > 0:
            nodeNum = len(stackNode) - 1
            tree = stackNode[nodeNum]
            stackNode.pop()
            nodeNum -= 1
            if tree.left or tree.right:
                tree.left, tree.right = tree.right, tree.left
            if tree.left:
                stackNode.append(tree.left)
                nodeNum += 1
            if tree.right:
                stackNode.append(tree.right)
                nodeNum += 1
pNode1 = TreeNode(8)
pNode2 = TreeNode(6)
pNode3 = TreeNode(10)
pNode4 = TreeNode(5)
pNode5 = TreeNode(7)
pNode6 = TreeNode(9)
pNode7 = TreeNode(11)
pNode1.left = pNode2
pNode1.right = pNode3
pNode2.left = pNode4
pNode2.right = pNode5
pNode3.left = pNode6
pNode3.right = pNode7
S = Solution()
S.Mirror(pNode1)
print(pNode1.right.left.val)

顺时针打印矩阵

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
class Solution:
    def printMatrix(self, matrix):
        if matrix == None:
            return
        rows = len(matrix)
        columns = len(matrix[0])
        start = 0
        while rows > start * 2 and columns > start * 2:
            self.PrintMatrixInCircle(matrix, columns, rows, start)
            start += 1
        print('')
    def PrintMatrixInCircle(self, matrix, columns, rows, start):
        endX = columns - 1 - start
        endY = rows - 1 - start
        for i in range(start, endX+1):
            number = matrix[start][i]
            print(number, ' ', end='')
        if start < endY:
            for i in range(start+1, endY+1):
                number = matrix[i][endX]
                print(number, ' ', end='')
        if start < endX and start < endY:
            for i in range(endX-1, start-1, -1):
                number = matrix[endY][i]
                print(number, ' ', end='')
        if start < endX and start < endY-1:
            for i in range(endY-1, start, -1):
                number = matrix[i][start]
                print(number, ' ', end='')
                
matrix = [[1,  2,  3,  4],
          [5,  6,  7,  8],
          [9, 10, 11, 12],
          [13, 14, 15, 16]]
matrix2 = [[1],[2],[3],[4],[5]]
matrix3 = [[1,2],[3,4],[5,6],[7,8],[9,10]]
S = Solution()
S.printMatrix(matrix)
S.printMatrix(matrix2)
S.printMatrix(matrix3)
# print(S.PrintMatrix(matrix))
# print(S.PrintMatrix(matrix2))
# print(S.PrintMatrix(matrix3))

发表于 |

背景

之前介绍过超微的 IPMI 配置时提过，超微的 IPMI 是最简陋的，最近在用戴尔服务器的时候碰到了一个比较坑的事情，查了资料解决了，更加坚定之前的结论，IPMI 相应的配置尽量独立。

问题

在戴尔服务器安装 CentOS 后，可见网卡比预期要多出一块，物理服务器安装了两块 PCIe 网卡，一块千兆，一块万兆，每块网卡有两个网口，那么理应在服务器看到的应该是 4个网口，即 ip ad 看到的应该是

1
2
3
4
5
root@node11 22:24:49 ~]$ip ad |grep enp
2: enp94s0f0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq master ovs-system state UP qlen 1000
3: enp24s0f0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc mq portid 3cfdfe6c9e10 state DOWN qlen 1000
4: enp24s0f1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq master ovs-system portid 3cfdfe6c9e12 state UP qlen 1000
5: enp94s0f1: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc mq state DOWN qlen 1000

但是安装完 OS，发现多出一块网口 eno16 ，通过 ethtool 工具查看，发现该网口为千兆，且处于连接状态，最开始没多想，直接将该网口作为管理网络配置了，一切正常。

当我尝试通过该网口连接 IPMI 获取风扇信息时，发现无法获取，验证命令为：
ipmitool -I lanplus -H <ipmi ip> -U <user name> -P <password> lan print
最开始以为是密码不对，后来发现是在 OS 内部无法 ping 通 IPMI IP，这就很奇怪了。

当时网络情况如下：

连通情况 yiran’s PC IPMI IP OS IP
yiran’s PC 1 1 1
IPMI IP 1 1 0
OS IP 1 0 1

因为没遇到过这种情况，根据经验，先检查了下 iDRAC 网络配置，发现当时 iDRAC 网卡选择的是 LOM1，也就是板载网卡，且该网卡处于 pass-through 状态，官方解释如下：

板载网卡 (LAN On Motherboards, LOM)，如果您选择 Network Settings（网络设置）下的 Auto Dedicated NIC（自动专用 NIC），则当 iDRAC 将其 NIC 选择作为共享 LOM（1、2、3 或 4）并且在 iDRAC 专用 NIC 上检测到链接时，iDRAC 会更改其 NIC 选择来使用专用 NIC。如果在专用 NIC 上检 测不到链接，则 iDRAC 使用共享 LOM。从共享 NIC 切换到专用 NIC 的超时为五秒，而从专用 NIC 切换到共享 NIC 的超时为 30 秒。可以使用 RACADM 或 WS-MAN 配置此超时值。
如果选择 LOM 作为直通配置，并且使用专用模式连接服务器，则输入操作系统的 IPv4 地址。 注: 如果在共享的 LOM 模式下连接了服务器，则操作系统 IP 地址字段将禁用。

解决办法

将 iDRAC 网络配置从 LOM 改为 Dedicated 后，重启 OS 即可，注意，改为 Dedicated 后，OS 将无法识别到 LOM，需要重新配置网络。

发表于 |

链表中倒数第k个结点

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
# 使用两个指针，a 先遍历 k-1，之后一起遍历，直到a 指针到最后一个节点，则 b 为倒数 k 节点
class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None
class Solution:
    def find_k_to_tail(self, head, k):
        if not head and k <= 0:
            return None
        a_head = head
        b_head = None
        for i in range(k - 1):
            if a_head.next != None:
                a_head = a_head.next
            else:
                return None
        b_head = head
        while a_head.next != None:
            a_head = a_head.next
            b_head = b_head.next
        return b_head.val
    def find_k_to_tail2(self, head, k):
        if not head and k <= 0:
            return None
        a_head = head
        while a_head and (k - 1) >= 0:
            a_head = a_head.next
            k -= 1
        while a_head:
            a_head = a_head.next
            head = head.next
        return head.val
a = ListNode(1)
a.next = ListNode(2)
a.next.next = ListNode(3)
a.next.next.next = ListNode(4)
a.next.next.next.next = ListNode(5)
s = Solution()
print s.find_k_to_tail2(a, 3)

发表于 |

调整数组顺序使奇数位于偶数前面

1
2
3
4
5
6
7
8
9
10
11
12
13
def reorder(nums, func):
    left, right = 0, len(nums) - 1
    while left < right:
        while not func(nums[left]):
            left += 1
        while func(nums[right]):
            right -= 1
        if left < right:
            nums[left], nums[right] = nums[right], nums[left]
def is_even(num):
    return (num & 1) == 0

调整数组顺序使奇数位于偶数前面，保持相对位置不变

1
2
3
4
5
6
7
def reorder2(nums):
    left = [num for num in nums if num & 1 != 0]
    right = [num for num in nums if num & 1 == 0]
    return left + right
nums = [1,2,3,4,5,6,7]
print reorder2(nums)