def get(self):
query = filter_query(Server, request.args)
return [s.to_json(add_gates=check_param_in_uri('gates'),
human=check_param_in_uri('human'),
no_delete=True,
add_ignore=True) for s in
query.all()]
def get(self):
query = filter_query(OrchExecution, request.args)
return [
oe.to_json(human=check_param_in_uri('human'),
add_step_exec=check_param_in_uri('steps'),
split_lines=True)
for oe in query.order_by(OrchExecution.start_time).all()
]
def get(self):
if check_param_in_uri('scopes'):
return [r[0] for r in
db.session.query(distinct(Vault.scope)).filter_by(user_id=get_jwt_identity()).filter_by(
deleted=0).all()]
elif check_param_in_uri('vars'):
query = db.session.query(distinct(Vault.name)).filter_by(user_id=get_jwt_identity()).filter_by(deleted=0)
if 'scope' in request.args:
query = query.filter_by(scope=request.args.get('scope'))
return [r[0] for r in query.order_by(Vault.name)]
else:
query = filter_query(Vault, request.args, exclude=["user_id", "value"]).filter_by(
user_id=get_jwt_identity())
return [vault.to_json(no_delete=True, human=check_param_in_uri('human')) for vault in query.all()]
def get(self, file_id):
query = filter_query(FileServerAssociation,
request.args).filter_by(file_id=file_id)
return [
fsa.to_json(human=check_param_in_uri('human'), no_delete=True)
for fsa in query.all()
]
def get(self, execution_id):
query = filter_query(StepExecution, request.args)
return [
oe.to_json(human=check_param_in_uri('human'))
for oe in query.filter_by(orch_execution_id=execution_id).order_by(
StepExecution.start_time).all()
]
def healthcheck():
if request.method == 'POST' and isinstance(g.source, Server):
data = request.get_json()
try:
heartbeat = dt.datetime.strptime(data['heartbeat'],
defaults.DATETIME_FORMAT)
except:
raise errors.InvalidDateFormat(data['heartbeat'],
defaults.DATETIME_FORMAT)
current_app.dm.cluster_manager.put(data['me'], heartbeat)
catalog_ver = Catalog.max_catalog()
data = {
"version":
dimensigon.__version__,
"catalog_version":
catalog_ver.strftime(defaults.DATEMARK_FORMAT)
if catalog_ver else None,
"services": [],
}
if not check_param_in_uri('human'):
server = {'id': str(g.server.id), 'name': g.server.name}
neighbours = [{
'id': str(s.id),
'name': s.name
} for s in Server.get_neighbours()]
cluster = {
'alive': current_app.dm.cluster_manager.get_alive(),
'in_coma': current_app.dm.cluster_manager.get_zombies()
}
else:
server = g.server.name
neighbours = sorted([s.name for s in Server.get_neighbours()])
cluster = {
'alive':
sorted([
getattr(Server.query.get(i), 'name', i)
for i in current_app.dm.cluster_manager.get_alive()
]),
'in_coma':
sorted([
getattr(Server.query.get(i), 'name', i)
for i in current_app.dm.cluster_manager.get_zombies()
])
}
data.update(server=server,
neighbours=neighbours,
cluster=cluster,
now=get_now().strftime(defaults.DATETIME_FORMAT))
return data
def get(self):
query = filter_query(Orchestration,
request.args).order_by(Orchestration.created_at)
return [
o.to_json(add_target=check_param_in_uri('target'),
add_params=check_param_in_uri('vars'),
add_steps=check_param_in_uri('steps'),
add_action=check_param_in_uri('action'),
split_lines=check_param_in_uri('split_lines'),
add_schema=check_param_in_uri('schema'))
for o in query.all()
]
def routes():
if request.method == 'GET':
route_table = []
for route in Route.query.join(Server.route).order_by(
Server.name).filter(Server.deleted == False).all():
route_table.append(
route.to_json(human=check_param_in_uri('human')))
data = {'route_list': route_table}
data.update(server=dict(name=g.server.name, id=str(g.server.id)))
return data
elif request.method == 'POST':
data = request.get_json()
current_app.dm.route_manager.refresh_table(
discover_new_neighbours=data.get('discover_new_neighbours', False),
check_current_neighbours=data.get('check_current_neighbours',
False),
max_num_discovery=data.get('max_num_discovery', 5))
return {}, 204
elif request.method == 'PATCH':
current_app.dm.route_manager.new_routes(request.get_json())
return {}, 204
def get(self, server_id):
return Server.query.get_or_raise(server_id).to_json(add_gates=check_param_in_uri('gates'),
human=check_param_in_uri('human'),
no_delete=True,
add_ignore=True)
def get(self):
query = filter_query(Log, request.args)
return [log.to_json(human=check_param_in_uri('human'), delete_data=False) for log in query.all()]
def get(self, execution_id):
return OrchExecution.query.get_or_raise(execution_id).to_json(
add_step_exec=check_param_in_uri('steps'),
human=check_param_in_uri('human'),
split_lines=True)
def get(self, orchestration_id):
return Orchestration.query.get_or_raise(orchestration_id).to_json(
check_param_in_uri('target'),
add_schema=check_param_in_uri('schema'),
split_lines=check_param_in_uri('split_lines'))
def get(self):
query = filter_query(Software, request.args)
return [
soft.to_json(servers=check_param_in_uri('servers'),
no_delete=False) for soft in query.all()
]
def get(self, execution_id):
return StepExecution.query.get_or_raise(execution_id).to_json(
human=check_param_in_uri('human'), split_lines=True)
def get(self, file_id):
return File.query.get_or_raise(file_id).to_json(human=check_param_in_uri('human'), delete_data=False,
destinations=True)
def launch_command():
data = request.get_json()
server_list = []
if 'target' in data:
not_found = []
servers = Server.query.all()
if data['target'] == 'all':
server_list = servers
elif is_iterable_not_string(data['target']):
for vv in data['target']:
sl = search(vv, servers)
if len(sl) == 0:
not_found.append(vv)
else:
server_list.extend(sl)
else:
sl = search(data['target'], servers)
if len(sl) == 0:
not_found.append(data['target'])
else:
server_list.extend(sl)
if not_found:
return {
'error':
"Following granules or ids did not match to any server: " +
', '.join(not_found)
}, 404
else:
server_list.append(g.server)
if re.search(r'rm\s+((-\w+|--[-=\w]*)\s+)*(-\w*[rR]\w*|--recursive)',
data['command']):
return {'error': 'rm with recursion is not allowed'}, 403
data.pop('target', None)
start = None
username = getattr(User.query.get(get_jwt_identity()), 'name', None)
if not username:
raise errors.EntityNotFound('User', get_jwt_identity())
cmd = wrap_sudo(username, data['command'])
if g.server in server_list:
start = time.time()
server_list.pop(server_list.index(g.server))
proc = subprocess.Popen(
cmd,
stdin=subprocess.PIPE if data.get('input', None) else None,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE,
shell=True,
close_fds=True,
encoding='utf-8')
resp_data = {}
if check_param_in_uri("human"):
attr = 'name'
else:
attr = 'id'
if server_list:
resp: t.List[ntwrk.Response] = asyncio.run(
ntwrk.parallel_requests(server_list,
method='POST',
view_or_url='api_1_0.launch_command',
json=data))
for s, r in zip(server_list, resp):
key = getattr(s, attr, s.id)
if r.ok:
resp_data[key] = r.msg[s.id]
else:
if not r.exception:
resp_data[key] = {
'error': {
'status_code': r.code,
'response': r.msg
}
}
else:
if isinstance(r.exception, errors.BaseError):
resp_data[key] = errors.format_error_content(
r.exception, current_app.config['DEBUG'])
else:
resp_data[key] = {
'error':
format_exception(r.exception) if
current_app.config['DEBUG'] else str(r.exception)
or str(r.exception.__class__.__name__)
}
if start:
key = getattr(g.server, attr, g.server.id)
timeout = data.get('timeout', defaults.TIMEOUT_COMMAND)
try:
outs, errs = proc.communicate(input=(data.get('input', '') or ''),
timeout=timeout)
except (TimeoutError, subprocess.TimeoutExpired):
proc.kill()
try:
outs, errs = proc.communicate(timeout=1)
except:
resp_data[key] = {
'error':
f"Command '{cmd}' timed out after {timeout} seconds. Unable to communicate with the process launched."
}
else:
resp_data[key] = {
'error':
f"Command '{cmd}' timed out after {timeout} seconds",
'stdout': outs.split('\n'),
'stderr': errs.split('\n')
}
except Exception as e:
current_app.logger.exception(
"Exception raised while trying to run command")
resp_data[key] = {
'error':
traceback.format_exc() if current_app.config['DEBUG'] else
str(r.exception) or str(r.exception.__class__.__name__)
}
else:
resp_data[key] = {
'stdout': outs.split('\n'),
'stderr': errs.split('\n'),
'returncode': proc.returncode
}
resp_data['cmd'] = cmd
resp_data['input'] = data.get('input', None)
return resp_data, 200
def get(self, step_id):
return Step.query.get_or_raise(step_id).to_json(split_lines=check_param_in_uri('split_lines'))
def get(self):
query = filter_query(Step, request.args)
return [s.to_json(split_lines=check_param_in_uri('split_lines')) for s in query.all()]
def get(self, action_template_id):
return ActionTemplate.query.get_or_raise(action_template_id).to_json(
split_lines=check_param_in_uri('split_lines'))
def get(self):
query = filter_query(ActionTemplate, request.args)
return [
at.to_json(split_lines=check_param_in_uri('split_lines'))
for at in query.all()
]
def launch_orchestration(orchestration_id):
data = request.get_json()
if orchestration_id:
orchestration = Orchestration.query.get_or_raise(orchestration_id)
else:
iden = (data.get('orchestration'), )
columns = ('orchestration', )
query = Orchestration.query.filter_by(name=data.get('orchestration'))
if 'version' in data:
iden += (data.get('version'), )
columns += ('version', )
query = query.filter_by(version=data.get('version'))
query = query.order_by(Orchestration.version.desc())
if query.count() <= 1:
orchestration = query.one_or_none()
else:
orchestration = query.first()
if not orchestration:
raise errors.EntityNotFound('Orchestration', iden, columns)
if not orchestration.steps:
return errors.GenericError(
'orchestration does not have steps to execute',
orchestration_id=orchestration_id)
params = data.get('params') or {}
hosts = data.get('hosts', Server.get_current().id)
a = set(orchestration.target)
if not isinstance(hosts, dict):
hosts = dict(all=hosts)
b = set(hosts.keys())
c = a - b
if len(c) > 0:
raise errors.TargetUnspecified(c)
c = b - a
if len(c) > 0:
raise errors.TargetNotNeeded(c)
not_found = normalize_hosts(hosts)
if not_found:
raise errors.ServerNormalizationError(not_found)
for target, target_hosts in hosts.items():
if len(target_hosts) == 0:
raise errors.EmptyTarget(target)
# check param entries
# rest = orchestration.user_parameters - set(params.keys())
# if rest:
# rest = list(rest)
# rest.sort()
# return {'error': f"Parameter(s) not specified: {', '.join(rest)}"}, 404
execution_id = str(uuid.uuid4())
executor_id = get_jwt_identity()
vc = Context(params,
dict(execution_id=None,
root_orch_execution_id=execution_id,
orch_execution_id=execution_id,
executor_id=executor_id),
vault=Vault.get_variables_from(executor_id,
scope=data.get(
'scope', 'global')))
if not data.get('skip_validation', False):
validate_input_chain(
orchestration, {
'input': set(params.keys()),
'env': set(vc.env.keys()),
'vault': set(vc.vault.keys())
})
if request.get_json().get('background', True):
future = executor.submit(deploy_orchestration,
orchestration=orchestration.id,
var_context=vc,
hosts=hosts,
timeout=data.get('timeout', None))
try:
future.result(5)
except concurrent.futures.TimeoutError:
return {'execution_id': execution_id}, 202
except Exception as e:
current_app.logger.exception(
f"Exception got when executing orchestration {orchestration}")
raise
else:
try:
deploy_orchestration(orchestration=orchestration,
var_context=vc,
hosts=hosts,
timeout=data.get('timeout', None))
except Exception as e:
current_app.logger.exception(
f"Exception got when executing orchestration {orchestration}")
raise
return OrchExecution.query.get(execution_id).to_json(
add_step_exec=True,
human=check_param_in_uri('human'),
split_lines=True), 200
def get(self, name, scope='global'):
return Vault.query.get_or_raise((get_jwt_identity(), scope, name)).to_json(human=check_param_in_uri('human'),
no_delete=True)
def get(self):
query = filter_query(StepExecution, request.args)
return [
e.to_json(human=check_param_in_uri('human'), split_lines=True)
for e in query.order_by(StepExecution.start_time).all()
]
def get(self):
query = filter_query(File, request.args)
return [file.to_json(human=check_param_in_uri('human'), no_delete=True,
destinations=check_param_in_uri('destinations')) for file in
query.all()]