private void beginSoap11Response( HttpResponseBuffer response ) throws IOException, XMLStreamException { response.setContentType( "text/xml" ); XMLStreamWriter xmlWriter = response.getXMLWriter(); String soapEnvNS = "http://schemas.xmlsoap.org/soap/envelope/"; String xsiNS = "http://www.w3.org/2001/XMLSchema-instance"; xmlWriter.writeStartElement( "soap", "Envelope", soapEnvNS ); xmlWriter.writeNamespace( "soap", soapEnvNS ); xmlWriter.writeNamespace( "xsi", xsiNS ); xmlWriter.writeAttribute( xsiNS, "schemaLocation", "http://schemas.xmlsoap.org/soap/envelope/ http://schemas.xmlsoap.org/soap/envelope/" ); xmlWriter.writeStartElement( soapEnvNS, "Body" ); }
/** * Returns an <code>XMLStreamWriter</code> for writing an XML response document. * * @param writer * writer to write the XML to, must not be <code>null</code> * @param mimeType * mime type, must not be <code>null</code> * @param schemaLocation * value for the 'xsi:schemaLocation' attribute in the root element, can be <code>null</code> * @return XML stream writer object that takes care of putting the schemaLocation in the root element * @throws XMLStreamException * @throws IOException */ public static XMLStreamWriter getXMLResponseWriter( HttpResponseBuffer writer, String mimeType, String schemaLocation ) throws XMLStreamException, IOException { boolean needsEncoding = mimeType.startsWith( "text" ); XMLStreamWriter xmlWriter = writer.getXMLWriter( needsEncoding ); // call setContentType(...) after setCharacterEncoding(...) to avoid problems on certain web containers // see http://tracker.deegree.org/deegree-services/ticket/323 writer.setContentType( mimeType ); if ( schemaLocation == null ) { return xmlWriter; } return new SchemaLocationXMLStreamWriter( xmlWriter, schemaLocation ); }
@Override public void serializeException( HttpResponseBuffer response, OWSException ex, XMLExceptionSerializer exceptionSerializer, Map<String, String> map ) throws SerializingException { try { response.setContentType( contenType ); ByteArrayOutputStream stream = writeToStream( ex, exceptionSerializer ); transform( new ByteArrayInputStream( stream.toByteArray() ), response ); } catch ( XMLStreamException e ) { throw new SerializingException( e ); } catch ( FactoryConfigurationError e ) { throw new SerializingException( e ); } }
public void sendResource ( HttpResponseBuffer response) { try { response.setContentType( getMimeType() ); response.setContentLength( (int) getLength() ); OutputStream os = response.getOutputStream(); InputStream is = getInputStream(); byte[] buffer = new byte[4096]; int numBytes = -1; while ( ( numBytes = is.read( buffer ) ) != -1 ) { os.write( buffer, 0, numBytes ); } os.flush(); } catch ( IOException e ) { LOG.debug( "Error sending resource to client.", e ); } }
public void sendImage( BufferedImage img, HttpResponseBuffer response, String format ) throws OWSException, IOException { response.setContentType( format ); ImageSerializer serializer = imageSerializers.get( format ); if ( serializer != null ) { serializer.serialize( null, img, response.getOutputStream() ); return; } format = format.substring( format.indexOf( "/" ) + 1 ); if ( format.equals( "x-ms-bmp" ) ) { format = "bmp"; } if ( format.equals( "png; subtype=8bit" ) || format.equals( "png; mode=8bit" ) ) { img = ColorQuantizer.quantizeImage( img, 256, false, false ); format = "png"; } LOG.debug( "Sending in format " + format ); if ( !write( img, format, response.getOutputStream() ) ) { throw new OWSException( get( "WMS.CANNOT_ENCODE_IMAGE", format ), OWSException.NO_APPLICABLE_CODE ); } }
@Override protected void exportCapas( String getUrl, String postUrl, MapService service, HttpResponseBuffer response, ServiceIdentification identification, ServiceProvider provider, Map<String, String> customParameters, WMSController controller, OWSMetadataProvider metadata ) throws IOException, OWSException { response.setContentType( "application/vnd.ogc.wms_xml" ); String userAgent = OGCFrontController.getContext().getUserAgent(); if ( userAgent != null && userAgent.toLowerCase().contains( "mozilla" ) ) { response.setContentType( "application/xml" ); } response.addHeader( "Content-Disposition", "inline; filename=\"capabilities.xml\"" ); try { XMLStreamWriter xmlWriter = response.getXMLWriter(); new Capabilities111XMLAdapter( identification, provider, metadata, getUrl, postUrl, service, controller ).export( xmlWriter ); } catch ( XMLStreamException e ) { throw new IOException( e ); } }
private void getFeatureInfoSchema( Map<String, String> map, HttpResponseBuffer response ) throws IOException { GetFeatureInfoSchema fis = new GetFeatureInfoSchema( map ); List<FeatureType> schema = service.getSchema( fis ); try { response.setContentType( "text/xml" ); XMLStreamWriter writer = response.getXMLWriter(); // TODO handle multiple namespaces String namespace = "http://www.deegree.org/app"; if ( !schema.isEmpty() ) { namespace = schema.get( 0 ).getName().getNamespaceURI(); } Map<String, String> nsToPrefix = new HashMap<String, String>(); if ( namespace != null && !namespace.isEmpty() ) { nsToPrefix.put( "app", namespace ); } new GMLAppSchemaWriter( GMLVersion.GML_2, namespace, null, nsToPrefix ).export( writer, schema ); writer.writeEndDocument(); } catch ( XMLStreamException e ) { LOG.error( "Unknown error", e ); } }
private void doGetCapabilities( GetCapabilities request, HttpResponseBuffer response ) throws OWSException, XMLStreamException, IOException { LOG.trace( "doGetCapabilities invoked, request: " + request ); // generic check if requested version is supported (currently this is only 1.0.0) negotiateVersion( request ); response.setContentType( "text/xml; charset=UTF-8" ); XMLStreamWriter xmlWriter = response.getXMLWriter(); WSDL serviceWSDL = new WSDL( "services" + File.separatorChar + "wps.wsdl" ); CapabilitiesXMLWriter.export100( xmlWriter, processManager.getProcesses(), mainMetadataConf, serviceWSDL ); LOG.trace( "doGetCapabilities finished" ); }
@Override protected void exportCapas( String getUrl, String postUrl, MapService service, HttpResponseBuffer response, ServiceIdentification identification, ServiceProvider provider, Map<String, String> customParameters, WMSController controller, OWSMetadataProvider metadata ) throws IOException, OWSException { String format = detectFormat( customParameters ); response.setContentType( format ); try { if ( TEXT_XML_FORMAT.equals( format ) ) { XMLStreamWriter xmlWriter = response.getXMLWriter(); new Capabilities130XMLAdapter( identification, provider, metadata, getUrl, postUrl, service, controller ).export( xmlWriter ); } else { ByteArrayOutputStream stream = new ByteArrayOutputStream(); XMLStreamWriter xmlWriter = XMLOutputFactory.newInstance().createXMLStreamWriter( stream ); new Capabilities130XMLAdapter( identification, provider, metadata, getUrl, postUrl, service, controller ).export( xmlWriter ); xmlWriter.close(); capabilitiesManager.serializeCapabilities( format, new ByteArrayInputStream( stream.toByteArray() ), response.getOutputStream() ); } } catch ( XMLStreamException e ) { throw new IOException( e ); } }
private void doSoapGetMap( SOAPVersion soapVersion, HttpResponseBuffer response, XMLStreamReader xmlStream ) throws OWSException, XMLStreamException, IOException, SOAPException { response.setContentType( "application/xop+xml" ); GetMapParser getMapParser = new GetMapParser(); GetMap getMap = getMapParser.parse( xmlStream ); Map<String, String> map = new HashMap<String, String>(); ByteArrayOutputStream stream = new ByteArrayOutputStream(); doGetMap( getMap, map, VERSION_130, stream ); String contentId = UUID.randomUUID().toString(); SOAPMessage message = createSoapMessage( soapVersion, contentId ); AttachmentPart attachmentPart = createAttachment( getMap, stream, message, contentId ); message.addAttachmentPart( attachmentPart ); message.writeTo( response.getOutputStream() ); }
private void doGetMap( Map<String, String> map, HttpResponseBuffer response, Version version, GetMap gm ) throws OWSException, IOException { LinkedList<String> headers = doGetMap( gm, map, version, response.getOutputStream() ); response.setContentType( gm.getFormat() ); addHeaders( response, headers ); }
private void doDescribeCoverage( DescribeCoverage describeReq, HttpResponseBuffer response ) throws IOException, XMLStreamException, OWSException { response.setContentType( "text/xml" ); XMLStreamWriter xmlWriter = getXMLStreamWriter( response.getWriter() ); List<WCSCoverage> coverages = new LinkedList<WCSCoverage>(); if ( describeReq.getCoverages().size() == 0 ) { // return all coverages = wcsService.getAllCoverages(); } else { for ( String reqCoverage : describeReq.getCoverages() ) { if ( wcsService.hasCoverage( reqCoverage ) ) { coverages.add( wcsService.getCoverage( reqCoverage ) ); } else { throw new OWSException( "Unknown coverage " + reqCoverage, COVERAGE_NOT_DEFINED, "coverage" ); } } } CoverageDescription100XMLAdapter.export( xmlWriter, coverages, UPDATE_SEQUENCE ); xmlWriter.flush(); }
@Override public void serializeException( HttpResponseBuffer response, OWSException exception ) throws IOException, XMLStreamException { response.reset(); response.setCharacterEncoding( "UTF-8" ); response.setContentType( mimeType ); setExceptionStatusCode( response, exception ); serializeExceptionToXML( response.getXMLWriter(), exception ); }
@Override public void serializeException( HttpResponseBuffer response, OWSException exception ) throws IOException, XMLStreamException { response.reset(); response.setCharacterEncoding( "UTF-8" ); response.setContentType( "application/xml" ); setExceptionStatusCode( response, exception ); serializeExceptionToXML( response.getXMLWriter(), exception ); }
@Override public void serializeException( HttpResponseBuffer response, OWSException exception ) throws IOException, XMLStreamException { response.reset(); response.setCharacterEncoding( "UTF-8" ); response.setContentType( "application/xml" ); setExceptionStatusCode( response, exception ); serializeExceptionToXML( response.getXMLWriter(), exception ); }
/** * * Preprocessing for the export of a {@link Transaction} request * * @param trans * @param response * @throws XMLStreamException * @throws OWSException * @throws IOException */ public void doTransaction( Transaction trans, HttpResponseBuffer response, MetadataStore<?> store ) throws XMLStreamException, OWSException, IOException { LOG.debug( "doTransaction: " + trans ); Version version = trans.getVersion(); response.setContentType( "application/xml; charset=UTF-8" ); // to be sure of a valid response String schemaLocation = ""; if ( version.equals( VERSION_202 ) ) { schemaLocation = CSW_202_NS + " " + CSW_202_PUBLICATION_SCHEMA; } XMLStreamWriter xmlWriter = getXMLResponseWriter( response, schemaLocation ); try { doTransaction( xmlWriter, trans, version, store ); } catch ( MetadataStoreException e ) { throw new OWSException( e.getMessage(), OWSException.NO_APPLICABLE_CODE ); } xmlWriter.flush(); }
@Override public void serializeException( HttpResponseBuffer response, OWSException exception ) throws IOException, XMLStreamException { response.reset(); response.setCharacterEncoding( "UTF-8" ); response.setContentType( "application/vnd.ogc.se_xml" ); setExceptionStatusCode( response, exception ); setStatusCode( response, exception ); serializeExceptionToXML( response.getXMLWriter(), exception ); }
@Override public void doXML( XMLStreamReader xmlStream, HttpServletRequest request, HttpResponseBuffer response, List<FileItem> multiParts ) throws ServletException, IOException, SecurityException { response.setContentType( "text/xml" ); try { XMLAdapter requestDoc = new XMLAdapter( xmlStream ); OMElement rootElement = requestDoc.getRootElement(); doXML( rootElement, response ); } catch ( OWSException e ) { LOG.debug( e.getMessage(), e ); sendServiceException( e, response ); } catch ( InvalidParameterValueException e ) { LOG.debug( e.getMessage(), e ); sendServiceException( new OWSException( e ), response ); } catch ( MissingParameterException e ) { LOG.debug( e.getMessage(), e ); sendServiceException( new OWSException( e ), response ); } catch ( Throwable t ) { String msg = "An unexpected error occured: " + t.getMessage(); LOG.error( msg, t ); sendServiceException( new OWSException( msg, t, NO_APPLICABLE_CODE ), response ); } }
/** * Preprocessing for the export of a {@link DescribeRecord} request to determine which recordstore is requested. * * @param descRec * the parsed describeRecord request * @param response * for the servlet request to the client * @throws XMLStreamException * @throws IOException * @throws OWSException */ public void doDescribeRecord( DescribeRecord descRec, HttpResponseBuffer response, ServiceProfile profile ) throws XMLStreamException, IOException, OWSException { this.profile = profile; QName[] typeNames = descRec.getTypeNames(); Version version = descRec.getVersion(); response.setContentType( descRec.getOutputFormat() ); XMLStreamWriter xmlWriter = dcHelper.getXMLResponseWriter( response, null ); try { export( xmlWriter, typeNames, version ); } catch ( MetadataStoreException e ) { LOG.debug( e.getMessage() ); throw new OWSException( e.getMessage(), NO_APPLICABLE_CODE ); } xmlWriter.flush(); }
@Override public void doGetRecordById( GetRecordById getRecBI, HttpResponseBuffer response, MetadataStore<?> store, ServiceProfile profile ) throws XMLStreamException, IOException, InvalidParameterValueException, OWSException { this.profile = profile; LOG.debug( "doGetRecordById: " + getRecBI ); Version version = getRecBI.getVersion(); String outputFormat = getRecBI.getOutputFormat(); response.setContentType( outputFormat ); // to be sure of a valid response String schemaLocation = profile.getGetRecordByIdSchemaLocation( getRecBI.getVersion() ); XMLStreamWriter xmlWriter = getXmlorJsonStreamWriter( outputFormat, response, schemaLocation ); try { export( xmlWriter, getRecBI, version, store ); } catch ( OWSException e ) { LOG.debug( e.getMessage() ); throw new InvalidParameterValueException( e.getMessage() ); } catch ( MetadataStoreException e ) { throw new OWSException( e.getMessage(), NO_APPLICABLE_CODE ); } xmlWriter.flush(); }