def connect_host(self, hostname, timeout=60, port=None, machine_id=None,
security=None):
ctl_config = self._controller._config
msg_dispatcher = self._controller._msg_dispatcher
if security is None:
security = {"auth_type": "none"}
if machine_id is None:
machine_id = hostname
m = Machine(machine_id, hostname, msg_dispatcher,
ctl_config, None, port, security)
def condition():
try:
m.init_connection(timeout=1)
return True
except:
log_exc_traceback()
return False
msg_dispatcher.wait_for_condition(condition, timeout)
host = Host(m)
self._controller._prepare_machine(m)
m.start_recipe(self._recipe)
return host
def _prepare_virtual_slave(self, tm_id, tm):
pm_id = self._get_machine_mapping(tm_id)
pm = self._pool[pm_id]
hostname = pm["params"]["hostname"]
libvirt_domain = pm["params"]["libvirt_domain"]
rpcport = None
if "rpc_port" in pm["params"]:
rpcport = pm["params"]["rpc_port"]
machine = Machine(tm_id, hostname, libvirt_domain, rpcport)
# make all the existing unused
for if_id, if_data in pm["interfaces"].iteritems():
iface = machine.new_unused_interface("eth")
iface.set_hwaddr(if_data["params"]["hwaddr"])
iface.set_network(None)
# add all the other devices
for if_id, if_data in tm["interfaces"].iteritems():
iface = machine.new_virtual_interface(if_id, "eth")
iface.set_network(if_data["network"])
if "hwaddr" in if_data["params"]:
iface.set_hwaddr(if_data["params"]["hwaddr"])
if "driver" in if_data["params"]:
iface.set_driver(if_data["params"]["driver"])
return machine
def _get_mapped_slave(self, tm_id):
pm_id = self._get_machine_mapping(tm_id)
pm = self._pool[pm_id]
hostname = pm["params"]["hostname"]
rpcport = None
if "rpc_port" in pm["params"]:
rpcport = pm["params"]["rpc_port"]
machine = Machine(tm_id, hostname, None, rpcport)
used = []
if_map = self._map["machines"][tm_id]["interfaces"]
for t_if, p_if in if_map.iteritems():
pool_id = p_if["target"]
used.append(pool_id)
if_data = pm["interfaces"][pool_id]
iface = machine.new_static_interface(t_if, "eth")
iface.set_hwaddr(if_data["params"]["hwaddr"])
for t_net, p_net in self._map["networks"].iteritems():
if pm["interfaces"][pool_id]["network"] == p_net:
iface.set_network(t_net)
break
for if_id, if_data in pm["interfaces"].iteritems():
if if_id not in used:
iface = machine.new_unused_interface("eth")
iface.set_hwaddr(if_data["params"]["hwaddr"])
iface.set_network(None)
return machine
def _get_mapped_slave(self, tm_id):
pm_id = self._get_machine_mapping(tm_id)
pm = self._pool[pm_id]
hostname = pm["params"]["hostname"]
libvirt_domain = None
if "libvirt_domain" in pm["params"]:
libvirt_domain = pm["params"]["libvirt_domain"]
machine = Machine(tm_id, hostname, libvirt_domain)
used = []
if_map = self._map["machines"][tm_id]["interfaces"]
for t_if, p_if in if_map.iteritems():
used.append(p_if)
if_data = pm["interfaces"][p_if]
for t_net, p_net in self._map["networks"].iteritems():
if pm["interfaces"][p_if]["network"] == p_net:
break
iface = machine.new_static_interface(t_if, "eth")
iface.set_hwaddr(if_data["hwaddr"])
iface.set_network(t_net)
for if_id, if_data in pm["interfaces"].iteritems():
if if_id not in used:
iface = machine.new_unused_interface("eth")
iface.set_hwaddr(if_data["hwaddr"])
iface.set_network(t_net)
return machine
def _create_container(self, name: str, reqs: dict):
logging.info("Creating container " + name)
if "rpc_port" in reqs:
rpc_port = reqs["rpc_port"]
else:
rpc_port = None
self._pool[name] = {
"interfaces": {},
"params": {
"hostname": "",
"rpc_port": rpc_port
},
"security": {
"auth_type": "none"
},
"available": True,
}
try:
container = self._podman_client.containers.create(self.image,
hostname=name,
privileged=True)
except APIError as e:
raise PoolManagerError(f"Could not create container {name}: {e}")
machine = Machine(
name,
"",
self._msg_dispatcher,
self._ctl_config,
None,
rpc_port,
self._pool[name]["security"],
reqs,
) # to get hostname the container needs to run
self._start_container(container, machine)
if self._pool_check:
self._check_machine(
machine) # checks if the agent process is already running
self._pool[name]["params"]["hostname"] = machine.get_hostname()
return container, machine
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.")
