/// <summary> /// Initializes a new instance of the <see cref="FileServiceProperties"/> class. /// </summary> public FileServiceProperties() { this.serviceProperties = new ServiceProperties(); this.serviceProperties.HourMetrics = null; this.serviceProperties.MinuteMetrics = null; this.serviceProperties.Logging = null; }
public Task SetServiceProperties(ServiceProperties properties, BlobRequestOptions requestOptions = null, OperationContext operationContext = null, CancellationToken cancellationToken = default(CancellationToken)) { return AsyncTaskUtil.RunAsyncCancellable( _inner.BeginSetServiceProperties(properties, requestOptions, operationContext, null, null), _inner.EndSetServiceProperties, cancellationToken); }
public StorageSettings(string storageName, ServiceProperties serviceProperties) { InitializeComponent(); this.Icon = Bitmaps.Azure_Explorer_ico; labelStorageAccount.Text = string.Format(labelStorageAccount.Text, storageName); _serviceProperties = serviceProperties; }
public static void SetSerivceProperties(Constants.ServiceType serviceType, Microsoft.WindowsAzure.Storage.Shared.Protocol.ServiceProperties serviceProperties) { switch (serviceType) { case Constants.ServiceType.Blob: StorageAccount.CreateCloudBlobClient().SetServiceProperties(serviceProperties); break; case Constants.ServiceType.Queue: StorageAccount.CreateCloudQueueClient().SetServiceProperties(serviceProperties); break; case Constants.ServiceType.Table: StorageAccount.CreateCloudTableClient().SetServiceProperties(serviceProperties); break; case Constants.ServiceType.File: FileServiceProperties fileProperties = new FileServiceProperties(); fileProperties.Cors = serviceProperties.Cors; fileProperties.HourMetrics = serviceProperties.HourMetrics; fileProperties.MinuteMetrics = serviceProperties.MinuteMetrics; StorageAccount.CreateCloudFileClient().SetServiceProperties(fileProperties); break; } }
private void InitializeCors() { var tableServiceProperties = new ServiceProperties(); var tableClient = new CloudStorageAccount( new StorageCredentials( CloudConfigurationManager.GetSetting("storageAccountName"), CloudConfigurationManager.GetSetting("storageAccountKey")), true).CreateCloudTableClient(); tableServiceProperties.HourMetrics = null; tableServiceProperties.MinuteMetrics = null; tableServiceProperties.Logging = null; tableServiceProperties.Cors = new CorsProperties(); tableServiceProperties.Cors.CorsRules.Add(new CorsRule() { AllowedHeaders = new List<string>() { "*" }, AllowedMethods = CorsHttpMethods.Get | CorsHttpMethods.Head , //AllowedOrigins = new List<string>() { "http://ercenkbike.azurewebsites.net/" }, AllowedOrigins = new List<string>() { "*" }, ExposedHeaders = new List<string>() { "*" }, MaxAgeInSeconds = 1800 // 30 minutes }); tableClient.SetServiceProperties(tableServiceProperties); }
public void OverwriteExistingCORSRuleOfXSCL() { Action <Constants.ServiceType> setCORSRules = (serviceType) => { PSCorsRule[] corsRules = CORSRuleUtil.GetRandomValidCORSRules(random.Next(1, 5)); Microsoft.WindowsAzure.Storage.Shared.Protocol.ServiceProperties serviceProperties = new Microsoft.WindowsAzure.Storage.Shared.Protocol.ServiceProperties(); serviceProperties.Clean(); serviceProperties.Cors = new CorsProperties(); foreach (var rule in corsRules) { serviceProperties.Cors.CorsRules.Add(new CorsRule() { AllowedHeaders = rule.AllowedHeaders, AllowedOrigins = rule.AllowedOrigins, ExposedHeaders = rule.ExposedHeaders, MaxAgeInSeconds = rule.MaxAgeInSeconds, AllowedMethods = (CorsHttpMethods)random.Next(1, 512) }); } SetSerivceProperties(serviceType, serviceProperties); }; this.OverwriteCORSRules(setCORSRules, Constants.ServiceType.Blob); this.OverwriteCORSRules(setCORSRules, Constants.ServiceType.Queue); this.OverwriteCORSRules(setCORSRules, Constants.ServiceType.Table); this.OverwriteCORSRules(setCORSRules, Constants.ServiceType.File); }
/// <summary> /// Get the service properties /// </summary> /// <param name="account">Cloud storage account</param> /// <param name="type">Service type</param> /// <param name="options">Request options</param> /// <param name="operationContext">Operation context</param> /// <returns>The service properties of the specified service type</returns> public XSCLProtocol.ServiceProperties GetStorageServiceProperties(StorageServiceType type, IRequestOptions options, XSCL.OperationContext operationContext) { XSCL.CloudStorageAccount account = StorageContext.StorageAccount; try { switch (type) { case StorageServiceType.Blob: return(account.CreateCloudBlobClient().GetServicePropertiesAsync((BlobRequestOptions)options, operationContext).Result); case StorageServiceType.Queue: return(account.CreateCloudQueueClient().GetServicePropertiesAsync((QueueRequestOptions)options, operationContext).Result); case StorageServiceType.File: FileServiceProperties fileServiceProperties = account.CreateCloudFileClient().GetServicePropertiesAsync((FileRequestOptions)options, operationContext).Result; XSCLProtocol.ServiceProperties sp = new XSCLProtocol.ServiceProperties(); sp.Clean(); sp.Cors = fileServiceProperties.Cors; sp.HourMetrics = fileServiceProperties.HourMetrics; sp.MinuteMetrics = fileServiceProperties.MinuteMetrics; return(sp); default: throw new ArgumentException(Resources.InvalidStorageServiceType, "type"); } } catch (AggregateException e) when(e.InnerException is XSCL.StorageException) { throw e.InnerException; } }
public void MyTestInitialize() { props = DefaultServiceProperties(); if (TestBase.QueueBufferManager != null) { TestBase.QueueBufferManager.OutstandingBufferCount = 0; } }
public static void ClearCorsRules(Constants.ServiceType serviceType) { Microsoft.WindowsAzure.Storage.Shared.Protocol.ServiceProperties serviceProperties = new Microsoft.WindowsAzure.Storage.Shared.Protocol.ServiceProperties(); serviceProperties.Clean(); serviceProperties.Cors = new CorsProperties(); serviceProperties.Cors.CorsRules.Clear(); SetSerivceProperties(serviceType, serviceProperties); }
public static void MyClassInitialize(TestContext testContext) { CloudQueueClient client = GenerateCloudQueueClient(); startProperties = client.GetServiceProperties(); if (TestBase.QueueBufferManager != null) { TestBase.QueueBufferManager.OutstandingBufferCount = 0; } }
public override void ExecuteCmdlet() { ServiceProperties currentServiceProperties = Channel.GetStorageServiceProperties(ServiceType, GetRequestOptions(ServiceType), OperationContext); ServiceProperties serviceProperties = new ServiceProperties(); serviceProperties.Clean(); serviceProperties.Cors = currentServiceProperties.Cors; serviceProperties.Cors.CorsRules.Clear(); Channel.SetStorageServiceProperties(ServiceType, serviceProperties, GetRequestOptions(ServiceType), OperationContext); }
private void ConfigureCors(ServiceProperties serviceProperties) { serviceProperties.Cors = new CorsProperties(); serviceProperties.Cors.CorsRules.Add(new CorsRule { AllowedHeaders = new[] { "*" }, AllowedMethods = CorsHttpMethods.Get | CorsHttpMethods.Head, AllowedOrigins = new[] { "*" }, ExposedHeaders = new[] { "Cache-Control", "Content-Type", "Last-Modified", "ETag", "Accept-Ranges" }, MaxAgeInSeconds = 31536000 }); }
/// <summary> /// Adds CORS rule to the service properties. /// </summary> /// <param name="serviceProperties">ServiceProperties</param> private static void ConfigureCors(ServiceProperties serviceProperties) { serviceProperties.Cors = new CorsProperties(); serviceProperties.Cors.CorsRules.Add(new CorsRule() { AllowedHeaders = new List<string>() { "*" }, AllowedMethods = CorsHttpMethods.Put | CorsHttpMethods.Get | CorsHttpMethods.Head | CorsHttpMethods.Post, AllowedOrigins = new List<string>() { "*" }, ExposedHeaders = new List<string>() { "*" }, MaxAgeInSeconds = 1800 // 30 minutes }); }
/// <summary> /// Sets the properties of the table service asynchronously. /// </summary> /// <param name="tableClient">Cloud table client.</param> /// <param name="serviceProperties">The table service properties.</param> /// <param name="cancellationToken">Cancellation token.</param> /// <returns>Task.</returns> public static Task SetServicePropertiesAsync( this CloudTableClient tableClient, ServiceProperties serviceProperties, CancellationToken cancellationToken = default (CancellationToken)) { ICancellableAsyncResult asyncResult = tableClient.BeginSetServiceProperties(serviceProperties, null, null); CancellationTokenRegistration registration = cancellationToken.Register(p => asyncResult.Cancel(), null); return Task.Factory.FromAsync( asyncResult, result => { registration.Dispose(); tableClient.EndSetServiceProperties(result); }); }
public override void ExecuteCmdlet() { ServiceProperties serviceProperties = new ServiceProperties(); serviceProperties.Clean(); serviceProperties.Cors = new CorsProperties(); foreach (var corsRuleObject in this.CorsRules) { CorsRule corsRule = new CorsRule(); corsRule.AllowedHeaders = corsRuleObject.AllowedHeaders; corsRule.AllowedOrigins = corsRuleObject.AllowedOrigins; corsRule.ExposedHeaders = corsRuleObject.ExposedHeaders; corsRule.MaxAgeInSeconds = corsRuleObject.MaxAgeInSeconds; this.SetAllowedMethods(corsRule, corsRuleObject.AllowedMethods); serviceProperties.Cors.CorsRules.Add(corsRule); } try { Channel.SetStorageServiceProperties(ServiceType, serviceProperties, GetRequestOptions(ServiceType), OperationContext); } catch (StorageException se) { if ((null != se.RequestInformation) && ((int)HttpStatusCode.BadRequest == se.RequestInformation.HttpStatusCode) && (null != se.RequestInformation.ExtendedErrorInformation) && (string.Equals(InvalidXMLNodeValueError, se.RequestInformation.ExtendedErrorInformation.ErrorCode, StringComparison.OrdinalIgnoreCase) || string.Equals(InvalidXMLDocError, se.RequestInformation.ExtendedErrorInformation.ErrorCode, StringComparison.OrdinalIgnoreCase))) { throw new InvalidOperationException(Resources.CORSRuleError); } else { throw; } } if (PassThru) { WriteObject(this.CorsRules); } }
static void Main(string[] args) { StorageCredentials storageCredentials = new StorageCredentials(args[0], args[1]); CloudStorageAccount storageAccount = new CloudStorageAccount(storageCredentials, true); var blobClient = storageAccount.CreateCloudBlobClient(); // Define our basics for quick op ServiceProperties blobServiceProperties = new ServiceProperties() { HourMetrics = null, MinuteMetrics = null, Logging = null, }; // Define our CORS rules (wide open here) CorsRule corsRule = new CorsRule() { AllowedHeaders = new List<string>() { "*" }, AllowedMethods = CorsHttpMethods.Get | CorsHttpMethods.Post | CorsHttpMethods.Head | CorsHttpMethods.Put, AllowedOrigins = new List<string>() { "*" }, ExposedHeaders = new List<string>() { "*", "Accept-Ranges", "Content-Range"}, MaxAgeInSeconds = 7200 }; // Set our rule blobServiceProperties.Cors.CorsRules.Add(corsRule); try { blobClient.SetServiceProperties(blobServiceProperties); Console.Out.WriteLine("CORS is rollin' for " + args[0]); } catch (Exception e) { Console.Out.WriteLine(e.ToString()); } }
/// <summary> /// Set service properties /// </summary> /// <param name="account">Cloud storage account</param> /// <param name="type">Service type</param> /// <param name="properties">Service properties</param> /// <param name="options">Request options</param> /// <param name="operationContext">Operation context</param> public void SetStorageServiceProperties(StorageServiceType type, XSCLProtocol.ServiceProperties properties, IRequestOptions options, XSCL.OperationContext operationContext) { XSCL.CloudStorageAccount account = StorageContext.StorageAccount; try { switch (type) { case StorageServiceType.Blob: Task.Run(() => account.CreateCloudBlobClient().SetServicePropertiesAsync(properties, (BlobRequestOptions)options, operationContext)).Wait(); break; case StorageServiceType.Queue: Task.Run(() => account.CreateCloudQueueClient().SetServicePropertiesAsync(properties, (QueueRequestOptions)options, operationContext)).Wait(); break; case StorageServiceType.File: if (null != properties.Logging) { throw new InvalidOperationException(Resources.FileNotSupportLogging); } FileServiceProperties fileServiceProperties = new FileServiceProperties(); fileServiceProperties.Cors = properties.Cors; fileServiceProperties.HourMetrics = properties.HourMetrics; fileServiceProperties.MinuteMetrics = properties.MinuteMetrics; Task.Run(() => account.CreateCloudFileClient().SetServicePropertiesAsync(fileServiceProperties, (FileRequestOptions)options, operationContext)).Wait(); break; default: throw new ArgumentException(Resources.InvalidStorageServiceType, "type"); } } catch (AggregateException e) when(e.InnerException is XSCL.StorageException) { throw e.InnerException; } }
public void SetServiceProperties(ServiceProperties properties, BlobRequestOptions requestOptions = null, OperationContext operationContext = null) { requestOptions = BlobRequestOptions.ApplyDefaults(requestOptions, BlobType.Unspecified, this); operationContext = operationContext ?? new OperationContext(); Executor.ExecuteSync( this.SetServicePropertiesImpl(properties, requestOptions), requestOptions.RetryPolicy, operationContext); }
public ICancellableAsyncResult BeginSetServiceProperties(ServiceProperties properties, BlobRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state) { requestOptions = BlobRequestOptions.ApplyDefaults(requestOptions, BlobType.Unspecified, this); operationContext = operationContext ?? new OperationContext(); return Executor.BeginExecuteAsync( this.SetServicePropertiesImpl(properties, requestOptions), requestOptions.RetryPolicy, operationContext, callback, state); }
public ICancellableAsyncResult BeginSetServiceProperties(ServiceProperties properties, AsyncCallback callback, object state) { return this.BeginSetServiceProperties(properties, null /* requestOptions */, null /* operationContext */, callback, state); }
/// <summary> /// Constructs a <c>ServiceProperties</c> object from an XML document received from the service. /// </summary> /// <param name="servicePropertiesDocument">The XML document.</param> /// <returns>A <c>ServiceProperties</c> object containing the properties in the XML document.</returns> internal static ServiceProperties FromServiceXml(XDocument servicePropertiesDocument) { XElement servicePropertiesElement = servicePropertiesDocument.Element(StorageServicePropertiesName); ServiceProperties properties = new ServiceProperties { Logging = ReadLoggingPropertiesFromXml(servicePropertiesElement.Element(LoggingName)), HourMetrics = ReadMetricsPropertiesFromXml(servicePropertiesElement.Element(HourMetricsName)), MinuteMetrics = ReadMetricsPropertiesFromXml(servicePropertiesElement.Element(MinuteMetricsName)), Cors = ReadCorsPropertiesFromXml(servicePropertiesElement.Element(CorsName)) }; XElement defaultServiceVersionXml = servicePropertiesElement.Element(DefaultServiceVersionName); if (defaultServiceVersionXml != null) { properties.DefaultServiceVersion = defaultServiceVersionXml.Value; } return properties; }
public Task SetServicePropertiesAsync(ServiceProperties properties, TableRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken) { TableRequestOptions modifiedOptions = TableRequestOptions.ApplyDefaults(requestOptions, this); operationContext = operationContext ?? new OperationContext(); return Task.Run(async () => await Executor.ExecuteAsyncNullReturn( this.SetServicePropertiesImpl(properties, modifiedOptions), modifiedOptions.RetryPolicy, operationContext, cancellationToken), cancellationToken); }
/// <returns>An <see cref="IAsyncAction"/> that represents an asynchronous action.</returns> public IAsyncAction SetServicePropertiesAsync(ServiceProperties properties) #endif { return this.SetServicePropertiesAsync(properties, null /* RequestOptions */, null /* OperationContext */); }
public static void MyClassInitialize(TestContext testContext) { CloudTableClient tableClient = GenerateCloudTableClient(); startProperties = tableClient.GetServiceProperties(); }
private void AssertServicePropertiesAreEqual(ServiceProperties propsA, ServiceProperties propsB) { Assert.AreEqual(propsA.Logging.LoggingOperations, propsB.Logging.LoggingOperations); Assert.AreEqual(propsA.Logging.RetentionDays, propsB.Logging.RetentionDays); Assert.AreEqual(propsA.Logging.Version, propsB.Logging.Version); Assert.AreEqual(propsA.Metrics.MetricsLevel, propsB.Metrics.MetricsLevel); Assert.AreEqual(propsA.Metrics.RetentionDays, propsB.Metrics.RetentionDays); Assert.AreEqual(propsA.Metrics.Version, propsB.Metrics.Version); Assert.AreEqual(propsA.DefaultServiceVersion, propsB.DefaultServiceVersion); }
public void GetServiceProperties_AllService_AllProperties() { //prepare the service properties to set and get PSCorsRule[] corsRules = CORSRuleUtil.GetRandomValidCORSRules(random.Next(1, 5)); Microsoft.WindowsAzure.Storage.Shared.Protocol.ServiceProperties serviceProperties = new Microsoft.WindowsAzure.Storage.Shared.Protocol.ServiceProperties(); serviceProperties.Clean(); serviceProperties.Cors = new CorsProperties(); foreach (var rule in corsRules) { CorsRule corsRule = new CorsRule() { AllowedHeaders = rule.AllowedHeaders, AllowedOrigins = rule.AllowedOrigins, ExposedHeaders = rule.ExposedHeaders, MaxAgeInSeconds = rule.MaxAgeInSeconds, }; SetAllowedMethods(corsRule, rule.AllowedMethods); serviceProperties.Cors.CorsRules.Add(corsRule); } serviceProperties.HourMetrics = new MetricsProperties("1.0"); serviceProperties.HourMetrics.MetricsLevel = MetricsLevel.ServiceAndApi; serviceProperties.HourMetrics.RetentionDays = 1; serviceProperties.MinuteMetrics = new MetricsProperties("1.0"); serviceProperties.MinuteMetrics.MetricsLevel = MetricsLevel.Service; serviceProperties.MinuteMetrics.RetentionDays = 3; serviceProperties.Logging = new LoggingProperties("1.0"); serviceProperties.Logging.LoggingOperations = LoggingOperations.All; serviceProperties.Logging.RetentionDays = 5; foreach (string servicetype in ValidServiceType) { Constants.ServiceType service = Constants.ServiceType.Blob; Enum.TryParse <Constants.ServiceType>(servicetype, true, out service); if (service == Constants.ServiceType.Blob) //only Blob support default service version { serviceProperties.DefaultServiceVersion = "2017-04-17"; serviceProperties.DeleteRetentionPolicy = new DeleteRetentionPolicy(); serviceProperties.DeleteRetentionPolicy.Enabled = true; serviceProperties.DeleteRetentionPolicy.RetentionDays = 10; } //Set Service Properties with XSCL API ServiceCORSRule.SetSerivceProperties(service, serviceProperties); //Get Service Properties with PowerShell PSSeriviceProperties properties = GetServicePropertiesFromPSH(service); //Validate Cors, metric, logging CORSRuleUtil.ValidateCORSRules(corsRules, properties.Cors); if (service != Constants.ServiceType.File) // File service don't support logging { ExpectEqual(serviceProperties.Logging.Version, properties.Logging.Version, "Logging version"); ExpectEqual(serviceProperties.Logging.LoggingOperations.ToString(), properties.Logging.LoggingOperations.ToString(), "Logging Operations"); ExpectEqual(serviceProperties.Logging.RetentionDays.Value, properties.Logging.RetentionDays.Value, "Logging RetentionDays"); } ExpectEqual(serviceProperties.HourMetrics.Version, properties.HourMetrics.Version, "HourMetrics Version"); ExpectEqual(serviceProperties.HourMetrics.MetricsLevel.ToString(), properties.HourMetrics.MetricsLevel.ToString(), "HourMetrics MetricsLevel"); ExpectEqual(serviceProperties.HourMetrics.RetentionDays.Value, properties.HourMetrics.RetentionDays.Value, "HourMetrics RetentionDays"); ExpectEqual(serviceProperties.MinuteMetrics.Version, properties.MinuteMetrics.Version, "MinuteMetrics Version"); ExpectEqual(serviceProperties.MinuteMetrics.MetricsLevel.ToString(), properties.MinuteMetrics.MetricsLevel.ToString(), "MinuteMetrics MetricsLevel"); ExpectEqual(serviceProperties.MinuteMetrics.RetentionDays.Value, properties.MinuteMetrics.RetentionDays.Value, "MinuteMetrics RetentionDays"); if (service == Constants.ServiceType.Blob) { ExpectEqual(serviceProperties.DefaultServiceVersion, properties.DefaultServiceVersion, "DefaultServiceVersion"); ExpectEqual(serviceProperties.DeleteRetentionPolicy.Enabled.ToString(), properties.DeleteRetentionPolicy.Enabled.ToString(), "DeleteRetentionPolicy Enabled"); ExpectEqual(serviceProperties.DeleteRetentionPolicy.RetentionDays.Value, properties.DeleteRetentionPolicy.RetentionDays.Value, "DeleteRetentionPolicy RetentionDays"); serviceProperties.DeleteRetentionPolicy = null; serviceProperties.DefaultServiceVersion = null; } } }
private static ServiceProperties DefaultServiceProperties() { ServiceProperties props = new ServiceProperties(); props.Logging.LoggingOperations = LoggingOperations.None; props.Logging.RetentionDays = null; props.Logging.Version = "1.0"; props.HourMetrics.MetricsLevel = MetricsLevel.None; props.HourMetrics.RetentionDays = null; props.HourMetrics.Version = "1.0"; props.MinuteMetrics.MetricsLevel = MetricsLevel.None; props.MinuteMetrics.RetentionDays = null; props.MinuteMetrics.Version = "1.0"; props.Cors.CorsRules = new List<CorsRule>(); return props; }
private RESTCommand<NullType> SetServicePropertiesImpl(ServiceProperties properties, BlobRequestOptions requestOptions) { MemoryStream str = new MemoryStream(); try { properties.WriteServiceProperties(str); } catch (InvalidOperationException invalidOpException) { throw new ArgumentException(invalidOpException.Message, "properties"); } str.Seek(0, SeekOrigin.Begin); RESTCommand<NullType> retCmd = new RESTCommand<NullType>(this.Credentials, this.BaseUri); retCmd.SendStream = str; retCmd.BuildRequestDelegate = BlobHttpWebRequestFactory.SetServiceProperties; retCmd.RecoveryAction = RecoveryActions.RewindStream; retCmd.SignRequest = this.AuthenticationHandler.SignRequest; retCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(System.Net.HttpStatusCode.Accepted, resp, NullType.Value, cmd, ex, ctx); retCmd.ApplyRequestOptions(requestOptions); return retCmd; }
/// <returns>An <see cref="Task"/> that represents an asynchronous action.</returns> public Task SetServicePropertiesAsync(ServiceProperties properties)
internal bool CheckStorageAnalytics(string storageAccountName, ServiceProperties currentConfig) { if ((currentConfig == null) || (currentConfig.Logging == null) || ((currentConfig.Logging.LoggingOperations & LoggingOperations.All) != LoggingOperations.All) || (currentConfig.MinuteMetrics == null) || (currentConfig.MinuteMetrics.MetricsLevel <= 0) || (currentConfig.MinuteMetrics.RetentionDays < 0)) { WriteVerbose("Storage account {0} does not have the required metrics enabled", storageAccountName); return false; } WriteVerbose("Storage account {0} has required metrics enabled", storageAccountName); return true; }
public Task SetServicePropertiesAsync(ServiceProperties properties, TableRequestOptions requestOptions, OperationContext operationContext) { return this.SetServicePropertiesAsync(properties, requestOptions, operationContext, CancellationToken.None); }
/// <summary> /// Set service properties /// </summary> /// <param name="account">Cloud storage account</param> /// <param name="type">Service type</param> /// <param name="properties">Service properties</param> /// <param name="options">Request options</param> /// <param name="operationContext">Operation context</param> public void SetStorageServiceProperties(StorageServiceType type, ServiceProperties properties, IRequestOptions options, OperationContext operationContext) { CloudStorageAccount account = StorageContext.StorageAccount; switch (type) { case StorageServiceType.Blob: account.CreateCloudBlobClient().SetServiceProperties(properties, (BlobRequestOptions)options, operationContext); break; case StorageServiceType.Queue: account.CreateCloudQueueClient().SetServiceProperties(properties, (QueueRequestOptions)options, operationContext); break; case StorageServiceType.Table: account.CreateCloudTableClient().SetServiceProperties(properties, (TableRequestOptions)options, operationContext); break; default: throw new ArgumentException(Resources.InvalidStorageServiceType, "type"); } }
private RESTCommand<NullType> SetServicePropertiesImpl(ServiceProperties properties, TableRequestOptions requestOptions) { MultiBufferMemoryStream memoryStream = new MultiBufferMemoryStream(null /* bufferManager */, (int)(1 * Constants.KB)); try { properties.WriteServiceProperties(memoryStream); } catch (InvalidOperationException invalidOpException) { throw new ArgumentException(invalidOpException.Message, "properties"); } RESTCommand<NullType> retCmd = new RESTCommand<NullType>(this.Credentials, this.StorageUri); requestOptions.ApplyToStorageCommand(retCmd); retCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => TableHttpRequestMessageFactory.SetServiceProperties(uri, serverTimeout, cnt, ctx); retCmd.BuildContent = (cmd, ctx) => HttpContentFactory.BuildContentFromStream(memoryStream, 0, memoryStream.Length, null /* md5 */, cmd, ctx); retCmd.Handler = this.AuthenticationHandler; retCmd.BuildClient = HttpClientFactory.BuildHttpClient; retCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Accepted, resp, null /* retVal */, cmd, ex); requestOptions.ApplyToStorageCommand(retCmd); return retCmd; }
public IAsyncAction SetServicePropertiesAsync(ServiceProperties properties, BlobRequestOptions requestOptions, OperationContext operationContext) { BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(requestOptions, BlobType.Unspecified, this); operationContext = operationContext ?? new OperationContext(); return AsyncInfo.Run(async (token) => await Executor.ExecuteAsyncNullReturn( this.SetServicePropertiesImpl(properties, modifiedOptions), modifiedOptions.RetryPolicy, operationContext, token)); }
public static void MyClassInitialize(TestContext testContext) { client = GenerateCloudQueueClient(); startProperties = client.GetServicePropertiesAsync().AsTask().Result; }
public void CloudTableTestAnalyticsDefaultServiceVersionThrows() { CloudTableClient client = GenerateCloudTableClient(); OperationContext ctx = new OperationContext(); ServiceProperties props = new ServiceProperties(); props.DefaultServiceVersion = "2009-09-19"; props.Logging.LoggingOperations = LoggingOperations.None; props.Logging.Version = "1.0"; props.Metrics.MetricsLevel = MetricsLevel.None; props.Metrics.Version = "1.0"; try { client.SetServiceProperties(props, null, ctx); Assert.Fail("Should not be able to set default Service Version for non Blob Client"); } catch (StorageException ex) { Assert.AreEqual(ex.Message, "The remote server returned an error: (400) Bad Request."); Assert.AreEqual(ex.RequestInformation.HttpStatusCode, (int)HttpStatusCode.BadRequest); TestHelper.AssertNAttempts(ctx, 1); } catch (Exception) { Assert.Fail(); } }