More re-arrangements

Author: 0x19

cmd/benchmark.go

@@ -1,14 +1,20 @@
 package cmd
 
 import (
+	"context"
+	"crypto/rand"
+	"crypto/tls"
+	"encoding/binary"
 	"fmt"
 	"github.com/unpackdev/fdb"
-	"github.com/unpackdev/fdb/pkg/config"
-	"github.com/unpackdev/fdb/pkg/types"
+	"github.com/unpackdev/fdb/config"
+	"github.com/unpackdev/fdb/types"
 	"github.com/urfave/cli/v2"
-	"log"
+	"io"
 	"runtime"
 	"time"
+
+	"github.com/quic-go/quic-go"
 )
 
 // BenchmarkCommand returns a cli.Command that benchmarks the real client
@@ -17,62 +23,154 @@ func BenchmarkCommand() *cli.Command {
 		Name:  "test",
 		Usage: "Benchmark the real client",
 		Action: func(c *cli.Context) error {
-			// Simulate benchmarking logic here
 			fmt.Println("Running client benchmark...")
 
+			// Configure QUIC transport
 			cnf := config.Config{
 				Transports: []config.Transport{
 					{
 						Type:    types.QUICTransportType,
 						Enabled: true,
 						Config:  config.QuicTransport{IPv4: "127.0.0.1", Port: 4433},
 					},
-					/*					{
-										Type:    fdb.UDS,
-										Enabled: true,
-										Config:  fdb.UdsTransport{IPv4: "127.0.0.1", Port: 8000},
-									},*/
 				},
 			}
 
-			fdbc, fdbcErr := fdb.New(c.Context, cnf)
-			if fdbcErr != nil {
-				return fdbcErr
+			// Initialize FDB
+			fdbc, err := fdb.New(c.Context, cnf)
+			if err != nil {
+				return err
+			}
+
+			// Get QUIC transport
+			quicTransport, err := fdbc.GetTransportByType(types.QUICTransportType)
+			if err != nil {
+				return fmt.Errorf("failed to retrieve QUIC transport: %w", err)
 			}
 
-			_ = fdbc
+			// Start the QUIC server
+			quicServer, ok := quicTransport.(*fdb.QuicServer)
+			if !ok {
+				return fmt.Errorf("failed to cast transport to QuicServer")
+			}
+			if err := quicServer.Start(); err != nil {
+				return fmt.Errorf("failed to start QUIC server: %w", err)
+			}
 
-			// Example: Perform a benchmark by running some mock client operations
-			benchmarkClient()
+			fmt.Println("QUIC server started successfully")
+
+			// Benchmark client
+			err = benchmarkQuicClient(quicServer.Addr())
+			if err != nil {
+				return fmt.Errorf("client benchmark failed: %w", err)
+			}
 
 			return nil
 		},
 	}
 }
 
