Entering broken phase - getting fdb() instance and config

Author: 0x19

cmd/benchmark.go

@@ -3,6 +3,8 @@ package cmd
 import (
 	"fmt"
 	"github.com/unpackdev/fdb"
+	"github.com/unpackdev/fdb/pkg/config"
+	"github.com/unpackdev/fdb/pkg/types"
 	"github.com/urfave/cli/v2"
 	"log"
 	"runtime"
@@ -18,7 +20,20 @@ func BenchmarkCommand() *cli.Command {
 			// Simulate benchmarking logic here
 			fmt.Println("Running client benchmark...")
 
-			cnf := fdb.Config{}
+			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 {

config.go

@@ -3,14 +3,15 @@ package fdb
 import (
 	"context"
 	"github.com/pkg/errors"
+	"github.com/unpackdev/fdb/pkg/config"
 )
 
 type FDB struct {
 	ctx    context.Context
-	config Config
+	config config.Config
 }
 
-func New(ctx context.Context, config Config) (*FDB, error) {
+func New(ctx context.Context, config config.Config) (*FDB, error) {
 	if err := config.Validate(); err != nil {
 		return nil, errors.Wrap(err, "failure to validate (f)db configuration")
 	}

fdb.go

@@ -4,17 +4,18 @@ import (
 	"context"
 	"github.com/erigontech/mdbx-go/mdbx"
 	"github.com/pkg/errors"
+	"github.com/unpackdev/fdb/pkg/config"
 	"os"
 )
 
 type Db struct {
 	ctx  context.Context
-	opts MdbxNode
+	opts config.MdbxNode
 	env  *mdbx.Env
 	dbi  mdbx.DBI
 }
 
-func NewDb(ctx context.Context, opts MdbxNode) (Provider, error) {
+func NewDb(ctx context.Context, opts config.MdbxNode) (Provider, error) {
 	env, err := mdbx.NewEnv()
 	if err != nil {
 		return nil, err

mdbx.go

@@ -0,0 +1,21 @@
+package config
+
+import "github.com/unpackdev/fdb/pkg/types"
+
+type Config struct {
+	Transports []Transport `yaml:"transports"`
+	MdbxNodes  MdbxNodes   `yaml:"nodes"`
+}
+
+func (c Config) Validate() error {
+	return nil
+}
+
+func (c Config) GetTransportByType(transportType types.TransportType) *Transport {
+	for _, t := range c.Transports {
+		if t.Type == transportType {
+			return &t
+		}
+	}
+	return nil
+}

pkg/config/config.go

@@ -0,0 +1,18 @@
+package config
+
+// MdbxNode and MdbxNodes as before
+type MdbxNode struct {
+	Name string `yaml:"name"`
+	Path string `yaml:"path"`
+}
+
+type MdbxNodes []MdbxNode
+
+func (c Config) GetMdbxNodeByName(name string) *MdbxNode {
+	for _, node := range c.MdbxNodes {
+		if node.Name == name {
+			return &node
+		}
+	}
+	return nil
+}

pkg/config/mdbx.go

@@ -0,0 +1,37 @@
+package config
+
+import "github.com/unpackdev/fdb/pkg/types"
+
+type TransportConfig interface {
+	GetTransportType() types.TransportType
+}
+
+type Transport struct {
+	Type    types.TransportType
+	Enabled bool
+	Config  TransportConfig
+}
+
+// QuicTransport implements TransportConfig
+type QuicTransport struct {
+	Type    types.TransportType `yaml:"type" json:"type" mapstructure:"type"`
+	Enabled bool                `yaml:"enabled" json:"enabled" mapstructure:"enabled"`
+	IPv4    string              `yaml:"ipv4" json:"ipv4" mapstructure:"ipv4"`
+	Port    int                 `yaml:"port" json:"port" mapstructure:"port"`
+}
+
+func (q QuicTransport) GetTransportType() types.TransportType {
+	return q.Type
+}
+
+// UdsTransport implements TransportConfig
+type UdsTransport struct {
+	Type    types.TransportType `yaml:"type" json:"type" mapstructure:"type"`
+	Enabled bool                `yaml:"enabled" json:"enabled" mapstructure:"enabled"`
+	IPv4    string              `yaml:"ipv4" json:"ipv4" mapstructure:"ipv4"`
+	Port    int                 `yaml:"port" json:"port" mapstructure:"port"`
+}
+
+func (u UdsTransport) GetTransportType() types.TransportType {
+	return u.Type
+}

pkg/config/transports.go

@@ -0,0 +1,44 @@
+package types
+
+import "fmt"
+
+type TransportType int
+
+const (
+	UDPTransportType TransportType = iota
+	QUICTransportType
+	UDSTransportType
+	TCPTransportType
+)
+
+type DbType string
+
+func (t DbType) String() string {
+	return string(t)
+}
+
+const (
+// To be defined for database types in the future...
+)
+
+// HandlerType represents different types of handlers
+type HandlerType byte
+
+// FromByte converts a byte into a HandlerType
+func (h *HandlerType) FromByte(b byte) error {
+	switch b {
+	case 'W':
+		*h = WriteHandlerType
+	case 'R':
+		*h = ReadHandlerType
+	default:
+		return fmt.Errorf("invalid action byte: %v", b)
+	}
+	return nil
+}
+
+// Define the handlers as 1-byte constants
+const (
+	WriteHandlerType HandlerType = 'W' // 'W' for WRITE
+	ReadHandlerType  HandlerType = 'R' // 'R' for READ
+)

pkg/types/types.go

@@ -3,15 +3,16 @@ package fdb
 import (
 	"context"
 	"fmt"
+	"github.com/unpackdev/fdb/pkg/config"
 )
 
 type Manager struct {
 	ctx  context.Context
-	opts MdbxNodes
+	opts config.MdbxNodes
 	dbs  map[DbType]Provider
 }
 
-func NewManager(ctx context.Context, opts MdbxNodes) (*Manager, error) {
+func NewManager(ctx context.Context, opts config.MdbxNodes) (*Manager, error) {
 	dbs := make(map[DbType]Provider)
 	for _, node := range opts {
 		db, err := NewDb(ctx, node)

provider_manager.go

@@ -15,6 +15,25 @@ import (
 // Handler function type for QUIC
 type QuicHandler func(sess quic.Connection, stream quic.Stream, message *Message)
 
+type QuicConfig struct {
+	Type    TransportType `yaml:"type" json:"type" mapstructure:"type"`
+	Enabled bool          `yaml:"enabled" json:"enabled" mapstructure:"enabled"`
+	IPv4    string        `yaml:"ipv4" json:"ipv4" mapstructure:"ipv4"`
+	Port    int           `yaml:"port" json:"port" mapstructure:"port"`
+}
+
+func (c QuicConfig) GetType() TransportType {
+	return c.Type
+}
+
+func (c QuicConfig) IsEnabled() bool {
+	return c.Enabled
+}
+
+func (c QuicConfig) IsIPv4() bool {
+	return c.IPv4 != ""
+}
+
 // QuicServer struct represents the QUIC server
 type QuicServer struct {
 	handlerRegistry map[HandlerType]QuicHandler