@blinklabs/dingo 0.6.0

package/peergov/peergov.go

@@ -0,0 +1,290 @@
+// 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 peergov
+
+import (
+	"fmt"
+	"io"
+	"log/slog"
+	"net"
+	"strconv"
+	"sync"
+	"time"
+
+	"github.com/blinklabs-io/dingo/connmanager"
+	"github.com/blinklabs-io/dingo/event"
+	"github.com/blinklabs-io/dingo/topology"
+	ouroboros "github.com/blinklabs-io/gouroboros"
+)
+
+const (
+	initialReconnectDelay  = 1 * time.Second
+	maxReconnectDelay      = 128 * time.Second
+	reconnectBackoffFactor = 2
+)
+
+type PeerGovernor struct {
+	mu     sync.Mutex
+	config PeerGovernorConfig
+	peers  []*Peer
+}
+
+type PeerGovernorConfig struct {
+	Logger      *slog.Logger
+	EventBus    *event.EventBus
+	ConnManager *connmanager.ConnectionManager
+}
+
+func NewPeerGovernor(cfg PeerGovernorConfig) *PeerGovernor {
+	if cfg.Logger == nil {
+		cfg.Logger = slog.New(slog.NewJSONHandler(io.Discard, nil))
+	}
+	cfg.Logger = cfg.Logger.With("component", "peergov")
+	return &PeerGovernor{
+		config: cfg,
+	}
+}
+
+func (p *PeerGovernor) Start() error {
+	// Setup connmanager event listeners
+	p.config.EventBus.SubscribeFunc(
+		connmanager.InboundConnectionEventType,
+		p.handleInboundConnectionEvent,
+	)
+	p.config.EventBus.SubscribeFunc(
+		connmanager.ConnectionClosedEventType,
+		p.handleConnectionClosedEvent,
+	)
+	// Start outbound connections
+	p.startOutboundConnections()
+	return nil
+}
+
+func (p *PeerGovernor) LoadTopologyConfig(
+	topologyConfig *topology.TopologyConfig,
+) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	// Remove peers originally sourced from the topology
+	tmpPeers := []*Peer{}
+	for _, tmpPeer := range p.peers {
+		if tmpPeer.Source == PeerSourceTopologyBootstrapPeer ||
+			tmpPeer.Source == PeerSourceTopologyLocalRoot ||
+			tmpPeer.Source == PeerSourceTopologyPublicRoot {
+			continue
+		}
+		tmpPeers = append(tmpPeers, tmpPeer)
+	}
+	p.peers = tmpPeers
+	// Add topology bootstrap peers
+	for _, bootstrapPeer := range topologyConfig.BootstrapPeers {
+		tmpAddress := net.JoinHostPort(
+			bootstrapPeer.Address,
+			strconv.FormatUint(uint64(bootstrapPeer.Port), 10),
+		)
+		p.peers = append(
+			p.peers,
+			&Peer{
+				Address: tmpAddress,
+				Source:  PeerSourceTopologyBootstrapPeer,
+			},
+		)
+	}
+	// Add topology local roots
+	for _, localRoot := range topologyConfig.LocalRoots {
+		for _, ap := range localRoot.AccessPoints {
+			tmpAddress := net.JoinHostPort(
+				ap.Address,
+				strconv.FormatUint(uint64(ap.Port), 10),
+			)
+			tmpPeer := &Peer{
+				Address:  tmpAddress,
+				Source:   PeerSourceTopologyLocalRoot,
+				Sharable: localRoot.Advertise,
+			}
+			for i, peer := range p.peers {
+				// This peer already appears, remove it
+				if peer.Address == tmpAddress {
+					copy(p.peers[i:], p.peers[i+1:])   // shift left
+					p.peers[len(p.peers)-1] = nil      // clear last
+					p.peers = p.peers[:len(p.peers)-1] // truncate
+				}
+			}
+			p.peers = append(p.peers, tmpPeer)
+		}
+	}
+	// Add topology public roots
+	for _, publicRoot := range topologyConfig.PublicRoots {
+		for _, ap := range publicRoot.AccessPoints {
+			tmpAddress := net.JoinHostPort(
+				ap.Address,
+				strconv.FormatUint(uint64(ap.Port), 10),
+			)
+			tmpPeer := &Peer{
+				Address:  tmpAddress,
+				Source:   PeerSourceTopologyPublicRoot,
+				Sharable: publicRoot.Advertise,
+			}
+			for i, peer := range p.peers {
+				// This peer already appears, remove it
+				if peer.Address == tmpAddress {
+					copy(p.peers[i:], p.peers[i+1:])   // shift left
+					p.peers[len(p.peers)-1] = nil      // clear last
+					p.peers = p.peers[:len(p.peers)-1] // truncate
+				}
+			}
+			p.peers = append(p.peers, tmpPeer)
+		}
+	}
+}
+
+func (p *PeerGovernor) GetPeers() []Peer {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	ret := make([]Peer, len(p.peers))
+	for idx, peer := range p.peers {
+		ret[idx] = *peer
+	}
+	return ret
+}
+
+func (p *PeerGovernor) peerIndexByAddress(address string) int {
+	for idx, tmpPeer := range p.peers {
+		if tmpPeer.Address == address {
+			return idx
+		}
+	}
+	return -1
+}
+
+func (p *PeerGovernor) peerIndexByConnId(connId ouroboros.ConnectionId) int {
+	for idx, tmpPeer := range p.peers {
+		if tmpPeer.Connection == nil {
+			continue
+		}
+		if tmpPeer.Connection.Id == connId {
+			return idx
+		}
+	}
+	return -1
+}
+
+func (p *PeerGovernor) startOutboundConnections() {
+	p.config.Logger.Debug(
+		"starting connections",
+		"role", "client",
+	)
+	for _, tmpPeer := range p.peers {
+		go p.createOutboundConnection(tmpPeer)
+	}
+}
+
+func (p *PeerGovernor) createOutboundConnection(peer *Peer) {
+	for {
+		conn, err := p.config.ConnManager.CreateOutboundConn(peer.Address)
+		if err == nil {
+			connId := conn.Id()
+			peer.ReconnectCount = 0
+			peer.setConnection(conn, true)
+			// Generate event
+			if p.config.EventBus != nil {
+				p.config.EventBus.Publish(
+					OutboundConnectionEventType,
+					event.NewEvent(
+						OutboundConnectionEventType,
+						OutboundConnectionEvent{
+							ConnectionId: connId,
+						},
+					),
+				)
+			}
+			return
+		}
+		p.config.Logger.Error(
+			fmt.Sprintf(
+				"outbound: failed to establish connection to %s: %s",
+				peer.Address,
+				err,
+			),
+		)
+		if peer.ReconnectDelay == 0 {
+			peer.ReconnectDelay = initialReconnectDelay
+		} else if peer.ReconnectDelay < maxReconnectDelay {
+			peer.ReconnectDelay = peer.ReconnectDelay * reconnectBackoffFactor
+		}
+		peer.ReconnectCount += 1
+		p.config.Logger.Info(
+			fmt.Sprintf(
+				"outbound: delaying %s (retry %d) before reconnecting to %s",
+				peer.ReconnectDelay,
+				peer.ReconnectCount,
+				peer.Address,
+			),
+		)
+		time.Sleep(peer.ReconnectDelay)
+	}
+}
+
+func (p *PeerGovernor) handleInboundConnectionEvent(evt event.Event) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	e := evt.Data.(connmanager.InboundConnectionEvent)
+	var tmpPeer *Peer
+	peerIdx := p.peerIndexByAddress(e.RemoteAddr.String())
+	if peerIdx == -1 {
+		tmpPeer = &Peer{
+			Address: e.RemoteAddr.String(),
+			Source:  PeerSourceInboundConn,
+		}
+		// Add inbound peer
+		p.peers = append(
+			p.peers,
+			tmpPeer,
+		)
+	} else {
+		tmpPeer = p.peers[peerIdx]
+	}
+	conn := p.config.ConnManager.GetConnectionById(e.ConnectionId)
+	tmpPeer.setConnection(conn, false)
+	if tmpPeer.Connection != nil {
+		tmpPeer.Sharable = tmpPeer.Connection.VersionData.PeerSharing()
+	}
+}
+
+func (p *PeerGovernor) handleConnectionClosedEvent(evt event.Event) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	e := evt.Data.(connmanager.ConnectionClosedEvent)
+	if e.Error != nil {
+		p.config.Logger.Error(
+			fmt.Sprintf(
+				"unexpected connection failure: %s",
+				e.Error,
+			),
+			"connection_id", e.ConnectionId.String(),
+		)
+	} else {
+		p.config.Logger.Info("connection closed",
+			"connection_id", e.ConnectionId.String(),
+		)
+	}
+	peerIdx := p.peerIndexByConnId(e.ConnectionId)
+	if peerIdx != -1 {
+		p.peers[peerIdx].Connection = nil
+		if p.peers[peerIdx].Source != PeerSourceInboundConn {
+			go p.createOutboundConnection(p.peers[peerIdx])
+		}
+	}
+}

