/// <summary>
/// Initializes a new instance of the ChatSessionObject class.
/// </summary>
/// <param name="bus">The BusAttachment to be associated with.</param>
/// <param name="path">The path for the BusObject.</param>
/// <param name="host">The instance of the MainPage which handles the UI for this
/// application.</param>
public ChatSessionObject(BusAttachment bus, string path, MainPage host)
{
try
{
this.hostPage = host;
this.busObject = new BusObject(bus, path, false);
/* Add the interface to this object */
InterfaceDescription[] ifaceArr = new InterfaceDescription[1];
bus.CreateInterface(ChatServiceInterfaceName, ifaceArr, false);
ifaceArr[0].AddSignal("Chat", "s", "str", 0, string.Empty);
ifaceArr[0].Activate();
InterfaceDescription chatIfc = bus.GetInterface(ChatServiceInterfaceName);
this.busObject.AddInterface(chatIfc);
this.chatSignalReceiver = new MessageReceiver(bus);
this.chatSignalReceiver.SignalHandler += new MessageReceiverSignalHandler(this.ChatSignalHandler);
this.chatSignalMember = chatIfc.GetMember("Chat");
bus.RegisterSignalHandler(this.chatSignalReceiver, this.chatSignalMember, path);
}
catch (System.Exception ex)
{
QStatus errCode = AllJoyn.AllJoynException.GetErrorCode(ex.HResult);
string errMsg = AllJoyn.AllJoynException.GetErrorMessage(ex.HResult);
this.hostPage.DisplayStatus("Create ChatSessionObject Error : " + errMsg);
}
}
public RequestReplySender(MessageSender sender, MessageReceiver receiver)
{
this.sender = sender;
this.receiver = receiver;
receiver.OnMessageAsync(this.DispatchReply, new OnMessageOptions {AutoComplete = false});
}
public void HandleRegenerateSite() {
long n = 0;
allMessages = factory.CreateMessageReceiver(regenSiteTopic + "/subscriptions/AllMessages", ReceiveMode.PeekLock);
while (_running) {
BrokeredMessage message = allMessages.Receive();
if (message != null) {
// let the message go back to the pool
Int64.TryParse(message.Properties["MessageNumber"].ToString(), out n);
message.Abandon();
try {
if( n > maxMessage ) {
maxMessage = n;
Console.WriteLine("\r\nAccepted message to regenerate site: {0} ",n);
RebuildWebsite();
}
else {
// Console.WriteLine("\r\nSkipping: {0} ",n);
}
}
catch (Exception) {
}
Thread.Sleep(8000); // wait 5 seconds to give other consumers a chance on this message.
}
}
}
/// <summary>
/// Creates a new <c>ForwardingTraceListener</c> that forwards to the
/// specified receiver.
/// </summary>
/// <param name="receiver">The method that accepts forwarded trace output (not null)</param>
/// <exception cref="ArgumentNullException">If <paramref name="receiver"/> is null</exception>
public ForwardingTraceListener(MessageReceiver receiver)
{
if (receiver==null)
throw new ArgumentNullException();
m_Receiver = receiver;
}
public MessageReceiverRegistration(DeviceAddress source, DeviceAddress destination, MessageReceiver callback, MatchType match)
{
Source = source;
Destination = destination;
Callback = callback;
Match = match;
}
private async Task StartAsyncCore(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
_receiver = await _messagingFactory.CreateMessageReceiverAsync(_entityPath);
_receiver.OnMessageAsync(ProcessMessageAsync, new OnMessageOptions());
}
public override async Task StopAsyncCore(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
await _receiver.CloseAsync();
_receiver = null;
}
public Receiver(MessageReceiver messageReceiver, Uri inputAddress, IPipe<ReceiveContext> receivePipe, ReceiveSettings receiveSettings,
IReceiveObserver receiveObserver, ITaskSupervisor supervisor)
{
_messageReceiver = messageReceiver;
_inputAddress = inputAddress;
_receivePipe = receivePipe;
_receiveSettings = receiveSettings;
_receiveObserver = receiveObserver;
_supervisor = supervisor;
_participant = supervisor.CreateParticipant();
var options = new OnMessageOptions
{
AutoComplete = false,
AutoRenewTimeout = receiveSettings.AutoRenewTimeout,
MaxConcurrentCalls = receiveSettings.MaxConcurrentCalls
};
options.ExceptionReceived += (sender, x) =>
{
if (_log.IsErrorEnabled)
_log.Error($"Exception received on receiver: {_inputAddress} during {x.Action}", x.Exception);
_participant.SetComplete();
};
messageReceiver.OnMessageAsync(OnMessage, options);
_participant.SetReady();
SetupStopTask();
}
/// <summary>
/// Initializes a new instance of the <see cref="SignalConsumerBusListener" /> class
/// </summary>
/// <param name="bus">object responsible for connecting to and optionally managing a message
/// bus</param>
/// <param name="foundNameEvent">event to set when the well-known name being queried
/// is found</param>
public SignalConsumerBusListener(BusAttachment bus, AutoResetEvent foundNameEvent)
{
SessionidList = new List<uint>();
this.busAtt = bus;
this.foundName = foundNameEvent;
this.busListener = new BusListener(bus);
this.busListener.BusDisconnected += new BusListenerBusDisconnectedHandler(this.BusListenerBusDisconnected);
this.busListener.BusStopping += new BusListenerBusStoppingHandler(this.BusListenerBusStopping);
this.busListener.FoundAdvertisedName += new BusListenerFoundAdvertisedNameHandler(this.BusListenerFoundAdvertisedName);
this.busListener.ListenerRegistered += new BusListenerListenerRegisteredHandler(this.BusListenerListenerRegistered);
this.busListener.ListenerUnregistered += new BusListenerListenerUnregisteredHandler(this.BusListenerListenerUnregistered);
this.busListener.LostAdvertisedName += new BusListenerLostAdvertisedNameHandler(this.BusListenerLostAdvertisedName);
this.busListener.NameOwnerChanged += new BusListenerNameOwnerChangedHandler(this.BusListenerNameOwnerChanged);
this.sessionListener = new SessionListener(this.busAtt);
this.sessionListener.SessionLost += new SessionListenerSessionLostHandler(this.SessionListenerSessionLost);
this.sessionListener.SessionMemberAdded += new SessionListenerSessionMemberAddedHandler(this.SessionListenerSessionMemberAdded);
this.sessionListener.SessionMemberRemoved += new SessionListenerSessionMemberRemovedHandler(this.SessionListenerSessionMemberRemoved);
MessageReceiver signalReceiver = new MessageReceiver(bus);
signalReceiver.SignalHandler += this.NameChangedSignalHandler;
InterfaceDescription interfaceDescription2 = bus.GetInterface(SignalConsumerGlobals.InterfaceName);
InterfaceMember signalMember = interfaceDescription2.GetSignal("nameChanged");
bus.RegisterSignalHandler(signalReceiver, signalMember, string.Empty);
}
private async Task<MessageReceiver> GetMessageReceiver()
{
if (_messageReceiver != null) return _messageReceiver;
_messageReceiver = await _queueManager.CreateMessageReceiver(_queuePath);
_messageReceiver.PrefetchCount = ConcurrentHandlerLimit;
return _messageReceiver;
}
public static void removeObserver(int messageType, MessageReceiver handler)
{
List<MessageReceiver> list = null;
if (_messageTable.TryGetValue(messageType, out list))
{
if (list.Contains(handler))
list.Remove(handler);
}
}
private Task StartAsyncCore(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
_receiver = _messagingProvider.CreateMessageReceiver(_messagingFactory, _entityPath);
_receiver.OnMessageAsync(ProcessMessageAsync, _messageProcessor.MessageOptions);
return Task.FromResult(0);
}
internal MessageDispatcher(ILogger logger, MessageReceiver messageReceiver, Func<object, Task> messageProcessor, IBrokeredMessageFactory brokeredMessageFactory, Type inboundMessageType, MaxConcurrentReceiverCallsSetting maxConcurrentReceiverCallsSetting)
{
_logger = logger;
_messageProcessor = messageProcessor;
_brokeredMessageFactory = brokeredMessageFactory;
_inboundMessageType = inboundMessageType;
messageReceiver.OnMessageAsync(PreProcessMessage, new OnMessageOptions() { MaxConcurrentCalls = maxConcurrentReceiverCallsSetting });
}
public InProcessTransportBuilder(MessageReceiver messageReceiver, IIocContainer container, IInProcessMessageServerFactory messageServerFactory)
{
Contract.Requires(messageReceiver != null);
Contract.Requires(container != null);
Contract.Requires(messageServerFactory != null);
this.messageReceiver = messageReceiver;
this.container = container;
this.messageServerFactory = messageServerFactory;
}
private void DiscardMessageReceiver()
{
var messageReceiver = _messageReceiver;
_messageReceiver = null;
if (messageReceiver == null) return;
if (messageReceiver.IsClosed) return;
messageReceiver.Close();
}
async Task<long> SendAndReceiveMessages(MessageSender sender, MessageReceiver receiver, int messageCount)
{
// Now we can start sending messages.
var rnd = new Random();
var mockPayload = new byte[100]; // 100 random-byte payload
rnd.NextBytes(mockPayload);
Console.WriteLine("\nSending {0} messages to the queue", messageCount);
var sendOps = new List<Task>();
for (var i = 0; i < messageCount; i++)
{
sendOps.Add(
sender.SendAsync(
new BrokeredMessage(new MemoryStream(mockPayload))
{
TimeToLive = TimeSpan.FromMinutes(5)
}));
}
Task.WaitAll(sendOps.ToArray());
Console.WriteLine("Send completed");
// Receive the messages
Console.WriteLine("Receiving messages...");
// Start stopwatch
var stopWatch = new Stopwatch();
stopWatch.Start();
var receivedMessage = await receiver.ReceiveAsync(TimeSpan.FromSeconds(5));
while (receivedMessage != null )
{
// here's where you'd do any work
// complete (roundtrips)
await receivedMessage.CompleteAsync();
if (--messageCount <= 0)
break;
// now get the next message
receivedMessage = await receiver.ReceiveAsync(TimeSpan.FromSeconds(5));
}
// Stop the stopwatch
stopWatch.Stop();
Console.WriteLine("Receive completed");
var timeTaken = stopWatch.ElapsedMilliseconds;
Console.WriteLine("Time to receive and complete all messages = {0} milliseconds", timeTaken);
return timeTaken;
}
public void Stop()
{
lock (_mutex)
{
var messageReceiver = _messageReceiver;
if (messageReceiver == null) return;
messageReceiver.Close();
_messageReceiver = null;
}
}
public MessageProcessor(string queueName, string serviceNameSpace, string issuer, string key)
{
// Create Token Provider and Service Uri
var tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuer, key);
var serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNameSpace, string.Empty);
// Create a messaging receiver
_factory = MessagingFactory.Create(serviceUri, tokenProvider);
_messageReceiver = _factory.CreateMessageReceiver(queueName);
//_messageSender = _factory.CreateMessageSender(queueName);
}
/// <summary>
/// Initializes a new instance of the <see cref="SecureBusObject" /> class.
/// </summary>
/// <param name="busAtt">Object responsible for connecting to and optionally managing a
/// message bus.</param>
/// <param name="iface">The interface used by the service that is implemented by this
/// class.</param>
public SecureBusObject(BusAttachment busAtt, InterfaceDescription[] iface)
{
this.BusObject = new BusObject(busAtt, App.ServicePath, false);
this.BusObject.AddInterface(iface[0]);
InterfaceMember pingMember = iface[0].GetMember("Ping");
MessageReceiver pingReceiver = new MessageReceiver(busAtt);
pingReceiver.MethodHandler += new MessageReceiverMethodHandler(this.PingMethodHandler);
BusObject.AddMethodHandler(pingMember, pingReceiver);
busAtt.RegisterBusObject(this.BusObject);
}
public static void addObserver(int messageType, MessageReceiver handler)
{
List<MessageReceiver> list = null;
if (!_messageTable.TryGetValue(messageType, out list))
{
list = new List<MessageReceiver>();
_messageTable.Add(messageType, list);
}
if (!list.Contains(handler))
_messageTable[messageType].Add(handler);
}
public AddMatchBusObj(BusAttachment bus)
{
this.busObj = new BusObject(bus, "/test", false);
InterfaceDescription[] intf = new InterfaceDescription[1];
bus.CreateInterface("org.alljoyn.addmatchtest", intf, false);
intf[0].AddSignal("testSig", "s", "str", (byte)0, "");
intf[0].Activate();
this.busObj.AddInterface(intf[0]);
MessageReceiver receiver = new MessageReceiver(bus);
receiver.SignalHandler += new MessageReceiverSignalHandler(this.SigHandle);
bus.RegisterSignalHandler(receiver, intf[0].GetSignal("testSig"), "");
bus.RegisterBusObject(this.busObj);
}
public override async Task StartAsyncCore(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
_messageWrapper.CreateTopicIfDoesntExistSilent(_globalSettings.DiscoTopicName, 1024, new TimeSpan(2, 0, 0, 0));
var eventDrivenMessagingOptions = new OnMessageOptions { AutoComplete = false, MaxConcurrentCalls = 5 };
eventDrivenMessagingOptions.ExceptionReceived += OnExceptionReceived;
_receiver = await _messageWrapper.CreateMessageReceiverAsync(_globalSettings.DiscoTopicName, "Notifications", ReceiveMode.PeekLock);
_receiver.OnMessageAsync(ProcessMessageAsync, eventDrivenMessagingOptions);
}
public MessageReceiverObservableExtensionsTests()
{
this.azureServiceBusTestUtilities = AzureServiceBusTestUtilities.Create();
string queueName = "MessageReceiverExtensionTests-" + Guid.NewGuid();
this.queueDescription = this.azureServiceBusTestUtilities.NamespaceManager.CreateQueue(queueName);
MessagingFactory messagingFactory = this.azureServiceBusTestUtilities.MessagingFactory;
this.messageSender = messagingFactory.CreateMessageSender(this.queueDescription.Path);
this.messageReceiver = messagingFactory.CreateMessageReceiver(this.queueDescription.Path);
}
public HttpServerTransportBuilder(
IHttpServerBuilder httpServerBuilder,
ISerialiser serialiser,
MessageReceiver messageReceiver)
{
Contract.Requires(httpServerBuilder != null);
Contract.Requires(serialiser != null);
Contract.Requires(messageReceiver != null);
this.httpServerBuilder = httpServerBuilder;
this.serialiser = serialiser;
this.messageReceiver = messageReceiver;
}
public void Start(Func<BrokeredMessage, Task> callback)
{
lock (_mutex)
{
if (_messageReceiver != null) throw new InvalidOperationException("Already started!");
_messageReceiver = _queueManager.CreateMessageReceiver(_queuePath);
_messageReceiver.OnMessageAsync(callback,
new OnMessageOptions
{
AutoComplete = false,
MaxConcurrentCalls = _concurrentHandlerLimit,
});
}
}
//[Test] not hangs the unit tests due to threads
//note the ability for this to function internally depends on what type of connection is created
public void RoundTrip()
{
var transmitter = new MessageSender(m_Context);
var receiver = new MessageReceiver(m_Context);
receiver.CreateReceiveSocket();
string message = "Hello world";
//transmitter.Connect();
transmitter.Send(message);
string recieved = receiver.Receive();
Assert.AreEqual(message, recieved);
receiver.Dispose();
transmitter.Dispose();
}
public LongPoller(
IWebRequestor requestor,
ISerialiser formatter,
ITaskScheduler scheduler,
MessageReceiver receiver,
ITaskStarter starter)
{
Contract.Requires(requestor != null);
Contract.Requires(formatter != null);
Contract.Requires(scheduler != null);
Contract.Requires(receiver != null);
Contract.Requires(starter != null);
this.requestor = requestor;
this.formatter = formatter;
this.scheduler = scheduler;
this.receiver = receiver;
this.starter = starter;
}
public void Init(Address address, bool transactional)
{
try
{
queueName = address.Queue;
var description = new QueueDescription {RequiresSession = false, RequiresDuplicateDetection = false, MaxQueueSizeInBytes = 104857600};
namespaceClient.CreateQueue(queueName, description);
}
catch (MessagingEntityAlreadyExistsException)
{
// the queue already exists, which is ok
}
queueClient = factory.CreateQueueClient(queueName);
receiver = queueClient.CreateReceiver(ReceiveMode.PeekLock);
receiver.Faulted += (o, args) => receiver = queueClient.CreateReceiver(ReceiveMode.PeekLock);
useTransactions = transactional;
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceBusObject"/> class.
/// </summary>
/// <param name="busAtt">Message bus for the stress operation using this</param>
/// <param name="op">Stress operation using this bus object</param>
public ServiceBusObject(BusAttachment busAtt, StressOperation op)
{
this.stressOp = op;
this.busObject = new BusObject(busAtt, ServicePath, false);
// Implement the 'cat' interface
InterfaceDescription[] intfDescription = new InterfaceDescription[1];
busAtt.CreateInterface(InterfaceName, intfDescription, false);
intfDescription[0].AddMethod("cat", "ss", "s", "inStr1,inStr2,outStr", (byte)0, string.Empty);
intfDescription[0].Activate();
this.busObject.AddInterface(intfDescription[0]);
// Register 'cat' method handler
InterfaceMember catMethod = intfDescription[0].GetMethod("cat");
MessageReceiver catReceiver = new MessageReceiver(busAtt);
catReceiver.MethodHandler += new MessageReceiverMethodHandler(this.Cat);
this.busObject.AddMethodHandler(catMethod, catReceiver);
busAtt.RegisterBusObject(this.busObject);
}
/// <summary>
/// Initializes a new instance of the <see cref="MyBusObject"/> class
/// </summary>
/// <param name="busAtt">Message bus for the sessions app</param>
/// <param name="ops">Session Operations object for this application</param>
public MyBusObject(BusAttachment busAtt, SessionOperations ops)
{
this.busObject = new BusObject(busAtt, BusObjectPath, false);
this.sessionOps = ops;
this.ChatEcho = true;
// Implement the 'Chat' interface
InterfaceDescription[] intfDescription = new InterfaceDescription[1];
busAtt.CreateInterface(SessionInterfaceName, intfDescription, false);
intfDescription[0].AddSignal("Chat", "s", "str", (byte)0, string.Empty);
intfDescription[0].Activate();
this.chatSignal = intfDescription[0].GetSignal("Chat");
this.busObject.AddInterface(intfDescription[0]);
// Register chat signal handler
MessageReceiver signalReceiver = new MessageReceiver(busAtt);
signalReceiver.SignalHandler += new MessageReceiverSignalHandler(this.ChatSignalHandler);
busAtt.RegisterSignalHandler(signalReceiver, this.chatSignal, string.Empty);
busAtt.RegisterBusObject(this.busObject);
}
public ServiceBusSubscription Subscribe(IList <string> topicNames,
Action <int, IEnumerable <BrokeredMessage> > handler,
Action <int, Exception> errorHandler)
{
if (topicNames == null)
{
throw new ArgumentNullException("topicNames");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
_trace.TraceInformation("Subscribing to {0} topic(s) in the service bus...", topicNames.Count);
var subscriptions = new ServiceBusSubscription.SubscriptionContext[topicNames.Count];
var clients = new TopicClient[topicNames.Count];
for (var topicIndex = 0; topicIndex < topicNames.Count; ++topicIndex)
{
string topicName = topicNames[topicIndex];
if (!_namespaceManager.TopicExists(topicName))
{
try
{
_trace.TraceInformation("Creating a new topic {0} in the service bus...", topicName);
_namespaceManager.CreateTopic(topicName);
_trace.TraceInformation("Creation of a new topic {0} in the service bus completed successfully.", topicName);
}
catch (MessagingEntityAlreadyExistsException)
{
// The entity already exists
_trace.TraceInformation("Creation of a new topic {0} threw an MessagingEntityAlreadyExistsException.", topicName);
}
}
// Create a client for this topic
clients[topicIndex] = TopicClient.CreateFromConnectionString(_configuration.ConnectionString, topicName);
_trace.TraceInformation("Creation of a new topic client {0} completed successfully.", topicName);
// Create a random subscription
string subscriptionName = Guid.NewGuid().ToString();
try
{
var subscriptionDescription = new SubscriptionDescription(topicName, subscriptionName);
// This cleans up the subscription while if it's been idle for more than the timeout.
subscriptionDescription.AutoDeleteOnIdle = IdleSubscriptionTimeout;
_namespaceManager.CreateSubscription(subscriptionDescription);
_trace.TraceInformation("Creation of a new subscription {0} for topic {1} in the service bus completed successfully.", subscriptionName, topicName);
}
catch (MessagingEntityAlreadyExistsException)
{
// The entity already exists
_trace.TraceInformation("Creation of a new subscription {0} for topic {1} threw an MessagingEntityAlreadyExistsException.", subscriptionName, topicName);
}
// Create a receiver to get messages
string subscriptionEntityPath = SubscriptionClient.FormatSubscriptionPath(topicName, subscriptionName);
MessageReceiver receiver = _factory.CreateMessageReceiver(subscriptionEntityPath, ReceiveMode.ReceiveAndDelete);
_trace.TraceInformation("Creation of a message receive for subscription entity path {0} in the service bus completed successfully.", subscriptionEntityPath);
subscriptions[topicIndex] = new ServiceBusSubscription.SubscriptionContext(topicName, subscriptionName, receiver);
var receiverContext = new ReceiverContext(topicIndex, receiver, handler, errorHandler);
ProcessMessages(receiverContext);
}
_trace.TraceInformation("Subscription to {0} topics in the service bus Topic service completed successfully.", topicNames.Count);
return(new ServiceBusSubscription(_configuration, _namespaceManager, subscriptions, clients));
}
public void Dispose()
{
MessageReceiver?.Dispose();
}
void Start()
{
text = transform.parent.GetChild(0).GetComponent <PlayText>();
msg = GameObject.Find("Controler").GetComponent <MessageReceiver>();
}
public static async Task Run([ServiceBusTrigger(Utils.PURGE_QUEUE_NAME, Connection = "ServiceBusConnection")] Message message, MessageReceiver messageReceiver, string lockToken,
[ServiceBus(Utils.PURGE_QUEUE_NAME, Connection = "ServiceBusConnection", EntityType = EntityType.Queue)] IAsyncCollector <Message> queueCollector,
[ServiceBus(Utils.REGISTRATION_QUEUE_NAME, Connection = "ServiceBusConnection", EntityType = EntityType.Queue)] IAsyncCollector <Message> registrationQueueCollector,
ILogger log)
{
var feedStateItem = FeedState.DecodeFromMessage(message);
log.LogInformation($"Purge Trigger Started: {feedStateItem.name}");
try
{
int itemCount = 0;
var sw = new Stopwatch();
sw.Start();
using (var db = new Database(SqlUtils.SqlDatabaseConnectionString, DatabaseType.SqlServer2012, SqlClientFactory.Instance))
{
itemCount = await db.ExecuteAsync("DELETE_SOURCE @0", feedStateItem.name);
}
sw.Stop();
log.LogWarning($"PURGE TIMER {feedStateItem.name}: Deleted {itemCount} items from source '{feedStateItem.name}' in {sw.ElapsedMilliseconds} ms");
feedStateItem.purgedItems = itemCount;
if (itemCount < 1000)
{
log.LogInformation($"Purge complete for '{feedStateItem.name}'");
// Check lock exists, as close to a transaction as we can get
if (await messageReceiver.RenewLockAsync(lockToken) != null)
{
await messageReceiver.CompleteAsync(lockToken);
// Attempt re-registration unless the proxy cache is being cleared
if (Environment.GetEnvironmentVariable("ClearProxyCache")?.ToString() != "true")
{
feedStateItem.ResetCounters();
feedStateItem.totalPurgeCount++;
await registrationQueueCollector.AddAsync(feedStateItem.EncodeToMessage(1));
}
else
{
log.LogWarning($"Purge Successfully Cleaned: {feedStateItem.name}");
}
}
}
else
{
feedStateItem.purgedItems += itemCount;
// Check lock exists, as close to a transaction as we can get
if (await messageReceiver.RenewLockAsync(lockToken) != null)
{
await messageReceiver.CompleteAsync(lockToken);
await queueCollector.AddAsync(feedStateItem.EncodeToMessage(1));
}
}
}
catch (SqlException ex)
{
log.LogError($"Error during DELETE_SOURCE stored procedure {ex.Number}: " + ex.ToString());
feedStateItem.lastError = ex.ToString();
feedStateItem.purgeRetries++;
TimeSpan timeSpan = new TimeSpan(1, 0, 0);
Random randomTest = new Random();
TimeSpan newSpan = TimeSpan.FromMinutes(randomTest.Next(0, (int)timeSpan.TotalMinutes));
int delaySeconds = (int)newSpan.TotalSeconds;
log.LogWarning($"Unexpected error purging items: Retrying '{feedStateItem.name}' attempt {feedStateItem.purgeRetries} in {delaySeconds} seconds");
// Check lock exists, as close to a transaction as we can get
if (await messageReceiver.RenewLockAsync(lockToken) != null)
{
await messageReceiver.CompleteAsync(lockToken);
await queueCollector.AddAsync(feedStateItem.EncodeToMessage(delaySeconds));
}
}
log.LogInformation($"Purge Trigger Complete: {feedStateItem.name}");
}
public CustomMessageProcessor(MessageReceiver messageReceiver, MessageHandlerOptions messageOptions, ILogger logger)
: base(messageReceiver, messageOptions)
{
_logger = logger;
}
abstract public void CallRPC(string aFunctionName, MessageReceiver aReceiver, int aNetworkId, params object[] aParams);
public async Task ReceiverShouldUseTheLatestPrefetchCount()
{
await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : false, async queueName =>
{
var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName);
var receiver1 = new MessageReceiver(TestUtility.NamespaceConnectionString, queueName, receiveMode: ReceiveMode.ReceiveAndDelete);
var receiver2 = new MessageReceiver(TestUtility.NamespaceConnectionString, queueName, receiveMode: ReceiveMode.ReceiveAndDelete, prefetchCount: 1);
Assert.Equal(0, receiver1.PrefetchCount);
Assert.Equal(1, receiver2.PrefetchCount);
try
{
for (var i = 0; i < 9; i++)
{
var message = new Message(Encoding.UTF8.GetBytes("test" + i))
{
Label = "prefetch" + i
};
await sender.SendAsync(message).ConfigureAwait(false);
}
// Default prefetch count should be 0 for receiver 1.
Assert.Equal("prefetch0", (await receiver1.ReceiveAsync().ConfigureAwait(false)).Label);
// The first ReceiveAsync() would initialize the link and block prefetch2 for receiver2
Assert.Equal("prefetch1", (await receiver2.ReceiveAsync().ConfigureAwait(false)).Label);
await Task.Delay(TwoSeconds);
// Updating prefetch count on receiver1.
receiver1.PrefetchCount = 2;
await Task.Delay(TwoSeconds);
// The next operation should fetch prefetch3 and prefetch4.
Assert.Equal("prefetch3", (await receiver1.ReceiveAsync().ConfigureAwait(false)).Label);
await Task.Delay(TwoSeconds);
Assert.Equal("prefetch2", (await receiver2.ReceiveAsync().ConfigureAwait(false)).Label);
await Task.Delay(TwoSeconds);
// The next operation should block prefetch6 for receiver2.
Assert.Equal("prefetch5", (await receiver2.ReceiveAsync().ConfigureAwait(false)).Label);
await Task.Delay(TwoSeconds);
// Updates in prefetch count of receiver1 should not affect receiver2.
// Receiver2 should continue with 1 prefetch.
Assert.Equal("prefetch4", (await receiver1.ReceiveAsync().ConfigureAwait(false)).Label);
Assert.Equal("prefetch7", (await receiver1.ReceiveAsync().ConfigureAwait(false)).Label);
Assert.Equal("prefetch8", (await receiver1.ReceiveAsync().ConfigureAwait(false)).Label);
}
catch (Exception)
{
// Cleanup
Message message;
do
{
message = await receiver1.ReceiveAsync(TimeSpan.FromSeconds(3)).ConfigureAwait(false);
} while (message != null);
}
finally
{
await sender.CloseAsync();
await receiver1.CloseAsync();
await receiver2.CloseAsync();
}
});
}
public static async Task Run([ServiceBusTrigger("complete", Connection = "SERVICE_BUS_CONNECTION")] Message message, ILogger log,
MessageReceiver messageReceiver, string lockToken)
{
//this code will trigger an unhandled exception becuase it exists outside a try/catch
//throw (new FunctionException("An unhandled FunctionException happened... goodbye..."));
try
{
var Data = Encoding.UTF8.GetString(message.Body);
log.LogInformation($"C# ServiceBus queue trigger function processed message: {message.MessageId}");
log.LogInformation($"The message is: {Data}");
log.LogInformation($"SequenceNumber: {message.SystemProperties.SequenceNumber}");
log.LogInformation($"DeliveryCount: {message.SystemProperties.DeliveryCount}");
//Do whatever you need to do with the message
//Code snippet that simulates transient issue 33% of the time
Random r = new Random();
var n = r.Next(1, 100);
if (n % 3 == 0)
{
throw (new TimeoutException("A transient exception happened, took longer than expected"));
}
//Code snippet to simulate a possible mailformed or invalid message
if (n % 2 == 0)
{
throw (new FormatException("The message failed to process, looks wrong..."));
}
//Code snippet that simulates a general exception another 20% of the time
if (n % 5 == 0)
{
throw (new Exception("An exception was thrown..."));
}
//If the code execution makes it here, then you are good to go
await messageReceiver.CompleteAsync(lockToken);
}
catch (TimeoutException toex)
{
//Wait a couple of seconds
//Let's assume the retry fails again, so we want abandon it
//This will put the message back into the queue and increment DeliveryCount by 1
//You also need to consider, when you will simply break out and stop totally
log.LogInformation($"A transient exception happened: {toex.Message}");
await messageReceiver.AbandonAsync(lockToken);
}
catch (FormatException fex)
{
if (message.SystemProperties.DeliveryCount > 2)
{
log.LogInformation($"Sending message; {message.MessageId} to DLQ");
await messageReceiver.DeadLetterAsync(lockToken, fex.Message + " sending to DLQ");
}
else
{
log.LogInformation($"An format exception happened: {fex.Message}, DeliveryCount: {message.SystemProperties.DeliveryCount}");
await messageReceiver.AbandonAsync(lockToken);
}
}
catch (Exception ex)
{
log.LogInformation($"An exception happened: {ex.Message}, not sure why...");
//Comment out this CompleteAsync and the messafe will get processed when Lock Duration is breached
await messageReceiver.CompleteAsync(lockToken);
}
}
public MessageBus(MessageReceiver messageReceiver, int minimumPriority)
{
this.messageReceiver = messageReceiver;
this.minimumPriority = minimumPriority;
}
internal static async Task CompleteMessagesAsync(MessageReceiver messageReceiver, IEnumerable <BrokeredMessage> messages)
{
await messageReceiver.CompleteAsync(messages.Select(message => message.LockToken));
Log($"Completed {messages.Count()} messages");
}
internal static async Task AbandonMessagesAsync(MessageReceiver messageReceiver, IEnumerable <BrokeredMessage> messages)
{
await messageReceiver.AbandonAsync(messages.Select(message => message.LockToken));
Log($"Abandoned {messages.Count()} messages");
}
// Lite Sync netword data abstract public void LiteSyncNetworkData(int aNetworkId, MessageReceiver aMessageReceiver, DeliveryMethod aDeliveryMethod, byte[] aData);
// Sync network data abstract public void SyncNetworkData(int aNetworkId, MessageReceiver aMessageReceiver, DeliveryMethod aDeliveryMethod, byte[] aData, Vector3 aPosition, Quaternion aRotation);
public Listener(MessageReceiver receiver, ILogger logger, IWebAPIClient webApiClient, BiblosDS.BiblosClient biblosClient, ServiceBus.ServiceBusClient serviceBusClient)
: base(receiver, logger, new Execution(logger, webApiClient, biblosClient, serviceBusClient),
string.Empty, webApiClient, commandNameFilterEnabled: false)
{
}
public async Task Should_be_configured_and_working()
{
var settings = new TestAzureServiceBusAccountSettings();
var provider = new SharedAccessKeyTokenProvider(settings);
TokenProvider tokenProvider = provider.GetTokenProvider();
Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", "masstransit-build",
"MassTransit.AzureServiceBusTransport.Tests");
var namespaceManager = new NamespaceManager(serviceUri, tokenProvider);
CreateQueue(namespaceManager, serviceUri, "TestClient");
CreateHostQueue(tokenProvider);
var mfs = new MessagingFactorySettings
{
TokenProvider = tokenProvider,
OperationTimeout = TimeSpan.FromSeconds(30),
TransportType = TransportType.Amqp,
AmqpTransportSettings = new AmqpTransportSettings
{
BatchFlushInterval = TimeSpan.FromMilliseconds(50),
},
};
MessagingFactory factory =
MessagingFactory.Create(
ServiceBusEnvironment.CreateServiceUri("sb", "masstransit-build", Environment.MachineName), mfs);
MessageReceiver receiver = await factory.CreateMessageReceiverAsync("Control");
receiver.PrefetchCount = 100;
var done = new TaskCompletionSource <bool>();
int count = 0;
const int limit = 1000;
receiver.OnMessageAsync(async message =>
{
var receiveContext = new ServiceBusReceiveContext(new Uri("sb://localhost/queue"), message, new ReceiveObservable());
await message.CompleteAsync();
int received = Interlocked.Increment(ref count);
if (received == limit)
{
done.TrySetResult(true);
}
}, new OnMessageOptions
{
AutoComplete = false,
MaxConcurrentCalls = 100,
AutoRenewTimeout = TimeSpan.FromSeconds(60),
});
MessageSender client = await factory.CreateMessageSenderAsync("Control");
Stopwatch stopwatch = Stopwatch.StartNew();
Task[] tasks = new Task[limit];
for (int i = 0; i < limit; i++)
{
tasks[i] = SendAMessage(client);
}
await done.Task;
stopwatch.Stop();
await Task.WhenAll(tasks);
await receiver.CloseAsync();
Console.WriteLine("Performance: {0:F2}/s", limit * 1000 / stopwatch.ElapsedMilliseconds);
}
private void ReceiveSubscription()
{
subscriptionReceiver = new MessageReceiver(Configuration.ServiceBusConnectionString, EntityNameHelper.FormatSubscriptionPath(TopicName, SubscriptionName), ReceiveMode.ReceiveAndDelete, RetryPolicy.Default);
RegisterHandler(subscriptionReceiver);
}
public Listener(MessageReceiver receiver, ILogger logger, IWebAPIClient webApiClient, BiblosDS.BiblosClient biblosClient)
: base(receiver, logger, new Execution(logger, webApiClient, biblosClient), "CommandCreateUDS", webApiClient)
{
}
private void ReceiveQueue()
{
queueReceiver = new MessageReceiver(Configuration.ServiceBusConnectionString, QueueName, ReceiveMode.ReceiveAndDelete, RetryPolicy.Default);
RegisterHandler(queueReceiver);
}
/// <summary>
/// Constructs a new instance.
/// </summary>
/// <param name="messageReceiver">The <see cref="MessageReceiver"/>.</param>
/// <param name="messageOptions">The <see cref="MessageHandlerOptions"/> to use.</param>
public MessageProcessor(MessageReceiver messageReceiver, MessageHandlerOptions messageOptions)
{
MessageReceiver = messageReceiver ?? throw new ArgumentNullException(nameof(messageReceiver));
MessageOptions = messageOptions ?? throw new ArgumentNullException(nameof(messageOptions));
}
public RequestReplyResponder(Uri namespaceUri, MessageReceiver receiver, Func <BrokeredMessage, Task <BrokeredMessage> > responseFunction)
{
this.namespaceUri = namespaceUri;
this.receiver = receiver;
this.responseFunction = responseFunction;
}
private async Task <Microsoft.Azure.ServiceBus.Message> GetMessageFromReceiver(MessageReceiver messageReceiver, TimeSpan?timeout)
{
var msg = timeout.HasValue
? await messageReceiver.ReceiveAsync(timeout.Value)
: await messageReceiver.ReceiveAsync();
await messageReceiver.CompleteAsync(msg.SystemProperties.LockToken);
return(msg);
}
public FullSocket(FullSocketConfiguration configuration, MessageReceiver messageReceiver)
{
_mConfiguration = configuration;
MessageBuilder = messageReceiver;
}
