public override bool OnStart() { // Set the maximum number of concurrent connections ServicePointManager.DefaultConnectionLimit = 12; // read storage account configuration settings CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) => { configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)); }); var _azure = new AzureRealm(); // initialize blob storage _storage = _azure.StorageProvider; _storage.CreateBucket("guestbookpics1"); // initialize queue storage _queueProvider = _azure.QueueProvider; _queueProvider.CreateQueue("guestthumbs"); _queue = _queueProvider.GetQueueById("guestthumbs"); Trace.TraceInformation("Creating container and queue..."); return base.OnStart(); }
protected override IQueue<SimpleWorkItem> GetQueue(int retries = 1, TimeSpan? workItemTimeout = null, TimeSpan? retryDelay = null, int deadLetterMaxItems = 100, bool runQueueMaintenance = true) { if (_queue == null) _queue = new InMemoryQueue<SimpleWorkItem>(retries, retryDelay, workItemTimeout: workItemTimeout, loggerFactory: Log); _logger.Debug("Queue Id: {queueId}", _queue.QueueId); return _queue; }
private StatusUpdater() { roverStatus = new RoverStatus(); //timer = new System.Timers.Timer(Properties.Settings.Default.StatusUpdateInterval) { Enabled = false }; updatesQueue = new PriorityQueue(100); listener = new MessageListener(Properties.NetworkSettings.Default.StatusUpdatePort, updatesQueue, Properties.NetworkSettings.Default.RoverIPAddress); }
internal LuceneSearchDeps(SearcherManager searcherManager, QueryParser parser, IMetaDataResolver resolver, IQueue queue) { this.SearcherManager = searcherManager; this.Parser = parser; this.Resolver = resolver; this.Queue = queue; }
public Mailer(IEmailGenerator emailGenerator, IQueue<MailMessage> queue, FormattingPluginManager pluginManager, IMetricsClient metrics, ILogger<Mailer> logger) { _emailGenerator = emailGenerator; _queue = queue; _pluginManager = pluginManager; _metrics = metrics; _logger = logger; }
public MessagePublisher(IAdvancedBus bus, ILogger logger, IExchange exchange, IQueue queue) { _bus = bus; _logger = logger; _exchange = exchange; _queue = queue; }
public SystemHealthChecker(ICacheClient cacheClient, IElasticClient elasticClient, IFileStorage storage, IQueue<StatusMessage> queue, IMessageBus messageBus) { _cacheClient = cacheClient; _elasticClient = elasticClient; _storage = storage; _queue = queue; _messageBus = messageBus; }
public QueuePublisher(ISession session, string queueName) { this.session = session; DestinationName = queueName; queue = SessionUtil.GetQueue(session, DestinationName); Producer = session.CreateProducer(queue); }
public void SetUp() { eventBus = new EventBus(); internalConsumers = new List<IInternalConsumer>(); createConsumerCalled = 0; mockBuilder = new MockBuilder(); queue = new Queue(queueName, false); onMessage = (body, properties, info) => Task.Factory.StartNew(() => { }); persistentConnection = MockRepository.GenerateStub<IPersistentConnection>(); internalConsumerFactory = MockRepository.GenerateStub<IInternalConsumerFactory>(); internalConsumerFactory.Stub(x => x.CreateConsumer()).WhenCalled(x => { var internalConsumer = MockRepository.GenerateStub<IInternalConsumer>(); internalConsumers.Add(internalConsumer); createConsumerCalled++; x.ReturnValue = internalConsumer; }).Repeat.Any(); consumer = new PersistentConsumer( queue, onMessage, persistentConnection, internalConsumerFactory, eventBus); AdditionalSetup(); }
public ExclusiveConsumer( IQueue queue, Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IPersistentConnection connection, IConsumerConfiguration configuration, IInternalConsumerFactory internalConsumerFactory, IEventBus eventBus ) { Preconditions.CheckNotNull(queue, "queue"); Preconditions.CheckNotNull(onMessage, "onMessage"); Preconditions.CheckNotNull(connection, "connection"); Preconditions.CheckNotNull(internalConsumerFactory, "internalConsumerFactory"); Preconditions.CheckNotNull(eventBus, "eventBus"); Preconditions.CheckNotNull(configuration, "configuration"); this.queue = queue; this.onMessage = onMessage; this.connection = connection; this.configuration = configuration; this.internalConsumerFactory = internalConsumerFactory; this.eventBus = eventBus; timer = new Timer(s => { StartConsumer(); ((Timer)s).Change(10000, -1); }); timer.Change(10000, -1); }
static IronMQReceiver() { string projectId = ConfigurationManager.AppSettings["IRON_MQ_PROJECT_ID"]; var token = ConfigurationManager.AppSettings["IRON_MQ_TOKEN"]; var client = new Client(projectId, token); queue = client.Queue("IronMQChat"); }
/// <summary> /// Record from a queue. The only real use case for this record as of now. /// </summary> /// <param name="queue">The queue to create this record from.</param> public ContextSwitchRecord(IQueue queue) { Process next = queue.GetContextSwitch(); this.Ready = new List<ProcessRecord>(); this.IO = new List<ProcessRecord>(); this.Complete = new List<ProcessRecord>(); this.Running = null; if (next != null && queue.State != QueueState.COMPLETE) this.Running = new ProcessRecord(next.Name, next.Parent.Name, next.Time.Current.Duration); this.Time = queue.TotalTime - 1; //-1 because we're checking this AFTER it has incremented times. foreach (Process p in queue.CompleteProcs) { ProcessRecord add = new ProcessRecord() { Name = p.Name, Parent = p.Parent.Name, CurrentTime = p.Time.Current == null ? 0 : p.Time.Current.Duration }; this.Complete.Add(add); } foreach (Process p in queue.IOProcs) this.IO.Add(new ProcessRecord(p.Name, p.Parent.Name, p.Time.Current.Duration)); foreach (Process p in queue.ReadyProcs) { if(p != next) this.Ready.Add(new ProcessRecord(p.Name, p.Parent.Name, p.Time.Current.Duration)); } }
internal AudioscrobblerConnection(IQueue queue) { LastfmCore.Account.Updated += AccountUpdated; state = State.Idle; this.queue = queue; }
public PlainWorkerPool(IQueue workQueue, int nWorkers) { this.nWorkers = nWorkers; this.workQueue = workQueue; for (int i = 0; i < nWorkers; ++i) activate(); }
public ThrottleBotsPlugin(ICacheClient cacheClient, IEventRepository eventRepository, IProjectRepository projectRepository, IMetricsClient metricsClient, IQueue<WorkItemData> workItemQueue) { _cacheClient = cacheClient; _metricsClient = metricsClient; _eventRepository = eventRepository; _projectRepository = projectRepository; _workItemQueue = workItemQueue; }
public void Bind(IQueue destination, IExchange source, params string[] topics) { foreach (var topic in topics) { _model.QueueBind(destination.Name, source.Name, topic); } }
public void AddPool(IQueue<PacketEventArgs> item) { if (!this.container.Contains<IQueue<PacketEventArgs>>(item)) { this.container.Add(item); } }
public QueueNotificationAction(IQueue<EventNotificationWorkItem> notificationQueue, IQueue<WebHookNotification> webHookNotificationQueue, IWebHookRepository webHookRepository, WebHookDataPluginManager webHookDataPluginManager, ILoggerFactory loggerFactory = null) : base(loggerFactory) { _notificationQueue = notificationQueue; _webHookNotificationQueue = webHookNotificationQueue; _webHookRepository = webHookRepository; _webHookDataPluginManager = webHookDataPluginManager; ContinueOnError = true; }
public AdminController(IFileStorage fileStorage, IMessagePublisher messagePublisher, IOrganizationRepository organizationRepository, IQueue<EventPost> eventPostQueue, IQueue<WorkItemData> workItemQueue) { _fileStorage = fileStorage; _messagePublisher = messagePublisher; _organizationRepository = organizationRepository; _eventPostQueue = eventPostQueue; _workItemQueue = workItemQueue; }
public QueueSender(ISession session, String destination) { Dectinanion = destination; this.session = session; queue = new ActiveMQQueue(Dectinanion); Producer = this.session.CreateProducer(queue); }
public static void Main(string[] args) { Console.CursorVisible = false; StartDisplayingLogMessages(); var muxer = ConnectionMultiplexer.Connect("localhost"); _queue = new RedisQueue<PingRequest>(muxer); var tokenSource = new CancellationTokenSource(); CancellationToken token = tokenSource.Token; WriteOptionsMenu(); while (true) { Console.SetCursorPosition(0, OPTIONS_MENU_LINE_COUNT + 1); ConsoleKeyInfo keyInfo = Console.ReadKey(true); if (keyInfo.Key == ConsoleKey.D1) EnqueuePing(); else if (keyInfo.Key == ConsoleKey.D2) EnqueuePing(100); //else if (keyInfo.Key == ConsoleKey.D3) // EnqueueContinuousPings(50, token, 100); //else if (keyInfo.Key == ConsoleKey.D4) // EnqueueContinuousPings(50, token, 100); else if (keyInfo.Key == ConsoleKey.Q) break; else if (keyInfo.Key == ConsoleKey.S) { tokenSource.Cancel(); tokenSource = new CancellationTokenSource(); token = tokenSource.Token; ClearOutputLines(); } } }
public QueueMessageProcessor(ISleepService sleepService, IQueue queue, ITraceService traceService, IQueueMessageParser messageParser) { _sleepService = sleepService; _queue = queue; _traceService = traceService; _messageParser = messageParser; }
public DistributeMessageEventArgs(PipelineEvent pipelineEvent, IQueue destinationQueue, TransportMessage transportMessage) : base(pipelineEvent) { DestinationQueue = destinationQueue; TransportMessage = transportMessage; }
static ValidateCodelineBus() { Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString); RequestExchange = new ExchangePublisher<ValidateBatchCodelineRequest>(Bus); Queue = Bus.QueueDeclare(ConfigurationHelper.ValidateCodelineResponseQueueName); }
static GetVouchersInformationBus() { Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString); ResponseExchange = new ExchangePublisher<GetVouchersInformationResponse>(Bus); RequestQueue = Bus.QueueDeclare(ConfigurationHelper.GetPoolVouchersQueueName); }
static CreateAdjustmentLettersBus() { Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString); RequestExchange = new ExchangePublisher<CreateBatchAdjustmentLettersRequest>(Bus); Queue = Bus.QueueDeclare(ConfigurationHelper.ResponseQueueName); }
public MyAppElasticConfiguration(IQueue<WorkItemData> workItemQueue, ICacheClient cacheClient, IMessageBus messageBus, ILoggerFactory loggerFactory) : base(workItemQueue, cacheClient, messageBus, loggerFactory) { AddIndex(Identities = new IdentityIndex(this)); AddIndex(Employees = new EmployeeIndex(this)); AddIndex(MonthlyEmployees = new MonthlyEmployeeIndex(this, 1)); AddIndex(DailyLogEvents = new DailyLogEventIndex(this)); AddIndex(MonthlyLogEvents = new MonthlyLogEventIndex(this)); AddIndex(ParentChild = new ParentChildIndex(this)); }
static CorrectTransactionBus() { Bus = MessageBusFactory.CreateBus(ConfigurationHelper.RabbitMqConnectionString); RequestExchange = new ExchangePublisher<CorrectBatchTransactionRequest>(Bus); Queue = Bus.QueueDeclare(ConfigurationHelper.CorrectTransactionResponseQueueName); }
public ResolvedQueue(IQueue queue, Uri uri) { Guard.AgainstNull(queue,"queue"); Guard.AgainstNull(uri, "uri"); _queue = queue; Uri = uri; }
public ReceivePipelineExceptionModule(IQueue inboxWorkQueue) { Guard.AgainstNull(inboxWorkQueue, "inboxWorkQueue"); this.inboxWorkQueue = inboxWorkQueue; log = Log.For(this); }
public WorkItemJob(IQueue <WorkItemData> queue, IMessageBus messageBus, WorkItemHandlers handlers) : base(queue) { _messageBus = messageBus; _handlers = handlers; }
protected SingleThreadEventExecutor(string threadName, TimeSpan breakoutInterval, IQueue <IRunnable> taskQueue) : this(null, threadName, breakoutInterval, taskQueue) { }
public Merger(IQueue <T> queue) { _queue = queue; }
// ---------------------------------- consume -------------------------------------- public IDisposable Consume <T>(IQueue queue, Action <IMessage <T>, MessageReceivedInfo> onMessage) where T : class { return(Consume <T>(queue, onMessage, x => { })); }
public AdminController(IFileStorage fileStorage, IMessagePublisher messagePublisher, IOrganizationRepository organizationRepository, IQueue <EventPost> eventPostQueue) { _fileStorage = fileStorage; _messagePublisher = messagePublisher; _organizationRepository = organizationRepository; _eventPostQueue = eventPostQueue; }
public void CanCreateNamespaceThenCRUDOnQueue() { using (var context = FluentMockContext.Start(this.GetType().FullName)) { var rgName = TestUtilities.GenerateName("javasbmrg"); try { var resourceManager = TestHelper.CreateResourceManager(); var serviceBusManager = TestHelper.CreateServiceBusManager(); Region region = Region.USEast; var rgCreatable = resourceManager.ResourceGroups .Define(rgName) .WithRegion(region); var namespaceDNSLabel = TestUtilities.GenerateName("jvsbns"); var nspace = serviceBusManager.Namespaces .Define(namespaceDNSLabel) .WithRegion(region) .WithNewResourceGroup(rgCreatable) .WithSku(NamespaceSku.PremiumCapacity1) .Create(); Assert.NotNull(nspace); Assert.NotNull(nspace.Inner); String queueName = TestUtilities.GenerateName("queue14444444444444444444444444444444444444444444555555555555"); var queue = nspace.Queues .Define(queueName) .Create(); Assert.NotNull(queue); Assert.NotNull(queue.Inner); Assert.NotNull(queue.Name); Assert.Equal(queue.Name, queueName, ignoreCase: true); // Default lock duration is 1 minute, assert TimeSpan("00:01:00") parsing // Assert.Equal("00:01:00", queue.Inner.LockDuration); Assert.Equal(60, queue.LockDurationInSeconds); var dupDetectionDuration = queue.DuplicateMessageDetectionHistoryDuration; Assert.Equal(10, dupDetectionDuration.TotalMinutes); // Default message TTL is TimeSpan.Max, assert parsing // Assert.Equal("10675199.02:48:05.4775807", queue.Inner.DefaultMessageTimeToLive); var msgTtlDuration = queue.DefaultMessageTtlDuration; // Assert the default ttl TimeSpan("10675199.02:48:05.4775807") parsing // Assert.Equal(10675199, msgTtlDuration.Days); Assert.Equal(2, msgTtlDuration.Hours); Assert.Equal(48, msgTtlDuration.Minutes); // Assert the default max size In MB // Assert.Equal(1024, queue.MaxSizeInMB); var queuesInNamespace = nspace.Queues.List(); Assert.NotNull(queuesInNamespace); Assert.True(queuesInNamespace.Count() > 0); IQueue foundQueue = queuesInNamespace.FirstOrDefault(q => q.Name.Equals(queueName, StringComparison.OrdinalIgnoreCase)); Assert.NotNull(foundQueue); // Dead lettering disabled by default // Assert.False(foundQueue.IsDeadLetteringEnabledForExpiredMessages); foundQueue = foundQueue.Update() .WithMessageLockDurationInSeconds(120) .WithDefaultMessageTTL(new TimeSpan(0, 20, 0)) .WithExpiredMessageMovedToDeadLetterQueue() .WithMessageMovedToDeadLetterQueueOnMaxDeliveryCount(25) .Apply(); Assert.Equal(120, foundQueue.LockDurationInSeconds); Assert.True(foundQueue.IsDeadLetteringEnabledForExpiredMessages); Assert.Equal(25, foundQueue.MaxDeliveryCountBeforeDeadLetteringMessage); queuesInNamespace = nspace.Queues.List(); Assert.NotNull(queuesInNamespace); Assert.True(queuesInNamespace.Count() > 0); foundQueue = queuesInNamespace.FirstOrDefault(q => q.Name.Equals(queueName, StringComparison.OrdinalIgnoreCase)); Assert.NotNull(foundQueue); Assert.Equal(120, foundQueue.LockDurationInSeconds); Assert.True(foundQueue.IsDeadLetteringEnabledForExpiredMessages); Assert.Equal(25, foundQueue.MaxDeliveryCountBeforeDeadLetteringMessage); nspace.Queues.DeleteByName(foundQueue.Name); } finally { try { TestHelper.CreateResourceManager().ResourceGroups.DeleteByName(rgName); } catch { } } } }
public QueueController(IQueue queue) { this._queue = queue; }
/// <summary>Creates a new instance of <see cref="SingleThreadEventLoop"/>.</summary> protected SingleThreadEventLoop(IEventLoopGroup parent, string threadName, TimeSpan breakoutInterval, IQueue <IRunnable> taskQueue) : base(parent, threadName, breakoutInterval, taskQueue) { }
public EmailSubscription CreateEmailSubscription(string emailAddress, bool?json, IDictionary <string, SubscriptionFilter> filterPolicy, IQueue queue) { return(new EmailSubscription(emailAddress, new EmailSubscriptionProps { Json = json, DeadLetterQueue = queue, FilterPolicy = filterPolicy })); }
public QueueJobBase(IQueue <T> queue, ILoggerFactory loggerFactory = null) : this(new Lazy <IQueue <T> >(() => queue), loggerFactory) { }
public void Merge(T[] Arr, int start1, int length1, int length2) { int aPos; int bPos; int arrEnd; int medium = start1 + length1;; IQueue <T> queue = _queue ?? new ArrayQueue <T>(length1 >> 1);; if (Arr[medium].CompareTo(Arr[medium - 1]) > 0) { return; } aPos = start1; bPos = medium; arrEnd = medium + length2; var ahalf = length1 >> 2 + aPos; while (aPos < medium && bPos < arrEnd) { if (queue.Length > 0) { var savedItem = queue.Look(); var aPartItem = Arr[aPos]; var bPartItem = Arr[bPos]; if ((savedItem.CompareTo(aPartItem) < 0) && (savedItem.CompareTo(bPartItem) < 0)) { // use saved Item queue.Next(); queue.Put(aPartItem); Arr[aPos] = savedItem; aPos++; continue; } if ((aPartItem.CompareTo(savedItem) <= 0) && (aPartItem.CompareTo(bPartItem) <= 0)) { // use item from 1st part - no chages aPos++; continue; } if ((bPartItem.CompareTo(savedItem) <= 0) && (bPartItem.CompareTo(aPartItem)) < 0) { // use Item from second part queue.Put(aPartItem); Arr[aPos] = bPartItem; aPos++; bPos++; continue; } } else { // no items in queue - just compare items from meged parts var aItem = Arr[aPos]; var bItem = Arr[bPos]; if (aItem.CompareTo(bItem) <= 0) //<= { aPos++; continue; } else { queue.Put(aItem); Arr[aPos] = bItem; aPos++; bPos++; } } } // tail of 2nd part int c = medium; while (c < arrEnd && bPos < arrEnd && queue.Length > 0) { var savedItem = queue.Look(); //if (savedItem < Arr[bPos]) if (savedItem.CompareTo(Arr[bPos]) < 0) { Arr[c++] = savedItem; queue.Next(); } else { Arr[c++] = Arr[bPos]; // Arr[b] = -1; bPos++; } } // just put saved Items to the end if (queue.Length > 0) { var cnt = queue.Length; var start = arrEnd - cnt; for (var i = start; i < arrEnd; i++) { Arr[i] = queue.Get(); } } }
public SqlProc(IQueueManger queueManger, IQueue queueSql) { QueueSql = queueSql; QueueManger = queueManger; }
public virtual IDisposable Consume(IQueue queue, Action <IHandlerRegistration> addHandlers) { return(Consume(queue, addHandlers, x => { })); }
public ThrottleBotsPlugin(ICacheClient cacheClient, IQueue <WorkItemData> workItemQueue) { _cacheClient = cacheClient; _workItemQueue = workItemQueue; }
public void RegistrateQueue(IQueue queue) { queues.Add(queue.QueueName, queue); }
public IDisposable Consume(IQueue queue, Func <byte[], MessageProperties, MessageReceivedInfo, Task> onMessage) { return(Consume(queue, onMessage, x => { })); }
public virtual IDisposable Consume <T>(IQueue queue, Func <IMessage <T>, MessageReceivedInfo, Task> onMessage) where T : class { return(Consume(queue, onMessage, x => { })); }
private Manager() { _croutonQueue = new LinkedBlockingQueue(); }
public MailMessageJob(IQueue <MailMessage> queue, IMailSender mailSender, ILoggerFactory loggerFactory) : base(queue, loggerFactory) { _mailSender = mailSender; AutoComplete = true; }
public Compressor(string name, ILogger logger, Action <Exception> exceptionHandler, ISystemInfoProvider systemInfoProvide, ProcessStatistic statistic, IQueue nextQueue) : base(name, logger, exceptionHandler, systemInfoProvide, statistic, nextQueue) { }
public EnqueueOrganizationNotificationOnPlanOverage(IQueue <WorkItemData> workItemQueue, IMessageSubscriber subscriber, ILoggerFactory loggerFactory = null) { _workItemQueue = workItemQueue; _subscriber = subscriber; _logger = loggerFactory.CreateLogger <EnqueueOrganizationNotificationOnPlanOverage>(); }
/// <inheritdoc/> public override void FilterWrite(INextFilter nextFilter, IoSession session, IWriteRequest writeRequest) { Object message = writeRequest.Message; // Bypass the encoding if the message is contained in a IoBuffer, // as it has already been encoded before if (message is IoBuffer || message is IFileRegion) { nextFilter.FilterWrite(session, writeRequest); return; } // Get the encoder in the session IProtocolEncoder encoder = _factory.GetEncoder(session); IProtocolEncoderOutput encoderOut = GetEncoderOut(session, nextFilter, writeRequest); if (encoder == null) { throw new ProtocolEncoderException("The encoder is null for the session " + session); } if (encoderOut == null) { throw new ProtocolEncoderException("The encoderOut is null for the session " + session); } try { encoder.Encode(session, message, encoderOut); AbstractProtocolEncoderOutput ape = encoderOut as AbstractProtocolEncoderOutput; if (ape != null) { // Send it directly IQueue <Object> bufferQueue = ape.MessageQueue; // Write all the encoded messages now while (!bufferQueue.IsEmpty) { Object encodedMessage = bufferQueue.Dequeue(); if (encodedMessage == null) { break; } // Flush only when the buffer has remaining. IoBuffer buf = encodedMessage as IoBuffer; if (buf == null || buf.HasRemaining) { IWriteRequest encodedWriteRequest = new EncodedWriteRequest(encodedMessage, null, writeRequest.Destination); nextFilter.FilterWrite(session, encodedWriteRequest); } } } // Call the next filter nextFilter.FilterWrite(session, new MessageWriteRequest(writeRequest)); } catch (Exception ex) { ProtocolEncoderException pee = ex as ProtocolEncoderException; if (pee == null) { pee = new ProtocolEncoderException(null, ex); } throw pee; } }
public ElasticConfiguration(IQueue <WorkItemData> workItemQueue, ICacheClient cacheClient, ILogger <ElasticConfiguration> logger) : base(workItemQueue, cacheClient) { _logger = logger; }
public BasicConsumer(Action <BasicConsumer> cancelled, IConsumerDispatcher consumerDispatcher, IQueue queue, IEventBus eventBus, IHandlerRunner handlerRunner, Func <byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IEasyNetQLogger logger, IModel model) { Queue = queue; OnMessage = onMessage; this.cancelled = cancelled; this.consumerDispatcher = consumerDispatcher; this.eventBus = eventBus; this.handlerRunner = handlerRunner; this.logger = logger; Model = model; }
protected SingleThreadEventExecutor(IEventExecutorGroup parent, string threadName, TimeSpan breakoutInterval, IQueue <IRunnable> taskQueue) : base(parent) { this.terminationCompletionSource = new TaskCompletionSource(); this.taskQueue = taskQueue; this.preciseBreakoutInterval = PreciseTimeSpan.FromTimeSpan(breakoutInterval); this.scheduler = new ExecutorTaskScheduler(this); this.thread = new Thread(this.Loop); if (string.IsNullOrEmpty(threadName)) { this.thread.Name = DefaultWorkerThreadName; } else { this.thread.Name = threadName; } this.thread.Start(); }
public static IServiceCollection AddRabbitQueue(this IServiceCollection services, IQueue queue) { return(services.AddSingleton(queue)); }
public SampleQueueJob(IQueue <SampleQueueWorkItem> queue, IMetricsClient metrics) : base(queue) { _metrics = metrics; }
protected override Task CleanupQueueAsync(IQueue <SimpleWorkItem> queue) { // Don't delete the queue, it's super expensive and will be cleaned up later. queue?.Dispose(); return(Task.CompletedTask); }
internal BaseOnBackpressureBufferSubscriber(int capacityHint) { this.queue = new SpscLinkedArrayQueue <T>(capacityHint); }
/// <summary>Creates a new instance of <see cref="SingleThreadEventLoop"/>.</summary> protected SingleThreadEventLoop(string threadName, TimeSpan breakoutInterval, IQueue <IRunnable> taskQueue) : base(null, threadName, breakoutInterval, taskQueue) { }