func Open(options ...EndpointOption) (*Endpoint, error) {
innerOptions := make([]e3x.EndpointOption, len(options)+10)
innerOptions = append(innerOptions, paths.Module())
innerOptions = append(innerOptions, bridge.Module(bridge.Config{}))
for i, option := range options {
innerOptions[i] = e3x.EndpointOption(option)
}
inner, err := e3x.Open(innerOptions...)
if err != nil {
return nil, err
}
return &Endpoint{inner: inner}, nil
}
func Test_resolveHTTP(t *testing.T) {
assert := assert.New(t)
e, err := e3x.Open()
if err != nil {
panic(err)
}
defer e.Close()
s := httptest.NewServer(WellKnown(e))
defer s.Close()
uri, err := Parse(s.URL[7:])
t.Logf("uri=%q parsed=%v", s.URL[7:], uri)
if err != nil {
panic(err)
}
ident, err := resolveHTTP(uri)
assert.NoError(err)
assert.NotNil(ident)
t.Logf("ident=%v addrs=%v keys=%v", ident, ident.Addresses(), ident.Keys())
}
func TestBridge(t *testing.T) {
// given:
// A <-> B exchange
// B <-> R exchange
// A x-x R no exchange
//
// when:
// R --> B route token from A->B to B
// A --x B block A from contacting B (while adding R's addresses to the exchange A->B)
//
// then:
// A and B should still be able to communicate.
assert := assert.New(t)
var blacklist []net.Addr
blacklistRule := func(src net.Addr) bool {
t.Logf("FW(%v, src=%s)", blacklist, src)
if len(blacklist) == 0 {
return true
}
for _, addr := range blacklist {
if transports.EqualAddr(addr, src) {
return false
}
}
return true
}
A, err := e3x.Open(
e3x.Log(nil),
e3x.Transport(udp.Config{}),
Module(Config{}))
assert.NoError(err)
B, err := e3x.Open(
e3x.Log(nil),
e3x.Transport(fw.Config{Config: udp.Config{}, Allow: fw.RuleFunc(blacklistRule)}),
Module(Config{}))
assert.NoError(err)
R, err := e3x.Open(
e3x.Log(nil),
e3x.Transport(udp.Config{}),
Module(Config{}))
assert.NoError(err)
done := make(chan bool, 1)
go func() {
var (
pkt *lob.Packet
err error
n = 1
first = true
)
defer func() { done <- true }()
c, err := A.Listen("ping", true).AcceptChannel()
defer c.Close()
for ; n > 0; n-- {
pkt, err = c.ReadPacket()
if err != nil {
t.Fatalf("ping: error: %s", err)
return
}
if first {
n, _ = pkt.Header().GetInt("n")
first = false
}
t.Logf("RCV ping: %d", n)
err = c.WritePacket(&lob.Packet{})
if err != nil {
t.Fatalf("ping: error: %s", err)
return
}
t.Logf("SND pong: %d", n)
}
}()
Aident, err := A.LocalIdentity()
assert.NoError(err)
Bident, err := B.LocalIdentity()
assert.NoError(err)
{
addr, err := transports.ResolveAddr("peer", string(R.LocalHashname()))
assert.NoError(err)
Bident = Bident.AddPathCandiate(addr)
}
log.Println("\x1B[31m------------------------------------------------\x1B[0m")
// blacklist A
blacklist = append(blacklist, Aident.Addresses()...)
log.Println("\x1B[32mblacklist:\x1B[0m", blacklist)
log.Println("\x1B[31m------------------------------------------------\x1B[0m")
_, err = R.Dial(Bident)
assert.NoError(err)
_, err = R.Dial(Aident)
assert.NoError(err)
ABex, err := A.Dial(Bident)
assert.NoError(err)
log.Println("\x1B[31m------------------------------------------------\x1B[0m")
log.Printf("ab-local-token = %x", ABex.LocalToken())
log.Printf("ab-remote-token = %x", ABex.RemoteToken())
log.Println("\x1B[31m------------------------------------------------\x1B[0m")
{
ch, err := B.Open(Aident, "ping", true)
assert.NoError(err)
for n := 10; n > 0; n-- {
pkt := &lob.Packet{}
pkt.Header().SetInt("n", n)
err = ch.WritePacket(pkt)
if err != nil {
t.Fatalf("ping: error: %s", err)
}
t.Logf("SND ping: %d", n)
_, err = ch.ReadPacket()
if err != nil {
t.Fatalf("ping: error: %s", err)
}
t.Logf("RCV pong: %d", n)
}
ch.Close()
}
<-done
assert.NoError(A.Close())
assert.NoError(B.Close())
assert.NoError(R.Close())
}
