class FDSNEvent(resource.Resource):
isLeaf = True
#---------------------------------------------------------------------------
def __init__(self,
hideAuthor=False,
evaluationMode=None,
eventTypeWhitelist=None,
eventTypeBlacklist=None):
self._hideAuthor = hideAuthor
self._evaluationMode = evaluationMode
self._eventTypeWhitelist = eventTypeWhitelist
self._eventTypeBlacklist = eventTypeBlacklist
#---------------------------------------------------------------------------
def render_GET(self, req):
# Parse and validate GET parameters
ro = _EventRequestOptions(req.args)
try:
ro.parse()
except ValueError, e:
Logging.warning(str(e))
return HTTP.renderErrorPage(req, http.BAD_REQUEST, str(e), ro)
# Catalog filter is not supported, any filter value will result in 204
if ro.catalogs:
msg = "no matching events found"
return HTTP.renderErrorPage(req, http.NO_CONTENT, msg, ro)
# updateafter not implemented
if ro.updatedAfter:
msg = "filtering based on update time not supported"
return HTTP.renderErrorPage(req, http.SERVICE_UNAVAILABLE, msg, ro)
# Exporter, 'None' is used for text output
if ro.format in ro.VText:
exp = None
else:
exp = Exporter.Create(ro.Exporters[ro.format])
if exp:
exp.setFormattedOutput(bool(ro.formatted))
else:
msg = "output format '%s' no available, export module '%s' could " \
"not be loaded." % (ro.format, ro.Exporters[ro.format])
return HTTP.renderErrorPage(req, http.SERVICE_UNAVAILABLE, msg,
ro)
# Create database query
dbq = DataModel.DatabaseQuery(Application.Instance().database())
if dbq.hasError():
msg = "could not connect to database: %s" % dbq.errorMsg()
return HTTP.renderErrorPage(req, http.SERVICE_UNAVAILABLE, msg, ro)
# Process request in separate thread
d = deferToThread(self._processRequest, req, ro, dbq, exp)
req.notifyFinish().addErrback(utils.onCancel, d)
d.addBoth(utils.onFinish, req)
# The request is handled by the deferred object
return server.NOT_DONE_YET
def render_GET(self, req):
# Parse and validate GET parameters
ro = _EventRequestOptions()
try:
ro.parseGET(req.args)
ro.parse()
except ValueError as e:
Logging.warning(str(e))
return self.renderErrorPage(req, http.BAD_REQUEST, str(e), ro)
# Catalog filter is not supported
if ro.catalogs:
msg = "catalog filter not supported"
return self.renderErrorPage(req, http.BAD_REQUEST, msg, ro)
if ro.comments and self._hideComments:
msg = "including of comments not supported"
return self.renderErrorPage(req, http.BAD_REQUEST, msg, ro)
# updateafter not implemented
if ro.updatedAfter:
msg = "filtering based on update time not supported"
return self.renderErrorPage(req, http.BAD_REQUEST, msg, ro)
if self._formatList is not None and ro.format not in self._formatList:
msg = "output format '%s' not available" % ro.format
return self.renderErrorPage(req, http.BAD_REQUEST, msg, ro)
# Exporter, 'None' is used for text output
if ro.format in ro.VText:
exp = None
else:
exp = Exporter.Create(ro.Exporters[ro.format])
if exp:
exp.setFormattedOutput(bool(ro.formatted))
else:
msg = "output format '%s' not available, export module '%s' could " \
"not be loaded." % (ro.format, ro.Exporters[ro.format])
return self.renderErrorPage(req, http.BAD_REQUEST, msg, ro)
# Create database query
db = DatabaseInterface.Open(Application.Instance().databaseURI())
if db is None:
msg = "could not connect to database"
return self.renderErrorPage(req, http.SERVICE_UNAVAILABLE, msg, ro)
dbq = DataModel.DatabaseQuery(db)
# Process request in separate thread
d = deferToThread(self._processRequest, req, ro, dbq, exp)
req.notifyFinish().addErrback(utils.onCancel, d)
d.addBoth(utils.onFinish, req)
# The request is handled by the deferred object
return server.NOT_DONE_YET
def _prepareRequest(self, req, ro):
if ro.availability and not self._daEnabled:
msg = "including of availability information not supported"
return self.renderErrorPage(req, http.BAD_REQUEST, msg, ro)
if ro.updatedAfter:
msg = "filtering based on update time not supported"
return self.renderErrorPage(req, http.BAD_REQUEST, msg, ro)
if ro.matchTimeSeries and not self._daEnabled:
msg = "filtering based on available time series not supported"
return self.renderErrorPage(req, http.BAD_REQUEST, msg, ro)
# load data availability if requested
dac = None
if ro.availability or ro.matchTimeSeries:
dac = Application.Instance().getDACache()
if dac is None or len(dac.extents()) == 0:
msg = "no data availabiltiy extent information found"
return self.renderErrorPage(req, http.NO_CONTENT, msg, ro)
# Exporter, 'None' is used for text output
if ro.format in ro.VText:
if ro.includeRes:
msg = "response level output not available in text format"
return self.renderErrorPage(req, http.BAD_REQUEST, msg, ro)
req.setHeader('Content-Type', 'text/plain')
d = deferToThread(self._processRequestText, req, ro, dac)
else:
exp = Exporter.Create(ro.Exporters[ro.format])
if exp is None:
msg = "output format '%s' no available, export module '%s' " \
"could not be loaded." % (
ro.format, ro.Exporters[ro.format])
return self.renderErrorPage(req, http.BAD_REQUEST, msg, ro)
req.setHeader('Content-Type', 'application/xml')
exp.setFormattedOutput(bool(ro.formatted))
d = deferToThread(self._processRequestExp, req, ro, exp, dac)
req.notifyFinish().addErrback(utils.onCancel, d)
d.addBoth(utils.onFinish, req)
# The request is handled by the deferred object
return server.NOT_DONE_YET
def _prepareRequest(self, req, ro):
if ro.availability:
msg = "including of availability information not supported"
return HTTP.renderErrorPage(req, http.SERVICE_UNAVAILABLE, msg, ro)
if ro.updatedAfter:
msg = "filtering based on update time not supported"
return HTTP.renderErrorPage(req, http.SERVICE_UNAVAILABLE, msg, ro)
if ro.matchTimeSeries:
msg = "filtering based on available time series not supported"
return HTTP.renderErrorPage(req, http.SERVICE_UNAVAILABLE, msg, ro)
# Exporter, 'None' is used for text output
if ro.format in ro.VText:
if ro.includeRes:
msg = "response level output not available in text format"
return HTTP.renderErrorPage(req, http.SERVICE_UNAVAILABLE,
msg, ro)
req.setHeader('Content-Type', 'text/plain')
d = deferToThread(self._processRequestText, req, ro)
else:
exp = Exporter.Create(ro.Exporters[ro.format])
if exp is None:
msg = "output format '%s' no available, export module '%s' " \
"could not be loaded." % (
ro.format, ro.Exporters[ro.format])
return HTTP.renderErrorPage(req, http.SERVICE_UNAVAILABLE,
msg, ro)
req.setHeader('Content-Type', 'application/xml')
exp.setFormattedOutput(bool(ro.formatted))
d = deferToThread(self._processRequestExp, req, ro, exp)
req.notifyFinish().addErrback(utils.onCancel, d)
d.addBoth(utils.onFinish, req)
# The request is handled by the deferred object
return server.NOT_DONE_YET
class FDSNEvent(resource.Resource):
isLeaf = True
#---------------------------------------------------------------------------
def __init__(self, hideAuthor = False, evaluationMode = None,
eventTypeWhitelist = None, eventTypeBlacklist = None,
formatList = None):
self._hideAuthor = hideAuthor
self._evaluationMode = evaluationMode
self._eventTypeWhitelist = eventTypeWhitelist
self._eventTypeBlacklist = eventTypeBlacklist
self._formatList = formatList
#---------------------------------------------------------------------------
def render_OPTIONS(self, req):
req.setHeader('Access-Control-Allow-Origin', '*')
req.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
req.setHeader('Access-Control-Allow-Headers',
'Accept, Content-Type, X-Requested-With, Origin')
req.setHeader('Content-Type', 'text/plain')
return ""
#---------------------------------------------------------------------------
def render_GET(self, req):
# Parse and validate GET parameters
ro = _EventRequestOptions(req.args)
try:
ro.parse()
except ValueError, e:
Logging.warning(str(e))
return HTTP.renderErrorPage(req, http.BAD_REQUEST, str(e), ro)
# Catalog filter is not supported
if ro.catalogs:
msg = "catalog filter not supported"
return HTTP.renderErrorPage(req, http.BAD_REQUEST, msg, ro)
# updateafter not implemented
if ro.updatedAfter:
msg = "filtering based on update time not supported"
return HTTP.renderErrorPage(req, http.BAD_REQUEST, msg, ro)
if self._formatList is not None and ro.format not in self._formatList:
msg = "output format '%s' not available" % ro.format
return HTTP.renderErrorPage(req, http.BAD_REQUEST, msg, ro)
# Exporter, 'None' is used for text output
if ro.format in ro.VText:
exp = None
else:
exp = Exporter.Create(ro.Exporters[ro.format])
if exp:
exp.setFormattedOutput(bool(ro.formatted))
else:
msg = "output format '%s' not available, export module '%s' could " \
"not be loaded." % (ro.format, ro.Exporters[ro.format])
return HTTP.renderErrorPage(req, http.BAD_REQUEST, msg, ro)
# Create database query
db = DatabaseInterface.Open(Application.Instance().databaseURI())
if db is None:
msg = "could not connect to database: %s" % dbq.errorMsg()
return HTTP.renderErrorPage(req, http.SERVICE_UNAVAILABLE, msg, ro)
dbq = DataModel.DatabaseQuery(db)
# Process request in separate thread
d = deferToThread(self._processRequest, req, ro, dbq, exp)
req.notifyFinish().addErrback(utils.onCancel, d)
d.addBoth(utils.onFinish, req)
# The request is handled by the deferred object
return server.NOT_DONE_YET