def __init__(self, **kwargs):
super().__init__(**kwargs)
self.cluster_name = kwargs.get('cluster_name', f'{consts.CLUSTER_PREFIX}')
self.network_name = kwargs.get('network_name', consts.TEST_NETWORK)
self.params = self._terraform_params(**kwargs)
self.tf_folder = self._create_tf_folder()
self.image_path = kwargs["iso_download_path"]
self.tf = terraform_utils.TerraformUtils(working_dir=self.tf_folder)
def __init__(self, config: VSphereControllerConfig,
cluster_config: BaseClusterConfig):
super().__init__(config, cluster_config)
self.cluster_name = cluster_config.cluster_name.get()
folder = TerraformControllerUtil.create_folder(
self.cluster_name, platform=cluster_config.platform)
self._tf = terraform_utils.TerraformUtils(working_dir=folder,
terraform_init=False)
def __init__(self, config: BaseTerraformConfig, entity_config: Union[BaseClusterConfig, BaseInfraEnvConfig]):
super().__init__(config, entity_config)
self._entity_name = self._get_entity_name()
self._suffix = self._entity_name.suffix or get_name_suffix()
self.tf_folder = config.tf_folder or self._create_tf_folder(self._entity_name.get(), config.platform)
self.network_name = config.network_name + self._suffix
self.params = self._terraform_params(**config.get_all())
self.tf = terraform_utils.TerraformUtils(working_dir=self.tf_folder)
self.master_ips = None
def set_hostnames_from_tf(client, cluster_id, tf_folder, network_name):
tf = terraform_utils.TerraformUtils(working_dir=tf_folder)
libvirt_nodes = utils.extract_nodes_from_tf_state(tf.get_state(),
network_name,
consts.NodeRoles.WORKER)
utils.update_hosts(client,
cluster_id,
libvirt_nodes,
update_roles=False,
update_hostnames=True)
def __init__(self, config: BaseTerraformConfig):
super().__init__(config.private_ssh_key_path)
self.config = config
self.cluster_suffix = self._get_cluster_suffix(config.cluster_name)
self.cluster_name = config.cluster_name
self.network_name = config.network_name + self.cluster_suffix
self.tf_folder = config.tf_folder or self._create_tf_folder(
self.cluster_name, config.platform)
self.params = self._terraform_params(**config.get_all())
self.tf = terraform_utils.TerraformUtils(working_dir=self.tf_folder)
self.master_ips = None
def _configure_load_balancer(self, controller):
main_cidr = controller.get_machine_cidr()
secondary_cidr = controller.get_provisioning_cidr()
master_ips = self.get_master_ips(self.api_client, self.id, main_cidr) + \
self.get_master_ips(self.api_client, self.id, secondary_cidr)
worker_ips = self.get_worker_ips(self.api_client, self.id, main_cidr)
load_balancer_ip = str(IPNetwork(main_cidr).ip + 1)
tf = terraform_utils.TerraformUtils(working_dir=controller.tf_folder)
lb_controller = LoadBalancerController(tf)
lb_controller.set_load_balancing_config(load_balancer_ip, master_ips, worker_ips)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.cluster_suffix = self._get_random_name()
self.cluster_name = kwargs.get('cluster_name', f'{consts.CLUSTER_PREFIX}') + "-" + self.cluster_suffix
self.network_name = kwargs.get('network_name', consts.TEST_NETWORK) + self.cluster_suffix
self.network_conf = kwargs.get('net_asset')
self.cluster_domain = kwargs.get('base_domain', "redhat.com")
self.ipv6 = kwargs.get('ipv6')
self.params = self._terraform_params(**kwargs)
self.tf_folder = self._create_tf_folder()
self.image_path = kwargs["iso_download_path"]
self.bootstrap_in_place = kwargs.get('bootstrap_in_place', False)
self.tf = terraform_utils.TerraformUtils(working_dir=self.tf_folder)
self.master_ips = None
def set_nodes_hostnames_if_needed(client, tf_folder,
with_static_network_config, has_ipv_6,
network_name, cluster_id):
if has_ipv_6 or with_static_network_config:
tf = terraform_utils.TerraformUtils(working_dir=tf_folder)
libvirt_nodes = utils.extract_nodes_from_tf_state(
tf.get_state(), network_name, consts.NodeRoles.WORKER)
log.info(
"Set hostnames of day2 cluster %s in case of static network configuration or "
"to work around libvirt for Terrafrom not setting hostnames of IPv6 hosts",
cluster_id)
utils.update_hosts(client,
cluster_id,
libvirt_nodes,
update_roles=False,
update_hostnames=True)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.cluster_suffix = kwargs.get('cluster_suffix', self._get_random_name())
self.cluster_name = kwargs.get('cluster_name', f'{consts.CLUSTER_PREFIX}' + "-" + self.cluster_suffix)
self.network_name = kwargs.get('network_name', consts.TEST_NETWORK) + self.cluster_suffix
self.network_conf = kwargs.get('net_asset')
self.platform = kwargs.get('platform', consts.Platforms.BARE_METAL)
self.cluster_domain = kwargs.get('base_domain', consts.DEFAULT_BASE_DNS_DOMAIN)
self.ipv6 = kwargs.get('ipv6')
self.params = self._terraform_params(**kwargs)
tf_folder = kwargs.get('tf_folder')
self.tf_folder = tf_folder if tf_folder else self._create_tf_folder()
self.image_path = kwargs["iso_download_path"]
self.bootstrap_in_place = kwargs.get('bootstrap_in_place', False)
self.tf = terraform_utils.TerraformUtils(working_dir=self.tf_folder)
self.master_ips = None
def nodes_flow_kube_api(cluster_name, machine_net, cluster_deployment,
agent_cluster_install):
tf_folder = utils.get_tf_folder(cluster_name, args.namespace)
baremetal_template = os.path.join(tf_folder, consts.Platforms.BARE_METAL)
nodes_details = utils.get_tfvars(baremetal_template)
tf = terraform_utils.TerraformUtils(working_dir=baremetal_template)
is_ipv4 = machine_net.has_ip_v4 or not machine_net.has_ip_v6
nodes_number = args.master_count + args.number_of_workers
create_nodes_and_wait_till_registered(
inventory_client=None,
cluster=None,
nodes_details=nodes_details,
tf=tf,
is_ipv4=is_ipv4,
nodes_number=nodes_number,
cluster_deployment=cluster_deployment,
)
if args.master_count == 1:
set_single_node_ip(
client=None,
cluster_id=None,
main_cidr=args.vm_network_cidr
if is_ipv4 else args.vm_network_cidr6,
is_ipv4=is_ipv4,
cluster_deployment=cluster_deployment,
tf=tf,
)
else:
log.info("VIPs already configured")
kubeapi_utils.set_agents_hostnames(
cluster_deployment=cluster_deployment,
is_ipv4=is_ipv4,
static_network_mode=args.with_static_network_config,
tf=tf,
nodes_number=nodes_number,
)
if args.install_cluster:
install_cluster.run_installation_flow_kube_api(
cluster_deployment=cluster_deployment,
agent_cluster_install=agent_cluster_install,
nodes_number=nodes_number,
kubeconfig_path=utils.get_kubeconfig_path(cluster_name))
def nodes_flow_kube_api(cluster_name, machine_net, cluster_deployment):
tf_folder = utils.get_tf_folder(cluster_name, args.namespace)
nodes_details = utils.get_tfvars(tf_folder)
tf = terraform_utils.TerraformUtils(working_dir=tf_folder)
is_ipv4 = machine_net.has_ip_v4 or not machine_net.has_ip_v6
nodes_number = args.master_count + args.number_of_workers
create_nodes_and_wait_till_registered(
inventory_client=None,
cluster=None,
nodes_details=nodes_details,
tf=tf,
is_ipv4=is_ipv4,
nodes_number=nodes_number,
cluster_deployment=cluster_deployment,
)
if cluster_deployment:
if args.master_count == 1:
set_single_node_ip(
client=None,
cluster_id=None,
main_cidr=args.vm_network_cidr
if is_ipv4 else args.vm_network_cidr6,
is_ipv4=is_ipv4,
cluster_deployment=cluster_deployment,
tf=tf,
)
else:
log.info("VIPs already configured")
kubeapi_utils.set_agents_hostnames(
cluster_deployment=cluster_deployment,
is_ipv4=is_ipv4,
static_network_mode=args.with_static_network_config,
tf=tf,
nodes_number=nodes_number,
)
if args.install_cluster:
install_cluster.run_installation_flow_kube_api(
cluster_deployment=cluster_deployment,
nodes_number=nodes_number,
kubeconfig_path=consts.DEFAULT_CLUSTER_KUBECONFIG_PATH,
)
def main():
_verify_kube_download_folder(args.kubeconfig_path)
log.info("Creating assisted service client")
# if not cluster id is given, reads it from latest run
tf = None
if not args.cluster_id:
cluster_name = f'{args.cluster_name or consts.CLUSTER_PREFIX}-{args.namespace}'
tf_folder = utils.get_tf_folder(cluster_name, args.namespace)
args.cluster_id = utils.get_tfvars(tf_folder).get(
'cluster_inventory_id')
tf = terraform_utils.TerraformUtils(working_dir=tf_folder)
client = assisted_service_api.create_client(
url=utils.get_assisted_service_url_by_args(args=args, wait=False))
run_install_flow(client=client,
cluster_id=args.cluster_id,
kubeconfig_path=args.kubeconfig_path,
pull_secret=args.pull_secret,
tf=tf)
def nodes_flow(client,
cluster_name,
cluster,
machine_net,
kube_client=None,
cluster_deployment=None):
tf_folder = utils.get_tf_folder(cluster_name, args.namespace)
nodes_details = utils.get_tfvars(tf_folder)
if cluster:
nodes_details["cluster_inventory_id"] = cluster.id
utils.set_tfvars(tf_folder, nodes_details)
tf = terraform_utils.TerraformUtils(working_dir=tf_folder)
is_ipv4 = machine_net.has_ip_v4 or not machine_net.has_ip_v6
nodes_number = args.master_count + args.number_of_workers
create_nodes_and_wait_till_registered(
inventory_client=client,
cluster=cluster,
nodes_details=nodes_details,
tf=tf,
is_ipv4=is_ipv4,
nodes_number=nodes_number,
cluster_deployment=cluster_deployment,
)
main_cidr = args.vm_network_cidr if is_ipv4 else args.vm_network_cidr6
secondary_cidr = machine_net.provisioning_cidr_v4 if is_ipv4 else machine_net.provisioning_cidr_v6
if client:
cluster_info = client.cluster_get(cluster.id)
macs = utils.get_libvirt_nodes_macs(
nodes_details["libvirt_network_name"])
if is_none_platform_mode():
macs += utils.get_libvirt_nodes_macs(
nodes_details["libvirt_secondary_network_name"])
if not (cluster_info.api_vip and cluster_info.ingress_vip):
if not args.kube_api:
utils.wait_till_hosts_with_macs_are_in_status(
client=client,
cluster_id=cluster.id,
macs=macs,
statuses=[
consts.NodesStatus.INSUFFICIENT,
consts.NodesStatus.PENDING_FOR_INPUT,
consts.NodesStatus.KNOWN
],
)
if args.master_count == 1:
set_single_node_ip(
client=client,
cluster_id=cluster.id,
main_cidr=main_cidr,
is_ipv4=is_ipv4,
cluster_deployment=cluster_deployment,
tf=tf,
)
if not args.kube_api:
set_cluster_machine_cidr(
client=client,
cluster_id=cluster.id,
machine_net=machine_net,
set_vip_dhcp_allocation=False,
)
elif is_none_platform_mode():
set_cluster_vips(client, cluster.id, machine_net)
elif args.vip_dhcp_allocation and not args.kube_api:
set_cluster_machine_cidr(client, cluster.id, machine_net)
else:
set_cluster_vips(client, cluster.id, machine_net)
else:
log.info("VIPs already configured")
if args.kube_api:
kubeapi_utils.set_agents_hostnames(
cluster_deployment=cluster_deployment,
is_ipv4=is_ipv4,
static_network_mode=args.with_static_network_config,
tf=tf,
nodes_number=nodes_number,
)
else:
set_hosts_roles(
client=client,
cluster=cluster,
nodes_details=nodes_details,
machine_net=machine_net,
tf=tf,
master_count=args.master_count,
static_network_mode=args.with_static_network_config,
)
if is_none_platform_mode() and args.master_count > 1:
master_ips = helper_cluster.Cluster.get_master_ips(
client, cluster.id,
main_cidr) + helper_cluster.Cluster.get_master_ips(
client, cluster.id, secondary_cidr)
worker_ips = helper_cluster.Cluster.get_worker_ips(
client, cluster.id,
main_cidr) + helper_cluster.Cluster.get_worker_ips(
client, cluster.id, secondary_cidr)
if not worker_ips:
worker_ips = master_ips
load_balancer_ip = _get_host_ip_from_cidr(
machine_net.cidr_v6 if machine_net.has_ip_v6
and not machine_net.has_ip_v4 else machine_net.cidr_v4)
lb_controller = LoadBalancerController(tf)
lb_controller.set_load_balancing_config(load_balancer_ip,
master_ips, worker_ips)
if not args.kube_api:
utils.wait_till_hosts_with_macs_are_in_status(
client=client,
cluster_id=cluster.id,
macs=macs,
statuses=[consts.NodesStatus.KNOWN],
)
if args.install_cluster:
install_cluster.run_install_flow(
client=client,
cluster_id=cluster.id,
kubeconfig_path=consts.DEFAULT_CLUSTER_KUBECONFIG_PATH,
pull_secret=args.pull_secret,
tf=tf,
cluster_deployment=cluster_deployment,
nodes_number=nodes_number,
)
# Validate DNS domains resolvability
validate_dns(client, cluster.id)
def nodes_flow(client, cluster_name, cluster, image_path):
nodes_details = _create_node_details(cluster_name)
if cluster:
nodes_details["cluster_inventory_id"] = cluster.id
tf_folder = utils.get_tf_folder(cluster_name, args.namespace)
utils.recreate_folder(tf_folder)
copy_tree(consts.TF_TEMPLATE, tf_folder)
tf = terraform_utils.TerraformUtils(working_dir=tf_folder)
machine_net = MachineNetwork(args.ipv4, args.ipv6, args.vm_network_cidr,
args.vm_network_cidr6, args.ns_index)
create_nodes_and_wait_till_registered(cluster_name=cluster_name,
inventory_client=client,
cluster=cluster,
image_path=image_path,
storage_path=args.storage_path,
master_count=args.master_count,
nodes_details=nodes_details,
tf=tf,
machine_net=machine_net)
if client:
cluster_info = client.cluster_get(cluster.id)
macs = utils.get_libvirt_nodes_macs(
nodes_details["libvirt_network_name"])
if not (cluster_info.api_vip and cluster_info.ingress_vip):
utils.wait_till_hosts_with_macs_are_in_status(
client=client,
cluster_id=cluster.id,
macs=macs,
statuses=[
consts.NodesStatus.INSUFFICIENT,
consts.NodesStatus.PENDING_FOR_INPUT,
],
)
if args.vip_dhcp_allocation:
set_cluster_machine_cidr(client, cluster.id, machine_net)
else:
set_cluster_vips(client, cluster.id, machine_net)
else:
log.info("VIPs already configured")
network_name = nodes_details["libvirt_network_name"]
if machine_net.has_ip_v4:
libvirt_nodes = utils.get_libvirt_nodes_mac_role_ip_and_name(
network_name)
update_hostnames = False
else:
log.warning(
"Work around libvirt for Terrafrom not setting hostnames of IPv6-only hosts"
)
libvirt_nodes = _get_libvirt_nodes_from_tf_state(
network_name, tf.get_state())
update_hostnames = True
update_hosts(client, cluster.id, libvirt_nodes, update_hostnames)
utils.wait_till_hosts_with_macs_are_in_status(
client=client,
cluster_id=cluster.id,
macs=macs,
statuses=[consts.NodesStatus.KNOWN],
)
if args.install_cluster:
time.sleep(10)
install_cluster.run_install_flow(
client=client,
cluster_id=cluster.id,
kubeconfig_path=consts.DEFAULT_CLUSTER_KUBECONFIG_PATH,
pull_secret=args.pull_secret,
tf=tf)
# Validate DNS domains resolvability
validate_dns(client, cluster.id)
if args.wait_for_cvo:
cluster_info = client.cluster_get(cluster.id)
log.info("Start waiting till CVO status is available")
config_etc_hosts(cluster_info.name,
cluster_info.base_dns_domain,
cluster_info.api_vip)
utils.wait_for_cvo_available()
def nodes_flow(client, cluster_name, cluster, image_path):
nodes_details = _create_node_details(cluster_name)
if cluster:
nodes_details["cluster_inventory_id"] = cluster.id
tf_folder = utils.get_tf_folder(cluster_name, args.namespace)
utils.recreate_folder(tf_folder)
copy_tree(consts.TF_TEMPLATE, tf_folder)
tf = terraform_utils.TerraformUtils(working_dir=tf_folder)
create_nodes_and_wait_till_registered(cluster_name=cluster_name,
inventory_client=client,
cluster=cluster,
image_path=image_path,
storage_path=args.storage_path,
master_count=args.master_count,
nodes_details=nodes_details,
tf=tf)
if client:
cluster_info = client.cluster_get(cluster.id)
macs = utils.get_libvirt_nodes_macs(
nodes_details["libvirt_network_name"])
if not (cluster_info.api_vip and cluster_info.ingress_vip):
utils.wait_till_hosts_with_macs_are_in_status(
client=client,
cluster_id=cluster.id,
macs=macs,
statuses=[
consts.NodesStatus.INSUFFICIENT,
consts.NodesStatus.PENDING_FOR_INPUT,
],
)
if args.vip_dhcp_allocation:
set_cluster_machine_cidr(client, cluster.id,
args.vm_network_cidr)
else:
set_cluster_vips(client, cluster.id)
else:
log.info("VIPs already configured")
set_hosts_roles(client, cluster.id,
nodes_details["libvirt_network_name"])
utils.wait_till_hosts_with_macs_are_in_status(
client=client,
cluster_id=cluster.id,
macs=macs,
statuses=[consts.NodesStatus.KNOWN],
)
if args.install_cluster:
time.sleep(10)
install_cluster.run_install_flow(
client=client,
cluster_id=cluster.id,
kubeconfig_path=consts.DEFAULT_CLUSTER_KUBECONFIG_PATH,
pull_secret=args.pull_secret,
tf=tf)
# Validate DNS domains resolvability
validate_dns(client, cluster.id)
if args.wait_for_cvo:
cluster_info = client.cluster_get(cluster.id)
log.info("Start waiting till CVO status is available")
utils.config_etc_hosts(cluster_info)
utils.wait_for_cvo_available()
def nodes_flow(client, cluster_name, cluster):
tf_folder = utils.get_tf_folder(cluster_name, args.namespace)
nodes_details = utils.get_tfvars(tf_folder)
if cluster:
nodes_details["cluster_inventory_id"] = cluster.id
utils.set_tfvars(tf_folder, nodes_details)
tf = terraform_utils.TerraformUtils(working_dir=tf_folder)
machine_net = MachineNetwork(args.ipv4, args.ipv6, args.vm_network_cidr,
args.vm_network_cidr6, args.ns_index)
create_nodes_and_wait_till_registered(inventory_client=client,
cluster=cluster,
nodes_details=nodes_details,
tf=tf)
if client:
cluster_info = client.cluster_get(cluster.id)
macs = utils.get_libvirt_nodes_macs(
nodes_details["libvirt_network_name"])
if not (cluster_info.api_vip and cluster_info.ingress_vip):
utils.wait_till_hosts_with_macs_are_in_status(
client=client,
cluster_id=cluster.id,
macs=macs,
statuses=[
consts.NodesStatus.INSUFFICIENT,
consts.NodesStatus.PENDING_FOR_INPUT,
consts.NodesStatus.KNOWN
],
)
if args.master_count == 1:
is_ip4 = machine_net.has_ip_v4 or not machine_net.has_ip_v6
cidr = args.vm_network_cidr if is_ip4 else args.vm_network_cidr6
tf.change_variables({
"single_node_ip":
helper_cluster.Cluster.get_ip_for_single_node(
client, cluster.id, cidr, ipv4_first=is_ip4)
})
elif args.vip_dhcp_allocation:
set_cluster_machine_cidr(client, cluster.id, machine_net)
else:
set_cluster_vips(client, cluster.id, machine_net)
else:
log.info("VIPs already configured")
set_hosts_roles(client, cluster, nodes_details, machine_net, tf,
args.master_count, args.with_static_ips)
utils.wait_till_hosts_with_macs_are_in_status(
client=client,
cluster_id=cluster.id,
macs=macs,
statuses=[consts.NodesStatus.KNOWN],
)
if args.install_cluster:
time.sleep(10)
install_cluster.run_install_flow(
client=client,
cluster_id=cluster.id,
kubeconfig_path=consts.DEFAULT_CLUSTER_KUBECONFIG_PATH,
pull_secret=args.pull_secret,
tf=tf)
# Validate DNS domains resolvability
validate_dns(client, cluster.id)
if args.wait_for_cvo:
cluster_info = client.cluster_get(cluster.id)
log.info("Start waiting till CVO status is available")
api_vip = helper_cluster.get_api_vip_from_cluster(
client, cluster_info)
config_etc_hosts(cluster_info.name,
cluster_info.base_dns_domain, api_vip)
utils.wait_for_cvo_available()
