
# Custom Local Domain over HTTPS

## Note
This is a documention for my own reference, so I can come back to it in the future either for setting up a new custom local domain over HTTPS using `docker` and `nginx`, or reverting back to the original state.

## Steps
### mkcert
Install mkcert:
```bash
# MacOS
$ brew install mkcert

# Create and install a local certificate authority (CA), trusted locally on your device.
$ mkcert -install

# List the root CA files.
$ ls "$(mkcert -CAROOT)"
rootCA-key.pem rootCA.pem

# Create a trusted certificate.
$ mkdir potato_cld && cd potato_cld
$ mkcert potato.cld "*.potato.cld"

Created a new certificate valid for the following names 📜
 - "potato.cld"
 - "*.potato.cld"

Reminder: X.509 wildcards only go one level deep, so this won\'t match a.b.potato.cld

The certificate is at "./potato.cld+1.pem" and the key at "./potato.cld+1-key.pem" ✅

It will expire on 11 May 2026 🗓
```

The command `mkcert potato.cld "*.potato.cld"` above does two things:
1. Generates a certificate for the hostname you've specified
2. Lets `mkcert` (that you've added as a local CA) sign this certificate.

Now, the certificate is ready and signed by a certificate authority that the browser trusts locally.
### Configure DNS
#### 1. Modify `/etc/hosts`

The simplest way to go about this is to update the `/etc/hosts` as shown below,
```bash
##
# Host Database
#
# localhost is used to configure the loopback interface
# when the system is booting.  Do not change this entry.
##
127.0.0.1	      localhost
255.255.255.255	broadcasthost
::1             localhost

127.0.0.1       potato.cld api.potato.cld api2.potato.cld
```

But that is too simple. Let's crank up the complexity so I can learn something new - `dnsmasq`.

#### 2. Install, configure and start the `dnsmasq`server

> `dnsmasq` is a lightweight DNS, TFTP, PXE, router advertisement and DHCP server. It is intended to provide coupled DNS and DHCP service to a LAN.
> 
> Dnsmasq accepts DNS queries and either answers them from a small, local, cache or forwards them to a real, recursive, DNS server. It loads the contents of /etc/hosts so that local hostnames which do not appear in the global DNS can be resolved and also answers DNS queries for DHCP configured hosts. It can also act as the authoritative DNS server for one or more domains, allowing local names to appear in the global DNS. ...
> _source_: `man dnsmasq`

```bash
# Install
$ brew install dnsmasq
$ brew list dnsmasq
/opt/homebrew/Cellar/dnsmasq/2.90/.bottle/etc/dnsmasq.conf
/opt/homebrew/Cellar/dnsmasq/2.90/homebrew.dnsmasq.service
/opt/homebrew/Cellar/dnsmasq/2.90/homebrew.mxcl.dnsmasq.plist
/opt/homebrew/Cellar/dnsmasq/2.90/sbin/dnsmasq
/opt/homebrew/Cellar/dnsmasq/2.90/share/man/man8/dnsmasq.8

# Create a new directory and a `.conf` file:
$ mkdir -p /Users/bsm/Development/dnsmasq.d
$ touch /Users/bsm/Development/dnsmasq.d/dnsmasq.conf
```

We will now uncomment and update the value of `conf-dir=` in `/opt/homebrew/etc/dnsmasq.conf` to point to `dnsmasq.conf` file we created above.

```bash
% cat $(brew --prefix)/etc/dnsmasq.conf | grep conf-dir
#conf-dir=/opt/homebrew/etc/dnsmasq.d
conf-dir=/Users/bsm/Development/dnsmasq.d/,*.conf
#conf-dir=/opt/homebrew/etc/dnsmasq.d,.bak
#conf-dir=/opt/homebrew/etc/dnsmasq.d/,*.conf
```

Next, edit `/Users/bsm/Development/dnsmasq.d/dnsmasq.conf` and add the line `address=/potato.cld/127.0.0.1`.
```bash
$ cat /Users/bensoorajmohan/Development/dnsmasq.d/dnsmasq.conf 
address=/potato.cld/127.0.0.1

```

Now,
```bash
# start the `dnsmasq` service:
$ sudo brew services start dnsmasq

Warning: Taking root:admin ownership of some dnsmasq paths:
  /opt/homebrew/Cellar/dnsmasq/2.90/sbin
  /opt/homebrew/Cellar/dnsmasq/2.90/sbin/dnsmasq
  /opt/homebrew/opt/dnsmasq
  /opt/homebrew/opt/dnsmasq/sbin
  /opt/homebrew/var/homebrew/linked/dnsmasq

This will require manual removal of these paths using `sudo rm` on
brew upgrade/reinstall/uninstall.
==> **Successfully started `dnsmasq` (label: homebrew.mxcl.dnsmasq)**

# verify that the service is running:
$ sudo brew services
**Name  Status  User File**
black   none         
dnsmasq started root /Library/LaunchDaemons/homebrew.mxcl.dnsmasq.plist
unbound none
```

#### 3. Configure `resolv.conf`

Configure the DNS server to be used for the domain `potato.cld`:
```shell
# Make a new folder called /etc/resolver/, if it doesn't exist
$ sudo mkdir -p /etc/resolver/
# Create a new file with the name of the domain you want custom DNS settings for
$ touch /etc/resolver/potato.cld
# Set the nameserver that the domain should resolve to
$ sudo tee /etc/resolver/potato.cld >/dev/null <<EOF
nameserver 127.0.0.1
EOF

# restart local dnsmasq service
$ sudo brew services restart dnsmasq
Stopping `dnsmasq`... (might take a while)

==> **Successfully stopped `dnsmasq` (label: homebrew.mxcl.dnsmasq)**
Warning: Taking root:admin ownership of some dnsmasq paths:
  /opt/homebrew/Cellar/dnsmasq/2.90/sbin
  /opt/homebrew/Cellar/dnsmasq/2.90/sbin/dnsmasq
  /opt/homebrew/opt/dnsmasq
  /opt/homebrew/opt/dnsmasq/sbin
  /opt/homebrew/var/homebrew/linked/dnsmasq
This will require manual removal of these paths using `sudo rm` on
brew upgrade/reinstall/uninstall.
==> **Successfully started `dnsmasq` (label: homebrew.mxcl.dnsmasq)**
```

### Verify
```bash
$ dscacheutil -q host -a name potato.cld

name: potato.cld
ip_address: 127.0.0.1

# Verify the new resolver was picked up
$ scutil --dns
DNS configuration

resolver #8
  domain        : potato.cld
  nameserver[0] : 127.0.0.1
  flags         : Request A records, Request AAAA records
  reach         : 0x00030002 (Reachable,Local Address,Directly Reachable Address)
```

## Docker and Nginx

Clone the git repository and start the docker containers:
```bash
$ git clone https://github.com/bensooraj/blog-artefact-custom-local-domain.git
$ docker-compose up -d

$ curl https://api.potato.cld/ok 
200 OK: api.potato.cld

$ curl https://api2.potato.cld/ok
200 OK: api2.potato.cld

$ docker ps -a

CONTAINER ID   IMAGE                   COMMAND                  CREATED         STATUS         PORTS                                      NAMES
ef88c504a751   nginx:latest            "/docker-entrypoint.…"   2 minutes ago   Up 2 minutes   0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp   nginx
39651f26920c   one_tls_whoami-goapi    "./server"               2 minutes ago   Up 2 minutes   8080/tcp, 0.0.0.0:8080->443/tcp            one_tls_whoami-goapi-1
a98caad7d4cb   one_tls_whoami-goapi2   "./server"               2 minutes ago   Up 2 minutes   8080/tcp, 0.0.0.0:8081->443/tcp            one_tls_whoami-goapi2-1

$ docker logs nginx --tail=2
192.168.65.1 - - [15/Feb/2024:09:54:17 +0000] "GET /ok HTTP/1.1" 200 23 "-" "curl/8.1.2" "-"
192.168.65.1 - - [15/Feb/2024:09:54:18 +0000] "GET /ok HTTP/1.1" 200 24 "-" "curl/8.1.2" "-"

$ docker logs one_tls_whoami-goapi-1 --tail=2
2024/02/15 09:54:09 INFO server started on localhost. protocol=https port=443
2024/02/15 09:54:17 INFO Header:  X-API-ServerName=api.potato.cld

$ docker logs one_tls_whoami-goapi2-1 --tail=2                       
2024/02/15 09:54:09 INFO server started on localhost. protocol=https port=443
2024/02/15 09:54:18 INFO Header:  X-API-ServerName=api2.potato.cld
```

Explore the `nginx` configuration files:
```bash
$ cat nginx/conf/api2_potato_cld.conf

server {
	listen 80;
	listen [::]:80;
	server_name api2.potato.cld;

	return 301 https://api2.potato.cld$request_uri;
}

server {
	listen 443 ssl;
	listen [::]:443 ssl;

	server_name api2.potato.cld;

	ssl_certificate /etc/nginx/ssl/potato.cld.pem;
	ssl_certificate_key /etc/nginx/ssl/potato.cld-key.pem;

	# If they come here using HTTP, bounce them to the correct scheme
	error_page 497 https://$server_name:$server_port$request_uri;

	error_log /dev/stderr;
	access_log /dev/stdout main;

	location / {
		proxy_set_header X-API-ServerName $server_name;
		proxy_set_header X-Forwarded-For $remote_addr;
		proxy_set_header Host $http_host;
		proxy_pass https://host.docker.internal:8081;
	}
}
```

## References
1. [How to use HTTPS for local development](https://web.dev/articles/how-to-use-local-https)
2. [macOS: Using Custom DNS Resolvers](https://vninja.net/2020/02/06/macos-custom-dns-resolvers/)
3. [Mastering NGINX Logs in Docker: From Novice to Ninja](https://karandeepsingh.ca/post/nginx-logs-and-docker-your-ultimate-guide/)
4. [How to create local wildcard domains in MacOS using dnsmasq?](https://dev.to/timtsoitt/how-to-resolve-local-wildcard-domains-in-macos-h5e)
5. [Gist: Never touch your local /etc/hosts file in OS X again](https://gist.github.com/ogrrd/5831371)
6. [OS/X "etc/resolver/dev" isn't working - why not?](https://stackoverflow.com/questions/50914268/os-x-etc-resolver-dev-isnt-working-why-not)
7. [Using Dnsmasq for local development on OS X](https://passingcuriosity.com/2013/dnsmasq-dev-osx/)
8. [Local domains with HTTPS and Docker compose](https://medium.com/@TomVance/local-domains-with-https-469036775818)
9. [Docker-Powered Web Development Utilizing HTTPS and Local Domain Names](https://betterprogramming.pub/docker-powered-web-development-utilizing-https-and-local-domain-names-a57f129e1c4d)
10. [Setting up a custom domain for your local apps (Mac OS & Linux)](https://emmapopoola.medium.com/setting-up-a-custom-domain-for-your-local-apps-mac-os-linux-c68798722143)
11. [Configure NGINX as a Reverse Proxy with Docker Compose file](https://umasrinivask.medium.com/configure-nginx-as-a-reverse-proxy-with-docker-compose-file-4ebba2b75c89)
12. [How to Setup a Local DNS Server Using DNSMasq](https://stevessmarthomeguide.com/home-network-dns-dnsmasq/)


Custom Local Domain over HTTPS


import MDImage from '../../../components/MDImage.js';

# Function Inlining in Golang

## What is Inlining?

Inlining is a form of compiler optimisation where the compiler replaces a function call with the function's body to reduce the overhead of the function call. The following diagram crudely shows what this process looks like.

<MDImage src="/7/0_func_inlining.png" alt="Function inlining illustration" />

Let's take an example Go program.

```go
// main.go
package main

func main() {
	var a int = 10
	var b int = 20
	
	c := sum(a, b)
	print(c)
	
	d := difference(b, a)
	print(d)
}

func sum(a int, b int) int {
	return a + b
}

func difference(a int, b int) int {
	return a - b
}
```

Build the above program using the following command,
```sh
GOOS=darwin GOARCH=amd64 go build -o expinline_darwin_amd64
```

To understand inlining in practice, we will have to look at the assembly code generated by the above command and for that, we will have to disassemble the binary `expinline_darwin_amd64`.

Before we do that, let's look at the symbols (I am looking for the function names here),
```sh
$ objdump --syms expinline_darwin_amd64 | grep -E '_main.main|sum|difference'        
0000000001057600 l     F __TEXT,__text _main.main
0000000001014ba0 l     F __TEXT,__text _runtime.(*limiterEvent).consume
0000000001025000 l     F __TEXT,__text _runtime.(*pallocBits).summarize
000000000102c9c0 l     F __TEXT,__text _runtime.resumeG
```
You will see no symbols for the functions `sum` and `difference`. To understand why this is the case, let's dig deeper into the assembly code,
```sh
$ objdump expinline_darwin_amd64 --disassemble-symbols=_main.main
```
<MDImage src="/7/1_opt_and_inline_asm.jpeg" alt="" />

Surprisingly, I see no function calls (`callq`) to `sum` or `difference`. It looks as if the compiler was smart enough to reduce the whole program to calling the print function on two absolute constants `30` (`a`+`b`) and `10` (`b`-`a`) denoted by `movl $30, %eax` and `movl $10, %eax` respectively, before the call to `print`.

Let's turn off this compiler optimisation to preserve calculation logic and reevaluate the results.
```sh
$ GOOS=darwin GOARCH=amd64 go build -gcflags='-N' -o expinline_darwin_amd64_no_op
```

And examine the `_main.main` symbol again,
```sh
$ objdump expinline_darwin_amd64_no_op --disassemble-symbols=_main.main
```
<MDImage src="/7/2_no_opt_asm.jpeg" alt="" />

Now you can observe that there is addition logic between the offsets `105762a` and `105763c`  and subtraction logic between the offsets `1057665` and `105767c`. Again, there are no function calls (`callq`) to `sum` or `difference`, indicating that they have been inlined into the caller `main()`.

Along with turning off the optimisation, `inlining` can also be turned off.
```sh
$ GOOS=darwin GOARCH=amd64 go build -gcflags='-N -l' -o expinline_darwin_amd64_no_op_no_inline
```
If you examine the symbols now, you can see the missing functions as well:
```sh
$ objdump --syms expinline_darwin_amd64_no_op_no_inline | grep -E '_main.main|sum|difference'
00000000010576e0 l     F __TEXT,__text _main.difference
0000000001057600 l     F __TEXT,__text _main.main
00000000010576a0 l     F __TEXT,__text _main.sum
0000000001014ba0 l     F __TEXT,__text _runtime.(*limiterEvent).consume
0000000001025000 l     F __TEXT,__text _runtime.(*pallocBits).summarize
000000000102c9c0 l     F __TEXT,__text _runtime.resumeG
```
And here's the disassembled code,
<MDImage src="/7/3_no_opt_no_inline_asm.jpeg" alt="" />

## Why inline?

### Improves performance by minimising the function call overheads
These overheads include stack manipulation, CPU register loading/unloading, branching, handling return values, etc.

Let's perform a quick benchmark test to gauge the gain in performance. The following bench function calls the `sum` and `difference` functions,
```go
// main_bench_test.go
package main

import "testing"

var Result int

func BenchmarkSpecialBinomialProduct(b *testing.B) {
	var r int
	for i := 0; i < b.N; i++ {
		r = sum(i, i+7) * difference(i+7, i)
	}
	Result = r
}
```

Run it with all the default optimisations turned on,
```sh
$ go test -run='^$' -bench=. -benchmem -benchtime=10s -count=10 > bench_with_inlining.txt
```

Now add the compiler directive `//go:noinline` just above the function definitions of `sum` and `difference` and rerun the bench,
```sh
$ go test -run='^$' -bench=. -benchmem -benchtime=10s -count=10 > bench_with_no_inlining.txt
```

Finally, compare the results from the benchmark above,
```sh
$ benchstat {bench_with_no_inlining,bench_with_inlining}.txt
```
<MDImage src="/7/4_benchstat.png" alt="" />

Albeit a contrived example, you can see a performance improvement of ~78%.

Two things to note about inlining.
* It is a trade-off between space (increased binary size) and time (performance). This is because the function's body is copied to everywhere it is called.
* It yields diminishing returns as the functions get larger or more complex because the call overhead to these functions becomes relatively negligible.

### Augments escape analysis

Escape analysis is a compiler optimisation technique that determines if a value can be on the stack frame for the function constructing it or if the value must “escape” to the heap.

Let's consider the following example,
``` go
// escape/main.go
package main

type Point struct {
	x, y int
}

func NewPoint(x, y int) *Point {
	return &Point{x, y} // 8:9
}

func main() {
	p1 := NewPoint(10, 20) // 12:16
	p2 := NewPoint(30, 40) // 13:16
	
	print(p1.x, p2.y)
}
```

Build the above program with the `-m` compiler flag to print optimisation decisions,
```sh
$ go build -gcflags='-m=1' escape/main.go         
# command-line-arguments
escape/main.go:7:6: can inline NewPoint
escape/main.go:11:6: can inline main
escape/main.go:12:16: inlining call to NewPoint
escape/main.go:13:16: inlining call to NewPoint
escape/main.go:8:9: &Point{...} escapes to heap
escape/main.go:12:16: &Point{...} does not escape
escape/main.go:13:16: &Point{...} does not escape
```

Since `NewPoint` is expanded inside the `main` function, the lifetimes of `Point{10, 20}` and `Point{30, 40}` are bound within the `main`'s scope. 

Now build with inlining turned off,
```sh
$ go build -gcflags='-m=1 -l' escape/main.go
# command-line-arguments
escape/main.go:8:9: &Point{...} escapes to heap
```

Each call to `NewPoint(..)` will result in a `Point` object allocated to the heap memory.

## How does the compiler do that?

Go's compiler uses a combination of budget and cost to determine whether to inline a function. Every function has a cost compared against a budget (threshold). 

A function's cost is calculated using the complexity of the statements within the function body (one unit per node in the AST). And the budget changes from one release (40 in Go 1.6 | [src/cmd/compile/internal/gc/inl.go](https://github.com/golang/go/blob/7bc40ffb05d8813bf9b41a331b45d37216f9e747/src/cmd/compile/internal/gc/inl.go#L14)) to another (80 | [src/cmd/compile/internal/inline/inl.go](https://github.com/golang/go/blob/4be921d888d3a68c51e38d4c615a4438c7b2cb30/src/cmd/compile/internal/inline/inl.go#L47)).

Let's take the following example,
<MDImage src="/7/5_cost_budget_midstack.jpeg" alt="" />

Figures `a`, `b` and `c` represent the same program, each with slight modifications (green highlight) to demonstrate cost allocation and mid-stack inlining.

Let's build the program in Figure `a` (output condensed for relevance),
```sh
$ GOOS=darwin GOARCH=amd64 go build -gcflags='-m=2' midstack/main.go                      
# command-line-arguments
midstack/main.go:30:6: can inline Sum with cost 4 as: func(int, int) int { return a + b }
midstack/main.go:23:6: can inline MidPoint with cost 28 as: func(Point, Point) Point { return Point{...} }
midstack/main.go:25:9: inlining call to Sum
midstack/main.go:26:9: inlining call to Sum
midstack/main.go:18:6: cannot inline PrintPoint: function too complex: cost 89 exceeds budget 80
midstack/main.go:20:13: inlining call to fmt.Println
midstack/main.go:10:6: cannot inline main: function too complex: cost 114 exceeds budget 80
midstack/main.go:13:26: inlining call to MidPoint
midstack/main.go:13:26: inlining call to Sum
midstack/main.go:13:26: inlining call to Sum
```

You can see that each function has a cost assigned to it, which is compared against the budget (`80`) to decide whether the function can be inlined. The functions `MidPoint` (cost: `28`) and `Sum` (cost: `4`) are inline-able, whereas `PrintPoint` (cost: `89`) and `main` (cost: `114`) are not.

I will also use this example to showcase the two forms of inlining,
1. Leaf inlining
	- Earlier, only functions that did not call other functions (bottom of the call stack) were eligible for inlining. Once a leaf function is inlined, the resulting code can be inlined into its caller, a recursive process.
	- For example, `Sum` (a leaf function) gets inlined into `MidPoint`. Next, `MidPoint` (a leaf function now) gets inlined into `main`.
2. Mid-stack inlining
	- Now, non-leaf functions are also eligible for inlining.
	- For example, in Figure `c`, the function `Sum` is marked with the directive `//go:noinline`, making it non-eligible for inlining. Even though `MidPoint` calls `Sum`, it is allocated a cost of `76`, making it eligible for inlining.

## References
1. [Inlining optimisations in Go - Dave Cheney](https://dave.cheney.net/2020/04/25/inlining-optimisations-in-go#easy-footnote-5-4053)
2. [Mid-stack inlining in Go - Dave Cheney](https://dave.cheney.net/2020/05/02/mid-stack-inlining-in-go#easy-footnote-bottom-1-4076)
3. [Inlining - bright victories and hidden defeats](/7/6_inlining_2019_bright_victories_and_hidden_defeats.pdf)
4. [Five things that make Go fast - Dave Cheney](https://dave.cheney.net/2014/06/07/five-things-that-make-go-fast)
5. [Mid-stack inlining in the Go compiler - David Lazar](/7/7_talk_Mid-stack_inlining_in_the_Go_compiler.pdf)


Function Inlining in Golang


# Go RPCs (Remote Procedure Calls)

## Introduction

Go's `rpc` package enables communication across multiple machines, sort of like inter-process communication via funtion/method/procedure calls.

As the Go documentation puts it:
> Package `rpc` provides access to the exported methods of an object across a network or other I/O connection. A server registers an object, making it visible as a service with the name of the type of the object.

The object that is registered with the `rpc` server can be either primitive/builtin data types (`int`, `string` etc.) or user-defined ones (such as `struct`s). I would usually prefer a `struct`.

Under the hood, by default, Go uses `gob` for serializing and deserializing the remote procedure calls. This is configurable, that is, you can plug-in `JSON` or other custom codecs.

## Prerequisites

The methods which define actions on the registered object must adhere to a specific function signature. The methods,
- and its type(s) must be exported (uppercased)
- have two arguments, both exported (or builtin) types.
- their second argument is a pointer.
- must have one return type, `error`.

Essentially the method signature looks like the following:
```go
func (t *T) MethodName(argType T1, replyType *T2) error
```

## Implementation

Let's look at a dummy blog server and a client interacting with each other via `rpc`.
### a. Types

It's a good idea to wrap the object, along with the methods and types, into a package of its own. This makes it easier for both the server and client implementations to agree on common type definitions.

In the following code, `Blog` will be registered with the `rpc` server.
```go
type Blog struct {
	posts      map[int]Post
	lastPostID int
	sync.Mutex
}

type Post struct {
	ID    int
	Title string
	Body  string
}

// NewBlog is required because, even though Blog is exported its fields are not.
// The fields are internal to the package.
func NewBlog() *Blog {
	return &Blog{
		posts: make(map[int]Post),
	}
}
```
The function `NewBlog() *Blog` is necessary since we aren't exporting its fields: `posts` and `lastPostID`.

### b. Methods
`Blog` will have two methods: `AddPost` and `GetPostByID`. Notice the function signature.
```go
func (b *Blog) AddPost(payload, reply *Post) error {
	b.Lock()
	defer b.Unlock()

	if payload.Title == "" || payload.Body == "" {
		return errors.New("Title and Body must not be empty")
	}

	b.lastPostID++

	*reply = Post{ID: b.lastPostID, Title: payload.Title, Body: payload.Body}
	b.posts[reply.ID] = *reply

	return nil
}

func (b *Blog) GetPostByID(payload int, reply *Post) error {
	b.Lock()
	defer b.Unlock()

	*reply = b.posts[payload]

	return nil
}
```

Each method takes two arguments, `payload` and `reply` (you can name them anything). It receives the input from the client in the first parameter. The second argument (a pointer) is used for sending a response back to the client.

### c. Server
The server implementation is fairly simple:
```go
// Fetch an instance of the object
blog := types.NewBlog()

rpc.Register(blog) // Register the instance with the rpc
rpc.HandleHTTP() // Configure the rpc to serve over HTTP

err := http.ListenAndServe(":3000", nil)
if err != nil {
	log.Fatalln("Error starting the RPC server", err)
}
```

### d. Client

Dial the server using `rpc.DialHTTP`:
```go
client, err := rpc.DialHTTP("tcp", ":3000")
if err != nil {
	log.Fatalln("Error creating the RPC client", err)
}
```

And make the remote procedure calls using `client.Call`. It takes three arguments:
1. The method name of the form: `<T>.<MethodName>`
2. Input params
3. A pointer to receive the response from the server
```go
// Create a post
var post types.Post

// Create posts
err = client.Call("Blog.AddPost", &types.Post{Title: "post 1", Body: "Hello, world!"}, &post)
if err != nil {
	log.Fatalln("Error creating post", err)
}
log.Printf("[AddPost] ID: %d | Title: %s | Body: %s\n", post.ID, post.Title, post.Body)

// Fetch a post by ID
err = client.Call("Blog.GetPostByID", 3, &post)
if err != nil {
	log.Fatalln("Error creating post", err)
}
log.Printf("[GetPostByID] ID: %d | Title: %s | Body: %s\n", post.ID, post.Title, post.Body)
```

The entire code can be found on [Github](https://github.com/bensooraj/blog-code-resource-repo/tree/main/borneo).

## Some thoughts

In our implementation, the initial handshake between the `rpc` client and server are negotiated over HTTP. Thereafter, the HTTP server acts like a proxy or a conduit between the two, a concept known as [HTTP tunneling](https://en.wikipedia.org/wiki/HTTP_tunnel). I believe this can be customized.

It can be difficult to standardize (to follow common semantics) RPC implementations. This gap is what projects like `gRPC`, `dRPC` etc. attepmt to solve.

It should be obvious by now that you can register only one object with a given name with the `rpc` server.

Further reading:
1. [godoc: Package `rpc`](https://golang.org/pkg/net/rpc/)
2. [gRPC: A high performance, open source universal RPC framework](https://grpc.io/)
3. [dRPC: A lightweight, drop-in replacement for gRPC](https://github.com/storj/drpc)

---

Note: _This article is not an in-depth tutorial or treatment of Golang's syntax, semantics, design or implementation, but a journal of my learnings._

Ben Sooraj

Latest Posts

Read all posts

17.02.2024

Custom Local Domain over HTTPS

18.09.2023

Function Inlining in Golang

28.05.2021

Go RPCs (Remote Procedure Calls)