reply to wip

fixes #133

Signed-off-by: Gabriele Santomaggio <[email protected]>

Author: Gsantomaggio

RabbitMQ.AMQP.Client/IConnection.cs

@@ -28,16 +28,16 @@ public interface IConnection : ILifeCycle
         IConsumerBuilder ConsumerBuilder();
 
         /// <summary>
-        /// Create an <see cref="IRpcServerBuilder"/> instance for this connection.
+        /// Create an <see cref="IResponderBuilder"/> instance for this connection.
         /// </summary>
-        /// <returns><see cref="IRpcServerBuilder"/> instance for this connection.</returns>
-        IRpcServerBuilder RpcServerBuilder();
+        /// <returns><see cref="IResponderBuilder"/> instance for this connection.</returns>
+        IResponderBuilder ResponderBuilder();
 
         /// <summary>
-        /// Create an <see cref="IRpcClientBuilder"/> instance for this connection.
+        /// Create an <see cref="IRequesterBuilder"/> instance for this connection.
         /// </summary>
-        /// <returns><see cref="IRpcClientBuilder"/> instance for this connection.</returns>
-        IRpcClientBuilder RpcClientBuilder();
+        /// <returns><see cref="IRequesterBuilder"/> instance for this connection.</returns>
+        IRequesterBuilder RequesterBuilder();
 
         /// <summary>
         /// Get the properties for this connection.

RabbitMQ.AMQP.Client/IRpcClient.cs renamed to RabbitMQ.AMQP.Client/IRequester.cs

