Skip to content

Commit

Permalink
satellite/accounting: use single call to get project limits
Browse files Browse the repository at this point in the history 
segment and usage limits now taken by single call

Closes storj/team-metainfo#124

Change-Id: I55e05e199d2575cb8d985f4d75ba061002c97f0f
  • Loading branch information
@Qweder93
Qweder93 authored and Storj Robot committed Sep 13, 2022
1 parent 601cadb commit 04411e6
Show file tree
Hide file tree
Showing 3 changed files with 31 additions and 78 deletions.
29 changes: 0 additions & 29 deletions satellite/accounting/projectlimitcache.go
View file
Expand Up @@ -98,20 +98,6 @@ func (c *ProjectLimitCache) Get(ctx context.Context, projectID uuid.UUID) (Proje
return limits, nil
}

// GetProjectStorageLimit returns the storage usage limit for a project ID.
func (c *ProjectLimitCache) GetProjectStorageLimit(ctx context.Context, projectID uuid.UUID) (_ memory.Size, err error) {
defer mon.Task()(&ctx)(&err)
projectLimits, err := c.Get(ctx, projectID)
if err != nil {
return 0, err
}
if projectLimits.Usage == nil {
return c.defaultMaxUsage, nil
}
return memory.Size(*projectLimits.Usage), nil

}

// GetProjectBandwidthLimit return the bandwidth usage limit for a project ID.
func (c *ProjectLimitCache) GetProjectBandwidthLimit(ctx context.Context, projectID uuid.UUID) (_ memory.Size, err error) {
defer mon.Task()(&ctx)(&err)
Expand All @@ -124,18 +110,3 @@ func (c *ProjectLimitCache) GetProjectBandwidthLimit(ctx context.Context, projec
}
return memory.Size(*projectLimits.Bandwidth), nil
}

// GetProjectSegmentLimit returns the segment limit for a project ID.
func (c *ProjectLimitCache) GetProjectSegmentLimit(ctx context.Context, projectID uuid.UUID) (_ int64, err error) {
defer mon.Task()(&ctx)(&err)
projectLimits, err := c.Get(ctx, projectID)
if err != nil {
return 0, err
}

if projectLimits.Segments == nil {
return c.defaultMaxSegments, nil
}

return *projectLimits.Segments, nil
}
52 changes: 17 additions & 35 deletions satellite/accounting/projectlimitcache_test.go
View file
Expand Up @@ -10,7 +10,6 @@ import (
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"

"storj.io/common/memory"
"storj.io/common/testcontext"
"storj.io/common/testrand"
"storj.io/common/uuid"
Expand Down Expand Up @@ -86,31 +85,21 @@ func TestProjectLimitCache(t *testing.T) {
assert.Equal(t, accounting.ProjectLimits{}, actualLimitsFromDB)

// storage
actualStorageLimitFromCache, err := projectLimitCache.GetProjectStorageLimit(ctx, projectID)
_, err = projectLimitCache.GetProjectLimits(ctx, projectID)
assert.Error(t, err)
assert.Equal(t, memory.Size(errorLimit), actualStorageLimitFromCache)

actualStorageLimitFromSvc, err := projectUsageSvc.GetProjectStorageLimit(ctx, projectID)
assert.Error(t, err)
assert.Equal(t, memory.Size(errorLimit), actualStorageLimitFromSvc)
assert.EqualValues(t, errorLimit, actualStorageLimitFromSvc)

// bandwidth
actualBandwidthLimitFromCache, err := projectLimitCache.GetProjectBandwidthLimit(ctx, projectID)
assert.Error(t, err)
assert.Equal(t, memory.Size(errorLimit), actualBandwidthLimitFromCache)
assert.EqualValues(t, errorLimit, actualBandwidthLimitFromCache)

actualBandwidthLimitFromSvc, err := projectUsageSvc.GetProjectBandwidthLimit(ctx, projectID)
assert.Error(t, err)
assert.Equal(t, memory.Size(errorLimit), actualBandwidthLimitFromSvc)

// segments
actualSegmentLimitFromCache, err := projectLimitCache.GetProjectSegmentLimit(ctx, projectID)
assert.Error(t, err)
assert.EqualValues(t, errorLimit, actualSegmentLimitFromCache)

actualSegmentLimitFromSvc, err := projectUsageSvc.GetProjectSegmentLimit(ctx, projectID)
assert.Error(t, err)
assert.EqualValues(t, errorLimit, actualSegmentLimitFromSvc)
assert.EqualValues(t, errorLimit, actualBandwidthLimitFromSvc)
})

