source: ndgCommon/trunk/ndg/common/src/dal/DocumentRetrieve.py @ 4793

'''
 Extend eXistInterface class - to add document retrieval functionality
 
 @author: B Lawrence?
'''
from ndg.common.src.clients.xmldb.eXist.eXistInterface import ndg_eXist
from ndg.common.src.lib.ndgXqueries import ndgXqueries
from xml.etree import ElementTree as ET
import urllib2, logging, socket


def httpify(url):
    '''
    Ensure a url has an http prefix
    '''
    if url[0:4] != 'http':
        url = 'http://' + url
    return url
    
        
class DocumentRetrieve(ndg_eXist):
    ''' 
    This class provides a document retrieval service via the NDG exist interfaces 
    '''

    ATOM_TYPE = 'ATOM-TYPE'
    ATOM_BACKUP_TYPE = 'ATOM-BACKUP'
    ATOM = 'ATOM'
    def __init__(self, repository, pwfile='passwords.txt'):
        logging.info("Using repository, '%s'" %repository)

        ndg_eXist.__init__(self, db=repository, passwordFile=pwfile)
        logging.info("DB connection initialised")
        self.repository=repository
        self.xq=ndgXqueries()
        self.knownQueries={'DIF':'moles2dif','DC':'moles2DC','ISO19139':'moles2iso19139', \
                           'NDG-B0':'moles','NDG-B1':'molesObjectType','MDIP':'moles2mdip', \
                           'NDG-A0':'csml','NumSim':'numsim', self.ATOM:'atom', \
                           self.ATOM_BACKUP_TYPE:'atom', self.ATOM_TYPE:'atomTypeList'}

    def _retrieveDoc(self, schema, xqtype, targetCollection, repository, localID):
        '''
        Retrieve doc using specified XQuery type
        @return: docName, docContents
        '''
        logging.debug("Retrieving doc - type, '%s', coll, '%s', rep:'%s', localID:'%s'" \
                      %(xqtype,targetCollection,repository,localID))
        xquery=self.xq.actual(xqtype,targetCollection,repository,localID)

        id,summary=self.executeQuery(xquery)
        # NB, backups will inevitably return lots of docs - only retrieve the top one
        # for the moment - since this is not really needed atm
        if summary['hits'] != 1 and schema != self.ATOM_BACKUP_TYPE:
            raise ValueError('Unable to obtain single %s document [%s] (hits=%s)'\
                             %(schema,localID,summary['hits']))

        docName = summary['documents'][0][0]
        r=self.retrieve(id,0,{})
        self.sessionRelease(id)
        return docName, r


    def get(self,repository,schema,localID,targetCollection='/db/discovery/moles', \
            includeDocNameData=False):
        '''
        @keyword includeDocNameData: if True, a dictionary is returned, instead of the dataset, with the key
        being the name of the document and the entry being the dataset
        '''
        logging.debug("Get called with rep:'%s', schema:'%s', localID:'%s', collection:'%s'" \
                      %(repository,schema,localID,targetCollection))
        docName = ""
        if schema not in self.knownQueries:
            raise TypeError('Unknown Schema "%s" in URI'%schema)

        xqtype=self.knownQueries[schema]

        if schema == 'NDG-B1':
            # this is a general moles object - so need to further establish the type of moles doc 
            # it is to get the correct XQUery to use
            name, xml = self._retrieveDoc(schema, xqtype, targetCollection, \
                                          repository, localID)
            xml=ET.fromstring(xml)
            otype=int(xml.text or 0)
            
            xqtype={4:'stubB_dataEntity',
                    3:'stubB_observationStation',
                    2:'stubB_DPT',
                    1:'stubB_activity'}[otype]

        docName, r = self._retrieveDoc(schema, xqtype, targetCollection, 
                                       repository, localID)
        if includeDocNameData:
            return {docName: r}
        return r
    
    
    def error(self,string,t,r,s,l):
        raise ValueError,string+' for %s:%s:%s in %s'%(r,s,l,t)

            
class genericHTTP(object):
    ''' Provides a generic HTTP request class '''
    def __init__(self,proxyServer=None):
        if proxyServer is None:
            proxyHandler=urllib2.ProxyHandler({})
        else:
            proxy=httpify(proxyServer)
            proxyHandler=urllib2.ProxyHandler({'http':proxy})
        self.opener=urllib2.build_opener(proxyHandler)
        
    def get(self,url):
        url = httpify(url)
        request=urllib2.Request(url)
        logging.info("Getting data from url: %s" %url)
        response='Cannot obtain remote file: '
        try:
            f = self.opener.open(request)
            response=''
        except urllib2.URLError,e:
            if hasattr(e,'reason'):
                response+='No access to server [%s]'%e.reason
            elif hasattr(e,'code'):
                response+='Response code [%s]'%e.code
        except socket.error:
            response+='Network Socket problem'
        except Exception,e:
            response+='[%s]'%str(e)
            
        if response=='':
            return f.read()
        else:
            raise IOError(response)  

            
class ndgHTTP(genericHTTP):
    ''' Provides a get method to obtain an xml document from a remote NDG repository '''
    def __init__(self,remoteHost,proxyServer=None):
        self.remoteHost=remoteHost
        genericHTTP.__init__(self,proxyServer)
        
    def uriget(self,uri):
        # NB, having this import at the module level can cause problems
        # with resolving imports when using this module - e.g. from the
        # ndgObject level
        from ndg.common.src.models.ndgObject import ndgObject
        n = ndgObject(uri)
        return self.get(n.repository,n.schema,n.localID)

    def get(self,repository,schema,localID,**kw):
        ''' Return a remote ndg document '''
        #TODO what about security? Probably means we need to get the headers of our responses sorted ...
        url='%s/retrieve/%s__%s__%s'%(self.remoteHost,repository,schema,localID)
        return genericHTTP.get(self,url)
        
    def setSecurity(self,location,usercode,password):
        ''' Use a usercode password to set security credentials at a specific location '''
        pass

    
class ndgVocabPOX(genericHTTP):
    ''' Provides a POX interface to the vocab server '''
    def __init__(self,path="http://vocab.ndg.nerc.ac.uk/axis2/services/vocab/",proxyServer=None):
        genericHTTP.__init__(self,proxyServer)
        self.path="http://vocab.ndg.nerc.ac.uk/axis2/services/vocab/"
        self.ns="http://vocab.ndg.nerc.ac.uk/"
    def getRelated(self,subject):
        ''' Get a related record '''
        url='%sgetRelatedRecordByCriteria?subjectText=%s&predicate=255&inferences=True&objectList=%slist/P211/current'%(self.path,subject,self.ns)
        self.url=url
        doc=genericHTTP.get(self,url)
        x=ET.fromstring(doc)
        b=x.findall('*/{urn:vocab/types}broadMatch')
        n=x.findall('*/{urn:vocab/types}narrowMatch')
        s=x.findall('*/{urn:vocab/types}exactMatch')
        self.broader=[(i.find('{urn:vocab/types}entryTerm').text or '') for i in b]
        self.narrower=[(i.find('{urn:vocab/types}entryTerm').text or '') for i in n]
        self.synonyms=[(i.find('{urn:vocab/types}entryTerm').text or '') for i in s]
        return [self.broader,self.narrower,self.synonyms]