Skip to content

Modern Docker Management, Designed for Everyone

3.5 KB
Raw Blame
package edge

import (
	"strings"
	"time"

	"github.com/samber/mo"
)

const (
	// EdgeTransportAuto prefers gRPC and falls back to WebSocket automatically.
	EdgeTransportAuto = "auto"
	// EdgeTransportWebSocket forces WebSocket tunnel transport.
	EdgeTransportWebSocket = "websocket"
	// EdgeTransportGRPC forces gRPC transport without WebSocket fallback.
	EdgeTransportGRPC = "grpc"
	// EdgeTransportPoll uses an HTTP polling control plane with the existing
	// websocket tunnel as an on-demand data plane.
	EdgeTransportPoll = "poll"

	// EdgeMTLSModeDisabled disables edge tunnel mTLS.
	EdgeMTLSModeDisabled = "disabled"
	// EdgeMTLSModeOptional enables edge tunnel mTLS when certificates are configured.
	EdgeMTLSModeOptional = "optional"
	// EdgeMTLSModeRequired requires a verified client certificate on edge tunnel endpoints
	// when Arcane terminates TLS; external TLS terminators must enforce mTLS before proxying.
	EdgeMTLSModeRequired = "required"
)

// NormalizeEdgeTransport normalizes transport config and defaults to auto-negotiation.
func NormalizeEdgeTransport(value string) string {
	switch strings.ToLower(strings.TrimSpace(value)) {
	case EdgeTransportAuto:
		return EdgeTransportAuto
	case EdgeTransportWebSocket:
		return EdgeTransportWebSocket
	case EdgeTransportGRPC:
		return EdgeTransportGRPC
	case EdgeTransportPoll:
		return EdgeTransportPoll
	default:
		return EdgeTransportAuto
	}
}

// NormalizeEdgeMTLSMode normalizes edge mTLS config and defaults to disabled.
func NormalizeEdgeMTLSMode(value string) string {
	switch strings.ToLower(strings.TrimSpace(value)) {
	case EdgeMTLSModeOptional:
		return EdgeMTLSModeOptional
	case EdgeMTLSModeRequired:
		return EdgeMTLSModeRequired
	default:
		return EdgeMTLSModeDisabled
	}
}

// UseGRPCEdgeTransport reports whether gRPC managed tunnel mode should be attempted.
func UseGRPCEdgeTransport(cfg *Config) bool {
	if cfg == nil {
		return false
	}
	transport := NormalizeEdgeTransport(cfg.EdgeTransport)
	return transport == EdgeTransportGRPC || transport == EdgeTransportAuto
}

// UseWebSocketEdgeTransport reports whether websocket managed tunnel mode is allowed.
func UseWebSocketEdgeTransport(cfg *Config) bool {
	if cfg == nil {
		return false
	}
	transport := NormalizeEdgeTransport(cfg.EdgeTransport)
	return transport == EdgeTransportWebSocket || transport == EdgeTransportAuto
}

// UsePollEdgeTransport reports whether the Portainer-style polling control plane
// should be used.
func UsePollEdgeTransport(cfg *Config) bool {
	if cfg == nil {
		return false
	}
	return NormalizeEdgeTransport(cfg.EdgeTransport) == EdgeTransportPoll
}

// GetTunnelRuntimeState returns live metadata for an active tunnel.
func GetTunnelRuntimeState(envID string) mo.Option[*TunnelRuntimeState] {
	tunnel, ok := GetActiveTunnel(envID).Get()
	if !ok {
		return mo.None[*TunnelRuntimeState]()
	}
	// One snapshot under a single read lock keeps the fields consistent and race-free.
	meta := tunnel.MetadataSnapshot()

	state := &TunnelRuntimeState{
		DataPlane:     EdgeDataPlaneLegacy,
		OpenStreams:   tunnel.openStreams(),
		Transport:     tunnel.Conn.Transport(),
		ConnectedAt:   new(meta.ConnectedAt),
		LastHeartbeat: new(meta.LastHeartbeat),
		SessionID:     meta.SessionID,
		AgentInstance: meta.AgentInstance,
		SecurityMode:  meta.SecurityMode,
		Capabilities:  meta.Capabilities,
		State:         meta.State,
	}
	if tunnel.mux != nil {
		state.DataPlane = EdgeDataPlaneMux
		if rtt := time.Duration(tunnel.mux.rtt.Load()); rtt > 0 {
			state.RoundTripTime = &rtt
		}
	}
	return mo.Some(state)
}