分类 技术 下的文章

一直以来在查对条件是否匹配时,我们使用的都是简单的表达式。那如果你想用超过一个表达式来查对特定的条件呢?

本文中,我们将看看如何在过滤文本和字符串时,结合多个表达式,即复合表达式,用以查对条件。

awk 的复合表达式可由表示“与”的组合操作符 && 和表示“或”的 || 构成。

复合表达式的常规写法如下:

( 第一个表达式 ) && ( 第二个表达式 )

这里只有当“第一个表达式” 和“第二个表达式”都是真值时整个表达式才为真。

( 第一个表达式 ) || ( 第二个表达式) 

这里只要“第一个表达式” 为真或“第二个表达式”为真,整个表达式就为真。

注意:切记要加括号。

表达式可以由比较操作符构成,具体可查看 awk 系列的第四节

现在让我们通过一个例子来加深理解:

此例中,有一个文本文件 tecmint_deals.txt,文本中包含着一张随机的 Tecmint 交易清单,其中包含了名称、价格和种类。

TecMint Deal List
No      Name                                    Price           Type
1       Mac_OS_X_Cleanup_Suite                  $9.99           Software
2       Basics_Notebook                         $14.99          Lifestyle
3       Tactical_Pen                            $25.99          Lifestyle
4       Scapple                                 $19.00          Unknown
5       Nano_Tool_Pack                          $11.99          Unknown
6       Ditto_Bluetooth_Altering_Device         $33.00          Tech
7       Nano_Prowler_Mini_Drone                 $36.99          Tech 

我们只想打印出价格超过 $20 且其种类为 “Tech” 的物品,在其行末用 (*) 打上标记。

我们将要执行以下命令。

# awk '($3 ~ /^\$[2-9][0-9]*\.[0-9][0-9]$/) && ($4=="Tech") { printf "%s\t%s\n",$0,"*"; } ' tecmint_deals.txt 

6   Ditto_Bluetooth_Altering_Device     $33.00      Tech    *
7   Nano_Prowler_Mini_Drone         $36.99          Tech     *

此例,在复合表达式中我们使用了两个表达式:

  • 表达式 1:($3 ~ /^\$[2-9][0-9]*\.[0-9][0-9]$/) ;查找交易价格超过 $20 的行,即只有当 $3 也就是价格满足 /^\$[2-9][0-9]*\.[0-9][0-9]$/ 时值才为真值。
  • 表达式 2:($4 == “Tech”) ;查找是否有种类为 “Tech”的交易,即只有当 $4 等于 “Tech” 时值才为真值。 切记,只有当 && 操作符的两端状态,也就是两个表达式都是真值的情况下,这一行才会被打上 (*) 标志。

总结

有些时候为了真正符合你的需求,就不得不用到复合表达式。当你掌握了比较和复合表达式操作符的用法之后,复杂的文本或字符串过滤条件也能轻松解决。

希望本向导对你有所帮助,如果你有任何问题或者补充,可以在下方发表评论,你的问题将会得到相应的解释。


via: http://www.tecmint.com/combine-multiple-expressions-in-awk/

作者:Aaron Kili 译者:martin2011qi 校对:wxy

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

作为一个 Ubuntu 16.04 LTS 的初学者。如何在 Ubuntu 14.04 和 16.04 的主机上搭建网桥呢?

顾名思义,网桥的作用是通过物理接口连接内部和外部网络。对于虚拟端口或者 LXC/KVM/Xen/容器来说,这非常有用。网桥虚拟端口看起来是网络上的一个常规设备。在这个教程中,我将会介绍如何在 Ubuntu 服务器上通过 bridge-utils (brctl) 命令行来配置 Linux 网桥。

网桥化的网络示例

图 01: Kvm/Xen/LXC 容器网桥示例 (br0)

在这个例子中,eth0 和 eth1 是物理网络接口。eth0 连接着局域网,eth1 连接着上游路由器和互联网。

安装 bridge-utils

使用 apt-get 命令 安装 bridge-utils:

