How to Share a Common Variable Between Two Services on the Same Server using Rust and Tonic

Learn how to effectively share a common variable between two gRPC services in Rust with Tonic. This post walks you through setting up a simple solution using Mutex for safe concurrent access.
---

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Using a common variable between two services on the same server

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Sharing a Common Variable Between Two Services on the Same Server

If you're developing an application using Rust and Tonic, you might find yourself needing to share a common variable between multiple services running on the same server. This becomes particularly relevant when you want to maintain shared state across different service implementations.

The Problem

In your scenario, you've created two gRPC services:

Greeter: This service implements a simple greeting function.

Wonderful: This service provides a different response based on a non-argument request.

You're aiming to utilize a shared variable, such as world_name, in both services so that they can use and modify it collaboratively. However, you've encountered some challenges, specifically:

Combining both services into the same struct led to complications with borrowing in Rust.

Attempting to encapsulate shared state in a separate struct did not yield the expected results.

Exploring the singleton option felt unsatisfactory due to potential issues with global state management.

The Solution

To efficiently manage shared state between your services, you can utilize Rust's features like Arc (Atomic Reference Counting) and Mutex (Mutual Exclusion). Here's a breakdown of how to implement this approach step-by-step:

Step 1: Define a Shared State Structure

First, create a struct that will hold your shared variables.

[[See Video to Reveal this Text or Code Snippet]]

Step 2: Modify Service Structs to Include Shared State

You'll need to adjust your service structs to include the shared state wrapped in an Arc and a Mutex for safe access across threads.

[[See Video to Reveal this Text or Code Snippet]]

Step 3: Implement Service Methods

While implementing the service methods, ensure that you lock the shared state before accessing it.

Greeter Implementation

Inside the say_hello method, lock and access your shared state:

[[See Video to Reveal this Text or Code Snippet]]

Wonderful Implementation

Similarly, implement the its_a_wonderful_world method to access shared state:

[[See Video to Reveal this Text or Code Snippet]]

Step 4: Main Function Setup

Finally, you will initialize your shared state in the main function and provide it to both service instances.

[[See Video to Reveal this Text or Code Snippet]]

Conclusion

By using Arc and Mutex, you can efficiently share and modify a common variable across multiple gRPC services within the same server instance. This method ensures thread safety and concurrency, allowing your services to interact smoothly and effectively.

By following this structure, you should be able to implement shared state in your Rust and Tonic application without adopting less desirable patterns like global singletons.

If you have any questions or need further clarification on the implementation, feel free to ask!