def __call__(self, environ, start_response):
# we need to seed the query object with an area by translating
# the area name to an area id
areas = {
'ices-rectangles': 'ir',
'countries': 'co',
'charting-progress': 'cp',
'sea-areas': 'sa'
}
area = environ['selector.vars']['area']
name = environ['selector.vars']['name']
try:
area_type = areas[area]
except KeyError:
raise HTTPError('404 Not Found',
'The area is not recognised: %s' % area)
areas = get_areas(environ)
aid = areas.getAreaId(name, area_type)
if not aid:
raise HTTPError('404 Not Found',
'The area name is not recognised: %s' % name)
q = get_query(environ)
q.setArea(aid)
set_query(q, environ)
# delegate to the result app
return self.app(environ, start_response)
def __call__(self, environ, start_response):
from os.path import splitext
self.prepareSOAP(environ)
gid, fmt = self.gid, self.fmt
response = self.request()
if not response:
raise HTTPError('404 Not Found',
'The metadata record does not exist: %s' % gid)
document = self.obfuscate_emails(response.xml)
if not document:
raise HTTPError(
'404 Not Found',
'The metadata format does not contain any data: %s' % fmt)
# Check if the client needs a new version
headers = []
date = response.date
if date:
etag = check_etag(environ, date)
headers.extend([('Etag', etag),
('Cache-Control', 'no-cache, must-revalidate')])
filename = gid
if splitext(filename)[1] != '.xml':
filename += '.xml'
headers.extend([('Content-disposition',
'attachment; filename="%s"' % filename),
('Content-Type', 'application/xml')])
start_response('200 OK', headers)
return [document]
def __call__(self, environ, start_response):
"""
Call an app associated with a template
"""
from medin.templates import get_template_name
template = get_template_name(environ)
if template is None:
template = self.default_template
if not self.templates:
raise RuntimeError('No template applications have been added')
try:
app = self.templates[template]
except KeyError:
from medin.templates import set_template_name
# set the template name so this error can't become
# recursive which is the case if this code is used in an
# error handler
if self.default_template in self.templates:
# use the default template
set_template_name(environ, self.default_template)
else:
# use any template
set_template_name(environ, self.templates.keys()[0])
raise HTTPError('404 Not Found',
'The requested template does not exist')
return app(environ, start_response)
def __call__(self, environ, start_response):
import os.path
import medin.spatial
self.prepareSOAP(environ)
parser = self.request()
if not parser:
raise HTTPError(
'404 Not Found', 'The metadata record does not exist: %s' %
environ['selector.vars']['gid'])
# Check if the client needs a new version
headers = []
date = get_metadata_date(environ, parser)
if date:
etag = check_etag(environ, date)
headers.extend([('Etag', etag),
('Cache-Control', 'no-cache, must-revalidate')])
bboxes = parser.bboxes()
if not bboxes:
raise HTTPError(
'404 Not Found',
'The metadata record does not have a geographic bounding box')
# ensure the background raster datasource has been created
template_lookup = TemplateLookup(environ)
lookup = template_lookup.lookup()
rasterpath = background_raster(lookup, environ)
# create the mapfile from its template
mappath = os.path.join('config', 'metadata-extent.xml')
template = lookup.get_template(mappath)
mapfile = template.render(root_dir=environ.root)
# create the image
image = medin.spatial.metadata_image(bboxes, mapfile)
# serialise the image
bytes = image.tostring('png')
headers.append(('Content-Type', 'image/png'))
start_response('200 OK', headers)
return [bytes]
def http404(environ, start_response):
"""
Raises a HTTP 404 Not Found exception when called
The actual exception should be handled elsewhere.
"""
msg = 'The resource you specified could not be found: %s' % environ.request_uri(
)
raise HTTPError('404 Not Found', msg)
def proxy(environ, start_response):
from medin.query import GETParams
params = GETParams(environ.get('QUERY_STRING', ''))
try:
url = params['url'][0]
except KeyError:
url = ''
valid_proxies = ('http://www.dassh.ac.uk:8081/geoserver/wfs', )
if not url.startswith(valid_proxies):
raise HTTPError('403 Forbidden', 'The url cannot be proxied: %s' % url)
import urllib2
response = urllib2.urlopen(url, timeout=5)
try:
response = urllib2.urlopen(url, timeout=5)
except urllib2.HTTPError, e:
raise HTTPError('%d Error' % e.getcode(), str(e))
def prepareSOAP(self, environ):
gid = environ['selector.vars']['gid'] # the global metadata identifier
fmt = environ['selector.vars']['format'] # the requested format
if fmt not in self.request.getMetadataFormats(
environ['logging.logger']):
raise HTTPError('404 Not Found',
'The metadata format is not supported: %s' % fmt)
self.gid = gid
self.fmt = fmt
return self.request.prepareCaller(environ['logging.logger'], gid, fmt)
def getConfig(self, environ):
if self.config:
return self.config
import os.path
from ConfigParser import SafeConfigParser
ini_file = os.path.join(environ.root, 'etc', self.name)
try:
fp = open(ini_file, 'r')
except Exception, e:
raise HTTPError('500 Configuration Error',
'the INI file could not be read: %s' % str(e))
def __call__(self, environ, start_response):
try:
fmt = environ['selector.vars']['format']
except KeyError:
app = self.default
else:
if fmt is not None:
try:
app = self.formats[fmt]
except KeyError:
raise HTTPError('404 Not Found',
'The format is not supported: %s' % fmt)
else:
app = self.default
return app(environ, start_response)
def setup(self, environ, etag_data=''):
self.prepareSOAP(environ)
parser = self.request()
if not parser:
raise HTTPError(
'404 Not Found', 'The metadata record does not exist: %s' %
environ['selector.vars']['gid'])
# Check if the client needs a new version
headers = []
if parser:
# check the etag, adding any extra data to the etag
date = get_metadata_date(environ, parser)
if date:
etag = check_etag(environ, date + etag_data)
headers.extend([('Etag', etag),
('Cache-Control', 'no-cache, must-revalidate')
])
return parser, headers
def get_bbox(environ, start_response):
from json import dumps as tojson
from medin.spatial import Areas
aid = environ['selector.vars']['id'] # the area ID
# Check if the client needs a new version
etag = check_etag(environ, aid)
bbox = Areas(get_db(environ)).getBBOX(aid)
if not bbox:
raise HTTPError('404 Not Found',
'The area id does not exist: %s' % aid)
json = tojson(bbox)
headers = [('Content-Type', 'application/json'), ('Etag', etag),
('Cache-Control', 'max-age=3600, must-revalidate')]
start_response('200 OK', headers)
return [json]
def __call__(self, environ, start_response):
from cStringIO import StringIO
from medin.metadata import metadata2csv
self.prepareSOAP(environ)
gid = self.gid
parser = self.request()
if not parser:
raise HTTPError('404 Not Found',
'The metadata record does not exist: %s' % gid)
# Check if the client needs a new version
headers = []
date = get_metadata_date(environ, parser)
if date:
etag = check_etag(environ, date)
headers.extend([('Etag', etag),
('Cache-Control', 'no-cache, must-revalidate')])
metadata = parser.parse()
buf = StringIO()
metadata2csv(metadata, buf)
buf.seek(0) # point to the start of the buffer
if metadata.unique_id:
filename = metadata.unique_id + '.csv'
else:
filename = gid + '.csv'
headers.extend([('Content-disposition',
'attachment; filename="%s"' % filename),
('Content-Type', 'application/vnd.ms-excel')])
start_response('200 OK', headers)
return buf
raise HTTPError('403 Forbidden', 'The url cannot be proxied: %s' % url)
import urllib2
response = urllib2.urlopen(url, timeout=5)
try:
response = urllib2.urlopen(url, timeout=5)
except urllib2.HTTPError, e:
raise HTTPError('%d Error' % e.getcode(), str(e))
except urllib2.URLError, e:
try:
status, msg = e.reason
except ValueError:
msg = str(e.reason)
status = 500
raise HTTPError('%d Error' % status, msg)
# remove hop-by-hop headers (as defined at http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html)
for header in ('Keep-Alive', 'Proxy-Authenticate', 'Proxy-Authorization',
'TE', 'Trailers', 'Transfer-Encoding', 'Upgrade',
'Connection', 'Server'):
del response.headers[header]
headers = response.headers.items()
start_response('%s OK' % response.getcode(), headers)
return response
class ErrorRenderer(MakoApp):
"""
A view to render an exception to the user interface.