def _insert_into_db(self, hwinfo=None, added_by='agent', agent_id=None, conn=None): collection = 'hardware_per_agent' added = True msg = '' logger.info(hwinfo) if hwinfo: try: if added_by == 'agent': (r.table(collection).get_all(agent_id, index='agent_id').filter({ 'added_by': added_by }).delete().run(conn)) for hw in hwinfo: (r.table(collection).insert(hw, upsert=True).run(conn)) msg = 'hardware added: %s' % (hwinfo) logger.info(msg) except Exception as e: added = False msg = ('Failed to add hardware: %s and %s' % (hwinfo, e)) logger.exception(msg) return (added, msg)
def fetch_agent_info(agent_id, keys_to_pluck=None, conn=None): """Retrieve information of an agent Args: agent_id(str): 36 character uuid of the agent you are updating Kwargs: keys_to_pluck(list): (Optional) Specific keys that you are retrieving from the database Basic Usage: >>> from vFense.core.agent._db import fetch_agent_info >>> agent_id = '52faa1db-290a-47a7-a4cf-e4ad70e25c38' >>> keys_to_pluck = ['production_level', 'needs_reboot'] >>> fetch_agent_info(agent_id, keys_to_pluck) Return: Dictionary of the agent data { u'agent_id': u'52faa1db-290a-47a7-a4cf-e4ad70e25c38', u'production_level': u'Development' } """ data = {} try: if agent_id and keys_to_pluck: data = r.table(AgentCollections.Agents).get(agent_id).merge(Merge.TAGS).pluck(keys_to_pluck).run(conn) elif agent_id and not keys_to_pluck: data = r.table(AgentCollections.Agents).get(agent_id).merge(Merge.TAGS).run(conn) except Exception as e: logger.exception(e) return data
def filter_by_and_query(username, customer_name, keys_to_pluck, key=AgentKey.ComputerName, count=30, offset=0, query=None, uri=None, method=None, conn=None): if query: count = (r.table(AgentsCollection).get_all( customer_name, index=AgentKey.CustomerName).filter( (r.row[AgentKey.ComputerName].match("(?i)" + query))).count().run(conn)) data = list( r.table(AgentsCollection).get_all( customer_name, index=AgentKey.CustomerName).filter( (r.row[key].match("(?i)" + query))).pluck( keys_to_pluck).skip(offset).limit(count).run(conn)) else: count = (r.table(AgentsCollection).get_all( customer_name, index=AgentKey.CustomerName).count().run(conn)) data = list( r.table(AgentsCollection).get_all( customer_name, index=AgentKey.CustomerName).pluck( keys_to_pluck).skip(offset).limit(count).run(conn)) return (data)
def get_all_agentids(username, customer_name, count=30, offset=0, uri=None, method=None, conn=None): try: count = (r.table(AgentsCollection).get_all( customer_name, index=AgentKey.CustomerName).count().run(conn)) data = list( r.table(AgentsCollection).get_all( customer_name, index=AgentKey.CustomerName).pluck(AgentKey.AgentId).order_by( AgentKey.ComputerName).skip(offset).limit(count).run(conn)) if data: for agent in data: agent[BASIC_RV_STATS] = (get_all_app_stats_by_agentid( agent[AgentKey.AgentId])) status = (GenericResults(username, uri, method).information_retrieved(data, count)) logger.info(status['message']) except Exception as e: status = (GenericResults(username, uri, method).something_broke( 'get_all_agents', 'agent', e)) return (status)
def _set_operation_per_agent_merge(self): agent_pluck = self._set_agent_collection_pluck() merge = ({ AgentOperationKey.CreatedTime: r.row[AgentOperationKey.CreatedTime].to_epoch_time(), AgentOperationKey.UpdatedTime: r.row[AgentOperationKey.UpdatedTime].to_epoch_time(), AgentOperationKey.CompletedTime: r.row[AgentOperationKey.CompletedTime].to_epoch_time(), OperationSearchValues.AGENTS: (r.table(OperationCollections.OperationPerAgent).get_all( r.row[AgentOperationKey.OperationId], index=OperationPerAgentIndexes.OperationId).coerce_to( 'array').eq_join(OperationPerAgentKey.AgentId, r.table(AgentCollections.Agents)).zip(). pluck(agent_pluck).merge( lambda x: { OperationPerAgentKey.PickedUpTime: x[OperationPerAgentKey.PickedUpTime].to_epoch_time(), OperationPerAgentKey.CompletedTime: x[OperationPerAgentKey.CompletedTime].to_epoch_time(), OperationPerAgentKey.ExpiredTime: x[OperationPerAgentKey.ExpiredTime].to_epoch_time(), })) }) return (merge)
def get_users_of_customer(customer_name=None, conn=None): if not customer_name: return None users = ( r.table(Collection.UsersPerCustomer) .get_all( customer_name, index=UsersPerCustomerKey.CustomerId ) .pluck(UsersPerCustomerKey.UserId) .eq_join( UsersPerCustomerKey.UserId, r.table(Collection.Users), index=UserKey.UserName ) .zip() .run(conn) ) u = [] for user in users: u.append(user) return u
def _set_agent_operation_base_query(self): base_filter = (r.table(OperationCollections.Agent)) if self.customer_name: base_filter = (r.table(OperationCollections.Agent).get_all( self.customer_name, index=AgentOperationIndexes.CustomerName)) return (base_filter)
def get_customers_of_user(user_name=None, conn=None): if not user_name: return None customers = ( r.table(Collection.UsersPerCustomer) .get_all( user_name, index=UsersPerCustomerKey.UserId ) .pluck(UsersPerCustomerKey.CustomerId) .eq_join( UsersPerCustomerKey.CustomerId, r.table(Collection.Customers), index=CustomerKey.CustomerName ) .zip() .run(conn) ) c = [] for customer in customers: c.append(customer) return c
def delete_multiple_jobs(job_ids, conn=None): """Delete all multiple jobs in the queue by job ids. DO NOT CALL DIRECTLY Args: job_ids (list): List of job ids to delete ['id1', 'id2'] Basic Usage: >>> from vFense.queue._db import delete_multiple_jobs >>> job_ids = ['id1', 'id2'] >>> delete_multiple_jobs(job_ids) Returns: Tuple (status_code, count, error, generated ids) >>> (2001, 1, None, []) """ jobs_deleted = 0 try: if isinstance(job_ids, list): jobs = r.table(QueueCollections.Agent).get_all(*job_ids).delete().run(conn) jobs_deleted = jobs.get("deleted") else: jobs = r.table(QueueCollections.Agent).get(job_ids).delete().run(conn) jobs_deleted = jobs.get("deleted") except Exception as e: logger.exception(e) return jobs_deleted
def get_sending_emails(self, notif_rules, conn=None): try: email_sender_list = [] for notif in notif_rules: if notif[NotificationKeys.Group]: users_list = (r.table(Collection.Groups).filter({ 'name': notif['group'] }).filter(lambda x: x['customer']['name'] == notif[ 'customer_name']).map(lambda x: x['users']).run(conn)) if users_list: users = map(lambda x: x['name'], user_list[0]) email_sender_list += (r.expr(users).map( lambda user: r.table('users').get(user)).map( lambda x: x['email']).run(conn)) elif notif[NotificationKeys.User]: email = (r.table(Collection.Users).get( notif[NotificationKeys.User]).pluck( UserKey.Email).run(conn)) if email: email_sender_list.append(email[UserKey.Email]) except Exception as e: logger.exception(e) return (email_sender_list)
def lower_version_exists_of_app(self, app, app_info, status=CommonAppKeys.AVAILABLE, conn=None): try: lower_version_exists = list( r.table(AppCollections.UniqueApplications).get_all( app_info[AppsKey.Name], index=AppsIndexes.Name).filter(lambda x: x[ AppsKey.Version] < app_info[AppsKey.Version]).eq_join( lambda y: [ app[AgentKey.AgentId], app[AppsPerAgentKey.AppId], ], r.table(AppCollections.AppsPerAgent), index=AppsPerAgentIndexes.AgentId).zip().filter({ AppsPerAgentKey.Status: status }).pluck(AppsKey.AppId, AppsPerAgentKey.Id, AppsKey.Name, AppsPerAgentKey.AgentId).run(conn)) except Exception as e: logger.exception(e) return (lower_version_exists)
def get_severity_bar_chart_stats_for_tag(username, customer_name, uri, method, tag_id, conn=None): try: sevs = (r.table(TagsPerAgentCollection, use_outdated=True).get_all( tag_id, index=TagsPerAgentIndexes.TagId ).pluck(TagsPerAgentKey.AgentId).eq_join( lambda x: [CommonAppKeys.AVAILABLE, x[AppsPerAgentKey.AgentId]], r.table(AppCollections.AppsPerAgent), index=AppsPerAgentIndexes.StatusAndAgentId).map({ AppsKey.AppId: r.row['right'][AppsKey.AppId], }).eq_join(AppsKey.AppId, r.table( AppCollections.UniqueApplications)).filter(lambda x: x[ 'right'][AppsKey.Hidden] == CommonKeys.NO).map({ AppsKey.AppId: r.row['right'][AppsKey.AppId], AppsKey.RvSeverity: r.row['right'][AppsKey.RvSeverity] }).group(AppsKey.RvSeverity).count().ungroup().order_by( r.desc('reduction')).run(conn)) data = app_stats_by_severity(sevs) results = (GenericResults(username, uri, method).information_retrieved( data, len(CommonSeverityKeys.ValidRvSeverities))) except Exception as e: results = (GenericResults(username, uri, method).something_broke( 'widget severity stats', 'widget', e)) logger.exception(results) return (results)
def insert_app_and_delete_old(self, app, lower_apps, conn=None): try: (r.table(AppCollections.SupportedAppsPerAgent).insert(app).run(conn)) for lower_app in lower_apps: (r.table(AppCollections.AppsPerAgent).get(lower_app[AppsPerAgentKey.Id]).delete().run(conn)) except Exception as e: logger.exception(e)
def _set_install_operation_email_alert_merge(self): agent_pluck = self._set_agent_collection_pluck() app_without = self._set_app_collection_without() merge = ({ AgentOperationKey.CreatedTime: (r.row[AgentOperationKey.CreatedTime].to_iso8601()), AgentOperationKey.UpdatedTime: (r.row[AgentOperationKey.UpdatedTime].to_iso8601()), AgentOperationKey.CompletedTime: (r.row[AgentOperationKey.CompletedTime].to_iso8601()), OperationSearchValues.AGENTS: (r.table(OperationCollections.OperationPerAgent).get_all( r.row[AgentOperationKey.OperationId], index=OperationPerAgentIndexes.OperationId).coerce_to( 'array').eq_join(OperationPerAgentKey.AgentId, r.table(AgentCollections.Agents)).zip(). pluck(agent_pluck).merge( lambda x: { OperationPerAgentKey.PickedUpTime: (x[OperationPerAgentKey.PickedUpTime].to_iso8601()), OperationPerAgentKey.CompletedTime: (x[OperationPerAgentKey.CompletedTime].to_iso8601()), OperationSearchValues.APPLICATIONS_FAILED: (r.table(OperationCollections.OperationPerApp ).get_all([ x[AgentOperationKey.OperationId], x[ OperationPerAgentKey.AgentId] ], index=OperationPerAppIndexes. OperationIdAndAgentId). filter(lambda y: y[OperationPerAppKey.Results] == AgentOperationCodes.ResultsReceivedWithErrors). coerce_to('array').merge( lambda y: { OperationPerAppKey.ResultsReceivedTime: (y[OperationPerAppKey.ResultsReceivedTime]. to_iso8601()) }).without(app_without)), OperationSearchValues.APPLICATIONS_PASSED: (r.table(OperationCollections.OperationPerApp ).get_all([ x[AgentOperationKey.OperationId], x[ OperationPerAgentKey.AgentId] ], index=OperationPerAppIndexes. OperationIdAndAgentId). filter(lambda y: y[OperationPerAppKey.Results ] == AgentOperationCodes. ResultsReceived).coerce_to('array').merge( lambda y: { OperationPerAppKey.ResultsReceivedTime: (y[OperationPerAppKey.ResultsReceivedTime] .to_iso8601()) }).without(app_without)) })) }) return (merge)
def insert_app_and_delete_old(self, app, lower_apps, conn=None): try: (r.table( AppCollections.SupportedAppsPerAgent).insert(app).run(conn)) for lower_app in lower_apps: (r.table(AppCollections.AppsPerAgent).get( lower_app[AppsPerAgentKey.Id]).delete().run(conn)) except Exception as e: logger.exception(e)
def fetch_all_by_tagid(self, tag_id, conn=None): """Fetch all operations by tag id Basic Usage: >>> from vFense.operations.search._db_agent_search import FetchAgentOperations >>> customer_name = 'default' >>> tag_id = '78076908-e93f-4116-8d49-ad42b4ad0297' >>> operation = FetchAgentOperations(customer_name) >>> operation.fetch_all_by_tagid(tag_id) Returns: List [count, data] [ 1, [ { "agents_expired_count": 0, "cpu_throttle": "normal", "agents_total_count": 2, "plugin": "rv", "tag_id": "78076908-e93f-4116-8d49-ad42b4ad0297", "agents_completed_with_errors_count": 0, "action_performed_on": "tag", "created_by": "admin", "agents_pending_pickup_count": 0, "completed_time": 1398110835, "operation_status": 6006, "agents_completed_count": 2, "operation_id": "d6956a46-165f-49b6-a3df-872a1453ab88", "created_time": 1398110770, "agents_pending_results_count": 0, "operation": "install_os_apps", "updated_time": 1398110835, "net_throttle": 0, "agents_failed_count": 0, "restart": "none", "customer_name": "default" } ] ] """ count = 0 data = [] base_time_merge = self._set_base_time_merge() try: count = (r.table(OperationCollections.Agent).get_all( tag_id, index=AgentOperationKey.TagId).count().run(conn)) data = list( r.table(OperationCollections.Agent).get_all( tag_id, index=AgentOperationKey.TagId).order_by( self.sort(self.sort_key)).skip(self.offset).limit( self.count).merge(base_time_merge).run(conn)) except Exception as e: logger.exception(e) return (count, data)
def update_supported_apps(json_data): try: rv_q = Queue("downloader", connection=RQ_PKG_POOL) conn = db_connect() inserted_count = 0 all_customers = list(r.table(Collection.Customers).map(lambda x: x[CustomerKey.CustomerName]).run(conn)) for i in range(len(json_data)): json_data[i][SupportedAppsKey.Customers] = all_customers json_data[i][SupportedAppsKey.ReleaseDate] = r.epoch_time(json_data[i][SupportedAppsKey.ReleaseDate]) json_data[i][SupportedAppsKey.FilesDownloadStatus] = PackageCodes.FilePendingDownload json_data[i][SupportedAppsKey.Hidden] = "no" json_data[i][SupportedAppsKey.VulnerabilityId] = "" insert_app_data(json_data[i], DownloadCollections.LatestDownloadedSupported) file_data = json_data[i].get(SupportedAppsKey.FileData) add_file_data(json_data[i][SupportedAppsKey.AppId], file_data) data_to_update = {SupportedAppsKey.Customers: all_customers} exists = r.table(AppCollections.SupportedApps).get(json_data[i][SupportedAppsKey.AppId]).run(conn) if exists: updated = ( r.table(AppCollections.SupportedApps) .get(json_data[i][SupportedAppsKey.AppId]) .update(data_to_update) .run(conn) ) else: updated = r.table(AppCollections.SupportedApps).insert(json_data[i]).run(conn) rv_q.enqueue_call( func=download_all_files_in_app, args=( json_data[i][SupportedAppsKey.AppId], json_data[i][SupportedAppsKey.OsCode], None, file_data, 0, AppCollections.SupportedApps, ), timeout=86400, ) inserted_count += updated["inserted"] conn.close() update_apps = IncomingSupportedApps() update_apps.sync_supported_updates_to_all_agents(json_data) except Exception as e: logger.exception(e)
def fetch_group_by_name(group_name, customer_name, fields_to_pluck=None, conn=None): """Retrieve a group by its name from the database Args: group_name (str): Name of group. customer_name (str): name of the customer, that the group belongs to. Kwargs: fields_to_pluck (list): List of fields you want to retrieve. Basic Usage: >>> from vFense.group._db import fetch_group_by_name >>> group_name = 'Administrator' >>> customer_name = 'default' >>> fetch_group_by_name(group_name, customer_name) Returns: Returns a Dict of the properties of a customer { u'group_name': u'Administrator', u'customer_name': u'default', u'id': u'8757b79c-7321-4446-8882-65457f28c78b', u'Permissions': [ u'administrator' ] } """ try: if fields_to_pluck: data = list( r.table(GroupCollections.Groups).filter({ GroupKeys.GroupName: group_name, GroupKeys.CustomerName: customer_name }).pluck(fields_to_pluck).run(conn)) else: data = list( r.table(GroupCollections.Groups).filter({ GroupKeys.GroupName: group_name, GroupKeys.CustomerName: customer_name }).run(conn)) if len(data) == 1: data = data[0] except Exception as e: logger.exception(e) data = {} return (data)
def filter_by(self, fkey, fval, conn=None): try: if fkey in self.list_of_valid_keys: count = (r.table(TagsCollection).filter({ fkey: fval, TagsKey.CustomerName: self.customer_name }).count().run(conn)) data = list( r.table(TagsCollection).filter({ fkey: fval, TagsKey.CustomerName: self.customer_name }).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][CommonAppKeys.BASIC_RV_STATS] = ( get_all_avail_stats_by_tagid(tag[TagsKey.TagId])) agents_in_tag = list( r.table(TagsPerAgentCollection).get_all( data[tag][TagsPerAgentKey.Id], 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']) else: status = (GenericResults(self.username, self.uri, self.method).incorrect_arguments( data, count)) logger.info(status['message']) except Exception as e: status = (GenericResults(self.username, self.uri, self.method).something_broke( 'search_tags_by_filter', 'tags', e)) logger.exception(status['message']) return (status)
def fetch_agent_ids(customer_name=None, agent_os=None, conn=None): """Retrieve a list of agent ids Kwargs: customer_name (str): Name of the customer, where the agent is located agent_os (str): The os code you are filtering on. (linux or windows or darwin) Basic Usage: >>> from vFense.core.agent._db import fetch_agent_ids >>> customer_name = 'default' >>> os_code = 'os_code' >>> fetch_agent_ids(customer_name, os_code) Returns: List of agent ids [ u'52faa1db-290a-47a7-a4cf-e4ad70e25c38', u'3ea8fd7a-8aad-40da-aff0-8da6fa5f8766' ] """ data = [] try: if customer_name and agent_os: data = list( r.table(AgentCollections.Agents) .get_all(customer_name, index=AgentIndexes.CustomerName) .filter({AgentKey.OsCode: agent_os}) .map(lambda x: x[AgentKey.AgentId]) .run(conn) ) elif customer_name and not agent_os: data = list( r.table(AgentCollections.Agents) .get_all(customer_name, index=AgentIndexes.CustomerName) .map(lambda x: x[AgentKey.AgentId]) .run(conn) ) elif agent_os and not customer_name: data = list( r.table(AgentCollections.Agents) .filter({AgentKey.OsCode: agent_os}) .map(lambda x: x[AgentKey.AgentId]) .run(conn) ) elif not agent_os and not customer_name: data = list(r.table(AgentCollections.Agents).map(lambda x: x[AgentKey.AgentId]).run(conn)) except Exception as e: logger.exception(e) return data
def get_severity_bar_chart_stats_for_tag(username, customer_name, uri, method, tag_id, conn=None): try: sevs = ( r .table(TagsPerAgentCollection, use_outdated=True) .get_all(tag_id, index=TagsPerAgentIndexes.TagId) .pluck(TagsPerAgentKey.AgentId) .eq_join( lambda x: [ CommonAppKeys.AVAILABLE, x[AppsPerAgentKey.AgentId] ], r.table(AppCollections.AppsPerAgent), index=AppsPerAgentIndexes.StatusAndAgentId ) .map( { AppsKey.AppId: r.row['right'][AppsKey.AppId], } ) .eq_join(AppsKey.AppId, r.table(AppCollections.UniqueApplications)) .filter( lambda x: x['right'][AppsKey.Hidden] == CommonKeys.NO ) .map( { AppsKey.AppId: r.row['right'][AppsKey.AppId], AppsKey.RvSeverity: r.row['right'][AppsKey.RvSeverity] } ) .group(AppsKey.RvSeverity) .count() .ungroup() .order_by(r.desc('reduction')) .run(conn) ) data = app_stats_by_severity(sevs) results = ( GenericResults( username, uri, method ).information_retrieved(data, len(CommonSeverityKeys.ValidRvSeverities)) ) except Exception as e: results = ( GenericResults( username, uri, method ).something_broke('widget severity stats', 'widget', e) ) logger.exception(results) return(results)
def fetch_group_properties(group_id, conn=None): """Retrieve a group and all of its properties. Args: group_id: 36 Character UUID. Basic Usage: >>> from vFense.group._db import fetch_group_properties >>> group_id = 'a7d4690e-5851-4d92-9626-07e16acaea1f' >>> fetch_group_properties(group_id) Returns: Returns a Dict of the properties of a group { "users": [ { "user_name": "admin" }, { "user_name": "agent_api" } ], "permissions": [ "administrator" ], "group_name": "Administrator", "id": "1b74a706-34e5-482a-bedc-ffbcd688f066", "customer_name": "default" } """ map_hash = (lambda x: { GroupKeys.GroupId: x[GroupKeys.GroupId], GroupKeys.GroupName: x[GroupKeys.GroupName], GroupKeys.CustomerName: x[GroupKeys.CustomerName], GroupKeys.Permissions: x[GroupKeys.Permissions], GroupKeys.Users: (r.table(GroupCollections.GroupsPerUser).get_all( group_id, index=GroupsPerUserIndexes.GroupId).coerce_to('array'). pluck(GroupsPerUserKeys.UserName)) }) data = {} try: data = (r.table( GroupCollections.Groups).get_all(group_id).map(map_hash).run(conn)) if data: data = data[0] except Exception as e: logger.exception(e) return (data)
def get_all_agents_per_appid(username, customer_name, uri, method, app_id, conn=None): data = [] try: agents = (r.table(AppCollections.vFenseAppsPerAgent).get_all( app_id, index=AgentAppsPerAgentKey.AppId).eq_join( AgentAppsPerAgentKey.AgentId, r.table(AgentsCollection)).zip().group( lambda x: x[AgentAppsPerAgentKey.Status]).map( lambda x: { AGENTS: [{ AgentKey.ComputerName: x[AgentKey.ComputerName], AgentKey.DisplayName: x[AgentKey.DisplayName], AgentAppsPerAgentKey.AgentId: x[AgentAppsPerAgentKey.AgentId] }], COUNT: 1 }).reduce(lambda x, y: { AGENTS: x[AGENTS] + y[AGENTS], COUNT: x[COUNT] + y[COUNT] }).ungroup().run(conn)) if agents: for i in agents: new_data = i['reduction'] new_data[AgentAppsPerAgentKey.Status] = i['group'] 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, AGENTS: [], STATUS: status} 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 update_supported_apps(json_data): try: rv_q = Queue('downloader', connection=RQ_PKG_POOL) conn = db_connect() inserted_count = 0 all_customers = list( r.table(Collection.Customers).map( lambda x: x[CustomerKey.CustomerName]).run(conn)) for i in range(len(json_data)): json_data[i][SupportedAppsKey.Customers] = all_customers json_data[i][SupportedAppsKey.ReleaseDate] = \ r.epoch_time(json_data[i][SupportedAppsKey.ReleaseDate]) json_data[i][SupportedAppsKey.FilesDownloadStatus] = \ PackageCodes.FilePendingDownload json_data[i][SupportedAppsKey.Hidden] = 'no' json_data[i][SupportedAppsKey.VulnerabilityId] = '' insert_app_data(json_data[i], DownloadCollections.LatestDownloadedSupported) file_data = json_data[i].get(SupportedAppsKey.FileData) add_file_data(json_data[i][SupportedAppsKey.AppId], file_data) data_to_update = {SupportedAppsKey.Customers: all_customers} exists = (r.table(AppCollections.SupportedApps).get( json_data[i][SupportedAppsKey.AppId]).run(conn)) if exists: updated = (r.table(AppCollections.SupportedApps).get( json_data[i][SupportedAppsKey.AppId]).update( data_to_update).run(conn)) else: updated = (r.table(AppCollections.SupportedApps).insert( json_data[i]).run(conn)) rv_q.enqueue_call(func=download_all_files_in_app, args=(json_data[i][SupportedAppsKey.AppId], json_data[i][SupportedAppsKey.OsCode], None, file_data, 0, AppCollections.SupportedApps), timeout=86400) inserted_count += updated['inserted'] conn.close() update_apps = IncomingSupportedApps() update_apps.sync_supported_updates_to_all_agents(json_data) except Exception as e: logger.exception(e)
def fetch_agent_ids(customer_name=None, agent_os=None, conn=None): """Retrieve a list of agent ids Kwargs: customer_name (str): Name of the customer, where the agent is located agent_os (str): The os code you are filtering on. (linux or windows or darwin) Basic Usage: >>> from vFense.core.agent._db import fetch_agent_ids >>> customer_name = 'default' >>> os_code = 'os_code' >>> fetch_agent_ids(customer_name, os_code) Returns: List of agent ids [ u'52faa1db-290a-47a7-a4cf-e4ad70e25c38', u'3ea8fd7a-8aad-40da-aff0-8da6fa5f8766' ] """ data = [] try: if customer_name and agent_os: data = list( r.table(AgentCollections.Agents).get_all( customer_name, index=AgentIndexes.CustomerName).filter({ AgentKey.OsCode: agent_os }).map(lambda x: x[AgentKey.AgentId]).run(conn)) elif customer_name and not agent_os: data = list( r.table(AgentCollections.Agents).get_all( customer_name, index=AgentIndexes.CustomerName).map( lambda x: x[AgentKey.AgentId]).run(conn)) elif agent_os and not customer_name: data = list( r.table(AgentCollections.Agents).filter({ AgentKey.OsCode: agent_os }).map(lambda x: x[AgentKey.AgentId]).run(conn)) elif not agent_os and not customer_name: data = list( r.table(AgentCollections.Agents).map( lambda x: x[AgentKey.AgentId]).run(conn)) except Exception as e: logger.exception(e) return data
def fetch_groups_for_user(username, fields_to_pluck=None, conn=None): """Retrieve all groups for a user by username Args: username (str): Get all groups for which this user is part of. Kwargs: fields_to_pluck (list): List of fields you want to pluck from the database Basic Usage: >>> from vFense.group._db import fetch_groups_for_user >>> username = '******' >>> fetch_groups_for_user(username) Returns: Returns a list of groups that the user belongs to. [ { u'group_name': u'FooLah', u'group_id': u'0834e656-27a5-4b13-ba56-635797d0d1fc', u'user_name': u'alien', u'id': u'ee54820c-cb4e-46a1-9d11-73afe8c4c4e3', u'customer_name': u'default' }, { u'group_name': u'Administrator', u'group_id': u'8757b79c-7321-4446-8882-65457f28c78b', u'user_name': u'alien', u'id': u'6bd51a04-fcec-46a7-bbe1-48c6221115ec', u'customer_name': u'default' } ] """ data = [] try: if username and not fields_to_pluck: data = list( r.table(GroupCollections.GroupsPerUser).get_all( username, index=GroupsPerUserIndexes.UserName).run(conn)) elif username and fields_to_pluck: data = list( r.table(GroupCollections.GroupsPerUser).get_all( username, index=GroupsPerUserIndexes.UserName).pluck( fields_to_pluck).run(conn)) except Exception as e: logger.exception(e) return (data)
def fetch_all_by_agentid(self, agent_id, conn=None): """Fetch all operations by agent id Basic Usage: >>> from vFense.operations.search._db_agent_search import FetchAgentOperations >>> customer_name = 'default' >>> agent_id = '6c0209d5-b350-48b7-808a-158ddacb6940' >>> operation = FetchAgentOperations(customer_name) >>> operation.fetch_all_by_agentid(agent_id) Returns: List [ { "agents_expired_count": 0, "agents_total_count": 1, "tag_id": null, "agents_completed_with_errors_count": 0, "created_by": "admin", "agents_pending_pickup_count": 0, "completed_time": 1398092303, "operation_status": 6006, "agents_completed_count": 1, "operation_id": "6c0209d5-b350-48b7-808a-158ddacb6940", "created_time": 1398092302, "agents_pending_results_count": 0, "operation": "install_os_apps", "updated_time": 1398092303, "agents_failed_count": 0, "customer_name": "default" } ] """ count = 0 data = [] base_time_merge = self._set_base_time_merge() try: count = (r.table(OperationCollections.Agent).get_all( agent_id, index=AgentOperationIndexes.AgentIds).count().run(conn)) data = list( r.table(OperationCollections.Agent).get_all( agent_id, index=AgentOperationIndexes.AgentIds).order_by( self.sort(self.sort_key)).skip(self.offset).limit( self.count).merge(base_time_merge).run(conn)) except Exception as e: logger.exception(e) return (count, data)
def validate_permission_for_user(username, customer_name, permission, conn=None): permission_exist = False try: is_empty = ( r .table(GroupCollections.GroupsPerUser) .get_all(username, index=GroupsPerUserIndexes.UserName) .filter({GroupsPerUserKeys.CustomerName: customer_name}) .eq_join( lambda group: group[GroupsPerUserKeys.GroupName], r.table(GroupCollections.Groups), index=GroupIndexes.GroupName ) .zip() .filter(r.row[GroupKeys.Permissions].contains(permission)) .is_empty() .run(conn) ) if not is_empty: permission_exist = True else: is_admin_empty = ( r .table(GroupCollections.GroupsPerUser) .get_all(username, index=GroupsPerUserIndexes.UserName) .filter({GroupsPerUserKeys.CustomerName: customer_name}) .eq_join( lambda group: group[GroupsPerUserKeys.GroupName], r.table(GroupCollections.Groups), index=GroupIndexes.GroupName ) .zip() .filter( r.row[GroupKeys.Permissions].contains( Permissions.ADMINISTRATOR ) ) .is_empty() .run(conn) ) if not is_admin_empty: permission_exist = True except Exception as e: logger.exception(e) return(permission_exist)
def get_all_expired_jobs(now=None, conn=None): """Retrieve all expired jobs Kwargs: now (float): The epoch time to compare against, during the retrieval process. Default: (Is to use the epoch time of right now) Basic Usage: >>> from vFense.queue._db import get_all_expired_jobs >>> now = 1396780822.0 >>> get_all_expired_jobs(now) Returns: List of dictionairies [ { "agent_queue_ttl": 1396778416, "plugin": "rv", "order_id": 1, "server_queue_ttl": 1396777816, "agent_id": "d4119b36-fe3c-4973-84c7-e8e3d72a3e02", "created_time": 1396777216, "operation_id": "b95837d9-5df7-4ab0-9449-a7be196a2b12", "operation": "updatesapplications", "id": "f9817e07-6877-4857-aef3-e80f57022ac8", "expire_minutes": 10, "customer_name": "default" } ] """ expired_jobs = [] try: if not now: expired_jobs = list( r.table(QueueCollections.Agent).filter(lambda x: x[AgentQueueKey.ServerQueueTTL] <= r.now()).run(conn) ) else: expired_jobs = list( r.table(QueueCollections.Agent) .filter(lambda x: x[AgentQueueKey.ServerQueueTTL].to_epoch_time() <= now) .run(conn) ) except Exception as e: logger.exception(e) return expired_jobs
def recently_released_packages(username, customer_name, uri, method, count=5, conn=None): data = [] try: data = list( r.table(AppCollections.AppsPerAgent, use_outdated=True).get_all( [CommonAppKeys.AVAILABLE, customer_name], index=AppsPerAgentIndexes.StatusAndCustomer).eq_join( AppsKey.AppId, r.table(AppCollections.UniqueApplications)). map( lambda x: { AppsKey.Name: x['right'][AppsKey.Name], AppsKey.AppId: x['right'][AppsKey.AppId], AppsKey.RvSeverity: x['right'][AppsKey.RvSeverity], AppsKey.Hidden: x['right'][AppsKey.Hidden], AppsKey.ReleaseDate: x['right'][AppsKey.ReleaseDate].to_epoch_time(), 'count': (r.table(AppCollections.AppsPerAgent).get_all( [x['right'][AppsKey.AppId], CommonAppKeys.AVAILABLE], index=AppsPerAgentIndexes.AppIdAndStatus).eq_join( AppsKey.AppId, r.table(AppCollections.UniqueApplications)). filter(lambda y: y['right'][AppsKey.Hidden] == CommonKeys.NO).count()) }).pluck(AppsKey.Name, AppsKey.AppId, AppsKey.Hidden, AppsKey.RvSeverity, AppsKey.ReleaseDate, 'count').order_by(r.desc( AppsKey.ReleaseDate)).limit(count).run(conn)) results = (GenericResults(username, uri, method).information_retrieved(data, count)) except Exception as e: results = (GenericResults(username, uri, method).something_broke( 'recently released os apps', 'widget', e)) logger.exception(results) return (results)
def _delete_old_supported_apps_from_agent(self, agent_id, conn): ( r.table(AppCollections.SupportedAppsPerAgent) .get_all(agent_id, index=SupportedAppsPerAgentIndexes.AgentId) .delete() .run(conn) )
def filter_by_status(self, pkg_status, conn=None): try: if pkg_status in CommonAppKeys.ValidPackageStatuses: base = ( r .table(self.CurrentAppsPerAgentCollection, use_outdated=True) .get_all( [pkg_status, self.customer_name], index=self.CurrentAppsPerAgentIndexes.StatusAndCustomer) .eq_join(self.CurrentAppsKey.AppId, r.table(self.CurrentAppsCollection)) .map(self.joined_map_hash) ) if self.show_hidden == CommonKeys.NO: base = base.filter( {self.CurrentAppsKey.Hidden: CommonKeys.NO} ) packages = list( base .distinct() .order_by(self.sort(self.sort_key)) .skip(self.offset) .limit(self.count) .run(conn) ) pkg_count = ( base .pluck(self.CurrentAppsKey.AppId) .distinct() .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 update_data_in_table(primary_key, data, collection, conn=None): """Update data by the primary key of the collection Args: primary_key (str): The primary key, of the object you are searching. data (dict): Dictionary of the data you are updating. you are inserting. collection (str): The name of the collection you are updating. Basic Usage: >>> from vFense.core._db import update_data_in_table >>> primary_key = 'default' >>> data = {'enabled': 'no'} >>> collection = 'users' >>> update_data_in_table(primary_key, data, collection) Returns: Tuple (status_code, count, error, generated ids) >>> (2001, 1, None, []) """ results = {} try: results = (r.table(collection).get(primary_key).update(data).run(conn)) except Exception as e: logger.exception(e) return results
def fetch_vuln_ids(name, version, os_string, conn=None): """Retrieve Ubuntu USN IDS and CVE_IDS for an Application Args: name (str): The name of the application version (str): The version of the application os_string (str): The Version of Ubuntu (Ubuntu 12.04 LTS) Basic Usage: >>> from vFense.plugins.vuln.ubuntu._db import fetch_ubuntu_vuln_ids >>> name = 'nvidia-173' >>> version = '173.14.22-0ubuntu11.2' >>> os_string = 'Ubuntu 10.04 LTS' >>> fetch_ubuntu_vuln_ids(name, version, os_string) Returns: Dictionary { "cve_ids": [], "bulletin_id": "USN-1523-1" } """ data = [] try: data = list( r.table(UbuntuSecurityCollection.Bulletin).get_all( [name, version], index=UbuntuSecurityBulletinIndexes.NameAndVersion).pluck( UbuntuSecurityBulletinKey.BulletinId, UbuntuSecurityBulletinKey.CveIds).run(conn)) except Exception as e: logger.exception(e) return (data)
def get_all_stats_by_appid( username, customer_name, uri, method, app_id, collection=AppCollections.AppsPerAgent, conn=None ): if collection == AppCollections.AppsPerAgent: CurrentAppsPerAgentCollection = AppCollections.AppsPerAgent CurrentAppsPerAgentKey = AppsPerAgentKey CurrentAppsPerAgentIndexes = AppsPerAgentIndexes elif collection == AppCollections.SupportedAppsPerAgent: CurrentAppsPerAgentCollection = AppCollections.SupportedAppsPerAgent CurrentAppsPerAgentKey = SupportedAppsPerAgentKey CurrentAppsPerAgentIndexes = SupportedAppsPerAgentIndexes elif collection == AppCollections.CustomAppsPerAgent: CurrentAppsPerAgentCollection = AppCollections.CustomAppsPerAgent CurrentAppsPerAgentKey = CustomAppsPerAgentKey CurrentAppsPerAgentIndexes = CustomAppsPerAgentIndexes elif collection == AppCollections.vFenseAppsPerAgent: CurrentAppsPerAgentCollection = AppCollections.vFenseAppsPerAgent CurrentAppsPerAgentKey = AgentAppsPerAgentKey CurrentAppsPerAgentIndexes = AgentAppsPerAgentIndexes try: data = [] apps = ( r.table(CurrentAppsPerAgentCollection) .get_all([app_id, customer_name], index=CurrentAppsPerAgentIndexes.AppIdAndCustomer) .group(CurrentAppsPerAgentKey.Status) .count() .ungroup() .run(conn) ) if apps: for i in apps: new_data = i["reduction"] new_data = { CurrentAppsPerAgentKey.Status: i["group"], CommonAppKeys.COUNT: i["reduction"], CommonAppKeys.NAME: i["group"].capitalize(), } data.append(new_data) statuses = map(lambda x: x["status"], data) difference = set(CommonAppKeys.ValidPackageStatuses).difference(statuses) if len(difference) > 0: for status in difference: status = {CommonAppKeys.COUNT: 0, CommonAppKeys.STATUS: status, CommonAppKeys.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 object_exist(primary_key, collection, conn=None): """Verify if an object exist in the database, by primary key. Args: primary_key (str): The primary key that you are doing a get against. collection (str): The table aka collection you are doing the query against. Basic Usage: >>> from vFense._db import object_exist >>> collection, = 'users' >>> primary_key = 'admin' >>> object_exist(primary_key, collection) Returns: Boolean """ exist = False try: is_empty = ( r.table(collection).get_all(primary_key).is_empty().run(conn)) if not is_empty: exist = True except Exception as e: logger.exception(e) return exist
def db_delete(collection=None, _id=None, conn=None): """Attempts to delete data from the DB. Tries to delete a document based on the id or filter provided. If filter is used, the first document returned is deleted. Args: collection_name: Name of the collection to be used. _id: Id (primary key) representing a document Returns: True if document was deleted, False otherwise. """ success = None if _id: result = r.table(collection).get(_id).delete().run(conn) if 'deleted' in result and result['deleted'] > 0: success = True return success
def fetch_supported_os_strings(customer_name, conn=None): """Retrieve all the operating systems that is in the database Args: customer_name (str): Name of the customer, where the agent is located Basic Usage: >>> from vFense.core.agent._db import fetch_supported_os_strings >>> customer_name = 'default' >>> fetch_supported_os_strings(customer_name) Returns: List of available operating system strings in the database [ u'CentOS 6.5', u'Ubuntu 12.04', u'Windows 7 Professional Service Pack 1', u'Windows 8.1 ' ] """ data = [] try: data = ( r.table(AgentCollections.Agents) .get_all(customer_name, index=AgentIndexes.CustomerName) .pluck(AgentKey.OsString) .distinct() .map(lambda x: x[AgentKey.OsString]) .run(conn) ) except Exception as e: logger.exception(e) return data
def move_agents_to_customer(agent_ids, new_customer, conn=None): """Move a list of agents into another customer Args: agent_ids (list): List of agent ids new_customer (str): Name of the new customer. Basic Usage: >>> from vFense.agent._db import move_agents_to_customer >>> new_customer = 'test' >>> agent_ids = ['7f242ab8-a9d7-418f-9ce2-7bcba6c2d9dc'] >>> move_agents_to_customer(agent_ids, new_customer) Returns: Tuple (status_code, count, error, generated ids) >>> (2001, 1, None, []) """ data = {} try: data = ( r.expr(agent_ids) .for_each( lambda agent_id: r.table(AgentCollections.Agents) .get(agent_id) .update({AgentKey.CustomerName: new_customer}) ) .run(conn) ) except Exception as e: logger.exception(e) return data
def insert_agent_data(agent_data, conn=None): """ Insert a new agent and its properties into the database This function should not be called directly. Args: agent_data (list|dict): Can either be a list of dictionaries or a dictionary of the data you are inserting. Basic Usage: >>> from vFense.core.agent._db import insert_agent_data >>> agent_data = {'customer_name': 'vFense', 'needs_reboot': 'no'} >>> insert_agent_data(agent_data) Return: Tuple (status_code, count, error, generated ids) >>> (2001, 1, None, []) """ data = {} try: data = r.table(AgentCollections.Agents).insert(agent_data).run(conn) except Exception as e: logger.exception(e) return data
def fetch_production_levels_from_agent(customer_name, conn=None): """Retrieve all the production levels that is in the database Args: customer_name (str): Name of the customer, where the agent is located Basic Usage: >>> from vFense.core.agent._db import fetch_production_levels_from_agent >>> customer_name = 'default' >>> fetch_production_levels_from_agent(customer_name) Returns: List of Production levels in the system [ u'Development', u'Production' ] """ data = [] try: data = ( r.table(AgentCollections.Agents) .get_all(customer_name, index=AgentIndexes.CustomerName) .pluck(AgentKey.ProductionLevel) .distinct() .map(lambda x: x[AgentKey.ProductionLevel]) .run(conn) ) except Exception as e: logger.exception(e) return data
def db_get( collection=None, primary_id=None, pluck=None, conn=None ): if ( not collection or not primary_id ): return None query = r.table(collection).get(primary_id) if pluck: if isinstance(pluck, list): doc = query.pluck(*pluck).run(conn) else: doc = query.pluck(pluck).run(conn) else: doc = query.run(conn) return doc
def get_email_config(customer_name=None, conn=None): mail_config = None config_exists = False msg = "" try: mail_config = list( r.table(NotificationCollections.NotificationPlugins) .get_all(customer_name, index=NotificationPluginIndexes.CustomerName) .filter({NotificationPluginKeys.PluginName: "email"}) .run(conn) ) if not mail_config: mail_config = { "modified_time": "", "username": "", "password": "", "server": "", "port": "", "is_tls": "", "is_ssl": "", "from_email": "", "to_email": "", "last_modify_user": "", } msg = "mail_config does not exist" else: config_exists = True except Exception as e: msg = "Failed to get mail config: %s" % (str(e)) logger.exception(e) return {"pass": config_exists, "message": msg, "data": mail_config}
def delete_data_in_table(primary_key, collection, conn=None): """Delete data in a collection Args: primary_key (str): The primary key of the collection you are searching for, collection (str): The name of the collection you are removing all data from. Basic Usage: >>> from vFense.core._db import delete_data_in_table >>> primary_key = 'default' >>> collection = 'agents' >>> delete_data_in_table(primary_key, collection) Returns: Tuple (status_code, count, error, generated ids) >>> (2001, 1, None, []) """ results = {} try: results = (r.table(collection).get(primary_key).delete().run(conn)) except Exception as e: logger.exception(e) return results
def move_all_agents_to_customer(current_customer, new_customer, conn=None): """Move all agents in current customer to the new customer. Args: current_customer (str): Name of the current customer. new_customer (str): Name of the new customer. Basic Usage: >>> from vFense.agent._db import move_all_agents_to_customer >>> current_customer = 'default' >>> new_customer = 'test' >>> move_all_agents_to_customer(current_customer, new_customer) Returns: Tuple (status_code, count, error, generated ids) >>> (2001, 1, None, []) """ data = {} try: data = ( r.table(AgentCollections.Agents) .get_all(current_customer, index=AgentIndexes.CustomerName) .update({AgentKey.CustomerName: new_customer}) .run(conn) ) except Exception as e: logger.exception(e) return data
def insert_app(self, app, conn=None): try: (r.table( AppCollections.SupportedAppsPerAgent).insert(app).run(conn)) except Exception as e: logger.exception(e)
def insert_data_in_table(data, collection, conn=None): """Insert data in a collection Args: data (list|dict): List of dictionaries or a dictionary of the data you are inserting. collection (str): The name of the collection you are removing all data from. Basic Usage: >>> from vFense.core._db import insert_data_in_table >>> data = [{'name': 'foo'}] >>> collection = 'agents' >>> insert_data_in_table(data, collection) Returns: Tuple (status_code, count, error, generated ids) >>> (2001, 1, None, []) """ results = {} try: results = (r.table(collection).insert(data, upsert=True).run(conn)) except Exception as e: logger.exception(e) return results
def insert_into_agent_queue(operation, conn=None): """Insert data into the agent_queue DO NOT CALL DIRECTLY Args: operation (list|dict): operation data Basic Usage: >>> from vFense.queue._db import insert_into_agent_queue >>> operation = [{'operation': 'data'}] >>> insert_into_agent_queue(operation) Returns: Tuple (status_code, count, error, generated ids) >>> (2001, 1, None, []) """ data = {} try: operation[AgentQueueKey.CreatedTime] = r.epoch_time(operation[AgentQueueKey.CreatedTime]) operation[AgentQueueKey.ServerQueueTTL] = r.epoch_time(operation[AgentQueueKey.ServerQueueTTL]) operation[AgentQueueKey.AgentQueueTTL] = r.epoch_time(operation[AgentQueueKey.AgentQueueTTL]) data = r.table(QueueCollections.Agent).insert(operation).run(conn) except Exception as e: logger.exception(e) return data
def update_user(username, user_data, conn=None): """Update user's properties Args: username (str): username of the user you are updating user_data (list|dict): Dictionary of the data you are updating Basic Usage:: >>> from vFense.user._db import update_user >>> username = '******' >>> data = {'production_level': 'Development', 'needs_reboot': 'no'} >>> update_user(username, data) Returns: Tuple (status_code, count, error, generated ids) >>> (2001, 1, None, []) """ data = {} try: data = (r.table( UserCollections.Users).get(username).update(user_data).run(conn)) except Exception as e: logger.exception(e) return (data)
def user_status_toggle(username, conn=None): """Enable or disable a user Args: username (str): The username you are enabling or disabling Basic Usage: >>> from vFense.user._db import status_toggle >>> username = '******' >>> status_toggle(username) Returns: Tuple (status_code, count, error, generated ids) >>> (2001, 1, None, []) """ try: toggled = (r.table(UserCollections.Users).get(username).update({ UserKeys.Enabled: (r.branch(r.row[UserKeys.Enabled] == CommonKeys.YES, CommonKeys.NO, CommonKeys.YES)) }).run(conn)) except Exception as e: logger.exception(e) return (toggled)
def top_packages_needed(username, customer_name, uri, method, count=5, conn=None): apps_needed=[] try: data = ( r .table(AppCollections.AppsPerAgent) .get_all( [CommonAppKeys.AVAILABLE, customer_name], index=AppsPerAgentIndexes.StatusAndCustomer ) .eq_join(AppsKey.AppId, r.table(AppCollections.UniqueApplications)) .filter( lambda x: x['right'][AppsKey.Hidden] == CommonKeys.NO ) .map( lambda x: { AppsKey.Name: x['right'][AppsKey.Name], AppsKey.AppId: x['right'][AppsKey.AppId], AppsKey.RvSeverity: x['right'][AppsKey.RvSeverity], AppsKey.ReleaseDate: x['right'][AppsKey.ReleaseDate].to_epoch_time(), } ) .group(AppsKey.Name, AppsKey.AppId, AppsKey.RvSeverity, AppsKey.ReleaseDate) .count() .ungroup() .map( lambda x: { AppsKey.Name: x['group'][0], AppsKey.AppId: x['group'][1], AppsKey.RvSeverity: x['group'][2], AppsKey.ReleaseDate: x['group'][3], 'count': x['reduction'], } ) .order_by(r.desc('count'), r.desc(AppsKey.ReleaseDate)) .limit(count) .run(conn) ) results = ( GenericResults( username, uri, method ).information_retrieved(data, count) ) except Exception as e: results = ( GenericResults( username, uri, method ).something_broke('top os apps needed', 'widget', e) ) logger.exception(results) return(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][CommonAppKeys.BASIC_RV_STATS] = ( get_all_avail_stats_by_tagid( data[tag][TagsKey.TagId] ) ) 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 fetch_appids_by_agentid_and_status(agent_id, status, sev=None, collection=AppCollections.AppsPerAgent, conn=None): if collection == AppCollections.AppsPerAgent: join_table = AppCollections.UniqueApplications elif collection == AppCollections.CustomAppsPerAgent: join_table = AppCollections.CustomApps elif collection == AppCollections.SupportedAppsPerAgent: join_table = AppCollections.SupportedApps elif collection == AppCollections.vFenseAppsPerAgent: join_table = AppCollections.vFenseApps if sev: appids = list( r .table(collection) .get_all( [ status, agent_id ], index=DbCommonAppPerAgentIndexes.StatusAndAgentId ) .eq_join( lambda x: [ x[DbCommonAppKeys.AppId], sev ], r.table(join_table), index=DbCommonAppIndexes.AppIdAndRvSeverity ) .map( lambda y: y['right'][DbCommonAppKeys.AppId] ) .run(conn) ) else: appids = list( r .table(collection) .get_all( [ status, agent_id ], index=DbCommonAppPerAgentIndexes.StatusAndAgentId ) .map( lambda y: y[DbCommonAppPerAgentKeys.AppId] ) .run(conn) ) return appids
def query_by_name(self, name, conn=None): try: agent = get_agent_info(self.agent_id) if agent: base = ( r .table(self.CurrentAppsPerAgentCollection) .get_all(self.agent_id, index=self.CurrentAppsPerAgentIndexes.AgentId) .eq_join(self.CurrentAppsPerAgentKey.AppId, r.table(self.CurrentAppsCollection)) .zip() ) if self.show_hidden == CommonKeys.NO: base = base.filter({self.CurrentAppsKey.Hidden: CommonKeys.NO}) packages = list( base .filter(lambda x: x[self.CurrentAppsKey.Name].match("(?i)"+name)) .map(self.map_hash) .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)) .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.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 sync_supported_updates_to_all_agents(self, apps): try: conn = db_connect() deleted_count = 0 (r.table(AppCollections.SupportedAppsPerAgent).delete().run(conn)) conn.close() self.update_agents_with_supported(apps) except Exception as e: logger.exception(e)
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[CommonAppKeys.BASIC_RV_STATS] = ( get_all_app_stats_by_tagid(tag_id) ) 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 db_get_all( collection=None, conn=None ): result = list( r.table(collection) .run(conn) ) return result
def get_customer(customer_name=None, conn=None): if not customer_name: return None customer = ( r.table(Collection.Customers) .get(customer_name) .run(conn) ) return customer