def render(self, params): map_ = self.create_map() use_name = (params.version == Version(1, 0)) for coverage in params.coverages: # ReferenceableDatasets are not supported in WCS < 2.0 if issubclass(coverage.real_type, models.ReferenceableDataset): raise NoSuchCoverageException((coverage.identifier,)) data_items = self.data_items_for_coverage(coverage) native_format = self.get_native_format(coverage, data_items) layer = self.layer_for_coverage( coverage, native_format, params.version ) map_.insertLayer(layer) for outputformat in self.get_all_outputformats(not use_name): map_.appendOutputFormat(outputformat) request = ms.create_request(params) raw_result = ms.dispatch(map_, request) result = result_set_from_raw_data(raw_result) return result
def render(self): mapfile_path = get_eoxserver_config().get("wmm", "mapfile") map_ = ms.mapObj(mapfile_path) #TODO: path to map map_.setMetaData("ows_enable_request", "*") map_.setProjection("EPSG:4326") map_.imagecolor.setRGB(0, 0, 0) # set supported CRSs decoder = CRSsConfigReader(get_eoxserver_config()) crss_string = " ".join( map(lambda crs: "EPSG:%d" % crs, decoder.supported_crss_wms) ) map_.setMetaData("ows_srs", crss_string) map_.setMetaData("wms_srs", crss_string) ms_request = ms.create_request(( ("service", "WMS"), ("version", "1.3.0"), ("request", "GetCapabilities"), )) raw_result = map_.dispatch(ms_request) result = result_set_from_raw_data(raw_result) return result, get_content_type(result)
def test_result_set_from_raw(self): result_set = result_set_from_raw_data(self.example_multipart) self.assertTrue(len(result_set) == 2) first = result_set[0] second = result_set[1] if isinstance(first.data, str): first_data = b(first.data) else: first_data = first.data if isinstance(second.data, str): second_data = b(second.data) else: second_data = second.data self.assertEqual(first_data, b"This is the body of the message.") self.assertEqual(first.content_type, b"text/plain") self.assertEqual(first.filename, b"message.msg") self.assertEqual(first.identifier, b"message-part") self.assertEqual( second_data, b"PGh0bWw+CiAgPGhlYWQ+CiAgPC9oZWFkPgogIDxib2R5PgogICAgPHA+VGhpcyBpcyB0aGUgYm9keSBvZiB0aGUgbWVzc2FnZS48L3A+CiAgPC9ib2R5Pgo8L2h0bWw+Cg==" )
def render(self, layer_groups, request_values, request, **options): config = CapabilitiesConfigReader(get_eoxserver_config()) http_service_url = get_http_service_url(request) map_ = ms.Map() map_.setMetaData({ "enable_request": "*", "onlineresource": http_service_url, }, namespace="ows") map_.setMetaData("wms_getfeatureinfo_formatlist", "text/html") map_.setProjection("EPSG:4326") session = self.setup_map(layer_groups, map_, options) # check if the required format is EO O&M frmt = pop_param(request_values, "info_format") use_eoom = False if frmt in ("application/xml", "text/xml"): request_values.append(("info_format", "application/vnd.ogc.gml")) use_eoom = True else: request_values.append(("info_format", frmt)) with session: request = ms.create_request(request_values) raw_result = map_.dispatch(request) result = result_set_from_raw_data(raw_result) if not use_eoom: # just return the response return result, get_content_type(result) else: # do a postprocessing step and get all identifiers in order # to encode them with EO O&M decoder = GMLFeatureDecoder(result[0].data_file.read()) identifiers = decoder.identifiers coverages = models.Coverage.objects.filter( identifier__in=identifiers ) # sort the result with the returned order of coverages lookup_table = dict((c.identifier, c) for c in coverages) coverages = [ lookup_table[identifier] for identifier in identifiers ] # encode the coverages with the EO O&M encoder = WCS20EOXMLEncoder() return [ ResultBuffer( encoder.serialize( encoder.encode_coverage_descriptions(coverages) ), encoder.content_type ) ], encoder.content_type
def render(self, layer_groups, request_values, **options): config = CapabilitiesConfigReader(get_eoxserver_config()) map_ = ms.Map() map_.setMetaData({ "enable_request": "*", "onlineresource": config.http_service_url, }, namespace="ows") map_.setMetaData("wms_getfeatureinfo_formatlist", "text/html") map_.setProjection("EPSG:4326") session = self.setup_map(layer_groups, map_, options) # check if the required format is EO O&M frmt = pop_param(request_values, "info_format") use_eoom = False if frmt in ("application/xml", "text/xml"): request_values.append(("info_format", "application/vnd.ogc.gml")) use_eoom = True else: request_values.append(("info_format", frmt)) with session: request = ms.create_request(request_values) raw_result = map_.dispatch(request) result = result_set_from_raw_data(raw_result) if not use_eoom: # just return the response return result, get_content_type(result) else: # do a postprocessing step and get all identifiers in order # to encode them with EO O&M decoder = GMLFeatureDecoder(result[0].data_file.read()) identifiers = decoder.identifiers coverages = models.Coverage.objects.filter( identifier__in=identifiers ) # sort the result with the returned order of coverages lookup_table = dict((c.identifier, c) for c in coverages) coverages = [ lookup_table[identifier] for identifier in identifiers ] # encode the coverages with the EO O&M encoder = WCS20EOXMLEncoder() return [ ResultBuffer( encoder.serialize( encoder.encode_coverage_descriptions(coverages) ), encoder.content_type ) ], encoder.content_type
def test_result_set_from_raw(self): result_set = result_set_from_raw_data(self.example_multipart) self.assertTrue(len(result_set) == 2) first = result_set[0] second = result_set[1] self.assertEqual(str(first.data), "This is the body of the message.") self.assertEqual(first.content_type, "text/plain") self.assertEqual(first.filename, "message.msg") self.assertEqual(first.identifier, "message-part") self.assertEqual(str(second.data), "PGh0bWw+CiAgPGhlYWQ+CiAgPC9oZWFkPgogIDxib2R5PgogICAgPHA+VGhpcyBpcyB0aGUgYm9keSBvZiB0aGUgbWVzc2FnZS48L3A+CiAgPC9ib2R5Pgo8L2h0bWw+Cg==")
def render(self, layer_groups, request_values, **options): map_ = ms.Map() map_.setMetaData("ows_enable_request", "*") map_.setProjection("EPSG:4326") map_.imagecolor.setRGB(0, 0, 0) session = self.setup_map(layer_groups, map_, options) with session: request = ms.create_request(request_values) raw_result = map_.dispatch(request) result = result_set_from_raw_data(raw_result) return result, get_content_type(result)
def render(self, layer_groups, request_values, **options): map_ = ms.Map() map_.setMetaData("ows_enable_request", "*") map_.setProjection("EPSG:4326") map_.imagecolor.setRGB(0, 0, 0) # set supported CRSs crss = CRSsConfigReader(get_eoxserver_config()) crss_string = " ".join("EPSG:%d"%v for v in crss.supported_crss_wms) map_.setMetaData("ows_srs", crss_string) map_.setMetaData("wms_srs", crss_string) self.check_parameters(map_, request_values) with self.setup_map(layer_groups, map_, options) as session: request = ms.create_request(self._alter_request(request_values)) raw_result = map_.dispatch(request) result = result_set_from_raw_data(raw_result) return result, get_content_type(result)
def render(self, params): map_ = self.create_map() use_name = (params.version == Version(1, 0)) for coverage in params.coverages: # ReferenceableDatasets are not supported in WCS < 2.0 if coverage.grid.is_referenceable: raise NoSuchCoverageException((coverage.identifier,)) data_locations = self.arraydata_locations_for_coverage(coverage) native_format = self.get_native_format(coverage, data_locations) layer = self.layer_for_coverage( coverage, native_format, params.version ) map_.insertLayer(layer) for outputformat in self.get_all_outputformats(not use_name): map_.appendOutputFormat(outputformat) request = ms.create_request(params) raw_result = ms.dispatch(map_, request) result = result_set_from_raw_data(raw_result) # load XML using lxml # find and exclude <metadataLink> nodes if present # re-encode xml_result = etree.fromstring(result[0].data) for elem in xml_result.xpath('//*[local-name() = "metadataLink"]'): elem.getparent().remove(elem) xml_result_data = etree.tostring(xml_result, pretty_print=True, encoding='UTF-8', xml_declaration=True) result[0] = ResultBuffer(xml_result_data, result[0].content_type) return result
def render(self, params): map_ = self.create_map() use_name = (params.version == Version(1, 0)) for coverage in params.coverages: # ReferenceableDatasets are not supported in WCS < 2.0 if issubclass(coverage.real_type, models.ReferenceableDataset): raise NoSuchCoverageException((coverage.identifier, )) data_items = self.data_items_for_coverage(coverage) native_format = self.get_native_format(coverage, data_items) layer = self.layer_for_coverage(coverage, native_format, params.version) map_.insertLayer(layer) for outputformat in self.get_all_outputformats(not use_name): map_.appendOutputFormat(outputformat) request = ms.create_request(params) raw_result = ms.dispatch(map_, request) result = result_set_from_raw_data(raw_result) return result
def render(self): mapfile_path = get_eoxserver_config().get("wmm", "mapfile") map_ = ms.mapObj(mapfile_path) #TODO: path to map map_.setMetaData("ows_enable_request", "*") map_.setProjection("EPSG:4326") map_.imagecolor.setRGB(0, 0, 0) # set supported CRSs decoder = CRSsConfigReader(get_eoxserver_config()) crss_string = " ".join( map(lambda crs: "EPSG:%d" % crs, decoder.supported_crss_wms)) map_.setMetaData("ows_srs", crss_string) map_.setMetaData("wms_srs", crss_string) ms_request = ms.create_request(( ("service", "WMS"), ("version", "1.3.0"), ("request", "GetCapabilities"), )) raw_result = map_.dispatch(ms_request) result = result_set_from_raw_data(raw_result) return result, get_content_type(result)
def render(self, layer_groups, request_values, **options): map_ = ms.Map() map_.setMetaData("ows_enable_request", "*") map_.setProjection("EPSG:4326") map_.imagecolor.setRGB(0, 0, 0) # set supported CRSs decoder = CRSsConfigReader(get_eoxserver_config()) crss_string = " ".join( map(lambda crs: "EPSG:%d" % crs, decoder.supported_crss_wms) ) map_.setMetaData("ows_srs", crss_string) map_.setMetaData("wms_srs", crss_string) self.check_parameters(map_, request_values) session = self.setup_map(layer_groups, map_, options) with session: request = ms.create_request(request_values) raw_result = map_.dispatch(request) result = result_set_from_raw_data(raw_result) return result, get_content_type(result)
def render(self, collections, coverages, request_values): conf = CapabilitiesConfigReader(get_eoxserver_config()) suffixes = self.suffixes map_ = Map() map_.setMetaData({ "enable_request": "*", "onlineresource": conf.http_service_url, "service_onlineresource": conf.onlineresource, "updateSequence": conf.update_sequence, "name": conf.name, "title": conf.title, "abstract": conf.abstract, "accessconstraints": conf.access_constraints, "addresstype": "postal", "address": conf.delivery_point, "stateorprovince": conf.administrative_area, "city": conf.city, "postcode": conf.postal_code, "country": conf.country, "contactelectronicmailaddress": conf.electronic_mail_address, "contactfacsimiletelephone": conf.phone_facsimile, "contactvoicetelephone": conf.phone_voice, "contactperson": conf.individual_name, "contactorganization": conf.provider_name, "contactposition": conf.position_name, "fees": conf.fees, "keywordlist": ",".join(conf.keywords), "srs": " ".join(crss.getSupportedCRS_WCS(format_function=crss.asShortCode)), }, namespace="ows") map_.setProjection("EPSG:4326") map_.setMetaData({ "getmap_formatlist": ",".join([f.mimeType for f in self.get_wms_formats()]), "getfeatureinfo_formatlist": "text/html,application/vnd.ogc.gml,text/plain", }, namespace="wms") map_extent = None for collection in collections: group_name = None # calculate extent and timextent for every collection extent = collection.extent_wgs84 # save overall map extent map_extent = self.join_extents(map_extent, extent) eo_objects = collection.eo_objects.filter( begin_time__isnull=False, end_time__isnull=False ) timeextent = ",".join( map( lambda o: ( "/".join( map(isoformat, o.time_extent) ) + "/PT1S" ), eo_objects ) ) if len(suffixes) > 1: # create group layer, if there is more than one suffix for this # collection group_name = collection.identifier + "_group" group_layer = Layer(group_name) group_layer.setMetaData({ "title": group_name, "abstract": group_name, "extent": " ".join(map(str, extent)), }, namespace="wms") group_layer.setExtent(*extent) # add default style default_class = Class("default") default_style= Style("default") default_class.insertStyle(default_style) group_layer.insertClass(default_class) map_.insertLayer(group_layer) for suffix in suffixes: layer_name = collection.identifier + (suffix or "") layer = Layer(layer_name) if group_name: layer.setMetaData({ "layer_group": "/" + group_name }, namespace="wms") layer.setMetaData({ "title": layer_name, "abstract": layer_name, "extent": " ".join(map(str, extent)), "timeextent": timeextent, }, namespace="wms") map_.insertLayer(layer) for coverage in coverages: extent = coverage.extent_wgs84 # save overall map extent map_extent = self.join_extents(map_extent, extent) layer_name = coverage.identifier layer = Layer(layer_name) layer.setMetaData({ "title": layer_name, "abstract": layer_name, "extent": " ".join(map(str, extent)), }, namespace="wms") layer.setExtent(*extent) map_.insertLayer(layer) # set the map_extent to a reasonable default value # in case there is no coverage or collection if map_extent is None: map_extent = (0.0, 0.0, 1.0, 1.0) map_.setExtent(*map_extent) request = create_request(request_values) raw_result = map_.dispatch(request) result = result_set_from_raw_data(raw_result) return result, get_content_type(result)
def render(self, layers, bbox, crs, size, frmt, time, elevation, styles): if not time: raise RenderException("Missing mandatory 'time' parameter.") try: time = time.value except AttributeError: raise RenderException( "Parameter 'time' must be a slice and not a range.") llbbox = self.get_llbbox(bbox, crs) mapfile_path = get_eoxserver_config().get("wmm", "mapfile") map_ = ms.mapObj(mapfile_path) #TODO: path to map map_.setMetaData("ows_enable_request", "*") map_.setProjection("EPSG:4326") map_.imagecolor.setRGB(0, 0, 0) # set supported CRSs decoder = crss.CRSsConfigReader(get_eoxserver_config()) crss_string = " ".join( map(lambda crs: "EPSG:%d" % crs, decoder.supported_crss_wms)) map_.setMetaData("ows_srs", crss_string) map_.setMetaData("wms_srs", crss_string) datasources = [] datasets = [] for layer_name in layers: layer = map_.getLayerByName(layer_name) if not layer: continue product = layer.metadata.get("wmm_product") filename = self.generate_filename("tif") ds = self.create_dataset(llbbox, time, elevation, size, product, filename) datasets.append(ds) if layer.type == ms.MS_LAYER_LINE: flavor = layer.metadata.get("wmm_flavor") contour_steps = self.get_contour_intervals( flavor, llbbox, size) filename = self.generate_filename("shp") self.generate_contours(ds, contour_steps, filename) layer.connectiontype = ms.MS_OGR layer.connection = filename layer.data, _ = splitext(basename(filename)) datasources.append(filename) ms_request = ms.create_request( (("service", "WMS"), ("version", "1.3.0"), ("request", "GetMap"), ("layers", ",".join(layers)), ("bbox", "%f,%f,%f,%f" % (bbox[1], bbox[0], bbox[3], bbox[2])), ("crs", crs), ("width", str(size[0])), ("height", str(size[1])), ("styles", ",".join(styles)), ("format", frmt))) raw_result = ms.dispatch(map_, ms_request) result = result_set_from_raw_data(raw_result) shp_drv = ogr.GetDriverByName("ESRI Shapefile") # cleanup datasources and datasets for filename in datasources: shp_drv.DeleteDataSource(filename) for ds in datasets: driver = ds.GetDriver() for filename in ds.GetFileList(): os.remove(filename) return result, get_content_type(result)
def render(self, collections, coverages, request_values, request): conf = CapabilitiesConfigReader(get_eoxserver_config()) suffixes = self.suffixes http_service_url = get_http_service_url(request) map_ = Map() map_.setMetaData( { "enable_request": "*", "onlineresource": http_service_url, "service_onlineresource": conf.onlineresource, "updateSequence": conf.update_sequence, "name": conf.name, "title": conf.title, "abstract": conf.abstract, "accessconstraints": conf.access_constraints, "addresstype": "postal", "address": conf.delivery_point, "stateorprovince": conf.administrative_area, "city": conf.city, "postcode": conf.postal_code, "country": conf.country, "contactelectronicmailaddress": conf.electronic_mail_address, "contactfacsimiletelephone": conf.phone_facsimile, "contactvoicetelephone": conf.phone_voice, "contactperson": conf.individual_name, "contactorganization": conf.provider_name, "contactposition": conf.position_name, "fees": conf.fees, "keywordlist": ",".join(conf.keywords), "srs": " ".join( crss.getSupportedCRS_WCS( format_function=crss.asShortCode)), }, namespace="ows") map_.setProjection("EPSG:4326") map_.setMetaData( { "getmap_formatlist": ",".join([f.mimeType for f in self.get_wms_formats()]), "getfeatureinfo_formatlist": "text/html,application/vnd.ogc.gml,text/plain", }, namespace="wms") map_extent = None for collection in collections: group_name = None # calculate extent and timextent for every collection extent = collection.extent_wgs84 # save overall map extent map_extent = self.join_extents(map_extent, extent) eo_objects = collection.eo_objects.filter(begin_time__isnull=False, end_time__isnull=False) timeextent = ",".join( map( lambda o: ("/".join(map(isoformat, o.time_extent)) + "/PT1S"), eo_objects)) if len(suffixes) > 1: # create group layer, if there is more than one suffix for this # collection group_name = collection.identifier + "_group" group_layer = Layer(group_name) group_layer.setMetaData( { "title": group_name, "abstract": group_name, "extent": " ".join(map(str, extent)), }, namespace="wms") minx, miny, maxx, maxy = extent group_layer.setExtent(minx, miny, maxx, maxy) # add default style default_class = Class("default") default_style = Style("default") default_class.insertStyle(default_style) group_layer.insertClass(default_class) map_.insertLayer(group_layer) for suffix in suffixes: layer_name = collection.identifier + (suffix or "") layer = Layer(layer_name) if group_name: layer.setMetaData({"layer_group": "/" + group_name}, namespace="wms") layer.setMetaData( { "title": layer_name, "abstract": layer_name, "extent": " ".join(map(str, extent)), "timeextent": timeextent, }, namespace="wms") map_.insertLayer(layer) for coverage in coverages: extent = coverage.extent_wgs84 minx, miny, maxx, maxy = extent # save overall map extent map_extent = self.join_extents(map_extent, extent) layer_name = coverage.identifier layer = Layer(layer_name) layer.setMetaData( { "title": layer_name, "abstract": layer_name, "extent": " ".join(map(str, extent)), }, namespace="wms") minx, miny, maxx, maxy = extent layer.setExtent(minx, miny, maxx, maxy) map_.insertLayer(layer) # set the map_extent to a reasonable default value # in case there is no coverage or collection if map_extent is None: map_extent = (0.0, 0.0, 1.0, 1.0) map_minx, map_miny, map_maxx, map_maxy = map_extent map_.setExtent(map_minx, map_miny, map_maxx, map_maxy) request = create_request(request_values) raw_result = map_.dispatch(request) result = result_set_from_raw_data(raw_result) return result, get_content_type(result)
def render(self, params): # get coverage related stuff coverage = params.coverage # ReferenceableDataset are not supported in WCS < 2.0 if issubclass(coverage.real_type, models.ReferenceableDataset): raise NoSuchCoverageException((coverage.identifier,)) data_items = self.data_items_for_coverage(coverage) range_type = coverage.range_type bands = list(range_type) subsets = params.subsets if subsets: srid = subsets.srid if srid is not None: if not crss.validateEPSGCode(srid): raise RenderException( "Failed to extract an EPSG code from the CRS URI " "'%s'." % srid, "subset" ) # create and configure map object map_ = self.create_map() # configure outputformat native_format = self.get_native_format(coverage, data_items) if get_format_by_mime(native_format) is None: native_format = "image/tiff" frmt = params.format or native_format if frmt is None: raise RenderException("Format could not be determined", "format") mime_type, frmt = split_format(frmt) imagemode = ms.gdalconst_to_imagemode(bands[0].data_type) time_stamp = datetime.now().strftime("%Y%m%d%H%M%S") basename = "%s_%s" % (coverage.identifier, time_stamp) of = create_outputformat( mime_type, frmt, imagemode, basename, getattr(params, "encoding_params", {}) ) map_.appendOutputFormat(of) map_.setOutputFormat(of) # TODO: use layer factory here layer = self.layer_for_coverage(coverage, native_format, params.version) map_.insertLayer(layer) for connector in self.connectors: if connector.supports(data_items): break else: raise OperationNotSupportedException( "Could not find applicable layer connector.", "coverage" ) try: connector.connect(coverage, data_items, layer) # create request object and dispatch it against the map request = ms.create_request( self.translate_params(params, range_type) ) request.setParameter("format", mime_type) raw_result = ms.dispatch(map_, request) finally: # perform any required layer related cleanup connector.disconnect(coverage, data_items, layer) result_set = result_set_from_raw_data(raw_result) if params.version == Version(2, 0): if getattr(params, "mediatype", None) in ("multipart/mixed", "multipart/related"): encoder = WCS20EOXMLEncoder() is_mosaic = issubclass( coverage.real_type, models.RectifiedStitchedMosaic ) if not is_mosaic: tree = encoder.alter_rectified_dataset( coverage, getattr(params, "http_request", None), etree.parse(result_set[0].data_file).getroot(), subsets.bounding_polygon(coverage) if subsets else None ) else: tree = encoder.alter_rectified_stitched_mosaic( coverage.cast(), getattr(params, "http_request", None), etree.parse(result_set[0].data_file).getroot(), subsets.bounding_polygon(coverage) if subsets else None ) result_set[0] = ResultBuffer( encoder.serialize(tree), encoder.content_type ) # "default" response return result_set
def render(self, layers, bbox, crs, size, frmt, time, elevation, styles): if not time: raise RenderException("Missing mandatory 'time' parameter.") try: time = time.value except AttributeError: raise RenderException( "Parameter 'time' must be a slice and not a range." ) llbbox = self.get_llbbox(bbox, crs) mapfile_path = get_eoxserver_config().get("wmm", "mapfile") map_ = ms.mapObj(mapfile_path) #TODO: path to map map_.setMetaData("ows_enable_request", "*") map_.setProjection("EPSG:4326") map_.imagecolor.setRGB(0, 0, 0) # set supported CRSs decoder = crss.CRSsConfigReader(get_eoxserver_config()) crss_string = " ".join( map(lambda crs: "EPSG:%d" % crs, decoder.supported_crss_wms) ) map_.setMetaData("ows_srs", crss_string) map_.setMetaData("wms_srs", crss_string) datasources = [] datasets = [] for layer_name in layers: layer = map_.getLayerByName(layer_name) if not layer: continue product = layer.metadata.get("wmm_product") filename = self.generate_filename("tif") ds = self.create_dataset( llbbox, time, elevation, size, product, filename ) datasets.append(ds) if layer.type == ms.MS_LAYER_LINE: flavor = layer.metadata.get("wmm_flavor") contour_steps = self.get_contour_intervals( flavor, llbbox, size ) filename = self.generate_filename("shp") self.generate_contours( ds, contour_steps, filename ) layer.connectiontype = ms.MS_OGR layer.connection = filename layer.data, _ = splitext(basename(filename)) datasources.append(filename) ms_request = ms.create_request(( ("service", "WMS"), ("version", "1.3.0"), ("request", "GetMap"), ("layers", ",".join(layers)), ("bbox", "%f,%f,%f,%f" % (bbox[1], bbox[0], bbox[3], bbox[2])), ("crs", crs), ("width", str(size[0])), ("height", str(size[1])), ("styles", ",".join(styles)), ("format", frmt) )) raw_result = ms.dispatch(map_, ms_request) result = result_set_from_raw_data(raw_result) shp_drv = ogr.GetDriverByName("ESRI Shapefile") # cleanup datasources and datasets for filename in datasources: shp_drv.DeleteDataSource(filename) for ds in datasets: driver = ds.GetDriver() for filename in ds.GetFileList(): os.remove(filename) return result, get_content_type(result)
def render(self, params): conf = CapabilitiesConfigReader(get_eoxserver_config()) map_ = Map() map_.setMetaData({ "enable_request": "*", "onlineresource": conf.http_service_url, "service_onlineresource": conf.onlineresource, "updateSequence": conf.update_sequence, "name": conf.name, "title": conf.title, "label": conf.title, "abstract": conf.abstract, "accessconstraints": conf.access_constraints, "addresstype": "", "address": conf.delivery_point, "stateorprovince": conf.administrative_area, "city": conf.city, "postcode": conf.postal_code, "country": conf.country, "contactelectronicmailaddress": conf.electronic_mail_address, "contactfacsimiletelephone": conf.phone_facsimile, "contactvoicetelephone": conf.phone_voice, "contactperson": conf.individual_name, "contactorganization": conf.provider_name, "contactposition": conf.position_name, "role": conf.role, "hoursofservice": conf.hours_of_service, "contactinstructions": conf.contact_instructions, "fees": conf.fees, "keywordlist": ",".join(conf.keywords), "formats": " ".join([f.wcs10name for f in self.get_wcs_formats()]), "srs": " ".join(crss.getSupportedCRS_WCS(format_function=crss.asShortCode)), }, namespace="ows") map_.setProjection("EPSG:4326") for outputformat in self.get_all_outputformats(False): map_.appendOutputFormat(outputformat) for coverage in params.coverages: layer = Layer(coverage.identifier) layer.setProjection(coverage.spatial_reference.proj) extent = coverage.extent size = coverage.size resolution = ((extent[2] - extent[0]) / float(size[0]), (extent[1] - extent[3]) / float(size[1])) layer.setExtent(*extent) layer.setMetaData({ "title": coverage.identifier, "label": coverage.identifier, "extent": "%.10g %.10g %.10g %.10g" % extent, "resolution": "%.10g %.10g" % resolution, "size": "%d %d" % size, "formats": " ".join([f.wcs10name for f in self.get_wcs_formats()]), "srs": " ".join(crss.getSupportedCRS_WCS(format_function=crss.asShortCode)), }, namespace="wcs") map_.insertLayer(layer) request = create_request(params) request.setParameter("version", params.version) raw_result = map_.dispatch(request) result = result_set_from_raw_data(raw_result) return result
def render(self, params): conf = CapabilitiesConfigReader(get_eoxserver_config()) http_service_url = get_http_service_url(params.http_request) map_ = Map() map_.setMetaData({ "enable_request": "*", "onlineresource": http_service_url, "service_onlineresource": conf.onlineresource, "updateSequence": conf.update_sequence, "name": conf.name, "title": conf.title, "label": conf.title, "abstract": conf.abstract, "accessconstraints": conf.access_constraints, "addresstype": "", "address": conf.delivery_point, "stateorprovince": conf.administrative_area, "city": conf.city, "postcode": conf.postal_code, "country": conf.country, "contactelectronicmailaddress": conf.electronic_mail_address, "contactfacsimiletelephone": conf.phone_facsimile, "contactvoicetelephone": conf.phone_voice, "contactperson": conf.individual_name, "contactorganization": conf.provider_name, "contactposition": conf.position_name, "role": conf.role, "hoursofservice": conf.hours_of_service, "contactinstructions": conf.contact_instructions, "fees": conf.fees, "keywordlist": ",".join(conf.keywords), "formats": " ".join([f.wcs10name for f in self.get_wcs_formats()]), "srs": " ".join(crss.getSupportedCRS_WCS(format_function=crss.asShortCode)), }, namespace="ows") map_.setProjection("EPSG:4326") for outputformat in self.get_all_outputformats(False): map_.appendOutputFormat(outputformat) for coverage in params.coverages: layer = Layer(coverage.identifier) layer.setProjection(coverage.spatial_reference.proj) extent = coverage.extent size = coverage.size resolution = ((extent[2] - extent[0]) / float(size[0]), (extent[1] - extent[3]) / float(size[1])) layer.setExtent(*extent) layer.setMetaData({ "title": coverage.identifier, "label": coverage.identifier, "extent": "%.10g %.10g %.10g %.10g" % extent, "resolution": "%.10g %.10g" % resolution, "size": "%d %d" % size, "formats": " ".join([f.wcs10name for f in self.get_wcs_formats()]), "srs": " ".join(crss.getSupportedCRS_WCS(format_function=crss.asShortCode)), }, namespace="wcs") map_.insertLayer(layer) request = create_request(params) request.setParameter("version", params.version) raw_result = map_.dispatch(request) result = result_set_from_raw_data(raw_result) return result
def render(self, params): # get coverage related stuff coverage = params.coverage # ReferenceableDataset are not supported in WCS < 2.0 if issubclass(coverage.real_type, models.ReferenceableDataset): raise NoSuchCoverageException((coverage.identifier, )) data_items = self.data_items_for_coverage(coverage) range_type = coverage.range_type bands = list(range_type) subsets = params.subsets if subsets: subsets.srid # this automatically checks the validity # create and configure map object map_ = self.create_map() # configure outputformat native_format = self.get_native_format(coverage, data_items) if get_format_by_mime(native_format) is None: native_format = "image/tiff" frmt = params.format or native_format if frmt is None: raise RenderException("Format could not be determined", "format") mime_type, frmt = split_format(frmt) imagemode = ms.gdalconst_to_imagemode(bands[0].data_type) time_stamp = datetime.now().strftime("%Y%m%d%H%M%S") basename = "%s_%s" % (coverage.identifier, time_stamp) of = create_outputformat(mime_type, frmt, imagemode, basename, getattr(params, "encoding_params", {})) map_.appendOutputFormat(of) map_.setOutputFormat(of) # TODO: use layer factory here layer = self.layer_for_coverage(coverage, native_format, params.version) map_.insertLayer(layer) for connector in self.connectors: if connector.supports(data_items): break else: raise OperationNotSupportedException( "Could not find applicable layer connector.", "coverage") try: connector.connect(coverage, data_items, layer, {}) # create request object and dispatch it against the map request = ms.create_request( self.translate_params(params, range_type)) request.setParameter("format", mime_type) raw_result = ms.dispatch(map_, request) finally: # perform any required layer related cleanup connector.disconnect(coverage, data_items, layer, {}) result_set = result_set_from_raw_data(raw_result) if params.version == Version(2, 0): if getattr(params, "mediatype", None) in ("multipart/mixed", "multipart/related"): encoder = WCS20EOXMLEncoder() is_mosaic = issubclass(coverage.real_type, models.RectifiedStitchedMosaic) if not is_mosaic: tree = encoder.alter_rectified_dataset( coverage, getattr(params, "http_request", None), etree.parse(result_set[0].data_file).getroot(), subsets.bounding_polygon(coverage) if subsets else None) else: tree = encoder.alter_rectified_stitched_mosaic( coverage.cast(), getattr(params, "http_request", None), etree.parse(result_set[0].data_file).getroot(), subsets.bounding_polygon(coverage) if subsets else None) result_set[0] = ResultBuffer(encoder.serialize(tree), encoder.content_type) # "default" response return result_set
def render(self, params): # get coverage related stuff coverage = params.coverage # ReferenceableDataset are not supported in WCS < 2.0 if params.coverage.grid.is_referenceable and params.version: raise NoSuchCoverageException((coverage.identifier, )) data_locations = self.arraydata_locations_for_coverage(coverage) range_type = coverage.range_type bands = list(range_type) subsets = params.subsets if subsets: subsets.srid # this automatically checks the validity # create and configure map object map_ = self.create_map() env = {} for data_location in data_locations: env.update(data_location.env) gdal.set_env(env, False) # configure outputformat native_format = self.get_native_format(coverage, data_locations) if native_format and get_format_by_mime(native_format) is None: native_format = "image/tiff" frmt = params.format or native_format if frmt is None: raise RenderException("Format could not be determined", "format") mime_type, frmt = split_format(frmt) imagemode = ms.gdalconst_to_imagemode(bands[0].data_type) time_stamp = datetime.now().strftime("%Y%m%d%H%M%S") basename = "%s_%s" % (coverage.identifier, time_stamp) of = create_outputformat(mime_type, frmt, imagemode, basename, getattr(params, "encoding_params", {})) map_.appendOutputFormat(of) map_.setOutputFormat(of) # TODO: use layer factory here layer = self.layer_for_coverage(coverage, native_format, params.version) map_.insertLayer(layer) connector = get_connector_by_test(coverage, data_locations) if not connector: raise OperationNotSupportedException( "Could not find applicable layer connector.", "coverage") try: connector.connect(coverage, data_locations, layer, {}) # create request object and dispatch it against the map request = ms.create_request( self.translate_params(params, range_type)) request.setParameter("format", mime_type) raw_result = ms.dispatch(map_, request) finally: # perform any required layer related cleanup connector.disconnect(coverage, data_locations, layer, {}) result_set = result_set_from_raw_data(raw_result) if params.version == Version(2, 0): mediatype = getattr(params, "mediatype", None) if mediatype in ("multipart/mixed", "multipart/related"): with vsi.TemporaryVSIFile.from_buffer(result_set[1].data) as f: ds = gdal.Open(f.name) grid = objects.Grid.from_gdal_dataset(ds) # get the output CRS definition crs = params.outputcrs or subsets.crs or 'imageCRS' if crs == 'imageCRS': crs = coverage.grid.coordinate_reference_system grid._coordinate_reference_system = crs origin = objects.Origin.from_gdal_dataset(ds) size = [ds.RasterXSize, ds.RasterYSize] range_type = coverage.range_type if params.rangesubset: range_type = range_type.subset(params.rangesubset) coverage._grid = grid coverage._origin = origin coverage._size = size coverage._range_type = range_type if isinstance(result_set[1].filename, binary_type): file_name = result_set[1].filename.decode() else: file_name = result_set[1].filename reference = 'cid:coverage/%s' % file_name encoder = WCS20EOXMLEncoder() if not isinstance(coverage, objects.Mosaic): tree = encoder.encode_rectified_dataset( coverage, getattr(params, "http_request", None), reference, mime_type, subsets.bounding_polygon(coverage) if subsets else None) else: tree = encoder.encode_rectified_stitched_mosaic( coverage, getattr(params, "http_request", None), reference, mime_type, subsets.bounding_polygon(coverage) if subsets else None) result_set[0] = ResultBuffer(encoder.serialize(tree), encoder.content_type) # "default" response return result_set
def dispatch(map_, request): """ Wraps the ``OWSDispatch`` method. Perfoms all necessary steps for a further handling of the result. """ logger.debug("MapServer: Installing stdout to buffer.") msIO_installStdoutToBuffer() # write the map if debug is enabled if logger.isEnabledFor(logging.DEBUG): fd, filename = tempfile.mkstemp(text=True) try: with os.fdopen(fd) as f: map_.save(filename) logger.debug(f.read()) finally: os.remove(filename) try: logger.debug("MapServer: Dispatching.") ts = time.time() # Execute the OWS request by mapserver, obtain the status in # dispatch_status (0 is OK) status = map_.OWSDispatch(request) te = time.time() logger.debug("MapServer: Dispatch took %f seconds." % (te - ts)) except Exception as e: raise MapServerException(str(e), "NoApplicableCode") raw_bytes = msIO_getStdoutBufferBytes() # check whether an error occurred if status != 0: # First try to get the error message through the error object obj = msGetErrorObj() if obj and obj.message: raise MapServerException(obj.message, obj.code) try: # try to parse the output as XML result = result_set_from_raw_data(raw_bytes) tree = etree.fromstring(result[0].data) exception_elem = tree.xpath( "*[local-name() = 'Exception']|*[local-name() = 'ServiceException']" )[0] locator = exception_elem.attrib.get("locator") code = exception_elem.attrib.get("exceptionCode") message = exception_elem[0].text raise MapServerException(message, locator, code) except (etree.XMLSyntaxError, IndexError, KeyError): pass # Fallback: raise arbitrary error raise MapServerException("Unexpected Error.", "NoApplicableCode") logger.debug("MapServer: Performing MapServer cleanup.") # Workaround for MapServer issue #4369 if msversion < 60004 or (msversion < 60200 and msversion >= 60100): msCleanup() else: msIO_resetHandlers() return raw_bytes
def render(self, params): conf = CapabilitiesConfigReader(get_eoxserver_config()) http_service_url = get_http_service_url(params.http_request) map_ = Map() map_.setMetaData( { "enable_request": "*", "onlineresource": http_service_url, "service_onlineresource": conf.onlineresource, "updateSequence": conf.update_sequence, "name": conf.name, "title": conf.title, "label": conf.title, "abstract": conf.abstract, "accessconstraints": conf.access_constraints, "addresstype": "", "address": conf.delivery_point, "stateorprovince": conf.administrative_area, "city": conf.city, "postcode": conf.postal_code, "country": conf.country, "contactelectronicmailaddress": conf.electronic_mail_address, "contactfacsimiletelephone": conf.phone_facsimile, "contactvoicetelephone": conf.phone_voice, "contactperson": conf.individual_name, "contactorganization": conf.provider_name, "contactposition": conf.position_name, "role": conf.role, "hoursofservice": conf.hours_of_service, "contactinstructions": conf.contact_instructions, "fees": conf.fees, "keywordlist": ",".join(conf.keywords), "formats": " ".join([f.wcs10name for f in self.get_wcs_formats()]), "srs": " ".join( crss.getSupportedCRS_WCS( format_function=crss.asShortCode)), }, namespace="ows") map_.setProjection("EPSG:4326") for outputformat in self.get_all_outputformats(False): map_.appendOutputFormat(outputformat) for coverage in params.coverages: layer = Layer(coverage.identifier) render_coverage = Coverage.from_model(coverage) layer.setProjection(render_coverage.grid.spatial_reference.proj) extent = render_coverage.extent size = render_coverage.size resolution = ((extent[2] - extent[0]) / float(size[0]), (extent[1] - extent[3]) / float(size[1])) layer.setExtent(*extent) layer.setMetaData( { "title": coverage.identifier, "label": coverage.identifier, "extent": "%.10g %.10g %.10g %.10g" % extent, "resolution": "%.10g %.10g" % resolution, "size": "%d %d" % size, "formats": " ".join([f.wcs10name for f in self.get_wcs_formats()]), "srs": " ".join( crss.getSupportedCRS_WCS( format_function=crss.asShortCode)), }, namespace="wcs") map_.insertLayer(layer) request = create_request(params) request.setParameter("version", params.version) raw_result = map_.dispatch(request) result = result_set_from_raw_data(raw_result) xml_result = etree.fromstring(result[0].data) for elem in xml_result.xpath('//*[local-name() = "metadataLink"]'): elem.getparent().remove(elem) # Add CQL parameter to GetCapabilities operation for elem in xml_result.xpath( '//*[local-name() = "Operation"][@name = "GetCapabilities"]'): ows = elem.nsmap['ows'] param = etree.SubElement(elem, '{%s}Parameter' % ows) param.attrib['name'] = 'cql' etree.SubElement(param, '{%s}AnyValue' % ows) xml_result_data = etree.tostring(xml_result, pretty_print=True, encoding='UTF-8', xml_declaration=True) result[0] = ResultBuffer(xml_result_data, result[0].content_type) return result