Service Communication: Integration of gRPC using Protocol Buffers

syntax = "proto3";

// Define the service
service MyService {
    // Define the unary RPC method
    rpc MyMethod(RequestMessage) returns (ResponseMessage);
}

// Define the request message type
message RequestMessage {
    // Define the fields of the request message
    string field1 = 1;
    int32 field2 = 2;
    // Add more fields as needed
}

// Define the response message type
message ResponseMessage {
    // Define the fields of the response message
    string result = 1;
    // Add more fields as needed
}

syntax = "proto3";

// Define the service
service MyStreamingService {
    // Define the server streaming RPC method
    rpc MyServerStreamingMethod(RequestMessage) returns (stream ResponseMessage);
}

// Define the request message type
message RequestMessage {
    // Define the fields of the request message
    string query = 1;
    // Add more fields as needed
}

// Define the response message type
message ResponseMessage {
    // Define the fields of the response message
    string result = 1;
    // Add more fields as needed
}

syntax = "proto3";

// Define the service
service MyClientStreamingService {
    // Define the client streaming RPC method
    rpc MyClientStreamingMethod(stream RequestMessage) returns (ResponseMessage);
}

// Define the request message type
message RequestMessage {
    // Define the fields of the request message
    string data = 1;
    // Add more fields as needed
}

// Define the response message type
message ResponseMessage {
    // Define the fields of the response message
    string result = 1;
    // Add more fields as needed
}

4. Bidirectional Streaming RPC

This RPC type allows both the client and server to independently send a stream of messages. This enables both parties to read and write messages concurrently over the same connection, making it particularly useful for scenarios requiring continuous communication between the client and server.

Protobuf file presentation for the above call.

syntax = "proto3";

// Define the service
service MyStreamingService {
    // Define the bidirectional streaming RPC method
    rpc MyBidirectionalStreamingMethod(stream RequestMessage) returns (stream ResponseMessage);
}

// Define the request message type
message RequestMessage {
    // Define the fields of the request message
    string data = 1;
    // Add more fields as needed
}

// Define the response message type
message ResponseMessage {
    // Define the fields of the response message
    string result = 1;
    // Add more fields as needed
}

What is a Protocol Buffers file?

A Protocol Buffers (protobuf) file is a text file that defines the structure of data messages and, optionally, service interfaces for gRPC-based systems. It uses a language-neutral interface definition language developed by Google for serializing structured data. Protobuf files typically have a .proto extension.

Sample of a protobuf file

syntax = "proto3";

// This defines a gRPC service named MyService. Inside MyService, there's a unary RPC method named MyMethod. This method takes a RequestMessage as input and returns a ResponseMessage.
service MyService {
    // Define the unary RPC method
    rpc MyMethod(RequestMessage) returns (ResponseMessage);
}

// This defines the structure of the request message (RequestMessage) used in the MyMethod RPC method. It has two fields: field1 of type string and field2 of type int32.
message RequestMessage {
    // Define the fields of the request message
    string field1 = 1;
    int32 field2 = 2;
    // Add more fields as needed
}

//This defines the structure of the response message (ResponseMessage) used in the MyMethod RPC method. It has a single field named result of type string with a field number of 1.
message ResponseMessage {
    // Define the fields of the response message
    string result = 1;
    // Add more fields as needed
}

What is a Channel in gRPC?

A channel in gRPC is an abstraction that represents a connection to a gRPC server. It acts as a conduit for communication, enabling clients to send RPC requests to the server and receive responses.

When creating a gRPC channel, you specify the server's address and can also configure various options such as security settings, load balancing policies, and timeouts. Once the channel is established, it takes care of managing the network connections, handling authentication and encryption if needed, and provides a user-friendly API for clients to make RPC calls.

In gRPC, channels are typically created using a channel builder or a channel factory, which abstracts the complexities of channel creation and configuration. This allows clients to focus on making RPC calls without having to worry about the underlying networking details.

Example Project

Step 1. The sample project appears as follows.

Step 2. The sample project is illustrated in the following manner.

• GrpcClientSource: The entirety of the client logic is established within this project.
• GrpcCommonSource: All files containing proto buffers are defined within this section.
• GrpcServerSource: The section contains the definition of the logic related to the server.
• GrpcTestingClient: The project functions as a client.
• GrpcTestingServer: This project functions in a manner similar to a server.

Step 3. I have segregated the implementation of request and response of protobuf files into distinct files like below.

greet. proto

syntax = "proto3";

import "Protos/HelloRequest.proto";
import "Protos/HelloReply.proto";
option csharp_namespace = "GrpcCommonSource";
package GrpcCommonSource;

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply);
}

HelloReply.proto

syntax = "proto3";

// The response message containing the greetings.
message HelloReply {
  string message = 1;
}

// HelloRequest.proto
syntax = "proto3";

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

Step 4. To start and stop the server

IGrpcServerHelper.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace GrpcServerSource.Interfaces
{
    public interface IGrpcServerHelper
    {
        void StartServer();
        void StopServer();
        bool CheckServerStatus();
    }
}

GrpcServerHelper.cs

using Grpc.Core;
using Grpc.Core.Interceptors;
using GrpcChatSample.Server;
using GrpcCommonSource;
using GrpcServerSource.Interfaces;
using GrpcServerSource.Services;
using GrpcServerSource.Utilities;
using System.ComponentModel.Composition;
using System.IO;

