mirror of
https://github.com/status-im/status-go.git
synced 2025-01-09 14:16:21 +00:00
eeca435064
Update vendor Integrate rendezvous into status node Add a test with failover using rendezvous Use multiple servers in client Use discovery V5 by default and test that node can be started with rendezvous discovet Fix linter Update rendezvous client to one with instrumented stream Address feedback Fix test with updated topic limits Apply several suggestions Change log to debug for request errors because we continue execution Remove web3js after rebase Update rendezvous package
134 lines
2.5 KiB
Go
134 lines
2.5 KiB
Go
package mafmt
|
|
|
|
import (
|
|
"strings"
|
|
|
|
ma "github.com/multiformats/go-multiaddr"
|
|
)
|
|
|
|
// Define IP as either ipv4 or ipv6
|
|
var IP = Or(Base(ma.P_IP4), Base(ma.P_IP6))
|
|
|
|
// Define TCP as 'tcp' on top of either ipv4 or ipv6
|
|
var TCP = And(IP, Base(ma.P_TCP))
|
|
|
|
// Define UDP as 'udp' on top of either ipv4 or ipv6
|
|
var UDP = And(IP, Base(ma.P_UDP))
|
|
|
|
// Define UTP as 'utp' on top of udp (on top of ipv4 or ipv6)
|
|
var UTP = And(UDP, Base(ma.P_UTP))
|
|
|
|
// Define QUIC as 'quic' on top of udp (on top of ipv4 or ipv6)
|
|
var QUIC = And(UDP, Base(ma.P_QUIC))
|
|
|
|
// Define unreliable transport as udp
|
|
var Unreliable = Or(UDP)
|
|
|
|
// Now define a Reliable transport as either tcp or utp or quic
|
|
var Reliable = Or(TCP, UTP, QUIC)
|
|
|
|
// IPFS can run over any reliable underlying transport protocol
|
|
var IPFS = And(Reliable, Base(ma.P_IPFS))
|
|
|
|
const (
|
|
or = iota
|
|
and = iota
|
|
)
|
|
|
|
func And(ps ...Pattern) Pattern {
|
|
return &pattern{
|
|
Op: and,
|
|
Args: ps,
|
|
}
|
|
}
|
|
|
|
func Or(ps ...Pattern) Pattern {
|
|
return &pattern{
|
|
Op: or,
|
|
Args: ps,
|
|
}
|
|
}
|
|
|
|
type Pattern interface {
|
|
Matches(ma.Multiaddr) bool
|
|
partialMatch([]ma.Protocol) (bool, []ma.Protocol)
|
|
String() string
|
|
}
|
|
|
|
type pattern struct {
|
|
Args []Pattern
|
|
Op int
|
|
}
|
|
|
|
func (ptrn *pattern) Matches(a ma.Multiaddr) bool {
|
|
ok, rem := ptrn.partialMatch(a.Protocols())
|
|
return ok && len(rem) == 0
|
|
}
|
|
|
|
func (ptrn *pattern) partialMatch(pcs []ma.Protocol) (bool, []ma.Protocol) {
|
|
switch ptrn.Op {
|
|
case or:
|
|
for _, a := range ptrn.Args {
|
|
ok, rem := a.partialMatch(pcs)
|
|
if ok {
|
|
return true, rem
|
|
}
|
|
}
|
|
return false, nil
|
|
case and:
|
|
if len(pcs) < len(ptrn.Args) {
|
|
return false, nil
|
|
}
|
|
|
|
for i := 0; i < len(ptrn.Args); i++ {
|
|
ok, rem := ptrn.Args[i].partialMatch(pcs)
|
|
if !ok {
|
|
return false, nil
|
|
}
|
|
|
|
pcs = rem
|
|
}
|
|
|
|
return true, pcs
|
|
default:
|
|
panic("unrecognized pattern operand")
|
|
}
|
|
}
|
|
|
|
func (ptrn *pattern) String() string {
|
|
var sub []string
|
|
for _, a := range ptrn.Args {
|
|
sub = append(sub, a.String())
|
|
}
|
|
|
|
switch ptrn.Op {
|
|
case and:
|
|
return strings.Join(sub, "/")
|
|
case or:
|
|
return "{" + strings.Join(sub, "|") + "}"
|
|
default:
|
|
panic("unrecognized pattern op!")
|
|
}
|
|
}
|
|
|
|
type Base int
|
|
|
|
func (p Base) Matches(a ma.Multiaddr) bool {
|
|
pcs := a.Protocols()
|
|
return pcs[0].Code == int(p) && len(pcs) == 1
|
|
}
|
|
|
|
func (p Base) partialMatch(pcs []ma.Protocol) (bool, []ma.Protocol) {
|
|
if len(pcs) == 0 {
|
|
return false, nil
|
|
}
|
|
if pcs[0].Code == int(p) {
|
|
return true, pcs[1:]
|
|
}
|
|
return false, nil
|
|
}
|
|
|
|
func (p Base) String() string {
|
|
return ma.ProtocolWithCode(int(p)).Name
|
|
}
|