$ sudo apt-get install bridge-utils

或者

$ sudo apt install bridge-utils

样例输出:

图 02: Ubuntu 安装 bridge-utils 包

在 Ubuntu 服务器上创建网桥

使用你熟悉的文本编辑器修改 /etc/network/interfaces ,例如 vi 或者 nano :

$ sudo cp /etc/network/interfaces /etc/network/interfaces.bakup-1-july-2016
$ sudo vi /etc/network/interfaces

接下来设置 eth1 并且将它映射到 br1 ,输入如下(删除或者注释所有 eth1 相关配置):

### br1 使用静态公网 IP 地址,并以 ISP 的路由器作为网关
auto br1
iface br1 inet static
        address 208.43.222.51
        network 255.255.255.248
        netmask 255.255.255.0
        broadcast 208.43.222.55
        gateway 208.43.222.49
        bridge_ports eth1
        bridge_stp off
        bridge_fd 0
        bridge_maxwait 0

接下来设置 eth0 并将它映射到 br0,输入如下(删除或者注释所有 eth0 相关配置):

auto br0
iface br0 inet static
        address 10.18.44.26
        netmask 255.255.255.192
        broadcast 10.18.44.63
        dns-nameservers 10.0.80.11 10.0.80.12
        # set static route for LAN
        post-up route add -net 10.0.0.0 netmask 255.0.0.0 gw 10.18.44.1
        post-up route add -net 161.26.0.0 netmask 255.255.0.0 gw 10.18.44.1
        bridge_ports eth0
        bridge_stp off
        bridge_fd 0
        bridge_maxwait 0

关于 br0 和 DHCP 的一点说明

如果使用 DHCP ,配置选项是这样的:

auto br0
iface br0 inet dhcp
        bridge_ports eth0
        bridge_stp off
        bridge_fd 0
        bridge_maxwait 0

保存并且关闭文件。

重启服务器或者网络服务

你需要重启服务器或者输入下列命令来重启网络服务(在 SSH 登录的会话中这可能不管用):

$ sudo systemctl restart networking

如果你证使用 Ubuntu 14.04 LTS 或者更老的没有 systemd 的系统,输入:

$ sudo /etc/init.d/restart networking

验证网络配置成功

使用 ping/ip 命令来验证 LAN 和 WAN 网络接口运行正常:

### 查看 br0 和 br1
ip a show
### 查看路由信息
ip r
### ping 外部站点
ping -c 2 cyberciti.biz
### ping 局域网服务器
ping -c 2 10.0.80.12

样例输出:

图 03: 验证网桥的以太网连接

现在,你就可以配置 br0 和 br1 来让 XEN/KVM/LXC 容器访问因特网或者私有局域网了。再也没有必要去设置特定路由或者 iptables 的 SNAT 规则了。


via: http://www.cyberciti.biz/faq/how-to-create-bridge-interface-ubuntu-linux/

作者:VIVEK GITE 译者:MikeCoder 校对:wxy

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

对于 使用 awk 命令的用户来说,处理一行文本中的数字或者字符串时,使用比较运算符来过滤文本和字符串是十分方便的。

在 awk 系列的此部分中,我们将探讨一下如何使用比较运算符来过滤文本或者字符串。如果你是程序员,那么你应该已经熟悉了比较运算符;对于其它人,下面的部分将介绍比较运算符。

awk 中的比较运算符是什么?

awk 中的比较运算符用于比较字符串和或者数值,包括以下类型:

  • > – 大于
  • < – 小于
  • >= – 大于等于
  • <= – 小于等于
  • == – 等于
  • != – 不等于
  • some_value ~ / pattern/ – 如果 some\_value 匹配模式 pattern,则返回 true
  • some_value !~ / pattern/ – 如果 some\_value 不匹配模式 pattern,则返回 true

现在我们通过例子来熟悉 awk 中各种不同的比较运算符。

