opensource/grafana
1
0
Fork 0
mirror of https://github.com/grafana/grafana.git synced 2025-08-02 03:12:13 +08:00
Code Issues Packages Projects Releases Wiki Activity

Plugins: Remove registry dependency from process manager (#73241)

Browse Source 
simplify
This commit is contained in:
Will Browne
2023-08-16 10:46:00 +02:00
committed by GitHub
parent d935e6ff57
commit 75b0788377
16 changed files with 202 additions and 221 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
pkg/plugins/manager/process/ifaces.go
View File

@ -1,10 +1,14 @@
package process
import "context"
import (
"context"
type Service interface {
"github.com/grafana/grafana/pkg/plugins"
)
type Manager interface {
// Start executes a backend plugin process.
Start(ctx context.Context, pluginID string) error
Start(ctx context.Context, p *plugins.Plugin) error
// Stop terminates a backend plugin process.
Stop(ctx context.Context, pluginID string) error
Stop(ctx context.Context, p *plugins.Plugin) error
}

70
pkg/plugins/manager/process/process.go
View File

@ -3,54 +3,22 @@ package process
import (
"context"
"errors"
"sync"
"time"
"github.com/grafana/grafana/pkg/plugins"
"github.com/grafana/grafana/pkg/plugins/backendplugin"
"github.com/grafana/grafana/pkg/plugins/log"
"github.com/grafana/grafana/pkg/plugins/manager/registry"
)
var _ Service = (*Manager)(nil)
type Service struct{}
type Manager struct {
pluginRegistry registry.Service
mu sync.Mutex
log log.Logger
func ProvideService() *Service {
return &Service{}
}
func ProvideService(pluginRegistry registry.Service) *Manager {
return NewManager(pluginRegistry)
}
func NewManager(pluginRegistry registry.Service) *Manager {
return &Manager{
pluginRegistry: pluginRegistry,
log: log.New("plugin.process.manager"),
}
}
func (m *Manager) Run(ctx context.Context) error {
<-ctx.Done()
m.shutdown(ctx)
return ctx.Err()
}
func (m *Manager) Start(ctx context.Context, pluginID string) error {
p, exists := m.pluginRegistry.Plugin(ctx, pluginID)
if !exists {
return backendplugin.ErrPluginNotRegistered
}
func (*Service) Start(ctx context.Context, p *plugins.Plugin) error {
if !p.IsManaged() || !p.Backend || p.SignatureError != nil {
return nil
}
m.mu.Lock()
defer m.mu.Unlock()
if err := startPluginAndRestartKilledProcesses(ctx, p); err != nil {
return err
}
@ -59,15 +27,8 @@ func (m *Manager) Start(ctx context.Context, pluginID string) error {
return nil
}
func (m *Manager) Stop(ctx context.Context, pluginID string) error {
p, exists := m.pluginRegistry.Plugin(ctx, pluginID)
if !exists {
return backendplugin.ErrPluginNotRegistered
}
m.log.Debug("Stopping plugin process", "pluginId", p.ID)
m.mu.Lock()
defer m.mu.Unlock()
func (*Service) Stop(ctx context.Context, p *plugins.Plugin) error {
p.Logger().Debug("Stopping plugin process")
if err := p.Decommission(); err != nil {
return err
}
@ -79,23 +40,6 @@ func (m *Manager) Stop(ctx context.Context, pluginID string) error {
return nil
}
// shutdown stops all backend plugin processes
func (m *Manager) shutdown(ctx context.Context) {
var wg sync.WaitGroup
for _, p := range m.pluginRegistry.Plugins(ctx) {
wg.Add(1)
go func(p backendplugin.Plugin, ctx context.Context) {
defer wg.Done()
p.Logger().Debug("Stopping plugin")
if err := p.Stop(ctx); err != nil {
p.Logger().Error("Failed to stop plugin", "error", err)
}
p.Logger().Debug("Plugin stopped")
}(p, ctx)
}
wg.Wait()
}
func startPluginAndRestartKilledProcesses(ctx context.Context, p *plugins.Plugin) error {
if err := p.Start(ctx); err != nil {
return err
@ -123,7 +67,7 @@ func restartKilledProcess(ctx context.Context, p *plugins.Plugin) error {
if err := ctx.Err(); err != nil && !errors.Is(err, context.Canceled) {
return err
}
return nil
return p.Stop(ctx)
case <-ticker.C:
if p.IsDecommissioned() {
p.Logger().Debug("Plugin decommissioned")

140
pkg/plugins/manager/process/process_test.go
View File

@ -14,12 +14,6 @@ import (
)
func TestProcessManager_Start(t *testing.T) {
t.Run("Plugin not found in registry", func(t *testing.T) {
m := NewManager(fakes.NewFakePluginRegistry())
err := m.Start(context.Background(), "non-existing-datasource")
require.ErrorIs(t, err, backendplugin.ErrPluginNotRegistered)
})
t.Run("Plugin state determines process start", func(t *testing.T) {
tcs := []struct {
name string
@ -58,21 +52,16 @@ func TestProcessManager_Start(t *testing.T) {
}
for _, tc := range tcs {
t.Run(tc.name, func(t *testing.T) {
bp := newFakeBackendPlugin(tc.managed)
bp := fakes.NewFakeBackendPlugin(tc.managed)
p := createPlugin(t, bp, func(plugin *plugins.Plugin) {
plugin.Backend = tc.backend
plugin.SignatureError = tc.signatureError
})
m := NewManager(&fakes.FakePluginRegistry{
Store: map[string]*plugins.Plugin{
p.ID: p,
}},
)
err := m.Start(context.Background(), p.ID)
m := &Service{}
err := m.Start(context.Background(), p)
require.NoError(t, err)
require.Equal(t, tc.expectedStartCount, bp.startCount)
require.Equal(t, tc.expectedStartCount, bp.StartCount)
if tc.expectedStartCount > 0 {
require.True(t, !p.Exited())
@ -85,67 +74,42 @@ func TestProcessManager_Start(t *testing.T) {
}
func TestProcessManager_Stop(t *testing.T) {
t.Run("Plugin not found in registry", func(t *testing.T) {
m := NewManager(fakes.NewFakePluginRegistry())
err := m.Stop(context.Background(), "non-existing-datasource")
require.ErrorIs(t, err, backendplugin.ErrPluginNotRegistered)
})
t.Run("Can stop a running plugin", func(t *testing.T) {
pluginID := "test-datasource"
bp := newFakeBackendPlugin(true)
bp := fakes.NewFakeBackendPlugin(true)
p := createPlugin(t, bp, func(plugin *plugins.Plugin) {
plugin.ID = pluginID
plugin.Backend = true
})
m := NewManager(&fakes.FakePluginRegistry{
Store: map[string]*plugins.Plugin{
pluginID: p,
}},
)
err := m.Stop(context.Background(), pluginID)
m := &Service{}
err := m.Stop(context.Background(), p)
require.NoError(t, err)
require.True(t, p.IsDecommissioned())
require.True(t, bp.decommissioned)
require.True(t, p.Exited())
require.Equal(t, 1, bp.stopCount)
require.Equal(t, 1, bp.StopCount)
})
}
func TestProcessManager_ManagedBackendPluginLifecycle(t *testing.T) {
bp := newFakeBackendPlugin(true)
bp := fakes.NewFakeBackendPlugin(true)
p := createPlugin(t, bp, func(plugin *plugins.Plugin) {
plugin.Backend = true
})
m := NewManager(&fakes.FakePluginRegistry{
Store: map[string]*plugins.Plugin{
p.ID: p,
}},
)
m := &Service{}
err := m.Start(context.Background(), p.ID)
err := m.Start(context.Background(), p)
require.NoError(t, err)
require.Equal(t, 1, bp.startCount)
require.Equal(t, 1, bp.StartCount)
t.Run("When plugin process is killed, the process is restarted", func(t *testing.T) {
pCtx := context.Background()
cCtx, cancel := context.WithCancel(pCtx)
var wgRun sync.WaitGroup
wgRun.Add(1)
var runErr error
go func() {
runErr = m.Run(cCtx)
wgRun.Done()
}()
var wgKill sync.WaitGroup
wgKill.Add(1)
go func() {
bp.kill() // manually kill process
bp.Kill() // manually kill process
for {
if !bp.Exited() {
break
@ -155,85 +119,15 @@ func TestProcessManager_ManagedBackendPluginLifecycle(t *testing.T) {
}()
wgKill.Wait()
require.True(t, !p.Exited())
require.Equal(t, 2, bp.startCount)
require.Equal(t, 0, bp.stopCount)
require.Equal(t, 2, bp.StartCount)
require.Equal(t, 0, bp.StopCount)
t.Run("When context is cancelled the plugin is stopped", func(t *testing.T) {
cancel()
wgRun.Wait()
require.ErrorIs(t, runErr, context.Canceled)
require.True(t, p.Exited())
require.Equal(t, 2, bp.startCount)
require.Equal(t, 1, bp.stopCount)
t.Cleanup(func() {
require.NoError(t, m.Stop(context.Background(), p))
})
})
}
type fakeBackendPlugin struct {
managed bool
startCount int
stopCount int
decommissioned bool
running bool
mutex sync.RWMutex
backendplugin.Plugin
}
func newFakeBackendPlugin(managed bool) *fakeBackendPlugin {
return &fakeBackendPlugin{
managed: managed,
}
}
func (p *fakeBackendPlugin) Start(_ context.Context) error {
p.mutex.Lock()
defer p.mutex.Unlock()
p.running = true
p.startCount++
return nil
}
func (p *fakeBackendPlugin) Stop(_ context.Context) error {
p.mutex.Lock()
defer p.mutex.Unlock()
p.running = false
p.stopCount++
return nil
}
func (p *fakeBackendPlugin) Decommission() error {
p.mutex.Lock()
defer p.mutex.Unlock()
p.decommissioned = true
return nil
}
func (p *fakeBackendPlugin) IsDecommissioned() bool {
p.mutex.RLock()
defer p.mutex.RUnlock()
return p.decommissioned
}
func (p *fakeBackendPlugin) IsManaged() bool {
p.mutex.RLock()
defer p.mutex.RUnlock()
return p.managed
}
func (p *fakeBackendPlugin) Exited() bool {
p.mutex.RLock()
defer p.mutex.RUnlock()
return !p.running
}
func (p *fakeBackendPlugin) kill() {
p.mutex.Lock()
defer p.mutex.Unlock()
p.running = false
}
func createPlugin(t *testing.T, bp backendplugin.Plugin, cbs ...func(p *plugins.Plugin)) *plugins.Plugin {
t.Helper()