def _makeInterface(self, publication):
return self.interfaceClass[VOR.accessURL(
use=base.getMetaText(publication, "urlUse"))[base.getMetaText(
publication, "accessURL", macroPackage=publication.parent)],
VOR.securityMethod(
standardId=base.getMetaText(
publication, "securityId")), ]
def getTableForTableDef(tableDef, namesInSet): """returns a VS.table instance for a rscdef.TableDef. namesInSet is a set of lowercased qualified table names; we need this to figure out which foreign keys to create. """ name = getEffectiveTableName(tableDef) # Fake type=output on the basis of the table name. We'll have # to do something sensible here if this "type" thing ever becomes # more meaningful. type = None if name=="output": type = "output" res = VS.table(type=type)[ VS.name[name], VS.title[base.getMetaText(tableDef, "title", propagate=False)], VS.description[base.getMetaText(tableDef, "description", propagate=True)], VS.utype[base.getMetaText(tableDef, "utype")], [ getTableColumnFromColumn(col, voTableDataTypeFactory) for col in tableDef], [ getForeignKeyForForeignKey(fk, namesInSet) for fk in tableDef.foreignKeys]] return res
def makeBaseRecord(res, keepTimestamp=False):
"""returns a dictionary giving the metadata common to resource records.
"""
# bomb out if critical metadata is missing
base.validateStructure(res)
# bomb out if, for some reason, we can't come up with a resource record
# for this guy
builders.getVOResourceElement(res)
rec = {}
rec["ivoid"] = base.getMetaText(res, "identifier")
rec["shortName"] = base.getMetaText(res, "shortName")
rec["sourceRD"] = res.rd.sourceId
rec["resId"] = res.id
rec["title"] = base.getMetaText(res, "title", propagate=True)
rec["deleted"] = False
rec["recTimestamp"] = datetime.datetime.utcnow()
rec["description"] = base.getMetaText(res, "description")
rec["authors"] = "; ".join(m.getContent("text")
for m in res.iterMeta("creator.name", propagate=True))
dateUpdated = res.getMeta("datetimeUpdated")
if keepTimestamp:
try:
rec["recTimestamp"] = base.getMetaText(res, "recTimestamp")
except base.NoMetaKey:
# not published, nothing to keep
pass
if dateUpdated is None:
rec["dateUpdated"] = datetime.datetime.utcnow()
else:
rec["dateUpdated"] = str(dateUpdated)
return rec
def _addTableMeta(query, tree, table):
"""adds various info items from query and its parsed tree to a
result table.
"""
# Copy over tableDef meta so it doesn't get obscured by what
# we're setting now.
for infoMeta in table.tableDef.iterMeta("info", propagate=False):
table.addMeta("info", infoMeta)
table.addMeta("info",
"",
infoName="server",
infoValue=base.getConfig("web", "serverURL"))
table.addMeta("info", "", infoName="query", infoValue=query)
mth = base.caches.getMTH(None)
sourceTables = tree.getContributingNames()
# for 1-table queries, we've already copied the entire table metadata.
# don't re-copy it.
tableMetaCopied = len(sourceTables) == 1
tablesSeen = set()
for tableName in sourceTables:
if tableName in tablesSeen:
continue
tablesSeen.add(tableName)
try:
sourceTD = mth.getTableDefForTable(tableName)
table.addMeta("info",
base.getMetaText(sourceTD.rd, "description", ""),
infoName="src_res",
infoValue="Contains traces from resource %s" %
(sourceTD.rd.sourceId))
for m in sourceTD.iterMeta("copyright", propagate=True):
table.addMeta("info",
m.getContent("text"),
infoName="copyright",
infoValue="%s copyright or license" %
(sourceTD.rd.sourceId))
table.addMeta("info",
base.getMetaText(sourceTD,
"description",
"",
propagate=False),
infoName="src_table",
infoValue="Contains traces from table %s" %
(sourceTD.getQName()))
if not tableMetaCopied:
for m in sourceTD.iterMeta("howtociteLink"):
table.addMeta("howtociteLink", m)
for m in sourceTD.iterMeta("source"):
table.addMeta("source", m)
except base.Error:
# don't fail just because of funny metadata or tables not found
pass
def getResourceArgs(resob):
"""returns the mandatory attributes for constructing a Resource record
for service in a dictionary.
"""
return {
"created": base.getMetaText(resob, "creationDate", propagate=True),
"updated": base.getMetaText(resob, "datetimeUpdated", propagate=True),
"status": base.getMetaText(resob, "status"),
}
def getSchemaForRD(rd): """returns a VS.schema instance for an rd. No tables are added. You need to pick and choose them yourself. """ return VS.schema[ VS.name[rd.schema.lower()], VS.title[base.getMetaText(rd, "title")], VS.description[base.getMetaText(rd, "description")], ]
def _makeInterface(self, publication):
paramSrc = publication.parent
if publication.service:
paramSrc = publication.service
return InterfaceMaker._makeInterface(
self,
publication)[VS.queryType[base.getMetaText(
publication, "requestMethod", propagate=False)],
VS.resultType[base.getMetaText(
publication, "resultType", propagate=False)],
getInputParams(publication, paramSrc)]
def _addToSourceTable(self):
"""adds information about self.tableDef to the tablemeta table.
"""
t = DBTable(base.caches.getRD(
self.__metaRDId).getTableDefById("tablemeta"),
connection=self.connection)
t.addRow({
"tableName": self.tableDef.getQName(),
"sourceRD": self.tableDef.rd.sourceId,
"adql": self.tableDef.adql,
"tableDesc": base.getMetaText(self.tableDef, "description"),
"resDesc": base.getMetaText(self.tableDef.rd, "description"),
})
def render_svclink(self, ctx, data):
"""renders a link to a service info with a service title.
data must be an item returned from data_services.
"""
return ctx.tag(href=data.getURL("info"))[base.getMetaText(
data, "title")]
def _getMetadataData(self, queryMeta):
"""returns a SIAP-style metadata data item.
"""
# XXX TODO: build VOTable directly (rather than from data)
inputFields = []
for param in self.service.getInputKeysFor(self):
# Caution: UPLOAD mangling is a *renderer* thing -- the core
# doesn't know anything about it. Hence, parameter adaption
# is *not* done by adapting the core. Instead:
if param.type == "file":
inputFields.append(dali.getUploadKeyFor(param))
else:
inputFields.append(param.change(name="INPUT:" + param.name))
outputTable = MS(rscdef.TableDef,
columns=self.service.getCurOutputFields(queryMeta),
id="result")
nullRowmaker = MS(rscdef.RowmakerDef)
dataDesc = MS(
svcs.InputDescriptor,
makes=[MS(rscdef.Make, table=outputTable, rowmaker=nullRowmaker)],
params=inputFields,
parent_=self.service.rd)
data = rsc.makeData(dataDesc)
data.tables["result"].votCasts = self._outputTableCasts
data.setMeta("_type", "results")
data.addMeta("info", "OK", infoName="QUERY_STATUS", infoValue="OK")
data.addMeta("info",
base.getMetaText(self.service, "title") or "Unnamed",
infoName="serviceInfo",
infoValue=str(self.service.getURL(self.name)))
return data
def _explain_ssap_xml(cls, service):
tqKeys = cgi.parse_qs(
base.getMetaText(service, "ssap.testQuery", default=""))
# validator php seems to insist on that key
opts = [
"batch=yes&"
"service=http%3A%2F%2Fvoparis-validator.obspm.fr%2Fxml%2F111.xml%3F"
]
for standardKey, default in [("REQUEST", "queryData"), ("SIZE", ""),
("POS", ""), ("TIME", ""), ("BAND", ""),
("FORMAT", "ALL")]:
opts.append("%s=%s" %
(standardKey,
urllib.quote(tqKeys.pop(standardKey, [default])[0])))
opts.append("addparams=" +
urllib.quote("\n".join("%s=%s" % (k, urllib.quote(v[0]))
for k, v in tqKeys.iteritems())))
optStr = "&".join(opts)
if optStr:
optStr = optStr + "&"
return T.invisible[
"a standard SSAP interface as defined by the"
" IVOA to access spectral or time-series data; SSAP clients"
" use ",
service.getURL("ssap.xml"), " to access the service",
T.invisible(render=T.directive("ifadmin"))[
" -- ",
T.a(href="http://voparis-validator.obspm.fr/validator.php?"
"spec=Simple+Spectral+Access+1.04&"
"format=XHTML&%sserviceURL=%s" %
(optStr,
urllib.quote(service.getURL("ssap.xml"))))["Validate"]]]
def _meta_identifier(self):
# Special case the authority
if base.getMetaText(self, "resType") == "authority":
localPart = ""
else:
localPart = "/%s/%s" % (self.rd.sourceId, self.id)
return "ivo://%s%s" % (base.getConfig("ivoa", "authority"), localPart)
def _iterResourceMeta(ctx, dataSet):
"""adds resource metadata to the Resource parent.
"""
yield V.DESCRIPTION[base.getMetaText(dataSet, "description",
macroPackage=dataSet.dd.rd, propagate=False)]
for el in itertools.chain(
_iterInfoInfos(dataSet), _iterWarningInfos(dataSet)):
yield el
sourcesSeen, citeLinksSeen = set(), set()
for table in dataSet.tables.values():
for m in table.iterMeta("source", propagate="True"):
src = m.getContent("text")
if src not in sourcesSeen:
yield V.INFO(name="source", value=src)[
"This resource contains data associated with the publication"
" %s."%src]
sourcesSeen.add(src)
for m in table.iterMeta("howtociteLink"):
link = m.getContent("text")
if link not in citeLinksSeen:
yield V.INFO(name="howtocite", value=link)[
"For advice on how to cite the resource(s)"
" that contributed to this result, see %s"%link]
citeLinksSeen.add(link)
def _makeCapability(self, publication):
return self.capabilityClass[
VOR.description[base.getMetaText(publication,
"description",
propagate=False,
macroPackage=publication.parent)],
getInterfaceElement(publication)]
def formatFault(exc, service):
if isinstance(exc, base.ValidationError):
val = ZSI.Fault(ZSI.Fault.Client, unicodeXML(exc))
else:
val = ZSI.Fault(ZSI.Fault.Server, unicodeXML(exc))
return val.AsSOAP(
nsdict={"tns": base.getMetaText(service, "identifier")})
def makePageTitle(cls, rd):
"""returns a suitable title for the rd info page.
This is a class method to allow other renderers to generate
titles for link anchors.
"""
return "Information on resource '%s'" % base.getMetaText(
rd, "title", default="%s" % rd.sourceId)
def _makeCapability(self, publication):
service = publication.parent
return CapabilityMaker._makeCapability(self, publication)[
SLAP.complianceLevel[service.getMeta("slap.complianceLevel",
default="full")], SSAP.
dataSource[service.getMeta("slap.dataSource", raiseOnFail=True)],
SSAP.testQuery[SSAP.queryDataCmd[base.getMetaText(
service, "slap.testQuery", raiseOnFail=True)]], ]
def _makeResource(ctx, data): """returns a Resource node for the rsc.Data instance data. """ res = V.RESOURCE() with ctx.activeContainer(res): res(type=base.getMetaText(data, "_type"), utype=base.getMetaText(data, "utype"))[ _iterResourceMeta(ctx, data), _iterParams(ctx, data), [ _makeVOTParam(ctx, param) for param in data.iterParams()], _linkBuilder.build(data.dd), ] for table in data: with ctx.buildingFromTable(table): res[makeTable(ctx, table)] res[ctx.overflowElement] return res
def _explain_scs_xml(cls, service):
return T.invisible[
"a standard SCS interface as defined by the"
" IVOA to access catalog-type data; SCS clients"
" use ",
service.getURL("scs.xml"), " to access the service",
T.invisible(render=T.directive("ifadmin"))
[" -- ",
T.a(href="http://nvo.ncsa.uiuc.edu/dalvalidate/"
"ConeSearchValidater?endpoint=" +
urllib.quote(service.getURL("scs.xml")) +
"&RA=%s&DEC=%s&SR=%s&format=html&show=fail&show=warn&show=rec"
"&op=Validate" %
(base.getMetaText(service, "testQuery.ra", default="180"),
base.getMetaText(service, "testQuery.dec", default="60"),
base.getMetaText(service, "testQuery.sr", default="1"))
)["Validate"]]]
def makeSOAPWSDLForService(service, queryMeta):
"""returns an stanxml definitions element describing service.
The definitions element also introduces a namespace named after the
ivoa id of the service, accessible through the tns prefix.
"""
serviceId = base.getMetaText(service, "identifier")
return WSDL.definitions(targetNamespace=serviceId,
xmlns_tns=serviceId,
name="%s_wsdl"%base.getMetaText(service, "shortName").replace(" ", "_"))[
WSDL.import_,
makeTypesForService(service, queryMeta),
makeMessagesForService(service),
makePortTypeForService(service),
makeSOAPBindingForService(service),
makeSOAPServiceForService(service),
]
def getIdentifyElement(registryService): """returns OAI Identify stanxml. registryService is the registry we're identifying, i.e. typically __system__/services#registry """ return OAI.Identify[ OAI.repositoryName[base.getMetaText(registryService, "title")], OAI.baseURL[_getOAIURL(registryService)], OAI.protocolVersion["2.0"], OAI.adminEmail[base.getMetaText(registryService, "contact.email")], OAI.earliestDatestamp["1970-01-01T00:00:00Z"], OAI.deletedRecord["transient"], OAI.granularity["YYYY-MM-DDThh:mm:ssZ"], OAI.description[ getVORMetadataElement(registryService), ], ]
def declareServes(self, data):
"""adds meta to self and data indicating that data is served by
service.
This is used by table/@adql and the publish element on data.
"""
if data.registration:
self.addMeta("serviceFor",
base.getMetaText(data, "title", default="Anonymous"),
ivoId=base.getMetaText(data, "identifier"))
data.addMeta("servedBy",
base.getMetaText(self, "title"),
ivoId=base.getMetaText(self, "identifier"))
# Since this is always initiated by the data, the dependency
# must show up in its RD to be properly added on publication
# and to be removed when the data is removed.
data.rd.addDependency(self.rd, data.rd)
def renderHTTP(self, ctx):
# look for a matching publication in the parent service...
for pub in self.service.publications:
if pub.render == self.name:
break
else: # no publication, 404
raise svcs.UnknownURI(
"No publication for an external service here.")
raise svcs.WebRedirect(
base.getMetaText(pub, "accessURL", macroPackage=self.service))
def makeSOAPServiceForService(service):
"""returns stanxml for a WSDL service definition of the SOAP interface
to service.
"""
shortName = base.getMetaText(service, "shortName")
return WSDL.service(name=shortName)[
WSDL.port(name="soap_%s"%shortName, binding="tns:soapBinding")[
SOAP.address(location=service.getURL("soap")),
]
]
def _makeCapability(self, publication):
service = publication.parent
return CapabilityMaker._makeCapability(self, publication)[
SCS.maxSR[base.getMetaText(service, "maxSR", "180")],
SCS.maxRecords[str(base.getConfig("ivoa", "dalDefaultLimit") *
10)], SCS.verbosity["true"],
SCS.testQuery[
SCS.ra[service.getMeta("testQuery.ra", raiseOnFail=True)],
SCS.dec[service.getMeta("testQuery.dec", raiseOnFail=True)],
SCS.sr[service.getMeta("testQuery.sr", default="0.001")], ], ]
def makeTable(ctx, table):
"""returns a Table node for the table.Table instance table.
"""
sm = valuemappers.SerManager(table, mfRegistry=ctx.mfRegistry,
idManager=ctx, acquireSamples=ctx.acquireSamples)
# this must happen before FIELDs and such are serialised to ensure
# referenced things have IDs.
result = V.TABLE()
with ctx.activeContainer(result):
result(
name=table.tableDef.id,
utype=base.getMetaText(table, "utype", macroPackage=table.tableDef,
propagate=False))[
# _iterGroups must run before _iterFields and _iterParams since it
# may need to add ids to the respective items. XSD-correct ordering of
# the elements is done by xmlstan.
V.DESCRIPTION[base.getMetaText(table, "description",
macroPackage=table.tableDef, propagate=False)],
_iterGroups(ctx, table.tableDef, sm),
_iterFields(ctx, sm),
_iterTableParams(ctx, sm),
_iterNotes(sm),
_linkBuilder.build(table.tableDef),
]
if ctx.version>(1,1):
result[_iterSTC(table.tableDef, sm)]
if ctx.produceVODML:
for ann in table.tableDef.annotations:
try:
result[ann.getVOT(ctx)]
except Exception, msg:
# never fail just because stupid DM annotation doesn't work out
base.ui.notifyError("DM annotation failed: %s"%msg)
return votable.DelayedTable(result,
sm.getMappedTuples(),
tableEncoders[ctx.tablecoding],
overflowElement=ctx.overflowElement)
def _writeErrorTable(self, ctx, msg, code=200, queryStatus="ERROR"):
request = inevow.IRequest(ctx)
request.setHeader("content-type", base.votableType)
votable.write(
V.VOTABLE11[
V.DESCRIPTION[base.getMetaText(self.service, "description")],
V.INFO(ID="Error",
name="Error",
value=str(msg).replace('"', '\\"'))], request)
request.write("\n")
return ""
def _explain_siap_xml(cls, service):
return T.invisible[
"a standard SIAP interface as defined by the"
" IVOA to access collections of celestial images; SIAP clients"
" use ",
service.getURL("siap.xml"), " to access the service",
T.invisible(
render=T.directive("ifadmin")
)[" -- ",
T.
a(href=
"http://nvo.ncsa.uiuc.edu/dalvalidate/SIAValidater?endpoint=" +
urllib.quote(service.getURL("siap.xml")) +
"&RA=%s&DEC=%s&RASIZE=%s&DECSIZE=%s&FORMAT=ALL&"
"format=html&show=fail&show=warn&show=rec&op=Validate" %
(base.getMetaText(service, "testQuery.pos.ra", default="180"),
base.getMetaText(service, "testQuery.pos.dec", default="60"),
base.getMetaText(service, "testQuery.size.ra", default="3"),
base.getMetaText(service, "testQuery.size.dec", default="3"))
)["Validate"]]]
def tapabort(querier, args):
from gavo.protocols import tap
tap.WORKER_SYSTEM.changeToPhase(
args.jobId, uws.ERROR,
"Job aborted by an administrator, probably because the query\n"
" should be written differently to be less of a resource hog.\n"
" Here's what the administrator had to say:\n\n" + args.helpMsg +
"\n\nIf you have further questions, just send a mail to " +
base.getMetaText(
base.caches.getRD("//tap").getById("run"), "contact.email"))
def _makeTableDoc(tableDef):
content = RSTFragment()
content.addHead1(tableDef.getQName())
content.addNormalizedPara("Defined in %s" %
tableDef.rd.sourceId.replace("__system__", "/"))
content.addNormalizedPara(
base.getMetaText(tableDef, "description", default="UNDOCUMENTED"))
content.makeSpace()
for col in tableDef:
content.addDLItem(col.name, "(%s) -- %s" % (col.type, col.description))
content.makeSpace()
return "".join(content.content)
