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