Skip to content

armgit / Piik

Public Imported from GitHub
0

Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。

15.0 KB
Raw Blame
// Package app composes the shared HTTP service, site access, embedded assets,
// media listeners, and startup/shutdown lifecycle for Hosted Server and App.
//
// # Locking
//
// signal.Server owns the one mutex that guards the room store, the media router
// and every session. This package never takes it: everything a request can
// mutate goes through the signaling server. Server.mu below guards only this
// struct's own lifecycle bookkeeping.
//
// The lock order is one-directional: Server.mu may be held while the signaling
// mutex is taken (reconcile calls signal.New under it, and signal.New locks the
// server it is still building), never the reverse. Nothing reachable under the
// signaling mutex may take Server.mu, which is why the one callback this
// package hands to signal, SiteAccessAtUpgrade, only reads the lock-free
// site-access gate. Keep it that way or the two locks can deadlock.
package app

import (
	"context"
	"crypto/tls"
	"errors"
	"fmt"
	"io/fs"
	"log/slog"
	"net"
	"net/http"
	"strconv"
	"sync"
	"sync/atomic"
	"time"

	"github.com/TNTcraftHIM/Piik/internal/diagnostics"
	"github.com/TNTcraftHIM/Piik/internal/media/forwarding"
	"github.com/TNTcraftHIM/Piik/internal/server/config"
	"github.com/TNTcraftHIM/Piik/internal/server/room"
	"github.com/TNTcraftHIM/Piik/internal/server/sfu"
	"github.com/TNTcraftHIM/Piik/internal/server/signal"
	"github.com/TNTcraftHIM/Piik/internal/server/stun"
	"github.com/pion/ice/v4"
	"github.com/pion/webrtc/v4"
)

// HTTP request, header and keep-alive deadlines.
const (
	requestTimeout   = 10 * time.Second
	headersTimeout   = 15 * time.Second
	keepAliveTimeout = 5 * time.Second
)

// Options supplies service configuration and optional lifecycle dependencies.
type Options struct {
	// Config is the loaded server configuration; cmd owns config.Load / Local.
	Config config.Config
	// Listeners transfers prebound HTTP/TLS sockets on successful New. The Local
	// App serves its loopback and LAN entries through the same authority.
	Listeners []net.Listener
	// Assets is the built Browser UI. A nil FS serves the API only.
	Assets fs.FS
	// Now returns Unix milliseconds; nil uses the wall clock.
	Now func() int64
	// Logger receives the request-failure record; nil uses slog.Default().
	Logger *slog.Logger

	AuthenticationTimeoutMs             int
	ViewerDisconnectGraceMs             int
	HeartbeatIntervalMs                 int
	MaxSignalConnections                int
	MaxUnauthenticatedSignalConnections int
	SiteAccessTTLSeconds                int

	// AfterFunc is the signaling timer factory; nil uses time.AfterFunc.
	AfterFunc func(time.Duration, func()) func() bool
	// RoomStore replaces the store this package would build from Config.
	RoomStore *room.Store
}

// Server owns one shared HTTP, room-authority and media service lifecycle.
type Server struct {
	config        config.Config
	store         *room.Store
	siteAccess    *siteAccessGate
	frontend      http.Handler
	logger        *slog.Logger
	media         *sfu.Media
	mediaMux      ice.UDPMux
	sfuPublicIP   atomic.Pointer[string]
	stopSFUDNS    func()
	signalOptions signal.Options
	httpServer    *http.Server
	// Listen binds unless New received owned listeners. Shutdown waits for
	// startupDone before reading them; closing before Listen also releases them.
	listeners []net.Listener
	// STUN shares the same startup/shutdown owner, never the advertised ICE URLs.
	stunServer *stun.Server

	// acceptingTraffic and signaling are read by request goroutines without
	// a lock and written together under mu.
	acceptingTraffic atomic.Bool
	signaling        atomic.Pointer[signal.Server]

	mu               sync.Mutex
	closing          bool
	startupRequested bool
	// startupDone is closed when listen settles, which is what shutdown awaits
	// so the listener stays owned until an in-flight startup finishes.
	startupDone chan struct{}
	serveErr    error
	done        chan error

	shutdownOnce sync.Once
	shutdownErr  error
}

