Beispiel #1
0
 def test_tcp1(self):
     self.server = pyuv.TCP(self.loop)
     self.server.bind(("0.0.0.0", TEST_PORT))
     self.server.listen(self.on_connection)
     self.client = pyuv.TCP(self.loop)
     self.client.connect(("127.0.0.1", TEST_PORT), self.on_client_connection)
     self.loop.run()
Beispiel #2
0
 def test_tcp_write_cancel(self):
     self.server = pyuv.TCP(self.loop)
     self.server.bind(("0.0.0.0", TEST_PORT))
     self.server.listen(self.on_connection)
     self.client = pyuv.TCP(self.loop)
     self.client.connect(("127.0.0.1", TEST_PORT), self.on_client_connection)
     self.loop.run()
     self.assertEqual(self.write_cb_count, 1024)
Beispiel #3
0
 def test_fileno(self):
     server = pyuv.TCP(self.loop)
     server.bind(("0.0.0.0", TEST_PORT))
     self.check_fileno(server)
     server.listen(self.on_connection)
     client = pyuv.TCP(self.loop)
     client.connect(("127.0.0.1", TEST_PORT), self.on_client_connection)
     self.check_fileno(client)
     self.loop.run()
Beispiel #4
0
 def test_tcp_write_saturate(self):
     if 'TRAVIS' in os.environ:
         self.skipTest("Test disabled on Travis")
         return
     self.server = pyuv.TCP(self.loop)
     self.server.bind(("0.0.0.0", TEST_PORT))
     self.server.listen(self.on_connection)
     self.client = pyuv.TCP(self.loop)
     self.client.connect(("127.0.0.1", TEST_PORT), self.on_client_connection)
     self.loop.run()
Beispiel #5
0
 def test_tcp_shutdown(self):
     self.shutdown_cb_called = 0
     self.close_cb_called = 0
     self.server = pyuv.TCP(self.loop)
     self.server.bind(("0.0.0.0", TEST_PORT))
     self.server.listen(self.on_connection)
     self.client = pyuv.TCP(self.loop)
     self.client.connect(("127.0.0.1", TEST_PORT), self.on_client_connection)
     self.loop.run()
     self.assertEqual(self.shutdown_cb_called, 1)
     self.assertEqual(self.close_cb_called, 3)
Beispiel #6
0
 def test_open(self):
     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     client = pyuv.TCP(self.loop)
     client.open(sock.fileno())
     client.connect(("127.0.0.1", TEST_PORT), self.on_client_connect_error)
     self.loop.run()
     sock.close()
Beispiel #7
0
 def on_connection(self, server, error):
     self.assertEqual(error, None)
     connection = pyuv.TCP(self.loop)
     server.accept(connection)
     while connection.write_queue_size == 0:
         connection.write(b"PING"*1000)
     connection.close(self.on_connection_close)
Beispiel #8
0
    def _on_connection(self, handle, error):
        if error:
            logging.error('_on_connection: {}'.format(error))
            return

        if type(self.socket) == pyuv.TCP:
            client = pyuv.TCP(self.loop)
        else:
            client = pyuv.Pipe(self.loop, True)

        self.socket.accept(client)

        if self.forward_address:
            self.on_connection(client)
        else:
            context = {
                'buffer': [],
                'stage': 0,
                'header': b'',
            }

            client.start_read(
                lambda handle, data, error: self._socks5_read(
                    handle, data, error, context
                ))
Beispiel #9
0
 def test_tcp_flags(self):
     tcp = pyuv.TCP(self.loop)
     tcp.nodelay(True)
     tcp.keepalive(True, 60)
     tcp.simultaneous_accepts(True)
     tcp.close()
     self.loop.run()
