source: TI05-delivery/ows_framework/trunk/ows_server/ows_server/lib/ndgInterface.py @ 2695

# Copyright (C) 2007 STFC & NERC (Science and Technology Facilities Council).
# This software may be distributed under the terms of the
# Q Public License, version 1.0 or later.
# http://ndg.nerc.ac.uk/public_docs/QPublic_license.txt
"""
Manages interface to NDG documents and data, including caching 
"""

from cache import Cache
import os, tempfile
import cdms, csml
from ows_server.models import ndgRetrieve, ndgObject
from pylons import request,session
import logging
logger = logging.getLogger('ndgInterface')
from ows_server.models.ndgSecurity import HandleSecurity

class CDMSEntry(object):
    """
    A reference to a CDMS file that will delete the file when it is
    garbage collected.

    Instances of this class are used as Cache entry values.  When entries are
    automatically removed from the cache the CDMSEntry object will be
    garbage collected unless it is being accessed by another thread.

    """

    __slots__ = ['_f', 'var']
    
    def __init__(self, filename, varname):
        logger.info('Caching file variable %s in %s' % (varname, filename))
        self._f = cdms.open(filename)
        self.var = self._f[varname]
    def __del__(self):
        filename = self._f.id
        logger.info('Removing file %s' % filename)
        self._f.close()
        os.remove(filename)
 

class CSMLExtractCache(Cache):
    
    def __init__(self, cache_dir, max_size=0):
        super(CSMLExtractCache, self).__init__(max_size)
        self._cache_dir = cache_dir

    def _extract(self, feature, sel):
        (fd, filename) = tempfile.mkstemp('.nc', 'csml_wxs_', self._cache_dir)
        os.close(fd)
        (outputdir, ncname) = os.path.split(filename)

        # Workarround until ticket:778 (TestExtractAll) is fixed
        sel.update(longitude=(-180, 180), latitude=(-90, 90))

        feature.subsetToGridSeries(ncname=ncname, outputdir=outputdir, **sel)

        return filename
    
    def key(self, name):
        """
        Cache provides this method to map externally visible entry names
        to internal keys.  We use it here to turn selectors into hashable
        values.

        """
        (feature, sel) = name
        
        return (feature.id, tuple(sorted(sel.items())))

    def build(self, key, name, opened, entry):
        (feature, sel) = name
        filename = self._extract(feature, sel)

        return CDMSEntry(filename, feature.name.CONTENT)

    def __getitem__(self, name):
        """
        Returns the opened CDMS object.

        """
        return super(CSMLExtractCache, self).__getitem__(name).var

class ndgInterface:
    
    def __init__(self):
        ''' Instantiate with three level cache:
                - a file cache
                - a xmlhandler object cache, and
                - a parsed CSML object cache.'''
                
        self.CSMLDataCache=CSMLExtractCache(
                request.environ['paste.config']['app_conf']['tmp_dir'],max_size=10)
        self.CSMLDocCache=Cache(max_size=10)
        self.XMLHCache=Cache(max_size=10)
        

    def GetXML(self,uri,format=''):
        ''' This method provides a secure interface to the server
        document cache and a remote NDG exist. It is assumed that
        the local filesystem is protected in that you can't get to
        files except via the CSML api '''
        #    Note that this method should not be used to obtain
        #unsecured discovery documents, these are called directly
        #in the retrieve controller!
        
        try:
            ndgO=ndgObject.ndgObject(uri)
            localFile=0
        except ValueError:
            ''' It's a local file not an ndg identifier '''
            ndg0=uri
            localFile=1
        
        if 'ndgCleared' in session:
            cleared=session['ndgCleared']
        else:
            cleared=None
         
        try:
            xmlh=self.XMLHCache[uri]
            status=1
            logging.info('XMLH Cache hit for [%s]'%uri)
        except:
            logging.info('XMLH Cache miss for [%s]'%uri)
            if localFile:
                status,xmlH=self.__getLocal(uri)
            else:    
                status,xmlh=ndgRetrieve.ndgRetrieve(ndgO,request.environ['ndgConfig'],logger,format)
            if status: self.XMLHCache[uri]=xmlh
        
        # valid values of the return objects SHOULD BE 
        #   ok:         status=1, xmlh=an xml handler instance.
        #   exceptions, status=0, xmlh='Exception(e)'
        
        status,xmlh=self.__GateKeep(ndgO,xmlh)
        if status:
            if cleared is None:
                session['ndgCleared']=[uri]
            else:
                session['ndgCleared'].append(uri)
            session.save()
       
        return status,xmlh
            
    def GetParsedCSML(self,uri):
        
        ''' This method gets a parsed CSML object corresponding to the URI '''
        
        # do we need an xml handler instance to test the security?
        if 'ndgCleared' not in session:
            status,xmlh=self.GetXML(uri)
        else: 
            if uri not in session['ndgCleared']: 
                status,xmlh=self.GetXML(uri)
            else: status=1
        if not status: return status,xmlh
        
        try:
            d=self.CSMLDocCache[uri]
            logging.info('CSML Cache hit for [%s]'%uri)
        except:
            logging.info('CSML Cache miss for [%s]'%uri)
            status,xmlh=self.GetXML(uri)
            if not status: return status,xmlh    
            d=csml.parser.Dataset()
            d.parseElemTree(xmlh.tree)
            self.CSMLDocCache[uri]=d
        status=1
        return status,d
        
    def __GateKeep(self,uri,x):
        ''' This is the NDG gatekeeper '''
        if 'ndgSec' in session:
            securityTokens=session['ndgSec']
        else:
            securityTokens=None
        
        if uri.schema=='DIF':
            pass # no access control
        elif uri.schema =='NDG-B0':
            #cred=x.find('dgSecurityCondition/simpleCondition')
            #if cred:
            #    return 0,'<p> Access Control: <br/>[<![CDAT[%s]]> </p>'
            pass
        elif uri.schema =='NDG-B1':
            pass # for the moment
        elif uri.schema =='NDG-A0':
            s=x.tree.find('{http://ndg.nerc.ac.uk/csml}AccessControlPolicy/{http://ndg.nerc.ac.uk/csml}dgSecurityCondition')
            if s is not None:
                status,message=HandleSecurity(s,securityTokens)
                if not status: return 0,'<p> Access Denied </p><p>%s</p>'%message
        return 1,x
                
    def __getLocal(self,uri):
        ''' Returns a local csml file (used for testing) '''
        csml_dir = request.environ['paste.config']['app_conf']['csml_dir']
        path = os.path.join(csml_dir, file)
        if os.path.exists(path+'.csml'):
            f = path+'.csml'
        elif os.path.exists(path+'.xml'):
            f = path +'.xml'
        else:
            return 0, '<p>Cannot find CSML file %s</p>' % file
        r=f.read()
        return 1,r     
       


interface=ndgInterface()