Merge branch 'dev/sugam'

Author: SugamKuber

.gitignore

@@ -1,2 +1 @@
-test
-go.sum
+**.sum

client/client.go

@@ -2,58 +2,56 @@ package client
 
 import (
 	"fmt"
-	"github.com/IntelliLog/IntelliLog-GoLang-Driver/connection"
-	"strings"
+	"github.com/citra-org/chrono-db-go-driver/connection"
 )
 
 type Client struct {
 	conn *connection.Connection
 }
 
-func NewClient(uri string) (*Client, error) {
-	conn, err := connection.NewConnection(uri)
+func Connect(uri string) (*Client, string, error) {
+	conn, dbName, err := connection.NewConnection(uri)
 	if err != nil {
-		return nil, err
+		return nil, "", err
 	}
-	return &Client{conn: conn}, nil
+	return &Client{conn: conn}, dbName, nil
 }
 
 func (c *Client) Close() error {
 	return c.conn.Close()
 }
 
-func (c *Client) Create() error {
-	response, err := c.conn.Execute("c")
-	if err != nil {
-		return err
+func (c *Client) CreateChrono(chrono string) error {
+	if response, err := c.conn.Execute("cc " + "heheh"); err != nil || response != "OK" {
+		return fmt.Errorf("create failed: %v", err)
 	}
-	if response != "OK" {
-		return fmt.Errorf("create failed: %s", response)
+	return nil
+}
+
+func (c *Client) CreateStream(chrono string, stream string) error {
+	if response, err := c.conn.Execute("cs " + stream); err != nil || response != "OK" {
+		return fmt.Errorf("create failed: %v", err)
+	}
+	return nil
+}
+func (c *Client) DeleteStream(chrono string, stream string) error {
+	if response, err := c.conn.Execute("ds " + stream); err != nil || response != "OK" {
+		return fmt.Errorf("delete failed: %v", err)
 	}
 	return nil
 }
 
-func (c *Client) Write(data map[string]string) error {
-	command := "w"
+func (c *Client) WriteEvent(chrono string, stream string, data map[string]string) error {
+	command := "w " + stream + " "
 	for k, v := range data {
-		command += fmt.Sprintf(" %s %s", k, v)
-	}
-	response, err := c.conn.Execute(command)
-	if err != nil {
-		return err
+		command += k + " " + v + " "
 	}
-	if response != "OK" {
-		return fmt.Errorf("write failed: %s", response)
+	if response, err := c.conn.Execute(command); err != nil || response != "OK" {
+		return fmt.Errorf("write failed: %v", err)
 	}
 	return nil
 }
 
-func (c *Client) Read() (string, error) {
-	response, err := c.conn.Execute("r")
-	if err != nil {
-		return "", err
-	}
-	//TODO: fix this to send lines insted of lines as string (check ops/read.rs)
-	formattedResponse := strings.ReplaceAll(response, "&/n", "\n")
-	return formattedResponse, nil
+func (c *Client) Read(chrono string, stream string) (string, error) {
+	return c.conn.Execute("r " + stream)
 }

connection/connection.go

@@ -11,47 +11,48 @@ type Connection struct {
 	conn net.Conn
 }
 
-func NewConnection(uri string) (*Connection, error) {
+func NewConnection(uri string) (*Connection, string, error) {
 	parts := strings.Split(uri, "://")
-	if len(parts) != 2 || parts[0] != "itlg" {
-		return nil, fmt.Errorf("invalid URI scheme")
+	if len(parts) != 2 || parts[0] != "chrono" {
+		return nil, "", fmt.Errorf("invalid URI scheme")
 	}
 
 	authAndHost := strings.Split(parts[1], "@")
 	if len(authAndHost) != 2 {
-		return nil, fmt.Errorf("invalid URI format")
+		return nil, "", fmt.Errorf("invalid URI format")
 	}
 
 	auth := strings.Split(authAndHost[0], ":")
 	if len(auth) != 2 {
-		return nil, fmt.Errorf("invalid URI format")
+		return nil, "", fmt.Errorf("invalid URI format")
 	}
 	username := auth[0]
 	password := auth[1]
 
 	hostAndDatabase := strings.Split(authAndHost[1], "/")
 	if len(hostAndDatabase) != 2 {
-		return nil, fmt.Errorf("invalid URI format")
+		return nil, "", fmt.Errorf("invalid URI format")
 	}
 	host := hostAndDatabase[0]
+	chrono := hostAndDatabase[1]
 
 	conn, err := net.Dial("tcp", host)
 	if err != nil {
-		return nil, err
+		return nil, "", err
 	}
 
 	connection := &Connection{conn: conn}
 	err = connection.authenticate(username, password)
 	if err != nil {
 		conn.Close()
-		return nil, err
+		return nil, "", err
 	}
 
-	return connection, nil
+	return connection, chrono, nil
 }
 
 func (c *Connection) authenticate(username, password string) error {
-	command := fmt.Sprintf("%s %s auth\n", username, password)
+	command := fmt.Sprintf("auth %s %s", username, password)
 	_, err := c.conn.Write([]byte(command))
 	if err != nil {
 		return err
@@ -79,10 +80,12 @@ func (c *Connection) Execute(command string) (string, error) {
 		return "", err
 	}
 
-	response, err := bufio.NewReader(c.conn).ReadString('\n')
+	buffer := make([]byte, 1024)
+	n, err := c.conn.Read(buffer)
 	if err != nil {
 		return "", err
 	}
 
-	return strings.TrimSpace(response), nil
+	response := string(buffer[:n])
+	return response, nil
 }

go.mod

@@ -1,3 +1,34 @@
-module github.com/IntelliLog/IntelliLog-GoLang-Driver
+module github.com/citra-org/chrono-db-go-driver
 
 go 1.22.4
+
+require github.com/gin-gonic/gin v1.10.0
+
+require (
+	github.com/bytedance/sonic v1.11.6 // indirect
+	github.com/bytedance/sonic/loader v0.1.1 // indirect
+	github.com/cloudwego/base64x v0.1.4 // indirect
+	github.com/cloudwego/iasm v0.2.0 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.3 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.20.0 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
+	github.com/leodido/go-urn v1.4.0 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.12 // indirect
+	golang.org/x/arch v0.8.0 // indirect
+	golang.org/x/crypto v0.23.0 // indirect
+	golang.org/x/net v0.25.0 // indirect
+	golang.org/x/sys v0.20.0 // indirect
+	golang.org/x/text v0.15.0 // indirect
+	google.golang.org/protobuf v1.34.1 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

test/api.txt

@@ -0,0 +1,4 @@
+curl http://localhost:3000/cs/<stream>
+curl -X POST -d '{"<header>": "<body>","<header>": "<body>"}' -H "Content-Type: application/json" http://localhost:3000/w/<stream>
+curl http://localhost:3000/r/<stream>
+curl http://localhost:3000/ds/<stream>

test/test.go

@@ -0,0 +1,93 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/citra-org/chrono-db-go-driver/client"
+	"github.com/gin-gonic/gin"
+)
+
+var dbClient *client.Client
+var dbName string
+
+func main() {
+	uri := "chrono://admin:[email protected]:3141/dev4"
+	var err error
+
+	dbClient, dbName, err = client.Connect(uri)
+	if err != nil {
+		fmt.Println("Error connecting to database:", err)
+		return
+	}
+	defer dbClient.Close()
+
+	r := gin.Default()
+	// r.GET("/c", handleCreate)
+	r.POST("/w/:stream", handleWrite)
+	r.GET("/r/:stream", handleRead)
+	r.GET("/cs/:stream", handleCreateStream)
+	r.GET("/ds/:stream", handleDeleteStream)
+
+	fmt.Println("Server listening on port 3000")
+	err = r.Run(":3000")
+	if err != nil {
+		fmt.Println("Error starting server:", err)
+	}
+}
+
+// func handleCreate(c *gin.Context) {
+// 	err := dbClient.CreateChrono(dbName)
+// 	if err != nil {
+// 		c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("Error creating record: %s", err)})
+// 		return
+// 	}
+// 	c.String(http.StatusOK, "Create operation successful")
+// }
+
+func handleCreateStream(c *gin.Context) {
+	stream := c.Param("stream")
+	err := dbClient.CreateStream(dbName, stream)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("Error creating record: %s", err)})
+		return
+	}
+	c.String(http.StatusOK, "Create operation successful")
+}
+
+func handleDeleteStream(c *gin.Context) {
+	stream := c.Param("stream")
+	err := dbClient.DeleteStream(dbName, stream)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("Error deleting record: %s", err)})
+		return
+	}
+	c.String(http.StatusOK, "Delete operation successful")
+}
+
+func handleWrite(c *gin.Context) {
+	stream := c.Param("stream")
+
+	var data map[string]string
+	if err := c.ShouldBindJSON(&data); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("Error decoding request body: %s", err)})
+		return
+	}
+
+	err := dbClient.WriteEvent(dbName, stream, data)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("Error writing data: %s", err)})
+		return
+	}
+	c.String(http.StatusOK, "Write operation successful")
+}
+
+func handleRead(c *gin.Context) {
+	stream := c.Param("stream")
+	response, err := dbClient.Read(dbName, stream)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("Error reading data: %s", err)})
+		return
+	}
+	c.String(http.StatusOK, response)
+}