/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.axis.attachments;
import org.apache.axis.Part;
import org.apache.axis.components.logger.LogFactory;
import org.apache.axis.components.image.ImageIOFactory;
import org.apache.axis.transport.http.HTTPConstants;
import org.apache.axis.utils.Messages;
import org.apache.axis.utils.SessionUtils;
import org.apache.axis.utils.IOUtils;
import org.apache.commons.logging.Log;
import javax.activation.DataHandler;
import javax.xml.soap.SOAPException;
import javax.xml.transform.stream.StreamSource;
import java.util.Iterator;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.InputStream;
/**
* An attachment part.
*
*
*/
public class AttachmentPart extends javax.xml.soap.AttachmentPart
implements Part {
/** Field log */
protected static Log log =
LogFactory.getLog(AttachmentPart.class.getName());
/**
* The data handler.
* <p>
* TODO: make private?
* */
javax.activation.DataHandler datahandler = null;
/** Field mimeHeaders. */
private javax.xml.soap.MimeHeaders mimeHeaders =
new javax.xml.soap.MimeHeaders();
private Object contentObject;
/**
* The name of a file used to store the data.
*/
private String attachmentFile;
/**
* Bulds a new <code>AttachmentPart</code>.
*/
public AttachmentPart() {
setMimeHeader(HTTPConstants.HEADER_CONTENT_ID, SessionUtils.generateSessionId());
}
/**
* Bulds a new <code>AttachmentPart</code> with a <code>DataHandler</code>.
*
* @param dh the <code>DataHandler</code>
*/
public AttachmentPart(javax.activation.DataHandler dh) {
setMimeHeader(HTTPConstants.HEADER_CONTENT_ID,
SessionUtils.generateSessionId());
datahandler = dh;
if(dh != null) {
setMimeHeader(HTTPConstants.HEADER_CONTENT_TYPE, dh.getContentType());
javax.activation.DataSource ds = dh.getDataSource();
if (ds instanceof ManagedMemoryDataSource) {
extractFilename((ManagedMemoryDataSource)ds); //and get the filename if appropriate
}
}
}
// fixme: be aware, this may never be called
/**
* On death, we clean up our file.
*
* @throws Throwable if anything went wrong during finalization
*/
protected void finalize() throws Throwable {
dispose();
}
/**
* Get the data handler.
*
* @return the activation <code>DataHandler</code>
*/
public javax.activation.DataHandler getActivationDataHandler() {
return datahandler;
}
/**
* getContentType
*
* @return content type
*/
public String getContentType() {
return getFirstMimeHeader(HTTPConstants.HEADER_CONTENT_TYPE);
}
/**
* Add the specified MIME header, as per JAXM.
*
* @param header
* @param value
*/
public void addMimeHeader(String header, String value) {
mimeHeaders.addHeader(header, value);
}
/**
* Get the specified MIME header.
*
* @param header
*
* @return
*/
public String getFirstMimeHeader(String header) {
String[] values = mimeHeaders.getHeader(header.toLowerCase());
if ((values != null) && (values.length > 0)) {
return values[0];
}
return null;
}
/**
* check if this Part's mimeheaders matches the one passed in.
* TODO: Am not sure about the logic.
*
* @param headers the <code>MimeHeaders</code> to check
* @return true if all header name, values in <code>headers</code> are
* found, false otherwise
*/
public boolean matches(javax.xml.soap.MimeHeaders headers) {
for (Iterator i = headers.getAllHeaders(); i.hasNext();) {
javax.xml.soap.MimeHeader hdr = (javax.xml.soap.MimeHeader) i.next();
String values[] = mimeHeaders.getHeader(hdr.getName());
boolean found = false;
if (values != null) {
for (int j = 0; j < values.length; j++) {
if (!hdr.getValue().equalsIgnoreCase(values[j])) {
continue;
}
found = true;
break;
}
}
if (!found) {
return false;
}
}
return true;
}
public String getContentLocation() {
return getFirstMimeHeader(HTTPConstants.HEADER_CONTENT_LOCATION);
}
public void setContentLocation(String loc) {
setMimeHeader(HTTPConstants.HEADER_CONTENT_LOCATION, loc);
}
public void setContentId(String newCid) {
setMimeHeader(HTTPConstants.HEADER_CONTENT_ID, newCid);
}
public String getContentId() {
return getFirstMimeHeader(HTTPConstants.HEADER_CONTENT_ID);
}
public java.util.Iterator getMatchingMimeHeaders(final String[] match) {
return mimeHeaders.getMatchingHeaders(match);
}
public java.util.Iterator getNonMatchingMimeHeaders(final String[] match) {
return mimeHeaders.getNonMatchingHeaders(match);
}
public Iterator getAllMimeHeaders() {
return mimeHeaders.getAllHeaders();
}
/**
* Changes the first header entry that matches the given name
* to the given value, adding a new header if no existing
* header matches. This method also removes all matching
* headers but the first.
*
* <P>Note that RFC822 headers can only contain US-ASCII
* characters.</P>
* @param name a <CODE>String</CODE> giving the
* name of the header for which to search
* @param value a <CODE>String</CODE> giving the
* value to be set for the header whose name matches the
* given name
* @throws java.lang.IllegalArgumentException if
* there was a problem with the specified mime header name
* or value
*/
public void setMimeHeader(String name, String value) {
mimeHeaders.setHeader(name, value);
}
/** Removes all the MIME header entries. */
public void removeAllMimeHeaders() {
mimeHeaders.removeAllHeaders();
}
/**
* Removes all MIME headers that match the given name.
* @param header - the string name of the MIME
* header/s to be removed
*/
public void removeMimeHeader(String header) {
mimeHeaders.removeHeader(header);
}
/**
* Gets the <CODE>DataHandler</CODE> object for this <CODE>
* AttachmentPart</CODE> object.
* @return the <CODE>DataHandler</CODE> object associated with
* this <CODE>AttachmentPart</CODE> object
* @throws SOAPException if there is
* no data in this <CODE>AttachmentPart</CODE> object
*/
public DataHandler getDataHandler() throws SOAPException {
if(datahandler == null) {
throw new SOAPException(Messages.getMessage("noContent"));
}
return datahandler;
}
/**
* Sets the given <CODE>DataHandler</CODE> object as the
* data handler for this <CODE>AttachmentPart</CODE> object.
* Typically, on an incoming message, the data handler is
* automatically set. When a message is being created and
* populated with content, the <CODE>setDataHandler</CODE>
* method can be used to get data from various data sources into
* the message.
* @param datahandler <CODE>DataHandler</CODE> object to
* be set
* @throws java.lang.IllegalArgumentException if
* there was a problem with the specified <CODE>
* DataHandler</CODE> object
*/
public void setDataHandler(DataHandler datahandler) {
if(datahandler == null) {
throw new java.lang.IllegalArgumentException(
Messages.getMessage("illegalArgumentException00"));
}
this.datahandler = datahandler;
setMimeHeader(HTTPConstants.HEADER_CONTENT_TYPE, datahandler.getContentType());
//now look at the source of the data
javax.activation.DataSource ds = datahandler.getDataSource();
if (ds instanceof ManagedMemoryDataSource) {
//and get the filename if appropriate
extractFilename((ManagedMemoryDataSource)ds);
}
}
/**
* Gets the content of this <CODE>AttachmentPart</CODE> object
* as a Java object. The type of the returned Java object
* depends on (1) the <CODE>DataContentHandler</CODE> object
* that is used to interpret the bytes and (2) the <CODE>
* Content-Type</CODE> given in the header.
*
* <P>For the MIME content types "text/plain", "text/html" and
* "text/xml", the <CODE>DataContentHandler</CODE> object does
* the conversions to and from the Java types corresponding to
* the MIME types. For other MIME types,the <CODE>
* DataContentHandler</CODE> object can return an <CODE>
* InputStream</CODE> object that contains the content data as
* raw bytes.</P>
*
* <P>A JAXM-compliant implementation must, as a minimum,
* return a <CODE>java.lang.String</CODE> object corresponding
* to any content stream with a <CODE>Content-Type</CODE>
* value of <CODE>text/plain</CODE> and a <CODE>
* javax.xml.transform.StreamSource</CODE> object
* corresponding to a content stream with a <CODE>
* Content-Type</CODE> value of <CODE>text/xml</CODE>. For
* those content types that an installed <CODE>
* DataContentHandler</CODE> object does not understand, the
* <CODE>DataContentHandler</CODE> object is required to
* return a <CODE>java.io.InputStream</CODE> object with the
* raw bytes.</P>
* @return a Java object with the content of this <CODE>
* AttachmentPart</CODE> object
* @throws SOAPException if there is no content set
* into this <CODE>AttachmentPart</CODE> object or if there
* was a data transformation error
*/
public Object getContent() throws SOAPException {
if(contentObject != null) {
return contentObject;
}
if(datahandler == null) {
throw new SOAPException(Messages.getMessage("noContent"));
}
javax.activation.DataSource ds = datahandler.getDataSource();
InputStream is = null;
try {
is = ds.getInputStream();;
} catch (java.io.IOException io) {
log.error(Messages.getMessage("javaIOException00"), io);
throw new SOAPException(io);
}
if (ds.getContentType().equals("text/plain")) {
try {
byte[] bytes = new byte[is.available()];
IOUtils.readFully(is, bytes);
return new String(bytes);
} catch (java.io.IOException io) {
log.error(Messages.getMessage("javaIOException00"), io);
throw new SOAPException(io);
}
} else if (ds.getContentType().equals("text/xml")) {
return new StreamSource(is);
} else if (ds.getContentType().equals("image/gif") ||
ds.getContentType().equals("image/jpeg")) {
try {
return ImageIOFactory.getImageIO().loadImage(is);
} catch (Exception ex) {
log.error(Messages.getMessage("javaIOException00"), ex);
throw new SOAPException(ex);
}
}
return is;
}
/**
* Sets the content of this attachment part to that of the
* given <CODE>Object</CODE> and sets the value of the <CODE>
* Content-Type</CODE> header to the given type. The type of the
* <CODE>Object</CODE> should correspond to the value given for
* the <CODE>Content-Type</CODE>. This depends on the particular
* set of <CODE>DataContentHandler</CODE> objects in use.
* @param object the Java object that makes up
* the content for this attachment part
* @param contentType the MIME string that
* specifies the type of the content
* @throws java.lang.IllegalArgumentException if
* the contentType does not match the type of the content
* object, or if there was no <CODE>
* DataContentHandler</CODE> object for this content
* object
* @see #getContent() getContent()
*/
public void setContent(Object object, String contentType) {
ManagedMemoryDataSource source = null;
setMimeHeader(HTTPConstants.HEADER_CONTENT_TYPE, contentType);
if (object instanceof String) {
try {
String s = (String) object;
java.io.ByteArrayInputStream bais =
new java.io.ByteArrayInputStream(s.getBytes());
source = new ManagedMemoryDataSource(bais,
ManagedMemoryDataSource.MAX_MEMORY_DISK_CACHED,
contentType, true);
extractFilename(source);
datahandler = new DataHandler(source);
contentObject = object;
return;
} catch (java.io.IOException io) {
log.error(Messages.getMessage("javaIOException00"), io);
throw new java.lang.IllegalArgumentException(
Messages.getMessage("illegalArgumentException00"));
}
} else if (object instanceof java.io.InputStream) {
try {
source = new ManagedMemoryDataSource((java.io.InputStream) object,
ManagedMemoryDataSource.MAX_MEMORY_DISK_CACHED,
contentType, true);
extractFilename(source);
datahandler = new DataHandler(source);
contentObject = null; // the stream has been consumed
return;
} catch (java.io.IOException io) {
log.error(Messages.getMessage("javaIOException00"), io);
throw new java.lang.IllegalArgumentException(Messages.getMessage
("illegalArgumentException00"));
}
} else if (object instanceof StreamSource) {
try {
source = new ManagedMemoryDataSource(((StreamSource)object).getInputStream(),
ManagedMemoryDataSource.MAX_MEMORY_DISK_CACHED,
contentType, true);
extractFilename(source);
datahandler = new DataHandler(source);
contentObject = null; // the stream has been consumed
return;
} catch (java.io.IOException io) {
log.error(Messages.getMessage("javaIOException00"), io);
throw new java.lang.IllegalArgumentException(Messages.getMessage
("illegalArgumentException00"));
}
} else {
throw new java.lang.IllegalArgumentException(
Messages.getMessage("illegalArgumentException00"));
}
}
/**
* Clears out the content of this <CODE>
* AttachmentPart</CODE> object. The MIME header portion is left
* untouched.
*/
public void clearContent() {
datahandler = null;
contentObject = null;
}
/**
* Returns the number of bytes in this <CODE>
* AttachmentPart</CODE> object.
* @return the size of this <CODE>AttachmentPart</CODE> object
* in bytes or -1 if the size cannot be determined
* @throws SOAPException if the content of this
* attachment is corrupted of if there was an exception
* while trying to determine the size.
*/
public int getSize() throws SOAPException {
if (datahandler == null) {
return 0;
}
ByteArrayOutputStream bout = new ByteArrayOutputStream();
try {
datahandler.writeTo(bout);
} catch (java.io.IOException ex) {
log.error(Messages.getMessage("javaIOException00"), ex);
throw new SOAPException(Messages.getMessage("javaIOException01", ex.getMessage()), ex);
}
return bout.size();
}
/**
* Gets all the values of the header identified by the given
* <CODE>String</CODE>.
* @param name the name of the header; example:
* "Content-Type"
* @return a <CODE>String</CODE> array giving the value for the
* specified header
* @see #setMimeHeader(java.lang.String, java.lang.String) setMimeHeader(java.lang.String, java.lang.String)
*/
public String[] getMimeHeader(String name) {
return mimeHeaders.getHeader(name);
}
/**
* Content ID.
*
* @return the contentId reference value that should be used directly
* as an href in a SOAP element to reference this attachment.
* <B>Not part of JAX-RPC, JAX-M, SAAJ, etc. </B>
*/
public String getContentIdRef() {
return Attachments.CIDprefix + getContentId();
}
/**
* Maybe add file name to the attachment.
*
* @param source the source of the data
*/
private void extractFilename(ManagedMemoryDataSource source) {
//check for there being a file
if(source.getDiskCacheFile()!=null) {
String path = source.getDiskCacheFile().getAbsolutePath();
setAttachmentFile(path);
}
}
/**
* Set the filename of this attachment part.
*
* @param path the new file path
*/
protected void setAttachmentFile(String path) {
attachmentFile=path;
}
/**
* Detach the attachment file from this class, so it is not cleaned up.
* This has the side-effect of making subsequent calls to
* getAttachmentFile() return <code>null</code>.
*/
public void detachAttachmentFile() {
attachmentFile=null;
}
/**
* Get the filename of this attachment.
*
* @return the filename or null for an uncached file
*/
public String getAttachmentFile() {
return attachmentFile;
}
/**
* when an attachment part is disposed, any associated files
* are deleted, and the datahandler itself nulled. The object
* is no longer completely usable, at this point
*/
public synchronized void dispose() {
if (attachmentFile != null) {
javax.activation.DataSource ds = datahandler.getDataSource();
if (ds instanceof ManagedMemoryDataSource) {
((ManagedMemoryDataSource) ds).delete(); //and delete the file
} else {
File f = new File(attachmentFile);
//no need to check for existence here.
f.delete();
}
//set the filename to null to stop repeated use
setAttachmentFile(null);
}
//clean up the datahandler, as it will have been
//invalidated if it was bound to a file; if it wasnt
//we get to release memory anyway
datahandler = null;
}
}
|