@@ -9,33 +9,33 @@
 namespace RabbitMQ.AMQP.Client
 {
 
-    public interface IRpcClientAddressBuilder : IAddressBuilder<IRpcClientAddressBuilder>
+    public interface IRequesterAddressBuilder : IAddressBuilder<IRequesterAddressBuilder>
     {
-        IRpcClientBuilder RpcClient();
+        IRequesterBuilder Requester();
     }
 
     /// <summary>
     /// IRpcClientBuilder is the interface for creating an RPC client.
-    /// See also <seealso cref="IRpcClient"/> and <seealso cref="IRpcServerBuilder"/>
+    /// See also <seealso cref="IRequester"/> and <seealso cref="IResponderBuilder"/>
     /// </summary>
-    public interface IRpcClientBuilder
+    public interface IRequesterBuilder
     {
         /// <summary>
         /// Request address where the client sends requests.
         /// The server consumes requests from this address.
         /// </summary>
         /// <returns></returns>
-        IRpcClientAddressBuilder RequestAddress();
+        IRequesterAddressBuilder RequestAddress();
 
         /// <summary>
         /// The queue from which requests are consumed.
         /// if not set the client will create a temporary queue.
         /// </summary>
         /// <param name="replyToQueueName"> The queue name</param>
         /// <returns></returns>
-        IRpcClientBuilder ReplyToQueue(string replyToQueueName);
+        IRequesterBuilder ReplyToQueue(string replyToQueueName);
 
-        IRpcClientBuilder ReplyToQueue(IQueueSpecification replyToQueue);
+        IRequesterBuilder ReplyToQueue(IQueueSpecification replyToQueue);
 
         /// <summary>
         /// Extracts the correlation id from the request message.
@@ -45,7 +45,7 @@ public interface IRpcClientBuilder
         /// </summary>
         /// <param name="correlationIdExtractor"></param>
         /// <returns></returns>
-        IRpcClientBuilder CorrelationIdExtractor(Func<IMessage, object>? correlationIdExtractor);
+        IRequesterBuilder CorrelationIdExtractor(Func<IMessage, object>? correlationIdExtractor);
 
         /// <summary>
         /// Post processes the reply message before sending it to the server.
@@ -56,7 +56,7 @@ public interface IRpcClientBuilder
         /// </summary>
         /// <param name="requestPostProcessor"></param>
         /// <returns></returns>
-        IRpcClientBuilder RequestPostProcessor(Func<IMessage, object, IMessage>? requestPostProcessor);
+        IRequesterBuilder RequestPostProcessor(Func<IMessage, object, IMessage>? requestPostProcessor);
 
         /// <summary>
         /// Client and Server must agree on the correlation id.
@@ -67,26 +67,26 @@ public interface IRpcClientBuilder
         /// <param name="correlationIdSupplier"></param>
         /// <returns></returns>
 
-        IRpcClientBuilder CorrelationIdSupplier(Func<object>? correlationIdSupplier);
+        IRequesterBuilder CorrelationIdSupplier(Func<object>? correlationIdSupplier);
 
         /// <summary>
         /// The time to wait for a reply from the server.
         /// </summary>
         /// <param name="timeout"></param>
         /// <returns></returns>
-        IRpcClientBuilder Timeout(TimeSpan timeout);
+        IRequesterBuilder Timeout(TimeSpan timeout);
         /// <summary>
         ///  Build and return the RPC client.
         /// </summary>
         /// <returns></returns>
-        Task<IRpcClient> BuildAsync();
+        Task<IRequester> BuildAsync();
     }
 
     /// <summary>
     ///  IRpcClient is the interface for an RPC client.
-    /// See also <seealso cref="IRpcServer"/> and <seealso cref="IRpcClientBuilder"/>
+    /// See also <seealso cref="IResponder"/> and <seealso cref="IRequesterBuilder"/>
     /// </summary>
-    public interface IRpcClient : ILifeCycle
+    public interface IRequester : ILifeCycle
     {
         /// <summary>
         /// PublishAsync sends a request message to the server and blocks the thread until the response is received.

RabbitMQ.AMQP.Client/IRpcServer.cs renamed to RabbitMQ.AMQP.Client/IResponder.cs

@@ -11,18 +11,18 @@ namespace RabbitMQ.AMQP.Client
     /// <summary>
     /// IRpcServerBuilder is the interface for creating an RPC server.
     /// The RPC server consumes requests from a queue and sends replies to a reply queue.
-    /// See also <seealso cref="IRpcServer"/>  and <seealso cref="IRpcClientBuilder"/>
+    /// See also <seealso cref="IResponder"/>  and <seealso cref="IRequesterBuilder"/>
     /// </summary>
-    public interface IRpcServerBuilder
+    public interface IResponderBuilder
     {
         /// <summary>
         /// The queue from which requests are consumed.
         /// The client sends requests to this queue and the server consumes them.
         /// </summary>
         /// <param name="requestQueue"></param>
         /// <returns></returns>
-        IRpcServerBuilder RequestQueue(string requestQueue);
-        IRpcServerBuilder RequestQueue(IQueueSpecification requestQueue);
+        IResponderBuilder RequestQueue(string requestQueue);
+        IResponderBuilder RequestQueue(IQueueSpecification requestQueue);
 
         /// <summary>
         /// Extracts the correlation id from the request message.
@@ -33,7 +33,7 @@ public interface IRpcServerBuilder
         /// <param name="correlationIdExtractor"></param>
         /// <returns></returns>
 
-        IRpcServerBuilder CorrelationIdExtractor(Func<IMessage, object>? correlationIdExtractor);
+        IResponderBuilder CorrelationIdExtractor(Func<IMessage, object>? correlationIdExtractor);
 
         /// <summary>
         /// Post processes the reply message before sending it to the client.
@@ -44,36 +44,36 @@ public interface IRpcServerBuilder
         /// </summary>
         /// <param name="replyPostProcessor"></param>
         /// <returns></returns>
-        IRpcServerBuilder ReplyPostProcessor(Func<IMessage, object, IMessage>? replyPostProcessor);
+        IResponderBuilder ReplyPostProcessor(Func<IMessage, object, IMessage>? replyPostProcessor);
 
         /// <summary>
         /// Handle the request message and return the reply message.
         /// </summary>
         /// <param name="handler"></param>
         /// <returns></returns>
-        IRpcServerBuilder Handler(RpcHandler handler);
+        IResponderBuilder Handler(RpcHandler handler);
 
         /// <summary>
         /// Build and return the RPC server.
         /// </summary>
         /// <returns></returns>
-        Task<IRpcServer> BuildAsync();
+        Task<IResponder> BuildAsync();
     }
 
     /// <summary>
     /// Event handler for handling RPC requests.
     /// </summary>
     // TODO cancellation token
-    public delegate Task<IMessage> RpcHandler(IRpcServer.IContext context, IMessage request);
+    public delegate Task<IMessage> RpcHandler(IResponder.IContext context, IMessage request);
 
     /// <summary>
     /// IRpcServer interface for creating an RPC server.
     /// The RPC is simulated by sending a request message and receiving a reply message.
     /// Where the client sends the queue where wants to receive the reply.
     /// RPC client ---> request queue ---> RPC server ---> reply queue ---> RPC client
-    /// See also <seealso cref="IRpcClient"/>
+    /// See also <seealso cref="IRequester"/>
     /// </summary>
-    public interface IRpcServer : ILifeCycle
+    public interface IResponder : ILifeCycle
     {
 
         public interface IContext

RabbitMQ.AMQP.Client/Impl/AddressBuilder.cs

@@ -124,16 +124,16 @@ public IMessage Build()
         }
     }
 
-    public class RpcClientAddressBuilder : DefaultAddressBuilder<IRpcClientAddressBuilder>, IRpcClientAddressBuilder
+    public class RequesterAddressBuilder : DefaultAddressBuilder<IRequesterAddressBuilder>, IRequesterAddressBuilder
     {
-        readonly AmqpRpcClientBuilder _builder;
-        public RpcClientAddressBuilder(AmqpRpcClientBuilder builder)
+        readonly AmqpRequesterBuilder _builder;
+        public RequesterAddressBuilder(AmqpRequesterBuilder builder)
         {
             _builder = builder;
             _owner = this;
         }
 
-        public IRpcClientBuilder RpcClient()
+        public IRequesterBuilder Requester()
         {
             return _builder;
         }

RabbitMQ.AMQP.Client/Impl/AmqpConnection.cs

@@ -124,21 +124,21 @@ public IConsumerBuilder ConsumerBuilder()
         }
 
         /// <summary>
-        /// Create an <see cref="IRpcServerBuilder"/> instance for this connection.
+        /// Create an <see cref="IResponderBuilder"/> instance for this connection.
         /// </summary>
-        /// <returns><see cref="IRpcServerBuilder"/> instance for this connection.</returns>
-        public IRpcServerBuilder RpcServerBuilder()
+        /// <returns><see cref="IResponderBuilder"/> instance for this connection.</returns>
+        public IResponderBuilder ResponderBuilder()
         {
-            return new AmqpRpcServerBuilder(this);
+            return new AmqpResponderBuilder(this);
         }
 
         /// <summary>
-        /// Create an <see cref="IRpcClientBuilder"/> instance for this connection.
+        /// Create an <see cref="IRequesterBuilder"/> instance for this connection.
         /// </summary>
-        /// <returns><see cref="IRpcClientBuilder"/> instance for this connection.</returns>
-        public IRpcClientBuilder RpcClientBuilder()
+        /// <returns><see cref="IRequesterBuilder"/> instance for this connection.</returns>
+        public IRequesterBuilder RequesterBuilder()
         {
-            return new AmqpRpcClientBuilder(this);
+            return new AmqpRequesterBuilder(this);
         }
 
         /// <summary>

RabbitMQ.AMQP.Client/Impl/AmqpRpcClient.cs renamed to RabbitMQ.AMQP.Client/Impl/AmqpRequester.cs

@@ -23,80 +23,80 @@ public class RpcClientConfiguration
         public Func<IMessage, object, IMessage>? RequestPostProcessor { get; set; }
     }
 
