Go: Implement connection logic in lib.rs

go/.gitignore

@@ -1,4 +1,7 @@
 # Go compilation files
 *.pb.go
 
+# Example binary
+examples/examples
+
 reports

go/Cargo.toml

@@ -13,6 +13,8 @@ redis = { path = "../submodules/redis-rs/redis", features = ["aio", "tokio-comp"
 glide-core = { path = "../glide-core" }
 tokio = { version = "^1", features = ["rt", "macros", "rt-multi-thread", "time"] }
 protobuf = { version = "3.3.0", features = [] }
+logger_core = {path = "../logger_core"}
+tracing-subscriber = "0.3.16"
 
 [profile.release]
 lto = true

go/examples/main.go

@@ -0,0 +1,38 @@
+/**
+ * Copyright GLIDE-for-Redis Project Contributors - SPDX Identifier: Apache-2.0
+ */
+package main
+
+import (
+	"fmt"
+	"github.com/aws/glide-for-redis/go/glide/glide"
+	"github.com/aws/glide-for-redis/go/glide/protobuf"
+	"log"
+)
+
+func main() {
+	fmt.Println("Starting go-glide client...")
+	client := glide.GlideRedisClient{}
+
+	// TODO: Update when configuration is implemented
+	request := &protobuf.ConnectionRequest{
+		TlsMode:            protobuf.TlsMode_NoTls,
+		ClusterModeEnabled: false,
+		ReadFrom:           protobuf.ReadFrom_Primary,
+	}
+	request.Addresses = append(
+		request.Addresses,
+		&protobuf.NodeAddress{Host: "localhost", Port: uint32(6379)},
+	)
+	connectionErr := client.ConnectToRedis(request)
+	if connectionErr != nil {
+		log.Fatal(connectionErr)
+	}
+
+	closeClientErr := client.CloseClient()
+	if closeClientErr != nil {
+		log.Fatal(closeClientErr)
+	}
+
+	fmt.Println("Disconnected from Redis")
+}

go/glide/glide.go

@@ -0,0 +1,76 @@
+/**
+ * Copyright GLIDE-for-Redis Project Contributors - SPDX Identifier: Apache-2.0
+ */
+package glide
+
+/*
+#cgo LDFLAGS: -L../target/release -lglide_rs
+#include "lib.h"
+
+void successCallback(uintptr_t channelPtr, char *message);
+void failureCallback(uintptr_t channelPtr, char *errMessage, RequestErrorType errType);
+*/
+import "C"
+
+import (
+	"fmt"
+	"github.com/aws/glide-for-redis/go/glide/protobuf"
+	"github.com/golang/protobuf/proto"
+	"unsafe"
+)
+
+type GlideRedisClient struct {
+	coreClient unsafe.Pointer
+}
+
+type payload struct {
+	value      string
+	errMessage error
+}
+
+type RequestType uint32
+
+type ErrorType uint32
+
+const (
+	ClosingError = iota
+	RequestError
+	TimeoutError
+	ExecAbortError
+	ConnectionError
+)
+
+//export successCallback
+func successCallback(channelPtr C.uintptr_t, message *C.char) {
+	// TODO: Implement when we implement the command logic
+}
+
+//export failureCallback
+func failureCallback(channelPtr C.uintptr_t, errMessage *C.char, errType C.RequestErrorType) {
+	// TODO: Implement when we implement the command logic
+}
+
+func (glideRedisClient *GlideRedisClient) ConnectToRedis(request *protobuf.ConnectionRequest) error {
+	marshalledRequest, err := proto.Marshal(request)
+	if err != nil {
+		return fmt.Errorf("Failed to encode connection request: %v", err)
+	}
+	byteCount := len(marshalledRequest)
+	requestBytes := C.CBytes(marshalledRequest)
+	response := (*C.struct_ConnectionResponse)(C.create_client((*C.uchar)(requestBytes), C.uintptr_t(byteCount), (C.SuccessCallback)(unsafe.Pointer(C.successCallback)), (C.FailureCallback)(unsafe.Pointer(C.failureCallback))))
+	defer C.free_connection_response(response)
+	if response.error_message != nil {
+		defer C.free_error(response.error_message)
+		return fmt.Errorf(C.GoString(response.error_message))
+	}
+	glideRedisClient.coreClient = response.conn_ptr
+	return nil
+}
+
+func (glideRedisClient *GlideRedisClient) CloseClient() error {
+	if glideRedisClient.coreClient == nil {
+		return fmt.Errorf("Cannot close glide client before it has been created.")
+	}
+	C.close_client(glideRedisClient.coreClient)
+	return nil
+}

go/glide/lib.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright GLIDE-for-Redis Project Contributors - SPDX Identifier: Apache-2.0
+ */
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef enum RequestErrorType {
+  Unspecified = 0,
+  ExecAbort = 1,
+  Timeout = 2,
+  Disconnect = 3,
+} RequestErrorType;
+
+/**
+ * The connection response.
+ *
+ * It contains either a connection or an error. It is represented as a struct instead of a union for ease of use in the wrapper language.
+ */
+typedef struct ConnectionResponse {
+  const void *conn_ptr;
+  const char *error_message;
+  RequestErrorType error_type;
+} ConnectionResponse;
+
+/**
+ * Success callback that is called when a Redis command succeeds.
+ */
+typedef void (*SuccessCallback)(uintptr_t channel_address, const char *message);
+
+/**
+ * Failure callback that is called when a Redis command fails.
+ *
+ * `error` should be manually freed by calling `free_error` after this callback is invoked, otherwise a memory leak will occur.
+ */
+typedef void (*FailureCallback)(uintptr_t channel_address,
+                                const char *error_message,
+                                RequestErrorType error_type);
+
+/**
+ * Creates a new client with the given configuration. The success callback needs to copy the given string synchronously, since it will be dropped by Rust once the callback returns. All callbacks should be offloaded to separate threads in order not to exhaust the client's thread pool.
+ *
+ * The returned `ConnectionResponse` should be manually freed by calling `free_connection_response`, otherwise a memory leak will occur. It should be freed whether or not an error occurs.
+ *
+ * # Safety
+ *
+ * * `connection_request_bytes` must point to `connection_request_len` consecutive properly initialized bytes.
+ * * `connection_request_len` must not be greater than `isize::MAX`. See the safety documentation of [`std::slice::from_raw_parts`](https://doc.rust-lang.org/std/slice/fn.from_raw_parts.html).
+ */
+const struct ConnectionResponse *create_client(const uint8_t *connection_request_bytes,
+                                               uintptr_t connection_request_len,
+                                               SuccessCallback success_callback,
+                                               FailureCallback failure_callback);
+
+/**
+ * Closes the given client, deallocating it from the heap.
+ *
+ * # Safety
+ *
+ * * `client_ptr` must be able to be safely casted to a valid `Box<Client>` via `Box::from_raw`. See the safety documentation of [`std::boxed::Box::from_raw`](https://doc.rust-lang.org/std/boxed/struct.Box.html#method.from_raw).
+ * * `client_ptr` must not be null.
+ */
+void close_client(const void *client_ptr);
+
+/**
+ * Deallocates a `ConnectionResponse`.
+ *
+ * # Safety
+ *
+ * * `connection_response_ptr` must be able to be safely casted to a valid `Box<ConnectionResponse>` via `Box::from_raw`. See the safety documentation of [`std::boxed::Box::from_raw`](https://doc.rust-lang.org/std/boxed/struct.Box.html#method.from_raw).
+ * * `connection_response_ptr` must not be null.
+ */
+void free_connection_response(const struct ConnectionResponse *connection_response_ptr);
+
+/**
+ * Deallocates an error message `CString`.
+ *
+ * # Safety
+ *
+ * * `error_msg_ptr` must be able to be safely casted to a valid `CString` via `CString::from_raw`. See the safety documentation of [`std::ffi::CString::from_raw`](https://doc.rust-lang.org/std/ffi/struct.CString.html#method.from_raw).
+ * * `error_msg_ptr` must not be null.
+ */
+void free_error(const char *error_msg_ptr);

go/go.mod

@@ -8,6 +8,16 @@ require (
 )
 
 require (
+	github.com/BurntSushi/toml v1.2.1 // indirect
+	github.com/golang/protobuf v1.5.3 // indirect
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/spf13/cobra v1.8.0 // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+	golang.org/x/exp/typeparams v0.0.0-20221208152030-732eee02a75a // indirect
+	golang.org/x/mod v0.12.0 // indirect
+	golang.org/x/sync v0.6.0 // indirect
+	golang.org/x/sys v0.11.0 // indirect
+	golang.org/x/tools v0.12.1-0.20230825192346-2191a27a6dc5 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/google/go-cmp v0.6.0 // indirect
 	github.com/kr/pretty v0.3.1 // indirect