namespace GrpcServerSource.Implementation
{
    [Export(typeof(IGrpcServerHelper))]
    internal class GrpcServerHelper : IGrpcServerHelper
    {
        #region Fields declaration
        [Import]
        private Logger m_logger = null;
        private Grpc.Core.Server? m_server = null;
        private bool isServerRunning = false;
        [Import]
        private ChatGrpcService? m_service = null;
        [Import]
        private GreetGrpcService? m_greetGrpcservice = null;
        #endregion

        public bool CheckServerStatus()
        {
            return isServerRunning;
        }

        public void StartServer()
        {
            if (!isServerRunning)
            {
                // Locate required files and set true to enable SSL
                var secure = false;

                if (secure)
                {
                    // secure
                    var clientCACert = File.ReadAllText(@"C:\localhost_client.crt");
                    var serverCert = File.ReadAllText(@"C:\localhost_server.crt");
                    var serverKey = File.ReadAllText(@"C:\localhost_serverkey.pem");
                    var keyPair = new KeyCertificatePair(serverCert, serverKey);
                    var credentials = new SslServerCredentials(new[] { keyPair }, clientCACert, SslClientCertificateRequestType.RequestAndRequireAndVerify);

                    // Client authentication is an option. You can remove it as follows if you only need SSL.
                    //var credentials = new SslServerCredentials(new[] { keyPair });

                    m_server = new Grpc.Core.Server
                    {
                        Services =
                        {
                            Chat.BindService(m_service)
                                .Intercept(new ClientIdLogger()) // 2nd
                                .Intercept(new IpAddressAuthenticator()), // 1st
                            Greeter.BindService(m_greetGrpcservice)
                                .Intercept(new ClientIdLogger()) // 2nd
                                .Intercept(new IpAddressAuthenticator()) // 1st
                        },
                        Ports =
                        {
                            new ServerPort("localhost", 50052, credentials)
                        }
                    };
                }
                else
                {
                    // insecure
                    m_server = new Grpc.Core.Server
                    {
                        Services =
                        {
                            Chat.BindService(m_service)
                                .Intercept(new ClientIdLogger()) // 2nd
                                .Intercept(new IpAddressAuthenticator()), // 1st
                            Greeter.BindService(m_greetGrpcservice)
                                .Intercept(new ClientIdLogger()) // 2nd
                                .Intercept(new IpAddressAuthenticator()) // 1st
                        },
                        Ports =
                        {
                            new ServerPort("localhost", 50052, ServerCredentials.Insecure)
                        }
                    };
                }

                m_server.Start();
                m_logger.Info("Started.");
                isServerRunning = true;
            }
        }

        public void StopServer()
        {
            if (m_server != null)
            {
                if (isServerRunning)
                {
                    m_server.ShutdownTask.Wait();
                    isServerRunning = false;
                }
            }
        }
    }
}

Step 5. Client implementation

GreetServiceClient.cs

using Grpc.Core;
using Grpc.Core.Interceptors;
using GrpcCommonSource;
using System.IO;

namespace GrpcClientSource
{
    public class GreetServiceClient : IDisposable
    {
        private readonly Greeter.GreeterClient m_client;
        private readonly Channel? m_channel; // If you create multiple client instances, the Channel should be shared.
        private readonly CancellationTokenSource m_cts = new CancellationTokenSource();
        private bool disposedValue;

        public GreetServiceClient()
        {
            // Locate required files and set true to enable SSL
            var secure = false;

            if (secure)
            {
                // create secure channel
                var serverCACert = File.ReadAllText(@"C:\localhost_server.crt");
                var clientCert = File.ReadAllText(@"C:\localhost_client.crt");
                var clientKey = File.ReadAllText(@"C:\localhost_clientkey.pem");
                var keyPair = new KeyCertificatePair(clientCert, clientKey);
                //var credentials = new SslCredentials(serverCACert, keyPair);

                // Client authentication is an option. You can remove it as follows if you only need SSL.
                var credentials = new SslCredentials(serverCACert);
                m_channel = new Channel("localhost", 50052, credentials);
                m_client = new Greeter.GreeterClient(
                    m_channel
                    .Intercept(new ClientIdInjector()) // 2nd
                    .Intercept(new HeadersInjector())); // 1st
            }
            else
            {
                // create insecure channel
                m_channel = new Channel("localhost", 50052, ChannelCredentials.Insecure);
                m_client = new Greeter.GreeterClient(
                    m_channel
                    .Intercept(new ClientIdInjector()) // 2nd
                    .Intercept(new HeadersInjector())); // 1st
            }
        }

        public HelloReply SayHelloMethod(HelloRequest helloRequest)
        {
            return m_client.SayHello(helloRequest);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    m_cts.Cancel(); // without cancel active calls, ShutdownAsync() never completes...
                    m_channel.ShutdownAsync().Wait();
                }

                disposedValue = true;
            }
        }

        public void Dispose()
        {
            Dispose(disposing: true);
            GC.SuppressFinalize(this);
        }
    }
}

Step 6. Server implementation

GreetGrpcService.cs

using Grpc.Core;
using GrpcCommonSource;
using System.ComponentModel.Composition;

namespace GrpcServerSource.Services
{
    [Export]
    public class GreetGrpcService : Greeter.GreeterBase
    {
        public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context)
        {
            return Task.FromResult(new HelloReply
            {
                Message = "Hello " + request.Name
            });
        }
    }
}

Step 7. To execute the project, adhere to the subsequent instructions.

Run GrpcTestingClient and GrpcTestingServer simultaneously like below.

Step 8. Output Appearance

Repository Path: https://github.com/OmatrixTech/GrpcSampleExample