python.PoolFile.PoolFileCatalog Class Reference

Inheritance diagram for python.PoolFile.PoolFileCatalog:

Collaboration diagram for python.PoolFile.PoolFileCatalog:

Public Member Functions
def	__init__ (self, catalog=None)
def	pfn (self, url_or_fid)
def	__call__ (self, url_or_fid)

Public Attributes
	catalog

Static Public Attributes
	DefaultCatalog
	AllowedProtocols

Private Member Functions
def	_pfn (self, url_or_fid)

Detailed Description

reverse-engineering of the POOL FileCatalog.
    allows to retrieve the physical filename from a logical one, provided
    that the file-id is known to the (real) PoolFileCatalog

Definition at line 35 of file PoolFile.py.

Constructor & Destructor Documentation

__init__()

def python.PoolFile.PoolFileCatalog.__init__	(		self,
			catalog = None
	)

Definition at line 50 of file PoolFile.py.

    def __init__ (self, catalog=None):
        super (PoolFileCatalog, self).__init__()
        self.catalog = None
 
        if catalog is None:
            # chase poolfilecatalog location
            catalog = os.environ.get("POOL_CATALOG", self.DefaultCatalog)
 
        if isinstance(catalog, str):
            catalog = [catalog]
            
        if not isinstance (catalog, (str, list)):
            raise TypeError(
                "catalog contact string should be a string or a list thereof! (got %r)"%
                type(catalog))
 
        osp = os.path
        def osp_exp(x):
            return osp.expanduser(osp.expandvars(x))
 
        def _handle_apcfile_old(x):
            """ return $ATLAS_POOLCOND_PATH/poolcond/x
            """
            if 'ATLAS_POOLCOND_PATH' not in os.environ:
                return osp_exp(x)
            pcp = os.environ["ATLAS_POOLCOND_PATH"]
            if x.startswith("apcfile:"):
                x = x[len("apcfile:"):]
            return osp_exp(osp.join(pcp, 'poolcond', x))
 
        def _handle_apcfile(x):
            """ return $ATLAS_POOLCOND_PATH/x
            """
            if 'ATLAS_POOLCOND_PATH' not in os.environ:
                return osp_exp(x)
            pcp = os.environ["ATLAS_POOLCOND_PATH"]
            if x.startswith("apcfile:"):
                x = x[len("apcfile:"):]
            return osp_exp(osp.join(pcp, x))
 
        def _handle_xmlcatalog_file(x):
            return osp_exp(x[len("xmlcatalog_file:"):])
 
        def _handle_prfile(x):
            x = x[len("prfile:"):]
            x = osp_exp(x)
            try:
                import AthenaCommon.Utils.unixtools as u
                return u.FindFile(x,
                                  os.environ['DATAPATH'].split(os.pathsep),
                                  os.R_OK)
            except ImportError:
                return x
 
        def _handle_file(x):
            x = x[len("file:"):]
            x = osp_exp(x)
            return x
        
        cat_dispatch = {
            "xmlcatalog_file:": _handle_xmlcatalog_file,
            "apcfile:": _handle_apcfile,
            "prfile:":  _handle_prfile,
            "file:":    _handle_file,
            }
        assert sorted(cat_dispatch.keys()) == sorted(self.AllowedProtocols), \
               "catalog dispatch keys does not match AllowedProtocols:" \
               "\n%s\n%s" % (sorted(cat_dispatch.keys()),
                             sorted(self.AllowedProtocols))
 
        from . import xmldict
        def _build_catalog(catalog):
            if not catalog.startswith(self.AllowedProtocols):
                raise ValueError(
                    "sorry PoolFile:PoolFileCatalog only supports %s"
                    " as a protocol for the POOL file catalog (got: '%s')"
                    % (self.AllowedProtocols, catalog)
                    )
            for protocol, handler in cat_dispatch.iteritems():
                if catalog.startswith(protocol):
                    catalog = handler(catalog)
                    break
            # make sure the catalog exists...
            import os
 
            if not os.path.exists (catalog):
                return {}
                # raise RuntimeError(
                #     'could not find any PoolFileCatalog in [%s]' % catalog
                #     )
        
       
            root = xmldict.ElementTree.parse (catalog).getroot()
            return dict(xmldict.xml2dict(root))
 
        errors = []
        cat = {'POOLFILECATALOG':{'File':[]}}
        for c in catalog:
            try:
                bc = _build_catalog(c)
                pc = bc.get('POOLFILECATALOG',{})
                files = []
                if pc:
                    files = pc.get('File',[])
                if isinstance(files, dict):
                    files = [files]
                cat['POOLFILECATALOG']['File'].extend(files)
            except Exception as err:
                errors.append(err)
 
        if errors:
            raise errors[0] # FIXME : should we customize this a bit ?
 
        self.catalog = cat
        pass
 

