Seth Kenlon 发布的文章

用 Gemini 协议发现更安静、更简单的互联网新角落。

如果你很久以前就已经上网了,或者是知识非常丰富,你可能还记得一个早期的文本共享协议,叫做 Gopher。Gopher 最终被 HTTP 协议所取代,当然,HTTP 协议是现代万维网的基础。对于很多人来说,“ 互联网 internet ”和“ 万维网 World Wide Web ”是一回事,因为很多人没有意识到在网上进行了 www 子域下的任何操作。

但一直以来,都有各种网络协议在互联网络上共享信息:Telnet、FTP、SSH、Torrent、GNUnet 等等。最近,在这一系列的替代品中又多了一个,它叫 Gemini

Gemini(双子座)协议,以“水星计划”和“阿波罗计划”的基础实验之间的太空任务命名,旨在和平地处在 Gopher 和 HTTP 之间。无论如何,它的目的并不是要取代现代 Web,但它确实试图创造一个简化的网络和一个现代化的 Gopher。

它的发展历史虽然可能很年轻,但意义重大,原因有很多。当然,人们会因为技术和哲学上的原因而对现代 Web 表示质疑,但它只是一般的臃肿。当你真正想要的是一个非常具体的问题的可靠答案时,那么无数次点击谷歌搜索的结果让人感觉过头了。

许多人使用 Gopher 就是因为这个原因:它的规模小到可以让小众的兴趣很容易找到。然而,Gopher 是一个旧的协议,它对编程、网络和浏览做出了一些假设,但这些假设已经不再适用了。 Gemini 的目标是将最好的网络带入一种类似于 Gopher 但易于编程的格式。一个简单的 Gemini 浏览器可以用几百行代码写成,并且有一个非常好的浏览器用 1600 行左右写成。这对于程序员、学生和极简主义者来说都是一个强大的功能。

如何浏览 Gemini

就像早期的网络一样,Gemini 的规模很小,所以有一个列表列出了运行 Gemini 网站的已知服务器。就像浏览 HTTP 站点需要一个网页浏览器一样,访问 Gemini 站点也需要一个 Gemini 浏览器。在 Gemini 网站上列出了有几个可用的浏览器。

最简单的一个是 AV-98 客户端。它是用 Python 编写的,在终端中运行。要想试试的话,请下载它:

$ git clone https://tildegit.org/solderpunk/AV-98.git

进入下载目录,运行 AV-98:

$ cd AV-98.git
$ python3 ./main.py

客户端是一个交互式的提示符。它有有限的几个命令,主要的命令是简单的 go,后面跟着一个 Gemini 服务器地址。在已知的 Gemini 服务器列表中选择一个看起来很有趣的服务器,然后尝试访问它:

AV-98> go gemini://example.club

Welcome to the example.club Gemini server!

Here are some folders of ASCII art:

[1] Penguins
[2] Wildebeests
[3] Demons

导航是按照编号的链接来进行的。例如,要进入 Penguins 目录,输入 1 然后按回车键:

AV-98> 1

[1] Gentoo
[2] Emperor
[3] Little Blue

要返回,输入 back 并按回车键:

AV-98> back

更多命令,请输入 help

用 Gemini 作为你的 web 替代

Gemini 协议非常简单,初级和中级程序员都可以为其编写客户端,而且它是在互联网上分享内容的一种简单快捷的方式。虽然万维网的无处不在对广泛传播是有利的,但总有替代方案的空间。看看 Gemini,发现更安静、更简单的互联网的新角落。


via: https://opensource.com/article/20/10/gemini-internet-protocol

作者:Seth Kenlon 选题:lujun9972 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

我们将所有的 C 语言要素放置到一份易读的备忘录上。

1972 年, 丹尼斯·里奇 Dennis Ritchie 任职于 贝尔实验室 Bell Labs ,在几年前,他和他的团队成员发明了 Unix 。在创建了一个经久不衰的操作系统(至今仍在使用)之后,他需要一种好的方法来对这些 Unix 计算机编程,以便它们可用执行新的任务。在现在看来,这很奇怪,但在当时,编程语言相对较少,Fortran、Lisp、Algol 以及 B 语言都很流行,但是,对于贝尔实验室的研究员们想要做的事情来说,它们还是远远不够的。丹尼斯·里奇表现出一种后来被称为程序员的主要特征的特质:创造了他自己的解决方案。他称之为 C 语言,并且在近 50 年后,它仍在广泛的使用。

为什么你应该学习 C 语言

今天,有很多语言为程序员提供了比 C 语言更多的特性。最明显的是 C++ 语言,这是一种以相当露骨的方式命名的语言,它构建在 C 语言之上,创建了一种很好的面向对象语言。不过,许多其它语言的存在是有充分理由的。计算机擅长一致的重复,因此任何可预见的东西都可以构建在编程语言中,对程序员来说这意味着更少的工作量。为什么在 C++ 语言中用一行语句就可以将一个 int 转换为一个 long 时(long x = long(n);),还要在 C 语言用两行语句呢?

然而,C 语言在今天仍然有用。

