Using an objects methods from client-side through Python Sockets

Question

My goal basically is to have this 'memcached' object i've created, which is basically a dictionary with a set of commands that resemble the memchached system, and operate them from a client perspective and actually make some changes to the 'memcached dictionary object'.

First of all, i decided to make a memcached.py script that's basically a Memcached class with some of the commands of the real Memcached system, but as methods.

'''Class built with the intention of simulating a real Memcached system'''

class Memcached:

def __init__(self):
    self.storage = {}

"""Storage Commands"""    
def set(self, key, value):
    self.storage[key] = value
    print("STORED")

def add(self,key,value):
    if key in self.storage:
        print("ERROR")
    else:
        self.storage[key] = value
        print("STORED")

"""Retrieval Commands"""
def get(self, key):
    response = print(f'VALUE {key} \n {self.storage[key]} \n END')
    return response

This works from the terminal obviously, so this is the farthest i would go as of complexity of the Memcached system(i will add some other functionalities/commands when i resolve the bigger problem)

The bigger problem:

What i'm trying to do now is actually send and receive this memcached object through a localhost socket, so(for example) the client can store and retrieve information from this memcached object that i've created.

These are basically the scripts i have made:

server.py

import socket
import json
import memcached

cache = memcached.Memcached()

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('localhost', 12345))
s.listen(1)
print('Socket is listening...')
conn, addr = s.accept()
b = b''

with conn:
    while True:
        data = conn.recv(1024)
        b += data
        if not data:
            break

d = json.loads(b.decode('utf-8'))

args = d.split(' ')

if args[0] == 'set':
    cache.set(args[1], args[2])
elif args[0] == 'add':
    cache.add(args[1], args[2])
elif args[0] == 'get':
    cache.get(args[1], args[2])
else:
    print('ERROR')    

#control print
print(d)

client.py

import socket
import json

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('localhost', 12345))

class Client:

    def __init__(self):
       self.host = 'localhost'
        self.port = 12345
 
    def command(self, command, key, value):
        cmd = command  + ' ' +  key + ' ' + value
        b = json.dumps(cmd).encode('utf-8')    
        s.sendall(b)


newClient = Client()

while True:
    print('Taking memcached commands...')
    cmd = input()
    if cmd == 'quit':
        break
    else:
        cmdList = cmd.split()
        newClient.command(cmdList[0], cmdList[1], cmdList[2])

EDITED: Updated the scripts with the logic that lets me accede memcached methods from the client side. However now i'm not able to send different commands from the same connection. Is threading neccesary or a simple change in the logic could solve this? For example, in the current state i'm in, i can't use the 'get' command since the dictionary is basically rebuilt after the client script ends.

Answer 1

You have to run code in while True: to repeat it for next command.

And if you want to connect many times then you have to run it in another while True.

I don't have memcache so I created own class with set, add, get to simulate it.

I use '\n' to recognize end of command.

I don't use JSON and split but shlex.split to correctly split set X "hello world" into ['set', 'X', 'hello world']

server.py

import socket
import shlex
#import memcached

# --- classes ---

class MyMemcached():

    def __init__(self):

        self.data = dict()
        
    def set(self, key, val):
        print('[MyClass]: set', key, val)
        self.data[key] = val

    def add(self, key, val):
        print('[MyClass]: add', key, val)
        if key not in self.data:
           self.data[key] = ""
        self.data[key] += val
    
    def get(self, key):
        val = self.data.get(key)
        print('[MyClass]: get', key, val)
        return val

# --- main ---

#cache = memcached.Memcached()
cache = MyMemcached()

s = socket.socket()  # default values are `socket.AF_INET, socket.SOCK_STREAM`

s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  # solution for: `OSError: [Errno 98] Address already in use` when socket already closed

print('Bind: 0.0.0.0:12345')
s.bind(('0.0.0.0', 12345))

print('Listen: 1')
s.listen(1)  # how many clients can wait for connection

try:
    while True:  # repeat for next connection
        print('Waiting for client...')
        conn, addr = s.accept()

        print('Connected:', addr)#, conn)

        with conn:
            while True: # repeat for next command

                cmd = b''
                
                # get one command
                while True:
                    data = conn.recv(1)  # read single char until you get `\n'
                    # read until `\n'`
                    if not data or data == b'\n':
                        break

                    cmd += data
                     
                cmd = cmd.decode('utf-8')   
                
                #control print
                print('cmd:', cmd)
                        
                if cmd.lower() == 'quit':
                    break
                                           
                #args = cmd.split(' ') # it split INCORRECTLY `set a "hello world"`
                args = shlex.split(cmd)  # it split correctly `set a "hello world"`
                print('args:', args)

                if args[0] == 'set':
                    cache.set(args[1], args[2])
                elif args[0] == 'add':
                    cache.add(args[1], args[2])
                elif args[0] == 'get':
                    val = cache.get(args[1])
                    print(val)
                else:
                    print('ERROR: cmd:', cmd) 
                    break
except KeyboardInterrupt:
    print('Pressed Ctrl+C')            
finally:            
    s.close()

client.py

import socket

# --- classes ---

class Client:

    def __init__(self, host='0.0.0.0', port=8000):
        self.host = host
        self.port = port
        self.socket = socket.socket()  # default values are `socket.AF_INET, socket.SOCK_STREAM`
        self.socket.connect((self.host, self.port))
 
    def command(self, cmd):
        print('send:', cmd)
        cmd = cmd.encode('utf-8') + b'\n'    
        self.socket.sendall(cmd)

    def run(self):
        while True:
            cmd = input('cmd: ')
            self.command(cmd)

            if cmd.lower() == 'quit':
                break
    
# --- functions ---

# ... empty ...

# --- main ---

#client = Client('localhost', 12345)
client = Client(port=12345)
client.run()