src.com.ibm.as400.access.AS400ThreadedServer Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt400-jdk8 Show documentation
Show all versions of jt400-jdk8 Show documentation
The Open Source version of the IBM Toolbox for Java
The newest version!
///////////////////////////////////////////////////////////////////////////////
//
// JTOpen (IBM Toolbox for Java - OSS version)
//
// Filename: AS400ThreadedServer.java
//
// The source code contained herein is licensed under the IBM Public License
// Version 1.0, which has been approved by the Open Source Initiative.
// Copyright (C) 1997-2003 International Business Machines Corporation and
// others. All rights reserved.
//
///////////////////////////////////////////////////////////////////////////////
package com.ibm.as400.access;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.SocketException;
import java.util.Hashtable;
final class AS400ThreadedServer extends AS400Server implements Runnable
{
private static int threadCount_ = 0;
private AS400ImplRemote system_;
private int service_;
private String jobString_;
private boolean disconnecting_ = false;
private SocketContainer socket_;
private InputStream inStream_;
private OutputStream outStream_;
private Hashtable replyStreams_;
private Hashtable instanceReplyStreams_ = new Hashtable();
private Thread readDaemon_ = null;
private IOException readDaemonException_ = null;
private RuntimeException unlikelyException_ = null;
private DataStream exchangeAttrReply_ = null;
// Vectors are slow, but Object arrays are big, so we implement our own hashtables to compromise.
private final ReplyList replyList_ = new ReplyList();
private static final class DataStreamCollection
{
DataStream[] chain_;
DataStreamCollection(DataStream ds)
{
chain_ = new DataStream[] { ds };
}
}
private static final class ReplyList
{
final DataStreamCollection[] streams_ = new DataStreamCollection[16];
private DiscardList discardList_;
final void add(DataStream ds)
{
int id = ds.getCorrelation();
if (discardList_.remove(id))
{
if (Trace.traceOn_) Trace.log(Trace.DIAGNOSTIC, "ReplyList: Discarded datastream:", id);
ClassDecoupler.freeDBReplyStream(ds); ds = null;
return;
}
int hash = ds.getCorrelation() % 16;
// Use the collection object for synchronization to prevent bottlenecks.
DataStreamCollection coll = streams_[hash];
if (coll == null)
{
streams_[hash] = new DataStreamCollection(ds);
return;
}
synchronized (coll)
{
DataStream[] chain = coll.chain_;
int max = chain.length;
for (int i = 0; i < max; ++i)
{
if (chain[i] == null)
{
chain[i] = ds;
return;
}
}
DataStream[] newChain = new DataStream[max * 2];
System.arraycopy(chain, 0, newChain, 0, max);
newChain[max] = ds;
coll.chain_ = newChain;
}
}
final DataStream remove(int correlation)
{
int hash = correlation % 16;
DataStreamCollection coll = streams_[hash];
if (coll == null) return null;
// Use the collection object for synchronization to prevent bottlenecks.
synchronized (coll)
{
DataStream[] chain = coll.chain_;
for (int i = 0; i < chain.length; ++i)
{
if (chain[i] != null && chain[i].getCorrelation() == correlation)
{
DataStream ds = chain[i];
// Move up the remaining entries because chained replies have the same correlation ID and need to remain in chronological order.
if (i + 1 < chain.length)
{
System.arraycopy(chain, i + 1, chain, i, chain.length - i - 1);
}
// Set last element to null.
chain[chain.length - 1] = null;
return ds;
}
}
return null;
}
}
void setDiscardList(DiscardList discardList)
{
discardList_ = discardList;
}
}
private final DiscardList discardList_ = new DiscardList();
private static final class DiscardList
{
int[] ids_ = new int[8];
final Object idsLock_ = new Object();
private ReplyList replyList_;
final void add(int correlation)
{
DataStream ds = replyList_.remove(correlation);
if (ds != null)
{
if (Trace.traceOn_) Trace.log(Trace.DIAGNOSTIC, "DiscardList: Discarded datastream:", correlation);
ClassDecoupler.freeDBReplyStream(ds); ds = null;
return;
}
synchronized (idsLock_)
{
final int max = ids_.length;
for (int i = 0; i < max; ++i)
{
if (ids_[i] == 0)
{
ids_[i] = correlation; // We don't allow 0 as a valid correlation ID.
return;
}
}
int[] newIds = new int[max * 2];
System.arraycopy(ids_, 0, newIds, 0, max);
newIds[max] = correlation;
ids_ = newIds;
}
}
final boolean remove(int correlation)
{
final int max = ids_.length;
for (int i = 0; i < max; ++i)
{
if (ids_[i] == correlation)
{
ids_[i] = 0;
return true;
}
}
return false;
}
void setReplyList(ReplyList replyList)
{
replyList_ = replyList;
}
}
private int lastCorrelationId_ = 0;
private class CorrelationIdLock extends Object {} //@C7A
private class ReceiveLock extends Object {} //@C7A
private final CorrelationIdLock correlationIdLock_ = new CorrelationIdLock();
private final ReceiveLock receiveLock_ = new ReceiveLock();
AS400ThreadedServer(AS400ImplRemote system, int service, SocketContainer socket, String jobString) throws IOException
{
system_ = system;
service_ = service;
jobString_ = jobString;
socket_ = socket;
connectionID_ = socket_.hashCode();
inStream_ = socket_.getInputStream();
outStream_ = socket_.getOutputStream();
replyStreams_ = AS400Server.replyStreamsHashTables[service];
discardList_.setReplyList(replyList_);
replyList_.setDiscardList(discardList_);
String jobID;
if (jobString != null && jobString.length() != 0) jobID = jobString;
else jobID = AS400.getServerName(service) + "/" + (++threadCount_);
readDaemon_ = new Thread(this, "AS400 Read Daemon [system:"+system.getSystemName() + ";job:" + jobID + "]");
readDaemon_.setDaemon(true);
readDaemon_.start();
}
// Print is the only service that uses this method.
final void addInstanceReplyStream(DataStream replyStream)
{
instanceReplyStreams_.put(replyStream, replyStream);
}
// Print is the only service that uses this method.
final void clearInstanceReplyStreams()
{
instanceReplyStreams_.clear();
}
final void forceDisconnect()
{
disconnecting_ = true;
if (readDaemonException_ == null)
{
readDaemonException_ = new ConnectionDroppedException(ConnectionDroppedException.DISCONNECT_RECEIVED);
}
if (service_ == AS400.DATABASE || service_ == AS400.COMMAND || service_ == AS400.CENTRAL)
{
AS400EndJobDS endjob = new AS400EndJobDS(AS400Server.getServerId(service_));
if (Trace.traceOn_) endjob.setConnectionID(connectionID_);
try
{
endjob.write(outStream_);
}
catch (IOException e)
{
Trace.log(Trace.ERROR, "Send end job data stream failed:", e);
}
}
Trace.log(Trace.INFORMATION , "forceDisconnect calling readDaemon_.interrupt");
readDaemon_.interrupt();
try
{
socket_.close();
}
catch (IOException e)
{
Trace.log(Trace.ERROR, "Socket close failed:", e);
}
// Wait for thread to end. This is necessary to help socket descriptor from being reused.
try
{
readDaemon_.join();
}
catch (InterruptedException e)
{
Trace.log(Trace.ERROR, "Thread join failed:", e);
}
}
public final DataStream getExchangeAttrReply()
{
return exchangeAttrReply_;
}
final String getJobString()
{
return jobString_;
}
final int getService()
{
return service_;
}
final boolean isConnected()
{
return readDaemonException_ == null && unlikelyException_ == null;
}
final int newCorrelationId()
{
synchronized (correlationIdLock_)
{
// Don't allow 0 as a valid correlation ID.
if (++lastCorrelationId_ == 0) lastCorrelationId_ = 1;
return lastCorrelationId_;
}
}
final DataStream receive(int correlationId) throws IOException, InterruptedException
{
if (Trace.traceOn_) Trace.log(Trace.DIAGNOSTIC, "AS400Server.receive");
synchronized (receiveLock_)
{
while (true) {
// Changed March 2018 to give priority to exceptions..
// Otherwise exceptions are being lost.
if (readDaemonException_ != null) {
Trace.log(Trace.ERROR, "receive(): Read daemon exception:",
readDaemonException_);
throw readDaemonException_;
} else if (unlikelyException_ != null) {
Trace.log(Trace.ERROR, "receive(): Read daemon exception:",
unlikelyException_);
throw unlikelyException_;
} else {
DataStream ds = replyList_.remove(correlationId);
if (ds != null) {
if (Trace.traceOn_) {
Trace.log(Trace.DIAGNOSTIC, "receive(): Valid reply found:",
correlationId);
}
if (DBDSPool.monitor) {
if (ds instanceof DBReplyRequestedDS) {
((DBReplyRequestedDS) ds).setAllocatedLocation();
}
} /* @B5A */
return ds;
}
}
if (Trace.traceOn_)
Trace.log(Trace.DIAGNOSTIC, "receive(): Reply not found. Waiting...");
receiveLock_.wait();
}
}
}
public void run()
{
while (readDaemonException_ == null && unlikelyException_ == null)
{
try
{
if (Trace.traceOn_) Trace.log(Trace.DIAGNOSTIC, "run(): Waiting for reply...");
DataStream reply = null;
// If client access server, construct ClientAccessDataStream.
if (service_ != AS400.RECORDACCESS)
{
reply = ClientAccessDataStream.construct(inStream_, instanceReplyStreams_, replyStreams_, system_, connectionID_);
}
else // Construct a DDMDataStream.
{
reply = ClassDecoupler.constructDDMDataStream(inStream_, replyStreams_, system_, connectionID_);
}
// Note: the thread is blocked on the above call if the inputStream has nothing to receive.
int correlation = reply.getCorrelation();
if (Trace.traceOn_) Trace.log(Trace.DIAGNOSTIC, "run(): Adding reply:", correlation);
replyList_.add(reply);
if (Trace.traceOn_) Trace.log(Trace.DIAGNOSTIC, "run(): Notifying threads.");
synchronized (receiveLock_)
{
receiveLock_.notifyAll(); // Notify all waiting threads.
}
if (Trace.traceOn_) Trace.log(Trace.DIAGNOSTIC, "run(): Threads notified.");
}
catch (IOException e)
{
if (Trace.traceOn_)
{
if (disconnecting_ &&
e instanceof SocketException )
{
// It's an expected consequence of a client-initiated disconnect.
Trace.log(Trace.DIAGNOSTIC, "run(): Caught SocketException during disconnect:", e);
}
else Trace.log(Trace.ERROR, "run(): Caught IOException:", e);
}
// At this point, all waiting threads must be notified that the connection has ended...
if (readDaemonException_ == null)
{
readDaemonException_ = e;
}
if (Trace.traceOn_) Trace.log(Trace.DIAGNOSTIC, "run(): Notifying threads after IOException.");
synchronized (receiveLock_)
{
receiveLock_.notifyAll(); // Notify all waiting threads.
}
if (Trace.traceOn_) Trace.log(Trace.DIAGNOSTIC, "run(): Threads notified after IOException.");
}
catch (RuntimeException e)
{
if (Trace.traceOn_) Trace.log(Trace.ERROR, "run(): Caught RuntimeException:", e);
if (unlikelyException_ == null)
{
unlikelyException_ = e;
}
if (Trace.traceOn_) Trace.log(Trace.DIAGNOSTIC, "run(): Notifying threads after RuntimeException.");
synchronized (receiveLock_)
{
receiveLock_.notifyAll();
}
if (Trace.traceOn_) Trace.log(Trace.DIAGNOSTIC, "run(): Threads notified after RuntimeException.");
}
//@socket2 removed finally close because we were doing double closes.
//@socket2finally
//@socket2{
// Since we've fallen out of the while loop, we can reasonably assume that the socket is broken (based on the loop condition).
// Ensure the socket doesn't get left open.
//@socket2 if (!isConnected()) // Check it this way, in case we change the meaning of isConnected() in the future.
//{
//@socket2 try { socket_.close(); }
//@socket2 catch (Throwable t) {
//@socket2 Trace.log(Trace.ERROR, "Socket close failed:", t);
//@socket2 }
//@socket2 }
//@socket2}
}
}
final int send(DataStream requestStream) throws IOException
{
if (Trace.traceOn_) {
Trace.log(Trace.DIAGNOSTIC, "send(): send request...");
requestStream.setConnectionID(connectionID_);
}
if (readDaemonException_ != null)
{
Trace.log(Trace.ERROR, "Read daemon generated exception:", readDaemonException_);
throw readDaemonException_;
}
if (unlikelyException_ != null)
{
Trace.log(Trace.ERROR, "Read daemon generated exception:", unlikelyException_);
throw unlikelyException_;
}
int correlationID = newCorrelationId();
requestStream.setCorrelation(correlationID);
requestStream.write(outStream_);
return correlationID;
}
final void send(DataStream requestStream, int correlationId) throws IOException
{
if (Trace.traceOn_) {
Trace.log(Trace.DIAGNOSTIC, "send(): send request...");
requestStream.setConnectionID(connectionID_);
}
if (readDaemonException_ != null)
{
Trace.log(Trace.ERROR, "Read daemon generated exception:", readDaemonException_);
throw readDaemonException_;
}
if (unlikelyException_ != null)
{
Trace.log(Trace.ERROR, "Read daemon generated exception:", unlikelyException_);
throw unlikelyException_;
}
requestStream.setCorrelation(correlationId);
requestStream.write(outStream_);
}
final void sendAndDiscardReply(DataStream requestStream) throws IOException
{
if (Trace.traceOn_) Trace.log(Trace.DIAGNOSTIC, "send and discard(): ...");
int correlationID = send(requestStream);
discardList_.add(correlationID);
}
//@M8a
final void sendAndDiscardReply(DataStream requestStream,int correlationID) throws IOException
{
if (Trace.traceOn_) Trace.log(Trace.DIAGNOSTIC, "send and discard(): ...");
send(requestStream,correlationID);
discardList_.add(correlationID);
}
public final DataStream sendAndReceive(DataStream requestStream) throws IOException, InterruptedException
{
if (Trace.traceOn_) Trace.log(Trace.DIAGNOSTIC, "send and receive(): ...");
int correlationID = send(requestStream);
return receive(correlationID);
}
public final synchronized DataStream sendExchangeAttrRequest(DataStream req) throws IOException, InterruptedException
{
if (exchangeAttrReply_ == null)
{
exchangeAttrReply_ = sendAndReceive(req);
}
return exchangeAttrReply_;
}
int getSoTimeout() throws SocketException {
return socket_.getSoTimeout();
}
void setSoTimeout(int timeout) throws SocketException {
socket_.setSoTimeout(timeout);
}
}