import base64
import copy

from kapitan.inputs.kadet import BaseObj, inventory
from kapitan.utils import render_jinja2_file
from kapitan.cached import args

from . import k8s

search_paths = args.get("search_paths")

inv = inventory()


def j2(filename, ctx):
    return render_jinja2_file(filename, ctx, search_paths=search_paths)


def merge(source, destination):
    for key, value in source.items():
        if isinstance(value, dict):
            node = destination.setdefault(key, value)
            if node is None:
                destination[key] = value
            else:
                merge(value, node)
        else:
            destination[key] = destination.setdefault(key, value)

    return destination
예제 #2
0
from kapitan.inputs import kadet

kubelib = kadet.load_from_search_paths("kubelib")
inv = kadet.inventory()

name = "nginx"
labels = kadet.BaseObj.from_dict({"app": name})
nginx_container = kubelib.Container(name=name,
                                    image=inv.parameters.nginx.image,
                                    ports=[{
                                        "containerPort": 80
                                    }])

svc_selector = {"app": name}
svc_port = kadet.BaseObj()
svc_port.root.name = "http"
svc_port.root.port = 80
svc_port.root.targetPort = 80


def main():
    return {
        "nginx_deployment":
        kubelib.Deployment(name=name,
                           labels=labels,
                           containers=[nginx_container]),
        "nginx_service":
        kubelib.Service(name=name,
                        labels=labels,
                        ports=[svc_port],
                        selector=svc_selector),
예제 #3
0
from .resources import DeploymentHost, DeploymentTunnel, ConfigMap, Secret, PersistentVolumeClaim
from kapitan.inputs.kadet import BaseObj, inventory
p = inventory().parameters


def main():
    obj = BaseObj()

    for node_name in p.nodes.keys():
        node = p.nodes[node_name]
        if node.type == "host":
            obj.root[node_name + "_host_deployment"] = DeploymentHost(
                name=node_name,
                image=node.image,
                validator_key=node.validator_key,
                infura_url=node.infura_url,
                rpc_port=node.rpc_port,
                node_port=node.node_port,
                node_selector=node.node_selector,
                hostpath=node.hostpath or None)
        elif node.type == "tunnel":
            obj.root[node_name + "_tunnel_deployment"] = DeploymentTunnel(
                name=node_name,
                image=node.image,
                tunnel_image=node.tunnel_image,
                validator_key=node.validator_key,
                infura_url=node.infura_url,
                public_ip=node.public_ip,
                node_port=node.node_port,
                node_selector=node.node_selector,
                hostpath=node.hostpath or None)