public ConnectionRequestHandler(Reference @ref, Ice.ConnectionI connection, bool compress)
{
_reference = @ref;
_response = _reference.getMode() == Reference.Mode.ModeTwoway;
_connection = connection;
_compress = compress;
}
public ConnectRequestHandler(Reference @ref, Ice.ObjectPrx proxy)
{
_reference = @ref;
_response = _reference.getMode() == Reference.Mode.ModeTwoway;
_proxy = (Ice.ObjectPrxHelperBase)proxy;
_initialized = false;
_flushing = false;
_requestHandler = this;
}
public Reference create(Ice.Identity ident, string facet, Reference tmpl, EndpointI[] endpoints)
{
if(ident.name.Length == 0 && ident.category.Length == 0)
{
return null;
}
return create(ident, facet, tmpl.getMode(), tmpl.getSecure(), endpoints, null, null);
}
public CollocatedRequestHandler(Reference @ref, Ice.ObjectAdapter adapter)
{
_reference = @ref;
_dispatcher = _reference.getInstance().initializationData().dispatcher != null;
_response = _reference.getMode() == Reference.Mode.ModeTwoway;
_adapter = (Ice.ObjectAdapterI)adapter;
_logger = _reference.getInstance().initializationData().logger; // Cached for better performance.
_traceLevels = _reference.getInstance().traceLevels(); // Cached for better performance.
_requestId = 0;
}
create(Ice.Identity ident, string facet, Reference tmpl, string adapterId)
{
if(ident.name.Length == 0 && ident.category.Length == 0)
{
return null;
}
//
// Create new reference
//
return create(ident, facet, tmpl.getMode(), tmpl.getSecure(), tmpl.getProtocol(), tmpl.getEncoding(),
null, adapterId, null);
}
public ConnectRequestHandler(Reference @ref, Ice.ObjectPrx proxy, Ice.ObjectDelM_ del)
{
_reference = @ref;
_response = _reference.getMode() == Reference.Mode.ModeTwoway;
_proxy = (Ice.ObjectPrxHelperBase)proxy;
_delegate = del;
_batchAutoFlush = @ref.getInstance().initializationData().properties.getPropertyAsIntWithDefault(
"Ice.BatchAutoFlush", 1) > 0 ? true : false;
_initialized = false;
_flushing = false;
_batchRequestInProgress = false;
_batchRequestsSize = Protocol.requestBatchHdr.Length;
_batchStream = new BasicStream(@ref.getInstance(), _batchAutoFlush);
_updateRequestHandler = false;
}
CollocatedRequestHandler(Reference @ref, Ice.ObjectAdapter adapter)
{
_reference = @ref;
_dispatcher = _reference.getInstance().initializationData().dispatcher != null;
_response = _reference.getMode() == Reference.Mode.ModeTwoway;
_adapter = (Ice.ObjectAdapterI)adapter;
_logger = _reference.getInstance().initializationData().logger; // Cached for better performance.
_traceLevels = _reference.getInstance().traceLevels(); // Cached for better performance.
_batchAutoFlushSize = @ref.getInstance().batchAutoFlushSize();
_requestId = 0;
_batchStreamInUse = false;
_batchRequestNum = 0;
_batchStream = new BasicStream(@ref.getInstance(), Ice.Util.currentProtocolEncoding);
}
public ConnectionRequestHandler(Reference @ref, Ice.ObjectPrx proxy)
{
_reference = @ref;
_response = _reference.getMode() == Reference.Mode.ModeTwoway;
_connection = _reference.getConnection(out _compress);
//
// If this proxy is for a non-local object, and we are using a router, then
// add this proxy to the router info object.
//
IceInternal.RouterInfo ri = _reference.getRouterInfo();
if(ri != null)
{
ri.addProxy(proxy);
}
}
public int checkRetryAfterException(Ice.LocalException ex, Reference @ref, bool sleep, ref int cnt)
{
TraceLevels traceLevels = instance_.traceLevels();
Ice.Logger logger = instance_.initializationData().logger;
//
// We don't retry batch requests because the exception might have caused
// the all the requests batched with the connection to be aborted and we
// want the application to be notified.
//
if(@ref.getMode() == Reference.Mode.ModeBatchOneway || @ref.getMode() == Reference.Mode.ModeBatchDatagram)
{
throw ex;
}
Ice.ObjectNotExistException one = ex as Ice.ObjectNotExistException;
if(one != null)
{
if(@ref.getRouterInfo() != null && one.operation.Equals("ice_add_proxy"))
{
//
// If we have a router, an ObjectNotExistException with an
// operation name "ice_add_proxy" indicates to the client
// that the router isn't aware of the proxy (for example,
// because it was evicted by the router). In this case, we
// must *always* retry, so that the missing proxy is added
// to the router.
//
@ref.getRouterInfo().clearCache(@ref);
if(traceLevels.retry >= 1)
{
string s = "retrying operation call to add proxy to router\n" + ex;
logger.trace(traceLevels.retryCat, s);
}
return 0; // We must always retry, so we don't look at the retry count.
}
else if(@ref.isIndirect())
{
//
// We retry ObjectNotExistException if the reference is
// indirect.
//
if(@ref.isWellKnown())
{
LocatorInfo li = @ref.getLocatorInfo();
if(li != null)
{
li.clearCache(@ref);
}
}
}
else
{
//
// For all other cases, we don't retry ObjectNotExistException.
//
throw ex;
}
}
else if(ex is Ice.RequestFailedException)
{
throw ex;
}
//
// There is no point in retrying an operation that resulted in a
// MarshalException. This must have been raised locally (because if
// it happened in a server it would result in an UnknownLocalException
// instead), which means there was a problem in this process that will
// not change if we try again.
//
// The most likely cause for a MarshalException is exceeding the
// maximum message size, which is represented by the subclass
// MemoryLimitException. For example, a client can attempt to send a
// message that exceeds the maximum memory size, or accumulate enough
// batch requests without flushing that the maximum size is reached.
//
// This latter case is especially problematic, because if we were to
// retry a batch request after a MarshalException, we would in fact
// silently discard the accumulated requests and allow new batch
// requests to accumulate. If the subsequent batched requests do not
// exceed the maximum message size, it appears to the client that all
// of the batched requests were accepted, when in reality only the
// last few are actually sent.
//
if(ex is Ice.MarshalException)
{
throw ex;
}
++cnt;
Debug.Assert(cnt > 0);
int interval;
if(cnt == (_retryIntervals.Length + 1) && ex is Ice.CloseConnectionException)
{
//
// A close connection exception is always retried at least once, even if the retry
// limit is reached.
//
interval = 0;
}
else if(cnt > _retryIntervals.Length)
{
if(traceLevels.retry >= 1)
{
string s = "cannot retry operation call because retry limit has been exceeded\n" + ex;
logger.trace(traceLevels.retryCat, s);
}
throw ex;
}
else
{
interval = _retryIntervals[cnt - 1];
}
if(traceLevels.retry >= 1)
{
string s = "retrying operation call";
if(interval > 0)
{
s += " in " + interval + "ms";
}
s += " because of exception\n" + ex;
logger.trace(traceLevels.retryCat, s);
}
if(sleep && interval > 0)
{
//
// Sleep before retrying.
//
System.Threading.Thread.Sleep(interval);
}
return interval;
}
public ConnectRequestHandler(Reference @ref, Ice.ObjectPrx proxy)
{
_reference = @ref;
_connect = true;
_response = _reference.getMode() == Reference.Mode.ModeTwoway;
_proxy = (Ice.ObjectPrxHelperBase)proxy;
_initialized = false;
_flushing = false;
_batchRequestInProgress = false;
_batchStream = new BasicStream(@ref.getInstance(), Ice.Util.currentProtocolEncoding);
}
