public Task RegisterAsync(IEventLoop eventLoop)
{
Contract.Requires(eventLoop != null);
if (this.channel.Registered)
{
return(TaskEx.FromException(new InvalidOperationException("registered to an event loop already")));
}
if (!this.channel.IsCompatible(eventLoop))
{
return(TaskEx.FromException(new InvalidOperationException("incompatible event loop type: " + eventLoop.GetType().Name)));
}
this.channel.eventLoop = eventLoop;
var promise = new TaskCompletionSource();
if (eventLoop.InEventLoop)
{
this.Register0(promise);
}
else
{
try
{
eventLoop.Execute((u, p) => ((AbstractUnsafe)u).Register0((TaskCompletionSource)p), this, promise);
}
catch (Exception ex)
{
Logger.Warn("Force-closing a channel whose registration task was not accepted by an event loop: {}", this.channel, ex);
this.CloseForcibly();
this.channel.closeFuture.Complete();
Util.SafeSetFailure(promise, ex, Logger);
}
}
return(promise.Task);
}
public Task RegisterAsync(IEventLoop eventLoop)
{
Contract.Requires(eventLoop != null);
if (this._channel.Registered)
{
return TaskEx.FromException(new InvalidOperationException("registered to an event loop already"));
}
if (!this._channel.IsCompatible(eventLoop))
{
return
TaskEx.FromException(
new InvalidOperationException("incompatible event loop type: " + eventLoop.GetType().Name));
}
// It's necessary to reuse the wrapped eventloop object. Otherwise the user will end up with multiple
// objects that do not share a common state.
if (this._channel._eventLoop == null)
{
this._channel._eventLoop = new PausableChannelEventLoop(this._channel, eventLoop);
}
else
{
this._channel._eventLoop.Unwrapped = eventLoop;
}
var promise = new TaskCompletionSource();
if (eventLoop.InEventLoop)
{
this.Register0(promise);
}
else
{
try
{
eventLoop.Execute(() => this.Register0(promise));
}
catch (Exception ex)
{
Logger.Warning(
"Force-closing a channel whose registration task was not accepted by an event loop: {0}; Cause: {1}",
_channel,
ex);
CloseForcibly();
_channel._closeTask.TryComplete();
PromiseUtil.SafeSetFailure(promise, ex, Logger);
}
}
return promise.Task;
}
public Task RegisterAsync(IEventLoop eventLoop)
{
Contract.Requires(eventLoop != null);
if (this.channel.Registered)
{
return(TaskEx.FromException(new InvalidOperationException("registered to an event loop already")));
}
if (!this.channel.IsCompatible(eventLoop))
{
return(TaskEx.FromException(new InvalidOperationException("incompatible event loop type: " + eventLoop.GetType().Name)));
}
// It's necessary to reuse the wrapped eventloop object. Otherwise the user will end up with multiple
// objects that do not share a common state.
if (this.channel.eventLoop == null)
{
this.channel.eventLoop = new PausableChannelEventLoop(this.channel, eventLoop);
}
else
{
this.channel.eventLoop.Unwrapped = eventLoop;
}
var promise = new TaskCompletionSource();
if (eventLoop.InEventLoop)
{
this.Register0(promise);
}
else
{
try
{
eventLoop.Execute(() => this.Register0(promise));
}
catch (Exception ex)
{
Logger.Warn(
string.Format("Force-closing a channel whose registration task was not accepted by an event loop: {0}", this.channel),
ex);
this.CloseForcibly();
this.channel.closeFuture.Complete();
Util.SafeSetFailure(promise, ex, Logger);
}
}
return(promise.Task);
}
public Task RegisterAsync(IEventLoop eventLoop)
{
Contract.Requires(eventLoop != null);
if (this.channel.Registered)
{
return TaskEx.FromException(new InvalidOperationException("registered to an event loop already"));
}
if (!this.channel.IsCompatible(eventLoop))
{
return TaskEx.FromException(new InvalidOperationException("incompatible event loop type: " + eventLoop.GetType().Name));
}
this.channel.eventLoop = eventLoop;
var promise = new TaskCompletionSource();
if (eventLoop.InEventLoop)
{
this.Register0(promise);
}
else
{
try
{
eventLoop.Execute((u, p) => ((AbstractUnsafe)u).Register0((TaskCompletionSource)p), this, promise);
}
catch (Exception ex)
{
Logger.Warn("Force-closing a channel whose registration task was not accepted by an event loop: {}", this.channel, ex);
this.CloseForcibly();
this.channel.closeFuture.Complete();
Util.SafeSetFailure(promise, ex, Logger);
}
}
return promise.Task;
}
