feat: initial commit

Author: smrz2001

.gitignore

@@ -0,0 +1,25 @@
+# Node dependencies
+node_modules/
+
+# Environment files
+.env
+.env.*
+!.env.example
+
+# Generated folders
+.build
+
+# Temporary files
+*.tmp
+*.temp
+
+# IDE files
+.idea/
+.vscode/
+*.swp
+*.swo
+*.iml
+
+# OS files
+.DS_Store
+Thumbs.db

cmd/server/main.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"context"
+	"log"
+	"runtime"
+
+	"github.com/3box/go-mirror/common/config"
+	"github.com/3box/go-mirror/common/container"
+	"github.com/3box/go-mirror/common/logging"
+	"github.com/3box/go-mirror/server"
+)
+
+func main() {
+	serverCtx := context.Background()
+	ctr, err := container.BuildContainer(serverCtx)
+	if err != nil {
+		log.Fatalf("Failed to build container: %v", err)
+	}
+
+	if err = ctr.Invoke(func(
+		c *config.Config,
+		l logging.Logger,
+		s server.Server,
+	) error {
+		l.Infow("starting db api",
+			"architecture", runtime.GOARCH,
+			"operating system", runtime.GOOS,
+			"go version", runtime.Version(),
+		)
+
+		s.Run()
+		return nil
+	}); err != nil {
+		log.Fatalf("Failed to start server: %v", err)
+	}
+}

common/cert/cert.go

@@ -0,0 +1,11 @@
+package cert
+
+import (
+	"crypto/tls"
+	"net/http"
+)
+
+type CertManager interface {
+	GetCertificate(hello *tls.ClientHelloInfo) (*tls.Certificate, error)
+	GetHTTPHandler() http.Handler
+}

common/cert/lets_encrypt.go

@@ -0,0 +1,51 @@
+package cert
+
+import (
+	"crypto/tls"
+	"net/http"
+
+	"golang.org/x/crypto/acme"
+	"golang.org/x/crypto/acme/autocert"
+
+	"github.com/3box/go-mirror/common/config"
+	"github.com/3box/go-mirror/common/logging"
+)
+
+type acmeCertManager struct {
+	logger     logging.Logger
+	certConfig *config.CertConfig
+	manager    *autocert.Manager
+}
+
+func NewACMECertManager(cfg *config.Config, logger logging.Logger) (CertManager, error) {
+	certConfig := cfg.Cert
+	if !certConfig.Enabled {
+		return nil, nil
+	}
+
+	manager := &autocert.Manager{
+		Cache:      autocert.DirCache(certConfig.CacheDir),
+		Prompt:     autocert.AcceptTOS,
+		HostPolicy: autocert.HostWhitelist(certConfig.Domains...),
+	}
+
+	if certConfig.TestMode {
+		manager.Client = &acme.Client{
+			DirectoryURL: "https://acme-staging-v02.api.letsencrypt.org/directory",
+		}
+	}
+
+	return &acmeCertManager{
+		logger:     logger,
+		certConfig: &certConfig,
+		manager:    manager,
+	}, nil
+}
+
+func (_this *acmeCertManager) GetCertificate(hello *tls.ClientHelloInfo) (*tls.Certificate, error) {
+	return _this.manager.GetCertificate(hello)
+}
+
+func (_this *acmeCertManager) GetHTTPHandler() http.Handler {
+	return _this.manager.HTTPHandler(nil)
+}

common/config/config.go

@@ -0,0 +1,52 @@
+package config
+
+import (
+	"strings"
+
+	"github.com/spf13/viper"
+
+	"github.com/3box/go-mirror/common/logging"
+)
+
+type Config struct {
+	Cert  CertConfig
+	Proxy ProxyConfig
+}
+
+type CertConfig struct {
+	Enabled    bool
+	Domains    []string
+	CacheDir   string
+	TestMode   bool
+	ListenAddr string
+}
+
+type ProxyConfig struct {
+	TargetURL  string
+	MirrorURL  string
+	ListenAddr string
+	TLSEnabled bool
+}
+
+func LoadConfig(logger logging.Logger) (*Config, error) {
+	// Create a new viper instance with the experimental bind struct feature enabled
+	v := viper.NewWithOptions(
+		viper.ExperimentalBindStruct(),
+		// This was necessary to get viper to recognize the nested struct fields
+		viper.EnvKeyReplacer(strings.NewReplacer(".", "_")),
+	)
+	v.SetEnvPrefix("GO_MIRROR")
+	v.AutomaticEnv()
+
+	// Unmarshal environment variables into the config struct
+	var cfg Config
+	if err := v.Unmarshal(&cfg); err != nil {
+		return nil, err
+	}
+
+	logger.Infow("config loaded successfully",
+		"config", cfg,
+	)
+
+	return &cfg, nil
+}

