/*
* 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 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.Map.Entry;
import java.util.Vector;
import javax.activation.DataSource;
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;
import iaik.xml.crypto.utils.URI;
/**
* 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();
}
final 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();
}
final 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;
}
final Vector entry = (Vector) attachments.get(referenceId);
if (entry == null) {
return null;
}
final 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;
}
final String referenceId = uri.getPath();
final Vector entry = (Vector) attachments.get(referenceId);
if (entry == null) {
return null;
}
InputStream attachmentIs = null;
final Object object = entry.get(1);
if (object instanceof DataSource) {
try {
attachmentIs = ((DataSource) object).getInputStream();
} catch (final 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) {
final 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;
}
final Iterator iterator = attachments.entrySet().iterator();
while (iterator.hasNext()) {
final Entry hmEntry = (Entry) iterator.next();
final Vector entry = (Vector) hmEntry.getValue();
final Object object = entry.get(1);
if (object instanceof DataSource) {
final DataSource mmds = (DataSource) object;
try {
if (mmds != null) {
final 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 (final IOException e) {
// ok to do nothing here
}
} else if (object instanceof InputStream) {
final InputStream is = (InputStream) object;
try {
if (is != null) {
is.close();
}
final String tempFile = (String) entry.get(2);
if (tempFile != null) {
final File f = new File(tempFile);
f.delete();
}
} catch (final 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;
final Vector entity = FindResolvedEntity(uri);
if (entity != null) {
final 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();
}
final Vector entity = new Vector();
entity.add(contentBytes);
entity.add(contentType);
resolvedEntities.put(uri, entity);
}
}