Esempio n. 1
0
 def setUp(self):
     self.port = InPort("port", Mock())
     self.peer_port = OutPort("peer_port", Mock())
     self.tunnel = Mock()
     self.scheduler = Mock()
     self.node_id = 123
     self.peer_node_id = 456
     self.tunnel_in = TunnelInEndpoint(self.port, self.tunnel,
                                       self.peer_node_id, self.peer_port.id,
                                       {}, self.scheduler)
     self.tunnel_out = TunnelOutEndpoint(self.peer_port, self.tunnel,
                                         self.node_id, self.port.id, {},
                                         self.scheduler)
     self.port.set_queue(
         queue.fanout_fifo.FanoutFIFO({
             'queue_length': 4,
             'direction': "in"
         }, {}))
     self.port.attach_endpoint(self.tunnel_in)
     self.peer_port.set_queue(
         queue.fanout_fifo.FanoutFIFO(
             {
                 'queue_length': 4,
                 'direction': "out"
             }, {}))
     self.peer_port.attach_endpoint(self.tunnel_out)
Esempio n. 2
0
 def setUp(self):
     self.port = InPort("port", Mock())
     self.peer_port = OutPort("peer_port", Mock())
     self.local_in = LocalInEndpoint(self.port, self.peer_port)
     self.local_out = LocalOutEndpoint(self.peer_port, self.port)
     self.port.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "in"}, {}))
     self.peer_port.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "out"}, {}))
     self.peer_port.attach_endpoint(self.local_out)
     self.port.attach_endpoint(self.local_in)
Esempio n. 3
0
 def setUp(self):
     self.port = InPort("port", Mock())
     self.peer_port = OutPort("peer_port", Mock())
     self.local_in = LocalInEndpoint(self.port, self.peer_port)
     self.local_out = LocalOutEndpoint(self.peer_port, self.port)
     self.port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
     self.peer_port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
     self.peer_port.attach_endpoint(self.local_out)
     self.port.attach_endpoint(self.local_in)
Esempio n. 4
0
 def setUp(self):
     self.port = InPort("port", Mock())
     self.peer_port = OutPort("peer_port", Mock())
     self.local_in = LocalInEndpoint(self.port, self.peer_port)
     self.local_out = LocalOutEndpoint(self.peer_port, self.port)
     self.port.attach_endpoint(self.local_in)
     self.peer_port.attach_endpoint(self.local_out)
Esempio n. 5
0
 def setUp(self):
     self.port = InPort("port", Mock())
     self.peer_port = OutPort("peer_port", Mock())
     self.tunnel = Mock()
     self.trigger_loop = Mock()
     self.node_id = 123
     self.peer_node_id = 456
     self.tunnel_in = TunnelInEndpoint(self.port, self.tunnel,
                                       self.peer_node_id, self.peer_port.id,
                                       self.trigger_loop)
     self.tunnel_out = TunnelOutEndpoint(self.peer_port, self.tunnel,
                                         self.node_id, self.port.id,
                                         self.trigger_loop)
     self.port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
     self.port.attach_endpoint(self.tunnel_in)
     self.peer_port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
     self.peer_port.attach_endpoint(self.tunnel_out)
Esempio n. 6
0
 def setUp(self):
     self.port = InPort("port", Mock())
     self.peer_port = OutPort("peer_port", Mock())
     self.local_in = LocalInEndpoint(self.port, self.peer_port)
     self.local_out = LocalOutEndpoint(self.peer_port, self.port)
     self.port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
     self.peer_port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
     self.peer_port.attach_endpoint(self.local_out)
     self.port.attach_endpoint(self.local_in)
 def setUp(self):
     self.port = InPort("port", Mock())
     self.peer_port = OutPort("peer_port", Mock())
     self.local_in = LocalInEndpoint(self.port, self.peer_port)
     self.local_out = LocalOutEndpoint(self.peer_port, self.port)
     self.port.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "in"}, {}))
     self.peer_port.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "out"}, {}))
     self.peer_port.attach_endpoint(self.local_out)
     self.port.attach_endpoint(self.local_in)
