def layer(self, tile_request):
if self.use_dimension_layers:
internal_layer = self._internal_dimension_layer(tile_request)
else:
internal_layer = self._internal_layer(tile_request)
if internal_layer is None:
raise RequestError('unknown layer: ' + tile_request.layer,
request=tile_request)
return internal_layer
def validate_styles(self):
if 'styles' in self.params:
styles = self.params['styles']
if not set(styles.split(',')).issubset(
set(['default', '', 'inspire_common:DEFAULT'])):
raise RequestError('unsupported styles: ' +
self.params['styles'],
code='StyleNotDefined',
request=self)
def check_map_request(self, request):
if self.max_output_pixels and \
(request.params.size[0] * request.params.size[1]) > self.max_output_pixels:
request.prevent_image_exception = True
raise RequestError("image size too large", request=request)
self.validate_layers(request)
request.validate_format(self.image_formats)
request.validate_srs(self.srs)
def check_request_dimensions(self, tile_layer, request):
# check that unknown dimension for this layer are set to default
if request.dimensions:
for dimension, value in iteritems(request.dimensions):
dimension = dimension.lower()
if dimension not in tile_layer.dimensions and value != 'default':
raise RequestError('unknown dimension: ' + str(dimension),
code='InvalidParameterValue',
request=request)
def authorized_tile_layers(self, env):
if 'mapproxy.authorize' in env:
result = env['mapproxy.authorize']('tms', [l for l in self.layers],
environ=env)
if result['authorized'] == 'unauthenticated':
raise RequestError('unauthorized', status=401)
if result['authorized'] == 'full':
return self.layers
if result['authorized'] == 'none':
raise RequestError('forbidden', status=403)
allowed_layers = odict()
for layer in self.layers.itervalues():
if result['layers'].get(layer.name, {}).get('tile',
False) == True:
allowed_layers[layer.name] = layer
return allowed_layers
else:
return self.layers
def authorized_demo(self, environ):
if 'mapproxy.authorize' in environ:
result = environ['mapproxy.authorize']('demo', [], environ=environ)
if result['authorized'] == 'unauthenticated':
raise RequestError('unauthorized', status=401)
if result['authorized'] == 'full':
return True
return False
return True
def _render_layer(self, layer):
try:
layer_img = layer.get_map(self.query)
if layer_img is not None:
layer_img.opacity = layer.opacity
return layer, layer_img
except SourceError:
raise
except MapBBOXError:
raise RequestError('Request too large or invalid BBOX.', request=self.request)
except MapError as e:
raise RequestError('Invalid request: %s' % e.args[0], request=self.request)
except TransformationError:
raise RequestError('Could not transform BBOX: Invalid result.',
request=self.request)
except BlankImage:
return layer, None
def test_render(self):
req = self.mock(WMSMapRequest)
ex_handler = self.mock(ExceptionHandler)
req_ex = RequestError('the exception message', request=req)
self.expect(req.exception_handler).result(ex_handler)
self.expect(ex_handler.render(req_ex))
self.replay()
req_ex.render()
def wmts_request(req, validate=True):
req_type = _parse_request_type(req)
req_class = request_mapping.get(req_type, None)
if req_class is None:
# use map request to get an exception handler for the requested version
dummy_req = request_mapping['tile'](param=req.args, url=req.base_url,
validate=False)
raise RequestError("unknown WMTS request type '%s'" % req_type, request=dummy_req)
return req_class(param=req.args, url=req.base_url, validate=True, http=req)
def _render_raise_exceptions(self, async_pool, render_layers,
layer_merger):
# call _render_layer, raise all exceptions
try:
for layer, layer_img in async_pool.imap(self._render_layer,
render_layers):
if layer_img is not None:
layer_merger.add(layer_img, layer=layer)
except SourceError, ex:
raise RequestError(ex.args[0], request=self.request)
def authorize_tile_layer(self, tile_layer, request):
if 'mapproxy.authorize' in request.http.environ:
query_extent = tile_layer.grid.srs.srs_code, tile_layer.tile_bbox(request)
result = request.http.environ['mapproxy.authorize']('wmts', [tile_layer.name],
query_extent=query_extent, environ=request.http.environ)
if result['authorized'] == 'unauthenticated':
raise RequestError('unauthorized', status=401)
if result['authorized'] == 'full':
return
if result['authorized'] == 'partial':
if result['layers'].get(tile_layer.name, {}).get('tile', False) == True:
limited_to = result['layers'][tile_layer.name].get('limited_to')
if not limited_to:
limited_to = result.get('limited_to')
if limited_to:
return load_limited_to(limited_to)
else:
return None
raise RequestError('forbidden', status=403)
def check_request(self, request, info_formats=None):
request.make_request()
if request.layer not in self.layers:
raise RequestError('unknown layer: ' + str(request.layer),
code='InvalidParameterValue', request=request)
if request.tilematrixset not in self.layers[request.layer]:
raise RequestError('unknown tilematrixset: ' + str(request.tilematrixset),
code='InvalidParameterValue', request=request)
if info_formats is not None:
if '/' in request.infoformat: # mimetype
if request.infoformat not in self.info_formats.values():
raise RequestError('unknown infoformat: ' + str(request.infoformat),
code='InvalidParameterValue', request=request)
else: # RESTful suffix
if request.infoformat not in self.info_formats:
raise RequestError('unknown infoformat: ' + str(request.infoformat),
code='InvalidParameterValue', request=request)
# set mimetype as infoformat
request.infoformat = self.info_formats[request.infoformat]
def authorized_tile_layers(self, env):
if 'mapproxy.authorize' in env:
result = env['mapproxy.authorize']('wmts',
[l for l in self.layers],
query_extent=None,
environ=env)
if result['authorized'] == 'unauthenticated':
raise RequestError('unauthorized', status=401)
if result['authorized'] == 'full':
return self.layers.values()
if result['authorized'] == 'none':
raise RequestError('forbidden', status=403)
allowed_layers = []
for layer in itervalues(self.layers):
if result['layers'].get(layer.name, {}).get('tile',
False) == True:
allowed_layers.append(layer)
return allowed_layers
else:
return self.layers.values()
def layer(self, tile_request):
if self.use_dimension_layers:
internal_layer = self._internal_dimension_layer(tile_request)
else:
internal_layer = self._internal_layer(tile_request)
if internal_layer is None:
raise RequestError('unknown layer: ' + tile_request.layer,
request=tile_request)
self.authorize_tile_layer(internal_layer.name,
tile_request.http.environ)
return internal_layer
def render(self, tile_request, use_profiles=False):
if tile_request.format != self.format:
raise RequestError(
'invalid format (%s). this tile set only supports (%s)' %
(tile_request.format, self.format),
request=tile_request,
code='InvalidParameterValue')
tile_coord = self._internal_tile_coord(tile_request,
use_profiles=use_profiles)
try:
with self.tile_manager.session():
tile = self.tile_manager.load_tile_coord(tile_coord,
with_metadata=True)
if tile.source is None:
return self.empty_response()
format = None if self._mixed_format else tile_request.format
return TileResponse(tile, format=format)
except SourceError, e:
raise RequestError(e.args[0], request=tile_request, internal=True)
def authorized_capability_layers(self, env):
if 'mapproxy.authorize' in env:
result = env['mapproxy.authorize']('wms.capabilities',
self.layers.keys(),
environ=env)
if result['authorized'] == 'unauthenticated':
raise RequestError('unauthorized', status=401)
if result['authorized'] == 'full':
return self.root_layer
if result['authorized'] == 'partial':
limited_to = result.get('limited_to')
if limited_to:
coverage = load_limited_to(limited_to)
else:
coverage = None
return FilteredRootLayer(self.root_layer,
result['layers'],
coverage=coverage)
raise RequestError('forbidden', status=403)
else:
return self.root_layer
def _internal_tile_coord(self, tile_request, use_profiles=False):
tile_coord = self.grid.internal_tile_coord(tile_request.tile, use_profiles)
if tile_coord is None:
raise RequestError('The requested tile is outside the bounding box'
' of the tile map.', request=tile_request,
code='TileOutOfRange')
if tile_request.origin == 'nw' and self.grid.origin not in ('ul', 'nw'):
tile_coord = self.grid.flip_tile_coord(tile_coord)
elif tile_request.origin == 'sw' and self.grid.origin not in ('ll', 'sw', None):
tile_coord = self.grid.flip_tile_coord(tile_coord)
return tile_coord
def test_exception(self):
self.req['exceptions'] = 'blank'
req = WMSMapRequest(self.req)
req_ex = RequestError('the exception message', request=req)
response = req_ex.render()
assert response.content_type == 'image/png'
data = StringIO(response.data)
assert is_png(data)
img = Image.open(data)
assert img.size == (150, 100)
eq_(img.getpixel((0, 0)), 0) #pallete image
eq_(img.getpalette()[0:3], [255, 255, 255])
def validate_format(self, image_formats):
format = self.params['format']
image_formats100 = [f.split('/', 1)[1].upper() for f in image_formats]
if format in image_formats100:
format = 'image/' + format.lower()
self.params['format'] = format
if format not in image_formats:
format = self.params['format']
self.params['format'] = 'image/png'
raise RequestError('unsupported image format: ' + format,
code='InvalidFormat', request=self)
def validate_param(self):
missing_param = []
for param in self.expected_param:
if self.non_strict and param in self.non_strict_params:
continue
if param not in self.params:
missing_param.append(param)
if missing_param:
if 'format' in missing_param:
self.params['format'] = 'image/png'
raise RequestError('missing parameters ' + str(missing_param),
request=self)
def test_exception(self):
self.req.set('exceptions', 'inimage')
self.req.set('transparent', 'true')
req = WMSMapRequest(self.req)
req_ex = RequestError('the exception message', request=req)
response = req_ex.render()
assert response.content_type == 'image/png'
data = StringIO(response.data)
assert is_png(data)
img = Image.open(data)
assert img.size == (150, 100)
def wmts_request(req):
if req.path.endswith(RESTFUL_CAPABILITIES_PATH):
return WMTS100RestCapabilitiesRequest(req)
match = tile_req_re.search(req.path)
if not match:
match = fi_req_re.search(req.path)
if not match:
raise RequestError('invalid request (%s)' % (req.path))
req_vars = match.groupdict()
return WMTS100RestFeatureInfoRequest(req, req_vars, fi_url_converter)
req_vars = match.groupdict()
return WMTS100RestTileRequest(req, req_vars, url_converter)
def checked_dimensions(self, tile_request):
dimensions = {}
for dimension, values in self.dimensions.iteritems():
value = tile_request.dimensions.get(dimension)
if value in values:
dimensions[dimension] = value
elif not value or value == 'default':
dimensions[dimension] = values.default
else:
raise RequestError('invalid dimension value (%s=%s).'
% (dimension, value), request=tile_request,
code='InvalidParameterValue')
return dimensions
def filter_actual_layers(self, actual_layers, requested_layers, authorized_layers):
if authorized_layers is not PERMIT_ALL_LAYERS:
requested_layer_names = set(requested_layers)
for layer_name in actual_layers.keys():
if layer_name not in authorized_layers:
# check whether layer was requested explicit...
if layer_name in requested_layer_names:
raise RequestError('forbidden', status=403)
# or implicit (part of group layer)
else:
del actual_layers[layer_name]
elif authorized_layers[layer_name] is not None:
limited_to = load_limited_to(authorized_layers[layer_name])
actual_layers[layer_name] = [LimitedLayer(lyr, limited_to) for lyr in actual_layers[layer_name]]
def test_exception_w_bgcolor(self):
self.req.set('exceptions', 'blank')
self.req.set('bgcolor', '0xff00ff')
req = WMSMapRequest(self.req)
req_ex = RequestError('the exception message', request=req)
response = req_ex.render()
assert response.content_type == 'image/png'
data = BytesIO(response.data)
assert is_png(data)
img = Image.open(data)
assert img.size == (150, 100)
assert img.getpixel((0, 0)) == 0 #pallete image
assert img.getpalette()[0:3] == [255, 0, 255]
def _render_raise_exceptions(self, async_pool, render_layers, layer_merger):
# call _render_layer, raise all exceptions
try:
for layer_task in async_pool.imap(self._render_layer, render_layers,
use_result_objects=True):
if layer_task.exception is None:
layer, layer_img = layer_task.result
if layer_img is not None:
layer_merger.add(layer_img, layer.coverage)
else:
ex = layer_task.exception
async_pool.shutdown(True)
reraise(ex)
except SourceError as ex:
raise RequestError(ex.args[0], request=self.request)
def legendgraphic(self, request):
legends = []
self.check_legend_request(request)
layer = request.params.layer
if not self.layers[layer].has_legend:
raise RequestError('layer %s has no legend graphic' % layer, request=request)
legend = self.layers[layer].legend(request)
[legends.append(i) for i in legend if i is not None]
result = concat_legends(legends)
if 'format' in request.params:
mimetype = request.params.format_mime_type
else:
mimetype = 'image/png'
img_opts = self.image_formats[request.params.format_mime_type]
return Response(result.as_buffer(img_opts), mimetype=mimetype)
def test_exception_w_transparent(self):
self.req.set('exceptions', 'blank')
self.req.set('transparent', 'true')
req = WMSMapRequest(self.req)
req_ex = RequestError('the exception message', request=req)
response = req_ex.render()
assert response.content_type == 'image/png'
data = StringIO(response.data)
assert is_png(data)
img = Image.open(data)
assert img.size == (150, 100)
assert img.mode == 'P'
img = img.convert('RGBA')
eq_(img.getpixel((0, 0))[3], 0)
def test_exception_w_transparent(self):
self.req.set('exceptions', 'inimage')
self.req.set('transparent', 'true')
req = WMSMapRequest(self.req)
req_ex = RequestError('the exception message', request=req)
response = req_ex.render()
assert response.content_type == 'image/png'
data = StringIO(response.data)
assert is_png(data)
img = Image.open(data)
assert img.size == (150, 100)
eq_(sorted([x for x in img.histogram() if x > 25]), [377, 14623])
img = img.convert('RGBA')
eq_(img.getpixel((0, 0))[3], 0)
def test_render(self):
req = self.mock(WMSMapRequest)
req_ex = RequestError('the exception message', request=req)
ex_handler = WMS100ExceptionHandler()
self.expect(req.exception_handler).result(ex_handler)
self.replay()
response = req_ex.render()
assert response.content_type == 'text/xml'
expected_resp = """
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<WMTException version="1.0.0">
the exception message
</WMTException>
"""
assert expected_resp.strip() == response.data
