def test_pub_send_pub_first():
print("Start test: pub_send_pub_first")
username = runtime.get_active_config("username")
userdir = os.path.join("/home", username)
riaps_app_path = os.path.join(userdir,
runtime.get_active_config("riaps_apps_path"))
test_app_path = os.path.join(riaps_app_path,
runtime.get_active_config('app_dir'))
pubActorName = "ActorTest1p"
subActorName = "ActorTest1s"
testId = "pubfirst_" + pubActorName
deployer = runtime.get_deployer(pubActorName)
deployer.start(
testId,
configs={
'sync':
False,
'args': [
os.path.join(test_app_path,
runtime.get_active_config('app_dir') + '.json'),
pubActorName, '--logfile="' + testId + '.log"', '> /dev/null'
]
})
# start test, publisher comes first
#for target in runtime.get_active_config("targets"):
# if target["actor"] == pubActorName:
# deployer = runtime.get_deployer(target["actor"])
# deployer.start(target["actor"], configs={"sync": False})
sleep(2)
testId = "pubfirst_" + subActorName
deployer = runtime.get_deployer(subActorName)
deployer.start(
testId,
configs={
"sync":
False,
'args': [
os.path.join(test_app_path,
runtime.get_active_config('app_dir') + '.json'),
subActorName, '--logfile="' + testId + '.log"', '> /dev/null'
]
})
# start subscriber
#for target in runtime.get_active_config("targets"):
# if target["actor"] == subActorName:
# deployer = runtime.get_deployer(target["actor"])
# deployer.start(target["actor"], configs={"sync": False})
sleep(30)
def test_server_off():
"""
Tests what happens when trying to connect when the server is off
"""
client_deployer = runtime.get_deployer("AdditionClient")
server_deployer = runtime.get_deployer("AdditionServer")
server_deployer.stop("server1")
client_deployer.start("client1", configs={"args": "localhost 8000 1 2 3".split(), "delay": 3})
def test_multi_basic():
"""
Tests single client multiple runs on same server session
"""
client_deployer = runtime.get_deployer("AdditionClient")
server_deployer = runtime.get_deployer("AdditionServer")
server_deployer.hard_bounce("server1")
for i in range(0, 3):
client_deployer.start("client1", configs={"args": "localhost 8000 1 2 3 4".split(), "delay": 3})
def test_fault_tolerance():
"""
Tests what happens when servers are stopped
"""
client_deployer = runtime.get_deployer("AdditionClient")
server_deployer = runtime.get_deployer("AdditionServer")
server_deployer.stop("server2")
server_deployer.stop("server3")
client_deployer.start("client1", configs={"args": "localhost 8000".split() + SMALL_SAMPLE, "sync": True})
def test_server_off():
"""
Tests what happens when trying to connect when the server is off
"""
client_deployer = runtime.get_deployer("AdditionClient")
server_deployer = runtime.get_deployer("AdditionServer")
server_deployer.stop("server1")
client_deployer.start("client1",
configs={
"args": "localhost 8000 1 2 3".split(),
"delay": 3
})
def test_multi_basic():
"""
Tests single client multiple runs on same server session
"""
client_deployer = runtime.get_deployer("AdditionClient")
server_deployer = runtime.get_deployer("AdditionServer")
server_deployer.hard_bounce("server1")
for i in range(0, 3):
client_deployer.start("client1",
configs={
"args": "localhost 8000 1 2 3 4".split(),
"delay": 3
})
def test_negative_correctness():
"""
Tests sending non-integers to the server
"""
client_deployer = runtime.get_deployer("AdditionClient")
client_deployer.start("client1", configs={"args": "localhost 8000 a b 3.14".split(), "sync": True})
client_deployer.start("client2", configs={"args": "localhost 8000 a b 3.14".split(), "sync": True})
def test_connection():
'''
Must connect on machine4 and receive a string.
'''
print "==> Test Connection machine3 and machine4"
client = runtime.get_deployer("client")
client.start("client1", configs={"sync": True})
def test_negative_correctness():
"""
Tests sending non-integers to the server
"""
client_deployer = runtime.get_deployer("AdditionClient")
client_deployer.start("client1", configs={"args": "localhost 8000 a b 3.14".split(), "sync": True})
client_deployer.start("client2", configs={"args": "localhost 8000 a b 3.14".split(), "sync": True})
def teardown():
print("Stop riaps actors...")
# kill all the runing riaps actors
for target in runtime.get_active_config("targets"):
deployerId = "killer_" + target["host"]
deployer = runtime.get_deployer(deployerId)
deployer.start(deployerId, configs={"sync": True})
print("Stop discovery...")
# Stop discovery
for target in runtime.get_active_config("targets"):
deployerId = "discostop_" + target["host"]
deployer = runtime.get_deployer(deployerId)
deployer.start(deployerId, configs={"sync": True})
sleep(10)
print(" -- END -- ")
def test_single_client_perf():
"""
Tests the performance of a server when handling single client
"""
#Leaving the print for proof of order
print "test_single_client_perf"
client_deployer = runtime.get_deployer("AdditionClient")
client_deployer.start("client1", configs={"args": "localhost 8000".split() + MEDIUM_SAMPLE, "sync": True})
def test_multi_client_perf():
"""
Tests the performance of a server when handling multiple clients
"""
client_deployer = runtime.get_deployer("AdditionClient")
client_deployer.start("client1", configs={"args": "localhost 8000".split() + [str(i) for i in range(1, 2000)], "sync": True})
client_deployer.start("client2", configs={"args": "localhost 8000".split() + [str(i) for i in range(1, 2000)], "sync": True})
def test_client_isolation():
"""
Tests what happens when the client is faulty
"""
client_deployer = runtime.get_deployer("AdditionClient")
client_deployer.start("client1", configs={"args": "localhost 8000".split() + LARGE_SAMPLE})
client_deployer.stop("client1")
def test_bouncing_with_state():
"""
Tests that bouncing the server retains state
"""
client_deployer = runtime.get_deployer("AdditionClient")
server_deployer = runtime.get_deployer("AdditionServer")
start_client = lambda: client_deployer.start("client1", configs={"args": "localhost 8000".split() + LARGE_SAMPLE, "sync": True})
client_thread = threading.Thread(target=start_client)
# create a thread that will bounce (stop and start) the server
bounce_server = lambda: server_deployer.soft_bounce("server1")
server_thread = threading.Thread(target=bounce_server)
client_thread.start()
server_thread.start()
client_thread.join()
def test_ordered_events():
"""
Tests that integers to a server are received in the same order that they are sent
"""
client_deployer = runtime.get_deployer("AdditionClient")
# set client to connect to localhost:8000 and send 1, 2, and 3 in that order
client_deployer.start("client1", configs={"args": "localhost 8000 1 2 3".split(), "sync": True})
def await_job(package_id, job_id):
"""
Wait for a Samza job to finish.
"""
logger.info('Awaiting {0}.{1}'.format(package_id, job_id))
samza_job_deployer = runtime.get_deployer(DEPLOYER)
samza_job_deployer.await(job_id, {
'package_id': package_id,
})
def test_redlining():
"""
Sends a large sample of integers to the server.
"""
# obtain the deployer for AdditionClient
client_deployer = runtime.get_deployer("AdditionClient")
# set client to connect to localhost:8000 with a large sample
client_deployer.start("client1", configs={"args": "localhost 8000".split() + LARGE_SAMPLE, "sync": True})
def await_job(package_id, job_id):
"""
Wait for a Samza job to finish.
"""
logger.info('Awaiting {0}.{1}'.format(package_id, job_id))
samza_job_deployer = runtime.get_deployer(DEPLOYER)
samza_job_deployer. await (job_id, {
'package_id': package_id,
})
def test_client_timeout():
"""
Tests what happens when the client does not finish a full request
"""
client_deployer = runtime.get_deployer("AdditionClient")
start_client = lambda: client_deployer.start("client1", configs={"args": "localhost 8000".split() + LARGE_SAMPLE, "sync": True})
timeout_client = lambda: _client_timeout(client_deployer, "client1")
testutilities.start_threads_and_join([start_client, timeout_client])
def test_client_isolation():
"""
Tests what happens when the client is faulty
"""
client_deployer = runtime.get_deployer("AdditionClient")
client_deployer.start(
"client1", configs={"args": "localhost 8000".split() + LARGE_SAMPLE})
client_deployer.stop("client1")
def test_load_balance():
"""
Tests if clients perform correct load balancing
"""
client_deployer = runtime.get_deployer("AdditionClient")
# start the client that will send integers from 1 to 1000
for i in range(3):
client_deployer.start("client1", configs={"args": "localhost 8000".split() + SMALL_SAMPLE, "sync": True})
def setup():
print("Start discovery service...")
# Start discovery
for target in runtime.get_active_config("targets"):
deployerId = "discostart_" + target["host"]
deployer = runtime.get_deployer(deployerId)
deployer.start(deployerId, configs={"sync": False})
sleep(2)
reach_discovery()
def start_job(package_id, job_id, config_file):
"""
Start a Samza job.
"""
logger.info('Starting {0}.{1}'.format(package_id, job_id))
samza_job_deployer = runtime.get_deployer(DEPLOYER)
samza_job_deployer.start(job_id, {
'package_id': package_id,
'config_file': config_file,
})
def test_ping_host1():
print "==> ping example.com (machine1)"
pyhk_deployer = runtime.get_deployer("pyhk")
pyhk_deployer.start(
"machine1",
configs={
"start_command": runtime.get_active_config('ping_cmd'),
"sync": True
})
def test_race_condition():
"""
Tests what happens when two clients send requests to the same server
"""
# obtain the deployer for AdditionClients
client_deployer = runtime.get_deployer("AdditionClient")
start_client1 = lambda: client_deployer.start("client1", configs={"args": "localhost 8000".split() + SMALL_SAMPLE, "sync": True})
start_client2 = lambda: client_deployer.start("client2", configs={"args": "localhost 8000".split() + SMALL_SAMPLE, "sync": True})
testutilities.start_threads_and_join([start_client1, start_client2])
def test_single_client_perf():
"""
Tests the performance of a server when handling single client
"""
client_deployer = runtime.get_deployer("AdditionClient")
client_deployer.start("client1",
configs={
"args": "localhost 8000".split() + MEDIUM_SAMPLE,
"sync": True
})
def start_job(package_id, job_id, config_file):
"""
Start a Samza job.
"""
logger.info('Starting {0}.{1}'.format(package_id, job_id))
samza_job_deployer = runtime.get_deployer(DEPLOYER)
samza_job_deployer.start(job_id, {
'package_id': package_id,
'config_file': config_file,
})
def test_no_valid_ints():
"""
Tests sending non-integers to the server
"""
client_deployer = runtime.get_deployer("AdditionClient")
client_deployer.start("client1",
configs={
"args": "localhost 8000 a b 3.14".split(),
"delay": 3
})
def test_correctness():
"""
Tests if the correct sums are calculated
"""
client_deployer = runtime.get_deployer("AdditionClient")
client_deployer.start("client1", configs={"args": "localhost 8000 1".split(), "sync": True})
client_deployer.start("client1", configs={"args": "localhost 8001 1 2".split(), "sync": True})
client_deployer.start("client1", configs={"args": "localhost 8002 1 2 3".split(), "sync": True})
client_deployer.start("client2", configs={"args": "localhost 8000 1".split(), "sync": True})
client_deployer.start("client2", configs={"args": "localhost 8001 1 2".split(), "sync": True})
client_deployer.start("client2", configs={"args": "localhost 8002 1 2 3".split(), "sync": True})
def test_ordered_events():
"""
Tests that integers to a server are received in the same order that they are sent
"""
client_deployer = runtime.get_deployer("AdditionClient")
# set client to connect to localhost:8000 and send 1, 2, and 3 in that order
client_deployer.start("client1",
configs={
"args": "localhost 8000 1 2 3".split(),
"sync": True
})
def test_correctness():
"""
Tests if the correct sums are calculated
"""
client_deployer = runtime.get_deployer("AdditionClient")
client_deployer.start("client1", configs={"args": "localhost 8000 1".split(), "sync": True})
client_deployer.start("client1", configs={"args": "localhost 8001 1 2".split(), "sync": True})
client_deployer.start("client1", configs={"args": "localhost 8002 1 2 3".split(), "sync": True})
client_deployer.start("client2", configs={"args": "localhost 8000 1".split(), "sync": True})
client_deployer.start("client2", configs={"args": "localhost 8001 1 2".split(), "sync": True})
client_deployer.start("client2", configs={"args": "localhost 8002 1 2 3".split(), "sync": True})
def test_basic():
"""
Trivial interaction between client and server
"""
client_deployer = runtime.get_deployer("AdditionClient")
client_deployer.start("client1", configs={"args": "localhost 8000 1".split(), "delay": 3})
client_deployer.start("client1", configs={"args": "localhost 8001 1 2".split(), "delay": 3})
client_deployer.start("client1", configs={"args": "localhost 8002 1 2 3".split(), "delay": 3})
client_deployer.start("client2", configs={"args": "localhost 8000 1".split(), "delay": 3})
client_deployer.start("client2", configs={"args": "localhost 8001 1 2".split(), "delay": 3})
client_deployer.start("client2", configs={"args": "localhost 8002 1 2 3".split(), "delay": 3})
def test_bouncing_with_state():
"""
Tests that bouncing the server retains state
"""
client_deployer = runtime.get_deployer("AdditionClient")
server_deployer = runtime.get_deployer("AdditionServer")
start_client = lambda: client_deployer.start(
"client1",
configs={
"args": "localhost 8000".split() + LARGE_SAMPLE,
"sync": True
})
client_thread = threading.Thread(target=start_client)
# create a thread that will bounce (stop and start) the server
bounce_server = lambda: server_deployer.soft_bounce("server1")
server_thread = threading.Thread(target=bounce_server)
client_thread.start()
server_thread.start()
client_thread.join()
def test_redlining():
"""
Sends a large sample of integers to the server.
"""
# obtain the deployer for AdditionClient
client_deployer = runtime.get_deployer("AdditionClient")
# set client to connect to localhost:8000 with a large sample
client_deployer.start("client1",
configs={
"args": "localhost 8000".split() + LARGE_SAMPLE,
"sync": True
})
def test_client_timeout():
"""
Tests what happens when the client does not finish a full request
"""
client_deployer = runtime.get_deployer("AdditionClient")
start_client = lambda: client_deployer.start(
"client1",
configs={
"args": "localhost 8000".split() + LARGE_SAMPLE,
"sync": True
})
timeout_client = lambda: _client_timeout(client_deployer, "client1")
testutilities.start_threads_and_join([start_client, timeout_client])
def test_zookeeper_fault_tolerance():
"""
Kill zookeeper1 and see if other zookeeper instances are in quorum
"""
zookeper_deployer = runtime.get_deployer("zookeeper")
kazoo_connection_url = str(runtime.get_active_config('zookeeper_host') + ':2181')
zkclient = KazooClient(hosts=kazoo_connection_url)
zkclient.start()
zkclient.ensure_path("/my/zookeeper_errorinjection")
# kill the Zookeeper1 instance
print "killing zoookeeper instance1"
zookeper_deployer.kill("zookeeper1")
time.sleep(20)
zkclient.stop()
def test_zookeeper_fault_tolerance():
"""
Kill zookeeper1 and see if other zookeeper instances are in quorum
"""
zookeper_deployer = runtime.get_deployer("zookeeper")
kazoo_connection_url = str(
runtime.get_active_config('zookeeper_host') + ':2181')
zkclient = KazooClient(hosts=kazoo_connection_url)
zkclient.start()
zkclient.ensure_path("/my/zookeeper_errorinjection")
# kill the Zookeeper1 instance
print "killing zoookeeper instance1"
zookeper_deployer.kill("zookeeper1")
time.sleep(20)
zkclient.stop()
def test_resilience():
"""
Tests if after killing one of the clients it restarts back correctly within 10 seconds
"""
client_deployer = runtime.get_deployer("AdditionClient")
client_deployer.start("client1", configs={"args": "localhost 8000 1".split(), "sync": True})
client_deployer.start("client2", configs={"args": "localhost 8002 1 2 3".split(), "sync": True})
restart_func_dict = {"client1":{"args": "localhost 8000 1".split(), "sync": True}, "client2" : {"args": "localhost 8002 1 2 3".split(), "sync": True}}
verify_client_recovery_dict = {"client1" : verify_client_recovery, "client2" : verify_client_recovery}
timeout_dict = {"client1" : 10, "client2" : 10}
#Verifies if the client recovers in 10s
testrecipe.test_kill_recovery(client_deployer, ["client1", "client2"], restart_func_dict, verify_client_recovery_dict, timeout_dict)
def test_multi_client_perf():
"""
Tests the performance of a server when handling multiple clients
"""
client_deployer = runtime.get_deployer("AdditionClient")
client_deployer.start("client1",
configs={
"args":
"localhost 8000".split() +
[str(i) for i in range(1, 2000)],
"sync":
True
})
client_deployer.start("client2",
configs={
"args":
"localhost 8000".split() +
[str(i) for i in range(1, 2000)],
"sync":
True
})
def test_resilience():
"""
Tests if after killing one of the clients it restarts back correctly within 10 seconds
"""
client_deployer = runtime.get_deployer("AdditionClient")
client_deployer.start("client1",
configs={
"args": "localhost 8000 1".split(),
"sync": True
})
client_deployer.start("client2",
configs={
"args": "localhost 8002 1 2 3".split(),
"sync": True
})
restart_func_dict = {
"client1": {
"args": "localhost 8000 1".split(),
"sync": True
},
"client2": {
"args": "localhost 8002 1 2 3".split(),
"sync": True
}
}
verify_client_recovery_dict = {
"client1": verify_client_recovery,
"client2": verify_client_recovery
}
timeout_dict = {"client1": 10, "client2": 10}
#Verifies if the client recovers in 10s
testrecipe.test_kill_recovery(client_deployer, ["client1", "client2"],
restart_func_dict,
verify_client_recovery_dict, timeout_dict)
def test_basic():
"""
Trivial interaction between client and server
"""
client_deployer = runtime.get_deployer("AdditionClient")
client_deployer.start("client1",
configs={
"args": "localhost 8000 1".split(),
"delay": 3
})
client_deployer.start("client1",
configs={
"args": "localhost 8001 1 2".split(),
"delay": 3
})
client_deployer.start("client1",
configs={
"args": "localhost 8002 1 2 3".split(),
"delay": 3
})
client_deployer.start("client2",
configs={
"args": "localhost 8000 1".split(),
"delay": 3
})
client_deployer.start("client2",
configs={
"args": "localhost 8001 1 2".split(),
"delay": 3
})
client_deployer.start("client2",
configs={
"args": "localhost 8002 1 2 3".split(),
"delay": 3
})
def teardown_suite(self):
#Terminate Zookeeper
zookeeper_deployer = runtime.get_deployer("zookeeper")
zookeeper_deployer.undeploy("zookeeper")
print "zookeeper terminated"
def reach_discovery():
for target in runtime.get_active_config("targets"):
deployerId = "disco" + target["host"]
deployer = runtime.get_deployer(deployerId)
deployer.start(deployerId, configs={"sync": True})
def teardown_suite(self):
#Terminate Zookeeper
zookeeper_deployer = runtime.get_deployer("zookeeper")
zookeeper_deployer.undeploy("zookeeper")
print "zookeeper terminated"
def test_files_on_etc_host1():
print "==> Check how many files on /etc/ (machine1)"
pyhk_deployer = runtime.get_deployer("pyhk")
pyhk_deployer.start("machine1", configs={
"start_command": runtime.get_active_config('pyhk_cmd'),
"sync": True})
def test_no_valid_ints():
"""
Tests sending non-integers to the server
"""
client_deployer = runtime.get_deployer("AdditionClient")
client_deployer.start("client1", configs={"args": "localhost 8000 a b 3.14".split(), "delay": 3})