def delete_relations(self,entity):
DBHelper().delete_all(EntityRelation,[],\
[EntityRelation.src_id==entity.entity_id,
EntityRelation.relation==u'Children'])
DBHelper().delete_all(EntityRelation,[],\
[EntityRelation.dest_id==entity.entity_id,
EntityRelation.relation==u'Children'])
def migration_vm_checks(self, vm_name, dest_node, live):
"""
Implements a series of compatiblity checks required for successful
migration.
"""
(err_list, warn_list) = VNode.migration_vm_checks(self, vm_name,
dest_node, live)
if self.is_up():
vm = self.get_dom(vm_name)
else:
vm = DBHelper().find_by_name(VM,vm_name)
if vm == None :
err_list.append(("VM", "VM %s not found."% vm_name))
return (err_list, warn_list)
# mem assumed to be in MB (same unit)
vm_memory = 0
if vm.is_running():
vm_memory = vm["memory"]
if dest_node.is_up():
node_free_mem = self.guess_free_mem(dest_node)
if int(vm_memory) > node_free_mem:
err_list.append(("Memory","Insufficient memory on destination node. " \
"VM memory %s, free memory on destination node %s " %
(vm["memory"], node_free_mem)))
# TBD : compare CPUs. This needs to encode compatibility list.
# check AMD/INTEL
# X86/X32
# 32 bit vs 64 bit kernel
# critical files available or not.
vm_conf = vm.get_config()
if vm_conf is not None and dest_node.is_up():
bootloader = vm_conf["bootloader"]
if bootloader and bootloader.strip() is not "":
if not dest_node.node_proxy.file_exists(bootloader.strip()):
err_list.append(("Bootloader","Bootloader %s for %s vm not found on destination node." % (bootloader.strip(), vm.name)))
kernel = vm_conf["kernel"]
if kernel and kernel.strip() is not "":
if not dest_node.node_proxy.file_exists(kernel.strip()):
err_list.append(("Kernel","Kernel %s for %s vm not found on destination node." % (kernel.strip(), vm.name)))
ramdisk = vm_conf["ramdisk"]
if ramdisk and ramdisk.strip() is not "":
if not dest_node.node_proxy.file_exists(ramdisk.strip()):
err_list.append(("Ramdisk", "Ramdisk %s for %s vm not found on destination node." % (ramdisk.strip(), vm.name)))
# hvm availablity
if vm_conf and vm_conf.is_hvm() \
and dest_node.get_platform_info().get("xen_caps","").find("hvm")==-1:
err_list.append(("HVM","VM %s requires hvm capabilities which are not found on destination node." % (vm.name)))
# TBD : PAE kernel check
return (err_list, warn_list)
def edit_group_details(self,groupid):
result=[]
group=Group()
session=DBHelper().get_session()
group=session.query(Group).filter(Group.group_id==groupid).first()
result.append(dict(groupid=group.group_id,groupname=group.group_name,createdby=group.created_by,modifiedby=group.modified_by,createddate=group.created_date,modifieddate=group.modified_date,desc=group.description))
return result
def get_nws(self,auth,image_id=None,dom_id=None,node_id=None, op_level=None):
vm_config=None
if dom_id is not None:
# dom=NodeService().get_dom(auth,dom_id,node_id)
dom=DBHelper().find_by_name(VM,dom_id)
vm_config=dom.get_config()
elif image_id is not None:
image=ImageService().get_image(auth,image_id)
(vm_config,img_conf)=image.get_configs()
if not vm_config:
return
managed_node=None
if node_id is not None:
managed_node=NodeService().get_managed_node(auth,node_id)
if managed_node is not None:
self.managed_node=managed_node
vifs = vm_config.getNetworks()
result=[]
for vif in vifs:
result.append(self.get_nw_entry(vif, op_level))
return result
def updatesave_group_details(self,login,groupid, groupname, userids,desc):
result = []
group=Group()
session=DBHelper().get_session()
if groupname in constants.DEFAULT_GROUPS:
user=session.query(User).filter(User.user_name==constants.DEFAULT_USERS[0]).first()
new_ids =[]
if userids !="":
new_ids=(userids).split(',')
new_ids = [int(id) for id in new_ids]
if user.user_id not in new_ids:
raise Exception("Can not remove user "+user.user_name+" from "+groupname)
group=session.query(Group).filter(Group.group_id==groupid).first()
group.group_name=groupname
group.description=desc
group.modified_date=datetime.now()
group.modified_by=(login)
for user in group.users:
group.users.remove(user)
if userids !="":
L=(userids).split(',')
for i in L:
user=session.query(User).filter(User.user_id==int(i)).first()
group.users.append(user)
DBHelper().update(group)
return result
def edit_op_det(self,opid,enttype):
result=[]
op=Operation()
session=DBHelper().get_session()
op=session.query(Operation).filter(Operation.id==opid).first()
entitytype=(enttype)
result.append(dict(opid=op.id,opname=op.name,desc=op.description,contextdisplay=op.display,enttype=entitytype,createdby=op.created_by,modifiedby=op.modified_by,createddate=op.created_date,modifieddate=op.modified_date,dispname=op.display_name,icon=op.icon))
return result
def edit_enttype_details(self,enttypeid):
result=[]
session=DBHelper().get_session()
ent=session.query(EntityType).filter(EntityType.id==enttypeid).first()
enttypeid=ent.id
entname=ent.name
entdisp=ent.display_name
result.append(dict(enttypeid=enttypeid,entname=entname,entdisp=entdisp,createdby=ent.created_by,modifiedby=ent.modified_by,createddate=ent.created_date,modifieddate=ent.modified_date))
return result
def get_tooperations_map(self,opsgroupid):
result= []
session=DBHelper().get_session()
opsgroup=session.query(OperationGroup).filter(OperationGroup.id==opsgroupid).first()
operatiions=opsgroup.operations
for o in operatiions:
oid=o.id
oname=(o.name)
result.append(dict(operationid=oid,operationname=oname))
return result
def get_tousers_map(self,groupid):
result= []
session=DBHelper().get_session()
group=session.query(Group).filter(Group.group_id==groupid).first()
users=group.users
for u in users:
uid=u.user_id
uname=(u.user_name)
result.append(dict(userid=uid,username=uname))
return result
def edit_opsgroup_details(self,opsgroupid):
result=[]
session=DBHelper().get_session()
opsgroup=session.query(OperationGroup).filter(OperationGroup.id==opsgroupid).first()
opsgrpid=opsgroup.id
opsgrpname=opsgroup.name
opsgrpdesc=opsgroup.description
result.append(dict(opsgroupid=opsgrpid,opsgroupname=opsgrpname,opsgroupdesc=opsgrpdesc,createdby=opsgroup.created_by,modifiedby=opsgroup.modified_by,createddate=opsgroup.created_date,modifieddate=opsgroup.modified_date))
return result
def get_tousers_map(self, groupid):
result = []
session = DBHelper().get_session()
group = session.query(Group).filter(Group.group_id == groupid).first()
users = group.users
for u in users:
uid = u.user_id
uname = (u.user_name)
result.append(dict(userid=uid, username=uname))
return result
def get_entities(self,entityType,parent=None):
ents=[]
type=DBHelper().find_by_name(EntityType,entityType)
filters=[Entity.type_id==type.id]
if parent is not None:
ids=[x.entity_id for x in parent.children]
filters.append(Entity.entity_id.in_(ids))
orderby=[Entity.name.asc()]
ents=DBHelper().filterby(Entity,[],filters,orderby)
return ents
def get_tooperations_map(self, opsgroupid):
result = []
session = DBHelper().get_session()
opsgroup = session.query(OperationGroup).filter(
OperationGroup.id == opsgroupid).first()
operatiions = opsgroup.operations
for o in operatiions:
oid = o.id
oname = (o.name)
result.append(dict(operationid=oid, operationname=oname))
return result
def get_entity_ids(self,entityType,parent=None):
type=DBHelper().find_by_name(EntityType,entityType)
filters=[Entity.type_id==type.id]
if parent is not None:
ids=[x.entity_id for x in parent.children]
filters.append(Entity.entity_id.in_(ids))
ents=DBHelper().filterby(Entity,[],filters)
ent_ids=[]
for ent in ents:
ent_ids.append(ent.entity_id)
return ent_ids
def add_entity(self, name, entity_id, entityType, parent):
try:
type = DBHelper().find_by_name(EntityType, entityType)
e = Entity()
e.name = name
e.type = type
e.entity_id = entity_id
e.parent = parent
DBHelper().add(e)
except Exception, e:
raise e
def get_disks(self,auth,image_id,mode,dom_id,node_id,group_id,action):
result=[]
try:
if action=="change_vm_settings":
return self.disk_data(auth,dom_id,node_id,mode)
else:
image=self.image_store.get_image(auth,image_id)
if image is None:
raise Exception("Can not find the specified Image.")
grp_settings={}
group=self.manager.getGroup(auth,group_id)
if group is not None:
grp_settings = group.getGroupVars()
disks=[]
vm_config,image_config = image.get_configs()
if mode !="NEW":
if dom_id is not None :
# dom = self.node_service.get_dom(auth,dom_id,node_id)
dom=DBHelper().find_by_name(VM,dom_id)
vm_config=dom.get_config()
if action!='edit_image_settings':
merge_pool_settings(vm_config,image_config,grp_settings, True)
vm_config.instantiate_config(image_config)
disks = vm_config.getDisks(image_config)
else:
new_disk = self.get_new_disk_entry(image_config)
if action!='edit_image_settings':
if grp_settings.get('VM_DISKS_DIR',None) is not None:
new_disk.filename=new_disk.filename.replace('$VM_DISKS_DIR',grp_settings.get('VM_DISKS_DIR'))
elif image_config.get('VM_DISKS_DIR') is not None:
new_disk.filename=new_disk.filename.replace('$VM_DISKS_DIR',image_config.get('VM_DISKS_DIR'))
disks=[new_disk]
# print "DDDDDDEVICe =",disks
# vm_config,image_config = image.get_configs()
is_remote=False
for disk in disks:
if vm_config:
is_remote = vm_config.get_storage_stats().get_remote(disk.filename)
storage_disk_id = vm_config.get_storage_stats().get_storage_disk_id(disk.filename)
result.append(dict(type=disk.type,filename=disk.filename,device=disk.device,
mode=disk.mode,shared=is_remote,option=disk.option,disk_create=disk.disk_create,
size=disk.size,disk_type=disk.disk_type,image_src=disk.image_src,
image_src_type=disk.image_src_type,image_src_format=disk.image_src_format,fs_type=disk.fs_type,storage_disk_id=storage_disk_id))
except Exception, ex:
print_traceback()
raise ex
def disk_data(self,auth,dom_id,node_id,mode):
result=[]
vm_config=None
if mode !="NEW":
# dom = self.node_service.get_dom(auth,dom_id,node_id)
dom=DBHelper().find_by_name(VM,dom_id)
if dom is None:
raise Exception("Can not find the specified .")
vm_config=dom.get_config()
disks=VMDiskManager(vm_config).getDisks(dom.id)
else:
#new_disk = self.get_new_disk_entry(None)
#TODO: think about this, can we change this
new_disk = VMDiskManager(vm_config).get_new_disk_entry()
disks=[new_disk]
is_remote=False
for disk in disks:
storage_disk_id = ""
storage_id = ""
storage_name=None
if vm_config:
#is_remote = vm_config.get_storage_stats().get_remote(disk.filename)
is_remote = VMDiskManager(vm_config).get_remote(disk.disk_name)
#storage_disk_id = vm_config.get_storage_stats().get_storage_disk_id(disk.filename)
storage_disk_id = VMDiskManager(vm_config).get_storage_disk_id(disk.disk_name)
storage_id = VMDiskManager(vm_config).get_storage_id(disk.disk_name)
if storage_disk_id:
vm_storage_link = DBSession.query(VMStorageLinks).filter_by(vm_disk_id=disk.id, storage_disk_id=storage_disk_id).first()
if vm_storage_link:
if storage_id:
defn = self.storage_manager.get_defn(storage_id)
storage_name = defn.name
"""
result.append(dict(type=disk.type,filename=disk.filename,device=disk.device,
mode=disk.mode,shared=is_remote,option=disk.option,disk_create="",
size=disk.size,disk_type=disk.disk_type,image_src=disk.image_src,
image_src_type=disk.image_src_type,image_src_format=disk.image_src_format,fs_type="",storage_disk_id=storage_disk_id))
"""
if mode!="NEW":
disk_gb=disk.disk_size*1024
disk_size=round(disk_gb)
else:
disk_size=disk.disk_size
result.append(dict(type=disk.disk_type,filename=disk.disk_name,device=disk.dev_type,
mode=disk.read_write,shared=is_remote,option="",disk_create="",
size=disk_size,disk_type=disk.disk_type,image_src="",
image_src_type="",image_src_format="",fs_type=disk.file_system,
storage_disk_id=storage_disk_id, storage_id=storage_id,
storage_name=storage_name,sequence=disk.sequence))
return result
def get_entity_names(self,entityType,parent=None):
ents=[]
if entityType is None or parent is None:
return []
type=DBHelper().find_by_name(EntityType,entityType)
filters=[Entity.type_id==type.id]
ids=[x.entity_id for x in parent.children]
filters.append(Entity.entity_id.in_(ids))
ents=DBHelper().filterby(Entity,[],filters)
ent_names=[]
for ent in ents:
ent_names.append(ent.name)
return ent_names
def get_entity_by_name(self,name,entityType=None,parent=None):
filters=[Entity.name==name]
if entityType is not None:
type=DBHelper().find_by_name(EntityType,entityType)
filters.append(Entity.type_id==type.id)
if parent is not None:
ids=[x.entity_id for x in parent.children]
filters.append(Entity.entity_id.in_(ids))
ents=DBHelper().filterby(Entity,[],filters)
ent=None
if(len(ents)>0):
ent=ents[0]
return ent
def save_opsgroup_details(self, login, opsgroupname, opsgroupdesc,
operation):
dupOpsgrp = None
db = DBHelper()
session = DBHelper().get_session()
dupOpsgrp = session.query(OperationGroup).filter(
OperationGroup.name == opsgroupname).first()
opsgroup = OperationGroup()
if dupOpsgrp is None:
result = []
opsgroup.name = (opsgroupname)
opsgroup.description = (opsgroupdesc)
opsgroup.created_by = (login)
opsgroup.modified_by = (login)
opsgroup.created_date = datetime.now()
L = ((operation)).split(',')
for i in L:
oper = session.query(Operation).filter(
Operation.id == int(i)).first()
opsgroup.operations.append(oper)
db.add(opsgroup)
return result
else:
result = "False"
return result
def updatesave_op_det(self, login, opid, opname, desc, entid, context_disp,
dispname, icon):
result = []
op = Operation()
db = DBHelper()
session = DBHelper().get_session()
op = session.query(Operation).filter(Operation.id == opid).first()
op.name = (opname)
op.description = (desc)
op.modified_date = datetime.now()
op.modified_by = (login)
op.display_name = (dispname)
op.icon = (icon)
if context_disp == "true":
op.display = True
else:
op.display = False
for i in op.entityType:
op.entityType.remove(i)
L = (entid).split(',')
if entid != "":
for i in L:
ent = session.query(EntityType).filter(
EntityType.id == int(i)).first()
op.entityType.append(ent)
db.update(op)
return result
def edit_group_details(self, groupid):
result = []
group = Group()
session = DBHelper().get_session()
group = session.query(Group).filter(Group.group_id == groupid).first()
result.append(
dict(groupid=group.group_id,
groupname=group.group_name,
createdby=group.created_by,
modifiedby=group.modified_by,
createddate=group.created_date,
modifieddate=group.modified_date,
desc=group.description))
return result
def updatesave_enttype_details(self, login, enttypeid ,enttypename, dispname):
result = []
ent=EntityType();
db=DBHelper()
session=DBHelper().get_session()
ent=session.query(EntityType).filter(EntityType.id==enttypeid).first()
ent.name=enttypename
ent.display_name=dispname
ent.modified_by=(login)
ent.modified_date=datetime.now()
db.update(ent);
return result
def save_group_details(self, login, groupid, groupname, userids, desc):
dupGrp = None
group = Group()
db = DBHelper()
session = DBHelper().get_session()
dupGrp = session.query(Group).filter(
Group.group_name == groupname).first()
if dupGrp is None:
result = []
group.group_name = groupname
group.created_by = (login)
group.modified_by = (login)
group.created_date = datetime.now()
group.description = desc
L = (userids).split(',')
if userids != "":
for i in L:
user = session.query(User).filter(
User.user_id == int(i)).first()
group.users.append(user)
db.add(group)
return result
else:
result = "False"
return result
def update_entity(self,entity,name=None,parent=None,new_entityId=None):
try:
if name is not None:
entity.name=name
if parent is not None:
old_prnt=entity.parents[0]
self.delete_entity_relation(old_prnt.entity_id,entity.entity_id,u'Children')
DBHelper().add(EntityRelation(parent.entity_id,entity.entity_id,u'Children'))
if new_entityId is not None:
entity.entity_id=new_entityId
DBHelper().add(entity)
except Exception, e:
raise e
def save_oper_det(self, login, opname, descr, context_disp, entityid,
dispname, icon):
result = []
dupOp = None
operation = Operation()
db = DBHelper()
session = DBHelper().get_session()
dupOp = session.query(Operation).filter(
Operation.name == opname).first()
if dupOp is None:
operation.name = (opname)
operation.description = (descr)
operation.display_name = (dispname)
operation.icon = (icon)
operation.created_by = (login)
operation.modified_by = (login)
operation.created_date = datetime.now()
if context_disp == "true":
operation.display = True
else:
operation.display = False
L = (entityid).split(',')
for i in L:
ent = session.query(EntityType).filter(
EntityType.id == int(i)).first()
operation.entityType.append(ent)
db.add(operation)
return result
else:
result = "False"
return result
def get_operations(self):
result = []
operations = DBHelper().get_all(Operation)
for op in operations:
strname = ''
opname = op.name
desc = op.description
ctxdisp = op.display
opid = op.id
for e in op.entityType:
disp_name = ''
if e.display_name is not None:
disp_name = e.display_name
strname += disp_name + " ,"
else:
strname += disp_name + " ,"
strname = strname[0:-1]
result.append(
dict(opname=opname,
description=desc,
cd=ctxdisp,
enttype=strname,
opid=opid))
return result
def get_opsgroups(self):
result = []
strent = ''
opsgrp = DBHelper().get_all(OperationGroup)
for og in opsgrp:
i = 0
sname = og.name
opsgroupid = og.id
strop = ''
stropid = ''
for o in og.operations:
strop = o.name
desc = o.description
opsgroupname = ""
stropid = o.id
if i == 0:
opsgroupname = og.name
i += 1
for e in o.entityType:
strent = e.display_name
result.append(
dict(opsgroupid=opsgroupid,
opsgrpname=opsgroupname,
opname=strop,
opid=stropid,
desc=desc,
entitytype=strent,
searchName=sname))
return result
def basic_initialize():
global local_node, client_config, store, registry, image_store, manager, storage_manager
global nw_manager, appliance_store
try:
local_node = ManagedNode(hostname=constants.LOCALHOST,
isRemote=False,
helper=None)
#client_config = local_node.config
#store = client_config
registry = PlatformRegistry(client_config, {})
#image_store = ImageStore(local_node.config, registry)
image_stores = DBHelper().get_all(ImageStore)
if len(image_stores) > 0:
image_store = image_stores[0]
image_store.set_registry(registry)
manager = GridManager(client_config, registry, None)
storage_manager = StorageManager()
nw_manager = NwManager()
appliance_store = ApplianceStore(local_node, client_config)
except Exception, e:
import traceback
traceback.print_exc()
raise e
def __init__(self, local_node, config):
self.local_node = local_node
self.config = config
self._feeds = None
self.cache_dir = None
self.catalogs = {}
# List of appliances keyd by feed name
self.appliance_list = {}
self.appliance_store_dir = config.get(constants.prop_appliance_store)
if self.appliance_store_dir is None or self.appliance_store_dir is '':
self.appliance_store_dir = self.DEFAULT_APPLIANCE_STORE
# self.catalog_conf_file = os.path.join(self.appliance_store_dir,
# self.CATALOG_CONF)
# self.catalog_conf = PyConfig(self.local_node,self.catalog_conf_file)
#
# catalogs = self.catalog_conf.get("catalogs")
# import pprint
# pprint.pprint(catalogs)
# if catalogs:
# self.catalogs = catalogs
catalogs = DBHelper().get_all(ApplianceCatalog)
for catalog in catalogs:
self.catalogs[catalog.name] = catalog.url
print self.catalogs
# create the cache dir if it does not exist
mkdir2(self.local_node, self.get_cache_dir())
def delete_user(self, userid):
userid = int(userid)
user = DBSession.query(User).filter(User.user_id == userid).first()
if user is not None:
if user.user_name in constants.DEFAULT_USERS:
raise Exception("Can not delete " + user.user_name + " user.")
DBHelper().delete_all(User, [], [User.user_id == userid])
def get_ops(self,entity,op=None):#
filters=[Entity.entity_id==entity.entity_id]
if op is not None:
filters.append(Operation.id==op.id)
ops=DBHelper().filterby(Operation,[Operation.entityType,Operation.opsGroup,Entity],
filters,[Operation.display_seq])
return ops
def get_emailsetupinfo(self):
result = []
emailsetups = DBHelper().get_all(
EmailSetup) #site id needs to be added in the filter
for obj in emailsetups:
result.append(dict(emailsetup_id=obj.id,servername=obj.mail_server,\
desc=obj.description, username = obj.credential.cred_details['user_email'], port = obj.port) )
return result
def remove_entity(self,entity):
try:
self.delete_relations(entity)
gc=GenericCache()
gc.on_delete_entity(entity.entity_id, entity.type.name)
DBHelper().delete(entity)
except Exception, e:
raise e
def get_emailsetup_details(self, emailsetup_id):
result = []
emailSetupobj = DBHelper().find_by_id(EmailSetup, emailsetup_id)
result.append(dict(emailsetup_id=emailSetupobj.id, servername=emailSetupobj.mail_server, \
desc=emailSetupobj.description, port = emailSetupobj.port, use_secure = emailSetupobj.use_secure ,\
username = emailSetupobj.credential.cred_details['user_email'],\
password = emailSetupobj.credential.cred_details['password']))
return result
def add_entity(self,name,entity_id,entityType,parent):
try:
type=DBHelper().find_by_name(EntityType,entityType)
e=Entity()
e.name=name
e.type=type
e.entity_id=entity_id
#e.parent=parent
DBHelper().add(e)
DBHelper().add(EntityRelation(parent.entity_id,entity_id,u'Children'))
###Added to remove the referential integrity error due to transaction
###that SA/MySQL innodb is supposed to take care
gc=GenericCache()
gc.on_add_entity(e.type.name)
DBSession.flush()
except Exception, e:
raise e
def remove_entity_by_id(self,entityId,entityType=None,parent=None):
try:
entity=self.get_entity(entityId, entityType,parent)
self.delete_relations(entity)
gc=GenericCache()
gc.on_delete_entity(entityId, entity.type.name)
DBHelper().delete(entity)
except Exception, e:
raise e
def delete_group(self, groupid):
groupid = int(groupid)
group = DBSession.query(Group).filter(
Group.group_id == groupid).first()
if group is not None:
if group.group_name in constants.DEFAULT_GROUPS:
raise Exception("Can not delete " + group.group_name +
" group.")
DBHelper().delete_all(Group, [], [Group.group_id == groupid])
def edit_opsgroup_details(self, opsgroupid):
result = []
session = DBHelper().get_session()
opsgroup = session.query(OperationGroup).filter(
OperationGroup.id == opsgroupid).first()
opsgrpid = opsgroup.id
opsgrpname = opsgroup.name
opsgrpdesc = opsgroup.description
result.append(
dict(opsgroupid=opsgrpid,
opsgroupname=opsgrpname,
opsgroupdesc=opsgrpdesc,
createdby=opsgroup.created_by,
modifiedby=opsgroup.modified_by,
createddate=opsgroup.created_date,
modifieddate=opsgroup.modified_date))
return result
def edit_enttype_details(self, enttypeid):
result = []
session = DBHelper().get_session()
ent = session.query(EntityType).filter(
EntityType.id == enttypeid).first()
enttypeid = ent.id
entname = ent.name
entdisp = ent.display_name
result.append(
dict(enttypeid=enttypeid,
entname=entname,
entdisp=entdisp,
createdby=ent.created_by,
modifiedby=ent.modified_by,
createddate=ent.created_date,
modifieddate=ent.modified_date))
return result
def scan_imagestore_details(self,auth,imagestore_id):
images=DBHelper().get_all(Image)
img_names= [image.name for image in images]
(entities,rej_imgs)=self.image_store.scan_dirs(auth,imagestore_id)
ent_names= [ent.name for ent in entities]
new_imgs=[]
for name in ent_names:
if name not in img_names:
new_imgs.append(name)
return (new_imgs,rej_imgs)
def save_enttype_details(self,login,enttypename,dispname):
dupEnt=None
db=DBHelper()
session=DBHelper().get_session()
dupEnt=session.query(EntityType).filter(EntityType.name==enttypename).first()
if dupEnt is None:
result=[]
ent=EntityType();
ent.name=(enttypename)
ent.display_name=(dispname)
ent.created_by=(login)
ent.created_date=datetime.now()
ent.modified_by=(login)
db.add(ent);
return result
else:
result="False"
return result
def get_miscellaneous_configs(self,auth,image_id,dom_id,node_id,group_id,action):
result=[]
display_list=[]
if action=="change_vm_settings":
#dom = self.node_service.get_dom(auth,dom_id,node_id)
dom=DBHelper().find_by_name(VM,dom_id)
if dom is not None:
vm_config=dom.get_config()
else:
image=self.image_store.get_image(auth,image_id)
if image is None:
raise Exception("Can not find the specified Image.")
if dom_id is None:
vm_config,img_config = image.get_configs()
#vm_config=get_config(image.vm_config)
else:
#dom = self.node_service.get_dom(auth,dom_id,node_id)
dom=DBHelper().find_by_name(VM,dom_id)
vm_config=dom.get_config()
if action=='provision_image' or action=='provision_vm':
group=self.manager.getGroup(auth,group_id)
if group is not None:
grp_settings = group.getGroupVars()
merge_pool_settings(vm_config,img_config,grp_settings, True)
for key in vm_config:
# print key,"---++--",vm_config[key]
if key not in self.node_service.get_exclude_list() and \
key not in vm_config.get_computed_options() :
display_list.append(key)
display_list.sort()
for key in display_list:
value=vm_config[key]
value=process_value(value)
result.append(dict(attribute=key,value=to_str(value)))
return dict(success='true',rows=result)
def save_group_details(self,login,groupid, groupname, userids,desc):
dupGrp=None
group=Group()
db=DBHelper()
session=DBHelper().get_session()
dupGrp=session.query(Group).filter(Group.group_name==groupname).first()
if dupGrp is None:
result = []
group.group_name=groupname
group.created_by=(login)
group.modified_by=(login)
group.created_date=datetime.now()
group.description=desc
L=(userids).split(',')
if userids !="":
for i in L:
user=session.query(User).filter(User.user_id==int(i)).first()
group.users.append(user);
db.add(group)
return result
else:
result="False"
return result
def updatesave_op_det(self, login,opid, opname, desc, entid, context_disp,dispname,icon):
result = []
op=Operation()
db=DBHelper()
session=DBHelper().get_session()
op=session.query(Operation).filter(Operation.id==opid).first()
op.name=(opname)
op.description=(desc)
op.modified_date=datetime.now()
op.modified_by=(login)
op.display_name=(dispname)
op.icon=(icon)
if context_disp=="true":
op.display=True
else:
op.display=False
for i in op.entityType:
op.entityType.remove(i);
L=(entid).split(',')
if entid !="":
for i in L:
ent=session.query(EntityType).filter(EntityType.id==int(i)).first()
op.entityType.append(ent);
db.update(op)
return result
def save_oper_det(self, login,opname, descr, context_disp, entityid,dispname,icon):
result = []
dupOp=None
operation=Operation()
db=DBHelper()
session=DBHelper().get_session()
dupOp=session.query(Operation).filter(Operation.name==opname).first()
if dupOp is None:
operation.name=(opname)
operation.description=(descr)
operation.display_name=(dispname)
operation.icon=(icon)
operation.created_by=(login)
operation.modified_by=(login)
operation.created_date=datetime.now()
if context_disp=="true":
operation.display=True
else:
operation.display=False
L=(entityid).split(',')
for i in L:
ent=session.query(EntityType).filter(EntityType.id==int(i)).first()
operation.entityType.append(ent);
db.add(operation)
return result
else:
result="False"
return result
def get_users_map(self,groupid=None):
result= []
users=DBHelper().get_all(User)
session=DBHelper().get_session()
group=session.query(Group).filter(Group.group_id==groupid).first()
for u in users:
uid=u.user_id
uname=(u.user_name)
result.append(dict(userid=uid,username=uname))
if groupid is None:
return result
else:
for grp in group.users:
i = 0
for user in result:
if grp.user_id == user['userid']:
del result[i]
break
i += 1
return result
def get_entitytype_map(self,opid=None):
result= []
session=DBHelper().get_session()
enty=DBHelper().get_all(EntityType)
operation=session.query(Operation).filter(Operation.id==opid).first()
for e in enty:
eid=e.id
ename=(e.display_name)
result.append(dict(entid=eid,entname=ename))
if opid is None:
return result
else:
for ent in operation.entityType:
i = 0
for enttype in result:
if ent.id == enttype['entid']:
del result[i]
break
i += 1
return result
def get_groups_map(self,userid=None):
result= []
session=DBHelper().get_session()
groups=DBHelper().get_all(Group)
user=session.query(User).filter(User.user_id==userid).first()
for g in groups:
gid=g.group_id
gname=(g.group_name)
result.append(dict(groupid=gid,groupname=gname))
if userid is None:
return result
else:
for grp in user.groups:
i = 0
for group in result:
if grp.group_id == group['groupid']:
del result[i]
break
i += 1
return result
def get_operations_map(self,opsgrpid=None):
result= []
operation=DBHelper().get_all(Operation)
session=DBHelper().get_session()
opsgroup=session.query(OperationGroup).filter(OperationGroup.id==opsgrpid).first()
for o in operation:
opid=o.id
opname=(o.name)
result.append(dict(operationid=opid,operationname=opname))
if opsgrpid is None:
return result
else:
for oprs in opsgroup.operations:
i = 0
for operation in result:
if oprs.id == operation['operationid']:
del result[i]
break
i += 1
return result
def updatesave_opsgroup_details(self, login,opsgroupid ,opsgroupname, opsgroupdesc,operation):
result = []
opsgroup=OperationGroup();
db=DBHelper()
session=DBHelper().get_session()
opsgroup=session.query(OperationGroup).filter(OperationGroup.id==opsgroupid).first()
opsgroup.name=opsgroupname
opsgroup.description=opsgroupdesc
opsgroup.modified_date=datetime.now()
opsgroup.modified_by=(login)
operation = operation[0:-1]
L=(operation).split(',')
for i in L:
operation=session.query(Operation).filter(Operation.id==int(i)).first()
opsgroup.operations.append(operation);
db.update(opsgroup);
return result
def save_opsgroup_details(self,login, opsgroupname, opsgroupdesc, operation):
dupOpsgrp=None
db=DBHelper()
session=DBHelper().get_session()
dupOpsgrp=session.query(OperationGroup).filter(OperationGroup.name==opsgroupname).first()
opsgroup=OperationGroup();
if dupOpsgrp is None:
result=[]
opsgroup.name=(opsgroupname)
opsgroup.description=(opsgroupdesc)
opsgroup.created_by=(login)
opsgroup.modified_by=(login)
opsgroup.created_date=datetime.now()
L=((operation)).split(',')
for i in L:
oper=session.query(Operation).filter(Operation.id==int(i)).first()
opsgroup.operations.append(oper);
db.add(opsgroup);
return result
else:
result="False"
return result
