public IAsyncAction SetServicePropertiesAsync(ServiceProperties properties)
#endif
{
return(this.SetServicePropertiesAsync(properties, null, null));
}
public void CloudBlobTestAnalyticsRetentionPolicies()
{
CloudBlobClient client = GenerateCloudBlobClient();
ServiceProperties props = client.GetServiceProperties();
// Set retention policy null with metrics disabled.
props.Metrics.RetentionDays = null;
props.Metrics.MetricsLevel = MetricsLevel.None;
client.SetServiceProperties(props);
// Wait for analytics server to update
Thread.Sleep(60 * 1000);
AssertServicePropertiesAreEqual(props, client.GetServiceProperties());
// Set retention policy not null with metrics disabled.
props.Metrics.RetentionDays = 1;
props.Metrics.MetricsLevel = MetricsLevel.Service;
client.SetServiceProperties(props);
// Wait for analytics server to update
Thread.Sleep(60 * 1000);
AssertServicePropertiesAreEqual(props, client.GetServiceProperties());
// Set retention policy not null with metrics enabled.
props.Metrics.MetricsLevel = MetricsLevel.ServiceAndApi;
props.Metrics.RetentionDays = 2;
client.SetServiceProperties(props);
// Wait for analytics server to update
Thread.Sleep(60 * 1000);
AssertServicePropertiesAreEqual(props, client.GetServiceProperties());
// Set retention policy null with logging disabled.
props.Logging.RetentionDays = null;
props.Logging.LoggingOperations = LoggingOperations.None;
client.SetServiceProperties(props);
// Wait for analytics server to update
Thread.Sleep(60 * 1000);
AssertServicePropertiesAreEqual(props, client.GetServiceProperties());
// Set retention policy not null with logging disabled.
props.Logging.RetentionDays = 3;
props.Logging.LoggingOperations = LoggingOperations.None;
client.SetServiceProperties(props);
// Wait for analytics server to update
Thread.Sleep(60 * 1000);
AssertServicePropertiesAreEqual(props, client.GetServiceProperties());
// Set retention policy null with logging enabled.
props.Logging.RetentionDays = null;
props.Logging.LoggingOperations = LoggingOperations.All;
client.SetServiceProperties(props);
// Wait for analytics server to update
Thread.Sleep(60 * 1000);
AssertServicePropertiesAreEqual(props, client.GetServiceProperties());
// Set retention policy not null with logging enabled.
props.Logging.RetentionDays = 4;
props.Logging.LoggingOperations = LoggingOperations.All;
client.SetServiceProperties(props);
// Wait for analytics server to update
Thread.Sleep(60 * 1000);
AssertServicePropertiesAreEqual(props, client.GetServiceProperties());
}
static void Main(string[] args)
{
ConsoleColor original = Console.ForegroundColor;
try
{
// Get Info From User
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("***************** Azure AD B2C Blob Storage Helper Tool *********************");
Console.WriteLine("This tool will upload all contents of a directory to an Azure Blob Storage Container you specify.");
Console.WriteLine("It will also enable CORS access from all origins on each of the files.");
Console.WriteLine("");
Console.WriteLine("Enter your Azure Storage Account name: ");
string storageAccountName = Console.ReadLine();
Console.WriteLine("Enter your Azure Blob Storage Primary Access Key: ");
string storageKey = Console.ReadLine();
Console.WriteLine("Enter your Azure Blob Storage Container name: ");
string containerName = Console.ReadLine();
Console.WriteLine("Enter the path to the directory whose contents you wish to upload: ");
string directoryPath = Console.ReadLine();
// Upload File to Blob Storage
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(String.Format(CultureInfo.InvariantCulture, connectionStringTemplate, storageAccountName, storageKey));
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference(containerName);
string absoluteDirPath = Path.GetFullPath(directoryPath);
string[] allFiles = Directory.GetFiles(absoluteDirPath, "*.*", SearchOption.AllDirectories);
foreach (string filePath in allFiles)
{
string relativePathAndFileName = filePath.Substring(filePath.IndexOf(absoluteDirPath) + absoluteDirPath.Length);
relativePathAndFileName = relativePathAndFileName[0] == '\\' ? relativePathAndFileName.Substring(1) : relativePathAndFileName;
CloudBlockBlob blockBlob = container.GetBlockBlobReference(relativePathAndFileName);
blockBlob.Properties.ContentType = MapFileExtensionToContentType(relativePathAndFileName);
using (var fileStream = System.IO.File.OpenRead(filePath))
{
blockBlob.UploadFromStream(fileStream);
}
Console.WriteLine("Sucessfully uploaded file " + relativePathAndFileName + " to Azure Blob Storage");
}
// Enable CORS
CorsProperties corsProps = new CorsProperties();
corsProps.CorsRules.Add(new CorsRule
{
AllowedHeaders = new List <string> {
"*"
},
AllowedMethods = CorsHttpMethods.Get,
AllowedOrigins = new List <string> {
"*"
},
ExposedHeaders = new List <string> {
"*"
},
MaxAgeInSeconds = 200
});
ServiceProperties serviceProps = new ServiceProperties
{
Cors = corsProps,
Logging = new LoggingProperties
{
Version = "1.0",
},
HourMetrics = new MetricsProperties
{
Version = "1.0"
},
MinuteMetrics = new MetricsProperties
{
Version = "1.0"
},
};
blobClient.SetServiceProperties(serviceProps);
Console.WriteLine("Successfully set CORS policy, allowing GET on all origins. See https://msdn.microsoft.com/en-us/library/azure/dn535601.aspx for more.");
}
catch (Exception ex)
{
Console.WriteLine("Error Making Request to Azure Blob Storage: ");
Console.WriteLine("");
Console.WriteLine(ex.Message);
}
finally
{
Console.WriteLine("Press Enter to close...");
Console.ReadLine();
Console.ForegroundColor = original;
}
}
public void CloudTableTestAnalyticsRoundTripAPM()
{
props.Logging.LoggingOperations = LoggingOperations.Read | LoggingOperations.Write;
props.Logging.RetentionDays = 5;
props.Logging.Version = Constants.AnalyticsConstants.LoggingVersionV1;
props.HourMetrics.MetricsLevel = MetricsLevel.Service;
props.HourMetrics.RetentionDays = 6;
props.HourMetrics.Version = Constants.AnalyticsConstants.MetricsVersionV1;
props.MinuteMetrics.MetricsLevel = MetricsLevel.Service;
props.MinuteMetrics.RetentionDays = 6;
props.MinuteMetrics.Version = Constants.AnalyticsConstants.MetricsVersionV1;
props.Cors.CorsRules.Add(
new CorsRule()
{
AllowedOrigins = new List <string>()
{
"www.ab.com", "www.bc.com"
},
AllowedMethods = CorsHttpMethods.Get | CorsHttpMethods.Put,
MaxAgeInSeconds = 500,
ExposedHeaders =
new List <string>()
{
"x-ms-meta-data*",
"x-ms-meta-source*",
"x-ms-meta-abc",
"x-ms-meta-bcd"
},
AllowedHeaders =
new List <string>()
{
"x-ms-meta-data*",
"x-ms-meta-target*",
"x-ms-meta-xyz",
"x-ms-meta-foo"
}
});
using (ManualResetEvent evt = new ManualResetEvent(false))
{
IAsyncResult result = null;
client.BeginSetServiceProperties(props, (res) =>
{
result = res;
evt.Set();
}, null);
evt.WaitOne();
client.EndSetServiceProperties(result);
}
ServiceProperties retrievedProps = null;
using (ManualResetEvent evt = new ManualResetEvent(false))
{
IAsyncResult result = null;
client.BeginGetServiceProperties((res) =>
{
result = res;
evt.Set();
}, null);
evt.WaitOne();
retrievedProps = client.EndGetServiceProperties(result);
}
TestHelper.AssertServicePropertiesAreEqual(props, retrievedProps);
}
internal static void AssertServicePropertiesAreEqual(ServiceProperties propsA, ServiceProperties propsB)
{
if (propsA.Logging != null && propsB.Logging != null)
{
Assert.AreEqual(propsA.Logging.LoggingOperations, propsB.Logging.LoggingOperations);
Assert.AreEqual(propsA.Logging.RetentionDays, propsB.Logging.RetentionDays);
Assert.AreEqual(propsA.Logging.Version, propsB.Logging.Version);
}
else
{
Assert.IsNull(propsA.Logging);
Assert.IsNull(propsA.Logging);
}
if (propsA.HourMetrics != null && propsB.Logging != null)
{
Assert.AreEqual(propsA.HourMetrics.MetricsLevel, propsB.HourMetrics.MetricsLevel);
Assert.AreEqual(propsA.HourMetrics.RetentionDays, propsB.HourMetrics.RetentionDays);
Assert.AreEqual(propsA.HourMetrics.Version, propsB.HourMetrics.Version);
}
else
{
Assert.IsNull(propsA.HourMetrics);
Assert.IsNull(propsB.HourMetrics);
}
if (propsA.MinuteMetrics != null && propsB.MinuteMetrics != null)
{
Assert.AreEqual(propsA.MinuteMetrics.MetricsLevel, propsB.MinuteMetrics.MetricsLevel);
Assert.AreEqual(propsA.MinuteMetrics.RetentionDays, propsB.MinuteMetrics.RetentionDays);
Assert.AreEqual(propsA.MinuteMetrics.Version, propsB.MinuteMetrics.Version);
}
else
{
Assert.IsNull(propsA.MinuteMetrics);
Assert.IsNull(propsB.MinuteMetrics);
}
if (propsA.DefaultServiceVersion != null && propsB.DefaultServiceVersion != null)
{
Assert.AreEqual(propsA.DefaultServiceVersion, propsB.DefaultServiceVersion);
}
else
{
Assert.IsNull(propsA.DefaultServiceVersion);
Assert.IsNull(propsB.DefaultServiceVersion);
}
if (propsA.Cors != null && propsB.Cors != null)
{
Assert.AreEqual(propsA.Cors.CorsRules.Count, propsB.Cors.CorsRules.Count);
// Check that rules are equal and in the same order.
for (int i = 0; i < propsA.Cors.CorsRules.Count; i++)
{
CorsRule ruleA = propsA.Cors.CorsRules.ElementAt(i);
CorsRule ruleB = propsB.Cors.CorsRules.ElementAt(i);
Assert.IsTrue(
ruleA.AllowedOrigins.Count == ruleB.AllowedOrigins.Count
&& !ruleA.AllowedOrigins.Except(ruleB.AllowedOrigins).Any());
Assert.IsTrue(
ruleA.ExposedHeaders.Count == ruleB.ExposedHeaders.Count
&& !ruleA.ExposedHeaders.Except(ruleB.ExposedHeaders).Any());
Assert.IsTrue(
ruleA.AllowedHeaders.Count == ruleB.AllowedHeaders.Count
&& !ruleA.AllowedHeaders.Except(ruleB.AllowedHeaders).Any());
Assert.IsTrue(ruleA.AllowedMethods == ruleB.AllowedMethods);
Assert.IsTrue(ruleA.MaxAgeInSeconds == ruleB.MaxAgeInSeconds);
}
}
else
{
Assert.IsNull(propsA.Cors);
Assert.IsNull(propsB.Cors);
}
}
public virtual Task SetServicePropertiesAsync(ServiceProperties properties, BlobRequestOptions requestOptions, OperationContext operationContext)
{
return(this.SetServicePropertiesAsync(properties, requestOptions, operationContext, CancellationToken.None));
}
/// <summary>
/// Initializes a new instance of the <see cref="FileServiceProperties"/> class.
/// </summary>
public FileServiceProperties(MetricsProperties hourMetrics = null, MetricsProperties minuteMetrics = null, CorsProperties cors = null)
{
this.serviceProperties = new ServiceProperties(null, hourMetrics, minuteMetrics, cors);
}
public virtual Task SetServicePropertiesAsync(ServiceProperties properties, CancellationToken cancellationToken)
{
return(AsyncExtensions.TaskFromVoidApm(this.BeginSetServiceProperties, this.EndSetServiceProperties, properties, cancellationToken));
}
public virtual Task SetServicePropertiesAsync(ServiceProperties properties, QueueRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return(AsyncExtensions.TaskFromVoidApm(this.BeginSetServiceProperties, this.EndSetServiceProperties, properties, options, operationContext, cancellationToken));
}
public virtual ICancellableAsyncResult BeginSetServiceProperties(ServiceProperties properties, AsyncCallback callback, object state)
{
return(this.BeginSetServiceProperties(properties, null /* RequestOptions */, null /* OperationContext */, callback, state));
}
public virtual Task SetServicePropertiesAsync(ServiceProperties properties)
{
return(this.SetServicePropertiesAsync(properties, CancellationToken.None));
}
public IAsyncAction SetServicePropertiesAsync(ServiceProperties properties)
{
return(this.SetServicePropertiesAsync(properties, null /* options */, null /* operationContext */));
}
public void SetServiceProperties(ServiceProperties properties)
{
_properties = Clone(properties);
}
public void TestSetServicePropertiesWithNoProperties()
{
ServiceProperties serviceProperties = new ServiceProperties();
TestHelper.ExpectedException <ArgumentException>(() => client.SetServiceProperties(serviceProperties), "At least one service property needs to be non-null for SetServiceProperties API.");
}
/// <summary>
/// Sets the properties of the blob service.
/// </summary>
/// <param name="properties">The blob service properties.</param>
public void SetServiceProperties(ServiceProperties properties)
{
TaskImplHelper.ExecuteImplWithRetry(() => this.SetServicePropertiesImpl(properties), this.RetryPolicy);
}
public virtual void SetServiceProperties(ServiceProperties properties, QueueRequestOptions requestOptions = null, OperationContext operationContext = null)
{
requestOptions = QueueRequestOptions.ApplyDefaults(requestOptions, this);
operationContext = operationContext ?? new OperationContext();
Executor.ExecuteSync(this.SetServicePropertiesImpl(properties, requestOptions), requestOptions.RetryPolicy, operationContext);
}
public IServiceProperty GetProperty(string key)
{
return(ServiceProperties.ContainsKey(key) ? ServiceProperties[key] : null);
}
public string EnableStorageCORS(Account account)
{
try
{
var storageAccount = StorageUtils.CreateCloudStorageAccount(account);
var blobClient = storageAccount.CreateCloudBlobClient();
CorsHttpMethods allowedMethods = CorsHttpMethods.None;
allowedMethods = allowedMethods | CorsHttpMethods.Get;
allowedMethods = allowedMethods | CorsHttpMethods.Put;
allowedMethods = allowedMethods | CorsHttpMethods.Post;
allowedMethods = allowedMethods | CorsHttpMethods.Delete;
allowedMethods = allowedMethods | CorsHttpMethods.Options;
var delimiter = new[] { "," };
CorsRule corsRule = new CorsRule();
const string allowedOrigins = "*";
const string allowedHeaders = "*";
const string exposedHeaders = "";
string[] allAllowedOrigin = allowedOrigins.Split(delimiter, StringSplitOptions.RemoveEmptyEntries);
string[] allExpHeaders = exposedHeaders.Split(delimiter, StringSplitOptions.RemoveEmptyEntries);
string[] allAllowHeaders = allowedHeaders.Split(delimiter, StringSplitOptions.RemoveEmptyEntries);
List <string> corsAllowedOrigin = new List <string>();
foreach (var item in allAllowedOrigin)
{
if (!string.IsNullOrWhiteSpace(item))
{
corsAllowedOrigin.Add(item.Trim());
}
}
List <string> corsExposedHeaders = new List <string>();
foreach (var item in allExpHeaders)
{
if (!string.IsNullOrWhiteSpace(item))
{
corsExposedHeaders.Add(item.Trim());
}
}
List <string> corsAllowHeaders = new List <string>();
foreach (var item in allAllowHeaders)
{
if (!string.IsNullOrWhiteSpace(item))
{
corsAllowHeaders.Add(item.Trim());
}
}
corsRule.MaxAgeInSeconds = 200;
corsRule.AllowedMethods = allowedMethods;
corsRule.AllowedHeaders = corsAllowHeaders;
corsRule.AllowedOrigins = corsAllowedOrigin;
corsRule.ExposedHeaders = corsExposedHeaders;
ServiceProperties properties = blobClient.GetServiceProperties();
properties.Cors.CorsRules.Clear();
properties.Cors.CorsRules.Add(corsRule);
blobClient.SetServiceProperties(properties);
}
catch (Exception ex)
{
logger.Error(ex);
return("Failed due to Incorrect Account Name or Key.");
}
return("Enabling CORS Succeed");
}
/// <summary>
/// Initializes a new instance of the <see cref="FileServiceProperties"/> class.
/// </summary>
public FileServiceProperties()
{
this.serviceProperties = new ServiceProperties();
}
public static void MyClassInitialize(TestContext testContext)
{
client = GenerateCloudTableClient();
startProperties = client.GetServicePropertiesAsync().Result;
}
/// <summary>
/// Writes service properties to a stream, formatted in XML.
/// </summary>
/// <param name="properties">The service properties to format and write to the stream.</param>
/// <param name="outputStream">The stream to which the formatted properties are to be written.</param>
public static void WriteServiceProperties(ServiceProperties properties, Stream outputStream)
{
properties.WriteServiceProperties(outputStream);
}
public Task SetServicePropertiesAsync(ServiceProperties properties)
{
return(SetServicePropertiesAsync(properties, null, null));
}
public void CloudTableTestAnalyticsOptionalPropertiesSync()
{
props.Logging.LoggingOperations = LoggingOperations.Read | LoggingOperations.Write;
props.Logging.RetentionDays = 5;
props.Logging.Version = Constants.AnalyticsConstants.LoggingVersionV1;
props.HourMetrics.MetricsLevel = MetricsLevel.Service;
props.HourMetrics.RetentionDays = 6;
props.HourMetrics.Version = Constants.AnalyticsConstants.MetricsVersionV1;
props.MinuteMetrics.MetricsLevel = MetricsLevel.Service;
props.MinuteMetrics.RetentionDays = 6;
props.MinuteMetrics.Version = Constants.AnalyticsConstants.MetricsVersionV1;
props.Cors.CorsRules.Clear();
client.SetServiceProperties(props);
ServiceProperties newProps = new ServiceProperties(cors: new CorsProperties());
newProps.Cors.CorsRules.Add(
new CorsRule()
{
AllowedOrigins = new List <string>()
{
"www.ab.com", "www.bc.com"
},
AllowedMethods = CorsHttpMethods.Get | CorsHttpMethods.Put,
MaxAgeInSeconds = 500,
ExposedHeaders =
new List <string>()
{
"x-ms-meta-data*",
"x-ms-meta-source*",
"x-ms-meta-abc",
"x-ms-meta-bcd"
},
AllowedHeaders =
new List <string>()
{
"x-ms-meta-data*",
"x-ms-meta-target*",
"x-ms-meta-xyz",
"x-ms-meta-foo"
}
});
client.SetServiceProperties(newProps);
// Test that the other properties did not change.
props.Cors = newProps.Cors;
TestHelper.AssertServicePropertiesAreEqual(props, client.GetServiceProperties());
newProps.Logging = props.Logging;
newProps.HourMetrics = props.HourMetrics;
newProps.MinuteMetrics = props.MinuteMetrics;
newProps.Cors = null;
client.SetServiceProperties(newProps);
// Test that the CORS rules did not change.
TestHelper.AssertServicePropertiesAreEqual(props, client.GetServiceProperties());
}
public Task SetServicePropertiesAsync(ServiceProperties properties, TableRequestOptions requestOptions, OperationContext operationContext)
{
return(SetServicePropertiesAsync(properties, requestOptions, operationContext, CancellationToken.None));
}
/// <summary>
/// Comapare PSServiceProperties and ServiceProperties, to make sure they are same content
/// </summary>
static private void CompareServiceProperties(PSSeriviceProperties pSSeriviceProperties, ServiceProperties serviceProperties)
{
if ((pSSeriviceProperties != null && pSSeriviceProperties.HourMetrics != null) || (serviceProperties != null && serviceProperties.HourMetrics != null))
{
Assert.AreEqual(serviceProperties.HourMetrics.Version, pSSeriviceProperties.HourMetrics.Version);
Assert.AreEqual(serviceProperties.HourMetrics.MetricsLevel, pSSeriviceProperties.HourMetrics.MetricsLevel);
Assert.AreEqual(serviceProperties.HourMetrics.RetentionDays, pSSeriviceProperties.HourMetrics.RetentionDays);
}
if ((pSSeriviceProperties != null && pSSeriviceProperties.MinuteMetrics != null) || (serviceProperties != null && serviceProperties.MinuteMetrics != null))
{
Assert.AreEqual(serviceProperties.MinuteMetrics.Version, pSSeriviceProperties.MinuteMetrics.Version);
Assert.AreEqual(serviceProperties.MinuteMetrics.MetricsLevel, pSSeriviceProperties.MinuteMetrics.MetricsLevel);
Assert.AreEqual(serviceProperties.MinuteMetrics.RetentionDays, pSSeriviceProperties.MinuteMetrics.RetentionDays);
}
if ((pSSeriviceProperties != null && pSSeriviceProperties.Logging != null) || (serviceProperties != null && serviceProperties.Logging != null))
{
Assert.AreEqual(serviceProperties.Logging.Version, pSSeriviceProperties.Logging.Version);
Assert.AreEqual(serviceProperties.Logging.LoggingOperations, pSSeriviceProperties.Logging.LoggingOperations);
Assert.AreEqual(serviceProperties.Logging.RetentionDays, pSSeriviceProperties.Logging.RetentionDays);
}
if ((pSSeriviceProperties != null && pSSeriviceProperties.Cors != null) || (serviceProperties != null && serviceProperties.Cors != null))
{
CompareCors(pSSeriviceProperties.Cors, serviceProperties.Cors);
}
if ((pSSeriviceProperties != null && pSSeriviceProperties.DefaultServiceVersion != null) || (serviceProperties != null && serviceProperties.DefaultServiceVersion != null))
{
Assert.AreEqual(serviceProperties.DefaultServiceVersion, pSSeriviceProperties.DefaultServiceVersion);
}
if ((pSSeriviceProperties != null && pSSeriviceProperties.DeleteRetentionPolicy != null) || (serviceProperties != null && serviceProperties.DeleteRetentionPolicy != null))
{
Assert.AreEqual(serviceProperties.DeleteRetentionPolicy.Enabled, pSSeriviceProperties.DeleteRetentionPolicy.Enabled);
Assert.AreEqual(serviceProperties.DeleteRetentionPolicy.RetentionDays, pSSeriviceProperties.DeleteRetentionPolicy.RetentionDays);
}
if ((pSSeriviceProperties != null && pSSeriviceProperties.StaticWebsite != null) || (serviceProperties != null && serviceProperties.StaticWebsite != null))
{
Assert.AreEqual(serviceProperties.StaticWebsite.Enabled, pSSeriviceProperties.StaticWebsite.Enabled);
Assert.AreEqual(serviceProperties.StaticWebsite.IndexDocument, pSSeriviceProperties.StaticWebsite.IndexDocument);
Assert.AreEqual(serviceProperties.StaticWebsite.ErrorDocument404Path, pSSeriviceProperties.StaticWebsite.ErrorDocument404Path);
}
}
public Task SetServicePropertiesAsync(ServiceProperties properties, TableRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken)
{
return(cloudTableClientImplementation.SetServicePropertiesAsync(properties, requestOptions, operationContext, cancellationToken));
}
public static void MyClassInitialize(TestContext testContext)
{
CloudBlobClient client = GenerateCloudBlobClient();
startProperties = client.GetServiceProperties();
}
/// <summary>
/// Sets the properties of the queue service.
/// </summary>
/// <param name="properties">The queue service properties.</param>
public void SetServiceProperties(ServiceProperties properties)
{
TaskImplHelper.ExecuteImplWithRetry(() => this.SetServicePropertiesImpl(properties), this.RetryPolicy);
}
public Task SetServicePropertiesAsync(ServiceProperties properties)
/// <summary>
/// Begins an asynchronous operation to set the properties of the queue service.
/// </summary>
/// <param name="properties">The queue service properties.</param>
/// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
/// <param name="state">A user defined object to be passed to the callback delegate.</param>
/// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
public IAsyncResult BeginSetServiceProperties(ServiceProperties properties, AsyncCallback callback, object state)
{
return(TaskImplHelper.BeginImplWithRetry(() => this.SetServicePropertiesImpl(properties), this.RetryPolicy, callback, state));
}
/// <summary>
/// Generates a task sequence for setting the properties of the blob service.
/// </summary>
/// <param name="properties">The blob service properties to set.</param>
/// <returns>A task sequence that sets the properties of the blob service.</returns>
private TaskSequence SetServicePropertiesImpl(ServiceProperties properties)
{
CommonUtils.AssertNotNull("properties", properties);
HttpWebRequest request = BlobRequest.SetServiceProperties(this.BaseUri, this.Timeout.RoundUpToSeconds());
using (MemoryStream memoryStream = new MemoryStream())
{
try
{
BlobRequest.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
StorageTask<Stream> getStreamTask = request.GetRequestStreamAsyncEx();
yield return getStreamTask;
using (Stream requestStream = getStreamTask.Result)
{
// Upload the service properties.
StorageTask<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.
StorageTask<WebResponse> responseTask = request.GetResponseAsyncWithTimeout(this, this.Timeout);
yield return responseTask;
// Materialize any exceptions.
using (HttpWebResponse response = responseTask.Result as HttpWebResponse)
{
}
}
public virtual Task SetServicePropertiesAsync(ServiceProperties properties)
{
return(this.SetServicePropertiesAsync(properties, null /* options */, null /* operationContext */));
}
/// <summary>
/// Begins an asynchronous operation to set the properties of the blob service.
/// </summary>
/// <param name="properties">The blob service properties.</param>
/// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
/// <param name="state">A user defined object to be passed to the callback delegate.</param>
/// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
public IAsyncResult BeginSetServiceProperties(ServiceProperties properties, AsyncCallback callback, object state)
{
return TaskImplHelper.BeginImplWithRetry(() => this.SetServicePropertiesImpl(properties), this.RetryPolicy, callback, state);
}
private async static Task AddDeviceAsync()
{
Device device;
try
{
device = await registryManager.AddDeviceAsync(new Device(deviceId));
if (string.IsNullOrEmpty(tags) == false)
{
ServiceProperties sps = new ServiceProperties();
sps.Tags.AddRange(tags.Split(','));
sps.ETag = device.ServiceProperties.ETag;
var properties = await registryManager.SetServicePropertiesAsync(deviceId, sps);
}
//device = await registryManager.GetDeviceAsync(deviceId);
}
catch (DeviceAlreadyExistsException)
{
device = await registryManager.GetDeviceAsync(deviceId);
}
deviceKey = device.Authentication.SymmetricKey.SecondaryKey;
Log($"device id {deviceId} : {deviceKey}");
Log($"Device Tags:{string.Join(",",device.ServiceProperties.Tags)}");
}
