From 8d57c25890edfda3310beb5e5d158d5245e1e963 Mon Sep 17 00:00:00 2001 From: Mile Druzijanic Date: Mon, 20 May 2024 16:38:02 +0200 Subject: [PATCH] adding processHandler struct update --- internal/mode/static/manager.go | 5 +- internal/mode/static/nginx/runtime/manager.go | 7 +- .../runtimefakes/fake_process_handler.go | 76 +++++++++++++++++++ 3 files changed, 83 insertions(+), 5 deletions(-) diff --git a/internal/mode/static/manager.go b/internal/mode/static/manager.go index 63313af572..9829f35c90 100644 --- a/internal/mode/static/manager.go +++ b/internal/mode/static/manager.go @@ -63,6 +63,7 @@ const ( ) var scheme = runtime.NewScheme() +var proccesHandler = &ngxruntime.ProcessHandlerImpl{} func init() { utilruntime.Must(gatewayv1beta1.Install(scheme)) @@ -134,7 +135,7 @@ func StartManager(cfg config.Config) error { } // Ensure NGINX is running before registering metrics & starting the manager. - if err := ngxruntime.EnsureNginxRunning(ctx, &ngxruntime.ProcessHandlerImpl{}); err != nil { + if err := proccesHandler.EnsureNginxRunning(ctx); err != nil { return fmt.Errorf("NGINX is not running: %w", err) } @@ -211,7 +212,7 @@ func StartManager(cfg config.Config) error { ngxPlusClient, ngxruntimeCollector, cfg.Logger.WithName("nginxRuntimeManager"), - &ngxruntime.ProcessHandlerImpl{}, + proccesHandler, ngxruntime.NewVerifyClient(ngxruntime.NginxReloadTimeout), ), statusUpdater: groupStatusUpdater, diff --git a/internal/mode/static/nginx/runtime/manager.go b/internal/mode/static/nginx/runtime/manager.go index a235a3bc7d..2af0c45f3f 100644 --- a/internal/mode/static/nginx/runtime/manager.go +++ b/internal/mode/static/nginx/runtime/manager.go @@ -36,12 +36,13 @@ type nginxPlusClient interface { GetUpstreams() (*ngxclient.Upstreams, error) } -//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 . processHandler +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 . ProcessHandler type ProcessHandler interface { FindMainProcess(ctx context.Context, checkFile CheckFileFunc, readFile ReadFileFunc, timeout time.Duration) (int, error) ReadFile(file string) ([]byte, error) Kill(pid int, signum syscall.Signal) error + EnsureNginxRunning(ctx context.Context) error } type ProcessHandlerImpl struct { @@ -176,8 +177,8 @@ func (m *ManagerImpl) GetUpstreams() (ngxclient.Upstreams, error) { } // EnsureNginxRunning ensures NGINX is running by locating the main process. -func EnsureNginxRunning(ctx context.Context, processHandler ProcessHandler) error { - if _, err := processHandler.FindMainProcess(ctx, os.Stat, os.ReadFile, pidFileTimeout); err != nil { +func (p *ProcessHandlerImpl) EnsureNginxRunning(ctx context.Context) error { + if _, err := p.FindMainProcess(ctx, os.Stat, os.ReadFile, pidFileTimeout); err != nil { return fmt.Errorf("failed to find NGINX main process: %w", err) } return nil diff --git a/internal/mode/static/nginx/runtime/runtimefakes/fake_process_handler.go b/internal/mode/static/nginx/runtime/runtimefakes/fake_process_handler.go index b0b8e3ca74..c5d63ff2c7 100644 --- a/internal/mode/static/nginx/runtime/runtimefakes/fake_process_handler.go +++ b/internal/mode/static/nginx/runtime/runtimefakes/fake_process_handler.go @@ -11,6 +11,17 @@ import ( ) type FakeProcessHandler struct { + EnsureNginxRunningStub func(context.Context) error + ensureNginxRunningMutex sync.RWMutex + ensureNginxRunningArgsForCall []struct { + arg1 context.Context + } + ensureNginxRunningReturns struct { + result1 error + } + ensureNginxRunningReturnsOnCall map[int]struct { + result1 error + } FindMainProcessStub func(context.Context, runtime.CheckFileFunc, runtime.ReadFileFunc, time.Duration) (int, error) findMainProcessMutex sync.RWMutex findMainProcessArgsForCall []struct { @@ -56,6 +67,67 @@ type FakeProcessHandler struct { invocationsMutex sync.RWMutex } +func (fake *FakeProcessHandler) EnsureNginxRunning(arg1 context.Context) error { + fake.ensureNginxRunningMutex.Lock() + ret, specificReturn := fake.ensureNginxRunningReturnsOnCall[len(fake.ensureNginxRunningArgsForCall)] + fake.ensureNginxRunningArgsForCall = append(fake.ensureNginxRunningArgsForCall, struct { + arg1 context.Context + }{arg1}) + stub := fake.EnsureNginxRunningStub + fakeReturns := fake.ensureNginxRunningReturns + fake.recordInvocation("EnsureNginxRunning", []interface{}{arg1}) + fake.ensureNginxRunningMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeProcessHandler) EnsureNginxRunningCallCount() int { + fake.ensureNginxRunningMutex.RLock() + defer fake.ensureNginxRunningMutex.RUnlock() + return len(fake.ensureNginxRunningArgsForCall) +} + +func (fake *FakeProcessHandler) EnsureNginxRunningCalls(stub func(context.Context) error) { + fake.ensureNginxRunningMutex.Lock() + defer fake.ensureNginxRunningMutex.Unlock() + fake.EnsureNginxRunningStub = stub +} + +func (fake *FakeProcessHandler) EnsureNginxRunningArgsForCall(i int) context.Context { + fake.ensureNginxRunningMutex.RLock() + defer fake.ensureNginxRunningMutex.RUnlock() + argsForCall := fake.ensureNginxRunningArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeProcessHandler) EnsureNginxRunningReturns(result1 error) { + fake.ensureNginxRunningMutex.Lock() + defer fake.ensureNginxRunningMutex.Unlock() + fake.EnsureNginxRunningStub = nil + fake.ensureNginxRunningReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeProcessHandler) EnsureNginxRunningReturnsOnCall(i int, result1 error) { + fake.ensureNginxRunningMutex.Lock() + defer fake.ensureNginxRunningMutex.Unlock() + fake.EnsureNginxRunningStub = nil + if fake.ensureNginxRunningReturnsOnCall == nil { + fake.ensureNginxRunningReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.ensureNginxRunningReturnsOnCall[i] = struct { + result1 error + }{result1} +} + func (fake *FakeProcessHandler) FindMainProcess(arg1 context.Context, arg2 runtime.CheckFileFunc, arg3 runtime.ReadFileFunc, arg4 time.Duration) (int, error) { fake.findMainProcessMutex.Lock() ret, specificReturn := fake.findMainProcessReturnsOnCall[len(fake.findMainProcessArgsForCall)] @@ -252,6 +324,8 @@ func (fake *FakeProcessHandler) ReadFileReturnsOnCall(i int, result1 []byte, res func (fake *FakeProcessHandler) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() + fake.ensureNginxRunningMutex.RLock() + defer fake.ensureNginxRunningMutex.RUnlock() fake.findMainProcessMutex.RLock() defer fake.findMainProcessMutex.RUnlock() fake.killMutex.RLock() @@ -276,3 +350,5 @@ func (fake *FakeProcessHandler) recordInvocation(key string, args []interface{}) } fake.invocations[key] = append(fake.invocations[key], args) } + +var _ runtime.ProcessHandler = new(FakeProcessHandler)