/*
* Copyright 2003 Federal Chancellery Austria
* MOA-SPSS has been developed in a cooperation between BRZ, the Federal
* Chancellery Austria - ICT staff unit, and Graz University of Technology.
*
* Licensed under the EUPL, Version 1.1 or - as soon they will be approved by
* the European Commission - subsequent versions of the EUPL (the "Licence");
* You may not use this work except in compliance with the Licence.
* You may obtain a copy of the Licence at:
* http://www.osor.eu/eupl/
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the Licence is distributed on an "AS IS" basis,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the Licence for the specific language governing permissions and
* limitations under the Licence.
*
* This product combines work with different licenses. See the "NOTICE" text
* file for details on the various modules and licenses.
* The "NOTICE" text file is part of the distribution. Any derivative works
* that you distribute must include a readable copy of the "NOTICE" text file.
*/
package at.gv.egovernment.moa.spss.server.transaction;
import iaik.xml.crypto.utils.URI;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.security.cert.X509Certificate;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Vector;
import javax.activation.DataSource;
import java.util.Map.Entry;
import org.w3c.dom.Element;
import at.gv.egovernment.moa.spss.MOAApplicationException;
import at.gv.egovernment.moa.spss.server.config.ConfigurationProvider;
import at.gv.egovernment.moaspss.logging.Logger;
/**
* Contains information about the current request.
*
* @author Stefan Knirsch
* @author Patrick Peck
*/
public class TransactionContext {
/** The client certificate. */
private X509Certificate[] clientCertificate = null;
/** The transaction ID. */
private String transactionID = null;
/** The name of the request. */
private String requestName = null;
/** The SOAP embedded request */
private Element request;
/** The response which is to embed by SOAP */
private Element response;
/** The map pointing to SOAP attachments needed by the request. */
private HashMap attachments = null;
/** The map containing cashed entities used in DataObjectFactory. */
private HashMap resolvedEntities = null;
/** The configuration to use throughout the request. */
private ConfigurationProvider configuration = null;
/**
* Create a TransactionContext
object.
*
* @param transactionID A unique ID for this TransactionContext
.
* @param clientCertificate The client certificate chain.
* @param configuration The MOA configuration to use for this transaction.
*/
public TransactionContext(
String transactionID,
X509Certificate[] clientCertificate,
ConfigurationProvider configuration) {
this.transactionID = transactionID;
this.clientCertificate = clientCertificate;
this.configuration = configuration;
}
/**
* Create a TransactionContext
object.
*
* @param transactionID A unique ID for this TransactionContext
.
* @param clientCertificate The client certificate chain.
* @param configuration The MOA configuration to use for this transaction.
* @param attachments to use for this transaction.
*/
public TransactionContext(
String transactionID,
X509Certificate[] clientCertificate,
ConfigurationProvider configuration,
Element request,
HashMap attachments) {
this.transactionID = transactionID;
this.clientCertificate = clientCertificate;
this.configuration = configuration;
this.request = request;
this.attachments = attachments;
}
/**
* Returns the client certificate.
*
* @return The client certificate chain, if SSL client authentication has been
* configured in the web server and has been used by the client. The 0th
* element of the array contains the client certificate. null
* otherwise.
*/
public X509Certificate[] getClientCertificate() {
return clientCertificate;
}
/**
* Returns the unique transaction ID.
*
* @return The transaction ID.
*/
public String getTransactionID() {
return transactionID;
}
/**
* Returns the name of the request.
*
* @return The name of the request.
*/
public String getRequestName() {
return requestName;
}
/**
* Sets the name of the request.
*
* @param requestName The request name to set.
*/
public void setRequestName(String requestName) {
this.requestName = requestName;
}
/**
* Sets the the request.
*
* @param request The request to set.
*/
public void setRequest(Element request) {
this.request = request;
}
/**
* Returns the request.
*
* @return The request.
*/
public Element getRequest() {
return request;
}
/**
* Sets the the response.
*
* @param response The response to set.
*/
public void setResponse(Element response) {
this.response = response;
}
/**
* Returns the response.
*
* @return The response.
*/
public Element getResponse() {
return response;
}
/**
* Adds an attachment to the transactions list of SOAP attachments.
*
* @param referenceId Identification value for the SOAP attachment.
* @param contentType MIME type of the SOAP attachment.
* @param is Handle to the ManagedMemoryDataSource of the SOAP attachment.
*/
public void addAttachment(String referenceId, String contentType, DataSource is) {
if (this.attachments == null) this.attachments = new HashMap();
Vector entry = new Vector(2);
entry.add(contentType);
entry.add(is);
this.attachments.put(referenceId, entry);
}
/**
* Adds an attachment to the transactions list of SOAP attachments.
*
* @param referenceId Identification value for the SOAP attachment.
* @param contentType MIME type of the SOAP attachment.
* @param is Handle to the InputStream of the SOAP attachment.
* @param filename Filename of the temporary file the InputStream belongs to
*/
public void addAttachment(String referenceId, String contentType, InputStream is, String filename) {
if (this.attachments == null) this.attachments = new HashMap();
Vector entry = new Vector(3);
entry.add(contentType);
entry.add(is);
entry.add(filename);
this.attachments.put(referenceId, entry);
}
/**
* Returns the ManagedMemoryDataSource to a specific SOAP attachment identified by referenceId.
*
* @param referenceId Identification value for the SOAP attachment.
*/
public DataSource getAttachment(String referenceId) {
if (attachments==null) {
return null;
}
Vector entry = (Vector) attachments.get(referenceId);
if (entry==null) {
return null;
}
Object object = entry.get(1);
if (object instanceof DataSource) {
return (DataSource) object;
} else {
return null;
}
}
/**
* Returns the InputStream to a specific SOAP attachment identified by uri.
*
* @param uri Identification value for the SOAP attachment.
*/
public InputStream getAttachmentInputStream(URI uri) throws MOAApplicationException {
if (attachments==null) {
return null;
}
String referenceId = uri.getPath();
Vector entry = (Vector) attachments.get(referenceId);
if (entry==null) {
return null;
}
InputStream attachmentIs = null;
Object object = entry.get(1);
if (object instanceof DataSource) {
try {
attachmentIs = (InputStream) ( ((DataSource)object).getInputStream());
} catch (IOException e) {
throw new MOAApplicationException("2208", new Object[] { uri }, e);
}
} else {
attachmentIs = (InputStream) object;
}
return attachmentIs;
//If we would return the whole mmds: return (ManagedMemoryDataSource) entry.get(1);
}
/**
* Returns the content type to a specific SOAP attachment identified by referenceId.
*
* @param referenceId Identification value for the SOAP attachment.
*/
public String getAttachmentContentType(String referenceId) {
Vector entry = (Vector) attachments.get(referenceId);
if (entry==null) {
return null;
}
return (String) entry.get(0);
}
/**
* Delete the temporary attachment files.
*/
public void cleanAttachmentCache() {
if (null==attachments) {
return;
}
Iterator iterator = attachments.entrySet().iterator();
while (iterator.hasNext()) {
Entry hmEntry = (Entry) iterator.next();
Vector entry = (Vector)hmEntry.getValue();
Object object = entry.get(1);
if (object instanceof DataSource) {
DataSource mmds = (DataSource)object;
try {
if (mmds!=null) {
InputStream is = mmds.getInputStream();
if (is!=null) is.close();
// not available in Axis 1.0 to 1.1
// File f = mmds.getDiskCacheFile();
// if (f!=null) f.delete();
if(mmds instanceof DeleteableDataSource) {
((DeleteableDataSource)mmds).delete();
}
//mmds..delete();
}
} catch (IOException e) {
// ok to do nothing here
}
} else if (object instanceof InputStream) {
InputStream is = (InputStream)object;
try {
if (is!=null) is.close();
String tempFile = (String) entry.get(2);
if (tempFile!=null){
File f = new File(tempFile);
f.delete();
}
} catch (IOException e) {
// ok to do nothing here
}
}
}
}
/**
* Returns the ConfigurationProvider
associated with this
* transaction.
*
* @return The ConfigurationProvider associated with this transaction.
*/
public ConfigurationProvider getConfiguration() {
return configuration;
}
/**
* Search an uri content in cashed map.
*
* @param uri The value to look for.
* @return If found the cached entity, null otherwise.
*/
public Vector FindResolvedEntity(String uri) {
if (resolvedEntities==null) return null;
return (Vector) resolvedEntities.get(uri);
}
/**
* Get a new InputStream of a cached entity.
*
* @param uri The value to look for.
* @return A new InputStream of the cached entity.
*/
public InputStream ResolveURI(String uri) {
InputStream is = null;
Vector entity = FindResolvedEntity(uri);
if (entity!=null) {
byte[] contentBytes = (byte[]) entity.get(0);
if (contentBytes!=null) {
is = new ByteArrayInputStream(contentBytes);
}
}
return is;
}
/**
* Put a read entity (supplement, detached content, data object) on
* transactions entity cash, to prevent repeated reading on slower channels.
*
* @param uri A transaction-wide unique URI used as key of the entity cash
* table.
* @param contentBytes The cached content belonging to the uri.
* @param contentType If known, the MIME-type of the cashed content.
*/
public void PutResolvedEntity(String uri, byte[] contentBytes, String contentType) {
Logger.trace(" storing uri content of uri \"" + uri + "\" for future references");
if (resolvedEntities==null) resolvedEntities = new HashMap();
Vector entity = new Vector();
entity.add(contentBytes);
entity.add(contentType);
resolvedEntities.put(uri, entity);
}
}