Exemplo n.º 1
0
    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()
Exemplo n.º 2
0
def rpc_server(handler, address, authkey):
    sock = Listener(address, authkey=authkey)
    while True:
        client = sock.accept()
        t = Thread(target=handler.handle_connection, args=(client,))
        t.daemon = True
        t.start()
Exemplo n.º 3
0
    def rpc(self, dest, method, args=None, kwargs=None):
        """ Make an RPC call to the named subscriber, expecting a
        response.  This opens a
        :class:`multiprocessing.connection.Listener` and passes the
        Listener address to the child as part of the RPC call, so that
        the child can connect to the Listener to submit its results.

        Listeners are reused when possible to minimize overhead.
        """
        try:
            listener = self._available_listeners.get_nowait()
            self.logger.debug("Reusing existing RPC listener at %s" %
                              listener.address)
        except Empty:
            listener = Listener()
            self.logger.debug("Created new RPC listener at %s" %
                              listener.address)
        self._blocking_listeners.append(listener)
        try:
            self._queues[dest].put((listener.address,
                                    (method, args or [], kwargs or dict())))
            conn = listener.accept()
            self._blocking_listeners.remove(listener)
            try:
                while not self._terminate.is_set():
                    if conn.poll(self.poll_wait):
                        return conn.recv()
            finally:
                conn.close()
        finally:
            self._available_listeners.put(listener)
Exemplo n.º 4
0
def main():
    setproctitle('graph4py.rpc')
    parser = argparse.ArgumentParser(description='Run Graph4Py graph server')
    parser.add_argument(
        '--version',
        '-v',
        action='version',
        version=__version__
    )
    parser.add_argument('host')
    parser.add_argument('port', type=int)
    parser.add_argument('backend')
    parser.add_argument('path')
    parser.add_argument('--authkey', '-k', action='store')
    parser.add_argument('--graph', '-g', action='store')
    args = parser.parse_args()

    graph_class = import_object(args.graph) if args.graph else None

    database = Graph4Py(args.backend, args.path, args.authkey, graph_class)

    def signal_handler(s, frame):
        database.close()
        sys.exit(0)
    signal.signal(signal.SIGINT, signal_handler)

    listener = Listener((args.host, args.port), family='AF_INET')
    print 'Running on %s:%s with %s' % (args.host, args.port, database.graph)

    while True:
        connection = listener.accept()
        database.process(connection)
Exemplo n.º 5
0
def main():
    _setproctitle('structurarium.graph')
    parser = argparse.ArgumentParser(description='Run Structurarium graph server')
    parser.add_argument('--version', '-v', action='version', version=__version__)
    parser.add_argument('host')
    parser.add_argument('port', type=int)
    parser.add_argument('path')
    parser.add_argument('--authkey', '-k', action='store')
    parser.add_argument(
        '--worker',
        '-w',
        action='store',
        type=int,
        help='default is set to the number of CPU'
    )
    args = parser.parse_args()
    listener = Listener((args.host, args.port), family='AF_INET')
    database = Graph(args.path, authkey=args.authkey)
    pool = Pool(processes=args.worker)

    print 'Running on %s:%s' % (args.host, args.port)
    while True:
        connection = listener.accept()
        connection = reduce_connection(connection)
        # pool.apply_async(connect, [database, connection])
        connect(database, connection)
Exemplo n.º 6
0
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()
Exemplo n.º 7
0
    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()
Exemplo n.º 8
0
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()
Exemplo n.º 9
0
 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()
Exemplo n.º 10
0
def objectLogger(params):
    """ Send data (dict, str, ...) into a storage """
    mode = params['mode']
    maxlen = params['maxlen']
    file_format = params['format']
    home_dir = params['storage_dir']
    server = Listener((params['ip'], int(params['port'])))
    storage = PersistentDeque(
        home_dir=home_dir,
        maxlen=maxlen,
        file_format=file_format,
        mode=mode,
    )
    while True:
        conn = server.accept()
        while True:
            try:
                data = conn.recv()
            except EOFError:
                break
            if data:
                storage.append(data)
            else:
                storage.sync(id_generator())
                storage = PersistentDeque(
                    home_dir=home_dir,
                    maxlen=maxlen,
                    file_format=file_format,
                    mode=mode,
                )
        conn.close()
