/// <summary>
/// Initializes a new instance of the <see cref="RingMasterClient"/> class.
/// </summary>
/// <param name="connectionString">Comma separated list of host:port pairs, each corresponding to a RingMaster server</param>
/// <param name="configuration">Configuration settings</param>
/// <param name="instrumentation">Instrumentation consumer</param>
public RingMasterClient(
string connectionString,
Configuration configuration,
IRingMasterClientInstrumentation instrumentation = null)
: this(connectionString, configuration, instrumentation, CancellationToken.None)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RingMasterClient"/> class.
/// </summary>
/// <param name="instrumentation">Instrumentation consumer</param>
/// <param name="communicationProtocol">Interface to the communication protocol</param>
/// <param name="transport">Interface to the transport layer</param>
/// <param name="cancellationToken">Token that will be observed for cancellation signal</param>
public RingMasterClient(
IRingMasterClientInstrumentation instrumentation,
ICommunicationProtocol communicationProtocol,
ITransport transport,
CancellationToken cancellationToken)
: this(new Configuration(), instrumentation, communicationProtocol, transport, cancellationToken)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RingMasterClient"/> class.
/// </summary>
/// <param name="connectionString">Comma separated list of host:port pairs, each corresponding to a RingMaster server</param>
/// <param name="configuration">Configuration settings</param>
/// <param name="instrumentation">Instrumentation consumer</param>
/// <param name="cancellationToken">Token that will be observed for cancellation signal</param>
public RingMasterClient(
string connectionString,
Configuration configuration,
IRingMasterClientInstrumentation instrumentation,
CancellationToken cancellationToken)
: this(CreateServerSpec(connectionString), configuration, instrumentation, cancellationToken)
{
}
public RingMasterClient(
ServerSpec serverSpec,
Configuration configuration,
IRingMasterClientInstrumentation instrumentation,
CancellationToken cancellationToken)
: this(serverSpec, configuration, instrumentation, null, cancellationToken)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RingMasterClient"/> class.
/// </summary>
/// <param name="configuration">RingMasterClient configuration</param>
/// <param name="instrumentation">Instrumentation consumer</param>
/// <param name="communicationProtocol">Interface to the communication protocol</param>
/// <param name="transport">Interface to the transport layer</param>
/// <param name="cancellationToken">Token that will be observed for cancellation signal</param>
public RingMasterClient(
Configuration configuration,
IRingMasterClientInstrumentation instrumentation,
ICommunicationProtocol communicationProtocol,
ITransport transport,
CancellationToken cancellationToken)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
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, communicationProtocol, transport, cancellationToken);
}
public RingMasterRequestHandlerInstrumentation(IRingMasterClientInstrumentation instrumentation)
{
this.instrumentation = instrumentation;
}
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();
}
}
}
