package connection import ( "github.com/cloudflare/cloudflared/edgediscovery" "github.com/cloudflare/cloudflared/h2mux" tunnelpogs "github.com/cloudflare/cloudflared/tunnelrpc/pogs" "github.com/prometheus/client_golang/prometheus" ) const ( DuplicateConnectionError = "EDUPCONN" ) // RegisterTunnel error from client type clientRegisterTunnelError struct { cause error } func newRPCError(cause error, counter *prometheus.CounterVec, name rpcName) clientRegisterTunnelError { counter.WithLabelValues(cause.Error(), string(name)).Inc() return clientRegisterTunnelError{cause: cause} } func (e clientRegisterTunnelError) Error() string { return e.cause.Error() } type DupConnRegisterTunnelError struct{} var errDuplicationConnection = &DupConnRegisterTunnelError{} func (e DupConnRegisterTunnelError) Error() string { return "already connected to this server, trying another address" } // RegisterTunnel error from server type serverRegisterTunnelError struct { cause error permanent bool } func (e serverRegisterTunnelError) Error() string { return e.cause.Error() } func serverRegistrationErrorFromRPC(err error) *serverRegisterTunnelError { if retryable, ok := err.(*tunnelpogs.RetryableError); ok { return &serverRegisterTunnelError{ cause: retryable.Unwrap(), permanent: false, } } return &serverRegisterTunnelError{ cause: err, permanent: true, } } type muxerShutdownError struct{} func (e muxerShutdownError) Error() string { return "muxer shutdown" } func isHandshakeErrRecoverable(err error, connIndex uint8, observer *Observer) bool { switch err.(type) { case edgediscovery.DialError: observer.log.Error().Msgf("Connection %d unable to dial edge: %s", connIndex, err) case h2mux.MuxerHandshakeError: observer.log.Error().Msgf("Connection %d handshake with edge server failed: %s", connIndex, err) default: observer.log.Error().Msgf("Connection %d failed: %s", connIndex, err) return false } return true }