Python connection.Listener方法代码示例

# 需要导入模块: from multiprocessing import connection [as 别名]
# 或者: from multiprocessing.connection import Listener [as 别名]
def main():
    global arpListener, config

    parser = argparse.ArgumentParser()
    parser.add_argument('dir', help='the directory of the example')
    args = parser.parse_args()

    # locate config file
    config_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),"..","examples",args.dir,"config","sdx_global.cfg")

    logger.info("Reading config file %s", config_file)
    config = parse_config(config_file)

    logger.info("Starting ARP Listener")
    arpListener = ArpListener()
    ap_thread = Thread(target=arpListener.start)
    ap_thread.start()

    # start pctrl listener in foreground
    logger.info("Starting PCTRL Listener")
    pctrlListener = PctrlListener()
    pctrlListener.start() 

# 需要导入模块: from multiprocessing import connection [as 别名]
# 或者: from multiprocessing.connection import Listener [as 别名]
def test_issue14725(self):
        l = self.connection.Listener()
        p = self.Process(target=self._test, args=(l.address,))
        p.daemon = True
        p.start()
        time.sleep(1)
        # On Windows the client process should by now have connected,
        # written data and closed the pipe handle by now.  This causes
        # ConnectNamdedPipe() to fail with ERROR_NO_DATA.  See Issue
        # 14725.
        conn = l.accept()
        self.assertEqual(conn.recv(), 'hello')
        conn.close()
        p.join()
        l.close()

#
# Test of sending connection and socket objects between processes
# 

# 需要导入模块: from multiprocessing import connection [as 别名]
# 或者: from multiprocessing.connection import Listener [as 别名]
def test_timeout(self):
        old_timeout = socket.getdefaulttimeout()
        try:
            socket.setdefaulttimeout(0.1)
            parent, child = multiprocessing.Pipe(duplex=True)
            l = multiprocessing.connection.Listener(family='AF_INET')
            p = multiprocessing.Process(target=self._test_timeout,
                                        args=(child, l.address))
            p.start()
            child.close()
            self.assertEqual(parent.recv(), 123)
            parent.close()
            conn = l.accept()
            self.assertEqual(conn.recv(), 456)
            conn.close()
            l.close()
            p.join(10)
        finally:
            socket.setdefaulttimeout(old_timeout)

#
# Test what happens with no "if __name__ == '__main__'"
# 

# 需要导入模块: from multiprocessing import connection [as 别名]
# 或者: from multiprocessing.connection import Listener [as 别名]
def _get_listener():
    global _listener

    if _listener is None:
        _lock.acquire()
        try:
            if _listener is None:
                debug('starting listener and thread for sending handles')
                _listener = Listener(authkey=current_process().authkey)
                t = threading.Thread(target=_serve)
                t.daemon = True
                t.start()
        finally:
            _lock.release()

    return _listener 

# 需要导入模块: from multiprocessing import connection [as 别名]
# 或者: from multiprocessing.connection import Listener [as 别名]
def _listener(cls, conn, families):
        for fam in families:
            l = cls.connection.Listener(family=fam)
            conn.send(l.address)
            new_conn = l.accept()
            conn.send(new_conn)
            new_conn.close()
            l.close()

        l = socket.socket()
        l.bind((test.support.HOST, 0))
        l.listen()
        conn.send(l.getsockname())
        new_conn, addr = l.accept()
        conn.send(new_conn)
        new_conn.close()
        l.close()

        conn.recv() 

# 需要导入模块: from multiprocessing import connection [as 别名]
# 或者: from multiprocessing.connection import Listener [as 别名]
def __init__(self, server=None, authkey='klustakwik',
                 global_ns=None, local_ns=None, level=0):
        if multiprocessing is None:
            raise ImportError('Cannot import the required multiprocessing module.')
        if server is None:
            server = ('localhost', 2719)
        frame = inspect.stack()[level + 1][0]
        ns_global, ns_local = frame.f_globals, frame.f_locals
        if global_ns is None:
            global_ns = frame.f_globals
        if local_ns is None:
            local_ns = frame.f_locals
        self.local_ns = local_ns
        self.global_ns = global_ns
        self.listener = Listener(server, authkey=authkey)
        self.conn = None 

