Performs the responding role in a message exchange (i.e receiver of the first message, * sender of the response; analagous to the server in a client-server interaction), according * to HL7's original mode processing rules.
*At the time of writing, enhanced mode, two-phase reply, continuation messages, and * batch processing are unsupported.
* @author Bryan Tripp */ public class Responder { private static final HapiLog log = HapiLogFactory.getHapiLog(Responder.class); //private LowerLayerProtocol llp; private Parser parser; private ArrayList apps; private HL7Reader in; private HL7Writer out; private BufferedWriter checkWriter = null; /** * Creates a new instance of Responder that optionally validates parsing of incoming * messages using a system property. If the system property *ca.uhn.hl7v2.app.checkparse equals "true", parse integrity is checked,
* i.e. each message is re-encoded and differences between the received message text
* and the re-encoded text are written to the file registerApplication. The Parser is obtained from the Connection
* associated with this Responder.
*/
protected String processMessage(String incomingMessageString) throws HL7Exception {
HapiLog rawOutbound = HapiLogFactory.getHapiLog("ca.uhn.hl7v2.raw.outbound");
HapiLog rawInbound = HapiLogFactory.getHapiLog("ca.uhn.hl7v2.raw.inbound");
log.info( "Responder got message: " + incomingMessageString );
rawInbound.info(incomingMessageString);
Message incomingMessageObject = null;
String outgoingMessageString = null;
try {
incomingMessageObject = parser.parse(incomingMessageString);
}
catch (HL7Exception e) {
try {
outgoingMessageString = logAndMakeErrorMessage(e, parser.getCriticalResponseData(incomingMessageString), parser, parser.getEncoding(incomingMessageString));
} catch (HL7Exception e2) {
outgoingMessageString = null;
}
for (Object app : apps) {
if (app instanceof ApplicationExceptionHandler) {
ApplicationExceptionHandler aeh = (ApplicationExceptionHandler) app;
outgoingMessageString = aeh.processException(incomingMessageString, outgoingMessageString, e);
}
}
}
if (outgoingMessageString == null) {
try {
//optionally check integrity of parse
try {
if (checkWriter != null)
checkParse(incomingMessageString, incomingMessageObject, parser);
}
catch (IOException e) {
log.error( "Unable to write parse check results to file", e );
}
//message validation (in terms of optionality, cardinality) would go here ***
Application app = findApplication(incomingMessageObject);
Message response = app.processMessage(incomingMessageObject);
//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 = parser.encode(response, parser.getEncoding(incomingMessageString));
}
catch (Exception e) {
outgoingMessageString = logAndMakeErrorMessage(e, (Segment) incomingMessageObject.get("MSH"), parser, parser.getEncoding(incomingMessageString));
}
}
log.info( "Responder sending message: " + outgoingMessageString );
rawOutbound.info(outgoingMessageString);
return outgoingMessageString;
}
/**
* Returns the first Application that has been registered, which can process the given
* Message (according to its canProcess() method).
*/
private Application findApplication(Message message) {
int c = 0;
Application app = null;
while (app == null && c < this.apps.size()) {
Application a = (Application) this.apps.get(c++);
if (a.canProcess(message))
app = a;
}
//have to send back an application reject of no apps available to process
if (app == null)
app = new DefaultApplication();
return app;
}
/**
* Encodes the given message and compares it to the given string. Any differences
* are noted in the file [hapi.home]/parse_check.txt. Ignores extra field delimiters.
*/
private void checkParse(String originalMessageText, Message parsedMessage, Parser parser)
throws HL7Exception, IOException {
log.info("ca.uhn.hl7v2.app.Responder is checking parse integrity (turn this off if you are not testing)");
String newMessageText = parser.encode(parsedMessage);
checkWriter.write("******************* Comparing Messages ****************\r\n");
checkWriter.write("Original: " + originalMessageText + "\r\n");
checkWriter.write("Parsed and Encoded: " + newMessageText + "\r\n");
if (!originalMessageText.equals(newMessageText)) {
//check each segment
StringTokenizer tok = new StringTokenizer(originalMessageText, "\r");
ArrayList one = new ArrayList();
while (tok.hasMoreTokens()) {
String seg = tok.nextToken();
if (seg.length() > 4)
one.add(seg);
}
tok = new StringTokenizer(newMessageText, "\r");
ArrayList two = new ArrayList();
while (tok.hasMoreTokens()) {
String seg = tok.nextToken();
if (seg.length() > 4)
two.add(stripExtraDelimiters(seg, seg.charAt(3)));
}
if (one.size() != two.size()) {
checkWriter.write("Warning: inbound and parsed messages have different numbers of segments: \r\n");
checkWriter.write("Original: " + originalMessageText + "\r\n");
checkWriter.write("Parsed: " + newMessageText + "\r\n");
}
else {
//check each segment
for (int i = 0; i < one.size(); i++) {
String origSeg = (String) one.get(i);
String newSeg = (String) two.get(i);
if (!origSeg.equals(newSeg)) {
checkWriter.write("Warning: inbound and parsed message segment differs: \r\n");
checkWriter.write("Original: " + origSeg + "\r\n");
checkWriter.write("Parsed: " + newSeg + "\r\n");
}
}
}
}
else {
checkWriter.write("No differences found\r\n");
}
checkWriter.write("******************** End Comparison ******************\r\n");
checkWriter.flush();
}
/**
* Removes unecessary delimiters from the end of a field or segment.
* This is cut-and-pasted from PipeParser (just making it public in
* PipeParser would kind of cloud the purpose of PipeParser).
*/
private static String stripExtraDelimiters(String in, char delim) {
char[] chars = in.toCharArray();
//search from back end for first occurance of non-delimiter ...
int c = chars.length - 1;
boolean found = false;
while (c >= 0 && !found) {
if (chars[c--] != delim)
found = true;
}
String ret = "";
if (found)
ret = String.valueOf(chars, 0, c + 2);
return ret;
}
/**
* Logs the given exception and creates an error message to send to the
* remote system.
*
* @param encoding The encoding for the error message. If null, uses default encoding
*/
public static String logAndMakeErrorMessage(Exception e, Segment inHeader, Parser p, String encoding) throws HL7Exception {
log.error( "Attempting to send error message to remote system.", e);
// create error message ...
String errorMessage = null;
try {
Message out = DefaultApplication.makeACK(inHeader);
Terser t = new Terser(out);
//copy required data from incoming message ...
try {
t.set("/MSH-10", MessageIDGenerator.getInstance().getNewID());
}
catch (IOException ioe) {
throw new HL7Exception("Problem creating error message ID: " + ioe.getMessage());
}
//populate MSA ...
t.set("/MSA-1", "AE"); //should this come from HL7Exception constructor?
t.set("/MSA-2", Terser.get(inHeader, 10, 0, 1, 1));
String excepMessage = e.getMessage();
if (excepMessage != null)
t.set("/MSA-3", excepMessage.substring(0, Math.min(80, excepMessage.length())));
/* Some earlier ACKs don't have ERRs, but I think we'll change this within HAPI
so that there is a single ACK for each version (with an ERR). */
//see if it's an HL7Exception (so we can get specific information) ...
if (e.getClass().equals(HL7Exception.class)) {
Segment err = (Segment) out.get("ERR");
// ((HL7Exception) e).populate(err); // FIXME: this is broken, it relies on the database in a place where it's not available
}
else {
t.set("/ERR-1-4-1", "207");
t.set("/ERR-1-4-2", "Application Internal Error");
t.set("/ERR-1-4-3", "HL70357");
}
if (encoding != null) {
errorMessage = p.encode(out, encoding);
} else {
errorMessage = p.encode(out);
}
}
catch (IOException ioe) {
throw new HL7Exception(
"IOException creating error response message: " + ioe.getMessage(),
HL7Exception.APPLICATION_INTERNAL_ERROR);
}
return errorMessage;
}
/**
* Registers a message parser/encoder with this responder. If multiple parsers
* are registered, each message is inspected by each parser in the order in which
* they are registered, until one parser recognizes the format and parses the
* message.
*/
/*public void registerParser(Parser p) {
this.parsers.add(p);
}*/
/**
* Registers an Application with this Responder. The "Application", in this
* context, is the software that uses the information in the message. If multiple
* applications are registered, incoming Message objects will be passed to
* each one in turn (calling canProcess()) until one of them accepts
* responsibility for the message. If none of the registered applications can
* process the message, a DefaultApplication is used, which simply returns an
* Application Reject message.
*/
public void registerApplication(Application a) {
this.apps.add(a);
}
/**
* Test code.
*/
public static void main(String args[]) {
if (args.length != 1) {
System.err.println("Usage: DefaultApplication message_file");
System.exit(1);
}
//read test message file ...
try {
File messageFile = new File(args[0]);
Reader in = new BufferedReader(new FileReader(messageFile));
int fileLength = (int) messageFile.length();
char[] cbuf = new char[fileLength];
in.read(cbuf, 0, fileLength);
String messageString = new String(cbuf);
//parse inbound message ...
final Parser parser = new PipeParser();
Message inMessage = null;
try {
inMessage = parser.parse(messageString);
}
catch (HL7Exception e) {
e.printStackTrace();
}
//process with responder ...
PipedInputStream initInbound = new PipedInputStream();
PipedOutputStream initOutbound = new PipedOutputStream();
PipedInputStream respInbound = new PipedInputStream(initOutbound);
PipedOutputStream respOutbound = new PipedOutputStream(initInbound);
/* This code won't work with new changes:
final Initiator init = new Initiator(parser, new MinLowerLayerProtocol(), initInbound, initOutbound);
Responder resp = new Responder(respInbound, respOutbound);
//run the initiator in a separate thread ...
final Message inMessCopy = inMessage;
Thread initThd = new Thread(new Runnable() {
public void run() {
try {
Message response = init.sendAndReceive(inMessCopy);
System.out.println("This is initiator writing response ...");
System.out.println(parser.encode(response));
} catch (Exception ie) {
if (HL7Exception.class.isAssignableFrom(ie.getClass())) {
System.out.println("Error in segment " + ((HL7Exception)ie).getSegmentName() + " field " + ((HL7Exception)ie).getFieldPosition());
}
ie.printStackTrace();
}
}
});
initThd.start();
//process the message we expect from the initiator thread ...
System.out.println("Responder is going to respond now ...");
resp.processOneMessage();
*/
}
catch (Exception e) {
e.printStackTrace();
}
}
}