feat: add Rust and Go hello examples

Signed-off-by: Roman Volosatovs <[email protected]>

Author: rvolosatovs

Cargo.lock

@@ -17,7 +17,7 @@ license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/rvolosatovs/wrpc"
 
 [workspace]
-members = ["crates/*"]
+members = ["crates/*", "examples/rust/*"]
 
 [features]
 default = ["nats", "wasmtime"]
@@ -86,6 +86,7 @@ tokio-stream = { version = "0.1", default-features = false }
 tower = { version = "0.4", default-features = false }
 tracing = { version = "0.1", default-features = false }
 tracing-subscriber = { version = "0.3", default-features = false }
+url = { version = "2", default-features = false }
 wasmtime = { version = "19", default-features = false }
 wasmtime-wasi = { version = "19", default-features = false }
 wasmtime-wasi-http = { version = "19", default-features = false }

Cargo.toml

@@ -0,0 +1,16 @@
+module github.com/wrpc/wrpc/examples/go/hello-nats-server
+
+go 1.22.1
+
+require github.com/nats-io/nats.go v1.34.1
+
+require github.com/tetratelabs/wabin v0.0.0-20230304001439-f6f874872834
+
+require (
+	github.com/klauspost/compress v1.17.2 // indirect
+	github.com/nats-io/nkeys v0.4.7 // indirect
+	github.com/nats-io/nuid v1.0.1 // indirect
+	// indirect
+	golang.org/x/crypto v0.18.0 // indirect
+	golang.org/x/sys v0.16.0 // indirect
+)

examples/go/hello-nats-server/go.mod

@@ -0,0 +1,22 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/klauspost/compress v1.17.2 h1:RlWWUY/Dr4fL8qk9YG7DTZ7PDgME2V4csBXA8L/ixi4=
+github.com/klauspost/compress v1.17.2/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
+github.com/nats-io/nats.go v1.34.1 h1:syWey5xaNHZgicYBemv0nohUPPmaLteiBEUT6Q5+F/4=
+github.com/nats-io/nats.go v1.34.1/go.mod h1:Ubdu4Nh9exXdSz0RVWRFBbRfrbSxOYd26oF0wkWclB8=
+github.com/nats-io/nkeys v0.4.7 h1:RwNJbbIdYCoClSDNY7QVKZlyb/wfT6ugvFCiKy6vDvI=
+github.com/nats-io/nkeys v0.4.7/go.mod h1:kqXRgRDPlGy7nGaEDMuYzmiJCIAAWDK0IMBtDmGD0nc=
+github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
+github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/tetratelabs/wabin v0.0.0-20230304001439-f6f874872834 h1:ZF+QBjOI+tILZjBaFj3HgFonKXUcwgJ4djLb6i42S3Q=
+github.com/tetratelabs/wabin v0.0.0-20230304001439-f6f874872834/go.mod h1:m9ymHTgNSEjuxvw8E7WWe4Pl4hZQHXONY8wE6dMLaRk=
+golang.org/x/crypto v0.18.0 h1:PGVlW0xEltQnzFZ55hkuX5+KLyrMYhHld1YHO4AKcdc=
+golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
+golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
+golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

examples/go/hello-nats-server/go.sum

@@ -0,0 +1,100 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"math"
+	"os"
+
+	"github.com/nats-io/nats.go"
+	"github.com/tetratelabs/wabin/leb128"
+)
+
+func encode_string(s string) ([]byte, error) {
+	n := len(s)
+	if n > math.MaxUint32 {
+		return nil, fmt.Errorf("response UTF-8 string byte length of %d overflows u32", n)
+	}
+	return append(leb128.EncodeUint32(uint32(n)), s...), nil
+}
+
+func handle_hello(nc *nats.Conn, results string) (err error) {
+	b, err := encode_string("hello from Go")
+	if err != nil {
+		return fmt.Errorf("failed to encode `hello`: %w", err)
+	}
+	n := len(b)
+	maxPayload := nc.MaxPayload()
+	if int64(n) > maxPayload {
+		return fmt.Errorf("response length of %d exceeds NATS.io max payload of %d", n, maxPayload)
+	}
+	if err := nc.Publish(results, b); err != nil {
+		return fmt.Errorf("failed to publish response on result subject `%s`: %w", results, err)
+	}
+	return nil
+}
+
+func run() error {
+	// Connect to a server
+	nc, err := nats.Connect(nats.DefaultURL)
+	if err != nil {
+		return fmt.Errorf("failed to connect to NATS.io: %w", err)
+	}
+	defer func() {
+		if err := nc.Drain(); err != nil {
+			log.Printf("failed to drain NATS.io connection: %s", err)
+		}
+	}()
+	defer nc.Close()
+
+	hello := make(chan *nats.Msg)
+	helloSub, err := nc.ChanSubscribe("go.wrpc.0.0.1.wrpc-examples:hello/handler.hello", hello)
+	if err != nil {
+		return fmt.Errorf("failed to subscribe to `hello` invocations: %w", err)
+	}
+	defer func() {
+		if err := helloSub.Unsubscribe(); err != nil {
+			log.Printf("failed to unsubscribe from `hello`: %s", err)
+			return
+		}
+		close(hello)
+	}()
+	for msg := range hello {
+		if err := msg.Respond([]byte{}); err != nil {
+			log.Printf("failed to complete handshake on `%s` subject", msg.Reply)
+			continue
+		}
+
+		if err := handle_hello(nc, fmt.Sprintf("%s.results", msg.Reply)); err != nil {
+			log.Printf("failed to handle `hello`: %s", err)
+			b, err := encode_string(fmt.Sprintf("%s", err))
+			if err != nil {
+				log.Printf("failed to encode `hello` handling error: %s", err)
+				// Encoding the error failed, let's try encoding the encoding error, shall we?
+				b, err = encode_string(fmt.Sprintf("failed to encode error: %s", err))
+				if err != nil {
+					log.Printf("failed to encode `hello` handling error encoding error: %s", err)
+					// Well, we're out of luck at this point, let's just send an empty string
+					b = []byte{0}
+				}
+			}
+			if len(b) > int(nc.MaxPayload()) {
+				// TODO: split the payload into multiple chunks
+				b = []byte{0}
+			}
+			if err = nc.Publish(fmt.Sprintf("%s.error", msg.Reply), b); err != nil {
+				log.Printf("failed to send error to client: %s", err)
+			}
+		}
+	}
+	return nil
+}
+
+func main() {
+	log.SetFlags(0)
+	log.SetOutput(os.Stderr)
+
+	if err := run(); err != nil {
+		log.Fatal(err)
+	}
+}

