source: exist/trunk/python/ndgUtils/eXistConnector.py @ 4286

# Code inspired by example on eXist website.
import urllib2, base64, urllib, urlparse, httplib, xmlrpclib, types, os, logging

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 eXistConnector(object):
    
    # default collections for the various file types in eXist
    BASE_COLLECTION_PATH = "/db/atoms/"
    OLD_COLLECTION_PATH = "old/"
    PUBLISHED_COLLECTION_PATH = "Published/"
    SMALL_P_PUBLISHED_COLLECTION_PATH = "published/"
    WORKING_COLLECTION_PATH = "working/"
    BACKUP_COLLECTION_PATH = "/db/atoms_backup/"
    GRANULE_COLLECTION_PATH = "data_granules/"
    DEPLOYMENT_COLLECTION_PATH = "deployment_data/"
    DEPLOYMENTS_COLLECTION_PATH = "deployments/"
    DE_COLLECTION_PATH = "data_entities/"
    NDG_A_COLLECTION_PATH = "/db/ndg_A_metadata/"
    NDG_A_COLLECTION_PATH_BACKUP = "/db/ndg_A_metadata_backup/"

    """Access class for eXist"""
    def __init__(self,constants=None):
        ''' Instantiates the eXist connector using supplied constants '''
        logging.debug("Setting up xmlrpc connection to eXist")
        if constants is None: raise 'NoExistConstants'
        logging.debug("Host: '%s', User: '%s'" %(constants.host, constants.userid))
        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)
        logging.debug("xmlrpc connection set up")


    def executeQuery(self, xquery, params={}):
        '''Execute an xquery string, return session and summary information'''
        logging.debug("Executing xquery on eXist:\n%s" %xquery)
        xquery=xmlrpclib.Binary(str(xquery))
        id = self.xmlrpc.executeQuery(xquery, params)
        summary = self.xmlrpc.querySummary(id)
        logging.debug("XQuery executed")
        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 '''
        logging.debug("Retrieving document from eXist...")
        xml = self.xmlrpc.retrieve(id,pos,params).data
        logging.debug("Document retrieved.")
        return xml
 
    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 
    '''
    # atoms have a more structured collection directory - as a result
    # AtomList.xq returns the full path to the listed docs - so avoid
    # concat'ing the collectionName for these
        if documentName.startswith(collectionName):
            name = documentName
        else:
            name='%s/%s'%(collectionName,documentName)
        r=self.xmlrpc.getDocumentAsString(name,{})
        return r
    
    def removeCollection(self,collectionPath):
        ''' Remove a collection in the eXist database '''
        r=self.xmlrpc.removeCollection(collectionPath)
        return r
    
    def removeDoc(self, docPath):
        ''' Remove a document from the eXist database '''
        r=self.xmlrpc.remove(docPath)
        return r
    
    def createCollection(self,collectionPath):
        ''' Create a collection in the eXist database at collectionPath '''
        logging.info("Creating collection: '%s'" %collectionPath)
        r=self.xmlrpc.createCollection(collectionPath)
        logging.info("Collection created")
        return r
    
    def storeXML(self,xml,path,overwrite=0):
        ''' Store some XML into the databse at path '''
        return self.xmlrpc.parse(xml,path,overwrite)