From d00da323751ce112edddddbd7d3bb687df28a5b8 Mon Sep 17 00:00:00 2001 From: Gabriel Adrian Samfira Date: Mon, 30 Jan 2023 14:29:55 +0000 Subject: [PATCH] Deduplicate some code Signed-off-by: Gabriel Adrian Samfira --- database/sql/enterprise.go | 39 ++---------------------- database/sql/enterprise_test.go | 10 ++---- database/sql/organizations.go | 39 ++---------------------- database/sql/organizations_test.go | 10 ++---- database/sql/pools.go | 49 ++++++++++++++++++++++++++++++ database/sql/repositories.go | 39 ++---------------------- database/sql/repositories_test.go | 12 +++----- runner/pool/pool.go | 2 +- 8 files changed, 69 insertions(+), 131 deletions(-) diff --git a/database/sql/enterprise.go b/database/sql/enterprise.go index f6a5ebb0..9215f561 100644 --- a/database/sql/enterprise.go +++ b/database/sql/enterprise.go @@ -195,7 +195,7 @@ func (s *sqlDatabase) CreateEnterprisePool(ctx context.Context, enterpriseID str } func (s *sqlDatabase) GetEnterprisePool(ctx context.Context, enterpriseID, poolID string) (params.Pool, error) { - pool, err := s.getEnterprisePool(ctx, enterpriseID, poolID, "Tags", "Instances") + pool, err := s.getEntityPool(ctx, params.EnterprisePool, enterpriseID, poolID, "Tags", "Instances") if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool") } @@ -203,7 +203,7 @@ func (s *sqlDatabase) GetEnterprisePool(ctx context.Context, enterpriseID, poolI } func (s *sqlDatabase) DeleteEnterprisePool(ctx context.Context, enterpriseID, poolID string) error { - pool, err := s.getEnterprisePool(ctx, enterpriseID, poolID) + pool, err := s.getEntityPool(ctx, params.EnterprisePool, enterpriseID, poolID) if err != nil { return errors.Wrap(err, "looking up enterprise pool") } @@ -215,7 +215,7 @@ func (s *sqlDatabase) DeleteEnterprisePool(ctx context.Context, enterpriseID, po } func (s *sqlDatabase) UpdateEnterprisePool(ctx context.Context, enterpriseID, poolID string, param params.UpdatePoolParams) (params.Pool, error) { - pool, err := s.getEnterprisePool(ctx, enterpriseID, poolID, "Tags", "Instances", "Enterprise", "Organization", "Repository") + pool, err := s.getEntityPool(ctx, params.EnterprisePool, enterpriseID, poolID, "Tags", "Instances", "Enterprise", "Organization", "Repository") if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool") } @@ -316,39 +316,6 @@ func (s *sqlDatabase) getEnterprisePoolByUniqueFields(ctx context.Context, enter return pool[0], nil } -func (s *sqlDatabase) getEnterprisePool(ctx context.Context, enterpriseID, poolID string, preload ...string) (Pool, error) { - _, err := s.getEnterpriseByID(ctx, enterpriseID) - if err != nil { - return Pool{}, errors.Wrap(err, "fetching enterprise") - } - - u, err := uuid.FromString(poolID) - if err != nil { - return Pool{}, errors.Wrap(runnerErrors.ErrBadRequest, "parsing id") - } - - q := s.conn - if len(preload) > 0 { - for _, item := range preload { - q = q.Preload(item) - } - } - - var pool Pool - err = q.Model(&Pool{}). - Where("id = ? and enterprise_id = ?", u, enterpriseID). - First(&pool).Error - - if err != nil { - if errors.Is(err, gorm.ErrRecordNotFound) { - return Pool{}, errors.Wrap(runnerErrors.ErrNotFound, "finding pool") - } - return Pool{}, errors.Wrap(err, "fetching pool") - } - - return pool, nil -} - func (s *sqlDatabase) getEnterprisePools(ctx context.Context, enterpriseID string, preload ...string) ([]Pool, error) { _, err := s.getEnterpriseByID(ctx, enterpriseID) if err != nil { diff --git a/database/sql/enterprise_test.go b/database/sql/enterprise_test.go index 189eae98..010febad 100644 --- a/database/sql/enterprise_test.go +++ b/database/sql/enterprise_test.go @@ -688,7 +688,7 @@ func (s *EnterpriseTestSuite) TestGetEnterprisePoolInvalidEnterpriseID() { _, err := s.Store.GetEnterprisePool(context.Background(), "dummy-enterprise-id", "dummy-pool-id") s.Require().NotNil(err) - s.Require().Equal("fetching pool: fetching enterprise: parsing id: invalid request", err.Error()) + s.Require().Equal("fetching pool: parsing id: invalid request", err.Error()) } func (s *EnterpriseTestSuite) TestDeleteEnterprisePool() { @@ -708,7 +708,7 @@ func (s *EnterpriseTestSuite) TestDeleteEnterprisePoolInvalidEnterpriseID() { err := s.Store.DeleteEnterprisePool(context.Background(), "dummy-enterprise-id", "dummy-pool-id") s.Require().NotNil(err) - s.Require().Equal("looking up enterprise pool: fetching enterprise: parsing id: invalid request", err.Error()) + s.Require().Equal("looking up enterprise pool: parsing id: invalid request", err.Error()) } func (s *EnterpriseTestSuite) TestDeleteEnterprisePoolDBDeleteErr() { @@ -717,10 +717,6 @@ func (s *EnterpriseTestSuite) TestDeleteEnterprisePoolDBDeleteErr() { s.FailNow(fmt.Sprintf("cannot create enterprise pool: %v", err)) } - s.Fixtures.SQLMock. - ExpectQuery(regexp.QuoteMeta("SELECT * FROM `enterprises` WHERE id = ? AND `enterprises`.`deleted_at` IS NULL ORDER BY `enterprises`.`id` LIMIT 1")). - WithArgs(s.Fixtures.Enterprises[0].ID). - WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(s.Fixtures.Enterprises[0].ID)) s.Fixtures.SQLMock. ExpectQuery(regexp.QuoteMeta("SELECT * FROM `pools` WHERE (id = ? and enterprise_id = ?) AND `pools`.`deleted_at` IS NULL ORDER BY `pools`.`id` LIMIT 1")). WithArgs(pool.ID, s.Fixtures.Enterprises[0].ID). @@ -809,7 +805,7 @@ func (s *EnterpriseTestSuite) TestUpdateEnterprisePoolInvalidEnterpriseID() { _, err := s.Store.UpdateEnterprisePool(context.Background(), "dummy-enterprise-id", "dummy-pool-id", s.Fixtures.UpdatePoolParams) s.Require().NotNil(err) - s.Require().Equal("fetching pool: fetching enterprise: parsing id: invalid request", err.Error()) + s.Require().Equal("fetching pool: parsing id: invalid request", err.Error()) } func TestEnterpriseTestSuite(t *testing.T) { diff --git a/database/sql/organizations.go b/database/sql/organizations.go index 452a159f..c89d4f8f 100644 --- a/database/sql/organizations.go +++ b/database/sql/organizations.go @@ -226,7 +226,7 @@ func (s *sqlDatabase) ListOrgPools(ctx context.Context, orgID string) ([]params. } func (s *sqlDatabase) GetOrganizationPool(ctx context.Context, orgID, poolID string) (params.Pool, error) { - pool, err := s.getOrgPool(ctx, orgID, poolID, "Tags", "Instances") + pool, err := s.getEntityPool(ctx, params.OrganizationPool, orgID, poolID, "Tags", "Instances") if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool") } @@ -234,7 +234,7 @@ func (s *sqlDatabase) GetOrganizationPool(ctx context.Context, orgID, poolID str } func (s *sqlDatabase) DeleteOrganizationPool(ctx context.Context, orgID, poolID string) error { - pool, err := s.getOrgPool(ctx, orgID, poolID) + pool, err := s.getEntityPool(ctx, params.OrganizationPool, orgID, poolID) if err != nil { return errors.Wrap(err, "looking up org pool") } @@ -268,7 +268,7 @@ func (s *sqlDatabase) ListOrgInstances(ctx context.Context, orgID string) ([]par } func (s *sqlDatabase) UpdateOrganizationPool(ctx context.Context, orgID, poolID string, param params.UpdatePoolParams) (params.Pool, error) { - pool, err := s.getOrgPool(ctx, orgID, poolID, "Tags", "Instances", "Enterprise", "Organization", "Repository") + pool, err := s.getEntityPool(ctx, params.OrganizationPool, orgID, poolID, "Tags", "Instances", "Enterprise", "Organization", "Repository") if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool") } @@ -300,39 +300,6 @@ func (s *sqlDatabase) getPoolByID(ctx context.Context, poolID string, preload .. return pool, nil } -func (s *sqlDatabase) getOrgPool(ctx context.Context, orgID, poolID string, preload ...string) (Pool, error) { - _, err := s.getOrgByID(ctx, orgID) - if err != nil { - return Pool{}, errors.Wrap(err, "fetching org") - } - - u, err := uuid.FromString(poolID) - if err != nil { - return Pool{}, errors.Wrap(runnerErrors.ErrBadRequest, "parsing id") - } - - q := s.conn - if len(preload) > 0 { - for _, item := range preload { - q = q.Preload(item) - } - } - - var pool Pool - err = q.Model(&Pool{}). - Where("id = ? and org_id = ?", u, orgID). - First(&pool).Error - - if err != nil { - if errors.Is(err, gorm.ErrRecordNotFound) { - return Pool{}, errors.Wrap(runnerErrors.ErrNotFound, "finding pool") - } - return Pool{}, errors.Wrap(err, "fetching pool") - } - - return pool, nil -} - func (s *sqlDatabase) getOrgPools(ctx context.Context, orgID string, preload ...string) ([]Pool, error) { _, err := s.getOrgByID(ctx, orgID) if err != nil { diff --git a/database/sql/organizations_test.go b/database/sql/organizations_test.go index b3be04c0..81dc9367 100644 --- a/database/sql/organizations_test.go +++ b/database/sql/organizations_test.go @@ -688,7 +688,7 @@ func (s *OrgTestSuite) TestGetOrganizationPoolInvalidOrgID() { _, err := s.Store.GetOrganizationPool(context.Background(), "dummy-org-id", "dummy-pool-id") s.Require().NotNil(err) - s.Require().Equal("fetching pool: fetching org: parsing id: invalid request", err.Error()) + s.Require().Equal("fetching pool: parsing id: invalid request", err.Error()) } func (s *OrgTestSuite) TestDeleteOrganizationPool() { @@ -708,7 +708,7 @@ func (s *OrgTestSuite) TestDeleteOrganizationPoolInvalidOrgID() { err := s.Store.DeleteOrganizationPool(context.Background(), "dummy-org-id", "dummy-pool-id") s.Require().NotNil(err) - s.Require().Equal("looking up org pool: fetching org: parsing id: invalid request", err.Error()) + s.Require().Equal("looking up org pool: parsing id: invalid request", err.Error()) } func (s *OrgTestSuite) TestDeleteOrganizationPoolDBDeleteErr() { @@ -717,10 +717,6 @@ func (s *OrgTestSuite) TestDeleteOrganizationPoolDBDeleteErr() { s.FailNow(fmt.Sprintf("cannot create org pool: %v", err)) } - s.Fixtures.SQLMock. - ExpectQuery(regexp.QuoteMeta("SELECT * FROM `organizations` WHERE id = ? AND `organizations`.`deleted_at` IS NULL ORDER BY `organizations`.`id` LIMIT 1")). - WithArgs(s.Fixtures.Orgs[0].ID). - WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(s.Fixtures.Orgs[0].ID)) s.Fixtures.SQLMock. ExpectQuery(regexp.QuoteMeta("SELECT * FROM `pools` WHERE (id = ? and org_id = ?) AND `pools`.`deleted_at` IS NULL ORDER BY `pools`.`id` LIMIT 1")). WithArgs(pool.ID, s.Fixtures.Orgs[0].ID). @@ -809,7 +805,7 @@ func (s *OrgTestSuite) TestUpdateOrganizationPoolInvalidOrgID() { _, err := s.Store.UpdateOrganizationPool(context.Background(), "dummy-org-id", "dummy-pool-id", s.Fixtures.UpdatePoolParams) s.Require().NotNil(err) - s.Require().Equal("fetching pool: fetching org: parsing id: invalid request", err.Error()) + s.Require().Equal("fetching pool: parsing id: invalid request", err.Error()) } func TestOrgTestSuite(t *testing.T) { diff --git a/database/sql/pools.go b/database/sql/pools.go index 0165577f..b25af195 100644 --- a/database/sql/pools.go +++ b/database/sql/pools.go @@ -16,10 +16,14 @@ package sql import ( "context" + "fmt" + runnerErrors "garm/errors" "garm/params" "github.com/pkg/errors" + uuid "github.com/satori/go.uuid" + "gorm.io/gorm" ) func (s *sqlDatabase) ListAllPools(ctx context.Context) ([]params.Pool, error) { @@ -63,3 +67,48 @@ func (s *sqlDatabase) DeletePoolByID(ctx context.Context, poolID string) error { return nil } + +func (s *sqlDatabase) getEntityPool(ctx context.Context, entityType params.PoolType, entityID, poolID string, preload ...string) (Pool, error) { + if entityID == "" { + return Pool{}, errors.Wrap(runnerErrors.ErrBadRequest, "missing entity id") + } + + u, err := uuid.FromString(poolID) + if err != nil { + return Pool{}, errors.Wrap(runnerErrors.ErrBadRequest, "parsing id") + } + + q := s.conn + if len(preload) > 0 { + for _, item := range preload { + q = q.Preload(item) + } + } + + var fieldName string + switch entityType { + case params.RepositoryPool: + fieldName = "repo_id" + case params.OrganizationPool: + fieldName = "org_id" + case params.EnterprisePool: + fieldName = "enterprise_id" + default: + return Pool{}, fmt.Errorf("invalid entityType: %v", entityType) + } + + var pool Pool + condition := fmt.Sprintf("id = ? and %s = ?", fieldName) + err = q.Model(&Pool{}). + Where(condition, u, entityID). + First(&pool).Error + + if err != nil { + if errors.Is(err, gorm.ErrRecordNotFound) { + return Pool{}, errors.Wrap(runnerErrors.ErrNotFound, "finding pool") + } + return Pool{}, errors.Wrap(err, "fetching pool") + } + + return pool, nil +} diff --git a/database/sql/repositories.go b/database/sql/repositories.go index f942de1c..6bef798f 100644 --- a/database/sql/repositories.go +++ b/database/sql/repositories.go @@ -226,7 +226,7 @@ func (s *sqlDatabase) ListRepoPools(ctx context.Context, repoID string) ([]param } func (s *sqlDatabase) GetRepositoryPool(ctx context.Context, repoID, poolID string) (params.Pool, error) { - pool, err := s.getRepoPool(ctx, repoID, poolID, "Tags", "Instances") + pool, err := s.getEntityPool(ctx, params.RepositoryPool, repoID, poolID, "Tags", "Instances") if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool") } @@ -234,7 +234,7 @@ func (s *sqlDatabase) GetRepositoryPool(ctx context.Context, repoID, poolID stri } func (s *sqlDatabase) DeleteRepositoryPool(ctx context.Context, repoID, poolID string) error { - pool, err := s.getRepoPool(ctx, repoID, poolID) + pool, err := s.getEntityPool(ctx, params.RepositoryPool, repoID, poolID) if err != nil { return errors.Wrap(err, "looking up repo pool") } @@ -269,7 +269,7 @@ func (s *sqlDatabase) ListRepoInstances(ctx context.Context, repoID string) ([]p } func (s *sqlDatabase) UpdateRepositoryPool(ctx context.Context, repoID, poolID string, param params.UpdatePoolParams) (params.Pool, error) { - pool, err := s.getRepoPool(ctx, repoID, poolID, "Tags", "Instances", "Enterprise", "Organization", "Repository") + pool, err := s.getEntityPool(ctx, params.RepositoryPool, repoID, poolID, "Tags", "Instances", "Enterprise", "Organization", "Repository") if err != nil { return params.Pool{}, errors.Wrap(err, "fetching pool") } @@ -322,39 +322,6 @@ func (s *sqlDatabase) findPoolByTags(id, poolType string, tags []string) (params return s.sqlToCommonPool(pool), nil } -func (s *sqlDatabase) getRepoPool(ctx context.Context, repoID, poolID string, preload ...string) (Pool, error) { - _, err := s.getRepoByID(ctx, repoID) - if err != nil { - return Pool{}, errors.Wrap(err, "fetching repo") - } - - u, err := uuid.FromString(poolID) - if err != nil { - return Pool{}, errors.Wrap(runnerErrors.ErrBadRequest, "parsing id") - } - - q := s.conn - if len(preload) > 0 { - for _, item := range preload { - q = q.Preload(item) - } - } - - var pool Pool - err = q.Model(&Pool{}). - Where("id = ? and repo_id = ?", u, repoID). - First(&pool).Error - - if err != nil { - if errors.Is(err, gorm.ErrRecordNotFound) { - return Pool{}, errors.Wrap(runnerErrors.ErrNotFound, "finding pool") - } - return Pool{}, errors.Wrap(err, "fetching pool") - } - - return pool, nil -} - func (s *sqlDatabase) getRepoPoolByUniqueFields(ctx context.Context, repoID string, provider, image, flavor string) (Pool, error) { repo, err := s.getRepoByID(ctx, repoID) if err != nil { diff --git a/database/sql/repositories_test.go b/database/sql/repositories_test.go index ef9a2591..7f2ea6ed 100644 --- a/database/sql/repositories_test.go +++ b/database/sql/repositories_test.go @@ -725,7 +725,7 @@ func (s *RepoTestSuite) TestGetRepositoryPoolInvalidRepoID() { _, err := s.Store.GetRepositoryPool(context.Background(), "dummy-repo-id", "dummy-pool-id") s.Require().NotNil(err) - s.Require().Equal("fetching pool: fetching repo: parsing id: invalid request", err.Error()) + s.Require().Equal("fetching pool: parsing id: invalid request", err.Error()) } func (s *RepoTestSuite) TestDeleteRepositoryPool() { @@ -738,14 +738,14 @@ func (s *RepoTestSuite) TestDeleteRepositoryPool() { s.Require().Nil(err) _, err = s.Store.GetOrganizationPool(context.Background(), s.Fixtures.Repos[0].ID, pool.ID) - s.Require().Equal("fetching pool: fetching org: not found", err.Error()) + s.Require().Equal("fetching pool: finding pool: not found", err.Error()) } func (s *RepoTestSuite) TestDeleteRepositoryPoolInvalidRepoID() { err := s.Store.DeleteRepositoryPool(context.Background(), "dummy-repo-id", "dummy-pool-id") s.Require().NotNil(err) - s.Require().Equal("looking up repo pool: fetching repo: parsing id: invalid request", err.Error()) + s.Require().Equal("looking up repo pool: parsing id: invalid request", err.Error()) } func (s *RepoTestSuite) TestDeleteRepositoryPoolDBDeleteErr() { @@ -754,10 +754,6 @@ func (s *RepoTestSuite) TestDeleteRepositoryPoolDBDeleteErr() { s.FailNow(fmt.Sprintf("cannot create repo pool: %v", err)) } - s.Fixtures.SQLMock. - ExpectQuery(regexp.QuoteMeta("SELECT * FROM `repositories` WHERE id = ? AND `repositories`.`deleted_at` IS NULL ORDER BY `repositories`.`id` LIMIT 1")). - WithArgs(s.Fixtures.Repos[0].ID). - WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(s.Fixtures.Repos[0].ID)) s.Fixtures.SQLMock. ExpectQuery(regexp.QuoteMeta("SELECT * FROM `pools` WHERE (id = ? and repo_id = ?) AND `pools`.`deleted_at` IS NULL ORDER BY `pools`.`id` LIMIT 1")). WithArgs(pool.ID, s.Fixtures.Repos[0].ID). @@ -845,7 +841,7 @@ func (s *RepoTestSuite) TestUpdateRepositoryPoolInvalidRepoID() { _, err := s.Store.UpdateRepositoryPool(context.Background(), "dummy-org-id", "dummy-repo-id", s.Fixtures.UpdatePoolParams) s.Require().NotNil(err) - s.Require().Equal("fetching pool: fetching repo: parsing id: invalid request", err.Error()) + s.Require().Equal("fetching pool: parsing id: invalid request", err.Error()) } func TestRepoTestSuite(t *testing.T) { diff --git a/runner/pool/pool.go b/runner/pool/pool.go index b2d3abe8..437b3d7b 100644 --- a/runner/pool/pool.go +++ b/runner/pool/pool.go @@ -836,7 +836,7 @@ func (r *basePoolManager) ensureIdleRunnersForOnePool(pool params.Pool) { } for i := 0; i < required; i++ { - log.Printf("addind new idle worker to pool %s", pool.ID) + log.Printf("adding new idle worker to pool %s", pool.ID) if err := r.AddRunner(r.ctx, pool.ID); err != nil { log.Printf("failed to add new instance for pool %s: %s", pool.ID, err) }