88316e7017
Gives the daemon a public HTTPS hostname (`https://<random>.trycloudflare.com`)
so the in-browser player on torrentclaw.com plays cross-network without
Tailscale or port forwarding — the mixed-content block that was breaking
HTTPS-page → HTTP-daemon fetches is gone. Bytes proxy through CloudFlare,
never through TorrentClaw infra (preserves the aggregator legal posture).
New surface:
• `internal/funnel/` package: subprocess wrapper + auto-download for
cloudflared. Linux amd64/arm64/armhf/386 fetched from GitHub releases
on first run, validated by ELF magic + size sanity, O_EXCL partial
write so concurrent daemons don't clobber each other.
• `unarr funnel on/off/status` cobra command (sibling of `unarr vpn`).
• Daemon supervisor goroutine keeps cloudflared up across crashes + CF's
~6h Quick Tunnel rotation. Exponential backoff (2 s → 5 min). On exit
the reported URL is cleared so the web stops handing out a dead host.
• Wire: agent registers/syncs a FunnelURL field; web prefers it over
Tailscale/LAN for in-browser playback (HlsStreamPlayer + Stremio
addon).
Default ON for fresh installs (NAS/Docker get it without terminal-in);
existing configs that pre-date the feature stay off until the operator
opts in with `unarr funnel on`.
Docker image now bundles cloudflared (built per TARGETARCH via buildx).
Also fixed: libx264 'frame MB size > level limit' on anamorphic >16:9
sources. The level we hint to libx264 was derived from height alone,
which busted on 720p cinemascope (1728×720 = 4860 MBs > level 3.1's
3600). Bumped each tier: 720p → 4.0, 1080p → 4.1.
Version: 0.9.4 → 0.9.5.
88 lines
2.9 KiB
Go
88 lines
2.9 KiB
Go
package agent
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"time"
|
|
|
|
"github.com/torrentclaw/unarr/internal/config"
|
|
)
|
|
|
|
// DaemonState is written to disk every heartbeat for external tools to read.
|
|
type DaemonState struct {
|
|
AgentID string `json:"agentId"`
|
|
Status string `json:"status"` // running | upgrading | shutting_down
|
|
Version string `json:"version"`
|
|
PID int `json:"pid"`
|
|
StartedAt time.Time `json:"startedAt"`
|
|
LastHeartbeat time.Time `json:"lastHeartbeat"`
|
|
ActiveTasks int `json:"activeTasks"`
|
|
CompletedCount int `json:"completedCount"`
|
|
FailedCount int `json:"failedCount"`
|
|
TotalDownloaded int64 `json:"totalDownloaded"`
|
|
MethodStats map[string]int `json:"methodStats,omitempty"`
|
|
|
|
// Managed-VPN split-tunnel state, so `unarr vpn status` can report whether
|
|
// torrent traffic is actually being routed through the tunnel (vs. the daemon
|
|
// running but the tunnel having failed to come up → downloading in the clear).
|
|
VPNActive bool `json:"vpnActive,omitempty"`
|
|
VPNMode string `json:"vpnMode,omitempty"` // managed | self-hosted
|
|
VPNServer string `json:"vpnServer,omitempty"` // WireGuard endpoint (ip:port)
|
|
|
|
// CloudFlare Quick Tunnel state, so `unarr funnel status` can report the
|
|
// HTTPS hostname the daemon is reachable at from anywhere on the internet.
|
|
// Empty when the funnel is off or hasn't registered yet.
|
|
FunnelURL string `json:"funnelUrl,omitempty"`
|
|
}
|
|
|
|
// stateFilePathFn is overridable for testing.
|
|
var stateFilePathFn = func() string {
|
|
return filepath.Join(config.DataDir(), "daemon.state.json")
|
|
}
|
|
|
|
// StateFilePath returns the path to the daemon state file.
|
|
func StateFilePath() string {
|
|
return stateFilePathFn()
|
|
}
|
|
|
|
// WriteState writes the daemon state to disk (best-effort, never errors).
|
|
func WriteState(state *DaemonState) {
|
|
path := StateFilePath()
|
|
dir := filepath.Dir(path)
|
|
os.MkdirAll(dir, 0o755)
|
|
|
|
data, err := json.MarshalIndent(state, "", " ")
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
// Write to temp file then rename for atomicity. 0o600 keeps the file
|
|
// readable only by the owning user — the state contains agentID, PID
|
|
// and counters which are useful to a co-tenant on a shared host for
|
|
// fingerprinting the daemon, and we already use 0o600 for the config
|
|
// file. No need for cross-user readability here.
|
|
tmp := path + ".tmp"
|
|
if err := os.WriteFile(tmp, data, 0o600); err != nil {
|
|
return
|
|
}
|
|
os.Rename(tmp, path)
|
|
}
|
|
|
|
// ReadState reads the daemon state from disk. Returns nil if not found.
|
|
func ReadState() *DaemonState {
|
|
data, err := os.ReadFile(StateFilePath())
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
var state DaemonState
|
|
if json.Unmarshal(data, &state) != nil {
|
|
return nil
|
|
}
|
|
return &state
|
|
}
|
|
|
|
// RemoveState deletes the state file (called on clean shutdown).
|
|
func RemoveState() {
|
|
os.Remove(StateFilePath())
|
|
}
|