package/peersharing.go

@@ -0,0 +1,70 @@
+// 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 dingo
+
+import (
+	"net"
+	"strconv"
+
+	opeersharing "github.com/blinklabs-io/gouroboros/protocol/peersharing"
+)
+
+func (n *Node) peersharingServerConnOpts() []opeersharing.PeerSharingOptionFunc {
+	return []opeersharing.PeerSharingOptionFunc{
+		opeersharing.WithShareRequestFunc(n.peersharingShareRequest),
+	}
+}
+
+func (n *Node) peersharingClientConnOpts() []opeersharing.PeerSharingOptionFunc {
+	// We don't provide any client options, but we have this here for consistency
+	return []opeersharing.PeerSharingOptionFunc{}
+}
+
+func (n *Node) peersharingShareRequest(
+	ctx opeersharing.CallbackContext,
+	amount int,
+) ([]opeersharing.PeerAddress, error) {
+	peers := []opeersharing.PeerAddress{}
+	var cnt int
+	for _, peer := range n.peerGov.GetPeers() {
+		cnt++
+		if cnt > amount {
+			break
+		}
+		if peer.Sharable {
+			host, port, err := net.SplitHostPort(peer.Address)
+			if err != nil {
+				// Skip on error
+				n.config.logger.Debug("failed to split peer address, skipping")
+				continue
+			}
+			portNum, err := strconv.ParseUint(port, 10, 16)
+			if err != nil {
+				// Skip on error
+				n.config.logger.Debug("failed to parse peer port, skipping")
+				continue
+			}
+			n.config.logger.Debug(
+				"adding peer for sharing: " + peer.Address,
+			)
+			peers = append(peers, opeersharing.PeerAddress{
+				IP:   net.ParseIP(host),
+				Port: uint16(portNum),
+			},
+			)
+		}
+	}
+	return peers, nil
+}

