/// <summary>
/// Creates a new <see cref="SimpleChannelPool"/> instance.
/// </summary>
/// <param name="bootstrap">The <see cref="Bootstrapping.Bootstrap"/> that is used for connections.</param>
/// <param name="handler">
/// The <see cref="IChannelPoolHandler"/> that will be notified for the different pool actions.
/// </param>
/// <param name="healthChecker">
/// The <see cref="IChannelHealthChecker"/> that will be used to check if a <see cref="IChannel"/> is still
/// healthy when obtained from the <see cref="IChannelPool"/>.
/// </param>
/// <param name="releaseHealthCheck">
/// If <c>true</c>, will check channel health before offering back. Otherwise, channel health is only checked
/// at acquisition time.
/// </param>
/// <param name="lastRecentUsed">
/// If <c>true</c>, <see cref="IChannel"/> selection will be LIFO. If <c>false</c>, it will be FIFO.
/// </param>
public SimpleChannelPool(Bootstrap bootstrap, IChannelPoolHandler handler, IChannelHealthChecker healthChecker, bool releaseHealthCheck, bool lastRecentUsed)
{
if (handler is null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.handler);
}
if (healthChecker is null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.healthChecker);
}
if (bootstrap is null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.bootstrap);
}
Handler = handler;
HealthChecker = healthChecker;
ReleaseHealthCheck = releaseHealthCheck;
// Clone the original Bootstrap as we want to set our own handler
Bootstrap = bootstrap.Clone();
_ = Bootstrap.Handler(new ActionChannelInitializer <IChannel>(OnChannelInitializing));
_store =
lastRecentUsed
? (IQueue <IChannel>) new CompatibleConcurrentStack <IChannel>()
: new CompatibleConcurrentQueue <IChannel>();
}
protected override WebSocketChannelPool NewPool(ExtendedNettyFullAddress key)
{
HttpPoolManager.HttpChannelPool httpPool = httpPoolMap.getChannelPool(key.Address);
IChannelPoolHandler wsPoolHandler = outerInstance.decorateChannelPoolHandler(new WebSocketChannelPoolHandler());
WebSocketChannelPool wsPool = new WebSocketChannelPool(httpPool, key, wsPoolHandler);
return(wsPool);
}
/// <summary>
/// Creates a new channel pool.
/// </summary>
/// <param name="bootstrap"> the <seealso cref="Bootstrap"/> used to create promises </param>
/// <param name="parentPool"> the parent pool providing the channels to the child </param>
/// <param name="handler"> the <seealso cref="ChannelPoolHandler"/> that will be notified for the different pool actions </param>
public ChildChannelPool(Bootstrap bootstrap, IChannelPool parentPool, IChannelPoolHandler handler)
{
Contract.Requires(handler != null);
Contract.Requires(parentPool != null);
Contract.Requires(bootstrap != null);
this.Handler = handler;
this.parentPool = parentPool;
this.bootstrap = bootstrap;
this.HealthChecker = ChannelActiveHealthChecker.Instance;
this.ReleaseHealthCheck = true;
this.store = (IQueue <IChannel>) new CompatibleConcurrentStack <IChannel>();
}
/// <summary>
/// Creates a new <see cref="FixedChannelPool"/> instance.
/// </summary>
/// <param name="bootstrap">The <see cref="Bootstrap"/> that is used for connections.</param>
/// <param name="handler">
/// The <see cref="IChannelPoolHandler"/> that will be notified for the different pool actions.
/// </param>
/// <param name="healthChecker">
/// The <see cref="IChannelHealthChecker"/> that will be used to check if a <see cref="IChannel"/> is still
/// healthy when obtained from the <see cref="IChannelPool"/>.
/// </param>
/// <param name="action">
/// The <see cref="AcquireTimeoutAction"/> to use or <c>null</c> if none should be used. In this case,
/// <paramref name="acquireTimeout"/> must also be <c>null</c>.
/// </param>
/// <param name="acquireTimeout">
/// A <see cref="TimeSpan"/> after which an pending acquire must complete, or the
/// <see cref="AcquireTimeoutAction"/> takes place.
/// </param>
/// <param name="maxConnections">
/// The number of maximal active connections. Once this is reached, new attempts to acquire an
/// <see cref="IChannel"/> will be delayed until a connection is returned to the pool again.
/// </param>
/// <param name="maxPendingAcquires">
/// The maximum number of pending acquires. Once this is exceeded, acquire attempts will be failed.
/// </param>
/// <param name="releaseHealthCheck">If <c>true</c>, will check channel health before offering it back.</param>
/// <param name="lastRecentUsed">
/// If <c>true</c>, <see cref="IChannel"/> selection will be LIFO. If <c>false</c>, it will be FIFO.
/// </param>
public FixedChannelPool(Bootstrap bootstrap, IChannelPoolHandler handler, IChannelHealthChecker healthChecker, AcquireTimeoutAction action, TimeSpan acquireTimeout, int maxConnections, int maxPendingAcquires, bool releaseHealthCheck, bool lastRecentUsed)
: base(bootstrap, handler, healthChecker, releaseHealthCheck, lastRecentUsed)
{
if ((uint)(maxConnections - 1) > SharedConstants.TooBigOrNegative)
{
ThrowHelper.ThrowArgumentException_MaxConnections(maxConnections);
}
if ((uint)(maxPendingAcquires - 1) > SharedConstants.TooBigOrNegative)
{
ThrowHelper.ThrowArgumentException_MaxPendingAcquires(maxPendingAcquires);
}
_acquireTimeout = acquireTimeout;
if (action == AcquireTimeoutAction.None && acquireTimeout == Timeout.InfiniteTimeSpan)
{
_timeoutTask = null;
}
else if (action == AcquireTimeoutAction.None && acquireTimeout != Timeout.InfiniteTimeSpan)
{
ThrowHelper.ThrowArgumentException_Action();
}
else if (action != AcquireTimeoutAction.None && acquireTimeout < TimeSpan.Zero)
{
ThrowHelper.ThrowArgumentException_AcquireTimeoutMillis(acquireTimeout);
}
else
{
switch (action)
{
case AcquireTimeoutAction.Fail:
_timeoutTask = new TimeoutTask(this, OnTimeoutFail);
break;
case AcquireTimeoutAction.New:
_timeoutTask = new TimeoutTask(this, OnTimeoutNew);
break;
default:
ThrowHelper.ThrowArgumentException_Action(); break;
}
}
_executor = bootstrap.Group().GetNext();
_maxConnections = maxConnections;
_maxPendingAcquires = maxPendingAcquires;
_pendingAcquireQueue = PlatformDependent.NewMpscQueue <AcquireTask>();
}
/// <summary>
/// Creates a new <see cref="FixedChannelPool"/> instance.
/// </summary>
/// <param name="bootstrap">The <see cref="Bootstrap"/> that is used for connections.</param>
/// <param name="handler">
/// The <see cref="IChannelPoolHandler"/> that will be notified for the different pool actions.
/// </param>
/// <param name="healthChecker">
/// The <see cref="IChannelHealthChecker"/> that will be used to check if a <see cref="IChannel"/> is still
/// healthy when obtained from the <see cref="IChannelPool"/>.
/// </param>
/// <param name="action">
/// The <see cref="AcquireTimeoutAction"/> to use or <c>null</c> if none should be used. In this case,
/// <paramref name="acquireTimeout"/> must also be <c>null</c>.
/// </param>
/// <param name="acquireTimeout">
/// A <see cref="TimeSpan"/> after which an pending acquire must complete, or the
/// <see cref="AcquireTimeoutAction"/> takes place.
/// </param>
/// <param name="maxConnections">
/// The number of maximal active connections. Once this is reached, new attempts to acquire an
/// <see cref="IChannel"/> will be delayed until a connection is returned to the pool again.
/// </param>
/// <param name="maxPendingAcquires">
/// The maximum number of pending acquires. Once this is exceeded, acquire attempts will be failed.
/// </param>
/// <param name="releaseHealthCheck">If <c>true</c>, will check channel health before offering it back.</param>
/// <param name="lastRecentUsed">
/// If <c>true</c>, <see cref="IChannel"/> selection will be LIFO. If <c>false</c>, it will be FIFO.
/// </param>
public FixedChannelPool(Bootstrap bootstrap, IChannelPoolHandler handler, IChannelHealthChecker healthChecker, AcquireTimeoutAction action, TimeSpan acquireTimeout, int maxConnections, int maxPendingAcquires, bool releaseHealthCheck, bool lastRecentUsed)
: base(bootstrap, handler, healthChecker, releaseHealthCheck, lastRecentUsed)
{
if (maxConnections < 1)
{
throw new ArgumentException($"maxConnections: {maxConnections} (expected: >= 1)");
}
if (maxPendingAcquires < 1)
{
throw new ArgumentException($"maxPendingAcquires: {maxPendingAcquires} (expected: >= 1)");
}
this.acquireTimeout = acquireTimeout;
if (action == AcquireTimeoutAction.None && acquireTimeout == Timeout.InfiniteTimeSpan)
{
this.timeoutTask = null;
}
else if (action == AcquireTimeoutAction.None && acquireTimeout != Timeout.InfiniteTimeSpan)
{
throw new ArgumentException("action");
}
else if (action != AcquireTimeoutAction.None && acquireTimeout < TimeSpan.Zero)
{
throw new ArgumentException($"acquireTimeoutMillis: {acquireTimeout} (expected: >= 1)");
}
else
{
switch (action)
{
case AcquireTimeoutAction.Fail:
this.timeoutTask = new TimeoutTask(this, this.OnTimeoutFail);
break;
case AcquireTimeoutAction.New:
this.timeoutTask = new TimeoutTask(this, this.OnTimeoutNew);
break;
default:
throw new ArgumentException("action");
}
}
this.executor = bootstrap.Group().GetNext();
this.maxConnections = maxConnections;
this.maxPendingAcquires = maxPendingAcquires;
}
protected override HttpChannelPool NewPool(NettyFullAddress key)
{
/*
* When there is a proxy configured, the client must not try to resolve the server address
* because the server could be on a network unreachable to the client
*/
Bootstrap poolBootstrap = cb.Clone();
poolBootstrap.RemoteAddress(key.Address);
if (log.IsDebugEnabled)
{
log.Debug("New HTTP channel pool created. Remote address: " + key.Address);
}
IChannelPoolHandler handler = outerInstance.decorateChannelPoolHandler(new HttpChannelPoolHandler(key));
return(new HttpChannelPool(key, poolBootstrap, handler));
}
/// <summary>
/// Creates a new <see cref="SimpleChannelPool"/> instance.
/// </summary>
/// <param name="bootstrap">The <see cref="Bootstrapping.Bootstrap"/> that is used for connections.</param>
/// <param name="handler">
/// The <see cref="IChannelPoolHandler"/> that will be notified for the different pool actions.
/// </param>
/// <param name="healthChecker">
/// The <see cref="IChannelHealthChecker"/> that will be used to check if a <see cref="IChannel"/> is still
/// healthy when obtained from the <see cref="IChannelPool"/>.
/// </param>
/// <param name="releaseHealthCheck">
/// If <c>true</c>, will check channel health before offering back. Otherwise, channel health is only checked
/// at acquisition time.
/// </param>
/// <param name="lastRecentUsed">
/// If <c>true</c>, <see cref="IChannel"/> selection will be LIFO. If <c>false</c>, it will be FIFO.
/// </param>
public SimpleChannelPool(Bootstrap bootstrap, IChannelPoolHandler handler, IChannelHealthChecker healthChecker, bool releaseHealthCheck, bool lastRecentUsed)
{
Contract.Requires(handler != null);
Contract.Requires(healthChecker != null);
Contract.Requires(bootstrap != null);
this.Handler = handler;
this.HealthChecker = healthChecker;
this.ReleaseHealthCheck = releaseHealthCheck;
// Clone the original Bootstrap as we want to set our own handler
this.Bootstrap = bootstrap.Clone();
this.Bootstrap.Handler(new ActionChannelInitializer <IChannel>(this.OnChannelInitializing));
this.store =
lastRecentUsed
? (IQueue <IChannel>) new CompatibleConcurrentStack <IChannel>()
: new CompatibleConcurrentQueue <IChannel>();
}
/// <summary>
/// Creates a new <see cref="FixedChannelPool"/> instance using the <see cref="ChannelActiveHealthChecker"/>.
/// </summary>
/// <param name="bootstrap">The <see cref="Bootstrap"/> that is used for connections.</param>
/// <param name="handler">
/// The <see cref="IChannelPoolHandler"/> that will be notified for the different pool actions.
/// </param>
/// <param name="maxConnections">
/// The number of maximal active connections. Once this is reached, new attempts to acquire an
/// <see cref="IChannel"/> will be delayed until a connection is returned to the pool again.
/// </param>
/// <param name="maxPendingAcquires">
/// The maximum number of pending acquires. Once this is exceeded, acquire attempts will be failed.
/// </param>
public FixedChannelPool(Bootstrap bootstrap, IChannelPoolHandler handler, int maxConnections, int maxPendingAcquires = int.MaxValue)
: this(bootstrap, handler, ChannelActiveHealthChecker.Instance, AcquireTimeoutAction.None, Timeout.InfiniteTimeSpan, maxConnections, maxPendingAcquires)
{
}
/// <summary>
/// Creates a new <see cref="FixedChannelPool"/> instance.
/// </summary>
/// <param name="bootstrap">The <see cref="Bootstrap"/> that is used for connections.</param>
/// <param name="handler">
/// The <see cref="IChannelPoolHandler"/> that will be notified for the different pool actions.
/// </param>
/// <param name="healthChecker">
/// The <see cref="IChannelHealthChecker"/> that will be used to check if a <see cref="IChannel"/> is still
/// healthy when obtained from the <see cref="IChannelPool"/>.
/// </param>
/// <param name="action">
/// The <see cref="AcquireTimeoutAction"/> to use or <c>null</c> if none should be used. In this case,
/// <paramref name="acquireTimeout"/> must also be <c>null</c>.
/// </param>
/// <param name="acquireTimeout">
/// A <see cref="TimeSpan"/> after which an pending acquire must complete, or the
/// <see cref="AcquireTimeoutAction"/> takes place.
/// </param>
/// <param name="maxConnections">
/// The number of maximal active connections. Once this is reached, new attempts to acquire an
/// <see cref="IChannel"/> will be delayed until a connection is returned to the pool again.
/// </param>
/// <param name="maxPendingAcquires">
/// The maximum number of pending acquires. Once this is exceeded, acquire attempts will be failed.
/// </param>
/// <param name="releaseHealthCheck">If <c>true</c>, will check channel health before offering it back.</param>
public FixedChannelPool(Bootstrap bootstrap, IChannelPoolHandler handler, IChannelHealthChecker healthChecker, AcquireTimeoutAction action, TimeSpan acquireTimeout, int maxConnections, int maxPendingAcquires, bool releaseHealthCheck)
: this(bootstrap, handler, healthChecker, action, acquireTimeout, maxConnections, maxPendingAcquires, releaseHealthCheck, true)
{
}
internal SingleChannelPool(Bootstrap bootstrap, IChannelPoolHandler handler)
: base(bootstrap, handler)
{
}
// TEST ONLY
protected internal virtual IChannelPoolHandler decorateChannelPoolHandler(IChannelPoolHandler handler)
{
return(handler);
}
/// <summary>
/// Creates a new <see cref="SimpleChannelPool"/> instance.
/// </summary>
/// <param name="bootstrap">The <see cref="Bootstrapping.Bootstrap"/> that is used for connections.</param>
/// <param name="handler">
/// The <see cref="IChannelPoolHandler"/> that will be notified for the different pool actions.
/// </param>
/// <param name="healthChecker">
/// The <see cref="IChannelHealthChecker"/> that will be used to check if a <see cref="IChannel"/> is still
/// healthy when obtained from the <see cref="IChannelPool"/>.
/// </param>
/// <param name="releaseHealthCheck">
/// If <c>true</c>, will check channel health before offering back. Otherwise, channel health is only checked
/// at acquisition time.
/// </param>
public SimpleChannelPool(Bootstrap bootstrap, IChannelPoolHandler handler, IChannelHealthChecker healthChecker, bool releaseHealthCheck)
: this(bootstrap, handler, healthChecker, releaseHealthCheck, true)
{
}
/// <summary>
/// Creates a new <see cref="SimpleChannelPool"/> instance using the <see cref="ChannelActiveHealthChecker"/>.
/// </summary>
/// <param name="bootstrap">The <see cref="Bootstrapping.Bootstrap"/> that is used for connections.</param>
/// <param name="handler">The <see cref="IChannelPoolHandler"/> that will be notified for the different pool actions.</param>
public SimpleChannelPool(Bootstrap bootstrap, IChannelPoolHandler handler)
: this(bootstrap, handler, ChannelActiveHealthChecker.Instance)
{
}
public WebSocketChannelPool(HttpChannelPool parentPool, ExtendedNettyFullAddress address, IChannelPoolHandler handler) : base(parentPool.Bootstrap, parentPool, handler)
{
this.address = address;
if (log.IsDebugEnabled)
{
log.Debug("New WS channel pool created. Remote address: " + address.Address.Address);
}
}
public HttpChannelPool(NettyFullAddress remoteAddress, Bootstrap bootstrap, IChannelPoolHandler handler) : base(bootstrap, handler)
{
this.remoteAddress = remoteAddress;
this.bootstrap = bootstrap;
}