# 需要导入模块: from multiprocessing import connection [as 别名]
# 或者: from multiprocessing.connection import Listener [as 别名]
def _listener(cls, conn, families):
        for fam in families:
            l = cls.connection.Listener(family=fam)
            conn.send(l.address)
            new_conn = l.accept()
            conn.send(new_conn)
            new_conn.close()
            l.close()

        l = socket.socket()
        l.bind((test.support.HOST, 0))
        l.listen(1)
        conn.send(l.getsockname())
        new_conn, addr = l.accept()
        conn.send(new_conn)
        new_conn.close()
        l.close()

        conn.recv() 

# 需要导入模块: from multiprocessing import connection [as 别名]
# 或者: from multiprocessing.connection import Listener [as 别名]
def attach_debugger(host='localhost', port=6000, authkey='secret password'):
    import gluon.contrib.qdb as qdb
    import gluon.debug
    from multiprocessing.connection import Listener

    if isinstance(authkey, unicode):
        authkey = authkey.encode('utf8')

    if not hasattr(gluon.debug, 'qdb_listener'):
        # create a remote debugger server and wait for connection
        address = (host, port)     # family is deduced to be 'AF_INET'
        gluon.debug.qdb_listener = Listener(address, authkey=authkey)
        gluon.debug.qdb_connection = gluon.debug.qdb_listener.accept()
        # create the backend
        gluon.debug.qdb_debugger = qdb.Qdb(gluon.debug.qdb_connection)
        gluon.debug.dbg = gluon.debug.qdb_debugger
        # welcome message (this should be displayed on the frontend)
        print 'debugger connected to', gluon.debug.qdb_listener.last_accepted
    return True     # connection successful! 

# 需要导入模块: from multiprocessing import connection [as 别名]
# 或者: from multiprocessing.connection import Listener [as 别名]
def __init__(self, logger):
        self.logger = logger

        self.listener = Listener(('localhost', 6000), authkey='xrs', backlog=100)

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

# 需要导入模块: from multiprocessing import connection [as 别名]
# 或者: from multiprocessing.connection import Listener [as 别名]
def __init__(self):
        logger.info("Initializing the BGP PctrlListener")
        self.listener = Listener(config.ah_socket, authkey=None, backlog=100)
        self.run = True 

# 需要导入模块: from multiprocessing import connection [as 别名]
# 或者: from multiprocessing.connection import Listener [as 别名]
def __init__(self):
        # "Set listener for ARP replies from the participants' controller"
        logger.info("Starting the PctrlListener")
        self.listener_garp = Listener(config.garp_socket, authkey=None, backlog=100) 

# 需要导入模块: from multiprocessing import connection [as 别名]
# 或者: from multiprocessing.connection import Listener [as 别名]
def __init__(self, address, port, logger):
        self.logger = logger
        self.listener = Listener((address, port), backlog=100) 

# 需要导入模块: from multiprocessing import connection [as 别名]
# 或者: from multiprocessing.connection import Listener [as 别名]
def test_rapid_restart(self):
        authkey = os.urandom(32)
        manager = QueueManager(
            address=(test.support.HOST, 0), authkey=authkey, serializer=SERIALIZER)
        srvr = manager.get_server()
        addr = srvr.address
        # Close the connection.Listener socket which gets opened as a part
        # of manager.get_server(). It's not needed for the test.
        srvr.listener.close()
        manager.start()

        p = self.Process(target=self._putter, args=(manager.address, authkey))
        p.start()
        p.join()
        queue = manager.get_queue()
        self.assertEqual(queue.get(), 'hello world')
        del queue
        manager.shutdown()

        manager = QueueManager(
            address=addr, authkey=authkey, serializer=SERIALIZER)
        manager.start()
        manager.shutdown()

#
#
# 

# 需要导入模块: from multiprocessing import connection [as 别名]
# 或者: from multiprocessing.connection import Listener [as 别名]
def test_listener_client(self):
        for family in self.connection.families:
            l = self.connection.Listener(family=family)
            p = self.Process(target=self._test, args=(l.address,))
            p.daemon = True
            p.start()
            conn = l.accept()
            self.assertEqual(conn.recv(), 'hello')
            p.join()
            l.close() 

# 需要导入模块: from multiprocessing import connection [as 别名]
# 或者: from multiprocessing.connection import Listener [as 别名]
def _test_ignore_listener(cls, conn):
        def handler(signum, frame):
            pass
        signal.signal(signal.SIGUSR1, handler)
        l = multiprocessing.connection.Listener()
        conn.send(l.address)
        a = l.accept()
        a.send('welcome')