def worker(address, port, password): listener = Listener(address, authkey=password) conn = listener.accept() print 'connection accepted from', listener.last_accepted conn.send_bytes('hello') conn.close() listener.close()
def run(self): print ('MSocket receiver thread starts...') while not self.terminate: try: address = ('localhost', self.port) # family is deduced to be 'AF_INET' listener = Listener(address, authkey = b'your_password') print ("Listening on port {}..".format(self.port)) conn = listener.accept() # blocking print ('Connection accepted from {}'.format (listener.last_accepted)) except Exception as e: print("MSocket error. Quitting :") print (e) return while not self.terminate: try: self.message = conn.recv() # blocking self.data_ready = True print (self.message) if self.message == 'exit': # quit inner loop break except Exception as e: print(e) break print ('closing client connection..') conn.close() listener.close() if self.message == 'exit': # quit outer loop break print ('shutting down Msock server..') conn.close() listener.close() print ('MSocket receiver thread exits.')
def controller(system): address = ('localhost', 6000) listener = Listener(address, authkey=b'secret') conn = listener.accept() print('connection accepted from ', listener.last_accepted) while True: msg = conn.recv() # do something with msg if msg == 'measure': conn.send(system.get_measurement()) elif msg == 'command': u = conn.recv() try: u = float(u) system.set_u(u) except: raise ValueError(f"Command {u} not allowed") elif msg == 'disturbance': disturbance = conn.recv() print(f'disturbance: {disturbance}') try: disturbance = float(disturbance) system.disturbance = disturbance except: raise ValueError(f"Disturbance {disturbance} not allowed") elif msg == 'reset': system.state = system.init_state() system.u = 0.0 if msg == 'close': conn.close() break listener.close()
def create_ipc_server(self): listener = Listener((self.ipc_address, self.ipc_port), authkey=self.ipc_authkey) self.is_ipc_alive = True while True: conn = listener.accept() start_time = time.time() print(f"New Connection: {listener.last_accepted}") while True: msg = conn.recv() if debug: print(msg) if "FILE|" in msg: file = msg.split("FILE|")[1].strip() if file: event_system.push_gui_event(["create_tab_from_ipc", None, file]) conn.close() break if msg == 'close connection': conn.close() break if msg == 'close server': conn.close() break # NOTE: Not perfect but insures we don't lockup the connection for too long. end_time = time.time() if (end - start) > self.ipc_timeout: conn.close() listener.close()
def interrupt_experiment(experiment_script, lifecycle_stage): """Interrupt the experiment and verify no children processes remain.""" args = ['python', experiment_script] # The pre-executed function setpgrp allows to create a process group # so signals are propagated to all the process in the group. proc = subprocess.Popen(args, preexec_fn=os.setpgrp) launcher_proc = psutil.Process(proc.pid) # This socket connects with the client in the algorithm, so we're # notified of the different stages in the experiment lifecycle. address = ('localhost', 6000) listener = Listener(address) conn = listener.accept() while True: msg = conn.recv() if msg == lifecycle_stage: # Notice that we're asking for the children of the launcher, not # the children of this test script, since there could be other # children processes attached to the process running this test # that are not part of the launcher. children = launcher_proc.children(recursive=True) # Remove the semaphore tracker from the list of children, since # we cannot stop its execution. for child in children: if any([ 'multiprocessing.semaphore_tracker' in cmd for cmd in child.cmdline() ]): children.remove(child) # We append the launcher to the list of children so later we can # check it has died. children.append(launcher_proc) pgrp = os.getpgid(proc.pid) os.killpg(pgrp, signal.SIGINT) conn.close() break listener.close() # Once the signal has been sent, all children should die _, alive = psutil.wait_procs(children, timeout=6) # If any, notify the zombie and sleeping processes and fail the test clean_exit = True error_msg = '' for child in alive: error_msg += ( str(child.as_dict(attrs=['pid', 'name', 'status', 'cmdline'])) + '\n') clean_exit = False error_msg = ("These processes didn't die during %s:\n" % (lifecycle_stage) + error_msg) for child in alive: os.kill(child.pid, signal.SIGINT) assert clean_exit, error_msg
def local_listener(): listener = Listener(local_address_d, authkey="localData") while True: conn = listener.accept() print("[DATA] connection accepted from", listener.last_accepted) msg = conn.recv() # TODO: check end validation assert isinstance(msg, list) and len(msg) == 4 video_id = msg[0] begin = msg[1] end = msg[2] fps = msg[3] # Recently fps can only be 24 if not video_id == "local.h264": fetch_remote_data(video_id) cap = cv2.VideoCapture(os.path.join(local_dir, video_id)) frame_id = begin * fps ret = cap.set(1, frame_id) if begin == end: ret, frame = cap.read() conn.send([frame]) conn.close() else: frame_list = list() for i in xrange((end - begin) * fps): ret, frame = cap.read() frame_list.append(frame) conn.send(frame_list) conn.close() listener.close()
class Ipc(): def sendCmd(self, cmd, port): self.cmdSemaphore.acquire() address = ('localhost', port) try: conn = Client(address, authkey=b'secret password') conn.send(json.dumps(cmd)) conn.close() except ConnectionRefusedError as e: #logging.debug(e) pass self.cmdSemaphore.release() def serverInit(self, port): address = ('localhost', port) # family is deduced to be 'AF_INET' self.listener = Listener(address, authkey=b'secret password') def serverClose(self): self.listener.close() def serverGetCmd(self): conn = self.listener.accept() msg = conn.recv() data = json.loads(msg) return data def __init__(self): self.cmdSemaphore = Semaphore()
def loop(self): listener = Listener(self.address, backlog=5, authkey=self.authkey) logging.warn('DB server started with %s, listening on %s:%d...', sys.executable, *self.address) self.thread.start() cmd = None try: while cmd != 'stop': try: conn = listener.accept() except KeyboardInterrupt: break except: # unauthenticated connection, for instance by a port # scanner such as the one in manage.py continue cmd_ = conn.recv() # a tuple (name, arg1, ... argN) cmd, args = cmd_[0], cmd_[1:] if cmd.startswith('@'): # slow command, run in process cmd = cmd[1:] # strip @ proc = Process( target=run_command, name=cmd, args=(cmd, args, conn)) proc.start() logging.warn('Started %s%s in process %d', cmd, args, proc.pid) else: queue.put((conn, cmd, args)) finally: listener.close() self.thread.join()
def _serve(self, port, path): data = [] # print 'Server', os.getpid() address = ('localhost', port) listener = Listener(address) loop = True while loop: conn = listener.accept() command, payload = conn.recv() response_payload = None if command == 'OPEN': #print command, payload path = payload elif command == 'WRITE': #print command, payload data.append(payload) elif command == 'FETCH': #print command, payload response_payload = data elif command == 'FLUSH': #print command json.dump(data, open(path, 'w')) elif command == 'CLOSE': #print command #json.dump(data, open(path, 'w')) loop = False conn.send(('OK', response_payload)) conn.close() listener.close()
class CountApiServer(threading.Thread): def __init__(self, port, parent): super(CountApiServer, self).__init__() self.parent = parent self.__listener = Listener(('127.0.0.1', port)) def run(self): conn = self.__listener.accept() while 1: if conn.closed: conn = self.__listener.accept() try: msg = conn.recv() except EOFError: conn.close() continue else: if msg == 'quit': conn.close() break conn.send(self.parent.key_count) self.__listener.close() self.parent.stop()
def run(self, engine, robo_id): """ Feed the Engine (read/exec/write)""" listener = Listener(self.address) con = listener.accept() self.game_tick = 0 while not con.closed: try: cmd = con.recv() except: break self.game_tick += 1 engine.game_timer(self.game_tick) reply = engine.execute(self.game_tick, robo_id, cmd) if reply: try: b = reply[1][0][0][0] status = reply[1][0][1] con.send([b, status, {'active': True}]) except Exception as e: break else: break try: con.close() listener.close() except Exception: pass
def runserver(): s, cook = prepare_session() acwing_socket = websocket.WebSocketApp('wss://www.acwing.com/wss/chat/', header=socket_header, cookie=cook, on_message=on_message, on_error=on_error, on_close=on_close) wst = threading.Thread(target=acwing_socket.run_forever, kwargs={'ping_interval': 60}) wst.daemon = True wst.start() address = ('localhost', 6001) # family is deduced to be 'AF_INET' listener = Listener(address, authkey=b'1234') try: while True: conn = listener.accept() send_debug_message(conn, 'welcome') send_debug_message(conn, str(listener.last_accepted)) t = threading.Thread(target=handle, args=(conn, acwing_socket, listener)) t.daemon = True t.start() except: pass listener.close()
def _listen(self): """ Listen for information from a client and performs actions related to the windows registry """ registry = Registry() listener = Listener(('localhost', self.port), authkey=self.password) conn = listener.accept() msg = conn.recv() if type(msg) is list and len(msg) == 2: # Deleting debugger key debug_path = self.DEBUG_KEY + msg[0] k = registry.open_key(HKLM, debug_path) registry.del_value(k, "debugger") # Deleting the bad path k = registry.open_key(HKCU, msg[1]) if k: self.brush.color("[!!] POSSIBLE UAC BYPASS IN YOUR SYSTEM\n", 'RED') registry.delete_key(HKCU, msg[1]) ctypes.windll.user32.MessageBoxA( None, "UAC BYPASS DETECTADO Y MITIGADO. EJECUCION SEGURA DEL BINARIO", "PELIGRO!", 0) os.system(msg[0]) # Setting the debugger key before breaking connection k = registry.open_key(HKLM, debug_path) payload = self.build_payload(msg[0][:-3] + "pyw") registry.create_value(k, "debugger", payload) print "[+] Closing the listener" conn.close() listener.close()
def _serve(self, port, path): data = [] # print 'Server', os.getpid() address = ('localhost', port) listener = Listener(address) loop = True while loop: conn = listener.accept() command, payload = conn.recv() response_payload = None if command == 'OPEN': #print command, payload path = payload elif command == 'WRITE': #print command, payload data.append(payload) elif command == 'FETCH': #print command, payload response_payload = data elif command == 'FLUSH': #print command json.dump(data, open(path, 'w')) elif command == 'CLOSE': #print command #json.dump(data, open(path, 'w')) loop = False conn.send(('OK', response_payload)) conn.close() listener.close()
def main(): # type: () -> None listener = Listener(WORKER_SOCKET_NAME, 'AF_UNIX') try: Door.initialize() name_to_add = None print('Worker started') while True: conn = listener.accept() print('connection accepted from', listener.last_accepted) msg = conn.recv() print('Message: ', msg) command = msg['type'] value = msg['value'] if command == 'read': process_read_command(value, name_to_add) name_to_add = None elif command == 'add': name_to_add = process_add_command(value) else: Repository.log_message( 'error', 'Unknown command: {}'.format(command)) finally: Door.cleanup() listener.close()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--port', default=6000) parser.add_argument('--authkey', default='adversql') parser.add_argument('--schemas_path', default='../../data/spider/tables.json') parser.add_argument('--models_path', default='generated_data_augment/saved_models') parser.add_argument('--glove_path', default='glove') parser.add_argument('--toy', action='store_true') args = parser.parse_args() schemas = load_schemas(args.schemas_path) model = load_model(args.models_path, args.glove_path, args.toy) while True: address = ('localhost', args.port) # family is deduced to be 'AF_INET' listener = Listener(address, authkey=args.authkey) print('Listening on port {}...'.format(args.port)) conn = listener.accept() print('Connection accepted from:', listener.last_accepted) while True: msg = conn.recv_bytes() if msg == 'close': conn.close() break db_name, nlq = msg.split('\t') sql, conf = translate(model, schemas, db_name, nlq) conn.send_bytes('{}\t{}'.format(sql, conf)) listener.close()
def issue_credential(data): address = ('localhost', Constant.PORT_NUMBER) listener = Listener(address) listener._listener._socket.settimeout(Constant.TIMEOUT) proposal_response = send_offer(data) credential_exchange_id = proposal_response["credential_exchange_id"] logger.info(f'credential_exchange_id: {credential_exchange_id}') while True: try: conn = listener.accept() msg = conn.recv() state = msg["state"] logger.info(f'waiting state change, current state is: {state}') conn.close() if state == 'credential_acked': print("Congratulation, execute publish successfully!") listener.close() break else: time.sleep(0.5) except socket.timeout as e: logger.error(e) print( "vsw: error: request timeout, there might be some issue during publishing" ) listener.close() break
def __init_listener(self): tmp_base = utils.get_tmp_base_path_from_mkfile() hmi_base_path = os.path.join(tmp_base, self.name) # Create HMI base path if it does not exist if not os.path.exists(hmi_base_path): os.makedirs(hmi_base_path) address = os.path.join(hmi_base_path, 'mb_socket') # Ensure that socket does not exist try: os.unlink(address) except OSError: if os.path.exists(address): logger.exception('Could not remove socket file.') # Create listener listener = Listener(address) while True: conn = listener.accept() msg = conn.recv() if isinstance(msg, ReadMessage): conn.send(self.mb_tbls[msg.mb_table][self.actions[0]]( msg.ip, msg.starting_addr)) elif isinstance(msg, WriteMessage): conn.send(self.mb_tbls[msg.mb_table][self.actions[1]]( msg.ip, msg.starting_addr, msg.values)) elif isinstance(msg, CloseMessage): conn.close() break listener.close()
def local_listener(): listener = Listener(local_address_m, authkey="localModel") while True: conn = listener.accept() print("[MODEL] connection accepted from", listener.last_accepted) msg = conn.recv() # print(msg) assert isinstance(msg, list) and len(msg) == 3 task = msg[0] frame = msg[1] nickname = msg[2] if nickname not in model_dict.get_all_dict().keys(): ''' t_tmp = Thread(target=fetch_remote_model, args=(nickname,), name="tmpDeployRemoteModel") t_tmp.start() # Use Default Model print("Model not found at local, fetch from remote, switch to default model") nickname = 'deploy_ssd_mobilenet_512' ''' fetch_remote_model(nickname) if task == "reid": ans = model_dict.get_model(nickname).doInference(frame) else: ans = model_dict.get_model(nickname).parseResult( task, model_dict.get_model(nickname).doInference(frame)) conn.send(ans) conn.close() listener.close()
def loop(self): listener = Listener(self.address, backlog=5, authkey=self.authkey) logging.warn('DB server started with %s, listening on %s:%d...', sys.executable, *self.address) try: while True: try: conn = listener.accept() except KeyboardInterrupt: break except: # unauthenticated connection, for instance by a port # scanner such as the one in manage.py continue cmd_ = conn.recv() # a tuple (name, arg1, ... argN) cmd, args = cmd_[0], cmd_[1:] logging.debug('Got ' + str(cmd_)) if cmd == 'stop': conn.send((None, None)) conn.close() break func = getattr(actions, cmd) fut = executor.submit(safely_call, func, (self.db, ) + args) def sendback(fut, conn=conn): res, etype, _mon = fut.result() if etype: logging.error(res) # send back the result and the exception class conn.send((res, etype)) conn.close() fut.add_done_callback(sendback) finally: listener.close()
class CommunicationDeamon(QThread): commandReceived = pyqtSignal(object) def __init__(self, address): QThread.__init__(self) self.listener = Listener(address, authkey=SECRET) def run(self): while True: conn = self.listener.accept() self.connection = conn msg = conn.recv() if msg[0] == 'stop': self.listener.close() return conn.close() self.commandReceived.emit(msg) def get_port(self): return self.listener.address[1] def get_address(self): return self.listener.address
def loop(self): listener = Listener(self.address, backlog=5, authkey=self.authkey) logging.warn('DB server listening on %s:%d...' % self.address) self.thread.start() cmd = None try: while cmd != 'stop': try: conn = listener.accept() except KeyboardInterrupt: break except: # unauthenticated connection, for instance by a port # scanner such as the one in manage.py continue cmd_ = conn.recv() # a tuple (name, arg1, ... argN) cmd, args = cmd_[0], cmd_[1:] if cmd.startswith('@'): # slow command, run in process cmd = cmd[1:] # strip @ proc = Process( target=run_command, name=cmd, args=(cmd, args, conn)) proc.start() logging.warn('Started %s%s in process %d', cmd, args, proc.pid) else: queue.put((conn, cmd, args)) finally: listener.close() self.thread.join()
def loop(self): listener = Listener(self.address, backlog=5, authkey=self.authkey) logging.warn('DB server started with %s, listening on %s:%d...', sys.executable, *self.address) try: while True: try: conn = listener.accept() except KeyboardInterrupt: break except: # unauthenticated connection, for instance by a port # scanner such as the one in manage.py continue cmd_ = conn.recv() # a tuple (name, arg1, ... argN) cmd, args = cmd_[0], cmd_[1:] logging.debug('Got ' + str(cmd_)) if cmd == 'stop': conn.send((None, None)) conn.close() break func = getattr(actions, cmd) fut = executor.submit(safely_call, func, (self.db, ) + args) def sendback(fut, conn=conn): res, etype, _mon = fut.result() if etype: logging.error(res) # send back the result and the exception class conn.send((res, etype)) conn.close() fut.add_done_callback(sendback) finally: listener.close()
def startListener(self): """ Listen to event triggers """ from multiprocessing.connection import Listener import time host = "localhost" port = int(main.params['GENERATOR']['listenerPort']) address = (host, port) listener = Listener(address) main.log.info( "Event Generator - Event listener start listening on %s:%s" % (host, port)) while 1: conn = listener.accept() t = main.Thread(target=self.handleConnection, threadID=main.threadID, name="handleConnection", args=[conn]) t.start() with main.variableLock: main.threadID += 1 listener.close()
class chimeraInterface(): def __init__(self): '''Initialize variables, create socket, register events and open volume''' self.vProj = None self.address = '' self.port = 6000 self.authkey = 'test' self.createSocket() self.registerEvent() self.openVolume() def createSocket(self): '''Create socket and wait for a new client''' print 'Waiting for client' self.listener = Listener((self.address, self.port), authkey=self.authkey) self.remote_conn = self.listener.accept() print 'Got client ' + self.listener.last_accepted[0] + ':%d' % ( self.listener.last_accepted[1]) def openVolume(self): '''Wait for volume data and open in volume viewer''' try: while True: if self.remote_conn.poll(): msg = self.remote_conn.recv() if type(msg) is numpy.ndarray: from VolumeData import Array_Grid_Data grid = Array_Grid_Data(msg) from VolumeViewer import volume_from_grid_data self.v = volume_from_grid_data(grid) break #else: #print 'msg: ' + msg else: time.sleep(0.01) except EOFError: print 'Lost connection to client' self.listener.close() #def motionStart(self, trigger, x, file): #print "Motion Start" def motionStop(self, trigger, x, file): '''Event executed when user unclick the volume''' #print "Motion Stop" rx, ry, rz, t = self.v.openState.xform.getCoordFrame() a = numpy.array([[rx[0], ry[0], rz[0]], [rx[1], ry[1], rz[1]], [rx[2], ry[2], rz[2]]]) self.remote_conn.send(pickle.dumps(a)) def registerEvent(self): '''Register Events''' #chimera.triggers.addHandler(chimera.MOTION_START, self.motionStart, None) chimera.triggers.addHandler(chimera.MOTION_STOP, self.motionStop, None)
def run(self): """ Enable the server and perform some function on the inputs from the client. """ print("\033[94mServer for Qgis backend running here...\033[0m") if isinstance(self.cache, dict): print( "\u001b[33mInputs and neural network will be cached in RAM.", "Faster but can be troublesome with large inputs.\033[0m", ) with open(self.connexion_file, "r") as f: d = yaml.safe_load(f) if self.ssh_server: address_server = tuple(d["ssh"]["address_server"]) address_client = tuple(d["ssh"]["address_client"]) else: address_server = tuple(d["local"]["address_server"]) address_client = tuple(d["local"]["address_client"]) while True: listener = Listener(address_server, authkey=b"Who you gonna call?") try: conn = listener.accept() # ends once it has found a client except KeyboardInterrupt: print_warning("Keyboard interrupt.") exit() data = conn.recv() # receive data conn.close() listener.close() if data["task"] == "Semantic segmentation": func = self.segmentation else: return "Only semantic segmentation task currently implemented." try: print(f"\u001b[36mRunning a {data['task'].lower()} task...\033[0m") tic = time() result = func(data) # perform all the real work. toc = time() time_ = np.round(toc - tic, 1) if not isinstance(self.cache, dict) and torch.cuda.is_available(): torch.cuda.empty_cache() if isinstance(result, str): new_msg = result else: new_msg = self.n_classes print(f"\033[92mDone in {time_} seconds.\033[0m") except KeyboardInterrupt: new_msg = "Task interrupted by the user." print_warning("\n" + new_msg) except Exception as error: new_msg = error print_warning(error) finally: conn_client = Client(address_client, authkey=b"ghostbusters") conn_client.send(new_msg) conn_client.close() if isinstance(new_msg, Exception): raise (new_msg) else: print("\u001b[35;1m\nReady for another task \U0001F60E \n\033[0m")
def close(self, blockUntilClosed = True): '''close may wait 1 second.''' Listener.close(self) if self.establish_connection_to_close_lock.acquire(False): if not blockUntilClosed: thread_start_new(self._connect_to_pipe_to_close_it, ()) else: self._connect_to_pipe_to_close_it()
def run(self): serv = Listener(self.address) while self.main_thread.is_alive(): client = Child(serv) client.start() while self.main_thread.is_alive() and client.is_alive(): pass serv.close()
def listen(self): listener = Listener(self.address, authkey=b'secret password') conn = listener.accept() print('connection accepted from', listener.last_accepted) msg = conn.recv() conn.close() listener.close() return msg
def send(msg): address = ('localhost', 6000) listener = Listener(address) conn = listener.accept() conn.send(msg) conn.close() listener.close()
class SingleInstanceApp(BaseJobManager): def __init__(self, name, session=''): BaseJobManager.__init__(self) if sys.platform == 'win32': self.address = r'\\.\pipe\single_instance_app.' else: self.address = '/var/tmp/single_instance_app.pipe' trans = string.maketrans('\\ ', '__') self.address += '.'+name.translate(trans) if session and len(session)>0: self.address += session.translate(trans) self.accepting_connection = False def _accept_connection(self): while self.accepting_connection: conn = self.listener.accept() args = conn.recv() conn.close() self.queue_launch_instance(*args) def try_start_instance(self, *args): try: conn = Client(self.address, authkey='secret password') conn.send(args) conn.close() #print "sent my args(%s)"%(', '.join(args)) return False except: self.queue_launch_instance(*args) self.listener = Listener(self.address, authkey='secret password') self.accepting_connection = True self.listener_tread = threading.Thread(target=self._accept_connection) self.listener_tread.daemon = True #because of listener.accept() blocks self.listener_tread.start() return True def stop_accepting(self): self.accepting_connection = False self.listener.close() self.listener_tread.join(0.01) def queue_launch_instance(self, *args): fancy_log(sys.stdout, 'queued instance launch with args: '+str(args)) self.add_job(*args) #override #def do_the_job(self, *args): # print 'calls instance with args: ',args # self.update_job() def job_is_updated(self, *args, **kwargs): fancy_log(sys.stdout,'calls instance with args: '+str(args)+'\n kwargs: '+str(kwargs)) pass
class server(): def __init__(self, sock=8000, ip='localhost', authkey='secret password', MAX=3): self.sock = sock self.ip = ip self.authkey = authkey self.connections = [] self.scale = MAX self.jobs = [] self.outputs = [] self.socket = None def setScale(self, scale): self.scale = scale def addJobs(self, _list): self.jobs.extend(_list) def _listen(self): scale = self.scale while True: if scale: scale -= 1 conn = self.socket.accept() self.connections.append(conn) #print 'connection accepted from', conn.last_accepted else: break def start(self): self.socket = Listener((self.ip, self.sock), authkey=self.authkey) self._listen() next = self.scale - 1 scheduler = chunks(self.jobs, self.scale) if len(self.jobs) is 0: print "Please add some jobs before you start me !!" return for each in scheduler: self.connections[next].send(each) next -= 1 if next < 0: break now = time.time() for conn in self.connections: x = conn.recv() self.outputs.extend(x) conn.close() self.socket.close() t = time.time() - now X = [] X.append(["time", t]) print tabulate(X, tablefmt='rst') #print str("Took me " + str(t) + " time") return self.outputs
def doorTriggerLoop(): for door in cfg.GARAGE_DOORS: state = get_garage_door_state(door['pin']) status = cfg.HOMEAWAY address = (cfg.NETWORK_IP, int(cfg.NETWORK_PORT)) listener = Listener(address, authkey='secret password') while True: conn = listener.accept() # print 'connection accepted from', listener.last_accepted received = conn.recv_bytes() response = 'unknown command' trigger = False if received == 'trigger': trigger = True if state == 'open': response = 'closing garage door' else: response = 'opening garage door' elif received == 'open': if state == 'open': response = 'garage door already open' else: response = 'opening garage door' trigger = True elif received == 'close': if state == 'open': response = 'closing garage door' trigger = True else: response = 'garage door alredy closed' elif received == 'state': response = 'the garage door is' + state elif received == 'home': cfg.HOMEAWAY = 'home' response = 'alert status set to HOME' elif received == 'away': cfg.HOMEAWAY = 'away' response = 'alert status set to AWAY' conn.send_bytes(response) print 'Received command to ' + received + ' the garage door. Response was ' + response if trigger: # GPIO.setup('7', GPIO.OUT) print 'Door triggered' # GPIO.setup('7', GPIO.IN) trigger = False time.sleep(1) conn.close() listener.close()
def doorTriggerLoop(): address = (cfg.NETWORK_IP, int(cfg.NETWORK_PORT)) listener = Listener(address) while True: # Receive incomming communications and set defaults conn = listener.accept() received_raw = '' received_raw = conn.recv_bytes() received = received_raw.lower() response = 'unknown command' trigger = False if received == 'trigger': trigger = True if state == 'open': response = 'closing' else: response = 'opening' elif received == 'open' or received == 'up': if state == 'open': response = 'already open' else: response = 'opening' trigger = True elif received == 'close' or received == 'down': if state == 'open': response = 'closing' trigger = True else: response = 'already closed' elif received == 'home' or received == 'set to home': cfg.HOMEAWAY = 'home' response = 'set to home' elif received == 'away' or received == 'set to away': cfg.HOMEAWAY = 'away' response = 'set to away' elif received == 'state' or received == 'status': response = get_garage_door_state() + ' and ' + cfg.HOMEAWAY elif received.startswith('firebase:'): cfg.FIREBASE_ID = received_raw.replace('firebase:','') response = 'ok' conn.send_bytes(response) print 'received ' + received_raw + '. ' + response if trigger: GPIO.output(26, GPIO.LOW) time.sleep(2) GPIO.output(26, GPIO.HIGH) trigger = False time.sleep(1) conn.close() listener.close()
def __init_listener(self): def on_connect(client, userdata, flags, rc): logger.info("MQTT client [name=%s] connected with result code %s.", self.name, str(rc)) self.is_connected = True def disconnect(): self.client.loop_stop() self.client.disconnect() self.is_connected = False # Create MQTT client self.client = mqtt.Client() self.client.on_connect = on_connect tmp_base = utils.get_tmp_base_path_from_mkfile() dev_base_path = os.path.join(tmp_base, self.name) # Create device base path if it does not exist if not os.path.exists(dev_base_path): os.makedirs(dev_base_path) address = os.path.join(dev_base_path, 'mqtt_socket') # Ensure that socket does not exist try: os.unlink(address) except OSError: if os.path.exists(address): logger.exception('Could not remove socket file.') # Create listener listener = Listener(address) while True: conn = listener.accept() msg = conn.recv() if isinstance(msg, ConnectMessage): if msg.auth is not None: username = msg.auth['username'] password = msg.auth['password'] if username is None: logger.error( "Could not authenticate MQTT client [name=%s], " + "because username has no username has been provided.", self.name) else: self.client.username_pw_set(username, password=password) self.client.connect(msg.host, msg.port, msg.keepalive, msg.bind_address) self.client.loop_start() elif isinstance(msg, PublishMessage): self.client.publish(msg.topic, msg.payload, msg.qos, msg.retain) elif isinstance(msg, DisconnectMessage): disconnect() elif isinstance(msg, CloseMessage): disconnect() conn.close() break listener.close()
class server(): def __init__(self, sock=8000, ip='localhost', authkey='secret password', MAX=3): self.sock = sock self.ip = ip self.authkey = authkey self.connections = [] self.scale = MAX self.jobs = [] self.outputs = [] self.socket = None def setScale(self, scale): self.scale = scale def addJobs(self, _list): self.jobs.extend(_list) def _listen(self): scale = self.scale while True: if scale: scale -= 1 conn = self.socket.accept() self.connections.append(conn) #print 'connection accepted from', conn.last_accepted else: break def start(self): self.socket = Listener((self.ip, self.sock), authkey=self.authkey) self._listen() next = self.scale-1 scheduler = chunks(self.jobs, self.scale) if len(self.jobs) is 0: print "Please add some jobs before you start me !!" return for each in scheduler: self.connections[next].send(each) next -= 1 if next < 0: break now = time.time() for conn in self.connections: x = conn.recv() self.outputs.extend(x) conn.close() self.socket.close() t = time.time() - now X = [] X.append(["time", t]) print tabulate(X, tablefmt='rst') #print str("Took me " + str(t) + " time") return self.outputs
def experiment_thread(self, db, schema, tsq, literals, ready, tsq_level, gold): address = ('', self.port) listener = Listener(address, authkey=self.authkey) ready.set() print(f'DuoquestServer listening on port {self.port}...') conn = listener.accept() print('DuoquestServer connection accepted from:', listener.last_accepted) self.verifier.init_stats() while True: msg = conn.recv_bytes() try: if msg.decode('utf-8') == 'close': conn.close() break except Exception: pass protolist = ProtoQueryList() protolist.ParseFromString(msg) response = ProtoResult() for query in protolist.queries: if query.done_query: if tsq_level == 'nlq_only': result = Tribool(True) else: result = self.verifier.verify(db, schema, query, tsq, literals) else: if tsq_level == 'nlq_only' or tsq_level == 'chain': result = Tribool(None) else: result = self.verifier.verify(db, schema, query, tsq, literals) if result.value is None: response.results.append(UNKNOWN) elif result.value: response.results.append(TRUE) if matches_gold(gold, query): response.answer_found = True else: response.results.append(FALSE) conn.send_bytes(response.SerializeToString()) pprint(self.verifier.stats) listener.close()
def start_serve(self): """start the server""" while True: listener = Listener(self.address) conn = listener.accept() process = ClientModuleConnect(listener.last_accepted, conn) process.start() listener.close()
def transient_server(address, authkey, seconds): class TimeoutException(Exception): pass def timeout_handler(signum, frame): raise TimeoutException('end for listener') signal.signal(signal.SIGALRM, timeout_handler) server = Listener(address, authkey=authkey) try: yield server except TimeoutException: server.close()
def run(self): address = ("localhost", 6000) listener = Listener(address, authkey="secret password") conn = listener.accept() while True: command = self.queue.get() conn.send_bytes(command) self.queue.task_done() if command == "quit": break conn.close() listener.close()
class Visualizer(object): def __init__(self, din = {}): import plotter self.dict = { 'plotter': plotter.SubplotAnimation(), } self.dict.update(din) print "[IPC-S] Server process ID ", os.getpid() self.init_communication() self.__run__() def init_communication(self): print "[IPC-S] Opening Server socket ... ", address = ('localhost', 6000) # family is deduced to be 'AF_INET' self.listener = Listener(address) print "done!" print "[IPC-S] Waiting Client ... ", self.conn = self.listener.accept() print 'connection accepted from', self.listener.last_accepted def close_communication(self): print "[IPC-S] Closing interprocess communication ... ", self.conn.close() self.listener.close() print "done!" def read_msg(self): return self.conn.recv() def __run__(self): while True: msg = self.read_msg() # msg format: [os.getpid(), i, time, avg[0], avg[1], avg[2]] # Process the message if msg == 'close': self.close_communication() break procID = msg[0] counter = msg[1] logTime = msg[2] avg = msg[3:] #print os.getpid(), "--- Recived ", msg, " ||| avg ", avg, " ||| counter ", counter # Plot the data self.dict['plotter'].draw_frame([logTime, avg[0], avg[1], avg[2]] ) # plots a point every 100 ms
def run(self): listener = Listener(self.address, authkey=self.auth) while True: with listener.accept() as connection: msg = connection.recv() if msg == 'exit': break else: if shared.settings['use_indicator']: GLib.idle_add(getattr(shared.indicator, msg).activate) else: GLib.idle_add(getattr(shared.indicator, msg)) listener.close()
def run_server(address, authkey, mod, q): serv = Listener(address, authkey =authkey) while True: try: client= serv.accept() msg= make_work(client, mod, q) if msg == 'Close': # 关闭监听 serv.close() return "Close" else: client.send(msg) except Exception: traceback.print_exc() serv.close()
def run(self): print 'Server setup' try: listener = Listener((self.host, self.port), authkey=self.pw) print 'Server address :',listener.address conn = listener.accept() print 'connection accepted' while True: msg = conn.recv() resp = self.dispatch(msg) conn.send(resp) except EOFError,IOError: conn.close() listener.close() print "Connection terminated by client"
def server(): listener = Listener(address, authkey=b'mypassword') print('listening..') from_client = True while from_client: conn = listener.accept() print ('connection accepted from', listener.last_accepted) conn.send([1,2,3,4]) conn.send_bytes(b'hello') from_client = conn.recv() print(from_client) conn.close() listener.close()
def run(self): global loop_data, archive_data, conn, lock syslog.syslog(syslog.LOG_INFO, "wxdata server started") syslog.syslog(syslog.LOG_INFO, "wxdata: server process {}".format(os.getpid())) syslog.syslog(syslog.LOG_INFO, "wxdata: address: '{}' ".format(self.address)) syslog.syslog(syslog.LOG_INFO, "wxdata: key: '{}' ".format(self.key)) listener = Listener(self.address, authkey=self.key) listener._listener._socket.settimeout(10) while True: # try to accept a connection - most likely failure is a timeout try: conn = listener.accept() if self.exit.is_set(): syslog.syslog(syslog.LOG_INFO, "wxdata: server exiting") break # syslog.syslog(syslog.LOG_INFO, "wxdata: connection accepted from: " + format(listener.last_accepted)) req = conn.recv() if isinstance(req,str): # simple request? if req == "wxloop": with lock: data = loop_data elif req == "wxarchive": with lock: data = archive_data elif req == "wxname": data = self.name # station name as string conn.send(data) elif isinstance(req,tuple): # request with keys? keys = req[1:] # extract the key list req = req[0] with lock: if req == "wxloop": wxdata = loop_data elif req == "wxarchive": wxdata = archive_data # data = {k: wxdata.get(k,'**BadKey**') for k in keys} dp = wxdata.get('dewpoint','***') if dp == "***": syslog.syslog(syslog.LOG_ERR, "wxdata: dewpoint missing".format(len(loop_data))) data = {k: wxdata.get(k,None) for k in keys} conn.send(data) conn.close() except socket.timeout: pass except Exception as e: syslog.syslog(syslog.LOG_ERR, "wxdata: Exception") syslog.syslog(syslog.LOG_ERR, "wxdata: error: {0} - {1}".format(type(e), e)) # syslog.syslog(syslog.LOG_ERR, "wxdata: error: {}".format(sys.exc_info()[0])) listener.close() syslog.syslog(syslog.LOG_INFO, "wxdata: server ended")
def listener(): address = ('localhost', 8888) # 为什么加了authkey就会报出OSError:bad message length ? 超出了最大的长度 # listener = Listener(address, backlog=100, authkey=bytes('johnson wu', 'utf-8')) listener = Listener(address, backlog=100) while True: conn = listener.accept() try: print(conn) # 根据打印出来的conn对象,只是用到了4个进程 conn.send('hhh') except Exception as e: raise e finally: conn.close() listener.close()
def testing(): from multiprocessing.connection import Listener address = ('localhost', 6000) # family is deduced to be 'AF_INET' listener = Listener(address, authkey='dp23y4fm') while True: conn = listener.accept() if conn.recv_bytes() == "stop": print "Stopping Speeking" global is_stopped with lock: is_stopped = True conn.close() listener.close()
def accept(address): """ Accept a connection and return a Connection object. """ while True: try: listener = Listener(address, authkey=USERPREF['authkey']) conn = listener.accept() break except Exception: log_warn("The authentication key is not correct") listener.close() del listener time.sleep(.1) client = listener.last_accepted return Connection(conn), client[0]
def bare_server(port, logfile): """Bare-bones remote server""" from multiprocessing.connection import Listener fd = open(logfile, "w", 0) address = ("", port) listener = Listener(address) conn = listener.accept() fd.write("Connection accepted\n") # Wait for main server and execute it msg = conn.recv() try: exec(msg) except Exception as e: fd.write("ERROR: %r\n" % e) fd.close() listener.close()
def main(host='localhost', port=6000, authkey='secret password'): "Debug a script and accept a remote frontend" if not sys.argv[1:] or sys.argv[1] in ("--help", "-h"): print "usage: pdb.py scriptfile [arg] ..." sys.exit(2) mainpyfile = sys.argv[1] # Get script filename if not os.path.exists(mainpyfile): print 'Error:', mainpyfile, 'does not exist' sys.exit(1) del sys.argv[0] # Hide "pdb.py" from argument list # Replace pdb's dir with script's dir in front of module search path. sys.path[0] = os.path.dirname(mainpyfile) from multiprocessing.connection import Listener address = (host, port) # family is deduced to be 'AF_INET' listener = Listener(address, authkey=authkey) print "qdb debugger backend: waiting for connection at", address conn = listener.accept() print 'qdb debugger backend: connected to', listener.last_accepted # create the backend qdb = Qdb(conn, redirect_stdio=True, allow_interruptions=True) try: print "running", mainpyfile qdb._runscript(mainpyfile) print "The program finished" except SystemExit: # In most cases SystemExit does not warrant a post-mortem session. print "The program exited via sys.exit(). Exit status: ", print sys.exc_info()[1] raise except Exception: traceback.print_exc() print "Uncaught exception. Entering post mortem debugging" info = sys.exc_info() qdb.post_mortem(info) print "Program terminated!" finally: conn.close() listener.close() print "qdb debbuger backend: connection closed"
def run(self): listener = Listener(('localhost', 18273)) connection = listener.accept() # uuid connection.recv_bytes().decode('utf-8') # ServerBreaks connection.recv_bytes().decode('utf-8') # Empty breaks connection.send_bytes(b'{}') # Continuing if self.stops: connection.recv_bytes().decode('utf-8') connection.send_bytes(b'Continue') self.lock.acquire() connection.close() listener.close() self.lock.release()
class ApiServer(object): def __init__(self,address,handler): self.listener = Listener(address,authkey='secret password') self.handler = handler self.done = False def serve_forever(self): while not self.done: conn = self.listener.accept() print 'connection accepted from', self.listener.last_accepted handler = self.handler(conn) handler_thread = threading.Thread(target=handler.handle) handler_thread.start() def shutdown(self): self.done = True self.listener.close()
def run(self): while True: # Start the server server_shutdown = False logging.info("Listening on {0} port".format(self.port)) listener = Listener((self.host, self.port)) conn = listener.accept() logging.info("Connection accepted from {0}".format(listener.last_accepted)) # Handle client requests while True: try: msg = conn.recv() if not msg: continue logging.info('Client request: {0}'.format(msg)) if msg[0] == 'start' and self.indexer_running == False: self.__start_indexer(msg) elif msg[0] == 'stop' and self.indexer_running == True: self.__stop_indexer() elif msg[0] == 'shutdown': server_shutdown = True break else: logging.warning('Unknown client request.') except (EOFError): logging.info('Connection closed.') conn.close() listener.close() break # Handle shutdown request if server_shutdown == True: logging.info('Shutting the indexer down ...') break # Clean-up and exit conn.close() listener.close() if self.indexer != None: if self.indexer_running == True: self.__stop_indexer() self.indexer.finalize() logging.info('Exiting ...')
def run_server(process = lambda x : x): """ Runs server (blocking). """ print "Listener created at", __address listener = Listener(__address, authkey='strumamor') while True: try: connection = listener.accept() except AuthenticationError: continue #print "Connection accepted from", listener.last_accepted result = _process(connection, process) if result == __quit_command: break listener.close()
def startServer(self): print('Listen starting ...') serv = Listener(self.address, authkey=self.authkey) while True: try: conn = serv.accept() msg = conn.recv() if msg is None: print('self.lock_dict') print('revice None ...') break print('\n\n') print(self.lock_dict) print('revice %s' % str(msg)) self.response(conn, msg) print(self.lock_dict) print('\n\n') conn.close() except Exception: traceback.print_exc() serv.close()
class ProcListener(threading.Thread): def __init__(self, addr, authkey): threading.Thread.__init__(self) self.running = False self.connections = [] self.bus = None self.addr = addr self.authkey = authkey self.listener = Listener(addr, authkey=authkey) self.setDaemon(True) def run(self): self.bus.log("Listening for incoming connections") self.running = True while self.running: conn = self.listener.accept() self.connections.append(conn) def stop(self): if not self.running: return self.bus.log("Stopping listener") self.running = False for conn in self.connections: if conn: conn.close() # if the listener is blocked in the accept() call # it will lock the thread, so by connecting to it # we unblock it c = Client(self.addr, authkey=self.authkey) c.close() self.connections = [] self.listener.close() def recv(self): return self.listener.recv()
def _create_server(self): self.pid_path = '/tmp/yli-METEOR-pid' #self.address = ('localhost', 6000) self.address = '/tmp/yli-METEOR-server' self.authkey = 'dummy key' try: pid = open(self.pid_path).read().strip() assert 'java' in subprocess.check_output(['ps', '-p', pid, '-o', 'cmd']) self.listener = None self.meteor_p = None except: # really create server self.meteor_p = subprocess.Popen(self.meteor_cmd, \ cwd=os.path.dirname(os.path.abspath(__file__)), \ stdin=subprocess.PIPE, \ stdout=subprocess.PIPE, \ stderr=sys.stderr) self.pid = self.meteor_p.pid open(self.pid_path, 'w').write(str(self.pid)) if os.fork(): # put to background # the main process should call _compute_score to # initialize meteor.jar, which takes longer than 5 seconds return else: while True: if os.path.exists(self.address): os.remove(self.address) listener = Listener(self.address, authkey=self.authkey) try: self._handle_listenser(listener) except Exception as ioe: print ioe, '65' pass finally: listener.close()