Beispiel #10
0
    def connectTCP(self, ip, port, factory, timeout=30, bindAddress=None):
        self.__log.debug("connectTCP: ip = {ip!r}".format(ip=ip))
        #
        p = factory.buildProtocol(addr=(ip, port))
        #
        tcp = pyuv.TCP(self._loop)
        p.transport = tcp
        #
        if bindAddress is not None:
            tcp.bind((bindAddress, port))
        #
        def connect_cb(tcp_handle, error):
            if error:
                reason = pyuv.errno.strerror(error)
                self.__log.error(reason)
                p.connectionLost(reason=reason)
            else:
                p.connectionMade()

                #
                def read_cb(tcp_handle, data, error):
                    if error:
                        reason = pyuv.errno.strerror(error)
                        self.__log.error(reason)
                        p.connectionLost(reason=reason)
                    else:
                        p.dataReceived(data)

                #
                tcp.start_read(read_cb)

        #
        tcp.connect((ip, port), connect_cb)
        #
        return tcp
    def __init__(self, server, endpoint):
        self.server = server

        loop = pyuv.Loop.default_loop()
        self.listenHandle = pyuv.TCP(loop)
        self.listenHandle.bind(endpoint)
        self.listenHandle.listen(self.onConnection)
Beispiel #12
0
 def test_open(self):
     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     loop = pyuv.Loop.default_loop()
     client = pyuv.TCP(loop)
     client.open(sock.fileno())
     client.connect(("127.0.0.1", TEST_PORT), self.on_client_connect_error)
     loop.run()
Beispiel #13
0
 def __init__(self, neighbor, local_address, forward_address=None):
     self.neighbor = neighbor
     self.loop = self.neighbor.manager.loop
     self.local_address = local_address
     self.forward_address = forward_address
     self.associaction = {}
     self.socket = pyuv.TCP(self.loop)
Beispiel #14
0
 def test_client2(self):
     loop = pyuv.Loop.default_loop()
     client = pyuv.TCP(loop)
     self.assertFalse(client.readable)
     self.assertFalse(client.writable)
     client.close()
     loop.run()
Beispiel #15
0
 def on_connection(self, server, error):
     self.assertEqual(error, None)
     client = pyuv.TCP(self.loop)
     server.accept(client)
     self.client_connections.append(client)
     client.start_read(self.on_client_connection_read)
     client.write(b"PING"+linesep)
Beispiel #16
0
 def __init__(self, address=None, port=None):
     self._loop = pyuv.Loop()
     self._error = None
     self._data = None
     self._written = True
     self._connected = False
     self._timed_out = False
     self._timer = pyuv.Timer(self._loop)
     self._timeout_cb = self._on_timeout.__get__(self, UvStream)
     self._read_cb = self._on_read.__get__(self, UvStream)
     self._write_cb = self._on_write.__get__(self, UvStream)
     connect_cb = self._on_connect.__get__(self, UvStream)
     # Select the type of handle
     if port:
         # tcp
         self._stream = pyuv.TCP(self._loop)
         self._stream.connect((address, port), connect_cb)
     elif address:
         # named pipe or unix socket
         self._stream = pyuv.Pipe(self._loop)
         self._stream.connect(address, connect_cb)
     else:
         # stdin/stdout
         self._read_stream = pyuv.Pipe(self._loop) 
         self._read_stream.open(sys.stdin.fileno())
         self._write_stream = pyuv.Pipe(self._loop) 
         self._write_stream.open(sys.stdout.fileno())
Beispiel #17
0
 def on_connection(self, server, error):
     self.assertEqual(error, None)
     client = pyuv.TCP(pyuv.Loop.default_loop())
     server.accept(client)
     self.client_connection = client
     client.start_read(self.on_client_connection_read)
     client.write(b"PING"+common.linesep)
Beispiel #18
0
 def on_connection(self, server, error):
     self.assertEqual(error, None)
     client = pyuv.TCP(self.loop)
     server.accept(client)
     for x in range(1024):
         client.write(b"PING"*1000, self.on_client_write)
     client.close()
     server.close()
