public async Task ThresholdExceeded_ThrowsException(string responseHeaders, int maxResponseHeadersLength, bool shouldSucceed) { using (Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) { s.Bind(new IPEndPoint(IPAddress.Loopback, 0)); s.Listen(1); var ep = (IPEndPoint)s.LocalEndPoint; using (var handler = new HttpClientHandler() { MaxResponseHeadersLength = maxResponseHeadersLength }) using (var client = new HttpClient(handler)) { Task<HttpResponseMessage> getAsync = client.GetAsync($"http://{ep.Address}:{ep.Port}", HttpCompletionOption.ResponseHeadersRead); using (Socket server = s.Accept()) using (Stream serverStream = new NetworkStream(server, ownsSocket: false)) using (StreamReader reader = new StreamReader(serverStream, Encoding.ASCII)) { string line; while ((line = reader.ReadLine()) != null && !string.IsNullOrEmpty(line)) ; byte[] headerData = Encoding.ASCII.GetBytes(responseHeaders); serverStream.Write(headerData, 0, headerData.Length); } if (shouldSucceed) { (await getAsync).Dispose(); } else { await Assert.ThrowsAsync<HttpRequestException>(() => getAsync); } } } }
public async Task HttpClient_ClientUsesAuxRecord_Ok() { X509Certificate2 serverCert = Configuration.Certificates.GetServerCertificate(); var server = new SchSendAuxRecordTestServer(serverCert); int port = server.StartServer(); string requestString = "https://localhost:" + port.ToString(); using (var handler = new HttpClientHandler() { ServerCertificateCustomValidationCallback = LoopbackServer.AllowAllCertificates }) using (var client = new HttpClient(handler)) { var tasks = new Task[2]; tasks[0] = server.RunTest(); tasks[1] = client.GetStringAsync(requestString); await Task.WhenAll(tasks).TimeoutAfter(15 * 1000); if (server.IsInconclusive) { _output.WriteLine("Test inconclusive: The Operating system preferred a non-CBC or Null cipher."); } else { Assert.True(server.AuxRecordDetected, "Server reports: Client auxiliary record not detected."); } } }
public void Default_Get_Null() { using (var handler = new HttpClientHandler()) { Assert.Null(handler.DefaultProxyCredentials); } }
public void ProxyExplicitlyProvided_DefaultCredentials_Ignored() { int port; Task<LoopbackGetRequestHttpProxy.ProxyResult> proxyTask = LoopbackGetRequestHttpProxy.StartAsync(out port, requireAuth: true, expectCreds: true); Uri proxyUrl = new Uri($"http://localhost:{port}"); var rightCreds = new NetworkCredential("rightusername", "rightpassword"); var wrongCreds = new NetworkCredential("wrongusername", "wrongpassword"); using (var handler = new HttpClientHandler()) using (var client = new HttpClient(handler)) { handler.Proxy = new UseSpecifiedUriWebProxy(proxyUrl, rightCreds); handler.DefaultProxyCredentials = wrongCreds; Task<HttpResponseMessage> responseTask = client.GetAsync(Configuration.Http.RemoteEchoServer); Task<string> responseStringTask = responseTask.ContinueWith(t => t.Result.Content.ReadAsStringAsync(), TaskScheduler.Default).Unwrap(); Task.WaitAll(proxyTask, responseTask, responseStringTask); TestHelper.VerifyResponseBody(responseStringTask.Result, responseTask.Result.Content.Headers.ContentMD5, false, null); Assert.Equal(Encoding.ASCII.GetString(proxyTask.Result.ResponseContent), responseStringTask.Result); string expectedAuth = $"{rightCreds.UserName}:{rightCreds.Password}"; Assert.Equal(expectedAuth, proxyTask.Result.AuthenticationHeaderValue); } }
public void Ctor_ExpectedDefaultPropertyValues() { using (var handler = new HttpClientHandler()) { // Same as .NET Framework (Desktop). Assert.True(handler.AllowAutoRedirect); Assert.Equal(ClientCertificateOption.Manual, handler.ClientCertificateOptions); CookieContainer cookies = handler.CookieContainer; Assert.NotNull(cookies); Assert.Equal(0, cookies.Count); Assert.Null(handler.Credentials); Assert.Equal(50, handler.MaxAutomaticRedirections); Assert.False(handler.PreAuthenticate); Assert.Equal(null, handler.Proxy); Assert.True(handler.SupportsAutomaticDecompression); Assert.True(handler.SupportsProxy); Assert.True(handler.SupportsRedirectConfiguration); Assert.True(handler.UseCookies); Assert.False(handler.UseDefaultCredentials); Assert.True(handler.UseProxy); // Changes from .NET Framework (Desktop). Assert.Equal(DecompressionMethods.GZip | DecompressionMethods.Deflate, handler.AutomaticDecompression); Assert.Equal(0, handler.MaxRequestContentBufferSize); } }
#pragma warning restore 0618 public void DisabledProtocols_SetSslProtocols_ThrowsException(SslProtocols disabledProtocols) { using (var handler = new HttpClientHandler()) { Assert.Throws<NotSupportedException>(() => handler.SslProtocols = disabledProtocols); } }
[PlatformSpecific(PlatformID.AnyUnix)] // proxies set via the http_proxy environment variable are specific to Unix public void ProxySetViaEnvironmentVariable_DefaultProxyCredentialsUsed() { int port; Task<LoopbackGetRequestHttpProxy.ProxyResult> proxyTask = LoopbackGetRequestHttpProxy.StartAsync(out port, requireAuth: true, expectCreds: true); const string ExpectedUsername = "******"; const string ExpectedPassword = "******"; // libcurl will read a default proxy from the http_proxy environment variable. Ensure that when it does, // our default proxy credentials are used. To avoid messing up anything else in this process, we run the // test in another process. var psi = new ProcessStartInfo(); psi.Environment.Add("http_proxy", $"http://localhost:{port}"); RemoteInvoke(() => { using (var handler = new HttpClientHandler()) using (var client = new HttpClient(handler)) { var creds = new NetworkCredential(ExpectedUsername, ExpectedPassword); handler.DefaultProxyCredentials = creds; Task<HttpResponseMessage> responseTask = client.GetAsync(Configuration.Http.RemoteEchoServer); Task<string> responseStringTask = responseTask.ContinueWith(t => t.Result.Content.ReadAsStringAsync(), TaskScheduler.Default).Unwrap(); Task.WaitAll(responseTask, responseStringTask); TestHelper.VerifyResponseBody(responseStringTask.Result, responseTask.Result.Content.Headers.ContentMD5, false, null); } return SuccessExitCode; }, new RemoteInvokeOptions { StartInfo = psi }).Dispose(); Assert.Equal($"{ExpectedUsername}:{ExpectedPassword}", proxyTask.Result.AuthenticationHeaderValue); }
public void InvalidValue_ThrowsException(int invalidValue) { using (var handler = new HttpClientHandler()) { Assert.Throws<ArgumentOutOfRangeException>("value", () => handler.MaxResponseHeadersLength = invalidValue); } }
public async Task ThresholdExceeded_ThrowsException(string responseHeaders, int maxResponseHeadersLength, bool shouldSucceed) { await LoopbackServer.CreateServerAsync(async (server, url) => { using (var handler = new HttpClientHandler() { MaxResponseHeadersLength = maxResponseHeadersLength }) using (var client = new HttpClient(handler)) { Task<HttpResponseMessage> getAsync = client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead); await LoopbackServer.AcceptSocketAsync(server, async (s, serverStream, reader, writer) => { using (s) using (serverStream) using (reader) using (writer) { string line; while ((line = reader.ReadLine()) != null && !string.IsNullOrEmpty(line)) ; byte[] headerData = Encoding.ASCII.GetBytes(responseHeaders); serverStream.Write(headerData, 0, headerData.Length); } if (shouldSucceed) { (await getAsync).Dispose(); } else { await Assert.ThrowsAsync<HttpRequestException>(() => getAsync); } return null; }); } }); }
public void ConnectTimeout_Default() { using (var handler = new HttpClientHandler()) { Assert.Equal(Timeout.InfiniteTimeSpan, handler.ConnectTimeout); } }
public async Task UseCallback_ValidCertificate_ExpectedValuesDuringCallback(Uri url, bool checkRevocation) { var handler = new HttpClientHandler(); using (var client = new HttpClient(handler)) { bool callbackCalled = false; handler.CheckCertificateRevocationList = checkRevocation; handler.ServerCertificateValidationCallback = (request, cert, chain, errors) => { callbackCalled = true; Assert.NotNull(request); Assert.Equal(SslPolicyErrors.None, errors); Assert.True(chain.ChainElements.Count > 0); Assert.NotEmpty(cert.Subject); Assert.Equal(checkRevocation ? X509RevocationMode.Online : X509RevocationMode.NoCheck, chain.ChainPolicy.RevocationMode); return true; }; using (HttpResponseMessage response = await client.GetAsync(url)) { Assert.Equal(HttpStatusCode.OK, response.StatusCode); } Assert.True(callbackCalled); } }
public void ClientCertificateOptions_InvalidArg_ThrowsException(ClientCertificateOption option) { using (var handler = new HttpClientHandler()) { Assert.Throws<ArgumentOutOfRangeException>("value", () => handler.ClientCertificateOptions = option); } }
public void DefaultProtocols_MatchesExpected() { using (var handler = new HttpClientHandler()) { Assert.Equal(SslProtocols.None, handler.SslProtocols); } }
public void Default_ExpectedValue() { using (var handler = new HttpClientHandler()) { Assert.Equal(int.MaxValue, handler.MaxConnectionsPerServer); } }
public void Set_InvalidValues_Throws(int invalidValue) { using (var handler = new HttpClientHandler()) { Assert.Throws<ArgumentOutOfRangeException>(() => handler.MaxConnectionsPerServer = invalidValue); } }
public void ClientCertificateOptions_Default() { using (var handler = new HttpClientHandler()) { Assert.Equal(ClientCertificateOption.Manual, handler.ClientCertificateOptions); } }
public void Default_MaxResponseHeadersLength() { using (var handler = new HttpClientHandler()) { Assert.Equal(64 * 1024, handler.MaxResponseHeadersLength); } }
public void ConnectTimeout_InvalidValues(long ms) { using (var handler = new HttpClientHandler()) { Assert.Throws<ArgumentOutOfRangeException>(() => handler.ConnectTimeout = TimeSpan.FromMilliseconds(ms)); } }
public void ValidValue_SetGet_Roundtrips(int validValue) { using (var handler = new HttpClientHandler()) { handler.MaxResponseHeadersLength = validValue; Assert.Equal(validValue, handler.MaxResponseHeadersLength); } }
public void DefaultProtocols_MatchesExpected() { using (var handler = new HttpClientHandler()) { const SslProtocols expectedDefault = SslProtocols.Tls | SslProtocols.Tls11 | SslProtocols.Tls12; Assert.Equal(expectedDefault, handler.SslProtocols); } }
public void ConnectTimeout_ValidValues_Roundtrip(long ms) { using (var handler = new HttpClientHandler()) { handler.ConnectTimeout = TimeSpan.FromMilliseconds(ms); Assert.Equal(TimeSpan.FromMilliseconds(ms), handler.ConnectTimeout); } }
public void SetGetProtocols_Roundtrips(SslProtocols protocols) { using (var handler = new HttpClientHandler()) { handler.SslProtocols = protocols; Assert.Equal(protocols, handler.SslProtocols); } }
public void ClientCertificateOptions_ValueArg_Roundtrips(ClientCertificateOption option) { using (var handler = new HttpClientHandler()) { handler.ClientCertificateOptions = option; Assert.Equal(option, handler.ClientCertificateOptions); } }
public async Task Manual_CertificateSentMatchesCertificateReceived_Success( int numberOfRequests, bool reuseClient) // validate behavior with and without connection pooling, which impacts client cert usage { var options = new LoopbackServer.Options { UseSsl = true }; using (X509Certificate2 cert = Configuration.Certificates.GetClientCertificate()) { Func<HttpClient> createClient = () => { var handler = new HttpClientHandler() { ServerCertificateCustomValidationCallback = delegate { return true; } }; handler.ClientCertificates.Add(cert); return new HttpClient(handler); }; Func<HttpClient, Socket, Uri, Task> makeAndValidateRequest = async (client, server, url) => { await TestHelper.WhenAllCompletedOrAnyFailed( client.GetStringAsync(url), LoopbackServer.AcceptSocketAsync(server, async (socket, stream, reader, writer) => { SslStream sslStream = Assert.IsType<SslStream>(stream); Assert.Equal(cert, sslStream.RemoteCertificate); await LoopbackServer.ReadWriteAcceptedAsync(socket, reader, writer); return null; }, options)); }; await LoopbackServer.CreateServerAsync(async (server, url) => { if (reuseClient) { using (HttpClient client = createClient()) { for (int i = 0; i < numberOfRequests; i++) { await makeAndValidateRequest(client, server, url); GC.Collect(); GC.WaitForPendingFinalizers(); } } } else { for (int i = 0; i < numberOfRequests; i++) { using (HttpClient client = createClient()) { await makeAndValidateRequest(client, server, url); } GC.Collect(); GC.WaitForPendingFinalizers(); } } }, options); } }
public async Task Manual_SSLBackendNotSupported_ThrowsPlatformNotSupportedException() { var handler = new HttpClientHandler(); handler.ClientCertificates.Add(Configuration.Certificates.GetClientCertificate()); using (var client = new HttpClient(handler)) { await Assert.ThrowsAsync<PlatformNotSupportedException>(() => client.GetAsync(Configuration.Http.SecureRemoteEchoServer)); } }
public async Task GetAsync_AllowedSSLVersion_Succeeds(SslProtocols acceptedProtocol, string url) { using (var handler = new HttpClientHandler()) using (var client = new HttpClient(handler)) { handler.SslProtocols = acceptedProtocol; using (await client.GetAsync(url)) { } } }
public async Task SetProtcols_AfterRequest_ThrowsException() { using (var handler = new HttpClientHandler()) using (var client = new HttpClient(handler)) { (await client.GetAsync(HttpTestServers.RemoteEchoServer)).Dispose(); Assert.Throws<InvalidOperationException>(() => handler.SslProtocols = SslProtocols.Tls12); } }
public async Task SetAfterUse_Throws() { using (var handler = new HttpClientHandler()) using (var client = new HttpClient(handler)) { handler.MaxResponseHeadersLength = int.MaxValue; await client.GetStreamAsync(Configuration.Http.RemoteEchoServer); Assert.Throws<InvalidOperationException>(() => handler.MaxResponseHeadersLength = int.MaxValue); } }
public async Task UseDefaultCredentials_SetFalse_Unauthorized(bool useProxy) { var handler = new HttpClientHandler { UseProxy = useProxy, UseDefaultCredentials = false }; using (var client = new HttpClient(handler)) using (HttpResponseMessage response = await client.GetAsync(s_authenticatedServer)) { Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); } }
public LuisRecognizer(LuisApplication application, IBotTelemetryClient telemetryClient, bool logPersonalInformation, LuisPredictionOptions predictionOptions = null, bool includeApiResults = false, HttpClientHandler clientHandler = null) : this(BuildLuisRecognizerOptionsV2(application, predictionOptions, includeApiResults), clientHandler) { }
/// <inheritdoc/> public void Configure(HttpClientHandler httpClientHandler) { }
/// <summary> /// Initializes a new instance of the <see cref="MockHttpClientHandlerGen"/> class. /// </summary> public MockHttpClientHandlerGen() { this.httpClientHandler = this.GenerateMockHttpClientHandler(); }
public WebClient(HttpClientHandler Handler) : base(Handler) { }
private void HentDataFraDiskAsync(string BilMaerke) { OC_bilmaerker.Clear(); List <Bil> nyListe = new List <Bil>(); //nyListe = await PersistencyService.HentDataFraDiskAsyncPS(); OC_forhandlere.Clear(); List <Forhandler> forhandlerListe = new List <Forhandler>(); OC_bookings.Clear(); List <Booking> bookingListe = new List <Booking>(); //Setup client handler HttpClientHandler handler = new HttpClientHandler(); handler.UseDefaultCredentials = true; using (var client = new HttpClient(handler)) { //Initialize client client.BaseAddress = new Uri(serverUrl); client.DefaultRequestHeaders.Clear(); //Request JSON format client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); try { //Get all the flower orders from the database var flowerOrderResponse = client.GetAsync("api/bils").Result; var forhandlerOrderResponse = client.GetAsync("api/forhandlers").Result; var bookingOrderResponse = client.GetAsync("api/bookings").Result; //Check response -> throw exception if NOT successful flowerOrderResponse.EnsureSuccessStatusCode(); forhandlerOrderResponse.EnsureSuccessStatusCode(); bookingOrderResponse.EnsureSuccessStatusCode(); //Get the hotels as a ICollection var orders = flowerOrderResponse.Content.ReadAsAsync <ICollection <Bil> >().Result; var orders2 = forhandlerOrderResponse.Content.ReadAsAsync <ICollection <Forhandler> >().Result; var orders3 = bookingOrderResponse.Content.ReadAsAsync <ICollection <Booking> >().Result; foreach (var order in orders) { if (order.BilMaerke == BilMaerke) { this.OC_bilmaerker.Add(new Bil(order.BilID, order.ForhandlerID, order.BilMaerke, order.BilModel, order.BilUdstyr, order.BilMotor)); } } foreach (var order in orders2) { this.OC_forhandlere.Add(new Forhandler(order.ForhandlerID, order.ForhandlerNavn, order.ForhandlerAdresse, order.ForhandlerBy, order.ForhandlerTelefon, order.ForhandlerEmail)); } foreach (var order in orders3) { this.OC_bookings.Add(new Booking(order.BookingID, order.KundeNavn, order.KundeEmail, order.BilModel, order.ForhandlerNavn, order.BookTime)); } } catch { } } /*public void SelectBilMaerke() * { * if * }*/ }
/// <summary> /// Registers a device described by the message. /// </summary> /// <param name="message">The provisioning message.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The registration result.</returns> public async override Task <DeviceRegistrationResult> RegisterAsync( ProvisioningTransportRegisterMessage message, CancellationToken cancellationToken) { if (Logging.IsEnabled) { Logging.Enter(this, $"{nameof(ProvisioningTransportHandlerHttp)}.{nameof(RegisterAsync)}"); } if (message == null) { throw new ArgumentNullException(nameof(message)); } cancellationToken.ThrowIfCancellationRequested(); try { HttpAuthStrategy authStrategy; if (message.Security is SecurityProviderTpm) { authStrategy = new HttpAuthStrategyTpm((SecurityProviderTpm)message.Security); } else if (message.Security is SecurityProviderX509) { authStrategy = new HttpAuthStrategyX509((SecurityProviderX509)message.Security); } else if (message.Security is SecurityProviderSymmetricKey) { authStrategy = new HttpAuthStrategySymmetricKey((SecurityProviderSymmetricKey)message.Security); } else { if (Logging.IsEnabled) { Logging.Error(this, $"Invalid {nameof(SecurityProvider)} type."); } throw new NotSupportedException( $"{nameof(message.Security)} must be of type {nameof(SecurityProviderTpm)}, " + $"{nameof(SecurityProviderX509)} or {nameof(SecurityProviderSymmetricKey)}"); } if (Logging.IsEnabled) { Logging.Associate(authStrategy, this); } var builder = new UriBuilder { Scheme = Uri.UriSchemeHttps, Host = message.GlobalDeviceEndpoint, Port = Port, }; var httpClientHandler = new HttpClientHandler { // Cannot specify a specific protocol here, as desired due to an error: // ProvisioningDeviceClient_ValidRegistrationId_AmqpWithProxy_SymmetricKey_RegisterOk_GroupEnrollment failing for me with System.PlatformNotSupportedException: Operation is not supported on this platform. // When revisiting TLS12 work for DPS, we should figure out why. Perhaps the service needs to support it. //SslProtocols = TlsVersions.Preferred, }; if (Proxy != DefaultWebProxySettings.Instance) { httpClientHandler.UseProxy = (Proxy != null); httpClientHandler.Proxy = Proxy; if (Logging.IsEnabled) { Logging.Info(this, $"{nameof(RegisterAsync)} Setting HttpClientHandler.Proxy"); } } DeviceProvisioningServiceRuntimeClient client = authStrategy.CreateClient(builder.Uri, httpClientHandler); client.HttpClient.DefaultRequestHeaders.Add("User-Agent", message.ProductInfo); if (Logging.IsEnabled) { Logging.Info(this, $"Uri: {builder.Uri}; User-Agent: {message.ProductInfo}"); } DeviceRegistration deviceRegistration = authStrategy.CreateDeviceRegistration(); if (message.Payload != null && message.Payload.Length > 0) { deviceRegistration.Payload = new JRaw(message.Payload); } string registrationId = message.Security.GetRegistrationID(); RegistrationOperationStatus operation = await client.RuntimeRegistration.RegisterDeviceAsync( registrationId, message.IdScope, deviceRegistration).ConfigureAwait(false); int attempts = 0; string operationId = operation.OperationId; if (Logging.IsEnabled) { Logging.RegisterDevice( this, registrationId, message.IdScope, deviceRegistration.Tpm == null ? "X509" : "TPM", operation.OperationId, operation.RetryAfter, operation.Status); } // Poll with operationId until registration complete. while (string.CompareOrdinal(operation.Status, RegistrationOperationStatus.OperationStatusAssigning) == 0 || string.CompareOrdinal(operation.Status, RegistrationOperationStatus.OperationStatusUnassigned) == 0) { cancellationToken.ThrowIfCancellationRequested(); TimeSpan?serviceRecommendedDelay = operation.RetryAfter; if (serviceRecommendedDelay != null && serviceRecommendedDelay?.TotalSeconds < s_defaultOperationPoolingIntervalMilliseconds.TotalSeconds) { if (Logging.IsEnabled) { Logging.Error(this, $"Service recommended unexpected retryAfter of {operation.RetryAfter?.TotalSeconds}, defaulting to delay of {s_defaultOperationPoolingIntervalMilliseconds.ToString()}", nameof(RegisterAsync)); } serviceRecommendedDelay = s_defaultOperationPoolingIntervalMilliseconds; } await Task.Delay(serviceRecommendedDelay ?? RetryJitter.GenerateDelayWithJitterForRetry(s_defaultOperationPoolingIntervalMilliseconds)).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); try { operation = await client.RuntimeRegistration.OperationStatusLookupAsync( registrationId, operationId, message.IdScope).ConfigureAwait(false); } catch (HttpOperationException oe) { bool isTransient = oe.Response.StatusCode >= HttpStatusCode.InternalServerError || (int)oe.Response.StatusCode == 429; try { var errorDetails = JsonConvert.DeserializeObject <ProvisioningErrorDetailsHttp>(oe.Response.Content); if (isTransient) { serviceRecommendedDelay = errorDetails.RetryAfter; } else { if (Logging.IsEnabled) { Logging.Error( this, $"{nameof(ProvisioningTransportHandlerHttp)} threw exception {oe}", nameof(RegisterAsync)); } throw new ProvisioningTransportException(oe.Response.Content, oe, isTransient, errorDetails); } } catch (JsonException ex) { if (Logging.IsEnabled) { Logging.Error( this, $"{nameof(ProvisioningTransportHandlerHttp)} server returned malformed error response." + $"Parsing error: {ex}. Server response: {oe.Response.Content}", nameof(RegisterAsync)); } throw new ProvisioningTransportException( $"HTTP transport exception: malformed server error message: '{oe.Response.Content}'", ex, false); } } if (Logging.IsEnabled) { Logging.OperationStatusLookup( this, registrationId, operation.OperationId, operation.RetryAfter, operation.Status, attempts); } attempts++; } if (string.CompareOrdinal(operation.Status, RegistrationOperationStatus.OperationStatusAssigned) == 0) { authStrategy.SaveCredentials(operation); } return(ConvertToProvisioningRegistrationResult(operation.RegistrationState)); } catch (HttpOperationException oe) { if (Logging.IsEnabled) { Logging.Error( this, $"{nameof(ProvisioningTransportHandlerHttp)} threw exception {oe}", nameof(RegisterAsync)); } bool isTransient = oe.Response.StatusCode >= HttpStatusCode.InternalServerError || (int)oe.Response.StatusCode == 429; try { var errorDetails = JsonConvert.DeserializeObject <ProvisioningErrorDetailsHttp>(oe.Response.Content); throw new ProvisioningTransportException(oe.Response.Content, oe, isTransient, errorDetails); } catch (JsonException ex) { if (Logging.IsEnabled) { Logging.Error( this, $"{nameof(ProvisioningTransportHandlerHttp)} server returned malformed error response." + $"Parsing error: {ex}. Server response: {oe.Response.Content}", nameof(RegisterAsync)); } throw new ProvisioningTransportException( $"HTTP transport exception: malformed server error message: '{oe.Response.Content}'", ex, false); } } catch (Exception ex) when(!(ex is ProvisioningTransportException)) { if (Logging.IsEnabled) { Logging.Error( this, $"{nameof(ProvisioningTransportHandlerHttp)} threw exception {ex}", nameof(RegisterAsync)); } throw new ProvisioningTransportException($"HTTP transport exception", ex, true); } finally { if (Logging.IsEnabled) { Logging.Exit(this, $"{nameof(ProvisioningTransportHandlerHttp)}.{nameof(RegisterAsync)}"); } } }
internal static async Task RunTestsAsync(DeploymentResult deploymentResult, ILogger logger) { var httpClientHandler = new HttpClientHandler(); var httpClient = deploymentResult.CreateHttpClient(httpClientHandler); httpClient.Timeout = TimeSpan.FromSeconds(15); // Request to base address and check if various parts of the body are rendered // & measure the cold startup time. var response = await RetryHelper.RetryRequest(async() => { return(await httpClient.GetAsync(string.Empty)); }, logger, cancellationToken : deploymentResult.HostShutdownToken); Assert.False(response == null, "Response object is null because the client could not " + "connect to the server after multiple retries"); var validator = new Validator(httpClient, httpClientHandler, logger, deploymentResult); logger.LogInformation("Verifying home page"); await validator.VerifyHomePage(response); logger.LogInformation("Verifying static files are served from static file middleware"); await validator.VerifyStaticContentServed(); logger.LogInformation("Verifying access to a protected resource should automatically redirect to login page."); await validator.AccessStoreWithoutPermissions(); logger.LogInformation("Verifying mismatched passwords trigger validaton errors during user registration"); await validator.RegisterUserWithNonMatchingPasswords(); logger.LogInformation("Verifying valid user registration"); var generatedEmail = await validator.RegisterValidUser(); logger.LogInformation("Verifying duplicate user email registration"); await validator.RegisterExistingUser(generatedEmail); logger.LogInformation("Verifying incorrect password login"); await validator.SignInWithInvalidPassword(generatedEmail, "InvalidPassword~1"); logger.LogInformation("Verifying valid user log in"); await validator.SignInWithUser(generatedEmail, "Password~1"); logger.LogInformation("Verifying change password"); await validator.ChangePassword(generatedEmail); logger.LogInformation("Verifying old password is not valid anymore"); await validator.SignOutUser(generatedEmail); await validator.SignInWithInvalidPassword(generatedEmail, "Password~1"); await validator.SignInWithUser(generatedEmail, "Password~2"); logger.LogInformation("Verifying authenticated user trying to access unauthorized resource"); await validator.AccessStoreWithoutPermissions(generatedEmail); logger.LogInformation("Verifying user log out"); await validator.SignOutUser(generatedEmail); logger.LogInformation("Verifying admin user login"); await validator.SignInWithUser("*****@*****.**", "YouShouldChangeThisPassword1!"); logger.LogInformation("Verifying admin user's access to store manager page"); await validator.AccessStoreWithPermissions(); logger.LogInformation("Verifying creating a new album"); var albumName = await validator.CreateAlbum(); var albumId = await validator.FetchAlbumIdFromName(albumName); logger.LogInformation("Verifying retrieved album details"); await validator.VerifyAlbumDetails(albumId, albumName); logger.LogInformation("Verifying status code pages for non-existing items"); await validator.VerifyStatusCodePages(); logger.LogInformation("Verifying non-admin view of an album"); await validator.GetAlbumDetailsFromStore(albumId, albumName); logger.LogInformation("Verifying adding album to a cart"); await validator.AddAlbumToCart(albumId, albumName); logger.LogInformation("Verifying cart checkout"); await validator.CheckOutCartItems(); logger.LogInformation("Verifying deletion of album from a cart"); await validator.DeleteAlbum(albumId, albumName); logger.LogInformation("Verifying administrator log out"); await validator.SignOutUser("Administrator"); logger.LogInformation("Variation completed successfully."); }
/// <summary> /// Initializes a new instance of the ContactsListAPI class. /// </summary> /// <param name='rootHandler'> /// Optional. The http client handler used to handle http transport. /// </param> /// <param name='handlers'> /// Optional. The set of delegating handlers to insert in the http /// client pipeline. /// </param> public ContactsListAPI(HttpClientHandler rootHandler, params DelegatingHandler[] handlers) : base(rootHandler, handlers) { this._contacts = new Contacts(this); this._baseUri = new Uri("http://localhost:51864"); }
public void SingletonReturnsTrue() { Assert.NotNull(HttpClientHandler.DangerousAcceptAnyServerCertificateValidator); Assert.Same(HttpClientHandler.DangerousAcceptAnyServerCertificateValidator, HttpClientHandler.DangerousAcceptAnyServerCertificateValidator); Assert.True(HttpClientHandler.DangerousAcceptAnyServerCertificateValidator(null, null, null, SslPolicyErrors.None)); }
/// <summary> /// Initializes a new instance of the DynamicsClient class. /// </summary> /// <param name='baseUri'> /// Optional. The base URI of the service. /// </param> /// <param name='credentials'> /// Required. Subscription credentials which uniquely identify client subscription. /// </param> /// <param name='rootHandler'> /// Optional. The http client handler used to handle http transport. /// </param> /// <param name='handlers'> /// Optional. The delegating handlers to add to the http client pipeline. /// </param> /// <exception cref="System.ArgumentNullException"> /// Thrown when a required parameter is null /// </exception> public DynamicsClient(System.Uri baseUri, ServiceClientCredentials credentials, HttpClientHandler rootHandler, params DelegatingHandler[] handlers) : this(rootHandler, handlers) { if (baseUri == null) { throw new System.ArgumentNullException("baseUri"); } if (credentials == null) { throw new System.ArgumentNullException("credentials"); } BaseUri = baseUri; Credentials = credentials; if (Credentials != null) { Credentials.InitializeServiceClient(this); } }
public LuisRecognizer(LuisService service, LuisPredictionOptions predictionOptions = null, bool includeApiResults = false, HttpClientHandler clientHandler = null) : this(new LuisApplication(service), predictionOptions, includeApiResults, clientHandler) { }
public LuisRecognizer(string applicationEndpoint, LuisPredictionOptions predictionOptions = null, bool includeApiResults = false, HttpClientHandler clientHandler = null) : this(new LuisApplication(applicationEndpoint), predictionOptions, includeApiResults, clientHandler) { }
/// <summary> /// Initializes a new instance of the EmailFormattingService class. /// </summary> /// <param name='rootHandler'> /// Optional. The http client handler used to handle http transport. /// </param> /// <param name='handlers'> /// Optional. The delegating handlers to add to the http client pipeline. /// </param> public EmailFormattingService(HttpClientHandler rootHandler, params DelegatingHandler[] handlers) : base(rootHandler, handlers) { Initialize(); }
/// <summary> /// Initializes a new instance of the DynamicsClient class. /// </summary> /// <param name='rootHandler'> /// Optional. The http client handler used to handle http transport. /// </param> /// <param name='handlers'> /// Optional. The delegating handlers to add to the http client pipeline. /// </param> protected DynamicsClient(HttpClientHandler rootHandler, params DelegatingHandler[] handlers) : base(rootHandler, handlers) { Initialize(); }
public static async Task DownloadDb(DownloadItem downloadItem) { try { var ext = Android.OS.Environment.ExternalStorageDirectory.Path + "/Downloads"; var rootfolder = FileSystem.Current.LocalStorage; var appfolder = await rootfolder.CreateFolderAsync(ext, CreationCollisionOption.OpenIfExists); var dbfolder = await appfolder.CreateFolderAsync("Db", CreationCollisionOption.OpenIfExists); var file = await dbfolder.CreateFileAsync(downloadItem.FileName, CreationCollisionOption.ReplaceExisting); using (var fileHandler = await file.OpenAsync(FileAccess.ReadAndWrite)) { var cookieContainer = new CookieContainer(); using (var handler = new HttpClientHandler { CookieContainer = cookieContainer }) using (var client = new HttpClient(handler) { BaseAddress = new Uri(downloadItem.Url) }) { foreach (var header in downloadItem.Headers) { cookieContainer.Add(new Uri(downloadItem.Url), new Cookie(header.Key, header.Value)); } var request = new HttpRequestMessage(HttpMethod.Head, downloadItem.Url); var resp = await client.SendAsync(request); if (resp != null && resp.IsSuccessStatusCode && resp.Content?.Headers?.ContentLength != null) { var dataBuffer = await resp.Content.ReadAsByteArrayAsync(); var dataBuffer1 = await resp.Content.ReadAsStreamAsync(); var dataBuffer2 = resp.Content.LoadIntoBufferAsync(); await fileHandler.WriteAsync(dataBuffer, 0, dataBuffer.Length); } //var resp2 = await client.GetAsync(request.RequestUri.AbsolutePath); //if (resp2.IsSuccessStatusCode) //{ // var content = await resp2.Content.ReadAsByteArrayAsync(); // await fileHandler.WriteAsync(content, 0, content.Length); //} } //var _progressBar = new ProgressBar(); //_progressBar.Progress = 0; //var progressReporter = new Progress<DownloadBytesProgress>(); //progressReporter.ProgressChanged += // (s, args) => _progressBar.Progress = (int) (100 * args.PercentComplete); //var downloadTask = CreateDownloadTask(ImageToDownload, // progressReporter); //var bytesDownloaded = await downloadTask; //Debug.WriteLine("Downloaded {0} bytes.", bytesDownloaded); } } catch (Exception ex) { throw ex; } }
public SocksProgressMessageHandler(HttpClientHandler innerHandler) : base(innerHandler) { }
/// <summary> /// Initializes a new instance of the SecurityCenterClient class. /// </summary> /// <param name='rootHandler'> /// Optional. The http client handler used to handle http transport. /// </param> /// <param name='handlers'> /// Optional. The delegating handlers to add to the http client pipeline. /// </param> protected SecurityCenterClient(HttpClientHandler rootHandler, params DelegatingHandler[] handlers) : base(rootHandler, handlers) { Initialize(); }
/// <summary> /// Initializes a new instance of the CosmosDBManagementClient class. /// </summary> /// <param name='rootHandler'> /// Optional. The http client handler used to handle http transport. /// </param> /// <param name='handlers'> /// Optional. The delegating handlers to add to the http client pipeline. /// </param> protected CosmosDBManagementClient(HttpClientHandler rootHandler, params DelegatingHandler[] handlers) : base(rootHandler, handlers) { Initialize(); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.Configure <CookiePolicyOptions>(options => { // This lambda determines whether user consent for non-essential cookies is needed for a given request. options.CheckConsentNeeded = context => true; options.MinimumSameSitePolicy = SameSiteMode.None; }); services.AddProtectWebApiWithMicrosoftIdentityPlatformV2(Configuration); services.Configure <KeyVaultAd>(options => Configuration.GetSection(nameof(KeyVaultAd)).Bind(options)); services.AddMvc(options => { var policy = new AuthorizationPolicyBuilder() .RequireAuthenticatedUser() .Build(); options.Filters.Add(new AuthorizeFilter(policy)); }) .SetCompatibilityVersion(CompatibilityVersion.Version_2_1); services.AddResponseCompression(options => { options.Providers.Add <GzipCompressionProvider>(); options.MimeTypes = ResponseCompressionDefaults.MimeTypes.Concat( new[] { "text/json" }); }); services.Configure <GzipCompressionProviderOptions>(options => { options.Level = CompressionLevel.Fastest; }); services.AddMemoryCache(); services.AddCors(); services.AddCors(options => { options.AddPolicy("AllowAllHeaders", builder => { builder.AllowAnyOrigin() .AllowAnyMethod() .AllowAnyHeader().WithExposedHeaders(); }); }); var keyVaultAd = new KeyVaultAd(); Configuration.GetSection(nameof(KeyVaultAd)).Bind(keyVaultAd); var handler = new HttpClientHandler { Proxy = new WebProxy { Address = new Uri(keyVaultAd.ProxyUrl), BypassProxyOnLocal = false, UseDefaultCredentials = false, // *** These creds are given to the proxy server, not the web server *** Credentials = new NetworkCredential(keyVaultAd.ProxyUsername, keyVaultAd.ProxyPassword) } }; var kv = new KeyVaultClient( async(string authority, string resource, string scope) => { var authContext = new AuthenticationContext(authority); var clientId = Configuration.GetSection("AzureAd").GetValue <string>("ClientId"); var clientSecret = Configuration.GetSection("AzureAd").GetValue <string>("ClientSecret"); ClientCredential clientCred = new ClientCredential(clientId, clientSecret); AuthenticationResult result = await authContext.AcquireTokenAsync(resource, clientCred); if (result == null) { throw new InvalidOperationException("Failed to retrieve access token for Key Vault"); } return(result.AccessToken); }, new HttpClient(handler, true) ); services.AddSingleton <IKeyVaultClient>(kv); // Register DA services.AddTransient <ICountryDataAccess, CountryDataAccess>(); // Register Services services.AddTransient <ICountryService, CountryService>(); }
/// <summary> /// Initializes a new instance of the AutoRestRFC1123DateTimeTestService class. /// </summary> /// <param name='rootHandler'> /// Optional. The http client handler used to handle http transport. /// </param> /// <param name='handlers'> /// Optional. The delegating handlers to add to the http client pipeline. /// </param> public AutoRestRFC1123DateTimeTestService(HttpClientHandler rootHandler, params DelegatingHandler[] handlers) : base(rootHandler, handlers) { this.Initialize(); }
/// <summary> /// Performs a query on the Twitter Stream. /// </summary> /// <param name="request">Request with url endpoint and all query parameters.</param> /// <returns> /// Caller expects an JSON formatted string response, but /// real response(s) with streams is fed to the callback. /// </returns> public async Task <string> QueryTwitterStreamAsync(Request request) { WriteLog(request.FullUrl, "QueryTwitterStreamAsync"); var handler = new HttpClientHandler(); if (Authorizer.Proxy != null && handler.SupportsProxy) { handler.Proxy = Authorizer.Proxy; } using (StreamingClient = new HttpClient(handler)) { StreamingClient.Timeout = TimeSpan.FromMilliseconds(System.Threading.Timeout.Infinite); var httpRequest = ConfigureRequest(request); var response = await StreamingClient.SendAsync( httpRequest, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false); await TwitterErrorHandler.ThrowIfErrorAsync(response).ConfigureAwait(false); Stream stream = await CreateStream(response); const int CarriageReturn = 0x0D; const int LineFeed = 0x0A; var memStr = new MemoryStream(); byte[] readByte; while (stream.CanRead && !IsStreamClosed) { readByte = new byte[1]; await stream.ReadAsync(readByte, 0, 1, CancellationToken).ConfigureAwait(false); byte nextByte = readByte.SingleOrDefault(); CancellationToken.ThrowIfCancellationRequested(); if (IsStreamClosed) { break; } if (nextByte == -1) { break; } if (nextByte != CarriageReturn && nextByte != LineFeed) { memStr.WriteByte(nextByte); } if (nextByte == LineFeed) { int byteCount = (int)memStr.Length; byte[] tweetBytes = new byte[byteCount]; memStr.Position = 0; await memStr.ReadAsync(tweetBytes, 0, byteCount, CancellationToken).ConfigureAwait(false); string tweet = Encoding.UTF8.GetString(tweetBytes, 0, byteCount); var strmContent = new StreamContent(this, tweet); await StreamingCallbackAsync(strmContent).ConfigureAwait(false); memStr.Dispose(); memStr = new MemoryStream(); } } } IsStreamClosed = false; return("{}"); }
/// <summary> /// Sends the specified text to be spoken to the TTS service and saves the response audio to a file. /// </summary> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>A Task</returns> public Task Speak(CancellationToken cancellationToken) { var cookieContainer = new CookieContainer(); var handler = new HttpClientHandler() { CookieContainer = cookieContainer }; var client = new HttpClient(handler); foreach (var header in this.inputOptions.Headers) { client.DefaultRequestHeaders.TryAddWithoutValidation(header.Key, header.Value); } var genderValue = ""; switch (this.inputOptions.VoiceType) { case Gender.Male: genderValue = "Male"; break; case Gender.Female: default: genderValue = "Female"; break; } var request = new HttpRequestMessage(HttpMethod.Post, this.inputOptions.RequestUri) { Content = new StringContent(String.Format(SsmlTemplate, this.inputOptions.Locale, genderValue, this.inputOptions.VoiceName, this.inputOptions.Text)) }; var httpTask = client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken); Console.WriteLine("Response status code: [{0}]", httpTask.Result.StatusCode); var saveTask = httpTask.ContinueWith( async(responseMessage, token) => { try { if (responseMessage.IsCompleted && responseMessage.Result != null && responseMessage.Result.IsSuccessStatusCode) { var httpStream = await responseMessage.Result.Content.ReadAsStreamAsync().ConfigureAwait(false); this.AudioAvailable(new GenericEventArgs <Stream>(httpStream)); } else { this.Error(new GenericEventArgs <Exception>(new Exception(String.Format("Service returned {0}", responseMessage.Result.StatusCode)))); } } catch (Exception e) { this.Error(new GenericEventArgs <Exception>(e.GetBaseException())); } finally { responseMessage.Dispose(); request.Dispose(); client.Dispose(); handler.Dispose(); } }, TaskContinuationOptions.AttachedToParent, cancellationToken); return(saveTask); }
/// <summary> /// Initializes a new instance of the AutoRestValidationTest class. /// </summary> /// <param name='rootHandler'> /// Optional. The http client handler used to handle http transport. /// </param> /// <param name='handlers'> /// Optional. The delegating handlers to add to the http client pipeline. /// </param> public AutoRestValidationTest(HttpClientHandler rootHandler, params DelegatingHandler[] handlers) : base(rootHandler, handlers) { this.Initialize(); }
/// <summary> /// Initializes a new instance of the AutoRestSwaggerBATByteService class. /// </summary> /// <param name='rootHandler'> /// Optional. The http client handler used to handle http transport. /// </param> /// <param name='handlers'> /// Optional. The delegating handlers to add to the http client pipeline. /// </param> public AutoRestSwaggerBATByteService(HttpClientHandler rootHandler, params DelegatingHandler[] handlers) : base(rootHandler, handlers) { this.Initialize(); }
public GhostBuster() { Handler = new HttpClientHandler(); Client = new HttpClient(Handler); }
public LuisRecognizer(LuisApplication application, LuisPredictionOptions predictionOptions = null, bool includeApiResults = false, HttpClientHandler clientHandler = null) #pragma warning disable CS0618 // Type or member is obsolete : this(application, telemetryClient: null, logPersonalInformation: false, predictionOptions: predictionOptions, includeApiResults: includeApiResults, clientHandler: clientHandler) #pragma warning restore CS0618 // Type or member is obsolete { }
public static IServiceCollection AddProjectServices(this IServiceCollection services) { // PartyMatchManagement Client _ = services .AddTransient <UserAgentDelegatingHandler>() .AddTransient <PartyMatchManagementAuthenticationHandler>() .AddHttpClient <IPartyMatchClient, PartyMatchClient>((serviceProvider, httpClient) => { var options = serviceProvider.GetRequiredService <PartyMatchManagementOptions>(); SetHttpClientConfig(httpClient, options); }) .ConfigurePrimaryHttpMessageHandler(x => new DefaultHttpClientHandler()) .AddHttpMessageHandler <PartyMatchManagementAuthenticationHandler>() .AddHttpMessageHandler <UserAgentDelegatingHandler>(); //QuoteManagement Client _ = services .AddTransient <QuoteManagementAuthenticationHandler>() .AddHttpClient <IQuoteManagementClient, QuoteManagementClient>((serviceProvider, httpClient) => { var options = serviceProvider.GetRequiredService <QuoteManagementOptions>(); SetHttpClientConfig(httpClient, options); }) .ConfigurePrimaryHttpMessageHandler(x => new DefaultHttpClientHandler()) .AddHttpMessageHandler <QuoteManagementAuthenticationHandler>() .AddHttpMessageHandler <UserAgentDelegatingHandler>(); //CartManagement Client _ = services .AddTransient <CartManagementAuthenticationHandler>() .AddHttpClient <ICartManagementClient, CartManagementClient>((serviceProvider, httpClient) => { var options = serviceProvider.GetRequiredService <CartManagementOptions>(); SetHttpClientConfig(httpClient, options); }) .ConfigurePrimaryHttpMessageHandler(x => new DefaultHttpClientHandler()) .AddHttpMessageHandler <CartManagementAuthenticationHandler>() .AddHttpMessageHandler <UserAgentDelegatingHandler>(); //PartyManagement Client _ = services .AddTransient <PartyManagementBearerTokenAuthenticationHandler>() .AddHttpClient() .AddHttpClient <IPartyManagementClient, PartyManagementClient>((serviceProvider, httpClient) => { var options = serviceProvider.GetRequiredService <PartyManagementOptions>(); SetHttpClientConfig(httpClient, options); }) #if DEBUG .ConfigurePrimaryHttpMessageHandler(() => { var handler = new HttpClientHandler { #pragma warning disable SCS0004 // Certificate Validation has been disabled ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => true #pragma warning restore SCS0004 // Certificate Validation has been disabled }; return(handler); }) #else .ConfigurePrimaryHttpMessageHandler(x => new DefaultHttpClientHandler()) #endif .AddHttpMessageHandler <PartyManagementBearerTokenAuthenticationHandler>() .AddHttpMessageHandler <UserAgentDelegatingHandler>(); services.AddSingleton <IServiceBusSender, ServiceBusSender>(); services.AddSingleton <IValidator <Nomination>, NominationValidator>(); return(services); }
public static async Task <HttpClient> BuildHttpClient(string gridMaster, string apiVersion, Cookie cookie, TimeSpan?timeout = null) { if (!String.IsNullOrEmpty(gridMaster)) { if (!String.IsNullOrEmpty(apiVersion)) { if (cookie != null) { if (!cookie.Expired) { if (await CommandHelpers.CheckConnection(gridMaster)) { HttpClientHandler Handler = new HttpClientHandler() { CookieContainer = new CookieContainer() }; if (!apiVersion.StartsWith("v")) { apiVersion = $"v{apiVersion}"; } Uri Address = new Uri("https://" + gridMaster + "/wapi/" + apiVersion + "/"); Handler.CookieContainer.Add(Address, cookie); Handler.ServerCertificateCustomValidationCallback += (sender, cert, chain, sslPolicyErrors) => true; HttpClient Client = new HttpClient(Handler) { BaseAddress = Address }; //The actual default timeout is 100 seconds if (timeout != null) { Client.Timeout = (TimeSpan)timeout; } return(Client); } else { throw new WebException("The grid master could not be contacted."); } } else { throw new ArgumentException($"The provided cookie is expired, it expired on {cookie.Expires.ToUniversalTime().ToString()} UTC"); } } else { throw new ArgumentNullException("cookie", "Cookie cannot be null"); } } else { throw new ArgumentNullException("apiVersion", "The api version parameter cannot be null or empty."); } } else { throw new ArgumentNullException("gridMaster", "The value for the grid master cannot be null or empty."); } }
public static async Task <HttpClient> BuildHttpClient(string gridMaster, string apiVersion, string username, SecureString password, TimeSpan?timeout = null) { if (!String.IsNullOrEmpty(gridMaster)) { if (!String.IsNullOrEmpty(apiVersion)) { if (!String.IsNullOrEmpty(username)) { if (password != null) { if (await CommandHelpers.CheckConnection(gridMaster)) { HttpClientHandler Handler = new HttpClientHandler(); Handler.ServerCertificateCustomValidationCallback += (sender, cert, chain, sslPolicyErrors) => true; if (!apiVersion.StartsWith("v")) { apiVersion = $"v{apiVersion}"; } HttpClient Client = new HttpClient(Handler) { BaseAddress = new Uri("https://" + gridMaster + "/wapi/" + apiVersion + "/") }; //The actual default is 100 seconds if (timeout != null) { Client.Timeout = (TimeSpan)timeout; } Client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes(username + ":" + SecureStringHelper.ToReadableString(password)))); return(Client); } else { throw new WebException("The grid master could not be contacted."); } } else { throw new ArgumentNullException("password", "The provided password cannot be null."); } } else { throw new ArgumentNullException("username", "The username used to connect to the grid master cannot be null or empty."); } } else { throw new ArgumentNullException("apiVersion", "The api version parameter cannot be null or empty."); } } else { throw new ArgumentNullException("gridMaster", "The value for the grid master cannot be null or empty."); } }
public static async Task <HttpClient> BuildHttpClient(string gridMaster, string apiVersion, TimeSpan?timeout = null) { if (!String.IsNullOrEmpty(gridMaster)) { if (!String.IsNullOrEmpty(apiVersion)) { if (await CommandHelpers.CheckConnection(gridMaster)) { if (InfobloxSessionData.UseSessionData) { if (InfobloxSessionData.Cookie != null && !InfobloxSessionData.Cookie.Expired) { HttpClientHandler Handler = new HttpClientHandler() { CookieContainer = new CookieContainer() }; if (!apiVersion.StartsWith("v")) { apiVersion = $"v{apiVersion}"; } Uri Address = new Uri("https://" + gridMaster + "/wapi/" + apiVersion + "/"); Handler.CookieContainer.Add(Address, InfobloxSessionData.Cookie); Handler.ServerCertificateCustomValidationCallback += (sender, cert, chain, sslPolicyErrors) => true; HttpClient Client = new HttpClient(Handler) { BaseAddress = Address }; //The actual default is 100 seconds if (timeout != null) { Client.Timeout = (TimeSpan)timeout; } return(Client); } else { throw new Exception("There is not a valid cookie to utilize, you must specify a credential."); } } else { throw new Exception("There is not a valid cookie to utilize, you must specify a credential."); } } else { throw new WebException("The grid master could not be contacted."); } } else { throw new ArgumentNullException("apiVersion", "The api version parameter cannot be null or empty."); } } else { throw new ArgumentNullException("gridMaster", "The value for the grid master cannot be null or empty."); } }
public void Default_CredentialCacheDefaultCredentials_Same() { using (var handler = new HttpClientHandler()) { Assert.Same(CredentialCache.DefaultCredentials, handler.DefaultProxyCredentials); } }