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

 ==== 基于TCP协议的socket实现远程命令输入之Server ====

import subprocess
from socket import *

server = socket(AF_INET,SOCK_STREAM)
server.bind(("0.0.0.0",6666))   放在远程填入0.0.0.0，放在本地填入127.0.0.1
server.listen(5)

while 1:   链接循环
    conn,client_addr = server.accept()
     通信循环
        try:   防止Windows平台下Client端异常关闭导致双向链接崩塌Server端异常的情况发生
            cmd = conn.recv(1024)
            if not cmd:   防止类Unix平台下Client端异常关闭导致双向链接崩塌Server端异常的情况发生
                break
            res = subprocess.Popen(cmd.decode(utf-8"),shell=True,stdout=subprocess.PIPE,stderr= 正确结果
            stderr_res = res.stderr.read()   错误结果
             subprocess模块拿到的是bytes类型，所以直接发送即可

            cmd_res = stdout_res if stdout_res else stderr_res   因为两个结果只有一个有信息，所以我们只拿到有结果的那个
            conn.send(cmd_res)

        except Exception:
            

    conn.close()   由于client端链接异常，故关闭链接循环

 ==== 基于TCP协议的socket实现远程命令输入之Client ====



client =xxx.xxx.xxx.xxx 填入Server端公网IP

while 1:
    cmd = input(请输入命令>>>:).strip()
    not cmd:
        continue
    if cmd == quit:
        
    client.send(cmd.encode())
    cmd_res = client.recv(1024)   本次接收1024字节数据
    print(cmd_res.decode("))   如果Server端是Windows则用gbk解码，类Unix用utf-8解码

client.close()

ip_port = (127.0.0.1)
buffer_size = 1024
back_log = 5 server.accept()
conn.send(hello,".encode( 第一次发送是6Bytes的数据
conn.send(world,1)">"))      第二次也是6Bytes的数据
conn.send(yunyaGG!! 第三次是9Bytes的数据

 我们读取数据时统一用设定的 buffer_size 来读取
print(这是第一次的数据包:))
data_2 = client.recv(buffer_size)
这是第二次的数据包:))
data_3 =这是第三次的数据包:"))

 ==== 执行结果 ====
"""
这是第一次的数据包: hello,这是第二次的数据包: world,yunyaGG!!
这是第三次的数据包: 
"""

 我们手动的按照对方发送时的规则来进行拆包
))
data_2 = client.recv(6)
))
data_3 = client.recv(9"))

"""

"0.0.0.0 放在远程填入0.0.0.0 放在本地测试填入127.0.0.1
server.listen(5 因为两个结果只有一个有信息，所以我们只拿到有结果的那个
            msg_length = len(cmd_res)   本次数据的长度
            conn.send(str(msg_length).encode( 先将要发的整体内容长度发送过去
            if conn.recv(1024) == bready":   如果接收方回应了ready则开始发送真正的数据体
                conn.send(cmd_res)

         由于client端链接异常，故关闭链接循环

))

    msg_length = int(client.recv(1024).decode( 接收到此次发送内容的整体长度
    recv_length = 0   代表已接收的内容长度
    cmd_res = b""

    client.send(b")   发送给Server端，代表自己已经接收到此次内容长度，可以发送真正的数据啦

    while recv_length < msg_length:
        cmd_res += client.recv(1024)   本次接收1024字节数据,可能是一小节数据
        recv_length += len(cmd_res)   添加上本次读取的长度，当全部读取完后应该 recv_length == msg_length

    else
client.close()

>>>  struct
>>> b1 = struct.pack(i 尝试将 int类型的12进行序列化，得到一个4字节的对象
>>> b1
b'x0cx00x00x00'
>>> struct.unpack( 尝试将12的序列化对象字节进行反解，得出元组，第1位就是需要的数据。
(12,)
>>>

 json
 struct
 因为两个结果只有一个有信息，所以我们只拿到有结果的那个

             解决粘包：构建字典,包含数据主体长度,这个就相当于其头部信息
            head_msg = {
                msg_length": len(cmd_res), 包含数据主体部分的长度
                 如果是文件，还可以添加file_name，file_size等属性。
            }

             序列化成json格式，并且统计其头部的长度
            head_data = json.dumps(head_msg).encode()
            head_length = struct.pack( 得到4字节的头部信息，里面包含头部的长度

             发送头部长度信息，头部数据，与真实数据部分
            conn.send(head_length + head_data + cmd_res)

         由于client端链接异常，故关闭链接循环

 发送终端命令

     解决粘包
    head_length = struct.unpack( 接收到头部的长度信息
    head_data = json.loads(client.recv(head_length))   接收到真实的头部信息

    msg_length = head_data["]   获取到数据主体的长度信息
    recv_length = 0  ""

     开始获取真正的数据主体信息
    

client.close()

def iter(source,sentinel=None):   known special case of iter
    
    iter(iterable) -> iterator
    iter(callable,sentinel) -> iterator

    Get an iterator from an object.  In the first form,the argument must
    supply its own iterator,or be a sequence.
    In the second form,the callable is called until it returns the sentinel.
    """
    pass

li = [1,2,3,4]

def my_iter():
    return li.pop()

res = iter(my_iter,2)   代表这个迭代器没__next__一下就会执行my_iter函数，并且该函数返回值如果是2则终止迭代
print(res.__next__())   4
 3
 StopIteration

from functools import partial   导入偏函数

 add(x,y):
    return x + y

func = partial(add,1)   设置辨寒暑绑定的第一个参数的值
print(func(1))   2
print(func(5))   6

 导入偏函数

li = [b"",12345 模拟内核缓冲区

 test(buffer_size):
    if buffer_size:   模拟recv的数据大小
         li.pop()
    buffer_size必须为一个int类型的值)

res = "".join(iter(partial(test,1024),b))
print(res)   54321

 join()方法会不断的调用iter()下的__next__，每调用一次就执行一次偏函数。知道出现b""停止

import *
 struct
ip_port=(',8080)
back_log=5
buffer_size=1024

tcp_server=socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)

while True:
    conn,addr=tcp_server.accept()
    新的Client链接' True:
        收
        try:
            cmd=conn.recv(buffer_size)
            not cmd:break
            收到Client的命令执行命令，得到命令的运行结果cmd_res
            res=subprocess.Popen(cmd.decode('),shell=subprocess.PIPE)
            err=res.stderr.read()
            if err:
                cmd_res=err
            :
                cmd_res=res.stdout.read()

            发
             cmd_res:
                cmd_res=执行成功'.encode(gbk)

            length=len(cmd_res)

            data_length=struct.pack( Exception as e:
            print(e)
            break

import partial   偏函数
ip_port=(

tcp_client= True:
    cmd=input(>>: ':

    tcp_client.send(cmd.encode())


    解决粘包
    length_data=tcp_client.recv(4)
    length=struct.unpack(第一种方法
    recv_size=0
    recv_msg=b''
    while recv_size < length:
        为何recv里是buffer_size，不是length，因为length如果为24G，系统内存没有那么大
        所以每次buffer_size,当recv_size < length时，循环接收，直到recv_size =length，退出循环
        recv_msg += tcp_client.recv(buffer_size)
        recv_size=len(recv_msg) 1024

    第二种方法 失败版本，会引发recv()的阻塞，而不会终止迭代。因为join()方法会不断的调用其iter()方法产生的迭代器，也就是调用其__next__方法，所以第二次没消息的recv()会阻塞住。
    recv_msg=''.join(iter(partial(tcp_client.recv,buffer_size),b''))
    命令的执行结果是 ))
tcp_client.close()