add volumedriver filter for desiredlrps

Author: kart2bc

db/sqldb/desired_lrp_db.go

@@ -125,6 +125,11 @@ func (db *SQLDB) DesiredLRPs(ctx context.Context, logger lager.Logger, filter mo
 		values = append(values, filter.Domain)
 	}
 
+	if filter.VolumeMountDriver != "" {
+		wheres = append(wheres, "run_info LIKE ?")
+		values = append(values, "%\"Driver\"%\"%"+filter.VolumeMountDriver+"\"%")
+	}
+
 	if len(filter.ProcessGuids) > 0 {
 		wheres = append(wheres, whereClauseForProcessGuids(filter.ProcessGuids))
 

db/sqldb/desired_lrp_db_test.go

@@ -135,6 +135,35 @@ var _ = Describe("DesiredLRPDB", func() {
 			expectedDesiredLRPs = append(expectedDesiredLRPs, model_helpers.NewValidDesiredLRP("d-1"))
 			expectedDesiredLRPs = append(expectedDesiredLRPs, model_helpers.NewValidDesiredLRP("d-2"))
 			expectedDesiredLRPs = append(expectedDesiredLRPs, model_helpers.NewValidDesiredLRP("d-3"))
+			// Create LRP with multiple volume mounts (one matching, one not)
+			expectedDesiredLRPs[1].VolumeMounts = []*models.VolumeMount{
+				{
+					Driver:       "other-driver",
+					ContainerDir: "/mnt/other",
+					Mode:         "r",
+					Shared: &models.SharedDevice{
+						VolumeId: "vol-id-3",
+					},
+				},
+				{
+					Driver:       "test-driver",
+					ContainerDir: "/mnt/test2",
+					Mode:         "rw",
+					Shared: &models.SharedDevice{
+						VolumeId: "vol-id-4",
+					},
+				},
+				{
+					Driver:       "third-driver",
+					ContainerDir: "/mnt/third",
+					Mode:         "r",
+					Shared: &models.SharedDevice{
+						VolumeId: "vol-id-5",
+					},
+				},
+			}
+			// Create LRP with no volume mounts
+			expectedDesiredLRPs[2].VolumeMounts = []*models.VolumeMount{}
 			for i, expectedDesiredLRP := range expectedDesiredLRPs {
 				expectedDesiredLRP.Domain = fmt.Sprintf("domain-%d", i+1)
 				Expect(sqlDB.DesireLRP(ctx, logger, expectedDesiredLRP)).To(Succeed())
@@ -218,6 +247,57 @@ var _ = Describe("DesiredLRPDB", func() {
 			})
 		})
 
+		Context("when filtering by volume mount driver", func() {
+			FIt("returns LRPs that have a volume mount with matching driver", func() {
+				desiredLRPs, err := sqlDB.DesiredLRPs(ctx, logger, models.DesiredLRPFilter{VolumeMountDriver: "my-driver"})
+				Expect(err).NotTo(HaveOccurred())
+
+				Expect(desiredLRPs).To(HaveLen(1))
+				processGuids := []string{desiredLRPs[0].ProcessGuid}
+				Expect(processGuids).To(ContainElements("d-1"))
+			})
+
+			FIt("finds LRPs with matching driver among multiple volume mounts", func() {
+				desiredLRPs, err := sqlDB.DesiredLRPs(ctx, logger, models.DesiredLRPFilter{VolumeMountDriver: "third-driver"})
+				Expect(err).NotTo(HaveOccurred())
+
+				Expect(desiredLRPs).To(HaveLen(1))
+				Expect(desiredLRPs[0].ProcessGuid).To(Equal("d-2"))
+				Expect(desiredLRPs[0].VolumeMounts).To(HaveLen(3))
+			})
+
+			It("returns empty list when no LRPs have matching volume mount driver", func() {
+				desiredLRPs, err := sqlDB.DesiredLRPs(ctx, logger, models.DesiredLRPFilter{VolumeMountDriver: "non-existent-driver"})
+				Expect(err).NotTo(HaveOccurred())
+
+				Expect(desiredLRPs).To(HaveLen(0))
+			})
+
+			It("excludes LRPs with no volume mounts", func() {
+				desiredLRPs, err := sqlDB.DesiredLRPs(ctx, logger, models.DesiredLRPFilter{VolumeMountDriver: "test-driver"})
+				Expect(err).NotTo(HaveOccurred())
+
+				processGuids := make([]string, len(desiredLRPs))
+				for i, lrp := range desiredLRPs {
+					processGuids[i] = lrp.ProcessGuid
+				}
+				Expect(processGuids).NotTo(ContainElement("d-3"))
+			})
+
+			It("can combine volume mount driver filter with domain filter", func() {
+				desiredLRPs, err := sqlDB.DesiredLRPs(ctx, logger, models.DesiredLRPFilter{
+					Domain:            "domain-1",
+					VolumeMountDriver: "my-driver",
+				})
+				Expect(err).NotTo(HaveOccurred())
+
+				Expect(desiredLRPs).To(HaveLen(1))
+				for _, lrp := range desiredLRPs {
+					Expect(lrp.Domain).To(Equal("domain-1"))
+				}
+			})
+		})
+
 		Context("when the run info is invalid", func() {
 			BeforeEach(func() {
 				queryStr := "UPDATE desired_lrps SET run_info = ? WHERE process_guid = ?"

handlers/desired_lrp_handlers.go

@@ -75,7 +75,7 @@ func (h *DesiredLRPHandler) commonDesiredLRPs(logger lager.Logger, targetVersion
 
 	err = parseRequest(logger, req, request)
 	if err == nil {
-		filter := models.DesiredLRPFilter{Domain: request.Domain, ProcessGuids: request.ProcessGuids}
+		filter := models.DesiredLRPFilter{Domain: request.Domain, ProcessGuids: request.ProcessGuids, VolumeMountDriver: request.VolumeMountDriver}
 
 		var desiredLRPs []*models.DesiredLRP
 		desiredLRPs, err = h.desiredLRPDB.DesiredLRPs(req.Context(), logger, filter)

handlers/desired_lrp_handlers_test.go

@@ -343,6 +343,18 @@ var _ = Describe("DesiredLRP Handlers", func() {
 			})
 		})
 
+		Context("when filtering by volume mount driver", func() {
+			BeforeEach(func() {
+				requestBody = &models.DesiredLRPsRequest{VolumeMountDriver: "test-driver"}
+			})
+
+			It("passes the volume mount driver filter to the DB", func() {
+				Expect(fakeDesiredLRPDB.DesiredLRPsCallCount()).To(Equal(1))
+				_, _, filter := fakeDesiredLRPDB.DesiredLRPsArgsForCall(0)
+				Expect(filter.VolumeMountDriver).To(Equal("test-driver"))
+			})
+		})
+
 		Context("when the DB returns no desired lrps", func() {
 			BeforeEach(func() {
 				fakeDesiredLRPDB.DesiredLRPsReturns([]*models.DesiredLRP{}, nil)
@@ -700,6 +712,18 @@ var _ = Describe("DesiredLRP Handlers", func() {
 					Expect(filter.ProcessGuids).To(Equal([]string{"guid-1", "guid-2"}))
 				})
 			})
+
+			Context("when filtering by volume mount driver", func() {
+				BeforeEach(func() {
+					requestBody = &models.DesiredLRPsRequest{VolumeMountDriver: "test-driver"}
+				})
+
+				It("passes the volume mount driver filter to the DB", func() {
+					Expect(fakeDesiredLRPDB.DesiredLRPSchedulingInfosCallCount()).To(Equal(1))
+					_, _, filter := fakeDesiredLRPDB.DesiredLRPSchedulingInfosArgsForCall(0)
+					Expect(filter.VolumeMountDriver).To(Equal("test-driver"))
+				})
+			})
 		})
 
 		Context("when the DB returns no desired lrps", func() {

models/desired_lrp.go

@@ -24,8 +24,9 @@ type DesiredLRPChange struct {
 }
 
 type DesiredLRPFilter struct {
-	Domain       string
-	ProcessGuids []string
+	Domain            string
+	ProcessGuids      []string
+	VolumeMountDriver string
 }
 
 func PreloadedRootFS(stack string) string {

models/desired_lrp_requests.pb.go

@@ -18,6 +18,7 @@ message DesiredLRPsResponse {
 message DesiredLRPsRequest {
   string domain = 1 [(gogoproto.jsontag) = "domain"];
   repeated string process_guids = 2;
+  repeated string app_guids = 3;
 }
 
 message DesiredLRPResponse {

models/desired_lrp_requests.proto

@@ -1692,3 +1692,17 @@ func newValidLRPKey() models.DesiredLRPKey {
 func newValidResource() models.DesiredLRPResource {
 	return models.NewDesiredLRPResource(256, 256, 256, "preloaded://linux64")
 }
+
+var _ = Describe("DesiredLRPFilter", func() {
+	It("supports VolumeMountDriver field", func() {
+		filter := models.DesiredLRPFilter{
+			Domain:            "test-domain",
+			ProcessGuids:      []string{"guid-1", "guid-2"},
+			VolumeMountDriver: "test-driver",
+		}
+
+		Expect(filter.Domain).To(Equal("test-domain"))
+		Expect(filter.ProcessGuids).To(Equal([]string{"guid-1", "guid-2"}))
+		Expect(filter.VolumeMountDriver).To(Equal("test-driver"))
+	})
+})