PipeContextHandle <TContext> GetContext()
{
lock (_contextLock)
{
if (_context != null && _context.IsDisposed == false)
{
return(_context);
}
PipeContextHandle <TContext> context = _context = _contextFactory.CreateContext(this);
void ClearContext(Task task)
{
Interlocked.CompareExchange(ref _context, null, context);
}
context.Context.ContinueWith(ClearContext, CancellationToken.None, TaskContinuationOptions.NotOnRanToCompletion, TaskScheduler.Default);
SetReady(context.Context);
return(context);
}
}
public IActivePipeContextAgent <ProcessorContext> CreateActiveContext(ISupervisor supervisor,
PipeContextHandle <ProcessorContext> context, CancellationToken cancellationToken = new CancellationToken())
{
return(supervisor.AddActiveContext(context, CreateSharedConnection(context.Context, cancellationToken)));
}
/// <summary>
/// Adds a context to the supervisor as an agent, which can be stopped by the supervisor.
/// </summary>
/// <param name="supervisor">The supervisor</param>
/// <param name="contextHandle">The actual context handle</param>
/// <param name="context">The active context</param>
/// <typeparam name="T">The context type</typeparam>
/// <returns>A context handle</returns>
public static IActivePipeContextAgent <T> AddActiveContext <T>(this ISupervisor supervisor, PipeContextHandle <T> contextHandle, T context)
where T : class, PipeContext
{
if (supervisor == null)
{
throw new ArgumentNullException(nameof(supervisor));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var activeContext = new ActivePipeContext <T>(contextHandle, context);
var contextAgent = new ActivePipeContextAgent <T>(activeContext);
supervisor.Add(contextAgent);
return(contextAgent);
}
IActivePipeContextAgent <ConnectionContext> IPipeContextFactory <ConnectionContext> .CreateActiveContext(ISupervisor supervisor,
PipeContextHandle <ConnectionContext> context, CancellationToken cancellationToken)
{
return(supervisor.AddActiveContext(context, CreateSharedConnection(context.Context, cancellationToken)));
}
public IActivePipeContextAgent <SendEndpointContext> CreateActiveContext(ISupervisor supervisor, PipeContextHandle <SendEndpointContext> context,
CancellationToken cancellationToken)
{
return(supervisor.AddActiveContext(context, CreateSharedContext(context.Context, cancellationToken)));
}
public IActivePipeContextAgent <ClientContext> CreateActiveContext(ISupervisor supervisor, PipeContextHandle <ClientContext> context,
CancellationToken cancellationToken = default)
{
return(supervisor.AddActiveContext(context, CreateSharedConnection(context.Context, cancellationToken)));
}
public IActivePipeContextAgent <SimpleContext> CreateActiveContext(ISupervisor supervisor, PipeContextHandle <SimpleContext> context,
CancellationToken cancellationToken = default(CancellationToken))
{
return(supervisor.AddActiveContext(context, CreateActiveContext(context.Context, cancellationToken)));
}
/// <summary>
/// Creates the active pipe context handle, which must have completed before this instance is created. Otherwise,
/// it would create a pretty nasty async mess that wouldn't handle faults very well (actually, it should, but I haven't tested it).
/// </summary>
/// <param name="contextHandle">The context handle of the actual context which is being used</param>
/// <param name="context">The actual context</param>
public ActivePipeContext(PipeContextHandle <TContext> contextHandle, TContext context)
{
_contextHandle = contextHandle;
_context = Task.FromResult(context);
}
/// <summary>
/// Creates the active pipe context handle, which must have completed before this instance is created. Otherwise,
/// it would create a pretty nasty async mess that wouldn't handle faults very well (actually, it should, but I haven't tested it).
/// </summary>
/// <param name="contextHandle">The context handle of the actual context which is being used</param>
/// <param name="context">The actual context, which should be a completed Task</param>
public ActivePipeContext(PipeContextHandle <TContext> contextHandle, Task <TContext> context)
{
_contextHandle = contextHandle;
_context = context;
}
IActivePipeContextAgent <TContext> CreateActiveContext(CancellationToken cancellationToken)
{
PipeContextHandle <TContext> pipeContextHandle = GetContext();
return(_contextFactory.CreateActiveContext(_activeSupervisor, pipeContextHandle, cancellationToken));
}
public IActivePipeContextAgent <ConsumerContext <TKey, TValue> > CreateActiveContext(ISupervisor supervisor,
PipeContextHandle <ConsumerContext <TKey, TValue> > context, CancellationToken cancellationToken = new CancellationToken())
{
return(supervisor.AddActiveContext(context, CreateSharedConnection(context.Context, cancellationToken)));
}