在这个例子中,我们有一个文件名为 food\_list.txt 的文件,里面包括不同食物的购买列表。我想给食物数量小于或等于 30 的物品所在行的后面加上(**)

File – food_list.txt
No      Item_Name               Quantity        Price
1       Mangoes                    45           $3.45
2       Apples                     25           $2.45
3       Pineapples                 5            $4.45
4       Tomatoes                   25           $3.45
5       Onions                     15           $1.45
6       Bananas                    30           $3.45

Awk 中使用比较运算符的通用语法如下:

# 表达式 { 动作; }

为了实现刚才的目的,执行下面的命令:

# awk '$3 <= 30 { printf "%s\t%s\n", $0,"**" ; } $3 > 30 { print $0 ;}' food_list.txt

No  Item_Name`      Quantity    Price
1   Mangoes            45       $3.45
2   Apples             25       $2.45   **
3   Pineapples         5        $4.45   **
4   Tomatoes           25       $3.45   **
5   Onions             15       $1.45   **
6   Bananas            30       $3.45   **

在刚才的例子中,发生如下两件重要的事情:

  • 第一个“表达式 {动作;}”组合中, $3 <= 30 { printf “%s\t%s\n”, $0,”**” ; } 打印出数量小于等于30的行,并且在后面增加(**)。物品的数量是通过 $3 这个域变量获得的。
  • 第二个“表达式 {动作;}”组合中, $3 > 30 { print $0 ;} 原样输出数量小于等于 30 的行。

再举一个例子:

# awk '$3 <= 20 { printf "%s\t%s\n", $0,"TRUE" ; } $3 > 20  { print $0 ;} ' food_list.txt 

No    Item_Name     Quantity    Price
1     Mangoes          45       $3.45
2     Apples           25       $2.45
3     Pineapples        5       $4.45 TRUE
4     Tomatoes         25       $3.45
5     Onions           15       $1.45 TRUE
6     Bananas          30       $3.45

在这个例子中,我们想通过在行的末尾增加 (TRUE) 来标记数量小于等于20的行。

总结

这是一篇对 awk 中的比较运算符介绍性的指引,因此你需要尝试其他选项,发现更多使用方法。

如果你遇到或者想到任何问题,请在下面评论区留下评论。请记得阅读 awk 系列下一部分的文章,那里我将介绍组合表达式。


via: http://www.tecmint.com/comparison-operators-in-awk/

作者:Aaron Kili 译者:chunyang-wen 校对:wxy

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

你知道 OpenCV 可以识别在图片中小猫的脸吗?而且是拿来就能用,不需要其它的库之类的。

之前我也不知道。

但是在 Kendrick Tan 曝出这个功能后,我需要亲自体验一下……去看看到 OpenCV 是如何在我没有察觉到的情况下,将这一个功能添加进了他的软件库(就像一只悄悄溜进空盒子的猫咪一样,等待别人发觉)。

下面,我将会展示如何使用 OpenCV 的猫咪检测器在图片中识别小猫的脸。同样的,该技术也可以用在视频流中。

使用 OpenCV 在图片中检测猫咪

如果你查找过 OpenCV 的代码仓库,尤其是在 haarcascades 目录里(OpenCV 在这里保存处理它预先训练好的 Haar 分类器,以检测各种物体、身体部位等), 你会看到这两个文件:

  • haarcascade\_frontalcatface.xml
  • haarcascade\_frontalcatface\_extended.xml

这两个 Haar Cascade 文件都将被用来在图片中检测小猫的脸。实际上,我使用了相同的 cascades 分类器来生成这篇博文顶端的图片。

在做了一些调查工作之后,我发现这些 cascades 分类器是由鼎鼎大名的 Joseph Howse 训练和贡献给 OpenCV 仓库的,他写了很多很棒的教程和书籍,在计算机视觉领域有着很高的声望。

下面,我将会展示给你如何使用 Howse 的 Haar cascades 分类器来检测图片中的小猫。

猫咪检测代码

让我们开始使用 OpenCV 来检测图片中的猫咪。新建一个叫 cat\_detector.py 的文件,并且输入如下的代码:

# import the necessary packages
import argparse
import cv2

# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--image", required=True,
    help="path to the input image")
ap.add_argument("-c", "--cascade",
    default="haarcascade_frontalcatface.xml",
    help="path to cat detector haar cascade")
args = vars(ap.parse_args())

第 2 和第 3 行主要是导入了必要的 python 包。6-12 行用于解析我们的命令行参数。我们仅要求一个必需的参数 --image ,它是我们要使用 OpenCV 检测猫咪的图片。

我们也可以(可选的)通过 --cascade 参数指定我们的 Haar cascade 分类器的路径。默认使用 haarcascades_frontalcatface.xml,假定这个文件和你的 cat_detector.py 在同一目录下。

注意:我已经打包了猫咪的检测代码,还有在这个教程里的样本图片。你可以在博文原文的 “下载” 部分下载到。如果你是刚刚接触 Python+OpenCV(或者 Haar cascade),我建议你下载这个 zip 压缩包,这个会方便你跟着教程学习。

接下来,就是检测猫的时刻了:

# load the input image and convert it to grayscale
image = cv2.imread(args["image"])
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# load the cat detector Haar cascade, then detect cat faces
# in the input image
detector = cv2.CascadeClassifier(args["cascade"])
rects = detector.detectMultiScale(gray, scaleFactor=1.3,
    minNeighbors=10, minSize=(75, 75))

在 15、16 行,我们从硬盘上读取了图片,并且进行灰度化(这是一个在将图片传给 Haar cascade 分类器之前的常用的图片预处理步骤,尽管不是必须的)

20 行,从硬盘加载 Haar casacade 分类器,即猫咪检测器,并且实例化 cv2.CascadeClassifier 对象。

在 21、22 行通过调用 detectordetectMultiScale 方法使用 OpenCV 完成猫脸检测。我们给 detectMultiScale 方法传递了四个参数。包括:

  1. 图片 gray,我们要在该图片中检测猫脸。
  2. 检测猫脸时的图片金字塔 的检测粒度 scaleFactor 。更大的粒度将会加快检测的速度,但是会对检测 准确性 true-positive 产生影响。相反的,一个更小的粒度将会影响检测的时间,但是会增加 准确性 true-positive 。但是,细粒度也会增加 误报率 false-positive 。你可以看这篇博文的“ Haar cascades 注意事项”部分来获得更多的信息。
  3. minNeighbors 参数控制了检定框的最少数量,即在给定区域内被判断为猫脸的最少数量。这个参数可以很好的排除 误报 false-positive 结果。
  4. 最后,minSize 参数不言自明。这个值描述每个检定框的最小宽高尺寸(单位是像素),这个例子中就是 75*75

detectMultiScale 函数会返回 rects,这是一个 4 元组列表。这些元组包含了每个检测到的猫脸的 (x,y) 坐标值,还有宽度、高度。

最后,让我们在图片上画下这些矩形来标识猫脸:

# loop over the cat faces and draw a rectangle surrounding each
for (i, (x, y, w, h)) in enumerate(rects):
    cv2.rectangle(image, (x, y), (x + w, y + h), (0, 0, 255), 2)
    cv2.putText(image, "Cat #{}".format(i + 1), (x, y - 10),
        cv2.FONT_HERSHEY_SIMPLEX, 0.55, (0, 0, 255), 2)

# show the detected cat faces
cv2.imshow("Cat Faces", image)
cv2.waitKey(0)

给我们这些框(比如,rects)的数据,我们在 25 行依次遍历它。

在 26 行,我们在每张猫脸的周围画上一个矩形。27、28 行展示了一个整数,即图片中猫咪的数量。

最后,31,32 行在屏幕上展示了输出的图片。

猫咪检测结果

为了测试我们的 OpenCV 猫咪检测器,可以在原文的最后,下载教程的源码。

然后,在你解压缩之后,你将会得到如下的三个文件/目录:

  1. cat\_detector.py:我们的主程序
  2. haarcascade\_frontalcatface.xml: 猫咪检测器 Haar cascade
  3. images:我们将会使用的检测图片目录。

到这一步,执行以下的命令:

$ python cat_detector.py --image images/cat_01.jpg

图 1. 在图片中检测猫脸,甚至是猫咪部分被遮挡了。

注意,我们已经可以检测猫脸了,即使它的其余部分是被遮挡的。

试下另外的一张图片:

python cat_detector.py --image images/cat_02.jpg

图 2. 使用 OpenCV 检测猫脸的第二个例子,这次猫脸稍有不同。

这次的猫脸和第一次的明显不同,因为它正在发出“喵呜”叫声的当中。这种情况下,我们依旧能检测到正确的猫脸。

在下面这张图片的结果也是正确的:

$ python cat_detector.py --image images/cat_03.jpg

图 3. 使用 OpenCV 和 python 检测猫脸

我们最后的一个样例就是在一张图中检测多张猫脸:

$ python cat_detector.py --image images/cat_04.jpg

图 4. 在同一张图片中使用 OpenCV 检测多只猫

注意,Haar cascade 返回的检定框不一定是以你预期的顺序。这种情况下,中间的那只猫会被标记成第三只。你可以通过判断他们的 (x, y) 坐标来自己排序这些检定框。

关于精度的说明

在这个 xml 文件中的注释非常重要,Joseph Hower 提到了这个猫脸检测器有可能会将人脸识别成猫脸。

这种情况下,他推荐使用两种检测器(人脸 & 猫脸),然后将出现在人脸识别结果中的结果剔除掉。

Haar cascades 注意事项

这个方法首先出现在 Paul Viola 和 Michael Jones 2001 年出版的 Rapid Object Detection using a Boosted Cascade of Simple Features 论文中。现在它已经成为了计算机识别领域引用最多的论文之一。

这个算法能够识别图片中的对象,无论它们的位置和比例。而且最令人感兴趣的或许是它能在现有的硬件条件下实现实时检测。

在他们的论文中,Viola 和 Jones 关注在训练人脸检测器;但是,这个框架也能用来检测各类事物,如汽车、香蕉、路标等等。

问题是?

Haar cascades 最大的问题就是如何确定 detectMultiScale 方法的参数正确。特别是 scaleFactorminNeighbors 参数。你很容易陷入一张一张图片调参数的坑,这个就是该对象检测器很难被实用化的原因。

这个 scaleFactor 变量控制了用来检测对象的图片的各种比例的图像金字塔。如果 scaleFactor 参数过大,你就只需要检测图像金字塔中较少的层,这可能会导致你丢失一些在图像金字塔层之间缩放时少了的对象。

换句话说,如果 scaleFactor 参数过低,你会检测过多的金字塔图层。这虽然可以能帮助你检测到更多的对象。但是他会造成计算速度的降低,还会明显提高误报率。Haar cascades 分类器就是这样。

为了避免这个,我们通常使用 Histogram of Oriented Gradients + 线性 SVM 检测 替代。

上述的 HOG + 线性 SVM 框架的参数更容易调优。而且更好的误报率也更低,但是唯一不好的地方是无法实时运算。

对对象识别感兴趣?并且希望了解更多?

图 5. 在 PyImageSearch Gurus 课程中学习如何构建自定义的对象识别器。

如果你对学习如何训练自己的自定义对象识别器感兴趣,请务必要去了解下 PyImageSearch Gurus 课程。

在这个课程中,我提供了 15 节课,覆盖了超过 168 页的教程,来教你如何从 0 开始构建自定义的对象识别器。你会掌握如何应用 HOG + 线性 SVM 框架来构建自己的对象识别器来识别路标、面孔、汽车(以及附近的其它东西)。

要学习 PyImageSearch Gurus 课程(有 10 节示例免费课程),点此: https://www.pyimagesearch.com/pyimagesearch-gurus/?src=post-cat-detection

总结

在这篇博文里,我们学习了如何使用 OpenCV 默认就有的 Haar cascades 分类器来识别图片中的猫脸。这些 Haar casacades 是由 Joseph Howse 训练兵贡献给 OpenCV 项目的。我是在 Kendrick Tan 的这篇文章中开始注意到这个。

尽管 Haar cascades 相当有用,但是我们也经常用 HOG + 线性 SVM 替代。因为后者相对而言更容易使用,并且可以有效地降低误报率。

我也会在 PyImageSearch Gurus 课程中详细的讲述如何构建定制的 HOG + 线性 SVM 对象识别器,来识别包括汽车、路标在内的各种事物。

不管怎样,我希望你喜欢这篇博文。


via: http://www.pyimagesearch.com/2016/06/20/detecting-cats-in-images-with-opencv/

作者:Adrian Rosebrock 译者:MikeCoder 校对:wxy

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

由于 LFCS 考试中的一些改变已在 2016 年 2 月 2 日生效,我们添加了一些必要的专题到 LFCS 系列。我们也非常推荐备考的同学,同时阅读 LFCE 系列

LFCS:管理 LVM 和创建 LVM 分区

在安装 Linux 系统的时候要做的最重要的决定之一便是给系统文件、home 目录等分配空间。在这个地方犯了错,再要扩大空间不足的分区,那样既麻烦又有风险。

逻辑卷管理LVM)相较于传统的分区管理有许多优点,已经成为大多数(如果不能说全部的话) Linux 发行版安装时的默认选择。LVM 最大的优点应该是能方便的按照你的意愿调整(减小或增大)逻辑分区的大小。

LVM 的组成结构:

  • 把一块或多块硬盘或者一个或多个分区配置成物理卷(PV)。
  • 一个用一个或多个物理卷创建出的卷组(VG)。可以把一个卷组想象成一个单独的存储单元。
  • 在一个卷组上可以创建多个逻辑卷。每个逻辑卷相当于一个传统意义上的分区 —— 优点是它的大小可以根据需求重新调整大小,正如之前提到的那样。

本文,我们将使用三块 8 GB 的磁盘(/dev/sdb/dev/sdc/dev/sdd)分别创建三个物理卷。你既可以直接在整个设备上创建 PV,也可以先分区在创建。

在这里我们选择第一种方式,如果你决定使用第二种(可以参考本系列第四讲:创建分区和文件系统)确保每个分区的类型都是 8e

创建物理卷,卷组和逻辑卷

要在 /dev/sdb/dev/sdc/dev/sdd上创建物理卷,运行:

# pvcreate /dev/sdb /dev/sdc /dev/sdd

你可以列出新创建的 PV ,通过:

# pvs

并得到每个 PV 的详细信息,通过:

# pvdisplay /dev/sdX

X 即 b、c 或 d)

如果没有输入 /dev/sdX ,那么你将得到所有 PV 的信息。

使用 /dev/sdb/dev/sdc创建卷组 ,命名为vg00(在需要时是可以通过添加其他设备来扩展空间的,我们等到说明这点的时候再用,所以暂时先保留/dev/sdd`):

