middleware

Documentation

Index

• Constants
• Variables
• func ConnectionLogger(informer logger.Informer) server.MiddlewareFunc
• func ReadBytesLogger(logger logger.Logger) server.MiddlewareFunc
• func ReadBytesMetric(informer logger.Informer, metric *metric.Metric) server.MiddlewareFunc
• func ReadBytesMetricWithName(informer logger.Informer, metric *metric.Metric, name string) server.MiddlewareFunc
• func ReadTimeout(config *ReadConfig, informer logger.Informer) server.Middleware
• func Recoverer(logger logger.Logger) server.MiddlewareFunc
• func WriteBytesLogger(logger logger.Logger) server.MiddlewareFunc
• func WriteBytesMetric(informer logger.Informer, metric *metric.Metric) server.MiddlewareFunc
• func WriteBytesMetricWithName(informer logger.Informer, metric *metric.Metric, name string) server.MiddlewareFunc
• func WriteTimeout(config *WriteConfig, informer logger.Informer) server.MiddlewareFunc
• type ConnectionCounter
  • func NewConnectionCounter(appConfig *app.Config) *ConnectionCounter
  • func (middleware *ConnectionCounter) Middleware(next server.Handler) server.Handler
• type ReadConfig
  • func NewReadConfig() *ReadConfig
• type WriteConfig
  • func NewWriteConfig() *WriteConfig

Constants

const (
	WriteTimeoutFieldName = "server.socket.timeout.write"
	ReadTimeoutFieldName  = "server.socket.timeout.read"

	WriteTimeoutDefault = 10 * time.Second
	ReadTimeoutDefault  = 10 * time.Second
)

Variables

var (
	ReadBytesLoggerComponent = &app.Component{
		Dependencies: app.Components{
			logger.Component,
			server.Component,
		},
		Run: app.Run(func(container container.Container) error {
			return container.Invoke(func(socketServer server.Server, logger logger.Logger) {
				socketServer.Use(ReadBytesLogger(logger))
			})
		}),
	}

	ReadBytesMetricComponent = &app.Component{
		Dependencies: app.Components{
			metric.Component,
			logger.Component,
			server.Component,
		},
		Run: app.Run(func(container container.Container) error {
			return container.Invoke(func(socketServer server.Server, logger logger.Logger, metric *metric.Metric) {
				socketServer.Use(ReadBytesMetric(logger, metric))
			})
		}),
	}

	ReadTimeoutComponent = &app.Component{
		Dependencies: app.Components{
			logger.Component,
			configurator.Component,
			server.Component,
		},
		Constructor: app.Constructor(func(container container.Container) error {
			return container.Provide(NewReadConfig)
		}),
		BindFlags: app.BindFlags(func(flagSet *pflag.FlagSet, container container.Container) error {
			return container.Invoke(func(config *ReadConfig) {
				flagSet.DurationVar(&config.Timeout, ReadTimeoutFieldName, ReadTimeoutDefault, "read timeout after which the connection will be considered invalid")
			})
		}),
		Run: app.Run(func(container container.Container) error {
			return container.Invoke(func(socketServer server.Server, config *ReadConfig, logger logger.Logger, configurator configurator.Configurator) {
				if config.Timeout == 0 || config.Timeout == ReadTimeoutDefault {
					configurator.SetDefault(ReadTimeoutFieldName, ReadTimeoutDefault)
					config.Timeout = configurator.GetDuration(ReadTimeoutFieldName)
				}

				socketServer.Use(ReadTimeout(config, logger))
			})
		}),
	}

	ReadComponent = &app.Component{
		Dependencies: app.Components{
			ReadBytesLoggerComponent,
			ReadBytesMetricComponent,
			ReadTimeoutComponent,
		},
	}

	WriteBytesLoggerComponent = &app.Component{
		Dependencies: app.Components{
			logger.Component,
			server.Component,
		},
		Run: app.Run(func(container container.Container) error {
			return container.Invoke(func(socketServer server.Server, logger logger.Logger) {
				socketServer.Use(WriteBytesLogger(logger))
			})
		}),
	}

	WriteBytesMetricComponent = &app.Component{
		Dependencies: app.Components{
			logger.Component,
			server.Component,
			metric.Component,
		},
		Run: app.Run(func(container container.Container) error {
			return container.Invoke(func(socketServer server.Server, logger logger.Logger, metric *metric.Metric) {
				socketServer.Use(WriteBytesMetric(logger, metric))
			})
		}),
	}

	WriteTimeoutComponent = &app.Component{
		Dependencies: app.Components{
			logger.Component,
			configurator.Component,
			server.Component,
		},
		Constructor: app.Constructor(func(container container.Container) error {
			return container.Provide(NewWriteConfig)
		}),
		BindFlags: app.BindFlags(func(flagSet *pflag.FlagSet, container container.Container) error {
			return container.Invoke(func(config *WriteConfig) {
				flagSet.DurationVar(&config.Timeout, WriteTimeoutFieldName, WriteTimeoutDefault, "write timeout, after which the connection will be considered invalid")
			})
		}),
		Run: app.Run(func(container container.Container) error {
			return container.Invoke(func(socketServer server.Server, config *WriteConfig, logger logger.Logger, configurator configurator.Configurator) {
				if config.Timeout == 0 || config.Timeout == WriteTimeoutDefault {
					configurator.SetDefault(WriteTimeoutFieldName, WriteTimeoutDefault)
					config.Timeout = configurator.GetDuration(WriteTimeoutFieldName)
				}

				socketServer.Use(WriteTimeout(config, logger))
			})
		}),
	}

	WriteComponent = &app.Component{
		Dependencies: app.Components{
			WriteBytesLoggerComponent,
			WriteBytesMetricComponent,
			WriteTimeoutComponent,
		},
	}

	ConnectionLoggerComponent = &app.Component{
		Dependencies: app.Components{
			logger.Component,
			server.Component,
		},
		Run: app.Run(func(container container.Container) error {
			return container.Invoke(func(socketServer server.Server, logger logger.Logger) {
				socketServer.Use(ConnectionLogger(logger))
			})
		}),
	}

	ConnectionCounterComponent = &app.Component{
		Dependencies: app.Components{
			logger.Component,
			server.Component,
		},
		Constructor: app.Constructor(func(container container.Container) error {
			return container.Provides(NewConnectionCounter)
		}),
		Run: app.Run(func(container container.Container) error {
			return container.Invoke(func(socketServer server.Server, connectionCounter *ConnectionCounter) {
				socketServer.Use(connectionCounter)
			})
		}),
	}

	RecovererComponent = &app.Component{
		Dependencies: app.Components{
			logger.Component,
			server.Component,
		},
		Run: app.Run(func(container container.Container) error {
			return container.Invoke(func(socketServer server.Server, logger logger.Logger) {
				socketServer.Use(Recoverer(logger))
			})
		}),
	}

	Component = &app.Component{Dependencies: app.Components{
		ReadComponent,
		WriteComponent,
		ConnectionLoggerComponent,
		ConnectionCounterComponent,
		RecovererComponent,
	}}
)