首先,C 语言是一种相当简约和直接的语言。除了编程的基础知识之外,并没有很高级的概念,这很大程度上是因为 C 语言实际上就是现代编程语言的基础之一。例如,C 语言的特性之一是数组,但是它不提供字典(除非你自己写一个)。当你学习 C 语言时,你会学习编程的基础组成部分,它可以帮助你认识到如今的编程语言的改进及其的精心设计。

因为 C 语言是一种最小化的编程语言,你的应用程序很可能会获得性能上的提升,这在其它许多编程语言中是看不到的。当你考虑你的代码可以执行多快的时候,很容易陷入锱铢必较的境地,因此,重要的是要问清楚你是否需要为某一特定任务提供更多的速度。与 Python 或 Java 相比,使用 C 语言,你在每行代码中需要纠结的地方更少。C 语言程序运行很快。这是 Linux 内核使用 C 语言编写的一个很好的理由。

最后,C 语言很容易入门,特别是,如果你正在运行 Linux,就已经能运行 C 语言代码了,因为 Linux 系统包含 GNU C 库(glibc)。为了编写和构建 C 语言程序,你需要做的全部工作就是安装一个编译器,打开一个文本编辑器,开始编码。

开始学习 C 语言

如果你正在运行 Linux ,你可以使用你的软件包管理器安装一个 C 编译器。在 Fedora 或 RHEL 上:

$ sudo dnf install gcc

在 Debian 及其衍生系统上:

$ sudo apt install build-essential

在 macOS 上,你可以 安装 Homebrew ,并使用它来安装 GCC

$ brew install gcc

在 Windows 上, 你可以使用 MinGW 安装一套最小的包含 GCC 的 GNU 实用程序集。

在 Linux 或 macOS 上验证你已经安装的 GCC:

$ gcc --version
gcc (GCC) x.y.z
Copyright (C) 20XX Free Software Foundation, Inc.

在 Windows 上,提供 EXE 文件的完整路径:

PS> C:\MinGW\bin\gcc.exe --version
gcc.exe (MinGW.org GCC Build-2) x.y.z
Copyright (C) 20XX Free Software Foundation, Inc.

C 语法

C 语言不是一种脚本语言。它是一种编译型语言,这意味着它由 C 编译器处理来产生一个二进制可执行文件。这不同于脚本语言(如 Bash)或混合型语言(如 Python)。

在 C 语言中,你可以创建函数来执行你希望做到的任务。默认情况下,执行的是一个名为 main 的函数。

这里是一个使用 C 语言写的简单的 “hello world” 程序:

#include <stdio.h>

int main() {
  printf("Hello world");
  return 0;
}

第一行包含一个被称为 stdio.h(标准输入和输出)的 头文件,它基本上是自由使用的、非常初级的 C 语言代码,你可以在你自己的程序中重复使用它。然后创建了一个由一条基本的输出语句构成的名为 main 的函数。保存这些文本到一个被称为 hello.c 的文件中,然后使用 GCC 编译它:

$ gcc hello.c --output hello

尝试运行你的 C 语言程序:

$ ./hello
Hello world$

返回值

这是 Unix 哲学的一部分,一个函数在执行后“返回”一些东西:在成功时不返回任何东西,在失败时返回其它的一些东西(例如,一个错误信息)。这些返回的内容通常使用数字(确切地说是整数)表示:0 表示没有错误,任何大于 0 的数字都表示一些不成功的状态。

Unix 和 Linux 被设计成在运行成功时保持沉默是很明智的。这是为了让你在执行一系列命令时,假设没有任何错误或警告会妨碍你的工作,从而可以始终为成功执行做准备。类似地,在 C 语言中的函数在设计上也预期不出现错误。

你可以通过一个小的修改,让你的程序看起来是失败的,就可以看到这一点:

include <stdio.h>

int main() {
  printf("Hello world");
  return 1;
}

编译它:

$ gcc hello.c --output failer

现在使用一个内置的 Linux 测试方式来运行它。仅在成功时,&& 操作符才会执行一个命令的第二部分。例如:

$ echo "success" && echo "it worked"
success
it worked

失败时,|| 测试会执行一个命令的第二部分。

$ ls blah || echo "it did not work"
ls: cannot access 'blah': No such file or directory
it did not work

现在,尝试你的程序,在成功时,它返回 0;而是返回 1

$ ./failer && echo "it worked"
String is: hello

这个程序成功地执行了,但是没有触发第二个命令。

变量和类型

在一些语言中,你可以创建变量而不具体指定变量所包含的数据的类型。这些语言如此设计使得解释器需要对一个变量运行一些测试来视图发现变量是什么样的数据类型。例如,var=1 定义了一个整型数,当你创建一个表达式将 var 与某些东西相加时,Python 知道显然它是一个整型数。它同样知道当你连接 helloworld 时,单词 world 是一个字符串。

C 语言不会为你做任何这些识别和调查;你必须自己定义你的变量类型。这里有几种变量类型,包括整型(int),字符型(char),浮点型(float),布尔型(boolean)。

你可能也注意到这里没有字符串类型。与 Python 和 Java 和 Lua 以及其它的编程语言不同,C 语言没有字符串类型,而是将字符串看作一个字符数组。

