不过作为我们DevOps, 不是所有语言都能拿得起放得下(自黑), 在写自动化脚本过程中势必要跟我们的Jenkins本家groovy脚本语言打交道, 这玩意可是直接能够调用Jenkins API的敲门砖, 但是前提你能玩得转他的API doc, 本铲屎官给Jenkins铲屎已经够意思了, 还让我去研究如果优雅的铲屎, 不留一丝痕迹? 

这里多亏了Docker swam和JCasC, 他们组合起来就能把我们可爱的Jenkins小宠宠瞬间打回一只可以被随时替代的小牛, 我们可以不必一天在给Jenkins遛弯的过程, 怕他走丢啦, 怕他肚子吃坏啦, 怕他被人欺负了, 给他打一针JCasC, 扔进Docker Swarm牛圈, 瞬间变成一只可被随时打入冷宫的小牛, 想怎么玩就怎么玩, 玩坏了分分钟扔掉并直接给他再克隆一只, 是不是很神奇?

闲话不多说, 其实宠物和牛对应的就是可变基础设施与不可变基础设施, 具体的基础设施我们可以拿vm与docker做比较.

可变基础设施vs不可变基础设施:

可变基础设施: 服务器会不断更新和修改。使用此类基础架构的工程师和管理员可以通过SSH连接到他们的服务器，手动升级或降级软件包，逐个服务器地调整配置文件，以及将新代码直接部署到现有服务器上。换句话说，这些服务器是可变的; 它们可以在创建后进行更改。

不可变基础设施: 他们部署了服务器之后决不会被修改。如果需要以任何方式更新，修复或修改某些内容，则会根据具有相应更改的公共映像构建新服务器以替换旧服务器。经过验证后，它们就会投入使用，而旧的则会退役。

比起传统的虚拟机基础环境, 使用docker本身就能让我们节省资源的同时快速构建我们的应用, 他的持续集成、版本控制、可移植性、隔离性和安全性能够让我们摆脱传统的可变基础设施(宠物), 让我们不必去在对他创建后进行任何配置更改, 只需要把他当做牛一样, 所有的配置都在牛(镜像)使用前进行版本配置变更, 使用时直接扔到docker swarm, 做到召之即来挥之即去, 降低我们的运维成本.

这里的Jenkins CasC plugin对我们的Jenkins在不可变基础设施中又做了一次二次优化, 他让我们原本需要去在我们的自动化脚本内嵌入groovy语言变成了历史, 我们只需要按照插件的语法格式编写一个human readable的yaml文件并嵌入Jenkins docker启动, 他就能自动化帮我们完成装插件, 配slave节点, 配环境变量, 配CI工具, 配后台管理权限等工作, 真正做到快速版本迭代更新, 节省了我们大量版本更新时花费的人力物力.

OK, Let's rack and roll...

安装环境

system: CentOS 7.4 x64

Docker: 17.12.0-ce

Jenkins docker image: 2.164.1

Docker manager node:  192.168.0.102

Docker worker1 node:   192.168.0.102

Docker worker2 node:   192.168.0.104

一. 系统环境配置

1.关闭iptables和selinux

# su - root

# systemctl stop firewalld

# setenforce 0

# vi /etc/sysconfig/selinux

修改

SELINUX=disabled

2.在三台节点分别添加本地host DNS

# vi /etc/hosts

192.168.0.102  manage
192.168.0.103  worker1
192.168.0.104  worker2

3.更改对应系统主机名
Manager:
# hostnamectl set-hostname manager
Worker1:
# hostnamectl set-hostname worker1
Worker2
# hostnamectl set-hostname worker2

二. 安装Docker Engine

1. 下载yum镜像源

# wget https://download.docker.com/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker.repo

2. 安装docker engine

# yum install docker-ce –y

3.启动docker service 

# systemctl start docker
# systemctl enable docker

4.创建docker manager节点(manager)

# docker swarm init --advertise-addr 192.168.0.102

Swarm initialized: current node (viwovkb0bk0kxlk98r78apopo) is now a manager.

To add a worker to this swarm, run the following command:

    docker swarm join --token SWMTKN-1-3793hvb71g0a6ubkgq8zgk9w99hlusajtmj5aqr3n2wrhzzf8z-    1s38lymnir13hhso1qxt5pqru 192.168.0.102:2377

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

5.加入worker节点到manager节点(worker1, worker2)

# docker swarm join --token SWMTKN-1-3793hvb71g0a6ubkgq8zgk9w99hlusajtmj5aqr3n2wrhzzf8z-1s38lymnir13hhso1qxt5pqru 192.168.0.102:2377

6.查看节点连接信息

# docker node ls

ID                            HOSTNAME           STATUS              AVAILABILITY        MANAGER STATUS
viwovkb0bk0kxlk98r78apopo *   manager            Ready               Active              Leader
yf6nb2er69pydlp6drijdfmwd     worker1            Ready               Active              
yyavdslji7ovmw5fd3v7l62g8     worker2            Ready               Active         

7.在docker swarm下创建http服务

# docker service create -p 80:80 --name webservice --replicas 5 httpd

