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 void OnLoaded() { DevelopmentStorageDbDataContext.AdjustSqlDateTime(ref this._LastModificationTime); DevelopmentStorageDbDataContext.AdjustSqlDateTime(ref this._CreationTime); this._VersionTimestamp = DateTime.SpecifyKind(this._VersionTimestamp, DateTimeKind.Utc); DevelopmentStorageDbDataContext.AdjustSqlDateTime(ref this._LeaseEndTime); }
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 TableRow GetSqlEntity(string partitionKey, string rowKey, DateTime?timeStamp) { string str = partitionKey; string str1 = rowKey; TableRow tableRow = null; str = DevelopmentStorageDbDataContext.EncodeKeyString(str); str1 = DevelopmentStorageDbDataContext.EncodeKeyString(str1); if (!timeStamp.HasValue || !timeStamp.HasValue) { tableRow = ( from r in this.m_dbContext.TableRows where (r.AccountName == this.AccountName) && (r.TableName == this.m_currentResourceContainer.Name.ToLowerInvariant()) && (r.PartitionKey == str) && (r.RowKey == str1) select r).FirstOrDefault <TableRow>(); } else { DateTime sql2005DateTime = DevelopmentStorageDbDataContext.GetSql2005DateTime(timeStamp.Value); tableRow = ( from r in this.m_dbContext.TableRows where (r.AccountName == this.AccountName) && (r.TableName == this.m_currentResourceContainer.Name.ToLowerInvariant()) && (r.PartitionKey == str) && (r.RowKey == str1) && (r.Timestamp == sql2005DateTime) select r).FirstOrDefault <TableRow>(); } return(tableRow); }
public static IEnumerator <T> GetProjectedWrapperTypedEnumerator <T>(IEnumerator <TableRow> enumerator, int propertyCount, string propertyListName, string resourceTypeName, string[] projectedProperties) where T : ProjectedWrapper { List <T> ts = new List <T>(); while (enumerator.MoveNext()) { TableRow current = enumerator.Current; Dictionary <string, object> strs = new Dictionary <string, object>(); strs["PartitionKey"] = DevelopmentStorageDbDataContext.DecodeKeyString(current.PartitionKey); strs["RowKey"] = DevelopmentStorageDbDataContext.DecodeKeyString(current.RowKey); strs["Timestamp"] = current.Timestamp; XmlUtility.AddObjectsToDictionaryFromXml(current.Data, strs, true); object[] objArray = new object[propertyCount]; for (int i = 0; i < propertyCount; i++) { if (!strs.TryGetValue(projectedProperties[i], out objArray[i])) { objArray[i] = null; } } ProjectedWrapperCreator projectedWrapperCreator = ProjectedWrapperCreator.GetProjectedWrapperCreator(propertyCount); ts.Add((T)projectedWrapperCreator.CreateProjectedWrapper(objArray, propertyListName, resourceTypeName)); } return(ts.GetEnumerator()); }
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> 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); }
private byte[] GetBytesFromCommittedBlocks(DevelopmentStorageDbDataContext dataContext, long start, long end, IOrderedQueryable <CommittedBlock> committedBlocks) { byte[] numArray = new byte[checked ((IntPtr)(end - start))]; long num = (long)0; long num1 = start; foreach (CommittedBlock committedBlock in committedBlocks) { BlockData blockDatum = ( from b in dataContext.BlocksData where (b.AccountName == this._blob.AccountName) && (b.ContainerName == this._blob.ContainerName) && (b.BlobName == this._blob.BlobName) && ((DateTime?)b.VersionTimestamp == committedBlock.BlockVersion) && b.IsCommitted && (b.BlockId == committedBlock.BlockId) select b).First <BlockData>(); byte[] numArray1 = null; using (FileStream fileStream = new FileStream(blockDatum.FilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { fileStream.Seek(blockDatum.StartOffset.Value, SeekOrigin.Begin); numArray1 = new byte[checked ((IntPtr)blockDatum.Length.Value)]; fileStream.Read(numArray1, 0, (int)numArray1.Length); } long num2 = (committedBlock.Offset < start ? start - committedBlock.Offset : (long)0); long?length = committedBlock.Length; long num3 = Math.Min(length.Value - num2, end - num1); Buffer.BlockCopy(numArray1, (int)num2, numArray, (int)num, (int)num3); num1 += num3; num += num3; } return(numArray); }
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> 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> 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); }
public static void AdjustSqlDateTime(ref DateTime?value) { if (!value.HasValue) { return; } value = new DateTime?(DevelopmentStorageDbDataContext.FromSql2005DateTime2(value.Value)); }
private BlockData TryLoadUncommittedBlock(DevelopmentStorageDbDataContext context, string blockId) { BlockData blockDatum = ( from b in context.BlocksData where (b.AccountName == this._blob.AccountName) && (b.ContainerName == this._blob.ContainerName) && (b.BlobName == this._blob.BlobName) && (b.VersionTimestamp == this._blob.VersionTimestamp) && !b.IsCommitted && (b.BlockId == blockId) select b).FirstOrDefault <BlockData>(); return(blockDatum); }
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); }
public static DevelopmentStorageDbDataContext GetDbContext() { DevelopmentStorageDbDataContext developmentStorageDbDataContext = new DevelopmentStorageDbDataContext(DevelopmentStorageDbDataContext.GetConnectionString()) { Log = DevelopmentStorageDbDataContext.LinqToSqlLogStream }; return(developmentStorageDbDataContext); }
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); }
private static void ExecuteCommands(DevelopmentStorageDbDataContext context, string fileText) { string[] strArrays = DevelopmentStorageDbDataContext.s_goRegex.Split(fileText); for (int i = 0; i < (int)strArrays.Length; i++) { string str = strArrays[i]; context.ExecuteCommand(str, new object[0]); } }
internal static object GetValueFromXml(string sqlType, string val) { string str = sqlType; string str1 = str; if (str != null) { switch (str1) { case "int": { return(XmlConvert.ToInt32(val)); } case "bigint": { return(XmlConvert.ToInt64(val)); } case "datetime": { return(DevelopmentStorageDbDataContext.CheckSqlBoundsAndReturnAptDate(XmlConvert.ToDateTime(val, XmlDateTimeSerializationMode.Utc))); } case "uniqueidentifier": { return(XmlConvert.ToGuid(val)); } case "float(53)": { return(XmlConvert.ToDouble(val)); } case "bit": { return(XmlConvert.ToBoolean(val)); } case "varbinary(max)": { return(Convert.FromBase64String(val)); } case "nvarchar(max)": { return(DevelopmentStorageDbDataContext.DecodeDataString(val)); } } } throw new ArgumentException(); }
private TableRow CreateAndPopulateSqlEntity(UtilityRow utilRow) { TableRow tableRow = new TableRow() { AccountName = this.AccountName, TableName = this.m_currentResourceContainer.Name.ToLowerInvariant(), PartitionKey = DevelopmentStorageDbDataContext.EncodeKeyString(utilRow.PartitionKey), RowKey = DevelopmentStorageDbDataContext.EncodeKeyString(utilRow.RowKey), Data = XmlUtility.GetXmlFromUtilityRow(utilRow) }; return(tableRow); }
private GeoReplicationStats LoadGeoReplicationStats(DevelopmentStorageDbDataContext dbContext) { DateTime dbUTCDate = dbContext.GetDbUTCDate(); DevelopmentStorageDbDataContext.AdjustSqlDateTime(ref dbUTCDate); GeoReplicationStats geoReplicationStat = new GeoReplicationStats() { LastSyncTime = new DateTime?(dbUTCDate), Status = new GeoReplicationStatus?(GeoReplicationStatus.Live) }; return(geoReplicationStat); }
private Account LoadAccount(DevelopmentStorageDbDataContext dataContext) { Account account = ( from a in dataContext.Accounts where a.Name == this._account.Name select a).FirstOrDefault <Account>(); if (account == null) { throw new AccountNotFoundException(); } return(account); }
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> 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 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 Blob GetBlob(DevelopmentStorageDbDataContext context, bool shouldCheckLMT) { Blob blob = ( from b in context.Blobs where (b.AccountName == this._accountName) && (b.ContainerName == this._containerName) && (b.BlobName == this._blobName) && (b.VersionTimestamp == this._versionTimeStamp) select b).FirstOrDefault <Blob>(); if (blob == null) { throw new BlobNotFoundException(); } if (shouldCheckLMT && blob.LastModificationTime.HasValue && this._lastModifiedTime.HasValue && blob.LastModificationTime.Value.ToString("u") != this._lastModifiedTime.Value.ToString("u")) { throw new ConditionNotMetException(); } return(blob); }
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); }