Esempio n. 8
0
 def setUp(self):
     self.port = InPort("port", Mock())
     self.peer_port = OutPort("peer_port", Mock())
     self.tunnel = Mock()
     self.trigger_loop = Mock()
     self.node_id = 123
     self.peer_node_id = 456
     self.tunnel_in = TunnelInEndpoint(self.port, self.tunnel, self.peer_node_id, self.peer_port.id, self.trigger_loop)
     self.tunnel_out = TunnelOutEndpoint(self.peer_port, self.tunnel, self.node_id, self.port.id, self.trigger_loop)
     self.port.attach_endpoint(self.tunnel_in)
     self.peer_port.attach_endpoint(self.tunnel_out)
 def setUp(self):
     self.port = InPort("port", Mock())
     self.peer_port = OutPort("peer_port", Mock())
     self.tunnel = Mock()
     self.scheduler = Mock()
     self.node_id = 123
     self.peer_node_id = 456
     self.tunnel_in = TunnelInEndpoint(self.port, self.tunnel, self.peer_node_id, self.peer_port.id, {}, self.scheduler)
     self.tunnel_out = TunnelOutEndpoint(self.peer_port, self.tunnel, self.node_id, self.port.id, {}, self.scheduler)
     self.port.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "in"}, {}))
     self.port.attach_endpoint(self.tunnel_in)
     self.peer_port.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "out"}, {}))
     self.peer_port.attach_endpoint(self.tunnel_out)
Esempio n. 10
0
class TestLocalEndpoint(unittest.TestCase):
    def setUp(self):
        self.port = InPort("port", Mock())
        self.peer_port = OutPort("peer_port", Mock())
        self.local_in = LocalInEndpoint(self.port, self.peer_port)
        self.local_out = LocalOutEndpoint(self.peer_port, self.port)
        self.port.set_queue(
            queue.fanout_fifo.FanoutFIFO({
                'queue_length': 4,
                'direction': "in"
            }, {}))
        self.peer_port.set_queue(
            queue.fanout_fifo.FanoutFIFO(
                {
                    'queue_length': 4,
                    'direction': "out"
                }, {}))
        self.peer_port.attach_endpoint(self.local_out)
        self.port.attach_endpoint(self.local_in)

    def test_is_connected(self):
        assert self.local_in.is_connected
        assert self.local_out.is_connected

    def test_communicate(self):
        self.peer_port.queue.write(0, None)
        self.peer_port.queue.write(1, None)

        for e in self.peer_port.endpoints:
            e.communicate()

        assert self.peer_port.tokens_available(4)
        self.local_out.port.queue.write(2, None)
        assert not self.peer_port.tokens_available(4)
        assert self.peer_port.tokens_available(3)

        assert self.port.tokens_available(2, self.port.id)

        for e in self.peer_port.endpoints:
            e.communicate()

        assert self.port.tokens_available(3, self.port.id)
        for i in range(3):
            assert self.port.queue.peek(self.port.id) == i
        assert self.port.tokens_available(0, self.port.id)
        self.port.queue.commit(self.port.id)
        assert self.port.tokens_available(0, self.port.id)

    def test_get_peer(self):
        assert self.local_in.get_peer() == ('local', self.peer_port.id)
        assert self.local_out.get_peer() == ('local', self.port.id)
Esempio n. 11
0
def test_attach_endpoint_to_inport(inport, outport):
    inport.owner.did_connect = Mock()
    first_outport = OutPort("out", actor())
    first_endpoint = LocalInEndpoint(inport, first_outport)
    first_endpoint._fifo_mismatch_fix = Mock() #  Skip fifo mismatch fixing
    endpoint = LocalInEndpoint(inport, outport)
    endpoint._fifo_mismatch_fix = Mock() #  Skip fifo mismatch fixing

    inport.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "in"}, {}))
    inport.attach_endpoint(first_endpoint)
    assert inport.is_connected_to(first_outport.id)

    prev_endpoint = inport.attach_endpoint(endpoint)
    assert prev_endpoint == None
    assert inport.is_connected_to(outport.id)
    assert inport.is_connected_to(first_outport.id)
    assert inport.owner.did_connect.called
Esempio n. 12
0
class TestLocalEndpoint(unittest.TestCase):

    def setUp(self):
        self.port = InPort("port", Mock())
        self.peer_port = OutPort("peer_port", Mock())
        self.local_in = LocalInEndpoint(self.port, self.peer_port)
        self.local_out = LocalOutEndpoint(self.peer_port, self.port)
        self.port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
        self.peer_port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
        self.peer_port.attach_endpoint(self.local_out)
        self.port.attach_endpoint(self.local_in)

    def test_is_connected(self):
        assert self.local_in.is_connected
        assert self.local_out.is_connected

    def test_communicate(self):
        self.peer_port.queue.write(0)
        self.peer_port.queue.write(1)

        for e in self.peer_port.endpoints:
            e.communicate()

        assert self.peer_port.tokens_available(4)
        self.local_out.port.queue.write(2)
        assert not self.peer_port.tokens_available(4)
        assert self.peer_port.tokens_available(3)

        assert self.port.tokens_available(2, self.port.id)

        for e in self.peer_port.endpoints:
            e.communicate()

        assert self.port.tokens_available(3, self.port.id)
        for i in range(3):
            assert self.port.queue.peek(self.port.id) == i
        assert self.port.tokens_available(0, self.port.id)
        self.port.queue.commit()
        assert self.port.tokens_available(0, self.port.id)

    def test_get_peer(self):
        assert self.local_in.get_peer() == ('local', self.peer_port.id)
        assert self.local_out.get_peer() == ('local', self.port.id)
