func TestSimultOpenMany(t *testing.T) { // t.Skip("very very slow") addrs := 20 rounds := 10 if ci.IsRunning() { addrs = 10 rounds = 5 } SubtestSwarm(t, addrs, rounds) }
func TestSimultOpenMany(t *testing.T) { // t.Skip("very very slow") addrs := 20 rounds := 10 if ci.IsRunning() || runtime.GOOS == "darwin" { // osx has a limit of 256 file descriptors addrs = 10 rounds = 5 } SubtestSwarm(t, addrs, rounds) }
func TestDialWait(t *testing.T) { // t.Skip("skipping for another test") t.Parallel() ctx := context.Background() swarms := makeSwarms(ctx, t, 1) s1 := swarms[0] defer s1.Close() s1.dialT = time.Millisecond * 300 // lower timeout for tests. if ci.IsRunning() { s1.dialT = time.Second } // dial to a non-existent peer. s2p, s2addr, s2l := newSilentPeer(t) go acceptAndHang(s2l) defer s2l.Close() s1.peers.AddAddr(s2p, s2addr, peer.PermanentAddrTTL) before := time.Now() if c, err := s1.Dial(ctx, s2p); err == nil { defer c.Close() t.Fatal("error swarm dialing to unknown peer worked...", err) } else { t.Log("correctly got error:", err) } duration := time.Now().Sub(before) dt := s1.dialT if duration < dt*dialAttempts { t.Error("< DialTimeout * dialAttempts not being respected", duration, dt*dialAttempts) } if duration > 2*dt*dialAttempts { t.Error("> 2*DialTimeout * dialAttempts not being respected", duration, 2*dt*dialAttempts) } if !s1.backf.Backoff(s2p) { t.Error("s2 should now be on backoff") } }
func TestDialBackoffClears(t *testing.T) { // t.Skip("skipping for another test") t.Parallel() ctx := context.Background() swarms := makeSwarms(ctx, t, 2) s1 := swarms[0] s2 := swarms[1] defer s1.Close() defer s2.Close() s1.dialT = time.Millisecond * 300 // lower timeout for tests. s2.dialT = time.Millisecond * 300 // lower timeout for tests. if ci.IsRunning() { s1.dialT = 2 * time.Second s2.dialT = 2 * time.Second } // use another address first, that accept and hang on conns _, s2bad, s2l := newSilentPeer(t) go acceptAndHang(s2l) defer s2l.Close() // phase 1 -- dial to non-operational addresses s1.peers.AddAddr(s2.local, s2bad, peer.PermanentAddrTTL) before := time.Now() if c, err := s1.Dial(ctx, s2.local); err == nil { t.Fatal("dialing to broken addr worked...", err) defer c.Close() } else { t.Log("correctly got error:", err) } duration := time.Now().Sub(before) dt := s1.dialT if duration < dt*dialAttempts { t.Error("< DialTimeout * dialAttempts not being respected", duration, dt*dialAttempts) } if duration > 2*dt*dialAttempts { t.Error("> 2*DialTimeout * dialAttempts not being respected", duration, 2*dt*dialAttempts) } if !s1.backf.Backoff(s2.local) { t.Error("s2 should now be on backoff") } else { t.Log("correctly added to backoff") } // phase 2 -- add the working address. dial should succeed. ifaceAddrs1, err := swarms[1].InterfaceListenAddresses() if err != nil { t.Fatal(err) } s1.peers.AddAddrs(s2.local, ifaceAddrs1, peer.PermanentAddrTTL) before = time.Now() if c, err := s1.Dial(ctx, s2.local); err != nil { t.Fatal(err) } else { c.Close() t.Log("correctly connected") } duration = time.Now().Sub(before) if duration >= dt { // t.Error("took too long", duration, dt) } if s1.backf.Backoff(s2.local) { t.Error("s2 should no longer be on backoff") } else { t.Log("correctly cleared backoff") } }
func TestDialBackoff(t *testing.T) { // t.Skip("skipping for another test") if ci.IsRunning() { t.Skip("travis and jenkins will never have fun with this test") } t.Parallel() ctx := context.Background() swarms := makeSwarms(ctx, t, 2) s1 := swarms[0] s2 := swarms[1] defer s1.Close() defer s2.Close() s1.dialT = time.Second // lower timeout for tests. s2.dialT = time.Second // lower timeout for tests. s2addrs, err := s2.InterfaceListenAddresses() if err != nil { t.Fatal(err) } s1.peers.AddAddrs(s2.local, s2addrs, peer.PermanentAddrTTL) // dial to a non-existent peer. s3p, s3addr, s3l := newSilentPeer(t) go acceptAndHang(s3l) defer s3l.Close() s1.peers.AddAddr(s3p, s3addr, peer.PermanentAddrTTL) // in this test we will: // 1) dial 10x to each node. // 2) all dials should hang // 3) s1->s2 should succeed. // 4) s1->s3 should not (and should place s3 on backoff) // 5) disconnect entirely // 6) dial 10x to each node again // 7) s3 dials should all return immediately (except 1) // 8) s2 dials should all hang, and succeed // 9) last s3 dial ends, unsuccessful dialOnlineNode := func(dst peer.ID, times int) <-chan bool { ch := make(chan bool) for i := 0; i < times; i++ { go func() { if _, err := s1.Dial(ctx, dst); err != nil { t.Error("error dialing", dst, err) ch <- false } else { ch <- true } }() } return ch } dialOfflineNode := func(dst peer.ID, times int) <-chan bool { ch := make(chan bool) for i := 0; i < times; i++ { go func() { if c, err := s1.Dial(ctx, dst); err != nil { ch <- false } else { t.Error("succeeded in dialing", dst) ch <- true c.Close() } }() } return ch } { // 1) dial 10x to each node. N := 10 s2done := dialOnlineNode(s2.local, N) s3done := dialOfflineNode(s3p, N) // when all dials should be done by: dialTimeout1x := time.After(s1.dialT) // dialTimeout1Ax := time.After(s1.dialT * 2) // dialAttempts) dialTimeout10Ax := time.After(s1.dialT * 2 * 10) // dialAttempts * 10) // 2) all dials should hang select { case <-s2done: t.Error("s2 should not happen immediately") case <-s3done: t.Error("s3 should not happen yet") case <-time.After(time.Millisecond): // s2 may finish very quickly, so let's get out. } // 3) s1->s2 should succeed. for i := 0; i < N; i++ { select { case r := <-s2done: if !r { t.Error("s2 should not fail") } case <-s3done: t.Error("s3 should not happen yet") case <-dialTimeout1x: t.Error("s2 took too long") } } select { case <-s2done: t.Error("s2 should have no more") case <-s3done: t.Error("s3 should not happen yet") case <-dialTimeout1x: // let it pass } // 4) s1->s3 should not (and should place s3 on backoff) // N-1 should finish before dialTimeout1x * 2 for i := 0; i < N; i++ { select { case <-s2done: t.Error("s2 should have no more") case r := <-s3done: if r { t.Error("s3 should not succeed") } case <-(dialTimeout1x): if i < (N - 1) { t.Fatal("s3 took too long") } t.Log("dialTimeout1x * 1.3 hit for last peer") case <-dialTimeout10Ax: t.Fatal("s3 took too long") } } // check backoff state if s1.backf.Backoff(s2.local) { t.Error("s2 should not be on backoff") } if !s1.backf.Backoff(s3p) { t.Error("s3 should be on backoff") } // 5) disconnect entirely for _, c := range s1.Connections() { c.Close() } for i := 0; i < 100 && len(s1.Connections()) > 0; i++ { <-time.After(time.Millisecond) } if len(s1.Connections()) > 0 { t.Fatal("s1 conns must exit") } } { // 6) dial 10x to each node again N := 10 s2done := dialOnlineNode(s2.local, N) s3done := dialOfflineNode(s3p, N) // when all dials should be done by: dialTimeout1x := time.After(s1.dialT) // dialTimeout1Ax := time.After(s1.dialT * 2) // dialAttempts) dialTimeout10Ax := time.After(s1.dialT * 2 * 10) // dialAttempts * 10) // 7) s3 dials should all return immediately (except 1) for i := 0; i < N-1; i++ { select { case <-s2done: t.Error("s2 should not succeed yet") case r := <-s3done: if r { t.Error("s3 should not succeed") } case <-dialTimeout1x: t.Fatal("s3 took too long") } } // 8) s2 dials should all hang, and succeed for i := 0; i < N; i++ { select { case r := <-s2done: if !r { t.Error("s2 should succeed") } // case <-s3done: case <-(dialTimeout1x): t.Fatal("s3 took too long") } } // 9) the last s3 should return, failed. select { case <-s2done: t.Error("s2 should have no more") case r := <-s3done: if r { t.Error("s3 should not succeed") } case <-dialTimeout10Ax: t.Fatal("s3 took too long") } // check backoff state (the same) if s1.backf.Backoff(s2.local) { t.Error("s2 should not be on backoff") } if !s1.backf.Backoff(s3p) { t.Error("s3 should be on backoff") } } }
func TestPeriodicBootstrap(t *testing.T) { // t.Skip("skipping test to debug another") if ci.IsRunning() { t.Skip("skipping on CI. highly timing dependent") } if testing.Short() { t.SkipNow() } ctx := context.Background() nDHTs := 30 _, _, dhts := setupDHTS(ctx, nDHTs, t) defer func() { for i := 0; i < nDHTs; i++ { dhts[i].Close() defer dhts[i].host.Close() } }() // signal amplifier amplify := func(signal chan time.Time, other []chan time.Time) { for t := range signal { for _, s := range other { s <- t } } for _, s := range other { close(s) } } signal := make(chan time.Time) allSignals := []chan time.Time{} var cfg BootstrapConfig cfg = DefaultBootstrapConfig cfg.Queries = 5 // kick off periodic bootstrappers with instrumented signals. for _, dht := range dhts { s := make(chan time.Time) allSignals = append(allSignals, s) dht.BootstrapOnSignal(cfg, s) } go amplify(signal, allSignals) t.Logf("dhts are not connected.", nDHTs) for _, dht := range dhts { rtlen := dht.routingTable.Size() if rtlen > 0 { t.Errorf("routing table for %s should have 0 peers. has %d", dht.self, rtlen) } } for i := 0; i < nDHTs; i++ { connect(t, ctx, dhts[i], dhts[(i+1)%len(dhts)]) } t.Logf("dhts are now connected to 1-2 others.", nDHTs) for _, dht := range dhts { rtlen := dht.routingTable.Size() if rtlen > 2 { t.Errorf("routing table for %s should have at most 2 peers. has %d", dht.self, rtlen) } } if u.Debug { printRoutingTables(dhts) } t.Logf("bootstrapping them so they find each other", nDHTs) signal <- time.Now() // this is async, and we dont know when it's finished with one cycle, so keep checking // until the routing tables look better, or some long timeout for the failure case. waitForWellFormedTables(t, dhts, 7, 10, 20*time.Second) if u.Debug { printRoutingTables(dhts) } }
func TestRepublisher(t *testing.T) { if ci.IsRunning() { t.Skip("dont run timing tests in CI") } ctx := context.TODO() pub := make(chan struct{}) pf := func(ctx context.Context, k key.Key) error { pub <- struct{}{} return nil } tshort := time.Millisecond * 50 tlong := time.Second / 2 rp := NewRepublisher(ctx, pf, tshort, tlong) go rp.Run() rp.Update("test") // should hit short timeout select { case <-time.After(tshort * 2): t.Fatal("publish didnt happen in time") case <-pub: } cctx, cancel := context.WithCancel(context.Background()) go func() { for { rp.Update("a") time.Sleep(time.Millisecond * 10) select { case <-cctx.Done(): return default: } } }() select { case <-pub: t.Fatal("shouldnt have received publish yet!") case <-time.After((tlong * 9) / 10): } select { case <-pub: case <-time.After(tlong / 2): t.Fatal("waited too long for pub!") } cancel() go func() { err := rp.Close() if err != nil { t.Fatal(err) } }() // final pub from closing <-pub }