ID                  NAME                IMAGE               NODE               DESIRED STATE       CURRENT STATE       ERROR           PORTS
xsa5wb0eg2ln        webservice.1        httpd:latest        manager            Running             Running about 10 minutes ago                                       
3sbscs7m9lnh        webservice.2        httpd:latest        worker2            Running             Running about 10 minutes ago                                      
yao2m5wi54kz        webservice.3        httpd:latest        worker2            Running             Running about 10 minutes ago                                 
dfg2mswa52sf        webservice.4        httpd:latest        worker1            Running             Running about 15 seconds ago                                 
kah1j5hs14as        webservice.5        httpd:latest        worker1            Running             Running about 15 seconds ago                                 

8.测试http站点

# curl 192.168.0.102

It works...

三.在docker swarm下构建Jenkins cluster with configuration as code

详见作者的github仓库

https://github.com/showerlee/docker-compose-with-JCasC

大功告成...

这里k8s官方给我们提供了两种比较主流的连接k8s API cluster的语言, 一种是GO, 另外一种就是我们DevOps比较主流的Python.

今天这里我将给大家介绍如何使用python client扩展包去编写脚本并远程连接k8s API cluster.

这样我们平时除了可以远程使用ssh+kubectl去与kubernetes进行命令行数据交互外, 同样可以在远程不依赖命令行直接连接k8s cluster API cluster, 与k8s进行python API交互, 方便我们后期利用python去对k8s进行自动化集成与二次开发.

这里我们不多说, 直接进入我们的runbook配置环节:

一.部署python client环境连接我们的k8s API cluster.

1.安装python3.6.5源及依赖包

# yum install epel-release -y

# yum groupinstall "Development tools" -y

# yum install zlib-devel bzip2-devel openssl-devel ncurses-devel zx-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel -y

2.编译安装python3.6.5以及pip package manager

# wget https://www.python.org/ftp/python/3.6.5/Python-3.6.5.tar.xz --no-check-certificate

# tar xf Python-3.6.5.tar.xz

# cd Python-3.6.5

# ./configure --prefix=/usr/local --with-ensurepip=install --enable-shared LDFLAGS="-Wl,-rpath /usr/local/lib"

# make && make altinstall

3.安装virtualenv

# pip3.6 install --upgrade pip

# pip3.6 install virtualenv

4.配置加载virtualenv环境

# virtualenv -p /usr/local/bin/python3 .py3env

# source .py3env/bin/activate

5.安装kubernetes python client扩展包

# pip install kubernetes

二.在k8s master获取API cluster URL与token

我们需要在创建python脚本前, 在k8s主机上创建一个admin权限的service account, 并获取其token 用来作为我们的脚本凭证.

1.抓取Cluster URL地址

# APISERVER=$(kubectl config view --minify | grep server | cut -f 2- -d ":" | tr -d " ")

# echo $APISERVER

2.创建k8s admin-user

# mkdir -p /kube/role

# cd /kube/role

在kube-system下创建admin-user

# vi CreateServiceAccount.yaml

apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin-user
  namespace: kube-system

给admin-user赋予admin权限

# vi CreateServiceAccount.yaml

apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: admin-user
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: admin-user
  namespace: kube-system

# kubectl create -f CreateServiceAccount.yaml
# kubectl create -f RoleBinding.yaml

3.获取admin-user token

# Token=$(kubectl describe secret $(kubectl get secret -n kube-system | grep ^admin-user | awk '{print $1}') -n kube-system | grep -E '^token'| awk '{print $2}')

# echo $Token

最后将token与APISERVER地址返回内容复制到python client主机上, 供脚本使用.

三. 在python client主机上编写脚本

1. 创建目录结构

# mkdir -p /kube/auth

# cd /kube/auth

# touch token.txt

2. 创建token.txt文件并将k8s主机上获取的Token字符串复制到该文件

这里我们获取的token会引入到我们的脚本下, 作为bearer authorization的api key与远程k8s API建立认证连接.

3. 编写python client脚本

# vi k8s_auth.py

#!/usr/bin/env python


from kubernetes import client, config


def main():
    # Define the barer token we are going to use to authenticate.
    # See here to create the token:
    # https://kubernetes.io/docs/tasks/access-application-cluster/access-cluster/

    with open('token.txt', 'r') as file:
        Token = file.read().strip('\n')

    APISERVER = 'https://10.110.16.14:6443'

    # Create a configuration object
    configuration = client.Configuration()

    # Specify the endpoint of your Kube cluster
    configuration.host = APISERVER

    # Security part.
    # In this simple example we are not going to verify the SSL certificate of
    # the remote cluster (for simplicity reason)
    configuration.verify_ssl = False

    # Nevertheless if you want to do it you can with these 2 parameters
    # configuration.verify_ssl=True
    # ssl_ca_cert is the filepath to the file that contains the certificate.
    # configuration.ssl_ca_cert="certificate"
    configuration.api_key = {"authorization": "Bearer " + Token}

    # configuration.api_key["authorization"] = "bearer " + Token
    # configuration.api_key_prefix['authorization'] = 'Bearer'
    # configuration.ssl_ca_cert = 'ca.crt'
    # Create a ApiClient with our config
    client.Configuration.set_default(configuration)

    # Do calls
    v1 = client.CoreV1Api()
    print("Listing pods with their IPs:")
    ret = v1.list_pod_for_all_namespaces(watch=False)
    for i in ret.items:
        print("%s\t%s\t%s" %
              (i.status.pod_ip, i.metadata.namespace, i.metadata.name))


