def test_lists(self):
kobj = KadetTestObj(name="testObj", size=5)
kobj.root.with_lists = [
Dict({"i_am_inside_a_list": True}),
BaseObj.from_dict({"me": "too"}),
BaseObj.from_dict({
"list_of_objs":
[BaseObj.from_dict(dict(a=1, b=2)),
Dict(dict(c=3, d=4))]
}),
]
output = kobj.to_dict()
desired_output = {
"name":
"testObj",
"size":
5,
"first_key":
1,
"traditional_key":
3,
"nested": {
"first_key": 2
},
"with_dict": {
"A": "dict"
},
"with_baseobj_init_as": {
"init": "as"
},
"with_baseobj": {
"inside": "BaseObj"
},
"with_another_dict": {
"Another": "Dict"
},
"with_lists": [
{
"i_am_inside_a_list": True
},
{
"me": "too"
},
{
"list_of_objs": [{
"a": 1,
"b": 2
}, {
"c": 3,
"d": 4
}]
},
],
}
self.assertEqual(output, desired_output)
def body(self):
self.root.name = self.kwargs.name
self.root.size = self.kwargs.size
self.root.first_key = 1
self.root.nested.first_key = 2
self.root["traditional_key"] = 3
self.root.with_dict = {"A": "dict"}
self.root.with_baseobj_init_as = BaseObj.from_dict({"init": "as"})
bobj = BaseObj()
bobj.root.inside = "BaseObj"
self.root.with_baseobj = bobj
self.root.with_another_dict = Dict({"Another": "Dict"})
def body(self):
self.root.name = self.kwargs.name
self.root.size = self.kwargs.size
self.root.first_key = 1
self.root.nested.first_key = 2
self.root['traditional_key'] = 3
self.root.with_dict = {'A': 'dict'}
self.root.with_baseobj_init_as = BaseObj.from_dict({'init': 'as'})
bobj = BaseObj()
bobj.root.inside = "BaseObj"
self.root.with_baseobj = bobj
self.root.with_another_dict = Dict({'Another': 'Dict'})
def generate_resource_manifests(input_params):
obj = BaseObj()
for secret_name, secret_spec in inv.parameters.generators.rabbitmq.secrets.items(
):
name = secret_spec.get('name', secret_name)
secret = ComponentSecret(name=name, config=secret_spec)
obj.root[f'{name}'] = secret
for config_name, config_spec in inv.parameters.generators.rabbitmq.configs.items(
):
name = config_spec.get('name', config_name)
config = ComponentConfig(name=name, config=config_spec)
obj.root[f'{name}'] = config
return obj
def create_probe(probe_definition):
probe = BaseObj()
if "type" in probe_definition:
probe.root.initialDelaySeconds = probe_definition.get(
'initial_delay_seconds', 0)
probe.root.periodSeconds = probe_definition.get(
'period_seconds', 10)
probe.root.timeoutSeconds = probe_definition.get(
'timeout_seconds', 5)
probe.root.successThreshold = probe_definition.get(
'success_threshold', 1)
probe.root.failureThreshold = probe_definition.get(
'failure_threshold', 3)
if probe_definition.type == "http":
probe.root.httpGet.scheme = probe_definition.get(
'scheme', "HTTP")
probe.root.httpGet.port = probe_definition.get("port", 80)
probe.root.httpGet.path = probe_definition.path
probe.root.httpGet.httpHeaders = probe_definition.httpHeaders
if probe_definition.type == "tcp":
probe.root.tcpSocket.port = probe_definition.port
if probe_definition.type == "command":
probe.root.exec.command = probe_definition.command
return probe.root
def generate_manifests(input_params):
all_manifests = BaseObj()
rabbitmq_manifests = generate_rabbitmqcluster(input_params)
rabbitmq_queue_manifests = generate_rabbitmq_queue(input_params)
rabbitmq_policy_manifests = generate_rabbitmq_policy(input_params)
rabbitmq_exchange_manifests = generate_rabbitmq_exchange(input_params)
rabbitmq_binding_manifests = generate_rabbitmq_binding(input_params)
rabbitmq_user_manifests = generate_rabbitmq_user(input_params)
rabbitmq_permission_manifests = generate_rabbitmq_permission(input_params)
rabbitmq_vhost_manifests = generate_rabbitmq_vhost(input_params)
rabbitmq_federation_manifests = generate_rabbitmq_federation(input_params)
rabbitmq_shovel_manifests = generate_rabbitmq_shovel(input_params)
resource_manifests = generate_resource_manifests(input_params)
all_manifests.root.update(rabbitmq_manifests.root)
all_manifests.root.update(rabbitmq_queue_manifests.root)
all_manifests.root.update(rabbitmq_policy_manifests.root)
all_manifests.root.update(rabbitmq_exchange_manifests.root)
all_manifests.root.update(rabbitmq_binding_manifests.root)
all_manifests.root.update(rabbitmq_user_manifests.root)
all_manifests.root.update(rabbitmq_permission_manifests.root)
all_manifests.root.update(rabbitmq_vhost_manifests.root)
all_manifests.root.update(rabbitmq_federation_manifests.root)
all_manifests.root.update(rabbitmq_shovel_manifests.root)
all_manifests.root.update(resource_manifests.root)
return all_manifests
def generate_pre_deploy(input_params):
obj = BaseObj()
name = inv.parameters.namespace
namespace = NameSpace(name=name)
obj.root["{}-namespace".format(name)] = namespace
return obj
def generate_rabbitmq_policy(input_params):
obj = BaseObj()
rabbitmq_policy_list = inv.parameters.rabbitmq_policy
for name in rabbitmq_policy_list.keys():
rabbitmq_policy = RabbitmqPolicy(
name=name, rabbitmq_policy=rabbitmq_policy_list[name])
obj.root['{}-rabbitmq'.format(name)] = rabbitmq_policy
return obj
def test_from_json(self):
json_file = tempfile.mktemp()
with open(json_file, 'w') as fp:
fp.write('{"this": "that", "list": [1,2,3]}')
kobj = BaseObj.from_json(json_file)
output = kobj.to_dict()
desired_output = {"this": "that", "list": [1, 2, 3]}
self.assertEqual(output, desired_output)
def generate_rabbitmq_shovel(input_params):
obj = BaseObj()
rabbitmq_shovel_list = inv.parameters.rabbitmq_shovel
for name in rabbitmq_shovel_list.keys():
rabbitmq_shovel = RabbitmqShovel(
name=name, rabbitmq_shovel=rabbitmq_shovel_list[name])
obj.root['{}-rabbitmq'.format(name)] = rabbitmq_shovel
return obj
def generate_rabbitmq_federation(input_params):
obj = BaseObj()
rabbitmq_federation_list = inv.parameters.rabbitmq_federation
for name in rabbitmq_federation_list.keys():
rabbitmq_federation = RabbitmqFederation(
name=name, rabbitmq_federation=rabbitmq_federation_list[name])
obj.root['{}-rabbitmq'.format(name)] = rabbitmq_federation
return obj
def generate_rabbitmq_vhost(input_params):
obj = BaseObj()
rabbitmq_vhost_list = inv.parameters.rabbitmq_vhost
for name in rabbitmq_vhost_list.keys():
rabbitmq_vhost = RabbitmqVhost(
name=name, rabbitmq_vhost=rabbitmq_vhost_list[name])
obj.root['{}-rabbitmq'.format(name)] = rabbitmq_vhost
return obj
def generate_rabbitmq_user(input_params):
obj = BaseObj()
rabbitmq_user_list = inv.parameters.rabbitmq_user
for name in rabbitmq_user_list.keys():
rabbitmq_user = RabbitmqUser(name=name,
rabbitmq_user=rabbitmq_user_list[name])
obj.root['{}-rabbitmq'.format(name)] = rabbitmq_user
return obj
def generate_rabbitmq_binding(input_params):
obj = BaseObj()
rabbitmq_binding_list = inv.parameters.rabbitmq_binding
for name in rabbitmq_binding_list.keys():
rabbitmq_binding = RabbitmqBinding(
name=name, rabbitmq_binding=rabbitmq_binding_list[name])
obj.root['{}-rabbitmq'.format(name)] = rabbitmq_binding
return obj
def generate_rabbitmq_exchange(input_params):
obj = BaseObj()
rabbitmq_exchange_list = inv.parameters.rabbitmq_exchange
for name in rabbitmq_exchange_list.keys():
rabbitmq_exchange = RabbitmqExchange(
name=name, rabbitmq_exchange=rabbitmq_exchange_list[name])
obj.root['{}-rabbitmq'.format(name)] = rabbitmq_exchange
return obj
def test_from_yaml(self):
yaml_file = tempfile.mktemp()
with open(yaml_file, 'w') as fp:
fp.write("this: that\nlist: [1,2,3]\n")
kobj = BaseObj.from_yaml(yaml_file)
output = kobj.to_dict()
desired_output = {"this": "that", "list": [1, 2, 3]}
self.assertEqual(output, desired_output)
def generate_docs(input_params):
obj = BaseObj()
template = input_params.get("template_path", None)
if template:
for name, component in get_components():
obj.root["{}-readme.md".format(name)] = j2(template,
{"service_component": component.to_dict(),
"inventory": inv.parameters.to_dict()})
return obj
def generate_argocd_appproject(input_params):
obj = BaseObj()
bundle = list()
argocd_projects = inv.parameters.argocd_projects
for name in argocd_projects.keys():
argocd_project = ArgoCDAppProject(name=name,
argocd_project=argocd_projects[name])
obj.root['{}-argo-appproject'.format(name)] = argocd_project
return obj
def generate_argocd_application(input_params):
obj = BaseObj()
bundle = list()
argocd_applications = inv.parameters.argocd_applications
for name in argocd_applications.keys():
argocd_application = ArgoCDApplication(
name=name, argocd_application=argocd_applications[name])
obj.root['{}-argo-application'.format(name)] = argocd_application
return obj
def generate_manifests(input_params):
all_manifests = BaseObj()
argocd_project_manifests = generate_argocd_appproject(input_params)
argocd_application_manifests = generate_argocd_application(input_params)
resource_manifests = generate_resource_manifests(input_params)
all_manifests.root.update(argocd_project_manifests.root)
all_manifests.root.update(argocd_application_manifests.root)
all_manifests.root.update(resource_manifests.root)
return all_manifests
def generate_manifests(input_params):
obj = BaseObj()
for name, component in get_components():
config_maps = GenerateConfigMaps(name=name, component=component).root
secrets = GenerateSecrets(name=name, component=component).root
obj.root["{}-config".format(name)] = config_maps
obj.root["{}-secret".format(name)] = secrets
bundle = []
workload = Workload(name=name, component=component).root
bundle += [workload]
if component.service:
service = Service(name=name, component=component, workload=workload).root
bundle += [service]
if component.network_policies:
policies = GeneratePolicies(name=name, component=component).root
bundle += policies
if component.webhooks:
webhooks = MutatingWebhookConfiguration(name=name, component=component).root
bundle += [webhooks]
if component.service_monitors:
service_monitor = ServiceMonitor(name=name, component=component).root
bundle += [service_monitor]
if component.prometheus_rules:
prometheus_rule = PrometheusRule(name=name, component=component).root
bundle += [prometheus_rule]
if component.cluster_role:
cluster_role = ClusterRole(name=name, component=component).root
bundle += [cluster_role]
cluster_role_binding = ClusterRoleBinding(name=name, component=component).root
bundle += [cluster_role_binding]
obj.root["{}-bundle".format(name)] = bundle
if component.service_account.get('enabled', False):
sa = ServiceAccount(name=name).root
obj.root["{}-sa".format(name)] = sa
return obj
def main():
obj = BaseObj()
for target in inv.keys():
p = inv[target].parameters
if "uptimerobot" in p:
obj.root["uptimerobot_provider.tf"] = UptimeRobotProvider(
version=p.uptimerobot.version,
api_key=p.uptimerobot.api_key,
email=p.uptimerobot.email)
if "nodes" in p:
for node_name in p.nodes.keys():
node = p.nodes[node_name]
obj.root[node_name +
"_uptimerobot_monitor.tf"] = UptimeRobotMonitor(
name=node_name,
ip=node.public_ip,
port=node.rpc_port)
return obj
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)
obj.root[node_name + "_tunnel_configmap"] = ConfigMap(
name=node_name + "-ssh-script",
rpc_port=node.rpc_port,
node_port=node.node_port,
public_ip=node.public_ip)
obj.root[node_name + "_tunnel_secret"] = Secret(name=node_name +
"-ssh",
key=node.ssh_key)
else:
raise Exception(
f"Expected node.type to be 'host' or 'tunnel', got {node.type}"
)
if not node.hostpath:
obj.root[node_name + "_pvc"] = PersistentVolumeClaim(
name=node_name + "-data", storage=node.pvc_storage)
return obj
def generate_manifests(input_params):
obj = BaseObj()
for name, component in get_components():
bundle = []
workload = Workload(name=name, component=component)
if component.schedule:
workload = CronJob(name=name, component=component, job=workload)
workload_spec = workload.root
bundle += [workload_spec]
configs = GenerateMultipleObjectsForClass(
name=name,
component=component,
generating_class=ConfigMap,
objects=component.config_maps,
workload=workload_spec)
secrets = GenerateMultipleObjectsForClass(name=name,
component=component,
generating_class=Secret,
objects=component.secrets,
workload=workload_spec)
workload.add_volumes_for_objects(configs)
workload.add_volumes_for_objects(secrets)
obj.root[f"{name}-config"] = configs.root
obj.root[f"{name}-secret"] = secrets.root
if component.vpa and component.type != "job":
vpa = VerticalPodAutoscaler(name=name,
component=component,
workload=workload_spec).root
bundle += [vpa]
if component.pdb_min_available:
pdb = PodDisruptionBudget(name=name,
component=component,
workload=workload_spec).root
bundle += [pdb]
if component.service:
service = Service(name=name,
component=component,
workload=workload_spec).root
bundle += [service]
if component.network_policies:
policies = GenerateMultipleObjectsForClass(
name=name,
component=component,
generating_class=NetworkPolicy,
objects=component.network_policies,
workload=workload_spec).root
bundle += policies
if component.webhooks:
webhooks = MutatingWebhookConfiguration(name=name,
component=component).root
bundle += [webhooks]
if component.service_monitors:
service_monitor = ServiceMonitor(name=name,
component=component,
workload=workload_spec).root
bundle += [service_monitor]
if component.prometheus_rules:
prometheus_rule = PrometheusRule(name=name,
component=component).root
bundle += [prometheus_rule]
if component.cluster_role:
cluster_role = ClusterRole(name=name, component=component).root
bundle += [cluster_role]
cluster_role_binding = ClusterRoleBinding(name=name,
component=component).root
bundle += [cluster_role_binding]
if component.backend_config:
backend_config = BackendConfig(name=name, component=component).root
bundle += [backend_config]
obj.root["{}-bundle".format(name)] = bundle
if component.service_account.get('create', False):
sa_name = component.service_account.get('name', name)
sa = ServiceAccount(name=sa_name, component=component).root
obj.root["{}-sa".format(name)] = sa
return obj
def test_parse_kwargs(self):
kobj = BaseObj.from_dict({"this": "that", "not_hidden": True})
output = kobj.to_dict()
desired_output = {"this": "that", "not_hidden": True}
self.assertEqual(output, desired_output)
def generate_manifests(input_params):
obj = BaseObj()
for name, component in get_components():
config_maps = GenerateConfigMaps(name=name, component=component).root
secrets = GenerateSecrets(name=name, component=component).root
obj.root["{}-config".format(name)] = config_maps
obj.root["{}-secret".format(name)] = secrets
bundle = []
workload = Workload(name=name, component=component)
if component.schedule:
workload = CronJob(name=name, component=component, job=workload)
workload_spec = workload.root
bundle += [workload_spec]
if component.vpa and component.type != "job":
vpa = VerticalPodAutoscaler(name=name,
component=component,
workload=workload_spec).root
bundle += [vpa]
if component.pdb_min_available:
pdb = PodDisruptionBudget(name=name,
component=component,
workload=workload_spec).root
bundle += [pdb]
if component.service:
service = Service(name=name,
component=component,
workload=workload_spec).root
bundle += [service]
if component.network_policies:
policies = GeneratePolicies(name=name, component=component).root
bundle += policies
if component.webhooks:
webhooks = MutatingWebhookConfiguration(name=name,
component=component).root
bundle += [webhooks]
if component.service_monitors:
service_monitor = ServiceMonitor(name=name,
component=component,
workload=workload_spec).root
bundle += [service_monitor]
if component.prometheus_rules:
prometheus_rule = PrometheusRule(name=name,
component=component).root
bundle += [prometheus_rule]
if component.cluster_role:
cluster_role = ClusterRole(name=name, component=component).root
bundle += [cluster_role]
cluster_role_binding = ClusterRoleBinding(name=name,
component=component).root
bundle += [cluster_role_binding]
obj.root["{}-bundle".format(name)] = bundle
if component.service_account.get('create', False):
sa_name = component.service_account.get('name', name)
sa = ServiceAccount(name=sa_name, component=component).root
obj.root["{}-sa".format(name)] = sa
return obj
