feat: enable unix listeners

refactor: parametrize listener

6 files changed, 131 insertions, 6 deletions

diff --git a/config/config.go b/config/config.go
index 536a333..784ac38 100644
--- a/config/config.go
+++ b/config/config.go
@@ -12,6 +12,7 @@ import (
 
 type Config struct {
 	LogLevel           slog.Level                `json:"LogLevel" yaml:"logLevel" validate:"required"`
+	Endpoint           EndpointConfig            `json:"Endpoint" yaml:"endpoint" validate:"required"`
 	BlogPages          BlogPagesConfig           `json:"BlogPages" yaml:"blogPages" validate:"required"`
 	FactGiver          FactGiverConfig           `json:"FactGiver" yaml:"factGiver" validate:"required"`
 	LocalePath         string                    `json:"LocalePath" yaml:"localePath" validate:"required,filepath"`
@@ -25,12 +26,90 @@ type Config struct {
 	AllowOrigins       []string                  `json:"AllowOrigins" yaml:"allowOrigins"`
 }
 
+type EndpointConfig struct {
+	Type   string `json:"Type" yaml:"type" validate:"required,oneof=http unix"`
+	Config any    `json:"Config" yaml:"config" validate:"required"`
+}
+
+func (ec *EndpointConfig) UnmarshalJSON(data []byte) error {
+	var tmp struct {
+		Type   string          `json:"Type"`
+		Config json.RawMessage `json:"Config"`
+	}
+
+	if err := json.Unmarshal(data, &tmp); err != nil {
+		return err
+	}
+
+	ec.Type = tmp.Type
+
+	switch tmp.Type {
+	case "http":
+		var httpConfig HttpConfig
+		if err := json.Unmarshal(tmp.Config, &httpConfig); err != nil {
+			return fmt.Errorf("unmarshal HttpConfig: %w", err)
+		}
+		ec.Config = &httpConfig
+	case "unix":
+		var unixConfig UnixConfig
+		if err := json.Unmarshal(tmp.Config, &unixConfig); err != nil {
+			return fmt.Errorf("unmarshal UnixConfig: %w", err)
+		}
+		ec.Config = &unixConfig
+	default:
+		return fmt.Errorf("unsupported storage type: %s", tmp.Type)
+	}
+
+	return nil
+}
+
+func (ec *EndpointConfig) UnmarshalYAML(value *yaml.Node) error {
+	var tmp struct {
+		Type   string    `yaml:"type"`
+		Config yaml.Node `yaml:"config"`
+	}
+
+	if err := value.Decode(&tmp); err != nil {
+		return err
+	}
+
+	ec.Type = tmp.Type
+
+	switch tmp.Type {
+	case "http":
+		var httpConfig HttpConfig
+		if err := tmp.Config.Decode(&httpConfig); err != nil {
+			return fmt.Errorf("unmarshal HttpConfig: %w", err)
+		}
+		ec.Config = &httpConfig
+	case "unix":
+		var unixConfig UnixConfig
+		if err := tmp.Config.Decode(&unixConfig); err != nil {
+			return fmt.Errorf("unmarshal UnixConfig: %w", err)
+		}
+		ec.Config = &unixConfig
+	default:
+		return fmt.Errorf("unsupported storage type: %s", tmp.Type)
+	}
+
+	return nil
+}
+
+type HttpConfig struct {
+	ListenOn string `json:"ListenOn" yaml:"listenOn" validate:"required"`
+}
+
+type UnixConfig struct {
+	Path  string `json:"Path" yaml:"path" validate:"required"`
+	Chmod string `json:"Chmod" yaml:"chmod" validate:"oneof=0600 0660 0666"`
+}
+
 type BlogPagesConfig struct {
 	Storage StorageConfig `json:"Storage" yaml:"storage" validate:"required"`
 }
 
 type StorageConfig struct {
-	Type   string `json:"type" yaml:"type,oneof=b2 s3"`
+	Type   string `json:"Type" yaml:"type" validate:"required,oneof=b2 s3"`
 	Config any    `json:"Config" yaml:"config" validate:"required"`
 }
 
@@ -202,6 +281,10 @@ func InitConfig(path string) (*Config, error) {
 		return nil, err
 	}
 
+	if config.Endpoint.Type == "unix" && config.Endpoint.Config.(*UnixConfig).Chmod == "" {
+		config.Endpoint.Config.(*UnixConfig).Chmod = "0660"
+	}
+
 	validate := validator.New(validator.WithRequiredStructEnabled())
 	if err := validate.Struct(config); err != nil {
 		return nil, err
diff --git a/config/config.local.yaml b/config/config.local.yaml
index 7769438..1822fdc 100644
--- a/config/config.local.yaml
+++ b/config/config.local.yaml
@@ -1,4 +1,8 @@
 logLevel: debug
+endpoint:
+  type: http
+  config:
+    listenOn: ":3000"
 blogPages:
   storage:
     type: b2
diff --git a/config/config.prod.yaml b/config/config.prod.yaml
index 91f606f..0b45e1a 100644
--- a/config/config.prod.yaml
+++ b/config/config.prod.yaml
@@ -1,4 +1,8 @@
 logLevel: info
+endpoint:
+  type: http
+  config:
+    listenOn: ":3000"
 blogPages:
   storage:
     type: b2
diff --git a/config/config.stage.yaml b/config/config.stage.yaml
index 3f1381b..23b76aa 100644
--- a/config/config.stage.yaml
+++ b/config/config.stage.yaml
@@ -1,4 +1,8 @@
 logLevel: debug
+endpoint:
+  type: http
+  config:
+    listenOn: ":3000"
 blogPages:
   storage:
     type: b2
diff --git a/internal/router/router.go b/internal/router/router.go
index 5230e74..2b45761 100644
--- a/internal/router/router.go
+++ b/internal/router/router.go
@@ -7,8 +7,11 @@ import (
 	"fmt"
 	"html/template"
 	"log/slog"
+	"net"
 	"net/url"
+	"os"
 	"slices"
+	"strconv"
 	"strings"
 	"time"
 
@@ -112,6 +115,7 @@ type Router struct {
 	templatedRoutes      map[string]map[string]Route
 	templatedPathMatcher *PathMatcher
 	canonicalEndpoint    string
+	endpoint             config.EndpointConfig
 }
 
 func NewRouter(cfg *config.Config) (*Router, error) {
@@ -256,7 +260,7 @@ func NewRouter(cfg *config.Config) (*Router, error) {
 	templatedRoutes := make(map[string]map[string]Route)
 	templatedPathMatcher := NewPathMatcher()
 
-	return &Router{supplements, app, templatedRoutes, templatedPathMatcher, cfg.CanonicalEndpoint}, nil
+	return &Router{supplements, app, templatedRoutes, templatedPathMatcher, cfg.CanonicalEndpoint, cfg.Endpoint}, nil
 }
 
 func (r *Router) InitRoutes() (err error) {
@@ -382,10 +386,30 @@ func (r *Router) InitRoutes() (err error) {
 	return nil
 }
 
-func (r *Router) Listen(endpoint string) error {
-	if err := r.app.Listen(endpoint); err != nil {
-		return fmt.Errorf("error while running fiber server: %w", err)
+func (r *Router) Listen() error {
+	switch r.endpoint.Type {
+	case "unix":
+		unixConfig := r.endpoint.Config.(*config.UnixConfig)
+		endpoint, _ := strings.CutPrefix(unixConfig.Path, "unix://")
+		ln, err := net.Listen("unix", endpoint)
+		if err != nil {
+			return fmt.Errorf("error while initializing unix listener: %w", err)
+		}
+		chmod, _ := strconv.ParseUint(unixConfig.Chmod[1:], 8, 32)
+		os.Chmod(unixConfig.Path, os.FileMode(chmod))
+		if err := r.app.Listener(ln); err != nil {
+			return fmt.Errorf("error while running fiber server: %w", err)
+		}
+	case "http":
+		httpConfig := r.endpoint.Config.(*config.HttpConfig)
+		fmt.Print(httpConfig)
+		if err := r.app.Listen(httpConfig.ListenOn); err != nil {
+			return fmt.Errorf("error while running fiber server: %w", err)
+		}
+	default:
+		return fmt.Errorf("error with initializing fiber server: invalid endpoint type (supported are unix and http)")
 	}
+
 	return nil
 }
 
@@ -409,6 +433,12 @@ func (r *Router) Close() (err error) {
 	}
 	slog.Debug("closing page cache")
 	r.supplements.PageCache.Close()
+	if r.endpoint.Type == "unix" {
+		slog.Debug("closing unix socket")
+		if err = os.Remove(r.endpoint.Config.(*config.UnixConfig).Path); err != nil {
+			allErrors = append(allErrors, fmt.Errorf("fail to close unix socket: %w", err))
+		}
+	}
 	return errors.Join(allErrors...)
 }
 
diff --git a/main.go b/main.go
index 3691e5b..9d90916 100644
--- a/main.go
+++ b/main.go
@@ -47,7 +47,7 @@ func main() {
 	routerShutdown := make(chan struct{}, 1)
 
 	go func() {
-		if err := app.Listen(":3000"); err != nil {
+		if err := app.Listen(); err != nil {
 			slog.Error("error while running fiber server", slog.String("error", err.Error()))
 			if nestedErr := app.Close(); nestedErr != nil {
 				slog.Error("error while shutting down fiber server", slog.String("error", err.Error()))