import socketserver

import subprocess

class Myserver(socketserver.BaseRequestHandler):

    def handle(self):

        while True:

            conn=self.request

            conn.sendall(bytes("欢迎登录","utf8"))

            while True:

                client_bytes=conn.recv(1024)

                if not client_bytes:break

                client_str=str(client_bytes,"utf8")

                print(client_str)

                command=client_str

                result_str=subprocess.getoutput(command)

                result_bytes = bytes(result_str,encoding='utf8')

                info_str="info|%d"%len(result_bytes)

                conn.sendall(bytes(info_str,"utf8"))

                # conn.recv(1024)

                conn.sendall(result_bytes)

            conn.close()

if __name__=="__main__":

    server=socketserver.ThreadingTCPServer(("127.0.0.1",9998),Myserver)

    server.serve_forever()

#####################################client

import socket

ip_port=("127.0.0.1",9998)

sk=socket.socket()

sk.connect(ip_port)

print("客户端启动...")

print(str(sk.recv(1024),"utf8"))

while True:

    inp=input("please input:").strip()

    sk.sendall(bytes(inp,"utf8"))

    basic_info_bytes=sk.recv(1024)

    print(str(basic_info_bytes,"utf8"))

    # sk.send(bytes('ok','utf8'))

    result_length=int(str(basic_info_bytes,"utf8").split("|")[1])

    print(result_length)

    has_received=0

    content_bytes=bytes()

    while has_received<result_length:

        fetch_bytes=sk.recv(1024)

        has_received+=len(fetch_bytes)

        content_bytes+=fetch_bytes

    cmd_result=str(content_bytes,"utf8")

    print(cmd_result)

sk.close()

import socket,os

ip_port=("127.0.0.1",8898)

sk=socket.socket()

sk.bind(ip_port)

sk.listen(5)

BASE_DIR=os.path.dirname(os.path.abspath(__file__))

while True:

    print("waiting connect")

    conn,addr=sk.accept()

    flag = True

    while flag:

            client_bytes=conn.recv(1024)

            client_str=str(client_bytes,"utf8")

            func,file_byte_size,filename=client_str.split("|",2)

            path=os.path.join(BASE_DIR,'yuan',filename)

            has_received=0

            file_byte_size=int(file_byte_size)

            f=open(path,"wb")

            while has_received<file_byte_size:

                data=conn.recv(1024)

                f.write(data)

                has_received+=len(data)

            print("ending")

            f.close()

#----------------------------------------------client

#----------------------------------------------

import socket

import re,os,sys

ip_port=("127.0.0.1",8898)

sk=socket.socket()

sk.connect(ip_port)

BASE_DIR=os.path.dirname(os.path.abspath(__file__))

print("客户端启动....")

while True:

    inp=input("please input:")

    if inp.startswith("post"):

        method,local_path=inp.split("|",1)

        local_path=os.path.join(BASE_DIR,local_path)

        file_byte_size=os.stat(local_path).st_size

        file_name=os.path.basename(local_path)

        post_info="post|%s|%s"%(file_byte_size,file_name)

        sk.sendall(bytes(post_info,"utf8"))

        has_sent=0

        file_obj=open(local_path,"rb")

        while has_sent<file_byte_size:

            data=file_obj.read(1024)

            sk.sendall(data)

            has_sent+=len(data)

        file_obj.close()

        print("上传成功")

