feat: Add list all functionality (#489)

This removes the requirement that a call to GetAllMicroVM must have a
namespace argument in the request. We do filtering on the Repo, so it is
not harmful to have all params be optional.

If a call to GetAllMicroVM is made without namespace or name, then all
mvms on the host will be returned.

If a call to GetAllMicroVM is made with just name, then all mvms
matching that name in any namespace will be returned.

If a call to to GetAllMicroVM is made with just namespace, then all mvms
under that namespace will be returned.

We can consider RBAC implications when we get to that.

Author: Callisto13

infrastructure/containerd/repo_test.go

@@ -1,34 +1,55 @@
 package containerd_test
 
 import (
+	"context"
 	"testing"
 
+	ctr "github.com/containerd/containerd"
 	. "github.com/onsi/gomega"
 
 	"github.com/weaveworks-liquidmetal/flintlock/core/models"
 	"github.com/weaveworks-liquidmetal/flintlock/core/ports"
 	"github.com/weaveworks-liquidmetal/flintlock/infrastructure/containerd"
 )
 
+const ctrdRepoNS = "flintlock_test_ctr_repo"
+
 func TestMicroVMRepo_Integration(t *testing.T) {
 	if !runContainerDTests() {
 		t.Skip("skipping containerd microvm repo integration test")
 	}
 
+	var (
+		repo            ports.MicroVMRepository
+		ctx             context.Context
+		testVm, testVm2 *models.MicroVM
+	)
+
+	t.Cleanup(func() {
+		if testVm != nil {
+			_ = repo.Delete(ctx, testVm)
+		}
+
+		if testVm2 != nil {
+			_ = repo.Delete(ctx, testVm2)
+		}
+	})
+
 	RegisterTestingT(t)
 
-	client, ctx := testCreateClient(t)
+	var client *ctr.Client
+	client, ctx = testCreateClient(t)
 
-	repo := containerd.NewMicroVMRepoWithClient(&containerd.Config{
+	repo = containerd.NewMicroVMRepoWithClient(&containerd.Config{
 		SnapshotterKernel: testSnapshotter,
 		SnapshotterVolume: testSnapshotter,
-		Namespace:         testContainerdNS,
+		Namespace:         ctrdRepoNS,
 	}, client)
 	exists, err := repo.Exists(ctx, *models.NewVMIDForce(testOwnerName, testOwnerNamespace, testOwnerUID))
 	Expect(err).NotTo(HaveOccurred())
 	Expect(exists).To(BeFalse())
 
-	testVm := makeSpec(testOwnerName, testOwnerNamespace)
+	testVm = makeSpec(testOwnerName, testOwnerNamespace, "uid")
 	savedVM, err := repo.Save(ctx, testVm)
 	Expect(err).NotTo(HaveOccurred())
 	Expect(savedVM).NotTo(BeNil())
@@ -40,6 +61,12 @@ func TestMicroVMRepo_Integration(t *testing.T) {
 	Expect(savedVM).NotTo(BeNil())
 	Expect(savedVM.Version).To(Equal(3))
 
+	testVm2 = makeSpec("bar", "foo", "uid2")
+	savedVM2, err := repo.Save(ctx, testVm2)
+	Expect(err).NotTo(HaveOccurred())
+	Expect(savedVM2).NotTo(BeNil())
+	Expect(savedVM2.Version).To(Equal(2))
+
 	exists, err = repo.Exists(ctx, *models.NewVMIDForce(testOwnerName, testOwnerNamespace, testOwnerUID))
 	Expect(err).NotTo(HaveOccurred())
 	Expect(exists).To(BeTrue())
@@ -67,6 +94,10 @@ func TestMicroVMRepo_Integration(t *testing.T) {
 	Expect(err).NotTo(HaveOccurred())
 	Expect(len(all)).To(Equal(1))
 
+	all2, err := repo.GetAll(ctx, models.ListMicroVMQuery{})
+	Expect(err).NotTo(HaveOccurred())
+	Expect(len(all2)).To(Equal(2))
+
 	err = repo.Delete(ctx, testVm)
 	Expect(err).NotTo(HaveOccurred())
 
@@ -90,12 +121,12 @@ func TestMicroVMRepo_Integration_MultipleSave(t *testing.T) {
 
 	client, ctx := testCreateClient(t)
 
-	testVm := makeSpec(testOwnerName, testOwnerNamespace)
+	testVm := makeSpec(testOwnerName, testOwnerNamespace, "uid")
 
 	repo := containerd.NewMicroVMRepoWithClient(&containerd.Config{
 		SnapshotterKernel: testSnapshotter,
 		SnapshotterVolume: testSnapshotter,
-		Namespace:         testContainerdNS,
+		Namespace:         ctrdRepoNS,
 	}, client)
 	savedVM, err := repo.Save(ctx, testVm)
 	Expect(err).NotTo(HaveOccurred())
@@ -111,8 +142,8 @@ func TestMicroVMRepo_Integration_MultipleSave(t *testing.T) {
 	Expect(err).NotTo(HaveOccurred())
 }
 
-func makeSpec(name, ns string) *models.MicroVM {
-	vmid, _ := models.NewVMID(name, ns, "uid")
+func makeSpec(name, ns, uid string) *models.MicroVM {
+	vmid, _ := models.NewVMID(name, ns, uid)
 	return &models.MicroVM{
 		ID:      *vmid,
 		Version: 1,

infrastructure/grpc/server.go

@@ -147,7 +147,7 @@ func (s *server) ListMicroVMs(ctx context.Context,
 ) (*mvmv1.ListMicroVMsResponse, error) {
 	logger := log.GetLogger(ctx)
 
-	if req == nil || req.Namespace == "" {
+	if req == nil {
 		logger.Error("invalid get microvm request")
 
 		//nolint:wrapcheck // don't wrap grpc errors when using the status package

infrastructure/grpc/server_test.go

@@ -267,10 +267,31 @@ func TestServer_ListMicroVMs(t *testing.T) {
 			expect:      func(cm *mock.MockMicroVMCommandUseCasesMockRecorder, qm *mock.MockMicroVMQueryUseCasesMockRecorder) {},
 		},
 		{
-			name:        "missing namespace should fail with error",
+			name:        "missing namespace should not fail with error",
 			listReq:     &mvm1.ListMicroVMsRequest{Namespace: ""},
-			expectError: true,
-			expect:      func(cm *mock.MockMicroVMCommandUseCasesMockRecorder, qm *mock.MockMicroVMQueryUseCasesMockRecorder) {},
+			expectError: false,
+			expect: func(cm *mock.MockMicroVMCommandUseCasesMockRecorder, qm *mock.MockMicroVMQueryUseCasesMockRecorder) {
+				qm.GetAllMicroVM(gomock.AssignableToTypeOf(
+					context.Background()),
+					gomock.Not(gomock.Eq("")),
+				).Return(
+					[]*models.MicroVM{
+						{
+							Version: 1,
+							Status: models.MicroVMStatus{
+								State: models.CreatedState,
+							},
+						},
+						{
+							Version: 1,
+							Status: models.MicroVMStatus{
+								State: models.CreatedState,
+							},
+						},
+					},
+					nil,
+				)
+			},
 		},
 		{
 			name:        "error from usecase should fail with error",