t.Run("default limits", func(t *testing.T) {
Expand All @@ -128,25 +117,25 @@ func TestProjectLimitCache(t *testing.T) {
assert.NoError(t, err)
assert.Nil(t, actualStorageLimitFromDB)

actualStorageLimitFromCache, err := projectLimitCache.GetProjectStorageLimit(ctx, testProject.ID)
actualLimitFromCache, err := projectLimitCache.GetProjectLimits(ctx, testProject.ID)
assert.NoError(t, err)
assert.Equal(t, memory.Size(*dbDefaultLimits.Usage), actualStorageLimitFromCache)
assert.EqualValues(t, *dbDefaultLimits.Usage, *actualLimitFromCache.Usage)

actualStorageLimitFromSvc, err := projectUsageSvc.GetProjectStorageLimit(ctx, testProject.ID)
assert.NoError(t, err)
assert.Equal(t, memory.Size(*dbDefaultLimits.Usage), actualStorageLimitFromSvc)
assert.EqualValues(t, *dbDefaultLimits.Usage, actualStorageLimitFromSvc)

actualBandwidthLimitFromDB, err := accountingDB.GetProjectBandwidthLimit(ctx, testProject.ID)
assert.NoError(t, err)
assert.Nil(t, actualBandwidthLimitFromDB)

actualBandwidthLimitFromCache, err := projectLimitCache.GetProjectBandwidthLimit(ctx, testProject.ID)
assert.NoError(t, err)
assert.Equal(t, memory.Size(*dbDefaultLimits.Bandwidth), actualBandwidthLimitFromCache)
assert.EqualValues(t, *dbDefaultLimits.Bandwidth, actualBandwidthLimitFromCache)

actualBandwidthLimitFromSvc, err := projectUsageSvc.GetProjectBandwidthLimit(ctx, testProject.ID)
assert.NoError(t, err)
assert.Equal(t, memory.Size(*dbDefaultLimits.Bandwidth), actualBandwidthLimitFromSvc)
assert.EqualValues(t, *dbDefaultLimits.Bandwidth, actualBandwidthLimitFromSvc)
})

t.Run("update limits in the database", func(t *testing.T) {
Expand All @@ -159,7 +148,7 @@ func TestProjectLimitCache(t *testing.T) {

actualStorageLimitFromDB, err := accountingDB.GetProjectStorageLimit(ctx, testProject.ID)
assert.NoError(t, err)
require.Equal(t, int64(expectedUsageLimit), *actualStorageLimitFromDB)
require.EqualValues(t, expectedUsageLimit, *actualStorageLimitFromDB)

actualLimitsFromDB, err := accountingDB.GetProjectLimits(ctx, testProject.ID)
assert.NoError(t, err)
Expand All @@ -169,39 +158,32 @@ func TestProjectLimitCache(t *testing.T) {
assert.Equal(t, accounting.ProjectLimits{Usage: &usageLimits, Bandwidth: &bwLimits, Segments: &segmentsLimits}, actualLimitsFromDB)

// storage
actualStorageLimitFromCache, err := projectLimitCache.GetProjectStorageLimit(ctx, testProject.ID)
actualLimitFromCache, err := projectLimitCache.GetProjectLimits(ctx, testProject.ID)
assert.NoError(t, err)
require.Equal(t, memory.Size(expectedUsageLimit), actualStorageLimitFromCache)
require.EqualValues(t, expectedUsageLimit, *actualLimitFromCache.Usage)
require.EqualValues(t, expectedSegmentLimit, *actualLimitFromCache.Segments)

actualStorageLimitFromSvc, err := projectUsageSvc.GetProjectStorageLimit(ctx, testProject.ID)
assert.NoError(t, err)
require.Equal(t, memory.Size(expectedUsageLimit), actualStorageLimitFromSvc)
require.EqualValues(t, expectedUsageLimit, actualStorageLimitFromSvc)

// bandwidth
actualBandwidthLimitFromDB, err := accountingDB.GetProjectBandwidthLimit(ctx, testProject.ID)
require.NoError(t, err)
require.Equal(t, int64(expectedBandwidthLimit), *actualBandwidthLimitFromDB)
require.EqualValues(t, expectedBandwidthLimit, *actualBandwidthLimitFromDB)

actualBandwidthLimitFromCache, err := projectLimitCache.GetProjectBandwidthLimit(ctx, testProject.ID)
assert.NoError(t, err)
require.Equal(t, memory.Size(expectedBandwidthLimit), actualBandwidthLimitFromCache)
require.EqualValues(t, expectedBandwidthLimit, actualBandwidthLimitFromCache)

actualBandwidthLimitFromSvc, err := projectUsageSvc.GetProjectBandwidthLimit(ctx, testProject.ID)
assert.NoError(t, err)
require.Equal(t, memory.Size(expectedBandwidthLimit), actualBandwidthLimitFromSvc)
require.EqualValues(t, expectedBandwidthLimit, actualBandwidthLimitFromSvc)

// segments
actualSegmentLimitFromDB, err := accountingDB.GetProjectSegmentLimit(ctx, testProject.ID)
require.NoError(t, err)
require.EqualValues(t, expectedSegmentLimit, *actualSegmentLimitFromDB)

actualSegmentLimitFromCache, err := projectLimitCache.GetProjectSegmentLimit(ctx, testProject.ID)
assert.NoError(t, err)
require.EqualValues(t, expectedSegmentLimit, actualSegmentLimitFromCache)

actualSegmentLimitFromSvc, err := projectUsageSvc.GetProjectSegmentLimit(ctx, testProject.ID)
assert.NoError(t, err)
require.EqualValues(t, expectedSegmentLimit, actualSegmentLimitFromSvc)
})
})
}
28 changes: 14 additions & 14 deletions satellite/accounting/projectusage.go
View file
Expand Up @@ -128,9 +128,15 @@ func (usage *Service) ExceedsUploadLimits(

group.Go(func() error {
var err error
limit.SegmentsLimit, err = usage.projectLimitCache.GetProjectSegmentLimit(ctx, projectID)
return err
limits, err := usage.projectLimitCache.GetProjectLimits(ctx, projectID)
if err != nil {
return err
}
limit.SegmentsLimit = *limits.Segments
limit.StorageLimit = memory.Size(*limits.Usage)
return nil
})

group.Go(func() error {
var err error
segmentUsage, err = usage.liveAccounting.GetProjectSegmentUsage(ctx, projectID)
Expand All @@ -141,11 +147,6 @@ func (usage *Service) ExceedsUploadLimits(
return err
})

group.Go(func() error {
var err error
limit.StorageLimit, err = usage.projectLimitCache.GetProjectStorageLimit(ctx, projectID)
return err
})
group.Go(func() error {
var err error
storageUsage, err = usage.GetProjectStorageTotals(ctx, projectID)
Expand Down Expand Up @@ -228,7 +229,12 @@ func (usage *Service) GetProjectBandwidth(ctx context.Context, projectID uuid.UU
// GetProjectStorageLimit returns current project storage limit.
func (usage *Service) GetProjectStorageLimit(ctx context.Context, projectID uuid.UUID) (_ memory.Size, err error) {
defer mon.Task()(&ctx, projectID)(&err)
return usage.projectLimitCache.GetProjectStorageLimit(ctx, projectID)
limits, err := usage.projectLimitCache.GetProjectLimits(ctx, projectID)
if err != nil {
return 0, ErrProjectUsage.Wrap(err)
}

return memory.Size(*limits.Usage), nil
}

// GetProjectBandwidthLimit returns current project bandwidth limit.
Expand All @@ -237,12 +243,6 @@ func (usage *Service) GetProjectBandwidthLimit(ctx context.Context, projectID uu
return usage.projectLimitCache.GetProjectBandwidthLimit(ctx, projectID)
}

// GetProjectSegmentLimit returns current project segment limit.
func (usage *Service) GetProjectSegmentLimit(ctx context.Context, projectID uuid.UUID) (_ int64, err error) {
defer mon.Task()(&ctx, projectID)(&err)
return usage.projectLimitCache.GetProjectSegmentLimit(ctx, projectID)
}

// UpdateProjectLimits sets new value for project's bandwidth and storage limit.
// TODO remove because it's not used.
func (usage *Service) UpdateProjectLimits(ctx context.Context, projectID uuid.UUID, limit memory.Size) (err error) {
Expand Down

0 comments on commit 04411e6

Please sign in to comment.