def get_export():
export_data = dict(hosts=[], groups=[])
args = merge_args_data(request.args, request.get_json(silent=True))
o_hosts = Host.objects()
for o_host in o_hosts:
export_data["hosts"].append(o_host.to_barn_dict())
o_groups = Group.objects()
for o_group in o_groups:
export_data["groups"].append(o_group.to_barn_dict())
if args.get("full", "").lower() in ("false", "no", "n", "0"):
export_data = remove_empty_fields(export_data)
response = None
if args.get("format") in ("yaml", "yml"):
response = make_response(
yaml.dump(yaml.load(json.dumps(export_data)), indent=2))
response.headers.set('Content-Type', 'text/plain')
else:
response = make_response(json.dumps(export_data, indent=2))
response.headers.set('Content-Type', 'application/json')
if "file" in args and args.get("file").lower() in ("true", "yes", "y",
"1"):
response.headers.set('Content-Disposition',
'attachment',
filename='barn-export.%s' % (args.get("format")))
return response
def init():
# Role.objects(name__not__iexact="admin").delete()
# Role(name="admin", description="Allow anything")
# Role(name="addHost", description="Add a host to the inventory").save()
# Role(name="addGroup", description="Add a group to the inventory").save()
# Role(name="readOnly", description="Read access on inventory").save()
# Role(name="query", description="Read access on inventory").save()
User.objects(name__not__iexact=current_app.config.get('BARN_CONFIG').get(
"barn_init_admin_user")).delete()
user_1 = User(name="Sander Descamps",
username="******",
password="******",
admin=True,
roles=["test"])
user_1.save()
Host.objects().delete()
h_srvplex01 = Host(name="srvplex01.myhomecloud.be")
h_srvplex01.save()
h_srvdns01 = Host(name="srvdns01.myhomecloud.be",
vars=dict(deploytime="today", env_environment="staging"))
h_srvdns01.save()
h_srvdns02 = Host(name="srvdns02.myhomecloud.be").save()
h_srvdns02.save()
Group.objects().delete()
g_dns_servers = Group(name="dns_servers")
g_dns_servers.hosts.append(h_srvdns01)
g_dns_servers.hosts.append(h_srvdns02)
g_dns_servers.save()
g_all_servers = Group(name="all_servers")
g_all_servers.child_groups.append(g_dns_servers)
g_all_servers.hosts.append(h_srvplex01)
g_all_servers.save()
return jsonify({'message': 'Database has been reseted'})
def get_hosts(resp=None):
if resp is None:
resp = ResponseFormater()
args = request.args if request.method == 'GET' else request.get_json(
silent=True) or {}
query_args = dict()
if "name" in args:
if boolean_parser(args.get("regex", False)):
regex_name = re.compile("^{}$".format(
args.get("name").strip(" ").lstrip("^").rstrip("$")))
query_args["name"] = regex_name
else:
regex_name = re.compile(r"^{}$".format(
re.escape(args.get("name")).replace("\*", ".*")))
query_args["name"] = regex_name
resp.add_result(Host.objects(**query_args))
return resp.get_response()
def get_ansible_inventory_file():
o_hosts = Host.objects()
d_hosts = {}
for host in o_hosts:
d_hosts[host.name] = host.vars
o_groups = Group.objects()
d_groups = {}
for group in o_groups:
d_groups[group.name] = dict(vars=group.vars, hosts={}, children={})
if len(group.hosts) > 0:
d_groups[group.name]["hosts"] = {h.name:None for h in group.hosts}
if len(group.child_groups) > 0:
d_groups[group.name]["children"] = {g.name:None for g in group.child_groups}
result = dict(all=dict(hosts=d_hosts, children=d_groups))
return jsonify(result)
def delete_hosts():
resp = ResponseFormater()
args = merge_args_data(request.args, request.get_json(silent=True))
query_args = dict()
if "name" in args:
query_args["name__in"] = list_parser(args.get("name"))
else:
resp.failed(msg='name not defined')
return resp.get_response()
o_hosts = Host.objects(**query_args)
if o_hosts.count() < 1:
resp.failed(msg='%s not found' % (args.get('name')))
else:
#Remove host from all groups where the host is used
Group.objects(hosts__in=o_hosts).update(pull_all__hosts=o_hosts)
s_hosts = ','.join(o_hosts.scalar('name'))
o_hosts.delete()
resp.succeed(msg='Delete host %s' % (s_hosts), changed=True)
return resp.get_response()
def put_groups(resp=None):
if resp is None:
resp = ResponseFormater()
args = merge_args_data(request.args, request.get_json(silent=True))
name = args.get("name", None)
if name is None:
abort(400, description="name not defined in request")
# Create Group
o_group = Group.objects(name=name).first()
if o_group is None:
try:
query_args = dict(name=name)
o_group = Group(**query_args)
resp.succeed(changed=True, status=HTTPStatus.CREATED)
resp.set_main_message("Create group {}".format(name))
except NotUniqueError:
resp.failed(msg='%s already exist' % (name))
return resp.get_response()
if "child_groups" in args or "child_groups_present" in args:
child_groups = []
child_groups.extend(list_parser(args.get("child_groups", [])))
child_groups.extend(list_parser(args.get("child_groups_present", [])))
child_groups = list(set(child_groups))
for child_group in child_groups:
o_child_group = Group.objects(name=child_group).first()
if not o_child_group and args.get('create_groups', True):
o_child_group = Group(name=child_group)
o_child_group.save()
resp.changed()
resp.add_message("Create group {}".format(child_group))
if o_child_group:
if o_child_group not in o_group.child_groups:
o_group.child_groups.append(o_child_group)
resp.changed()
resp.add_message(
"Add {} group as child-group".format(child_group))
else:
resp.add_message(
"Can't add {} as child group. Group does not exist.")
if "child_groups_set" in args:
o_child_groups = []
for child_group in list_parser(args.get("child_groups_set", [])):
o_child_group = Group.objects(name=child_group).first()
if not o_child_group and args.get('create_groups', True):
o_child_group = Group(name=child_group)
o_child_group.save()
resp.changed()
resp.add_message("Create group {}")
if o_child_group:
o_child_groups.append(o_child_group)
else:
resp.add_message(
"Can't set {} as child group. Group does not exist.")
if set(o_group.child_groups) != set(o_child_groups):
o_group.child_groups = o_child_groups
resp.changed()
if len(o_child_groups) == 0:
resp.add_message("Remove all child-groups from {}".format(
o_group.name))
else:
resp.add_message("Set {} as child-group of {}".format(
','.join([cg.name for cg in o_child_groups]),
o_group.name))
if "child_groups_absent" in args:
for child_group in list_parser(args.get("child_groups_absent")):
o_child_group = Group.objects(name=child_group).first()
if o_child_group is None:
resp.add_message("{} group does not exist".format(child_group))
elif o_child_group in o_group.child_groups:
o_group.child_groups.remove(o_child_group)
resp.changed()
resp.add_message(
"Remove {} from child-groups".format(child_group))
else:
resp.add_message("{} is not a child-group of {}".format(
child_group, name))
if "hosts" in args:
hosts = list_parser(args.get("hosts")) or list_parser(
args.get("hosts_present", []))
o_hosts = Host.objects(name__in=hosts)
hosts_not_found = list(
set(hosts).difference(set(o_hosts.scalar('name'))))
if len(hosts_not_found) > 0:
resp.add_message("Hosts not found: {}".format(
",".join(hosts_not_found)))
o_hosts_to_add = set(o_hosts).difference(o_group["hosts"])
if len(o_hosts_to_add) > 0:
o_group["hosts"].extend(o_hosts_to_add)
resp.changed()
resp.add_message("Add {} to hosts".format(",".join(
map(lambda h: h.name, o_hosts_to_add))))
if "hosts_set" in args:
hosts = list_parser(args.get("hosts_set"))
o_hosts = Host.objects(name__in=hosts)
hosts_not_found = list(
set(hosts).difference(set(o_hosts.scalar('name'))))
if len(hosts_not_found) > 0:
resp.add_message("Hosts not found: {}".format(
",".join(hosts_not_found)))
if set(o_group.get("hosts")) != set(o_hosts):
o_group["hosts"] = list(o_hosts)
resp.changed()
resp.add_message("Set {} to hosts".format(",".join(
o_hosts_to_add.scalar('name'))))
if "hosts_absent" in args:
hosts = list_parser(args.get("hosts_absent"))
o_hosts = Host.objects(name__in=hosts)
o_hosts_to_remove = set(o_hosts).union(set(o_group["hosts"]))
for o_host in o_hosts_to_remove:
o_group["hosts"].remove(o_host)
resp.changed()
resp.add_message("Remove {} from hosts".format(o_host.get("name")))
# Set variables
barn_vars = args.get("vars", {})
for k, v in barn_vars.items():
if o_group.vars.get(k, None) != v:
o_group.vars[k] = v
resp.changed()
# Delete variables
vars_to_remove = args.get("vars_absent", [])
for var_to_remove in vars_to_remove:
if var_to_remove in o_group.vars:
del o_group.vars[var_to_remove]
resp.changed()
# Save group
if resp.get_changed():
o_group.save()
parent_groups_present = list_parser(
args.get("parent_groups", args.get("parent_groups_present", [])))
parent_groups_set = list_parser(args.get("parent_groups_set", []))
parent_groups_absent = list_parser(args.get("parent_groups_absent", []))
used_groups_list = parent_groups_present + parent_groups_set
used_groups_list = list(set(used_groups_list))
logging.debug("list used groups: %s", ",".join(used_groups_list))
# Add groups who do not exist
for g in used_groups_list:
if Group.objects(name=g).first() is None:
if args.get('create_groups', True):
Group(name=g).save()
resp.add_message("Create group {}".format(g))
resp.changed()
else:
resp.add_message("{} group does not exist.".format(g))
if "parent_groups" in args or "parent_groups_present" in args:
o_parent_groups_to_add = Group.objects(name__in=parent_groups_present,
child_groups__nin=[o_group])
if len(o_parent_groups_to_add) > 0:
o_parent_groups_to_add.update(add_to_set__child_groups=o_group)
resp.changed()
s_parent_groups_to_add = ",".join(
[str(g) for g in o_parent_groups_to_add])
resp.add_message("Add {} to child-groups of {}".format(
o_group.name, s_parent_groups_to_add))
if "parent_groups_set" in args:
o_parent_groups_to_add = Group.objects(name__in=parent_groups_set,
child_groups__nin=[o_group])
if len(o_parent_groups_to_add) > 0:
o_parent_groups_to_add.update(add_to_set__child_groups=o_group)
resp.changed()
s_parent_groups_to_add = ",".join(
[str(g) for g in o_parent_groups_to_add])
resp.add_message("Add {} to child-groups of {}".format(
o_group.name, s_parent_groups_to_add))
o_parent_groups_to_remove = Group.objects(name__nin=parent_groups_set,
child_groups__in=[o_group])
if len(o_parent_groups_to_remove) > 0:
o_parent_groups_to_remove.update(pull__child_groups=o_group)
resp.changed()
s_parent_groups_to_remove = ",".join(
[str(g) for g in o_parent_groups_to_remove])
resp.add_message("Remove {} from child-groups of {}".format(
o_group.name, s_parent_groups_to_remove))
if "parent_groups_absent" in args:
o_parent_groups_to_remove = Group.objects(
name__in=parent_groups_absent, child_groups__in=[o_group])
if len(o_parent_groups_to_remove) > 0:
o_parent_groups_to_remove.update(pull__child_groups=o_group)
resp.changed()
s_parent_groups_to_remove = ",".join(
[str(g) for g in o_parent_groups_to_remove])
resp.add_message("Remove {} from child-groups of {}".format(
o_group.name, s_parent_groups_to_remove))
return resp.get_response()
def put_file_import():
resp = ResponseFormater()
hosts_to_add = []
groups_to_add = []
keep_existing_nodes = str(
request.args.get("keep")
or next(iter(request.form.getlist('keep')), None)).lower() in [
"on", "true", "1", "yes"
]
for file in request.files.values():
fileextention = file.filename.split(".")[-1]
to_add = None
if fileextention.lower() in ("yaml", "yml"):
try:
to_add = yaml.load(file, Loader=yaml.FullLoader)
resp.add_message("Successfully loaded %s" % (file.filename))
except yaml.YAMLError as _:
return resp.failed(
msg="failed to read yaml file: %s" % (file.filename),
changed=False,
status=HTTPStatus.BAD_REQUEST).get_response()
elif fileextention.lower() == "json":
try:
to_add = json.load(file)
resp.add_message("Successfully loaded %s" % (file.filename))
except json.JSONDecodeError as _:
return resp.failed(
msg="failed to read json file: %s" % (file.filename),
changed=False,
status=HTTPStatus.BAD_REQUEST).get_response()
elif fileextention.lower() == "ini":
try:
data = file.read().decode('utf-8')
to_add = _convert_ini(data)
except Exception:
return resp.failed(
msg="failed to read ini file: %s" % (file.filename),
changed=False,
status=HTTPStatus.BAD_REQUEST).get_response()
else:
return resp.failed("unsupported extention",
changed=False,
status=HTTPStatus.BAD_REQUEST).get_response()
if "hosts" in to_add and isinstance(to_add["hosts"], list):
hosts_to_add.extend(to_add["hosts"])
if "groups" in to_add and isinstance(to_add["groups"], list):
groups_to_add.extend(to_add["groups"])
for node in to_add.get("nodes", []):
if node.get("type", "").lower() == "host":
hosts_to_add.append(node)
elif node.get("type", "").lower() == "group":
groups_to_add.append(node)
if len(hosts_to_add) > 0 or len(groups_to_add) > 0:
if not keep_existing_nodes:
o_nodes_to_delete = Node.objects()
if o_nodes_to_delete.count() > 0:
o_nodes_to_delete.delete()
resp.add_message("Remove old hosts and groups")
logging.info("Remove all existing nodes during import")
resp.changed()
else:
logging.info("Keep existing nodes during import")
# first make sure all nodes exist
for host in hosts_to_add:
if host.get("name") and not Host.objects(name=host.get("name")):
Host(name=host.get("name")).save()
for group in groups_to_add:
if group.get("name") and not Group.objects(name=group.get("name")):
Group(name=group.get("name")).save()
for host in hosts_to_add:
try:
o_host = Host.from_json(host, append=True)
o_host.save()
resp.add_result(o_host)
resp.changed()
except Exception as _:
resp.add_message("Failed to import host %s" %
(host.get("name", "unknown")))
for group in groups_to_add:
try:
o_group = Group.from_json(group, append=True)
o_group.save()
resp.add_result(o_group)
resp.changed()
except Exception as _:
resp.add_message("Failed to import group %s" %
(group.get("name", "unknown")))
else:
resp.failed(msg="No valid hosts or groups in import")
resp.add_message("Import completed")
return resp.get_response()
def put_hosts(action=None, resp=None):
if resp is None:
resp = ResponseFormater()
args = merge_args_data(request.args, request.get_json(silent=True))
name = args.get("name", None)
if name is None:
resp.failed(msg='name not defined')
return resp.get_response()
# Create Host
o_host = Host.objects(name=name).first()
if o_host is not None and action == "add":
resp.failed(msg='%s already exist' % (args.get("name")))
return resp.get_response()
elif o_host is None:
if action == "update":
resp.failed(msg='Host not found: %s Does not exist' %
(args.get("name")))
return resp.get_response()
else:
try:
o_host = Host(name=name)
resp.succeed(changed=True,
msg="Create host {}".format(name),
status=HTTPStatus.CREATED)
except NotUniqueError:
resp.failed(msg='%s already exist' % (args.get("name")))
return resp.get_response()
# Set variables
barn_vars = args.get("vars", {})
if action == "set" and barn_vars != o_host.vars:
o_host.vars = {}
resp.changed()
resp.add_message("Reset host variables")
for k, v in barn_vars.items():
if o_host.vars.get(k, None) != v:
o_host.vars[k] = v
resp.changed()
resp.add_message("Change variable: {}".format(k))
# Delete variables
if action != "add":
vars_to_remove = args.get("vars_absent", [])
for var_to_remove in vars_to_remove:
if var_to_remove in o_host.vars:
del o_host.vars[var_to_remove]
resp.add_message("Remove variable: {}".format(var_to_remove))
resp.changed()
# Save Host
if resp.get_changed():
o_host.save()
# Add host to group
o_groups_remove_list = []
o_groups_add_list = []
if args.get("groups", False):
groups = list_parser(args.get("groups"))
for group in groups:
o_group = Group.objects(name=group).first()
if not o_group and args.get('create_groups', True):
o_group = Group(name=group)
resp.changed()
resp.add_message("Create {} group".format(group))
if o_group:
o_groups_add_list.append(o_group)
if args.get("groups_present", False):
groups = list_parser(args.get("groups_present"))
for group in groups:
o_group = Group.objects(name=group).first()
if not o_group and args.get('create_groups', True):
o_group = Group(name=group)
if o_group:
o_groups_add_list.append(o_group)
if args.get("groups_set", False) and not any(
k in args for k in ("groups", "groups_present", "groups_absent")):
groups = list_parser(args.get("groups_set"))
o_groups_remove = Group.objects(name__not__in=groups,
hosts__in=[o_host])
for g in o_groups_remove:
o_groups_remove_list.append(g)
for group in groups:
o_group = Group.objects(name=group).first()
if not o_group and args.get('create_groups', True):
o_group = Group(name=group)
if o_group:
o_groups_add_list.append(o_group)
if args.get("groups_absent", False):
groups = list_parser(args.get("groups_absent"))
o_groups_remove = Group.objects(name__in=groups)
for g in o_groups_remove:
o_groups_remove_list.append(g)
for g in list(set(o_groups_remove_list)):
if o_host in g.hosts:
g.hosts.remove(o_host)
resp.add_message("Remove {} from {} group".format(name, g.name))
g.save()
resp.changed()
for g in list(set(o_groups_add_list)):
if o_host not in g.hosts:
g.hosts.append(o_host)
resp.add_message("Add {} into {} group".format(name, g.name))
g.save()
resp.changed()
return resp.get_response()
def flush():
Host.objects().delete()
Group.objects().delete()
return jsonify({'message': 'Database has been flushed'})
