refactor: add service package and start splitting HTTP handling

api/api_interface_impl.go

@@ -53,7 +53,7 @@ type CacheControl interface {
 	FlushCaches(ctx context.Context)
 }
 
-func RegisterOpenAPIEndpoints(router chi.Router, impl StrictServerInterface) {
+func registerOpenAPIEndpoints(router chi.Router, impl StrictServerInterface) {
 	middleware := []StrictMiddlewareFunc{ctxWithHTTPRequestMiddleware}
 
 	HandlerFromMuxWithBaseURL(NewStrictHandler(impl, middleware), router, "/api")

api/api_interface_impl_test.go

@@ -105,7 +105,7 @@ var _ = Describe("API implementation tests", func() {
 	Describe("RegisterOpenAPIEndpoints", func() {
 		It("adds routes", func() {
 			rtr := chi.NewRouter()
-			RegisterOpenAPIEndpoints(rtr, sut)
+			registerOpenAPIEndpoints(rtr, sut)
 
 			Expect(rtr.Routes()).ShouldNot(BeEmpty())
 		})

api/service.go

@@ -0,0 +1,27 @@
+package api
+
+import (
+	"github.com/0xERR0R/blocky/config"
+	"github.com/0xERR0R/blocky/service"
+	"github.com/0xERR0R/blocky/util"
+)
+
+// Service implements service.HTTPService.
+type Service struct {
+	service.SimpleHTTP
+}
+
+func NewService(cfg config.APIService, server StrictServerInterface) *Service {
+	endpoints := util.ConcatSlices(
+		service.EndpointsFromAddrs(service.HTTPProtocol, cfg.Addrs.HTTP),
+		service.EndpointsFromAddrs(service.HTTPSProtocol, cfg.Addrs.HTTPS),
+	)
+
+	s := &Service{
+		SimpleHTTP: service.NewSimpleHTTP("API", endpoints),
+	}
+
+	registerOpenAPIEndpoints(s.Router(), server)
+
+	return s
+}

api/service_test.go

@@ -0,0 +1,43 @@
+package api
+
+import (
+	"github.com/0xERR0R/blocky/config"
+	"github.com/0xERR0R/blocky/service"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("API Service", func() {
+	var (
+		cfg config.APIService
+		sut *Service
+		err error
+	)
+
+	BeforeEach(func() {
+		cfg, err = config.WithDefaults[config.APIService]()
+		Expect(err).Should(Succeed())
+
+		cfg.Addrs.HTTP = config.ListenConfig{":80"}
+		cfg.Addrs.HTTPS = config.ListenConfig{":443"}
+	})
+
+	JustBeforeEach(func() {
+		sut = NewService(cfg, nil)
+	})
+
+	Describe("NewService", func() {
+		When("enabled", func() {
+			It("uses the configured addresses", func() {
+				Expect(sut.ExposeOn()).Should(ContainElements(
+					Equal(service.Endpoint{Protocol: "http", AddrConf: ":80"}),
+					Equal(service.Endpoint{Protocol: "https", AddrConf: ":443"}),
+				))
+			})
+
+			It("sets up routes", func() {
+				Expect(sut.Router().Routes()).ShouldNot(BeEmpty())
+			})
+		})
+	})
+})

cmd/serve.go

@@ -10,6 +10,7 @@
 	"github.com/0xERR0R/blocky/config"
 	"github.com/0xERR0R/blocky/evt"
 	"github.com/0xERR0R/blocky/log"
+	"github.com/0xERR0R/blocky/metrics"
 	"github.com/0xERR0R/blocky/server"
 	"github.com/0xERR0R/blocky/util"
 
@@ -49,6 +50,10 @@
 	ctx, cancelFn := context.WithCancel(context.Background())
 	defer cancelFn()
 
+	if cfg.Prometheus.Enable {
+		metrics.StartCollection()
+	}
+
 	srv, err := server.NewServer(ctx, cfg)
 	if err != nil {
 		return fmt.Errorf("can't start server: %w", err)

config/config.go

@@ -234,6 +234,7 @@
 	Redis            Redis               `yaml:"redis"`
 	Log              log.Config          `yaml:"log"`
 	Ports            Ports               `yaml:"ports"`
+	Services         Services            `yaml:"-"` // not user exposed yet
 	MinTLSServeVer   TLSVersion          `yaml:"minTlsServeVersion" default:"1.2"`
 	CertFile         string              `yaml:"certFile"`
 	KeyFile          string              `yaml:"keyFile"`
@@ -263,6 +264,19 @@
 	} `yaml:",inline"`
 }
 
+// Services holds network service related configuration.
+//
+// The actual config layout is not decided yet.
+// See https://github.com/0xERR0R/blocky/issues/1206
+//
+// The `yaml` struct tags are just for manual testing,
+// and require replacing `yaml:"-"` in Config to work.
+type Services struct {
+	API     APIService     `yaml:"control-api"`
+	DoH     DoHService     `yaml:"dns-over-https"`
+	Metrics MetricsService `yaml:"metrics"`
+}
+
 type Ports struct {
 	DNS   ListenConfig `yaml:"dns" default:"53"`
 	HTTP  ListenConfig `yaml:"http"`
@@ -601,6 +615,23 @@
 	cfg.Upstreams.validate(logger)
 }
 
+// CopyPortsToServices sets Services values to match Ports.
+//
+// This should be replaced with a migration once everything from Ports is supported in Services.
+// Done this way for now to avoid creating temporary generic services and updating all Ports related code at once.
+func (cfg *Config) CopyPortsToServices() {
+	httpAddrs := AllHTTPAddrs{
+		HTTPAddrs:  HTTPAddrs{HTTP: cfg.Ports.HTTP},
+		HTTPSAddrs: HTTPSAddrs{HTTPS: cfg.Ports.HTTPS},
+	}
+
+	cfg.Services = Services{
+		API:     APIService{Addrs: httpAddrs},
+		DoH:     DoHService{Addrs: httpAddrs},
+		Metrics: MetricsService{Addrs: httpAddrs},
+	}
+}
+
 // ConvertPort converts string representation into a valid port (0 - 65535)
 func ConvertPort(in string) (uint16, error) {
 	const (

config/http_services.go

@@ -0,0 +1,25 @@
+package config
+
+type (
+	APIService     HTTPService
+	DoHService     HTTPService
+	MetricsService HTTPService
+)
+
+// HTTPService can be used by any service that uses HTTP(S).
+type HTTPService struct {
+	Addrs AllHTTPAddrs `yaml:"addrs"`
+}
+
+type AllHTTPAddrs struct {
+	HTTPAddrs  `yaml:",inline"`
+	HTTPSAddrs `yaml:",inline"`
+}
+
+type HTTPAddrs struct {
+	HTTP ListenConfig `yaml:"http"`
+}
+
+type HTTPSAddrs struct {
+	HTTPS ListenConfig `yaml:"https"`
+}

helpertest/tls.go

@@ -0,0 +1,60 @@
+package helpertest
+
+import (
+	"crypto/tls"
+	"crypto/x509"
+	"sync"
+
+	"github.com/0xERR0R/blocky/util"
+	. "github.com/onsi/gomega"
+)
+
+const tlsTestServerName = "test.blocky.invalid"
+
+type tlsData struct {
+	ServerCfg *tls.Config
+	ClientCfg *tls.Config
+}
+
+// Lazy init
+//
+//nolint:gochecknoglobals
+var (
+	initTLSData    sync.Once
+	tlsDataStorage tlsData
+)
+
+func getTLSData() tlsData {
+	initTLSData.Do(func() {
+		cert, err := util.TLSGenerateSelfSignedCert([]string{tlsTestServerName})
+		Expect(err).Should(Succeed())
+
+		tlsDataStorage.ServerCfg = &tls.Config{
+			Certificates: []tls.Certificate{cert},
+			MinVersion:   tls.VersionTLS13,
+		}
+
+		certPool := x509.NewCertPool()
+		certPool.AddCert(cert.Leaf)
+
+		tlsDataStorage.ClientCfg = &tls.Config{
+			RootCAs:    certPool,
+			ServerName: tlsTestServerName,
+			MinVersion: tls.VersionTLS13,
+		}
+	})
+
+	return tlsDataStorage
+}
+
+// TLSTestServerConfig returns a TLS Config for use by test servers.
+func TLSTestServerConfig() *tls.Config {
+	return getTLSData().ServerCfg.Clone()
+}
+
+// TLSTestServerConfig returns a TLS Config for use by test clients.
+//
+// This is required to connect to a test TLS server, otherwise TLS verification fails.
+func TLSTestClientConfig() *tls.Config {
+	return getTLSData().ClientCfg.Clone()
+}

metrics/metrics.go

@@ -1,12 +1,8 @@
 package metrics
 
 import (
-	"github.com/0xERR0R/blocky/config"
-
-	"github.com/go-chi/chi/v5"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/collectors"
-	"github.com/prometheus/client_golang/prometheus/promhttp"
 )
 
 //nolint:gochecknoglobals
@@ -17,12 +13,9 @@
 	_ = Reg.Register(c)
 }
 
-// Start starts prometheus endpoint
-func Start(router *chi.Mux, cfg config.Metrics) {
-	if cfg.Enable {
-		_ = Reg.Register(collectors.NewProcessCollector(collectors.ProcessCollectorOpts{}))
-		_ = Reg.Register(collectors.NewGoCollector())
-		router.Handle(cfg.Path, promhttp.InstrumentMetricHandler(Reg,
-			promhttp.HandlerFor(Reg, promhttp.HandlerOpts{})))
-	}
+func StartCollection() {
+	_ = Reg.Register(collectors.NewProcessCollector(collectors.ProcessCollectorOpts{}))
+	_ = Reg.Register(collectors.NewGoCollector())
+
+	registerEventListeners()
 }

metrics/metrics_event_publisher.go

@@ -11,8 +11,8 @@
 	"github.com/prometheus/client_golang/prometheus"
 )
 
-// RegisterEventListeners registers all metric handlers by the event bus
-func RegisterEventListeners() {
+// registerEventListeners registers all metric handlers on the event bus
+func registerEventListeners() {
 	registerBlockingEventListeners()
 	registerCachingEventListeners()
 	registerApplicationEventListeners()

metrics/service.go

@@ -0,0 +1,36 @@
+package metrics
+
+import (
+	"github.com/0xERR0R/blocky/config"
+	"github.com/0xERR0R/blocky/service"
+	"github.com/0xERR0R/blocky/util"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+// Service implements service.HTTPService.
+type Service struct {
+	service.SimpleHTTP
+}
+
+func NewService(cfg config.MetricsService, metricsCfg config.Metrics) *Service {
+	endpoints := util.ConcatSlices(
+		service.EndpointsFromAddrs(service.HTTPProtocol, cfg.Addrs.HTTP),
+		service.EndpointsFromAddrs(service.HTTPSProtocol, cfg.Addrs.HTTPS),
+	)
+
+	if !metricsCfg.Enable || len(endpoints) == 0 {
+		// Avoid setting up collectors and listeners
+		return new(Service)
+	}
+
+	s := &Service{
+		SimpleHTTP: service.NewSimpleHTTP("Metrics", endpoints),
+	}
+
+	s.Router().Handle(
+		metricsCfg.Path,
+		promhttp.InstrumentMetricHandler(Reg, promhttp.HandlerFor(Reg, promhttp.HandlerOpts{})),
+	)
+
+	return s
+}