Upstream/harbor
1
0
Fork 0
mirror of https://github.com/goharbor/harbor.git synced 2024-06-29 16:25:09 +02:00
Code Issues Projects Releases Wiki Activity

refactor immutable dao code to align the new structure under pkg

Browse Source 
1, add manager
2, move model dao to /pkg/dao

Signed-off-by: wang yan <wangyan@vmware.com>
This commit is contained in:
wang yan 2019-09-26 17:07:35 +08:00
parent cabe0b6243
commit 7c4fd79b5c
11 changed files with 515 additions and 266 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
src/common/dao/immutable.go
View File

@ -1,74 +0,0 @@
package dao
import (
"fmt"
"github.com/astaxie/beego/orm"
"github.com/goharbor/harbor/src/common/models"
)
// CreateImmutableRule creates the Immutable Rule
func CreateImmutableRule(ir *models.ImmutableRule) (int64, error) {
ir.Enabled = true
o := GetOrmer()
return o.Insert(ir)
}
// UpdateImmutableRule update the immutable rules
func UpdateImmutableRule(projectID int64, ir *models.ImmutableRule) (int64, error) {
ir.ProjectID = projectID
o := GetOrmer()
return o.Update(ir, "TagFilter")
}
// ToggleImmutableRule enable/disable immutable rules
func ToggleImmutableRule(id int64, enabled bool) (int64, error) {
o := GetOrmer()
ir := &models.ImmutableRule{ID: id, Enabled: enabled}
return o.Update(ir, "Enabled")
}
// GetImmutableRule get immutable rule
func GetImmutableRule(id int64) (*models.ImmutableRule, error) {
o := GetOrmer()
ir := &models.ImmutableRule{ID: id}
err := o.Read(ir)
if err == orm.ErrNoRows {
return nil, nil
}
if err != nil {
return nil, err
}
return ir, nil
}
// QueryImmutableRuleByProjectID get all immutable rule by project
func QueryImmutableRuleByProjectID(projectID int64) ([]models.ImmutableRule, error) {
o := GetOrmer()
qs := o.QueryTable(&models.ImmutableRule{}).Filter("ProjectID", projectID)
var r []models.ImmutableRule
_, err := qs.All(&r)
if err != nil {
return nil, fmt.Errorf("failed to get immutable tag rule by projectID %d, error: %v", projectID, err)
}
return r, nil
}
// QueryEnabledImmutableRuleByProjectID get all enabled immutable rule by project
func QueryEnabledImmutableRuleByProjectID(projectID int64) ([]models.ImmutableRule, error) {
o := GetOrmer()
qs := o.QueryTable(&models.ImmutableRule{}).Filter("ProjectID", projectID).Filter("Enabled", true)
var r []models.ImmutableRule
_, err := qs.All(&r)
if err != nil {
return nil, fmt.Errorf("failed to get enabled immutable tag rule for by projectID %d, error: %v", projectID, err)
}
return r, nil
}
// DeleteImmutableRule delete the immutable rule
func DeleteImmutableRule(id int64) (int64, error) {
o := GetOrmer()
ir := &models.ImmutableRule{ID: id}
return o.Delete(ir)
}

130
src/common/dao/immutable_test.go
View File

