Merge branch 'experimental' into beta

cmd/decypharr/main.go

@@ -3,15 +3,15 @@ package decypharr
 import (
 	"context"
 	"fmt"
-	"github.com/sirrobot01/debrid-blackhole/internal/config"
-	"github.com/sirrobot01/debrid-blackhole/internal/logger"
-	"github.com/sirrobot01/debrid-blackhole/pkg/proxy"
-	"github.com/sirrobot01/debrid-blackhole/pkg/qbit"
-	"github.com/sirrobot01/debrid-blackhole/pkg/server"
-	"github.com/sirrobot01/debrid-blackhole/pkg/service"
-	"github.com/sirrobot01/debrid-blackhole/pkg/version"
-	"github.com/sirrobot01/debrid-blackhole/pkg/web"
-	"github.com/sirrobot01/debrid-blackhole/pkg/worker"
+	"github.com/sirrobot01/decypharr/internal/config"
+	"github.com/sirrobot01/decypharr/internal/logger"
+	"github.com/sirrobot01/decypharr/pkg/qbit"
+	"github.com/sirrobot01/decypharr/pkg/server"
+	"github.com/sirrobot01/decypharr/pkg/service"
+	"github.com/sirrobot01/decypharr/pkg/version"
+	"github.com/sirrobot01/decypharr/pkg/web"
+	"github.com/sirrobot01/decypharr/pkg/webdav"
+	"github.com/sirrobot01/decypharr/pkg/worker"
 	"os"
 	"runtime/debug"
 	"strconv"
@@ -28,25 +28,28 @@ func Start(ctx context.Context) error {
 		SetUmask(int(umask))
 	}
 
-	cfg := config.GetConfig()
+	cfg := config.Get()
 	var wg sync.WaitGroup
 	errChan := make(chan error)
 
 	_log := logger.GetDefaultLogger()
 
-	_log.Info().Msgf("Version: %s", version.GetInfo().String())
-	_log.Debug().Msgf("Config Loaded: %s", cfg.JsonFile())
+	_log.Info().Msgf("Starting Decypher (%s)", version.GetInfo().String())
 	_log.Info().Msgf("Default Log Level: %s", cfg.LogLevel)
 
 	svc := service.New()
 	_qbit := qbit.New()
 	srv := server.New()
-	webRoutes := web.New(_qbit).Routes()
+	_webdav := webdav.New()
+
+	ui := web.New(_qbit).Routes()
+	webdavRoutes := _webdav.Routes()
 	qbitRoutes := _qbit.Routes()
 
 	// Register routes
-	srv.Mount("/", webRoutes)
+	srv.Mount("/", ui)
 	srv.Mount("/api/v2", qbitRoutes)
+	srv.Mount("/webdav", webdavRoutes)
 
 	safeGo := func(f func() error) {
 		wg.Add(1)
@@ -71,11 +74,9 @@ func Start(ctx context.Context) error {
 		}()
 	}
 
-	if cfg.Proxy.Enabled {
-		safeGo(func() error {
-			return proxy.NewProxy().Start(ctx)
-		})
-	}
+	safeGo(func() error {
+		return _webdav.Start(ctx)
+	})
 
 	safeGo(func() error {
 		return srv.Start(ctx)

cmd/healthcheck/main.go

@@ -1,22 +1,141 @@
 package main
 
 import (
-	"cmp"
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"github.com/sirrobot01/decypharr/internal/config"
 	"net/http"
 	"os"
+	"time"
 )
 
+// HealthStatus represents the status of various components
+type HealthStatus struct {
+	QbitAPI       bool `json:"qbit_api"`
+	WebUI         bool `json:"web_ui"`
+	WebDAVService bool `json:"webdav_service,omitempty"`
+	OverallStatus bool `json:"overall_status"`
+}
+
 func main() {
-	port := cmp.Or(os.Getenv("QBIT_PORT"), "8282")
-	resp, err := http.Get("http://localhost:" + port + "/api/v2/app/version")
-	if err != nil {
+	var configPath string
+	flag.StringVar(&configPath, "config", "/data", "path to the data folder")
+	flag.Parse()
+	config.SetConfigPath(configPath)
+	cfg := config.Get()
+	// Get port from environment variable or use default
+	qbitPort := getEnvOrDefault("QBIT_PORT", cfg.QBitTorrent.Port)
+	webdavPath := ""
+	for _, debrid := range cfg.Debrids {
+		if debrid.UseWebDav {
+			webdavPath = debrid.Name
+		}
+	}
+
+	// Initialize status
+	status := HealthStatus{
+		QbitAPI:       false,
+		WebUI:         false,
+		WebDAVService: false,
+		OverallStatus: false,
+	}
+
+	// Create a context with timeout for all HTTP requests
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	// Check qBittorrent API
+	if checkQbitAPI(ctx, qbitPort) {
+		status.QbitAPI = true
+	}
+
+	// Check Web UI
+	if checkWebUI(ctx, qbitPort) {
+		status.WebUI = true
+	}
+
+	// Check WebDAV if enabled
+	if webdavPath != "" {
+		if checkWebDAV(ctx, qbitPort, webdavPath) {
+			status.WebDAVService = true
+		}
+	} else {
+		// If WebDAV is not enabled, consider it healthy
+		status.WebDAVService = true
+	}
+
+	// Determine overall status
+	// Consider the application healthy if core services are running
+	status.OverallStatus = status.QbitAPI && status.WebUI
+	if webdavPath != "" {
+		status.OverallStatus = status.OverallStatus && status.WebDAVService
+	}
+
+	// Optional: output health status as JSON for logging
+	if os.Getenv("DEBUG") == "true" {
+		statusJSON, _ := json.MarshalIndent(status, "", "  ")
+		fmt.Println(string(statusJSON))
+	}
+
+	// Exit with appropriate code
+	if status.OverallStatus {
+		os.Exit(0)
+	} else {
 		os.Exit(1)
 	}
+}
+
+func getEnvOrDefault(key, defaultValue string) string {
+	if value, exists := os.LookupEnv(key); exists {
+		return value
+	}
+	return defaultValue
+}
+
+func checkQbitAPI(ctx context.Context, port string) bool {
+	req, err := http.NewRequestWithContext(ctx, "GET", fmt.Sprintf("http://localhost:%s/api/v2/app/version", port), nil)
+	if err != nil {
+		return false
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return false
+	}
 	defer resp.Body.Close()
 
-	if resp.StatusCode != http.StatusOK {
-		os.Exit(1)
+	return resp.StatusCode == http.StatusOK
+}
+
+func checkWebUI(ctx context.Context, port string) bool {
+	req, err := http.NewRequestWithContext(ctx, "GET", fmt.Sprintf("http://localhost:%s/", port), nil)
+	if err != nil {
+		return false
 	}
 
-	os.Exit(0)
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return false
+	}
+	defer resp.Body.Close()
+
+	return resp.StatusCode == http.StatusOK
+}
+
+func checkWebDAV(ctx context.Context, port, path string) bool {
+	url := fmt.Sprintf("http://localhost:%s/webdav/%s", port, path)
+	req, err := http.NewRequestWithContext(ctx, "PROPFIND", url, nil)
+	if err != nil {
+		return false
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return false
+	}
+	defer resp.Body.Close()
+
+	return resp.StatusCode == 207 || resp.StatusCode == http.StatusOK
 }