/// <summary>
/// Creates an instance of the SplunkViaHttp context
/// </summary>
public SplunkContext(SplunkClient.Scheme scheme, string host, int port, string index, string username, string password, TimeSpan timeout, HttpMessageHandler handler, bool disposeHandler = true)
: base(scheme, host, port, timeout, handler, disposeHandler)
{
Index = index;
Username = username;
Password = password;
}
/// <summary>
/// Initializes a new instance of the <see cref="SumoLogicAppender"/> class.
/// </summary>
/// <param name="log">The log service.</param>
/// <param name="httpMessageHandler">The HTTP message handler.</param>
public SumoLogicAppender(SumoLogic.Logging.Common.Log.ILog log, HttpMessageHandler httpMessageHandler)
{
this.SourceName = "Log4Net-SumoObject";
this.ConnectionTimeout = 60000;
this.LogLog = log ?? new DummyLog();
this.HttpMessageHandler = httpMessageHandler;
}
public VkGroupMembersProvider(HttpMessageHandler httpMessageHandler, TimeSpan? maxIntervalBetweenApiRequest = null)
{
_httpMessageHandler = httpMessageHandler;
_maxIntervalBetweenApiRequest = maxIntervalBetweenApiRequest >= MaxIntervalBetweenApiRequestDefault
? maxIntervalBetweenApiRequest.Value
: MaxIntervalBetweenApiRequestDefault;
}
/// <summary>
/// Downloads an image at the provided URL and converts it to a valid Data Uri scheme (https://en.wikipedia.org/wiki/Data_URI_scheme)
/// </summary>
/// <param name="url">The url where the image is located.</param>
/// <param name="logger">A logger.</param>
/// <param name="fallbackFileInfo">A FileInfo to retrieve the local fallback image.</param>
/// <param name="fallbackMediaType">The media type of the fallback image.</param>
/// <param name="messageHandler">An optional message handler.</param>
/// <returns>A string that contains the data uri of the downloaded image, or a default image on any error.</returns>
public static async Task<string> DownloadImageAndConvertToDataUri(this string url, ILogger logger, IFileInfo fallbackFileInfo, string fallbackMediaType = "image/png", HttpMessageHandler messageHandler = null)
{
// exclude completely invalid URLs
if (!string.IsNullOrWhiteSpace(url))
{
try
{
// set a timeout to 10 seconds to avoid waiting on that forever
using (var client = new HttpClient(messageHandler) { Timeout = TimeSpan.FromSeconds(10) })
{
var response = await client.GetAsync(url);
response.EnsureSuccessStatusCode();
// set the media type and default to JPG if it wasn't provided
string mediaType = response.Content.Headers.ContentType?.MediaType;
mediaType = string.IsNullOrWhiteSpace(mediaType) ? "image/jpeg" : mediaType;
// return the data URI according to the standard
return (await response.Content.ReadAsByteArrayAsync()).ToDataUri(mediaType);
}
}
catch (Exception ex)
{
logger.LogInformation(0, ex, "Error while downloading resource");
}
}
// any error or invalid URLs just return the default data uri
return await fallbackFileInfo.ToDataUri(fallbackMediaType);
}
/// <summary>
/// Initializes a new instance of the <see cref="RetryHandler" /> class.
/// </summary>
/// <param name="innerHandler">The inner handler. (Usually new HttpClientHandler())</param>
/// <param name="maxRetries">The maximum retries.</param>
/// <param name="retryDelayMilliseconds">The retry delay milliseconds.</param>
/// <param name="logger">The optional logger to log error messages to.</param>
/// <remarks>
/// When only the auth0 token provider is injected, the auth0 token provider should try to extract the client id from the 401 response header.
/// </remarks>
public RetryHandler(HttpMessageHandler innerHandler, uint maxRetries = 1, uint retryDelayMilliseconds = 500, ILogger logger = null)
: base(innerHandler)
{
this.maxRetries = maxRetries;
this.retryDelayMilliseconds = retryDelayMilliseconds;
this.logger = logger;
}
public GoogleApi(string identifier, string clientId, string clientSecret, HttpMessageHandler handler = null) : base(identifier, CleanseClientId(clientId), clientSecret, handler)
{
this.TokenUrl = "https://accounts.google.com/o/oauth2/token";
#if __UNIFIED__
this.CurrentShowAuthenticator = NativeSafariAuthenticator.ShowAuthenticator;
#endif
}
public OAuthMessageHandler(HttpMessageHandler innerHandler, IHmacSha1HashProvider hashProvider, string consumerKey, string consumerSecret, Token oAuthToken)
: base(innerHandler)
{
if (hashProvider == null)
throw new ArgumentNullException("hashProvider");
if (consumerKey == null)
throw new ArgumentNullException("consumerKey");
if (consumerKey.Length == 0)
throw new ArgumentException("Consumer key cannot be empty.", "consumerKey");
if (consumerSecret == null)
throw new ArgumentNullException("consumerSecret");
if (consumerSecret.Length == 0)
throw new ArgumentException("Consumer secret cannot be empty.", "consumerSecret");
if(oAuthToken != null && !oAuthToken.IsValid)
throw new ArgumentException("OAuth token is not valid.", "oAuthToken");
if (consumerKey == null)
throw new ArgumentNullException("consumerKey");
this.hashProvider = hashProvider;
this.consumerKey = consumerKey;
this.consumerSecret = consumerSecret;
this.oAuthToken = oAuthToken;
}
public HttpWrapper(string baseUrl, ILog logger, Envelope envelope, HttpMessageHandler httpMessageHandler)
{
_logger = logger;
_envelope = envelope;
_baseUrl = new Uri(baseUrl);
_httpMessageHandler = httpMessageHandler ?? new HttpClientHandler();
}
protected DelegatingHandler(HttpMessageHandler innerHandler)
{
if (innerHandler == null)
throw new ArgumentNullException ("innerHandler");
InnerHandler = innerHandler;
}
/// <summary>
/// Configures API routes to expose sensors.
/// </summary>
/// <param name="configuration">The HTTP configuration.</param>
/// <param name="authorizeRequest">A delegate providing a method to authorize or deny sensor requests.</param>
/// <param name="baseUri">The base URI at which sensors will be routed.</param>
/// <param name="handler">An optional message handler to be invoked when sensors are called.</param>
/// <returns>
/// The updated <see cref="HttpConfiguration" />.
/// </returns>
/// <exception cref="System.ArgumentNullException">configuration
/// or
/// authorizeRequest</exception>
public static HttpConfiguration MapSensorRoutes(
this HttpConfiguration configuration,
Func<HttpActionContext, bool> authorizeRequest,
string baseUri = "sensors",
HttpMessageHandler handler = null)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (authorizeRequest == null)
{
throw new ArgumentNullException(nameof(authorizeRequest));
}
AuthorizeSensorsAttribute.AuthorizeRequest = authorizeRequest;
configuration.Routes.MapHttpRoute(
"Its-Log-Monitoring-Sensors",
baseUri.AppendSegment("{name}"),
defaults: new
{
controller = "Sensor",
name = RouteParameter.Optional
},
constraints: null,
handler: handler);
return configuration;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:SimpleAuth.OauthApiKeyApi"/> class.
/// </summary>
/// <param name="identifier">This is used to store and look up credentials/cookies for the API</param>
/// <param name="apiKey">API key.</param>
/// <param name="authKey">Auth key.</param>
/// <param name="authLocation">Auth location.(Header or Query)</param>
/// <param name="authenticator">OAuth Authenticator.</param>
/// <param name="handler">Handler.</param>
public OauthApiKeyApi(string identifier, string apiKey, string authKey, AuthLocation authLocation , OAuthAuthenticator authenticator, HttpMessageHandler handler = null) : base(identifier, authenticator, handler)
{
AuthLocation = authLocation;
AuthKey = authKey;
ApiKey = apiKey;
}
/// <summary>
/// Creates an instance of an <see cref="HttpMessageHandler"/> using the <see cref="DelegatingHandler"/> instances
/// provided by <paramref name="handlers"/>.
/// </summary>
/// <param name="handlers">An ordered list of <see cref="DelegatingHandler"/> instances to be invoked as an
/// <see cref="HttpRequestMessage"/> travels up the stack and an <see cref="HttpResponseMessage"/> travels down.</param>
/// <param name="innerChannel">The inner channel represents the destination of the HTTP message channel.</param>
/// <returns>The HTTP message channel.</returns>
public static HttpMessageHandler Create(IEnumerable<DelegatingHandler> handlers, HttpMessageHandler innerChannel)
{
if (innerChannel == null)
{
throw Error.ArgumentNull("innerChannel");
}
if (handlers == null)
{
return innerChannel;
}
// Wire handlers up
HttpMessageHandler pipeline = innerChannel;
foreach (DelegatingHandler handler in handlers)
{
if (handler == null)
{
throw Error.Argument("handlers", SRResources.DelegatingHandlerArrayContainsNullItem, typeof(DelegatingHandler).Name);
}
if (handler.InnerHandler != null)
{
throw Error.Argument("handlers", SRResources.DelegatingHandlerArrayHasNonNullInnerHandler, typeof(DelegatingHandler).Name, "InnerHandler", handler.GetType().Name);
}
handler.InnerHandler = pipeline;
pipeline = handler;
}
return pipeline;
}
protected virtual HttpClient MakeClient(HttpMessageHandler handler)
{
return new HttpClient(handler)
{
Timeout = TimeSpan.FromMilliseconds(int.MaxValue) // Longest TimeSpan HttpClient will accept
};
}
/// <summary>
/// Creates an instance of an <see cref="HttpMessageHandler"/> using the <see cref="DelegatingHandler"/> instances
/// provided by <paramref name="handlers"/>. The resulting pipeline can be used to manually create <see cref="HttpClient"/>
/// or <see cref="HttpMessageInvoker"/> instances with customized message handlers.
/// </summary>
/// <param name="innerHandler">The inner handler represents the destination of the HTTP message channel.</param>
/// <param name="handlers">An ordered list of <see cref="DelegatingHandler"/> instances to be invoked as part
/// of sending an <see cref="HttpRequestMessage"/> and receiving an <see cref="HttpResponseMessage"/>.
/// The handlers are invoked in a top-down fashion. That is, the first entry is invoked first for
/// an outbound request message but last for an inbound response message.</param>
/// <returns>The HTTP message channel.</returns>
public static HttpMessageHandler CreatePipeline(HttpMessageHandler innerHandler, IEnumerable<DelegatingHandler> handlers)
{
if (innerHandler == null)
{
throw Error.ArgumentNull("innerHandler");
}
if (handlers == null)
{
return innerHandler;
}
// Wire handlers up in reverse order starting with the inner handler
HttpMessageHandler pipeline = innerHandler;
IEnumerable<DelegatingHandler> reversedHandlers = handlers.Reverse();
foreach (DelegatingHandler handler in reversedHandlers)
{
if (handler == null)
{
throw Error.Argument("handlers", Properties.Resources.DelegatingHandlerArrayContainsNullItem, typeof(DelegatingHandler).Name);
}
if (handler.InnerHandler != null)
{
throw Error.Argument("handlers", Properties.Resources.DelegatingHandlerArrayHasNonNullInnerHandler, typeof(DelegatingHandler).Name, "InnerHandler", handler.GetType().Name);
}
handler.InnerHandler = pipeline;
pipeline = handler;
}
return pipeline;
}
public InstagramApi(string identifier, string clientId, string clientSecret, string redirectUrl, HttpMessageHandler handler = null)
: base(identifier, clientId, clientSecret, handler)
{
this.TokenUrl = "https://api.instagram.com/oauth/access_token";
this.RedirectUrl = new Uri(redirectUrl);
Scopes = new[] { "basic" };
}
public TwitterOAuthMessageHandler(OAuthCredential oAuthCredential, OAuthSignatureEntity signatureEntity,
TwitterQueryCollection parameters, HttpMessageHandler innerHandler)
: base(innerHandler)
{
//TODO: Parameters needs to come here as encoded so that they can be encoded twice
// for the signature base. Handle that.
//TODO: We don't even need to get parameters seperately. We can get them through
// query string and by reading the body but reading the body is a overhead here.
_oAuthState = new OAuthState() {
Credential = new OAuthCredentialState() {
ConsumerKey = oAuthCredential.ConsumerKey,
//encode it here first
CallbackUrl = OAuthUtil.PercentEncode(oAuthCredential.CallbackUrl),
Token = oAuthCredential.Token
},
SignatureEntity = new OAuthSignatureEntityState() {
ConsumerSecret = signatureEntity.ConsumerSecret,
TokenSecret = signatureEntity.TokenSecret
},
Parameters = parameters,
Nonce = GenerateNonce(),
SignatureMethod = GetOAuthSignatureMethod(),
Timestamp = GenerateTimestamp(),
Version = GetVersion()
};
}
public AsyncClient(
string auth,
int timeout,
ProductInfoHeaderValue userAgent,
HttpMessageHandler httpMessageHandler = null
)
{
_httpMessageHandler = httpMessageHandler ?? new HttpClientHandler();
try
{
_httpClient = new HttpClient(_httpMessageHandler)
{
DefaultRequestHeaders =
{
Authorization = new AuthenticationHeaderValue("Basic", auth),
Accept = {new MediaTypeWithQualityHeaderValue("application/json")},
UserAgent = {userAgent}
},
Timeout = TimeSpan.FromMilliseconds(timeout)
};
}
catch
{
_httpClient?.Dispose();
_httpMessageHandler.Dispose();
throw;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ServerCompressionHandler" /> class.
/// </summary>
/// <param name="innerHandler">The inner handler.</param>
/// <param name="contentSizeThreshold">The content size threshold before compressing.</param>
/// <param name="enableCompression">Custom delegate to enable or disable compression.</param>
/// <param name="compressors">The compressors.</param>
protected BaseServerCompressionHandler(HttpMessageHandler innerHandler, int contentSizeThreshold, Predicate<HttpRequestMessage> enableCompression, params ICompressor[] compressors)
{
if (innerHandler != null)
{
this.InnerHandler = innerHandler;
}
this.Compressors = compressors;
this.contentSizeThreshold = contentSizeThreshold;
this.httpContentOperations = new HttpContentOperations();
this.enableCompression = enableCompression ?? (x =>
{
// If request does not accept gzip or deflate, return false
if (x.Headers.AcceptEncoding.All(y => y.Value != "gzip" && y.Value != "deflate"))
{
return false;
}
// If compression has been explicitly disabled, return false
if (x.Properties.ContainsKey("compression:Enable"))
{
bool enable;
bool.TryParse(x.Properties["compression:Enable"].ToString(), out enable);
return enable;
}
return true;
});
}
/// <summary>
/// Used internally only for unit testing.
/// </summary>
/// <param name="innerHandler">The inner handler to retrieve the content from on cache misses.</param>
/// <param name="cacheExpirationPerHttpResponseCode">A mapping of HttpStatusCode to expiration times. If unspecified takes a default value.</param>
/// <param name="cache">The distributed cache to use.</param>
/// /// <param name="statsProvider">An <see cref="IStatsProvider"/> that records statistic information about the caching behavior.</param>
internal RedisCacheHandler(HttpMessageHandler innerHandler, IDictionary<HttpStatusCode, TimeSpan> cacheExpirationPerHttpResponseCode, IDistributedCache cache,
IStatsProvider statsProvider = null) : base(innerHandler ?? new HttpClientHandler())
{
this.StatsProvider = statsProvider ?? new StatsProvider(nameof(RedisCacheHandler));
this.cacheExpirationPerHttpResponseCode = cacheExpirationPerHttpResponseCode ?? new Dictionary<HttpStatusCode, TimeSpan>();
responseCache = cache;
}
public Task<IHalHttpClient> CreateClientAsync(HttpMessageHandler httpMessageHandler, CachingBehavior apiRootCachingBehavior = CachingBehavior.Never)
{
if (httpMessageHandler == null)
throw new ArgumentNullException(nameof(httpMessageHandler));
return CreateHalHttpClientAsync(GetHttpClient(httpMessageHandler), apiRootCachingBehavior);
}
public static IAppBuilder UseWebApiWithContainer(this IAppBuilder app, HttpConfiguration configuration, HttpMessageHandler dispatcher)
{
IServiceProvider appContainer = app.GetApplicationContainer();
configuration.DependencyResolver = new OwinDependencyResolverWebApiAdapter(appContainer);
HttpServer httpServer = new OwinDependencyScopeHttpServerAdapter(configuration, dispatcher);
return app.UseWebApi(httpServer);
}
public IHalHttpClient CreateClient(HttpMessageHandler httpMessageHandler)
{
if (httpMessageHandler == null)
throw new ArgumentNullException(nameof(httpMessageHandler));
return CreateHalHttpClient(GetHttpClient(httpMessageHandler));
}
public DurableSeqSink(
string serverUrl,
string bufferBaseFilename,
string apiKey,
int batchPostingLimit,
TimeSpan period,
long? bufferFileSizeLimitBytes,
long? eventBodyLimitBytes,
LoggingLevelSwitch levelControlSwitch,
HttpMessageHandler messageHandler,
long? retainedInvalidPayloadsLimitBytes)
{
if (serverUrl == null) throw new ArgumentNullException(nameof(serverUrl));
if (bufferBaseFilename == null) throw new ArgumentNullException(nameof(bufferBaseFilename));
_shipper = new HttpLogShipper(
serverUrl,
bufferBaseFilename,
apiKey,
batchPostingLimit,
period,
eventBodyLimitBytes,
levelControlSwitch,
messageHandler,
retainedInvalidPayloadsLimitBytes);
_sink = new RollingFileSink(
bufferBaseFilename + "-{Date}.json",
new RawJsonFormatter(),
bufferFileSizeLimitBytes,
null);
}
public HttpClient (HttpMessageHandler handler, bool disposeHandler)
: base (handler, disposeHandler)
{
buffer_size = int.MaxValue;
timeout = TimeoutDefault;
cts = new CancellationTokenSource ();
}
public override HttpClient CreateClient(Url url, HttpMessageHandler handler)
{
return new HttpClient(handler)
{
Timeout = FlurlHttp.Configuration.DefaultTimeout
};
}
public ScApiSession(
ISessionConfig config,
IWebApiCredentials credentials,
IMediaLibrarySettings mediaSettings,
ItemSource defaultSource = null,
HttpMessageHandler httpMessageHandler = null)
{
if (null == config)
{
throw new ArgumentNullException("ScApiSession.config cannot be null");
}
this.sessionConfig = config.SessionConfigShallowCopy();
this.requestMerger = new UserRequestMerger(this.sessionConfig, defaultSource);
if (null != credentials)
{
this.credentials = credentials.CredentialsShallowCopy();
}
if (null != mediaSettings)
{
this.mediaSettings = mediaSettings.MediaSettingsShallowCopy();
}
this.httpClient = httpMessageHandler == null ? new HttpClient() : new HttpClient(httpMessageHandler);
}
public OpenSrsClient(OpenSrsMode openSrsMode, string username, string apiKey, HttpMessageHandler httpMessageHandler)
{
HttpClient = new HttpClient(httpMessageHandler);
OpenSrsMode = openSrsMode;
Username = username;
ApiKey = apiKey;
}
protected virtual void Dispose (bool disposing)
{
if (disposing && disposeHandler && handler != null) {
handler.Dispose ();
handler = null;
}
}
//
// Summary:
// Initializes an instance of a System.Net.Http.HttpMessageInvoker class with
// a specific System.Net.Http.HttpMessageHandler.
//
// Parameters:
// handler:
// The System.Net.Http.HttpMessageHandler responsible for processing the HTTP
// response messages.
//
// disposeHandler:
// true if the inner handler should be disposed of by Dispose(),false if you
// intend to reuse the inner handler.
public HttpMessageInvoker(HttpMessageHandler handler, bool disposeHandler)
{
if (handler == null)
throw new ArgumentNullException("handler");
m_handler = handler;
m_disposeHandler = disposeHandler;
}
public IRdfeIaasClustersRestClient Create(
HttpMessageHandler defaultHttpClientHandler,
IHDInsightSubscriptionCredentials credentials,
IAbstractionContext context,
bool ignoreSslErrors)
{
HttpRestClientRetryPolicy retryPolicy = null;
var tokenCreds = credentials as IHDInsightAccessTokenCredential;
var customHandlers = new List<DelegatingHandler>();
if (context != null && context.Logger != null)
{
customHandlers.Add(new HttpLoggingHandler(context.Logger));
retryPolicy = new HttpRestClientRetryPolicy(context.RetryPolicy);
}
else
{
retryPolicy = new HttpRestClientRetryPolicy(RetryPolicyFactory.CreateExponentialRetryPolicy());
customHandlers.Add(new HttpLoggingHandler(new Logger()));
}
if (tokenCreds != null)
{
customHandlers.Add(new BearerTokenMessageHandler(tokenCreds.AccessToken));
}
var httpConfiguration = new HttpRestClientConfiguration(defaultHttpClientHandler, customHandlers, retryPolicy);
var client = new RdfeIaasClustersRestClient(credentials.Endpoint, httpConfiguration);
return client;
}
/// <summary>
/// Constructs a new instance using the specified <see cref="OAuth2Settings"/>.
/// </summary>
/// <param name="settings">An <see cref="OAuth2Settings"/> instance containing details used to request and manage tokens and authentication flows.</param>
/// <param name="innerHandler">The inner <see cref="System.Net.Http.HttpMessageHandler"/> to call in the pipeline.</param>
/// <param name="requestCondition">An optional <see cref="IRequestCondition"/> used to determine if authorisation is required. If null, then authorisation is always performed.</param>
/// <exception cref="System.ArgumentNullException">Thrown if the <paramref name="settings"/> is null.</exception>
/// <exception cref="System.InvalidOperationException">Thrown if a validation error occurs for the <paramref name="settings"/> argument. See <see cref="OAuth2Settings.Validate"/>.</exception>
public OAuth2RequestSigningHandler(OAuth2Settings settings, System.Net.Http.HttpMessageHandler innerHandler, IRequestCondition requestCondition) : base(innerHandler)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
settings.Validate();
_Token = settings.AccessToken;
_RequestCondition = requestCondition;
_Settings = settings;
}
/// <summary>
/// Full constructor.
/// </summary>
/// <param name="maxConcurrentRequests">The maximum number of concurrent requests allowed. Must be greater than zero</param>
/// <param name="innerHandler">The next handler in the pipeline to pass the request onto.</param>
/// <exception cref="System.ArgumentOutOfRangeException">Thrown if <paramref name="maxConcurrentRequests"/> is less than or equal to zero.</exception>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="innerHandler"/> parameter is null.</exception>
public ThrottledConcurrentRequestHandler(int maxConcurrentRequests, System.Net.Http.HttpMessageHandler innerHandler) : base(innerHandler)
{
if (maxConcurrentRequests <= 0)
{
throw new ArgumentOutOfRangeException(nameof(maxConcurrentRequests));
}
if (innerHandler == null)
{
throw new ArgumentNullException(nameof(innerHandler));
}
_ThrottlingSemaphore = new System.Threading.Semaphore(maxConcurrentRequests, maxConcurrentRequests);
}
private async Task RunUsingUserCredential()
{
var requestUri = "path to server resource we want";
IAuthorizationCodeFlow authFLow = null;
var userId = "";
TokenResponse token = null;
var authUri = "";
System.Net.Http.HttpMessageHandler httpMessageHandler = null;
var messageHandler = new ConfigurableMessageHandler(httpMessageHandler);
var cancellationToken = new CancellationToken();
cancellationToken.Register(() => { });
var credential = new UserCredential(authFLow, userId, token)
{
};
var accessToken = await credential.GetAccessTokenForRequestAsync(authUri, cancellationToken);
// Create the service.
var service = new Google.Apis.Datastore.v1beta3.DatastoreService(new BaseClientService.Initializer
{
HttpClientInitializer = credential,
ApplicationName = "Discovery Sample",
ApiKey = "[YOUR_API_KEY_HERE]",
});
var httpClient = new ConfigurableHttpClient(messageHandler);
service.HttpClientInitializer.Initialize(httpClient);
var res = await httpClient.GetAsync(requestUri);
}
/// <summary>
/// Constructs a new instance using the specified <see cref="OAuth2Settings"/>.
/// </summary>
/// <param name="settings">An <see cref="OAuth2Settings"/> instance containing details used to request and manage tokens and authentication flows.</param>
/// <param name="innerHandler">The inner <see cref="System.Net.Http.HttpMessageHandler"/> to call in the pipeline.</param>
/// <exception cref="System.ArgumentNullException">Thrown if the <paramref name="settings"/> is null.</exception>
public OAuth2RequestSigningHandler(OAuth2Settings settings, System.Net.Http.HttpMessageHandler innerHandler) : this(settings, innerHandler, null)
{
}
/// <summary>
/// Constructs a new instance using the specified <see cref="OAuth2Settings"/>.
/// </summary>
/// <param name="settings">An <see cref="OAuth2Settings"/> instance containing details used to request and manage tokens and authentication flows.</param>
/// <param name="innerHandler">The inner <see cref="System.Net.Http.HttpMessageHandler"/> to call in the pipeline.</param>
/// <param name="requestCondition">An optional <see cref="IRequestCondition"/> used to determine if authorisation is required. If null, then authorisation is always performed.</param>
/// <exception cref="System.ArgumentNullException">Thrown if the <paramref name="settings"/> is null.</exception>
public OAuth2RequestSigningHandler(OAuth2Settings settings, System.Net.Http.HttpMessageHandler innerHandler, IRequestCondition requestCondition) : base(innerHandler)
{
Helper.Throw();
}
/// <summary>
/// Full constructor.
/// </summary>
/// <param name="maxConcurrentRequests">The maximum number of concurrent requests allowed. Must be greater than zero</param>
/// <param name="innerHandler">The next handler in the pipeline to pass the request onto.</param>
/// <exception cref="System.ArgumentOutOfRangeException">Thrown if <paramref name="maxConcurrentRequests"/> is less than or equal to zero.</exception>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="innerHandler"/> parameter is null.</exception>
public ThrottledConcurrentRequestHandler(int maxConcurrentRequests, System.Net.Http.HttpMessageHandler innerHandler) : base(innerHandler)
{
Helper.Throw();
}
/// <summary>
/// Default constructor. Creates an instance that only allows 4 concurrent requests.
/// </summary>
/// <param name="innerHandler">The next handler in the pipeline to pass the request onto.</param>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="innerHandler"/> parameter is null.</exception>
public ThrottledConcurrentRequestHandler(System.Net.Http.HttpMessageHandler innerHandler) : this(4, innerHandler)
{
Helper.Throw();
}
#pragma warning disable 1998
public static async Task Main(string[] args)
#pragma warning restore 1998
{
bool tracingDisabled = args.Any(arg => arg.Equals("TracingDisabled", StringComparison.OrdinalIgnoreCase));
Console.WriteLine($"TracingDisabled {tracingDisabled}");
string port = args.FirstOrDefault(arg => arg.StartsWith("Port="))?.Split('=')[1] ?? "9000";
Console.WriteLine($"Port {port}");
using (var server = WebServer.Start(port, out var url))
{
server.RequestHandler = HandleHttpRequests;
Console.WriteLine();
Console.WriteLine($"Starting HTTP listener at {url}");
// send async http requests using HttpClient
Console.WriteLine();
Console.WriteLine("Sending async request with default HttpClient.");
using (var client = new HttpClient())
{
RequestHelpers.SendAsyncHttpClientRequests(client, tracingDisabled, url, RequestContent);
}
// send async http requests using HttpClient with CustomHandler
Console.WriteLine();
Console.WriteLine("Sending async request with HttpClient(CustomHandler).");
using (var client = new HttpClient(new CustomHandler()))
{
RequestHelpers.SendAsyncHttpClientRequests(client, tracingDisabled, url, RequestContent);
}
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
// send async http requests using HttpClient with raw WinHttpHandler
Console.WriteLine();
Console.WriteLine("Sending async request with HttpClient(WinHttpHandler).");
using (var client = new HttpClient(new WinHttpHandler()))
{
RequestHelpers.SendAsyncHttpClientRequests(client, tracingDisabled, url, RequestContent);
}
}
#if NETCOREAPP
// send async http requests using HttpClient with raw SocketsHttpHandler
Console.WriteLine();
Console.WriteLine("Sending async request with HttpClient(SocketsHttpHandler).");
using (var client = new HttpClient(new SocketsHttpHandler()))
{
RequestHelpers.SendAsyncHttpClientRequests(client, tracingDisabled, url, RequestContent);
}
#endif
#if NET5_0_OR_GREATER
// send sync http requests using HttpClient
Console.WriteLine();
Console.WriteLine("Sending sync request with default HttpClient.");
using (var client = new HttpClient())
{
RequestHelpers.SendHttpClientRequests(client, tracingDisabled, url, RequestContent);
}
// send async http requests using HttpClient with CustomHandler
Console.WriteLine();
Console.WriteLine("Sending sync request with HttpClient(CustomHandler).");
using (var client = new HttpClient(new CustomHandler()))
{
RequestHelpers.SendHttpClientRequests(client, tracingDisabled, url, RequestContent);
}
// send sync http requests using HttpClient with raw SocketsHttpHandler
Console.WriteLine();
Console.WriteLine("Sending sync request with HttpClient(SocketsHttpHandler).");
using (var client = new HttpClient(new SocketsHttpHandler()))
{
RequestHelpers.SendHttpClientRequests(client, tracingDisabled, url, RequestContent);
}
// sync http requests using HttpClient are not supported with WinHttpHandler
#endif
#if NETCOREAPP2_1 || NETCOREAPP3_0 || NETCOREAPP3_1
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
Console.WriteLine();
Console.WriteLine("Sending async request with internal WinHttpHandler.");
Type winHttpHandler = typeof(System.Net.Http.HttpMessageHandler).Assembly.GetTypes().FirstOrDefault(t => t.Name == "WinHttpHandler");
System.Net.Http.HttpMessageHandler handler = (System.Net.Http.HttpMessageHandler)Activator.CreateInstance(winHttpHandler);
using (var invoker = new HttpMessageInvoker(handler, false))
{
await RequestHelpers.SendHttpMessageInvokerRequestsAsync(invoker, tracingDisabled, url);
}
}
else
{
Console.WriteLine();
Console.WriteLine("Sending async request with CurlHandler.");
Type curlHandlerType = typeof(System.Net.Http.HttpMessageHandler).Assembly.GetTypes().FirstOrDefault(t => t.Name == "CurlHandler");
System.Net.Http.HttpMessageHandler handler = (System.Net.Http.HttpMessageHandler)Activator.CreateInstance(curlHandlerType);
using (var invoker = new HttpMessageInvoker(handler, false))
{
await RequestHelpers.SendHttpMessageInvokerRequestsAsync(invoker, tracingDisabled, url);
}
}
#endif
Console.WriteLine();
Console.WriteLine("Stopping HTTP listener.");
}
// Force process to end, otherwise the background listener thread lives forever in .NET Core.
// Apparently listener.GetContext() doesn't throw an exception if listener.Stop() is called,
// like it does in .NET Framework.
Environment.Exit(0);
}
public MobileCenterAPIServiceApiKeyApi(string apiKey, string encryptionKey, System.Net.Http.HttpMessageHandler handler = null) :
base(apiKey, encryptionKey, "v0.1/api_tokens", handler)
{
BaseAddress = new System.Uri("https://api.mobile.azure.com");;
}
/// <summary>
/// Full constructor.
/// </summary>
/// <param name="innerHandler">The next handler in the pipeline to pass requests through.</param>
/// <param name="requestCondition">A <see cref="IRequestCondition"/> that controls whether any individual request is compressed or not. If null, all requests are compressed.</param>
public CompressedRequestHandler(System.Net.Http.HttpMessageHandler innerHandler, IRequestCondition requestCondition) : base(innerHandler)
{
Helper.Throw();
}
/// <summary>
/// Default constructor. Creates an instance that only allows 4 concurrent requests.
/// </summary>
/// <param name="innerHandler">The next handler in the pipeline to pass the request onto.</param>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="innerHandler"/> parameter is null.</exception>
public ThrottledConcurrentRequestHandler(System.Net.Http.HttpMessageHandler innerHandler) : this(DefaultMaxRequests, innerHandler)
{
}
/// <summary>
/// Partial constructor.
/// </summary>
/// <param name="innerHandler">The next handler in the pipeline to pass requests through.</param>
public CompressedRequestHandler(System.Net.Http.HttpMessageHandler innerHandler) : this(innerHandler, null)
{
Helper.Throw();
}
protected DelegatingHandler(HttpMessageHandler innerHandler)
{
InnerHandler = innerHandler;
}
public RetryHandler(System.Net.Http.HttpMessageHandler innerHandler, int maxRetries = 3, int timeToWait = 3000)
: base(innerHandler)
{
MaxRetries = maxRetries;
TimeToWait = timeToWait;
}
/// <summary>
/// DiagnosticHandler constructor
/// </summary>
/// <param name="innerHandler">Inner handler: Windows or Unix implementation of HttpMessageHandler.
/// Note that DiagnosticHandler is the latest in the pipeline </param>
public DiagnosticsHandler(HttpMessageHandler innerHandler) : base(innerHandler)
{
}
/// <summary>
/// Full constructor.
/// </summary>
/// <param name="innerHandler">The next handler in the pipeline to pass requests through.</param>
/// <param name="requestCondition">A <see cref="IRequestCondition"/> that controls whether any individual request is compressed or not. If null, all requests are compressed.</param>
public CompressedRequestHandler(System.Net.Http.HttpMessageHandler innerHandler, IRequestCondition requestCondition) : base(innerHandler)
{
_RequestCondition = requestCondition;
}
public HttpClient(HttpMessageHandler handler)
: this(handler, true)
{
}
public RedirectHandler(int maxAutomaticRedirections, HttpMessageHandler initialInnerHandler, HttpMessageHandler redirectInnerHandler)
{
Debug.Assert(initialInnerHandler != null);
Debug.Assert(redirectInnerHandler != null);
Debug.Assert(maxAutomaticRedirections > 0);
_maxAutomaticRedirections = maxAutomaticRedirections;
_initialInnerHandler = initialInnerHandler;
_redirectInnerHandler = redirectInnerHandler;
}
protected MessageProcessingHandler(HttpMessageHandler innerHandler)
: base(innerHandler)
{
}
public AuthenticateAndRedirectHandler(bool preAuthenticate, ICredentials credentials, bool allowRedirect, int maxAutomaticRedirections, HttpMessageHandler innerHandler)
{
Debug.Assert(innerHandler != null);
_preAuthenticate = preAuthenticate;
_credentials = credentials;
_allowRedirect = allowRedirect;
if (allowRedirect && maxAutomaticRedirections < 0)
{
throw new ArgumentOutOfRangeException(nameof(maxAutomaticRedirections));
}
_maxAutomaticRedirections = maxAutomaticRedirections;
_innerHandler = innerHandler;
}
