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 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 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 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_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 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 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 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_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 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 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 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 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_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 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 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 __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 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_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 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 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(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 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 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 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 change_user_password(self, userid, newpasswd, oldpasswd):
result = []
user = DBSession.query(User).filter(User.user_name == userid).first()
if (user.validate_password(oldpasswd)):
user.password = newpasswd
DBHelper().update(user)
return result
else:
raise Exception(
'Old Password is not valid.<br>Please enter valid Password.')
def get_groupsdetails(self):
result = []
groups = DBHelper().get_all(Group)
for g in groups:
groupid = g.group_id
groupname = g.group_name
groupdesc = g.description
result.append(
dict(groupid=groupid, groupname=groupname, desc=groupdesc))
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_enttype(self):
result = []
enttype = DBHelper().get_all(EntityType)
for e in enttype:
ent_id = e.id
ent_name = e.name
disp_name = e.display_name
result.append(
dict(entid=ent_id, entname=ent_name, dispname=disp_name))
return result
