Python第十五天 datetime模块 time模块 thread模块 threading模块 Queue队列模块 multiprocessing模块 paramiko模块 fabric模块
Python第十五天 datetime模块 time模块 thread模块 threading模块 Queue队列模块 multiprocessing模块 paramiko模块 fabric模块
目录
Python第二天 变量 运算符与表达式 input()与raw_input()区别 字符编码 python转义符 字符串格式化
Python第三天 序列 5种数据类型 数值 字符串 列表 元组 字典
Python第四天 流程控制 if else条件判断 for循环 while循环
Python第五天 文件访问 for循环访问文件 while循环访问文件 字符串的startswith函数和split函数
Python第七天 函数 函数参数 函数变量 函数返回值 多类型传值 冗余参数 函数递归调用 匿名函数 内置函数 列表表达式/列表重写
Python第八天 模块 包 全局变量和内置变量__name__ Python path
Python第九天 面向对象 类定义 类的属性 类的方法 内部类 垃圾回收机制 类的继承 装饰器
Python第十天 print >> f,和fd.write()的区别 stdout的buffer 标准输入 标准输出 标准错误 重定向 输出流和输入流
Python第十二天 收集主机信息 正则表达式 无名分组 有名分组
Python第十四天 序列化 pickle模块 cPickle模块 JSON模块 API的两种格式
Python第十五天 datetime模块 time模块 thread模块 threading模块 Queue队列模块 multiprocessing模块 paramiko模块 fabric模块
datetime模块 time模块
子类之间的对应关系
object
timedelta
tzinfo
time
date
datetime
now = datetime.datetime.utcnow() # 获取当前utc时间
now = datetime.datetime.now() # 获取当前时间
delta = datetime.timedelta(minutes=5) # 获取前5分钟时间
fiveminago = now – delta # 时间差
now > fiveminago # 时间比较
GMT_FORMAT = '%b %d %H:%M:%S GMT'
now.strftime(GMT_FORMAT) # 格式化时间
now.strftime('%Y-%m-%d.%H:%M:%S') # 格式化时间
int(time.time()) #返回时间戳
time.ctime() #相当于datetime.datetime.now()
datetime模块
https://www.cnblogs.com/cindy-cindy/p/6720196.html
- # 解释日志时间
- import datetime
- import time
- def parseLogTime(line):
- now = datetime.datetime.now()
- month,day,time = line.split()[:3]
- hour,minute,second = [int(i) for i in time.split(':')]
- logtime = datetime.datetime(now.year,MONTH[month],int(day),hour,minute,second)
- return logtime
获取今天零点和昨天零点时间
- # 获取今天零点和昨天零点时间
- import datetime
- import time
- now_time = int(time.time()) # 获取当前时间的时间戳
- day_time = now_time - now_time % 86400 + time.timezone # 今天零点时间戳
- today_datetimeformat=datetime.datetime.fromtimestamp(day_time) # 转换为datetime格式
- delta = datetime.timedelta(days=1) # 一天的时间差
- yesterday_datetimeformat = today_datetimeformat - delta # 昨天零点时间datetime格式
- yesterday_uxtimeformat = int(time.mktime(yesterday_datetimeformat.timetuple()))
- torday_uxtimeformat = int(time.mktime(today_datetimeformat.timetuple()))
- print yesterday_uxtimeformat
- print torday_uxtimeformat
- 定义
- class datetime(date)
- | datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])
- |
- | The year, month and day arguments are required. tzinfo may be None, or an
- | instance of a tzinfo subclass. The remaining arguments may be ints or longs.
time模块
python中的time模块
https://www.cnblogs.com/renpingsheng/p/6965044.html
datetime模块
datetime模块定义了下面这几个类:
datetime.date:表示日期的类。常用的属性有year, month, day;
datetime.time:表示时间的类。常用的属性有hour, minute, second, microsecond;
datetime.datetime:表示日期时间。
datetime.timedelta:表示时间间隔,即两个时间点之间的长度。
datetime.tzinfo:与时区有关的相关信息。
时间格式相互转换
时间对象,时间字符串,时间戳
获取当前时间
import datetime
now_time=datetime.datetime.now()
print(now_time)
print(type(now_time))
字符串、datetime互转
import datetime
string = '2017-01-02 11:12:12'
_d_time = datetime.datetime.strptime(string, '%Y-%m-%d %H:%M:%S')
print (_d_time)
print(type(_d_time))
dateime转字符串
import datetime
_time=datetime.datetime.strftime(now_time,'%Y-%m-%d %H:%M:%S')
print(_time)
print(type(_time))
时间戳、datetime互转
import time
_a=int(time.time())
print (_a)
_n_time=datetime.datetime.fromtimestamp(_a)
print (_n_time)
print(type(_n_time))
datetime转换为unix时间戳
dtime = datetime.datetime.now()
un_time = int(time.mktime(dtime.timetuple()))
print un_time
多线程
thread模块(python3不存在thread模块,thread模块在python3中命名为_thread)
threading模块
thread模块是低级模块
threading模块是高级模块,对thread模块的封装
生产中要用threading模块而不用thread模块
GIL:Python无法高效的实现多线程的原因 《Python Linux系统管理与自动化运维》
Python 默认的解释器,由于全局解释器锁GIL的存在,确实在任意时刻都只有一个线程在执行Python 代码,致使多线程不能充分利用机器多核的特性,GIL的好处是防止死锁、争用条件、高复杂性问题
多进程代替多线程有效避开GIL,每个进程都有自己的python解释器实例,不受GIL限制
但是,我们的程序也不是无时无刻不在计算的,我们的程序需要等待用户输入、等待文件读写以及网络收发数据,这些都是比较费时的操作。
使用Python 多线程,计算机会将这些等待操作放到后台去处理,从而释放出宝贵的计算资源,继续进行计算。
也就是说,如果读者的程序是CPU 密集型的,使用Python 的多线程确实无法提升程序的效率,如果读者的程序是IO 密集型的,则可以使用Python 的多线程提高程序的整体效率。
线程的特点:
- 线程的生命周期
- 开始
- 运行
- 结束
线程的退出:
- 进程执行完成
- 线程的退出方法
- python系统退出
我们通常把当前进程叫做主线程或者主进程。
函数是通过thread.start_new_thread来调用的,说明它是在线程中运行的。
import thread,threading
start_new_thread(func, args)
func:函数名
args:元组
allocate_lock()
exit()
- #!/usr/bin/env python
- #encoding:utf8
- import thread
- import time
- def func(name,i):
- for n in xrange(i):
- print name,n
- #time.sleep(1)
- thread.start_new_thread(func, ('声音',3))
- thread.start_new_thread(func, ('画面',3))
- time.sleep(1)
LockType对象方法
acquire()
locked()
release() //释放锁,使用前线程必须已获得锁定,否则将抛出异常
thread锁使用
lock = thread.allocate_lock():生成全局锁对象
lock.acquire():加锁
线程使用锁对象
lock.release():线程调度释放锁
查看locked()状态
示例1
- #!/usr/bin/env python
- #encoding:utf8
- import thread
- import time
- def func(name, i, l):
- for n in xrange(i):
- print name, n
- time.sleep(1)
- l.release()
- lock = thread.allocate_lock()
- lock.acquire()
- thread.start_new_thread(func, ('声音', 3, lock))
- thread.start_new_thread(func, ('画面', 3, lock))
- while lock.locked():
- pass
- print lock.locked()
- print "Exit main process"
示例2
- #!/usr/bin/env python
- import thread
- import time
- def world():
- for i in range(5):
- if w_lock.acquire():
- print 'world', time.ctime()
- h_lock.release()
- h_lock = thread.allocate_lock()
- w_lock = thread.allocate_lock()
- thread.start_new_thread(world, ())
- w_lock.acquire()
- for i in range(5):
- if h_lock.acquire():
- print 'hello',
- w_lock.release()
- while h_lock.locked():
- pass
示例3
- #!/usr/bin/env python
- import thread
- import time
- def hello():
- for i in xrange(5):
- h_lock.acquire()
- print 'hello',
- w_lock.release()
- def world():
- for i in xrange(5):
- w_lock.acquire()
- print 'world', time.ctime()
- h_lock.release()
- lock.release()
- lock = thread.allocate_lock() 分配锁
- lock.acquire() 获得锁
- h_lock = thread.allocate_lock()
- w_lock = thread.allocate_lock()
- w_lock.acquire()
- thread.start_new_thread(hello, ())
- thread.start_new_thread(world, ())
- while lock.locked(): 是否获得锁
- pass
threading模块
threading不需要进程来控制线程,主进程会等待线程执行完毕才退出
threading.Thread:类
成员方法:
- isAlive() //查线程是否在运行中
- start() //启动线程 非阻塞
- run() //可以重写
- join() //该方法会阻塞调用,直到线程中止
- getName() //获取线程的名称
- setName() //设置线程的名称
- isDaemon() //判断线程是否守护线程
- setDaemon() //设置线程为守护线程
1、使用threading.Thread生成线程对象来开启多线程
#给线程/函数传递参数
- import time
- import threading
- def t1(name, x):
- for i in xrange(x):
- print i, name
- time.sleep(1)
- th1 = threading.Thread(target=t1, args=('声音', 3))
- th2 = threading.Thread(target=t1, args=('画面', 3))
- target:函数名
- args:函数的参数
- th1.setDaemon(True) //随着主线程的退出而退出,一定要写在th1.start()前面
- th1.start() //运行一个线程
- #th1.run() //一直运行这个线程,直到运行完才会运行下一个线程
- #th1.join() //等待线程终止
- th2.start()
2、继承threading.Thread 的方式编写多线程程序
通过继承threading.Thread 类进行多线程编程,只需要在子类中实现run 方法,并在run 方法中实现该线程的业务逻辑即可
- from __future__ import print_function
- import threading
- class MyThread(threading.Thread ):
- def __init__(self, count, name):
- super(MyThread, self).__init__()
- self.count = count
- self.name = name
- def run(self):
- while self.count>0:
- print ("hello", self.name)
- self.count-= 1
- def main():
- usernames = [ 'Bob','Jack','Pony','Jone','Mike']
- for i in range(5):
- thread = MyThread(50,usernames[i])
- thread.start()
- if __name__ =='__main__':
- main()
线程安全:用锁来控制并发访问
Lock工厂函数
lock = threading.Lock()
lock. acquire() //获取锁
lock.release() //释放锁
lock.locked() //查看锁状态
- #加锁和释放锁
- import threading
- lock = threading.Lock()
- try:
- lock.acquire()
- # do something
- finally:
- lock.release()
- #改为用上下文管理器
- import threading
- lock = threading.Lock()
- with lock:
- # do something
- pass
启动线程的两个方法
第一种方法:定义一个函数,threading.Thread实例化对象来启动
第二种方法:编写一个类并继承threading.Thread并重写run方法
线程安全队列
线程安全队列是线程间最常用的交换数据的形式,线程间通信模块。Queue是提供队列操作的模块
生产者消费者模型
生产者 和消费者之间加一个缓冲区
生产者消费者之间存在并发访问问题,即多个消费者可能同时从缓冲区中获取商品,
为了解决并发问题,使用python标准库的queue,queue是线程安全的队列实现FIFO
提供多线程编程的先进先出数据结构,非常适合生产者消费者之间数据传递
三种队列:
FIFO:Queue.Queue(maxsize=0):一个先进先出( FIFO )的队列,最先加入队列的元素最先取出
LIFO:Queue.LifoQueue(maxsize=0):一个后进先出( LIFO )的队列,最后加入队列的元素最先取出
Priority:Queue.PriorityQueue(maxsize=0):优先级队列,队列中的元素根据优先级排序
Queue一些方法
Queue.empty() //如果队列为空,返回True,反之False
Queue.full() //如果队列满了,返回True,反之False
Queue.join() //阻塞等待,直到所有消费者对每一个元素都调用了task_done
Queue.task_done() //和join一起工作,提示先前取出的元素已经完成处理
Queue.get([block[, timeout]]) //读队列,timeout等待时间 ,block和timeout意思跟put方法一样
Queue.get_nowait() //读队列,当队列中没有数据的时候会直接抛出Empty异常,而不会等待
Queue.put_nowait() //写队列,非阻塞地向队列添加元素
Queue.put(item, [block[, timeout]]) //写队列,timeout等待时间 ,任何数据结构数据都可以加到队列,block=true,timeout=none默认,当队列满了会一直阻塞并等待
Queue.queue.clear() 清空队列
q = Queue.Queue()
class Queue
| Create a queue object with a given maximum size.
|
| If maxsize is <= 0, the queue size is infinite.
|
| Methods defined here:
|
| __init__(self, maxsize=0)
|
- #!/usr/bin/env python
- import threading
- import random
- import Queue
- import time
- def producer(name, queue):
- for i in xrange(10):
- num = random.randint(1,10)
- th_name = name + '-' + threading.currentThread().getName()
- print "%s: %s ---> %s" % (time.ctime(), th_name, num)
- queue.put(num)
- time.sleep(1)
- def odd(name, queue):
- th_name = name + '-' + threading.currentThread().getName()
- while True:
- try:
- val_odd = queue.get(1,5) #阻塞,阻塞5秒超时
- if val_odd % 2 != 0:
- print "%s: %s ---> %s" % (time.ctime(), th_name, val_odd)
- time.sleep(1)
- else:
- queue.put(val_odd)
- time.sleep(1)
- except:
- print "%s: %s finished" % (time.ctime(), th_name)
- break
- def even(name, queue):
- th_name = name + '-' + threading.currentThread().getName()
- while True:
- try:
- val_even = queue.get(1,5)
- if val_even % 2 == 0:
- print "%s: %s ---> %s" % (time.ctime(), th_name, val_even)
- time.sleep(1)
- else:
- queue.put(val_even)
- time.sleep(1)
- except:
- print "%s: %s finished" % (time.ctime(), th_name)
- break
- def main():
- q = Queue.Queue(10)
- t_pro = threading.Thread(target=producer, args=('pro',q))
- t_odd = threading.Thread(target=odd, args=('odd',q))
- t_even = threading.Thread(target=even, args=('even',q))
- t_pro.start()
- t_odd.start()
- t_even.start()
- if __name__ == '__main__':
- main()
multiprocessing模块
thread模块和threading模块都不是真正意义的多线程,受限于GIL只能用到一个核心
multiprocessing使用多进程,可以利用多个核心,但是因为是多进程开销也比多线程大
multiprocessing.Process调用方法跟threading.Thread调用方法和参数基本一样
from multiprocessing import Process
import time
import os
def f(name):
print 'hello', name, os.getpid(), os.getppid()
time.sleep(1)
if __name__ == '__main__':
for i in range(10):
p = Process(target=f, args=(i,))
p.start()
#p.join() #wait
进程池Pool
multiprocessing.Pool很方便的同时自动处理几百或者上千个并行操作,脚本的复杂性也大大降低。
pool = multiprocessing.Pool(processes=3) // 设置最大进程数为3,processes的默认值等于系统当前的最大核心数,假设当前是4核机器,那么进程池默认会初始化四个进程
result = pool.apply_async(func=f, args=(i,)) //向进程池提交目标请求,非阻塞的,但result.get()方法是阻塞的。
pool.close() //会等待池中的所有worker进程执行结束再关闭pool
pool. terminate() //直接关闭pool
pool.join() //等待进程池中的所有worker进程执行完毕,阻塞主进程。但必须使用在pool.close()或者pool.terminate()之后
- pool.close()
- pool.join() #阻塞主进程,不然主进程退出了子进程还在运行变成孤儿进程
如果进程池里所有进程都再处理请求,这时候有新进程进来必须等待直到有空闲进程可以处理这个新请求
- #!/usr/bin/env python
- import multiprocessing
- from subprocess import Popen, PIPE
- def run(id):
- p = Popen('vim', stdout=PIPE, stderr=PIPE)
- p.communicate() #不用 stdout和 stderr 接收 表示等待命令执行完
- print "Task: %s" %id
- pool = multiprocessing.Pool()
- for i in xrange(5):
- pool.apply_async(func=run, args=(i,))
- print "Wait..."
- pool.close()
- pool.join()
- print 'Done'
- #!/usr/bin/env python
- import multiprocessing
- import os
- import time
- def run_task(id):
- print "Run task id: %s pid(%s) ppid(%s)" % (id, os.getpid(), os.getppid())
- start = int(time.time())
- time.sleep(3)
- end = int(time.time())
- print "Task %s run %0.2f" % (id, (end - start))
- if __name__ == '__main__':
- print "Parent process %s" %os.getpid()
- pool = multiprocessing.Pool(processes=2)
- for i in xrange(5):
- pool.apply_async(run_task, args=(i,))
- #print "Wait..."
- pool.close()
- pool.join()
- print "Done"
paramiko模块
paramiko 是一个Python 的库,该库支持Python 2.6 +和Python 3.3 +版本,实现了SSHv2 协议(底层使用cryptography )
cryptography为python开发组提供cryptographic recipes加密套件和 primitives 原语的一个python包
cryptographic standard library
It supports Python 2.7, Python 3.4+, and PyPy 5.3+
pip install cryptography
只能上传文件,不能上传文件夹,需要结合os.walk,上传目录里所有文件
SSHClient
SSHClient 类是对SSH 会话的封装,该类封装了传输(transport) 、通道(channel)及SFTPClient 建立的方法(open_sftp), 通常用于执行远程命令
SSHClient 类常用的几个方法:
1 ) connect : connect 方法实现远程服务器连接与认证,对于该方法, 只有hostname 是必传参数。
connect(self , hostname , port=22, username=None , password=None ,pkey=None , key_filename=None , timeout=None ,allow_agent=True , look_for_keys=True , compress=False)
2 ) set_missing_host_key_policy : 设置远程服务器没有在know_hosts 文件中记录时的应对策略。目前支持三种策略,分别是AutoAddPolicy 、RejectPolicy ( 默认策略)与WarningPolicy
分别表示自动添加服务器到know_hosts 文件、拒绝本次连接、警告并将服务器添加到know hosts 文件中。
3 ) exec_command :在远程服务器执行Linux 命令的方法。
4 ) open_sftp:在当前ssh 会话的基础上创建一个sftp 会话。该方法会返回一个SFTPClient 对象。
SFTPClient 类常用的几个方法:
put :上传本地文件到远程服务器;
get :从远程服务器下载文件到本地;
mkdir :在远程服务器上创建目录;
remove :删除远程服务器中的文件;
rmdir :删除远程服务器中的目录;
rename :重命名远程服务器中的文件或目录;
stat : 获取远程服务器中文件的详细信息;
listdir :列出远程服务器中指定目录下的内容。
这里仅仅介绍了paramiko 中SSHClient 与SFTPClient 类的常用方法,完整的API 可以参考官方文档
需要安装libffi-devel开发库
yum install -y libffi*
error: invalid command ‘bdist_wheel’
http://www.cnblogs.com/BugQiang/archive/2015/08/22/4732991.html
paramiko模块遵循SSH2协议,支持加密和认证的方式,进行远程服务器的连接。
由于使用的是python这样的能够跨平台运行的语言,所以所有python支持的平台,如Linux, Solaris, BSD, MacOS X, Windows等,paramiko都可以支持
批量执行命令
安装paramilo模块
yum install -y python-paramiko1.10.noarch
或者:
pip install paramiko==2.2.1
例子
import paramiko
client = paramiko.SSHClient()
client.load_system_host_keys() //~/.ssh/know_hosts #加载本机known_hosts文件
或:
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.connect(hostname='127.0.0.1',username='root',password=‘XXX')
stdin, stdout, stderr = client.exec_command('date')
stdout.read()
client.close()
基于用户名和密码的 sshclient 方式登录
# 建立一个sshclient对象
ssh = paramiko.SSHClient()
# 允许将信任的主机自动加入到known_hosts列表,此方法必须放在connect方法的前面
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# 调用connect方法连接服务器
ssh.connect(hostname='192.168.2.129', port=22, username='super', password='super',timeout=5)
# 执行命令
stdin, stdout, stderr = ssh.exec_command('df -hl')
# 结果放到stdout中,读出stdout中的结果
print(stdout.read().decode())
# 关闭连接
ssh.close()
基于公钥密钥的 SSHClient 方式登录
# 指定本地的RSA私钥文件,如果建立密钥对时设置的有密码,password为设定的密码,如无不用指定password参数
pkey = paramiko.RSAKey.from_private_key_file('/home/super/.ssh/id_rsa', password='12345')
# 建立连接
ssh = paramiko.SSHClient()
ssh.connect(hostname='192.168.2.129',port=22,username='super',pkey=pkey,timeout=5)
# 执行命令
stdin, stdout, stderr = ssh.exec_command('df -hl')
# 结果放到stdout中,读出stdout中的结果
print(stdout.read().decode())
# 关闭连接
ssh.close()
基于用户名和密码的 transport 方式传文件
# 实例化一个transport对象
trans = paramiko.Transport(('192.168.2.129', 22))
# 建立连接
trans.connect(username='super', password='super')
# 实例化一个 sftp对象,指定连接的通道
sftp = paramiko.SFTPClient.from_transport(trans)
# 发送文件
sftp.put(localpath='/tmp/11.txt', remotepath='/tmp/22.txt')
# 下载文件
sftp.get(remotepath='/tmp/22.txt', localpath='/tmp/11.txt')
trans.close()
基于密钥的 Transport 方式传文件
# 指定本地的RSA私钥文件,如果建立密钥对时设置的有密码,password为设定的密码,如无不用指定password参数
pkey = paramiko.RSAKey.from_private_key_file('/home/super/.ssh/id_rsa', password='12345')
# 建立连接
trans = paramiko.Transport(('192.168.2.129', 22))
trans.connect(username='super', pkey=pkey)
# 实例化一个 sftp对象,指定连接的通道
sftp = paramiko.SFTPClient.from_transport(trans)
# 发送文件
sftp.put(localpath='/tmp/11.txt', remotepath='/tmp/22.txt')
# 下载文件
sftp.get(remotepath='/tmp/22.txt', localpath='/tmp/11.txt')
trans.close()
问题汇总
https://cloud.tencent.com/community/article/945339
Error reading SSH protocol banner连接错误
解决办法:
重新下载paramiko插件源码,解压后,编辑安装目录下的transport.py文件:
vim build/lib/paramiko/transport.py
搜索 self.banner_timeout 关键词,并将其参数改大即可,比如改为300s:
self.banner_timeout = 300
最后,重装paramiko即可。
paramiko远程执行后台脚本“阻塞”问题
解决办法
将远程脚本的标准输出stdout重定向到错误输出stderr即可
现在执行,就能立即得到结果了。其实原因很简单,因为bash /tmp/test.sh & 虽然是后台执行,但是依然会产生标准输出,一旦产生标准输出,paramiko就会认为命令还未执行完成,且stdout的buffer大于stderr,因此产生等待问题。
这里只要将脚本执行的标准输出重定向到错误输出(1>&2),然后paramiko就可以使用stderr快速读取远程打屏信息了。
- #!/usr/bin/env python
- import paramiko
- import threading
- import sys
- def ssh_conn(ip, cmd):
- ssh = paramiko.SSHClient()
- ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
- pkey_file = '/root/.ssh/id_rsa'
- key = paramiko.RSAKey.from_private_key_file(pkey_file)
- try:
- ssh.connect(hostname=ip, username='root', pkey=key, timeout=5)
- except:
- print "%s: Timeout or not permission" % ip
- return 1
- stdin, stdout, stderr = ssh.exec_command(cmd)
- stdout = stdout.read()[:-1] #第0个字符到最后一个字符但是不包含最后一个字符
- stderr = stderr.read()[:-1]
- if stdout:
- print "%s:\t %s" % (ip, stdout)
- ssh.close()
- else:
- print "%s:\t %s" % (ip, stderr)
- ssh.close()
- if __name__ == '__main__':
- paramiko.util.log_to_file('/tmp/paramiko.log')
- ips = ['192.168.20.'+str(i) for i in xrange(1, 100)]
- try:
- cmd = sys.argv[1]
- except IndexError:
- print "%s follow a command" % __file__
- sys.exit(1)
- for ip in ips:
- t = threading.Thread(target=ssh_conn, args=(ip,cmd))
- t.start()
- #!/usr/bin/env python
- #进程池版本
- import paramiko
- import multiprocessing
- import sys
- def ssh_conn(ip, cmd):
- ssh = paramiko.SSHClient()
- ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
- pkey_file = '/root/.ssh/id_rsa'
- key = paramiko.RSAKey.from_private_key_file(pkey_file)
- try:
- ssh.connect(hostname=ip, username='root', pkey=key, timeout=5)
- except:
- print "%s: Timeout or not permission" % ip
- return 1
- stdin, stdout, stderr = ssh.exec_command(cmd)
- stdout = stdout.read()[:-1]
- stderr = stderr.read()[:-1]
- if stdout:
- print "%s:\t %s" % (ip, stdout)
- ssh.close()
- else:
- print "%s:\t %s" % (ip, stderr)
- ssh.close()
- if __name__ == '__main__':
- paramiko.util.log_to_file('/tmp/paramiko.log')
- ips = ['192.168.20.'+str(i) for i in xrange(1, 100)]
- try:
- cmd = sys.argv[1]
- except IndexError:
- print "%s follow a command" % __file__
- sys.exit(1)
- pool = multiprocessing.Pool(processes=10)
- for ip in ips:
- pool.apply_async(func=ssh_conn, args=(ip, cmd))
- pool.close()
- pool.join()
- #!/usr/bin/env python
- #可传入参数改进版
- import paramiko
- import multiprocessing
- import sys
- from optparse import OptionParser
- import urllib, urllib2
- import json
- DATA_BACK = '/var/tmp/data.json'
- def opt():
- parser = OptionParser("Usage: %prog -a|-g command")
- parser.add_option('-a',
- dest='addr',
- action='store',
- default='True',
- help='ip or iprange EX: 192.168.1,192.168.1.3 or 192.168.1.1-192.168.1.100')
- parser.add_option('-g',
- dest='group',
- action='store',
- help='groupname')
- options, args = parser.parse_args()
- return options, args
- def ssh_conn(ip, cmd):
- ssh = paramiko.SSHClient()
- ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
- try:
- ssh.connect(hostname=ip, port=9022, username='steven', password='xx',timeout=5)
- except:
- print "%s: Timeout or not permission" % ip
- return 1
- stdin, stdout, stderr = ssh.exec_command(cmd)
- stdout = stdout.read()[:-1]
- stderr = stderr.read()[:-1]
- if stdout:
- print "%s:\t %s" % (ip, stdout)
- ssh.close()
- else:
- print "%s:\t %s" % (ip, stderr)
- ssh.close()
- def parseOpt(option):
- if ',' in option:
- ips = option.split(',')
- return ips
- elif '-' in option:
- ip_start, ip_end = option.split('-')
- ip_net = '.'.join(ip_start.split('.')[:-1])
- start = int(ip_start.split('.')[-1])
- end = int(ip_end.split('.')[-1]) + 1
- ips = [ip_net+'.'+str(i) for i in range(start, end)]
- return ips
- elif ',' not in option or '-' not in option:
- ips = [option]
- return ips
- else:
- print "%s -h" % __file__
- def getData():
- url = 'http://192.168.1.5:8000/hostinfo/getjson/'
- try:
- req = urllib2.urlopen(url)
- data = json.loads(req.read())
- with open(DATA_BACK, 'wb') as fd:
- json.dump(data, fd)
- except:
- with open(DATA_BACK) as fd:
- data = json.load(fd)
- return data
- def parseData(data):
- dic_host = {}
- for hg in data:
- groupname = hg['groupname']
- dic_host[groupname] = []
- for h in hg['members']:
- dic_host[groupname] += [h['ip']] #列表相加 得到一个新列表
- return dic_host
- if __name__ == '__main__':
- paramiko.util.log_to_file('/tmp/paramiko.log')
- options, args = opt()
- try:
- cmd = args[0]
- except IndexError:
- print "%s follow a command" % __file__
- sys.exit(1)
- if options.addr:
- ips = parseOpt(options.addr)
- elif options.group:
- groupname = options.group
- data = getData()
- dic = parseData(data)
- if groupname in dic:
- ips = dic[groupname]
- else:
- print "%s is not exists in SimpleCMDB" % groupname
- sys.exit()
- else:
- print "%s -h" % __file__
- sys.exit(1)
- pool = multiprocessing.Pool(processes=10)
- for ip in ips:
- pool.apply_async(func=ssh_conn, args=(ip, cmd))
- pool.close()
- pool.join() #阻塞一下主进程,不然主进程退出了子进程还在运行变成孤儿进程
fabric模块
Fabric 的作者也是paramiko 的作者
Fabric 依赖paramiko 、pycrypto
fabric是基于paramiko模块封装开发的。paramiko更底层
安装:依赖pycrypto,paramiko
要先卸载系统自带的python-pycrypto与python-paramiko
pycrypto最好安装2.3版本,如果安装2.6.1会有gmp版本低的警告
Fabric 比较特殊,它既是一个Python 库,也是一个命令行工具
它的命令行工具不是Fabric , 而是fab 。我们可以通过下面的语句获得命令行工具的简单说明以及验证Fabric 是否安装正确:
$ fab --help
安装:
yum install -y python-devel
pip install pycrypto=="2.3"
pip install paramiko==1.12.4
pip install fabric==1.8.3
pip list
argparse (1.2.1)
asn1crypto (0.22.0)
bcrypt (3.1.3)
cffi (1.10.0)
cryptography (2.0.1)
distribute (0.6.10)
Django (1.6.5)
ecdsa (0.13)
enum34 (1.1.6)
Fabric (1.8.3)
idna (2.5)
iniparse (0.3.1)
ipaddress (1.0.18)
ipython (1.2.1)
mysql-connector-python (2.1.6)
MySQL-python (1.2.3rc1)
mysql-replication (0.13)
mysql-utilities (1.6.5)
ordereddict (1.2)
paramiko (1.12.4)
pip (7.1.0)
pyasn1 (0.3.1)
pycparser (2.18)
pycrypto (2.3)
pycurl (7.19.0)
pygpgme (0.1)
pymssql (2.1.0)
PyMySQL (0.7.11)
PyNaCl (1.1.2)
setuptools (0.6rc11)
six (1.10.0)
urlgrabber (3.9.1)
virtinst (0.600.0)
wheel (0.29.0)
yum-metadata-parser (1.1.2)
http://www.fabfile.org/en/latest/index.html
编写fabfile.py文件:
from fabric.api import run
def host_type(): #函数名随便定义
run('uname -s')
执行:
fab -H localhost host_type
http://docs.fabfile.org/en/1.10/usage/execution.html#connections
#不能同时出现多个hosts
from fabric.api import env
env.user='test' #机器的用户名
env.password='123' #机器的密码
env.hosts = ['node1','node2']
#分组
不能同时出现多个roledefs
from fabric.api import env
env.roledefs['webservers'] = ['www1', 'www2', 'www3']
env.roledefs = {
'web': ['www1', 'www2', 'www3'],
'dns': ['ns1', 'ns2']
Fab -R web …
cryptography 、 PyCrypto 、 PyCryptodome(pycrypto的分支pycryptodome)
PyCrypto:Python Cryptography Toolkit (pycrypto)
PyCryptodome: is a self-contained Python package of low-level cryptographic primitives.
f
Python第十五天 datetime模块 time模块 thread模块 threading模块 Queue队列模块 multiprocessing模块 paramiko模块 fabric模块的更多相关文章
- 孤荷凌寒自学python第二十五天初识python的time模块
孤荷凌寒自学python第二十五天python的time模块 (完整学习过程屏幕记录视频地址在文末,手写笔记在文末) 通过对time模块添加引用,就可以使用python的time模块来进行相关的时间操 ...
- 初学 Python(十五)——装饰器
初学 Python(十五)--装饰器 初学 Python,主要整理一些学习到的知识点,这次是生成器. #-*- coding:utf-8 -*- import functools def curren ...
- 孤荷凌寒自学python第十五天python循环控制语句
孤荷凌寒自学python第十五天python循环控制语句 (完整学习过程屏幕记录视频地址在文末,手写笔记在文末) python中只有两种循环控制语句 一.while循环 while 条件判断式 1: ...
- Python进阶(十五)----面向对象之~继承(单继承,多继承MRO算法)
Python进阶(十五)----面向对象之~继承 一丶面向对象的三大特性:封装,继承,多态 二丶什么是继承 # 什么是继承 # b 继承 a ,b是a的子类 派生类 , a是b的超类 基类 父类 # ...
- 多进程 multiprocessing 模块进程并发Process;Pool ;Queue队列 、threading模块;
multiprocessing 模块中的 Process类提供了跨平台的多进程功能,在windows和linux系统都可以使用. 1.首先要实例化一个类,传入要执行的函数. 实例名 = Process ...
- python学习(十五) 内建模块学习
介绍python的几个內建模块,原文链接 1 python的时间模块datetime 取现在时间 from datetime import datetime now = datetime.now() ...
- 流畅的python第十五章上下文管理器和else块学习记录
with 语句和上下文管理器for.while 和 try 语句的 else 子句 with 语句会设置一个临时的上下文,交给上下文管理器对象控制,并且负责清理上下文.这么做能避免错误并减少样板代码, ...
- python系列十五:Python3 错误和异常
#!/usr/bin/python #-*-coding:gbk-*- #Python3 错误和异常'''Python 语法错误或者称之为解析错语法分析器指出了出错的一行,并且在最先找到的错误的位置标 ...
- selenium python (十五)控制滚动条操作
#!/usr/bin/python# -*- coding: utf-8 -*-__author__ = 'zuoanvip' #一般用到操作滚动条的两个场景 #注册时的法律条文的阅读,判断用户 ...
随机推荐
- 24分钟让AI跑起飞车类游戏
本文由云+社区发表 作者:WeTest小编 WeTest 导读 本文主要介绍如何让AI在24分钟内学会玩飞车类游戏.我们使用Distributed PPO训练AI,在短时间内可以取得不错的训练效果. ...
- .NET 平台上C#语言的基本技术点
第一次用画图3D画的知识点,有点丑..........开始Csharp之路
- 【开发记录】如何在B/S项目中使用中国天气的实时天气功能
好久没有更新我的博客了,正好手头有一个比较合适的项目经验可以分享出来,就是这个如何使用中国天气的天气预报功能,也正好做个项目经验记录. 功能需求 这个功能需求比较简单,就是想在网页端显示实时天气数据. ...
- SQL执行WebService
写了一个钉钉发送消息的类, 要发送用友等审核单据信息, 模式: 钉钉发消息功能在webservice中, 用友消息列表中有新消息时,采用触发器执行webservice. 在测试中 ,功能正常 ,但将在 ...
- Chrome内核浏览器打开网页报 错误代码: ERR_TIMED_OUT
升级win10之后如果出现chrome内核的浏览器网页总是打不开 打开很慢 而ie和edge是可以正常访问的 用这个方法可以 我弄了几天终于 搞好了我直接转载过来了近期,工程师收到大量反馈360浏 ...
- 【JavaScript动画基础】学习笔记(一)-- 旋转箭头
随着鼠标的移动旋转箭头. requestAnimationFrame 在requestAnimationFrame之前我们可以用setInterval来实现动画的循环: function drawFr ...
- 微服务与RPC
1.微服务架构 1.1 特征 自动化部署,端点智能化,语言和数据的去中心化控制. 1.2架构 一种将一个单一应用程序开发为一组小型服务的方法,每个服务运行在自己的进程中,服务间通信采用轻量级通信机制( ...
- 最短路问题之Bellman-ford算法
题目: 最短路:给定两个顶点,在以这两个点为起点和终点的路径中,边的权值和最小的路径.考虑权值为点之间的距离. 单源最短路问题,Bellman-ford算法 思路:每次循环检查所有边,可优化. 应用于 ...
- 解决Ajax请求时无法重定向的问题
今天发现,当使用Ajax请求时,如果后台进行重定向到其他页面时是无法成功的,只能在浏览器地址栏输入才能够实现重定向. Ajax默认就是不支持重定向的,它是局部刷新,不重新加载页面. 需要实现的功能是, ...
- IDEA同步上传lua代码,方便开发。
因项目是Java和lua一起开发的,以前用Notepad++插件连接,每次关掉得重新寻找目录.有点耗时间,所以用idea提供的工具很是便利,再此做个笔记. 点击上面的绿色”+“号,添加 在配置mapp ...