这里是一些简单的代码,它建立了一个 char 数组变量,然后使用 printf 将数组变量和一段简单的信息打印到你的屏幕上:

#include <stdio.h>

int main() {
   char var[6] = "hello";
   printf("Your string is: %s
",var);
}

你可能会注意到,这个代码示例向一个由五个字母组成的单词提供了六个字符的空间。这是因为在字符串的结尾有处一个隐藏的终止符,它占用了数组中的一个字节。你可以通过编译和执行代码来运行它:

$ gcc hello.c --output hello
$ ./hello
hello

函数

和其它的编程语言一样,C 函数也接受可选的参数。你可以通过定义你希望函数接受的数据类型,来将参数从一个函数传递到另一个函数:

#include <stdio.h>

int printmsg(char a[]) {
   printf("String is: %s
",a);
}

int main() {
   char a[6] = "hello";
   printmsg(a);
   return 0;
}

简单地将一个函数分解为两个函数的这种方法并不是非常有用,但是它演示了默认运行 main 函数以及如何在函数之间传递数据。

条件语句

在真实的编程中,你通常希望你的代码根据数据做出判断。这是使用条件语句完成的,if 语句是其中最基础的一个语句。

为了使这个示例程序更具动态性,你可以包含 string.h 头文件,顾名思义,它包含用于检查字符串的代码。尝试使用来自 string.h 文件中的 strlen 函数测试传递给 printmsg 函数的字符串是否大于 0

#include <stdio.h>
#include <string.h>

int printmsg(char a[]) {
  size_t len = strlen(a);
  if ( len > 0) {
    printf("String is: %s
",a);
  }
}

int main() {
   char a[6] = "hello";
   printmsg(a);
   return 1;
}

正如在这个示例中所实现的,该条件永远都不会是非真的,因为所提供的字符串总是 hello,它的长度总是大于 0。这个不够认真的重新实现的 echo 命令的最后一点要做是接受来自用户的输入。

命令参数

stdio.h 文件包含的代码在每次程序启动时提供了两个参数: 一个是命令中包含多少项的计数(argc),一个是包含每个项的数组(argv)。例如, 假设你发出这个虚构的命令:

$ foo -i bar

argc3argv 的内容是:

  • argv[0] = foo
  • argv[1] = -i
  • argv[2] = bar

你可以修改示例 C 语言程序来以字符串方式接受 argv[2],而不是默认的 hello 吗?

命令式编程语言

C 语言是一种命令式编程语言。它不是面向对象的,也没有类结构。使用 C 语言的经验可以教你很多关于如何处理数据,以及如何更好地管理你的代码运行时生成的数据。多使用 C 语言,你最后能够编写出其它语言(例如 Python 和 Lua)可以使用的库。

想要了解更多关于 C 的知识,你需要使用它。在 /usr/include/ 中查找有用的 C 语言头文件,并且看看你可以做什么小任务来使 C 语言对你有用。在学习的过程中,使用来自 FreeDOS 的 Jim Hall 编写的 C 语言忘备录。它在一张双面纸忘备录上放置了所有的基本要素,所以在你练习时,可以立即访问 C 语言语法的所有要素。


via: https://opensource.com/article/20/8/c-programming-cheat-sheet

作者:Seth Kenlon 选题:lujun9972 译者:robsean 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

无论你的脚本是否成功运行, 信号捕获 trap 都能让它平稳结束。

Shell 脚本的启动并不难被检测到,但 Shell 脚本的终止检测却并不容易,因为我们无法确定脚本会按照预期地正常结束,还是由于意外的错误导致失败。当脚本执行失败时,将正在处理的内容记录下来是非常有用的做法,但有时候这样做起来并不方便。而 Bashtrap 命令的存在正是为了解决这个问题,它可以捕获到脚本的终止信号,并以某种预设的方式作出应对。

响应失败

如果出现了一个错误,可能导致发生一连串错误。下面示例脚本中,首先在 /tmp 中创建一个临时目录,这样可以在临时目录中执行解包、文件处理等操作,然后再以另一种压缩格式进行打包:

#!/usr/bin/env bash
CWD=`pwd`
TMP=${TMP:-/tmp/tmpdir}

## create tmp dir
mkdir "${TMP}"

## extract files to tmp
tar xf "${1}" --directory "${TMP}"

## move to tmpdir and run commands
pushd "${TMP}"
for IMG in *.jpg; do
  mogrify -verbose -flip -flop "${IMG}"
done
tar --create --file "${1%.*}".tar *.jpg

## move back to origin
popd

## bundle with bzip2
bzip2 --compress "${TMP}"/"${1%.*}".tar \
      --stdout > "${1%.*}".tbz

## clean up
/usr/bin/rm -r /tmp/tmpdir

一般情况下,这个脚本都可以按照预期执行。但如果归档文件中的文件是 PNG 文件而不是期望的 JPEG 文件,脚本就会在中途失败,这时候另一个问题就出现了:最后一步删除临时目录的操作没有被正常执行。如果你手动把临时目录删掉,倒是不会造成什么影响,但是如果没有手动把临时目录删掉,在下一次执行这个脚本的时候,它必须处理一个现有的临时目录,里面充满了不可预知的剩余文件。

其中一个解决方案是在脚本开头增加一个预防性删除逻辑用来处理这种情况。但这种做法显得有些暴力,而我们更应该从结构上解决这个问题。使用 trap 是一个优雅的方法。

使用 trap 捕获信号

我们可以通过 trap 捕捉程序运行时的信号。如果你使用过 kill 或者 killall 命令,那你就已经使用过名为 SIGTERM 的信号了。除此以外,还可以执行 trap -ltrap --list 命令列出其它更多的信号:

$ trap --list
 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
16) SIGSTKFLT   17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ
26) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO       30) SIGPWR
31) SIGSYS      34) SIGRTMIN    35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3
38) SIGRTMIN+4  39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8
43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7
58) SIGRTMAX-6  59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
63) SIGRTMAX-1  64) SIGRTMAX

