Пример #1
0
def echo_server(port=12345, pcon=NewLinerConn):
    """makes Echo server"""
    print("Making echo server")
    def echo_handler(request):
        print("echo server: "+request.body)
        request.write(request.body)

    server = PServer(echo_handler, pcon)
    server.listen(port)
    server.start()
    IOLoop.instance().start()
class TestPServer1(AsyncTestCase):
    def setUp(self):
        AsyncTestCase.setUp(self)
        self.response_callback = SpyMethod()
        self.server = PServer(self.response_callback, NetStringConn, io_loop = self.io_loop)
        self.server.handle_stream = SpyMethod()
        self.port = get_unused_port()
        self.server.listen(self.port)

    def check_and_stop(self):
        assert self.io_loop._running
        assert self.server._started
        self.server.stop()
        self.io_loop.add_callback(self.stop)

    def test_start_stop_server(self):
        self.server.start()
        assert self.port in [s[1] for s in self.server.sockets_names()]
        self.io_loop.add_timeout(time.time()+.2, self.check_and_stop)
        self.wait(timeout=1)


    def check_handle_request(self):
        assert self.server.handle_stream.num_calls == 1

        # assert_that_method(self.server.handle_stream).was_called()
        # self.io_loop.add_callback(assert_that_method(self.server.handle_stream).was_called)

    def test_connection_sync(self):
        self.server.start()

        def connect():
            # following raises exception, if connection was'nt made
            sock = socket.create_connection(("127.0.0.1", self.port), .2)
            assert sock
            #assert_that_method(self.server.handle_stream).was_never_called()
            assert self.server.handle_stream.num_calls == 0
            sock.send(b'request\n')
            self.io_loop.add_callback(self.check_handle_request)
            self.io_loop.add_callback(self.stop)

        self.io_loop.add_callback(connect)
        self.wait(timeout=1)
class TestPServer2(AsyncTestCase):
    def setUp(self):
        AsyncTestCase.setUp(self)
        self.response_callback = echo_handler
        self.server = PServer(self.response_callback, NetStringConn, io_loop = self.io_loop)
        #self.server = proxy_spy(self.server)
        self.port = get_unused_port()
        self.server.listen(self.port)

        conn_info = socket.getaddrinfo('127.0.0.1', self.port, socket.AF_UNSPEC, socket.SOCK_STREAM)
        af, socktype, proto, conname, saddress = conn_info[0]
        # print(conn_info)
        # print(socket.AF_INET, socket.SOCK_STREAM)
        self.server_address = saddress
        self.sock = socket.socket(af, socktype, 6)                 # In the examples from net, the protocol version is 0
        self.stream = iostream.IOStream(self.sock, self.io_loop)   # client must have the same event loop, otherwise it will create new one
        self.server.start()


    def test_connection_stream(self):
        """test próby połączenia trzech klientów: jeden z tego samego wątku, drugi z nowego.
        Pierwszy jest z tego samego wątku. Przy połączeniu uwstawia walidator <connected>.
        Drugi z nowego wątku zamyka przy połączeniu zatrzymuje główną pętlę i server.
        Trzeci jest z nowego procesu. Musi mieć nowego event loopa, który musi osobno wystartować (główny event loop startuje wraz z funkcją self.wati).
           Przy połączeniu event loop procesu zostaje zamknięty i proces się kończy.
           Gdyby się nie połączył, test się nie skończy"""
        connected_t = TEvent()

        def connect(io_loop, f_stop=None):
            if not f_stop:
                f_stop = io_loop.stop
            sock2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
            stream2 = iostream.IOStream(sock2, io_loop)
            stream2.connect(self.server_address, f_stop)
            if io_loop != self.io_loop:                       # we get other event loop
                logger.debug("Mam nowy  event loop. Startuje go")
                io_loop.start()


        self.stream.connect(self.server_address, connected_t.set)
        p=Process(target = connect, args=(self.get_new_ioloop(), ))  # proces musi operować na innym event loopie!
        p.start()
        t=Thread(target = connect, args=(self.io_loop, self.stop))   # wątek może mieć ten sam eventloop
        t.start()

        self.wait(timeout=1)
        assert connected_t.is_set()
        assert t.is_alive() is False
        p.join(0.1)
        if p.is_alive():
            p.terminate()
            self.fail("Process doesn't terminate normally - client doesn't connect to server")

    def test_req_resp(self):

        def client_work():
            num_writes = 1
            client.stop_cond = lambda obj: len(obj.resp)==num_writes
            #client.next_random()
            for i in range(num_writes):
                #self.io_loop.add_callback(lambda: client.write(str(random.random())))
                client.next_random()

        client = EchoClient(self.stream, self)
        self.stream.connect(self.server_address, client_work)

        self.wait(timeout=1)
        assert client.req == client.resp


    def raw_req_resp_session(self, length, callback):
        """make req resp session with NetString server.
        when session is finished, call callback
        """
        out = []
        def send(i):
            """Send some data in NetString format"""
            data = 'w'+str(i+1)                       # some test data
            data = "{}:{},".format(len(data), data) # constructing NetString
            logger.debug("send "+data)
            self.stream.write(data, on_write)

        def on_read(data):
            out.append(data)
            logger.debug("out: {}".format(data))
            i = len(out)
            if i == length:
                callback()
            else:
                send(i)

        def on_write():
            self.stream.read_bytes(5, on_read)

        send(0)

    def test_req_resp2(self):
        self.stream.connect(self.server_address,
                            lambda: self.raw_req_resp_session(1, self.stop))

        self.wait(timeout=1)


    def test_req_resp3(self):
        self.stream.connect(self.server_address,
                            lambda: self.raw_req_resp_session(4, self.stop))

        self.wait(timeout=1)

    def test_req_resp_noseq(self):
        """test if reads /writes where reads do not follow approprite writes don't succeed"""

        def work():
            self.stream.write("2:d1,")
            with pytest.raises(IOError):
                self.stream.write("2:d1,")
            self.io_loop.add_callback(self.stop)

        self.io_loop.add_callback(work)

        self.wait(timeout=1)


    def socket_raw_req_resp(self, d_in, d_out):
        time.sleep(.1)
        sock = socket.create_connection(self.server_address, .2)
        for d in d_out:
            logger.info("sending: "+ d)
            sock.send(d)
            r = sock.recv(8)
            try:
                r += sock.recv(8)  # net string are written sended in two phases, and depends on cache can be sent in two phases as well.
            except: pass
            logger.info("received: "+ r)
            d_in.append(r)
        self.stop()


    def test_req_resp_socket(self):
        d_out = ["2:d1,", "2:d2,"]
        d_in  = []
        t = Thread(target=self.socket_raw_req_resp,  args=(d_in, d_out))
        self.io_loop.add_callback(t.start)

        self.wait(timeout=1.2)
        assert d_in == d_out