def test_inport_outport_connection(inport, outport):
out_endpoint = LocalOutEndpoint(outport, inport)
out_endpoint._fifo_mismatch_fix = Mock() # Skip fifo mismatch fixing
in_endpoint = LocalInEndpoint(inport, outport)
in_endpoint._fifo_mismatch_fix = Mock() # Skip fifo mismatch fixing
outport.set_queue(
queue.fanout_fifo.FanoutFIFO({
'queue_length': 4,
'direction': "out"
}, {}))
outport.attach_endpoint(out_endpoint)
inport.set_queue(
queue.fanout_fifo.FanoutFIFO({
'queue_length': 4,
'direction': "in"
}, {}))
inport.attach_endpoint(in_endpoint)
assert outport.tokens_available(1)
assert outport.tokens_available(4)
outport.write_token(1)
assert outport.tokens_available(3)
for e in outport.endpoints:
e.communicate()
assert inport.tokens_available(1)
assert inport.peek_token() == 1
inport.peek_cancel()
assert inport.peek_token() == 1
assert inport.tokens_available(0)
def test_disconnect_inport(inport, outport):
inport.owner.did_disconnect = Mock()
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(endpoint)
assert inport.disconnect() == [endpoint]
assert inport.owner.did_disconnect.called
def test_detach_endpoint_from_inport(inport, outport):
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(endpoint)
assert inport.is_connected_to(outport.id)
inport.detach_endpoint(endpoint)
assert not inport.is_connected_to(outport.id)
def test_disconnect_inport(inport, outport):
inport.owner.did_disconnect = Mock()
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(endpoint)
assert inport.disconnect() == [endpoint]
assert inport.owner.did_disconnect.called
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_detach_endpoint_from_inport(inport, outport):
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(endpoint)
assert inport.is_connected_to(outport.id)
inport.detach_endpoint(endpoint)
assert not inport.is_connected_to(outport.id)
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_set_outport_state(inport, outport):
new_state = {
'properties': {
'routing': 'fanout',
'nbr_peers': 2
},
'name': 'new_name',
'id': '123',
'queue': {
'fifo': [{
'value': 1
} for n in range(5)],
'N': 5,
'readers': ['123'],
'write_pos': 3,
'read_pos': {
'123': 2
},
'tentative_read_pos': {
'123': 0
},
'queuetype': 'fifo'
}
}
out_endpoint = LocalOutEndpoint(outport, inport)
out_endpoint._fifo_mismatch_fix = Mock() # Skip fifo mismatch fixing
in_endpoint = LocalInEndpoint(inport, outport)
in_endpoint._fifo_mismatch_fix = Mock() # Skip fifo mismatch fixing
inport.set_queue(
queue.fanout_fifo.FanoutFIFO({
'queue_length': 4,
'direction': "in"
}, {}))
inport.attach_endpoint(in_endpoint)
outport.set_queue(
queue.fanout_fifo.FanoutFIFO({
'queue_length': 4,
'direction': "out"
}, {}))
outport.attach_endpoint(out_endpoint)
outport._set_state(new_state)
assert outport.name == 'new_name'
assert outport.id == '123'
assert outport.properties['nbr_peers'] == 2
assert outport.tokens_available(1)
assert outport.tokens_available(3)
outport.write_token(10)
assert outport.queue.fifo[3] == 10
def test_set_inport_state(inport, outport):
out_endpoint = LocalOutEndpoint(outport, inport)
out_endpoint._fifo_mismatch_fix = Mock() # Skip fifo mismatch fixing
in_endpoint = LocalInEndpoint(inport, outport)
in_endpoint._fifo_mismatch_fix = Mock() # Skip fifo mismatch fixing
outport.set_queue(
queue.fanout_fifo.FanoutFIFO({
'queue_length': 4,
'direction': "out"
}, {}))
outport.attach_endpoint(out_endpoint)
inport.set_queue(
queue.fanout_fifo.FanoutFIFO({
'queue_length': 4,
'direction': "in"
}, {}))
inport.attach_endpoint(in_endpoint)
new_state = {
'name': 'new_name',
'id': inport.id,
'queue': {
'fifo': [{
'data': n
} for n in range(5)],
'N': 5,
'readers': [in_endpoint.port.id],
'write_pos': 5,
'read_pos': {
in_endpoint.port.id: 4
},
'tentative_read_pos': {
in_endpoint.port.id: 2
}
}
}
inport._set_state(new_state)
assert inport.name == 'new_name'
assert inport.tokens_available(3)
assert inport.peek_token().value == 2
assert inport.peek_token().value == 3
assert inport.peek_token().value == 4
try:
assert inport.peek_token()
assert False
except queue.common.QueueEmpty:
assert True
except:
assert False
def app_from_script(script, script_name):
deployable, issuetracker = calvin_codegen(script, script_name, verify=False)
errors = issuetracker.errors(sort_key='reason')
warnings = issuetracker.warnings(sort_key='reason')
if errors:
return {}, errors, warnings
actors = {}
for name, setup in deployable['actors'].iteritems():
a_type = setup['actor_type']
a_args = setup['args']
a_args.update({"name":name}) # Optional, for human readability only
a = create_actor(a_type, a_args)
actors[name] = a
for src, dests in deployable['connections'].iteritems():
for dest in dests:
a_name, p_name = src.split('.')
outport = actors[a_name].outports[p_name]
# FIXME: setup port properties (queue) from deployable info
outport.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "out"}, {}))
a_name, p_name = dest.split('.')
inport = actors[a_name].inports[p_name]
# FIXME: setup port properties (queue) from deployable info
inport.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "in"}, {}))
outport.attach_endpoint(LocalOutEndpoint(outport, inport))
inport.attach_endpoint(LocalInEndpoint(inport, outport))
return actors, errors, warnings
def test_connections():
node = DummyNode()
node.id = "node_id"
actor = create_actor(node)
inport = actor.inports['token']
outport = actor.outports['token']
in_peer_port = TestPort("x", "out")
out_peer_port = TestPort("y", "in")
out_peer_port.queue.add_reader(out_peer_port.id, {})
in_peer_port.queue.add_reader(inport.id, {})
inport.attach_endpoint(LocalInEndpoint(inport, in_peer_port))
outport.attach_endpoint(LocalOutEndpoint(outport, out_peer_port))
assert actor.connections(node) == {
'actor_id': actor.id,
'actor_name': actor.name,
'inports': {
inport.id: [(node, in_peer_port.id)]
},
'outports': {
outport.id: [(node, out_peer_port.id)]
}
}
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 == Endpoint.void()
assert inport.is_connected_to(outport.id)
assert inport.is_connected_to(first_outport.id)
assert inport.owner.did_connect.called
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)
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)
def test_simple(self):
# Create actors
src = create_actor('std.Constant', {"data":42, "name":"src"})
filter = create_actor('std.Identity', {"name":"filter"})
snk = create_actor('flow.Terminator', {"name":"snk"})
# Get get the ports
src_outport = src.outports['token']
filter_inport = filter.inports['token']
filter_outport = filter.outports['token']
snk_inport = snk.inports['void']
# Set the queue types and length for each port
src_outport.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "out"}, {}))
filter_inport.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "in"}, {}))
filter_outport.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "out"}, {}))
snk_inport.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "in"}, {}))
# Create endpoints
src_out_ep = LocalOutEndpoint(src_outport, filter_inport)
filter_in_ep = LocalInEndpoint(filter_inport, src_outport)
filter_out_ep = LocalOutEndpoint(filter_outport, snk_inport)
snk_in_ep = LocalInEndpoint(snk_inport, filter_outport)
# Attach the enpoints to the ports
src_outport.attach_endpoint(src_out_ep)
filter_inport.attach_endpoint(filter_in_ep)
filter_outport.attach_endpoint(filter_out_ep)
snk_inport.attach_endpoint(snk_in_ep)
assert src.name == "src"
assert filter.name == "filter"
# Verify that src.token is connected to filter.token
assert len(src.outports['token'].endpoints) == 1
assert src.outports['token'].endpoints[0].peer_port.owner.name == filter.name
assert src.outports['token'].endpoints[0].peer_port.owner == filter
assert src.outports['token'].endpoints[0].peer_port.name == "token"
assert src.outports['token'].endpoints[0].peer_port == filter.inports['token']
def test_inport_outport_connection(inport, outport):
out_endpoint = LocalOutEndpoint(outport, inport)
out_endpoint._fifo_mismatch_fix = Mock() # Skip fifo mismatch fixing
in_endpoint = LocalInEndpoint(inport, outport)
in_endpoint._fifo_mismatch_fix = Mock() # Skip fifo mismatch fixing
outport.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "out"}, {}))
outport.attach_endpoint(out_endpoint)
inport.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "in"}, {}))
inport.attach_endpoint(in_endpoint)
assert outport.tokens_available(1)
assert outport.tokens_available(4)
outport.write_token(1)
assert outport.tokens_available(3)
for e in outport.endpoints:
e.communicate()
assert inport.tokens_available(1)
assert inport.peek_token() == 1
inport.peek_cancel()
assert inport.peek_token() == 1
assert inport.tokens_available(0)
def test_set_outport_state(inport, outport):
new_state = {
'properties': {
'routing': 'fanout',
'nbr_peers': 2
},
'name': 'new_name',
'id': '123',
'queue': {
'fifo': [{'value': 1} for n in range(5)],
'N': 5,
'readers': ['123'],
'write_pos': 3,
'read_pos': {'123': 2},
'tentative_read_pos': {'123': 0},
'queuetype': 'fifo'
}
}
out_endpoint = LocalOutEndpoint(outport, inport)
out_endpoint._fifo_mismatch_fix = Mock() # Skip fifo mismatch fixing
in_endpoint = LocalInEndpoint(inport, outport)
in_endpoint._fifo_mismatch_fix = Mock() # Skip fifo mismatch fixing
inport.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "in"}, {}))
inport.attach_endpoint(in_endpoint)
outport.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "out"}, {}))
outport.attach_endpoint(out_endpoint)
outport._set_state(new_state)
assert outport.name == 'new_name'
assert outport.id == '123'
assert outport.properties['nbr_peers'] == 2
assert outport.tokens_available(1)
assert outport.tokens_available(3)
outport.write_token(10)
assert outport.queue.fifo[3] == 10
def test_set_inport_state(inport, outport):
out_endpoint = LocalOutEndpoint(outport, inport)
out_endpoint._fifo_mismatch_fix = Mock() # Skip fifo mismatch fixing
in_endpoint = LocalInEndpoint(inport, outport)
in_endpoint._fifo_mismatch_fix = Mock() # Skip fifo mismatch fixing
outport.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "out"}, {}))
outport.attach_endpoint(out_endpoint)
inport.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "in"}, {}))
inport.attach_endpoint(in_endpoint)
new_state = {
'name': 'new_name',
'id': inport.id,
'queue': {
'fifo': [{'data': n} for n in range(5)],
'N': 5,
'readers': [in_endpoint.port.id],
'write_pos': 5,
'read_pos': {in_endpoint.port.id: 4},
'tentative_read_pos': {in_endpoint.port.id: 2}
}
}
inport._set_state(new_state)
assert inport.name == 'new_name'
assert inport.tokens_available(3)
assert inport.peek_token().value == 2
assert inport.peek_token().value == 3
assert inport.peek_token().value == 4
try:
assert inport.peek_token()
assert False
except queue.common.QueueEmpty:
assert True
except:
assert False
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)
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
