Ejemplo n.º 1
0
 def getVolume(self, name_or_id, serv=None, _user="", cached=True):
     VolList=[]
     if cached :
         if serv != "" :
             serv_uuid=afs.LookupUtil[self._CFG.CELL_NAME].getFSUUID(serv,self._CFG)
             if afsutil.isName(name_or_id) :
                 vol=self.DBManager.getFromCache(Volume,name=name_or_id,serv_uuid=serv_uuid)
             else :
                 vol=self.DBManager.getFromCache(Volume,vid=name_or_id,serv_uuid=serv_uuid)
         else :
             if afsutil.isName(name_or_id) :
                 vol=self.DBManager.getFromCache(Volume,name=name_or_id)
             else :
                 vol=self.DBManager.getFromCache(Volume,vid=name_or_id)
         if vol != None :
             for v in vol :
                 v.ExtAttr=self.getExtVolAttr(v.vid)
                 VolList.append(v)
             return vol
     vdictList = self._volDAO.getVolume(name_or_id, serv, _cfg=self._CFG, _user=_user)
     for vdict in vdictList :
         vdict["serv_uuid"]=afs.LookupUtil[self._CFG.CELL_NAME].getFSUUID(serv,self._CFG)
         vdict.pop("serv")
         self.Logger.debug("getVolume: vdict=%s" % vdict)
         vol = Volume()
         vol.setByDict(vdict)
         # this doesnot work, since RO are not unique.  
         # we would need to write a setListIntoCache method for this
         #if self._CFG.DB_CACHE :
         #    self.DBManager.setIntoCache(Volume,vol,vid = vol.vid)
         VolList.append(vol)
     return VolList
Ejemplo n.º 2
0
    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
Ejemplo n.º 3
0
    def getVolume(self, name_or_id, serv=None,  _user="", cached=False):
        self.Logger.debug("Entering with name_or_id=%s, serv=%s, cached=%s" % (name_or_id, serv, cached) )
        VolList = []
        if cached :
            if serv != None :
                serv_uuid=afs.LookupUtil[self._CFG.CELL_NAME].getFSUUID(serv,self._CFG,cached=True)
                # need function in util name_or_ip and name_or_id?
                if afsutil.isName(name_or_id) :
                    vol=self.DBManager.getFromCache(Volume,name=name_or_id,serv_uuid=serv_uuid)
                else :
                    vol=self.DBManager.getFromCache(Volume,vid=name_or_id,serv_uuid=serv_uuid)
                VolList.append(vol)
            else :
                if afsutil.isName(name_or_id) :
                    VolList=self.DBManager.getFromCache(Volume,name=name_or_id,mustBeUnique=False)
                else :
                    VolList=self.DBManager.getFromCache(Volume,vid=name_or_id,mustBeUnique=False)
                self.Logger.debug("OSDgetVolume: VolList=%s" % VolList)
            for vol in VolList :
                vol.ExtAttr=self.getExtVolAttr(vol.vid)
                vol.OsdAttr=self.DBManager.getFromCache(ExtVolAttr_OSD,vid=vol.vid)
            return VolList
        osdExtAttr=ExtVolAttr_OSD()
        odict=osdExtAttr.getDict()
        vdictList = self._osdvolDAO.getVolume(name_or_id, serv=serv, _cfg=self._CFG, _user=_user)
        self.Logger.debug("OSDgetVolume: vdictList=%s" % vdictList)
        for vdict in vdictList :
            StorageUsage=self.getStorageUsage([serv,],vdict["vid"])
            vdict["blocks_osd_on"]=StorageUsage["storageUsage"]["online"]["Data"]
            vdict["blocks_osd_off"]=StorageUsage["storageUsage"]["archival"]["Data"]
            vdict["blocks_fs"]=StorageUsage["storageUsage"]["fileserver"]["Data"]
            vdict["serv_uuid"]=afs.LookupUtil[self._CFG.CELL_NAME].getFSUUID(vdict["serv"],self._CFG,cached=False)
            vdict.pop("serv")
            self.Logger.debug("getVolume: vdict=%s" % vdict)
            # move stuff to OSD-dict
            for k in vdict.keys() :
                if k in odict.keys() : 
                    odict[k] = vdict[k] 
                    if k == "vid" : continue
                    vdict.pop(k)
            vol = Volume()
            # XXX: we need this to ignore the OsdAttr and ExtAttr in the copy-operation.
            vdict["ignAttrList"]=vol.ignAttrList
            vol.setByDict(vdict)
            if odict['osdPolicy'] != 0 : 
                vol.OsdAttr=odict
                osdExtAttr.setByDict(odict)

            if self._CFG.DB_CACHE :
                self.DBManager.setIntoCache(Volume,vol,vid=vol.vid,serv_uuid=serv_uuid,part=vol.part) 
                if odict['osdPolicy'] != 0 : 
                    self.DBManager.setIntoCache(ExtVolAttr_OSD,osdExtAttr,vid=osdExtAttr.vid) 
            VolList.append(vol) 
        return VolList