Esempio n. 13
0
class TestTunnelEndpoint(unittest.TestCase):

    def setUp(self):
        self.port = InPort("port", Mock())
        self.peer_port = OutPort("peer_port", Mock())
        self.tunnel = Mock()
        self.trigger_loop = Mock()
        self.node_id = 123
        self.peer_node_id = 456
        self.tunnel_in = TunnelInEndpoint(self.port, self.tunnel, self.peer_node_id, self.peer_port.id, self.trigger_loop)
        self.tunnel_out = TunnelOutEndpoint(self.peer_port, self.tunnel, self.node_id, self.port.id, self.trigger_loop)
        self.port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
        self.port.attach_endpoint(self.tunnel_in)
        self.peer_port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
        self.peer_port.attach_endpoint(self.tunnel_out)

    def test_recv_token(self):
        expected_reply = {
            'cmd': 'TOKEN_REPLY',
            'port_id': self.port.id,
            'peer_port_id': self.peer_port.id,
            'sequencenbr': 0,
            'value': 'ACK'
        }
        payload = {
            'port_id': self.port.id,
            'peer_port_id': self.peer_port.id,
            'sequencenbr': 0,
            'token': {'type': 'Token', 'data': 5}
        }
        self.tunnel_in.recv_token(payload)
        assert self.trigger_loop.called
        assert self.port.queue.fifo[0].value == 5
        self.tunnel.send.assert_called_with(expected_reply)

        self.trigger_loop.reset_mock()
        self.tunnel.send.reset_mock()

        payload['sequencenbr'] = 100
        self.tunnel_in.recv_token(payload)
        assert not self.trigger_loop.called
        expected_reply['sequencenbr'] = 100
        expected_reply['value'] = 'NACK'
        self.tunnel.send.assert_called_with(expected_reply)

        self.trigger_loop.reset_mock()
        self.tunnel.send.reset_mock()

        payload['sequencenbr'] = 0
        self.tunnel_in.recv_token(payload)
        assert not self.trigger_loop.called
        expected_reply['sequencenbr'] = 0
        expected_reply['value'] = 'ACK'
        self.tunnel.send.assert_called_with(expected_reply)

    def test_get_peer(self):
        assert self.tunnel_in.get_peer() == (self.peer_node_id, self.peer_port.id)
        assert self.tunnel_out.get_peer() == (self.node_id, self.port.id)

    def test_reply(self):
        self.tunnel_out.port.queue.com_commit = Mock()
        self.tunnel_out.port.queue.com_cancel = Mock()
        self.tunnel.send = Mock()

        self.tunnel_out.port.write_token(Token(1))
        self.tunnel_out._send_one_token()
        nbr = self.tunnel.send.call_args_list[-1][0][0]['sequencenbr']

        self.tunnel_out.reply(0, 'ACK')
        self.tunnel_out.port.queue.com_commit.assert_called_with(self.port.id, nbr)
        assert self.trigger_loop.called

        self.tunnel_out.port.write_token(Token(1))
        self.tunnel_out._send_one_token()
        nbr = self.tunnel.send.call_args_list[-1][0][0]['sequencenbr']

        self.tunnel_out.reply(nbr, 'NACK')
        assert self.tunnel_out.port.queue.com_cancel.called

    def test_nack_reply(self):
        self.tunnel_out.port.write_token(Token(1))
        self.tunnel_out._send_one_token()

        self.tunnel_out.port.queue.commit(self.port.id)
        assert self.tunnel_out.port.queue.tentative_read_pos[self.port.id] == 1
        assert self.tunnel_out.port.queue.read_pos[self.port.id] == 1

        self.tunnel_out.port.write_token(Token(2))
        self.tunnel_out.port.write_token(Token(3))
        self.tunnel_out._send_one_token()
        self.tunnel_out._send_one_token()

        assert self.tunnel_out.port.queue.read_pos[self.port.id] == 1
        assert self.tunnel_out.port.queue.tentative_read_pos[self.port.id] == 3

        self.tunnel_out.reply(1, 'NACK')
        assert self.tunnel_out.port.queue.tentative_read_pos[self.port.id] == 1
        assert self.tunnel_out.port.queue.read_pos[self.port.id] == 1

    def test_bulk_communicate(self):
        self.tunnel_out.port.write_token(Token(1))
        self.tunnel_out.port.write_token(Token(2))
        self.tunnel_out.bulk = True
        self.tunnel_out.communicate()
        assert self.tunnel.send.call_count == 2

    def test_communicate(self):
        self.tunnel_out.port.write_token(Token(1))
        self.tunnel_out.port.write_token(Token(2))

        self.tunnel_out.bulk = False

        assert self.tunnel_out.communicate() is True
        assert self.tunnel.send.call_count == 1

        assert self.tunnel_out.communicate() is False

        self.tunnel_out.reply(1, 'ACK')
        assert self.tunnel_out.communicate() is True
        assert self.tunnel.send.call_count == 2