@ -1,130 +0,0 @@
package dao
import (
"testing"
"github.com/goharbor/harbor/src/common/models"
)
func TestCreateImmutableRule(t *testing.T) {
ir := &models.ImmutableRule{TagFilter: "**", ProjectID: 1}
id, err := CreateImmutableRule(ir)
if err != nil {
t.Errorf("error: %+v", err)
}
if id <= 0 {
t.Error("Can not create immutable tag rule")
}
_, err = DeleteImmutableRule(id)
if err != nil {
t.Errorf("error: %+v", err)
}
}
func TestUpdateImmutableRule(t *testing.T) {
ir := &models.ImmutableRule{TagFilter: "**", ProjectID: 1}
id, err := CreateImmutableRule(ir)
if err != nil {
t.Errorf("error: %+v", err)
}
if id <= 0 {
t.Error("Can not create immutable tag rule")
}
updatedIR := &models.ImmutableRule{ID: id, TagFilter: "1.2.0", ProjectID: 1}
updatedCnt, err := UpdateImmutableRule(1, updatedIR)
if err != nil {
t.Errorf("error: %+v", err)
}
if updatedCnt <= 0 {
t.Error("Failed to update immutable id")
}
newIr, err := GetImmutableRule(id)
if err != nil {
t.Errorf("error: %+v", err)
}
if newIr.TagFilter != "1.2.0" {
t.Error("Failed to update immutable tag")
}
defer DeleteImmutableRule(id)
}
func TestEnableImmutableRule(t *testing.T) {
ir := &models.ImmutableRule{TagFilter: "**", ProjectID: 1}
id, err := CreateImmutableRule(ir)
if err != nil {
t.Errorf("error: %+v", err)
}
if id <= 0 {
t.Error("Can not create immutable tag rule")
}
ToggleImmutableRule(id, false)
newIr, err := GetImmutableRule(id)
if err != nil {
t.Errorf("error: %+v", err)
}
if newIr.Enabled != false {
t.Error("Failed to disable the immutable rule")
}
defer DeleteImmutableRule(id)
}
func TestGetImmutableRuleByProject(t *testing.T) {
irs := []*models.ImmutableRule{
{TagFilter: "version1", ProjectID: 99},
{TagFilter: "version2", ProjectID: 99},
{TagFilter: "version3", ProjectID: 99},
{TagFilter: "version4", ProjectID: 99},
}
for _, ir := range irs {
CreateImmutableRule(ir)
}
qrs, err := QueryImmutableRuleByProjectID(99)
if err != nil {
t.Errorf("error: %+v", err)
}
if len(qrs) != 4 {
t.Error("Failed to query 4 rows!")
}
defer ExecuteBatchSQL([]string{"delete from immutable_tag_rule where project_id = 99 "})
}
func TestGetEnabledImmutableRuleByProject(t *testing.T) {
irs := []*models.ImmutableRule{
{TagFilter: "version1", ProjectID: 99},
{TagFilter: "version2", ProjectID: 99},
{TagFilter: "version3", ProjectID: 99},
{TagFilter: "version4", ProjectID: 99},
}
for i, ir := range irs {
id, _ := CreateImmutableRule(ir)
if i == 1 {
ToggleImmutableRule(id, false)
}
}
qrs, err := QueryEnabledImmutableRuleByProjectID(99)
if err != nil {
t.Errorf("error: %+v", err)
}
if len(qrs) != 3 {
t.Errorf("Failed to query 3 rows!, got %v", len(qrs))
}
defer ExecuteBatchSQL([]string{"delete from immutable_tag_rule where project_id = 99 "})
}

1
src/common/models/base.go
View File

@ -46,6 +46,5 @@ func init() {
new(CVEWhitelist),
new(Quota),
new(QuotaUsage),
new(ImmutableRule),
)
}

2
src/core/api/immutabletagrule.go
View File

