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))); }