Esempio n. 14
0
def outport():
    return OutPort("outport", actor())
Esempio n. 15
0
class TestTunnelEndpoint(unittest.TestCase):
    def setUp(self):
        self.port = InPort("port", Mock())
        self.peer_port = OutPort("peer_port", Mock())
        self.tunnel = Mock()
        self.scheduler = Mock()
        self.node_id = 123
        self.peer_node_id = 456
        self.tunnel_in = TunnelInEndpoint(self.port, self.tunnel,
                                          self.peer_node_id, self.peer_port.id,
                                          {}, self.scheduler)
        self.tunnel_out = TunnelOutEndpoint(self.peer_port, self.tunnel,
                                            self.node_id, self.port.id, {},
                                            self.scheduler)
        self.port.set_queue(
            queue.fanout_fifo.FanoutFIFO({
                'queue_length': 4,
                'direction': "in"
            }, {}))
        self.port.attach_endpoint(self.tunnel_in)
        self.peer_port.set_queue(
            queue.fanout_fifo.FanoutFIFO(
                {
                    'queue_length': 4,
                    'direction': "out"
                }, {}))
        self.peer_port.attach_endpoint(self.tunnel_out)

    def test_recv_token(self):
        expected_reply = {
            'cmd': 'TOKEN_REPLY',
            'port_id': self.port.id,
            'peer_port_id': self.peer_port.id,
            'sequencenbr': 0,
            'value': 'ACK'
        }
        payload = {
            'port_id': self.port.id,
            'peer_port_id': self.peer_port.id,
            'sequencenbr': 0,
            'token': {
                'type': 'Token',
                'data': 5
            }
        }
        self.tunnel_in.recv_token(payload)
        assert self.scheduler.tunnel_rx.called
        assert self.port.queue.fifo[0].value == 5
        self.tunnel.send.assert_called_with(expected_reply)

        self.scheduler.reset_mock()
        self.tunnel.send.reset_mock()

        payload['sequencenbr'] = 100
        self.tunnel_in.recv_token(payload)
        assert not self.scheduler.tunnel_rx.called
        expected_reply['sequencenbr'] = 100
        expected_reply['value'] = 'NACK'
        self.tunnel.send.assert_called_with(expected_reply)

        self.scheduler.reset_mock()
        self.tunnel.send.reset_mock()

        payload['sequencenbr'] = 0
        self.tunnel_in.recv_token(payload)
        assert not self.scheduler.called
        expected_reply['sequencenbr'] = 0
        expected_reply['value'] = 'ACK'
        self.tunnel.send.assert_called_with(expected_reply)

    def test_get_peer(self):
        assert self.tunnel_in.get_peer() == (self.peer_node_id,
                                             self.peer_port.id)
        assert self.tunnel_out.get_peer() == (self.node_id, self.port.id)

    def test_reply(self):
        self.tunnel_out.port.queue.com_commit = Mock()
        self.tunnel_out.port.queue.com_cancel = Mock()
        self.tunnel.send = Mock()

        self.tunnel_out.port.write_token(Token(1))
        self.tunnel_out._send_one_token()
        nbr = self.tunnel.send.call_args_list[-1][0][0]['sequencenbr']

        self.tunnel_out.reply(0, 'ACK')
        self.tunnel_out.port.queue.com_commit.assert_called_with(
            self.port.id, nbr)
        assert self.scheduler.tunnel_tx_ack.called

        self.tunnel_out.port.write_token(Token(1))
        self.tunnel_out._send_one_token()
        nbr = self.tunnel.send.call_args_list[-1][0][0]['sequencenbr']

        self.tunnel_out.reply(nbr, 'NACK')
        assert self.tunnel_out.port.queue.com_cancel.called
        assert self.scheduler.tunnel_tx_nack.called

    def test_nack_reply(self):
        self.tunnel_out.port.write_token(Token(1))
        self.tunnel_out._send_one_token()

        self.tunnel_out.port.queue.commit(self.port.id)
        assert self.tunnel_out.port.queue.tentative_read_pos[self.port.id] == 1
        assert self.tunnel_out.port.queue.read_pos[self.port.id] == 1

        self.tunnel_out.port.write_token(Token(2))
        self.tunnel_out.port.write_token(Token(3))
        self.tunnel_out._send_one_token()
        self.tunnel_out._send_one_token()

        assert self.tunnel_out.port.queue.read_pos[self.port.id] == 1
        assert self.tunnel_out.port.queue.tentative_read_pos[self.port.id] == 3

        self.tunnel_out.reply(1, 'NACK')
        assert self.tunnel_out.port.queue.tentative_read_pos[self.port.id] == 1
        assert self.tunnel_out.port.queue.read_pos[self.port.id] == 1

    def test_bulk_communicate(self):
        self.tunnel_out.port.write_token(Token(1))
        self.tunnel_out.port.write_token(Token(2))
        self.tunnel_out.bulk = True
        self.tunnel_out.communicate()
        assert self.tunnel.send.call_count == 2

    def test_communicate(self):
        self.tunnel_out.port.write_token(Token(1))
        self.tunnel_out.port.write_token(Token(2))

        self.tunnel_out.bulk = False

        assert self.tunnel_out.communicate() is True
        assert self.tunnel.send.call_count == 1

        assert self.tunnel_out.communicate() is False

        self.tunnel_out.reply(1, 'ACK')
        assert self.tunnel_out.communicate() is True
        assert self.tunnel.send.call_count == 2
