source: TI05-delivery/ows_framework/trunk/ows_server/ows_server/lib/csml_util.py @ 2682

# 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
"""
csml access routines.

@author: Stephen Pascoe
"""
from pylons import Response, c, g, cache, request, session
import csml, cdms
import os, string
import zipfile
import tempfile
from ows_server.models import ndgObject,ndgRetrieve

def get_csml_doc(fileoruri):
        """
        Gets a csml document from file or exist when passed a file name or uri         
               
        Note, access control is not implemented on file access, only on exist access.
        
        """
        if string.find(fileoruri,'__NDG-A0__') == -1:
            #it's a local file not an identifier
            file=fileoruri
            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:
                raise ValueError("Cannot find CSML file %s" % file)
            
            d = csml.parser.Dataset()
            d.parse(f)
        
        else:
            #it's an NDG identifier, get the document from exist.
            uri=fileoruri
            uriN=ndgObject.ndgObject(uri)
            cf=request.environ['ndgConfig']
            requestor=request.environ['REMOTE_ADDR']
            if 'ndgSec' in session:
                securityTokens=session['ndgSec']
            else: securityTokens=None
            status,x=ndgRetrieve.ndgRetrieve(
                    uriN,cf,requestor=requestor,
                    securityTokens=securityTokens)
            d=csml.parser.Dataset()
            d.parseElemTree(x.tree)                         
        return d

#this version of get_csml_doc can be deleted now if no problems found with new version:
#def get_csml_doc(file):
    #"""
    #A trivial document retrieval function.

    #This could be replaced with a proper csml server object that supports
    #multiple stores (filesystem, exist) and cache's the results for
    #performance.

    #"""
    #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:
        #raise ValueError("Cannot find CSML file %s" % file)
    
    #d = csml.parser.Dataset()
    #d.parse(f)
      
    #return d

        
def extractToNetCDF(feature, sel, publish=False):
    """
       performs the CSML subset and returns a filename of the netcdf extract
       publish flag is used to indicate that the netcdf file should be made available to the webserver (for asynchronous delivery)
    """

    if publish:
        #if publishing to download directory is required, do so and return publishable file name
        #used e.g. in WCS when "STORE = true"
        extract_dir=request.environ['paste.config']['app_conf']['publish_dir']
    else:
        extract_dir = request.environ['paste.config']['app_conf']['tmp_dir']
    
    # Subset the feature
    (fd, filename) = tempfile.mkstemp('.nc', 'csml_wxs_', extract_dir); os.close(fd)
    feature.subsetToGridSeries(ncname=os.path.basename(filename), outputdir=os.path.dirname(filename) ,**sel)

    return filename
        
def extractToVariable(feature, sel):
    """
      calls extractToNetCDF to get the netcdf file, then returns a cdms variable from this file
    """
    #call extractToNetCDF:
    filename = extractToNetCDF(feature, sel)
    d = cdms.open(filename)
    var = d(feature.name.CONTENT, squeeze=1)
    # Work around for CSML bug
    #var = d(feature.name.CONTENT, longitude=sel['longitude'], latitude=sel['latitude'],
    #        squeeze=1)

    d.close()
    #os.remove(filename)
    return var
        
class CsmlBundle(csml.API.csmlContainer.Container):
    """
    A quick stab at bundling CSML.

    """
    def __init__(self, context, **kwargs):
        """
        @param context: A directory path to store the CSML and NetCDF
        """
        self.context = context
        kwargs['csmlpath'] = os.path.join(context, 'container.xml')
        super(CsmlBundle, self).__init__(**kwargs)

    def add(self, fpd):
        """
        Overrides the file storage descriptor so that the CSML points relative to the
        bundle context

        @warning: THIS IS A HACK!

        """
        (feature, path, desc) = fpd
        if os.path.dirname(path) != self.context:
            raise ValueError, "Extract not in bundle context"
        desc.fileName.CONTENT = os.path.basename(path)

        return super(CsmlBundle, self).add(fpd)

    def join(self, *p):
        return os.path.join(self.context, *p)

    def makeBundle(self, file, bundleName=None):
        """
        Writes the bundle to a zipfile.

        @param file: path or file-like object (see zipfile docs)

        """
        if bundleName is None:
            bundleName = os.path.splitext(os.path.basename(file))[0]
        
        zf = zipfile.ZipFile(file, 'w')
        self.getContents()
        for f in self.containerContents:
            zf.write(f, os.path.join(bundleName, os.path.basename(f)))
        zf.close()

        return file