DEV Community: Achintya

Blazingly Fast Interprocess communication in Go using UNIX Sockets!!

Achintya — Sun, 17 Mar 2024 13:20:36 +0000

What are Unix Sockets?

A UNIX socket, AKA Unix Domain Socket, is an inter-process communication mechanism that allows bidirectional data exchange between processes. It is similar to TCP/IP sockets, but it does not use the network stack, and it is used for communication between processes on the same machine.

Why use Unix Sockets?

Unix sockets have various advantages as mentioned below:

UNIX domain sockets know that they’re executing on the same system, so they can avoid some checks and operations (like routing); which makes them faster and lighter than IP sockets.
They are also more secure because they are not exposed to the network.
They are also more reliable to use because they are not dependent on the network.

How to use Unix Sockets in Go?

We will be using the Gin web framework which allows us to route unix sockets pretty similarly like APIs. This makes the code more easy and familiar to work with.

Lets create a Gin server which listens on a Unix Socket and returns a the current ram usage of the process.




package main

import (
    "fmt"
    "net"
    "net/http"
    "runtime"

    "github.com/gin-gonic/gin"
)

func main() {
    router := gin.Default()

    router.GET("/ram", func(c *gin.Context) {
        var m runtime.MemStats
        runtime.ReadMemStats(&m)

        // Convert bytes to megabytes
        mb := m.Alloc / 1024 / 1024

        c.String(http.StatusOK, fmt.Sprintf("Current RAM usage: %v MB", mb))
    })

    listener, err := net.Listen("unix", "/tmp/demo.sock")
    if err != nil {
        panic(err)
    }

    http.Serve(listener, router)
}

Code Explanation

We are using the net.Listen function to listen on a Unix socket.
The first argument is the network type, which is unix in our case. The second argument is the path to the Unix socket file.
It is preferred to use the /tmp directory for the Unix socket file, as it is a common location for temporary files.
We are using the http.Serve function to serve the requests on the Unix socket.
As per the router, we have a single route /ram which returns the current RAM usage of the process.

Now, lets create the client which connects to the Unix socket and fetches the RAM usage.




package main

import (
    "context"
    "fmt"
    "io"
    "net"
    "net/http"
)

func main() {
    // Dial the Unix socket
    conn, err := net.Dial("unix", "/tmp/demo.sock")
    if err != nil {
        panic(err)
    }

    // Create an HTTP client with the Unix socket connection
    client := http.Client{
        Transport: &http.Transport{
            DialContext: func(_ context.Context, _, _ string) (net.Conn, error) {
                return conn, nil
            },
        },
    }

    // Send a GET request to the server
    resp, err := client.Get("http://unix/ram")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    // Read the response body
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    // Print the response body
    fmt.Println(string(body))
}

Code explanation

We are using the net.Dial function to dial the Unix socket.
The first argument is the network type, which is unix in our case. The second argument is the path to the Unix socket file.
We are creating an HTTP client with the Unix socket connection.
We are sending a GET request to the server using the Unix socket.
We are reading the response body and printing it.

Now let's run the server and the client and see the output.



cd server
go run main.go



