public void setup() { _pollerSource = Substitute.For<IPollSource<string>>(); _pollerSource.TryGet(out dummy).Returns(false); _subject = new PollingWorkQueue<string>(_pollerSource); }
public void setup() { _dispatcher = Substitute.For<IDispatch<object>>(); _queue = new InMemoryWorkQueue<object>(); _subject = new DirectWorkerPool<object>(); _subject.SetSource(_dispatcher, _queue); }
public override void setup() { _output = new List<string>(); _boundedWorkQueue = new BoundedWorkQueue<string>(Bound); _subject = new Dispatch<string>( _boundedWorkQueue, new DirectWorkerPool<string>()); }
public void setup() { _actionCalled = false; _dispatcher = Substitute.For<IDispatch<object>>(); _dispatcher.MaximumInflight().Returns(1); _queue = Substitute.For<IWorkQueue<object>>(); _subject = new ThreadedWorkerPool<object>("name", 1); _subject.SetSource(_dispatcher, _queue); }
public override void setup() { _output = new List<string>(); _boundedWorkQueue = new BoundedWorkQueue<string>(Bound); _subject = new Dispatch<string>( _boundedWorkQueue, new ThreadedWorkerPool<string>("Test", 8)); _maxQueueSize = 0; }
public void Add(IWorkQueue queue, bool autoUpdate) { if (!ListsByPriority.TryGetValue(queue.Priority, out ListForPriority lfp)) { ListsByPriority[queue.Priority] = lfp = new ListForPriority(queue.Priority); } lfp.Add(queue); if (autoUpdate) { UpdateItems(); } }
public IngressController( ICache cache, IReconciler reconciler, IResourceInformer <V1Ingress> ingressInformer, IResourceInformer <V1Service> serviceInformer, IResourceInformer <V1Endpoints> endpointsInformer, IHostApplicationLifetime hostApplicationLifetime, ILogger <IngressController> logger) : base(hostApplicationLifetime, logger) { if (ingressInformer is null) { throw new ArgumentNullException(nameof(ingressInformer)); } if (serviceInformer is null) { throw new ArgumentNullException(nameof(serviceInformer)); } if (endpointsInformer is null) { throw new ArgumentNullException(nameof(endpointsInformer)); } if (hostApplicationLifetime is null) { throw new ArgumentNullException(nameof(hostApplicationLifetime)); } if (logger is null) { throw new ArgumentNullException(nameof(logger)); } _registrations = new[] { ingressInformer.Register(Notification), serviceInformer.Register(Notification), endpointsInformer.Register(Notification), }; _queue = new ProcessingRateLimitedQueue <QueueItem>(perSecond: 0.5, burst: 1); _cache = cache ?? throw new ArgumentNullException(nameof(cache)); _reconciler = reconciler ?? throw new ArgumentNullException(nameof(reconciler)); _reconciler.OnAttach(TargetAttached); _ingressChangeQueueItem = new QueueItem("Ingress Change", null); }
public Consumer(IWorkQueue workQueue, ITransformer transformer) { if (workQueue == null) { throw new ArgumentNullException(nameof(workQueue)); } if (transformer == null) { throw new ArgumentNullException(nameof(transformer)); } _workQueue = workQueue; _transformer = transformer; }
public static Task EnqueueAsync([NotNull] this IWorkQueue workQueue, [NotNull] object item, [CanBeNull] DateTime?whenToProcess = null) { if (workQueue is null) { throw new ArgumentNullException(nameof(workQueue)); } if (item == null) { throw new ArgumentNullException(nameof(item)); } return(workQueue.EnqueueManyAsync(new[] { item }, whenToProcess)); }
/// <summary> Batch process works </summary> /// <param name="queue"> Work Queue instance </param> /// <param name="works"> Works to process </param> /// <param name="cancellation"> Processing cancellation token </param> /// <param name="attemptsCount"> Retry on fail attempts count </param> /// <param name="enqueueAll"> Option to enqueue all data first </param> /// <typeparam name="TResult"> Processing result type </typeparam> /// <returns> Processing result task enumeration </returns> /// <exception cref="ArgumentNullException"> Thrown if <paramref name="queue" /> or <paramref name="works" /> is NULL </exception> public static async IAsyncEnumerable <TResult> DoWorkAsync <TResult>(this IWorkQueue queue, IEnumerable <IWork <TResult> > works, [EnumeratorCancellation] CancellationToken cancellation = default, int attemptsCount = 1, bool enqueueAll = false) { _ = queue ?? throw new ArgumentNullException(nameof(queue)); var results = (works ?? throw new ArgumentNullException(nameof(works))).Select(work => queue.EnqueueWork(work, cancellation, attemptsCount)); if (enqueueAll) { results = results.ToList(); } foreach (var result in results) { yield return(await result.ConfigureAwait(false)); } }
/// <summary> /// Default constructor /// </summary> /// <param name="context"></param> /// <param name="logger"></param> /// <param name="mapper"></param> /// <param name="httpClient"></param> /// <param name="appSettings"></param> /// <param name="analyticsService"></param> /// <param name="recommendationService"></param> /// <param name="distributedCache"></param> /// <param name="workQueue"></param> /// <param name="popularityService"></param> public EventService(ApplicationContext context, ILogger <EventService> logger, IMapper mapper, HttpClient httpClient, IOptions <AppSettings> appSettings, IAnalyticsService analyticsService, IRecommendationService recommendationService, IDistributedCache distributedCache, IWorkQueue workQueue, IPopularityService popularityService) { Logger = logger; ApplicationContext = context; Mapper = mapper; HttpClient = httpClient; AppSettings = appSettings.Value; AnalyticsService = analyticsService; RecommendationService = recommendationService; DistributedCache = distributedCache; WorkQueue = workQueue; PopularityService = popularityService; }
public void enqueue_is_exception_safe() { _subject = new BoundedWorkQueue<object>(_mockQueue, 1); var objectToThrowAt = new object(); _mockQueue.When(queue => queue.Enqueue(objectToThrowAt)) .Do(_ => { throw new DummyException(); }); try { _subject.Enqueue(objectToThrowAt); } catch (DummyException) { } _subject.Enqueue(new object()); }
public Producer(IWorkQueue workQueue, IEnumerable <IXPathNavigable> documents, string outputDir) { if (workQueue == null) { throw new ArgumentNullException(nameof(workQueue)); } if (documents == null) { throw new ArgumentNullException(nameof(documents)); } if (outputDir == null) { throw new ArgumentNullException(nameof(outputDir)); } _workQueue = workQueue; _documents = documents; _outputDir = outputDir; }
/// <inheritdoc cref="DoWorkAsync{TResult}(IWorkQueue,IEnumerable{IAsyncWork{TResult}},CancellationToken,int,bool)" /> public static async IAsyncEnumerable <TResult> DoWorkAsync <TResult>(this IWorkQueue queue, IAsyncEnumerable <IAsyncWork <TResult> > works, [EnumeratorCancellation] CancellationToken cancellation = default, int attemptsCount = 1) { _ = queue ?? throw new ArgumentNullException(nameof(queue)); var channel = Channel.CreateUnbounded <Task <TResult> >(new UnboundedChannelOptions { SingleReader = true, SingleWriter = true }); var reader = channel.Reader; var writer = channel.Writer; _ = Task.Run(async() => { try { await foreach (var work in works.WithCancellation(cancellation).ConfigureAwait(false)) { await writer.WriteAsync(queue.EnqueueAsyncWork(work, cancellation, attemptsCount), cancellation).ConfigureAwait(false); } } catch (OperationCanceledException ex) { await writer.WriteAsync(Task.FromCanceled <TResult>(ex.CancellationToken), CancellationToken.None).ConfigureAwait(false); } catch (Exception ex) { await writer.WriteAsync(Task.FromException <TResult>(ex), cancellation).ConfigureAwait(false); } finally { writer.Complete(); } }, cancellation); while (await reader.WaitToReadAsync(cancellation).ConfigureAwait(false)) { yield return(await(await reader.ReadAsync(cancellation).ConfigureAwait(false)).ConfigureAwait(false)); } }
public void Unregister(IWorkQueue wq) { lock (m_queues) m_queues.Remove(wq); }
public CommandHandler(IWorkQueue workQueue, IServiceProvider serviceProvider) { _workQueue = workQueue; _serviceProvider = serviceProvider; }
public void setup() { _queue = Substitute.For<IWorkQueue<object>>(); _pool = Substitute.For<IWorkerPool<object>>(); _pool.PoolSize().Returns(10000); _subject = new Dispatch<object>(_queue, _pool); }
/// <summary> /// Initializes a new instance of the <see cref="WorkQueueBase{TItem}" /> class. /// </summary> /// <param name="workQueue">The work queue.</param> public WorkQueueBase(IWorkQueue <TItem> workQueue) => _base = workQueue;
public WorkQueueException(IWorkQueue queue, string message) : base(message) { Queue = queue; }
/// <summary> Enqueue background work </summary> /// <param name="queue"> Work queue instance </param> /// <param name="cancellation"> Work cancellation token </param> /// <param name="attemptsCount"> Retry on fail attempts count </param> /// <typeparam name="TWork"> Work type </typeparam> /// <returns> Work completion task </returns> /// <exception cref="ArgumentNullException"> Thrown if <paramref name="queue" /> is NULL </exception> public static Task EnqueueWork <TWork>(this IWorkQueue queue, CancellationToken cancellation = default, int attemptsCount = 1) where TWork : IWork => (queue ?? throw new ArgumentNullException(nameof(queue))).EnqueueWork(
/// <inheritdoc /> public BackGroundWorkService(ILogger <BackGroundWorkService> logger, IWorkQueue workQueue) { Logger = logger; WorkQueue = workQueue; }
public RepositoryController(ILoggerFactory logFactory, IAuthHandler auth, IClientFactory clientFactory, IIndexStore indexStore, IWorkQueue <IndexRequest> indexQueue, ISecurityScanner secScanner = null) : base(logFactory, auth) { this.clientFactory = clientFactory; this.logger = logFactory.CreateLogger <RepositoryController>(); this.indexStore = indexStore; this.indexQueue = indexQueue; this.secScanner = secScanner; }
public ClairScanner(ILogger <ClairScanner> logger, ServiceConfig config, IClairAPI clair, ICacheFactory cacheFactory, IWorkQueue <ScanRequest> queue) { this.logger = logger; this.config = config; this.clair = clair; this.cacheFactory = cacheFactory; Queue = queue; }
public WorkQueueBatch(IWorkQueue queue) { mQueue = queue; }
/// <inheritdoc cref="DoWorkAsync{TResult}(IWorkQueue,IEnumerable{IWork{TResult}},CancellationToken,int,bool)" /> public static IAsyncEnumerable <TResult> DoWorkAsync <TResult>(this IEnumerable <IWork <TResult> > works, IWorkQueue queue, CancellationToken cancellation = default, int attemptsCount = 1, bool enqueueAll = false) => (queue ?? throw new ArgumentNullException(nameof(queue))).DoWorkAsync(works, cancellation, attemptsCount, enqueueAll);
/// <summary> Enqueue asynchronous access action into work queue with given <paramref name="priority" /> (if supported) </summary> /// <param name="queue"> Work queue instance </param> /// <param name="priority"> Access action priority </param> /// <param name="cancellation"> Access cancellation token </param> /// <param name="attemptsCount"> Retry on fail attempts count </param> /// <typeparam name="TResource"> Shared resource type</typeparam> /// <typeparam name="TAsyncAccess"> Access action type </typeparam> /// <typeparam name="TResult"> Access action result type </typeparam> /// <returns> Access action completion task </returns> /// <exception cref="ArgumentNullException"> Thrown if <paramref name="queue" /> is NULL </exception> public static Task <TResult> EnqueueAsyncAccess <TResource, TAsyncAccess, TResult>(this IWorkQueue queue, CancellationToken cancellation = default, int attemptsCount = 1, int priority = 0) where TResource : notnull where TAsyncAccess : IAsyncAccess <TResource, TResult> { var work = CreateAsyncWork((provider, cancel) => provider.EnqueueAsyncAccess <TResource, TAsyncAccess, TResult>(cancel, attemptsCount, priority)); return((queue ?? throw new ArgumentNullException(nameof(queue))) is IPriorityWorkQueue priorityQueue ? priorityQueue.EnqueueAsyncWork(work, priority, cancellation) : queue.EnqueueAsyncWork(work, cancellation)); }
internal void RegisterQueue(IWorkQueue queue) { lock (Queues) Queues.Add(queue); }
public QueueEventProducer(IWorkQueue <IEvent> workQueue, int delayInMilliseconds = 1 * 1000) { WorkQueue = workQueue ?? throw new ApplicationException("No work queue was provided"); DelayInMilliseconds = delayInMilliseconds; }
public WorkItemAggregatorService(IWorkQueue <TContext> destination) : base(null) { m_Queue = new WorkQueue <TContext>(destination.Context); m_DestinationQueue = destination; }
public EventContext(IWorkQueue <IEvent> eventQueue = null, double defaultScheduleTimeIntervalInMilliseconds = 60 * 1000) { EventQueue = eventQueue ?? new MemoryEventQueue(); GlobalClock = new TimeEventProducer(defaultScheduleTimeIntervalInMilliseconds); }
/// <summary> /// Default constructor /// </summary> /// <param name="context"></param> /// <param name="logger"></param> /// <param name="mapper"></param> /// <param name="analyticsService"></param> /// <param name="recommendationService"></param> /// <param name="workQueue"></param> public TicketService(ApplicationContext context, ILogger <TicketService> logger, IMapper mapper, IAnalyticsService analyticsService, IRecommendationService recommendationService, IWorkQueue workQueue) { Logger = logger; Mapper = mapper; ApplicationContext = context; AnalyticsService = analyticsService; WorkQueue = workQueue; RecommendationService = recommendationService; }
/// <summary> /// Initializes a new instance of the <see cref="DelayingQueue{TItem}" /> class. /// </summary> public DelayingQueue(ISystemClock clock = default, IWorkQueue <TItem> @base = default) : base(@base ?? new WorkQueue <TItem>()) { _waitingLoopTask = Task.Run(WaitingLoopAsync); _clock = clock ?? new SystemClock(); }
public void setup() { _mockQueue = Substitute.For<IWorkQueue<object>>(); _subject = new BoundedWorkQueue<object>(_mockQueue, Bound); }
public SecurityScanWorker(ILogger <SecurityScanWorker> logger, ServiceConfig config, IWorkQueue <ScanRequest> queue, ISecurityScanner scanner, IClientFactory clientFactory, RegistryAuthenticationDecoder authDecoder, IAuthHandler authHandler) : base(logger, config, queue, clientFactory) { this.scanner = scanner; this.authDecoder = authDecoder; this.authHandler = authHandler; }
public DefaultScheduler(string name, IWorkTaskFactory workTaskFactory, IDownloader downloader, IParserFactory parserFactory, IWorkQueue workQueue) { Name = name; this.workTaskFactory = workTaskFactory; this.downloader = downloader; this.parserFactory = parserFactory; this.workQueue = workQueue; }
public void Register(IWorkQueue wq) { Logging.LogManager.Log.Log(LogLevel.DINITDETAIL, "WorkQueueManager: registering queue {0}", wq.Name); lock (m_queues) m_queues.Add(wq); }