@blinklabs/dingo 0.6.0

package/internal/config/config.go

@@ -0,0 +1,145 @@
+// Copyright 2024 Blink Labs Software
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package config
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/blinklabs-io/dingo/topology"
+	ouroboros "github.com/blinklabs-io/gouroboros"
+	"github.com/kelseyhightower/envconfig"
+	"gopkg.in/yaml.v3"
+)
+
+type ctxKey string
+
+const configContextKey ctxKey = "dingo.config"
+
+func WithContext(ctx context.Context, cfg *Config) context.Context {
+	return context.WithValue(ctx, configContextKey, cfg)
+}
+
+func FromContext(ctx context.Context) *Config {
+	cfg, ok := ctx.Value(configContextKey).(*Config)
+	if !ok {
+		return nil
+	}
+	return cfg
+}
+
+type Config struct {
+	BindAddr        string `yaml:"bindAddr"        split_words:"true"`
+	CardanoConfig   string `yaml:"cardanoConfig"                      envconfig:"config"`
+	DatabasePath    string `yaml:"databasePath"    split_words:"true"`
+	SocketPath      string `yaml:"socketPath"      split_words:"true"`
+	Network         string `yaml:"network"`
+	TlsCertFilePath string `yaml:"tlsCertFilePath"                    envconfig:"TLS_CERT_FILE_PATH"`
+	TlsKeyFilePath  string `yaml:"tlsKeyFilePath"                     envconfig:"TLS_KEY_FILE_PATH"`
+	Topology        string `yaml:"topology"`
+	MetricsPort     uint   `yaml:"metricsPort"     split_words:"true"`
+	PrivateBindAddr string `yaml:"privateBindAddr" split_words:"true"`
+	PrivatePort     uint   `yaml:"privatePort"     split_words:"true"`
+	RelayPort       uint   `yaml:"relayPort"                          envconfig:"port"`
+	UtxorpcPort     uint   `yaml:"utxorpcPort"     split_words:"true"`
+	IntersectTip    bool   `yaml:"intersectTip"    split_words:"true"`
+}
+
+var globalConfig = &Config{
+	BindAddr:        "0.0.0.0",
+	CardanoConfig:   "./config/cardano/preview/config.json",
+	DatabasePath:    ".dingo",
+	SocketPath:      "dingo.socket",
+	IntersectTip:    false,
+	Network:         "preview",
+	MetricsPort:     12798,
+	PrivateBindAddr: "127.0.0.1",
+	PrivatePort:     3002,
+	RelayPort:       3001,
+	UtxorpcPort:     9090,
+	Topology:        "",
+	TlsCertFilePath: "",
+	TlsKeyFilePath:  "",
+}
+
+func LoadConfig(configFile string) (*Config, error) {
+	// Load config file as YAML if provided
+	fmt.Println(configFile)
+	if configFile != "" {
+		fmt.Printf("Reading from config file %s\n", configFile)
+		buf, err := os.ReadFile(configFile)
+		if err != nil {
+			return nil, fmt.Errorf("error reading config file: %w", err)
+		}
+		err = yaml.Unmarshal(buf, globalConfig)
+		if err != nil {
+			return nil, fmt.Errorf("error parsing config file: %w", err)
+		}
+		fmt.Printf("Successfully loaded the config file %s\n", configFile)
+	}
+	err := envconfig.Process("cardano", globalConfig)
+	if err != nil {
+		return nil, fmt.Errorf("error processing environment: %+w", err)
+	}
+	_, err = LoadTopologyConfig()
+	if err != nil {
+		return nil, fmt.Errorf("error loading topology: %+w", err)
+	}
+	return globalConfig, nil
+}
+
+func GetConfig() *Config {
+	return globalConfig
+}
+
+var globalTopologyConfig = &topology.TopologyConfig{}
+
+func LoadTopologyConfig() (*topology.TopologyConfig, error) {
+	if globalConfig.Topology == "" {
+		// Use default bootstrap peers for specified network
+		network, ok := ouroboros.NetworkByName(globalConfig.Network)
+		if !ok {
+			return nil, fmt.Errorf("unknown network: %s", globalConfig.Network)
+		}
+		if len(network.BootstrapPeers) == 0 {
+			return nil, fmt.Errorf(
+				"no known bootstrap peers for network %s",
+				globalConfig.Network,
+			)
+		}
+		for _, peer := range network.BootstrapPeers {
+			globalTopologyConfig.BootstrapPeers = append(
+				globalTopologyConfig.BootstrapPeers,
+				topology.TopologyConfigP2PAccessPoint{
+					Address: peer.Address,
+					Port:    peer.Port,
+				},
+			)
+		}
+		return globalTopologyConfig, nil
+	}
+	tc, err := topology.NewTopologyConfigFromFile(globalConfig.Topology)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load topology file: %+w", err)
+	}
+	// update globalTopologyConfig
+	globalTopologyConfig = tc
+	return globalTopologyConfig, nil
+}
+
+func GetTopologyConfig() *topology.TopologyConfig {
+	return globalTopologyConfig
+}