Exemplo n.º 11
0
 def start(self):
     address = ('localhost', 6000)
     listener = Listener(address)
     conn = listener.accept()
     while True:
         msg = conn.recv()
         self.log_id += 1
         self.log_file.add_row(LogEntry([self.node_id, self.log_id, msg]))
Exemplo n.º 12
0
 def _listenThread(self):
     address = ('localhost', self.port)     # family is deduced to be 'AF_INET'
     listener = Listener(address, authkey=self.pwd)
     while True:
         conn = listener.accept()
         self._printDebug('MultiBus,Listner: connection accepted from' + str(listener.last_accepted))
         p = Process(target=self._connThread, args=(conn,))
         p.start()
Exemplo n.º 13
0
 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()
Exemplo n.º 14
0
def echo_server(address, authkey):
    serv = Listener(address, authkey=authkey)
    while True:
        try:
            client = serv.accept()
            echo_client(client)
        except Exception:
            traceback.print_exc()
Exemplo n.º 15
0
    def run(self):
        listener = Listener(self.address, self.family)

        while True:
            conn = listener.accept()
            t = threading.Thread(target=self._handle_conn, args=(conn,))
            t.daemon = True
            t.start()
Exemplo n.º 16
0
def send(msg):
    address = ('localhost', 6000)
    listener = Listener(address)
    conn = listener.accept()
    conn.send(msg)

    conn.close()
    listener.close()
Exemplo n.º 17
0
 def run(self):
     serv = Listener(self.address,authkey=self.authkey)
     while True:
         try:
             client = serv.accept()
             DispatchClientTask(client).start()
         except Exception as e:
             self.log.info("Error : %s", e, exc_info=True)
Exemplo n.º 18
0
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
Exemplo n.º 19
0
def client_listener():
    cl = Listener(address=local_listener[0], authkey=local_listener[1])
    print '.............client listener starting' 
    print '.............accepting conexions'
    while True:
        conn = cl.accept()
        print '.............connection accepted from', cl.last_accepted        
        m = conn.recv()
        print '.............message received from server', m 
Exemplo n.º 20
0
 def run(self):
     listen = Listener(self._address)
     print 'simplepycache server start to listen at', self._address
     cleaner = self.Cleaner(self)
     cleaner.deamon = True
     cleaner.start()        
     while True:
         conn = listen.accept()
         self.Worker(self, conn).start()
Exemplo n.º 21
0
 def run(self):
     server = Listener( ('', 25000) )
     logging.getLogger("thread-listener").info("Connection listener initialized.")
     while self.RUN:
         try:
             client = server.accept()
             logging.getLogger("thread-listener").debug("Client connecting...")
             self.echo_client(client)
         except Exception:
             traceback.print_exc()
Exemplo n.º 22
0
 def __init__ (self):   
     from app import APP
     self.logger = APP.LoggingClient(name="UIHUB")
     addr = APP.Functions.parse_socket_address ( APP.BE.CLI.server_address )
     try: os.unlink (addr)
     except: pass
     self.logger( "Starting. Listening on {0}".format (addr) )
     Listener.__init__(self, addr)
     self.queue = ThreadingQueue.Queue(1024)
     self.workers = [CLIWorker(self.queue, self.logger) for i in range(0,5)]
Exemplo n.º 23
0
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
Exemplo n.º 24
0
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 listener():
    address = ('10.33.41.112', 6666)
    listener = Listener(address, backlog=100, authkey='hellokey')
    while True:
        conn = listener.accept()
        #print 'connection accepted from', listener.last_accepted
        try:
            conn.send({'1':2, '2':'abc'})
        except Exception, e:
            print e
        finally:
