Changeset 4934 for ndgCommon/trunk/ndg


Ignore:
Timestamp:
10/02/09 17:36:35 (11 years ago)
Author:
cbyrom
Message:

Update lib code to cope with new client suite + remove dependency on
xmlHandler2 and remove this + various other tidy ups.

Location:
ndgCommon/trunk/ndg/common/src
Files:
3 deleted
5 edited

Legend:

Unmodified
Added
Removed
  • ndgCommon/trunk/ndg/common/src/clients/reldb/postgres/postgresclient.py

    r4853 r4934  
    66 
    77import pgdb, logging, sys 
    8 import ndg.common.src.clients.xmldb.eXist.existdbclient as edc 
    98 
    109DEFAULT_CONFIG_FILE = 'pg.config' 
  • ndgCommon/trunk/ndg/common/src/lib/atomutilities.py

    r4793 r4934  
    99from ndg.common.src.models.ndgObject import ndgObject 
    1010from ndg.common.src.lib.utilities import findElementIndex 
    11  
     11import ndg.common.src.clients.xmldb.eXist.dbconstants as dc 
    1212 
    1313def addStandardKeywords(doc): 
     
    111111 
    112112 
    113 def getDataCentreDIFElement(repositoryID, xmldb): 
     113def getDataCentreDIFElement(repositoryID, atomClient): 
    114114    ''' 
    115115    Organisation data needs to be added to DIF records created from atoms 
     
    117117    @param repositoryID: ID of the organisation where the data is stored.  Currently 
    118118    valid IDs are 'badc.nerc.ac.uk' and 'neodc.nerc.ac.uk' 
    119     @param xmldb: eXist client implemnting eXistInterface 
     119    @param atomClient: xml db client implementing the InterfaceXMLDBClient interface 
    120120    @return: Elementtree Element containing the specified Data_Centre element data 
    121121    @raise: ValueError if unrecognised repository ID is specified 
     
    125125        raise ValueError("Unrecognised repository ID, '$s'" %repositoryID) 
    126126     
    127     ndgURL = '%s:DIF:organisation' %repositoryID 
    128     orgData = xmldb.getDIF(ndgURL) 
     127    # NB, using the query() method (via the useChunked keyword) here results 
     128    # in the namespaces being expanded - which ET doesn't like 
     129    orgData = atomClient.buildAndRunQuery('dif', dc.RESOURCES_COLLECTION_PATH,  
     130                                          repositoryID, 'organisation', 
     131                                          useChunked = False) 
     132     
     133    if not orgData: 
     134        raise ValueError("Could not find organisation data for provider, '%s'" %repositoryID) 
     135 
    129136    logging.info("Data retrieved - turning this into Elementtree Element data") 
    130137     
    131138    # strip out the content we want 
    132     tree = ET.fromstring(orgData) 
     139    tree = ET.fromstring(orgData[0]) 
    133140    dataCentre = tree.find('{' + ndgObject.DIF_NS + '}Data_Center') 
    134141    logging.info("- returning Element data for data centre") 
  • ndgCommon/trunk/ndg/common/src/lib/atomvalidator.py

    r4844 r4934  
    1212''' 
    1313import logging, traceback, datetime, xmlrpclib, socket 
    14 import ndg.common.src.clients.xmldb.eXist.existdbclient as edc 
     14from ndg.common.src.clients.xmldb.eXist.atomclient import AtomClient 
    1515from ndg.common.src.models.vocabtermdata import isValidTermURI 
    1616from ndg.common.src.models.Atom import Atom 
     
    3838    Helper class for validating atom data 
    3939    ''' 
    40     # eXist DB client 
    41     _eXist = None 
     40    # eXist DB atom client 
     41    _atomClient = None 
    4242     
    4343    # standard output delimiter 
     
    5757    def __init__(self, atom, dbConfigFile, raiseException = True, \ 
    5858                 newLineChar= NEW_LINE, loadAllCollections = False, \ 
    59                  isDebug = False): 
     59                 isDebug = False, dbHostName = 'chinook.badc.rl.ac.uk'): 
    6060        ''' 
    6161        Set up validator object - with atom to validate 
     
    6767        connection, if True 
    6868        @keyword isDebug: if True, provide more detailed output 
     69        @keyword dbHostName: name of eXist host to use - NB, should feature in 
     70        the specified dbConfigFile 
    6971        ''' 
    7072        logging.info("Setting up atomValidation object") 
     
    7981         
    8082        # set up connection to eXist 
    81         self.__setUpEXistDBConnection(dbConfigFile, loadAllCollections = loadAllCollections) 
     83        self.__setUpEXistDBConnection(dbConfigFile,  
     84                                      loadAllCollections = loadAllCollections, 
     85                                      dbHostName = dbHostName) 
    8286 
    8387        # setup the dictionary to store errors 
     
    8791 
    8892     
    89     def __setUpEXistDBConnection(self, dbConfFile, loadAllCollections = False): 
     93    def __setUpEXistDBConnection(self, dbConfFile,  
     94                                 loadAllCollections = False, 
     95                                 dbHostName = 'chinook.badc.rl.ac.uk'): 
    9096        ''' 
    9197        Get the default eXist DB connection - by reading in data from the db config file 
    9298        @keyword dbConfigFile: config file to use with eXist DB connection 
    9399        @keyword loadAllCollections: loads all collections info when initialising eXist 
     100        @keyword dbHostName: name of eXist host to use - NB, should feature in 
    94101        ''' 
    95102        logging.info("Setting up connection to eXist DB") 
    96         self._eXist = edc.eXistDBClient(configFile = dbConfFile,  
    97                                         loadCollectionData=loadAllCollections) 
     103        self._atomClient = AtomClient(configFileName = dbConfFile,  
     104                                      loadCollectionData=loadAllCollections, 
     105                                      dbHostName = dbHostName) 
    98106        logging.info("eXist DB connection now set up") 
    99107 
     
    327335        atomPath = self._atom.getDefaultCollectionPath() + self._atom.atomName 
    328336        try: 
    329             errors = self._eXist.checkAtomSchemaCompliance(atomPath, atom = self._atom, 
     337            errors = self._atomClient.checkAtomSchemaCompliance(atomPath, atom = self._atom, 
    330338                                                           isDebug = self._isDebug) 
    331339            for error in errors: 
  • ndgCommon/trunk/ndg/common/src/lib/granulite.py

    r4844 r4934  
    77''' 
    88import os, sys, string, getopt, logging, re, datetime, cgi 
    9 from ndg.common.src.clients.xmldb.eXist.eXistConnector import eXistConnector 
     9import ndg.common.src.clients.xmldb.eXist.dbconstants as dc 
    1010from ndg.common.src.models import Atom 
    1111import ndg.common.src.lib.utilities as utilities 
    1212from ndg.common.src.models.vocabtermdata import VocabTermData as VTD 
    13 import ndg.common.src.clients.xmldb.eXist.existdbclient as edc 
     13from ndg.common.src.clients.xmldb.eXist.atomclient import AtomClient 
    1414 
    1515class granulite(object): 
     
    8282        @keyword granuleAtom: an existing granule atom - to add granulite data to 
    8383        - NB, if not specified, a new atom is used 
    84         @keyword eXistClient: an eXist connection 
     84        @keyword eXistClient: an eXist client implementing the InterfaceXMLDBAtomClient interface 
    8585        @keyword csmlOrCdmlFile: a cgi.FieldStorage object with CSML or CDML data 
    8686        @keyword aggregateCoverage: if set to True, only coverage data that extends the 
     
    106106            self._eXist = eXistClient 
    107107        else: 
    108             self._eXist = edc.eXistDBClient(configFile = self.DBCONFIG_FILE) 
     108            self._eXist = AtomClient(configFile = self.DBCONFIG_FILE) 
    109109         
    110110        # override CSML/CDML data specified in the granulite file with data input directly 
     
    371371            dataEntityProviderID = data[1] 
    372372             
    373             self.__updateDataEntity(dataEntityID) 
     373            self.__updateDataEntity(dataEntityID, dataEntityProviderID) 
    374374 
    375375        logging.info("Granule data added to data entities") 
     
    382382        logging.info("Removing granule info from data entities") 
    383383        logging.info("Retrieving data entities with references to granule") 
    384         self._atom.lookupAssociatedData(VTD.DE_TERM, self._eXist.xmldb, \ 
    385                                     lookupIndirectReferences = True) 
     384        self._atom.lookupAssociatedData(VTD.DE_TERM, self._eXist, 
     385                                        lookupIndirectReferences = True) 
    386386         
    387387        # now set up the granule links to the data entities specified 
    388388        for de in self._atom.dataEntities: 
    389             self.__updateDataEntity(de.rel, removeLink = True) 
     389            self.__updateDataEntity(de.rel, "", removeLink = True) 
    390390        logging.info("Granule data removed from data entities") 
    391391 
    392392 
    393     def __updateDataEntity(self, dataEntityID, removeLink = False): 
     393    def __updateDataEntity(self, dataEntityID, providerID, removeLink = False): 
    394394        ''' 
    395395        Retrieve the specified data entity and add a link to the current 
    396396        data granule, if required, then update the atom in eXist 
    397397        @param dataEntityID: ID of the data entity to augment with granule link 
     398        @param providerID: provider ID of the data entity to augment with granule link 
    398399        @keyword removeLink: If True, remove the link to the current data granule 
    399400        - otherwise add it 
    400401        ''' 
    401402        logging.debug("Retrieving data entity atom - to update associated granule info") 
    402 #        doc = self._eXist.getAtom('dataent_' + dataEntityID) 
    403         doc = self._eXist.getAtom(dataEntityID) 
     403        doc = self._eXist.buildAndRunQuery('atom',  
     404                                           dc.ATOM_COLLECTION_PATH,  
     405                                           providerID,  
     406                                           dataEntityID) 
    404407        logging.debug("DE retrieved") 
    405         de = Atom.Atom(xmlString=str(doc)) 
     408         
     409        de = Atom.Atom(xmlString=str(doc[0])) 
    406410        noLinks = len(de.relatedLinks) 
    407411         
     
    426430         
    427431        logging.debug("Now, save the updated DE atom back to eXist") 
    428         self._eXist.createAtomInExist(de) 
     432        self._eXist.createAtom(de) 
    429433        logging.debug("DE atom updated") 
    430434 
     
    447451                               self._csmlContent, useCSMLID = self.useCSMLID) 
    448452        logging.info("Adding CSML file to eXist") 
    449         self._eXist.createOrUpdateEXistFile(self._csmlContent, \ 
    450                                         eXistConnector.NDG_A_COLLECTION_PATH + \ 
    451                                         self._atom.ME.providerID + '/', \ 
    452                                         fileName) 
     453        self._eXist.createOrUpdateDoc(self._csmlContent, 
     454                                      dc.NDG_A_COLLECTION_PATH + \ 
     455                                      self._atom.ME.providerID + '/', 
     456                                      fileName) 
    453457        logging.info("CSML file added to eXist") 
    454458        logging.info("Finished processing CSML file") 
     
    468472 
    469473        logging.info("Adding CDML file to eXist") 
    470         self._eXist.createOrUpdateEXistFile(self._cdmlContent, \ 
    471                                             eXistConnector.NDG_A_COLLECTION_PATH + \ 
    472                                             self._atom.ME.providerID + '/',\ 
    473                                             fileName) 
    474         self._atom.cdmlFile = eXistConnector.NDG_A_COLLECTION_PATH + fileName 
     474        self._eXist.createOrUpdateDoc(self._cdmlContent, 
     475                                      dc.NDG_A_COLLECTION_PATH + \ 
     476                                      self._atom.ME.providerID + '/', 
     477                                      fileName) 
     478        self._atom.cdmlFile = dc.NDG_A_COLLECTION_PATH + fileName 
    475479         
    476480        # create a local copy of the CDML file - NB, this is required if running 
     
    589593            doReplace = replaceAtom or self._replaceAtom 
    590594            logging.info("Creating granule atom, '%s', in eXist DB" %self._atom.atomName) 
    591             self._eXist.createAtomInExist(self._atom, replaceAtom = doReplace) 
     595            self._eXist.createAtom(self._atom, replaceAtom = doReplace) 
    592596             
    593597            # if the atom already exists, keep track of the backed up file - incase it 
     
    635639        logging.info("Deleting granule...") 
    636640        logging.info("Remove granule atom from eXist") 
    637         self._eXist.deleteAtomInExist(self._atom) 
     641        self._eXist.deleteDoc(self._atom.getFullPath()) 
    638642        logging.info("Granule deleted") 
    639643 
  • ndgCommon/trunk/ndg/common/src/lib/utilities.py

    r4844 r4934  
    2424 
    2525URLIB2_INITIALISED = False 
     26 
     27 
     28def loadConfigDetails(configFilename, dbName = None): 
     29    ''' 
     30    Load the config file details for the DB and return the data relating 
     31    to the specified db 
     32    @param configFilename: name of config file to use 
     33    @keyword dbName: name of DB to use; if specified, must feature in the config file; 
     34    if not specified, use first config data found in file 
     35    @raise ValueError: if dbName not featured in the password file 
     36    @raise IOError: if password file cannot be opened 
     37    @return userID, password, hostname for specified DB 
     38    '''     
     39    logging.info("Loading DB config data") 
     40    # Check this file exists 
     41    if not os.path.isfile(configFilename): 
     42        errorMessage = "Could not find the DB config file, %s; please make sure this " \ 
     43                 "is available from the running directory" %configFilename 
     44        logging.error(errorMessage) 
     45        raise ValueError(errorMessage) 
     46     
     47    f=file(configFilename, 'r') 
     48    for line in f.readlines(): 
     49        line = line.strip() 
     50        if not line: 
     51            continue 
     52        host,userid,password=line.split(' ') 
     53        data = (userid, password, host) 
     54        if not dbName or dbName == host: 
     55            f.close() 
     56            logging.debug("Returning config file info for db, '%s'" %host) 
     57            return data 
     58 
     59    raise ValueError('Unable to find valid eXist config data') 
     60 
    2661 
    2762def openURLWithProxy(uri): 
Note: See TracChangeset for help on using the changeset viewer.