Python_oldboy_自动化运维之路_socket编程（十）

链接：http://www.cnblogs.com/linhaifeng/articles/6129246.html

1.osi七层

引子：

须知一个完整的计算机系统是由硬件、操作系统、应用软件三者组成,具备了这三个条件，一台计算机系统就可以自己跟自己玩了（打个单机游戏，玩个扫雷啥的）

如果你要跟别人一起玩，那你就需要上网了（访问个黄色网站，发个黄色微博啥的），互联网的核心就是由一堆协议组成，协议就是标准，全世界人通信的标准是英语，如果把计算机比作人，互联网协议就是计算机界的英语。所有的计算机都学会了互联网协议，那所有的计算机都就可以按照统一的标准去收发信息从而完成通信了。人们按照分工不同把互联网协议从逻辑上划分了层级，详见我另一篇博客

网络通信原理：http://www.cnblogs.com/linhaifeng/articles/5937962.html

为何学习socket一定要先学习互联网协议：

1.首先：本节课程的目标就是教会你如何基于socket编程，来开发一款自己的C/S架构软件

2.其次：C/S架构的软件（软件属于应用层）是基于网络进行通信的

3.然后：网络的核心即一堆协议，协议即标准，你想开发一款基于网络通信的软件，就必须遵循这些标准。

4.最后：就让我们从这些标准开始研究，开启我们的socket编程之旅

2.socket层

3.socket是什么

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。

也有人将socket说成ip+port，ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序，ip地址是配置到网卡上的，而port是应用程序开启的，ip与port的绑定就标识了互联网中独一无二的一个应用程序

而程序的pid是同一台机器上不同进程或者线程的标识

4.套接字的工作流程

一个生活中的场景。你要打电话给一个朋友，先拨号，朋友听到电话铃声后提起电话，这时你和你的朋友就建立起了连接，就可以讲话了。等交流结束，挂断电话结束此次交谈。    生活中的场景就解释了这工作原理，也许TCP/IP协议族就是诞生于生活中，这也不一定。

先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束

socket()模块函数用法

案例1：基于tcp的一次套接字的通信：

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/

import socket

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #socket.AF_INET，叫做基于网络的地址家族 socket.SOCK_STREAM代表TCP协议
                                                       #相当于买手机
phone.bind(('127.0.0.1',8081))                           #相当于插入卡，唯一的标示

phone.listen(5)                                        #相当于开机 5表示等待别人连接，假如我这边通话中，让他等待我完成在连接

conn,addr=phone.accept()                               #接电话conn表示线路，addr表示客户端地址
print('tcp的连接',conn)
print('客户端的地址',addr)

data=conn.recv(1024)                                   #收消息，收1024个字节大小的内容，收到的内容是bytes格式
print('from client msg:%s' %data)                      #打印传过来的消息

conn.send(data.upper())                                #发消息，将传过来的值转换成大写

conn.close()                                           #挂电话
phone.close()                                          #关手机

socket服务端

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/
import socket

client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

client.connect(('127.0.0.1',8081))          #拨通电话

client.send('hello'.encode('utf-8'))        #客户发送消息

date =  client.recv(1024)
print(date)

client.close()

socket客户端

#先执行服务端在执行客户端

#服务端输出：
tcp的连接 <socket.socket fd=268, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8081), raddr=('127.0.0.1', 54345)>
客户端的地址 ('127.0.0.1', 54345)
from client msg:b'hello'

#客户端输出：
b'HELLO'

执行结果

案例2：循环的socket

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/
#验证：将一个客户端断开连接，另外一个自动连接
import socket

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)    #假如不加这行参数，假如运行过一次服务器在运行就表示端口被占用，报错
phone.bind(('127.0.0.1',8081))

phone.listen(5)

while True:                             #链接循环
    conn,addr=phone.accept()
    print('client:',addr)
    while True:
        try:                                 #异常捕捉，假如有异常，然后就断掉此次循环
            data=conn.recv(1024)
            print('from client msg:%s' %data)
            conn.send(data.upper())
        except Exception:                   #万能的错误，假如上面有一个异常，就执行下面的break代码
            break

    conn.close()