Exemplo n.º 26
0
 def listen_code(self):
     listener = Listener(address=self._address, family='AF_UNIX')
     while not self.quit.isSet():
         self.code_channel = listener.accept()
         while not self.quit.isSet():
             try:
                 msg = self.code_channel.recv()
                 self.code_lines.append(msg)
             except EOFError:
                 # client exited but it may be started again
                 continue
Exemplo n.º 27
0
    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()
Exemplo n.º 28
0
 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
Exemplo n.º 30
0
 def run(self):
     try:
         server_c = Listener(self.address, authkey=self.authkey)
         while True:
             client_c = server_c.accept()
             clientaddress = server_c.last_accepted
             handler = ClientHandler(client_c, self.lockSettingsInstance, clientaddress)
             handler.setOutputFrequencySignal.connect( self.lockSettingsInstance.setOutputFrequencyGui )
             handler.setHarmonicSignal.connect(self.lockSettingsInstance.setHarmonicGui)
             handler.start()
     except Exception as e:
         logging.getLogger(__name__).exception(e)  
Exemplo n.º 31
0
class server(object):
    def __init__(self, logger, endpoint=('localhost', 6000), authkey=None):
        self.logger = logger

        self.listener = Listener(endpoint, authkey=authkey)
        self.port = endpoint[1]

        self.sender_queue = Queue()
        self.receiver_queue = Queue()

    def start(self):
        self.logger.debug('waiting for connection')
        self.conn = self.listener.accept()
        self.logger.debug('Connection accepted from ' +
                          str(self.listener.last_accepted))

        self.sender = Thread(target=_sender,
                             args=(self.conn, self.sender_queue))
        self.sender.setName("sender server " + str(self.port))
        self.sender.start()

        self.receiver = Thread(target=_receiver,
                               args=(self.conn, self.receiver_queue))
        self.receiver.setName("receiver server " + str(self.port))
        self.receiver.start()
Exemplo n.º 32
0
def main(args=sys.argv):
    gui_debug = None
    if args[0] == '__CALIBRE_GUI_DEBUG__':
        gui_debug = args[1]
        args = ['calibre']

    try:
        app, opts, args, actions = init_qt(args)
    except AbortInit:
        return 1
    from calibre.utils.lock import singleinstance
    from multiprocessing.connection import Listener
    si = singleinstance('calibre GUI')
    if si and opts.shutdown_running_calibre:
        return 0
    if si:
        try:
            listener = Listener(address=gui_socket_address())
        except socket.error:
            if iswindows:
                cant_start()
            if os.path.exists(gui_socket_address()):
                os.remove(gui_socket_address())
            try:
                listener = Listener(address=gui_socket_address())
            except socket.error:
                cant_start()
            else:
                return run_gui(opts, args, actions, listener, app,
                        gui_debug=gui_debug)
        else:
            return run_gui(opts, args, actions, listener, app,
                    gui_debug=gui_debug)
    otherinstance = False
    try:
        listener = Listener(address=gui_socket_address())
    except socket.error:  # Good si is correct (on UNIX)
        otherinstance = True
    else:
        # On windows only singleinstance can be trusted
        otherinstance = True if iswindows else False
    if not otherinstance and not opts.shutdown_running_calibre:
        return run_gui(opts, args, actions, listener, app, gui_debug=gui_debug)

    communicate(opts, args)

    return 0
