def submit_experiment(testbed_name, board, firmware, duration):
"""
Reserve nodes in the given site.
The function uses the json experiment file corresponding to the site.
:param str firmware: the name of the firmware as it is in the code/firmware/ folder
:param str board: the type of board (ex: m3)
:param str testbed_name: The name of the testbed (ex: grenoble)
:param int duration: The duration of the experiment in minutes
:return: The id of the experiment
"""
# use the file created by auth-cli command
usr, pwd = iotlab.get_user_credentials()
# authenticate through the REST interface
api = iotlab.rest.Api(usr, pwd)
# load the experiment
tb_file = open("{0}states.json".format(METAS_PATH))
tb_json = json.load(tb_file)
nodes = [x for x in tb_json[testbed_name] if board in x]
firmware = FIRMWARE_PATH + firmware
profile = "mercator"
resources = [experiment.exp_resources(nodes, firmware, profile)]
# submit experiment
logconsole.info("Submitting experiment.")
expid = experiment.submit_experiment(api, "mercatorExp", duration,
resources)["id"]
logconsole.info("Experiment submited with id: %u", expid)
logconsole.info("Waiting for experiment to be running.")
experiment.wait_experiment(api, expid)
return expid
def launch_experiment(deployment_site, number_of_nodes, experiment_time,
corridor):
settings = settings_reader.SettingsReader(deployment_site)
ids_text = extract_nodes_ids(str(settings.get_parameter(corridor)))
nodes_ids = []
for item in ids_text:
id_begin, id_end = (int(x) for x in item.split("-"))
nodes_ids.extend(np.arange(id_begin, id_end + 1, 1).tolist())
json_data = json.loads(
experiment.info_experiment(request, site=deployment_site))
nodes_to_reserve = select_candidates(json_data, nodes_ids, number_of_nodes,
deployment_site)
resources = experiment.exp_resources(nodes_to_reserve)
experiment_id = json.loads(
experiment.submit_experiment(
request, '', experiment_time + int(
settings_reader.SettingsReader('experiment').get_parameter(
"extra_time")), resources))["id"]
print_log("Starting new Experiment ({})".format(experiment_id))
print_log("Selected nodes: {}".format(" ".join(nodes_to_reserve)),
header=False)
experiment.wait_experiment(request, experiment_id)
return experiment_id
def test_submit_experiment_a8_physical(api):
resources = exp_resources_from_str("grenoble,a8,1-2")
name = "test_exp_A8"
duration = 2
exp = experiment.submit_experiment(api, name, duration, [resources])
exp_id = exp['id']
experiment.wait_experiment(api, exp_id)
state = experiment.get_experiment(api, exp_id, 'state')
assert state['state'] == "Running"
def _wait_exp(api, exp_id):
""" Wait experiment started """
time.sleep(10) # wait 10s so that 'start date' is set
timestamp = experiment.get_experiment(
api, exp_id, 'start')['start_time']
start_date = time.ctime(timestamp) if timestamp else 'Unknown'
print "Start-date: %s" % start_date
experiment.wait_experiment(api, exp_id)
print "Exp-started: %s" % time.ctime(int(time.time()))
def test_submit_experiment_a8_logical(api, exp):
name = "test_exp_A8"
duration = 2
resources = exp_resources_from_str("2,archi=a8:at86rf231+site=grenoble")
ret = experiment.submit_experiment(api, name, duration, [resources])
exp.id = ret['id']
exp_id = exp.id
experiment.wait_experiment(api, exp_id)
state = experiment.get_experiment(api, exp_id, 'state')
assert state['state'] == "Running"
def wait_exp(self):
""" Wait experiment started """
fabric.utils.puts("wait_exp: %i" % self.exp_id)
time.sleep(10) # wait 10s so that 'start date' is set
timestamp = experiment.get_experiment(
self.api, self.exp_id, 'start')['start_time']
start_date = time.ctime(timestamp) if timestamp else 'Unknown'
fabric.utils.puts("Start-date: %s" % start_date)
experiment.wait_experiment(self.api, self.exp_id)
if self.archi == 'a8:at86rf231':
self.wait_a8_started()
fabric.utils.puts("Exp-started: %s" % start_date)
def wait_exp(self):
""" Wait experiment started """
fabric.utils.puts("wait_exp: %i" % self.exp_id)
time.sleep(10) # wait 10s so that 'start date' is set
timestamp = experiment.get_experiment(self.api, self.exp_id,
'start')['start_time']
start_date = time.ctime(timestamp) if timestamp else 'Unknown'
fabric.utils.puts("Start-date: %s" % start_date)
experiment.wait_experiment(self.api, self.exp_id)
if self.archi == 'a8:at86rf231':
self.wait_a8_started()
fabric.utils.puts("Exp-started: %s" % start_date)
def test_wait_experiment(self, get_exp):
""" Test the wait_experiment function """
self.wait_ret = [
'Waiting', 'Waiting', 'toLaunch', 'Launching', 'Running'
]
get_exp.side_effect = self._get_exp
# simple
ret = experiment.wait_experiment(self.api, 123, step=0)
self.assertEqual('Running', ret)
# Error before Running
self.wait_ret = ['Waiting', 'toLaunch', 'Launching', 'Error']
self.assertRaises(RuntimeError,
experiment.wait_experiment,
self.api,
123,
step=0)
# Timeout
self.wait_ret = []
self.assertRaises(RuntimeError,
experiment.wait_experiment,
self.api,
123,
step=0.1,
timeout=0.5)
def submit_experiment(args):
"""
Reserve nodes in the given site.
The function uses the json experiment file corresponding to the site.
:param str firmware: the name of the firmware as it is in the code/firmware/ folder
:param str board: the type of board (ex: m3)
:param str testbed: The name of the testbed (ex: grenoble)
:param int duration: The duration of the experiment in minutes
:param int nbnodes: The number of nodes to use
:return: The id of the experiment
"""
# use the file created by auth-cli command
usr, pwd = iotlab.get_user_credentials()
# authenticate through the REST interface
api = iotlab.rest.Api(usr, pwd)
# load the experiment
firmware = FIRMWARE_PATH + args.firmware
profile = "mercator"
if args.nbnodes != 0:
if args.board == "m3":
args.board = "m3:at86rf231"
nodes = experiment.AliasNodes(args.nbnodes, args.testbed, args.board)
else:
tb_file = open("{0}states.json".format(METAS_PATH))
tb_json = json.load(tb_file)
nodes = [x for x in tb_json[args.testbed] if args.board in x]
resources = [experiment.exp_resources(nodes, firmware, profile)]
# submit experiment
logconsole.info("Submitting experiment.")
expid = experiment.submit_experiment(
api, "mercatorExp", args.duration,
resources)["id"]
logconsole.info("Experiment submited with id: %u", expid)
logconsole.info("Waiting for experiment to be running.")
experiment.wait_experiment(api, expid)
return expid
def wait_experiment_parser(opts):
""" Parse namespace 'opts' object and execute requested 'wait' command """
user, passwd = auth.get_user_credentials(opts.username, opts.password)
api = rest.Api(user, passwd)
exp_id = helpers.get_current_experiment(api, opts.experiment_id, running_only=False)
sys.stderr.write("Waiting that experiment {0} gets in state {1}\n".format(exp_id, opts.state))
return experiment.wait_experiment(api, exp_id, opts.state, opts.step, opts.timeout)
def wait_experiment_parser(opts):
""" Parse namespace 'opts' object and execute requested 'wait' command """
user, passwd = auth.get_user_credentials(opts.username, opts.password)
api = rest.Api(user, passwd)
exp_id = helpers.get_current_experiment(api,
opts.experiment_id,
running_only=False)
sys.stderr.write("Waiting that experiment {} gets in state {}\n".format(
exp_id, opts.state))
return experiment.wait_experiment(api, exp_id, opts.state, opts.step,
opts.timeout)
def test_wait_experiment(self, get_exp):
""" Test the wait_experiment function """
self.wait_ret = ['Waiting', 'Waiting', 'toLaunch', 'Launching',
'Running']
get_exp.side_effect = self._get_exp
# simple
ret = experiment.wait_experiment(self.api, 123, step=0)
self.assertEqual('Running', ret)
# Error before Running
self.wait_ret = ['Waiting', 'toLaunch', 'Launching', 'Error']
self.assertRaises(RuntimeError, experiment.wait_experiment,
self.api, 123, step=0)
# Timeout
self.wait_ret = []
self.assertRaises(RuntimeError, experiment.wait_experiment,
self.api, 123, step=0.1, timeout=0.5)
def wait_stop(self):
""" Wait the experimentation is Terminated """
experiment.wait_experiment(self.api, self.idexpe, states='Terminated')
def wait_run(self):
""" Wait the experimentation is Running """
experiment.wait_experiment(self.api, self.idexpe, states='Running')
def wait_stop(self):
""" Wait the experimentation is Terminated """
experiment.wait_experiment(self.api, self.idexpe, states='Terminated')
def wait_run(self):
""" Wait the experimentation is Running """
experiment.wait_experiment(self.api, self.idexpe, states='Running')
def wait_for_running(api, exp_id):
experiment.wait_experiment(api, exp_id)
state = experiment.get_experiment(api, exp_id, 'state')
assert state['state'] == "Running"
def test_stop_experiment(api, exp):
api.stop_experiment(exp.id)
# stopped experiments eventually report as Error
experiment.wait_experiment(api, exp.id, states="Error")
def _wait(self):
"""Wait for the experiment to finish launching"""
ret = wait_experiment(Api(*self.user_credentials()), self.exp_id)
return ret
