Refactor some configuration to proxy_opts

mtglib/proxy.go

 	}
 }
 
-func NewProxy(opts ProxyOpts) (*Proxy, error) { // nolint: cyclop, funlen
-	switch {
-	case opts.Network == nil:
-		return nil, ErrNetworkIsNotDefined
-	case opts.AntiReplayCache == nil:
-		return nil, ErrAntiReplayCacheIsNotDefined
-	case opts.IPBlocklist == nil:
-		return nil, ErrIPBlocklistIsNotDefined
-	case opts.EventStream == nil:
-		return nil, ErrEventStreamIsNotDefined
-	case opts.TimeAttackDetector == nil:
-		return nil, ErrTimeAttackDetectorIsNotDefined
-	case opts.Logger == nil:
-		return nil, ErrLoggerIsNotDefined
-	case !opts.Secret.Valid():
-		return nil, ErrSecretInvalid
+func NewProxy(opts ProxyOpts) (*Proxy, error) {
+	if err := opts.valid(); err != nil {
+		return nil, fmt.Errorf("invalid settings: %w", err)
 	}
 
-	preferIP := opts.PreferIP
-	if preferIP == "" {
-		preferIP = DefaultPreferIP
-	}
-
-	concurrency := opts.Concurrency
-	if concurrency == 0 {
-		concurrency = DefaultConcurrency
-	}
-
-	idleTimeout := opts.IdleTimeout
-	if idleTimeout < 1 {
-		idleTimeout = DefaultIdleTimeout
-	}
-
-	bufferSize := opts.BufferSize
-	if bufferSize < 1 {
-		bufferSize = DefaultBufferSize
-	}
-
-	domainFrontingPort := int(opts.DomainFrontingPort)
-	if domainFrontingPort == 0 {
-		domainFrontingPort = DefaultDomainFrontingPort
-	}
-
-	tg, err := telegram.New(opts.Network, preferIP)
+	tg, err := telegram.New(opts.Network, opts.getPreferIP())
 	if err != nil {
 		return nil, fmt.Errorf("cannot build telegram dialer: %w", err)
 	}
 		timeAttackDetector: opts.TimeAttackDetector,
 		ipBlocklist:        opts.IPBlocklist,
 		eventStream:        opts.EventStream,
-		logger:             opts.Logger.Named("proxy"),
-		domainFrontingPort: domainFrontingPort,
-		idleTimeout:        idleTimeout,
-		bufferSize:         int(bufferSize),
+		logger:             opts.getLogger("proxy"),
+		domainFrontingPort: opts.getDomainFrontingPort(),
+		idleTimeout:        opts.getIdleTimeout(),
+		bufferSize:         opts.getBufferSize(),
 		telegram:           tg,
 	}
 
-	pool, err := ants.NewPoolWithFunc(int(concurrency), func(arg interface{}) {
-		proxy.ServeConn(arg.(net.Conn))
-	},
-		ants.WithLogger(opts.Logger.Named("ants")),
+	pool, err := ants.NewPoolWithFunc(opts.getConcurrency(),
+		func(arg interface{}) {
+			proxy.ServeConn(arg.(net.Conn))
+		},
+		ants.WithLogger(opts.getLogger("ants")),
 		ants.WithNonblocking(true))
 	if err != nil {
 		panic(err)

mtglib/proxy_opts.go

 	IdleTimeout        time.Duration
 	PreferIP           string
 }
+
+func (p ProxyOpts) valid() error {
+	switch {
+	case p.Network == nil:
+		return ErrNetworkIsNotDefined
+	case p.AntiReplayCache == nil:
+		return ErrAntiReplayCacheIsNotDefined
+	case p.IPBlocklist == nil:
+		return ErrIPBlocklistIsNotDefined
+	case p.EventStream == nil:
+		return ErrEventStreamIsNotDefined
+	case p.TimeAttackDetector == nil:
+		return ErrTimeAttackDetectorIsNotDefined
+	case p.Logger == nil:
+		return ErrLoggerIsNotDefined
+	case !p.Secret.Valid():
+		return ErrSecretInvalid
+	}
+
+	return nil
+}
+
+func (p ProxyOpts) getBufferSize() int {
+	if p.BufferSize < 1 {
+		return DefaultBufferSize
+	}
+
+	return int(p.BufferSize)
+}
+
+func (p ProxyOpts) getConcurrency() int {
+	if p.Concurrency == 0 {
+		return DefaultConcurrency
+	}
+
+	return int(p.Concurrency)
+}
+
+func (p ProxyOpts) getDomainFrontingPort() int {
+	if p.DomainFrontingPort == 0 {
+		return DefaultDomainFrontingPort
+	}
+
+	return int(p.DomainFrontingPort)
+}
+
+func (p ProxyOpts) getIdleTimeout() time.Duration {
+	if p.IdleTimeout == 0 {
+		return DefaultIdleTimeout
+	}
+
+	return p.IdleTimeout
+}
+
+func (p ProxyOpts) getPreferIP() string {
+	if p.PreferIP == "" {
+		return DefaultPreferIP
+	}
+
+	return p.PreferIP
+}
+
+func (p ProxyOpts) getLogger(name string) Logger {
+	return p.Logger.Named(name)
+}