Python socket 编程

发表于 2018-09-30 |

背景

平时工作很少涉及到 Socket 相关，基本上都是 HTTP 之上的业务，最近看到 Real Python 的一篇博客，非常详细的讲解了 Python 下的 socket 编程，其中有两个示例觉得很好，帮助我理解了一些要点，记录一下。

多连接情况

Server

multiconn-server.py

#!/usr/bin/env python3
import sys
import socket
import selectors
import types
sel = selectors.DefaultSelector()
def accept_wrapper(sock):
    conn, addr = sock.accept()  # 前提条件：可读状态
    print('accepted connection from', addr)
    conn.setblocking(False)     # 置为非阻塞
    data = types.SimpleNamespace(addr=addr, inb=b'', outb=b'')
    events = selectors.EVENT_READ | selectors.EVENT_WRITE
    sel.register(conn, events, data=data)  # 注册事件到 select
def service_connection(key, mask):
    sock = key.fileobj
    data = key.data
    if mask & selectors.EVENT_READ:
        recv_data = sock.recv(1024)  #  前提条件：可读状态
        if recv_data:
            data.outb += recv_data    # 保存数据
        else:
            print('closing connection to', data.addr) # 如果没有接受到数据，则需关闭该 socket 连接
            sel.unregister(sock) # 将该 socket 事件从 select 删除
            sock.close()
    if mask & selectors.EVENT_WRITE:
        if data.outb:
            print('echoing', repr(data.outb), 'to', data.addr)
            sent = sock.send(data.outb)  #前提条件：可写状态
            data.outb = data.outb[sent:] # 在数据发送完后， 将其删除
if len(sys.argv) != 3:
    print('usage:', sys.argv[0], '<host> <port>')
    sys.exit(1)
host, port = sys.argv[1], int(sys.argv[2])
lsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
lsock.bind((host, port))
lsock.listen()
print('listening on', (host, port))
lsock.setblocking(False)
sel.register(lsock, selectors.EVENT_READ, data=None)
try:
    while True:
        events = sel.select(timeout=None)
        for key, mask in events:    
            if key.data is None:         # 如果没有传输数据，则该请求为连接请求
                accept_wrapper(key.fileobj)
            else:
                service_connection(key, mask)  # 处理数据
except KeyboardInterrupt:
    print('caught keyboard interrupt, exiting')
finally:
    sel.close()

Client

multiconn-client.py

#!/usr/bin/env python3
import sys
import socket
import selectors
import types
sel = selectors.DefaultSelector()
messages = [b'Message 1 from client.', b'Message 2 from client.']
def start_connections(host, port, num_conns):
    server_addr = (host, port)
    for i in range(0, num_conns):
        connid = i + 1
        print('starting connection', connid, 'to', server_addr)
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.setblocking(False)
        sock.connect_ex(server_addr)
        events = selectors.EVENT_READ | selectors.EVENT_WRITE
        data = types.SimpleNamespace(connid=connid,
                                     msg_total=sum(len(m) for m in messages),
                                     recv_total=0,
                                     messages=list(messages),
                                     outb=b'')
        sel.register(sock, events, data=data)
def service_connection(key, mask):
    sock = key.fileobj
    data = key.data
    if mask & selectors.EVENT_READ:
        recv_data = sock.recv(1024)  # 前提条件：可读状态
        if recv_data:
            print('received', repr(recv_data), 'from connection', data.connid)
            data.recv_total += len(recv_data)
        if not recv_data or data.recv_total == data.msg_total:
            print('closing connection', data.connid)
            sel.unregister(sock)
            sock.close()
    if mask & selectors.EVENT_WRITE:
        if not data.outb and data.messages:
            data.outb = data.messages.pop(0) # 如果没有可发送数据，则取 messages 中的第一条用户发送请求
        if data.outb:
            print('sending', repr(data.outb), 'to connection', data.connid)
            sent = sock.send(data.outb)  # Should be ready to write
            data.outb = data.outb[sent:]
if len(sys.argv) != 4:
    print('usage:', sys.argv[0], '<host> <port> <num_connections>')
    sys.exit(1)
host, port, num_conns = sys.argv[1:4]
start_connections(host, int(port), int(num_conns))
try:
    while True:
        events = sel.select(timeout=1)
        if events:
            for key, mask in events:
                service_connection(key, mask)
        # Check for a socket being monitored to continue.
        if not sel.get_map():
            break
except KeyboardInterrupt:
    print('caught keyboard interrupt, exiting')
finally:
    sel.close()

协议封装处理

在多连接基础上，增加特殊协议处理，比如 json header 、 protocol header 等。

Server

libserver.py

import sys
import selectors
import json
import io
import struct
request_search = {
    'morpheus': 'Follow the white rabbit. \U0001f430',
    'ring': 'In the caves beneath the Misty Mountains. \U0001f48d',
    '\U0001f436': '\U0001f43e Playing ball! \U0001f3d0',
}
class Message:
    def __init__(self, selector, sock, addr):
        self.selector = selector
        self.sock = sock
        self.addr = addr
        self._recv_buffer = b''
        self._send_buffer = b''
        self._jsonheader_len = None
        self.jsonheader = None
        self.request = None
        self.response_created = False
    def _set_selector_events_mask(self, mode):
        """Set selector to listen for events: mode is 'r', 'w', or 'rw'."""
        if mode == 'r':
            events = selectors.EVENT_READ
        elif mode == 'w':
            events = selectors.EVENT_WRITE
        elif mode == 'rw':
            events = selectors.EVENT_READ | selectors.EVENT_WRITE
        else:
            raise ValueError(f'Invalid events mask mode {repr(mode)}.')
        self.selector.modify(self.sock, events, data=self)
    def _read(self):
        try:
            # Should be ready to read
            data = self.sock.recv(4096)
        except BlockingIOError:
            # Resource temporarily unavailable (errno EWOULDBLOCK)
            pass
        else:
            if data:
                self._recv_buffer += data
            else:
                raise RuntimeError('Peer closed.')
    def _write(self):
        if self._send_buffer:
            print('sending', repr(self._send_buffer), 'to', self.addr)
            try:
                # Should be ready to write
                sent = self.sock.send(self._send_buffer)
            except BlockingIOError:
                # Resource temporarily unavailable (errno EWOULDBLOCK)
                pass
            else:
                self._send_buffer = self._send_buffer[sent:]
                # Close when the buffer is drained. The response has been sent.
                if sent and not self._send_buffer:
                    self.close()
    # JSON 编码、解码
    def _json_encode(self, obj, encoding):
        return json.dumps(obj, ensure_ascii=False).encode(encoding)
    def _json_decode(self, json_bytes, encoding):
        tiow = io.TextIOWrapper(io.BytesIO(json_bytes), encoding=encoding,
                                newline='')
        obj = json.load(tiow)
        tiow.close()
        return obj
    def _create_message(self, *, content_bytes, content_type,
                        content_encoding):
        jsonheader = {
            'byteorder': sys.byteorder,
            'content-type': content_type,
            'content-encoding': content_encoding,
            'content-length': len(content_bytes)
        }
        jsonheader_bytes = self._json_encode(jsonheader, 'utf-8')
        message_hdr = struct.pack('>H', len(jsonheader_bytes))
        message = message_hdr + jsonheader_bytes + content_bytes # 生成编码后信息
        return message
    def _create_response_json_content(self):
        action = self.request.get('action')
        if action == 'search':  # 根据客户端发送请求返回相应响应信息
            query = self.request.get('value')
            answer = request_search.get(query) or f'No match for "{query}".'
            content = {'result': answer}
        else:
            content = {'result': f'Error: invalid action "{action}".'}
        content_encoding = 'utf-8'
        response = {
            'content_bytes': self._json_encode(content, content_encoding),
            'content_type': 'text/json',
            'content_encoding': content_encoding
        }
        return response
    def _create_response_binary_content(self): # 如果为 binary，则直接返回
        response = {
            'content_bytes': b'First 10 bytes of request: ' +
                             self.request[:10],
            'content_type': 'binary/custom-server-binary-type',
            'content_encoding': 'binary'
        }
        return response
    def process_events(self, mask):
        if mask & selectors.EVENT_READ:
            self.read()
        if mask & selectors.EVENT_WRITE:
            self.write()
    def read(self):
        self._read()
        if self._jsonheader_len is None:
            self.process_protoheader()
        if self._jsonheader_len is not None:
            if self.jsonheader is None:
                self.process_jsonheader()
        if self.jsonheader:
            if self.request is None:
                self.process_request()
    def write(self):
        if self.request:
            if not self.response_created:
                self.create_response()
        self._write()
    def close(self):
        print('closing connection to', self.addr)
        try:
            self.selector.unregister(self.sock)
        except Exception as e:
            print(f'error: selector.unregister() exception for',
                  f'{self.addr}: {repr(e)}')
        try:
            self.sock.close()
        except OSError as e:
            print(f'error: socket.close() exception for',
                  f'{self.addr}: {repr(e)}')
        finally:
            # Delete reference to socket object for garbage collection
            self.sock = None
    def process_protoheader(self): # 解析协议头部信息，得到 json header 大小
        hdrlen = 2
        if len(self._recv_buffer) >= hdrlen:
            self._jsonheader_len = struct.unpack('>H',
                                                 self._recv_buffer[:hdrlen])[0]
            self._recv_buffer = self._recv_buffer[hdrlen:]
    def process_jsonheader(self): # 解析 json header 信息，得到真实请求信息
        hdrlen = self._jsonheader_len
        if len(self._recv_buffer) >= hdrlen:
            self.jsonheader = self._json_decode(self._recv_buffer[:hdrlen],
                                                'utf-8')
            self._recv_buffer = self._recv_buffer[hdrlen:]
            for reqhdr in ('byteorder', 'content-length', 'content-type',
                           'content-encoding'):
                if reqhdr not in self.jsonheader:
                    raise ValueError(f'Missing required header "{reqhdr}".')
    def process_request(self):
        content_len = self.jsonheader['content-length']
        if not len(self._recv_buffer) >= content_len:
            return
        data = self._recv_buffer[:content_len]
        self._recv_buffer = self._recv_buffer[content_len:]
        if self.jsonheader['content-type'] == 'text/json':
            encoding = self.jsonheader['content-encoding']
            self.request = self._json_decode(data, encoding)
            print('received request', repr(self.request), 'from', self.addr)
        else:
            # Binary 或者未知请求类型
            self.request = data
            print(f'received {self.jsonheader["content-type"]} request from',
                  self.addr)
        # 设置 selector 监听写入事件，读事件已经完成
        self._set_selector_events_mask('w')
    def create_response(self):
        if self.jsonheader['content-type'] == 'text/json':
            response = self._create_response_json_content()
        else:
            # Binary or unknown content-type
            response = self._create_response_binary_content()
        message = self._create_message(**response)
        self.response_created = True
        self._send_buffer += message

app-server.py

#!/usr/bin/env python3
import sys
import socket
import selectors
import traceback
import libserver
sel = selectors.DefaultSelector()
def accept_wrapper(sock):
    conn, addr = sock.accept()  # Should be ready to read
    print('accepted connection from', addr)
    conn.setblocking(False)
    message = libserver.Message(sel, conn, addr)
    sel.register(conn, selectors.EVENT_READ, data=message)
if len(sys.argv) != 3:
    print('usage:', sys.argv[0], '<host> <port>')
    sys.exit(1)