package/preview-local-topology.json

@@ -0,0 +1,23 @@
+{
+  "bootstrapPeers": [
+    {
+      "address": "192.168.4.56",
+      "port": 3001
+    }
+  ],
+  "localRoots": [
+    {
+      "accessPoints": [],
+      "advertise": false,
+      "trustable": false,
+      "valency": 1
+    }
+  ],
+  "publicRoots": [
+    {
+      "accessPoints": [],
+      "advertise": false
+    }
+  ],
+  "useLedgerAfterSlot": 53827185
+}

package/topology/topology.go

@@ -0,0 +1,69 @@
+// 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 topology
+
+import (
+	"encoding/json"
+	"io"
+	"os"
+)
+
+// TopologyConfig represents a cardano-node topology config
+type TopologyConfig struct {
+	LocalRoots         []TopologyConfigP2PLocalRoot     `json:"localRoots"`
+	PublicRoots        []TopologyConfigP2PPublicRoot    `json:"publicRoots"`
+	BootstrapPeers     []TopologyConfigP2PBootstrapPeer `json:"bootstrapPeers"`
+	UseLedgerAfterSlot int64                            `json:"useLedgerAfterSlot"`
+}
+
+type TopologyConfigP2PAccessPoint struct {
+	Address string `json:"address"`
+	Port    uint   `json:"port"`
+}
+
+type TopologyConfigP2PLocalRoot struct {
+	AccessPoints []TopologyConfigP2PAccessPoint `json:"accessPoints"`
+	Advertise    bool                           `json:"advertise"`
+	Trustable    bool                           `json:"trustable"`
+	Valency      uint                           `json:"valency"`
+}
+
+type TopologyConfigP2PPublicRoot struct {
+	AccessPoints []TopologyConfigP2PAccessPoint `json:"accessPoints"`
+	Advertise    bool                           `json:"advertise"`
+	Valency      uint                           `json:"valency"`
+}
+
+type TopologyConfigP2PBootstrapPeer = TopologyConfigP2PAccessPoint
+
+func NewTopologyConfigFromFile(path string) (*TopologyConfig, error) {
+	dataFile, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	return NewTopologyConfigFromReader(dataFile)
+}
+
+func NewTopologyConfigFromReader(r io.Reader) (*TopologyConfig, error) {
+	t := &TopologyConfig{}
+	data, err := io.ReadAll(r)
+	if err != nil {
+		return nil, err
+	}
+	if err := json.Unmarshal(data, t); err != nil {
+		return nil, err
+	}
+	return t, nil
+}

