main.go

package main

import (
	"digitalcashtools/monerod-proxy/endpoints"
	"digitalcashtools/monerod-proxy/httpclient"
	"digitalcashtools/monerod-proxy/monerodclient"
	"digitalcashtools/monerod-proxy/nodemanagement"
	"digitalcashtools/monerod-proxy/security"
	"digitalcashtools/monerod-proxy/txpool"
	"flag"
	"fmt"
	"net/http"
	"os"
	"time"

	log "github.com/sirupsen/logrus"
	"golang.org/x/crypto/acme/autocert"

	"github.com/labstack/echo/v4"
	"github.com/labstack/echo/v4/middleware"
	"gopkg.in/ini.v1"
)

func main() {
	configPathPtr := flag.String("c", "config.ini", "path to config file")
	flag.Parse()

	cfg, err := ini.Load(*configPathPtr)
	if err != nil {
		log.Fatal("Failed to read config file: ", *configPathPtr)
	}

	logLevel := cfg.Section("").Key("log_level").Value()
	switch logLevel {
	case "Trace":
		log.SetLevel(log.TraceLevel)
	case "Debug":
		log.SetLevel(log.DebugLevel)
	case "Info":
		log.SetLevel(log.InfoLevel)
	case "Warn":
		log.SetLevel(log.WarnLevel)
	case "Error":
		log.SetLevel(log.ErrorLevel)
	default:
		log.SetLevel(log.InfoLevel)
		log.Info("Log level from config not recognised, defaulting to Info level.")
	}

	httpPort := cfg.Section("").Key("http_port").Value()
	httpsEnabled, _ := cfg.Section("").Key("https_enabled").Bool()
	httpsDomain := cfg.Section("").Key("https_domain").Value()
	httpsCertCacheDir := cfg.Section("").Key("https_cert_cache_dir").Value()

	nodeProvider := nodemanagement.CreateNodeProviderFromConfig(cfg)
	passwordChecker := security.CreatePasswordCheckerFromConfig(cfg)
	monerodClient := monerodclient.CreateMonerodClient(nodeProvider, httpclient.ExecuteGETRequest, httpclient.ExecutePOSTRequest)
	txRepository := txpool.CreateTXRepositoryFromConfig(cfg, monerodClient, func() time.Time { return time.Now().UTC() })
	txpoolTracker := txpool.CreateTXPoolTrackerFromConfig(cfg, txRepository, nodeProvider)

	e := echo.New()
	endpoints.ConfigurePing(e)
	endpoints.ConfigureAdminEndpoints(e, passwordChecker, nodeProvider)
	endpoints.ConfigureMonerodProxyHandler(e, nodeProvider)
	endpoints.ConfigureTXPoolNotifier(e, txpoolTracker.NotifyChannel)
	endpoints.ConfigureMonerodExtensions(e, txRepository)

	setUpNodeHealthCheckTicker(cfg, nodeProvider)

	nodeProvider.CheckNodeHealth()
	log.Info("Selected node: ", nodeProvider.GetBaseURL())

	e.GET("*", func(c echo.Context) error {
		reqDump := time.Now().Format(time.RFC3339) + " GET Request received: " + c.Path() + c.QueryString()
		log.Debug(reqDump)
		return c.String(http.StatusOK, reqDump)
	})

	e.POST("*", func(c echo.Context) error {
		reqDump := time.Now().Format(time.RFC3339) + " POST Request received: " + c.Path() + c.QueryString()
		log.Debug(reqDump)
		return c.String(http.StatusOK, reqDump)
	})

	log.Info("Server running, test by visiting localhost:", httpPort, "/api/proxy/ping")

	go txpoolTracker.StartTracking()

	e.Use(middleware.CORS())
	e.Use(middleware.Recover())
	e.Use(middleware.Logger())

	if httpsEnabled {
		e.AutoTLSManager.HostPolicy = autocert.HostWhitelist(httpsDomain)
		os.MkdirAll(httpsCertCacheDir, 0700)
		e.AutoTLSManager.Cache = autocert.DirCache(httpsCertCacheDir)
		e.Pre(middleware.HTTPSRedirect())

		e.Logger.Fatal(e.StartAutoTLS(":" + httpPort))
	} else {
		e.Logger.Fatal(e.Start(":" + httpPort))
	}
}

func setUpNodeHealthCheckTicker(cfg *ini.File, nodeProvider nodemanagement.INodeProvider) {
	secondsBetweenHealthChecks, err := cfg.Section("").Key("seconds_between_health_checks").Int()
	if err != nil {
		secondsBetweenHealthChecks = 10 * 60
	}

	log.Info(fmt.Sprintf("Performing node health check every %d seconds.", secondsBetweenHealthChecks))

	healthCheckTicker := time.NewTicker(time.Duration(secondsBetweenHealthChecks) * time.Second)

	go func() {
		for {
			<-healthCheckTicker.C
			log.Debug("Checking node health...")

			previousNode := nodeProvider.GetBaseURL()

			nodeProvider.CheckNodeHealth()

			newSelectedNode := nodeProvider.GetBaseURL()

			if newSelectedNode != previousNode {
				log.Info("Switched to new node:", newSelectedNode)
			}
		}
	}()
}