host, port = sys.argv[1], int(sys.argv[2])
lsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Avoid bind() exception: OSError: [Errno 48] Address already in use
lsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
lsock.bind((host, port))
lsock.listen()
print('listening on', (host, port))
lsock.setblocking(False)
sel.register(lsock, selectors.EVENT_READ, data=None) # 将 socket 监听事件注册到 selector
try:
    while True:
        events = sel.select(timeout=None)
        for key, mask in events:
            if key.data is None: # 如果没有请求数据，则为客户端连接请求
                accept_wrapper(key.fileobj)
            else:
                message = key.data
                try:
                    message.process_events(mask) # 处理请求信息
                except Exception:
                    print('main: error: exception for',
                          f'{message.addr}:\n{traceback.format_exc()}')
                    message.close()
except KeyboardInterrupt:
    print('caught keyboard interrupt, exiting')
finally:
    sel.close()

Client

libclient.py

import sys
import selectors
import json
import io
import struct
class Message:
    def __init__(self, selector, sock, addr, request):
        self.selector = selector
        self.sock = sock
        self.addr = addr
        self.request = request
        self._recv_buffer = b''
        self._send_buffer = b''
        self._request_queued = False
        self._jsonheader_len = None
        self.jsonheader = None
        self.response = None
    def _set_selector_events_mask(self, mode):
        """Set selector to listen for events: mode is 'r', 'w', or 'rw'."""
        if mode == 'r':
            events = selectors.EVENT_READ
        elif mode == 'w':
            events = selectors.EVENT_WRITE
        elif mode == 'rw':
            events = selectors.EVENT_READ | selectors.EVENT_WRITE
        else:
            raise ValueError(f'Invalid events mask mode {repr(mode)}.')
        self.selector.modify(self.sock, events, data=self)
    def _read(self):
        try:
            # Should be ready to read
            data = self.sock.recv(4096)
        except BlockingIOError:
            # Resource temporarily unavailable (errno EWOULDBLOCK)
            pass
        else:
            if data:
                self._recv_buffer += data
            else:
                raise RuntimeError('Peer closed.')
    def _write(self):
        if self._send_buffer:
            print('sending', repr(self._send_buffer), 'to', self.addr)
            try:
                # Should be ready to write
                sent = self.sock.send(self._send_buffer)
            except BlockingIOError:
                # Resource temporarily unavailable (errno EWOULDBLOCK)
                pass
            else:
                self._send_buffer = self._send_buffer[sent:]
    def _json_encode(self, obj, encoding): # JSON 编码
        return json.dumps(obj, ensure_ascii=False).encode(encoding)
    def _json_decode(self, json_bytes, encoding): # JSON 解码
        tiow = io.TextIOWrapper(io.BytesIO(json_bytes), encoding=encoding,
                                newline='')
        obj = json.load(tiow)
        tiow.close()
        return obj
    def _create_message(self, *, content_bytes, content_type,
                        content_encoding): # 打包处理请求信息
        jsonheader = {
            'byteorder': sys.byteorder,
            'content-type': content_type,
            'content-encoding': content_encoding,
            'content-length': len(content_bytes)
        }
        jsonheader_bytes = self._json_encode(jsonheader, 'utf-8')
        message_hdr = struct.pack('>H', len(jsonheader_bytes))
        message = message_hdr + jsonheader_bytes + content_bytes
        return message
    def _process_response_json_content(self):
        content = self.response
        result = content.get('result')
        print(f'got result: {result}')
    def _process_response_binary_content(self):
        content = self.response
        print(f'got response: {repr(content)}')
    def process_events(self, mask):
        if mask & selectors.EVENT_READ:
            self.read()
        if mask & selectors.EVENT_WRITE:
            self.write()
    def read(self):
        self._read()
        if self._jsonheader_len is None:
            self.process_protoheader()
        if self._jsonheader_len is not None:
            if self.jsonheader is None:
                self.process_jsonheader()
        if self.jsonheader:
            if self.response is None:
                self.process_response()
    def write(self):
        if not self._request_queued:
            self.queue_request()
        self._write()
        if self._request_queued:
            if not self._send_buffer:
                # Set selector to listen for read events, we're done writing.
                self._set_selector_events_mask('r')
    def close(self):
        print('closing connection to', self.addr)
        try:
            self.selector.unregister(self.sock)
        except Exception as e:
            print(f'error: selector.unregister() exception for',
                  f'{self.addr}: {repr(e)}')
        try:
            self.sock.close()
        except OSError as e:
            print(f'error: socket.close() exception for',
                  f'{self.addr}: {repr(e)}')
        finally:
            # Delete reference to socket object for garbage collection
            self.sock = None
    def queue_request(self):
        content = self.request['content']
        content_type = self.request['type']
        content_encoding = self.request['encoding']
        if content_type == 'text/json':
            req = {
                'content_bytes': self._json_encode(content, content_encoding),
                'content_type': content_type,
                'content_encoding': content_encoding
            }
        else:
            req = {
                'content_bytes': content,
                'content_type': content_type,
                'content_encoding': content_encoding
            }
        message = self._create_message(**req)
        self._send_buffer += message
        self._request_queued = True
    def process_protoheader(self):
        hdrlen = 2
        if len(self._recv_buffer) >= hdrlen:
            self._jsonheader_len = struct.unpack('>H',
                                                 self._recv_buffer[:hdrlen])[0]
            self._recv_buffer = self._recv_buffer[hdrlen:]
    def process_jsonheader(self):
        hdrlen = self._jsonheader_len
        if len(self._recv_buffer) >= hdrlen:
            self.jsonheader = self._json_decode(self._recv_buffer[:hdrlen],
                                                'utf-8')
            self._recv_buffer = self._recv_buffer[hdrlen:]
            for reqhdr in ('byteorder', 'content-length', 'content-type',
                           'content-encoding'):
                if reqhdr not in self.jsonheader:
                    raise ValueError(f'Missing required header "{reqhdr}".')
    def process_response(self):
        content_len = self.jsonheader['content-length']
        if not len(self._recv_buffer) >= content_len:
            return
        data = self._recv_buffer[:content_len]
        self._recv_buffer = self._recv_buffer[content_len:]
        if self.jsonheader['content-type'] == 'text/json':
            encoding = self.jsonheader['content-encoding']
            self.response = self._json_decode(data, encoding)
            print('received response', repr(self.response), 'from', self.addr)
            self._process_response_json_content()
        else:
            # Binary or unknown content-type
            self.response = data
            print(f'received {self.jsonheader["content-type"]} response from',
                  self.addr)
            self._process_response_binary_content()
        # Close when response has been processed
        self.close()

app-client.py

#!/usr/bin/env python3
import sys
import socket
import selectors
import traceback
import libclient
sel = selectors.DefaultSelector()
def create_request(action, value):
    if action == 'search':
        return dict(
            type='text/json',
            encoding='utf-8',
            content=dict(action=action, value=value)
        )
    else:
        return dict(
            type='binary/custom-client-binary-type',
            encoding='binary',
            content=bytes(action + value, encoding='utf-8')
        )
def start_connection(host, port, request):
    addr = (host, port)
    print('starting connection to', addr)
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.setblocking(False)
    sock.connect_ex(addr)
    events = selectors.EVENT_READ | selectors.EVENT_WRITE
    message = libclient.Message(sel, sock, addr, request)
    sel.register(sock, events, data=message)
if len(sys.argv) != 5:
    print('usage:', sys.argv[0], '<host> <port> <action> <value>')
    sys.exit(1)
host, port = sys.argv[1], int(sys.argv[2])
action, value = sys.argv[3], sys.argv[4]
request = create_request(action, value)
start_connection(host, port, request)
try:
    while True:
        events = sel.select(timeout=1)
        for key, mask in events:
            message = key.data
            try:
                message.process_events(mask)
            except Exception as e:
                print('main: error: exception for',
                      f'{message.addr}:\n{traceback.format_exc()}')
                message.close()
        # Check for a socket being monitored to continue.
        if not sel.get_map():
            break
except KeyboardInterrupt:
    print('caught keyboard interrupt, exiting')
finally:
    sel.close()

总结

学习了通过 selector 多路 I/O 复用方式来处理 socket 多连接情况，如果请求量少的情况下，也可以使用多线程方式处理。

selector 是 Python3.6 标准库，等之后更了解 select、poll、epoll 之后写一篇总结。
（不知道何年何月啊）

硬件故障坑死人（一）

发表于 2018-09-27 |

背景

因为公司提供的产品不单单是软件形式提供，还对应的提供一体机形式（服务器 & 相应软件）。正式工作2年多也接触到了一些硬件的坑，特此总结。

磁盘

因为公司主要提供的产品是分布式存储和虚拟化相关产品，最直接的影响也是产生范围最大的影响就是磁盘了，会直接导致存储出现单副本等问题，从而产生数据恢复，影响集群稳定性。

固件版本

数据中心级别磁盘，相比于性能的要求，稳定性才是重中之重。大部分厂商的磁盘均支持 S.M.A.R.T. 规范，也就是“Self-Monitoring Analysis and Reporting Technology”，即“自我监测、分析及报告技术”，是一种自动的硬盘状态检测与预警系统和规范。我们可以通过相应命令比如 smartctl 直接获取磁盘相应信息，或者对磁盘进行检测。

S.M.A.R.T. 存在两个问题：

大部分厂商支持，意味着一部分厂商不支持
不同厂商对于自家磁盘的关键字定义不同

针对上述两个问题，我们只能说做到尽量多的测试踩坑，防止出现意外情况。

介绍了 S.M.A.R.T. ，我们来看看这节标题，固件。磁盘固件版本可以通过 smartctl 或者 sg_utils 工具获取：

[root@node 07:47:14 ~]$smartctl -i /dev/sdc
smartctl 6.5 2016-05-07 r4318 [x86_64-linux-3.10.0-693.11.6.el7.smartx.1.x86_64] (local build)
Copyright (C) 2002-16, Bruce Allen, Christian Franke, www.smartmontools.org
=== START OF INFORMATION SECTION ===
Model Family:     Intel 730 and DC S35x0/3610/3700 Series SSDs
Device Model:     INTEL SSDSC2BA400G4
Serial Number:    BTHV518009D3400NGN
LU WWN Device Id: 5 5cd2e4 04c00728c
Firmware Version: G2010160
User Capacity:    400,088,457,216 bytes [400 GB]
Sector Sizes:     512 bytes logical, 4096 bytes physical
Rotation Rate:    Solid State Device
Form Factor:      2.5 inches
Device is:        In smartctl database [for details use: -P show]
ATA Version is:   ACS-3 T13/2161-D revision 5
SATA Version is:  SATA 3.1, 6.0 Gb/s (current: 6.0 Gb/s)
Local Time is:    Wed Sep 26 07:47:20 2018 CST
SMART support is: Available - device has SMART capability.
SMART support is: Enabled
[root@node 07:47:07 ~]$sg_inq /dev/sdc
standard INQUIRY:
  PQual=0  Device_type=0  RMB=0  version=0x05  [SPC-3]
  [AERC=0]  [TrmTsk=0]  NormACA=0  HiSUP=0  Resp_data_format=2
  SCCS=0  ACC=0  TPGS=0  3PC=0  Protect=0  [BQue=0]
  EncServ=0  MultiP=0  [MChngr=0]  [ACKREQQ=0]  Addr16=0
  [RelAdr=0]  WBus16=0  Sync=0  Linked=0  [TranDis=0]  CmdQue=0
  [SPI: Clocking=0x0  QAS=0  IUS=0]
    length=96 (0x60)   Peripheral device type: disk
 Vendor identification: ATA     
 Product identification: INTEL SSDSC2BA40
 Product revision level: 0160
 Unit serial number: BTHV518009D3400NGN

可以看到上面这块磁盘 /dev/sdc 的固件版本就是 0160 。
我们日常看到的磁盘根据出厂时间的不同，对应的固件版本也不同，平时也都没有在意固件版本。但是某次在进行 POC 时，发现性能不稳定，在排除了存储系统问题后，直接对该磁盘进行 Fio 测试，发现确实是磁盘自身性能不稳定。这块磁盘是 Intel 当时的中高端产品 S3710 系列，理论上不应该存在问题，经过排查，最终确定是固件版本导致的，通过 Intel 提供的升级工具升级后，性能恢复正常。

