public class ProcessorImpl extends Object implements Processor
Processor.| Constructor and Description |
|---|
ProcessorImpl(ProcessorContext theContext,
boolean isThreaded) |
| Modifier and Type | Method and Description |
|---|---|
void |
cycle(boolean expectingAck)
Performs a single iteration of the receiving-side
of the HL7 original mode or enhanced mode processing rules
(see HL7 Standard v2.5 Chapter 2; the choice of rules
is determined by message values).
|
ProcessorContext |
getContext() |
boolean |
isAvailable(String theAckId) |
Transportable |
receive(String theAckId,
long theTimeoutMillis)
Gets the message with the given acknowledgement ID from
the incoming message list.
|
void |
reserve(String theAckId,
long thePeriodMillis)
Indicates that the calling thread expects a message with a certain ack
ID.
|
void |
send(Transportable theMessage,
int maxRetries,
long retryIntervalMillis)
Sends a message to a remote system via an underlying
TransportLayer. |
void |
stop()
If self-threaded, stops threads that have been created.
|
public ProcessorImpl(ProcessorContext theContext, boolean isThreaded)
theContext - source of supporting servicesisThreaded - true if this class should create threads in which to call cycle(), and
in which to send responses from Applications. This is the preferred mode. Use false
if threading is not allowed, eg you are running the code in an EJB container. In this case,
the send() and receive() methods will call cycle() themselves as needed. However, cycle()
makes potentially blocking calls, so these methods may not return until the next message
is received from the remote server, regardless of timeout. Probably the worst example of this
would be if receive() was called to wait for an application ACK that was specified as "RE" (ie
required on error). No response will be returned if the message is processed without error,
and in a non-threaded environment, receive() will block forever. Use true if you can, otherwise
study this class carefully.
TODO: write a MLLPTransport with non-blocking IO
TODO: reconnect transport layers on error and retrypublic void stop()
public void send(Transportable theMessage, int maxRetries, long retryIntervalMillis) throws HL7Exception
ProcessorTransportLayer.
If the message specifies that an accept ACK is required (under enhanced mode
processing rules) then this method may retry if transmission does not appear
to be successful. The call to this method blocks while this is happening.
Retries are attempted if a CR message is received, or if no message is received
in the specified time frame. If a CE is received, an exception is thrown. If
a CA is received, the call returns quietly.
If no accept ack is required, this method returns immediately after attempting to
send a message, throwing an exception only if there is an immediate problem (eg the
server can't be contacted).
If an accept ack is required only on error, the method waits for maxRetries *
retryItervalMillis for an error to be returned, and assumes that there is no error
if none appears in that time. The message is not actually resent while waiting for an
error ACK.send in interface ProcessortheMessage - the message to sendmaxRetries - note that this should be a small value if you demand an accept ack only
on errorretryIntervalMillis - note that this should be a small value if you demand an accept ack only
on errorTransportException - if there is an immediate problem trying to send the
message.HL7ExceptionProcessor.send(ca.uhn.hl7v2.protocol.Transportable, int, long)public void reserve(String theAckId, long thePeriodMillis)
ProcessorApplication. If a message is in this list it isAvailable()
and can be had via receive()reserve in interface ProcessortheAckId - the acknowledgement ID of the messagethePeriodMillis - time span during which the message should be kept if receivedProcessor.reserve(java.lang.String, long)public void cycle(boolean expectingAck) throws HL7Exception
ProcessorPerforms a single iteration of the receiving-side of the HL7 original mode or enhanced mode processing rules (see HL7 Standard v2.5 Chapter 2; the choice of rules is determined by message values). Steps in the process are as follows:
1. TransportLayer.receive() is called to get the next messagecycle in interface ProcessorexpectingAck - is passed to TransportLayer.receive(), and may determine
where the message is read from (eg different sockets may be used for
commit-level ACKs). Note that this call blocks until a message is ready
at the specified location, so to run the Processor continuously,
separate threads are needed to call cycle() with true and false args.HL7ExceptionProcessor.cycle(boolean)public boolean isAvailable(String theAckId)
isAvailable in interface ProcessortheAckId - the acknowledgement ID of an expected messageProcessor.isAvailable(java.lang.String)public Transportable receive(String theAckId, long theTimeoutMillis) throws HL7Exception
ProcessorisAvailable() to see if it is there.
Note also that the message has no way of arriving on the list
during this call unless the Processor is running
as a thread, or unless some other thread is calling cycle().receive in interface ProcessortheTimeoutMillis - milliseconds until the call times out
and returns null if the desired message is not available.HL7ExceptionProcessor.receive(java.lang.String, long)public ProcessorContext getContext()
getContext in interface ProcessorProcessor.getContext()Copyright © 2001–2017 University Health Network. All rights reserved.