Exemplo n.º 33
0
def main():
    firebase_connector = FirebaseConnector()
    log("Firebase connection ready")

    visitor_info = firebase_connector.get_visitor_info()
    log("Got visitor info")

    if not CONFIG["super-debug"]["dont_redownload_visitor_photos"]:
        firebase_connector.get_visitor_photos(visitor_info)
        log("Finished getting visitor photos")
    else:
        log("Skipping getting visitor photos per config")

    if not CONFIG["super-debug"]["dont_reprocess_visitor_faces"]:
        known_face_encodings, known_face_names = process_visitor_images(visitor_info)
    else:
        log("Attempting to skip processing visitor faces per config")
        try:
            visitor_faces_pickle = open(
                CONFIG["super-debug"]["visitor_faces_pickle"],
                'rb'
            )
            saved_face_data = pickle.load(visitor_faces_pickle)
            known_face_encodings, known_face_names = saved_face_data
            log("Loaded saved visitor face data")
        except FileNotFoundError:
            log("Failed to load visitor face data, generating and saving it")
            known_face_encodings, known_face_names = process_visitor_images(visitor_info)
            visitor_faces_pickle = open(
                CONFIG["super-debug"]["visitor_faces_pickle"],
                'wb'
            )
            face_data = (known_face_encodings, known_face_names)
            pickle.dump(face_data, visitor_faces_pickle)

    try:
        os.unlink('/tmp/buzz_socket')
    except FileNotFoundError:
        pass

    while True:
        with Listener(CONFIG["core"]["socket"], "AF_UNIX") as listener:
            log("Ready to accept connections")
            with listener.accept() as conn:
                received_signal = conn.recv()

                if CONFIG["core"]["debug"]:
                    log(f"Received signal: {received_signal}")

                if received_signal == "event_start":
                    handle_motion(firebase_connector, known_face_encodings, known_face_names)
                elif received_signal == "event_end" and CONFIG["core"]["debug"]:
                    notification_response = firebase_connector.send_notification(
                        "DEBUG: Motion event ended.")
                    log(f"Notification {notification_response} sent")
                elif "movie_end" in received_signal:
                    log(f"Video file ended {received_signal.split(' ')[1]}")
                    firebase_connector.upload_to_storage(received_signal.split(' ')[1])
                    log(f"Uploaded video file to Firebase Storage")
Exemplo n.º 34
0
    def receive_loop(self):
        try:
            address = ('localhost', 6001)
            listener = Listener(address, authkey=b'password')
            conn = listener.accept()

            while self.thread:
                msg = conn.recv()
                if isinstance(msg, str):
                    t = threading.Thread(target=self.r, args=(msg, ))
                    # t.start()
                else:
                    send = msg.pop('send')
                    read = msg.pop('read')
                    stream = msg.pop('stream')

                    print("send: ", send)
                    print("read: ", read)
                    print("stream: ", stream)

                    address = msg.pop('mac_addr', None)
                    if address is not None:
                        #                         self.last_activity = time.time()
                        if not self.is_connected_to_device(address):
                            self.connect_to_device(address)

                        if send and stream and not read:
                            t = threading.Thread(target=self.r,
                                                 args=(address, ))
                            t.start()

                        elif send and not read:
                            data = msg
                            t = threading.Thread(target=self.s,
                                                 args=(address, data))
                            t.start()

                        elif send and read:
                            data = msg
                            t = threading.Thread(target=self.s_t_r,
                                                 args=(address, data))
                            t.start()

            listener.close()
        except Exception as e:
            print(e)
Exemplo n.º 35
0
def listen():
    listener = Listener(('localhost', 6000), authkey=b'secret')
    conn = listener.accept()
    while True:
        msg = conn.recv()
        print("received: {}".format(msg))
        if msg == 'close':
            break

        if msg[0] == 'video':
            subprocess.Popen(['vlc', msg[1], '--fullscreen'])
        elif msg[0] == 'website':
            subprocess.Popen(['firefox', msg[1]])
        elif msg[0] == 'video-pause':
            requests.get('http://127.0.0.1:8080/requests/status.xml?command=pl_pause')
        elif msg[0] == 'video-stop':
            requests.get('http://127.0.0.1:8080/requests/status.xml?command=pl_stop')
Exemplo n.º 36
0
def server(address, port):
    server = Listener(address, authkey=b"peekaboo")
    conn = server.accept()
    worker_pid = conn.recv()

    print(f"Server : Worked PID {worker_pid}")

    # This is how socket.socket() is generally used to return new socket fd
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
    s.bind(('', port))
    s.listen(1)
    while True:
        client, address = s.accept()
        print(f"Server got connection from {address}")
        send_handle(conn, client.fileno(), worker_pid)
        client.close()
