python自动化开发学习-9 socket网络编程

#!/usr/bin/env python3
# -*- coding:utf-8 -*-

# 导入socket模块
import socket
#开启ip和port
ip_port=(‘127.0.0.1‘,9999)
# 生成句柄
s=socket.socket()
# 绑定IP端口，必须是元组
s.bind(ip_port)
# 最多连接数
s.listen(5)

# 开启信息处理死循环
while True:
    # 阻塞，等待连接
    conn,addr=s.accept()
    while True:  # 连接成功
        try:
            # 获取客户端的请求信息
            recv_data=conn.recv(1024)
            # 在server端输出获取的客户端信息
            print(‘RECV %s [%s]‘ %(addr,recv_data))
            # 向客户端发送数据
            send_data=recv_data.upper()
            conn.send(send_data)
        except Exception:
            break
    # 关闭连接
    conn.close()

#!/usr/bin/env python
# -*- coding:utf-8 -*-

# 导入socket模块
import socket
# 连接服务器的IP和端口
ip_port=(‘127.0.0.1‘,9999)
# 生成句柄
s=socket.socket()
# 请求连接服务器
s.connect(ip_port)
# 循环发送数据到服务端
while True:
    # 发送数据到服务端
    send_data=input(">>: ").strip()
    if len(send_data) == 0:continue
    s.send(bytes(send_data,‘utf8‘))
    # 接受服务端发送过来的数据
    recv_data=s.recv(1024)
    print(str(recv_data,‘utf8‘))
# 关闭连接
s.close()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 导入socket模块
import socket
#导入执行命令模块
import subprocess 
#定义元组
ip_port=(‘127.0.0.1‘,9999) 
#绑定协议，生成套接字
s=socket.socket()  
#绑定ip+协议+端口：用来唯一标识一个进程，ip_port必须是元组格式
s.bind(ip_port)    
#定义最大可以挂起的链接数，也就是一个客户端和服务端交互，另外5个客户端等待
s.listen(5)
#用来重复接收新的链接的循环
while True:  
    #接收客户端的链接请求，返回conn（相当于一个特定的链接），addr是客户端ip+port
    conn, addr = s.accept()
    #用来基于一个链接重复收发消息
    while True:
            try:  #捕捉客户端异常关闭（ctrl+c）
                recv_data = conn.recv(1024)  #收消息，阻塞
                if len(recv_data) == 0:
                    break #客户端如果退出，服务端将收到空消息，退出

                #发消息
                #执行系统命令，windows平台命令的标准输出是gbk编码，需要转换
                p = subprocess.Popen(str(recv_data, encoding=‘utf8‘), shell=True,stdout=subprocess.PIPE)                                                                                                     
                res = p.stdout.read()   #获取标准输出
                if len(res) == 0:   #执行错误命令，标准输出为空，
                    send_data = ‘cmd err‘
                else:
                    send_data = str(res, encoding=‘gbk‘)  #命令执行ok，字节gbk---->str---->字节utf-8,如果server在linux则无需如此转换
                #将发送给客户端的数据转换为字节
                send_data = bytes(send_data, encoding=‘utf8‘)

                #解决粘包问题
                ready_tag = ‘Ready|%s‘ % len(send_data)  # 定义给要发送数据的长度
                conn.send(bytes(ready_tag, encoding=‘utf8‘)) #发送数据长度给客户端
                feedback = conn.recv(1024)  #阻塞，接收客户端确认信息
                feedback = str(feedback, encoding=‘utf8‘)

                if feedback.startswith(‘Start‘):
                    conn.send(send_data)  #发送命令的执行结果
            except Exception:
                break
    #断开连接
    conn.close()

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import socket
ip_port = (‘127.0.0.1‘,9999)
s = socket.socket()
s.connect(ip_port)  #链接服务端，如果服务已经存在一个好的连接，那么挂起

while True:        #基于connect建立的连接来循环发送消息
    send_data = input(">>: ").strip()
    if send_data == ‘exit‘:
        break
    if len(send_data) == 0:
        continue
    s.send(bytes(send_data, encoding=‘utf8‘))

    #解决粘包问题
    ready_tag = s.recv(1024)  #收取带数据长度的字节：Ready|9998
    ready_tag = str(ready_tag, encoding=‘utf8‘) # 将字节转换为字符串
    if ready_tag.startswith(‘Ready‘):  #Ready|9998
        msg_size = int(ready_tag.split(‘|‘)[-1])  #获取待接收数据长度
    start_tag = ‘Start‘
    s.send(bytes(start_tag, encoding=‘utf8‘)) #发送确认信息给服务端，服务端收到消息后会发送命令执行结果

    #基于已经收到的待接收数据长度，循环接收数据
    recv_size = 0
    recv_msg = b‘‘
    while recv_size < msg_size:
        recv_data = s.recv(1024)
        recv_msg += recv_data
        recv_size += len(recv_data)
        print(‘MSG SIZE %s RECE SIZE %s‘ % (msg_size, recv_size))

    print(str(recv_msg, encoding=‘utf8‘))
# 关闭连接
s.close()

import socketserver
class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        conn = self.request
        conn.sendall(‘我是多线程‘)
        Flag = True
        while Flag:
            data = conn.recv(1024)
            if data == ‘exit‘:
                Flag = False
            elif data == ‘0‘:
                conn.sendall(‘您输入的是0‘)
            else:
                conn.sendall(‘请重新输入.‘)
if __name__ == ‘__main__‘:
    server = socketserver.ThreadingTCPServer((‘127.0.0.1‘,8009),MyServer)
    server.serve_forever()

import socket
ip_port = (‘127.0.0.1‘,8009)
sk = socket.socket()
sk.connect(ip_port)
while True:
    data = sk.recv(1024)
    print ‘receive:‘,data
    inp = input(‘please input:‘)
    sk.sendall(inp)
    if inp == ‘exit‘:
    break
sk.close()

class BaseRequestHandler:

    """Base class for request handler classes.

    This class is instantiated for each request to be handled.  The
    constructor sets the instance variables request, client_address
    and server, and then calls the handle() method.  To implement a
    specific service, all you need to do is to derive a class which
    defines a handle() method.

    The handle() method can find the request as self.request, the
    client address as self.client_address, and the server (in case it
    needs access to per-server information) as self.server.  Since a
    separate instance is created for each request, the handle() method
    can define arbitrary other instance variariables.

    """

    def __init__(self, request, client_address, server):
        self.request = request
        self.client_address = client_address
        self.server = server
        self.setup()
        try:
            self.handle()
        finally:
            self.finish()

    def setup(self):
        pass

    def handle(self):
        pass

    def finish(self):
        pass