Function joinWhileVoteInProgress

ais/tests/multiproxy_test.go:551–604

(t *testing.T)

}

func joinWhileVoteInProgress(t *testing.T) {
	if docker.IsRunning() {
		t.Skipf("skipping %s (docker is not supported)", t.Name())
	}
	var (
		proxyURL     = tutils.RandomProxyURL(t)
		smap         = tutils.GetClusterMap(t, proxyURL)
		oldTargetCnt = smap.CountActiveTargets()
		oldProxyCnt  = smap.CountActiveProxies()
		stopch       = make(chan struct{})
		errCh        = make(chan error, 10)
		mocktgt      = &voteRetryMockTarget{
			voteInProgress: true,
			errCh:          errCh,
		}
	)
	tlog.Logf("targets: %d, proxies: %d\n", oldTargetCnt, oldProxyCnt)

	go runMockTarget(t, proxyURL, mocktgt, stopch, smap)

	_, err := tutils.WaitForClusterState(proxyURL, "synchronize on 'new mock target'",
		smap.Version, oldProxyCnt, oldTargetCnt+1)
	tassert.CheckFatal(t, err)

	smap = killRestorePrimary(t, proxyURL, false, nil)
	//
	// FIXME: election is in progress if and only when xaction(apc.ActElection) is running -
	//        simulating the scenario via mocktgt.voteInProgress = true is incorrect
	//
	// if _, ok := smap.Pmap[oldPrimaryID]; ok {
	//	t.Fatalf("Previous primary proxy rejoined the cluster during a vote")
	// }
	mocktgt.voteInProgress = false
	// smap, err = tutils.WaitForClusterState(newPrimaryURL, "synchronize new Smap",
	// smap.Version, testing.Verbose(), oldProxyCnt, oldTargetCnt+1)
	// tassert.CheckFatal(t, err)
	//
	// end of FIXME

	// time to kill the mock target, job well done
	var v struct{}
	stopch <- v
	close(stopch)
	select {
	case err := <-errCh:
		t.Errorf("Mock Target Error: %v", err)

	default:
	}

	_, err = tutils.WaitForClusterState(smap.Primary.URL(cmn.NetPublic),
		"to kill mock target", smap.Version, oldProxyCnt, oldTargetCnt)
	tassert.CheckFatal(t, err)
}

func minorityTargetMapVersionMismatch(t *testing.T) {
	proxyURL := tutils.RandomProxyURL(t)