# vgcreate vg00 /dev/sdb /dev/sdc

就像物理卷那样,你也可以查看卷组的信息,通过:

# vgdisplay vg00

由于 vg00 是由两个 8 GB 的磁盘组成的,所以它将会显示成一个 16 GB 的硬盘:

LVM 卷组列表

当谈到创建逻辑卷,空间的分配必须考虑到当下和以后的需求。根据每个逻辑卷的用途来命名是一个好的做法。

举个例子,让我们创建两个 LV,命名为 vol_projects10 GB) 和 vol_backups (剩下的空间), 在日后分别用于部署项目文件和系统备份。

参数 -n 用于为 LV 指定名称,而 -L 用于设定固定的大小,还有 -l (小写的 L)在 VG 的预留空间中用于指定百分比大小的空间。

# lvcreate -n vol_projects -L 10G vg00
# lvcreate -n vol_backups -l 100%FREE vg00

和之前一样,你可以查看 LV 的列表和基础信息,通过:

# lvs

或是查看详细信息,通过:

# lvdisplay

若要查看单个 LV 的信息,使用 lvdisplay 加上 VGLV 作为参数,如下:

# lvdisplay vg00/vol_projects

逻辑卷列表

如上图,我们看到 LV 已经被创建成存储设备了(参考 LV Path 那一行)。在使用每个逻辑卷之前,需要先在上面创建文件系统。

