def test_stop_stop(self):
"""
CLI test: stop a node will hint it's already stopped
"""
output_start = run_command("infrasim node start")
self.assertEqual(output_start[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_stop_1 = run_command("infrasim node stop")
self.assertEqual(output_stop_1[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_stop_2 = run_command("infrasim node stop")
self.assertEqual(output_stop_2[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
assert "{}-socat starts to run".format(
self.node_name) in output_start[1]
assert "{}-bmc starts to run".format(self.node_name) in output_start[1]
assert "{}-node is running".format(self.node_name) in output_start[1]
assert "{}-socat stop".format(self.node_name) in output_stop_1[1]
assert "{}-bmc stop".format(self.node_name) in output_stop_1[1]
assert "{}-node stop".format(self.node_name) in output_stop_1[1]
assert "[ ] {}-node is stopped".format(
self.node_name) in output_stop_2[1]
assert "[ ] {}-bmc is stopped".format(
self.node_name) in output_stop_2[1]
assert "[ ] {}-socat is stopped".format(
self.node_name) in output_stop_2[1]
def test_start_status_restart_status_destroy_status(self):
"""
CLI test: start, restart and destroy a node and check status respectively
"""
output_status = {}
output_start = run_command("infrasim node start")
self.assertEqual(output_start[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_status["start"] = run_command("infrasim node status")
self.assertEqual(output_status["start"][0], 0)
output_restart = run_command("infrasim node restart")
self.assertEqual(output_restart[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_status["restart"] = run_command("infrasim node status")
self.assertEqual(output_status["restart"][0], 0)
output_destroy = run_command("infrasim node destroy")
self.assertEqual(output_destroy[0], 0)
self.assertFalse(Workspace.check_workspace_exists(self.node_name))
output_status["destroy"] = run_command("infrasim node status")
self.assertEqual(output_status["destroy"][0], 0)
assert "{}-socat is running".format(self.node_name) in output_start[1]
assert "{}-bmc is running".format(self.node_name) in output_start[1]
assert "{}-node is running".format(self.node_name) in output_start[1]
assert "{}-socat is running".format(
self.node_name) in output_status["start"][1]
assert "{}-bmc is running".format(
self.node_name) in output_status["start"][1]
assert "{}-node is running".format(
self.node_name) in output_status["start"][1]
assert "{}-socat is stopped".format(
self.node_name) in output_restart[1]
assert "{}-bmc is stopped".format(self.node_name) in output_restart[1]
assert "{}-node is stopped".format(self.node_name) in output_restart[1]
assert "{}-socat is running".format(
self.node_name) in output_restart[1]
assert "{}-bmc is running".format(self.node_name) in output_restart[1]
assert "{}-node is running".format(self.node_name) in output_restart[1]
assert "{}-socat is running".format(
self.node_name) in output_status["restart"][1]
assert "{}-bmc is running".format(
self.node_name) in output_status["restart"][1]
assert "{}-node is running".format(
self.node_name) in output_status["restart"][1]
assert "Node {} runtime workspace is destroyed".format(
self.node_name) in output_destroy[1]
assert "Node {} runtime workspace doesn't exist".format(
self.node_name) in output_status["destroy"][1]
def test_stop_stop(self):
"""
CLI test: stop a node will hint it's already stopped
"""
output_start = run_command("infrasim node start")
self.assertEqual(output_start[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_stop_1 = run_command("infrasim node stop")
self.assertEqual(output_stop_1[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_stop_2 = run_command("infrasim node stop")
self.assertEqual(output_stop_2[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
assert "{}-socat is running".format(self.node_name) in output_start[1]
assert "{}-bmc is running".format(self.node_name) in output_start[1]
assert "{}-node is running".format(self.node_name) in output_start[1]
assert "{}-socat is stopped".format(self.node_name) in output_stop_1[1]
assert "{}-bmc is stopped".format(self.node_name) in output_stop_1[1]
assert "{}-node is stopped".format(self.node_name) in output_stop_1[1]
assert "{}-node is stopped".format(self.node_name) in output_stop_2[1]
assert "{}-bmc is stopped".format(self.node_name) in output_stop_2[1]
assert "{}-socat is stopped".format(self.node_name) in output_stop_2[1]
def test_start_status_restart_status_destroy_status(self):
"""
CLI test: start, restart and destroy a node and check status respectively
"""
output_status = {}
output_start = run_command("infrasim node start")
self.assertEqual(output_start[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_status["start"] = run_command("infrasim node status")
self.assertEqual(output_status["start"][0], 0)
output_restart = run_command("infrasim node restart")
self.assertEqual(output_restart[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_status["restart"] = run_command("infrasim node status")
self.assertEqual(output_status["restart"][0], 0)
output_destroy = run_command("infrasim node destroy")
self.assertEqual(output_destroy[0], 0)
self.assertFalse(Workspace.check_workspace_exists(self.node_name))
output_status["destroy"] = run_command("infrasim node status")
self.assertEqual(output_status["destroy"][0], 0)
assert "{}-socat is running".format(self.node_name) in output_start[1]
assert "{}-bmc is running".format(self.node_name) in output_start[1]
assert "{}-node is running".format(self.node_name) in output_start[1]
assert "{}-socat is running".format(self.node_name) in output_status["start"][1]
assert "{}-bmc is running".format(self.node_name) in output_status["start"][1]
assert "{}-node is running".format(self.node_name) in output_status["start"][1]
assert "{}-socat is stopped".format(self.node_name) in output_restart[1]
assert "{}-bmc is stopped".format(self.node_name) in output_restart[1]
assert "{}-node is stopped".format(self.node_name) in output_restart[1]
assert "{}-socat is running".format(self.node_name) in output_restart[1]
assert "{}-bmc is running".format(self.node_name) in output_restart[1]
assert "{}-node is running".format(self.node_name) in output_restart[1]
assert "{}-socat is running".format(self.node_name) in output_status["restart"][1]
assert "{}-bmc is running".format(self.node_name) in output_status["restart"][1]
assert "{}-node is running".format(self.node_name) in output_status["restart"][1]
assert "Node {} runtime workspace is destroyed".format(self.node_name) in output_destroy[1]
assert "Node {} runtime workspace doesn't exist".format(self.node_name) in output_status["destroy"][1]
def destroy(self, node_name):
if Workspace.check_workspace_exists(node_name):
try:
node_info = Workspace.get_node_info_in_workspace(node_name)
except InfraSimError, e:
print e.value
return
def destroy(self, node_name):
if Workspace.check_workspace_exists(node_name):
try:
node_info = Workspace.get_node_info_in_workspace(node_name)
except InfraSimError as e:
print e.value
logger_cmd.error("cmd res: {}".format(e.value))
return
else:
print "Node {} runtime workspace is not found, destroy action is not applied.".\
format(node_name)
logger_cmd.warning(
"cmd res: Node {} runtime workspace is not found, "
"destroy action is not applied.".format(node_name))
return
node = model.CNode(node_info)
try:
self._node_preinit(node, ignore_check=True)
except InfraSimError as e:
print(e.value)
logger_cmd.error("cmd res: {}".format(e.value))
except Exception as e:
print(e)
logger_cmd.error("cmd res: {}".format(e))
try:
node.stop()
node.terminate_workspace()
logger_cmd.info("cmd res: destroy node {} OK".format(node_name))
except Exception as e:
print(
"You have to destroy node {} manually due to fatal error: {}".
format(node_name, e))
def start(self, node_name):
try:
if Workspace.check_workspace_exists(node_name):
node_info = Workspace.get_node_info_in_workspace(node_name)
else:
node_info = nm.get_item_info(node_name)
node = model.CNode(node_info)
self._node_preinit(node)
except InfraSimError as e:
print e.value
logger_cmd.error("cmd res: {}".format(e.value))
return
node.start()
vnc_port = node_info["compute"].get("vnc_display", 1) + 5900
# get IP address
print "Infrasim service started.\n" \
"Node {} graphic interface accessible via: \n" \
"VNC port: {} \n" \
"Either host IP: {} \n" \
"depending on host in which network VNC viewer is running \n"\
"Node log folder: {}". \
format(node.get_node_name(),
vnc_port,
helper.ip4_addresses(netns=node_info.get("namespace")),
infrasim_log.get_log_path(node_name))
logger_cmd.info("cmd res: start node {} OK".format(node_name))
def test_init(self):
"""
CLI test: test init "-f" which will remove existing workspace
"""
output_info = {}
output_start = run_command("infrasim node start")
self.assertEqual(output_start[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_info['start'] = run_command("infrasim node info")
self.assertEqual(output_info['start'][0], 0)
self.assertRaises(CommandRunFailed, run_command,
cmd="infrasim init -s", shell=True,
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
run_command("infrasim init -s -f")
self.assertEqual(len(os.listdir(config.infrasim_home)), 1)
# Verify if it will reinstall packages when user confirmed 'Y'
result = run_command_with_user_input("infrasim init", True, subprocess.PIPE, subprocess.PIPE, subprocess.PIPE, "Y\nY\nY\n")
assert "downloading Infrasim_Qemu" in result[1]
assert "downloading OpenIpmi" in result[1]
assert "downloading Seabios" in result[1]
result = run_command_with_user_input("infrasim init", True, subprocess.PIPE, subprocess.PIPE, subprocess.PIPE, "Y\nyes\nn\n")
assert "downloading Infrasim_Qemu" in result[1]
assert "downloading OpenIpmi" in result[1]
assert "downloading Seabios" not in result[1]
result = run_command_with_user_input("infrasim init", True, subprocess.PIPE, subprocess.PIPE, subprocess.PIPE, "no\nN\nY\n")
assert "downloading Infrasim_Qemu" not in result[1]
assert "downloading OpenIpmi" not in result[1]
assert "downloading Seabios" in result[1]
def destroy(self, node_name):
if Workspace.check_workspace_exists(node_name):
try:
node_info = Workspace.get_node_info_in_workspace(node_name)
except InfraSimError, e:
print e.value
logger_cmd.error("cmd res: {}".format(e.value))
return
def destroy(self, node_name):
if Workspace.check_workspace_exists(node_name):
try:
node_info = Workspace.get_node_info_in_workspace(node_name)
except InfraSimError, e:
print e.value
logger_cmd.error("cmd res: {}".format(e.value))
return
def destroy(self, chassis_name=None):
if Workspace.check_workspace_exists(chassis_name):
try:
chassis_info = ChassisWorkspace.get_chassis_info_in_workspace(chassis_name)
except InfraSimError, e:
print e.value
logger_cmd.error("cmd res: {}".format(e.value))
return
def wrapper(*args, **kwargs):
frame = inspect.currentframe()
frame_args, _, _, values = inspect.getargvalues(frame)
node_name = values["args"][1]
if not Workspace.check_workspace_exists(node_name):
print "Node {} runtime workspace doesn't exist".format(node_name)
return
return func(*args, **kwargs)
def terminate_workspace(self):
if Workspace.check_workspace_exists(self.__node_name):
shutil.rmtree(self.workspace.get_workspace())
self.__logger.info(
"[Node] Node {} runtime workspcace is destroyed".format(
self.__node_name))
print "Node {} runtime workspace is destroyed.".format(
self.__node_name)
def test_start_destroy(self):
"""
CLI test: start, then destroy the node directly
"""
output_start = run_command("infrasim node start")
self.assertEqual(output_start[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_destroy = run_command("infrasim node destroy")
self.assertEqual(output_destroy[0], 0)
self.assertFalse(Workspace.check_workspace_exists(self.node_name))
assert "{}-socat is running".format(self.node_name) in output_start[1]
assert "{}-bmc is running".format(self.node_name) in output_start[1]
assert "{}-node is running".format(self.node_name) in output_start[1]
assert "Node {} runtime workspace is destroyed".format(self.node_name) in output_destroy[1]
def test_start_destroy(self):
"""
CLI test: start, then destroy the node directly
"""
output_start = run_command("infrasim node start")
self.assertEqual(output_start[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_destroy = run_command("infrasim node destroy")
self.assertEqual(output_destroy[0], 0)
self.assertFalse(Workspace.check_workspace_exists(self.node_name))
assert "{}-socat is running".format(self.node_name) in output_start[1]
assert "{}-bmc is running".format(self.node_name) in output_start[1]
assert "{}-node is running".format(self.node_name) in output_start[1]
assert "Node {} runtime workspace is destroyed".format(self.node_name) in output_destroy[1]
def test_destory_destroy(self):
"""
CLI test: fail to destroy a destroyed node
"""
output_start = run_command("infrasim node start")
self.assertEqual(output_start[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_destroy_1 = run_command("infrasim node destroy")
self.assertEqual(output_destroy_1[0], 0)
self.assertFalse(Workspace.check_workspace_exists(self.node_name))
output_destroy_2 = run_command("infrasim node destroy")
self.assertEqual(output_destroy_2[0], 0)
self.assertFalse(Workspace.check_workspace_exists(self.node_name))
assert "Node {} runtime workspace is destroyed".format(self.node_name) in output_destroy_1[1]
assert "Node {} runtime workspace is not found".format(self.node_name) in output_destroy_2[1]
def wrapper(*args, **kwargs):
frame = inspect.currentframe()
frame_args, _, _, values = inspect.getargvalues(frame)
node_name = values["args"][1]
if not Workspace.check_workspace_exists(node_name):
print "Node {} runtime workspace doesn't exist".format(node_name)
logger_cmd.warning("cmd res: Node {} runtime workspace doesn't exist".format(node_name))
return
return func(*args, **kwargs)
def test_destory_destroy(self):
"""
CLI test: fail to destroy a destroyed node
"""
output_start = run_command("infrasim node start")
self.assertEqual(output_start[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_destroy_1 = run_command("infrasim node destroy")
self.assertEqual(output_destroy_1[0], 0)
self.assertFalse(Workspace.check_workspace_exists(self.node_name))
output_destroy_2 = run_command("infrasim node destroy")
self.assertEqual(output_destroy_2[0], 0)
self.assertFalse(Workspace.check_workspace_exists(self.node_name))
assert "Node {} runtime workspace is destroyed".format(self.node_name) in output_destroy_1[1]
assert "Node {} runtime workspace is not found".format(self.node_name) in output_destroy_2[1]
def test_start_info_destroy_info(self):
"""
CLI test: start and destroy a node, and get node_info respectively
"""
output_info = {}
output_start = run_command("infrasim node start")
self.assertEqual(output_start[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_info['start'] = run_command("infrasim node info")
self.assertEqual(output_info['start'][0], 0)
output_destroy = run_command("infrasim node destroy")
self.assertEqual(output_destroy[0], 0)
self.assertFalse(Workspace.check_workspace_exists(self.node_name))
output_info['destroy'] = run_command("infrasim node info")
self.assertEqual(output_info['destroy'][0], 0)
assert "{}-socat starts to run".format(
self.node_name) in output_start[1]
assert "{}-bmc starts to run".format(self.node_name) in output_start[1]
assert "{}-node is running".format(self.node_name) in output_start[1]
assert "node name: {}".format(
self.node_name) in output_info['start'][1]
assert "type:" in output_info['start'][1]
assert "memory size:" in output_info['start'][1]
assert "sol_enable:" in output_info['start'][1]
assert "cpu quantities:" in output_info['start'][1]
assert "cpu type:" in output_info['start'][1]
assert "network(s):" in output_info['start'][1]
assert "device" in output_info['start'][1]
assert "mode" in output_info['start'][1]
assert "name " in output_info['start'][1]
assert "storage backend:" in output_info['start'][1]
assert "type " in output_info['start'][1]
assert "max drive" in output_info['start'][1]
assert "drive size" in output_info['start'][1]
assert "Node {} runtime workspace is destroyed".format(
self.node_name) in output_destroy[1]
assert "Node {} runtime workspace doesn't exist".format(
self.node_name) in output_info['destroy'][1]
def test_start_start(self):
"""
CLI test: start a started node will hint it's running
"""
output_start_1 = run_command("infrasim node start")
self.assertEqual(output_start_1[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_start_2 = run_command("infrasim node start")
self.assertEqual(output_start_2[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
assert "{}-socat is running".format(self.node_name) in output_start_1[1]
assert "{}-bmc is running".format(self.node_name) in output_start_1[1]
assert "{}-node is running".format(self.node_name) in output_start_1[1]
assert "{}-socat is running".format(self.node_name) in output_start_2[1]
assert "{}-bmc is running".format(self.node_name) in output_start_2[1]
assert "{}-node is running".format(self.node_name) in output_start_2[1]
def test_start_start(self):
"""
CLI test: start a started node will hint it's running
"""
output_start_1 = run_command("infrasim node start")
self.assertEqual(output_start_1[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_start_2 = run_command("infrasim node start")
self.assertEqual(output_start_2[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
assert "{}-socat starts to run".format(self.node_name) in output_start_1[1]
assert "{}-bmc starts to run".format(self.node_name) in output_start_1[1]
assert "{}-node is running".format(self.node_name) in output_start_1[1]
assert "{}-socat is already running".format(self.node_name) in output_start_2[1]
assert "{}-bmc is already running".format(self.node_name) in output_start_2[1]
assert "{}-node is running".format(self.node_name) in output_start_2[1]
def start(self, node_name):
try:
if Workspace.check_workspace_exists(node_name):
node_info = Workspace.get_node_info_in_workspace(node_name)
else:
node_info = nm.get_node_info(node_name)
node = model.CNode(node_info)
self._node_preinit(node)
except InfraSimError, e:
print e.value
return
def test_start_info_destroy_info(self):
"""
CLI test: start and destroy a node, and get node_info respectively
"""
output_info = {}
output_start = run_command("infrasim node start")
self.assertEqual(output_start[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_info['start'] = run_command("infrasim node info")
self.assertEqual(output_info['start'][0], 0)
output_destroy = run_command("infrasim node destroy")
self.assertEqual(output_destroy[0], 0)
self.assertFalse(Workspace.check_workspace_exists(self.node_name))
output_info['destroy'] = run_command("infrasim node info")
self.assertEqual(output_info['destroy'][0], 0)
assert "{}-socat is running".format(self.node_name) in output_start[1]
assert "{}-bmc is running".format(self.node_name) in output_start[1]
assert "{}-node is running".format(self.node_name) in output_start[1]
assert "node name: {}".format(self.node_name) in output_info['start'][1]
assert "type:" in output_info['start'][1]
assert "memory size:" in output_info['start'][1]
assert "sol_enable:" in output_info['start'][1]
assert "cpu quantities:" in output_info['start'][1]
assert "cpu type:" in output_info['start'][1]
assert "network(s):" in output_info['start'][1]
assert "device" in output_info['start'][1]
assert "mode" in output_info['start'][1]
assert "name " in output_info['start'][1]
assert "storage backend:" in output_info['start'][1]
assert "type " in output_info['start'][1]
assert "max drive" in output_info['start'][1]
assert "drive size" in output_info['start'][1]
assert "Node {} runtime workspace is destroyed".format(self.node_name) in output_destroy[1]
assert "Node {} runtime workspace doesn't exist".format(self.node_name) in output_info['destroy'][1]
def start(self, node_name):
try:
if Workspace.check_workspace_exists(node_name):
node_info = Workspace.get_node_info_in_workspace(node_name)
else:
node_info = nm.get_node_info(node_name)
node = model.CNode(node_info)
self._node_preinit(node)
except InfraSimError, e:
print e.value
logger_cmd.error("cmd res: {}".format(e.value))
return
def start(self, node_name):
try:
if Workspace.check_workspace_exists(node_name):
node_info = Workspace.get_node_info_in_workspace(node_name)
else:
node_info = nm.get_node_info(node_name)
node = model.CNode(node_info)
self._node_preinit(node)
except InfraSimError, e:
print e.value
logger_cmd.error("cmd res: {}".format(e.value))
return
def update(self, node_name, config_file):
try:
nm.update(node_name, config_file)
logger_cmd.info("cmd res: update node {} OK".format(node_name))
except InfraSimError as e:
print e.value
logger_cmd.error("cmd res: {}".format(e.value))
if Workspace.check_workspace_exists(node_name):
print "Node {0} runtime workspace exists.\n" \
"If you want to apply updated configuration, please destroy node runtime workspace first.\n" \
"You can run commands: \n" \
" infrasim node destroy {0}\n" \
" infrasim node start {0}".format(node_name)
logger_cmd.warning(
"Node {0} runtime workspace exists. "
"Need to destroy node runtime workspace first".format(
node_name))
def update(self, name, config_file):
try:
mm = self._get_map_manager(name, config_file)
mm.update(name, config_file)
logger_cmd.info("cmd res: update {} OK".format(name))
except InfraSimError as e:
print e.value
logger_cmd.error("cmd res: {}".format(e.value))
if Workspace.check_workspace_exists(name):
print "{1} {0} runtime workspace exists.\n" \
"If you want to apply updated configuration, please destroy runtime workspace first.\n" \
"You can run commands: \n" \
" infrasim {1} destroy {0}\n" \
" infrasim {1} start {0}".format(name, mm.get_type())
logger_cmd.warning(
"{1} {0} runtime workspace exists. "
"Need to destroy {1} runtime workspace first".format(
name, mm.get_type()))
def test_init(self):
"""
CLI test: test init "-f" which will remove existing workspace
"""
output_info = {}
output_start = run_command("infrasim node start")
self.assertEqual(output_start[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_info['start'] = run_command("infrasim node info")
self.assertEqual(output_info['start'][0], 0)
self.assertRaises(CommandRunFailed,
run_command,
cmd="infrasim init -s",
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
run_command("infrasim init -s -f")
self.assertEqual(len(os.listdir(config.infrasim_home)), 1)
# Verify if it will reinstall packages when user confirmed 'Y'
result = run_command_with_user_input("infrasim init", True,
subprocess.PIPE, subprocess.PIPE,
subprocess.PIPE, "Y\nY\nY\n")
assert "downloading Infrasim_Qemu" in result[1]
assert "downloading OpenIpmi" in result[1]
assert "downloading Seabios" in result[1]
result = run_command_with_user_input("infrasim init", True,
subprocess.PIPE, subprocess.PIPE,
subprocess.PIPE, "Y\nyes\nn\n")
assert "downloading Infrasim_Qemu" in result[1]
assert "downloading OpenIpmi" in result[1]
assert "downloading Seabios" not in result[1]
result = run_command_with_user_input("infrasim init", True,
subprocess.PIPE, subprocess.PIPE,
subprocess.PIPE, "no\nN\nY\n")
assert "downloading Infrasim_Qemu" not in result[1]
assert "downloading OpenIpmi" not in result[1]
assert "downloading Seabios" in result[1]
def test_init(self):
"""
CLI test: test init "-f" which will remove existing workspace
"""
output_info = {}
output_start = run_command("infrasim node start")
self.assertEqual(output_start[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_info['start'] = run_command("infrasim node info")
self.assertEqual(output_info['start'][0], 0)
self.assertRaises(CommandRunFailed,
run_command,
cmd="infrasim init -s",
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
run_command("infrasim init -s -f")
self.assertEqual(len(os.listdir(config.infrasim_home)), 1)
def edit(self, chassis_name):
if chassis_name not in cm.get_name_list():
print "Fail to find chassis {0} configuration. It is not registered. Check by:\n" \
" infrasim config list".format(chassis_name)
logger_cmd.warning("cmd res: Fail to find chassis {0} configuration. It is not registered. Check by:\n"
" infrasim config list".format(chassis_name))
return
editor = os.environ.get('EDITOR', 'vi')
config_path = os.path.join(cm.get_mapping_folder(),
"{}.yml".format(chassis_name))
try:
os.system("{} {}".format(editor, config_path))
if Workspace.check_workspace_exists(chassis_name):
print "Warning: " \
"\033[93mPlease destroy chassis {}\033[0m " \
"before start or restart, " \
"or this edit won't work." .format(chassis_name)
logger_cmd.info("cmd res: edit chassis {} OK".format(chassis_name))
except OSError, e:
print e
logger_cmd.error("cmd res: {}".format(e))
def edit(self, node_name):
if node_name not in nm.get_name_list():
print "Fail to find node {0} configuration. It is not registered. Check by:\n" \
" infrasim config list".format(node_name)
logger_cmd.warning("cmd res: Fail to find node {0} configuration. It is not registered. Check by:\n"
" infrasim config list".format(node_name))
return
editor = os.environ.get('EDITOR', 'vi')
config_path = os.path.join(nm.get_mapping_folder(),
"{}.yml".format(node_name))
try:
os.system("{} {}".format(editor, config_path))
if Workspace.check_workspace_exists(node_name):
print "Warning: " \
"\033[93mPlease destroy node {}\033[0m " \
"before start or restart, " \
"or this edit won't work." .format(node_name)
logger_cmd.info("cmd res: edit node {} OK".format(node_name))
except OSError, e:
print e
logger_cmd.error("cmd res: {}".format(e))
def destroy(self, chassis_name=None):
if Workspace.check_workspace_exists(chassis_name):
try:
chassis_info = ChassisWorkspace.get_chassis_info_in_workspace(
chassis_name)
except InfraSimError as e:
print e.value
logger_cmd.error("cmd res: {}".format(e.value))
return
else:
print "Chassis {} runtime workspace is not found, destroy action is not applied.".\
format(chassis_name)
logger_cmd.warning(
"cmd res: Chassis {} runtime workspace is not found, "
"destroy action is not applied.".format(chassis_name))
return
chassis = model.CChassis(chassis_name, chassis_info)
try:
chassis.init()
chassis.destroy()
except InfraSimError as e:
print e.value
logger_cmd.error("cmd res: {}".format(e.value))
logger_cmd.info("cmd res: destroy chassis {} OK".format(chassis_name))
except InfraSimError, e:
print e.value
logger_cmd.error("cmd res: {}".format(e.value))
@args("name", help="Specify name to update configuration mapping")
@args("config_file", help="Node Config File Path")
def update(self, name, config_file):
try:
mm = self._get_map_manager(name, config_file)
mm.update(name, config_file)
logger_cmd.info("cmd res: update {} OK".format(name))
except InfraSimError, e:
print e.value
logger_cmd.error("cmd res: {}".format(e.value))
if Workspace.check_workspace_exists(name):
print "Node {0} runtime workspace exists.\n" \
"If you want to apply updated configuration, please destroy runtime workspace first.\n" \
"You can run commands: \n" \
" infrasim node destroy {0}\n" \
" infrasim node start {0}".format(name)
logger_cmd.warning("Node {0} runtime workspace exists. "
"Need to destroy node runtime workspace first".format(name))
@args("name", nargs='?', default="default",
help="Specify name to open its configuration in editor")
def edit(self, name):
mm = self._get_map_manager(name)
if name not in mm.get_name_list():
print "Fail to find {0} configuration. It is not registered. Check by:\n" \
" infrasim config list".format(name)
def init_env(instance):
"""
This is to sync ipmi-console with runtime vBMC configuration.
Initial version capture infrasim instance name by infrasim-main status, while we
have a plan to give instance name to ipmi-console so that it can be attached to
target vBMC instance.
"""
if not Workspace.check_workspace_exists(instance):
raise IpmiError("Warning: there is no node {} workspace. Please start node {} first.".format(instance, instance))
output = run_command("infrasim node status")
if output[0] == 0 and "{}-bmc is stopped".format(instance) in output[1]:
raise IpmiError("Warning: node {} has not started BMC. Please start node {} first.".format(instance, instance))
logger.info("Init ipmi-console environment for infrasim instance: {}".
format(instance))
# Get runtime vbmc.conf
vbmc_conf_path = os.path.join(os.environ["HOME"], ".infrasim", instance, "etc", "vbmc.conf")
if not os.path.exists(vbmc_conf_path):
msg = "{} vBMC configuration is not defined at {}".format(instance, vbmc_conf_path)
logger.error(msg)
raise Exception(msg)
else:
msg = "Target vbmc to attach is: {}".format(vbmc_conf_path)
logger.info(msg)
# Get runtime infrasim.yml
infrasim_yml_path = os.path.join(os.environ["HOME"], ".infrasim", instance, "etc", "infrasim.yml")
if not os.path.exists(infrasim_yml_path):
msg = "{} infrasim instance is not defined at {}".format(instance, infrasim_yml_path)
logger.error(msg)
raise Exception(msg)
else:
msg = "Target infrasim instance to attach is: {}".format(infrasim_yml_path)
logger.info(msg)
# Get variable and set to ipmi-console env
# - PORT_TELNET_TO_VBMC
# - VBMC_IP
# - VBMC_PORT
with open(vbmc_conf_path, 'r') as fp:
conf = fp.read()
p_telnet = re.compile(r"^\s*console\s*[\d:\.]+\s+(?P<port_telnet_to_vbmc>\d+)",
re.MULTILINE)
s_telnet = p_telnet.search(conf)
if s_telnet:
env.PORT_TELNET_TO_VBMC = int(s_telnet.group("port_telnet_to_vbmc"))
logger.info("PORT_TELNET_TO_VBMC: {}".format(env.PORT_TELNET_TO_VBMC))
else:
raise Exception("PORT_TELNET_TO_VBMC is not found")
p_vbmc = re.compile(r"^\s*addr\s*(?P<vbmc_ip>[\d:\.]+)\s*(?P<vbmc_port>\d+)",
re.MULTILINE)
s_vbmc = p_vbmc.search(conf)
if s_vbmc:
ip = s_vbmc.group("vbmc_ip")
if ip == "::" or ip == "0.0.0.0":
env.VBMC_IP = "localhost"
else:
env.VBMC_IP = ip
logger.info("VBMC_IP: {}".format(env.VBMC_IP))
env.VBMC_PORT = int(s_vbmc.group("vbmc_port"))
logger.info("VBMC_PORT: {}".format(env.VBMC_PORT))
else:
raise Exception("VBMC_IP and VBMC_PORT is not found")
# Get variable and set to ipmi-console env
# - PORT_SSH_FOR_CLIENT
with open(infrasim_yml_path, 'r') as fp:
conf = fp.read()
p_port = re.compile(r"^\s*ipmi_console_ssh:\s*(?P<port_ssh_for_client>\d+)",
re.MULTILINE)
s_port = p_port.search(conf)
if s_port:
env.PORT_SSH_FOR_CLIENT = int(s_port.group("port_ssh_for_client"))
else:
env.PORT_SSH_FOR_CLIENT = 9300
logger.info("PORT_SSH_FOR_CLIENT: {}".format(env.PORT_SSH_FOR_CLIENT))
@args("node_name", help="Specify node name to delete configuration mapping")
def delete(self, node_name):
try:
nm.delete(node_name)
except InfraSimError, e:
print e.value
@args("node_name", help="Specify node name to update configuration mapping")
@args("config_file", help="Node Config File Path")
def update(self, node_name, config_file):
try:
nm.update(node_name, config_file)
except InfraSimError, e:
print e.value
if Workspace.check_workspace_exists(node_name):
print "Node {0} runtime workspace exists.\n" \
"If you want to apply updated configuration, please destroy node runtime workspace first.\n" \
"You can run commands: \n" \
" infrasim node destroy {0}\n" \
" infrasim node start {0}".format(node_name)
def list(self):
try:
nm.list()
except InfraSimError, e:
print e.value
class NodeCommands(object):
except InfraSimError, e:
print e.value
logger_cmd.error("cmd res: {}".format(e.value))
@args("node_name",
help="Specify node name to update configuration mapping")
@args("config_file", help="Node Config File Path")
def update(self, node_name, config_file):
try:
nm.update(node_name, config_file)
logger_cmd.info("cmd res: update node {} OK".format(node_name))
except InfraSimError, e:
print e.value
logger_cmd.error("cmd res: {}".format(e.value))
if Workspace.check_workspace_exists(node_name):
print "Node {0} runtime workspace exists.\n" \
"If you want to apply updated configuration, please destroy node runtime workspace first.\n" \
"You can run commands: \n" \
" infrasim node destroy {0}\n" \
" infrasim node start {0}".format(node_name)
logger_cmd.warning(
"Node {0} runtime workspace exists. "
"Need to destroy node runtime workspace first".format(
node_name))
@args("node_name",
nargs='?',
default="default",
help="Specify node name to open its configuration in editor")
def edit(self, node_name):
def terminate_workspace(self):
if Workspace.check_workspace_exists(self.__node_name):
shutil.rmtree(self.workspace.get_workspace())
self.__logger.info("[Node] Node {} runtime workspcace is destroyed".
format(self.__node_name))
print "Node {} runtime workspace is destroyed.".format(self.__node_name)
def test_init(self):
"""
CLI test: test init "-f" which will remove existing workspace
"""
output_info = {}
output_start = run_command("infrasim node start")
self.assertEqual(output_start[0], 0)
self.assertTrue(Workspace.check_workspace_exists(self.node_name))
output_info['start'] = run_command("infrasim node info")
self.assertEqual(output_info['start'][0], 0)
self.assertRaises(CommandRunFailed,
run_command,
cmd="infrasim init -s",
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
run_command("infrasim init -s -f")
dirs = [
i for i in os.listdir(config.infrasim_home)
if i.startswith('.') is False
]
self.assertEqual(len(dirs), 0)
# install specific versions
package_list = [{
"name": "infrasim-qemu",
"version": "2.10.1-ubuntu-xenial-1.0.251"
}, {
"name": "infrasim-openipmi",
"version": "2.0.24-1.4.79ubuntu16.04.1"
}]
pm = PackageManager(only_upgrade=False, force=True)
for pkg in package_list:
pm.do_install(pkg.get('name'), version=pkg.get('version'))
for pkg in package_list:
rc, output = run_command('dpkg -s {} | grep \"^Version:\"'.format(
pkg.get('name')))
reobj = re.search(r'^Version:\s?(?P<version>.*)', output.strip())
assert reobj
assert pkg.get('version') == reobj.groupdict().get('version')
# upgrade to latest version
package_list = [{
"name": "infrasim-qemu",
"version": "latest"
}, {
"name": "infrasim-openipmi",
"version": "latest"
}]
for pkg in package_list:
pm.do_install(pkg.get('name'), version=pkg.get('version'))
for pkg in package_list:
rc, output = run_command('dpkg -s {} | grep \"^Version:\"'.format(
pkg.get('name')))
reobj = re.search(r'^Version:\s?(?P<version>.*)', output.strip())
assert reobj
assert pkg.get('version') != reobj.groupdict().get('version')
# downgrade to specific versions
package_list = [{
"name": "infrasim-qemu",
"version": "2.10.1-ubuntu-xenial-1.0.251"
}, {
"name": "infrasim-openipmi",
"version": "2.0.24-1.4.79ubuntu16.04.1"
}]
for pkg in package_list:
pm.do_install(pkg.get('name'), version=pkg.get('version'))
for pkg in package_list:
rc, output = run_command('dpkg -s {} | grep \"^Version:\"'.format(
pkg.get('name')))
reobj = re.search(r'^Version:\s?(?P<version>.*)', output.strip())
assert reobj
assert pkg.get('version') == reobj.groupdict().get('version')
# uninstall the versions
for pkg in package_list:
pm.do_remove(pkg.get('name'))
# update cache
pm.init()
for pkg in package_list:
self.assertRaises(CommandRunFailed,
run_command,
cmd='dpkg -l | grep {}'.format(pkg.get('name')),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
# install the packages again for the subsequent tests
package_list = [{
"name": "infrasim-qemu",
"version": "latest"
}, {
"name": "infrasim-openipmi",
"version": "latest"
}, {
"name": "infrasim-seabios",
"version": "latest"
}]
for pkg in package_list:
pm.do_install(pkg.get('name'), version=pkg.get('version'))
for pkg in package_list:
rc, output = run_command('dpkg -s {} | grep \"^Version:\"'.format(
pkg.get('name')))
reobj = re.search(r'^Version:\s?(?P<version>.*)', output.strip())
# make sure the package is installed
assert reobj
def init_env(instance):
"""
This is to sync ipmi-console with runtime vBMC configuration.
Initial version capture infrasim instance name by infrasim-main status, while we
have a plan to give instance name to ipmi-console so that it can be attached to
target vBMC instance.
"""
# Threading quit flag initilization
env.local_env.quit_flag = False
# Verify node instance runtime
cur_path = os.environ["PATH"]
os.environ["PATH"] = "{}/bin:{}".format(os.environ.get("PYTHONPATH"), cur_path)
if not Workspace.check_workspace_exists(instance):
logger.error("Warning: there is no node {} workspace. "
"Please start node {} first.".format(instance, instance))
raise IpmiError(
"Warning: there is no node {} workspace. "
"Please start node {} first.".format(instance, instance))
try:
with open("{}/{}/.{}-bmc.pid".format(
config.infrasim_home, instance, instance), "r") as f:
pid = f.readline().strip()
if not os.path.exists("/proc/{}".format(pid)):
raise Exception
except Exception:
logger.error("Warning: node {} has not started BMC. "
"Please start node {} first.".format(instance, instance))
raise IpmiError(
"Warning: node {} has not started BMC. "
"Please start node {} first.".format(instance, instance))
logger.info("Init ipmi-console environment for infrasim instance: {}".
format(instance))
# Get runtime vbmc.conf
vbmc_conf_path = os.path.join(config.infrasim_home, instance, "etc", "vbmc.conf")
if not os.path.exists(vbmc_conf_path):
msg = "{} vBMC configuration is not defined at {}".format(instance, vbmc_conf_path)
logger.error(msg)
raise Exception(msg)
else:
msg = "Target vbmc to attach is: {}".format(vbmc_conf_path)
logger.info(msg)
# Get runtime infrasim.yml
infrasim_yml_path = os.path.join(config.infrasim_home, instance, "etc", "infrasim.yml")
if not os.path.exists(infrasim_yml_path):
msg = "{} infrasim instance is not defined at {}".format(instance, infrasim_yml_path)
logger.error(msg)
raise Exception(msg)
else:
msg = "Target infrasim instance to attach is: {}".format(infrasim_yml_path)
logger.info(msg)
# Get variable and set to ipmi-console env
# - PORT_TELNET_TO_VBMC
# - VBMC_IP
# - VBMC_PORT
with open(vbmc_conf_path, 'r') as fp:
conf = fp.read()
p_telnet = re.compile(r"^\s*console\s*[\d:\.]+\s+(?P<port_telnet_to_vbmc>\d+)",
re.MULTILINE)
s_telnet = p_telnet.search(conf)
if s_telnet:
env.PORT_TELNET_TO_VBMC = int(s_telnet.group("port_telnet_to_vbmc"))
logger.info("PORT_TELNET_TO_VBMC: {}".format(env.PORT_TELNET_TO_VBMC))
else:
logger.error("PORT_TELNET_TO_VBMC is not found")
raise Exception("PORT_TELNET_TO_VBMC is not found")
p_vbmc = re.compile(r"^\s*addr\s*(?P<vbmc_ip>[\d:\.]+)\s*(?P<vbmc_port>\d+)",
re.MULTILINE)
s_vbmc = p_vbmc.search(conf)
if s_vbmc:
ip = s_vbmc.group("vbmc_ip")
if ip == "::" or ip == "0.0.0.0":
env.VBMC_IP = "localhost"
else:
env.VBMC_IP = ip
logger.info("VBMC_IP: {}".format(env.VBMC_IP))
env.VBMC_PORT = int(s_vbmc.group("vbmc_port"))
logger.info("VBMC_PORT: {}".format(env.VBMC_PORT))
else:
logger.error("VBMC_IP and VBMC_PORT is not found")
raise Exception("VBMC_IP and VBMC_PORT is not found")
# Get variable and set to ipmi-console env
# - PORT_SSH_FOR_CLIENT
with open(infrasim_yml_path, 'r') as fp:
conf = fp.read()
p_port = re.compile(r"^\s*ipmi_console_ssh:\s*(?P<port_ssh_for_client>\d+)",
re.MULTILINE)
s_port = p_port.search(conf)
if s_port:
env.PORT_SSH_FOR_CLIENT = int(s_port.group("port_ssh_for_client"))
else:
env.PORT_SSH_FOR_CLIENT = 9300
logger.info("PORT_SSH_FOR_CLIENT: {}".format(env.PORT_SSH_FOR_CLIENT))
# check if ipmi_console_ssh port is in use
if helper.check_if_port_in_use("0.0.0.0", env.PORT_SSH_FOR_CLIENT):
logger.error("ssh port {} is already in use.".format(env.PORT_SSH_FOR_CLIENT))
raise IpmiError("ssh port {} is already in use.".format(env.PORT_SSH_FOR_CLIENT))
