Merge branch 'master' of git+ssh://git.ccss.cz/hsrs/owsproxy

OWS.py

@@ -41,9 +41,8 @@ class OWS:
         if qstring:
             self.qstring = qstring
 
-        configFiles = [
-                os.path.join(os.path.dirname(__file__),"config.cfg")
-                ]
+        configFiles = [ os.path.join(os.path.dirname(__file__),"config.cfg") ]
+
         if sys.platform == "win32":
             pass # TODO Default conf. file on windows platform
         elif sys.platform == "linux2":
@@ -63,14 +62,26 @@ class OWS:
         self.parsedUrl = urlparse.urlparse(self.url)
         if self.service == "WFS":
             from owslib.wfs import WebFeatureService
-            self.capabilities = WebFeatureService(url=self.url,version="1.1.0")
+            self.capabilities = WebFeatureService(url=self.url,version="1.0.0")
             logging.debug("OWS Capabilities: %s",self.capabilities)
         elif self.service == "WCS":
             from owslib.wcs import WebCoverageService
             self.capabilities = WebCoverageService(url=self.url,version="1.0.0")
 
     def getParams(self):
-        return urlparse.parse_qs(self.qstring)
+        params =  urlparse.parse_qs(self.qstring)
+
+        if not "VERSION" in params.keys():
+            params["VERSION"] = params.pop("version")
+        if not "LAYERS" in params.keys():
+            params["LAYERS"] = params.pop("layers")
+        if not "FORMAT" in params.keys():
+            params["FORMAT"] = params.pop("format")
+        if not "STYLES" in params.keys():
+            params["STYLES"] = params.pop("styles")
+        if not "TRANSPARENT" in params.keys():
+            params["TRANSPARENT"] = params.pop("transparent")
+        return params
 
     def getOnlineResource(self,onlineresource,mapfilename=None):
         o = urlparse.urlparse(onlineresource)
@@ -141,7 +152,6 @@ class OWS:
 
         # mapobj.getLayerByName(request.getValueByName("layers")).metadata.get("wfs_filter")
         # here is still fine, but it fails on dispatch:
-
         res = mapobj.OWSDispatch(request)
         if mapscript.MS_DONE == res:
             raise OWSExceptions.NoValidRequest("No valid OWS Request")
@@ -220,7 +230,7 @@ class OWS:
         return layerurl
 
     def createLayerDefinitionFile(self, name,
-            templatefile,time=None,target=None):
+            templatefile,time="",target=None):
 
             layerurl = self.getLayerUrl()
             defFileName = None
@@ -230,12 +240,12 @@ class OWS:
                 defFileName = os.path.join(self.cachedir,'%s.%s'%(name,self.service.lower()))
             if time:
                 time = "<DefaultTime>"+time+"</DefaultTime>"
-            else:
-                time = ""
 
             open(defFileName,'w').write(
                     Template(open(templatefile).read()).substitute( 
-                            dict(url= layerurl, name=name,time=time)))
+                            dict(url= layerurl,
+                                name=name,time=time,extras="&BAND=1,2,3")))
+                            # FIXME always takes band 1,2,3 ^^
 
             logging.debug("Created %s layer definition file" % defFileName)
 
@@ -301,7 +311,7 @@ class OWS:
         layerobj.setMetaData("wfs_filter",msFilter)
 
 
-def getService():
+def getService(configFile=None):
 
     qstring = os.environ["QUERY_STRING"]
     params = urlparse.parse_qs(qstring)
@@ -325,10 +335,13 @@ def getService():
         if params["owsService"][0].lower() == "wfs":
             from wfs import WFS
             logging.debug("OWS.py::getService()::owsUrl: '%s'" % owsUrl)
-            return WFS(owsUrl,qstring)
+            return WFS(owsUrl,qstring,configFile = configFile )
         elif params["owsService"][0].lower() == "wcs":
             from wcs import WCS
-            return WCS(owsUrl,qstring)
+            return WCS(owsUrl,qstring, configFile = configFile)
+        elif params["owsService"][0].lower() == "wms":
+            from wms import WMS
+            return WMS(owsUrl,qstring, configFile = configFile)
     else:
         raise OWSExceptions.MissingParameterValue("""owsUrl or owsService""")
     