if __name__ == '__main__':
    main()

这个脚本通过抓取同目录的k8s token字符串, 以及我们之前获取到的api server地址,利用python kubernetes扩展模块连接我们的远程API, 最终实现打印我们k8s所有namespace下的所有pods.

实际效果与kubectl get pods --all-namespaces类似.

4. 修改权限并执行

# chmod 755 k8s_auth.py

# ./k8s_auth.py

Listing pods with their IPs:
...
10.244.1.3	default	db
10.244.1.2	default	kubernetes-downwardapi-volume-example
10.244.1.245	default	nginx1-7-deployment-667547b6d8-c5nsr
10.244.1.239	default	nginx1-7-deployment-667547b6d8-mjxq4
10.244.1.247	default	nginx1-8-deployment-d46768cf9-888v8
10.244.1.242	default	nginx1-8-deployment-d46768cf9-fglq2
10.110.16.14	kube-system	etcd-kube-master
10.110.16.14	kube-system	kube-apiserver-kube-master
10.110.16.14	kube-system	kube-controller-manager-kube-master
10.244.1.241	kube-system	kube-dns-6f4fd4bdf-qsxrj
10.110.16.14	kube-system	kube-flannel-ds-5sdlg
10.110.16.15	kube-system	kube-flannel-ds-qctv4
10.110.16.14	kube-system	kube-proxy-5nscq
10.110.16.15	kube-system	kube-proxy-6g7jc
10.110.16.14	kube-system	kube-scheduler-kube-master
10.244.1.246	kube-system	kubernetes-dashboard-58f5cb49c-6dxgn
10.244.1.240	kube-system	tiller-deploy-cbb85d8dc-f6rsv
10.110.16.15	kube-system	traefik-ingress-lb-765c44656f-fkzxb
10.244.1.243	spinnaker	kubelive-create-bucket-wxlv4
10.244.1.244	spinnaker	kubelive-delete-jobs-zhn75

这样我们就成功的编写完成python client脚本连接k8s API cluster, 将所有namespace下的pod的基本信息打印出来.

Finished...

Beautiful Soup主要从解析好的HTML源码中抓取我们所需要的关键内容

Pandas与Beautiful Soup类似, 不过它侧重去抓取源码中的表格信息

pyqt5这里的作用是模拟浏览器去解析源码中的Javasript, 并最终抓取JS实际的返回值.

这里我在我的Flask env下创建了一个测试页面, 用这些模块进行一些简单的页面爬虫测试.

http://flask.showerlee.com/scrapingtest/

安装环境

OS:       Windows 7 x64   
Python:   Python3.6.2
Git Bash: Git-2.15.1.2-64-bit

一. 环境配置:

1. 安装并运行Git bash

2. 安装并测试python版本

# python -V

Python 3.6.2

3. 安装相关爬虫模块

# python -m pip install beautifulsoup4 lxml pandas html5lib pyqt5 selenum

二. Beautiful Soup演示

# vi ~/scrap1.py

Tip: 这里首先去调用io和sys模块是为了改变默认的标准输出为utf-8, 这么做是为了保证无论我们抓取的源页面是什么格式, 都不会在用BS解析时报UnicodeEncodeError.

import io
import sys
import bs4 as bs
import urllib.request

# 改变标准输出的默认编码为utf-8
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf8')

# 获取该页面编码并解码成utf-8
sauce = urllib.request.urlopen(
    'http://flask.showerlee.com/scrapingtest/').read().decode('utf-8')

# 利用BS抓取页面源代码,并利用lxml规范格式
soup = bs.BeautifulSoup(sauce, 'lxml')

# 获取页面源代码
print(soup)

# 获取titile标签源代码
print(soup.title)

# 获取titile标签name
print(soup.title.name)

# 获取titile标签字符
print(soup.title.string)
print(soup.title.text)

# 获取第一个p标签源代码
print(soup.p)

# 获取p标签源代码
print(soup.find_all('p'))

# 获取p标签所有内容
for paragraph in soup.find_all('p'):
    print(paragraph.text)

# 获取页面所有内容
print(soup.get_text())

# 获取a标签所有内容
for url in soup.find_all('a'):
    print(url.text)

# 获取a标签所有href链接
for url in soup.find_all('a'):
    print(url.get('href'))

# 获取nav标签源代码
nav = soup.nav
print(nav)

# 获取nav标签URL
for url in nav.find_all('a'):
    print(url.get('href'))

# 获取body标签内容
body = soup.body
for paragraph in body.find_all('p'):
    print(paragraph.text)

# 获取div标签下body下的内容
for div in soup.find_all('div', class_='body'):
    print(div.text)

# 获取table标签源代码
table = soup.table
# table = soup.find('table')
print(table)

# 获取table每行内容
table_rows = table.find_all('tr')

for tr in table_rows:
    td = tr.find_all('td')
    row = [i.text for i in td]
    print(row)

	

# python scrap1.py

......

三. Pandas演示

# vi ~/scrap2.py

import pandas as pd

dfs = pd.read_html(
    'http://flask.showerlee.com/scrapingtest/', header=0)

for df in dfs:
    print(df)

# python scrap2.py

  Program Name  Internet Points    Kittens?
0       Python        932914021  Definitely
1       Pascal              532    Unlikely
2         Lisp             1522   Uncertain
3           D#               12    Possibly
4        Cobol                3         No.
5      Fortran            52124        Yes.
6      Haskell               24        lol.