这里我们拿 ext4 来做举例,因为对于每个 LV 的大小, ext4 既可以增大又可以减小(相对的 xfs 就只允许增大):

# mkfs.ext4 /dev/vg00/vol_projects
# mkfs.ext4 /dev/vg00/vol_backups

我们将在下一节向大家说明,如何调整逻辑卷的大小并在需要的时候添加额外的外部存储空间。

调整逻辑卷大小和扩充卷组

现在设想以下场景。vol_backups 中的空间即将用完,而 vol_projects 中还有富余的空间。由于 LVM 的特性,我们可以轻易的减小后者的大小(比方说 2.5 GB),并将其分配给前者,与此同时调整每个文件系统的大小。

幸运的是这很简单,只需:

# lvreduce -L -2.5G -r /dev/vg00/vol_projects
# lvextend -l +100%FREE -r /dev/vg00/vol_backups

减小逻辑卷和卷组

在调整逻辑卷的时候,其中包含的减号 (-) 或加号 (+) 是十分重要的。否则 LV 将会被设置成指定的大小,而非调整指定大小。

有些时候,你可能会遭遇那种无法仅靠调整逻辑卷的大小就可以解决的问题,那时你就需要购置额外的存储设备了,你可能需要再加一块硬盘。这里我们将通过添加之前配置时预留的 PV (/dev/sdd),用以模拟这种情况。

