Windows Server间的通信: 基于Python-Socket编程的实现

import argparse


def run(task_id):
    msg = f"you have successfully run task {task_id}"
    print("print: ", msg)
    return msg


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--task_id", type=int, dest="task")
    a = parser.parse_args()
    if a.task is None:
        print("No arg")
    else:
        print(f"called from server {run(task_id=a.task)}")

import socket
import subprocess
from time import ctime
BUF_SIZE = 1024
class SocketServer:
    def __init__(self, host='127.0.0.1', port=12138):
        self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # 为服务绑定主机地址和端口号
        self.server.bind((host, port))
        self.server.listen(1)

    def run(self):
        while True:
            try:
                print("server listening...")
                # 等待客户端连接（阻塞，直到收到客户端的连接请求）
                client_socket, address = self.server.accept()
                print(f"connected from {address}...")

                command = client_socket.recv(BUF_SIZE).decode()
                # refer to https://docs.python.org/3/library/subprocess.html#subprocess.check_output
                result = subprocess.check_output(command, shell=True)
                print(result)
                # socket.sendall的参数是byte对象，需要将字符串通过encode方法转成byte对象
                client_socket.sendall(f"[{ctime()}]-{result.decode()}".encode())
                client_socket.close()
            except subprocess.CalledProcessError as e:
                # raise RuntimeError("command '{}' return with error (code {}): {}".format(e.cmd, e.returncode, e.output))
                print("command '{}' return with error (code {}): {}".format(e.cmd, e.returncode, e.output))

if __name__ == "__main__":
    server = SocketServer()
    server.run()

import socket

def send_command(command:str) -> str:
    host = '127.0.0.1'
    port = 12138
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client_socket.connect_ex((host, port))
    client_socket.sendall(command.encode())
    print(client_socket.family, client_socket.type, client_socket.proto)
    result = client_socket.recv(1024)
    return result.decode()

if __name__ == "__main__":
    print(send_command("python --version"))
    print(send_command("python ..\exec\\task.py --task_id 1"))
    print(send_command("python ..\exec\\task.py --task_id 10"))

from socket import *
from time import ctime
ADDR = "::1"
PORT = 12135
BUFSIZE = 1024


class UDPServer:
    """UDP服务器"""
    def __init__(self, host, port):
        self.udp_socket = socket(family=AF_INET6, type=SOCK_DGRAM, proto=0)
        self.udp_socket.bind((host, port))

    def run(self):
        try:
            while True:
                print("Server is waiting data...")
                data, addr = self.udp_socket.recvfrom(BUFSIZE)
                self.udp_socket.sendto(("[%s] %s}"%(ctime(), data.decode("utf-8"))).encode(), addr)
                print(f"received {data.decode('utf-8')} from and returned to: {addr}")
        except Exception as e:
            print(repr(e))
        finally:
            self.udp_socket.close()

if __name__ == "__main__":
    UDPServer(host=ADDR, port=PORT).run()

from socket import *
HOST = "::1"
PORT = 12135
BUFSIZE = 1024


if __name__ == "__main__":
    udp_client = socket(AF_INET6, SOCK_DGRAM)
    try:
        while True:
            data = input(">")
            if not data:
                break
            udp_client.sendto(data.encode(), (HOST, PORT))
            data, addr = udp_client.recvfrom(BUFSIZE)
            if not data:
                break
            print(data.decode('utf-8'))
    finally:
        udp_client.close()

# tcp_server.py

"""
使用socket高级模块socketserver
"""
from socketserver import (TCPServer as TCP,
                          StreamRequestHandler as SRH
                          )
from time import ctime

HOST = "127.0.0.1"
# HOST = "::1"

PORT = 12138
ADDR = (HOST, PORT)


class MyRequestHandler(SRH):
    def handle(self) -> None:
        """
        当接收到来自客户端的消息，就会调用handle方法
        :return:
        """
        print(f"connected from: {self.client_address}")
        self.wfile.write(('[%s] %s' % (ctime(), self.rfile.readline().decode())).encode())


if __name__ == "__main__":
    # 基于给定的主机信息和请求处理类创建TCP服务器
    tcp_server = TCP(server_address=ADDR, RequestHandlerClass=MyRequestHandler)
    print("waiting for connection...")
    tcp_server.serve_forever()

# tcp_client.py
import socket
HOST = "127.0.0.1"
PORT = 12138
ADDR = (HOST, PORT)


if __name__ == "__main__":


    while True:
        client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        client_socket.connect(ADDR)
        data = input(">")
        if not data:
            break
        # \r\n是行终止符，由于处理程序类对待套接字通信像对待文件一样所以需要行终止符才能让服务器完成数据读取
        client_socket.send(("%s\r\n"%data).encode())

        # client_socket.send(("%s\r\n"%data).encode())
        result = client_socket.recv(1024)
        print(result.strip())
        client_socket.close()

# ssl_server.py
import ssl
import socket

# 服务器地址、端口以及协议类型配置
server_address = ('localhost', 12138)
ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
ssl_context.load_cert_chain(certfile='server.crt', keyfile='server.key')

# 创建并配置套接字
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(server_address)
server_socket.listen(1)

# 循环等待连接请求并处理
while True:
    client_socket, client_address = server_socket.accept()
    ssl_socket = ssl_context.wrap_socket(client_socket, server_side=True)
    print(f'Got connection from {client_address}')
    received_data = ssl_socket.recv(1024)
    if received_data:
        received_message = received_data.decode()
        print(f"Received message: {received_message}")
        response_message = f"Received message: {received_message}"
        ssl_socket.sendall(response_message.encode())
    ssl_socket.close()

import ssl
import socket

client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ssl_socket = ssl.wrap_socket(client_socket, ssl_version=ssl.PROTOCOL_TLSv1, ciphers="HIGH")
ssl_socket.connect(("127.0.0.1", 12138))
message = "This is a message encrypted by SSL"
ssl_socket.send(message.encode())
response = ssl_socket.recv(1024)
print(response)