def __init__(self,conf=None):
self._volDAO = VolumeDAO()
# LOAD Configuration from file if exist
# FIXME Move in decorator
if conf:
self._CFG = conf
else:
self._CFG = afs.defaultConfig
# DB INIT
if self._CFG.DB_CACHE :
import sqlalchemy.orm
from sqlalchemy import func, or_
self.DbSession = sqlalchemy.orm.sessionmaker(bind=self._CFG.DB_ENGINE)
class VolService (object):
"""
Provides Service about a Volume management.
The cellname is set in the methods so that we
can use this for more than one cell.
"""
def __init__(self,conf=None):
self._volDAO = VolumeDAO()
# LOAD Configuration from file if exist
# FIXME Move in decorator
if conf:
self._CFG = conf
else:
self._CFG = afs.defaultConfig
# DB INIT
if self._CFG.DB_CACHE :
import sqlalchemy.orm
from sqlalchemy import func, or_
self.DbSession = sqlalchemy.orm.sessionmaker(bind=self._CFG.DB_ENGINE)
###############################################
# Volume Section
###############################################
#FIXME list or object ... no DICT !
"""
Retrieve Volume Group
"""
def getVolGroup(self, id ):
list = self._volDAO.getVolGroup(id, self._CFG.CELL_NAME, self._CFG.Token);
return list
"""
Retrieve Volume Information by Name or ID
"""
def getVolume(self, name, serv, part):
vdict = self._volDAO.getVolume(name, serv, part, self._CFG.CELL_NAME, self._CFG.Token)
vol = Volume()
vol.setByDict(vdict)
self._setIntoCache(vol)
return vol
"""
Retrieve Volume extended information
"""
def getVolExtended(self,id):
pass
################################################
# Cache Query
################################################
def getVolCountByQuery(self,query):
if not self._CFG.DB_CACHE:
raise VolError('Error, no db Cache defined ',None)
query._tbl= "Volume"
session = self.DbSession()
queryc = query.getQueryCount()
count = eval(queryc)
session.close()
return count
def getVolByQuery(self,query):
if not self._CFG.DB_CACHE:
raise VolError('Error, no db Cache defined ',None)
query._tbl= "Volume"
session = self.DbSession()
query = query.getQuery()
res = eval(query)
session.close()
return res
def refreshCache(self, serv, part):
if not self._CFG.DB_CACHE:
raise VolError('Error, no db Cache defined ',None)
part = afsutil.canonicalizePartition(part)
list = self._volDAO.getVolList( serv, part, self._CFG.CELL_NAME, self._CFG.Token)
#Convert into dictionary
idVolDict = {}
cUpdate = len(list)
for el in list:
idVolDict[el['vid']] = el
session = self.DbSession()
res = session.query(Volume).filter(or_(Volume.serv == serv,Volume.servername == serv )).filter(Volume.part == part)
flush = 0
for vol in res:
flush +=1
if idVolDict.has_key(vol.vid):
vol.setByDict(idVolDict[vol.vid])
del idVolDict[vol.vid]
else:
session.delete(vol)
if flush > self._CFG.DB_FLUSH:
session.flush()
session.flush()
# ADD section
flush = 0
for key in idVolDict.keys():
flush +=1
vol = Volume()
vol.setByDict(idVolDict[key])
session.add(vol)
if flush > self._CFG.DB_FLUSH:
session.flush()
session.flush()
session.commit()
return cUpdate
################################################
# Internal Cache Management
################################################
def _getFromCache(self,id, serv, part):
#STORE info into CACHE
if not self._CFG.DB_CACHE:
return None
part = afsutil.canonicalizePartition(part)
session = self.DbSession()
# Do update
vol = session.query(Volume).filter(Volume.vid == id).filter(Volume.serv == serv).filter(Volume.part == part).first
session.close()
return vol
def _setIntoCache(self,vol):
#STORE info into CACHE
if not self._CFG.DB_CACHE:
return vol
session = self.DbSession()
volCache = session.query(Volume).filter(Volume.vid == vol.vid).filter(or_(Volume.serv == vol.serv,Volume.servername == vol.servername )).filter(Volume.part == vol.part).first()
if volCache:
volCache.copyObj(vol)
session.flush()
else:
session.add(vol)
volCache = vol
session.commit()
session.close()
return volCache
def _delCache(self,vol):
#STORE info into CACHE
if not self._CFG.DB_CACHE:
return None
session = self.DbSession()
# Do update
session.delete(vol)
session.commit()
session.close()
def __init__(self) :
VolumeDAO.__init__(self)
return
class CellService(object):
"""
Provides Service about a Cell global information.
The cellname is set in the methods so that we
can use this for more than one cell.
"""
def __init__(self,conf=None):
self._vlDAO = VLDbDAO()
self._volDAO = VolumeDAO()
# LOAD Configuration from file if exist
# FIXME Move in decorator
if conf:
self._CFG = conf
else:
self._CFG = afs.defaultConfig
# DB INIT
if self._CFG.DB_CACHE :
import sqlalchemy.orm
from sqlalchemy import func, or_
self.DbSession = sqlalchemy.orm.sessionmaker(bind=self._CFG.DB_ENGINE,expire_on_commit=False)
###############################################
# Server Section
###############################################
"""
Retrieve Server List
"""
def getFsList(self):
nameList = self._vlDAO.getFsServList(self._CFG.CELL_NAME, self._CFG.Token);
ipList = self._vlDAO.getFsServList(self._CFG.CELL_NAME, self._CFG.Token, noresolve=True );
nameDict = {}
for el in nameList:
nameDict[el['uuid']] = el['serv']
fsList = []
for el in ipList:
el['servername'] = nameDict[el['uuid']]
el['fileserver'] = 1
serv = Server()
serv.setByDict(el)
print "Before _______________________________"
print serv
# Cache Stuffz
serv = self._setServIntoCache(serv)
fsList.append(serv)
return fsList
"""
Retrieve Server List
"""
def getPartList(self, serv,):
# FIXME look up server ip use only ip
list =self._volDAO.getPartList(serv, self._CFG.CELL_NAME, self._CFG.Token )
partList = []
for el in list:
part = Partition()
part.setByDict(el)
# Cache Stuff
part = self._setPartIntoCache(part)
partList.append(part)
return partList
################################################
# Internal Cache Management
################################################
def _getPartFromCache(self, serv, part):
#STORE info into CACHE
if not self._CFG.DB_CACHE:
return None
part = afsutil.canonicalizePartition(part)
session = self.DbSession()
# Do update
part = session.query(Partition).filter(Partition.part == part).filter(Partition.serv == serv).first
session.close()
return part
def _setPartIntoCache(self,part):
#STORE info into CACHE
if not self._CFG.DB_CACHE:
return part
session = self.DbSession()
partCache = session.query(Partition).filter(Partition.part == part.part).filter(Partition.serv == part.serv).first()
if partCache:
partCache.copyObj(part)
else:
session.add(part)
partCache = part
session.flush()
session.commit()
session.close()
return partCache
def _delPartFromCache(self,part):
#STORE info into CACHE
if not self._CFG.DB_CACHE:
return None
session = self.DbSession()
# Do update
session.delete(part)
session.commit()
session.close()
def _setServIntoCache(self,serv):
#STORE info into CACHE
if not self._CFG.DB_CACHE:
return serv
session = self.DbSession()
servCache = session.query(Server).filter(Server.serv == serv.serv).first()
session.flush()
if servCache:
servCache.copyObj(serv)
else:
session.add(serv)
servCache = serv
session.commit()
session.close()
return servCache