Ejemplo n.º 4
0
 def get_object(self, obj_or_param) :
     """
     return an object, regardless of what was the input (object or unique parameters)
     unique paramter is name_or_id (either volume name or volume id)
     """
     if isinstance(obj_or_param, Volume) :
          this_Volume = obj_or_param
     else : 
          this_Volume = Volume()
          if misc.is_name(obj_or_param) :
              this_Volume.name = obj_or_param
          else :
              this_Volume.vid = obj_or_param
     return this_Volume
Ejemplo n.º 5
0
 def getVolume(self, name, serv, part,  cached=False):
     if cached :
         serv_uuid=self.FsS.getUUID(serv)
         vol=self._getFromCache(name, serv_uuid, part)
         return vol
     vdict = self._volDAO.getVolume(name, serv, part,  self._CFG.CELL_NAME, self._CFG.Token)
     vdict["serv_uuid"]=self.FsS.getUUID(serv)
     vdict.pop("serv")
     vol = None
     if vdict:
         vol = Volume()
         vol.setByDict(vdict)
         if self._CFG.DB_CACHE :
             self._setIntoCache(vol)
     return  vol
Ejemplo n.º 6
0
 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
Ejemplo n.º 7
0
# only get the most specific one

PrjObj=PS.getProjectsByVolumeName(VolumeName)[0]
if afs.defaultConfig.ProjectName != None :
    thisPrjObj=PS.getProjectByName(afs.defaultConfig.ProjectName)
    if thisPrjObj == None :
        myParser.error("Project \"%s\" does not exist" % afs.defaultConfig.ProjectName)
    if thisPrjObj.id != PrjObj.id :
        if not afs.defaultConfig.force :
            myParser.error("VolumeName \"%s\" not matched by given Project \"%s\"\n" % (VolumeName,afs.defaultConfig.ProjectName))
            sys.exit(1)
        PrjObj = thisPrjObj
    
if not PrjObj :
    sys.stderr.write("Cannot guess Project for volume %s" % VolumeName)
VolObj=Volume()
VolObj.name=VolumeName
VolObj.type=VolumeType
if VolObj.type == "RW" :
    RWServ,RWPart=(PS.getNewVolumeLocation(PrjObj.name,VolObj))
    print "Creating new volume %s of type %s on %s %s with size %d" % (VolObj.name, VolObj.type, RWServ,RWPart,VolSize)
    VD.create(VolObj.name,RWServ,RWPart,VolSize)
    print "Creating accompanying RO"
    VlD.addsite(VolObj.name,RWServ,RWPart)
    # XXX it's a bit shitty, but we have to release after each addsite for now, since we get the locations from vos examine atm and not from vos listvldb
    VD.release(VolObj.name)
    for i in range(1,PrjObj.minnum_ro) :
        print "Creating additional RO-copy number %s" % i
        ROServ,ROPart=(PS.getNewVolumeLocation(PrjObj.name,VolObj))
        VlD.addsite(VolObj.name,ROServ,ROPart)
        VD.release(VolObj.name)
Ejemplo n.º 8
0
        if not afs.defaultConfig.dpart in dstFS.parts : 
            sys.stderr.write("Partition %s does not exist on server %s\n" % (afs.defaultConfig.dpart, afs.defaultConfig.dsrv))
            sys.exit(2)
        else :
            reqDstPart=afs.defaultConfig.dpart  
    else :
        reqDstPart=None
else :
    dstFS=None
    if afs.defaultConfig.dpart != None :
        sys.stderr.write("Warning: ignoring given dpart=%s, because no dsrv has been specified.\n" % afs.defaultConfig.dpart)

# XXX we should handle everything internally with bytes
untilFree=parseHumanWriteableSize(afs.defaultConfig.untilfree)/1024
minUsage=parseHumanWriteableSize(afs.defaultConfig.minVolumeUsage)/1024
VolObj = Volume()
movedVolcount=0
for srcP in srcParts :
    print "Processing Partition %s...." % srcP
    # check if partition is freed enough
    parts=FS.getPartitions(afs.defaultConfig.ssrv)
    if parts[srcP]["free"] > untilFree and untilFree > 0 :
        print "already %s Bytes free on spart %s." % (afs.util.afsutil.humanReadableSize(parts[srcP]["free"]),srcP )
        continue
    # get list of volumes to move
    srcVolList=FS.getVolList(srcFS.servernames[0],srcP,cached=False)
    # get RW Volumes :
    RWVols=[]
    solitaryROVols=[]
    for v in srcVolList : 
        if "type" in v.keys() :