package/internal/config/config_test.go

@@ -0,0 +1,118 @@
+package config
+
+import (
+	"os"
+	"reflect"
+	"testing"
+)
+
+func resetGlobalConfig() {
+	globalConfig = &Config{
+		BindAddr:        "0.0.0.0",
+		CardanoConfig:   "./config/cardano/preview/config.json",
+		DatabasePath:    ".dingo",
+		SocketPath:      "dingo.socket",
+		IntersectTip:    false,
+		Network:         "preview",
+		MetricsPort:     12798,
+		PrivateBindAddr: "127.0.0.1",
+		PrivatePort:     3002,
+		RelayPort:       3001,
+		UtxorpcPort:     9090,
+		Topology:        "",
+		TlsCertFilePath: "",
+		TlsKeyFilePath:  "",
+	}
+}
+
+func TestLoad_CompareFullStruct(t *testing.T) {
+	resetGlobalConfig()
+	yamlContent := `
+bindAddr: "127.0.0.1"
+cardanoConfig: "./cardano/preview/config.json"
+databasePath: ".dingo"
+socketPath: "env.socket"
+intersectTip: true
+network: "preview"
+metricsPort: 8088
+privateBindAddr: "127.0.0.1"
+privatePort: 8000
+relayPort: 4000
+utxorpcPort: 9940
+topology: ""
+tlsCertFilePath: "cert1.pem"
+tlsKeyFilePath: "key1.pem"
+`
+
+	tmpFile := "test-dingo.yaml"
+	err := os.WriteFile(tmpFile, []byte(yamlContent), 0644)
+	if err != nil {
+		t.Fatalf("failed to write config file: %v", err)
+	}
+	defer os.Remove(tmpFile)
+
+	expected := &Config{
+		BindAddr:        "127.0.0.1",
+		CardanoConfig:   "./cardano/preview/config.json",
+		DatabasePath:    ".dingo",
+		SocketPath:      "env.socket",
+		IntersectTip:    true,
+		Network:         "preview",
+		MetricsPort:     8088,
+		PrivateBindAddr: "127.0.0.1",
+		PrivatePort:     8000,
+		RelayPort:       4000,
+		UtxorpcPort:     9940,
+		Topology:        "",
+		TlsCertFilePath: "cert1.pem",
+		TlsKeyFilePath:  "key1.pem",
+	}
+
+	actual, err := LoadConfig(tmpFile)
+	if err != nil {
+		t.Fatalf("failed to load config: %v", err)
+	}
+
+	if !reflect.DeepEqual(actual, expected) {
+		t.Errorf(
+			"Loaded config does not match expected.\nActual: %+v\nExpected: %+v",
+			actual,
+			expected,
+		)
+	}
+}
+func TestLoad_WithoutConfigFile_UsesDefaults(t *testing.T) {
+	resetGlobalConfig()
+
+	// Without Config file
+	cfg, err := LoadConfig("")
+	if err != nil {
+		t.Fatalf("expected no error, got: %v", err)
+	}
+
+	// Expected is the original default values from globalConfig
+	expected := &Config{
+		BindAddr:        "0.0.0.0",
+		CardanoConfig:   "./config/cardano/preview/config.json",
+		DatabasePath:    ".dingo",
+		SocketPath:      "dingo.socket",
+		IntersectTip:    false,
+		Network:         "preview",
+		MetricsPort:     12798,
+		PrivateBindAddr: "127.0.0.1",
+		PrivatePort:     3002,
+		RelayPort:       3001,
+		UtxorpcPort:     9090,
+		Topology:        "",
+		TlsCertFilePath: "",
+		TlsKeyFilePath:  "",
+	}
+
+	if !reflect.DeepEqual(cfg, expected) {
+		t.Errorf(
+			"config mismatch without file:\nExpected: %+v\nGot:      %+v",
+			expected,
+			cfg,
+		)
+	}
+}

package/internal/node/load.go