可以被 trap 识别的信号除了以上这些,还包括:

  • EXIT:进程退出时发出的信号
  • ERR:进程以非 0 状态码退出时发出的信号
  • DEBUG:表示调试模式的布尔值

如果要在 Bash 中实现信号捕获,只需要在 trap 后加上需要执行的命令,再加上需要捕获的信号列表就可以了。

例如,下面的这行语句可以捕获到在进程运行时用户按下 Ctrl + C 组合键发出的 SIGINT 信号:

trap "{ echo 'Terminated with Ctrl+C'; }" SIGINT

因此,上文中脚本的缺陷可以通过使用 trap 捕获 SIGINTSIGTERM、进程错误退出、进程正常退出等信号,并正确处理临时目录的方式来修复:

#!/usr/bin/env bash
CWD=`pwd`
TMP=${TMP:-/tmp/tmpdir}

trap \
 "{ /usr/bin/rm -r "${TMP}" ; exit 255; }" \
 SIGINT SIGTERM ERR EXIT

## create tmp dir
mkdir "${TMP}"
tar xf "${1}" --directory "${TMP}"

## move to tmp and run commands
pushd "${TMP}"
for IMG in *.jpg; do
  mogrify -verbose -flip -flop "${IMG}"
done
tar --create --file "${1%.*}".tar *.jpg

## move back to origin
popd

## zip tar
bzip2 --compress $TMP/"${1%.*}".tar \
      --stdout > "${1%.*}".tbz

对于更复杂的功能,还可以用 Bash 函数来简化 trap 语句。

Bash 中的信号捕获

信号捕获可以让脚本在无论是否成功执行所有任务的情况下都能够正确完成清理工作,能让你的脚本更加可靠,这是一个很好的习惯。尽管尝试把信号捕获加入到你的脚本里看看能够起到什么作用吧。


via: https://opensource.com/article/20/6/bash-trap

作者:Seth Kenlon 选题:lujun9972 译者:HankChow 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

使用 Ansible 剧本自动安装和更新设备上的软件。

Ansible 是系统管理员和开发人员用来保持计算机系统处于最佳状态的一种流行的自动化工具。与可扩展框架一样,Ansible 本身功能有限,它真正的功能体现在许多模块中。在某种程度上,Ansible 模块就是 Linux 系统的命令。它们针对特定问题提供解决方案,而维护计算机时的一项常见任务是使所有计算机的更新和一致。

我曾经使用软件包的文本列表来保持系统或多或少的同步:我会列出笔记本电脑上安装的软件包,然后将其与台式机或另一台服务器之间进行交叉参考,手动弥补差异。当然,在 Linux 机器上安装和维护应用程序是 Ansible 的一项基本功能,这意味着你可以在自己关心的计算机上列出所需的内容。

寻找正确的 Ansible 模块

Ansible 模块的数量非常庞大,如何找到能完成你任务的模块?在 Linux 中,你可以在应用程序菜单或 /usr/bin 中查找要运行的应用程序。使用 Ansible 时,你可以参考 Ansible 模块索引

这个索引按照类别列出。稍加搜索,你就很可能找到所需的模块。对于包管理,Packaging 模块几乎适用于所有带包管理器的系统。

动手写一个 Ansible 剧本

首先,选择本地计算机上的包管理器。例如,如果你打算在运行 Fedora 的笔记本电脑上编写 Ansible 指令(在 Ansible 中称为“ 剧本 playbook ”),那么从 dnf 模块开始。如果你在 Elementary OS 上编写,使用 apt 模块,以此类推。这样你就可以开始进行测试和验证,并可以在以后扩展到其它计算机。

第一步是创建一个代表你的剧本的目录。这不是绝对必要的,但这是一个好习惯。Ansible 只需要一个配置文件就可以运行在 YAML 中,但是如果你以后想要扩展剧本,你就可以通过改变目录和文件的方式来控制 Ansible。现在,只需创建一个名为 install_packages 或类似的目录:

$ mkdir ~/install_packages

你可以根据自己的喜好来命名 Ansible 的剧本,但通常将其命名为 site.yml

$ touch ~/install_packages/site.yml

