pool

Documentation

Index

• Constants
• Variables
• type Config
  • func Configuration(config *Config, configurator configurator.Configurator) *Config
  • func NewConfig() *Config
• type Pool
  • func NewPool(config *Config, monitorCfg *monitor.Config, connectorCfg *connector.Config, ...) (*Pool, error)
  • func NewWithConfigurator(config *Config, configurator configurator.Configurator, ...) (*Pool, error)
  • func (pool *Pool) Close() error
  • func (pool *Pool) Get() monitor.Monitor
  • func (pool *Pool) GetChan() chan monitor.Monitor
  • func (pool *Pool) Name() string
  • func (pool *Pool) Process(ctx context.Context) error
  • func (pool *Pool) Put(client monitor.Monitor)
• type Pooler

Constants

const (
	SizeFieldName = "client.socket.pool.size"

	SizeDefault = 10
)

Variables

var Component = &app.Component{
	Dependencies: app.Components{
		logger.Component,
		configurator.Component,
		runner.Component,
		metric.Component,
	},
	Constructor: app.Constructor(func(container container.Container) error {
		return container.Provides(
			monitor.NewConfig,
			counter.NewConfig,
			connector.NewConfig,
			middleware.NewReadConfig,
			middleware.NewWriteConfig,

			NewConfig,
			NewWithConfigurator,
			func(pool *Pool) Pooler { return pool },
		)
	}),
	BindFlags: app.BindFlags(func(flagSet *pflag.FlagSet, container container.Container) error {
		if err := monitor.BindFlags(flagSet, container); err != nil {
			return err
		}

		if err := counter.BindFlags(flagSet, container); err != nil {
			return err
		}

		if err := connector.BindFlags(flagSet, container); err != nil {
			return err
		}

		if err := middleware.ReadTimeoutComponentBindFlags(flagSet, container); err != nil {
			return err
		}

		if err := middleware.WriteTimeoutComponentBindFlags(flagSet, container); err != nil {
			return err
		}

		return container.Invoke(func(config *Config) {
			flagSet.Uint8Var(&config.Size, SizeFieldName, SizeDefault, "")
		})
	}),
	Run: app.Run(func(container container.Container) error {
		if err := container.Invoke(connector.Configuration); err != nil {
			return err
		}

		if err := container.Invoke(counter.Configuration); err != nil {
			return err
		}

		if err := container.Invoke(monitor.Configuration); err != nil {
			return err
		}

		if err := container.Invoke(middleware.ReadConfigConfiguration); err != nil {
			return err
		}

		if err := container.Invoke(middleware.WriteConfigConfiguration); err != nil {
			return err
		}

		return container.Invoke(func(pool Pooler, runner runner.Runner) error {
			return runner.AddProcesses(pool)
		})
	}),
}

Types

type Config

type Config struct {
	Size uint8
}

func Configuration

func Configuration(config *Config, configurator configurator.Configurator) *Config

func NewConfig

func NewConfig() *Config

type Pool

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

func NewPool

func NewPool(
	config *Config,
	monitorCfg *monitor.Config,
	connectorCfg *connector.Config,
	counterCfg *counter.Config,
	logger logger.Logger,
	middlewareReadCfg *middleware.ReadConfig,
	middlewareWriteCfg *middleware.WriteConfig,
	runner runner.Runner,
	metric *metric.Metric,
) (*Pool, error)

func NewWithConfigurator

func NewWithConfigurator(
	config *Config,
	configurator configurator.Configurator,
	monitorCfg *monitor.Config,
	connectorCfg *connector.Config,
	counterCfg *counter.Config,
	logger logger.Logger,
	middlewareReadCfg *middleware.ReadConfig,
	middlewareWriteCfg *middleware.WriteConfig,
	runner runner.Runner,
	metric *metric.Metric,
) (*Pool, error)

func (*Pool) Close

func (pool *Pool) Close() error

func (*Pool) Get

func (pool *Pool) Get() monitor.Monitor

func (*Pool) GetChan

func (pool *Pool) GetChan() chan monitor.Monitor

func (*Pool) Name

func (pool *Pool) Name() string

func (*Pool) Process

func (pool *Pool) Process(ctx context.Context) error

func (*Pool) Put

func (pool *Pool) Put(client monitor.Monitor)

type Pooler

type Pooler interface {
	io.Closer
	runner.Process
	Get() monitor.Monitor
	GetChan() chan monitor.Monitor
	Put(client monitor.Monitor)
}