"""
Common code supporting functionality described in DALI.
"""
#c Copyright 2008-2023, the GAVO project <gavo@ari.uni-heidelberg.de>
#c
#c This program is free software, covered by the GNU GPL. See the
#c COPYING file in the source distribution.
from twisted.web import resource
from twisted.web import server
from gavo import base
from gavo import formats
from gavo import utils
from gavo.base import sqlmunge
from gavo.votable import V
# Upload stuff -- note that TAP uploads are somewhat different from the
# DALI ones, as TAP allows multiple uploads in one string. Hence, we
# have a different (and simpler) implementation here.
[docs]def getUploadKeyFor(inputKey):
"""returns an input key for file items in "PQL".
This is actually specified by DALI. In that scheme, the parameter
is always called UPLOAD (there can thus only be one such parameter,
but it can be present multiple times in calls if necessary, except we've
not figured out how to do the description right in that case).
It contains a comma-separated (key,source) pair, where
source is a URL; there's a special scheme param: for referring to
inline uploads by their name.
This is used exclusively for metadata generation, and there's special
code to handle it there. There's also special code in
mangleUploads (called by, e.g., the ApiRenderer) to magcially make UPLOAD
into the file parameters we use within DaCHS. Sigh.
"""
return inputKey.change(
name="UPLOAD",
type="pql-upload",
description="An upload of the form '%s,URL'; the input for this"
" parameter is then taken from URL, which may be param:name"
" for pulling the content from the inline upload name. Purpose"
" of the upload: %s"%(inputKey.name, inputKey.description),
values=None)
# pql-uploads never contribute to SQL queries
sqlmunge.registerSQLFactory("pql-upload", lambda field, val, sqlPars: None)
[docs]def parseUploadString(uploadString):
"""returns resourceName, uploadSource from a DALI upload string.
"""
try:
destName, uploadSource = uploadString.split(",", 1)
except (TypeError, ValueError):
raise base.ValidationError("Invalid UPLOAD string",
"UPLOAD", hint="UPLOADs look like my_upload,http://foo.bar/up"
" or inline_upload,param:foo.")
return destName, uploadSource
[docs]class URLUpload(object):
"""a somewhat FieldStorage-compatible facade to an upload coming from
a URL.
The filename for now is the complete upload URL, but that's likely
to change.
"""
def __init__(self, uploadURL, uploadName):
self.uploadURL, self.name = uploadURL, uploadName
self.file_object = utils.urlopenRemote(self.uploadURL)
self.file_name = uploadURL
self.headers = self.file_object.info()
major, minor, parSet = formats.getMIMEKey(
self.headers.get("content-type", "*/*"))
self.type = "%s/%s"%(major, minor)
self.type_options = dict(parSet)
@property
def value(self):
try:
f = utils.urlopenRemote(self.uploadURL)
return f.read()
finally:
f.close()
[docs]def iterUploads(request):
"""iterates over DALI uploads in request.
This yields pairs of (file name, file object), where file name
is the file name requested (sanitized to have no slashes and non-ASCII).
The UPLOAD and inline-file keys are removed from request's args
member. The file object is a cgi-style thing with file, filename,
etc. attributes.
"""
# UWS auto-downcases things (it probably shouldn't)
uploads = request.strargs.pop("UPLOAD", [])
if not uploads:
return
for uploadString in uploads:
paramName, uploadSource = parseUploadString(uploadString)
try:
if uploadSource.startswith("param:"):
fileKey = uploadSource[6:]
upload = request.files[fileKey][0]
else:
upload = URLUpload(uploadSource, paramName)
yield paramName, upload
except (KeyError, AttributeError):
raise base.ui.logOldExc(base.ValidationError(
"%s references a non-existing"
" file upload."%uploadSource, "UPLOAD",
hint="If you pass UPLOAD=foo,param:x,"
" you must pass a file upload under the key x."))
[docs]def mangleUploads(request):
"""manipulates request such that DALI UPLOADs appear in strargs
as pairs of name and file/URLUpload
These are as in normal CGI: uploads are under "their names" (with
DALI uploads, the resource names), with values being pairs of
some name and a FieldStorage-compatible thing having name, filename, value,
file, type, type_options, and headers.
This will also overwrite upload with a sequence of (name, file) for
all uploads for the benefit of uws.
There's different code for this in TAP because regrettably TAP works a bit
differently from this.
"""
newUploads = []
try:
for paramName, fObject in iterUploads(request):
request.strargs[paramName] = (
utils.defuseFileName(fObject.file_name), fObject.file_object)
newUploads.append((paramName, request.strargs[paramName]))
except base.Error:
raise
except Exception as ex:
raise base.ui.logOldExc(
base.ValidationError("Processing upload failed: %s"%ex,
"UPLOAD", hint="If this was a URL upload, perhaps I"
" just can't see the machine the URL is pointing to?"))
request.strargs["upload"] = newUploads
[docs]def getDALIError(errInfo, queryStatus="ERROR", request=None):
"""returns a DALI-compliant error VOTable from an error info.
errInfo can either be an exception, a UWS error info (a
dict with keys msg, type, and hint), or a pre-formatted string.
"""
if isinstance(errInfo, Exception):
errInfo = {
"msg": str(errInfo),
"type": errInfo.__class__.__name__,
"hint": getattr(errInfo, "hint", None)}
elif isinstance(errInfo, str):
errInfo = {
"msg": errInfo,
"type": "ReportableError",
"hint": None}
res = V.RESOURCE(type="results") [
V.INFO(name="QUERY_STATUS", value=queryStatus)[
errInfo["msg"]]]
if request:
res[V.INFO(name="request", value=utils.debytify(request.uri))]
if errInfo["hint"]:
res[V.INFO(name="HINT", value="HINT")[
errInfo["hint"]]]
return V.VOTABLE[res]
[docs]def serveDALIError(request, errInfo, httpStatus=200, queryStatus="ERROR"):
"""serves a DALI-compliant error message from errInfo.
See getDALIError for what errInfo can be.
This closes the request and returns NOT_DONE_YET, so you
can write ``return serverDALIError`` in normal render functions
DALI isn't quite clear on what httpCode ought to be, and protocols
sometimes actually require it to be 200 even of errors (sigh).
To return non-200, pass an httpCode
"""
if request._disconnected:
# the other end has hung up; don't touch the connection any more,
# they won't see our error anyway.
return server.NOT_DONE_YET
try:
request.setHeader("content-type", "text/xml")
errVOT = getDALIError(errInfo, queryStatus, request)
request.setResponseCode(httpStatus)
request.write(
utils.xmlrender(errVOT,
prolog="<?xml-stylesheet href='/static/xsl/"
"dalierror-to-html.xsl' type='text/xsl'?>"))
except Exception as ex:
request.write(b"Ouch. Can't even produce an error any more.\n")
base.ui.notifyError(f"Exception while trying to server error: {ex}")
finally:
request.finish()
return server.NOT_DONE_YET
[docs]class DALIErrorResource(resource.Resource):
"""A DALI error (i.e., an INFO in a VOTable.
This is constructed with an exception or a UWS errInfo (see getDALIError).
Use this when you want to return a DALI error from within a getChild
function. Otherwise, just use serveDALIError.
"""
isLeaf = True
def __init__(self, errInfo):
self.errInfo = errInfo
[docs] def render(self, request):
return serveDALIError(request, self.errInfo)