common/container/container.go

@@ -0,0 +1,58 @@
+package container
+
+import (
+	"context"
+
+	"go.uber.org/dig"
+
+	"github.com/3box/go-mirror/common/cert"
+	"github.com/3box/go-mirror/common/config"
+	"github.com/3box/go-mirror/common/logging"
+	"github.com/3box/go-mirror/common/metric"
+	"github.com/3box/go-mirror/controllers"
+	"github.com/3box/go-mirror/server"
+)
+
+func BuildContainer(ctx context.Context) (*dig.Container, error) {
+	container := dig.New()
+	var err error
+
+	// Provide logging
+	if err = container.Provide(logging.NewLogger); err != nil {
+		return nil, err
+	}
+
+	// Provide context
+	if err = container.Provide(func() context.Context {
+		return ctx
+	}); err != nil {
+		return nil, err
+	}
+
+	// Provide config
+	if err = container.Provide(config.LoadConfig); err != nil {
+		return nil, err
+	}
+
+	// Provide metrics
+	if err = container.Provide(metric.NewOTelMetricService); err != nil {
+		return nil, err
+	}
+
+	// Provide cert manager
+	if err = container.Provide(cert.NewACMECertManager); err != nil {
+		return nil, err
+	}
+
+	// Provide handlers
+	if err = container.Provide(controllers.NewProxyController); err != nil {
+		return nil, err
+	}
+
+	// Provide server
+	if err = container.Provide(server.NewServer); err != nil {
+		return nil, err
+	}
+
+	return container, nil
+}

common/logging/logger.go

@@ -0,0 +1,15 @@
+package logging
+
+// Logger is the common interface for logging
+type Logger interface {
+	Debugf(template string, args ...interface{})
+	Debugw(msg string, args ...interface{})
+	Errorf(template string, args ...interface{})
+	Errorw(msg string, args ...interface{})
+	Fatalf(template string, args ...interface{})
+	Infow(msg string, args ...interface{})
+	Infof(template string, args ...interface{})
+	Warnf(template string, args ...interface{})
+	Warnw(msg string, args ...interface{})
+	Sync() error
+}

common/logging/zap_logger.go

@@ -0,0 +1,40 @@
+package logging
+
+import (
+	"embed"
+	"log"
+	"os"
+
+	"gopkg.in/yaml.v3"
+
+	"go.uber.org/zap"
+)
+
+//go:embed zap_logger.yml
+var zapYamlFile embed.FS
+
+func NewLogger() Logger {
+	configYaml, err := zapYamlFile.ReadFile("zap_logger.yml")
+	if err != nil {
+		log.Fatalf("logger: failed to read logger configuration: %s", err)
+	}
+	var zapConfig *zap.Config
+	if err = yaml.Unmarshal(configYaml, &zapConfig); err != nil {
+		log.Fatalf("logger: failed to unmarshal zap logger configuration: %s", err)
+	}
+
+	level := zap.NewAtomicLevelAt(zap.InfoLevel)
+	logLevel := os.Getenv("LOG_LEVEL")
+	if len(logLevel) > 0 {
+		if parsedLevel, err := zap.ParseAtomicLevel(logLevel); err != nil {
+			log.Fatalf("logger: error parsing log level %s: %v", logLevel, err)
+		} else {
+			level = parsedLevel
+		}
+	}
+	zapConfig.Level = level
+	zapConfig.Encoding = "json"
+	baseLogger := zap.Must(zapConfig.Build())
+	sugaredLogger := baseLogger.Sugar()
+	return sugaredLogger
+}

common/logging/zap_logger.yml

@@ -0,0 +1,18 @@
+level: "debug"
+encoding: "json"
+development: true
+encoderConfig:
+  messageKey: "Msg"
+  levelKey: "Level"
+  timeKey: "Time"
+  nameKey: "Name"
+  callerKey: "Caller"
+  stacktraceKey: "St"
+  levelEncoder: "capital"
+  timeEncoder: "iso8601"
+  durationEncoder: "string"
+  callerEncoder: "short"
+outputPaths:
+  - "stdout"
+errorOutputPaths:
+  - "stdout"

common/metric/metric.go

@@ -0,0 +1,21 @@
+package metric
+
+import (
+	"context"
+	"time"
+
+	"github.com/gin-gonic/gin"
+
+	"go.opentelemetry.io/otel/attribute"
+)
+
+type MetricService interface {
+	GetPrometheusHandler() gin.HandlerFunc
+	RecordRequest(ctx context.Context, name, method, path string, attrs ...attribute.KeyValue) error
+	RecordDuration(ctx context.Context, name string, duration time.Duration, attrs ...attribute.KeyValue) error
+}
+
+const (
+	MetricProxyRequest  = "proxy_request"
+	MetricMirrorRequest = "mirror_request"
+)