-    public class AmqpRpcClientBuilder : IRpcClientBuilder
+    public class AmqpRequesterBuilder : IRequesterBuilder
     {
-        private readonly RpcClientAddressBuilder _addressBuilder;
+        private readonly RequesterAddressBuilder _addressBuilder;
         private readonly AmqpConnection _connection;
         private readonly RpcClientConfiguration _configuration = new();
 
-        public AmqpRpcClientBuilder(AmqpConnection connection)
+        public AmqpRequesterBuilder(AmqpConnection connection)
         {
             _connection = connection;
-            _addressBuilder = new RpcClientAddressBuilder(this);
+            _addressBuilder = new RequesterAddressBuilder(this);
         }
 
-        public IRpcClientAddressBuilder RequestAddress()
+        public IRequesterAddressBuilder RequestAddress()
         {
             return _addressBuilder;
         }
 
-        public IRpcClientBuilder ReplyToQueue(string replyToQueueName)
+        public IRequesterBuilder ReplyToQueue(string replyToQueueName)
         {
             _configuration.ReplyToQueue = replyToQueueName;
             return this;
         }
 
-        public IRpcClientBuilder ReplyToQueue(IQueueSpecification replyToQueue)
+        public IRequesterBuilder ReplyToQueue(IQueueSpecification replyToQueue)
         {
             _configuration.ReplyToQueue = replyToQueue.QueueName;
             return this;
         }
 
-        public IRpcClientBuilder CorrelationIdExtractor(Func<IMessage, object>? correlationIdExtractor)
+        public IRequesterBuilder CorrelationIdExtractor(Func<IMessage, object>? correlationIdExtractor)
         {
             _configuration.CorrelationIdExtractor = correlationIdExtractor;
             return this;
         }
 
-        public IRpcClientBuilder RequestPostProcessor(Func<IMessage, object, IMessage>? requestPostProcessor)
+        public IRequesterBuilder RequestPostProcessor(Func<IMessage, object, IMessage>? requestPostProcessor)
         {
             _configuration.RequestPostProcessor = requestPostProcessor;
             return this;
         }
 
-        public IRpcClientBuilder CorrelationIdSupplier(Func<object>? correlationIdSupplier)
+        public IRequesterBuilder CorrelationIdSupplier(Func<object>? correlationIdSupplier)
         {
             _configuration.CorrelationIdSupplier = correlationIdSupplier;
             return this;
         }
 
-        public IRpcClientBuilder Timeout(TimeSpan timeout)
+        public IRequesterBuilder Timeout(TimeSpan timeout)
         {
             _configuration.Timeout = timeout;
             return this;
         }
 
-        public async Task<IRpcClient> BuildAsync()
+        public async Task<IRequester> BuildAsync()
         {
             _configuration.RequestAddress = _addressBuilder.Address();
             _configuration.Connection = _connection;
-            var rpcClient = new AmqpRpcClient(_configuration);
+            var rpcClient = new AmqpRequester(_configuration);
             await rpcClient.OpenAsync().ConfigureAwait(false);
             return rpcClient;
         }
     }
 
     /// <summary>
-    /// AmqpRpcClient is an implementation of <see cref="IRpcClient"/>.
+    /// AmqpRpcClient is an implementation of <see cref="IRequester"/>.
     /// It is a wrapper around <see cref="IPublisher"/> and <see cref="IConsumer"/> to create an RPC client over AMQP 1.0.
     /// even the PublishAsync is async the RPClient blocks the thread until the response is received.
     /// within the timeout.
     ///
     ///  The PublishAsync is thread-safe and can be called from multiple threads.
     ///
-    /// See also the server side <see cref="IRpcServer"/>.
+    /// See also the server side <see cref="IResponder"/>.
     /// </summary>
-    public class AmqpRpcClient : AbstractLifeCycle, IRpcClient
+    public class AmqpRequester : AbstractLifeCycle, IRequester
     {
         private readonly RpcClientConfiguration _configuration;
         private IConsumer? _consumer = null;
@@ -138,7 +138,7 @@ private IMessage RequestPostProcess(IMessage request, object correlationId)
                 .MessageId(correlationId);
         }
 
-        public AmqpRpcClient(RpcClientConfiguration configuration)
+        public AmqpRequester(RpcClientConfiguration configuration)
         {
             _configuration = configuration;
         }