想把 /dev/sdd 加到 vg00,执行:

# vgextend vg00 /dev/sdd

如果你在运行上条命令的前后执行 vgdisplay vg00 ,你就会看出 VG 的大小增加了。

# vgdisplay vg00

查看卷组磁盘大小

现在,你可以使用新加的空间,按照你的需求调整现有 LV 的大小,或者创建一个新的 LV。

在启动和需求时挂载逻辑卷

当然,如果我们不打算实际的使用逻辑卷,那么创建它们就变得毫无意义了。为了更好的识别逻辑卷,我们需要找出它的 UUID (用于识别一个格式化存储设备的唯一且不变的属性)。

要做到这点,可使用 blkid 加每个设备的路径来实现:

# blkid /dev/vg00/vol_projects
# blkid /dev/vg00/vol_backups

寻找逻辑卷的 UUID

为每个 LV 创建挂载点:

# mkdir /home/projects
# mkdir /home/backups

并在 /etc/fstab 插入相应的条目(确保使用之前获得的UUID):

UUID=b85df913-580f-461c-844f-546d8cde4646 /home/projects    ext4 defaults 0 0
UUID=e1929239-5087-44b1-9396-53e09db6eb9e /home/backups ext4    defaults 0 0

保存并挂载 LV:

# mount -a
# mount | grep home