Ejemplo n.º 9
0
def get_volume_list(rc, output, outerr, parseParamList, Logger) :
    if rc :
        raise FileServerLLAError("Error",outerr)
        
    # first line gives Name, ID, Type, Used and Status 
    volList = [] 
    dateT=datetime.datetime(1970, 1, 1)
    i = 0
    while i < len(output):
        while output[i] != "BEGIN_OF_ENTRY":
             i = i+1  
             if i >= len(output): break
        if i >= len(output): break
        #Beginnig block
        splits = output[i].split()
        if splits[0] == "BEGIN_OF_ENTRY":
                vol = Volume()
                splits = output[i+1].split()
                # Invalid volume, something wrong
                if splits[0] != 'name':
                    #vol['valid'] = False 
                    if  splits[0] == 'id':
                        vol.vid  = int(splits[1])
                    
                    splits = output[i+2].split()
                    if  splits[0] == 'serv':
                        vol.servername = splits[1] 
                    
                    splits = output[i+3].split()   
                    if  splits[0] == 'part':
                         vol.part = misc.canonicalize_partition(splits[1]) 
                         
                    splits = output[i+4].split()
                    if  splits[0] == 'status':
                        vol.status = splits[1] 
                    
                    while output[i] != "END_OF_ENTRY":
                        i = i+1  
                        
                # Valid volume                           
                else:  
                    vol.vid = "UNSET"
                    try: 
                      vol.name     = splits[1]
                      splits = output[i+2].split()
                      vol.vid      = int(splits[1])
                      splits = output[i+3].split()
                    except :
                        # XXX Here we need a flag to show that parsing was not complete
                        # or a list of Volumes which need to be reparsed.
                        # this will be in the return-code
                        while output[i] != "END_OF_ENTRY":
                            i = i+1
                        Logger.error("Cannot parse name of volume with id=%s! Skipping." % vol.vid)
                        continue
                    
                    if len(splits) > 2:
                       vol.servername     = splits[2]
                    else:
                       #Only ip is available 
                       vol.servername     = splits[1] 
                    splits = output[i+4].split()
                    vol.partition = misc.canonicalize_partition(splits[1])
                    splits = output[i+5].split()
                    vol.status     = splits[1]
                    if vol.status != "OK" : 
                        while output[i] != "END_OF_ENTRY":
                            i = i+1
                        continue
                    splits = output[i+6].split()
                    vol.backup_id = int(splits[1])
                    splits = output[i+7].split()
                    vol.parent_id = int(splits[1])
                    splits = output[i+8].split()
                    vol.clone_id = int(splits[1])
                    splits = output[i+9].split()
                    vol.in_use    = splits[1]
                    splits = output[i+10].split()
                    vol.needs_salvage = splits[1]
                    splits = output[i+11].split()
                    vol.destroy_me = splits[1]
                    splits = output[i+12].split()
                    vol.type = splits[1]
                    splits = output[i+13].split()
                    vol.creation_date  =  dateT.fromtimestamp(float(splits[1]))
                    splits = output[i+14].split()
                    vol.access_date = dateT.fromtimestamp(float(splits[1]))
                    splits = output[i+15].split()
                    vol.update_date = dateT.fromtimestamp(float(splits[1]))
                    splits = output[i+16].split()
                    vol.backup_date = dateT.fromtimestamp(float(splits[1]))
                    splits = output[i+17].split()
                    vol.copy_date = dateT.fromtimestamp(float(splits[1]))
                    splits = output[i+18].split()
                    vol.flags = splits[1]
                    splits = output[i+19].split()
                    vol.diskused = int(splits[1])
                    splits = output[i+20].split()
                    vol.maxquota = int(splits[1])
                    splits = output[i+21].split()
                    vol.minquota = int(splits[1])
                    splits = output[i+22].split()
                    vol.filecount = int(splits[1])
                    splits = output[i+23].split()
                    vol.day_use = int(splits[1])
                    splits = output[i+24].split()
                    vol.week_use = int(splits[1])
                    splits = output[i+25].split()
                    vol.spare2 = splits[1]
                    splits = output[i+26].split()
                    vol.spare3 = splits[1]
                    i = i+26
                volList.append(vol)
    return volList