class ServerManager: def __init__(self): self.socket_server = SocketServer() self.threads = [] self.socket_ip = self.socket_server.get_ip() def create_thread(self, thread_target): print('Create thread') new_thread = threading.Thread(target=thread_target) self.threads.append(new_thread) def setup(self): print('Socket setup') self.socket_server.setup() self.create_thread(self.socket_server.run_listen) self.create_thread(self.socket_server.run_send) self.create_thread(self.socket_server.record_data) print('Set dameon') for thread in self.threads: thread.setDaemon(True) def start(self): for thread in self.threads: print('Start thread') thread.start() def finish(self): self.socket_server.finish() def get_socket_instance(self): return self.socket_server def get_socket_ip(self): return self.socket_ip
def connect_socket(argument): so = SocketServer(argument["ip"], argument["port"]) if so.connect_server() == False: print("Error connexion to server ip:[{0}] port:[{1}]".format( argument["ip"], argument["port"])) exit(1) return so
def __init__(self, gateway_ip): self.Flaged_ip=dict() self.CONFIG = self.get_config() self.REPLICATION_COUNT = self.CONFIG["REPLICATION_COUNT"] self.GATEWAY_IP = gateway_ip self.mnode = SocketServer(gateway_ip) t = threading.Thread(target = self.run_mmnode_thread) t.start()
def __init__(self): self.CONFIG = self.get_config() self.GATEWAY_IPS = self.CONFIG["gateway_ips"] self.GATEWAY_SOCKS = [] self.CONTAINER_IP = self.CONFIG["api_server"] self.APISOCK = SocketServer(self.CONTAINER_IP, 44123) t = threading.Thread(target=self.run_APISOCK_thread) t.start()
def init_socket(): # Socket process parent_pipe, child_pipe = Pipe() # Starts the process proc = SocketServer(port, child_pipe) proc.start() queue = Queue() # Creates a new thread that will be listening the pipe nbpl = NBPL(parent_pipe, queue) nbpl.setDaemon(True) nbpl.start() return parent_pipe, queue
def _queue_linesplit(self): ss = SocketServer(host='localhost', port=8888) ss.create() self.lg.info('8888 Waiting connection...') while True: ss.accept() self.lg.info('Connection Accepted!') self.lg.info('8888 Waiting for stream...') data = ss.recv() while data != '\n': self.tq.put(data) data = ss.recv() self.tq.put(data) ss.close()
def start(self): server = SocketServer() thread = Thread(target=server.run, args=[self.sf2, True]) thread.start() while self.sf0.notComplete() and self.sf1.notComplete(): # camera looking at reflective tape self.sf2.setFrame( viewReflTape(self.sf0.getFrame(), self.sf1.getFrame()))
def _shipper(self, none): ss = SocketServer(host='localhost', port=8887) ss.create() self.lg.info('Waiting sub') while True: ss.accept() while True: data = self.tq.get() try: ss.send(data) except: logging.warning('Connection with 8887 losed') self.tq.put(data) break ss.close()
def scheduler(): """ Start all streams """ print("Flask up and running, now starting data streams...") # Start TCP socket Server SocketServer().start() print("SocketServer Started") ImageServer().start() print("ImageServer Started") # Start HTTP server HTTPserver().start() print("HTTPServer Started")
def run(self, lg): self.lg = lg ss = SocketServer(host='localhost', port=9999) ss.create() self.lg.info('9999 Waiting connection...') while True: ss.accept() while True: with open('res/results.txt', 'a') as outfile: try: data = ss.recv() outfile.write(data) except: logging.warning('Connection with 9999 losed') break ss.close()
class ConnectGateway(object): def __init__(self): self.CONFIG = self.get_config() self.GATEWAY_IPS = self.CONFIG["gateway_ips"] self.GATEWAY_SOCKS = [] self.CONTAINER_IP = self.CONFIG["api_server"] self.APISOCK = SocketServer(self.CONTAINER_IP, 44123) t = threading.Thread(target=self.run_APISOCK_thread) t.start() @staticmethod def get_config(): with open("./config/config.json") as fin: return json.loads(fin.read()) def run_APISOCK_thread(self): self.APISOCK.connection_accept() def get_gateway_ips(self): return self.GATEWAY_IPS def get_sock(self): return self.APISOCK
def main(): if os.path.exists("config.json"): with open("config.json", 'r') as file: configuration = json.load(file) ip = configuration["ip"] port = configuration["port"] motd = configuration["motd"]["1"] + "\n" + configuration["motd"]["2"] version_text = configuration["version_text"] kick_message = "" server_icon = None for message in configuration["kick_message"]: kick_message += message + "\n" kick_message = kick_message[:-2] if not os.path.exists(configuration["server_icon"]): print("Server icon doesn't exists - submitting none...") else: with open(configuration["server_icon"], 'rb') as image: server_icon = "data:image/png;base64," + base64.b64encode( image.read()).decode() try: global server server = SocketServer(ip, port, motd, version_text, kick_message, server_icon) server.start() except KeyboardInterrupt: server.close() exit(1) except Exception as e: print(e) else: configuration = {} configuration["ip"] = "0.0.0.0" configuration["port"] = 25565 configuration["motd"] = {} configuration["motd"]["1"] = "§4Maintenance!" configuration["motd"][ "2"] = "§aCheck example.com for more information!" configuration["version_text"] = "§4Maintenance" configuration["kick_message"] = [ "§bSorry", "", "§aThis server is offline!" ] configuration["server_icon"] = "server_icon.png" configuration["samples"] = ["§bexample.com", "", "§4Maintenance"] with open("config.json", 'w') as file: json.dump(configuration, file, sort_keys=True, indent=4, ensure_ascii=False) print("[!] A new configuration was created!") print("Please check the settings in the config.json!") exit(1)
def run(self): # Get event loop # -------------------- # Get the current event loop. If there is no current event loop set in # the current OS thread and set_event_loop() has not yet been called, # asyncio will create a new event loop and set it as the current one. self.loop = asyncio.get_event_loop() self.context.loop = self.loop self.futures = [] # Register actor instances logger.info('Registering {0} actor instances'.format( len(self.context.config['actors']) )) self.context.actors = list(map( lambda a: a['class'](a, self.context), self.context.config['actors'] )) # Message processor self.futures.append(asyncio.ensure_future(self.events_processor())) try: # Servers self.context.http_server = HttpServer() self.context.socket_server = SocketServer(async_mode='aiohttp') self.context.socket_server.configure(self.context) asyncio.ensure_future( self.context.http_server.configure(self.context), loop=self.loop) # Startup event self.context.queue_event('homeghost', 'startup', payload={}) # Run the event loop logger.info('Running core event loop') self.context.running = True self.loop.run_forever() finally: # Stop event loop self.context.running = False asyncio.wait(self.futures, loop=self.loop) self.loop.close()
def scheduler(): """ Start all streams """ print("Flask up and running, now starting data streams...") # Start TCP socket Server SocketServer().start() ImageServer().start() # Start HTTP server HTTPserver().start() # Can be a smart idea to start streams here! # Start some demo flows demo()
from oled_print import OLEDPrint from wifi import Wifi from socket_server import SocketServer from motor_control import MotorControl from wheel_encoder import WheelEncoder import global_params if __name__ == '__main__': global_params.init() global_params.set_value("motor_control", MotorControl()) global_params.set_value("wheel_encoder", WheelEncoder()) oled = OLEDPrint() wifi = Wifi(output_fun=oled) flag = wifi.do_connect() if flag is False: oled.output("Wifi Error") exit(0) ip = wifi.get_ip() socket_server = SocketServer(ip, output_fun=oled) socket_server.run()
def create_router_instance(self): SocketClient().create_socket_client_instance(self.interfaces) SocketServer().create_socket_server_instance(self.router_name)
isServer.width = 50 isServer.height = 30 isServer.x = 30 isServer.y = 650 isServer.bind(active=on_server_active) layout.add_widget(isServer) global ed ed = TextInput(hint_text='digite a mensagem a ser enviada') ed.size_hint = None, None ed.height = 500 ed.width = 400 ed.y = 100 layout.add_widget(ed) global bt bt = Button(text='send') bt.size_hint = None, None bt.width = 400 bt.height = 60 bt.y = 20 bt.on_press = handleClick layout.add_widget(bt) return layout global socket socket = SocketServer() janela = App() Window.size = 400, 700 janela.build = build janela.run()
def run_inference(args): from modules.inference_engine_pytorch import InferenceEnginePyTorch socket_server = SocketServer(args.port) joint_angle_calculator = JointAngleCalculator() stride = 8 model_path = os.path.join('models', 'human-pose-estimation-3d.pth') net = InferenceEnginePyTorch(model_path, "GPU") canvas_3d = np.zeros((720, 1280, 3), dtype=np.uint8) plotter = Plotter3d(canvas_3d.shape[:2]) canvas_3d_window_name = 'Canvas 3D' cv2.namedWindow(canvas_3d_window_name) cv2.setMouseCallback(canvas_3d_window_name, Plotter3d.mouse_callback) file_path = None if file_path is None: file_path = os.path.join('data', 'extrinsics.json') with open(file_path, 'r') as f: extrinsics = json.load(f) R = np.array(extrinsics['R'], dtype=np.float32) t = np.array(extrinsics['t'], dtype=np.float32) frame_provider = ImageReader(args.images) is_video = False if args.video != '': frame_provider = VideoReader(args.video) is_video = True base_height = args.height_size fx = 1 # focal length delay = 1 esc_code = 27 p_code = 112 space_code = 32 mean_time = 0 for frame in frame_provider: current_time = cv2.getTickCount() if frame is None: break input_scale = base_height / frame.shape[0] scaled_img = cv2.resize(frame, dsize=None, fx=input_scale, fy=input_scale) scaled_img = scaled_img[:, 0:scaled_img.shape[1] - (scaled_img.shape[1] % stride)] # better to pad, but cut out for demo if fx < 0: # Focal length is unknown fx = np.float32(0.8 * frame.shape[1]) inference_result = net.infer(scaled_img) poses_3d, poses_2d = parse_poses(inference_result, input_scale, stride, fx, is_video) edges = [] if len(poses_3d): poses_3d = rotate_poses(poses_3d, R, t) poses_3d_copy = poses_3d.copy() x = poses_3d_copy[:, 0::4] y = poses_3d_copy[:, 1::4] z = poses_3d_copy[:, 2::4] poses_3d[:, 0::4], poses_3d[:, 1::4], poses_3d[:, 2::4] = -z, x, -y poses_3d = poses_3d.reshape(poses_3d.shape[0], 19, -1)[:, :, 0:3] edges = (Plotter3d.SKELETON_EDGES + 19 * np.arange(poses_3d.shape[0]).reshape((-1, 1, 1))).reshape((-1, 2)) plotter.plot(canvas_3d, poses_3d, edges) cv2.imshow(canvas_3d_window_name, canvas_3d) draw_poses(frame, poses_2d) current_time = (cv2.getTickCount() - current_time) / cv2.getTickFrequency() if mean_time == 0: mean_time = current_time else: mean_time = mean_time * 0.95 + current_time * 0.05 cv2.putText(frame, 'FPS: {}'.format(int(1 / mean_time * 10) / 10), (40, 80), cv2.FONT_HERSHEY_COMPLEX, 1, (0, 0, 255)) cv2.imshow('ICV 3D Human Pose Estimation', frame) key = cv2.waitKey(delay) if key == esc_code: break if key == p_code: if delay == 1: delay = 0 else: delay = 1 if delay == 0 or not is_video: # allow to rotate 3D canvas while on pause key = 0 while (key != p_code and key != esc_code and key != space_code): plotter.plot(canvas_3d, poses_3d, edges) cv2.imshow(canvas_3d_window_name, canvas_3d) key = cv2.waitKey(33) if key == esc_code: break else: delay = 1 joint_angles = joint_angle_calculator.calculate_angles(poses_3d) if joint_angles: socket_server.send_data(joint_angles)
for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)] ][0][1]]) if l ][0][0] #--------------------------------------------------------------------------- ###################################### MAIN ########################################### if __name__ == "__main__": # Thread for socket server socket_host = getIpAddress() socket_port = "8889" print "Start MAIN - host: ", socket_host, ", port: ", socket_port socketServer = SocketServer(socket_host, socket_port) socketThread = threading.Thread(target=socketServer.communicate) socketThread.setDaemon(True) socketThread.start() print "SocketServer is running" # Streaming thread GObject.threads_init() Gst.init(None) server = GstServer() loop = GObject.MainLoop() loop.run() # End
from socket_server import SocketServer s = SocketServer('', 7000) s.start()
def main(): logger = logging.getLogger("FakeMCServer") if not os.path.exists("logs"): os.makedirs("logs") logger.setLevel(logging.INFO) console_handler = logging.StreamHandler() console_handler.setLevel(logging.INFO) file_handler = logging.FileHandler("logs/access.log") file_handler.setLevel(logging.INFO) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') file_handler.setFormatter(formatter) console_handler.setFormatter(formatter) logger.addHandler(console_handler) logger.addHandler(file_handler) if os.path.exists("config.json"): logger.info("Loading configuration...") with open("config.json", 'r') as file: configuration = json.load(file) ip = configuration["ip"] port = configuration["port"] motd = configuration["motd"]["1"] + "\n" + configuration["motd"]["2"] version_text = configuration["version_text"] kick_message = "" samples = configuration["samples"] try: show_hostname = configuration["show_hostname_if_available"] except KeyError: configuration["show_hostname_if_available"] = True show_hostname = True with open("config.json", 'w') as file: json.dump(configuration, file, sort_keys=True, indent=4, ensure_ascii=False) player_max = configuration.get("player_max", 0) player_online = configuration.get("player_online", 0) protocol = configuration.get("protocol", 2) server_icon = None for message in configuration["kick_message"]: kick_message += message + "\n" if not os.path.exists(configuration["server_icon"]): logger.warning("Server icon doesn't exists - submitting none...") else: with open(configuration["server_icon"], 'rb') as image: server_icon = "data:image/png;base64," + base64.b64encode( image.read()).decode() try: global server logger.info("Setting up server...") server = SocketServer(ip, port, motd, version_text, kick_message, samples, server_icon, logger, show_hostname, player_max, player_online, protocol) server.start() except KeyboardInterrupt: logger.info("Shutting down server...") server.close() logger.info("Done. Thanks for using FakeMCServer!") exit(0) except Exception as e: logger.exception(e) else: logger.warning("No configuration file found. Creating config.json...") configuration = {} configuration["ip"] = "0.0.0.0" configuration["port"] = 25565 configuration["protocol"] = 2 configuration["motd"] = {} configuration["motd"]["1"] = "§4Maintenance!" configuration["motd"][ "2"] = "§aCheck example.com for more information!" configuration["version_text"] = "§4Maintenance" configuration["kick_message"] = [ "§bSorry", "", "§aThis server is offline!" ] configuration["server_icon"] = "server_icon.png" configuration["samples"] = ["§bexample.com", "", "§4Maintenance"] configuration["show_ip_if_hostname_available"] = True configuration["player_max"] = 0 configuration["player_online"] = 0 with open("config.json", 'w') as file: json.dump(configuration, file, sort_keys=True, indent=4, ensure_ascii=False) logger.info("Please adjust the settings in the config.json!") exit(1)
def run_websocket_svr(): socket_svr = SocketServer() socket_svr.start()
def connect_socket(argument): so = SocketServer(argument["ip"], argument["port"]) if so.connect_server() == False: print ("Error connexion to server ip:[{0}] port:[{1}]".format(argument["ip"], argument["port"])) exit(1) return so
async def init_server(): server = SocketServer(int(os.getenv("TELEGRAM_PORT")), on_response_message) await server.create()
from myutils import * from machine import reset from socket_server import SocketServer from ubinascii import a2b_base64 l = Logger() l.info('Started main.py') wifi_connect() wifi = network.WLAN(network.STA_IF) ap = network.WLAN(network.AP_IF) ss = SocketServer('10.0.0.32', 8888)
None Returns: None """ from urllib.request import urlopen import json byte_str = urlopen('https://www.howsmyssl.com/a/check').read() data = json.loads(byte_str.decode('utf-8')) tls_version = data['tls_version'] print('>>>Support TSL version {}'.format(tls_version)) print('>>>SSL library version {}'.format(ssl.OPENSSL_VERSION)) print('>>>SSL API version {}'.format(ssl._OPENSSL_API_VERSION)) if __name__ == "__main__": try: check_ssl() except Exception as ex: print(ex) server = SocketServer(is_debug=True, is_flushing=True) while True: if len(server.queuing_clients) > 0: print("Start recording ...") server.record() break # # server.start() # time.sleep(5.0) # server.record()
def __init__(self): self.socket_server = SocketServer() self.threads = [] self.socket_ip = self.socket_server.get_ip()
class Gateway(): def __init__(self, gateway_ip): self.Flaged_ip=dict() self.CONFIG = self.get_config() self.REPLICATION_COUNT = self.CONFIG["REPLICATION_COUNT"] self.GATEWAY_IP = gateway_ip self.mnode = SocketServer(gateway_ip) t = threading.Thread(target = self.run_mmnode_thread) t.start() def run_mmnode_thread(self): self.mnode.connection_accept() @staticmethod def get_config(): with open("./config/config.json") as fin: return json.loads(fin.read()) def get_crush(self): with open("./config/crushmap.json") as fin: return json.loads(fin.read()) @staticmethod def create_hash(user_id:str, pid:str): m = hashlib.sha1() m.update(user_id.encode()) m.update(pid.encode()) digest = m.hexdigest() digest_int = int(digest, 16) % 10**8 # decoded = binascii.unhexlify(str(encoded).encode()).decode() return digest_int def run_crush(self, user_id:str, pid:str, rcount:int): val = self.create_hash(user_id, pid) proc = subprocess.Popen(['python2', 'crush_runner.py', str(val), str(rcount)], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE, ) stdout_value = proc.communicate() print(stdout_value) device_ids = stdout_value[0].decode() device_ids = [str(devid).strip() for devid in device_ids.split("\n") if len(devid) > 0] print(device_ids, "in running crush") return device_ids def update_crush(self, critera): print("Update crush", critera) crush_map = self.get_crush() did = int(critera["DEVICE"].strip("_")[-1]) if critera["OP"] == "ADD": crush_map["trees"][0]["children"].insert(did-1, { "type": "host", "name": "host{}".format(did-1), "id": -1*did, "children": [ { "id": did, "name": critera["DEVICE"], "weight": 65536 } ] }) elif critera["OP"] == "REMOVE": del crush_map["trees"][0]["children"][did-1] fout = open("config/crushmap.json", "w") json.dump(crush_map, fout) fout.close() def insert(self, data:dict): kmaster = kazooMaster( self.GATEWAY_IP, "p", "", data["USERID"], data["PRODUCTID"], data["OPERATION"] ) for dname,val in self.Flaged_ip.items(): path = "/ephemeral_" + dname if kmaster.exist(path) and val == -1: self.update_crush({"OP": "ADD","DEVICE": dname}) #UP Update update crush #old MAX_loop_checker = 5 while MAX_loop_checker > 0: MAX_loop_checker -= 1 down_devices = False device_ids = list(self.run_crush(data["USERID"], data["PRODUCTID"], self.REPLICATION_COUNT)) device_ip_map = {} for node in self.CONFIG["nodes"]: if node["device_id"] in device_ids: device_ip_map[node["device_id"]] = node["ip"] print(self.Flaged_ip, ":flagged ips") kmaster.start_client() for did, ip in device_ip_map.items(): path = "/ephemeral_" + did if kmaster.exist(path): if did in self.Flaged_ip.keys() and self.Flaged_ip[did] == -1: self.read_repair({"NODES":device_ids}) self.Flaged_ip[did]=0 del self.Flaged_ip[did] else: self.update_crush({"OP": "REMOVE","DEVICE": did}) self.Flaged_ip[did]=-1 down_devices = True if not down_devices: break for did, ip in device_ip_map.items(): path = "/ephemeral_" + did if kmaster.exist(path): self.mnode.send_command(device_ip_map[did], data) kmaster.stop_client() return True def read_repair(self,info:dict): print("In read repair", info) """ dict={"NODES":[node1,node2,node3]} """ kmaster = kazooMaster( self.GATEWAY_IP,"p","","","","",False ) kmaster.start_client() all_user = set() flag = False down_node = [] for nodes in info["NODES"]: path = "/" + nodes print(path, "in read_repar") all_child = [] all_child = kmaster.get_children(path) print(all_child) if all_child == "": print("Node does not exists") kmaster.create(path) flag = True down_node.append(nodes) else: for child in all_child: all_user.add(child) for child in all_user: self.list_all({"USERID":child}, flag, down_node) kmaster.stop_client() def get_device_ip_map(self): device_ip_map = {} for node in self.CONFIG["nodes"]: device_ip_map[node["device_id"]] = node["ip"] return device_ip_map def list_all(self,info:dict, flag = False, down_nodes = None): """ dict={ "userid":username } """ print("list_all", info, flag, down_nodes) kmaster = kazooMaster( self.GATEWAY_IP,"p","",info["USERID"],"","",False ) kmaster.start_client() to_return = kmaster.getmap() if len(to_return) == 0: return [] self.mnode latest=dict() key="" maxVersion_replace = [] device_ip_map = self.get_device_ip_map() for i in range(len(to_return)): tkey = to_return[i]["key"] tdevice = to_return[i]["device"] tversion = to_return[i]["version"] if key != tkey: key = tkey all_dev=[] all_dev.append((tdevice,tversion)) latest[key]=all_dev else: all_dev.append((tdevice,tversion)) latest[key]=all_dev # print(latest[key]) maxData = None maxProductid = None for keys in latest: max_version=-1 List = latest[keys] #print(keys,List) for i in range(len(List)): x,y = List[i] # print("FOR PID: ",keys," DEVICE: ",x," VERSION: ",y) if max_version < int(y): max_version = int(y) maxDevice = x maxProductid = keys for node in self.CONFIG["nodes"]: if node["device_id"] == maxDevice: self.mnode.send_command([node["ip"], ], {"COMMAND":"RETRIEVE","USERID":info["USERID"], "PRODUCTID": maxProductid}) target= self.mnode.targets[node["ip"]] print(target) maxData = self.mnode.reliable_recv(target) # GOT THE PRODUCTS maxData = json.loads(maxData)["PRODUCT"] """ HUGE DOUBT IF SEND WILL I RECIVE USING RELIABLE RECV """ for i in range(len(List)): x,y = List[i] if max_version != int(y): path = "/" + info["USERID"] + "/"+ str(keys) + "/" + str(x) path_rev = "/" + str(x) + "/" + info["USERID"] + "/"+ str(keys) device_ids = list(x) for node in self.CONFIG["nodes"]: if node["device_id"] in device_ids: self.mnode.send_command( [node["ip"]], {"COMMAND":"REPLACE","USERID":info["USERID"], "UPDATEDLIST":maxData, "MAX_PRODUCTID": maxProductid} ) """ SENDING A LIST DEPENDS ON IF maxData RECIEVED """ kmaster.setVersion(path,max_version) kmaster.setVersion(path_rev,max_version) if flag == True: for down_node in down_nodes: kmaster.create("/{}/{}/{}".format(down_node, info["USERID"], keys)) kmaster.create("/{}/{}/{}".format(info["USERID"], keys, down_node)) print(maxData, type(maxData), "maxdata") """ {"COMMAND":"INSERT","USERID":"1", "PRODUCTID":"5","OPERATION":"2","PRICE":"4","CATEGORY":"12"} """ self.mnode.send_command( [device_ip_map[down_node],], {"COMMAND":"REPLACE","USERID":info["USERID"], "MAX_PRODUCTID": maxProductid, "UPDATEDLIST":[maxData]}) #TO DO CHANGE DATA NODES ALSO latest_data = kmaster.getmap() if len(latest_data) == 0: return [] kmaster.stop_client() return latest_data def list_all_user_products(self, critera): latest_data = self.list_all({"USERID": critera["USERID"]}) print(latest_data, "in gateway") device_ip_map = {} for node in self.CONFIG["nodes"]: device_ip_map[node["device_id"]] = node["ip"] counter = None to_return = [] for data in latest_data: if counter != data["key"]: counter = data["key"] self.mnode.send_command([device_ip_map[data["device"]]], { "COMMAND":"RETRIEVE","USERID":critera["USERID"], "PRODUCTID": data["key"]} ) target = self.mnode.targets[device_ip_map[data["device"]]] prod = self.mnode.reliable_recv(target) prod = json.loads(prod)["PRODUCT"] to_return.append(prod) print(to_return, "in gateway") return to_return def delete(self,info:dict): """ dict ={ "USERID":username, "PRODUCTID":productID } """ kmaster = kazooMaster( self.GATEWAY_IP,"p","",info["USERID"],info["PRODUCTID"],"",False ) kmaster.start_client() allInfo = self.list_all({"USERID": info["USERID"]}) print(allInfo) for val in range(len(allInfo)): if allInfo[val]["key"]==info["PRODUCTID"]: for node in self.CONFIG["nodes"]: if node["device_id"] == allInfo[val]["device"]: self.mnode.send_command([node["ip"]], {"COMMAND":"DELETE", "USERID":info["USERID"],"PRODUCTID":allInfo[val]["key"]}) def list_category(self,info:dict): """ { Find all the alive nodes and take secondary indexes from them } dict = { info={ "CATEGORY":CATEGORY_NUMBER } } } """ val = self.get_crush() all_category_info = [] device_ip_map = self.get_device_ip_map() for value in range(len(val["trees"][0]["children"])): name = val["trees"][0]["children"][value]["children"][0]["name"] # for node in self.CONFIG["nodes"]: self.mnode.send_command( [device_ip_map[name], ], {"COMMAND":"LISTCATEGORY", "CATEGORY":info["CATEGORY"] }) target= self.mnode.targets[device_ip_map[name]] temp = self.mnode.reliable_recv(target) temp = json.loads(temp) all_category_info.append(temp) print(all_category_info, "in list_category") return all_category_info
def thd_worker(inst, idx, conn, addr): print(f"got {idx} {addr}") conn.settimeout(3) buff = "" try: while (_ := conn.recv(512).decode()): if not _: break buff += _ except socket.timeout: pass conn.settimeout(None) conn.send(b"ok\n") inst.halted = buff.strip() == "halt" print(inst.halted, buff.strip().encode()) conn.close() if __name__ != "__main__": raise SystemExit server = SocketServer(port=randint(49152, 65535), logger_file=sys.stdout) print(f"started server on address {server.host}:{server.port}") server.handle_connections( thd_worker, proxy_worker_thd=lambda fn, *args, **kwargs: threading.Thread( target=fn, args=args, kwargs=kwargs).start())