def delete_deployment(name: str, namespace: str=None, concurrency: int=None) -> None:
args = ["delete", "deploy", "--force", name]
if namespace is not None:
args.extend(["--namespace", namespace])
if concurrency is not None:
args.extend(["--concurrency", concurrency])
sh.chkit(*args).execute()
def create_ingress(ingress: Ingress, file: bool=False, namespace: str=None) -> None:
args = ["create", "ingr", "--name", ingress.name[0], "--force"]
if file:
args.extend(["--input", "json"])
else:
rule = ingress.rules[0]
args.extend(["--host", rule.host])
path = rule.path[0]
args.extend(["--path", path.path, "--service", path.service_name, "--port", path.service_port])
if namespace is not None:
args.extend(["--namespace", namespace])
sh.chkit(*args).execute()
def replace_container(deployment: str="", container: Container=Container(), namespace: str=None) -> None:
args = ["replace", "container", "--container", container.name, "--deployment", deployment, "--force"]
if namespace is not None:
args.extend(["--namespace", namespace])
if container.env is not None:
for var in container.env:
args.extend(["--env", f"{var.name}:{var.value}"])
if container.limits is not None:
if container.limits.cpu is not None:
args.extend(["--cpu", container.limits.cpu])
if container.limits.memory is not None:
args.extend(["--memory", container.limits.memory])
if container.image is not None:
args.extend(["--image", container.image])
sh.chkit(*args).execute()
def get_services(solution: str=None, namespace: str=None) -> List[Service]:
args = ["get", "svc", "--output", "json"]
if solution is not None:
args.extend(["--solution", solution])
if namespace is not None:
args.extend(["--namespace", namespace])
return [Service.json_decode(j) for j in json.loads(sh.chkit(*args).execute().stdout())]
def add_container(deployment: str="", container: Container=Container(), namespace: str=None, file: bool=False) -> None:
args = ["create", "container", "--name", container.name, "--deployment", deployment, "--force"]
if file:
args.extend(["--file", "-"])
else:
args.extend(["--image", container.image, "--memory", container.limits.memory, "--cpu", container.limits.cpu])
if container.env is not None:
for var in container.env:
args.extend(["--env", f"{var.name}:{var.value}"])
if namespace is not None:
args.extend(["--namespace", namespace])
if file:
sh.chkit(*args, _stdin=json.dumps(container, cls=JSONSerialize)).execute()
else:
sh.chkit(*args).execute()
def replace_ingress(ingress: Ingress, file: bool=False, namespace: str=None) -> None:
args = ["replace", "ingr", ingress.name[0], "--force"]
if file:
args.extend(["--input", "json"])
else:
path = ingress.rules[0].path[0]
if path.path is not None:
args.extend(["--path", path.path])
if path.service_name is not None:
args.extend(["--service", path.service_name])
if path.service_port != 0:
args.extend(["--port", path.service_port])
if namespace is not None:
args.extend(["--namespace", namespace])
sh.chkit(*args).execute()
def get_pods(namespace: str=None, status: str=None) -> List[Pod]:
args = ["get", "pods", "--output", "json"]
if namespace is not None:
args.extend(["--namespace", namespace])
if status is not None:
args.extend(["--status", status])
output = sh.chkit(*args).execute().stdout()
return [Pod.json_decode(j) for j in json.loads(output)]
def create_service(service: Service, file: bool=False, namespace: str=None) -> None:
args = ["create", "service", "--name", service.name, "--deployment", service.deploy, "--force"]
if file:
args.extend(["--input", "json"])
else:
port = service.ports[0]
args.extend(["--port-name", port.name, "--target-port", port.target_port, "--protocol", port.protocol])
if port.port is not None:
args.extend(["--port", port.port])
if namespace is not None:
args.extend(["--namespace", namespace])
if file:
service_to_create = Service(name=service.name, deploy=service.deploy, ports=service.ports)
sh.chkit(*args, _stdin=json.dumps(service_to_create, cls=JSONSerialize)).execute()
else:
sh.chkit(*args).execute()
def pod_logs(pod: str, container: str=None, tail: int=None, namespace: str=None) -> List[str]:
args = ["logs", pod]
if container is not None:
args.append(container)
if tail is not None:
args.extend(["--tail", tail])
if namespace is not None:
args.extend(["--namespace", namespace])
return sh.chkit(*args).execute().stdout().splitlines()
def replace_configmap(cm: ConfigMap, file: bool=False, namespace: str=None) -> None:
args = ["replace", "cm", cm.name, "--force"]
# if file:
# args.extend(["--input", "json"])
# else:
sep = " "
envs = []
for d in cm.data:
buf = "%s:%s" % (d, cm.data[d])
envs.append(buf)
args.extend(["--item-string", sep.join(envs)])
if namespace is not None:
args.extend(["--namespace", namespace])
# if file:
# cm_to_create = ConfigMap(name=cm.name, data=cm.data)
# sh.chkit(*args, _stdin=json.dumps(cm_to_create, cls=JSONSerialize)).execute()
# else:
sh.chkit(*args).execute()
def create_deployment(depl: Deployment, namespace: str=None, file: bool=False) -> None:
args = ["create", "deployment", "--force"]
if not file:
if depl.name is not None:
args.extend(["--name", depl.name])
for container in depl.containers:
args.extend(["--image", f"{container.name}@{container.image}"])
args.extend(["--cpu", f"{container.name}@{container.limits.cpu}"])
args.extend(["--memory", f"{container.name}@{container.limits.memory}"])
if container.env is not None:
for var in container.env:
args.extend(["--env", f"{container.name}@{var.name}:{var.value}"])
if container.config_maps is not None:
for var in container.config_maps:
args.extend(["--configmap", f"{container.name}@{var.name}"])
else:
args.extend(["--file", "-"])
if namespace is not None:
args.extend(["--namespace", namespace])
if not file:
sh.chkit(*args).execute()
else:
sh.chkit(*args, _stdin=json.dumps(depl, cls=JSONSerialize)).execute()
def delete_solution(name: str) -> None:
args = ["delete", "sol", name, "--force"]
sh.chkit(*args).execute()
def login(user: str="test", password: str="test", namespace: str="-") -> None:
sh.chkit("login", "--username", user, "--password", password, "--namespace", namespace).execute()
def get_solutions() -> List[Solution]:
args = ["get", "sol", "--output", "json"]
return [Solution.json_decode(j) for j in json.loads(sh.chkit(*args).execute().stdout()).get("solutions")]
def get_solution(name: str) -> Solution:
args = ["get", "sol", name, "--output", "json"]
return Solution.json_decode(json.loads(sh.chkit(*args).execute().stdout()))
def delete_service(service: str, namespace: str=None) -> None:
args = ["delete", "service", service, "--force"]
if namespace is not None:
args.extend(["--namespace", namespace])
sh.chkit(*args).execute()
def set_default_namespace(namespace: str="-") -> None:
sh.chkit("set", "default-namespace", namespace).execute()
def get_templates() -> List[Templates]:
args = ["get", "tmpl", "--output", "json"]
return [Templates.json_decode(j) for j in json.loads(sh.chkit(*args).execute().stdout()).get("solutions")]
def get_ingresses() -> List[Ingress]:
args = ["get", "ingr", "--output", "json"]
return [Ingress.json_decode(j) for j in json.loads(sh.chkit(*args).execute().stdout())]
def get_default_namespace() -> Tuple[str, str]:
output = sh.chkit("get", "default-namespace").execute().stdout()
line = output.splitlines()[0]
kv = line.split("/")
owner_login, namespace_name = kv[0], kv[1]
return owner_login, namespace_name
def delete_configmap(configmap: str, namespace: str=None) -> None:
args = ["delete", "cm", configmap, "--force"]
if namespace is not None:
args.extend(["--namespace", namespace])
sh.chkit(*args).execute()
def delete_container(deployment: str="", container: str="", namespace: str=None) -> None:
args = ["delete", "container", "--deployment", deployment, "--container", container, "--force"]
if namespace is not None:
args.extend(["--namespace", namespace])
sh.chkit(*args).execute()
def get_configmaps(namespace: str=None) -> List[ConfigMap]:
args = ["get", "cm", "--output", "json"]
if namespace is not None:
args.extend(["--namespace", namespace])
return [ConfigMap.json_decode(j) for j in json.loads(sh.chkit(*args).execute().stdout())]
def get_configmap(configmap: str, namespace: str=None) -> ConfigMap:
args = ["get", "cm", configmap, "--output", "json"]
if namespace is not None:
args.extend(["--namespace", namespace])
return ConfigMap.json_decode(json.loads(sh.chkit(*args).execute().stdout()))
def set_image(image: str="", container: str="", deployment: str="", namespace: str=None) -> None:
args = ["set", "image", "--image", image, "--container", container, "--deployment", deployment, "--force"]
if namespace is not None:
args.extend(["--namespace", namespace])
sh.chkit(*args).execute()
def get_template_envs(tmpl: str) -> TemplateEnvs:
args = ["get", "envs", tmpl, "--output", "json"]
return TemplateEnvs.json_decode(json.loads(sh.chkit(*args).execute().stdout()))
def delete_ingress(ingr: str, namespace: str=None) -> None:
args = ["delete", "ingr", ingr, "--force"]
if namespace is not None:
args.extend(["--namespace", namespace])
sh.chkit(*args).execute()
def run_solution(tmpl: str, name: str) -> None:
args = ["run", "sol", tmpl, "--name", name, "--force"]
sh.chkit(*args).execute()
def get_ingress(name: str) -> Ingress:
args = ["get", "ingr", name, "--output", "json"]
return Ingress.json_decode(json.loads(sh.chkit(*args).execute().stdout()))
def get_profile() -> Dict[str, str]:
output = sh.chkit("get", "profile").execute().stdout()
profile = (line.split(':') for line in output.splitlines())
profile = (tuple(items) for items in profile if len(items) == 2)
profile = {key.strip(): value.strip() for key, value in profile}
return profile