Exemplo n.º 37
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()
Exemplo n.º 38
0
	def __init__(self, port, hostname=None, **kwargs):
		address = ('localhost', port)     # family is deduced to be 'AF_INET'
		if hostname is None:
			hostname = "{}:{}".format(socket.gethostname(), port)
			
		self.hostname = hostname
		self.listener = Listener(address, authkey='secret password')
		Thread(target=self.accept_wait, name="accept_wait", args=(self.listener,)).start()
Exemplo n.º 39
0
 def __init__(self, job_handler: Callable[[TJob], None], query_handler: Callable[[TQuery], Any],
              max_queue_size=50, timeout=5):
     """
     @param job_handler: The callback for when a new job is received
     @param query_handler: The callback for when a new query is received
     @param max_queue_size: The maximum number of instructions in the queue before the next one is dropped
     @param timeout: The amount of time to wait to place a job/query on the queue before dropping it (if full)
     """
     self.job_handler = job_handler
     self.query_handler = query_handler
     self.listener = Listener(Config.address)
     self.connection = None
     self.job_queue = Queue(maxsize=max_queue_size)
     # Possible issue: if queries are dropped, the server may become out of sync with the worker,
     # as is expects are response for each query and is not guaranteed one
     self.query_queue = Queue(maxsize=max_queue_size)
     self.timeout = timeout
Exemplo n.º 40
0
	def start(self):
		# setup listener
		logger.info('Server starting %s at %s', os.getpid(), SERVER_ADDRESS)
		#~ authkey = multiprocessing.current_process().authkey
		#~ fh = open(AUTHKEY_FILE.path, 'w')
		#~ fh.write(authkey)
		#~ fh.close()
		#~ print "SERVER >>%s<<" % authkey

		if SERVER_ADDRESS_FAMILY == 'AF_UNIX' \
		and os.path.exists(SERVER_ADDRESS):
			# Clean up old socket (someone should already have checked
			# before whether or not it is functional)
			os.unlink(SERVER_ADDRESS)

		#~ self.listener = Listener(SERVER_ADDRESS, authkey=authkey)
		self.listener = Listener(SERVER_ADDRESS)
    def __init__(self, conf):
        # initialize config params
        self.batch_interval = conf['batch_interval']
        self.window_length = conf['window_length']
        self.sliding_interval = conf['sliding_interval']
        self.sm_socket = tuple(conf['sm_socket'])
        self.sm_listener = Listener(self.sm_socket)
        self.op_handler_socket = conf['op_handler_socket']

        self.spark_stream_address = conf['spark_stream_address']
        self.spark_stream_port = conf['spark_stream_port']

        self.start_time = time.time()

        self.sc = SparkContext(appName="Sonata-Streaming")
        self.sc.setLogLevel("OFF")
        self.ssc = StreamingContext(self.sc, self.batch_interval)
Exemplo n.º 42
0
def handler():
    this.LOGGER.info('START RECEIVER')
    address = ('localhost', 6000)  # family is deduced to be 'AF_INET'
    this.listener = Listener(address, authkey=b'12345')
    this.LOGGER.info('START ACCEPT')
    this.conn = this.listener.accept()
    this.LOGGER.info('START THREADING')
    thread.start_new_thread(messageHandler, (this.conn))
Exemplo n.º 43
0
    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()
Exemplo n.º 44
0
 def run(self):
     with Listener(*constants.XWARED_SOCKET) as listener:
         while True:
             with listener.accept() as conn:
                 func, args, kwargs = conn.recv()
                 response = getattr(self._xwared,
                                    "interface_" + func)(*args, **kwargs)
                 conn.send(response)
