feat(stream): persistent stream server with file swapping
This commit is contained in:
Deivid Soto
parent
080fdf4d76
commit
5994a30447
11 changed files with 354 additions and 282 deletions
|
|
@ -297,7 +297,7 @@ func (s *StreamEngine) FileName() string { return s.fileName }
|
|||
// FileLength returns the total size of the selected file in bytes.
|
||||
func (s *StreamEngine) FileLength() int64 { return s.totalBytes }
|
||||
|
||||
// FileSize implements fileProvider for StreamServer compatibility.
|
||||
// FileSize implements FileProvider for StreamServer compatibility.
|
||||
func (s *StreamEngine) FileSize() int64 { return s.totalBytes }
|
||||
|
||||
// BufferTarget returns the buffer threshold in bytes.
|
||||
|
|
|
|||
|
|
@ -13,7 +13,9 @@ import (
|
|||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"github.com/anacrolix/torrent"
|
||||
|
|
@ -28,151 +30,83 @@ type StreamURLs struct {
|
|||
Public string `json:"pub,omitempty"`
|
||||
}
|
||||
|
||||
// fileProvider abstracts where to get a file reader for streaming.
|
||||
type fileProvider interface {
|
||||
// FileProvider abstracts where to get a file reader for streaming.
|
||||
type FileProvider interface {
|
||||
NewFileReader(ctx context.Context) io.ReadSeekCloser
|
||||
FileName() string
|
||||
FileSize() int64
|
||||
}
|
||||
|
||||
// StreamServer serves a torrent file over HTTP with Range request support.
|
||||
// StreamServer is a persistent HTTP server that serves one file at a time.
|
||||
// Start it once with Listen(), then swap files with SetFile()/ClearFile().
|
||||
// The server stays alive for the entire daemon lifecycle — no port churn.
|
||||
type StreamServer struct {
|
||||
provider fileProvider
|
||||
server *http.Server
|
||||
port int
|
||||
url string // best single URL (backward compat)
|
||||
urls StreamURLs // all available URLs by network type
|
||||
upnpMapping *UPnPMapping
|
||||
disableUPnP bool // for testing
|
||||
lastActivity atomic.Int64 // UnixNano of last HTTP request
|
||||
maxByteOffset atomic.Int64 // highest byte offset served (for watch progress estimation)
|
||||
totalFileSize int64 // total file size in bytes (set on Start)
|
||||
mu sync.RWMutex
|
||||
provider FileProvider
|
||||
taskID string // current task being streamed
|
||||
|
||||
server *http.Server
|
||||
port int
|
||||
url string // best single URL (backward compat)
|
||||
urls StreamURLs // all available URLs by network type
|
||||
upnpMapping *UPnPMapping
|
||||
disableUPnP bool
|
||||
|
||||
lastActivity atomic.Int64
|
||||
maxByteOffset atomic.Int64
|
||||
totalFileSize atomic.Int64
|
||||
}
|
||||
|
||||
// NewStreamServer creates a new HTTP server for streaming via StreamEngine.
|
||||
func NewStreamServer(engine *StreamEngine, port int) *StreamServer {
|
||||
return &StreamServer{
|
||||
provider: engine,
|
||||
port: port,
|
||||
}
|
||||
// NewStreamServer creates a stream server bound to the given port.
|
||||
// Call Listen() to start accepting connections, then SetFile() to serve content.
|
||||
func NewStreamServer(port int) *StreamServer {
|
||||
return &StreamServer{port: port}
|
||||
}
|
||||
|
||||
// NewStreamServerFromFile creates a server that streams directly from a torrent.File.
|
||||
// Used for streaming an active download without a separate StreamEngine.
|
||||
func NewStreamServerFromFile(file *torrent.File, port int) *StreamServer {
|
||||
return &StreamServer{
|
||||
provider: &torrentFileProvider{file: file},
|
||||
port: port,
|
||||
}
|
||||
}
|
||||
|
||||
// torrentFileProvider wraps a torrent.File to implement fileProvider.
|
||||
type torrentFileProvider struct {
|
||||
file *torrent.File
|
||||
}
|
||||
|
||||
func (p *torrentFileProvider) NewFileReader(ctx context.Context) io.ReadSeekCloser {
|
||||
reader := p.file.NewReader()
|
||||
reader.SetResponsive()
|
||||
reader.SetReadahead(5 * 1024 * 1024)
|
||||
reader.SetContext(ctx)
|
||||
return reader
|
||||
}
|
||||
|
||||
func (p *torrentFileProvider) FileName() string {
|
||||
return filepath.Base(p.file.DisplayPath())
|
||||
}
|
||||
|
||||
func (p *torrentFileProvider) FileSize() int64 {
|
||||
return p.file.Length()
|
||||
}
|
||||
|
||||
// diskFileProvider serves a file from disk.
|
||||
type diskFileProvider struct {
|
||||
path string
|
||||
name string
|
||||
}
|
||||
|
||||
func (p *diskFileProvider) NewFileReader(_ context.Context) io.ReadSeekCloser {
|
||||
f, err := os.Open(p.path)
|
||||
if err != nil {
|
||||
log.Printf("stream: failed to open %q: %v", p.path, err)
|
||||
return nil
|
||||
}
|
||||
return f
|
||||
}
|
||||
|
||||
func (p *diskFileProvider) FileName() string { return p.name }
|
||||
|
||||
func (p *diskFileProvider) FileSize() int64 {
|
||||
fi, err := os.Stat(p.path)
|
||||
if err != nil {
|
||||
log.Printf("stream: failed to stat %q: %v", p.path, err)
|
||||
return 0
|
||||
}
|
||||
return fi.Size()
|
||||
}
|
||||
|
||||
// NewStreamServerFromDisk creates a server that streams a file from disk.
|
||||
func NewStreamServerFromDisk(filePath string, port int) *StreamServer {
|
||||
return &StreamServer{
|
||||
provider: &diskFileProvider{
|
||||
path: filePath,
|
||||
name: filepath.Base(filePath),
|
||||
},
|
||||
port: port,
|
||||
}
|
||||
}
|
||||
|
||||
// FindVideoFile scans a directory (recursively) for the largest video file.
|
||||
// Returns empty string if no video file found.
|
||||
func FindVideoFile(dir string) string {
|
||||
var best string
|
||||
var bestSize int64
|
||||
|
||||
filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error {
|
||||
if err != nil || d.IsDir() {
|
||||
return nil
|
||||
}
|
||||
ext := strings.ToLower(filepath.Ext(d.Name()))
|
||||
if !VideoExts[ext] {
|
||||
return nil
|
||||
}
|
||||
info, err := d.Info()
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
if info.Size() > bestSize {
|
||||
best = path
|
||||
bestSize = info.Size()
|
||||
}
|
||||
return nil
|
||||
})
|
||||
return best
|
||||
}
|
||||
|
||||
// Start begins serving the file on all interfaces. Returns the best reachable URL.
|
||||
// The file is served as-is — the user's media player (VLC, mpv, etc.) handles decoding.
|
||||
func (ss *StreamServer) Start(ctx context.Context) (string, error) {
|
||||
ss.lastActivity.Store(time.Now().UnixNano())
|
||||
ss.totalFileSize = ss.provider.FileSize()
|
||||
|
||||
// Listen starts the HTTP server on the configured port. Call once at daemon startup.
|
||||
func (ss *StreamServer) Listen(ctx context.Context) error {
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("/stream", ss.handler)
|
||||
|
||||
addr := fmt.Sprintf("0.0.0.0:%d", ss.port)
|
||||
listener, err := net.Listen("tcp", addr)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("listen on %s: %w", addr, err)
|
||||
// SO_REUSEADDR allows immediate rebind if the port is in TIME_WAIT (e.g. after agent restart)
|
||||
lc := net.ListenConfig{
|
||||
Control: func(network, address string, c syscall.RawConn) error {
|
||||
return c.Control(func(fd uintptr) {
|
||||
_ = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
|
||||
})
|
||||
},
|
||||
}
|
||||
|
||||
// Try configured port; if busy, try next ports (heartbeat reports actual port to web)
|
||||
var listener net.Listener
|
||||
var listenErr error
|
||||
basePort := ss.port
|
||||
for attempt := 0; attempt < 10; attempt++ {
|
||||
addr := fmt.Sprintf("0.0.0.0:%d", ss.port)
|
||||
listener, listenErr = lc.Listen(ctx, "tcp", addr)
|
||||
if listenErr == nil {
|
||||
break
|
||||
}
|
||||
if !strings.Contains(listenErr.Error(), "address already in use") {
|
||||
return fmt.Errorf("stream server listen on %s: %w", addr, listenErr)
|
||||
}
|
||||
ss.port++
|
||||
log.Printf("[stream] port %d in use, trying %d", ss.port-1, ss.port)
|
||||
}
|
||||
if listenErr != nil {
|
||||
return fmt.Errorf("stream server: all ports busy (%d-%d): %w", basePort, ss.port, listenErr)
|
||||
}
|
||||
if ss.port != basePort {
|
||||
log.Printf("[stream] using port %d (configured %d was busy)", ss.port, basePort)
|
||||
}
|
||||
|
||||
ss.port = listener.Addr().(*net.TCPAddr).Port
|
||||
|
||||
// Collect all reachable URLs by network type
|
||||
if lanIP := lanIP(); lanIP != "" {
|
||||
if lanIP := LanIP(); lanIP != "" {
|
||||
ss.urls.LAN = fmt.Sprintf("http://%s:%d/stream", lanIP, ss.port)
|
||||
}
|
||||
if tsIP := tailscaleIP(); tsIP != "" {
|
||||
if tsIP := TailscaleIP(); tsIP != "" {
|
||||
ss.urls.Tailscale = fmt.Sprintf("http://%s:%d/stream", tsIP, ss.port)
|
||||
}
|
||||
if !ss.disableUPnP {
|
||||
|
|
@ -206,15 +140,49 @@ func (ss *StreamServer) Start(ctx context.Context) (string, error) {
|
|||
}
|
||||
}()
|
||||
|
||||
return ss.url, nil
|
||||
log.Printf("[stream] server listening on port %d", ss.port)
|
||||
return nil
|
||||
}
|
||||
|
||||
// SetFile atomically swaps the file being served and resets progress tracking.
|
||||
func (ss *StreamServer) SetFile(provider FileProvider, taskID string) {
|
||||
ss.mu.Lock()
|
||||
ss.provider = provider
|
||||
ss.taskID = taskID
|
||||
ss.mu.Unlock()
|
||||
ss.totalFileSize.Store(provider.FileSize())
|
||||
ss.lastActivity.Store(time.Now().UnixNano())
|
||||
ss.maxByteOffset.Store(0)
|
||||
}
|
||||
|
||||
// ClearFile stops serving any file. Subsequent requests return 404.
|
||||
func (ss *StreamServer) ClearFile() {
|
||||
ss.mu.Lock()
|
||||
ss.provider = nil
|
||||
ss.taskID = ""
|
||||
ss.mu.Unlock()
|
||||
ss.totalFileSize.Store(0)
|
||||
ss.maxByteOffset.Store(0)
|
||||
}
|
||||
|
||||
// CurrentTaskID returns the task ID of the file currently being served.
|
||||
func (ss *StreamServer) CurrentTaskID() string {
|
||||
ss.mu.RLock()
|
||||
defer ss.mu.RUnlock()
|
||||
return ss.taskID
|
||||
}
|
||||
|
||||
// HasFile returns true if a file is currently being served.
|
||||
func (ss *StreamServer) HasFile() bool {
|
||||
ss.mu.RLock()
|
||||
defer ss.mu.RUnlock()
|
||||
return ss.provider != nil
|
||||
}
|
||||
|
||||
// URL returns the best single stream URL (backward compat).
|
||||
func (ss *StreamServer) URL() string { return ss.url }
|
||||
|
||||
// URLsJSON returns all available stream URLs as a JSON string.
|
||||
// Stored in the stream_url DB field so the web API can resolve
|
||||
// the best URL based on the browser's network.
|
||||
func (ss *StreamServer) URLsJSON() string {
|
||||
b, _ := json.Marshal(ss.urls)
|
||||
return string(b)
|
||||
|
|
@ -233,6 +201,7 @@ func (ss *StreamServer) IdleSince() time.Duration {
|
|||
}
|
||||
|
||||
// Shutdown gracefully stops the HTTP server and removes the UPnP port mapping.
|
||||
// Call only at daemon shutdown — NOT between file swaps.
|
||||
func (ss *StreamServer) Shutdown(ctx context.Context) error {
|
||||
ss.upnpMapping.Remove()
|
||||
if ss.server != nil {
|
||||
|
|
@ -256,6 +225,16 @@ func (ss *StreamServer) handler(w http.ResponseWriter, r *http.Request) {
|
|||
}
|
||||
}
|
||||
|
||||
// Get current provider (may be nil if no file is being served)
|
||||
ss.mu.RLock()
|
||||
provider := ss.provider
|
||||
ss.mu.RUnlock()
|
||||
|
||||
if provider == nil {
|
||||
http.Error(w, "no active stream", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
|
||||
// CORS headers — only when browser sends Origin (HTTPS site → localhost)
|
||||
if origin := r.Header.Get("Origin"); origin != "" {
|
||||
w.Header().Set("Access-Control-Allow-Origin", "*")
|
||||
|
|
@ -269,21 +248,20 @@ func (ss *StreamServer) handler(w http.ResponseWriter, r *http.Request) {
|
|||
}
|
||||
}
|
||||
|
||||
reader := ss.provider.NewFileReader(r.Context())
|
||||
reader := provider.NewFileReader(r.Context())
|
||||
if reader == nil {
|
||||
http.Error(w, "file not found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
defer reader.Close()
|
||||
|
||||
w.Header().Set("Content-Type", mimeTypeFromExt(ss.provider.FileName()))
|
||||
w.Header().Set("Content-Type", mimeTypeFromExt(provider.FileName()))
|
||||
// "inline" for play requests (VLC/mpv), "attachment" for download requests.
|
||||
// Browser download via window.open() relies on "attachment" to trigger save dialog.
|
||||
disposition := "inline"
|
||||
if r.URL.Query().Get("download") == "1" {
|
||||
disposition = "attachment"
|
||||
}
|
||||
downloadName := ss.provider.FileName()
|
||||
downloadName := provider.FileName()
|
||||
if disposition == "attachment" {
|
||||
ext := filepath.Ext(downloadName)
|
||||
downloadName = strings.TrimSuffix(downloadName, ext) + " [TorrentClaw]" + ext
|
||||
|
|
@ -291,13 +269,12 @@ func (ss *StreamServer) handler(w http.ResponseWriter, r *http.Request) {
|
|||
w.Header().Set("Content-Disposition", fmt.Sprintf("%s; filename=%q", disposition, downloadName))
|
||||
w.Header().Set("Accept-Ranges", "bytes")
|
||||
|
||||
http.ServeContent(w, r, ss.provider.FileName(), time.Time{}, reader)
|
||||
http.ServeContent(w, r, provider.FileName(), time.Time{}, reader)
|
||||
}
|
||||
|
||||
// EstimatedProgress returns an estimated watch progress based on HTTP Range requests.
|
||||
// Returns (position, duration) where both are 0-100 scale (percentage-based).
|
||||
func (ss *StreamServer) EstimatedProgress() (position int, duration int) {
|
||||
total := ss.totalFileSize
|
||||
total := ss.totalFileSize.Load()
|
||||
if total <= 0 {
|
||||
return 0, 0
|
||||
}
|
||||
|
|
@ -311,7 +288,6 @@ func (ss *StreamServer) EstimatedProgress() (position int, duration int) {
|
|||
|
||||
// parseRangeStart extracts the start byte from a "Range: bytes=START-" header.
|
||||
func parseRangeStart(rangeHeader string) int64 {
|
||||
// Format: "bytes=START-" or "bytes=START-END"
|
||||
after, found := strings.CutPrefix(rangeHeader, "bytes=")
|
||||
if !found {
|
||||
return -1
|
||||
|
|
@ -327,8 +303,98 @@ func parseRangeStart(rangeHeader string) int64 {
|
|||
return start
|
||||
}
|
||||
|
||||
// lanIP returns the machine's LAN IP, or "" if unavailable.
|
||||
func lanIP() string {
|
||||
// --- File Providers ---
|
||||
|
||||
// NewDiskFileProvider creates a FileProvider that serves a file from disk.
|
||||
func NewDiskFileProvider(filePath string) FileProvider {
|
||||
return &diskFileProvider{
|
||||
path: filePath,
|
||||
name: filepath.Base(filePath),
|
||||
}
|
||||
}
|
||||
|
||||
// diskFileProvider serves a file from disk.
|
||||
type diskFileProvider struct {
|
||||
path string
|
||||
name string
|
||||
}
|
||||
|
||||
func (p *diskFileProvider) NewFileReader(_ context.Context) io.ReadSeekCloser {
|
||||
f, err := os.Open(p.path)
|
||||
if err != nil {
|
||||
log.Printf("stream: failed to open %q: %v", p.path, err)
|
||||
return nil
|
||||
}
|
||||
return f
|
||||
}
|
||||
|
||||
func (p *diskFileProvider) FileName() string { return p.name }
|
||||
|
||||
func (p *diskFileProvider) FileSize() int64 {
|
||||
fi, err := os.Stat(p.path)
|
||||
if err != nil {
|
||||
log.Printf("stream: failed to stat %q: %v", p.path, err)
|
||||
return 0
|
||||
}
|
||||
return fi.Size()
|
||||
}
|
||||
|
||||
// NewTorrentFileProvider creates a FileProvider from an active torrent file.
|
||||
func NewTorrentFileProvider(file *torrent.File) FileProvider {
|
||||
return &torrentFileProvider{file: file}
|
||||
}
|
||||
|
||||
// torrentFileProvider wraps a torrent.File to implement FileProvider.
|
||||
type torrentFileProvider struct {
|
||||
file *torrent.File
|
||||
}
|
||||
|
||||
func (p *torrentFileProvider) NewFileReader(ctx context.Context) io.ReadSeekCloser {
|
||||
reader := p.file.NewReader()
|
||||
reader.SetResponsive()
|
||||
reader.SetReadahead(5 * 1024 * 1024)
|
||||
reader.SetContext(ctx)
|
||||
return reader
|
||||
}
|
||||
|
||||
func (p *torrentFileProvider) FileName() string {
|
||||
return filepath.Base(p.file.DisplayPath())
|
||||
}
|
||||
|
||||
func (p *torrentFileProvider) FileSize() int64 {
|
||||
return p.file.Length()
|
||||
}
|
||||
|
||||
// --- Utility functions ---
|
||||
|
||||
// FindVideoFile scans a directory (recursively) for the largest video file.
|
||||
func FindVideoFile(dir string) string {
|
||||
var best string
|
||||
var bestSize int64
|
||||
|
||||
filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error {
|
||||
if err != nil || d.IsDir() {
|
||||
return nil
|
||||
}
|
||||
ext := strings.ToLower(filepath.Ext(d.Name()))
|
||||
if !VideoExts[ext] {
|
||||
return nil
|
||||
}
|
||||
info, err := d.Info()
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
if info.Size() > bestSize {
|
||||
best = path
|
||||
bestSize = info.Size()
|
||||
}
|
||||
return nil
|
||||
})
|
||||
return best
|
||||
}
|
||||
|
||||
// LanIP returns the machine's LAN IP, or "" if unavailable.
|
||||
func LanIP() string {
|
||||
conn, err := net.Dial("udp", "8.8.8.8:80")
|
||||
if err != nil {
|
||||
return ""
|
||||
|
|
@ -337,8 +403,8 @@ func lanIP() string {
|
|||
return conn.LocalAddr().(*net.UDPAddr).IP.String()
|
||||
}
|
||||
|
||||
// tailscaleIP returns the Tailscale IPv4 address, or "" if Tailscale isn't running.
|
||||
func tailscaleIP() string {
|
||||
// TailscaleIP returns the Tailscale IPv4 address, or "" if Tailscale isn't running.
|
||||
func TailscaleIP() string {
|
||||
out, err := exec.Command("tailscale", "ip", "-4").Output()
|
||||
if err != nil {
|
||||
return ""
|
||||
|
|
|
|||
|
|
@ -189,16 +189,28 @@ func TestStreamServerStartShutdown(t *testing.T) {
|
|||
totalBytes: 1024,
|
||||
}
|
||||
|
||||
srv := NewStreamServer(s, 0)
|
||||
srv := NewStreamServer(0)
|
||||
if srv.Port() != 0 {
|
||||
t.Errorf("initial port should be 0, got %d", srv.Port())
|
||||
}
|
||||
|
||||
// We can't Start() because NewFileReader needs a real torrent File
|
||||
// But we can test that Shutdown on an un-started server doesn't panic
|
||||
// Test that Shutdown on an un-started server doesn't panic
|
||||
if err := srv.Shutdown(context.Background()); err != nil {
|
||||
t.Errorf("shutdown of un-started server should not error: %v", err)
|
||||
}
|
||||
|
||||
// Test SetFile/ClearFile
|
||||
srv.SetFile(s, "test-task-id")
|
||||
if !srv.HasFile() {
|
||||
t.Error("HasFile should be true after SetFile")
|
||||
}
|
||||
if srv.CurrentTaskID() != "test-task-id" {
|
||||
t.Errorf("CurrentTaskID = %q, want %q", srv.CurrentTaskID(), "test-task-id")
|
||||
}
|
||||
srv.ClearFile()
|
||||
if srv.HasFile() {
|
||||
t.Error("HasFile should be false after ClearFile")
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -502,10 +502,9 @@ func (d *TorrentDownloader) SaveDhtNodes() {
|
|||
saveDhtNodesBinary(d.client)
|
||||
}
|
||||
|
||||
// StartStream starts an HTTP server for an active torrent download.
|
||||
// It selects the largest video file and serves it via HTTP Range requests.
|
||||
// Returns the running server (caller is responsible for shutdown).
|
||||
func (d *TorrentDownloader) StartStream(taskID string) (*StreamServer, error) {
|
||||
// GetStreamProvider returns a FileProvider for the largest video file in an active torrent.
|
||||
// Used with the persistent StreamServer's SetFile() method.
|
||||
func (d *TorrentDownloader) GetStreamProvider(taskID string) (FileProvider, error) {
|
||||
d.activeMu.Lock()
|
||||
t, ok := d.active[taskID]
|
||||
d.activeMu.Unlock()
|
||||
|
|
@ -535,14 +534,7 @@ func (d *TorrentDownloader) StartStream(taskID string) (*StreamServer, error) {
|
|||
return nil, fmt.Errorf("torrent has no files")
|
||||
}
|
||||
|
||||
srv := NewStreamServerFromFile(video, 0)
|
||||
url, err := srv.Start(context.Background())
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("start stream server: %w", err)
|
||||
}
|
||||
|
||||
log.Printf("[%s] stream started: %s → %s", taskID[:8], filepath.Base(video.DisplayPath()), url)
|
||||
return srv, nil
|
||||
return NewTorrentFileProvider(video), nil
|
||||
}
|
||||
|
||||
// VideoExts is the canonical set of video file extensions used for file selection.
|
||||
|
|
|
|||
|
|
@ -47,7 +47,8 @@ func TestEstimatedProgress_NoFile(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestEstimatedProgress_HalfWay(t *testing.T) {
|
||||
ss := &StreamServer{totalFileSize: 1000}
|
||||
ss := &StreamServer{}
|
||||
ss.totalFileSize.Store(1000)
|
||||
ss.maxByteOffset.Store(500)
|
||||
|
||||
pos, dur := ss.EstimatedProgress()
|
||||
|
|
@ -57,7 +58,8 @@ func TestEstimatedProgress_HalfWay(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestEstimatedProgress_CapsAt100(t *testing.T) {
|
||||
ss := &StreamServer{totalFileSize: 1000}
|
||||
ss := &StreamServer{}
|
||||
ss.totalFileSize.Store(1000)
|
||||
ss.maxByteOffset.Store(1500)
|
||||
|
||||
pos, dur := ss.EstimatedProgress()
|
||||
|
|
@ -71,7 +73,8 @@ func TestEstimatedProgress_CapsAt100(t *testing.T) {
|
|||
// ---------------------------------------------------------------------------
|
||||
|
||||
func TestMaxByteOffsetNeverRegresses(t *testing.T) {
|
||||
ss := &StreamServer{totalFileSize: 10000}
|
||||
ss := &StreamServer{}
|
||||
ss.totalFileSize.Store(10000)
|
||||
|
||||
offsets := []int64{0, 2000, 5000, 3000, 8000, 4000}
|
||||
for _, off := range offsets {
|
||||
|
|
@ -103,14 +106,15 @@ func TestStreamServerRangeTracking(t *testing.T) {
|
|||
t.Fatal(err)
|
||||
}
|
||||
|
||||
srv := NewStreamServerFromDisk(tmpFile, 0)
|
||||
srv := NewStreamServer(0)
|
||||
srv.disableUPnP = true
|
||||
ctx := context.Background()
|
||||
url, err := srv.Start(ctx)
|
||||
if err != nil {
|
||||
t.Fatalf("start: %v", err)
|
||||
if err := srv.Listen(ctx); err != nil {
|
||||
t.Fatalf("listen: %v", err)
|
||||
}
|
||||
defer srv.Shutdown(ctx)
|
||||
srv.SetFile(NewDiskFileProvider(tmpFile), "test-task")
|
||||
url := srv.URL()
|
||||
|
||||
// 1. Non-range GET — maxByteOffset stays 0
|
||||
resp, err := http.Get(url)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue