Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
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)
}