python之day9(socket)

今日重点socket网络编程：

1，tcp/ip简介：

2，socket简单应用模型：

3，socket单用户模式扩展：

4，socketserver实例：

首先记录一个在day6时没有记录的知识点：

百分比的应用：

import sys
import time

def view_bar(num, total):
    rate = float(num) / float(total)
    rate_num = int(rate * 100)
    r = '
%d%%' % (rate_num, )
    sys.stdout.write(r)
    sys.stdout.flush()


if __name__ == '__main__':
    for i in range(0, 101):
        time.sleep(0.1)
        view_bar(i, 100)

进入主要内容：

一,tcp/ip

　　　　osi7层结构以及具体作用。

　　　　物理层：电缆，双绞线，无线电波

　　　　链路层（网卡）：ethernet通用协议---》找到唯一的mac地址

　　　　网络层：IP 找到了子网中唯一的标识。

　　　　传输层：tcp,udp,port 规定传输协议以及端口号。

　　　　tcp/ip基本模型

二，socket简单应用模型：

　　　　socket的所在位置。

　　　　整个的socket交流过程。

socket要点提示：

1.基于python3.5.2版本的socket只能收发字节(python2.7可以发送str)
2.退出只在客户端退出就ok了
3.s.accept()和s.recv()是阻塞的（基于链接正常）
4.listen(n) n代表：能挂起的链接数，如果n=1，代表可以链接一个，挂起一个，第三个拒绝
5.服务端出现端口冲突：修改监听端口号
6.服户端：1.send #数据长度
              4.recv #收到确认信息，开始下一步发送

          send

  客户端：2.recv #获取数据长度
             3.send #发送确认信息

          recv #循环接收

基础socket程序：

import socket
ip_port=('127.0.0.1',9999)
#买手机
s=socket.socket()
#买手机卡
s.bind(ip_port)
#开机
s.listen(5)
#等待电话
while True:
    conn,addr=s.accept()
    #收消息
    while True:
        try:
            recv_data=conn.recv(1024)
            if len(recv_data) == 0:break
            # print('--------------------',type(recv_data))
            #发消息
            send_data=recv_data.upper()
            print(send_data)
            conn.send(send_data)
        except Exception:
            break
    #挂电话t
    conn.close()

#!/usr/bin/env  python
# -*- coding: UTF-8 -*-
# Author: Aaron Shen

import socket
ip_port=('127.0.0.1',9999)
#买手机
s=socket.socket()
#拨号
s.connect(ip_port)
#发送消息
while True:
    send_data=input(">>: ").strip()
    if send_data == "exit": break
    if len(send_data) == 0:continue
    s.send(bytes(send_data,encoding='utf8'))


    #收消息
    recv_data=s.recv(1024)
    print(str(recv_data,encoding='utf8'))
#挂电话
s.close()

三，socket单用户模式扩展：

关于执行系统命令，以及粘包问题解决思想：

执行系统命令 用到subprocess 模块 .Popen方法 参数跟（系统命令，shell=True,stdout = subprocess.PIPE, stderr = subprocess.PIPE）

粘包问题产生的原因：

由于发送端的字节数超过了接收端一次性可接收的数量，到时一次无法将发送端的数据全部接收完，再继续执行命令是会继续进行发送，造成粘包。

解决办法：

首先就是要有一下循环的思想，只要没接收完就一直接收。因此我们要知道发送包data的具体大小。

其次我们要先将data的大小发送给接收端。

然后接收端回复Ok我收到了发送端要发送多大的包给我，我会根据这个包的大小进行循环接收，接收完就不再接收。

最后发送端开始发送数据，接收端接收知道接收完成。

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

                #发消息
                p=subprocess.Popen(str(recv_data,encoding='utf8'),shell=True,stdout=subprocess.PIPE) #执行系统命令，windows平
                                                                                                      # 台命令的标准输出是gbk编码，需要转换
                res=p.stdout.read()   #获取标准输出
                if len(res) == 0:   #执行错误命令，标准输出为空，
                    send_data='cmd err'
                else:
                    send_data=str(res,encoding='gbk')  #命令执行ok，字节gbk---->str---->字节utf-8

                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 -*-
# Author:Alex Li
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()

四，socketserver实例：

　　这部分是alex大拿老师讲的，基本上没听懂，呵呵，主要靠课下重新读代码，重新构思的。

　　首先说一下socketserver与普通socket的区别：

　　普通socket所有点链路（conn）都是单通道的，只能一个客户端占用。服务端也是一对一进行相应。如果还有别的客户端要访问就要排队等待，直到之前的客户端退出后才可以与服务端进行交互。

　　

　　socketserver 使用socketserver模块（2.7头字母要进行大写），继承了socketserver.BaseRequestHandler这个类，我们用的时候必须使用 handle这个函数。他的特点就是可以完成一对多的相应。

　　　基本程序构建：

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


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

class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        # print self.request,self.client_address,self.server
        self.request.sendall(bytes('欢迎致电 10086，请输入1xxx,0转人工服务.',encoding="utf-8"))
        while True:
            data = self.request.recv(1024)
            print("-->",len(data))
            if len(data) == 0:break
            print("[%s] says:%s" % (self.client_address,data.decode() ))
            self.request.sendall(data.upper())

if __name__ == '__main__':
    server = socketserver.ThreadingTCPServer(('127.0.0.1',8009),MyServer)
    server.serve_forever()

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

import socket
ip_port=('192.168.11.58',8009)
#买手机
s=socket.socket()
#拨号
s.connect(ip_port)
#发送消息
welcome_msg = s.recv(1024)
print("from server:",welcome_msg.decode())
while True:
    send_data=input(">>: ").strip()
    if len(send_data) == 0:continue
    s.send(bytes(send_data,encoding='utf8'))
    #收消息
    recv_data=s.recv(1024)
    print(str(recv_data,encoding='utf8'))
    #挂电话
s.close()

　　通过socket 远程执行命令（通过客户端发送命令到服务端并执行）

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


