private HttpResponseMessage TrySending(HttpRequestMessage request, HttpRequestMessageRequestDetails requestDetails, PipelineOptions options)
{
var adapter = _adapterFactory.CreateClient(options);
HttpResponseMessage response;
try
{
response = adapter.SendAsync(request).Result;
}
catch (AggregateException exception)
{
if (SendError != null)
{
requestDetails = requestDetails ?? new HttpRequestMessageRequestDetails(request);
SendError(this, new RequestErrorEventArgs(requestDetails, exception.InnerException));
}
if (exception.InnerException is TaskCanceledException)
{
throw new TimeoutException("The request timed out");
}
throw exception.InnerException;
}
if (Responded != null)
{
requestDetails = requestDetails ?? new HttpRequestMessageRequestDetails(request);
Responded(this, new ResponseEventArgs(requestDetails, new HttpResponseMessageResponseDetails(requestDetails, response)));
}
ApplyPipelineToResponse(response, options);
options.AssertAllRequestResponseOptionsWereUsed();
return response;
}
public HttpClientAdapter CreateClient(PipelineOptions options)
{
AutoRedirect redirectOption = null;
options.Use<AutoRedirect>(option => {
redirectOption = option;
});
return new SystemNetHttpClientAdapter(redirectOption);
}
public Response Send(HttpMethod method, string uri, BodyContent body, params PipelineOption[] overridingPipelineOptions)
{
var combinedOptions = new PipelineOptions(DefaultPipelineOptions.Concat(_ambientPipelineOptions.Concat(overridingPipelineOptions)));
HttpRequestMessageRequestDetails requestDetails;
var request = CreateRequestMessage(method, uri, body, combinedOptions, out requestDetails);
var response = TrySending(request, requestDetails, combinedOptions);
return new SubordinateResource(response, response.RequestMessage.RequestUri, _adapterFactory, _ambientPipelineOptions);
}
public HttpClientAdapter CreateClient(PipelineOptions options)
{
var adapterOptions = new AdapterOptions
{
AutoRedirect = AutoRedirect.AutoRedirectButDoNotForwardAuthorizationHeader,
CachePolicy = new CachePolicy {Cache = false},
AcceptEncoding = new AcceptEncoding {AcceptGzipAndDeflate = true}
};
options.Use<AutoRedirect>(option => { adapterOptions.AutoRedirect = option; });
options.Use<CachePolicy>(option => { adapterOptions.CachePolicy = option; });
options.Use<AcceptEncoding>(option => { adapterOptions.AcceptEncoding = option; });
return CreateClient(adapterOptions);
}
public async Task ConfiguringRetries()
{
// specify retry policy options
var options = new PipelineOptions();
options.RetryPolicy = RetryPolicy.CreateFixed(
maxRetries: 10,
delay: TimeSpan.FromSeconds(1),
retriableCodes: new int[] {
500, // Internal Server Error
504 // Gateway Timeout
}
);
var connectionString = Environment.GetEnvironmentVariable("AZ_CONFIG_CONNECTION");
// pass the policy options to the client
var client = new ConfigurationClient(connectionString, options);
await client.SetAsync(new ConfigurationSetting("some_key", "some_value"));
await client.DeleteAsync("some_key");
}
public void PipelineBuilder_BuildFromConfiguration_AssemblyServices_NotAvailable()
{
var element = new ElementOptions()
{
BuilderName = "RequiredService"
};
// Create configuration object.
PipelineOptions opts = new PipelineOptions();
opts.Elements = new List <ElementOptions>
{
element
};
// Pass the configuration to the builder to create the pipeline.
var pipeline = new PipelineBuilder(_loggerFactory, new FiftyOneServiceProvider())
.BuildFromConfiguration(opts);
Assert.IsNotNull(pipeline.GetElement <RequiredServiceElement>().LoggerFactory);
Assert.IsNull(pipeline.GetElement <RequiredServiceElement>().Service);
Assert.IsNull(pipeline.GetElement <RequiredServiceElement>().UpdateService);
}
public void Basics()
{
var options = new PipelineOptions();
options.Transport = new MockTransport(500, 1);
options.RetryPolicy = new CustomRetryPolicy();
var listener = new TestEventListener();
listener.EnableEvents(EventLevel.LogAlways);
var pipeline = HttpPipeline.Create(options, "test", "1.0.0");
using (var message = pipeline.CreateMessage(options, cancellation: default))
{
message.SetRequestLine(PipelineMethod.Get, new Uri("https://contoso.a.io"));
pipeline.ProcessAsync(message).Wait();
Assert.AreEqual(1, message.Response.Status);
var result = listener.ToString();
Assert.AreEqual(expected, result);
}
}
/// <summary>
/// The default <see cref="IPipeline"/> factory function.
/// This looks for a 'PipelineOptions' configuration item and uses
/// that to build the pipeline.
/// </summary>
/// <param name="config">
/// The application configuration object
/// </param>
/// <param name="pipelineBuilder">
/// a pipeline builder instance to use when constructing the
/// <see cref="IPipeline"/>.
/// </param>
/// <returns>
/// A new <see cref="IPipeline"/> instance
/// </returns>
private static IPipeline CreatePipelineFromConfig(
IConfiguration config,
IPipelineBuilderFromConfiguration pipelineBuilder)
{
// Get Pipeline options to check that it is present
PipelineOptions options = new PipelineOptions();
config.Bind("PipelineOptions", options);
if (options == null ||
options.Elements == null ||
options.Elements.Count == 0)
{
throw new PipelineConfigurationException(
Messages.ExceptionNoConfiguration);
}
PipelineWebIntegrationOptions webOptions = new PipelineWebIntegrationOptions();
config.Bind("PipelineWebIntegrationOptions", webOptions);
// Add the sequence element.
AddSequenceElement(options);
if (webOptions.ClientSideEvidenceEnabled)
{
// Client-side evidence is enabled so make sure the
// JsonBuilderElement and JavaScriptBundlerElement has been
// included.
AddJsElements(options);
}
// Add the SetHeaders element
AddSetHeadersElement(options);
return(pipelineBuilder.BuildFromConfiguration(options));
}
public HttpClientAdapter CreateClient(PipelineOptions options)
{
return(new AlwaysThrowsOnSendingAdapter());
}
private HttpResponseMessage TrySending(HttpRequestMessage request, HttpRequestMessageRequestDetails requestDetails, PipelineOptions options)
{
var adapter = _adapterFactory.CreateClient(options);
HttpResponseMessage response;
try
{
response = adapter.SendAsync(request).Result;
}
catch (AggregateException exception)
{
if (SendError != null)
{
requestDetails = requestDetails ?? new HttpRequestMessageRequestDetails(request);
SendError(this, new RequestErrorEventArgs(requestDetails, exception.InnerException));
}
if (exception.InnerException is TaskCanceledException)
{
throw new TimeoutException("The request timed out");
}
throw exception.InnerException;
}
if (Responded != null)
{
requestDetails = requestDetails ?? new HttpRequestMessageRequestDetails(request);
Responded(this, new ResponseEventArgs(requestDetails, new HttpResponseMessageResponseDetails(requestDetails, response)));
}
ApplyPipelineToResponse(response, options);
options.AssertAllRequestResponseOptionsWereUsed();
return(response);
}
public sealed override PipelineCallContext CreateContext(PipelineOptions options, CancellationToken cancellation) => new Context(cancellation);
public HttpClientAdapter CreateClient(PipelineOptions options)
{
return new AlwaysThrowsOnSendingAdapter();
}
public HttpClientAdapter CreateClient(PipelineOptions options)
{
return _adapter;
}
public void ApplyToResponse(HttpResponseMessage response, PipelineOptions pipelineOptions)
{
pipelineOptions.Use<ExpectResponseHeaders>(option => AssertResponseHeadersAreExpected(option, response.AllHeadersAsStrings()));
}
public void ApplyToResponse(HttpResponseMessage response, PipelineOptions pipelineOptions)
{
}
/// <summary>
/// The default <see cref="IPipeline"/> factory function.
/// This looks for a 'PipelineOptions' configuration item and uses
/// that to build the pipeline.
/// </summary>
/// <param name="config">
/// The application configuration object
/// </param>
/// <param name="pipelineBuilder">
/// a pipeline builder instance to use when constructing the
/// <see cref="IPipeline"/>.
/// </param>
/// <returns>
/// A new <see cref="IPipeline"/> instance
/// </returns>
private static IPipeline CreatePipelineFromConfig(
IConfiguration config,
IPipelineBuilderFromConfiguration pipelineBuilder)
{
// Get Pipeline options to check that it is present
PipelineOptions options = new PipelineOptions();
config.Bind("PipelineOptions", options);
if (options == null ||
options.Elements == null ||
options.Elements.Count == 0)
{
throw new PipelineConfigurationException(
Messages.ExceptionNoConfiguration);
}
PipelineWebIntegrationOptions webOptions = new PipelineWebIntegrationOptions();
config.Bind("PipelineWebIntegrationOptions", webOptions);
// Add the sequence element.
var sequenceConfig = options.Elements.Where(e =>
e.BuilderName.Contains(nameof(SequenceElement),
StringComparison.OrdinalIgnoreCase));
if (sequenceConfig.Any() == false)
{
// The sequence element is not included so add it.
// Make sure it's added as the first element.
options.Elements.Insert(0, new ElementOptions()
{
BuilderName = nameof(SequenceElement)
});
}
if (webOptions.ClientSideEvidenceEnabled)
{
// Client-side evidence is enabled so make sure the
// JsonBuilderElement and JavaScriptBundlerElement has been
// included.
var jsonConfig = options.Elements.Where(e =>
e.BuilderName.Contains(nameof(JsonBuilderElement),
StringComparison.OrdinalIgnoreCase));
var javascriptConfig = options.Elements.Where(e =>
e.BuilderName.Contains(nameof(JavaScriptBuilderElement),
StringComparison.OrdinalIgnoreCase));
var jsIndex = javascriptConfig.Any() ?
options.Elements.IndexOf(javascriptConfig.First()) : -1;
if (jsonConfig.Any() == false)
{
// The json builder is not included so add it.
var newElementOptions = new ElementOptions()
{
BuilderName = nameof(JsonBuilderElement)
};
if (jsIndex > -1)
{
// There is already a javascript builder element
// so insert the json builder before it.
options.Elements.Insert(jsIndex, newElementOptions);
}
else
{
options.Elements.Add(newElementOptions);
}
}
if (jsIndex == -1)
{
// The builder is not included so add it.
options.Elements.Add(new ElementOptions()
{
BuilderName = nameof(JavaScriptBuilderElement),
BuildParameters = new Dictionary <string, object>()
{
{ "EnableCookies", true }
}
});
}
}
return(pipelineBuilder.BuildFromConfiguration(options));
}
public HttpClientAdapter CreateClient(PipelineOptions options)
{
return(_adapter);
}
public CnieltsPipeline1(PipelineOptions options) : base(options)
{
}
public Pipeline(IServiceProvider services, PipelineOptions options)
{
_services = services;
_options = options;
}
public void ApplyToRequest(HttpRequestMessage request, PipelineOptions pipelineOptions)
{
pipelineOptions.Use <BasicAuth>(auth => AddAuthorizationHeader(request, auth.Username, auth.Password));
}
public void ApplyToResponse(HttpResponseMessage response, PipelineOptions pipelineOptions)
{
StatusAcceptability acceptable = new ExpectStatusNotInRange(400, 599);
pipelineOptions.Use<StatusAcceptability>(option => { acceptable = option; });
AssertResponseHasAcceptableStatus(response, acceptable);
}
public void ApplyToResponse(HttpResponseMessage response, PipelineOptions pipelineOptions)
{
}
public abstract PipelineCallContext CreateContext(PipelineOptions options, CancellationToken cancellation);
public void ApplyToRequest(HttpRequestMessage request, PipelineOptions pipelineOptions)
{
pipelineOptions.Use<BasicAuth>(auth => AddAuthorizationHeader(request, auth.Username, auth.Password));
}
public void ApplyToRequest(HttpRequestMessage request, PipelineOptions pipelineOptions)
{
pipelineOptions.UseAll <SetRequestHeaders>(options => AddRequestHeaders(request, options));
}
public MockSocketMessage(ref PipelineOptions options, CancellationToken cancellation, byte[][] responses)
: base(ref options, cancellation)
{
_responses = responses;
}
public void ApplyToRequest(HttpRequestMessage request, PipelineOptions pipelineOptions)
{
}
private void ApplyPipelineToResponse(HttpResponseMessage response, PipelineOptions options)
{
foreach (var element in _pipeline)
{
element.ApplyToResponse(response, options);
}
}
public abstract HttpMessage CreateMessage(PipelineOptions options, CancellationToken cancellation);
public Message(ref PipelineOptions client, CancellationToken cancellation)
: base(cancellation)
{
}
public ConfigurationClient(string connectionString, PipelineOptions options)
{
_options = options;
Pipeline = ClientPipeline.Create(_options, SdkName, SdkVersion);
ParseConnectionString(connectionString, out _baseUri, out _credential, out _secret);
}
public Context(ref PipelineOptions client, CancellationToken cancellation)
: base(cancellation)
{
}
private HttpRequestMessage CreateRequestMessage(HttpMethod method, string uri, BodyContent body, PipelineOptions options,
out HttpRequestMessageRequestDetails requestDetails)
{
var absoluteUri = AbsoluteUrlOf(uri);
var request = new HttpRequestMessage();
ApplyPipelineToRequest(request, options);
if (body != null)
{
var content = new StreamContent(body.AsStream());
foreach (var header in body.Headers)
{
content.Headers.Add(header.Key, header.Value);
}
request.Content = content;
}
request.RequestUri = absoluteUri;
request.Method = method;
requestDetails = null;
if (Sending != null)
{
requestDetails = new HttpRequestMessageRequestDetails(request);
Sending(this, new RequestEventArgs(requestDetails));
}
return(request);
}
/// <summary>
/// Register a <see cref="EventPipeline"/> Factory to the Server
/// </summary>
/// <param name="factory"></param>
/// <param name="options"></param>
public void Register(Func <EventPipeline> factory, PipelineOptions options)
{
_server.Register(_pipelineId, factory, options);
}
private void ApplyPipelineToRequest(HttpRequestMessage request, PipelineOptions options)
{
foreach (var element in _pipeline)
{
element.ApplyToRequest(request, options);
}
}
public void ApplyToRequest(HttpRequestMessage request, PipelineOptions pipelineOptions)
{
pipelineOptions.UseAll<SetRequestHeaders>(options => AddRequestHeaders(request, options));
pipelineOptions.UseAll<ComputeRequestHeaders>(options => AddRequestHeaders(request, options));
}
private HttpRequestMessage CreateRequestMessage(HttpMethod method, string uri, BodyContent body, PipelineOptions options,
out HttpRequestMessageRequestDetails requestDetails)
{
var absoluteUri = AbsoluteUrlOf(uri);
var request = new HttpRequestMessage();
ApplyPipelineToRequest(request, options);
if (body != null)
{
var content = new StreamContent(body.AsStream());
if (body.MediaType != null)
{
content.Headers.ContentType = new MediaTypeHeaderValue(body.MediaType);
}
request.Content = content;
}
request.RequestUri = absoluteUri;
request.Method = method;
requestDetails = null;
if (Sending != null)
{
requestDetails = new HttpRequestMessageRequestDetails(request);
Sending(this, new RequestEventArgs(requestDetails));
}
return request;
}
public void ApplyToResponse(HttpResponseMessage response, PipelineOptions pipelineOptions)
{
pipelineOptions.Use <ExpectResponseHeaders>(option => AssertResponseHeadersAreExpected(option, response.AllHeadersAsStrings()));
}
public FaceClient(string baseUri, string key, PipelineOptions options)
: this(new Uri(baseUri), key, options)
{
}
public void ApplyToRequest(HttpRequestMessage request, PipelineOptions pipelineOptions)
{
}