__init__.py

@@ -1,22 +1 @@
-import urllib
-import tempfile
-import ConfigParser 
-
-DEFAULT_CONFIGS={}
-
-class OWSViewer:
-    workingDir = None
-    config = None
-
-    def __init__(self,configFiles):
-        config = ConfigParser.ConfigParser()
-        config.read(configFiles)
-
-        self.workingDir = tempfile.mkdtemp(prefix="owsviewer",dir=config.get("server","tempdir",vars=DEFAULT_CONFIGS))
-        
-    def getImage(self,url,targetFormat="image/png"):
-        pass
-
-        
-
-
+__all__ = [ "OWS","wcs","wfs","wms","OWSException"]

owsproxy.cgi → owsproxy.cgi-template

@@ -3,17 +3,17 @@
 #debugger
 #import rpdb2; rpdb2.start_embedded_debugger("lucerna")
 
+# import sys
+# sys.path.append("/path/to/owsproxy/")
+
 import OWS
 import logging
 import OWSExceptions
 
-#debugger
-#import rpdb2; rpdb2.start_embedded_debugger("lucerna")
-
 logging.basicConfig(level=logging.DEBUG)
 
 try:
-    service = OWS.getService()
+    service = OWS.getService(configFile = "config.cfg")
     service.dispatch()
 except OWSExceptions.OWSException,e:
     e.toXml()

wcs/__init__.py

@@ -17,8 +17,8 @@ class WCS(OWS):
     parser = None
     version = None
 
-    def __init__(self,url=None,qstring=None,configFiles=None):
-        OWS.__init__(self,url,qstring)
+    def __init__(self,url=None,qstring=None,configFile=None):
+        OWS.__init__(self,url,qstring,configFile)
 
     def makeMap(self,mapfilename=None):
         """Create mapscript.mapObj"""
@@ -44,6 +44,7 @@ class WCS(OWS):
 
             # create the layer
             ds = gdal.Open(layerDefFile)
+
             try:
                 lyrobj = mapscript.layerObj(mapobj)
                 lyrobj.name = name
@@ -55,6 +56,7 @@ class WCS(OWS):
                 #    lyrobj.setMetaData("ows_abstract",  layer["{%s}%s" % (self.owsns11,"Abstract")].text)
                 lyrobj.setMetaData("wms_srs",self.config.get("MapServer","srs"))
                 extent = None
+                # processing
                 if layer.crsOptions:
                     lyrobj.setProjection(layer.crsOptions[0])
                     extent = self.getLayerExtent(layer,layer.crsOptions[0])

wcs/templates/wcs.xml

@@ -2,5 +2,6 @@
   <ServiceURL>$url</ServiceURL>
   <CoverageName>$name</CoverageName>
   <Timeout>5000</Timeout>
+  <GetCoverageExtras>$extras</GetCoverageExtras>
   $time
 </WCS_GDAL>

wfs/__init__.py

@@ -20,8 +20,8 @@ class WFS(OWS):
     layerDefFile = None
     lyrobj = None
 
-    def __init__(self,url=None,qstring=None,configFiles=None):
-        OWS.__init__(self,url,qstring)
+    def __init__(self,url=None,qstring=None,configFile=None):
+        OWS.__init__(self,url,qstring,configFile)
 
     def makeMap(self,mapfilename=None):
 

