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 save_access_token(self, token):
self.session = validate_session(self.session)
self.session.add(token)
self.session.commit()
self.session.close()
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()
