def testInOutPortRemoteToRemoteMigration(self):
"""Testing out- and inport remote to remote migration"""
rt = self.runtime
id_ = rt.id
peer0 = self.runtimes[0]
peer0_id = peer0.id
peer1 = self.runtimes[1]
peer1_id = peer1.id
time.sleep(0.5)
snk = utils.new_actor_wargs(rt, 'io.StandardOut', 'snk', store_tokens=1)
sum_ = utils.new_actor(peer0, 'std.Sum', 'sum')
src = utils.new_actor(rt, 'std.CountTimer', 'src')
utils.connect(rt, snk, 'token', peer0_id, sum_, 'integer')
time.sleep(0.5)
utils.connect(peer0, sum_, 'integer', id_, src, 'integer')
time.sleep(0.5)
actual_1 = actual_tokens(rt, snk)
utils.migrate(peer0, sum_, peer1_id)
time.sleep(0.5)
expected = expected_tokens(rt, src, 'std.Sum')
actual = actual_tokens(rt, snk)
assert(len(actual) > 1)
assert(len(actual) > len(actual_1))
self.assertListPrefix(expected, actual)
utils.delete_actor(rt, snk)
utils.delete_actor(peer1, sum_)
utils.delete_actor(rt, src)
def testOutPortLocalToRemoteMigration(self):
"""Testing outport local to remote migration"""
rt = self.runtime
id_ = rt.id
peer = self.runtimes[0]
peer_id = peer.id
snk = utils.new_actor_wargs(rt, 'io.StandardOut', 'snk', store_tokens=1)
sum_ = utils.new_actor(peer, 'std.Sum', 'sum')
src = utils.new_actor(peer, 'std.CountTimer', 'src')
utils.connect(rt, snk, 'token', peer_id, sum_, 'integer')
utils.connect(peer, sum_, 'integer', peer_id, src, 'integer')
time.sleep(0.27)
actual_1 = actual_tokens(rt, snk)
utils.migrate(peer, src, id_)
time.sleep(0.2)
expected = expected_tokens(rt, src, 'std.Sum')
actual = actual_tokens(rt, snk)
assert(len(actual) > 1)
assert(len(actual) > len(actual_1))
self.assertListPrefix(expected, actual)
utils.delete_actor(rt, snk)
utils.delete_actor(peer, sum_)
utils.delete_actor(rt, src)
def testInOutPortLocalRemoteRepeatedMigration(self):
"""Testing outport local to remote migration and revers repeatedly"""
rt = self.runtime
id_ = rt.id
peer = self.runtimes[0]
peer_id = peer.id
snk = utils.new_actor_wargs(rt, 'io.StandardOut', 'snk', store_tokens=1)
sum_ = utils.new_actor(rt, 'std.Sum', 'sum')
src = utils.new_actor(rt, 'std.CountTimer', 'src')
utils.connect(rt, snk, 'token', id_, sum_, 'integer')
utils.connect(rt, sum_, 'integer', id_, src, 'integer')
time.sleep(0.27)
actual_x = []
actual_1 = actual_tokens(rt, snk)
for i in range(5):
if i % 2 == 0:
utils.migrate(rt, sum_, peer_id)
else:
utils.migrate(peer, sum_, id_)
time.sleep(0.2)
actual_x_ = actual_tokens(rt, snk)
assert(len(actual_x_) > len(actual_x))
actual_x = actual_x_
expected = expected_tokens(rt, src, 'std.Sum')
actual = actual_tokens(rt, snk)
assert(len(actual) > 1)
assert(len(actual) > len(actual_1))
self.assertListPrefix(expected, actual)
utils.delete_actor(rt, snk)
utils.delete_actor(peer, sum_)
utils.delete_actor(rt, src)
def testAppDestructionOneRemote(self):
script = """
src : std.CountTimer()
sum : std.Sum()
snk : io.StandardOut(store_tokens=1, quiet=1)
src.integer > sum.integer
sum.integer > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "simple")
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(1)
src = d.actor_map['simple:src']
csum = d.actor_map['simple:sum']
snk = d.actor_map['simple:snk']
utils.migrate(self.rt1, csum, self.rt2.id)
time.sleep(1)
actual = utils.report(self.rt1, snk)
expected = [sum(range(i+1)) for i in range(1,10)]
self.assert_lists_equal(expected, actual)
utils.delete_application(self.rt1, d.app_id)
time.sleep(0.5)
self.assertIsNone(utils.get_actor(self.rt1, src))
self.assertIsNone(utils.get_actor(self.rt1, csum))
self.assertIsNone(utils.get_actor(self.rt1, snk))
self.assertIsNone(utils.get_application(self.rt1, d.app_id))
def testExplicitStateMigration(self):
"""Testing migration of explicit state handling"""
rt = self.runtime
id_ = rt.id
peer0 = self.runtimes[0]
peer0_id = peer0.id
peer1 = self.runtimes[1]
peer1_id = peer1.id
snk = utils.new_actor_wargs(peer0, 'io.StandardOut', 'snk', store_tokens=1)
wrapper = utils.new_actor(rt, 'misc.ExplicitStateExample', 'wrapper')
src = utils.new_actor(rt, 'std.CountTimer', 'src')
utils.connect(peer0, snk, 'token', id_, wrapper, 'token')
utils.connect(rt, wrapper, 'token', id_, src, 'integer')
time.sleep(0.3)
actual_1 = actual_tokens(peer0, snk)
utils.migrate(rt, wrapper, peer0_id)
time.sleep(0.3)
actual = actual_tokens(peer0, snk)
expected = [u'((( 1 )))', u'((( 2 )))', u'((( 3 )))', u'((( 4 )))', u'((( 5 )))', u'((( 6 )))', u'((( 7 )))', u'((( 8 )))']
assert(len(actual) > 1)
assert(len(actual) > len(actual_1))
self.assertListPrefix(expected, actual)
utils.delete_actor(peer0, snk)
utils.delete_actor(peer0, wrapper)
utils.delete_actor(rt, src)
def testSimpleState(self):
_log.analyze("TESTRUN", "+", {})
script = """
src : std.CountTimer()
sum : std.Sum()
snk : io.StandardOut(store_tokens=1, quiet=1)
src.integer > sum.integer
sum.integer > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "simple")
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(1)
csum = d.actor_map['simple:sum']
snk = d.actor_map['simple:snk']
utils.migrate(self.rt1, csum, self.rt2.id)
time.sleep(1)
actual = utils.report(self.rt1, snk)
expected = [sum(range(i+1)) for i in range(1,10)]
self.assert_lists_equal(expected, actual)
d.destroy()
def testExplicitStateMigration(self):
"""Testing migration of explicit state handling"""
rt = self.runtime
id_ = rt.id
peer0 = self.runtimes[0]
peer0_id = peer0.id
peer1 = self.runtimes[1]
peer1_id = peer1.id
snk = utils.new_actor_wargs(peer0, 'io.StandardOut', 'snk', store_tokens=1)
wrapper = utils.new_actor(rt, 'misc.ExplicitStateExample', 'wrapper')
src = utils.new_actor(rt, 'std.CountTimer', 'src')
utils.connect(peer0, snk, 'token', id_, wrapper, 'token')
utils.connect(rt, wrapper, 'token', id_, src, 'integer')
time.sleep(0.3)
actual_1 = actual_tokens(peer0, snk)
utils.migrate(rt, wrapper, peer0_id)
time.sleep(0.3)
actual = actual_tokens(peer0, snk)
expected = [u'((( 1 )))', u'((( 2 )))', u'((( 3 )))', u'((( 4 )))', u'((( 5 )))', u'((( 6 )))', u'((( 7 )))', u'((( 8 )))']
assert(len(actual) > 1)
assert(len(actual) > len(actual_1))
self.assertListPrefix(expected, actual)
utils.delete_actor(peer0, snk)
utils.delete_actor(peer0, wrapper)
utils.delete_actor(rt, src)
def testAppDestructionOneRemote(self):
script = """
src : std.CountTimer()
sum : std.Sum()
snk : io.StandardOut(store_tokens=1, quiet=1)
src.integer > sum.integer
sum.integer > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "simple")
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(1)
src = d.actor_map['simple:src']
csum = d.actor_map['simple:sum']
snk = d.actor_map['simple:snk']
utils.migrate(self.rt1, csum, self.rt2.id)
time.sleep(1)
actual = utils.report(self.rt1, snk)
expected = [sum(range(i + 1)) for i in range(1, 10)]
self.assert_lists_equal(expected, actual)
utils.delete_application(self.rt1, d.app_id)
time.sleep(0.5)
self.assertIsNone(utils.get_actor(self.rt1, src))
self.assertIsNone(utils.get_actor(self.rt1, csum))
self.assertIsNone(utils.get_actor(self.rt1, snk))
self.assertIsNone(utils.get_application(self.rt1, d.app_id))
def testMigrateSink(self):
src = utils.new_actor(self.rt1, 'std.CountTimer', 'src')
snk = utils.new_actor_wargs(self.rt1, 'io.StandardOut', 'snk', store_tokens=1, quiet=1)
utils.connect(self.rt1, snk, 'token', self.rt1.id, src, 'integer')
time.sleep(.4)
utils.migrate(self.rt1, snk, self.rt2.id)
time.sleep(.6)
actual = utils.report(self.rt2, snk)
self.assert_lists_equal(range(1, 10), actual)
def testDestroyAppWithMigratedActors(self):
rt = self.runtime
rt1 = self.runtimes[0]
rt2 = self.runtimes[1]
script = """
src : std.CountTimer()
snk : io.StandardOut(store_tokens=1)
src.integer > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "simple")
d = deployer.Deployer(rt, app_info)
app_id = d.deploy()
time.sleep(1.0)
src = d.actor_map['simple:src']
snk = d.actor_map['simple:snk']
# FIXME --> remove when operating on closed pending connections during migration is fixed
utils.disable(rt, src)
utils.disable(rt, snk)
# <--
utils.migrate(rt, snk, rt1.id)
utils.migrate(rt, src, rt2.id)
applications = utils.get_applications(rt)
assert app_id in applications
d.destroy()
for retry in range(1, 5):
applications = utils.get_applications(rt)
if app_id in applications:
print("Retrying in %s" % (retry * 0.2, ))
time.sleep(0.2 * retry)
else :
break
assert app_id not in applications
for retry in range(1, 5):
actors = []
actors.extend(utils.get_actors(rt))
actors.extend(utils.get_actors(rt1))
actors.extend(utils.get_actors(rt2))
intersection = [a for a in actors if a in d.actor_map.values()]
if len(intersection) > 0:
print("Retrying in %s" % (retry * 0.2, ))
time.sleep(0.2 * retry)
else:
break
for actor in d.actor_map.values():
assert actor not in actors
def testAppDestructionOneRemote(self):
_log.analyze("TESTRUN", "+", {})
script = """
src : std.CountTimer()
sum : std.Sum()
snk : io.StandardOut(store_tokens=1, quiet=1)
src.integer > sum.integer
sum.integer > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "simple")
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(1)
src = d.actor_map['simple:src']
csum = d.actor_map['simple:sum']
snk = d.actor_map['simple:snk']
utils.migrate(self.rt1, csum, self.rt2.id)
time.sleep(.5)
actual = utils.report(self.rt1, snk)
expected = [sum(range(i+1)) for i in range(1,10)]
self.assert_lists_equal(expected, actual)
utils.delete_application(self.rt1, d.app_id)
for a in range(0, 20):
all_removed = None
try:
self.assertIsNone(utils.get_actor(self.rt1, src))
self.assertIsNone(utils.get_actor(self.rt1, csum))
self.assertIsNone(utils.get_actor(self.rt1, snk))
self.assertIsNone(utils.get_actor(self.rt2, src))
self.assertIsNone(utils.get_actor(self.rt2, csum))
self.assertIsNone(utils.get_actor(self.rt2, snk))
self.assertIsNone(utils.get_actor(self.rt3, src))
self.assertIsNone(utils.get_actor(self.rt3, csum))
self.assertIsNone(utils.get_actor(self.rt3, snk))
except AssertionError as e:
print a, e
all_removed = e
if all_removed is None:
break
time.sleep(1)
if all_removed:
raise all_removed
self.assertIsNone(utils.get_application(self.rt1, d.app_id))
self.assertIsNone(utils.get_application(self.rt2, d.app_id))
self.assertIsNone(utils.get_application(self.rt3, d.app_id))
def testMigrateSink(self):
src = utils.new_actor(self.rt1, 'std.CountTimer', 'src')
snk = utils.new_actor_wargs(self.rt1,
'io.StandardOut',
'snk',
store_tokens=1,
quiet=1)
utils.connect(self.rt1, snk, 'token', self.rt1.id, src, 'integer')
time.sleep(.4)
utils.migrate(self.rt1, snk, self.rt2.id)
time.sleep(.6)
actual = utils.report(self.rt2, snk)
self.assert_lists_equal(range(1, 10), actual)
def testTwoStepMigrateSinkSource(self):
_log.analyze("TESTRUN", "+", {})
src = utils.new_actor(self.rt1, 'std.CountTimer', 'src')
snk = utils.new_actor_wargs(self.rt1, 'io.StandardOut', 'snk', store_tokens=1, quiet=1)
utils.connect(self.rt1, snk, 'token', self.rt1.id, src, 'integer')
time.sleep(1)
utils.migrate(self.rt1, snk, self.rt2.id)
time.sleep(1)
utils.migrate(self.rt1, src, self.rt2.id)
time.sleep(1)
actual = utils.report(self.rt2, snk)
self.assert_lists_equal(range(1,15), actual, min_length=10)
utils.delete_actor(self.rt2, src)
utils.delete_actor(self.rt2, snk)
def testMigrateSource(self):
_log.analyze("TESTRUN", "+", {})
src = utils.new_actor(self.rt1, 'std.CountTimer', 'src')
snk = utils.new_actor_wargs(self.rt1, 'io.StandardOut', 'snk', store_tokens=1, quiet=1)
utils.connect(self.rt1, snk, 'token', self.rt1.id, src, 'integer')
time.sleep(1)
utils.migrate(self.rt1, src, self.rt2.id)
interval = 0.5
for retries in range(1,5):
time.sleep(interval * retries)
actual = utils.report(self.rt1, snk)
if len(actual) > 10 :
break
self.assert_lists_equal(range(1, 10), actual)
utils.delete_actor(self.rt2, src)
utils.delete_actor(self.rt1, snk)
def control_actors(args):
if args.cmd == "list":
return utils.get_actors(args.node)
if args.cmd == "info":
if not args.id:
raise Exception("No actor id given")
return utils.get_actor(args.node, args.id)
elif args.cmd == "delete":
if not args.id:
raise Exception("No actor id given")
return utils.delete_actor(args.node, args.id)
elif args.cmd == "migrate":
if not args.id or not args.peer_node:
raise Exception("No actor or peer given")
return utils.migrate(args.node, args.id, args.peer_node)
def control_actors(args):
if args.cmd == 'list':
return utils.get_actors(args.node)
if args.cmd == 'info':
if not args.id:
raise Exception("No actor id given")
return utils.get_actor(args.node, args.id)
elif args.cmd == 'delete':
if not args.id:
raise Exception("No actor id given")
return utils.delete_actor(args.node, args.id)
elif args.cmd == 'migrate':
if not args.id or not args.peer_node:
raise Exception("No actor or peer given")
return utils.migrate(args.node, args.id, args.peer_node)
def control_actors(args):
if args.cmd == 'list':
return utils.get_actors(args.node)
if args.cmd == 'info':
if not args.id:
raise Exception("No actor id given")
return utils.get_actor(args.node, args.id)
elif args.cmd == 'delete':
if not args.id:
raise Exception("No actor id given")
return utils.delete_actor(args.node, args.id)
elif args.cmd == 'migrate':
if not args.id or not args.peer_node:
raise Exception("No actor or peer given")
return utils.migrate(args.node, args.id, args.peer_node)
elif args.cmd == 'replicate':
if not args.id:
raise Exception("No actor id given")
return utils.replicate(args.node, args.id, args.peer_node)
elif args.cmd == 'lost':
if not args.id:
raise Exception("No actor id given")
return utils.lost_actor(args.node, args.id)