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 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();
}
