def push_data(self,): key = self.request.headers.get('X-Key') if not key: return JSONAsyncResult(http_code = 401, data = {'error': 'X-Key header missing'}) try: data = tornado.escape.json_decode(self.request.body) # Insert data in an other thread. except Exception as e: return JSONAsyncResult(http_code = 500, data = {'error': e.message}) try: # We need to use a scoped_session object here as far the # code below is executed in its own thread. session_factory = sessionmaker(bind=self.engine) Session = scoped_session(session_factory) thread_session = Session() # Check the key if data['instances'][0]['available']: check_agent_key(thread_session, data['hostinfo']['hostname'], data['instances'][0]['data_directory'], data['instances'][0]['port'], key) else: # Case when PostgreSQL instance is not started. check_host_key(thread_session, data['hostinfo']['hostname'], key) # Update the inventory host = merge_agent_info(thread_session, data['hostinfo'], data['instances']) # Send the write SQL commands to the database because the # metrics are inserted with queries not the orm. Tables must # be there. thread_session.flush() thread_session.commit() # Insert metrics data insert_metrics(thread_session, host, data['data'], self.logger, data['hostinfo']['hostname']) # Close the session thread_session.close() return JSONAsyncResult(http_code = 200, data = {'done': True}) except IntegrityError as e: self.logger.traceback(get_tb()) self.logger.error(str(e)) try: thread_session.rollback() thread_session.close() except Exception: pass return JSONAsyncResult(http_code = 409, data = {'error': e.message}) except Exception as e: self.logger.traceback(get_tb()) self.logger.error(str(e)) try: thread_session.rollback() thread_session.close() except Exception: pass return JSONAsyncResult(http_code = 500, data = {'error': e.message})
def post_register(self, ): try: data = tornado.escape.json_decode(self.request.body) if 'agent_address' not in data or data['agent_address'] is None: # Try to find agent's IP x_real_ip = self.request.headers.get("X-Real-IP") data['new_agent_address'] = x_real_ip or self.request.remote_ip else: data['new_agent_address'] = data['agent_address'] data['new_agent_port'] = data['agent_port'] self.request.body = tornado.escape.json_encode(data) self.logger.debug(data) self.logger.debug(self.request.body) return self.post_instance(None, None) 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(e.code, {'error': e.message}) else: return JSONAsyncResult(500, {'error': "Internal error."})
def insert_metrics(session, host, agent_data, logger, hostname): for metric in agent_data.keys(): # Do not try to insert empty lines if len(agent_data[metric]) == 0: continue # Find the name to the Table object if 'metric_' + metric in globals().keys(): table = globals()['metric_' + metric] else: continue # XXX The interval input must be a string to be cast by # PostgreSQL. It is used by the measure_interval value, which # come as a number for line in agent_data[metric]: if 'measure_interval' in line: line['measure_interval'] = str(line['measure_interval']) # Add hostname from hostinfo to each line line['hostname'] = hostname try: session.execute(table.insert().values(agent_data[metric])) session.flush() session.commit() except Exception as e: logger.info("Metric data not inserted in table '%s'" % (table.name)) logger.debug(agent_data[metric]) logger.traceback(get_tb()) logger.error(str(e)) session.rollback()
def worker_data_agg(task): try: parameters = json.loads(task.parameters) config = Configuration(parameters['configpath']) set_logger_name("worker_data_agg") logger = get_logger(config) dburi = 'postgresql://{user}:{password}@{host}:{port}/{dbname}'.format( user = config.repository['user'], password = config.repository['password'], host = config.repository['host'], port = config.repository['port'], dbname = config.repository['dbname']) engine = create_engine(dburi) with engine.connect() as conn: conn.execute("SET search_path TO supervision") res = conn.execute("SELECT * FROM metric_populate_agg_tables()") for row in res.fetchall(): logger.debug("table=%s insert=%s" % (row['agg_tablename'], row['nb_insert'])) conn.execute("COMMIT") exit(0) except (ConfigurationError, ImportError, Exception) as e: try: logger.traceback(get_tb()) logger.error(str(e)) try: conn.execute("ROLLBACK") except Exception as e: pass except Exception: pass exit(1)
def get_discover(self, agent_address, agent_port): try: self.logger.info("Getting discovery.") self.load_auth_cookie() self.start_db_session() self.check_admin() self.db_session.close() res = temboard_discover(self.ssl_ca_cert_file, agent_address, agent_port) self.logger.info("Done.") return JSONAsyncResult(200, 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(e.code, {'error': e.message}) else: return JSONAsyncResult(500, {'error': "Internal error."})
def delete_instance(self): try: self.logger.info("Deleting instance.") self.load_auth_cookie() self.start_db_session() 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.db_session.commit() self.db_session.close() self.logger.info("Done.") return JSONAsyncResult(200, {'delete': True}) 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 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 get_current_user(self, ): if self.auth_cookie and self.db_session: try: return get_role_by_cookie(self.db_session, self.auth_cookie) except Exception as e: self.logger.traceback(get_tb()) self.logger.error(e.message) return
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.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 get_activity_w_b(self, agent_address, agent_port, mode): try: self.logger.info("Getting waiting/blocking sessions (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') # 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.") self.logger.info("Done.") return JSONAsyncResult(http_code=200, data=data_activity) 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 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.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 start_db_session(self): """ Try to start a new DB session (local to current thread). """ MetaData.bind = self.application.engine try: session_factory = sessionmaker(bind=self.application.engine) Session = scoped_session(session_factory) self.db_session = Session() except Exception as e: self.logger.traceback(get_tb()) self.logger.error(e.message) raise TemboardUIError(500, "Unable to create a new database session.")
def prepare(self): # Incorporate request JSON into arguments dictionary. if self.request.body: try: json_data = json.loads(self.request.body) self.request.arguments.update(json_data) except Exception as e: self.logger.traceback(get_tb()) self.logger.error(e.message) message = 'Unable to parse JSON.' self.send_error(400, error=message) # Set up response dictionary. self.response = dict()
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 post_login(self, agent_address, agent_port): try: self.logger.info("Posting to agent login.") 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) self.db_session.expunge_all() self.db_session.commit() self.db_session.close() xsession = temboard_login(self.ssl_ca_cert_file, instance.agent_address, instance.agent_port, self.get_argument("username"), self.get_argument("password")) self.set_secure_cookie( "temboard_%s_%s" % (instance.agent_address, instance.agent_port), xsession, expires_days=0.5) self.logger.info("Done.") return HTMLAsyncResult( http_code = 302, redirection = self.get_secure_cookie('referer_uri') \ if self.get_secure_cookie('referer_uri') is not None \ else "/server/%s/%s/dashboard" % (instance.agent_address, instance.agent_port)) except (TemboardError, 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 as e: pass return HTMLAsyncResult(http_code=200, template_file='agent-login.html', data={ 'nav': True, 'error': e.message, 'instance': instance, 'username': None })
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 get_login(self): role = None try: self.load_auth_cookie() self.start_db_session() role = self.current_user self.db_session.expunge_all() self.db_session.commit() self.db_session.close() except Exception as e: self.logger.traceback(get_tb()) self.logger.error(str(e)) if role is not None: return HTMLAsyncResult(http_code=302, redirection='/home') return HTMLAsyncResult(http_code=200, template_file='login.html', data={'nav': False})
def get_home(self): try: self.logger.info("Loading home.") self.load_auth_cookie() self.start_db_session() role = self.current_user if not role: raise TemboardUIError(302, 'Current role unknown.') instance_list = get_instances_by_role_name(self.db_session, role.role_name) self.db_session.expunge_all() self.db_session.commit() self.db_session.close() self.logger.info("Done.") return HTMLAsyncResult(http_code=200, template_file='home.html', data={ 'nav': True, 'role': role, 'instance_list': instance_list }) except (TemboardUIError, Exception) as e: self.logger.traceback(get_tb()) self.logger.error(str(e)) self.logger.info("Failed.") try: self.db_session.expunge_all() 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='error.html')
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='manage/group.html') 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): 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='manage/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.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 post_login(self): try: self.logger.info("Login (API).") post = tornado.escape.json_decode(self.request.body) p_role_name = post['username'] p_role_password = post['password'] role_hash_password = hash_password(p_role_name, p_role_password) self.start_db_session() role = get_role_by_auth(self.db_session, p_role_name, role_hash_password) self.logger.info("Role '%s' authentificated." % (role.role_name)) self.db_session.expunge_all() self.db_session.commit() self.db_session.close() sleep(1) self.logger.info("Done.") return JSONAsyncResult(http_code=200, data={"message": "OK"}, secure_cookie={ 'name': 'temboard', 'content': gen_cookie(role.role_name, role_hash_password) }) except (TemboardUIError, Exception) as e: try: self.db_session.rollback() self.db_session.close() except Exception: pass self.logger.traceback(get_tb()) self.logger.error(str(e)) self.logger.info("Failed.") sleep(1) return JSONAsyncResult(http_code=401, data={"error": "Wrong username/password."})
def post_login(self): try: self.logger.info("Login.") p_role_name = self.get_argument('username') p_role_password = self.get_argument('password') role_hash_password = hash_password(p_role_name, p_role_password) self.start_db_session() role = get_role_by_auth(self.db_session, p_role_name, role_hash_password) self.logger.info("Role '%s' authentificated." % (role.role_name)) self.db_session.expunge_all() self.db_session.commit() self.db_session.close() sleep(1) self.logger.info("Done.") return HTMLAsyncResult( http_code=302, redirection=self.get_secure_cookie('referer_uri') if self.get_secure_cookie('referer_uri') is not None else '/home', secure_cookie={ 'name': 'temboard', 'content': gen_cookie(role.role_name, role_hash_password) }) except (TemboardUIError, Exception) as e: try: self.db_session.rollback() self.db_session.close() except Exception: pass self.logger.traceback(get_tb()) self.logger.error(str(e)) self.logger.info("Failed.") sleep(1) return HTMLAsyncResult(http_code=401, template_file='login.html', data={ 'nav': False, 'error': 'Wrong username/password.' })
def load_plugins(plugin_names, config): """ Intend to load plugins and run their configuration() function. Plugins are defined as a module located in plugins/ directory. Plugins list to load is declared into temboard section of the configuration file: [temboard] plugins = [ "plugin1", "plugin2" ] """ # Get this module's path. path = os.path.dirname(os.path.realpath(__file__)) ret = dict() # Get the logger. logger = get_logger(config) # Loop through declared plugins. for plugin_name in plugin_names: # Locate and load the module with imp. logger.info("Loading plugin '%s'." % (plugin_name, )) fp, pathname, description = imp.find_module(plugin_name, [path + '/plugins']) try: module = imp.load_module(plugin_name, fp, pathname, description) # Try to run module's configuration() function. logger.info("Loading plugin '%s' configuration." % (plugin_name, )) ret.update({ module.__name__: { 'configuration': getattr(module, 'configuration')(config), 'routes': getattr(module, 'get_routes')(config) } }) fp.close() except AttributeError as e: if fp: fp.close() except Exception as e: logger.traceback(get_tb()) logger.error(str(e)) return ret
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.traceback(get_tb()) self.logger.error(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."})
def get_activity(self, agent_address, agent_port): try: self.logger.info("Getting activity.") 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 activated.") 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.") # Load activity. activity_data = temboard_activity(self.ssl_ca_cert_file, instance.agent_address, instance.agent_port, xsession) self.logger.info("Done.") return HTMLAsyncResult(http_code=200, template_path=self.template_path, template_file='activity.html', data={ 'nav': True, 'role': role, 'instance': instance, 'activities': activity_data, 'xsession': xsession }) except (TemboardUIError, TemboardError, Exception) as e: self.logger.traceback(get_tb()) self.logger.error(str(e)) self.logger.info("Failed.") try: self.db_session.expunge_all() self.db_session.rollback() self.db_session.close() except Exception: pass if (isinstance(e, TemboardUIError) or isinstance(e, TemboardError)): if e.code == 401: return HTMLAsyncResult(http_code=401, redirection="/server/%s/%s/login" % (agent_address, agent_port)) elif 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, 'role': role, 'instance': instance, 'code': e.code, 'error': e.message })
def get_dashboard(self, agent_address, agent_port): try: self.logger.info("Getting dashboard.") 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.") dashboard_history = temboard_dashboard_history( self.ssl_ca_cert_file, instance.agent_address, instance.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, instance.agent_address, instance.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': role, 'instance': instance, 'dashboard': last_data, 'history': history, 'buffers_delta': 0, 'readratio': (100 - last_data['hitratio']), 'xsession': xsession }) except (TemboardUIError, TemboardError, Exception) as e: self.logger.traceback(get_tb()) self.logger.error(str(e)) self.logger.info("Failed.") try: self.db_session.expunge_all() self.db_session.rollback() self.db_session.close() except Exception: pass if (isinstance(e, TemboardUIError) or isinstance(e, TemboardError)): if e.code == 401: return HTMLAsyncResult(http_code=401, redirection="/server/%s/%s/login" % (agent_address, agent_port)) elif 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, 'role': role, 'instance': instance, 'code': e.code, 'error': e.message })
def post_configuration(self, agent_address, agent_port, category=None): try: self.logger.info("Posting configuration.") 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.") query_filter = self.get_argument('filter', None, True) error_code = None error_message = None post_settings = self.request.arguments ret_post = None settings = {'settings': []} for setting_name, setting_value in post_settings.iteritems(): # 'filter' is not a setting, just ignore it. if setting_name == 'filter': continue settings['settings'].append({ 'name': setting_name, 'setting': setting_value[0] }) try: # Try to send settings to the agent. ret_post = temboard_post_configuration(self.ssl_ca_cert_file, instance.agent_address, instance.agent_port, xsession, settings) except TemboardError as e: error_code = e.code error_message = e.message # Get PostgreSQL configuration status: needs restart, reload or is fine. configuration_status = temboard_get_configuration_status( self.ssl_ca_cert_file, instance.agent_address, instance.agent_port, xsession) # Load settings categories. configuration_cat = temboard_get_configuration_categories( self.ssl_ca_cert_file, instance.agent_address, instance.agent_port, xsession) if category == None: category = tornado.escape.url_escape( configuration_cat['categories'][0]) # Load settings depending on the current category or the filter value. configuration_data = temboard_get_configuration( self.ssl_ca_cert_file, instance.agent_address, instance.agent_port, xsession, tornado.escape.url_escape( tornado.escape.url_unescape(category)), query_filter) self.logger.info("Done.") return HTMLAsyncResult(http_code=200, template_path=self.template_path, template_file='configuration.html', data={ 'nav': True, 'role': role, 'instance': instance, 'data': configuration_data, 'xsession': xsession, 'current_cat': tornado.escape.url_unescape(category), 'configuration_categories': configuration_cat, 'configuration_status': configuration_status, 'error_code': error_code, 'error_message': error_message, 'ret_post': ret_post, 'query_filter': query_filter }) except (TemboardUIError, TemboardError, Exception) as e: self.logger.traceback(get_tb()) self.logger.error(str(e)) self.logger.info("Failed.") try: self.db_session.expunge_all() self.db_session.rollback() self.db_session.close() except Exception: pass if (isinstance(e, TemboardUIError) or isinstance(e, TemboardError)): if e.code == 401: return HTMLAsyncResult(http_code=401, redirection="/server/%s/%s/login" % (agent_address, agent_port)) elif 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, 'role': role, 'instance': instance, 'code': e.code, 'error': e.message })
def get_configuration_file(self, agent_address, agent_port): try: self.logger.info("Getting configuration (file).") instance = None role = None self.load_auth_cookie() self.start_db_session() mode = self.get_argument('mode', None) version = self.get_argument('version', None) role = self.current_user if not role: raise TemboardUIError(302, "Current role unknown.") if mode is None and len(self.available_modes) > 0: mode = self.available_modes[0] if not (mode in self.available_modes): raise TemboardUIError(404, "Editing mode not available.") 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.") file_versions = temboard_get_conf_file_versions( self.ssl_ca_cert_file, self.file_type, instance.agent_address, instance.agent_port, xsession) if mode == 'raw': # Load file content. conf_file_raw = temboard_get_conf_file_raw( self.ssl_ca_cert_file, self.file_type, version, instance.agent_address, instance.agent_port, xsession) self.logger.info("Done.") return HTMLAsyncResult(http_code=200, template_path=self.template_path, template_file='edit_conf_file_raw.html', data={ 'nav': True, 'role': role, 'instance': instance, 'file_versions': file_versions, 'file_type': self.file_type, 'conf_file_raw': conf_file_raw, 'xsession': xsession }) if mode == 'advanced': hba_options = None if self.file_type == 'hba': hba_options = temboard_get_hba_options( self.ssl_ca_cert_file, instance.agent_address, instance.agent_port, xsession) conf_file = temboard_get_conf_file(self.ssl_ca_cert_file, self.file_type, version, instance.agent_address, instance.agent_port, xsession) self.logger.info("Done.") return HTMLAsyncResult( http_code=200, template_path=self.template_path, template_file='edit_conf_file_advanced.html', data={ 'nav': True, 'role': role, 'instance': instance, 'file_versions': file_versions, 'file_type': self.file_type, 'conf_file': conf_file, 'hba_options': hba_options, 'xsession': xsession }) except (TemboardUIError, TemboardError, Exception) as e: self.logger.traceback(get_tb()) self.logger.error(str(e)) self.logger.info("Failed.") try: self.db_session.expunge_all() self.db_session.rollback() self.db_session.close() except Exception: pass if (isinstance(e, TemboardUIError) or isinstance(e, TemboardError)): if e.code == 401: return HTMLAsyncResult(http_code=401, redirection="/server/%s/%s/login" % (agent_address, agent_port)) elif 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, 'role': role, 'instance': instance, 'code': e.code, 'error': e.message })
def get_configuration(self, agent_address, agent_port, category=None): try: self.logger.info("Getting configuration.") 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.") configuration_status = temboard_get_configuration_status( self.ssl_ca_cert_file, instance.agent_address, instance.agent_port, xsession) configuration_cat = temboard_get_configuration_categories( self.ssl_ca_cert_file, instance.agent_address, instance.agent_port, xsession) query_filter = self.get_argument('filter', None, True) if category == None: category = tornado.escape.url_escape( configuration_cat['categories'][0]) configuration_data = temboard_get_configuration( self.ssl_ca_cert_file, instance.agent_address, instance.agent_port, xsession, tornado.escape.url_escape( tornado.escape.url_unescape(category)), query_filter) self.logger.info("Done.") return HTMLAsyncResult(http_code=200, template_path=self.template_path, template_file='configuration.html', data={ 'nav': True, 'role': role, 'instance': instance, 'data': configuration_data, 'xsession': xsession, 'current_cat': tornado.escape.url_unescape(category), 'configuration_categories': configuration_cat, 'configuration_status': configuration_status, 'query_filter': query_filter }) except (TemboardUIError, TemboardError, Exception) as e: self.logger.traceback(get_tb()) self.logger.error(str(e)) self.logger.info("Failed.") try: self.db_session.expunge_all() self.db_session.rollback() self.db_session.close() except Exception: pass if (isinstance(e, TemboardUIError) or isinstance(e, TemboardError)): if e.code == 401: return HTMLAsyncResult(http_code=401, redirection="/server/%s/%s/login" % (agent_address, agent_port)) elif 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, 'role': role, 'instance': instance, 'code': e.code, 'error': e.message })
def post_configuration_file(self, agent_address, agent_port): error_code = None error_message = None ret_post = None try: self.logger.info("Posting configuration (file).") 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.") try: # Send file content .. ret_post = temboard_post_file_content( self.ssl_ca_cert_file, self.file_type, instance.agent_address, instance.agent_port, xsession, { 'content': self.request.arguments['content'][0], 'new_version': True }) # .. and reload configuration. ret_post = temboard_post_administration_control( self.ssl_ca_cert_file, instance.agent_address, instance.agent_port, xsession, {'action': 'reload'}) except (TemboardError, Exception) as e: self.logger.traceback(get_tb()) self.logger.error(str(e)) if isinstance(TemboardError, e): error_code = e.code error_message = e.message else: error_code = 500 error_message = "Internale error." # Load file content. file_content = temboard_get_file_content(self.ssl_ca_cert_file, self.file_type, instance.agent_address, instance.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': role, 'instance': instance, 'file_type': self.file_type, 'file_content': file_content, 'error_code': error_code, 'error_message': error_message, 'xsession': xsession, 'ret_post': ret_post }) except (TemboardUIError, TemboardError, Exception) as e: self.logger.traceback(get_tb()) self.logger.error(str(e)) self.logger.info("Failed.") try: self.db_session.expunge_all() self.db_session.rollback() self.db_session.close() except Exception: pass if (isinstance(e, TemboardUIError) or isinstance(e, TemboardError)): if e.code == 401: return HTMLAsyncResult(http_code=401, redirection="/server/%s/%s/login" % (agent_address, agent_port)) elif 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, 'role': role, 'instance': instance, 'code': e.code, 'error': e.message })