033远程执行命令

在服务器执行命令
之前好像缺了执行命令的模块，现在补上

import  subprocess
obj = subprocess.Popen('dir',shell=True,stdout=subprocess.PIPE)
#拿到一个对象，前面是命令，shell设置可以执行脚本，stdout设置一个进程管道，这里实际上是有两个进程，一个是主进程，一个是shell进程
x = obj.stdout.read()    # 这里拿到执行信息
print(str(x,'gbk'))  #  str(x,'utf8')忘记系统是gbk编码了

 

    1. Python中执行系统命令常见的几种方法：  
    2. (1)os.system  
    3. # 仅仅在一个子终端运行系统命令，而不能获取命令执行后的返回信息  
    4. # 如果再命令行下执行，结果直接打印出来  
    5. 例如：  
    6. >>> import os  
    7. >>> os.system('ls')  
    8. chk_err_log.py CmdTool.log  install_log.txt  install_zabbix.sh  manage_deploy.sh  MegaSAS.log  
    9.  
    10. (2)os.popen  
    11. #该方法不但执行命令还返回执行后的信息对象  
    12. #好处在于：将返回的结果赋于一变量，便于程序的处理。  
    13. 例如：  
    14. >>> import os  
    15. >>>tmp = os.popen('ls *.sh').readlines()  
    16. >>>tmp  
    17. ['install_zabbix.sh\n', 'manage_deploy.sh\n', 'mysql_setup.sh\n', 'python_manage_deploy.sh\n', 'setup.sh\n']  
    18.  
    19. (3)使用模块subprocess  
    20. 使用方法：  
    21. >>> import subprocess  
    22. >>> subprocess.call (["cmd", "arg1", "arg2"],shell=True)  
    23. 好处在于:运用对线程的控制和监控，将返回的结果赋于一变量，便于程序的处理。  
    24. 如获取返回和输出:  
    25. import subprocess  
    26. p = subprocess.Popen('ls *.sh', shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)  
    27. print p.stdout.readlines()  
    28. for line in p.stdout.readlines():  
    29.     print line,  
    30. retval = p.wait()  
    31.  
    32. (4)  使用模块commands模块  
    33. 常用的主要有两个方法：getoutput和getstatusoutput  
    34. >>> import commands  
    35. >>> commands.getoutput('ls *.sh')  
    36. 'install_zabbix.sh\nmanage_deploy.sh\nmysql_setup.sh\npython_manage_deploy.sh\nsetup.sh' 
    37. >>> commands.getstatusoutput('ls *.sh')  
    38. (0, 'install_zabbix.sh\nmanage_deploy.sh\nmysql_setup.sh\npython_manage_deploy.sh\nsetup.sh')  
    39.  
    40. 注意： 当执行命令的参数或者返回中包含了中文文字，那么建议使用subprocess，如果使用os.popen则会出现错误。 

以上部分文档来自：http://blog.csdn.net/wangzhaotongalex/article/details/48998299

 

###远程执行命令例子：

#指令执行结果短的，不会出现问题

 1 import socket
 2 import subprocess
 3 def get_server_socket():
 4     sk = socket.socket()
 5     server_address = ('127.0.0.1',8888)
 6     sk.bind(server_address)
 7     sk.listen(5)
 8     return sk
 9 
10 def get_conn(sk):
11     print('waitconnect...')
12     conn,addr = sk.accept()
13     return conn
14 
15 if __name__ == '__main__':
16     sk = get_server_socket()
17     conn = get_conn(sk)
18     while True:
19         try:
20             data = conn.recv(1024)##Linux这里不会报错，如果强行关闭了conn，data就会变成空，也就是说Linux的直接不try就行了。
21         except Exception as e:
22             conn = get_conn(sk)
23         print(str(data,'utf8'))
24         if not data:
25             conn = get_conn(sk)
26             continue
27         sp = subprocess.Popen(str(data,'utf8'),shell=True,stdout=subprocess.PIPE)#注意命令要是字符串类型
28         result = sp.stdout.read()#str(sp.stdout.read(),'gbk')
29         conn.send(result)
30         print(str(result,'gbk'))
31         print('waiting...')
32     conn.close()
cmd_server.py
 1 import socket
 2 
 3 def connect_server():
 4     sk = socket.socket()
 5     server_address = ('127.0.0.1',8888)
 6     sk.connect(server_address)
 7     return sk
 8 
 9 if __name__ == '__main__':
10     sk = connect_server()
11     while True:
12         inp = input('>>>')
13         if inp == 'exit':
14             break
15         sk.send(bytes(inp,'utf8'))
16         print('waiting...')
17         data = sk.recv(1024)
18         print(str(data,'gbk'))
19     sk.close()
cmd_client.py

 

#指令执行结果较长，无法一次传递，改进。传送文件的思想。

 1 import  socket
 2 import  subprocess
 3 def  get_server_socket():
 4     sk = socket.socket()
 5     server_address = ('127.0.0.1',8888)
 6     sk.bind(server_address)
 7     sk.listen(5)
 8     return sk
 9 def  get_conn(sk):
10     print('waitconnect...')
11     conn, addr = sk.accept()
12     return conn
13 
14 if __name__ == '__main__':
15     sk = get_server_socket()
16     conn = get_conn(sk)
17     while True:
18         try:
19             data = conn.recv(1024)##Linux这里不会报错，如果强行关闭了conn，data就会变成空，也就是说Linux的直接不try就行了。
20         except Exception as e:
21             conn = get_conn(sk)
22         print(str(data,'utf8'))
23         if not data:
24             conn = get_conn(sk)
25             continue
26         sp = subprocess.Popen(str(data,'utf8'),shell=True,stdout=subprocess.PIPE)#注意命令要是字符串类型
27         result = sp.stdout.read()#读取内容
28         conn.sendall(bytes(str(len(result)),'utf8'))#发送长度
29         conn.sendall(result)#发送内容
30         print(str(result,'gbk'))
31         print('waiting...')
32     conn.close()
cmd_server.py
 1 import socket
 2 def connect_server():
 3     sk = socket.socket()
 4     server_address = ('127.0.0.1',8888)
 5     sk.connect(server_address)
 6     return sk
 7 
 8 if __name__ == '__main__':
 9     sk = connect_server()
10     while True:
11         inp = input('>>>')
12         if inp == '__exit':
13             break
14         sk.send(bytes(inp,'utf8'))
15     print('waiting...')
16 
17     result_length = int(str(sk.recv(1024),'utf8'))#记录长度，然后下面接收到相应长度的那内容停止
18     data = bytes()
19     while  len(data) != result_length:
20         r = sk.recv(1024)
21         data += r
22     print(str(data,'gbk'))
23     sk.close()
cmd_client.py

 

####另外两次连续接收会出现粘包现象

做个隔断，就是接收方随便发送一个数据，发送方接受后才继续发送，这样子就解决了。

 

posted @ 2018-03-02 10:42  Alos403  阅读(247)  评论(0)  编辑  收藏  举报