protected IRingMasterRequestHandler ConnectToRingMaster() { SimpleTransport clientTransport = null; IRingMasterRequestHandler ringMaster = null; bool mustDispose = true; try { var configuration = new RingMasterClient.Configuration(); IRingMasterClientInstrumentation instrumentation = new RingMasterClientInstrumentation(); clientTransport = new SimpleTransport(); ringMaster = new RingMasterClient(configuration, instrumentation, this.protocol, clientTransport, CancellationToken.None); clientTransport.Connect(this.serverTransport); mustDispose = false; return(ringMaster); } finally { if (mustDispose) { ringMaster.Dispose(); clientTransport.Dispose(); } } }
/// <summary> /// Creates the ring master connection. /// </summary> /// <param name="connectionString">The connection string.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="timeStreamId">The time stream identifier.</param> /// <returns>ring master client connection</returns> public static IRingMasterRequestHandler CreateRingMasterTimeStreamRequestHandler(string connectionString, CancellationToken cancellationToken, ulong timeStreamId) { var configuration = new RingMasterClient.Configuration(); var ringMaster = new RingMasterClient(connectionString, configuration, null, cancellationToken); return(ringMaster.OpenTimeStream(timeStreamId)); }
public void TestConstructorWithServerSpec() { var serverSpec = new RingMasterClient.ServerSpec(); serverSpec.Endpoints = new IPEndPoint[] { new IPEndPoint(IPAddress.Loopback, 0) }; serverSpec.UseSecureConnection = true; serverSpec.ClientCertificate = GetLocalCertificates(1)[0]; serverSpec.AcceptedServerCertificates = GetLocalCertificates(1); var configuration = new RingMasterClient.Configuration(); configuration.DefaultTimeout = Timeout.InfiniteTimeSpan; configuration.HeartBeatInterval = Timeout.InfiniteTimeSpan; configuration.RequestQueueLength = int.MaxValue; configuration.BufferSize = int.MaxValue; var instrumentation = new RingMasterClientInstrumentation(); try { using (var client = new RingMasterClient(serverSpec, configuration, instrumentation, new CancellationToken(true))) { client.Sync("/").Wait(); } } catch (Exception) { } }
/// <summary> /// Initializes a new instance of the <see cref="RingMasterSession" /> class. /// </summary> /// <param name="serverSpec">Server spec</param> /// <param name="configuration">Client configuration</param> internal RingMasterSession( RingMasterClient.ServerSpec serverSpec, RingMasterClient.Configuration configuration) { this.ServerSpec = serverSpec; this.Configuration = configuration; this.Client = new RingMasterClient(serverSpec, configuration, instrumentation: null, cancellationToken: CancellationToken.None); }
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); } }
public void TestConstructorWithConnectionStringNoCancellationToken() { var configuration = new RingMasterClient.Configuration(); configuration.DefaultTimeout = Timeout.InfiniteTimeSpan; configuration.HeartBeatInterval = Timeout.InfiniteTimeSpan; configuration.RequestQueueLength = int.MaxValue; configuration.BufferSize = int.MaxValue; var instrumentation = new RingMasterClientInstrumentation(); using (var client = new RingMasterClient("127.0.0.1:0", configuration, instrumentation)) { } }
public void TestNullServerSpec() { var configuration = new RingMasterClient.Configuration(); var instrumentation = new RingMasterClientInstrumentation(); try { using (var clientTransport = new SimpleTransport()) using (var ringMaster = new RingMasterClient((RingMasterClient.ServerSpec)null, configuration, instrumentation, CancellationToken.None)) { Assert.Fail("ArgumentNullException should have been thrown"); } } catch (ArgumentNullException) { } }
private async Task <IRingMasterRequestHandler> ConnectToRingMaster(long iteration, CancellationToken cancellationToken) { using (var serviceDiscovery = new ServiceDiscovery()) { IReadOnlyList <Uri> endpoints = await serviceDiscovery.GetServiceEndpoints(this.ringMasterServiceUri, ServiceEndpointName); if (endpoints.Count == 0 || string.IsNullOrEmpty(endpoints[0].Host) || endpoints[0].Port <= 0) { return(null); } var configuration = new RingMasterClient.Configuration(); string connectionString = $"{endpoints[0].Host}:{endpoints[0].Port}"; RingMasterWatchdogEventSource.Log.ConnectToRingMaster(iteration, connectionString); return(new RingMasterClient(connectionString, configuration, null, cancellationToken)); } }
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); } }
protected override void ProcessRecord() { if (this.ServerSpec == null) { this.ServerSpec = new RingMasterClient.ServerSpec { Endpoints = SecureTransport.ParseConnectionString(this.ConnectionString), UseSecureConnection = false, }; } var configuration = new RingMasterClient.Configuration { DefaultTimeout = this.DefaultTimeout, HeartBeatInterval = this.HeartBeatInterval, RequestQueueLength = this.RequestQueueLength, }; this.WriteObject(new RingMasterSession(this.ServerSpec, configuration)); }
public void TestEmptyEndpoints() { var serverSpec = new RingMasterClient.ServerSpec(); var configuration = new RingMasterClient.Configuration(); var instrumentation = new RingMasterClientInstrumentation(); try { serverSpec.Endpoints = new IPEndPoint[0]; serverSpec.UseSecureConnection = false; using (var clientTransport = new SimpleTransport()) using (var ringMaster = new RingMasterClient(serverSpec, configuration, instrumentation, CancellationToken.None)) { Assert.Fail("ArgumentException should have been thrown"); } } catch (ArgumentException) { } }
private static IRingMasterRequestHandler ConnectToRingMaster(string connectionString, CancellationToken cancellationToken) { var configuration = new RingMasterClient.Configuration(); return(new RingMasterClient(connectionString, configuration, null, cancellationToken)); }
/// <summary> /// Entry point /// </summary> /// <param name="args">Arguments provided to the program</param> public static void Main(string[] args) { string testType = "getdata"; string ringMasterAddress = "127.0.0.1:99"; string path = "/Performance"; var assemblyPath = System.Reflection.Assembly.GetExecutingAssembly().Location; var builder = new ConfigurationBuilder().SetBasePath(Path.GetDirectoryName(assemblyPath)).AddJsonFile("appSettings.json"); appSettings = builder.Build(); if (args.Length > 0) { testType = args[0].ToLower(); } if (args.Length > 1) { ringMasterAddress = args[1]; } if (args.Length > 2) { path = args[2]; } bool useSecureConnection = false; X509Certificate[] clientCertificates = null; X509Certificate[] acceptedServerCertificates = null; if (bool.Parse(appSettings["SSL.UseSSL"])) { useSecureConnection = true; string[] clientCertificateThumbprints = appSettings["SSL.ClientCerts"].Split(new char[] { ';', ',' }); clientCertificates = RingMasterClient.GetCertificatesFromThumbPrintOrFileName(clientCertificateThumbprints); acceptedServerCertificates = Certificates.GetDecodedCertificates(appSettings["SSL.ServerCerts"]); foreach (var certificate in clientCertificates) { Trace.TraceInformation($"Client certificate: subject={certificate.Subject} thumbprint={certificate.GetCertHashString()}"); } foreach (var certificate in acceptedServerCertificates) { Trace.TraceInformation($"Server certificate: subject={certificate.Subject} thumbprint={certificate.GetCertHashString()}"); } } else { Trace.TraceInformation("Not using SSL"); } var performanceTest = new RingMasterPerformance(); performanceTest.TestPath = path; performanceTest.TimeStreamId = ulong.Parse(appSettings["TimeStream"]); performanceTest.MaxConcurrency = int.Parse(appSettings["MaxConcurrency"]); performanceTest.MaxDataSize = int.Parse(appSettings["MaxDataSize"]); performanceTest.MinDataSize = int.Parse(appSettings["MinDataSize"]); performanceTest.MinChildrenPerNode = int.Parse(appSettings["MinChildrenPerNode"]); performanceTest.MaxChildrenPerNode = int.Parse(appSettings["MaxChildrenPerNode"]); performanceTest.BatchLength = int.Parse(appSettings["BatchLength"]); performanceTest.MaxAllowedCodePoint = int.Parse(appSettings["MaxAllowedCodePoint"]); performanceTest.MaxGetChildrenEnumerationCount = int.Parse(appSettings["MaxGetChildrenEnumerationCount"]); performanceTest.MaxSetOperations = int.Parse(appSettings["MaxSetOperations"]); performanceTest.MaxNodes = int.Parse(appSettings["MaxNodes"]); performanceTest.TestMaxRunTimeInSeconds = int.Parse(appSettings["TestMaxRunTimeInSeconds"]); int requestTimeout = int.Parse(appSettings["RequestTimeout"]); Trace.Listeners.Add(new TextWriterTraceListener(Console.Out)); var serverSpec = new RingMasterClient.ServerSpec { Endpoints = SecureTransport.ParseConnectionString(ringMasterAddress), UseSecureConnection = useSecureConnection, }; if (useSecureConnection) { serverSpec.ClientCertificate = clientCertificates[0]; serverSpec.AcceptedServerCertificates = acceptedServerCertificates; serverSpec.MustCheckCertificateRevocation = false; serverSpec.MustCheckCertificateTrustChain = false; } var clientConfiguration = new RingMasterClient.Configuration { DefaultTimeout = TimeSpan.FromMilliseconds(requestTimeout), }; var cancellation = new CancellationTokenSource(); cancellation.CancelAfter(TimeSpan.FromSeconds(performanceTest.TestMaxRunTimeInSeconds)); try { using (var client = new RingMasterClient(serverSpec, clientConfiguration, instrumentation: null, watcher: null, cancellationToken: CancellationToken.None)) using (var ringMaster = client.OpenTimeStream(performanceTest.TimeStreamId)) { if (testType == "setdata") { performanceTest.SetDataPerformanceTest(ringMaster).Wait(); } else if (testType == "create") { int numNodes = 500000; if (args.Length > 3) { numNodes = int.Parse(args[3]); } performanceTest.CreatePerformanceTest(ringMaster, numNodes); } else if (testType == "createflat") { int numNodes = 1000000; if (args.Length > 3) { numNodes = int.Parse(args[3]); } performanceTest.CreateFlatPerformanceTest(ringMaster, numNodes); } else if (testType == "getchildren") { int maxChildren = 1000; if (args.Length > 3) { maxChildren = int.Parse(args[3]); } performanceTest.GetChildrenPerformanceTest(ringMaster, maxChildren); } else if (testType == "delete") { performanceTest.DeletePerformanceTest(ringMaster).Wait(); } else if (testType == "scheduleddelete") { performanceTest.ScheduledDeletePerformanceTest(ringMaster); } else if (testType == "connect") { int numConnections = 100; if (args.Length > 3) { numConnections = int.Parse(args[3]); } var configuration = new SecureTransport.Configuration { UseSecureConnection = useSecureConnection, ClientCertificates = clientCertificates, ServerCertificates = acceptedServerCertificates, CommunicationProtocolVersion = RingMasterCommunicationProtocol.MaximumSupportedVersion, }; IPEndPoint[] endpoints = SecureTransport.ParseConnectionString(ringMasterAddress); performanceTest.ConnectPerformanceTest(configuration, endpoints, numConnections); } else if (testType == "exists") { performanceTest.ExistsPerformanceTest(ringMaster).Wait(); } else if (testType == "watchers") { int maxWatchers = 1000; if (args.Length > 3) { maxWatchers = int.Parse(args[3]); } performanceTest.WatcherPerformanceTest(ringMaster, maxWatchers, cancellation).Wait(); } else { performanceTest.GetDataPerformanceTest(ringMaster, cancellation).Wait(); } } } catch (OperationCanceledException) { } catch (AggregateException ex) { if (!ex.Flatten().InnerExceptions.Any(e => e is OperationCanceledException)) { throw ex; } } }