Server and client stubs.

Implemented HTTP server with configuration getting stub.

Implemented CLI client with configuration getting stub.

internal/configuration/config.go

@@ -0,0 +1,22 @@
+package configuration
+
+import (
+	// other
+	"github.com/vrischmann/envconfig"
+)
+
+type config struct {
+	HTTP struct {
+		Listen         string `envconfig:"default=127.0.0.1:62222"`
+		WaitForSeconds int    `envconfig:"default=10"`
+	}
+}
+
+// Initialize loads configuration into memory.
+func (cf *config) Initialize() {
+	log.Info().Msg("Loading configuration...")
+
+	_ = envconfig.Init(cf)
+
+	log.Info().Msgf("Configuration parsed: %+v", cf)
+}

internal/configuration/exported.go

@@ -0,0 +1,25 @@
+package configuration
+
+import (
+	// local
+	"sources.dev.pztrn.name/pztrn/giredore/internal/logger"
+
+	// other
+	"github.com/rs/zerolog"
+)
+
+var (
+	log               zerolog.Logger
+	loggerInitialized bool
+
+	Cfg *config
+)
+
+func Initialize() {
+	log = logger.Logger.With().Str("type", "internal").Str("package", "configuration").Logger()
+	loggerInitialized = true
+	log.Info().Msg("Initializing...")
+
+	Cfg = &config{}
+	Cfg.Initialize()
+}

internal/httpserver/exported.go

@@ -0,0 +1,107 @@
+package httpserver
+
+import (
+	// stdlib
+	"context"
+	"io/ioutil"
+	"net/http"
+	"strings"
+	"time"
+
+	// local
+	"sources.dev.pztrn.name/pztrn/giredore/internal/configuration"
+	"sources.dev.pztrn.name/pztrn/giredore/internal/logger"
+
+	// other
+	"github.com/labstack/echo"
+	"github.com/labstack/echo/middleware"
+	"github.com/rs/zerolog"
+)
+
+var (
+	log zerolog.Logger
+
+	Srv *echo.Echo
+)
+
+func Initialize() {
+	log = logger.Logger.With().Str("type", "internal").Str("package", "httpserver").Logger()
+
+	log.Info().Msg("Initializing...")
+
+	Srv = echo.New()
+	Srv.Use(middleware.Recover())
+	Srv.Use(requestLogger())
+	Srv.DisableHTTP2 = true
+	Srv.HideBanner = true
+	Srv.HidePort = true
+
+	Srv.GET("/_internal/waitForOnline", waitForHTTPServerToBeUpHandler)
+}
+
+// Shutdown stops HTTP server. Returns true on success and false on failure.
+func Shutdown() {
+	log.Info().Msg("Shutting down HTTP server...")
+	err := Srv.Shutdown(context.Background())
+	if err != nil {
+		log.Fatal().Err(err).Msg("Failed to stop HTTP server")
+	}
+	log.Info().Msg("HTTP server shutted down")
+
+}
+
+// Start starts HTTP server and checks that server is ready to process
+// requests. Returns true on success and false on failure.
+func Start() {
+	log.Info().Str("address", configuration.Cfg.HTTP.Listen).Msg("Starting HTTP server...")
+
+	go func() {
+		err := Srv.Start(configuration.Cfg.HTTP.Listen)
+		if !strings.Contains(err.Error(), "Server closed") {
+			log.Fatal().Err(err).Msg("HTTP server critial error occured")
+		}
+	}()
+
+	// Check that HTTP server was started.
+	httpc := &http.Client{Timeout: time.Second * 1}
+	checks := 0
+	for {
+		checks++
+		if checks >= configuration.Cfg.HTTP.WaitForSeconds {
+			log.Fatal().Int("seconds passed", checks).Msg("HTTP server isn't up")
+		}
+		time.Sleep(time.Second * 1)
+		resp, err := httpc.Get("http://" + configuration.Cfg.HTTP.Listen + "/_internal/waitForOnline")
+		if err != nil {
+			log.Debug().Err(err).Msg("HTTP error occured, HTTP server isn't ready, waiting...")
+			continue
+		}
+
+		response, err := ioutil.ReadAll(resp.Body)
+		resp.Body.Close()
+		if err != nil {
+			log.Debug().Err(err).Msg("Failed to read response body, HTTP server isn't ready, waiting...")
+			continue
+		}
+		log.Debug().Str("status", resp.Status).Int("body length", len(response)).Msg("HTTP response received")
+
+		if resp.StatusCode == http.StatusOK {
+			if len(response) == 0 {
+				log.Debug().Msg("Response is empty, HTTP server isn't ready, waiting...")
+				continue
+			}
+			log.Debug().Int("status code", resp.StatusCode).Msgf("Response: %+v", string(response))
+			if len(response) == 17 {
+				break
+			}
+		}
+	}
+	log.Info().Msg("HTTP server is ready to process requests")
+}
+
+func waitForHTTPServerToBeUpHandler(ec echo.Context) error {
+	response := map[string]string{
+		"error": "None",
+	}
+	return ec.JSON(200, response)
+}

internal/httpserver/requestlogger.go