Exemplo n.º 45
0
class StreamReceiver:
    def __init__(self, streamq):
        self.streamq = streamq
        self.run()

    def openconnection(self):
        address = ('localhost', 3140)
        print "[INIT] Opening connection on %s)" % str(address)
        self._LISTENER = Listener(address, authkey='1kdw91l')
        self._CONN = self._LISTENER.accept()
        return self._CONN

    def run(self):
        while True:
            try:
                conn = self.openconnection()
                self.serve(conn)
            except EOFError:
                conn.close()
                self._LISTENER.close()
                print "Connection terminated by client"

    def serve(self, conn):
        while True:
            msg = conn.recv()
            if msg == 'TERMINATE':
                print 'terminate received'
                self.finalize()
                conn.send("OK")
                conn.close()
                break

            resp = self.dispatch(msg)
            conn.send(resp)

    # expects format: {msg:'BLOCK', block:DATA}
    def dispatch(self, msg):
        cmd = msg['msg']
        data = msg['block']
        if cmd == 'BLOCK':
            self.streamq.addblock(data)
            return 'OK'
        return 'NOK'

    def finalize(self):
        pass
Exemplo n.º 46
0
 def _server(self):
     logger.info('Starting OM messaging service...')
     self._stop = False
     while not self._stop:
         try:
             conn = self.listener.accept()
             logger.info('connection accepted from {0}'.format(self.listener.last_accepted))
             receiver = Thread(target=self._receiver, args=(conn,))
             receiver.daemon = True
             receiver.start()
         except IOError as io_error:
             logger.error('IOError in accepting connection: {0}'.format(io_error))
         except Exception as e:
             logger.exception('Error in message service. Restarting...')
             self.listener.close()
             time.sleep(1)
             self.listener = Listener(self.address, authkey=self.authkey)
Exemplo n.º 47
0
def server(address, port, t, ang, fes, start_time, running, imu_data):
    serv = Listener((address, port))
    # s = socket.socket()
    # s.bind(address)
    # s.listen()
    while running.value:
        # client, addr = s.accept()
        client = serv.accept()
        print('Connected to {}'.format(serv.last_accepted))
        source = client.recv()
        print('Source: {}'.format(source))
        p = multiprocessing.Process(target=do_stuff, args=(client, source, t, ang, fes, start_time, running, imu_data))
        # do_stuff(client, addr)
        p.start()

        # signal.pause()
    print('End of process server')
Exemplo n.º 48
0
def server():
    address = ('localhost', 6000)  # family is deduced to be 'AF_INET'
    with Listener(address, authkey=b'secret password') as listener:
        with listener.accept() as conn:
            print('connection accepted from', listener.last_accepted)
            conn.send([2.25, None, 'junk', float])
            conn.send_bytes(b'hello')
            conn.send_bytes(array('i', [42, 1729]))
Exemplo n.º 49
0
def server(work_address, port):
    # Wait for the worker to connect
    work_serv = Listener(work_address, authkey=b'peekaboo')
    worker = work_serv.accept()
    worker_pid = worker.recv()

    # Now run a TCP/IP server and send clients to worker
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
    s.bind(('', port))
    s.listen(1)
    while True:
        client, addr = s.accept()
        print('SERVER: Got connection from', addr)

        send_handle(worker, client.fileno(), worker_pid)
        client.close()
Exemplo n.º 50
0
def _recv_align_result(host):
    """
    Receive align result from receiver.

    :param host: str. The host who is waiting for align result.
    The host is represented as "id:ip:port".
    :return: set. The received align result.
    """
    from multiprocessing.connection import Listener
    ip_addr = host.split(":")[1]
    port = int(host.split(":")[2])
    server = Listener((ip_addr, port))
    conn = server.accept()
    result = conn.recv()
    conn.close()
    server.close()
    return result
