def get_instance(session, agent_address, agent_port):
try:
return session.query(Instances).options(joinedload(
Instances.groups), joinedload(Instances.plugins)).filter_by(
agent_address=unicode(agent_address),
agent_port=agent_port).first()
except AttributeError as e:
raise TemboardUIError(
400,
"Instance entry '%s:%s' not found." % (agent_address, agent_port))
except Exception as e:
raise TemboardUIError(e.message)
def delete_role_from_group(session, role_name, group_name):
try:
role_group = session.query(RoleGroups).filter(
RoleGroups.group_name == unicode(group_name),
RoleGroups.role_name == unicode(role_name)).one()
session.delete(role_group)
except NoResultFound as e:
raise TemboardUIError(
400,
"Role '%s' not found in group '%s'." % (role_name, group_name))
except Exception as e:
raise TemboardUIError(400, e.message)
def delete_instance(session, agent_address, agent_port):
try:
instance = session.query(Instances).filter(
Instances.agent_address == unicode(agent_address),
Instances.agent_port == agent_port).one()
session.delete(instance)
except NoResultFound as e:
raise TemboardUIError(
400, "Instance entry ('%s:%s') not found." %
(agent_address, agent_port))
except Exception as e:
raise TemboardUIError(400, e.message)
def post_hba(self, agent_address, agent_port):
try:
self.logger.info("Posting HBA (proxy).")
instance = None
role = None
self.load_auth_cookie()
self.start_db_session()
role = self.current_user
if not role:
raise TemboardUIError(302, "Current role unknown.")
instance = get_instance(self.db_session, agent_address, agent_port)
if not instance:
raise TemboardUIError(404, "Instance not found.")
if __name__ not in [plugin.plugin_name for plugin in instance.plugins]:
raise TemboardUIError(408, "Plugin not active.")
self.db_session.expunge_all()
self.db_session.commit()
self.db_session.close()
xsession = self.get_secure_cookie("temboard_%s_%s" % (instance.agent_address, instance.agent_port))
if not xsession:
raise TemboardUIError(401, "Authentication cookie is missing.")
data = temboard_post_conf_file(
self.ssl_ca_cert_file,
'hba',
instance.agent_address,
instance.agent_port,
xsession,
tornado.escape.json_decode(self.request.body))
# And reload postgresql configuration.
ret_reload = temboard_post_administration_control(
self.ssl_ca_cert_file,
instance.agent_address,
instance.agent_port,
xsession,
{'action': 'reload'})
self.logger.info("Done.")
return JSONAsyncResult(http_code = 200, data = data)
except (TemboardUIError, TemboardError, Exception) as e:
self.logger.exception(str(e))
self.logger.info("Failed.")
try:
self.db_session.close()
except Exception:
pass
if (isinstance(e, TemboardUIError) or isinstance(e, TemboardError)):
return JSONAsyncResult(http_code = e.code, data = {'error': e.message})
else:
return JSONAsyncResult(http_code = 500, data = {'error': e.message})
def update_instance(session,
agent_address,
agent_port,
new_agent_address=None,
new_agent_port=None,
agent_key=None,
hostname=None,
cpu=None,
memory_size=None,
pg_port=None,
pg_version=None,
pg_data=None):
try:
instance = session.query(Instances).filter_by(
agent_address=unicode(agent_address),
agent_port=agent_port).first()
if new_agent_address is not None:
instance.agent_adresse = unicode(new_agent_address)
if new_agent_port is not None:
instance.agent_port = int(new_agent_port)
if cpu is not None and cpu is not u'':
instance.cpu = int(cpu)
else:
instance.cpu = None
if memory_size is not None and memory_size is not u'':
instance.memory_size = int(memory_size)
else:
instance.memory_size = None
if pg_port is not None and pg_port is not u'':
instance.pg_port = int(pg_port)
else:
instance.pg_port = None
instance.agent_key = unicode(agent_key)
instance.hostname = unicode(hostname)
instance.pg_version = unicode(pg_version)
instance.pg_data = unicode(pg_data)
session.merge(instance)
session.flush()
return instance
except IntegrityError as e:
if e.message.find('instances_pkey') > 0:
raise TemboardUIError(
400, "Instance entry ('%s:%s') already exists." %
(agent_address, agent_port))
else:
raise TemboardUIError(400, e.message)
except AttributeError as e:
raise TemboardUIError(
400, "Instance entry ('%s:%s') not found." %
(agent_address, agent_port))
except Exception as e:
raise TemboardUIError(400, e.message)
def get_state_changes(self, address, port, check_name):
self.setUp(address, port)
# Arguments
start = self.get_argument('start', default=None)
end = self.get_argument('end', default=None)
key = self.get_argument('key', default=None)
if check_name not in check_specs:
raise TemboardUIError(404, "Unknown check '%s'" % check_name)
start_time = None
end_time = None
if start:
try:
start_time = dt_parser.parse(start)
except ValueError:
raise TemboardUIError(406, 'Datetime not valid.')
if end:
try:
end_time = dt_parser.parse(end)
except ValueError:
raise TemboardUIError(406, 'Datetime not valid.')
data_buffer = cStringIO.StringIO()
cur = self.db_session.connection().connection.cursor()
cur.execute("SET search_path TO monitoring")
query = """
COPY (
SELECT array_to_json(array_agg(json_build_object(
'datetime', f.datetime,
'state', f.state,
'value', f.value,
'warning', f.warning,
'critical', f.critical
))) FROM get_state_changes(%s, %s, %s, %s, %s, %s) f
) TO STDOUT
""" # noqa
# build the query
query = cur.mogrify(query, (self.host_id, self.instance_id, check_name,
key, start_time, end_time))
cur.copy_expert(query, data_buffer)
cur.close()
data = data_buffer.getvalue()
data_buffer.close()
try:
data = json.loads(data)
except Exception:
# No data
data = []
return JSONAsyncResult(http_code=200, data=data)
def delete_instance_from_group(session, agent_address, agent_port, group_name):
try:
instance_group = session.query(InstanceGroups).filter(
InstanceGroups.agent_address == unicode(agent_address),
InstanceGroups.agent_port == agent_port,
InstanceGroups.group_name == unicode(group_name)).one()
session.delete(instance_group)
except NoResultFound as e:
raise TemboardUIError(
400, "Instance entry ('%s:%s)' not found in group '%s'." %
(agent_address, agent_port, group_name))
except Exception as e:
raise TemboardUIError(400, e.message)
def get_activity_w_b(self, agent_address, agent_port, mode):
try:
role = None
instance = None
self.load_auth_cookie()
self.start_db_session()
role = self.current_user
if not role:
raise TemboardUIError(302, "Current role unknown.")
instance = get_instance(self.db_session, agent_address, agent_port)
if not instance:
raise TemboardUIError(404, "Instance not found.")
if __name__ not in [
plugin.plugin_name for plugin in instance.plugins
]:
raise TemboardUIError(408, "Plugin not activated.")
self.db_session.expunge_all()
self.db_session.commit()
self.db_session.close()
xsession = self.request.headers.get('X-Session')
if not xsession:
raise TemboardUIError(401, 'X-Session header missing')
# Load activity.
if mode == 'waiting':
data_activity = temboard_activity_waiting(
self.ssl_ca_cert_file, instance.agent_address,
instance.agent_port, xsession)
elif mode == 'blocking':
data_activity = temboard_activity_blocking(
self.ssl_ca_cert_file, instance.agent_address,
instance.agent_port, xsession)
else:
raise TemboardUIError(404, "Mode unknown.")
return JSONAsyncResult(http_code=200, data=data_activity)
except (TemboardUIError, TemboardError, Exception) as e:
self.logger.error(e.message)
try:
self.db_session.close()
except Exception:
pass
if (isinstance(e, TemboardUIError)
or isinstance(e, TemboardError)):
return JSONAsyncResult(http_code=e.code,
data={'error': e.message})
else:
return JSONAsyncResult(http_code=500,
data={'error': e.message})
def delete_role_group_from_instance_group(session, role_group_name,
instance_group_name):
try:
ari = session.query(AccessRoleInstance).filter(
AccessRoleInstance.role_group_name == unicode(role_group_name),
AccessRoleInstance.instance_group_name == unicode(
instance_group_name)).one()
session.delete(ari)
except NoResultFound as e:
raise TemboardUIError(
400, "Role group '%s' not found in instance group '%s'." %
(role_role_name, instance_group_name))
except Exception as e:
raise TemboardUIError(400, e.message)
def get_role_by_auth(session, role_name, role_password):
try:
role = session.query(Roles).filter(
Roles.role_name == unicode(role_name),
Roles.is_active == True).one()
if role.role_password != unicode(role_password):
raise TemboardUIError(
400, "Wrong user/password: %s/%s" % (role_name, role_password))
return role
except NoResultFound as e:
raise TemboardUIError(
400, "Wrong user/password: %s/%s" % (role_name, role_password))
except Exception as e:
raise TemboardUIError(400, e.message)
def delete_hba(self, agent_address, agent_port):
try:
self.logger.info("Deleting HBA (proxy).")
instance = None
role = None
self.load_auth_cookie()
self.start_db_session()
role = self.current_user
if not role:
raise TemboardUIError(302, "Current role unknown.")
instance = get_instance(self.db_session, agent_address, agent_port)
if not instance:
raise TemboardUIError(404, "Instance not found.")
if __name__ not in [
plugin.plugin_name for plugin in instance.plugins
]:
raise TemboardUIError(408, "Plugin not active.")
self.db_session.expunge_all()
self.db_session.commit()
self.db_session.close()
xsession = self.get_secure_cookie(
"temboard_%s_%s" %
(instance.agent_address, instance.agent_port))
if not xsession:
raise TemboardUIError(401, "Authentication cookie is missing.")
res = temboard_delete_hba_version(
self.ssl_ca_cert_file, instance.agent_address,
instance.agent_port, xsession,
self.get_argument('version', None))
self.logger.info("Done.")
return JSONAsyncResult(http_code=200, data=res)
except (TemboardUIError, TemboardError, Exception) as e:
self.logger.traceback(get_tb())
self.logger.error(str(e))
self.logger.info("Failed.")
try:
self.db_session.close()
except Exception:
pass
if (isinstance(e, TemboardUIError)
or isinstance(e, TemboardError)):
return JSONAsyncResult(http_code=e.code,
data={'error': e.message})
else:
return JSONAsyncResult(http_code=500,
data={'error': e.message})
def delete_instance(session, agent_address, agent_port):
from temboardui.plugins.monitoring.model.orm import (
Host as MonitoringHost,
Instance as MonitoringInstance,
)
try:
instance = session.query(Instances).filter(
Instances.agent_address == unicode(agent_address),
Instances.agent_port == agent_port).one()
session.delete(instance)
except NoResultFound as e:
raise TemboardUIError(
400, "Instance entry ('%s:%s') not found." %
(agent_address, agent_port))
except Exception as e:
raise TemboardUIError(400, e.message)
# Also delete any monitoring data
# First all instance data
try:
monitoring_instance = session.query(MonitoringInstance) \
.join(MonitoringHost) \
.filter(
MonitoringHost.hostname == instance.hostname,
MonitoringInstance.port == instance.pg_port).one()
session.delete(monitoring_instance)
except NoResultFound as e:
pass
except Exception as e:
raise TemboardUIError(400, e.message)
# Then delete host data if there's no instance left referenced for this
# host
count = session.query(MonitoringInstance.instance_id) \
.join(MonitoringHost) \
.filter(MonitoringHost.hostname == instance.hostname) \
.count()
if count == 0:
# Using bulk delete query here to prevent errors on not null constraint
# on checks::host_id column (ON CASCADE DELETE not working)
# when using session.delete(host)
try:
session.query(MonitoringHost) \
.filter(MonitoringHost.hostname == instance.hostname) \
.delete()
except NoResultFound as e:
pass
except Exception as e:
raise TemboardUIError(400, e.message)
def post_kill(self, agent_address, agent_port):
try:
self.logger.info("Posting terminate backend.")
role = None
instance = None
self.load_auth_cookie()
self.start_db_session()
role = self.current_user
if not role:
raise TemboardUIError(302, "Current role unknown.")
instance = get_instance(self.db_session, agent_address, agent_port)
if not instance:
raise TemboardUIError(404, "Instance not found.")
if __name__ not in [
plugin.plugin_name for plugin in instance.plugins
]:
raise TemboardUIError(408, "Plugin not activated.")
self.db_session.expunge_all()
self.db_session.commit()
self.db_session.close()
xsession = self.request.headers.get('X-Session')
if not xsession:
raise TemboardUIError(401, 'X-Session header missing')
self.logger.debug(tornado.escape.json_decode(self.request.body))
data_kill = temboard_activity_kill(
self.ssl_ca_cert_file, instance.agent_address,
instance.agent_port, xsession,
tornado.escape.json_decode(self.request.body))
self.logger.info("Done.")
return JSONAsyncResult(http_code=200, data=data_kill)
except (TemboardUIError, TemboardError, Exception) as e:
self.logger.traceback(get_tb())
self.logger.error(str(e))
self.logger.info("Failed.")
try:
self.db_session.close()
except Exception:
pass
if (isinstance(e, TemboardUIError)
or isinstance(e, TemboardError)):
return JSONAsyncResult(http_code=e.code,
data={'error': e.message})
else:
return JSONAsyncResult(http_code=500,
data={'error': e.message})
def delete_role(self):
try:
self.logger.info("Deleting role.")
self.load_auth_cookie()
self.start_db_session()
self.check_admin()
data = tornado.escape.json_decode(self.request.body)
self.logger.debug(data)
if 'username' not in data or data['username'] == '':
raise TemboardUIError(400, "Username field is missing.")
delete_role(self.db_session, data['username'])
self.db_session.commit()
self.db_session.close()
self.logger.info("Done.")
return JSONAsyncResult(200, {'delete': True})
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 send_mail(host,
port,
subject,
content,
emails,
tls=False,
login=None,
password=None,
from_addr=None):
msg = MIMEText(content, 'plain', 'utf-8')
msg['Subject'] = subject
try:
if not tls:
smtp = SMTP(host, port)
else:
smtp = SMTP_SSL(host, port)
if login is not None and password is not None:
smtp.login(login, password)
smtp.sendmail(from_addr, emails, msg.as_string())
smtp.quit()
except Exception as e:
raise TemboardUIError(
500, "Could not send mail; %s\n"
"SMTP server may be misconfigured." % e)
def check_group_description(group_description):
if len(group_description) > 255:
raise TemboardUIError(
400,
"Invalid group description, must be a 256 char (max) length "
"string."
)
def get_dashboard(self, agent_address, agent_port):
self.logger.info("Getting dashboard.")
self.setUp(agent_address, agent_port)
self.check_active_plugin(__name__)
xsession = self.get_secure_cookie("temboard_%s_%s" %
(agent_address, agent_port))
if not xsession:
raise TemboardUIError(401, "Authentication cookie is missing.")
else:
data_profile = temboard_profile(self.ssl_ca_cert_file,
agent_address, agent_port,
xsession)
agent_username = data_profile['username']
try:
config = temboard_dashboard_config(
self.ssl_ca_cert_file, agent_address, agent_port, xsession)
except TemboardError as e:
# Agent may not be able to send config (old agent)
# Use a default one
if e.code == 404:
config = {
'history_length': 150,
'scheduler_interval': 2
}
else:
raise e
dashboard_history = temboard_dashboard_history(
self.ssl_ca_cert_file, agent_address, agent_port, xsession)
if dashboard_history and isinstance(
dashboard_history, list) and len(dashboard_history) > 0:
last_data = dashboard_history[-1]
history = json.dumps(dashboard_history)
else:
# If dashboard history is empty, let's try to get data from the
# live data source.
last_data = temboard_dashboard_live(
self.ssl_ca_cert_file, agent_address, agent_port, xsession)
history = ''
self.logger.info("Done.")
return HTMLAsyncResult(
http_code=200,
template_file='dashboard.html',
template_path=self.template_path,
data={
'nav': True,
'role': self.current_user,
'instance': self.instance,
'plugin': __name__,
'dashboard': last_data,
'config': json.dumps(config),
'history': history,
'buffers_delta': 0,
'readratio': (100 - last_data['hitratio']),
'xsession': xsession,
'agent_username': agent_username,
})
def get_group(session, group_name, group_kind):
try:
if group_kind == 'role':
return session.query(Groups).filter_by(
group_name=unicode(group_name),
group_kind=unicode(group_kind)).one()
else:
return session.query(Groups).options(
joinedload(Groups.ari)).filter(
Groups.group_name == unicode(group_name),
Groups.group_kind == unicode(group_kind)).one()
except AttributeError as e:
raise TemboardUIError(
400, "Group '%s' (%s) not found." % (group_name, group_kind))
except Exception as e:
raise TemboardUIError(e.message)
def delete_instance(self):
self.logger.info("Deleting instance.")
self.setUp()
self.check_admin()
data = tornado.escape.json_decode(self.request.body)
self.logger.debug(data)
if 'agent_address' not in data or data['agent_address'] == '':
raise TemboardUIError(400, "Agent address field is missing.")
if 'agent_port' not in data or data['agent_port'] == '':
raise TemboardUIError(400, "Agent port field is missing.")
delete_instance(self.db_session, data['agent_address'],
data['agent_port'])
self.tearDown()
self.logger.info("Done.")
return JSONAsyncResult(200, {'delete': True})
def send_sms(config, content, phones):
sid = config.twilio_account_sid
token = config.twilio_auth_token
from_ = config.twilio_from
uri = 'https://api.twilio.com/2010-04-01/Accounts/%s/Messages.json' % sid
s = base64.b64encode('%s:%s' % (sid, token))
errors = []
for recipient in phones:
req = urllib2.Request(url=uri)
req.add_header('Authorization', 'Basic %s' % s)
data = {'From': from_, 'Body': content, 'To': recipient}
req.add_data(urllib.urlencode(data))
try:
urllib2.urlopen(req)
except urllib2.HTTPError as e:
response = json.loads(e.read())
logger.error("Could not send SMS; %s" % response.get('message'))
errors.append(recipient)
except Exception as e:
logger.error("Could not send SMS; %s" % e)
errors.append(recipient)
if errors:
raise TemboardUIError(
500,
"Could not send SMS to %s; \n See logs for more information" %
', '.join(errors))
def get_notifications(self, agent_address, agent_port):
self.logger.info("Getting notifications.")
self.setUp(agent_address, agent_port)
xsession = self.get_secure_cookie("temboard_%s_%s" %
(agent_address, agent_port))
if not xsession:
raise TemboardUIError(401, "Authentication cookie is missing.")
else:
data_profile = temboard_profile(self.ssl_ca_cert_file,
agent_address, agent_port,
xsession)
agent_username = data_profile['username']
# Load notifications.
notifications = temboard_get_notifications(self.ssl_ca_cert_file,
agent_address, agent_port,
xsession)
self.tearDown(commit=False)
self.logger.info("Done.")
return HTMLAsyncResult(http_code=200,
template_file='notifications.html',
data={
'nav': True,
'role': self.current_user,
'instance': self.instance,
'plugin': 'notifications',
'notifications': notifications,
'xsession': xsession,
'agent_username': agent_username,
})
def get_configuration_file(self, agent_address, agent_port):
self.logger.info("Getting configuration (file).")
self.setUp(agent_address, agent_port)
self.check_active_plugin(__name__)
xsession = self.get_secure_cookie("temboard_%s_%s" %
(agent_address, agent_port))
if not xsession:
raise TemboardUIError(401, "Authentication cookie is missing.")
# Load file content.
file_content = temboard_get_file_content(self.ssl_ca_cert_file,
self.file_type, agent_address,
agent_port, xsession)
self.logger.info("Done.")
return HTMLAsyncResult(http_code=200,
template_path=self.template_path,
template_file='edit_file.html',
data={
'nav': True,
'role': self.current_user,
'instance': self.instance,
'plugin': __name__,
'file_type': self.file_type,
'file_content': file_content,
'xsession': xsession
})
def check_group_name(group_name):
p_group_name = r'^([a-z0-9_\-.]{3,16})$'
r_group_name = re.compile(p_group_name)
if not r_group_name.match(group_name):
raise TemboardUIError(
400, "Invalid group name, must satisfy this regexp pattern: %s" %
(p_group_name))
def delete_group(self, group_kind):
try:
self.load_auth_cookie()
self.start_db_session()
self.check_admin()
data = tornado.escape.json_decode(self.request.body)
if 'group_name' not in data or data['group_name'] == '':
raise TemboardUIError(400, "Group name field is missing.")
delete_group(self.db_session, data['group_name'], group_kind)
self.db_session.commit()
self.db_session.close()
return JSONAsyncResult(200, {'delete': True})
except (TemboardUIError, Exception) as e:
self.logger.error(e.message)
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_activity(self, agent_address, agent_port, mode):
self.logger.info("Getting activity.")
self.setUp(agent_address, agent_port)
self.check_active_plugin(__name__)
xsession = self.get_secure_cookie("temboard_%s_%s" %
(agent_address, agent_port))
if not xsession:
raise TemboardUIError(401, "Authentication cookie is missing.")
else:
data_profile = temboard_profile(self.ssl_ca_cert_file,
agent_address, agent_port,
xsession)
agent_username = data_profile['username']
self.logger.info("Done.")
return HTMLAsyncResult(http_code=200,
template_path=self.template_path,
template_file='activity.html',
data={
'nav': True,
'role': self.current_user,
'instance': self.instance,
'plugin': __name__,
'mode': mode,
'xsession': xsession,
'agent_username': agent_username,
})
def get_activity(self, agent_address, agent_port, mode):
self.logger.info("Getting activity (proxy).")
self.setUp(agent_address, agent_port)
self.check_active_plugin(__name__)
xsession = self.request.headers.get('X-Session')
if not xsession:
raise TemboardUIError(401, 'X-Session header missing')
# Load activity.
if mode == 'waiting':
data_activity = temboard_activity_waiting(self.ssl_ca_cert_file,
agent_address,
agent_port, xsession)
elif mode == 'blocking':
data_activity = temboard_activity_blocking(self.ssl_ca_cert_file,
agent_address,
agent_port, xsession)
else:
data_activity = temboard_activity(self.ssl_ca_cert_file,
agent_address, agent_port,
xsession)
self.logger.info("Done.")
return JSONAsyncResult(http_code=200, data=data_activity)
def get_hba_options(self, agent_address, agent_port):
try:
self.logger.info("Getting HBA options (proxy).")
role = None
instance = None
self.load_auth_cookie()
self.start_db_session()
role = self.current_user
if not role:
raise TemboardUIError(302, "Current role unknown.")
instance = get_instance(self.db_session, agent_address, agent_port)
if not instance:
raise TemboardUIError(404, "Instance not found.")
if __name__ not in [
plugin.plugin_name for plugin in instance.plugins
]:
raise TemboardUIError(408, "Plugin not activated.")
self.db_session.expunge_all()
self.db_session.commit()
self.db_session.close()
xsession = self.request.headers.get('X-Session')
if not xsession:
raise TemboardUIError(401, 'X-Session header missing')
hba_options = temboard_get_hba_options(self.ssl_ca_cert_file,
instance.agent_address,
instance.agent_port,
xsession)
self.logger.info("Done.")
return JSONAsyncResult(http_code=200, data=hba_options)
except (TemboardUIError, TemboardError, Exception) as e:
self.logger.exception(str(e))
self.logger.info("Failed.")
try:
self.db_session.close()
except Exception:
pass
if (isinstance(e, TemboardUIError)
or isinstance(e, TemboardError)):
return JSONAsyncResult(http_code=e.code,
data={'error': e.message})
else:
return JSONAsyncResult(http_code=500,
data={'error': e.message})
def get_login(self, agent_address, agent_port):
try:
instance = None
role = None
agent_username = None
self.start_db_session()
try:
self.load_auth_cookie()
role = self.current_user
except Exception as e:
pass
if role is None:
raise TemboardUIError(302, "Current role unknown.")
instance = get_instance(self.db_session, agent_address, agent_port)
self.db_session.close()
xsession = self.get_secure_cookie(
"temboard_%s_%s" %
(instance.agent_address, instance.agent_port))
if xsession:
try:
data_profile = temboard_profile(self.ssl_ca_cert_file,
instance.agent_address,
instance.agent_port,
xsession)
agent_username = data_profile['username']
self.logger.error(agent_username)
except Exception as e:
self.logger.exception(str(e))
return HTMLAsyncResult(http_code=200,
template_file='agent-login.html',
data={
'nav': True,
'instance': instance,
'role': role,
'username': agent_username
})
except (TemboardUIError, TemboardError, Exception) as e:
self.logger.exception(str(e))
try:
self.db_session.close()
except Exception as e:
pass
if (isinstance(e, TemboardUIError)
or isinstance(e, TemboardError)):
if e.code == 302:
return HTMLAsyncResult(http_code=401, redirection="/login")
code = e.code
else:
code = 500
return HTMLAsyncResult(http_code=code,
template_file='error.html',
data={
'nav': True,
'instance': instance,
'code': str(e.code),
'message': str(e.message)
})
def get_instance(self, agent_address, agent_port):
try:
self.logger.info("Getting instance.")
self.load_auth_cookie()
self.start_db_session()
self.check_admin()
instance = get_instance(self.db_session, agent_address, agent_port)
groups = get_group_list(self.db_session, 'instance')
if not instance:
raise TemboardUIError(404, "Instance entry not found.")
self.db_session.expunge_all()
self.db_session.commit()
self.db_session.close()
self.logger.info("Done.")
return JSONAsyncResult(
200, {
'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':
[group.group_name for group in instance.groups],
'enabled_plugins':
[plugin.plugin_name for plugin in instance.plugins],
'groups': [{
'name': group.group_name,
'description': group.group_description
} for group in groups],
'loaded_plugins':
self.application.loaded_plugins
})
except (TemboardUIError, Exception) as e:
self.logger.traceback(get_tb())
self.logger.error(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 load_auth_cookie(self,):
"""
Try to load secure cookie content.
"""
cookie_content = self.get_secure_cookie('temboard')
if cookie_content is None:
raise TemboardUIError(302, "Authentication cookie is missing.")
self.auth_cookie = cookie_content