在你最喜欢的文本编辑器中打开 site.yml,添加以下内容:

---
- hosts: localhost
  tasks:
    - name: install packages
      become: true
      become_user: root
      dnf:
        state: present
        name:
         - tcsh
         - htop

你必须调整使用的模块名称以匹配你使用的发行版。在此示例中,我使用 dnf 是因为我在 Fedora Linux 上编写剧本。

就像 Linux 终端中的命令一样,知道 如何 来调用 Ansible 模块就已经成功了一半。这个示例剧本遵循标准剧本格式:

  • hosts 是一台或多台计算机。在本示例中,目标计算机是 localhost,即你当前正在使用的计算机(而不是你希望 Ansible 连接的远程系统)。
  • tasks 是你要在主机上执行的任务列表。

    • name 是任务的人性化名称。在这种情况下,我使用 install packages,因为这就是该任务正在做的事情。
    • become 允许 Ansible 更改运行此任务的用户。
    • become_user 允许 Ansible 成为 root 用户来运行此任务。这是必须的,因为只有 root 用户才能使用 dnf 安装应用程序。
    • dnf 是模块名称,你可以在 Ansible 网站上的模块索引中找到。

dnf 下的节点是 dnf 模块专用的。这是模块文档的关键所在。就像 Linux 命令的手册页一样,模块文档会告诉你可用的选项和所需的参数。

 title=

安装软件包是一个相对简单的任务,仅需要两个元素。state 选项指示 Ansible 检查系统上是否存在 软件包,而 name 选项列出要查找的软件包。Ansible 会针对机器的 状态 进行调整,因此模块指令始终意味着更改。假如 Ansible 扫描了系统状态,发现剧本里描述的系统(在本例中,tcshhtop 存在)与实际状态存在冲突,那么 Ansible 的任务是进行必要的更改来使系统与剧本匹配。Ansible 可以通过 dnf(或 apt 或者其它任何包管理器)模块进行更改。

每个模块可能都有一组不同的选项,所以在编写剧本时,要经常参考模块文档。除非你对模块非常熟悉,否则这是期望模块完成工作的唯一合理方法。

验证 YAML

剧本是用 YAML 编写的。因为 YAML 遵循严格的语法,所以安装 yamllint 来检查剧本是很有帮助的。更妙的是,有一个专门针对 Ansible 的检查工具称为 ansible-lint,它专门为剧本而生。在继续之前,安装它。

在 Fedora 或 CentOs 上:

$ sudo dnf ins tall yamllint python3-ansible-lint

在 Debian、Elementary 或 Ubuntu 上,同样的:

$ sudo apt install yamllint ansible-lint

使用 ansible-link 来验证你的剧本。如果你无法使用 ansible-lint,你可以使用 yamllint

$ ansible-lint ~/install_packages/site.yml

成功则不返回任何内容,但如果文件中有错误,则必须先修复它们,然后再继续。复制和粘贴过程中的常见错误包括在最后一行的末尾省略换行符、使用制表符而不是空格来缩进。在文本编辑器中修复它们,重新运行 ansible-llint,重复这个过程,直到 ansible-lintyamllint 没有返回为止。

使用 Ansible 安装一个应用

现在你有了一个可验证的有效剧本,你终于可以在本地计算机上运行它了,因为你碰巧知道该剧本定义的任务需要 root 权限,所以在调用 Ansible 时必须使用 --ask-become-pass 选项,因此系统会提示你输入管理员密码。

开始安装:

$ ansible-playbook --ask-become-pass ~/install_packages/site.yml
BECOME password:
PLAY [localhost] ******************************

TASK [Gathering Facts] ******************************
ok: [localhost]

TASK [install packages] ******************************
ok: [localhost]

PLAY RECAP ******************************
localhost: ok=0 changed=2 unreachable=0 failed=0 [...]

这些命令被执行后,目标系统将处于与剧本中描述的相同的状态。

在远程系统上安装应用程序

通过这么多操作来替换一个简单的命令可能会适得其反,但是 Ansible 的优势是它可以在你的所有系统中实现自动化。你可以使用条件语句使 Ansible 在不同的系统上使用特定的模块,但是现在,假定所有计算机都使用相同的包管理器。

要连接到远程系统,你必须在 /etc/ansible/hosts 文件中定义远程系统,该文件与 Ansible 是一起安装的,所以它已经存在了,但它可能是空的,除了一些解释性注释之外。使用 sudo 在你喜欢的文本编辑器中打开它。

你可以通过其 IP 地址或主机名(只要主机名可以解析)定义主机。例如,如果你已经在 /etc/hosts 中定义了 liavara 并可以成功 ping 通,那么你可以在 /etc/ansible/hosts 中将 liavara 设置为主机。或者,如果你正在运行一个域名服务器或 Avahi 服务器并且可以 pingliavara,那么你就可以在 /etc/ansible/hosts 中定义它。否则,你必须使用它的 IP 地址。

你还必须成功地建立与目标主机的安全 shell(SSH)连接。最简单的方法是使用 ssh-copy-id 命令,但是如果你以前从未与主机建立 SSH 连接,阅读我关于如何创建自动 SSH 连接的文章