存储控制器

blkdiscard ，用来清理磁盘扇区的操作。某天 POC 过程中发现当 SSD 进行 blkdiscard 时，直接导致该 SSD IO Error。

当时想法：

第一想法是该磁盘有问题，不支持，结果发现是惠普 OEM Intel 的 S3520 SSD，应该是支持相关指令的；
想到上面一节提到的固件版本问题，由于磁盘是 OEM 的原因，固件只能更新惠普提供的固件，当时去惠普官方网站查询发现已经是最新版本；

上面两个原因都不是，当时没有什么其他的想法，我司售前文工提到，有没有可能是存储控制器的原因？
检查当时的存储控制器，是惠普的一块型号为 Smart Array P440ar Controller 的控制器。检查该控制器固件，查询官网，发现不是最新版本，于是下载更新，控制器固件版本更新方式有两种：

DOS 更新
UEFI 更新

两种方式都是将固件文件放置到 U盘或者其他存储介质中，然后启动 OS，进行更新。由于现在新款服务器均带 UEFI ，那么方式 2 会简单一些。

更新固件后，发现磁盘执行 blkdiscard 无报错，检查命令返回值（$?）也是 0 ，问题解决。

电源

通常服务器配置双路电源，避免单一故障，此为前提。

导致 CPU 频率过低

某次测试，由于上架偷懒，只连接了单路电源就开始进行测试。开始功能测试一切正常，到了性能测试，发现相同物理设备下，这台机器性能比之前验证结果低 20%，发现 CPU 频率过低，查看 /proc/cpuinfo 发现部分 core 低于标准主频数。

查看 IPMI & BIOS 配置，并无异常配置，咨询服务器厂商 400，提示是否是由于电源供电不足导致的，插上第二个电源后，CPU 频率稳定，sysbench 运行结果符合标准，问题解决。

磁盘闪断

在服务器正常运行过程中，磁盘的任何故障都会导致业务受到严重影响，哪怕是分布式存储，采用副本机制，如果同时有多个服务器出现磁盘闪断，后果也是极为严重的。

现在各大服务器厂商出货量较多的均为高密度服务器，也就是我们见到的一个机箱内部同时存在多个节点，比如：

四子星就是一个机箱内部有4个节点，如果前置面板磁盘插槽（2.5 寸）为 24 的话，那么每个节点可以连接磁盘数为 6，；
双子星就是一个机箱内部有 2 个节点，如果前置面板为 3.5 寸磁盘的话，那么每个节点连接磁盘数为 6；
双子星如果前置面板为 2.5 的话，那么每个节点连接磁盘数为 12。

这样的服务器好处就是在同一个机箱中，可以放置更多的 CPU内存，成本低，功耗低。但是它的缺点同样明显：多个节点采用同一电源，若电源出现故障，会导致整个机箱内的所有节点出现故障。

最近发现某个机器频繁出现整个节点的磁盘同时断开再连接的场景，由于是双子星，也就是两个节点共用同一电源，影响较大。

最开始这种涉及到整个节点所有磁盘的故障，想法是这样的：

节点操作系统日志只有磁盘连接断开的日志，无特殊问题
整个节点所有磁盘故障，应该不是单一磁盘问题，估计是控制器问题
检查控制器日志，没有发现报错
检查控制器固件版本，已为最新版本
检查控制器连线，连线正常

想法到这里就断了，只能求助服务器厂商了，厂商检查后发现是电源背板问题，由于电源背板故障，导致供电不足，磁盘连接一直处于连接断开重复状态。

总结

暂时总结了印象比较深的几次硬件故障，由于大家现在都是只做软件，对硬件了解仅限于概念，随着云计算的兴起，很多同学可能没见过真正的服务器，更别提遇到这些诡异的故障。

硬件故障特别难定位，如果没有一定的相关经验，估计会像我一样捉瞎。希望这篇文章对大家有所帮助。

OpenvSwitch Active-Backup failback 验证

发表于 2018-09-24 |

背景

在虚拟化场景下，我们经常使用 OpenvSwitch 进行虚拟网络配置，最近看到有人问，Open vSwitch 的 bonding 模式 Avtice-Backup ，是否支持 failback 功能？虽然一直经常使用该模式，但是不知道当故障恢复后，是否会出现故障恢复？
看官方文档中描述感觉有些模糊，来验证下。

验证方式

配置 VDS

[root@node 17:14:54 ~]$ovs-vsctl show
b9956069-4101-4aab-a8a2-86db4f5ae390
    Bridge ovsbr-mgt
        Port bond-mgt
            Interface "eno2"
            Interface "eno1"
        Port port-mgt
            tag: 0
            Interface port-mgt
                type: internal
        Port ovsbr-mgt
            Interface ovsbr-mgt
                type: internal
    ovs_version: "2.3.1"

1
2
3

[root@node 17:14:59 ~]$ovs-appctl bond/list
bond	type	recircID	slaves
bond-mgt	active-backup	0	eno1, eno2

故障前流量检测