package/topology/topology_test.go

@@ -0,0 +1,179 @@
+// 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 topology_test
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/blinklabs-io/dingo/topology"
+)
+
+type topologyTestDefinition struct {
+	jsonData       string
+	expectedObject *topology.TopologyConfig
+}
+
+var topologyTests = []topologyTestDefinition{
+	{
+		jsonData: `
+{
+  "localRoots": [
+    {
+      "accessPoints": [],
+      "advertise": false,
+      "valency": 1
+    }
+  ],
+  "publicRoots": [
+    {
+      "accessPoints": [
+        {
+          "address": "backbone.cardano.iog.io",
+          "port": 3001
+        }
+      ],
+      "advertise": false
+    },
+    {
+      "accessPoints": [
+        {
+          "address": "backbone.mainnet.emurgornd.com",
+          "port": 3001
+        }
+      ],
+      "advertise": false
+    }
+  ],
+  "useLedgerAfterSlot": 99532743
+}
+`,
+		expectedObject: &topology.TopologyConfig{
+			LocalRoots: []topology.TopologyConfigP2PLocalRoot{
+				{
+					AccessPoints: []topology.TopologyConfigP2PAccessPoint{},
+					Advertise:    false,
+					Valency:      1,
+				},
+			},
+			PublicRoots: []topology.TopologyConfigP2PPublicRoot{
+				{
+					AccessPoints: []topology.TopologyConfigP2PAccessPoint{
+						{
+							Address: "backbone.cardano.iog.io",
+							Port:    3001,
+						},
+					},
+					Advertise: false,
+				},
+				{
+					AccessPoints: []topology.TopologyConfigP2PAccessPoint{
+						{
+							Address: "backbone.mainnet.emurgornd.com",
+							Port:    3001,
+						},
+					},
+					Advertise: false,
+				},
+			},
+			UseLedgerAfterSlot: 99532743,
+		},
+	},
+	{
+		jsonData: `
+{
+  "bootstrapPeers": [
+    {
+      "address": "backbone.cardano.iog.io",
+      "port": 3001
+    },
+    {
+      "address": "backbone.mainnet.emurgornd.com",
+      "port": 3001
+    },
+    {
+      "address": "backbone.mainnet.cardanofoundation.org",
+      "port": 3001
+    }
+  ],
+  "localRoots": [
+    {
+      "accessPoints": [],
+      "advertise": false,
+      "trustable": false,
+      "valency": 1
+    }
+  ],
+  "publicRoots": [
+    {
+      "accessPoints": [],
+      "advertise": false
+    }
+  ],
+  "useLedgerAfterSlot": 128908821
+}
+`,
+		expectedObject: &topology.TopologyConfig{
+			LocalRoots: []topology.TopologyConfigP2PLocalRoot{
+				{
+					AccessPoints: []topology.TopologyConfigP2PAccessPoint{},
+					Advertise:    false,
+					Trustable:    false,
+					Valency:      1,
+				},
+			},
+			PublicRoots: []topology.TopologyConfigP2PPublicRoot{
+				{
+					AccessPoints: []topology.TopologyConfigP2PAccessPoint{},
+					Advertise:    false,
+				},
+			},
+			BootstrapPeers: []topology.TopologyConfigP2PBootstrapPeer{
+				{
+					Address: "backbone.cardano.iog.io",
+					Port:    3001,
+				},
+				{
+					Address: "backbone.mainnet.emurgornd.com",
+					Port:    3001,
+				},
+				{
+					Address: "backbone.mainnet.cardanofoundation.org",
+					Port:    3001,
+				},
+			},
+			UseLedgerAfterSlot: 128908821,
+		},
+	},
+}
+
+func TestParseTopologyConfig(t *testing.T) {
+	for _, test := range topologyTests {
+		topology, err := topology.NewTopologyConfigFromReader(
+			strings.NewReader(test.jsonData),
+		)
+		if err != nil {
+			t.Fatalf("failed to load TopologyConfig from JSON data: %s", err)
+		}
+		if !reflect.DeepEqual(topology, test.expectedObject) {
+			t.Fatalf(
+				"did not get expected object\n  got:\n    %#v\n  wanted:\n    %#v",
+				topology,
+				test.expectedObject,
+			)
+		}
+	}
+}

