public static TableOperation Retrieve <TElement>(string partitionKey, string rowkey, List <string> selectColumns = null)
where TElement : ITableEntity
{
CommonUtility.AssertNotNull("partitionKey", partitionKey);
CommonUtility.AssertNotNull("rowkey", rowkey);
// Create and return the table operation.
return(new TableOperation(null /* entity */, TableOperationType.Retrieve)
{
RetrievePartitionKey = partitionKey,
RetrieveRowKey = rowkey,
SelectColumns = selectColumns,
RetrieveResolver =
(pk, rk, ts, prop, etag) => EntityUtilities.ResolveEntityByType <TElement>(
pk,
rk,
ts,
prop,
etag),
PropertyResolverType = typeof(TElement)
});
}
/// <summary>
/// Generates a <see cref="RESTCommand{T}"/> for releasing a lease.
/// </summary>
/// <param name="blob">The blob.</param>
/// <param name="attributes">The attributes.</param>
/// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed. If <c>null</c>, no condition is used.</param>
/// <param name="options">A <see cref="BlobRequestOptions"/> object that specifies additional options for the request.</param>
/// <returns>
/// A <see cref="RESTCommand{T}"/> implementing the release lease operation.
/// </returns>
/// <exception cref="System.ArgumentException">accessCondition</exception>
internal static RESTCommand <NullType> ReleaseLeaseImpl(ICloudBlob blob, BlobAttributes attributes, AccessCondition accessCondition, BlobRequestOptions options)
{
CommonUtility.AssertNotNull("accessCondition", accessCondition);
if (accessCondition.LeaseId == null)
{
throw new ArgumentException(SR.MissingLeaseIDReleasing, "accessCondition");
}
RESTCommand <NullType> putCmd = new RESTCommand <NullType>(blob.ServiceClient.Credentials, attributes.StorageUri);
options.ApplyToStorageCommand(putCmd);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, useVersionHeader, ctx) => BlobHttpWebRequestFactory.Lease(uri, serverTimeout, LeaseAction.Release, null /* proposedLeaseId */, null /* leaseDuration */, null /* leaseBreakPeriod */, accessCondition, useVersionHeader, ctx);
putCmd.SignRequest = blob.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, NullType.Value, cmd, ex);
CloudBlobSharedImpl.UpdateETagLMTLengthAndSequenceNumber(attributes, resp, false);
return(NullType.Value);
};
return(putCmd);
}
/// <summary>
/// Generates XML representing the given delete retention policy.
/// </summary>
/// <param name="deleteRetentionPolicy">The DeleteRetentionPolicy properties.</param>
/// <returns>An XML logging element.</returns>
private static XElement GenerateDeleteRetentionPolicyXml(DeleteRetentionPolicy deleteRetentionPolicy)
{
CommonUtility.AssertNotNull("deleteRetentionPolicy", deleteRetentionPolicy);
bool enabled = deleteRetentionPolicy.Enabled;
XElement xml = new XElement(DeleteRetentionPolicyName, new XElement(EnabledName, enabled));
if (!enabled)
{
return(xml);
}
if (!deleteRetentionPolicy.RetentionDays.HasValue || deleteRetentionPolicy.RetentionDays.Value < 1 ||
deleteRetentionPolicy.RetentionDays > Constants.MaximumAllowedRetentionDays)
{
throw new ArgumentException(SR.InvalidDeleteRetentionDaysValue);
}
xml.Add(new XElement(DaysName, (int)deleteRetentionPolicy.RetentionDays));
return(xml);
}
/// <summary>
/// Constructs a <see cref="SharedAccessTablePermissions"/> object from a permissions string.
/// </summary>
/// <param name="input">The shared access permissions in string format.</param>
/// <returns>A set of shared access permissions.</returns>
public static SharedAccessTablePermissions PermissionsFromString(string input)
{
CommonUtility.AssertNotNull("input", input);
SharedAccessTablePermissions permissions = 0;
foreach (char c in input)
{
switch (c)
{
case 'r':
permissions |= SharedAccessTablePermissions.Query;
break;
case 'a':
permissions |= SharedAccessTablePermissions.Add;
break;
case 'u':
permissions |= SharedAccessTablePermissions.Update;
break;
case 'd':
permissions |= SharedAccessTablePermissions.Delete;
break;
default:
throw new ArgumentOutOfRangeException("input");
}
}
// Incase we ever change none to be something other than 0
if (permissions == 0)
{
permissions |= SharedAccessTablePermissions.None;
}
return(permissions);
}
/// <summary>
/// Gets the container's properties from the response.
/// </summary>
/// <param name="response">The web response.</param>
/// <returns>The container's attributes.</returns>
public static BlobContainerProperties GetProperties(HttpWebResponse response)
{
CommonUtility.AssertNotNull("response", response);
// Set the container properties
BlobContainerProperties containerProperties = new BlobContainerProperties();
containerProperties.ETag = HttpResponseParsers.GetETag(response);
#if WINDOWS_PHONE
containerProperties.LastModified = HttpResponseParsers.GetLastModified(response);
#else
containerProperties.LastModified = response.LastModified.ToUniversalTime();
#endif
// Get lease properties
containerProperties.LeaseStatus = BlobHttpResponseParsers.GetLeaseStatus(response);
containerProperties.LeaseState = BlobHttpResponseParsers.GetLeaseState(response);
containerProperties.LeaseDuration = BlobHttpResponseParsers.GetLeaseDuration(response);
return(containerProperties);
}
/// <summary>
/// Extracts a <see cref="CopyState"/> object from the headers of a web response.
/// </summary>
/// <param name="response">The HTTP web response.</param>
/// <returns>A <see cref="CopyState"/> object, or null if the web response does not contain a copy status.</returns>
public static CopyState GetCopyAttributes(HttpResponseMessage response)
{
CommonUtility.AssertNotNull("response", response);
string copyStatusString = response.Headers.GetHeaderSingleValueOrDefault(Constants.HeaderConstants.CopyStatusHeader);
if (!string.IsNullOrEmpty(copyStatusString))
{
return(GetCopyAttributes(
copyStatusString,
response.Headers.GetHeaderSingleValueOrDefault(Constants.HeaderConstants.CopyIdHeader),
response.Headers.GetHeaderSingleValueOrDefault(Constants.HeaderConstants.CopySourceHeader),
response.Headers.GetHeaderSingleValueOrDefault(Constants.HeaderConstants.CopyProgressHeader),
response.Headers.GetHeaderSingleValueOrDefault(Constants.HeaderConstants.CopyCompletionTimeHeader),
response.Headers.GetHeaderSingleValueOrDefault(Constants.HeaderConstants.CopyDescriptionHeader),
response.Headers.GetHeaderSingleValueOrDefault(Constants.HeaderConstants.CopyDestinationSnapshotHeader)));
}
else
{
return(null);
}
}
/// <summary>
/// Generates a <see cref="RESTCommand{T}" /> for changing a lease ID.
/// </summary>
/// <param name="blob">The blob.</param>
/// <param name="attributes">The attributes.</param>
/// <param name="proposedLeaseId">The proposed new lease ID.</param>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies additional options for the request.</param>
/// <returns>
/// A <see cref="RESTCommand{T}" /> implementing the change lease ID operation.
/// </returns>
/// <exception cref="System.ArgumentException">accessCondition</exception>
internal static RESTCommand <string> ChangeLeaseImpl(ICloudBlob blob, BlobAttributes attributes, string proposedLeaseId, AccessCondition accessCondition, BlobRequestOptions options)
{
CommonUtility.AssertNotNull("accessCondition", accessCondition);
CommonUtility.AssertNotNull("proposedLeaseId", proposedLeaseId);
if (accessCondition.LeaseId == null)
{
throw new ArgumentException(SR.MissingLeaseIDChanging, "accessCondition");
}
RESTCommand <string> putCmd = new RESTCommand <string>(blob.ServiceClient.Credentials, attributes.Uri);
putCmd.ApplyRequestOptions(options);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => BlobHttpWebRequestFactory.Lease(uri, serverTimeout, LeaseAction.Change, proposedLeaseId, null /* leaseDuration */, null /* leaseBreakPeriod */, accessCondition, ctx);
putCmd.SignRequest = blob.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex);
return(BlobHttpResponseParsers.GetLeaseId(resp));
};
return(putCmd);
}
/// <summary>
/// Initializes a new instance of the <see cref="BlobProperties"/> class based on an existing instance.
/// </summary>
/// <param name="other">A <see cref="BlobProperties"/> object.</param>
/// <remarks>Lease-related properties will not be cloned, because a lease associated with the base blob is not copied to the snapshot.</remarks>
public BlobProperties(BlobProperties other)
{
CommonUtility.AssertNotNull("other", other);
this.BlobType = other.BlobType;
this.ContentType = other.ContentType;
this.ContentDisposition = other.ContentDisposition;
this.ContentEncoding = other.ContentEncoding;
this.ContentLanguage = other.ContentLanguage;
this.CacheControl = other.CacheControl;
this.ContentMD5 = other.ContentMD5;
this.Length = other.Length;
this.ETag = other.ETag;
this.LastModified = other.LastModified;
this.PageBlobSequenceNumber = other.PageBlobSequenceNumber;
this.AppendBlobCommittedBlockCount = other.AppendBlobCommittedBlockCount;
this.IsServerEncrypted = other.IsServerEncrypted;
this.IsIncrementalCopy = other.IsIncrementalCopy;
this.PremiumPageBlobTier = other.PremiumPageBlobTier;
this.StandardBlobTier = other.StandardBlobTier;
this.RehydrationStatus = other.RehydrationStatus;
}
/// <summary>
/// Constructs a web request to set system properties for a file.
/// </summary>
/// <param name="uri">The absolute URI to the file.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The file's properties.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static StorageRequestMessage SetProperties(Uri uri, int?timeout, FileProperties properties, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials)
{
CommonUtility.AssertNotNull("properties", properties);
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "properties");
StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials);
if (properties != null)
{
request.AddOptionalHeader(Constants.HeaderConstants.FileCacheControlHeader, properties.CacheControl);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentDispositionRequestHeader, properties.ContentDisposition);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentEncodingHeader, properties.ContentEncoding);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentLanguageHeader, properties.ContentLanguage);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentMD5Header, properties.ContentMD5);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentTypeHeader, properties.ContentType);
}
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Get the complete query builder for creating the Shared Access Signature query.
/// </summary>
/// <param name="policy">The shared access policy to hash.</param>
/// <param name="tableName">The name of the table associated with this shared access signature.</param>
/// <param name="accessPolicyIdentifier">An optional identifier for the policy.</param>
/// <param name="startPartitionKey">The start partition key, or null.</param>
/// <param name="startRowKey">The start row key, or null.</param>
/// <param name="endPartitionKey">The end partition key, or null.</param>
/// <param name="endRowKey">The end row key, or null.</param>
/// <param name="signature">The signature to use.</param>
/// <param name="accountKeyName">The name of the key used to create the signature, or null if the key is implicit.</param>
/// <returns>The finished query builder.</returns>
internal static UriQueryBuilder GetSignature(
SharedAccessTablePolicy policy,
string tableName,
string accessPolicyIdentifier,
string startPartitionKey,
string startRowKey,
string endPartitionKey,
string endRowKey,
string signature,
string accountKeyName)
{
CommonUtility.AssertNotNull("signature", signature);
UriQueryBuilder builder = new UriQueryBuilder();
AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedVersion, Constants.HeaderConstants.TargetStorageVersion);
AddEscapedIfNotNull(builder, Constants.QueryConstants.SasTableName, tableName);
AddEscapedIfNotNull(builder, Constants.QueryConstants.StartPartitionKey, startPartitionKey);
AddEscapedIfNotNull(builder, Constants.QueryConstants.StartRowKey, startRowKey);
AddEscapedIfNotNull(builder, Constants.QueryConstants.EndPartitionKey, endPartitionKey);
AddEscapedIfNotNull(builder, Constants.QueryConstants.EndRowKey, endRowKey);
AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedIdentifier, accessPolicyIdentifier);
AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedKey, accountKeyName);
AddEscapedIfNotNull(builder, Constants.QueryConstants.Signature, signature);
if (policy != null)
{
AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedStart, GetDateTimeOrNull(policy.SharedAccessStartTime));
AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedExpiry, GetDateTimeOrNull(policy.SharedAccessExpiryTime));
string permissions = SharedAccessTablePolicy.PermissionsToString(policy.Permissions);
if (!string.IsNullOrEmpty(permissions))
{
AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedPermissions, permissions);
}
}
return(builder);
}
public TableServiceContext(CloudTableClient client)
: base(client.BaseUri)
{
CommonUtility.AssertNotNull("client", client);
if (client.BaseUri == null)
{
throw new ArgumentNullException("client");
}
if (!client.BaseUri.IsAbsoluteUri)
{
string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.RelativeAddressNotPermitted, client.BaseUri.ToString());
throw new ArgumentException(errorMessage, "client");
}
this.SendingRequest += this.TableServiceContext_SendingRequest;
this.IgnoreMissingProperties = true;
this.MergeOption = MergeOption.PreserveChanges;
this.ServiceClient = client;
}
/// <summary>
/// Constructs a web request to set system properties for a file.
/// </summary>
/// <param name="uri">The absolute URI to the file.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The file's properties.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <param name="useVersionHeader">A boolean value indicating whether to set the <i>x-ms-version</i> HTTP header.</param>
/// <param name="operationContext">An <see cref="OperationContext" /> object for tracking the current operation.</param>
/// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
public static HttpWebRequest SetProperties(Uri uri, int?timeout, FileProperties properties, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
{
CommonUtility.AssertNotNull("properties", properties);
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "properties");
HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, builder, useVersionHeader, operationContext);
if (properties != null)
{
request.AddOptionalHeader(Constants.HeaderConstants.FileCacheControlHeader, properties.CacheControl);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentEncodingHeader, properties.ContentEncoding);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentDispositionRequestHeader, properties.ContentDisposition);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentLanguageHeader, properties.ContentLanguage);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentMD5Header, properties.ContentMD5);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentTypeHeader, properties.ContentType);
}
request.ApplyAccessCondition(accessCondition);
return(request);
}
/// <summary>
/// Gets the share's properties from the response.
/// </summary>
/// <param name="response">The web response.</param>
/// <returns>The share's attributes.</returns>
public static FileShareProperties GetProperties(HttpWebResponse response)
{
CommonUtility.AssertNotNull("response", response);
// Set the share properties
FileShareProperties shareProperties = new FileShareProperties();
shareProperties.ETag = HttpResponseParsers.GetETag(response);
#if WINDOWS_PHONE
shareProperties.LastModified = HttpResponseParsers.GetLastModified(response);
#else
shareProperties.LastModified = response.LastModified.ToUniversalTime();
#endif
string quota = response.Headers[Constants.HeaderConstants.ShareQuota];
if (!string.IsNullOrEmpty(quota))
{
shareProperties.Quota = int.Parse(quota, CultureInfo.InvariantCulture);
}
return(shareProperties);
}
/// <summary>
/// Converts the specified HTTP request data into a standard form appropriate for signing.
/// </summary>
/// <param name="request">The HTTP request that needs to be signed.</param>
/// <param name="accountName">The name of the storage account that the HTTP request will access.</param>
/// <returns>The canonicalized string containing the HTTP request data in a standard form appropriate for signing.</returns>
/// <seealso href="http://msdn.microsoft.com/en-us/library/windowsazure/dd179428.aspx">Authentication for the Windows Azure Storage Services</seealso>
public string CanonicalizeHttpRequest(HttpWebRequest request, string accountName)
{
CommonUtility.AssertNotNull("request", request);
// Add the method (GET, POST, PUT, or HEAD).
CanonicalizedString canonicalizedString = new CanonicalizedString(request.Method, ExpectedCanonicalizedStringLength);
// Add the Content-* HTTP headers. Empty values are allowed.
canonicalizedString.AppendCanonicalizedElement(request.Headers[HttpRequestHeader.ContentMd5]);
canonicalizedString.AppendCanonicalizedElement(request.ContentType);
// Add the Date HTTP header (only if the x-ms-date header is not being used)
AuthenticationUtility.AppendCanonicalizedDateHeader(canonicalizedString, request);
// Add any custom headers
AuthenticationUtility.AppendCanonicalizedCustomHeaders(canonicalizedString, request);
// Add the canonicalized URI element
string resourceString = AuthenticationUtility.GetCanonicalizedResourceString(request.RequestUri, accountName, true);
canonicalizedString.AppendCanonicalizedElement(resourceString);
return canonicalizedString.ToString();
}
/// <summary>
/// Return an encrypted base64 encoded message along with encryption related metadata given a plain text message.
/// </summary>
/// <param name="inputMessage">The input message in bytes.</param>
/// <returns>The encrypted message that will be uploaded to the service.</returns>
internal string EncryptMessage(byte[] inputMessage)
{
CommonUtility.AssertNotNull("inputMessage", inputMessage);
if (this.Key == null)
{
throw new InvalidOperationException(SR.KeyMissingError, null);
}
CloudQueueEncryptedMessage encryptedMessage = new CloudQueueEncryptedMessage();
EncryptionData encryptionData = new EncryptionData();
encryptionData.EncryptionAgent = new EncryptionAgent(Constants.EncryptionConstants.EncryptionProtocolV1, EncryptionAlgorithm.AES_CBC_256);
encryptionData.KeyWrappingMetadata = new Dictionary <string, string>();
encryptionData.KeyWrappingMetadata[Constants.EncryptionConstants.AgentMetadataKey] = Constants.EncryptionConstants.AgentMetadataValue;
#if WINDOWS_DESKTOP && !WINDOWS_PHONE
using (AesCryptoServiceProvider myAes = new AesCryptoServiceProvider())
#else
using (AesManaged myAes = new AesManaged())
#endif
{
encryptionData.ContentEncryptionIV = myAes.IV;
// Wrap always happens locally, irrespective of local or cloud key. So it is ok to call it synchronously.
Tuple <byte[], string> wrappedKey = CommonUtility.RunWithoutSynchronizationContext(() => this.Key.WrapKeyAsync(myAes.Key, null /* algorithm */, CancellationToken.None).GetAwaiter().GetResult());
encryptionData.WrappedContentKey = new WrappedKey(this.Key.Kid, wrappedKey.Item1, wrappedKey.Item2);
using (ICryptoTransform encryptor = myAes.CreateEncryptor())
{
encryptedMessage.EncryptedMessageContents = Convert.ToBase64String(encryptor.TransformFinalBlock(inputMessage, 0, inputMessage.Length));
}
encryptedMessage.EncryptionData = encryptionData;
return(JsonConvert.SerializeObject(encryptedMessage));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CloudBlobClient"/> class.
/// </summary>
/// <param name="usePathStyleUris">True to use path style Uris.</param>
/// <param name="baseUri">The Blob service endpoint to use to create the client.</param>
/// <param name="credentials">The account credentials.</param>
internal CloudBlobClient(bool?usePathStyleUris, Uri baseUri, StorageCredentials credentials)
{
CommonUtility.AssertNotNull("baseUri", baseUri);
if (credentials == null)
{
credentials = new StorageCredentials();
}
if (baseUri == null)
{
throw new ArgumentNullException("baseUri");
}
if (!baseUri.IsAbsoluteUri)
{
string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.RelativeAddressNotPermitted, baseUri.ToString());
throw new ArgumentException(errorMessage, "baseUri");
}
this.BaseUri = baseUri;
this.Credentials = credentials;
this.RetryPolicy = new ExponentialRetry();
this.ServerTimeout = Constants.DefaultServerSideTimeout;
this.DefaultDelimiter = NavigationHelper.Slash;
this.AuthenticationScheme = AuthenticationScheme.SharedKey;
if (usePathStyleUris.HasValue)
{
this.UsePathStyleUris = usePathStyleUris.Value;
}
else
{
// Automatically decide whether to use host style uri or path style uri
this.UsePathStyleUris = CommonUtility.UsePathStyleAddressing(this.BaseUri);
}
}
/// <summary>
/// Tries to translate the specified exception into a storage exception.
/// Note: we can probably combine this with the above CoreTranslate, this doesn't need to be async.
/// </summary>
/// <param name="ex">The exception to translate.</param>
/// <param name="reqResult">The request result.</param>
/// <param name="parseError">The delegate used to parse the error to get extended error information.</param>
/// <returns>The storage exception or <c>null</c>.</returns>
private static StorageException CoreTranslateAsync(Exception ex, RequestResult reqResult, CancellationToken token)
{
CommonUtility.AssertNotNull("reqResult", reqResult);
CommonUtility.AssertNotNull("ex", ex);
// Dont re-wrap storage exceptions
if (ex is StorageException)
{
return((StorageException)ex);
}
else if (ex is TimeoutException)
{
reqResult.HttpStatusMessage = null;
reqResult.HttpStatusCode = (int)HttpStatusCode.RequestTimeout;
reqResult.ExtendedErrorInformation = null;
return(new StorageException(reqResult, ex.Message, ex));
}
else if (ex is ArgumentException)
{
reqResult.HttpStatusMessage = null;
reqResult.HttpStatusCode = (int)HttpStatusCode.Unused;
reqResult.ExtendedErrorInformation = null;
return(new StorageException(reqResult, ex.Message, ex)
{
IsRetryable = false
});
}
else if (ex is OperationCanceledException)
{
reqResult.HttpStatusMessage = null;
reqResult.HttpStatusCode = 306; // unused
reqResult.ExtendedErrorInformation = null;
return(new StorageException(reqResult, ex.Message, ex));
}
// return null and check in the caller
return(null);
}
/// <summary>
/// Reads the bytes from the current stream and writes them to another stream. This method writes directly to the destination stream,
/// rather than copying the data into a temporary buffer.
/// </summary>
/// <param name="destination">The stream to which the contents of the current stream will be copied.</param>
/// <param name="expiryTime">A DateTime indicating the expiry time.</param>
public void FastCopyTo(Stream destination, DateTime?expiryTime)
{
CommonUtility.AssertNotNull("destination", destination);
// Maximum amount you can read is from current spot to the end.
long leftToRead = this.Length - this.Position;
try
{
while (leftToRead != 0)
{
if (expiryTime.HasValue && DateTime.Now.CompareTo(expiryTime.Value) > 0)
{
throw new TimeoutException();
}
ArraySegment <byte> currentBlock = this.GetCurrentBlock();
// Copy the block
int blockReadLength = (int)Math.Min(leftToRead, currentBlock.Count);
destination.Write(currentBlock.Array, currentBlock.Offset, blockReadLength);
this.AdvancePosition(ref leftToRead, blockReadLength);
}
}
catch (Exception)
{
if (expiryTime.HasValue && DateTime.Now.CompareTo(expiryTime.Value) > 0)
{
throw new TimeoutException();
}
else
{
throw;
}
}
}
/// <summary>
/// Gets the directory's properties from the response.
/// </summary>
/// <param name="response">The web response.</param>
/// <returns>The directory's attributes.</returns>
public static FileDirectoryProperties GetProperties(HttpResponseMessage response)
{
CommonUtility.AssertNotNull("response", response);
// Set the directory properties
FileDirectoryProperties directoryProperties = new FileDirectoryProperties();
directoryProperties.ETag = (response.Headers.ETag == null) ? null :
response.Headers.ETag.ToString();
string directoryEncryption = response.Headers.GetHeaderSingleValueOrDefault(Constants.HeaderConstants.ServerEncrypted);
directoryProperties.IsServerEncrypted = string.Equals(directoryEncryption, Constants.HeaderConstants.TrueHeader, StringComparison.OrdinalIgnoreCase);
if (response.Content != null)
{
directoryProperties.LastModified = response.Content.Headers.LastModified;
}
else
{
directoryProperties.LastModified = null;
}
return(directoryProperties);
}
internal IEnumerable <TResult> Execute <TResult>(CloudTableClient client, string tableName, EntityResolver <TResult> resolver, TableRequestOptions requestOptions, OperationContext operationContext)
{
CommonUtility.AssertNotNullOrEmpty("tableName", tableName);
CommonUtility.AssertNotNull("resolver", resolver);
TableRequestOptions modifiedOptions = TableRequestOptions.ApplyDefaults(requestOptions, client);
operationContext = operationContext ?? new OperationContext();
IEnumerable <TResult> enumerable =
CommonUtility.LazyEnumerable <TResult>(
(continuationToken) =>
{
TableQuerySegment <TResult> seg = CommonUtility.RunWithoutSynchronizationContext(() => this.ExecuteQuerySegmentedAsync((TableContinuationToken)continuationToken, client, tableName, resolver, modifiedOptions, operationContext).Result);
return(new ResultSegment <TResult>(seg.Results)
{
ContinuationToken = seg.ContinuationToken
});
},
this.takeCount.HasValue ? this.takeCount.Value : long.MaxValue);
return(enumerable);
}
/// <summary>
/// Asynchronously reads a sequence of bytes from the current stream, advances the
/// position within the stream by the number of bytes read, and monitors cancellation requests.
/// </summary>
/// <remarks>In the returned <see cref="Task{TElement}"/> object, the value of the integer
/// parameter contains the total number of bytes read into the buffer. The result value can be
/// less than the number of bytes requested if the number of bytes currently available is less
/// than the requested number, or it can be 0 (zero) if the end of the stream has been reached.</remarks>
/// <param name="buffer">The buffer to read the data into.</param>
/// <param name="offset">The byte offset in buffer at which to begin writing
/// data read from the stream.</param>
/// <param name="count">The maximum number of bytes to read.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <returns>A task that represents the asynchronous read operation.</returns>
public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
CommonUtility.AssertNotNull("buffer", buffer);
CommonUtility.AssertInBounds("offset", offset, 0, buffer.Length);
CommonUtility.AssertInBounds("count", count, 0, buffer.Length - offset);
if (this.lastException != null)
{
throw this.lastException;
}
if ((this.currentOffset == this.Length) || (count == 0))
{
return 0;
}
int readCount = this.ConsumeBuffer(buffer, offset, count);
if (readCount > 0)
{
return readCount;
}
return await this.DispatchReadAsync(buffer, offset, count);
}
/// <summary>
/// Generates a <see cref="RESTCommand"/> for changing a lease ID.
/// </summary>
/// <param name="blob">The blob object that is calling this method.</param>
/// <param name="attributes">The blob's attributes.</param>
/// <param name="proposedLeaseId">The proposed new lease ID.</param>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies additional options for the request.</param>
/// <returns>A <see cref="RESTCommand"/> implementing the change lease ID operation.</returns>
internal static RESTCommand <string> ChangeLeaseImpl(ICloudBlob blob, BlobAttributes attributes, string proposedLeaseId, AccessCondition accessCondition, BlobRequestOptions options)
{
CommonUtility.AssertNotNull("accessCondition", accessCondition);
CommonUtility.AssertNotNull("proposedLeaseId", proposedLeaseId);
if (accessCondition.LeaseId == null)
{
throw new ArgumentException(SR.MissingLeaseIDChanging, "accessCondition");
}
RESTCommand <string> putCmd = new RESTCommand <string>(blob.ServiceClient.Credentials, attributes.StorageUri);
options.ApplyToStorageCommand(putCmd);
putCmd.Handler = blob.ServiceClient.AuthenticationHandler;
putCmd.BuildClient = HttpClientFactory.BuildHttpClient;
putCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => BlobHttpRequestMessageFactory.Lease(uri, serverTimeout, LeaseAction.Change, proposedLeaseId, null /* leaseDuration */, null /* leaseBreakPeriod */, accessCondition, cnt, ctx);
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex);
CloudBlobSharedImpl.UpdateETagLMTAndSequenceNumber(attributes, resp);
return(BlobHttpResponseParsers.GetLeaseId(resp));
};
return(putCmd);
}
/// <summary>
/// Generates XML representing the given static website properties.
/// </summary>
/// <param name="staticWebsiteProperties">The static website properties.</param>
/// <returns>An XML element corresponding to the input properties.</returns>
private static XElement GenerateStaticWebsitePropertiesXml(StaticWebsiteProperties staticWebsiteProperties)
{
CommonUtility.AssertNotNull("staticWebsiteProperties", staticWebsiteProperties);
bool enabled = staticWebsiteProperties.Enabled;
XElement xml = new XElement(StaticWebsiteName, new XElement(StaticWebsiteEnabledName, enabled));
if (!enabled)
{
return(xml);
}
if (!string.IsNullOrWhiteSpace(staticWebsiteProperties.IndexDocument))
{
xml.Add(new XElement(StaticWebsiteIndexDocumentName, staticWebsiteProperties.IndexDocument));
}
if (!string.IsNullOrWhiteSpace(staticWebsiteProperties.ErrorDocument404Path))
{
xml.Add(new XElement(StaticWebsiteErrorDocument404PathName, staticWebsiteProperties.ErrorDocument404Path));
}
return(xml);
}
internal KeyRotationEntity(DynamicTableEntity dte)
{
CommonUtility.AssertNotNull("properties", dte.Properties);
// Store the information about this entity. Make a copy of the properties list, in case the caller decides to reuse the list.
this.PartitionKey = dte.PartitionKey;
this.RowKey = dte.RowKey;
this.Timestamp = dte.Timestamp;
this.ETag = dte.ETag;
if (!dte.Properties.ContainsKey(Constants.EncryptionConstants.TableEncryptionKeyDetails))
{
// This should only be possible if RequireEncryption is true, otherwise the entity would have been filtered out in the query.
throw new InvalidOperationException(SR.KeyRotationNoEncryptionMetadata);
}
else
{
this.encryptionMetadataJson = dte.Properties[Constants.EncryptionConstants.TableEncryptionKeyDetails].StringValue;
}
Dictionary <string, EntityProperty> properties = new Dictionary <string, EntityProperty>(dte.Properties);
properties.Remove(Constants.EncryptionConstants.TableEncryptionKeyDetails);
properties.Remove(Constants.EncryptionConstants.TableEncryptionPropertyDetails);
this.Properties = new System.Collections.ObjectModel.ReadOnlyDictionary <string, EntityProperty>(properties);
}
/// <summary>
/// Constructs a web request to return a specified range of the file's content, together with its properties and metadata.
/// </summary>
/// <param name="uri">The absolute URI to the file.</param>
/// <param name="timeout">The server timeout interval, in seconds.</param>
/// <param name="offset">The byte offset at which to begin returning content.</param>
/// <param name="count">The number of bytes to return, or null to return all bytes through the end of the file.</param>
/// <param name="shareSnapshot">A <see cref="DateTimeOffset"/> specifying the share snapshot timestamp, if the share is a snapshot.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static StorageRequestMessage Get(Uri uri, int?timeout, long?offset, long?count, bool rangeContentMD5, DateTimeOffset?shareSnapshot, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials)
{
if (offset.HasValue && offset.Value < 0)
{
CommonUtility.ArgumentOutOfRange("offset", offset);
}
if (offset.HasValue && rangeContentMD5)
{
CommonUtility.AssertNotNull("count", count);
CommonUtility.AssertInBounds("count", count.Value, 1, Constants.MaxRangeGetContentMD5Size);
}
StorageRequestMessage request = Get(uri, timeout, shareSnapshot, accessCondition, content, operationContext, canonicalizer, credentials);
AddRange(request, offset, count);
if (offset.HasValue && rangeContentMD5)
{
request.Headers.Add(Constants.HeaderConstants.RangeContentMD5Header, Constants.HeaderConstants.TrueHeader);
}
return(request);
}
/// <summary>
/// Constructs a web request to return a specified range of the blob's content, together with its properties and metadata.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval, in seconds.</param>
/// <param name="snapshot">The snapshot version, if the blob is a snapshot.</param>
/// <param name="offset">The byte offset at which to begin returning content.</param>
/// <param name="count">The number of bytes to return, or null to return all bytes through the end of the blob.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage Get(Uri uri, int?timeout, DateTimeOffset?snapshot, long?offset, long?count, bool rangeContentMD5, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
if (offset.HasValue && offset.Value < 0)
{
CommonUtility.ArgumentOutOfRange("offset", offset);
}
if (offset.HasValue && rangeContentMD5)
{
CommonUtility.AssertNotNull("count", count);
CommonUtility.AssertInBounds("count", count.Value, 1, Constants.MaxBlockSize);
}
HttpRequestMessage request = Get(uri, timeout, snapshot, accessCondition, content, operationContext);
AddRange(request, offset, count);
if (offset.HasValue && rangeContentMD5)
{
request.Headers.Add(Constants.HeaderConstants.RangeContentMD5Header, Constants.HeaderConstants.TrueHeader);
}
return(request);
}
/// <summary>
/// Constructs a web request to set system properties for a directory.
/// </summary>
/// <param name="uri">The absolute URI to the file.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The directory's properties.</param>
/// <param name="filePermissionToSet">The file's file permission</param>
/// <param name="content">HttpContent for the request</param>
/// <param name="operationContext">An <see cref="OperationContext" /> object for tracking the current operation.</param>
/// <param name="canonicalizer">A canonicalizer that converts HTTP request data into a standard form appropriate for signing.</param>
/// <param name="credentials">A <see cref="StorageCredentials"/> object providing credentials for the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static StorageRequestMessage SetProperties(
Uri uri,
int?timeout,
FileDirectoryProperties properties,
string filePermissionToSet,
HttpContent content,
OperationContext operationContext,
ICanonicalizer canonicalizer,
StorageCredentials credentials)
{
CommonUtility.AssertNotNull("properties", properties);
UriQueryBuilder builder = GetDirectoryUriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "properties");
StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials);
AddFilePermissionOrFilePermissionKey(request, filePermissionToSet, properties, Constants.HeaderConstants.Preserve);
AddNtfsFileAttributes(request, properties, Constants.HeaderConstants.Preserve);
AddCreationTime(request, properties, Constants.HeaderConstants.Preserve);
AddLastWriteTime(request, properties, Constants.HeaderConstants.Preserve);
return(request);
}
protected override SharedAccessTablePolicy ParseElement(XElement accessPolicyElement)
{
CommonUtility.AssertNotNull("accessPolicyElement", accessPolicyElement);
SharedAccessTablePolicy sharedAccessTablePolicy = new SharedAccessTablePolicy();
string text = (string)accessPolicyElement.Element("Start");
if (!string.IsNullOrEmpty(text))
{
sharedAccessTablePolicy.SharedAccessStartTime = Uri.UnescapeDataString(text).ToUTCTime();
}
string text2 = (string)accessPolicyElement.Element("Expiry");
if (!string.IsNullOrEmpty(text2))
{
sharedAccessTablePolicy.SharedAccessExpiryTime = Uri.UnescapeDataString(text2).ToUTCTime();
}
string text3 = (string)accessPolicyElement.Element("Permission");
if (!string.IsNullOrEmpty(text3))
{
sharedAccessTablePolicy.Permissions = SharedAccessTablePolicy.PermissionsFromString(text3);
}
return(sharedAccessTablePolicy);
}
/// <summary>
/// Initializes a new instance of the <see cref="FileProperties"/> class based on an existing instance.
/// </summary>
/// <param name="other">The set of file properties to clone.</param>
public FileProperties(FileProperties other)
{
CommonUtility.AssertNotNull("other", other);
this.ContentType = other.ContentType;
this.ContentDisposition = other.ContentDisposition;
this.ContentEncoding = other.ContentEncoding;
this.ContentLanguage = other.ContentLanguage;
this.CacheControl = other.CacheControl;
this.ContentChecksum.MD5 = other.ContentChecksum.MD5;
this.ContentChecksum.CRC64 = other.ContentChecksum.CRC64;
this.Length = other.Length;
this.ETag = other.ETag;
this.LastModified = other.LastModified;
this.IsServerEncrypted = other.IsServerEncrypted;
this.filePermissionKey = other.filePermissionKey;
this.ntfsAttributes = other.ntfsAttributes;
this.creationTime = other.creationTime;
this.lastWriteTime = other.lastWriteTime;
this.filePermissionKeyToSet = other.filePermissionKeyToSet;
this.ntfsAttributesToSet = other.ntfsAttributesToSet;
this.creationTimeToSet = other.creationTimeToSet;
this.lastWriteTimeToSet = other.lastWriteTimeToSet;
}
/// <summary>
/// Constructs a web request to set system properties for a file.
/// </summary>
/// <param name="uri">The absolute URI to the file.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The file's properties.</param>
/// <param name="filePermissionToSet">The file's file permission</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <param name="content">HttpContent for the request</param>
/// <param name="operationContext">An <see cref="OperationContext" /> object for tracking the current operation.</param>
/// <param name="canonicalizer">A canonicalizer that converts HTTP request data into a standard form appropriate for signing.</param>
/// <param name="credentials">A <see cref="StorageCredentials"/> object providing credentials for the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static StorageRequestMessage SetProperties(
Uri uri,
int?timeout,
FileProperties properties,
string filePermissionToSet,
AccessCondition accessCondition,
HttpContent content,
OperationContext operationContext,
ICanonicalizer canonicalizer,
StorageCredentials credentials)
{
CommonUtility.AssertNotNull("properties", properties);
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "properties");
StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext, canonicalizer, credentials);
if (properties != null)
{
request.AddOptionalHeader(Constants.HeaderConstants.FileCacheControlHeader, properties.CacheControl);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentDispositionRequestHeader, properties.ContentDisposition);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentEncodingHeader, properties.ContentEncoding);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentLanguageHeader, properties.ContentLanguage);
request.AddOptionalHeader(Constants.HeaderConstants.FileContentTypeHeader, properties.ContentType);
request.ApplyFileContentChecksumHeaders(properties.ContentChecksum);
}
AddFilePermissionOrFilePermissionKey(request, filePermissionToSet, properties, Constants.HeaderConstants.Preserve);
AddNtfsFileAttributes(request, properties, Constants.HeaderConstants.Preserve);
AddCreationTime(request, properties, Constants.HeaderConstants.Preserve);
AddLastWriteTime(request, properties, Constants.HeaderConstants.Preserve);
request.ApplyAccessCondition(accessCondition);
return(request);
}