examples/go/hello-nats-server/main.go

@@ -0,0 +1,27 @@
+[package]
+name = "hello-nats-client"
+version = "0.1.0"
+
+authors.workspace = true
+categories.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[dependencies]
+anyhow = { workspace = true }
+async-nats = { workspace = true }
+clap = { workspace = true, features = [
+    "color",
+    "derive",
+    "error-context",
+    "help",
+    "std",
+    "suggestions",
+    "usage",
+] }
+tokio = { workspace = true, features = ["rt-multi-thread"] }
+tracing-subscriber = { workspace = true, features = ["ansi", "fmt"] }
+url = { workspace = true }
+wit-bindgen-wrpc = { workspace = true }
+wrpc-transport-nats = { workspace = true }

examples/rust/hello-nats-client/Cargo.toml

@@ -0,0 +1,67 @@
+use anyhow::Context as _;
+use clap::Parser;
+use tokio::sync::mpsc;
+use url::Url;
+
+mod bindings {
+    wit_bindgen_wrpc::generate!();
+}
+
+#[derive(Parser, Debug)]
+#[command(author, version, about, long_about = None)]
+struct Args {
+    /// NATS.io URL to connect to
+    #[arg(short, long, default_value = "nats://127.0.0.1:4222")]
+    nats: Url,
+
+    /// Prefixes to invoke `hello` on
+    prefixes: Vec<String>,
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt().init();
+
+    let Args { nats, prefixes } = Args::parse();
+
+    let nats = connect(nats)
+        .await
+        .context("failed to connect to NATS.io")?;
+    for prefix in prefixes {
+        let wrpc = wrpc_transport_nats::Client::new(nats.clone(), prefix.clone());
+        let hello = bindings::wrpc_examples::hello::handler::hello(&wrpc)
+            .await
+            .context("failed to invoke `wrpc-examples.hello/handler.hello`")?;
+        eprintln!("{prefix}: {hello}")
+    }
+    Ok(())
+}
+
+/// Connect to NATS.io server and ensure that the connection is fully established before
+/// returning the resulting [`async_nats::Client`]
+async fn connect(url: Url) -> anyhow::Result<async_nats::Client> {
+    let (conn_tx, mut conn_rx) = mpsc::channel(1);
+    let client = async_nats::connect_with_options(
+        String::from(url),
+        async_nats::ConnectOptions::new()
+            .retry_on_initial_connect()
+            .event_callback(move |event| {
+                let conn_tx = conn_tx.clone();
+                async move {
+                    if let async_nats::Event::Connected = event {
+                        conn_tx
+                            .send(())
+                            .await
+                            .expect("failed to send NATS.io server connection notification");
+                    }
+                }
+            }),
+    )
+    .await
+    .context("failed to connect to NATS.io server")?;
+    conn_rx
+        .recv()
+        .await
+        .context("failed to await NATS.io server connection to be established")?;
+    Ok(client)
+}

examples/rust/hello-nats-client/src/main.rs

@@ -0,0 +1,4 @@
+[hello]
+path = "../../../wit/hello"
+sha256 = "3680bb734f3fa9f7325674142a2a9b558efd34ea2cb2df7ccb651ad869078d27"
+sha512 = "688fdae594dc43bd65bd15ea66b77a8f97cb4bc1c3629719e91d6c1391c66f7c8c6517d096f686cca996188f64f075c4ccb0d70a40097ce76b8b4bcc71dc7506"