// New composes the service without binding sockets or opening the room database.
func New(options Options) (*Server, error) {
	configuration := options.Config
	now := options.Now
	if now == nil {
		now = func() int64 { return time.Now().UnixMilli() }
	}
	logger := options.Logger
	if logger == nil {
		logger = slog.Default()
	}

	store, err := newRoomStore(options)
	if err != nil {
		return nil, err
	}

	siteAccess, err := newSiteAccess(siteAccessOptions{
		Password: configuration.SiteAccessPassword,
		Secure: configuration.Env == config.EnvironmentProduction &&
			configuration.PublicBaseURL.Scheme == "https",
		Now:        now,
		TTLSeconds: options.SiteAccessTTLSeconds,
	})
	if err != nil {
		return nil, err
	}

	server := &Server{
		config:      configuration,
		store:       store,
		siteAccess:  siteAccess,
		logger:      logger,
		startupDone: make(chan struct{}),
		done:        make(chan error, 1),
	}
	server.listeners = append([]net.Listener(nil), options.Listeners...)
	if options.Assets != nil {
		server.frontend = staticHandler(options.Assets, http.HandlerFunc(notFoundJSON))
	}
	server.signalOptions = signal.Options{
		Store:                     store,
		EndpointMediaCopyCapacity: configuration.EndpointMediaCopyCapacity,
		SfuOnly:                   configuration.SFU != nil && configuration.SFU.Only,
		Ice:                       config.IceConfig(configuration),
		// The prediction capability is separate from the wire-shaped ICE settings.
		NATPredictionEnabled: configuration.NATPredictionEnabled,
		AllowedOrigins:       configuration.AllowedOrigins,
		SiteAccessAtUpgrade: func(request *http.Request) bool {
			return server.siteAccessForRequest(request).isAuthenticated(cookieHeader(request))
		},
		PublicBaseURL:                 configuration.PublicBaseURL,
		Now:                           now,
		AuthenticationTimeoutMs:       options.AuthenticationTimeoutMs,
		ViewerDisconnectGraceMs:       options.ViewerDisconnectGraceMs,
		HeartbeatIntervalMs:           options.HeartbeatIntervalMs,
		RoomEmptyTimeoutMs:            int64(configuration.RoomEmptyTimeoutSeconds) * 1_000,
		MaxConnections:                options.MaxSignalConnections,
		MaxUnauthenticatedConnections: options.MaxUnauthenticatedSignalConnections,
		AfterFunc:                     options.AfterFunc,
		Logger:                        logger,
	}
	server.httpServer = &http.Server{
		Handler:           server,
		ErrorLog:          slog.NewLogLogger(logger.Handler(), slog.LevelDebug),
		ReadHeaderTimeout: headersTimeout,
		ReadTimeout:       requestTimeout,
		IdleTimeout:       keepAliveTimeout,
		// No WriteTimeout: a fixed deadline would cut long asset downloads.
	}
	return server, nil
}

// newRoomStore uses the injected store or creates one from configuration.
// An empty RoomDatabasePath selects memory-only authority.
func newRoomStore(options Options) (*room.Store, error) {
	if options.RoomStore != nil {
		return options.RoomStore, nil
	}
	var database *room.Database
	if options.Config.RoomDatabasePath != "" {
		// The file is opened by store.Initialize, not here: a failed bind must
		// leave no database behind.
		opened, err := room.NewDatabase(options.Config.RoomDatabasePath)
		if err != nil {
			return nil, err
		}
		database = opened
	}
	return room.New(room.Options{
		MaxRooms:          room.Capacity,
		MaxViewersPerRoom: options.Config.MaxViewersPerRoom,
		Database:          database,
		Now:               options.Now,
	})
}

// Done reports the first unexpected HTTP listener failure. Normal Close/End
// leave it silent; owners also observe their own cancellation/lifetime signal.
func (s *Server) Done() <-chan error { return s.done }

// Listen binds application sockets before recovering room authority and accepting traffic.
func (s *Server) Listen(ctx context.Context) (int, error) {
	s.mu.Lock()
	if s.startupRequested {
		s.mu.Unlock()
		return 0, errors.New("Piik server startup was already requested")
	}
	if s.closing {
		s.mu.Unlock()
		return 0, errors.New("Piik server is closing")
	}
	s.startupRequested = true
	s.mu.Unlock()

	// Release the startup latch even when start panics, so a later Close
	// cannot wait forever for startup to finish.
	defer close(s.startupDone)
	return s.start(ctx)
}

