/// <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;
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;
account.CreateCloudFileClient().SetServiceProperties(fileServiceProperties, (FileRequestOptions)options, operationContext);
break;
default:
throw new ArgumentException(Resources.InvalidStorageServiceType, "type");
}
}
/// <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;
}
}
private RESTCommand <NullType> SetServicePropertiesImpl(FileServiceProperties properties, FileRequestOptions 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, this.HttpClient);
requestOptions.ApplyToStorageCommand(retCmd);
retCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => FileHttpRequestMessageFactory.SetServiceProperties(uri, serverTimeout, cnt, ctx, this.GetCanonicalizer(), this.Credentials);
retCmd.BuildContent = (cmd, ctx) => HttpContentFactory.BuildContentFromStream(memoryStream, 0, memoryStream.Length, Checksum.None, cmd, ctx);
retCmd.StreamToDispose = memoryStream;
retCmd.RetrieveResponseStream = true;
retCmd.PreProcessResponse =
(cmd, resp, ex, ctx) =>
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Accepted, resp, null /* retVal */, cmd, ex);
requestOptions.ApplyToStorageCommand(retCmd);
return(retCmd);
}
public virtual ICancellableAsyncResult BeginSetServiceProperties(FileServiceProperties properties, FileRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state)
{
requestOptions = FileRequestOptions.ApplyDefaults(requestOptions, this);
operationContext = operationContext ?? new OperationContext();
return(CancellableAsyncResultTaskWrapper.Create(token => this.SetServicePropertiesAsync(properties, requestOptions, operationContext), callback, state));
}
/// <summary>
/// The <see cref="SetPropertiesInternal"/> operation sets properties for
/// a storage account’s File service endpoint, including properties
/// for Storage Analytics, CORS (Cross-Origin Resource Sharing) rules
/// and soft delete settings. You can also use this operation to set
/// the default request version for all incoming requests to the File
/// service that do not have a version specified.
///
/// For more information, see <see href="https://docs.microsoft.com/en-us/rest/api/storageservices/set-file-service-properties"/>.
/// </summary>
/// <param name="properties">The file service properties.</param>
/// <param name="async">
/// Whether to invoke the operation asynchronously.
/// </param>
/// <param name="cancellationToken">
/// Optional <see cref="CancellationToken"/> to propagate
/// notifications that the operation should be cancelled.
/// </param>
/// <returns>
/// A <see cref="Response"/> if the operation was successful.
/// </returns>
/// <remarks>
/// A <see cref="StorageRequestFailedException"/> will be thrown if
/// a failure occurs.
/// </remarks>
private async Task <Response> SetPropertiesInternal(
FileServiceProperties properties,
bool async,
CancellationToken cancellationToken)
{
using (this.Pipeline.BeginLoggingScope(nameof(FileServiceClient)))
{
this.Pipeline.LogMethodEnter(
nameof(FileServiceClient),
message: $"{nameof(this.Uri)}: {this.Uri}");
try
{
return(await FileRestClient.Service.SetPropertiesAsync(
this.Pipeline,
this.Uri,
properties : properties,
async : async,
operationName : Constants.File.Service.SetPropertiesOperationName,
cancellationToken : cancellationToken)
.ConfigureAwait(false));
}
catch (Exception ex)
{
this.Pipeline.LogException(ex);
throw;
}
finally
{
this.Pipeline.LogMethodExit(nameof(FileServiceClient));
}
}
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
// Check input parameter
// ShareRetentionDays should only be specified when EnableShareDeleteRetentionPolicy is true
if (this.enableShareDeleteRetentionPolicy == null || this.enableShareDeleteRetentionPolicy.Value == false)
{
if (this.ShareRetentionDays != 0)
{
throw new ArgumentException("ShareRetentionDays should only be specified when EnableShareDeleteRetentionPolicy is true.");
}
}
else
{
if (this.ShareRetentionDays == 0)
{
throw new ArgumentException("ShareRetentionDays must be specified when EnableShareDeleteRetentionPolicy is true.");
}
}
if (ShouldProcess("FileServiceProperties", "Update"))
{
switch (ParameterSetName)
{
case AccountObjectParameterSet:
this.ResourceGroupName = StorageAccount.ResourceGroupName;
this.StorageAccountName = StorageAccount.StorageAccountName;
break;
case PropertiesResourceIdParameterSet:
ResourceIdentifier blobServicePropertiesResource = new ResourceIdentifier(ResourceId);
this.ResourceGroupName = blobServicePropertiesResource.ResourceGroupName;
this.StorageAccountName = PSBlobServiceProperties.GetStorageAccountNameFromResourceId(ResourceId);
break;
default:
// For AccountNameParameterSet, the ResourceGroupName and StorageAccountName can get from input directly
break;
}
DeleteRetentionPolicy deleteRetentionPolicy = null;
if (this.enableShareDeleteRetentionPolicy != null)
{
deleteRetentionPolicy = new DeleteRetentionPolicy();
deleteRetentionPolicy.Enabled = this.enableShareDeleteRetentionPolicy.Value;
if (this.enableShareDeleteRetentionPolicy.Value == true)
{
deleteRetentionPolicy.Days = ShareRetentionDays;
}
}
FileServiceProperties serviceProperties = this.StorageClient.FileServices.SetServiceProperties(this.ResourceGroupName, this.StorageAccountName,
new FileServiceProperties(shareDeleteRetentionPolicy: deleteRetentionPolicy));
// Get all File service properties from server for output
serviceProperties = this.StorageClient.FileServices.GetServiceProperties(this.ResourceGroupName, this.StorageAccountName);
WriteObject(new PSFileServiceProperties(serviceProperties));
}
}
/// <summary>
/// The <see cref="SetPropertiesAsync"/> operation sets properties for
/// a storage account’s File service endpoint, including properties
/// for Storage Analytics, CORS (Cross-Origin Resource Sharing) rules
/// and soft delete settings. You can also use this operation to set
/// the default request version for all incoming requests to the File
/// service that do not have a version specified.
///
/// For more information, see <see href="https://docs.microsoft.com/en-us/rest/api/storageservices/set-file-service-properties"/>.
/// </summary>
/// <param name="properties">The file service properties.</param>
/// <param name="cancellation">
/// Optional <see cref="CancellationToken"/> to propagate
/// notifications that the operation should be cancelled.
/// </param>
/// <returns>
/// A <see cref="Task{Response}"/> if the operation was successful.
/// </returns>
/// <remarks>
/// A <see cref="StorageRequestFailedException"/> will be thrown if
/// a failure occurs.
/// </remarks>
public async Task <Response> SetPropertiesAsync(
FileServiceProperties properties,
CancellationToken cancellation = default)
{
using (this._pipeline.BeginLoggingScope(nameof(FileServiceClient)))
{
this._pipeline.LogMethodEnter(
nameof(FileServiceClient),
message: $"{nameof(this.Uri)}: {this.Uri}");
try
{
return(await FileRestClient.Service.SetPropertiesAsync(
this._pipeline,
this.Uri,
properties : properties,
cancellation : cancellation)
.ConfigureAwait(false));
}
catch (Exception ex)
{
this._pipeline.LogException(ex);
throw;
}
finally
{
this._pipeline.LogMethodExit(nameof(FileServiceClient));
}
}
}
internal static void AssertFileServicePropertiesAreEqual(FileServiceProperties propsA, FileServiceProperties propsB)
{
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);
}
}
private RESTCommand <NullType> SetServicePropertiesImpl(FileServiceProperties properties, FileRequestOptions requestOptions)
{
MultiBufferMemoryStream str = new MultiBufferMemoryStream(null /* bufferManager */, (int)(1 * Constants.KB));
try
{
properties.WriteServiceProperties(str);
}
catch (InvalidOperationException invalidOpException)
{
str.Dispose();
throw new ArgumentException(invalidOpException.Message, "properties");
}
str.Seek(0, SeekOrigin.Begin);
RESTCommand <NullType> retCmd = new RESTCommand <NullType>(this.Credentials, this.StorageUri);
retCmd.SendStream = str;
retCmd.StreamToDispose = str;
retCmd.BuildRequestDelegate = FileHttpWebRequestFactory.SetServiceProperties;
retCmd.RecoveryAction = RecoveryActions.RewindStream;
retCmd.SignRequest = this.AuthenticationHandler.SignRequest;
retCmd.PreProcessResponse =
(cmd, resp, ex, ctx) =>
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Accepted, resp, NullType.Value, cmd, ex);
requestOptions.ApplyToStorageCommand(retCmd);
return(retCmd);
}
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;
}
}
/// <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 ServiceProperties GetStorageServiceProperties(StorageServiceType type, IRequestOptions options, OperationContext operationContext)
{
CloudStorageAccount account = StorageContext.StorageAccount;
switch (type)
{
case StorageServiceType.Blob:
return(account.CreateCloudBlobClient().GetServiceProperties((BlobRequestOptions)options, operationContext));
case StorageServiceType.Queue:
return(account.CreateCloudQueueClient().GetServiceProperties((QueueRequestOptions)options, operationContext));
case StorageServiceType.Table:
return(account.CreateCloudTableClient().GetServiceProperties((TableRequestOptions)options, operationContext));
case StorageServiceType.File:
FileServiceProperties fileServiceProperties = account.CreateCloudFileClient().GetServiceProperties((FileRequestOptions)options, operationContext);
ServiceProperties sp = new ServiceProperties();
sp.Clean();
sp.Cors = fileServiceProperties.Cors;
sp.HourMetrics = fileServiceProperties.HourMetrics;
sp.MinuteMetrics = fileServiceProperties.MinuteMetrics;
return(sp);
default:
throw new ArgumentException(Resources.InvalidStorageServiceType, "type");
}
}
public void CloudFileTestAnalyticsRoundTripAPM()
{
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);
}
FileServiceProperties 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.AssertFileServicePropertiesAreEqual(props, retrievedProps);
}
/// <summary>
/// The <see cref="SetPropertiesAsync"/> operation sets properties for
/// a storage account’s File service endpoint, including properties
/// for Storage Analytics, CORS (Cross-Origin Resource Sharing) rules
/// and soft delete settings. You can also use this operation to set
/// the default request version for all incoming requests to the File
/// service that do not have a version specified.
///
/// For more information, see <see href="https://docs.microsoft.com/en-us/rest/api/storageservices/set-file-service-properties"/>.
/// </summary>
/// <param name="properties">The file service properties.</param>
/// <param name="cancellationToken">
/// Optional <see cref="CancellationToken"/> to propagate
/// notifications that the operation should be cancelled.
/// </param>
/// <returns>
/// A <see cref="Response"/> if the operation was successful.
/// </returns>
/// <remarks>
/// A <see cref="StorageRequestFailedException"/> will be thrown if
/// a failure occurs.
/// </remarks>
public virtual async Task <Response> SetPropertiesAsync(
FileServiceProperties properties,
CancellationToken cancellationToken = default) =>
await this.SetPropertiesInternal(
properties,
true, // async
cancellationToken)
.ConfigureAwait(false);
/// <summary>
/// The <see cref="SetProperties"/> operation sets properties for
/// a storage account’s File service endpoint, including properties
/// for Storage Analytics, CORS (Cross-Origin Resource Sharing) rules
/// and soft delete settings. You can also use this operation to set
/// the default request version for all incoming requests to the File
/// service that do not have a version specified.
///
/// For more information, see <see href="https://docs.microsoft.com/en-us/rest/api/storageservices/set-file-service-properties"/>.
/// </summary>
/// <param name="properties">The file service properties.</param>
/// <param name="cancellationToken">
/// Optional <see cref="CancellationToken"/> to propagate
/// notifications that the operation should be cancelled.
/// </param>
/// <returns>
/// A <see cref="Response"/> if the operation was successful.
/// </returns>
/// <remarks>
/// A <see cref="StorageRequestFailedException"/> will be thrown if
/// a failure occurs.
/// </remarks>
public virtual Response SetProperties(
FileServiceProperties properties,
CancellationToken cancellationToken = default) =>
this.SetPropertiesInternal(
properties,
false, // async
cancellationToken)
.EnsureCompleted();
private static FileServiceProperties DefaultServiceProperties()
{
FileServiceProperties props = new FileServiceProperties();
props.Cors.CorsRules = new List <CorsRule>();
return(props);
}
public void MyTestInitialize()
{
props = DefaultServiceProperties();
if (TestBase.FileBufferManager != null)
{
TestBase.FileBufferManager.OutstandingBufferCount = 0;
}
}
public virtual void SetServiceProperties(FileServiceProperties properties, FileRequestOptions requestOptions = null, OperationContext operationContext = null)
{
requestOptions = FileRequestOptions.ApplyDefaults(requestOptions, this);
operationContext = operationContext ?? new OperationContext();
Executor.ExecuteSync(
this.SetServicePropertiesImpl(properties, requestOptions),
requestOptions.RetryPolicy,
operationContext);
}
public PSFileServiceProperties(FileServiceProperties policy)
{
this.ResourceGroupName = (new ResourceIdentifier(policy.Id)).ResourceGroupName;
this.StorageAccountName = PSBlobServiceProperties.GetStorageAccountNameFromResourceId(policy.Id);
this.Id = policy.Id;
this.Name = policy.Name;
this.Type = policy.Type;
this.Cors = policy.Cors is null ? null : new PSCorsRules(policy.Cors);
this.ShareDeleteRetentionPolicy = policy.ShareDeleteRetentionPolicy is null ? null : new PSDeleteRetentionPolicy(policy.ShareDeleteRetentionPolicy);
}
public virtual Task SetServicePropertiesAsync(FileServiceProperties properties, FileRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken)
{
requestOptions = FileRequestOptions.ApplyDefaults(requestOptions, this);
operationContext = operationContext ?? new OperationContext();
return(Executor.ExecuteAsync(
this.SetServicePropertiesImpl(properties, requestOptions),
requestOptions.RetryPolicy,
operationContext,
cancellationToken));
}
private static FileServiceProperties DefaultServiceProperties()
{
FileServiceProperties props = new FileServiceProperties(new MetricsProperties(), new MetricsProperties(), new CorsProperties());
props.MinuteMetrics.Version = Constants.AnalyticsConstants.MetricsVersionV1;
props.HourMetrics.Version = Constants.AnalyticsConstants.MetricsVersionV1;
props.Cors.CorsRules = new List <CorsRule>();
return(props);
}
public virtual Task SetServicePropertiesAsync(FileServiceProperties properties, FileRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken)
{
FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(requestOptions, this);
operationContext = operationContext ?? new OperationContext();
return(Task.Run(async() => await Executor.ExecuteAsyncNullReturn(
this.SetServicePropertiesImpl(properties, modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
cancellationToken), cancellationToken));
}
public IAsyncAction SetServicePropertiesAsync(FileServiceProperties properties, FileRequestOptions requestOptions, OperationContext operationContext)
{
FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(requestOptions, this);
operationContext = operationContext ?? new OperationContext();
return(AsyncInfo.Run(async(token) => await Executor.ExecuteAsyncNullReturn(
this.SetServicePropertiesImpl(properties, modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
token)));
}
public virtual ICancellableAsyncResult BeginSetServiceProperties(FileServiceProperties properties, FileRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state)
{
requestOptions = FileRequestOptions.ApplyDefaults(requestOptions, this);
operationContext = operationContext ?? new OperationContext();
return(Executor.BeginExecuteAsync(
this.SetServicePropertiesImpl(properties, requestOptions),
requestOptions.RetryPolicy,
operationContext,
callback,
state));
}
public void FileServiceTest()
{
var handler = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var resourcesClient = StorageManagementTestUtilities.GetResourceManagementClient(context, handler);
var storageMgmtClient = StorageManagementTestUtilities.GetStorageManagementClient(context, handler);
// Create resource group
var rgName = StorageManagementTestUtilities.CreateResourceGroup(resourcesClient);
// Create storage account
string accountName = TestUtilities.GenerateName("sto");
var parameters = new StorageAccountCreateParameters
{
Sku = new Sku {
Name = SkuName.PremiumLRS
},
Kind = Kind.FileStorage,
Location = "centraluseuap"
};
var account = storageMgmtClient.StorageAccounts.Create(rgName, accountName, parameters);
// implement case
try
{
// Get after account create
FileServiceProperties properties1 = storageMgmtClient.FileServices.GetServiceProperties(rgName, accountName);
Assert.Equal(0, properties1.Cors.CorsRulesProperty.Count);
//Set and validated
FileServiceProperties properties2 = new FileServiceProperties();
properties2.ProtocolSettings = new ProtocolSettings();
properties2.ProtocolSettings.Smb = new SmbSetting();
properties2.ProtocolSettings.Smb.Multichannel = new Multichannel(true);
FileServiceProperties properties3 = storageMgmtClient.FileServices.SetServiceProperties(rgName, accountName, properties2);
Assert.True(properties3.ProtocolSettings.Smb.Multichannel.Enabled);
// Get and validate
FileServiceProperties properties4 = storageMgmtClient.FileServices.GetServiceProperties(rgName, accountName);
Assert.True(properties3.ProtocolSettings.Smb.Multichannel.Enabled);
}
finally
{
// clean up
storageMgmtClient.StorageAccounts.Delete(rgName, accountName);
resourcesClient.ResourceGroups.Delete(rgName);
}
}
}
private static void AssertPropertiesAreEqual(FileServiceProperties fileProps, ServiceProperties props)
{
if (fileProps == null || props == null)
{
Assert.IsNull(fileProps);
Assert.IsNull(props);
}
else
{
Assert.AreEqual(fileProps.Cors, props.Cors);
Assert.AreEqual(fileProps.MinuteMetrics, props.MinuteMetrics);
Assert.AreEqual(fileProps.HourMetrics, props.HourMetrics);
}
}
internal static void AssertFileServicePropertiesAreEqual(FileServiceProperties propsA, FileServiceProperties propsB)
{
if (propsA == null || propsB == null)
{
Assert.IsNull(propsA);
Assert.IsNull(propsB);
}
else
{
AssertPropertiesAreEqual(propsA, propsA.serviceProperties);
AssertPropertiesAreEqual(propsB, propsB.serviceProperties);
AssertServicePropertiesAreEqual(propsA.serviceProperties, propsB.serviceProperties);
}
}
private static FileServiceProperties DefaultServiceProperties()
{
FileServiceProperties props = new FileServiceProperties();
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 static FileServiceProperties DefaultServiceProperties()
{
FileServiceProperties props = new FileServiceProperties(new MetricsProperties(), new MetricsProperties(), new CorsProperties());
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";
#if !FACADE_NETCORE
props.Cors.CorsRules = new List <CorsRule>();
#endif
return(props);
}
public async Task CloudFileTestAnalyticsRoundTripAsync()
{
FileServiceProperties props = DefaultServiceProperties();
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"
}
});
props.MinuteMetrics.MetricsLevel = MetricsLevel.Service;
props.MinuteMetrics.RetentionDays = 8;
props.HourMetrics.MetricsLevel = MetricsLevel.None;
props.HourMetrics.RetentionDays = 1;
CloudFileClient client = GenerateCloudFileClient();
await client.SetServicePropertiesAsync(props);
TestHelper.AssertFileServicePropertiesAreEqual(props, await client.GetServicePropertiesAsync());
}
public void Troubleshooting_File_storage_using_metrics()
{
// Parse your storage connection string from your application's configuration file.
StorageCredentials Credentials = new StorageCredentials(this.Account, this.Key);
CloudStorageAccount storageAccount = new CloudStorageAccount(Credentials, false);
// Create the File service client.
CloudFileClient fileClient = storageAccount.CreateCloudFileClient();
// Set metrics properties for File service.
// Note that the File service currently uses its own service properties type,
// available in the Microsoft.WindowsAzure.Storage.File.Protocol namespace.
fileClient.SetServiceProperties(new FileServiceProperties()
{
// Set hour metrics
HourMetrics = new MetricsProperties()
{
MetricsLevel = MetricsLevel.ServiceAndApi,
RetentionDays = 14,
Version = "1.0"
},
// Set minute metrics
MinuteMetrics = new MetricsProperties()
{
MetricsLevel = MetricsLevel.ServiceAndApi,
RetentionDays = 7,
Version = "1.0"
}
});
// Read the metrics properties we just set.
FileServiceProperties serviceProperties = fileClient.GetServiceProperties();
Console.WriteLine("Hour metrics:");
Console.WriteLine(serviceProperties.HourMetrics.MetricsLevel);
Console.WriteLine(serviceProperties.HourMetrics.RetentionDays);
Console.WriteLine(serviceProperties.HourMetrics.Version);
Console.WriteLine();
Console.WriteLine("Minute metrics:");
Console.WriteLine(serviceProperties.MinuteMetrics.MetricsLevel);
Console.WriteLine(serviceProperties.MinuteMetrics.RetentionDays);
Console.WriteLine(serviceProperties.MinuteMetrics.Version);
}