Exemplo n.º 51
0
def exploration():
    """Plot q-table and game board for reference during exploration."""
    fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(10, 5))
    plt.ion()
    plt.show()
    address = ('localhost', 6000)  # family is deduced to be 'AF_INET'
    listener = Listener(address, authkey=b'secret password')
    conn = listener.accept()
    print('connection accepted from {}'.format(listener.last_accepted))

    while True:
        msg = conn.recv()
        ax1.clear()
        ax2.clear()
        q_table = msg['q_table']
        game_board = msg['game_board']
        cords = msg['cords']
        action = msg['action']

        next_state = map_action_to_next_state(cords, action)
        print('State: {}    action: {}    next {}'.format(
            cords, action, next_state))
        next_row = int(next_state[1])
        next_col = next_state[0]
        row = int(cords[1])
        col = cords[0]

        game_board.loc[row, col] = -3  # Mark current state on a game board
        game_board.loc[next_row,
                       next_col] = -2  # mark next state on a game board

        # Plot q-table and game board as heatmaps
        sns.heatmap(q_table,
                    ax=ax1,
                    cbar=False,
                    vmin=-200,
                    vmax=200,
                    annot=True)
        sns.heatmap(game_board,
                    ax=ax2,
                    cbar=False,
                    vmin=-3,
                    vmax=3,
                    annot=True)
        plt.draw()
        plt.pause(0.1)
Exemplo n.º 52
0
 def run(self):
     global PROCESS_STATUS
     listener = Listener((self.ip, self.port))
     while True:
         try:
             conn = listener.accept()
             new_status = int(conn.recv())
             if new_status in [
                     PROCESS_STATUS_RUN, PROCESS_STATUS_PAUSE,
                     PROCESS_STATUS_FINISH, PROCESS_STATUS_STOP
             ]:
                 PROCESS_STATUS = new_status
         except IOError:
             pass
         finally:
             conn.close()
     listener.close()
Exemplo n.º 53
0
class IPCServer(Thread):
    """
    This is (sort of?) a barebones implementation of a reverse pub/sub
    pattern: multiple publishers can connect to this and it dispatches
    the events to registered subscribers.

    Why? Cause miss me with that zeromq shit.
    """

    def __init__(self, address=('localhost', 60000), authkey=ipc_pass):
        Thread.__init__(self)
        self.name = 'IPCServer'
        self.address = address
        self.listener = Listener(self.address, authkey=authkey)
        self.daemon = True
        self.subscribers = {}

    def run(self):
        logging.debug(f"Started IPC server on {self.address}")
        while True:
            client = self.listener.accept()

            t = Thread(target=self.serve, args=(client,))
            t.setDaemon(True)
            t.start()

    def attach(self, event, func):
        if event not in self.subscribers:
            self.subscribers[event] = set()
            self.subscribers[event].add(func)
        else:
            self.subscribers[event].add(func)

    def detach(self, event, func):
        raise NotImplemented

    def publish(self, topic, msg):
        if topic in self.subscribers:
            for sub in self.subscribers[topic]:
                #run_in_terminal(functools.partial(sub, msg))
                return sub(msg)

    def serve(self, client):
        logging.debug(f"connection accepted from {self.listener.last_accepted}")
        while True:
            try:
                data = client.recv()
            except EOFError:
                pass

            topic, msg = data
            logging.debug(f"Got event: {topic} msg: {msg}")
            if topic in self.subscribers:
                for sub in self.subscribers[topic]:
                    future = run_in_terminal(functools.partial(sub, msg))
                    future.add_done_callback(functools.partial(lambda f, c: c.send(f.result()), c=client))
            else:
                logging.debug(f"Got event: {topic}, but there's nothing subscribed")