四. pyqt5演示

这里我们首先不解析JS, 直接利用Beautiful Soup去抓取p标签下class=jstest的内容

# vi ~/scrap3.py

import io
import sys
import bs4 as bs
import urllib.request

# 改变标准输出的默认编码为utf-8
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf8')

# 获取该页面编码并解码成utf-8
sauce = urllib.request.urlopen(
    'http://flask.showerlee.com/scrapingtest/').read().decode('utf-8')

# 利用BS抓取页面源代码,并利用lxml规范格式
soup = bs.BeautifulSoup(sauce, 'lxml')

js_test = soup.find('p', class_='jstest')

print(js_test.text)

# python scrap3.py

No js loaded

可以看到实际抓取的为未被JS处理的标签内容

这里利用pyqt5去抓取p标签下class=jstest的内容

# vi ~/scrap4.py

import bs4 as bs
import sys
from PyQt5.QtWebEngineWidgets import QWebEnginePage
from PyQt5.QtWidgets import QApplication
from PyQt5.QtCore import QUrl


class Page(QWebEnginePage):
    def __init__(self, url):
        self.app = QApplication(sys.argv)
        QWebEnginePage.__init__(self)
        self.html = ''
        self.loadFinished.connect(self._on_load_finished)
        self.load(QUrl(url))
        self.app.exec_()

    def _on_load_finished(self):
        self.html = self.toHtml(self.Callable)
        # print('Load finished')

    def Callable(self, html_str):
        self.html = html_str
        self.app.quit()


def main():
    page = Page('http://flask.showerlee.com/scrapingtest/')
    soup = bs.BeautifulSoup(page.html, 'html.parser')
    js_test = soup.find('p', class_='jstest')
    print(js_test.text)


if __name__ == '__main__':
    main()

# python scrap4.py

js loaded successfully

JS解析成功.

四. selenum演示

首先我们需要从官网下载chrome driver, 并放到脚本同路径的driver目录里.

这里需要查找匹配你当前chrome浏览器版本的driver版本. 这边我的chrome版本为62.0, 所以选择driver版本为2.35.

# vi selenum.py

from selenium import webdriver
from selenium.common.exceptions import TimeoutException
from bs4 import BeautifulSoup
import time, sys, io

sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf8')

def scrape():

	chromedriver = r".\driver\chromedriver.exe"
	URL = "http://flask.showerlee.com/scrapingtest/"

	try:
		driver = webdriver.Chrome(chromedriver)
		driver.set_window_position(-10000, 0)
		driver.get(URL)
		time.sleep(10)
		result = driver.execute_script("return document.body.innerHTML").encode('utf-8')
	except TimeoutException as e:
		print(e)

	soup = BeautifulSoup(result, "lxml")

	print(soup)

	driver.close()

scrape()

# python selenum.py

...

更多文档:

https://www.crummy.com/software/BeautifulSoup/bs4/doc.zh/

http://pandas.pydata.org/pandas-docs/stable/

http://pyqt.sourceforge.net/Docs/PyQt5/

https://sites.google.com/a/chromium.org/chromedriver/downloads

https://chromedriver.storage.googleapis.com/index.html

如何使我们在保留旧版本的同时, 使用最新发行版来Fix这个issue, 则是本文所要讨论的问题.

因为ansible本身由python编写而成, 所以我们可以使用python下的virtualenv模块对我们所需的ansible发行版进行隔离安装, 这样既能保证我们原有的job还可以正常在stable version下safe running, 而且又不影响我们new job在新版本下适配新的模块.

接下来我会使用virtualenv隔离安装ansible2.1, 并保留老版本ansible1.9.4

详细配置步骤如下:

安装环境:
System: Centos 6.3 x64

Python: 2.6.6

Ansible: 1.9.4

一.安装virtualenv

1.保证系统默认YUM源

2.安装easy_install

# whoami

root

# yum install python-setuptools python-setuptools-devel

3.安装pip

# easy_install pip

4.安装virtualenv

# pip install virtualenv

二.配置系统非root用户使用新版本ansible.

Tip: 我们正常部署过程中建议使用一个普通用户来跑我们日常的ansible job

1.创建用户

# useradd deploy

2.切换到该用户进行初始配置.

# su - deploy

# virtualenv .virtualenv

# cd .virtualenv

# ls

bin  include  lib  lib64  pip-selfcheck.json

3.使用git下载ansible最新发行版.

# git clone https://github.com/ansible/ansible.git

4.进入virtualenv环境

$ source /home/deploy/.virtualenv/bin/activate

(.virtualenv) [deploy@www .virtualenv]$ 

5.安装必要的ansible依赖包

# pip install paramiko PyYAML jinja2

# cd ansible

# git submodule update --init lib/ansible/modules/core

# git submodule update --init lib/ansible/modules/extras

6. 加载ansible2.1

Tip: env-setup 是 ansible 为 hacker 准备的一个脚本，用来设置一些ansible所需的环境变量

# . /home/deploy/.virtualenv/ansible/hacking/env-setup -q

$ ansible --version