go run main.go
[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.

[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
 - using env:   export GIN_MODE=release
 - using code:  gin.SetMode(gin.ReleaseMode)

[GIN-debug] GET    /ram                      --> main.main.func1 (3 handlers)
[GIN] 2024/03/17 - 20:49:55 | 200 |     346.791µs |                 | GET      "/ram"

You can actually disconnect the internet and run the client to see that it still works. For reference, I am running a ping command to google.com and then running the client to show that it still works.



cd client
ping -c 4 google.com
go run main.go



ping -c 4 google.com
go run main.go

ping: google.com: Temporary failure in name resolution
Current RAM usage: 2 MB

Can I use this as a normal TCP/IP server?

The simple answer is YES!

You can use NGINX to proxy pass your unix socket and use it as a simple HTTP server. Here is a NGINX config which can be imported into the nginx.conf file.



upstream demo {
    server unix:/tmp/demo.sock;
}

# the nginx server instance
server {
    listen 8081;
    server_name go.dev *.go.dev;

    location / {
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header Host $http_host;
      proxy_set_header X-NginX-Proxy true;
      proxy_http_version 1.1; # for keep-alive
      proxy_pass http://demo/;
      proxy_redirect off;
    }
}

NOTE: If you want to know more about NGINX and how to use it, you can refer to one of other blogs: Deploy on Linux with Systemctl and Nginx .

You might also need to change the permissions of the socket file to allow NGINX to access it. You can do that by running the following command.



sudo chmod a+rw /tmp/demo.sock

Finally, you can run the NGINX server and access the HTTP server using the NGINX server.



sudo nginx

curl localhost:8081/ram

Use Cases

Microservices: You can use Unix sockets to communicate between microservices running on the same machine.
GUI Applications: You can use Unix sockets to communicate between a GUI application and a backend server. Docker Desktop and Docker CLI uses Unix sockets to communicate with the Docker Daemon.
Security: Unix sockets are more secure than TCP/IP sockets because they are not exposed to the network.

Flutter Isolates 101

Achintya — Sun, 18 Feb 2024 16:01:22 +0000

What are Isolates?

In Flutter Isolates are a way to run computationally intensive tasks in the background. Isolates are independent and do not share memory.
They communicate with each other by sending messages. This is a very important concept to understand. Isolates are not threads and they do not share memory.
This means that you cannot access variables from the main isolate in a background isolate. You can only send messages to the main isolate and vice versa.

Where to use Isolates?

Isolates are useful when you have to perform a computationally intensive task in the background. For example, if you have to perform a heavy calculation or you have to download a large file from the internet, you can use isolates to perform these tasks in the background.
For this blog, we will run a function which will find the count of prime numbers between 1 and 200000. This is a computationally intensive task of about O(n^2)

Here is the code for the function:

Future<List<int>> getPrimes() async {
  bool isPrime(int n) {
    if (n <= 1) {
      return false;
    }
    for (var i = 2; i < n / 2; i++) {
      if (n % i == 0) {
        return false;
      }
    }
    return true;
  }

  final List<int> primes = [];
  for (var i = 0; i < 200000; i++) {
    if (isPrime(i)) {
      primes.add(i);
    }
  }

  log("No. Of Primes: ${primes.length}");

  return primes;
}

Lets run this function without isolates. I have a simple page with one CircularProgressIndicator and one Button widget. We will observe the UI when we click the button.
Here is the code for it.

{
    const SizedBox(height: 20),
    const CircularProgressIndicator(),
    const SizedBox(height: 20),
    FilledButton.tonal(
        child: const Text("Get Primes"),
        onPressed: () async => await getPrimes(),
    ),
}

We can see that the UI is blocked while the function is running.

How to use Isolates?

You can spawn a new isolate by calling the Isolate.spawn() method. Lets see how to use it.

Now, firstly we will modify our functions a bit. Firstly we will modify our getPrimes() function. A function to be used in an isolate should be an void function and it cant return any value like a normal function. It will also accept one parameter as SendPort.

void getPrimes(SendPort sendPort) {
  bool isPrime(int n) {
    if (n <= 1) {
      return false;
    }
    for (var i = 2; i < n / 2; i++) {
      if (n % i == 0) {
        return false;
      }
    }
    return true;
  }

  final List<int> primes = [];
  for (var i = 0; i < 200000; i++) {
    if (isPrime(i)) {
      primes.add(i);
    }
  }

  sendPort.send(primes);
}

Here we will return our list of primes using the sendPort. Think of sendPort like a pipe which will be used to transfer data from one isolate to another. Remember, all isolates as the name suggests are isolated and do not share memory. If you are familiar with Go, think of SendPort as a channels.
Now we will modify the onPressed method of our button such that it will spawn a new isolate and run our getPrimes() function in it.

FilledButton.tonal(
    child: const Text("Get Primes"),
    onPressed: () async {
        final receivePort = ReceivePort();
        await Isolate.spawn(getPrimes, receivePort.sendPort);
        final List<int> primes = await receivePort.first;
        Fluttertoast.showToast(msg: "Primes: ${primes.length}");
    },
),

We build a receivePort object and use it to spawn a new isolate. Then we will get the first value from receivePort after it completes its task. Then we will show it out using FlutterToast.

We can see that the UI is not blocked anymore. We can interact with the UI while the function is running in the background.

Sending Additional Data to Isolates

In the previous example, you can see that we were using a constant value of 200000. But what if we want to send a variable value to the isolate?
For that we can send a Map object to the isolate. Lets see how to do it. You can send any type of object T here so if you have a custom data object. You can send it too.
First lets modify the onPressed method of our button.

FilledButton.tonal(
    child: const Text("Get Primes"),
    onPressed: () async {
        final receivePort = ReceivePort();
        Map<String, dynamic> args = {
            "sendPort": receivePort.sendPort, 
            "n": 100000,
        };
        await Isolate.spawn(getPrimes, args);
        final List<int> primes = await receivePort.first;
        Fluttertoast.showToast(msg: "Primes: ${primes.length}");
    },
),

Here we are sending a Map object with two keys. One is the sendPort and the other is the value of n. Now lets modify our getPrimes() function to accept this Map object.

void getPrimes(Map<String, dynamic> args) {
  final int n = args["n"];
  final SendPort sendPort = args["sendPort"];

  bool isPrime(int n) {
    if (n <= 1) {
      return false;
    }
    for (var i = 2; i < n / 2; i++) {
      if (n % i == 0) {
        return false;
      }
    }
    return true;
  }

  final List<int> primes = [];
  for (var i = 0; i < n; i++) {
    if (isPrime(i)) {
      primes.add(i);
    }
  }

  sendPort.send(primes);
}

Here we are getting the value of n and the sendPort from the Map object. Now we can use the value of n in our function.
And thats it. Now we can send any type of object to our isolate.

The Better Way

Well what we have done previously can be considered the Boomer way but its a better way to understand the concept and understand how isolates * work.
There is a better way to call isolates using the compute() method. Lets see how to use it.
The onPressed button can be reduced to this.

FilledButton.tonal(
    child: const Text("Get Primes"),
    onPressed: () async {
        final List<int> primes = await compute(getPrimes, 100000);
        Fluttertoast.showToast(msg: "Primes: ${primes.length}");
    },
),

Similarly there will be some changes to the getPrimes() function.

List<int> getPrimes(int n) {
  bool isPrime(int n) {
    if (n <= 1) {
      return false;
    }
    for (var i = 2; i < n / 2; i++) {
      if (n % i == 0) {
        return false;
      }
    }
    return true;
  }

  final List<int> primes = [];
  for (var i = 0; i < n; i++) {
    if (isPrime(i)) {
      primes.add(i);
    }
  }

  return primes;
}

Now, we have written it as a normal function. This indeed is the better way to call isolates.

Conclusion

Isolates are a great way to run computationally intensive tasks in the background. Here we saw 2 ways to call isolates. One is the normal way and the other is the better way. I hope you liked this blog and you learned something new.