一旦你在 /etc/ansible/hosts 文件中输入了主机名或 IP 地址后,你就可以在剧本中更改 hosts 定义:

---
- hosts: all
  tasks:
    - name: install packages
      become: true
      become_user: root
      dnf:
        state: present
        name:
         - tcsh
         - htop

再次运行 ansible-playbook

$ ansible-playbook --ask-become-pass ~/install_packages/site.yml

这次,剧本会在你的远程系统上运行。

如果你添加更多主机,则有许多方法可以过滤哪个主机执行哪个任务。例如,你可以创建主机组(服务器的 webserves,台式机的 workstations等)。

适用于混合环境的 Ansible

到目前为止,我们一直假定 Ansible 配置的所有主机都运行相同的操作系统(都是是使用 dnf 命令进行程序包管理的操作系统)。那么,如果你要管理不同发行版的主机,例如 Ubuntu(使用 apt)或 Arch(使用 pacman),或者其它的操作系统时,该怎么办?

只要目标操作系统具有程序包管理器(MacOs 有 HomebrewWindows 有 Chocolatey),Ansible 就能派上用场。

这就是 Ansible 优势最明显的地方。在 shell 脚本中,你必须检查目标主机上有哪些可用的包管理器,即使使用纯 Python,也必须检查操作系统。Ansible 不仅内置了这些功能,而且还具有在剧本中使用命令结果的机制。你可以使用 action 关键字来执行由 Ansible 事实收集子系统提供的变量定义的任务,而不是使用 dnf 模块。

---
- hosts: all
  tasks:
    - name: install packages
      become: true
      become_user: root
      action: >
       {{ ansible_pkg_mgr }} name=htop,transmission state=present update_cache=yes

action 关键字会加载目标插件。在本例中,它使用了 ansible_pkg_mgr 变量,该变量由 Ansible 在初始 收集信息 期间填充。你不需要告诉 Ansible 收集有关其运行操作系统的事实,所以很容易忽略这一点,但是当你运行一个剧本时,你会在默认输出中看到它:

TASK [Gathering Facts] *****************************************
ok: [localhost]

action 插件使用来自这个探针的信息,使用相关的包管理器命令填充 ansible_pkg_mgr,以安装在 name 参数之后列出的程序包。使用 8 行代码,你可以克服在其它脚本选项中很少允许的复杂跨平台难题。

使用 Ansible

现在是 21 世纪,我们都希望我们的计算机设备能够互联并且相对一致。无论你维护的是两台还是 200 台计算机,你都不必一次又一次地执行相同的维护任务。使用 Ansible 来同步生活中的计算机设备,看看 Ansible 还能为你做些什么。


via: https://opensource.com/article/20/9/install-packages-ansible

作者:Seth Kenlon 选题:lujun9972 译者:MjSeven 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

下载我们的电子书,学习如何更好地使用 awk

在众多 Linux 命令中,sedawkgrep 恐怕是其中最经典的三个命令了。它们引人注目或许是由于名字发音与众不同,也可能是它们无处不在,甚至是因为它们存在已久,但无论如何,如果要问哪些命令很有 Linux 风格,这三个命令是当之无愧的。其中 sedgrep 已经有很多简洁的标准用法了,但 awk 的使用难度却相对突出。

在日常使用中,通过 sed 实现字符串替换、通过 grep 实现过滤,这些都是司空见惯的操作了,但 awk 命令相对来说是用得比较少的。在我看来,可能的原因是大多数人都只使用 sed 或者 grep 的一些变化实现某些功能,例如:

$ sed -e 's/foo/bar/g' file.txt
$ grep foo file.txt

因此,尽管你可能会觉得 sedgrep 使用起来更加顺手,但实际上它们还有更多更强大的作用没有发挥出来。当然,我们没有必要在这两个命令上钻研得很深入,但我有时会好奇自己“学习”命令的方式。很多时候我会记住一整串命令“咒语”,而不会去了解其中的运作过程,这就让我产生了一种很熟悉命令的错觉,我可以随口说出某个命令的好几个选项参数,但这些参数具体有什么作用,以及它们的相关语法,我都并不明确。

这大概就是很多人对 awk 缺乏了解的原因了。

为使用而学习 awk

awk 并不深奥。它是一种相对基础的编程语言,因此你可以把它当成一门新的编程语言来学习:使用一些基本命令来熟悉语法、了解语言中的关键字并实现更复杂的功能,然后再多加练习就可以了。

awk 是如何解析输入内容的

awk 的本质是将输入的内容看作是一个数组。当 awk 扫描一个文本文件时,会把每一行作为一条 记录 record ,每一条记录中又分割为多个 字段 field awk 记录了各条记录各个字段的信息,并通过内置变量 NR(记录数) 和 NF(字段数) 来调用相关信息。例如一下这个命令可以查看文件的行数:

$ awk 'END { print NR;}' example.txt
36

从上面的命令可以看出 awk 的基本语法,无论是一个单行命令还是一整个脚本,语法都是这样的:

模式或关键字 { 操作 }

