quota

README

Определение квоты по памяти и цпу.

Компонент автоматически определяет квоты на использование цпу и памяти и передает это значение в runtime GoLang.

Объект конфигурации.

type Config struct {
	MemoryLimitHumanReadable     string
	MemoryLimit                  uint64
	CpuSecondsLimitHumanReadable string
	CpuSecondsLimit              uint32
}

Описание полей:

Поле	Описание	Значение по умолчанию
MemoryLimitHumanReadable	Человеко читаемое значение квоты памяти, этот параметр может быть передан одним из 3-х методов: - флаг командной строки --quota.memory - переменная окружения GOMEMLIMIT - значение в конфиг файле quota.memory
MemoryLimit	Значение квоты памяти в байтах, если пустое, в это поле будет распарсино значение из поля MemoryLimitHumanReadable, это поле может быть установлено только в коде на этапе конфигурирования приложения
CpuSecondsLimitHumanReadable	Человеко читаемое значение квоты использования цпу в значениях процессорного времени, этот параметр может быть передан одним из 3-х методов: - флаг командной строки --quota.cpu - переменная окружения GOMAXPROC - значение в конфиг файле quota.cpu
CpuSecondsLimit	Значение квоты использования цпу в значениях процессорного времени, если пустое, в это поле будет распарсино значение из поля CpuSecondsLimitHumanReadable, это поле может быть установлено только в коде на этапе конфигурирования приложения

Важно. Если все параметры пустые или не установлены, компонент предпринимает попытку автоматического получение квот от ОС:

• Linux - пакет будет парсить конфиги CGroup для получения квот, если в cgroup квоты не будут установлены, пакет запросит информацию у ОС о максимальном кол. памяти и цпу и будет использовать эти значения в качестве квоты;
• Остальные ОС, компонент будет полагаться на runtime GoLang.

Documentation

Index

• Constants
• Variables
• type Config
  • func Configuration(config *Config, configurator configurator.Configurator, appConfig *app.Config, ...) (*Config, error)
  • func NewConfig() *Config
• type GetQuotas
• type Quota
  • func New(config *Config) Quota
  • func NewWithConfigurator(config *Config, configurator configurator.Configurator, appConfig *app.Config) (Quota, error)
• type ReConfiguration
  • func NewReConfiguration(appConfig *app.Config, informer logger.Informer, config *Config) *ReConfiguration
  • func NewReConfigurationWithConfigurator(config *Config, configurator configurator.Configurator, appConfig *app.Config, ...) (*ReConfiguration, error)
  • func (reConfiguration *ReConfiguration) Memory() uint64
  • func (reConfiguration *ReConfiguration) Processes() uint8
  • func (reConfiguration *ReConfiguration) Quota() Quota
  • func (reConfiguration *ReConfiguration) ReConfiguration(configurator configurator.Configurator) error

Constants

const (
	MemoryLimitEnvFieldName  = "GOMEMLIMIT"
	ProcessLimitEnvFieldName = "GOMAXPROC"

	MemoryLimitHumanReadableFieldName     = "quota.memory.limit"
	CpuSecondsLimitHumanReadableFieldName = "quota.cpu.limit"

	EnabledMemoryLimitFieldName = "quota.memory.enabled"
	EnabledCpuLimitFieldName    = "quota.cpu.enabled"

	EnabledMemoryLimitDefault = false
	EnabledCpuLimitDefault    = false
)

Variables

var (
	MemoryLimitHumanReadableDefault = os.Getenv(MemoryLimitEnvFieldName)
	CpuSecondsLimitHumanReadable    = os.Getenv(ProcessLimitEnvFieldName)
)

