DBM=DBManager()
CellInfo=CS.getCellInfo(cached=True)
CellInfo.FileServers=CellInfo.FileServers
PrjObj = Project()
defaultDict=PrjObj.getDict()
#
#
# dump/import :
# for serverpartitions, tranlsate for dump into human readable.
# also dump raw server-uuids.
# for import only consider human readable
# but fail if we find no UUID for the hostname
if afs.defaultConfig.dumpPrj == True :
for p in PS.getProjectList() :
if afs.defaultConfig.prjname != "" and p.name != afs.defaultConfig.prjname : continue
d=p.getDict()
if afs.defaultConfig.prjname != "" and afs.defaultConfig.prjname != d["name"] : continue
print "========================================"
print "name: {0}".format(d["name"])
for k in d :
if k in [ "name", "ignAttrList" ] : continue
if k in [ "rw_serverparts","ro_serverparts" ] :
translatedList=[]
for FSUUID,Part in d[k] :
FSName=afs.LookupUtil[afs.defaultConfig.CELL_NAME].getHostnameByFSUUID(FSUUID)
translatedList.append([FSName,Part])
print "{0}_human: {1}".format(k,translatedList)
print "{0}_raw: {1}".format(k,d[k])
else :
class CellService(BaseService):
"""
Provides Service about a Cell global information.
The cellname is set in the configuration passed to constructor.
Thus one instance works only for cell.
"""
def __init__(self, conf=None):
BaseService.__init__(self, conf, DAOList=["fs", "bnode","vl", "vol", "rx", "ubik", "dns"])
self.FS=FsService()
self.PS=ProjectService()
return
def getCellInfo(self, cellname="", _user="", cached=False) :
"""
return full Cellobject.
"""
if cellname == "" : cellname = self._CFG.CELL_NAME
self.Logger.debug("Using cellname : %s " % cellname)
if cached :
cell=self.DBManager.getFromCache(Cell,Name = cellname)
if cell == None :
self.Logger.info("getCellInfo: Cannot get cached Cell. Returning none.")
return cell
self.Logger.debug("getCellInfo: Cell.udate=%s" % cell.udate)
# update Sums etc. from DB_CACHE
cell.Name=cellname
self.Logger.debug("getCellInfo: Cell.FileServers=%s" % cell.FileServers)
cell.numRW = cell.numRO = cell.numBK = cell.numOffline = 0
numVolDict=self.bulk_getNumVolumes()
for f in cell.FileServers :
self.Logger.debug("getCellInfo: f=%s" % f)
uuid = afs.LookupUtil[self._CFG.CELL_NAME].getFSUUID(f)
if numVolDict.has_key(uuid) :
cell.numRW += numVolDict[uuid].get("RW",0)
cell.numRO += numVolDict[uuid].get("RO",0)
cell.numBK += numVolDict[uuid].get("BK",0)
cell.numOffline = -1
cell.numUsers,cell.numGroups = self.getPTInfo(cached=True)
cell.allocated,cell.allocated_stale = self.getAllocated()
cell.size,cell.used,cell.free=self.getUsage(cached=True)
cell.Projects=[] # Projects are in DB_CACHE only
for p in self.PS.getProjectList() :
cell.Projects.append(p.name)
self.Logger.debug("Cell=%s" % cell)
return cell
# refresh whole new CellObj
cell=Cell()
cell.Name=cellname
cell.FileServers=self.getFileServers()
cell.DBServers=self.getDBServers()
cell.PTDBSyncSite, cell.PTDBVersion,cell.PTDBState=self.getUbikDBInfo(cell.DBServers[0],7002)
cell.VLDBSyncSite, cell.VLDBVersion,cell.VLDBState=self.getUbikDBInfo(cell.DBServers[0],7003)
cell.numRW = cell.numRO = cell.numBK = cell.numOffline = 0
for f in cell.FileServers :
numRW,numRO,numBK,numOffline = self.FS.getNumVolumes(name_or_ip=f,cached=True)
cell.numRW += numRW
cell.numRO += numRO
cell.numBK += numBK
cell.numOffline += numOffline
cell.numUsers,cell.numGroups = self.getPTInfo()
cell.size,cell.used,cell.free=self.getUsage()
# some information are only available if DB_CACHE is used.
cell.allocated,cell.allocated_stale = -1,-1
cell.Projects=[] # Projects are in DB_CACHE only
if self._CFG.DB_CACHE :
for p in self.PS.getProjectList() :
cell.Projects.append(p.name)
cell.allocated,cell.allocated_stale = self.getAllocated()
self.Logger.debug("Cell=%s" % Cell)
self.DBManager.setIntoCache(Cell,cell,Name=self._CFG.CELL_NAME)
return cell
def refreshLiveData(self, cellname="") :
"""
update livedata for the cell :
partition free and used space, DBVersions, list of Servers
"""
if cellname == "" : cellname = self._CFG.CELL_NAME
cell=Cell()
cell.FileServers=self.getFileServers()
cell.DBServers=self.getDBServers()
cell.PTDBSyncSite, cell.PTDBVersion,cell.PTDBState=self.getUbikDBInfo(cell.DBServers[0],7002)
cell.VLDBSyncSite, cell.VLDBVersion,cell.VLDBState=self.getUbikDBInfo(cell.DBServers[0],7003)
cell.size,cell.used,cell.free=self.getUsage()
return True
###############################################
# Internal helper Section
###############################################
def getFileServers(self, _user="", cached=False):
"""
Return FileServers as a list of hostnames for each fileserver
"""
FileServers=[]
if cached :
for fs in self.DBManager.getFromCache(FileServer,mustBeunique=False) :
FileServers.append(fs.servernames[0])
return FileServers
self.Logger.debug("refreshing FileServers from live system")
for na in self._vlDAO.getFsServList(_cfg=self._CFG, _user=_user,noresolve=True) :
DNSInfo=afs.LookupUtil[self._CFG.CELL_NAME].getDNSInfo(na['name_or_ip'])
FileServers.append(DNSInfo['names'][0])
self.Logger.debug("returning %s" % FileServers)
return FileServers
def getDBServers(self, _user="", cached=False):
"""
return a DB-Server-hostname list
"""
DBServers=[]
if cached :
for na in self.DBManager.getFromCache(DBServer,mustBeUnique=False) :
DBServers.append(na.servernames[0])
return DBServers
# we need to bootstrap ourselves now from nothing but the Cellname
# just list of simple dicts hostnames
DBServList=[]
# try DNS _SRV Records from afsdb
try :
DBServList=self._dnsDAO.getDBServList(_cfg=self._CFG)
except:
pass
if len(DBServList) == 0 :
# get one fileserver and from that one the DBServList
# we need to make sure to get the IP
for f in self._vlDAO.getFsServList(_cfg=self._CFG, _user=_user, noresolve=True ) :
if f["name_or_ip"] in self._CFG.ignoreIPList : continue
DBServList = self._bnodeDAO.getDBServList(f["name_or_ip"], _cfg=self._CFG, _user=_user)
# canonicalize DBServList
for na in DBServList :
DNSInfo=afs.LookupUtil[self._CFG.CELL_NAME].getDNSInfo(na)
DBServers.append(DNSInfo['names'][0])
self.Logger.debug("returning %s" % DBServers)
return DBServers
def getUbikDBInfo(self, name_or_ip, Port, _user=""):
"""
return (SyncSite,DBVersion,DBState) tuple for DataBase accessible from Port
"""
shortInfo = self._ubikDAO.getShortInfo(name_or_ip, Port, _cfg=self._CFG, _user=_user)
# we get DBState only from SyncSite
if not shortInfo["isSyncSite"] :
shortInfo = self._ubikDAO.getShortInfo(shortInfo["SyncSite"], Port, _cfg=self._CFG,_user=_user)
return (shortInfo["SyncSite"],shortInfo["SyncSiteDBVersion"],shortInfo["DBState"])
def getUsage(self,cached=False) :
"""
Get Partition info of all Fileservers
"""
size = used = free = 0
return size,used,free
def getAllocated(self) :
"""
Get sum of all given quotas of all Volumes
DBCache only.
"""
allocated = allocated_stale= 0
return allocated,allocated_stale
def getPTInfo(self,cached=False) :
"""
Get all sum of all users and groups defined in PTDB
"""
numUsers = numGroups = 0
return numUsers,numGroups
def bulk_getNumVolumes(self) :
"""
returns all volume count for all servers from DB
"""
self.Logger.debug("bulk_getNumVolumes:")
resDict={}
conn = self._CFG.DB_ENGINE.connect()
transa = conn.begin()
for t in ["RW","RO","BK"] :
rawsql='SELECT TF.uuid, COUNT(TV.vid) FROM tbl_volume AS TV JOIN tbl_fileserver AS TF on TV.serv_uuid = TF.uuid WHERE TV.type="%s" GROUP BY TF.uuid;' % t
for uuid,count in conn.execute(rawsql).fetchall() :
if not resDict.has_key(uuid) : resDict[uuid]={"RW" : 0,"RO" : 0, "BK" : 0}
resDict[uuid][t]=count
transa.commit()
conn.close()
self.Logger.debug("bulk_getNumVolumes: returning %s" % resDict)
return resDict