package/tracing.go

@@ -0,0 +1,65 @@
+// 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 dingo
+
+import (
+	"context"
+	"log/slog"
+
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
+	"go.opentelemetry.io/otel/exporters/stdout/stdouttrace"
+	"go.opentelemetry.io/otel/propagation"
+	"go.opentelemetry.io/otel/sdk/trace"
+)
+
+func (n *Node) setupTracing() error {
+	// Set up propagator.
+	otel.SetTextMapPropagator(
+		propagation.NewCompositeTextMapPropagator(
+			propagation.TraceContext{},
+			propagation.Baggage{},
+		),
+	)
+
+	// Set up trace provider.
+	var traceExporter trace.SpanExporter
+	var err error
+	if n.config.tracingStdout {
+		traceExporter, err = stdouttrace.New(
+			stdouttrace.WithPrettyPrint(),
+		)
+	} else {
+		// TODO: make options configurable (#387)
+		traceExporter, err = otlptracehttp.New(context.TODO())
+	}
+	if err != nil {
+		return err
+	}
+	tracerProvider := trace.NewTracerProvider(
+		trace.WithBatcher(traceExporter),
+	)
+	n.shutdownFuncs = append(n.shutdownFuncs, tracerProvider.Shutdown)
+	otel.SetTracerProvider(tracerProvider)
+	otel.SetErrorHandler(
+		otel.ErrorHandlerFunc(
+			func(err error) {
+				slog.Error(err.Error())
+			},
+		),
+	)
+
+	return nil
+}