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