ansible 2.1.0 (devel 6ddea3e915) last updated 2016/02/16 16:13:32 (GMT +800)
  lib/ansible/modules/core: (detached HEAD 8d126bd877) last updated 2016/02/16 16:19:09 (GMT +800)
  lib/ansible/modules/extras: (detached HEAD f6c5ed987f) last updated 2016/02/16 16:19:40 (GMT +800)
  config file = /etc/ansible/ansible.cfg
  configured module search path = Default w/o overrides

7. 退出virtualenv

(.virtualenv) # deactivate

# exit

# su - deploy

# ansible --version

ansible 1.9.4
  configured module search path = None

配置完毕

Tip:

以后若想使用新版本ansible则直接执行下面两行命令即可.

# source /home/deploy/.virtualenv/bin/activate

# . /home/deploy/.virtualenv/ansible/hacking/env-setup -q

Target:

column A 是DB内存储的若干Project name,需要通过查询数据库,获取这些project name在DB对应的Project key的具体值,并插入column A后保存.

#!/usr/bin/env python
# encoding: utf-8

import MySQLdb
import csv
import sys

# Define csv list
Csv_content = []
Csv_content_edited = []

# Define project list
Project_names = []

# Define db list
Db_content = []

# Define the file that needs to be handled.
try:
	file_name = sys.argv[1]
	new_file_name = file_name.split('.')[0] + '_new.' + file_name.split('.')[1]
except IndexError:
	pass

def selectDB():
	# Open db connection
	db = MySQLdb.connect("test.com", "testuser", "testuser", "testdb")

	# Use cursor() fuction to get current db cursor
	cursor = db.cursor()

	Csv_content_edited = readContent(file_name)

	for c in range(1,len(Csv_content_edited)):
		Project_names.append(Csv_content_edited[c][0])

	Project_name_string = ",".join(['"' + p + '"' for p in Project_names])

	# SQL "SELECT" statement
	sql = 'select pname,pkey from project where pname in (%s)' %Project_name_string
	
	try:
		# Execute SQL
		cursor.execute(sql)
		# Obtain all the record list
		results = cursor.fetchall()

		for row in results:
			#lower_user_name = row[3]
			Db_content.append(row)

		return Db_content
	except:
		print "Error: unable to fecth data"

	# Close connection
	db.close()


def readContent(file_name):
	# Read the csv file,then put it into list.
	with open(file_name, 'r') as csvfile:
		csv_reader = csv.reader(csvfile, delimiter=',')
		for row in csv_reader:			 
			if row[0]:
				Csv_content.append(row)
	return Csv_content


def insert_col():
	Csv_content_edited = readContent(file_name)
	# Insert null value to each components of "Csv_content_edited" afterward.
	for i in range(0,len(Csv_content_edited)):
		Csv_content_edited[i].insert(1,'')

	# Define the second inserted column title.
	Csv_content_edited[0][1] = "Pkey"
	# Grab the users data from db.
	Db_content = selectDB()
	# print Db_content
	
	for d in range(0,len(Db_content)):
		Pkey = Db_content[d][1]
		Pname = Db_content[d][0]
		for c in range(0,len(Csv_content_edited)):  
			if Csv_content_edited[c][0] == Pname:
				Csv_content_edited[c][1] = Pkey
	# print Csv_content_edited

	pname_list = []
	Csv_content_edited_new = []
	
	for c in range(0,len(Csv_content_edited)):
		if not Csv_content_edited[c][0] in pname_list:
			pname_list.append(Csv_content_edited[c][0])
			Csv_content_edited_new.append(Csv_content_edited[c])
	# print Csv_content_edited_new
	
	return Csv_content_edited_new



# Write the csv file. 
def writeContent():
	with open(new_file_name,'wb') as csvfile:
		csv_writer = csv.writer(csvfile)
		csv_writer.writerows(insert_col())


# Execute the finnal function.	
if __name__ == '__main__':
	try:
		writeContent()
	except (IOError,NameError,IndexError):
		print "Please type the correct file name. e.g: '" + sys.argv[0] + " testfile.csv'"
	else:
		print 'The result file is: %s' %new_file_name

Result:

Before the change:

after the change:

其实，只要稍微做一些工作，Mac的终端同样可以多姿多彩，请往下看。

彩色化ls的输出

Mac中BSD的ls命令可以使用-G参数彩色化输出的文件列表，需要配置LSCOLORS环境变量定义颜色，具体配置方法可以输入man ls查看。

不过，我推荐安装Linux使用的GNU Coreutils替换Mac的ls命令，因为：

Coreutils提供了配置工具，定义颜色代码更加方便；

Coreutils包含的不仅仅是ls，同时作为Linux用户，我更习惯于使用GNU的各种shell工具。

Coreutils的安装与配置方法如下：

通过Homebrew安装Coreutils

# brew install xz coreutils

注：Coreutils并不依赖于xz，但它的源码是用xz格式压缩的，安装xz才能解压。

生成颜色定义文件

# gdircolors --print-database > ~/.dir_colors

在~/.bash_profile配置文件中加入以下代码

if brew list | grep coreutils > /dev/null ; then

  PATH="$(brew --prefix coreutils)/libexec/gnubin:$PATH"

  alias ls='ls -F --show-control-chars --color=auto'

  eval `gdircolors -b $HOME/.dir_colors`

fi

gdircolor的作用就是设置ls命令使用的环境变量LS_COLORS（BSD是LSCOLORS），我们可以修改~/.dir_colors自定义文件的颜色，此文件中的注释已经包含各种颜色取值的说明。

