@blinklabs/dingo 0.6.0 → 0.8.0

package/connmanager/connection_manager.go

@@ -1,105 +0,0 @@
-// 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 connmanager
-
-import (
-	"io"
-	"log/slog"
-	"sync"
-
-	"github.com/blinklabs-io/dingo/event"
-	ouroboros "github.com/blinklabs-io/gouroboros"
-)
-
-// ConnectionManagerConnClosedFunc is a function that takes a connection ID and an optional error
-type ConnectionManagerConnClosedFunc func(ouroboros.ConnectionId, error)
-
-type ConnectionManager struct {
-	config           ConnectionManagerConfig
-	connections      map[ouroboros.ConnectionId]*ouroboros.Connection
-	connectionsMutex sync.Mutex
-}
-
-type ConnectionManagerConfig struct {
-	Logger             *slog.Logger
-	EventBus           *event.EventBus
-	ConnClosedFunc     ConnectionManagerConnClosedFunc
-	Listeners          []ListenerConfig
-	OutboundConnOpts   []ouroboros.ConnectionOptionFunc
-	OutboundSourcePort uint
-}
-
-func NewConnectionManager(cfg ConnectionManagerConfig) *ConnectionManager {
-	if cfg.Logger == nil {
-		cfg.Logger = slog.New(slog.NewJSONHandler(io.Discard, nil))
-	}
-	cfg.Logger = cfg.Logger.With("component", "connmanager")
-	return &ConnectionManager{
-		config: cfg,
-		connections: make(
-			map[ouroboros.ConnectionId]*ouroboros.Connection,
-		),
-	}
-}
-
-func (c *ConnectionManager) Start() error {
-	if err := c.startListeners(); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (c *ConnectionManager) AddConnection(conn *ouroboros.Connection) {
-	connId := conn.Id()
-	c.connectionsMutex.Lock()
-	c.connections[connId] = conn
-	c.connectionsMutex.Unlock()
-	go func() {
-		err := <-conn.ErrorChan()
-		// Remove connection
-		c.RemoveConnection(connId)
-		// Generate event
-		if c.config.EventBus != nil {
-			c.config.EventBus.Publish(
-				ConnectionClosedEventType,
-				event.NewEvent(
-					ConnectionClosedEventType,
-					ConnectionClosedEvent{
-						ConnectionId: connId,
-						Error:        err,
-					},
-				),
-			)
-		}
-		// Call configured connection closed callback func
-		if c.config.ConnClosedFunc != nil {
-			c.config.ConnClosedFunc(connId, err)
-		}
-	}()
-}
-
-func (c *ConnectionManager) RemoveConnection(connId ouroboros.ConnectionId) {
-	c.connectionsMutex.Lock()
-	delete(c.connections, connId)
-	c.connectionsMutex.Unlock()
-}
-
-func (c *ConnectionManager) GetConnectionById(
-	connId ouroboros.ConnectionId,
-) *ouroboros.Connection {
-	c.connectionsMutex.Lock()
-	defer c.connectionsMutex.Unlock()
-	return c.connections[connId]
-}

package/connmanager/connection_manager_test.go

@@ -1,185 +0,0 @@
-// 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 connmanager_test
-
-import (
-	"errors"
-	"io"
-	"testing"
-	"time"
-
-	"github.com/blinklabs-io/dingo/connmanager"
-
-	ouroboros "github.com/blinklabs-io/gouroboros"
-	"github.com/blinklabs-io/gouroboros/protocol/keepalive"
-	ouroboros_mock "github.com/blinklabs-io/ouroboros-mock"
-	"go.uber.org/goleak"
-)
-
-/*
-func TestConnectionManagerTagString(t *testing.T) {
-	testDefs := map[connmanager.ConnectionManagerTag]string{
-		connmanager.ConnectionManagerTagHostP2PLedger: "HostP2PLedger",
-		connmanager.ConnectionManagerTagHostP2PGossip: "HostP2PGossip",
-		connmanager.ConnectionManagerTagRoleInitiator: "RoleInitiator",
-		connmanager.ConnectionManagerTagRoleResponder: "RoleResponder",
-		connmanager.ConnectionManagerTagNone:          "Unknown",
-		connmanager.ConnectionManagerTag(9999):        "Unknown",
-	}
-	for k, v := range testDefs {
-		if k.String() != v {
-			t.Fatalf(
-				"did not get expected string for ID %d: got %s, expected %s",
-				k,
-				k.String(),
-				v,
-			)
-		}
-	}
-}
-*/
-
-func TestConnectionManagerConnError(t *testing.T) {
-	defer goleak.VerifyNone(t)
-	var expectedConnId ouroboros.ConnectionId
-	expectedErr := io.EOF
-	doneChan := make(chan any)
-	connManager := connmanager.NewConnectionManager(
-		connmanager.ConnectionManagerConfig{
-			ConnClosedFunc: func(connId ouroboros.ConnectionId, err error) {
-				if err != nil {
-					if connId != expectedConnId {
-						t.Fatalf(
-							"did not receive error from expected connection: got %d, wanted %d",
-							connId,
-							expectedConnId,
-						)
-					}
-					if !errors.Is(err, expectedErr) {
-						t.Fatalf(
-							"did not receive expected error: got: %s, expected: %s",
-							err,
-							expectedErr,
-						)
-					}
-					close(doneChan)
-				}
-			},
-		},
-	)
-	testIdx := 2
-	var connIds []ouroboros.ConnectionId
-	for i := 0; i < 3; i++ {
-		mockConversation := ouroboros_mock.ConversationKeepAlive
-		if i == testIdx {
-			mockConversation = ouroboros_mock.ConversationKeepAliveClose
-		}
-		mockConn := ouroboros_mock.NewConnection(
-			ouroboros_mock.ProtocolRoleClient,
-			mockConversation,
-		)
-		oConn, err := ouroboros.New(
-			ouroboros.WithConnection(mockConn),
-			ouroboros.WithNetworkMagic(ouroboros_mock.MockNetworkMagic),
-			ouroboros.WithNodeToNode(true),
-			ouroboros.WithKeepAlive(true),
-			ouroboros.WithKeepAliveConfig(
-				keepalive.NewConfig(
-					keepalive.WithCookie(ouroboros_mock.MockKeepAliveCookie),
-					keepalive.WithPeriod(2*time.Second),
-					keepalive.WithTimeout(1*time.Second),
-				),
-			),
-		)
-		if err != nil {
-			t.Fatalf("unexpected error when creating Ouroboros object: %s", err)
-		}
-		if i == testIdx {
-			expectedConnId = oConn.Id()
-		}
-		connManager.AddConnection(oConn)
-		connIds = append(connIds, oConn.Id())
-	}
-	select {
-	case <-doneChan:
-		// Shutdown other connections
-		for _, connId := range connIds {
-			if connId != expectedConnId {
-				tmpConn := connManager.GetConnectionById(connId)
-				tmpConn.Close()
-			}
-		}
-		// TODO: actually wait for shutdown
-		time.Sleep(5 * time.Second)
-		return
-	case <-time.After(10 * time.Second):
-		t.Fatalf("did not receive error within timeout")
-	}
-}
-
-func TestConnectionManagerConnClosed(t *testing.T) {
-	defer goleak.VerifyNone(t)
-	var expectedConnId ouroboros.ConnectionId
-	doneChan := make(chan any)
-	connManager := connmanager.NewConnectionManager(
-		connmanager.ConnectionManagerConfig{
-			ConnClosedFunc: func(connId ouroboros.ConnectionId, err error) {
-				if connId != expectedConnId {
-					t.Fatalf(
-						"did not receive closed signal from expected connection: got %d, wanted %d",
-						connId,
-						expectedConnId,
-					)
-				}
-				if err != nil {
-					t.Fatalf("received unexpected error: %s", err)
-				}
-				close(doneChan)
-			},
-		},
-	)
-	mockConn := ouroboros_mock.NewConnection(
-		ouroboros_mock.ProtocolRoleClient,
-		[]ouroboros_mock.ConversationEntry{
-			ouroboros_mock.ConversationEntryHandshakeRequestGeneric,
-			ouroboros_mock.ConversationEntryHandshakeNtNResponse,
-		},
-	)
-	oConn, err := ouroboros.New(
-		ouroboros.WithConnection(mockConn),
-		ouroboros.WithNetworkMagic(ouroboros_mock.MockNetworkMagic),
-		ouroboros.WithNodeToNode(true),
-		ouroboros.WithKeepAlive(false),
-	)
-	if err != nil {
-		t.Fatalf("unexpected error when creating Ouroboros object: %s", err)
-	}
-	expectedConnId = oConn.Id()
-	connManager.AddConnection(oConn)
-	time.AfterFunc(
-		1*time.Second,
-		func() {
-			oConn.Close()
-		},
-	)
-	select {
-	case <-doneChan:
-		// TODO: actually wait for shutdown
-		time.Sleep(5 * time.Second)
-		return
-	case <-time.After(10 * time.Second):
-		t.Fatalf("did not receive error within timeout")
-	}
-}

package/connmanager/event.go

@@ -1,37 +0,0 @@
-// 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 connmanager
-
-import (
-	"net"
-
-	ouroboros "github.com/blinklabs-io/gouroboros"
-)
-
-const (
-	InboundConnectionEventType = "connmanager.inbound-conn"
-	ConnectionClosedEventType  = "connmanager.conn-closed"
-)
-
-type InboundConnectionEvent struct {
-	ConnectionId ouroboros.ConnectionId
-	LocalAddr    net.Addr
-	RemoteAddr   net.Addr
-}
-
-type ConnectionClosedEvent struct {
-	ConnectionId ouroboros.ConnectionId
-	Error        error
-}

package/connmanager/listener.go

@@ -1,140 +0,0 @@
-// 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 connmanager
-
-import (
-	"context"
-	"fmt"
-	"net"
-
-	"github.com/blinklabs-io/dingo/event"
-	ouroboros "github.com/blinklabs-io/gouroboros"
-)
-
-type ListenerConfig struct {
-	UseNtC         bool
-	Listener       net.Listener
-	ListenNetwork  string
-	ListenAddress  string
-	ReuseAddress   bool
-	ConnectionOpts []ouroboros.ConnectionOptionFunc
-}
-
-func (c *ConnectionManager) startListeners() error {
-	for _, l := range c.config.Listeners {
-		if err := c.startListener(l); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (c *ConnectionManager) startListener(l ListenerConfig) error {
-	// Create listener if none is provided
-	if l.Listener == nil {
-		listenConfig := net.ListenConfig{}
-		if l.ReuseAddress {
-			listenConfig.Control = socketControl
-		}
-		listener, err := listenConfig.Listen(
-			context.Background(),
-			l.ListenNetwork,
-			l.ListenAddress,
-		)
-		if err != nil {
-			return fmt.Errorf("failed to open listening socket: %w", err)
-		}
-		l.Listener = listener
-		if l.UseNtC {
-			c.config.Logger.Info(
-				"listening for ouroboros node-to-client connections on " + l.ListenAddress,
-			)
-		} else {
-			c.config.Logger.Info(
-				"listening for ouroboros node-to-node connections on " + l.ListenAddress,
-			)
-		}
-	}
-	// Build connection options
-	defaultConnOpts := []ouroboros.ConnectionOptionFunc{
-		ouroboros.WithLogger(c.config.Logger),
-		ouroboros.WithNodeToNode(!l.UseNtC),
-		ouroboros.WithServer(true),
-	}
-	defaultConnOpts = append(
-		defaultConnOpts,
-		l.ConnectionOpts...,
-	)
-	go func() {
-		for {
-			// Accept connection
-			conn, err := l.Listener.Accept()
-			if err != nil {
-				c.config.Logger.Error(
-					fmt.Sprintf("listener: accept failed: %s", err),
-				)
-				continue
-			}
-			// Wrap UNIX connections
-			if uConn, ok := conn.(*net.UnixConn); ok {
-				tmpConn, err := NewUnixConn(uConn)
-				if err != nil {
-					c.config.Logger.Error(
-						fmt.Sprintf("listener: accept failed: %s", err),
-					)
-					_ = conn.Close()
-					continue
-				}
-				conn = tmpConn
-			}
-			c.config.Logger.Info(
-				fmt.Sprintf(
-					"listener: accepted connection from %s",
-					conn.RemoteAddr(),
-				),
-			)
-			// Setup Ouroboros connection
-			connOpts := append(
-				defaultConnOpts,
-				ouroboros.WithConnection(conn),
-			)
-			oConn, err := ouroboros.NewConnection(connOpts...)
-			if err != nil {
-				c.config.Logger.Error(
-					fmt.Sprintf(
-						"listener: failed to setup connection: %s",
-						err,
-					),
-				)
-				continue
-			}
-			// Add to connection manager
-			c.AddConnection(oConn)
-			// Generate event
-			c.config.EventBus.Publish(
-				InboundConnectionEventType,
-				event.NewEvent(
-					InboundConnectionEventType,
-					InboundConnectionEvent{
-						ConnectionId: oConn.Id(),
-						LocalAddr:    conn.LocalAddr(),
-						RemoteAddr:   conn.RemoteAddr(),
-					},
-				),
-			)
-		}
-	}()
-	return nil
-}

package/connmanager/outbound.go

@@ -1,93 +0,0 @@
-// 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 connmanager
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"time"
-
-	ouroboros "github.com/blinklabs-io/gouroboros"
-	"go.opentelemetry.io/otel"
-	"go.opentelemetry.io/otel/attribute"
-)
-
-func (c *ConnectionManager) CreateOutboundConn(
-	address string,
-) (*ouroboros.Connection, error) {
-	t := otel.Tracer("")
-	if t != nil {
-		_, span := t.Start(context.TODO(), "create outbound connection")
-		defer span.End()
-		span.SetAttributes(
-			attribute.String("peer.address", address),
-		)
-	}
-
-	var clientAddr net.Addr
-	dialer := net.Dialer{
-		Timeout: 10 * time.Second,
-	}
-	if c.config.OutboundSourcePort > 0 {
-		// Setup connection to use our listening port as the source port
-		// This is required for peer sharing to be useful
-		clientAddr, _ = net.ResolveTCPAddr(
-			"tcp",
-			fmt.Sprintf(":%d", c.config.OutboundSourcePort),
-		)
-		dialer.LocalAddr = clientAddr
-		dialer.Control = socketControl
-	}
-	c.config.Logger.Debug(
-		"establishing TCP connection to: "+address,
-		"role", "client",
-	)
-	tmpConn, err := dialer.Dial("tcp", address)
-	if err != nil {
-		return nil, err
-	}
-	// Build connection options
-	connOpts := []ouroboros.ConnectionOptionFunc{
-		ouroboros.WithConnection(tmpConn),
-		ouroboros.WithLogger(c.config.Logger),
-	}
-	connOpts = append(
-		connOpts,
-		c.config.OutboundConnOpts...,
-	)
-	// Setup Ouroboros connection
-	c.config.Logger.Debug(
-		"establishing ouroboros protocol to "+address,
-		"role", "client",
-	)
-	oConn, err := ouroboros.NewConnection(
-		connOpts...,
-	)
-	if err != nil {
-		return nil, err
-	}
-	c.config.Logger.Info(
-		"connected ouroboros to "+address,
-		"role", "client",
-	)
-	c.config.Logger.Debug(
-		"peer address mapping: address: "+address,
-		"role", "client",
-		"connection_id", oConn.Id().String(),
-	)
-	c.AddConnection(oConn)
-	return oConn, nil
-}

package/connmanager/socket.go

@@ -1,55 +0,0 @@
-// 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 connmanager
-
-import (
-	"syscall"
-
-	"golang.org/x/sys/unix"
-)
-
-// socketControl is a helper function for setting socket options on outbound and listener sockets
-func socketControl(network, address string, c syscall.RawConn) error {
-	var innerErr error
-	err := c.Control(func(fd uintptr) {
-		err := unix.SetsockoptInt(
-			int(fd),
-			unix.SOL_SOCKET,
-			unix.SO_REUSEADDR,
-			1,
-		)
-		if err != nil {
-			innerErr = err
-			return
-		}
-		err = unix.SetsockoptInt(
-			int(fd),
-			unix.SOL_SOCKET,
-			unix.SO_REUSEPORT,
-			1,
-		)
-		if err != nil {
-			innerErr = err
-			return
-		}
-	})
-	if innerErr != nil {
-		return innerErr
-	}
-	if err != nil {
-		return err
-	}
-	return nil
-}

package/connmanager/unix.go

@@ -1,78 +0,0 @@
-// 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 connmanager
-
-import (
-	"errors"
-	"fmt"
-	"net"
-)
-
-// UnixConn is a wrapper around net.UnixConn that provides a unique remote address
-type UnixConn struct {
-	*net.UnixConn
-	remoteAddr UnixConnAddr
-}
-
-func NewUnixConn(conn net.Conn) (*UnixConn, error) {
-	uConn, ok := conn.(*net.UnixConn)
-	if !ok {
-		return nil, errors.New("connection is not net.UnixConn")
-	}
-	// Construct address string
-	var fdNum int
-	// Get raw connection
-	rawConn, err := uConn.SyscallConn()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get raw connection: %w", err)
-	}
-	// Retrieve socket file descriptor
-	if rawConn == nil {
-		return nil, errors.New("raw connection returned empty")
-	}
-	err = rawConn.Control(
-		func(fd uintptr) {
-			fdNum = int(fd)
-		},
-	)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get socket file descriptor: %w", err)
-	}
-	return &UnixConn{
-		UnixConn: uConn,
-		remoteAddr: UnixConnAddr{
-			addr: fmt.Sprintf(
-				"unix@%d",
-				fdNum,
-			),
-		},
-	}, nil
-}
-
-func (u UnixConn) RemoteAddr() net.Addr {
-	return u.remoteAddr
-}
-
-type UnixConnAddr struct {
-	addr string
-}
-
-func (UnixConnAddr) Network() string {
-	return "unix"
-}
-
-func (u UnixConnAddr) String() string {
-	return u.addr
-}