phone.close()

socket服务端

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/

import socket

client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

client.connect(('127.0.0.1',8081))          #拨通电话

while True:
    msg = input('>>:')
    client.send(msg.encode('utf-8'))        #客户发送消息

    date =  client.recv(1024)
    print(date)

client.close()

socket客户端1

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/
import socket

client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

client.connect(('127.0.0.1',8081))          #拨通电话

while True:
    msg = input('>>:')
    client.send(msg.encode('utf-8'))        #客户发送消息

    date =  client.recv(1024)
    print(date)

client.close()

socket客户端2

#服务端
C:\Python35\python3.exe D:/pycharm/s16/day7/循环的socket服务端.py
client: ('127.0.0.1', 58308)
from client msg:b'ls'
from client msg:b'test'
from client msg:b'\xe8\xb5\xb0\xe4\xba\x86'
client: ('127.0.0.1', 58313)
from client msg:b'ls'
from client msg:b'ss'

#客户端1：将客户端1断掉后发现服务端可以看到客户端2立马连了上来
C:\Python35\python3.exe D:/pycharm/s16/day7/循环的socket客户端2.py
>>:ls
b'LS'
>>:test
b'TEST'
>>:走了
b'\xe8\xb5\xb0\xe4\xba\x86'
>>:
Process finished with exit code 1

#客户端2
C:\Python35\python3.exe D:/pycharm/s16/day7/循环的socket客户端.py
>>:ls
b'LS'
>>:ss
b'SS'

执行结果

案例3：循环的socke优化

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/
#验证：将一个客户端断开连接，另外一个自动连接
import socket

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)    #假如不加这行参数，假如运行过一次服务器在运行就表示端口被占用，报错
phone.bind(('127.0.0.1',8081))

phone.listen(5)

while True:                             #链接循环
    conn,addr=phone.accept()
    print('client:',addr)
    while True:
        try:                                 #异常捕捉，假如有异常，然后就断掉此次循环
            data=conn.recv(1024)
            if not data:break               #针对linux，客户端断开链接的异常处理
            print('from client msg:%s' %data)
            conn.send(data.upper())
        except Exception:                   #万能的错误，假如上面有一个异常，就执行下面的break代码
            break

    conn.close()
phone.close()

socket服务端

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/

import socket

client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

client.connect(('127.0.0.1',8081))          #拨通电话

while True:
    msg = input('>>:')
    if not msg:continue                     #假如不输入这条内容，当msg直接为空时，会发生阻塞，客户端send一个空，服务器会一直等着收，不会send
    client.send(msg.encode('utf-8'))        #客户发送消息
    print('===========has send=========')

    date =  client.recv(1024)
    print('===========has recv=========')
    print(date)

client.close()

socket客户端

案例4：socke模拟远程执行命令

import socket
import subprocess
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)    #假如不加这行参数，假如运行过一次服务器在运行就表示端口被占用，报错
phone.bind(('127.0.0.1',8081))
phone.listen(5)
while True:
    conn,addr=phone.accept()
    print('client:',addr)
    while True:
        try:
            cmd=conn.recv(1024)
            print('-------shou dao--- ')
            if not cmd:break
            print('from client msg:%s' %cmd)

            res=subprocess.Popen(cmd.decode('utf-8'),
                             shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE
                             )

            err=res.stderr.read()
            if err:
                back_msg=err
            else:
                back_msg=res.stdout.read()

            conn.sendall(back_msg)

        except Exception:
            break

    conn.close()
phone.close()

socket服务端

import socket
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect(('127.0.0.1',8081))

while True:
    cmd = input('>>:').strip()
    if not cmd:continue

    client.send(cmd.encode('utf-8'))
    print('send chenggong')
    res = client.recv(1024)
    print(res.decode('gbk'))

socke客户端

#服务端
client: ('127.0.0.1', 61320)
-------shou dao---
from client msg:b'dir'

#客户端
C:\Python35\python3.exe D:/pycharm/s16/day7/远程执行命令客户端.py
>>:dir
send chenggong
 驱动器 D 中的卷是 Data
 卷的序列号是 EE42-C3C3

 D:\pycharm\s16\day7 的目录