在上面的例子中,END 是一个关键字而不是模式,与此类似的另一个关键字是 BEGIN。使用 BEGINEND 可以让 awk 在解析内容前或解析内容后执行大括号中指定的操作。

你可以使用 模式 pattern 作为过滤器或限定符,这样 awk 只会对匹配模式的对应记录执行指定的操作。以下这个例子就是使用 awk 实现 grep 命令在文件中查找“Linux”字符串的功能:

$ awk '/Linux/ { print $0; }' os.txt
OS: CentOS Linux (10.1.1.8)
OS: CentOS Linux (10.1.1.9)
OS: Red Hat Enterprise Linux (RHEL) (10.1.1.11)
OS: Elementary Linux (10.1.2.4)
OS: Elementary Linux (10.1.2.5)
OS: Elementary Linux (10.1.2.6)

awk 会将文件中的每一行作为一条记录,将一条记录中的每个单词作为一个字段,默认情况下会以空格作为 字段分隔符 field separator FS)切割出记录中的字段。如果想要使用其它内容作为分隔符,可以使用 --field-separator 选项指定分隔符:

$ awk --field-separator ':' '/Linux/ { print $2; }' os.txt
 CentOS Linux (10.1.1.8)
 CentOS Linux (10.1.1.9)
 Red Hat Enterprise Linux (RHEL) (10.1.1.11)
 Elementary Linux (10.1.2.4)
 Elementary Linux (10.1.2.5)
 Elementary Linux (10.1.2.6)

在上面的例子中,可以看到在 awk 处理后每一行的行首都有一个空格,那是因为在源文件中每个冒号(:)后面都带有一个空格。和 cut 有所不同的是,awk 可以指定一个字符串作为分隔符,就像这样:

$ awk --field-separator ': ' '/Linux/ { print $2; }' os.txt
CentOS Linux (10.1.1.8)
CentOS Linux (10.1.1.9)
Red Hat Enterprise Linux (RHEL) (10.1.1.11)
Elementary Linux (10.1.2.4)
Elementary Linux (10.1.2.5)
Elementary Linux (10.1.2.6)

awk 中的函数

可以通过这样的语法在 awk 中自定义函数:

函数名称(参数) { 操作 }

函数的好处在于只需要编写一次就可以多次复用,因此函数在脚本中起到的作用会比在构造单行命令时大。同时 awk 自身也带有很多预定义的函数,并且工作原理和其它编程语言或电子表格一样。你只需要了解函数需要接受什么参数,就可以放心使用了。

awk 中提供了数学运算和字符串处理的相关函数。数学运算函数通常比较简单,传入一个数字,它就会传出一个结果:

$ awk 'BEGIN { print sqrt(1764); }'
42

而字符串处理函数则稍微复杂一点,但 GNU awk 手册中也有充足的文档。例如 split() 函数需要传入一个待分割的单一字段、一个用于存放分割结果的数组,以及用于分割的 定界符 delimiter

例如前面示例中的输出内容,每条记录的末尾都包含了一个 IP 地址。由于变量 NF 代表的是每条记录的字段数量,刚好对应的是每条记录中最后一个字段的序号,因此可以通过引用 NF 将每条记录的最后一个字段传入 split() 函数:

$ awk --field-separator ': ' '/Linux/ { split($NF, IP, "."); print "subnet: " IP[3]; }' os.txt
subnet: 1
subnet: 1
subnet: 1
subnet: 2
subnet: 2
subnet: 2

还有更多的函数,没有理由将自己限制在每个 awk 代码块中。你可以在终端中使用 awk 构建复杂的管道,也可以编写 awk 脚本来定义和使用你自己的函数。

下载电子书

使用 awk 本身就是一个学习 awk 的过程,即使某些操作使用 sedgrepcuttr 命令已经完全足够了,也可以尝试使用 awk 来实现。只要熟悉了 awk,就可以在 Bash 中自定义一些 awk 函数,进而解析复杂的数据。

下载我们的这本电子书(需注册)学习并开始使用 awk 吧!


via: https://opensource.com/article/20/9/awk-ebook

作者:Seth Kenlon 选题:lujun9972 译者:HankChow 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

来了解一下 printf ,一个神秘的、灵活的和功能丰富的函数,可以替换 echo、print 和 cout。

当我开始学习 Unix 时,我很早就接触到了 echo 命令。同样,我最初的 Python 课程也涉及到了 print 函数。再想起学习 C++ 和 Java 时学到 coutsystemout。似乎每种语言都骄傲地宣称拥有一种方便的单行输出方法,并生怕这种方式要过时一样宣传它。

但是当我翻开中级教程的第一页后,我遇到了 printf,一个晦涩难懂的、神秘莫测的,又出奇灵活的函数。本文一反向初学者隐藏 printf 这个令人费解的传统,旨在介绍这个不起眼的 printf 函数,并解释如何在几乎所有语言中使用它。

printf 简史

术语 printf 代表“ 格式化打印 print formatted ”,它可能最早出现 Algol 68 编程语言中。自从它被纳入到 C 语言后,printf 已经在 C++、Java、Bash、PHP 中一次次重新实现,并且很可能在你最喜欢的 “后 C” 语言中再次出现。

