Upstream/harbor
1
0
Fork 0
mirror of https://github.com/goharbor/harbor.git synced 2024-07-05 19:26:23 +02:00
Code Issues Projects Releases Wiki Activity

fix retention rule compute error (#8664)

Browse Source 
Change-Id: I16d7284b17508885e136f2d9ea5651978ba4a6d8
Signed-off-by: Ziming Zhang <zziming@vmware.com>
This commit is contained in:
Ziming 2019-08-15 20:12:59 +08:00 committed by GitHub
parent 98ca45c93a
commit c279b7f3e9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 49 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/core/api/retention.go
View File

@ -67,7 +67,7 @@ func (r *RetentionAPI) GetMetadatas() {
] ]
}, },
{ {
"rule_template": "dayspl", "rule_template": "nDaysSinceLastPull",
"display_text": "pulled within the last # days", "display_text": "pulled within the last # days",
"action": "retain", "action": "retain",
"params": [ "params": [
@ -79,7 +79,7 @@ func (r *RetentionAPI) GetMetadatas() {
] ]
}, },
{ {
"rule_template": "daysps", "rule_template": "nDaysSinceLastPush",
"display_text": "pushed within the last # days", "display_text": "pushed within the last # days",
"action": "retain", "action": "retain",
"params": [ "params": [

7
src/pkg/retention/policy/rule/dayspl/evaluator.go
View File

@ -58,12 +58,13 @@ func (e *evaluator) Action() string {
func New(params rule.Parameters) rule.Evaluator { func New(params rule.Parameters) rule.Evaluator {
if params != nil { if params != nil {
if p, ok := params[ParameterN]; ok { if p, ok := params[ParameterN]; ok {
if v, ok := p.(int); ok && v >= 0 { if v, ok := p.(float64); ok && v >= 0 {
return &evaluator{n: v} return &evaluator{n: int(v)}
} }
} }
} }
log.Debugf("default parameter %d used for rule %s", DefaultN, TemplateID) log.Warningf("default parameter %d used for rule %s", DefaultN, TemplateID)
return &evaluator{n: DefaultN} return &evaluator{n: DefaultN}
} }

10
src/pkg/retention/policy/rule/dayspl/evaluator_test.go
View File

@ -15,7 +15,7 @@
package dayspl package dayspl
import ( import (
"strconv" "fmt"
"testing" "testing"
"time" "time"
@ -36,8 +36,8 @@ func (e *EvaluatorTestSuite) TestNew() {
args rule.Parameters args rule.Parameters
expectedN int expectedN int
}{ }{
{Name: "Valid", args: map[string]rule.Parameter{ParameterN: 5}, expectedN: 5}, {Name: "Valid", args: map[string]rule.Parameter{ParameterN: float64(5)}, expectedN: 5},
{Name: "Default If Negative", args: map[string]rule.Parameter{ParameterN: -1}, expectedN: DefaultN}, {Name: "Default If Negative", args: map[string]rule.Parameter{ParameterN: float64(-1)}, expectedN: DefaultN},
{Name: "Default If Not Set", args: map[string]rule.Parameter{}, expectedN: DefaultN}, {Name: "Default If Not Set", args: map[string]rule.Parameter{}, expectedN: DefaultN},
{Name: "Default If Wrong Type", args: map[string]rule.Parameter{ParameterN: "foo"}, expectedN: DefaultN}, {Name: "Default If Wrong Type", args: map[string]rule.Parameter{ParameterN: "foo"}, expectedN: DefaultN},
} }
@ -65,7 +65,7 @@ func (e *EvaluatorTestSuite) TestProcess() {
} }
tests := []struct { tests := []struct {
n int n float64
expected int expected int
minPullTime int64 minPullTime int64
}{ }{
@ -80,7 +80,7 @@ func (e *EvaluatorTestSuite) TestProcess() {
} }
for _, tt := range tests { for _, tt := range tests {
e.T().Run(strconv.Itoa(tt.n), func(t *testing.T) { e.T().Run(fmt.Sprintf("%v", tt.n), func(t *testing.T) {
sut := New(map[string]rule.Parameter{ParameterN: tt.n}) sut := New(map[string]rule.Parameter{ParameterN: tt.n})
result, err := sut.Process(data) result, err := sut.Process(data)

7
src/pkg/retention/policy/rule/daysps/evaluator.go
View File

@ -58,12 +58,13 @@ func (e *evaluator) Action() string {
func New(params rule.Parameters) rule.Evaluator { func New(params rule.Parameters) rule.Evaluator {
if params != nil { if params != nil {
if p, ok := params[ParameterN]; ok { if p, ok := params[ParameterN]; ok {
if v, ok := p.(int); ok && v >= 0 { if v, ok := p.(float64); ok && v >= 0 {
return &evaluator{n: v} return &evaluator{n: int(v)}
} }
} }
} }
log.Debugf("default parameter %d used for rule %s", DefaultN, TemplateID) log.Warningf("default parameter %d used for rule %s", DefaultN, TemplateID)
return &evaluator{n: DefaultN} return &evaluator{n: DefaultN}
} }

10
src/pkg/retention/policy/rule/daysps/evaluator_test.go
View File

@ -15,7 +15,7 @@
package daysps package daysps
import ( import (
"strconv" "fmt"
"testing" "testing"
"time" "time"
@ -36,8 +36,8 @@ func (e *EvaluatorTestSuite) TestNew() {
args rule.Parameters args rule.Parameters
expectedN int expectedN int
}{ }{
{Name: "Valid", args: map[string]rule.Parameter{ParameterN: 5}, expectedN: 5}, {Name: "Valid", args: map[string]rule.Parameter{ParameterN: float64(5)}, expectedN: 5},
{Name: "Default If Negative", args: map[string]rule.Parameter{ParameterN: -1}, expectedN: DefaultN}, {Name: "Default If Negative", args: map[string]rule.Parameter{ParameterN: float64(-1)}, expectedN: DefaultN},
{Name: "Default If Not Set", args: map[string]rule.Parameter{}, expectedN: DefaultN}, {Name: "Default If Not Set", args: map[string]rule.Parameter{}, expectedN: DefaultN},
{Name: "Default If Wrong Type", args: map[string]rule.Parameter{ParameterN: "foo"}, expectedN: DefaultN}, {Name: "Default If Wrong Type", args: map[string]rule.Parameter{ParameterN: "foo"}, expectedN: DefaultN},
} }
@ -65,7 +65,7 @@ func (e *EvaluatorTestSuite) TestProcess() {
} }
tests := []struct { tests := []struct {
n int n float64
expected int expected int
minPushTime int64 minPushTime int64
}{ }{
@ -80,7 +80,7 @@ func (e *EvaluatorTestSuite) TestProcess() {
} }
for _, tt := range tests { for _, tt := range tests {
e.T().Run(strconv.Itoa(tt.n), func(t *testing.T) { e.T().Run(fmt.Sprintf("%v", tt.n), func(t *testing.T) {
sut := New(map[string]rule.Parameter{ParameterN: tt.n}) sut := New(map[string]rule.Parameter{ParameterN: tt.n})
result, err := sut.Process(data) result, err := sut.Process(data)

6
src/pkg/retention/policy/rule/lastx/evaluator.go
View File

@ -59,15 +59,15 @@ func (e *evaluator) Action() string {
func New(params rule.Parameters) rule.Evaluator { func New(params rule.Parameters) rule.Evaluator {
if params != nil { if params != nil {
if param, ok := params[ParameterX]; ok { if param, ok := params[ParameterX]; ok {
if v, ok := param.(int); ok && v >= 0 { if v, ok := param.(float64); ok && v >= 0 {
return &evaluator{ return &evaluator{
x: v, x: int(v),
} }
} }
} }
} }
log.Debugf("default parameter %d used for rule %s", DefaultX, TemplateID) log.Warningf("default parameter %d used for rule %s", DefaultX, TemplateID)
return &evaluator{ return &evaluator{
x: DefaultX, x: DefaultX,

8
src/pkg/retention/policy/rule/lastx/evaluator_test.go
View File

@ -21,8 +21,8 @@ func (e *EvaluatorTestSuite) TestNew() {
args rule.Parameters args rule.Parameters
expectedX int expectedX int
}{ }{
{Name: "Valid", args: map[string]rule.Parameter{ParameterX: 3}, expectedX: 3}, {Name: "Valid", args: map[string]rule.Parameter{ParameterX: float64(3)}, expectedX: 3},
{Name: "Default If Negative", args: map[string]rule.Parameter{ParameterX: -3}, expectedX: DefaultX}, {Name: "Default If Negative", args: map[string]rule.Parameter{ParameterX: float64(-3)}, expectedX: DefaultX},
{Name: "Default If Not Set", args: map[string]rule.Parameter{}, expectedX: DefaultX}, {Name: "Default If Not Set", args: map[string]rule.Parameter{}, expectedX: DefaultX},
{Name: "Default If Wrong Type", args: map[string]rule.Parameter{}, expectedX: DefaultX}, {Name: "Default If Wrong Type", args: map[string]rule.Parameter{}, expectedX: DefaultX},
} }
@ -48,7 +48,7 @@ func (e *EvaluatorTestSuite) TestProcess() {
} }
tests := []struct { tests := []struct {
days int days float64
expected int expected int
}{ }{
{days: 0, expected: 0}, {days: 0, expected: 0},
@ -62,7 +62,7 @@ func (e *EvaluatorTestSuite) TestProcess() {
} }
for _, tt := range tests { for _, tt := range tests {
e.T().Run(fmt.Sprintf("%d days - should keep %d", tt.days, tt.expected), func(t *testing.T) { e.T().Run(fmt.Sprintf("%v days - should keep %d", tt.days, tt.expected), func(t *testing.T) {
e := New(rule.Parameters{ParameterX: tt.days}) e := New(rule.Parameters{ParameterX: tt.days})
result, err := e.Process(data) result, err := e.Process(data)

4
src/pkg/retention/policy/rule/latestk/evaluator.go
View File

@ -65,9 +65,9 @@ func (e *evaluator) Action() string {
func New(params rule.Parameters) rule.Evaluator { func New(params rule.Parameters) rule.Evaluator {
if params != nil { if params != nil {
if param, ok := params[ParameterK]; ok { if param, ok := params[ParameterK]; ok {
if v, ok := param.(int); ok && v >= 0 { if v, ok := param.(float64); ok && v >= 0 {
return &evaluator{ return &evaluator{
k: v, k: int(v),
} }
} }
} }

8
src/pkg/retention/policy/rule/latestk/evaluator_test.go
View File

@ -15,7 +15,7 @@
package latestk package latestk
import ( import (
"strconv" "fmt"
"testing" "testing"
"github.com/goharbor/harbor/src/pkg/retention/policy/rule" "github.com/goharbor/harbor/src/pkg/retention/policy/rule"
@ -58,7 +58,7 @@ func (e *EvaluatorTestSuite) TestProcess() {
{k: 99, expected: len(e.artifacts)}, {k: 99, expected: len(e.artifacts)},
} }
for _, tt := range tests { for _, tt := range tests {
e.T().Run(strconv.Itoa(tt.k), func(t *testing.T) { e.T().Run(fmt.Sprintf("%v", tt.k), func(t *testing.T) {
sut := &evaluator{k: tt.k} sut := &evaluator{k: tt.k}
result, err := sut.Process(e.artifacts) result, err := sut.Process(e.artifacts)
@ -79,8 +79,8 @@ func (e *EvaluatorTestSuite) TestNew() {
params rule.Parameters params rule.Parameters
expectedK int expectedK int
}{ }{
{name: "Valid", params: rule.Parameters{ParameterK: 5}, expectedK: 5}, {name: "Valid", params: rule.Parameters{ParameterK: float64(5)}, expectedK: 5},
{name: "Default If Negative", params: rule.Parameters{ParameterK: -5}, expectedK: DefaultK}, {name: "Default If Negative", params: rule.Parameters{ParameterK: float64(-5)}, expectedK: DefaultK},
{name: "Default If Wrong Type", params: rule.Parameters{ParameterK: "5"}, expectedK: DefaultK}, {name: "Default If Wrong Type", params: rule.Parameters{ParameterK: "5"}, expectedK: DefaultK},
{name: "Default If Wrong Key", params: rule.Parameters{"n": 5}, expectedK: DefaultK}, {name: "Default If Wrong Key", params: rule.Parameters{"n": 5}, expectedK: DefaultK},
{name: "Default If Empty", params: rule.Parameters{}, expectedK: DefaultK}, {name: "Default If Empty", params: rule.Parameters{}, expectedK: DefaultK},

6
src/pkg/retention/policy/rule/latestpl/evaluator.go
View File

@ -59,13 +59,13 @@ func (e *evaluator) Action() string {
func New(params rule.Parameters) rule.Evaluator { func New(params rule.Parameters) rule.Evaluator {
if params != nil { if params != nil {
if p, ok := params[ParameterN]; ok { if p, ok := params[ParameterN]; ok {
if v, ok := p.(int); ok && v >= 0 { if v, ok := p.(float64); ok && v >= 0 {
return &evaluator{n: v} return &evaluator{n: int(v)}
} }
} }
} }
log.Debugf("default parameter %d used for rule %s", DefaultN, TemplateID) log.Warningf("default parameter %d used for rule %s", DefaultN, TemplateID)
return &evaluator{n: DefaultN} return &evaluator{n: DefaultN}
} }

10
src/pkg/retention/policy/rule/latestpl/evaluator_test.go
View File

@ -15,8 +15,8 @@
package latestpl package latestpl
import ( import (
"fmt"
"math/rand" "math/rand"
"strconv"
"testing" "testing"
"github.com/goharbor/harbor/src/pkg/retention/policy/rule" "github.com/goharbor/harbor/src/pkg/retention/policy/rule"
@ -35,8 +35,8 @@ func (e *EvaluatorTestSuite) TestNew() {
args rule.Parameters args rule.Parameters
expectedK int expectedK int
}{ }{
{Name: "Valid", args: map[string]rule.Parameter{ParameterN: 5}, expectedK: 5}, {Name: "Valid", args: map[string]rule.Parameter{ParameterN: float64(5)}, expectedK: 5},
{Name: "Default If Negative", args: map[string]rule.Parameter{ParameterN: -1}, expectedK: DefaultN}, {Name: "Default If Negative", args: map[string]rule.Parameter{ParameterN: float64(-1)}, expectedK: DefaultN},
{Name: "Default If Not Set", args: map[string]rule.Parameter{}, expectedK: DefaultN}, {Name: "Default If Not Set", args: map[string]rule.Parameter{}, expectedK: DefaultN},
{Name: "Default If Wrong Type", args: map[string]rule.Parameter{ParameterN: "foo"}, expectedK: DefaultN}, {Name: "Default If Wrong Type", args: map[string]rule.Parameter{ParameterN: "foo"}, expectedK: DefaultN},
} }
@ -57,7 +57,7 @@ func (e *EvaluatorTestSuite) TestProcess() {
}) })
tests := []struct { tests := []struct {
n int n float64
expected int expected int
minPullTime int64 minPullTime int64
}{ }{
@ -69,7 +69,7 @@ func (e *EvaluatorTestSuite) TestProcess() {
} }
for _, tt := range tests { for _, tt := range tests {
e.T().Run(strconv.Itoa(tt.n), func(t *testing.T) { e.T().Run(fmt.Sprintf("%v", tt.n), func(t *testing.T) {
ev := New(map[string]rule.Parameter{ParameterN: tt.n}) ev := New(map[string]rule.Parameter{ParameterN: tt.n})
result, err := ev.Process(data) result, err := ev.Process(data)

6
src/pkg/retention/policy/rule/latestps/evaluator.go
View File

@ -62,15 +62,15 @@ func (e *evaluator) Action() string {
func New(params rule.Parameters) rule.Evaluator { func New(params rule.Parameters) rule.Evaluator {
if params != nil { if params != nil {
if param, ok := params[ParameterK]; ok { if param, ok := params[ParameterK]; ok {
if v, ok := param.(int); ok && v >= 0 { if v, ok := param.(float64); ok && v >= 0 {
return &evaluator{ return &evaluator{
k: v, k: int(v),
} }
} }
} }
} }
log.Debugf("default parameter %d used for rule %s", DefaultK, TemplateID) log.Warningf("default parameter %d used for rule %s", DefaultK, TemplateID)
return &evaluator{ return &evaluator{
k: DefaultK, k: DefaultK,

10
src/pkg/retention/policy/rule/latestps/evaluator_test.go
View File

@ -1,8 +1,8 @@
package latestps package latestps
import ( import (
"fmt"
"math/rand" "math/rand"
"strconv"
"testing" "testing"
"github.com/stretchr/testify/suite" "github.com/stretchr/testify/suite"
@ -22,8 +22,8 @@ func (e *EvaluatorTestSuite) TestNew() {
args rule.Parameters args rule.Parameters
expectedK int expectedK int
}{ }{
{Name: "Valid", args: map[string]rule.Parameter{ParameterK: 5}, expectedK: 5}, {Name: "Valid", args: map[string]rule.Parameter{ParameterK: float64(5)}, expectedK: 5},
{Name: "Default If Negative", args: map[string]rule.Parameter{ParameterK: -1}, expectedK: DefaultK}, {Name: "Default If Negative", args: map[string]rule.Parameter{ParameterK: float64(-1)}, expectedK: DefaultK},
{Name: "Default If Not Set", args: map[string]rule.Parameter{}, expectedK: DefaultK}, {Name: "Default If Not Set", args: map[string]rule.Parameter{}, expectedK: DefaultK},
{Name: "Default If Wrong Type", args: map[string]rule.Parameter{ParameterK: "foo"}, expectedK: DefaultK}, {Name: "Default If Wrong Type", args: map[string]rule.Parameter{ParameterK: "foo"}, expectedK: DefaultK},
} }
@ -44,7 +44,7 @@ func (e *EvaluatorTestSuite) TestProcess() {
}) })
tests := []struct { tests := []struct {
k int k float64
expected int expected int
}{ }{
{k: 0, expected: 0}, {k: 0, expected: 0},
@ -55,7 +55,7 @@ func (e *EvaluatorTestSuite) TestProcess() {
} }
for _, tt := range tests { for _, tt := range tests {
e.T().Run(strconv.Itoa(tt.k), func(t *testing.T) { e.T().Run(fmt.Sprintf("%v", tt.k), func(t *testing.T) {
e := New(map[string]rule.Parameter{ParameterK: tt.k}) e := New(map[string]rule.Parameter{ParameterK: tt.k})
result, err := e.Process(data) result, err := e.Process(data)