class BaseServer:

    """Base class for server classes.

    Methods for the caller:

    - __init__(server_address, RequestHandlerClass)

    - serve_forever(poll_interval=0.5)

    - shutdown()

    - handle_request()  # if you do not use serve_forever()

    - fileno() -> int   # for select()

    Methods that may be overridden:

    - server_bind()

    - server_activate()

    - get_request() -> request, client_address

    - handle_timeout()

    - verify_request(request, client_address)

    - server_close()

    - process_request(request, client_address)

    - shutdown_request(request)

    - close_request(request)

    - service_actions()

    - handle_error()

    Methods for derived classes:

    - finish_request(request, client_address)

    Class variables that may be overridden by derived classes or

    instances:

    - timeout

    - address_family

    - socket_type

    - allow_reuse_address

    Instance variables:

    - RequestHandlerClass

    - socket

    """

    timeout = None

    def __init__(self, server_address, RequestHandlerClass):

        """Constructor.  May be extended, do not override."""

        self.server_address = server_address

        self.RequestHandlerClass = RequestHandlerClass

        self.__is_shut_down = threading.Event()

        self.__shutdown_request = False

    def server_activate(self):

        """Called by constructor to activate the server.

        May be overridden.

        """

        pass

    def serve_forever(self, poll_interval=0.5):

        """Handle one request at a time until shutdown.

        Polls for shutdown every poll_interval seconds. Ignores

        self.timeout. If you need to do periodic tasks, do them in

        another thread.

        """

        self.__is_shut_down.clear()

        try:

            while not self.__shutdown_request:

                # XXX: Consider using another file descriptor or

                # connecting to the socket to wake this up instead of

                # polling. Polling reduces our responsiveness to a

                # shutdown request and wastes cpu at all other times.

                r, w, e = _eintr_retry(select.select, [self], [], [],

                                       poll_interval)

                if self in r:

                    self._handle_request_noblock()

                self.service_actions()

        finally:

            self.__shutdown_request = False

            self.__is_shut_down.set()

    def shutdown(self):

        """Stops the serve_forever loop.

        Blocks until the loop has finished. This must be called while

        serve_forever() is running in another thread, or it will

        deadlock.

        """

        self.__shutdown_request = True

        self.__is_shut_down.wait()

    def service_actions(self):

        """Called by the serve_forever() loop.

        May be overridden by a subclass / Mixin to implement any code that

        needs to be run during the loop.

        """

        pass

    # The distinction between handling, getting, processing and

    # finishing a request is fairly arbitrary.  Remember:

    #

    # - handle_request() is the top-level call.  It calls

    #   select, get_request(), verify_request() and process_request()

    # - get_request() is different for stream or datagram sockets

    # - process_request() is the place that may fork a new process

    #   or create a new thread to finish the request

    # - finish_request() instantiates the request handler class;

    #   this constructor will handle the request all by itself

    def handle_request(self):

        """Handle one request, possibly blocking.

        Respects self.timeout.

        """

        # Support people who used socket.settimeout() to escape

        # handle_request before self.timeout was available.

        timeout = self.socket.gettimeout()

        if timeout is None:

            timeout = self.timeout

        elif self.timeout is not None:

            timeout = min(timeout, self.timeout)

        fd_sets = _eintr_retry(select.select, [self], [], [], timeout)

        if not fd_sets[0]:

            self.handle_timeout()

            return

        self._handle_request_noblock()

    def _handle_request_noblock(self):

        """Handle one request, without blocking.

        I assume that select.select has returned that the socket is

        readable before this function was called, so there should be

        no risk of blocking in get_request().

        """

        try:

            request, client_address = self.get_request()

        except OSError:

            return

        if self.verify_request(request, client_address):

            try:

                self.process_request(request, client_address)

            except:

                self.handle_error(request, client_address)

                self.shutdown_request(request)

    def handle_timeout(self):

        """Called if no new request arrives within self.timeout.

        Overridden by ForkingMixIn.

        """

        pass

    def verify_request(self, request, client_address):

        """Verify the request.  May be overridden.

        Return True if we should proceed with this request.

        """

        return True

    def process_request(self, request, client_address):

        """Call finish_request.

        Overridden by ForkingMixIn and ThreadingMixIn.

        """

        self.finish_request(request, client_address)

        self.shutdown_request(request)

    def server_close(self):

        """Called to clean-up the server.

        May be overridden.

        """

        pass

    def finish_request(self, request, client_address):

        """Finish one request by instantiating RequestHandlerClass."""

        self.RequestHandlerClass(request, client_address, self)

    def shutdown_request(self, request):

        """Called to shutdown and close an individual request."""

        self.close_request(request)

    def close_request(self, request):

        """Called to clean up an individual request."""

        pass

    def handle_error(self, request, client_address):

        """Handle an error gracefully.  May be overridden.

        The default is to print a traceback and continue.

        """

        print('-'*40)

        print('Exception happened during processing of request from', end=' ')

        print(client_address)

        import traceback

        traceback.print_exc() # XXX But this goes to stderr!

        print('-'*40)

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

import socketserver

class MyTCPHandler(socketserver.BaseRequestHandler):

    """

    The request handler class for our server.

    It is instantiated once per connection to the server, and must

    override the handle() method to implement communication to the

    client.

    """

    def handle(self):

        # self.request is the TCP socket connected to the client

        self.data = self.request.recv(1024).strip()

        print("{} wrote:".format(self.client_address[0]))

        print(self.data)

        # just send back the same data, but upper-cased

        self.request.sendall(self.data.upper())

if __name__ == "__main__":

    HOST, PORT = "localhost", 9999

    # Create the server, binding to localhost on port 9999

    server = socketserver.TCPServer((HOST, PORT), MyTCPHandler)

    # Activate the server; this will keep running until you

    # interrupt the program with Ctrl-C

    server.serve_forever()