2017/03/08  21:35    <DIR>          .
2017/03/08  21:35    <DIR>          ..
2017/03/08  17:23               337 socket客户端.py
2017/03/08  17:23             1,222 socket服务端.py
2017/03/08  14:39               697 为什么要有类，对象.py
2017/03/07  17:24               690 多态与多态性.py
2017/03/07  19:22               780 子类调用父类的方法.py
2017/03/06  17:51             1,268 对象之间的交互.py
2017/03/07  17:58             1,532 封装.py
2017/03/08  20:06               652 循环的socket客户端.py
2017/03/08  17:49               380 循环的socket客户端2.py
2017/03/08  20:09             1,062 循环的socket服务端.py
2017/03/07  15:59               939 抽象类.py
2017/03/07  15:03               741 接口与归一化设计.py
2017/03/07  18:57             1,376 特性_set_get.py
2017/03/07  18:23             1,337 特性（property）.py
2017/03/06  16:09                 2 笔记
2017/03/06  17:39             1,719 类与对象.py
20

#备注：假如执行的时候客户端发出去了，服务端没有收到，但是已经连接上了，已经打印客户端的信息，那么就换个端口试试，原因：未解

执行结果

5.粘包

1.粘包的存在：客户端发两次，服务端收两次，

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/
import socket

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)
phone.bind(('127.0.0.1',8081))

phone.listen(5)

conn,addr=phone.accept()

data1=conn.recv(1)        #收一个字节
print(data1)

data2=conn.recv(10)        #收10个字节
print(data2)

服务端

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/
import socket

client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

client.connect(('127.0.0.1',8081))

client.send('hello'.encode('utf-8'))
client.send('lijun'.encode('utf-8'))

客户端

#服务端

C:\Python35\python3.exe D:/pycharm/s16/day7/粘包/服务端.py
b'h'
b'ellolijun'

#说明服务端只从自己的缓存里收

执行结果

2.tcp是基于流的一种工作方式（不知道什么时候开始，什么时候结束），所以只会收到第一次发的消息

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/
import socket

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)
phone.bind(('127.0.0.1',8081))

phone.listen(5)

conn,addr=phone.accept()

data1=conn.recv(1024)
print(data1)

data2=conn.recv(1024)
print(data2)

s

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/
import time
import socket

client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

client.connect(('127.0.0.1',8081))

client.send('hello'.encode('utf-8'))
time.sleep(5)                                  #相当于截断5s中后在发第二个消息
client.send('lijun'.encode('utf-8'))

c

#服务端
C:\Python35\python3.exe D:/pycharm/s16/day7/粘包/s.py
b'hello'

执行结果

3.知道了粘包存在的原理，解决方法就是客户端发的时候先把要发的大小发过去让服务端知道应该接受多少数据

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/
import struct                                                        #将一串数字打包成二进制并且长度固定的模块
#x=struct.pack('i',12121212121212)                                   #i表示将一串数字打包成4个字节
#struct.unpack('1',x)[0]                                             #解包
import socket
import subprocess
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)
phone.bind(('127.0.0.1',8081))
phone.listen(5)
while True:
    conn,addr=phone.accept()
    print('client:',addr)
    while True:
        try:
            cmd=conn.recv(1024)
            print('-------shou dao--- ')
            if not cmd:break
            print('from client msg:%s' %cmd)

            res=subprocess.Popen(cmd.decode('utf-8'),
                             shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE
                             )

            err=res.stderr.read()
            if err:
                back_msg=err
            else:
                back_msg=res.stdout.read()

            conn.send(struct.pack('i',len(back_msg)))      #发送消息之前先将长度发送过去
            conn.sendall(back_msg)                         #sendall运用场景为假如数据back_msg过大，send一次发不过去，sendall就是表示循环的send，直到发完为止

        except Exception:
            break

    conn.close()
phone.close()

服务端

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/
import socket
import struct
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect(('127.0.0.1',8081))