Exemplo n.º 54
0
class Server:
    def __init__(self, camera, board_length, board_width, board_orientation=None, debug=False):
        self.camera = camera
        self.debug = debug

        # Listener
        self.address = 'localhost'
        #self.address = '0.0.0.0'
        if board_orientation == 'left':
            self.port = 6001
        elif board_orientation == 'right':
            self.port = 6002
        else:
            self.port = 6000
        self.listener = Listener((self.address, self.port), authkey=b'secret password')

        # Boards
        suffix = '' if board_orientation is None else '_{}'.format(board_orientation)
        self.robot_board = Board('robots' + suffix, board_length, board_width, board_orientation, 0.036)
        self.cube_board = Board('cubes' + suffix, board_length, board_width, board_orientation, 0.012)

    def initialize_boards(self):
        boards = [self.robot_board, self.cube_board]
        for board in boards:
            board.reset()
        while not all(board.initialized for board in boards):
            image = self.camera.read()
            for board in boards:
                if not board.initialized:
                    board.initialize(image, debug=self.debug)

    def run(self):
        try:
            while True:
                # Connect to client
                print('Waiting for connection ({}:{})'.format(self.address, self.port))
                conn = self.listener.accept()
                print('Connected!')

                # Initialize boards
                self.initialize_boards()

                # Send pose estimates
                debug_data = None
                while True:
                    start_time = time.time()
                    try:
                        debug_data = conn.recv()  # Wait for request
                        image = self.camera.read()
                        robot_poses = self.robot_board.get_marker_poses(image, debug_data=debug_data, debug=self.debug)
                        cube_poses = self.cube_board.get_marker_poses(image, debug_data=debug_data, debug=self.debug)
                        conn.send((robot_poses, cube_poses))
                    except (ConnectionResetError, EOFError):
                        break
                    print('{:.1f} ms'.format(1000 * (time.time() - start_time)))
        finally:
            self.camera.release()
            cv2.destroyAllWindows()
Exemplo n.º 55
0
class MJPEGServer:
    def __init__(
        self,
        input_address: _Address,
        http_address: _Address,
        max_fps: Optional[int] = None,
    ):
        self._publisher = Publisher()
        self._http_server = _MJPEGHTTPServer(http_address, self._publisher,
                                             max_fps)
        self._listener = Listener(input_address)

    @property
    def input_address(self):
        return self._listener.address

    @property
    def http_address(self):
        return self._http_server.server_address

    def _listener_thread(self):
        try:
            with self._listener:
                while True:
                    logger.debug("Waiting for data source to connect...")
                    conn = self._listener.accept()
                    logger.info("Source connection accepted.")
                    receiver = threading.Thread(target=self._receiver_thread,
                                                args=(conn, ),
                                                daemon=True)
                    receiver.start()
                    time.sleep(1)

        except:  # pragma: no cover
            self.shutdown()
            traceback.print_exc()

    def _receiver_thread(self, conn: Connection):
        with conn:
            while True:
                try:
                    buf = conn.recv_bytes()
                except EOFError:
                    break
                channel, data = unpack_message(buf)
                logger.debug("Received data from %s.", channel)
                self._publisher.publish(channel, data)
        logger.info("Source connection closed.")

    def serve_forever(self, poll_interval: float = 0.5) -> None:
        listener_thread = threading.Thread(target=self._listener_thread,
                                           daemon=True)
        listener_thread.start()

        self._http_server.serve_forever(poll_interval=poll_interval)

    def shutdown(self):
        self._http_server.shutdown()
Exemplo n.º 56
0
 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.')    
Exemplo n.º 57
0
    def run(self):
        """
        The supervisor process starts all its assigned processes
        as its children and monitors their work.
        """
        # Double-fork allows background running
        if fork() != 0:
            return

        # Declare signal handler
        signal(SIGTERM, self.sighandler)
        signal(SIGINT, self.sighandler)

        # Create PID file
        with open(AppConfig.PID_LOCATION, 'w') as pidfile:
            pidfile.write(str(getpid()))

        # Create UNIX_AF listening thread
        unixsock = Listener(AppConfig.UNIX_SOCKET, 'AF_UNIX')

        # Spawn listener thread
        UnixListener(unixsock, self.assigned).start()

        # Main Loop
        while self.canSupervise():

            # Monitor assigned consumers every 10 sec
            self.monitInstances()

            # Sleep 10 sec
            time.sleep(1)

        print('Supervisor: Stoping all children....')

        # Stop all running consumers
        for process in self.assigned.keys():
            while len(self.assigned[process]['running']) > 0:
                self.stopInstance(process)
                time.sleep(0.2)

        # Close unixsocket
        unixsock.close()

        # Close everything / remove PID file
        unlink(AppConfig.PID_LOCATION)
Exemplo n.º 58
0
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
Exemplo n.º 59
0
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"
Exemplo n.º 60
0
    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()