-// benchmarkClient simulates client benchmarking
-func benchmarkClient() {
-	// Capture initial memory usage
+// benchmarkQuicClient benchmarks the QUIC client by simulating write and read operations
+func benchmarkQuicClient(serverAddr string) error {
+	// Setup TLS configuration for QUIC client
+	clientTLSConfig := &tls.Config{
+		InsecureSkipVerify: true,
+		NextProtos:         []string{"quic-example"},
+	}
+
+	// Start benchmarking
+	start := time.Now()
 	var memStart runtime.MemStats
 	runtime.ReadMemStats(&memStart)
 
-	// Simulate some work being done by the client
-	start := time.Now()
+	// Connect to the QUIC server
+	client, err := quic.DialAddr(context.Background(), serverAddr, clientTLSConfig, nil)
+	if err != nil {
+		return fmt.Errorf("failed to dial QUIC server: %w", err)
+	}
+	defer client.CloseWithError(0, "closing connection")
+
+	// Open stream
+	stream, err := client.OpenStreamSync(context.Background())
+	if err != nil {
+		return fmt.Errorf("failed to open stream: %w", err)
+	}
+	defer stream.Close()
+
+	// Simulate write operation
+	message := createWriteMessage()
+	encodedMessage, err := message.Encode()
+	if err != nil {
+		return fmt.Errorf("failed to encode message: %w", err)
+	}
+
+	_, err = stream.Write(encodedMessage)
+	if err != nil {
+		return fmt.Errorf("failed to write message to server: %w", err)
+	}
+
+	// Read server response
+	buffer := make([]byte, 1024)
+	_, err = stream.Read(buffer)
+	if err != nil {
+		return fmt.Errorf("failed to read response: %w", err)
+	}
+	fmt.Printf("Response from server: %s\n", string(buffer))
+
+	// Simulate read operation
+	readMessage := createReadMessage(message.Key)
+	encodedReadMessage, err := readMessage.Encode()
+	if err != nil {
+		return fmt.Errorf("failed to encode read message: %w", err)
+	}
+
+	_, err = stream.Write(encodedReadMessage)
+	if err != nil {
+		return fmt.Errorf("failed to write read message to server: %w", err)
+	}
+
+	// Read back the data length
+	_, err = io.ReadFull(stream, buffer[:4])
+	if err != nil {
+		return fmt.Errorf("failed to read data length: %w", err)
+	}
+	valueLength := binary.BigEndian.Uint32(buffer[:4])
 
-	// Replace this loop with real benchmarking code
-	for i := 0; i < 1000; i++ {
-		// Simulate work by sleeping
-		time.Sleep(1 * time.Millisecond)
+	// Read the actual value
+	readBuffer := make([]byte, valueLength)
+	_, err = io.ReadFull(stream, readBuffer)
+	if err != nil {
+		return fmt.Errorf("failed to read value: %w", err)
 	}
+	fmt.Printf("Data read from server: %s\n", string(readBuffer))
 
-	// Measure memory usage after
+	// Capture memory usage after the operation
 	var memEnd runtime.MemStats
 	runtime.ReadMemStats(&memEnd)
 
+	// Calculate elapsed time
 	elapsed := time.Since(start)
-
-	// Output benchmarking results
 	fmt.Printf("Benchmark completed in %s\n", elapsed)
 	fmt.Printf("Memory used: %d bytes\n", memEnd.Alloc-memStart.Alloc)
-	log.Printf("Test completed.")
+
+	return nil
+}
+
+// createWriteMessage generates a random write message
+func createWriteMessage() fdb.Message {
+	var key [32]byte
+	rand.Read(key[:])
+	return fdb.Message{
+		Handler: fdb.WriteHandlerType,
+		Key:     key,
+		Data:    []byte("benchmark test data"),
+	}
+}
+
+// createReadMessage generates a read message for a given key
+func createReadMessage(key [32]byte) fdb.Message {
+	return fdb.Message{
+		Handler: fdb.ReadHandlerType,
+		Key:     key,
+	}
 }

pkg/config/config.go renamed to config/config.go

@@ -1,6 +1,6 @@
 package config
 
-import "github.com/unpackdev/fdb/pkg/types"
+import "github.com/unpackdev/fdb/types"
 
 type Config struct {
 	Transports []Transport `yaml:"transports"`

pkg/config/mdbx.go renamed to config/mdbx.go

@@ -1,6 +1,6 @@
 package config
 
-import "github.com/unpackdev/fdb/pkg/types"
+import "github.com/unpackdev/fdb/types"
 
 type TransportConfig interface {
 	GetTransportType() types.TransportType

pkg/config/transports.go renamed to config/transports.go

@@ -3,8 +3,8 @@ package fdb
 import (
 	"context"
 	"github.com/pkg/errors"
-	"github.com/unpackdev/fdb/pkg/config"
-	"github.com/unpackdev/fdb/pkg/types"
+	"github.com/unpackdev/fdb/config"
+	"github.com/unpackdev/fdb/types"
 )
 
 type FDB struct {

fdb.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"github.com/erigontech/mdbx-go/mdbx"
 	"github.com/pkg/errors"
-	"github.com/unpackdev/fdb/pkg/config"
+	"github.com/unpackdev/fdb/config"
 	"os"
 )
 

mdbx.go

@@ -3,7 +3,7 @@ package fdb
 import (
 	"context"
 	"fmt"
-	"github.com/unpackdev/fdb/pkg/config"
+	"github.com/unpackdev/fdb/config"
 )
 
 type Manager struct {

pkg/.gitkeep

@@ -2,7 +2,7 @@ package fdb
 
 import (
 	"errors"
-	"github.com/unpackdev/fdb/pkg/types"
+	"github.com/unpackdev/fdb/types"
 	"sync"
 )