source: TI07-MOLES/trunk/StubB/XSLT/browse/portal/cgi/browse/ServiceBinding.py @ 1182

#
# There are (at least) two classes of service map issues which NDG needs to support.
# Firstly, one can expect that given a specific NDG record, there is a native
# service for that record ... eg. for an A record, the native service is the 
# data extractor, but there may be others ... at some point we need to be
# able to find those out (this is a processing affordance issue, and something
# that we want to use registries for) ... anyway, meanwhile, we have these "native"
# service types.
# Secondly, in D  we have related URL's, which are essentially mappings to 
# services which may exist on the dataset described by that D-catalogue record.
# This is a special case of the generic case described above ...
#
# This module provides classes to support these activities.

from Utilities import myConfig
from htmlUtilities import hyperlink,image
from ETxmlView import nsdumb,et2text

def idconvert(e,helper=None):
    ''' Converts an XML ndg identifier into a uri version '''
    if helper is None:
        helper=nsdumb()
    s='%s:%s:%s'%(helper.getText(e,'repositoryIdentifier'),
                    helper.getText(e,'schemeIdentifier'),
                    helper.getText(e,'localIdentifier'))
    return s

class ServiceMap(myConfig):
    ''' This should itself eventually be a service that can be looked up, or maybe
    even use the dns '''
    def __init__(self,serviceFile='cgi/serviceMap.config'):
        myConfig.__init__(self,serviceFile)
        self.seticon('RELATED')
    def seticon(self,t):
        ''' Set icon type t, or if it doesn't exist, use RELATED '''
        self.icon=self.get(t,'icon')
        if self.icon is None:
            self.seticon('RELATED')
        else: self.iconalt=self.get(t,'icon_alt')
    def do(self,serviceType,dataProvider):
        '''  Return an actual endpoint for a given service from the data provider, e.g.
        for ndg_a_service,badc.nerc.ac.uk get http://superglue.badc.rl.ac.uk/cgi-bin/browse.py '''
        serviceType=serviceType.upper() # ought to be redundant ...
        r=self.get(serviceType,dataProvider)
        if r is None:
            # just return the URL
            if dataProvider[0:4]!='http':
                r='http://%s'%dataProvider
            else: r=dataProvider
        self.seticon(serviceType)
        return r
        
class Service:
    ''' This simple class simply holds the service information known in a DIF ''' 
    def __init__(self):
        self.type='dif_related_url'
        self.name=''
        self.url=''
        self.description=''

