private static HttpMessageHandler CreateMessageHandler(IProxyConfig proxyConfig) { var proxy = new WebProxy { Address = new UriBuilder(proxyConfig.Host) { Port = proxyConfig.Port }.Uri, UseDefaultCredentials = true, BypassProxyOnLocal = proxyConfig.BypassProxyOnLocal }; if (!string.IsNullOrEmpty(proxyConfig.User) || !string.IsNullOrEmpty(proxyConfig.Password)) { proxy.UseDefaultCredentials = false; proxy.Credentials = new NetworkCredential(proxyConfig.User, proxyConfig.Password); } var httpClientHandler = new HttpClientHandler { PreAuthenticate = proxy.UseDefaultCredentials, UseDefaultCredentials = proxy.UseDefaultCredentials, UseProxy = true, Proxy = proxy, }; if (proxyConfig.SkipSSLCheck) { httpClientHandler.ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) => true; } return(httpClientHandler); }
private void VerifyRoute(IProxyConfig validConfig, IProxyConfig abstractConfig, string routeId) { var route = validConfig.Routes.Single(c => c.RouteId == routeId); Assert.Single(abstractConfig.Routes.Where(c => c.RouteId == routeId)); var abstractRoute = abstractConfig.Routes.Single(c => c.RouteId == routeId); Assert.Equal(route.ClusterId, abstractRoute.ClusterId); Assert.Equal(route.Order, abstractRoute.Order); Assert.Equal(route.Match.Hosts, abstractRoute.Match.Hosts); Assert.Equal(route.Match.Methods, abstractRoute.Match.Methods); Assert.Equal(route.Match.Path, abstractRoute.Match.Path); var header = route.Match.Headers.Single(); var expectedHeader = abstractRoute.Match.Headers.Single(); Assert.Equal(header.Name, expectedHeader.Name); Assert.Equal(header.Mode, expectedHeader.Mode); Assert.Equal(header.IsCaseSensitive, expectedHeader.IsCaseSensitive); var queryparam = route.Match.QueryParameters.Single(); var expectedQueryParam = abstractRoute.Match.QueryParameters.Single(); Assert.Equal(queryparam.Name, expectedQueryParam.Name); Assert.Equal(queryparam.Mode, expectedQueryParam.Mode); Assert.Equal(queryparam.IsCaseSensitive, expectedQueryParam.IsCaseSensitive); // Skipping header.Value/s because it's a fuzzy match Assert.Equal(route.Transforms, abstractRoute.Transforms); }
public NetHttpClient(IProxyConfig proxyConfig) { Ensure.ArgumentNotNull(proxyConfig, nameof(proxyConfig)); _httpMessageHandler = CreateMessageHandler(proxyConfig); _httpClient = new HttpClient(_httpMessageHandler); }
public GitHubAPI(IProxyConfig proxyConfig) { this.proxyConfig = proxyConfig; ServicePointManager.Expect100Continue = true; ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12; }
public WebConnectionConfig(bool useCompression, int httpTimeout, int retriesCount, IProxyConfig proxyConfig) { _useCompression = useCompression; _httpTimeout = httpTimeout; _retriesCount = retriesCount; _proxyConfig = proxyConfig; }
/// public void Initialize(IProxyConfig proxyConfig, string host, int port) { if (IsInitialized) { return; } // Create version service var binding = new BasicHttpBinding { SendTimeout = new TimeSpan(0, 0, 2), OpenTimeout = new TimeSpan(0, 0, 2) }; //Set proxy SetProxyOnBinding(proxyConfig, binding); var url = $@"http://{host}:{port}/{ServiceName}"; var endpoint = new EndpointAddress(url); var channelFactory = new ChannelFactory <IVersionService>(binding); channelFactory.Endpoint.Behaviors.Add(new CultureBehavior()); _versionService = channelFactory.CreateChannel(endpoint); IsInitialized = true; }
private void UpdateRules() { if (this.proxyConfig?.ChangeToken.HasChanged ?? true) { lock (this.rules) { if (this.proxyConfig?.ChangeToken.HasChanged ?? true) { this.proxyConfigSubscription?.Dispose(); var newRules = new Dictionary <string, DelegationRule>(); var newProxyConfig = this.proxyConfigProvider.GetConfig(); var queueDelegationRules = newProxyConfig.Clusters .SelectMany(c => c.Destinations) .Where(d => ShouldUseQueueDelegation(d.Value)); foreach (KeyValuePair <string, Destination> destination in queueDelegationRules) { if (this.rules.Remove(destination.Key, out DelegationRule rule)) { newRules.Add(destination.Key, rule); } else { try { rule = this.delegationFeature.CreateDelegationRule(destination.Key, destination.Value.Address); newRules.Add(destination.Key, rule); this.logger.LogDebug($"Added delegation rule: {rule.QueueName} - {rule.UrlPrefix}"); } catch (HttpSysException ex) when(ex.ErrorCode == 183) { // It's possible we hit this issue // https://github.com/dotnet/aspnetcore/issues/27126 this.logger.LogError( ex, "Failed to create delegation rule. Are you trying to add a previously removed rule, if so that doesn't work right now"); } catch (Exception ex) { this.logger.LogError(ex, "Failed to create delegation rule"); } } } foreach (DelegationRule rule in this.rules.Values) { this.logger.LogDebug($"Removing delegation rule: {rule.QueueName} - {rule.UrlPrefix}"); DisposeDelegationRule(rule); } this.proxyConfigSubscription = newProxyConfig.ChangeToken.RegisterChangeCallback(s => this.UpdateRules(), null); this.rules = newRules; this.proxyConfig = newProxyConfig; } } } }
private void VerifyValidAbstractConfig(IProxyConfig validConfig, X509Certificate2 certificate, IProxyConfig abstractConfig) { Assert.NotNull(abstractConfig); Assert.Equal(2, abstractConfig.Clusters.Count); var cluster1 = validConfig.Clusters.First(c => c.Id == "cluster1"); Assert.Single(abstractConfig.Clusters.Where(c => c.Id == "cluster1")); var abstractCluster1 = abstractConfig.Clusters.Single(c => c.Id == "cluster1"); Assert.Equal(cluster1.Destinations["destinationA"].Address, abstractCluster1.Destinations["destinationA"].Address); Assert.Equal(cluster1.Destinations["destinationA"].Health, abstractCluster1.Destinations["destinationA"].Health); Assert.Equal(cluster1.Destinations["destinationA"].Metadata, abstractCluster1.Destinations["destinationA"].Metadata); Assert.Equal(cluster1.Destinations["destinationB"].Address, abstractCluster1.Destinations["destinationB"].Address); Assert.Equal(cluster1.Destinations["destinationB"].Health, abstractCluster1.Destinations["destinationB"].Health); Assert.Equal(cluster1.Destinations["destinationB"].Metadata, abstractCluster1.Destinations["destinationB"].Metadata); Assert.Equal(cluster1.HealthCheck.Passive.Enabled, abstractCluster1.HealthCheck.Passive.Enabled); Assert.Equal(cluster1.HealthCheck.Passive.Policy, abstractCluster1.HealthCheck.Passive.Policy); Assert.Equal(cluster1.HealthCheck.Passive.ReactivationPeriod, abstractCluster1.HealthCheck.Passive.ReactivationPeriod); Assert.Equal(cluster1.HealthCheck.Active.Enabled, abstractCluster1.HealthCheck.Active.Enabled); Assert.Equal(cluster1.HealthCheck.Active.Interval, abstractCluster1.HealthCheck.Active.Interval); Assert.Equal(cluster1.HealthCheck.Active.Timeout, abstractCluster1.HealthCheck.Active.Timeout); Assert.Equal(cluster1.HealthCheck.Active.Policy, abstractCluster1.HealthCheck.Active.Policy); Assert.Equal(cluster1.HealthCheck.Active.Path, abstractCluster1.HealthCheck.Active.Path); Assert.Equal(LoadBalancingPolicies.Random, abstractCluster1.LoadBalancingPolicy); Assert.Equal(cluster1.SessionAffinity.Enabled, abstractCluster1.SessionAffinity.Enabled); Assert.Equal(cluster1.SessionAffinity.FailurePolicy, abstractCluster1.SessionAffinity.FailurePolicy); Assert.Equal(cluster1.SessionAffinity.Mode, abstractCluster1.SessionAffinity.Mode); Assert.Equal(cluster1.SessionAffinity.Settings, abstractCluster1.SessionAffinity.Settings); Assert.Same(certificate, abstractCluster1.HttpClient.ClientCertificate); Assert.Equal(cluster1.HttpClient.MaxConnectionsPerServer, abstractCluster1.HttpClient.MaxConnectionsPerServer); #if NET Assert.Equal(cluster1.HttpClient.EnableMultipleHttp2Connections, abstractCluster1.HttpClient.EnableMultipleHttp2Connections); Assert.Equal(Encoding.UTF8, abstractCluster1.HttpClient.RequestHeaderEncoding); #endif Assert.Equal(cluster1.HttpClient.ActivityContextHeaders, abstractCluster1.HttpClient.ActivityContextHeaders); Assert.Equal(SslProtocols.Tls11 | SslProtocols.Tls12, abstractCluster1.HttpClient.SslProtocols); Assert.Equal(cluster1.HttpRequest.Timeout, abstractCluster1.HttpRequest.Timeout); Assert.Equal(HttpVersion.Version10, abstractCluster1.HttpRequest.Version); #if NET Assert.Equal(cluster1.HttpRequest.VersionPolicy, abstractCluster1.HttpRequest.VersionPolicy); #endif Assert.Equal(cluster1.HttpClient.DangerousAcceptAnyServerCertificate, abstractCluster1.HttpClient.DangerousAcceptAnyServerCertificate); Assert.Equal(cluster1.Metadata, abstractCluster1.Metadata); var cluster2 = validConfig.Clusters.First(c => c.Id == "cluster2"); Assert.Single(abstractConfig.Clusters.Where(c => c.Id == "cluster2")); var abstractCluster2 = abstractConfig.Clusters.Single(c => c.Id == "cluster2"); Assert.Equal(cluster2.Destinations["destinationC"].Address, abstractCluster2.Destinations["destinationC"].Address); Assert.Equal(cluster2.Destinations["destinationC"].Metadata, abstractCluster2.Destinations["destinationC"].Metadata); Assert.Equal(cluster2.Destinations["destinationD"].Address, abstractCluster2.Destinations["destinationD"].Address); Assert.Equal(cluster2.Destinations["destinationD"].Metadata, abstractCluster2.Destinations["destinationD"].Metadata); Assert.Equal(LoadBalancingPolicies.RoundRobin, abstractCluster2.LoadBalancingPolicy); Assert.Equal(2, abstractConfig.Routes.Count); VerifyRoute(validConfig, abstractConfig, "routeA"); VerifyRoute(validConfig, abstractConfig, "routeB"); }
/// <summary> /// Initializes this factory. /// </summary> /// <param name="factoryConfig">The configuration of this factory.</param> /// <param name="proxyConfig">An optional proxy configuration.</param> /// <param name="threadContext">For WPF applications, an instance of WpfThreadContext should be passed here. /// For console applications or Windows services an instance of SimpleThreadContext should be used instead.</param> protected void Initialize(IWcfClientFactoryConfig factoryConfig, IProxyConfig proxyConfig, IThreadContext threadContext) { _factoryConfig = factoryConfig; _proxyConfig = proxyConfig; _threadContext = threadContext; VersionService = new VersionServiceManager(proxyConfig, factoryConfig.Host, factoryConfig.Port); }
/// <summary> /// Creates a new SocksWebProxy /// </summary> /// <param name="config">Proxy settings</param> /// <param name="allowBypass">Whether to allow bypassing the proxy server. /// The current implementation to allow bypassing the proxy server requiers elevated privileges. /// If you want to use the library in an environment with limited privileges (like Azure Websites or Azure Webjobs), set allowBypass = false</param> /// <returns></returns> public SocksWebProxy(ProxyConfig config = null, bool allowBypass = true) { if (config == null) { config = ProxyConfig.Settings ?? new ProxyConfig(); } Config = config; GetListener(config, allowBypass); }
public void Initialize(IProxyConfig proxyConfig, string host, int port) { IsInitialized = true; Binding = BindingType.BasicHttp; MinClientVersion = "2.0.0.0"; ServerVersion = "1.0.0.0"; ServiceUrl = "http://blah.fasel"; EnableVersionService = true; }
private static WebRequest CreateWebRequest(string url, IProxyConfig proxyConfig = null) { WebRequest webRequest = WebRequest.Create(url); AddDefaultHeaders(webRequest); webRequest.Method = HttpMethod.Head.Method; webRequest.Proxy = proxyConfig?.CreateWebProxy(); webRequest.Timeout = 10000; return(webRequest); }
/// <summary> /// Initializes a new instance of the <see cref="NewsfeedListener"/> class. /// </summary> /// <param name="proxyConfig"></param> /// <see cref="IProxyConfig"/> public NewsfeedListener(IProxyConfig proxyConfig) { ThreadPool.SetMaxThreads(50, 1000); // TODO: Put in config section ThreadPool.SetMinThreads(50, 50); // TODO: Put in config section _uriListener = new HttpListener(); string prefix = UriHelper.CalculateCombinedPath(proxyConfig); // TODO: to be removed !! // _uriListener.Prefixes.Add("http://+:80/"); // _uriListener.Prefixes.Add("http://*:8080/"); // TODO: to be removed !! _uriListener.Prefixes.Add(prefix); }
public ProxyConfig(IProxyConfig proxyConfig) { if (proxyConfig != null) { _proxyAddress = proxyConfig.Address; var networkCredentials = proxyConfig.Credentials as NetworkCredential; if (networkCredentials != null) { Credentials = new NetworkCredential(networkCredentials.UserName, networkCredentials.Password, networkCredentials.Domain); } } }
private void VerifyRoute(ConfigurationData validConfig, IProxyConfig abstractConfig, string routeId) { var route = validConfig.Routes.Single(c => c.RouteId == routeId); Assert.Single(abstractConfig.Routes.Where(c => c.RouteId == routeId)); var abstractRoute = abstractConfig.Routes.Single(c => c.RouteId == routeId); Assert.Equal(route.ClusterId, abstractRoute.ClusterId); Assert.Equal(route.Order, abstractRoute.Order); Assert.Equal(route.Match.Hosts, abstractRoute.Match.Hosts); Assert.Equal(route.Match.Methods, abstractRoute.Match.Methods); Assert.Equal(route.Match.Path, abstractRoute.Match.Path); Assert.Equal(route.Transforms, abstractRoute.Transforms); }
// Throws for validation failures private async Task ApplyConfigAsync(IProxyConfig config) { var(configuredRoutes, routeErrors) = await VerifyRoutesAsync(config.Routes, cancellation : default); var(configuredClusters, clusterErrors) = await VerifyClustersAsync(config.Clusters, cancellation : default); if (routeErrors.Count > 0 || clusterErrors.Count > 0) { throw new AggregateException("The proxy config is invalid.", routeErrors.Concat(clusterErrors)); } // Update clusters first because routes need to reference them. UpdateRuntimeClusters(configuredClusters); UpdateRuntimeRoutes(configuredRoutes); }
/// private static void SetProxyOnBinding(IProxyConfig proxyConfig, BasicHttpBinding binding) { if (proxyConfig == null || !proxyConfig.EnableProxy) { return; } if (proxyConfig.UseDefaultWebProxy) { binding.UseDefaultWebProxy = true; } else if (!string.IsNullOrEmpty(proxyConfig.Address) && proxyConfig.Port != 0) { binding.ProxyAddress = new Uri($"http://{proxyConfig.Address}:{proxyConfig.Port}"); } }
public static bool CheckInternetConnection([CanBeNull] IProxyConfig proxyConfig) { // NOTE: Not using PING as it might be blocked in some workplaces and schools var httpClientHandler = CreateHttpClientHandler(proxyConfig); if (!CheckConnectionToUri("http://clients3.google.com/generate_204", httpClientHandler)) { // Google might be blocked in some countries (China?) if (!CheckConnectionToUri("https://github.com", httpClientHandler)) { // As last resort, try Spotify return(CheckConnectionToUri("https://www.spotify.com", httpClientHandler)); } } return(true); }
/// <summary> /// Creates a HttpClient based on the proxy config and base address /// </summary> public static HttpClient GetClient(string baseAddress, IProxyConfig proxyConfig) { var httpClient = new HttpClient(); if (proxyConfig?.EnableProxy == true && !proxyConfig.UseDefaultWebProxy) { var proxy = new WebProxy { Address = new Uri($"http://{proxyConfig.Address}:{proxyConfig.Port}"), BypassProxyOnLocal = false, UseDefaultCredentials = true }; httpClient = new HttpClient(new HttpClientHandler { Proxy = proxy }); } httpClient.BaseAddress = new Uri(baseAddress); return(httpClient); }
public VersionServiceManager(IProxyConfig proxyConfig, string host, int port) { // Create HttpClient if (proxyConfig?.EnableProxy == true && !proxyConfig.UseDefaultWebProxy) { var proxy = new WebProxy { Address = new Uri($"http://{proxyConfig.Address}:{proxyConfig.Port}"), BypassProxyOnLocal = false, UseDefaultCredentials = true }; _client = new HttpClient(new HttpClientHandler { Proxy = proxy }); } else { _client = new HttpClient(); } _client.BaseAddress = new Uri($"http://{host}:{port}/{ServiceName}/"); }
public static HttpClientHandler CreateHttpClientHandler([CanBeNull] IProxyConfig proxyConfig) { HttpClientHandler clientHandler = new HttpClientHandler { PreAuthenticate = false, UseDefaultCredentials = true, UseProxy = false }; if (proxyConfig?.IsValid() == true) { IWebProxy proxy = proxyConfig.CreateWebProxy(); if (proxy != null) { clientHandler.UseProxy = true; clientHandler.Proxy = proxy; clientHandler.UseDefaultCredentials = proxyConfig.UseDefaultCredentials; clientHandler.PreAuthenticate = proxyConfig.UseDefaultCredentials; } } return(clientHandler); }
public static string CalculateCombinedPath(IProxyConfig proxyConfig) { int portNumber; int.TryParse(proxyConfig.PortNumber, NumberStyles.Integer, CultureInfo.InvariantCulture, out portNumber); string uriPortCombined; //"http://www.contoso.com:8080/customerData/" if (!string.IsNullOrEmpty(proxyConfig.Uri)) { Uri uri = new Uri(proxyConfig.Uri); uriPortCombined = portNumber != 0 ? SetPort(uri, portNumber).OriginalString : proxyConfig.Uri; } else if (!string.IsNullOrEmpty(proxyConfig.PortNumber)) { uriPortCombined = string.Format("http://*:{0}/", proxyConfig.PortNumber); } else { uriPortCombined = "http://*/"; } return(uriPortCombined); }
/// <summary> /// Initializes this factory. /// </summary> /// <param name="factoryConfig">The configuration of this factory.</param> /// <param name="proxyConfig">An optional proxy configuration.</param> /// <param name="threadContext">For WPF applications, an instance of WpfThreadContext should be passed here. /// For console applications or Windows services an instance of SimpleThreadContext should be used instead.</param> protected void Initialize(IWcfClientFactoryConfig factoryConfig, IProxyConfig proxyConfig, IThreadContext threadContext) { _factoryConfig = factoryConfig; _proxyConfig = proxyConfig; _threadContext = threadContext; }
private void SetConfig(IProxyConfig config) { _cache.Set("ReverseProxyConfig", config); }
private void VerifyValidAbstractConfig(ConfigurationData validConfig, X509Certificate2 certificate, IProxyConfig abstractConfig) { Assert.NotNull(abstractConfig); Assert.Equal(2, abstractConfig.Clusters.Count); Assert.Single(abstractConfig.Clusters.Where(c => c.Id == "cluster1")); var abstractCluster1 = abstractConfig.Clusters.Single(c => c.Id == "cluster1"); Assert.Equal(validConfig.Clusters["cluster1"].Destinations["destinationA"].Address, abstractCluster1.Destinations["destinationA"].Address); Assert.Equal(validConfig.Clusters["cluster1"].Destinations["destinationA"].Health, abstractCluster1.Destinations["destinationA"].Health); Assert.Equal(validConfig.Clusters["cluster1"].Destinations["destinationA"].Metadata, abstractCluster1.Destinations["destinationA"].Metadata); Assert.Equal(validConfig.Clusters["cluster1"].Destinations["destinationB"].Address, abstractCluster1.Destinations["destinationB"].Address); Assert.Equal(validConfig.Clusters["cluster1"].Destinations["destinationB"].Health, abstractCluster1.Destinations["destinationB"].Health); Assert.Equal(validConfig.Clusters["cluster1"].Destinations["destinationB"].Metadata, abstractCluster1.Destinations["destinationB"].Metadata); Assert.Equal(validConfig.Clusters["cluster1"].CircuitBreaker.MaxConcurrentRequests, abstractCluster1.CircuitBreaker.MaxConcurrentRequests); Assert.Equal(validConfig.Clusters["cluster1"].CircuitBreaker.MaxConcurrentRetries, abstractCluster1.CircuitBreaker.MaxConcurrentRetries); Assert.Equal(validConfig.Clusters["cluster1"].HealthCheck.Passive.Enabled, abstractCluster1.HealthCheck.Passive.Enabled); Assert.Equal(validConfig.Clusters["cluster1"].HealthCheck.Passive.Policy, abstractCluster1.HealthCheck.Passive.Policy); Assert.Equal(validConfig.Clusters["cluster1"].HealthCheck.Passive.ReactivationPeriod, abstractCluster1.HealthCheck.Passive.ReactivationPeriod); Assert.Equal(validConfig.Clusters["cluster1"].HealthCheck.Active.Enabled, abstractCluster1.HealthCheck.Active.Enabled); Assert.Equal(validConfig.Clusters["cluster1"].HealthCheck.Active.Interval, abstractCluster1.HealthCheck.Active.Interval); Assert.Equal(validConfig.Clusters["cluster1"].HealthCheck.Active.Timeout, abstractCluster1.HealthCheck.Active.Timeout); Assert.Equal(validConfig.Clusters["cluster1"].HealthCheck.Active.Policy, abstractCluster1.HealthCheck.Active.Policy); Assert.Equal(validConfig.Clusters["cluster1"].HealthCheck.Active.Path, abstractCluster1.HealthCheck.Active.Path); Assert.Equal(Abstractions.LoadBalancingMode.Random, abstractCluster1.LoadBalancing.Mode); Assert.Equal(validConfig.Clusters["cluster1"].Partitioning.PartitionCount, abstractCluster1.Partitioning.PartitionCount); Assert.Equal(validConfig.Clusters["cluster1"].Partitioning.PartitioningAlgorithm, abstractCluster1.Partitioning.PartitioningAlgorithm); Assert.Equal(validConfig.Clusters["cluster1"].Partitioning.PartitionKeyExtractor, abstractCluster1.Partitioning.PartitionKeyExtractor); Assert.Equal(validConfig.Clusters["cluster1"].Quota.Average, abstractCluster1.Quota.Average); Assert.Equal(validConfig.Clusters["cluster1"].Quota.Burst, abstractCluster1.Quota.Burst); Assert.Equal(validConfig.Clusters["cluster1"].SessionAffinity.Enabled, abstractCluster1.SessionAffinity.Enabled); Assert.Equal(validConfig.Clusters["cluster1"].SessionAffinity.FailurePolicy, abstractCluster1.SessionAffinity.FailurePolicy); Assert.Equal(validConfig.Clusters["cluster1"].SessionAffinity.Mode, abstractCluster1.SessionAffinity.Mode); Assert.Equal(validConfig.Clusters["cluster1"].SessionAffinity.Settings, abstractCluster1.SessionAffinity.Settings); Assert.Same(certificate, abstractCluster1.HttpClient.ClientCertificate); Assert.Equal(validConfig.Clusters["cluster1"].HttpClient.MaxConnectionsPerServer, abstractCluster1.HttpClient.MaxConnectionsPerServer); Assert.Equal(SslProtocols.Tls11 | SslProtocols.Tls12, abstractCluster1.HttpClient.SslProtocols); Assert.Equal(validConfig.Clusters["cluster1"].HttpClient.DangerousAcceptAnyServerCertificate, abstractCluster1.HttpClient.DangerousAcceptAnyServerCertificate); Assert.Equal(validConfig.Clusters["cluster1"].HttpRequest.RequestTimeout, abstractCluster1.HttpRequest.RequestTimeout); Assert.Equal(HttpVersion.Version10, abstractCluster1.HttpRequest.Version); #if NET Assert.Equal(validConfig.Clusters["cluster1"].HttpRequest.VersionPolicy, abstractCluster1.HttpRequest.VersionPolicy); #endif Assert.Equal(validConfig.Clusters["cluster1"].Metadata, abstractCluster1.Metadata); Assert.Single(abstractConfig.Clusters.Where(c => c.Id == "cluster2")); var abstractCluster2 = abstractConfig.Clusters.Single(c => c.Id == "cluster2"); Assert.Equal(validConfig.Clusters["cluster2"].Destinations["destinationC"].Address, abstractCluster2.Destinations["destinationC"].Address); Assert.Equal(validConfig.Clusters["cluster2"].Destinations["destinationC"].Metadata, abstractCluster2.Destinations["destinationC"].Metadata); Assert.Equal(validConfig.Clusters["cluster2"].Destinations["destinationD"].Address, abstractCluster2.Destinations["destinationD"].Address); Assert.Equal(validConfig.Clusters["cluster2"].Destinations["destinationD"].Metadata, abstractCluster2.Destinations["destinationD"].Metadata); Assert.Equal(Abstractions.LoadBalancingMode.RoundRobin, abstractCluster2.LoadBalancing.Mode); Assert.Equal(2, abstractConfig.Routes.Count); VerifyRoute(validConfig, abstractConfig, "routeA"); VerifyRoute(validConfig, abstractConfig, "routeB"); }
public WcfVersionServiceManager(IProxyConfig proxyConfig, string host, int port) : base(proxyConfig, host, port) { }
/// <inheritdoc /> public ProductServiceModel(string host, int port, IProxyConfig proxyConfig, IModuleLogger logger) : base(host, port, proxyConfig, logger.GetChild(nameof(ProductServiceModel), typeof(ProductServiceModel))) { }
/// <summary> /// Creates a default BasicHttp binding including proxy configuration as configured for this factory. /// </summary> /// <param name="requiresAuthentication">If <c>true</c>, set the security mode to <c>BasicHttpSecurityMode.TransportCredentialOnly</c>, /// otherwise <c>BasicHttpSecurityMode.None</c> will be used.</param> /// <param name="proxyConfig">An optional proxy configuration.</param> /// <returns>The binding</returns> public static BasicHttpBinding CreateDefaultBasicHttpBinding(bool requiresAuthentication, IProxyConfig proxyConfig) { var binding = new BasicHttpBinding { MaxBufferSize = int.MaxValue, MaxReceivedMessageSize = int.MaxValue, ReceiveTimeout = TimeSpan.FromSeconds(30), SendTimeout = TimeSpan.FromSeconds(30), OpenTimeout = TimeSpan.FromSeconds(30), CloseTimeout = TimeSpan.FromSeconds(30), ReaderQuotas = { MaxArrayLength = int.MaxValue, MaxStringContentLength = int.MaxValue, MaxBytesPerRead = int.MaxValue }, Security = { Mode = requiresAuthentication ? BasicHttpSecurityMode.TransportCredentialOnly : BasicHttpSecurityMode.None, Transport = { ClientCredentialType = HttpClientCredentialType.Ntlm, ProxyCredentialType = HttpProxyCredentialType.Ntlm, }, Message = { ClientCredentialType = BasicHttpMessageCredentialType.UserName, } }, UseDefaultWebProxy = false, }; if (proxyConfig != null && proxyConfig.EnableProxy) { binding.UseDefaultWebProxy = proxyConfig.UseDefaultWebProxy; if (!string.IsNullOrEmpty(proxyConfig.Address) && proxyConfig.Port != 0) { var proxyUrl = $"http://{proxyConfig.Address}:{proxyConfig.Port}"; binding.ProxyAddress = new Uri(proxyUrl); } } return(binding); }
/// <summary> /// Creates the default binding by type of the binding. /// </summary> /// <param name="type">The type.</param> /// <param name="requiresAuthentication">if set to <c>true</c> [requires authentication].</param> /// <param name="proxyConfig">The proxy configuration.</param> /// <returns></returns> internal static Binding CreateDefault(BindingType type, bool requiresAuthentication, IProxyConfig proxyConfig) { switch (type) { case BindingType.NetTcp: return(CreateDefaultNetTcpBinding()); case BindingType.BasicHttp: return(CreateDefaultBasicHttpBinding(requiresAuthentication, proxyConfig)); default: return(null); } }
public void Setup() { _proxyConfig = new ProxyConfig(UriCetrea, PortNumberCetrea); _newsfeedListener = new NewsfeedListener(_proxyConfig); _newsfeedListener.Start(); }