static void Main(string[] args)
{
Console.WriteLine("Listerner Starting");
QueueListener listner = new QueueListener();
listner.DataReceived += listner_DataReceived;
listner.Start();
}
public IListener CreateQueueListenr(
string queue,
string poisonQueue,
Func <string, CancellationToken, Task <FunctionResult> > callback
)
{
// Provide an upper bound on the maximum polling interval for run/abort from dashboard.
// This ensures that if users have customized this value the Dashboard will remain responsive.
TimeSpan maxPollingInterval = QueuePollingIntervals.DefaultMaximum;
var wrapper = new Wrapper
{
_callback = callback
};
IListener listener = new QueueListener(Convert(queue),
poisonQueue: Convert(poisonQueue),
triggerExecutor: wrapper,
exceptionHandler: _exceptionHandler,
loggerFactory: _loggerFactory,
sharedWatcher: _sharedWatcher,
queueOptions: _queueOptions,
queueProcessorFactory: _queueProcessorFactory,
functionDescriptor: new FunctionDescriptor(),
maxPollingInterval: maxPollingInterval);
return(listener);
}
public QueueListenerTests()
{
CloudQueue queue = new CloudQueue(new Uri("https://test.queue.core.windows.net/testqueue"));
Mock <IStorageQueue> mockQueue = new Mock <IStorageQueue>(MockBehavior.Strict);
mockQueue.Setup(p => p.SdkObject).Returns(queue);
_mockTriggerExecutor = new Mock <ITriggerExecutor <IStorageQueueMessage> >(MockBehavior.Strict);
Mock <IDelayStrategy> mockDelayStrategy = new Mock <IDelayStrategy>(MockBehavior.Strict);
Mock <IBackgroundExceptionDispatcher> mockExceptionDispatcher = new Mock <IBackgroundExceptionDispatcher>(MockBehavior.Strict);
TestTraceWriter log = new TestTraceWriter(TraceLevel.Verbose);
Mock <IQueueProcessorFactory> mockQueueProcessorFactory = new Mock <IQueueProcessorFactory>(MockBehavior.Strict);
JobHostQueuesConfiguration queuesConfig = new JobHostQueuesConfiguration();
QueueProcessorFactoryContext context = new QueueProcessorFactoryContext(queue, log, queuesConfig);
_mockQueueProcessor = new Mock <QueueProcessor>(MockBehavior.Strict, context);
JobHostQueuesConfiguration queueConfig = new JobHostQueuesConfiguration
{
MaxDequeueCount = 5,
QueueProcessorFactory = mockQueueProcessorFactory.Object
};
mockQueueProcessorFactory.Setup(p => p.Create(It.IsAny <QueueProcessorFactoryContext>())).Returns(_mockQueueProcessor.Object);
_listener = new QueueListener(mockQueue.Object, null, _mockTriggerExecutor.Object, mockDelayStrategy.Object, mockExceptionDispatcher.Object, log, null, queueConfig);
CloudQueueMessage cloudMessage = new CloudQueueMessage("TestMessage");
_storageMessage = new StorageQueueMessage(cloudMessage);
}
private QueueListener ConfigureQueueListener(ConfigurationContext context, string inboundQueueName,
string outboundQueueName)
{
var inboundQueue = _messageQueueProvider.Open(inboundQueueName);
var outboundQueue = inboundQueueName == outboundQueueName
? inboundQueue
: _messageQueueProvider.Open(outboundQueueName);
var scopeFactory = new ScopeWrapper(context.ServiceProvider);
var router = new MessageRouter
{
ReportAnalyzerQueue = outboundQueue,
AppQueue = _messageQueueProvider.Open("Messaging")
};
var listener = new QueueListener(inboundQueue, router, scopeFactory)
{
RetryAttempts = new[]
{ TimeSpan.FromMilliseconds(500), TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2) },
MessageInvokerFactory = scope =>
{
var invoker = new MessageInvoker(scope);
invoker.Logger += (level, name, message) => _logger.Debug("[" + name + "] " + message);
invoker.InvokingHandler += (sender, args) =>
{
_logger.Debug(
$"Invoking {JsonConvert.SerializeObject(args.Message)} ({args.Handler.GetType()}).");
};
return(invoker);
},
Logger = DiagnosticLog
};
listener.PoisonMessageDetected += (sender, args) =>
{
Err.Report(args.Exception, new { args.Message.Body });
_logger.Error(inboundQueueName + " Poison message: " + args.Message.Body, args.Exception);
};
listener.ScopeCreated += (sender, args) =>
{
args.Scope.ResolveDependency <IPrincipalAccessor>().First().Principal = args.Principal;
_logger.Debug(inboundQueueName + " Running " + args.Message.Body + ", Credentials: " +
args.Principal.ToFriendlyString());
};
listener.ScopeClosing += (sender, args) =>
{
if (args.Exception != null)
{
return;
}
var all = args.Scope.ResolveDependency <IAdoNetUnitOfWork>().ToList();
all[0].SaveChanges();
var queue = (DomainQueueWrapper)args.Scope.ResolveDependency <IDomainQueue>().First();
queue.SaveChanges();
};
listener.MessageInvokerFactory = MessageInvokerFactory;
return(listener);
}
public QueueListenerTests()
{
CloudQueue queue = new CloudQueue(new Uri("https://test.queue.core.windows.net/testqueue"));
_mockQueue = new Mock <IStorageQueue>(MockBehavior.Strict);
_mockQueue.Setup(p => p.SdkObject).Returns(queue);
_mockTriggerExecutor = new Mock <ITriggerExecutor <IStorageQueueMessage> >(MockBehavior.Strict);
Mock <IWebJobsExceptionHandler> mockExceptionDispatcher = new Mock <IWebJobsExceptionHandler>(MockBehavior.Strict);
_loggerFactory = new LoggerFactory();
_loggerFactory.AddProvider(new TestLoggerProvider());
Mock <IQueueProcessorFactory> mockQueueProcessorFactory = new Mock <IQueueProcessorFactory>(MockBehavior.Strict);
JobHostQueuesConfiguration queuesConfig = new JobHostQueuesConfiguration();
QueueProcessorFactoryContext context = new QueueProcessorFactoryContext(queue, _loggerFactory, queuesConfig);
_mockQueueProcessor = new Mock <QueueProcessor>(MockBehavior.Strict, context);
JobHostQueuesConfiguration queueConfig = new JobHostQueuesConfiguration
{
MaxDequeueCount = 5,
QueueProcessorFactory = mockQueueProcessorFactory.Object
};
mockQueueProcessorFactory.Setup(p => p.Create(It.IsAny <QueueProcessorFactoryContext>())).Returns(_mockQueueProcessor.Object);
_listener = new QueueListener(_mockQueue.Object, null, _mockTriggerExecutor.Object, mockExceptionDispatcher.Object, _loggerFactory, null, queueConfig);
CloudQueueMessage cloudMessage = new CloudQueueMessage("TestMessage");
_storageMessage = new StorageQueueMessage(cloudMessage);
}
public QueueListenerTests(TestFixture fixture)
{
Fixture = fixture;
_mockQueue = new Mock <CloudQueue>(new Uri("https://test.queue.core.windows.net/testqueue"));
_mockTriggerExecutor = new Mock <ITriggerExecutor <CloudQueueMessage> >(MockBehavior.Strict);
Mock <IWebJobsExceptionHandler> mockExceptionDispatcher = new Mock <IWebJobsExceptionHandler>(MockBehavior.Strict);
_loggerFactory = new LoggerFactory();
_loggerFactory.AddProvider(new TestLoggerProvider());
Mock <IQueueProcessorFactory> mockQueueProcessorFactory = new Mock <IQueueProcessorFactory>(MockBehavior.Strict);
QueuesOptions queuesOptions = new QueuesOptions();
QueueProcessorFactoryContext context = new QueueProcessorFactoryContext(_mockQueue.Object, _loggerFactory, queuesOptions);
_mockQueueProcessor = new Mock <QueueProcessor>(MockBehavior.Strict, context);
QueuesOptions queueConfig = new QueuesOptions
{
MaxDequeueCount = 5
};
mockQueueProcessorFactory.Setup(p => p.Create(It.IsAny <QueueProcessorFactoryContext>())).Returns(_mockQueueProcessor.Object);
_listener = new QueueListener(_mockQueue.Object, null, _mockTriggerExecutor.Object, mockExceptionDispatcher.Object, _loggerFactory, null, queueConfig, queueProcessorFactory: mockQueueProcessorFactory.Object);
_queueMessage = new CloudQueueMessage("TestMessage");
}
public void Add(QueueListener listener)
{
lock (listener)
{
this.Listeners.Add(listener);
}
}
public async Task GetMetrics_ReturnsExpectedResult()
{
var queuesOptions = new QueuesOptions();
Mock <ITriggerExecutor <QueueMessage> > mockTriggerExecutor = new Mock <ITriggerExecutor <QueueMessage> >(MockBehavior.Strict);
var queueProcessorFactory = new DefaultQueueProcessorFactory();
var queueProcessor = QueueListenerFactory.CreateQueueProcessor(Fixture.Queue, null, _loggerFactory, queueProcessorFactory, queuesOptions, null);
QueueListener listener = new QueueListener(Fixture.Queue, null, mockTriggerExecutor.Object, new WebJobsExceptionHandler(null),
_loggerFactory, null, queuesOptions, queueProcessor, new FunctionDescriptor {
Id = "TestFunction"
});
var metrics = await listener.GetMetricsAsync();
Assert.AreEqual(0, metrics.QueueLength);
Assert.AreEqual(TimeSpan.Zero, metrics.QueueTime);
Assert.AreNotEqual(default(DateTime), metrics.Timestamp);
// add some test messages
for (int i = 0; i < 5; i++)
{
await Fixture.Queue.SendMessageAsync($"Message {i}");
}
await Task.Delay(TimeSpan.FromSeconds(5));
metrics = await listener.GetMetricsAsync();
Assert.AreEqual(5, metrics.QueueLength);
Assert.True(metrics.QueueTime.Ticks > 0);
Assert.AreNotEqual(default(DateTime), metrics.Timestamp);
// verify non-generic interface works as expected
metrics = (QueueTriggerMetrics)(await((IScaleMonitor)listener).GetMetricsAsync());
Assert.AreEqual(5, metrics.QueueLength);
}
public void SetUp()
{
_mockQueue = new Mock <QueueClient>(new Uri("https://test.queue.core.windows.net/testqueue"), null);
_mockQueue.Setup(x => x.Name).Returns("testqueue");
_mockTriggerExecutor = new Mock <ITriggerExecutor <QueueMessage> >(MockBehavior.Strict);
Mock <IWebJobsExceptionHandler> mockExceptionDispatcher = new Mock <IWebJobsExceptionHandler>(MockBehavior.Strict);
_loggerFactory = new LoggerFactory();
_loggerProvider = new TestLoggerProvider();
_loggerFactory.AddProvider(_loggerProvider);
QueuesOptions queuesOptions = new QueuesOptions();
QueueProcessorOptions context = new QueueProcessorOptions(_mockQueue.Object, _loggerFactory, queuesOptions);
_mockQueueProcessor = new Mock <QueueProcessor>(MockBehavior.Strict, context);
QueuesOptions queueConfig = new QueuesOptions
{
MaxDequeueCount = 5
};
_listener = new QueueListener(_mockQueue.Object, null, _mockTriggerExecutor.Object, mockExceptionDispatcher.Object, _loggerFactory, null, queueConfig, _mockQueueProcessor.Object, new FunctionDescriptor {
Id = "TestFunction"
});
_queueMessage = QueuesModelFactory.QueueMessage("TestId", "TestPopReceipt", "TestMessage", 0);
}
public override void Run()
{
try
{
Trace.TraceInformation("Listening for merger queue messages...");
m_log.Info("Listening for merger queue messages...");
m_makePicStopwatch = new Stopwatch();
m_makePicStopwatch.Start();
while (true) //run process
{
prepareMerger();
QueueListener <MergerMessage> queueListener =
new QueueListener <MergerMessage>(m_instanceQueue, m_log);
queueListener.AddResponse("ToMergeMessage", toMergeMessageEvent);
queueListener.AddResponse("RenderingFinishMessage", renderingFinishMessageEvent);
MergerExitCondition exitCondition = new MergerExitCondition(isFinish);
queueListener.Run(exitCondition);
}
}
catch (Exception e)
{
Trace.TraceError("Exception when processing queue item. Message: ", e.Message);
m_log.Error("Exception when processing queue item. Message: " + e.Message);
}
}
private QueueListener CreateQueueListener(IServiceLocator locator, string inboundQueueName,
string outboundQueueName)
{
var provider = locator.Resolve <IMessageQueueProvider>();
var inboundQueue = provider.Open(inboundQueueName);
var outboundQueue = inboundQueueName == outboundQueueName ? inboundQueue : provider.Open(outboundQueueName);
var listener = new QueueListener(inboundQueue, outboundQueue, new GriffinHandlerScopeFactory(Container))
{
RetryAttempts = new[]
{ TimeSpan.FromMilliseconds(500), TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2) },
MessageInvokerFactory = scope => new MessageInvoker(scope),
Logger = Logga
};
listener.PoisonMessageDetected += (sender, args) =>
{
//Err.Report(args.Exception, new { args.Message });
_log.Error(inboundQueueName + " Poison message: " + args.Message.Body, args.Exception);
};
listener.ScopeCreated += (sender, args) =>
{
_log.Debug(inboundQueueName + " Running " + args.Message.Body + ", Credentials: " +
args.Principal.ToFriendlyString());
};
listener.ScopeClosing += (sender, args) =>
{
if (args.Exception == null)
{
var all = args.Scope.ResolveDependency <IAdoNetUnitOfWork>().ToList();
all[0].SaveChanges();
}
};
return(listener);
}
//static QListener _queue=new QListener();
static void Main(string[] args)
{
Console.WriteLine("QueueTasksDemo started...");
var watch = Stopwatch.StartNew();
QueueListener <LogItem> _queue = new QueueListener <LogItem>(MessageReceivedAction <LogItem>);
//_queue.MessageReceived += new MControl.Generic.GenericEventHandler<LogItem>(_queue_MessageReceived);
_queue.Start();
int counter = 0;
int items = 0;
while (_queue.IsAlive)
{
if (++counter > 200)
{
break;
}
// Add some log messages in parallel...
Task.Factory.StartNew(() => _queue.Enqueue(new LogItem("Log from task A")));
Task.Factory.StartNew(() => _queue.Enqueue(new LogItem("Log from task B")));
Task.Factory.StartNew(() => _queue.Enqueue(new LogItem("Log from task B1")));
Task.Factory.StartNew(() => _queue.Enqueue(new LogItem("Log from task C")));
Task.Factory.StartNew(() => _queue.Enqueue(new LogItem("Log from task D")));
items += 5;
// Pretend to do other things...
Thread.Sleep(100);
}
while (_queue.Count > 0)
{
Thread.Sleep(100);
}
//_queue.Start();
//QTest.Invoke(_queue,200);
watch.Stop();
Console.WriteLine("Duration: {0}", watch.ElapsedMilliseconds);
Console.WriteLine("Items per second : {0}", (float)items / (watch.ElapsedMilliseconds / 1000));
Console.WriteLine("QueueTasksDemo waiting...");
Console.ReadKey();
_queue.Stop();
Console.WriteLine("QueueTasksDemo finished...");
Console.ReadKey();
}
public Task <IListener> CreateAsync(CancellationToken cancellationToken)
{
QueueTriggerExecutor triggerExecutor = new QueueTriggerExecutor(_executor);
var queueProcessor = CreateQueueProcessor(_queue, _poisonQueue, _loggerFactory, _queueProcessorFactory, _queueOptions, _messageEnqueuedWatcherSetter);
IListener listener = new QueueListener(_queue, _poisonQueue, triggerExecutor, _exceptionHandler, _loggerFactory,
_messageEnqueuedWatcherSetter, _queueOptions, queueProcessor, _descriptor);
return(Task.FromResult(listener));
}
private void waitingProcess(NetMessageHandler handler, string sessionId, SceneMessage sceneMessage,
MessageQueue <DispetcherMessage> dispatcherHandler)
{
DispatcherExitCondition exitCondition = new DispatcherExitCondition(handler, sessionId, isDisconnected);
QueueListener <DispetcherMessage> queueListener = new QueueListener <DispetcherMessage>(dispatcherHandler, m_log);
queueListener.AddResponse("MergerFinishMessage", mergerFinishMessageEvent);
queueListener.AddResponse("MergerUpdateMessage", mergerUpdateMessageEvent);
queueListener.AddResponse("MergerUpdateFailedMessage", mergerUpdateFailedMessageEvent);
queueListener.Run(exitCondition);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
_queueListener = new QueueListener();
_queueListener.Received += _queueListener_Received;
_queueListener.StartListening("response");
}
public SharedBlobQueueListener Create()
{
IStorageQueue blobTriggerPoisonQueue =
_queueClient.GetQueueReference(HostQueueNames.BlobTriggerPoisonQueue);
BlobQueueTriggerExecutor triggerExecutor =
new BlobQueueTriggerExecutor(_blobWrittenWatcher);
IDelayStrategy delayStrategy = new RandomizedExponentialBackoffStrategy(QueuePollingIntervals.Minimum,
_queueConfiguration.MaxPollingInterval);
IListener listener = new QueueListener(_hostBlobTriggerQueue, blobTriggerPoisonQueue, triggerExecutor,
delayStrategy, _exceptionHandler, _trace, _sharedQueueWatcher, _queueConfiguration);
return(new SharedBlobQueueListener(listener, triggerExecutor));
}
public static void DoListnning(QueueHost host)
{
var adapter = new QueueAdapter()
{
Source = host,
IsAsync = true,
//Interval = 100,
ConnectTimeout = 5000,
ReadTimeout = 180000,
WorkerCount = 1,
EnableDynamicWait = true,
QueueAction = (message) =>
{
Console.WriteLine("State:{0},Arrived:{1},Host:{2},Label:{3}, Identifier:{4}, Duration:{5}", message.MessageState, message.ArrivedTime.ToString("yyyy-MM-dd HH:mm:ss.fff"), message.Host, message.Label, message.Identifier, message.Duration);
var body = message.GetBody();
string sbody = body == null ? "null" : body.ToString();
Console.WriteLine("body: " + sbody);
},
FaultAction = (message) =>
{
Console.WriteLine(message);
}
};
QueueListener listener = new QueueListener(adapter, 100);
string logpath = NetlogSettings.GetDefaultPath("qlistener");
listener.Logger = new Logger(logpath);
//listener.ErrorOcurred += Listener_ErrorOcurred;
//listener.MessageReceived += Listener_MessageReceived;
listener.Start();
//QueueApi api = new QueueApi(host);
//api.ReceiveCompleted += api_ReceiveCompleted;
////api.Listener(10000, message_ReceiveCompleted);
//bool KeepAlive = true;
//int connectTimeout=10000;
// while (KeepAlive)
// {
// api.Receive(connectTimeout,message_ReceiveCompleted);
// Thread.Sleep(100);
// }
//Console.WriteLine("QueueListener finished...");
//Console.ReadLine();
}
public QueueListenerTests(TestDbFixture fixture)
{
fixture.ClearQueue("QLInbound");
_inboundQueue = fixture.OpenQueue("QLInbound");
_scopeFactory = Substitute.For <IHandlerScopeFactory>();
_queueListener = new QueueListener(_inboundQueue, fixture.OpenQueue("QLOutbound"), _scopeFactory);
_handlerScope = Substitute.For <IHandlerScope>();
_scopeFactory.CreateScope().Returns(_handlerScope);
_messageInvoker = Substitute.For <IMessageInvoker>();
_handlerScope.ResolveDependency <IMessageInvoker>().Returns(new[] { _messageInvoker });
this._fixture = fixture;
}
static void Main(string[] args)
{
IConfiguration config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", true, true)
.Build();
//var conStr = config["ConnectionString"];
//var queueName = config["QueueName"];
var conStr =
"Endpoint=sb://coderrlive.servicebus.windows.net/;SharedAccessKeyName=App;SharedAccessKey=zV623X84oZuyWEgn/PR21a72/snkxZA/r7PIMJYWEbY=";
var queueName = "labb";
var claims = new List <Claim>()
{
new Claim(ClaimTypes.NameIdentifier, "11"),
new Claim(ClaimTypes.Name, "Arne"),
new Claim(ClaimTypes.Email, "*****@*****.**")
};
var identity = new ClaimsIdentity(claims, "Mofo");
var p = new ClaimsPrincipal(identity);
var queue = new AzureMessageQueue(conStr, queueName)
{
MessageSerializer = new JsonMessageSerializer()
};
ClearQueue(queue);
Console.WriteLine("Sending");
using (var session = queue.BeginSession())
{
session.EnqueueAsync(p, new Message("Hello world!"));
session.SaveChanges();
}
Console.WriteLine("SENT");
QueueListener listener = new QueueListener(queue, queue, new ManualScopeFactory());
listener.RunAsync(new CancellationToken()).GetAwaiter().GetResult();
SendReceiveSingle(queue);
Console.WriteLine("==============");
SendReceiveBatch(queue);
Console.WriteLine("==============");
ReceiveFailure(queue);
Console.WriteLine("==============");
Console.WriteLine("Done, press ENTER to quit");
Console.ReadLine();
}
public async Task TestRunAsyncStatusCodeNotFound()
{
//Arrange
var fakeResponse = GetFakeResponse(HttpStatusCode.NotFound);
var(traceWriter, fakeSettings, fakeRestClient, fakeAdalHelper) = Arrange(fakeResponse);
//Act
await QueueListener.TestableRunAsync("somevalue", traceWriter, fakeSettings, fakeRestClient, fakeAdalHelper);
//Assert
var traceEvent = traceWriter.Traces.FirstOrDefault(t => t.Message.Contains("Successfully processed"));
Assert.IsNotNull(traceEvent);
}
public async Task TestRunAsyncStatusCodeOther()
{
//Arrange
var fakeResponse = GetFakeResponse(HttpStatusCode.Forbidden);
var(traceWriter, fakeSettings, fakeRestClient, fakeAdalHelper) = Arrange(fakeResponse);
//Act
await QueueListener.TestableRunAsync("somevalue", traceWriter, fakeSettings, fakeRestClient, fakeAdalHelper);
//Assert
var traceEvent = traceWriter.Traces.FirstOrDefault(t => t.Message.Contains("Something went wrong"));
Assert.IsNotNull(traceEvent);
}
public async Task UpdatedQueueMessage_RetainsOriginalProperties()
{
TraceWriter trace = new TestTraceWriter(TraceLevel.Verbose);
CloudQueue queue = Fixture.CreateNewQueue();
CloudQueue poisonQueue = Fixture.CreateNewQueue();
JobHostQueuesConfiguration queuesConfig = new JobHostQueuesConfiguration {
MaxDequeueCount = 2
};
StorageQueue storageQueue = new StorageQueue(new StorageQueueClient(Fixture.QueueClient), queue);
StorageQueue storagePoisonQueue = new StorageQueue(new StorageQueueClient(Fixture.QueueClient), poisonQueue);
Mock <ITriggerExecutor <IStorageQueueMessage> > mockTriggerExecutor = new Mock <ITriggerExecutor <IStorageQueueMessage> >(MockBehavior.Strict);
string messageContent = Guid.NewGuid().ToString();
CloudQueueMessage message = new CloudQueueMessage(messageContent);
await queue.AddMessageAsync(message, null, null, null, null, CancellationToken.None);
CloudQueueMessage messageFromCloud = await queue.GetMessageAsync();
QueueListener listener = new QueueListener(storageQueue, storagePoisonQueue, mockTriggerExecutor.Object, new WebJobsExceptionHandler(), trace,
null, null, queuesConfig);
mockTriggerExecutor
.Setup(m => m.ExecuteAsync(It.IsAny <IStorageQueueMessage>(), CancellationToken.None))
.ReturnsAsync(new FunctionResult(false));
await listener.ProcessMessageAsync(new StorageQueueMessage(messageFromCloud), TimeSpan.FromMinutes(10), CancellationToken.None);
// pull the message and process it again (to have it go through the poison queue flow)
messageFromCloud = await queue.GetMessageAsync();
Assert.Equal(2, messageFromCloud.DequeueCount);
await listener.ProcessMessageAsync(new StorageQueueMessage(messageFromCloud), TimeSpan.FromMinutes(10), CancellationToken.None);
// Make sure the message was processed and deleted.
await queue.FetchAttributesAsync();
Assert.Equal(0, queue.ApproximateMessageCount);
// The Listener has inserted a message to the poison queue.
await poisonQueue.FetchAttributesAsync();
Assert.Equal(1, poisonQueue.ApproximateMessageCount);
mockTriggerExecutor.Verify(m => m.ExecuteAsync(It.IsAny <IStorageQueueMessage>(), CancellationToken.None), Times.Exactly(2));
}
public void GetMonitor_ReturnsSharedMonitor()
{
var queueListener = new QueueListener();
var watcherMock = new Mock <IBlobWrittenWatcher>(MockBehavior.Strict);
var executor = new BlobQueueTriggerExecutor(watcherMock.Object, NullLogger <BlobListener> .Instance);
var sharedBlobQueueListener = new SharedBlobQueueListener(queueListener, executor);
var sharedListenerMock = new Mock <ISharedListener>(MockBehavior.Strict);
var blobListener1 = new BlobListener(sharedBlobQueueListener);
var blobListener2 = new BlobListener(sharedBlobQueueListener);
var monitor1 = blobListener1.GetMonitor();
var monitor2 = blobListener1.GetMonitor();
Assert.AreSame(monitor1, monitor2);
Assert.AreSame(monitor1, queueListener);
}
static void Main(string[] args)
{
var host = new ServiceHost(typeof(StockService));
host.Open();
var queueListener = new QueueListener();
queueListener.StartListening("request", true);
Console.WriteLine("Press <Enter> to stop the services.");
Console.ReadLine();
queueListener.Dispose();
host.Close();
}
public async Task UpdatedQueueMessage_RetainsOriginalProperties()
{
CloudQueue queue = Fixture.CreateNewQueue();
CloudQueue poisonQueue = Fixture.CreateNewQueue();
var queuesOptions = new QueuesOptions {
MaxDequeueCount = 2
};
Mock <ITriggerExecutor <CloudQueueMessage> > mockTriggerExecutor = new Mock <ITriggerExecutor <CloudQueueMessage> >(MockBehavior.Strict);
string messageContent = Guid.NewGuid().ToString();
CloudQueueMessage message = new CloudQueueMessage(messageContent);
await queue.AddMessageAsync(message, null, null, null, null, CancellationToken.None);
CloudQueueMessage messageFromCloud = await queue.GetMessageAsync();
var queueProcessorFactory = new DefaultQueueProcessorFactory();
QueueListener listener = new QueueListener(queue, poisonQueue, mockTriggerExecutor.Object, new WebJobsExceptionHandler(null),
null, null, queuesOptions, queueProcessorFactory);
mockTriggerExecutor
.Setup(m => m.ExecuteAsync(It.IsAny <CloudQueueMessage>(), CancellationToken.None))
.ReturnsAsync(new FunctionResult(false));
await listener.ProcessMessageAsync(messageFromCloud, TimeSpan.FromMinutes(10), CancellationToken.None);
// pull the message and process it again (to have it go through the poison queue flow)
messageFromCloud = await queue.GetMessageAsync();
Assert.Equal(2, messageFromCloud.DequeueCount);
await listener.ProcessMessageAsync(messageFromCloud, TimeSpan.FromMinutes(10), CancellationToken.None);
// Make sure the message was processed and deleted.
await queue.FetchAttributesAsync();
Assert.Equal(0, queue.ApproximateMessageCount);
// The Listener has inserted a message to the poison queue.
await poisonQueue.FetchAttributesAsync();
Assert.Equal(1, poisonQueue.ApproximateMessageCount);
mockTriggerExecutor.Verify(m => m.ExecuteAsync(It.IsAny <CloudQueueMessage>(), CancellationToken.None), Times.Exactly(2));
}
public async Task RenewedQueueMessage_DeletesCorrectly()
{
TraceWriter trace = new TestTraceWriter(TraceLevel.Verbose);
CloudQueue queue = Fixture.CreateNewQueue();
StorageQueue storageQueue = new StorageQueue(new StorageQueueClient(Fixture.QueueClient), queue);
Mock <ITriggerExecutor <IStorageQueueMessage> > mockTriggerExecutor = new Mock <ITriggerExecutor <IStorageQueueMessage> >(MockBehavior.Strict);
string messageContent = Guid.NewGuid().ToString();
CloudQueueMessage message = new CloudQueueMessage(messageContent);
await queue.AddMessageAsync(message, null, null, null, null, CancellationToken.None);
CloudQueueMessage messageFromCloud = await queue.GetMessageAsync();
QueueListener listener = new QueueListener(storageQueue, null, mockTriggerExecutor.Object, new WebJobsExceptionHandler(), trace,
null, null, new JobHostQueuesConfiguration());
listener.MinimumVisibilityRenewalInterval = TimeSpan.FromSeconds(1);
// Set up a function that sleeps to allow renewal
mockTriggerExecutor
.Setup(m => m.ExecuteAsync(It.Is <IStorageQueueMessage>(msg => msg.DequeueCount == 1), CancellationToken.None))
.ReturnsAsync(() =>
{
Thread.Sleep(4000);
return(new FunctionResult(true));
});
var previousNextVisibleTime = messageFromCloud.NextVisibleTime;
var previousPopReceipt = messageFromCloud.PopReceipt;
// Renewal should happen at 2 seconds
await listener.ProcessMessageAsync(new StorageQueueMessage(messageFromCloud), TimeSpan.FromSeconds(4), CancellationToken.None);
// Check to make sure the renewal occurred.
Assert.NotEqual(messageFromCloud.NextVisibleTime, previousNextVisibleTime);
Assert.NotEqual(messageFromCloud.PopReceipt, previousPopReceipt);
// Make sure the message was processed and deleted.
await queue.FetchAttributesAsync();
Assert.Equal(0, queue.ApproximateMessageCount);
}
public SharedBlobQueueListener Create()
{
BlobQueueTriggerExecutor triggerExecutor = new BlobQueueTriggerExecutor(_blobWrittenWatcher, _loggerFactory.CreateLogger <BlobListener>());
// The poison queue to use for a given poison blob lives in the same
// storage account as the triggering blob by default. In multi-storage account scenarios
// that means that we'll be writing to different poison queues, determined by
// the triggering blob.
// However we use a poison queue in the host storage account as a fallback default
// in case a particular blob lives in a restricted "blob only" storage account (i.e. no queues).
var defaultPoisonQueue = _hostQueueServiceClient.GetQueueClient(HostQueueNames.BlobTriggerPoisonQueue);
// This special queue bypasses the QueueProcessorFactory - we don't want people to override this.
// So we define our own custom queue processor factory for this listener
var queueProcessorFactory = new SharedBlobQueueProcessorFactory(triggerExecutor, _hostBlobTriggerQueue, _loggerFactory, _queueOptions, defaultPoisonQueue);
IListener listener = new QueueListener(_hostBlobTriggerQueue, defaultPoisonQueue, triggerExecutor, _exceptionHandler, _loggerFactory,
_sharedQueueWatcher, _queueOptions, queueProcessorFactory, _functionDescriptor, functionId: SharedBlobQueueListenerFunctionId);
return(new SharedBlobQueueListener(listener, triggerExecutor));
}
public void Configure(ConfigurationContext context)
{
var assembly = typeof(IAccountService).Assembly;
context.Services.RegisterMessageHandlers(assembly);
assembly = typeof(SqlServerTools).Assembly;
context.Services.RegisterMessageHandlers(assembly);
context.Services.AddSingleton <IMessageQueueProvider>(CreateQueueProvider(context));
context.Services.AddSingleton <IMessageBus>(x =>
{
var queue = x.GetService <IMessageQueueProvider>().Open("Messaging");
var bus = new SingleInstanceMessageBus(queue);
return(bus);
});
context.Services.AddScoped <IQueryBus, ScopedQueryBus>();
context.Services.AddScoped(CreateMessageInvoker);
_messagingQueueListener = ConfigureQueueListener(context, "Messaging", "Messaging");
}
private QueueListener ConfigureQueueListener(ConfigurationContext context, string inboundQueueName,
string outboundQueueName)
{
var inboundQueue = _queueProvider.Open(inboundQueueName);
var outboundQueue = inboundQueueName == outboundQueueName
? inboundQueue
: _queueProvider.Open(outboundQueueName);
var scopeFactory = new ScopeFactory(context.ServiceProvider);
var listener = new QueueListener(inboundQueue, outboundQueue, scopeFactory)
{
RetryAttempts = new[]
{ TimeSpan.FromMilliseconds(500), TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2) },
MessageInvokerFactory = scope => new MessageInvoker(scope),
Logger = DiagnosticLog
};
listener.PoisonMessageDetected += (sender, args) =>
{
//Err.Report(args.Exception, new { args.Message });
_log.Error(inboundQueueName + " Poison message: " + args.Message.Body, args.Exception);
};
listener.ScopeCreated += (sender, args) =>
{
args.Scope.ResolveDependency <IPrincipalAccessor>().First().Principal = args.Principal;
_log.Debug(inboundQueueName + " Running " + args.Message.Body + ", Credentials: " +
args.Principal.ToFriendlyString());
};
listener.ScopeClosing += (sender, args) =>
{
if (args.Exception != null)
{
return;
}
var all = args.Scope.ResolveDependency <IAdoNetUnitOfWork>().ToList();
all[0].SaveChanges();
};
listener.MessageInvokerFactory = MessageInvokerFactory;
return(listener);
}
public async Task Should_be_able_to_handle_a_message_flow()
{
ManualResetEvent evt = new ManualResetEvent(false);
var upgrade = new LogAdminUpgrades(evt);
var serviceProvider = new ServiceCollection()
.AddScoped <IMessageHandler <ActivateUser>, ActivateUserHandler>()
.AddScoped <IMessageHandler <UserActivated>, UpgradeToAdminHandler>()
.AddSingleton <IMessageHandler <UserBecameAdmin> >(upgrade)
.AddScoped <IQueryHandler <FindUser, FindUserResult>, FindUserHandler>()
.BuildServiceProvider();
var scopeFactory = new MicrosoftHandlerScopeFactory(serviceProvider);
var inboundQueue = _fixture.OpenQueue("inbound", false);
var outboundQueue = _fixture.OpenQueue("outbound", false);
var token = new CancellationTokenSource();
using (var session = inboundQueue.BeginSession())
{
await session.EnqueueAsync(new Message(new ActivateUser()));
await session.SaveChanges();
}
var listener1 = new QueueListener(inboundQueue, outboundQueue, scopeFactory);
listener1.MessageInvokerFactory = scope => new MessageInvoker(scope);
listener1.Logger = (level, queue, msg) => Console.WriteLine($"{level} {queue} {msg}");
var listener2 = new QueueListener(outboundQueue, outboundQueue, scopeFactory);
listener2.MessageInvokerFactory = scope => new MessageInvoker(scope);
listener2.Logger = (level, queue, msg) => Console.WriteLine($"{level} {queue} {msg}");
var t1 = listener1.RunAsync(token.Token);
var t2 = listener2.RunAsync(token.Token);
token.Cancel();
await Task.WhenAll(t1, t2);
evt.WaitOne(500).Should().BeTrue();
}
public void GetMessageReceiveCount_DynamicConcurrencyEnabled_ReturnsExpectedValue()
{
var concurrencyOptions = new ConcurrencyOptions
{
DynamicConcurrencyEnabled = true
};
var throttleStatus = new ConcurrencyThrottleAggregateStatus {
State = ThrottleState.Disabled
};
var optionsWrapper = new OptionsWrapper <ConcurrencyOptions>(concurrencyOptions);
var mockConcurrencyThrottleManager = new Mock <IConcurrencyThrottleManager>(MockBehavior.Strict);
mockConcurrencyThrottleManager.Setup(p => p.GetStatus()).Returns(() => throttleStatus);
var concurrencyManager = new ConcurrencyManager(optionsWrapper, _loggerFactory, mockConcurrencyThrottleManager.Object);
var localListener = new QueueListener(_mockQueue.Object, null, _mockTriggerExecutor.Object, _mockExceptionDispatcher.Object, _loggerFactory, null, _queuesOptions, _mockQueueProcessor.Object, new FunctionDescriptor {
Id = TestFunctionId
}, concurrencyManager);
int result = localListener.GetMessageReceiveCount();
Assert.AreEqual(1, result);
}
public void StartListening()
{
_queueListener = _listenerFactory.Create<InstagramMessageDto>();
Listen();
}
