void AssertReplicationMessageIsEnqueued(MessageTypes messageType, string container, string blobName, string primaryAccount) { // Wait for the messages to be fully enqueued Task.Delay(1000).Wait(); var queue = new AzureMessageQueue(); var replicaAccounts = DashConfiguration.DataAccounts .Select(account => account.Credentials.AccountName) .Where(accountName => !String.Equals(accountName, primaryAccount, StringComparison.OrdinalIgnoreCase)) .ToDictionary(accountName => accountName, accountName => false, StringComparer.OrdinalIgnoreCase); while (true) { var replicateMessage = queue.Dequeue(); if (replicateMessage == null) { break; } Assert.IsNotNull(replicateMessage); Assert.AreEqual(replicateMessage.MessageType, messageType); if (messageType == MessageTypes.BeginReplicate) { Assert.AreEqual(replicateMessage.Payload[ReplicatePayload.Source], primaryAccount); } Assert.AreEqual(replicateMessage.Payload[ReplicatePayload.Container], container); Assert.AreEqual(replicateMessage.Payload[ReplicatePayload.BlobName], blobName); replicaAccounts[replicateMessage.Payload[messageType == MessageTypes.BeginReplicate ? ReplicatePayload.Destination : ReplicatePayload.Source]] = true; queue.DeleteCurrentMessage(); } Assert.IsFalse(replicaAccounts.Any(account => !account.Value), "Data accounts detected with no replication enqueued: {0}", String.Join(", ", replicaAccounts .Where(account => !account.Value) .Select(account => account.Key))); }
public Tuple <ISendMessages, IReceiveMessages> Create() { sender = GetQueue("myTestSender"); receiver = GetQueue("myTestReceiver"); return(new Tuple <ISendMessages, IReceiveMessages>(sender, receiver)); }
private static void ReceiveFailure(AzureMessageQueue queue) { using (var session = queue.BeginSession()) { Console.WriteLine("Sending"); session.EnqueueAsync(new Message("Hello world FAIL")).GetAwaiter().GetResult(); session.SaveChanges().GetAwaiter().GetResult(); } for (int i = 0; i < 11; i++) { try { using (var session = queue.BeginSession()) { var message = session.Dequeue(TimeSpan.FromSeconds(1)).GetAwaiter().GetResult(); if (message == null) { Console.WriteLine("** GOT NONE FROM FAIL, YAY!"); } else { Console.WriteLine("GOT FAIL: " + message.Body); } throw new Exception("shit!"); } } catch (Exception ex) { Console.WriteLine($"Attempt {i}: {ex.Message}"); } } }
private static void SendReceiveBatch(AzureMessageQueue queue) { using (var session = queue.BeginSession()) { Console.WriteLine("Sending"); session.EnqueueAsync(new Message("Hello world1")).GetAwaiter().GetResult(); session.EnqueueAsync(new Message("Hello world2")).GetAwaiter().GetResult(); session.EnqueueAsync(new Message("Hello world3")).GetAwaiter().GetResult(); session.EnqueueAsync(new Message("Hello world4")).GetAwaiter().GetResult(); session.SaveChanges().GetAwaiter().GetResult(); } using (var session = queue.BeginSession()) { var message = session.Dequeue(TimeSpan.FromSeconds(30)).GetAwaiter().GetResult(); Console.WriteLine("GOT1: " + message.Body); message = session.Dequeue(TimeSpan.FromSeconds(30)).GetAwaiter().GetResult(); Console.WriteLine("GOT2: " + message.Body); message = session.Dequeue(TimeSpan.FromSeconds(30)).GetAwaiter().GetResult(); Console.WriteLine("GOT3: " + message.Body); message = session.Dequeue(TimeSpan.FromSeconds(30)).GetAwaiter().GetResult(); Console.WriteLine("GOT4: " + message.Body); session.SaveChanges().GetAwaiter().GetResult(); } }
public static void ProcessMessageLoop(ref int msgProcessed, ref int msgErrors, int?invisibilityTimeout = null) { IMessageQueue queue = new AzureMessageQueue(); while (true) { try { QueueMessage payload = queue.Dequeue(invisibilityTimeout); if (payload == null) { break; } // Right now, success/failure is indicated through a bool // Do we want to surround this with a try/catch and use exceptions instead? if (ProcessMessage(payload, invisibilityTimeout)) { queue.DeleteCurrentMessage(); msgProcessed++; } else { // Leave it in the queue for retry after invisibility period expires msgErrors++; } } catch (Exception ex) { DashTrace.TraceWarning("Unhandled exception processing async message. Message will be left in queue. Details: {0}", ex); msgErrors++; } } }
public void Init() { _runner = new WebApiTestRunner(new Dictionary <string, string>() { { "AccountName", "dashtest" }, { "StorageConnectionStringMaster", "DefaultEndpointsProtocol=https;AccountName=dashtestnamespace;AccountKey=N+BMOAp/bswfqp4dxoQYLLwmYnERysm1Xxv3qSf5H9RVhQ0q+f/QKNHhXX4Z/P67mZ+5QwT6RZv9qKV834pOqQ==" }, { "ScaleoutStorage0", "DefaultEndpointsProtocol=https;AccountName=dashtestdata1;AccountKey=IatOQyIdf8x3HcCZuhtGGLv/nS0v/SwXu2vBS6E9/5/+GYllhdmFFX6YqMXmR7U6UyFYQt4pdZnlLCM+bPcJ4A==" }, { "ScaleoutStorage1", "DefaultEndpointsProtocol=https;AccountName=dashtestdata2;AccountKey=OOXSVWWpImRf79sbiEtpIwFsggv7VAhdjtKdt7o0gOLr2krzVXwZ+cb/gJeMqZRlXHTniRN6vnKKjs1glijihA==" }, { "ScaleoutNumberOfAccounts", "2" }, }); _queue = new AzureMessageQueue(Guid.NewGuid().ToString()); }
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 static async Task EnqueueBlobReplicationAsync(NamespaceBlob namespaceBlob, bool deleteReplica, bool saveNamespaceEntry = true) { if (!await namespaceBlob.ExistsAsync()) { return; } // Trim down the namespace replication list to the first 'master' item. This is sufficient to ensure that the // orphaned blobs are not effectively in the account. The master blob will be replicated over the top of the // orphaned blobs. string primaryAccount = namespaceBlob.PrimaryAccountName; if (namespaceBlob.IsReplicated) { namespaceBlob.PrimaryAccountName = primaryAccount; if (saveNamespaceEntry) { await namespaceBlob.SaveAsync(); } } // This rest of this method does not block. Enqueueing the replication is a completely async process var task = Task.Factory.StartNew(() => { var queue = new AzureMessageQueue(); var tasks = DashConfiguration.DataAccounts .Where(dataAccount => !dataAccount.Credentials.AccountName.Equals(primaryAccount, StringComparison.OrdinalIgnoreCase)) .Select(async dataAccount => await queue.EnqueueAsync(ConstructReplicationMessage(deleteReplica, primaryAccount, dataAccount.Credentials.AccountName, namespaceBlob.Container, namespaceBlob.BlobName, deleteReplica ? await GetBlobETagAsync(dataAccount, namespaceBlob.Container, namespaceBlob.BlobName) : null))); Task.WhenAll(tasks) .ContinueWith(antecedent => { if (antecedent.Exception != null) { DashTrace.TraceWarning("Error queueing replication message for blob: {0}. Details: {1}", PathUtils.CombineContainerAndBlob(namespaceBlob.Container, namespaceBlob.BlobName), antecedent.Exception.Flatten()); } else { DashTrace.TraceInformation("Blob: {0} has been enqueued for replication.", PathUtils.CombineContainerAndBlob(namespaceBlob.Container, namespaceBlob.BlobName)); } }); }); }
public void Setup() { client = CloudStorageAccount.DevelopmentStorageAccount.CreateCloudQueueClient(); nativeQueue = client.GetQueueReference(QueueName); nativeQueue.CreateIfNotExist(); nativeQueue.Clear(); queue = new AzureMessageQueue(client) { PurgeOnStartup = PurgeOnStartup }; queue.Init(QueueName,true); }
public void Setup() { client = CloudStorageAccount.DevelopmentStorageAccount.CreateCloudQueueClient(); nativeQueue = client.GetQueueReference(QueueName); nativeQueue.CreateIfNotExist(); nativeQueue.Clear(); queue = new AzureMessageQueue(client) { PurgeOnStartup = PurgeOnStartup }; queue.Init(QueueName, true); }
private static void ClearQueue(AzureMessageQueue queue) { using (var session = queue.BeginSession()) { while (true) { var message = session.Dequeue(TimeSpan.FromSeconds(1)).GetAwaiter().GetResult(); Console.WriteLine("CLEAR DQ: " + message?.Body); if (message == null) { break; } } session.SaveChanges().GetAwaiter().GetResult(); } }
void AssertQueueIsDrained() { // Wait for the messages to be fully enqueued Task.Delay(1000).Wait(); bool messageSeen = false; var queue = new AzureMessageQueue(); while (true) { var message = queue.Dequeue(); if (message == null) { break; } queue.DeleteCurrentMessage(); messageSeen = true; } if (messageSeen) { Assert.Fail("Expected queue to be empty"); } }
public void Cleanup() { var queue = new AzureMessageQueue(); queue.DeleteQueue(); }
Tuple<ISendMessages, IReceiveMessages> AzureQueueTransports() { var sender = new AzureMessageQueue(CloudStorageAccount.DevelopmentStorageAccount, "testqueue").PurgeInputQueue(); var receiver = new AzureMessageQueue(CloudStorageAccount.DevelopmentStorageAccount, "testqueue").PurgeInputQueue(); return new Tuple<ISendMessages, IReceiveMessages>(sender, receiver); }