Member Function Documentation

__call__()

def python.PoolFile.PoolFileCatalog.__call__	(		self,
			url_or_fid
	)

Definition at line 240 of file PoolFile.py.

    def __call__ (self, url_or_fid):
        return self.pfn (url_or_fid)
    

_pfn()

def python.PoolFile.PoolFileCatalog._pfn (   self,   url_or_fid  )

private

find the physical file name given a url or a file-id

Definition at line 176 of file PoolFile.py.

    def _pfn (self, url_or_fid):
        """find the physical file name given a url or a file-id"""
        if not ('POOLFILECATALOG' in self.catalog):
            return None
        if not ('File' in self.catalog['POOLFILECATALOG']):
            return None
 
        PFN_IDX = 0 # take this pfn when alternates exist
        
        files = self.catalog['POOLFILECATALOG']['File']
        if isinstance(files, dict):
            # in case there where only one entry in the catalog
            files = [files]
        import re
        if url_or_fid.lower().startswith('fid:'):
            url_or_fid = url_or_fid[len('fid:'):]
        if re.compile (r'\w{8}-\w{4}-\w{4}-\w{4}-\w{12}$').match (url_or_fid):
            fid = url_or_fid.lower()
            # better to check consistency of catalog over all entries
            # than declare success on first match...
            match = {}
            for f in files:
                if f.ID.lower() == fid:
                    match[fid] = []
                    pfn = f.physical.pfn
                    if isinstance(pfn, (list,tuple)):
                        match[fid].append([i.name for i in pfn])
                    else:
                        match[fid].append([pfn.name])
            if len(match[fid])==1:
                return match[fid][0][PFN_IDX]
            if len(match[fid])>1:
                raise LookupError (
                    "more than one match for FID='%s'!\n%r"%(fid,match)
                    )
            raise KeyError ("no entry with FID='%s' in catalog" % fid)
        else:
            url = url_or_fid
            if url.lower().startswith("lfn:"):
                url = url[len("lfn:"):]
                # better to check consistency of catalog over all entries
                # than declare success on first match...
                match = {}
                for f in files:
                    if (f.logical != '' # no LFN for this entry
                        and f.logical.lfn.name == url):
                        match[url] = []
                        pfn = f.physical.pfn
                        if isinstance(pfn, (list,tuple)):
                            match[url].append([i.name for i in pfn])
                        else:
                            match[url].append([pfn.name])
                if len(match[url])==1:
                    return match[url][0][PFN_IDX]
                if len(match[url])>1:
                    raise LookupError (
                        "more than one match for LFN='%s'!\n%r"%(url,match)
                    )
                raise KeyError ("no entry with LFN='%s' in catalog" % url)
            # assume that if not LFN: then PFN:, no matter what...
            if url.lower().startswith("pfn:"):
                url = url[len("pfn:"):]
            return url
 

pfn()

def python.PoolFile.PoolFileCatalog.pfn	(		self,
			url_or_fid
	)

find the physical file name given a url or a file-id

Definition at line 166 of file PoolFile.py.

    def pfn (self, url_or_fid):
        """find the physical file name given a url or a file-id"""
        import os.path as osp
        url_or_fid = osp.expanduser(osp.expandvars(url_or_fid))
        import types
        if isinstance (url_or_fid, types.ListType):
            return [self._pfn(f) for f in url_or_fid]
        else:
            return self._pfn(url_or_fid)
        

Member Data Documentation

AllowedProtocols

python.PoolFile.PoolFileCatalog.AllowedProtocols

static

Definition at line 41 of file PoolFile.py.

catalog

python.PoolFile.PoolFileCatalog.catalog

Definition at line 52 of file PoolFile.py.

DefaultCatalog

python.PoolFile.PoolFileCatalog.DefaultCatalog

static

Definition at line 40 of file PoolFile.py.

---

The documentation for this class was generated from the following file:

• PoolFile.py