Beispiel #1
0
func consulStoreWithFakeKV() *consulStore {
	return &consulStore{
		kv:      consulutil.NewFakeClient().KV(),
		logger:  logging.DefaultLogger,
		retries: 0,
	}
}
Beispiel #2
0
func consulStoreWithFakeKV() *consulStore {
	return &consulStore{
		kv:         consulutil.NewFakeClient().KV(),
		applicator: labels.NewFakeApplicator(),
		logger:     logging.DefaultLogger,
	}
}
Beispiel #3
0
// Instantiates a preparer with a podStore and podStatusStore backed by a fake
// consul KV implementation. The podStore field is necessary for acquiring the
// "intent" manifest for uuid pods, while the podStatusStore is necessary for
// getting the reality manifest
func testResultSetPreparer() *Preparer {
	fakeStatusStore := statusstoretest.NewFake()
	return &Preparer{
		podStatusStore: podstatus.NewConsul(fakeStatusStore, kp.PreparerPodStatusNamespace),
		podStore:       podstore.NewConsul(consulutil.NewFakeClient().KV()),
	}
}
Beispiel #4
0
func setupServerWithFakePodStore() (podstore.Store, store) {
	fakePodStore := podstore.NewConsul(consulutil.NewFakeClient().KV_)
	server := store{
		scheduler: fakePodStore,
	}

	return fakePodStore, server
}
Beispiel #5
0
func TestPublishLatestRCsWithLockInfoWithLocks(t *testing.T) {
	client := consulutil.NewFakeClient()
	fakeKV := client.KV()
	rcstore := NewConsul(client, 1)

	inCh := make(chan []fields.RC)
	defer close(inCh)
	quitCh := make(chan struct{})
	defer close(quitCh)

	lockResultCh, errCh := rcstore.publishLatestRCsWithLockInfo(inCh, quitCh)
	go func() {
		for err := range errCh {
			t.Fatalf("Unexpected error on errCh: %s", err)
		}
	}()

	// Create a test case with 2 RCs with no locks
	lockedCase := LockInfoTestCase{
		InputRCs: []fields.RC{fields.RC{ID: "abc"}, fields.RC{ID: "123"}},
		ExpectedOutput: []RCLockResult{
			{
				RC:                fields.RC{ID: "abc"},
				LockedForMutation: true,
			},
			{
				RC:                 fields.RC{ID: "123"},
				LockedForOwnership: true,
			},
		},
	}

	ownershipLockPath, err := rcstore.ownershipLockPath("123")
	if err != nil {
		t.Fatalf("Unable to compute ownership lock path: %s", err)
	}
	_, _, err = fakeKV.Acquire(&api.KVPair{
		Key: ownershipLockPath,
	}, nil)
	if err != nil {
		t.Fatalf("Unable to lock for ownership: %s", err)
	}

	mutationLockPath, err := rcstore.mutationLockPath("abc")
	if err != nil {
		t.Fatalf("Unable to compute mutation lock path: %s", err)
	}
	_, _, err = fakeKV.Acquire(&api.KVPair{
		Key: mutationLockPath,
	}, nil)
	if err != nil {
		t.Fatalf("Unable to lock for mutation: %s", err)
	}

	verifyLockInfoTestCase(t, lockedCase, inCh, lockResultCh)

	// Add an update creation lock to the second one
	lockedCase2 := LockInfoTestCase{
		InputRCs: []fields.RC{fields.RC{ID: "abc"}, fields.RC{ID: "123"}},
		ExpectedOutput: []RCLockResult{
			{
				RC:                fields.RC{ID: "abc"},
				LockedForMutation: true,
			},
			{
				RC:                      fields.RC{ID: "123"},
				LockedForOwnership:      true,
				LockedForUpdateCreation: true,
			},
		},
	}

	updateCreationLockPath, err := rcstore.updateCreationLockPath("123")
	if err != nil {
		t.Fatalf("Unable to compute update creation lock path: %s", err)
	}
	_, _, err = fakeKV.Acquire(&api.KVPair{
		Key: updateCreationLockPath,
	}, nil)
	if err != nil {
		t.Fatalf("Unable to lock for updateCreation: %s", err)
	}

	verifyLockInfoTestCase(t, lockedCase2, inCh, lockResultCh)
}
Beispiel #6
0
func TestPublishLatestRCsWithLockInfoNoLocks(t *testing.T) {
	client := consulutil.NewFakeClient()
	rcstore := NewConsul(client, 1)

	inCh := make(chan []fields.RC)
	defer close(inCh)
	quitCh := make(chan struct{})
	defer close(quitCh)

	lockResultCh, errCh := rcstore.publishLatestRCsWithLockInfo(inCh, quitCh)
	go func() {
		for err := range errCh {
			t.Fatalf("Unexpected error on errCh: %s", err)
		}
	}()

	// Create a test case with 2 RCs with no locks
	unlockedCase := LockInfoTestCase{
		InputRCs: []fields.RC{fields.RC{ID: "abc"}, fields.RC{ID: "123"}},
		ExpectedOutput: []RCLockResult{
			{
				RC: fields.RC{ID: "abc"},
			},
			{
				RC: fields.RC{ID: "123"},
			},
		},
	}

	verifyLockInfoTestCase(t, unlockedCase, inCh, lockResultCh)

	// Write the same input once more without reading the channel and make
	// sure that doesn't cause timeouts
	select {
	case inCh <- unlockedCase.InputRCs:
	case <-time.After(1 * time.Second):
		t.Fatalf("Timed out writing to input channel")
	}

	// create a new case
	unlockedCase2 := LockInfoTestCase{
		InputRCs: []fields.RC{
			fields.RC{ID: "abc"},
			fields.RC{ID: "123"},
			fields.RC{ID: "456"},
		},
		ExpectedOutput: []RCLockResult{
			{
				RC: fields.RC{ID: "abc"},
			},
			{
				RC: fields.RC{ID: "123"},
			},
			{
				RC: fields.RC{ID: "456"},
			},
		},
	}

	verifyLockInfoTestCase(t, unlockedCase2, inCh, lockResultCh)
}
Beispiel #7
0
func storeWithFakeKV() *consulStore {
	return &consulStore{
		kv: consulutil.NewFakeClient().KV(),
	}
}
Beispiel #8
0
func TestAllPods(t *testing.T) {
	fakeConsulClient := consulutil.NewFakeClient()
	store := NewConsulStore(fakeConsulClient)

	consulStore, ok := store.(*consulStore)
	if !ok {
		t.Fatal("Type assertion to consulStore struct type failed")
	}

	// Add a new uuid pod (i.e. we expect an index rather than a manifest to be written to /intent)
	uuidKey, err := consulStore.podStore.Schedule(testManifest("first_pod"), "node1")
	if err != nil {
		t.Fatal(err)
	}

	// now write a legacy manifest to /intent
	_, err = store.SetPod(INTENT_TREE, "node2", testManifest("second_pod"))
	if err != nil {
		t.Fatal(err)
	}

	// Now retrieve all the pods and make sure the manifest results are sane
	allPods, _, err := store.AllPods(INTENT_TREE)
	if err != nil {
		t.Fatalf("Unexpected error calling all pods: %s", err)
	}

	if len(allPods) != 2 {
		t.Errorf("Expected 2 pods to be returned, but there were '%d'", len(allPods))
	}

	// Make sure the legacy pod was found
	legacyFound := false
	for _, result := range allPods {
		if result.PodLocation.Node == "node2" {
			legacyFound = true
			if result.Manifest.ID() != "second_pod" {
				t.Errorf("Legacy pod manifest should have had id '%s' but was '%s'", "second_pod", result.Manifest.ID())
			}

			if result.PodUniqueKey != nil {
				t.Error("Legacy pod should not have a uuid")
			}
		}
	}

	if !legacyFound {
		t.Error("Didn't find the legacy (non uuid) pod")
	}

	uuidPodFound := false
	for _, result := range allPods {
		if result.PodLocation.Node == "node1" {
			uuidPodFound = true
			if result.Manifest.ID() != "first_pod" {
				t.Errorf("UUID pod manifest should have had id '%s' but was '%s'", "first_pod", result.Manifest.ID())
			}

			if result.PodUniqueKey == nil {
				t.Error("UUID pod should have a uuid")
			}

			if result.PodUniqueKey.ID != uuidKey.ID {
				t.Errorf("Expected legacy pod to have PodUniqueKeyID '%s', was '%s'", "node2/second_pod", result.PodUniqueKey.ID)
			}
		}
	}

	if !uuidPodFound {
		t.Error("Didn't find uuid pod")
	}
}
Beispiel #9
0
func TestAllPods(t *testing.T) {
	fakeConsulClient := consulutil.NewFakeClient()
	store := NewConsulStore(fakeConsulClient)

	// Add a new uuid pod (i.e. we expect an index rather than a manifest to be written to /intent)
	uuidKey, err := store.podStore.Schedule(testManifest("first_pod"), "node1")
	if err != nil {
		t.Fatal(err)
	}

	// Add a status entry for the pod
	err = store.podStatusStore.Set(uuidKey, podstatus.PodStatus{Manifest: "id: first_pod"})
	if err != nil {
		t.Fatal(err)
	}

	// Write the /reality index for the pod
	err = store.podStore.WriteRealityIndex(uuidKey, "node1")
	if err != nil {
		t.Fatal(err)
	}

	// now write a legacy manifest to /intent and /reality
	_, err = store.SetPod(INTENT_TREE, "node2", testManifest("second_pod"))
	if err != nil {
		t.Fatal(err)
	}

	_, err = store.SetPod(REALITY_TREE, "node2", testManifest("second_pod"))
	if err != nil {
		t.Fatal(err)
	}

	// Now retrieve all the /intent pods and make sure the manifest results are sane
	allIntentPods, _, err := store.AllPods(INTENT_TREE)
	if err != nil {
		t.Fatalf("Unexpected error calling all pods: %s", err)
	}

	if len(allIntentPods) != 2 {
		t.Errorf("Expected 2 intent pods to be returned, but there were %d", len(allIntentPods))
	}

	// Make sure the legacy pod was found
	legacyFound := false
	for _, result := range allIntentPods {
		if result.PodLocation.Node == "node2" {
			legacyFound = true
			if result.Manifest.ID() != "second_pod" {
				t.Errorf("Legacy pod manifest should have had id '%s' but was '%s'", "second_pod", result.Manifest.ID())
			}

			if result.PodUniqueKey != "" {
				t.Error("Legacy pod should not have a uuid")
			}
		}
	}

	if !legacyFound {
		t.Error("Didn't find the legacy (non uuid) pod")
	}

	uuidPodFound := false
	for _, result := range allIntentPods {
		if result.PodLocation.Node == "node1" {
			uuidPodFound = true
			if result.Manifest.ID() != "first_pod" {
				t.Errorf("UUID pod manifest should have had id '%s' but was '%s'", "first_pod", result.Manifest.ID())
			}

			if result.PodUniqueKey == "" {
				t.Error("UUID pod should have a uuid")
			}

			if result.PodUniqueKey != uuidKey {
				t.Errorf("Expected legacy pod to have PodUniqueKey '%s', was '%s'", "node2/second_pod", result.PodUniqueKey)
			}
		}
	}

	if !uuidPodFound {
		t.Error("Didn't find uuid pod")
	}

	// Now retrieve all the pods and make sure the manifest results are sane
	allRealityPods, _, err := store.AllPods(REALITY_TREE)
	if err != nil {
		t.Fatalf("Unexpected error calling all pods: %s", err)
	}

	if len(allRealityPods) != 2 {
		t.Errorf("Expected 2 reality pods to be returned, but there were %d", len(allRealityPods))
	}

	// Make sure the legacy pod was found
	legacyFound = false
	for _, result := range allRealityPods {
		if result.PodLocation.Node == "node2" {
			legacyFound = true
			if result.Manifest.ID() != "second_pod" {
				t.Errorf("Legacy pod manifest should have had id '%s' but was '%s'", "second_pod", result.Manifest.ID())
			}

			if result.PodUniqueKey != "" {
				t.Error("Legacy pod should not have a uuid")
			}
		}
	}

	if !legacyFound {
		t.Error("Didn't find the legacy (non uuid) pod")
	}

	uuidPodFound = false
	for _, result := range allRealityPods {
		if result.PodLocation.Node == "node1" {
			uuidPodFound = true
			if result.Manifest.ID() != "first_pod" {
				t.Errorf("UUID pod manifest should have had id '%s' but was '%s'", "first_pod", result.Manifest.ID())
			}

			if result.PodUniqueKey == "" {
				t.Error("UUID pod should have a uuid")
			}

			if result.PodUniqueKey != uuidKey {
				t.Errorf("Expected legacy pod to have PodUniqueKey '%s', was '%s'", "node2/second_pod", result.PodUniqueKey)
			}
		}
	}

	if !uuidPodFound {
		t.Error("Didn't find uuid pod")
	}
}