kacarmichael 309eeef59a
Some checks failed
Build Go Binaries / build (push) Has been cancelled
Health/status http endpoint, logging
2026-08-06 01:24:29 -05:00

124 lines
3.4 KiB
Go

package downloader
import (
"context"
"log"
"m3u8-downloader/pkg/constants"
"m3u8-downloader/pkg/health"
"m3u8-downloader/pkg/logging"
"m3u8-downloader/pkg/media"
"m3u8-downloader/pkg/transfer"
"m3u8-downloader/pkg/utils"
"os"
"os/signal"
"sync"
"syscall"
"time"
)
func Download(masterURL string, eventName string, debug bool) {
appLog := logging.MustGetFactory().App
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
// Goroutine to listen for shutdown signals
sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
go func() {
<-sigChan
log.Println("Shutting down...")
appLog.Info("shutdown signal received")
cancel()
}()
cfg := constants.MustGetConfig()
if cfg.Health.Enabled {
healthSrv, err := health.Start(ctx, &cfg.Health, health.MustGetRegistry())
if err != nil {
appLog.Error("failed to start health server", logging.KeyError, err.Error())
} else {
appLog.Info("health server listening", "addr", cfg.Health.Addr)
defer func() {
shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 5*time.Second)
defer shutdownCancel()
_ = healthSrv.Shutdown(shutdownCtx)
}()
}
}
var wg sync.WaitGroup
var transferService *transfer.TransferService
if cfg.NAS.EnableTransfer {
ts, err := transfer.NewTrasferService(cfg.NAS.OutputPath, eventName)
if err != nil {
log.Printf("Failed to create transfer service: %v", err)
log.Println("Continuing without transfer service...")
appLog.Error("failed to create transfer service, continuing without it", logging.KeyError, err.Error())
} else {
transferService = ts
wg.Add(1)
go func() {
defer wg.Done()
if err := transferService.Start(ctx); err != nil && err != context.Canceled {
log.Printf("Transfer service error: %v", err)
appLog.Error("transfer service error", logging.KeyError, err.Error())
}
}()
log.Println("Transfer service started.")
appLog.Info("transfer service started")
}
}
manifestWriter := media.NewManifestWriter(eventName)
eventPath := cfg.GetEventPath(eventName)
if err := utils.EnsureDir(eventPath); err != nil {
appLog.Error("failed to create event directory", logging.KeyError, err.Error())
log.Fatalf("Failed to create event directory: %v", err)
}
variants, err := media.GetAllVariants(masterURL, eventPath, manifestWriter)
if err != nil {
appLog.Error("failed to get variants", logging.KeyError, err.Error())
log.Fatalf("Failed to get variants: %v", err)
}
log.Printf("Found %d variants", len(variants))
sem := make(chan struct{}, constants.WorkerCount*len(variants))
manifest := media.NewManifestWriter(eventName)
for _, variant := range variants {
// Debug mode only tracks one variant for easier debugging
if debug {
if variant.Resolution != "1080p" {
continue
}
}
wg.Add(1)
go func(v *media.StreamVariant) {
defer wg.Done()
media.VariantDownloader(ctx, v, sem, manifest)
}(variant)
}
wg.Wait()
log.Println("All variant downloaders finished.")
appLog.Info("all variant downloaders finished")
if transferService != nil {
shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 30*time.Second)
defer shutdownCancel()
transferService.Shutdown(shutdownCtx)
}
log.Println("All Services shut down.")
appLog.Info("all services shut down")
manifestWriter.WriteManifest()
log.Println("Manifest written.")
appLog.Info("manifest written", logging.KeyEvent, eventName)
}