挂载逻辑卷

在涉及到 LV 的实际使用时,你还需要按照曾在本系列第八讲:管理用户和用户组中讲解的那样,为其设置合适的 ugo+rwx

总结

本文介绍了 逻辑卷管理,一个用于管理可扩展存储设备的多功能工具。与 RAID(曾在本系列讲解过的 第六讲:组装分区为RAID设备——创建和管理系统备份)结合使用,你将同时体验到(LVM 带来的)可扩展性和(RAID 提供的)冗余。

在这类的部署中,你通常会在 RAID 上发现 LVM,这就是说,要先配置好 RAID 然后它在上面配置 LVM。

如果你对本问有任何的疑问和建议,可以直接在下方的评论区告诉我们。


via: http://www.tecmint.com/manage-and-create-lvm-parition-using-vgcreate-lvcreate-and-lvextend/

作者:Gabriel Cánepa 译者:martin2011qi 校对:wxy

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

作为 awk 命令系列的第三部分,这次我们将看一看如何基于用户定义的特定模式来筛选文本或字符串。

在筛选文本时,有时你可能想根据某个给定的条件或使用一个可被匹配的特定模式,去标记某个文件或数行字符串中的某几行。使用 awk 来完成这个任务是非常容易的,这也正是 awk 中可能对你有所帮助的几个功能之一。

