Move into api routers instead of main

services/entry/pkg/infrastructure/dependencies/cache.go

@@ -0,0 +1,29 @@
+package dependencies
+
+import (
+	"github.com/dgraph-io/ristretto"
+	"github.com/eko/gocache/cache"
+	"github.com/eko/gocache/metrics"
+	"github.com/eko/gocache/store"
+	"go.uber.org/zap"
+)
+
+func setupCache(l *zap.Logger) *cache.MetricCache {
+	l.Info("Setting up Cache")
+	ristrettoCache, err := ristretto.NewCache(&ristretto.Config{
+		NumCounters: 1000,
+		MaxCost:     100_000_000,
+		BufferItems: 64,
+	})
+	promMetrics := metrics.NewPrometheus("serverctl")
+
+	if err != nil {
+		panic(err)
+	}
+	ristrettoStore := store.NewRistretto(ristrettoCache, nil)
+
+	cacheManager := cache.New(ristrettoStore)
+	metricsCache := cache.NewMetric(promMetrics, cacheManager)
+
+	return metricsCache
+}

services/entry/pkg/infrastructure/dependencies/cron.go

@@ -0,0 +1,37 @@
+package dependencies
+
+import (
+	"context"
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/client"
+	"github.com/eko/gocache/cache"
+	"github.com/eko/gocache/store"
+	"github.com/go-co-op/gocron"
+	"go.uber.org/zap"
+	"time"
+)
+
+func setupCron(l *zap.Logger, cm *cache.MetricCache, cc *client.Client) {
+	l.Info("Setting up job scheduler (cron)")
+
+	s := gocron.NewScheduler(time.UTC)
+
+	s.Every(10).Second().Do(func() {
+		l.Debug("getting container list")
+		list, err := cc.ContainerList(context.Background(), types.ContainerListOptions{})
+		if err != nil {
+			l.Warn(err.Error())
+			return
+		}
+
+		err = cm.Set("docker-containers", list, &store.Options{
+			Cost: 2,
+		})
+		if err != nil {
+			l.Warn(err.Error())
+			return
+		}
+	})
+
+	s.StartAsync()
+}

services/entry/pkg/infrastructure/dependencies/dependencies.go

@@ -0,0 +1,52 @@
+package dependencies
+
+import (
+	"github.com/eko/gocache/cache"
+	"go.uber.org/zap"
+	"serverctl/pkg/application/applications"
+	"serverctl/pkg/application/projects"
+	"serverctl/pkg/application/users"
+	"serverctl/pkg/db"
+	"serverctl/pkg/db/postgres"
+)
+
+type Dependencies struct {
+	Logger                 *zap.Logger
+	Cache                  *cache.MetricCache
+	Database               *db.Client
+	UsersRepository        users.Repository
+	UsersService           *users.Service
+	ProjectsRepository     projects.Repository
+	ProjectsService        *projects.Service
+	ApplicationsRepository applications.Repository
+	ApplicationsService    *applications.Service
+}
+
+func New() *Dependencies {
+
+	logger := setupLogger()
+
+	cacheM := setupCache(logger)
+	containerClient := setupDocker(logger)
+	setupCron(logger, cacheM, containerClient)
+
+	database := db.NewClient(logger)
+	usersRepository := postgres.NewUsersRepository(database)
+	usersService := users.NewService(logger, usersRepository, cacheM)
+	projectsRepository := postgres.NewProjectsRepository(database)
+	projectsService := projects.NewService(logger, projectsRepository, cacheM)
+	applicationsRepository := postgres.NewApplicationRepository(logger, database)
+	applicationsService := applications.NewService(logger, applicationsRepository)
+
+	return &Dependencies{
+		Logger:                 logger,
+		Cache:                  cacheM,
+		Database:               database,
+		UsersRepository:        usersRepository,
+		UsersService:           usersService,
+		ProjectsRepository:     projectsRepository,
+		ProjectsService:        projectsService,
+		ApplicationsRepository: applicationsRepository,
+		ApplicationsService:    applicationsService,
+	}
+}

services/entry/pkg/infrastructure/dependencies/docker.go

@@ -0,0 +1,16 @@
+package dependencies
+
+import (
+	"github.com/docker/docker/client"
+	"go.uber.org/zap"
+)
+
+func setupDocker(l *zap.Logger) *client.Client {
+	l.Info("Setting up Docker")
+	cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
+	if err != nil {
+		panic(err)
+	}
+
+	return cli
+}

services/entry/pkg/infrastructure/dependencies/logger.go

@@ -0,0 +1,36 @@
+package dependencies
+
+import (
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+	"io/ioutil"
+	"os"
+)
+
+func setupLogger() *zap.Logger {
+	highPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
+		return lvl >= zapcore.ErrorLevel
+	})
+	lowPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
+		return lvl < zapcore.ErrorLevel
+	})
+	fileDebugging := zapcore.AddSync(ioutil.Discard)
+	fileErrors := zapcore.AddSync(ioutil.Discard)
+
+	consoleDebugging := zapcore.Lock(os.Stdout)
+	consoleErrors := zapcore.Lock(os.Stderr)
+
+	fileEncoder := zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())
+	_ = zapcore.NewConsoleEncoder(zap.NewDevelopmentEncoderConfig())
+
+	core := zapcore.NewTee(
+		zapcore.NewCore(fileEncoder, fileErrors, highPriority),
+		zapcore.NewCore(fileEncoder, consoleErrors, highPriority),
+		zapcore.NewCore(fileEncoder, fileDebugging, lowPriority),
+		zapcore.NewCore(fileEncoder, consoleDebugging, lowPriority),
+	)
+
+	logger := zap.New(core)
+	defer logger.Sync()
+	return logger
+}