cleanup file structure, dockerize app

cmd/app/handler/httpjson/handler.go

@@ -0,0 +1,56 @@
+package httpjson
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/kjannette/go_http_server/internal/config"
+	"github.com/labstack/echo/v4"
+	"github.com/pkg/errors"
+	"go.uber.org/zap"
+)
+
+// Handler has services that are required by the handler.
+type Handler struct {
+	logger *zap.Logger
+}
+
+// New creates a new Handler instance.
+func New(logger *zap.Logger) (*echo.Echo, Handler) {
+	h := Handler{
+		logger: logger,
+	}
+
+	e := echo.New()
+	h.setupHealthCheckRoutes(e)
+
+	return e, h
+}
+
+// RunServer runs http server and listens until context is canceled.
+func (h *Handler) RunServer(ctx context.Context, conf *config.Config, e *echo.Echo) error {
+	go func() {
+		<-ctx.Done()
+
+		timeout, cancel := context.WithTimeout(context.Background(), time.Duration(conf.API.ReadTimeout)*time.Second)
+		defer cancel()
+
+		_ = e.Shutdown(timeout) // try gracefully first
+		_ = e.Close()           // immediate termination
+	}()
+
+	server := &http.Server{
+		Addr:         fmt.Sprintf(":%d", conf.API.Port),
+		ReadTimeout:  time.Duration(conf.API.ReadTimeout) * time.Second,
+		WriteTimeout: time.Duration(conf.API.WriteTimeout) * time.Second,
+		IdleTimeout:  time.Duration(conf.API.IdleTimeout) * time.Second,
+	}
+
+	if err := e.StartServer(server); !errors.Is(err, http.ErrServerClosed) {
+		return errors.Wrap(err, "server error")
+	}
+
+	return nil
+}

cmd/app/handler/httpjson/health.go

@@ -0,0 +1,15 @@
+package httpjson
+
+import (
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+)
+
+func (h *Handler) setupHealthCheckRoutes(app *echo.Echo) {
+	app.GET("/health", h.healthCheck)
+}
+
+func (h *Handler) healthCheck(c echo.Context) error {
+	return c.String(http.StatusOK, "OK")
+}

cmd/app/main.go

@@ -3,16 +3,17 @@ package main
 import (
 	"context"
 
-	"github.com/felipecoppola/go-boilerplate/internal/config"
-	"github.com/felipecoppola/go-boilerplate/internal/infrastructure/os"
+	"github.com/kjannette/go_http_server/internal/config"
+	infrasignal "github.com/kjannette/go_http_server/internal/infrastructure/os"
+	_ "github.com/kjannette/go_http_server/pkg/logger"
 
 	"go.uber.org/zap"
 )
 
 // Globals that are set at build time.
 var (
-	appName    = ""
-	appVersion = ""
+	appName    = "go-http-server"
+	appVersion = "dev"
 )
 
 func main() {
@@ -28,15 +29,15 @@ func main() {
 
 	cfg, err := config.NewConfig()
 	if err != nil {
-		logger.Error("error creating config: %w", zap.Error(err))
+		logger.Error("error creating config", zap.Error(err))
 		return
 	}
 
 	logger.Info("starting app")
-	os.SignalListener(logger, cancel)
+	infrasignal.SignalListener(logger, cancel)
 
 	if err = run(ctx, cfg); err != nil {
-		logger.Error("command failed: %w", zap.Error(err))
+		logger.Error("command failed", zap.Error(err))
 		return
 	}
 

cmd/app/service.go

@@ -3,9 +3,8 @@ package main
 import (
 	"context"
 
-	"github.com/kjannette/go-http-server/cmd/app/handler/httpjson"
-	"github.com/kjannnette/go-http-server/internal/config"
-	"github.com/kjannette/go-http-server/pkg/logger"
+	"github.com/kjannette/go_http_server/cmd/app/handler/httpjson"
+	"github.com/kjannette/go_http_server/internal/config"
 
 	"go.uber.org/zap"
 	"golang.org/x/sync/errgroup"
@@ -16,14 +15,13 @@ func run(ctx context.Context, cfg *config.Config) error {
 
 	eg, ctx := errgroup.WithContext(ctx)
 	app, h := httpjson.New(lg)
+	serverLog := lg.Named("run_server")
 
-	eg.Go(func(l logger.Logger) func() error {
-		return func() error {
-			l.Info("starting server")
-			defer l.Info("terminated server")
-			return h.RunServer(ctx, cfg, app)
-		}
-	}(lg.Named("run_server")))
+	eg.Go(func() error {
+		serverLog.Info("starting server")
+		defer serverLog.Info("terminated server")
+		return h.RunServer(ctx, cfg, app)
+	})
 
 	return eg.Wait()
 }