def _try_remove_nat(tfvars): primary_interface = tfvars.get('libvirt_network_if') if primary_interface is None: raise Exception("Could not get primary interface") secondary_interface = tfvars.get('libvirt_secondary_network_if', f's{primary_interface}') nat_controller = NatController([primary_interface, secondary_interface], _get_namespace_index(primary_interface)) nat_controller.remove_nat_rules()
def unconfigure_nat(self): nat_interfaces = self.nat_interfaces NatController.remove_nat_rules( nat_interfaces, self._get_namespace_index(nat_interfaces[0]))
def teardown_nat(nat: NatController) -> None: if global_variables.test_teardown and nat: nat.remove_nat_rules()
class Nodes: DEFAULT_STATIC_IP_CONFIG = False def __init__(self, node_controller: NodeController, private_ssh_key_path: str, net_asset: NetworkAssets = None, needs_nat: bool = False ): self.controller = node_controller self.private_ssh_key_path = private_ssh_key_path self._needs_nat = needs_nat self._net_asset = net_asset self._nodes = None self._nodes_as_dict = None self._nat = None @property def nodes(self) -> List[Node]: if not self._nodes: self._nodes = self.controller.list_nodes() return self._nodes def __getitem__(self, i): return self.nodes[i] def __len__(self): return len(self.nodes) def __iter__(self) -> Iterator[Node]: for n in self.nodes: yield n def is_nat_active(self) -> bool: return self._needs_nat @property def nat_interfaces(self): return (self.controller.network_conf.libvirt_network_if, self.controller.network_conf.libvirt_secondary_network_if) @staticmethod def _get_namespace_index(libvirt_network_if): """ Hack to retrieve namespace index - does not exist in tests """ matcher = re.match(r'^tt(\d+)$', libvirt_network_if) return int(matcher.groups()[0]) if matcher is not None else 0 def release_net_asset(self): if self._net_asset: self._net_asset.release_all() def configure_nat(self): nat_interfaces = self.nat_interfaces self._nat = NatController(nat_interfaces, self._get_namespace_index(nat_interfaces[0])) self._nat.add_nat_rules() def unconfigure_nat(self): if self._nat: self._nat.remove_nat_rules() def drop_cache(self): self._nodes = None self._nodes_as_dict = None def get_masters(self): return [node for node in self.nodes if node.is_master_in_name()] def get_workers(self): return [node for node in self.nodes if node.is_worker_in_name()] @property def nodes_as_dict(self): if not self._nodes_as_dict: self._nodes_as_dict = {node.name: node for node in self.nodes} return self._nodes_as_dict @property def setup_time(self): return self.controller.setup_time def get_random_node(self): return random.choice(self.nodes) def shutdown_all(self): self.run_for_all_nodes("shutdown") def start_all(self, is_static_ip: bool = DEFAULT_STATIC_IP_CONFIG): if is_static_ip: skip_ips = False else: skip_ips = True self.run_for_all_nodes("start", skip_ips) def start_given(self, nodes): self.run_for_given_nodes(nodes, "start") def shutdown_given(self, nodes): self.run_for_given_nodes(nodes, "shutdown") def format_all_disks(self): self.run_for_all_nodes("format_disk") def destroy_all(self): self.run_for_all_nodes("shutdown") def destroy_all_nodes(self): self.controller.destroy_all_nodes() def prepare_nodes(self): self.controller.prepare_nodes() self.configure_nat() def reboot_all(self): self.run_for_all_nodes("restart") def reboot_given(self, nodes): self.run_for_given_nodes(nodes, "restart") def get_cluster_network(self): return self.controller.get_cluster_network() def set_correct_boot_order(self, nodes=None, start_nodes=False): nodes = nodes or self.nodes logging.info("Going to set correct boot order to nodes: %s", nodes) self.run_for_given_nodes(nodes, "set_boot_order_flow", False, start_nodes) def run_for_all_nodes(self, func_name, *args): return self.run_for_given_nodes(self.nodes, func_name, *args) @staticmethod def run_for_given_nodes(nodes, func_name, *args): logging.info("Running %s on nodes : %s", func_name, nodes) return run_concurrently([(getattr(node, func_name), *args) for node in nodes]) def run_for_given_nodes_by_cluster_hosts(self, cluster_hosts, func_name, *args): return self.run_for_given_nodes([self.get_node_from_cluster_host(host) for host in cluster_hosts], func_name, *args) @staticmethod def run_ssh_command_on_given_nodes(nodes, command) -> Dict: return run_concurrently({node.name: (node.run_command, command) for node in nodes}) def set_wrong_boot_order(self, nodes=None, start_nodes=True): nodes = nodes or self.nodes logging.info("Setting wrong boot order for %s", self.nodes_as_dict.keys()) self.run_for_given_nodes(nodes, "set_boot_order_flow", True, start_nodes) def get_bootstrap_node(self, cluster) -> Node: for cluster_host_object in cluster.get_hosts(): if cluster_host_object.get("bootstrap", False): node = self.get_node_from_cluster_host(cluster_host_object) logging.info("Bootstrap node is %s", node.name) return node def create_nodes_cluster_hosts_mapping(self, cluster): node_mapping_dict = {} for cluster_host_object in cluster.get_hosts(): name = self.get_cluster_hostname(cluster_host_object) node_mapping_dict[name] = NodeMapping(self.nodes_as_dict[name], Munch.fromDict(cluster_host_object)) return node_mapping_dict def get_node_from_cluster_host(self, cluster_host_object): hostname = self.get_cluster_hostname(cluster_host_object) return self.get_node_by_hostname(hostname) def get_node_by_hostname(self, get_node_by_hostname): return self.nodes_as_dict[get_node_by_hostname] def get_cluster_host_obj_from_node(self, cluster, node): mapping = self.create_nodes_cluster_hosts_mapping(cluster=cluster) return mapping[node.name].cluster_host def get_cluster_hostname(self, cluster_host_object): inventory = json.loads(cluster_host_object["inventory"]) return inventory["hostname"] def set_hostnames(self, cluster, nodes_count: int, is_ipv6: bool, is_static_ip: bool = False): if is_ipv6 or is_static_ip: # When using IPv6 with libvirt, hostnames are not set automatically by DHCP. Therefore, we must find out # the hostnames using terraform's tfstate file. In case of static ip, the hostname is localhost and must be # set to valid hostname # TODO - NodeController has no `params` and `tf` attributes network_name = self.controller.params.libvirt_network_name libvirt_nodes = utils.get_libvirt_nodes_from_tf_state(network_name, self.controller.tf.get_state()) utils.update_hosts(cluster.api_client, cluster.id, libvirt_nodes, update_hostnames=True, update_roles=(nodes_count != 1)) def set_single_node_ip(self, cluster): self.controller.tf.change_variables( {"single_node_ip": cluster.get_ip_for_single_node(cluster.api_client, cluster.id, self.controller.get_machine_cidr())})
def unconfigure_nat(cls, controller): libvirt_network_if = controller.network_conf.libvirt_network_if libvirt_secondary_network_if = controller.network_conf.libvirt_secondary_network_if input_interfaces = [libvirt_network_if, libvirt_secondary_network_if] nat_controller = NatController() nat_controller.remove_nat_rules(input_interfaces, cls._get_namespace_index(libvirt_network_if))
def _try_remove_nat(namespace, tfvars): primary_interface = tfvars.get('libvirt_network_if', f'tt{namespace}') secondary_interface = tfvars.get('libvirt_secondary_network_if', f's{primary_interface}') nat_controller = NatController() nat_controller.remove_nat_rules([primary_interface, secondary_interface])