def make_object(self, k8pg_name, body):
"""Sub Methode zu generate_project für die einzelnen Kubernetes Objecte"""
patch = False
body_dict = body.to_dict()
try:
if k8pg_name in self.k8_modul_no_namespace:
api_response = self.k8_modul[k8pg_name]["k8_methode"](body=body, pretty="true")
else:
api_response = self.k8_modul[k8pg_name]["k8_methode"](namespace=self.config.get_object("namespace1", "name"), body=body, pretty="true")
print("%s Opject: %s (Type: %s)" % (Color.color_text(" CREATE ", color=Color.BOLD, long=20, fill="-"), body_dict["metadata"]["name"], k8pg_name))
pprint(api_response)
sleep(1)
except ApiException as e:
error_body = eval(e.body)
if not ErrorHandling.print_K8Exection(self.config, error_body, self.language["main03"], k8pg_name):
patch = True
if patch:
try:
if k8pg_name in self.k8_modul_no_namespace:
api_response = self.k8_patch[k8pg_name]["k8_methode"](name=body_dict["metadata"]["name"], body=body, pretty="true")
else:
api_response = self.k8_patch[k8pg_name]["k8_methode"](name=body_dict["metadata"]["name"], namespace=self.config.get_object("namespace1", "name"), body=body, pretty="true")
print("%s Opject: %s (Type: %s)" % (Color.color_text(" UPDATE ", color=Color.BOLD, long=20, fill="-"), body_dict["metadata"]["name"], k8pg_name))
pprint(api_response)
sleep(1)
except ApiException as e:
error_body = eval(e.body)
ErrorHandling.print_K8Exection(self.config, error_body, self.language["main04"], k8pg_name)
def set_volume(self, volume):
"""Erstelle ein Volume Object"""
self.config.activ_modul = "volume"
if self.config.has_option(volume, "label"):
label = self.config.get_object(volume, "label").split(",")
if len(label) < 2:
label = ["volume", label[0]]
self.config.set(volume, "label", ",".join(label))
label = {label[0]: label[1]}
else:
label = None
k8_drive = self.k8_drives.get(self.config.get_object(volume, "drive"), None)
if k8_drive is None:
self.config.config_status = ErrorHandling.print_error_config(self.config, self.language["vol01"], locals(), bold=True)
return None
drive = k8_drive(self.config, volume)
if drive is None:
self.config.config_status = ErrorHandling.print_error_config(self.config, self.language["vol02"], locals(), bold=True)
return None
metadata = K8Meta(annotations=drive["metadata"].annotations,
name=self.config.get_object(volume, "name"),
labels=label)
spec = K8Spec(storage_class_name=self.config.get_object(volume, "class"),
capacity={"storage": self.config.get_object(volume, "capacity")},
access_modes=[self.config.get_object(volume, "accessmodes")],
nfs=drive["spec"].nfs)
if metadata.name is None or spec.storage_class_name is None or spec.capacity["storage"] is None or spec.access_modes is None:
self.config.config_status = ErrorHandling.print_error_config(self.config, self.language["vol03"], locals(), bold=True)
return None
return K8Volume(metadata=metadata, spec=spec)
def set_template(self, deploy_index):
"""Erstelt ein Template Object"""
template = "template%s" % deploy_index
self.config.activ_modul = 'template'
spec = {"containers": None}
label = self.config.get_object(template, "label")
if label is not None:
label = label.split(",")
if len(label) == 2:
label = {label[0]: label[1]}
elif len(label) == 1:
self.config.set(template, "label", "app,%s" % label[0])
label = {"app": label[0]}
else:
self.config.config_status = ErrorHandling.print_error_config(
self.config, self.language["tem05"], locals(), bold=True)
return None
else:
self.config.config_status = ErrorHandling.print_error_config(
self.config, self.language["tem01"], locals(), bold=True)
return None
if self.config.has_section("namespace%s" % deploy_index):
namespace = self.config.get_object("namespace%s" % deploy_index,
"name",
modul="namespace")
else:
namespace = self.config.get_object("namespace1",
"name",
modul="namespace")
if not self.config.has_option(template, "name"):
self.config.set(
template, "name", "%s-%s" %
(self.config.project_name, "template%s" % deploy_index))
metadata = K8Meta(name=self.config.get_object(template, "name"),
namespace=namespace,
labels=label)
volumes = self.set_template_volumes(template)
if self.config.has_option(template, "restart"):
restart = self.config.get_object(template, "restart")
else:
restart = None
container = self.set_container(deploy_index)
if container is None:
self.config.config_status = ErrorHandling.print_error_config(
self.config, self.language["tem02"], locals(), bold=True)
return None
spec = K8spec(containers=container,
volumes=volumes,
restart_policy=restart)
return K8Template(metadata=metadata, spec=spec)
def tls(self, secret):
"""Verfahren für ein TLS Secret System"""
data = {}
secret_type = "kubernetes.io/tls"
metadata = self.set_metadata(secret)
if self.config.has_option(secret, "tls_key"):
key_file = self.config.get_object(secret, "tls_key")
if key_file.startswith("@"):
self.config.copy_option_to_option(key_file[1:],
secret,
"tls_key",
change=True)
else:
self.config.copy_option_to_option("secret", secret, "tls_key")
tls_key = self.config.get_object(secret, "tls_key")
tls_crt = self.config.get_object(secret, "tls_crt")
if tls_key is None:
self.config.config_status = ErrorHandling.print_error_config(
self.config,
"%s (%s/secret)" % (self.language["s_s01"], secret),
locals(),
bold=True)
return None
if tls_crt is None:
self.config.config_status = ErrorHandling.print_error_config(
self.config,
"%s (%s)" % (self.language["s_s02"], secret),
locals(),
bold=True)
return None
try:
tls_key = open(tls_key, "rb")
tls_crt = open(tls_crt, "rb")
except FileNotFoundError as e:
self.config.config_status = ErrorHandling.print_error_config(
self.config,
"%s (%s)" % (self.language["s_s03"], e),
locals(),
bold=True)
return None
data["tls.key"] = b64encode(tls_key.read()).decode("ASCII")
data["tls.crt"] = b64encode(tls_crt.read()).decode("ASCII")
tls_key.close()
tls_crt.close()
return K8Secret(data=data, metadata=metadata, type=secret_type)
def generate_project(self):
"""Erstele die Kubernetes Objecte in Kubernetes"""
if not self.config.config_status:
# Handling wenn ein Congig Fehler gefunden wurde
print(Color.color_text(" FAIL ", Color.BLINK, long=70, fill="!"))
ErrorHandling.print_error(self.language["main01"], bold=True, verbose=self.config.verbose)
print(Color.color_text(" FAIL ", Color.BLINK, long=70, fill="!"))
return
if self.k8_activ:
for k8pg_modul in self.k8_modul_interal:
if self.k8_object[k8pg_modul] is not None:
for body in self.k8_object[k8pg_modul]:
self.make_object(k8pg_modul, body)
def set_service(self, service):
"""Erstelt ein Service Object"""
index = service.replace("service", "")
self.config.activ_modul = "service"
template_index = "template%s" % index
if not self.config.has_option(service, "name"):
self.config.set(service, "name", "%s-%s" % (self.config.project_name, service))
name = self.config.get_object(service, "name")
if not self.config.has_option(service, template_index) and self.config.has_option(template_index, "label"):
self.config.copy_option_to_option(template_index, service, "label", to_option="template")
if self.config.has_option(service, "template"):
template = self.config.get_object(service, "template")
if template.startswith("@t"):
self.config.copy_option_to_option(template[1:], service, "label", to_option="template", iteral=False, change=True)
template = self.config.get_object(service, "template")
template = template.split(",")
if not len(template) == 2:
self.config.config_status = ErrorHandling.print_error_config(self.config, "%s (%s)" % (self.language["ser06"], service), locals(), bold=True)
else:
self.config.config_status = ErrorHandling.print_error_config(self.config, "%s (%s)" % (self.language["ser01"], service), locals(), bold=True)
return None
if self.config.has_option(service, "extern_ips"):
external_i_ps = self.config.get_object(service, "extern_ips").split(",")
else:
external_i_ps = None
ports = []
for port in self.config.config_iteral(service, "port", no="_"):
service_port = self.set_service_port(service, port, template_index)
if service_port is None:
self.config.config_status = ErrorHandling.print_error("%s (%s)" % (self.language["ser02"], service))
return None
ports.append(self.set_service_port(service, port, template_index))
if not ports:
self.config.config_status = ErrorHandling.print_error_config(self.config, "%s (%s)" % (self.language["ser03"], name), locals(), bold=True)
ports = self.config.config_iteral(service, "port", no="_")
if len(ports) == 0:
self.config.config_status = ErrorHandling.print_error("%s (%s)" % (self.language["ser01"], service))
return None
metadata = K8Meta(name=name,
labels={"name": name})
spec = K8Spec(selector={template[0]: template[1]},
external_i_ps=external_i_ps,
ports=ports)
return K8Service(metadata=metadata, spec=spec)
def set_volume_nfs(config, volume):
"""Kubernetes Object Einträge für NFS Server"""
metadata = K8Meta(annotations={
"volume.beta.kubernetes.io/mount-options":
"nolock,local_lock=none"
})
server = config.get_object(volume, "server")
path = config.get_object(volume, "path")
if server is None or path is None:
ErrorHandling.print_error("no server info", locals())
return None
device = K8NFSDivice(server=config.get_object(volume, "server"),
path=config.get_object(volume, "path"))
spec = K8Spec(nfs=device)
return {"metadata": metadata, "spec": spec}
def set_ingress_tls(self, tls_hosts):
"""Ermitlung einer TLS Definition für das Ingress Object"""
tls_nr = tls_hosts.split("_")[0]
rule_nr = tls_nr.replace("tls", "rule")
secret_nr = tls_nr.replace("tls", "secret")
secret = None
hosts = self.config.get_object("ingress1", tls_hosts).split(",")
if hosts[0].startswith("@"):
self.config.copy_option_to_option_in_section("ingress1",
rule_nr,
from_pre="_host",
to_option=tls_hosts,
change=True,
iteral=False)
hosts = self.config.get_object("ingress1", tls_hosts).split(",")
self.config.copy_option_to_option("%s1" % secret_nr,
"ingress1",
"name",
to_option=tls_nr,
to_pre="_secret",
iteral=False)
if self.config.has_option("ingress1", "%s_secret" % tls_nr):
secret = self.config.get_object("ingress1", tls_nr, pre="_secret")
else:
self.config.config_status = ErrorHandling.print_error_config(
self.config,
"%s (%s)" % (self.language["ing05"], tls_nr),
locals(),
bold=True)
return None
return K8IngressTLS(hosts=hosts, secret_name=secret)
def set_service_port(self, service, port, template):
"""Port Definitions Ermitlung für das Service Object"""
port_target = "%s_target" % port
if self.config.has_option(service, port_target):
port_intern = self.config.get_object(service, port_target)
if port_intern.startswith("@c"):
if port_intern == "@container":
port_intern = "@container1"
container_ports = self.config.get_object(port_intern[1:], "ports", modul="container")
if container_ports is None:
self.config.config_status = ErrorHandling.print_error_config(self.config, "%s ( %s, %s, %s)" % (self.language["ser01"], port_intern, port, service), locals(), bold=True)
return None
container_ports = container_ports.split(",")
self.config.set(service, port_target, container_ports[0])
else:
if self.config.has_option(template, port):
self.config.copy_option_to_option(template, service, port, to_option=port_target, iteral=False)
else:
return None
if not self.config.has_option(service, "%s_name" % port):
self.config.set(service, "%s_name" % port, "%s-%s-%s" % (self.config.project_name, service, port))
if self.config.has_option(service, "%s_protocol" % port):
protocol = self.config.get_object(service, port, pre="_protocol")
else:
protocol = None
return K8Port(port=self.config.get_object(service, port, integer=True),
name=self.config.get_object(service, port, pre="_name"),
target_port=self.config.get_object(service, port_target, integer=True),
protocol=protocol)
def set_deploy(self, deploy):
"""Erstelt ein Deployment Object"""
deploy_index = deploy.replace('deploy', '')
metadata = None
if not self.config.has_option(deploy, "name"):
self.config.set(deploy, "name", "%s-%s" % (self.config.project_name, deploy))
metadata = K8Meta(name=self.config.get_object(deploy, "name"))
if not self.config.has_option(deploy, "replicas"):
self.config.set(deploy, "replicas", "1")
replicas = self.config.get_object(deploy, "replicas", integer=True)
template = self.set_template(deploy_index)
if template is None:
self.config.config_status = ErrorHandling.print_error_config(self.config, self.language["dep01"], locals(), bold=True)
return None
label = self.config.get_object("template%s" % deploy_index, "label", modul="template")
label = label.split(",")
selector = K8Selector(match_labels={label[0]: label[1]})
spec = K8Spec(replicas=replicas,
selector=selector,
template=template)
return K8Deployment(metadata=metadata, spec=spec)
def del_project(self):
"""geht die zu löschenden Kubernetes Objecte durch"""
if not self.config.config_status:
# Handling wenn ein Congig Fehler gefunden wurde
print(Color.color_text(" FAIL ", Color.BLINK, long=70, fill="!"))
ErrorHandling.print_error(self.language["main01"], bold=True, verbose=self.config.verbose)
print(Color.color_text(" FAIL ", Color.BLINK, long=70, fill="!"))
return
if self.k8_activ:
for k8pg_modul in self.k8_modul_interal:
if self.k8_object[k8pg_modul] is not None:
if type(self.k8_object[k8pg_modul]) is list:
for body in self.k8_object[k8pg_modul]:
self.del_object(k8pg_modul, body)
else:
self.del_object(k8pg_modul, self.k8_object[k8pg_modul])
def set_template_volume(self, volume_nr, template):
"""Ermitlung einer Volume Definition für das Template Object"""
volume_intern = self.config.get_object(template, volume_nr)
if volume_intern.startswith("@c"):
self.config.copy_option_to_option(volume_intern[1:],
template,
"name",
to_option=volume_nr,
add=True,
change=True,
iteral=False)
self.config.copy_option_to_option(volume_intern[1:],
template,
"name",
to_option=volume_nr,
to_pre="_claim",
change=True,
iteral=False)
if self.config.has_option(template, "%s_claim" % volume_nr):
claim = self.config.get_object(template, volume_nr, pre="_claim")
if claim.startswith("@c"):
claim = self.config.get_object(claim[1:],
"name",
modul="claims")
if claim is None:
self.config.config_status = ErrorHandling.print_error_config(
self.config,
"%s (%s)" % (self.language["tem03"], volume_nr),
locals(),
bold=True)
return None
self.config.set(template, "%s_claim" % volume_nr, claim)
else:
self.config.config_status = ErrorHandling.print_error_config(
self.config,
"%s (%s)" % (self.language["tem04"], volume_nr),
locals(),
bold=True)
return None
volume_claim = K8VolumeClaim(claim_name=claim)
volume = K8Volume(name=self.config.get_object(template, volume_nr),
persistent_volume_claim=volume_claim)
return volume
def del_object(self, k8pg_name, body):
"""Löscht die einzelnene Kubernetes Objecte"""
body_dict = body.to_dict()
try:
if k8pg_name in self.k8_modul_no_namespace:
if self.arg.deleteall:
api_response = self.k8_delete[k8pg_name]["k8_methode"](name=body_dict["metadata"]["name"], pretty="true")
else:
api_response = None
else:
api_response = self.k8_delete[k8pg_name]["k8_methode"](namespace=self.config.get_object("namespace1", "name"), name=body_dict["metadata"]["name"], pretty="true")
if api_response is not None:
print("%s Opject: %s (Type: %s)" % (Color.color_text(" DELETE ", color=Color.BOLD, long=20, fill="-"), body_dict["metadata"]["name"], k8pg_name))
pprint(api_response)
sleep(5)
except ApiException as e:
error_body = eval(e.body)
ErrorHandling.print_K8Exection(self.config, error_body, self.language["main03"], k8pg_name)
def run_projects(self):
"""Start Methode der Classe"""
if self.arg.printconfig:
self.print_config()
if self.arg.configfile:
# Handling wenn eine Config Datei angegeben wird
if self.arg.configfile.endswith(".conf"):
project_name = self.arg.configfile.split("/")[-1][:-5]
else:
project_name = self.arg.configfile.split("/")[-1]
self.set_project(self.arg.configfile, project_name)
if self.arg.run:
self.generate_project()
else:
self.get_object()
if self.arg.getconfigfile:
fh = open("%s_out.config" % self.config.project_name, "w")
self.config.write(fh)
fh.close()
else:
for config_file in glob("*.conf"):
# Handling wenn der K8ProjectGenerater in einen Verzeichnis mit Config Dateien ausgefürt wird
self.config = None
self.k8_object = {}
if not self.arg.run:
print(Color.color_text(" %s " % config_file, Color.BOLD, 70, "-"))
project_name = config_file[:-5]
self.set_project(config_file, project_name)
if self.arg.run:
self.generate_project()
else:
self.get_object()
print(Color.color_text(" END %s " % config_file, Color.BOLD, 70, "-"))
if self.arg.getconfigfile:
fh = open("%s_out.config" % self.config.project_name, "w")
self.config.write(fh)
fh.close()
if not self.k8_activ:
# Handling wenn Kubernetes nicht in System gefunden wird
print(Color.color_text(" Warrning ", Color.PURPLE, long=70, fill="!"))
ErrorHandling.print_error(self.language["main02"], bold=True, verbose=self.arg.verbose)
print(Color.color_text(" Warrning ", Color.PURPLE, long=70, fill="!"))
def get_object(self):
"""Gebe die erstelten Kubernetes body Objecte und K8PojectManager Objecte aus"""
if self.config.verbose or not self.config.config_status:
# Gibt eine Warnung und die Config Datei mit aus abhängig von Verbose Parameter und ob ein Config Fehler festgestelt worden ist
if not self.config.config_status:
print(Color.color_text(" FAIL ", Color.BLINK, long=70, fill="!"))
self.config.format_print()
if not self.config.config_status:
print(Color.color_text(" FAIL ", Color.BLINK, long=70, fill="!"))
if self.config.config_status:
# Gibt die Kubernetes Body Objecte nur aus wenn kein Config Fehler festgestelt wurde
print(Color.color_text(" Project: %s " % self.config.project_name, long=70, fill="*"))
for k8pg_modul in self.k8_modul_interal:
if self.k8_object[k8pg_modul] is not None:
index = 0
for body in self.k8_object[k8pg_modul]:
index = index + 1
print(Color.color_text(" %s%i " % (k8pg_modul, index), long=60, fill="#"))
print(type(body))
ErrorHandling.pprint_to_dic(body, self.config.verbose)
def set_secrets(self):
"""Esstellt das Secret Object"""
self.config.activ_modul = "secret"
secrets = []
for secret in self.config.config_iteral("secret"):
k8pg_secret = self.k8_secret.get(
self.config.get_object(secret, "type"), None)
if k8pg_secret is None:
self.config.config_status = ErrorHandling.print_error_config(
self.config, self.language["sec01"], locals(), bold=True)
continue
secret = k8pg_secret(secret)
if secret is None:
self.config.config_status = ErrorHandling.print_error_config(
self.config, self.language["sec03"], locals(), bold=True)
continue
secrets.append(secret)
if not secrets:
return None
return secrets
def set_claim(self, claim):
"""Erstelle ein Claim Object"""
self.config.activ_modul = "claim"
claim_options = {}
claim_options.update(self.k8pg_option_to_section["claim"])
del claim_options["__section__"]
volume = claim.replace("claim", "volume")
spec = {
"storageClassName": None,
"accessModes": None,
"resources": {
"requests": {
"storage": None
}
}
}
for option in claim_options.keys():
self.config.copy_option_to_option(volume,
claim,
claim_options[option][3],
to_option=option,
add=claim_options[option][4],
iteral=False)
option_value = self.config.get_object(claim, option)
if option_value is None:
self.config.config_status = ErrorHandling.print_error_config(
self.config,
"%s (%s)" %
(self.language[claim_options[option][5]], claim),
locals(),
bold=True)
return None
elif option_value.startswith("@v"):
self.config.copy_option_to_option(option_value[1:],
claim,
claim_options[option][3],
to_option=option,
add=claim_options[option][4],
change=True,
iteral=False)
metadata = K8Meta(name=self.config.get_object(claim, "name"))
resource = K8Resource(
requests={"storage": self.config.get_object(claim, "requests")})
spec = K8Spec(
access_modes=[self.config.get_object(claim, "accessmodes")],
resources=resource,
storage_class_name=self.config.get_object(claim, "volume_class"))
return K8Claim(metadata=metadata, spec=spec)
def delete_project(self):
"""Start Methode der Classe"""
if self.arg.printconfig:
self.print_config()
if self.arg.configfile.endswith(".conf"):
project_name = self.arg.configfile.split("/")[-1][:-5]
else:
project_name = self.arg.configfile.split("/")[-1]
self.set_project(self.arg.configfile, project_name)
self.k8_modul_interal.reverse()
if self.arg.delete or self.arg.deleteall:
self.del_project()
else:
self.get_object()
if self.arg.getconfigfile:
fh = open("%s_out.config" % self.config.project_name, "w")
self.config.write(fh)
fh.close()
if not self.k8_activ:
# Handling wenn Kubernetes nicht in System gefunden wird
print(Color.color_text(" Warrning ", Color.PURPLE, long=70, fill="!"))
ErrorHandling.print_error(self.language["main02"], bold=True, verbose=self.arg.verbose)
print(Color.color_text(" Warrning ", Color.PURPLE, long=70, fill="!"))
def get_object(self, selector, key, pre=None, integer=False, booled=False, noconfig=False, modul=None):
"""get() mit Überprüfung"""
active_modul = modul or self.activ_modul
key = SubMethodes.get_index_str(key, text2=pre)
try:
if integer:
value = self.getint(selector, key)
elif booled:
value = self.getboolean(selector, key)
else:
value = self.get(selector, key)
except (NoSectionError, NoOptionError, ValueError) as e:
self.config_status = ErrorHandling.print_error("%s (Project %s)" % (e, self.project_name), verbose=self.verbose)
if noconfig or self.verbose:
self.format_print()
return None
rawkey = ""
for index in key:
if not index.isdigit():
rawkey = rawkey + index
if not ErrorHandling.check_parameter(value, self.k8_option_to_section[active_modul][rawkey][2]) or value is None:
ErrorHandling.print_error("Parameter Fail: Parameter: %s / required: %s" % (value, self.k8_option_to_section[active_modul][rawkey][2]))
return None
return value
def set_ingress_annotations(self):
"""Ermitlung der Anntations Definitionen für das Ingress Object"""
annotations = {}
for annotation in self.config.config_iteral("ingress1",
"annotation",
no="_value"):
value = self.config.get_object("ingress1",
annotation,
pre="_value")
if value is not None:
annotations[annotation] = value
else:
self.config.config_status = ErrorHandling.print_error_config(
self.config, self.language["ing03"], locals(), bold=True)
return None
return annotations
def set_container_volume(self, container, volume_path, deploy_index):
"""Ermitlung der persitent Volume Definitionen in einen Pod/Container Object"""
template = "template%s" % deploy_index
volume_nr = volume_path.split("_")[0]
path = self.config.get_object(container, volume_path)
if path.startswith("@co"):
alter_container = path[1:]
self.config.copy_option_to_option(alter_container,
container,
volume_nr,
change=True)
self.config.copy_option_to_option(alter_container,
container,
volume_path,
change=True)
name = None
if self.config.has_option(container, volume_nr):
name = self.config.get_object(container, volume_nr)
if name.startswith("@vo"):
self.config.copy_option_to_option(template,
container,
name[1:],
to_option=volume_nr,
iteral=False)
else:
if self.config.has_option(template, volume_nr):
self.config.copy_option_to_option(template,
container,
volume_nr,
iteral=False)
elif self.config.has_option(template, "volume%s" % deploy_index):
self.config.copy_option_to_option(template,
container,
"volume%s" % deploy_index,
to_option=volume_nr,
iteral=False)
name = self.config.get_object(container, volume_nr)
if name is None:
self.config.config_status = ErrorHandling.print_error_config(
self.config, self.language["con03"], locals(), bold=True)
return None
return K8Mount(name=name,
mount_path=self.config.get_object(
container, volume_path))
def set_ingress_rules(self):
"""Handhabung für scalirte Rule Definitionen für das Ingress Object"""
rules = []
self.config.copy_option_to_option("service",
"ingress1",
"port",
to_option="rule",
to_pre="_port")
for rule in self.config.config_iteral("ingress1", "rule", pre="_host"):
rule_spec = self.set_ingress_rule(rule)
if rule_spec is not None:
rules.append(self.set_ingress_rule(rule))
else:
self.config.config_status = ErrorHandling.print_error_config(
self.config,
"%s (%s)" % (self.language["ing06"], rule),
locals(),
bold=True)
return None
return rules
def set_ingress(self):
"""Erstelt Ingress Object"""
self.config.activ_modul = "ingress"
metadata = {"name": None}
spec = {}
if not self.config.has_section("ingress1"):
return None
if not self.config.has_option("ingress1", "name"):
if self.config.has_option("template1", "label"):
name = self.config.get_object("template1",
"label",
modul="template")
name = name.split(",")[1]
self.config.set("ingress1", "name", name)
else:
self.config.set("ingress1", "name", self.config.project_name)
annotations = {}
if self.config.has_option("ingress1", "whitelist"):
annotations.update(self.insert_whitelist())
if len(self.config.config_iteral("ingress1", "rule", pre="_host")) > 0:
rules = self.set_ingress_rules()
else:
rules = None
if self.config.has_option("ingress1", "ssl_backends"):
ssl_backend = self.insert_ssl_backend()
if ssl_backend is None:
self.config.config_status = ErrorHandling.print_error_config(
self.config, self.language["ing01"], locals(), bold=True)
return None
annotations.update(self.insert_ssl_backend())
if len(self.config.config_iteral("ingress1", "annotation",
no="_value")) > 0:
annotations.update(self.set_ingress_annotations())
if annotations == {}:
annotations = None
if self.config.has_option("ingress1", "backend_host"):
backend = K8IngressBackend(
self.config.get_object("ingress1", "backend_host"),
self.config.get_object("ingress1",
"backend_port",
integer=True))
else:
backend = None
if self.config.has_option("ingress1",
"tls_hosts") or self.config.has_option(
"ingress1", "tls1_hosts"):
tls = self.set_ingress_tls_s()
else:
tls = None
if rules is None and backend is None:
self.config.config_status = ErrorHandling.print_error_config(
self.config, self.language["ing02"], locals(), bold=True)
return None
metadata = K8Meta(annotations=annotations,
name=self.config.get_object("ingress1", "name"))
spec = K8Spec(backend=backend, rules=rules, tls=tls)
return [K8Ingress(metadata=metadata, spec=spec)]
def set_ingress_rule(self, rule_host):
"""Ermitlung einer Rule Definition für das Ingress Object"""
rule_nr = rule_host.split("_")[0]
port_nr = rule_nr.replace("rule", "port")
self.config.copy_option_to_option("service1",
"ingress1",
"name",
to_option=rule_nr,
to_pre="_servicename",
iteral=False)
self.config.copy_option_to_option("service1",
"ingress1",
port_nr,
to_option=rule_nr,
to_pre="_port",
iteral=False)
service_port = self.config.get_object("ingress1",
rule_nr,
pre="_servicename")
if service_port is not None:
if service_port.startswith("@p"):
self.config.copy_option_to_option("service1",
"ingress1",
"name",
to_option=rule_nr,
to_pre="_servicename",
change=True,
iteral=False)
self.config.copy_option_to_option("service1",
"ingress1",
service_port[1:],
to_option=rule_nr,
to_pre="_port",
change=True,
iteral=False)
if service_port.startswith("@s"):
self.config.copy_option_to_option(service_port[1:],
"ingress1",
"name",
to_option=rule_nr,
to_pre="_servicename",
change=True,
iteral=False)
self.config.copy_option_to_option(service_port[1:],
"ingress1",
"port",
to_option=rule_nr,
to_pre="_port",
change=True,
iteral=False)
host = self.config.get_object("ingress1", rule_host)
port = self.config.get_object("ingress1",
rule_nr,
pre="_port",
integer=True)
servicname = self.config.get_object("ingress1",
rule_nr,
pre="_servicename")
if host is None or port is None or servicname is None:
self.config.config_status = ErrorHandling.print_error_config(
self.config, self.language["ing04"], locals(), bold=True)
return None
http = K8IngressBackend(servicname, port)
http = K8IngressPath(http)
http = K8IngressRuleValue([http])
return K8IngressRule(self.config.get_object("ingress1", rule_host),
http)
def set_container(self, deploy_index):
"""Erstellt ein Pod/Container Object"""
pot = "container%s" % deploy_index
template = "template%s" % deploy_index
self.config.activ_modul = "container"
# Ermittle Image
image = self.config.get_object(pot, "image")
if image is not None:
if not self.config.has_option(pot, "name"):
name = sub("[:/.]", "-", self.config.get_object(pot, "image"))
self.config.set(pot, "name", name)
else:
ErrorHandling.print_error_config(self.config,
self.language["con02"],
locals(),
bold=True)
return None
# Ermitle Ports
ports = []
if self.config.has_option(pot, "ports"):
pre_ports = self.config.config_iteral(template, "port")
pre_ports = len(pre_ports)
if self.config.has_option(template, "port"):
pre_ports = pre_ports - 1
for port in self.config.get_object(pot, "ports").split(","):
ports.append(K8Port(container_port=int(port)))
pre_ports = pre_ports + 1
self.config.set(template, "port%i" % pre_ports, port)
if pre_ports == 1:
self.config.set(template, "port", port)
if not ports:
ports = None
envs = []
for env in self.config.config_iteral(pot, "env", no="_value"):
envs.append(self.set_container_env(pot, env))
if not envs:
envs = None
if self.config.has_option(pot, "command"):
command = self.config.get_object(pot, "command").split(" ")
else:
command = None
if self.config.has_option(pot, "pull"):
pull = self.config.get_object(pot, "pull")
else:
pull = "Always"
args = []
for arg in self.config.config_iteral(pot, "arg"):
args.append(self.set_container_arg(pot, arg))
if not args:
args = None
volumes = []
for volume in self.config.config_iteral(pot, "volume", pre="_path"):
volumes.append(self.set_container_volume(pot, volume,
deploy_index))
if not volumes:
volumes = None
return [
K8Container(name=self.config.get_object(pot, "name"),
image=self.config.get_object(pot, "image"),
command=command,
args=args,
env=envs,
volume_mounts=volumes,
ports=ports,
image_pull_policy=pull)
]