[root@node 17:15:58 ~]$ifconfig eno1
eno1: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet6 fe80::ec4:7aff:fe0f:8f68  prefixlen 64  scopeid 0x20<link>
        ether 0c:c4:7a:0f:8f:68  txqueuelen 1000  (Ethernet)
        RX packets 10046643  bytes 1131705628 (1.0 GiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 4182418  bytes 443990895 (423.4 MiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
        device memory 0xdfd20000-dfd3ffff
[root@node 17:16:45 ~]$ifconfig eno2
eno2: flags=4099<UP,BROADCAST,MULTICAST>  mtu 1500
        ether 0c:c4:7a:0f:8f:69  txqueuelen 1000  (Ethernet)
        RX packets 100  bytes 10240 (100 KiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 100  bytes 10240 (100 KiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
        device memory 0xdfd00000-dfd1ffff

故障后流量检测

[root@node 17:15:58 ~]$ifconfig eno1
eno1: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet6 fe80::ec4:7aff:fe0f:8f68  prefixlen 64  scopeid 0x20<link>
        ether 0c:c4:7a:0f:8f:68  txqueuelen 1000  (Ethernet)
        RX packets 10046643  bytes 1131705628 (1.0 GiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 4182418  bytes 443990895 (423.4 MiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
        device memory 0xdfd20000-dfd3ffff
[root@node 17:16:45 ~]$ifconfig eno2
eno2: flags=4099<UP,BROADCAST,MULTICAST>  mtu 1500
        ether 0c:c4:7a:0f:8f:69  txqueuelen 1000  (Ethernet)
        RX packets 22222222  bytes 2231705628 (1.0 GiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 2231705628  bytes 2231705628 (1.0 GiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
        device memory 0xdfd00000-dfd1ffff

故障恢复后流量检测

[root@node 17:15:58 ~]$ifconfig eno1
eno1: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet6 fe80::ec4:7aff:fe0f:8f68  prefixlen 64  scopeid 0x20<link>
        ether 0c:c4:7a:0f:8f:68  txqueuelen 1000  (Ethernet)
        RX packets 10046643  bytes 1131705628 (1.0 GiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 4182418  bytes 443990895 (423.4 MiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
        device memory 0xdfd20000-dfd3ffff
[root@node 17:16:45 ~]$ifconfig eno2
eno2: flags=4099<UP,BROADCAST,MULTICAST>  mtu 1500
        ether 0c:c4:7a:0f:8f:69  txqueuelen 1000  (Ethernet)
        RX packets 33333333  bytes 3331705628 (1.0 GiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 3331705628  bytes 3331705628 (1.0 GiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
        device memory 0xdfd00000-dfd1ffff

结论

可以看到整体流程中流量占用网口情况，主要看 RX 和 TX packets 数量：

故障前：eno1
故障后：eno2
故障恢复后：eno2

在 OpenvSwitch Active-Backup 场景下，未支持 failback 功能，我理解是因为这两块网卡完全等价，failback 在 Master-Slave 场景下更有用一些。

cgroups 常用配置

发表于 2018-09-23 |

背景

在软件运行过程中，我们经常需要限制 CPU 、内存、磁盘的使用，方式程序超出了限定边界范围。在 Linux 中，我们可以通过 cgroups 来进行限制。

cgroups

中文名称为控制组群，具体功能分类为：

资源限制：组可以被设置不超过设定的内存限制；这也包括虚拟内存。
优先级：一些组可能会得到大量的CPU或磁盘IO吞吐量。
结算：用来衡量系统确实把多少资源用到适合的目的上。
控制：冻结组或检查点和重启动。

下面来说下常见的使用方式

CPU

RedHat 官方文档中描述 cgroups 在 RHEL7/CentOS7 之后的版本需要通过 systemd 配置，不再使用 libcgconfig 方式。
但是在 systemd 的配置中，CPU 相关的配置项比较简单，或者说 OS 自动配置了很多，没有暴露出来。所以我们这里还是采用 libcgconfig 的配置方式。

在进行 CPU 限制之前，我们需要了解一下 NUMA 结构。什么是 NUMA？ NUMA 是一种为多处理器的计算机设计的内存，内存访问时间取决于内存相对于处理器的位置。在NUMA下，处理器访问它自己的本地内存的速度比非本地内存快一些。
不同的 Thread 在同一个 Core 上也会发生抢占情况，具体可以通过 sysbench 进行测试。

内存

相对于 CPU，内存配置我们可以直接通过 systemd 配置，就简化很多了。
最简单的，如果我们想立即配置一个服务的内存限制，我们可以直接执行命令：

1	[root@test 11:05:50 ~]systemctl set-property <service name> MemoryLimit=500M

执行完这条命令后，系统会自动在该服务的 systemd 配置路径(/etc/systemd/system/<service name>.d/ 下生成文件 50-MemoryLimit.conf ，文件内容为：

1 2	[Slice] MemoryLimit=5368709120

当然我们如果直接在该路径下编写配置文件也是可以的，重启服务后生效。

Slice 配置

上面这种方式只是针对单一的服务配置，如果我们想创建一个组，控制多个服务计算资源总和的配置，我们就需要通过配置 Slice 完成。

slice —— 一组按层级排列的单位。slice 并不包含进程，但会组建一个层级，并将 scope 和 service 都放置其中。真正的进程包含在 scope 或 service 中。在这一被划分层级的树中，每一个 slice 单位的名字对应通向层级中一个位置的路径。小横线（”-“）起分离路径组件的作用。例如，如果一个 slice 的名字是：

parent-name.slice

这说明 parent-name.slice 是 parent.slice 的一个子 slice。这一子 slice 可以再拥有自己的子 slice，被命名为：parent-name-name2.slice，以此类推。

根 slice 的表示方式：-.slice

我们在 /etc/systemd/system/ 下创建一个组，名称还是 yiran ，创建 flask 在 yiran 下：

/etc/systemd/system
├── flask.service.d
│   └── cgroup.conf
├── system-yiran.slice
├── system-yiran.slice.d
│   └── 50-MemoryLimit.conf

配置完成后，我们重启 cgconfig 相关服务即可使能配置。

磁盘

如要降低 flask 服务读取某个目录 block IO 的权重，只需要修改该服务配置文件增加 BlockIODeviceWeight=/home/jdoe 750 字段即可。

后续

日常用到最多的应该就是 CPU 和内存，如果很多对 IO 要求高的服务运行在一块磁盘上，那么可以先通过针对不同服务进行不同磁盘分区的方式（此方式不包括 lvm）验证，如果还不能解决的话，再考虑针对服务控制磁盘 IO。

为了追求性能，我们在 CPU 配置的时候给应用程序分配的 Thread 都位于同一个 Socket 上 CPU 的不同的 Core 上。老板说还要考虑网卡、磁盘等 PCI 设备接入的 Socket ，如果应用程序分配在了 NUMA node0 上，但是网卡、磁盘等 PCI 设备连接在了 NUMA node1 上，还是会对性能有影响，还没找到相应配置，后续有时间再了解吧。

参考链接

基于zeroconf实现节点自发现

发表于 2018-08-22 |

背景

通常我们使用联网的电子设备，都会配置一个 IP 地址用于通信，一般采用 DHCP 配置，DHCP 有
lease 时间，如果超过 lease 时间又没有续约的话，产生的 IP 地址有可能发生改变，那么如何
自动识别我们的设备呢？ ZeroConf 是一个好的选择。

ZeroConf

以下介绍摘录自维基百科：

Zero-configuration networking (zeroconf) is a set of technologies that
automatically creates a usable computer network based on the
Internet Protocol Suite (TCP/IP) when computers or network peripherals are
interconnected. It does not require manual operator intervention or special
configuration servers. Without zeroconf, a network administrator must set up
network services, such as Dynamic Host Configuration Protocol (DHCP) and
Domain Name System (DNS), or configure each computer’s network settings manually.
Zeroconf is built on three core technologies: automatic assignment of numeric
network addresses for networked devices, automatic distribution and resolution
of computer hostnames, and automatic location of network services, such as printing devices.

简单来说我们可以通过 ZeroConf 进行服务自发现，日常使用最多的就是 Apple 家的产品及一些
打印设备。

Avahi

如果我们想要在 Linux 中使用的话，我们可以选择 Avahi，配合 nss-mdns 一起使用可以在复杂网络场景下自动发现服务器，并获取 IPv4 或 IPv6 地址进行通信。

扫描节点安装

我们使用 yum 进行相应工具的安装：

1	yum install avahi-libs avahi-tools avahi-autoipd avahi nss-mdns

扫描节点配置

安装完成后，我们修改配置文件，开启 IPv6 配置：

[root@yiran-pxe data]# cat /etc/nsswitch.conf |grep -v ^# |grep -v ^$
passwd:     files sss
shadow:     files sss
group:      files sss
hosts:      files mdns4_minimal [NOTFOUND=return] dns
bootparams: nisplus [NOTFOUND=return] files
ethers:     files
netmasks:   files
networks:   files
protocols:  files
rpc:        files
services:   files sss
netgroup:   files sss
publickey:  nisplus
automount:  files
aliases:    files nisplus
[root@yiran-pxe data]# cat /etc/avahi/avahi-daemon.conf  |grep -v ^# |grep -v ^$
[server]
use-ipv4=no
use-ipv6=yes            ## 开启 IPv6 
ratelimit-interval-usec=1000000
ratelimit-burst=1000
[wide-area]
enable-wide-area=yes
[publish]
[reflector]
[rlimits]
rlimit-core=0
rlimit-data=4194304
rlimit-fsize=0
rlimit-nofile=768
rlimit-stack=4194304
rlimit-nproc=3

配置完成后我们启动服务：

1	systemctl start avahi-daemon

被扫描节点配置

扫描节点可以通过制定的域名进行扫描，我们可以通过给被扫描节点配置特殊的主机名称，来实现自动识别被扫描节点具体是什么类型的服务器，比如我们可以通过 ipmitool 获取 IPMI IP，并配置主机名为 node-192-168-67-173 来实现识别，具体操作：

1
2
3

[root@node-192-168-67-173 ~]# cat /etc/hostname 
node-192-168-67-173
[root@node-192-168-67-173 ~]# hostname -F /etc/hostname

同样编辑 avahi 配置文件，开启 IPv6 配置：

[root@node-192-168-67-173 avahi]# cat avahi-daemon.conf |grep -v ^# |grep -v ^$
[server]
use-ipv4=yes
use-ipv6=yes
ratelimit-interval-usec=1000000
ratelimit-burst=1000
[wide-area]
enable-wide-area=yes
[publish]
publish-a-on-ipv6=yes
[reflector]
[rlimits]
rlimit-core=0
rlimit-data=4194304
rlimit-fsize=0
rlimit-nofile=768
rlimit-stack=4194304
rlimit-nproc=3

启动 avahi 服务：

1	systemctl start avahi-daemon

扫描节点发现节点

我们可以通过 avahi-tools 提供的 avahi-brower 工具进行持续扫描：

1
2
3

[root@yiran-pxe data]# avahi-browse -a
+ eno33559296 IPv6 node-192-168-67-173 [24:6e:96:7c:50:70]       Workstation          local
+ eno16780032 IPv6 node-192-168-67-173 [24:6e:96:7c:50:50]       Workstation          local

可以看到我们在扫描节点已经发现了被扫描节点的信息，那么我们接下来获取具体的 IP 地址：

[root@yiran-pxe data]# avahi-resolve --help 
avahi-resolve [options] -n <host name ...>
avahi-resolve [options] -a <address ... >
    -h --help            Show this help
    -V --version         Show version
    -n --name            Resolve host name
    -a --address         Resolve address
    -v --verbose         Enable verbose mode
    -6                   Lookup IPv6 address
    -4                   Lookup IPv4 address
[root@yiran-pxe data]# avahi-resolve -n node-192-168-67-173.local -4
node-192-168-67-173.local       127.0.0.1
[root@yiran-pxe data]# avahi-resolve -n node-192-168-67-173.local -6
node-192-168-67-173.local       fe80::266e:96ff:fe7c:5070

如果被扫描节点没有 IPv4 地址，则会显示 127.0.0.1，若有 IPv4 地址，则会正常显示。

远程通信

在得到具体的 IP 地址之后我们就可以按照上一篇博客提到的 IPv6 地址远程连接的方式进行通信了。

[root@yiran-pxe data]# ping6 fe80::266e:96ff:fe7c:5070%eno33559296
PING fe80::266e:96ff:fe7c:5070%eno33559296(fe80::266e:96ff:fe7c:5070) 56 data bytes
64 bytes from fe80::266e:96ff:fe7c:5070: icmp_seq=1 ttl=64 time=0.448 ms
64 bytes from fe80::266e:96ff:fe7c:5070: icmp_seq=2 ttl=64 time=0.338 ms
^C
--- fe80::266e:96ff:fe7c:5070%eno33559296 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 999ms
rtt min/avg/max/mdev = 0.338/0.393/0.448/0.055 ms
[root@yiran-pxe data]# ssh fe80::266e:96ff:fe7c:5070%eno33559296
root@fe80::266e:96ff:fe7c:5070%eno33559296's password: 
Last login: Wed Aug 22 15:44:17 2018 from fe80::250:56ff:fe9f:ef9c%eno3
[root@node-192-168-67-173 ~]# hostname
node-192-168-67-173
[root@node-192-168-67-173 ~]# logout
Connection to fe80::266e:96ff:fe7c:5070%eno33559296 closed.

总结

目前 Linux 发行版本都自动安装了 Avahi 服务，大家可以启用，方便远程连接控制。

Ansible 配置 IPv6 连接

发表于 2018-08-17 |

背景

平时工作中因为通常需要远程操作较多 Linux 环境，引入了 Ansible，但是大都是通过 Ansible 远程命令的方式执行，少数的封装为 Playbook 也是很简单的配置。
最早的时候用过简单的 SaltStack，但是要安装 Agent，觉得不好用，在 16年早期的时候使用 Ansible，简单快捷（当然我对性能没有要求）。
最近需要把之前由 Shell & Python 拼装的一个服务统一用 Ansible 进行重写，又花了些时间看了看相关文档。发现大家操作远程机器无论是通过秘钥还是通过密码，都是基于 IPv4 的地址链接的，而有些机器是没有 IPv4 地址的，于是花费了些时间验证 Ansible IPv6 配置方式。

IPv6

IPv6 维基百科的解释是：网际协议第6版（英文：Internet Protocol version 6，缩写：IPv6）是网际协议（IP）的最新版本，用作互联网的网络层协议，用它来取代IPv4主要是为了解决IPv4地址枯竭问题，不过它也在其他很多方面对IPv4有所改进。我们目前日常中使用的地址都是 IPv4 的地址（比如：192.168.1.1）。
使用 IPv6 有一个好处是，可以通过 NDP（Neighbor Discovery Protocol）扫描二层网络内的所有的 IPv6 地址，方便我们使用，那么我们如何判断 IPv6 是否可以连通呢？
可以通过 ping6 的方式判断，比如：

[root@node111 14:00:44 ~]$ping6 fe80::2487:93ff:fe9a:c546%port-mgt
PING fe80::2487:93ff:fe9a:c546%port-mgt(fe80::2487:93ff:fe9a:c546%port-mgt) 56 data bytes
64 bytes from fe80::2487:93ff:fe9a:c546%port-mgt: icmp_seq=1 ttl=64 time=0.443 ms
64 bytes from fe80::2487:93ff:fe9a:c546%port-mgt: icmp_seq=2 ttl=64 time=0.488 ms
^C
--- fe80::2487:93ff:fe9a:c546%port-mgt ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1000ms
rtt min/avg/max/mdev = 0.443/0.465/0.488/0.031 ms

注意这里的 IPv6 的格式，前面是 IPv6 地址，后面是本地网络接口名称，如果是物理网卡则接物理网卡名称，如果是 OVS Port，则接 Port 名称。

既然地址可以连通，那么我们思考如何进行远程控制。

SSH 远程连接

通常我们通过 IPv4 地址链接远程 Linux，通过如下方式：

[root@node111 14:01:23 ~]$ssh 192.168.30.112
root@192.168.30.112's password: 
Last login: Fri Aug 17 12:15:52 2018 from 192.168.16.1
[root@node112 14:03:46 ~]$

我们尝试将上面的 IPv4 地址替换为 IPv6 地址试试看：

1
2
3

[root@node111 14:04:55 ~]$ssh fe80::2487:93ff:fe9a:c546
ssh: connect to host fe80::2487:93ff:fe9a:c546 port 22: Invalid argument
[root@node111 14:05:10 ~]$

直接指定 IPv6 地址是无法识别的，那么我们按照 ping6 规则，加上网络接口名称试试看：

[root@node111 14:05:10 ~]$ssh fe80::2487:93ff:fe9a:c546%port-mgt
root@fe80::2487:93ff:fe9a:c546%port-mgt's password: 
Last login: Fri Aug 17 14:04:56 2018 from fe80::d4b7:acff:fe2f:604e%ovsbr-mgt
[root@node112 14:03:46 ~]$

一切顺利，我们成功的登录到了远程的机器上，我们知道 Ansible 是通过 SSH 的方式远程控制的，具体是调用 Python 的 (paramiko)[https://github.com/paramiko/paramiko/] ，我们接下来配置 Ansible。

Ansible 远程连接

Ansible Inventory 标准格式是：IP options ，比如：

1 2	[cluster] fe80::58d3:16ff:fe43:ce77%port-mgt ansible_ssh_user=root ansible_ssh_pass=abc123

验证 Ansible 远程控制：

[root@node111 14:11:14 ~]$ansible cluster -m raw -a 'uptime'
fe80::58d3:16ff:fe43:ce77%port-mgt | SUCCESS | rc=0 >>
 14:11:22 up 7 days, 23:15,  2 users,  load average: 1.55, 1.39, 1.23
Shared connection to fe80::58d3:16ff:fe43:ce77%port-mgt closed.

总结

只要注意在 IPv6 地址后加上本地网络接口名称就可以正确配置 IPv6 远程控制了。

Pure Bash Bible

发表于 2018-08-11 |

背景

逛 Github Trending 的时候，发现一个叫 pure bash bible 的项目，这个项目主要是介绍一些常用功能的 Bash 实现。
在日常使用中，Bash 作为大部分 Linux 发行版的默认 Shell 是使用最多的，尤其是进行一些简单的自动处理事件上很方便。但是我使用的时候通常会用 Bash、Sed、Awk、cut、timeout 等一些 Linux 命令相互配合使用。
如果你要维护的 Server 是一个比较少见的版本，比如：ESXi 5.0、XenServer 6.0 等版本，那么就会导致有些命令是缺失的，且无法安装，这时候就需要单独使用 Bash 来实现一些其他命令的功能。
pure bash bible 这个项目列举了很多常用常用功能，有一些比较有借鉴意义，在此记录。

字符串

删除字符串前后空格

trim_string（）{ # Ups：trim_string“example string” 
    ： “ $ {1 ＃” $ {1 %% [！[：space：]] * } “ } ”
    ： “ $ {_ ％” $ {_ ## * [！[：space：]]} “ } ”
     printf  '％s \ n '  “ $ _ ” }
$ trim_string “ Hello，World ” 
Hello, World
$ name = “ John Black ” $ trim_string “ $ name ” John Black

删除字符串中所有空格

# shellcheck disable=SC2086,SC2048
trim_all() {
    # Usage: trim_all "   example   string    "
    set -f
    set -- $*
    printf '%s\n' "$*"
    set +f
}
$ trim_all "    Hello,    World    "
Hello, World
$ name="   John   Black  is     my    name.    "
$ trim_all "$name"
John Black is my name.

根据指定分隔符分隔字符串

split() {
   # Usage: split "string" "delimiter"
   IFS=$'\n' read -d "" -ra arr <<< "${1//$2/$'\n'}"
   printf '%s\n' "${arr[@]}"
}
$ split "apples,oranges,pears,grapes" ","
apples
oranges
pears
grapes
$ split "1, 2, 3, 4, 5" ", "
1
2
3
4
5
# Multi char delimiters work too!
$ split "hello---world---my---name---is---john" "---"
hello
world
my
name
is
john

数组

反转

reverse_array() {
    # Usage: reverse_array "array"
    shopt -s extdebug
    f()(printf '%s\n' "${BASH_ARGV[@]}"); f "$@"
    shopt -u extdebug
}
$ reverse_array 1 2 3 4 5
5
4
3
2
1
$ arr=(red blue green)
$ reverse_array "${arr[@]}"
green
blue
red

删除重复项

remove_array_dups() {
    # Usage: remove_array_dups "array"
    declare -A tmp_array
    for i in "$@"; do
        [[ "$i" ]] && IFS=" " tmp_array["${i:- }"]=1
    done
    printf '%s\n' "${!tmp_array[@]}"
}
$ remove_array_dups 1 1 2 2 3 3 3 3 3 4 4 4 4 4 5 5 5 5 5 5
1
2
3
4
5
$ arr=(red red green blue blue)
$ remove_array_dups "${arr[@]}"
red
green
blue

随机选择

random_array_element() {
    # Usage: random_array_element "array"
    local arr=("$@")
    printf '%s\n' "${arr[RANDOM % $#]}"
}
$ array=(red green blue yellow brown)
$ random_array_element "${array[@]}"
yellow
# Multiple arguments can also be passed.
$ random_array_element 1 2 3 4 5 6 7
3

文件

获取文件绝对路径

dirname() {
    # Usage: dirname "path"
    printf '%s\n' "${1%/*}/"
}
$ dirname ~/Pictures/Wallpapers/1.jpg
/home/black/Pictures/Wallpapers/
$ dirname ~/Pictures/Downloads/
/home/black/Pictures/

获取文件相对路径

basename() {
    # Usage: basename "path"
    : "${1%/}"
    printf '%s\n' "${_##*/}"
}
$ basename ~/Pictures/Wallpapers/1.jpg
1.jpg
$ basename ~/Pictures/Downloads/
Downloads

进度条

打印进度条

bar() {
    # Usage: bar 1 10
    #            ^----- Elapsed Percentage (0-100).
    #               ^-- Total length in chars.
    ((elapsed=$1*$2/100))
    # Create the bar with spaces.
    printf -v prog  "%${elapsed}s"
    printf -v total "%$(($2-elapsed))s"
    printf '%s\r' "[${prog// /-}${total}]"
}
for ((i=0;i<=100;i++)); do
    # Pure bash micro sleeps (for the example).
    (:;:) && (:;:) && (:;:) && (:;:) && (:;:)
    # Print the bar.
    bar "$i" "10"
done
printf '\n'

总结

感觉平时很难用到这么诡异的 Bash 语法的。。。。

Linux 安全清理 /boot 分区

发表于 2018-08-09 |

背景

众多 Linux 发行版中，很多为了稳定性要求，Kernel 的版本还处于比较低的版本，比如：3.10.0-xxx（说的就是 CentOS）。
在工作中难免因为某些需求要升级 Kernel，最近遇到多次升级 Kernel 后导致 /boot 分区被占满的情况，特此查找资料记录。

升级方式

在之前的博客中提到过多次，CentOS 发行版升级一般采用 yum update ，Kernel 因为没有相关依赖，也可以直接 rpm -Uvh 的方式升级。

yum update

举个例子，比如这台 Linux，目前情况如下：

[root@node111 14:25:10 ~]$uname -a
Linux node111 3.10.0-693.11.6.el7.smartx.1.x86_64 #1 SMP Tue Jan 16 22:09:10 CST 2018 x86_64 x86_64 x86_64 GNU/Linux
[root@node111 14:25:12 ~]$ll /boot/
total 124929
-rw-r--r--. 1 root root   140924 Jan 16  2018 config-3.10.0-693.11.6.el7.smartx.1.x86_64
drwxr-xr-x. 3 root root     1024 Jul  2 07:23 efi
drwxr-xr-x. 2 root root     1024 Jul  2 07:24 grub
drwx------. 5 root root     1024 Jul  2 07:31 grub2
-rw-------. 1 root root 57031976 Jul  2 07:29 initramfs-0-rescue-9b8f4b7a44fc4a1db2b125ee46f00892.img
-rw-------. 1 root root 17270634 Jul  2 07:30 initramfs-3.10.0-229.el7.x86_64.img
-rw-------. 1 root root 20958312 Jul  2 07:31 initramfs-3.10.0-693.11.6.el7.smartx.1.x86_64.img
-rw-------  1 root root 16575028 Jul  2 07:32 initramfs-3.10.0-693.11.6.el7.smartx.1.x86_64kdump.img
-rw-r--r--. 1 root root   610559 Jul  2 07:28 initrd-plymouth.img
drwx------. 2 root root    12288 Jul  2 07:23 lost+found
-rw-r--r--. 1 root root   293110 Jan 16  2018 symvers-3.10.0-693.11.6.el7.smartx.1.x86_64.gz
-rw-------. 1 root root  3232490 Jan 16  2018 System.map-3.10.0-693.11.6.el7.smartx.1.x86_64
-rwxr-xr-x. 1 root root  5889744 Jul  2 07:29 vmlinuz-0-rescue-9b8f4b7a44fc4a1db2b125ee46f00892
-rwxr-xr-x. 1 root root  5889744 Jan 16  2018 vmlinuz-3.10.0-693.11.6.el7.smartx.1.x86_64

我们要对它进行升级 Kernel 操作：

[root@node111 14:36:19 ~]$uname -a
Linux node111 3.10.0-693.11.6.el7.smartx.1.x86_64 #1 SMP Tue Jan 16 22:09:10 CST 2018 x86_64 x86_64 x86_64 GNU/Linux
[root@node111 14:36:22 ~]$yum update kernel
Loaded plugins: fastestmirror, langpacks
Loading mirror speeds from cached hostfile
Resolving Dependencies
--> Running transaction check
---> Package kernel.x86_64 0:4.4.26-201.el7.centos will be installed
--> Processing Dependency: kernel-core-uname-r = 4.4.26-201.el7.centos.x86_64 for package: kernel-4.4.26-201.el7.centos.x86_64
--> Processing Dependency: kernel-modules-uname-r = 4.4.26-201.el7.centos.x86_64 for package: kernel-4.4.26-201.el7.centos.x86_64
--> Processing Dependency: xorg-x11-drv-vmmouse >= 14.0.0 for package: kernel-4.4.26-201.el7.centos.x86_64
--> Running transaction check
---> Package kernel-core.x86_64 0:4.4.26-201.el7.centos will be installed
---> Package kernel-headers.x86_64 0:3.10.0-862.3.3.el7 will be obsoleted
---> Package kernel-headers.x86_64 0:3.10.0-862.3.3.el7 will be updated
---> Package kernel-headers.x86_64 0:4.4.26-201.el7.centos will be obsoleting
---> Package kernel-modules.x86_64 0:4.4.26-201.el7.centos will be installed
--> Finished Dependency Resolution
Dependencies Resolved
=====================================================================================================================================================================================================================================================================
 Package                                                          Arch                                                     Version                                                                    Repository                                                Size
=====================================================================================================================================================================================================================================================================
Installing:
 kernel                                                           x86_64                                                   4.4.26-201.el7.centos                                                      kernel                                                    79 k
 kernel-headers                                                   x86_64                                                   4.4.26-201.el7.centos                                                      kernel                                                   1.0 M
     replacing  kernel-headers.x86_64 3.10.0-862.3.3.el7
Installing for dependencies:
 kernel-core                                                      x86_64                                                   4.4.26-201.el7.centos                                                      kernel                                                    20 M
 kernel-modules                                                   x86_64                                                   4.4.26-201.el7.centos                                                      kernel                                                    18 M
Transaction Summary
=====================================================================================================================================================================================================================================================================
Install  2 Packages (+2 Dependent packages)
Total download size: 40 M
Is this ok [y/d/N]: y
Downloading packages:
Delta RPMs disabled because /usr/bin/applydeltarpm not installed.
(1/4): kernel-4.4.26-201.el7.centos.x86_64.rpm                                                                                                                                                                                                |  79 kB  00:00:00     
(2/4): kernel-headers-4.4.26-201.el7.centos.x86_64.rpm                                                                                                                                                                                        | 1.0 MB  00:00:00     
(3/4): kernel-core-4.4.26-201.el7.centos.x86_64.rpm                                                                                                                                                                                           |  20 MB  00:00:00     
(4/4): kernel-modules-4.4.26-201.el7.centos.x86_64.rpm                                                                                                                                                                                        |  18 MB  00:00:00     
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Total                                                                                                                                                                                                                                 50 MB/s |  40 MB  00:00:00     
Running transaction check
Running transaction test
Transaction test succeeded
Running transaction
Warning: RPMDB altered outside of yum.
  Installing : kernel-core-4.4.26-201.el7.centos.x86_64                                                                                                                                                                                                          1/5 
  Installing : kernel-modules-4.4.26-201.el7.centos.x86_64                                                                                                                                                                                                       2/5 
  Installing : kernel-headers-4.4.26-201.el7.centos.x86_64                                                                                                                                                                                                       3/5 
  Installing : kernel-4.4.26-201.el7.centos.x86_64                                                                                                                                                                                                               4/5 
  Cleanup    : kernel-headers-3.10.0-862.3.3.el7.x86_64                                                                                                                                                                                                          5/5 
  Verifying  : kernel-core-4.4.26-201.el7.centos.x86_64                                                                                                                                                                                                          1/5 
  Verifying  : kernel-headers-4.4.26-201.el7.centos.x86_64                                                                                                                                                                                                       2/5 
  Verifying  : kernel-4.4.26-201.el7.centos.x86_64                                                                                                                                                                                                               3/5 
  Verifying  : kernel-modules-4.4.26-201.el7.centos.x86_64                                                                                                                                                                                                       4/5 
  Verifying  : kernel-headers-3.10.0-862.3.3.el7.x86_64                                                                                                                                                                                                          5/5 
  Verifying  : kernel-headers-3.10.0-862.3.3.el7.x86_64                                                                                                                                                                                                          6/5 
Installed:
  kernel.x86_64 0:4.4.26-201.el7.centos                                                                                         kernel-headers.x86_64 0:4.4.26-201.el7.centos                                                                                        
Dependency Installed:
  kernel-core.x86_64 0:4.4.26-201.el7.centos                                                                                      kernel-modules.x86_64 0:4.4.26-201.el7.centos                                                                                     
Replaced:
  kernel-headers.x86_64 0:3.10.0-862.3.3.el7                                                                                                                                                                                                                         
Complete!

可以看到，在升级之后 /boot/ 分区下的老版本 Kernel 内核文件 vmlinuz-3.10.0-693.11.6.el7.smartx.1.x86_64 还在：

[root@node111 14:37:47 ~]$ll /boot/
total 151927
-rw-r--r--. 1 root root   140924 Jan 16  2018 config-3.10.0-693.11.6.el7.smartx.1.x86_64
-rw-r--r--  1 root root   169326 Oct 21  2016 config-4.4.26-201.el7.centos.x86_64
drwxr-xr-x. 3 root root     1024 Jul  2 07:23 efi
drwxr-xr-x. 2 root root     1024 Jul  2 07:24 grub
drwx------. 5 root root     1024 Aug  9 14:37 grub2
-rw-------. 1 root root 57031976 Jul  2 07:29 initramfs-0-rescue-9b8f4b7a44fc4a1db2b125ee46f00892.img
-rw-------. 1 root root 17270634 Jul  2 07:30 initramfs-3.10.0-229.el7.x86_64.img
-rw-------. 1 root root 20958312 Jul  2 07:31 initramfs-3.10.0-693.11.6.el7.smartx.1.x86_64.img
-rw-------  1 root root 16575028 Jul  2 07:32 initramfs-3.10.0-693.11.6.el7.smartx.1.x86_64kdump.img
-rw-------  1 root root 18060511 Aug  9 14:37 initramfs-4.4.26-201.el7.centos.x86_64.img
-rw-r--r--. 1 root root   610559 Jul  2 07:28 initrd-plymouth.img
drwx------. 2 root root    12288 Jul  2 07:23 lost+found
-rw-r--r--. 1 root root   293110 Jan 16  2018 symvers-3.10.0-693.11.6.el7.smartx.1.x86_64.gz
-rw-------. 1 root root  3232490 Jan 16  2018 System.map-3.10.0-693.11.6.el7.smartx.1.x86_64
-rw-------  1 root root  3265893 Oct 21  2016 System.map-4.4.26-201.el7.centos.x86_64
-rwxr-xr-x. 1 root root  5889744 Jul  2 07:29 vmlinuz-0-rescue-9b8f4b7a44fc4a1db2b125ee46f00892
-rwxr-xr-x. 1 root root  5889744 Jan 16  2018 vmlinuz-3.10.0-693.11.6.el7.smartx.1.x86_64
-rwxr-xr-x  1 root root  6148096 Oct 21  2016 vmlinuz-4.4.26-201.el7.centos.x86_64

yum upgrade

刚刚我们用了 yum update 方式升级，发现没有自动清理掉旧的 Kernel ，在 Stack Overflow 上看到有人说可以使用 upgrade 方式，会自动清理，
现在我们换 yum upgrade 升级看看有何不同。

首先查看我们的环境状态：

[root@node112 14:41:11 ~]$ll /boot/
total 124884
-rw-r--r--. 1 root root   140924 Jan 16  2018 config-3.10.0-693.11.6.el7.smartx.1.x86_64
drwxr-xr-x. 3 root root     1024 May 31 10:55 efi
drwxr-xr-x. 2 root root     1024 May 31 10:56 grub
drwx------. 5 root root     1024 May 31 11:02 grub2
-rw-------. 1 root root 57008277 May 31 11:01 initramfs-0-rescue-00bf5adc700644d685733d8e76c21d42.img
-rw-------. 1 root root 17249662 May 31 11:01 initramfs-3.10.0-229.el7.x86_64.img
-rw-------. 1 root root 20945698 May 31 11:02 initramfs-3.10.0-693.11.6.el7.smartx.1.x86_64.img
-rw-------  1 root root 16586061 Jul  4 11:49 initramfs-3.10.0-693.11.6.el7.smartx.1.x86_64kdump.img
-rw-r--r--. 1 root root   610343 May 31 11:00 initrd-plymouth.img
drwx------. 2 root root    12288 May 31 10:55 lost+found
-rw-r--r--. 1 root root   293110 Jan 16  2018 symvers-3.10.0-693.11.6.el7.smartx.1.x86_64.gz
-rw-------. 1 root root  3232490 Jan 16  2018 System.map-3.10.0-693.11.6.el7.smartx.1.x86_64
-rwxr-xr-x. 1 root root  5889744 May 31 11:01 vmlinuz-0-rescue-00bf5adc700644d685733d8e76c21d42
-rwxr-xr-x. 1 root root  5889744 Jan 16  2018 vmlinuz-3.10.0-693.11.6.el7.smartx.1.x86_64
[root@node112 14:41:13 ~]$uname -a
Linux node112 3.10.0-693.11.6.el7.smartx.1.x86_64 #1 SMP Tue Jan 16 22:09:10 CST 2018 x86_64 x86_64 x86_64 GNU/Linux

进行升级：

[root@node112 14:42:34 ~]$yum upgrade kernel
Loaded plugins: fastestmirror, langpacks
Loading mirror speeds from cached hostfile
Resolving Dependencies
--> Running transaction check
---> Package kernel.x86_64 0:4.4.26-201.el7.centos will be installed
--> Processing Dependency: kernel-core-uname-r = 4.4.26-201.el7.centos.x86_64 for package: kernel-4.4.26-201.el7.centos.x86_64
--> Processing Dependency: kernel-modules-uname-r = 4.4.26-201.el7.centos.x86_64 for package: kernel-4.4.26-201.el7.centos.x86_64
--> Processing Dependency: xorg-x11-drv-vmmouse >= 14.0.0 for package: kernel-4.4.26-201.el7.centos.x86_64
--> Running transaction check
---> Package kernel-core.x86_64 0:4.4.26-201.el7.centos will be installed
---> Package kernel-headers.x86_64 0:3.10.0-862.3.3.el7 will be updated
---> Package kernel-headers.x86_64 0:3.10.0-862.3.3.el7 will be obsoleted
---> Package kernel-headers.x86_64 0:4.4.26-201.el7.centos will be obsoleting
---> Package kernel-modules.x86_64 0:4.4.26-201.el7.centos will be installed
--> Finished Dependency Resolution
Dependencies Resolved
=====================================================================================================================================================================================================================================================================
 Package                                                          Arch                                                     Version                                                                    Repository                                                Size
=====================================================================================================================================================================================================================================================================
Installing:
 kernel                                                           x86_64                                                   4.4.26-201.el7.centos                                                      kernel                                                    79 k
 kernel-headers                                                   x86_64                                                   4.4.26-201.el7.centos                                                      kernel                                                   1.0 M
     replacing  kernel-headers.x86_64 3.10.0-862.3.3.el7
Installing for dependencies:
 kernel-core                                                      x86_64                                                   4.4.26-201.el7.centos                                                      kernel                                                    20 M
 kernel-modules                                                   x86_64                                                   4.4.26-201.el7.centos                                                      kernel                                                    18 M
Transaction Summary
=====================================================================================================================================================================================================================================================================
Install  2 Packages (+2 Dependent packages)
Total download size: 40 M
Is this ok [y/d/N]: y
Downloading packages:
Delta RPMs disabled because /usr/bin/applydeltarpm not installed.
(1/4): kernel-4.4.26-201.el7.centos.x86_64.rpm                                                                                                                                                                                                |  79 kB  00:00:00     
(2/4): kernel-headers-4.4.26-201.el7.centos.x86_64.rpm                                                                                                                                                                                        | 1.0 MB  00:00:00     
(3/4): kernel-modules-4.4.26-201.el7.centos.x86_64.rpm                                                                                                                                                                                        |  18 MB  00:00:00     
(4/4): kernel-core-4.4.26-201.el7.centos.x86_64.rpm                                                                                                                                                                                           |  20 MB  00:00:00     
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Total                                                                                                                                                                                                                                 58 MB/s |  40 MB  00:00:00     
Running transaction check
Running transaction test
Transaction test succeeded
Running transaction
Warning: RPMDB altered outside of yum.
  Installing : kernel-core-4.4.26-201.el7.centos.x86_64                                                                                                                                                                                                          1/5 
  Installing : kernel-modules-4.4.26-201.el7.centos.x86_64                                                                                                                                                                                                       2/5 
  Installing : kernel-headers-4.4.26-201.el7.centos.x86_64                                                                                                                                                                                                       3/5 
  Installing : kernel-4.4.26-201.el7.centos.x86_64                                                                                                                                                                                                               4/5 
  Cleanup    : kernel-headers-3.10.0-862.3.3.el7.x86_64                                                                                                                                                                                                          5/5 
  Verifying  : kernel-core-4.4.26-201.el7.centos.x86_64                                                                                                                                                                                                          1/5 
  Verifying  : kernel-headers-4.4.26-201.el7.centos.x86_64                                                                                                                                                                                                       2/5 
  Verifying  : kernel-4.4.26-201.el7.centos.x86_64                                                                                                                                                                                                               3/5 
  Verifying  : kernel-modules-4.4.26-201.el7.centos.x86_64                                                                                                                                                                                                       4/5 
  Verifying  : kernel-headers-3.10.0-862.3.3.el7.x86_64                                                                                                                                                                                                          5/5 
  Verifying  : kernel-headers-3.10.0-862.3.3.el7.x86_64                                                                                                                                                                                                          6/5 
Installed:
  kernel.x86_64 0:4.4.26-201.el7.centos                                                                                         kernel-headers.x86_64 0:4.4.26-201.el7.centos                                                                                        
Dependency Installed:
  kernel-core.x86_64 0:4.4.26-201.el7.centos                                                                                      kernel-modules.x86_64 0:4.4.26-201.el7.centos                                                                                     
Replaced:
  kernel-headers.x86_64 0:3.10.0-862.3.3.el7                                                                                                                                                                                                                         
Complete!

可以看到，仍然没有自动清理掉旧的 Kernel， /boot 分区的空间还是被占用了。

[root@node112 14:43:49 ~]$ll /boot/
total 151870
-rw-r--r--. 1 root root   140924 Jan 16  2018 config-3.10.0-693.11.6.el7.smartx.1.x86_64
-rw-r--r--  1 root root   169326 Oct 21  2016 config-4.4.26-201.el7.centos.x86_64
drwxr-xr-x. 3 root root     1024 May 31 10:55 efi
drwxr-xr-x. 2 root root     1024 May 31 10:56 grub
drwx------. 5 root root     1024 Aug  9 14:43 grub2
-rw-------. 1 root root 57008277 May 31 11:01 initramfs-0-rescue-00bf5adc700644d685733d8e76c21d42.img
-rw-------. 1 root root 17249662 May 31 11:01 initramfs-3.10.0-229.el7.x86_64.img
-rw-------. 1 root root 20945698 May 31 11:02 initramfs-3.10.0-693.11.6.el7.smartx.1.x86_64.img
-rw-------  1 root root 16586061 Jul  4 11:49 initramfs-3.10.0-693.11.6.el7.smartx.1.x86_64kdump.img
-rw-------  1 root root 18048069 Aug  9 14:43 initramfs-4.4.26-201.el7.centos.x86_64.img
-rw-r--r--. 1 root root   610343 May 31 11:00 initrd-plymouth.img
drwx------. 2 root root    12288 May 31 10:55 lost+found
-rw-r--r--. 1 root root   293110 Jan 16  2018 symvers-3.10.0-693.11.6.el7.smartx.1.x86_64.gz
-rw-------. 1 root root  3232490 Jan 16  2018 System.map-3.10.0-693.11.6.el7.smartx.1.x86_64
-rw-------  1 root root  3265893 Oct 21  2016 System.map-4.4.26-201.el7.centos.x86_64
-rwxr-xr-x. 1 root root  5889744 May 31 11:01 vmlinuz-0-rescue-00bf5adc700644d685733d8e76c21d42
-rwxr-xr-x. 1 root root  5889744 Jan 16  2018 vmlinuz-3.10.0-693.11.6.el7.smartx.1.x86_64
-rwxr-xr-x  1 root root  6148096 Oct 21  2016 vmlinuz-4.4.26-201.el7.centos.x86_64

正确清理方式

1
2
3

[root@node112 14:44:11 ~]$rpm -q kernel
kernel-3.10.0-693.11.6.el7.smartx.1.x86_64
kernel-4.4.26-201.el7.centos.x86_64

使用 yum-utils 中提供的 package-cleanup 工具：

1 2	[root@node112 14:48:02 ~]$rpm -qf `which package-cleanup` yum-utils-1.1.31-42.el7.noarch

在我们重启过 OS，并确保已经使用升级后的 Kernel 后，进行如下操作：

[root@node112 14:53:44 ~]$uname -a
Linux node112 4.4.26-201.el7.centos.x86_64 #1 SMP Thu Oct 20 17:49:17 UTC 2016 x86_64 x86_64 x86_64 GNU/Linux
[root@node112 14:53:46 ~]$package-cleanup --oldkernels --count=1
Loaded plugins: fastestmirror, langpacks
--> Running transaction check
---> Package kernel.x86_64 0:3.10.0-693.11.6.el7.smartx.1 will be erased
--> Processing Dependency: kernel(__alloc_workqueue_key) = 0x43a53735 for package: kmod-mpt3sas-24.125.01.00_el7.4-1.x86_64
--> Processing Dependency: kernel(__bitmap_or) = 0x9f2bdaac for package: kmod-mpt3sas-24.125.01.00_el7.4-1.x86_64
--> Processing Dependency: kernel(__bitmap_weight) = 0x4cbbd171 for package: kmod-mpt3sas-24.125.01.00_el7.4-1.x86_64
--> Running transaction check
---> Package kmod-mpt3sas.x86_64 0:24.125.01.00_el7.4-1 will be erased
--> Finished Dependency Resolution
Dependencies Resolved
=====================================================================================================================================================================================================================================================================
 Package                                                      Arch                                                   Version                                                                         Repository                                                 Size
=====================================================================================================================================================================================================================================================================
Removing:
 kernel                                                       x86_64                                                 3.10.0-693.11.6.el7.smartx.1                                                    @anaconda                                                  60 M
Removing for dependencies:
 kmod-mpt3sas                                                 x86_64                                                 24.125.01.00_el7.4-1                                                            @anaconda                                                 5.3 M
Transaction Summary
=====================================================================================================================================================================================================================================================================
Remove  1 Package (+1 Dependent package)
Installed size: 65 M
Is this ok [y/N]: y
Downloading packages:
Running transaction check
Running transaction test
Transaction test succeeded
Running transaction
  Erasing    : kmod-mpt3sas-24.125.01.00_el7.4-1.x86_64                                                                                                                                                                                                          1/2 
  Erasing    : kernel-3.10.0-693.11.6.el7.smartx.1.x86_64                                                                                                                                                                                                        2/2 
  Verifying  : kernel-3.10.0-693.11.6.el7.smartx.1.x86_64                                                                                                                                                                                                        1/2 
  Verifying  : kmod-mpt3sas-24.125.01.00_el7.4-1.x86_64                                                                                                                                                                                                          2/2 
Removed:
  kernel.x86_64 0:3.10.0-693.11.6.el7.smartx.1                                                                                                                                                                                                                       
Dependency Removed:
  kmod-mpt3sas.x86_64 0:24.125.01.00_el7.4-1                                                                                                                                                                                                                         
Complete!

现在我们来看下 /boot 分区情况：

[root@node112 14:54:41 ~]$ll /boot/
total 105878
-rw-r--r--  1 root root   169326 Oct 21  2016 config-4.4.26-201.el7.centos.x86_64
drwxr-xr-x. 3 root root     1024 May 31 10:55 efi
drwxr-xr-x. 2 root root     1024 May 31 10:56 grub
drwx------. 5 root root     1024 Aug  9 14:54 grub2
-rw-------. 1 root root 57008277 May 31 11:01 initramfs-0-rescue-00bf5adc700644d685733d8e76c21d42.img
-rw-------. 1 root root 17249662 May 31 11:01 initramfs-3.10.0-229.el7.x86_64.img
-rw-------  1 root root 18048069 Aug  9 14:43 initramfs-4.4.26-201.el7.centos.x86_64.img
-rw-r--r--. 1 root root   610343 May 31 11:00 initrd-plymouth.img
drwx------. 2 root root    12288 May 31 10:55 lost+found
-rw-------  1 root root  3265893 Oct 21  2016 System.map-4.4.26-201.el7.centos.x86_64
-rwxr-xr-x. 1 root root  5889744 May 31 11:01 vmlinuz-0-rescue-00bf5adc700644d685733d8e76c21d42
-rwxr-xr-x  1 root root  6148096 Oct 21  2016 vmlinuz-4.4.26-201.el7.centos.x86_64

可以旧的 Kernel 内核文件已经被清除了。

总结

在进行软件包卸载的时候，尤其是像 Kernel 这种会影响到服务器运行的软件包，我们操作一定要谨慎，不要轻易的执行 rpm -e --nodeps 或者 yum -y remove 等操作。尽量保证服务器安全性。

CentOS LiveCD 构建及修改方式

发表于 2018-08-04 |

背景

Linux 作为目前服务器占比超过 60% 的操作系统，日常使用过程中，都是采用官方发布的 DVD ISO 安装，可以选择安装桌面版本还是 Minimal 版本。但是如果我们想要验证服务器硬件是否满足产品需求，就需要通过 Live CD 的方式先在内存中运行操作系统，然后进行硬件检测。通过这种方式可以在最小成本（无需安装操作系统到磁盘中）下完成硬件检测。目前 OpenStack 厂商 Mirantis 及云计算厂商 Nutanix 均采用该种方式进行产品安装前校验。要进行校验的第一步，就是构建属于我们自己的 Live CD ISO，下面以 CentOS 为例介绍如何构建和定制 Live CD ISO。

流程

准备构建工具
编写 KickStart 脚本
准备软件源
构建

构建工具

核心工具 livecd-creator。
构建环境为 CentOS 7。指定官方 yum repo：

root@yiran-30-250:/etc/yum.repos.d
 $ ll
总用量 56K
-rw-r--r--  1 root root 1.7K 1月  15 2018 CentOS-Base.repo
-rw-r--r--. 1 root root 1.3K 12月  9 2015 CentOS-CR.repo
-rw-r--r--. 1 root root  649 12月  9 2015 CentOS-Debuginfo.repo
-rw-r--r--. 1 root root  290 12月  9 2015 CentOS-fasttrack.repo
-rw-r--r--. 1 root root  630 12月  9 2015 CentOS-Media.repo
-rw-r--r--  1 root root  916 5月  23 2016 CentOS-SCLo-scl.repo
-rw-r--r--  1 root root  892 5月  23 2016 CentOS-SCLo-scl-rh.repo
-rw-r--r--. 1 root root 1.3K 12月  9 2015 CentOS-Sources.repo
-rw-r--r--. 1 root root 2.0K 12月  9 2015 CentOS-Vault.repo
-rw-r--r--  1 root root  951 10月  3 2017 epel.repo
-rw-r--r--  1 root root 1.1K 10月  3 2017 epel-testing.repo
-rw-r--r--  1 root root  306 7月   2 13:58 mcepl-vim8-epel-7.repo
-rw-r--r--  1 root root 3.2K 6月  23 19:00 smartx-idc.repo

通过 Yum 安装，会自动安装相应依赖软件包：

1	yum install -y livecd-tools

KickStart 脚本

什么是 KickStart？许多系统管理员更愿意使用自动安装方法在其服务器上安装 Red Hat Enterprise Linux。为了满足这一需求，Red Hat 创建了 KickStart 安装方法。具体 KickStart 编写语法查看 RedHat 官方查看
这里我们可以先参考官方样例，先确保通过官方样例可以构建成功，我们再来进行自己的定制操作。
将官方样例下载到本地，接下来看下面一节，不着急定制。

如果按照官方样例已经正确构建了自己的 ISO，那么我们下面来看如何进行简单的定制，如配置网络。
打开 KickStart.cfg 文件，我们可以看到除了特定的语法外，其他的都是 Shell 脚本，可见 KickStart 是兼容 Shell 语法的，那么我们就可以直接在 KickStart 内指定要进行的事情。
如启动之后配置网卡信息：

# config eth0
cat > /etc/sysconfig/network-scripts/ifcfg-eth0 << EOF
DEVICE=eth0
IPADDR=192.168.30.253
NETMASK=255.255.240.0
GATEWAY=192.168.16.1
ONBOOT=yes
NAME=eth0
EOF
ifup eth0

或者安装某指定软件并自动启动：

# install & start & enable dhcpd
yum install -y dhcpd
systemctl enable dhcpd
systemctl start dhcpd
tail -n 10 /var/lib/dhcpd/dhcpd.leases

准备软件源

在之前的博客中我们介绍过 RPM 及 Yum 等工具的概念及使用。
我们现在需要构建一个本地的 Yum Repo。通用做法为：

$cd /data/
$mkdir packages
$cp $some_packages packages
$createrepo .

这样我们就创建好了一个本地的 Yum repo，如何让本地 Yum 生效呢？
我们可以通过 http 或者 ftp 的方式配置，只需要将 /data/packages 这个路径允许通过文件方式访问。

上面这种方式通常用于定制化使用，我们此处为了简化操作，可以直接拷贝一个官方 ISO，挂载到本地的方式作为本地 Yum Repo。具体操作如下：

$cd /data/
$mkdir /data/centos7
$mount CentOS-7.4-x86_64-DVD-1708.iso /data/centos7
$mkdir /etc/yum.repos.d/bk
$mv /etc/yum.repos.d/*.repo /etc/yum.repos.d/bk/
$cat > /etc/yum.repos.d/local.repo << EOF
[local]
name=local
baseurl=file:///data/centos7
enabled=1
gpgcheck=0
EOF
$

我们就可以通过 yum 的方式安装软件包了。

构建 Live CD ISO

在一切准备好之后，我们开始构建 ISO。
编辑官方样例，将 17 & 18 行替换为如下文件，指定我们刚刚指定的本地 Yum repo：

1	repo --name=base --baseurl=file:///data/packages

使用 livecd-tools 构建名为 yiran-live.iso：

1	livecd-creator -v --config centos-7-livecd.cfg --cache /var/cache/livecd --name yiran-livecd

构建过程大概需要 5 ~ 10 分钟，构建完成后我们可以再当前路径下看到 yiran-livecd.iso，我们来看下 ISO 中的目录结构：

$mkdir /tmp/yiran-livecd
$mount yiran-livecd.iso /tmp/yiran-livecd
$tree /tmp/yiran-livecd
/tmp/yiran-livecd
├── isolinux
│   ├── boot.cat
│   ├── initrd0.img
│   ├── isolinux.bin
│   ├── isolinux.cfg
│   ├── vesamenu.c32
│   └── vmlinuz0
└── LiveOS
    ├── osmin.img
    └── squashfs.img

可以看到，用于启动引导的文件均在 isolinux 路径下，而设计到文件系统相关的文件均被打包压缩到 squashfs.img 中，如果想要更多的定制方式，我们就需要解压这个 img 文件并修改对应路径下的内容，然后再压缩重新制作 ISO，这里不深入介绍。

总结

构建属于自己的 ISO 可以很方便的在日常工作中开展工作，我们可以直接挂载 LiveCD 并直接查看磁盘内容，可以把我们常用的内置软件放到 ISO 中，减少重复的安装操作。

LiveCD 工作中用处不多，硬件检查是一项很符合 LiveCD 本职功能的需求，无论是时间成本还是实现成本都是很低的，推荐使用。

RPM 常用构建方式

发表于 2018-07-28 |

背景

作为一个标准化的产品，需要提供简单快捷的软件安装方式，比如 Python pip、 Ubuntu apt-get、SUSE zypper 或者是 CentOS/RHEL yum。都可以让用户快速的安装产品并上手使用，极大的节省了软件安装的时间。因为工作中使用的发行版是 CentOS/RHEL 系列，常用的方式是 RPM。
本文介绍下常用的集中构建 RPM 软件包方式，便于快速上手构建属于自己的 RPM。

RPM 介绍

什么是 RPM？ RPM 全称为 RedHat Package Manager，也就是常见的以 .rpm 为后缀的软件包。属于 RedHat 系列发行版的通用软件包解决方式。
在安装 CentOS(RHEL，以下 CentOS 均可适用于 RHEL)操作系统时，我们可以选择要安装的软件包，默认系统安装为 Minimal 模式，只包含系统必要的 RPM。

理论上操作系统上所有的软件都是通过 RPM 的方式安装的，比如常用的 Kernel、GCC、LS 等工具。

RPM 使用

在进行 RPM 安装时，通常会遇到一个问题：依赖。由于某些特定的软件包在使用时，要求系统必须安装其所依赖的软件才可以正常工作，因此我们需要查看要安装的软件包的依赖。

root@yiran-30-250:~/project/Blog
master ✔ $ rpm -qR sos-3.2-35.el7.centos.3.noarch
/usr/bin/python
bzip2
config(sos) = 3.2-35.el7.centos.3
libxml2-python
python(abi) = 2.7
python-six
rpmlib(CompressedFileNames) <= 3.0.4-1
rpmlib(FileDigests) <= 4.6.0-1
rpmlib(PartialHardlinkSets) <= 4.0.4-1
rpmlib(PayloadFilesHavePrefix) <= 4.0-1
xz
rpmlib(PayloadIsXz) <= 5.2-1

在安装之前博客提到的 sos 软件时，需要安装 Python、bzip、config 等软件包才可以正常使用 sos。

此时遇到一个问题，如果 bzip 又依赖某些其他的 RPM，我们如何解决呢，当然可以继续使用 rpm -qR 来查看 bzip 的依赖，然后手动进行安装，但是 Duke University 团队提供了更好用的工具：Yum(Yellow dog Updater, Modified)。可以自动帮助我们解决 RPM 依赖问题。我们只需要在 /etc/yum.repos.d/ 路径下配置合理的 yum repo 配置文件，就可以直接使用 yum install sos 的方式安装软件包。在 Fedora 22 版本之后，提供了新的工具叫做 DNF，标称为 Yum 下一代工具（但我没觉得有多好用。。。）。

RPM 构建方式

简单介绍了 RPM 的基础使用，具体常用的操作比如：升级、卸载、强制安装、不检查依赖卸载等操作，需要大家自行 Google。

下面介绍两种方式构建 RPM。

rpmbuild

常规构建 RPM 方式是使用 rpmbuild 工具，我们需要自己编写好相应的 spec 文件，打包压缩好要构建的软件，完成 RPM 构建，下面讲解具体方式。

安装 rpm-build

使用 yum 命令安装： yum install rpm-build 。会自动将 rpm-build 依赖软件安装，依赖包名如下：

elfutils-libelf
rpm
rpm-libs
rpm-python

RPM 构建路径

在 rpm-build 安装完成后，会自动在 /root/ 下创建相应 rpmbuild 文件夹，会包含构建 RPM 所必须的路径，你也可以之后构建时手动指定路径，但是不推荐新手这种方式，会增加 debug 成本，默认就好。

准备 tar 软件包

在准备工作完成后，我们需要准备软件包源文件，并放置 /root/rpmbuild/SOURCES/ 路径下。开源软件包通常可以在晚上下载到，如果是本地 git 管理的仓库，也可以通过以下方式自动生成 Tar 包。

1	git archive --format=tar.gz --prefix=$RPM_VERSION HEAD > /root/rpmbuild/SOURCES/

创建 SPEC 文件

接下来是最重要的一步，也是出错最多的一步，准备 SPEC 文件。

SPEC 配置文件指定了在 RPM 构建时进行的操作，和 RPM 安装时执行的操作、拷贝对应源文件到哪个路径、要创建哪些文件夹等。

我们仍以 sos 作为示例，sos 作为 RedHat 开源软件，在 Github 上是包含了对应的 sos.spec 文件的。

截取重要的部分：

%{!?python_sitelib: %define python_sitelib %(%{__python} -c "from distutils.sysconfig import get_python_lib; print get_python_lib()")}
Summary: A set of tools to gather troubleshooting information from a system   
# rpm package summary info
Name: sos                         											  
# rpm package name
Version: 3.6																  
# rpm package version
Release: 1%{?dist}															  
# rpm release number
Group: Applications/System     												  
# rpm group name
Source0: http://people.redhat.com/breeves/sos/releases/sos-%{version}.tar.gz  
# rpm software tar package name, abs path
License: GPLv2+																  
# rpm license
BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot                
# rpm build path
BuildArch: noarch   													      
# rpm arch version: x86_64/noarch/i686
Url: http://fedorahosted.org/sos
BuildRequires: python-devel													  
# rpm build dependency package
BuildRequires: gettext														  
# ...
BuildRequires: python-six													  
# ...
Requires: libxml2-python													  
# rpm install dependency package
Requires: rpm-python														  
# ...
Requires: tar
Requires: bzip2
Requires: xz
Requires: python-six
Requires: python-futures
%description																  
# rpm package description
Sos is a set of tools that gathers information about system
hardware and configuration. The information can then be used for
diagnostic purposes and debugging. Sos is commonly used to help
support technicians and developers.
%prep
%setup -q
%build
make																		  
# rpm build method: make/setup.py
%install																	  
# perform operations when the package is installed
rm -rf ${RPM_BUILD_ROOT}
make DESTDIR=${RPM_BUILD_ROOT} install
%find_lang %{name} || echo 0
%clean 																		  
# perform operations when rpm package build success
rm -rf ${RPM_BUILD_ROOT}
%files -f %{name}.lang     													  
# rpm install software file path
%defattr(-,root,root,-)
%{_sbindir}/sosreport
%{_datadir}/%{name}
%{python_sitelib}/*
%{_mandir}/man1/*
%{_mandir}/man5/*
%doc AUTHORS README.md LICENSE
%doc /usr/share/doc/sos/html
%config(noreplace) %{_sysconfdir}/sos.conf
%changelog																	  
# software changelog
* Thu Nov 02 2017 Bryn M. Reeves <bmr@redhat.com> = 3.5
- New upstream release

可以看到，SPEC 文件的编写要指定的东西还是很多的，我们需要配置好每一项所做的操作，才能保证软件正确安装。

{_datadir}, {_mandir} 等类似的宏定义，可以查看 Fedora 维基了解详情。

构建

上述操作均完成后，我们可以进行真正的构建操作了，执行 rpmbuild -ba sos.spec ，如果构建成功后，我们可以再 /root/rpmbuild/SRPMS/ /root/rpmbuild/RPMS 下看到对应的 RPM 源文件包和 RPM 软件包，SRPMS 内的软件包，可以让我们之后的构建更轻松，如果不更改 spec 时，我们可以直接 rpm -ivh sos*src.rpm 安装后，即可再次执行 rpmbuild -ba sos.spec 进行构建。

验证 RPM 正确性

最简单的验证方式就是在测试环境中安装刚刚构建出的软件包，如果相应的配置、源文件已经在正确的路径下，则安装成功。

FPM

概念

什么是 FPM？ FPM 是一个命令行工具用于构建软件包，软件包来源支持的种类很多，如: dir/gem/rpm/python/pear 等等。
通过 FPM 我们可以很轻松的构建 RPM，不用再编写那一堆 spec 文件中的参数了。所有参数都可以通过命令行 option 的方式添加，方便快捷。

安装

从 https://rubygems.org/ 下载并安装 gem。也可以通过 yum install ruby-devel gcc 方式安装。
安装完成后，默认的 gem 源指定的是国外的，我们可以替换成 taobao ：

1 2	gem source --remove https://rubygems.org/ gem source --add https://ruby.taobao.org

然后执行 gem install fpm 记了。

使用

如果我们要构建一个 python 软件包，如 pyroute2。我们可以这样操作：

root@yiran-30-250:~
 $ fpm -s python -t rpm -a noarch -n python2-pyroute2 pyroute2
Created package {:path=>"python2-pyroute2-0.5.2-1.noarch.rpm"}
root@yiran-30-250:~
 $ ll -trh |grep python2-pyroute2
-rw-r--r--  1 root root 208K 7月  28 07:50 python2-pyroute2-0.5.2-1.noarch.rpm

只需一条命令就可以自动从 pypi 上下载源软件包并构建出对应的 rpm。

如果我们此时不止要构建 rpm，还要指定 rpm 的依赖关系，我们可以这样做：

root@yiran-30-250:~
 $ fpm -s python -t rpm -a x86_64 -n python2-crypto -v 2.6.1 --iteration 1.el7 --depends "python-pycrypto"
Created package {:path=>"python2-crypto-2.6.1-1.el7.x86_64.rpm"}
root@yiran-30-250:~
 $ ll -trh |grep python2-crypto
-rw-r--r--  1 root root 1.5K 7月  28 07:52 python2-crypto-2.6.1-1.el7.x86_64.rpm
root@yiran-30-250:~
 $ rpm -qpR python2-crypto-2.6.1-1.el7.x86_64.rpm
python-pycrypto
rpmlib(PayloadFilesHavePrefix) <= 4.0-1
rpmlib(CompressedFileNames) <= 3.0.4-1

总结

日常用到的 RPM，推荐还是 Google，基本上常见版本都会有。如果我们要构建自己需要的指定版本第三方 RPM，推荐使用 FPM 的方式，可以省去很多烦恼。
但是如果我们需要对自己编写、维护的软件进行 RPM 构建，那还是推荐 rpmbuild 方式，毕竟可以指定 RPM 安装前，安装时，安装后的所有操作，可以根据自己需求定义操作，很强大。

吐槽

目前主要工作是使用 Python。在 Python 引入第三方依赖时，软件包名字很头疼，如果软件包名不同，但是源文件是相同的，RPM 安装时会提示软件包冲突，此时就需要自己去解决冲突，如果要安装的软件依赖于 A，系统已经安装了 B，目前我常用的方式有：

rpm -ivh A –replacefiles # 强制安装 A
rpm -e B –nodeps ; rpm -ivh A # 因为 A 与 B 源文件相同，在版本相同的情况下，这种方式是最快的解决办法
Build 一个空的软件包，名字为 A，依赖于 B。这样我们可以直接安装 A，因为 A 是空的，不做任何操作，安装完 A 后，系统同时存在 A & B，此时再安装依赖于 A 的软件就可以正常安装了

目前已经见过以下几种 Python RPM 命名方式了：

python-pyroute2
python2-pyroute2
pyroute2
…

真是无力吐槽啊。。。。