1095 lines
30 KiB
Python
1095 lines
30 KiB
Python
import logging
|
|
import os
|
|
from collections import namedtuple
|
|
from pprint import pprint
|
|
from types import SimpleNamespace
|
|
|
|
# TO BE REMOVED !!!!
|
|
import click
|
|
import sh
|
|
|
|
from . import exceptions as error
|
|
from .framework import DictCtrl, DictItem, KeyValue, KeyValueExtra
|
|
from .idents import Ident
|
|
from .lib.utils import (empty, format_render, jinja_render,
|
|
jinja_template_vars, uniq)
|
|
|
|
logger = logging.getLogger(__name__)
|
|
cli_logger = logging.getLogger("iam.cli")
|
|
|
|
|
|
IamException = error.IamException
|
|
|
|
|
|
# Config classes: Plugin
|
|
# ================
|
|
|
|
|
|
# class Plugin(DictItem):
|
|
# "Hold provider entities"
|
|
|
|
# default_attrs = {
|
|
# "desc": "Resource without description",
|
|
# "input": {},
|
|
# "needs": [],
|
|
# }
|
|
|
|
|
|
# class Plugins(DictCtrl):
|
|
# "Hold provider entities"
|
|
|
|
# default_attrs = {
|
|
# "desc": "Resource without description",
|
|
# "input": {},
|
|
# "needs": [],
|
|
# }
|
|
|
|
|
|
# Config classes: Services
|
|
# ================
|
|
|
|
|
|
class ServiceCommand(DictItem):
|
|
"Hold provider services command"
|
|
|
|
default_attrs = {
|
|
"desc": "Service without description",
|
|
"cmd": "", # Direct commands to launch
|
|
"shell": "", # Will be run in a shell (or specific shell below)
|
|
# "shell_sh": "",
|
|
# "shell_bash": "",
|
|
# "shell_zsh": "",
|
|
# "shell_fish": "",
|
|
# "shell_bash": "",
|
|
# "source_output": False, # True for shell commands by default !
|
|
}
|
|
|
|
# Overrides
|
|
# ---------------
|
|
|
|
def init(self):
|
|
"Transform short form into long form"
|
|
self.service = self.parent
|
|
|
|
# def payload_transform(self, name, kwargs=None):
|
|
# "Transform short form into long form"
|
|
# self.service = self.parent
|
|
|
|
# payload = self._payload
|
|
# if not isinstance(payload, dict):
|
|
# payload = {"cmd": payload}
|
|
# self._payload = payload
|
|
|
|
def cmd_name(self):
|
|
return self.name.replace("_", " ")
|
|
|
|
|
|
class Service(DictItem):
|
|
"Hold provider services"
|
|
|
|
default_attrs = {
|
|
"desc": "Service without description",
|
|
"enabled": False,
|
|
"input": {},
|
|
"resources_lookup": [],
|
|
"required_services": [],
|
|
"commands": {},
|
|
# "resolved_resources": [],
|
|
"resources_matches": 1,
|
|
}
|
|
|
|
# Overrides
|
|
# ---------------
|
|
|
|
def prepare(self):
|
|
self.catalog = self.parent.catalog
|
|
|
|
def init(self):
|
|
ret = {}
|
|
for cmd_name, cmd in self.commands.items():
|
|
ret[cmd_name] = ServiceCommand(cmd_name, cmd, parent=self)
|
|
self.commands = ret
|
|
|
|
# def require_resolved_deps(func):
|
|
# "Decorator that ensure resource resolution is called before method call"
|
|
|
|
# def wrap(self, *args, **kwargs):
|
|
# "Wrapper that ensure dependencies are resolved"
|
|
|
|
# if not self._resolved:
|
|
# self.resolve_deps(skip_missing=True)
|
|
# return func(self, *args, **kwargs)
|
|
|
|
# return wrap
|
|
|
|
# Catalog dependent is built !
|
|
# ---------------
|
|
def resolve_resources(self, catalog):
|
|
"Resolve required resources"
|
|
|
|
# catalog.res_inst,
|
|
# catalog.context
|
|
|
|
self._catalog = catalog
|
|
|
|
requests = self.resources_lookup
|
|
curr_vars = catalog.context.get_vars()
|
|
ret = []
|
|
for pattern in requests:
|
|
req = pattern.format(**curr_vars)
|
|
|
|
if req in catalog.res_inst:
|
|
resource = catalog.res_inst[req]
|
|
|
|
tmp = {
|
|
"resource": resource,
|
|
"vars": resource.resolve_inputs(),
|
|
}
|
|
ret.append(tmp)
|
|
|
|
self.resolved_resources_names = [x["resource"].name for x in ret]
|
|
self._resolved_resources = ret
|
|
|
|
def _prepare_runtime(self):
|
|
if not hasattr(self, "_resolved_resources"):
|
|
assert (
|
|
self._resolved_resources
|
|
), f"Please run {self}.resolve_resources() first"
|
|
|
|
print("Process each item")
|
|
processed_vars = []
|
|
|
|
# Deduplicate common resources
|
|
for box in self._resolved_resources:
|
|
res = box["resource"]
|
|
name = res.name
|
|
curr_vars = res.resolve_inputs()
|
|
|
|
# WIPPPP
|
|
expand_inputs(curr_vars)
|
|
|
|
var_matches = [x for x in processed_vars if x.value == curr_vars]
|
|
if len(var_matches) > 0:
|
|
print(f" Skip duplicate resource vars {res.name}")
|
|
continue
|
|
|
|
# print (f" Process: {res.name}")
|
|
processed_vars.append(KeyValueExtra(name, curr_vars, res))
|
|
|
|
# print("PROCESSEDS")
|
|
# pprint(processed_vars)
|
|
|
|
return processed_vars
|
|
|
|
# Workflow
|
|
# ---------------
|
|
|
|
def run_cmd(self, command=None):
|
|
processed_vars = self._prepare_runtime()
|
|
|
|
cmd = self.commands.get(command, None)
|
|
if not cmd:
|
|
choices = (
|
|
",".join(self.commands.keys())
|
|
or "No available commands for this service"
|
|
)
|
|
raise IamException(
|
|
f"Unknown command: {command}, please choose one of: {choices}"
|
|
)
|
|
|
|
svc_input = self.input
|
|
|
|
# Run on each requested resources
|
|
max_items = self.resources_matches
|
|
for res in processed_vars[0:max_items]:
|
|
print("process item:", res.key)
|
|
|
|
# if command:
|
|
# pprint (res.value)
|
|
# # pprint (self.__dict__)
|
|
|
|
# # assert False
|
|
# pprint (self._catalog.context.get_vars())
|
|
|
|
env_var = {}
|
|
env_var.update(svc_input)
|
|
env_var.update(res.value) # == res.resolve_inputs()
|
|
env_var.update(self._catalog.context.get_vars())
|
|
|
|
# pprint (env_var)
|
|
|
|
try:
|
|
out = cmd.format(**env_var)
|
|
except KeyError as err:
|
|
msg = f"Missing variable: {err} for service: {res.key}"
|
|
logger.warning(msg)
|
|
out = msg
|
|
# raise IamException(msg)
|
|
|
|
print("\n" + "-- %<--" * 6)
|
|
print(out)
|
|
print("-- %<--" * 6)
|
|
|
|
# def _list_cmds_shell(self):
|
|
# "Li"
|
|
|
|
# def _list_cmds(self):
|
|
|
|
def get_cmds(self):
|
|
"Get all services commands objects"
|
|
|
|
return [
|
|
cmd for name, cmd in self.commands.items() if not name.startswith("shell")
|
|
]
|
|
|
|
def list_cmds(self):
|
|
"List all services commands"
|
|
|
|
prefix = self.name.split(".")[-1]
|
|
|
|
shell_prefix = "shell_"
|
|
ret2 = {
|
|
"shell": {},
|
|
"cmds": {},
|
|
}
|
|
|
|
for cmd_name, conf in self.commands.items():
|
|
target = ret2["cmds"]
|
|
|
|
if cmd_name.startswith(shell_prefix):
|
|
target = ret2["shell"]
|
|
# cmd_name = cmd_name[len(shell_prefix):]
|
|
name = f"{cmd_name}_{prefix}"
|
|
else:
|
|
name = cmd_name.replace("_", " ")
|
|
|
|
target[name] = conf.desc
|
|
|
|
return ret2
|
|
|
|
def get_linked_resource(self):
|
|
"Return linked resource or None"
|
|
|
|
catalog = self.catalog
|
|
res_name = f"service.{self.name}:{catalog.ident.name}"
|
|
ret = catalog.resources.get(res_name, None)
|
|
logger.debug(f"Linked resource for service {self.name}: {ret}")
|
|
return ret
|
|
|
|
def is_active(self):
|
|
return True if self.get_linked_resource() is not None else False
|
|
|
|
|
|
class Services(DictCtrl):
|
|
"Simple wrapper class to manage services"
|
|
|
|
items_class = Service
|
|
|
|
RESERVED_CMD_PREFIX = ["kind", "res", "svc", "shell", "run"]
|
|
|
|
def prepare(self):
|
|
self.catalog = self.parent
|
|
|
|
def get_svc_command(self, cmd):
|
|
"Return the command to be run"
|
|
|
|
# Prepare context
|
|
cmd_parts = cmd
|
|
if isinstance(cmd, str):
|
|
cmd_parts = cmd.split(" ")
|
|
cmd_req = " ".join(cmd_parts)
|
|
|
|
# Retrieve command list
|
|
cmds = self.list_cmds()
|
|
cmd_names = [cmd.name for cmd in cmds]
|
|
|
|
# Find best matching command
|
|
cmd_split_idx = None
|
|
cmd = None
|
|
curr = None
|
|
for index, part in enumerate(cmd_parts):
|
|
curr = f"{curr} {part}" if curr is not None else part
|
|
if curr in cmd_names:
|
|
cmd_idx = cmd_names.index(curr)
|
|
cmd = cmds[cmd_idx]
|
|
cmd_split_idx = index + 1
|
|
break
|
|
|
|
# Validate result
|
|
if not cmd:
|
|
_choices = ",".join(cmd_names)
|
|
_msg = f"No such services command named: {cmd_req}, please choose one of: {_choices}"
|
|
raise error.UnknownServiceCommand(_msg)
|
|
|
|
args = cmd_parts[cmd_split_idx:]
|
|
|
|
return cmd, args
|
|
|
|
def list_cmds(self):
|
|
"List all services commands"
|
|
|
|
ret = []
|
|
for name, service in self.items():
|
|
cmds = service.get_cmds()
|
|
ret.extend(cmds)
|
|
|
|
# Check for invalid configs
|
|
conf = []
|
|
for cmd in ret:
|
|
prefix = cmd.name.split(" ")[0]
|
|
if prefix in self.RESERVED_CMD_PREFIX:
|
|
_msg = f"Forbidden prefix! {cmd}"
|
|
raise Exception(_msg)
|
|
conf.append(cmd.name)
|
|
dump = uniq(conf)
|
|
|
|
if conf != dump:
|
|
_msg = f"Duplicates values! {conf}"
|
|
raise Exception(_msg)
|
|
|
|
return ret
|
|
|
|
def get_linked_resources(self):
|
|
"""
|
|
Like get method, but only grab enabled services
|
|
Return a list of an object containing service and its
|
|
matched resource
|
|
"""
|
|
|
|
enabled_services = {}
|
|
for name, service in self.items():
|
|
res = service.get_linked_resource()
|
|
if res:
|
|
enabled_services[service.name] = SimpleNamespace(
|
|
svc=service,
|
|
res=res, # order=None
|
|
)
|
|
|
|
return enabled_services
|
|
|
|
def get_loading_order(self, reverse=False):
|
|
"Process resolution order"
|
|
|
|
# Filter out disabled services
|
|
enabled_services = self.get_linked_resources()
|
|
|
|
# Process resolution order
|
|
queue_todo = list(enabled_services.keys())
|
|
queue_done = []
|
|
loop_index = 0
|
|
while len(queue_todo) > 0:
|
|
loop_index = loop_index + 1
|
|
_queue_todo = list(queue_todo)
|
|
|
|
for svc_name in queue_todo:
|
|
service = enabled_services[svc_name].svc
|
|
resource = enabled_services[svc_name].res
|
|
|
|
# Check services requirements
|
|
required_services = list(set(service.required_services))
|
|
# if not svc_name.startswith("service.id:"):
|
|
if svc_name != "id":
|
|
required_services.insert(0, f"id")
|
|
|
|
missing = False
|
|
_missing = []
|
|
for req in required_services:
|
|
if not req in queue_done:
|
|
missing = True
|
|
_missing.append(req)
|
|
|
|
if not missing:
|
|
# Save result
|
|
queue_todo.remove(svc_name)
|
|
queue_done.append(svc_name)
|
|
|
|
if queue_todo == _queue_todo:
|
|
print("Loop Index ERROR", loop_index)
|
|
raise IamException(f"Loop detexted ! {loop_index}")
|
|
|
|
if reverse:
|
|
queue_done.reverse()
|
|
|
|
for index, svc_name in enumerate(queue_done):
|
|
enabled_services[svc_name].order = index
|
|
|
|
# Return list of ordered service names, and other useful data
|
|
return queue_done, enabled_services
|
|
|
|
|
|
# Config classes: ResourcesKinds
|
|
# ================
|
|
|
|
ResolvedRes = namedtuple("ResolvedRes", "name inputs")
|
|
|
|
|
|
class ResourceKind(DictItem):
|
|
"Hold resource kinds"
|
|
|
|
default_attrs = {
|
|
"desc": "ResourceKind without description",
|
|
"input": {},
|
|
"needs": [],
|
|
"remap": {},
|
|
}
|
|
|
|
|
|
# def config_validate(self):
|
|
# if ":" in self.name:
|
|
# raise IamException(
|
|
# "Colons are not accepted for catalog resources", self.__dict__
|
|
# )
|
|
|
|
|
|
class ResourcesKinds(DictCtrl):
|
|
"Simple wrapper class to manage resources kinds"
|
|
|
|
items_class = ResourceKind
|
|
|
|
# def prepare(self):
|
|
# self.catalog = self.parent
|
|
|
|
|
|
# Config classes: Resources
|
|
# ================
|
|
|
|
|
|
class Resource(DictItem):
|
|
"Create a new resource"
|
|
|
|
default_attrs = {
|
|
"desc": "",
|
|
"input": {},
|
|
"uses": [], # Optional
|
|
"needs": [], # Required dependencies AND
|
|
"loop_limit": 1,
|
|
"loop": [],
|
|
"_ctx_vars": {},
|
|
}
|
|
|
|
# Overrides
|
|
# ---------------
|
|
|
|
def prepare(self):
|
|
self.catalog = self.parent.catalog
|
|
|
|
def config_validate(self):
|
|
# Fetch info from controller
|
|
resources_kind = self.parent.available_resources_kinds
|
|
loaded_resources = self.parent.loaded_resources
|
|
|
|
# Check overrides
|
|
if self.name in loaded_resources:
|
|
_msg = f"User resource overrides: {self.name}"
|
|
logger.debug(_msg)
|
|
|
|
# Check for the kind
|
|
kind = self.get_kind()
|
|
if not kind in resources_kind:
|
|
choices = ", ".join(resources_kind.keys())
|
|
_msg = (
|
|
f"Unknown resource kind: {self.name}, please choose one of: {choices}"
|
|
)
|
|
raise error.UnknownResourceKind(_msg)
|
|
|
|
def init(self):
|
|
"Init each resources"
|
|
|
|
self.name_raw = self.name
|
|
ctx_vars = self.parent.ctx_vars
|
|
|
|
self.name = format_render(self.name, vars=ctx_vars)
|
|
# self.name = format_render(self.name, vars=self.catalog.context.get_vars())
|
|
|
|
# Append common base dependency on all resources
|
|
if len(self.uses) == 0:
|
|
self.uses.insert(0, "account:{user}")
|
|
# self.uses = list(set(self.uses))
|
|
|
|
self.uses = uniq(self.uses)
|
|
|
|
# Resolution management vars
|
|
self._resolved = False
|
|
self.resources_deps = None
|
|
self.resources_missing = None
|
|
|
|
# Helpers
|
|
# ---------------
|
|
|
|
def _parse_name(self):
|
|
ret = self.name.split(":", 2)
|
|
|
|
if len(ret) == 2:
|
|
return ret[0], ret[1]
|
|
|
|
# Raise error if name is invalid
|
|
_msg = f"Invalid resource name: {self.name}, missing :<name>"
|
|
raise IamException(_msg)
|
|
|
|
def get_kind(self):
|
|
"Return resource kind"
|
|
ret, _ = self._parse_name()
|
|
return ret
|
|
|
|
def get_name(self):
|
|
"Return resource instance name"
|
|
|
|
_, ret = self._parse_name()
|
|
return ret
|
|
|
|
# Methods
|
|
# ---------------
|
|
|
|
def require_resolved_deps(func):
|
|
"Decorator that ensure resource resolution is called before method call"
|
|
|
|
def wrap(self, *args, **kwargs):
|
|
"Wrapper that ensure dependencies are resolved"
|
|
|
|
if not self._resolved:
|
|
self.resolve_deps(skip_missing=True)
|
|
return func(self, *args, **kwargs)
|
|
|
|
return wrap
|
|
|
|
def resolve_deps(self, vars=None, add_self=True, cache=True, skip_missing=False):
|
|
"Recursive uses dependency resolver"
|
|
|
|
if cache and self.resources_deps is not None:
|
|
return self.resources_deps
|
|
|
|
# try:
|
|
# ret, _missing = self._resolve_deps(vars=vars, add_self=add_self)
|
|
# except error.UnresolvedResourceDependencies:
|
|
# return None
|
|
|
|
dependencies, missings = self._resolve_deps(vars=vars, add_self=add_self)
|
|
|
|
self.resources_missing = missings
|
|
self.resources_deps = dependencies
|
|
self._is_active = True if len(missings) == 0 else False
|
|
|
|
# Raise error on missing deps
|
|
if not skip_missing and len(missings) > 0:
|
|
pprint(self.catalog.resources.get())
|
|
_msg = f"Missing deps for {self.name}: {missings}"
|
|
raise error.UnresolvedResourceDependencies(_msg)
|
|
|
|
if cache:
|
|
self._resolved_deps = dependencies
|
|
|
|
self._resolved = True
|
|
|
|
return dependencies
|
|
|
|
def _resolve_deps(self, vars=None, add_self=True, _results=None, _missings=None):
|
|
"Recursive dependency helper"
|
|
|
|
# Recurisive control
|
|
_missings = _missings or []
|
|
_results = _results or []
|
|
if self in _results:
|
|
return _results
|
|
|
|
# Get root context
|
|
# ctx_vars = vars or self.catalog.context.get_vars()
|
|
catalog = self.catalog
|
|
ctx_vars = catalog.context.get_vars()
|
|
|
|
# Check each dependency
|
|
uses = self.uses
|
|
for dep_name in uses:
|
|
# Parse resource name
|
|
if ctx_vars:
|
|
dep_name = format_render(dep_name, ctx_vars)
|
|
|
|
if dep_name == self.name:
|
|
continue
|
|
|
|
if dep_name in _missings:
|
|
_missings.delete(dep_name)
|
|
|
|
# Load child or quit if missing
|
|
child = catalog.resources.find_closest(dep_name)
|
|
if not child:
|
|
_missings.append(dep_name)
|
|
# _missings.append((self.name, dep_name, ))
|
|
|
|
# _msg = f"Undeclared resource: {dep_name}"
|
|
# raise error.UnresolvedResourceDependencies(_msg)
|
|
continue
|
|
|
|
# Avoid already processed resources
|
|
if child and child in _results:
|
|
continue
|
|
|
|
_results.append(child)
|
|
child._resolve_deps(vars=vars, _results=_results)
|
|
|
|
if add_self:
|
|
_results.append(self)
|
|
|
|
return _results, _missings
|
|
|
|
# Resolved methods
|
|
# ==================
|
|
|
|
@require_resolved_deps
|
|
def is_active(self):
|
|
"Return True if this resource is active"
|
|
return self._is_active
|
|
|
|
# return True if len(self.resources_missing) == 0 else False
|
|
|
|
@require_resolved_deps
|
|
def resolve_inputs(self, vars=None):
|
|
"Resolve uses dependencies recursively"
|
|
|
|
# WIPPPP, split this function in 2 !!!
|
|
# self.catalog.
|
|
|
|
# deps = self.resolve_deps()
|
|
deps = self.resources_deps
|
|
|
|
output = {}
|
|
for res in deps:
|
|
output.update(res.input)
|
|
|
|
return output
|
|
|
|
def loop_extend(self):
|
|
"Extend loops from catalog"
|
|
|
|
ctx_vars = self.catalog.context.get_vars()
|
|
loops = self.loop
|
|
loop_limit = self.loop_limit
|
|
|
|
matches = []
|
|
stop = False
|
|
for loop_search in loops:
|
|
if len(matches) >= loop_limit:
|
|
stop = True
|
|
|
|
if not stop:
|
|
loop_search = loop_search.format(**ctx_vars)
|
|
res = self.catalog.resources.get(loop_search, skip_missing=True)
|
|
if res:
|
|
matches.append(res)
|
|
|
|
return matches
|
|
|
|
|
|
class Resources(DictCtrl):
|
|
"Simple wrapper class to manage resources"
|
|
|
|
items_class = Resource
|
|
|
|
# Overrides
|
|
# ---------------
|
|
|
|
def prepare(self):
|
|
# Save Catalog
|
|
self.catalog = self.parent
|
|
|
|
self.ctx_vars = self.catalog.context.get_vars()
|
|
|
|
self.available_resources_kinds = self.catalog.resources_kind
|
|
self.loaded_resources = []
|
|
|
|
# pprint (self.__dict__)
|
|
# print ("INIT RES CATALOG")
|
|
|
|
def find_closest(self, dep_name):
|
|
"Find closest match on type"
|
|
assert ":" in dep_name, f"We have unresolved query here: {dep_name}"
|
|
|
|
catalog = self.catalog
|
|
|
|
# Direct access
|
|
child = catalog.resources.get(dep_name, None)
|
|
if child:
|
|
return child
|
|
|
|
# Loop over resources
|
|
target = dep_name.split(":")[0]
|
|
scope = dep_name.split(":")[1]
|
|
|
|
match = None
|
|
while target:
|
|
# Query other resources
|
|
# query_name = f"{target}:{scope}"
|
|
matches = catalog.resources.select("startswith", target)
|
|
matches = {
|
|
key: val for key, val in matches.items() if key.endswith(f":{scope}")
|
|
}
|
|
|
|
# Check closest matches
|
|
if len(matches) == 1:
|
|
match = list(matches.values())[0]
|
|
# print ("Longer MATCH", match.name)
|
|
logger.info(
|
|
f"Closest resource of {dep_name} was mapped to: {match.name}"
|
|
)
|
|
break
|
|
elif len(matches) > 1:
|
|
logger.debug(
|
|
f"More than one closest resources for {dep_name}: {matches}"
|
|
)
|
|
|
|
# raise Exception(f"Bug here, too many matches: {matches}")
|
|
|
|
# Reduce again the common lookup pattern
|
|
if "." in target:
|
|
target = ".".join(target.split(".")[:-1])
|
|
else:
|
|
break
|
|
|
|
# print ("QUERY", target, scope)
|
|
|
|
return match
|
|
# view = scoped_ident(ident)
|
|
|
|
|
|
# Catalog
|
|
# ============================================================
|
|
|
|
|
|
# Context classes
|
|
# ================
|
|
|
|
|
|
class Context(DictItem):
|
|
"Class that hold a context"
|
|
|
|
default_attrs = {
|
|
"ident": None,
|
|
}
|
|
|
|
# Overrides
|
|
# ---------------
|
|
def config_validate(self):
|
|
assert isinstance(self.ident, Ident), f"Gotr: {self.ident}"
|
|
|
|
def init(self):
|
|
self.catalog = self.parent
|
|
|
|
root_dir = self.catalog.app.config_dir
|
|
self._vars = {
|
|
"ident": self.ident.name,
|
|
"user": self.ident.name,
|
|
"config_dir": root_dir,
|
|
"scripts_dir": os.path.join(root_dir, "scripts"),
|
|
"bin_dir": os.path.join(root_dir, "bin"),
|
|
}
|
|
|
|
def get_vars(self):
|
|
"Return all vars context"
|
|
|
|
return dict(self._vars)
|
|
|
|
|
|
# Catalog classes
|
|
# ================
|
|
|
|
|
|
class Catalog:
|
|
"Manage catalog resources"
|
|
|
|
def __init__(self, app, ident):
|
|
# Prepare catalog
|
|
self.app = app
|
|
self.ident = ident
|
|
|
|
# Prepare context
|
|
ctx_conf = {
|
|
"ident": ident,
|
|
}
|
|
self.context = Context("current_context", ctx_conf, parent=self)
|
|
|
|
self._prepare_catalog()
|
|
|
|
# Catalog building classes
|
|
# ================
|
|
|
|
def _merge_inst_configs(self, merge=True):
|
|
plugins_confs = self.app.providers.get_resource_configs()
|
|
user_confs = self.ident.get_resource_configs()
|
|
|
|
final_config = {}
|
|
|
|
# Remap config names
|
|
for source in [plugins_confs, user_confs]:
|
|
# source = source or {}
|
|
for name, conf in source.items():
|
|
# Check name
|
|
if not ":" in name:
|
|
ident_name = f"{name}:{self.ident.name}"
|
|
# print (f"Renaming resource '{name}' to '{ident_name}'")
|
|
name = ident_name
|
|
|
|
# Check config
|
|
existing = final_config.get(name, None)
|
|
if existing:
|
|
# print (f"Overrides: {name}")
|
|
|
|
if merge:
|
|
new_conf = dict(existing)
|
|
new_conf.update(conf)
|
|
conf = new_conf
|
|
|
|
final_config[name] = conf
|
|
|
|
return final_config
|
|
|
|
def _prepare_catalog(self):
|
|
"Prepare catalog resources configs"
|
|
|
|
# Get resources from providers and user
|
|
providers = self.app.providers
|
|
ident = self.ident
|
|
|
|
# Build kind catalog
|
|
res_kind_configs = providers.get_resource_kinds()
|
|
self.resources_kind = ResourcesKinds(
|
|
"CatalogResourcesKinds", payload=res_kind_configs, parent=self
|
|
)
|
|
|
|
# Build resources catalog
|
|
res_inst_configs = self._merge_inst_configs()
|
|
self.resources = Resources(
|
|
"CatalogResources", payload=res_inst_configs, parent=self
|
|
)
|
|
self._resources_config = res_inst_configs
|
|
|
|
# Prepare services catalog
|
|
services_confs = providers.get_services_configs()
|
|
self.services = Services("CatalogServices", payload=services_confs, parent=self)
|
|
|
|
def dump(self):
|
|
print("Catalog settings")
|
|
print("=" * 16)
|
|
|
|
# pprint (self.__dict__)
|
|
# return
|
|
|
|
print("\n=== Catalog resources kinds:")
|
|
pprint(self.resources_kind)
|
|
|
|
print("\n=== Catalog resources configs:")
|
|
pprint(self._resources_config)
|
|
|
|
print("\n=== Catalog resources instances:")
|
|
pprint(self.resources)
|
|
|
|
print("\n=== Catalog services instances:")
|
|
# for name, srv in self.services.items():
|
|
# pprint(srv.dump_item())
|
|
pprint({name: srv.dump_item() for name, srv in self.services.items()})
|
|
|
|
# Catalog interfaces
|
|
# ================
|
|
|
|
# Catalog helpers
|
|
# ================
|
|
|
|
# def resolve_service_order(self, reverse=False):
|
|
# "Resolve service order"
|
|
|
|
# return self.services.get_loading_order(reverse=reverse)
|
|
|
|
# Shell helpers
|
|
# ================
|
|
|
|
def shell_enable(self, run_start=True):
|
|
"Enable shell"
|
|
|
|
actions = ["shell_enable"]
|
|
if run_start:
|
|
actions.insert(0, "shell_start")
|
|
# logger.warning("Shell Start")
|
|
# logger.warning("Shell Enable")
|
|
|
|
return self._shell_action(actions)
|
|
|
|
def shell_disable(self, run_stop=False):
|
|
"Disable shell"
|
|
|
|
actions = ["shell_disable"]
|
|
if run_stop:
|
|
actions.insert(0, "shell_stop")
|
|
# cli_logger.info("Shell Stop")
|
|
# cli_logger.info("Shell Disable")
|
|
|
|
return self._shell_action(actions)
|
|
|
|
def _shell_action(self, action_names, reverse=False):
|
|
"Run command order"
|
|
|
|
ident = self.ident
|
|
vars = self.context.get_vars()
|
|
|
|
# Fetch execution order
|
|
order, services = self.services.get_loading_order(reverse=reverse)
|
|
|
|
# Prepare context
|
|
log_action_name = "Enable"
|
|
if reverse:
|
|
log_action_name = "Disable"
|
|
cli_logger.info(f"Identity {ident.name} action: {','.join(action_names)}")
|
|
|
|
# Execute on each plugins commands
|
|
output_code = []
|
|
for srv_name in order:
|
|
service = services[srv_name].svc
|
|
res = services[srv_name].res
|
|
|
|
# Load service command
|
|
for action_name in action_names:
|
|
command = service.commands.get(action_name, None)
|
|
if not command:
|
|
continue
|
|
|
|
# Build loop with at least ONE item
|
|
cmd_shell = command.shell
|
|
if not cmd_shell:
|
|
continue
|
|
|
|
# Create context var dict
|
|
ctx_vars = dict()
|
|
ctx_vars.update(service.input)
|
|
ctx_vars.update(vars)
|
|
ctx_vars.update(res.resolve_inputs(vars=ctx_vars))
|
|
|
|
loops = res.loop_extend() or [res]
|
|
res_vars = [x.resolve_inputs(vars=ctx_vars) for x in loops]
|
|
|
|
ctx_vars.update(
|
|
{
|
|
"item": res_vars[0],
|
|
"loop": res_vars,
|
|
}
|
|
)
|
|
|
|
logger.debug(f"{log_action_name} service: {res.name}")
|
|
|
|
# pprint (ctx_vars)
|
|
cmd = jinja_render(cmd_shell, ctx_vars)
|
|
output_code.append(
|
|
f"# Loading: {action_name} {res.name} ({service.name})"
|
|
)
|
|
output_code.append(f"# =====================")
|
|
output_code.append(cmd)
|
|
output_code.append("\n")
|
|
|
|
return "\n".join(output_code)
|
|
|
|
def run_svc_cmd(self, cmd):
|
|
"Run a command against the services"
|
|
|
|
cmd, args = self.services.get_svc_command(cmd)
|
|
|
|
# pprint (cmd.cmd)
|
|
# pprint (args)
|
|
|
|
service = cmd.service
|
|
|
|
# pprint (service)
|
|
# pprint (service.__dict__)
|
|
# pprint (dir(service))
|
|
res = service.get_linked_resource()
|
|
# pprint (res)
|
|
|
|
vars = self.context.get_vars()
|
|
|
|
ctx_vars = dict()
|
|
ctx_vars.update(vars)
|
|
ctx_vars.update(service.inputs)
|
|
|
|
# ctx_vars.update(res.resolve_inputs(vars=ctx_vars))
|
|
|
|
# loops = res.loop_extend() or [res]
|
|
# res_vars = [x.resolve_inputs(vars=ctx_vars) for x in loops]
|
|
|
|
# ctx_vars.update(
|
|
# {
|
|
# "item": res_vars[0],
|
|
# "loop": res_vars,
|
|
# }
|
|
# )
|
|
|
|
# pprint (ctx_vars)
|
|
|
|
new_env = dict(os.environ)
|
|
new_env.update(ctx_vars)
|
|
# pprint(new_env)
|
|
|
|
if cmd.cmd and cmd.shell:
|
|
logger.warning(f"Duplicate cmd and shell for {service.name}")
|
|
|
|
out = None
|
|
|
|
if cmd.shell:
|
|
mode = "shell"
|
|
payload = cmd.shell
|
|
|
|
# Scan for missing vars !!!
|
|
tmp = jinja_template_vars(payload)
|
|
prompt_vars = []
|
|
for var_name in tmp:
|
|
if var_name not in ctx_vars:
|
|
prompt_vars.append(var_name)
|
|
else:
|
|
var_value = ctx_vars[var_name]
|
|
if empty(var_value):
|
|
prompt_vars.append(var_name)
|
|
|
|
# Ask for missing vars
|
|
if len(prompt_vars) > 0:
|
|
# print ("MISSING VARS")
|
|
# pprint (prompt_vars)
|
|
|
|
answered_items = {}
|
|
for missed in prompt_vars:
|
|
default = ctx_vars.get(missed, None)
|
|
result = click.prompt(f"Select value for {missed}", default=default)
|
|
answered_items[missed] = result
|
|
|
|
ctx_vars.update(answered_items)
|
|
|
|
real_cmd = jinja_render(payload, ctx_vars)
|
|
|
|
# print ("RUN SHELL")
|
|
builtins = sh.bash.bake("-c")
|
|
out = builtins(real_cmd, _fg=True, _env=new_env)
|
|
|
|
# print (out)
|
|
|
|
elif cmd.cmd:
|
|
mode = "cmd"
|
|
payload = cmd.cmd
|
|
real_cmd = jinja_render(payload, ctx_vars)
|
|
|
|
cmd_parts = real_cmd.split(" ", 1)
|
|
sh_cmd = cmd_parts[0]
|
|
sh_args = cmd_parts[1] if len(cmd_parts) > 0 else []
|
|
|
|
# print ("Prepare", sh_cmd, " ||| ", sh_args)
|
|
|
|
# proc = sh.bake(sh_cmd)
|
|
# sh(sh_cmd, *sh_args, _fg=True)
|
|
|
|
cmd = sh.Command(sh_cmd)
|
|
if sh_args:
|
|
out = cmd(sh_args, _fg=True, _env=new_env)
|
|
else:
|
|
out = cmd(_fg=True, _env=new_env)
|
|
|
|
# print (out)
|
|
|
|
else:
|
|
raise Exception("MIssing cmd or shell in config !")
|
|
|
|
return out
|
|
|
|
# print ("RUN CMD", mode, "\n\n\n====\n", real_cmd)
|