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