第一次拍星轨

第一次拍星轨,大约半个小时的时间,使用Sony A7的星轨插件拍摄,50张合成,效果略显粗糙,不过作为第一次尝试,也算是没有白白挨冻了。

22535600

2017-02-13 20_14_55

MySQL之ROUND函数四舍五入的陷阱

在MySQL中,ROUND函数用于对查询结果进行四舍五入,不过最近使用ROUND函数四舍五入时意外发现并没有预期的那样,本文将这一问题记录下来,以免大家跟我一样犯同样的错误。

问题描述

假如我们有如下一个数据表test,建表语句如下

CREATE TABLE test (
  id int(11) NOT NULL AUTO_INCREMENT,
  field1 bigint(10) DEFAULT NULL,
  field2 decimal(10,0) DEFAULT NULL,
  field3 int(10) DEFAULT NULL,
  field4 float(15,4) DEFAULT NULL,
  field5 float(15,4) DEFAULT NULL,
  field6 float(15,4) DEFAULT NULL,
  PRIMARY KEY (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

我们创建了一个名为test的表,出了id字段之外还包含了多个字段,拥有这不同的数据类型。我们向这个表中插入一条数据

INSERT INTO test (field1, field2, field3, field4, field5, field6) VALUE (100, 100, 100, 1.005, 3.5, 2.5);

插入之后表中的数据是这样的

mysql> select * from test;
+----+--------+--------+--------+--------+--------+--------+
| id | field1 | field2 | field3 | field4 | field5 | field6 |
+----+--------+--------+--------+--------+--------+--------+
|  1 |    100 |    100 |    100 | 1.0050 | 3.5000 | 2.5000 |
+----+--------+--------+--------+--------+--------+--------+
1 row in set (0.00 sec)

如果现在我们执行下面这个SQL,你觉得结果会是什么样的呢?

SELECT
  round(field1 * field4),
  round(field2 * field4),
  round(field3 * field4),
  round(field1 * 1.005),
  round(field2 * 1.005),
  round(field3 * 1.005),
  round(field5),
  round(field6)
FROM test;

最初一直以为这样的结果肯定是都是101,因为上面这六个取值结果都是对100 * 1.005进行四舍五入,结果肯定都是101才对,而后面两个肯定是43才对,但是最终的结果却是与设想的大相径庭

*************************** 1. row ***************************
round(field1 * field4): 100
round(field2 * field4): 100
round(field3 * field4): 100
 round(field1 * 1.005): 101
 round(field2 * 1.005): 101
 round(field3 * 1.005): 101
         round(field5): 4
         round(field6): 2
1 row in set (0.00 sec)

为什么会这样?

同样是100*1.005,为什么从数据库中的字段相乘得到的结果和直接字段与小数相乘得到的不一样呢?

对这个问题百思不得其解,各种百度谷歌无果。。。没办法,还得靠自己,这个时候最有用的就是官网文档了,于是查询了mysql官方文档中关于ROUND函数的部分,其中包含下面两条规则

  • For exact-value numbers, ROUND() uses the “round half up” rule(对于精确的数值,ROUND函数使用四舍五入)
  • For approximate-value numbers, the result depends on the C library. On many systems, this means that ROUND() uses the “round to nearest even” rule: A value with any fractional part is rounded to the nearest even integer. (对于近似值,则依赖于底层的C函数库,在很多系统中ROUND函数会使用“取最近的偶数”的规则)

通过这两条规则,我们可以看出,由于我们在使用两个字段相乘的时候,最终的结果是按照float类型处理的,而在计算机中float类型不是精确的数,因此处理结果会按照第二条来,而直接整数字段与1.005这样的小数运算的结果是因为两个参与运算的值都是精确数,因此按照第一条规则计算。从field5field6执行ROUND函数的结果可以明确的看确实是转换为了最近的偶数。

总结

从这个例子中可以看到,在MySQL中使用ROUND还是要非常需要注意的,特别是当参与计算的字段中包含浮点数的时候,这个时候计算结果是不准确的。

本文将会持续修正和更新,最新内容请参考我的 GITHUB 上的 程序猿成长计划 项目,欢迎 Star,另外,求follow😂。

三十分钟学会SED

本文承接之前写的三十分钟学会AWK一文,在学习完AWK之后,趁热打铁又学习了一下SED,不得不说这两个工具真的堪称文本处理神器,谁用谁知道!本文大部分内容依旧是翻译自Tutorialspoint上的入门教程,这次是 Sed Tutorial 一文,内容做了一些删减和补充,增加了一些原文中没有提及到的语法和命令的讲解,并且对原文所有的示例都一一进行了验证,希望本文对大家学习和了解Sed有所帮助。

Continue reading →

为什么你的命令行程序没有输出

问题描述

为什么你的程序没有输出?请看下面的命令

tail -f logfile | grep 'foo bar' | awk...

执行上述命令,你会发现你的程序没有产生任何输出,只有当logfile的内容足够多的时候才会产生输出,这是怎么回事呢?

原因

在非交互模式下,大多数的UNIX命令行程序都会缓冲它们的输出,这就意味着程序会缓冲一定数量(通常是4kilobytes)的字符再进行输出,而不是直接输出它的每个字符。在上面这种情况下,grep命令会缓冲它的输出,因此后面的awk命令只会收到一大块的输入。

缓冲区的使用极大地提高了I/O操作的效率,通常情况下其缓冲操作对用户是不可见的,不会影响到用户。在交互式的控制台会话中执行tail -f命令是实时的,但是当命令行程序通过管道连接其它程序的时候,命令行程序可能就无法识别最终的输出是否需要(接近)实时了。幸运的是,在UNIX下有一些技术可以用于控制I/O的缓冲行为。

理解缓冲原理,最重要的是要明确的知道,是写入方(writer)使用的缓冲区,而不是读取方(reader)。

什么是交互模式、非交互模式?

交互式模式就是在终端上执行,shell等待你的输入,并且立即执行你提交的命令。这种模式被称作交互式是因为shell与用户进行交互。这种模式也是大多数用户非常熟悉的:登录、执行一些命令、退出。当你退出后,shell也终止了。

shell也可以运行在另外一种模式:非交互式模式,以shell script(非交互)方式执行。在这种模式 下,shell不与你进行交互,而是读取存放在文件中的命令,并且执行它们。当它读到文件的结尾EOF,shell也就终止了。

参考bash 深入理解:交互式shell和非交互式shell、登录shell和非登录shell的区别

解决方案

排除不需要的命令

回到上面的问题,我们有一个命令行管道程序tail -f logfile | grep 'foo bar' | awk ...。因为tail -f永远都不会缓冲它的输出,因此如果只是运行tail -f logfile的话我们的程序是没有问题的。当标准输出是控制台的时候,grep命令不会使用输出缓冲区,因此在交互模式下,我们运行tail -f logfile | grep 'foo bar'也是没有问题的。现在的问题是如果grep命令的输出是通过管道连接到其它程序(例如上例中的awk命令)的话,它会启用输出缓冲区以提高效率。

下面的命令中去掉了grep命令,使用AWK去实现了筛选操作

tail -f logfile | awk '/foo bar/ ...'

但是这样做依然是不够的,比如我们无法实现对结果进行排序。这种情况下怎么办呢,我们应该总是去寻找最简单的方法,或许你的命令行程序已经支持非缓冲的输出了呢!

grep (e.g. GNU version 2.5.1) –line-buffered
sed (e.g. GNU version 4.0.6) -u,–unbuffered
awk (GNU awk, nawk) use the fflush() function
awk (mawk) -W interactive
tcpdump, tethereal -l

为了让我们的整个管道命令可以(近乎)实时的执行,我们需要告诉管道程序中的每个命令禁用输出缓冲区。管道的最后一个命令可以不需要禁用输出缓冲,因为它的输出是控制台。

在C程序中禁用缓冲区

如果带缓冲的程序是使用C语言开发的,或者你拥有他的源码可以修改它,可以使用下面这个函数禁用缓冲

setvbuf(stdout, 0, _IONBF, 0);

通常情况下只需要在main函数的顶部添加该函数即可。不过如果你的程序关闭并且重新打开了标准输出或者是调用了setvbuf()函数,你可能需要更加仔细一点。

unbuffer

expect 的程序包中包含了一个名为 unbuffer 的程序,它可以有效的欺骗其它程序,让它们以为自己总是在交互模式下执行(交互模式下会禁用缓冲)。

tail -f logfile | unbuffer grep 'foo bar' | awk ...

unbufferunbuffer不是标准的POSIX工具,不过不要担心,你的系统中可能已经安装过它们了。

stdbuf

新版的 GNU coreutils (从7.5开始)新增了一个名为 stdbuf 的程序,使用它也可以用来取消程序的输出缓冲。

tail -f logfile | stdbuf -oL grep 'foo bar' | awk ...

上面的代码中,“-oL” 选项告诉程序使用行缓冲模式,也可以使用“-o0”完全禁止缓冲。

stdbuf也不是标准的POSIX工具,但是你的系统中可能也已经安装了。另外,在Mac系统下可能是没有这个命令的,你需要手动去安装 brew install coreutils,安装之后的该工具的名字叫做gstdbuf

参考

本文大部分内容翻译自What is buffering? Or, why does my command line produce no output: tail -f logfile | grep 'foo bar' | awk …,内容有删减。

三十分钟学会AWK

本文大部分内容翻译自我开始学习AWK时看到的一篇英文文章 AWK Tutorial ,觉得对AWK入门非常有帮助,所以对其进行了粗略的翻译,并对其中部分内容进行了删减或者补充,希望能为对AWK感兴趣的小伙伴提供一份快速入门的教程,帮助小伙伴们快速掌握AWK的基本使用方式,当然,我也是刚开始学习AWK,本文在翻译或者补充的过程中肯定会有很多疏漏或者错误,希望大家能够帮忙指正。

本文将会持续修正和更新,最新内容请参考我的 GITHUB 上的 程序猿成长计划 项目,欢迎 Star。

概述

AWK是一门解释型的编程语言。在文本处理领域它是非常强大的,它的名字来源于它的三位作者的姓氏:Alfred AhoPeter WeinbergerBrian Kernighan

GNU/Linux发布的AWK目前由自由软件基金会(FSF)进行开发和维护,通常也称它为 GNU AWK

AWK的类型

下面是几个AWK的变体:

  • AWK – 原先来源于 AT & T 实验室的的AWK
  • NAWK – AT & T 实验室的AWK的升级版
  • GAWK – 这就是GNU AWK。所有的GNU/Linux发布版都自带GAWK,它与AWK和NAWK完全兼容

AWK的典型用途

使用AWK可以做很多任务,下面是其中一些

  • 文本处理
  • 输出格式化的文本报表
  • 执行算数运算
  • 执行字符串操作等等

工作流

要成为AWK编程专家,你需要先知道它的内部实现机制,AWK遵循了非常简单的工作流 – 读取执行重复,下图描述了AWK的工作流。

Read

AWK从输入流(文件,管道或者标准输入)中读取一行,然后存储到内存中。

Execute

所有的AWK命令都依次在输入上执行。默认情况下,AWK会对每一行执行命令,我们可以通过提供模式限制这种行为。

Repeat

处理过程不断重复,直到到达文件结尾。

程序结构

现在,让我们先学习一下AWK的程序结构。

BEGIN 语句块

BEGIN语句块的语法

BEGIN {awk-commands}

BEGIN语句块在程序开始的使用执行,它只执行一次,在这里可以初始化变量。BEGIN是AWK的关键字,因此它必须为大写,注意,这个语句块是可选的。

BODY 语句块

BODY语句块的语法

/pattern/ {awk-commands}

BODY语句块中的命令会对输入的每一行执行,我们也可以通过提供模式来控制这种行为。注意,BODY语句块没有关键字。

END 语句块

END语句块的语法

END {awk-commands}

END语句块在程序的最后执行,END是AWK的关键字,因此必须为大写,它也是可选的。

让我们创建一个包含序号,学生姓名,科目名称和得分的文件 marks.txt

1)  Amit    Physics  80
2)  Rahul   Maths    90
3)  Shyam   Biology  87
4)  Kedar   English  85
5)  Hari    History  89