@@ -0,0 +1,24 @@
+package httpserver
+
+import (
+	// other
+	"github.com/labstack/echo"
+)
+
+func requestLogger() echo.MiddlewareFunc {
+	return func(next echo.HandlerFunc) echo.HandlerFunc {
+		return func(ec echo.Context) error {
+			log.Info().
+				Str("From", ec.RealIP()).
+				Str("To", ec.Request().Host).
+				Str("Method", ec.Request().Method).
+				Str("Path", ec.Request().URL.Path).
+				Int64("Length", ec.Request().ContentLength).
+				Str("UA", ec.Request().UserAgent()).
+				Msg("HTTP request")
+
+			_ = next(ec)
+			return nil
+		}
+	}
+}

internal/logger/exported.go

@@ -0,0 +1,76 @@
+package logger
+
+import (
+	// stdlib
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	// other
+	"github.com/rs/zerolog"
+)
+
+var (
+	Logger         zerolog.Logger
+	SuperVerbosive bool
+
+	loggerInitialized bool
+)
+
+// Initialize initializes zerolog with proper formatting and log level.
+func Initialize() {
+	// Check environment for logger level.
+	// Defaulting to INFO.
+	loggerLevel, loggerLevelFound := os.LookupEnv("LOGGER_LEVEL")
+	if loggerLevelFound {
+		fmt.Println("Setting logger level to:", loggerLevel)
+		switch strings.ToUpper(loggerLevel) {
+		case "DEBUG":
+			zerolog.SetGlobalLevel(zerolog.DebugLevel)
+		case "INFO":
+			zerolog.SetGlobalLevel(zerolog.InfoLevel)
+		case "WARN":
+			zerolog.SetGlobalLevel(zerolog.WarnLevel)
+		case "ERROR":
+			zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+		case "FATAL":
+			zerolog.SetGlobalLevel(zerolog.FatalLevel)
+		default:
+			fmt.Println("Invalid logger level passed:", loggerLevel)
+			fmt.Println("Fofcing INFO")
+			zerolog.SetGlobalLevel(zerolog.InfoLevel)
+		}
+	} else {
+		fmt.Println("Setting logger level to: info")
+		zerolog.SetGlobalLevel(zerolog.InfoLevel)
+	}
+
+	output := zerolog.ConsoleWriter{Out: os.Stdout, NoColor: false, TimeFormat: time.RFC3339}
+	output.FormatLevel = func(i interface{}) string {
+		var v string
+		if ii, ok := i.(string); ok {
+			ii = strings.ToUpper(ii)
+			switch ii {
+			case "DEBUG":
+				v = fmt.Sprintf("\x1b[30m%-5s\x1b[0m", ii)
+			case "ERROR":
+				v = fmt.Sprintf("\x1b[31m%-5s\x1b[0m", ii)
+			case "FATAL":
+				v = fmt.Sprintf("\x1b[35m%-5s\x1b[0m", ii)
+			case "INFO":
+				v = fmt.Sprintf("\x1b[32m%-5s\x1b[0m", ii)
+			case "PANIC":
+				v = fmt.Sprintf("\x1b[36m%-5s\x1b[0m", ii)
+			case "WARN":
+				v = fmt.Sprintf("\x1b[33m%-5s\x1b[0m", ii)
+			default:
+				v = ii
+			}
+		}
+		return fmt.Sprintf("| %s |", v)
+	}
+
+	Logger = zerolog.New(output).With().Timestamp().Logger()
+	loggerInitialized = true
+}

internal/requester/exported.go

@@ -0,0 +1,54 @@
+package requester
+
+import (
+	// stdlib
+	"io/ioutil"
+	"net/http"
+
+	// local
+	"sources.dev.pztrn.name/pztrn/giredore/internal/logger"
+
+	// other
+	"github.com/rs/zerolog"
+)
+
+var (
+	log zerolog.Logger
+)
+
+func Initialize() {
+	log = logger.Logger.With().Str("type", "internal").Str("package", "requester").Logger()
+	log.Info().Msg("Initializing...")
+}
+
+func execRequest(method string, url string, data map[string]string) ([]byte, error) {
+	log.Debug().Str("method", method).Str("URL", url).Msg("Trying to execute HTTP request...")
+
+	httpClient := getHTTPClient()
+
+	// Compose HTTP request.
+	// ToDo: POST/PUT/other methods that require body.
+	httpReq, err := http.NewRequest(method, url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	response, err1 := httpClient.Do(httpReq)
+	if err1 != nil {
+		return nil, err1
+	}
+
+	bodyBytes, err2 := ioutil.ReadAll(response.Body)
+	if err2 != nil {
+		return nil, err2
+	}
+	response.Body.Close()
+
+	log.Debug().Int("response body length (bytes)", len(bodyBytes)).Msg("Got response")
+
+	return bodyBytes, nil
+}
+
+func Get(url string) ([]byte, error) {
+	return execRequest("GET", url, nil)
+}

internal/requester/httpclient.go

@@ -0,0 +1,30 @@
+package requester
+
+import (
+	// stdlib
+	"net"
+	"net/http"
+	"time"
+)
+
+func getHTTPClient() *http.Client {
+	c := &http.Client{
+		Transport: &http.Transport{
+			// ToDo: configurable.
+			ExpectContinueTimeout: time.Second * 5,
+			DialContext: (&net.Dialer{
+				// ToDo: configurable.
+				Timeout: time.Second * 5,
+			}).DialContext,
+			// ToDo: configurable.
+			ResponseHeaderTimeout: time.Second * 5,
+			// ToDo: configurable.
+			TLSHandshakeTimeout: time.Second * 10,
+		},
+	}
+
+	// ToDo: skip verifying insecure certificates if option was
+	// specified.
+
+	return c
+}