让我们看一看下面这个例子,比方说你有一个写有你想要购买的食物的购物清单,其名称为 food\_prices.list,它所含有的食物名称及相应的价格如下所示:

$ cat food_prices.list 
No  Item_Name       Quantity    Price
1   Mangoes            10       $2.45
2   Apples             20       $1.50
3   Bananas            5        $0.90
4   Pineapples         10       $3.46
5   Oranges            10       $0.78
6   Tomatoes           5        $0.55
7   Onions             5        $0.45

然后,你想使用一个 (*) 符号去标记那些单价大于 $2 的食物,那么你可以通过运行下面的命令来达到此目的:

$ awk '/ *\$[2-9]\.[0-9][0-9] */ { print $1, $2, $3, $4, "*" ; } / *\$[0-1]\.[0-9][0-9] */ { print ; }' food_prices.list

打印出单价大于 $2 的项目

从上面的输出你可以看到在含有 芒果 mangoes 菠萝 pineapples 的那行末尾都已经有了一个 (*) 标记。假如你检查它们的单价,你可以看到它们的单价的确超过了 $2 。

在这个例子中,我们已经使用了两个模式:

  • 第一个模式: / *\$[2-9]\.[0-9][0-9] */ 将会得到那些含有食物单价大于 $2 的行,
  • 第二个模式: /*\$[0-1]\.[0-9][0-9] */ 将查找那些食物单价小于 $2 的那些行。

上面的命令具体做了什么呢?这个文件有四个字段,当模式一匹配到含有食物单价大于 $2 的行时,它便会输出所有的四个字段并在该行末尾加上一个 (*) 符号来作为标记。

第二个模式只是简单地输出其他含有食物单价小于 $2 的行,按照它们出现在输入文件 food\_prices.list 中的样子。

这样你就可以使用模式来筛选出那些价格超过 $2 的食物项目,尽管上面的输出还有些问题,带有 (*) 符号的那些行并没有像其他行那样被格式化输出,这使得输出显得不够清晰。

我们在 awk 系列的第二部分中也看到了同样的问题,但我们可以使用下面的两种方式来解决:

1、可以像下面这样使用 printf 命令,但这样使用又长又无聊:

$ awk '/ *\$[2-9]\.[0-9][0-9] */ { printf "%-10s %-10s %-10s %-10s\n", $1, $2, $3, $4 "*" ; } / *\$[0-1]\.[0-9][0-9] */ { printf "%-10s %-10s %-10s %-10s\n", $1, $2, $3, $4; }' food_prices.list 

使用 Awk 和 Printf 来筛选和输出项目

2、 使用 $0 字段。Awk 使用变量 0 来存储整个输入行。对于上面的问题,这种方式非常方便,并且它还简单、快速:

$ awk '/ *\$[2-9]\.[0-9][0-9] */ { print $0 "*" ; } / *\$[0-1]\.[0-9][0-9] */ { print ; }' food_prices.list 

使用 Awk 和变量来筛选和输出项目

结论

这就是全部内容了,使用 awk 命令你便可以通过几种简单的方法去利用模式匹配来筛选文本,帮助你在一个文件中对文本或字符串的某些行做标记。

希望这篇文章对你有所帮助。记得阅读这个系列的下一部分,我们将关注在 awk 工具中使用比较运算符。


via: http://www.tecmint.com/awk-filter-text-or-string-using-patterns/

作者:Aaron Kili 译者:FSSlc 校对:wxy

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