Functions

func ConnectionLogger

func ConnectionLogger(informer logger.Informer) server.MiddlewareFunc

func ReadBytesLogger

func ReadBytesLogger(logger logger.Logger) server.MiddlewareFunc

func ReadBytesMetric

func ReadBytesMetric(informer logger.Informer, metric *metric.Metric) server.MiddlewareFunc

func ReadBytesMetricWithName

func ReadBytesMetricWithName(informer logger.Informer, metric *metric.Metric, name string) server.MiddlewareFunc

func ReadTimeout

func ReadTimeout(config *ReadConfig, informer logger.Informer) server.Middleware

func Recoverer

func Recoverer(logger logger.Logger) server.MiddlewareFunc

func WriteBytesLogger

func WriteBytesLogger(logger logger.Logger) server.MiddlewareFunc

func WriteBytesMetric

func WriteBytesMetric(informer logger.Informer, metric *metric.Metric) server.MiddlewareFunc

func WriteBytesMetricWithName

func WriteBytesMetricWithName(informer logger.Informer, metric *metric.Metric, name string) server.MiddlewareFunc

func WriteTimeout

func WriteTimeout(config *WriteConfig, informer logger.Informer) server.MiddlewareFunc

Types

type ConnectionCounter

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

func NewConnectionCounter

func NewConnectionCounter(appConfig *app.Config) *ConnectionCounter

func (*ConnectionCounter) Middleware

func (middleware *ConnectionCounter) Middleware(next server.Handler) server.Handler

type ReadConfig

type ReadConfig struct {
	Timeout time.Duration
}

func NewReadConfig

func NewReadConfig() *ReadConfig

type WriteConfig

type WriteConfig struct {
	Timeout time.Duration
}

func NewWriteConfig

func NewWriteConfig() *WriteConfig