-
-
Notifications
You must be signed in to change notification settings - Fork 16
/
libp2p.go
96 lines (80 loc) · 3.01 KB
/
libp2p.go
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
//go:build !wasm
/*
Copyright 2023 Avi Zimmerman <avi.zimmerman@gmail.com>
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 libp2p provides webmesh integration with libp2p.
package libp2p
import (
"fmt"
"log/slog"
"strings"
"sync"
"github.com/libp2p/go-libp2p/core/protocol"
"github.com/multiformats/go-multiaddr"
"github.com/webmeshproj/webmesh/pkg/crypto"
"github.com/webmeshproj/webmesh/pkg/meshnet/system/buffers"
)
const (
// BootstrapProtocol is the protocol used for bootstrapping a mesh.
BootstrapProtocol = protocol.ID("/webmesh/bootstrap/0.0.1")
// RPCProtocol is the protocol used for executing RPCs against a mesh.
// The method should be appended to the end of the protocol.
RPCProtocol = protocol.ID("/webmesh/rpc/0.0.1")
// RaftProtocol is the protocol used for webmesh raft.
// This is not used yet.
RaftProtocol = protocol.ID("/webmesh/raft/0.0.1")
// UDPRelayProtocol is the protocol used for relaying UDP packets.
// The destination node should be appended to the end of the protocol.
UDPRelayProtocol = protocol.ID("/webmesh/udp-relay/0.0.1")
)
// RPCProtocolFor returns the RPCProtocol for the given method.
func RPCProtocolFor(method string) protocol.ID {
return protocol.ID(fmt.Sprintf("%s/%s", RPCProtocol, strings.TrimPrefix(method, "/")))
}
// UDPRelayProtocolFor returns the UDPRelayProtocol for accepting connections
// from the given public key.
func UDPRelayProtocolFor(pubkey crypto.PublicKey) protocol.ID {
return protocol.ID(fmt.Sprintf("%s/%s", UDPRelayProtocol, pubkey.WireGuardKey().String()))
}
var buffersOnce sync.Once
// MaxBuffer is the maximum buffer size for libp2p.
const MaxBuffer = 2500000
// SetMaxSystemBuffers sets the system buffers to the maximum size for libp2p.
func SetMaxSystemBuffers() {
SetSystemBuffers(MaxBuffer)
}
// SetSystemBuffers sets the system buffers to use for libp2p.
func SetSystemBuffers(size int) {
buffersOnce.Do(func() {
err := buffers.SetMaximumReadBuffer(size)
if err != nil {
slog.Default().Warn("Failed to set maximum read buffer", "error", err.Error())
}
err = buffers.SetMaximumWriteBuffer(size)
if err != nil {
slog.Default().Warn("Failed to set maximum write buffer", "error", err.Error())
}
})
}
// ToMultiaddrs returns the given strings as multiaddrs. It silently
// ignores any invalid multiaddrs.
func ToMultiaddrs(addrs []string) []multiaddr.Multiaddr {
out := make([]multiaddr.Multiaddr, 0)
for _, addr := range addrs {
maddr, err := multiaddr.NewMultiaddr(addr)
if err != nil {
continue
}
out = append(out, maddr)
}
return out
}