From fe2cb015280a991cc07535aedcaab571d3f89325 Mon Sep 17 00:00:00 2001 From: Gabriel Adrian Samfira Date: Wed, 5 Jul 2023 09:46:19 +0000 Subject: [PATCH] Slight refactor and fix tests Updating a pool will no longer try to create a pool manager if one does not already exist. A pool manager must be started when a pool is created. Updating an existing pool without a pool manager is an error condition. Signed-off-by: Gabriel Adrian Samfira --- runner/enterprises.go | 21 +----- runner/enterprises_test.go | 16 ++-- runner/interfaces.go | 5 +- runner/mocks/PoolManagerController.go | 102 ++++++++++++++++++++------ runner/organizations.go | 19 +---- runner/organizations_test.go | 14 ++-- runner/repositories.go | 21 +----- runner/repositories_test.go | 18 ++--- runner/runner.go | 83 ++++++++++++++++++++- 9 files changed, 186 insertions(+), 113 deletions(-) diff --git a/runner/enterprises.go b/runner/enterprises.go index 4f1ecb1a..4256cae8 100644 --- a/runner/enterprises.go +++ b/runner/enterprises.go @@ -169,24 +169,9 @@ func (r *Runner) UpdateEnterprise(ctx context.Context, enterpriseID string, para return params.Enterprise{}, errors.Wrap(err, "updating enterprise") } - poolMgr, err := r.poolManagerCtrl.GetEnterprisePoolManager(enterprise) - if err == nil { - internalCfg, err := r.poolManagerCtrl.GetInternalConfig(enterprise.CredentialsName) - if err != nil { - return params.Enterprise{}, errors.Wrap(err, "fetching internal config") - } - newState := params.UpdatePoolStateParams{ - WebhookSecret: enterprise.WebhookSecret, - InternalConfig: &internalCfg, - } - if err := poolMgr.RefreshState(newState); err != nil { - return params.Enterprise{}, errors.Wrap(err, "updating enterprise pool manager") - } - } else { - poolMgr, err = r.poolManagerCtrl.CreateEnterprisePoolManager(r.ctx, enterprise, r.providers, r.store) - if err != nil { - return params.Enterprise{}, errors.Wrap(err, "creating enterprise pool manager") - } + poolMgr, err := r.poolManagerCtrl.UpdateEnterprisePoolManager(r.ctx, enterprise) + if err != nil { + return params.Enterprise{}, fmt.Errorf("failed to update enterprise pool manager: %w", err) } enterprise.PoolManagerStatus = poolMgr.Status() diff --git a/runner/enterprises_test.go b/runner/enterprises_test.go index 40f79f9f..f4c81f53 100644 --- a/runner/enterprises_test.go +++ b/runner/enterprises_test.go @@ -290,8 +290,8 @@ func (s *EnterpriseTestSuite) TestDeleteEnterprisePoolMgrFailed() { } func (s *EnterpriseTestSuite) TestUpdateEnterprise() { - s.Fixtures.PoolMgrCtrlMock.On("GetEnterprisePoolManager", mock.AnythingOfType("params.Enterprise")).Return(s.Fixtures.PoolMgrMock, nil) - s.Fixtures.PoolMgrCtrlMock.On("CreateEnterprisePoolManager", s.Fixtures.AdminContext, mock.AnythingOfType("params.Enterprise"), s.Fixtures.Providers, s.Fixtures.Store).Return(s.Fixtures.PoolMgrMock, nil) + s.Fixtures.PoolMgrCtrlMock.On("UpdateEnterprisePoolManager", s.Fixtures.AdminContext, mock.AnythingOfType("params.Enterprise")).Return(s.Fixtures.PoolMgrMock, nil) + s.Fixtures.PoolMgrMock.On("Status").Return(params.PoolManagerStatus{IsRunning: true}, nil) org, err := s.Runner.UpdateEnterprise(s.Fixtures.AdminContext, s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, s.Fixtures.UpdateRepoParams) @@ -317,25 +317,21 @@ func (s *EnterpriseTestSuite) TestUpdateEnterpriseInvalidCreds() { } func (s *EnterpriseTestSuite) TestUpdateEnterprisePoolMgrFailed() { - s.Fixtures.PoolMgrCtrlMock.On("GetEnterprisePoolManager", mock.AnythingOfType("params.Enterprise")).Return(s.Fixtures.PoolMgrMock, s.Fixtures.ErrMock) - s.Fixtures.PoolMgrMock.On("RefreshState", s.Fixtures.UpdatePoolStateParams).Return(s.Fixtures.ErrMock) + s.Fixtures.PoolMgrCtrlMock.On("UpdateEnterprisePoolManager", s.Fixtures.AdminContext, mock.AnythingOfType("params.Enterprise")).Return(s.Fixtures.PoolMgrMock, s.Fixtures.ErrMock) _, err := s.Runner.UpdateEnterprise(s.Fixtures.AdminContext, s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, s.Fixtures.UpdateRepoParams) - s.Fixtures.PoolMgrMock.AssertExpectations(s.T()) s.Fixtures.PoolMgrCtrlMock.AssertExpectations(s.T()) - s.Require().Equal(fmt.Sprintf("updating enterprise pool manager: %s", s.Fixtures.ErrMock.Error()), err.Error()) + s.Require().Equal(fmt.Sprintf("failed to update enterprise pool manager: %s", s.Fixtures.ErrMock.Error()), err.Error()) } func (s *EnterpriseTestSuite) TestUpdateEnterpriseCreateEnterprisePoolMgrFailed() { - s.Fixtures.PoolMgrCtrlMock.On("GetEnterprisePoolManager", mock.AnythingOfType("params.Enterprise")).Return(s.Fixtures.PoolMgrMock, nil) - s.Fixtures.PoolMgrCtrlMock.On("CreateEnterprisePoolManager", s.Fixtures.AdminContext, mock.AnythingOfType("params.Enterprise"), s.Fixtures.Providers, s.Fixtures.Store).Return(s.Fixtures.PoolMgrMock, s.Fixtures.ErrMock) + s.Fixtures.PoolMgrCtrlMock.On("UpdateEnterprisePoolManager", s.Fixtures.AdminContext, mock.AnythingOfType("params.Enterprise")).Return(s.Fixtures.PoolMgrMock, s.Fixtures.ErrMock) _, err := s.Runner.UpdateEnterprise(s.Fixtures.AdminContext, s.Fixtures.StoreEnterprises["test-enterprise-1"].ID, s.Fixtures.UpdateRepoParams) - s.Fixtures.PoolMgrMock.AssertExpectations(s.T()) s.Fixtures.PoolMgrCtrlMock.AssertExpectations(s.T()) - s.Require().Equal(fmt.Sprintf("creating enterprise pool manager: %s", s.Fixtures.ErrMock.Error()), err.Error()) + s.Require().Equal(fmt.Sprintf("failed to update enterprise pool manager: %s", s.Fixtures.ErrMock.Error()), err.Error()) } func (s *EnterpriseTestSuite) TestCreateEnterprisePool() { diff --git a/runner/interfaces.go b/runner/interfaces.go index d91d8430..05ae9c0f 100644 --- a/runner/interfaces.go +++ b/runner/interfaces.go @@ -24,6 +24,7 @@ import ( type RepoPoolManager interface { CreateRepoPoolManager(ctx context.Context, repo params.Repository, providers map[string]common.Provider, store dbCommon.Store) (common.PoolManager, error) + UpdateRepoPoolManager(ctx context.Context, repo params.Repository) (common.PoolManager, error) GetRepoPoolManager(repo params.Repository) (common.PoolManager, error) DeleteRepoPoolManager(repo params.Repository) error GetRepoPoolManagers() (map[string]common.PoolManager, error) @@ -31,6 +32,7 @@ type RepoPoolManager interface { type OrgPoolManager interface { CreateOrgPoolManager(ctx context.Context, org params.Organization, providers map[string]common.Provider, store dbCommon.Store) (common.PoolManager, error) + UpdateOrgPoolManager(ctx context.Context, org params.Organization) (common.PoolManager, error) GetOrgPoolManager(org params.Organization) (common.PoolManager, error) DeleteOrgPoolManager(org params.Organization) error GetOrgPoolManagers() (map[string]common.PoolManager, error) @@ -38,6 +40,7 @@ type OrgPoolManager interface { type EnterprisePoolManager interface { CreateEnterprisePoolManager(ctx context.Context, enterprise params.Enterprise, providers map[string]common.Provider, store dbCommon.Store) (common.PoolManager, error) + UpdateEnterprisePoolManager(ctx context.Context, enterprise params.Enterprise) (common.PoolManager, error) GetEnterprisePoolManager(enterprise params.Enterprise) (common.PoolManager, error) DeleteEnterprisePoolManager(enterprise params.Enterprise) error GetEnterprisePoolManagers() (map[string]common.PoolManager, error) @@ -49,6 +52,4 @@ type PoolManagerController interface { RepoPoolManager OrgPoolManager EnterprisePoolManager - - GetInternalConfig(credsName string) (params.Internal, error) } diff --git a/runner/mocks/PoolManagerController.go b/runner/mocks/PoolManagerController.go index db710274..d422508a 100644 --- a/runner/mocks/PoolManagerController.go +++ b/runner/mocks/PoolManagerController.go @@ -191,30 +191,6 @@ func (_m *PoolManagerController) GetEnterprisePoolManagers() (map[string]common. return r0, r1 } -// GetInternalConfig provides a mock function with given fields: credsName -func (_m *PoolManagerController) GetInternalConfig(credsName string) (params.Internal, error) { - ret := _m.Called(credsName) - - var r0 params.Internal - var r1 error - if rf, ok := ret.Get(0).(func(string) (params.Internal, error)); ok { - return rf(credsName) - } - if rf, ok := ret.Get(0).(func(string) params.Internal); ok { - r0 = rf(credsName) - } else { - r0 = ret.Get(0).(params.Internal) - } - - if rf, ok := ret.Get(1).(func(string) error); ok { - r1 = rf(credsName) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - // GetOrgPoolManager provides a mock function with given fields: org func (_m *PoolManagerController) GetOrgPoolManager(org params.Organization) (common.PoolManager, error) { ret := _m.Called(org) @@ -319,6 +295,84 @@ func (_m *PoolManagerController) GetRepoPoolManagers() (map[string]common.PoolMa return r0, r1 } +// UpdateEnterprisePoolManager provides a mock function with given fields: ctx, enterprise +func (_m *PoolManagerController) UpdateEnterprisePoolManager(ctx context.Context, enterprise params.Enterprise) (common.PoolManager, error) { + ret := _m.Called(ctx, enterprise) + + var r0 common.PoolManager + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, params.Enterprise) (common.PoolManager, error)); ok { + return rf(ctx, enterprise) + } + if rf, ok := ret.Get(0).(func(context.Context, params.Enterprise) common.PoolManager); ok { + r0 = rf(ctx, enterprise) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(common.PoolManager) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, params.Enterprise) error); ok { + r1 = rf(ctx, enterprise) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// UpdateOrgPoolManager provides a mock function with given fields: ctx, org +func (_m *PoolManagerController) UpdateOrgPoolManager(ctx context.Context, org params.Organization) (common.PoolManager, error) { + ret := _m.Called(ctx, org) + + var r0 common.PoolManager + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, params.Organization) (common.PoolManager, error)); ok { + return rf(ctx, org) + } + if rf, ok := ret.Get(0).(func(context.Context, params.Organization) common.PoolManager); ok { + r0 = rf(ctx, org) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(common.PoolManager) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, params.Organization) error); ok { + r1 = rf(ctx, org) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// UpdateRepoPoolManager provides a mock function with given fields: ctx, repo +func (_m *PoolManagerController) UpdateRepoPoolManager(ctx context.Context, repo params.Repository) (common.PoolManager, error) { + ret := _m.Called(ctx, repo) + + var r0 common.PoolManager + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, params.Repository) (common.PoolManager, error)); ok { + return rf(ctx, repo) + } + if rf, ok := ret.Get(0).(func(context.Context, params.Repository) common.PoolManager); ok { + r0 = rf(ctx, repo) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(common.PoolManager) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, params.Repository) error); ok { + r1 = rf(ctx, repo) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // NewPoolManagerController creates a new instance of PoolManagerController. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. // The first argument is typically a *testing.T value. func NewPoolManagerController(t interface { diff --git a/runner/organizations.go b/runner/organizations.go index 00913be1..b3a44446 100644 --- a/runner/organizations.go +++ b/runner/organizations.go @@ -183,24 +183,9 @@ func (r *Runner) UpdateOrganization(ctx context.Context, orgID string, param par return params.Organization{}, errors.Wrap(err, "updating org") } - poolMgr, err := r.poolManagerCtrl.GetOrgPoolManager(org) + poolMgr, err := r.poolManagerCtrl.UpdateOrgPoolManager(r.ctx, org) if err != nil { - internalCfg, err := r.poolManagerCtrl.GetInternalConfig(org.CredentialsName) - if err != nil { - return params.Organization{}, errors.Wrap(err, "fetching internal config") - } - newState := params.UpdatePoolStateParams{ - WebhookSecret: org.WebhookSecret, - InternalConfig: &internalCfg, - } - if err := poolMgr.RefreshState(newState); err != nil { - return params.Organization{}, errors.Wrap(err, "updating org pool manager") - } - } else { - poolMgr, err = r.poolManagerCtrl.CreateOrgPoolManager(r.ctx, org, r.providers, r.store) - if err != nil { - return params.Organization{}, errors.Wrap(err, "creating org pool manager") - } + return params.Organization{}, fmt.Errorf("updating org pool manager: %w", err) } org.PoolManagerStatus = poolMgr.Status() diff --git a/runner/organizations_test.go b/runner/organizations_test.go index 0ce67a97..d3d554f1 100644 --- a/runner/organizations_test.go +++ b/runner/organizations_test.go @@ -290,8 +290,8 @@ func (s *OrgTestSuite) TestDeleteOrganizationPoolMgrFailed() { } func (s *OrgTestSuite) TestUpdateOrganization() { - s.Fixtures.PoolMgrCtrlMock.On("GetOrgPoolManager", mock.AnythingOfType("params.Organization")).Return(s.Fixtures.PoolMgrMock, nil) - s.Fixtures.PoolMgrCtrlMock.On("CreateOrgPoolManager", s.Fixtures.AdminContext, mock.AnythingOfType("params.Organization"), s.Fixtures.Providers, s.Fixtures.Store).Return(s.Fixtures.PoolMgrMock, nil) + s.Fixtures.PoolMgrCtrlMock.On("UpdateOrgPoolManager", s.Fixtures.AdminContext, mock.AnythingOfType("params.Organization")).Return(s.Fixtures.PoolMgrMock, nil) + s.Fixtures.PoolMgrMock.On("Status").Return(params.PoolManagerStatus{IsRunning: true}, nil) org, err := s.Runner.UpdateOrganization(s.Fixtures.AdminContext, s.Fixtures.StoreOrgs["test-org-1"].ID, s.Fixtures.UpdateRepoParams) @@ -317,25 +317,21 @@ func (s *OrgTestSuite) TestUpdateOrganizationInvalidCreds() { } func (s *OrgTestSuite) TestUpdateOrganizationPoolMgrFailed() { - s.Fixtures.PoolMgrCtrlMock.On("GetOrgPoolManager", mock.AnythingOfType("params.Organization")).Return(s.Fixtures.PoolMgrMock, s.Fixtures.ErrMock) - s.Fixtures.PoolMgrMock.On("RefreshState", s.Fixtures.UpdatePoolStateParams).Return(s.Fixtures.ErrMock) + s.Fixtures.PoolMgrCtrlMock.On("UpdateOrgPoolManager", s.Fixtures.AdminContext, mock.AnythingOfType("params.Organization")).Return(s.Fixtures.PoolMgrMock, s.Fixtures.ErrMock) _, err := s.Runner.UpdateOrganization(s.Fixtures.AdminContext, s.Fixtures.StoreOrgs["test-org-1"].ID, s.Fixtures.UpdateRepoParams) - s.Fixtures.PoolMgrMock.AssertExpectations(s.T()) s.Fixtures.PoolMgrCtrlMock.AssertExpectations(s.T()) s.Require().Equal(fmt.Sprintf("updating org pool manager: %s", s.Fixtures.ErrMock.Error()), err.Error()) } func (s *OrgTestSuite) TestUpdateOrganizationCreateOrgPoolMgrFailed() { - s.Fixtures.PoolMgrCtrlMock.On("GetOrgPoolManager", mock.AnythingOfType("params.Organization")).Return(s.Fixtures.PoolMgrMock, nil) - s.Fixtures.PoolMgrCtrlMock.On("CreateOrgPoolManager", s.Fixtures.AdminContext, mock.AnythingOfType("params.Organization"), s.Fixtures.Providers, s.Fixtures.Store).Return(s.Fixtures.PoolMgrMock, s.Fixtures.ErrMock) + s.Fixtures.PoolMgrCtrlMock.On("UpdateOrgPoolManager", s.Fixtures.AdminContext, mock.AnythingOfType("params.Organization")).Return(s.Fixtures.PoolMgrMock, s.Fixtures.ErrMock) _, err := s.Runner.UpdateOrganization(s.Fixtures.AdminContext, s.Fixtures.StoreOrgs["test-org-1"].ID, s.Fixtures.UpdateRepoParams) - s.Fixtures.PoolMgrMock.AssertExpectations(s.T()) s.Fixtures.PoolMgrCtrlMock.AssertExpectations(s.T()) - s.Require().Equal(fmt.Sprintf("creating org pool manager: %s", s.Fixtures.ErrMock.Error()), err.Error()) + s.Require().Equal(fmt.Sprintf("updating org pool manager: %s", s.Fixtures.ErrMock.Error()), err.Error()) } func (s *OrgTestSuite) TestCreateOrgPool() { diff --git a/runner/repositories.go b/runner/repositories.go index 4fd0b6d7..77e594fc 100644 --- a/runner/repositories.go +++ b/runner/repositories.go @@ -182,24 +182,9 @@ func (r *Runner) UpdateRepository(ctx context.Context, repoID string, param para return params.Repository{}, errors.Wrap(err, "updating repo") } - poolMgr, err := r.poolManagerCtrl.GetRepoPoolManager(repo) - if err == nil { - internalCfg, err := r.poolManagerCtrl.GetInternalConfig(repo.CredentialsName) - if err != nil { - return params.Repository{}, errors.Wrap(err, "fetching internal config") - } - newState := params.UpdatePoolStateParams{ - WebhookSecret: repo.WebhookSecret, - InternalConfig: &internalCfg, - } - if err := poolMgr.RefreshState(newState); err != nil { - return params.Repository{}, errors.Wrap(err, "updating repo pool manager") - } - } else { - poolMgr, err = r.poolManagerCtrl.CreateRepoPoolManager(r.ctx, repo, r.providers, r.store) - if err != nil { - return params.Repository{}, errors.Wrap(err, "creating repo pool manager") - } + poolMgr, err := r.poolManagerCtrl.UpdateRepoPoolManager(r.ctx, repo) + if err != nil { + return params.Repository{}, fmt.Errorf("failed to update pool manager: %w", err) } repo.PoolManagerStatus = poolMgr.Status() diff --git a/runner/repositories_test.go b/runner/repositories_test.go index ba84868b..68a8c14a 100644 --- a/runner/repositories_test.go +++ b/runner/repositories_test.go @@ -293,13 +293,13 @@ func (s *RepoTestSuite) TestDeleteRepositoryPoolMgrFailed() { } func (s *RepoTestSuite) TestUpdateRepository() { - s.Fixtures.PoolMgrCtrlMock.On("GetRepoPoolManager", mock.AnythingOfType("params.Repository")).Return(s.Fixtures.PoolMgrMock, nil) - s.Fixtures.PoolMgrCtrlMock.On("CreateRepoPoolManager", s.Fixtures.AdminContext, mock.AnythingOfType("params.Repository"), s.Fixtures.Providers, s.Fixtures.Store).Return(s.Fixtures.PoolMgrMock, nil) + s.Fixtures.PoolMgrCtrlMock.On("UpdateRepoPoolManager", s.Fixtures.AdminContext, mock.AnythingOfType("params.Repository")).Return(s.Fixtures.PoolMgrMock, nil) + s.Fixtures.PoolMgrMock.On("Status").Return(params.PoolManagerStatus{IsRunning: true}, nil) repo, err := s.Runner.UpdateRepository(s.Fixtures.AdminContext, s.Fixtures.StoreRepos["test-repo-1"].ID, s.Fixtures.UpdateRepoParams) - s.Fixtures.PoolMgrMock.AssertExpectations(s.T()) s.Fixtures.PoolMgrCtrlMock.AssertExpectations(s.T()) + s.Fixtures.PoolMgrMock.AssertExpectations(s.T()) s.Require().Nil(err) s.Require().Equal(s.Fixtures.UpdateRepoParams.CredentialsName, repo.CredentialsName) s.Require().Equal(s.Fixtures.UpdateRepoParams.WebhookSecret, repo.WebhookSecret) @@ -320,25 +320,21 @@ func (s *RepoTestSuite) TestUpdateRepositoryInvalidCreds() { } func (s *RepoTestSuite) TestUpdateRepositoryPoolMgrFailed() { - s.Fixtures.PoolMgrCtrlMock.On("GetRepoPoolManager", mock.AnythingOfType("params.Repository")).Return(s.Fixtures.PoolMgrMock, s.Fixtures.ErrMock) - s.Fixtures.PoolMgrMock.On("RefreshState", s.Fixtures.UpdatePoolStateParams).Return(s.Fixtures.ErrMock) + s.Fixtures.PoolMgrCtrlMock.On("UpdateRepoPoolManager", s.Fixtures.AdminContext, mock.AnythingOfType("params.Repository")).Return(s.Fixtures.PoolMgrMock, s.Fixtures.ErrMock) _, err := s.Runner.UpdateRepository(s.Fixtures.AdminContext, s.Fixtures.StoreRepos["test-repo-1"].ID, s.Fixtures.UpdateRepoParams) - s.Fixtures.PoolMgrMock.AssertExpectations(s.T()) s.Fixtures.PoolMgrCtrlMock.AssertExpectations(s.T()) - s.Require().Equal(fmt.Sprintf("updating repo pool manager: %s", s.Fixtures.ErrMock.Error()), err.Error()) + s.Require().Equal(fmt.Sprintf("failed to update pool manager: %s", s.Fixtures.ErrMock.Error()), err.Error()) } func (s *RepoTestSuite) TestUpdateRepositoryCreateRepoPoolMgrFailed() { - s.Fixtures.PoolMgrCtrlMock.On("GetRepoPoolManager", mock.AnythingOfType("params.Repository")).Return(s.Fixtures.PoolMgrMock, nil) - s.Fixtures.PoolMgrCtrlMock.On("CreateRepoPoolManager", s.Fixtures.AdminContext, mock.AnythingOfType("params.Repository"), s.Fixtures.Providers, s.Fixtures.Store).Return(s.Fixtures.PoolMgrMock, s.Fixtures.ErrMock) + s.Fixtures.PoolMgrCtrlMock.On("UpdateRepoPoolManager", s.Fixtures.AdminContext, mock.AnythingOfType("params.Repository")).Return(s.Fixtures.PoolMgrMock, s.Fixtures.ErrMock) _, err := s.Runner.UpdateRepository(s.Fixtures.AdminContext, s.Fixtures.StoreRepos["test-repo-1"].ID, s.Fixtures.UpdateRepoParams) - s.Fixtures.PoolMgrMock.AssertExpectations(s.T()) s.Fixtures.PoolMgrCtrlMock.AssertExpectations(s.T()) - s.Require().Equal(fmt.Sprintf("creating repo pool manager: %s", s.Fixtures.ErrMock.Error()), err.Error()) + s.Require().Equal(fmt.Sprintf("failed to update pool manager: %s", s.Fixtures.ErrMock.Error()), err.Error()) } func (s *RepoTestSuite) TestCreateRepoPool() { diff --git a/runner/runner.go b/runner/runner.go index 37419be7..55753542 100644 --- a/runner/runner.go +++ b/runner/runner.go @@ -105,7 +105,7 @@ func (p *poolManagerCtrl) CreateRepoPoolManager(ctx context.Context, repo params p.mux.Lock() defer p.mux.Unlock() - cfgInternal, err := p.GetInternalConfig(repo.CredentialsName) + cfgInternal, err := p.getInternalConfig(repo.CredentialsName) if err != nil { return nil, errors.Wrap(err, "fetching internal config") } @@ -117,6 +117,31 @@ func (p *poolManagerCtrl) CreateRepoPoolManager(ctx context.Context, repo params return poolManager, nil } +func (p *poolManagerCtrl) UpdateRepoPoolManager(ctx context.Context, repo params.Repository) (common.PoolManager, error) { + p.mux.Lock() + defer p.mux.Unlock() + + poolMgr, ok := p.repositories[repo.ID] + if !ok { + return nil, errors.Wrapf(runnerErrors.ErrNotFound, "repository %s/%s pool manager not loaded", repo.Owner, repo.Name) + } + + internalCfg, err := p.getInternalConfig(repo.CredentialsName) + if err != nil { + return nil, errors.Wrap(err, "fetching internal config") + } + + newState := params.UpdatePoolStateParams{ + WebhookSecret: repo.WebhookSecret, + InternalConfig: &internalCfg, + } + + if err := poolMgr.RefreshState(newState); err != nil { + return nil, errors.Wrap(err, "updating repo pool manager") + } + return poolMgr, nil +} + func (p *poolManagerCtrl) GetRepoPoolManager(repo params.Repository) (common.PoolManager, error) { if repoPoolMgr, ok := p.repositories[repo.ID]; ok { return repoPoolMgr, nil @@ -146,7 +171,7 @@ func (p *poolManagerCtrl) CreateOrgPoolManager(ctx context.Context, org params.O p.mux.Lock() defer p.mux.Unlock() - cfgInternal, err := p.GetInternalConfig(org.CredentialsName) + cfgInternal, err := p.getInternalConfig(org.CredentialsName) if err != nil { return nil, errors.Wrap(err, "fetching internal config") } @@ -158,6 +183,31 @@ func (p *poolManagerCtrl) CreateOrgPoolManager(ctx context.Context, org params.O return poolManager, nil } +func (p *poolManagerCtrl) UpdateOrgPoolManager(ctx context.Context, org params.Organization) (common.PoolManager, error) { + p.mux.Lock() + defer p.mux.Unlock() + + poolMgr, ok := p.organizations[org.ID] + if !ok { + return nil, errors.Wrapf(runnerErrors.ErrNotFound, "org %s pool manager not loaded", org.Name) + } + + internalCfg, err := p.getInternalConfig(org.CredentialsName) + if err != nil { + return nil, errors.Wrap(err, "fetching internal config") + } + + newState := params.UpdatePoolStateParams{ + WebhookSecret: org.WebhookSecret, + InternalConfig: &internalCfg, + } + + if err := poolMgr.RefreshState(newState); err != nil { + return nil, errors.Wrap(err, "updating repo pool manager") + } + return poolMgr, nil +} + func (p *poolManagerCtrl) GetOrgPoolManager(org params.Organization) (common.PoolManager, error) { if orgPoolMgr, ok := p.organizations[org.ID]; ok { return orgPoolMgr, nil @@ -187,7 +237,7 @@ func (p *poolManagerCtrl) CreateEnterprisePoolManager(ctx context.Context, enter p.mux.Lock() defer p.mux.Unlock() - cfgInternal, err := p.GetInternalConfig(enterprise.CredentialsName) + cfgInternal, err := p.getInternalConfig(enterprise.CredentialsName) if err != nil { return nil, errors.Wrap(err, "fetching internal config") } @@ -199,6 +249,31 @@ func (p *poolManagerCtrl) CreateEnterprisePoolManager(ctx context.Context, enter return poolManager, nil } +func (p *poolManagerCtrl) UpdateEnterprisePoolManager(ctx context.Context, enterprise params.Enterprise) (common.PoolManager, error) { + p.mux.Lock() + defer p.mux.Unlock() + + poolMgr, ok := p.enterprises[enterprise.ID] + if !ok { + return nil, errors.Wrapf(runnerErrors.ErrNotFound, "enterprise %s pool manager not loaded", enterprise.Name) + } + + internalCfg, err := p.getInternalConfig(enterprise.CredentialsName) + if err != nil { + return nil, errors.Wrap(err, "fetching internal config") + } + + newState := params.UpdatePoolStateParams{ + WebhookSecret: enterprise.WebhookSecret, + InternalConfig: &internalCfg, + } + + if err := poolMgr.RefreshState(newState); err != nil { + return nil, errors.Wrap(err, "updating repo pool manager") + } + return poolMgr, nil +} + func (p *poolManagerCtrl) GetEnterprisePoolManager(enterprise params.Enterprise) (common.PoolManager, error) { if enterprisePoolMgr, ok := p.enterprises[enterprise.ID]; ok { return enterprisePoolMgr, nil @@ -224,7 +299,7 @@ func (p *poolManagerCtrl) GetEnterprisePoolManagers() (map[string]common.PoolMan return p.enterprises, nil } -func (p *poolManagerCtrl) GetInternalConfig(credsName string) (params.Internal, error) { +func (p *poolManagerCtrl) getInternalConfig(credsName string) (params.Internal, error) { creds, ok := p.credentials[credsName] if !ok { return params.Internal{}, runnerErrors.NewBadRequestError("invalid credential name (%s)", credsName)