source: TI05-delivery/ows_framework/trunk/ows_server/ows_server/models/eXistInterface.py @ 3094

# Code inspired by example on eXist website.
import urllib2, base64, urllib, urlparse, httplib, xmlrpclib, types, os
from xmlHandler2 import xmlHandler as xmlh
import ndg_xqueries as xq

class InstanceObject(object):
    def __init__(self, **kw):
        self.dict={}
        self.dict.update(kw)
    def __getattr__(self,arg):
        return self.dict[arg]
    def __str__(self):
        return 'InstanceObject: %s '%self.dict
       
class edict(dict):
    '''An extended dictionary which allows one to set and get values
    as attributes (kudos Joe Gregorio's 1812) 
    The extended part allows you to get and set values as attributes.
    That is, 
       d.fred 
    is the same as 
       d['fred']
    '''
    def __init__(self,**kw):
        for a in kw:
            self[a]=kw[a]
    def __getattr__(self, key):
        try:
            return self.__dict__[key]
        except KeyError:
            pass
        try:
            assert not key.startswith('_')
            return self.__getitem__(key)
        except:
            raise AttributeError, "object has no attribute '%s'" % key
    def __setattr__(self, key, value):
        if key.startswith('_'):
            self.__dict__[key] = value
        else:
            return self.__setitem__(key, value)


class  eXist_Connector(object):
    """Access class for eXist"""
    def __init__(self,constants=None):
        ''' Instantiates the eXist connector using supplied constants '''
        if constants is None: raise 'NoExistConstants'
        authinfo = urllib2.HTTPPasswordMgrWithDefaultRealm()
        authinfo.add_password(None,
                                  constants.host,
                                  constants.userid,
                                  constants.password)
        authHandler = urllib2.HTTPBasicAuthHandler(authinfo)
        opener = urllib2.build_opener(authHandler)
        s = constants.userid+':'+constants.password 
        z = base64.encodestring(s)[:-1] # strip trailing 12
        opener.addheaders.append(('Authorization', 'Basic %s' % z))
        self.http_headers = {'Authorization':'Basic %s' % z}
        self.opener = opener
        # also create an xmlrpc Server object
        
        xmlrpc_uri = '%s%s:%s@%s:%d%s' % (  
                                            'http://',
                                            constants.userid,
                                            constants.password,
                                            constants.host,
                                            constants.port,
                                            constants.xmlrpc_base_path
                                        )
        self.xmlrpc = xmlrpclib.Server(xmlrpc_uri)

    def executeQuery(self, xquery, params={}):
        '''Execute an xquery string, return session and summary information'''
        xquery=xmlrpclib.Binary(xquery)
        id = self.xmlrpc.executeQuery(xquery, params)
        summary = self.xmlrpc.querySummary(id)
        return id,summary

    def release(self,id):
        ''' Release an executeQuery session '''
        self.xmlrpc.releaseQueryResult(id)
        
    def retrieve(self,id,pos,params={}):
        ''' Retrieve a specific document from an executeQuery result set '''
        return self.xmlrpc.retrieve(id,pos,params).data
 
    def executeChunkedQuery(self,xquery,start,number,params={}):
        ''' Execute a query, return a specific part of the result set, and
        dump the session automagically '''
        xquery=xmlrpclib.Binary(xquery)
        r=self.xmlrpc.query(xquery,number,start,params)
        return r
    
    def querySummary(self,id):
        ''' Returns a summary of query results for the result-set referenced by id (which was returned by a previous query '''
        return self.xmlrpc.querySummary(id)
    
    def getHits(self,id):
        ''' Return the number of hits associated with the query that created session id '''
        return self.xmlrpc.getHits(id)
    
    def getDoc(self,collectionName,documentName):
        ''' Lightweight interface to the getDocument method '''
        name='%s/%s'%(collectionName,documentName)
        r=self.xmlrpc.getDocumentAsString(name,{})
        return r
    
# unfortunately it looks like the exist server doesn't support introspection
#    def showMethods(self):
#        print self.xmlrpc.system.listMethods()
        