var Component = &app.Component{
	Dependencies: app.Components{
		logger.Component,
		configurator.Component,
		re_configuration.Component,
		info.Component,
	},
	Constructor: func(container container.Container) error {
		return container.Provides(
			NewConfig,
			NewReConfigurationWithConfigurator,
			func(reConfiguration *ReConfiguration) Quota {
				return reConfiguration
			},
		)
	},
	BindFlags: func(flagSet *pflag.FlagSet, container container.Container) error {
		return container.Invoke(func(config *Config) {
			flagSet.StringVar(&config.MemoryLimitHumanReadable, MemoryLimitHumanReadableFieldName, MemoryLimitHumanReadableDefault, "memory limit")
			flagSet.StringVar(&config.CpuSecondsLimitHumanReadable, CpuSecondsLimitHumanReadableFieldName, CpuSecondsLimitHumanReadable, "cpu limit")
			flagSet.BoolVar(&config.MemoryLimitEnabled, EnabledMemoryLimitFieldName, EnabledMemoryLimitDefault, "enabling memory quotas")
			flagSet.BoolVar(&config.CpuLimitEnabled, EnabledCpuLimitFieldName, EnabledCpuLimitDefault, "enabling cpu quotas")
		})
	},
	Run: func(c container.Container) error {
		logger, err := container.Get[logger.Logger](c)
		if err != nil {
			return err
		}

		quota, err := container.Get[*ReConfiguration](c)
		if err != nil {
			logger.Error(err)
			return err
		}

		reConfiguration, err := container.Get[configurator.ReConfiguration](c)
		if err != nil {
			return err
		}

		reConfiguration.Registration(quota)
		logger.Info("quota: registration in the reConfigurator")

		if quota.Memory() > 0 {
			logger.Infof("quota: set memory limit %s", size.FormatBinary(quota.Memory()))
			debug.SetMemoryLimit(int64(quota.Memory()))
		} else {
			logger.Info("quota: memory quota tracking, at runtime, disabled")
		}

		if quota.Processes() > 0 {
			logger.Infof("quota: set the total number of processes %d", quota.Processes())
			runtime.GOMAXPROCS(int(quota.Processes()))
		} else {
			logger.Info("quota: cpu quota tracking, at runtime, disabled")
		}

		info, err := container.Get[info.Info](c)
		if err != nil {
			return err
		}

		config, err := container.Get[*Config](c)
		if err != nil {
			return err
		}

		info.Registration("quota", config)

		return nil
	},
}

Types

type Config

type Config struct {
	MemoryLimitEnabled           bool
	MemoryLimitHumanReadable     string
	MemoryLimit                  uint64
	CpuLimitEnabled              bool
	CpuSecondsLimitHumanReadable string
	CpuSecondsLimit              uint32
}

func Configuration

func Configuration(config *Config, configurator configurator.Configurator, appConfig *app.Config, getQuotas GetQuotas) (*Config, error)

func NewConfig

func NewConfig() *Config

type GetQuotas

type GetQuotas func(appConfig *app.Config) (uint64, uint32, error)

type Quota

type Quota interface {
	Memory() uint64
	Processes() uint8
}

func New

func New(config *Config) Quota

func NewWithConfigurator

func NewWithConfigurator(config *Config, configurator configurator.Configurator, appConfig *app.Config) (Quota, error)

type ReConfiguration

type ReConfiguration struct {
	// contains filtered or unexported fields
}

func NewReConfiguration

func NewReConfiguration(appConfig *app.Config, informer logger.Informer, config *Config) *ReConfiguration

func NewReConfigurationWithConfigurator

func NewReConfigurationWithConfigurator(config *Config, configurator configurator.Configurator, appConfig *app.Config, informer logger.Informer) (*ReConfiguration, error)

func (*ReConfiguration) Memory

func (reConfiguration *ReConfiguration) Memory() uint64

func (*ReConfiguration) Processes

func (reConfiguration *ReConfiguration) Processes() uint8

func (*ReConfiguration) Quota

func (reConfiguration *ReConfiguration) Quota() Quota

func (*ReConfiguration) ReConfiguration

func (reConfiguration *ReConfiguration) ReConfiguration(configurator configurator.Configurator) error