/// <summary>
/// Creates a pipeline to use for processing sub-operations before they
/// are combined into a single multipart request.
/// </summary>
/// <param name="pipeline">
/// The pipeline used to submit the live request.
/// </param>
/// <param name="authenticationPolicy">
/// An optional <see cref="HttpPipelinePolicy"/> used to authenticate
/// the sub-operations.
/// </param>
/// <param name="serviceVersion">
/// The serviceVersion used when generating sub-requests.
/// </param>
/// <returns>A pipeline to use for processing sub-operations.</returns>
private static HttpPipeline CreateBatchPipeline(
HttpPipeline pipeline,
HttpPipelinePolicy authenticationPolicy,
BlobClientOptions.ServiceVersion serviceVersion)
{
// Configure the options to use minimal policies
var options = new BlobClientOptions(serviceVersion);
options.Diagnostics.IsLoggingEnabled = false;
options.Diagnostics.IsTelemetryEnabled = false;
options.Diagnostics.IsDistributedTracingEnabled = false;
options.Retry.MaxRetries = 0;
// Use an empty transport so requests aren't sent
options.Transport = new BatchPipelineTransport(pipeline);
// Use the same authentication mechanism
return(HttpPipelineBuilder.Build(
options,
RemoveVersionHeaderPolicy.Shared,
authenticationPolicy));
}
/// <summary>
/// Initializes a new instance of the <see cref="DataLakeServiceClient"/>
/// class.
/// </summary>
/// <param name="serviceUri">
/// A <see cref="Uri"/> referencing the Data Lake service.
/// </param>
/// <param name="authentication">
/// An optional authentication policy used to sign requests.
/// </param>
/// <param name="options">
/// Optional client options that define the transport pipeline
/// policies for authentication, retries, etc., that are applied to
/// every request.
/// </param>
/// <param name="clientDiagnostics"></param>
/// <param name="storageSharedKeyCredential">
/// The shared key credential used to sign requests.
/// </param>
internal DataLakeServiceClient(
Uri serviceUri,
HttpPipelinePolicy authentication,
DataLakeClientOptions options,
ClientDiagnostics clientDiagnostics,
StorageSharedKeyCredential storageSharedKeyCredential)
{
Argument.AssertNotNull(serviceUri, nameof(serviceUri));
options ??= new DataLakeClientOptions();
_pipeline = options.Build(authentication);
_uri = serviceUri;
_blobUri = new DataLakeUriBuilder(serviceUri).ToBlobUri();
_version = options.Version;
_clientDiagnostics = clientDiagnostics ?? new ClientDiagnostics(options);
_storageSharedKeyCredential = storageSharedKeyCredential;
_blobServiceClient = BlobServiceClientInternals.Create(
_blobUri,
_pipeline,
authentication,
Version.AsBlobsVersion(),
_clientDiagnostics);
}
/// <summary> Initializes a new instance of WebPubSubServiceClient. </summary>
/// <param name="endpoint"> server parameter. </param>
/// <param name="hub"> Target hub name, which should start with alphabetic characters and only contain alpha-numeric characters or underscore. </param>
/// <param name="credential"> A credential used to authenticate to an Azure Service. </param>
/// <param name="options"> The options for configuring the client. </param>
public WebPubSubServiceClient(Uri endpoint, string hub, AzureKeyCredential credential, WebPubSubServiceClientOptions options)
: this(endpoint, hub, options)
{
Argument.AssertNotNull(credential, nameof(credential));
_credential = credential;
HttpPipelinePolicy[] perCallPolicies;
if (options.ReverseProxyEndpoint != null)
{
perCallPolicies = new HttpPipelinePolicy[] { new ReverseProxyPolicy(options.ReverseProxyEndpoint) };
}
else
{
perCallPolicies = Array.Empty <HttpPipelinePolicy>();
}
_pipeline = HttpPipelineBuilder.Build(
options,
perCallPolicies: perCallPolicies,
perRetryPolicies: new HttpPipelinePolicy[] { new WebPubSubAuthenticationPolicy(credential) },
new ResponseClassifier()
);
}
/// <summary> Initializes a new instance of WebPubSubServiceClient. </summary>
/// <param name="endpoint"> server parameter. </param>
/// <param name="hub"> Target hub name, which should start with alphabetic characters and only contain alpha-numeric characters or underscore. </param>
/// <param name="credential"> A token credential used to authenticate to an Azure Service. </param>
/// <param name="options"> The options for configuring the client. </param>
public WebPubSubServiceClient(Uri endpoint, string hub, TokenCredential credential, WebPubSubServiceClientOptions options)
: this(endpoint, hub, options)
{
Argument.AssertNotNull(credential, nameof(credential));
_tokenCredential = credential;
HttpPipelinePolicy[] perCallPolicies;
if (options.ReverseProxyEndpoint != null)
{
perCallPolicies = new HttpPipelinePolicy[] { new ReverseProxyPolicy(options.ReverseProxyEndpoint), new LowLevelCallbackPolicy() };
}
else
{
perCallPolicies = new HttpPipelinePolicy[] { new LowLevelCallbackPolicy() };
}
_pipeline = HttpPipelineBuilder.Build(
options,
perCallPolicies: perCallPolicies,
perRetryPolicies: new HttpPipelinePolicy[] { new BearerTokenAuthenticationPolicy(credential, WebPubSubServiceClientOptions.CredentialScopeName) },
new ResponseClassifier()
);
}
internal TableServiceClient(Uri endpoint, TableSharedKeyPipelinePolicy policy, AzureSasCredential sasCredential, TableClientOptions options)
{
Argument.AssertNotNull(endpoint, nameof(endpoint));
_endpoint = endpoint;
options ??= new TableClientOptions();
_isCosmosEndpoint = IsPremiumEndpoint(endpoint);
var perCallPolicies = _isCosmosEndpoint ? new[] { new CosmosPatchTransformPolicy() } : Array.Empty <HttpPipelinePolicy>();
var endpointString = endpoint.AbsoluteUri;
string secondaryEndpoint = TableConnectionString.GetSecondaryUriFromPrimary(endpoint)?.AbsoluteUri;
HttpPipelinePolicy authPolicy = sasCredential switch
{
null => policy,
_ => new AzureSasCredentialSynchronousPolicy(sasCredential)
};
HttpPipeline pipeline = HttpPipelineBuilder.Build(options, perCallPolicies: perCallPolicies, perRetryPolicies: new[] { authPolicy }, new ResponseClassifier());
_version = options.VersionString;
_diagnostics = new TablesClientDiagnostics(options);
_tableOperations = new TableRestClient(_diagnostics, pipeline, endpointString, _version);
_serviceOperations = new ServiceRestClient(_diagnostics, pipeline, endpointString, _version);
_secondaryServiceOperations = new ServiceRestClient(_diagnostics, pipeline, secondaryEndpoint, _version);
}
protected async Task <Response> SendGetRequest(HttpPipelineTransport transport, HttpPipelinePolicy policy, ResponseClassifier responseClassifier = null)
{
using Request request = transport.CreateRequest();
request.Method = RequestMethod.Get;
request.UriBuilder.Uri = new Uri("http://example.com");
return(await SendRequestAsync(transport, request, policy, responseClassifier));
}
protected async Task <Response> SendRequestAsync(HttpPipelineTransport transport, Request request, HttpPipelinePolicy policy, ResponseClassifier responseClassifier = null)
{
await Task.Yield();
var pipeline = new HttpPipeline(transport, new [] { policy }, responseClassifier);
return(await SendRequestAsync(pipeline, request, CancellationToken.None));
}
protected static async Task <Response> SendGetRequest(HttpPipelineTransport transport, HttpPipelinePolicy policy, ResponseClassifier responseClassifier = null)
{
Assert.IsInstanceOf <HttpPipelineSynchronousPolicy>(policy, "Use SyncAsyncPolicyTestBase base type for non-sync policies");
using (Request request = transport.CreateRequest())
{
request.Method = RequestMethod.Get;
request.Uri.Reset(new Uri("http://example.com"));
var pipeline = new HttpPipeline(transport, new[] { policy }, responseClassifier);
return(await pipeline.SendRequestAsync(request, CancellationToken.None));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DataLakeServiceClient"/>
/// class.
/// </summary>
/// <param name="serviceUri">
/// A <see cref="Uri"/> referencing the Data Lake service
/// </param>
/// <param name="authentication">
/// An optional authentication policy used to sign requests.
/// </param>
/// <param name="options">
/// Optional client options that define the transport pipeline
/// policies for authentication, retries, etc., that are applied to
/// every request.
/// </param>
internal DataLakeServiceClient(Uri serviceUri, HttpPipelinePolicy authentication, DataLakeClientOptions options)
: this(serviceUri, authentication, options, null)
{
}
protected static Task <Response> SendGetRequest(HttpPipelineTransport transport, HttpPipelinePolicy policy)
{
using (HttpPipelineRequest request = transport.CreateRequest(null))
{
request.Method = HttpPipelineMethod.Get;
request.Uri = new Uri("http://example.com");
var pipeline = new HttpPipeline(transport, new [] { policy });
return(pipeline.SendRequestAsync(request, CancellationToken.None));
}
}
protected async Task <Response> SendGetRequest(HttpPipelineTransport transport, HttpPipelinePolicy policy, ResponseClassifier responseClassifier = null, bool bufferResponse = true, Uri uri = null, CancellationToken cancellationToken = default)
{
return(await SendRequestAsync(transport, request =>
{
request.Method = RequestMethod.Get;
request.Uri.Reset(uri ?? new Uri("http://example.com"));
}, policy, responseClassifier, bufferResponse, cancellationToken));
}
/// <summary>
/// Initializes a new instance of the <see cref="QueueServiceClient"/>
/// class.
/// </summary>
/// <param name="serviceUri">
/// A <see cref="Uri"/> referencing the queue service.
/// </param>
/// <param name="authentication">
/// An optional authentication policy used to sign requests.
/// </param>
/// <param name="options">
/// Optional client options that define the transport pipeline
/// policies for authentication, retries, etc., that are applied to
/// every request.
/// </param>
internal QueueServiceClient(Uri serviceUri, HttpPipelinePolicy authentication, QueueClientOptions options)
{
_uri = serviceUri;
options ??= new QueueClientOptions();
_pipeline = options.Build(authentication);
}
protected Task <Response> SendRequestAsync(HttpPipelineTransport transport, Action <Request> requestAction, HttpPipelinePolicy policy, ResponseClassifier responseClassifier = null, bool bufferResponse = true, CancellationToken cancellationToken = default)
{
return(SendRequestAsync(transport, message => requestAction(message.Request), policy, responseClassifier, bufferResponse, cancellationToken));
}
/// <summary>
/// Create an HttpPipeline from DataLakeClientOptions.
/// </summary>
/// <param name="authentication">Optional authentication policy.</param>
/// <returns>An HttpPipeline to use for Storage requests.</returns>
internal HttpPipeline Build(HttpPipelinePolicy authentication = null)
{
return(this.Build(authentication, GeoRedundantSecondaryUri));
}
protected static Task <Response> SendRequest(MockTransport mockTransport, HttpPipelinePolicy policy, ResponseClassifier responseClassifier)
{
return(SendGetRequest(mockTransport, policy, responseClassifier));
}
public ConfigurationClientOptions()
{
LoggingPolicy = Base.Http.Pipeline.LoggingPolicy.Shared;
RetryPolicy = s_defaultRetryPolicy;
}
protected async Task <Response> SendGetRequest(HttpPipelineTransport transport, HttpPipelinePolicy policy, ResponseClassifier responseClassifier = null, bool bufferResponse = true)
{
return(await SendRequestAsync(transport, request =>
{
request.Method = RequestMethod.Get;
request.Uri.Reset(new Uri("http://example.com"));
}, policy, responseClassifier, bufferResponse));
}
protected async Task <Response> SendGetRequest(HttpPipelineTransport transport, HttpPipelinePolicy policy, ResponseClassifier responseClassifier = null)
{
await Task.Yield();
using (Request request = transport.CreateRequest())
{
request.Method = HttpPipelineMethod.Get;
request.UriBuilder.Uri = new Uri("http://example.com");
var pipeline = new HttpPipeline(transport, new [] { policy }, responseClassifier);
return(await SendRequestAsync(pipeline, request, CancellationToken.None));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DirectoryClient"/>
/// class.
/// </summary>
/// <param name="directoryUri">
/// A <see cref="Uri"/> referencing the directory that includes the
/// name of the account, the name of the file system, and the path of the
/// directory.
/// </param>
/// <param name="authentication">
/// An optional authentication policy used to sign requests.
/// </param>
/// <param name="options">
/// Optional client options that define the transport pipeline
/// policies for authentication, retries, etc., that are applied to
/// every request.
/// </param>
internal DirectoryClient(Uri directoryUri, HttpPipelinePolicy authentication, DataLakeClientOptions options)
: base(directoryUri, authentication, options)
{
}
protected async Task <Response> SendRequestAsync(HttpPipelineTransport transport, Action <Request> requestAction, HttpPipelinePolicy policy, ResponseClassifier responseClassifier = null, bool bufferResponse = true, CancellationToken cancellationToken = default)
{
await Task.Yield();
var pipeline = new HttpPipeline(transport, new[] { policy }, responseClassifier);
return(await SendRequestAsync(pipeline, requestAction, bufferResponse, cancellationToken));
}
public static void AddPolicy(this BlobClientOptions options, HttpPipelinePolicy policy, HttpPipelinePosition position)
{
options.AddPolicy(position, policy);
}
/// <summary>
/// Initializes a new instance of the <see cref="FileServiceClient"/>
/// class.
/// </summary>
/// <param name="serviceUri">
/// A <see cref="Uri"/> referencing the file service.
/// </param>
/// <param name="authentication">
/// An optional authentication policy used to sign requests.
/// </param>
/// <param name="options">
/// Optional client options that define the transport pipeline
/// policies for authentication, retries, etc., that are applied to
/// every request.
/// </param>
internal FileServiceClient(Uri serviceUri, HttpPipelinePolicy authentication, FileClientOptions options)
{
_uri = serviceUri;
_pipeline = (options ?? new FileClientOptions()).Build(authentication);
}
/// <summary>
/// Initializes a new instance of the <see cref="QueueServiceClient"/>
/// class.
/// </summary>
/// <param name="serviceUri">
/// A <see cref="Uri"/> referencing the queue service.
/// </param>
/// <param name="authentication">
/// An optional authentication policy used to sign requests.
/// </param>
/// <param name="options">
/// Optional client options that define the transport pipeline
/// policies for authentication, retries, etc., that are applied to
/// every request.
/// </param>
internal QueueServiceClient(Uri serviceUri, HttpPipelinePolicy authentication, QueueClientOptions options)
{
this._uri = serviceUri;
this._pipeline = (options ?? new QueueClientOptions()).Build(authentication);
}
/// <summary>
/// Creates a
/// </summary>
/// <param name="options"></param>
/// <param name="authenticationPolicy"></param>
/// <returns></returns>
private static HttpPipeline CreatePipeline(MobileDataClientOptions options, HttpPipelinePolicy authenticationPolicy)
=> HttpPipelineBuilder.Build(options,
new HttpPipelinePolicy[] { /* per-call policies */ },
new HttpPipelinePolicy[] { authenticationPolicy },
new ResponseClassifier());
