add configuration

config/config.go

@@ -0,0 +1,23 @@
+package config
+
+import "flag"
+
+type Config struct {
+	Port         int    `json:"port"`
+	LogPath      string `json:"logPath"`
+	DatabasePath string `json:"databasePath"`
+}
+
+func ParseFlags() Config {
+	port := flag.Int("Port", 8080, "Listen port")
+	logPath := flag.String("LogPath", "logs", "Path to log files")
+	databasePath := flag.String("DatabasePath", "badgerdb", "Path to the database directory")
+
+	flag.Parse()
+
+	return Config{
+		Port:         *port,
+		LogPath:      *logPath,
+		DatabasePath: *databasePath,
+	}
+}

database/db.go

@@ -15,8 +15,8 @@ const (
 	CollectionName = "shares"
 )
 
-func InitDatabase() (*clover.DB, error) {
+func InitDatabase(path string) (*clover.DB, error) {
-	store, err := badgerstore.Open("badgerdb")
+	store, err := badgerstore.Open(path)
 	if err != nil {
 		return nil, fmt.Errorf("failed to open BadgerDB store: %v", err)
 	}

ingest/ingest.go

@@ -18,17 +18,26 @@ import (
 
 const logsDir = "/home/pk/pro/pkstats/logs"
 
-func WatchAndIngest(db *clover.DB) {
+type Ingestor struct {
+	db      *clover.DB
+	logPath string
+}
+
+func NewIngestor(db *clover.DB, path string) *Ingestor {
+	return &Ingestor{db: db, logPath: path}
+}
+
+func (this *Ingestor) WatchAndIngest() {
 	ticker := time.NewTicker(30 * time.Second)
 	defer ticker.Stop()
 
 	for {
 		<-ticker.C
-		IngestClosedBlocks(db)
+		this.ingestClosedBlocks()
 	}
 }
 
-func IngestClosedBlocks(db *clover.DB) {
+func (this *Ingestor) ingestClosedBlocks() {
 	entries, err := os.ReadDir(logsDir)
 	if err != nil {
 		log.Println("Error reading logsDir:", err)
@@ -54,12 +63,12 @@ func IngestClosedBlocks(db *clover.DB) {
 
 	// Ingest all except last (current block dir)
 	for _, dir := range blockDirs[:len(blockDirs)-1] {
-		IngestBlockDir(db, filepath.Join(logsDir, dir.Name()))
+		this.ingestBlockDir(this.db, filepath.Join(logsDir, dir.Name()))
 		_ = os.RemoveAll(filepath.Join(logsDir, dir.Name()))
 	}
 }
 
-func IngestBlockDir(db *clover.DB, dirPath string) {
+func (this *Ingestor) ingestBlockDir(db *clover.DB, dirPath string) {
 	files, err := os.ReadDir(dirPath)
 	if err != nil {
 		log.Printf("Failed to read block dir %s: %v", dirPath, err)

main.go

@@ -3,31 +3,32 @@ package main
 import (
 	"fmt"
 	"log"
-	"net/http"
 	"os"
 	"os/signal"
 	"syscall"
 
+	"pool-stats/config"
 	"pool-stats/database"
 	"pool-stats/ingest"
 	"pool-stats/web"
 )
 
 func main() {
-	db, err := database.InitDatabase()
+	config := config.ParseFlags()
+
+	db, err := database.InitDatabase(config.DatabasePath)
 	if err != nil {
 		log.Fatalf("Failed to initialize database: %v", err)
 	}
 	defer db.Close()
 
-	go ingest.WatchAndIngest(db)
+	ingestor := ingest.NewIngestor(db, config.LogPath)
+	go ingestor.WatchAndIngest()
 
-	go func() {
+	webServer := web.NewWebServer(db, config.Port)
-		handlers := web.Handlers{DB: db}
+	if err := webServer.Start(); err != nil {
-		http.HandleFunc("/", handlers.IndexHandler)
+		log.Fatalf("Failed to start web server: %v", err)
-		fmt.Println("Listening on :8081")
+	}
-		log.Fatal(http.ListenAndServe(":8081", nil))
-	}()
 
 	fmt.Println("Waiting for ctrl-c")
 	sigs := make(chan os.Signal, 1)

web/handlers.go

@@ -5,16 +5,10 @@ import (
 	"net/http"
 
 	"pool-stats/stats"
-
-	"github.com/ostafen/clover/v2"
 )
 
-type Handlers struct {
+func (ws *WebServer) IndexHandler(w http.ResponseWriter, r *http.Request) {
-	DB *clover.DB
+	shareStats, err := stats.GetStats(ws.db)
-}
-
-func (h Handlers) IndexHandler(w http.ResponseWriter, r *http.Request) {
-	shareStats, err := stats.GetStats(h.DB)
 	if err != nil {
 		http.Error(w, "Failed to load stats", 500)
 		return

web/server.go

@@ -0,0 +1,28 @@
+package web
+
+import (
+	"net/http"
+
+	"fmt"
+
+	"github.com/ostafen/clover/v2"
+)
+
+type WebServer struct {
+	db   *clover.DB
+	port int
+}
+
+func NewWebServer(db *clover.DB, port int) *WebServer {
+	return &WebServer{
+		db:   db,
+		port: port,
+	}
+}
+
+func (ws *WebServer) Start() error {
+	http.HandleFunc("/", ws.IndexHandler)
+	address := ":" + fmt.Sprint(ws.port)
+	println("Listening on", address)
+	return http.ListenAndServe(address, nil)
+}