component.go

package middleware

import (
	"github.com/D3rus/go-library/app"
	"github.com/D3rus/go-library/configurator"
	"github.com/D3rus/go-library/container"
	"github.com/D3rus/go-library/logger"
	"github.com/D3rus/go-library/socket/server"
	"github.com/D3rus/go-library/socket/server/metric"
	"github.com/spf13/pflag"
)

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,
	}}
)