@ -18,7 +18,7 @@ import (
// ImmutableTagRuleAPI ...
type ImmutableTagRuleAPI struct {
BaseController
manager immutabletag.RuleManager
manager immutabletag.Manager
projectID int64
ID int64
}

93
src/pkg/immutabletag/dao/immutable.go Normal file
View File

@ -0,0 +1,93 @@
package dao
import (
"fmt"
"github.com/astaxie/beego/orm"
"github.com/goharbor/harbor/src/common/dao"
"github.com/goharbor/harbor/src/pkg/immutabletag/dao/model"
)
// ImmutableRuleDao defines the interface to access the ImmutableRule data model
type ImmutableRuleDao interface {
CreateImmutableRule(ir *model.ImmutableRule) (int64, error)
UpdateImmutableRule(projectID int64, ir *model.ImmutableRule) (int64, error)
ToggleImmutableRule(id int64, enabled bool) (int64, error)
GetImmutableRule(id int64) (*model.ImmutableRule, error)
QueryImmutableRuleByProjectID(projectID int64) ([]model.ImmutableRule, error)
QueryEnabledImmutableRuleByProjectID(projectID int64) ([]model.ImmutableRule, error)
DeleteImmutableRule(id int64) (int64, error)
}
// New creates a default implementation for ImmutableRuleDao
func New() ImmutableRuleDao {
return &immutableRuleDao{}
}
type immutableRuleDao struct{}
// CreateImmutableRule creates the Immutable Rule
func (i *immutableRuleDao) CreateImmutableRule(ir *model.ImmutableRule) (int64, error) {
ir.Enabled = true
o := dao.GetOrmer()
return o.Insert(ir)
}
// UpdateImmutableRule update the immutable rules
func (i *immutableRuleDao) UpdateImmutableRule(projectID int64, ir *model.ImmutableRule) (int64, error) {
ir.ProjectID = projectID
o := dao.GetOrmer()
return o.Update(ir, "TagFilter")
}
// ToggleImmutableRule enable/disable immutable rules
func (i *immutableRuleDao) ToggleImmutableRule(id int64, enabled bool) (int64, error) {
o := dao.GetOrmer()
ir := &model.ImmutableRule{ID: id, Enabled: enabled}
return o.Update(ir, "Enabled")
}
// GetImmutableRule get immutable rule
func (i *immutableRuleDao) GetImmutableRule(id int64) (*model.ImmutableRule, error) {
o := dao.GetOrmer()
ir := &model.ImmutableRule{ID: id}
err := o.Read(ir)
if err == orm.ErrNoRows {
return nil, nil
}
if err != nil {
return nil, err
}
return ir, nil
}
// QueryImmutableRuleByProjectID get all immutable rule by project
func (i *immutableRuleDao) QueryImmutableRuleByProjectID(projectID int64) ([]model.ImmutableRule, error) {
o := dao.GetOrmer()
qs := o.QueryTable(&model.ImmutableRule{}).Filter("ProjectID", projectID)
var r []model.ImmutableRule
_, err := qs.All(&r)
if err != nil {
return nil, fmt.Errorf("failed to get immutable tag rule by projectID %d, error: %v", projectID, err)
}
return r, nil
}
// QueryEnabledImmutableRuleByProjectID get all enabled immutable rule by project
func (i *immutableRuleDao) QueryEnabledImmutableRuleByProjectID(projectID int64) ([]model.ImmutableRule, error) {
o := dao.GetOrmer()
qs := o.QueryTable(&model.ImmutableRule{}).Filter("ProjectID", projectID).Filter("Enabled", true)
var r []model.ImmutableRule
_, err := qs.All(&r)
if err != nil {
return nil, fmt.Errorf("failed to get enabled immutable tag rule for by projectID %d, error: %v", projectID, err)
}
return r, nil
}
// DeleteImmutableRule delete the immutable rule
func (i *immutableRuleDao) DeleteImmutableRule(id int64) (int64, error) {
o := dao.GetOrmer()
ir := &model.ImmutableRule{ID: id}
return o.Delete(ir)
}

113
src/pkg/immutabletag/dao/immutable_test.go Normal file
View File

@ -0,0 +1,113 @@
package dao
import (
"github.com/goharbor/harbor/src/common/dao"
"github.com/goharbor/harbor/src/pkg/immutabletag/dao/model"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
"testing"
)
type immutableRuleDaoTestSuite struct {
suite.Suite
require *require.Assertions
assert *assert.Assertions
dao ImmutableRuleDao
id int64
}
func (t *immutableRuleDaoTestSuite) SetupSuite() {
t.require = require.New(t.T())
t.assert = assert.New(t.T())
dao.PrepareTestForPostgresSQL()
t.dao = New()
}
func (t *immutableRuleDaoTestSuite) TestCreateImmutableRule() {
ir := &model.ImmutableRule{TagFilter: "**", ProjectID: 1}
id, err := t.dao.CreateImmutableRule(ir)
t.require.Nil(err)
t.require.True(id > 0, "Can not create immutable tag rule")
_, err = t.dao.DeleteImmutableRule(id)
t.require.Nil(err)
}
func (t *immutableRuleDaoTestSuite) TestUpdateImmutableRule() {
ir := &model.ImmutableRule{TagFilter: "**", ProjectID: 1}
id, err := t.dao.CreateImmutableRule(ir)
t.require.Nil(err)
t.require.True(id > 0, "Can not create immutable tag rule")
updatedIR := &model.ImmutableRule{ID: id, TagFilter: "1.2.0", ProjectID: 1}
updatedCnt, err := t.dao.UpdateImmutableRule(1, updatedIR)
t.require.Nil(err)
t.require.True(updatedCnt > 0, "Failed to update immutable id")
newIr, err := t.dao.GetImmutableRule(id)
t.require.Nil(err)
t.require.True(newIr.TagFilter == "1.2.0", "Failed to update immutable tag")
defer t.dao.DeleteImmutableRule(id)
}
func (t *immutableRuleDaoTestSuite) TestEnableImmutableRule() {
ir := &model.ImmutableRule{TagFilter: "**", ProjectID: 1}
id, err := t.dao.CreateImmutableRule(ir)
t.require.Nil(err)
t.require.True(id > 0, "Can not create immutable tag rule")
t.dao.ToggleImmutableRule(id, false)
newIr, err := t.dao.GetImmutableRule(id)
t.require.Nil(err)
t.require.False(newIr.Enabled, "Failed to disable the immutable rule")
defer t.dao.DeleteImmutableRule(id)
}
func (t *immutableRuleDaoTestSuite) TestGetImmutableRuleByProject() {
irs := []*model.ImmutableRule{
{TagFilter: "version1", ProjectID: 99},
{TagFilter: "version2", ProjectID: 99},
{TagFilter: "version3", ProjectID: 99},
{TagFilter: "version4", ProjectID: 99},
}
for _, ir := range irs {
t.dao.CreateImmutableRule(ir)
}
qrs, err := t.dao.QueryImmutableRuleByProjectID(99)
t.require.Nil(err)
t.require.True(len(qrs) == 4, "Failed to query 4 rows!")
defer dao.ExecuteBatchSQL([]string{"delete from immutable_tag_rule where project_id = 99 "})
}
func (t *immutableRuleDaoTestSuite) TestGetEnabledImmutableRuleByProject() {
irs := []*model.ImmutableRule{
{TagFilter: "version1", ProjectID: 99},
{TagFilter: "version2", ProjectID: 99},
{TagFilter: "version3", ProjectID: 99},
{TagFilter: "version4", ProjectID: 99},
}
for i, ir := range irs {
id, _ := t.dao.CreateImmutableRule(ir)
if i == 1 {
t.dao.ToggleImmutableRule(id, false)
}
}
qrs, err := t.dao.QueryEnabledImmutableRuleByProjectID(99)
t.require.Nil(err)
t.require.True(len(qrs) == 3, "Failed to query 3 rows!, got %v", len(qrs))
defer dao.ExecuteBatchSQL([]string{"delete from immutable_tag_rule where project_id = 99 "})
}
func TestImmutableRuleDaoTestSuite(t *testing.T) {
suite.Run(t, &immutableRuleDaoTestSuite{})
}

2
src/common/models/immutable.go → src/pkg/immutabletag/dao/model/rule.go
View File

@ -1,4 +1,4 @@
package models
package model
// ImmutableRule - rule which filter image tags should be immutable.
type ImmutableRule struct {

68
src/pkg/immutabletag/manager.go Normal file
View File

@ -0,0 +1,68 @@
package immutabletag
import (
"github.com/goharbor/harbor/src/pkg/immutabletag/dao"
"github.com/goharbor/harbor/src/pkg/immutabletag/dao/model"
)
var (
// Mgr is a global variable for the default immutablerule manager implementation
Mgr = NewDefaultRuleManager()
)
// Manager ...
type Manager interface {
// CreateImmutableRule creates the Immutable Rule
CreateImmutableRule(ir *model.ImmutableRule) (int64, error)
// UpdateImmutableRule update the immutable rules
UpdateImmutableRule(projectID int64, ir *model.ImmutableRule) (int64, error)
// EnableImmutableRule enable/disable immutable rules
EnableImmutableRule(id int64, enabled bool) (int64, error)
// GetImmutableRule get immutable rule
GetImmutableRule(id int64) (*model.ImmutableRule, error)
// QueryImmutableRuleByProjectID get all immutable rule by project
QueryImmutableRuleByProjectID(projectID int64) ([]model.ImmutableRule, error)
// QueryEnabledImmutableRuleByProjectID get all enabled immutable rule by project
QueryEnabledImmutableRuleByProjectID(projectID int64) ([]model.ImmutableRule, error)
// DeleteImmutableRule delete the immutable rule
DeleteImmutableRule(id int64) (int64, error)
}
type defaultRuleManager struct {
dao dao.ImmutableRuleDao
}
func (drm *defaultRuleManager) CreateImmutableRule(ir *model.ImmutableRule) (int64, error) {
return drm.dao.CreateImmutableRule(ir)
}
func (drm *defaultRuleManager) UpdateImmutableRule(projectID int64, ir *model.ImmutableRule) (int64, error) {
return drm.dao.UpdateImmutableRule(projectID, ir)
}
func (drm *defaultRuleManager) EnableImmutableRule(id int64, enabled bool) (int64, error) {
return drm.dao.ToggleImmutableRule(id, enabled)
}
func (drm *defaultRuleManager) GetImmutableRule(id int64) (*model.ImmutableRule, error) {
return drm.dao.GetImmutableRule(id)
}
func (drm *defaultRuleManager) QueryImmutableRuleByProjectID(projectID int64) ([]model.ImmutableRule, error) {
return drm.dao.QueryImmutableRuleByProjectID(projectID)
}
func (drm *defaultRuleManager) QueryEnabledImmutableRuleByProjectID(projectID int64) ([]model.ImmutableRule, error) {
return drm.dao.QueryEnabledImmutableRuleByProjectID(projectID)
}
func (drm *defaultRuleManager) DeleteImmutableRule(id int64) (int64, error) {
return drm.dao.DeleteImmutableRule(id)
}
// NewDefaultRuleManager return a new instance of defaultRuleManager
func NewDefaultRuleManager() Manager {
return &defaultRuleManager{
dao: dao.New(),
}
}

178
src/pkg/immutabletag/manager_test.go Normal file
View File

@ -0,0 +1,178 @@
package immutabletag
import (
"github.com/goharbor/harbor/src/pkg/immutabletag/dao/model"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
"os"
"testing"
)
type mockImmutableDao struct {
mock.Mock
}
func (m *mockImmutableDao) CreateImmutableRule(ir *model.ImmutableRule) (int64, error) {
args := m.Called(ir)
return int64(args.Int(0)), args.Error(1)
}
func (m *mockImmutableDao) UpdateImmutableRule(projectID int64, ir *model.ImmutableRule) (int64, error) {
args := m.Called(ir)
return int64(0), args.Error(1)
}
func (m *mockImmutableDao) QueryImmutableRuleByProjectID(projectID int64) ([]model.ImmutableRule, error) {
args := m.Called()
var irs []model.ImmutableRule
if args.Get(0) != nil {
irs = args.Get(0).([]model.ImmutableRule)
}
return irs, args.Error(1)
}
func (m *mockImmutableDao) QueryEnabledImmutableRuleByProjectID(projectID int64) ([]model.ImmutableRule, error) {
args := m.Called()
var irs []model.ImmutableRule
if args.Get(0) != nil {
irs = args.Get(0).([]model.ImmutableRule)
}
return irs, args.Error(1)
}
func (m *mockImmutableDao) DeleteImmutableRule(id int64) (int64, error) {
args := m.Called(id)
return int64(args.Int(0)), args.Error(1)
}
func (m *mockImmutableDao) ToggleImmutableRule(id int64, enabled bool) (int64, error) {
args := m.Called(id)
return int64(args.Int(0)), args.Error(1)
}
func (m *mockImmutableDao) GetImmutableRule(id int64) (*model.ImmutableRule, error) {
args := m.Called(id)
var ir *model.ImmutableRule
if args.Get(0) != nil {
ir = args.Get(0).(*model.ImmutableRule)
}
return ir, args.Error(1)
}
type managerTestingSuite struct {
suite.Suite
t *testing.T
assert *assert.Assertions
require *require.Assertions
mockImmutableDao *mockImmutableDao
}
func (m *managerTestingSuite) SetupSuite() {
m.t = m.T()
m.assert = assert.New(m.t)
m.require = require.New(m.t)
err := os.Setenv("RUN_MODE", "TEST")
m.require.Nil(err)
}
func (m *managerTestingSuite) TearDownSuite() {
err := os.Unsetenv("RUN_MODE")
m.require.Nil(err)
}
func (m *managerTestingSuite) SetupTest() {
m.mockImmutableDao = &mockImmutableDao{}
Mgr = &defaultRuleManager{
dao: m.mockImmutableDao,
}
}
func TestManagerTestingSuite(t *testing.T) {
suite.Run(t, &managerTestingSuite{})
}
func (m *managerTestingSuite) TestCreateImmutableRule() {
m.mockImmutableDao.On("CreateImmutableRule", mock.Anything).Return(1, nil)
id, err := Mgr.CreateImmutableRule(&model.ImmutableRule{})
m.mockImmutableDao.AssertCalled(m.t, "CreateImmutableRule", mock.Anything)
m.require.Nil(err)
m.assert.Equal(int64(1), id)
}
func (m *managerTestingSuite) TestQueryImmutableRuleByProjectID() {
m.mockImmutableDao.On("QueryImmutableRuleByProjectID", mock.Anything).Return([]model.ImmutableRule{
{
ProjectID: int64(1),
TagFilter: "project_1_tag_filter",
Enabled: false,
},
{
ProjectID: int64(2),
TagFilter: "project_2_tag_filter",
Enabled: true,
}}, nil)
irs, err := Mgr.QueryImmutableRuleByProjectID(int64(1))
m.mockImmutableDao.AssertCalled(m.t, "QueryImmutableRuleByProjectID", mock.Anything)
m.require.Nil(err)
m.assert.Equal(len(irs), 2)
m.assert.Equal(irs[0].TagFilter, "project_1_tag_filter")
}
func (m *managerTestingSuite) TestQueryEnabledImmutableRuleByProjectID() {
m.mockImmutableDao.On("QueryEnabledImmutableRuleByProjectID", mock.Anything).Return([]model.ImmutableRule{
{
ProjectID: int64(1),
TagFilter: "project_1_tag_filter",
Enabled: true,
},
{
ProjectID: int64(2),
TagFilter: "project_2_tag_filter",
Enabled: true,
}}, nil)
irs, err := Mgr.QueryEnabledImmutableRuleByProjectID(int64(1))
m.mockImmutableDao.AssertCalled(m.t, "QueryEnabledImmutableRuleByProjectID", mock.Anything)
m.require.Nil(err)
m.assert.Equal(len(irs), 2)
m.assert.Equal(irs[0].Enabled, true)
}
func (m *managerTestingSuite) TestGetImmutableRule() {
m.mockImmutableDao.On("GetImmutableRule", mock.Anything).Return(&model.ImmutableRule{
ID: 1,
}, nil)
ir, err := Mgr.GetImmutableRule(1)
m.mockImmutableDao.AssertCalled(m.t, "GetImmutableRule", mock.Anything)
m.require.Nil(err)
m.require.NotNil(ir)
m.assert.Equal(int64(1), ir.ID)
}
func (m *managerTestingSuite) TestUpdateImmutableRule() {
m.mockImmutableDao.On("UpdateImmutableRule", mock.Anything).Return(1, nil)
id, err := Mgr.UpdateImmutableRule(int64(1), &model.ImmutableRule{})
m.mockImmutableDao.AssertCalled(m.t, "UpdateImmutableRule", mock.Anything)
m.require.Nil(err)
m.assert.Equal(int64(0), id)
}
func (m *managerTestingSuite) TestEnableImmutableRule() {
m.mockImmutableDao.On("ToggleImmutableRule", mock.Anything).Return(1, nil)
id, err := Mgr.EnableImmutableRule(int64(1), true)
m.mockImmutableDao.AssertCalled(m.t, "ToggleImmutableRule", mock.Anything)
m.require.Nil(err)
m.assert.Equal(int64(1), id)
}
func (m *managerTestingSuite) TestDeleteImmutableRule() {
m.mockImmutableDao.On("DeleteImmutableRule", mock.Anything).Return(1, nil)
id, err := Mgr.DeleteImmutableRule(int64(1))
m.mockImmutableDao.AssertCalled(m.t, "DeleteImmutableRule", mock.Anything)
m.require.Nil(err)
m.assert.Equal(int64(1), id)
}

61
src/pkg/immutabletag/model/rule.go Normal file
View File

@ -0,0 +1,61 @@
package model
import (
"github.com/astaxie/beego/validation"
)
// Metadata of the immutable rule
type Metadata struct {
// UUID of rule
ID int `json:"id"`
// Disabled rule
Disabled bool `json:"disabled"`
// Priority of rule when doing calculating
Priority int `json:"priority"`
// Action of the rule performs
// "immutable"
Action string `json:"action" valid:"Required"`
// Template ID
Template string `json:"template" valid:"Required"`
// TagSelectors attached to the rule for filtering tags
TagSelectors []*Selector `json:"tag_selectors" valid:"Required"`
// Selector attached to the rule for filtering scope (e.g: repositories or namespaces)
ScopeSelectors map[string][]*Selector `json:"scope_selectors" valid:"Required"`
}
// Valid Valid
func (m *Metadata) Valid(v *validation.Validation) {
for _, ts := range m.TagSelectors {
if pass, _ := v.Valid(ts); !pass {
return
}
}
for _, ss := range m.ScopeSelectors {
for _, s := range ss {
if pass, _ := v.Valid(s); !pass {
return
}
}
}
}
// Selector to narrow down the list
type Selector struct {
// Kind of the selector
// "doublestar" or "label"
Kind string `json:"kind" valid:"Required;Match(doublestar)"`
// Decorated the selector
// for "doublestar" : "matching" and "excluding"
// for "label" : "with" and "without"
Decoration string `json:"decoration" valid:"Required"`
// Param for the selector
Pattern string `json:"pattern" valid:"Required"`
}

59
src/pkg/immutabletag/rulemanager.go
View File

@ -1,59 +0,0 @@
package immutabletag
import (
"github.com/goharbor/harbor/src/common/dao"
"github.com/goharbor/harbor/src/common/models"
)
// RuleManager ...
type RuleManager interface {
// CreateImmutableRule creates the Immutable Rule
CreateImmutableRule(ir *models.ImmutableRule) (int64, error)
// UpdateImmutableRule update the immutable rules
UpdateImmutableRule(projectID int64, ir *models.ImmutableRule) (int64, error)
// EnableImmutableRule enable/disable immutable rules
EnableImmutableRule(id int64, enabled bool) (int64, error)
// GetImmutableRule get immutable rule
GetImmutableRule(id int64) (*models.ImmutableRule, error)
// QueryImmutableRuleByProjectID get all immutable rule by project
QueryImmutableRuleByProjectID(projectID int64) ([]models.ImmutableRule, error)
// QueryEnabledImmutableRuleByProjectID get all enabled immutable rule by project
QueryEnabledImmutableRuleByProjectID(projectID int64) ([]models.ImmutableRule, error)
// DeleteImmutableRule delete the immutable rule
DeleteImmutableRule(id int64) (int64, error)
}
type defaultRuleManager struct{}
func (drm *defaultRuleManager) CreateImmutableRule(ir *models.ImmutableRule) (int64, error) {
return dao.CreateImmutableRule(ir)
}
func (drm *defaultRuleManager) UpdateImmutableRule(projectID int64, ir *models.ImmutableRule) (int64, error) {
return dao.UpdateImmutableRule(projectID, ir)
}
func (drm *defaultRuleManager) EnableImmutableRule(id int64, enabled bool) (int64, error) {
return dao.ToggleImmutableRule(id, enabled)
}
func (drm *defaultRuleManager) GetImmutableRule(id int64) (*models.ImmutableRule, error) {
return dao.GetImmutableRule(id)
}
func (drm *defaultRuleManager) QueryImmutableRuleByProjectID(projectID int64) ([]models.ImmutableRule, error) {
return dao.QueryImmutableRuleByProjectID(projectID)
}
func (drm *defaultRuleManager) QueryEnabledImmutableRuleByProjectID(projectID int64) ([]models.ImmutableRule, error) {
return dao.QueryEnabledImmutableRuleByProjectID(projectID)
}
func (drm *defaultRuleManager) DeleteImmutableRule(id int64) (int64, error) {
return dao.DeleteImmutableRule(id)
}
// NewDefaultRuleManager return a new instance of defaultRuleManager
func NewDefaultRuleManager() RuleManager {
return &defaultRuleManager{}
}