private IEnumerator <IAsyncResult> DeleteQueueContainerImpl(string containerName, IContainerCondition conditions, AsyncIteratorContext <NoResults> context)
{
IStringDataEventStream verboseDebug = Logger <INormalAndDebugLogger> .Instance.VerboseDebug;
object[] objArray = new object[] { containerName, this.Timeout };
verboseDebug.Log("DeleteQueueContainerImpl({0},{1})", objArray);
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute((TimeSpan param0) => {
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer queueContainer = new Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer()
{
AccountName = this._account.Name,
QueueName = containerName
};
queueContainer = DbQueueContainer.LoadQueueContainer(dbContext, queueContainer);
DbQueueContainer.CheckQueueContainerCondition(queueContainer, conditions);
dbContext.QueueContainers.DeleteOnSubmit(queueContainer);
dbContext.SubmitChanges();
}
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("StorageAccount.DeleteBlobContainerImpl"));
yield return(asyncResult);
this.StorageManager.AsyncProcessor.EndExecute(asyncResult);
}
private IEnumerator <IAsyncResult> PeekMessageImpl(int numberOfMessages, AsyncIteratorContext <IEnumerable <IMessageData> > context)
{
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute <List <IMessageData> >((TimeSpan remaining) => {
List <IMessageData> messageDatas;
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer queueContainer = this.LoadQueueContainer(dbContext);
this._queue = queueContainer;
IQueryable <QueueMessage> queueMessages = (
from m in dbContext.QueueMessages
where (m.AccountName == this._queue.AccountName) && (m.QueueName == this._queue.QueueName) && (m.VisibilityStartTime <= DateTime.UtcNow) && (m.ExpiryTime >= DateTime.UtcNow)
orderby m.VisibilityStartTime
select m).Take <QueueMessage>(numberOfMessages);
List <IMessageData> messageDatas1 = new List <IMessageData>();
foreach (QueueMessage queueMessage in queueMessages)
{
messageDatas1.Add(new DbMessageData(queueMessage, true));
}
messageDatas = messageDatas1;
}
return(messageDatas);
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("DbQueueContainer.PeekMessage"));
yield return(asyncResult);
context.ResultData = this.StorageManager.AsyncProcessor.EndExecute <List <IMessageData> >(asyncResult);
}
private IEnumerator <IAsyncResult> CreateQueueContainerImpl(string containerName, DateTime?expiryTime, byte[] serviceMetadata, byte[] applicationMetadata, AsyncIteratorContext <IQueueContainer> context)
{
IStringDataEventStream verboseDebug = Logger <INormalAndDebugLogger> .Instance.VerboseDebug;
object[] objArray = new object[] { containerName, expiryTime, serviceMetadata, applicationMetadata, this.Timeout };
verboseDebug.Log("CreateQueueContainerImpl({0},{1},{2},{3},{4})", objArray);
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute <DbQueueContainer>((TimeSpan param0) => {
Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer queueContainer = new Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer()
{
AccountName = this._account.Name,
QueueName = containerName,
ServiceMetadata = serviceMetadata,
Metadata = applicationMetadata
};
DbQueueContainer dbQueueContainer = new DbQueueContainer(this, queueContainer);
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
dbContext.QueueContainers.InsertOnSubmit(queueContainer);
dbContext.SubmitChanges();
}
return(dbQueueContainer);
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("StorageAccount.CreateQueueContainer"));
yield return(asyncResult);
context.ResultData = this.StorageManager.AsyncProcessor.EndExecute <DbQueueContainer>(asyncResult);
}
private IEnumerator <IAsyncResult> DeleteMessageImpl(IQueueMessageReceipt queueMessageReceipt, AsyncIteratorContext <bool> context)
{
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute <bool>((TimeSpan remaining) => {
bool flag;
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer queueContainer = this.LoadQueueContainer(dbContext);
context.ResultData = false;
Receipt receipt = (Receipt)queueMessageReceipt;
Guid messageId = receipt.MessageId;
DateTime visibilityStart = receipt.VisibilityStart;
QueueMessage queueMessage = (
from m in dbContext.QueueMessages
where (m.AccountName == this._queue.AccountName) && (m.QueueName == this._queue.QueueName) && (m.VisibilityStartTime == visibilityStart) && (m.MessageId == messageId)
select m).FirstOrDefault <QueueMessage>();
if (queueMessage == null)
{
throw new MessageNotFoundException();
}
dbContext.QueueMessages.DeleteOnSubmit(queueMessage);
dbContext.SubmitChanges();
this._queue = queueContainer;
flag = true;
}
return(flag);
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("DbQueueContainer.DeleteMessageImpl"));
yield return(asyncResult);
context.ResultData = this.StorageManager.AsyncProcessor.EndExecute <bool>(asyncResult);
}
internal DbQueueContainer(DbStorageAccount account, Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer container)
{
StorageStampHelpers.CheckContainerName(container.QueueName, Microsoft.Cis.Services.Nephos.Common.Storage.ContainerType.QueueContainer, false);
this.StorageManager = account.StorageManager;
this._queue = container;
this.OperationStatus = account.OperationStatus;
this.Account = account;
}
internal static void CheckQueueContainerCondition(Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer queueContainer, IContainerCondition condition)
{
if (condition != null && condition.IfModifiedSinceTime.HasValue && condition.IfModifiedSinceTime.Value >= queueContainer.LastModificationTime)
{
throw new ConditionNotMetException(null, null, null);
}
if (condition != null && condition.IfNotModifiedSinceTime.HasValue && condition.IfNotModifiedSinceTime.Value < queueContainer.LastModificationTime)
{
throw new ConditionNotMetException(null, null, null);
}
}
internal static Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer LoadQueueContainer(DevelopmentStorageDbDataContext context, Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer queue)
{
StorageStampHelpers.CheckContainerName(queue.QueueName, Microsoft.Cis.Services.Nephos.Common.Storage.ContainerType.QueueContainer, false);
Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer queueContainer = (
from c in context.QueueContainers
where (c.AccountName == queue.AccountName) && (c.QueueName == queue.QueueName)
select c).FirstOrDefault <Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer>();
if (queueContainer == null)
{
throw new ContainerNotFoundException();
}
return(queueContainer);
}
private IEnumerator <IAsyncResult> GetPropertiesImpl(ContainerPropertyNames propertyNames, IContainerCondition condition, AsyncIteratorContext <NoResults> context)
{
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute((TimeSpan remaining) => {
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer queueContainer = this.LoadQueueContainer(dbContext);
DbQueueContainer.CheckQueueContainerCondition(queueContainer, condition);
this._queue = queueContainer;
}
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("DbQueueContainer.GetPropertiesImpl"));
yield return(asyncResult);
this.StorageManager.AsyncProcessor.EndExecute(asyncResult);
}
private IEnumerator <IAsyncResult> ClearQueueImpl(AsyncIteratorContext <NoResults> context)
{
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute((TimeSpan remaining) => {
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer queueContainer = this.LoadQueueContainer(dbContext);
dbContext.ClearQueue(queueContainer.AccountName, queueContainer.QueueName);
this._queue = queueContainer;
}
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("DbQueueContainer.ClearQueue"));
yield return(asyncResult);
this.StorageManager.AsyncProcessor.EndExecute(asyncResult);
}
private IEnumerator <IAsyncResult> UpdateMessageImpl(IQueueMessageReceipt queueMessageReceipt, byte[] body, TimeSpan visibilityTimeout, TimeSpan?timeToLive, AsyncIteratorContext <IQueueMessageReceipt> context)
{
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute <IQueueMessageReceipt>((TimeSpan remaining) => {
IQueueMessageReceipt receipt;
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer queueContainer = this.LoadQueueContainer(dbContext);
this._queue = queueContainer;
QueueMessage queueMessage = (
from m in dbContext.QueueMessages
where (m.AccountName == this._queue.AccountName) && (m.QueueName == this._queue.QueueName) && (m.MessageId == ((Receipt)queueMessageReceipt).MessageId) && (m.VisibilityStartTime == ((Receipt)queueMessageReceipt).VisibilityStart)
select m).FirstOrDefault <QueueMessage>();
if (queueMessage == null)
{
throw new MessageNotFoundException();
}
DateTime utcNow = DateTime.UtcNow;
QueueMessage queueMessage1 = new QueueMessage()
{
AccountName = queueMessage.AccountName,
QueueName = queueMessage.QueueName,
VisibilityStartTime = utcNow.Add(visibilityTimeout),
MessageId = queueMessage.MessageId,
ExpiryTime = queueMessage.ExpiryTime,
InsertionTime = queueMessage.InsertionTime,
DequeueCount = queueMessage.DequeueCount,
Data = body ?? queueMessage.Data
};
dbContext.QueueMessages.DeleteOnSubmit(queueMessage);
dbContext.QueueMessages.InsertOnSubmit(queueMessage1);
dbContext.SubmitChanges();
receipt = new Receipt()
{
MessageId = ((Receipt)queueMessageReceipt).MessageId,
VisibilityStart = queueMessage1.VisibilityStartTime,
DequeueCount = queueMessage1.DequeueCount
};
}
return(receipt);
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("DbQueueContainer.UpdateMessage"));
yield return(asyncResult);
context.ResultData = this.StorageManager.AsyncProcessor.EndExecute <IQueueMessageReceipt>(asyncResult);
}
private IEnumerator <IAsyncResult> GetQueueStatisticsImpl(bool includeInvisibleMessages, bool includeExpiredMessages, AsyncIteratorContext <IQueueStatistics> context)
{
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute <DbQueueStatistics>((TimeSpan remaining) => {
DbQueueStatistics dbQueueStatistic;
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer queueContainer = this.LoadQueueContainer(dbContext);
IQueryable <QueueMessage> queueMessages =
from m in dbContext.QueueMessages
where (m.AccountName == this._queue.AccountName) && (m.QueueName == this._queue.QueueName)
select m;
if (!includeExpiredMessages)
{
queueMessages =
from m in queueMessages
where m.VisibilityStartTime >= DateTime.UtcNow
select m;
}
if (!includeExpiredMessages)
{
queueMessages =
from m in queueMessages
where m.ExpiryTime <= DateTime.UtcNow
select m;
}
var variable = (
from m in queueMessages
group m by m.AccountName into s
select new { TotalMessages = s.Count <QueueMessage>(), TotalSize = s.Sum <QueueMessage>((QueueMessage m) => m.Data.Length) }).FirstOrDefault();
this._queue = queueContainer;
dbQueueStatistic = (variable == null ? new DbQueueStatistics((long)0, (long)0) : new DbQueueStatistics((long)variable.TotalMessages, (long)variable.TotalSize));
}
return(dbQueueStatistic);
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("DbQueueContainer.GetQueueStatistics"));
yield return(asyncResult);
context.ResultData = this.StorageManager.AsyncProcessor.EndExecute <DbQueueStatistics>(asyncResult);
}
private IEnumerator <IAsyncResult> GetMessageImpl(int numberOfMessages, TimeSpan visibilityTimeout, AsyncIteratorContext <IEnumerable <IMessageData> > context)
{
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute <List <IMessageData> >((TimeSpan remaining) => {
List <IMessageData> messageDatas;
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer queueContainer = this.LoadQueueContainer(dbContext);
ISingleResult <QueueMessage> queueMessages = dbContext.DequeueMessages(this._queue.AccountName, this._queue.QueueName, new int?((int)visibilityTimeout.TotalSeconds), new int?(numberOfMessages));
List <IMessageData> messageDatas1 = new List <IMessageData>();
foreach (QueueMessage queueMessage in queueMessages)
{
messageDatas1.Add(new DbMessageData(queueMessage, false));
}
this._queue = queueContainer;
messageDatas = messageDatas1;
}
return(messageDatas);
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("DbQueueContainer.GetMessage"));
yield return(asyncResult);
context.ResultData = this.StorageManager.AsyncProcessor.EndExecute <List <IMessageData> >(asyncResult);
}
private IEnumerator <IAsyncResult> SetPropertiesImpl(ContainerPropertyNames propertyNames, IContainerCondition condition, AsyncIteratorContext <NoResults> context)
{
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute((TimeSpan remaining) => {
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer applicationMetadata = this.LoadQueueContainer(dbContext);
if ((propertyNames & ContainerPropertyNames.ApplicationMetadata) != ContainerPropertyNames.None)
{
StorageStampHelpers.ValidateApplicationMetadata(this.ApplicationMetadata);
applicationMetadata.Metadata = this.ApplicationMetadata;
}
if ((propertyNames & ContainerPropertyNames.ServiceMetadata) != ContainerPropertyNames.None)
{
applicationMetadata.ServiceMetadata = ((IContainer)this).ServiceMetadata;
}
dbContext.SubmitChanges();
this._queue = applicationMetadata;
}
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("DbQueueContainer.SetProperties"));
yield return(asyncResult);
this.StorageManager.AsyncProcessor.EndExecute(asyncResult);
}
private IEnumerator <IAsyncResult> ListMessagesImpl(string queueNameStart, DateTime?visibilityStart, Guid messageIdStart, int?subQueueId, bool includeInvisibleMessages, int numberOfMessages, AsyncIteratorContext <ListMessagesResult> context)
{
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute <ListMessagesResult>((TimeSpan remaining) => {
ListMessagesResult listMessagesResults;
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer queueContainer = this.LoadQueueContainer(dbContext);
this._queue = queueContainer;
queueNameStart = (string.IsNullOrEmpty(queueNameStart) ? this._queue.QueueName : queueNameStart);
DateTime?nullable = visibilityStart;
visibilityStart = new DateTime?((nullable.HasValue ? nullable.GetValueOrDefault() : DateTime.UtcNow));
IQueryable <QueueMessage> queueMessages =
from m in dbContext.QueueMessages
select m;
queueMessages =
from m in queueMessages
where (m.AccountName == this._queue.AccountName) && (m.QueueName == queueNameStart) && (m.ExpiryTime >= DateTime.UtcNow)
select m;
if (messageIdStart != Guid.Empty)
{
queueMessages = (!includeInvisibleMessages ?
from m in queueMessages
where ((DateTime?)m.VisibilityStartTime > visibilityStart) && (m.VisibilityStartTime <= DateTime.UtcNow) || ((DateTime?)m.VisibilityStartTime == visibilityStart) && (m.VisibilityStartTime <= DateTime.UtcNow) && string.Compare(m.MessageId.ToString(), messageIdStart.ToString(), true) >= 0
select m :
from m in queueMessages
where ((DateTime?)m.VisibilityStartTime > visibilityStart) || ((DateTime?)m.VisibilityStartTime == visibilityStart) && string.Compare(m.MessageId.ToString(), messageIdStart.ToString(), true) >= 0
select m);
}
else if (!includeInvisibleMessages)
{
queueMessages =
from m in queueMessages
where (DateTime?)m.VisibilityStartTime <= visibilityStart
select m;
}
queueMessages = (
from m in queueMessages
orderby m.VisibilityStartTime
select m).Take <QueueMessage>(numberOfMessages);
ListMessagesResult listMessagesResults1 = new ListMessagesResult();
List <IMessageData> messageDatas = new List <IMessageData>();
int num = 1;
QueueMessage queueMessage = null;
foreach (QueueMessage queueMessage1 in queueMessages)
{
queueMessage = queueMessage1;
messageDatas.Add(new DbMessageData(queueMessage1, true));
num++;
}
if (num > numberOfMessages && queueMessage != null)
{
IQueryable <QueueMessage> queueMessages1 = (
from msg in dbContext.QueueMessages
where (msg.AccountName == queueMessage.AccountName) && (msg.QueueName == queueMessage.QueueName) && ((msg.VisibilityStartTime > queueMessage.VisibilityStartTime) || (msg.VisibilityStartTime == queueMessage.VisibilityStartTime) && string.Compare(msg.MessageId.ToString(), queueMessage.MessageId.ToString(), true) > 0)
orderby msg.VisibilityStartTime, msg.MessageId
select msg).Take <QueueMessage>(1);
if (queueMessages1 != null && queueMessages1.Count <QueueMessage>() > 0)
{
QueueMessage queueMessage2 = queueMessages1.First <QueueMessage>();
listMessagesResults1.NextMarker = SummaryResult.EncodeMarker <ListMessagesMarker>(new ListMessagesMarker(queueMessage2.QueueName, 0, new DateTime?(queueMessage2.VisibilityStartTime), queueMessage2.MessageId));
}
}
listMessagesResults1.Messages = messageDatas;
listMessagesResults = listMessagesResults1;
}
return(listMessagesResults);
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("DbQueueContainer.PeekMessage"));
yield return(asyncResult);
context.ResultData = this.StorageManager.AsyncProcessor.EndExecute <ListMessagesResult>(asyncResult);
}