下面的例子中我们将会显示文件内容,并且添加每一列的标题

$ awk 'BEGIN{printf "Sr No\tName\tSub\tMarks\n"} {print}' marks.txt

上述代码执行后,输出以下内容

Sr No     Name     Sub          Marks
 1)       Amit     Physics      80
 2)       Rahul    Maths        90
 3)       Shyam    Biology      87
 4)       Kedar    English      85
 5)       Hari     History      89

在程序的开始,AWK在BEGIN语句中打印出标题。然后再BODY语句中,它会读取文件的每一行然后执行AWK的print命令将每一行的内容打印到标准输出。这个过程会一直重复直到文件的结尾。

基础语法

AWK的使用非常简单,我们可以直接在命令行中执行AWK的命令,也可以从包含AWK命令的文本文件中执行。

AWK命令行

我们可以使用单引号在命令行中指定AWK命令

awk [options] file ...

比如我们有一个包含下面内容的文本文件 marks.txt:

1) Amit     Physics    80
2) Rahul    Maths      90
3) Shyam    Biology    87
4) Kedar    English    85
5) Hari     History    89

我们可以使用下面的命令显示该文件的完整内容

$ awk '{print}' marks.txt 

AWK程序文件

我们可以使用脚本文件提供AWK命令

awk [options] -f file ....

首先,创建一个包含下面内容的文本文件 command.awk

{print} 

现在,我们可以让AWK执行该文件中的命令,这里我们实现了和上例同样的结果

$ awk -f command.awk marks.txt

AWK标准选项

AWK支持下列命令行标准选项

-v 变量赋值选项

该选项将一个值赋予一个变量,它会在程序开始之前进行赋值,下面的例子描述了该选项的使用

$ awk -v name=Jerry 'BEGIN{printf "Name = %s\n", name}'
Name = Jerry

--dump-variables[=file] 选项

该选项会输出排好序的全局变量列表和它们最终的值到文件中,默认的文件是 awkvars.out

$ awk --dump-variables ''
$ cat awkvars.out 
ARGC: 1
ARGIND: 0
ARGV: array, 1 elements
BINMODE: 0
CONVFMT: "%.6g"
ERRNO: ""
FIELDWIDTHS: ""
FILENAME: ""
FNR: 0
FPAT: "[^[:space:]]+"
FS: " "
IGNORECASE: 0
LINT: 0
NF: 0
NR: 0
OFMT: "%.6g"
OFS: " "
ORS: "\n"
RLENGTH: 0
RS: "\n"
RSTART: 0
RT: ""
SUBSEP: "\034"
TEXTDOMAIN: "messages"

--help 选项

打印帮助信息。

$ awk --help
Usage: awk [POSIX or GNU style options] -f progfile [--] file ...
Usage: awk [POSIX or GNU style options] [--] 'program' file ...
POSIX options : GNU long options: (standard)
   -f progfile                --file=progfile
   -F fs                      --field-separator=fs
   -v var=val                 --assign=var=val
Short options : GNU long options: (extensions)
   -b                         --characters-as-bytes
   -c                         --traditional
   -C                         --copyright
   -d[file]                   --dump-variables[=file]
   -e 'program-text'          --source='program-text'
   -E file                    --exec=file
   -g                         --gen-pot
   -h                         --help
   -L [fatal]                 --lint[=fatal]
   -n                         --non-decimal-data
   -N                         --use-lc-numeric
   -O                         --optimize
   -p[file]                   --profile[=file]
   -P                         --posix
   -r                         --re-interval
   -S                         --sandbox
   -t                         --lint-old
   -V                         --version

--lint[=fatal] 选项

