def legend(layer, style):
cfg = get_config()
product = cfg.product_index.get(layer)
if not product:
return ("Unknown Layer", 404,
resp_headers({"Content-Type": "text/plain"}))
img = create_legend_for_style(product, style)
if not img:
return ("Unknown Style", 404,
resp_headers({"Content-Type": "text/plain"}))
return img
def legend(layer, style, dates=None):
cfg = get_config()
product = cfg.product_index.get(layer)
if not product:
return ("Unknown Layer", 404, resp_headers({"Content-Type": "text/plain"}))
if dates is None:
args = lower_get_args()
ndates = int(args.get("ndates", 0))
else:
ndates = len(dates)
img = create_legend_for_style(product, style, ndates)
if not img:
return ("Unknown Style", 404, resp_headers({"Content-Type": "text/plain"}))
return img
def exception_response(self, traceback=[]):
return (render_template("ogc_error.xml",
exception=self,
traceback=traceback,
version=self.version,
schema_url=self.schema_url),
self.http_response,
resp_headers({"Content-Type": "application/xml"}))
def ping():
db_ok = False
with cube() as dc:
if dc:
# pylint: disable=protected-access
with dc.index._db.give_me_a_connection() as conn:
results = conn.execute("""
SELECT *
FROM wms.product_ranges
LIMIT 1"""
)
for r in results:
db_ok = True
if db_ok:
return (render_template("ping.html", status="Up"), 200, resp_headers({"Content-Type": "text/html"}))
else:
return (render_template("ping.html", status="Down"), 500, resp_headers({"Content-Type": "text/html"}))
def get_coverage(args):
request_obj = kvp_decode_get_coverage(args)
output, mime, filename = get_coverage_data(request_obj)
return (
output,
200,
resp_headers({
"Content-Type": mime,
'content-disposition': 'attachment; filename=%s' % filename
})
)
def exception_response(self, traceback=[]):
exceptions = [
OWSException(code=error['code'],
locator=error['locator'],
text=[error['msg']] + tb.format_list(traceback))
for error in self.errors
]
if traceback:
exceptions[0].traceback = tb.format_list(traceback)
result = xml_encode_exception_report(exceptions,
Version.from_str(self.version))
return (result.value, self.http_response,
resp_headers({"Content-Type": "application/xml"}))
def ogc_impl():
#pylint: disable=too-many-branches
nocase_args = lower_get_args()
nocase_args = capture_headers(request, nocase_args)
service = nocase_args.get("service", "").upper()
if service:
return ogc_svc_impl(service.lower())
# create dummy env if not exists
try:
# service argument is only required (in fact only defined) by OGC for
# GetCapabilities requests. As long as we are persisting with a single
# routing end point for all services, we must derive the service from the request
# parameter.
# This is a quick hack to fix #64. Service and operation routing could be
# handled more elegantly.
op = nocase_args.get("request", "").upper()
if op in WMS_REQUESTS:
return ogc_svc_impl("wms")
elif op in WCS_REQUESTS:
return ogc_svc_impl("wcs")
elif op:
# Should we return a WMS or WCS exception if there is no service specified?
# Defaulting to WMS because that's what we already have.
raise WMSException("Invalid service and/or request", locator="Service and request parameters")
else:
cfg = get_config()
url = nocase_args.get('Host', nocase_args['url_root'])
base_url = get_service_base_url(cfg.allowed_urls, url)
return (render_template(
"index.html",
cfg=cfg,
supported=OWS_SUPPORTED,
base_url=base_url,
version=__version__,
),
200,
resp_headers({"Content-Type": "text/html"}))
except OGCException as e:
_LOG.error("Handled Error: %s", repr(e.errors))
return e.exception_response()
except Exception as e: # pylint: disable=broad-except
tb = sys.exc_info()[2]
ogc_e = WMSException("Unexpected server error: %s" % str(e), http_response=500)
return ogc_e.exception_response(traceback=traceback.extract_tb(tb))
def desc_coverages(args):
cfg = get_config()
request_obj = kvp_decode_describe_coverage(args)
products = []
for coverage_id in request_obj.coverage_ids:
product = cfg.product_index.get(coverage_id)
if product and product.wcs:
products.append(product)
else:
raise WCS2Exception("Invalid coverage: %s" % coverage_id,
WCS2Exception.NO_SUCH_COVERAGE,
locator=coverage_id)
coverage_descriptions = [
create_coverage_description(cfg, product)
for product in products
]
version = request_obj.version
if version == (2, 0):
result = encoders_v20.xml_encode_coverage_descriptions(coverage_descriptions)
elif version == (2, 1):
result = encoders_v21.xml_encode_coverage_descriptions(coverage_descriptions)
else:
raise WCS2Exception("Unsupported version: %s" % version,
WCS2Exception.INVALID_PARAMETER_VALUE,
locator="version")
return (
result.value,
200,
resp_headers({
"Content-Type": result.content_type,
"Cache-Control": "no-cache, max-age=0"
})
)
def get_capabilities(args):
# Extract layer metadata from Datacube.
cfg = get_config()
url = args.get('Host', args['url_root'])
base_url = get_service_base_url(cfg.allowed_urls, url)
request_obj = kvp_decode_get_capabilities(args)
sections = request_obj.sections or ['all']
# TODO: check for invalid sections
include_service_identification = False
include_service_provider = False
include_operations_metadata = False
include_service_metadata = False
include_coverage_summary = False
if 'all' in sections:
include_service_identification = True
include_service_provider = True
include_operations_metadata = True
include_service_metadata = True
include_coverage_summary = True
if 'serviceidentification' in sections:
include_service_identification = True
if 'serviceprovider' in sections:
include_service_provider = True
if 'operationsmetadata' in sections:
include_operations_metadata = True
if 'servicemetadata' in sections:
include_service_metadata = True
if 'coveragesummary' in sections:
include_coverage_summary = True
capabilities = ServiceCapabilities.with_defaults_v20(
service_url=base_url + '/wcs',
allowed_operations=[
'GetCapabilities', 'DescribeCoverage', 'GetCoverage'
],
allow_post=False,
title=cfg.title,
abstract=cfg.abstract,
keywords=cfg.keywords,
fees=cfg.fees,
access_constraints=[cfg.access_constraints],
provider_name='',
provider_site='',
individual_name=cfg.contact_info['person'],
organisation_name=cfg.contact_info['organisation'],
position_name=cfg.contact_info['position'],
phone_voice=cfg.contact_info['telephone'],
phone_facsimile=cfg.contact_info['fax'],
delivery_point=cfg.contact_info['address']['address'],
city=cfg.contact_info['address']['city'],
administrative_area=cfg.contact_info['address']['state'],
postal_code=cfg.contact_info['address']['postcode'],
country=cfg.contact_info['address']['country'],
electronic_mail_address=cfg.contact_info['email'],
online_resource=base_url,
# hours_of_service=,
# contact_instructions=,
# role=,
coverage_summaries=[
CoverageSummary(identifier=product.name,
coverage_subtype='RectifiedGridCoverage',
title=product.title,
wgs84_bbox=WGS84BoundingBox([
product.ranges['lon']['min'],
product.ranges['lat']['min'],
product.ranges['lon']['max'],
product.ranges['lat']['max'],
])) for product in cfg.product_index.values()
if product.ready and not product.hide and product.wcs
],
formats_supported=[
fmt.mime for fmt in cfg.wcs_formats if 2 in fmt.renderers
],
crss_supported=[
crs # TODO: conversion to URL format
for crs in cfg.published_CRSs
],
interpolations_supported=None, # TODO: find out interpolations
)
result = encoders_v20.xml_encode_capabilities(
capabilities,
include_service_identification=include_service_identification,
include_service_provider=include_service_provider,
include_operations_metadata=include_operations_metadata,
include_service_metadata=include_service_metadata,
include_coverage_summary=include_coverage_summary)
return (result.value, 200,
resp_headers({
"Content-Type": result.content_type,
"Cache-Control": "no-cache, max-age=0"
}))