看看默认颜色的显示效果。

# ls screenshot

grep高亮显示关键字

这个很简单，加上--color参数就可以了，为了使用方便，可以在~/.bash_profile配置文件中加上alias定义。

alias grep='grep --color'

alias egrep='egrep --color'

alias fgrep='fgrep --color'

Vim语法高亮

在Vim中输入命令:syntax on激活语法高亮，若需要Vim启动时自动激活，在~/.vimrc中添加一行syntax on即可。

解决方案：

一.环境部署

操作系统：        centos6.3 x64

SVN:             subversion-1.8.0

apache:          httpd-2.4.4

svn server(centos6.3 x64): node2.example.com

svn client(centos6.3 x64): node1.example.com

git server: https://github.com/leonIi/

一.关闭iptables和SELINUX

# service iptables stop

注：如需开启防火墙,则添加如下一条规则打开svn 3690端口

# iptables -A INPUT -p tcp  --dport 3690 -j ACCEPT

# setenforce 0

# vi /etc/sysconfig/selinux

---------------

SELINUX=disabled

---------------

二.同步时间

# ntpdate cn.pool.ntp.org

三.安装apache

传送门：http://www.showerlee.com/archives/6

四.关闭系统自带svnserve

# service svnserve stop

# chkconfig svnserve off

注：本文档为了与apache2.4.4配合不发生兼容问题，所以使用了最新编译版本的svn,这里关闭是为了保证与rpm的版本不冲突.

五.安装svn server

传送门：http://www.showerlee.com/archives/350

注:安装完毕后:

svn根目录: /data/svn_repo

http访问URL: http://node2.example.com/svn/'具体仓库'

六.SVN到GIT迁移

1.首先在github上面创建一个repository(略)

2.创建一个SVN仓库(svn server)

# cd /data/svn_repo/

# svnadmin create project01

重启svn与apache

# killall svnserve

# /usr/local/svn/bin/svnserve -d -r /data/svn_repo/

# /usr/local/apache2/bin/apachectl restart

3.SVN checkin and checkout(svn client)

1).客户端安装svn(若安装可略过)

# yum install svn -y

2). svn checkout

# cd ~

# mkdir svn_client_repo

# cd svn_client_repo

# svn co http://node2.example.com/svn/project01

3). svn status

# svn status project01

# cd project01

# touch test01 test02 test03

4). svn add (添加)

# svn add test01

# svn add test02

# svn add test03

5). svn checkin(提交)

# svn ci -m”project01”

6). svn log (查看文件日志注释)

# svn log 1

常见错误提示:

Commit failed (details follow):

Error normalizing log message to internal format

Can't convert string from native encoding to 'UTF-8':

解决方法:

# vi ~/.subversion/config

修改:log-encoding = UTF-8

svn: Can't open file '/data/svn_repo/project01/db/txn-current-lock': Permission denied

解决方法:

将server端 /data/svn_repo/project01目录属主修改为apache用户,默认为daemon

# chown -R daemon.daemon /data/svn_repo/project01

2.使用git迁移(svn client)

1).客户端安装git(若安装可略过)

# yum install git* git-svn -y

# cd ~

# mkdir git_client_repo

# cd git_client_repo

建立SVN用户到git用户的映射文件

# echo "(no author) = test <test@123.com>" > userinfo.txt 

# git svn init http://node2.example.com/svn/project01 project01

# cd project01

将svn用户映射到git上.

# git svn fetch --authors-file=../userinfo.txt

# git log

-------------------------------------------------------------------------------------------------------------------------

commit edc2cdd658f8844ad4a883d083b84ef5dad2320c

Author: test <test@123.com>

Date:   Mon Aug 11 05:50:09 2014 +0000

    project01
    

    git-svn-id: http://node2.example.com/svn/project01@2 595a6c50-5861-48b1-ab0a-b1b54e0fc7cc

commit 9bde3c02fbfa6f22088b442a519cfd3870433ebc

Author: test <test@123.com>

Date:   Fri Aug 8 07:55:54 2014 +0000

    <E2><80><9D>project01<E2><80><9D>
    

    git-svn-id: http://node2.example.com/svn/project01@1 595a6c50-5861-48b1-ab0a-b1b54e0fc7cc

-----------------------------------------------------------------------------------------------------------------------

当然上面的两步，可以作一步处理

# git svn clone http://node2.example.com/svn/project01  --authors-file=userinfo.txt  project01

注: git svn fetch 这个步骤，可能碰到只想从某个版本开始进行fetch，那么请需要 –r 参数。

例如：

# git svn fetch -r 1342:HEAD

注：1342是你想要从这个版本开始fetch，如何查看这个版本号，你可以使用 svn 命令（windows下需要安装Subversion Client，e.g. sliksvn），简单使用就是 svn log svn_url 

这个时候，你可能看到整屏在刷新，没关系，看到log就行。当然更简单的就是使用TortoiseSVN-> Show log。

亦或者你可以这样使用：

# git svn clone http://node2.example.com/svn/project01 -sr 1342:HEAD project01

2)创建本地SSH keys并上传到github,详见:

https://help.github.com/articles/generating-ssh-keys

并更改连接到github SSH端口

# vim ~/.ssh/config

增加:

————————————————————————————

Host github.com

  Hostname ssh.github.com

  Port 443