func (s *Server) start(ctx context.Context) (int, error) {
	if s.config.SFU != nil {
		publicIP, err := resolveSFUPublicIP(ctx, s.config.SFU.PublicIP)
		if err != nil {
			_ = s.stopServing(ctx)
			return 0, err
		}
		s.sfuPublicIP.Store(&publicIP)
	}
	// Bind first. A listener owned by another process must fail before
	// the room database is opened.
	var err error
	if len(s.listeners) == 0 {
		address := net.JoinHostPort(s.config.ListenHost, strconv.Itoa(s.config.Port))
		listener, err := net.Listen("tcp", address)
		if err != nil {
			return 0, err
		}
		if s.config.TLS != nil {
			listener = tls.NewListener(listener, s.config.TLS)
		}
		s.listeners = []net.Listener{listener}
	}
	if len(s.config.STUNListenAddresses) > 0 {
		s.stunServer, err = stun.Listen(ctx, s.config.STUNListenAddresses)
		if err != nil {
			for _, listener := range s.listeners {
				_ = listener.Close()
			}
			return 0, fmt.Errorf("Piik STUN listener failed: %w", err)
		}
	}
	if configuration := s.config.SFU; configuration != nil {
		connection, listenErr := net.ListenPacket("udp4", net.JoinHostPort(configuration.ListenHost, strconv.Itoa(configuration.Port)))
		if listenErr != nil {
			_ = s.stopServing(ctx)
			return 0, fmt.Errorf("Piik SFU listener failed: %w", listenErr)
		}
		factory := diagnostics.PionLoggerFactory()
		s.mediaMux = forwarding.NewUDPMux(ice.UDPMuxParams{UDPConn: connection, Logger: factory.NewLogger("sfu-udp")})
		settings := webrtc.SettingEngine{LoggerFactory: factory}
		settings.SetNetworkTypes([]webrtc.NetworkType{webrtc.NetworkTypeUDP4})
		settings.SetICEUDPMux(s.mediaMux)
		settings.SetIncludeLoopbackCandidate(net.ParseIP(configuration.ListenHost).IsLoopback())
		s.media = sfu.NewMedia(sfu.MediaOptions{Settings: func() webrtc.SettingEngine {
			// A Pion API owns its settings snapshot for its entire lifetime.
			snapshot := settings
			if address := *s.sfuPublicIP.Load(); address != "" {
				snapshot.SetNAT1To1IPs([]string{address}, webrtc.ICECandidateTypeHost)
			}
			return snapshot
		}, Events: func(event sfu.MediaEvent) {
			if signaling := s.signaling.Load(); signaling != nil {
				signaling.HandleSfuMediaEvent(event)
			}
		}})
		s.signalOptions.SfuFallback = &signal.SfuFallback{Media: s.media, Admission: sfu.NewAdmission(sfu.AdmissionOptions{
			IngressCapacity: room.Capacity, EgressCapacity: room.Capacity * s.config.MaxViewersPerRoom,
		})}
		s.startSFUDNSRefresh(configuration.PublicIP)
	}
	for _, listener := range s.listeners {
		go func() {
			// Report permanent accept failures so an unexpectedly stopped HTTP
			// listener is visible to the operator.
			if err := s.httpServer.Serve(listener); !errors.Is(err, http.ErrServerClosed) {
				s.mu.Lock()
				if !s.closing && s.serveErr == nil {
					s.serveErr = fmt.Errorf("Piik HTTP listener stopped unexpectedly: %w", err)
					s.acceptingTraffic.Store(false)
					s.done <- s.serveErr
				}
				s.mu.Unlock()
				s.logger.Error("Piik HTTP server stopped unexpectedly", "errorType", fmt.Sprintf("%T", err))
				s.logger.Debug("http-listener-failed", diagnostics.Error(err))
			}
		}()
	}
	port := s.listeners[0].Addr().(*net.TCPAddr).Port

	if err := s.reconcile(); err != nil {
		// Give the database and the listener back before reporting.
		var cleanup []error
		if closeErr := s.store.Close(); closeErr != nil {
			cleanup = append(cleanup, closeErr)
		}
		if closeErr := s.stopServing(ctx); closeErr != nil {
			cleanup = append(cleanup, closeErr)
		}
		if len(cleanup) > 0 {
			return 0, fmt.Errorf("Piik startup reconciliation failed: %w",
				errors.Join(append([]error{err}, cleanup...)...))
		}
		return 0, err
	}
	return port, nil
}