@@ -0,0 +1,149 @@
+// Copyright 2025 Blink Labs Software
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package node
+
+import (
+	"fmt"
+	"log/slog"
+	"slices"
+	"time"
+
+	"github.com/blinklabs-io/dingo/config/cardano"
+	"github.com/blinklabs-io/dingo/database/immutable"
+	"github.com/blinklabs-io/dingo/event"
+	"github.com/blinklabs-io/dingo/internal/config"
+	"github.com/blinklabs-io/dingo/ledger"
+	gledger "github.com/blinklabs-io/gouroboros/ledger"
+)
+
+func Load(cfg *config.Config, logger *slog.Logger, immutableDir string) error {
+	var nodeCfg *cardano.CardanoNodeConfig
+	if cfg.CardanoConfig != "" {
+		tmpCfg, err := cardano.NewCardanoNodeConfigFromFile(cfg.CardanoConfig)
+		if err != nil {
+			return err
+		}
+		nodeCfg = tmpCfg
+		logger.Debug(
+			fmt.Sprintf(
+				"cardano network config: %+v",
+				nodeCfg,
+			),
+			"component", "node",
+		)
+	}
+	// Load state
+	eventBus := event.NewEventBus(nil)
+	ls, err := ledger.NewLedgerState(
+		ledger.LedgerStateConfig{
+			DataDir:           cfg.DatabasePath,
+			Logger:            logger,
+			CardanoNodeConfig: nodeCfg,
+			EventBus:          eventBus,
+		},
+	)
+	if err != nil {
+		return fmt.Errorf("failed to load state database: %w", err)
+	}
+	c := ls.Chain()
+	// Open immutable DB
+	immutable, err := immutable.New(immutableDir)
+	if err != nil {
+		return fmt.Errorf("failed to read immutable DB: %w", err)
+	}
+	// Record immutable DB tip
+	immutableTip, err := immutable.GetTip()
+	if err != nil {
+		return fmt.Errorf("failed to read immutable DB tip: %w", err)
+	}
+	// Copy all blocks
+	logger.Info("copying blocks from immutable DB")
+	chainTip := c.Tip()
+	iter, err := immutable.BlocksFromPoint(chainTip.Point)
+	if err != nil {
+		return fmt.Errorf("failed to get immutable DB iterator: %w", err)
+	}
+	var blocksCopied int
+	blockBatch := make([]gledger.Block, 0, 500)
+	for {
+		for {
+			next, err := iter.Next()
+			if err != nil {
+				return err
+			}
+			// No more blocks
+			if next == nil {
+				break
+			}
+			tmpBlock, err := gledger.NewBlockFromCbor(next.Type, next.Cbor)
+			if err != nil {
+				return err
+			}
+			// Skip first block when continuing a load operation
+			if blocksCopied == 0 &&
+				tmpBlock.SlotNumber() == chainTip.Point.Slot {
+				continue
+			}
+			blockBatch = append(blockBatch, tmpBlock)
+			if len(blockBatch) == cap(blockBatch) {
+				break
+			}
+		}
+		if len(blockBatch) == 0 {
+			break
+		}
+		// Add block batch to chain
+		if err := c.AddBlocks(blockBatch); err != nil {
+			logger.Error(
+				fmt.Sprintf(
+					"failed to import block: %s",
+					err,
+				),
+			)
+			return nil
+		}
+		blocksCopied += len(blockBatch)
+		blockBatch = slices.Delete(blockBatch, 0, len(blockBatch))
+		if blocksCopied > 0 && blocksCopied%10000 == 0 {
+			logger.Info(
+				fmt.Sprintf(
+					"copying blocks from immutable DB (%d blocks copied)",
+					blocksCopied,
+				),
+			)
+		}
+	}
+	logger.Info(
+		fmt.Sprintf(
+			"finished copying %d blocks from immutable DB",
+			blocksCopied,
+		),
+	)
+	// Wait for ledger to catch up
+	for {
+		time.Sleep(5 * time.Second)
+		tip := ls.Tip()
+		if tip.Point.Slot >= immutableTip.Slot {
+			break
+		}
+	}
+	logger.Info(
+		fmt.Sprintf(
+			"finished processing %d blocks from immutable DB",
+			blocksCopied,
+		),
+	)
+	return nil
+}

package/internal/node/node.go