Esempio n. 16
0
class TestLocalEndpoint(unittest.TestCase):

    def setUp(self):
        self.port = InPort("port", Mock())
        self.peer_port = OutPort("peer_port", Mock())
        self.local_in = LocalInEndpoint(self.port, self.peer_port)
        self.local_out = LocalOutEndpoint(self.peer_port, self.port)
        self.port.attach_endpoint(self.local_in)
        self.peer_port.attach_endpoint(self.local_out)

    def test_is_connected(self):
        assert self.local_in.is_connected
        assert self.local_out.is_connected

    def test_read_token_fixes_fifo_mismatch(self):
        self.local_in.fifo_mismatch = True
        token = self.local_in.read_token()
        assert token is None
        assert self.local_in.fifo_mismatch is False

    def test_read_token_commits_if_token_is_not_none(self):
        self.local_in.port.fifo.commit_reads = Mock()
        self.local_out.port.fifo.commit_reads = Mock()
        self.local_in.port.fifo.write(1)

        assert self.local_in.data_in_local_fifo is True
        assert self.local_in.read_token() == 1
        assert self.local_in.data_in_local_fifo is True
        self.local_in.port.fifo.commit_reads.assert_called_with(self.port.id, True)

        self.local_out.port.fifo.write(2)

        assert self.local_in.data_in_local_fifo is True
        assert self.local_in.read_token() == 2
        assert self.local_in.data_in_local_fifo is False
        self.local_out.port.fifo.commit_reads.assert_called_with(self.port.id, True)

    def test_peek_token(self):
        self.local_in.port.fifo.commit_reads = Mock()
        self.local_out.port.fifo.commit_reads = Mock()
        self.local_in.port.fifo.write(1)

        assert self.local_in.peek_token() == 1
        assert not self.local_in.port.fifo.commit_reads.called
        assert self.local_in.peek_token() is None
        self.local_in.peek_rewind()
        self.local_in.commit_peek_as_read()
        self.local_in.port.fifo.commit_reads.assert_called_with(self.port.id)
        self.local_out.port.fifo.commit_reads.assert_called_with(self.port.id)

        self.local_in.port.fifo.commit_reads.reset_mock()
        self.local_out.port.fifo.commit_reads.reset_mock()

        self.local_out.port.fifo.write(2)
        assert self.local_in.peek_token() == 2
        assert not self.local_out.port.fifo.commit_reads.called
        self.local_in.commit_peek_as_read()
        assert not self.local_in.port.fifo.commit_reads.called
        self.local_out.port.fifo.commit_reads.assert_called_with(self.port.id)

    def test_available_tokens(self):
        self.local_in.port.fifo.write(1)
        self.local_in.port.fifo.write(1)
        assert self.local_in.available_tokens() == 2
        self.local_out.port.fifo.write(1)
        assert self.local_in.available_tokens() == 3

    def test_get_peer(self):
        assert self.local_in.get_peer() == ('local', self.peer_port.id)
        assert self.local_out.get_peer() == ('local', self.port.id)