wms/__init__.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+# coding=utf-8
+
+from OWS import OWS
+import mapscript
+from osgeo import gdal
+from osgeo import ogr
+from osgeo import osr
+import os
+import logging
+import re
+
+class WMS(OWS):
+
+    service = "WMS"
+    request = '' # GetCapabilies, ...
+    parser = None
+    version = None
+
+    def __init__(self,url=None,qstring=None,configFile=None):
+        OWS.__init__(self,url,qstring,configFile)
+
+    def makeMap(self,mapfilename=None):
+        """Create mapscript.mapObj"""
+
+        mapobj = self.getMapObj(mapfilename)
+
+
+        params = self.getParams()
+
+
+        self.version = params["VERSION"][0]
+
+        # create layer
+        logging.debug("Creating layer %s" % params["LAYERS"][0]) 
+        lyrobj = mapscript.layerObj(mapobj)
+        lyrobj.name = params["LAYERS"][0]
+        lyrobj.type = mapscript.MS_LAYER_RASTER
+        lyrobj.connection = params["OWSURL"][0]
+        lyrobj.status = mapscript.MS_DEFAULT
+        lyrobj.setConnectionType(mapscript.MS_WMS,None)
+        lyrobj.setMetaData("wms_srs",params["FROMCRS"][0])
+        lyrobj.setMetaData("wms_name",params["LAYERS"][0])
+        lyrobj.setMetaData("wms_server_version",params["VERSION"][0])
+        lyrobj.setMetaData("wms_exceptions_format",params["EXCEPTIONS"][0])
+        lyrobj.setMetaData("wms_formatlist",params["FORMAT"][0])
+        lyrobj.setMetaData("wms_style",params["STYLES"][0])
+        lyrobj.setMetaData("wms_transparent",params["TRANSPARENT"][0])
+        lyrobj.setMetaData("gml_include_items","all")
+        lyrobj.template = "foo"
+
+        self.saveMapfile(mapobj,mapfilename)
+        return mapobj
+
+    def getTime(self,ds,lyrobj):
+        """Generate time index file, set approripate layer metadata"""
+
+        # make time index file
+        drv = ogr.GetDriverByName("ESRI Shapefile")
+        tindex = '%s.%s.%s'%(lyrobj.name,self.service.lower(),"tindex")
+        logging.info("Creating time index definition file %s.shp in %s" % (tindex,self.cachedir))
+        tds = drv.CreateDataSource(os.path.join(self.cachedir,tindex))
+        lyr = tds.CreateLayer(tindex)
+        tile_field = ogr.FieldDefn("location", ogr.OFTString )
+        tile_field.SetWidth( 256 )
+        lyr.CreateField(tile_field)
+
+        time_field = ogr.FieldDefn("time", ogr.OFTString )
+        time_field.SetWidth( 256 )
+        lyr.CreateField(time_field)
+
+        timeMetadata = ""
+        for sds in ds.GetSubDatasets():
+            if sds[0].find('time') > -1:
+                # crate mapfile metadata
+                sdsname = sds[0].split(",")[0]
+                sdsvalue = re.findall(r'".*"',sdsname)[0].replace('"',"")
+                timeMetadata = timeMetadata+","+sdsvalue
+
+                # create OGR tindex vector feature
+                feature = ogr.Feature(lyr.GetLayerDefn())
+
+                # feature geometry
+                geotransform = ds.GetGeoTransform()
+                w = ds.RasterXSize
+                h = ds.RasterYSize
+                bbox = {"minx":geotransform[0],"miny":geotransform[5]*h+geotransform[3],"maxx":geotransform[1]*w+geotransform[0],"maxy":geotransform[3]}
+                poly = ogr.CreateGeometryFromWkt("""POLYGON((%(minx)s %(miny)s, %(maxx)s %(miny)s, %(maxx)s %(maxy)s, %(minx)s %(maxy)s, %(minx)s %(miny)s))""" % bbox)
+                feature.SetGeometry(poly)
+
+                # set time attribute
+                feature.SetField("time","%s" % (sdsvalue))
+                feature.SetField("location",sds[0])
+                lyr.CreateFeature(feature)
+
+        if timeMetadata.endswith(","):
+            timeMetadata = re.sub(r",$","",timeMetadata)
+        if timeMetadata.startswith(","):
+            timeMetadata = re.sub(r"^,","",timeMetadata)
+
+        if timeMetadata:
+            logging.info("Setting %s to %s layer" % (timeMetadata, lyrobj.name))
+
+            lyrobj.setMetaData("wms_timeextent", timeMetadata) 
+            lyrobj.setMetaData("wms_timeitem", "time") 
+
+            # NOTE: lyrobj.data will not be the wcs definition file
+            # anymore, BUT the time index shapefile
+            logging.info("Setting layer data to %s" %
+                    (os.path.join(tindex,tindex+".shp")))
+            lyrobj.data = None
+            lyrobj.tileindex = os.path.join(tindex,tindex+".shp")
+        else:
+            logging.info("No time subset found")