public async Task ConnectedEvent_HasRightRemoteEndpointDetails()
{
EpoxyTransport transport = MakeTransport();
var listener = transport.MakeListener(localhostEndpoint);
EpoxyConnection remoteConnection = null;
var connectedEventDone = new ManualResetEventSlim(initialState: false);
listener.Connected += (sender, args) =>
{
Assert.AreSame(listener, sender);
remoteConnection = (EpoxyConnection)args.Connection;
connectedEventDone.Set();
};
await listener.StartAsync();
var connection = await transport.ConnectToAsync(localhostAddress);
bool wasSignaled = connectedEventDone.Wait(TimeSpan.FromSeconds(10));
Assert.IsTrue(wasSignaled, "Timed out waiting for Connected event to complete");
Assert.AreEqual(connection.LocalEndPoint, remoteConnection.RemoteEndPoint);
Assert.AreEqual(connection.RemoteEndPoint, remoteConnection.LocalEndPoint);
}
public async Task DisconnectedEvent_ClientDisconnects_GetsFired()
{
EpoxyTransport transport = MakeTransport();
var listener = transport.MakeListener(localhostEndpoint);
var disconnectedEventDone = new ManualResetEventSlim(initialState: false);
EpoxyConnection disconnectedConnection = null;
listener.Disconnected += (sender, args) =>
{
disconnectedConnection = (EpoxyConnection)args.Connection;
disconnectedEventDone.Set();
};
await listener.StartAsync();
var connection = await transport.ConnectToAsync(localhostAddress);
await connection.StopAsync();
bool wasSignaled = disconnectedEventDone.Wait(TimeSpan.FromSeconds(10));
Assert.IsTrue(wasSignaled, "Timed out waiting for Disconnected event to complete");
Assert.IsNotNull(disconnectedConnection);
Assert.AreEqual(connection.LocalEndPoint, disconnectedConnection.RemoteEndPoint);
}
private async static Task <EpoxyTransport> SetupAsync()
{
var transport = new EpoxyTransportBuilder()
.SetLogSink(new ConsoleLogger())
.Construct();
var pingPongService = new PingPongService();
EpoxyListener pingPongListener = transport.MakeListener(PingEndpoint);
pingPongListener.AddService(pingPongService);
var reversePingPongService = new ReversePingPongService();
EpoxyListener reversePingPongListener = transport.MakeListener(ReversePingEndpoint);
reversePingPongListener.AddService(reversePingPongService);
await Task.WhenAll(
pingPongListener.StartAsync(),
reversePingPongListener.StartAsync());
pingConnection = await transport.ConnectToAsync(PingUri);
reverseConnection = await transport.ConnectToAsync(ReversePingUri);
return(transport);
}
private async static Task <EpoxyTransport> SetupAsync()
{
var transport = new EpoxyTransportBuilder()
.SetLogSink(new ConsoleLogger())
.SetMetricsSink(new ConsoleMetricsSink())
.Construct();
var pingEndpoint = new IPEndPoint(IPAddress.Loopback, pingPort);
var reversePingEndpoint = new IPEndPoint(IPAddress.Loopback, reversePingPort);
var pingPongService = new PingPongService();
EpoxyListener pingPongListener = transport.MakeListener(pingEndpoint);
pingPongListener.AddService(pingPongService);
var reversePingPongService = new ReversePingPongService();
EpoxyListener reversePingPongListener = transport.MakeListener(reversePingEndpoint);
reversePingPongListener.AddService(reversePingPongService);
await Task.WhenAll(
pingPongListener.StartAsync(),
reversePingPongListener.StartAsync());
s_pingConnection = await transport.ConnectToAsync(pingPongListener.ListenEndpoint, CancellationToken.None);
s_reverseConnection = await transport.ConnectToAsync(reversePingPongListener.ListenEndpoint, CancellationToken.None);
return(transport);
}
public async Task <TestClientServer <TService> > SetupTestClientServer <TService>(
ILayerStackProvider serviceLayerStackProvider = null, ILayerStackProvider clientLayerStackProvider = null
) where TService : class, IService, new()
{
var testService = new TService();
EpoxyTransport serviceTransport = new EpoxyTransportBuilder()
.SetLayerStackProvider(serviceLayerStackProvider)
.Construct();
listener = serviceTransport.MakeListener(new IPEndPoint(IPAddress.Loopback, EpoxyTransport.DefaultInsecurePort));
listener.AddService(testService);
await listener.StartAsync();
EpoxyTransport clientTransport = new EpoxyTransportBuilder()
.SetLayerStackProvider(clientLayerStackProvider)
.Construct();
EpoxyConnection clientConnection = await clientTransport.ConnectToAsync("epoxy://127.0.0.1");
return(new TestClientServer <TService>
{
Service = testService,
ServiceTransport = serviceTransport,
Listener = listener,
ClientConnection = clientConnection,
ClientTransport = clientTransport
});
}
public static async Task <TestClientServer <TService> > SetupTestClientServer <TService>(ILayerStack serviceLayerStack = null,
ILayerStack clientLayerStack = null) where TService : class, IService, new()
{
var testService = new TService();
EpoxyTransport serviceTransport = new EpoxyTransportBuilder()
.SetLayerStack(serviceLayerStack)
.Construct();
EpoxyListener listener = serviceTransport.MakeListener(new IPEndPoint(IPAddress.Loopback, 0));
listener.AddService(testService);
await listener.StartAsync();
EpoxyTransport clientTransport = new EpoxyTransportBuilder()
// some tests rely on the use of DebugExceptionHandler to assert things about the error message
.SetLayerStack(clientLayerStack)
.Construct();
EpoxyConnection clientConnection = await clientTransport.ConnectToAsync(listener.ListenEndpoint);
return(new TestClientServer <TService>
{
Service = testService,
ServiceTransport = serviceTransport,
Listener = listener,
ClientConnection = clientConnection,
ClientTransport = clientTransport
});
}
private async static Task<EpoxyTransport> SetupAsync()
{
var transport = new EpoxyTransportBuilder()
.SetLogSink(new ConsoleLogger())
.SetMetricsSink(new ConsoleMetricsSink())
.Construct();
var pingEndpoint = new IPEndPoint(IPAddress.Loopback, pingPort);
var reversePingEndpoint = new IPEndPoint(IPAddress.Loopback, reversePingPort);
var pingPongService = new PingPongService();
EpoxyListener pingPongListener = transport.MakeListener(pingEndpoint);
pingPongListener.AddService(pingPongService);
var reversePingPongService = new ReversePingPongService();
EpoxyListener reversePingPongListener = transport.MakeListener(reversePingEndpoint);
reversePingPongListener.AddService(reversePingPongService);
await Task.WhenAll(
pingPongListener.StartAsync(),
reversePingPongListener.StartAsync());
s_pingConnection = await transport.ConnectToAsync(pingPongListener.ListenEndpoint, CancellationToken.None);
s_reverseConnection = await transport.ConnectToAsync(reversePingPongListener.ListenEndpoint, CancellationToken.None);
return transport;
}
public async Task Tls_Mutual_CanAuthenticate()
{
var serverTlsConfig = new EpoxyServerTlsConfig(
testServerCert,
checkCertificateRevocation: false,
clientCertificateRequired: true,
remoteCertificateValidationCallback: EnsureRootedWithTestCertificate
);
var clientTlsConfig = new EpoxyClientTlsConfig(
certificate: testClientCert,
checkCertificateRevocation: false,
remoteCertificateValidationCallback: EnsureRootedWithTestCertificate);
var transport = new EpoxyTransportBuilder()
.SetResolver(ResolveEverythingToLocalhost)
.SetServerTlsConfig(serverTlsConfig)
.SetClientTlsConfig(clientTlsConfig)
.Construct();
transports.Add(transport);
var listener = transport.MakeListener(new IPEndPoint(IPAddress.Loopback, EpoxyTransport.DefaultSecurePort));
listener.AddService(new DummyTestService());
await listener.StartAsync();
EpoxyConnection clientConnection = await transport.ConnectToAsync("epoxys://bond-test-server1");
var proxy = new DummyTestProxy <EpoxyConnection>(clientConnection);
await AssertRequestResponseWorksAsync(proxy);
}
public static void CreateFrames()
{
goodRequestFrame = EpoxyConnection.MessageToFrame(
GoodRequestId, GoodMethod, PayloadType.Request, meaninglessMessage, null, LoggerTests.BlackHole);
goodRequestLayerDataFrame = EpoxyConnection.MessageToFrame(
GoodRequestId, GoodMethod, PayloadType.Request, meaninglessMessage, GoodLayerData, LoggerTests.BlackHole);
goodResponseFrame = EpoxyConnection.MessageToFrame(
GoodResponseId, GoodMethod, PayloadType.Response, meaninglessMessage, null, LoggerTests.BlackHole);
goodEventFrame = EpoxyConnection.MessageToFrame(
GoodRequestId, GoodMethod, PayloadType.Event, meaninglessMessage, null, LoggerTests.BlackHole);
var goodFrameletCount = goodRequestFrame.Count;
shortRequestFrame = new Frame(goodFrameletCount - 1, LoggerTests.BlackHole);
for (var i = 0; i < goodFrameletCount - 1; i++)
{
shortRequestFrame.Add(goodRequestFrame.Framelets[i]);
}
doubleHeadersRequestFrame = new Frame(goodFrameletCount + 1, LoggerTests.BlackHole);
doubleHeadersRequestFrame.Add(goodRequestFrame.Framelets[0]);
for (var i = 0; i < goodFrameletCount; i++)
{
doubleHeadersRequestFrame.Add(goodRequestFrame.Framelets[i]);
}
doublePayloadRequestFrame = new Frame(goodFrameletCount + 1, LoggerTests.BlackHole);
for (var i = 0; i < goodFrameletCount; i++)
{
doublePayloadRequestFrame.Add(goodRequestFrame.Framelets[i]);
}
doublePayloadRequestFrame.Add(goodRequestFrame.Framelets[goodFrameletCount - 1]);
backwardsRequestFrame = new Frame(goodFrameletCount, LoggerTests.BlackHole);
foreach (var framelet in goodRequestFrame.Framelets.Reverse())
{
backwardsRequestFrame.Add(framelet);
}
protocolErrorFrame = EpoxyConnection.MakeProtocolErrorFrame(meaninglessErrorCode, null, LoggerTests.BlackHole);
doubleProtocolErrorFrame = EpoxyConnection.MakeProtocolErrorFrame(meaninglessErrorCode, null, LoggerTests.BlackHole);
doubleProtocolErrorFrame.Add(doubleProtocolErrorFrame.Framelets[0]);
configFrame = EpoxyConnection.MakeConfigFrame(LoggerTests.BlackHole);
configFrameExtra = EpoxyConnection.MakeConfigFrame(LoggerTests.BlackHole);
configFrameExtra.Add(goodRequestFrame.Framelets[0]);
var invalidConfigData = new ArraySegment <byte>(new byte[] { 0x01 });
configFrameBadConfigData = new Frame(1, LoggerTests.BlackHole);
configFrameBadConfigData.Add(new Framelet(FrameletType.EpoxyConfig, invalidConfigData));
protocolErrorFrame = EpoxyConnection.MakeProtocolErrorFrame(meaninglessErrorCode, null, LoggerTests.BlackHole);
}
public async Task Connection_StartStop()
{
var testClientServer = await SetupTestClientServer <TestService>();
EpoxyConnection connection = testClientServer.ClientConnection;
var timeoutTask = Task.Delay(TimeSpan.FromSeconds(10));
var completedTask = await Task.WhenAny(connection.StopAsync(), timeoutTask);
Assert.AreNotSame(timeoutTask, completedTask, "Timed out waiting for connection to be shutdown.");
}
public async Task TransportWithCustomResolver_UsesResolver()
{
await SetupTestClientServer <DummyTestService>();
var clientTransport = new EpoxyTransportBuilder().SetResolver(ResolveEverythingToLocalhost).Construct();
transports.Add(clientTransport);
EpoxyConnection clientConnection = await clientTransport.ConnectToAsync("epoxy://resolve-this-to-localhost/");
var proxy = new DummyTestProxy <EpoxyConnection>(clientConnection);
await AssertRequestResponseWorksAsync(proxy);
}
public async Task Tls_MutualNoClientCert_ProxyDoesNotWork()
{
var serverTlsConfig = new EpoxyServerTlsConfig(
testServerCert,
checkCertificateRevocation: false,
clientCertificateRequired: true,
remoteCertificateValidationCallback: EnsureRootedWithTestCertificate
);
var clientTlsConfig = new EpoxyClientTlsConfig(certificate: null,
checkCertificateRevocation: false,
remoteCertificateValidationCallback: EnsureRootedWithTestCertificate);
var transport = new EpoxyTransportBuilder()
.SetResolver(ResolveEverythingToLocalhost)
.SetServerTlsConfig(serverTlsConfig)
.SetClientTlsConfig(clientTlsConfig)
.Construct();
listener = transport.MakeListener(new IPEndPoint(IPAddress.Loopback, EpoxyTransport.DefaultSecurePort));
listener.AddService(new DummyTestService());
await listener.StartAsync();
try
{
// The .NET SslStream implementation currently does not give us
// a way to signal during TLS handshaking that the server is
// rejecting the connection. Instead, we have to RST the
// underlying socket. With Epoxy's current implementation, this
// can't reliably be detected at connection time. So we attempt
// to exercise the connection using a proxy and expect that to fail.
EpoxyConnection clientConnection = await transport.ConnectToAsync("epoxys://bond-test-server1");
var proxy = new DummyTestProxy <EpoxyConnection>(clientConnection);
await AssertRequestResponseWorksAsync(proxy);
}
catch (Exception ex) when(ex is InvalidOperationException || ex is AuthenticationException)
{
// An expected exception type, depending on timing, so pass the
// test.
}
catch (Exception ex)
{
Assert.Fail("Unexpected exception of type {0}: {1}", ex.GetType(), ex);
}
finally
{
await transport.StopAsync();
}
}
public void MakeProtocolErrorFrame_JustErrorCode_MakesAFrame()
{
var frame = EpoxyConnection.MakeProtocolErrorFrame(MeaninglessErrorCode, null, LoggerTests.BlackHole);
Assert.NotNull(frame);
Assert.AreEqual(1, frame.Framelets.Count);
Assert.AreEqual(FrameletType.ProtocolError, frame.Framelets[0].Type);
var inputBuffer = new InputBuffer(frame.Framelets[0].Contents);
var fastBinaryReader = new FastBinaryReader <InputBuffer>(inputBuffer, version: 1);
var error = Deserialize <ProtocolError> .From(fastBinaryReader);
Assert.AreEqual(MeaninglessErrorCode, error.error_code);
Assert.Null(error.details);
}
private async static Task<EpoxyTransport> SetupAsync()
{
var transport = new EpoxyTransportBuilder()
.SetLogSink(new ConsoleLogger())
.Construct();
var assignAPortEndPoint = new IPEndPoint(IPAddress.Loopback, 0);
var notifyService = new NotifyEventService();
EpoxyListener notifyListener = transport.MakeListener(assignAPortEndPoint);
notifyListener.AddService(notifyService);
await notifyListener.StartAsync();
s_connection = await transport.ConnectToAsync(notifyListener.ListenEndpoint, CancellationToken.None);
return transport;
}
public void MakeProtocolErrorFrame_WithDetails_MakesAFrame()
{
var frame = EpoxyConnection.MakeProtocolErrorFrame(MeaninglessErrorCode, AnyDetails, LoggerTests.BlackHole);
Assert.NotNull(frame);
Assert.AreEqual(1, frame.Framelets.Count);
Assert.AreEqual(FrameletType.ProtocolError, frame.Framelets[0].Type);
var inputBuffer = new Bond.IO.Unsafe.InputBuffer(frame.Framelets[0].Contents);
var fastBinaryReader = new FastBinaryReader <InputBuffer>(inputBuffer, version: 1);
var error = Deserialize <ProtocolError> .From(fastBinaryReader);
Assert.AreEqual(MeaninglessErrorCode, error.error_code);
Assert.NotNull(error.details);
var details = error.details.Deserialize();
Assert.IsTrue(AnyDetails.IsEqual <Error, Error>(details));
}
private async static Task <EpoxyTransport> SetupAsync()
{
var transport = new EpoxyTransportBuilder()
.SetLogSink(new ConsoleLogger())
.Construct();
var assignAPortEndPoint = new IPEndPoint(IPAddress.Loopback, EpoxyTransport.DefaultInsecurePort);
var notifyService = new NotifyEventService();
EpoxyListener notifyListener = transport.MakeListener(assignAPortEndPoint);
notifyListener.AddService(notifyService);
await notifyListener.StartAsync();
s_connection = await transport.ConnectToAsync("epoxy://127.0.0.1", CancellationToken.None);
return(transport);
}
public async Task Connection_CanBeStoppedMultipleTimes()
{
var testClientServer = await SetupTestClientServer <TestService>();
EpoxyConnection connection = testClientServer.ClientConnection;
var stopTasks = new[] { connection.StopAsync(), connection.StopAsync() };
var timeoutTask = Task.Delay(TimeSpan.FromSeconds(10));
var allTasks = new List <Task>(stopTasks)
{
timeoutTask
};
var completedTask = await Task.WhenAny(allTasks);
Assert.AreNotSame(timeoutTask, completedTask, "Timed out waiting for connection to be shutdown.");
await connection.StopAsync();
}
public async Task Connection_OutstandingRequestsThenShutdown_CompletedWithError()
{
var testClientServer = await SetupTestClientServer <TestServiceNeverResponds>();
EpoxyConnection connection = testClientServer.ClientConnection;
IMessage <SomePayload> anyPayload = Message.FromPayload(new SomePayload());
Task <IMessage <SomePayload> > responseTask = connection
.RequestResponseAsync <SomePayload, SomePayload>(
"TestService", "NeverRespond", anyPayload, CancellationToken.None);
await connection.StopAsync();
IMessage <SomePayload> response = await responseTask;
Assert.IsTrue(response.IsError);
Error err = response.Error.Deserialize();
Assert.AreEqual((int)ErrorCode.CONNECTION_SHUT_DOWN, err.error_code);
}
private async static Task <EpoxyTransport> SetupAsync()
{
var handler = new ConsoleLogger();
Log.SetHandler(handler);
var transport = new EpoxyTransportBuilder().Construct();
var assignAPortEndPoint = new IPEndPoint(IPAddress.Loopback, 0);
var notifyService = new NotifyEventService();
EpoxyListener notifyListener = transport.MakeListener(assignAPortEndPoint);
notifyListener.AddService(notifyService);
await notifyListener.StartAsync();
s_connection = await transport.ConnectToAsync(notifyListener.ListenEndpoint, CancellationToken.None);
return(transport);
}
public async Task IPv6Listener_RequestReply_PayloadResponse()
{
var transport = new EpoxyTransportBuilder().Construct();
transports.Add(transport);
var listener = transport.MakeListener(new IPEndPoint(IPAddress.IPv6Loopback, EpoxyTransport.DefaultInsecurePort));
listener.AddService(new DummyTestService());
await listener.StartAsync();
EpoxyConnection conn = await transport.ConnectToAsync("epoxy://[::1]");
var proxy = new DummyTestProxy <EpoxyConnection>(conn);
var request = new Dummy {
int_value = 100
};
IMessage <Dummy> response = await proxy.ReqRspMethodAsync(request);
Assert.IsFalse(response.IsError);
Assert.AreEqual(101, response.Payload.Deserialize().int_value);
}
private async static Task<EpoxyTransport> SetupAsync()
{
var transport = new EpoxyTransportBuilder()
.SetLogSink(new ConsoleLogger())
.Construct();
var pingPongService = new PingPongService();
EpoxyListener pingPongListener = transport.MakeListener(PingEndpoint);
pingPongListener.AddService(pingPongService);
var reversePingPongService = new ReversePingPongService();
EpoxyListener reversePingPongListener = transport.MakeListener(ReversePingEndpoint);
reversePingPongListener.AddService(reversePingPongService);
await Task.WhenAll(
pingPongListener.StartAsync(),
reversePingPongListener.StartAsync());
pingConnection = await transport.ConnectToAsync(PingUri);
reverseConnection = await transport.ConnectToAsync(ReversePingUri);
return transport;
}
public EpoxySendContext(EpoxyConnection connection, ConnectionMetrics connectionMetrics, RequestMetrics requestMetrics)
: base(connectionMetrics, requestMetrics)
{
Connection = connection;
}
public static void CreateFrames()
{
// Set up the non-empty layer data we'll use.
Bond.IBonded goodLayerObject = new Bond.Bonded <Dummy>(dummyObject);
var outputBuffer = new OutputBuffer();
var compactWriter = new CompactBinaryWriter <OutputBuffer>(outputBuffer);
compactWriter.WriteVersion();
goodLayerObject.Serialize(compactWriter);
goodLayerData = outputBuffer.Data;
// Good frames, from which we can pull good framelets to build bad frames.
goodRequestFrame = EpoxyConnection.MessageToFrame(
GoodRequestId, GoodService, GoodMethod, EpoxyMessageType.REQUEST, meaninglessPayload, null, LoggerTests.BlackHole);
goodRequestLayerDataFrame = EpoxyConnection.MessageToFrame(
GoodRequestId, GoodService, GoodMethod, EpoxyMessageType.REQUEST, meaninglessPayload, goodLayerObject, LoggerTests.BlackHole);
goodResponseFrame = EpoxyConnection.MessageToFrame(
GoodResponseId, GoodService, GoodMethod, EpoxyMessageType.RESPONSE, meaninglessPayload, null, LoggerTests.BlackHole);
goodErrorResponseFrame = EpoxyConnection.MessageToFrame(
GoodResponseId, GoodService, GoodMethod, EpoxyMessageType.RESPONSE, meaninglessError, null, LoggerTests.BlackHole);
goodEventFrame = EpoxyConnection.MessageToFrame(
GoodRequestId, GoodService, GoodMethod, EpoxyMessageType.EVENT, meaninglessPayload, null, LoggerTests.BlackHole);
configFrame = EpoxyConnection.MakeConfigFrame(LoggerTests.BlackHole);
protocolErrorFrame = EpoxyConnection.MakeProtocolErrorFrame(MeaninglessErrorCode, null, LoggerTests.BlackHole);
var goodFrameletCount = goodRequestFrame.Count;
// Bad frames made of good framelets.
shortRequestFrame = new Frame(goodFrameletCount - 1, LoggerTests.BlackHole);
for (var i = 0; i < goodFrameletCount - 1; i++)
{
shortRequestFrame.Add(goodRequestFrame.Framelets[i]);
}
doubleHeadersRequestFrame = new Frame(goodFrameletCount + 1, LoggerTests.BlackHole);
doubleHeadersRequestFrame.Add(goodRequestFrame.Framelets[0]);
for (var i = 0; i < goodFrameletCount; i++)
{
doubleHeadersRequestFrame.Add(goodRequestFrame.Framelets[i]);
}
headersConfigRequestFrame = new Frame(2, LoggerTests.BlackHole);
headersConfigRequestFrame.Add(goodRequestFrame.Framelets[0]);
headersConfigRequestFrame.Add(configFrame.Framelets[0]);
doublePayloadRequestFrame = new Frame(goodFrameletCount + 1, LoggerTests.BlackHole);
for (var i = 0; i < goodFrameletCount; i++)
{
doublePayloadRequestFrame.Add(goodRequestFrame.Framelets[i]);
}
doublePayloadRequestFrame.Add(goodRequestFrame.Framelets[goodFrameletCount - 1]);
backwardsRequestFrame = new Frame(goodFrameletCount, LoggerTests.BlackHole);
foreach (var framelet in goodRequestFrame.Framelets.Reverse())
{
backwardsRequestFrame.Add(framelet);
}
doubleProtocolErrorFrame = EpoxyConnection.MakeProtocolErrorFrame(MeaninglessErrorCode, null, LoggerTests.BlackHole);
doubleProtocolErrorFrame.Add(doubleProtocolErrorFrame.Framelets[0]);
configFrameExtra = EpoxyConnection.MakeConfigFrame(LoggerTests.BlackHole);
configFrameExtra.Add(goodRequestFrame.Framelets[0]);
// Bad frames made of bad framelets.
var invalidConfigData = new ArraySegment <byte>(new byte[] { 0x01 });
configFrameBadConfigData = new Frame(1, LoggerTests.BlackHole);
configFrameBadConfigData.Add(new Framelet(FrameletType.EpoxyConfig, invalidConfigData));
}
public EpoxyReceiveContext(EpoxyConnection connection)
{
Connection = connection;
}
public EpoxySendContext(EpoxyConnection connection)
{
Connection = connection;
}
public EpoxyReceiveContext(EpoxyConnection connection)
{
Connection = connection;
}
public EpoxySendContext(EpoxyConnection connection)
{
Connection = connection;
}
public EpoxySendContext(EpoxyConnection connection, ConnectionMetrics connectionMetrics, RequestMetrics requestMetrics)
: base(connectionMetrics, requestMetrics)
{
Connection = connection;
}
