def associate_defns(self, site_id, group_id, def_type, def_ids, auth, op_level=None):
error_desc = ''
site = self.manager.getSite(site_id)
group = self.manager.getGroup(auth, group_id)
group_list = self.manager.getGroupList(auth, site_id)
def_id_list = def_ids.split(',')
for def_id in def_id_list:
new_sd = DBSession.query(StorageDef).filter_by(id=def_id).first()
node = None
sp_ids = group_id
try:
self.sync_manager.add_defn(new_sd, site, group, node, auth, to_unicode(constants.STORAGE), constants.ATTACH, 'ADD_STORAGE_DEF', self.storage_manager, self.manager, op_level, sp_ids)
except Exception as ex:
error_desc = to_str(ex)
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
add_mode = True
try:
self.sync_manager.remove_defn(new_sd, site, group, node, auth, to_unicode(constants.STORAGE), constants.DETACH, 'REMOVE_STORAGE_DEF', self.storage_manager, self.manager, add_mode, group_list, op_level)
except Exception as ex1:
print_traceback()
LOGGER.error(to_str(ex1).replace("'", ''))
raise Exception(to_str(ex1))
if error_desc:
raise Exception(error_desc)
return {'success':True,'msg':'Storage Added'}
def on_add_node(self, nodeId, groupId, site_id, auth, def_manager):
op = constants.ATTACH
if not(nodeId or groupId):
return None
defn_list = []
errs = []
sync_manager = SyncDef()
defType = def_manager.getType()
sp_defns = DBSession.query(SPDefLink).filter_by(group_id=to_unicode(groupId))
if sp_defns:
for eachdefn in sp_defns:
defn = def_manager.get_defn(eachdefn.def_id)
if defn:
defn_list.append(defn)
status = to_unicode(constants.OUT_OF_SYNC)
details = None
sync_manager.add_node_defn(nodeId, defn.id, defType, status, details)
node = DBSession.query(ManagedNode).filter_by(id=nodeId).first()
if node:
update_status = True
try:
sync_manager.sync_node(defn_list, node, groupId, site_id, auth, defType, op, def_manager, update_status, errs)
except Exception as ex:
if errs:
if len(errs)>0:
LOGGER.error('Error in syncing definition while adding node: ' + to_str(errs))
def set_transient_state(self, defn, transient_state, op, site_id=None, group_id=None, node_id=None):
scope = defn.scope
if op==constants.SCOPE_LEVEL:
if scope == constants.SCOPE_S:
def_link = DBSession.query(ServerDefLink).filter_by(server_id=node_id, def_id=defn.id).first()
else:
if scope == constants.SCOPE_SP:
def_link = DBSession.query(SPDefLink).filter_by(group_id=group_id, def_id=defn.id).first()
else:
if scope == constants.SCOPE_DC:
def_link = DBSession.query(DCDefLink).filter_by(site_id=site_id, def_id=defn.id).first()
if def_link:
if transient_state:
def_link.transient_state = to_unicode(transient_state)
else:
def_link.transient_state = None
LOGGER.info('Transient state of ' + to_str(defn.name) + ' is changed to ' + to_str(transient_state) + ' at definition scope level')
if op==constants.NODE_LEVEL:
def_link = DBSession.query(ServerDefLink).filter_by(server_id=node_id, def_id=defn.id).first()
if def_link:
if transient_state:
def_link.transient_state = to_unicode(transient_state)
else:
def_link.transient_state = None
LOGGER.info('Transient state of ' + to_str(defn.name) + ' is changed to ' + to_str(transient_state) + ' at node level')
def create_vmw_server_pool(self, auth, name, actual_name, moid, vcenter_id, parent_ent=None):
msg = ''
entityType = to_unicode(constants.SERVER_POOL)
sp = None
update_name = False
sp_ent = auth.get_entity_by_entity_attributes(self.get_entity_attributes_dict(vcenter_id, moid), entityType)
if not sp_ent:
dup_ent = auth.get_entity_by_name(name, entityType=entityType)
if dup_ent:
msg += '\nERROR: Could not import Server Pool:%s. It is already exist,please choose different name' % name
return (msg, None, None)
if sp_ent:
update_name = self.can_update_managed_object_name(auth, name, actual_name, sp_ent.name)
msg += '\nServer Pool: %s already exist' % name
sp = DBSession.query(VMWServerGroup).filter(VMWServerGroup.id == sp_ent.entity_id).first()
if sp:
if update_name:
sp.name = name
if not sp:
msg += '\nCreating Server Pool: %s' % name
sp = VMWServerGroup(name)
DBSession.add(sp)
if not sp_ent:
cntx = {'external_manager_id': vcenter_id, 'external_id': moid}
sp_ent = self.add_vcenter_entity(auth, cntx, sp.name, sp.id, to_unicode(constants.SERVER_POOL), parent_ent)
else:
if not update_name:
name = None
auth.update_entity(sp_ent, name=name, parent=parent_ent)
return (msg, sp, sp_ent)
def update_disks_size(self, auth):
from stackone.model.availability import AvailState
sites = DBSession.query(Site)
if sites:
for eachsite in sites:
site_entity = auth.get_entity(eachsite.id)
group_entities = auth.get_entities(to_unicode(constants.SERVER_POOL), site_entity)
for eachgroup in group_entities:
group = DBSession.query(ServerGroup).filter_by(id=eachgroup.entity_id).first()
if group:
group_entity = auth.get_entity(group.id)
node_entities = auth.get_entities(to_unicode(constants.MANAGED_NODE), group_entity)
for eachnode in node_entities:
node = DBSession.query(ManagedNode).filter_by(id=eachnode.entity_id).first()
is_node_up = True
objAvailState = DBSession.query(AvailState).filter_by(entity_id=node.id).first()
if objAvailState:
avail_state = objAvailState.avail_state
if avail_state == node.DOWN:
is_node_up = False
if is_node_up:
server_def_link = DBSession.query(ServerDefLink).filter_by(server_id=node.id)
if server_def_link:
for each_link in server_def_link:
defn = DBSession.query(StorageDef).filter_by(id=each_link.def_id).first()
if defn:
if defn.type == constants.NFS or defn.type == constants.OCFS or defn.type == constants.CIFS or defn.type == constants.GFS:
scan_result = self.test_storage_def(auth, node, group, eachsite, defn)
self.update_size(defn, scan_result)
def add_role(self, rolename, roledesc, type):
rolename = to_unicode(rolename)
roledesc = to_unicode(roledesc)
role = self.user_info.get_role(rolename)
if role == None:
result = self.model_controller.add_role(rolename, roledesc, type, None, True)
else:
result = dict(False, 'The role with rolename ' + rolename + ' already exists')
return result
def add_node_defn(self, node_id, def_id, def_type, status, details):
row = DBSession.query(ServerDefLink).filter_by(server_id=node_id, def_id=def_id).first()
if not row:
node_defn = ServerDefLink()
node_defn.server_id = to_unicode(node_id)
node_defn.def_type = to_unicode(def_type)
node_defn.def_id = def_id
node_defn.status = to_unicode(status)
node_defn.details = to_unicode(details)
node_defn.dt_time = datetime.now()
DBSession.add(node_defn)
def is_selected(self, auth, external_id, external_manager_id, type, parent_ent=None):
entityType = None
if type in ('HostSystem',):
entityType = to_unicode(constants.MANAGED_NODE)
elif type in ('ClusterComputeResource', 'Folder'):
entityType = to_unicode(constants.SERVER_POOL)
elif type in ('Datacenter',):
entityType = to_unicode(constants.DATA_CENTER)
ent = auth.get_entity_by_entity_attributes(self.get_entity_attributes_dict(external_manager_id, external_id), entityType, parent_ent)
if ent:
return True
return False
def save_email_setup_details(self, desc, servername, port, useremail, password, secure):
SiteRecord = DBSession.query(Site).filter(Site.name == 'Data Center').first()
if SiteRecord:
site_id = SiteRecord.id
EmailRecord = DBSession.query(EmailSetup).filter(EmailSetup.site_id == site_id).filter(EmailSetup.mail_server == servername).first()
if EmailRecord:
return dict(success=True, msg='Duplicaate Record found in list')
else:
email_setup_obj = EmailSetup(servername, desc, port, secure, site_id, useremail, password)
DBSession.add(email_setup_obj)
emailsetupid = email_setup_obj.getEmailSetupId()
EmailManager().add_entity(to_unicode(servername), emailsetupid, to_unicode(constants.EMAIL), None)
return dict(success=True, msg='New Record Added Sucessfully')
def add_defn(self, defn, site, group, node, auth, defType, op, action_op, def_manager, grid_manager, op_level, sp_ids=None, scan_result=None, csep_id=None):
scope = op_level
if scope == constants.SCOPE_S:
entityId = node.id
elif scope == constants.SCOPE_SP:
entityId = group.id
elif scope == constants.SCOPE_DC:
entityId = site.id
elif scope == constants.SCOPE_CP:
entityId = csep_id
ent = auth.get_entity(entityId)
if not auth.has_privilege(action_op, ent):
raise Exception(constants.NO_PRIVILEGE)
if scope == constants.SCOPE_SP:
if not PrivilegeOps.check_child_privileges(auth, action_op, ent):
raise Exception(constants.NO_CHILD_PRIVILEGE % ('Servers', 'Server Pool'))
DBSession.add(defn)
nw_id = defn.id
if site:
def_manager.SaveScanResult(defn.id, grid_manager, scan_result, site.id)
def_manager.RemoveScanResult(scan_result)
errs = []
details = {}
status = to_unicode(constants.OUT_OF_SYNC)
if scope == constants.SCOPE_DC:
oos_count = 0
status = to_unicode(constants.IN_SYNC)
self.add_site_defn(site.id, defn.id, defType, status, oos_count)
def_manager.manage_defn_to_groups(site, group, sp_ids, defn, defType, op, def_manager, auth, errs, grid_manager)
elif scope == constants.SCOPE_SP:
def_manager.manage_defn_to_groups(site, group, sp_ids, defn, defType, op, def_manager, auth, errs, grid_manager)
elif scope == constants.SCOPE_S:
self.add_node_defn(node.id, defn.id, defType, status, details)
update_status = True
#def_manager.add_private_ip_pool(defn)
self.sync_node_defn(auth, node, group.id, site.id, defn, defType, op, def_manager, update_status, errs)
elif scope == constants.SCOPE_CP:
oos_count = 0
status = to_unicode(constants.IN_SYNC)
self.add_csep_defn(csep_id, defn.id, defType, status, oos_count)
def_manager.manage_defn_to_groups(site, group, sp_ids, defn, defType, op, def_manager, auth, errs, grid_manager, csep_id)
details['defn_id'] = defn.id
if node:
details['node_id'] = node.id
def_manager.on_defn_creation(auth,**details)
def_manager.Recompute(defn)
if errs:
if len(errs) > 0:
LOGGER.error('Error:' + to_str(errs))
return (errs, nw_id)
def get_valid_sd(self, type, options, scope, added_manually=False):
creds_req = False
creds = {}
conn_options = {}
if type == constants.iSCSI:
creds_req = True
creds['username'] = options.get('username')
creds['password'] = options.get('password')
conn_options['server'] = options.get('portal')
conn_options['target'] = options.get('target')
conn_options['options'] = options.get('options')
conn_options['username'] = options.get('username')
conn_options['password'] = options.get('password')
if type == constants.NFS:
conn_options['server'] = options.get('server')
conn_options['share'] = options.get('share')
conn_options['mount_point'] = options.get('mount_point')
conn_options['mount_options'] = options.get('mount_options')
if type == constants.AOE:
conn_options['interface'] = options.get('interface')
if type == constants.LVM:
conn_options['volume_group'] = options.get('volume_group')
if type == constants.CIFS:
conn_options['server'] = options.get('server')
conn_options['windows_share'] = options.get('windows_share')
conn_options['mount_point'] = options.get('mount_point')
conn_options['windows_username'] = options.get('windows_username')
conn_options['windows_password'] = options.get('windows_password')
conn_options['domain'] = options.get('domain')
if type == constants.GFS:
conn_options['device'] = options.get('device')
conn_options['mount_point'] = options.get('mount_point')
if type == constants.OCFS:
conn_options['device'] = options.get('device')
conn_options['mount_point'] = options.get('mount_point')
if type == constants.FC:
conn_options['host_adapter'] = options.get('host_adapter')
conn_options['bus_channel'] = options.get('bus_channel')
conn_options['target'] = options.get('target')
conn_options['lun'] = options.get('lun')
conn_options['added_manually'] = added_manually
new_sd = StorageDef(None, to_unicode(options.get('name')), type, to_unicode(options.get('description')), conn_options, scope, creds_req)
if creds_req == True:
new_sd.set_creds(creds)
if options['total_cap']!='null':
options['total_cap'] = str(options.get('total_cap')).strip()
if options['total_cap']:
total_cap = str(options.get('total_cap'))
if not total_cap:
total_cap=0
return new_sd
def set_standby(self, standby=False):
if standby == False or standby == None:
self.standby_status = None
else:
if standby == True:
self.standby_status = to_unicode(self.STANDBY)
return None
def add_rep(self, entity, parent):
propagate = True
import tg
is_granular = tg.config.get(constants.GRANULAR_USER_MODEL)
if is_granular!='True':
propagate = False
else:
is_granular = True
role_ids = []
if propagate and (self.user is not None or self.groups is not None):
roles = self.get_user_roles()
r = DBHelper().find_by_name(Role, to_unicode(constants.DEFAULT_ROLES[0]))
if r not in roles:
roles.append(r)
role_ids=[role.id for role in roles]
reps = self.get_all_rep(parent, role_ids,is_granular)
for rep in reps:
new_rep = RoleEntityPrivilege()
new_rep.privilege = rep.privilege
prop = True
if is_granular and rep.role.id not in role_ids:
prop = rep.propagate
new_rep.propagate = prop
new_rep.role = rep.role
new_rep.entity = entity
DBHelper().add(new_rep)
def getCandidateData(self, auth, ctx, standby=False):
sp = auth.get_entity(self._group.id)
child_ents = auth.get_entities(to_unicode(constants.MANAGED_NODE), parent=sp)
if ctx.exclude_ids is not None:
ctx.exclude_ids.append(ctx.node_id)
else:
ctx.exclude_ids = []
ctx.exclude_ids.append(ctx.node_id)
LOGGER.error('exclude_ids======' + str(ctx.exclude_ids))
ids = [child_ent.entity_id for child_ent in child_ents if child_ent.entity_id not in ctx.exclude_ids]
nodelist = DBHelper().filterby(ManagedNode,[], [ManagedNode.id.in_(ids)])
load_time = self._group.getGroupVarValue('SERVER_LOAD_TIME')
try:
load_time = int(load_time)
except Exception as e:
load_time = 0
list = []
LOGGER.error('Begining initial placement on ' + self._group.name)
for n in nodelist:
if n.is_maintenance():
LOGGER.info('Node %s in Maintenance mode' % n.hostname)
count_check = self.checkVmLimit(n.id, self._group)
if count_check == True:
if n.is_standby() == standby and self.filter_node(n,ctx) and n.current_state.avail_state == ManagedNode.UP and not n.is_maintenance():
metrics = n.get_raw_metrics(load_time)
cpu_info = n.get_cpu_info()
nr_cpus = int(cpu_info.get(constants.key_cpu_count , 1))
vcpus = n.get_vcpu_count()
free_mem = int(n.get_memory_info().get(constants.key_memory_free,0))
list.append((metrics['VM_TOTAL_CPU(%)'], metrics['VM_TOTAL_MEM(%)'], vcpus / nr_cpus, n.get_VM_count(), -free_mem, n, n.hostname))
LOGGER.error('Capable nodes:\n ' + to_str(list))
LOGGER.error('Finishing initial placement on ' + self._group.name)
if len(list) == 0:
return None
return min(list)
def add_vcenter_entity(self, auth, context_dict, ent_name, ent_id, ent_type, parent_ent):
external_manager_id = context_dict.get('external_manager_id')
external_id = context_dict.get('external_id')
ent_cntx_dict = self.get_entity_context_dict(external_manager_id=external_manager_id, external_id=external_id)
ent = auth.add_entity(ent_name, ent_id, to_unicode(ent_type), parent_ent, context=ent_cntx_dict)
ent_attr_dict = self.get_entity_attributes_dict(external_manager_id=external_manager_id, external_id=external_id)
self.add_entity_attributes(ent, ent_attr_dict)
return ent
def has_privilege(self, opname, entity=None):
op = DBHelper().find_by_name(Operation, to_unicode(opname))
if op is None or entity is None:
return False
ops = self.get_ops(entity, op)
if len(ops) > 0:
return True
return False
def __init__(self, mail_server, desc, port, use_secure, site_id, useremail, password):
self.id = getHexID()
self.mail_server = to_unicode(mail_server)
self.description = desc
self.port = port
self.use_secure = use_secure
self.site_id = site_id
self.credential = Credential(self.id, u'', user_email=useremail, password=password)
def get_entity_type(self, klass_name):
from psphere.managedobjects import Datacenter
from psphere.managedobjects import ClusterComputeResource
from psphere.managedobjects import HostSystem
from psphere.managedobjects import ComputeResource
from psphere.managedobjects import VirtualMachine
from psphere.managedobjects import Folder
TYPE_MAP = {Datacenter.__name__: to_unicode(constants.DATA_CENTER), ClusterComputeResource.__name__: to_unicode(constants.SERVER_POOL), Folder.__name__: to_unicode(constants.SERVER_POOL), HostSystem.__name__: to_unicode(constants.MANAGED_NODE), ComputeResource.__name__: to_unicode(constants.MANAGED_NODE), VirtualMachine.__name__: to_unicode(constants.DOMAIN)}
return TYPE_MAP.get(klass_name)
def isVMRunningInPool(self, auth, group_id):
returnVal = False
ent = auth.get_entity(group_id)
nodes = auth.get_entities(to_unicode(constants.MANAGED_NODE), parent=ent)
for eachnode in nodes:
returnVal = self.isVMRunningOnServer(auth, eachnode.entity_id)
if returnVal == True:
break
return returnVal
def check_privilege(self, opname, entities):
op = DBHelper().find_by_name(Operation, to_unicode(opname))
if op is None:
return False
for ent in entities:
ops = self.get_ops(ent, op)
if len(ops) == 0:
return False
return True
def getNodeList(self,auth):
ent=auth.get_entity(self.id)
nodelist={}
if ent is not None:
child_ents=auth.get_entities(to_unicode(constants.MANAGED_NODE),parent=ent)
ids = [child_ent.entity_id for child_ent in child_ents]
nodes= DBHelper().filterby(ManagedNode,[],[ManagedNode.id.in_(ids)])
for node in nodes:
nodelist[node.id]=node
return nodelist
def add_csep_defn(self, csep_id, def_id, def_type, status, oos_count):
row = DBSession.query(CSEPDefLink).filter_by(csep_id=csep_id, def_id=def_id).first()
if not row:
CPDL = CSEPDefLink()
CPDL.csep_id = csep_id
CPDL.def_type = def_type
CPDL.def_id = def_id
CPDL.status = to_unicode(status)
CPDL.oos_count = oos_count
CPDL.dt_time = datetime.now()
DBSession.add(CPDL)
def add_site_defn(self, site_id, def_id, def_type, status, oos_count):
row = DBSession.query(DCDefLink).filter_by(site_id=site_id, def_id=def_id).first()
if not row:
DCDL = DCDefLink()
DCDL.site_id = site_id
DCDL.def_type = def_type
DCDL.def_id = def_id
DCDL.status = to_unicode(status)
DCDL.oos_count = oos_count
DCDL.dt_time = datetime.now()
DBSession.add(DCDL)
def is_admin_role(self):
r = DBHelper().find_by_name(Role, to_unicode(constants.DEFAULT_ROLES[0]))
if self.user:
if self.user.is_cloud():
return self.user.has_cloudadmin_role()
return self.user.has_role(r)
if self.groups:
for g in self.groups:
g = DBSession.query(Group).filter(Group.group_id == g.group_id).first()
if g and r.id ==g.role.id:
return True
return False
def populate_appliance_feeds(self):
feeds = {}
for c, c_info in self.catalogs.iteritems():
print c, c_info
if type(c_info) in [types.StringType, types.UnicodeType]:
url = c_info
try:
feed_conf = self.fetch_catalog(c, url)
except Exception as ex:
feed_conf = self.get_conf_name(c)
print "Error getting catalog ", c, url, ex
print "Continue using the existing data"
if not os.path.exists(feed_conf):
print "Skipping : %s does not exist.", feed_conf
feed = PyConfig(self.local_node, feed_conf)
for k, v in feed.iteritems():
feeds[k] = v
a_feeds = []
for k in feeds.iteritems():
a_feed = ApplianceFeed(to_unicode(k))
a_feed.feed_name = to_unicode(v["feed_name"])
a_feed.feed_url = to_unicode(v["feed_url"])
a_feed.provider_logo_url = to_unicode(v["logo_url"])
a_feed.provider_name = to_unicode(v["provider"])
a_feed.provider_url = to_unicode(v["provider_url"])
a_feeds.append(a_feed)
DBHelper().truncate(ApplianceFeed)
DBHelper().add_all(a_feeds)
return a_feeds
def get_vlan_network_info(self, cidr, num_networks, network_size, vlan_start, interface, **msg):
num_networks = int(num_networks)
network_size = int(network_size)
vlan_start = int(vlan_start)
msg = "\nnum_networks:%s, network_size:%s, vlan_start:%s, cidr:%s, interface:%s " % (
num_networks,
network_size,
vlan_start,
cidr,
interface,
)
print msg
LOGGER.info(msg)
if num_networks + vlan_start > 4094:
raise ValueError("The sum between the number of networks and the vlan start cannot be greater than 4094")
fixed_net = netaddr.IPNetwork(cidr)
msg = "\nfixed_net:%s, num_networks*network_size:%s" % (len(fixed_net), num_networks * network_size)
print msg
LOGGER.info(msg)
if len(fixed_net) < num_networks * network_size:
raise ValueError(
"The network range is not big enough to fit %(num_networks)s. Network size is %(network_size)s"
% locals()
)
private_ip_bottom_reserve = int(tg.config.get("private_ip_bottom_reserve", 10))
private_ip_top_reserve = int(tg.config.get("private_ip_top_reserve", 2))
interface_str = "x"
if interface:
if_str = re.sub("\\D", "", interface)
if if_str:
interface_str = if_str
result = []
for index in range(num_networks):
vlan = vlan_start + index
start = index * network_size
significant_bits = 32 - int(math.log(network_size, 2))
cidr = "%s/%s" % (fixed_net[start], significant_bits)
project_net = netaddr.IPNetwork(cidr)
net = {}
net["cidr"] = to_unicode(cidr)
net["netmask"] = to_unicode(project_net.netmask)
net["gateway"] = to_unicode(list(project_net)[1])
net["broadcast"] = to_unicode(project_net.broadcast)
net["vpn_private_address"] = to_unicode(list(project_net)[2])
net["dhcp_start"] = to_unicode(list(project_net)[private_ip_bottom_reserve])
net["dhcp_end"] = to_unicode(list(project_net)[private_ip_top_reserve * -1])
net["vlan_id"] = vlan
net["bridge"] = to_unicode("br%s_%s" % (interface_str, vlan))
result.append(net)
return result
def heartbeat(self):
if self.isRemote == False:
return [self.UP, u'Localhost is always up']
try:
state = self.node_proxy.get_power_state()
except VCenterDownError as ex:
print '===ex1============',
print ex
return [self.current_state.avail_state, u'vCenter Down. ' + to_unicode(ex)]
except urllib2.URLError as ex:
print '===ex2============',
print ex
return [self.DOWN, u'Host not found. ' + to_unicode(ex)]
except suds.WebFault as ex:
print '===ex3============',
print ex
return [self.DOWN, u'Host not found. ' + to_unicode(ex)]
except Exception as ex:
print '===ex5=========',
print ex
return [self.DOWN, u'Host not found. ' + to_unicode(ex)]
return self.get_power_state(state)
def storage_def_test(self, auth, storage_id, nodeId, groupId, site_id, type, mode, opts, scope, show_available='true', vm_config_action=None, disk_option=None):
if mode == 'SELECT':
result = self.get_storage_disks_for_test(storage_id, show_available, vm_config_action, disk_option)
return result
try:
self.storage_manager.RemoveScanResult()
group = self.manager.getGroup(auth, groupId)
managed_node = self.manager.getNode(auth, nodeId)
if not managed_node:
raise Exception('Managed Server not found.')
try:
managed_node.connect()
except AuthenticationException as ex:
if opts.has_key('username') and opts.has_key('password'):
managed_node.set_credentials(opts['username'], opts['password'])
try:
managed_node.connect()
except AuthenticationException as ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
return ("{success: false,msg: '", to_str(ex).replace("'", ''), "',error:'Not Authenticated'}")
else:
return ("{success: false,msg: '", to_str(ex).replace("'", ''), "',error:'Not Authenticated'}")
sd = None
if mode == 'TEST' or mode == 'EDIT' or mode == 'SELECT':
sd = self.storage_manager.get_sd(storage_id, site_id, groupId, to_unicode(constants.STORAGE))
else:
sd = self.get_valid_sd(type, opts, scope)
if site_id:
if site_id == 'data_center':
site = self.manager.getSiteByGroupId(group.id)
else:
site = self.manager.getSite(site_id)
else:
site = self.manager.getSiteByGroupId(group.id)
result = self.test_storage_def(auth, managed_node, group, site, sd)
if result or mode == 'NEW' or mode == 'EDIT':
#if not mode == 'NEW' or mode == 'EDIT':
try:
session[constants.SCAN_RESULT] = result
session.save()
except Exception as ex:
print_traceback()
LOGGER.error('Error while keeping the scan result in session: ' + to_str(ex).replace("'", ''))
except Exception as ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
return dict(success=False, msg=to_str(ex).replace("'", ''))
return result
def getNodeList(self, auth, groupId=None):
LOGGER.debug('In getNodeList')
if groupId is None:
return []
ent = auth.get_entity(groupId)
nodelist = []
if ent is not None:
child_ents = auth.get_entities(to_unicode(constants.MANAGED_NODE),parent = ent)
node_ids = [child_ent.entity_id for child_ent in child_ents]
nodelist = DBSession.query(ManagedNode)\
.filter(ManagedNode.id.in_(node_ids)).order_by(ManagedNode.standby_status.desc())\
.order_by(ManagedNode.hostname.asc()).all()
return nodelist
return []
def task_fail_start(self, exception, conn):
results = to_str(exception)
self.curr_instance = datetime.now()
res = TaskResult(self.task_id, self.curr_instance, self.FAILED, results)
u = User.by_user_name(self.user_name)
if u is None:
u = User.by_user_name(u'admin')
email = u.email_address
notification = Notification(to_unicode(self.task_id), self.name, self.curr_instance, results, self.user_name, email)
conn.merge(res)
conn.add(notification)
if not self.repeating and self.entity_id != None:
UIUpdateManager().set_updated_tasks(self.task_id, self.user_name, self.entity_id)
return None
