Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

3.7 KB
Raw Blame
package api

import (
	"net/http"

	"github.com/rcourtman/pulse-go-rewrite/internal/config"
)

func (r *Router) handleAgentEvents(w http.ResponseWriter, req *http.Request) {
	r.agentEventBroadcaster.handleAgentEvents(w, req, agentEventTokenRevalidator(r.config, req))
}

// agentEventTokenRevalidator keeps a long-lived token stream bound to its
// admitted credential and organization, not its connection-time snapshot.
// Session withdrawal is checked too. The callback runs on the stream
// goroutine; it never writes an HTTP auth error after streaming has begun.
func agentEventTokenRevalidator(cfg *config.Config, req *http.Request) func() bool {
	revalidate := monitoringTokenSnapshotRevalidator(cfg, req)
	if revalidate == nil {
		// A signed-in user's stream also follows the organization access
		// policy, so lost membership or default access ends it.
		return combineAuthorization(sessionReadRevalidator(req), orgAccessRevalidator(req))
	}
	admittedContext := req.Context()
	return func() bool {
		current, ok := revalidate()
		if !ok {
			return false
		}
		// Replace over the admitted context, never the previous refresh. Only
		// the SSE goroutine owns this request and its disclosure snapshot.
		refreshed := req.WithContext(admittedContext)
		attachAPITokenRecord(refreshed, current)
		*req = *refreshed
		return true
	}
}

// monitoringTokenSnapshotRevalidator is shared by long-lived monitoring reads.
// It returns detached current authority without mutating the admitted request;
// WebSocket writes outlive the HTTP handler and must not race its middleware.
// A nil callback preserves existing session/proxy authentication behaviour.
func monitoringTokenSnapshotRevalidator(cfg *config.Config, req *http.Request) func() (*config.APITokenRecord, bool) {
	return tokenStreamSnapshotRevalidator(cfg, req, config.ScopeMonitoringRead)
}

// tokenStreamSnapshotRevalidator preserves the stream's admitted credential,
// principal and organization while checking its current operation-specific
// scope. Callers must retain any additional route policy (e.g. instance admin).
func tokenStreamSnapshotRevalidator(cfg *config.Config, req *http.Request, scopes ...string) func() (*config.APITokenRecord, bool) {
	admitted := getAPITokenRecordFromRequest(req)
	if admitted == nil {
		return nil
	}
	raw, provided := explicitAPITokenFromRequest(req)
	orgID := GetOrgID(req.Context())
	source, tenantInventory := req.Context().Value(tenantTokenSourceContextKey).(tenantTokenSource)
	tenantInventory = tenantInventory && source.orgID != "" && source.orgID != "default"
	checker := NewAuthorizationChecker(nil)

	return func() (*config.APITokenRecord, bool) {
		if !provided || raw == "" {
			return nil, false
		}
		config.Mu.RLock()
		defer config.Mu.RUnlock()

		live := cfg
		if tenantInventory {
			live = tenantTokenConfigForRequest(req)
			if live == nil {
				return nil, false
			}
		}
		// Reuse authentication's exclusive metadata ownership and detached
		// snapshot. A tenant stream must not fall back to another inventory
		// when its current owner disappears or revokes the credential.
		current, ok := validateAPITokenLocked(live, raw)
		if !ok || (tenantInventory && tenantTokenConfigForRequest(req) != live) {
			return nil, false
		}
		// Keep the route's existing scope alternatives (notably mobile chat)
		// rather than requiring a new grant or pinning one interchangeable scope.
		hasScope := false
		for _, scope := range scopes {
			hasScope = hasScope || current.HasScope(scope)
		}
		if current.ID != admitted.ID || apiTokenAuthenticatedUser(current) != apiTokenAuthenticatedUser(admitted) ||
			!hasScope || !checker.CheckAccess(current, "", orgID).Allowed {
			return nil, false
		}
		return current, true
	}
}