def user_account(self, username, password, fullname=None, email=None): """ Create a new account. Returns None if account is not created successfully.""" # Have to check first if the account with the same username exist. self.session = validate_session(self.session) account = self.session.query(User).filter(User.username == username).first() if account is None: hash = Crypto.hash_scrypt(password) return User(username, hash) else: # Looks like a developer account already exist. return None # Have to check first if the account with the same username exist. self.session = validate_session(self.session) account = self.session.query(Developer).filter(Developer.name == name).first() if account is None: client_id = token.generate_token() client_secret = token.generate_token() return Developer(name, client_id, client_secret, redirect_uri) else: # Looks like a developer account already exist. return None
def list_groups(session): session = validate_session(session) grouplist = session.query(Group).all() node_acl_list =[] tag_acl_list = [] global_acl_list = [] result = [] for group in grouplist: node_group_acl = session.query(NodeGroupAccess).\ filter(NodeGroupAccess.group_id == group.id).\ all() node_acl_list = map(lambda node: node.__dict__, node_group_acl) map(lambda node: node.pop('_sa_instance_state'), node_acl_list) global_group_acl = session.query(GlobalGroupAccess).\ filter(GlobalGroupAccess.group_id == group.id).\ all() global_acl_list = map(lambda groups: groups.__dict__, global_group_acl) map(lambda groups: groups.pop('_sa_instance_state'), global_acl_list) map(lambda node: node.pop('is_global'), global_acl_list) tag_group_acl = session.query(TagGroupAccess).\ filter(TagGroupAccess.group_id == group.id).\ all() tag_acl_list = map(lambda tag: tag.__dict__, tag_group_acl) map(lambda tag: tag.pop('_sa_instance_state'), tag_acl_list) result.append({ 'groupname': group.groupname, 'id': group.id, 'global_acls': return_modified_list(global_acl_list), 'node_acls': return_modified_list(node_acl_list), 'tag_acls': return_modified_list(tag_acl_list) }) return result
def __init__( self, session, user_name=None, action="allow_read", node_id=None, host_name=None, display_name=None, ip_address=None, tag_id=None, tag_name=None, user_id=None, ): self.session = validate_session(session) self.global_user_query = self.session.query(GlobalUserAccess) self.global_group_query = self.session.query(GlobalGroupAccess) self.node_user_query = self.session.query(NodeUserAccess) self.node_group_query = self.session.query(NodeGroupAccess) self.tag_user_query = self.session.query(TagUserAccess) self.tag_group_query = self.session.query(TagGroupAccess) self.node_id = node_id self.host_name = host_name self.display_name = display_name self.ip_address = ip_address self.tag_id = tag_id self.tag_name = tag_name self.tag_names = [] self.user_id = user_id self.user_name = user_name self.action = action self.groups = [] self.group_names = [] self.user = None self.node = None self.nodes = [] self.tag = None self.tags = [] self.acls = [] self.global_acls = None self.node_or_tag_acls = None self.user_access = None self.group_access = None self.user_for_node_exists = None self.user_for_tag_exists = None self.global_user_name = None self.operation_call = [ "allow_install", "allow_uninstall", "allow_read", "allow_reboot", "allow_wol", "allow_tag_creation", "allow_tag_removal", "allow_snapshot_creation", "allow_snapshot_removal", "allow_snapshot_revert", ]
def create_group(session, groupname): session = validate_session(session) result = None if groupname: result = add_group(session, groupname) return(result) else: return({ 'pass': False, 'message': 'Need to pass the groupname' })
def change_user_password(self, username, new_password): """ Updates the password of an existing user's account. """ self.session = validate_session(self.session) account = self.session.query(User).filter(User.username == username).first() account.hash = Crypto.hash_scrypt(new_password) self.session.commit() self.session.close()
def acl_modifier(session, acl_type, acl_action, acl): session = validate_session(session) valid_acl_type = ['global_user', 'global_group', 'node_user', \ 'node_group', 'tag_user', 'tag_group'] valid_acl_action = ['create', 'modify', 'delete'] result = None if acl_type and acl_action and acl: if acl_type in valid_acl_type and \ acl_action in \ valid_acl_action: for key, value in acl.items(): if value == 'true' or value == 'false': acl[key] = return_bool(value) if acl_action == 'create': if 'global_user' in acl_type: result = add_global_user_acl(session, **acl) if 'global_group' in acl_type: result = add_global_group_acl(session, **acl) if 'node_user' in acl_type: result = add_node_user_acl(session, **acl) if 'node_group' in acl_type: result = add_node_group_acl(session, **acl) if 'tag_user' in acl_type: result = add_tag_user_acl(session, **acl) if 'tag_group' in acl_type: result = add_tag_group_acl(session, **acl) elif acl_action == 'modify': if 'global_user' in acl_type: result = update_global_user_acl(session, **acl) if 'global_group' in acl_type: result = update_global_group_acl(session, **acl) if 'node_user' in acl_type: result = update_node_user_acl(session, **acl) if 'node_group' in acl_type: print acl result = update_node_group_acl(session, **acl) print result if 'tag_user' in acl_type: result = update_tag_user_acl(session, **acl) if 'tag_group' in acl_type: result = update_tag_group_acl(session, **acl) elif acl_action == 'delete': result = remove_acl(session, acl_type, **acl) else: result({ 'pass': False, 'message': 'the acl_type or acl_action was invalid' }) else: result({ 'pass': False, 'message': 'Arguments needed are acl_type, acl_action, and acl' }) return result
def modify_user_from_group(session, user_id=None, group_id=None, action=None): session = validate_session(session) if user_id and group_id and action: user = session.query(UsersInAGroup).\ filter(UsersInAGroup.user_id == user_id).\ filter(UsersInAGroup.group_id == group_id).first() user1 = session.query(User).filter(User.id == user_id).first() group = session.query(Group).filter(Group.id == group_id).first() if user and group and 'remove' in action: try: session.delete(user) session.commit() return({ 'pass': True, 'message': 'User %s has been removed from Group %s' %\ (user1.username, group.groupname) }) except Exception as e: session.rollback() return({ 'pass': False, 'message': 'User %s couldnt be removed from the Group %s' %\ (user1.username, group.groupname) }) elif not user and group and 'add' in action: try: user = session.query(User).filter(User.id == user_id).first() addtogroup = UsersInAGroup(user_id, group_id) session.add(addtogroup) session.commit() return({ 'pass': True, 'message': 'User %s has been added to Group %s' %\ (user.username, group.groupname) }) except Exception as e: session.rollback() return({ 'pass': False, 'message': 'User %s couldnt be added to the Group %s' %\ (user.username, group.groupname) }) else: return({ 'pass': False, 'message': 'User %s and or Group %s do not exist' %\ (user_id, group_id) }) else: return({ 'pass': False, 'message': 'Incorrect parameters were passed' })
def __init__(self, session, qcount=20, qoffset=0): """ This must be called first with at least session initialized. session == SQLAlchemy Session qcount == how many results you want to retreive qoffset == what is the offset, that you want returned """ self.session = validate_session(session) self.qcount = qcount self.qoffset = qoffset
def authenticate_account(session, username, password): """ Checks if the username and password are correct. Returns True if it is, False otherwise. """ authenticated = False session = validate_session(session) account = session.query(User).filter(User.username == username).first() if account: authenticated = Crypto.verify_bcrypt_hash(password, account.hash) else: authenticated = False print "AUTHENTICATED", authenticated return authenticated
def authenticate_account(self, username, password): """ Checks if the username and password are correct. Returns True if it is, False otherwise. """ self.session = validate_session(self.session) account = self.session.query(User).filter(User.username == username).first() # Check if account/username exist. False if it doesn't. if account is None: return False if Crypto.verify_scrypt_hash(password, account.hash): return True else: return False
def create_user(session, username=None, password=None, fullname=None, email=None, groupname='READ_ONLY', user_name=None): session = validate_session(session) if username and password and groupname: user_exists = session.query(User).\ filter(User.username == username).first() if not user_exists: user = None user_hash = Crypto.hash_bcrypt(password) try: user = User(username, user_hash, fullname, email) session.add(user) session.commit() group = session.query(Group).\ filter(Group.groupname == groupname).first() if group: user_to_group = \ add_user_to_group(session, user_id=user.id, group_id=group.id) if user_to_group['pass'] == True: return({ 'pass': True, 'message': \ 'User %s was created and added to group %s'%\ (username, groupname) }) else: return({ 'pass': False, 'message': \ 'User %s was created and not added to group %s'%\ (username, groupname) }) except Exception as e: session.rollback() return({ 'pass': False, 'message': 'User %s was not created and added to group %s'%\ (username, groupname) }) else: return({ 'pass': False, 'message': 'User %s already exists'%\ (username) })
def get_node_stats(session, nodeid=None, hostname=None, displayname=None, computername=None, username='******'): """ return a list of node_statistics in json """ session = validate_session(session) node = None if nodeid: node = session.query(NodeInfo).\ filter(NodeInfo.id == nodeid).first() elif hostname: node = session.query(NodeInfo).\ filter(NodeInfo.host_name == hostname).first() elif displayname: node = session.query(NodeInfo).\ filter(NodeInfo.display_name == displayname).first() elif computername: node = session.query(NodeInfo).\ filter(NodeInfo.computer_name == computername).first() else: result = { 'pass': False, 'message': 'Incorrect arguments passed' } if node: update_node_stats(session, node.id, username) node_stats = session.query(NodeStats).\ filter(NodeStats.node_id == node.id).first() if node_stats: result = { "id" : int(node.id), "host_name" : node.host_name, "display_name" : node.display_name, "computer_name" : node.computer_name, "ip_address" : node.ip_address, "reboots_pending" : int(node_stats.reboots_pending), "agents_down" : int(node_stats.agents_down), "agents_up" : int(node_stats.agents_up), "patches_completed" : int(node_stats.patches_installed), "patches_available" : int(node_stats.patches_available), "patches_failed" : int(noed_stats.patches_failed), "patches_pending" : int(node_stats.patches_pending) } return(result)
def list_user(session): session = validate_session(session) userlist = session.query(User).all() user_dict = {} user_groups = map(lambda x: (x[0].user_id, x[1].groupname), session.query(UsersInAGroup, Group).join(Group).all()) for i in user_groups: if str(i[0]) in user_dict: user_dict[str(i[0])].append(i[1]) else: user_dict[str(i[0])] = [i[1]] node_acl_list =[] tag_acl_list = [] global_acl_list = [] result = [] for user in userlist: if not str(user.id) in user_dict: user_dict[str(user.id)] = [] node_user_acl = session.query(NodeUserAccess).\ filter(NodeUserAccess.user_id == user.id).\ all() node_acl_list = map(lambda node: node.__dict__, node_user_acl) map(lambda node: node.pop('_sa_instance_state'), node_acl_list) global_user_acl = session.query(GlobalUserAccess).\ filter(GlobalUserAccess.user_id == user.id).\ all() global_acl_list = map(lambda user: user.__dict__, global_user_acl) map(lambda user: user.pop('_sa_instance_state'), global_acl_list) map(lambda node: node.pop('is_global'), global_acl_list) tag_user_acl = session.query(TagUserAccess).\ filter(TagUserAccess.user_id == user.id).\ all() tag_acl_list = map(lambda tag: tag.__dict__, tag_user_acl) map(lambda tag: tag.pop('_sa_instance_state'), tag_acl_list) result.append({ 'username': user.username, 'id': user.id, 'groups': user_dict[str(user.id)], 'global_acls': return_modified_list(global_acl_list), 'node_acls': return_modified_list(node_acl_list), 'tag_acls': return_modified_list(tag_acl_list) }) return result
def change_host_name(session, nodeid=None, hostname=None, username='******'): session = validate_session(session) result = None if nodeid and hostname: node = session.query(NodeInfo).\ filter(NodeInfo.id == nodeid).first() if node: try: if re.search(r'none', hostname, re.IGNORECASE): hostname = return_bool(hostname) node.host_name = hostname session.commit() logger.info('%s - Host name was changed to %s' % (username, hostname) ) result = { 'pass' : True, 'message' : 'Host name change to %s' % (hostname) } except Exception as e: session.rollback() logger.error('%s - Host name was not changed to %s' % (username, hostname) ) result = { 'pass' : False, 'message' : 'Host name was not changed to %s' % (hostname) } else: result = { 'pass' : False, 'message' : 'Invalid node_id %s' % (node_id) } else: result = { 'pass': False, 'message': 'Incorrect parameters passed' } return(result)
def change_display_name(session, nodeid=None, displayname=None, username='******'): session = validate_session(session) result = None if nodeid and displayname: node = session.query(NodeInfo).\ filter(NodeInfo.id == nodeid).first() if node: try: if re.search(r'none', displayname, re.IGNORECASE): displayname = return_bool(displayname) node.display_name = displayname session.commit() logger.info('%s - Display name was changed to %s' % (username, displayname) ) result = { 'pass' : True, 'message' : 'Display name change to %s' % (displayname) } except Exception as e: session.rollback() logger.error('%s - Display name was not changed to %s' % (username, displayname) ) result = { 'pass' : False, 'message' : "Display name was not changed to %s"% (displayname) } else: result = { 'pass': False, 'message': 'Node doesnt exist' } else: result = { 'pass': False, 'message': 'Incorrect parameters passed' } return(result)
def node_toggler(session, nodeid=None, toggle=False, username='******'): session = validate_session(session) result = None if nodeid: sslinfo = session.query(NodeInfo).\ filter(NodeInfo.id == nodeid).first() if sslinfo and toggle: sslinfo.enabled = True session.commit() logger.info('%s - ssl communication for nodeid %s %s'% (username, nodeid, 'has been enabled') ) result = { 'pass' : True, 'message' : 'node_id %s has been enabled' % (nodeid) } elif sslinfo and not toggle: sslinfo.enabled = False session.commit() logger.info('%s - ssl communication for nodeid %s %s'% (username, nodeid, 'has been disabled') ) result = { 'pass' : True, 'message' : 'node_id %s has been disabled' % (nodeid) } else: logger.warn('%s - invalid nodeid %s' % (username, nodeid)) result = { 'pass' : False, 'message' : 'node_id %s does not exist' % (nodeid) } session.close() return(result)
def get_account(self, username): self.session = validate_session(self.session) return self.session.query(User).filter(User.username == username).first()
def delete_group(session, group_id=None, username='******'): session = validate_session(session) if group_id: if int(group_id) >=5: group = session.query(Group).\ filter(Group.id == group_id).first() if group: global_acl = session.query(GlobalGroupAccess).\ filter(GlobalGroupAccess.group_id == group_id).first() tag_acl = session.query(TagGroupAccess).\ filter(TagGroupAccess.group_id == group_id).all() node_acl = session.query(NodeGroupAccess).\ filter(NodeGroupAccess.group_id == group_id).all() user_in_groups = session.query(UsersInAGroup).\ filter(UsersInAGroup.group_id == group.id).all() try: if global_acl: session.delete(global_acl) if len(node_acl) >= 1: map(lambda nodeacl: session.delete(nodeacl),\ node_acl) if len(tag_acl) >= 1: map(lambda tagacl: session.delete(tagacl),\ tag_acl) if len(user_in_groups) >= 1: map(lambda user_group: session.delete(user_group),\ user_in_groups) session.commit() session.delete(group) session.commit() logger.info('%s - user %s has been deleted'%\ (username, group.groupname) ) result = { "pass" : True, "message" : "%s group deleted" % \ (group.groupname) } except Exception as e: session.rollback() result = { "pass" : False, "message" : "%s group couldnt be deleted %s" % \ (group.groupname, e) } else: logger.info('%s - %s group doesnt exist'%\ (username, group_id) ) result = { "pass" : False, "message" : "%s group doesnt exist" % \ (group_id) } else: logger.info('%s - %s Cant delete default groups'%\ (username, group_id) ) result = {"pass" : False, "message" : "%s Cant delete default groups" % \ (group_id) } else: logger.info('%s - Need to pass the groupid'%\ (username) ) result = { 'pass': False, 'message': 'Need to pass the groupid' } return result
def save_access_token(self, token): self.session = validate_session(self.session) self.session.add(token) self.session.commit() self.session.close()
def list_tags_per_tpid(session, tpid): """ Return a json object containing the nodes and the related packages concerning that node within the tag name. arguments below.. session == sqlalchemy session object tpid == the toppatch_id of the package """ session = validate_session(session) tagdict = {} tagdict['available'] =[] tagdict['pending'] = [] tagdict['failed'] = [] tagdict['done'] = [] tagdict['pass'] = True tagdict['message'] = 'Tags found for toppatchid %s' % (tpid) tag_pos = {} i = 0 list_of_nodes = session.query(PackagePerNode).\ filter(PackagePerNode.toppatch_id == tpid).all() if len(list_of_nodes) >0: for node in list_of_nodes: list_of_tags = session.query(TagsPerNode).\ filter(TagsPerNode.node_id == node.node_id).all() if len (list_of_tags) >0: node_info = session.query(NodeInfo).\ filter(NodeInfo.id == node.node_id).first() tag_nodes = [] for tagnode in list_of_tags: tag = session.query(TagInfo).\ filter(TagInfo.id == tagnode.tag_id).first() if not tag.tag in tag_pos: tag_pos[tag.tag] = i i = i + 1 if node.installed: if not tag_pos[tag.tag] in range(len(tagdict['done'])): tagdict['done'].append({'tag_name': tag.tag, 'tag_id': tag.id, 'nodes': [return_node_json(node_info)] }) elif tag.tag in tagdict['done'][tag_pos[tag.tag]]['tag_name']: tagdict['done'][tag_pos[tag.tag]]['nodes'].append( return_node_json(node_info)) elif node.installed and node.pending: if not tag_pos[tag.tag] in range(len(tagdict['pending'])): tagdict['pending'].append({'tag_name': tag.tag, 'tag_id': tag.id, 'nodes': [return_node_json(node_info)] }) elif tag.tag in tagdict['pending'][tag_pos[tag.tag]]['tag_name']: tagdict['pending'][tag_pos[tag.tag]]['nodes'].append( return_node_json(node_info)) elif not node.installed and node.attempts >=1: if not tag_pos[tag.tag] in range(len(tagdict['failed'])): tagdict['failed'].append({'tag_name': tag.tag, 'tag_id': tag.id, 'nodes': [return_node_json(node_info)] }) elif tag.tag in tagdict['failed'][tag_pos[tag.tag]]['tag_name']: tagdict['failed'][tag_pos[tag.tag]]['nodes'].append( return_node_json(node_info)) elif not node.installed and node.attempts ==0: if not tag_pos[tag.tag] in range(len(tagdict['available'])): tagdict['available'].append({'tag_name': tag.tag, 'tag_id': tag.id, 'nodes': [return_node_json(node_info)] }) elif tag.tag in tagdict['available'][tag_pos[tag.tag]]['tag_name']: tagdict['available'][tag_pos[tag.tag]]['nodes'].append( return_node_json(node_info)) return(tagdict) else: tagdict['pass'] = False tagdict['message'] = 'Tags do not exist for toppatchid %s' % (tpid) return(tagdict)
def delete_user(session, user_id, username='******'): session = validate_session(session) result = None if user_id: user = session.query(User).\ filter(User.id == user_id).first() if user: global_acl = session.query(GlobalUserAccess).\ filter(GlobalUserAccess.user_id == user.id).first() node_acl = session.query(NodeUserAccess).\ filter(NodeUserAccess.user_id == user.id).all() tag_acl = session.query(TagUserAccess).\ filter(TagUserAccess.user_id == user.id).all() user_in_groups = session.query(UsersInAGroup).\ filter(UsersInAGroup.user_id == user.id).all() try: if user.id != 1: if global_acl: session.delete(global_acl) if len(node_acl) >= 1: map(lambda nodeacl: session.delete(nodeacl),\ node_acl) if len(tag_acl) >= 1: map(lambda tagacl: session.delete(tagacl),\ tag_acl) if len(user_in_groups) >= 1: map(lambda user_group: session.delete(user_group),\ user_in_groups) session.commit() session.delete(user) session.commit() logger.info('%s - user %s has been deleted'%\ (username, user.username) ) result = {"pass" : True, "message" : "%s user deleted" % \ (user.username) } else: logger.info('%s - user %s could not be deleted'%\ (username, user.username) ) result = {"pass" : False, "message" : "%s user could not be deleted" % \ (user.username) } except Exception as e: session.rollback() logger.info('%s - user %s could not be deleted, message:%s'%\ (username, user.username, e) ) result = {"pass" : False, "message" : "%s user could not be deleted" % \ (user.username) } else: result = {"pass" : False, "message" : "%s user does not exist" % \ (user.username) } return result
def retrieve_transactions(session, count=None, offset=None): """ Return a list of historical transactions of the RV system in json """ session = validate_session(session) transactions, total_count = get_transactions(session, count, offset) final_msg = {"count" : total_count, "data" : []} for trans in transactions: operation_received = None key_error = None results = None node = None node_info = session.query(NodeInfo).filter(NodeInfo.id == trans[1][0].node_id).first() if node_info.is_vm: vm = session.query(VirtualMachineInfo).\ filter(VirtualMachineInfo.node_id == \ node_info.id).first() if vm: vm_name = vm.vm_name else: vm_name = None if trans[1][0].operation_received: operation_received = trans[1][0].operation_received.strftime("%m/%d/%Y %H:%M") print trans if len(trans[1]) == 1: final_msg['data'].append({ "operation" : trans[1][0].operation_type, "username" : trans[1][0].username, "operation_sent" : trans[1][0].operation_sent.strftime("%m/%d/%Y %H:%M"), "operations_received" : operation_received, "node_id" : node_info.id, "node_host_name" : node_info.host_name, "node_display_name" : node_info.display_name, "node_vm_name" : vm_name, "node_ip_address" : node_info.ip_address, "node_computer_name" : node_info.computer_name, "results_received" : None, #"patch_id" : None, #"succeeded" : None, #"reboot" : None, "error" : None }) elif len(trans[1]) >= 2: final_msg['data'].append({ "operation" : trans[1][0].operation_type, "username" : trans[1][0].username, "operation_sent" : trans[1][0].operation_sent.strftime("%m/%d/%Y %H:%M"), "operations_received" : operation_received, "node_id" : node_info.id, "node_host_name" : node_info.host_name, "node_display_name" : node_info.display_name, "node_vm_name" : vm_name, "node_ip_address" : node_info.ip_address, "node_computer_name" : node_info.computer_name, "results_received" : trans[1][1].results_received.strftime("%m/%d/%Y %H:%M"), #"patch_id" : trans[1][1].patch_id, "result" : trans[1][1].succeeded, #"reboot" : trans[1][1].reboot, "error" : trans[1][1].error, }) return final_msg
def node_remover(session, node_id=None, certs=True, just_clean_and_not_delete=False, username='******'): session = validate_session(session) result = None if node_id: node = session.query(NodeInfo).\ filter(NodeInfo.id == node_id).first() if node: try: session.query(Results).\ filter(Results.node_id == node.id).delete() session.commit() session.query(Operations).\ filter(Operations.node_id == node.id).delete() session.commit() session.query(PackagePerNode).\ filter(PackagePerNode.node_id == node.id).delete() session.commit() session.query(SoftwareInstalled).\ filter(SoftwareInstalled.node_id == node.id).delete() session.commit() session.query(SoftwareAvailable).\ filter(SoftwareAvailable.node_id == node.id).delete() session.commit() session.query(NodeStats).\ filter(NodeStats.node_id == node.id).delete() session.commit() session.query(NetworkInterface).\ filter(NetworkInterface.node_id == node.id).delete() session.commit() session.query(NodeUserAccess).\ filter(NodeUserAccess.node_id == node.id).delete() session.commit() session.query(SystemInfo).\ filter(SystemInfo.node_id == node_id).delete() session.commit() if not just_clean_and_not_delete: ssl_info = session.query(SslInfo).\ filter(SslInfo.node_id == node.id).delete() session.commit() session.query(NodeInfo).\ filter(NodeInfo.id == node_id).delete() session.commit() session.query(CsrInfo).\ filter(CsrInfo.ip_address == node.ip_address).delete() session.commit() result = { 'pass': True, 'message': 'All information for %s has been deleted' % (node.host_name, 'from RemediationVault, except for ssl_info' ) } logger.info('%s - Node %s was cleaned %s' % (username, node.host_name, 'from RemediationVault, except for ssl_info' ) ) else: result = { 'pass': True, 'message': '%s has been deleted from RemediationVault' % (node.host_name) } logger.info('%s - Node %s was deleted from RemediationVault' % (username, node.host_name) ) except Exception as e: result = { 'pass': False, 'message': '%s could not be deleted from %s. Error:%s' % (node.host_name, 'RemediationVault', e) } logger.info('%s - Node %s could not be deleted from %s' % (username, node.host_name, 'RemediationVault') ) else: result = { 'pass': False, 'message': 'NodeID %s does not exist in RemediationVault' % (node_id) } logger.info('%s - Node %s does not exist in %s' % (username, node_id, 'RemediationVault') ) else: result = { 'pass': False, 'message': 'NodeID %s does not exist in RemediationVault' % (node_id) } logger.info('%s - Node %s does not exist in %s' % (username, node_id, 'RemediationVault') ) return(result)
def save_account(self, account): self.session = validate_session(self.session) self.session.add(account) self.session.commit() self.session.close()