class ServiceBinding (Service):
        ''' Given a specific entryID, we can go from the scheme identifier to the 
        native service which one expects to be able to operate upon it, for example,
        an NDG-A type identifier should expect the NDG-A-Service running at the
        specific repository. Note that we support the NDG id in the abbreviated format
        entryID is a repository:scheme:localidentifier string '''
        def __init__(self,n='',entryID=None,serviceFile='serviceMap.config'):
            Service.__init__(self)
            # regrettably we used different things in our ID's than we did in
            # our difs :
            self.mapping={'NDG-A0':'NDG_A_SERVICE','NDG-B0':'NDG_B_SERVICE',
            'NDG-B1':'NDG_B_SERVICE','DIF':'DISCOVERY'}
            self.serviceMap=ServiceMap(serviceFile=serviceFile)
            self.name=n
            if entryID is not None:
                self.fromEntry(entryID)
        def fromNative(self,nativeID,helper=None,seqno=1):
            ''' Support native XML ID form of entryID, see also fromEntry '''
            entryID=idconvert(nativeID,helper)
            return self.fromEntry(entryID,seqno)
        def fromEntry(self,entryID,seqno=1):
            ''' Given an entryID, get the native service '''
            #e.g. badc.nerc.ac.uk:NDG-A0:someLocalIdentifier 
            s,r,l,b=self.__getsrlb(entryID)
            uri=self.__makeuri(s,r,l)
            self.url=self.__makeurl(s,b,uri,seqno)
            self.serviceType=s
            return self
        def fromRelated(self,elem,entryID,helper=None,seqno=1):
            ''' Given a DIF related URL, get a service binding,
            using an instantiated ET helper that's available
            to avoid problems with namespaces '''
            # e.g:
            #<Related_URL>
            #<URL_Content_Type>NDG_B_Service</URL_Content_Type>
            #<URL>badc.nerc.ac.uk</URL>
            #</Related_URL>
            #<Related_URL>
            #<URL>http://badc.nerc.ac.uk/browse/badc/CDs/spade9293</URL>
            #</Related_URL>
            #following call simply sets some defaults
            s,r,l,b=self.__getsrlb(entryID)
            #which we now overwrite with detail from this particular rleated url
            #following helps us avoid namespace problems
            if helper is None:helper=nsdumb()
            self.description=helper.getText(elem,'Description')
            s=helper.getText(elem,'URL_Content_Type').upper()
            self.serviceType=s
            if s!='':
                #we (NDG) know about this type of URL ...
                r=helper.getText(elem,'URL')
                b=self.serviceMap.do(s,r)
                uri=self.__makeuri(s,r,l)
                self.url=self.__makeurl(s,b,uri,seqno)
            else:
                #unknown type
                self.serviceType='RELATED'
                self.url=self.serviceMap.do(self.serviceType,helper.getText(elem,'URL'))
            return self
        def __str__(self):
            ''' return string only html link '''
            return hyperlink(self.name,self.url)
        def icon(self):
            ''' return html icon linking to specific service '''
            return hyperlink(image(self.serviceMap.icon,self.serviceMap.iconalt),self.url)
        def __makeuri(self,s,r,l):
            ''' Actually create the URI '''
            if r=='': return l
            if s in ('NDG_B_SERVICE','DISCOVERY'):
                uri='%s/%s'%(r,l)
            else:
                uri=l
            return uri
        def __makeurl(self,s,b,uri,seqno):
            ''' Actually create the URL, which may be sequentially
            numbered if it's going to the data extractor (and so
            iType read from config file will have a %s in it ) '''
            iType=self.serviceMap.get(s,'instance','uri')
            if '%s' in iType: iType=iType%seqno
            return '%s?%s=%s'%(b,iType,uri)
        def __getsrlb(self,entryID):
            '''Take an entry ID, and parse it for NDG identifiers otherwise
            and if not, do something sensible '''
            try:
                r,s,l=entryID.split(':')
                if s in self.mapping: s=self.mapping[s].upper()
                b=self.serviceMap.do(s,r)
            except:
                #not from NDG ... provide only discovery binding
                s,r,l='DISCOVERY','',entryID
                b=self.serviceMap.get(s,'default')
                self.serviceMap.seticon(s)
            return s,r,l,b
            
if __name__=="__main__":
        import ElementTree as ET
        s='''<dataModelID>
                <schemeIdentifier>NDG-A0</schemeIdentifier>
                <repositoryIdentifier>badc.nerc.ac.uk</repositoryIdentifier>
                <localIdentifier>acsoe_badc_eae96_macehead_mcf_1</localIdentifier>
            </dataModelID>'''
        idelem=ET.fromstring(s)
        entryID=idconvert(idelem)
        n=ServiceBinding('macehead',entryID=entryID,serviceFile='serviceMap.config')
        maceheadServices=[n]
        s='''<dummy><Related_URL>
        <URL_Content_Type>NDG_B_Service</URL_Content_Type>
        <URL>badc.nerc.ac.uk</URL>
        </Related_URL>
        <Related_URL>
        <URL>http://badc.nerc.ac.uk/browse/badc/CDs/spade9293</URL>
        </Related_URL>
        <Related_URL>
        <URL_Content_Type>NDG_A_Service</URL_Content_Type>
        <URL>glue.badc.rl.ac.uk/somelongpath</URL>
        <Description> dummy dx example </Description>
        </Related_URL></dummy>
        '''
        stuff=ET.fromstring(s)
        for x in stuff.findall('Related_URL'):
            n=ServiceBinding('macehead',serviceFile='serviceMap.config')
            maceheadServices.append(n.fromRelated(x,idelem))
        for i in maceheadServices: 
            print str(i)
            print i.icon()