HellPot NextGen

Makefile

@@ -1,11 +1,13 @@
 all: deps check build
-format:
+format :
 	find . -iname "*.go" -exec gofmt -s -l -w {} \;
-check:
+check :
 	go vet ./...
-run:
+run :
 	go run cmd/HellPot/*.go
 deps:
 	go mod tidy -v
-build:
-	go build -trimpath -ldflags "-s -w -X main.version=`git tag --sort=-version:refname | head -n 1`" cmd/HellPot/*.go
+test :
+	go test -v ./...
+build :
+	go build -x -trimpath -ldflags "-s -w -X main.version=`git tag --sort=-version:refname | head -n 1`" cmd/HellPot/*.go

README.md

@@ -17,7 +17,7 @@ Clients (hopefully bots) that disregard `robots.txt` and connect to your instanc
 
 HellPot will send an infinite stream of data that is _just close enough_ to being a real website that they might just stick around until their soul is ripped apart and they cease to exist.
 
-Under the hood of this eternal suffering is a markov engine that chucks bits and pieces of [The Birth of Tragedy (Hellenism and Pessimism)](https://www.gutenberg.org/files/51356/51356-h/51356-h.htm) by Friedrich Nietzsche at the client using [fasthttp](https://github.com/valyala/fasthttp).
+Under the hood of this eternal suffering is a markov engine that chucks bits and pieces of [The Birth of Tragedy (Hellenism and Pessimism)](https://www.gutenberg.org/files/51356/51356-h/51356-h.htm) by Friedrich Nietzsche at the client~~~~ using [fasthttp](https://github.com/valyala/fasthttp), or optionally you may synchronize HellPot with your nightmares by using the `-g`/`--grimoire` flag
 
 ## Building From Source
 

cmd/HellPot/HellPot.go

@@ -2,58 +2,26 @@ package main
 
 import (
 	"os"
-	"os/signal"
-	"syscall"
 
-	"github.com/rs/zerolog"
-
-	"github.com/yunginnanet/HellPot/internal/config"
-	"github.com/yunginnanet/HellPot/internal/extra"
 	"github.com/yunginnanet/HellPot/internal/http"
 )
 
-var (
-	log     zerolog.Logger
-	version string // set by linker
-)
-
-func init() {
-	if version != "" {
-		config.Version = version[1:]
-	}
-	config.Init()
-	if config.BannerOnly {
-		extra.Banner()
-		os.Exit(0)
-	}
+func main() {
+	stopChan := make(chan os.Signal, 1)
+	log, resolvedConf, realConf, err := setup(stopChan)
 
-	switch config.DockerLogging {
-	case true:
-		config.CurrentLogFile = "/dev/stdout"
-		config.NoColor = true
-		log = config.StartLogger(false, os.Stdout)
-	default:
-		log = config.StartLogger(true)
+	if err != nil {
+		println("failed to start: " + err.Error())
+		os.Exit(1)
 	}
 
-	extra.Banner()
-
-	log.Info().Str("caller", "config").Str("file", config.Filename).Msg(config.Filename)
-	log.Info().Str("caller", "logger").Msg(config.CurrentLogFile)
-	log.Debug().Str("caller", "logger").Msg("debug enabled")
-	log.Trace().Str("caller", "logger").Msg("trace enabled")
-
-}
-
-func main() {
-	stopChan := make(chan os.Signal, 1)
-	signal.Notify(stopChan, syscall.SIGINT, syscall.SIGTERM)
+	printInfo(log, resolvedConf, realConf)
 
 	go func() {
-		log.Fatal().Err(http.Serve()).Msg("HTTP error")
+		log.Fatal().Err(http.Serve(realConf)).Msg("HTTP error")
 	}()
 
-	<-stopChan // wait for SIGINT
-	log.Warn().Msg("Shutting down server...")
-
+	sig := <-stopChan // wait for SIGINT
+	log.Warn().Interface("signal_received", sig).
+		Msg("Shutting down server...")
 }

cmd/HellPot/HellPot_test.go

@@ -0,0 +1,102 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/yunginnanet/HellPot/internal/config"
+	"github.com/yunginnanet/HellPot/internal/http"
+	"github.com/yunginnanet/HellPot/internal/logger"
+)
+
+func testMain(t *testing.T) (string, chan os.Signal, *logger.Log, *config.Parameters, error) {
+	t.Setenv("HELLPOT_TEST_MODE", "true")
+	t.Helper()
+	stopChan := make(chan os.Signal, 1)
+
+	log, resolvedConf, realConfig, err := setup(stopChan)
+	if err == nil {
+		printInfo(log, resolvedConf, realConfig)
+		go func() {
+			terr := http.Serve(realConfig)
+			if terr != nil {
+				t.Error("failed to serve HTTP: " + terr.Error())
+				return
+			}
+		}()
+	}
+	//goland:noinspection GoNilness
+	return resolvedConf, stopChan, log, realConfig, err
+}
+
+func TestHellPot(t *testing.T) {
+	tDir := filepath.Join(t.TempDir(), strconv.Itoa(int(time.Now().Unix())))
+	logDir := filepath.Join(tDir, "logs")
+	if err := os.MkdirAll(logDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	confFile := filepath.Join(tDir, "HellPot_test.toml")
+	t.Setenv("HELLPOT_LOGGER_DIRECTORY", logDir)
+	t.Setenv("HELLPOT_LOGGER_RSYSLOG__ADDRESS", "local")
+	t.Setenv("HELLPOT_LOGGER_DEBUG", "true")
+	t.Setenv("HELLPOT_CONFIG", confFile)
+
+	resolvedConf, stopChan, log, realConfig, err := testMain(t)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	if log == nil {
+		t.Fatal("log is nil")
+	}
+	if realConfig == nil {
+		t.Fatal("realConfig is nil")
+	}
+
+	logFile := log.Config.ActiveLogFileName
+
+	if stopChan == nil {
+		t.Fatal("stopChan is nil")
+	}
+	if resolvedConf == "" {
+		t.Fatal("resolvedConf is empty")
+	}
+	if logFile == "" {
+		t.Fatal("logFile is empty")
+	}
+	if _, err = os.Stat(logFile); err != nil {
+		t.Fatal(err)
+	}
+	if resolvedConf != confFile {
+		t.Errorf("expected %s, got %s", confFile, resolvedConf)
+	}
+	if logFile != filepath.Join(logDir, "HellPot.log") {
+		t.Errorf("expected %s, got %s", filepath.Join(logDir, "HellPot.log"), logFile)
+	}
+	time.Sleep(25 * time.Millisecond) // sync maybe
+	logDat, err := os.ReadFile(logFile)
+	if err != nil {
+		t.Error(err)
+	}
+	if !strings.Contains(string(logDat), "🔥 Starting HellPot 🔥") {
+		t.Errorf("expected log to contain '🔥 Starting HellPot 🔥', got %s", logDat)
+	}
+	if !strings.Contains(string(logDat), logFile) {
+		t.Errorf("expected log to contain '%s'", logFile)
+	}
+	if !strings.Contains(string(logDat), resolvedConf) {
+		t.Errorf("expected log to contain '%s'", resolvedConf)
+	}
+	if !strings.Contains(string(logDat), strconv.Itoa(os.Getpid())+",") {
+		t.Errorf("expected log to contain 'PID: %d', got %s", os.Getpid(), logDat)
+	}
+	t.Log("resolvedConf: ", resolvedConf)
+	t.Log("logFile: ", logFile)
+	t.Log("realConfig: ", realConfig)
+	time.Sleep(100 * time.Millisecond)
+	stopChan <- os.Interrupt
+}