Found a work-around for my immediate issue, but it speaks of a
much deeper problem in the Mina and/or rxtx layers.
I have added a static lock around my chunk of code that calls the
IoConnector.connect() method. I have locked code lazily, so the
critical code includes the bulk of my open() method; this consists
of building the IoConnector, configuring it, calling connect(),
and waiting on the ConnectFuture returned (if not null). It
may be that a much tighter lock is all that is needed -- that is
beyond the scope of my work-around.
With no two ports attempting an open operation concurrently, the
symptoms (Exceptions and loss of the serial port) have stopped.
I have two tests going on (different pieces of hardware), and both
have passed 12 hours now without showing any problems.
Apparently that maybe-collision the logs were hinting at was a
real collision (though I misnamed IoSession.open() as the culprit)
-- whether it's Mina or rxtx is beyond my knowledge. But
apparently two threads attempting to open different serial ports
at the same time *can* cause fatal problems. [ It's very timing
based; I've seen runs go 6 hours before failing; seen others fail
in under 10 minutes. ]
A repeating (ie unrecoverable) SerialPortUnavailableException is
the one consistent symptom. I cannot explain why early tests got
a single PortInUseException first, nor why later tests got a
recoverable SerialPortUnavailableException before complete failure
-- but the RejectedExecutionExceptions were definitely unrelated
red herrings.
It seems likely this is a serial-specific issue, as I have run
many similar tests using socket connections without seeing this
behaviour.
Thanks again for all the help!!
boB
PS. Opps, keep forgetting to say: Mina 2.0.0-M6, RxTx 2.1.7 r2
boB Gage wrote:
Have made some more progress on this issue. The
RejectedExecutionException's were my fault and have been
eliminated. [ Executor handling periodic requests was getting
shut down and re-started, rather than destroyed and recreated. ]
I still, however, have the case where after some un-constant
number of successful serial port open/timeout/close cycles I
start seeing SerialPortUnavailableExceptions.
With my newest code I'm seeing a new pattern (twice in two runs):
* A number of successful open/timeout/close cycles on the port
* A single SerialPortUnavailableException
* Several more successful open/timeout/close cycles on the port
* A series of SerialPortUnavailableExceptions, one for every
connection attempt until the program is stopped and restarted.
Two pieces of new behavior here. 1) I've never before seen the
port go unavailable and come back again (the first single
exception). 2) I'm no longer seeing a PortInUseException at the
edge of the port going unavailable.
Some more factoids that may or may not help:
* With one serial port, this problem is very rare (I've seen
runs over 24 hours). With each additional serial port, the
occurrence rate goes up.
* Logs make it look like the problem *MIGHT* be a collision
between two IoSession.open() calls happening concurrently
(different ports, of course). Could there be something
non-thread safe in Mina's serial layer and/or the rxtx library
it's using??
* The message text of the SerialPortUnavailableExceptions reads
"Serial port not found"
Thanks in advance,
boB Gage
boB Gage wrote:
I'm seeing three different exceptions on the serial ports and am
unsure what they exactly mean.
Can anyone provide details as to *why* each of these may be
throw:
* PortInUseException
* SerialPortUnavailableException
* RejectedExecutionException
I have seen each of the preceding exceptions while trying to
open a serial port. The first two make the open fail, the
third does not (though the open operation has not completely
succeeded either -- no data flows on the port.)
There are two specific cases that I have seen, both while
attempting to connect to a device that's temporarily unavailable
(ie powered off):
1) My program opens the port, times out, closes it, waits, and
tries again (proper behavior). This cycle continues fine for
awhile (time varies) then a single PortInUseException is
thrown. On the next, and every following, attempt a
SerialPortUnavailableException is thrown. The
SerialPortUnavailableException continues until my program is
shut down and restarted -- then it immediately can open the port
again.
2) Same situation, same timeout cycles, but for some reason a
RejectedExecutionException is thrown. The "open" still returns
true, but no data flows on the port. Eventually the attempt
times out. One the next, and every following, attempt the
RejectedExecutionException is thrown and the behavior does not
change.
In both cases, turning on the far end device after the first
exception has no affect. The port, once failed stays that
way. Stopping and restarting our program has immediately
cleared up the issue each and every time. Unfortunately,
stopping & restarting our problem is not a viable solution.
I have seen timing changes have some effect. With a 5-second
delay between connection attempts only 27 attempts succeeded
(timed out) over a period of about 8 minutes before throwing the
PortInUseException. Changing that delay to 20 seconds, over
220 attempts were made over a period of 6+ hours before the
exception was thrown.
Any clues???????
Thanks in advance!!!
