diff --git a/commands/clean.go b/commands/clean.go index da95d1f2f..25b9bbac5 100644 --- a/commands/clean.go +++ b/commands/clean.go @@ -100,6 +100,12 @@ var CleanCommand = cli.Command{ logger.Error("getting-unused-volumes-size", err) } metricsEmitter.TryEmitUsage(logger, "UnusedLayersSize", unusedVolumesSize, "bytes") + + usedVolumesSize, err := sm.UsedVolumesSize(logger) + if err != nil { + logger.Error("getting-used-volumes-size", err) + } + metricsEmitter.TryEmitUsage(logger, "UsedLayersSize", usedVolumesSize, "bytes") }() noop, err := cleaner.Clean(logger, cfg.Clean.ThresholdBytes) diff --git a/commands/create.go b/commands/create.go index 0022461c7..25c86ada2 100644 --- a/commands/create.go +++ b/commands/create.go @@ -253,19 +253,25 @@ var CreateCommand = cli.Command{ } fmt.Println(string(jsonBytes)) - emitMetrics(logger, metricsEmitter, sm, cfg.Create.WithClean) + emitMetrics(logger, metricsEmitter, sm, cfg.Create.WithClean, storePath) return nil }, } -func emitMetrics(logger lager.Logger, metricsEmitter *metrics.Emitter, sm *storepkg.StoreMeasurer, cleanOnCreate bool) { +func emitMetrics(logger lager.Logger, metricsEmitter *metrics.Emitter, sm *storepkg.StoreMeasurer, cleanOnCreate bool, storePath string) { if !cleanOnCreate { unusedVolumesSize, err := sm.UnusedVolumesSize(logger) if err != nil { logger.Info(fmt.Sprintf("getting-unused-layers-size: %s", err)) } metricsEmitter.TryEmitUsage(logger, "UnusedLayersSize", unusedVolumesSize, "bytes") + + usedVolumesSize, err := sm.UsedVolumesSize(logger) + if err != nil { + logger.Info(fmt.Sprintf("getting-used-layers-size: %s", err)) + } + metricsEmitter.TryEmitUsage(logger, "UsedLayersSize", usedVolumesSize, "bytes") } totalVolumesSize, err := sm.TotalVolumesSize(logger) @@ -279,6 +285,12 @@ func emitMetrics(logger lager.Logger, metricsEmitter *metrics.Emitter, sm *store logger.Info(fmt.Sprintf("getting-commited-quota: %s", err)) } metricsEmitter.TryEmitUsage(logger, "CommittedQuotaInBytes", commitedQuota, "bytes") + + _, usedBackingStore, err := sm.PathStats(storePath) + if err != nil { + logger.Info(fmt.Sprintf("getting-store-stats: %s", err)) + } + metricsEmitter.TryEmitUsage(logger, "UsedBackingStoreInBytes", usedBackingStore, "bytes") } func createFetcher(baseImageUrl *url.URL, systemContext types.SystemContext, createCfg config.Create) base_image_puller.Fetcher { diff --git a/commands/delete.go b/commands/delete.go index c48abc10f..1cb8b36d7 100644 --- a/commands/delete.go +++ b/commands/delete.go @@ -82,6 +82,12 @@ var DeleteCommand = cli.Command{ logger.Error("getting-unused-layers-size", err) } metricsEmitter.TryEmitUsage(logger, "UnusedLayersSize", unusedVolumesSize, "bytes") + + usedVolumesSize, err := sm.UsedVolumesSize(logger) + if err != nil { + logger.Error("getting-used-layers-size", err) + } + metricsEmitter.TryEmitUsage(logger, "UsedLayersSize", usedVolumesSize, "bytes") }() err = deleter.Delete(logger, id) diff --git a/groot/cleaner.go b/groot/cleaner.go index 83f75ad8c..1995cd383 100644 --- a/groot/cleaner.go +++ b/groot/cleaner.go @@ -1,6 +1,7 @@ package groot import ( + "fmt" "time" "code.cloudfoundry.org/lager" @@ -42,10 +43,15 @@ func (c *cleaner) Clean(logger lager.Logger, threshold int64) (bool, error) { if err != nil { return false, errorspkg.Wrap(err, "failed to calculate committed quota") } + logger.Debug(fmt.Sprintf("commitedQuota in bytes is: %d", committedQuota)) + totalVolumesSize, err := c.storeMeasurer.TotalVolumesSize(logger) if err != nil { return false, errorspkg.Wrap(err, "failed to calculate total volumes size") } + logger.Debug(fmt.Sprintf("totalVolumesSize in bytes is: %d", totalVolumesSize)) + logger.Debug(fmt.Sprintf("threshold in bytes is: %d", threshold)) + if (committedQuota + totalVolumesSize) < threshold { return true, nil } diff --git a/store/measurer_linux.go b/store/measurer_linux.go index 807ebb070..af0f25e17 100644 --- a/store/measurer_linux.go +++ b/store/measurer_linux.go @@ -45,6 +45,20 @@ func (s *StoreMeasurer) UnusedVolumesSize(logger lager.Logger) (int64, error) { return s.countVolumesSize(logger, unusedVols) } +func (s *StoreMeasurer) UsedVolumesSize(logger lager.Logger) (int64, error) { + + totalVolumesSize, err := s.TotalVolumesSize(logger) + if err != nil { + return 0, err + } + unusedVolumesSize, err := s.UnusedVolumesSize(logger) + if err != nil { + return 0, err + } + usedVolumesSize := totalVolumesSize - unusedVolumesSize + return usedVolumesSize, nil +} + func (s *StoreMeasurer) TotalVolumesSize(logger lager.Logger) (int64, error) { vols, err := s.volumeDriver.Volumes(logger) if err != nil { @@ -114,7 +128,7 @@ func readImageQuota(imageDir string) (int64, error) { return imageQuota, nil } -func (s *StoreMeasurer) pathStats(path string) (totalBytes, UsedBytes int64, err error) { +func (s *StoreMeasurer) PathStats(path string) (totalBytes, UsedBytes int64, err error) { stats := syscall.Statfs_t{} if err = syscall.Statfs(s.storePath, &stats); err != nil { return 0, 0, errorspkg.Wrapf(err, "Invalid path %s", s.storePath) @@ -127,3 +141,5 @@ func (s *StoreMeasurer) pathStats(path string) (totalBytes, UsedBytes int64, err return int64(total), used, nil } + + diff --git a/store/measurer_linux_test.go b/store/measurer_linux_test.go index 8aab416e9..2adaab9ba 100644 --- a/store/measurer_linux_test.go +++ b/store/measurer_linux_test.go @@ -95,6 +95,42 @@ var _ = Describe("Measurer", func() { }) }) + Describe("UsedVolumesSize", func() { + BeforeEach(func() { + volumeDriver.VolumeSizeReturns(1024, nil) + unusedVolumeGetter.UnusedVolumesReturns([]string{"sha256:fake1", "sha256:fake2"}, nil) + volumeDriver.VolumesReturns([]string{"sha256:fake1", "sha256:fake2"}, nil) + }) + + It("measures the size of the used layers", func() { + cacheUsage, err := storeMeasurer.UsedVolumesSize(logger) + Expect(err).NotTo(HaveOccurred()) + Expect(cacheUsage).To(BeNumerically("==", 0)) + }) + + Context("when getting total volumes returns an error", func() { + BeforeEach(func() { + volumeDriver.VolumesReturns([]string{}, errors.New("failed here")) + }) + + It("returns the error", func() { + _, err := storeMeasurer.TotalVolumesSize(logger) + Expect(err).To(HaveOccurred()) + }) + }) + + Context("when getting unused volumes returns an error", func() { + BeforeEach(func() { + unusedVolumeGetter.UnusedVolumesReturns([]string{}, errors.New("failed here")) + }) + + It("returns the error", func() { + _, err := storeMeasurer.UnusedVolumesSize(logger) + Expect(err).To(HaveOccurred()) + }) + }) + }) + Describe("UnusedVolumeSize", func() { BeforeEach(func() { volumeDriver.VolumeSizeReturns(1024, nil)