Beispiel #19
0
 def on_connection(self, server, error):
     client = pyuv.TCP(pyuv.Loop.default_loop())
     server.accept(client)
     self.client_connections.append(client)
     client.start_read(self.on_client_connection_read)
     client.writelines([
         b"PING1", b"PING2", b"PING3", b"PING4", b"PING5", b"PING\x00\xFF6"
     ])
Beispiel #20
0
 def test_family_unspec2(self):
     client = pyuv.TCP(self.loop, socket.AF_UNSPEC)
     with self.assertRaises(pyuv.error.TCPError):
         client.family
     client.bind(('::1', TEST_PORT))
     self.assertEqual(client.family, socket.AF_INET6)
     client.close()
     self.loop.run()
Beispiel #21
0
 def test_fromfd_inet6(self):
     client = pyuv.TCP(self.loop)
     client.bind(('::1', TEST_PORT))
     sock = socket.fromfd(client.fileno(), client.family, socket.SOCK_STREAM)
     self.assertEqual(client.getsockname(), sock.getsockname())
     client.close()
     sock.close()
     self.loop.run()
Beispiel #22
0
 def on_connection(self, server, error):
     self.assertEqual(error, None)
     client = pyuv.TCP(pyuv.Loop.default_loop())
     server.accept(client)
     self.client_connections.append(client)
     client.start_read(self.on_client_connection_read)
     data = memoryview(b"PING")
     client.write(data)
Beispiel #23
0
 def on_connection(self, server, error):
     self.assertEqual(error, None)
     self.check_fileno(server)
     client = pyuv.TCP(self.loop)
     server.accept(client)
     self.check_fileno(client)
     client.close()
     server.close()
Beispiel #24
0
    def connect(self, host, port):
        self._handle = pyuv.TCP(self._loop)
        self._handle.connect((host, int(port)), self._on_connected)
        self._handle.start_read(self._on_read)

        self._sigint_handler = pyuv.Signal(self._loop)
        self._sigint_handler.start(self._on_signal, signal.SIGINT)
        return
Beispiel #25
0
    def handle_pending_client(self, server, err):
        client = pyuv.TCP(server.loop)
        server.accept(client)

        serverClient = ServerClient(client)
        self.clients.append(serverClient)
        # Begin the "recursive" read chain.
        client.start_read(serverClient.handle_data_available)
Beispiel #26
0
    def start(self):
        self.server = pyuv.TCP(pyuv.Loop.default_loop())
        self.server.bind(('0.0.0.0', 6379))  # Notice the tuple parameter
        self.server.listen(self.handle_pending_client)

        # Make sure to listen for SIGINT to happen so ^C works.
        self.sigint = pyuv.Signal(pyuv.Loop.default_loop())
        self.sigint.start(self.handle_end_signal, signal.SIGINT)
Beispiel #27
0
 def on_ipc_connection(self, handle, error):
     if self.local_conn_accepted:
         return
     conn = pyuv.TCP(self.loop)
     self.tcp_server.accept(conn)
     conn.close()
     self.tcp_server.close()
     self.local_conn_accepted = True
Beispiel #28
0
 def test_tcp_flags(self):
     loop = pyuv.Loop.default_loop()
     tcp = pyuv.TCP(loop)
     tcp.nodelay(True)
     tcp.keepalive(True, 60)
     tcp.simultaneous_accepts(True)
     tcp.close()
     loop.run()
     self.assertTrue(True)
Beispiel #29
0
def on_ipc_connection(handle, error):
    global channel, connection_accepted, loop, tcp_server
    if connection_accepted:
        return
    conn = pyuv.TCP(loop)
    tcp_server.accept(conn)
    conn.close()
    channel.write(b"accepted_connection", on_channel_write)
    connection_accepted = True
Beispiel #30
0
 def _on_connection(self, server, error):
     """
     .. warning::Internal method.
     Connect to client on request
     """
     client = pyuv.TCP(self.server.loop)
     self.server.accept(client)
     self.clients.append(client)
     client.start_read(self._stream)