该选项允许检查程序的不兼容性或者模棱两可的代码,当提供参数 fatal的时候,它会对待Warning消息作为Error。

$ awk --lint '' /bin/ls
awk: cmd. line:1: warning: empty program text on command line
awk: cmd. line:1: warning: source file does not end in newline
awk: warning: no program text at all!

--posix 选项

该选项开启严格的POSIX兼容。

--profile[=file]选项

该选项会输出一份格式化之后的程序到文件中,默认文件是 awkprof.out

$ awk --profile 'BEGIN{printf"---|Header|--\n"} {print} 
END{printf"---|Footer|---\n"}' marks.txt > /dev/null 
$ cat awkprof.out
    # gawk 配置, 创建 Wed Oct 26 15:05:49 2016

    # BEGIN 块

    BEGIN {
        printf "---|Header|--\n"
    }

    # 规则

    {
        print $0
    }

    # END 块

    END {
        printf "---|Footer|---\n"
    }

--traditional 选项

该选项会禁止所有的gawk规范的扩展。

--version 选项

输出版本号

$ awk --version
GNU Awk 3.1.7
版权所有 © 1989, 1991-2009 自由软件基金会(FSF)。

该程序为自由软件,你可以在自由软件基金会发布的 GNU 通用公共许可证(GPL)第
3版或以后版本下修改或重新发布。

该程序之所以被发布是因为希望他能对你有所用处,但我们不作任何担保。这包含
但不限于任何商业适售性以及针对特定目的的适用性的担保。详情参见 GNU 通用公
共许可证(GPL)。

你应该收到程序附带的一份 GNU 通用公共许可证(GPL)。如果没有收到,请参看 http://www.gnu.org/licenses/ 。
You have new mail in /var/spool/mail/root

基本使用示例

本部分会讲述一些有用的AWK命令和它们的使用示例,所有的例子都是以下面的文本文件 marks.txt 为基础的

1) Amit Physics     80
2) Rahul    Maths       90
3) Shyam    Biology     87
4) Kedar    English     85
5) Hari History     89

打印某列或者字段

AWK可以只打印输入字段中的某些列。

$ awk '{print $3 "\t" $4}' marks.txt
Physics 80
Maths   90
Biology 87
English 85
History 89

在文件marks.txt中,第三列包含了科目名,第四列则是得分,上面的例子中,我们只打印出了这两列,$3$4 代表了输入记录中的第三和第四个字段。

打印所有的行

默认情况下,AWK会打印出所有匹配模式的行

$ awk '/a/ {print $0}' marks.txt
2)  Rahul   Maths    90
3)  Shyam   Biology  87
4)  Kedar   English  85
5)  Hari    History  89

上述命令会判断每一行中是否包含a,如果包含则打印该行,如果BODY部分缺失则默认会执行打印,因此,上述命令和下面这个是等价的

$ awk '/a/' marks.txt

打印匹配模式的列

当模式匹配成功时,默认情况下AWK会打印该行,但是也可以让它只打印指定的字段。例如,下面的例子中,只会打印出匹配模式的第三和第四个字段。

$ awk '/a/ {print $3 "\t" $4}' marks.txt
Maths   90
Biology 87
English 85
History 89

任意顺序打印列

$ awk '/a/ {print $4 "\t" $3}' marks.txt
90  Maths
87  Biology
85  English
89  History

统计匹配模式的行数

$ awk '/a/{++cnt} END {print "Count = ", cnt}' marks.txt
Count =  4

打印超过18个字符的行

$ awk 'length($0) > 18' marks.txt
3) Shyam   Biology   87
4) Kedar   English   85

内建变量

AWK提供了很多内置的变量,它们在开发AWK脚本的过程中起着非常重要的角色。

标准AWK变量

ARGC 命令行参数个数

命令行中提供的参数个数

$ awk 'BEGIN {print "Arguments =", ARGC}' One Two Three Four
Arguments = 5

ARGV 命令行参数数组

存储命令行参数的数组,索引范围从0ARGC – 1

$ awk 'BEGIN { 
   for (i = 0; i < ARGC - 1; ++i) { 
      printf "ARGV[%d] = %s\n", i, ARGV[i] 
   } 
}' one two three four
ARGV[0] = awk
ARGV[1] = one
ARGV[2] = two
ARGV[3] = three

CONVFMT 数字的约定格式

代表了数字的约定格式,默认值是%.6g

$ awk 'BEGIN { print "Conversion Format =", CONVFMT }'
Conversion Format = %.6g

ENVIRON 环境变量

环境变量的关联数组

$ awk 'BEGIN { print ENVIRON["USER"] }'
mylxsw

FILENAME 当前文件名

$ awk 'END {print FILENAME}' marks.txt
marks.txt

FS 输入字段的分隔符

代表了输入字段的分隔符,默认值为空格,可以通过-F选项在命令行选项中修改它。

$ awk 'BEGIN {print "FS = " FS}' | cat -vte
FS =  $
$ awk -F , 'BEGIN {print "FS = " FS}' | cat -vte
FS = ,$

NF 字段数目

代表了当前行中的字段数目,例如下面例子打印出了包含大于两个字段的行

$ echo -e "One Two\nOne Two Three\nOne Two Three Four" | awk 'NF > 2'
One Two Three
One Two Three Four

NR 行号

$ echo -e "One Two\nOne Two Three\nOne Two Three Four" | awk 'NR < 3'
One Two
One Two Three

FNR 行号(相对当前文件)

与NR相似,不过在处理多文件时更有用,获取的行号相对于当前文件。

OFMT 输出格式数字

默认值为%.6g

$ awk 'BEGIN {print "OFMT = " OFMT}'
OFMT = %.6g

OFS 输出字段分隔符

输出字段分隔符,默认为空格

$ awk 'BEGIN {print "OFS = " OFS}' | cat -vte
OFS =  $

ORS 输出行分隔符

默认值为换行符

$ awk 'BEGIN {print "ORS = " ORS}' | cat -vte
ORS = $
$

RLENGTH

代表了 match 函数匹配的字符串长度。

$ awk 'BEGIN { if (match("One Two Three", "re")) { print RLENGTH } }'
2

RS 输入记录分隔符

$ awk 'BEGIN {print "RS = " RS}' | cat -vte
RS = $
$

RSTART

match函数匹配的第一次出现位置

$ awk 'BEGIN { if (match("One Two Three", "Thre")) { print RSTART } }
9

SUBSEP 数组子脚本的分隔符

数组子脚本的分隔符,默认为\034

$ awk 'BEGIN { print "SUBSEP = " SUBSEP }' | cat -vte
SUBSEP = ^\$

$ 0 代表了当前行

代表了当前行

$ awk '{print $0}' marks.txt
1) Amit     Physics   80
2) Rahul    Maths     90
3) Shyam    Biology   87
4) Kedar    English   85
5) Hari     History   89

$n

当前行中的第n个字段

$ awk '{print $3 "\t" $4}' marks.txt
Physics   80
Maths     90
Biology   87
English   85
History   89

GNU AWK的变量

ARGIND

当前被处理的ARGV的索引

$ awk '{ 
   print "ARGIND   = ", ARGIND; print "Filename = ", ARGV[ARGIND] 
}' junk1 junk2 junk3
ARGIND   =  1
Filename =  junk1
ARGIND   =  2
Filename =  junk2
ARGIND   =  3
Filename =  junk3

BINMODE

在非POSIX系统上指定对所有的文件I/O采用二进制模式。

ERRORNO

一个代表了getline跳转失败或者是close调用失败的错误的字符串。

$ awk 'BEGIN { ret = getline < "junk.txt"; if (ret == -1) print "Error:", ERRNO }'
Error: No such file or directory

FIELDWIDTHS

设置了空格分隔的字段宽度变量列表的话,GAWK会将输入解析为固定宽度的字段,而不是使用FS进行分隔。

IGNORECASE

设置了这个变量的话,AWK会忽略大小写。

$ awk 'BEGIN{IGNORECASE = 1} /amit/' marks.txt
1) Amit  Physics   80

