MapProxy 1.16.1__py3-none-any.whl

mapproxy/response.py

@@ -0,0 +1,237 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2010 Omniscale <http://omniscale.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Service responses.
+"""
+
+import hashlib
+from mapproxy.util.times import format_httpdate, parse_httpdate, timestamp
+from mapproxy.compat import PY2, text_type, iteritems
+
+class Response(object):
+    charset = 'utf-8'
+    default_content_type = 'text/plain'
+    block_size = 1024 * 32
+
+    def __init__(self, response, status=None, content_type=None, mimetype=None):
+        self.response = response
+        if status is None:
+            status = 200
+        self.status = status
+        self._timestamp = None
+        self.headers = {}
+        if mimetype:
+            if mimetype.startswith('text/'):
+                content_type = mimetype + '; charset=' + self.charset
+            else:
+                content_type = mimetype
+        if content_type is None:
+            content_type = self.default_content_type
+        self.headers['Content-type'] = content_type
+
+        if content_type.startswith(('text/', 'application/')):
+            # Capability documents can be dependent on the value of a few X-headers.
+            # Tell this caching proxies via the Vary HTTP header. This also prevents
+            # malicious cache poisoning.
+            self.headers['Vary'] = 'X-Script-Name, X-Forwarded-Host, X-Forwarded-Proto'
+
+    def _status_set(self, status):
+        if isinstance(status, int):
+            status = status_code(status)
+        self._status = status
+
+    def _status_get(self):
+        return self._status
+
+    status = property(_status_get, _status_set)
+
+    def _last_modified_set(self, date):
+        if not date: return
+        self._timestamp = timestamp(date)
+        self.headers['Last-modified'] = format_httpdate(self._timestamp)
+    def _last_modified_get(self):
+        return self.headers.get('Last-modified', None)
+
+    last_modified = property(_last_modified_get, _last_modified_set)
+
+    def _etag_set(self, value):
+        self.headers['ETag'] = value
+
+    def _etag_get(self):
+        return self.headers.get('ETag', None)
+
+    etag = property(_etag_get, _etag_set)
+
+    def cache_headers(self, timestamp=None, etag_data=None, max_age=None, no_cache=False):
+        """
+        Set cache-related headers.
+
+        :param timestamp: local timestamp of the last modification of the
+            response content
+        :param etag_data: list that will be used to build an ETag hash.
+            calls the str function on each item.
+        :param max_age: the maximum cache age in seconds
+        """
+        if etag_data:
+            hash_src = ''.join((str(x) for x in etag_data)).encode('ascii')
+            self.etag = hashlib.md5(hash_src).hexdigest()
+
+        if no_cache:
+            assert not timestamp and not max_age
+            self.headers['Cache-Control'] = 'no-cache, no-store'
+            self.headers['Pragma'] = 'no-cache'
+            self.headers['Expires'] = '-1'
+
+        self.last_modified = timestamp
+        if (timestamp or etag_data) and max_age is not None:
+            self.headers['Cache-control'] = 'public, max-age=%d, s-maxage=%d' % (max_age, max_age)
+
+    def make_conditional(self, req):
+        """
+        Make the response conditional to the HTTP headers in the CGI/WSGI `environ`.
+        Checks for ``If-none-match`` and ``If-modified-since`` headers and compares
+        to the etag and timestamp of this response. If the content was not modified
+        the repsonse will changed to HTTP 304 Not Modified.
+        """
+        if req is None:
+            return
+        environ = req.environ
+
+        not_modified = False
+
+
+        if self.etag == environ.get('HTTP_IF_NONE_MATCH', -1):
+            not_modified = True
+        elif self._timestamp is not None:
+            date = environ.get('HTTP_IF_MODIFIED_SINCE', None)
+            timestamp = parse_httpdate(date)
+            if timestamp is not None and self._timestamp <= timestamp:
+                not_modified = True
+
+        if not_modified:
+            self.status = 304
+            self.response = []
+            if 'Content-type' in self.headers:
+                del self.headers['Content-type']
+
+    @property
+    def content_length(self):
+        return int(self.headers.get('Content-length', 0))
+
+    @property
+    def content_type(self):
+        return self.headers['Content-type']
+
+    @property
+    def data(self):
+        if hasattr(self.response, 'read'):
+            return self.response.read()
+        else:
+            return b''.join(chunk.encode() for chunk in self.response)
+
+    @property
+    def fixed_headers(self):
+        headers = []
+        for key, value in iteritems(self.headers):
+            if type(value) != text_type:
+                # for str subclasses like ImageFormat
+                value = str(value)
+            if PY2 and isinstance(value, unicode):
+                value = value.encode('utf-8')
+            headers.append((key, value))
+        return headers
+
+    def __call__(self, environ, start_response):
+        if hasattr(self.response, 'read'):
+            if ((not hasattr(self.response, 'ok_to_seek') or
+                self.response.ok_to_seek) and
+               (hasattr(self.response, 'seek') and
+                hasattr(self.response, 'tell'))):
+                self.response.seek(0, 2) # to EOF
+                self.headers['Content-length'] = str(self.response.tell())
+                self.response.seek(0)
+            if 'wsgi.file_wrapper' in environ:
+                resp_iter = environ['wsgi.file_wrapper'](self.response, self.block_size)
+            else:
+                resp_iter = iter(lambda: self.response.read(self.block_size), b'')
+        elif not self.response:
+            resp_iter = iter([])
+        elif isinstance(self.response, text_type):
+            self.response = self.response.encode(self.charset)
+            self.headers['Content-length'] = str(len(self.response))
+            resp_iter = iter([self.response])
+        elif isinstance(self.response, bytes):
+            self.headers['Content-length'] = str(len(self.response))
+            resp_iter = iter([self.response])
+        else:
+            resp_iter = self.response
+
+        start_response(self.status, self.fixed_headers)
+        return resp_iter
+
+    def iter_encode(self, chunks):
+        for chunk in chunks:
+            if isinstance(chunk, text_type):
+                chunk = chunk.encode(self.charset)
+            yield chunk
+
+
+# http://www.faqs.org/rfcs/rfc2616.html
+_status_codes = {
+    100: 'Continue',
+    101: 'Switching Protocols',
+    200: 'OK',
+    201: 'Created',
+    202: 'Accepted',
+    203: 'Non-Authoritative Information',
+    204: 'No Content',
+    205: 'Reset Content',
+    206: 'Partial Content',
+    300: 'Multiple Choices',
+    301: 'Moved Permanently',
+    302: 'Found',
+    303: 'See Other',
+    304: 'Not Modified',
+    305: 'Use Proxy',
+    307: 'Temporary Redirect',
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    402: 'Payment Required',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    406: 'Not Acceptable',
+    407: 'Proxy Authentication Required',
+    408: 'Request Time-out',
+    409: 'Conflict',
+    410: 'Gone',
+    411: 'Length Required',
+    412: 'Precondition Failed',
+    413: 'Request Entity Too Large',
+    414: 'Request-URI Too Large',
+    415: 'Unsupported Media Type',
+    416: 'Requested range not satisfiable',
+    417: 'Expectation Failed',
+    500: 'Internal Server Error',
+    501: 'Not Implemented',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable',
+    504: 'Gateway Time-out',
+    505: 'HTTP Version not supported',
+}
+
+def status_code(code):
+    return str(code) + ' ' + _status_codes[code]

mapproxy/script/conf/app.py

@@ -0,0 +1,195 @@
+# -:- encoding: utf-8 -:-
+# This file is part of the MapProxy project.
+# Copyright (C) 2013 Omniscale <http://omniscale.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import codecs
+import sys
+import os
+import optparse
+import logging
+import textwrap
+import datetime
+import xml.etree.ElementTree
+import yaml
+
+from contextlib import contextmanager
+from io import BytesIO
+
+from .sources import sources
+from .layers import layers
+from .caches import caches
+from .seeds import seeds
+from .utils import update_config, MapProxyYAMLDumper, download_capabilities
+
+from mapproxy.compat import iteritems
+from mapproxy.config.loader import load_configuration
+from mapproxy.util.ext.wmsparse import parse_capabilities
+
+def setup_logging(level=logging.INFO):
+    mapproxy_log = logging.getLogger('mapproxy')
+    mapproxy_log.setLevel(level)
+
+    # do not init logging when stdout is captured
+    # eg. when running in tests
+    if isinstance(sys.stdout, BytesIO):
+        return
+
+    ch = logging.StreamHandler(sys.stdout)
+    ch.setLevel(logging.DEBUG)
+    formatter = logging.Formatter(
+        "[%(asctime)s] %(name)s - %(levelname)s - %(message)s")
+    ch.setFormatter(formatter)
+    mapproxy_log.addHandler(ch)
+
+def write_header(f, capabilities):
+    print('# MapProxy configuration automatically generated from:', file=f)
+    print('#   %s' % capabilities, file=f)
+    print('#', file=f)
+    print('# NOTE: The generated configuration can be highly inefficient,', file=f)
+    print('#       especially when multiple layers and caches are requested at once.', file=f)
+    print('#       Make sure you understand the generated configuration!', file=f)
+    print('#', file=f)
+    print('# Created on %s with:' % datetime.datetime.now(), file=f)
+    print(' \\\n'.join(textwrap.wrap(' '.join(sys.argv), initial_indent='# ', subsequent_indent='#    ')), file=f)
+    print('', file=f)
+
+
+@contextmanager
+def file_or_stdout(name):
+    if name == '-':
+        if hasattr(sys.stdout, 'buffer'):
+            yield codecs.getwriter('utf-8')(sys.stdout.buffer)
+        else:
+            yield codecs.getwriter('utf-8')(sys.stdout)
+    else:
+        with open(name, 'wb') as f:
+            yield codecs.getwriter('utf-8')(f)
+
+def config_command(args):
+    parser = optparse.OptionParser("usage: %prog autoconfig [options]")
+
+    parser.add_option('--capabilities',
+        help="URL or filename of WMS 1.1.1/1.3.0 capabilities document")
+    parser.add_option('--output', help="filename for created MapProxy config [default: -]", default="-")
+    parser.add_option('--output-seed', help="filename for created seeding config")
+
+    parser.add_option('--base', help='base config to include in created MapProxy config')
+
+    parser.add_option('--overwrite',
+        help='YAML file with overwrites for the created MapProxy config')
+    parser.add_option('--overwrite-seed',
+        help='YAML file with overwrites for the created seeding config')
+
+    parser.add_option('--force', default=False, action='store_true',
+        help="overwrite existing files")
+
+    options, args = parser.parse_args(args)
+
+    if not options.capabilities:
+        parser.print_help()
+        print("\nERROR: --capabilities required", file=sys.stderr)
+        return 2
+
+    if not options.output and not options.output_seed:
+        parser.print_help()
+        print("\nERROR: --output and/or --output-seed required", file=sys.stderr)
+        return 2
+
+    if not options.force:
+        if options.output and options.output != '-' and os.path.exists(options.output):
+            print("\nERROR: %s already exists, use --force to overwrite" % options.output, file=sys.stderr)
+            return 2
+        if options.output_seed and options.output_seed != '-' and os.path.exists(options.output_seed):
+            print("\nERROR: %s already exists, use --force to overwrite" % options.output_seed, file=sys.stderr)
+            return 2
+
+    log = logging.getLogger('mapproxy_conf_cmd')
+    log.addHandler(logging.StreamHandler())
+
+    setup_logging(logging.WARNING)
+
+    srs_grids = {}
+    if options.base:
+        base = load_configuration(options.base)
+        for name, grid_conf in iteritems(base.grids):
+            if name.startswith('GLOBAL_'):
+                continue
+            srs_grids[grid_conf.tile_grid().srs.srs_code] = name
+
+    cap_doc = options.capabilities
+    if cap_doc.startswith(('http://', 'https://')):
+        cap_doc = download_capabilities(options.capabilities).read()
+    else:
+        cap_doc = open(cap_doc, 'rb').read()
+
+    try:
+        cap = parse_capabilities(BytesIO(cap_doc))
+    except (xml.etree.ElementTree.ParseError, ValueError) as ex:
+        print(ex, file=sys.stderr)
+        print(cap_doc[:1000] + ('...' if len(cap_doc) > 1000 else ''), file=sys.stderr)
+        return 3
+
+    overwrite = None
+    if options.overwrite:
+        with open(options.overwrite, 'rb') as f:
+            overwrite = yaml.safe_load(f)
+
+    overwrite_seed = None
+    if options.overwrite_seed:
+        with open(options.overwrite_seed, 'rb') as f:
+            overwrite_seed = yaml.safe_load(f)
+
+    conf = {}
+    if options.base:
+        conf['base'] = os.path.abspath(options.base)
+
+    conf['services'] = {'wms': {'md': {'title': cap.metadata()['title']}}}
+    if overwrite:
+        conf['services'] = update_config(conf['services'], overwrite.pop('service', {}))
+
+    conf['sources'] = sources(cap)
+    if overwrite:
+        conf['sources'] = update_config(conf['sources'], overwrite.pop('sources', {}))
+
+    conf['caches'] = caches(cap, conf['sources'], srs_grids=srs_grids)
+    if overwrite:
+        conf['caches'] = update_config(conf['caches'], overwrite.pop('caches', {}))
+
+    conf['layers'] = layers(cap, conf['caches'])
+    if overwrite:
+        conf['layers'] = update_config(conf['layers'], overwrite.pop('layers', {}))
+
+    if overwrite:
+        conf = update_config(conf, overwrite)
+
+
+    seed_conf = {}
+    seed_conf['seeds'], seed_conf['cleanups'] = seeds(cap, conf['caches'])
+    if overwrite_seed:
+        seed_conf = update_config(seed_conf, overwrite_seed)
+
+
+    if options.output:
+        with file_or_stdout(options.output) as f:
+            write_header(f, options.capabilities)
+            yaml.dump(conf, f, default_flow_style=False, Dumper=MapProxyYAMLDumper)
+    if options.output_seed:
+        with file_or_stdout(options.output_seed) as f:
+            write_header(f, options.capabilities)
+            yaml.dump(seed_conf, f, default_flow_style=False, Dumper=MapProxyYAMLDumper)
+
+    return 0

mapproxy/script/conf/caches.py

@@ -0,0 +1,45 @@
+# -:- encoding: utf-8 -:-
+# This file is part of the MapProxy project.
+# Copyright (C) 2013 Omniscale <http://omniscale.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from mapproxy.compat import iteritems
+
+def caches(cap, sources, srs_grids):
+    caches = {}
+    for name, source in iteritems(sources):
+        conf = for_source(name, source, srs_grids)
+        if not conf:
+            continue
+        caches[name[:-len('_wms')] + '_cache'] = conf
+
+    return caches
+
+def for_source(name, source, srs_grids):
+    cache = {
+        'sources': [name]
+    }
+
+    grids = []
+    for srs in source['supported_srs']:
+        if srs in srs_grids:
+            grids.append(srs_grids[srs])
+
+    if not grids:
+        return None
+
+    cache['grids'] = grids
+
+    return cache
+

mapproxy/script/conf/layers.py

@@ -0,0 +1,54 @@
+# -:- encoding: utf-8 -:-
+# This file is part of the MapProxy project.
+# Copyright (C) 2013 Omniscale <http://omniscale.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+def layers(cap, caches):
+    return [_layer(cap.layers(), caches)]
+
+def _layer(layer, caches):
+    name, conf = for_layer(layer, caches)
+    child_layers = []
+
+    for child_layer in layer['layers']:
+        child_layers.append(_layer(child_layer, caches))
+
+    if child_layers:
+        conf['layers'] = child_layers
+
+    return conf
+
+
+def for_layer(layer, caches):
+    conf = {
+        'title': layer['title'],
+    }
+
+    if layer['name']:
+        conf['name'] = layer['name']
+
+        if layer['name'] + '_cache' in caches:
+            conf['sources'] = [layer['name'] + '_cache']
+        else:
+            conf['sources'] = [layer['name'] + '_wms']
+
+    md = {}
+    if layer['abstract']:
+        md['abstract'] = layer['abstract']
+
+    if md:
+        conf['md'] = md
+
+    return layer['name'], conf
+

mapproxy/script/conf/seeds.py

@@ -0,0 +1,37 @@
+# -:- encoding: utf-8 -:-
+# This file is part of the MapProxy project.
+# Copyright (C) 2013 Omniscale <http://omniscale.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from mapproxy.compat import iteritems
+
+def seeds(cap, caches):
+    seeds = {}
+    cleanups = {}
+
+    for cache_name, cache in iteritems(caches):
+        for grid in cache['grids']:
+            seeds[cache_name + '_' + grid] = {
+                'caches': [cache_name],
+                'grids': [grid],
+            }
+            cleanups[cache_name + '_' + grid] = {
+                'caches': [cache_name],
+                'grids': [grid],
+                'remove_before': {
+                    'time': '1900-01-01T00:00:00',
+                }
+            }
+
+    return seeds, cleanups

mapproxy/script/conf/sources.py

@@ -0,0 +1,86 @@
+# -:- encoding: utf-8 -:-
+# This file is part of the MapProxy project.
+# Copyright (C) 2013 Omniscale <http://omniscale.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from mapproxy.srs import SRS
+
+import logging
+
+def sources(cap):
+    sources = {}
+    for layer in cap.layers_list():
+        name, conf = for_layer(cap, layer)
+        sources[name+'_wms'] = conf
+
+    return sources
+
+_checked_srs = {}
+
+def check_srs(srs):
+    if srs not in _checked_srs:
+        try:
+            SRS(srs)
+            _checked_srs[srs] = True
+        except Exception as ex:
+            logging.getLogger(__name__).warning('unable to initialize srs for %s: %s', srs, ex)
+            _checked_srs[srs] = False
+
+    return _checked_srs[srs]
+
+def for_layer(cap, layer):
+    source = {'type': 'wms'}
+
+    req = {
+        'url': layer['url'],
+        'layers': layer['name'],
+    }
+
+    if not layer['opaque']:
+        req['transparent'] = True
+
+    wms_opts = {}
+    if cap.version != '1.1.1':
+        wms_opts['version'] = cap.version
+    if layer['queryable']:
+        wms_opts['featureinfo'] = True
+    if layer['legend']:
+        wms_opts['legendurl'] = layer['legend']['url']
+    if wms_opts:
+        source['wms_opts'] = wms_opts
+
+    source['req'] = req
+
+    source['supported_srs'] = []
+    for srs in layer['srs']:
+        if check_srs(srs):
+            source['supported_srs'].append(srs)
+    source['supported_srs'].sort()
+
+    if layer['llbbox']:
+        source['coverage'] = {
+            'srs': 'EPSG:4326',
+            'bbox': layer['llbbox'],
+        }
+
+    res_hint = layer['res_hint']
+    if res_hint:
+        if res_hint[0]:
+            source['min_res'] = res_hint[0]
+        if res_hint[1]:
+            source['max_res'] = res_hint[1]
+
+    return layer['name'], source
+
+