Update secret functionality (#342)

simone-fariselli · Gsantomaggio · web-flow · commit c3d8e555be31 · 2024-02-01T15:21:18.000+01:00
* add update secret functionality.
* Update the secrets for all the pool connections

Signed-off-by: Gabriele Santomaggio &lt;G.santomaggio@gmail.com&gt;
Co-authored-by: Gabriele Santomaggio &lt;G.santomaggio@gmail.com&gt;
diff --git a/RabbitMQ.Stream.Client/Client.cs b/RabbitMQ.Stream.Client/Client.cs
@@ -117,7 +117,7 @@ public class Client : IClient
 
         private uint correlationId = 0; // allow for some pre-amble
 
-        private Connection connection;
+        private Connection _connection;
 
         private readonly ConcurrentDictionary<uint, IValueTaskSource> requests = new();
 
@@ -148,7 +148,7 @@ public class Client : IClient
 
         public int ConfirmFrames => confirmFrames;
 
-        public int IncomingFrames => connection.NumFrames;
+        public int IncomingFrames => _connection.NumFrames;
 
         //public int IncomingChannelCount => this.incoming.Reader.Count;
         private static readonly object Obj = new();
@@ -176,7 +176,7 @@ public bool IsClosed
         {
             get
             {
-                if (connection.IsClosed)
+                if (_connection.IsClosed)
                 {
                     isClosed = true;
                 }
@@ -208,10 +208,10 @@ private async Task OnConnectionClosed(string reason)
         public static async Task<Client> Create(ClientParameters parameters, ILogger logger = null)
         {
             var client = new Client(parameters, logger);
-            client.connection = await Connection
+            client._connection = await Connection
                 .Create(parameters.Endpoint, client.HandleIncoming, client.HandleClosed, parameters.Ssl, logger)
                 .ConfigureAwait(false);
-            client.connection.ClientId = client.ClientId;
+            client._connection.ClientId = client.ClientId;
             // exchange properties
             var peerPropertiesResponse = await client.Request<PeerPropertiesRequest, PeerPropertiesResponse>(corr =>
                 new PeerPropertiesRequest(corr, parameters.Properties)).ConfigureAwait(false);
@@ -283,6 +283,23 @@ await client.Publish(new TuneRequest(0,
             return client;
         }
 
+        public async Task UpdateSecret(string newSecret)
+        {
+            var saslData = Encoding.UTF8.GetBytes($"\0{Parameters.UserName}\0{newSecret}");
+
+            var authResponse =
+                await Request<SaslAuthenticateRequest, SaslAuthenticateResponse>(corr =>
+                        new SaslAuthenticateRequest(
+                            corr,
+                            Parameters.AuthMechanism.ToString().ToUpperInvariant(),
+                            saslData))
+                    .ConfigureAwait(false);
+
+            ClientExceptions.MaybeThrowException(
+                authResponse.ResponseCode,
+                "Error while updating secret: the secret will not be updated.");
+        }
+
         public async ValueTask<bool> Publish(Publish publishMsg)
         {
             var publishTask = await Publish<Publish>(publishMsg).ConfigureAwait(false);
@@ -296,7 +313,7 @@ public ValueTask<bool> Publish<T>(T msg) where T : struct, ICommand
         {
             try
             {
-                return connection.Write(msg);
+                return _connection.Write(msg);
             }
             catch (Exception e)
             {
@@ -757,7 +774,7 @@ public async Task<CloseResponse> Close(string reason)
             InternalClose();
             try
             {
-                connection.UpdateCloseStatus(ConnectionClosedReason.Normal);
+                _connection.UpdateCloseStatus(ConnectionClosedReason.Normal);
                 var result =
                     await Request<CloseRequest, CloseResponse>(corr => new CloseRequest(corr, reason),
                         TimeSpan.FromSeconds(10)).ConfigureAwait(false);
@@ -771,11 +788,11 @@ public async Task<CloseResponse> Close(string reason)
             }
             catch (Exception e)
             {
-                _logger.LogError(e, "An error occurred while calling {CalledFunction}", nameof(connection.Dispose));
+                _logger.LogError(e, "An error occurred while calling {CalledFunction}", nameof(_connection.Dispose));
             }
             finally
             {
-                connection.Dispose();
+                _connection.Dispose();
             }
 
             return new CloseResponse(0, ResponseCode.Ok);
diff --git a/RabbitMQ.Stream.Client/ConnectionsPool.cs b/RabbitMQ.Stream.Client/ConnectionsPool.cs
@@ -130,7 +130,7 @@ public ConnectionsPool(int maxConnections, byte idsPerConnection)
     ///  Value is the connection item
     ///  The Connections contains all the connections created by the pool
     /// </summary>
-    internal ConcurrentDictionary<string, ConnectionItem> Connections { get; } = new();
+    private ConcurrentDictionary<string, ConnectionItem> Connections { get; } = new();
 
     /// <summary>
     /// GetOrCreateClient returns a client for the given brokerInfo.
@@ -162,7 +162,8 @@ internal async Task<IClient> GetOrCreateClient(string brokerInfo, Func<Task<ICli
                 // let's remove it from the pool
                 Connections.TryRemove(connectionItem.Client.ClientId, out _);
                 // let's create a new one
-                connectionItem = new ConnectionItem(brokerInfo, _idsPerConnection, await createClient().ConfigureAwait(false));
+                connectionItem = new ConnectionItem(brokerInfo, _idsPerConnection,
+                    await createClient().ConfigureAwait(false));
                 Connections.TryAdd(connectionItem.Client.ClientId, connectionItem);
 
                 return connectionItem.Client;
@@ -185,6 +186,7 @@ internal async Task<IClient> GetOrCreateClient(string brokerInfo, Func<Task<ICli
             _semaphoreSlim.Release();
         }
     }
+
     public void Remove(string clientId)
     {
         _semaphoreSlim.Wait();
@@ -202,6 +204,23 @@ public void Remove(string clientId)
         }
     }
 
+    public async Task UpdateSecrets(string newSecret)
+    {
+        await _semaphoreSlim.WaitAsync().ConfigureAwait(false);
+        try
+        {
+            foreach (var connectionItem in Connections.Values)
+            {
+                await connectionItem.Client.UpdateSecret(newSecret).ConfigureAwait(false);
+                connectionItem.Client.Parameters.Password = newSecret;
+            }
+        }
+        finally
+        {
+            _semaphoreSlim.Release();
+        }
+    }
+
     public void MaybeClose(string clientId, string reason)
     {
         _semaphoreSlim.Wait();
diff --git a/RabbitMQ.Stream.Client/IClient.cs b/RabbitMQ.Stream.Client/IClient.cs
@@ -28,6 +28,8 @@ public interface IClient
         IDictionary<byte, (string, (Action<ReadOnlyMemory<ulong>>, Action<(ulong, ResponseCode)[]>))> Publishers { get; }
         IDictionary<byte, (string, ConsumerEvents)> Consumers { get; }
 
+        Task UpdateSecret(string newSecret);
+
         public bool IsClosed { get; }
     }
 }
diff --git a/RabbitMQ.Stream.Client/PublicAPI.Unshipped.txt b/RabbitMQ.Stream.Client/PublicAPI.Unshipped.txt
@@ -41,6 +41,7 @@ RabbitMQ.Stream.Client.Client.QueryRoute(string superStream, string routingKey)
 RabbitMQ.Stream.Client.Client.StreamStats(string stream) -> System.Threading.Tasks.ValueTask<RabbitMQ.Stream.Client.StreamStatsResponse>
 RabbitMQ.Stream.Client.Client.Subscribe(string stream, RabbitMQ.Stream.Client.IOffsetType offsetType, ushort initialCredit, System.Collections.Generic.Dictionary<string, string> properties, System.Func<RabbitMQ.Stream.Client.Deliver, System.Threading.Tasks.Task> deliverHandler, System.Func<bool, System.Threading.Tasks.Task<RabbitMQ.Stream.Client.IOffsetType>> consumerUpdateHandler = null, RabbitMQ.Stream.Client.ConnectionsPool pool = null) -> System.Threading.Tasks.Task<(byte, RabbitMQ.Stream.Client.SubscribeResponse)>
 RabbitMQ.Stream.Client.Client.Unsubscribe(byte subscriptionId, bool ignoreIfAlreadyRemoved = false) -> System.Threading.Tasks.Task<RabbitMQ.Stream.Client.UnsubscribeResponse>
+RabbitMQ.Stream.Client.Client.UpdateSecret(string newSecret) -> System.Threading.Tasks.Task
 RabbitMQ.Stream.Client.ClientParameters.AuthMechanism.get -> RabbitMQ.Stream.Client.AuthMechanism
 RabbitMQ.Stream.Client.ClientParameters.AuthMechanism.set -> void
 RabbitMQ.Stream.Client.ClientParameters.MetadataUpdateHandler
@@ -68,6 +69,7 @@ RabbitMQ.Stream.Client.ConnectionsPool.MaybeClose(string clientId, string reason
 RabbitMQ.Stream.Client.ConnectionsPool.Remove(string clientId) -> void
 RabbitMQ.Stream.Client.ConnectionsPool.RemoveConsumerEntityFromStream(string clientId, byte id, string stream) -> void
 RabbitMQ.Stream.Client.ConnectionsPool.RemoveProducerEntityFromStream(string clientId, byte id, string stream) -> void
+RabbitMQ.Stream.Client.ConnectionsPool.UpdateSecrets(string newSecret) -> System.Threading.Tasks.Task
 RabbitMQ.Stream.Client.ConsumerEvents
 RabbitMQ.Stream.Client.ConsumerEvents.ConsumerEvents() -> void
 RabbitMQ.Stream.Client.ConsumerEvents.ConsumerEvents(System.Func<RabbitMQ.Stream.Client.Deliver, System.Threading.Tasks.Task> deliverHandler, System.Func<bool, System.Threading.Tasks.Task<RabbitMQ.Stream.Client.IOffsetType>> consumerUpdateHandler) -> void
@@ -103,6 +105,7 @@ RabbitMQ.Stream.Client.IClient.ClientId.init -> void
 RabbitMQ.Stream.Client.IClient.Consumers.get -> System.Collections.Generic.IDictionary<byte, (string, RabbitMQ.Stream.Client.ConsumerEvents)>
 RabbitMQ.Stream.Client.IClient.IsClosed.get -> bool
 RabbitMQ.Stream.Client.IClient.Publishers.get -> System.Collections.Generic.IDictionary<byte, (string, (System.Action<System.ReadOnlyMemory<ulong>>, System.Action<(ulong, RabbitMQ.Stream.Client.ResponseCode)[]>))>
+RabbitMQ.Stream.Client.IClient.UpdateSecret(string newSecret) -> System.Threading.Tasks.Task
 RabbitMQ.Stream.Client.IClosable
 RabbitMQ.Stream.Client.IClosable.Close() -> System.Threading.Tasks.Task<RabbitMQ.Stream.Client.ResponseCode>
 RabbitMQ.Stream.Client.IConsumer.Info.get -> RabbitMQ.Stream.Client.ConsumerInfo
@@ -276,6 +279,7 @@ RabbitMQ.Stream.Client.StreamSystem.CreateRawSuperStreamProducer(RabbitMQ.Stream
 RabbitMQ.Stream.Client.StreamSystem.CreateSuperStreamConsumer(RabbitMQ.Stream.Client.RawSuperStreamConsumerConfig rawSuperStreamConsumerConfig, Microsoft.Extensions.Logging.ILogger logger = null) -> System.Threading.Tasks.Task<RabbitMQ.Stream.Client.ISuperStreamConsumer>
 RabbitMQ.Stream.Client.StreamSystem.StreamInfo(string streamName) -> System.Threading.Tasks.Task<RabbitMQ.Stream.Client.StreamInfo>
 RabbitMQ.Stream.Client.StreamSystem.StreamStats(string stream) -> System.Threading.Tasks.Task<RabbitMQ.Stream.Client.StreamStats>
+RabbitMQ.Stream.Client.StreamSystem.UpdateSecret(string newSecret) -> System.Threading.Tasks.Task
 RabbitMQ.Stream.Client.StreamSystemConfig.AuthMechanism.get -> RabbitMQ.Stream.Client.AuthMechanism
 RabbitMQ.Stream.Client.StreamSystemConfig.AuthMechanism.set -> void
 RabbitMQ.Stream.Client.StreamSystemConfig.ConnectionPoolConfig.get -> RabbitMQ.Stream.Client.ConnectionPoolConfig
@@ -286,6 +290,8 @@ RabbitMQ.Stream.Client.UnknownCommandException
 RabbitMQ.Stream.Client.UnknownCommandException.UnknownCommandException(string s) -> void
 RabbitMQ.Stream.Client.UnsupportedOperationException
 RabbitMQ.Stream.Client.UnsupportedOperationException.UnsupportedOperationException(string s) -> void
+RabbitMQ.Stream.Client.UpdateSecretFailureException
+RabbitMQ.Stream.Client.UpdateSecretFailureException.UpdateSecretFailureException(string s) -> void
 static RabbitMQ.Stream.Client.Connection.Create(System.Net.EndPoint endpoint, System.Func<System.Memory<byte>, System.Threading.Tasks.Task> commandCallback, System.Func<string, System.Threading.Tasks.Task> closedCallBack, RabbitMQ.Stream.Client.SslOption sslOption, Microsoft.Extensions.Logging.ILogger logger) -> System.Threading.Tasks.Task<RabbitMQ.Stream.Client.Connection>
 static RabbitMQ.Stream.Client.Message.From(ref System.Buffers.ReadOnlySequence<byte> seq, uint len) -> RabbitMQ.Stream.Client.Message
 static RabbitMQ.Stream.Client.RawConsumer.Create(RabbitMQ.Stream.Client.ClientParameters clientParameters, RabbitMQ.Stream.Client.RawConsumerConfig config, RabbitMQ.Stream.Client.StreamInfo metaStreamInfo, Microsoft.Extensions.Logging.ILogger logger = null) -> System.Threading.Tasks.Task<RabbitMQ.Stream.Client.IConsumer>
diff --git a/RabbitMQ.Stream.Client/StreamSystem.cs b/RabbitMQ.Stream.Client/StreamSystem.cs
@@ -153,6 +153,17 @@ private async Task MayBeReconnectLocator()
             }
         }
 
+        public async Task UpdateSecret(string newSecret)
+        {
+            if (_client.IsClosed)
+                throw new UpdateSecretFailureException("Cannot update a closed connection.");
+
+            await _client.UpdateSecret(newSecret).ConfigureAwait(false);
+            _clientParameters.Password = newSecret;
+            _client.Parameters.Password = newSecret;
+
+        }
+
         public async Task<ISuperStreamProducer> CreateRawSuperStreamProducer(
             RawSuperStreamProducerConfig rawSuperStreamProducerConfig, ILogger logger = null)
         {
@@ -542,4 +553,11 @@ public StreamSystemInitialisationException(string error) : base(error)
         {
         }
     }
+    public class UpdateSecretFailureException : ProtocolException
+    {
+        public UpdateSecretFailureException(string s)
+            : base(s)
+        {
+        }
+    }
 }
diff --git a/Tests/SystemTests.cs b/Tests/SystemTests.cs
@@ -159,6 +159,38 @@ await Assert.ThrowsAsync<AuthenticationFailureException>(
             );
         }
 
+        [Fact]
+        public async void UpdateSecretWithValidSecretShouldNoRaiseExceptions()
+        {
+            var config = new StreamSystemConfig { UserName = "guest", Password = "guest" }; // specified for readability
+            var streamSystem = await StreamSystem.Create(config);
+
+            await streamSystem.UpdateSecret("guest");
+        }
+
+        [Fact]
+        public async void UpdateSecretWithInvalidSecretShouldThrowAuthenticationFailureException()
+        {
+            var config = new StreamSystemConfig { UserName = "guest", Password = "guest" }; // specified for readability
+            var streamSystem = await StreamSystem.Create(config);
+
+            await Assert.ThrowsAsync<AuthenticationFailureException>(
+                async () => { await streamSystem.UpdateSecret("not_valid_secret"); }
+            );
+        }
+
+        [Fact]
+        public async void UpdateSecretForClosedConnectionShouldThrowUpdateSecretFailureException()
+        {
+            var config = new StreamSystemConfig { UserName = "guest", Password = "guest" }; // specified for readability
+            var streamSystem = await StreamSystem.Create(config);
+
+            await streamSystem.Close();
+            await Assert.ThrowsAsync<UpdateSecretFailureException>(
+                async () => { await streamSystem.UpdateSecret("guest"); }
+            );
+        }
+
         [Fact]
         public async void CreateExistStreamIdempotentShouldNoRaiseExceptions()
         {
diff --git a/Tests/UnitTests.cs b/Tests/UnitTests.cs
@@ -32,6 +32,8 @@ public Task<CloseResponse> Close(string reason)
         }
 
         public IDictionary<byte, (string, ConsumerEvents)> Consumers { get; }
+        public Task UpdateSecret(string newSecret) => throw new NotImplementedException();
+
         public bool IsClosed { get; }
 
         public FakeClient(ClientParameters clientParameters)

Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ public class Client : IClient`
`117`	`117`
`118`	`118`	`private uint correlationId = 0; // allow for some pre-amble`
`119`	`119`
`120`		`- private Connection connection;`
	`120`	`+ private Connection _connection;`
`121`	`121`
`122`	`122`	`private readonly ConcurrentDictionary<uint, IValueTaskSource> requests = new();`
`123`	`123`
`@@ -148,7 +148,7 @@ public class Client : IClient`
`148`	`148`
`149`	`149`	`public int ConfirmFrames => confirmFrames;`
`150`	`150`
`151`		`- public int IncomingFrames => connection.NumFrames;`
	`151`	`+ public int IncomingFrames => _connection.NumFrames;`
`152`	`152`
`153`	`153`	`//public int IncomingChannelCount => this.incoming.Reader.Count;`
`154`	`154`	`private static readonly object Obj = new();`
`@@ -176,7 +176,7 @@ public bool IsClosed`
`176`	`176`	`{`
`177`	`177`	`get`
`178`	`178`	`{`
`179`		`- if (connection.IsClosed)`
	`179`	`+ if (_connection.IsClosed)`
`180`	`180`	`{`
`181`	`181`	`isClosed = true;`
`182`	`182`	`}`
`@@ -208,10 +208,10 @@ private async Task OnConnectionClosed(string reason)`
`208`	`208`	`public static async Task<Client> Create(ClientParameters parameters, ILogger logger = null)`
`209`	`209`	`{`
`210`	`210`	`var client = new Client(parameters, logger);`
`211`		`- client.connection = await Connection`
	`211`	`+ client._connection = await Connection`
`212`	`212`	`.Create(parameters.Endpoint, client.HandleIncoming, client.HandleClosed, parameters.Ssl, logger)`
`213`	`213`	`.ConfigureAwait(false);`
`214`		`- client.connection.ClientId = client.ClientId;`
	`214`	`+ client._connection.ClientId = client.ClientId;`
`215`	`215`	`// exchange properties`
`216`	`216`	`var peerPropertiesResponse = await client.Request<PeerPropertiesRequest, PeerPropertiesResponse>(corr =>`
`217`	`217`	`new PeerPropertiesRequest(corr, parameters.Properties)).ConfigureAwait(false);`
`@@ -283,6 +283,23 @@ await client.Publish(new TuneRequest(0,`
`283`	`283`	`return client;`
`284`	`284`	`}`
`285`	`285`
	`286`	`+ public async Task UpdateSecret(string newSecret)`
	`287`	`+ {`
	`288`	`+ var saslData = Encoding.UTF8.GetBytes($"\0{Parameters.UserName}\0{newSecret}");`
	`289`	`+`
	`290`	`+ var authResponse =`
	`291`	`+ await Request<SaslAuthenticateRequest, SaslAuthenticateResponse>(corr =>`
	`292`	`+ new SaslAuthenticateRequest(`
	`293`	`+ corr,`
	`294`	`+ Parameters.AuthMechanism.ToString().ToUpperInvariant(),`
	`295`	`+ saslData))`
	`296`	`+ .ConfigureAwait(false);`
	`297`	`+`
	`298`	`+ ClientExceptions.MaybeThrowException(`
	`299`	`+ authResponse.ResponseCode,`
	`300`	`+ "Error while updating secret: the secret will not be updated.");`
	`301`	`+ }`
	`302`	`+`
`286`	`303`	`public async ValueTask<bool> Publish(Publish publishMsg)`
`287`	`304`	`{`
`288`	`305`	`var publishTask = await Publish<Publish>(publishMsg).ConfigureAwait(false);`
`@@ -296,7 +313,7 @@ public ValueTask<bool> Publish<T>(T msg) where T : struct, ICommand`
`296`	`313`	`{`
`297`	`314`	`try`
`298`	`315`	`{`
`299`		`- return connection.Write(msg);`
	`316`	`+ return _connection.Write(msg);`
`300`	`317`	`}`
`301`	`318`	`catch (Exception e)`
`302`	`319`	`{`
`@@ -757,7 +774,7 @@ public async Task<CloseResponse> Close(string reason)`
`757`	`774`	`InternalClose();`
`758`	`775`	`try`
`759`	`776`	`{`
`760`		`- connection.UpdateCloseStatus(ConnectionClosedReason.Normal);`
	`777`	`+ _connection.UpdateCloseStatus(ConnectionClosedReason.Normal);`
`761`	`778`	`var result =`
`762`	`779`	`await Request<CloseRequest, CloseResponse>(corr => new CloseRequest(corr, reason),`
`763`	`780`	`TimeSpan.FromSeconds(10)).ConfigureAwait(false);`
`@@ -771,11 +788,11 @@ public async Task<CloseResponse> Close(string reason)`
`771`	`788`	`}`
`772`	`789`	`catch (Exception e)`
`773`	`790`	`{`
`774`		`- _logger.LogError(e, "An error occurred while calling {CalledFunction}", nameof(connection.Dispose));`
	`791`	`+ _logger.LogError(e, "An error occurred while calling {CalledFunction}", nameof(_connection.Dispose));`
`775`	`792`	`}`
`776`	`793`	`finally`
`777`	`794`	`{`
`778`		`- connection.Dispose();`
	`795`	`+ _connection.Dispose();`
`779`	`796`	`}`
`780`	`797`
`781`	`798`	`return new CloseResponse(0, ResponseCode.Ok);`
Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,8 @@ public interface IClient`
`28`	`28`	`IDictionary<byte, (string, (Action<ReadOnlyMemory<ulong>>, Action<(ulong, ResponseCode)[]>))> Publishers { get; }`
`29`	`29`	`IDictionary<byte, (string, ConsumerEvents)> Consumers { get; }`
`30`	`30`
	`31`	`+ Task UpdateSecret(string newSecret);`
	`32`	`+`
`31`	`33`	`public bool IsClosed { get; }`
`32`	`34`	`}`
`33`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -153,6 +153,17 @@ private async Task MayBeReconnectLocator()`
`153`	`153`	`}`
`154`	`154`	`}`
`155`	`155`
	`156`	`+ public async Task UpdateSecret(string newSecret)`
	`157`	`+ {`
	`158`	`+ if (_client.IsClosed)`
	`159`	`+ throw new UpdateSecretFailureException("Cannot update a closed connection.");`
	`160`	`+`
	`161`	`+ await _client.UpdateSecret(newSecret).ConfigureAwait(false);`
	`162`	`+ _clientParameters.Password = newSecret;`
	`163`	`+ _client.Parameters.Password = newSecret;`
	`164`	`+`
	`165`	`+ }`
	`166`	`+`
`156`	`167`	`public async Task<ISuperStreamProducer> CreateRawSuperStreamProducer(`
`157`	`168`	`RawSuperStreamProducerConfig rawSuperStreamProducerConfig, ILogger logger = null)`
`158`	`169`	`{`
`@@ -542,4 +553,11 @@ public StreamSystemInitialisationException(string error) : base(error)`
`542`	`553`	`{`
`543`	`554`	`}`
`544`	`555`	`}`
	`556`	`+ public class UpdateSecretFailureException : ProtocolException`
	`557`	`+ {`
	`558`	`+ public UpdateSecretFailureException(string s)`
	`559`	`+ : base(s)`
	`560`	`+ {`
	`561`	`+ }`
	`562`	`+ }`
`545`	`563`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,8 @@ public Task<CloseResponse> Close(string reason)`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`public IDictionary<byte, (string, ConsumerEvents)> Consumers { get; }`
	`35`	`+ public Task UpdateSecret(string newSecret) => throw new NotImplementedException();`
	`36`	`+`
`35`	`37`	`public bool IsClosed { get; }`
`36`	`38`
`37`	`39`	`public FakeClient(ClientParameters clientParameters)`