re_configuration.go

package memory

import (
	"context"
	"github.com/D3rus/go-library/configurator"
	"github.com/D3rus/go-library/logger"
	"github.com/D3rus/go-library/quota"
	"sync"
)

type ReConfiguration struct {
	stater        Stater
	staterRWMutex *sync.RWMutex

	quota  quota.Quota
	logger logger.Logger

	config *Config

	generalCtx context.Context

	ctx        context.Context
	cancelFunc context.CancelFunc
	wg         *sync.WaitGroup
}

func NewReConfigurationWithConfigurator(quota quota.Quota, logger logger.Logger, config *Config, configurator configurator.Configurator) *ReConfiguration {
	return NewReConfiguration(quota, logger, Configuration(config, configurator))
}

func NewReConfiguration(quota quota.Quota, logger logger.Logger, config *Config) *ReConfiguration {
	return &ReConfiguration{
		stater:        New(config, logger, quota),
		staterRWMutex: &sync.RWMutex{},
		quota:         quota,
		logger:        logger,
		config:        config,
		wg:            &sync.WaitGroup{},
	}
}

func (reConfiguration *ReConfiguration) State() State {
	return reConfiguration.Stater().State()
}

func (reConfiguration *ReConfiguration) ReConfiguration(configurator configurator.Configurator) error {
	isConfigChange := false

	config := Configuration(NewConfig(), configurator)

	if config.CriticalPercent != reConfiguration.config.CriticalPercent {
		reConfiguration.logger.Infof("memoryStater: old critical percent '%d%', new critical percent '%d%'", reConfiguration.config.CriticalPercent, config.CriticalPercent)

		reConfiguration.config.CriticalPercent = config.CriticalPercent
		isConfigChange = true
	}

	if config.WarnPercent != reConfiguration.config.WarnPercent {
		reConfiguration.logger.Infof("memoryStater: old warn percent '%d%', new warn percent '%d%'", reConfiguration.config.WarnPercent, config.WarnPercent)

		reConfiguration.config.WarnPercent = config.WarnPercent
		isConfigChange = true
	}

	if config.ScanInterval != reConfiguration.config.ScanInterval {
		reConfiguration.logger.Infof("memoryStater: old scan interval '%s', new scan interval '%s'", reConfiguration.config.ScanInterval, config.ScanInterval)

		reConfiguration.config.ScanInterval = config.ScanInterval
		isConfigChange = true
	}

	if isConfigChange {
		reConfiguration.logger.Info("memoryStater: config change detected")

		reConfiguration.Stop()
		reConfiguration.SetStater(New(reConfiguration.config, reConfiguration.logger, reConfiguration.quota))
		reConfiguration.Start(reConfiguration.generalCtx)
	}

	return nil
}

func (reConfiguration *ReConfiguration) Stater() Stater {
	reConfiguration.staterRWMutex.RLock()
	defer reConfiguration.staterRWMutex.RUnlock()

	return reConfiguration.stater
}

func (reConfiguration *ReConfiguration) SetStater(stater Stater) {
	reConfiguration.staterRWMutex.Lock()
	defer reConfiguration.staterRWMutex.Unlock()

	reConfiguration.stater = stater
}

func (reConfiguration *ReConfiguration) Start(ctx context.Context) {
	reConfiguration.ctx, reConfiguration.cancelFunc = context.WithCancel(ctx)
	reConfiguration.wg.Add(1)

	go func(ctx context.Context) {
		defer reConfiguration.wg.Done()
		if err := reConfiguration.Stater().Process(ctx); err != nil {
			reConfiguration.logger.Error(err)
		}
	}(reConfiguration.ctx)
}

func (reConfiguration *ReConfiguration) Stop() {
	reConfiguration.cancelFunc()

	reConfiguration.wg.Wait()
}

func (reConfiguration *ReConfiguration) Name() string {
	return reConfiguration.Stater().Name()
}

func (reConfiguration *ReConfiguration) Process(ctx context.Context) error {
	ctx, cancelFunc := context.WithCancel(ctx)
	defer cancelFunc()

	reConfiguration.generalCtx = ctx

	reConfiguration.Start(reConfiguration.generalCtx)

	<-ctx.Done()

	reConfiguration.Stop()

	return nil
}