显然,它很受欢迎,但很多人认为它的语法很复杂,尤其是与 echoprintcout 等替代的函数相比尤为明显。例如,这是在 Bash 中的一个简单的 echo 语句:

$ echo hello
hello
$

这是在 Bash 中使用 printf 得到同样结果:

$ printf "%s\n" hello
hello
$

但是所增加的复杂性反而让你拥有很多功能,这是为什么 printf 值得学习的确切原因。

printf 输出

printf 背后的基本思想是:它能够基于与内容分离的样式信息来格式化输出。例如,这里是 printf 认可的视作特殊字符的特定序列集合。你喜欢的语言可能会有或多或少的序列,但是通常包含:

  • \n: 新行
  • \r: 回车换行
  • \t: 水平制表符
  • \NNN: 一个包含一个到三个数字,使用八进制值表示的特殊字节

例如:

$ printf "\t\123\105\124\110\n"
     SETH
$

在这个 Bash 示例中, printf 渲染一个制表符后,然后是分配给四个八进制值字符串的 ASCII 字符,并以一个生成一个新行(\n)的控制序列结束。

如果同样使用 echo 来输出会产生更多的字符:

$ echo "\t\123\105\124\110\n"
\t\123\105\124\110\n
$

使用 Python 的 print 函数来完成同样的任务,你会发现 Python 的 print 命令比你想象的要强大:

>>> print("\t\123\n")
        S

>>>

显然,Python 的 print 包含传统的 printf 特性以及简单的 echocout 的特性。

不过,这些示例包括的只是文字字符,尽管在某些情况下它们也很有用,但它们可能是 printf 最不重要的部分。printf 的真正的威力在于格式化说明。

使用 printf 格式化输出

格式化说明符是以一个百分号(%)开头的字符。

常见的格式化说明符包括:

  • %s: 字符串
  • %d: 数字
  • %f: 浮点数字
  • %o: 一个八进制的数字

这些格式化说明符是 printf 语句的占位符,你可以使用一个在其它地方提供的值来替换你的 printf 语句中的占位符。这些值在哪里提供取决于你使用的语言和它的语法,这里有一个简单的 Java 例子:

string var="hello\n";
system.out.printf("%s", var);

把这个代码包裹在适当的样板文件中,在执行后,将呈现:

$ ./example
hello
$

但是,当一个变量的内容更改时,有意思的地方就来了。假设你想基于不断增加的数字来更新输出:

#include <stdio.h>

int main() {
  int var=0;
  while ( var < 100) {
    var++;
  printf("Processing is %d% finished.\n", var);
  }
  return 0;
}

编译并运行:

Processing is 1% finished.
[...]
Processing is 100% finished.

注意,在代码中的两个 % 将被解析为一个打印出来的 % 符号。

使用 printf 限制小数位数

数字也可以是很复杂,printf 提供很多格式化选项。你可以对浮点数使用 %f 限制打印出多少个小数位。通过把一个点(.)和一个限制的数放置在百分符号和 f 之间, 你可以告诉 printf 打印多少位小数。这是一个简单的用 Bash 写的简练示例:

$ printf "%.2f\n" 3.141519
3.14
$

类似的语法也适用于其它的语言。这里是一个 C 语言的示例:

#include <math.h>
#include <stdio.h>

int main() {
  fprintf(stdout, "%.2f\n", 4 * atan(1.0));
  return 0;
}

对于三位小数,使用 .3f ,依次类推。

使用 printf 来在数字上添加逗号

因为位数大的数字很难解读,所以通常使用一个逗号来断开大的数字。你可以在百分号和 d 之间放置一个撇号('),让 printf 根据需要添加逗号:

$ printf "%'d\n" 1024
1,024
$ printf "%'d\n" 1024601
1,024,601
$

使用 printf 来添加前缀零

printf 的另一个常用的用法是对文件名称中的数字强制实行一种特定的格式。例如,如果你在一台计算机上有 10 个按顺序排列的文件,计算机可能会把 10.jpg 排在 1.jpg 之前,这可能不是你的本意。当你以编程的方式写一个到文件时,你可以使用 printf 来用前缀为 0 的字符形成文件名称。这是一个简单的用 Bash 写的简练示例:

$ printf "%03d.jpg\n" {1..10}
001.jpg
002.jpg
[...]
010.jpg

注意:每个数字最多使用 3 位数字。

使用 printf

正如这些 printf 示例所显示,包括控制字符,尤其是 \n ,可能会冗长,并且语法相对复杂。这就是为什么开发像 echocout 之类的快捷方式的原因。不过,如果你时不时地使用 printf ,你就会习惯于这种语法,并且它也会变成你的习惯。我不认为 printf 有任何理由成为你在日常活动中打印时的首选,但是它是一个很好的工具,当你需要它时,它不会拖累你。

花一些时间学习你所选择语言中的 printf,并且当你需要时就使用它。它是一个强有力的工具,你不会后悔随时可用的工具。


via: https://opensource.com/article/20/8/printf

作者:Seth Kenlon 选题:lujun9972 译者:robsean 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出