class ndg_eXist(eXist_Connector):
    ''' Adds ndg methods to a "standard" exist Connector '''
    def __init__(self,db='glue.badc.rl.ac.uk',passwordFile='passwords.txt'):
        try:
            f=file(passwordFile,'r')
        except IOError,e:
            raise IOError('%s [looking for %s in %s]'%(e,passwordFile,os.getcwd()))
            
        pw={}
        for line in f.readlines():
            host,userid,password=line.strip().split(' ')
            pw[host]=(userid,password)
        if db not in pw:
            raise ValueError('Unable to find eXist password for repository [%s]'%db)
        eXistConstants = InstanceObject(host=db,
                                userid=pw[db][0],
                                password=pw[db][1],
                                base_path="/exist/servlet",
                                xmlrpc_base_path="/exist/xmlrpc",
                                port=8080)
        
        eXist_Connector.__init__(self,eXistConstants)
        self.ids={}
        
    def __buildquery(self,query,target=None):
        '''Create an NDG full text query '''
        if target is not None:
            s='''let $hits := collection('/db/%s')//root()[. &= '%s'] 
                 for $i in $hits 
                    return <document>{document-uri($i)}</document>'''%(target,query)
        else: s="/*[. &='%s']"%query

        return s#xmlrpclib.Binary(s)

    def __buildParamSearch(self,param,value,target):
        s="for $x in document()//%s where $x[.%s &= '%s'] return $x"%(target,param,value)
        return s

    def full_text(self,query,target=None):
        ''' Carry out a full text search within the "target" collection '''
        id,summary=self.executeQuery(self.__buildquery(query,target))
        self.ids[id]=0
        return id,summary

    def retrieveNext(self,id,pos=None):
        ''' Takes a sessionID from an existing query and gets the next document '''
        if pos is not None: self.ids[id]=pos
        try:
            r=self.retrieve(id, self.ids[id])
            self.ids[id]+=1
            return r
        except xmlrpclib.Fault:
            return None
        except KeyError:
            return None
    
    def sessionRelease(self,id):
        ''' Releases a session and removes the position counter '''
        try:
            self.release(id)
            del self.ids[id]
            return 1
        except:
            return 0
    
    def chunkedFullText(self,query,start=1,number=10,target='DIF'):
        ''' Execute a chunked full text query and return the result
        set '''
        return self.executeChunkedQuery(self.__buildquery(query,target),start,number,params={})
    
    
    def getDIF(self,entryID):
        ''' Get a specific DIF document from a repository by using the entryID '''
        xq='''for $DE in collection()/DIF[Entry_ID='%s'] return $DE'''%entryID
        xquery='''for $DE in collection('/db/testdif1')/DIF[Entry_ID='%s'] return $DE'''%entryID
        id,summary=self.executeQuery(xq)#xquery)
        if summary['hits']==1:
            r=self.retrieve(id,0,{})
            self.sessionRelease(id)
        else:
            r=summary['hits']
        return r
        
    def search(self,term,start=1,howmany=20,target=None,scope=None,bbox=None,dateRange=None,geoSearchType=None):
        ''' Provides a search interface that mimics the WSDL search interface, except that
        the target used is the exist collection name, and scope, bbox and dateRange are ignored,
        and a python summary object is returned '''
        xquery={'ndg_B_metadata':xq.molesSearchSummary,'NumSim':xq.numsimSummary}[target]
        xquery=xquery.replace('SEARCHSTRING',term)
        r=self.executeChunkedQuery(xquery,start,howmany)
        print r
        x=xmlh(str(r),string=1)
        h=x.tree.get('hits')
        self.results=[]
        self.serverSessionID=''
        if h is None:
            self.hits=0
            self.start=0
            self.howmany=0
            self.error=['No results for [%s]'%term,]
        else:
            self.hits=int(h)
            self.error=None
            self.start=int(x.tree.get('start'))
            self.howmany=int(x.tree.get('count'))
            slist=x.tree.findall('summary')
            for s in slist:
                t=edict(id=s.find('id').text,name=s.find('name').text,type=s.find('type').text)
                self.results.append(t)
        return self.results

import unittest

class TestCase(unittest.TestCase):
    
    def testFullText(self):
            
        ''' Exercises some of the methods based on something we hope might exist in the database '''
        
        existDB=ndg_eXist(db='glue.badc.rl.ac.uk')
        id,summary=existDB.full_text('neodc')
        
        r=existDB.retrieveNext(id)
        d=summary['documents'][0][0]
        doc=existDB.getDoc('/db/discovery/moles',d)
        
        ok=existDB.sessionRelease(id)
        self.assertEqual(1,ok)
        
    def testSearch(self):
        existDB=ndg_eXist(db='chinook.badc.rl.ac.uk')
        r=existDB.search('coapec',target='ndg_B_metadata')
        print existDB.hits
        for i in r: print i
        r=existDB.search('HadAM2',target='NumSim')
        print existDB.hits
        
    def testedict(self):
        i=edict(a=1,b=2)
        i.c=3
        i['d']=4
        correct={'a':1,'b':2,'c':3,'d':4}
        for j in correct: self.assertEqual(correct[j],i[j])

if __name__=="__main__":
    unittest.main()