internal AsynchronousResponseWaiter(GiopTransportMessageHandler transportHandler,
uint requestId,
AsyncResponseAvailableCallBack callback,
IClientChannelSinkStack clientSinkStack,
GiopClientConnection connection,
MessageTimeout timeOut)
{
Initalize(transportHandler, requestId, callback, clientSinkStack, connection, timeOut);
}
private void Initalize(ITransport transport, MessageTimeout timeout,
byte headerFlags)
{
m_transport = transport;
m_timeout = timeout;
m_headerFlags = headerFlags;
m_writeLock = new AutoResetEvent(true);
m_reiceivedRequestDispatcher = null;
m_messageSendTask = new MessageSendTask(m_transport, this);
}
/// <param name="connectionKey">the key describing the connection</param>
/// <param name="transport">a not yet connected client transport</param>
/// <param name="headerFlags">the header flags to use for transport related giop messages.</param>
internal GiopClientInitiatedConnection(string connectionKey, IClientTransport transport,
MessageTimeout requestTimeOut, GiopClientConnectionManager conManager,
bool supportBidir, byte headerFlags)
{
GiopRequestNumberGenerator reqNumberGen =
(!supportBidir ? new GiopRequestNumberGenerator() : new GiopRequestNumberGenerator(true));
GiopTransportMessageHandler handler =
new GiopTransportMessageHandler(transport, requestTimeOut, headerFlags);
GiopClientConnectionDesc conDesc = new GiopClientConnectionDesc(conManager, this, reqNumberGen, handler);
m_clientTransport = transport;
Initalize(connectionKey, handler, conDesc);
}
private void Initalize(GiopTransportMessageHandler transportHandler,
uint requestId,
AsyncResponseAvailableCallBack callback,
IClientChannelSinkStack clientSinkStack,
GiopClientConnection connection,
MessageTimeout timeOutMillis)
{
m_alreadyNotified = false;
m_transportHandler = transportHandler;
m_requestId = requestId;
m_callback = callback;
m_clientConnection = connection;
m_clientSinkStack = clientSinkStack;
m_timeOut = timeOutMillis;
}
private void Initalize(IClientTransportFactory transportFactory, MessageTimeout requestTimeOut,
int unusedKeepAliveTime, int maxNumberOfConnections, bool allowMultiplex,
int maxNumberOfMultplexedRequests, byte headerFlags)
{
m_transportFactory = transportFactory;
m_requestTimeOut = requestTimeOut;
if (unusedKeepAliveTime != Timeout.Infinite)
{
m_connectionLifeTime = TimeSpan.FromMilliseconds(unusedKeepAliveTime);
TimerCallback timerDelegate = new TimerCallback(DestroyUnusedConnections);
// Create a timer which invokes the session destroyer every unusedKeepAliveTime
m_destroyTimer = new Timer(timerDelegate, null, 2 * unusedKeepAliveTime, unusedKeepAliveTime);
}
m_maxNumberOfConnections = maxNumberOfConnections; // the max. number of concurrent connections to the same target.
if (m_maxNumberOfConnections < 1)
{
throw new BAD_PARAM(579, CompletionStatus.Completed_MayBe);
}
m_allowMultiplex = allowMultiplex;
m_maxNumberOfMultiplexedRequests = maxNumberOfMultplexedRequests;
m_headerFlags = headerFlags;
}
/// <summary>creates a giop transport message handler, which doesn't accept request messages.
/// A receiver must be installed first.</summary>
/// <param name="transport">the transport implementation</param>
/// <param name="timeout">the client side timeout for a request</param>
/// <param name="headerFlags">the header flags to use for message created by giop transport.</param>
internal GiopTransportMessageHandler(ITransport transport, MessageTimeout timeout,
byte headerFlags)
{
Initalize(transport, timeout, headerFlags);
}
private void Initalize(ITransport transport, MessageTimeout timeout,
byte headerFlags) {
m_transport = transport;
m_timeout = timeout;
m_headerFlags = headerFlags;
m_writeLock = new AutoResetEvent(true);
m_reiceivedRequestDispatcher = null;
m_messageSendTask = new MessageSendTask(m_transport, this);
}
/// <summary>creates a giop transport message handler, which doesn't accept request messages.
/// A receiver must be installed first.</summary>
/// <param name="transport">the transport implementation</param>
/// <param name="timeout">the client side timeout for a request</param>
/// <param name="headerFlags">the header flags to use for message created by giop transport.</param>
internal GiopTransportMessageHandler(ITransport transport, MessageTimeout timeout,
byte headerFlags) {
Initalize(transport, timeout, headerFlags);
}
private void Initalize(GiopTransportMessageHandler transportHandler,
uint requestId,
AsyncResponseAvailableCallBack callback,
IClientChannelSinkStack clientSinkStack,
GiopClientConnection connection,
MessageTimeout timeOutMillis) {
m_alreadyNotified = false;
m_transportHandler = transportHandler;
m_requestId = requestId;
m_callback = callback;
m_clientConnection = connection;
m_clientSinkStack = clientSinkStack;
m_timeOut = timeOutMillis;
}
/// <summary>the constructor used by the config file</summary>
public IiopClientChannel(IDictionary properties, IClientChannelSinkProvider sinkProvider)
{
if (!CheckSinkProviderChain(sinkProvider))
{
throw new ArgumentException(
"IIOPClientSideFormatter provider not found in chain, this channel is only usable with the IIOPFormatters");
}
m_providerChain = sinkProvider;
IDictionary nonDefaultOptions = new Hashtable();
int receiveTimeOut = 0;
int sendTimeOut = 0;
ArrayList interceptionOptions = new ArrayList();
int maxNumberOfRetries = MAX_NUMBER_OF_RETRIES;
int retryDelay = RETRY_DELAY;
if (properties != null)
{
foreach (DictionaryEntry entry in properties)
{
switch ((string)entry.Key)
{
case IiopChannel.CHANNEL_NAME_KEY:
m_channelName = (string)entry.Value;
break;
case IiopChannel.PRIORITY_KEY:
m_channelPriority = Convert.ToInt32(entry.Value);
break;
case IiopChannel.TRANSPORT_FACTORY_KEY:
Type transportFactoryType = Type.GetType((string)entry.Value, true);
m_transportFactory = (IClientTransportFactory)
Activator.CreateInstance(transportFactoryType);
break;
case IiopClientChannel.CLIENT_RECEIVE_TIMEOUT_KEY:
receiveTimeOut = Convert.ToInt32(entry.Value);
break;
case IiopClientChannel.CLIENT_SEND_TIMEOUT_KEY:
sendTimeOut = Convert.ToInt32(entry.Value);
break;
case IiopClientChannel.CLIENT_REQUEST_TIMEOUT_KEY:
int requestTimeOutMilllis = Convert.ToInt32(entry.Value);
m_requestTimeOut = new MessageTimeout(TimeSpan.FromMilliseconds(requestTimeOutMilllis));
break;
case IiopClientChannel.CLIENT_UNUSED_CONNECTION_KEEPALIVE_KEY:
m_unusedClientConnectionTimeOut = Convert.ToInt32(entry.Value);
break;
case IiopClientChannel.CLIENT_CONNECTION_LIMIT_KEY:
m_maxNumberOfConnections = Convert.ToInt32(entry.Value);
break;
case IiopClientChannel.ALLOW_REQUEST_MULTIPLEX_KEY:
m_allowMultiplex = Convert.ToBoolean(entry.Value);
break;
case IiopClientChannel.MAX_NUMBER_OF_MULTIPLEXED_REQUESTS_KEY:
m_maxNumberOfMultplexedRequests = Convert.ToInt32(entry.Value);
break;
case IiopClientChannel.MAX_NUMBER_OF_RETRIES_KEY:
maxNumberOfRetries = Convert.ToInt32(entry.Value);
break;
case IiopClientChannel.RETRY_DELAY_KEY:
retryDelay = Convert.ToInt32(entry.Value);
break;
case IiopChannel.BIDIR_KEY:
m_isBidir = Convert.ToBoolean(entry.Value);
interceptionOptions.Add(new BiDirIiopInterceptionOption());
break;
case IiopChannel.ENDIAN_KEY:
Endian endian =
(Endian)Enum.Parse(typeof(Endian), (string)entry.Value);
m_headerFlags = GiopHeader.GetDefaultHeaderFlagsForEndian(endian);
break;
default:
Debug.WriteLine("non-default property found for IIOPClient channel: " + entry.Key);
nonDefaultOptions[entry.Key] = entry.Value;
break;
}
}
}
m_retryConfig = new RetryConfig(maxNumberOfRetries, retryDelay);
m_interceptionOptions =
(IInterceptionOption[])interceptionOptions.ToArray(typeof(IInterceptionOption));
// handle the options now by transport factory
m_transportFactory.SetClientTimeOut(receiveTimeOut, sendTimeOut);
m_transportFactory.SetupClientOptions(nonDefaultOptions);
InitChannel();
}
internal GiopClientConnectionManager(IClientTransportFactory transportFactory, MessageTimeout requestTimeOut,
int unusedKeepAliveTime, int maxNumberOfConnections, bool allowMultiplex,
int maxNumberOfMultplexedRequests, byte headerFlags)
{
Initalize(transportFactory, requestTimeOut, unusedKeepAliveTime,
maxNumberOfConnections, allowMultiplex, maxNumberOfMultplexedRequests,
headerFlags);
}
/// <summary>
/// see <see cref="Ch.Elca.Iiop.GiopClientConnectionManager.CreateClientConnection"></see>
/// </summary>
/// <remarks>for use case (2)</remarks>
protected override GiopClientInitiatedConnection CreateClientConnection(string targetKey, IClientTransport transport,
MessageTimeout requestTimeOut)
{
return(new GiopClientInitiatedConnection(targetKey, transport, requestTimeOut, this, true,
m_headerFlags));
}
internal GiopClientConnectionManager(IClientTransportFactory transportFactory, MessageTimeout requestTimeOut,
int unusedKeepAliveTime, int maxNumberOfConnections, bool allowMultiplex,
int maxNumberOfMultplexedRequests, byte headerFlags) {
Initalize(transportFactory, requestTimeOut, unusedKeepAliveTime,
maxNumberOfConnections, allowMultiplex, maxNumberOfMultplexedRequests,
headerFlags);
}
/// <summary>
/// see <see cref="Ch.Elca.Iiop.GiopClientConnectionManager.CreateClientConnection"></see>
/// </summary>
/// <remarks>for use case (2)</remarks>
protected override GiopClientInitiatedConnection CreateClientConnection(string targetKey, IClientTransport transport,
MessageTimeout requestTimeOut) {
return new GiopClientInitiatedConnection(targetKey, transport, requestTimeOut, this, true,
m_headerFlags);
}
private void Initalize(IClientTransportFactory transportFactory, MessageTimeout requestTimeOut,
int unusedKeepAliveTime, int maxNumberOfConnections, bool allowMultiplex,
int maxNumberOfMultplexedRequests, byte headerFlags) {
m_transportFactory = transportFactory;
m_requestTimeOut = requestTimeOut;
if (unusedKeepAliveTime != Timeout.Infinite) {
m_connectionLifeTime = TimeSpan.FromMilliseconds(unusedKeepAliveTime);
TimerCallback timerDelegate = new TimerCallback(DestroyUnusedConnections);
// Create a timer which invokes the session destroyer every unusedKeepAliveTime
m_destroyTimer = new Timer(timerDelegate, null, 2 * unusedKeepAliveTime, unusedKeepAliveTime);
}
m_maxNumberOfConnections = maxNumberOfConnections; // the max. number of concurrent connections to the same target.
if (m_maxNumberOfConnections < 1) {
throw new BAD_PARAM(579, CompletionStatus.Completed_MayBe);
}
m_allowMultiplex = allowMultiplex;
m_maxNumberOfMultiplexedRequests = maxNumberOfMultplexedRequests;
m_headerFlags = headerFlags;
}
internal AsynchronousResponseWaiter(GiopTransportMessageHandler transportHandler,
uint requestId,
AsyncResponseAvailableCallBack callback,
IClientChannelSinkStack clientSinkStack,
GiopClientConnection connection,
MessageTimeout timeOut) {
Initalize(transportHandler, requestId, callback, clientSinkStack, connection, timeOut);
}
/// <param name="connectionKey">the key describing the connection</param>
/// <param name="transport">a not yet connected client transport</param>
/// <param name="headerFlags">the header flags to use for transport related giop messages.</param>
internal GiopClientInitiatedConnection(string connectionKey, IClientTransport transport,
MessageTimeout requestTimeOut, GiopClientConnectionManager conManager,
bool supportBidir, byte headerFlags)
{
GiopRequestNumberGenerator reqNumberGen =
(!supportBidir ? new GiopRequestNumberGenerator() : new GiopRequestNumberGenerator(true));
GiopTransportMessageHandler handler =
new GiopTransportMessageHandler(transport, requestTimeOut, headerFlags);
GiopClientConnectionDesc conDesc = new GiopClientConnectionDesc(conManager, this, reqNumberGen, handler);
m_clientTransport = transport;
Initalize(connectionKey, handler, conDesc);
}
