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