// stopServing releases the application-owned HTTP and STUN sockets. Shutdown
// stops accepting HTTP and drains, but it can lose the race against the Serve
// goroutine registering the listener, in
// which case it returns without having closed the bound socket; closing the
// listener afterwards makes the port release synchronous. A second close of an
// already closed HTTP listener is harmless.
func (s *Server) stopServing(ctx context.Context) error {
	if s.stopSFUDNS != nil {
		s.stopSFUDNS()
		s.stopSFUDNS = nil
	}
	err := s.httpServer.Shutdown(ctx)
	for _, listener := range s.listeners {
		_ = listener.Close()
	}
	if s.stunServer != nil {
		err = errors.Join(err, s.stunServer.Close())
		s.stunServer = nil
	}
	if s.media != nil {
		err = errors.Join(err, s.media.Close())
		s.media = nil
	}
	if s.mediaMux != nil {
		err = errors.Join(err, s.mediaMux.Close())
		s.mediaMux = nil
	}
	return err
}

// reconcile restores room authority and enables traffic unless shutdown has begun.
func (s *Server) reconcile() error {
	if err := s.store.Initialize(); err != nil {
		return err
	}
	// Serialize publication with shutdown; once closing is set, startup must
	// never re-enable traffic.
	s.mu.Lock()
	defer s.mu.Unlock()
	if s.closing {
		return nil
	}
	if s.serveErr != nil {
		return s.serveErr
	}
	signaling, err := signal.New(s.signalOptions)
	if err != nil {
		return err
	}
	s.signaling.Store(signaling)
	s.acceptingTraffic.Store(true)
	return nil
}

// Close stops accepting traffic, closes signaling, the HTTP/STUN listeners and
// the room store, and leaves the rooms in place. Hosted restarts use it.
func (s *Server) Close(ctx context.Context) error {
	return s.shutdown(ctx, false)
}

// End is Close preceded by ending every room. The Local App uses it, because its
// authority dies with the process.
func (s *Server) End(ctx context.Context) error {
	return s.shutdown(ctx, true)
}

// Every shutdown caller joins the first operation and receives the same result.
func (s *Server) shutdown(ctx context.Context, endRooms bool) error {
	s.shutdownOnce.Do(func() { s.shutdownErr = s.runShutdown(ctx, endRooms) })
	return s.shutdownErr
}

func (s *Server) runShutdown(ctx context.Context, endRooms bool) error {
	// Stop traffic, mark closing, then wait for an in-flight startup.
	s.mu.Lock()
	s.acceptingTraffic.Store(false)
	s.closing = true
	awaitStartup := s.startupRequested
	s.mu.Unlock()
	if awaitStartup {
		// The listen caller owns the startup error; shutdown only waits.
		<-s.startupDone
	}

	var failures []error
	signaling := s.signaling.Load()
	if endRooms {
		failures = append(failures, s.endAllRooms(signaling))
	}
	if signaling != nil {
		failures = append(failures, signaling.Close(ctx))
	}
	// The signaling server must be closed before the listener: its connections
	// live on it.
	failures = append(failures, s.stopServing(ctx))
	if signaling != nil {
		failures = append(failures, signaling.CloseStorage())
	} else {
		failures = append(failures, s.store.Close())
	}
	if joined := errors.Join(failures...); joined != nil {
		return fmt.Errorf("Piik server shutdown failed: %w", joined)
	}
	return nil
}

// Without signaling no participant is connected, so room authority can be
// retired directly; otherwise signaling owns participant and media teardown.
func (s *Server) endAllRooms(signaling *signal.Server) error {
	if signaling != nil {
		return signaling.EndAllRooms()
	}
	_, err := s.store.AbandonAllRooms()
	return err
}