LINT

提供了对–lint选项的动态控制。

$ awk 'BEGIN {LINT = 1; a}'
awk: cmd. line:1: warning: reference to uninitialized variable `a'
awk: cmd. line:1: warning: statement has no effect

PROCINFO

包含进程信息的关联数组,例如UID,进程ID等

$ awk 'BEGIN { print PROCINFO["pid"] }'
4316

TEXTDOMAIN

代表了AWK的文本域,用于查找字符串的本地化翻译。

$ awk 'BEGIN { print TEXTDOMAIN }'
messages

操作符

与其它编程语言一样,AWK也提供了大量的操作符。

算数操作符

算数操作符不多说,直接看例子,无非就是+-*/%

$ awk 'BEGIN { a = 50; b = 20; print "(a + b) = ", (a + b) }'
(a + b) =  70

$ awk 'BEGIN { a = 50; b = 20; print "(a - b) = ", (a - b) }'
(a - b) =  30

$ awk 'BEGIN { a = 50; b = 20; print "(a * b) = ", (a * b) }'
(a * b) =  1000

$ awk 'BEGIN { a = 50; b = 20; print "(a / b) = ", (a / b) }'
(a / b) =  2.5

$ awk 'BEGIN { a = 50; b = 20; print "(a % b) = ", (a % b) }'
(a % b) =  10

增减运算符

自增自减与C语言一致。

$ awk 'BEGIN { a = 10; b = ++a; printf "a = %d, b = %d\n", a, b }'
a = 11, b = 11

$ awk 'BEGIN { a = 10; b = --a; printf "a = %d, b = %d\n", a, b }'
a = 9, b = 9

$ awk 'BEGIN { a = 10; b = a++; printf "a = %d, b = %d\n", a, b }'
a = 11, b = 10

$ awk 'BEGIN { a = 10; b = a--; printf "a = %d, b = %d\n", a, b }'
a = 9, b = 10

赋值操作符

$ awk 'BEGIN { name = "Jerry"; print "My name is", name }'
My name is Jerry
$ awk 'BEGIN { cnt = 10; cnt += 10; print "Counter =", cnt }'
Counter = 20
$ awk 'BEGIN { cnt = 100; cnt -= 10; print "Counter =", cnt }'
Counter = 90
$ awk 'BEGIN { cnt = 10; cnt *= 10; print "Counter =", cnt }'
Counter = 100
$ awk 'BEGIN { cnt = 100; cnt /= 5; print "Counter =", cnt }'
Counter = 20
$ awk 'BEGIN { cnt = 100; cnt %= 8; print "Counter =", cnt }'
Counter = 4
$ awk 'BEGIN { cnt = 2; cnt ^= 4; print "Counter =", cnt }'
Counter = 16
$ awk 'BEGIN { cnt = 2; cnt **= 4; print "Counter =", cnt }'
Counter = 16

关系操作符

$ awk 'BEGIN { a = 10; b = 10; if (a == b) print "a == b" }'
a == b
$ awk 'BEGIN { a = 10; b = 20; if (a != b) print "a != b" }'
a != b
$ awk 'BEGIN { a = 10; b = 20; if (a < b) print "a  < b" }'
a  < b
$ awk 'BEGIN { a = 10; b = 10; if (a <= b) print "a <= b" }'
a <= b
$ awk 'BEGIN { a = 10; b = 20; if (b > a ) print "b > a" }'
b > a

逻辑操作符

$ awk 'BEGIN {
   num = 5; if (num >= 0 && num <= 7) printf "%d is in octal format\n", num
}'
5 is in octal format
$ awk 'BEGIN {
   ch = "\n"; if (ch == " " || ch == "\t" || ch == "\n")
   print "Current character is whitespace."
}'
Current character is whitespace.
$ awk 'BEGIN { name = ""; if (! length(name)) print "name is empty string." }'
name is empty string.

三元操作符

$ awk 'BEGIN { a = 10; b = 20; (a > b) ? max = a : max = b; print "Max =", max}'
Max = 20

一元操作符

$ awk 'BEGIN { a = -10; a = +a; print "a =", a }'
a = -10
$ awk 'BEGIN { a = -10; a = -a; print "a =", a }'
a = 10

指数操作符

$ awk 'BEGIN { a = 10; a = a ^ 2; print "a =", a }'
a = 100

$ awk 'BEGIN { a = 10; a ^= 2; print "a =", a }'
a = 100

字符串连接操作符

$ awk 'BEGIN { str1 = "Hello, "; str2 = "World"; str3 = str1 str2; print str3 }'
Hello, World

数组成员操作符

$ awk 'BEGIN { 
   arr[0] = 1; arr[1] = 2; arr[2] = 3; for (i in arr) printf "arr[%d] = %d\n", i, arr[i]
}'
arr[2] = 3
arr[0] = 1
arr[1] = 2

正则表达式操作符

正则表达式操作符使用 ~!~ 分别代表匹配和不匹配。

$ awk '$0 ~ 9' marks.txt
2) Rahul   Maths    90
5) Hari    History  89

$ awk '$0 !~ 9' marks.txt
1) Amit     Physics   80
3) Shyam    Biology   87
4) Kedar    English   85

# 匹配正则表达式需要在表达式前后添加反斜线,与js类似吧
$ tail -n 40 /var/log/nginx/access.log | awk '$0 ~ /ip\[127\.0\.0\.1\]/'

更多关于正则表达式请看后面的正则表达式部分

正则表达式

AWK在处理正则表达式方面是非常强大的,使用简单的正则表达式可以处理非常复杂的问题。

$ echo -e "cat\nbat\nfun\nfin\nfan" | awk '/f.n/'
fun
fin
fan

$ echo -e "This\nThat\nThere\nTheir\nthese" | awk '/^The/'
There
Their

$ echo -e "knife\nknow\nfun\nfin\nfan\nnine" | awk '/n$/'
fun
fin
fan

$ echo -e "Call\nTall\nBall" | awk '/[CT]all/'
Call
Tall

$ echo -e "Call\nTall\nBall" | awk '/[^CT]all/'
Ball

$ echo -e "Call\nTall\nBall\nSmall\nShall" | awk '/Call|Ball/'
Call
Ball

$ echo -e "Colour\nColor" | awk '/Colou?r/'
Colour
Color

$ echo -e "ca\ncat\ncatt" | awk '/cat*/'
ca
cat
catt

$ echo -e "111\n22\n123\n234\n456\n222"  | awk '/2+/'
22
123
234
222

$ echo -e "Apple Juice\nApple Pie\nApple Tart\nApple Cake" | awk '/Apple (Juice|Cake)/'
Apple Juice
Apple Cake

数组

AWK支持关联数组,也就是说,不仅可以使用数字索引的数组,还可以使用字符串作为索引,而且数字索引也不要求是连续的。数组不需要声明可以直接使用,语法如下:

array_name[index] = value

创建数组的方式非常简单,直接为变量赋值即可

$ awk 'BEGIN {
   fruits["mango"] = "yellow";
   fruits["orange"] = "orange"
   print fruits["orange"] "\n" fruits["mango"]
}'
orange
yellow

删除数组元素使用delete语句

$ awk 'BEGIN {
   fruits["mango"] = "yellow";
   fruits["orange"] = "orange";
   delete fruits["orange"];
   print fruits["orange"]
}'

在AWK中,只支持一维数组,但是可以通过一维数组模拟多维,例如我们有一个3×3的三维数组

100   200   300
400   500   600
700   800   900

可以这样操作

$ awk 'BEGIN {
   array["0,0"] = 100;
   array["0,1"] = 200;
   array["0,2"] = 300;
   array["1,0"] = 400;
   array["1,1"] = 500;
   array["1,2"] = 600;

   # print array elements
   print "array[0,0] = " array["0,0"];
   print "array[0,1] = " array["0,1"];
   print "array[0,2] = " array["0,2"];
   print "array[1,0] = " array["1,0"];
   print "array[1,1] = " array["1,1"];
   print "array[1,2] = " array["1,2"];
}'
array[0,0] = 100
array[0,1] = 200
array[0,2] = 300
array[1,0] = 400
array[1,1] = 500
array[1,2] = 600

流程控制

流程控制语句与大多数语言一样,基本格式如下

if (condition)
   action

if (condition) {
   action-1
   action-1
   .
   .
   action-n
}

if (condition)
   action-1
else if (condition2)
   action-2
else
   action-3

例如:

$ awk 'BEGIN {
   num = 11; if (num % 2 == 0) printf "%d is even number.\n", num; 
      else printf "%d is odd number.\n", num 
}'

$ awk 'BEGIN {
   a = 30;

   if (a==10)
   print "a = 10";
   else if (a == 20)
   print "a = 20";
   else if (a == 30)
   print "a = 30";
}'

循环

循环操作与其他C系语言一样,主要包括 forwhiledo...whilebreakcontinue 语句,当然,还有一个 exit语句用于退出脚本执行。

for (initialisation; condition; increment/decrement)
   action

while (condition)
   action

do
   action
while (condition)

例子:

$ awk 'BEGIN { for (i = 1; i <= 5; ++i) print i }'

$ awk 'BEGIN {i = 1; while (i < 6) { print i; ++i } }'

$ awk 'BEGIN {i = 1; do { print i; ++i } while (i < 6) }'

$ awk 'BEGIN {
   sum = 0; for (i = 0; i < 20; ++i) { 
      sum += i; if (sum > 50) break; else print "Sum =", sum 
   } 
}'

$ awk 'BEGIN {
   for (i = 1; i <= 20; ++i) {
      if (i % 2 == 0) print i ; else continue
   } 
}'

$ awk 'BEGIN {
   sum = 0; for (i = 0; i < 20; ++i) {
      sum += i; if (sum > 50) exit(10); else print "Sum =", sum 
   } 
}'

exit用于退出脚本,参数为退出的状态码,可以通过shell中的$?获取

函数

内建函数

AWK提供了很多方便的内建函数供编程人员使用。由于函数比较多,个人觉得单纯看每个函数的使用也没有什么实际意义,比较容易遗忘,因此,这里只简单的列出常用的一些函数,只需要对其有个印象即可,使用的时候再去 查手册 效果会更好一些吧。

数学函数

  • atan2(y, x)
  • cos(expr)
  • exp(expr)
  • int(expr)
  • log(expr)
  • rand
  • sin(expr)
  • sqrt(expr)
  • srand([expr])

字符串函数

  • asort(arr [, d [, how] ])
  • asorti(arr [, d [, how] ])
  • gsub(regex, sub, string)
  • index(str, sub)
  • length(str)
  • match(str, regex)
  • split(str, arr, regex)
  • sprintf(format, expr-list)
  • strtonum(str)
  • sub(regex, sub, string)
  • substr(str, start, l)
  • tolower(str)
  • toupper(str)

时间函数

  • systime
  • mktime(datespec)
  • strftime([format [, timestamp[, utc-flag]]])

字节操作函数

  • and
  • compl
  • lshift
  • rshift
  • or
  • xor

其它

  • close(expr) 关闭管道文件

    请看下面这段代码

    $ awk 'BEGIN {
       cmd = "tr [a-z] [A-Z]"
       print "hello, world !!!" |& cmd
    
       close(cmd, "to")
       cmd |& getline out
       print out;
    
       close(cmd);
    }'
    HELLO, WORLD !!!
    

    是不是感觉很难懂?让我来解释一下

    • 第一个语句cmd = "tr [a-z] [A-Z]"是我们在AWK中要用来建立双向连接的命令。
    • 第二个语句print提供了tr命令的输入,使用 &| 表名建立双向连接。
    • 第三个语句close(cmd, "to")用于执行完成后关闭to进程
    • 第四个语句cmd |& getline out使用getline函数存储输出到out变量
    • 接下来打印变量out的内容,然后关闭cmd
  • delete 用于删除数组元素

  • exit 退出脚本执行,并返回状态码参数

  • fflush

  • getline 该命令让awk读取下一行内容

    该命令让awk读取下一行内容,比如

    $ awk '{getline; print $0}' marks.txt
    2) Rahul   Maths     90
    4) Kedar   English   85
    5) Hari    History   89
    

    使用getline var < file可以从file中读取输入,存储到变量var中

    {
         if (NF == 2 && $1 == "@include") {
              while ((getline line < $2) > 0)
                   print line
              # 这里的close确保如果文件中两个@include,可以让其读取两次
              close($2)
         } else
              print
    }
    

    命令的输出也可以通过管道输入到getline,使用command | getline这种方式。在这种情况下,字符串命令会作为shell命令执行,其标准输出会通过管道传递个awk作为其输入,这种形式的getline会从管道中一次读取一条记录。例如下面的命令会从输入中逐行读取,如果遇到@execute,则将该行作为命令执行,将命令的输出作为最终的输出内容

    {
         if ($1 == "@execute") {
              tmp = substr($0, 10)        # Remove "@execute"
              while ((tmp | getline) > 0)
                   # 这里实际上设置了$0为这一行的内容
                   print
              close(tmp)
         } else
              print
    }
    

    如果文件包含以下内容

    foo
    bar
    baz
    @execute who
    bletch
    

    则会输出

    foo
    bar
    baz
    arnold     ttyv0   Jul 13 14:22
    miriam     ttyp0   Jul 13 14:23     (murphy:0)
    bill       ttyp1   Jul 13 14:23     (murphy:0)
    bletch
    

    使用command | getline var可以实现将命令的输出写入到变量var。

    BEGIN {
         "date" | getline current_time
         close("date")
         print "Report printed on " current_time
    }
    

    getline使用管道读取输入是一种单向的操作,在某些场景下,你可能希望发送数据到另一个进程,然后从这个进程中读取处理后的结果, 这就用到了协同进程,我们可以使用|&打开一个双向管道。

    print "some query" |& "db_server"
    "db_server" |& getline
    

    同样,我们也可以使用command |& getline var将协同进程的输出写入到变量var。

  • next

  • nextfile

  • return

    用于用户自定义函数的返回值。
    首先,创建一个functions.awk文件,包含下面的awk命令

    function addition(num1, num2) {
       result = num1 + num2
       return result
    }
    BEGIN {
       res = addition(10, 20)
       print "10 + 20 = " res
    }
    

    执行上述代码,输出

    10 + 20 = 30
    
  • system

    该函数用于执行指定的命令并且返回它的退出状态,返回状态码0表示命令成功执行。

    $ awk 'BEGIN { ret = system("date"); print "Return value = " ret }'
    2016年 10月 27日 星期四 22:08:36 CST
    Return value = 0
    

用户自定义函数

函数是程序基本的组成部分,AWK允许我们自己创建自定义的函数。一个大型的程序可以被划分为多个函数,每个函数之间可以独立的开发和测试,提供可重用的代码。

下面是用户自定义函数的基本语法

function function_name(argument1, argument2, ...) { 
   function body
}

例如,我们创建一个名为functions.awk的文件,包含下面的代码

# Returns minimum number
function find_min(num1, num2){
   if (num1 < num2)
   return num1
   return num2
}
# Returns maximum number
function find_max(num1, num2){
   if (num1 > num2)
   return num1
   return num2
}
# Main function
function main(num1, num2){
   # Find minimum number
   result = find_min(10, 20)
   print "Minimum =", result

   # Find maximum number
   result = find_max(10, 20)
   print "Maximum =", result
}
# Script execution starts here
BEGIN {
   main(10, 20)
}

执行上述代码,会得到下面的输出

Minimum = 10
Maximum = 20

输出重定向

重定向操作符

到目前为止,我们所有的程序都是直接显示数据到了标准输出流,其实,我们也可以将输出重定向到文件。重定向操作符跟在printprintf函数的后面,与shell中的用法基本一致。

print DATA > output-file
print DATA >> output-file

例如,下面两条命令输出是一致的

$ echo "Hello, World !!!" > /tmp/message.txt
$ awk 'BEGIN { print "Hello, World !!!" > "/tmp/message.txt" }'

与shell中一样,>用于将输出写入到指定的文件中,如果文件中有内容则覆盖,而>>则为追加模式写入。

$ awk 'BEGIN { print "Hello, World !!!" >> "/tmp/message.txt" }'
$ cat /tmp/message.txt

管道

除了将输出重定向到文件之外,我们还可以将输出重定向到其它程序,与shell中一样,我们可以使用管道操作符|

$ awk 'BEGIN { print "hello, world !!!" | "tr [a-z] [A-Z]" }'
HELLO, WORLD !!!

AWK中可以使用|&进行双向连接,那么什么是双向连接呢?一种常见的场景是我们发送数据到另一个程序处理,然后读取处理结果,这种场景下就需要打开一个到另外一个进程的双向管道了。第二个进程会与gawk程序并行执行,这里称其为 协作进程。与单向连接使用|操作符不同的是,双向连接使用|&操作符。

do {
    print data |& "subprogram"
    "subprogram" |& getline results
} while (data left to process)
close("subprogram")

第一次I/O操作使用了|&操作符,gawk会创建一个到运行其它程序的子进程的双向管道,print的输出被写入到了subprogram的标准输入,而这个subprogram的标准输出在gawk中使用getline函数进行读取。

注意:目前协同进程的标准错误输出将会和gawk的标准错误输出混杂在一起,无法单独获取标准错误输出。另外,I/O缓冲可能存在问题,gawk程序会自动的刷新所有输出到下游的协同进程的管道。但是,如果协同进程没有刷新其标准输出的话,gawk将可能会在使用getline函数从协同进程读取输出的时候挂起,这就可能引起死锁。

我们可以使用close函数关闭双向管道的to或者from一端,这两个字符串值告诉gawk发送数据到协同进程完成时或者从协同进程读取完毕时关闭管道。在使用系统命令sort的时候是这样做是非常必要的,因为它必须等所有输出都读取完毕时才能进行排序。

BEGIN {
    command = "LC_ALL=C sort"
    n = split("abcdefghijklmnopqrstuvwxyz", a, "")

    for (i = n; i > 0; i--)
        print a[i] |& command
    close(command, "to")

    while ((command |& getline line) > 0)
        print "got", line
    close(command)
}

例如,下面的例子中使用tr命令转换小写为大写。我们的command.awk文件包含以下内容

BEGIN {
   cmd = "tr [a-z] [A-Z]"
   print "hello, world !!!" |& cmd
   close(cmd, "to")

   cmd |& getline out
   print out;
   close(cmd);
}

输出

HELLO, WORLD !!!

上例看起来有些复杂,我们逐行分析一下

  • 首先,第一行 cmd = "tr [a-z] [A-Z]" 是在AWK中要建立双向连接的命令
  • 第二行的print命令用于为tr命令提供输入,而 |& 用于指出要建立双向连接
  • 第三行用于在上面的语句close(cmd, "to"),在执行完成后关闭其to进程
  • 第四行 cmd |& getline out使用getline函数存储输出到变量out中
  • 最后一行使用close函数关闭命令

美化输出

到目前为止,我们已经使用过printprintf函数显示数据到标准输出,但是printf函数实际上要比我们之前使用的情况更加强大得多。该函数是从C语言中借鉴来的,在处理格式化的输出时非常有用。

$ awk 'BEGIN { printf "Hello\nWorld\n" }'
Hello
World

$ awk 'BEGIN { printf "ASCII value 65 = character %c\n", 65 }'
ASCII value 65 = character A

格式化输出标识有 %c%d%s 等,基本与C语言一致,这里就不多赘述了。

执行shell命令

在AWK中执行shell命令有两种方式

  • 使用system函数
  • 使用管道

使用system函数

system函数用于执行操作系统命令并且返回命令的退出码到awk。

END {
     system("date | mail -s 'awk run done' root")
}

使用管道

如果要执行的命令很多,可以将输出的命令直接用管道传递给"/bin/sh"执行

while (more stuff to do)
    print command | "/bin/sh"
close("/bin/sh")

参考

本文将会持续修正和更新,最新内容请参考我的 GITHUB 上的 程序猿成长计划 项目,欢迎 Star。

【译】在 Go 语言中实现 UDP 和 TCP 网络通讯

Go因为作为非常好用的系统编程语言而知名。开发者很喜欢它在开发后端服务时的简洁,易于开发和高性能。在很多后端服务中一个关键的特性是网络通信。有很多应用级别的协议用于软件之间通过网络进行交互。在它们的底层大都依赖于 TCP 或者 UDP。在本文中, 我们将讨论在Golang中实现UDP和TCP所涉及到的一些代码。让我们开始吧。

Go语言中的TCP

在Go语言中支持TCP已经有大量的文章和资源讲解了。显然,因为它作为互联网中广泛使用的HTTP协议的底层协议,使得它变得非常流行。 让我们看看在Go语言中使用TCP的一些实例。

首先,最重要的是Go的net包,它是在Go中任何网络通信的关键。在net包中,包含了 TCPAddrTCPConn, and TCPListener 这几个用于支持TCP的数据类型。如果你对此感兴趣,可以花一些时间去研究一下它们。在大多数情况下,除非需要访问连接的高级属性,我们并不需要直接使用这些类型。Go的net包支持一些不仅仅包含TCP,还包含其它的面向流的网络协议,比如TCP, unix或者unixpocket。这些接口是 Conn 和 Listener,我们将会简短的了解一下这两个接口。

Go语言中的UDP

在Go语言中,UDP的支持并不像TCP那样在很多博客和论坛中有很多指南。对于现代软件来说,UDP是非常重要的协议,有些情况下使用UDP作为我们的网络协议是非常合理的。

Go的net包提供了对UDP相关类型的支持,主要包含 UDPConn 和 UDPAddr。在网络上我找到的大部分例子都是直接使用这些类型,但是,在Go中有更好的方式去开发基于UDP的软件。

与TCP一样,也有很多抽象的接口用于使用UDP进行通信。最重要的是 PacketConn,它提供了对面向数据报的协议如UDP,IP或者Unix数据报的支持。

Go 语言的 UDP 和 TCP 客户端实现

现在我们开始来看看实际的代码,如果我们使用接口,那么 TCP 和 UDP 版本的实现是一致的,来看看具体代码:

TCP:

//Connect TCP
conn, err := net.Dial("tcp", "host:port")
if err != nil {
    return err
}
defer conn.Close()

//simple Read
buffer := make([]byte, 1024)
conn.Read(buffer)

//simple write
conn.Write([]byte("Hello from client"))

net.Dial() 返回 Conn 接口,支持读和写方法。Conn 支持超级受欢迎的 io.Readerio.Writer 接口,在 Go 的很多包中都有实现,例如 bufio允许缓冲 I/O 读写。

我们注意到net.Dial()有一个“tcp”的字符串参数,它用于告诉Go初始化一个tcp连接。第二个参数是目标地址。

那关于UDP客户端怎么写?猜一下!!

//Connect udp
conn, err := net.Dial("udp", "host:port")
if err != nil {
    return err
}
defer conn.Close()

//simple Read
buffer := make([]byte, 1024)
conn.Read(buffer)

//simple write
conn.Write([]byte("Hello from client"))

非常直接对吧?唯一的不同是net.Dial()函数的第一个参数不同。我们使用“udp”表明我们希望创建一个UDP连接。

GOLANG中的TCP VS UDP:服务端实现

TCP和UDP在服务端的实现是不同的。在实现TCP的时候,我们需要使用 Listener 接口 监听和接受TCP连接。让我们看一段代码:

// listen to incoming tcp connections
l, err := net.Listen("tcp", "host:port")
if err != nil {
    return err
}
defer l.Close()
// A common pattern is to start a loop to continously accept connections
for {
    //accept connections using Listener.Accept()
    c, err := l.Accept()
    if err!= nil {
        return err
    }
    //It's common to handle accepted connection on different goroutines
    go handleConnection(c)
}

代码是非常简单和直接的,只需要对TCP服务端有一些基础的理解:你需要监听来自外部的连接,然后通过在连接上读写数据处理对它进行处理。让我们看一段关于如何读写数据的最简单的代码:

func handleConnection(c net.Conn) {
    //some code...

    //Simple read from connection
    buffer := make([]byte, 1024)
    c.Read(buffer)

    //simple write to connection
    c.Write([]byte("Hello from server"))
}

现在,你注意到了吗:Listener.Accept()返回的连接是与TCP客户端一样的,都实现了 Conn 接口。对io.Reader和io.Writer的支持使它可以在很多Go的包中得到很好地兼容。

在Go中实现一个UDP服务器与TCP有些不同,它使用 PacketConn 接口取代了Conn接口和listener。让我们看一下如何实现:

// listen to incoming udp packets
pc, err := net.ListenPacket("udp", "host:port")
if err != nil {
    log.Fatal(err)
}
defer pc.Close()

//simple read
buffer := make([]byte, 1024)
pc.ReadFrom(buffer)

//simple write
pc.WriteTo([]byte("Hello from client"), addr)

对于UDP服务器来说,我们使用net.ListenPacket()方法,加上"udp"参数宣称我们准备在服务器的地址上接收UDP交互。我们之后就可以对UDP客户端进行读写了。
与类型Conn不同的是,PackerConn并不支持io.readerio.writer接口,但是它支持两个特殊的读写方法ReadFrom()WriteTo()WriteTo()方法需要提供一个参数作为发送的数据到哪个地址,ReadFrom()则返回数据是从哪个地址接收的。

本文应该可以作为在Go中实现TCP和UDP的代码实践,希望你能够学到一些新的东西。


原文:

【译】Let’s Encrypt – 免费的SSL/TLS证书

每一个建立过安全站点的人都在如何维护证书这个问题上深受困扰。Let’s Encrypt 推荐的客户端 Certbot,能够自动的消除这些用户的痛点,并且让站点维护人员能够使用简单的命令开启和管理站点的HTTPS功能。

不需要验证邮件,不需要去编辑复杂的配置,也不再你的站点因为证书过期而无法正常工作。当然,因为Let’s Encrypt提供的是免费证书,因此也不需要付费。

本文简要描述了如何使用Certbot进行证书管理。(欢迎使用任何兼容的客户端;相关说明请查看这些项目的指导页面)。

如果你想知道更多关于它是工作原理,查看我们的 工作原理 页面。

安装客户端软件

如果你的操作系统包含了一个certbot的安装包,从这里安装它 ,然后使用相应的certbot命令。如果没有的话,则可以使用我们提供的cert-auto包装器脚本快速的获取一份。

$ git clone https://github.com/certbot/certbot
$ cd certbot
$ ./certbot-auto --help 

certbot-autocertbot命令拥有相同的命令行参数;它会安装所有的依赖并且自动更新 Certbot 的代码(这个过程下载的文件比较大,因此比较慢)。

使用限制

Let’s Encrypt 每周会产生有限数量的证书,确切的数量请查看这篇文章。如果你第一次使用certbot,你可能希望添加--test-cert标识,并且使用一个未使用的域名。这样将会从staging服务器获得一个证书,它们在浏览器中是无效的,除此之外,其它过程都是相同的,因此你可以测试各种配置选项而不会超过这个数量限制。

如何使用客户端

Cerbot 支持很多插件,可以用它们来获取和安装证书。下面包含了一些选项的使用例子:

如果你在近期发布的Debian操作系统上运行Apache服务,你可以尝试Apache插件,使用它可以自动获取和安装证书:

certbot --apache

目前在其它平台上还没有实现自动安装,因此你必须使用命令certonly进行安装。下面是一些例子:

要获取一个可以在任何web服务器的webroot目录上能够运行证书,需要使用“webroot”插件:

certbot certonly --webroot -w /var/www/example -d example.com -d www.example.com -w /var/www/thing -d thing.is -d m.thing.is

这个命令将会获取example.com,www.example.com, thing.is 和 m.thing.is 的单个证书,它将会把前两个域名生成的文件放到/var/www/example目录,后面两个放到/var/www/thing目录。

例如使用内建的“独立”web服务器获取 example.com 和 www.example.com 的证书(你可能需要临时停止已经存在的web服务器):

certbot certonly --standalone -d example.com -d www.example.com

证书续订

从0.4.0版本开始,Certbot增加了高级的renew子命令,它可以用于使用之前获取证书时相同的配置续订所有的证书。你可以通过运行以下命令测试一下:

certbot renew --dry-run

上述命令会获取一个测试证书,它不会对你的系统产生任何持久化的修改。如果你觉得这个结果还可以,可以运行下面的命令:

certbot renew

如果你想续订某一个证书(而不是所有的)或者修改某一个用于续订的配置参数,你可以使用certbot certonly命令和其它特定的配置获取单个证书。当使用certbot certonly命令的时候,你可以得到单个证书的续订。使用指定-d选项指定你希望续订的域名所覆盖的每一个域名。

注意: 从0.4.0开始,Certbot将会记录任何你使用certonlyrenew时选择的配置,未来使用renew的时候将会使用最近的配置。在版本0.3.0中,Certbot只会记录第一次获取证书时的配置,并不会使用之后续订时的配置替换它。

动词renew被设计用来半自动或者自动的使用,因此它也隐含着--non-interactive的意味。该选项意味着Certbot不会停下来与你进行交互;对于自动续订来说,使用该选项是非常不错的,但是因为指定该选项的话你无法与Certbot进行交互,因此你应该确保你所有的配置都被正确的设置。

选项--dry-run用于从我们的staging服务器获取证书。获取的证书不会保存到磁盘上,并且你的配置也不会被更新,因此你可以用来测试是否的renew或者certonly命令能够正确的执行续订。从staging服务器获取证书不会影响生产服务器的数量限制。

如果你想要改变之前指定的值,你可以在续订时,在命令行中指定一个新的选项,例如:

certbot renew --rsa-key-size 4096

运行certbot renew命令将会续订所有在续订窗口的证书(默认情况下,证书过期时间为30天)。如果你想要续订单个证书,你应该使用certbot certonly -d命令指定要续订的证书的域名。例如:

certbot certonly --keep-until-expiring --webroot -w /var/www/example.com -d example.com,www.example.com -w /var/www/thing -d thing.is,m.thing.is

如果你的证书安装在本地服务器,则一旦certonly命令执行完成,你需要重载服务器的配置文件(例如,对于apache2服务器来说执行server apache2 reload命令)。

开发自己的续订脚本

对于如何建立自动续订功能,请参考续订文档

撤销证书

使用下面的命令撤销撤销一个证书

$ certbot revoke --cert-path example-cert.pem

完整文档

更多关于Certbot的信息,请参考 完整文档。已知的一些问题使用Github进行跟踪。在提交新的问题的时候请先参考最近是否有相似的问题。

获得帮助

在阅读文档和问题列表之后,如果你需要额外的帮助的话,请尝试我们的帮助社区论坛

查看我们的 隐私策略.

查看我们的 商标策略.

Let’s Encrypt是由非营利的互联网安全研究小组(ISRG)管理的一个免费,自动化,开放的证书授权机构。

1 Letterman Drive, Suite D4700, San Francisco, CA 94129

Linux Foundation是Linux基金会的注册商标。Linux是由Linus Torvalds注册的商标


原文:

Let's Encrypt – Getting Started

研发团队GIT开发流程新人学习指南

分支流程说明

简介

项目中长期存在的两个分支

  • master:主分支,负责记录上线版本的迭代,该分支代码与线上代码是完全一致的。
  • develop:开发分支,该分支记录相对稳定的版本,所有的feature分支和bugfix分支都从该分支创建。

其它分支为短期分支,其完成功能开发之后需要删除

  • feature/*:特性(功能)分支,用于开发新的功能,不同的功能创建不同的功能分支,功能分支开发完成并自测通过之后,需要合并到 develop 分支,之后删除该分支。
  • bugfix/*:bug修复分支,用于修复不紧急的bug,普通bug均需要创建bugfix分支开发,开发完成自测没问题后合并到 develop 分支后,删除该分支。
  • release/*:发布分支,用于代码上线准备,该分支从develop分支创建,创建之后由测试同学发布到测试环境进行测试,测试过程中发现bug需要开发人员在该release分支上进行bug修复,所有bug修复完后,在上线之前,需要合并该release分支到master分支和develop分支。
  • hotfix/*:紧急bug修复分支,该分支只有在紧急情况下使用,从master分支创建,用于紧急修复线上bug,修复完成后,需要合并该分支到master分支以便上线,同时需要再合并到develop分支。

必读文章

团队中的 Git 实践
Git 在团队中的最佳实践–如何正确使用Git Flow

分支命令规范

特性(功能)分支

功能分支的分支名称应该为能够准确描述该功能的英文简要表述

feature/分支名称

例如,开发的功能为 新增商品到物料库,则可以创建名称为 feature/material-add的分支。

bug修复分支、紧急bug修复分支

bug修复分支的分支名称可以为Jira中bug代码或者是描述该bug的英文简称

bugfix/分支名称
hotfix/分支名称

比如,修复的bug在jira中代号为MATERIAL-1,则可以创建一个名为bugfix/MATERIAL-1的分支。

release分支

release分支为预发布分支,命名为本次发布的主要功能英文简称

release/分支名称

比如,本次上线物料库新增的功能,则分支名称可以为release/material-add

常用操作命令简介

基本操作

基本命令这里就不多说了,基本跟以前一样,唯一的区别是注意分支是从哪里拉去的以及分支的命名规范。涉及到的命令主要包含以下,大家自己学习:

  • git commit
  • git add [–all]
  • git push
  • git pull
  • git branch [-d]
  • git merge
  • git cherry-pick
  • git checkout [-b] BRANCH_NAME
  • git stash

分支操作参考 Git常用操作-分支管理

使用git flow简化操作

git flow是git的一个插件,可以极大程度的简化执行git标准分支流程的操作,可以在gitflow-avh安装。

如果是windows下通过安装包安装的git,则该插件默认已经包含,可以直接使用。

初始化

使用git flow init初始化项目

$ git flow init

Which branch should be used for bringing forth production releases?
   - develop
   - feature-fulltext
   - feature-vender
   - master
Branch name for production releases: [master]

Which branch should be used for integration of the "next release"?
   - develop
   - feature-fulltext
   - feature-vender
Branch name for "next release" development: [develop]

How to name your supporting branch prefixes?
Feature branches? [feature/]
Bugfix branches? [bugfix/]
Release branches? [release/]
Hotfix branches? [hotfix/]
Support branches? [support/]
Version tag prefix? []
Hooks and filters directory? [/Users/mylxsw/codes/work/e-business-3.0/.git/hooks]

功能分支

git flow feature
git flow feature start <name>
git flow feature finish <name>
git flow feature delete <name>

git flow feature publish <name>
git flow feature track <name>

功能分支使用例子:

$ git flow feature start material-add
Switched to a new branch 'feature/material-add'

Summary of actions:
- A new branch 'feature/material-add' was created, based on 'develop'
- You are now on branch 'feature/material-add'

Now, start committing on your feature. When done, use:

     git flow feature finish material-add

$ git status
On branch feature/material-add
nothing to commit, working directory clean
$ git flow feature publish
Total 0 (delta 0), reused 0 (delta 0)
To http://dev.oss.yunsom.cn:801/yunsom/e-business-3.0.git
 * [new branch]      feature/material-add -> feature/material-add
Branch feature/material-add set up to track remote branch feature/material-add from origin.
Already on 'feature/material-add'
Your branch is up-to-date with 'origin/feature/material-add'.

Summary of actions:
- The remote branch 'feature/material-add' was created or updated
- The local branch 'feature/material-add' was configured to track the remote branch
- You are now on branch 'feature/material-add'

$ vim README.md
$ git add --all
$ git commit -m "modify readme file "
[feature/material-add 7235bd4] modify readme file
 1 file changed, 1 insertion(+), 2 deletions(-)
$ git push
Counting objects: 3, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 303 bytes | 0 bytes/s, done.
Total 3 (delta 2), reused 0 (delta 0)
To http://dev.oss.yunsom.cn:801/yunsom/e-business-3.0.git
   0d4fb8f..7235bd4  feature/material-add -> feature/material-add
$ git flow feature finish
Switched to branch 'develop'
Your branch is up-to-date with 'origin/develop'.
Updating 0d4fb8f..7235bd4
Fast-forward
 README.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)
To http://dev.oss.yunsom.cn:801/yunsom/e-business-3.0.git
 - [deleted]         feature/material-add
Deleted branch feature/material-add (was 7235bd4).

Summary of actions:
- The feature branch 'feature/material-add' was merged into 'develop'
- Feature branch 'feature/material-add' has been locally deleted; it has been remotely deleted from 'origin'
- You are now on branch 'develop'

$ git branch
* develop
  feature-fulltext
  feature-vender
  master

预发布分支

git flow release
git flow release start <release> [<base>]
git flow release finish <release>
git flow release delete <release>

hotfix分支

git flow hotfix
git flow hotfix start <release> [<base>]
git flow hotfix finish <release>
git flow hotfix delete <release>

git-flow 备忘清单

参考git-flow 备忘清单

总结

如果上面内容太多记不住,也没有关系,作为开发人员,刚开始的时候只要知道以下几点就足够了,其它的可以在碰到的时候再深入学习:

  • 所有的新功能开发,bug修复(非紧急)都要从develop分支拉取新的分支进行开发,开发完成自测没有问题再合并到develop分支
  • release分支发布到测试环境,由开发人员创建release分支(需要测试人员提出需求)并发布到测试环境,如果测试过程中发现bug,需要开发人员track到该release分支修复bug,上线前需要测试人员提交merge requestmaster分支,准备上线,同时需要合并回develop分支。
  • 只有紧急情况下才允许从master上拉取hotfix分支,hotfix分支需要最终同时合并到developmaster分支(共两次merge操作)
  • 除了masterdevelop分支,其它分支在开发完成后都要删除

Unix系统服务监控 Monit

Monit 是Unix系统中用于管理和监控进程、程序、文件、目录和文件系统的工具。使用 Monit 可以检测进程是否正常运行,如果异常可以自动重启服务以及报警,当然,也可以使用 Monit 检查文件和目录是否发生修改,例如时间戳、校验和以及文件大小的改变。

常用操作

Monit 默认的配置文件是~/.monitrc,如果没有该文件,则使用/etc/monitrc文件。在启动 Monit 的时候,可以指定使用的配置文件:

$ monit -c /var/monit/monitrc

在第一次启动 monit 的使用,可以使用如下命令测试配置文件(控制文件)是否正确

$ monit -t
$ Control file syntax OK

如果配置文件没有问题的话,就可以使用monit命令启动 monit 了。

Continue reading →

Linux 配置安装MySQL

废话不多说,虽然可以通过yum直接安装MySQL,但是为了能够对安装过程有一个比较清晰的认识,
我们这里还是使用源码编译安装。

$ wget http://dev.mysql.com/get/Downloads/MySQL-5.6/mysql-5.6.21.tar.gz
$ tar -zxvf mysql-5.6.21.tar.gz
$ cd mysql-5.6.21

文件已经下载并且解压好了,在安装之前,我们需要为mysql建立名为mysql的用户名和用户组。

$ sudo groupadd mysql
$ sudo useradd -r -g mysql mysql

Continue reading →

Scroll Up