def put(self, agent_id): username = self.get_current_user() customer_name = get_current_customer_name(username) uri = self.request.uri method = self.request.method try: logger.info(self.request.body) oper_id = self.arguments.get('operation_id') data = self.arguments.get('data') apps_to_delete = self.arguments.get('apps_to_delete', []) apps_to_add = self.arguments.get('apps_to_add', []) error = self.arguments.get('error', None) reboot_required = self.arguments.get('reboot_required') app_id = self.arguments.get('app_id') success = self.arguments.get('success') results = (AddAppResults(username, uri, method, agent_id, app_id, oper_id, reboot_required, success, data, apps_to_delete, apps_to_add, error)) results_data = results.install_os_apps(data) self.set_status(results_data['http_status']) self.set_header('Content-Type', 'application/json') self.write(dumps(results_data, indent=4)) send_notifications(username, customer_name, oper_id, agent_id) except Exception as e: results = (GenericResults(username, uri, method).something_broke( agent_id, 'uninstall_os_apps results', e)) logger.exception(results) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(dumps(results, indent=4))
def get(self): username = self.get_current_user().encode('utf-8') customer_name = get_current_customer_name(username) uri = self.request.uri method = self.request.method try: results = ( customer_apps_by_type_count( username, customer_name, uri, method ) ) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4)) except Exception as e: results = ( GenericResults( username, uri, method ).something_broke('widget handler', 'widgets', e) ) logger.exception(results) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4))
def get(self): username = self.get_current_user() customer_name = get_current_customer_name(username) uri = self.request.uri method = self.request.method try: results = None os_code = self.get_argument('os_code', None) tag_id = self.get_argument('tag_id', None) results = systems_cpu_details(username=username, customer_name=customer_name, tag_id=tag_id, os_code=os_code, uri=uri, method=method) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4)) except Exception as e: results = (GenericResults(username, uri, method).something_broke( 'no stats', '', e)) logger.exception(e) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4))
def get(self, tag_id): username = self.get_current_user().encode('utf-8') customer_name = get_current_customer_name(username) uri = self.request.uri method = self.request.method try: count = self.get_argument('limit', 3) results = ( tag_stats_by_os( username, customer_name, uri, method, tag_id, count ) ) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4)) except Exception as e: results = ( GenericResults( username, uri, method ).something_broke('customer os stats', 'os stats', e) ) logger.exception(results) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4))
def get(self, tag_id): username = self.get_current_user().encode('utf-8') customer_name = get_current_customer_name(username) uri = self.request.uri method = self.request.method try: results = ( get_severity_bar_chart_stats_for_tag( username, customer_name, uri, method, tag_id ) ) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4)) except Exception as e: results = ( GenericResults( username, uri, method ).something_broke('tag severity stats', 'sev stats', e) ) logger.exception(results) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4))
def get(self, tag_id): username = self.get_current_user().encode('utf-8') customer_name = get_current_customer_name(username) uri = self.request.uri method = self.request.method try: status = self.get_argument('status', 'available') start_date = self.get_argument('start_date', None) end_date = self.get_argument('end_date', None) if start_date: start_date = int(start_date) if end_date: end_date = int(end_date) results = ( get_os_apps_history_for_tag( username, customer_name, uri, method, tag_id, status, start_date, end_date ) ) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4)) except Exception as e: results = ( GenericResults( username, uri, method ).something_broke('customer os stats', 'os stats', e) ) logger.exception(results) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4))
def add_tags_to_agent(self, tag_id, agent_id, conn=None): try: tag_for_agent_exists = list( r.table(TagsPerAgentCollection).get_all( [agent_id, tag_id], index=TagsPerAgentIndexes.AgentIdAndTagId).run(conn)) tag_info = r.table(TagsCollection).get(tag_id).run(conn) tag_name = tag_info[TagsKey.TagName] if not tag_for_agent_exists: agent_info = ( r.table(AgentsCollection).get(agent_id).run(conn)) if agent_info: tag_agent_info = ({ TagsPerAgentKey.AgentId: agent_id, TagsPerAgentKey.TagId: tag_id, }) add_agent_to_tag = (r.table(TagsPerAgentCollection).insert( tag_agent_info).run(conn)) if 'inserted' in add_agent_to_tag: status = (GenericResults(self.username, self.uri, self.method).object_updated( tag_id, 'tag_id', tag_agent_info)) logger.info(status['message']) else: status = (GenericResults(self.username, self.uri, self.method).object_exists( tag_id, 'tag')) logger.warn(status['message']) except Exception as e: status = (GenericResults(self.username, self.uri, self.method).something_broke( tag_id, 'adding tag to agent', e)) logger.exception(e) return (status)
def post(self, tag_id): username = self.get_current_user() customer_name = get_current_customer_name(username) uri = self.request.uri method = self.request.method try: reboot = self.arguments.get('reboot', None) shutdown = self.arguments.get('shutdown', None) apps_refresh = self.arguments.get('apps_refresh', None) operation = ( StoreOperation( username, customer_name, uri, method ) ) if reboot: results = ( operation.reboot(tag_id) ) elif shutdown: results = ( operation.shutdown(tag_id) ) elif apps_refresh: results = ( operation.apps_refresh(tag_id) ) else: results = ( GenericResults( username, uri, method ).incorrect_arguments() ) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4)) except Exception as e: results = ( GenericResults( username, uri, method ).something_broke(tag_id, '', e) ) logger.exception(e) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4))
def tag_stats_by_os(username, customer_name, uri, method, tag_id, count=3, conn=None): try: stats = ( r .table(TagsPerAgentCollection, use_outdated=True) .get_all(tag_id, index=TagsPerAgentIndexes.TagId) .pluck(TagsPerAgentKey.AgentId) .eq_join( lambda x: [ AVAILABLE, x[AppsPerAgentKey.AgentId] ], r.table(AppsPerAgentCollection), index=AppsPerAgentIndexes.StatusAndAgentId ) .zip() .eq_join(AgentKey.AgentId, r.table(AgentsCollection)) .zip() .pluck(APP_ID, AgentKey.OsString) .distinct() .group_by(AgentKey.OsString, r.count) .order_by(r.desc('reduction')) .limit(count) .run(conn) ) data = [] if stats: data = app_stats_by_os(stats) results = ( GenericResults( username, uri, method ).information_retrieved(data, count) ) except Exception as e: results = ( GenericResults( username, uri, method ).something_broke('tag widget stats', 'widget', e) ) logger.exception(results) return(results)
def get_all_agents(self, conn=None): try: count = ( r .table(AgentsCollection) .get_all(self.customer_name, index=AgentKey.CustomerName) .count() .run(conn) ) data = list( r .table(AgentsCollection) .get_all(self.customer_name, index=AgentKey.CustomerName) .order_by(AgentKey.ComputerName) .pluck(self.keys_to_pluck) .order_by(self.sort(self.sort_key)) .skip(self.offset) .limit(self.count) .run(conn) ) if data: for agent in data: agent[BASIC_RV_STATS] = ( get_all_app_stats_by_agentid( self.username, self.customer_name, self.uri, self.method, agent[AgentKey.AgentId] )['data'] ) status = ( GenericResults( self.username, self.uri, self.method ).information_retrieved(data, count) ) logger.info(status['message']) except Exception as e: status = ( GenericResults( self.username, self.uri, self.method ).something_broke('get_all_agents', 'agent', e) ) return(status)
def filter_by_status(self, pkg_status, conn=None): try: agent = get_agent_info(self.agent_id) if agent: if pkg_status in ValidPackageStatuses: base = (r.table( self.CurrentAppsPerAgentCollection, use_outdated=True).get_all( [pkg_status, self.agent_id], index=self.CurrentAppsPerAgentIndexes. StatusAndAgentId).eq_join( self.CurrentAppsPerAgentKey.AppId, r.table(self.CurrentAppsCollection)).zip()) if self.show_hidden == NO: base = base.filter({self.CurrentAppsKey.Hidden: NO}) packages = list( base.map(self.map_hash).order_by( self.sort(self.sort_key)).skip(self.offset).limit( self.count).run(conn)) pkg_count = (base.count().run(conn)) return_status = (GenericResults( self.username, self.uri, self.method).information_retrieved( packages, pkg_count)) else: return_status = (PackageResults( self.username, self.uri, self.method).invalid_status(self.agent_id, pkg_status)) else: return_status = (GenericResults(self.username, self.uri, self.method).invalid_id( self.agent_id, 'agents')) except Exception as e: return_status = (GenericResults( self.username, self.uri, self.method).something_broke("Package Searching went haywire", 'os_updates', e)) logger.exception(e) return (return_status)
def get(self, agent_id): username = self.get_current_user().encode('utf-8') customer_name = get_current_customer_name(username) query = self.get_argument('query', None) count = int(self.get_argument('count', 30)) offset = int(self.get_argument('offset', 0)) status = self.get_argument('status', 'installed') severity = self.get_argument('severity', None) sort = self.get_argument('sort', 'asc') sort_by = self.get_argument('sort_by', CustomAppsKey.Name) hidden = self.get_argument('hidden', 'false') if hidden == 'false': hidden = NO else: hidden = YES uri = self.request.uri method = self.request.method patches = (RetrieveCustomAppsByAgentId(username, customer_name, agent_id, uri, method, count, offset, sort, sort_by, show_hidden=hidden)) if not query and not severity and status: results = patches.filter_by_status(status) elif not query and status and severity: results = patches.filter_by_status_and_sev(status, severity) elif severity and not query and not status: results = patches.filter_by_severity(severity) elif severity and status and query: results = (patches.filter_by_status_and_query_by_name_and_sev( query, status, severity)) elif status and query: results = (patches.filter_by_status_and_query_by_name( query, status)) elif severity and query: results = (patches.filter_by_sev_and_query_by_name( query, severity)) elif query and not severity and not status: results = patches.query_by_name(query) else: results = (GenericResults(username, uri, method).incorrect_arguments()) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4))
def post(self, app_id): username = self.get_current_user().encode('utf-8') customer_name = get_current_customer_name(username) uri = self.request.uri method = self.request.method try: severity = self.arguments.get('severity').capitalize() if severity in ValidRvSeverities: sev_data = ( { AppsKey.RvSeverity: severity } ) update_os_app( app_id, sev_data ) results = ( GenericResults( username, uri, method ).object_updated(app_id, 'app severity', [sev_data]) ) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4)) else: results = ( PackageResults( username, uri, method ).invalid_severity(severity) ) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4)) except Exception as e: results = ( GenericResults( username, uri, method ).something_broke(app_id, 'update_severity', e) ) logger.exception(e) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4))
def get_by_app_id(self, stats=False, conn=None): """ """ try: pkg = list( r .table(self.CurrentAppsCollection, use_outdated=True) .get_all(self.app_id, index=self.CurrentAppsIndexes.AppId) .map(self.map_hash) .run(conn) ) if pkg: pkg[0][self.CurrentAppsKey.FileData] = get_file_data(self.app_id) if stats: pkg[0]['agent_stats'] = ( get_all_stats_by_appid( self.username, self.customer_name, self.uri, self.method, self.app_id, table=self.CurrentAppsPerAgentCollection )['data'] ) status = ( GenericResults( self.username, self.uri, self.method ).information_retrieved(pkg[0], 1) ) else: status = ( GenericResults( self.username, self.uri, self.method ).invalid_id(self.app_id, 'package') ) except Exception as e: status = ( GenericResults( self.username, self.uri, self.method ).something_broke(self.app_id, 'package', e) ) logger.exception(e) return(status)
def customer_stats_by_os(username, customer_name, uri, method, count=3, conn=None): try: stats = ( r .table(AppsPerAgentCollection, use_outdated=True) .get_all( [AVAILABLE, customer_name], index=AppsPerAgentIndexes.StatusAndCustomer ) .eq_join(AgentKey.AgentId, r.table(AgentsCollection)) .map( { AppsKey.AppId: r.row['left'][AppsKey.AppId], AgentKey.OsString: r.row['right'][AgentKey.OsString] } ) .pluck(AppsKey.AppId, AgentKey.OsString) .distinct() .group_by(AgentKey.OsString, r.count) .order_by(r.desc('reduction')) .limit(count) .run(conn) ) data = [] if stats: data = app_stats_by_os(stats) results = ( GenericResults( username, uri, method ).information_retrieved(data, count) ) except Exception as e: results = ( GenericResults( username, uri, method ).something_broke('widget stats', 'widget', e) ) logger.exception(results) return(results)
def query_by_name(self, name, conn=None): try: tag = tag_exists(self.tag_id) if tag: base = (r.table( TagsPerAgentCollection, use_outdated=True ).get_all(self.tag_id, index=TagsPerAgentIndexes.TagId).pluck( TagsPerAgentKey.AgentId).eq_join( self.CurrentAppsPerAgentIndexes.AgentId, r.table(self.CurrentAppsPerAgentCollection), index=self.CurrentAppsPerAgentIndexes.AgentId).eq_join( lambda y: y['right'][self.CurrentAppsKey.AppId], r.table(self.CurrentAppsCollection)).map( self.map_hash)) if self.show_hidden == NO: base = base.filter({self.CurrentAppsKey.Hidden: NO}) packages = list( base.filter(lambda x: x[self.CurrentAppsKey.Name].match( "(?i)" + name)).distinct().order_by( self.sort(self.sort_key)).skip(self.offset).limit( self.count).run(conn)) pkg_count = ( base.filter(lambda x: x[self.CurrentAppsKey.Name].match( "(?i)" + name)).distinct().count().run(conn)) return_status = (GenericResults( self.username, self.uri, self.method).information_retrieved(packages, pkg_count)) else: return_status = (GenericResults(self.username, self.uri, self.method).invalid_id( self.tag_id, 'tags')) except Exception as e: return_status = (GenericResults( self.username, self.uri, self.method).something_broke("Package Searching went haywire", 'os_updates', e)) logger.exception(e) return (return_status)
def move_packages(username, customer_name, uri, method, name=None, path=None, size=None, md5=None, uuid=None, conn=None): files_stored = list() PKG_DIR = None FILE_PATH = None if name and uuid and path and size and md5: PKG_DIR = TMP_DIR + uuid + '/' FILE_PATH = PKG_DIR + name if not os.path.exists(PKG_DIR): try: os.mkdir(PKG_DIR) except Exception as e: logger.error(e) try: shutil.move(path, FILE_PATH) files_stored.append( { 'uuid': uuid, 'name': name, 'size': int(size), 'md5': md5, 'file_path': FILE_PATH } ) results = ( GenericResults( username, uri, method ).file_uploaded(name, files_stored) ) except Exception as e: results = ( GenericResults( username, uri, method ).file_failed_to_upload(name, e) ) logger.error(e) return(results)
def get_all_stats_by_appid(username, customer_name, uri, method, app_id, conn=None): data = [] try: apps = (r.table(CustomAppsPerAgentCollection).get_all( [app_id, customer_name], index=CustomAppsPerAgentIndexes.AppIdAndCustomer).group_by( CustomAppsPerAgentKey.Status, r.count).run(conn)) if apps: for i in apps: new_data = i['reduction'] new_data = ({ CustomAppsPerAgentKey.Status: i['group'][CustomAppsPerAgentKey.Status], COUNT: i['reduction'], NAME: i['group'][CustomAppsPerAgentKey.Status].capitalize() }) data.append(new_data) statuses = map(lambda x: x['status'], data) difference = set(ValidPackageStatuses).difference(statuses) if len(difference) > 0: for status in difference: status = {COUNT: 0, STATUS: status, NAME: status.capitalize()} data.append(status) results = (GenericResults(username, uri, method).information_retrieved( data, len(data))) logger.info(results) except Exception as e: results = (GenericResults(username, uri, method).something_broke( 'getting_pkg_stats', 'updates', e)) logger.info(results) return (results)
def add_agent_to_install_operation(self, agent_id, operation_id, applications, conn=None): try: (r.table(OperationsPerAgentCollection).insert({ OperationPerAgentKey.AgentId: agent_id, OperationPerAgentKey.OperationId: operation_id, OperationPerAgentKey.CustomerName: self.customer_name, OperationPerAgentKey.Status: PENDINGPICKUP, OperationPerAgentKey.PickedUpTime: r.epoch_time(0.0), OperationPerAgentKey.CompletedTime: r.epoch_time(0.0), OperationPerAgentKey.AppsTotalCount: len(applications), OperationPerAgentKey.AppsPendingCount: len(applications), OperationPerAgentKey.AppsFailedCount: self.INIT_COUNT, OperationPerAgentKey.AppsCompletedCount: self.INIT_COUNT, OperationPerAgentKey.Errors: None }).run(conn)) for app in applications: (r.table(OperationsPerAppCollection).insert({ OperationPerAppKey.AgentId: agent_id, OperationPerAppKey.OperationId: operation_id, OperationPerAppKey.CustomerName: self.customer_name, OperationPerAppKey.Results: OperationCodes.ResultsPending, OperationPerAppKey.ResultsReceivedTime: r.epoch_time(0.0), OperationPerAppKey.AppId: app[OperationPerAppKey.AppId], OperationPerAppKey.AppName: app[OperationPerAppKey.AppName], OperationPerAppKey.Errors: None }).run(conn)) except Exception as e: results = (GenericResults(self.username, self.uri, self.method).something_broke( operation_id, 'add agent to install operation', e)) logger.exception(results)
def get_all(self, conn=None): try: count = (r.table(TagsCollection).get_all( self.customer_name, index=TagsIndexes.CustomerName).count().run(conn)) data = list( r.table(TagsCollection).get_all( self.customer_name, index=TagsIndexes.CustomerName).order_by( self.sort(self.sort_key)).skip(self.qoffset).limit( self.qcount).run(conn)) if data: for tag in xrange(len(data)): data[tag][BASIC_RV_STATS] = (get_all_avail_stats_by_tagid( self.username, self.customer_name, self.uri, self.method, data[tag][TagsKey.TagId])['data']) agents_in_tag = list( r.table(TagsPerAgentCollection).get_all( data[tag][TagsPerAgentKey.TagId], index=TagsPerAgentIndexes.TagId).eq_join( TagsPerAgentKey.AgentId, r.table(AgentsCollection)).zip().pluck( TagsPerAgentKey.AgentId, AgentKey.ComputerName, AgentKey.DisplayName).run(conn)) data[tag]['agents'] = agents_in_tag status = (GenericResults(self.username, self.uri, self.method).information_retrieved( data, count)) logger.info(status['message']) except Exception as e: status = (GenericResults(self.username, self.uri, self.method).something_broke( 'get_all_tags', 'tags', e)) logger.exception(status['message']) return (status)
def get(self): username = self.get_current_user() customer_name = get_current_customer_name(username) uri = self.request.uri method = self.request.method data = {"uuid": gen_uuid()} results = (GenericResults(username, uri, method).information_retrieved(data, 0)) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4))
def create_tag(self, tag_name, prod_level='Production', conn=None): tag_id = None ninsert = { TagsKey.TagName: tag_name, TagsKey.CustomerName: self.customer_name, TagsKey.ProductionLevel: prod_level, } try: tag_exists = list( r.table(TagsCollection).get_all( [self.customer_name, tag_name], index=TagsIndexes.TagNameAndCustomer).pluck( TagsKey.TagId).run(conn)) if len(tag_exists) == 0: inserted = (r.table(TagsCollection).insert(ninsert).run(conn)) if 'inserted' in inserted: tag_id = inserted['generated_keys'][0] data = { TagsKey.TagId: tag_id, TagsKey.TagName: tag_name, } status = (GenericResults(self.username, self.uri, self.method).object_created( tag_id, tag_name, data)) logger.info(status['message']) else: status = (GenericResults(self.username, self.uri, self.method).object_exists( tag_id, tag_name)) logger.warn(status['message']) except Exception as e: status = (GenericResults(self.username, self.uri, self.method).something_broke( tag_name, 'while creating a tag', e)) logger.exception(e) return (status)
def put(self, app_id): username = self.get_current_user().encode('utf-8') customer_name = get_current_customer_name(username) uri = self.request.uri method = self.request.method try: agent_ids = self.arguments.get('agent_ids') epoch_time = self.arguments.get('time', None) label = self.arguments.get('label', None) restart = self.arguments.get('restart', 'none') cpu_throttle = self.arguments.get('cpu_throttle', 'normal') net_throttle = self.arguments.get('net_throttle', 0) if not epoch_time and not label and app_id: operation = (StoreOperation(username, customer_name, uri, method)) results = (operation.install_custom_apps([app_id], cpu_throttle, net_throttle, restart, agentids=agent_ids)) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4)) elif epoch_time and label and agent_ids: date_time = datetime.fromtimestamp(int(epoch_time)) sched = self.application.scheduler job = ({ 'cpu_throttle': cpu_throttle, 'net_throttle': net_throttle, 'pkg_type': 'custom_apps', 'restart': restart, 'app_ids': [app_id] }) add_install_job = (schedule_once(sched, customer_name, username, agent_ids=agent_ids, operation='install', name=label, date=date_time, uri=uri, method=method, job_extra=job)) result = add_install_job self.set_header('Content-Type', 'application/json') self.write(json.dumps(result)) except Exception as e: results = (GenericResults(username, uri, method).something_broke( app_id, 'install_custom_apps', e)) logger.exception(e) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4))
def get(self): username = self.get_current_user().encode('utf-8') uri = self.request.uri method = self.request.method try: data = get_production_levels() results = (GenericResults(username, uri, method).information_retrieved( data, len(data))) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4)) except Exception as e: results = (GenericResults(username, uri, method).something_broke( 'Get OS Codes', 'Agent', e)) logger.exception(e) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4))
def get_all_mouseys(username, uri, method, customer_name=None): conn = db_connect() try: if not customer_name: data = list(r.table(RelayServersCollection).run(conn)) else: data = list( r.table(RelayServersCollection).filter(lambda x: x[ RelayServers.Customers].contains(customer_name)).run(conn)) status = (GenericResults(username, uri, method).information_retrieved( data, len(data))) except Exception as e: status = (GenericResults(username, uri, method).something_broke( 'retreiving Relay Servers', 'RelayServers', e)) conn.close() return (status)
def filter_by_status_and_query_by_name(self, name, pkg_status, conn=None): try: if pkg_status in ValidPackageStatuses: base = (r.table(self.CurrentAppsPerAgentCollection).get_all( pkg_status, index=self.CurrentAppsPerAgentIndexes.Status).eq_join( self.CurrentAppsPerAgentKey.AppId, r.table(self.CurrentAppsCollection)).map( self.joined_map_hash)) if self.show_hidden == NO: base = base.filter({self.CurrentAppsKey.Hidden: NO}) packages = list( base.filter(lambda x: x[self.CurrentAppsKey.Name].match( "(?i)" + name)).distinct().order_by( self.sort(self.sort_key)).skip(self.offset).limit( self.count).run(conn)) pkg_count = (base.filter(lambda x: x[ self.CurrentAppsKey.Name].match("(?i)" + name)).pluck( self.CurrentAppsKey.AppId).count().run(conn)) return_status = (GenericResults( self.username, self.uri, self.method).information_retrieved(packages, pkg_count)) else: return_status = (PackageResults( self.username, self.uri, self.method).invalid_global_status(pkg_status)) except Exception as e: return_status = (GenericResults( self.username, self.uri, self.method).something_broke("Package Searching went haywire", 'os_updates', e)) logger.exception(e) return (return_status)
def get_tag(self, tag_id, conn=None): try: tag_info = (r.table(TagsCollection).get(tag_id).run(conn)) if tag_info: agents_in_tag = list( r.table(TagsPerAgentCollection).get_all( tag_id, index=TagsPerAgentIndexes.TagId).eq_join( TagsPerAgentKey.AgentId, r.table(AgentsCollection)).zip().pluck( TagsPerAgentKey.AgentId, AgentKey.ComputerName, AgentKey.DisplayName).run(conn)) tag_info[BASIC_RV_STATS] = (get_all_app_stats_by_tagid( self.username, self.customer_name, self.uri, self.method, tag_id)['data']) tag_info['agents'] = agents_in_tag status = (GenericResults(self.username, self.uri, self.method).information_retrieved( tag_info, 1)) logger.info(status['message']) else: status = (GenericResults(self.username, self.uri, self.method).invalid_id( tag_id, 'tag_id')) logger.info(status['message']) except Exception as e: status = (GenericResults(self.username, self.uri, self.method).something_broke( tag_id, 'tags', e)) logger.exception(status['message']) return (status)
def get_severity_bar_chart_stats_for_customer(username, customer_name, uri, method, conn=None): try: sevs = ( r .table(AppsPerAgentCollection, use_outdated=True) .get_all( [AVAILABLE, customer_name], index=AppsPerAgentIndexes.StatusAndCustomer ) .pluck(AppsKey.AppId) .distinct() .eq_join(AppsKey.AppId, r.table(AppsCollection)) .map( { AppsKey.AppId: r.row['right'][AppsKey.AppId], AppsKey.RvSeverity: r.row['right'][AppsKey.RvSeverity] } ) .group_by(AppsKey.RvSeverity, r.count) .order_by(r.asc('group')) .run(conn) ) data = app_stats_by_severity(sevs) results = ( GenericResults( username, uri, method ).information_retrieved(data, len(ValidRvSeverities)) ) except Exception as e: results = ( GenericResults( username, uri, method ).something_broke('widget severity stats', 'widget', e) ) logger.exception(results) return(results)
def post(self): username = self.get_current_user() customer_name = get_current_customer_name(username) uri = self.request.uri method = self.request.method try: result = None sched = self.application.scheduler operation = self.arguments.get('operation', None) pkg_type = self.arguments.get('pkg_type', None) jobname = self.arguments.get('jobname') severity = self.arguments.get('severity') node_ids = self.arguments.get('nodes', None) tag_ids = self.arguments.get('tags', None) all_agents = self.arguments.get('all_agents', False) all_tags = self.arguments.get('all_tags', False) every = self.arguments.get('every') custom = self.arguments.get('custom') epoch_time = self.arguments.get('epoch_time') datetime = datetime.fromtimestamp(epoch_time) results = (add_custom_recurrent( sched, agent_ids=node_ids, all_agents=all_agents, all_tags=all_tags, tag_ids=tag_ids, severity=severity, pkg_type=pkg_type, operation=operation, name=jobname, every=every, custom=custom, frequency=frequency, date=datetime, customer_name=customer_name, username=username, uri=uri, method=method, )) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4)) except Exception as e: results = (GenericResults(username, uri, method).something_broke( 'add custom recurrent schedule', '', e)) logger.exception(e) self.set_status(results['http_status']) self.set_header('Content-Type', 'application/json') self.write(json.dumps(results, indent=4))
def get_tags(self, uri=None, method=None, conn=None): try: tags = get_tags_by_agent_id(agent_id=self.agent_id) if tags: for i in range(len(tags)): name = tags[i].pop('tag_name') tags[i]['name'] = name tag_id = tags[i].pop('tag_id') tags[i]['id'] = tag_id status = (GenericResults(self.username, uri, method).information_retrieved(tags, 1)) logger.info(status['message']) except Exception as e: status = (GenericResults(self.username, uri, method).something_broke( self.agent_id, 'agent', e)) logger.error(status['message']) return (status)