————————————————————————————

3).到这步的时候，本地已经clone了SVN仓库，现在需要的就是提交到远程了。首先，关联github远程仓库，如下：

# git remote add origin git@github.com:leonIi/project01

# git fetch

# git commit -a -m "add file"

# git add .

# git push -f 

到github上面查看这个仓库(repository),大致效果如下（https://github.com/leonIi/project01.git）

大功告成…

# rpm -aq|grep yum|xargs rpm -e --nodeps  

二.从CentOS系统镜像中提取rpm包,这里以centos6.3_x64为例

这里从镜像包Packages目录下提取如下rpm包:

三.安装rpm包

注:这里我为了方便就将所有提取出来的包放到我的VPS上供大家下载

# wget http://www.showerlee.com/down/python-iniparse-0.3.1-2.1.el6.noarch.rpm

# rpm -ivh python-iniparse-0.3.1-2.1.el6.noarch.rpm

# wget http://www.showerlee.com/down/yum-metadata-parser-1.1.2-16.el6.x86_64.rpm

# rpm -ivh yum-metadata-parser-1.1.2-16.el6.x86_64.rpm

# wget http://www.showerlee.com/down/yum-3.2.29-30.el6.centos.noarch.rpm

# wget http://www.showerlee.com/down/yum-plugin-fastestmirror-1.1.30-14.el6.noarch.rpm

# rpm -ivh yum-3.2.29-30.el6.centos.noarch.rpm yum-plugin-fastestmirror-1.1.30-14.el6.noarch.rpm

注：这一步要两个一起安装，要不会会出现如下错误：

----------------------------------------------

# rpm -ivh yum-3.2.29-30.el6.centos.noarch.rpm

warning: yum-3.2.29-30.el6.centos.noarch.rpm: Header V3 DSA signature: NOKEY, key ID e8562897

error: Failed dependencies:

yum-fastestmirror is needed by yum-3.2.29-30.el6.centos.noarch

# rpm -ivh yum-plugin-fastestmirror-1.1.30-14.el6.noarch.rpm

warning: yum-plugin-fastestmirror-1.1.30-14.el6.noarch.rpm: Header V3 DSA signature: NOKEY, key ID e8562897

error: Failed dependencies:

yum >= 3.0 is needed by yum-plugin-fastestmirror-1.1.30-14.el6.noarch

-----------------------------------------------

# wget http://www.showerlee.com/down/PackageKit-yum-0.5.8-20.el6.x86_64.rpm

# rpm -ivh PackageKit-yum-0.5.8-20.el6.x86_64.rpm

# wget http://www.showerlee.com/down/PackageKit-yum-plugin-0.5.8-20.el6.x86_64.rpm

# rpm -ivh PackageKit-yum-plugin-0.5.8-20.el6.x86_64.rpm

四.下载配置源：

# cd /etc/yum.repos.d/

# wget http://docs.linuxtone.org/soft/lemp/CentOS-Base.repo

五.测试

# yum version

---------------------------------------------

Loaded plugins: fastestmirror, refresh-packagekit

Warning: RPMDB altered outside of yum.

Installed: 6/x86_64                1285:a2a18f0b8c3ca036a361579f6b22014aadfd680e

Group-Installed: yum                 14:45bb88c01e2346ba8fe7ac401a053cfd42bda739

version

----------------------------------------------

大功告成.....

   之前利用的rsync+crond来触发实现同步的瓶颈在于，rsync在同步数据时，需要先扫描所有文件后进行比对，而后进行差异传输，如果文件数量级别很大而且变化会很快，扫描所有文件会非常耗时，而且会存在漏同步的问题，造成效率低下。

   而rsync+inotify则会弥补前者先扫描后同步的效率问题，采用系统级别监控各种变化，当文件发生任何变化，就会触发rsync同步，解决效率与实时性问题。

LINUX操作系统:  centOS6.3 64bit

rsync:          系统自带

inotify-tools:  inotify-tools-master

www1(rsync server):192.168.7.73

www2(rsync client):192.168.7.74

拓扑图：

(server)表示仅服务端配置

(client)表示仅客户端配置

(server,client)表示客户端与服务端都需配置

环境搭建：(server,client)

1.关闭iptables和SELINUX

# service iptables stop

# setenforce 0

# vi /etc/sysconfig/selinux

---------------

SELINUX=disabled

---------------

判断LINUX系统内核是否达到2.6.13以上：

# uname -a

-------------

Linux www1.example.com 2.6.32-279.el6.x86_64 #1 SMP Fri Jun 22 12:19:21 UTC 2012 x86_64 x86_64 x86_64 GNU/Linux

-------------

查看inotify目录是否存在：

# ls -lsart /proc/sys/fs/inotify/

------------------

总用量 0

0 dr-xr-xr-x 0 root root 0 6月   4 14:04 ..

0 dr-xr-xr-x 0 root root 0 6月   4 17:35 .

0 -rw-r--r-- 1 root root 0 6月   4 17:35 max_user_watches

0 -rw-r--r-- 1 root root 0 6月   4 17:35 max_user_instances

0 -rw-r--r-- 1 root root 0 6月   4 17:35 max_queued_events

------------------

若返回以上内容，则系统支持inotify.

一.安装rsync:(server,client)

传送门：http://www.showerlee.com/archives/419

配置：(server)

