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> 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> SnapshotBlobImpl(byte[] metadata, IBlobObjectCondition condition, AsyncIteratorContext <DateTime> context)
{
IAsyncResult asyncResult = this._storageManager.AsyncProcessor.BeginExecute <DateTime>((TimeSpan param0) => {
DateTime value;
StorageStampHelpers.ValidateApplicationMetadata(metadata);
using (TransactionScope transactionScope = new TransactionScope())
{
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
base.LoadContainer(dbContext);
BlockBlob blockBlob = base.LoadBlockBlob(dbContext);
BlobLeaseInfo blobLeaseInfo = new BlobLeaseInfo(blockBlob, DateTime.UtcNow);
DbBlobObject.CheckConditionsAndReturnResetRequired(blockBlob, blobLeaseInfo, condition, null, false);
DateTime?nullable = null;
DateTime?nullable1 = null;
dbContext.SnapshotBlockBlob(blockBlob.AccountName, blockBlob.ContainerName, blockBlob.BlobName, metadata, ref nullable, ref nullable1);
transactionScope.Complete();
nullable = new DateTime?(DateTime.SpecifyKind(nullable.Value, DateTimeKind.Utc));
this._blob = blockBlob;
this.LeaseInfo = blobLeaseInfo;
if (nullable1.HasValue)
{
this._blob.LastModificationTime = new DateTime?(nullable1.Value);
}
value = nullable.Value;
}
}
return(value);
}, base.Timeout, context.GetResumeCallback(), context.GetResumeState("BlobObject.SnapshotBlobImpl"));
yield return(asyncResult);
context.ResultData = this._storageManager.AsyncProcessor.EndExecute <DateTime>(asyncResult);
}
public bool TryResolveResourceSet(string name, out ResourceSet resourceSet)
{
string str;
if (this.m_currentResourceContainer == null || !name.Equals(this.m_currentResourceContainer.ResourceType.Name, StringComparison.OrdinalIgnoreCase))
{
if (!TableResourceContainer.IsUtilityTables(name))
{
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
str = (
from t in dbContext.TableContainers
where (t.AccountName == this.AccountName) && (t.TableName == name.ToLowerInvariant())
select t.CasePreservedTableName).FirstOrDefault <string>();
}
if (str == null)
{
resourceSet = null;
throw new ContainerNotFoundException();
}
this.m_currentResourceContainer = TableResourceContainer.GetResourceContainer(this.AccountName, str, false);
}
else
{
this.m_currentResourceContainer = TableResourceContainer.GetResourceContainer(this.AccountName, "Tables", false);
}
}
resourceSet = this.m_currentResourceContainer;
return(true);
}
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> ReleaseLeaseImpl(Guid leaseId, IContainerCondition condition, bool updateLastModificationTime, AsyncIteratorContext <NoResults> context)
{
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute((TimeSpan param0) => {
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
Microsoft.WindowsAzure.DevelopmentStorage.Store.BlobContainer nullable = this.LoadBlobContainer(dbContext);
DbBlobContainer.CheckBlobContainerConditionWithoutLeaseCondition(nullable, condition);
DateTime utcNow = DateTime.UtcNow;
ContainerLeaseInfo containerLeaseInfo = new ContainerLeaseInfo(nullable, utcNow);
if (containerLeaseInfo.Id.HasValue && containerLeaseInfo.Id.Value != leaseId)
{
throw new LeaseLostException();
}
if (containerLeaseInfo.State.Value == LeaseState.Available)
{
throw new LeaseLostException();
}
nullable.LeaseEndTime = new DateTime?(utcNow);
nullable.LeaseState = 0;
nullable.IsLeaseOp = !updateLastModificationTime;
dbContext.SubmitChanges();
containerLeaseInfo.SetBlobContainer(nullable, utcNow);
this._container = nullable;
this.LeaseInfo = containerLeaseInfo;
}
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("DbBlobContainer.ReleaseLease"));
yield return(asyncResult);
this.StorageManager.AsyncProcessor.EndExecute(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);
}
private IEnumerator <IAsyncResult> SetPropertiesImpl(ContainerPropertyNames propertyNames, IContainerCondition condition, AsyncIteratorContext <NoResults> context)
{
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute <Microsoft.WindowsAzure.DevelopmentStorage.Store.BlobContainer>((TimeSpan param0) => {
Microsoft.WindowsAzure.DevelopmentStorage.Store.BlobContainer blobContainer;
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
Microsoft.WindowsAzure.DevelopmentStorage.Store.BlobContainer serviceMetadata = this.LoadBlobContainer(dbContext);
ContainerLeaseInfo containerLeaseInfo = new ContainerLeaseInfo(serviceMetadata, DateTime.UtcNow);
DbBlobContainer.CheckBlobContainerCondition(serviceMetadata, condition, containerLeaseInfo);
if ((propertyNames & ContainerPropertyNames.ServiceMetadata) != ContainerPropertyNames.None)
{
serviceMetadata.ServiceMetadata = ((IContainer)this).ServiceMetadata;
}
if ((propertyNames & ContainerPropertyNames.ApplicationMetadata) != ContainerPropertyNames.None)
{
serviceMetadata.Metadata = this.ApplicationMetadata;
}
dbContext.SubmitChanges();
this.LeaseInfo = containerLeaseInfo;
blobContainer = serviceMetadata;
}
return(blobContainer);
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("DbBlobContainer.SetProperties"));
yield return(asyncResult);
this._container = this.StorageManager.AsyncProcessor.EndExecute <Microsoft.WindowsAzure.DevelopmentStorage.Store.BlobContainer>(asyncResult);
}
private IEnumerator <IAsyncResult> GetBlockListImpl(IBlobObjectCondition condition, BlockListTypes blockListTypes, BlobServiceVersion blobServiceVersion, AsyncIteratorContext <IBlockLists> context)
{
IAsyncResult asyncResult = this._storageManager.AsyncProcessor.BeginExecute <BlockLists>((TimeSpan param0) => {
BlockLists blockList;
using (TransactionScope transactionScope = new TransactionScope())
{
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
base.LoadContainer(dbContext);
BlockBlob blockBlob = base.LoadBlockBlob(dbContext, true);
BlobLeaseInfo blobLeaseInfo = new BlobLeaseInfo(blockBlob, DateTime.UtcNow);
DbBlobObject.CheckConditionsAndReturnResetRequired(blockBlob, blobLeaseInfo, condition, null, false);
BlockLists dbBlockCollections = new BlockLists()
{
BlobLastModificationTime = blockBlob.LastModificationTime.Value,
BlobSize = blockBlob.ContentLength
};
if ((blockListTypes & BlockListTypes.Committed) != BlockListTypes.None)
{
List <IBlock> blocks = new List <IBlock>();
if (blockBlob.HasBlock.Value)
{
foreach (CommittedBlock committedBlock in
from blck in dbContext.CommittedBlocks
where (blck.AccountName == this._blob.AccountName) && (blck.ContainerName == this._blob.ContainerName) && (blck.BlobName == this._blob.BlobName) && (blck.VersionTimestamp == this._blob.VersionTimestamp)
select blck)
{
blocks.Add(new Block(DbListBlobObject.FromHexString(committedBlock.BlockId), committedBlock.Length.Value));
}
}
dbBlockCollections.CommittedBlockList = new DbListBlobObject.DbBlockCollection(blocks);
}
if ((blockListTypes & BlockListTypes.Uncommitted) != BlockListTypes.None)
{
List <IBlock> blocks1 = new List <IBlock>();
foreach (BlockData blockDatum in
from blck in dbContext.BlocksData
where (blck.AccountName == this._blob.AccountName) && (blck.ContainerName == this._blob.ContainerName) && (blck.BlobName == this._blob.BlobName) && (blck.VersionTimestamp == this._blob.VersionTimestamp) && !blck.IsCommitted
select blck)
{
blocks1.Add(new Block(DbListBlobObject.FromHexString(blockDatum.BlockId), blockDatum.Length.Value));
}
dbBlockCollections.UncommittedBlockList = new DbListBlobObject.DbBlockCollection(blocks1);
}
transactionScope.Complete();
this._blob = blockBlob;
this.LeaseInfo = blobLeaseInfo;
blockList = dbBlockCollections;
}
}
return(blockList);
}, base.Timeout, context.GetResumeCallback(), context.GetResumeState("DbListBlobObject.GetBlockList"));
yield return(asyncResult);
context.ResultData = this._storageManager.AsyncProcessor.EndExecute <BlockLists>(asyncResult);
}
private bool PutBlockList()
{
bool flag;
bool flag1 = false;
try
{
for (int i = 0; i < this._maxNumberOfRetries; i++)
{
try
{
using (TransactionScope transactionScope = new TransactionScope(TransactionScopeOption.RequiresNew))
{
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
this.GetContainer(dbContext);
BlockBlob blob = this.GetBlob(dbContext, true) as BlockBlob;
BlobServiceMetaData instance = BlobServiceMetaData.GetInstance(blob.ServiceMetadata);
instance.CopyStatus = "success";
instance.CopyProgressOffset = this._contentLength.ToString();
instance.CopyProgressTotal = this._contentLength.ToString();
instance.CopyCompletionTime = new long?(DateTime.UtcNow.ToFileTimeUtc());
blob.HasBlock = new bool?((this._blockIds.Count > 1 ? true : this._contentLength < (long)4194304));
blob.ContentLength = this._contentLength;
blob.ServiceMetadata = instance.GetMetadata();
blob.IsCommitted = new bool?(false);
blob.UncommittedBlockIdLength = null;
dbContext.SubmitChanges();
dbContext.CommitBlockList(this._accountName, this._containerName, this._blobName, DbListBlobObject.SerializeCommitBlockListEntryFromUncommitted(this._blockIds).ToString(), ref this._lastModifiedTime);
transactionScope.Complete();
}
}
IStringDataEventStream info = Logger <IRestProtocolHeadLogger> .Instance.Info;
object[] objArray = new object[] { this._accountName, this._containerName, this._blobName, this._contentLength };
info.Log("Commited Blocks for: {0}/{1}/{2}, Length:{3}", objArray);
break;
}
catch (SqlException sqlException)
{
if (this.ShouldRethrowException(i, sqlException, out flag1))
{
throw;
}
}
}
return(true);
}
catch (Exception exception1)
{
Exception exception = exception1;
Logger <IRestProtocolHeadLogger> .Instance.Error.Log("CopyBlob: PutBlockList exception {0}", new object[] { exception });
this.SetCopyFailed(exception, flag1, null);
flag = false;
}
return(flag);
}
private IEnumerator <IAsyncResult> ChangeLeaseImpl(Guid leaseId, Guid proposedLeaseId, IContainerCondition condition, bool updateLastModificationTime, AsyncIteratorContext <NoResults> context)
{
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute((TimeSpan param0) => {
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
Microsoft.WindowsAzure.DevelopmentStorage.Store.BlobContainer nullable = this.LoadBlobContainer(dbContext);
DbBlobContainer.CheckBlobContainerConditionWithoutLeaseCondition(nullable, condition);
DateTime utcNow = DateTime.UtcNow;
ContainerLeaseInfo containerLeaseInfo = new ContainerLeaseInfo(nullable, utcNow);
switch (containerLeaseInfo.State.Value)
{
case LeaseState.Available:
{
throw new LeaseNotPresentException();
}
case LeaseState.Leased:
{
if (!(leaseId != containerLeaseInfo.Id.Value) || !(proposedLeaseId != containerLeaseInfo.Id.Value))
{
break;
}
throw new LeaseHeldException();
}
case LeaseState.Expired:
{
throw new LeaseHeldException();
}
case LeaseState.Breaking:
{
if (!containerLeaseInfo.Id.HasValue || !(leaseId != containerLeaseInfo.Id.Value) || !(proposedLeaseId != containerLeaseInfo.Id.Value))
{
throw new LeaseBrokenException();
}
throw new LeaseHeldException();
}
case LeaseState.Broken:
{
throw new LeaseNotPresentException();
}
}
nullable.LeaseId = new Guid?(proposedLeaseId);
nullable.IsLeaseOp = !updateLastModificationTime;
dbContext.SubmitChanges();
containerLeaseInfo.SetBlobContainer(nullable, utcNow);
this._container = nullable;
this.LeaseInfo = containerLeaseInfo;
}
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("DbBlobContainer.ChangeLease"));
yield return(asyncResult);
this.StorageManager.AsyncProcessor.EndExecute(asyncResult);
}
public static void SetCopyStatusToFailedAfterRestart()
{
while (true)
{
IEnumerable <Blob> blobs = null;
try
{
using (TransactionScope transactionScope = new TransactionScope())
{
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
IQueryable <Blob> blobs1 =
from b in dbContext.Blobs
select b;
blobs = blobs1.Take <Blob>(100);
if (blobs == null || blobs.Count <Blob>() == 0)
{
break;
}
else
{
foreach (Blob blob in blobs)
{
BlobServiceMetaData instance = BlobServiceMetaData.GetInstance(blob.ServiceMetadata);
if (!"pending".Equals(instance.CopyStatus))
{
continue;
}
instance.CopyStatus = "failed";
instance.CopyStatusDescription = "500 InternalError \"Reset to failed during restart.\"";
Blob blob1 = DbBlobObject.ClearBlob(blob, instance.GetMetadata());
dbContext.Blobs.DeleteOnSubmit(blob);
dbContext.SubmitChanges();
using (DevelopmentStorageDbDataContext developmentStorageDbDataContext = DevelopmentStorageDbDataContext.GetDbContext())
{
developmentStorageDbDataContext.Blobs.InsertOnSubmit(blob1);
developmentStorageDbDataContext.SubmitChanges();
}
}
}
}
transactionScope.Complete();
}
}
catch (Exception exception1)
{
Exception exception = exception1;
Logger <IRestProtocolHeadLogger> .Instance.Error.Log("SetCopyStatusToFailedAfterRestart: Failed to change copy status! Exception {0}", new object[] { exception });
}
}
}
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> GetPropertiesImpl(ContainerPropertyNames propertyNames, IContainerCondition condition, AsyncIteratorContext <NoResults> context)
{
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute((TimeSpan param0) => {
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
Microsoft.WindowsAzure.DevelopmentStorage.Store.BlobContainer blobContainer = this.LoadBlobContainer(dbContext);
ContainerLeaseInfo containerLeaseInfo = new ContainerLeaseInfo(blobContainer, DateTime.UtcNow);
DbBlobContainer.CheckBlobContainerCondition(blobContainer, condition, containerLeaseInfo);
this._container = blobContainer;
this.LeaseInfo = containerLeaseInfo;
}
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("DbBlobContainer.GetProperties"));
yield return(asyncResult);
this.StorageManager.AsyncProcessor.EndExecute(asyncResult);
}
private IEnumerator <IAsyncResult> PutMessageImpl(List <PushedMessage> messagesList, bool usePutMessageRowCommand, AsyncIteratorContext <List <IMessageData> > context)
{
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute <List <IMessageData> >((TimeSpan remaining) => {
List <IMessageData> messageDatas;
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
DateTime utcNow = DateTime.UtcNow;
this.LoadQueueContainer(dbContext);
List <QueueMessage> queueMessages = new List <QueueMessage>();
List <IMessageData> messageDatas1 = new List <IMessageData>();
object obj = messagesList;
if (obj == null)
{
obj = Enumerable.Empty <PushedMessage>();
}
foreach (PushedMessage pushedMessage in (IEnumerable <PushedMessage>)obj)
{
QueueMessage queueMessage = new QueueMessage()
{
AccountName = this._queue.AccountName,
QueueName = this._queue.QueueName,
VisibilityStartTime = utcNow.Add(pushedMessage.VisibilityTimeout),
MessageId = Guid.NewGuid()
};
QueueMessage queueMessage1 = queueMessage;
TimeSpan?messageTTL = pushedMessage.MessageTTL;
queueMessage1.ExpiryTime = utcNow.Add((messageTTL.HasValue ? messageTTL.GetValueOrDefault() : new TimeSpan((long)0)));
queueMessage.InsertionTime = utcNow;
queueMessage.DequeueCount = 0;
queueMessage.Data = pushedMessage.MessageText;
QueueMessage queueMessage2 = queueMessage;
queueMessages.Add(queueMessage2);
messageDatas1.Add(new DbMessageData(queueMessage2, false));
}
dbContext.QueueMessages.InsertAllOnSubmit <QueueMessage>(queueMessages);
dbContext.SubmitChanges();
messageDatas = messageDatas1;
}
return(messageDatas);
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("DbQueueContainer.PutMessage"));
yield return(asyncResult);
context.ResultData = this.StorageManager.AsyncProcessor.EndExecute <List <IMessageData> >(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);
}
public void SetCopyCompleted()
{
for (int i = 0; i < this._maxNumberOfRetries; i++)
{
try
{
using (TransactionScope transactionScope = new TransactionScope())
{
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
this.GetContainer(dbContext);
Blob blob = this.GetBlob(dbContext, false);
BlobServiceMetaData instance = BlobServiceMetaData.GetInstance(blob.ServiceMetadata);
if (!string.Equals(this._copyId, instance.CopyId, StringComparison.OrdinalIgnoreCase))
{
Logger <IRestProtocolHeadLogger> .Instance.Info.Log("CopyBlob: SetCopyCompleted not updating status as the copyId has changed.");
}
else
{
instance.CopyStatus = "success";
instance.CopyProgressOffset = this._contentLength.ToString();
instance.CopyProgressTotal = this._contentLength.ToString();
instance.CopyCompletionTime = new long?(DateTime.UtcNow.ToFileTimeUtc());
blob.ServiceMetadata = instance.GetMetadata();
dbContext.SubmitChanges();
transactionScope.Complete();
}
}
}
break;
}
catch (Exception exception1)
{
Exception exception = exception1;
if (i != this._maxNumberOfRetries - 1)
{
IStringDataEventStream critical = Logger <IRestProtocolHeadLogger> .Instance.Critical;
object[] objArray = new object[] { exception, i + 1 };
critical.Log("Could not set copyStatus of blob. Exception {0}!Retrying attempt {1}...", objArray);
}
}
}
}
public DbTableDataContext(IAccountIdentifier accountIdentifier, string resourceOwner)
{
if (accountIdentifier == null || string.IsNullOrEmpty(accountIdentifier.AccountName))
{
throw new DataServiceException(404, "Resource not found.");
}
if (string.IsNullOrEmpty(resourceOwner))
{
throw new DataServiceException(404, "Resource not found.");
}
if (!string.Equals(resourceOwner, accountIdentifier.AccountName, StringComparison.OrdinalIgnoreCase) && !accountIdentifier.IsAdmin)
{
throw new UnauthorizedAccessException();
}
this.m_dbContext = DevelopmentStorageDbDataContext.GetDbContext();
this.AccountName = accountIdentifier.AccountName;
this.AccountIdentifier = accountIdentifier;
this.SignedAccountIdentifier = accountIdentifier as TableSignedAccessAccountIdentifier;
}
private void SaveEntityChanges()
{
this.FailedCommandIndex = -1;
for (int i = 0; i < 5; i++)
{
this.changeDescriptionMap = new Dictionary <string, ChangeDescription>();
this.m_dbContext.Dispose();
this.FailedCommandIndex = -1;
try
{
using (TransactionScope transactionScope = new TransactionScope(TransactionScopeOption.RequiresNew))
{
this.m_dbContext = DevelopmentStorageDbDataContext.GetDbContext();
foreach (ChangeDescription changeDescription in this.changeDescriptionList)
{
this.ProcessChange(changeDescription);
}
this.m_dbContext.SubmitChanges();
transactionScope.Complete();
}
break;
}
catch (SqlException sqlException)
{
if (sqlException.Number != 1205)
{
throw;
}
if (i + 1 == 5)
{
throw;
}
Thread.Sleep(TimeSpan.FromMilliseconds(500));
this.FailedCommandIndex = -1;
}
}
foreach (ChangeDescription changeDescription1 in this.changeDescriptionList)
{
this.SetValuesInResponseIfRequired(changeDescription1);
}
}
private IEnumerator <IAsyncResult> GetBlobImpl(IBlobRegion blobRegion, BlobPropertyNames propertyNames, IBlobObjectCondition condition, AsyncIteratorContext <CrcStream> context)
{
IAsyncResult asyncResult = this._storageManager.AsyncProcessor.BeginExecute <CrcStream>((TimeSpan param0) => {
CrcStream streamFromByteArray;
using (TransactionScope transactionScope = new TransactionScope())
{
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
base.LoadContainer(dbContext);
BlockBlob blockBlob = base.LoadBlockBlob(dbContext);
if (blobRegion == null)
{
blobRegion = new BlobRegion((long)0, blockBlob.ContentLength);
}
else if (blobRegion.Offset > blockBlob.ContentLength || blobRegion.Offset == blockBlob.ContentLength && blockBlob.ContentLength > (long)0)
{
throw new InvalidBlobRegionException(new long?(blobRegion.Offset), "Offset value is greater than the contentlength");
}
BlobLeaseInfo blobLeaseInfo = new BlobLeaseInfo(blockBlob, DateTime.UtcNow);
DbBlobObject.CheckConditionsAndReturnResetRequired(blockBlob, blobLeaseInfo, condition, null, false);
long offset = blobRegion.Offset;
long num = Math.Min(offset + blobRegion.Length, blockBlob.ContentLength);
IOrderedQueryable <CommittedBlock> committedBlocks =
from b in dbContext.CommittedBlocks
where (b.AccountName == this._blob.AccountName) && (b.ContainerName == this._blob.ContainerName) && (b.BlobName == this._blob.BlobName) && (b.VersionTimestamp == this._blob.VersionTimestamp) && (long?)b.Offset + b.Length >= (long?)offset && b.Offset < num
orderby b.Offset
select b;
byte[] bytesFromCommittedBlocks = this.GetBytesFromCommittedBlocks(dbContext, offset, num, committedBlocks);
transactionScope.Complete();
this._blob = blockBlob;
this.LeaseInfo = blobLeaseInfo;
streamFromByteArray = DbStorageHelper.GetStreamFromByteArray(bytesFromCommittedBlocks);
}
}
return(streamFromByteArray);
}, base.Timeout, context.GetResumeCallback(), context.GetResumeState("DbListBlobObject.GetBlob"));
yield return(asyncResult);
context.ResultData = this._storageManager.AsyncProcessor.EndExecute <CrcStream>(asyncResult);
}
private IEnumerator <IAsyncResult> ListBlobsImpl(string blobNamePrefix, BlobPropertyNames propertyNames, string separator, string blobNameStart, DateTime?snapshotStart, IBlobObjectCondition condition, int maxBlobNames, BlobServiceVersion version, AsyncIteratorContext <IBlobObjectCollection> context)
{
IStringDataEventStream verboseDebug = Logger <INormalAndDebugLogger> .Instance.VerboseDebug;
object[] objArray = new object[] { blobNamePrefix, propertyNames, separator, blobNameStart, snapshotStart, condition, maxBlobNames, this.Timeout };
verboseDebug.Log("ListBlobsImpl({0},{1},{2},{3},{4},{5},{6},{7})", objArray);
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute <DbBlobObjectCollection>((TimeSpan param0) => {
DbBlobObjectCollection dbBlobObjectCollections;
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
this.LoadBlobContainer(dbContext);
IQueryable <Blob> blobs = this.MakeListBlobsQuery(blobNamePrefix, blobNameStart, snapshotStart, separator, condition, maxBlobNames, dbContext);
dbBlobObjectCollections = this.ReadListBlobsResult(blobNamePrefix, separator, maxBlobNames, blobs);
}
return(dbBlobObjectCollections);
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("DbBlobContainer.ListBlobs"));
yield return(asyncResult);
context.ResultData = this.StorageManager.AsyncProcessor.EndExecute <DbBlobObjectCollection>(asyncResult);
}
private IEnumerator <IAsyncResult> CreateContainerImpl(DateTime?expiryTime, byte[] serviceMetadata, byte[] applicationMetadata, AsyncIteratorContext <NoResults> context)
{
IStringDataEventStream verboseDebug = Logger <INormalAndDebugLogger> .Instance.VerboseDebug;
object[] objArray = new object[] { expiryTime, serviceMetadata, applicationMetadata, this.Timeout };
verboseDebug.Log("CreateContainerImpl({0},{1},{2},{3})", objArray);
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute((TimeSpan param0) => {
StorageStampHelpers.CheckContainerName(this._container.ContainerName, Microsoft.Cis.Services.Nephos.Common.Storage.ContainerType.BlobContainer, false);
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
this._container.ServiceMetadata = serviceMetadata;
this._container.Metadata = applicationMetadata;
dbContext.BlobContainers.InsertOnSubmit(this._container);
dbContext.SubmitChanges();
}
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("DbBlobContainer.CreateContainerImpl"));
yield return(asyncResult);
this.StorageManager.AsyncProcessor.EndExecute(asyncResult);
}
private IEnumerator <IAsyncResult> ListQueueContainersImpl(string containerNamePrefix, ContainerPropertyNames propertyNames, string separator, string containerNameStart, IContainerCondition condition, int maxQueueNames, AsyncIteratorContext <IQueueContainerCollection> context)
{
IStringDataEventStream verboseDebug = Logger <INormalAndDebugLogger> .Instance.VerboseDebug;
object[] objArray = new object[] { containerNamePrefix, propertyNames, separator, containerNameStart, condition, maxQueueNames, this.Timeout };
verboseDebug.Log("ListQueueContainersImpl({0},{1},{2},{3},{4},{5},{6})", objArray);
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute <DbQueueContainerCollection>((TimeSpan param0) => {
DbQueueContainerCollection dbQueueContainerCollections;
StorageStampHelpers.ValidateMaxContainers(maxQueueNames);
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
IQueryable <Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer> queueContainers = this.MakeListQueueContainersQuery(containerNamePrefix, separator, containerNameStart, condition, maxQueueNames, dbContext);
dbQueueContainerCollections = this.ReadListQueueContainersResult(containerNamePrefix, separator, maxQueueNames, queueContainers);
}
return(dbQueueContainerCollections);
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("StorageStamp.ListQueueContainersImpl"));
yield return(asyncResult);
context.ResultData = this.StorageManager.AsyncProcessor.EndExecute <DbQueueContainerCollection>(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> ListBlobContainersImpl(string containerNamePrefix, ContainerPropertyNames propertyNames, string separator, string containerKeyStart, IContainerCondition condition, int maxContainerNames, AsyncIteratorContext <IBlobContainerCollection> context)
{
IStringDataEventStream verboseDebug = Logger <INormalAndDebugLogger> .Instance.VerboseDebug;
object[] objArray = new object[] { containerNamePrefix, propertyNames, separator, containerKeyStart, condition, maxContainerNames, this.Timeout };
verboseDebug.Log("ListBlobContainersImpl({0},{1},{2},{3},{4},{5},{6})", objArray);
string str = null;
if (containerKeyStart != null)
{
string[] strArrays = containerKeyStart.Split(new char[] { '/' });
if ((int)strArrays.Length != 3)
{
throw new ArgumentOutOfRangeException("containerKeyStart", "The marker is not well formed.");
}
string str1 = strArrays[1];
str = strArrays[2];
if (str1 != this.Name)
{
throw new ArgumentException(string.Format("Account name '{0}' specified in the container key start does not match the account being listed '{1}'", str1, this.Name), "containerKeyStart");
}
}
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute <DbBlobContainerCollection>((TimeSpan param0) => {
DbBlobContainerCollection dbBlobContainerCollections;
StorageStampHelpers.ValidateMaxContainers(maxContainerNames);
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
IQueryable <Microsoft.WindowsAzure.DevelopmentStorage.Store.BlobContainer> blobContainers = this.MakeListBlobContainersQuery(containerNamePrefix, separator, str, condition, maxContainerNames, dbContext);
dbBlobContainerCollections = this.ReadListBlobContainersResult(containerNamePrefix, separator, maxContainerNames, blobContainers);
}
return(dbBlobContainerCollections);
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("StorageStamp.ListBlobContainersImpl"));
yield return(asyncResult);
context.ResultData = this.StorageManager.AsyncProcessor.EndExecute <DbBlobContainerCollection>(asyncResult);
}
public static void CreateDatabase(bool force)
{
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
bool flag = dbContext.DatabaseExists();
if (flag)
{
if (force)
{
dbContext.DeleteDatabase();
}
else
{
return;
}
}
try
{
dbContext.CreateDatabase();
}
catch (SqlException sqlException)
{
if (flag)
{
throw;
}
dbContext.DetachDatabase();
dbContext.CreateDatabase();
}
DevelopmentStorageDbDataContext.ExecuteCommands(dbContext, Resources.ForeignKeys);
DevelopmentStorageDbDataContext.ExecuteCommands(dbContext, Resources.LastModificationTimeTriggers);
DevelopmentStorageDbDataContext.ExecuteCommands(dbContext, Resources.BlobSummary);
DevelopmentStorageDbDataContext.ExecuteCommands(dbContext, Resources.CommitBlockList);
DevelopmentStorageDbDataContext.ExecuteCommands(dbContext, Resources.QueueFunctions);
DevelopmentStorageDbDataContext.ExecuteCommands(dbContext, Resources.PageBlob);
}
}
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> DeleteContainerImpl(IContainerCondition conditions, Guid?leaseId, AsyncIteratorContext <NoResults> context)
{
object obj;
IStringDataEventStream verboseDebug = Logger <INormalAndDebugLogger> .Instance.VerboseDebug;
object[] timeout = new object[2];
object[] objArray = timeout;
obj = (leaseId.HasValue ? leaseId.Value.ToString() : "NULL");
objArray[0] = obj;
timeout[1] = this.Timeout;
verboseDebug.Log("DeleteContainerImpl({0},{1})", timeout);
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute((TimeSpan param0) => {
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
Microsoft.WindowsAzure.DevelopmentStorage.Store.BlobContainer blobContainer = this.LoadBlobContainer(dbContext);
ContainerLeaseInfo containerLeaseInfo = new ContainerLeaseInfo(blobContainer, DateTime.UtcNow);
DbBlobContainer.CheckBlobContainerCondition(blobContainer, conditions, containerLeaseInfo);
LeaseState?state = containerLeaseInfo.State;
LeaseState valueOrDefault = state.GetValueOrDefault();
if (state.HasValue)
{
switch (valueOrDefault)
{
case LeaseState.Available:
case LeaseState.Broken:
{
if (!leaseId.HasValue)
{
break;
}
if (!containerLeaseInfo.Id.HasValue)
{
throw new LeaseNotPresentException();
}
throw new LeaseLostException();
}
case LeaseState.Leased:
case LeaseState.Breaking:
{
if (leaseId.HasValue && !(leaseId.Value != containerLeaseInfo.Id.Value))
{
break;
}
throw new LeaseHeldException();
}
case LeaseState.Expired:
{
if (!leaseId.HasValue)
{
break;
}
throw new LeaseLostException();
}
}
}
dbContext.BlobContainers.DeleteOnSubmit(blobContainer);
dbContext.SubmitChanges();
}
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("DbBlobContainer.DeleteContainerImpl"));
yield return(asyncResult);
this.StorageManager.AsyncProcessor.EndExecute(asyncResult);
}