#!/usr/bin/env python
# -*- coding:utf-8 -*-
#import SocketServer
import socketserver
import subprocess 
class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        # print self.request,self.client_address,self.server
        self.request.sendall(bytes('欢迎致电 10086，请输入1xxx,0转人工服务.',encoding="utf-8"))
        while True:
            data = self.request.recv(1024)
            if len(data) == 0:break
            print("[%s] says:%s" % (self.client_address,data.decode() ))
            #self.request.sendall(data.upper())
            cmd = subprocess.Popen(data.decode(),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
            cmd_res =cmd.stdout.read()
            if not cmd_res:
               cmd_res = cmd.stderr.read()
            if len(cmd_res) == 0: #cmd has not output 
               cmd_res = bytes("cmd has output",encoding="utf-8")
            self.request.send(cmd_res )


if __name__ == '__main__':
    server = socketserver.ThreadingTCPServer(('0.0.0.0',8009),MyServer)
    server.serve_forever()

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

import socket
ip_port=('192.168.11.58',8009)
#买手机
s=socket.socket()
#拨号
s.connect(ip_port)
#发送消息
welcome_msg = s.recv(1024)
print("from server:",welcome_msg.decode())
while True:
    send_data=input(">>: ").strip()
    if len(send_data) == 0:continue
    s.send(bytes(send_data,encoding='utf8'))
    #收消息
    recv_data=s.recv(1024)
    print(str(recv_data,encoding='utf8'))
    #挂电话
s.close()

　　通过socket进行ftp 上传操作（通过客户端发送指令，上传到服务器端）

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


#!/usr/bin/env python
# -*- coding:utf-8 -*-
#import SocketServer
import socketserver,json
class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        # print self.request,self.client_address,self.server
        self.request.sendall(bytes('欢迎致电 10086，请输入1xxx,0转人工服务.',encoding="utf-8"))
        while True:
            data = self.request.recv(1024)                  #接收要进行操作的基本信息，包括动作，文件路径以及文件名，文件大小
            if len(data) == 0:break
            print("data", data)
            print("[%s] says:%s" % (self.client_address,data.decode() ))

            task_data = json.loads( data.decode()  )        #接收到一个json格式的字典
            task_action = task_data.get("action")           #获取字典的中动作的值
            if hasattr(self, "task_%s"%task_action):        #反射到本程序的下面的函数，查看是否存在。如果存在
               func = getattr(self,"task_%s" %task_action)  #获取函数
               func(task_data)                                     #执行函数，同时参数就是那个字典
            else:
               print("task action is not supported",task_action)

    def task_put(self,*args,**kwargs):
        print("---put",args,kwargs)         
        filename = args[0].get('filename')          #文件名就等于task_data.get('filename')
        filesize = args[0].get('file_size')         #文件大小就等于task_data.get('file_size')
        server_response = {"status":200}            #准备工作都准备好后，给客户端发一个确认
        self.request.send(bytes( json.dumps(server_response), encoding='utf-8'  ))      #发送确认
        f = open(filename,'wb')                     #打开文件
        recv_size = 0                                #未开始接收，因此接收大小是 0
        while recv_size < filesize:                  #如果接收大小小于文件大小就是一直循环
            data = self.request.recv(4096)            #开始接收
            f.write(data)                               #写入文件
            recv_size += len(data)                      #增加大小
            print('filesize: %s  recvsize:%s' % (filesize,recv_size))           #展示进度
        print("file recv success")                      #循环结束，完成接收
        f.close()

if __name__ == '__main__':
    server = socketserver.ThreadingTCPServer(('0.0.0.0',8009),MyServer)
    server.serve_forever()

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

import socket
import os ,json
ip_port=('192.168.11.150',8009)                     #要访问的服务端IP以及端口
#买手机
s=socket.socket()                                      #生成套接字s
#拨号
s.connect(ip_port)                                      #连接服务和端口
#发送消息
welcome_msg = s.recv(1024)                              #获取服务端相应
print("from server:",welcome_msg.decode())             #打印获取的服务端欢迎语
while True:                                             #循环交互
    send_data=input(">>: ").strip()
    if len(send_data) == 0:continue                     #如果发送为空就重新发送

    cmd_list = send_data.split()                        #将命令进行分割 [put  test.txt]
    if len(cmd_list) <2:continue                        #如果小于2个元素就重新输入，命令是不完整的
    task_type = cmd_list[0]                               #第一个是命令 put, 第二个是文件路径
    if task_type == 'put':                              #如果是 put
        abs_filepath = cmd_list[1]                       #第二个就是文件路径
        if os.path.isfile(abs_filepath):                   #如果文件存在
            file_size = os.stat(abs_filepath).st_size       #获取文件大小
            filename = abs_filepath.split("\")[-1]         #获取文件名
            print('file:%s size:%s' %(abs_filepath,file_size))
            msg_data = {"action":"put",
                        "filename":filename,
                        "file_size":file_size}             #写成字典包括动作，文件名，文件大小

            s.send(  bytes(json.dumps(msg_data),encoding="utf-8")  )        #将字典整合成json发送给服务端（明确要上传的信息）
            server_confirmation_msg = s.recv(1024)                           #接收服务端发送的确认信息。
            confirm_data = json.loads(server_confirmation_msg.decode())      #获取确认信息，服务端发来的信息也是json封装的字典
            if confirm_data['status'] ==200:                                #如果是200 确认成功

                print("start sending file ",filename)
                f = open(abs_filepath,'rb')                                 #二进制打开要上传的文件
                for line in f:                                              #逐行循环
                    s.send(line)                                             #上传到服务端   

                print("send file done ")

        else:
            print("33[31;1mfile [%s] is not exist33[0m" % abs_filepath)
            continue
    else:
        print("doesn't support task type",task_type)
        continue
    #s.send(bytes(send_data,encoding='utf8'))
    #收消息
    recv_data=s.recv(1024)
    print(str(recv_data,encoding='utf8'))
    #挂电话
s.close()