/*
* Created on 21-Apr-2004
*/
package ca.uhn.hl7v2.protocol.impl;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import ca.uhn.hl7v2.AcknowledgmentCode;
import ca.uhn.hl7v2.HL7Exception;
import ca.uhn.hl7v2.HapiContext;
import ca.uhn.hl7v2.Version;
import ca.uhn.hl7v2.app.DefaultApplication;
import ca.uhn.hl7v2.model.GenericMessage;
import ca.uhn.hl7v2.model.Message;
import ca.uhn.hl7v2.model.Segment;
import ca.uhn.hl7v2.parser.GenericParser;
import ca.uhn.hl7v2.parser.Parser;
import ca.uhn.hl7v2.protocol.*;
import ca.uhn.hl7v2.util.DeepCopy;
import ca.uhn.hl7v2.util.Terser;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* <p>A default implementation of <code>ApplicationRouter</code> </p>
*
* @author <a href="mailto:bryan.tripp@uhn.on.ca">Bryan Tripp</a>
* @version $Revision: 1.2 $ updated on $Date: 2009-09-01 00:22:23 $ by $Author: jamesagnew $
*/
public class ApplicationRouterImpl implements ApplicationRouter {
/**
* The default acknowledgment code used in MSA-1 when generating a NAK (negative ACK) message
* as a result of a processing exception.
*/
public static final AcknowledgmentCode DEFAULT_EXCEPTION_ACKNOWLEDGEMENT_CODE = AcknowledgmentCode.AE;
private static final Logger log = LoggerFactory.getLogger(ApplicationRouterImpl.class);
/**
* Key under which raw message text is stored in metadata Map sent to
* <code>ReceivingApplication</code>s.
*/
public static String RAW_MESSAGE_KEY = MetadataKeys.IN_RAW_MESSAGE;
private List<Binding> myBindings;
private Parser myParser;
private ReceivingApplicationExceptionHandler myExceptionHandler;
private HapiContext myContext;
/**
* Creates an instance that uses a <code>GenericParser</code>.
*/
@Deprecated
public ApplicationRouterImpl() {
this(new GenericParser());
}
/**
* Creates an instance that uses the specified <code>Parser</code>.
*
* @param theParser the parser used for converting between Message and
* Transportable
*/
public ApplicationRouterImpl(Parser theParser) {
this(theParser.getHapiContext(), theParser);
}
public ApplicationRouterImpl(HapiContext theContext) {
this(theContext, theContext.getGenericParser());
}
/**
* Creates an instance that uses the specified <code>Parser</code>.
*
* @param theContext HAPI context
* @param theParser the parser used for converting between Message and
* Transportable
*/
public ApplicationRouterImpl(HapiContext theContext, Parser theParser) {
init(theParser);
myContext = theContext;
}
private void init(Parser theParser) {
myBindings = new ArrayList<Binding>(20);
myParser = theParser;
}
/**
* @see ca.uhn.hl7v2.protocol.ApplicationRouter#processMessage(ca.uhn.hl7v2.protocol.Transportable)
*/
public Transportable processMessage(Transportable theMessage) throws HL7Exception {
String[] result = processMessage(theMessage.getMessage(), theMessage.getMetadata());
Transportable response = new TransportableImpl(result[0]);
if (result[1] != null) {
response.getMetadata().put(METADATA_KEY_MESSAGE_CHARSET, result[1]);
}
return response;
}
/**
* Processes an incoming message string and returns the response message string.
* Message processing consists of parsing the message, finding an appropriate
* Application and processing the message with it, and encoding the response.
* Applications are chosen from among those registered using
* <code>bindApplication</code>.
*
* @return {text, charset}
*/
private String[] processMessage(String incomingMessageString, Map<String, Object> theMetadata) throws HL7Exception {
Logger rawOutbound = LoggerFactory.getLogger("ca.uhn.hl7v2.raw.outbound");
Logger rawInbound = LoggerFactory.getLogger("ca.uhn.hl7v2.raw.inbound");
// TODO: add a way to register an application handler and
// invoke it any time something goes wrong
log.debug("ApplicationRouterImpl got message: {}", incomingMessageString);
rawInbound.debug(incomingMessageString);
Message incomingMessageObject = null;
String outgoingMessageString = null;
String outgoingMessageCharset = null;
try {
incomingMessageObject = myParser.parse(incomingMessageString);
Terser inTerser = new Terser(incomingMessageObject);
theMetadata.put(MetadataKeys.IN_MESSAGE_CONTROL_ID, inTerser.get("/.MSH-10"));
} catch (HL7Exception e) {
try {
outgoingMessageString = logAndMakeErrorMessage(e, myParser.getCriticalResponseData(incomingMessageString), myParser, myParser.getEncoding(incomingMessageString));
} catch (HL7Exception e2) {
outgoingMessageString = null;
}
if (myExceptionHandler != null) {
outgoingMessageString = myExceptionHandler.processException(incomingMessageString, theMetadata, outgoingMessageString, e);
if (outgoingMessageString == null) {
throw new HL7Exception("Application exception handler may not return null");
}
}
}
// At this point, no exception has occurred and the message is processed normally
if (outgoingMessageString == null) {
try {
//optionally check integrity of parse
String check = System.getProperty("ca.uhn.hl7v2.protocol.impl.check_parse");
if (check != null && check.equals("TRUE")) {
ParseChecker.checkParse(incomingMessageString, incomingMessageObject, myParser);
}
//message validation (in terms of optionality, cardinality) would go here ***
ReceivingApplication app = findApplication(incomingMessageObject);
theMetadata.put(RAW_MESSAGE_KEY, incomingMessageString);
log.debug("Sending message to application: {}", app.toString());
Message response = app.processMessage(incomingMessageObject, theMetadata);
//Here we explicitly use the same encoding as that of the inbound message - this is important with GenericParser, which might use a different encoding by default
outgoingMessageString = myParser.encode(response, myParser.getEncoding(incomingMessageString));
Terser t = new Terser(response);
outgoingMessageCharset = t.get(METADATA_KEY_MESSAGE_CHARSET);
} catch (Exception e) {
outgoingMessageString = handleProcessMessageException(incomingMessageString, theMetadata, incomingMessageObject, e);
} catch (Error e) {
log.debug("Caught runtime exception of type {}, going to wrap it as HL7Exception and handle it", e.getClass());
HL7Exception wrapped = new HL7Exception(e);
outgoingMessageString = handleProcessMessageException(incomingMessageString, theMetadata, incomingMessageObject, wrapped);
}
}
log.debug("ApplicationRouterImpl sending message: {}", outgoingMessageString);
rawOutbound.debug(outgoingMessageString);
return new String[]{outgoingMessageString, outgoingMessageCharset};
}
private String handleProcessMessageException(String incomingMessageString, Map<String, Object> theMetadata, Message incomingMessageObject, Exception e) throws HL7Exception {
String outgoingMessageString;
Segment inHeader = incomingMessageObject != null ? (Segment) incomingMessageObject.get("MSH") : null;
outgoingMessageString = logAndMakeErrorMessage(e, inHeader, myParser, myParser.getEncoding(incomingMessageString));
if (outgoingMessageString != null && myExceptionHandler != null) {
outgoingMessageString = myExceptionHandler.processException(incomingMessageString, theMetadata, outgoingMessageString, e);
}
return outgoingMessageString;
}
/**
* @see ca.uhn.hl7v2.protocol.ApplicationRouter#hasActiveBinding(ca.uhn.hl7v2.protocol.ApplicationRouter.AppRoutingData)
*/
public boolean hasActiveBinding(AppRoutingData theRoutingData) {
boolean result = false;
ReceivingApplication app = findDestination(null, theRoutingData);
if (app != null) {
result = true;
}
return result;
}
/**
* @param theMessage message for which a destination is looked up
* @param theRoutingData routing data
* @return the application from the binding with a WILDCARD match, if one exists
*/
private ReceivingApplication findDestination(Message theMessage, AppRoutingData theRoutingData) {
ReceivingApplication result = null;
for (int i = 0; i < myBindings.size() && result == null; i++) {
Binding binding = myBindings.get(i);
if (matches(theRoutingData, binding.routingData) && binding.active) {
if (theMessage == null || binding.application.canProcess(theMessage)) {
result = binding.application;
}
}
}
return result;
}
/**
* @param theRoutingData routing data
* @return the binding with an EXACT match on routing data if one exists
*/
private Binding findBinding(AppRoutingData theRoutingData) {
Binding result = null;
for (int i = 0; i < myBindings.size() && result == null; i++) {
Binding binding = myBindings.get(i);
if (theRoutingData.equals(binding.routingData)) {
result = binding;
}
}
return result;
}
/**
* @see ca.uhn.hl7v2.protocol.ApplicationRouter#bindApplication(
*ca.uhn.hl7v2.protocol.ApplicationRouter.AppRoutingData, ca.uhn.hl7v2.protocol.ReceivingApplication)
*/
public void bindApplication(AppRoutingData theRoutingData, ReceivingApplication theApplication) {
Binding binding = new Binding(theRoutingData, true, theApplication);
myBindings.add(binding);
}
/**
* @see ca.uhn.hl7v2.protocol.ApplicationRouter#disableBinding(ca.uhn.hl7v2.protocol.ApplicationRouter.AppRoutingData)
*/
public void disableBinding(AppRoutingData theRoutingData) {
Binding b = findBinding(theRoutingData);
if (b != null) {
b.active = false;
}
}
/**
* @see ca.uhn.hl7v2.protocol.ApplicationRouter#enableBinding(ca.uhn.hl7v2.protocol.ApplicationRouter.AppRoutingData)
*/
public void enableBinding(AppRoutingData theRoutingData) {
Binding b = findBinding(theRoutingData);
if (b != null) {
b.active = true;
}
}
/**
* @see ca.uhn.hl7v2.protocol.ApplicationRouter#getParser()
*/
public Parser getParser() {
return myParser;
}
/**
* {@inheritDoc}
*/
public void setExceptionHandler(ReceivingApplicationExceptionHandler theExceptionHandler) {
this.myExceptionHandler = theExceptionHandler;
}
/**
* @param theMessageData routing data related to a particular message
* @param theReferenceData routing data related to a binding, which may include
* wildcards
* @return true if the message data is consist with the reference data, ie all
* values either match or are wildcards in the reference
*/
public static boolean matches(AppRoutingData theMessageData,
AppRoutingData theReferenceData) {
boolean result = false;
if (matches(theMessageData.getMessageType(), theReferenceData.getMessageType())
&& matches(theMessageData.getTriggerEvent(), theReferenceData.getTriggerEvent())
&& matches(theMessageData.getProcessingId(), theReferenceData.getProcessingId())
&& matches(theMessageData.getVersion(), theReferenceData.getVersion())) {
result = true;
}
return result;
}
//support method for matches(AppRoutingData theMessageData, AppRoutingData theReferenceData)
private static boolean matches(String theMessageData, String theReferenceData) {
boolean result = false;
String messageData = theMessageData;
if (messageData == null) {
messageData = "";
}
if (messageData.equals(theReferenceData) ||
theReferenceData.equals("*") ||
Pattern.matches(theReferenceData, messageData)) {
result = true;
}
return result;
}
/**
* Returns the first Application that has been bound to messages of this type.
*/
private ReceivingApplication findApplication(Message theMessage) throws HL7Exception {
Terser t = new Terser(theMessage);
AppRoutingData msgData =
new AppRoutingDataImpl(t.get("/MSH-9-1"), t.get("/MSH-9-2"), t.get("/MSH-11-1"), t.get("/MSH-12"));
ReceivingApplication app = findDestination(theMessage, msgData);
//have to send back an application reject if no apps available to process
if (app == null) {
app = new DefaultApplication();
}
return app;
}
/**
* A structure for bindings between routing data and applications.
*/
private static class Binding {
public AppRoutingData routingData;
public boolean active;
public ReceivingApplication application;
public Binding(AppRoutingData theRoutingData, boolean isActive, ReceivingApplication theApplication) {
routingData = theRoutingData;
active = isActive;
application = theApplication;
}
}
/**
* Logs the given exception and creates an error message to send to the
* remote system.
*
* @param e exception
* @param inHeader MSH segment of incoming message
* @param p parser to be used
* @param encoding The encoding for the error message. If <code>null</code>, uses
* default encoding
* @return error message as string
* @throws ca.uhn.hl7v2.HL7Exception if an error occured during generation of the error message
*/
public String logAndMakeErrorMessage(Exception e, Segment inHeader,
Parser p, String encoding) throws HL7Exception {
switch (myContext.getServerConfiguration().getApplicationExceptionPolicy()) {
case DO_NOT_RESPOND:
log.error("Application exception detected, not going to send a response back to the client", e);
return null;
case DEFAULT:
default:
log.error("Attempting to send error message to remote system.", e);
break;
}
HL7Exception hl7e = e instanceof HL7Exception ?
(HL7Exception) e :
new HL7Exception(e.getMessage(), e);
try {
Message out = hl7e.getResponseMessage();
if (out == null) {
Message in = getInMessage(inHeader);
out = in.generateACK(DEFAULT_EXCEPTION_ACKNOWLEDGEMENT_CODE, hl7e);
}
return encoding != null ? p.encode(out, encoding) : p.encode(out);
} catch (IOException ioe) {
throw new HL7Exception(
"IOException creating error response message: "
+ ioe.getMessage());
}
}
private Message getInMessage(Segment inHeader) throws HL7Exception, IOException {
Message in;
if (inHeader != null) {
in = inHeader.getMessage();
// the message may be a dummy message, whose MSH segment is incomplete
DeepCopy.copy(inHeader, (Segment) in.get("MSH"));
} else {
in = Version.highestAvailableVersionOrDefault().newGenericMessage(myParser.getFactory());
((GenericMessage) in).initQuickstart("ACK", "", "");
}
return in;
}
}