def get_group(self, group_kind, group_name):
self.logger.info("Getting group by name.")
self.setUp()
self.check_admin()
group = get_group(self.db_session, group_name, group_kind)
self.logger.debug(group)
if group_kind == 'role':
self.tearDown(commit=False)
self.logger.info("Done")
return JSONAsyncResult(
200, {
'name': group.group_name,
'kind': group.group_kind,
'description': group.group_description
})
else:
user_groups = get_group_list(self.db_session)
self.tearDown(commit=False)
self.logger.info("Done.")
return JSONAsyncResult(
200, {
'name':
group.group_name,
'kind':
group.group_kind,
'description':
group.group_description,
'user_groups': [{
'name': user_group.group_name,
'description': user_group.group_description
} for user_group in user_groups],
'in_groups': [ari.role_group_name for ari in group.ari]
})
def groups(request, kind):
return render_template(
"settings/group.html",
nav=True,
role=request.current_user,
group_kind=kind,
group_list=get_group_list(request.db_session, kind),
)
def get_group(self, group_kind, group_name):
try:
self.logger.info("Getting group by name.")
self.load_auth_cookie()
self.start_db_session()
self.check_admin()
group = get_group(self.db_session, group_name, group_kind)
self.logger.debug(group)
if group_kind == 'role':
self.db_session.expunge_all()
self.db_session.commit()
self.db_session.close()
self.logger.info("Done")
return JSONAsyncResult(
200, {
'name': group.group_name,
'kind': group.group_kind,
'description': group.group_description
})
else:
user_groups = get_group_list(self.db_session)
self.db_session.expunge_all()
self.db_session.commit()
self.db_session.close()
self.logger.info("Done.")
return JSONAsyncResult(
200, {
'name':
group.group_name,
'kind':
group.group_kind,
'description':
group.group_description,
'user_groups':
[{
'name': user_group.group_name,
'description': user_group.group_description
} for user_group in user_groups],
'in_groups':
[ari.role_group_name for ari in group.ari]
})
except (TemboardUIError, Exception) as e:
self.logger.exception(str(e))
self.logger.info("Failed.")
try:
self.db_session.rollback()
self.db_session.close()
except Exception:
pass
if isinstance(e, TemboardUIError):
return JSONAsyncResult(e.code, {'error': e.message})
else:
return JSONAsyncResult(500, {'error': "Internal error."})
def json_instance(request):
instance = request.instance
if 'GET' == request.method:
groups = get_group_list(request.db_session, 'instance')
return {
'agent_address': instance.agent_address,
'agent_port': instance.agent_port,
'agent_key': instance.agent_key,
'hostname': instance.hostname,
'cpu': instance.cpu,
'memory_size': instance.memory_size,
'pg_port': instance.pg_port,
'pg_version': instance.pg_version,
'pg_data': instance.pg_data,
'in_groups': [g.group_name for g in instance.groups],
'enabled_plugins': [p.plugin_name for p in instance.plugins],
'groups': [{
'name': group.group_name,
'description': group.group_description
} for group in groups],
'loaded_plugins': request.handler.application.loaded_plugins,
'notify': instance.notify,
'comment': instance.comment,
}
else: # POST (update)
data = request.json
validate_instance_data(data)
groups = data.pop('groups')
plugins = data.pop('plugins') or []
# First step is to remove the instance from the groups it belongs to.
instance_groups = get_groups_by_instance(
request.db_session, instance.agent_address,
instance.agent_port)
for instance_group in instance_groups:
delete_instance_from_group(
request.db_session, instance.agent_address,
instance.agent_port, instance_group.group_name)
# Remove plugins
purge_instance_plugins(
request.db_session, instance.agent_address,
instance.agent_port)
instance = update_instance(
request.db_session,
instance.agent_address,
instance.agent_port,
**data)
add_instance_in_groups(request.db_session, instance, groups)
enable_instance_plugins(
request.db_session, instance, plugins,
request.handler.application.loaded_plugins,
)
return {"message": "OK"}
def all_group(request, kind):
groups = get_group_list(request.db_session, kind)
return {
'groups': [{
'name': group.group_name,
'kind': group.group_kind,
'description': group.group_description
} for group in groups],
'loaded_plugins':
request.handler.application.loaded_plugins,
}
def group(request, kind, name):
if 'GET' == request.method:
if not name:
raise HTTPError(404)
group = get_group(request.db_session, name, kind)
data = dict(
name=group.group_name,
kind=kind,
description=group.group_description,
)
if kind == 'instance':
data['user_groups'] = [
dict(name=g.group_name, description=g.group_description)
for g in get_group_list(request.db_session)
]
data['in_groups'] = [a.role_group_name for a in group.ari]
return data
else: # POST
data = request.json
if not data.get('new_group_name'):
raise HTTPError(400, "Missing group name.")
check_group_name(data['new_group_name'])
if not data.get('description'):
raise HTTPError(400, "Missing description")
check_group_description(data['description'])
if name: # Group update
group = get_group(request.db_session, name, kind)
if 'instance' == kind:
for ari in group.ari:
delete_role_group_from_instance_group(
request.db_session, ari.role_group_name,
group.group_name)
group = update_group(request.db_session, group.group_name, kind,
data['new_group_name'], data['description'])
else: # Group creation
group = add_group(request.db_session, data['new_group_name'],
data['description'], kind)
if 'user_groups' in data and data['user_groups']:
for group_name in data['user_groups']:
add_role_group_in_instance_group(request.db_session,
group_name, group.group_name)
return {'ok': True}
def json_user(request, username):
if 'GET' == request.method:
if username is None:
raise HTTPError(500, "Username is missing")
role = get_role(request.db_session, username)
groups = get_group_list(request.db_session)
return {
'role_name': role.role_name,
'role_email': role.role_email,
'role_phone': role.role_phone,
'is_active': role.is_active,
'is_admin': role.is_admin,
'in_groups': [group.group_name for group in role.groups],
'groups': [{
'name': group.group_name,
'description': group.group_description
} for group in groups]
}
elif 'POST' == request.method: # update
data = request.json
role = get_role(request.db_session, username)
validate_user_data(data, role)
h_passwd = handle_password(data)
# First step is to remove user from the groups he belongs to.
role_groups = get_groups_by_role(request.db_session,
role.role_name)
if role_groups:
for role_group in role_groups:
delete_role_from_group(request.db_session, role.role_name,
role_group.group_name)
role = update_role(
request.db_session,
role.role_name,
data['new_username'],
h_passwd,
data['email'],
data['is_active'],
data['is_admin'],
data['phone'])
add_user_to_groups(request, data, role)
return {"message": "OK"}
def get_index(self, group_kind):
try:
self.logger.info("Group list.")
self.load_auth_cookie()
self.start_db_session()
self.check_admin()
group_list = get_group_list(self.db_session, group_kind)
self.logger.debug(group_list)
self.db_session.expunge_all()
self.db_session.commit()
self.db_session.close()
self.logger.info("Done.")
return HTMLAsyncResult(200,
None, {
'nav': True,
'role': self.current_user,
'group_list': group_list,
'group_kind': group_kind
},
template_file='settings/group.html')
except (TemboardUIError, Exception) as e:
self.logger.exception(str(e))
self.logger.info("Failed.")
try:
self.db_session.rollback()
self.db_session.close()
except Exception:
pass
if isinstance(e, TemboardUIError):
if e.code == 302:
return HTMLAsyncResult(302, '/login')
elif e.code == 401:
return HTMLAsyncResult(401,
None, {'nav': False},
template_file='unauthorized.html')
return HTMLAsyncResult(500,
None, {
'nav': False,
'error': e.message
},
template_file='settings/error.html')
def get_role(self, username):
try:
self.logger.info("Getting role by name.")
self.load_auth_cookie()
self.start_db_session()
self.check_admin()
role = get_role(self.db_session, username)
groups = get_group_list(self.db_session)
self.db_session.expunge_all()
self.db_session.commit()
self.db_session.close()
self.logger.info("Done.")
return JSONAsyncResult(
200, {
'role_name':
role.role_name,
'role_email':
role.role_email,
'is_active':
role.is_active,
'is_admin':
role.is_admin,
'in_groups': [group.group_name for group in role.groups],
'groups': [{
'name': group.group_name,
'description': group.group_description
} for group in groups]
})
except (TemboardUIError, Exception) as e:
self.logger.exception(str(e))
self.logger.info("Failed.")
try:
self.db_session.rollback()
self.db_session.close()
except Exception:
pass
if isinstance(e, TemboardUIError):
return JSONAsyncResult(e.code, {'error': e.message})
else:
return JSONAsyncResult(500, {'error': "Internal error."})
def get_all(self, group_kind):
self.logger.info("Getting group list.")
self.setUp()
self.check_admin()
groups = get_group_list(self.db_session, group_kind)
self.logger.debug(groups)
self.logger.info("Done.")
self.tearDown(commit=False)
return JSONAsyncResult(
200, {
'groups': [{
'name': group.group_name,
'kind': group.group_kind,
'description': group.group_description
} for group in groups],
'loaded_plugins':
self.application.loaded_plugins
})
def get_instance(self, agent_address, agent_port):
self.logger.info("Getting instance.")
self.setUp(agent_address, agent_port)
self.check_admin()
groups = get_group_list(self.db_session, 'instance')
self.logger.info("Done.")
self.tearDown(commit=False)
return JSONAsyncResult(
200, {
'agent_address':
self.instance.agent_address,
'agent_port':
self.instance.agent_port,
'agent_key':
self.instance.agent_key,
'hostname':
self.instance.hostname,
'cpu':
self.instance.cpu,
'memory_size':
self.instance.memory_size,
'pg_port':
self.instance.pg_port,
'pg_version':
self.instance.pg_version,
'pg_data':
self.instance.pg_data,
'in_groups':
[group.group_name for group in self.instance.groups],
'enabled_plugins':
[plugin.plugin_name for plugin in self.instance.plugins],
'groups': [{
'name': group.group_name,
'description': group.group_description
} for group in groups],
'loaded_plugins':
self.application.loaded_plugins
})
def get_all(self, group_kind):
try:
self.logger.info("Getting group list.")
self.load_auth_cookie()
self.start_db_session()
self.check_admin()
groups = get_group_list(self.db_session, group_kind)
self.logger.debug(groups)
self.db_session.expunge_all()
self.db_session.commit()
self.db_session.close()
self.logger.info("Done.")
return JSONAsyncResult(
200, {
'groups': [{
'name': group.group_name,
'kind': group.group_kind,
'description': group.group_description
} for group in groups],
'loaded_plugins':
self.application.loaded_plugins
})
except (TemboardUIError, Exception) as e:
self.logger.info("Failed.")
self.logger.exception(str(e))
try:
self.db_session.rollback()
self.db_session.close()
except Exception:
pass
if isinstance(e, TemboardUIError):
return JSONAsyncResult(e.code, {'error': e.message})
else:
return JSONAsyncResult(500, {'error': "Internal error."})