def create_actor(kind, args):
# Must go after fiddling with calvinsys
from calvin.runtime.north.actormanager import ActorManager
node = Mock()
actor_manager = ActorManager(node)
actor_id = actor_manager.new(kind, args)
actor = actor_manager.actors[actor_id]
return actor
def create_actor(node):
actor_manager = ActorManager(node)
actor_id = actor_manager.new('std.Identity', {})
actor = actor_manager.actors[actor_id]
actor.inports['token'].set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "in"}, {}))
actor.inports['token'].queue.add_reader(actor.inports['token'].id, {})
actor.outports['token'].set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "out"}, {}))
return actor
def create_actor(node):
actor_manager = ActorManager(node)
actor_id = actor_manager.new('std.Identity', {})
actor = actor_manager.actors[actor_id]
actor._calvinsys = Mock()
actor.inports['token'].set_queue(queue.fanout_fifo.FanoutFIFO(5))
actor.inports['token'].queue.add_reader(actor.inports['token'].id)
actor.outports['token'].set_queue(queue.fanout_fifo.FanoutFIFO(5))
return actor
def create_actor(node):
actor_manager = ActorManager(node)
actor_id = actor_manager.new('std.Identity', {})
actor = actor_manager.actors[actor_id]
actor._calvinsys = Mock()
actor.inports['token'].set_queue(queue.fanout_fifo.FanoutFIFO(5))
actor.inports['token'].queue.add_reader(actor.inports['token'].id)
actor.outports['token'].set_queue(queue.fanout_fifo.FanoutFIFO(5))
return actor
class ActorManagerTests(unittest.TestCase):
def setUp(self):
n = DummyNode()
self.am = ActorManager(node=n)
n.am = self.am
def tearDown(self):
pass
def _new_actor(self, a_type, a_args, **kwargs):
a_id = self.am.new(a_type, a_args, **kwargs)
a = self.am.actors.get(a_id, None)
self.assertTrue(a)
return a, a_id
def testNewActor(self):
# Test basic actor creation
a_type = 'std.Constant'
data = 42
a, _ = self._new_actor(a_type, {'data':data})
self.assertEqual(a.data, data)
def testActorStateGet(self):
# Test basic actor state retrieval
a_type = 'std.Constant'
data = 42
a, a_id = self._new_actor(a_type, {'data':data})
s = a.state()
self.assertEqual(s['data'], data)
self.assertEqual(s['id'], a_id)
self.assertEqual(s['n'], 1)
def testNewActorFromState(self):
# Test basic actor state manipulation
a_type = 'std.Constant'
data = 42
a, a_id = self._new_actor(a_type, {'data':data})
a.data = 43
a.n = 2
s = a.state()
self.am.destroy(a_id)
self.assertEqual(len(self.am.actors), 0)
b, b_id = self._new_actor(a_type, None, state = s)
self.assertEqual(a.data, 43)
self.assertEqual(a.n, 2)
# Assert id is preserved
self.assertEqual(a.id, a_id)
# Assert actor database is consistent
self.assertTrue(self.am.actors[a_id])
self.assertEqual(len(self.am.actors), 1)
class ActorManagerTests(unittest.TestCase):
def setUp(self):
n = DummyNode()
self.am = ActorManager(node=n)
n.am = self.am
def tearDown(self):
pass
def _new_actor(self, a_type, a_args, **kwargs):
a_id = self.am.new(a_type, a_args, **kwargs)
a = self.am.actors.get(a_id, None)
self.assertTrue(a)
return a, a_id
def testNewActor(self):
# Test basic actor creation
a_type = 'std.Constant'
data = 42
a, _ = self._new_actor(a_type, {'data': data})
self.assertEqual(a.data, data)
def testActorStateGet(self):
# Test basic actor state retrieval
a_type = 'std.Constant'
data = 42
a, a_id = self._new_actor(a_type, {'data': data})
s = a.state()
self.assertEqual(s['data'], data)
self.assertEqual(s['id'], a_id)
self.assertEqual(s['n'], 1)
def testNewActorFromState(self):
# Test basic actor state manipulation
a_type = 'std.Constant'
data = 42
a, a_id = self._new_actor(a_type, {'data': data})
a.data = 43
a.n = 2
s = a.state()
self.am.destroy(a_id)
self.assertEqual(len(self.am.actors), 0)
b, b_id = self._new_actor(a_type, None, state=s)
self.assertEqual(a.data, 43)
self.assertEqual(a.n, 2)
# Assert id is preserved
self.assertEqual(a.id, a_id)
# Assert actor database is consistent
self.assertTrue(self.am.actors[a_id])
self.assertEqual(len(self.am.actors), 1)
def create_actor(node):
actor_manager = ActorManager(node)
actor_id = actor_manager.new('std.Identity', {})
actor = actor_manager.actors[actor_id]
actor.inports['token'].set_queue(
queue.fanout_fifo.FanoutFIFO({
'queue_length': 4,
'direction': "in"
}, {}))
actor.inports['token'].queue.add_reader(actor.inports['token'].id, {})
actor.outports['token'].set_queue(
queue.fanout_fifo.FanoutFIFO({
'queue_length': 4,
'direction': "out"
}, {}))
return actor
def setUp(self):
n = DummyNode()
self.am = ActorManager(node=n)
n.am = self.am
n.pm.remove_ports_of_actor = Mock(return_value = [])
def create_actor(node):
actor_manager = ActorManager(node)
actor_id = actor_manager.new('std.Identity', {})
actor = actor_manager.actors[actor_id]
return actor
def setUp(self):
n = DummyNode()
self.am = ActorManager(node=n)
n.am = self.am
def setUp(self):
n = DummyNode()
self.am = ActorManager(node=n)
n.am = self.am
def create_actor(node):
actor_manager = ActorManager(node)
actor_id = actor_manager.new('std.Identity', {})
actor = actor_manager.actors[actor_id]
return actor
class ActorManagerTests(unittest.TestCase):
def setUp(self):
n = DummyNode()
self.am = ActorManager(node=n)
n.am = self.am
def tearDown(self):
pass
def _new_actor(self, a_type, a_args, **kwargs):
a_id = self.am.new(a_type, a_args, **kwargs)
a = self.am.actors.get(a_id, None)
self.assertTrue(a)
return a, a_id
def test_new_actor(self):
# Test basic actor creation
a_type = 'std.Constant'
data = 42
a, _ = self._new_actor(a_type, {'data': data})
self.assertEqual(a.data, data)
def test_actor_state_get(self):
# Test basic actor state retrieval
a_type = 'std.Constant'
data = 42
a, a_id = self._new_actor(a_type, {'data': data})
s = a.state()
self.assertEqual(s['data'], data)
self.assertEqual(s['id'], a_id)
self.assertEqual(s['n'], 1)
def test_new_actor_from_state(self):
# Test basic actor state manipulation
a_type = 'std.Constant'
data = 42
a, a_id = self._new_actor(a_type, {'data': data})
a.data = 43
a.n = 2
s = a.state()
self.am.destroy(a_id)
self.assertEqual(len(self.am.actors), 0)
b, b_id = self._new_actor(a_type, None, state=s)
self.assertEqual(a.data, 43)
self.assertEqual(a.n, 2)
# Assert id is preserved
self.assertEqual(a.id, a_id)
# Assert actor database is consistent
self.assertTrue(self.am.actors[a_id])
self.assertEqual(len(self.am.actors), 1)
@patch('calvin.runtime.north.storage.Storage.delete_actor')
@patch('calvin.runtime.north.metering.Metering.remove_actor_info')
def test_destroy_actor(self, remove_actor_info, delete_actor):
actor, actor_id = self._new_actor('std.Constant', {'data': 42})
self.am.destroy(actor_id)
assert actor_id not in self.am.actors
remove_actor_info.assert_called_with(actor_id)
self.am.node.storage.delete_actor.assert_called_with(actor_id)
self.am.node.control.log_actor_destroy.assert_called_with(actor_id)
def test_enable_actor(self):
actor, actor_id = self._new_actor('std.Constant', {'data': 42})
actor.enable = Mock()
self.am.enable(actor_id)
assert actor.enable.called
def test_disable_actor(self):
actor, actor_id = self._new_actor('std.Constant', {'data': 42})
actor.disable = Mock()
self.am.disable(actor_id)
assert actor.disable.called
def test_migrate_to_same_node_does_nothing(self):
callback_mock = Mock()
actor, actor_id = self._new_actor('std.Constant', {'data': 42})
actor.will_migrate = Mock()
self.am.migrate(actor_id, self.am.node.id, callback_mock)
assert not actor.will_migrate.called
assert callback_mock.called
args, kwargs = callback_mock.call_args
self.assertEqual(kwargs['status'].status, 200)
def test_migrate_non_existing_actor_returns_false(self):
callback_mock = Mock()
self.am.migrate("123", self.am.node.id, callback_mock)
assert callback_mock.called
args, kwargs = callback_mock.call_args
self.assertEqual(kwargs['status'].status, 500)
def test_migrate(self):
callback_mock = Mock()
actor, actor_id = self._new_actor('std.Constant', {'data': 42})
actor.outports['token'].set_queue(queue.fanout_fifo.FanoutFIFO(5))
peer_node = DummyNode()
actor.will_migrate = Mock()
self.am.migrate(actor_id, peer_node.id, callback_mock)
assert actor.will_migrate.called
assert self.am.node.pm.disconnect.called
args, kwargs = self.am.node.pm.disconnect.call_args
self.assertEqual(kwargs['actor_id'], actor_id)
cb = kwargs['callback']
self.assertEqual(cb.kwargs['actor'], actor)
self.assertEqual(cb.kwargs['actor_type'], actor._type)
self.assertEqual(cb.kwargs['callback'], callback_mock)
self.assertEqual(cb.kwargs['node_id'], peer_node.id)
self.assertEqual(cb.kwargs['ports'],
actor.connections(self.am.node.id))
self.am.node.control.log_actor_migrate.assert_called_once_with(
actor_id, peer_node.id)
def test_connect(self):
actor, actor_id = self._new_actor('std.Constant', {'data': 42})
connection_list = [['1', '2', '3', '4'], ['5', '6', '7', '8']]
callback_mock = Mock()
self.am.connect(actor_id, connection_list, callback_mock)
self.assertEqual(self.am.node.pm.connect.call_count, 2)
calls = self.am.node.pm.connect.call_args_list
for index, (args, kwargs) in enumerate(calls):
self.assertEqual(kwargs['port_id'], connection_list[index][1])
self.assertEqual(kwargs['peer_node_id'], connection_list[index][2])
self.assertEqual(kwargs['peer_port_id'], connection_list[index][3])
callback = kwargs['callback'].kwargs
self.assertEqual(callback['peer_port_id'],
connection_list[index][3])
self.assertEqual(callback['actor_id'], actor_id)
self.assertEqual(callback['peer_port_ids'], ['4', '8'])
self.assertEqual(callback['_callback'], callback_mock)
def test_connections_returns_actor_connections_for_current_node(self):
actor, actor_id = self._new_actor('std.Constant', {
'data': 42,
'name': 'actor'
})
actor.outports['token'].set_queue(queue.fanout_fifo.FanoutFIFO(5))
expected = {
'actor_name': 'actor',
'actor_id': actor_id,
'inports': {},
'outports': {
actor.outports['token'].id:
actor.outports['token'].get_peers()
}
}
self.assertEqual(self.am.connections(actor_id), expected)
def test_missing_actor(self):
test_functions = [("report", ()), ("destroy", ()), ("enable", ()),
("disable", ()), ("connect", ([], None)),
("connections", ()), ("dump", ()),
("get_port_state", (None, ))]
for func, args in test_functions:
with pytest.raises(Exception) as excinfo:
print func
getattr(self.am, func)('123', *args)
assert "Actor '123' not found" in str(excinfo.value)
def test_actor_type(self):
actor, actor_id = self._new_actor('std.Constant', {
'data': 42,
'name': 'actor'
})
self.assertEqual(self.am.actor_type(actor_id), 'std.Constant')
def test_actor_type_of_missing_actor(self):
self.assertEqual(self.am.actor_type("123"), 'BAD ACTOR')
def test_enabled_actors(self):
actor, actor_id = self._new_actor('std.Constant', {
'data': 42,
'name': 'actor'
})
enabled_actor, enabled_actor_id = self._new_actor(
'std.Constant', {
'data': 42,
'name': 'actor'
})
enabled_actor.enable()
self.assertEqual(self.am.enabled_actors(), [enabled_actor])
def test_list_actors(self):
actor_1, actor_1_id = self._new_actor('std.Constant', {
'data': 42,
'name': 'actor'
})
actor_2, actor_2_id = self._new_actor('std.Constant', {
'data': 42,
'name': 'actor'
})
actors = self.am.list_actors()
assert actor_1_id in actors
assert actor_2_id in actors
class ActorManagerTests(unittest.TestCase):
def setUp(self):
n = DummyNode()
self.am = ActorManager(node=n)
self.am.connection_handler = ConnectionHandler()
n.am = self.am
def tearDown(self):
pass
def _new_actor(self, a_type, a_args, app_id=None, **kwargs):
a_id = self.am.new(a_type, a_args, app_id=app_id, **kwargs)
a = self.am.actors.get(a_id, None)
self.assertTrue(a)
return a, a_id
def testNewActor(self):
# Test basic actor creation
a_type = 'std.Constant'
data = 42
a, _ = self._new_actor(a_type, {'data':data})
self.assertEqual(a.data, data)
def testActorStateGet(self):
# Test basic actor state retrieval
a_type = 'std.Constant'
data = 42
a, a_id = self._new_actor(a_type, {'data':data})
s = a.state()
self.assertEqual(s['data'], data)
self.assertEqual(s['id'], a_id)
self.assertEqual(s['n'], 1)
def testNewActorFromState(self):
# Test basic actor state manipulation
a_type = 'std.Constant'
data = 42
a, a_id = self._new_actor(a_type, {'data': data})
a.data = 43
a.n = 2
s = a.state()
self.am.delete_actor(a_id)
self.assertEqual(len(self.am.actors), 0)
b, b_id = self._new_actor(a_type, None, state=s)
self.assertEqual(a.data, 43)
self.assertEqual(a.n, 2)
# Assert id is preserved
self.assertEqual(a.id, a_id)
# Assert actor database is consistent
self.assertTrue(self.am.actors[a_id])
self.assertEqual(len(self.am.actors), 1)
def testNewReplicaWithState(self):
a_type = 'io.StandardOut'
a, a_id = self._new_actor(a_type, {'name': 'a_name', 'store_tokens': 1})
a.tokens = [1, 2, 3]
state = a.state()
prev_connections = a.connections(self.am.node.id)
prev_connections['port_names'] = a.port_names()
args = a.replication_args()
args['name'] = 'new_name'
self.am.new_replica(a_type, args, state, dict(prev_connections), None, None)
self.assertEqual(len(self.am.actors), 2)
ids = set(self.am.actors.keys())
b_id = (ids | set([a.id])).pop()
b = self.am.actors[b_id]
self.assertEqual(a.tokens, [1, 2, 3])
self.assertEqual(a.store_tokens, 1)
self.assertEqual(b.tokens, [1, 2, 3])
self.assertEqual(b.store_tokens, 1)
# Assert new id is assigned
self.assertNotEqual(b.id, a.id)
# Assert new name is assigned
self.assertNotEqual(b.name, a.name)
# Assert actor database is consistent
self.assertTrue(self.am.actors[a_id])
self.assertTrue(self.am.actors[b.id])
self.assertEqual(len(self.am.actors), 2)
def setUp(self):
n = DummyNode()
self.am = ActorManager(node=n)
n.am = self.am
n.pm.remove_ports_of_actor = Mock(return_value=[])
def create_actor(node):
actor_manager = ActorManager(node)
actor_id = actor_manager.new('std.Identity', {})
actor = actor_manager.actors[actor_id]
actor._calvinsys = Mock()
return actor
def setUp(self):
n = DummyNode()
self.am = ActorManager(node=n)
self.am.connection_handler = ConnectionHandler()
n.am = self.am
class ActorManagerTests(unittest.TestCase):
def setUp(self):
n = DummyNode()
self.am = ActorManager(node=n)
n.am = self.am
n.pm.remove_ports_of_actor = Mock(return_value = [])
def tearDown(self):
pass
def _new_actor(self, a_type, a_args, **kwargs):
a_id = self.am.new(a_type, a_args, **kwargs)
a = self.am.actors.get(a_id, None)
self.assertTrue(a)
return a, a_id
def test_new_actor(self):
# Test basic actor creation
a_type = 'std.Constantify'
constant = 42
a, _ = self._new_actor(a_type, {'constant':constant})
self.assertEqual(a.constant, constant)
def test_actor_state_get(self):
# Test basic actor state retrieval
a_type = 'std.Constantify'
constant = 42
a, a_id = self._new_actor(a_type, {'constant':constant})
s = a.serialize()
self.assertEqual(s['managed']['constant'], constant)
self.assertEqual(s['private']['_id'], a_id)
def test_new_actor_from_state(self):
# Test basic actor state manipulation
a_type = 'std.Constantify'
constant = 42
a, a_id = self._new_actor(a_type, {'constant':constant})
a.constant = 43
s = a.serialize()
self.am.destroy(a_id)
self.assertEqual(len(self.am.actors), 0)
b, b_id = self._new_actor(a_type, None, state = s)
self.assertEqual(a.constant, 43)
# Assert id is preserved
self.assertEqual(a.id, a_id)
# Assert actor database is consistent
self.assertTrue(self.am.actors[a_id])
self.assertEqual(len(self.am.actors), 1)
@patch('calvin.runtime.north.storage.Storage.delete_actor')
def test_destroy_actor(self, delete_actor):
actor, actor_id = self._new_actor('std.Constantify', {'constant': 42})
self.am.destroy(actor_id)
assert actor_id not in self.am.actors
assert self.am.node.storage.delete_actor.call_args[0][0] == actor_id
self.am.node.control.log_actor_destroy.assert_called_with(actor_id)
def test_enable_actor(self):
actor, actor_id = self._new_actor('std.Constantify', {'constant': 42})
actor.enable = Mock()
self.am.enable(actor_id)
assert actor.enable.called
def test_disable_actor(self):
actor, actor_id = self._new_actor('std.Constantify', {'constant': 42})
actor.disable = Mock()
self.am.disable(actor_id)
assert actor.disable.called
def test_migrate_to_same_node_does_nothing(self):
callback_mock = Mock()
actor, actor_id = self._new_actor('std.Constantify', {'constant': 42})
actor.will_migrate = Mock()
self.am.migrate(actor_id, self.am.node.id, callback_mock)
assert not actor.will_migrate.called
assert callback_mock.called
args, kwargs = callback_mock.call_args
self.assertEqual(kwargs['status'].status, 200)
def test_migrate_non_existing_actor_returns_false(self):
callback_mock = Mock()
self.am.migrate("123", self.am.node.id, callback_mock)
assert callback_mock.called
args, kwargs = callback_mock.call_args
self.assertEqual(kwargs['status'].status, 500)
def test_migrate(self):
callback_mock = Mock()
actor, actor_id = self._new_actor('std.Constantify', {'constant': 42})
actor.outports['out'].set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "out"}, {}))
actor.inports['in'].set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "in"}, {}))
peer_node = DummyNode()
actor.will_migrate = Mock()
self.am.migrate(actor_id, peer_node.id, callback_mock)
assert actor.will_migrate.called
assert self.am.node.pm.disconnect.called
args, kwargs = self.am.node.pm.disconnect.call_args
self.assertEqual(kwargs['actor_id'], actor_id)
cb = kwargs['callback']
self.assertEqual(cb.kwargs['actor'], actor)
self.assertEqual(cb.kwargs['actor_type'], actor._type)
self.assertEqual(cb.kwargs['callback'], callback_mock)
self.assertEqual(cb.kwargs['node_id'], peer_node.id)
self.assertEqual(cb.kwargs['ports'], actor.connections(self.am.node.id))
self.am.node.control.log_actor_migrate.assert_called_once_with(actor_id, peer_node.id)
def test_connect(self):
actor, actor_id = self._new_actor('std.Constantify', {'constant': 42})
connection_list = [['1', '2', '3', '4'], ['5', '6', '7', '8']]
callback_mock = Mock()
self.am.connect(actor_id, connection_list, callback_mock)
self.assertEqual(self.am.node.pm.connect.call_count, 2)
calls = self.am.node.pm.connect.call_args_list
for index, (args, kwargs) in enumerate(calls):
self.assertEqual(kwargs['port_id'], connection_list[index][1])
self.assertEqual(kwargs['peer_node_id'], connection_list[index][2])
self.assertEqual(kwargs['peer_port_id'], connection_list[index][3])
callback = kwargs['callback'].kwargs
self.assertEqual(callback['peer_port_id'], connection_list[index][3])
self.assertEqual(callback['actor_id'], actor_id)
self.assertEqual(callback['peer_port_ids'], ['4', '8'])
self.assertEqual(callback['_callback'], callback_mock)
def test_connections_returns_actor_connections_for_current_node(self):
actor, actor_id = self._new_actor('std.Constantify', {'constant': 42, 'name': 'actor'})
actor.outports['out'].set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "out"}, {}))
actor.inports['in'].set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "in"}, {}))
expected = {
'actor_name': 'actor',
'actor_id': actor_id,
'inports': {actor.inports['in'].id: actor.inports['in'].get_peers()},
'outports': {actor.outports['out'].id: actor.outports['out'].get_peers()}
}
self.assertEqual(self.am.connections(actor_id), expected)
def test_missing_actor(self):
test_functions = [("report", ({},)), ("destroy", ()), ("enable", ()), ("disable", ()),
("connect", ([], None)), ("connections", ()), ("dump", ()),
("get_port_state", (None, ))]
for func, args in test_functions:
with pytest.raises(Exception) as excinfo:
print func
getattr(self.am, func)('123', *args)
assert "Actor '123' not found" in str(excinfo.value)
def test_actor_type(self):
actor, actor_id = self._new_actor('std.Constantify', {'constant': 42, 'name': 'actor'})
self.assertEqual(self.am.actor_type(actor_id), 'std.Constantify')
def test_actor_type_of_missing_actor(self):
self.assertEqual(self.am.actor_type("123"), 'BAD ACTOR')
def test_enabled_actors(self):
actor, actor_id = self._new_actor('std.Constantify', {'constant': 42, 'name': 'actor'})
enabled_actor, enabled_actor_id = self._new_actor('std.Constantify', {'constant': 42, 'name': 'actor'})
enabled_actor.enable()
self.assertEqual(self.am.enabled_actors(), [enabled_actor])
def test_list_actors(self):
actor_1, actor_1_id = self._new_actor('std.Constantify', {'constant': 42, 'name': 'actor'})
actor_2, actor_2_id = self._new_actor('std.Constantify', {'constant': 42, 'name': 'actor'})
actors = self.am.list_actors()
assert actor_1_id in actors
assert actor_2_id in actors
def create_actor(node):
actor_manager = ActorManager(node)
actor_id = actor_manager.new('std.Identity', {})
actor = actor_manager.actors[actor_id]
actor._calvinsys = Mock()
return actor
