/// <summary>
/// Generates a task sequence for getting the properties of the queue service.
/// </summary>
/// <param name="setResult">A delegate to receive the service properties.</param>
/// <returns>A task sequence that gets the properties of the queue service.</returns>
private TaskSequence GetServicePropertiesImpl(Action <ServiceProperties> setResult)
{
HttpWebRequest request = QueueRequest.GetServiceProperties(this.BaseUri, this.Timeout.RoundUpToSeconds());
CommonUtils.ApplyRequestOptimizations(request, -1);
this.Credentials.SignRequest(request);
// Get the web response.
Task <WebResponse> responseTask = request.GetResponseAsyncWithTimeout(this, this.Timeout);
yield return(responseTask);
using (HttpWebResponse response = responseTask.Result as HttpWebResponse)
using (Stream responseStream = response.GetResponseStream())
using (MemoryStream memoryStream = new MemoryStream())
{
// Download the service properties.
Task <NullTaskReturn> downloadTask = new InvokeTaskSequenceTask(() => { return(responseStream.WriteTo(memoryStream)); });
yield return(downloadTask);
// Materialize any exceptions.
NullTaskReturn scratch = downloadTask.Result;
// Get the result from the memory stream.
memoryStream.Seek(0, SeekOrigin.Begin);
setResult(QueueResponse.ReadServiceProperties(memoryStream));
}
}
/// <summary>
/// Uploads the block list.
/// </summary>
/// <param name="blocks">The blocks to upload.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <returns>A <see cref="TaskSequence"/> that uploads the block list.</returns>
internal TaskSequence UploadBlockList(List <PutBlockListItem> blocks, BlobRequestOptions options)
{
if (options == null)
{
throw new ArgumentNullException("modifers");
}
var request = ProtocolHelper.GetWebRequest(this.ServiceClient, options, (timeout) => BlobRequest.PutBlockList(this.TransformedAddress, timeout, this.Properties, null));
options.AccessCondition.ApplyCondition(request);
BlobRequest.AddMetadata(request, this.Metadata);
using (var memoryStream = new SmallBlockMemoryStream(Constants.DefaultBufferSize))
{
BlobRequest.WriteBlockListBody(blocks, memoryStream);
CommonUtils.ApplyRequestOptimizations(request, memoryStream.Length);
memoryStream.Seek(0, SeekOrigin.Begin);
// Compute the MD5
var md5 = System.Security.Cryptography.MD5.Create();
request.Headers[HttpRequestHeader.ContentMd5] = Convert.ToBase64String(md5.ComputeHash(memoryStream));
this.ServiceClient.Credentials.SignRequest(request);
memoryStream.Seek(0, SeekOrigin.Begin);
// Retrieve the stream
var requestStreamTask = request.GetRequestStreamAsync();
yield return(requestStreamTask);
using (Stream requestStream = requestStreamTask.Result)
{
// Copy the data
var copyTask = new InvokeTaskSequenceTask(() => { return(memoryStream.WriteTo(requestStream)); });
yield return(copyTask);
// Materialize any exceptions
var scratch = copyTask.Result;
Console.WriteLine(scratch);
}
}
// Get the response
var responseTask = request.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
yield return(responseTask);
using (var response = responseTask.Result as HttpWebResponse)
{
ParseSizeAndLastModified(response);
this.Properties.Length = 0;
}
}
/// <summary>
/// Callback on DataContext object sending request.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.Data.Services.Client.SendingRequestEventArgs"/> instance containing the event data.</param>
private void DataContextSendingRequest(object sender, SendingRequestEventArgs e)
{
HttpWebRequest request = e.Request as HttpWebRequest;
request.Headers.Add(
Protocol.Constants.HeaderConstants.StorageVersionHeader,
Protocol.Request.GetTargetVersion());
StorageCredentials.SignRequestLite(request);
CommonUtils.ApplyRequestOptimizations(request, -1);
}
/// <summary>
/// Gets the web request.
/// </summary>
/// <param name="serviceClient">The service client.</param>
/// <param name="options">The options.</param>
/// <param name="retrieveRequest">The retrieve request.</param>
/// <returns>The web request.</returns>
internal static HttpWebRequest GetWebRequest(CloudBlobClient serviceClient, BlobRequestOptions options, Func <int, HttpWebRequest> retrieveRequest)
{
CommonUtils.AssertNotNull("options", options);
int timeoutInSeconds = options.Timeout.RoundUpToSeconds();
AccessCondition accessCondition = options.AccessCondition;
var webRequest = retrieveRequest(timeoutInSeconds);
accessCondition.ApplyCondition(webRequest);
CommonUtils.ApplyRequestOptimizations(webRequest, -1);
return(webRequest);
}
/// <summary>
/// Generates a task sequence for setting the properties of the queue service.
/// </summary>
/// <param name="properties">The queue service properties to set.</param>
/// <returns>A task sequence that sets the properties of the queue service.</returns>
private TaskSequence SetServicePropertiesImpl(ServiceProperties properties)
{
CommonUtils.AssertNotNull("properties", properties);
HttpWebRequest request = QueueRequest.SetServiceProperties(this.BaseUri, this.Timeout.RoundUpToSeconds());
using (MemoryStream memoryStream = new MemoryStream())
{
try
{
QueueRequest.WriteServiceProperties(properties, memoryStream);
}
catch (InvalidOperationException invalidOpException)
{
throw new ArgumentException(invalidOpException.Message, "properties");
}
memoryStream.Seek(0, SeekOrigin.Begin);
CommonUtils.ApplyRequestOptimizations(request, memoryStream.Length);
this.Credentials.SignRequest(request);
// Get the request stream
Task <Stream> getStreamTask = request.GetRequestStreamAsync();
yield return(getStreamTask);
using (Stream requestStream = getStreamTask.Result)
{
// Upload the service properties.
Task <NullTaskReturn> uploadTask = new InvokeTaskSequenceTask(() => { return((memoryStream as Stream).WriteTo(requestStream)); });
yield return(uploadTask);
// Materialize any exceptions.
NullTaskReturn scratch = uploadTask.Result;
Console.WriteLine(scratch);
}
}
// Get the web response.
Task <WebResponse> responseTask = request.GetResponseAsyncWithTimeout(this, this.Timeout);
yield return(responseTask);
// Materialize any exceptions.
using (HttpWebResponse response = responseTask.Result as HttpWebResponse)
{
}
}