@@ -0,0 +1,176 @@
+// Copyright 2025 Blink Labs Software
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package node
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"net/http"
+	_ "net/http/pprof" // #nosec G108
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/blinklabs-io/dingo"
+	"github.com/blinklabs-io/dingo/config/cardano"
+	"github.com/blinklabs-io/dingo/internal/config"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+func Run(cfg *config.Config, logger *slog.Logger) error {
+	logger.Debug(fmt.Sprintf("config: %+v", cfg), "component", "node")
+	logger.Debug(
+		fmt.Sprintf("topology: %+v", config.GetTopologyConfig()),
+		"component", "node",
+	)
+	// TODO: make this safer, check PID, create parent, etc. (#276)
+	if _, err := os.Stat(cfg.SocketPath); err == nil {
+		os.Remove(cfg.SocketPath)
+	}
+	var nodeCfg *cardano.CardanoNodeConfig
+	if cfg.CardanoConfig != "" {
+		tmpCfg, err := cardano.NewCardanoNodeConfigFromFile(cfg.CardanoConfig)
+		if err != nil {
+			return err
+		}
+		nodeCfg = tmpCfg
+		logger.Debug(
+			fmt.Sprintf(
+				"cardano network config: %+v",
+				nodeCfg,
+			),
+			"component", "node",
+		)
+	}
+	listeners := []dingo.ListenerConfig{}
+	if cfg.RelayPort > 0 {
+		// Public "relay" port (node-to-node)
+		listeners = append(
+			listeners,
+			dingo.ListenerConfig{
+				ListenNetwork: "tcp",
+				ListenAddress: fmt.Sprintf(
+					"%s:%d",
+					cfg.BindAddr,
+					cfg.RelayPort,
+				),
+				ReuseAddress: true,
+			},
+		)
+	}
+	if cfg.PrivatePort > 0 {
+		// Private TCP port (node-to-client)
+		listeners = append(
+			listeners,
+			dingo.ListenerConfig{
+				ListenNetwork: "tcp",
+				ListenAddress: fmt.Sprintf(
+					"%s:%d",
+					cfg.PrivateBindAddr,
+					cfg.PrivatePort,
+				),
+				UseNtC: true,
+			},
+		)
+	}
+	if cfg.SocketPath != "" {
+		// Private UNIX socket (node-to-client)
+		listeners = append(
+			listeners,
+			dingo.ListenerConfig{
+				ListenNetwork: "unix",
+				ListenAddress: cfg.SocketPath,
+				UseNtC:        true,
+			},
+		)
+	}
+	d, err := dingo.New(
+		dingo.NewConfig(
+			dingo.WithIntersectTip(cfg.IntersectTip),
+			dingo.WithLogger(logger),
+			dingo.WithDatabasePath(cfg.DatabasePath),
+			dingo.WithNetwork(cfg.Network),
+			dingo.WithCardanoNodeConfig(nodeCfg),
+			dingo.WithListeners(listeners...),
+			dingo.WithOutboundSourcePort(cfg.RelayPort),
+			dingo.WithUtxorpcPort(cfg.UtxorpcPort),
+			dingo.WithUtxorpcTlsCertFilePath(cfg.TlsCertFilePath),
+			dingo.WithUtxorpcTlsKeyFilePath(cfg.TlsKeyFilePath),
+			// Enable metrics with default prometheus registry
+			dingo.WithPrometheusRegistry(prometheus.DefaultRegisterer),
+			// TODO: make this configurable (#387)
+			// dingo.WithTracing(true),
+			dingo.WithTopologyConfig(config.GetTopologyConfig()),
+		),
+	)
+	if err != nil {
+		return err
+	}
+	// Metrics and debug listener
+	http.Handle("/metrics", promhttp.Handler())
+	logger.Info(
+		"serving prometheus metrics on "+fmt.Sprintf(
+			"%s:%d",
+			cfg.BindAddr,
+			cfg.MetricsPort,
+		),
+		"component",
+		"node",
+	)
+	go func() {
+		debugger := &http.Server{
+			Addr: fmt.Sprintf(
+				"%s:%d",
+				cfg.BindAddr,
+				cfg.MetricsPort,
+			),
+			ReadHeaderTimeout: 60 * time.Second,
+		}
+		if err := debugger.ListenAndServe(); err != nil {
+			logger.Error(
+				fmt.Sprintf("failed to start metrics listener: %s", err),
+				"component", "node",
+			)
+			os.Exit(1)
+		}
+	}()
+	// Wait for interrupt/termination signal
+	signalCtx, signalCtxStop := signal.NotifyContext(
+		context.Background(),
+		syscall.SIGINT,
+		syscall.SIGTERM,
+	)
+	defer signalCtxStop()
+	go func() {
+		<-signalCtx.Done()
+		logger.Info("signal received, shutting down")
+		if err := d.Stop(); err != nil { // nolint:contextcheck
+			logger.Error(
+				"failure(s) while shutting down",
+				"error",
+				err,
+			)
+		}
+		os.Exit(0)
+	}()
+	// Run node
+	if err := d.Run(); err != nil {
+		return err
+	}
+	return nil
+}

package/internal/version/version.go

@@ -0,0 +1,33 @@
+// Copyright 2024 Blink Labs Software
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package version
+
+import (
+	"fmt"
+)
+
+// These are populated at build time
+var (
+	Version    string
+	CommitHash string
+)
+
+func GetVersionString() string {
+	if Version != "" {
+		return fmt.Sprintf("%s (commit %s)", Version, CommitHash)
+	} else {
+		return fmt.Sprintf("devel (commit %s)", CommitHash)
+	}
+}