while True:
    cmd = input('>>:').strip()
    if not cmd:continue

    client.send(cmd.encode('utf-8'))

    data=client.recv(4)
    data_size=struct.unpack('i',data)[0]             #解压

    recv_size = 0                                    #客户端解决msg过大的方法
    recv_bytes=b''
    while recv_size < data_size:
        res=client.recv(1024)
        recv_bytes+=res
        recv_size+=len(res)

    print(recv_bytes.decode('gbk'))

客户端

#服务端
C:\Python35\python3.exe D:/pycharm/s16/day7/粘包/解决粘包服务端.py
client: ('127.0.0.1', 58287)
-------shou dao---
from client msg:b'dir'
-------shou dao---
from client msg:b'ls'

#客户端
C:\Python35\python3.exe D:/pycharm/s16/day7/粘包/解决粘包客户端.py
>>:dir
 驱动器 D 中的卷是 Data
 卷的序列号是 EE42-C3C3

 D:\pycharm\s16\day7\粘包 的目录

2017/03/09  17:37    <DIR>          .
2017/03/09  17:37    <DIR>          ..
2017/03/09  15:09               368 c.py
2017/03/09  15:11               363 s.py
2017/03/09  14:56               261 客户端.py
2017/03/09  15:00               407 服务端.py
2017/03/09  17:37               664 解决粘包客户端.py
2017/03/09  15:36             1,612 解决粘包服务端.py
               6 个文件          3,675 字节
               2 个目录 197,418,659,840 可用字节

>>:ls
'ls' 不是内部或外部命令，也不是可运行的程序
或批处理文件。

执行结果

4.假如发送的消息两三个G，那么struct.pack('i',122121212)的i就满足不了，需要自定制报头

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/
import struct                                                        #将一串数字打包成二进制并且长度固定的模块
#x=struct.pack('i',12121212121212)                                   #i表示将一串数字打包成4个字节
#struct.unpack('1',x)[0]                                             #解包
import socket
import subprocess
import json

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)
phone.bind(('127.0.0.1',8081))
phone.listen(5)
while True:
    conn,addr=phone.accept()
    print('client:',addr)
    while True:
        try:
            cmd=conn.recv(1024)
            print('-------shou dao--- ')
            if not cmd:break
            print('from client msg:%s' %cmd)

            #定义命令执行结果的输出
            res=subprocess.Popen(cmd.decode('utf-8'),
                             shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE
                             )

            err=res.stderr.read()
            if err:
                back_msg=err
            else:
                back_msg=res.stdout.read()

            #第一阶段：报头信息
            head_dic={
                'data_size':len(back_msg)
            }                                              #定义报头的字典
            head_json=json.dumps(head_dic)                 #发的时候字典就变成了字节或者字符串，需要序列化
            head_bytes=head_json.encode('utf-8')           #将字典转换成字节

            #第二阶段：发消息，先发报头的长度（4个字节）
            conn.send(struct.pack('i',len(head_bytes)))      #发送消息之前先将长度发送过去，这次发字典的长度

            #第三阶段：发报头
            conn.send(head_bytes)

            #第四阶段：发真实的数据
            conn.sendall(back_msg)                         #sendall运用场景为假如数据back_msg过大，send一次发不过去，sendall就是表示循环的send，直到发完为止

        except Exception:
            break

    conn.close()
phone.close()

服务端

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/

import json
import socket
import struct
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect(('127.0.0.1',8081))

while True:
    cmd = input('>>:').strip()
    if not cmd:continue

    client.send(cmd.encode('utf-8'))

    #收报头的长度
    head=client.recv(4)
    head_size=struct.unpack('i',head)[0]             #解压后就是报头的长度

    #收报头，跟进报头的长度收报头
    head_bytes=client.recv(head_size)
    head_json=head_bytes.decode('utf-8')            #转换成bytes

    head_dic=json.loads(head_json)                  #反序列化
    data_size=head_dic['data_size']                 #取出真实的数据

    #收真实的数据
    recv_size = 0                                    #客户端解决msg过大的方法
    recv_bytes=b''
    while recv_size < data_size:
        res=client.recv(1024)
        recv_bytes+=res
        recv_size+=len(res)

    print(recv_bytes.decode('gbk'))

客户端