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()
if len(sys.argv) != 4:
host = raw_input('Enter game server host IP/name: ')
port = int(raw_input('Enter host port: '))
pw = raw_input('Enter password: '******'start client')
try:
while working and (hfclient.connected or not hfclient.authed):
#print("\t%s" % (time.time() - hfclient.last_pong_time))
if time.time() - hfclient.last_pong_time > 6 and hfclient.last_ping_time < hfclient.last_pong_time:
hfclient.ping()
asyncore.loop(timeout=3, count=1)
except EOFError, KeyboardInterrupt:
hfclient.close()
print('end client')
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')
# host = sys.argv[1]
# port = int(sys.argv[2])
# user = sys.argv[3]
# pw = sys.argv[4]
host = '127.0.0.1'
port = 14507
user = '******'
pw = 'pass'
def packetListener(packet):
print(">>> received : %s" % packet)
frontline_client = FrontlineClient(fakeConsole, host, port, user, pw, keepalive=True)
frontline_client.add_listener(packetListener)
working = True
def run_hf_client(frontline_client):
print('start client')
try:
while working and (frontline_client.connected or not frontline_client.authed):
asyncore.loop(timeout=3, count=1)
except EOFError, KeyboardInterrupt:
frontline_client.close()
print('end client')
thread.start_new_thread(run_hf_client, (frontline_client,))
time.sleep(3)
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)
def client_handler(client, exit_flag):
connection_thread = threading.Thread(target=try_connect, args=(client,"ubuntu",50007,))
connection_thread.start()
connection_thread.join()
interface_thread = threading.Thread(target=input_listener, args=(client,exit_flag))
server_thread = threading.Thread(target=server_listener, args=(client,exit_flag))
interface_thread.start()
if client.is_alive() and not exit_flag.checkout():
server_thread.start()
server_thread.join()
interface_thread.join()
if __name__ == "__main__":
client = Client()
exit_flag = Exit_flag()
client_handler(client, exit_flag)
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 sys, logging
from protocol import Client, CommandError
logging.basicConfig(level=logging.WARNING,
format='%(asctime)s [%(levelname)s] %(message)s')
client = Client()
print("Start miniredis client.")
print(client.info)
print(
"""Available commands:[GET],[SET],[DELETE],[FLUSH],[MGET],[MSET],[LPUSH],[RPUSH],[LPOP],[RPOP],[BLPOP],[BRPOP],[LLEN]
[EXPIRE],[TTL],[PERSIST]
([MULTI],[EXEC] to be complete)
[INFO],[QUIT],[EXIT]""")
while True:
command = input(">")
segments = command.split(" ")
segments[0] = segments[0].upper()
if segments[0] == "QUIT" or segments[0] == "EXIT":
break
arguments = tuple(segments)
try:
received = client.execute(*arguments)
if isinstance(received, bytes):
filename = "_".join(segments) + ".bin"
with open(filename, mode='wb') as file: # b is important -> binary
"""
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()
