1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
|
// Package transport provides an abstraction layer for different network transports
package transport
import (
"fmt"
"net"
"sync"
)
// TransportType represents the type of network transport
type TransportType int
const (
TransportTor TransportType = iota
TransportMesh
TransportDirect
)
// String returns string representation of transport type
func (t TransportType) String() string {
switch t {
case TransportTor:
return "Tor"
case TransportMesh:
return "Mesh"
case TransportDirect:
return "Direct"
default:
return "Unknown"
}
}
// Transport defines the interface for network transports
type Transport interface {
// Connect establishes a connection to a remote peer
Connect(address string) (net.Conn, error)
// Listen starts listening for incoming connections
Listen(address string) (net.Listener, error)
// Type returns the transport type
Type() TransportType
// Close closes the transport
Close() error
}
// TransportManager manages multiple transports
type TransportManager struct {
transports map[TransportType]Transport
mu sync.RWMutex
closed bool
}
// NewTransportManager creates a new transport manager
func NewTransportManager() *TransportManager {
return &TransportManager{
transports: make(map[TransportType]Transport),
}
}
// RegisterTransport registers a new transport
func (tm *TransportManager) RegisterTransport(transport Transport) error {
tm.mu.Lock()
defer tm.mu.Unlock()
if tm.closed {
return fmt.Errorf("transport manager is closed")
}
transportType := transport.Type()
if _, exists := tm.transports[transportType]; exists {
return fmt.Errorf("transport %s already registered", transportType)
}
tm.transports[transportType] = transport
return nil
}
// GetTransport retrieves a transport by type
func (tm *TransportManager) GetTransport(transportType TransportType) (Transport, error) {
tm.mu.RLock()
defer tm.mu.RUnlock()
if tm.closed {
return nil, fmt.Errorf("transport manager is closed")
}
transport, exists := tm.transports[transportType]
if !exists {
return nil, fmt.Errorf("transport %s not registered", transportType)
}
return transport, nil
}
// Connect connects using the specified transport
func (tm *TransportManager) Connect(transportType TransportType, address string) (net.Conn, error) {
transport, err := tm.GetTransport(transportType)
if err != nil {
return nil, err
}
return transport.Connect(address)
}
// Listen starts listening on the specified transport
func (tm *TransportManager) Listen(transportType TransportType, address string) (net.Listener, error) {
transport, err := tm.GetTransport(transportType)
if err != nil {
return nil, err
}
return transport.Listen(address)
}
// ListTransports returns all registered transport types
func (tm *TransportManager) ListTransports() []TransportType {
tm.mu.RLock()
defer tm.mu.RUnlock()
types := make([]TransportType, 0, len(tm.transports))
for transportType := range tm.transports {
types = append(types, transportType)
}
return types
}
// Close closes all transports
func (tm *TransportManager) Close() error {
tm.mu.Lock()
defer tm.mu.Unlock()
if tm.closed {
return nil
}
var lastErr error
for transportType, transport := range tm.transports {
if err := transport.Close(); err != nil {
lastErr = fmt.Errorf("failed to close %s transport: %w", transportType, err)
}
}
tm.transports = make(map[TransportType]Transport)
tm.closed = true
return lastErr
}
// Count returns the number of registered transports
func (tm *TransportManager) Count() int {
tm.mu.RLock()
defer tm.mu.RUnlock()
return len(tm.transports)
}
// String returns a string representation
func (tm *TransportManager) String() string {
tm.mu.RLock()
defer tm.mu.RUnlock()
return fmt.Sprintf("TransportManager(transports=%d, closed=%v)", len(tm.transports), tm.closed)
}
|
