private void Run(int port) { var protocol = new RingMasterCommunicationProtocol(); this.CreateBackend(); using (var cancel = new CancellationTokenSource()) { this.ringMasterServer = new RingMasterServer(protocol, null, cancel.Token); var transportConfig = new SecureTransport.Configuration { UseSecureConnection = false, IsClientCertificateRequired = false, CommunicationProtocolVersion = RingMasterCommunicationProtocol.MaximumSupportedVersion, }; using (var serverTransport = new SecureTransport(transportConfig)) { this.ringMasterServer.RegisterTransport(serverTransport); this.ringMasterServer.OnInitSession = initRequest => { return(new CoreRequestHandler(this.backend, initRequest)); }; serverTransport.StartServer(port); Console.WriteLine("Press ENTER to exit..."); Console.ReadLine(); cancel.Cancel(); } } }
public void TestNullConfiguration() { var instrumentation = new RingMasterClientInstrumentation(); try { var serverSpec = new RingMasterClient.ServerSpec(); using (var ringMaster = new RingMasterClient(serverSpec, null, instrumentation, CancellationToken.None)) { Assert.Fail("ArgumentNullException should have been thrown"); } } catch (ArgumentNullException) { } var protocol = new RingMasterCommunicationProtocol(); try { using (var clientTransport = new SimpleTransport()) using (var ringMaster = new RingMasterClient(null, instrumentation, protocol, clientTransport, CancellationToken.None)) { Assert.Fail("ArgumentNullException should have been thrown"); } } catch (ArgumentNullException) { } }
private void ConnectPerformanceTest(ConfigurationSection config, CancellationToken cancellationToken) { try { var instrumentation = new ConnectPerformanceInstrumentation(this.MetricsFactory); var random = new Random(); string connectionString = config.GetStringValue("TargetConnectionString"); connectionString = Helpers.GetServerAddressIfNotProvided(connectionString); IPEndPoint[] endpoints = SecureTransport.ParseConnectionString(connectionString); string testPath = config.GetStringValue("TestPath"); int numConnections = config.GetIntValue("NumberOfConnections"); int maxConcurrentRequests = config.GetIntValue("MaxConcurrentRequests"); int minConnectionLifetimeSeconds = config.GetIntValue("MinConnectionLifetimeSeconds"); int maxConnectionLifetimeSeconds = config.GetIntValue("MaxConnectionLifetimeSeconds"); Func <IRingMasterRequestHandler> createConnection = () => { var connectionConfiguration = new SecureTransport.Configuration { UseSecureConnection = false, CommunicationProtocolVersion = RingMasterCommunicationProtocol.MaximumSupportedVersion, MaxConnectionLifespan = TimeSpan.FromSeconds(random.Next(minConnectionLifetimeSeconds, maxConnectionLifetimeSeconds)) }; var protocol = new RingMasterCommunicationProtocol(); var transport = new SecureTransport(connectionConfiguration, instrumentation, cancellationToken); var client = new RingMasterClient(protocol, transport); transport.StartClient(endpoints); ConnectionStressServiceEventSource.Log.CreateConnection( connectionConfiguration.UseSecureConnection, connectionConfiguration.CommunicationProtocolVersion, (long)connectionConfiguration.MaxConnectionLifespan.TotalSeconds); client.Exists("/", watcher: null).Wait(); return((IRingMasterRequestHandler)client); }; using (var connectPerformanceTest = new ConnectPerformance(instrumentation, maxConcurrentRequests, cancellationToken)) { ConnectionStressServiceEventSource.Log.ConnectPerformanceTestStarted(testPath, numConnections, minConnectionLifetimeSeconds, maxConnectionLifetimeSeconds); connectPerformanceTest.EstablishConnections(createConnection, numConnections); connectPerformanceTest.QueueRequests(testPath); } ConnectionStressServiceEventSource.Log.ConnectPerformanceTestCompleted(); } catch (Exception ex) { ConnectionStressServiceEventSource.Log.ConnectPerformanceTestFailed(ex.ToString()); } }
public void TestDefaultconfiguration() { var configuration = new RingMasterClient.Configuration(); var protocol = new RingMasterCommunicationProtocol(); using (var clientTransport = new SimpleTransport()) using (var ringMaster = new RingMasterClient(protocol, clientTransport)) { Assert.AreEqual((int)configuration.DefaultTimeout.TotalMilliseconds, ringMaster.Timeout); } }
private void ConnectPerformanceTest(SecureTransport.Configuration configuration, IPEndPoint[] endpoints, int numConnections) { var instrumentation = new ConnectPerformanceInstrumentation(); var random = new Random(); int minConnectionLifetimeSeconds = int.Parse(appSettings["ConnectPerformance.MinConnectionLifetimeSeconds"]); int maxConnectionLifetimeSeconds = int.Parse(appSettings["ConnectPerformance.MaxConnectionLifetimeSeconds"]); Func <IRingMasterRequestHandler> createConnection = () => { var connectionConfiguration = new SecureTransport.Configuration { UseSecureConnection = configuration.UseSecureConnection, ClientCertificates = configuration.ClientCertificates, ServerCertificates = configuration.ServerCertificates, CommunicationProtocolVersion = configuration.CommunicationProtocolVersion, MaxConnectionLifespan = TimeSpan.FromSeconds(random.Next(minConnectionLifetimeSeconds, maxConnectionLifetimeSeconds)), }; var protocol = new RingMasterCommunicationProtocol(); var transport = new SecureTransport(connectionConfiguration, instrumentation, CancellationToken.None); var client = new RingMasterClient(protocol, transport); transport.StartClient(endpoints); client.Exists("/", watcher: null).Wait(); return((IRingMasterRequestHandler)client); }; using (var connectPerformanceTest = new ConnectPerformance(instrumentation, this.MaxConcurrency, CancellationToken.None)) { Trace.TraceInformation($"Connect performance test numConnections={numConnections}, path={this.TestPath}, minConnectionLifetimeSeconds={minConnectionLifetimeSeconds}, maxConnectionLifetimeSeconds={maxConnectionLifetimeSeconds}"); connectPerformanceTest.EstablishConnections(createConnection, numConnections); var task = Task.Run(() => connectPerformanceTest.QueueRequests(this.TestPath)); long lastSuccessCount = 0; var timer = Stopwatch.StartNew(); while (!task.Wait(5000)) { timer.Stop(); long rate = (long)((instrumentation.Success - lastSuccessCount) * 1000) / timer.ElapsedMilliseconds; Trace.TraceInformation($"Connections created={instrumentation.ConnectionCreatedCount}, closed={instrumentation.ConnectionClosedCount}, requestSuccess={instrumentation.Success}, requestFailure={instrumentation.Failure}, rate={rate}"); timer.Restart(); lastSuccessCount = instrumentation.Success; } } }
private ICommunicationListener CreateListener(StatefulServiceContext context) { // Partition replica's URL is the node's IP, port, PartitionId, ReplicaId, Guid var protocol = EndpointProtocol.Tcp; try { var internalEndpoint = context.CodePackageActivationContext.GetEndpoint("ServiceEndpoint"); this.port = Convert.ToUInt16(internalEndpoint.Port); protocol = internalEndpoint.Protocol; RingMasterServiceEventSource.Log.CreateListener("RingMasterProtocol", this.port, 0); } catch (Exception ex) { RingMasterServiceEventSource.Log.CreateListener_GetEndpointFailed($"Failed to get ServiceEndpoint for RingMasterProtocol: {ex}"); throw; } var communicationProtocol = new RingMasterCommunicationProtocol(); this.ringMasterServer = new RingMasterServer( communicationProtocol, this.ringMasterServerInstrumentation, CancellationToken.None); string nodeIp = context.NodeContext.IPAddressOrFQDN; if (nodeIp.Equals("LocalHost", StringComparison.OrdinalIgnoreCase)) { nodeIp = GetHostIp(Dns.GetHostName()); } string uri = $"{protocol}://{nodeIp}:{this.port}/"; return(new TcpCommunicationListener( this.ringMasterServer, this.port, uri, this.backend, this.ringMasterServerInstrumentation, communicationProtocol, RingMasterCommunicationProtocol.MaximumSupportedVersion)); }
public void TestTimeoutConfiguration() { int timespanInMilliseconds = 4536; var configuration = new RingMasterClient.Configuration() { DefaultTimeout = TimeSpan.FromMilliseconds(timespanInMilliseconds) }; var protocol = new RingMasterCommunicationProtocol(); using (var clientTransport = new SimpleTransport()) using (var ringMaster = new RingMasterClient(configuration, null, protocol, clientTransport, CancellationToken.None)) { Assert.AreEqual(timespanInMilliseconds, ringMaster.Timeout); ringMaster.Timeout = 10000; Assert.AreEqual(10000, ringMaster.Timeout); } }
public RingMasterClient( ServerSpec serverSpec, Configuration configuration, IRingMasterClientInstrumentation instrumentation, IWatcher watcher, CancellationToken cancellationToken) { if (serverSpec == null) { throw new ArgumentNullException(nameof(serverSpec)); } if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } IPEndPoint[] endpoints = serverSpec.Endpoints; if ((endpoints == null) || (endpoints.Length == 0)) { throw new ArgumentException("Endpoints were not specified"); } if (watcher != null) { this.SetWatcher(watcher); } SecureTransport secureTransport = null; try { var transportConfiguration = new SecureTransport.Configuration(); transportConfiguration.UseSecureConnection = serverSpec.UseSecureConnection; transportConfiguration.ClientCertificates = new X509Certificate[] { serverSpec.ClientCertificate }; transportConfiguration.ServerCertificates = serverSpec.AcceptedServerCertificates; transportConfiguration.RemoteCertificateValidationCallback = serverSpec.ServerCertificateValidationCallback; transportConfiguration.LocalCertificateSelectionCallback = serverSpec.ClientCertificationSelectionCallback; transportConfiguration.MustCheckCertificateRevocation = serverSpec.MustCheckCertificateRevocation; transportConfiguration.MustCheckCertificateTrustChain = serverSpec.MustCheckCertificateTrustChain; transportConfiguration.CommunicationProtocolVersion = serverSpec.CommunicationProtocolVersion; transportConfiguration.SendBufferSize = configuration.BufferSize; transportConfiguration.ReceiveBufferSize = configuration.BufferSize; transportConfiguration.SendQueueLength = configuration.RequestQueueLength; transportConfiguration.AuthAsClient = true; List <SecureTransport.SubjectRuleValidation> subjectRules = new List <SecureTransport.SubjectRuleValidation>(); if (!string.IsNullOrWhiteSpace(serverSpec.CertValidationASubject) && serverSpec.CertValidationASigningThumbprints != null) { SecureTransport.SubjectValidation subjectA = new SecureTransport.SubjectValidation() { CertificateSubject = serverSpec.CertValidationASubject, SigningCertThumbprints = serverSpec.CertValidationASigningThumbprints, }; subjectRules.Add(new SecureTransport.SubjectRuleValidation(CertificateRules.AbstractCertificateRule.RoleToApply.ServerCert, subjectA)); } if (!string.IsNullOrWhiteSpace(serverSpec.CertValidationBSubject) && serverSpec.CertValidationBSigningThumbprints != null) { SecureTransport.SubjectValidation subjectB = new SecureTransport.SubjectValidation() { CertificateSubject = serverSpec.CertValidationBSubject, SigningCertThumbprints = serverSpec.CertValidationBSigningThumbprints, }; subjectRules.Add(new SecureTransport.SubjectRuleValidation(CertificateRules.AbstractCertificateRule.RoleToApply.ServerCert, subjectB)); } if (subjectRules != null && subjectRules.Count > 0) { transportConfiguration.SubjectValidations = subjectRules; } secureTransport = new SecureTransport(transportConfiguration, instrumentation: null, cancellationToken: cancellationToken); ICommunicationProtocol protocol = new RingMasterCommunicationProtocol(); var handlerConfiguration = new RingMasterRequestHandler.Configuration(); handlerConfiguration.DefaultTimeout = configuration.DefaultTimeout; handlerConfiguration.HeartBeatInterval = configuration.HeartBeatInterval; handlerConfiguration.RequestQueueLength = configuration.RequestQueueLength; handlerConfiguration.RequireLockForReadOnlyOperations = configuration.RequireLockForReadOnlyOperations; handlerConfiguration.MustTransparentlyForwardRequests = configuration.MustTransparentlyForwardRequests; var handlerInstrumentation = new RingMasterRequestHandlerInstrumentation(instrumentation); this.requestHandler = new RingMasterRequestHandler( handlerConfiguration, handlerInstrumentation, protocol, secureTransport, cancellationToken); foreach (var endpoint in endpoints) { RingMasterClientEventSource.Log.Start(endpoint.ToString()); } secureTransport.StartClient(endpoints); secureTransport = null; } finally { if (secureTransport != null) { secureTransport.Dispose(); } } }