# vi /etc/rsyncd.conf

--------------------

uid = root

gid = root

use chroot = no

max connections = 10

strict modes = yes

port = 873

address = 192.168.7.73

[test]

path = /test

comment = mirror for test

ignore errors

read only = no

list = no

auth users = user

secrets file = /etc/rsync.pas

hosts allow = *

# hosts deny = 0.0.0.0/0

pid file = /var/run/rsyncd.pid

lock file = /var/run/rsync.lock

log file = /var/log/rsyncd.log

--------------------

启动rsync

# rsync --daemon --config=/etc/rsyncd.conf

重启xinetd使其配置生效：

# /etc/init.d/xinetd restart

二.安装inotify-tools：(server,client)

可以到https://github.com/rvoicilas/inotify-tools/下载zip包，然后传到系统进行编译安装：

# unzip inotify-tools-master.zip

# cd inotify-tools-master

# ./autogen.sh

# ./configure --prefix=/usr/local/inotify

# make && make install

配置client端的inotify：(client)

# vi /etc/rc.d/inotify.sh

该脚本在做客户端目录下文件若发生变化，则向服务端做同步上传操作，也就是保持客户端目录文件发生变化，服务端也相应改变。

------------------

#!/bin/bash

src=/test

des=test

ip=192.168.7.73

/usr/local/inotify/bin/inotifywait -mrq --timefmt '%d/%m/%y/%H:%M' --format '%T%w%f' -e modify,delete,create,attrib $src | while read file

  do

       rsync -vzrtopg --delete --progress $src user@$ip::$des --password-file=/etc/rsync.pas &&

   echo "$src has been resynced"

  done

------------------

赋予执行权限

# chmod +x /etc/rc.d/inotify.sh

执行脚本并做开机启动：

# /etc/rc.d/inotify.sh

# echo "/etc/rc.d/inotify.sh" >> /etc/rc.local

注：这个脚本的作用是通过inotify监控文件目录的变化，进而触发rsync进行同步操作，由于这是通过内核完成的主动式触发操作，所以比rsync遍历整个目录的扫描方式效率要高很多。

验证：

在客户端创建5个文件，到服务端查看文件是否实时同步？

(client)

# cd /test

# touch 1 2 3 4 5

(server)

# cd /test

# ls

-------------

1  2  3  4  5

-------------

验证成功，client端的目录发生变化会实时同步到server端，类似一个网络raid-1

总结：

rsync+inotify比较适用于轻量级文件即时同步，如果量大建议还是使用共享存储方法解决。

参考：酒哥的构建高可用LINUX服务器（第2版）

博主用的魅族MX2，所以是个实实在在魅粉+安卓root控，平时捣鼓完日常的运维工作后就会找点安卓上有意思的APP研究下，这不这几天LEB安全大师（安卓公认的良心之作）又更新了，但苦于没有免杀版(也就是MX2自带任务管理器会杀掉LEB本身)，所以就到机锋找到了一个任务白名单APP，该软件相当于是自带魅族MX2 FLYME系统任务管理器的一个扩展插件，所以就按照教程一步步的操作，结果悲剧就发生。

教程传送门：http://bbs.gfan.com/forum.php?mod=viewthread&tid=6123114

按照教程所说：

1.下载附件中apk

2.备份/system/app/下同名apk文件以及odex文件(如果有的话)

3.替换/system/app/下同名应用 修改权限

4.如果/system/app/下面有同名后缀odex文件请删除

5.重启

利用手机上的R.E管理器一步步操作完毕，重启机子会不停的报任务管理器进程错误，然后就各种崩溃，无法操作任何手机上的APP，OK 基本变砖了。

啊。。。

仔细看了下教程，原来忘了删除/system/app/下 MzRecentApps.odex文件

╮(╯▽╰)╭

冷静了下，既然安卓是基于linux内核写的系统，那他肯定也有自己的shell,网上找个工具进入shell/system/app/下删除这个该死的.odex文件不是OK了？

不过还好博主对LINUX shell还是比较熟的(RHCE可不是白考的)

网上搜索了相关资料，总结了下：

其实安卓手机崩溃和LINUX系统崩溃解决方案其实都一样（废话，都是一个妈生的）

也就是只要能进入shell后提权操作即可：

LINUX下的方法：

找到系统光盘，然后进入救援模式，进入shell,然后重新挂载根分区可读写即可，然后具体问题具体解决。

# mount -o remount, rw /

这个有点LINUX常识的人估计都很清楚

ANDROID的方法：

下载附件的adb shell到windows,利用豌豆荚或360手机助手下载你的安卓手机驱动，安装完毕

开始菜单-运行-输入"cmd"(找到指定adb文件路径),执行以下命令进入安卓 shell

> adb.exe shell

1.首先提权为root,无需密码

# su -

2.挂载目录可读写。

注：默认根目录可读写，但子目录无法读写，需再次挂载,但/system下的子目录就不需要再挂载即可读写

例如：获取/system下root读写权限

# mount -o remount,rw rootfs /system

剩下的操作基本上和LINUX shell的语法类似

这下三下五除二，很娴熟的进入该目录，干掉这个该死的文件，重启手机，哈哈，手机复活了

自带任务管理器的白名单扩展插件也出来了

所以安卓手机变砖了不可怕，可怕的就是你当转一样直接砸了。。。