TypeCodes

OpenAI限制免费账号（Free Tier）使用gpt-5.3-codex 和 gpt-5.4

2026-03-12T14:00:00+08:00

2026-03-10 上午发现本地 codex 无法调用 cpa 服务器的 api，于是上 cpa 服务器查看了一下账号，发现已经无法使用 gpt5.4 了。同时 github 和 openai 社区也有反馈免费账号（Free Tier）的用户无法使用 gpt-5.3-codex 和 gpt-5.4。

{"detail":"The 'gpt-5.3-codex' model is not supported when using Codex with a ChatGPT account."}
{"detail":"The 'gpt-5.4' model is not supported when using Codex with a ChatGPT account."}

一、本地 codex 异常

上 cpa 服务器发现 Auth Files 中的免费账号已经全部移除了 gpt-5.3-codex 和 gpt-5.4 这两个模型，最新可用的 coding 只剩下 gpt-5.2-codex 了。

二、社区回应

在 github 上 Issue · GitHub 和 Codex Desktop App: gpt-5.3-codex not shown in model selector dropdown · Issue #10873 · openai/codex 官方回应：

If you're a paid subscriber and are not able to access gpt-5.3-codex or gpt-5.4, please look at my request here. we're looking for a few more affected users to post their user IDs. This will help us investigate.

在 openai 社区上 Temporary issue or best available model has been actually downgraded for free tier users? - Codex - OpenAI Developer Community 官方回应：

We’ve limited access to our latest models (gpt-5.3-codex and gpt-5.4) to paid subscriptions. This is necessary to ensure capacity for paid subscribers. If you’re on a Free plan, you can still use Codex with other models including gpt-5.2-codex.

三、其它

目前社区有很多针对 gpt free tier 用户的注册机，已经在 B 站、抖音等渠道被传开，通过注册机可以堆号来实现 gpt-5.3-codex 或者 gpt-5.4 无限 token 的漏洞。官方这一操作也算是 仁义 了（虽然本人也在使用），否则可以针对注册 ip、注册邮箱、注册时间等特征对这些 注册机 账号批量封禁。

serv00官方4月清理计划和新服务条款

2025-04-05T16:01:00+08:00

serv00官方在2025-04-03突然发布了02.04.2025 - 06.04.2025的清理计划【April cleaning and new ToS】，并禁止了fastdownload、p2p、盗版、网络攻击工具/脚本等内容的托管。

To maintain the quality of our free services, we will be conducting a series of verification operations.
New points will be added to the list every week.

一、清理的对象

根据公告内容，清理的对象包括：

02.04.2025 - 06.04.2025
Detecting and blocking accounts using forbidden software, including:
🚫 Proxy software
🚫 VPN
🚫 Tunneling software
🚫 Alist
🚫 Nezha
🚫 Hikka
🚫 Randomly named binaries
🚫 Binary names that don't match the software

⚠️ To keep your account, remove any of the above.
✅ If you don’t use anything from this list, your account is safe!

二、账号被禁用

由于自己的s13安装了Nezha，刚登录机器查看了下，已经被禁用了：THE ACCOUNT HAS BEEN BLOCKED: ToS violation: forbidden software - nezha 。

三、解决方案

只能静观其变啦，等待官方6月4号官方清理完毕后再说。当前如果安装了上述清理对象的，可以先卸载，不要顶风作案。

github workflow构建哪吒探针FreeBSD安装包

2025-02-09T18:30:00+08:00

之前写了关于如何在serv00/ct8机器上一键安装哪吒探针的内容，这里主要分享下如何构建这种运行在serv00/ct8这种FreeBSD操作系统上的哪吒探针面板二进制安装包。

当然，也可以直接了当的在github上查看https://github.com/vfhky/nezha-build的源代码，也可以直接下载代码构建出来的可用于serv00/ct8这种FreeBSD主机的哪吒面板安装包。

一、背景

由于哪吒官方没有提供FreeBSD的dashboard面板安装包，所以如果想在serv00/ct8上使用就得先自己构建一个。

可以看到serv00_ct8_nezha项目最初的几个版本(也是哪吒探针V0版本期间)，是在安装期间直接拉取官方源代码构建出来的：即在serv00/ct8机器安装探针面板时，会先用命令go build -ldflags="-s -w --extldflags '-static -fpic' -X github.com/naiba/nezha/service/singleton.Version=${version_num}"构建得到安装包然后再安装。

这样带来的问题就是每次安装或者升级dashboard面板时都会消耗较长时间，所以在24年10月做了优化：

创建一个新的github工程nezha-build使用 workflow 来构建哪吒面板FreeBSD安装包；
原有github工程serv00_ct8_nezha解耦后就只需从 nezha-build 下载FreeBSD包安装即可。

二、开启CGO

哪吒探针dashboard面板是go语言开发的，但是使用了go-sqlite3驱动，所以在交叉编译的时候必须得设置CGO_ENABLED=1，否则就会得到go-sqlite3 requires cgo to work的错误：

三、交叉编译的困局

在开启CGO的前提下，最初nezha-build工程尝试在github workflow中使用 Ubuntu 环境，然后使用交叉编译工具链（如 Clang、musl-tools）来构建 FreeBSD amd64 二进制文件。但实际操作中，却遇到了各种棘手的难题：主要是缺少FreeBSD C头文件。

3.1 使用clang编译

先贴一下workflow核心代码：

      - name: Build
        uses: goreleaser/goreleaser-action@v6
        env:
          GOOS: ${{ matrix.goos }}
          GOARCH: ${{ matrix.goarch }}
          CGO_ENABLED: 1
          CC: /usr/bin/clang
        with:
          distribution: goreleaser
          version: "~> v2"
          workdir: nezha
          args: build --single-target --clean --skip=validate

然后运行workflow报错：

│ build failed: failed to build for freebsd_amd64_v1: exit status 1: # runtime/cgo
│ In file included from _cgo_export.c:3:
│ /usr/include/stdlib.h:25:10: fatal error: 'bits/libc-header-start.h' file not found
│ target: freebsd_amd64_v1
Error: The process '/__t/goreleaser-action/2.6.1/x64/goreleaser' failed with exit code 1

原因：在 Go runtime 尝试编译其 C 代码部分时，会默认使用当前 Ubuntu 系统中的 glibc 头文件，导致编译器尝试包含 bits/libc-header-start.h，从而引发错误。

3.2 使用musl-tools编译

先贴一下workflow核心代码：

      - name: Install dependencies
        run: |
          apt-get install -y clang lld musl-tools
      .......................

      - name: Build
        uses: goreleaser/goreleaser-action@v6
        env:
          GOOS: ${{ matrix.goos }}
          GOARCH: ${{ matrix.goarch }}
          CGO_ENABLED: 1
          CC: /usr/bin/musl-gcc # Use musl-gcc symlink
          LDFLAGS: "-static" # Crucial: Static linking with musl

然后运行workflow报错：

│ build failed: failed to build for freebsd_amd64_v1: exit status 1: # runtime/cgo
│ gcc_freebsd_amd64.c:7:10: fatal error: sys/signalvar.h: No such file or directory
│     7 | #include <sys/signalvar.h>
│       |          ^~~~~~~~~~~~~~~~~
│ compilation terminated.
│ target: freebsd_amd64_v1
Error: The process '/__t/goreleaser-action/2.6.1/x64/goreleaser' failed with exit code 1

原因：同样的，sys/signalvar.h 是 FreeBSD 特有的系统头文件，它在 Ubuntu 系统中并不存在。尽管我尝试使用 musl-gcc 作为交叉编译器，但是 Go runtime 自身的 C 代码仍然会尝试使用 Ubuntu 系统中的头文件，导致编译器无法找到 sys/signalvar.h。

3.3 困局

通过多次构建，我发现即使使用了clang 、musl-tools 和其它交叉编译工具链，仍然无法在 Ubuntu 环境下成功构建 FreeBSD amd64 二进制文件。

四、解决方案：vmactions/freebsd-vm

上述问题归根结底是由于构建环境不一致导致的。我在 Ubuntu 环境中尝试构建 FreeBSD 程序，虽然使用了交叉编译工具，但是 Go runtime 仍然会受到 Ubuntu 系统库的影响。因此，我需要一个真正的 FreeBSD 环境来进行构建。

vmactions/freebsd-vm 正是为此而生，它可以在 GitHub Actions 工作流程中启动一个真实的 FreeBSD 虚拟机，提供一个与目标环境完全一致的构建环境，从而彻底解决交叉编译带来的各种问题。

vmactions/freebsd-vm的大致原理：依赖于 QEMU 进行虚拟化，并通过 SSH 进行远程控制，以实现自动化任务。

1、在Ubuntu中运行 QEMU，然后创建 FreeBSD 虚拟机；
2、使用预构建的 FreeBSD 磁盘镜像。从源代码中的freebsd-vm/conf/14.1.conf可以看到诸如
OVA_LINK="https://github.com/vmactions/freebsd-builder/releases/download/v${BUILDER_VERSION}/freebsd-${VM_RELEASE}.qcow2.zst"
3、使用SSH公私钥连接 FreeBSD 虚拟机，上传哪吒探针dashboard面板源码并构建。

五、总结

可以看到在相较于开启CGO后交叉编译构建哪吒探针面板FreeBSD安装包的复杂，使用vmactions/freebsd-vm提供的真实FreeBSD构建环境可以很简单的实现。

最后，大家可以在 https://github.com/vfhky/nezha-build 查看实现的源代码。也可以直接下载构建好的哪吒探针dashboard面板（FreeBSD版本），目前设置每天8点、16点、24点拉取官方最新代码进行构建，以便serv00和ct8主机一键安装哪吒探针V1版本工程能下载和安装到最新的探针面板。

serv00和ct8上的哪吒探针V1开启Github和Gitee登录

2025-01-04T13:40:00+08:00

一、背景

上篇文章https://typecodes.com/python/serv00ct8nezhav1.html介绍了如何在serv00/ct8主机上一键安装哪吒探针V1版本（含面板和agent），这次看naiba最近已经增加了Github和Gitee等OAuth2认证登录的支持，所以把 https://github.com/vfhky/serv00_ct8_nezha 工程做了跟进升级。

二、如何安装或者升级

如果之前没有使用前面的https://typecodes.com/python/serv00ct8nezhav1.html安装过哪吒探针，那么直接按照教程进行安装即可。

对于之前已经使用本项目安装过了哪吒探针V1版本的用户，那么可以选择选择直接升级或者修改dashboard面板配置。

三、详细安装或者升级过程

3.1 创建GitHub和Gitee应用

如下所示，在创建应用时，【应用主页】填写你的哪吒探针面板地址，例如：https://monitor2.typecodes.us.kg ；

【授权回调地址】填写你的哪吒探针面板地址/api/v1/oauth2/callback，例如：https://monitor2.typecodes.us.kg/api/v1/oauth2/callback 。

1、创建GitHub应用：https://github.com/settings/developers

2、创建Gitee应用：https://gitee.com/oauth/applications

3.2 直接安装或者升级

对于之前没有安装过哪吒面板V1版本的用户，按照https://typecodes.com/python/serv00ct8nezhav1.html操作即可。

对于已经使用本项目安装过了哪吒探针V1面板的用户，可以直接按照下面操作进行升级：

1、更新代码： git pull orgin main
2、升级哪吒： python3 main.py

以下是安装或者升级的记录，可以看到第2步骤中输入Github和Gitee应用得到的client id和client secret：

3.3 修改配置

对于之前已经使用本项目安装过了哪吒探针V1面板的用户，还可以选择修改dashboard配置文件来开通Github和Gitee的功能。

如下图所示，只需执行命令bash utils.sh modify_config即可：

3.4 绑定哪吒探针

完成上面的操作后，你已经成功拥有了Github和Gitee的功能。

接下来只需要登录dashboard管理面板，然后在【个人信息】菜单中，点击【GitHub】或者【Gitee】中的bind按钮来绑定哪吒探针用户即可。

如下所示，这里把Github和Gitee都绑定了哪吒探针用户：

3.5 关闭密码登录

因为后面可以直接使用【GitHub】或者【Gitee】登录dashboard面板了，所以我这里关闭密钥登录的功能。

四、结尾

最后，大家有什么问题或者建议可以在 https://github.com/vfhky/serv00_ct8_nezha 反馈。

serv00和ct8主机一键安装哪吒探针V1版本和多主机保活

2024-12-11T20:10:00+08:00

一、背景

上周末L站有佬友反馈之前写的serv00 和 ct8一键安装哪吒探针的github项目: https://github.com/vfhky/serv00_ct8_nezha出现无法unzip: Unrecognized archive format的问题，后面排查是哪吒探针升级到V1版本，导致在github构建freebsd包异常，所以安装失败。

经过这几天抽空研究，已经完成了哪吒V1版本的freebsd打包以及完成了serv00 和 ct8一键安装哪吒探针项目的升级。

如下图所示，这是在s13机器上的安装v1最新版本哪吒探针的效果：

二、重要说明

经过这次的升级后，项目已经支持自主选择安装哪吒v0还是v1版本的探针。

不过由于哪吒探针自身v0和v1版本存在不兼容的问题，所以如果想不断在v0和v1版本间进行切换，请先备份哪吒面板中的数据库sqlite.db再操作。

哪吒v0版本的效果体验：https://monitor1.typecodes.us.kg

哪吒v1版本的效果体验：https://monitor2.typecodes.us.kg

三、如何安装或者升级

由于这次对 https://github.com/vfhky/serv00_ct8_nezha 的做了完全兼容的升级，所以安装v1版本的哪吒探针和之前安装v0版本操作是完全一样的，都是很简单的。

1、下载脚本: git clone https://github.com/vfhky/serv00_ct8_nezha.git
2、进入项目: cd serv00_ct8_nezha
3、修改配置文件: vim config/host.eg 然后添加需要保活的主机信息。
4、开始安装: python3 main.py 。

再次提醒，对于想不断在v0和v1版本间进行切换的用户，请先备份sqlite.db。

四、详细安装或者升级过程

下面是安装过程的一些截图：

4.1 生成ssh公私钥

4.2 选择并安装v1版本的哪吒dashboard

如下图所示，在配置dashboard面板时，【面板访问端口】填写在serv00/ct8的panel面板创建的任意tcp端口；

【GRPC通信地址】填写在serv00/ct8的panel面板分配的域名:tcp端口，或者自己的反代域名。

由于v1版本的dashboard面板访问端口和agent的GRPC通信端口已经合并成了，所以只需要在panel面板申请一个tcp端口即可。这个是和安装v0版本不一样的地方，大家不要踩坑！！！

另外，第4步骤安装python依赖可能耗时较长(主要是机器磁盘性能太差)，请耐心等待。

最后，请留意打印的【用于agent连接的密钥】，也就是agentsecretkey，在后面安装哪吒agent客户端时需要用到。

4.3 安装哪吒agent

如下图所示，在配置哪吒agent的时候需要dashboard步骤中的【agentsecretkey】，【GRPC通信地址】也是填写dashboard步骤中的域名:tcp端口。

4.4 安装完毕

至此已经完成了v1版本的安装，你可以通过4.2小节中填写的【GRPC通信地址】访问哪吒探针页面了。

我这里额外多做了一步：在cloudflare上用 https://monitor2.typecodes.us.kg 对这个通信地址做了一个反代。

五、结尾

综上，整个哪吒探针V1版本的安装或者升级过程都是很简单的，和之前安装v0版本完全兼容。

另外，如果选择安装v0版本的哪吒探针，那么会直接安装基于v0最后一次更新的代码构建的freebsd包，也就是v0.20.13版本的dashboard和v0.20.5版本的agent。

最后，大家有什么问题或者建议可以在 https://github.com/vfhky/serv00_ct8_nezha 反馈。

博客完成Follow.is订阅认证

2024-10-19T17:10:00+08:00

一、前言

最近一个RSS订阅follow.is火了起来，在收到内测邀请码注册后，顺便在上面把博客的订阅也做了认证。

目前体验下来还可以，界面比较清爽，订阅源比较丰富，美中不足的是目前还没有手Y客户端。

二、如何认证

首先打开Follow客户端，点击左上方的+号。然后直接在rss订阅源里面添加要订阅的网站的rss数据源，例如：https://typecodes.com/feed.xml 。

在点击follow订阅后，在左侧面板的订阅列表中右键要认证的follow源。接着就是按照follow.is的提示操作即可。

BZ这里是直接在feed.xml文件中添加follow.is提供的代码，然后点击认证就通过了。

三、界面效果

如图，follow.is 的阅读模式还是挺清爽的。

四、本站的订阅地址

欢迎大家订阅本站，方式如下：

1. 在Follow上订阅   https://app.follow.is/feed/70387716523684864
2. 直接RSS订阅      https://typecodes.com/feed.xml

serv00和 ct8主机一键安装哪吒探针和多主机保活 (六)

2024-10-13T15:10:00+08:00

一、前言

由于 serv00和ct8主机一键安装哪吒探针的项目(github.com/vfhky/serv00_ct8_nezha)的易用性和功能多样性，目前在github上已经有50多个star了。这期间也有多个大佬反馈使用问题，也都做了一些优化。

最近有反馈关于哪吒面板没有显示主机区域的PR，后面排查了一下是因为建构的时候没有打包geoip库导致的。

它和之前另外一个大佬反馈的dashboard面板可能耗时很长的问题其实都是出在dashboard的安装包上，，所以蹭周末有时间一并解决一下。

二、更新说明

为了修复这个区域显示问题，同时彻底解决有部分用户反馈在安装dashboard面板可能耗时很长的问题，本次更新放弃了之前在安装面板时先编译构建二进制包的逻辑，采用了直接拉取已经在github构建好的包的方案。

带来的优势如下：

1、关键点：在 github 上新建 github.com/vfhky/nezha-build 项目，构建包含freebsd平台的哪吒面板的安装包（除了手动输入要构建的版本，每天凌晨3点还会自动同步拉取哪吒面板最新官方代码进行打包）；
2、通过下载上面的构建好的安装包，可以大大降低在serv00或者ct8主机上安装dashboard的时长，更享丝滑的安装过程；
3、打包的时候引入 geoip 库，解决哪吒dashboard面板没有显示主机区域的问题。

三、使用方法

这里只针对已经安装的dashboard面板的用户，对于还未使用项目进行安装的，请参考之前的文档 https://typecodes.com/python/serv00ct8nezha.html 进行安装体验。

3.1、更新 git 代码：

$ cd ~/serv00_ct8_nezha && git pull

3.2、重新下载dashboard:

接着执行python3 main.py命令重新下载dashboard面板（注意：不需要生成或者拷贝ssh公私钥等步骤），等下载完后直接ctrl+c中止后面代码运行即可。

3.3、重启dashboard面板:

在用新的dashboard安装包替换完旧的后，需要执行bash utils.sh restart命令来重启dashboard面板进程：

四、结尾

通过上面3个简单的操作步骤，就可以拥有开头图片中演示的主机区域图标了！同时也感谢大佬们的反馈~

PS：dashboard面板和agent客户端自动更新的需求也正在计划中，敬请关注项目: github.com/vfhky/serv00_ct8_nezha

博客切换到Cloudflare并使用免费域名进行DNS解析优选

2024-09-29T21:30:00+08:00

一、前言

大概 6 月份的时候，博客把 typecodes.com 域名解析迁移到了 Cloudflare。但是如果直接使用 Cloudflare 的解析，在国内的效果基本相当于 “减速器”，所以得需要对域名的 dns 解析进行优选。

二、前提准备

这里使用免费域名 cloudns 对托管在 Cloudflare 的域名解析进行优选，需要准备的素材如下：

1、一个托管在Cloudflare的辅助域名，且开通了自定义域名功能；
2、托管在 Cloudflare 的主域名；
3、自己真实的服务器的ip，例如自己的博客所在的服务器的ip地址。

三、操作步骤

大致的操作步骤如下：

1、辅助域名 ，例如： blog.cloudns.be
1.2 origin.blog.cloudns.be   A类型   指向自己的真实服务器ip， 开小黄云（代理）
1.1 添加回退源： origin.blog.cloudns.be    自定义主机名:  typecodes.com
1.3 cdn.blog.cloudns.be   CNAME  到优选域名 cloudflare.182682.xyz 或者ip，不开小黄云（代理）

2、主域名 ，例如： typecodes.com
typecodes.com   CNAME  cdn.blog.cloudns.be  不开小黄云（代理）

详细操作步骤可以参考下面的内容，也是 UP 参照 B 站的白嫖Cloudflare最优CDN给自己网站加速，尽情享受CF的免费服务_哔哩哔哩_bilibili 视频教程的实践。

3.1、辅助域名

本教程使用的辅助域名是 blog.cloudns.be 这个免费的二级域名，而且托管到了 Cloudflare 上。辅助域名主要执行 3 个操作步骤，具体如下：

3.1.1 新增 A 记录

新增一个 A 类型的任意前缀域名作为回退源，且解析到自己的真实的服务器的 ip，另外需要 开启小黄云。

如下图：origin.blog.cloudns.be 的 A 记录解析到了11.12.13.14这个 ip。

3.1.2 开启自定义主机名

如下图所示，在辅助域名的 自定义主机名 菜单中，添加之前设置的回退源，例如 origin.blog.cloudns.be。

接着，在 自定义主机名 中填写自己的主域名，例如 typecodes.com。注意，需要验证域名，按照界面上的提示在主域名中添加相应的 TXT 记录即可。

3.1.3 选择优选域名

新增 CNAME 类型任意前缀的子域名到一个优选域名，关闭小黄云。

注意：可以用于优选的域名或者 ip 有很多，可以从 Cloudflare 优选IP - 每15分钟更新文中任选一个，例如：typecodes.cloudflare.182682.xyz 。

如下图：cdn.blog.cloudns.be 的 CNAME 记录解析到了 www.visa.cn 。

3.2 主域名

主域名的操作比较简单，只需要把域名通过 CNMAE 解析到前面的优选辅助域名即可。如下图所示，主域名 typecodes.com 解析到了 cdn.blog.cloudns.be.

四、其它

除了上面这种使用另外一个辅助域名解析到一个优选域名的方式之外，还可以通过主域名的子域名解析到国内 DNS 进行分流优选。

serv00和 ct8主机一键安装哪吒探针和多主机保活 (五)

2024-09-07T16:10:00+08:00

一、前言

前文 serv00和ct8主机一键安装哪吒探针和多主机保活(四) - TypeCodes 介绍了如何 utils.sh 脚本的使用方法，例如修改配置等等，那么这篇文章主要是介绍新增的哪吒面板数据库sqlite.db的备份功能。

项目地址：github.com/vfhky/serv00_ct8_nezha

二、特点说明

本次新增的云备份哪吒面板的数据库sqlite.db的功能，其主要特点如下：

1、支持 七牛云存储、腾讯云cos、阿里云oss 这三种云存储平台；
2、自动创建bucket存储仓库，无需其它复杂操作；
3、支持bucket存储仓库名称、备份文件的存放路径等；
4、支持自定义过期时间，对过期的备份数据能够自动删除，节约成本。

三、使用方法

由于是针对哪吒面板的数据库备份，所以只需要在 安装了 dashboard 面板 的主机上操作即可。具体操作步骤如下：

3.1、更新 git 代码：

1、之前未安装过项目的 : 请先按照 https://typecodes.com/python/serv00ct8nezha.html 操作安装好项目
2、之前已经安装过项目 : cd serv00_ct8_nezha && git pull

3.2、更新配置:

最简单的方式是通过python3 main.py然后等配置文件更新后，直接ctrl+c中止后面代码运行即可。

当然也可以手工按需复制如下配置到sys.conf文件末尾。

# 七牛备份. 0-否 1-是
ENABLE_QINIU_BACKUP=0
QINIU_ACCESS_KEY=xxxxxx
QINIU_SECRET_KEY=xxxxxx
# https://developer.qiniu.com/kodo/1671/region-endpoint-fq
QINIU_REGION=z2
QINIU_BUCKET_NAME=serv00-ct8-nezha
QINIU_DIR_NAME=serv00_ct_nezha
# 文件保存多少天
QINIU_EXPIRE_DAYS=30
# 腾讯云cos备份. 0-否 1-是
ENABLE_QCLOUD_COS_BACKUP=0
QCLOUD_COS_APP_ID=xxxxxx
QCLOUD_COS_SECRET_ID=xxxxxx
QCLOUD_COS_SECRET_KEY=xxxxxx
# https://cloud.tencent.com/document/product/436/6224
QCLOUD_COS_REGION=ap-guangzhou
QCLOUD_COS_BUCKET_NAME=serv00-ct8-nezha
QCLOUD_COS_DIR_NAME=serv00_ct_nezha
QCLOUD_COS_EXPIRE_DAYS=30
# 阿里云OSS备份. 0-否 1-是
ENABLE_ALI_OSS_BACKUP=0
ALI_OSS_ACCESS_KEY_ID=xxxxxx
ALI_OSS_ACCESS_KEY_SECRET=xxxxxx
# https://help.aliyun.com/zh/oss/user-guide/regions-and-endpoints
ALI_OSS_ENDPOINT=oss-cn-guangzhou.aliyuncs.com
ALI_OSS_BUCKET_NAME=serv00-ct8-nezha
ALI_OSS_DIR_NAME=serv00_ct_nezha
ALI_OSS_EXPIRE_DAYS=30

3.3、修改配置:

按照需要开启备份功能，例如ENABLE_QCLOUD_COS_BACKUP=1开启腾讯云cos备份。当然，还得配置相关密钥。

四、备份效果

4.1 七牛云存储

可以看到七牛云存储备份后的文件命名风格是 yyyymm/dd_hh_mm_sqlite.db：

可以看到七牛云存储是针对文件级别的过期时间：

4.2 腾讯云cos存储

可以看到腾讯云cos存储备份后的文件命名风格也是yyyymm/dd_hh_mm_sqlite.db：

可以看到腾讯云cos存储是针对bucket级别的过期时间：

4.3 阿里云 oss 存储

可以看到阿里云oss存储备份后的文件命名风格也是yyyymm/dd_hh_mm_sqlite.db：

可以看到和腾讯云cos存储一样，阿里云oss存储也是针对文件级别的过期时间：

serv00和 ct8主机一键安装哪吒探针和多主机保活 (四)

2024-09-01T18:10:00+08:00

一、工具说明

前文 serv00和ct8主机一键安装哪吒探针和多主机保活(三) - TypeCodes 介绍了如何使用青龙面板进行保活，这一篇文章主要是介绍 https://github.com/vfhky/serv00_ct8_nezha 项目中的 utils.sh 脚本工具。

二、菜单说明

utils.sh 脚本主要是封装了一些简单的操作，包括 vim 环境、生成 ssh 公私钥、写入进程监控、修改 dashboard 或者 agent 配置等等。

下面简要介绍一下每个选项的功能和使用方法：

2.1 init

作用：优化使用环境：vim 优化行号、优化复制粘贴等；增加 ll 命令显示 linux 当前目录；对项目所有 shell 文件增加 x 可执行权限。

用法： sh utils.sh init

2.2 kill

作用：停止当前用户启动的所有进程。

用法： sh utils.sh kill

2.3 key

作用：在当前用户的.ssh 目录生成 id_ed25519的公私钥，且把公钥内容写入到 authorized_keys 中，用于 ssh 登录。

用法： sh utils.sh key

2.4 monitor

作用：把任意一个进程（例如哪吒面板，或者自己写的任意后面服务）写入到进程监控配置文件 monitor.conf中，这样当 crontab 运行时，项目会自动检查配置的这个进程是否存在，不存在的话，则自动拉起该进程。

用法： sh utils.sh monitor 配置文件的完整路径  新增的进程路径  新增的进程名  进程的启动命令  新增的进程运行方式(background-前台 foreground-后台)
示例： sh utils.sh monitor /home/vfhky/serv00_ct8_nezha/config/monitor.conf /home/vfhky/nezha_app/dashboard dashboard ./dashboard background

2.5 heart

作用：当新增了一台需要保活的主机时，通过脚本把主机信息写入到主机心跳文件 heartbeat.conf 中，样当 crontab 运行时，项目会自动通过 ssh 私钥登录这台新增的主机。

用法： sh utils.sh monitor 配置文件的完整路径  serv00_ct8_host  serv00_ct8_port  serv00_ct8_username
示例： sh utils.sh monitor /home/vfhky/serv00_ct8_nezha/config/heartbeat.conf s10.serv00.net 22 mytest

2.6 modify_config

作用：修改哪吒 dashboard 面板或者 agent 的配置，修改后会自动调用 sh heart_beat_entry.sh 重启 dashboard和 agent 进程。

用法： bash utils.sh modify_config

示例操作：

2.7 pushplus

作用：测试通过 pushplus 发送通知。

用法： bash utils.sh pushplus token 通知的标题 通知的内容

2.8 restore

作用：重新 serv00 或者 ct8 主机的系统。脚本会删除用户目录除了 backup 外的所有文件或者目录，请 【谨慎使用】。

用法： bash utils.sh restore

2.9 uninstall

作用：卸载已经安装的哪吒探针的dashboard和agent 并删除 crontab中的哪吒探针心跳(heart_beat_entry.sh)。

用法： bash utils.sh uninstall

serv00和ct8主机一键安装哪吒探针和多主机保活(三)

2024-08-27T20:10:00+08:00

一、青龙面板

前文 serv00和ct8主机一键安装哪吒探针和多主机保活(二) - TypeCodes 介绍了 https://github.com/vfhky/serv00_ct8_nezha 项目的架构，这一篇文章主要是介绍如何使用青龙面板来调用项目监控进程和主机保活。

二、操作步骤

由于项目的进程监控和多主机保活的入口是 heart_beat_entry.sh 脚本，所以我们只需要在青龙面板中添加定时任务，通过 ssh 私钥来登录主机并执行这个脚本。

2.1 环境变量

在青龙面板中添加以下 3 个环境变量，用于后面的 shell 脚本。

1、SERV00_SSH_PRIVATE_KEY  ： 由serv00_ct8_nezha生成的ssh私钥，也就是~/.ssh/id_ed25519文件中的内容
2、SERV00_SSH_HOST         ： 主机host，例如: s7.serv00.com ， s1.ct8.pl
3、SERV00_SSH_USER         ： 主机用户名

2.2 新建脚本

进入青龙面板中的 脚本管理 菜单，然后新建一个名为 serv00_ct8_nezha 的目录，再新建一个名为 monitor.sh 的脚本位于该目录下。脚本内容如下：

#!/bin/bash

echo "$(date): 开始执行远程命令"

echo "$SERV00_SSH_PRIVATE_KEY" > /tmp/id_rsa
chmod 600 /tmp/id_rsa

REMOTE_USER=${SERV00_SSH_USER:-root}

echo "$(date): 尝试连接到 ${REMOTE_USER}@${SERV00_SSH_HOST}"
if ssh -i /tmp/id_rsa -o StrictHostKeyChecking=no $REMOTE_USER@${SERV00_SSH_HOST} "/usr/home/${REMOTE_USER}/serv00_ct8_nezha/heart_beat_entry.sh"; then
    echo "$(date): 远程命令执行成功"
else
    echo "$(date): 远程命令执行失败"
fi

rm /tmp/id_rsa

echo "$(date): 脚本执行结束"

2.3 定时任务

在青龙面板的 定时任务 菜单下面新建一个定时任务，要执行的命令/脚本为 task serv00_ct8_nezha/monitor.sh。

2.4 手工执行查看效果

在青龙面板上手工执行这个定时任务，然后在 serv00 或者 ct8 主机上使用 ps 命令查看执行执行情况：

2.5 查看项目日志

在 serv00 或者 ct8 主机上进入 serv00_ct8_nezha 目录后，使用 tail -f log/main.log 查看项目日志。

注：下图中的主机用户和主机名已经用 shell 命令进行了锐敏：

serv00和ct8主机一键安装哪吒探针和多主机保活(二)

2024-08-25T20:10:00+08:00

一、项目的简单架构说明

前文 serv00和ct8主机一键安装哪吒探针和多主机保活 - TypeCodes 介绍了 https://github.com/vfhky/serv00_ct8_nezha 项目的使用方法，这一篇文章简要通过两个流程图来说明一下整个项目的大体流程。

二、脚本安装流程

当执行 python3 main.py 安装哪吒 dashboard 或者 agent 时，会进入到如下流程：

三、crontab 进程监控和主机间保活

安装完成后，会生成一个 crontab，通过这个 crontab 来监控哪吒 dashboard 或者 agent 以及自定义的进程，保持进程处于运行状态。

当进程被 serv00 或者 ct8 主机自动 kill 掉时（使用 PM 2 脚本被 kill 的概率很大），能够自动重新拉起进程。

最后会通过ssh私钥登录其它主机，并执行保活脚本，保证所有主机的哪吒进程都处于运行状态。

四、其它

整个项目开发采用 python3 + shell 的方式，其中 python 用于主要逻辑处理，shell 主要用于一些简单的命令操作。

serv00和ct8主机一键安装哪吒探针和多主机保活

2024-08-25T10:10:00+08:00

一、背景

基于 serv00 和 ct8 这种配置较低的主机，比较适合用来做探针。目前还没发现能自动安装哪吒面板和 agent 客户端的脚本，以及多主机间动态保活，所以写了这个 github 项目: https://github.com/vfhky/serv00_ct8_nezha。

二、特点

1、支持分别安装最新版本的哪吒dashboard和agent客户端，且安装时基本一路点确认即可，无需复杂操作；
2、弃用PM2，使用脚本进行进程监控，尽量避免被serv00或者ct8杀掉；
3、自动生成crontab，实现进程监控和主机保活；
4、对于多个主机，可以实现相互保活；
5、多个主机之间的通信，使用ssh公私钥，无需暴露主机密码；
6、支持 青龙面板 或者其它云主机对自己的serv00或者ct8主机进行进程监控和保活；
7、支持自定义进程保活，例如自己写的任何一个服务，可以在monitor.conf配置文件中简单配置即可；
8、支持企业微信机器人、企业微信app应用、tg、pushPlus等监控通知；
9、自动备份哪吒dashboard面板数据库到 七牛云存储、腾讯云cos、阿里云oss 这三种云存储平台。

三、使用步骤

1、下载脚本: git clone https://github.com/vfhky/serv00_ct8_nezha.git
2、进入项目: cd serv00_ct8_nezha
3、修改配置文件: vim config/host.eg 然后添加需要保活的主机信息。
4、开始安装: python3 main.py 。

四、配置文件说明

在config配置目录下面有4个模板文件，其中host.eg和sys.eg这两个配置文件是需要手工配置，其它两个文件都不需要修改，系统会自动根据相关逻辑生成对应的xxx.conf配置文件。

4.1 主机配置模板 host.eg

host.eg模板文件是填写需要保活的主机信息。例如当前要保活另外一个s9的serv00机器(用户名是vhub)，那么填写：

s9.serv00.com|22|vhub|password

4.2 系统常量模板 sys.eg

这个是系统配置文件，可以配置企业微信机器人、tg、pushPlus 等监控通知等功能。

4.3 进程监控模板 monitor.eg

用于进程监控：当进程不存在时（例如被serv00系统自动杀掉），会自动重新拉起进程。当安装完哪吒dashboard和agent后，系统会自动生成类型以下的配置。当然也可以手工追加其它进程来实现该进程的监控保活。

/home/vfhky/nezha_app/agent|nezha-agent|sh nezha-agent.sh|foreground
/home/vfhky/nezha_app/dashboard|nezha-dashboard|./nezha-dashboard|background

4.4 多主机心跳保活模板 heartbeat.eg

当手工配置了host.eg主机模板并手工执行安装后，系统会根据这个模板自动生成主机需要保活的主机信息。示例如下：

s9.serv00.com|22|vhub

五、安装过程记录

下面是安装过程的一些截图：

六、监控消息推送

项目支持企业微信机器人、企业微信 app 应用、tg、pushPlus 等推送方式。推送效果如下：

6.1 企业微信机器人：

6.2 企业微信 app 应用：

注意，企业微信应用需要在企微后台设置 企业可信IP，也就是需要添加 serv00 或者 ct8 主机的 ip，否则会报错：

{"errcode":60020,"errmsg":"not allow to access from your ip, hint: [1724584289591812691117273], from ip: 你的serv00主机ip, more info at https://open.work.weixin.qq.com/devtool/query?e=60020"}

6.3 TG通知：

七、架构说明

下一篇文章会简单说一下业务架构，详见：serv00和ct8主机一键安装哪吒探针和多主机保活(二) - TypeCodes

在serv00主机上安装哪吒探针

2024-07-28T15:10:00+08:00

一、探针

前段时间申请了 serv00 主机一直闲置没有用，但是这个主机的配置比较低（512 M 内存），所以准备用来装个工具类的小应用。

之前使用 Uptime Kuma 创建了一个比较全能的探针：web monitor ，看着哪吒探针使用量也比较大，于是选择在 server00 主机上安装了一下。

二、操作步骤

1、安装 pm2 管理器

用过 NodeJs 的对 pm2 应该比较熟悉，常用于创建进程守护、进程监控、日志查看等。

bash <(curl -s https://raw.githubusercontent.com/k0baya/alist_repl/main/serv00/install-pm2.sh)

2、server00 开启自定义应用

在 server00 的 panel 控制面板 Zaloguj się 中把 run you own application 设置成 enable 。

3、server00 开放端口

同样在 server00 的 panel 控制面板 Zaloguj się 中新增 10087 和 10089 这两个监听端口，分别用于哪吒的 dashboard 和 agent 通信端口。

4、server00 设置哪吒 dashboard 代理

同样在 server00 的 panel 控制面板 Zaloguj się 中，新增域名 status.vfhky.serv00.net （前缀可任意），端口选择前面开放的 10087 端口。

5、github 上申请一个 app 授权应用

由于哪吒面板的管理界面需要使用 github 等 OAuth 方式，所以得先去 github 申请一个授权应用。

以下步骤是根据官方文档：安装 Dashboard | 哪吒服务器监控整理的：

# 1、登录 https://github.com/settings/developers  ，依次选择“OAuth Apps” - “New OAuth App”。
# 2、Application name - 任意命名。
# 3、Homepage URL - 面板的访问域名。这里就是前面设置的server00的dashboard代理：https://status.vfhky.serv00.net 。
# 4、Authorization callback URL - 填写回调地址。也即： https://status.vfhky.serv00.net/oauth2/callback（不要忘记/oauth2/callback）。
# 5、点击 “Register application”。
# 6、复制并保存页面中的 Client ID。
# 7、点击 “Generate a new client secret”，创建一个新的 Client Secret，复制并保存。

6、开始安装哪吒 dashboard 面板

$ cd ~
git clone https://github.com/naiba/nezha.git
cd ~/nezha/cmd/dashboard
go build -ldflags="-s -w --extldflags '-static -fpic' -X github.com/naiba/nezha/service/singleton.Version=0.18.8"
mkdir ~/nezhapanel && cd ~/nezhapanel && cp ~/nezha/cmd/dashboard/dashboard ~/nezhapanel/dashboard 
    && cp -r ~/nezha/resource ~/nezhapanel/resource && rm ~/nezhapanel/resource/resource.go && mkdir ~/nezhapanel/data \
    && cp ~/nezha/script/config.yaml ~/nezhapanel/data/config.yaml

sed -i -e "s@^httpport: 80@httpport: 10087@g" -e "s@nz_language@zh-CN@g" \
    -e "s@nz_grpc_port@10089@g" -e "s@nz_oauth2_type@github@g"   ~/nezhapanel/data/config.yaml

### 注意修改下面的管理员账号，github授权的id和密钥
sed -i -e "s@nz_admin_logins@vfhky@g" -e "s@nz_github_oauth_client_id@github的ClientId@g" \
    -e "s@nz_github_oauth_client_id@github的Client Secret@g"   ~/nezhapanel/data/config.yaml

### 启动面板程序
cd ~/nezhapanel && chmod +x ./dashboard
pm2 start ./dashboard
pm2 save

7、开始安装哪吒客户端应用

这一步是非必选的，只是用于演示监控 server00 主机的状态。由于官方已经发布了 agent 编译后的二进制文件 Release v0.18.8 · nezhahq/agent · GitHub，所以下面就直接使用这个文件了。

注意，serv00 应该选择 nezha-agent_freebsd_amd64.zip 这个包，其它常用的 64 位 linux 系统下载 nezha-agent_linux_amd64.zip 即可。

$ cd  ~
mkdir -p ~/nezha-agent
wget -c https://github.com/nezhahq/agent/releases/download/v0.18.8/nezha-agent_linux_amd64.zip
unzip nezha-agent_linux_amd64.zip

8、登录 dashboard 新增服务器

登录哪吒 dashboard 管理界面，在 服务器 菜单下选择 新增服务器，然后点击一键安装或者右侧的编辑按钮，可以得到一个这个客户端的密钥。

接着使用 ssh 登录到 server00，并创建启动脚本 start.sh：

$ cd ~/nezha-agent/

### 客户端的启动脚本，注意替换为自己的目录和域名、密钥等。
cat > start.sh << EOF

#!/bin/sh

mkdir -p ~/tmp
export TMPDIR=~/tmp

/home/vfhky/nezha-agent/nezha-agent -s status.vfhky.serv00.net:10089 -p 客户端的密钥 -d

EOF

### 启动客户端
$ pm2 start start.sh

9、查看哪吒 dashboard 和 agent 客户端启动情况

当安装完后，可能通过 pm2 status 命令查看面板和 agent 的启动情况，也可以通过 pm2 logs dashboard 查看日志。

正常来说两者的 status 状态都是 online，此时访问面板首页 https://status.vfhky.serv00.net/ 即可看到 server00 主机客户端的情况了。

一款基于typecho官网的pelican主题

2024-05-08T20:10:00+08:00

一、主题说明

一款用于 pelcian 博客的主题，移植自 Typecho 官网的皮肤，所以取名为 pelican-typecho。

同时也支持谷歌站内搜索、disqus 评论等，目前我自己的博客也在用，欢迎大家体验。

二、目录结构

.
├── Makefile                # pelican官方文件
├── ReadMe.md
├── autoGenAndPublish.sh    # 用于自动构建的脚本。如果你未使用自己的构建平台，该文件可以忽略。
├── content                 # 用于存放favicon等文件，以及存放md文档目录。
├── develop_server.sh       # pelican官方文件
├── fabfile.py              # pelican官方文件
├── pelican-themes          # pelican的主题目录。下面的 pelican-typecho 即是当前博客使用的主题。
├── pelicanconf.py          # pelican的配置文件。按需修改
├── publishconf.py          # pelican官方发布文件
└── tools                   # 用于pygments生产代码高亮的样式

三、使用方法

3.1 安装 pelican 所有的环境

这里以 ubuntu 系统为例：

apt install -y make python3-pip \
    && pip3 install --upgrade pip \
    && pip3 install --upgrade --default-timeout=100 install tzdata pelican \
        markdown pelican-sitemap Pygments minchin.pelican.plugins.summary \
        -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com

3.2 编译生成博客

把自己的markdown文件放在content/articles目录下，然后在根目录执行 make publish 即可生成博客html文件。

四、下载地址

目前把主题放在 github 上了，欢迎点击体验。

给博客(pelican)增加git提交和自动构建信息

2024-05-04T15:10:00+08:00

一、pelican 的构建和生成：

博客使用的是 pelican 开源静态博客系统，之前每次生成 html 代码都需要手动在服务器上用脚本生成的。也就是每次新增或者修改了文章都需要手工去执行脚本，然后发布到 nginx 目录。

鉴于每次的生成流程过于繁琐，所以最近考虑把博客的生成过程改用自动构建，同时在博客底部栏增加 git commit 和 自动构建 的信息。效果如下：

二、大体的开发流程

由于博客的 pelican 代码和 pelican 的文章是分开来托管的，所以在自动构建的时候需要分别拉取这两个 git 项目，然后再把文章按照 pelican 的生成要求放在 content/articles 目录下面。

### 1、修改pelican的配置和模板文件
修改pelican的配置文件：pelican.conf 和 模板文件：footer.html，以便支持git commit 和 自动构建的信息数据。

### 2、博客文章变动
当博客新增或者修改文章后，会提交到github的仓库。由于设置了webHook，所以会通知自己的cicd服务后台进行构建

### 3、自动构建后台
自动构建后台收到github的commit通知后，触发自动构建：先拉取pelican的代码（包括了博客当前的pelican主题），然后准备pelican构建的环境。

apt install -y make python3-pip && pip3 install --upgrade pip && pip3 install --upgrade --default-timeout=100 install tzdata pelican markdown pelican-sitemap Pygments minchin.pelican.plugins.summary -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com && sh autoGenAndPublish.sh "${CICD_WORKING_DIR}" "${GITHUB_TOKEN}" "${CICD_BUILD_ID}"

### 4、构建脚本 autoGenAndPublish.sh
在pelican根目录创建一个shell构建脚本，传入了当前自动构建的根目录(也就是pelican代码所在的根目录)、github的token用于拉取文章仓库和本次构建的id。

代码的大体逻辑：先拉取博客文章到pelican的`./content/articles`目录，然后获取git commit的id和时间信息，接着获取本次自动构建的id和日期，最后更改pelican.conf配置代码中的变量，最后通过pelican命令生成html代码并打包成blog.tar.gz。

### 5、由构建系统分发到业务机器
构建系统分发到业务机器后，会执行一个shell脚本，用于把打包的blog.tar.gz博客代码解包并发布到nginx目录上面即可。

三、具体的代码

上面的流程会涉及到下面几个主要的代码逻辑：

3.1 修改主题代码

在 pelican 主题下面的 footer.html 代码中增加 git commit 和自动构建信息的数据：

# 配置是否定义了COMMIT_ID，且不为空值
{%- if COMMIT_ID -%}
    # 配置是否定义了COMMIT的图标，且不为空值
    {%- if COMMIT_ICON -%}
        <img class="image" src="{{ COMMIT_ICON }}"> 
    {%- endif -%}
    # 展示commitId 和 commit date
    <b> commit:</b> <em>  {{ COMMIT_ID[0:7] }}</em>
    {%- if COMMIT_DATE -%}
        <em>-{{ COMMIT_DATE }}  </em>
    {%- endif -%}
     &nbsp 
    # 展示构建id 和 构建 date
    {%- if BUILD_ID -%}
        <b> build:</b> <em>{{ BUILD_ID[0:7] }}</em>
        {%- if BUILD_DATE -%}
            <em>-{{ BUILD_DATE }}</em>
        {%- endif -%}
    {%- endif -%}
{%- endif -%}

3.2 修改 pelican.conf 配置文件

在配置文件中增加以下定义数据，最后会在自建构建的时候修改变量的值，最终会填充到上面的 footer.html 代码中。

# 底部栏git相关
COMMIT_ID = ''
COMMIT_ICON = 'https://cdn.typecodes.com/libs/img/git.png'
COMMIT_DATE = ''
# 底部栏构建相关
BUILD_ID = ''
BUILD_DATE = ''

3.3 构建脚本 autoGenAndPublish.sh

在 pelican 主题代码中新增一个 autoGenAndPublish.sh 的 shell 脚本。

#!/bin/bash
# pelican编译并打包
# (c) 2024.5.4 vfhky https://typecodes.com/mix/pelicanaddgitcommitcicdinfo.html
# Simple Usage:  sh autoGenAndPublish.sh /home/typcodes/github/tp_code github_token "#abcded"


if [ $# -ne 3 ]; then
  echo "pelican编译脚本必须输入构建路径参数"
  exit 1
fi


# 根路径
WORKING_DIR=$1
GITHUB_TOKEN=$2
# 构建id
BUILD_ID=$3
BUILD_DATE=$(date +%Y.%m.%d)

# github commitId
COMMIT_ID=''
COMMIT_DATE=''

# target
TARGET='blog.tar.gz'
PELICAN_CONF='pelicanconf.py'

# 修改配置文件
replaceGitAndBuildInfo() {
    if [ ! -e "${PELICAN_CONF}" ]; then
        echo "配置文件${PELICAN_CONF}不存在"
        exit 0
    fi

    sed -i "s/COMMIT_ID = ''/COMMIT_ID = '$1'/" "${PELICAN_CONF}"
    sed -i "s/COMMIT_DATE = ''/COMMIT_DATE = '$2'/" "${PELICAN_CONF}"
    sed -i "s/BUILD_ID = ''/BUILD_ID = '$3'/" "${PELICAN_CONF}"
    sed -i "s/BUILD_DATE = ''/BUILD_DATE = '$4'/" "${PELICAN_CONF}"
}


cd "${WORKING_DIR}" \
&& rm -rf ./content/articles \
&& mkdir -p ./content/articles \
&& cd ./content/articles \
&& git clone -b master "https://${GITHUB_TOKEN}:x-oauth-basic@github.com/vfhky/article.git" . \
&& COMMIT_ID=$(git rev-parse --short HEAD) \
&& COMMIT_DATE=$(git log -1 --format=%cd --date=format:'%Y.%m.%d') \
&& cd "${WORKING_DIR}" || exit

# 修改配置文件
replaceGitAndBuildInfo "${COMMIT_ID}" "${COMMIT_DATE}" "${BUILD_ID}" "${BUILD_DATE}"

# 编译并打包
make publish \
&& tar -zcf "${TARGET}" -C output/ .

使用ChatGPT对GitHub项目进行CodeReview

2023-09-01T22:47:00+08:00

前段时间兴起的 ChatGPT 热，跟风研究了一些应用方向。七月份的时候刚好自己打算写一个简易的 redis sentinel 数据解析的服务端项目，于是想用 ChatGPT 的对话模式来对提交的 git 代码进行 review。将近两个月使用下来，自己觉得 review 效果还不错。

1 实现逻辑

已知 GitHub 自带了 Webhooks 功能，每次 git push 提交代码等操作都会触发钩子函数。这就给了很多的业务发挥空间，例如自动发布等。

Webhooks allow external services to be notified when certain events happen. When the specified events happen, we’ll send a POST request to each of the URLs you provide. Learn more in our [Webhooks Guide](https://docs.github.com/webhooks/).

这里我主要是在自己的服务器上建立了一个 http 服务，接收 Webhooks 触发的 json 通知，然后异步拉取本次 push 的 commit 内容，再使用 ChatGPT 的 gpt-3.5-turbo 模型进行 review，最后把对话结果写入到该 commit 的 comment 中。

2 CodeReview 效果

通过 ChatGPT 的 gpt-3.5-turbo 模型的 review 效果还可以，以其中的一个 commit 的 review 结果为例。本意是判断 https 监听服务创建是否成功，但是代码写成了 NULL == http 判断的是 http 监听服务创建的结果。所以通过 review 可以很快的进行修正，即写成 NULL == https。

// create https server
struct evhttp *https = EventHttpsServer::instance().createHttpsServer(base);
if (NULL == http) {
    return -4;
}

在 github 项目的 commit 记录里面可以看到这里的评论就是 review 的数量。

3 其它

这个 github 项目地址是 GitHub - vfhky/socketRedisSentinel: tcp原生通信从redis的sentinel域名解析数据，大家可以访问看看效果。另外这个 C++项目功能是创建了一个 Linux 服务端来解析 redis sentinel 服务返回的主从分片 redis 分片信息，例如 master 或者 slave 的 redis 的 ip 和端口，然后返回给客户端。主要是通过 Libvent + OpenSSL 库实现的，支持 tcp 、http 和 https 这三种客户端请求方式。

感兴趣的可以一起讨论下。

Linux C/C++工程中可生成 ELF、动/静态库文件的通用 Makefile（二）

2023-06-04T10:27:00+08:00

今天对之前写的 Linux C/C++工程中可生成ELF、动/静态库文件的通用Makefile - TypeCodes 文章里面的 Makefile 进行了优化，增加了在当前目录生成单个可执行文件的功能。

1 功能说明

之前已有的功能不再赘述，这次主要是在包含多个 cpp 文件的项目中生成一个可执行文件（之前只能一个 cpp 或者 c 文件生成对应的一个可执行文件）。

如上图所示，我的一个 myRedisSentinel 目录中包含了多个 cpp 文件，然后只要在 SINGLE_BIN 里面配置想要输出的可执行文件名称，最后执行 make -j4 命令即可生成。

2 附录：Makefile 文件源码

已将下面的 Makefile 源文件托管到 github仓库中：

1、GitHub： https://github.com/vfhky/General_Makefile ；

##################################################################
#
# FILENAME   :  Makefile
# DESCRIPT   :  A general makefile to generate an ELF or a
#                   dynamic or a static library for C/C++ project.
# AUTHOR     :  vfhky  2015.08.07
# URI        :  https://typecodes.com/cseries/cppgeneralmakefile.html
#
##################################################################

.PHONY: all clean help
all: 

# Some important on-off settings. You can not be too careful about them.
DEBUG           := y
# Flag of generate a dynamic lib or a static lib: y means yes. If the target is a excutable file, it should be blank!
GEN_LIBS        := y
# Flag of generate a dynamic lib: y means yes. It should be blank unless you want to generate a dynamic lib!
GEN_DYN_LIB     := y
# generate a single target bin file.Please let it be blank unless the target is a excutable file.
SINGLE_BIN      :=
# generate mutil target bin files.Please let it be blank unless the target is a excutable file.
MUTIL_BIN       :=
# Name of the static lib. It should be blank unless the target is a static lib, then the GEN_LIBS is y and GEN_DYN_LIB is blank.
# STATIC_LIBS       := libsrcpbl.a
# Name of the dynamic lib. It should be blank unless the target is a dynamic lib, then the GEN_LIBS is y and GEN_DYN_LIB is y.
DYNAMIC_LIBS    := libsrcpbl.so

# Environment settings. The value of PROJECT_DIR shoule be set in the *nix system as the the absolute dir path of your project.
# PROJECT_DIR   := /home/test_usr
#CURDIR         := $(PROJECT_DIR)/src/pbl
CURDIR          := $(shell pwd)
PRG_BIN_DIR     := $(PROJECT_DIR)/bin
PRG_LIB_DIR     := $(PROJECT_DIR)/lib
PRG_INC_DIR     := $(PROJECT_DIR)/include

# Cross compile tools defined. You needn't modify these vars below generally.
AS      := as
LD      := ld
CC      := gcc
CXX     := g++
CPP     := $(CC) -E
AR      := ar rcs
NM      := nm
STRIP   := strip
RANLIB  := ranlib
STD_OPT := -D_GNU_SOURCE
CC      += -std=c99 $(STD_OPT)
CXX     += $(STD_OPT)

# *nix system tools defined. You needn't modify these vars below generally.
BLACK = "\e[33;0m"
RED  =  "\e[31;1m"
GREEN = "\e[32;1m"
YELLOW = "\e[33;3m"
BLUE  = "\e[34;1m"
PURPLE = "\e[35;1m"
CYAN  = "\e[36;1m"
WHITE = "\e[37;1m"
CP      := cp
SED     := sed
FIND    := find
MKDIR   := mkdir -p
XARGS   := xargs
MV      := mv
RM      := rm -rf


# Get .c, .cpp source files by searching from current directory.
CUR_SRC_DIR = $(shell ls -AxR $(CURDIR)|grep ":"|tr -d ':')
CUR_SRC     := $(foreach subdir,$(CUR_SRC_DIR),$(wildcard $(subdir)/*.c $(subdir)/*.cpp))
#CUR_SRC    := $(shell find . -name "*.c" -o -name "*.cpp"|sed -e 's,./,,')
CUR_C       := $(filter %.c, $(CUR_SRC))
CUR_CPP     := $(filter %.cpp, $(CUR_SRC))

# Get the include files, object files, dependent files by searching from PRG_INC_DIR.
CUR_INC_DIR = $(shell ls -AxR $(PRG_INC_DIR)|grep ":"|tr -d ':')
CUR_INC     := $(foreach subdir,$(CUR_INC_DIR),$(subdir)/*.h)
SRC_H       := $(filter %.h, $(CUR_INC))
#CUR_OBJ    := $(addprefix $(PRG_BIN_DIR)/,$(strip $(CUR_CPP:.cpp=.o) $(CUR_C:.c=.o)))
#CUR_OBJ    := $(addprefix $(PRG_BIN_DIR)/,$(notdir $(CUR_CPP:.cpp=.o) $(CUR_C:.c=.o)))
CUR_OBJ     := $(strip $(CUR_CPP:.cpp=.o) $(CUR_C:.c=.o))
#CUR_DEP    := $(addprefix $(PRG_BIN_DIR)/,$(notdir $(CUR_CPP:.cpp=.d) $(CUR_C:.c=.d)))
CUR_DEP     := $(strip $(CUR_CPP:.cpp=.d) $(CUR_C:.c=.d))

# Create directory in the header files, bin and library directory.
$(foreach dirname,$(sort $(PRG_INC_DIR) $(PRG_BIN_DIR) $(PRG_LIB_DIR)),\
  $(shell $(MKDIR) $(dirname)))

# Complie and link variables. LD_LIBS means the dynamic or static library needed for the object file.
CFLAGS      := $(if $(DEBUG),-g -Wall, -O2 -Wall)
CFLAGS      += $(if $(GEN_DYN_LIB), $(addprefix -fPIC -I ,$(sort $(dir $(SRC_H)))), $(addprefix -I ,$(sort $(dir $(SRC_H)))))
CXXFLAGS    = $(CFLAGS)
LDFLAGS     := 
LD_LIB_DIR  := #-L $(PRG_LIB_DIR)
LD_LIBS     := #-lsrcpbl -lmysqlclient
XLD_FLG     := -Xlinker "-(" $(LDFLAGS) -Xlinker "-)"

# Add vpath.
vpath %.h $(sort $(dir $(SRC_H)))
vpath %.c $(sort $(dir $(CUR_C)))
vpath %.cpp $(sort $(dir $(CUR_CPP)))

# Generate depend files.
ifneq "$(MAKECMDGOALS)" "clean"
sinclude $(CUR_DEP)
endif

# Gen_depend(depend-file,source-file,object-file,cc). This command-package is used to generate a depend file with a postfix of .d.
define gen_depend
  @set -e;                                      \
  $(RM) $1;                                     \
  $4 $(CFLAGS) -MM $2 |                         \
  $(SED) 's,\($(notdir $3)\): ,$3: ,' > $1.tmp; \
  $(SED) -e 's/#.*//'                           \
         -e 's/^[^:]*: *//'                     \
         -e 's/ *\\$$//'                        \
         -e '/^$$/ d'                           \
         -e 's/$$/ :/' < $1.tmp >> $1.tmp;      \
  $(MV) $1.tmp $1;
endef

# Rules to generate objects file(.o) from .c or .cpp files.
$(CURDIR)/%.o: $(CURDIR)/%.c
    @$(call gen_depend,$(patsubst %.o,%.d,$@),$<,$@,$(CC))
    $(CC) $(CFLAGS) -o $@ -c $<

$(CURDIR)/%.o: $(CURDIR)/%.cpp
    @$(call gen_depend,$(patsubst %.o,%.d,$@),$<,$@,$(CXX))
    $(CXX) $(CXXFLAGS) -o $@ -c $<

# Gen_excbin(target,CUR_OBJ,cc). This command-package is used to generate a excutable file.
define gen_single_excbin
  ULT_SINGLE_BIN += $(PRG_BIN_DIR)/$1
  $(PRG_BIN_DIR)/$1: $2
    $3 $(LDFLAGS) $$^ $(LD_LIB_DIR) $(LD_LIBS) $(XLD_FLG) -o $$@
    @echo -e $(YELLOW)"========================Success========================"$(BLACK)
endef

# Gen_excbin(target,CUR_OBJ,cc). This command-package is used to generate a excutable file.
define gen_mutil_bin
  ULT_MUTIL_BIN += $(PRG_BIN_DIR)/$1
  $(PRG_BIN_DIR)/$1: $2
    $3 $(LDFLAGS) $$^ $(LD_LIB_DIR) $(LD_LIBS) $(XLD_FLG) -o $$@
    @echo -e $(YELLOW)"========================Success========================"$(BLACK)
endef

# Gen_libs(libs,CUR_OBJ,cc). This command-package is used to generate a dynamic lib or a static lib.
define gen_libs
  ULT_LIBS += $(PRG_LIB_DIR)/$1
  $(PRG_LIB_DIR)/$1: $2
    $3 $(if $(GEN_DYN_LIB),-shared $$^ $(CXXFLAGS) $(LD_LIB_DIR) $(LD_LIBS) $(XLD_FLG) -o $$@,$$@ $$^)
    @echo -e $(YELLOW)"========================Success========================"$(BLACK)
endef

# Call gen_single_excbin to generate an excutale file.
$(foreach bin,$(SINGLE_BIN),$(eval $(call gen_single_excbin,$(bin),$(CUR_OBJ),$(CXX))))

# Call gen_mutil_bin to generate mutil excutale files.
$(foreach bin,$(MUTIL_BIN),$(eval $(call gen_mutil_bin,$(bin),$(CURDIR)/$(bin).o,$(CXX))))

# Call gen_libs to generate a dynamic lib.
$(foreach lib,$(DYNAMIC_LIBS),$(eval $(call gen_libs,$(lib),$(CUR_OBJ),$(CXX))))

# Call gen_libs to generate a static lib.
$(foreach lib,$(STATIC_LIBS),$(eval $(call gen_libs,$(lib),$(CUR_OBJ),$(AR))))


all: $(ULT_SINGLE_BIN) $(ULT_MUTIL_BIN) $(ULT_LIBS)


clean:
    -$(FIND) $(CURDIR) -name "*.o" -o -name "*.d" | $(XARGS) $(RM)
    -$(RM) $(ULT_SINGLE_BIN) $(ULT_MUTIL_BIN) $(ULT_LIBS)


help:
    @echo CC=[$(CC)]
    @echo CXX=[$(CXX)]
    @echo CFLAGS=[$(CFLAGS)]
    @echo CXXFLAGS=[$(CXXFLAGS)]
    @echo PROJECT_DIR=[$(PROJECT_DIR)]
    @echo CURDIR=[$(CURDIR)]
    @echo PRG_BIN_DIR=[$(PRG_BIN_DIR)]
    @echo PRG_LIB_DIR=[$(PRG_LIB_DIR)]
    @echo PRG_INC_DIR=[$(PRG_INC_DIR)]
    @echo CUR_SRC_DIR=[$(CUR_SRC_DIR)]
    @echo CUR_SRC=[$(CUR_SRC)]
    @echo CUR_C=[$(CUR_C)]
    @echo CUR_CPP=[$(CUR_CPP)]
    @echo CUR_OBJ=[$(CUR_OBJ)]
    @echo CUR_DEP=[$(CUR_DEP)]
    @echo STATIC_LIBS=[$(STATIC_LIBS)]
    @echo DYNAMIC_LIBS=[$(DYNAMIC_LIBS)]

utuntu22.04安装含brotli模块的Ningx

2023-05-29T22:10:00+08:00

一、更新源：

cp /etc/apt/sources.list /etc/apt/sources.list.bak

### 替换成阿里云的源
sudo bash -c "cat << EOF > /etc/apt/sources.list && apt update 
deb http://mirrors.aliyun.com/ubuntu/ jammy main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ jammy main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ jammy-security main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ jammy-security main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ jammy-updates main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ jammy-updates main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ jammy-proposed main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ jammy-proposed main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ jammy-backports main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ jammy-backports main restricted universe multiverse
EOF"

### 重启
reboot

### 更新
apt update -y && apt upgrade && apt install dpkg-dev

二、开始安装 nginx 和 brotli

### 安装nginx
apt install nginx
systemctl enable nginx.service

### 编译brotli
apt source nginx && apt build-dep nginx
git clone --recursive https://github.com/google/ngx_brotli.git
cd nginx-1.18.0 && ./configure --with-compat --add-dynamic-module=../ngx_brotli && make modules

### 库文件
cp ./objs/*.so /usr/share/nginx/modules
vim /usr/share/nginx/modules-available/mod-http-brotli.conf
load_module modules/ngx_http_brotli_filter_module.so;
load_module modules/ngx_http_brotli_static_module.so;

cd /etc/nginx/modules-enabled && ln -s /usr/share/nginx/modules-available/mod-http-brotli.conf 50-mod-http-brotli.conf

### brolit 配置文件
vim /etc/nginx/conf.d/brotli.conf
# Enable Brotli
brotli            on;
brotli_static     on;
brotli_comp_level 6;

# File types to compress
brotli_types application/atom+xml application/javascript application/json application/rss+xml
             application/vnd.ms-fontobject application/x-font-opentype application/x-font-truetype
             application/x-font-ttf application/x-javascript application/xhtml+xml application/xml
             font/eot font/opentype font/otf font/truetype image/svg+xml image/vnd.microsoft.icon
             image/x-icon image/x-win-bitmap text/css text/javascript text/plain text/xml;

三、验证

### 重启nginx
systemctl restart nginx

### 验证，出现 content-encoding: br 表示生效
root@VM-0-12-ubuntu:~# curl -H 'Accept-Encoding: br' -I https://typecodes.com
HTTP/2 200 
server: nginx
date: Wed, 03 May 2023 16:21:44 GMT
content-type: text/html; charset=utf-8
last-modified: Fri, 03 Mar 2023 09:25:39 GMT
vary: Accept-Encoding
etag: W/"6401bd13-412d"
strict-transport-security: max-age=31536000; includeSubdomains;preload
x-frame-options: DENY
x-content-type-options: nosniff
public-key-pins: pin-sha256="YLh1dUR9y6Kja30RrAn7JKnbQG/uEtLMkBgFF2Fuihg="; pin-sha256="aef6IF2UF6jNEwA2pNmP7kpgT6NFSdt7Tqf5HzaIGWI="; max-age=2592000; includeSubDomains
cache-control: no-cache
content-security-policy: default-src disqus.com disquscdn.com; script-src 'unsafe-inline' 'unsafe-eval' blob: https:; img-src 'self' https: hm.baidu.com disqus.com; style-src 'unsafe-inline' https:; child-src https:; connect-src 'self' https: hm.baidu.com disqus.com; frame-src https://disqus.com
content-encoding: br

root@VM-0-12-ubuntu:~#

使用shell脚本导出MySql查询的月表数据到EXCEL中

2020-08-02T22:10:00+08:00

经常会踫到这样的场景需求：自定义时间从MySql流水月表中SELECT出来数据到excel报表文件中，所以自己写了这个shell脚本来处理。

1 实现思路

代码比较简单，主要使用了mysql -e执行SQL语句，然后重定向到txt文件中。由于linux默认是uft-8的格式，所以在使用awk命令处理完txt文件后，通过iconv命令把utf8的文件转换成最终的gbk文件。

2 脚本代码

鉴于数据量比较大，我们的shell脚本需要考虑MySQL执行INSERT的效率，所以采用了对次数取模拼接多个VALUES的值来实现。

#!/bin/bash
# FileName:      exportmysqlshell1.sh
# Description:   使用shell脚本导出MySql月表数据到EXCEL中
# Simple Usage:  sh exportmysqlshell1.sh
# (c) 2020.08.01 vfhky https://typecodes.com/linux/exportmysqlshell1.html
# https://github.com/vfhky/shell-tools/blob/master/mysql/exportmysqlshell1.sh

if [[ $# -ne 2 ]]; then
    echo "usage: sudo $0 startTimeStamp endTimeStamp"
    exit 0
fi

startTimeStamp=$1
endTimeStamp=$2

# 简单校验合法性
if [[ "${startTimeStamp}" -ge "${endTimeStamp}" ]]; then
    echo "${startTimeStamp} >= ${endTimeStamp}."
    exit 1
fi

# 获得月表后缀
startYearMonth=$(date -d @"${startTimeStamp}"  "+%Y%m")
endYearMonth=$(date -d @"${endTimeStamp}"  "+%Y%m")
if [[ "${startYearMonth}" -ne "${endYearMonth}" ]]; then
    echo "${startYearMonth} is not equalt to ${endYearMonth}."
    exit 2
fi

curDateTime=$(date "+%Y-%m-%d %H:%M:%S")
timeStamp=$(date -d "$current" +%s)

dstFilePrefix="gather_rcd_"${startTimeStamp}"_"${endTimeStamp}"_"${timeStamp}
dstFile=${dstFilePrefix}"_gbk.csv"
dstFileUtf8Txt=${dstFilePrefix}"_utf8.txt"
dstFileUtf8Csv=${dstFilePrefix}"_utf8.csv"
echo ${curDateTime}","${timeStamp}","${dstFile}

# mysql命令导出查询结果到txt文件中
mysql -h113.16.111.17 -P3301 -utest_user -p12345678 activity --default-character-set=utf8 -A -e "SELECT uid, FROM_UNIXTIME(createtime,'%Y-%m-%d %H:%i:%s') as createTime, ispush from test_log_${startYearMonth} WHERE createtime>=${startTimeStamp} AND createtime<=${endTimeStamp};" > ${dstFileUtf8Txt}
if [[ $? -ne 0 ]]; then
    echo "== mysql query failed =="
    exit 3
fi

# 注意是3个字段，但是createTime值自带了1个空格
awk -F " " '{if(NR==1){print $1",",$2",", $3}else{print $1",",$2" "$3",", $4}}' ${dstFileUtf8Txt} > ${dstFileUtf8Csv}
if [[ $? -ne 0 ]]; then
    echo "== handle file failed =="
    exit 4
fi

# utf-8转换成gbk格式
iconv -f utf8 -t gb2312 -o ${dstFile} ${dstFileUtf8Csv}
if [[ $? -ne 0 ]]; then
    echo "== iconv failed =="
else
    echo "== iconv success. =="
fi

3 脚本管理

目前已经把这个脚本放在Github了，地址是https://github.com/vfhky/shell-tools，以后脚本的更新或者更多好用的脚本也都会加入到这个工程中。

使用shell脚本批量插入数据到MySQL中

2020-04-15T22:10:00+08:00

经常会踫到这样的场景需求：批量向MySQL数据库插入数据，显然手工INSERT成千上万条数据是不现实的，所以自己写了这个shell脚本来处理。

1 具体需求

shell脚本批量插入10万条数据到MySQL中，其中对应表唯一索引是用户uid。因此在程序循环1万次数时，每次都使uid自增1就行了。

2 脚本代码

鉴于数据量比较大，我们的shell脚本需要考虑MySQL执行INSERT的效率，所以采用了对次数取模拼接多个VALUES的值来实现。

#!/bin/bash
# FileName:      batchinsertmysqlshell1.sh
# Description:   使用shell脚本批量插入数据到MySQL中
# Simple Usage:  sh batchinsertmysqlshell1.sh
# (c) 2020.04.15 vfhky https://typecodes.com/linux/batchinsertmysqlshell1.html
# https://github.com/vfhky/shell-tools/blob/master/mysql/batchinsertmysqlshell1.sh

# mysql db name.
db_name="gamedata"
# mysql table name.
table_name="test_user_skin"


beginTime=$(date "+%Y-%m-%d %H:%M:%S")
echo "==== ${beginTime} ===="

# logic begin.
index=0
# uid in [3000000,4999999].
for uid in {3000000..4999999}
do
    if [ `expr ${index} % 1000` -ne 0 ]; then
        insertValues+=",("${uid}",'2020-04-09 08:08:08')"
        index=$(( $index + 1 ))
    else
        index=1
        if [ -n "$insertValues" ]; then
            #echo "${insertValues}"
            # INSERT INTO `gamedata`.`test_user_skin`(`id`, `uid`, `due_time`, `create_time`, `update_time`, `extend`) VALUES (1156, 1007200, '2020-04-09 10:11:11', '2020-04-07 10:11:11', '2020-04-07 10:11:11', '');
            mysql -h11.36.122.55 -P6302 -utestuser -p123qwe -e "INSERT INTO ${db_name}.${table_name}(uid,due_time) values ${insertValues}"
        fi
        insertValues="("${uid}",'2020-04-09 08:08:08')"
    fi
done

if [ -z "${insertValues}" ]; then
    echo "empty."
else
    mysql -h11.36.122.55 -P6302 -utestuser -p123qwe -e "INSERT INTO ${db_name}.${table_name}(uid,due_time) values ${insertValues}"
fi

endTime=$(date "+%Y-%m-%d %H:%M:%S")
echo "==== ${endTime} ===="

3 脚本管理

目前已经把这个脚本放在Github了，地址是https://github.com/vfhky/shell-tools，以后脚本的更新或者更多好用的脚本也都会加入到这个工程中。

Python脚本上传博客自定义的SSL证书到七牛云

2019-06-23T23:55:00+08:00

博客图片域名(cnd.typecodes.com)的SSL证书是通过Let's Encrypt申请的，因为证书有效期为3个月，所以需要用脚本定时去重新申请。

重新申请证书主要步骤为：

1、源主机上创建crontab定时任务；
2、先把图片域名DNS解析到源主机上，重新申请Let's Encrypt证书；
3、把申请到的SSL证书上传到七牛云的证书管理平台并启用；
4、把图片域名DNS重新解析到七牛云上；
5、最后重启源主机的Nginx服务。

在上篇文章中使用Python脚本来切换DNS的解析，也就是实现了上面的2、4步骤；这篇文章主要是用Python脚本来上传SSL证书到七牛云上，也就是实现上面的步骤3。

1 七牛云存储相关

和前文中操作阿里云DNS的Python脚本一样，我们也需要在七牛创建一个API相关的AccessKey和SecretKey。

七牛云开放的API接口对应的SDK库已经在GitHub了，对应python版本的地址是： https://github.com/qiniu/python-sdk/releases。

2 要实现的功能

要实现的功能也就是上面说的步骤3：上传SSL证书到七牛云存储并启用。

所有已上传的自定义SSL证书都会在七牛云存储SSL证书服务上展示出来，如下图所示：

3 实现程序

根据七牛云存储的SDK python版本的说明，用下面这个Python脚本实现上面的需求。

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# FileName:      qiniu_letssl.py
# (c) 2019.6.23 vfhky https://typecodes.com/python/qiniuletssl1.html
# https://github.com/vfhky/shell-tools/blob/master/filehandle/qiniu_letssl.py
# 脚本功能：上传从Let's Encrypt申请的 cdn.typecodes.com 的SSL证书到七牛云存储并启用。
# 使用方法: python qiniu_letssl.py
#
# 必须安装的核心包：             pip install qiniu

import qiniu
from qiniu import DomainManager
import os
import time

# 七牛云API相关的AccessKey和SecretKey.
# access_key = os.getenv('ACCESS_KEY', '')
access_key = "ac_key"
secret_key = "se_key"
# 操作的域名
domain_name = "cdn.typecodes.com"

auth = qiniu.Auth(access_key=access_key, secret_key=secret_key)
domain_manager = DomainManager(auth)

# Let's Encrypt申请的证书公钥和私钥文件所在的目录.
privatekey = "/etc/letsencrypt/live/{}/privkey.pem".format(domain_name)
ca = "/etc/letsencrypt/live/{}/fullchain.pem".format(domain_name)

with open(privatekey, 'r') as f:
    privatekey_str = f.read()

with open(ca, 'r') as f:
    ca_str = f.read()

ret, info = domain_manager.create_sslcert("{}/{}".format(domain_name, time.strftime("%Y%m%d_%M%S", time.localtime())),
                                        domain_name, privatekey_str, ca_str)
print(ret['certID'])

if domain_name.startswith("*"):
    domain_name = domain_name[1:]
ret, info = domain_manager.put_httpsconf(domain_name, ret['certID'], False)
print(info)

4 执行效果

执行python qiniu_letssl.py就会把Let's Encrypt申请的SSL证书公私钥文件上传到七牛云存储。从下面的效果可以看出目前博客用的证书文件命令就是cdn.typecodes.com/20190530_2840。

5 脚本管理

目前已经把这个脚本放在Github了，地址是https://github.com/vfhky/shell-tools，以后脚本的更新或者更多好用的脚本也都会加入到这个工程中。

脚本自动切换博客图片域名在阿里云的DNS解析

2019-06-01T15:28:00+08:00

自从七牛开放了自定义SSL证书服务后，博主就通过CNAME方式把博客图片对应的域名cdn.typecodes.com解析到了七牛，然后把Let's Encrypt申请的SSL证书上传到七牛服务器。

但是Let's Encrypt的证书有效期只有3个月，所以到期后需要先把域名重新解析到原来的主机服务器，然后重新申请证书。申请通过后再把域名解析到七牛，同时上传并启用新SSL证书。

1 阿里云DNS相关

博客根域名是在阿里云购买的，所以用的DNS解析服务也是阿里云的。目前整个阿里云控制台的相关功能都可以通过在RAM访问控制申请用户AccessKey和AccessKeySecret后调用相关的API实现。

阿里云开放的API接口对应的SDK库已经在GitHub了，对应的python版本地址是： https://github.com/aliyun/aliyun-openapi-python-sdk。

2 要实现的功能

根据业务需求，博客在申请Let's Encrypt证书时，需要使用A方式把cdn.typecodes.com解析到主机服务器（111.231.246.29）。

当证书申请通过后，需要使用CNAME方式把cdn.typecodes.com解析到七牛云存储服务器（cdn.typecodes.com.qiniudns.com）。

3 实现程序

根据阿里云的SDK python版本的说明，下面是具体的实现程序。最后传入的参数1表示把域名解析到七牛，其它值则表示把域名解析到原主机服务器。

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# FileName:      aliyun_dns_modify.py
# (c) 2019.6.1 vfhky https://typecodes.com/python/aliyundnsanalysis1.html
# https://github.com/vfhky/shell-tools/blob/master/dns/aliyun_dns_modify.py
# 脚本功能：修改 cdn.typecodes.com 在阿里云DNS的解析（七牛和源主机之间的切换）。
# 使用方法: python aliyun_dns_modify.py cdn 1/2
#
# 必须安装的核心包：             pip install aliyun-python-sdk-core
# 根据功能选装dns相关的包：       pip install aliyun-python-sdk-alidns

import sys
import json
from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.acs_exception.exceptions import ClientException
from aliyunsdkcore.acs_exception.exceptions import ServerException
from aliyunsdkalidns.request.v20150109.DescribeDomainRecordsRequest import DescribeDomainRecordsRequest
from aliyunsdkalidns.request.v20150109.UpdateDomainRecordRequest import UpdateDomainRecordRequest


# constant statics.
aliyun_accesskey = "key"
aliyun_accesskeysecret = "secret"
domain_pre = "cdn"
# must be the root domain other than the second or third level domain.
domain = "typecodes.com"
# the dns record type which is defined 1 meaning qiniu defaultly.
record_type = 1
# qiniu.
qiniu_cname = ("CNAME", "cdn.typecodes.com.qiniudns.com")
# host ip.
original_host = ("A", "111.231.246.29")


# create aliyun api object.
client = AcsClient(
  aliyun_accesskey,
  aliyun_accesskeysecret
);


if __name__ == '__main__':
    if len(sys.argv) == 3:
        domain_pre = sys.argv[1]
        record_type = int(sys.argv[2])
    else:
        print("==== usage: python %s %s %d ====" % (sys.argv[0], domain_pre, record_type) )
        sys.exit(1)

    # first step: call aliyun api to get dns record lists.
    try:
        # domain act.
        request = DescribeDomainRecordsRequest()
        request.set_accept_format('json')
        request.set_DomainName( domain )
        response = client.do_action_with_exception(request)
    except ServerException as srv_ex:
    # if response.has_key('Code') or response.has_key('Message'):
        print("Error: Code=[%s] Message=[%s], exit." % (srv_ex.error_code, srv_ex.message) )
        sys.exit(1)
    except:
        print( "unexcepted error, exit." )
        sys.exit(1)

    # parse response:
    data = json.loads(response)
    record = data["DomainRecords"]["Record"];

    # recrucive all dns record and find the RecordId of target pre-domain.
    for single_record in record:
        if ( single_record["RR"] == domain_pre ):
            print( "==== get domain=[%s] RR=[%s] RecordId=[%s] Type=[%s] Value=[%s]." % (domain, single_record["RR"], single_record["RecordId"], single_record["Type"], single_record["Value"] ) )
            # second step: call aliyun api to update the target record.
            request = UpdateDomainRecordRequest()
            request.set_accept_format('json')
            request.set_RR( domain_pre )
            request.set_RecordId( single_record["RecordId"] )

            if record_type == 1:
                request.set_Type( qiniu_cname[0] )
                request.set_Value( qiniu_cname[1] )
            else:
                request.set_Type( original_host[0] )
                request.set_Value( original_host[1] )

            try:
                response = client.do_action_with_exception(request)
            except ServerException as srv_ex:
            # if response.has_key('Code') or response.has_key('Message'):
                print("Error: Code=[%s] Message=[%s], exit." % (srv_ex.error_code, srv_ex.message) )
                sys.exit(1)
            except:
                print( "unexcepted error, exit." )
                sys.exit(1)

            print("==== success.")
        else:
            continue

4 执行效果

执行python aliyun_dns_modify.py cdn 2将域名DNS解析到原主机。

执行python aliyun_dns_modify.py cdn 1将域名DNS解析到七牛。

在阿里云的域名解析日志上可以看到效果，如下图所示：

5 脚本管理

目前已经把这个脚本放在Github了，地址是https://github.com/vfhky/shell-tools，以后脚本的更新或者更多好用的脚本也都会加入到这个工程中。

6 其它说明

阿里云相关的API是可以在线调试的，非常方便！例如，查看所有的DNS解析记录可以点这里进入调试。

使用 fastjson 解析json中的键值：乱序和原样输出

2019-01-22T17:21:00+08:00

最近项目需要做一个java版本的demo，简单来做就是按照api文档拼装请求报文请求自己的服务端，收到应答报文后做MD5签名验证等后续处理。由于客户端和服务端之前通讯报文是json格式的，那么就会涉及到json报文的生成和解析。网上找了下，貌似阿里巴巴的fastjson库评价不错，所以就直接拿过来用了。

1 与实际的偏差

fastjson封装的api函数倒是蛮简单的，直接拿过来就可以上手用了。但是demo程序在对服务端返回的报文做验签的时候总是通不过，后面把原始的待签报文和服务器的待签报文一对比发现两者不一致，这样验签肯定是失败的。

那问题就出在这个原始的待签报文为什么会被改变的环节了：用fastjson从json格式的应答报文中获取的这个待签报文被重新排序了（见小节2中的json_order_is_changed函数）。

在查过资料后，原来是fastjson包中的JSONObject对象中，如果直接使用parseObject方法，可能会导致json数据重新排序。这个问题可以通过使用com.alibaba.fastjson.parser.Feature包解决，但是需要使用最新的fastjson包。

2 示例程序

由于demo中的业务代码过长，这里把关键的json报文解析的这一部分抽出来做了个演示程序。

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.Feature;
import java.util.LinkedHashMap;


/**
* File:   fastjsonParseMain.java
* Description:   使用 fastjson 解析json中的键值：乱序和原样输出
* Refer:         最新的fastjson包可以到官网 https://github.com/alibaba/fastjson/releases 去下载。
* (c) 2019.01.22 vfhky https://typecodes.com/java/fastjsonorder1.html
*/
public class fastjsonParseMain {
    public fastjsonParseMain(){

    }

    /**
    * 使用 fastjson 根据输入的key原样获取json中对应的值。
    *
    * @param    s_json_data     json字符串
    * @param    s_key           json字符串中的key
    * @return   value           key对应的value
    */
    public static String json_order_not_change(String s_json_data, String s_key) {
        // 1.2.54版本的fastjson包测试通过
        LinkedHashMap<String, Object> json = JSON.parseObject(s_json_data, LinkedHashMap.class, Feature.OrderedField);
        JSONObject jsonObject=new JSONObject(true);
        jsonObject.putAll(json);
        if( null == json.get(s_key) ) {
            return "";
        } else {
            return json.get(s_key).toString();
        }
    }

    /**
    * 使用 fastjson 根据输入的key获取json中对应的值（可能会被排序）。
    *
    * @param    s_json_data     json字符串
    * @param    s_key           json字符串中的key
    * @return   value           key对应的value
    */
    public static String json_order_is_changed(String s_json_data, String s_key){
        JSONObject object=JSONObject.parseObject(s_json_data);
        if( null == object.getString(s_key) ) {
            return "";
        } else {
            return object.getString(s_key).toString();
        }
    }


    public static void main(String[] args){
        String s_org_buff = "{\"cmd_1\":1, \"cmd_2\":2, \"biz_content\":{\"aa\":\"11\",\"cb\":\"55\",\"11\":\"66\"}}";
        String s_dst_buff = "";

        System.out.println("==================== 原始json字符串 ===================");
        System.out.println("s_org_buff=[" + s_org_buff + "].\n");

        System.out.println("==================== 获取的value可能是乱序的 ===================");
        s_dst_buff = fastjsonParseMain.json_order_is_changed( s_org_buff, "biz_content" );
        System.out.println("s_dst_buff=[" + s_dst_buff + "].\n");

        System.out.println("==================== 原样输出对应的 value 值 ====================");
        s_dst_buff = fastjsonParseMain.json_order_not_change( s_org_buff, "biz_content" );
        System.out.println("s_dst_buff=[" + s_dst_buff + "].\n");
    }
}

3 使用eclipse编译执行

上面代码json_order_not_change函数通过Feature参数使得解析json数据的时候能够保持原样，而json_order_is_changed函数中获取的value值可能会是排序后的数据。

两者的效果如下图所示：

Python自动析构时出现Exception AttributeError: 'NoneType' object has no attribute的问题

2018-12-19T11:45:00+08:00

昨晚在整理自己的python脚本的时候，想把其中一个脚本中的print函数全都改成logging包中的相关函数。改完后一运行却出现了Exception AttributeError: 'NoneType' object has no attribute的错误，网上搜了一下没找到相关答案。上午再想了想，原因应该是跟python对象的析构有关，具体分析过程如下：

1 示例程序

由于原脚本业务部分过长，这里把关键的几个部位抽出来做了个演示程序。

# -*- coding: UTF-8 -*-
# File:   destrution_attribute_error_nonetype1.py
# Description:   python自动析构时出现Exception AttributeError: 'NoneType' object has no attribute问题的示例程序
# (c) 2018.12.19 vfhky https://typecodes.com/python/destrution_attribute_error_nonetype1.html

import threading
import logging


# MYSQL 的简单封装
class CMySQL:
    # 线程锁
    _instance_lock = threading.Lock()

    # 数据库连接对象
    __db = None
    # 游标对象
    __cursor = None

    def __init__(self, *args, **kwargs):
        pass

    def __new__(cls, *args, **kwargs):
        pass

    # 析构函数，释放对象时使用
    def __del__(self):
        # 关闭数据库连接
        if self.__db:
            self.__db.close()
            # 自动析构时这里会出问题：'NoneType' object
            logging.info("-------> close db.")
        else:
            # 自动析构时这里也会出问题：'NoneType' object
            logging.warning("-------> db unconnected or had been closed.")


if __name__ == "__main__":
    # 创建实例
    db_obj = CMySQL()

    # 输出到控制台
    logging.basicConfig(level=logging.INFO,
                    format='[%(asctime)s][L:%(lineno)d][%(levelname)s][%(process)d] %(message)s',
                    datefmt='%d %b %Y %H:%M:%S')
    logging.info("================================== END ==================================")

2 执行后出现错误

执行上面的程序，在Linux终端上就会出现Exception AttributeError: 'NoneType' object has no attribute 'warning'" in <bound method CMySQL.__del__ of <__main__.CMySQL instance at 0x7f4b3f9b7128>>的错误。

如下图所示：

3 分析问题

其实是不了解python的析构过程导致的：当main函数结束后（输出图中的END字样），意味着进程即将退出，那么会自动调用对象的析构函数进行析构，这点Python和C++是一样的。

由于logging模块中的类对象（包括成员变量、成员函数等）已经被析构了，所以当执行CMySQL对象的析构函数__del__中的logging.warning函数时会出现"'NoneType' object has no attribute 'warning'的错误。

4 解决问题

解决方法很简单，只要增加一个封装MySQL链接关闭的函数close就行了，当main函数结果调用即可。下面的代码是针对这个问题的改进版本。

# -*- coding: UTF-8 -*-
# File:   destrution_attribute_error_nonetype1_1.py
# Description:   修正Exception AttributeError: 'NoneType' object has no attribute问题的示例程序
# (c) 2018.12.19 vfhky https://typecodes.com/python/destrution_attribute_error_nonetype1.html

import threading
import logging


# MYSQL 的简单封装
class CMySQL:
    # 线程锁
    _instance_lock = threading.Lock()

    # 数据库连接对象
    __db = None
    # 游标对象
    __cursor = None

    def __init__(self, *args, **kwargs):
        pass

    def __new__(cls, *args, **kwargs):
        pass

    # 关闭数据库连接
    def close(self):
        if self.__db:
            self.__db.close()
            self.__db = None
            self.__cursor = None
            logging.info("-------> close db.")
        else:
            logging.warning("-------> db unconnected or had been closed.")

    # 析构函数，释放对象时使用
    def __del__(self):
        # 关闭数据库连接
        if self.__db:
            self.__db.close()
            self.__db = None
            self.__cursor = None
            # logging.info("-------> close db.")
        else:
            pass
            #logging.warning("-------> db unconnected or had been closed.")


if __name__ == "__main__":
    #
    db_obj = CMySQL()

    # 输出到控制台
    logging.basicConfig(level=logging.INFO,
                    format='[%(asctime)s][L:%(lineno)d][%(levelname)s][%(process)d] %(message)s',
                    datefmt='%d %b %Y %H:%M:%S')
    logging.info("================================== END ==================================")

    # 关闭数据库连接
    db_obj.close()

运行效果如下图所示：

awk中符点型小数去掉小数点转换成整数的方法

2018-03-28T23:12:00+08:00

在写shell脚本时，会遇到要把一个符点数转换成整数的情况。之前线上一个shell脚本在用awk从文本中读取出一个带两位小数的符点数后，是直接把它乘以100转换成整数的。脚本一直运行正常，直到后面遇到了一个符点数19004.44，它在乘以100后得到的不是1900444而是科学记数1.90044e+06，导致导入数据库失败。后面测试发现符点数19004.42也存在同样的问题，如果下图所示：

1 解决方法

有两种方法可以解决这个问题：1通过sub或者gsub函数把符点数的小数点去掉；2和C/C++那样通过printf占位符格式化。

测试结果如下所示：

# Description:   awk中符点型小数去掉小数点转换成整数的方法
# (c) 2018.03.28 vfhky https://typecodes.com/linux/awkdecimaltoint1.html


#### 方法一：使用sub函数进行替换（把小数点去掉）
[vfhky@typecodes shell]$ echo 19004.44 | awk '{sub(/\./,"",$1); print $1}'
1900444
[vfhky@typecodes shell]$ echo 0.44 | awk '{sub(/\./,"",$1); print $1}'
044
#### 小数点前面的0可以通过int函数强制转换去掉
[vfhky@typecodes shell]$ echo 0.44 | awk '{sub(/\./,"",$1); print int($1)}'
44
[vfhky@typecodes shell]$

#### 方法二：使用printf函数格式化
[vfhky@typecodes shell]$ echo 19004.44 | awk '{printf("%.0f\n", 100*$1)}'
1900444
[vfhky@typecodes shell]$ echo 0.44 | awk '{printf("%.0f\n", 100*$1)}'
44
[vfhky@typecodes shell]$

exit 0

MySQL5.7中使用GROUP_CONCAT数据被截断的问题

2018-03-14T23:10:00+08:00

前天在生产环境中遇到一个问题：使用GROUP_CONCAT函数select出来的数据被截断了，最长长度不超过1024字节，开始还以为是navicat客户端自身对字段长度做了限制的问题。后面故意重新INSERT了一个字段长度超1024字节的数据，但是navicat能完整展示出来，所以就排除了navicat的问题。

然后想到1024这个熟悉的数字，会不会是C++框架在接收MySQL通过socket传输过来的数据时被处理了呢？于是手工在日志中打印这个字段，发现即使数据长度超过1024字节仍然是可以完整显示的。

1 查找原因

至此，只能从SQL语句出发了。网上搜了下GROUP_CONCAT数据截断的问题，答案都指向了group_concat_max_len这个参数，它的默认值正好是1024。可以直接在数据库中通过下面的命令查看这个默认值：

mysql> show variables like 'group_concat_max_len';
+----------------------+-------+
| Variable_name        | Value |
+----------------------+-------+
| group_concat_max_len | 1024  |
+----------------------+-------+
1 row in set (0.00 sec)

mysql>

MySQL官方手册对它的定义是The maximum permitted result length in bytes for the GROUP_CONCAT() function.，也就是它限制了GROUP_CONCAT数据的长度。

2 解决问题

只要调整group_concat_max_len到最大值就行了，官方在MySQL5.7的手册中给出了如下定义：

由于BZ的测试虚拟机MySQL5.7.19是64位的，所以可以通过下面这两种方法配置好group_concat_max_len为最大值18446744073709551615：

#### 方法一：修改MySQL配置文件my.cnf，在[mysqld]节点中添加
group_concat_max_len = 18446744073709551615

#### 方法二：直接控制台上设置立即生效
-- 【必须操作】更改全局配置----
SET GLOBAL group_concat_max_len=18446744073709551615;
-- 【可选操作】使配置在当前会话中也立即生效，其它已经登录的会话终端需要重启生效----
SET SESSION group_concat_max_len=18446744073709551615;

3 测试效果

这里采用的是第二种方法，通过执行SELECT LENGTH(GROUP_CONCAT(Fremark)) FROM account;结果的对比，可以发现已经成功解决了MySQL5.7中使用GROUP_CONCAT数据被截断的问题。

分布式系统：一致性hash算法的应用

2018-02-17T00:13:00+08:00

前段时间在了解分布式，发现firefoxbug在博客中写的这篇《一致性hash在分布式系统中的应用》对这个问题说明得比较清晰易懂，本文主要是自己的理解和实践。

在后端一般会遇到这样的场景：随着应用系统的访问量或者DB/文件存储系统的数据量增大，系统由于负载增大而出现响应延迟甚至down掉的情况。为了解决这个问题，往往会对系统采用垂直扩展和水平扩展的架构设计，而分布式系统正是水平扩展架构的一种应用实践。

1 分布式系统要求

分布式设计的初衷就是为了解决单一服务端负载过大的问题，所以在对系统做水平扩展后，数据要尽量均匀地分布在每台服务器节点的上（即不会出现热点数据节点）。其次，如果后期需要扩容或者某一节点发生故障需要从集群中剔除，那么处理后的分布式系统应该做到对已存储的数据影响最小，降低数据迁移的成本和风险。

2 解决方法

由于机器的数量不可能是无限的，所以水平扩展的时候，要考虑把无限的数据通过一定的算法平衡、有序、易扩展地分布在这些机器上。

常见的做法是利用把要处理的数据进行编号，然后对机器的数据进行取模运算。例如，假设有10个数据（编号为0~9），机器数量为3（编号为0~2），那么每个数据编号对机器数3取模后，0号机器存放了编号为0,3,6,9的数据；1号机器存了编号为1,4,7的数据；2号机器存放了编号为2,5,8的数据。

取模算法比较简单，但是当某个服务器节点出现故障或者新增节点后，需要对已有数据作大量的迁移。在memcached分布式原理中介绍了Consistent Hashing算法，它能较好地解决这个问题。

3 一致性哈希算法原理

如上图所示，memcached分布式提供的哈希算法的主要处理流程如下：

1、使用算法求出每个memcached服务器节点（ip地址）的哈希值x，并将其分配到0~2^32的圆上（值域）；
2、用同样的方法求出存储数据键的哈希值y，并映射到圆上。
3、按顺时针方向查找第1个比y大的x，那么y就分布在x前面那个节点上。

4 示例程序

在firefoxbug的原文中提供了python2的示例程序，这里改成了python3。注意，程序中对这4台机器都使用了虚拟节点(replicas)，它可以增加数据分布的均匀性。

# -*- coding: UTF-8 -*-

'''
FileName:      consistenthashdistributed1.sh
Description:   分布式系统：一致性hash算法的应用
Simple Usage:  python consistenthashdistributed1.py [numbers of replicate]
Reference:     http://www.firefoxbug.com/index.php/archives/2791/
(c) 2018.02.17 vfhky https://typecodes.com/python/consistenthashdistributed1.html
'''

import sys
import hashlib

CONTENT = """Consistent hashing is a special kind of hashing such that when a hash table is resized and consistent hashing is used, only K/n keys need to be remapped on average, where K is the number of keys, and n is the number of slots. In contrast, in most traditional hash tables, a change in the number of array slots causes nearly all keys to be remapped."""

# 所有机器列表
SERVERS = [
    "192.168.1.1",
    "192.168.2.2",
    "192.168.3.3",
    "192.168.4.4"
]


class HashRing(object):
    """Constructs.
    """
    def __init__(self, nodes=None, replicas=3):
        """Manages a hash ring.

        `nodes` is a list of objects that have a proper __str__ representation.
        `replicas` indicates how many virtual points should be used pr. node,
        replicas are required to improve the distribution.
        """
        self.replicas = replicas

        self.ring = dict()
        self._sorted_keys = []

        if nodes:
            for node in nodes:
                self.add_node(node)

    def add_node(self, node):
        """Adds a `node` to the hash ring (including a number of replicas).
        """
        for i in range(0, self.replicas):
            key = self.gen_key('%s:%s' % (node, i))
            self.ring[key] = node
            # print("key=[%s]=[%s]." %(key, node))
            self._sorted_keys.append(key)

        self._sorted_keys.sort()
        #print("%s" %(self._sorted_keys))

    def remove_node(self, node):
        """Removes `node` from the hash ring and its replicas.
        """
        for i in range(0, self.replicas):
            key = self.gen_key('%s:%s' % (node, i))
            del self.ring[key]
            self._sorted_keys.remove(key)

    def get_node(self, string_key):
        """Given a string key a corresponding node in the hash ring is returned.

        If the hash ring is empty, `None` is returned.
        """
        return self.get_node_pos(string_key)[0]

    def get_node_pos(self, string_key):
        """Given a string key a corresponding node in the hash ring is returned
        along with it's position in the ring.

        If the hash ring is empty, (`None`, `None`) is returned.
        """
        if not self.ring:
            return None, None

        key = self.gen_key(string_key)

        nodes = self._sorted_keys
        nodes_num = len(nodes)
        for i in range(0, nodes_num):
            node = nodes[i]
            if key <= node:
                return self.ring[node], i

        # 对于key>node节点key的，全部落在第1个key对应的节点(192.168.1.4)上，这样就形成了1个闭环。
        print("[%s:%s] string_key=[%s] key=[%s] node=[%s] self.ring[nodes[0]]=[%s].\n" %(__file__, sys._getframe().f_lineno, string_key, key, node, self.ring[nodes[0]]))
        return self.ring[nodes[0]], 0

    def gen_key(self, key):
        """Given a string key it returns a long value,
        this long value represents a place on the hash ring.

        md5 is currently used because it mixes well.
        """
        m = hashlib.md5()
        m.update(key.encode('utf-8'))
        return m.hexdigest()


def consistent_hash(replicas):
    '''docstring'''
    # 模拟初始化每天机器的db
    database = {}
    for s in SERVERS:
        database[s] = []

    hr = HashRing(SERVERS,replicas)

    for w in CONTENT.split():
        database[hr.get_node(w)].append(w)

    # 打印所有的节点下面的数据
    for node in database:
        print("[%s]=[%s].\n" %(node, database[node]))


if __name__ == '__main__':
    '''docstring'''
    replicas = 3

    if len(sys.argv) > 1:
        replicas = long(sys.argv[1])

    if( replicas < 3 or replicas > 100000 ):
        print( "Rreplicas should lower than 100000." )
        sys.exit()

    consistent_hash(replicas)

5 测试

上面程序在查找落地节点时，采用的是遍历整个hash圈上的值，所以虚拟节点不宜过大，否则会出现查找时间过长的问题。如下图所示，BZ在自己的单核1G内存的虚拟机中测试，发现4个节点如果都有10000个虚拟节点时在速度和均衡性方面都是不错的。

6 参考文章

《Memcached 分布式缓存实现原理》。

使用shell脚本解决Navicat导出excel数据不全的问题

2018-02-07T20:10:00+08:00

月末需要对系统注册用户进行报表统计，在使用Navicat从MySQL数据库中导出数据到excel文件时，发现最大只能导出为65536（美好的数字）行的数据。按理说 Navicat应该是从数据库中读取一条记录会立即写到excel文件中，不应该只读取65536范围内的数据然后一次性写到文件里面。

1 问题转换

鉴于Navicat的限制，只能想想其它办法了，这里选择使用shell脚本来处理。如下图所示，在Navicat中对select出来的数据右键，然后选择复制为-制表符分隔值（字段名和数据）把select出来的数据粘贴到任意文本文档中。如此就可以通过shell脚本对这个文本文档进行处理，最后输出为excel文件。

2 脚本代码

程序比较简单，处理时有两个需要注意的地方。第一，excel会把较大的数字采用科学记数法显示，可以采用在数字前面添加`反引号解决；第二，一般Windows下的编码为gbk，如果Linux环境默认的是utf-8的格式，那么shell最后生成的excel文件中的汉字是乱码的，所以最好通过iconv工具提前把文件转换成gbk格式。

#!/bin/bash
# FileName:      navicatxportoverflow1.sh
# Description:   使用shell脚本解决Navicat导出excel数据不全的问题
# Simple Usage:  sh navicatxportoverflow1.sh file_name.txt
# (c) 2018.02.07 vfhky https://typecodes.com/linux/navicatxportoverflow1.html
# https://github.com/vfhky/shell-tools/blob/master/filehandle/navicatxportoverflow1.sh


dst_file=$1
dst_ile_name=$(basename ${dst_file})
dst_ile_name_prefix=${dst_ile_name%.*}


cp ${dst_file} ${dst_ile_name_prefix}.tmp
sed -i 's/\t/,/g' ${dst_ile_name_prefix}.tmp
awk -F',' '{print $1",`"$2","$3}' ${dst_ile_name_prefix}.tmp > ${dst_ile_name_prefix}.tmp1
iconv -f "utf-8" -t "gbk" ${dst_ile_name_prefix}.tmp1 > ${dst_ile_name_prefix}.csv
rm -rf ${dst_ile_name_prefix}.tmp ${dst_ile_name_prefix}.tmp1

exit 0

修复CentOS7升级Python到3.6版本后yum不能使用的问题（续）

2018-01-28T18:35:00+08:00

在上一篇文章中通过重装yum解决了无法使用Python3解释执行的问题，但是yum -y update后又会使得之前设置的软链接（ln -s /usr/local/bin/python3.6 /usr/bin/python）被替换成python2.7。为了把Python3设置为默认py解释器的同时保证yum能正常使用，还得从yum相关脚本下手。

不难猜测这些脚本都是使用py2语法，如果能把它们声明的解释器改成python2，那么问题就迎刃而解了。搜索了一下，发现在/usr/bin/目录有7个yum相关的脚本，再加上前文提到的/usr/libexec/urlgrabber-ext-down共8个。

1 解决方法

这里直接使用shell脚本来把这8个脚本文件中的/usr/bin/python替换成/usr/bin/python2。

#!/bin/bash
# FileName:      python3caseyumbug2.sh
# Description:   修复CentOS7升级Python到3.6版本后yum不能使用的问题（续）
# Simple Usage:  sh python3caseyumbug2.sh
# (c) 2018.01.28 vfhky https://typecodes.com/linux/python3caseyumbug2.html
# https://github.com/vfhky/shell-tools/blob/master/filehandle/python3caseyumbug2.sh


echo "begin handle /usr/bin/yum*."
ALL_YUM_FILES=$(find /usr/bin/ -type f -name "yum*")
for SINGLE_FILE in ${ALL_YUM_FILES}
do
    sed -i 's/#!\/usr\/bin\/python$/#!\/usr\/bin\/python2/' ${SINGLE_FILE}
done


echo "begin handle /usr/libexec/urlgrabber-ext-down."
sed -i 's/\/usr\/bin\/python$/\/usr\/bin\/python2/' /usr/libexec/urlgrabber-ext-down

echo "done."

exit 0

2 后记

通过上面的脚本处理后，即使CentOS7被设置成默认使用Python3.6来执行py脚本，yum工具也不会受到影响了。

修复CentOS7升级Python到3.6版本后yum不能使用的问题

2018-01-25T23:01:00+08:00

之前把现有这台阿里CentOS7.2系统的Python2.7.5升级成Python3.6后，yum工具就不能使用了。当时网上查了下原因，都说是Python3导致的，但是试了很多种方法还是没解决，后面也就一直没管了。因为最近要弄一个Nodejs微信小程序，需要用yum安装一些开发工具，就不得不修复这个问题了。

1 yum工具报错情况

直接执行yum命令就会提示/usr/bin/yum文件第34行有错误：

[root@typecodes ~]# yum
File "/usr/bin/yum", line 34

    ^
SyntaxError: EOF while scanning triple-quoted string literal
[root@typecodes ~]#

但是vim查看这个文件根本没有这一行：

2 解决方法

由于找不到报错的位置，只能考虑重新安装yum了。

2.1、下载yum安装包

[root@typecodes ~]# wget -c http://yum.baseurl.org/download/3.4/yum-3.4.3.tar.gz
[root@typecodes ~]# tar -zxf yum-3.4.3.tar.gz
[root@typecodes ~]# cd yum-3.4.3/

接着使用python2 yummain.py install yum命令（还是不能使用python3来执行）重新安装yum工具：

2.2、执行yum命令

尝试执行yum命令，在/usr/bin/yum文件的第30行报错：

[root@typecodes yum-3.4.3]# yum
File "/usr/bin/yum", line 30
    except KeyboardInterrupt, e:
                            ^
SyntaxError: invalid syntax
[root@typecodes yum-3.4.3]#

显然上面的except语句是python2的写法，当然不能使用默认的Python3命令来执行了。于是把这个文件第1行的#!/usr/bin/python替换成#!/usr/bin/python2。

2.2、继续执行yum命令

尝试执行yum -y update命令更新CentOS系统，结果在文件/usr/libexec/urlgrabber-ext-down第28行处还是报SyntaxError: invalid syntax的错误。

原因是一样的，所以要么把/usr/libexec/urlgrabber-ext-down文件中所有的except写法改成Python3，要么修改第1行的解释器声明，显然第2种方法更新简单有效。

3 解决完毕

到此，可以愉快地使用yum -y update命令更新CentOS系统，然后做开发了！

Linux C/C++多进程同时写一个文件（三）

2017-10-29T22:23:00+08:00

本文是这《Linux C/C++多进程同时写一个文件》系列文章的第三篇，上一篇文章演示了两个亲缘关系的进程（父子进程）同时写一个文件的情形，并得出了数据只会错乱但不会覆盖的结论。这篇文章主要是在第一篇文章的基础上，加上上篇文章的分析，更深下一步地探索两个非亲缘关系的进程同时写一个文件的问题。

1 查看要写入的文件的inode信息

使用stat LINUX_MUTIL_PROCESS_WRITE_2命令查看要写入的文件inode信息，可以看到它的值为67728087。

2 示例程序

下面这个linux_process_fork1_7.c程序很简单，主要是把p_buf指向的静态区数据写入到文件LINUX_MUTIL_PROCESS_WRITE中。

为了测试多进程同时写文件的情景，需要复制linux_process_fork1_7.c程序为linux_process_fork1_8.c，同时把p_buf指向改成abcdefghi，然后分别编译成两个不同的可执行文件：linux_process_fork1_7 和 linux_process_fork1_8。

/** 
 * @FileName    linux_process_fork1_7.c
 * @Describe    Linux C/C++多进程同时写一个文件（三）
 * @Author      vfhky 2017-10-29 22:23 https://typecodes.com/cseries/linuxmutilprocesswrite3.html
 * @Compile     gcc linux_process_fork1_7.c -o linux_process_fork1_7
 */
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include "printnolog.h"


#define FILE_NAME "LINUX_MUTIL_PROCESS_WRITE_2"
static const char *p_buf = "123456789";


int main( const int argc, const char * const *argv  )
{
    int i_fd = open( FILE_NAME, O_RDWR | O_CREAT );
    if( -1 == i_fd )
    {
        PRINTNOLOG( "Open file=[%s] failed, errno=[%d] errmsg=[%s].\n", FILE_NAME, errno, strerror( errno ) );
        return -1;
    }

    static int i_write_len = 0;
    for( int i=0; i<10000; i++ )
    {
        //每次都偏移到文件最末尾
//        if( 0 > lseek( i_fd, 0L, SEEK_END ) )
//        {
//          PRINTNOLOG( "lseek error.\n" );
//          return 0;
//        }

        usleep( 1000 );

        i_write_len += write( i_fd, p_buf, strlen( p_buf ) );
    }
    close( i_fd );
    PRINTNOLOG( "i_write_len=[%ld].\n", i_write_len );

    return 0;
}

3 开始测试

具体的测试过程和第一篇文章一样的：

这里只列出最后的测试结果：两个非亲缘进程分别写入了90000字节，但是文件总共大小还是90000字节。

4 结论

从测试结果可以得出：两个非亲缘关系的进程同时写一个文件时，如果没有设置append同步文件偏移量，那么两个进程写入的数据会出现覆盖的情况。

Linux C/C++多进程同时写一个文件（二）

2017-10-29T21:23:00+08:00

本文是这《Linux C/C++多进程同时写一个文件》系列文章的第二篇，上一篇文章演示了两个非亲缘关系的进程同时写一个文件的情形，并得出了数据只会错乱但不会覆盖的结论。这篇文章主要是讨论两个亲缘进程（fork）同时写一个文件的情况。

1 查看要写入的文件的inode信息

使用如下命令可以查看要写入的文件LINUX_MUTIL_PROCESS_WRITE对应的inode情况，可以看到它的值为67530179。

[vfhky@typecodes fork2]$ stat /home/vfhky/src/linux/process/fork2/LINUX_MUTIL_PROCESS_WRITE_1 
  File: ‘/home/vfhky/src/linux/process/fork2/LINUX_MUTIL_PROCESS_WRITE_1’
  Size: 671744          Blocks: 1312       IO Block: 4096   regular file
Device: 803h/2051d      Inode: 67530179    Links: 1
Access: (0664/-rw-rw-r--)  Uid: ( 1000/   vfhky)   Gid: ( 1000/   vfhky)
Access: 2017-10-29 15:48:33.404406925 +0800
Modify: 2017-10-28 20:36:34.185587055 +0800
Change: 2017-10-28 20:36:34.185587055 +0800
 Birth: -
[vfhky@typecodes fork2]$

2 示例程序

下面这个linux_process_fork2_1.c程序很简单，主要是fork后的父子进程把对应p_buf指向的静态区数据写入到文件LINUX_MUTIL_PROCESS_WRITE_1中。

/** 
 * @FileName    linux_process_fork2_1.c
 * @Describe    Linux C/C++多进程同时写一个文件（二）
 * @Author      vfhky 2017-10-29 21:23 https://typecodes.com/cseries/linuxmutilprocesswrite2.html
 * @Compile     gcc linux_process_fork2_1.c -o linux_process_fork2_1
 */
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include "printnolog.h"


#define FILE_NAME "LINUX_MUTIL_PROCESS_WRITE_1"
static const char *p_buf_1 = "123456789";
static const char *p_buf_2 = "abcdefghi";


int main( const int argc, const char * const *argv )
{
    /**
        上方中fopen函数的第2个参数使用ab，其中a表示追加，它能原子性地保证进程对应的文件表项中的当前文件偏移量每一次都等于v节点表中当前文件长度。
        但是这里由于父子进程共享一个文件表项，也就是文件偏移量是相同的，所以可以直接使用w+（若文件存在则文件长度清为零，即该文件内容会消失；若文件不存在则建立该文件）。
     */
    FILE *fp = fopen( FILE_NAME, "w+" );
    if( fp == NULL )
    {
        printf( "Can not open [%s], errno=[%d] errmsg=[%s].\n", FILE_NAME, errno, strerror(errno) );
        return -1;
    }

    PRINTNOLOG( "Begin to fork.\n" );
    int pid;
    if( 0 == ( pid = fork() ) )
    {
        PRINTNOLOG( "Child pid=[%d] ppid=[%d].\n", getpid(), getppid() );
        static size_t i_write_len = 0;
        for( int i=0; i<10000; i++ )
        {
            usleep( 1000 );
            i_write_len += fwrite( p_buf_1, 1, strlen(p_buf_1), fp );
        }

        PRINTNOLOG( "i_write_len=[%ld].\n", i_write_len );
    }
    else if( 0 < pid )
    {
        PRINTNOLOG( "Parent pid=[%d], child pid=[%d].\n", getpid(), pid );
        static size_t i_write_len = 0;
        for( int i=0; i<10000; i++ )
        {
            usleep( 1000 );
            i_write_len += fwrite( p_buf_2, 1, strlen(p_buf_2), fp );
        }
        PRINTNOLOG( "i_write_len=[%ld].\n", i_write_len );
    }
    else
    {
        PRINTNOLOG( "Fork errno=[%d], errmsg=[%s].\n", errno, strerror(errno) );
    }

    return 0;
}

3 开始测试

打开一个linux ssh终端，使用ps ux命令可以看到父进程（pid为6524）和子进程（pid为6525）。

再打开一个ssh终端，使用lsof -p 6524命令查看两个进程打开的文件情况，从下图中可以看出这两个进程开打的都是同一个文件（对应的inode值为67530179）。

使用ll /proc/6524/fd命令查看两个进程表项中的所有文件描述符，都是标准输入0、标准输出1、标准错误输出2和打开的文件对应的描述符3。也就是说对于文件描述符3来说，这两个进程表项指向的文件表项中的v节点指针指向的是同一个v节点（包含i节点、文件长度等信息，且唯一）。

使用strace -p 6524命令查看两个进程的内核调用情况，可以看到这两个进程由于for循环的缘故，一直在调用usleep和fwrite函数，而这两个函数最终会调用内核的nanosleep和write函数。

需要思考一点，为什么会函数write(3, "34567891234567891234567891234567"..., 4096) = 4096第2个参数不是程序中指定的abcdefghi而是4096个字节的字符。从这里可以延伸到write和fwrite的区别，就不多说了。

最后通过tail -f LINUX_MUTIL_PROCESS_WRITE命令查看文件写入情况，从下图两个红色标注可以看出父进程写入4096字节（123456789）后在字符3后子进程开始4096字节（abcdefghi）。

4 结论

从上面小节的测试过程可以发现，和上文中两个非亲缘关系的进程同时写一个文件一样，两个亲缘关系的父子进程同时写一个文件时会出现数据混乱的情况，但是两个进程写入的数据没有覆盖。

由于父子进程表项中fd=3指向同一个文件表项，因此两个进程对应文件表项中当前文件偏移量是唯一的，所以尽管在程序没有fopen函数没有使用append模式保证每次写入时的文件偏移量是正确的，但是依然能做到数据无覆盖。

这点从程序输出结果可以验证，父子进程分别写入了90000字节，所以文件总共大小为180000字节。

Linux C/C++多进程同时写一个文件（一）

2017-10-28T13:23:00+08:00

近期会写关于《Linux C/C++多进程同时写一个文件》的系列文章，主要是探索在Linux下非亲缘关系的多进程和具有亲缘关系的多进程同时写一个文件的问题。例如，当两个进程同时写一个文件，那么写入结果是怎样的呢？是否会出现数据丢失的情况？是否会出现覆盖？是否会出现错乱？

本文是这一系列文章的第一篇，通过两个非亲缘关系的进程演示同时写一个文件的情形，最终得出结论、回答上面的问题。

1 查看要写入的文件的inode信息

使用如下命令可以查看要写入的文件LINUX_MUTIL_PROCESS_WRITE对应的inode情况，可以看到它的值为67530247。

[vfhky@typecodes ~]$ stat /home/vfhky/src/linux/process/fork1/LINUX_MUTIL_PROCESS_WRITE 
  File: ‘/home/vfhky/src/linux/process/fork1/LINUX_MUTIL_PROCESS_WRITE’
  Size: 1220608         Blocks: 2384       IO Block: 4096   regular file
Device: 803h/2051d      Inode: 67530247    Links: 1
Access: (0664/-rw-rw-r--)  Uid: ( 1000/   vfhky)   Gid: ( 1000/   vfhky)
Access: 2017-10-28 12:00:32.935269018 +0800
Modify: 2017-10-28 12:02:32.228412041 +0800
Change: 2017-10-28 12:02:32.228412041 +0800
 Birth: -
[vfhky@typecodes ~]$

2 示例程序

下面这个linux_process_fork1_5.c程序很简单，主要是把p_buf指向的静态区数据写入到文件LINUX_MUTIL_PROCESS_WRITE中。

为了测试多进程同时写文件的情景，需要复制linux_process_fork1_5.c程序为linux_process_fork1_6.c，同时把p_buf指向改成abcdefghi，然后分别编译成两个不同的可执行文件：linux_process_fork1_5 和 linux_process_fork1_6。

/** 
 * @FileName    linux_process_fork1_5.c
 * @Describe    Linux C/C++多进程同时写一个文件（一）
 * @Author      vfhky 2017-10-28 13:23 https://typecodes.com/cseries/linuxmutilprocesswrite1.html
 * @Compile     gcc linux_process_fork1_5.c -o linux_process_fork1_5
 */
#include <stdio.h>
#include <unistd.h>
#include <string.h>


#define FILE_NAME "LINUX_MUTIL_PROCESS_WRITE"
static const char *p_buf = "123456789";


int main( const int argc, const char * const *argv )
{
    //这里使用ab，其中a表示追加，它能原子性地保证进程对应的文件表项中的当前文件偏移量每一次都等于v节点表中当前文件长度。
    FILE *fp = fopen( FILE_NAME, "ab" );
    if( fp == NULL )
    {
        printf( "Can not opent [%s].\n", FILE_NAME );
        return -1;
    }

    for( int i=0; i<10000000000; i++ )
    {
        usleep( 1000 );
        fwrite( p_buf, strlen( p_buf ), 1, fp );
    }
    fclose( fp );

    printf( "Write end.\n" );

    return 0;
}

3 开始测试

打开两个linux ssh终端，然后分别执行linux_process_fork1_5（对应进程pid为2910）、linux_process_fork1_6（对应进程pid为2910）。

再打开一个ssh终端，使用lsof -p 2910命令查看两个进程打开的文件情况，从下图中可以看出这两个进程开打的都是同一个文件（对应的inode值为67530247）。

使用ll /proc/2910/fd命令查看两个进程表项中的所有文件描述符，都是标准输入0、标准输出1、标准错误输出2和打开的文件对应的描述符3。也就是说对于文件描述符3来说，这两个进程表项指向的文件表项中的v节点指针指向的是同一个v节点（包含i节点、文件长度等信息，且唯一）。

使用strace -p 2910命令查看两个进程的内核调用情况，可以看到这两个进程由于for循环的缘故，一直在调用usleep和fwrite函数，而这两个函数最终会调用内核的nanosleep和write函数。

需要思考一点，为什么会函数write(3, "fghiabcdefghiabcdefghiabcdefghia"..., 4096) = 4096第2个参数不是程序中指定的abcdefghi而是4096个字节的字符。从这里可以延伸到write和fwrite的区别，就不多说了。

最后通过tail -f LINUX_MUTIL_PROCESS_WRITE命令查看文件写入情况，从下图两个红色标注可以看出linux_process_fork1_5进程写入的123456789在字符4后插入了linux_process_fork1_6进程写入的defg等数据。

4 结论

从上面小节的测试过程可以发现，两个非亲缘关系的进程同时写一个文件时，会出现数据混乱的情况，但是两个进程写入的数据没有覆盖。

这是因为这两个进程表项中指向的对应的两个文件表项对应的当前文件偏移量是不一致的，但是由于打开文件时是使用append追加的方式，使得进程指向的文件表项中的当前文件偏移量都等于当前文件中所有数据的总长度。这就是为什么写入的数据会出现错乱，但是不会出现覆盖（偏移量不一致）的原因。

注意：内核write函数在写入时是原子操作，所以两个进程会有一个竞争关系，最终只会由某个进程写入数据。

5 附录

关于Linux C/C++多个亲缘关系的进程同时写同一个文件的分析请参考下一篇文章。

Linux C++简单实现一个批量插入的sql脚本生成工具

2017-10-18T23:29:00+08:00

之前项目上隔三差五地要手工批量导入一些数据，于是自己用C++写了这个sql脚本文件的生成工具。

1 需求说明

批量插入多个用户收费信息，也就是用户id不同，但是包括所属区域代号、收费模式和费率值等数据是相同的。如果使用手工拼接insert语句工作量很大，而且可能出现差错，所以改用程序来生成。

只需要配置好相关参数，然后直接执行程序就可以把生成的sql脚本交给DBA处理了。

2 C++程序

代码比较简单，从main函数中可以看出主要流程是先读取配置文件（见小节3）中的数据，然后把使用|分隔的用户id进行分解。经过一系列操作后，会拼接出所有的insert语句，最终把这些数据到写入到文件流中。

这里用到了C++文件流的读写、string中字符串的查找和删除、string数据切割成vector或者map对象等。当然代码还可以做很多优化，例如参数的过滤检查、用户数过多时考虑分成多个insert语句、数据量大时使用多线程等。

/** 
 * @FileName    linux_file_basic1_2.cpp
 * @Describe    Linux C++简单实现一个批量插入的sql脚本生成工具.
 * @Author      vfhky 2017-10-18 23:29 https://typecodes.com/cseries/genmysqlinsertsql.html
 * @Compile     g++ linux_file_basic1_2.cpp -o linux_file_basic1_2 -std=c++11
 */
#include <iostream>
#include <fstream>
#include <vector>
#include <map>
#include <sstream>

#include <time.h>


typedef std::map<std::string, std::string> StringMap;


//去除string中所有的空格
void TrimAllSpace( std::string &s_str )
{
    size_t index = 0;
    if( !s_str.empty())
    {
        while( (index = s_str.find(' ',index)) != std::string::npos )
        {
            s_str.erase( index, 1 );
        }
    }
}

//切割字符串
void splitToMap( const std::string &s_orginal, const std::string &s_split_pattern, StringMap &StringMap_Obj )
{
    if( s_orginal.empty() )
    {
        throw( "s_Faccount_id is empty." );
    }

    //方便截取最后一段数据
    std::string s_strs = s_orginal + s_split_pattern;

    size_t i_pos = s_strs.find(s_split_pattern);
    size_t i_size = s_strs.size();

    while( i_pos != std::string::npos )
    {
        std::string s_key_val = s_strs.substr( 0, i_pos );

        size_t i_key_pos = s_key_val.find( "=" );
        if( i_key_pos != std::string::npos )
        {
            std::string s_key = s_key_val.substr( 0, i_key_pos );
            std::string s_val = s_key_val.substr( i_key_pos+1, s_key_val.size() );

            StringMap_Obj.insert( make_pair( s_key, s_val ) );
        }
        else
        {
            throw( "config file is illegal." );
        }

        s_strs = s_strs.substr( i_pos+1, i_size );
        i_pos = s_strs.find( s_split_pattern );
    }
}

//切割字符串
void splitToVector( const std::string &s_orginal, const std::string &s_split_pattern, std::vector<std::string> &vect_str )
{
    vect_str.clear();

    if( s_orginal.empty() )
    {
        throw( "s_Faccount_id is empty." );
    }

    //方便截取最后一段数据
    std::string strs = s_orginal + s_split_pattern;

    size_t pos = strs.find(s_split_pattern);
    size_t size = strs.size();

    while( pos != std::string::npos )
    {
        std::string s_str = strs.substr(0,pos);
        TrimAllSpace( s_str );
        vect_str.push_back( s_str );
        strs = strs.substr(pos+1,size);
        pos = strs.find(s_split_pattern);
    }
}

void GetTime( std::string &s_date )
{
    time_t t = time(NULL);
    char p_date[20] = {0x00};
    strftime( p_date, sizeof(p_date), "%Y%m%d %H:%M:%S", localtime(&t) );
    s_date = p_date;
}



class CGenSqlFile
{
public:
    CGenSqlFile( const std::string &s_config_file ): s_config_file( s_config_file )
    {
        ReadFile();
    }

    virtual ~CGenSqlFile(){}


    //读取每行的数据，然后进行处理
    void ReadFile()
    {
        std::ifstream inFile;

        //以二进制可读的方式打开文件，也可以使用： inFile.open( s_config_file.data() );
        inFile.open( s_config_file.c_str(), std::ios::in | std::ios::binary );

        //Checks if the file stream has an associated file.
        if( !inFile.is_open() )
        {
            inFile.close();
            throw( "Cannot open the config file." );
        }

        //每一行的数据
        std::string s_line_buf;

        //读取一行内容    getline( inFile, s_line_buf )
        while( getline( inFile, s_line_buf, inFile.widen('\n') ) )
        {
            if( s_line_buf.empty() || s_line_buf[0] == '#' )
            {
                continue;
            }

            //开始数据处理
            splitToMap( s_line_buf, "&", StringMap_Obj );
        }

        //关闭文件流
        inFile.close();
    }

    //打印所有的配置数据
    void ShowAllConf() const
    {
        std::cout << "=================== Config data begin. ===================" << std::endl;
        for( auto iter : StringMap_Obj )
        {
            std::cout << "[" << iter.first << "]=[" << iter.second << "]" << std::endl;
        }
        std::cout << "=================== Config data end. ===================" << std::endl;
    }

    std::string GenSql()
    {
        const std::string s_genonesql_comm = GenOneSqlComm();

        //所有的商户/渠道id
        std::vector<std::string> vect_Faccount_id;
        splitToVector( StringMap_Obj["Faccount_id"], "|", vect_Faccount_id );

        //拼装sql
        std::string s_sql_content;
        for( auto iter : vect_Faccount_id )
        {
            s_sql_content += GenOneSql( iter, s_genonesql_comm );
        }

        //把末尾的逗号去掉
        std::string s_sql_contents = s_sql_content.erase( s_sql_content.length()-2, 2 );

        //当前日期
        std::string s_date;
        GetTime( s_date );
        std::string s_sql_illustartion = "-- --------------------------------------------------------------------\n"
                                         "-- Auto Generated on " + s_date + " --------------------------------\n"
                                         "-- --------------------------------------------------------------------\n";

        return ( s_sql_illustartion + StringMap_Obj["INSERT_HEADER"] + "\n" + s_sql_contents + "\n;\n\n\n" );
    }


    //生成SQL数据
    std::string GenOneSql( const std::string &s_Faccount_id, const std::string &s_genonesql_comm )
    {
        return ( "( '" + s_Faccount_id + s_genonesql_comm );
    }

    std::string GenOneSqlComm()
    {
        std::string s_sql = "', '" + StringMap_Obj["Fpay_channel_id"] + "', '" + StringMap_Obj["Fpay_method"] + "', '" + StringMap_Obj["Frate_mode"] + "', '" + StringMap_Obj["Frate_value"] + "', '" + StringMap_Obj["Frate_value_base"] + "', '1'),\n";

        return s_sql;
    }

    void OpenFile()
    {
        //追加
        if( "1" == StringMap_Obj["Ffile_mode"] )
        {
            ostream.open( StringMap_Obj["sql_file"].c_str(), std::ofstream::out | std::ofstream::binary | std::ofstream::app );
        }
        //覆盖
        else if( "2" == StringMap_Obj["Ffile_mode"] )
        {
            ostream.open( StringMap_Obj["sql_file"].c_str(), std::ofstream::out | std::ofstream::binary );
        }
        else
        {
            throw( "Ffile_mode is illegal." );
        }


        if( !ostream.is_open() )
        {
            ostream.close();
            throw( "Cannot open the file." );
        }
    }

    void CloseFile()
    {
        ostream.close();
    }

    //获取配置数据
    const std::string GetConfByKey( std::string &s_config_key ) const
    {
        StringMap::const_iterator iter = StringMap_Obj.find( s_config_key );
        if( iter != StringMap_Obj.end() )
        {
            return iter->second;
        }
        else
        {
            return "";
        }
    }

    //把数据写入到文件流中
    void WriteToFile( const std::string &s_file_contents )
    {
        ostream << s_file_contents;
    }

protected:
    StringMap StringMap_Obj;


private:
    std::string s_config_file;
    std::ofstream ostream;

};


int main( const int argc, const char * const * argv )
{
    static const std::string s_config_file = "./LINUX_FILE_BASIC1_2.txt";


    try
    {
        CGenSqlFile t( s_config_file );

        //显示所有的配置
        t.ShowAllConf();

        //打开文件
        t.OpenFile();

        //生成SQL数据
        std::string s_sql_contents = t.GenSql();

        //写入到文件
        t.WriteToFile( s_sql_contents );

        //关闭文件
        t.CloseFile();

        std::string s_config_key = "sql_file";
        std::cout << "\nGenerate sql file=[" << t.GetConfByKey( s_config_key ) << "] success." << std::endl;
    }
    catch( const char *p_errstr )
    {
        std::cout << p_errstr << std::endl;
    }

    return 0;
}

3 配置文件

上面的C++程序会读取这个linux_file_basic1_2.txt的配置文件，可以使用#符号给一些必要的数据配备注释文字。

需要说明的是Ffile_mode参数表示sql文件的写入方式，当值为2时表示每次都把生成的数据覆盖原文件中的数据；为1时表示支持把多次生成的SQL数据写入到同一个SQL脚本文件中。

#  
# @FileName    linux_file_basic1_2.txt
# @Describe    Linux C++简单实现一个批量插入的sql脚本生成工具的配置文件.
# @Author      vfhky 2017-10-18 23:29 https://typecodes.com/cseries/genmysqlinsertsql.html



# 用户账号id，多个账号使用 | 符号分隔
Faccount_id=10001342|  10001447

# 所属区域代号
Fpay_channel_id=GDSZ01

# 支付方式：
# 支付宝服务窗支付      ALIPAY.JSAPI
# 支付宝刷卡         ALIPAY.MICROPAY
# 支付宝扫码支付       ALIPAY.NATIVE
# 
# 微信公众号         WXPAY.JSAPI
# 微信刷卡支付            WXPAY.MICROPAY
# 微信扫码支付            WXPAY.NATIVE
Fpay_method=WXPAY.NATIVE

# 收费模式，1固定比例，2单笔计费
Frate_mode=1

# 费率值，单位：1/10000
Frate_value=50

# 基本费用，单位：分
Frate_value_base=0


# 生成的sql文件名
sql_file=user_account.sql

# 生成的sql文件模式，1追加，2覆盖
Ffile_mode=2

# insert语句的头部
INSERT_HEADER=INSERT INTO `USER_ACCOUNT_DB`.`t_mch_rate` ( `Faccount_id`, `Fpay_channel_id`, `Fpay_method`, `Frate_mode`, `Frate_value`, `Frate_value_base`, `Fstatus`) VALUES

4 编译执行

使用《Linux C/C++工程中可生成ELF、动/静态库文件的通用Makefile》文中的Makefile编译：

然后执行生成MySql脚本如下：

CentOS7.3使用CMake编译安装最新的LLVM和Clang4.0.1

2017-10-07T21:59:00+08:00

前段时间试了把虚拟机CentOS下面的C/C++工程中的Makefile文件改用clang/clang++来编译，这篇文章主要是介绍如何在CentOS7.3系统编译安装最新的LLVM和Clang4.0.1。

关于GCC、LLVM和Clang关系可以参考《这篇文章》，个人的理解如下：

LLVM 是 Low Level Virtual Machine 的简称，这个库提供了与编译器相关的支持，能够进行程序语言的编译期优化、链接优化、在线编译优化、代码生成。

而从clang官网的介绍可以看出，clang的目标是创建一种新的基于C语言的LLVM编译器的前端（应该是提供词法分析、语法检测等功能）。

The goal of the Clang project is to create a new C based language front-end: C, C++, Objective C/C++, OpenCL C and others for the LLVM compiler.

1 下载编译所需的文件

从clang官网上下载包含llvm、clang和libcxx等7个文件：

[root@typecodes ~]# wget -c http://releases.llvm.org/4.0.1/llvm-4.0.1.src.tar.xz
[root@typecodes ~]# wget -c http://releases.llvm.org/4.0.1/cfe-4.0.1.src.tar.xz
[root@typecodes ~]# wget -c http://releases.llvm.org/4.0.1/clang-tools-extra-4.0.1.src.tar.xz
[root@typecodes ~]# wget -c http://releases.llvm.org/4.0.1/compiler-rt-4.0.1.src.tar.xz
[root@typecodes ~]# wget -c http://releases.llvm.org/4.0.1/libcxx-4.0.1.src.tar.xz
[root@typecodes ~]# wget -c http://releases.llvm.org/4.0.1/libcxxabi-4.0.1.src.tar.xz
[root@typecodes ~]# wget -c http://releases.llvm.org/4.0.1/libunwind-4.0.1.src.tar.xz

2 解压所有文件到目录：llvm

2.1、解压 llvm-4.0.1.src.tar.xz

[root@typecodes ~]# tar -xf llvm-4.0.1.src.tar.xz && mv -f llvm-4.0.1.src llvm && rm -rf llvm-4.0.1.src.tar.xz

2.2、解压 cfe-4.0.1.src.tar.xz

[root@typecodes ~]# cd llvm/tools/ && mv ~/cfe-4.0.1.src.tar.xz .
[root@typecodes tools]# tar -xf cfe-4.0.1.src.tar.xz && mv -f cfe-4.0.1.src clang && rm -rf cfe-4.0.1.src.tar.xz

2.3、解压 clang-tools-extra-4.0.1.src.tar.xz

[root@typecodes tools]# cd clang/tools/ && mv ~/clang-tools-extra-4.0.1.src.tar.xz .
[root@typecodes tools]# tar -xf clang-tools-extra-4.0.1.src.tar.xz && mv -f clang-tools-extra-4.0.1.src extra && rm -rf clang-tools-extra-4.0.1.src.tar.xz

2.4、进入projescts目录

[root@typecodes tools]# cd ../../../projects/ && pwd
/root/llvm/projects
[root@typecodes projects]#

2.5、解压 compiler-rt-4.0.1.src.tar.xz

[root@typecodes projects]# mv ~/compiler-rt-4.0.1.src.tar.xz .
[root@typecodes projects]# tar -xf compiler-rt-4.0.1.src.tar.xz && mv -f compiler-rt-4.0.1.src compiler-rt && rm -rf compiler-rt-4.0.1.src.tar.xz

2.6、解压 libcxx-4.0.1.src.tar.xz

[root@typecodes projects]# mv ~/libcxx-4.0.1.src.tar.xz .
[root@typecodes projects]# tar -xf libcxx-4.0.1.src.tar.xz && mv -f libcxx-4.0.1.src libcxx && rm -rf libcxx-4.0.1.src.tar.xz

2.7、解压 libcxxabi-4.0.1.src.tar.xz

[root@typecodes projects]# mv ~/libcxxabi-4.0.1.src.tar.xz .
[root@typecodes projects]# tar -xf libcxxabi-4.0.1.src.tar.xz && mv -f libcxxabi-4.0.1.src libcxxabi && rm -rf libcxxabi-4.0.1.src.tar.xz

2.8、解压 libunwind-4.0.1.src.tar.xz

[root@typecodes projects]# mv ~/libunwind-4.0.1.src.tar.xz .
[root@typecodes projects]# tar -xf libunwind-4.0.1.src.tar.xz && mv -f libunwind-4.0.1.src libunwind && rm -rf libunwind-4.0.1.src.tar.xz

3 创建CMake的编译目录：build

[root@typecodes projects]# cd ~/ && mkdir build && cd build/

4 使用Cmake编译生成makefile文件

如果想clang/clang++自动使用libc++库，那么在编译clang时就需要指定DCLANG_DEFAULT_CXX_STDLIB参数值为libc++，否则在链接的时候自动使用gcc/g++的libstdc++库。当然，也可以每次在用clang/clang++编译程序的时候指定--stdlib=libc++。

[root@typecodes build]# cmake -G "Unix Makefiles" -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCLANG_DEFAULT_CXX_STDLIB=libc++ -DCMAKE_BUILD_TYPE="Release" ../llvm

关于glibc、libstdc++和libc+++这三个库的关系，可以参考文章《理清gcc、libc、libstdc++的关系》。前两者是gcc/g++编译C/C++默认链接的库文件，libc+++是clang需要链接的库文件。

5 开始通过make命令编译

使用make -j2命令进行编译。

6 安装 clang 和 llvm

使用命令make install进行安装。

7 安装 libcxx 和 libcxxabi

使用命令make install-cxx install-cxxabi安装clang/clang++所需要的libc++库。

8 查看clang/clang++版本

使用如下命令查看clang/clang++版本：

[root@typecodes build]# clang --version
clang version 4.0.1 (tags/RELEASE_401/final)Target: x86_64-unknown-linux-gnuThread model: posixInstalledDir: /usr/local/bin
[root@typecodes build]#

[root@typecodes build]# clang++ --version
clang version 4.0.1 (tags/RELEASE_401/final)Target: x86_64-unknown-linux-gnuThread model: posixInstalledDir: /usr/local/bin
[root@typecodes build]#

9 查看安装位置

使用如下命令查看clang/clang++安装的位置：

[root@typecodes build]# which clang
/usr/local/bin/clang
[root@typecodes build]#

[root@typecodes build]# which clang++
/usr/local/bin/clang++
[root@typecodes build]#

10 查看LLVM的配置

使用llvm-config --bindir --includedir --libdir --cmakedir命令查看llvm的配置信息。

11 使用clang++编译c++程序

clang/clang++目前是兼容gcc/g++的，所以二者的编译命令基本一致。

[vfhky@typecodes ~]$ clang++ hello.cpp -Wall -g -o hello

如果在小节4中没有指定DCLANG_DEFAULT_CXX_STDLIB参数的值，那么在编译的时候需要使用如下命令：

[vfhky@typecodes ~]$ clang++ hello.cpp -Wall -g -o hello --stdlib=libc++

12 错误分析

从下面这个错误信息可以知道：LLVM最新的4.0.1版本已经不能通过configure/make来编译安装了，它只支持CMake编译。

[root@typecodes build]# ../llvm/configure  --enable-optimized --enable-targets=host-only CC=gcc CXX=g++################################################################################################################################################################The LLVM project no longer supports building with configure & make.Please migrate to the CMake-based build system.For more information see: http://llvm.org/docs/CMake.html################################################################################################################################################################
[root@typecodes build]#

Typecho同步新浪微博的插件（可提取文章图片作配图）

2017-07-04T22:52:00+08:00

由于博客在2015-12-10已经从Typecho转到了Pelican，所以把这个Typecho同步新浪微博的插件放在Github上后就一直也没管了。最近有同学在Github上提了issue，于是写了这篇文章对插件作了详细说明，希望对大家有帮助。

插件基于新浪微博开放平台最新的OAuth2认证方式调用相关API接口把文章同步到微博上。微博发布后，会显示来源（也即应用名称，如下图BZ的是TypeCodes）以及缩略图（需要在插件后台设置）。

1 插件说明：

由于插件基于OAuth2认证方式，在调用相关微博API的时候需要用户的access_token（30天有效）和uid数据，所以需要自己额外搭建一个新浪微博应用服务。

2 搭建新浪微博应用服务：

首先用户必须有一个已经审核通过的新浪微博开放平台的应用。申请方法这里不再赘述，详见官方说明。

2.1 修改配置文件

根据新浪微博开放平台的应用的信息修改config.php文件中的WB_AKEY、WB_SKEY和WB_CALLBACK_URL这三个变量，它们分别代表应用的App Key、App Secret和回调地址。

2.2 博客搭建回调服务

把本目录（weibo）上传至对应的新浪微博应用服务器，如果能通过访问该回调地址（例如https://typecodes.com/weibo）则表示服务搭建完毕。

3 安装插件：

在搭建新浪微博应用服务后就可以安装这个新浪微博同步插件了。

3.1 修改配置文件

同2.1小节所示，根据新浪微博开放平台的应用的信息修改config.php文件中的WB_AKEY、WB_SKEY和WB_CALLBACK_URL这三个变量，它们分别代表应用的App Key、App Secret和回调地址。

3.2 上传插件程序

把本目录（WeiboSync）上传至Typecho插件目录（默认为/usr/plugins）。

4 插件设置

进入typecho的后台并启用WeiboSync插件，再点击设置按钮，进入到WeiboSync插件信息的设置页面。

点击“使用微博账号登录”按钮会跳转到新浪微博登录授权界面，在授权登录后会自动跳转到2.2小节设置的回调地址界面。

如下图所示，在这个界面会输出用户的access_token（30天有效）和uid数据，把这两个值填写到上图中的新浪微博Access Token和个人微博ID中即可。

5 插件维护

目前已经把整个工程放在了GitHub上了，地址是：https://github.com/vfhky/WeiboSync 。

shell遍历输出两个日期范围内所有的日期

2017-06-22T22:48:00+08:00

在平常c/c++开发中经常遇到日期处理的情形，例如求两个给定的日期之间相差的天数或者需要使用map存储两个固定日期范围内的所有日期。前段时间项目中需要用shell脚本批量处理给定的两个日期范围内所有日期产生的日志，当时以为shell处理不方便就用c++来处理了。后面用shell实现了下，发现也挺简单的。

1 思路流程

1、显然不能直接把这两个日期当作整数相减得到差值然后把初始日期不断累加1得到所有的日期，而且要考虑大小月的问题。

2、为了以后开发的方便，需要把这个求两个固定上期范围内的所有日期功能封装在一个函数（即下面脚本中的genAlldate）中。

但是shell的function不能像C/C++那样能return一个数据类型，也没有引用或者指针的功能，所以在需要先声明一个数组变量DATE_ARRAY用于存放计算出来的所有日期，然后在函数遍历中直接写入每个日期数据。

3、最后使用了3种方法来遍历输出数组DATE_ARRAY存放的所有日期。

4、输出的日期格式尽量能够自定义，例如2017-03-30、2017.06.18和20170618等等。

2 shell程序

#!/bin/bash
# FileName:      alldateduringtwodays1.sh
# Description:   Print all the date during the two days you inpute.
# Simple Usage:  ./alldateduringtwodays1.sh 2017-04-01 2017-06-14 or ./alldateduringtwodays1.sh 20170401 20170614 [-]
# (c) 2017.6.15 vfhky https://typecodes.com/linux/alldateduringtwodays1.html
# https://github.com/vfhky/shell-tools/blob/master/datehandle/alldateduringtwodays1.sh


if [[ $# -le 2 || $# -gt 3 ]]; then
    echo "Usage: $0 2017-04-01 2017-06-14 [-]  or  $0 20170401 20170614 [-] ."
    exit 1
fi

START_DAY=$(date -d "$1" +%s)
END_DAY=$(date -d "$2" +%s)
# The spliter bettwen year, month and day.
SPLITER=${3}


# Declare an array to store all the date during the two days you inpute.
declare -a DATE_ARRAY


function genAlldate
{
    if [[ $# -ne 3 ]]; then
        echo "Usage: genAlldate 2017-04-01 2017-06-14 [-]  or  genAlldate 20170401 20170614 [-] ."
        exit 1
    fi

    START_DAY_TMP=${1}
    END_DAY_TMP=${2}
    SPLITER_TMP=${3}
    I_DATE_ARRAY_INDX=0

    # while [[ "${START_DAY}" -le "${END_DAY}" ]]; do
    while (( "${START_DAY_TMP}" <= "${END_DAY_TMP}" )); do
        cur_day=$(date -d @${START_DAY_TMP} +"%Y${SPLITER_TMP}%m${SPLITER_TMP}%d")
        DATE_ARRAY[${I_DATE_ARRAY_INDX}]=${cur_day}

        # We should use START_DAY_TMP other ${START_DAY_TMP} here.
        START_DAY_TMP=$((${START_DAY_TMP}+86400))
        ((I_DATE_ARRAY_INDX++))

        #sleep 1
    done
}

# Call the funciotn to generate date during the two days you inpute.
genAlldate "${START_DAY}" "${END_DAY}" "${SPLITER}"


# [Method 1] Traverse the array.
echo -e "[Method 1] Traverse the array."
for SINGLE_DAY in ${DATE_ARRAY[@]};
do
    echo ${SINGLE_DAY}
done


# [Method 2] Traverse the array.
echo -e "\n[Method 2] Traverse the array."
for i in "${!DATE_ARRAY[@]}"; do 
    printf "%s\t%s\n" "$i" "${DATE_ARRAY[$i]}"
done


# [Method 3] Traverse the array.
echo -e "\n[Method 3] Traverse the array."
i=0
while [ $i -lt ${#DATE_ARRAY[@]} ]
do
    echo ${DATE_ARRAY[$i]}
    let i++
done

# If you do not need this array any more, you can unset it.
# unset DATE_ARRAY

exit 0

3 测试

该shell脚本支持的输入日期格式为2017-04-01和20170401这两种，输出的日期格式格式很灵活，只要在执行程序时再追加一个任意日期分隔符（例如常见的.、-等）即可，最后由脚本中的SPLITER变量做输出格式控制。

这里使用./alldateduringtwodays1.sh 2017-03-30 2017-04-02 .进行测试，效果如下图所示。

4 脚本管理

目前已经把这个脚本放在Github了，地址是https://github.com/vfhky/shell-tools，以后脚本的更新或者更多好用的脚本也都会加入到这个工程中。

使用sed和awk查找和替换字符串处理Makefile文件（三）

2017-05-22T23:45:00+08:00

在前文中演示了使用awk和sed命令正则查找和替换Makefile文件中的make clean操作规则：把-$(RM) $(ULT_BIN)和-$(RM) $(ULT_BIN)这两句写成一句-$(RM) $(ULT_BIN) $(ULT_BIN)，这篇文件主要是通过sed和awk命令继续优化该Makefile文件。

1 具体功能需求

要实现的效果如果上图所示，左边表示之前的Makefile文件，右边是通过本次Shell脚本处理后的Makefile文件，红色部分就是需要点。具体如下：

需求1：

之前这个Makefile脚本在生成多个可执行文件时会调用gen_excbin包，然后执行*.o的生成规则，但是由于它前面加了$(CURDIR)/变量，而%.cpp和.c前面没有加，所以不会调用gen_depend包生成.d依赖文件了，而是按照默认隐含的gcc或者g++编译规则生成.o文件。所以为了批量替换掉虚拟机中项目现有所有的Makefile文件，BZ选择用包含sed和awk命令的shell脚本来处理。

需求2：

每调用gen_excbin或者gen_libs包生成可执行文件或者库文件后（即$$@和$$@ $$^)结尾处）都追加打印一个包含SUCCESS文件的行，方便区分生成多个可执行文件时日志不好区分的情形。

需求3：

替换掉原来的$(bin).o为$(CURDIR)/$(bin).o。

2 shell程序

下面的这份shell脚本比较简单，直接运行./sedawkfindreplace3.sh即可。同前文的脚本框架一样，这里先使用for ... in的Makefile文件遍历中，然后利用了awk命令的正则匹配查找、替换操作，然后是sed命令执行正则匹配查找、替换以及追加操作。

#!/bin/bash
# FileName:      sedawkfindreplace3.sh
# Description:   Basic usage of sed and awk command such as find and replace words in the regular expression.
# Simple Usage:  ./sedawkfindreplace1.sh
# (c) 2017.5.22 vfhky https://typecodes.com/linux/sedawkfindreplace3.html
# https://github.com/vfhky/shell-tools/blob/master/filehandle/sedawkfindreplace3.sh


# Dir to be handled for windows.
# SRC_DIR="/e/typecodes.com/vfhky/src"
# Dir to be handled for Linux.
SRC_DIR="/home/vfhky/src"
# The makefile you want to modify.
SEARCH_NAME="Makefile*"
# The maximum depth of the dirs where files such as Makefile you're dealing with lies in.
MAXDEPTH=10

# Get the target files you want to modify.
ALL_MAKEFILE=$(find ${SRC_DIR} -maxdepth ${MAXDEPTH} -type f -name "${SEARCH_NAME}")


# Traverse the target files.
for FILE in ${ALL_MAKEFILE}
do
    echo -e 'Handling file=['${FILE}']'
    #### Ways recommended: find "-$(RM) $(ULT_BIN)" by awk command.
    #awk '/\$\(CURDIR\)\/\%\.o\: \%\.cpp/{printf( "[%s:%d]: %s\n", FILENAME, NR, $0) }' ${FILE}
    #awk '/-lprint$/{printf( "[%s:%d]: %s\n", FILENAME, NR, $0) }' ${FILE}

    #### replace "-$(RM) $(ULT_BIN)" with "-$(RM) $(ULT_BIN) $(ULT_LIBS)" using awk command.
    # awk '{sub(/-\$\(RM\) \$\(ULT_BIN\)/,"-\$\(RM\) \$\(ULT_BIN\) \$\(ULT_LIBS\)"); print $0}' ${FILE} > ${FILE}.tmp; cp ${FILE}.tmp ${FILE}; rm -rf ${FILE}.tmp


    #### find "-$(RM) $(ULT_BIN)" by sed command.
    #sed -n "/\$(CURDIR)\/\%.o: \%.c$/p" ${FILE}

    #### Ways recommended: Step1. replace "-$(RM) $(ULT_BIN)" with "-$(RM) $(ULT_BIN) $(ULT_LIBS)" using sed command.

    ## 替换
    sed -i 's#\$(CURDIR)\/\%.o: \%.cpp$#\$(CURDIR)\/\%.o: \$(CURDIR)\/\%.cpp#g' ${FILE}

    ## 替换
    sed -i 's#\$(CURDIR)\/\%.o: \%.c$#\$(CURDIR)\/\%.o: \$(CURDIR)\/\%.c#g' ${FILE}

    ## 替换
    sed -i 's#$(bin).o#\$(CURDIR)\/$(bin).o#g' ${FILE}

    ## 追加（以  $$@  结尾）
    sed -i '/ -o \$\$\@$/ a\
    @echo \"========================Success========================\"' ${FILE}

    ## 追加（以  $$@ $$^)  结尾）
    sed -i '/\$\$\@ \$\$\^)$/ a\
    @echo \"========================Success========================\"' ${FILE}
done

exit 0

3 脚本测试

BZ在C/C++工程在/home/vfhky/src，执行这个脚本得到的如下图所示的结果：

4 Linux find 命令中正则

在find命令的某个参数使用正则，那么最好对这个对数加上双引号，正如上面的代码"${SEARCH_NAME}"所示，否则会出现下面的错误：

find: paths must precede expression: Makefile1
Usage: find [-H] [-L] [-P] [-Olevel] [-D help|tree|search|stat|rates|opt|exec] [path...] [expression]

5 脚本管理

目前已经把这个脚本放在Github了，地址是https://github.com/vfhky/shell-tools，以后脚本的更新或者更多好用的脚本也都会加入到这个工程中。

同时，BZ也把修改后的Makefile文件同步更新到了对应的Github上了，欢迎关注，地址还是之前的：https://github.com/vfhky/General_Makefile。

使用C++ STL库统计一散文中单词出现次数和行号

2017-04-16T16:44:00+08:00

在开发过程中经常会遇到文件处理的情形，例如统计一篇文章单词的数量、行数、出现频率最高的几个单词等等。这篇文章主要通过C++来解析一篇文章，实现每个单词（不区分大小写）出现的总次数和出现的行号的统计。

1 演示程序

文件处理能比较好地考验对开发语言基础技能的掌握能力，因为这需要去考虑数据的读取、数据的存储方式、数据的处理等等，可能不同的处理方法会得到不同的效率和结果。

下面的代码主要是使用C++的STL库解析一篇英文散文（网上看到不错就wget下来了），涉及的编程基本点如下：

1、STL容器中的map和vector容器；
2、ifstream库文件流的操作；
3、string的分割查找find、获取子串substr、去除非法字符等待；
4、c++中的基本知识点：构造函数（包括常量的初始化）、引用、对象的构造和析构等等。

文章内容如上图所示，下面直接呈上代码：

/** 
 * @FileName    stl_apply_readfile_1.cpp
 * @Describe    A simple example for using c++ STL to calculate words and line numbers in an article.
 * @Author      vfhky 2017-04-16 16:44 https://typecodes.com/cseries/stlcalcarticlewordlines1.html
 * @Compile     g++ stl_apply_readfile_1.cpp -o stl_apply_readfile_1
 */
#include <iostream>
#include <map>
#include <vector>
#include <fstream>
#include <algorithm>
#include <string>
#include <assert.h>
#include <string.h>
using namespace std;


class CFileHandle
{
public:
    CFileHandle( const string &s_file_name ) : s_m_file_name(s_file_name)
    {
        i_m_line_number = 0;
    }

    //读取每行的数据，然后进行处理
    void ReadFile( const string &s_file_name )
    {
        ifstream inFile;

        //以二进制可读的方式打开文件，也可以使用： inFile.open( s_file_name.data() );
        inFile.open( s_file_name.c_str(), ios::in | ios::binary );

        //Checks if the file stream has an associated file.
        assert( inFile.is_open() );

        //每一行的数据
        string s_line_buf;

        //读取一行内容    getline( inFile, s_line_buf )
        while( getline( inFile, s_line_buf, inFile.widen('\n') ) )
        {
            ++i_m_line_number;

            //统一转换成大写：也可以使用 transform( s_line_buf.begin(), s_line_buf.end(), s_line_buf.begin(), ::toupper );
            transform( s_line_buf.begin(), s_line_buf.end(), s_line_buf.begin(), (int (*)(int))toupper );

            //开始数据处理
            HandleLine( s_line_buf );
        }

        //关闭文件流
        inFile.close();
    }

    //对每行的数据进行解析
    void HandleLine( const string &s_line_buf )
    {
        string s_word_buf;
        int i_start=0, i_last=s_line_buf.size();
        //std::size_t i_split_pos;
        int i_split_pos = 0;

        while( i_start < i_last )
        {
            i_split_pos = s_line_buf.find( ' ', i_start );
            string s_word;

            //if( i_split_pos == std::string::npos )
            if( i_split_pos == -1 )
            {
                s_word = s_line_buf.substr( i_start, i_last );
                HandleUnkind( s_word );
                HandleWord( s_word );
                break;
            }
            /**
                避免空格，也可以使用下面这两行来去掉行首和行尾的空格
                s_line_buf.erase( 0, s_line_buf.find_first_not_of(" ") );
                s_line_buf.erase( s_line_buf.find_last_not_of(" ") + 1 );
             */
            else if( i_start != i_split_pos )
            {
                s_word = s_line_buf.substr( i_start, i_split_pos-i_start );
                HandleUnkind( s_word );
                HandleWord( s_word );
                i_start = i_split_pos + 1;
            }
            //对于行首的空格不进行处理
            else
            {
                i_start = i_split_pos + 1;
            }
        }
    }

    //去除每个单词可能包含的非字符（除0~9和A~Z外的数据）
    void HandleUnkind( string &s_word_buf )
    {
        assert( s_word_buf.size() );

        //char c_word_buf[s_word_buf.size()+1]; 在vs中会报错：error C2131: 表达式的计算结果不是常数
        char *c_word_buf = new char[s_word_buf.size()+1]();

        unsigned int j = 0;
        for( unsigned int i=0; i<s_word_buf.size(); ++i )
        {
            if( ( s_word_buf[i] >= 0x30 && s_word_buf[i] <= 0x39 ) || ( s_word_buf[i] >= 0x41 && s_word_buf[i] <= 0x5A ) )
            {
                c_word_buf[j++] = s_word_buf[i];
            }
        }

        s_word_buf = c_word_buf;
        delete c_word_buf; 
    }

    //对每个单词的处理
    void HandleWord( const string &s_word_buf )
    {
        map<string, vector<int> >::iterator mapit = mapobj.find( s_word_buf );

        //如果该单词不存在
        if( mapit == mapobj.end() )
        {
            vector<int> vect;
            vect.push_back( i_m_line_number );
            mapobj.insert( make_pair( s_word_buf, vect ) );
        }
        else
        {
            mapit->second.push_back( i_m_line_number );
        }
    }

    //遍历map对象
    void Traverse()
    {
        map< string, vector<int> >::iterator mapit = mapobj.begin();
        cout << "Words\t\t\t\tCounts\t\t\t\tLines" << endl;
        cout << "---------------------------------------------------------------------" << endl;
        for( ; mapit != mapobj.end(); ++mapit )
        {
            cout << mapit->first << "\t\t\t\t" << mapit->second.size() << "\t\t\t\t";
            for( vector<int>::iterator vectorit = mapit->second.begin(); vectorit != mapit->second.end(); ++vectorit )
            {
                cout << *vectorit << " ";
            }
            cout << endl;
        }
    }

    //获取文件总行数
    const unsigned int GetTotalLines() const
    {
        return i_m_line_number;
    }

private:
    map<string, vector<int> > mapobj;
    unsigned int i_m_line_number;
    const string s_m_file_name;
};


int main( int argc, char **argv )
{
    //文件所在路径
    const string s_file_name =  "STL_APPLY_READFILE_1";

    CFileHandle *pCFileHandle = new CFileHandle( s_file_name );

    //开始处理文件
    pCFileHandle->ReadFile( s_file_name );
    //打印总行数
    cout << "[" << __FILE__ << ":" << __LINE__ << "] Total Lines=[" << pCFileHandle->GetTotalLines() << "]." << endl;
    //遍历结果
    pCFileHandle->Traverse();

    delete pCFileHandle;

    return 0;
}

2 使用g++编译器进行编译并执行

使用g++或者之前写的这个Makefile文件进行编译，结果如下图所示。

接着执行程序stl_apply_readfile_1，效果如下图所示（图片大小的限制只显示了一部分结果）。另外，上面C++程序中的数据处理函数HandleUnkind相对比较粗略：只简单过滤了非数字和字母的字符。这样会出现类似把YOU'R这样的数据处理成YOUR的情况，大家可以进行代码改进做更精细化的处理。

Linux C++使用函数模板实现JSON数据快速和完整写入到文件

2017-04-16T15:54:00+08:00

昨天在自己的CentOS7机器上编译了JSONCPP库，然后根据api写了下面这个简单的测试程序。代码涉及了文件流数据读取和写入、jsoncpp库的读写api的使用。整个处理流程是先读取一个json格式文件的内容，然后把这些内容分别用jsoncpp库的Json::FastWriter（快速写入）和Json::StyledWriter（完整写入）这两个方式写入到两个文件中，最后读取这两个文件并输出。

1 测试程序

代码比较简单，通过函数模板实现了Json::FastWriter（快速写入）和Json::StyledWriter（完整写入）这两个方式写入。

/** 
 * @FileName    jsoncpp_basic_4.cpp
 * @Describe    A simple example for using function template to complete Json::FastWriter and Json::StyledWriter.
 * @Author      vfhky 2017-04-16 15:54 https://typecodes.com/cseries/templatejsoncpp2file1.html
 * @Compile     g++ jsoncpp_basic_4.cpp -ljsoncpp -o jsoncpp_basic_4
 */
#include <iostream>
#include <fstream>
#include <json/json.h>
#include <stdlib.h>
using namespace std;


//读取json格式的文件
bool b_ReadJson( const string &s_file_path, Json::Value &j_root )
{
    bool b_result = true;

    Json::Features features = Json::Features::strictMode();
    Json::Reader j_reader( features );

    //打开文件流
    ifstream istream;
    istream.open( s_file_path.c_str(), ios::in | ios::binary );
    if( !istream.is_open() )
    {
        istream.close();
        return b_result;
    }

    //parse函数会返回bool值
    if( !j_reader.parse( istream, j_root ) )
    {
        istream.close();
        cout << "[" << __LINE__ << "]Fail to parse." << endl;
        return b_result;
    }

    istream.close();
    return b_result;
}


//使用函数模板来实现快速写入json数据到文件和写入完整json数据到文件这两种方式
template< class T >
bool b_WriteJson( const string &s_file_path, Json::Value &j_root, T &t_writer )
{
    bool b_result = true;

    string s_fwriter = t_writer.write( j_root );
    ofstream ostream;
    ostream.open( s_file_path.c_str(), ios::out | ios::binary );
    if( !ostream.is_open() )
    {
        ostream.close();
        return b_result;
    }

    ostream << s_fwriter;
    ostream.close();

    return b_result;
}


int main( int argc, char **argv )
{
    Json::Value j_root;

    //要读取的文件
    const string s_jon_reader = "JSONCPP_BASIC_2.json";
    //要快速写入的文件
    const string s_jon_fwriter = "JSONCPP_BASIC_4_1.json";
    //要以完整json格式写入的文件
    const string s_jon_swriter = "JSONCPP_BASIC_4_2.json";

    if( !b_ReadJson( s_jon_reader, j_root ) )
    {
        cout << "[" << __LINE__ << "]Fail b_ReadJson." << endl;
        return -1;
    }

    //快速写入json数据到文件
    Json::FastWriter j_fwriter;
    if( !b_WriteJson( s_jon_fwriter, j_root, j_fwriter ) )
    {
       cout << "[" << __LINE__ << "]Fail b_WriteJson." << endl;
       return -2;
    }

    //写入完整json数据到文件
    Json::StyledWriter j_swriter;
    if( !b_WriteJson( s_jon_swriter, j_root, j_swriter ) )
    {
       cout << "[" << __LINE__ << "]Fail b_WriteJson." << endl;
       return -3;
    }


    //先读取上面快速写入json数据到文件中的内容
    cout << "-----------------------" << s_jon_fwriter << "-----------------------" << endl;
    string s_cmd = "cat " + s_jon_fwriter;
    system( s_cmd.c_str() );

    //再读取上面完整json数据到文件中的内容（当然也可以使用system函数）
    cout << "\n-----------------------" << s_jon_swriter << "-----------------------" << endl;
    if( !b_ReadJson( s_jon_swriter, j_root ) )
    {
       cout << "[" << __LINE__ << "]Fail to parse." << endl;
       return -4;
    }
    cout << j_root << endl;

    return 0;
}

2 编译并执行

使用g++或者之前写的这个Makefile文件进行编译，执行结果如开头的图片所示。

Git多仓库作子目录的双向同步：一次Git Subtree的实践

2017-03-22T18:30:00+08:00

今年1月中旬的时候BZ在GitHub上收到Typecho社区组织typecho-fans的成员邀请，原来是想把所有TP的开源插件都整合到GitHub上进行维护。之前BLOG在使用Typecho的时候写了3个插件：新浪云存储SCS插件、移植自WordPress的音乐播放器插件和新浪微博同步插件，那如果放到typecho-fans上进行维护的话对使用者和开发者来说都是挺方便的。但是当时不知道怎么把之前这3个已经放在GitHub上进行维护的插件仓库作为子目录/仓库同步到typecho-fans的插件仓库中，所以一直都没有行动。

这几天发现在社区GitHub上的README文件中已经推荐用subtree方法添加作者之前的插件repo（submodule方法能链接至原repo但也会给下载与维护带来一定麻烦），所以BZ查了subtree的相关资料，然后成功将自己之前放在GitHub上的这3个插件repo作为社区插件库的3个子目录进行双向同步维护。下面是这次Git Subtree实践的具体过程。

1 克隆社区维护的插件库到本地

BZ在自己的Win 10机器上安装了git version 2.11.0.windows.1，因此下面所有的操作都是通过Git Bash实现的。如下所示，首先使用git clone命令把由社区维护的插件库克隆到E盘(plugins目录)。

####### 进入硬盘的E目录并clone项目
vfhky@vfhky-pc MINGW64 /e
$ git clone git@github.com:typecho-fans/plugins.git
Cloning into 'plugins'...
remote: Counting objects: 3928, done.
remote: Compressing objects: 100% (124/124), done.
remote: Total 3928 (delta 51), reused 0 (delta 0), pack-reused 3803
Receiving objects: 100% (3928/3928), 7.58 MiB | 265.00 KiB/s, done.
Resolving deltas: 100% (1284/1284), done.
Checking out files: 100% (1484/1484), done.

2 添加第1个要作为子仓库/目录的远程仓库

进入刚建立的plugins目录，然后使用git remote add命令把要合并进来作为子仓库/目录的远程库PlayAtWill加入到本地仓库plugins中。注意：一个本地的仓库可以添加多个远程仓库！

####### 添加远程仓库PlayAtWill，其中-f意思是在添加远程仓库之后，立即执行fetch 
vfhky@vfhky-pc MINGW64 /e/plugins (master)
$ git remote add -f PlayAtWill git@github.com:vfhky/PlayAtWill.git
Updating PlayAtWill
warning: no common commits
remote: Counting objects: 15, done.
remote: Total 15 (delta 0), reused 1 (delta 0), pack-reused 14
Unpacking objects: 100% (15/15), done.
From github.com:vfhky/PlayAtWill
 * [new branch]      master     -> PlayAtWill/master
 * [new tag]         v1.0.0     -> v1.0.0

3 把第1个远程仓库作为本地仓库的子仓库/目录

在添加完PlayAtWill这个远程仓库后就可以通过git subtree add命令来设置这个远程仓库为社区插件库plugins的一个子仓库（或者称为子目录）了。

####### 其中--squash意思是把subtree的改动合并成一次commit，这样就不用拉取子项目完整的历史记录。
vfhky@vfhky-pc MINGW64 /e/plugins (master)
$ git subtree add --prefix=PlayAtWill PlayAtWill master --squash
git fetch PlayAtWill master
From github.com:vfhky/PlayAtWill
 * branch            master     -> FETCH_HEAD
Added dir 'PlayAtWill'         【此时在本地仓库同步创建了远程PlayAtWill仓库】

4 查看本地整个仓库情况

使用git status命令查看本地整个仓库plugins的情况，结果如下所示。可以看到由于第2、3小节的操作，现在本地仓库已经比对应的远程仓库(origin/master)多了2个commits。如果此时本地仓库没有要更改的文件的话，那么直接使用git push命令可以推送到typecho-fans的远程仓库中了（其它开发成员也能看到此次更新）。

vfhky@vfhky-pc MINGW64 /e/plugins (master)
$ git status
On branch master
Your branch is ahead of 'origin/master' by 2 commits.
  (use "git push" to publish your local commits)
nothing to commit, working tree clean

5 添加第2个要作为子仓库/目录的远程仓库

同小节2中的操作一样，使用git remote add命令把要合并进来作为子仓库/目录的远程库SCS加入到本地仓库plugins中。

####### 添加远程仓库SCS，其中-f意思是在添加远程仓库之后，立即执行fetch 
vfhky@vfhky-pc MINGW64 /e/plugins (master)
$ git remote add -f SCS git@github.com:vfhky/SCS.git
Updating SCS
warning: no common commits
remote: Counting objects: 48, done.
remote: Compressing objects: 100% (6/6), done.
remote: Total 48 (delta 0), reused 6 (delta 0), pack-reused 42
Unpacking objects: 100% (48/48), done.
From github.com:vfhky/SCS
 * [new branch]      master     -> SCS/master
 * [new tag]         v1.1.1     -> v1.1.1
 * [new tag]         v1.0.1     -> v1.0.1
 * [new tag]         v1.0.2     -> v1.0.2
 * [new tag]         v1.0.3     -> v1.0.3
 * [new tag]         v1.0.4     -> v1.0.4
 * [new tag]         v1.1.0     -> v1.1.0

6 把第2个远程仓库作为本地仓库的子仓库/目录

同小节3中的操作一样，使用git subtree add命令来设置这个远程仓库SCS作为社区插件库plugins的一个子仓库（或者称为子目录）了。

####### 其中--squash意思是把subtree的改动合并成一次commit，这样就不用拉取子项目完整的历史记录。
vfhky@vfhky-pc MINGW64 /e/plugins (master)
$ git subtree add --prefix=SCS SCS master --squash
git fetch SCS master
From github.com:vfhky/SCS
 * branch            master     -> FETCH_HEAD
Added dir 'SCS'

7 修改项目的readme.md文件

由于新增了两个插件，所以需要更新下本地仓库的readme.md文件。这里BZ在自己的win10上安装了MarkdownPad2，所以直接使用MarkdownPad命令打开这个文件编辑即可。

vfhky@vfhky-pc MINGW64 /e/plugins (master)
$ /d/MarkdownPad\ 2/MarkdownPad2.exe  README.md

8 查看本地整个仓库情况

同小节4中的操作一样，使用git status命令查看本地整个仓库plugins的情况，结果如下所示。可以看到本地仓库由于第2/3/5/6小节的操作一共进行了4个commits，然后由于小节7的操作修改了README.md文件（等待git add操作）。

vfhky@vfhky-pc MINGW64 /e/plugins (master)
$ git status
On branch master
Your branch is ahead of 'origin/master' by 4 commits.
  (use "git push" to publish your local commits)
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)
        modified:   README.md
no changes added to commit (use "git add" and/or "git commit -a")

9 查看git的操作记录

使用git log命令查看本地仓库的git操作日志，结果如下：

vfhky@vfhky-pc MINGW64 /e/plugins (master)
$ git log
commit 126fdf96dc462f22c5a64b71f92d425de12b3f06
Merge: 3175b06 c4f6105
Author: vfhky <vfhky@qq.com>
Date:   Tue Mar 21 20:27:57 2017 +0800
    Merge commit 'c4f61059b3cf459466a4972bc34246de524e1f33' as 'SCS'
commit c4f61059b3cf459466a4972bc34246de524e1f33
Author: vfhky <vfhky@qq.com>
Date:   Tue Mar 21 20:27:57 2017 +0800
    Squashed 'SCS/' content from commit 00668df
    git-subtree-dir: SCS
    git-subtree-split: 00668dfe151c7ea371595a297075249d39916c51
commit 3175b0670d5a2410170e4f8a74791580639fea38
Merge: 0e9dfe9 f4f9dca
Author: vfhky <vfhky@qq.com>
Date:   Tue Mar 21 20:25:00 2017 +0800
    Merge commit 'f4f9dcab478239e4be38da081417cd627f9c64bf' as 'PlayAtWill'

10 把本地仓库所有的更新都同步到远程仓库

通过小节8/9的分析，确认了整个本地仓库的所有更新和提交都是无误的，那么就使用git add、git commit -m和git push这3个命令把本地仓库的所有操作同步更新到社区typecho-fans的远程仓库中。

vfhky@vfhky-pc MINGW64 /e/plugins (master)
$ git add --all && git commit -m "add two plugins." && git push origin master
[master bafc97f] add two plugins.
 1 file changed, 2 insertions(+)
Counting objects: 18, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (18/18), done.
Writing objects: 100% (18/18), 27.09 KiB | 0 bytes/s, done.
Total 18 (delta 4), reused 0 (delta 0)
remote: Resolving deltas: 100% (4/4), completed with 2 local objects.
To github.com:typecho-fans/plugins.git
   0e9dfe9..bafc97f  master -> master

通过上面的操作已经成功把本地仓库的所有操作同步更新到了社区的远程仓库中了，效果如下图所示。

11 对子仓库的操作同步更新到其对应的原来的远程仓库

如果在本地仓库中对刚才通过git subtree add命令设置为子仓库的SCS和PlayAtWill作修改，又如何同步更新到这两个子仓库原来对应的远程仓库中呢？

这里以修改子仓库SCS为例，已知它原来对应的远程仓库是git@github.com:vfhky/SCS.git。当修改了SCS中的README.md文件（并且已经在本地仓库作了git commit和git push操作），那么使用git subtree push命令就可以同步更新到它原来对应的远程仓库了。

git subtree push的原理是先遍历本地仓库所有的git commit操作，然后匹配出对子仓库SCS的那些commit，最后把这些操作同步更新到它原来对应的远程仓库中。

####### 对子仓库的操作同步更新到其对应的原来远程仓库
vfhky@vfhky-pc MINGW64 /e/plugins (master)
$ git subtree push --prefix=SCS git@github.com:vfhky/SCS.git master --squash
git push using:  git@github.com:vfhky/SCS.git master
Counting objects: 3, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 360 bytes | 0 bytes/s, done.
Total 3 (delta 1), reused 0 (delta 0)
remote: Resolving deltas: 100% (1/1), completed with 1 local objects.
To github.com:vfhky/SCS.git
   00668df..088684c  088684c0e68554dea3c29c61c68003798ddbd781 -> master
vfhky@vfhky-pc MINGW64 /e/plugins (master)
$

最终的同步效果如下图所示。

12 把子仓库对应的远程仓库的操作同步更新到本地仓库

如果对子仓库原来对应的远程仓库作了修改，那么可以在本地仓库使用git subtree pull --prefix=SCS git@github.com:vfhky/SCS.git master --squash命令来获取其远程仓库更新的内容，这里就不做演示了。到此，关于子仓库和其原来对应的远程仓库的双向同步操作演示已经完毕。

C++中使用vs2015和g++对new开辟的堆内存是否初始化的分析

2017-03-14T23:24:00+08:00

在C++中使用new运算符在堆中申请一内存块的使用权的同时还可以执行对该内存块的初始化工作。下面通过使用2个类对象和2个基本数据类型来分析使用new class_object、new class_object()和new int、new int()对这块内存的初始化情况。

1 示例程序

这里用下面这个C++程序作为演示，在后面两个小节中分别使用g++和vs2015来编译。

/** 
 * @FileName    gccvsheapnewinit1.cpp
 * @Describe    A simple example for using new to allocating mem and initialize it compiled with visual studio and g++.
 * @Author      vfhky 2017-03-14 23:24 https://typecodes.com/cseries/gccvsheapnewinit1.html
 * @Compile     g++ gccvsheapnewinit1.cpp -o gccvsheapnewinit1
 */
#include <iostream>
#include <stdio.h>
using namespace std;

//类A中是否开启默认构造函数
#define DEFAULTFUN 0

class A
{
public:
    int i_value;
#if DEFAULTFUN
    //无参构造函数
    A():i_value(10){}
#endif
};

int main( int argc, char **argv )
{
    A *obj1 = new A;
    //如果类A中没有自定义的构造函数（调用编译器合成的默认构造函数，不会对数据成员初始化），如果不加括号，则打印1个随机数；如果有自定义的构造函数，那么会调用这个构造函数进行初始化（本例为10）。
    cout << "new A=[" << obj1->i_value << "]" << endl;
    delete obj1;

    A *obj2 = new A();
    //如果类A中没有自定义的构造函数（调用编译器合成的默认构造函数），但是接着会对内存（各个成员变量）进行初始化（默认为0）；如果自定义了构造函数，那么会调用这个构造函数进行初始化（本例为10）。
    cout << "new A()=[" << obj2->i_value << "]" << endl;
    delete obj2;

    cout << "----------------" << endl;

    //int类型中没有默认构造函数，如果不加括号，那么不会初始化。
    int *i_arra = new int[20];
    printf( "new int[10]=[%d]\n", *(i_arra+10) );
    delete i_arra;

    //int类型中没有默认构造函数，如果加括号，那么会初始化为0。
    int *i_arrb = new int[20]();
    printf( "new int[10]()=[%d]\n", *(i_arrb+10) );
    delete i_arrb;

    return 0;
}

2 使用g++编译器进行编译并执行

无论是否将DEFAULTFUN的值设置为1（即打开类A中的默认构造函数），在使用g++编译器编译并执行的输出结果都如下图所示。从图中可以看出在使用new运算符开辟了内存后，会自动对这块内存进行初始化。因此，图中类A的两个对象obj1和obj2对应的数据成员i_value的值都为0，而且整型指针变量指向偏移量为10的那个整数也都是0。

3 在visual studio 2015中进行编译并执行

分别把上面程序中的DEFAULTFUN的值设置为0和1，也就是测试类中是否包含自定义的构造函数对使用new运算符开辟内存并初始化的影响，然后在vs2015中进行编译和执行，具体操作和对应结果如下。

3.1 把`DEFAULTFUN`的值设置为0

DEFAULTFUN的值设置为0，然后在visual studio 2015中进行编译并执行，得到的结果如下图所示。对比类A的对象obj1和obj2的数据成员的输出值可以得出结论：如果类A中没有自定义的构造函数，那么new A和new A()会调用编译器合成的默认构造函数，但是只有new A()会对这块内存（各个成员变量）进行初始化（默认为0）。

3.2 把`DEFAULTFUN`的值设置为1

DEFAULTFUN的值设置为1，然后在visual studio 2015中进行编译并执行，得到的结果如下图所示。对比类A的对象obj1和obj2的数据成员的输出值可以得出结论：如果自定义了构造函数，那么不论是new A还是new A()都会调用这个构造函数进行初始化（本例为10）。

4 总结

从第2小节的结果可以看出，对于g++编译器来说，无论是使用new class_object、new class_object()和new int、new int()都会对申请的这块内存进行初始化。

从第3和第4小节的结果可以看出，对于visual studio 2015编译器来说他们对上述new运算符的操作有不同的结果，具体总结如下：

对于基本数据类型（例如int, char等待）在使用new开辟申请内存空间时，如果使用new data_type[numbers]不会做内存的初始化操作；而使用new data_type[numbers]()时除了申请内存空间外还会把这块内存中所有的数据初始化为0。

对于对象类型（例如string以及自定义的类对象等）在使用new开辟申请内存空间时，如果没有自定义构造函数，那么使用new data_type[numbers]和使用new data_type[numbers]()都会调用由编译器合成的默认构造函数，但是new data_type[numbers]()还会把这块内存中所有的数据初始化为0；如果自定义了构造函数，那么使用new data_type[numbers]和使用new data_type[numbers]()都会调用由编译器合成的默认构造函数，然后进行初始化（例中为10）。

Linux TCP客户端出现CLOSE_WAIT后进入死循环

2017-03-10T13:49:00+08:00

在前文中讲述了Linux服务端TCP的某个链路变成CLOSE_WAIT状态，然后由于客户端已经关闭了（发送了RST标志的报文），那么服务端如果继续向这个链路中写入数据的话就会收到SIGPIPE信号而终止，这篇文章主要通过客户端进入CLOSE_WAIT后由于收到服务端产生的RST标志报文进入死循环的情况。注：RST表示复位，用来关闭异常的连接。

1 CentOS服务端建立监听端口

如上图所示，在虚拟机CentOS7服务器（192.168.1.177）中打开一个终端界面，执行程序linux_epoll_server_2建立8000端口的监听服务（PID:2791）。进程的大体执行过程是通过epoll_wait等待客户端的接入，当可读描述符就绪时打印接收的报文并回复应答报文，最后调用close函数关闭这个描述符并将其从监听事件中删除。

2 CentOS客户端连接服务端

新建一个Linux会话终端并执行客户端程序linux_epoll_simple_sndmsg_netstat（具体代码见文末附录部分）。在过三次握手建立TCP连接后进程进入循环模式：每次发送完报文休眠5秒（sleep(5)）接着再次向服务端发送报文。

3 使用netstat命令查看TCP状态

新建一个Linux会话终端并创建一个shell脚本linux_epoll_simple_sndmsg_netstat.sh ，里面包含关键命令sudo netstat -npt|head -n 2;sudo netstat -npa|grep 8006。这个脚本用于监控TCP的通信状态。从下图中可以看到，最终服务端进程（PID:2791）在监听8006端口，然后和客户端进程（PID:2804）建立了TCP连接。

4 关键步骤：使用tcpdump命令抓取TCP通信包

新建一个Linux会话终端并输入命令sudo tcpdump -i lo -n port 8006抓取客户端和服务端的TCP通信报文。

5 过程分析

根据前面步骤1服务端、步骤2客户端、步骤3netstat的监控以及步骤4中的TCPDUMP抓包做出具体的分析：

1、tcpdump抓包分析：

[vfhky@typecodes ~]$ sudo tcpdump -i lo -n port 8006
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on lo, link-type EN10MB (Ethernet), capture size 65535 bytes

######三次握手
11:55:35.724646 IP 127.0.0.1.56710 > 127.0.0.1.8006: Flags [S], seq 1652959375, win 43690, options [mss 65495,sackOK,TS val 8433172 ecr 0,nop,wscale 7], length 0
13:09:58.084191 IP 127.0.0.1.8006 > 127.0.0.1.56710: Flags [S.], seq 2881349854, ack 1652959376, win 43690, options [mss 65495,sackOK,TS val 8433172 ecr 8433172,nop,wscale 7], length 0
11:55:35.724660 IP 127.0.0.1.56710 > 127.0.0.1.8006: Flags [.], ack 1, win 342, options [nop,nop,TS val 8433172 ecr 8433172], length 0

######客户端发送58字节的报文（ seq 1:59中的59=seq(1)+length(58) ）
11:55:35.724966 IP 127.0.0.1.56710 > 127.0.0.1.8006: Flags [P.], seq 1:59, ack 1, win 342, options [nop,nop,TS val 8433173 ecr 8433172], length 58
######服务端回复ACK确认报文（ACK=对方SEQ+报文长度=1+58=59）
11:55:35.724970 IP 127.0.0.1.8006 > 127.0.0.1.56710: Flags [.], ack 59, win 342, options [nop,nop,TS val 8433173 ecr 8433173], length 0

######服务端主动发送58字节的报文（ seq 1:59中的59=seq(1)+length(58) ）
11:55:35.725006 IP 127.0.0.1.8006 > 127.0.0.1.56710: Flags [P.], seq 1:59, ack 59, win 342, options [nop,nop,TS val 8433173 ecr 8433173], length 58
######客户端回复ACK确认报文（ACK=对方SEQ+报文长度=1+58=59）
11:55:35.725008 IP 127.0.0.1.56710 > 127.0.0.1.8006: Flags [.], ack 59, win 342, options [nop,nop,TS val 8433173 ecr 8433173], length 0

######服务端调用close函数关闭连接（发送FIN标志的报文后进入FIN_WAIT_1状态）
11:55:35.725018 IP 127.0.0.1.8006 > 127.0.0.1.56710: Flags [F.], seq 59, ack 59, win 342, options [nop,nop,TS val 8433173 ecr 8433173], length 0
######客户端回复ACK确认报文（客户端进入CLOSE_WAIT状态，服务端进入FIN_WAIT_2状态）
######ACK=对方SEQ+1=59+1=60
11:55:35.766501 IP 127.0.0.1.56710 > 127.0.0.1.8006: Flags [.], ack 60, win 342, options [nop,nop,TS val 8433215 ecr 8433173], length 0

######客户端5秒后再次发送58字节的报文（CLOSE_WAIT状态还是可以向对端发送报文的）
11:55:40.736161 IP 127.0.0.1.56710 > 127.0.0.1.8006: Flags [P.], seq 59:117, ack 60, win 342, options [nop,nop,TS val 8438184 ecr 8433173], length 58
######服务端发送RST链路重置标志的报文（客户端关闭）
11:55:40.736190 IP 127.0.0.1.8006 > 127.0.0.1.56710: Flags [R], seq 2881349914, win 0, length 0

2、netstat命令监控：由于脚本中做了sleep 1的操作，所以监控不是很及时，对小节4的图中关键的4个部分进行分析。其中Recv-Q对应的值为59，它不同于前文中LISTEN状态下Recv-Q对应的值（表示由内核完成的已就绪队列中的连接数），这里表示客户端接收缓存中有59字节的数据等待客户端进程去读取。另外为什么是59字节而不是服务端发送的58字节数据？LZ这里也不是很确定。

[vfhky@typecodes epoll]$ ./linux_epoll_simple_sndmsg_netstat.sh 
######服务端建立监听
Active Internet connections (w/o servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 0.0.0.0:8006            0.0.0.0:*               LISTEN      2791/linux_epoll_se

######由于服务端接收并回复报文后主动调用close函数关闭了链路，服务端进入FIN_WAIT1状态，客户端进入CLOSE_WAIT状态。
Active Internet connections (w/o servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 0.0.0.0:8006            0.0.0.0:*               LISTEN      2791/linux_epoll_se 
tcp       59      0 127.0.0.1:56710         127.0.0.1:8006          CLOSE_WAIT  2804/linux_epoll_si 
tcp        0      1 127.0.0.1:8006          127.0.0.1:56710         FIN_WAIT1   -

######客户端回复了ACK确认报文后，服务端进入FIN_WAIT2状态
Active Internet connections (w/o servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 0.0.0.0:8006            0.0.0.0:*               LISTEN      2791/linux_epoll_se 
tcp       59      0 127.0.0.1:56710         127.0.0.1:8006          CLOSE_WAIT  2804/linux_epoll_si 
tcp        0      0 127.0.0.1:8006          127.0.0.1:56710         FIN_WAIT2   -

######由于服务端回复了RST标志的报文导致链路重置
Active Internet connections (w/o servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 0.0.0.0:8006            0.0.0.0:*               LISTEN      2791/linux_epoll_se

3、客户端进程执行过程分析：

###### 客户端执行过程
[vfhky@typecodes epoll]$ linux_epoll_simple_sndmsg
i_send_len=[58].        //第1次发送报文（正常）
i_send_len=[58].        //5秒后再次发送报文，那么会收到RST标志的应答报文
[vfhky@typecodes epoll]$

6 得出结论

通过小节5中的具体分析可以看到在服务端调用close函数关闭了客户端的连接后进入FIN_WAIT_1状态，那么客户端立马进入了CLOSE_WAIT状态。而服务端在收到客户端回复的ACK报文后进入FIN_WAIT_2状态。

因为处于CLOSE_WAIT状态的一方仍然可以向对端发送报文，所以客户端在休眠5秒后再次向服务端发送了58字节的报文。但是此时的服务端已经关闭了链路（FIN_WAIT_2状态），所以Linux内核自动发送了一个RST复位标志的报文给客户端。

但是为什么客户端进程在收到RST报文后会关闭呢？原因和《Linux TCP通信出现CLOSE_WAIT后导致服务端进程挂掉》是一样的，就是Linux内核产生软中断，发送SIGPIPE信号给客户端进程，导致其默认终止了。这点可以通过设置客户端程序中#define SIGNAL_HANDLE 0为1来验证，执行的效果如下图所示：

那么问题又来了，由于捕捉了SIGPIPE信号（对应值为13）后，客户端进程不会终止，所以进入了while死循环。同时由于捕捉了SIGINT信号（对应值为2），导致在客户端所在的Linux会话终端上无法使用Ctrl+C来终止进程，最后只能使用kill信号来终止客户端！

7 附录：

以上就是Linux TCP通信中客户端出现CLOSE_WAIT后进入死循环的一个实例以及分析过程，下面是客户端程序linux_epoll_simple_sndmsg_netstat.c，工作流程很简单。

/** 
 * @FileName    linux_epoll_simple_sndmsg.c
 * @Describe    A simple example for creating a listen as a server and simulate generate a sigpipe signal in linux.
 * @Author      vfhky 2017-03-10 12:49 https://typecodes.com/cseries/tcpclosewaitfinwaitrst1.html
 * @Compile     gcc linux_epoll_simple_sndmsg.c -o linux_epoll_simple_sndmsg
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <signal.h>

#define IPADDR "127.0.0.1"
#define SERVPORT 8006
#define MAXLINE 1024

#define SIGNAL_HANDLE 0
void sig_handle( int signal )
{
    printf( "Receive a signal=[%d].\n", signal );
    return;
}


int main( int argc, char **argv )
{
#if SIGNAL_HANDLE
    struct sigaction new_act, old_act;
    new_act.sa_handler = sig_handle;
    new_act.sa_flags = 0;
    sigemptyset( &new_act.sa_mask );
    sigaction( SIGPIPE, &new_act, &old_act );
    sigaction( SIGINT, &new_act, &old_act );
#endif

    //发送缓存区
    char buf[MAXLINE] = {0x00};
    //成功发送的字节数
    unsigned int i_send_len = 0;

    int sockfd;
    struct sockaddr_in serv_addr;

    //创建1个socket描述符
    if((sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1)
    {
        perror("socket error \n");
        exit(1);
    }

    bzero( &serv_addr, sizeof(serv_addr) );
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERVPORT);
    inet_pton( AF_INET, IPADDR, &serv_addr.sin_addr );

    if( connect( sockfd, (struct sockaddr *)&serv_addr, sizeof(struct sockaddr) ) ==-1 )
    {
        perror("connect \n");
        exit(1);
    }
    printf( "sockfd=[%d].\n", sockfd );
    while( 1 )
    {
        sprintf( buf, "HTTP/1.0 200 OK\r\nContent-type: text/plain\r\n\r\n%s", "Hello world!\n" );
        if( ( i_send_len = write( sockfd, buf, strlen(buf) ) ) > 0 )
        {
            printf( "i_send_len=[%d].\n", i_send_len );
        }
        sleep(5);
    }

    return 0;
}

使用sed和awk查找和替换字符串处理Makefile文件（二）

2017-03-09T16:45:00+08:00

在前文中演示了使用awk和sed命令正则查找和替换Makefile文件的匹配内容，这篇文章依然使用这个Makefile文件作为awk和sed命令正则匹配查找、替换和删除操作。

1 功能需求

由于之前在BZ自己CenOS7中的C/C++工程部分Makefile文件在make clean操作时的语句可以优化，也就是可以把-$(RM) $(ULT_BIN)和-$(RM) $(ULT_BIN)这两句写成一句-$(RM) $(ULT_BIN) $(ULT_BIN)。

2 shell程序

下面的这份shell脚本比较简单，直接运行./sedawkfindreplace2.sh即可。在for ... in的Makefile文件遍历中，先利用了awk命令的正则匹配查找、替换操作，然后是sed命令执行正则匹配查找、替换以及删除操作。

程序难点应该在于对$符号的正则匹配（它本来表示结尾，所以需要转义），可以看到awk和sed对它的正则匹配形式是不一样的。

另外，脚本中sed命令通过-e参数先执行正则匹配和替换操作，然后执行正则匹配删除操作。

#!/bin/bash
# FileName:      sedawkfindreplace2.sh
# Description:   Basic usage of sed and awk command such as find and replace words in the regular expression.
# Simple Usage:  ./sedawkfindreplace1.sh
# (c) 2017.3.9 vfhky https://typecodes.com/linux/sedawkfindreplace2.html
# https://github.com/vfhky/shell-tools/blob/master/filehandle/sedawkfindreplace2.sh


# Dir to be handled.
SRC_DIR="/home/vfhky/shell"
# The makefile you want to modify.
SEARCH_NAME="Makefile*"
# The maximum depth of the dirs where files such as Makefile you're dealing with lies in.
MAXDEPTH=10

# Get the target files you want to modify.
ALL_MAKEFILE=$(find ${SRC_DIR} -maxdepth ${MAXDEPTH} -type f -name "${SEARCH_NAME}")


# Traverse the target files.
for FILE in ${ALL_MAKEFILE}
do
    #### Ways recommended: find "-$(RM) $(ULT_BIN)" by awk command.
    #awk '/-\$\(RM\) \$\(ULT_BIN\)/{printf( "[%s:%d]: %s\n", FILENAME, NR, $0) }' ${FILE}

    #### replace "-$(RM) $(ULT_BIN)" with "-$(RM) $(ULT_BIN) $(ULT_LIBS)" using awk command.
    # awk '{sub(/-\$\(RM\) \$\(ULT_BIN\)/,"-\$\(RM\) \$\(ULT_BIN\) \$\(ULT_LIBS\)"); print $0}' ${FILE} > ${FILE}.tmp; cp ${FILE}.tmp ${FILE}; rm -rf ${FILE}.tmp


    #### find "-$(RM) $(ULT_BIN)" by sed command.
    #sed -n "/-\$(RM) \$(ULT_BIN)/p" ${FILE}

    #### Ways recommended: Step1. replace "-$(RM) $(ULT_BIN)" with "-$(RM) $(ULT_BIN) $(ULT_LIBS)" using sed command.
    #### Step2. delete the line contains the words "-$(RM) $(ULT_LIBS)".
    sed -i -e "s#-\$(RM) \$(ULT_BIN)#-\$(RM) \$(ULT_BIN) \$(ULT_LIBS)#" -e "/-\$(RM) \$(ULT_LIBS)/d" ${FILE}
done

exit 0

3 脚本测试

BZ在虚拟机的/home/vfhky/shell目录复制了5个错误的Makefile文件，然后先做正则查找测试，结果如下图所示：

4 Linux find 命令中正则

在find命令的某个参数使用正则，那么最好对这个对数加上双引号，正如上面的代码"${SEARCH_NAME}"所示，否则会出现下面的错误：

find: paths must precede expression: Makefile1
Usage: find [-H] [-L] [-P] [-Olevel] [-D help|tree|search|stat|rates|opt|exec] [path...] [expression]

5 脚本管理

目前已经把这个脚本放在Github了，地址是https://github.com/vfhky/shell-tools，以后脚本的更新或者更多好用的脚本也都会加入到这个工程中。

使用sed和awk查找和替换字符串处理Makefile文件（一）

2017-02-22T16:39:00+08:00

在《使用sed命令批量处理Makefile文件的脚本》文中使用sed命令对前文中的Makefile文件进行了替换、追加和删除操作，这篇文章通过使用sed和awk命令对该Makefile文件的某个字符串进行正则匹配查找以及替换。

1 功能需求

由于之前在BZ自己CenOS7中的C/C++工程部分Makefile文件有问题（CC变量被赋值为CC := g++），所以想写个shell脚本批量把Makefile文件出错的部分全部替换成CC := gcc。

2 shell程序

下面的这份shell脚本比较简单，直接运行./sedawkfindreplace1.sh即可。在for ... in的Makefile文件遍历中，先利用了awk命令的正则匹配查找、替换操作，然后是sed命令执行正则匹配查找、替换操作。

程序难点应该在于对g++中的+号正则匹配。awk的sub函数的正则替换时，需要对g++处理成g\+\+形式，而其它正常都写成g+\+的形式。

#!/bin/bash
# FileName:      sedawkfindreplace1.sh
# Description:   Basic usage of sed and awk command such as find and replace words in the regular expression.
# Simple Usage:  ./sedawkfindreplace1.sh
# (c) 2017.2.22 vfhky https://typecodes.com/linux/sedawkfindreplace1.html
# https://github.com/vfhky/shell-tools/blob/master/filehandle/sedawkfindreplace1.sh


# Dir to be handled.
SRC_DIR="/home/vfhky/shell"
# The makefile you want to modify.
SEARCH_NAME="Makefile*"
# The maximum depth of the dirs where files such as Makefile you're dealing with lies in.
MAXDEPTH=10

# Get the target files you want to modify.
ALL_MAKEFILE=$(find ${SRC_DIR} -maxdepth ${MAXDEPTH} -type f -name "${SEARCH_NAME}")


# Traverse the target files.
for FILE in ${ALL_MAKEFILE}
do
    #### Ways recommended: find "^CC        := g++" by awk command.
    awk '/CC        := g+\+/{printf( "[%s:%d]: %s\n", FILENAME, NR, $0) }' ${FILE}
    #### replace "g++" with "gcc" using awk command.
    # awk '{sub(/^CC        := g\+\+/,"CC       := gcc"); print $0}' ${FILE} > ${FILE}.tmp; cp ${FILE}.tmp ${FILE}; rm -rf ${FILE}.tmp


    #### find "CC       := g++" by sed command.
    # sed -n "/^CC      := g+\+/p" ${FILE}
    #### Ways recommended: replace "g++" with "gcc" using sed command.
    # sed -i "s#^CC     := g+\+#CC      := gcc#" ${FILE}
done

exit 0

3 脚本测试

BZ在虚拟机的/home/vfhky/shell目录复制了5个错误的Makefile文件，然后先做正则查找测试，结果如下图所示：

4 Linux find 命令中正则

在find命令的某个参数使用正则，那么最好对这个对数加上双引号，正如上面的代码"${SEARCH_NAME}"所示，否则会出现下面的错误：

find: paths must precede expression: Makefile1
Usage: find [-H] [-L] [-P] [-Olevel] [-D help|tree|search|stat|rates|opt|exec] [path...] [expression]

5 脚本管理

目前已经把这个脚本放在Github了，地址是https://github.com/vfhky/shell-tools，以后脚本的更新或者更多好用的脚本也都会加入到这个工程中。

C++删除map容器中指定值的元素

2016-06-26T10:26:00+08:00

map容器是C++ STL中的重要一员，平时会遇到删除map容器中value为指定元素的问题，例如删除所有字符串为"123"或者能整除3的元素。

1 map容器下的方法说明

由于map容器下的方法较多，这里只列举代码中用到的几个方法：

insert()方法：

//插入val到pos的后面，然后返回一个指向这个元素的迭代器
iterator insert( iterator pos, const pair<KEY_TYPE,VALUE_TYPE> &val );
//插入start到end的元素到map中
void insert( input_iterator start, input_iterator end );
//只有在val不存在时插入val。返回值是一个指向被插入元素的迭代器和一个描述是否插入的bool值
pair<iterator, bool> insert( const pair<KEY_TYPE,VALUE_TYPE> &val );

erase()方法：

//erase()函数删除在pos位置的元素，或者删除在start和end之间的元素，或者删除那些值为key的所有元素
void erase( iterator pos );
void erase( iterator start, iterator end );
size_type erase( const KEY_TYPE &key );

iterator迭代器。

2 删除map容器中指定的字符串

下面代码中map容器的value对应的是一个string类型的指针，在初始化时类似于string *p = new string("123");。

/**
 * @FileName    map_del_str.cpp
 * @Describe    A simple example for deleting an element of string in map.
 * @Author      vfhky 2016-06-26 10:26 https://typecodes.com/cseries/mapdelintstring.html
 * @Compile     g++ map_del_str.cpp -o map_del_str
 * @Reference   
 */
#include <iostream>
#include <map>

using namespace std;
#define TOTAL 10
#define DEL_STR "123"


/**
 * 删除map中所有元素为str的数据
 */
void fun( map<int, string *> &map1, const string str )
{
    map<int, string *>::iterator it;
    int i_Total = 0;
    for( it=map1.begin(); it!=map1.end(); )
    {
        if( *(it->second) == str )
        {
            /**
             * 123 123 123 123 123 123 123 123 123 123 
             */
            cout << *(it->second) << " ";

            //一定要先释放内存的控制
            delete it->second;
            it->second = NULL;

            //再删除迭代
            map1.erase(it++);
            ++i_Total;
        }
        else
        {
            it++;
        }
    }

    //i_Total=[10]
    cout << endl << "i_Total=[" << i_Total << "]" << endl;
}

int main( int argc, char **argv )
{
    map<int, string *> map1;

    //初始化map1
    for( int i=0; i<TOTAL; i++ )
    {
        map1.insert( pair<int, string *>(i,new string("123")) );
        //map1[i] = new string("123");
    }

    //删除为DEL_STR的元素
    fun( map1, DEL_STR );

    //查看最后的数据
    map<int, string *>::iterator it1;
    for( it1=map1.begin(); it1!=map1.end(); ++it1 )
    {
        cout << "map1[" << it1->first << "]=[" << *(it1->second) << "]" << endl;
    }
    return 0;
}

效果如下图所示：

3 删除map容器中指定的整型数据

下面代码中map容器的value对应的是一个int数据，在初始化时可以直接使用map1[i] = i语句。

/**
 * @FileName    map_del_int.cpp
 * @Describe    A simple example for deleting an element of interger in map.
 * @Author      vfhky 2016-06-26 10:26 https://typecodes.com/cseries/mapdelintstring.html
 * @Compile     g++ map_del_int.cpp -o map_del_int
 * @Reference   
 */
#include <iostream>
#include <map>

using namespace std;
#define TOTAL 100
#define DEL_INT 3


/**
 * 删除map中所有值整除NUM的元素
 */
void fun( map<int,int> &map1, const int NUM )
{
    map<int, int>::iterator it;
    int i_Total = 0;
    for( it=map1.begin(); it!=map1.end(); )
    {
        if( it->second % NUM == 0 )
        {
            /**
             * 0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45 48 51 54 57 60 63 66 69 72 75 78 81 84 87 90 93 96 99 
             */
            cout << it->second << " ";
            map1.erase(it++);
            ++i_Total;
        }
        else
        {
            it++;
        }
    }
    cout << endl << "i_Total=[" << i_Total << "]" << endl;
}

int main( int argc, char **argv )
{
    map<int, int> map1;

    //初始化map1
    for( int i=0; i<TOTAL; i++ )
    {
        map1.insert(pair<int, int>(i,i));
        //map1[i] = i;
    }

    //删除整除3的元素
    fun( map1, DEL_INT );

    //查看最后的数据
    map<int, int>::iterator it1;
    for( it1=map1.begin(); it1!=map1.end(); ++it1 )
    {
        cout << "map1[" << it1->first << "]=[" << it1->second << "]" << endl;
    }
    return 0;
}

效果如下图所示：

4 附录

STL容器分顺序容器Sequence Container（包含vector，deque，list容器）和关联容器Associative Container（包含set，multiset，map，multimap容器）。C++标准中，Sequence Container的erase函数会返回iterator，但Associative Container不返回iterator。所以在小节2、小节3中使用map1.erase(it++)而不是直接map1.erase(it)。

使用sed命令批量处理Makefile文件的脚本

2016-06-18T15:56:00+08:00

前面写了一篇文章《Linux C/C++工程中可生成ELF、动/静态库文件的通用Makefile》，里面的Makefile代码有个不好的地方需要修改。当编译.cpp文件时，使用的STD_OPT变量仍然是编译.c文件时的参数-std=c99，这个在C++中是不支持的。

1 sed命令的简要说明

由于sed命令可用的参数太多了，这里只列举脚本中用到的几个参数：

sed -i：直接修改文件而不是将处理的结果在屏幕上输出；
sed -e：多个操作action按顺序执行；
sed -e '/help:/ a 要追加的内容'：表示在help:文字后面追加内容。

2 具体代码

代码比较简单，直接执行命令./handle_makefile.sh即可。其中handle函数主要用到了正则替换，追加，删除这三个action操作。

#!/bin/bash
# FileName:      handle_makefile.sh
# Description:   Simple usage of sed command to modify many Makefiles in batch processing.
# Simple Usage:  ./handle_makefile.sh
# (c) 2016 vfhky https://typecodes.com/linux/handlemakefilebysed.html
# https://github.com/vfhky/shell-tools/blob/master/filehandle/handle_makefile.sh


# Dir to be handled.
SRC_DIR="/home/vfhky/shell"
# The makefile you want to modify.
SEARCH_NAME="Makefile"

####
# @param:   $1  Name of the file
####
function handle()
{
    echo -e 'Handling file=['$1']'
    sed -i \
        -e 's/-std=c99 -D_GNU_SOURCE /-D_GNU_SOURCE/'   \
        -e 's/CC        += $(STD_OPT)/CC        += -std=c99 $(STD_OPT)/'    \
        -e '/help:/ a\
    @echo CC=[$(CC)]\
    @echo CXX=[$(CXX)]\
    @echo CFLAGS=[$(CFLAGS)]\
    @echo CXXFLAGS=[$(CXXFLAGS)]'   \
        -e '/   @echo STD_OPT=\[$(STD_OPT)\]/d' \
        -e '/   @echo CFLAGS=\[$(CFLAGS)\]/d'   \
         $1
    #echo "" | awk '{fflush()}'
}

# Get the target files you want to modify.
ALL_MAKEFILE=$(find ${SRC_DIR} -type f -name ${SEARCH_NAME})


# Traverse the target files.
for FILE in ${ALL_MAKEFILE}
do
    handle ${FILE}
    if [ $? -gt 0 ]; then
        echo 'failed.'
        #echo "" | awk '{fflush()}'
    fi  
done

3 脚本执行结果

如上图所示，脚本不断遍历src目录下的Makefile文件，然后进行处理。

4 脚本管理

目前已经把这个脚本放在Github了，地址是https://github.com/vfhky/shell-tools，以后脚本的更新或者更多好用的脚本也都会加入到这个工程中。

自己实现inet_aton和inet_ntoa函数功能

2016-04-08T13:11:00+08:00

之前遇到过要自己实现inet_aton和inet_ntoa函数功能的问题，这里总结一下。

1 基本知识

网络字节序是大端模式，那么内存中的低地址存放的是数据的高位，内存中的高地址存放的是数据的低位。 inet_aton是将IPv4地址（点分法）转换成对应的十进制整数；而inet_ntoa是将十进制整数转换成对应的IPv4地址（点分法）。

2 完整代码

/**
 * @FileName    network_selfdefine.c
 * @Describe    A simple example for using sigprocmask and sigsuspend functions in linux.
 * @Author      vfhky 2016-04-08 13:11 https://typecodes.com/cseries/networkselfdefineconv.html
 * @Compile     gcc network_selfdefine.c -o network_selfdefine
 */
#include <stdio.h>
#include <ctype.h>
#include "print.h"
#define IP_ADRESS "192.168.1.177"

/*
 * 将IPv4地址（点分法）转换成对应的十进制整数
 * 原函数声明：
 * int inet_aton(const char *cp, struct in_addr *inp);
 */
unsigned int __inet_aton( const char *c_ipaddr )
{
    unsigned int u_ipaddr = 0;
    unsigned int u_tmp = 0;
    char c;
    int i_base = 10;
    int i_shift = 0;
    int i_recycle = 0;

    c = *c_ipaddr;
    while( 1 )
    {
        u_tmp = 0;
        while( 1 )
        {
            //如果是数字
            if( isdigit(c) )
            {
                u_tmp = (u_tmp * i_base) + (c - 0x30);
                c = *++c_ipaddr;
            }
            else
            {
                //如果不是数字而是.符号，说明.符号前面的数据已经处理完毕
                break;
            }
        }

        //字节移位，注意网络字节序是大端模式
        i_shift = 8*i_recycle++;
        u_tmp <<= i_shift;
        u_ipaddr += u_tmp;

        //对点(.)符号的处理
        if( c == '.' )
        {
            c = *++c_ipaddr;
        }
        else
        {
            //如果是其它符号（例如结束符\0等）则跳出整个循环
            break;
        }
    }

    //检查是否包含非结束符、空格等符号，是则返回0
    if( c != '\0' && ( !isspace(c) ) )
        goto ret_0;

    return u_ipaddr;
ret_0:
    return (0);
}

/**
 * 将十进制整数转换成对应的IPv4地址（点分法），其中由于网络字节序是大端表示，所以第一个字节对应的是整数的低位byte[0]
 * 原函数声明：
 * int inet_aton(const char *cp, struct in_addr *inp);
 */
static char buffer[16];
char *  __inet_ntoa( unsigned int in )
{
    unsigned char *bytes = (unsigned char *) &in;
    snprintf( buffer, sizeof (buffer), "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3] );
    return buffer;
}

int main( int argc, char **argv )
{
    PRINT( "IP_ADRESS[%s] ==> [%lu].", IP_ADRESS, __inet_aton( IP_ADRESS ) );
    PRINT( "[%lu]=[0x%x].", __inet_aton( IP_ADRESS ), __inet_aton( IP_ADRESS ) );
    PRINT( "Network orders[%lu] ==> [%s].", __inet_aton( IP_ADRESS ), __inet_ntoa(__inet_aton( IP_ADRESS )) );
    return 0;
}

3 编译执行

使用《Linux C/C++工程中可生成ELF、动/静态库文件的通用Makefile》一文中的Makefile文件进行程序编译（当然也可以使用命令进行编译gcc network_selfdefine.c -o network_selfdefine），接着执行该程序，得到如下图所示的结果：

需要说明的是从第87行输出的[2969675968]=[0xb101a8c0].可以看出，低字节的0xC0(即192)由于网络字节序大端模式的关系存放在内存中的高位，高字节的0xB1(即177)存放在内存中的低位。

4 附录

关于inet_aton的man说明：

[vfhky@typecodes xlei]$ man inet_aton
INET(3)                         Linux Programmer's Manual                        INET(3)

NAME
       inet_aton,   inet_addr,   inet_network,   inet_ntoa,  inet_makeaddr,  inet_lnaof,
       inet_netof - Internet address manipulation routines

SYNOPSIS
       #include <sys/socket.h>
       #include <netinet/in.h>
       #include <arpa/inet.h>

       int inet_aton(const char *cp, struct in_addr *inp);

       in_addr_t inet_addr(const char *cp);

       in_addr_t inet_network(const char *cp);

       char *inet_ntoa(struct in_addr in);

       struct in_addr inet_makeaddr(int net, int host);

       in_addr_t inet_lnaof(struct in_addr in);

       in_addr_t inet_netof(struct in_addr in);

   Feature Test Macro Requirements for glibc (see feature_test_macros(7)):

       inet_aton(), inet_ntoa(): _BSD_SOURCE || _SVID_SOURCE

DESCRIPTION
       inet_aton() converts the Internet host address cp from the IPv4  numbers-and-dots
       notation  into binary form (in network byte order) and stores it in the structure
       that inp points to.  inet_aton() returns nonzero if the address is valid, zero if
       not.

关于inet_aton的man说明：

[vfhky@typecodes ~]$ man inet_ntoa
INET(3)                         Linux Programmer's Manual                        INET(3)

NAME
       inet_aton,   inet_addr,   inet_network,   inet_ntoa,  inet_makeaddr,  inet_lnaof,
       inet_netof - Internet address manipulation routines

SYNOPSIS
       #include <sys/socket.h>
       #include <netinet/in.h>
       #include <arpa/inet.h>

       int inet_aton(const char *cp, struct in_addr *inp);

       in_addr_t inet_addr(const char *cp);

       in_addr_t inet_network(const char *cp);

       char *inet_ntoa(struct in_addr in);

       struct in_addr inet_makeaddr(int net, int host);

       in_addr_t inet_lnaof(struct in_addr in);

       in_addr_t inet_netof(struct in_addr in);

   Feature Test Macro Requirements for glibc (see feature_test_macros(7)):

       inet_aton(), inet_ntoa(): _BSD_SOURCE || _SVID_SOURCE

DESCRIPTION
       inet_aton() converts the Internet host address cp from the IPv4  numbers-and-dots
       notation  into binary form (in network byte order) and stores it in the structure
       that inp points to.  inet_aton() returns nonzero if the address is valid, zero if
       not.

C语言删除无序整型数组中的重复元素及时间复杂度

2016-03-23T22:44:00+08:00

遇到一个题，大概要求是写一个函数处理来去掉一个无序的整型数组（例如int i_arr[] = { 1, 2, 2, 3, 4, 2, 3, 5 };）中重复的元素，并返回最终的长度。

1 思路

看到这道题的时候，第一反应就是需要删除元素，然后联想到单链表。但是后面一想还是不划算，因为单链表还得先把数组中的元素遍历到链表节点中。

换一下思路，可以先创建另一个整型数组（大小和原数组一样），然后正向遍历数组中的元素，比较当前元素和它前面所有的元素是否重复，如果这个整数之前没有出现过，那么就放到新的数组中，于是有了小节2中的Method1；另外一种就是不需要创建新的数组，在正向遍历数组中的元素时，比较当前元素和它后面所有的元素是否重复，如果重复就把后面的所有元素向前移动（即覆盖），于是有了小节2中的Method2。

2 完整程序

程序中第104行的--j语句非常重要，这是为了避免当前元素连续出现3次（或以上）而没有被删除。

/**
 * @FileName    int_del_repeat.c
 * @Describe    A simple example for deleting the repeated elements in a deldisor interger array.
 * @Author      vfhky 2016-03-23 22:44 https://typecodes.com/cseries/deldisorderintarrrepeatele.html
 * @Compile     gcc int_del_repeat.c -o int_del_repeat
 */
#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include "print.h"

int f_del1( int *i, int iLen );
int f_del2( int *i_f_del2, int len );

int main( int argc, char **argv )
{
    //The test array.
    int i_arr1[26] = { 1, 3, 2, 1, 2, 3, 4, 5, 5, 6, 7, 8, 12, 11, 22, 3, 7, 5, 13, 4, 5, 8, 7, 6, 23, 12 };
    int i_arr2[26] = { 1, 3, 2, 1, 2, 3, 4, 5, 5, 6, 7, 8, 12, 11, 22, 3, 7, 5, 13, 4, 5, 8, 7, 6, 23, 12 };
    int i_ar2r[26] = { 1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 7, 8, 11, 11, 12, 13, 13, 13, 13, 14, 15, 15, 17, 18, 23, 24 };
    int i_ar3r[26] = { 1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 7, 8, 11, 11, 12, 13, 13, 13, 13, 14, 15, 15, 17, 18, 23, 24 };

    //The length of .
    int i_p_len = 0;

    #if 1
    i_p_len = f_del1( i_ar2r, 26 );
    PRINT( "len=[%d].", i_p_len );
    #endif

    PRINT( "------------------------------\n" );

    #if 1
    i_p_len = f_del2( i_ar3r, 26 );
    PRINT( "len=[%d].", i_p_len );
    #endif

    return 0;
}

//Method 1: Using malloc to init an array for storing the elements after deleting the repeated ones.
int f_del1( int *array, int iLen )
{
    int i = 1;
    int i_recycle = 0;
    //Flags to store an element into the array i_f_del1.
    int i_flag = 1;
    //Length of the sorted array, name as i_f_del1.
    int i_f_del1_len = 1;

    //Init an array for storing the elements after deleting the repeated ones.
    int *i_f_del1 = (int *)malloc( iLen*sizeof(int) );
    //Init the first interger element.
    *i_f_del1 = *array;

    while( i < iLen )
    {
        i_flag = 1;
        i_recycle = 0;
        while( i_recycle < i )
        {
            if( array[i] == array[i_recycle++] )
            {
                i_flag = 0;
                break;
            }
        }

        //If i_flag equals 1, we should put the current element to the array i_f_del1.
        if( i_flag )
        {
            i_f_del1[i_f_del1_len++] = array[i];
        }

        ++i;
    }

#if 1
    for( i=0; i<i_f_del1_len; i++ )
    {
        PRINT( "i_f_del1[%d]=[%d].", i, i_f_del1[i] );
    }
#endif

    return i_f_del1_len;
}

//Method 2: cover up the repeated elements.
int f_del2( int *i_f_del2, int len )
{
    int i = 0, j = 0, k = 0;
    for( i=0; i<len; i++ )
    {
        for( j=i+1; j<len; j++ )
        {
            if( i_f_del2[i] == i_f_del2[j] )
            {
                for( k=j+1; k < len; ++k )
                {
                    i_f_del2[k-1] = i_f_del2[k];        //cover up
                }
                --len;
                //Key step to avoiding the continuous elements repeated more than 2 times.
                --j;
            }
        }
    }

    #if 1
    for( i=0; i<len; ++i )
    {
        PRINT( "i_f_del2[%d]=[%d].", i, i_f_del2[i] );
    }
    #endif

    return len;
}

3 测试执行

使用《Linux C/C++工程中可生成ELF、动/静态库文件的通用Makefile》一文中的Makefile文件进行程序编译，当然也可以使用命令进行编译gcc int_del_repeat.c -o int_del_repeat。

4 时间复杂度

Method 2中的时间复杂度为O(N＾2)，Method 2中的时间复杂度为O(N＾3)。

UNIX环境高级编程（APUE）之单实例守护进程

2016-03-14T17:52:00+08:00

在UNIX环境高级编程（APUE）中提到了守护进程的创建方法，思路很清晰，所以这里通过代码具体研究下。

1 完整程序：单实例守护进程

根据APUE的介绍，创建守护进程基本需要如下7个步骤。需要注意的是由于守护进程没有TTY（控制终端），所以代码中部分特意写上去的printf语句是不会输出到终端界面上的。

/**
 * @FileName    daemon_process.c
 * @Describe    A simple example for creating a single object of daemon process in linux.
 * @Author      vfhky 2016-03-14 17:52 https://typecodes.com/cseries/apuesingledaemonprocess.html
 * @Compile     gcc daemon_process.c -o daemon_process
 * @Reference   program list 13-1 in APUE.
 */
#include <stdio.h>
#include <unistd.h>
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <syslog.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/resource.h>
#include <errno.h>

#define PRINT_PID() printf( "Row[%d]: getpid=[%d].\n", __LINE__, getpid() )
//守护进程对应的用户必须对该文件具有访问权限
#define LOCK_FILE "/home/vfhky/daemon_process.pid"
#define MAXLINE 1024


/**
 * Print a message and return to caller.
 * Caller specifies "errnoflag".
 */
static void err_doit(int errnoflag, int error, const char *fmt, va_list ap)
{
    char    buf[MAXLINE];

    vsnprintf(buf, MAXLINE, fmt, ap);
    if (errnoflag)
        snprintf(buf+strlen(buf), MAXLINE-strlen(buf), ": %s",
                 strerror(error));
    strcat(buf, "\n");
    fflush(stdout);     /* in case stdout and stderr are the same */
    fputs(buf, stderr);
    fflush(NULL);       /* flushes all stdio output streams */
}

/**
 * Fatal error unrelated to a system call.
 * Print a message and terminate.
 */
void err_quit(const char *fmt, ...)
{
    va_list     ap;

    va_start(ap, fmt);
    err_doit(0, 0, fmt, ap);
    va_end(ap);
    exit(1);
}


void daemonize(const char *cmd)
{
    int                 i, fd0, fd1, fd2;
    pid_t               pid;
    struct rlimit       rl;
    struct sigaction    sa;

    /**
     * 第一步：设置文件模式屏蔽字为0
     * Clear file creation mask.
     */
    umask(0);

    /**
     * 获取最大的文件描述符数目
     * Get maximum number of file descriptors.
     */
    if (getrlimit(RLIMIT_NOFILE, &rl) < 0)
        err_quit("%s: can't get file limit", cmd);

    /**
     * 第二步：创建一个子进程，使父进程退出
     * Become a session leader to lose controlling TTY.
     */
    if ((pid = fork()) < 0)
        err_quit("%s: can't fork", cmd);
    else if (pid != 0) /* parent */
        exit(0);

    PRINT_PID();

    /**
     * 第三步：创建一个新的会话ID
     */
    setsid();

    /**
     * Ensure future opens won't allocate controlling TTYs.
     */
    sa.sa_handler = SIG_IGN;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    if ( sigaction(SIGHUP, &sa, NULL) < 0 )
        err_quit( "%s: can't ignore SIGHUP" );
    if( ( pid = fork() ) < 0 )                  //再次创建一个子进程，同样使父进程退出
        err_quit("%s: can't fork", cmd);
    else if( pid != 0 ) /* parent */
        exit(0);

    PRINT_PID();

    /**
     * 第四步：切换当前工作目录到根目录
     * Change the current working directory to the root so
     * we won't prevent file systems from being unmounted.
     */
    if (chdir("/") < 0)
        err_quit("%s: can't change directory to /");

    /**
     * 第五步：关闭所有打开的文件描述符
     * Close all open file descriptors.
     */
    if (rl.rlim_max == RLIM_INFINITY)
        rl.rlim_max = 1024;
    for (i = 0; i < rl.rlim_max; i++)
        close(i);

    /**
     * 第六步：使/dev/null具有文件描述符0，1，2.
     * Attach file descriptors 0, 1, and 2 to /dev/null.
     */
    fd0 = open("/dev/null", O_RDWR);
    fd1 = dup(0);
    fd2 = dup(0);

    /**
     * Initialize the log file.
     * @para-in:    cmd: the identifier in the log.
     */
    openlog( cmd, LOG_CONS, LOG_DAEMON );
    if( fd0 != 0 || fd1 != 1 || fd2 != 2 )
    {
        syslog( LOG_ERR, "unexpected file descriptors %d %d %d", fd0, fd1, fd2 );
        exit(1);
    }

    /**
     * 第七步：通过文件锁避免重复运行多个守护进程
     */
    int lockfd = open( LOCK_FILE, O_RDWR );
    if( lockfd < 0 )
    {
        syslog( LOG_ERR, "Cannot lock file[%s], aborting[%s].\n", LOCK_FILE, strerror(errno) );
        //下面这一行无法打印到控制台，项目上应该打印到日志文件中
        printf( "Cannot lock file[%s], aborting[%s].\n", LOCK_FILE, strerror(errno) );
        exit(-1);
    }
    if( lockf(lockfd,F_TLOCK,0) < 0 )
    {
        syslog( LOG_ERR, "Daemon process is already running[%s].\n", strerror(errno) );
        //下面这一行无法打印到控制台，项目上应该打印到日志文件中
        printf( "Daemon process is already running[%s].\n", strerror(errno) );
        exit(-2);
    }
}

int main( int argc, char **argv )
{
    PRINT_PID();
    daemonize( "Daemon test." );
    //由于父进程退出，所有只有最后一个子进程执行下面的语句（休眠）
    printf( "This line will not be print for the daemon process has no terminate.\n" );
    while(1)
        sleep(120);
    return 0;
}

2 程序编译

使用《Linux C/C++工程中可生成ELF、动/静态库文件的通用Makefile》一文中的Makefile文件进行程序编译，当然也可以使用命令进行编译gcc daemon_process.c -o daemon_process。

3 创建第一个守护进程

如下图所示，程序先执行第178行main函数中的打印语句，输出当前第一个进程的PID值为25872；然后由于在daemonize函数中第一个进程(PID:25872)退出，所以它的子进程(PID:25873)执行第101行的打印语句；接着由于第二个进程(PID:25873)退出，那么它的子进程(PID:25874)执行第121行的打印语句；在关闭了所有文件描述符后，该子进程(PID:25874)打开标准输入/输出/错误流，最后该子进程成为由Linux系统init进程托管的孤儿进程，没有终端terminal，这也就是守护进程。

其中使用ps -axj|head -n 1; ps -axj|grep daemon_process命令发现子进程(PID:25874)的父进程为1进程(init进程)，终端TTY为空。

接着使用命令pstree -pul查看当前用户的所有进程情况，如下图所示，再次说明守护进程(PID:25874)创建成功了。

4 创建第二个守护进程

如果尝试再次创建一个同样的守护进程，如下图所示。执行命令ps -axj|head -n 1; ps -axj|grep daemon_process，发现仍然只有一个守护进程(PID:25874)，也就是创建第二个守护进程失败。

这时使用cat /var/log/message命令查看进程在Linux系统日志文件中打印的内容，如下图所示：

很显然程序执行到第160行，由于第一个守护进程对LOCK_FILE文件加锁的缘故而无法获取该文件的访问权限最终导致子进程(PID:25909)终止。于是，第二次创建守护进程失败了。

5 附录

关于openlog和syslog函数的使用方法，可以通过命令man 3 syslog查看，大概就是根据日志标识符（ident）和日志level（LOG_EMERG、LOG_ERR、LOG_WARNING等）和日志文件类型facility（LOG_CRON、LOG_MAIL、LOG_SYSLOG和默认的LOG_USER等）把进程的内容输出到Linux系统某一类型的日志文件中。

SYNOPSIS
    #include <syslog.h>

    void openlog(const char *ident, int option, int facility);
    void syslog(int priority, const char *format, ...);
    void closelog(void);

DESCRIPTION
    closelog()  closes  the descriptor being used to write to the system logger.
    The use of closelog() is optional.

    openlog() opens a connection to the system logger for a program.  The string
    pointed  to  by ident is prepended to every message, and is typically set to
    the  program  name.   If  ident  is  NULL,  the  program   name   is   used.
    (POSIX.1-2008 does not specify the behavior when ident is NULL.)

    The option argument specifies flags which control the operation of openlog()
    and subsequent calls to  syslog().   The  facility  argument  establishes  a
    default  to  be  used  if none is specified in subsequent calls to syslog().
    Values for option and facility are given below.  The  use  of  openlog()  is
    optional; it will automatically be called by syslog() if necessary, in which
    case ident will default to NULL.

    syslog() generates a log message, which will be distributed  by  syslogd(8).
    The  priority  argument is formed by ORing the facility and the level values
    (explained below).  The remaining arguments are a format,  as  in  printf(3)
    and  any  arguments  required  by  the format, except that the two character
    sequence %m will be replaced by the error message string strerror(errno).  A
    trailing newline may be added if needed.

Linux使用KILL 0检测进程是否存在

2016-03-14T11:48:00+08:00

之前遇到过kill( pid, 0 )的情况，由于平常没注意到kill函数的形参为0的情况，不知道它的作用。后面用man 2 kill命令查看了下kill函数的说明，发现可以用来检测进程的存在情况。

1 关于kill 0的说明1

从上图DESCRIPTION区域的文字可以看出，kill函数中的形参sig是0的话，那么不会向pid进程发送任何信号，但是仍然会继续检测错误（进程ID或者进程组ID是否存在）。kill函数的返回值和具体的错误信息如下：

RETURN VALUE
       On  success  (at least one signal was sent), zero is returned.  On error, -1
       is returned, and errno is set appropriately.

ERRORS
       EINVAL An invalid signal was specified.

       EPERM  The process does not have permission to send the signal to any of the
              target processes.

       ESRCH  The  pid  or  process  group  does  not exist.  Note that an existing
              process might be a zombie, a process which already committed termina‐
              tion, but has not yet been wait(2)ed for.

2 简单测试程序

/**
 * @FileName    chk_signal_exist.c
 * @Describe    A simple example for checking if a proccess is existing in linux.
 * @Author      vfhky 2016-03-14 11:48 https://typecodes.com/cseries/kill0checkprocessifexist.html
 * @Compile     gcc chk_signal_exist.c -o chk_signal_exist
 */

#include <stdio.h>
#include <signal.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>

#define GO_FREE(p) \
    free(p);    \
    p = NULL;   \
    printf( "exit.\n" );

int main( int argc, char **argv )
{
    if( argc != 2 )
    {
        printf( "Usage: %s %s\n", argv[0], "pid" );
        exit(-1);
    }
    char *p = (char *)malloc( sizeof(char) * 20 );
    memcpy( p, argv[1], strlen(argv[1]) );

    /**
     * no signal is sent, but error checking is still performed;
     * this can be used to check for the existence of a process ID or process group ID.
     */
    if( kill( atoi(p), 0 ) == -1 )
    {
        perror( "error" );
    }
    else
    {
        printf( "Signal[%s] exist.\n", p );
    }
    GO_FREE(p);
    return 0;
}

3 测试执行

使用《Linux C/C++工程中可生成ELF、动/静态库文件的通用Makefile》一文中的Makefile文件进行程序编译，当然也可以使用命令进行编译gcc chk_signal_exist.c -o chk_signal_exist。

先测试进程不存在的情况：随便输入一个进程ID(23232)作为参数1

然后测试进程存在的情况：先使用ps命令查看已存在的进程daemon_sleep1(20608)，然后把作为参数1传入

4 其它说明

网上有资料说0代表的是信号0，但是使用命令kill -l却没有显示，所以这里个人觉得不应该叫信号0。它只是kill函数中的一个普通形参而已，大于0的时候发送对应信号给某个进程，等于0的时候表示检测某个进程是否存在。

vsnprintf字符串格式化输出实例：日志中打印程序名和行号

2016-03-13T23:28:00+08:00

在Linux C/C++程序中打印日志时，可能会由于需要打印未知个数的变量参数，那么vsnprintf函数就排上用场了。这里使用一个简单的C程序例子，演示在打印源程序文件名和该打印函数所在的行号的同时，使用vsnprintf函数打印个数未知的参数变量。

1 完整程序

代码比较简单，如果需要把内容打印在日志文件中的话，还需要调用文件处理函数。为了便于理解，这里直接把内容输出到控制台上了。需要说明的三个地方：

静态全局变量 c_FileName 和 i_FileLineNum 分别用于存储源程序文件名和打印函数所在的行号；
自定义标识符 PRINT 先调用源程序文件名和行号的赋值函数 Get_File_Line ，然后调用个数未知的参数的处理函数 F_vsnprintf；
类似于sprintf和snprintf这两个函数，相比vsprintf函数，vsnprintf加了最大字节( MAXBYTES )的限制，防止内存溢出。

具体代码如下：

/**
 * @FileName    vsnprintf_name_line.c
 * @Describe    A simple example for using vsnprintf to print the name and line-num of source file in linux.
 * @Author      vfhky 2016-03-13 23:28 https://typecodes.com/cseries/vsnprintffilenameline.html
 * @Compile     gcc vsnprintf_name_line.c -o vsnprintf_name_line
 */
#include <stdio.h>
#include <string.h>
#include <stdarg.h>

#define FILENAME_LEN 100
#define MAXLINE 1024
#define MAXBYTES 50

static char c_FileName[FILENAME_LEN];
static int  i_FileLineNum;

//Self-define a function which can print the name and line-number of the source file calling it.
#define PRINT Get_File_Line( __FILE__, __LINE__ );\
              F_vsnprintf

/**
 * Get the linenum and filename of the source file.
 * @Para-in:        p_FileName: The name of the source file.
 * @Para-in:        i_FileLine: The line-number of the source file.
 */
void Get_File_Line( char *p_FileName, int i_FileLine )
{
    strcpy( c_FileName, p_FileName );
    i_FileLineNum = i_FileLine;
    return;
}

/**
 * Print the arguments according to the first argument, name as fmt.
 */
void F_vsnprintf( char *fmt, ... )
{
    char buf[MAXLINE] = {0x00};
    snprintf( buf, MAXBYTES, "[%s:%d] ", c_FileName, i_FileLineNum );
    va_list ap;
    va_start( ap, fmt );
    vsnprintf( buf+strlen(buf), MAXLINE, fmt, ap );
    va_end( ap );

    strcat( buf, "\n" );
    fflush( stdout );

    fputs( buf, stderr );
    fflush( NULL );
    return;
}

int main( int argc, char **argv )
{
    PRINT( "[%s]", "Hello." );
    PRINT( "[%s %s]", "Hello", "world." );
    return 0;
}

2 编译执行

使用《Linux C/C++工程中可生成ELF、动/静态库文件的通用Makefile》一文中的Makefile文件进行程序编译（当然也可以使用命令进行编译gcc vsnprintf_name_line.c -o vsnprintf_name_line），接着执行该程序，得到如下图所示的结果：

Disqus支持的HTML标签和代码高亮方法

2016-03-03T13:09:00+08:00

由于Disqus不支持Markdown的原因，所以在评论中使用HTML标签和代码高亮就不像Markdown那样方便了。在查看了Disqus官方关于HTML标签和代码高亮的说明后，发现Disqus只支持原生的HTML标签和代码高亮方式。

1 支持的HTML标签

Disqus官方给出的HTML标签如下，BZ推测大部分原生的HTML TAG应该都是支持的。

<br>Defines a single line break.</br>
<i>italic text</i>
<a> Defines an anchor.</a>
<strong> Defines bold text.</strong>
<blockquote> Defines a long quotation.</blockquote>
<caption> Defines a table caption.</caption>
<cite> Defines a citation.</cite>
<em> Defines italic text.</em>
<p> Defines a paragraph.</p>
<span> Defines a section in a document.</span>
<s> Defines strikethrough text.</s>
<strike> Defines strikethrough text.</strike>
<u> Defines strikethrough text.</u>

2 支持的代码高亮方式

只要将代码包含在<pre><code class="代码类型">......</code></pre>标签内就行了。目前官方支持的代码类型包括：

C#
HTML/XML (Note: You must first HTML-encode these tags to display them)
Java
Python
C/C++
HTTP
JavaScript
Ruby
CSS
Ini
PHP
SQL

3 演示

这里演示了在Disqus评论中使用blockquote标签以及代码高亮的方法，如下图所示：

最终的效果如本文第一张图片所示。

更新博客生成发布及同步GitHub的Shell脚本：解决文件名空格问题

2016-03-02T23:55:00+08:00

前面一篇文章通过Linux Shell脚本的方式，实现博客生成发布及同步GitHub的的功能：先同步GitHub个人仓库中的Markdown文章到本地，然后通过Pelican编译生成静态HTML文件，最后发布到Nginx的web目录下面，同时更新到GitHub个人主页（vfhky.github.io）。

由于没仔细考虑到Markdown文件名中可能包含空格的问题，所以在Shell脚本的文件名遍历时（代码第108行）出现了BUG：Linux Shell默认把空格空格做为值与值之间的分隔符，所以原本一个带空格的文件名就被拆分成了几个文件名。

1 解决方法

网上查找相关资料后，有两种主要的实现方法：Method 1是通过修改IFS(Internal Field Seperator: Linuxshell中预设的分隔符，用来把command line分解成word)实现。如上图所示，BZ用命令echo $IFS查看了自己的CentOS7.2服务器默认的IFS为空值。

Method 2是直接在使用find命令遍历文件时，把结果作为while read的输入，这样就可以避免空格作为文件名的分隔符了。

2 完整代码

根据这两种方法，修改后的代码如下，同时也已经更新到了当前脚本所在的GitHub工程：https://github.com/vfhky/shell-tools。

#!/bin/bash
# FileName:      github_pelican_nginx.sh
# Description:   Synchronize markdown articles with github, convert to html files using Pelican, deliver it to nginx environment.
# Simple Usage:  ./github_pelican_nginx.sh "commit_comments"
# Crontab Usage: 00 01 * * * /mydata/backups/bak_list/github_pelican_nginx.sh >/dev/null 2>&1
# (c) 2016 vfhky https://typecodes.com/linux/syngithubmarkdownpelican.html
# https://github.com/vfhky/shell-tools/blob/master/synchronize/github_pelican_nginx.sh


# Basic command.
FINDCMD="find"
MVCMD="\mv -f"
CPCMD="\cp -rf"
RMCMD="\rm -rf"
TARXCMD="tar -zxf"
TARZIPCMD="tar --warning=no-file-changed -zcf"

# Pelican compile markdown files to html.
PELICAN_COMPILE_DIR=/mydata/GitBang/pelican
# Private bang in github for store your markdown files.
GITHUB_PELICAN_DIR=/mydata/GitBang/GitHub/BlogBak
# Backup dir for your website's version management.
PELICAN_TAR_DIR=/usr/share/nginx/html/pelican_content_bak
# Dir of your website in nginx server.
PELICAN_BLOG_DIR=/usr/share/nginx/html/pelican
# Dir for this shell script to generate logs automatically.
BLOG_PUBLISH_LOG_DIR=/mydata/backups/logs/blogpublish
# Your personal homepage in github.
GITHUB_PERSONAL_PAGE=/mydata/GitBang/GitHub/vfhky.github.io
# Articles in 15 minutes are legal.
TIME_GAP=15

# Get the newest file name.
#Newest_File="ls -lrt| tail -n 1 | awk '{print $9}'"

# Name of this shell script.
PRGNAME="github_pelican_nginx"

# Current date format: e.g 20150505_2015.
Current_Date=$(date +%Y%m%d_%H%M)

# Check if current user is root.
[ "$(id -u)" != "0" ] && echo "Error: You must be root to run this script." && exit 1

# Check parameter.
if [ $# -gt 1 ]; then
    echo "Usage:    ./github_pelican_nginx.sh \"commit_comments\"" && exit 1
fi

# Run command functions.
function ERROR() {
    echo >/dev/null && echo "[$(date +%H:%M:%S:%N)][error] $*" >> ${BLOG_PUBLISH_LOG_DIR}/${Current_Date}.log
    exit 1
}

function NOTICE() {
    echo >/dev/null && echo "[$(date +%H:%M:%S:%N)][notice] $*" >> ${BLOG_PUBLISH_LOG_DIR}/${Current_Date}.log
}

function RUNCMD() {
    echo "[$(date +%H:%M:%S:%N)][notice] $*" >> ${BLOG_PUBLISH_LOG_DIR}/${Current_Date}.log
    eval $@
}

# Git pull command function.
function Git_Pull(){
    RUNCMD "git pull origin master >/dev/null"
}

# Git commit command function.
function Git_Commit(){
    if [ $# -ne 1 ]; then
        ERROR "Usage: Git_Commit commit_comments!"
        exit 1;
    else
        RUNCMD "git pull && git add --all && git commit -m \"$1\" && git push origin master"
    fi
}

# Get the path of markdown articles in TIME_GAP minutes.
# function Get_Files_Path(){
#    RUNCMD "${FINDCMD} . -mmin -${TIME_GAP} -type f -name \"*.md\" -print0"
# }

# Lock down permissions.You should be careful when it comes to your website for the permission of files, but it's safe using 022.
# umask 022

# Create the log dir.
if [ ! -d $BLOG_PUBLISH_LOG_DIR ]; then
    mkdir -p $BLOG_PUBLISH_LOG_DIR
fi


# Main process begin.
NOTICE "[1]Start pull from GitHub."
RC=0
RUNCMD "cd ${GITHUB_PELICAN_DIR}/md_article && Git_Pull"

RC=$?
if [ $RC -gt 0 ]; then
    ERROR "Git pull failed!"
fi


#### Method 1:Chang the IFS to del with the blank word in the filename.
#old_IFS=$IFS
#IFS=$(echo -en "\n\b")

NOTICE "[2]Start copy the pulled articles to the compile dir of PELICAN."
# New_Article_Files=$(Get_Files_Path ${GITHUB_PELICAN_DIR}/md_article)
# You should not delete the double quotation marks in case of existing a blank in the file path.
#### Method 1: for New_Article_File in `${FINDCMD} . -mmin -${TIME_GAP} -type f -name "*.md"`
#### Method 2: use the while recycle.
${FINDCMD} . -mmin -${TIME_GAP} -type f -name "*.md"|while read New_Article_File
do
    if [ -z "${New_Article_File}" ]; then
        echo "No articles, nothing to do."
        ERROR "No articles, nothing to do."
    fi
    FILE_PATH=$(dirname ${PELICAN_COMPILE_DIR}/content/articles/"${New_Article_File:2}")
    RUNCMD "mkdir -p ${FILE_PATH} && ${CPCMD} \"${New_Article_File}\" ${FILE_PATH}"
done

#### Method 1:Recovery the IFS setting.
#IFS=${old_IFS}

RC=$?
if [ $RC -gt 0 ]; then
    ERROR "Copy the pulled articles failed!"
fi


NOTICE "[3]Start compile in pelican."
RUNCMD "cd ${PELICAN_COMPILE_DIR} && make publish > /dev/null"

RC=$?
if [ $RC -gt 0 ]; then
    ERROR "Compile in pelican failed!"
fi


NOTICE "[4]Start generate a tar packgage and move it to the backup dir."
# The command of tar cause the problem that file changed as we read with the value 1, so we should ignore it using OR logic.
RUNCMD "cd ${PELICAN_COMPILE_DIR}/output && ${TARZIPCMD} ${Current_Date}.tar.gz . || ${MVCMD} ${Current_Date}.tar.gz ${PELICAN_BLOG_DIR}"

RC=$?
if [ $RC -gt 0 ]; then
    ERROR "Generate a tar packgage failed!"
fi


NOTICE "[5]Start unpack the target files."
RUNCMD "cd ${PELICAN_BLOG_DIR} && ${TARXCMD} ${Current_Date}.tar.gz && ${MVCMD} ${Current_Date}.tar.gz ${PELICAN_TAR_DIR}"

RC=$?
if [ $RC -gt 0 ]; then
    ERROR "Unpack the target files failed!"
fi

# if [ $# -eq 1 ]; then
if [ -n "$1" ]; then
    echo "Ready to synchronize to the homepage on github.com."
    NOTICE "[6]Start copy the packgage to the local homepage bang cloned from remote in GitHub."
    RUNCMD "${CPCMD} ${PELICAN_TAR_DIR}/${Current_Date}.tar.gz ${GITHUB_PERSONAL_PAGE} && cd ${GITHUB_PERSONAL_PAGE} && ${TARXCMD} ${Current_Date}.tar.gz && ${RMCMD} ${Current_Date}.tar.gz"

    RC=$?
    if [ $RC -gt 0 ]; then
        ERROR "Copy the packgage to the local homepage bang failed!"
    fi

    NOTICE "[7]Start synchronize website to my homepage on GitHub."
    # read -p "Please input your comments on this commitment: " COMMIT_COMMENTS
    # while [[ -z "${COMMIT_COMMENTS}" ]]
    # do
    #   read -p "Comments can not be empty.Please input again: " COMMIT_COMMENTS
    # done
    # RUNCMD "Git_Commit \"${COMMIT_COMMENTS}\""
    RUNCMD "Git_Commit \"$1\""

    RC=$?
    if [ $RC -gt 0 ]; then
        ERROR "Synchronize website to GitHub failed!"
    fi
else
    echo "Not synchronize your weibsite to the homepage on github.com."
    NOTICE "[6]Not synchronize your weibsite to the homepage on github.com."
fi


NOTICE "------END------"
exit 0

3 脚本执行结果

一个sigprocmask和sigsuspend函数的综合应用

2016-02-29T11:39:00+08:00

在Linux服务端后台开发中，经常会用到信号处理函数：sigprocmask和sigsuspend。这篇文章主要通过一个综合实例演示如何使用sigprocmask函数屏蔽目标信号（信号掩码）以及sigsuspend函数挂起进程。

1 sigprocmask和sigsuspend函数的说明

关于sigprocmask函数的说明：

头文件：    #include <signal.h>
函数：     int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
功能：     用于获取或者改变当前进程的信号掩码（当前进程屏蔽的信号集）。
返回值：    0成功，-1失败（具体原因由errno值表示）。

关于sigsuspend函数的说明：

头文件：    #include <signal.h>
函数：     int sigsuspend(const sigset_t *mask);
功能：     阻塞当前进程（TASK_INTERRUPTIBLE可中断状态），等待mask信号集（信号掩码）之外的任何信号的到来。
            在收到pendmask之外）信号后，先调用该信号的处理函数，然后把信号集mask还原为原来的信号集，接着从sigsuspend调用处返回（进程恢复执行）。
返回值：    该系统调用始终返回-1，并将errno设置为EINTR。

2 完整的程序实例

在CentOS服务器中使用编译并执行下面这段程序，效果如上图所示。

/**
 * @FileName    sigprocmask_sigsuspend.c
 * @Describe    A simple example for using sigprocmask and sigsuspend functions in linux.
 * @Author      vfhky 2016-02-29 11:21 https://typecodes.com/cseries/sigprocmasksigsuspendapp.html
 * @Compile     gcc sigprocmask_sigsuspend.c -o sigprocmask_sigsuspend
 */
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>

//Signal handle function.
void sig_handler( int signal )
{
    printf( "Receive signal=[%d].\n", signal );
    return;
}

int main( int argc, char *argv[] )
{
    printf( "getpid=[%d].\n", getpid() );
    int i = 0;

    //Register a signal.
    struct sigaction new_act;
    sigemptyset( &new_act.sa_mask );
    new_act.sa_handler = sig_handler;
    new_act.sa_flags = 0;
    sigaction( SIGUSR1, &new_act, 0 );
    sigaction( SIGUSR2, &new_act, 0 );
    sigaction( SIGINT, &new_act, 0 );

    //Add SIGINT, SIGUSR1/SIGUSR2 signals to the signal-set of new_set.
    sigset_t new_set, old_set;
    sigemptyset( &new_set );
    sigaddset( &new_set, SIGINT );              //2
    sigaddset( &new_set, SIGUSR1 );             //10
    //sigaddset( &new_set, SIGUSR2 );           //12

    /**
     * Repalce the old mask set with the new mask set.Thus the process will block the signal of SIGINT and SIGUSR1, 
     * but it will excute the function of sig_handler when the signal such as SIGUSR2 other than SIGINT, SIGUSR1 arrives.
     */
    sigprocmask( SIG_SETMASK, &new_set, &old_set );

    //Add SIGUSR1 and SIGUSR2 signals to the signal-set of pendmask.
    sigset_t pendmask;
    sigemptyset( &pendmask );
    sigaddset( &pendmask, SIGUSR1 );            //10
    sigaddset( &pendmask, SIGUSR2 );            //12

    //Replaces the signal mask of the process with pendmask temporarily and suspends the process until delivery of a signal whose action is to invoke a signal handler or to terminate a process.
    i = sigsuspend( &pendmask );
    printf( "Sigsuspend returned with value[%d].\n", i );
    if( errno == EINTR )
    {
        printf( "[%d]Interrupted by a signal.\n", errno );
    }

    while(1)
    {
        printf( "--while.\n" );
        sleep(3);
    }
    return 0;
}

3 发送SIGUSR1和SIGUSR2信号

如下图所示，使用kill命令向进程（PID:7154）发送SIGUSR1和SIGUSR2信号。

由于sigsuspend函数把信号SIGUSR1和SIGUSR2加入到信号掩码pendmask中，所以这两个信号的到来对当前进程没有任何影响。

4 发送SIGINT信号

使用命令kill -SIGINT 7154向当前进程（PID:7154）发送SIGINT信号。由于该信号不在信号掩码pendmask中，所以先调用SIGINT信号的处理函数sig_handler，然后把现在的信号集pendmask还原为原来的new_set信号集。

这时，由于之前由于信号掩码pendmask被屏蔽的未决信号信号SIGUSR1和SIGUSR2由内核重新传递，所以进程会执行SIGUSR2信号的处理函数（SIGUSR1信号被信号集new_set所屏蔽，因此不会执行）。接着进程从sigsuspend调用处返回，恢复执行（进入while循环）。

如果继续发送SIGINT信号，因为被加入到了当前信号掩码new_set中，所以也会被屏蔽（对进程无影响）。最后可以通过命令kill -SIGKILL 7154将整个进程关闭。

Linux TCP通信出现CLOSE_WAIT后导致服务端进程挂掉

2016-02-29T08:39:00+08:00

在前文中讲述了Linux服务端TCP通信出现CLOSE_WAIT状态的原因，这篇文章主要通过一个实例演示它个一个“恶劣”影响：直接使服务端进程Down掉。

1 CentOS服务端建立监听端口

如上图所示，在虚拟机CentOS7服务器（192.168.1.178）中打开一个终端界面，建立8000端口的监听服务（PID:13035）。所用代码如下，和上一篇文章中的程序大体一样，只是多了一个SIGPIPE信号处理以及自动回复(Auto response from server.)部分。

/** 
 * @FileName    server_socket.c
 * @Describe    A simple example for creating a listen as a server and simulate generate a sigpipe signal in linux.
 * @Author      vfhky 2016-02-29 08:01 https://typecodes.com/cseries/tcpclosewaitsigpipe.html
 * @Compile     gcc server_socket.c -o server_socket
 */
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <signal.h>

//Whether add a signal handle.
#define SIGNAL_HANDLE 0

void sig_handle( int signal )
{
    printf( "Receive a signal=[%d].\n", signal );
    return;
}

int main( int argc, char **argv )
{
    int server_sockfd;
    int client_sockfd;
    int len;
    int llOpt = 1;
    struct sockaddr_in my_addr;
    struct sockaddr_in remote_addr;
    int sin_size;
    char buf[BUFSIZ];
    memset( &my_addr, 0, sizeof(my_addr) );
    my_addr.sin_family = AF_INET;
    my_addr.sin_addr.s_addr = INADDR_ANY;
    my_addr.sin_port = htons(8000);

    #if SIGNAL_HANDLE
    struct sigaction new_act, old_act;
    new_act.sa_handler = sig_handle;
    new_act.sa_flags = 0;
    sigemptyset( &new_act.sa_mask );
    sigaction( SIGPIPE, &new_act, &old_act );
    sigaction( SIGINT, &new_act, &old_act );    
    #endif

    if( ( server_sockfd = socket( AF_INET, SOCK_STREAM, 0 ) ) < 0 )
    {  
        perror("socket");
        return 1;
    }

    if( setsockopt( server_sockfd, SOL_SOCKET, SO_REUSEADDR, &llOpt, sizeof(llOpt) ) ) {
        close(server_sockfd);
        return errno;
    }

    if( bind( server_sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr) ) < 0 )
    {
        perror( "bind" );
        return 1;
    }

    listen( server_sockfd, 5 );

    sin_size = sizeof( struct sockaddr_in );

    printf( "Server is listening with pid=[%d].\n", getpid() );

    while(1)
    {
        if( ( client_sockfd = accept( server_sockfd, (struct sockaddr *)&remote_addr, &sin_size ) ) < 0 )
        {
            perror( "accept" );
            return 1;
        }
        //Print the ip address and port of client.
        printf( "Accept client[%s:%u].\n", inet_ntoa(remote_addr.sin_addr), ntohs(remote_addr.sin_port) );

        send( client_sockfd, "Auto response from server.", strlen("Auto response from server."), 0 );

        memset( buf, 0x00, BUFSIZ );
        while( ( len = recv( client_sockfd ,buf, BUFSIZ, 0) ) > 0 )
        {
            buf[len]='\0';
            printf( "Message from client=[%s]\n", buf );
        }
        close( client_sockfd );
    }
    close( server_sockfd );
    return 0;
}

2 在Linux中利用telnet命令创建一个客户端

新建一个shell脚本netstat_nap.sh，里面只包含一条有效命令netstat -nap|head -n 2;netstat -nap|grep 8000。

再打开一个Linux终端界面，然后输入命令telnet 192.168.1.177 8000作为客户端建立与服务端的TCP连接。这时执行脚本./netstat_nap.sh可以看到Linux客户端（PID:13045）和服务端（PID:13035）的TCP通信已经变成ESTABLISHED状态，效果如下图所示：

3 在Windows中利用telnet命令创建一个客户端

在Windows主机（192.168.1.110）中打开一个PowerShell终端界面，然后输入命令telnet 192.168.1.177 8000作为客户端建立与Linux服务端的TCP连接。

如下图所示，执行脚本./netstat_nap.sh，可以看到Windows客户端（端口:64012）和服务端（PID:13035）的TCP通信已经变成ESTABLISHED状态。同时使用命令lsof -i:8000，可以看到进程打开的文件。此时，处于LISTEN状态的13035进程对应的Recv-Q（表示内核中已经接收的队列）从0变成了1。

4 直接关闭Windows telnet客户端界面并使用Wireshark抓包

在直接关闭telnet界面后，继续使用netstat_nap.sh脚本和lsof命令发现刚才建立的TCP通信出现了CLOSE_WAIT的状态。

在等待2分钟后，在Windows中使用Wireshark抓包发现由于客户端发送了RST+ACK报文给Linux服务端，所以二者的TCP链路已经被复位了：

这时在Linux中再次使用netstat_nap.sh脚本和lsof命令发现CLOSE_WAIT的状态已经不存在了。但是从下图中可以看到处于LISTEN状态的Recv-Q对应的值还是为1，也就是由内核维护的已完成握手的队列中的这个连接还等待着服务端程序读取。

5 关闭Linux telnet客户端

在Windows关闭telnet客户端界面并发送RST+ACK报文后，关闭小节2中在Linux中打开的telnet客户端。这时Linux服务端进程会执行第90行处的close()函数，也即执行正常四次挥手关闭TCP连接。

接着Linux服务端进程继续从内核中已完成连接队列中取出已完成连接，这样之前小节3中Windows telnet建立的客户端连接被读取。如下图所示，服务端进程打印了第80行出的数据（Accept client[192.168.1.110:64012].），但是服务端进程却挂掉了。

这时在Linux中再次使用netstat_nap.sh脚本和lsof命令：

6 原因分析

由于Windows客户端的TCP链路在小节4中由于RST的缘故而关闭了，没有读端。那么当Linux服务端执行82行的send()函数时，向之前的socket描述符发送26字节的报文数据时，会收到内核发送过来的SIGPIPE信号，导致服务端进程默认关闭。

因此，如果想捕捉到这个SIGPIPE信号的话，可以将程序17行的SIGNAL_HANDLE宏定义值改成1，那么就会得到如下图所示的情况（进程能正常运行了）。

7 问题延伸

如果在第4小节中关闭Windows客户端界面后，又直接如第5小节所示关闭Linux telnet客户端界面，那么又会出现什么情况呢？于是又重新做了一遍测试，流程同上，下面是测试结果以及分析。

先用netstat和lsof命令查看TCP服务状态，发现监听服务正常：

然后分别用TCPDUMP和Wireshark抓取TCP通信包，截取如下所示。可以发现在Linux telnet客户端完成四次挥手后，服务端进程继续向之前Windows telnet客户端建立的socket描述符发送26字节的报文数据。

因为Windows客户端此时处于FIN_WAIT2状态（Linux服务端处于CLOSE_WAIT状态），所以服务端能继续发其发送数据（即图中的PUSH+ACK报文），接着Windows客户端回应RST+ACK报文，从而两者的TCP链路复位。

这样Linux服务端进程还是能够正常执行监听任务：

8 其它

网上有人把这种客户端或者服务端异常关闭的连接叫做TCP半关闭（Half-Close），例如网线拔掉、突然断电等，此时对端连接仍认为双方连接处于打开中。

使用TCPDUMP和Wireshark排查服务端CLOSE_WAIT（二）

2016-02-28T18:11:00+08:00

前文《使用TCPDUMP和Wireshark排查服务端CLOSE_WAIT（一）》通过TCPDUMP和Wireshark在利用CentOS7作为服务端、Windows10作为客户端，模拟演示了一个TCP通信的CLOSE_WAIT状态，这篇文章主要利用前文的数据尝试解释Linux服务端产生CLOSE_WAIT状态的原因。

1 原因分析：从客户端和服务端TCP通信的流程出发

从前文中的tcpdump和Wireshark抓包都可看到当Windows客户端关闭后，会主动发送带有FIN+ACK标志的报文给Linux服务端。那么从上图TCP客户端和服务端的通信流程图开始分析：客户端先进入FIN_WAIT_1状态，在收到服务端应答的ACK标志的报文后进入FIN_WAIT_2状态（在Windows中重新打开一个PowerShell窗口，然后输入命令netstat -na|findstr 8000查看）。

同时，服务端的TCP状态也就变成了CLOSE_WAIT。但是后面由于Linux服务端没有调用close()函数关闭socket链路，也即没有发送FIN标志的报文给主动关闭TCP链路的客户端，所以造成这个问题。

2 原因分析：从服务端程序出发

在服务端程序的第69行可以看到：一旦客户端关闭socket后，服务端也会调用close( client_sockfd );来关闭链路。那为什么还是会出现CLOSE_WAIT现象呢？答案是因为服务端在与客户端三次握手完后，只有一个进程（PID:5325）在处理客户端的TCP数据交互，而这个进程正在处理在Linux中使用telnet命令建立起来的这个客户端（PID:5331）的请求。

因此，在Windows中使用telnet命令作为客户端与Linux服务端完成三次握手后，没有相关进程来处理。这点也可以通过前文小节4中的截图看出，虽然TCP状态为ESTABLISHED，但是对应的进程PID/Program name为空，这点也可以通过lsof -i:8000命令验证（没有因为Windows客户端的连接出现进程打开的文件）。

当Windows客户端关闭telnet界面后，Linux服务端虽然收到了客户端的FIN+ACK标志的报文，但是没有相关进程调用close()函数通知内核发送FIN报文给客户端。这样就造成了Linux服务端的TCP状态出现了CLOSE_WAIT，同时Windows客户端的TCP状态变成了对应的FIN_WAIT_2。

3 问题延伸：从服务端程序出发

这里可能会存在疑问了，明明Windows客户端与Linux服务端建立了ESTABLISHED状态，也就是server_socket进程对它进行了处理，这不是与小节2中的原因分析相矛盾了吗？其实，这是由于对服务端的一些认识有偏差造成的，BZ之前也错误地认为以下命题是成立的：

listen()函数会使进程阻塞等待客户端的连接，也就是等待与客户端完成三次握手；
accept()函数就是服务端进程在完成三次握手后，接收客户端发送报文数据的请求，然后调用recv()函数来接收；
close()函数就是服务端进程直接向客户端发送FIN报文给客户端。

其实不然，在查阅了相关资料后，个人觉得正确的理解如下：

listen()函数不会使进程阻塞，UNP第3版84页有一句话：listen函数把一个未连接的套接字转换成一个被动套接字，指示内核应接受指向该该套接字的连接请求。
内核为任何一个给定的监听套接字维护两个队列：未完成连接队列和已完成连接队列。
因此，三次握手是由内核自动完成的，无需服务器进程插手。

accept()函数功能是从由内核维护的处于established状态的已完成连接队列列头部取出下一个已经完成的连接。
如果这个队列为空，accept()函数就会阻塞让进程进入睡眠状态。

close()函数是把一个TCP套接字标记成已关闭，然后立即返回调用进程。
TCP尝试发送已排队等待发送到对端的任何数据，发送完毕后发生的是正常的TCP连接终止序列，于是有了著名的四次挥手。

到这里问题其实已经很简单明了了，Linux内核完成“三次握手”跟服务端进程无关，当然这点也可以由程序没有打印第51、60行的数据证实。

4 总结

socket被动关闭的服务端产生CLOSE_WAIT的根本原因是没有调用close()函数关闭socket链路，也即没有发送FIN标志的报文给主动关闭TCP链路的客户端。

使用TCPDUMP和Wireshark排查服务端CLOSE_WAIT（一）

2016-02-26T18:41:00+08:00

在Linux后端服务网络通信开发中，可能会遇到CLOSE_WAIT的状况。引起TCP CLOSE_WAIT状态的情况很多，归根结底还是由于被动关闭的一方没有关闭socket链路导致的。这篇文章主要是通过用一个简单的例子通过TCPDUMP和Wireshark这两个工具来模拟产生CLOSE_WAIT的情况，下一篇主要是对这个问题的原理解释。

1 CentOS服务端建立监听端口

如上图所示，在虚拟机CentOS7服务器（192.168.1.178）中打开一个终端界面，然后使用下面这个简单的服务端程序，建立8000端口的监听服务（PID:5325）。

/** 
 * @FileName    server_socket.c
 * @Describe    A simple example for creating a listen as a server in linux system.
 * @Author      vfhky 2016-02-26 18:45 https://typecodes.com/cseries/tcpdumpwiresharkclosewait1.html
 * @Compile     gcc server_socket.c -o server_socket
 */
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

int main( int argc, char **argv )
{
    int server_sockfd;
    int client_sockfd;
    int len;
    int llOpt = 1;
    struct sockaddr_in my_addr;
    struct sockaddr_in remote_addr;
    int sin_size;
    char buf[BUFSIZ];
    memset( &my_addr, 0, sizeof(my_addr) );
    my_addr.sin_family = AF_INET;
    my_addr.sin_addr.s_addr = INADDR_ANY;
    my_addr.sin_port = htons(8000);

    if( ( server_sockfd = socket( AF_INET, SOCK_STREAM, 0 ) ) < 0 )
    {  
        perror("socket");
        return 1;
    }

    if( setsockopt( server_sockfd, SOL_SOCKET, SO_REUSEADDR, &llOpt, sizeof(llOpt) ) )
    {
        close(server_sockfd);
        return errno;
    }

    if( bind( server_sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr) ) < 0 )
    {
        perror( "bind" );
        return 1;
    }

    listen( server_sockfd, 5 );

    sin_size = sizeof( struct sockaddr_in );

    printf( "Socket server begin to recieve connectiong from client.\n" );

    while(1)
    {
        if( ( client_sockfd = accept( server_sockfd, (struct sockaddr *)&remote_addr, &sin_size ) ) < 0 )
        {
            perror( "accept" );
            return 1;
        }
        //Print the ip address and port of client.
        printf( "Accept client[%s:%u].\n", inet_ntoa(remote_addr.sin_addr), ntohs(remote_addr.sin_port) );

        memset( buf, 0x00, BUFSIZ );
        while( ( len = recv( client_sockfd ,buf, BUFSIZ, 0) ) > 0 )
        {
            buf[len]='\0';
            printf( "Message from client=[%s]\n", buf );
        }
        close( client_sockfd );
    }
    close( server_sockfd );
    return 0;
}

2 在Linux中使用netstat命令查看TCP服务状态

新建一个shell脚本netstat.sh，里面只包含一条有效命令netstat -nap|head -n 2;netstat -nap|grep 8000。执行该脚本可以看到服务端的监听效果：

3 在Linux中利用telnet命令创建一个客户端

再打开一个Linux终端界面，然后输入命令telnet 192.168.1.177 8000作为客户端建立与服务端的TCP连接。这时执行脚本./netstat.sh可以看到Linux客户端（PID:5331）和服务端（PID:5325）的TCP通信已经变成ESTABLISHED状态，效果如下图所示：

4 在Windows中利用telnet命令创建一个客户端

在Windows中打开一个PowerShell终端界面，然后输入命令telnet 192.168.1.177 8000作为客户端建立与Linux服务端的TCP连接。

这时执行脚本./netstat.sh可以看到Windows客户端（端口:52552）和服务端（PID:5325）的TCP通信已经变成ESTABLISHED状态，效果如下图所示：

5 在Linux中使用tcpdump工具抓包

再打开一个Linux终端界面，然后输入命令tcpdump -n port 8000进行抓包（目的是获取Windows客户端telnet建立的tcp连接的数据包）。当前面第4小节中Windows客户端发起“三次握手”时得到如下数据：

[root@typecodes ~]# tcpdump -n port 8000
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on eth0, link-type EN10MB (Ethernet), capture size 65535 bytes

######Windows中的telnet命令作为客户端向Linux服务器发起第一次握手，请求建立连接(SYN)
17:10:43.150463 IP 192.168.1.110.52552 > 192.168.1.177.irdmi: Flags [S], seq 4020000773, win 8192, options [mss 1460,nop,wscale 8,nop,nop,sackOK], length 0
######Linux服务端向Windows客户端发送握手确认包(SYN+ACK)
17:10:43.150518 IP 192.168.1.177.irdmi > 192.168.1.110.52552: Flags [S.], seq 2818288395, ack 4020000774, win 29200, options [mss 1460,nop,nop,sackOK,nop,wscale 7], length 0
######Windows客户端向Linux服务端发送确认包(ACK)，三次握手完毕
17:10:43.150652 IP 192.168.1.110.52552 > 192.168.1.177.irdmi: Flags [.], ack 1, win 256, length 0

效果如下图所示：

6 在Windows中使用Wireshark抓包

在Windows中使用telnet 192.168.1.177 8000命令建立与Linux服务端的TCP链路后（即前面小节4的操作），通过Windows客户端的TCP端口号52552开始准备使用Wireshark进行抓包。

手动直接关闭小节4中创建的Windows telnet终端界面，然后Wireshark抓包情况如下图所示：

同时，通过Linux中的netstat.sh脚本发现刚才建立的TCP通信出现了CLOSE_WAIT的状态。

同样，使用第4小节中的tcpdump抓包情况如下：

######Windows客户端被“意外”关闭，向Linux服务端发送FIN+ACK报文
17:11:35.668512 IP 192.168.1.110.52552 > 192.168.1.177.irdmi: Flags [F.], seq 1, ack 1, win 256, length 0
######Linux服务端向Windows客户端发送ACK确认报文
17:11:35.668851 IP 192.168.1.177.irdmi > 192.168.1.110.52552: Flags [.], ack 2, win 229, length 0
######2分钟后，Windows系统自动向Linux服务端发送一个RST+ACK报文，告知对方自己已关闭之前的TCP连接，同时要求对方也关闭链路
17:13:35.670464 IP 192.168.1.110.52552 > 192.168.1.177.irdmi: Flags [R.], seq 2, ack 1, win 0, length 0

效果如下图所示：

7 原因分析

详见下文。

Linux中使用TCPDUMP进行简单的TCP抓包

2016-02-26T15:51:00+08:00

在Linux TCP通信的调试中，tcpdump应该算是很好的一个工具。这篇文章主要使用Windows作为客户端，向作为服务端的Linux中的一个socket监听端口发送报文信息，然后在Linux中用TCPDUMP工具进行抓包。通过这个实例，可以较为完整的了解TCP通信中的“三次握手”等过程。

1 CentOS服务端建立监听并抓包

在虚拟机服务器（192.168.1.178）使用下面这个简单的服务端程序，建立8000端口的监听服务，然后使用tcpdump -n port 8000命令抓包。

/** 
 * @FileName    server_socket.c
 * @Describe    A simple example for creating a listen as a server in linux system.
 * @Author      vfhky 2015-09-25 21:32 https://typecodes.com/linux/simpletcpdumpapply.html
 * @Compile     gcc server_socket.c -o server_socket
 */
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

int main( int argc, char **argv )
{
    int server_sockfd;
    int client_sockfd;
    int len;
    int llOpt = 1;
    struct sockaddr_in my_addr;
    struct sockaddr_in remote_addr;
    int sin_size;
    char buf[BUFSIZ];
    memset( &my_addr, 0, sizeof(my_addr) );
    my_addr.sin_family = AF_INET;
    my_addr.sin_addr.s_addr = INADDR_ANY;
    my_addr.sin_port = htons(8000);

    if( ( server_sockfd = socket( AF_INET, SOCK_STREAM, 0 ) ) < 0 )
    {  
        perror("socket");
        return 1;
    }

    if( setsockopt( server_sockfd, SOL_SOCKET, SO_REUSEADDR, &llOpt, sizeof(llOpt) ) ) {
        close(server_sockfd);
        return errno;
    }

    if( bind( server_sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr) ) < 0 )
    {
        perror( "bind" );
        return 1;
    }

    listen( server_sockfd, 5 );

    sin_size = sizeof( struct sockaddr_in );

    printf( "Socket server begin to recieve connectiong from client.\n" );

    while(1)
    {
        if( ( client_sockfd = accept( server_sockfd, (struct sockaddr *)&remote_addr, &sin_size ) ) < 0 )
        {
            perror( "accept" );
            return 1;
        }
        printf( "Accept client[%s].\n", inet_ntoa(remote_addr.sin_addr) );

        memset( buf, 0x00, BUFSIZ );
        while( ( len = recv( client_sockfd ,buf, BUFSIZ, 0) ) > 0 )
        {
            buf[len]='\0';
            printf( "Message from client=[%s]\n", buf );
        }
        close( client_sockfd );
    }
    close( server_sockfd );
    return 0;
}

2 Windows客户端发送请求报文

在本地Windows机器（192.168.1.109）使用报文发送工具连接到虚拟机服务器192.168.1.178，然后发送两次请求报文。

其中，第一次发送“11111”的报文：

第二次发送“123321”的请求报文：

3 Windows客户端关闭socket

点击左边配置菜单栏中的“关闭”按钮，断开tcp连接。

4 分析抓包的情况

在Linux服务端的抓包情况如下，其中抓包内容中出现冒号表示范围，例如seq 1:6表示seq序号范围从1到6。另外，抓包中的iRDMI代表iRDMI/Shoutcast Server，对应着8000端口。

[root@typecodes ~]# tcpdump -n port 8000
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on eth0, link-type EN10MB (Ethernet), capture size 65535 bytes

//内容格式
//时分秒           客户端IP和端口         服务端IP和端口   SYN(客户端主动请求连接服务器)  包序号  8192(Window size),  长度0
11:12:02.534303 IP 192.168.1.109.8886 > 192.168.1.178.irdmi: Flags [S], seq 2639909369, win 8192, options [mss 1460,nop,wscale 8,nop,nop,sackOK], length 0

//服务器端发送SYN+ACK(.)的报文给客户端,  ack=seq+1=2639909369+1,  长度0
11:12:02.534339 IP 192.168.1.178.irdmi > 192.168.1.109.8886: Flags [S.], seq 1984808639, ack 2639909370, win 14600, options [mss 1460,nop,nop,sackOK,nop,wscale 7], length 0

//客户端收到确认包后，发送ACK(.)报文给服务端,  长度0
11:12:02.534528 IP 192.168.1.109.8886 > 192.168.1.178.irdmi: Flags [.], ack 1, win 256, length 0

//三次握手成功后,  客户端发送"11111"报文内容给服务端, 长度为5字节, 标识P即PSH(Push function)为1时, 代表要发送缓冲区的封包, 无需等待缓冲区满了才送
11:12:16.501177 IP 192.168.1.109.8886 > 192.168.1.178.irdmi: Flags [P.], seq 1:6, ack 1, win 256, length 5

//服务端收到客户端请求报文包后, 发送ACK(.)报文给客户端,  长度为0字节,  ACK=SEQ+LENGTH=1+5
11:12:16.501208 IP 192.168.1.178.irdmi > 192.168.1.109.8886: Flags [.], ack 6, win 115, length 0

//客户端继续发送请求报文, 内容为"123321", 长度6字节
11:44:16.181474 IP 192.168.1.109.8886 > 192.168.1.178.irdmi: Flags [P.], seq 6:12, ack 1, win 256, length 6

//服务端发送ACK(.)应答报文给客户端, ack=SEQ+length=6+6=12
11:44:16.181508 IP 192.168.1.178.irdmi > 192.168.1.109.8886: Flags [.], ack 12, win 115, length 0

//客户端关闭后向服务端发送标识为(R+.ACK), RST(Reset)为1时, 表示tcp连接马上会被结束，而无需等待终止确认手续. 也就是说, 这是个强制结束的连线, 且发送端已经断开.
//这里即使服务端没有调用close(accept_sockfd)来向客户端发送FIN报文，两者之间建立的tcp链路都会被关闭！！！
11:50:55.047977 IP 192.168.1.109.8886 > 192.168.1.178.irdmi: Flags [R.], seq 12, ack 1, win 0, length 0

CentOS 7.2使用yum安装MYSQL 5.7.10

2016-02-26T14:55:00+08:00

前面两篇文章《2015博客升级记(四)：CentOS 7.1编译安装MySQL5.7.7rc》、《阿里云CentOS 7.1使用yum安装MySql5.6.24》分别使用源码编译和YUM方法安装MySQL数据库，这篇文章同样是使用YUM方法在CentOS7.2(64bits)的机器上安装最新的MySQL5.7.10数据库。

1 查看Linux发行版本

[root@typecodes ~]# cat /etc/redhat-release
CentOS Linux release 7.2.1511 (Core)

2 下载MySQL官方的Yum Repository

根据Linux发行版本（CentOS、Fedora都属于红帽系），从mysql官方（http://dev.mysql.com/downloads/repo/yum/）获取Yum Repository。

[root@typecodes ~]#  wget -i http://dev.mysql.com/get/mysql57-community-release-el7-7.noarch.rpm
--2016-02-03 18:36:02--  http://dev.mysql.com/get/mysql57-community-release-el7-7.noarch.rpm
Resolving dev.mysql.com (dev.mysql.com)... 137.254.60.11
Connecting to dev.mysql.com (dev.mysql.com)|137.254.60.11|:80... connected.
HTTP request sent, awaiting response... 302 Found
Location: http://repo.mysql.com//mysql57-community-release-el7-7.noarch.rpm [following]
--2016-02-03 18:36:04--  http://repo.mysql.com//mysql57-community-release-el7-7.noarch.rpm
Resolving repo.mysql.com (repo.mysql.com)... 104.102.164.25
Connecting to repo.mysql.com (repo.mysql.com)|104.102.164.25|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 8984 (8.8K) [application/x-redhat-package-manager]
Saving to: ‘mysql57-community-release-el7-7.noarch.rpm’

100%[=============================================================================================================================>] 8,984       --.-K/s   in 0s

2016-02-03 18:36:07 (68.4 MB/s) - ‘mysql57-community-release-el7-7.noarch.rpm’ saved [8984/8984]

3 安装MySQL的Yum Repository

安装完MySQL的Yum Repository，每次执行yum update都会检查MySQL是否更新。

[root@typecodes ~]# yum -y install mysql57-community-release-el7-7.noarch.rpm
Loaded plugins: axelget, fastestmirror, langpacks
Examining mysql57-community-release-el7-7.noarch.rpm: mysql57-community-release-el7-7.noarch
Marking mysql57-community-release-el7-7.noarch.rpm to be installed
Resolving Dependencies
--> Running transaction check
---> Package mysql57-community-release.noarch 0:el7-7 will be installed
--> Finished Dependency Resolution

Dependencies Resolved

=======================================================================================================================================================================
 Package                                       Arch                       Version                    Repository                                                   Size
=======================================================================================================================================================================
Installing:
 mysql57-community-release                     noarch                     el7-7                      /mysql57-community-release-el7-7.noarch                     7.8 k

Transaction Summary
=======================================================================================================================================================================
Install  1 Package

Total size: 7.8 k
Installed size: 7.8 k
Downloading packages:
Running transaction check
Running transaction test
Transaction test succeeded
Running transaction
  Installing : mysql57-community-release-el7-7.noarch                                                                                                              1/1 
  Verifying  : mysql57-community-release-el7-7.noarch                                                                                                              1/1

Installed:
  mysql57-community-release.noarch 0:el7-7

Complete!

3 安装MySQL数据库的服务器版本

[root@typecodes ~]# yum -y install mysql-community-server
Loaded plugins: axelget, fastestmirror, langpacks
No metadata available for base
No metadata available for epel
No metadata available for extras
repomd.xml                                                                                                                                      | 2.5 kB  00:00:00     
update mysql-connectors-community metadata successfully
repomd.xml                                                                                                                                      | 2.5 kB  00:00:00     
update mysql-tools-community metadata successfully
repomd.xml                                                                                                                                      | 2.5 kB  00:00:00     
update mysql57-community metadata successfully
No metadata available for updates
mysql-connectors-community                                                                                                                      | 2.5 kB  00:00:00     
mysql-tools-community                                                                                                                           | 2.5 kB  00:00:00     
mysql57-community                                                                                                                               | 2.5 kB  00:00:00     
(1/3): mysql-tools-community/x86_64/primary_db                                                                                                  |  24 kB  00:00:01     
(2/3): mysql57-community/x86_64/primary_db                                                                                                      |  28 kB  00:00:01     
(3/3): mysql-connectors-community/x86_64/primary_db                                                                                             | 8.6 kB  00:00:02     
Loading mirror speeds from cached hostfile
 * base: mirrors.aliyun.com
 * epel: mirrors.neusoft.edu.cn
 * extras: mirrors.163.com
 * updates: mirrors.163.com
Resolving Dependencies
--> Running transaction check
---> Package mysql-community-server.x86_64 0:5.7.10-1.el7 will be installed
--> Processing Dependency: mysql-community-common(x86-64) = 5.7.10-1.el7 for package: mysql-community-server-5.7.10-1.el7.x86_64
--> Processing Dependency: mysql-community-client(x86-64) = 5.7.10-1.el7 for package: mysql-community-server-5.7.10-1.el7.x86_64
--> Running transaction check
---> Package mysql-community-client.x86_64 0:5.7.10-1.el7 will be installed
--> Processing Dependency: mysql-community-libs(x86-64) = 5.7.10-1.el7 for package: mysql-community-client-5.7.10-1.el7.x86_64
---> Package mysql-community-common.x86_64 0:5.7.10-1.el7 will be installed
--> Running transaction check
---> Package mariadb-libs.x86_64 1:5.5.44-2.el7.centos will be obsoleted
--> Processing Dependency: libmysqlclient.so.18()(64bit) for package: 2:postfix-2.10.1-6.el7.x86_64
--> Processing Dependency: libmysqlclient.so.18(libmysqlclient_18)(64bit) for package: 2:postfix-2.10.1-6.el7.x86_64
---> Package mysql-community-libs.x86_64 0:5.7.10-1.el7 will be obsoleting
--> Running transaction check
---> Package mysql-community-libs-compat.x86_64 0:5.7.10-1.el7 will be obsoleting
--> Finished Dependency Resolution

Dependencies Resolved

=======================================================================================================================================================================
 Package                                            Arch                          Version                               Repository                                Size
=======================================================================================================================================================================
Installing:
 mysql-community-libs                               x86_64                        5.7.10-1.el7                          mysql57-community                        2.2 M
     replacing  mariadb-libs.x86_64 1:5.5.44-2.el7.centos
 mysql-community-libs-compat                        x86_64                        5.7.10-1.el7                          mysql57-community                        2.0 M
     replacing  mariadb-libs.x86_64 1:5.5.44-2.el7.centos
 mysql-community-server                             x86_64                        5.7.10-1.el7                          mysql57-community                        142 M
Installing for dependencies:
 mysql-community-client                             x86_64                        5.7.10-1.el7                          mysql57-community                         24 M
 mysql-community-common                             x86_64                        5.7.10-1.el7                          mysql57-community                        269 k

Transaction Summary
=======================================================================================================================================================================
Install  3 Packages (+2 Dependent packages)

Total download size: 171 M
Downloading packages:
mysql-community-server-5.7.10-1.el7.x86_64.rpm                                                                                                  | 142 MB  00:03:42     
mysql-community-libs-compat-5.7.10-1.el7.x86_64.rpm                                                                                             | 2.0 MB  00:00:03     
mysql-community-libs-5.7.10-1.el7.x86_64.rpm                                                                                                    | 2.2 MB  00:00:05     
mysql-community-client-5.7.10-1.el7.x86_64.rpm                                                                                                  |  24 MB  00:00:41     
warning: /var/cache/yum/x86_64/7/mysql57-community/packages/mysql-community-common-5.7.10-1.el7.x86_64.rpm: Header V3 DSA/SHA1 Signature, key ID 5072e1f5: NOKEY00 ETA 
Public key for mysql-community-common-5.7.10-1.el7.x86_64.rpm is not installed
mysql-community-common-5.7.10-1.el7.x86_64.rpm                                                                                                  | 269 kB  00:00:01     
Retrieving key from file:///etc/pki/rpm-gpg/RPM-GPG-KEY-mysql
Importing GPG key 0x5072E1F5:
 Userid     : "MySQL Release Engineering <mysql-build@oss.oracle.com>"
 Fingerprint: a4a9 4068 76fc bd3c 4567 70c8 8c71 8d3b 5072 e1f5
 Package    : mysql57-community-release-el7-7.noarch (@/mysql57-community-release-el7-7.noarch)
 From       : /etc/pki/rpm-gpg/RPM-GPG-KEY-mysql
Running transaction check
Running transaction test
Transaction test succeeded
Running transaction
  Installing : mysql-community-common-5.7.10-1.el7.x86_64                                                                                                          1/6 
  Installing : mysql-community-libs-5.7.10-1.el7.x86_64                                                                                                            2/6 
  Installing : mysql-community-client-5.7.10-1.el7.x86_64                                                                                                          3/6 
  Installing : mysql-community-server-5.7.10-1.el7.x86_64                                                                                                          4/6 
  Installing : mysql-community-libs-compat-5.7.10-1.el7.x86_64                                                                                                     5/6 
  Erasing    : 1:mariadb-libs-5.5.44-2.el7.centos.x86_64                                                                                                           6/6 
  Verifying  : mysql-community-server-5.7.10-1.el7.x86_64                                                                                                          1/6 
  Verifying  : mysql-community-libs-compat-5.7.10-1.el7.x86_64                                                                                                     2/6 
  Verifying  : mysql-community-common-5.7.10-1.el7.x86_64                                                                                                          3/6 
  Verifying  : mysql-community-libs-5.7.10-1.el7.x86_64                                                                                                            4/6 
  Verifying  : mysql-community-client-5.7.10-1.el7.x86_64                                                                                                          5/6 
  Verifying  : 1:mariadb-libs-5.5.44-2.el7.centos.x86_64                                                                                                           6/6

Installed:
  mysql-community-libs.x86_64 0:5.7.10-1.el7          mysql-community-libs-compat.x86_64 0:5.7.10-1.el7          mysql-community-server.x86_64 0:5.7.10-1.el7

Dependency Installed:
  mysql-community-client.x86_64 0:5.7.10-1.el7                                       mysql-community-common.x86_64 0:5.7.10-1.el7

Replaced:
  mariadb-libs.x86_64 1:5.5.44-2.el7.centos

Complete!
[root@typecodes ~]# clear

最后的截图：

4 启动数据库：

[root@typecodes ~]# systemctl start  mysqld.service

然后使用命令systemctl status mysqld.service查看MySQL数据库启动后的服务状态：

5 获取初始密码

使用YUM安装并启动MySQL服务后，MySQL进程会自动在进程日志中打印root用户的初始密码：

#######从mysql进程日志中获取root用户的初始密码：ra%yk7urCBIh
[root@typecodes ~]# grep "password" /var/log/mysqld.log
2016-02-03T10:42:17.272166Z 1 [Note] A temporary password is generated for root@localhost: ra%yk7urCBIh
2016-02-03T10:42:36.776875Z 2 [Note] Access denied for user 'root'@'localhost' (using password: NO)
2016-02-03T10:42:52.063138Z 3 [Note] Access denied for user 'root'@'localhost' (using password: NO)
2016-02-03T10:42:57.564373Z 4 [Note] Access denied for user 'root'@'localhost' (using password: NO)
2016-02-03T10:43:01.477007Z 5 [Note] Access denied for user 'root'@'localhost' (using password: NO)
2016-02-03T10:46:03.642008Z 6 [Note] Access denied for user 'root'@'localhost' (using password: NO)
2016-02-03T10:46:11.217889Z 7 [Note] Access denied for user 'root'@'localhost' (using password: NO)
2016-02-03T10:47:44.755199Z 0 [Note] Shutting down plugin 'validate_password'
2016-02-03T10:47:46.505844Z 0 [Note] Shutting down plugin 'sha256_password'
2016-02-03T10:47:46.505851Z 0 [Note] Shutting down plugin 'mysql_native_password'

6 修改root用户密码

使用小节5中获取的root用户的初始密码，然后进行修改：

[root@typecodes ~]# mysql -uroot -p
Enter password:             #######输入默认的root密码后回车
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 2
Server version: 5.7.10

Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> ALTER USER 'root'@'localhost' IDENTIFIED BY 'new password';
Query OK, 0 rows affected (0.00 sec)

mysql> exit
Bye

7 安装完毕

至此，使用在CentOS7中使用YUM方法安装MySQL5.7.10数据库完毕。如下所示，可以使用新的root密码登陆MySQL了。

[root@typecodes ~]# mysql -uroot -ppassword
mysql: [Warning] Using a password on the command line interface can be insecure.
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 3
Server version: 5.7.10 MySQL Community Server (GPL)

Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> use mysql;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
4 rows in set (0.00 sec)

mysql> clear
mysql> exit
Bye
[root@typecodes ~]# clear

附录1：查看MySQL数据库的配置信息

MySQL的配置文件依然是/etc/my.cnf，其它安装信息可以通过mysql_config命令查看。其中，动态库文件存放在/usr/lib64/mysql目录下。

附录2：对于C/C++等开发者

由于需要用到类似mysql.h等头文件，需要执行下面的命令安装mysql开发版本即可。

[root@typecodes ~]# yum -y install mysql-community-devel

附录3：删除MySQL的Repository

因为小节3中安装了MySQL的Yum Repository，所以以后每次执行yum操作时，都会去检查更新。如果想要去掉这种自动检查操作的话，可以使用如下命令卸载MySQL的Repository即可。

[root@typecodes ~]# yum -y remove mysql57-community-release-el7-7.noarch

update 2017.04.10 11:10

使用上面的yum方法也可以安装目前mysql官网上最新的版本mysql5.7.18。只要替换小节2中rmp包的版本即可，后续操作步骤不变。

wget -i -c http://dev.mysql.com/get/mysql57-community-release-el7-10.noarch.rpm

Linux多进程和多线程的一次gdb调试实例

2016-02-25T23:18:00+08:00

Linux C/C++开发中gdb进行多进程和多线程的调试一直比较麻烦，在CSDN上看到高科的一篇文章《gdb调试多进程和多线程命令》比较有启发，这里就自己重新整理并做了一个GDB多进程/线程的调试实践。

1 原文整理

默认设置下，在调试多进程程序时gdb只会调试主进程。gdb7以上的版本(gdb --version)支持多进程调试，只需要设置好follow-fork-mode（fork追踪模式）以及detach-on-fork（指示GDB在fork之后是否断开某个进程的调试）即可。

这两个参数的设置命令分别是：set follow-fork-mode [parent|child]，set detach-on-fork [on|off]。两者结合起来构成了GDB的调试模式：

follow-fork-mode  detach-on-fork    说明
    parent              on          GDB默认的调试模式：只调试主进程
    child               on          只调试子进程
    parent              off         同时调试两个进程，gdb跟主进程，子进程block在fork位置
    child               off         同时调试两个进程，gdb跟子进程，主进程block在fork位置

查看gdb默认的参数设置：

(gdb) show follow-fork-mode
Debugger response to a program call of fork or vfork is "parent".
(gdb) show detach-on-fork
Whether gdb will detach the child of a fork is on.
(gdb)

2 演示代码

下面这段代码的主要流程就是在main函数中fork创建一个子进程，然后在父进程中又创建一个线程，接着就使用gdb进行调试（block子进程）。注意，在调试设置断点的时候，由于之前调试的时候代码最前面没有加上这7行说明文字，所以设置断点的行号要加上7。

/** 
 * @FileName    gdb_pthread.c
 * @Describe    A simple example for the debug of multiprocess and multithreading using gdb in linux system.
 * @Author      vfhky 2016-02-25 22:48 https://typecodes.com/cseries/multilprocessthreadgdb.html
 * @Compile     gcc gdb_pthread.c -g -o gdb_pthread
 * @Reference   http://blog.csdn.net/pbymw8iwm/article/details/7876797
 */
#include <stdio.h>
#include <pthread.h>
#include <sys/types.h>
#include <unistd.h>


//Parent process handle.
void Parent();
//Child process handle.
void Child();
//Parent process handle after generate a thread.
void * ParentDo( char *argv );

int main( int argc, const char **argv )
{
    int pid;
    pid = fork();
    if(pid != 0)        //add the first breakpoint.
        Parent();
    else
        Child();
    return 0;
}

//Parent process handle.
void Parent()
{
    pid_t pid = getpid();
    char cParent[] = "Parent";
    char cThread[] = "Thread";
    pthread_t pt;

    printf( "[%s]: [%d] [%s]\n", cParent, pid, "step1" );

    if( pthread_create( &pt, NULL, (void *)*ParentDo, cThread ) )
    {
        printf( "[%s]: Can not create a thread.\n", cParent );
    }

    ParentDo( cParent );
    sleep(1);
}

void * ParentDo( char *argv )
{
    pid_t pid = getpid();
    pthread_t tid = pthread_self();     //Get the thread-id selfly.
    char tprefix[] = "thread";

    printf( "[%s]: [%d] [%s] [%lu] [%s]\n", argv, pid, tprefix, tid, "step2" );         //add the second breakpoint.
    printf( "[%s]: [%d] [%s] [%lu] [%s]\n", argv, pid, tprefix, tid, "step3" );

    return NULL;
}

void Child()
{
    pid_t pid = getpid();
    char prefix[] = "Child";
    printf( "[%s]: [%d] [%s]\n", prefix, pid, "step1" );
    return;
}

已知如果直接运行程序，那么输出的内容如下：

[vfhky@typecodes pthread_key]$ gdb_pthread
[Parent]: [22648] [step1]
[Parent]: [22648] [thread] [139722467432256] [step2]
[Parent]: [22648] [thread] [139722467432256] [step3]
[Thread]: [22648] [thread] [139722450630400] [step2]
[Thread]: [22648] [thread] [139722450630400] [step3]
[Child]: [22649] [step1]
[vfhky@typecodes pthread_key]$

3 gdb调试

3.1 设置调试模式和Catchpoint

设置调试父子进程，gdb跟主进程，子进程block在fork位置。

[vfhky@typecodes pthread_key]$ gdb gdb_pthread
GNU gdb (GDB) Red Hat Enterprise Linux 7.6.1-80.el7
Copyright (C) 2013 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-redhat-linux-gnu".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>...
Reading symbols from /home/vfhky/bin/gdb_pthread...done.
(gdb) set detach-on-fork off
#####catch让程序在发生某种事件（fork、异常throw、异常catch、动态库加载等）的时候停止运行
(gdb) catch fork 
Catchpoint 1 (fork)
(gdb) info b
Num     Type           Disp Enb Address            What
1       catchpoint     keep y                      fork
(gdb)

如下图所示：

3.2 开始gdb调试

(gdb) r                         ####运行到断点/捕捉点（第17行处的fork函数，23873是子进程PID）
Starting program: /home/vfhky/bin/gdb_pthread 
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib64/libthread_db.so.1".

Catchpoint 1 (forked process 23873), 0x00007ffff709b50c in __libc_fork () at ../nptl/sysdeps/unix/sysv/linux/fork.c:130
130       pid = ARCH_FORK ();
(gdb) bt                        #####查看堆栈情况
#0  0x00007ffff709b50c in __libc_fork () at ../nptl/sysdeps/unix/sysv/linux/fork.c:130
#1  0x00000000004007b4 in main (argc=1, argv=0x7fffffffe4c8) at gdb_pthread.c:17
(gdb) info threads              #######显示运行的线程信息(23869是父进程的PID)
  Id   Target Id         Frame 
* 1    Thread 0x7ffff7fe1740 (LWP 23869) "gdb_pthread" 0x00007ffff709b50c in __libc_fork () at ../nptl/sysdeps/unix/sysv/linux/fork.c:130
(gdb) info inferiors            ######显示正在调试的进程：1前面的星号表示当前调试的进程（PID 23869）。  
  Num  Description       Executable        
* 1    process 23869     /home/vfhky/bin/gdb_pthread 
(gdb) info b                    ######列出所有断点和捕捉点，此时已经hit 1 time，即捕捉到了一次fork事件
Num     Type           Disp Enb Address            What
1       catchpoint     keep y                      fork, process 23873                   #####子进程23873
        catchpoint already hit 1 time
(gdb)

这时使用如下命令查看当前CentOS系统所有进程的状态：发现父进程PID为23869，通过fork产生的子进程为23873：

[vfhky@typecodes ~]$ pstree -pul

同时，使用命令cat /proc/23869/status查看当前进程的详细信息：进程PID为23869，它的父进程（即GDB进程）为23859，同时这也是追踪进程ID，线程数Threads为1（共享使用该信号描述符的线程数，在POSIX多线程序应用程序中，线程组中的所有线程使用同一个信号描述符）。

3.3 设置第一个断点

在程序的第18行设置断点：

(gdb) b gdb_pthread.c:18
Breakpoint 2 at 0x4007b7: file gdb_pthread.c, line 18.
(gdb) info b                        ######列出所有断点和捕捉点
Num     Type           Disp Enb Address            What
1       catchpoint     keep y                      fork, process 23873                 ########子进程23873
        catchpoint already hit 1 time
2       breakpoint     keep y   0x00000000004007b7 in main at gdb_pthread.c:18
(gdb)

3.4 执行到第一个断点

(gdb) c                #####执行到第18行处的断点
Continuing.
[New process 23873]                     #####父进程23869执行完第1个捕捉点的程序，产生子进程23873
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib64/libthread_db.so.1".

Breakpoint 2, main (argc=1, argv=0x7fffffffe4c8) at gdb_pthread.c:18            ##########父进程执行到第18行处的断点
18              if(pid != 0)
(gdb) info threads                      ####查看所有运行的线程，有父进程23869和子进程23873
  Id   Target Id         Frame 
  2    Thread 0x7ffff7fe1740 (LWP 23873) "gdb_pthread" 0x00007ffff709b50c in __libc_fork () at ../nptl/sysdeps/unix/sysv/linux/fork.c:130
* 1    Thread 0x7ffff7fe1740 (LWP 23869) "gdb_pthread" main (argc=1, argv=0x7fffffffe4c8) at gdb_pthread.c:18
(gdb) info inferiors                    #####显示正在调试的进程
  Num  Description       Executable        
  2    process 23873     /home/vfhky/bin/gdb_pthread                ########子进程
* 1    process 23869     /home/vfhky/bin/gdb_pthread                ########父进程
(gdb) info b                    #######查看当前所有的断点
Num     Type           Disp Enb Address            What
1       catchpoint     keep y                      fork, process 23873 
        catchpoint already hit 1 time
2       breakpoint     keep y   <MULTIPLE>         
        breakpoint already hit 1 time
2.1                         y     0x00000000004007b7 in main at gdb_pthread.c:18 inf 2
2.2                         y     0x00000000004007b7 in main at gdb_pthread.c:18 inf 1
(gdb)

截图如下：

这时使用命令查看当前系统进程的状态：发现此时仍然只有父进程23869和子进程23873。

[vfhky@typecodes ~]$ pstree -pul

3.5 执行到第一个断点此时如果切换到子进程23873

(gdb) inferior 2
[Switching to inferior 2 [process 23873] (/home/vfhky/bin/gdb_pthread)]
[Switching to thread 2 (Thread 0x7ffff7fe1740 (LWP 23873))] 
#0  0x00007ffff709b50c in __libc_fork () at ../nptl/sysdeps/unix/sysv/linux/fork.c:130
130       pid = ARCH_FORK ();
(gdb) info inferiors                 #####显示正在调试的进程 
  Num  Description       Executable        
* 2    process 23873     /home/vfhky/bin/gdb_pthread                #####子进程
  1    process 23869     /home/vfhky/bin/gdb_pthread                #####父进程
(gdb)

3.6 重新切换到父进程23869

(gdb) inferior 1
[Switching to inferior 1 [process 23869] (/home/vfhky/bin/gdb_pthread)]
[Switching to thread 1 (Thread 0x7ffff7fe1740 (LWP 23869))] 
#0  main (argc=1, argv=0x7fffffffe4c8) at gdb_pthread.c:18
18              if(pid != 0)
(gdb) info inferiors                 #####显示正在调试的进程
  Num  Description       Executable        
  2    process 23873     /home/vfhky/bin/gdb_pthread 
* 1    process 23869     /home/vfhky/bin/gdb_pthread 
(gdb)

3.7 设置第二个断点并调试

在第50行设置断点继续调试主进程（使父进程产生线程），其中父进程和线程到底是谁先执行是由内核调度控制的。

(gdb) b gdb_pthread.c:50
Breakpoint 3 at 0x4008a7: gdb_pthread.c:50. (2 locations)
(gdb) c                    ######继续执行代码到第50行处的断点
Continuing.
[Parent]: [23869] [step1]                              ######第33行父进程打印Parent()函数中的数据
[New Thread 0x7ffff6fdd700 (LWP 24024)]                ######第35行父进程创建了一个线程24024（LWP表示轻量级进程）
[Switching to Thread 0x7ffff6fdd700 (LWP 24024)]            #####已经自动切换到线程24024（LWP表示轻量。进程），也就是GDB继续调试线程而不是父进程了。

Breakpoint 3, ParentDo (argv=0x7fffffffe390 "Thread") at gdb_pthread.c:50            ######线程24024阻塞在程序的第50行
50              printf( "[%s]: [%d] [%s] [%lu] [%s]\n", argv, pid, tprefix, tid, "step2" );
(gdb)

这时使用命令查看当前系统进程的状态：存在父进程23869和子进程23873以及父进程创建的一个线程24024（线程用大括号{}表示）。

[vfhky@typecodes ~]$ pstree -pul

同时，使用命令cat /proc/23869/status查看当前进程的详细信息：进程PID为23869，它的父进程（即GDB进程）为23859，同时这也是追踪进程ID，线程数Threads为2（当前父进程23869+线程24024）。

3.8 查看第二个断点处的调试信息

(gdb) info inferiors                 #####显示正在调试的进程 
  Num  Description       Executable        
  2    process 23873     /home/vfhky/bin/gdb_pthread                     ###子进程
* 1    process 23869     /home/vfhky/bin/gdb_pthread                     ###父进程 
(gdb) info threads         ####查看所有运行的线程，父进程23869、子进程23873、线程24024，由星号可以发现目前调试已经切换到了线程24024了。 
  Id   Target Id         Frame 
* 3    Thread 0x7ffff6fdd700 (LWP 24024) "gdb_pthread" ParentDo (argv=0x7fffffffe390 "Thread") at gdb_pthread.c:50
  2    Thread 0x7ffff7fe1740 (LWP 23873) "gdb_pthread" 0x00007ffff709b50c in __libc_fork () at ../nptl/sysdeps/unix/sysv/linux/fork.c:130
  1    Thread 0x7ffff7fe1740 (LWP 23869) "gdb_pthread" ParentDo (argv=0x7fffffffe3a0 "Parent") at gdb_pthread.c:50
(gdb) info b                #####查看设置的所有的断点breakpoint和捕捉点catchpoint（共3个）：
Num     Type           Disp Enb Address            What
1       catchpoint     keep y                      fork, process 23873 
        catchpoint already hit 1 time
2       breakpoint     keep y   <MULTIPLE>         
        breakpoint already hit 1 time
2.1                         y     0x00000000004007b7 in main at gdb_pthread.c:18 inf 2
2.2                         y     0x00000000004007b7 in main at gdb_pthread.c:18 inf 1
3       breakpoint     keep y   <MULTIPLE>         
        breakpoint already hit 1 time
3.1                         y     0x00000000004008a7 in ParentDo at gdb_pthread.c:50 inf 2
3.2                         y     0x00000000004008a7 in ParentDo at gdb_pthread.c:50 inf 1
(gdb)

3.9 如果手动切换到线程24024

(gdb) thread 3
[Switching to thread 3 (Thread 0x7ffff6fdd700 (LWP 24024))]
#0  ParentDo (argv=0x7fffffffe390 "Thread") at gdb_pthread.c:50
50              printf( "[%s]: [%d] [%s] [%lu] [%s]\n", argv, pid, tprefix, tid, "step2" );
(gdb) info threads                   #####查看所有运行的线程
  Id   Target Id         Frame 
* 3    Thread 0x7ffff6fdd700 (LWP 24024) "gdb_pthread" ParentDo (argv=0x7fffffffe390 "Thread") at gdb_pthread.c:50
  2    Thread 0x7ffff7fe1740 (LWP 23873) "gdb_pthread" 0x00007ffff709b50c in __libc_fork () at ../nptl/sysdeps/unix/sysv/linux/fork.c:130
  1    Thread 0x7ffff7fe1740 (LWP 23869) "gdb_pthread" ParentDo (argv=0x7fffffffe3a0 "Parent") at gdb_pthread.c:50
(gdb) info inferiors                 #####显示正在调试的进程  
  Num  Description       Executable        
  2    process 23873     /home/vfhky/bin/gdb_pthread 
* 1    process 23869     /home/vfhky/bin/gdb_pthread 
(gdb)

3.10 开始执行第二个断点处的代码

(gdb) c
Continuing.
[Thread]: [23869] [thread] [140737337218816] [step2]            #####线程24024执行第50行处，打印数据
[Thread]: [23869] [thread] [140737337218816] [step3]            #####线程24024执行第51行处，打印数据
[Thread 0x7ffff6fdd700 (LWP 24024) exited]                      #####线程24024退出
[Switching to Thread 0x7ffff7fe1740 (LWP 23869)]                #####切换到父进程中去

Breakpoint 3, ParentDo (argv=0x7fffffffe3a0 "Parent") at gdb_pthread.c:50                #####父进程继续停在第50行处的断点
50              printf( "[%s]: [%d] [%s] [%lu] [%s]\n", argv, pid, tprefix, tid, "step2" );
(gdb) info inferiors                    ######列出正在调试进程（父进程23869和子进程23873），1前面的星号表示当前调试的进程（父进程23869）。 
  Num  Description       Executable        
  2    process 23873     /home/vfhky/bin/gdb_pthread 
* 1    process 23869     /home/vfhky/bin/gdb_pthread 
(gdb) info threads                     ######查看所有运行的线程
  Id   Target Id         Frame 
  2    Thread 0x7ffff7fe1740 (LWP 23873) "gdb_pthread" 0x00007ffff709b50c in __libc_fork () at ../nptl/sysdeps/unix/sysv/linux/fork.c:130            #####子进程23873
* 1    Thread 0x7ffff7fe1740 (LWP 23869) "gdb_pthread" ParentDo (argv=0x7fffffffe3a0 "Parent") at gdb_pthread.c:50          #####父进程23869
(gdb)

这时使用命令查看当前系统进程的状态：存在父进程23869和子进程23873，其中线程24024已经结束了。

[vfhky@typecodes ~]$ pstree -pul

3.11 继续调试父进程

此时，由于线程的退出，父进程作为自动选择的要调试的线程。

(gdb) c
Continuing.
[Parent]: [23869] [thread] [140737354012480] [step2]        #####父进程23869执行第50行
[Parent]: [23869] [thread] [140737354012480] [step3]        #####父进程23869执行第51行
[Inferior 1 (process 23869) exited normally]                #####正在调试的父进程23869退出
(gdb) info inferiors             ######显示正在调试的进程
  Num  Description       Executable        
  2    process 23873     /home/vfhky/bin/gdb_pthread        #####fork创建的子进程23873
* 1    <null>            /home/vfhky/bin/gdb_pthread        #####fork创建的父进程23869已经退出 
(gdb) info threads              ####显示正在运行的线程：只存在子进程23873，父进程23869已经退出 
  Id   Target Id         Frame 
  2    Thread 0x7ffff7fe1740 (LWP 23873) "gdb_pthread" 0x00007ffff709b50c in __libc_fork () at ../nptl/sysdeps/unix/sysv/linux/fork.c:130

No selected thread.  See `help thread'.         #####提示没有被选中的要调试的线程
(gdb) info b                                    #####查看所有的断点
Num     Type           Disp Enb Address            What
1       catchpoint     keep y                      fork, process 23873 
        catchpoint already hit 1 time
2       breakpoint     keep y   <MULTIPLE>         
        breakpoint already hit 1 time
2.1                         y     0x00000000004007b7 in main at gdb_pthread.c:18 inf 2
2.2                         y     0x00000000004007b7 in main at gdb_pthread.c:18 inf 1
3       breakpoint     keep y   <MULTIPLE>         
        breakpoint already hit 2 times
3.1                         y     0x00000000004008a7 in ParentDo at gdb_pthread.c:50 inf 2      #####子进程23873
3.2                         y     0x00000000004008a7 in ParentDo at gdb_pthread.c:50 inf 1      #####父进程23869
(gdb)

这时使用命令查看当前系统进程的状态：只有子进程23873（由内核init进程接管这个孤儿进程），父进程23869也已经结束了。

[vfhky@typecodes ~]$ pstree -pul

再用ps ux命令查看子进程23873：

4 附录

在gdb中，经常用到的恢复程序运行和单步调试的命令有：

continue        继续运行程序直到下一个断点（类似于VS里的F5）
next            逐过程步进，不会进入子函数（类似VS里的F10）
setp            逐语句步进，会进入子函数（类似VS里的F11）
until           运行至当前语句块结束
finish          运行至函数结束并跳出，并打印函数的返回值（类似VS的Shift+F11）

同步GitHub Markdown文章到Linux服务器后更新Pelican博客的脚本

2016-01-10T22:22:00+08:00

使用了Pelican后，最多的操作就是编译Markdown文章生成HTML文件，然后发布到Nginx的博客目录下。

如上面的流程图所示，目前自己在CentOS7.1服务器上通过Pelican生成和发布博客的做法如下：

在Windows中写好Markdown文章，然后git push到GitHub中的私人仓库中；
在CentOS7.1服务器中git pull到本地仓库；
把Markdown文件复制到Pelican的文章目录(content)生成HTML文件；
用tar命令打包Pelcian在OUTPUT目录中生成的所有HTML文件到一个博客版本备份目录形成一个博客版本；
将这个版本复制到Nginx的博客目录下解压，这样就更新了博客；
同时，也可以发布到GitHub个人主页上。

1 考虑点

如果每次手动执行上面的操作步骤实在是太麻烦了，所以决定使用shell脚本来自动完成。当然除了实现上面的基本功能点之外，脚本还需具备如下4个特点：

脚本执行过程打印到日志文件中，方便查看；
脚本中每条重要语句的执行时间都有记录在日志中；
如果没有从GitHub个人仓库中检测到更新的文章，那么直接结束；
能自动判断是否同步发布到GitHub的个人主页中（博主的是vfhky.github.io）。

2 具体代码

代码比较简单，需要注明的是，如果个人没有Github主页的话，可以直接执行命令./github_pelican_nginx.sh即可，这样就不会执行脚本中的第7个步骤。否则，需要执行命令./github_pelican_nginx.sh "关于本次更新的说明内容"。

#!/bin/bash
# FileName:      github_pelican_nginx.sh
# Description:   Synchronize markdown articles with github, convert to html files using Pelican, deliver it to nginx environment.
# Simple Usage:  ./github_pelican_nginx.sh "commit_comments"
# Crontab Usage: 00 01 * * * /mydata/backups/bak_list/github_pelican_nginx.sh >/dev/null 2>&1
# (c) 2016 vfhky https://typecodes.com/linux/githubpelicanpublishshell.html
# https://github.com/vfhky/shell-tools/blob/master/synchronize/github_pelican_nginx.sh


# Basic command.
FINDCMD="find"
MVCMD="\mv -f"
CPCMD="\cp -rf"
RMCMD="\rm -rf"
TARXCMD="tar -zxf"
TARZIPCMD="tar --warning=no-file-changed -zcf"

# Pelican compile markdown files to html.
PELICAN_COMPILE_DIR=/mydata/GitBang/pelican
# Private bang in github for store your markdown files.
GITHUB_PELICAN_DIR=/mydata/GitBang/GitHub/BlogBak
# Backup dir for your website's version management.
PELICAN_TAR_DIR=/usr/share/nginx/html/pelican_content_bak
# Dir of your website in nginx server.
PELICAN_BLOG_DIR=/usr/share/nginx/html/pelican
# Dir for this shell script to generate logs automatically.
BLOG_PUBLISH_LOG_DIR=/mydata/backups/logs/blogpublish
# Your personal homepage in github.
GITHUB_PERSONAL_PAGE=/mydata/GitBang/GitHub/vfhky.github.io
# Articles in 15 minutes are legal.
TIME_GAP=15

# Get the newest file name.
#Newest_File="ls -lrt| tail -n 1 | awk '{print $9}'"

# Name of this shell script.
PRGNAME="github_pelican_nginx"

# Current date format: e.g 20150505_2015.
Current_Date=$(date +%Y%m%d_%H%M)

# Check if current user is root.
[ "$(id -u)" != "0" ] && echo "Error: You must be root to run this script." && exit 1

# Check parameter.
if [ $# -gt 1 ]; then
    echo "Usage:    ./github_pelican_nginx.sh \"commit_comments\"" && exit 1
fi

# Run command functions.
function ERROR() {
    echo >/dev/null && echo "[$(date +%H:%M:%S:%N)][error] $*" >> ${BLOG_PUBLISH_LOG_DIR}/${Current_Date}.log
    exit 1
}

function NOTICE() {
    echo >/dev/null && echo "[$(date +%H:%M:%S:%N)][notice] $*" >> ${BLOG_PUBLISH_LOG_DIR}/${Current_Date}.log
}

function RUNCMD() {
    echo "[$(date +%H:%M:%S:%N)][notice] $*" >> ${BLOG_PUBLISH_LOG_DIR}/${Current_Date}.log
    eval $@
}

# Git pull command function.
function Git_Pull(){
    RUNCMD "git pull origin master >/dev/null"
}

# Git commit command function.
function Git_Commit(){
    if [ $# -ne 1 ]; then
        ERROR "Usage: Git_Commit commit_comments!"
        exit 1;
    else
        RUNCMD "git pull && git add --all && git commit -m \"$1\" && git push origin master"
    fi
}

# Get the path of markdown articles in TIME_GAP minutes.
function Get_Files_Path(){
    RUNCMD "${FINDCMD} . -mmin -${TIME_GAP} -type f -name \"*.md\" -print0"
}

# Lock down permissions.You should be careful when it comes to your website for the permission of files, but it's safe using 022.
# umask 022

# Create the log dir.
if [ ! -d $BLOG_PUBLISH_LOG_DIR ]; then
    mkdir -p $BLOG_PUBLISH_LOG_DIR
fi


# Main process begin.
NOTICE "[1]Start pull from GitHub."
RC=0
RUNCMD "cd ${GITHUB_PELICAN_DIR}/md_article && Git_Pull"

RC=$?
if [ $RC -gt 0 ]; then
    ERROR "Git pull failed!"
fi


NOTICE "[2]Start copy the pulled articles to the compile dir of PELICAN."
New_Article_Files=$(Get_Files_Path ${GITHUB_PELICAN_DIR}/md_article)
# You should not delete the double quotation marks in case of existing a blank in the file path.
for New_Article_File in "${New_Article_Files}"
do
    if [ -z "${New_Article_File}" ]; then
        echo "No articles, nothing to do."
        ERROR "No articles, nothing to do."
    fi
    FILE_PATH=$(dirname ${PELICAN_COMPILE_DIR}/content/articles/"${New_Article_Files:2}")
    RUNCMD "mkdir -p ${FILE_PATH} && ${CPCMD} \"${New_Article_File}\" ${FILE_PATH}"
done

RC=$?
if [ $RC -gt 0 ]; then
    ERROR "Copy the pulled articles failed!"
fi


NOTICE "[3]Start compile in pelican."
RUNCMD "cd ${PELICAN_COMPILE_DIR} && make publish > /dev/null"

RC=$?
if [ $RC -gt 0 ]; then
    ERROR "Compile in pelican failed!"
fi


NOTICE "[4]Start generate a tar packgage and move it to the backup dir."
# The command of tar cause the problem that file changed as we read with the value 1, so we should ignore it using OR logic.
RUNCMD "cd ${PELICAN_COMPILE_DIR}/output && ${TARZIPCMD} ${Current_Date}.tar.gz . || ${MVCMD} ${Current_Date}.tar.gz ${PELICAN_TAR_DIR}"

RC=$?
if [ $RC -gt 0 ]; then
    ERROR "Generate a tar packgage failed!"
fi


NOTICE "[5]Start unpack the target files."
RUNCMD "${CPCMD} ${PELICAN_TAR_DIR}/${Current_Date}.tar.gz ${PELICAN_BLOG_DIR} && cd ${PELICAN_BLOG_DIR} && ${TARXCMD} ${Current_Date}.tar.gz && ${RMCMD} ${Current_Date}.tar.gz"

RC=$?
if [ $RC -gt 0 ]; then
    ERROR "Unpack the target files failed!"
fi

# if [ $# -eq 1 ]; then
if [ -n "$1" ]; then
    echo "You're going to synchronize your weibsite to the homepage on github.com."
    NOTICE "[6]Start copy the packgage to the local homepage bang cloned from remote in GitHub."
    RUNCMD "${CPCMD} ${PELICAN_TAR_DIR}/${Current_Date}.tar.gz ${GITHUB_PERSONAL_PAGE} && cd ${GITHUB_PERSONAL_PAGE} && ${TARXCMD} ${Current_Date}.tar.gz && ${RMCMD} ${Current_Date}.tar.gz"

    RC=$?
    if [ $RC -gt 0 ]; then
        ERROR "Copy the packgage to the local homepage bang failed!"
    fi

    NOTICE "[7]Start synchronize website to my homepage on GitHub."
    # read -p "Please input your comments on this commitment: " COMMIT_COMMENTS
    # while [[ -z "${COMMIT_COMMENTS}" ]]
    # do
    #   read -p "Comments can not be empty.Please input again: " COMMIT_COMMENTS
    # done
    # RUNCMD "Git_Commit \"${COMMIT_COMMENTS}\""
    RUNCMD "Git_Commit \"$1\""

    RC=$?
    if [ $RC -gt 0 ]; then
        ERROR "Synchronize website to GitHub failed!"
    fi
else
    echo "Not synchronize your weibsite to the homepage on github.com."
    NOTICE "[6]Not synchronize your weibsite to the homepage on github.com."
fi


NOTICE "------END------"
exit 0

3 脚本执行结果

4 脚本管理

目前已经把这个脚本放在Github了，地址是https://github.com/vfhky/shell-tools，以后脚本的更新或者更多好用的脚本也都会加入到这个工程中。

Linux c语言连接MySQL数据库实例

2016-01-07T14:42:00+08:00

工作上自己在Linux C/C++开发时，用的都是Oracle数据库，毕竟企业级应用追求稳定性好、安全可靠。业余时间做了一些WEB开发，接触到MySQL数据库比较多，也比较喜欢开源的MySQL。之前都是用PHP连接MySQL数据库，这里自己用C语言连接MySQL，执行一些简单的连接、查询操作、异常处理等操作。

1 测试程序

代码比较简单，先把MySQL数据库安装后得到的头文件mysql.h包含进来，然后编译时需要用到MySQL对外提供的API接口。查阅了下MySQL官方文档，MySQL对C语言提供了一个静态库libmysqlclient.a和一个动态库libmysqlclient.so接口文件，本文选择使用动态库libmysqlclient.so。

/** 
 * @FileName    linux_c_mysql.c
 * @Describe    A simple example for operating mysql using c programming in linux system.
 * @Author      vfhky 2015.12.29 15:40 https://typecodes.com/cseries/linuxgccgconnectmysql.html
 * @Compile     gcc -I/usr/local/mysql/include  -L/usr/local/mysql/lib -lmysqlclient  linux_c_mysql.c -o linux_c_mysql
 * @Reference   http://dev.mysql.com/doc/refman/5.7/en/c-api-function-overview.html
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mysql.h>


//MySQL connection.
MYSQL *pMysqlConn;
//result set.
MYSQL_RES *pMysqlRes;
//an instance of a row from the result.
MYSQL_ROW MysqlRow;

#define MAX_BUF_SIZE 1024

const char *pHostName = "localhost";    //or set the remote ip address.
const char *pUserName = "root";
const char *pPassword = "password";
const char *pDbName = "typecodes";      //database name of my typecho blog.
const unsigned int iDbPort = 3306;

/* print the last error message. */
void finish_with_error(const char *msg)
{
    if( msg )
        printf("Error message[%s]: [%s].\n", msg, mysql_error(pMysqlConn) );
    else
        printf( "Error message[%s].\n", mysql_error(pMysqlConn) );
    mysql_close(pMysqlConn);
    /**
     * When errors such as MySQL server has gone away hapended, the program should be end immeidately.
     * Otherwise, we should encounter the error below.
     * *** Error in `./linux_c_mysql': double free or corruption (!prev): 0x0000000001223560 ***
     */
    exit(-1);
}

/**
 * mysql_query() cannot be used for statements that contain binary data; you must use mysql_real_query() instead. 
 * Binary data may contain the “\0” character, which mysql_query() interprets as the end of the statement string.
 * In addition, mysql_real_query() is faster than mysql_query() because it does not call strlen() on the statement string. 
 */
int executesql( const char * sql )
{
    if( mysql_real_query( pMysqlConn, sql, strlen(sql) ) )
        return -1;
    return 0;
}

/* init the mysql connection. */
int init_mysql()
{
    pMysqlConn = mysql_init(NULL);
    if( pMysqlConn == NULL ) 
        return -1;
    if( !mysql_real_connect( pMysqlConn, pHostName, pUserName, pPassword, pDbName, iDbPort, NULL, 0 ) )
        return -2;
    //set the language for the results excuted.
    if( executesql("set names utf8") )
        return -3;
    return 0;
}


int main( int argc, char ** argv )
{
    int x=0, i=0;
    printf( "A example for connecting mysql using c program in linux.\n" );
    if( init_mysql() )
        finish_with_error(NULL);

    char cSqlData[MAX_BUF_SIZE] = {0x00};

    memcpy( cSqlData, "SELECT * FROM typecodes_users", strlen("SELECT * FROM vfhkytpvfhky_users") );
    if( executesql( cSqlData ) )
        finish_with_error(NULL);

    //pMysqlRes = mysql_use_result(pMysqlConn);
    pMysqlRes = mysql_store_result(pMysqlConn);

    int iNum_rows = mysql_num_rows(pMysqlRes);
    int iNum_fields = mysql_num_fields(pMysqlRes);

    printf( "Table have [%d] records containing [%d] fields in each one.\n", iNum_rows, iNum_fields );
    printf( "+------------------------------------------------+\n" );

    while( ( MysqlRow = mysql_fetch_row(pMysqlRes) ) )
    {
        i = 0;
        while( i < iNum_fields )
        {
            printf( "| %s", MysqlRow[i]?MysqlRow[i] : "NULL" );
            x = strlen(MysqlRow[i++]);
            for( ; x < 21; x++ )
                printf(" ");
        }
        printf("|\n");
    }

    printf( "+------------------------------------------------+\n" );
    mysql_free_result(pMysqlRes);
    mysql_close(pMysqlConn);
    return 0;
}

2 gcc编译方法

由于之前在搭建MySQL服务的时候，已经把MySQL的动态库路径通过ldconfig命令添加到了Linux系统动态库搜索路径当中了，所以这里直接生成可执行文件就行了。当然，还可以像上一篇文章中的其它3种操作方法，把MySQL动态库mysqlclient.so链接进来最终生成可执行文件。

用下面这条命令编译即可，其中-I参数表示MySQL数据库头文件路径，-L参数表示MySQL数据库的动态库路径。

[root@typecodes ~]# gcc -I/usr/local/mysql/include  -L/usr/local/mysql/lib -lmysqlclient  linux_c_mysql.c -o linux_c_mysql
[root@typecodes ~]# ldd linux_c_mysql

3 执行结果

下图是程序执行获取的之前Typecho博客数据库typecodes中的用户表typecodes_users中的数据：

Linux gcc编译生成静态库和共享动态库的过程

2016-01-05T22:48:00+08:00

这篇文章主要通过实例演示在Linux下如何使用gcc分别编译生成静态库和动态库文件以及其它程序如何使用这个生成的静态库和动态库。

1 要用到的3个测试程序

1、头文件hello.h：

#ifndef HELLO_H
#define HELLO_H
  void hello(const char *name);
#endif

2、hello.c程序：

#include <stdio.h>
void hello(const char *name)
{
    printf( "Welcome to %s.\n", name );
    printf( "libmyhello.so.1.0.1\n" );
    //printf( "libmyhello.so.1.0.2\n" );
    //printf( "libmyhello.so.1.0.3\n" );
}

3、主程序main.c：

#include "hello.h"
int main( int argc, char **argv )
{
    hello("typecodes.com");
    return 0;
}

2 生成静态库文件

使用如下两个命令即可把.o目标文件聚合成.a静态库文件：

[root@typecodes howto_gen_static_lib]# ls
hello.c  hello.h  main.c

####生成目标文件 hello.o
[root@typecodes howto_gen_static_lib]# gcc -c hello.c
[root@typecodes howto_gen_static_lib]# ls
hello.c  hello.h  hello.o  main.c

#####生成静态库文件 libmyhello.a
[root@typecodes howto_gen_static_lib]# ar rcs libmyhello.a hello.o
[root@typecodes howto_gen_static_lib]# ls
hello.c  hello.h  hello.o  libmyhello.a  main.c

那么如何使用生成的静态库文件呢？这里以main.c中调用静态库文件并生成最终的可执行文件hello为例：

[root@typecodes howto_gen_static_lib]# gcc -o hello main.c libmyhello.a
####或者类似于动态共享库
[root@typecodes howto_gen_static_lib]# gcc -o hello main.c -L . -lmyhello
[root@typecodes howto_gen_static_lib]# gcc -o hello main.c -static -L. -lmyhello

注意：如果出现下面这个错误，那么是由于程序链接需要静态库，系统没有安装静态库导致报错：

[root@typecodes howto_gen_static_lib]# gcc -o hello main.c -static -L. -lmyhello
/usr/bin/ld: cannot find -lc
collect2: error: ld returned 1 exit status
[root@typecodes ~]# yum info glibc-static
Loaded plugins: axelget, fastestmirror, langpacks
No metadata available for base
No metadata available for epel
No metadata available for extras
No metadata available for updates
Loading mirror speeds from cached hostfile
 * base: mirrors.aliyun.com
 * epel: mirrors.yun-idc.com
 * extras: mirrors.aliyun.com
 * updates: mirrors.aliyun.com
Available Packages
Name        : glibc-static
Arch        : i686
Version     : 2.17
Release     : 106.el7_2.1
Size        : 1.2 M
Repo        : updates/7/x86_64
Summary     : C library static libraries for -static linking.
URL         : http://www.gnu.org/software/glibc/
License     : LGPLv2+ and LGPLv2+ with exceptions and GPLv2+
Description : The glibc-static package contains the C library static libraries
            : for -static linking.  You don't need these, unless you link statically,
            : which is highly discouraged.

Name        : glibc-static
Arch        : x86_64
Version     : 2.17
Release     : 106.el7_2.1
Size        : 1.5 M
Repo        : updates/7/x86_64
Summary     : C library static libraries for -static linking.
URL         : http://www.gnu.org/software/glibc/
License     : LGPLv2+ and LGPLv2+ with exceptions and GPLv2+
Description : The glibc-static package contains the C library static libraries
            : for -static linking.  You don't need these, unless you link statically,
            : which is highly discouraged.

解决方法：使用如下命令，安装glibc-static程序即可。

[root@typecodes howto_gen_static_lib]# yum -y install glibc-static
[root@typecodes howto_gen_static_lib]# ls
hello  hello.c  hello.h  hello.o  libmyhello.a  main.c

#####运行可执行文件即可
[root@typecodes howto_gen_static_lib]# ./hello 
Hello everyone!
[root@typecodes howto_gen_static_lib]#

3 生成动态库文件

可以如下面3.1小节所示通过gcc直接生成动态库文件，也可以像3.2小节中那样依次生成realname、soname、linkname库文件。不经常更新动态库版本的话，一般会采用3.1小节中的做法；版本更新较频繁的动态库，诸如MySQL的一些动态库就是采用的3.2小节中的做法。

3.1 直接编译生成symbolic link动态库文件

##### 生成hello.o目标文件
[root@typecodes ~]# gcc -c -fPIC hello.c
##### 生成动态库文件libmyhello.so
[root@typecodes ~]# gcc -shared -fPIC -o libmyhello.so hello.o
##### main.c调用动态库文件并生成可执行文件hello
[root@typecodes ~]# gcc -o hello main.c -L. -lmyhello
##### 如果直接执行程序则会报错
[root@typecodes ~]# ./hello 
./hello: error while loading shared libraries: libmyhello.so: cannot open shared object file: No such file or directory

如下图所示，可执行文件hello找不到链接的动态库libmyhello.so而报错：

原因分析：使用ldd hello命令查看可执行文件hello依赖的动态库libmyhello.so，结果是not found。

解决方法一：使用root用户把自己生成的动态共享库路径添加系统动态库中即可。
##### ldconfig更新配置文件目录下的所有动态链接库为Linux系统所共享 [root@typecodes ~]# echo "/root/">/etc/ld.so.conf.d/test.conf [root@typecodes ~]# ldconfig ##### 运行可执行文件 [root@typecodes ~]# ./hello Welcome to typecodes.com.

这时使用ldconfig -v命令查看系统动态库的搜索路径，可以看到libmyhello.so.1动态库所在的路径为绝对路径/root/：

3.2 先生成real name动态库文件，然后创建soname软连接，最后创建link name软链接

##### 生成hello.o目标文件
[root@typecodes ~]# gcc -c -fPIC hello.c
##### 生成共享库：对应real name是libmyhello.so.1.0.1, 对应soname是libmyhello.so.1
[root@typecodes ~]# gcc -g -shared -Wl,-soname,libmyhello.so.1 -o libmyhello.so.1.0.1 hello.o

如下图所示，使用readelf -d libmyhello.so.1.0.1命令查看动态库libmyhello.so.1.0.1的信息，可以看到对应的soname为libmyhello.so.1：

如下图所示，使用ldconfig -vn .命令在当前目录自动生成一个软链接：将soname（libmyhello.so.1）链接到real name（libmyhello.so.1.0.1）。

如下图所示，使用ln -sf libmyhello.so.1 libmyhello.so命令创建链接到soname的共享库文件名(Link Name)：libmyhello.so。

这里如果和前面一样，直接链接创建的动态库文件libmyhello.so生成可执行文件hello，然后直至执行hello，那么也会提示找不到链接的动态库libmyhello.so：

[root@typecodes ~]# gcc -o hello main.c -L. -lmyhello

原因也是一样的，可执行文件hello找不到链接库：

[root@typecodes ~]# ldd hello
        linux-vdso.so.1 =>  (0x00007ffd7e7f7000)
        libmyhello.so.1 => not found
        libc.so.6 => /lib64/libc.so.6 (0x00007f641cb7d000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f641cf53000)

3.1小节中的方法需要root用户权限，对于非root用户有方法二来解决：如前文《Linux gcc链接动态库出错：LIBRARY_PATH和LD_LIBRARY_PATH的区别》所述，只要在当前Linux系统中配置LD_LIBRARY_PATH变量，就可以搜索到依赖的动态库libmyhello.so。

[root@typecodes ~]# gcc -o hello main.c -L. -lmyhello
##### 把当前动态库路径添加到Linux环境变量LD_LIBRARY_PATH中
[root@typecodes ~]# export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:/root
[root@typecodes ~]# echo $LD_LIBRARY_PATH
/root
##### 执行程序
[root@typecodes ~]# ./hello
Welcome to typecodes.com.
libmyhello.so.1.0
##### ldd查看可执行文件依赖的动态库
[root@typecodes ~]# ldd hello
        linux-vdso.so.1 =>  (0x00007fffccf0d000)
        libmyhello.so => /root/libmyhello.so (0x00007f6b58770000)
        libc.so.6 => /lib64/libc.so.6 (0x00007f6b5839b000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f6b58973000)
[root@typecodes ~]#

解决方法三：gcc链接动态库生成可执行文件时，加入rpath参数。

[root@typecodes ~]# gcc -o hello main.c -Wl,-rpath=./ -L. -lmyhello
[root@typecodes ~]# ./hello
Welcome to typecodes.com.
libmyhello.so.1.0.1
[root@typecodes ~]#

解决方法四：最简单的操作就是直接将生成的动态库文件拷贝到Linux系统动态库搜索目录下。

/lib、/lib64：                        系统必备共享库
/usr/lib、/usr/lib64：                标准共享库和静态库
/usr/local/lib：                 本地/第三方函数库

4 总结（update 2017.04.18 12:10）

小节2中讲述了静态库文件的生成方法，小节3中讲述了动态库的生成方法。同时，在执行程序时如果报错提示找不到对应的库文件（可以通过readelf -d hello验证），那么一共有4种方法。

1、添加库路径到 /etc/ld.so.conf.d/ 目录下的配置文件中，然后执行命令ldconfig；
2、添加库路径到 LD_LIBRARY_PATH 环境变量中；
3、在编译链接命令中加入参数 -rpath=库文件所在路径 ；
4、最简单的方式：把库文件拷贝到Linux系统库文件所在目录下（/lib、/lib64、/usr/lib、/usr/lib64、/usr/local/lib等）。

Linux下Nginx、MySQL和PHP等应用的日志切割脚本

2015-12-18T21:01:00+08:00

在Linux中如果应用程序会产生日志，那么就需要考虑日志切割，例如按照固定的大小切割、按照日期进行切割等等。同样，在编译Nginx1.9.0、MySQL5.7.7rc和PHP7后，这三个应用服务都会产生日志，尤其是Nginx进程根据配置文件ngnix.conf记录每条访问记录到access.log中。如果所有的日志都打印到同一个文件中的话，那么时间长了的话就会影响效率。

这篇文章就是针对Linux下应用使用shell脚本进行分割的描述，该脚本特点是：按天切割、自定义切割出来的日志保留的天数以及记录脚本执行过程和耗时。在使用时需要配置好对应应用的日志目录（Source_Log_Dir变量）、日志备份目录（Backup_Dirs变量），然后使用Crontab定时任务执行该脚本即可。

下面是脚本nginx_log_backup.sh的具体内容，这里备份的是Nginx日志，其它诸如MySQL、php等Linux应用只要修改脚本对应的日志路径即可。目前该脚本已经同步到博客在GitHub上创建的关于LNMP配置的工程上了，地址是：https://github.com/vfhky/mylnmp。

#!/bin/bash
# Backup Log Files for linux applications such as nginx, php, mysql and so on.
# Crontab Usage: 00 01 * * * /mydata/backups/bak_list/nginx_log_backup.sh >/dev/null 2>&1
# (c) 2015 vfhky https://typecodes.com/linux/applogsbackup.html
# https://github.com/vfhky/mylnmp/blob/master/nginx_log_backup.sh

# Basic command.
TARCMD="tar -zcf"
MVCMD="\mv -f"
FINDCMD="find"

# Number of days to keep.
NUMDAYS=40

# Path of the logs you want backup.You can set it as the nginx log path or the mysql log path and so on.
Source_Log_Dir=/var/log/nginx
# Set the file types you want backup accoding to the suffix of log files.
Source_Log_Files=`ls ${Source_Log_Dir}/*.log`
# Set the backup path.
Backup_Dirs=${Source_Log_Dir}
# Previous date format: e.g 20150505
Previous_Date=`date -d "-1 days" +%Y%m%d`
# The target backup dir.
Backup_Dir=${Backup_Dirs}/${Previous_Date}
# Path of the log generated by this shell script automatically.
Shell_Log=${Backup_Dir}/process.log


# Run command functions.
function ERROR() {
  echo >/dev/null && echo "[`date +%H:%M:%S:%N`][error] $@" >> ${Shell_Log}
  exit 1
}

function NOTICE() {
  echo >/dev/null && echo "[`date +%H:%M:%S:%N`][notice] $@" >> ${Shell_Log}
}

function RUNCMD() {
  echo $@ >> ${Shell_Log}
  eval $@
}


# Check the days user input.You can delete the codes below generally.
if [[ ! $NUMDAYS =~ ^[0-9]+$ ]]; then
  ERROR "Invalid number of days[$NUMDAYS]!"
elif [ "$NUMDAYS" -eq "0" ]; then
  ERROR "Number of days must be greater than zero!"
fi


# Lock down permissions.
umask 077

# Create the backup log dir and a shell log.
mkdir -p $Backup_Dir
touch $Shell_Log


NOTICE "[1]Start backup."


NOTICE "[2]Start compress the log files using the tar command."
RUNCMD "cd ${Source_Log_Dir} && ${TARCMD} ${Previous_Date}.tar.gz *.log"

RC=$?
if [ $RC -gt 0 ]; then
  ERROR "Creat the backup package failed!"
fi


NOTICE "[3]Start move the compress file to backup dir."
RUNCMD "${MVCMD} ${Previous_Date}.tar.gz ${Backup_Dir}/"

RC=$?
if [ $RC -gt 0 ]; then
  ERROR "Move the compress file failed!"
fi


NOTICE "[4]Start empty every log file."

for file in ${Source_Log_Files}
do
    RUNCMD ">$file"
    RC=$?
    if [ $RC -gt 0 ]; then
      ERROR "Empty every log file failed!"
    fi
done


NOTICE "[5]Removing older folders than $NUMDAYS days."
# ls ${Source_Log_Dir} | grep '^[0-9]\{8\}$' | xargs rm -rf
RUNCMD "$FINDCMD ${Source_Log_Dir} -type d -name [0-9]*\[0-9] -mtime +$NUMDAYS | xargs rm -rf"


NOTICE "[6]End backup."

exit 0

成功将博客从Typecho迁移到Pelican

2015-12-10T22:06:00+08:00

根据前文的上线步骤，目前已经成功的将博客从Typecho迁移到了Pelican。中间上线发布的时候，遇到了好几个问题，不过由于上线步骤中有失败的处理方案（保留Typecho程序），所以在Typecho到Pelican之间来来回回切换了好几次。

1 遇到的问题

主题部分代码在测试的时候存在写死的情况，尤其是网站地址；
测试用的代码没被正常替换成正式发布的版本。

2 上线心得

切换前做好备份工作，并且有失败的处理方案，尽量避免对访问造成影响；
对Nginx来说，从Typecho切换到Pelican，只需要去掉PHP的配置部分就行了。

最后，大家在访问博客的时候出现任何问题，请告知博主，谢谢~

准备将博客从Typecho迁移到Pelican

2015-12-10T16:20:00+08:00

8月份的时候，终于从庞大的WordPress转到了轻量级的博客程序Typecho。简洁的设计和比较出色的Markdown支持，整个Typecho体验还是挺不错的。到10月份的时候，自己了解了一些静态博客程序，包括nodejs的Ghost、Hexo等，ruby写的jekyll以及Python写的Pelican等。

由于当时正好接触到了大蟒蛇，而且对js不熟（ruby都没用过），所以就在本地尝试了一下Pelican。之间折腾了一个从Octopress移植过来的主题Pelican-Octopress未果，后面忙着就没怎么弄了。

前段时间辞职后，闲着就打算把博客“简洁到底”：抛弃MySQL数据库和PHP执行解释，完全采用Python生成静态HTML文件。这样以后就只需要在本地通过Markdown写好文章，然后通过pelican生成html文件即可。

1 目前已完成的操作

将之前这份Typecho主题平滑移植到Pelican中，并在本地调试完毕；
备份目前LNMP环境中的博客数据库和PHP程序（可能会迁移到SAE）；
导出Typecho文章和评论到Disqus中；
在目前CentOS7.1机器上搭建Pelican环境。

2 上线步骤

关闭博客自带评论；
修改博客PHP程序使之支持Disqus评论，并测试导入到Disqus中的评论是否正常；
上传本地Pelican生成的博客（静态HTML文件）；
可选步骤：设置博客所有HTML文件权限为444，文件夹为555（没有执行权限X的话会造成403错误）；
更改Nginx的配置文件，支持Pelican静态博客；
暂时保留PHP和MySQL服务，以便Pelican上线失败的切换；
完成Disqus测试；
service nginx reload重载Nginx服务，开放博客评论；
关闭PHP和MySQL服务；
上线完毕。

3 后续操作

更新博客文章；
继续优化主题模板；
将博客PHP版本迁移到SAE上；
开源博客Typecho版的主题程序和目前Pelican版本的主题程序；
保留新浪微博的PHP版本的API接口（可能会开放）。

4 Pelican简介

Pelican是一个用Python语言编写的静态网站生成器，完全不需要数据库和逻辑服务端支持。
可以使用restructuredText和Markdown进行写作，全静态化对主机非常友好。
特性：使用Jinja模板自定义制作Pelican主题，多语言支持，Atom/RSS feeds，代码高亮，丰富的插件支持...

Linux TCP连接Connection Refused和Connection timed out的问题

2015-09-12T22:39:00+08:00

前段时间和其它系统做联调测试，对方系统采用的是负载均衡模式。调试时采用的是多台手机作为客户端发送到对方负载均衡服务器，然后再把报文转发送到我这边的服务端。在测试的时候，对方测试人员说有的手机客户端会偶尔出现报文发不过来的情况。

故事有点长，先发一张tcp三次握手的过程图镇楼~

1 自己服务端的socket监听出现问题

一开始认为可能是自己作为服务端的监听有问题，因为后面排查监听端口的时候发现了close_wait的情况。当时没多想，认为对方负载均衡不会出错（先前跟其它系统联调过了），就急着解决close_wait的问题去了。

可是后面测试的时候，尽管服务端监听没有任何异常，但是手机APP还是有发包失败的情况，而且怪异的是服务端日志也没打印请求包内容。

2 防火墙只收到对方系统的一个IP记录

折腾了很久还是没找到原因所在，后面联系了对方系统测试人员得到回复说他们的日志报错：

java.net.SocketTimeoutException: SocketTimeoutException invoking https://123.123.123.214:7070: connect timed out

于是联系网络管理员，看防火墙是否拒掉了对方请求报文。结果网管回复防火墙正常，但是只收到对方的一台IP记录，另一IP没有发送过报文。

立即反映给对方开发人员，结果对方发现是负载均衡系统的一台服务器连接我这边系统的网络有问题。

3 问题的总结

到这里问题已经解决了，但是自己对于tcp出现Connection timed out的错误认识不足，只想到是自己服务端close_wait引起的问题。下面是自己对tcp握手过程中出现Connection refused和Connection timed out的总结。

3.1 Connection refused

使用telnet来检查tcp链路时，如果遇到"Connection refused"的错误，那么表示从本地客户端到目标IP地址的路由是正常的，但是该目标端口没有进程在监听，然后服务端拒绝掉了连接。

一个成功的tcp链接将会看到Syn，Syn-Ack，Ack，这也就是我们预期的TCP三次握手。当使用tcpdump或wireshark抓包工具来探测发送过来的请求报文包时，Connection refused将会看到Syn,Rst。

3.2 Connection timed out

如果telnet的时候，TCP路由不正常，那么会得到一个Connection timed out的错误。"Couldn't connect"原因有很多，可能是服务器无法ping通，可能是服务器（防火墙等）丢弃了该请求报文包，也可能是服务器应答太慢，又或者存在间歇性的问题（这种情况很难从日志文件中排查问题）。

下面演示“Connection timed out”的情况：

# 先打开一个ssh会话，telnet任意一个不存在IP
[root@typecodes ~]# telnet 10.10.223.123 9010
Trying 10.10.223.123...

# 然后打开另一个ssh会话，netstat服务器上tcp连接状况
[root@typecodes ~]# netstat -anpt
tcp        0      1 10.169.218.97:53794     10.10.223.123:9010      SYN_SENT    4271/telnet

由下图可知，telnet进程作为客户端发送SYN包后，进入SYN_SENT状态，等待服务端应答。

但是由于客户端和目标IP的路由无法建立（也就是BZ遇到的情况），所以在3分钟后该tcp链路显示Connection timed out。

博客MySQL服务惊魂记：Linux磁盘空间不足(Core Dump文件引爆)

2015-08-17T22:33:00+08:00

昨天在更新完文章《升级博客文章同步微博的插件：PHP正则提取Markdown的图片地址》后，博客突然无法访问了。

1 查看Nginx的错误日志error.log

惊愕之余，换了多个浏览器打开博客首页无果(一直显示加载状态)，最终报内部服务器500的错误。立即查看Nginx服务的错误日志：

[root@typecodes nginx]# vim error.log 
........
[error] 19620#0: *1 FastCGI sent in stderr: "PHP message: SQLSTATE[HY000] [2002] No such file or directory" while reading response header from php-fpm.sock:", host: "typecodes.com"
........

2 查看MySQL的错误日志error.log

从上面的Nginx错误日志中可以看出，可能是MySQL的错误。于是查看MySQL的错误日志error.log，但是当时没注意到下面这条重要错误信息提示：No space left on device。

#### 查看MySQL的错误日志error.log
[root@typecodes mysql]# ls
error.log  mysql.pid
[root@typecodes mysql]# vim error.log 
[02:47:34] [20150816_02:47:34] 103 2015-08-15T18:47:11.843790Z 0 [ERROR] InnoDB: Error number 28 means 'No space left on device'.
[02:47:34] [20150816_02:47:34]     es.html
[02:47:34] [20150816_02:47:34] 105 2015-08-15T18:47:11.843805Z 0 [Warning] InnoDB: Retry attempts for writing partial data failed.
[02:47:34] [20150816_02:47:34] 106 2015-08-15T18:47:11.843812Z 0 [ERROR] InnoDB: Write to file ./ibtmp1 failed at offset 11534336. 1048576 bytes should have been written, only 1044480 were written.
[02:47:34] [20150816_02:47:34]     Check that your OS and file system support files of  this size. Check also that the disk is not full or a disk quota  exceeded.
[02:47:34] [20150816_02:47:34] 107 2015-08-15T18:47:11.843821Z 0 [ERROR] InnoDB: Could not set the file size of './ibtmp1'. Probably out of disk space
[02:47:34] [20150816_02:47:34] 108 2015-08-15T18:47:11.843828Z 0 [ERROR] InnoDB: Unable to create the shared innodb_temporary
[02:47:34] [20150816_02:47:34] 109 2015-08-15T18:47:11.947045Z 0 [Note] InnoDB: Removed temporary tablespace data file: "ibtmp1"
[02:47:34] [20150816_02:47:34] 110 2015-08-15T18:47:11.947081Z 0 [ERROR] Plugin 'InnoDB' init function returned error.
[02:47:34] [20150816_02:47:34] 111 2015-08-15T18:47:11.947089Z 0 [ERROR] Plugin 'InnoDB' registration as a STORAGE ENGINE failed.
[02:47:34] [20150816_02:47:34] 112 2015-08-15T18:47:11.947098Z 0 [ERROR] Failed to initialize plugins.
[02:47:34] [20150816_02:47:34] 113 2015-08-15T18:47:11.947143Z 0 [ERROR] Aborting
[02:47:34] [20150816_02:47:34] 114 
[02:47:34] [20150816_02:47:34] 115 2015-08-15T18:47:11.947154Z 0 [Note] Binlog end
[02:47:34] [20150816_02:47:34] 116 2015-08-15T18:47:11.947598Z 0 [Note] /usr/local/mysql/bin/mysqld: Shutdown complete

由于本能反应（BZ的CentOS7.1服务器20G系统盘+20G数据盘），服务器不可能会出现磁盘空间不足的问题。结果再一次忽略了No space left on device提示。

[root@typecodes mysql]# vim error.log 
........
mysql/data
etting it to a valid, non-empty path.
rc-log) starting as process 22504 ...
c builtins
2015-08-15T18:49:59.921545Z 0 [Note] InnoDB: Uses event mutexes
) is used for memory barrier
2015-08-15T18:49:59.921559Z 0 [Note] InnoDB: Compressed tables use zlib 1.2.3
2015-08-15T18:49:59.922232Z 0 [Note] InnoDB: Number of pools: 1
2015-08-15T18:49:59.922362Z 0 [Note] InnoDB: Using CPU crc32 instructions
ze = 128M, instances = 1, chunk size = 128M
pool
e distribution
user: 'TypeCodes_test' host: 'localhost' (Got an error reading communication packets)
user: 'TypeCodes_test' host: 'localhost' (Got an error reading communication packets)
pecodes.log' (errno: 28 - No space left on device)
00 secs
s)
s)
.......
2015-08-16T14:36:25.977210Z 831 [ERROR] Retry in 60 secs. Message reprinted in

后面尝试使用一个MySQL测试用户登录数据库，还是报错：

[root@typecodes ~]# mysql -u TypeCodes_test -p
[02:43:32] [20150816_02:43:32] Enter password: 
[02:43:32] [20150816_02:43:32] ERROR 2002 (HY000): Can't connect to local MySQL server through socket '/var/run/mysql/mysql.sock' (2)

找不到方法，只能先重启一下MySQL服务，结果一直报The server quit without updating PID file的错误。又一次查看日志，最终确认从问题No space left on device入手。

3 查看Linux磁盘空间信息

根据上面MySQL的No space left on device提示，立马使用df -hl命令查看当前CentOS7.1服务器的磁盘空间信息。结果很明显，挂载在/dev/xvdb2数据盘下面的分区/mydata只剩的12M的空间了！而mysql得数据文件正好存放在mydata分区中，悲剧！

接着进入到/mydata分区，使用命令du -sh查看当前目录下各个子目录所占用的空间大小。结果太出乎意料了，竟然是存放Core Dump文件的corefile目录占用了16G的空间！

这才想起在《CentOS开启coredump转储并生成core文件的配置》文中，设置了Core Dump文件大小为unlimited。日积月累，终于把MySQL搞挂掉了！

4 解决

先删掉corefile目录下面的大部分Core Dump文件，然后使用命令ulimit -c 10240设置coredump file-size为10M。最后，使用命令service mysqld start成功启动MySQL服务！看了下时间，从发现问题到解决用了40多分钟，还好只是个个人博客~

Linux C/C++工程中可生成ELF、动/静态库文件的通用Makefile

2015-08-14T20:27:00+08:00

最近写了一个*nix环境下的Makefile文件，支持编译C/C++，同时能够通过参数配置生成ELF目标文件、动态链接库(.so)和静态链接库(.a)文件。

1 Makefile文件配置说明

首先，根据生成的目标文件类型（ELF可执行文件，动态链接库文件或静态链接库文件），配置GEN_LIBS、GEN_DYN_LIB、EXCUTE_BIN、STATIC_LIBS和DYNAMIC_LIBS等变量。

其次，如果生成的目标文件依赖其它库文件，那么只要将LD_LIB_DIR设置成该动态库所在的目录，LD_LIBS设置成要链接的动态库文件名即可。更建议的做法是在当前C/C++工程的配置文件中设置LIBPATH参数为动态库所在的目录，这样就不用在设置变量LD_LIB_DIR的值了，例如：

export LIBPATH=/usr/lib64/:${LIBPATH}:/home/typecodes/lib

最后需要说明的是，变量$(PROJECT_DIR)表示当前C/C++工程的根路径，可以直接将本Makefile文件中的命令# PROJECT_DIR := /home/typecodes前面的#号去掉，然后设置成自己的工程根目录即可。同样，更建议在工程的配置文件中配置，例如：

export PROJECT_DIR=/home/typecodes

2 使用方法

在配置好Makefile文件中的变量对应的值后，直接将该文件放置在需要编译的C/C++工程目录下面，然后执行make或者make all就可以了。伪目标clean对应的命令make clean能够清除上次执行make命令产生的影响；伪目标help对应的命令make help能够在界面上输出Makefile文件中的重要变量的值，方便调试。

执行完make命令后，在当前目录下会生成.o目标文件以及.d依赖文件，ELF可执行文件放在工程的bin目录下，动/静态库文件放在工程的lib目录下。

3 附录：Makefile文件源码

已将下面的Makefile源文件托管到两个仓库中：

1、GitHub： https://github.com/vfhky/General_Makefile；

2、Coding： https://coding.net/u/vfhky/p/General_Makefile/git。

##################################################################
#
# FILENAME   :  Makefile
# DESCRIPT   :  A general makefile to generate an ELF or a
#                   dynamic or a static library for C/C++ project.
# AUTHOR     :  vfhky  2015.08.07
# URI        :  https://typecodes.com/cseries/cppgeneralmakefile.html
#
##################################################################

.PHONY: all clean help
all:

# Some important on-off settings. You can not be too careful about them.
DEBUG           := y
# Flag of generate a dynamic lib or a static lib: y means yes. If the target is a excutable file, it should be blank!
GEN_LIBS        := y
# Flag of generate a dynamic lib: y means yes. It should be blank unless you want to generate a dynamic lib!
GEN_DYN_LIB     := y
# The name of target bin file.Please let it be blank unless the target is a excutable file. 
EXCUTE_BIN      := 
# Name of the static lib. It should be blank unless the target is a static lib, then the GEN_LIBS is y and GEN_DYN_LIB is blank.
# STATIC_LIBS       := libsrcpbl.a
# Name of the dynamic lib. It should be blank unless the target is a dynamic lib, then the GEN_LIBS is y and GEN_DYN_LIB is y.
DYNAMIC_LIBS    := libsrcpbl.so

# Environment settings. The value of PROJECT_DIR shoule be set in the *nix system as the the absolute dir path of your project.
# PROJECT_DIR   := /home/typecodes
#CURDIR         := $(PROJECT_DIR)/src/pbl
CURDIR          := $(shell pwd)
PRG_BIN_DIR     := $(PROJECT_DIR)/bin
PRG_LIB_DIR     := $(PROJECT_DIR)/lib
PRG_INC_DIR     := $(PROJECT_DIR)/include

# Cross compile tools defined. You needn't modify these vars below generally.
AS      := as
LD      := ld
CC      := gcc
CXX     := g++
CPP     := $(CC) -E
AR      := ar rcs
NM      := nm
STRIP   := strip
RANLIB  := ranlib
STD_OPT := -std=c99 -D_GNU_SOURCE 
CC      += $(STD_OPT)
CXX     += $(STD_OPT)

# *nix system tools defined. You needn't modify these vars below generally.
CP      := cp
SED     := sed
FIND    := find
MKDIR   := mkdir -p
XARGS   := xargs
MV      := mv
RM      := rm -rf


# Get .c, .cpp source files by searching from current directory.
CUR_SRC_DIR = $(shell ls -AxR $(CURDIR)|grep ":"|tr -d ':')
CUR_SRC     := $(foreach subdir,$(CUR_SRC_DIR),$(wildcard $(subdir)/*.c $(subdir)/*.cpp))
#CUR_SRC    := $(shell find . -name "*.c" -o -name "*.cpp"|sed -e 's,./,,')
CUR_C       := $(filter %.c, $(CUR_SRC))
CUR_CPP     := $(filter %.cpp, $(CUR_SRC))

# Get the include files, object files, dependent files by searching from PRG_INC_DIR.
CUR_INC_DIR = $(shell ls -AxR $(PRG_INC_DIR)|grep ":"|tr -d ':')
CUR_INC     := $(foreach subdir,$(CUR_INC_DIR),$(subdir)/*.h)
SRC_H       := $(filter %.h, $(CUR_INC))
#CUR_OBJ    := $(addprefix $(PRG_BIN_DIR)/,$(strip $(CUR_CPP:.cpp=.o) $(CUR_C:.c=.o)))
#CUR_OBJ    := $(addprefix $(PRG_BIN_DIR)/,$(notdir $(CUR_CPP:.cpp=.o) $(CUR_C:.c=.o)))
CUR_OBJ     := $(strip $(CUR_CPP:.cpp=.o) $(CUR_C:.c=.o))
#CUR_DEP    := $(addprefix $(PRG_BIN_DIR)/,$(notdir $(CUR_CPP:.cpp=.d) $(CUR_C:.c=.d)))
CUR_DEP     := $(strip $(CUR_CPP:.cpp=.d) $(CUR_C:.c=.d))

# Create directory in the header files, bin and library directory.
$(foreach dirname,$(sort $(PRG_INC_DIR) $(PRG_BIN_DIR) $(PRG_LIB_DIR)),\
  $(shell $(MKDIR) $(dirname)))

# Complie and link variables. LD_LIBS means the dynamic or static library needed for the object file.
CFLAGS      := $(if $(DEBUG),-g -Wall, -O2 -Wall)
CFLAGS      += $(if $(GEN_DYN_LIB), $(addprefix -fPIC -I ,$(sort $(dir $(SRC_H)))), $(addprefix -I ,$(sort $(dir $(SRC_H)))))
CXXFLAGS    = $(CFLAGS)
LDFLAGS     := 
LD_LIB_DIR  := #-L $(PRG_LIB_DIR)
LD_LIBS     := #-lsrcpbl -lmysqlclient
XLD_FLG     := -Xlinker "-(" $(LDFLAGS) -Xlinker "-)"

# Add vpath.
vpath %.h $(sort $(dir $(SRC_H)))
vpath %.c $(sort $(dir $(CUR_C)))
vpath %.cpp $(sort $(dir $(CUR_CPP)))

# Generate depend files.
ifneq "$(MAKECMDGOALS)" "clean"
sinclude $(CUR_DEP)
endif

# Gen_depend(depend-file,source-file,object-file,cc). This command-package is used to generate a depend file with a postfix of .d.
define gen_depend
  @set -e;                                      \
  $(RM) $1;                                     \
  $4 $(CFLAGS) -MM $2 |                         \
  $(SED) 's,\($(notdir $3)\): ,$3: ,' > $1.tmp; \
  $(SED) -e 's/#.*//'                           \
         -e 's/^[^:]*: *//'                     \
         -e 's/ *\\$$//'                        \
         -e '/^$$/ d'                           \
         -e 's/$$/ :/' < $1.tmp >> $1.tmp;      \
  $(MV) $1.tmp $1;
endef

# Rules to generate objects file(.o) from .c or .cpp files.
$(CURDIR)/%.o: %.c
    @$(call gen_depend,$(patsubst %.o,%.d,$@),$<,$@,$(CC))
    $(CC) $(CFLAGS) -o $@ -c $<

$(CURDIR)/%.o: %.cpp
    @$(call gen_depend,$(patsubst %.o,%.d,$@),$<,$@,$(CXX))
    $(CXX) $(CXXFLAGS) -o $@ -c $<

# Gen_excbin(target,CUR_OBJ,cc). This command-package is used to generate a excutable file.
define gen_excbin
  ULT_BIN += $(PRG_BIN_DIR)/$1
  $(PRG_BIN_DIR)/$1: $2
    $3 $(LDFLAGS) $$^ $(LD_LIB_DIR) $(LD_LIBS) $(XLD_FLG) -o $$@
endef

# Gen_libs(libs,CUR_OBJ,cc). This command-package is used to generate a dynamic lib or a static lib.
define gen_libs
  ULT_LIBS += $(PRG_LIB_DIR)/$1
  $(PRG_LIB_DIR)/$1: $2
    $3 $(if $(GEN_DYN_LIB),-shared $$^ $(CXXFLAGS) $(LD_LIB_DIR) $(LD_LIBS) $(XLD_FLG) -o $$@,$$@ $$^)
endef

# Call gen_excbin to generate a excutale file.
$(foreach bin,$(EXCUTE_BIN),$(eval $(call gen_excbin,$(bin),$(CUR_OBJ),$(CXX))))

# Call gen_libs to generate a dynamic lib.
$(foreach lib,$(DYNAMIC_LIBS),$(eval $(call gen_libs,$(lib),$(CUR_OBJ),$(CXX))))

# Call gen_libs to generate a static lib.
$(foreach lib,$(STATIC_LIBS),$(eval $(call gen_libs,$(lib),$(CUR_OBJ),$(AR))))


all: $(ULT_BIN) $(ULT_LIBS)


clean: 
    -$(FIND) $(CURDIR) -name "*.o" -o -name "*.d" | $(XARGS) $(RM)
    -$(RM) $(ULT_BIN)
    -$(RM) $(ULT_LIBS)


help:
    @echo PROJECT_DIR=[$(PROJECT_DIR)]
    @echo CURDIR=[$(CURDIR)]
    @echo PRG_BIN_DIR=[$(PRG_BIN_DIR)]
    @echo PRG_LIB_DIR=[$(PRG_LIB_DIR)]
    @echo PRG_INC_DIR=[$(PRG_INC_DIR)]
    @echo CUR_SRC_DIR=[$(CUR_SRC_DIR)]
    @echo CUR_SRC=[$(CUR_SRC)]
    @echo CUR_C=[$(CUR_C)]
    @echo CUR_CPP=[$(CUR_CPP)]
    @echo CUR_OBJ=[$(CUR_OBJ)]
    @echo CUR_DEP=[$(CUR_DEP)]
    @echo STD_OPT=[$(STD_OPT)]
    @echo CFLAGS=[$(CFLAGS)]
    @echo STATIC_LIBS=[$(STATIC_LIBS)]
    @echo DYNAMIC_LIBS=[$(DYNAMIC_LIBS)]

解决make编译链接动态库错误：libxx.so: undefined reference to xx

2015-08-13T21:05:00+08:00

最近在写一个Makefile，调试时遇到了libsrcpbl.so: undefined reference to gcProgramName的问题。在这个Makefile脚本里面，终极目标是通过链接一个自定义的动态库libsrcpbl.so生成一个ELF目标文件。

由于链接生成libsrcpbl.so动态库的.o文件比较多，无法定位具体的错误程序文件和位置，所以折腾了较长时间。

1 场景再现

为了能快速定位出错的位置，自己写了一个很简单的测试程序test.c，该程序调用了libsrcpbl.so动态库中的一个自定义的公共头文件pbl_global.h。

/** 
 * @FileName    tst.c
 * @Describe    a simple test program to find out the reason of dynamic library undefined reference.
 * @Author      vfhky 2015.08.12 https://typecodes.com/cseries/libraryundefinedref.html
 */
#include <stdio.h>
#include "pbl_global.h"     //为减少“干扰”，还可以去掉这个头文件引用

int main( int argc, char ** argv )
{
    printf( "exit\n" );
    return 0;
}

接着使用make命令编译链接生成目标ELF文件test，但是在ld链接自定义的动态库libsrcpbl.so的时候报错。为了减少干扰，还可以把pbl_global.h头文件引用去掉。也就是tst.c中是一个及其普通的程序，与libsrcpbl.so中的数据完全没关系，但是还是报出同样的错误：

[root@typecodes test]# make
gcc -std=c99 -D_GNU_SOURCE  -g -Wall  -I /root/gcc_test/tcp_msg/include/ -I /root/gcc_test/tcp_msg/include/CommAPI/ -I /root/gcc_test/tcp_msg/include/pbl/ -o /root/gcc_test/tcp_msg/src/test/tst.o -c tst.c
g++ -std=c99 -D_GNU_SOURCE   /root/gcc_test/tcp_msg/src/test/tst.o -L /root/gcc_test/tcp_msg/lib  -lsrcpbl -Xlinker "-("  -Xlinker "-)" -o /root/gcc_test/tcp_msg/bin/test
/root/gcc_test/tcp_msg/lib/libsrcpbl.so: undefined reference to `gcProgramName'
collect2: error: ld returned 1 exit status
make: *** [/root/gcc_test/tcp_msg/bin/test] Error 1

2 查找 libsrcpbl.so: undefined reference to gcProgramName 的原因

通过make显示的内容，基本判断Makefile文件是正确的。用nm libsrcpbl.so命令查看一下链接的动态库，结果如下：

##### 使用nm查看动态库
[root@typecodes test]# nm -A /root/gcc_test/tcp_msg/lib/libsrcpbl.so|grep gcProgramName
/root/gcc_test/tcp_msg/lib/libsrcpbl.so:                 U gcProgramName
[root@typecodes test]#

根据上图中的信息，结合前文《Unix系统中nm命令展示目标文件符号的方法》nm命令的man手册关于符号U的说明，推测可能原因：libsrcpbl.so动态库文件中存在gcProgramName符号（即变量），需要从test.o对象文件中链接进来，但是test.c程序中没有定义gcProgramName变量，所以报错了。

于是查看原工程中的头文件pbl_global.h，果然发现了gcProgramName是一个外部全局变量，其声明如下：

extern char gcProgramName[20 + 1];

接着发现生成这个libsrcpbl.so动态库的一个源程序中，通过引用头文件pbl_global.h，然后直接使用了这个外部全局变量gcProgramName，因此需要在tst.c对这个变量进行定义。

2 解决方法

找到原因后，解决就很简单了：只要在test.c程序中定义这个外部全局变量gcProgramName即可。

#include <stdio.h>

//定义外部全局变量，解决libsrcpbl.so: undefined reference to gcProgramName的问题
char gcProgramName[20 + 1] = {0x00};
int main( int argc, char ** argv )
{
    //在这里就可以随便赋值使用了
    memcpy( gcProgramName, "TestPrg", strlen( "TestPrg" ) );
    printf( "exit\n" );
    return 0;
}

最后重新make一下，链接生成ELF文件成功！

4 总结

在make编译链接某个动态库lxx.so时，如果报libxx.so: undefined reference to xx的话，很可能是由下面两种原因引起的。Unix/Linux系统中使用nm、objdump和readelf命令可以辅助调试目标文件。

1、链接的动态库中存在只做了声明的自定义的函数/全局变量，但是在其它对象文件中没有实现定义；
2、链接生成的目标文件中引用了某动态库的自定义函数/全局变量，但是没有通过`-lXX`选项链接进来。

Unix系统中nm命令展示目标文件符号的方法

2015-08-12T00:07:00+08:00

在unix系统中，通过gnu开源gcc或者g++工具生成的目标文件（object file），可以用nm、objdump和readelf这三个命令来查看。

nm：显示目标文件中的符号；
objdump：打印目标文件中的详细信息；
readelf：显示关于 ELF 目标文件的信息。

之前在调试makefile文件的时候，链接动态库出错：libsrcpbl.so: undefined reference to 'gcProgramName'。也就是变量gcProgramName没定义，后来通过nm -u libsrcpbl.so命令辅助排查解决了。

为了更全面的了解一下这个命令，在自己的CentOS7.1机器上通过man nm操作查看gnu官方说明手册。同时，对里面涉及的一些opinion选项和nm命令显示的符号做了DESCRIPTION说明，供以后参考。

###### CentOS7.1上查看nm命令的man手册，部分选项仍未能理解。如有熟悉者请指教，谢谢！
[root@typecodes lib]# man nm
NM(1)                                                                  GNU Development Tools                                                                 NM(1)

NAME
       nm - list symbols from object files

SYNOPSIS【纲要】
       nm [-A|-o|--print-file-name] [-a|--debug-syms]
          [-B|--format=bsd] [-C|--demangle[=style]]
          [-D|--dynamic] [-fformat|--format=format]
          [-g|--extern-only] [-h|--help]
          [-l|--line-numbers] [-n|-v|--numeric-sort]
          [-P|--portability] [-p|--no-sort]
          [-r|--reverse-sort] [-S|--print-size]
          [-s|--print-armap] [-t radix|--radix=radix]
          [-u|--undefined-only] [-V|--version]
          [-X 32_64] [--defined-only] [--no-demangle]
          [--plugin name] [--size-sort] [--special-syms]
          [--synthetic] [--target=bfdname]
          [objfile...]

DESCRIPTION
       GNU nm lists the symbols from object files objfile....  If no object files are listed as arguments, nm assumes the file a.out.【GNU nm命令展示nm参数中的所有目标文件中的符号（默认目标文件是a.out）】

       For each symbol, nm shows:

       o   The symbol value, in the radix selected by options (see below), or hexadecimal by default.【符号是按照下面radix进制（默认十六进制）显示】

       o   The symbol type.  At least the following types are used; others are, as well, depending on the object file format.  If lowercase, the symbol is usually
           local; if uppercase, the symbol is global (external).  There are however a few lowercase symbols that are shown for special global symbols ("u", "v"
           and "w").【小写符号通常表示值是局部的，大写表示全局或外部的。小写u,v,w除外】

           "A" The symbol's value is absolute, and will not be changed by further linking.【符号的值是绝对固定的，在后面的链接中也不会改变】

           "B"
           "b" The symbol is in the uninitialized data section (known as BSS).【符号位于内存中未初始化的区域，即BSS段】

           "C" The symbol is common.  Common symbols are uninitialized data.  When linking, multiple common symbols may appear with the same name.  If the symbol
               is defined anywhere, the common symbols are treated as undefined references.【C表示符号类型是未初始化的。当链接时，可能出现多个常用符号同名，这时如果该符号值都被定义了，那么会被当作未定义的引用（重定义错误）】

           "D"
           "d" The symbol is in the initialized data section.【已经初始化的数据段（全局变量）】

           "G"
           "g" The symbol is in an initialized data section for small objects.  Some object file formats permit more efficient access to small data objects, such
               as a global int variable as opposed to a large global array.【小目标文件中的未初始化的数据段的符号】

           "i" For PE format files this indicates that the symbol is in a section specific to the implementation of DLLs.  For ELF format files this indicates
               that the symbol is an indirect function.  This is a GNU extension to the standard set of ELF symbol types.  It indicates a symbol which if
               referenced by a relocation does not evaluate to its address, but instead must be invoked at runtime.  The runtime execution will then return the
               value to be used in the relocation.

           "N" The symbol is a debugging symbol.【N代表调试符号】

           "p" The symbols is in a stack unwind section.【非重定向的栈区】

           "R"
           "r" The symbol is in a read only data section.【只读数据区】

           "S"
           "s" The symbol is in an uninitialized data section for small objects.【未初始化的数据区域】

           "T"
           "t" The symbol is in the text (code) section.【内存中代码文本段（通常是全局非静态函数等）】

           "U" The symbol is undefined.【未定义的符号，需要从其它对象文件中链接进来】

           "u" The symbol is a unique global symbol.  This is a GNU extension to the standard set of ELF symbol bindings.  For such a symbol the dynamic linker
               will make sure that in the entire process there is just one symbol with this name and type in use.【链接器保证唯一性的符号】

           "V"
           "v" The symbol is a weak object.  When a weak defined symbol is linked with a normal defined symbol, the normal defined symbol is used with no error.
               When a weak undefined symbol is linked and the symbol is not defined, the value of the weak symbol becomes zero with no error.  On some systems,
               uppercase indicates that a default value has been specified.

           "W"
           "w" The symbol is a weak symbol that has not been specifically tagged as a weak object symbol.  When a weak defined symbol is linked with a normal
               defined symbol, the normal defined symbol is used with no error.  When a weak undefined symbol is linked and the symbol is not defined, the value
               of the symbol is determined in a system-specific manner without error.  On some systems, uppercase indicates that a default value has been
               specified.【表示如果其他函数库中也有对这个符号的定义，则其他符号的定义可以覆盖这个定义】

           "-" The symbol is a stabs symbol in an a.out object file.  In this case, the next values printed are the stabs other field, the stabs desc field, and
               the stab type.  Stabs symbols are used to hold debugging information.

           "?" The symbol type is unknown, or object file format specific.

       o   The symbol name.

OPTIONS     【nm 可以使用的参数】
       The long and short forms of options, shown here as alternatives, are equivalent.【下面展示的分别以长、短形式的选项都是等效的】

       -A
       -o
       --print-file-name
           Precede each symbol by the name of the input file (or archive member) in which it was found, rather than identifying the input file once only, before
           all of its symbols.【输出符号所对应的库的名字，便于查找符号对应的被定义的库】

       -a
       --debug-syms
           Display all symbols, even debugger-only symbols; normally these are not listed.【展示所有的符号（包括默认不展示的调试符号）】

       -B  The same as --format=bsd (for compatibility with the MIPS nm).

       -C
       --demangle[=style]
           Decode (demangle) low-level symbol names into user-level names.  Besides removing any initial underscore prepended by the system, this makes C++
           function names readable. Different compilers have different mangling styles. The optional demangling style argument can be used to choose an
           appropriate demangling style for your compiler.【将低级符号名解码(demangle)成用户级的名字，使得C++函数名具有可读性。为了区分重载函数，c++编译器会将函数返回值/参数等信息附加到函数名称中去组成一个mangle过的符号。这里的-C选项就是做一个逆操作，输出其原始可理解的符号名称】

       --no-demangle
           Do not demangle low-level symbol names.  This is the default.

       -D
       --dynamic
           Display the dynamic symbols rather than the normal symbols.  This is only meaningful for dynamic objects, such as certain types of shared libraries.【显示动态符号（只对动态目标有效，如特定类型的共享库）】

       -f format
       --format=format
           Use the output format format, which can be "bsd", "sysv", or "posix".  The default is "bsd".  Only the first character of format is significant; it can
           be either upper or lower case.【使用format格式输出】

       -g
       --extern-only
           Display only external symbols.【仅显示外部符号】

       -h
       --help
           Show a summary of the options to nm and exit.

       -l
       --line-numbers
           For each symbol, use debugging information to try to find a filename and line number.  For a defined symbol, look for the line number of the address of
           the symbol.  For an undefined symbol, look for the line number of a relocation entry which refers to the symbol.  If line number information can be
           found, print it after the other symbol information.【对每个符号，使用调试信息（对象文件编译时增加-g选项）以便找到文件名和行号。对于已定义的符号，查找符号地址的行号。对于未定义符号，查找指向符号重定位入口的行号。如果可以找到行号信息，显示在符号信息之后】

       -n
       -v
       --numeric-sort
           Sort symbols numerically by their addresses, rather than alphabetically by their names.【按照符号对应的地址排序而不是字母】

       -p
       --no-sort
           Do not bother to sort the symbols in any order; print them in the order encountered.【按目标文件中遇到的符号顺序显示】

       -P
       --portability
           Use the POSIX.2 standard output format instead of the default format.  Equivalent to -f posix.【使用POSIX.2标准输出格式代替默认的输出格式。等同于使用任选项-f?posix】

       -r
       --reverse-sort
           Reverse the order of the sort (whether numeric or alphabetic); let the last come first.【不管以数字或字母为基本，都反转排序】

       -S
       --print-size
           Print both value and size of defined symbols for the "bsd" output style.  This option has no effect for object formats that do not record symbol sizes,
           unless --size-sort is also used in which case a calculated size is displayed.

       -s
       --print-armap
           When listing symbols from archive members, include the index: a mapping (stored in the archive by ar or ranlib) of which modules contain definitions
           for which names.【当列出库中成员的符号时，包含索引（即哪些模块包含哪些名字的映射）】

       -t radix
       --radix=radix
           Use radix as the radix for printing the symbol values.  It must be d for decimal, o for octal, or x for hexadecimal.【使用radix进制显示符号值。radix只能为―d(十进制)、―o(八进制)或―x(十六进制)】

       -u
       --undefined-only
           Display only undefined symbols (those external to each object file).【仅显示未定义的符号（它们对目标文件都是外部的）】

       -V
       --version
           Show the version number of nm and exit.【显示nm版本并退出】

       -X  This option is ignored for compatibility with the AIX version of nm.  It takes one parameter which must be the string 32_64.  The default mode of AIX
           nm corresponds to -X 32, which is not supported by GNU nm.

       --defined-only
           Display only defined symbols for each object file.【仅显示每个目标文件中已定义的符号】

       --plugin name
           Load the plugin called name to add support for extra target types.  This option is only available if the toolchain has been built with plugin support
           enabled.

       --size-sort
           Sort symbols by size.  The size is computed as the difference between the value of the symbol and the value of the symbol with the next higher value.
           If the "bsd" output format is used the size of the symbol is printed, rather than the value, and -S must be used in order both size and value to be
           printed.【按大小排列符号顺序。该大小是按照一个符号的值与它下一个符号的值进行计算的】

       --special-syms
           Display symbols which have a target-specific special meaning.  These symbols are usually used by the target for some special processing and are not
           normally helpful when included included in the normal symbol lists.  For example for ARM targets this option would skip the mapping symbols used to
           mark transitions between ARM code, THUMB code and data.

       --synthetic
           Include synthetic symbols in the output.  These are special symbols created by the linker for various purposes.  They are not shown by default since
           they are not part of the binary's original source code.

       --target=bfdname
           Specify an object code format other than your system's default format.【指定一个目标代码的格式，而非系统默认的格式】

       @file
           Read command-line options from file.  The options read are inserted in place of the original @file option.  If file does not exist, or cannot be read,
           then the option will be treated literally, and not removed.

           Options in file are separated by whitespace.  A whitespace character may be included in an option by surrounding the entire option in either single or
           double quotes.  Any character (including a backslash) may be included by prefixing the character to be included with a backslash.  The file may itself
           contain additional @file options; any such options will be processed recursively.

SEE ALSO
       ar(1), objdump(1), ranlib(1), and the Info entries for binutils.

COPYRIGHT
       Copyright (c) 1991-2013 Free Software Foundation, Inc.

       Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later
       version published by the Free Software Foundation; with no Invariant Sections, with no Front-Cover Texts, and with no Back-Cover Texts.  A copy of the
       license is included in the section entitled "GNU Free Documentation License".

binutils-2.23.52.0.1                                                        2015-05-12                                                                       NM(1)
 Manual page nm(1) line 178/223 (END) (press h for help or q to quit)

Linux gcc链接动态库出错：LIBRARY_PATH和LD_LIBRARY_PATH的区别

2015-08-08T22:51:00+08:00

昨天在自己的CentOs7.1上写makefile的时候，发现在一个C程序在编译并链接一个已生成好的lib动态库的时候出错。链接命令大概是这样的：

[root@typecodes tcpmsg]# gcc -o hello main.c -lmyhello
/usr/bin/ld: cannot find -lmyhello
collect2: error: ld returned 1 exit status

1 gcc链接动态库时的搜索路径

自以为在当前工程中设置好了环境变量LD_LIBRARY_PATH包含了工程中的lib库路径，并且还在/etc/ld.so.conf/apphome.conf中配置了lib库的路径。那么在调用动态库的时候，gcc就应该能自动去搜索该目录。

很遗憾ld链接器报了如上的错误，但是如果在上面的gcc命令中添加上-L /root/gcc_test/tcp_msg/lib/参数，即明确动态库的绝对路径，是能够链接成功的。

2 Google上查找 /usr/bin/ld: cannot find -l* 的出错原因

gg了很久gcc ld链接动态库出错的原因，结果还是没找到理想的答案。后来猜想是不是在CentOs7中LD_LIBRARY_PATH不起作用的缘故，但是也不应该，因为自己用的GCC（version 4.8.3）跟操作系统没关系。于是重新搜索了gcc LD_LIBRARY_PATH的作用，竟然发现gcc在编译链接时链接的动态库跟LIBRARY_PATH有关而跟LD_LIBRARY_PATH没关系！

3 关于Linux gcc中的`LIBRARY_PATH`和`LD_LIBRARY_PATH`参数说明

下面摘取了两篇较权威的说明资料：

1、GNU上关于LIBRARY_PATH的说明：

LIBRARY_PATH
The value of LIBRARY_PATH is a colon-separated list of directories, much like PATH.
When configured as a native compiler, GCC tries the directories thus specified when searching for special linker files, if it can't find them using GCC_EXEC_PREFIX.
Linking using GCC also uses these directories when searching for ordinary libraries for the -l option (but directories specified with -L come first).

2、man7上关于LD_LIBRARY_PATH的说明：

LD_LIBRARY_PATH
A colon-separated list of directories in which to search for
ELF libraries at execution-time.  Similar to the PATH
environment variable.  Ignored in set-user-ID and set-group-ID
programs.

后面发现StackOverflow上关于LIBRARY_PATH和LD_LIBRARY_PATH的解释更直白：

LIBRARY_PATH is used by gcc before compilation to search for directories containing libraries that need to be linked to your program.

LD_LIBRARY_PATH is used by your program to search for directories containing the libraries after it has been successfully compiled and linked.

EDIT: As pointed below, your libraries can be static or shared.
If it is static then the code is copied over into your program and you don't need to search for the library after your program is compiled and linked.
If your library is shared then it needs to be dynamically linked to your program and that's when LD_LIBRARY_PATH comes into play.

通过这三篇资料的说明，很快明白了LIBRARY_PATH和LD_LIBRARY_PATH的作用。于是，自己在项目配置文件中添加export LIBRARY_PATH=${LIBRARY_PATH}:${APPHOME}/lib。接着将这个配置文件加载到CentOs的环境变量中，这样就在gcc编译不用加-L参数生成目标文件CommuTcp了。

4 总结

关于LIBRARY_PATH和LD_LIBRARY_PATH的关系，这里自己再总结一下。

4.1 Linux gcc编译链接时的动态库搜索路径

GCC编译、链接生成可执行文件时，动态库的搜索路径就包含LIBRARY_PATH，具体的搜索路径顺序如下（注意不会递归性地在其子目录下搜索）：

1、gcc编译、链接命令中的-L选项；
2、gcc的环境变量的LIBRARY_PATH（多个路径用冒号分割）；
3、gcc默认动态库目录：/lib:/usr/lib:usr/lib64:/usr/local/lib。

4.2 执行二进制文件时的动态库搜索路径

链接生成二进制可执行文件后，运行该程序加载动态库文件时就会搜索包含LD_LIBRARY_PATH路径下的动态库，具体顺序如下：

1、编译目标代码时指定的动态库搜索路径：用选项-Wl,rpath和include指定的动态库的搜索路径，比如gcc -Wl,-rpath,include -L. -ldltest hello.c，在执行文件时会搜索路径`./include`；
2、环境变量LD_LIBRARY_PATH（多个路径用冒号分割）；
3、在 /etc/ld.so.conf.d/ 目录下的配置文件指定的动态库绝对路径（通过ldconfig生效，一般是非root用户时使用）；
4、gcc默认动态库目录：/lib:/usr/lib:usr/lib64:/usr/local/lib等。

其中，Linux GCC默认的动态库搜索路径可以通过ld --verbose命令查看：

[root@typecodes tcpmsg]# ld --verbose
    ............
    SEARCH_DIR("/usr/x86_64-redhat-linux/lib64");
    SEARCH_DIR("/usr/local/lib64");
    SEARCH_DIR("/lib64");
    SEARCH_DIR("/usr/lib64");               ##### 64位系统
    SEARCH_DIR("/usr/x86_64-redhat-linux/lib");
    SEARCH_DIR("/usr/local/lib");
    SEARCH_DIR("/lib");
    SEARCH_DIR("/usr/lib");

Unix系统进程对SIGTERM、SIGUSR1和SIGUSR2信号处理

2015-08-05T17:41:00+08:00

好久没更新博客了，写篇文章除除草。这篇文章主要通过简单的例子说明一下Unix/Linux进程中如果捕捉和处理SIGTERM、SIGUSR1和SIGUSR2信号。

先说明一下这三个信号：

信号(signal)是*nix系统中进程之间通信(IPC)的一种常见方式。
SIGTERM：进程终止信号，效果等同于*nix shell中不带-9的kill命令；
SIGUSR1：保留给用户使用的信号；
SIGUSR2：同SIGUSR1，保留给用户使用的信号。

1 信号的处理方式

对于SIGTERM、SIGUSR1和SIGUSR2这三种信号，如果在当前进程中不进行捕获或者忽略（sighold）的话，*nix系统内核会自动使进程退出然后回收进程资源。那么进程如何优雅地处理信号呢？通常需要根据实际情况处理：例如忽略，sigset( SIGCLD, SIG_IGN )父进程忽略子进程退出信号，交由内核init进程回收处理；例如阻塞，sighold( SIGCLD )暂时把子进程退出信号加入到信号掩码中，然后通过sigrelse( SIGCLD )删除并重新接收该信号。

2 程序演示

下面通过两个程序简单演示一个进程如何对SIGTERM信号进行处理。

2.1 SIGTERM信号处理进程：sigterm.c

先为信号SIGTERM注册一个处理函数sTerminate，然后pause()函数使当前进程一直处于挂起状态，直到接收到一个信号才返回。通过静态变量iExtFlag决定是否直接在SIGTERM信号处理函数sTerminate中使进程退出。

/** 
 * @FileName    sigterm.c
 * @Describe    Use kill function to send a signal to a process with the pid coming from argv[1]
 * @Author      vfhky 2015.08.03 https://typecodes.com/cseries/unixsigtermkill.html
 * @Excute      ./sigterm means sTerminate() do not exit before;  ./sigterm 1 means sTerminate() containing exit function.
 * @Return      0
 */
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

void sTerminate();
static int iExtFlag = 0;

int main( int argc, char ** argv )
{
    sigset( SIGTERM, sTerminate );
    printf( "Main process_pid=[%d] will sleep!\n", getpid() );
    if( argc == 2 && *argv[1] == 0x31 )
        iExtFlag = 1;

    //the process will be hung up forever if not receving a signal.
    pause();

    //if there is a signal coming, this code will keep going. 
    printf( "Main process begin to work!\n" );

    //let the process being sleeping 10 sec, and exit then.
    sleep(10);
    printf( "Main process exit!\n" );
    return 0;
}

/**
 * functions to handle the signal of SIGTERM.
 * if the value of static variable iExtFlag is not equal zero, this func will exit without waiting for the main function to do to other things.
 */
void sTerminate()
{
    printf( "Get a SIGTERM signal!\n" );
    if( iExtFlag )
    {
        printf( "Making process exit!\n" );
        exit(EXIT_SUCCESS);
    }
    return;
}

2.2 SIGTERM信号发送进程：sigkill.c

程序功能很简单：通过kill函数把SIGTERM信号发送给前面的sigterm进程。

/** 
 * @FileName    sigkill.c
 * @Describe    Use kill function to send a signal to a process with the pid from argv[1]
 * @Author      vfhky 2015.08.03 https://typecodes.com/cseries/unixsigtermkill.html
 * @Return      success:0    failure: -1
 */
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

int main( int argc, char ** argv )
{
    if( argc != 2 )
    {
        printf( "Usage: ./sigkill process_pid" );
        return -1;
    }
    printf( "You will send a signal to the process=[%s]!\n", argv[1] );
    kill( atoi(argv[1]), SIGTERM );
    printf( "Send over!\n" );
    return 0;
}

3 执行结果

使用GCC命令gcc -Wall sigterm.c -o sigterm和gcc -Wall sigkill.c -o sigkill编译生成可执行文件sigterm和sigkill。

然后输入./sigterm开启SIGTERM信号处理进程sigterm，界面在显示如下所示的当前进程PID后，由于pause进入hung up状态。

Main process_pid=[27346] will sleep!

这时，在另一个shell终端上输入如下命令，sigkill进程向sigterm进程(27346)发送SIGTERM信号。

[root@typecodes signal]# ./sigkill 27346
##### 作用相当于直接通过Linux shell的kill命令:
[root@typecodes signal]# kill 27346

sigterm进程(27346)在接收到信号后，从pause函数中返回，并调用sTerminate函数进行处理。函数处理完后，继续执行pause函数后面的代码。于是，在sleep 10秒后，整个进程退出。

[root@typecodes signal]# ./sigterm 
Main process_pid=[27346] will sleep!
Get a SIGTERM signal!
Main process begin to work!
Main process exit!
[root@typecodes signal]#

效果如图所示：

4 其它说明

对于通过执行./sigterm 1使sigterm进程在接收到sigkill进程发送的信号后，这样sigterm进程就不会进入休眠状态而是直接在sTerminate函数中退出了。

由于进程对SIGUSR1和SIGUSR2等其它信号的处理方法和SIGTERM可以完全一样，这里就不再演示了（只需要把两个程序中的SIGTERM替换即可）。

CentOS中将备份文件同步到BitBucket、GitHub和Coding的shell脚本

2015-07-07T00:30:00+08:00

在上一篇文章讲述了如何在Linux系统中配置BitBucket、GitHub和Coding这三个平台的git账户，这篇文章就分享如何通过shell脚本定时获取自己的CentOS7.1服务器上的备份文件，然后使用git命令同步到这三个平台仓库上。

1 功能需求描述

我自己为这个shell同步脚本设定了以下三个需求功能点：

1、自动获取数据库备份目和程序备份目录下自动生成的最新的备份文件；
2、将获取到的最新的备份数据库和程序文件自动同步到BitBucket、GitHub和Coding这三个Git平台；
3、生成相应的执行日志文件。

2 shell脚本的思路和流程

根据上面的需求，整理出脚本思路：先获取最新的备份文件，然后复制到本地的BitBucket、GitHub和Coding仓库目录下，然后通过Git命令同步到远端仓库即可，整个过程执行的命令以追加的方式保存到同一个日志文件中。

脚本的主要流程：

1、先声明变量`Source_DB_Dir`、`Source_PRG_Dir`表示自己的CentOS服务器上的数据库和程序备份目录，然后`Git_Err_Log_Dir`是生成的执行日志目录。

2、接着声明BitBucket、GitHub和Coding这3个Git平台的本地仓库所在目录（主要是数据库DB目录和程序PRG目录）；

3、后面的三个函数`ERROR`、`NOTICE`和`RUNCMD`对应着不同的操作命令级别并生成相应的日志文件；

4、函数`Get_last_file`功能是获取该目录下面最新的文件；

5、`Git_Commit`函数主要会先通过`git pull`获取远端仓库的最新内容到本地仓库，然后再将本地仓库更新的备份文件同步到远端仓库中。

3 完整的脚本内容

#!/bin/bash
# TypeCodes Git Synchronous Script v1.0.0
# (c) 2015 vfhky https://typecodes.com/linux/gitsynbackupshell.html


Source_DB_Dir=/mydata/backups/data/mysql
Source_PRG_Dir=/mydata/backups/data/typecodes
Git_Err_Log_Dir=/mydata/backups/logs/git

# Coding.net
CodingNet_DB_Dir=/mydata/GitBang/CodingNet/myblog/db
CodingNet_PRG_Dir=/mydata/GitBang/CodingNet/myblog/program

# BitBucket.org
BitBucket_Dir=/mydata/GitBang/BitBucket/myblog/db
BitBucket_PRG_Dir=/mydata/GitBang/BitBucket/myblog/program

# GitHub.com
GitHub_Dir=/mydata/GitBang/GitHub/myblog/db
GitHub_PRG_Dir=/mydata/GitBang/GitHub/myblog/program

# Get the newest file name
#Newest_File="ls -lrt| tail -n 1 | awk '{print $9}'"

# Space separated list of databases
PRGNAME="Git_Synchronous"

# Current date format: e.g 20150505_2015
Current_Date=`date +%Y%m%d_%H%M`

function USAGE() {
cat << EOF
usage: $0 options

This script synchronize the backup files to BitBucket, GitHub and Coding.

OPTIONS:
  -h    Show this message
  -n    Number of days to keep backups
EOF
}

while getopts "hal:n:" opt; do
  case $opt in
    a)
      PRGNAME=""
      ;;
    h)
      USAGE
      exit 1
      ;;
    l)
      PRGNAME="$OPTARG"
      ;;
    n)
      NUMDAYS=$OPTARG
      ;;
    \?)
      USAGE
      exit
      ;;
    :)
      echo "Option -$OPTARG requires an argument." >&2
      exit 1
      ;;
  esac
done

function ERROR() {
  echo && echo "[error] $@" >> $Git_Err_Log_Dir/Git_$Current_Date.log
  exit 1
}

function NOTICE() {
  echo && echo "[notice] $@" >> $Git_Err_Log_Dir/Git_$Current_Date.log
}

function RUNCMD() {
  echo $@ >> $Git_Err_Log_Dir/Git_$Current_Date.log
  eval $@
}

# Git commit command function
function Git_Commit(){
  if [ $# -ne 0 -a $# -ne 1 ]; then
    ERROR "Usage: Git_Commit or Git_Commit file_path!"
    exit 1;
  elif [ $# -lt 1 ]; then
    RUNCMD git pull && git add --all && git commit -m "Backup from TypeCodes.com [Time:$Current_Date]" && git push origin master
  else
    RUNCMD git pull && git add $1 && git commit -m "Backup from TypeCodes.com [Time:$Current_Date]" && git push origin master
  fi
}

# $1:path  $2:filter file-type
function Get_last_file(){
  if [ $# -ne 1 -a $# -ne 2 ]; then
    ERROR "Usage: Get_last_file file_path or Get_last_file file_path file_type!"
    exit 1;
  elif [ $# -lt 2 ]; then
    ls -lrt $1 | tail -n 1 | awk '{print $9}'
  else
    ls -lrt $1 | awk "/$2/" | tail -n 1 | awk '{print $9}'
  fi
}

if [ ! -d $Git_Err_Log_Dir ]; then
  mkdir -p $Git_Err_Log_Dir
fi


NOTICE "Start copy the db_file to git index"
RC=0
Last_Source_DB_File=$(Get_last_file $Source_DB_Dir)
RUNCMD "cd $Source_DB_Dir && \cp -rf $Last_Source_DB_File $CodingNet_DB_Dir && \cp -rf $Last_Source_DB_File $BitBucket_Dir && \cp -rf $Last_Source_DB_File $GitHub_Dir"

RC=$?
if [ $RC -gt 0 ]; then
  ERROR "Copy db_file failed!"
fi

NOTICE "Start copy the program_file to git index"
Last_Program_DB_File=$(Get_last_file $Source_PRG_Dir)
RUNCMD "cd $Source_PRG_Dir && \cp -rf $Last_Program_DB_File $CodingNet_PRG_Dir && \cp -rf $Last_Program_DB_File $BitBucket_PRG_Dir && \cp -rf $Last_Program_DB_File $GitHub_PRG_Dir"

RC=$?
if [ $RC -gt 0 ]; then
  ERROR "Copy program_file failed!"
fi

NOTICE "Start push to CodingNet"
RUNCMD "cd $CodingNet_PRG_Dir && tar -zxf $(Get_last_file $CodingNet_PRG_Dir .tar.gz) && cd ../ && Git_Commit"

NOTICE "Start push to BitBucket"
RUNCMD "cd $BitBucket_PRG_Dir && tar -zxf $(Get_last_file $BitBucket_PRG_Dir .tar.gz) && cd ../ && Git_Commit"

NOTICE "Start push to GitHub"
RUNCMD "cd $GitHub_PRG_Dir && tar -zxf $(Get_last_file $GitHub_PRG_Dir .tar.gz) && cd ../ && Git_Commit"

# exit 0

4 单独执行该shell脚本

可以将这个脚本保存为git.sh，然后使用时通过chmod +x git.sh命令添加执行权限，最后通过./git.sh执行该脚本即可。附图如下：

同步到BitBucket仓库时的截图：

同步到GitHub仓库时的截图：

5 定时执行该shell脚本

利用Linux系统的crontab定时任务工具执行该脚本，例如下面这个配置就是每天凌晨1点的时候执行该shell脚本。

[root@typecodes bak_list]# crontab -e
0 1 * * * /mydata/backups/bak_list/git.sh

根据脚本中的配置，生成的日志类似于/mydata/backups/logs/git/Git_20150706_0100.log：

CentOS系统BitBucket、GitHub和Coding等多git账户的配置

2015-07-05T22:22:00+08:00

目前自己主要在BitBucket、GitHub和Coding这三个Git平台创建了一些项目，所以这篇文章以自己的CentOS7.1服务器作为示例，说说如何在Linux系统中配置不同平台的Git仓库，也即多git账户的配置。

类似于Windows机器上的git配置方法，在CentOS上也是一样的。通过设置Git全部变量的配置文件~/.ssh/config和当前工作仓库的配置文件your_git_project_root/.git/config即可。

1 Git全部变量的配置文件：~/.ssh/config

如上图所示，git全部变量的配置文件~/.ssh/config在当前用户的.ssh目录下面，通过配置这个文件可以实现对多个不同平台的Git账户进行整体控制。例如，使用ssh身份认证的RSA密钥对的存放位置；使用git push的时候，到底是推送到BitBucket还是GitHub活着Coding呢？这些都是由这个文件控制的。

[root@typecodes .ssh]# vim config 
Host github.com
    HostName        github.com
    User            vfhky
    IdentityFile    ~/.ssh/github_rsa

Host git.coding.net
    HostName        git.coding.net
    User            vfhky
    IdentityFile    ~/.ssh/coding_rsa

Host bitbucket.org
    HostName        bitbucket.org
    User            vfhky
    IdentityFile    ~/.ssh/bitbucket_rsa

Host typecodes.com
    HostName        typecodes.com
    Port            8866
    User            root
    IdentityFile    ~/.ssh/typecodes_rsa

配置要点： 1、Host表示主机名，当在每个具体的git项目中执行了git操作，那么会先在这个文件里面所有的HOST名字中进行查找匹配出对应的SSH或者HTTPS地址。通过Host别名和User的配置，可以将不同的Git账户（即使是同一平台的）的区分开来；2、IdentityFile表示使用SSH登录认证时的私钥路径（一般在.ssh目录下面），对应的公钥复制到对应的Git平台上。

注意：如前文《Coding.net上git仓库ssh地址的"bug"》所述，如果错误的配置了Host，那么会造成Permission denied的错误。

2 当前Git项目的配置文件：your_git_project_root/.git/config

小节1中是全部变量的配置，那么在对应每个具体的Git项目中，还需要做一些配置。

vim编辑当前Git项目的隐藏目录.git下面的config文件（以bitbucket为例），这里很容易猜到git push origin master命令的含义和来源。我们在末尾添加[user]信息，包括name和email。当然，也可以直接通过命令git config --global user.name "your git-account-name"和git config --global user.email "your git-account-email"配置。

如果[user]信息未配置，很可能在执行git命令时报错：

3 结束：关于SSH登录认证的RSA公私钥的权限设置

小节1中已经说了，git的SSH登录认证的RSA私钥存放在当前用的.ssh目录下面。我们需要尽量降低该私钥文件的权限，否则会报Permissions 0644 for '~/.ssh/bitbucket_rsa' are too open.的错误。

2015博客升级记(八)：CentOS7定时备份博客程序的shell脚本

2015-06-30T22:24:00+08:00

这是《2015年博客升级记》系列文章的第八篇，同时也是这一系列文章的最后一篇，内容主要记录在Linux系统中如何使用shell脚本备份服务器上的博客程序（当然也可以是主机上的任何目录或者文件）。

1 使用说明

下面是Linux系统文件的shell备份脚本，其中参数BACKUPDIR表示备份文件的存储路径、ORGDIR是待备份的Linux文件路径、NUMDAYS表示保留多少天以内的备份文件。最终，每次执行这个脚本生成的备份文件名类似于系统日期时间+.tar.gz，例如20150606.tar.gz。

使用时通过chmod +x typecodes_backup.sh命令添加执行权限，然后可以利用Linux系统的crontab定时任务工具执行该脚本。例如下面这个配置就是每天凌晨1点的时候执行该shell脚本，生成博客程序的备份文件。当然也可以手动执行命令./typecodes_backup.sh即可立即生成备份文件。

[root@typecodes bak_list]# crontab -e
0 1 * * * /mydata/backups/bak_list/typecodes_backup.sh

2 脚本mysql_backup.sh的全部内容

利用前文mysql备份脚本的框架，写了可以备份Linux主机上的任意目录或者文件的shell脚本，内容如下：

#!/bin/bash
# Blog Program Backup Script v1.0.0(applying to backup any linux directory or files)
# (c) 2015 vfhky https://typecodes.com/linux/centos7blogregularbackup.html
# https://github.com/vfhky/shell-tools/blob/master/backup/typcodes-backup.sh
# https://coding.net/u/vfhky/p/shell-tools/git/blob/master/backup/typcodes-backup.sh

# Shell Script Alias Name
PRGNAME="typecodes"

# Backup to this directory
BACKUPDIR=/mydata/backups/data/typecodes
# The blog programs dir
ORGDIR=/usr/share/nginx/html

# Number of days to keep
NUMDAYS=60

# Some linux command
FINDCMD="find"
TARCMD="tar -zcf"

# Backup date format,e.g 20150505_2010
BACKUPDATE=`date +%Y%m%d_%H%M`

function USAGE() {
cat << EOF
usage: $0 options

This script backs up the blog programs(or other files you want).

OPTIONS:
  -h    Show this message
  -a    Backup all files
  -l    Databases to backup (space seperated)
  -n    Number of days to keep backups
EOF
}

while getopts "hal:n:" opt; do
  case $opt in
    a)
      PRGNAME=""
      ;;
    h)
      USAGE
      exit 1
      ;;
    l)
      PRGNAME="$OPTARG"
      ;;
    n)
      NUMDAYS=$OPTARG
      ;;
    \?)
      USAGE
      exit
      ;;
    :)
      echo "Option -$OPTARG requires an argument." >&2
      exit 1
      ;;
  esac
done

function ERROR() {
  echo && echo "[error] $@"
  exit 1
}

function NOTICE() {
  echo && echo "[notice] $@"
}

function RUNCMD() {
  echo $@
  eval $@
}

# Sanity checks
if [ ! -n "$BACKUPDIR" ]; then
  ERROR "Invalid backup directory"
fi

if [[ ! $NUMDAYS =~ ^[0-9]+$ ]]; then
  ERROR "Invalid number of days: $NUMDAYS"
elif [ "$NUMDAYS" -eq "0" ]; then
  ERROR "Number of days must be greater than zero"
fi

# Lock down permissions
umask 077

# Create directory if needed
RUNCMD mkdir -p -v $BACKUPDIR

if [ ! -d $BACKUPDIR ]; then
  ERROR "Invalid directory: $BACKUPDIR"
fi

RC=0

RUNCMD "cd $ORGDIR && $TARCMD $BACKUPDATE.tar.gz ./ || mv $BACKUPDATE.tar.gz $BACKUPDIR"
RC=$?

if [ $RC -gt 0 ]; then
  ERROR "TypeCodesDump failed!"

else
  NOTICE "Removing dumps older than $NUMDAYS days..."
  RUNCMD "$FINDCMD $BACKUPDIR -name \"*.tar.gz\" -type f -mtime +$NUMDAYS -print0 | xargs -0 rm -fv"

  NOTICE "Listing backup directory contents..."
  RUNCMD ls -la $BACKUPDIR

  NOTICE "Dumping TypeCodes Programs is complete!"

fi

# exit 0

3 Shell Script工具集合

同前文的mysql备份脚本一样，这个博客程序备份脚本也托管在自己的Coding.net和GitHub上：

Coding.net地址：https://github.com/vfhky/shell-tools/；

GitHub地址：https://coding.net/u/vfhky/p/shell-tools/git。

2015博客升级记(七)：CentOS7定时备份MySql的shell脚本

2015-06-29T22:41:00+08:00

这是《2015年博客升级记》系列文章的第七篇，主要记录在Linux系统中如何使用shell脚本备份服务器上的mysql数据库。

1 使用说明

下面是MySql数据库的shell备份脚本，其中参数DBLIST表示要备份的mysql数据库名称、NUMDAYS表示保留多少天以内的备份文件、MyUSER和MyPASS表示mysql数据库的用户名和密码。最终，每次执行这个脚本生成的备份文件名类似于系统日期时间+.sql.gz，例如20150606.sql.gz。

使用时通过chmod +x mysql_backup.sh命令添加执行权限，然后可以利用Linux系统的crontab定时任务工具执行该脚本。例如下面这个配置就是每天凌晨1点的时候执行该shell脚本，生成mysql数据库的备份文件。

[root@typecodes bak_list]# crontab -e
0 1 * * * /mydata/backups/bak_list/mysql_backup.sh

2 脚本mysql_backup.sh的全部内容

以后的更新都会提交到本文小节3中的两个git仓库中。

#!/bin/bash
# MySQL Backup Script v1.0.0
# (c) 2015 vfhky https://typecodes.com/linux/centos7mysqlregularbackup.html
# Reference: https://github.com/chekolyn/bash-scripts/blob/master/mysql-dbs-backup.sh
# https://github.com/vfhky/shell-tools/blob/master/backup/mysql_backup.sh
# https://coding.net/u/vfhky/p/shell-tools/git/blob/master/backup/mysql_backup.sh

# Space separated list of databases
DBLIST="your mysql database name witch you want to backup"

# Backup to this directory
BACKUPDIR=/mydata/backups/data/mysql

# Number of days to keep
NUMDAYS=60

# Some linux command and your mysql configure
FINDCMD="find"
MYSQLCMD="mysql"
MyUSER="your mysql user name"                   # USERNAME
MyPASS="your mysql password"                   # PASSWORD 
MyHOST="localhost"          # Hostname
DUMPCMD="mysqldump -u$MyUSER -h $MyHOST -p$MyPASS --lock-tables --databases "
GZIPCMD="gzip"

# Backup date format,e.g 20150505_2010
BACKUPDATE=`date +%Y%m%d_%H%M`

function USAGE() {
cat << EOF
usage: $0 options

This script backs up a list of MySQL databases.

OPTIONS:
  -h    Show this message
  -a    Backup all databases
  -l    Databases to backup (space seperated)
  -n    Number of days to keep backups
EOF
}

while getopts "hal:n:" opt; do
  case $opt in
    a)
      DBLIST=""
      ;;
    h)
      USAGE
      exit 1
      ;;
    l)
      DBLIST="$OPTARG"
      ;;
    n)
      NUMDAYS=$OPTARG
      ;;
    \?)
      USAGE
      exit
      ;;
    :)
      echo "Option -$OPTARG requires an argument." >&2
      exit 1
      ;;
  esac
done

function ERROR() {
  echo && echo "[error] $@"
  exit 1
}

function NOTICE() {
  echo && echo "[notice] $@"
}

function RUNCMD() {
  echo $@
  eval $@
}

# Sanity checks
if [ ! -n "$DBLIST" ]; then
  DBLIST=`$MYSQLCMD -N -s -e "show databases" | grep -viE '(information_schema|performance_schema|mysql|test)'`

  if [ ! -n "$DBLIST" ]; then
    ERROR "Invalid database list"
  fi
fi

if [ ! -n "$BACKUPDIR" ]; then
  ERROR "Invalid backup directory"
fi

if [[ ! $NUMDAYS =~ ^[0-9]+$ ]]; then
  ERROR "Invalid number of days: $NUMDAYS"
elif [ "$NUMDAYS" -eq "0" ]; then
  ERROR "Number of days must be greater than zero"
fi

# Lock down permissions
umask 077

# Create directory if needed
RUNCMD mkdir -p -v $BACKUPDIR

if [ ! -d $BACKUPDIR ]; then
  ERROR "Invalid directory: $BACKUPDIR"
fi

NOTICE "Dumping MySQL databases..."
RC=0

for database in $DBLIST; do
  NOTICE "Dumping $database..."
  RUNCMD "$DUMPCMD $database | $GZIPCMD > $BACKUPDIR/$BACKUPDATE.sql.gz"

  RC=$?
  if [ $RC -gt 0 ]; then
    continue;
  fi
done

if [ $RC -gt 0 ]; then
  ERROR "MySQLDump failed!"
else
  NOTICE "Removing dumps older than $NUMDAYS days..."
  RUNCMD "$FINDCMD $BACKUPDIR -name \"*.sql.gz\" -type f -mtime +$NUMDAYS -print0 | xargs -0 rm -fv"

  NOTICE "Listing backup directory contents..."
  RUNCMD ls -la $BACKUPDIR

  NOTICE "MySQLDump is complete!"
fi

# exit 0

3 Shell Script工具集合

目前把这个脚本托管在自己的Coding.net和GitHub的上一个shell script工具集合，地址如下：

Coding.net地址：https://coding.net/u/vfhky/p/shell-tools/git。

GitHub地址：https://github.com/vfhky/shell-tools/。

Coding.net上git仓库ssh地址的"bug"

2015-06-28T19:34:00+08:00

前段时间在用Coding.net同步git仓库时，能正常使用非https的ssh协议，但是这两天在自己的Windows机器上push内容时，报如下图中的错误Permission denied (publickey).：

1 查找原因

查了下Coding.net上这个项目的ssh地址如图所示：

它和我的Windows机器上该项目的G:\php\htdocs\CodingNet\mylnmp\.git\config文件中的配置是一样的（url = git@git.coding.net:vfhky/mylnmp.git），如下图所示：

对于Permission denied错误，按理说git项目地址没问题，那只能是ssh公私钥不对了。于是又用Git Bash重新生成了一对SSH公私钥，并把公钥放到Coding.net上。结果执行git push origin master推送命令时，还是报一样的错误。

在Google上找了好久都没找到原因所在，没办法就只能将仓库切换到https协议。这样每次push或者pull的时候，都需要输入用户名和密码，比较麻烦。

2 对比GitHub的ssh地址发现Coding.net的“bug” 【！！！经指正，其实是我自己弄错了！！！】

下午无意之间看到了自己GitHub上一个仓库的ssh命名git@github.com:vfhky/mylnmp.git，它和上面Coding.net的ssh地址是有区别的。Github的ssh地址中是直接@域名的，而Coding.net的ssh地址是@git.域名。

3 解决方法【！！！经指正，该方法是错误的！！！】

于是，立马尝试把本地Coding.net项目中的ssh地址改成类似于GitHub的ssh地址：

######Coding.net上git仓库ssh地址的bug
url = git@git.coding.net:vfhky/mylnmp.git
改成正确的ssh地址
url = git@coding.net:vfhky/mylnmp.git

4 结束

改完之后，重新执行git push命令，就正常了。在遇到到如下错误时，基本可以从git地址和ssh公私钥是否都正确这两方面来解决。

vfhky@VFHKY-PC /g/php/htdocs/CodingNet/mylnmp (master)
$ git push origin master
Permission denied (publickey).
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

vfhky@VFHKY-PC /g/php/htdocs/CodingNet/mylnmp (master)
$

4 update 2015.07.01 15:12 【正确的解决方法】

经过 @yucong sun 的指正，之前是由于本地Win机上的~/.ssh/config文件配置的主机名是Host coding.net而不是Host git.coding.net，所以git项目中配置的url = git@git.coding.net:vfhky/mylnmp.git，无法匹配到这个主机名Host。

因此，只要把~/.ssh/config的Host coding.net改成Host git.coding.net就行了，如下图所示。这里由于自己的考虑不周，误会“小猴子”了，抱歉抱歉！

PHP7中php.ini、php-fpm和www.conf的配置

2015-06-27T19:05:00+08:00

根据前文《2015博客升级记(五)：CentOS 7.1编译安装PHP7》的configure编译参数设定，安装后的PHP7配置文件所在路径是/usr/local/php7/etc。该目录下会有两个配置文件：php-fpm.conf和php.ini，以及一个文件夹php-fpm.d（包含www.conf文件）。

因此，这篇文章主要对这三个PHP配置文件的进行简单说明，具体的配置过程见本文末尾的附录部分。

1 配置php.ini

php.ini是php运行核心配置文件：

######避免PHP信息暴露在http头中
expose_php = Off

######避免暴露php调用mysql的错误信息
display_errors = Off

######在关闭display_errors后开启PHP错误日志（路径在php-fpm.conf中配置）
log_errors = On

######设置PHP的扩展库路径
extension_dir = "/usr/local/php7/lib/php/extensions/no-debug-non-zts-20141001/"

######设置PHP的opcache和mysql动态库
zend_extension=opcache.so
extension=mysqli.so
extension=pdo_mysql.so

######设置PHP的时区
date.timezone = PRC

######开启opcache
[opcache]
; Determines if Zend OPCache is enabled
opcache.enable=1

######设置PHP脚本允许访问的目录（需要根据实际情况配置）
;open_basedir = /usr/share/nginx/html;

2 配置php-fpm.conf

php-fpm.conf是php-fpm进程服务的配置文件：

######设置错误日志的路径
error_log = /var/log/php-fpm/error.log
######引入www.conf文件中的配置
include=/usr/local/php7/etc/php-fpm.d/*.conf

3 配置www.conf（在php-fpm.d目录下）

www.conf这是php-fpm进程服务的扩展配置文件：

######设置用户和用户组
user = nginx
group = nginx

######根据nginx.conf中的配置fastcgi_pass unix:/var/run/php-fpm/php-fpm.sock;设置PHP监听
; listen = 127.0.0.1:9000   #####不建议使用
listen = /var/run/php-fpm/php-fpm.sock

######开启慢日志
slowlog = /var/log/php-fpm/$pool-slow.log
request_slowlog_timeout = 10s

######设置php的session目录（所属用户和用户组都是nginx）
php_value[session.save_handler] = files
php_value[session.save_path] = /var/lib/php/session

4 附录

在前文《2015博客升级记(六)：Nginx配置HTTPS和SPDY实战》和《CentOS系统MySQL的配置文件my.cnf》已经说明了，目前已经把这个关于Nginx、MySQL和PHP配置的全部托管在GitHub和coding.net上，地址如下：

GitHub地址：https://github.com/vfhky/mylnmp；

Coding地址：https://coding.net/u/vfhky/p/mylnmp/git。

最后，附上工程的截图：

2015博客升级记(五)：CentOS 7.1编译安装PHP7

2015-06-26T19:16:00+08:00

这是《2015年博客升级记》系列文章的第五篇，主要记录在Linux系统中如何编译安装PHP7。

1 创建php用户和用户组，并在github下载php7源码

首先创建一个名为php且没有登录权限的用户和一个名为php的用户组，然后去GitHub下载php7源码包。

#######新建php用户和php组
[root@typecodes ~]# groupadd -r php && useradd -r -g php -s /bin/false -d /usr/local/php7 -M php
######从GitHub下载php7安装包
[root@typecodes ~]# wget -c --no-check-certificate -O php7-src-master.zip https://github.com/php/php-src/archive/master.zip
######开始解压php7包
[root@typecodes ~]# unzip -q php7-src-master.zip && cd php-src-master
#####安装编译php7时需要的依赖包
[root@typecodes php-src-master]# yum -y install libxml2 libxml2-devel openssl openssl-devel curl-devel libjpeg-devel libpng-devel freetype-devel libmcrypt-devel

2 PHP7编译参数的配置

准备工作做好后，就开始正式配置php7的安装明细了。注意，操作时一定要先把下面反斜杠“\”后面添加的注释文字去掉！！！

######开始生成配置文件
[root@typecodes php-src-master]# ./buildconf
buildconf: checking installation...
buildconf: autoconf version 2.69 (ok)
rebuilding aclocal.m4
rebuilding configure
rebuilding main/php_config.h.in
######开始配置
[root@typecodes php-src-master]# ./configure \
--prefix=/usr/local/php7 \                              [PHP7安装的根目录]
--exec-prefix=/usr/local/php7 \
--bindir=/usr/local/php7/bin \
--sbindir=/usr/local/php7/sbin \
--includedir=/usr/local/php7/include \
--libdir=/usr/local/php7/lib/php \
--mandir=/usr/local/php7/php/man \
--with-config-file-path=/usr/local/php7/etc \           [PHP7的配置目录]
--with-mysql-sock=/var/run/mysql/mysql.sock \           [PHP7的Unix socket通信文件]
--with-mcrypt=/usr/include \
--with-mhash \
--with-openssl \
--with-mysql=shared,mysqlnd \                           [PHP7依赖mysql库]              
--with-mysqli=shared,mysqlnd \                          [PHP7依赖mysql库]
--with-pdo-mysql=shared,mysqlnd \                       [PHP7依赖mysql库]
--with-gd \
--with-iconv \
--with-zlib \
--enable-zip \
--enable-inline-optimization \
--disable-debug \
--disable-rpath \
--enable-shared \
--enable-xml \
--enable-bcmath \
--enable-shmop \
--enable-sysvsem \
--enable-mbregex \
--enable-mbstring \
--enable-ftp \
--enable-gd-native-ttf \
--enable-pcntl \
--enable-sockets \
--with-xmlrpc \
--enable-soap \
--without-pear \
--with-gettext \
--enable-session \                                      [允许php会话session]
--with-curl \                                           [允许curl扩展]
--with-jpeg-dir \
--with-freetype-dir \
--enable-opcache \                                      [使用opcache缓存]
--enable-fpm \
--enable-fastcgi \
--with-fpm-user=nginx \                                 [php-fpm的用户]
--with-fpm-group=nginx \                                [php-fpm的用户组]
--without-gdbm \
--disable-fileinfo

执行上面的配置命令的结果如下图所示：

3 开始编译和安装PHP7

相对编译安装MySQL的大量CPU和内存消耗，PHP7的编译安装轻松多了，整个过程大约1个小时左右。

[root@typecodes php-src-master]# make clean && make && make install

看到下图就代表已经编译安装好了PHP7！

4 选做步骤：执行make test命令进行测试

这是一个非必需的操作步骤，执行make test命令。

有趣的一件事就是：在test期间，会和一个IP地址72.52.91.14建立tcp连接，它对应着php官网http://www.php.net。

执行完make test命令后，最终的结果如下：

5 查看编译成功后的PHP7安装目录

由于需要和MySQL进行通信，所以需要特别查看PHP7安装后的lib扩展库目录（/usr/local/php7/lib/php/extensions/no-debug-non-zts-20141001/）。需要确保至少存在mysqli.so、pdo_mysql.so这两个动态库文件，如下图所示。

6 开始设置PHP7的配置文件php.ini、php-fpm.conf、www.conf和php-fpm脚本

可以用编译后的配置文件复制到PHP7的配置目录（/usr/local/php7/etc/），推荐使用《PHP7中php.ini、php-fpm和www.conf的配置》文中整理的3个PHP7配置文件和php-fpm服务控制脚本。

#######方法一：直接使用编译后未经优化处理的配置
[root@typecodes php-src-master]# cp php.ini-production /usr/local/php7/etc/php.ini
[root@typecodes php-src-master]# cp /root/php-src-master/sapi/fpm/init.d.php-fpm /etc/init.d/php-fpm
[root@typecodes php-src-master]# cp /usr/local/php7/etc/php-fpm.conf.default /usr/local/php7/etc/php-fpm.conf
[root@typecodes php-src-master]# cp /usr/local/php7/etc/php-fpm.d/www.conf.default /usr/local/php7/etc/php-fpm.d/www.conf
#######方法二：使用https://typecodes.com/web/php7configure.html文中的配置 
[root@typecodes php-src-master]# mv ~/php.ini /usr/local/php7/etc/php.ini && mv ~/php-fpm /etc/init.d/php-fpm
[root@typecodes php-src-master]# mv ~/php-fpm.conf /usr/local/php7/etc/php-fpm.conf && mv ~/www.conf /usr/local/php7/etc/php-fpm.d/www.conf

7 添加php的环境变量

将php编译生成的bin目录添加到当前Linux系统的环境变量中

[root@typecodes ~]# echo -e '\nexport PATH=/usr/local/php7/bin:/usr/local/php7/sbin:$PATH\n' >> /etc/profile && source /etc/profile

8 设置PHP日志目录和php-fpm进程文件（php-fpm.sock）目录

其中，设置php-fpm进程目录的用户和用户组为nginx，并创建php会话session目录。

#######设置PHP日志目录和php-fpm的运行进程ID文件（php-fpm.sock）目录
[root@typecodes ~]# mkdir -p /var/log/php-fpm/ && mkdir -p /var/run/php-fpm && cd /var/run/ && chown -R nginx:nginx php-fpm
#######修改session的目录配置
[root@typecodes etc]# mkdir -p /var/lib/php/session
[root@typecodes etc]# chown -R nginx:nginx /var/lib/php

9 设置PHP开机启动以及测试配置文件是否正确

######配置开机自启动，增加到主机sysV服务
[root@typecodes php-src-master]# chmod +x /etc/init.d/php-fpm
[root@typecodes php-src-master]# chkconfig --add php-fpm
[root@typecodes php-src-master]# chkconfig php-fpm on
######测试PHP的配置文件是否正确合法
[root@typecodes sbin]# php-fpm -t
[03-May-2015 17:50:04] NOTICE: configuration file /usr/local/php7/etc/php-fpm.conf test is successful

10 启动php服务

在完成上面的操作后，就可以正式使用php服务了。启动php进程服务的命令如下：

[root@typecodes sbin]# service php-fpm start
Starting php-fpm  done

然后可以通过命令ps -aux|grep php查看是否成功（图中的php-fpm进程数和进程用户nginx都是由www.conf中pm.start_servers和user的值分别决定的）：

11 查看PHP7版本信息

最后，可以通过命令php -v查看当前PHP版本信息，图中可以看到当前PHP7还使用了Zend OPcache缓存，是因为在php.ini文件中添加了zend_extension=opcache.so配置。

阿里云CentOS 7.1使用yum安装MySql5.6.24

2015-06-25T09:43:00+08:00

在前面两篇文章《2015博客升级记(四)：CentOS 7.1编译安装MySQL5.7.7rc》和《阿里云CentOS 7.1编译安装MySql5.6.24》中，都是采用编译MySQL源码的方式安装的，过程相对比较复杂。所以，这篇文章演示如何使用yum的方式安装MySql5.6.24。

1 常规错误的yum安装方法：

在前文中记述了CentOS 6.5系统中通过yum方式快速地搭建了LNMP环境，那么是否也能在CentOS 7或CentOS 7.1系统中依葫芦画瓢安装MySql5.6.24呢？答案是否定的。

[root@typecodes ~]# yum -y install mysql mysql-server mysql-devel
.....................。
....省略部分安装过程....
.....................。

Installed:
  mariadb.x86_64 1:5.5.41-2.el7_0                                                 mariadb-devel.x86_64 1:5.5.41-2.el7_0

Dependency Installed:
  keyutils-libs-devel.x86_64 0:1.5.8-3.el7    krb5-devel.x86_64 0:1.12.2-14.el7      libcom_err-devel.x86_64 0:1.42.9-7.el7    libselinux-devel.x86_64 0:2.2.2-6.el7   
  libsepol-devel.x86_64 0:2.1.9-3.el7         libverto-devel.x86_64 0:0.2.5-4.el7    openssl-devel.x86_64 1:1.0.1e-42.el7.4    pcre-devel.x86_64 0:8.32-14.el7         
  zlib-devel.x86_64 0:1.2.7-13.el7

Complete!

从上面的安装结果可以看出，没有安装mysql数据库，而是安装了mariadb数据！因为在CentOS 7和CentOS 7.1系统中，默认安装的mysql是它的分支mariadb。这里引用下百度百科关于mariadb的描述：

MariaDB数据库管理系统是MySQL的一个分支，主要由开源社区在维护，采用GPL授权许可 MariaDB的目的是完全兼容MySQL，包括API和命令行，使之能轻松成为MySQL的代替品。

因此，下面这些正常的MySQL操作都是无效的：

#######无法把mysql服务加入系统启动
[root@typecodes ~]# chkconfig mysqld on
error reading information on service mysqld: No such file or directory
#######启动不了mysql
[root@typecodes ~]# service mysqld start
Redirecting to /bin/systemctl start  mysqld.service
Failed to issue method call: Unit mysqld.service failed to load: No such file or directory.
#######没有安装mysql相关包
[root@typecodes ~]# rpm -qa |grep mysql
php-mysql-5.4.16-23.el7_0.3.x86_64
[root@typecodes ~]#

2 正确的安装方法：

众所周知，Linux系统自带的repo是不会自动更新每个软件的最新版本（基本都是比较靠后的稳定版），所以无法通过yum方式安装MySQL的高级版本。所以我们需要先安装带有当前可用的mysql5系列社区版资源的rpm包。

#######安装rpm包
[root@typecodes ~]# rpm -Uvh http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm
Retrieving http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm
Preparing...                          ################################# [100%]
Updating / installing...
   1:mysql-community-release-el7-5    ################################# [100%]

这时查看当前可用的mysql安装资源：

[root@typecodes ~]# yum repolist enabled | grep "mysql.*-community.*"
mysql-connectors-community/x86_64 MySQL Connectors Community                 14
mysql-tools-community/x86_64      MySQL Tools Community                      17
mysql56-community/x86_64          MySQL 5.6 Community Server                139

从上面的列表可以看出，mysql56-community/x86_64和MySQL 5.6 Community Server可以使用。

因此，我们就可以直接用yum方式安装了MySQL5.6版本了。

[root@typecodes ~]# yum -y install mysql-community-server
Loaded plugins: axelget, langpacks
No metadata available for base
No metadata available for epel
No metadata available for extras
(Failed to load module fastestmirror: No module named fastestmirror)
repomd.xml                                                                                                                                      | 2.5 kB  00:00:00     
update mysql-connectors-community metadata successfully
(Failed to load module fastestmirror: No module named fastestmirror)
repomd.xml                                                                                                                                      | 2.5 kB  00:00:00     
update mysql-tools-community metadata successfully
(Failed to load module fastestmirror: No module named fastestmirror)
repomd.xml                                                                                                                                      | 2.5 kB  00:00:00     
update mysql56-community metadata successfully
No metadata available for updates
mysql-connectors-community                                                                                                                      | 2.5 kB  00:00:00     
mysql-tools-community                                                                                                                           | 2.5 kB  00:00:00     
mysql56-community                                                                                                                               | 2.5 kB  00:00:00     
(1/3): mysql-connectors-community/x86_64/primary_db                                                                                             | 7.3 kB  00:00:00     
(2/3): mysql56-community/x86_64/primary_db                                                                                                      |  83 kB  00:00:01     
mysql-tools-community/x86_64/p FAILED                                          ==============================================        ]  19 kB/s |  92 kB  00:00:00 ETA 
http://repo.mysql.com/yum/mysql-tools-community/el/7/x86_64/repodata/3301d2eb425f300dec5a46c4201d08f2cf9232a6-primary.sqlite.bz2: [Errno 12] Timeout on http://repo.mysql.com/yum/mysql-tools-community/el/7/x86_64/repodata/3301d2eb425f300dec5a46c4201d08f2cf9232a6-primary.sqlite.bz2: (28, 'Operation too slow. Less than 1000 bytes/sec transferred the last 3 seconds')
Trying other mirror.
(3/3): mysql-tools-community/x86_64/primary_db                                                                                                  |  15 kB  00:00:00     
Resolving Dependencies
--> Running transaction check
---> Package mysql-community-server.x86_64 0:5.6.24-3.el7 will be installed
--> Processing Dependency: mysql-community-common(x86-64) = 5.6.24-3.el7 for package: mysql-community-server-5.6.24-3.el7.x86_64
--> Processing Dependency: mysql-community-client(x86-64) = 5.6.24-3.el7 for package: mysql-community-server-5.6.24-3.el7.x86_64
--> Processing Dependency: perl(DBI) for package: mysql-community-server-5.6.24-3.el7.x86_64
--> Running transaction check
---> Package mariadb.x86_64 1:5.5.41-2.el7_0 will be obsoleted
---> Package mysql-community-client.x86_64 0:5.6.24-3.el7 will be obsoleting
--> Processing Dependency: mysql-community-libs(x86-64) = 5.6.24-3.el7 for package: mysql-community-client-5.6.24-3.el7.x86_64
---> Package mysql-community-common.x86_64 0:5.6.24-3.el7 will be installed
---> Package perl-DBI.x86_64 0:1.627-4.el7 will be installed
--> Processing Dependency: perl(RPC::PlServer) >= 0.2001 for package: perl-DBI-1.627-4.el7.x86_64
--> Processing Dependency: perl(RPC::PlClient) >= 0.2000 for package: perl-DBI-1.627-4.el7.x86_64
--> Running transaction check
---> Package mariadb-libs.x86_64 1:5.5.41-2.el7_0 will be obsoleted
--> Processing Dependency: mariadb-libs(x86-64) = 1:5.5.41-2.el7_0 for package: 1:mariadb-devel-5.5.41-2.el7_0.x86_64
---> Package mysql-community-libs.x86_64 0:5.6.24-3.el7 will be obsoleting
---> Package perl-PlRPC.noarch 0:0.2020-14.el7 will be installed
--> Processing Dependency: perl(Net::Daemon) >= 0.13 for package: perl-PlRPC-0.2020-14.el7.noarch
--> Processing Dependency: perl(Net::Daemon::Test) for package: perl-PlRPC-0.2020-14.el7.noarch
--> Processing Dependency: perl(Net::Daemon::Log) for package: perl-PlRPC-0.2020-14.el7.noarch
--> Processing Dependency: perl(Compress::Zlib) for package: perl-PlRPC-0.2020-14.el7.noarch
--> Running transaction check
---> Package mariadb-devel.x86_64 1:5.5.41-2.el7_0 will be obsoleted
---> Package mysql-community-devel.x86_64 0:5.6.24-3.el7 will be obsoleting
---> Package perl-IO-Compress.noarch 0:2.061-2.el7 will be installed
--> Processing Dependency: perl(Compress::Raw::Zlib) >= 2.061 for package: perl-IO-Compress-2.061-2.el7.noarch
--> Processing Dependency: perl(Compress::Raw::Bzip2) >= 2.061 for package: perl-IO-Compress-2.061-2.el7.noarch
---> Package perl-Net-Daemon.noarch 0:0.48-5.el7 will be installed
--> Running transaction check
---> Package perl-Compress-Raw-Bzip2.x86_64 0:2.061-3.el7 will be installed
---> Package perl-Compress-Raw-Zlib.x86_64 1:2.061-4.el7 will be installed
--> Finished Dependency Resolution

Dependencies Resolved

=======================================================================================================================================================================
 Package                                         Arch                           Version                                Repository                                 Size
=======================================================================================================================================================================
Installing:
 mysql-community-client                          x86_64                         5.6.24-3.el7                           mysql56-community                          19 M
     replacing  mariadb.x86_64 1:5.5.41-2.el7_0
 mysql-community-devel                           x86_64                         5.6.24-3.el7                           mysql56-community                         3.4 M
     replacing  mariadb-devel.x86_64 1:5.5.41-2.el7_0
 mysql-community-libs                            x86_64                         5.6.24-3.el7                           mysql56-community                         2.0 M
     replacing  mariadb-libs.x86_64 1:5.5.41-2.el7_0
 mysql-community-server                          x86_64                         5.6.24-3.el7                           mysql56-community                          58 M
Installing for dependencies:
 mysql-community-common                          x86_64                         5.6.24-3.el7                           mysql56-community                         256 k
 perl-Compress-Raw-Bzip2                         x86_64                         2.061-3.el7                            base                                       32 k
 perl-Compress-Raw-Zlib                          x86_64                         1:2.061-4.el7                          base                                       57 k
 perl-DBI                                        x86_64                         1.627-4.el7                            base                                      802 k
 perl-IO-Compress                                noarch                         2.061-2.el7                            base                                      260 k
 perl-Net-Daemon                                 noarch                         0.48-5.el7                             base                                       51 k
 perl-PlRPC                                      noarch                         0.2020-14.el7                          base                                       36 k

Transaction Summary
=======================================================================================================================================================================
Install  4 Packages (+7 Dependent packages)

Total download size: 83 M
Downloading packages:
mysql-community-devel-5.6.24-3.el7.x86_64.rpm                                                                                                   | 3.4 MB  00:00:03     
mysql-community-client-5.6.24-3.el7.x86_64.rpm                                                                                                  |  19 MB  00:00:05     
mysql-community-server-5.6.24-3.el7.x86_64.rpm                                                                                                  |  58 MB  00:00:11     
mysql-community-libs-5.6.24-3.el7.x86_64.rpm                                                                                                    | 2.0 MB  00:00:02     
perl-DBI-1.627-4.el7.x86_64.rpm                                                                                                                 |    0 B  00:00:01 ... 
perl-DBI-1.627-4.el7.x86_64.rpm                                                                                                                 | 802 kB  00:00:00     
(1/6): perl-Compress-Raw-Zlib-2.061-4.el7.x86_64.rpm                                                                                            |  57 kB  00:00:00     
(2/6): perl-Net-Daemon-0.48-5.el7.noarch.rpm                                                                                                    |  51 kB  00:00:00     
(3/6): perl-PlRPC-0.2020-14.el7.noarch.rpm                                                                                                      |  36 kB  00:00:00     
(4/6): perl-Compress-Raw-Bzip2-2.061-3.el7.x86_64.rpm                                                                                           |  32 kB  00:00:00     
(5/6): perl-IO-Compress-2.061-2.el7.noarch.rpm                                                                                                  | 260 kB  00:00:00     
warning: /var/cache/yum/x86_64/7/mysql56-community/packages/mysql-community-common-5.6.24-3.el7.x86_64.rpm: V3 DSA/SHA1 Signature, key ID 5072e1f5: NOKEY 00:00:01 ETA 
Public key for mysql-community-common-5.6.24-3.el7.x86_64.rpm is not installed
(6/6): mysql-community-common-5.6.24-3.el7.x86_64.rpm                                                                                           | 256 kB  00:00:01     
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------
Total                                                                                                                                  388 kB/s | 692 kB  00:00:01     
Retrieving key from file:/etc/pki/rpm-gpg/RPM-GPG-KEY-mysql
Importing GPG key 0x5072E1F5:
 Userid     : "MySQL Release Engineering <mysql-build@oss.oracle.com>"
 Fingerprint: a4a9 4068 76fc bd3c 4567 70c8 8c71 8d3b 5072 e1f5
 Package    : mysql-community-release-el7-5.noarch (installed)
 From       : file:/etc/pki/rpm-gpg/RPM-GPG-KEY-mysql
Running transaction check
Running transaction test
Transaction test succeeded
Running transaction
Warning: RPMDB altered outside of yum.
  Installing : mysql-community-common-5.6.24-3.el7.x86_64                                                                                                         1/14 
  Installing : mysql-community-libs-5.6.24-3.el7.x86_64                                                                                                           2/14 
  Installing : mysql-community-client-5.6.24-3.el7.x86_64                                                                                                         3/14 
  Installing : perl-Net-Daemon-0.48-5.el7.noarch                                                                                                                  4/14 
  Installing : 1:perl-Compress-Raw-Zlib-2.061-4.el7.x86_64                                                                                                        5/14 
  Installing : perl-Compress-Raw-Bzip2-2.061-3.el7.x86_64                                                                                                         6/14 
  Installing : perl-IO-Compress-2.061-2.el7.noarch                                                                                                                7/14 
  Installing : perl-PlRPC-0.2020-14.el7.noarch                                                                                                                    8/14 
  Installing : perl-DBI-1.627-4.el7.x86_64                                                                                                                        9/14 
  Installing : mysql-community-server-5.6.24-3.el7.x86_64                                                                                                        10/14 
  Installing : mysql-community-devel-5.6.24-3.el7.x86_64                                                                                                         11/14 
  Erasing    : 1:mariadb-devel-5.5.41-2.el7_0.x86_64                                                                                                             12/14 
  Erasing    : 1:mariadb-5.5.41-2.el7_0.x86_64                                                                                                                   13/14 
  Erasing    : 1:mariadb-libs-5.5.41-2.el7_0.x86_64                                                                                                              14/14 
  Verifying  : perl-Compress-Raw-Bzip2-2.061-3.el7.x86_64                                                                                                         1/14 
  Verifying  : mysql-community-common-5.6.24-3.el7.x86_64                                                                                                         2/14 
  Verifying  : mysql-community-devel-5.6.24-3.el7.x86_64                                                                                                          3/14 
  Verifying  : mysql-community-client-5.6.24-3.el7.x86_64                                                                                                         4/14 
  Verifying  : perl-PlRPC-0.2020-14.el7.noarch                                                                                                                    5/14 
  Verifying  : mysql-community-server-5.6.24-3.el7.x86_64                                                                                                         6/14 
  Verifying  : 1:perl-Compress-Raw-Zlib-2.061-4.el7.x86_64                                                                                                        7/14 
  Verifying  : mysql-community-libs-5.6.24-3.el7.x86_64                                                                                                           8/14 
  Verifying  : perl-Net-Daemon-0.48-5.el7.noarch                                                                                                                  9/14 
  Verifying  : perl-DBI-1.627-4.el7.x86_64                                                                                                                       10/14 
  Verifying  : perl-IO-Compress-2.061-2.el7.noarch                                                                                                               11/14 
  Verifying  : 1:mariadb-5.5.41-2.el7_0.x86_64                                                                                                                   12/14 
  Verifying  : 1:mariadb-devel-5.5.41-2.el7_0.x86_64                                                                                                             13/14 
  Verifying  : 1:mariadb-libs-5.5.41-2.el7_0.x86_64                                                                                                              14/14

Installed:
  mysql-community-client.x86_64 0:5.6.24-3.el7            mysql-community-devel.x86_64 0:5.6.24-3.el7            mysql-community-libs.x86_64 0:5.6.24-3.el7           
  mysql-community-server.x86_64 0:5.6.24-3.el7

Dependency Installed:
  mysql-community-common.x86_64 0:5.6.24-3.el7 perl-Compress-Raw-Bzip2.x86_64 0:2.061-3.el7 perl-Compress-Raw-Zlib.x86_64 1:2.061-4.el7 perl-DBI.x86_64 0:1.627-4.el7
  perl-IO-Compress.noarch 0:2.061-2.el7        perl-Net-Daemon.noarch 0:0.48-5.el7          perl-PlRPC.noarch 0:0.2020-14.el7

Replaced:
  mariadb.x86_64 1:5.5.41-2.el7_0                    mariadb-devel.x86_64 1:5.5.41-2.el7_0                    mariadb-libs.x86_64 1:5.5.41-2.el7_0

Complete!

3 MySQL安装完成后，进行相关配置

安装完MySQL后，需要进行一些基础配置工作：

#######安装成功后，将其加入开机启动
[root@typecodes ~]# systemctl enable mysqld

#######启动mysql服务进程
[root@typecodes ~]# systemctl start mysqld

#######配置mysql（设置密码等）
[root@typecodes ~]# mysql_secure_installation

NOTE: RUNNING ALL PARTS OF THIS SCRIPT IS RECOMMENDED FOR ALL MySQL
      SERVERS IN PRODUCTION USE!  PLEASE READ EACH STEP CAREFULLY!

In order to log into MySQL to secure it, we'll need the current
password for the root user.  If you've just installed MySQL, and
you haven't set the root password yet, the password will be blank,
so you should just press enter here.

Enter current password for root (enter for none): 
OK, successfully used password, moving on...

Setting the root password ensures that nobody can log into the MySQL
root user without the proper authorisation.

Set root password? [Y/n] y                  [设置root用户密码]
New password: 
Re-enter new password: 
Password updated successfully!
Reloading privilege tables..
 ... Success!


By default, a MySQL installation has an anonymous user, allowing anyone
to log into MySQL without having to have a user account created for
them.  This is intended only for testing, and to make the installation
go a bit smoother.  You should remove them before moving into a
production environment.

Remove anonymous users? [Y/n] y                 [删除匿名用户]
 ... Success!

Normally, root should only be allowed to connect from 'localhost'.  This
ensures that someone cannot guess at the root password from the network.

Disallow root login remotely? [Y/n] y       [禁止root远程登录]
 ... Success!

By default, MySQL comes with a database named 'test' that anyone can
access.  This is also intended only for testing, and should be removed
before moving into a production environment.

Remove test database and access to it? [Y/n] y          [删除test数据库]
 - Dropping test database...
ERROR 1008 (HY000) at line 1: Can't drop database 'test'; database doesn't exist
 ... Failed!  Not critical, keep moving...
 - Removing privileges on test database...
 ... Success!

Reloading the privilege tables will ensure that all changes made so far
will take effect immediately.

Reload privilege tables now? [Y/n] y            [刷新权限]
 ... Success!




All done!  If you've completed all of the above steps, your MySQL
installation should now be secure.

Thanks for using MySQL!


Cleaning up...

4 其它说明

至于其它诸如使用root用户创建其它mysql用户或者导入sql文件到数据库中的操作，这里就不说了，可以参考前面的两篇文章。

阿里云CentOS 7.1编译安装MySql5.6.24

2015-06-25T09:42:00+08:00

继前文记述了如何在Linux系统中，通过源码编译安装MySQL5.7.7 Release Candidate版本的过程，这篇文章主要是记录源码编译安装MySql5.6.24的过程。

鉴于官方MySql5.6.24相对是一个比较稳定的版本，所以博主之前也在自己的另一台CentOS7.1主机上安装了一遍。不过最后还是图新鲜，选择了MySQL5.7.7rc版本。下面是具体的安装过程，由于和MySQL5.7.7rc的编译安装过程很类似，所以这里尽可能精简文字：

1 创建mysql用户和用户组，并下载MySql5.6.24版本

首先创建一个名为mysql且没有登录权限的用户和一个名为mysql的用户组，然后去mysql官网下载MySql5.6.24版本。

#######新建mysql用户和mysql组
[root@typecodes ~]# groupadd -r mysql && useradd -r -g mysql -s /bin/false -M mysql

######从官网或者博客备份地址下载MySql5.6.24版本
[root@typecodes ~]# wget -c http://cdn.mysql.com/Downloads/MySQL-5.6/mysql-5.6.24.tar.gz
[root@typecodes ~]# wget -c http://git.typecodes.com/libs/mysql/mysql-5.6.24.tar.gz

######开始解压MySql5.6.24
[root@typecodes ~]# tar -zxvf mysql-5.6.24.tar.gz && cd mysql-5.6.24/
######下载gmock：google的c++mock框架，从mysql 5.6开始支持
[root@typecodes mysql-5.6.24]# wget -c https://googlemock.googlecode.com/files/gmock-1.6.0.zip
[root@typecodes mysql-5.6.24]# wget -c http://git.typecodes.com/libs/ccpp/gmock-1.6.0.zip
######将其解压到MySQL5.6.24的source_downloads目录下
[root@typecodes mysql-5.6.24]# unzip gmock-1.6.0.zip -d source_downloads

2 下载编译MySql5.6.24时需要的工具（安装过程同编译安装MySQL5.7.7rc完全一致）

和编译安装MySQL5.7.7rc版本一样，这里也需要安装CMake、Ncurses、bison和Boost库。

#######CMake编译工具
[root@typecodes ~]# wget -c http://git.typecodes.com/libs/ccpp/cmake-3.2.1.tar.gz
[root@typecodes ~]# tar -zxf cmake-3.2.1.tar.gz && cd cmake-3.2.1
[root@typecodes cmake-3.2.1]# ./configure 
[root@typecodes cmake-3.2.1]# make && make install  [默认安装路径是/usr/local/bin]
[root@typecodes cmake-3.2.1]# cmake --version       [查看cmake版本]
cmake version 3.2.1

CMake suite maintained and supported by Kitware (kitware.com/cmake).
[root@typecodes cmake-3.2.1]# cd ~ && rm -rf cmake-3.2.1*

#######Ncurses：提供功能键定义(快捷键),屏幕绘制以及基于文本终端的图形互动功能的动态库。
[root@typecodes ~]# yum -y install ncurses-devel

#######bison：GNU分析器生成器
[root@typecodes ~]# wget -c http://git.typecodes.com/libs/ccpp/bison-3.0.tar.gz
[root@typecodes ~]# tar -zxf bison-3.0.tar.gz && cd bison-3.0/ && ./configure
[root@typecodes bison-3.0]# make && make install
[root@typecodes bison-3.0]# cd ~ && rm -rf bison-3.0*

#######Boost库：一个开源可移植的C++库，是C++标准化进程的开发引擎之一
[root@typecodes ~]# wget -c http://git.typecodes.com/libs/ccpp/boost_1_57_0.tar.bz2
[root@typecodes ~]# tar -jxf boost_1_57_0.tar.bz2 && cd boost_1_57_0/
[root@typecodes boost_1_57_0]# ./bootstrap.sh
[root@typecodes boost_1_57_0]# ./b2 stage threading=multi link=shared
[root@typecodes boost_1_57_0]# ./b2 install threading=multi link=shared
[root@typecodes boost_1_57_0]# cd ~ && rm -rf boost_1_57_0*

3 解决MySQL5.6.24的bug

在MySQL5.6.24源码包中的/cmd-line-utils/libedit/terminal.c文件有bug，会导致在安装完后，使用命令报Segmentation fault的错误。

谷歌到这篇文章解决：注销第869行的 //char buf[TC_BUFSIZE];并将第879行的area = buf;改成area = NULL;。

4 开始进行MySql5.6.24编译前的配置

这里和编译安装MySQL5.7.7rc时的操作也完全相同：

######使用cmake命令，开始编译MySql5.6.24
[root@typecodes mysql-5.6.24]# cmake \
-DCMAKE_INSTALL_PREFIX=/usr/local/mysql  \              [MySQL安装的根目录]
-DMYSQL_DATADIR=/mydata/mysql/data  \                   [MySQL数据库文件存放目录]
-DSYSCONFDIR=/etc \                                     [MySQL配置文件所在目录]
-DMYSQL_USER=mysql \                                    [MySQL用户名]      
-DWITH_MYISAM_STORAGE_ENGINE=1 \                        [MySQL的数据库引擎]
-DWITH_INNOBASE_STORAGE_ENGINE=1 \                      [MySQL的数据库引擎]
-DWITH_ARCHIVE_STORAGE_ENGINE=1 \                       [MySQL的数据库引擎]
-DWITH_MEMORY_STORAGE_ENGINE=1 \                        [MySQL的数据库引擎]
-DWITH_READLINE=1 \                                     [MySQL的readline library]
-DMYSQL_UNIX_ADDR=/var/run/mysql/mysql.sock \           [MySQL的通讯目录]
-DMYSQL_TCP_PORT=3306 \                                 [MySQL的监听端口]
-DENABLED_LOCAL_INFILE=1 \                              [启用加载本地数据]
-DENABLE_DOWNLOADS=1 \                                  [编译时允许自主下载相关文件]
-DWITH_PARTITION_STORAGE_ENGINE=1  \
-DEXTRA_CHARSETS=all \                                  [使MySQL支持所有的扩展字符]
-DDEFAULT_CHARSET=utf8 \                                [设置默认字符集为utf8]
-DDEFAULT_COLLATION=utf8_general_ci \                   [设置默认字符校对]
-DWITH_DEBUG=0 \                                        [禁用调试模式]
-DMYSQL_MAINTAINER_MODE=0 \
-DWITH_SSL:STRING=bundled \                             [通讯时支持ssl协议]
-DWITH_ZLIB:STRING=bundled                              [允许使用zlib library]

执行上面的配置命令的结果如下图所示：

5 开始编译和安装MySQL5.6.24

相对编译MySQL5.7.7rc来说，编译MySQL5.6.24对主机资源的消耗低很多，而且耗时也少（约1小时）。

[root@typecodes mysql-5.6.24]# make && make install

下图展示的是make命令执行完毕的情况：

make命令执行完后，开始执行make install命令：

最后，激动人心的时刻，看到下图就代表已经编译安装好了MySQL5.6.24！

6 查看编译成功后的MySQL安装目录

同MySQL5.7.7rc一样，需要查看MySQL5.6.24的/usr/local/mysql/lib/目录下是否存在下面的库文件。

[root@typecodes lib]# ls
libmysqlclient.a    libmysqlclient_r.so     libmysqlclient_r.so.18.1.0  libmysqlclient.so.18      libmysqld.a         plugin
libmysqlclient_r.a  libmysqlclient_r.so.18  libmysqlclient.so           libmysqlclient.so.18.1.0  libmysqlservices.a

7 开始设置MySQL的配置文件my.cnf

同MySQL5.7.7rc的配置文件my.cnf一样，直接把《CentOS系统MySQL的配置文件my.cnf》文中整理的my.cnf文件覆盖服务器上的/etc/my.cnf即可。

[root@typecodes mysql]# mv /etc/my.cnf /etc/my.cnfbak
[root@typecodes mysql]# mv  ~/my.cnf  /etc/my.cnf

8 添加mysql的环境变量

同MySQL5.7.7rc，添加MySQL的bin目录到Linux环境变量中：

[root@typecodes mysql]# echo -e '\n\nexport PATH=/usr/local/mysql/bin:$PATH\n' >> /etc/profile && source /etc/profile

9 创建MySQL数据库文件的存放路径以及相关安全配置

同MySQL5.7.7rc，创建/mydata/mysql/data作为MySQL的数据库目录。

[root@typecodes ~]# mkdir -p /mydata/mysql/data && chown -R root:mysql /usr/local/mysql
[root@typecodes mysql]# chown -R mysql:mysql /mydata/mysql/data
[root@typecodes mysql]# chmod -R go-rwx /mydata/mysql/data

10 初始化MySQL自身的数据库

同MySQL5.7.7rc，初始化MySQL自身的数据库。

######参数user表示用户，basedir表示mysql的安装路径，datadir表示数据库文件存放路径
[root@typecodes bin]# mysqld --initialize-insecure --user=mysql --basedir=/usr/local/mysql --datadir=/mydata/mysql/data

执行完后，可以通过[root@typecodes mysql]# ls -lrt /mydata/mysql/data/命令查看是否生成了MySQL自身的数据库文件。

11 创建MySQL日志存放目录以及设置开机启动

同MySQL5.7.7rc，将启动MySQL服务进程的脚本添加到开机启动项中。

[root@typecodes ~]# mkdir -p /var/run/mysql && mkdir -p /var/log/mysql
[root@typecodes ~]# chown -R mysql:mysql /var/log/mysql && chown -R mysql:mysql /var/run/mysql
######配置开机自启动
[root@typecodes mysql]# cp /usr/local/mysql/support-files/mysql.server  /etc/init.d/mysqld
[root@typecodes mysql]# chmod +x /etc/init.d/mysqld     #增加可执行权限
[root@typecodes mysql]# chkconfig --add mysql       #添加到sysV服务
[root@typecodes mysql]# chkconfig mysqld on

12 启动MySQL服务

同MySQL5.7.7rc，启动MySQL服务进程：

[root@typecodes mysql]# mysqld_safe --user=mysql --datadir=/mydata/mysql/data --log-error=/var/log/mysql/error.log &
[1] 10274
[root@typecodes mysql]# 150513 21:28:16 mysqld_safe Logging to '/var/log/mysql/error.log'.
150513 21:28:16 mysqld_safe Starting mysqld daemon with databases from /mydata/mysql/data

[root@typecodes mysql]# service mysqld start
Starting MySQL.[  OK  ]                 [启动成功]
[root@typecodes mysql]#

然后使用下面这命令ps -ef | grep mysql和netstat -tunpl | grep 3306查看MySQL服务进程和端口监听情况：

13 初始化MySQL数据库的root用户密码

MySQL5.6.24和MySQL5.7.7rc的用户密码策略是不同的，MySQL5.6.24没有提示用户密码的强度等级，所以也就不会去校验。因此，我们只需要一路输入y和自己喜欢的密码即可。

14 将MySQL数据库的动态链接库共享至系统链接库

同MySQL5.7.7rc，将MySQL5.6.24的lib库文件添加到当前Linux主机链接库/etc/ld.so.conf.d/下，方便其它程序安装调用。

[root@typecodes lib]# echo "/usr/local/mysql/lib" > /etc/ld.so.conf.d/mysql.conf
[root@typecodes lib]# ldconfig          [使生效]
[root@typecodes lib]# ldconfig -v |grep mysql       [查看效果]
ldconfig: Can't stat /libx32: No such file or directory
ldconfig: Path `/usr/lib' given more than once
ldconfig: Path `/usr/lib64' given more than once
ldconfig: Can't stat /usr/libx32: No such file or directory
/usr/lib64/mysql:
    libmysqlclient.so.18 -> libmysqlclient.so.18.0.0
    libmysqlclient.so.18 -> libmysqlclient_r.so.18.1.0
/usr/local/mysql/lib:
    libmysqlclient.so.18 -> libmysqlclient_r.so.18.1.0

15 创建其它MySQL数据库用户

操作同MySQL5.7.7rc，这里就不再演示了。

MySQL编译安装时常见错误分析

2015-06-23T19:20:00+08:00

这篇文章主要是关于MySQL在编译安装时，可能出现的错误的解决方法。MySQL正确的编译安装操作见前文《2015博客升级记(四)：CentOS 7.1编译安装MySQL5.7.7rc》。

1 没有安装MySQL所需要的boost库

测试发现编译MySQL5.7以及更高的版本时，都需要下载并引用或者直接安装boost库，否则在执行cmake命令时会报如下错误：

-- Running cmake version 3.2.1
-- Configuring with MAX_INDEXES = 64U
-- SIZEOF_VOIDP 8
-- MySQL 5.7.6-m16          [MySQL版本]
-- Packaging as: mysql-5.7.6-m16-Linux-x86_64
-- Looked for boost/version.hpp in  and 
-- BOOST_INCLUDE_DIR BOOST_INCLUDE_DIR-NOTFOUND
-- LOCAL_BOOST_DIR 
-- LOCAL_BOOST_ZIP 
-- Could not find (the correct version of) boost.       [关键错误信息]
-- MySQL currently requires boost_1_57_0                    [解决办法]

CMake Error at cmake/boost.cmake:76 (MESSAGE):          [具体错误和解决方法]
  You can download it with -DDOWNLOAD_BOOST=1 -DWITH_BOOST=<directory>

  This CMake script will look for boost in <directory>.  If it is not there,
  it will download and unpack it (in that directory) for you.

  If you are inside a firewall, you may need to use an http proxy:

  export http_proxy=http://example.com:80

Call Stack (most recent call first):
  cmake/boost.cmake:228 (COULD_NOT_FIND_BOOST)
  CMakeLists.txt:452 (INCLUDE)


-- Configuring incomplete, errors occurred!
See also "/mydata/mysql-5.7.6-m16/CMakeFiles/CMakeOutput.log".

解决方法：直接按照前文《2015博客升级记(四)：CentOS 7.1编译安装MySQL5.7.7rc》小节2中的方法安装Boost库即可。或者先下载Boost库，然后通过在cmake命令后面添加参数-DDOWNLOAD_BOOST=1 -DWITH_BOOST=Boost库路径即可。

2 执行cmake时缺少Ncurses库的支持

Ncurses提供功能键定义(快捷键)，屏幕绘制以及基于文本终端的图形互动功能的动态库。

[root@typecodes ~]# yum -y install ncurses-devel

-- Could NOT find Curses (missing:  CURSES_LIBRARY CURSES_INCLUDE_PATH) 
CMake Error at cmake/readline.cmake:64 (MESSAGE):
  Curses library not found.  Please install appropriate package,

      remove CMakeCache.txt and rerun cmake.On Debian/Ubuntu, package name is libncurses5-dev, on Redhat and derivates it is ncurses-devel.
Call Stack (most recent call first):
  cmake/readline.cmake:107 (FIND_CURSES)
  cmake/readline.cmake:181 (MYSQL_USE_BUNDLED_EDITLINE)
  CMakeLists.txt:480 (MYSQL_CHECK_EDITLINE)


-- Configuring incomplete, errors occurred!
See also "/mydata/mysql-5.7.6-m16/CMakeFiles/CMakeOutput.log".
See also "/mydata/mysql-5.7.6-m16/CMakeFiles/CMakeError.log".

解决方法：直接执行命令yum -y install ncurses-devel安装Ncurses即可。

3 安装MySQL完后，无法正常启动服务

在安装完MySQL后，执行命令service mysqld start失败，也即无法正常启动MySQL服务。

解决方法：主要通过命令systemctl status mysqld.service和MySQL的日志来分析。如上图所示，在日志文件/var/log/mysql/error.log中可以看到具体的ERROR信息：Could not create unix socket lock file /var/run/mysql/mysql.sock.lock。这种错误一般都是目录不存在或者权限不足，所以我们直接使用命令mkdir -p /var/log/mysql/创建该目录即可，然后可以设置目录权限chown -R mysql:mysql /var/log/mysql/。

4 操作MySQL时，报错You must SET PASSWORD before executing this statement

用MySQL的root用户登录数据库后，如果之前没有设置密码，那么执行任何操作命令时，会提示如下错误信息。

mysql> CREATE DATABASE `testmysqldatabase` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
ERROR 1820 (HY000): You must SET PASSWORD before executing this statement

常规的使用MySQL安全模式的解决方法如下，但是在MySQL5.7以及更高版本下是行不通的。

[root@typecodes ~]# service mysqld stop
Shutting down MySQL..[  OK  ]
[root@typecodes ~]# /mydata/mysql/bin/mysqld_safe --user=mysql --skip-networking --skip-grant-tables &
[1] 3688
[root@typecodes ~]# 150409 23:02:02 mysqld_safe Logging to '/var/log/mysql/error.log'.
150409 23:02:02 mysqld_safe Starting mysqld daemon with databases from /mydata/mysql/data
######重新登录mysql后，设置root密码
mysql> set password='this is a password sample';
ERROR 1290 (HY000): The MySQL server is running with the --skip-grant-tables option so it cannot execute this statement

有效的解决方法：

[root@typecodes ~]# mysql -u root -p            [使用root用户登录]
Enter password:                             [无密码，直接回车]
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 3
Server version: 5.7.6-m16

Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> select * from mysql.user;
ERROR 1820 (HY000): You must SET PASSWORD before executing this statement
mysql> set password='this is a password sample';
ERROR 1819 (HY000): Your password does not satisfy the current policy requirements
######设置当前root用户密码
mysql> set password='your password';
Query OK, 0 rows affected (0.00 sec)

mysql> flush privileges;
Query OK, 0 rows affected (0.00 sec)

需要说明的是，修改用户密码的SQL语句在不同的MySQL版本中是不同的。下面这3种是MySQL5.5以下的版本的修改方法，但是不适用于MySQL5.7以及更高版本。

mysql> update mysql.user set PASSWORD='your password' where User='root';

mysql> SET PASSWORD for root@'localhost' = PASSWORD('your password');

mysql> SET PASSWORD = PASSWORD('your password');

CentOS系统MySQL的配置文件my.cnf

2015-06-23T19:11:00+08:00

这篇文章主要内容是前文《2015博客升级记(四)：CentOS 7.1编译安装MySQL5.7.7rc》提到的MySQL的配置文件my.cnf。

需要注意的是my.cnf中的一些配置需要和MySQL5.7.7rc编译安装时的一些配置保持一致。例如，MySQL的socket文件/var/run/mysql/mysql.sock路径在MySQL5.7.7rc编译安装时，需要创建/var/run/mysql/文件路径。也就是my.cnf的配置是由编译MySQL时配置的内容决定的。

由于MySQL的配置明细不多，所以这里就直接将my.cnf的全部内容贴出来了。

# For advice on how to change settings please see
# http://dev.mysql.com/doc/refman/5.7/en/server-configuration-defaults.html
# *** DO NOT EDIT THIS FILE. It's a template which will be copied to the
# *** default location during install, and will be replaced if you
# *** upgrade to a newer version of MySQL.

[client]
port=3306
socket=/var/run/mysql/mysql.sock

[mysqld]

# Remove leading # and set to the amount of RAM for the most important data
# cache in MySQL. Start at 70% of total RAM for dedicated server, else 10%.
# innodb_buffer_pool_size = 128M

# Remove leading # to turn on a very important data integrity option: logging
# changes to the binary log between backups.
# log_bin

# These are commonly set, remove the # and set as required.
user = mysql
basedir = /usr/local/mysql
datadir = /mydata/mysql/data
port=3306
server-id = 1
socket=/var/run/mysql/mysql.sock

character-set-server = utf8
log-error = /var/log/mysql/error.log
pid-file = /var/log/mysql/mysql.pid
general_log = 1
skip-name-resolve
#skip-networking
back_log = 300

max_connections = 1000
max_connect_errors = 6000
open_files_limit = 65535
table_open_cache = 128 
max_allowed_packet = 4M
binlog_cache_size = 1M
max_heap_table_size = 8M
tmp_table_size = 16M

read_buffer_size = 2M
read_rnd_buffer_size = 8M
sort_buffer_size = 8M
join_buffer_size = 28M
key_buffer_size = 4M

thread_cache_size = 8

query_cache_type = 1
query_cache_size = 8M
query_cache_limit = 2M

ft_min_word_len = 4

log_bin = mysql-bin
binlog_format = mixed
expire_logs_days = 30


performance_schema = 0
explicit_defaults_for_timestamp

#lower_case_table_names = 1



myisam_sort_buffer_size = 8M
myisam_repair_threads = 1

interactive_timeout = 28800
wait_timeout = 28800


# Remove leading # to set options mainly useful for reporting servers.
# The server defaults are faster for transactions and fast SELECTs.
# Adjust sizes as needed, experiment to find the optimal values.
# join_buffer_size = 128M
# sort_buffer_size = 2M
# read_rnd_buffer_size = 2M

# Disabling symbolic-links is recommended to prevent assorted security risks
symbolic-links=0

# Recommended in standard MySQL setup
sql_mode=NO_ENGINE_SUBSTITUTION,NO_AUTO_CREATE_USER,STRICT_TRANS_TABLES

[mysqldump]
quick
max_allowed_packet = 16M

[myisamchk]
key_buffer_size = 8M
sort_buffer_size = 8M
read_buffer = 4M
write_buffer = 4M

和前文《2015博客升级记(六)：Nginx配置HTTPS和SPDY实战》的Nginx配置文件nginx.conf一样，这个MySQL的配置文件my.cnf也托管在下面这两个LNMP配置工程上，以后有任何的修改都会更新到这上面。

GitHub地址：https://github.com/vfhky/mylnmp ；

Coding地址：https://coding.net/u/vfhky/p/mylnmp/git 。

Nginx编译安装时常见错误分析

2015-06-22T17:02:00+08:00

这篇文章主要是关于Nginx在编译安装时，可能出现的错误的解决方法。Nginx正确的编译安装操作见前文《2015博客升级记(三)：CentOS 7.1编译安装Nginx1.9.0》。

1 Nginx启动脚本错误：env: /etc/init.d/nginx: No such file or directory

明明上传了Nginx服务控制脚本nginx，但是在执行service nginx start命令时，却会报上面的错误。

解决方法：启动脚本的格式有问题，例如该脚本是dos格式，在Linux系统是中无法识别的。可以通过vim打开该文件，如果可以看到出现^M的字符，就可以确定是DOS格式的了。那么可以在vim中执行命令:%s/\r\+$//e，将其转换成Unix格式即可。

2 启动Nginx服务失败

安装完Nginx后，执行命令service nginx start失败，即无法正常启动Nginx服务。

[root@typecodes init.d]# service nginx start
Starting nginx (via systemctl):  Warning: Unit file of nginx.service changed on disk, 'systemctl daemon-reload' recommended.
Job for nginx.service failed. See 'systemctl status nginx.service' and 'journalctl -xn' for details.
[FAILED]

解决方法：主要通过命令systemctl status nginx.service来分析，如下图所示。

很明显是由于下面这个错误，导致Nginx服务启动失败。

Apr 11 21:43:07 typecodes nginx[4026]: Starting nginx: nginx: [emerg] mkdir() "/var/tmp/nginx/client/" failed (2: No such file or directory)

这种错误一般都是目录不存在或者权限不足，所以直接执行下面两条命令即可。

[root@typecodes ~]# cd /var/tmp/
[root@typecodes ~]# mkdir -p /var/tmp/nginx/{client,proxy,fastcgi,uwsgi,scgi}

3 启动Nginx服务时，界面卡住

在敲入命令service nginx restart后，终端界面能卡住，也就是Nginx服务控制脚本nginx没有正常执行完毕。在停止Nginx服务后，发现Nginx进程还存在。

#######启动Nginx服务出现警告
[root@typecodes init.d]# service nginx restart 
Restarting nginx (via systemctl):  Warning: Unit file of nginx.service changed on disk, 'systemctl daemon-reload' recommended.
Restarting nginx (via systemctl):  Warning: Unit file of nginx.service changed on disk, 'systemctl daemon-reload' recommended.
^C     ######终端界面卡住，使用ctrl+c命令强制结束

#######停掉Nginx服务
[root@typecodes init.d]# service nginx stop
Stopping nginx (via systemctl):  [  OK  ]

#######查看Nginx进程是否已被停止（可以看到未停止）
[root@typecodes init.d]# ps -aux|grep nginx 
root      7796  0.0  0.2  84184  2044 ?        Ss   21:14   0:00 nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf
nginx     7798  0.0  0.3  86656  3380 ?        S    21:14   0:00 nginx: worker process
root      7981  0.0  0.0 112644   964 pts/0    S+   21:19   0:00 grep --color=auto nginx

解决方法：可能是Nginx服务控制脚本（/etc/init.d/nginx）代码不正确，推荐使用文章《Nginx服务启动、停止和重启等操作的SHELL脚本》中的shell脚本。最后再重新执行下面的脚本即可。

[root@typecodes init.d]# chkconfig --add nginx
[root@typecodes init.d]# chkconfig nginx on
[root@typecodes init.d]# service nginx restart

还有一种在启动Nginx服务时，终端界面会卡住的情况：那就是Nginx的配置文件/etc/nginx/nginx.conf不正确，但是使用nginx -t命令显示正常。这种情况只能对nginx.conf文件中的每一个配置进行检查了。

4 Compilation failed in require或者perl_parse() failed

在使用命令service nginx start启动Nginx服务时报错，于是通过systemctl status nginx.service查看具体的错误信息。

然后使用命令nginx -t查看配置是否正常，如下图所示，同样报错。

解决方法：从图中可以看出由于Can't load '/usr/local/lib64/perl5/auto/nginx/nginx.so' for module nginx: /usr/local/lib64/perl5/au...m line 68.的错误，导致了Nginx在调用函数时失败：perl_parse() failed。也就是证明是之前没有安装perl依赖包，于是通过执行命令yum -y install perl-devel perl-ExtUtils-Embed后，再次编译安装Nginx解决。

2015博客升级记(六)：Nginx配置HTTPS和SPDY实战

2015-06-21T22:39:00+08:00

这是《2015年博客升级记》系列文章的第六篇，主要记录如何在CentOS 7.1中Nginx如何配置HTTPS和SPDY。关于具体如何编译安装Nginx，可以查看文章《2015博客升级记(三)：CentOS 7.1编译安装Nginx1.9.0》。

1 重点：Nginx配置文件nginx.conf的具体内容

######
###  Description: The config file of Nginx with ssl, spdy, no-www redircting, gzip functions
###  Author:  vfhky  2015.05.05  https://typecodes.com/web/centos7nginxhttpsspdy.html
######
user  nginx nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

pid        /var/run/nginx/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    #隐藏Nginx版本信息，禁止网站目录浏览
    server_tokens off;
    autoindex off;
    #当FastCGI后端服务器处理请求给出http响应码为4xx和5xx时，就转发给nginx
    fastcgi_intercept_errors on;

    #关于fastcgi的配置
    fastcgi_connect_timeout 300;    
    fastcgi_send_timeout 300;    
    fastcgi_read_timeout 300;    
    fastcgi_buffer_size 64k;    
    fastcgi_buffers 4 64k;    
    fastcgi_busy_buffers_size 128k;    
    fastcgi_temp_file_write_size 128k;

    #支持gzip压缩
    gzip on;
    gzip_min_length 1k;
    gzip_buffers 16 64k;
    gzip_http_version 1.1;
    gzip_comp_level 6;
    gzip_types text/plain application/x-javascript text/css application/javascript text/javascript image/jpeg image/gif image/png application/xml application/json;
    gzip_vary on;
    gzip_disable "MSIE [1-6].(?!.*SV1)";

    #
    # 重定向所有带www请求到非www的请求
    #
    server {
        listen               *:80;
        listen               *:443 ssl spdy;
        server_name www.typecodes.com;
        # ssl证书配置见文章 https://typecodes.com/web/lnmppositivessl.html
        ssl_certificate /etc/nginx/ssl/typecodes.crt;
        # ssl密钥文件见文章 https://typecodes.com/web/lnmppositivessl.html
        ssl_certificate_key /etc/nginx/ssl/typecodes.key;
        # 不产生日志
        access_log off;

        # 访问favicon.ico和robots.txt不跳转（把这两个文件存放在上级目录html中）
        location ~* ^/(favicon.ico|robots.txt)$ {
            root html;
            expires max;
            log_not_found off;
            break;
        }

        location / {
            return 301 https://typecodes.com$request_uri;
        }
    }

    #
    # 将所有http请求重定向到https
    #
    server {
        listen               *:80;
        server_name          typecodes.com;
        # 不产生日志
        access_log off;

        # 访问favicon.ico和robots.txt不跳转（把这两个文件存放在上级目录html中）
        location ~* ^/(favicon.ico|robots.txt)$ {
            root html;
            expires max;
            log_not_found off;
            break;
        }

        location / {
            return 301 https://typecodes.com$request_uri;
        }
    }

    #
    # HTTPS server
    #
    server {
        listen               *:443 ssl spdy;
        server_name typecodes.com;

        # ssl证书配置见文章 https://typecodes.com/web/lnmppositivessl.html
        ssl_certificate /etc/nginx/ssl/typecodes.crt;
        # ssl密钥文件见文章 https://typecodes.com/web/lnmppositivessl.html
        ssl_certificate_key /etc/nginx/ssl/typecodes.key;
        ssl_session_cache shared:SSL:20m;
        ssl_session_timeout 10m;
        ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:AES:CAMELLIA:DES-CBC3-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!aECDH:!EDH-DSS-DES-CBC3-SHA:!EDH-RSA-DES-CBC3-SHA:!KRB5-DES-CBC3-SHA:!CAMELLIA;
        ssl_protocols TLSv1 TLSv1.1 TLSv1.2; #enables TLSv1, but not SSLv2, SSLv3 which is weak and should no longer be used.
        ssl_prefer_server_ciphers on;
        # 开启spdy功能
        add_header Alternate-Protocol 443:npn-spdy/3.1;
        # 严格的https访问
        add_header Strict-Transport-Security "max-age=31536000; includeSubdomains;";

        #设置网站根目录
        root   /usr/share/nginx/html/typecodes;
        index  index.php index.html;

        charset utf-8;

        #access_log  /var/log/nginx/log/host.access.log  main;

        #设置css/javascript/图片等静态资源的缓存时间
        location ~ .*\.(css|js|ico|png|gif|jpg|json|mp3|mp4|flv|swf)(.*) {
            expires 60d;
        }

        # include /etc/nginx/default.d/*.conf;
        # 设置typecho博客的config文章不被访问，保证安全
        location = /config.inc.php{
            deny  all;
        }

        # keep the uploads directory safe by excluding php, php5, html file accessing. Applying to wordpress and typecho.
        # location ~ .*/uploads/.*\.(php|php5|html)$ {
        #   deny  all;
        # }

        # 设置wordpress和typecho博客中，插件目录无法直接访问php或者html文件
        location ~ .*/plugins/.*\.(php|php5|html)$ {
            deny  all;
        }

        #Rewrite的伪静态(针对wordpress/typecho)，url地址去掉index.php
        location / {
            if (-f $request_filename/index.html){
                rewrite (.*) $1/index.html break;
            }
            if (-f $request_filename/index.php){
                rewrite (.*) $1/index.php;
            }
        if (!-f $request_filename){
                rewrite (.*) /index.php;
            }
        }

        #访问favicon.ico时不产生日志
        location = /favicon.ico {
            access_log off;
        }

        #设置40系列错误的应答文件为40x.html
        error_page  400 401 402 403 404  /40x.html;
        location = /40x.html {
                root   html;
                index  index.html index.htm;
        }

        #设置50系列错误的应答文件为50x.html
        #
        error_page   500 501 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
            index  index.html index.htm;
        }

        # proxy the PHP scripts to Apache listening on 127.0.0.1:80
        #
        #location ~ \.php$ {
        #    proxy_pass   http://127.0.0.1;
        #}

        # 设置Nginx和php通信机制为tcp的socket模式，而不是直接监听9000端口
        location  ~ .*\.php(\/.*)*$ {
             fastcgi_split_path_info ^(.+\.php)(/.+)$;
             #fastcgi_pass   127.0.0.1:9000;
             # the better form of fastcgi_pass than before
             fastcgi_pass   unix:/var/run/php-fpm/php-fpm.sock;
             fastcgi_index  index.php;
             fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;
             include        fastcgi_params;
        }

        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        #
        #location ~ /\.ht {
        #    deny  all;
        #}
    }
}

2 Nginx开启spdy功能

如下图所示，在chrome浏览器的地址栏中输入chrome://net-internals/#spdy抓取访问事件，然后新建一个页面打开自己的博客，这样就会被第一个页面抓取到了。

3 Nginx中url地址中，将带www的二级域名跳转到不带www顶级域名

博客目前将http访问全部定向到https，同时将https://www.typecodes.com重定向到https://typecodes.com上。前文《阿里云CentOS 6.5系统LNMP环境安装SSL证书》中，只做了http跳转到https。需要注意的是，在Nginx配置中最好不要包含过多的if判断语句；另外，处理不同的server_name时，官方建议写在多个server块中，就像小节1中的那样。

4 其他说明

由于LNMP配置比较繁琐，所以我建了一个关于Nginx、MySQL和PHP配置的git工程，方便查询。目前这个工程托管在GitHub和coding.net上，地址如下：

GitHub地址：https://github.com/vfhky/mylnmp ；

Coding地址：https://coding.net/u/vfhky/p/mylnmp/git 。

2015博客升级记(四)：CentOS 7.1编译安装MySQL5.7.7rc

2015-06-21T00:53:00+08:00

这是《2015年博客升级记》系列文章的第四篇，主要记录在Linux系统中如何编译安装MySql数据库。

1 创建mysql用户和用户组，并下载MySQL5.7.7 Release Candidate版本

首先创建一个名为mysql且没有登录权限的用户和一个名为mysql的用户组，然后去mysql官网下载MySQL5.7.7rc版本。

#######新建mysql用户和mysql组
[root@typecodes ~]# groupadd -r mysql && useradd -r -g mysql -s /bin/false -M mysql

######从官网或者博客备份地址下载MySQL5.7.7 Release Candidate版本
[root@typecodes ~]# wget -c http://cdn.mysql.com/Downloads/MySQL-5.7/mysql-5.7.7-rc.tar.gz
[root@typecodes ~]# wget -c http://git.typecodes.com/libs/mysql/mysql-5.7.7-rc.tar.gz
[root@typecodes ~]# md5sum mysql-5.7.7-rc.tar.gz        [MD5校验]
36a96021a93ca236e76f5c90ae19cd44  mysql-5.7.7-rc.tar.gz
######开始解压MySQL5.7.7
[root@typecodes ~]# tar -zxf mysql-5.7.7-rc.tar.gz && cd mysql-5.7.7-rc
######下载gmock：google的c++mock框架，从mysql 5.6开始支持
[root@typecodes mysql-5.7.7-rc]# wget -c http://git.typecodes.com/libs/ccpp/gmock-1.6.0.zip
######将其解压到MySQL5.7.7的source_downloads目录下
[root@typecodes mysql-5.7.7-rc]# unzip gmock-1.6.0.zip -d source_downloads

2 下载编译MySQL5.7.7rc时需要的工具

由于从MySQL5.5版本开始弃用了常规的configure编译方法，所以需要下载CMake编译器、Boost库、ncurses库和GNU分析器生成器bison这4种工具。经过自己的测试发现，MySQL5.7.7rc编译时所需要的Boost库只能是boost 1.57.0版本，低于或者高于这个版本的都会编译失败！

#######CMake编译工具
[root@typecodes ~]# wget -c http://git.typecodes.com/libs/ccpp/cmake-3.2.1.tar.gz
[root@typecodes ~]# tar -zxf cmake-3.2.1.tar.gz && cd cmake-3.2.1
[root@typecodes cmake-3.2.1]# ./configure 
[root@typecodes cmake-3.2.1]# make && make install  [默认安装路径是/usr/local/bin]
[root@typecodes cmake-3.2.1]# cmake --version       [查看cmake版本]
cmake version 3.2.1

CMake suite maintained and supported by Kitware (kitware.com/cmake).
[root@typecodes cmake-3.2.1]# cd ~ && rm -rf cmake-3.2.1*
######也可以直接yum安装CMake2.8.11版本
[root@typecodes ~]# yum -y install cmake

#######Ncurses：提供功能键定义(快捷键),屏幕绘制以及基于文本终端的图形互动功能的动态库。
[root@typecodes ~]# yum -y install ncurses-devel

#######bison：GNU分析器生成器
[root@typecodes ~]# wget -c http://git.typecodes.com/libs/ccpp/bison-3.0.tar.gz
[root@typecodes ~]# tar -zxf bison-3.0.tar.gz && cd bison-3.0/ && ./configure
[root@typecodes bison-3.0]# make && make install
[root@typecodes bison-3.0]# cd ~ && rm -rf bison-3.0*

#######Boost库：一个开源可移植的C++库，是C++标准化进程的开发引擎之一
[root@typecodes ~]# wget -c http://git.typecodes.com/libs/ccpp/boost_1_57_0.tar.bz2
[root@typecodes ~]# tar -jxf boost_1_57_0.tar.bz2 && cd boost_1_57_0/
[root@typecodes boost_1_57_0]# ./bootstrap.sh
[root@typecodes boost_1_57_0]# ./b2 stage threading=multi link=shared
[root@typecodes boost_1_57_0]# ./b2 install threading=multi link=shared
[root@typecodes boost_1_57_0]# cd ~ && rm -rf boost_1_57_0*

3 开始进行MySQL5.7.7rc编译前的配置

准备工作做好后，就开始正式配置MySQL5.7.7rc的安装明细了。注意，操作时一定要先把下面反斜杠“\”后面添加的注释文字去掉！！！

######使用cmake命令，开始编译MySQL5.7.7rc
[root@typecodes mysql-5.7.7-rc]# cmake \
-DCMAKE_INSTALL_PREFIX=/usr/local/mysql  \              [MySQL安装的根目录]
-DMYSQL_DATADIR=/mydata/mysql/data  \                   [MySQL数据库文件存放目录]
-DSYSCONFDIR=/etc \                                     [MySQL配置文件所在目录]
-DMYSQL_USER=mysql \                                    [MySQL用户名]      
-DWITH_MYISAM_STORAGE_ENGINE=1 \                        [MySQL的数据库引擎]
-DWITH_INNOBASE_STORAGE_ENGINE=1 \                      [MySQL的数据库引擎]
-DWITH_ARCHIVE_STORAGE_ENGINE=1 \                       [MySQL的数据库引擎]
-DWITH_MEMORY_STORAGE_ENGINE=1 \                        [MySQL的数据库引擎]
-DWITH_READLINE=1 \                                     [MySQL的readline library]
-DMYSQL_UNIX_ADDR=/var/run/mysql/mysql.sock \           [MySQL的通讯目录]
-DMYSQL_TCP_PORT=3306 \                                 [MySQL的监听端口]
-DENABLED_LOCAL_INFILE=1 \                              [启用加载本地数据]
-DENABLE_DOWNLOADS=1 \                                  [编译时允许自主下载相关文件]
-DWITH_PARTITION_STORAGE_ENGINE=1  \
-DEXTRA_CHARSETS=all \                                  [使MySQL支持所有的扩展字符]
-DDEFAULT_CHARSET=utf8 \                                [设置默认字符集为utf8]
-DDEFAULT_COLLATION=utf8_general_ci \                   [设置默认字符校对]
-DWITH_DEBUG=0 \                                        [禁用调试模式]
-DMYSQL_MAINTAINER_MODE=0 \
-DWITH_SSL:STRING=bundled \                             [通讯时支持ssl协议]
-DWITH_ZLIB:STRING=bundled                              [允许使用zlib library]

执行上面的配置命令的结果如下图所示：

4 开始编译和安装MySQL5.7.7rc

使用make命令编译时，会比较吃CPU。博主当时购买的阿里主机是单核1G内存，编译到55%左右时直接卡住，同时无法新建一个终端连接，内存或者CPU已经严重耗尽。在重新购买了一个物理数据盘并划分出一个swap交换空间后，最终还是编译成功了，耗时约4个小时。所以，如果主机内存在1G一下并且没有设置Linux交换空间的，不建议直接编译MySQL5.7.7rc！

[root@typecodes mysql-5.7.7-rc]# make && make install

下图展示的是make命令执行完毕的情况：

编译MySQL5.7.7rc对CPU和内存消耗比较大，这里截取了两张使用top命令的图片：

最后，激动人心的时刻，看到下图就代表已经编译安装好了MySQL5.7.7rc！

5 查看编译成功后的MySQL安装目录

使用命令查看MySQL的安装目录/usr/local/mysql/下面是否生成了相关目录文件（最重要的当然是bin、sbin和lib目录）。如果lib目录下面没有生成如图所示的.so动态库文件和.a静态库文件，那么说明安装不成功（即使成功了也可能会导致php进程无法找到mysql的相关库文件）。

6 开始设置MySQL的配置文件my.cnf

先把编译生成的my.cnf文件备份，然后把《CentOS系统MySQL的配置文件my.cnf》文中整理的MySQL的配置文件my.cnf上传到服务器的/etc/目录下即可。

[root@typecodes mysql]# mv /etc/my.cnf /etc/my.cnfbak
[root@typecodes mysql]# mv  ~/my.cnf  /etc/my.cnf

7 添加mysql的环境变量

将MySQL编译生成的bin目录添加到当前Linux系统的环境变量中

[root@typecodes mysql]# echo -e '\n\nexport PATH=/usr/local/mysql/bin:$PATH\n' >> /etc/profile && source /etc/profile

8 创建MySQL数据库文件的存放路径以及相关安全配置

在Linux主机上创建一个目录/mydata/mysql/data，用于存放MySQL的数据库文件。同时设置其用户和用户组为之前创建的mysql，权限为777。这样其它用户是无法进行读写的，尽量保证数据库的安全。

[root@typecodes ~]# mkdir -p /mydata/mysql/data && chown -R root:mysql /usr/local/mysql
[root@typecodes mysql]# chown -R mysql:mysql /mydata/mysql/data
[root@typecodes mysql]# chmod -R go-rwx /mydata/mysql/data

9 初始化MySQL自身的数据库

在MySQL安装目录的\bin\路径下，执行mysqld命令，初始化MySQL自身的数据库。

######参数user表示用户，basedir表示mysql的安装路径，datadir表示数据库文件存放路径
[root@typecodes bin]# mysqld --initialize-insecure --user=mysql --basedir=/usr/local/mysql --datadir=/mydata/mysql/data

执行完后，可以通过[root@typecodes mysql]# ls -lrt /mydata/mysql/data/命令查看是否生成了MySQL自身的数据库文件。

10 创建MySQL日志存放目录以及设置开机启动

下面配置的MySQL日志存放目录以及权限都是根据前面my.cnf文件写的，也就是两者需要保持一致。

[root@typecodes ~]# mkdir -p /var/run/mysql && mkdir -p /var/log/mysql
[root@typecodes ~]# chown -R mysql:mysql /var/log/mysql && chown -R mysql:mysql /var/run/mysql
######配置开机自启动
[root@typecodes mysql]# cp /usr/local/mysql/support-files/mysql.server  /etc/init.d/mysqld
[root@typecodes mysql]# chmod +x /etc/init.d/mysqld     #增加可执行权限
[root@typecodes mysql]# chkconfig --add mysqld      #添加到sysV服务
[root@typecodes mysql]# chkconfig mysqld on

11 启动MySQL服务

在完成上面的操作后，就可以正式使用MySQL服务了。启动MySQL进程服务的命令如下：

[root@typecodes mysql]# mysqld_safe --user=mysql --datadir=/mydata/mysql/data --log-error=/var/log/mysql/error.log &        [直接回车]
[1] 10274
150513 21:28:16 mysqld_safe Logging to '/var/log/mysql/error.log'.
150513 21:28:16 mysqld_safe Starting mysqld daemon with databases from /mydata/mysql/data

######上面这条命令会在后台继续执行，所以直接回车并执行下面这条命令
[root@typecodes mysql]# service mysqld start
Starting MySQL.[  OK  ]                 [启动成功]
[root@typecodes mysql]#

然后使用下面这命令ps -ef | grep mysql和netstat -tunpl | grep 3306查看MySQL服务进程和端口监听情况：

12 初始化MySQL数据库的root用户密码

和Oracle数据库一样，MySQL数据库也默认自带了一个root用户（这个和当前Linux主机上的root用户是完全不搭边的），我们在设置好MySQL数据库的安全配置后初始化root用户的密码。配置过程中，一路输入y就行了。这里只说明下MySQL5.7.7rc版本中，用户密码策略分成低级LOW、中等MEDIUM和超强STRONG三种，推荐使用中等MEDIUM级别！

[root@typecodes mysql]# mysql_secure_installation
............省略前面的过程............
Press y|Y for Yes, any other key for No: y   【需要修改密码，所以输入y】

There are three levels of password validation policy:

LOW    Length >= 8     【只需要长度大于或等于8】
MEDIUM Length >= 8, numeric, mixed case, and special characters   【还需要包含数字、大小写和类似于@#%等特殊字符】
STRONG Length >= 8, numeric, mixed case, special characters and dictionary                  file    【还需要包含字典文件】
............省略剩下的过程............

13 将MySQL数据库的动态链接库共享至系统链接库

一般MySQL数据库还会被类似于PHP等服务调用，所以我们需要将MySQL编译后的lib库文件添加至当前Linux主机链接库/etc/ld.so.conf.d/下，这样MySQL服务就可以被其它服务调用了。

[root@typecodes lib]# echo "/usr/local/mysql/lib" > /etc/ld.so.conf.d/mysql.conf
[root@typecodes lib]# ldconfig          [使生效]
[root@typecodes lib]# ldconfig -v |grep mysql       [查看效果]
ldconfig: Can't stat /libx32: No such file or directory
ldconfig: Path `/usr/lib' given more than once
ldconfig: Path `/usr/lib64' given more than once
ldconfig: Can't stat /usr/libx32: No such file or directory
/usr/lib64/mysql:
        libmysqlclient.so.18 -> libmysqlclient.so.18.0.0
/usr/local/mysql/lib:
        libmysqlclient.so.20 -> libmysqlclient_r.so.20.0.0

14 创建其它MySQL数据库用户

使用MySQL数据库root管理员用户登录MySQL数据库后，可以管理数据库和其他用户了。这里演示创建一个名为typecodes的MySQL用户（密码为@typecodes2014.com）和一个名为typecodes的数据库。

[root@typecodes mysql]# mysql -uroot -p密码

######登录成功后，创建typecodes数据库，并设置字符集和字符校
mysql> CREATE DATABASE `typecodes` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
Query OK, 1 row affected (0.00 sec)

######创建名为typecodes用户，并让它拥有typecodes数据库所有的权限
mysql> grant all privileges on typecodes.* to typecodes@localhost identified by '@typecodes2014.com';
Query OK, 0 rows affected, 1 warning (0.01 sec)

mysql> flush privileges;
Query OK, 0 rows affected (0.00 sec)

mysql> exit;            [创建完毕，root用户退出]

15 错误分析

这里特意分析了一些MySQL安装过程中可能出现的错误情况，详见文章《MySQL编译安装时常见错误分析》。

CentOS开启coredump转储并生成core文件的配置

2015-06-11T21:47:00+08:00

在CentOS或者suse等Linux系统中默认是关闭coredump核心转储的，也就不会产生core文件。由于在C/C++开发中会用到gdb调试，所以需要开启coredump功能。下面是具体的配置命令，可以保存为一个简单的shell脚本执行。

#!/bin/bash

### Filename: coredumpshell.sh
### Description: enable coredump and format the name of core file on centos system

# enable coredump whith unlimited file-size for all users
echo -e "\n# enable coredump whith unlimited file-size for all users\n* soft core unlimited" >> /etc/security/limits.conf

# set the path of core file with permission 777 
cd /mydata && mkdir corefile && chmod 777 corefile

# format the name of core file.   
# %% – 符号%
# %p – 进程号
# %u – 进程用户id
# %g – 进程用户组id
# %s – 生成core文件时收到的信号
# %t – 生成core文件的时间戳(seconds since 0:00h, 1 Jan 1970)
# %h – 主机名
# %e – 程序文件名
echo -e "/mydata/corefile/core-%e-%s-%u-%g-%p-%t" > /proc/sys/kernel/core_pattern

# for centos7 system(update 2017.2.3 21:44)
echo -e "/mydata/corefile/core-%e-%s-%u-%g-%p-%t" > /etc/sysctl.conf

# suffix of the core file name
echo -e "1" > /proc/sys/kernel/core_uses_pid

在Linux终端上执行完上面的脚本后，退出并重新登录即可生效。可以通过[root@typecodes ~]# ulimit -a命令查看效果，如下图所示：

最后，写了一个简单C程序测试CentOS是否生成了相应的core文件。

[root@typecodes test]# vim test.c 
#include <stdio.h>
int main( int argc, char * argv[] )
{
    char a[1];
    scanf( "%s", a );
    return 0;
}

使用命令gcc test.c -o test编译后执行，然后故意输入错误的数据，让进程报错。这时，在/mydata/corefile/目录就生成了相应的core文件core-test-11-0-0-27124-1434029850。

update 2017.2.3 21:44

每次重启CentOS7后，由于proc目录是动态更新的，所以系统会初始化core_pattern的值。如果想永久设置coredump文件为上面的格式，那么需要使用编辑文件 /etc/sysctl.conf ，加入kernel.core_pattern=/mydata/corefile/core-%e-%s-%u-%g-%p-%t，然后使用命令sysctl -p /etc/sysctl.conf重新加载。

#!/bin/bash

### Filename: coredumpshell.sh
### Description: enable coredump and format the name of core file on centos system

# enable coredump whith unlimited file-size for all users
echo -e "\n# enable coredump whith unlimited file-size for all users\n* soft core unlimited" >> /etc/security/limits.conf

# format the name of core file.   
# %% – 符号%
# %p – 进程号
# %u – 进程用户id
# %g – 进程用户组id
# %s – 生成core文件时收到的信号
# %t – 生成core文件的时间戳(seconds since 0:00h, 1 Jan 1970)
# %h – 主机名
# %e – 程序文件名    
# for centos7 system(update 2017.4.2 21:44)
echo -e "\nkernel.core_pattern=/mydata/corefile/core-%e-%s-%u-%g-%p-%t" >> /etc/sysctl.conf

# suffix of the core file name
echo -e "1" > /proc/sys/kernel/core_uses_pid

sysctl -p /etc/sysctl.conf

Typecho评论邮件通知插件中使用腾讯企业邮箱SSL功能

2015-06-06T19:45:00+08:00

前段时间，在查看博客绑定的腾讯企业邮箱时，发现POP3/SMTP协议支持SSL。由于正好使用了Typecho版的CommentToMail评论邮件通知插件，就顺便也升级成SSL协议。

整个配置过程很简单，SMTP填写腾讯企业邮箱的发送服务器地址：smtp.exmail.qq.com，同时把之前是25的SMTP端口改成腾讯企业邮箱支持SSL协议的465端口，最后勾选上ssl加密选项即可，附图如下：

Nginx服务启动、停止和重启等操作的SHELL脚本

2015-06-06T13:42:00+08:00

由于使用源码编译安装Nginx，不会像yum install那样自动生成Nginx服务控制脚本，所以需要自己添加一个操作脚本。谷歌上搜了一下，shell脚本的代码基本类似，因此自己稍微整理改动了下。

下面的shell脚本内容，需要根据Nginx实际编译安装的配置，修改NGINX_CONF_FILE="/etc/nginx/nginx.conf"和lockfile=/var/lock/nginx.lock这两个参数（即前文《2015博客升级记(三)：CentOS 7.1编译安装Nginx1.9.0》中的configure配置）。

#! /bin/bash
#
# nginx - this script starts and stops the nginx daemon
#
# chkconfig:   - 85 15
# description:  Nginx is an HTTP(S) server, HTTP(S) reverse \
#               proxy and IMAP/POP3 proxy server
#
# processname: nginx
# config:      /etc/nginx/nginx.conf
# pidfile:     /var/run/nginx/nginx.pid

# Source function library.
. /etc/rc.d/init.d/functions

# Source networking configuration.
. /etc/sysconfig/network

# Check that networking is up.
[ "$NETWORKING" = "no" ] && exit 0

nginx="/usr/sbin/nginx"
prog=$(basename $nginx)

NGINX_CONF_FILE="/etc/nginx/nginx.conf"

[ -f /etc/sysconfig/nginx ] && . /etc/sysconfig/nginx

lockfile=/var/lock/nginx.lock

start() {
    [ -x $nginx ] || exit 5
    [ -f $NGINX_CONF_FILE ] || exit 6
    echo -n $"Starting $prog: "
    daemon $nginx -c $NGINX_CONF_FILE
    retval=$?
    echo
    [ $retval -eq 0 ] && touch $lockfile
    return $retval
}

stop() {
    echo -n $"Stopping $prog: "
    killproc $prog -QUIT
    retval=$?
    echo
    [ $retval -eq 0 ] && rm -f $lockfile
    return $retval
}

restart() {
    configtest || return $?
    stop
    sleep 1
    start
}

reload() {
    configtest || return $?
    echo -n $"Reloading $prog: "
    killproc $nginx -HUP
    RETVAL=$?
    echo
}

force_reload() {
    restart
}

configtest() {
  $nginx -t -c $NGINX_CONF_FILE
}

rh_status() {
    status $prog
}

rh_status_q() {
    rh_status >/dev/null 2>&1
}

case "$1" in
    start)
        rh_status_q && exit 0
        $1
        ;;
    stop)
        rh_status_q || exit 0
        $1
        ;;
    restart|configtest)
        $1
        ;;
    reload)
        rh_status_q || exit 7
        $1
        ;;
    force-reload)
        force_reload
        ;;
    status)
        rh_status
        ;;
    condrestart|try-restart)
        rh_status_q || exit 0
            ;;
    *)
        echo $"Usage: $0 {start|stop|status|restart|condrestart|try-restart|reload|force-reload|configtest}"
        exit 2
esac

将上面的shell脚本内容以Unix格式(不能用dos哦)保存并命名为nginx，然后上传到centos系统的/etc/init.d/目录，接着添加可执行权限，最后执行添加到开机启动的命令：chkconfig --add nginx、chkconfig nginx on即可。

最后，我们可以使用如下命令对Nginx服务进行操作：

######启动Nginx服务
[root@typecodes ~]# service nginx start
######停止Nginx服务
[root@typecodes ~]# service nginx stop
######重启Nginx服务
[root@typecodes ~]# service nginx restart
######Nginx服务的状态
[root@typecodes ~]# service nginx status
######在Nginx服务启动的状态下，重新加载nginx.conf这个配置文件
[root@typecodes ~]# service nginx reload

update 2017.03.22 17:22

看到很多网站引用了本篇文章，由于这一年多的时间相关启动脚本和配置文件可能存在一些优化更新。当时在写这篇文章的时候也忘了说明这些关于Nginx和MySQL以及PHP7的启动脚本和配置文件的维护都托管在GitHub上了，所以请大家参考GitHub上最新的项目代码，地址如下：https://github.com/vfhky/mylnmp。

2015博客升级记(三)：CentOS 7.1编译安装Nginx1.9.0

2015-06-03T16:06:00+08:00

这是《2015年博客升级记》系列文章的第三篇，主要记录如何在CentOS 7.1中编译安装Nginx官方最新的1.9.0版本。由于像Nginx、Mysql和PHP7的的源码都是用C/C++写的，所以自己的CentOS 7.1服务器上必须要安装gcc和g++软件（CentOS 7系列会自带这两个编译软件）。

1 依赖库配置，编译和安装Nginx1.9.0

先创建一个名为nginx且没有登录权限的用户和一个名为nginx的用户组，然后安装nginx所需的依赖库和依赖包，最后通过.configure进行安装的详细配置。另外，补录一个pcre的tar包备份地址：https://cdn.typecodes.com/libs/nginx/pcre-8.36.tar.gz，以及一个zlib的tar包备份地址：https://cdn.typecodes.com/libs/nginx/zlib-1.2.8.tar.gz。

#######新建nginx用户和nginx组
[root@typecodes ~]# groupadd -r nginx && useradd -r -g nginx -s /bin/false -M nginx
#######yum安装nginx必须的依赖库
[root@typecodes ~]# yum -y install openssl openssl-devel libxml2-devel libxslt-devel perl-devel perl-ExtUtils-Embed

#######官网下载Nginx1.9.0的tar包，然后解压到服务器上
[root@typecodes ~]# wget -c http://nginx.org/download/nginx-1.9.0.tar.gz
[root@typecodes ~]# tar -zxf nginx-1.9.0.tar.gz && cd nginx-1.9.0

#######下载pcre的tar包并解压，以便支持Nginx的Rewrite功能
[root@typecodes nginx-1.9.0]# wget -c http://git.typecodes.com/libs/php/pcre-8.36.tar.gz && tar -zxf pcre-8.36.tar.gz
#######下载zlib的tar包并解压，以便支持Nginx的Gzip压缩功能
[root@typecodes nginx-1.9.0]# wget -c http://git.typecodes.com/libs/nginx/zlib-1.2.8.tar.gz
[root@typecodes nginx-1.9.0]# tar -zxf zlib-1.2.8.tar.gz

#######新建Nginx1.9.0安装时所需要的目录
[root@typecodes nginx-1.9.0]# cd /var/tmp/ && mkdir -p /var/tmp/nginx/{client,proxy,fastcgi,uwsgi,scgi}
[root@typecodes tmp]# mkdir -p /var/run/nginx && cd ~/nginx-1.9.0

准备工作做好后，就开始正式配置Nginx-1.9.0的安装明细了。注意，在使用下面这条configure参数配置时，一定要先把反斜杠“\”后面添加的注释文字去掉！！！

[root@typecodes nginx-1.9.0]# ./configure \
--prefix=/usr/share/nginx \                     [Nginx安装目录]
--sbin-path=/usr/sbin/nginx \                   [Nginx的sbin目录]
--conf-path=/etc/nginx/nginx.conf \             [Nginx的配置文件]
--error-log-path=/var/log/nginx/error.log \     [Nginx的错误日志]
--http-log-path=/var/log/nginx/access.log \     [Nginx的访问日志]
--pid-path=/var/run/nginx/nginx.pid  \          [Nginx的进程ID]
--lock-path=/var/lock/nginx.lock \
--user=nginx \                          [Nginx所属用户]
--group=nginx \                         [Nginx所属用户组]
--with-http_ssl_module \                    [Nginx的ssl模块]
--with-http_spdy_module \               [Nginx的Google spdy模块]
--with-http_dav_module \
--with-http_flv_module \
--with-http_realip_module \
--with-http_addition_module \
--with-http_xslt_module \
--with-http_stub_status_module \
--with-http_sub_module \
--with-http_random_index_module \
--with-http_degradation_module \
--with-http_secure_link_module \
--with-http_gzip_static_module \            [Nginx的gzip压缩模块]
--with-http_perl_module \
--with-pcre=pcre-8.36 \                 [pcre的安装目录]
--with-zlib=zlib-1.2.8 \                    [pcre的安装目录]
--with-debug \                          [允许DEBUG]
--with-file-aio \
--with-mail \
--with-mail_ssl_module \
--http-client-body-temp-path=/var/tmp/nginx/client_body \
--http-proxy-temp-path=/var/tmp/nginx/proxy \
--http-fastcgi-temp-path=/var/tmp/nginx/fastcgi \
--http-uwsgi-temp-path=/var/tmp/nginx/uwsgi \
--http-scgi-temp-path=/var/tmp/nginx/scgi \
--with-stream \                         [Nginx1.9.0特有的stream模块]
--with-ld-opt="-Wl,-E"                  [gcc的编译优化]

配置过程大概需要5分钟左右，部分截图如下：

2 配置完后，就可以直接编译和安装了

最后，直接使用执行这条命令[root@typecodes nginx-1.9.0]# make && make install进行安装即可。其中，make命令和make install命令的执行结果附图如下：

3 配置Nginx1.9.0，使之正常工作

成功安装Nginx1.9.0后，我们需要进行一些配置，包括开机启动、SSL/HTTPS服务等。其中，Nginx服务控制脚本nginx见文章《Nginx服务启动、停止和重启等操作的SHELL脚本》。

#######上传Nginx服务控制脚本nginx，并赋予执行权限，删除安装包，添加Nginx服务到开机启动
[root@typecodes ~]# mv ~/nginx /etc/init.d/nginx && chmod +x /etc/init.d/nginx
[root@typecodes ~]# rm -rf nginx-1.9.0*
[root@typecodes ~]# chkconfig --add nginx
[root@typecodes ~]# chkconfig nginx on

由于博客准备全站启用https服务，所以直接将前文《阿里云CentOS 6.5系统LNMP环境安装SSL证书》中产生的私钥typecodes.key和证书文件typecodes_last.crt打包的ssl.tar.gz上传到服务器使用。而Nginx配置文件nginx.conf见文章《2015博客升级记(六)：Nginx配置HTTPS和SPDY实战》。

#######上传ssl文件和Nginx配置文件nginx.conf
[root@typecodes ~]# mkdir -p /etc/nginx/ssl && tar -zxf ~/ssl.tar.gz -C /etc/nginx/ssl
[root@typecodes ~]# cd /etc/nginx/ && tar -zcf etc.nginx.tar.gz ./
[root@typecodes ~]# rm -rf ~/ssl.tar.gz 
[root@typecodes ~]# mv ~/nginx.conf /etc/nginx
mv: overwrite ‘/etc/nginx/nginx.conf’? y

#######测试配置是否正常
root@typecodes ~]# nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

#######新建Nginx进程日志nginx.pid目录，并启动服务
[root@typecodes ~]# mkdir -p /var/run/nginx/
[root@typecodes ~]# service nginx start
Restarting nginx (via systemctl):  [  OK  ]

最后使用命令[root@typecodes nginx]# nginx -V查看Nginx1.9.0的详细信息。

4 错误分析

这里特意分析了一些Nginx安装过程中可能出现的错误情况，详见文章《Nginx编译安装时常见错误分析》。

Typecho评论中开启和使用Markdown的方法

2015-05-31T18:20:00+08:00

轻量级的博客程序Typecho，还有一个很舒适的体验，那就是支持Markdown语法，不论是在文章或是评论中。这篇文章主要是说明如何在博客中使用Markdown写作以及如何在评论中使用Markdown语法。

1 Typecho博客评论中开启Markdown功能

在Typecho中，如何在写评论的时候也能像写文章那样，使用Markdown语法？我们只需要在Typecho的后台分两个步骤即可开启这个功能。

首先进入Typecho博客的后台管理界面，然后鼠标滑到左上角菜单栏上的设置，接着点击评论进入到评论设置界面。如下图所示，需要勾选上在评论中使用 Markdown 语法。同时，我们还需要在允许使用的HTML标签和属性栏目中填写上Typecho将Markdown转换后的HTML标签。

博客目前使用的是如图所示的下面这个配置，大家可以根据需要进行加减。

<blockquote><pre><code><strong><em><h5><h6><a href title><table><thead><tr><th><tbody><td>

其中，code标签作用是高亮某个单词或词组；<a href>标签作用是允许评论文字附带超链接，而如果这个链接上还要有文字提示信息，那么就需要改成<a href title>标签；剩余的<table>标签作用是允许表格。

2 如何在评论中使用Markdown语法

由于Typecho程序使用的是PHP Markdown Lib库，自然也遵循Markdown基本语法。所以，在写评论的时候，直接使用Markdown的基本语法即可。下面是在写文章或者评论时，一些经常会用到的Markdown演示。

2.1 高亮某个词组

使用两个反引号把要高亮的词组包含起来，例如`echo "Hello"`即可，结果如图所示。

2.2 插入代码

在评论中插入代码，只需要在代码中的每一行的开头增加4个空格即可，效果如下图所示。

2.3 将文字加上超链接

这个功能不是用来发广告链接的哟！开个玩笑，我们只需要使用Markdown的超链接标签即可。例如，[欢迎来到我的博客](https://typecodes.com "TypeCodes")。

2.4 插入表格

在评论中插入表格，当然这个功能基本不会用到吧。在文章中使用Markdown语法展示表格的效果如下图所示：

那么在评论中要用Markdown展示表格的话，方法也是一样的。例如使用下面这段格式，就可以用表格的形式展示出来了。

Lang| Start | IDE| Inheritance
----|------|----
Java | 1995  | Eclipse | Yes
C | 1972  | CodeBlocks | No
C++ | 1983 | Visual Studio | Yes
Python | 1989 | Eclipse | Yes
C#| 2000 | Visual Studio | Yes

3 总结

小节2中只是展示了Markdown的部分基本语法如何在Typecho写文章或者评论中应用，更多的语法可以参考这篇文章。最后需要说明的是：Typecho将Markdown转换成普通html标签后，我们可以修改对应的CSS样式，大家可以尽情发挥。

视角：C语言将十六进制字符串转成十进制整数

2015-05-30T07:58:00+08:00

在前文《再议C语言将十六进制字符串转成十进制整数》中 @大致童鞋帮忙提了一个思路：直接将指针p读取的十六进制字符串中的单个字符转换后的结果保存在iResult中，而不是保存在指针p指向的内存中。这样思路更为简洁，下面是具体的两个实现程序。

1 从高位到低位单个字符转换

正向转换时，提前判断出字符串中部分非法字符，然后根据+、-、0x、0X这四个特殊字符(串)对指针变量p进行特殊处理。

#include <stdio.h>
#include <string.h>

/**
 * @FileName  HexStr2Integer.c
 * @author    vfhky 2015.05.30 https://typecodes.com/cseries/simplifychexstrtoint.html
 * @param     [in]HexStr 十六进制字符串（例如"eE2"、"Fa1"、"2011"、"-eE2"、"+eE2"等） 
 * @return    -1:字符串为空; -2:字符串中包含非十六进制的字符; 其它:转换后的十进制整数
 */
int HexStr2Integer( char * HexStr )
{
    int iResult = 0, iFlag = 1;

    //判断字符串是否合法
    if( NULL == HexStr || ( *HexStr == '+' && *(HexStr+1) == '\0' ) || ( *HexStr == '-' && *(HexStr+1) == '\0' ) 
        || ( *HexStr == 0x30 && *(HexStr+1) == 0x58 && *(HexStr+2) == '\0' )
        || ( *HexStr == 0x30 && *(HexStr+1) == 0x78 && *(HexStr+2) == '\0' ) )
    {
        return -1;
    }

    //指针变量p指向字符串的首位
    char * p = HexStr;

    //对以"+"、"-"号开头的十六进制字符串的处理
    if ( '-' == *p || '+' == *p )
    {
        if( *p == '-' )
            iFlag = -1;
        ++p;
    }
    //对"0x"或者"0X"开头的十六进制字符的处理
    else if( ( *p == 0x30 && *(p+1) == 0x58 ) || ( *p == 0x30 && *(p+1) == 0x78 ) )
    {
        p += 2;
    }

    while( *p != '\0' )
    {
        if ( *p >= 48 && *p <= 57 )
            iResult = ( *p - 48 )+ ( iResult<<4 );
        else if ( *p >= 65 && *p <= 70 )
            iResult = ( *p - 65 + 10 )+ ( iResult<<4 );
        else if ( *p >= 97 && *p <= 102 )
            iResult = ( *p - 97 + 10 )+ ( iResult<<4 );
        else
            return -2;

        ++p;
    }
    return iFlag*iResult;
}

int main( int argc, char * argv[] )
{
    char cHexString[200+1];
    while(1)
    {
        memset( cHexString, 0x00, sizeof(cHexString) );
        printf( "Please input a HexString with length less than 200:\n" );
        scanf( "%s", cHexString );
        printf( "---->[%d]\n", HexStr2Integer(cHexString) );
    }
    return 0;
}

同样使用GCC编译命令gcc HexStr2Integer.c -o HexStr2Integer，然后输入测试用的十六进制的字符串"eE2"、"Fa1"、"2011"、"-eE2"、"+eE2"分别转换成了对应的十进制整数：3810、4001、8209、-3810、3810。

2 从低位到高位单个字符转换

逆向转换时，需要注意while循环中通过对+、-、0x、0X这四个特殊字符(串)的判断出非法字符。

#include <stdio.h>
#include <string.h>

/**
 * @FileName  HexStr2Integer2.c
 * @author    vfhky 2015.05.30 https://typecodes.com/cseries/simplifychexstrtoint.html
 * @param     [in]HexStr 十六进制字符串（例如"eE2"、"Fa1"、"2011"、"-eE2"、"+eE2"等） 
 * @return    -1:字符串为空; -2:字符串中包含非十六进制的字符; 其它:转换后的十进制整数
 */
int HexStr2Integer2( char * HexStr )
{
    int iResult = 0, iCycle = 1, iFlag = 1;

    //判断字符串是否合法
    if( !strlen( HexStr ) )
    {
        return -1;
    }

    //指针变量p指向字符串的末尾
    char * p = HexStr + strlen( HexStr );

    while( (--p+1) != HexStr )
    {
        if ( *p >= '0' && *p <= '9' )
            iResult += ( *p - '0' )*iCycle;
        else if ( *p >= 'A' && *p <= 'F' )
            iResult += ( *p - 'A' + 10 )*iCycle;
        else if ( *p >= 'a' && *p <= 'f' )
            iResult += ( *p - 'a' + 10 )*iCycle;
        else if ( ( '+' == *p && ( p == HexStr + 1 ) )
            || ( 'x' == *p && '0' == *( p - 1 ) && ( p == HexStr + 1 ) ) 
            || ( 'X' == *p && '0' == *( p - 1 ) && ( p == HexStr + 1 ) ) )
            break;
        else if ( '-' == *p && p == HexStr )
            iFlag = -1;
        else
            return -2;

        iCycle <<= 4;
    }
    return iFlag*iResult;
}

int main( int argc, char * argv[] )
{
    char cHexString[200+1];
    while(1)
    {
        memset( cHexString, 0x00, sizeof(cHexString) );
        printf( "Please input a HexString with length less than 200:\n" );
        scanf( "%s", cHexString );
        printf( "---->[%d]\n", HexStr2Integer2(cHexString) );
    }
    return 0;
}

同样，使用GCC编译后，输入十六进制字符串数据进行测试，结果如下图所示：