// TestElectionSessionRelock ensures that campaigning twice on the same election // with the same lock will Proclaim instead of deadlocking. func TestElectionSessionRecampaign(t *testing.T) { clus := NewClusterV3(t, &ClusterConfig{Size: 1}) defer clus.Terminate(t) cli := clus.RandClient() session, err := concurrency.NewSession(cli) if err != nil { t.Error(err) } defer session.Orphan() e := concurrency.NewElection(session, "test-elect") if err := e.Campaign(context.TODO(), "abc"); err != nil { t.Fatal(err) } e2 := concurrency.NewElection(session, "test-elect") if err := e2.Campaign(context.TODO(), "def"); err != nil { t.Fatal(err) } ctx, cancel := context.WithCancel(context.TODO()) defer cancel() if resp := <-e.Observe(ctx); len(resp.Kvs) == 0 || string(resp.Kvs[0].Value) != "def" { t.Fatalf("expected value=%q, got response %v", "def", resp) } }
// TestElectionFailover tests that an election will func TestElectionFailover(t *testing.T) { clus := NewClusterV3(t, &ClusterConfig{Size: 3}) defer clus.Terminate(t) defer dropSessionLease(clus) cctx, cancel := context.WithCancel(context.TODO()) defer cancel() // first leader (elected) e := concurrency.NewElection(clus.clients[0], "test-election") if err := e.Campaign(context.TODO(), "foo"); err != nil { t.Fatalf("failed volunteer (%v)", err) } // check first leader resp, ok := <-e.Observe(cctx) if !ok { t.Fatalf("could not wait for first election; channel closed") } s := string(resp.Kvs[0].Value) if s != "foo" { t.Fatalf("wrong election result. got %s, wanted foo", s) } // next leader electedc := make(chan struct{}) go func() { ee := concurrency.NewElection(clus.clients[1], "test-election") if eer := ee.Campaign(context.TODO(), "bar"); eer != nil { t.Fatal(eer) } electedc <- struct{}{} }() // invoke leader failover session, serr := concurrency.NewSession(clus.clients[0]) if serr != nil { t.Fatal(serr) } if err := session.Close(); err != nil { t.Fatal(err) } // check new leader e = concurrency.NewElection(clus.clients[2], "test-election") resp, ok = <-e.Observe(cctx) if !ok { t.Fatalf("could not wait for second election; channel closed") } s = string(resp.Kvs[0].Value) if s != "bar" { t.Fatalf("wrong election result. got %s, wanted bar", s) } // leader must ack election (otherwise, Campaign may see closed conn) <-electedc }
func observe(c *clientv3.Client, election string) error { e := concurrency.NewElection(context.TODO(), c, election) ctx, cancel := context.WithCancel(context.TODO()) donec := make(chan struct{}) sigc := make(chan os.Signal, 1) signal.Notify(sigc, os.Interrupt, os.Kill) go func() { <-sigc cancel() }() go func() { for resp := range e.Observe(ctx) { display.Get(resp) } close(donec) }() <-donec select { case <-ctx.Done(): default: return errors.New("elect: observer lost") } return nil }
func campaign(c *clientv3.Client, election string, prop string) error { s, err := concurrency.NewSession(c) if err != nil { return err } e := concurrency.NewElection(s, election) ctx, cancel := context.WithCancel(context.TODO()) donec := make(chan struct{}) sigc := make(chan os.Signal, 1) signal.Notify(sigc, os.Interrupt, os.Kill) go func() { <-sigc cancel() close(donec) }() s, serr := concurrency.NewSession(c) if serr != nil { return serr } if err = e.Campaign(ctx, prop); err != nil { return err } // print key since elected resp, err := c.Get(ctx, e.Key()) if err != nil { return err } display.Get(*resp) select { case <-donec: case <-s.Done(): return errors.New("elect: session expired") } return e.Resign(context.TODO()) }
// TestElectionOnPrefixOfExistingKey checks that a single // candidate can be elected on a new key that is a prefix // of an existing key. To wit, check for regression // of bug #6278. https://github.com/coreos/etcd/issues/6278 // func TestElectionOnPrefixOfExistingKey(t *testing.T) { clus := NewClusterV3(t, &ClusterConfig{Size: 1}) defer clus.Terminate(t) cli := clus.RandClient() if _, err := cli.Put(context.TODO(), "testa", "value"); err != nil { t.Fatal(err) } s, serr := concurrency.NewSession(cli) if serr != nil { t.Fatal(serr) } e := concurrency.NewElection(s, "test") ctx, cancel := context.WithTimeout(context.TODO(), 5*time.Second) err := e.Campaign(ctx, "abc") cancel() if err != nil { // after 5 seconds, deadlock results in // 'context deadline exceeded' here. t.Fatal(err) } }
// TestElectionWait tests if followers can correctly wait for elections. func TestElectionWait(t *testing.T) { clus := NewClusterV3(t, &ClusterConfig{Size: 3}) defer clus.Terminate(t) defer dropSessionLease(clus) leaders := 3 followers := 3 electedc := make(chan string) nextc := []chan struct{}{} // wait for all elections donec := make(chan struct{}) for i := 0; i < followers; i++ { nextc = append(nextc, make(chan struct{})) go func(ch chan struct{}) { for j := 0; j < leaders; j++ { b := concurrency.NewElection(clus.RandClient(), "test-election") cctx, cancel := context.WithCancel(context.TODO()) defer cancel() s, ok := <-b.Observe(cctx) if !ok { t.Fatalf("could not observe election; channel closed") } electedc <- string(s.Kvs[0].Value) // wait for next election round <-ch } donec <- struct{}{} }(nextc[i]) } // elect some leaders for i := 0; i < leaders; i++ { go func() { e := concurrency.NewElection(clus.RandClient(), "test-election") ev := fmt.Sprintf("electval-%v", time.Now().UnixNano()) if err := e.Campaign(context.TODO(), ev); err != nil { t.Fatalf("failed volunteer (%v)", err) } // wait for followers to accept leadership for j := 0; j < followers; j++ { s := <-electedc if s != ev { t.Errorf("wrong election value got %s, wanted %s", s, ev) } } // let next leader take over if err := e.Resign(); err != nil { t.Fatalf("failed resign (%v)", err) } // tell followers to start listening for next leader for j := 0; j < followers; j++ { nextc[j] <- struct{}{} } }() } // wait on followers for i := 0; i < followers; i++ { <-donec } }
func runElection(eps []string, rounds int) { rcs := make([]roundClient, 15) validatec, releasec := make(chan struct{}, len(rcs)), make(chan struct{}, len(rcs)) for range rcs { releasec <- struct{}{} } for i := range rcs { v := fmt.Sprintf("%d", i) observedLeader := "" validateWaiters := 0 rcs[i].c = randClient(eps) e := concurrency.NewElection(rcs[i].c, "electors") rcs[i].acquire = func() error { <-releasec ctx, cancel := context.WithCancel(context.Background()) go func() { if ol, ok := <-e.Observe(ctx); ok { observedLeader = string(ol.Kvs[0].Value) if observedLeader != v { cancel() } } }() err := e.Campaign(ctx, v) if err == nil { observedLeader = v } if observedLeader == v { validateWaiters = len(rcs) } select { case <-ctx.Done(): return nil default: cancel() return err } } rcs[i].validate = func() error { if l, err := e.Leader(context.TODO()); err == nil && l != observedLeader { return fmt.Errorf("expected leader %q, got %q", observedLeader, l) } validatec <- struct{}{} return nil } rcs[i].release = func() error { for validateWaiters > 0 { select { case <-validatec: validateWaiters-- default: return fmt.Errorf("waiting on followers") } } if err := e.Resign(context.TODO()); err != nil { return err } if observedLeader == v { for range rcs { releasec <- struct{}{} } } observedLeader = "" return nil } } doRounds(rcs, rounds) }