def exec_client_disconnect(key=None, value=None, client=None, exit_flag = None):
output = "disconnecting..."
client.disconnect()
print(output)
status_code = "002"
status_message = Client().get_status_by_code(status_code)["message"]
print(status_message)
def response_handler(response):
status_message = "response not handled yet"
extra_info = None
if response not in ["", None]:
(line,parameters,content) = break_down_message(response)
status_code = line.split(" ")[0]
if status_code in ["003"]:
extra_info = "key: "+"".join(parameters.split(":")[1:])
elif status_code == "000":
extra_info = content
if "key" in parameters:
extra_info = "".join(parameters.split(":")[1:])
status_message = Client().get_status_by_code(status_code)["message"]
print(status_message)
if extra_info != None:
print(extra_info)
def try_connect(client, ip, port):
seconds = 0
status_code = "100"
while seconds < 10 and not client.is_connected():
try:
client.connect(ip, port)
except Exception as e:
print("trying to connect...")
#print(e)
#traceback.print_exc()
time.sleep(1)
seconds += 1
if client.is_connected():
status_code = "001"
status_message = Client().get_status_by_code(status_code)["message"]
console_output = status_message
print(console_output)
from protocol import Client
client = Client(6631)
client.wait_handshake()
while True:
client.receive_message()
import sys
from Crypto.PublicKey import RSA
from protocol import Client
from protocol import Protocol
if __name__ == '__main__':
client = Client('localhost', 10010)
client.connect()
keyFile = open('serverPublicKey.txt', 'r')
serverPublicKey = keyFile.read()
try:
# Create protocol
protocol = Protocol()
# Call client procedure
protocol.clientProcedure(client, RSA.importKey(serverPublicKey))
except Exception as e:
print(e)
client.socket.close()
sys.exit()
client.socket.close()
sys.exit()
"""
Test the server
"""
import os, sys, logging
import pickle
logging.basicConfig(level=logging.INFO,
format='%(asctime)s [%(levelname)s] %(message)s')
sys.path.append('../')
from protocol import Client
client = Client()
logging.info("Start set")
client.set('k0', 'v0')
logging.info("End set. Start get")
x = client.get('k0')
logging.info("End get")
print(f"expecting: v0 recieved:{x}")
client.set('k2', -0.345)
x = client.get('k2') - 1
print(f"expecting: -1.345 recieved:{x}")
x = client.get('k1')
print(f"expecting: None recieved:{x}")
client.mset('k1', 'v1', 'k2', ['v2-0', 1, 'v2-2'], 'k3', 'v3')
client.get('k2')
from protocol import Address, Client
client = Client(6632)
client.handshake(Address('127.0.0.1', 6631))
while True:
message = input(">>> ")
client.send_message(message)
"""
Test the server
"""
import concurrent.futures
import sys, logging
import argparse
import multiprocessing
import time
from protocol import Client, CommandError
globalclient = Client()
class Process(multiprocessing.Process):
def __init__(self):
super(Process, self).__init__()
def run(self):
globalclient.set('foo', 'bar')
if __name__ == "__main__":
logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s')
parser = argparse.ArgumentParser()
parser.add_argument("-t", help="commands to test")
parser.add_argument("-r", help="key space")
parser.add_argument("-n", help='repeat', default=50)
args = parser.parse_args()
def protocol_test():
port = randint(5000, 5099)
print(f"port: {port}")
client = Client(port)
client.wait_handshake()
client.receive_message()
