params = buildParameterDictionary(requestBody);
log.trace("Request parameters: {}", params);
request = StringUtil.urldecode(params.get("request"), httpRequest.
getContentType());
// WPS 1.0.0 GET interface processing
String service = httpRequest.getParameter("service");
if (service != null) {
if (service.equals("WPS")) {
WpsServer wpsServer = new WpsServer(httpResponse, httpRequest);
request = wpsServer.request;
} else if (service.equals("WCS")) {
handleWcs2Request(httpRequest.getQueryString(), false, httpResponse);
return;
}
}
// To preserve compatibility with previous client versions, we allow
// GET requests with parameter "query"
String request2 = null;
request2 = httpRequest.getParameter("query");
if (request2 == null) {
request2 = StringUtil.urldecode(params.get("query"), httpRequest.
getContentType());
}
if (request2 != null) {
log.debug("Received Abstract Syntax Request via GET: \n\t\t{}", request2);
request2 = ProcessCoveragesRequest.abstractQueryToXmlQuery(request2);
}
if (request == null && request2 != null) {
request = request2;
}
// Empty request ?
if (request == null && (requestBody == null || requestBody.
length() == 0)) {
printUsage(httpResponse, request);
return;
}
// No parameters, just XML in the request body
if (request == null && requestBody != null && requestBody.length() > 0) {
request = StringUtil.urldecode(requestBody, httpRequest.
getContentType());
// if (request.matches(" *<.*") == false)
// {
// handleUnknownRequest(request, httpResponse);
// return;
// }
}
log.debug("Petascope Request: \n------START REQUEST--------\n"
+ request + "\n------END REQUEST------\n");
if (XMLUtil.isFirstTag(request, "Envelope")) {
handleWcs2Request(request, true, httpResponse);
return;
}
Document doc = builder.parse(IOUtils.toInputStream(request));
Element rootElem = doc.getDocumentElement();
String root = rootElem.getTagName();
log.debug("Root Element name: {}", root);
String version = "2.0";
try {
XPath xpath = xpathFactory.newXPath();
xpath.setNamespaceContext(new WcsNamespaceContext());
String query = "/*/@version";
version = (String) xpath.evaluate(query, doc, XPathConstants.STRING);
} catch (XPathExpressionException e) {
log.warn("The root XML node has no attribute called \"version\"");
}
/* The next request types are defined in the WcsServer standard, and
are common to all the PetaScope services. */
log.trace("WCS version: {}", version);
if (version.startsWith("1")) {
if (root.endsWith("GetCapabilities")) {
handleGetCapabilities(request, httpResponse);
return;
} else if (root.endsWith("DescribeCoverage")) {
handleDescribeCoverage(request, httpResponse);
return;
} else if (root.endsWith("GetCoverage")) {
handleGetCoverage(request, httpResponse);
return;
}
} else {
handleWcs2Request(request, false, httpResponse);
return;
}
if (root.endsWith("ProcessCoveragesRequest")) { /* ProcessCoverages is defined in the WCPS extension to WcsServer */
handleProcessCoverages(request, httpResponse);
} else if (root.endsWith("Transaction")) { /* Transaction is defined in the WcsServer-T extension to WcsServer */
handleTransaction(request, httpResponse);
} else { /* Print Error Message */
handleUnknownRequest(request, httpResponse);
}
} catch (WCSException e) {
throw e;
} catch (Exception e) {
// Finally, cast all other exceptions into a WCSException
log.error("Runtime error : {}", e.getMessage());
throw new WCSException(ExceptionCode.RuntimeError,
"Runtime error while processing request", e);
}
} // And catch all WCSExceptions, to display to the client
catch (WCSException e) {
printError(httpResponse, request, e);
}
}
private void printUsage(HttpServletResponse httpResponse,
String request) throws IOException {
PrintWriter out = httpResponse.getWriter();
httpResponse.setContentType("text/html");
out.write(usageMessage);
out.flush();
}
private void printError(HttpServletResponse response,
String message, Exception e) {
PrintWriter out;
try {
out = new PrintWriter(response.getOutputStream());
} catch (IOException e1) {
log.error("Could not print exception because of IO error. Stack trace:", e1);
return;
}
log.error("Error stack trace:", e);
if (e instanceof WCSException) {
// We can send an error report
String output = exceptionToXml((WCSException) e);
response.setContentType("text/xml; charset=utf-8");
out.println(output);
out.close();
} else {
log.trace("setting response mimetype to text/html; charset=utf-8");
response.setContentType("text/html; charset=utf-8");
log.trace("returning the following error message.", e);
log.trace("end of error message");
out.println(
"PetaScope");
out.println("An error has occured
");
out.println("" + message + "
");
out.println("Stack trace:
");
e.printStackTrace(out);
out.println("
");
out.close();
log.trace("done with error");
}
}
private void handleUnknownRequest(String request, HttpServletResponse httpResponse) {
request = "'" + request + "'";
printError(httpResponse, request, new WCSException(
ExceptionCode.NoApplicableCode, "Could not understand request " + request));
}
private String exceptionReportToXml(ExceptionReport report) {
String output = null;
try {
javax.xml.bind.JAXBContext jaxbCtx = javax.xml.bind.JAXBContext.
newInstance(report.getClass().getPackage().getName());
javax.xml.bind.Marshaller marshaller = jaxbCtx.createMarshaller();
marshaller.setProperty(javax.xml.bind.Marshaller.JAXB_ENCODING, "UTF-8"); //NOI18N
marshaller.setProperty("jaxb.formatted.output", true);
marshaller.setProperty("jaxb.schemaLocation",
"http://www.opengis.net/ows http://schemas.opengis.net/ows/2.0/owsExceptionReport.xsd");
marshaller.setProperty("com.sun.xml.bind.namespacePrefixMapper", new PetascopeXmlNamespaceMapper());
StringWriter strWriter = new StringWriter();
marshaller.marshal(report, strWriter);
output = strWriter.toString();
String sub = output.substring(output.indexOf(""));
try {
output = Templates.getTemplate(Templates.EXCEPTION_REPORT, Pair.of("\\{exception\\}", sub));
} catch (Exception ex) {
log.warn("Error handling exception report template");
}
log.debug("Done marshalling Error Report.");
} catch (JAXBException e2) {
log.error("Stack trace: {}", e2);
log.error("Error stack trace: " + e2);
}
return output;
}
private String exceptionToXml(PetascopeException e) {
return exceptionReportToXml(e.getReport());
}
/**
* Handle WCS 2.0 request.
*
* @param request request string
* @param response
* @throws WCSException in case of I/O error, or if the server is unable to handle the request
*/
private void handleWcs2Request(String request, boolean soap, HttpServletResponse response)
throws WCSException, PetascopeException {
try {
log.info("Handling WCS 2.0 request");
ProtocolExtension pext = ExtensionsRegistry.getProtocolExtension(request);
if (pext == null) {
throw new WCSException(ExceptionCode.NoApplicableCode,
"No protocol binding extension that can handle this request was found ");
}
log.info("Protocol binding extension found: {}", pext.
getExtensionIdentifier());
Response res = pext.handle(request, meta);
OutputStream os = response.getOutputStream();
if (res.getXml() != null && res.getData() != null) {
MultipartResponse multi = new MultipartResponse(response);
multi.startResponse(FormatExtension.MIME_GML);
IOUtils.write(res.getXml(), os);
multi.endResponse();
multi.startResponse(res.getMimeType());
IOUtils.write(res.getData(), os);
multi.endResponse();
multi.finish();
} else {
try {
if (res.getMimeType() != null) {
response.setContentType(res.getMimeType());
} else {
// response.setContentType(WcsUtil.MIME_GML);
response.setContentType(FormatExtension.MIME_TEXT);
}
if (res.getXml() != null) {
IOUtils.write(res.getXml(), os);
} else if (res.getData() != null) {
IOUtils.write(res.getData(), os);
}
} finally {
if (os != null) {
os.flush();
os.close();
}
}
}
} catch (Exception ex) {
if (!(ex instanceof PetascopeException)) {
ex = new WCSException(ExceptionCode.RuntimeError, ex);
}
throw ((PetascopeException) ex);
}
}
/**
* GetCapabilities of WCS 1.1
* @param request
* @param httpResponse
* @throws WCSException
*/
private void handleGetCapabilities(String request, HttpServletResponse httpResponse)
throws WCSException, PetascopeException {
String output = wcs.GetCapabilities(request);
PrintWriter out;
try {
out = httpResponse.getWriter();
httpResponse.setContentType("text/xml; charset=utf-8");
out.write(output);
out.flush();
out.close();
} catch (IOException e) {
throw new WCSException(ExceptionCode.IOConnectionError, e.getMessage(), e);
}
}
/**
* DescribeCoverage for WCS 1.1
* @param request
* @param httpResponse
* @throws WCSException
*/
private void handleDescribeCoverage(String request, HttpServletResponse httpResponse)
throws WCSException {
String output = wcs.DescribeCoverage(request);
PrintWriter out;
try {
out = httpResponse.getWriter();
httpResponse.setContentType("text/xml; charset=utf-8");
out.write(output);
out.flush();
out.close();
} catch (IOException e) {
throw new WCSException(ExceptionCode.IOConnectionError, e.getMessage(), e);
}
}
private void handleGetCoverage(String request, HttpServletResponse httpResponse)
throws WCSException {
String xmlRequest = wcs.GetCoverage(request, wcps);
log.debug("Received GetCoverage Request: \n{}", xmlRequest);
// Redirect the request to WCPS
handleProcessCoverages(xmlRequest, httpResponse);
}
private void handleProcessCoverages(String xmlRequest, HttpServletResponse response)
throws WCSException {
OutputStream webOut = null;
try {
log.debug("Received a ProcessCoverages request: \n{}", xmlRequest);
log.debug("WCPS: preparing request");
ProcessCoveragesRequest processCoverageRequest =
wcps.pcPrepare(ConfigManager.RASDAMAN_URL, ConfigManager.RASDAMAN_DATABASE,
IOUtils.toInputStream(xmlRequest));
String query = processCoverageRequest.getRasqlQuery();
String mime = processCoverageRequest.getMime();
log.debug("Resulting RasQL query: [{}] {}", mime, query);
log.trace("WCPS: executing request");
List results = processCoverageRequest.execute();
log.debug("WCPS: setting response mimetype to " + mime);
response.setContentType(mime);
log.trace("WCPS: returning response");
webOut = response.getOutputStream();
if (results.size() > 0) {
webOut.write(results.get(0));
if (ConfigManager.CCIP_HACK == true) {
try {
String dir = getServletContext().getRealPath("/");
File f = new File(dir + "image.jpeg");
log.info("HACK: Writing image to: " + f.getAbsolutePath());
{
OutputStream os = new DataOutputStream(new FileOutputStream(f, false));
os.write(results.get(0));
os.close();
log.info("HACK: Wrote image successfully !");
}
} catch (Exception e) {
log.warn("Error while evaluating CCIP hack: '{}'", e.
getMessage());
}
}
} else {
log.warn("WCPS: Warning! No result returned from rasql query.");
}
log.debug("WCPS: done");
} catch (WCPSException e) {
throw new WCSException(ExceptionCode.InternalComponentError, e.
getMessage(), e);
} catch (SAXException e) {
throw new WCSException(ExceptionCode.XmlNotValid, e.getMessage(), e);
} catch (IOException e) {
throw new WCSException(ExceptionCode.IOConnectionError, e.getMessage(), e);
} finally {
if (webOut != null) {
try {
webOut.close();
} catch (IOException e) {
}
}
}
}
private void handleTransaction(String request, HttpServletResponse httpResponse)
throws WCSTException, RasdamanException, WCPSException,
PetascopeException {
try {
String outputXml = wcst.Transaction(request);
PrintWriter out = new PrintWriter(httpResponse.getOutputStream());
httpResponse.setContentType("text/xml; charset=utf-8");
out.write(outputXml);
out.flush();
} catch (IOException e) {
throw new PetascopeException(ExceptionCode.IOConnectionError, e.
getMessage(), e);
}
}
}