def type_init(self):
super(NetConfigDeviceOvsBridge, self).type_init()
if not check_process_running("ovsdb-server"):
exec_cmd("mkdir -p /var/run/openvswitch/")
exec_cmd("ovsdb-server --detach --pidfile "\
"--remote=punix:/var/run/openvswitch/db.sock",
die_on_err=False)
if not check_process_running("ovs-vswitchd"):
exec_cmd("ovs-vswitchd --detach --pidfile", die_on_err=False)
def type_init(self):
super(NetConfigDeviceOvsBridge, self).type_init()
if not check_process_running("ovsdb-server"):
exec_cmd("mkdir -p /var/run/openvswitch/")
exec_cmd("ovsdb-server --detach --pidfile "\
"--remote=punix:/var/run/openvswitch/db.sock",
die_on_err=False)
if not check_process_running("ovs-vswitchd"):
exec_cmd("ovs-vswitchd --detach --pidfile", die_on_err=False)
def __init__(self, recipe_path, log_ctl,
res_serializer=None, pool_checks=True,
defined_aliases=None, overriden_aliases=None,
reduce_sync=False):
self._res_serializer = res_serializer
self._remote_capture_files = {}
self._log_ctl = log_ctl
self._recipe_path = recipe_path
self._msg_dispatcher = MessageDispatcher(log_ctl)
self._reduce_sync = reduce_sync
self._parser = RecipeParser(recipe_path)
self.remove_saved_machine_config()
sp = SlavePool(lnst_config.get_option('environment', 'pool_dirs'),
check_process_running("libvirtd"), pool_checks)
self._slave_pool = sp
self._machines = {}
self._network_bridges = {}
self._tasks = []
mac_pool_range = lnst_config.get_option('environment', 'mac_pool_range')
self._mac_pool = MacPool(mac_pool_range[0], mac_pool_range[1])
self._parser.set_machines(self._machines)
self._parser.set_aliases(defined_aliases, overriden_aliases)
self._recipe = self._parser.parse()
modules_dirs = lnst_config.get_option('environment', 'module_dirs')
tools_dirs = lnst_config.get_option('environment', 'tool_dirs')
self._resource_table = {}
self._resource_table["module"] = self._load_test_modules(modules_dirs)
self._resource_table["tools"] = self._load_test_tools(tools_dirs)
def __init__(self, pools, pool_checks=True):
self._map = {}
self._pools = {}
self._pool = {}
self._machine_matches = []
self._network_matches = []
self._allow_virt = lnst_config.get_option("environment",
"allow_virtual")
self._allow_virt &= check_process_running("libvirtd")
self._pool_checks = pool_checks
self._mapper = SetupMapper()
self._mreqs = None
logging.info("Checking machine pool availability.")
for pool_name, pool_dir in pools.items():
self._pools[pool_name] = {}
self.add_dir(pool_name, pool_dir)
if len(self._pools[pool_name]) == 0:
del self._pools[pool_name]
self._mapper.set_pools(self._pools)
logging.info("Finished loading pools.")
def is_nm_managed(dev_config, if_manager):
if lnst_config.get_option("environment", "use_nm") and\
check_process_running("NetworkManager"):
return type_class_mapping[dev_config["type"]].is_nm_managed(dev_config,
if_manager)
else:
return False
def hello(self, recipe_path):
self.machine_cleanup()
self.restore_nm_option()
logging.info("Recieved a controller connection.")
self.clear_resource_table()
self._cache.del_old_entries()
self.reset_file_transfers()
self._if_manager.rescan_devices()
date = datetime.datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
self._log_ctl.set_recipe(recipe_path, expand=date)
sleep(1)
slave_desc = {}
if check_process_running("NetworkManager"):
logging.warning("=============================================")
logging.warning("NetworkManager is running on a slave machine!")
if lnst_config.get_option("environment", "use_nm"):
logging.warning("Support of NM is still experimental!")
else:
logging.warning("Usage of NM is disabled!")
logging.warning("=============================================")
slave_desc["nm_running"] = True
else:
slave_desc["nm_running"] = False
k_release, _ = exec_cmd("uname -r", False, False, False)
r_release, _ = exec_cmd("cat /etc/redhat-release", False, False, False)
slave_desc["kernel_release"] = k_release.strip()
slave_desc["redhat_release"] = r_release.strip()
return ("hello", slave_desc)
def is_nm_managed(dev_config, if_manager):
if lnst_config.get_option("environment", "use_nm") and\
check_process_running("NetworkManager"):
return type_class_mapping[dev_config["type"]].is_nm_managed(dev_config,
if_manager)
else:
return False
def hello(self, recipe_path):
self.machine_cleanup()
self.restore_nm_option()
logging.info("Recieved a controller connection.")
self.clear_resource_table()
self._cache.del_old_entries()
self.reset_file_transfers()
self._if_manager.rescan_devices()
date = datetime.datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
self._log_ctl.set_recipe(recipe_path, expand=date)
sleep(1)
slave_desc = {}
if check_process_running("NetworkManager"):
logging.warning("=============================================")
logging.warning("NetworkManager is running on a slave machine!")
if lnst_config.get_option("environment", "use_nm"):
logging.warning("Support of NM is still experimental!")
else:
logging.warning("Usage of NM is disabled!")
logging.warning("=============================================")
slave_desc["nm_running"] = True
else:
slave_desc["nm_running"] = False
k_release, _ = exec_cmd("uname -r", False, False, False)
r_release, _ = exec_cmd("cat /etc/redhat-release", False, False, False)
slave_desc["kernel_release"] = k_release.strip()
slave_desc["redhat_release"] = r_release.strip()
slave_desc["lnst_version"] = lnst_config.version
return ("hello", slave_desc)
def __init__(self, pools, pool_checks=True):
self._map = {}
self._pools = {}
self._pool = {}
self._machine_matches = []
self._network_matches = []
self._allow_virt = lnst_config.get_option("environment",
"allow_virtual")
self._allow_virt &= check_process_running("libvirtd")
self._pool_checks = pool_checks
self._mapper = SetupMapper()
self._mreqs = None
logging.info("Checking machine pool availability.")
for pool_name, pool_dir in pools.items():
self._pools[pool_name] = {}
self.add_dir(pool_name, pool_dir)
if len(self._pools[pool_name]) == 0:
del self._pools[pool_name]
self._mapper.set_pools(self._pools)
logging.info("Finished loading pools.")
def NetConfigDeviceAllCleanup():
if check_process_running("NetworkManager") and \
lnst_config.get_option("environment", "use_nm"):
for dev_type in nm_type_class_mapping:
nm_type_class_mapping[dev_type].type_cleanup()
else:
for dev_type in type_class_mapping:
type_class_mapping[dev_type].type_cleanup()
def NetConfigDeviceAllCleanup():
if check_process_running("NetworkManager") and \
lnst_config.get_option("environment", "use_nm"):
for dev_type in nm_type_class_mapping:
nm_type_class_mapping[dev_type].type_cleanup()
else:
for dev_type in type_class_mapping:
type_class_mapping[dev_type].type_cleanup()
def get_nm_version():
if not check_process_running("NetworkManager") or not lnst_config.get_option("environment", "use_nm"):
return ""
bus = dbus.SystemBus()
nm_obj = bus.get_object(NM_BUS, OBJ_PRE)
nm_if = dbus.Interface(nm_obj, IF_PRE)
props = dbus.Interface(nm_obj, "org.freedesktop.DBus.Properties")
return props.Get(IF_PRE, "Version")
def get_nm_version():
if not check_process_running("NetworkManager") or\
not lnst_config.get_option("environment", "use_nm"):
return ""
bus = dbus.SystemBus()
nm_obj = bus.get_object(NM_BUS, OBJ_PRE)
nm_if = dbus.Interface(nm_obj, IF_PRE)
props = dbus.Interface(nm_obj, "org.freedesktop.DBus.Properties")
return props.Get(IF_PRE, "Version")
def hello(self):
logging.info("Recieved a controller connection.")
slave_desc = {}
if check_process_running("NetworkManager"):
slave_desc["nm_running"] = True
else:
slave_desc["nm_running"] = False
k_release, _ = exec_cmd("uname -r", False, False, False)
r_release, _ = exec_cmd("cat /etc/redhat-release", False, False, False)
slave_desc["kernel_release"] = k_release.strip()
slave_desc["redhat_release"] = r_release.strip()
slave_desc["lnst_version"] = lnst_version
return ("hello", slave_desc)
def virtual(self, pool_dir=None):
""" Starts Wizard in a virtual mode
@param pool_dir Path to pool directory (optional)
"""
print("WARNING: For LNST Pool Wizard to work with virtual guests, "
"several conditions have to be met: \n"
"\t1) Guests must be running under libvirt and QEMU\n"
"\t2) Guests must be in \"default\" network and have an IP "
"address from DHCP in that network")
if not LIBVIRT_SUPPORT:
sys.stderr.write("Missing package libvirt-python, "
"aborting wizard\n")
return
if not check_process_running("libvirtd"):
sys.stderr.write("libvirtd is not running, aborting wizard\n")
return
pool_dir = self._check_and_query_pool_dir(pool_dir)
conn = libvirt.openReadOnly("qemu:///system")
if conn is None:
sys.stderr.write("Failed to open connection to hypervisor, "
"aborting wizard\n")
return
while True:
libvirt_domain, hostname = self._query_libvirt_domain(conn)
if hostname is None or libvirt_domain is None:
return
sec_params = self._query_sec_params(hostname)
filename = self._query_filename(libvirt_domain)
self._create_xml(hostname=hostname,
pool_dir=pool_dir,
filename=filename,
mode="virtual",
libvirt_domain=libvirt_domain,
sec_params=sec_params)
if self._query_continuation():
continue
else:
break
def __init__(self,
recipe_path,
log_ctl,
cleanup=False,
res_serializer=None,
pool_checks=True):
self._docleanup = cleanup
self._res_serializer = res_serializer
self._remote_capture_files = {}
self._log_ctl = log_ctl
self._recipe_path = recipe_path
self._msg_dispatcher = MessageDispatcher(log_ctl)
sp = SlavePool(lnst_config.get_option('environment', 'pool_dirs'),
check_process_running("libvirtd"), pool_checks)
self._slave_pool = sp
self._machines = {}
self._network_bridges = {}
self._recipe = recipe = {}
recipe["networks"] = {}
recipe["machines"] = {}
recipe["switches"] = {}
mac_pool_range = lnst_config.get_option('environment',
'mac_pool_range')
self._mac_pool = MacPool(mac_pool_range[0], mac_pool_range[1])
parser = RecipeParse(recipe_path)
parser.set_target(self._recipe)
parser.set_machines(self._machines)
parser.register_event_handler("provisioning_requirements_ready",
self._prepare_provisioning)
parser.register_event_handler("interface_config_ready",
self._prepare_interface)
modules_dirs = lnst_config.get_option('environment', 'module_dirs')
tools_dirs = lnst_config.get_option('environment', 'tool_dirs')
self._resource_table = {}
self._resource_table["module"] = self._load_test_modules(modules_dirs)
self._resource_table["tools"] = self._load_test_tools(tools_dirs)
self._parser = parser
def start_recipe(self, recipe_name):
date = datetime.datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
self._log_ctl.set_recipe(recipe_name, expand=date)
sleep(1)
if check_process_running("NetworkManager"):
logging.warning("=============================================")
logging.warning("NetworkManager is running on a slave machine!")
logging.warning("=============================================")
for device in self._if_manager.get_devices():
try:
device.store_cleanup_data()
except DeviceDisabled:
pass
return True
def virtual(self, pool_dir=None):
""" Starts Wizard in a virtual mode
@param pool_dir Path to pool directory (optional)
"""
print("WARNING: For LNST Pool Wizard to work with virtual guests, "
"several conditions have to be met: \n"
"\t1) Guests must be running under libvirt and QEMU\n"
"\t2) Guests must be in \"default\" network and have an IP "
"address from DHCP in that network")
if not LIBVIRT_SUPPORT:
sys.stderr.write("Missing package libvirt-python, "
"aborting wizard\n")
return
if not check_process_running("libvirtd"):
sys.stderr.write("libvirtd is not running, aborting wizard\n")
return
pool_dir = self._check_and_query_pool_dir(pool_dir)
conn = libvirt.openReadOnly("qemu:///system")
if conn is None:
sys.stderr.write("Failed to open connection to hypervisor, "
"aborting wizard\n")
return
while True:
libvirt_domain, hostname = self._query_libvirt_domain(conn)
if hostname is None or libvirt_domain is None:
return
sec_params = self._query_sec_params(hostname)
filename = self._query_filename(libvirt_domain)
self._create_xml(hostname=hostname, pool_dir=pool_dir,
filename=filename, mode="virtual",
libvirt_domain=libvirt_domain,
sec_params=sec_params)
if self._query_continuation():
continue
else:
break
def is_nm_managed_by_name(dev_name):
if not check_process_running("NetworkManager") or not lnst_config.get_option("environment", "use_nm"):
return False
bus = dbus.SystemBus()
nm_obj = bus.get_object(NM_BUS, OBJ_PRE)
nm_if = dbus.Interface(nm_obj, IF_PRE)
try:
device_obj_path = nm_if.GetDeviceByIpIface(dev_name)
except:
# There is a higher possibility that if the interface doesn't exist
# it's a software interface that can be created by NM so we say that it's
# managed and check existance of physical interfaces sepparately
return True
dev = bus.get_object(NM_BUS, device_obj_path)
dev_props = dbus.Interface(dev, "org.freedesktop.DBus.Properties")
return dev_props.Get(IF_PRE + ".Device", "Managed")
def __init__(self, pools, msg_dispatcher, ctl_config, pool_checks=True):
self._map = {}
self._pools = {}
self._pool = {}
self._msg_dispatcher = msg_dispatcher
self._ctl_config = ctl_config
self._allow_virt = ctl_config.get_option("environment",
"allow_virtual")
self._allow_virt &= check_process_running("libvirtd")
self._pool_checks = pool_checks
logging.info("Checking machine pool availability.")
for pool_name, pool_dir in list(pools.items()):
self._pools[pool_name] = {}
self.add_dir(pool_name, pool_dir)
if len(self._pools[pool_name]) == 0:
del self._pools[pool_name]
self._machines = {}
for pool_name, machines in list(self._pools.items()):
pool = self._machines[pool_name] = {}
for m_id, m_spec in list(machines.items()):
params = m_spec["params"]
hostname = params["hostname"]
if "libvirt_domain" in params:
libvirt_domain = params["libvirt_domain"]
else:
libvirt_domain = None
if "rpc_port" in params:
rpc_port = params["rpc_port"]
else:
rpc_port = None
pool[m_id] = Machine(m_id, hostname, self._msg_dispatcher,
ctl_config, libvirt_domain, rpc_port,
m_spec["security"], params)
pool[m_id].init_connection()
#TODO check if all described devices are available
logging.info("Finished loading pools.")
def hello(self, recipe_path):
logging.info("Recieved a controller connection.")
self.clear_resource_table()
self._cache.del_old_entries()
self.reset_file_transfers()
date = datetime.datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
self._log_ctl.set_recipe(recipe_path, expand=date)
sleep(1)
if check_process_running("NetworkManager"):
logging.warning("=============================================")
logging.warning("NetworkManager is running on a slave machine!")
if lnst_config.get_option("environment", "use_nm"):
logging.warning("Support of NM is still experimental!")
else:
logging.warning("Usage of NM is disabled!")
logging.warning("=============================================")
return "hello"
def is_nm_managed_by_name(dev_name):
if not check_process_running("NetworkManager") or\
not lnst_config.get_option("environment", "use_nm"):
return False
bus = dbus.SystemBus()
nm_obj = bus.get_object(NM_BUS, OBJ_PRE)
nm_if = dbus.Interface(nm_obj, IF_PRE)
try:
device_obj_path = nm_if.GetDeviceByIpIface(dev_name)
except:
#There is a higher possibility that if the interface doesn't exist
#it's a software interface that can be created by NM so we say that it's
#managed and check existance of physical interfaces sepparately
return True
dev = bus.get_object(NM_BUS, device_obj_path)
dev_props = dbus.Interface(dev, "org.freedesktop.DBus.Properties")
return dev_props.Get(IF_PRE + ".Device", "Managed")
def hello(self, recipe_path):
logging.info("Recieved a controller connection.")
self.clear_resource_table()
self._cache.del_old_entries()
self.reset_file_transfers()
date = datetime.datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
self._log_ctl.set_recipe(recipe_path, expand=date)
sleep(1)
if check_process_running("NetworkManager"):
logging.warning("=============================================")
logging.warning("NetworkManager is running on a slave machine!")
if lnst_config.get_option("environment", "use_nm"):
logging.warning("Support of NM is still experimental!")
else:
logging.warning("Usage of NM is disabled!")
logging.warning("=============================================")
return "hello"
def __init__(self, recipe_path, log_ctl, cleanup=False,
res_serializer=None, pool_checks=True):
self._docleanup = cleanup
self._res_serializer = res_serializer
self._remote_capture_files = {}
self._log_ctl = log_ctl
self._recipe_path = recipe_path
self._msg_dispatcher = MessageDispatcher(log_ctl)
sp = SlavePool(lnst_config.get_option('environment', 'pool_dirs'),
check_process_running("libvirtd"), pool_checks)
self._slave_pool = sp
self._machines = {}
self._network_bridges = {}
self._recipe = recipe = {}
recipe["networks"] = {}
recipe["machines"] = {}
recipe["switches"] = {}
mac_pool_range = lnst_config.get_option('environment', 'mac_pool_range')
self._mac_pool = MacPool(mac_pool_range[0], mac_pool_range[1])
parser = RecipeParse(recipe_path)
parser.set_target(self._recipe)
parser.set_machines(self._machines)
parser.register_event_handler("provisioning_requirements_ready",
self._prepare_provisioning)
parser.register_event_handler("interface_config_ready",
self._prepare_interface)
modules_dirs = lnst_config.get_option('environment', 'module_dirs')
tools_dirs = lnst_config.get_option('environment', 'tool_dirs')
self._resource_table = {}
self._resource_table["module"] = self._load_test_modules(modules_dirs)
self._resource_table["tools"] = self._load_test_tools(tools_dirs)
self._parser = parser
def start_recipe(self, recipe_name):
date = datetime.datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
self._log_ctl.set_recipe(recipe_name, expand=date)
sleep(1)
if check_process_running("NetworkManager"):
logging.warning("=============================================")
logging.warning("NetworkManager is running on a slave machine!")
if self._slave_config.get_option("environment", "use_nm"):
logging.warning("Support of NM is still experimental!")
else:
logging.warning("Usage of NM is disabled!")
logging.warning("=============================================")
for device in self._if_manager.get_devices():
try:
device.store_cleanup_data()
except DeviceDisabled:
pass
return True
def set_recipe(self, recipe_name):
self.machine_cleanup()
self.restore_nm_option()
self._cache.del_old_entries()
self.reset_file_transfers()
date = datetime.datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
self._log_ctl.set_recipe(recipe_name, expand=date)
sleep(1)
if check_process_running("NetworkManager"):
logging.warning("=============================================")
logging.warning("NetworkManager is running on a slave machine!")
if self._slave_config.get_option("environment", "use_nm"):
logging.warning("Support of NM is still experimental!")
else:
logging.warning("Usage of NM is disabled!")
logging.warning("=============================================")
return True
import logging
import socket
import sys
import signal
from lnst.Common.Utils import sha256sum
from lnst.Common.Utils import check_process_running
from lnst.Common.TestModule import BaseTestModule
from lnst.Controller.Common import ControllerError
from lnst.Controller.CtlSecSocket import CtlSecSocket
from lnst.Devices import device_classes
from lnst.Devices.Device import Device
from lnst.Devices.RemoteDevice import RemoteDevice
from lnst.Devices.VirtualDevice import VirtualDevice
# conditional support for libvirt
if check_process_running("libvirtd"):
from lnst.Controller.VirtDomainCtl import VirtDomainCtl
class MachineError(ControllerError):
pass
class PrefixMissingError(ControllerError):
pass
class Machine(object):
""" Slave machine abstraction
A machine object represents a handle using which the controller can
manipulate the machine. This includes tasks such as, configuration,
deconfiguration, and running commands.
"""
import logging
import socket
import os
import tempfile
import signal
from time import sleep
from xmlrpclib import Binary
from lnst.Common.Config import lnst_config
from lnst.Common.NetUtils import normalize_hwaddr
from lnst.Common.Utils import wait_for, create_tar_archive
from lnst.Common.Utils import check_process_running
from lnst.Common.NetTestCommand import DEFAULT_TIMEOUT
# conditional support for libvirt
if check_process_running("libvirtd"):
from lnst.Controller.VirtUtils import VirtNetCtl, VirtDomainCtl
class MachineError(Exception):
pass
class PrefixMissingError(Exception):
pass
class Machine(object):
""" Slave machine abstraction
A machine object represents a handle using which the controller can
manipulate the machine. This includes tasks such as, configuration,
deconfiguration, and running commands.
"""