package config

internal/config/config.go

@@ -0,0 +1,58 @@
+package config
+
+import (
+	"time"
+)
+
+type Config struct {
+	Server ServerConfig `yaml:"server"`
+	Auth   AuthConfig   `yaml:"auth"`
+	TLS    TLSConfig    `yaml:"tls"`
+}
+
+type ServerConfig struct {
+	BindAddress  string        `yaml:"bind_address"`
+	ReadTimeout  time.Duration `yaml:"read_timeout"`
+	WriteTimeout time.Duration `yaml:"write_timeout"`
+}
+
+type AuthConfig struct {
+	Mode  string `yaml:"mode"`
+	Token string `yaml:"token,omitempty"`
+}
+
+type TLSConfig struct {
+	Enabled  bool   `yaml:"enabled"`
+	CertFile string `yaml:"cert_file"`
+	KeyFile  string `yaml:"key_file"`
+}
+
+type ConfigLoader interface {
+	LoadConfig() (*Config, error)
+}
+
+func DefaultConfig() *Config {
+	return &Config{
+		Server: ServerConfig{
+			BindAddress:  ":8080",
+			ReadTimeout:  15 * time.Second,
+			WriteTimeout: 15 * time.Second,
+		},
+		Auth: AuthConfig{
+			Mode: "none",
+		},
+		TLS: TLSConfig{
+			Enabled: false,
+		},
+	}
+}
+
+func (c Config) applyDefaults() *Config {
+	if c.Server.BindAddress == "" {
+		c.Server.BindAddress = ":8080"
+	}
+	if c.Auth.Mode == "" {
+		c.Auth.Mode = "none"
+	}
+	return &c
+}

internal/config/yamlloader.go

@@ -0,0 +1,29 @@
+package config
+
+import (
+	"fmt"
+	"os"
+
+	"gopkg.in/yaml.v3"
+)
+
+type YamlConfigLoader struct {
+	FilePath string
+}
+
+func (l *YamlConfigLoader) LoadConfig() (*Config, error) {
+	data, err := os.ReadFile(l.FilePath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return DefaultConfig(), nil
+		}
+		return nil, fmt.Errorf("reading config file: %w", err)
+	}
+
+	var cfg Config
+	if err := yaml.Unmarshal(data, &cfg); err != nil {
+		return nil, fmt.Errorf("parsing config file: %w", err)
+	}
+
+	return cfg.applyDefaults(), nil
+}

internal/server/gethandlers.go

@@ -0,0 +1,11 @@
+package server
+
+import (
+	"net/http"
+)
+
+func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	w.Write([]byte(`{"status":"ok"}`))
+}

internal/server/server.go

@@ -0,0 +1,72 @@
+package server
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"net/http"
+
+	"git.systemact.nl/henk/mars-terraform-registry/internal/config"
+)
+
+type Server struct {
+	httpServer *http.Server
+	cfg        *config.Config
+}
+
+func NewServer(ctx context.Context, cfgLoader config.ConfigLoader) (*Server, error) {
+	cfg, err := cfgLoader.LoadConfig()
+	if err != nil {
+		return nil, fmt.Errorf("failed to load config: %w", err)
+	}
+
+	srv := &Server{
+		cfg: cfg,
+	}
+	err = srv.setup()
+	return srv, err
+}
+
+func (s *Server) setup() error {
+	mux := http.NewServeMux()
+
+	mux.HandleFunc("/health", s.handleHealth)
+	s.httpServer = &http.Server{
+		Handler: mux,
+	}
+	return nil
+}
+
+func (s *Server) Run(ctx context.Context) error {
+	slog.Info("Starting AgentGopher gateway", "address", s.cfg.Server.BindAddress)
+
+	errCh := make(chan error, 1)
+	go func() {
+		if s.cfg.TLS.Enabled {
+			errCh <- s.httpServer.ListenAndServeTLS(s.cfg.TLS.CertFile, s.cfg.TLS.KeyFile)
+		} else {
+			errCh <- s.httpServer.ListenAndServe()
+		}
+	}()
+
+	select {
+	case <-ctx.Done():
+		slog.Info("Shutdown signal received")
+		return s.Shutdown(context.Background())
+	case err := <-errCh:
+		return err
+	}
+}
+
+func (s *Server) Shutdown(ctx context.Context) error {
+	var errs []error
+
+	if err := s.httpServer.Shutdown(ctx); err != nil {
+		errs = append(errs, fmt.Errorf("http server shutdown: %w", err))
+	}
+
+	if len(errs) > 0 {
+		return fmt.Errorf("shutdown errors: %v", errs)
+	}
+	return nil
+}