607 lines
25 KiB
Go
607 lines
25 KiB
Go
package config
|
||
|
||
import (
|
||
"errors"
|
||
"fmt"
|
||
"regexp"
|
||
"slices"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/centrifugal/centrifugo/v6/internal/configtypes"
|
||
"github.com/centrifugal/centrifugo/v6/internal/tools"
|
||
|
||
"github.com/centrifugal/centrifuge"
|
||
)
|
||
|
||
var knownBrokers = []string{"memory", "nats", "redis", "redisnats", "postgres"}
|
||
|
||
// Validate validates config and returns error if problems found.
|
||
func (c Config) Validate() error {
|
||
if c.HTTP.H2CExternal && (c.HTTP.InternalPort == "" || strconv.Itoa(c.HTTP.Port) == c.HTTP.InternalPort) {
|
||
return fmt.Errorf("external_h2c requires custom separate internal_port to be configured")
|
||
}
|
||
if c.HTTP.TLS.Enabled && c.HTTP.H2CExternal {
|
||
return fmt.Errorf("external_h2c cannot be used together with enabled TLS for external HTTP server")
|
||
}
|
||
|
||
if !slices.Contains(knownBrokers, c.Broker.Type) {
|
||
return fmt.Errorf("unknown broker: %s", c.Broker.Type)
|
||
}
|
||
|
||
if err := validateTokens(c); err != nil {
|
||
return err
|
||
}
|
||
|
||
if c.Client.Proxy.Connect.Enabled {
|
||
if err := validateProxy("default", c.Client.Proxy.Connect.Proxy); err != nil {
|
||
return fmt.Errorf("in client.proxy.connect: %v", err)
|
||
}
|
||
}
|
||
if c.Client.Proxy.Refresh.Enabled {
|
||
if err := validateProxy("default", c.Client.Proxy.Refresh.Proxy); err != nil {
|
||
return fmt.Errorf("in client.proxy.refresh: %v", err)
|
||
}
|
||
}
|
||
|
||
if err := validateSecondPrecisionDuration(c.Channel.HistoryMetaTTL); err != nil {
|
||
return fmt.Errorf("in channel.history_meta_ttl: %v", err)
|
||
}
|
||
|
||
if !slices.Contains([]string{"", configtypes.PublicationDataFormatJSON, configtypes.PublicationDataFormatJSONObject, configtypes.PublicationDataFormatBinary}, c.Channel.PublicationDataFormat) {
|
||
return fmt.Errorf("unknown channel.publication_data_format: \"%s\"", c.Channel.PublicationDataFormat)
|
||
}
|
||
|
||
if err := validateCodeToUniDisconnectTransforms(c.Client.ConnectCodeToUnidirectionalDisconnect.Transforms); err != nil {
|
||
return fmt.Errorf("in client.connect_code_to_unidirectional_disconnect: %v", err)
|
||
}
|
||
|
||
var proxyNames []string
|
||
for _, p := range c.Proxies {
|
||
if slices.Contains(proxyNames, p.Name) {
|
||
return fmt.Errorf("duplicate proxy name in proxies: %s", p.Name)
|
||
}
|
||
if err := validateProxy(p.Name, p.Proxy); err != nil {
|
||
return fmt.Errorf("in proxy %s: %v", p.Name, err)
|
||
}
|
||
proxyNames = append(proxyNames, p.Name)
|
||
}
|
||
if slices.Contains(proxyNames, DefaultProxyName) {
|
||
return fmt.Errorf("proxy name %s is reserved", DefaultProxyName)
|
||
}
|
||
proxyNames = append(proxyNames, DefaultProxyName) // channel options can use default proxy name.
|
||
|
||
if err := validateChannelOptions(c.Channel.WithoutNamespace, c.Channel.HistoryMetaTTL, proxyNames, c); err != nil {
|
||
return fmt.Errorf("in channel.without_namespace: %v", err)
|
||
}
|
||
|
||
if err := validateRpcOptions(c.RPC.WithoutNamespace, proxyNames); err != nil {
|
||
return fmt.Errorf("in rpc.without_namespace: %v", err)
|
||
}
|
||
|
||
usePersonalChannel := c.Client.SubscribeToUserPersonalChannel.Enabled
|
||
personalChannelNamespace := c.Client.SubscribeToUserPersonalChannel.PersonalChannelNamespace
|
||
personalSingleConnection := c.Client.SubscribeToUserPersonalChannel.SingleConnection
|
||
var validPersonalChannelNamespace bool
|
||
if !usePersonalChannel || personalChannelNamespace == "" {
|
||
validPersonalChannelNamespace = true
|
||
if personalSingleConnection && !c.Channel.WithoutNamespace.Presence {
|
||
return fmt.Errorf("presence must be enabled on top level to maintain single connection")
|
||
}
|
||
}
|
||
|
||
nss := make([]string, 0, len(c.Channel.Namespaces))
|
||
for _, n := range c.Channel.Namespaces {
|
||
if slices.Contains(nss, n.Name) {
|
||
return fmt.Errorf("namespace name must be unique: %s", n.Name)
|
||
}
|
||
if err := validateNamespace(n, c.Channel.HistoryMetaTTL, proxyNames, c); err != nil {
|
||
return fmt.Errorf("namespace %s: %v", n.Name, err)
|
||
}
|
||
if n.Name == personalChannelNamespace {
|
||
validPersonalChannelNamespace = true
|
||
if personalSingleConnection && !n.Presence {
|
||
return fmt.Errorf("presence must be enabled for namespace %s to maintain single connection", n.Name)
|
||
}
|
||
}
|
||
nss = append(nss, n.Name)
|
||
}
|
||
|
||
if !validPersonalChannelNamespace {
|
||
return fmt.Errorf("namespace for user personal channel not found: %s", personalChannelNamespace)
|
||
}
|
||
|
||
// Validate that map presence channel prefix references point to existing namespaces with map type.
|
||
boundary := c.Channel.NamespaceBoundary
|
||
if boundary == "" {
|
||
boundary = ":"
|
||
}
|
||
for _, n := range c.Channel.Namespaces {
|
||
if n.MapClientsPresenceChannelPrefix != "" {
|
||
targetNs := strings.SplitN(n.MapClientsPresenceChannelPrefix+"x", boundary, 2)[0]
|
||
if !slices.Contains(nss, targetNs) {
|
||
return fmt.Errorf("namespace %s: map_clients_presence_channel_prefix %q resolves to namespace %q which does not exist", n.Name, n.MapClientsPresenceChannelPrefix, targetNs)
|
||
}
|
||
}
|
||
if n.MapUsersPresenceChannelPrefix != "" {
|
||
targetNs := strings.SplitN(n.MapUsersPresenceChannelPrefix+"x", boundary, 2)[0]
|
||
if !slices.Contains(nss, targetNs) {
|
||
return fmt.Errorf("namespace %s: map_users_presence_channel_prefix %q resolves to namespace %q which does not exist", n.Name, n.MapUsersPresenceChannelPrefix, targetNs)
|
||
}
|
||
}
|
||
}
|
||
|
||
rpcNss := make([]string, 0, len(c.RPC.Namespaces))
|
||
for _, n := range c.RPC.Namespaces {
|
||
if slices.Contains(rpcNss, n.Name) {
|
||
return fmt.Errorf("rpc namespace name must be unique: %s", n.Name)
|
||
}
|
||
if err := validateRpcNamespace(n, proxyNames); err != nil {
|
||
return fmt.Errorf("rpc namespace %s: %v", n.Name, err)
|
||
}
|
||
rpcNss = append(rpcNss, n.Name)
|
||
}
|
||
|
||
var consumerNames []string
|
||
for _, config := range c.Consumers {
|
||
if !consumerNameRe.Match([]byte(config.Name)) {
|
||
return fmt.Errorf("invalid consumer name: %s, must match %s regular expression", config.Name, consumerNamePattern)
|
||
}
|
||
if slices.Contains(consumerNames, config.Name) {
|
||
return fmt.Errorf("invalid consumer name: %s, must be unique", config.Name)
|
||
}
|
||
if !slices.Contains(configtypes.KnownConsumerTypes, config.Type) {
|
||
return fmt.Errorf("unknown consumer type: %s", config.Type)
|
||
}
|
||
if config.Enabled {
|
||
var err error
|
||
switch config.Type {
|
||
case configtypes.ConsumerTypeKafka:
|
||
err = config.Kafka.Validate()
|
||
case configtypes.ConsumerTypePostgres:
|
||
err = config.Postgres.Validate()
|
||
case configtypes.ConsumerTypeGooglePubSub:
|
||
err = config.GooglePubSub.Validate()
|
||
case configtypes.ConsumerTypeRedisStream:
|
||
err = config.RedisStream.Validate()
|
||
case configtypes.ConsumerTypeNatsJetStream:
|
||
err = config.NatsJetStream.Validate()
|
||
case configtypes.ConsumerTypeAwsSqs:
|
||
err = config.AwsSqs.Validate()
|
||
case configtypes.ConsumerTypeAzureServiceBus:
|
||
err = config.AzureServiceBus.Validate()
|
||
default:
|
||
}
|
||
if err != nil {
|
||
return fmt.Errorf("in consumer %s (%s): %w", config.Name, config.Type, err)
|
||
}
|
||
}
|
||
consumerNames = append(consumerNames, config.Name)
|
||
}
|
||
|
||
if err := validateConnectCodeTransforms(c.UniSSE.ConnectCodeToHTTPResponse.Transforms); err != nil {
|
||
return fmt.Errorf("in uni_sse.connect_code_to_http_response.transforms: %v", err)
|
||
}
|
||
if err := validateConnectCodeTransforms(c.UniHTTPStream.ConnectCodeToHTTPResponse.Transforms); err != nil {
|
||
return fmt.Errorf("in uni_http_stream.connect_code_to_http_response.transforms: %v", err)
|
||
}
|
||
|
||
// Map broker validation.
|
||
var knownMapBrokers = []string{"memory", "redis", "postgres"}
|
||
if !slices.Contains(knownMapBrokers, c.MapBroker.Type) {
|
||
return fmt.Errorf("unknown map broker type: %s", c.MapBroker.Type)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
var namePattern = "^[-a-zA-Z0-9_.]{2,}$"
|
||
var nameRe = regexp.MustCompile(namePattern)
|
||
|
||
func validateNamespace(ns configtypes.ChannelNamespace, globalHistoryMetaTTL configtypes.Duration, proxyNames []string, cfg Config) error {
|
||
name := ns.Name
|
||
match := nameRe.MatchString(name)
|
||
if !match {
|
||
return fmt.Errorf("invalid namespace name – %s (must match %s regular expression)", name, namePattern)
|
||
}
|
||
if err := validateChannelOptions(ns.ChannelOptions, globalHistoryMetaTTL, proxyNames, cfg); err != nil {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func validateRpcNamespace(ns configtypes.RpcNamespace, rpcProxyNames []string) error {
|
||
name := ns.Name
|
||
match := nameRe.MatchString(name)
|
||
if !match {
|
||
return fmt.Errorf("invalid rpc namespace name – %s (must match %s regular expression)", name, namePattern)
|
||
}
|
||
if err := validateRpcOptions(ns.RpcOptions, rpcProxyNames); err != nil {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func validateChannelOptions(c configtypes.ChannelOptions, globalHistoryMetaTTL configtypes.Duration, proxyNames []string, cfg Config) error {
|
||
if err := validateSecondPrecisionDuration(c.HistoryTTL); err != nil {
|
||
return fmt.Errorf("in history_ttl: %v", err)
|
||
}
|
||
if err := validateSecondPrecisionDuration(c.HistoryMetaTTL); err != nil {
|
||
return fmt.Errorf("in history_meta_ttl: %v", err)
|
||
}
|
||
if (c.HistorySize != 0 && c.HistoryTTL == 0) || (c.HistorySize == 0 && c.HistoryTTL != 0) {
|
||
return errors.New("both history size and history ttl required for history")
|
||
}
|
||
historyMetaTTL := globalHistoryMetaTTL
|
||
if c.HistoryMetaTTL != 0 {
|
||
historyMetaTTL = c.HistoryMetaTTL
|
||
}
|
||
if historyMetaTTL < c.HistoryTTL {
|
||
return fmt.Errorf("history ttl (%s) can not be greater than history meta ttl (%s)", c.HistoryTTL, historyMetaTTL)
|
||
}
|
||
if c.ForceRecovery && (c.HistorySize == 0 || c.HistoryTTL == 0) {
|
||
return errors.New("both history size and history ttl required for recovery")
|
||
}
|
||
if c.AutoCacheRecover && (!c.ForceRecovery || c.ForceRecoveryMode != "cache") {
|
||
return errors.New("auto_cache_recover requires force_recovery and force_recovery_mode set to cache")
|
||
}
|
||
if c.ChannelRegex != "" {
|
||
if _, err := regexp.Compile(c.ChannelRegex); err != nil {
|
||
return fmt.Errorf("invalid channel regex %s: %w", c.ChannelRegex, err)
|
||
}
|
||
}
|
||
if (c.SubscribeStreamProxyEnabled) && (c.SubscribeProxyEnabled || c.PublishProxyEnabled || c.SubRefreshProxyEnabled) {
|
||
return fmt.Errorf("can't use subscribe stream proxy together with subscribe, publish or sub refresh proxies")
|
||
}
|
||
if len(c.AllowedDeltaTypes) > 0 {
|
||
for _, dt := range c.AllowedDeltaTypes {
|
||
if !slices.Contains([]centrifuge.DeltaType{centrifuge.DeltaTypeFossil}, dt) {
|
||
return fmt.Errorf("unknown allowed delta type: \"%s\"", dt)
|
||
}
|
||
}
|
||
}
|
||
if !slices.Contains([]string{"", "stream", "cache"}, c.ForceRecoveryMode) {
|
||
return fmt.Errorf("unknown recovery mode: \"%s\"", c.ForceRecoveryMode)
|
||
}
|
||
|
||
if !slices.Contains([]string{"", configtypes.PublicationDataFormatJSON, configtypes.PublicationDataFormatJSONObject, configtypes.PublicationDataFormatBinary}, c.PublicationDataFormat) {
|
||
return fmt.Errorf("unknown publication_data_format: \"%s\"", c.PublicationDataFormat)
|
||
}
|
||
|
||
if c.SubscribeProxyName != "" && !slices.Contains(proxyNames, c.SubscribeProxyName) {
|
||
return fmt.Errorf("subscribe proxy with name \"%s\" not found", c.SubscribeProxyName)
|
||
}
|
||
if c.SubscribeProxyEnabled && c.SubscribeProxyName == DefaultProxyName {
|
||
if err := validateProxy("default", cfg.Channel.Proxy.Subscribe); err != nil {
|
||
return fmt.Errorf("in channel.proxy.subscribe: %v", err)
|
||
}
|
||
}
|
||
|
||
if c.PublishProxyName != "" && !slices.Contains(proxyNames, c.PublishProxyName) {
|
||
return fmt.Errorf("publish proxy with name \"%s\" not found", c.PublishProxyName)
|
||
}
|
||
if c.PublishProxyEnabled && c.PublishProxyName == DefaultProxyName {
|
||
if err := validateProxy("default", cfg.Channel.Proxy.Publish); err != nil {
|
||
return fmt.Errorf("in channel.proxy.publish: %v", err)
|
||
}
|
||
}
|
||
|
||
if c.SubRefreshProxyName != "" && !slices.Contains(proxyNames, c.SubRefreshProxyName) {
|
||
return fmt.Errorf("sub refresh proxy with name \"%s\" not found", c.SubRefreshProxyName)
|
||
}
|
||
if c.SubRefreshProxyEnabled && c.SubRefreshProxyName == DefaultProxyName {
|
||
if err := validateProxy("default", cfg.Channel.Proxy.SubRefresh); err != nil {
|
||
return fmt.Errorf("in channel.proxy.sub_refresh: %v", err)
|
||
}
|
||
}
|
||
|
||
if c.SubscribeStreamProxyName != "" && !slices.Contains(proxyNames, c.SubscribeStreamProxyName) {
|
||
return fmt.Errorf("subscribe stream proxy with name \"%s\" not found", c.SubscribeStreamProxyName)
|
||
}
|
||
if c.SubscribeStreamProxyEnabled && c.SubscribeStreamProxyName == DefaultProxyName {
|
||
if err := validateProxy("default", cfg.Channel.Proxy.SubscribeStream); err != nil {
|
||
return fmt.Errorf("in channel.proxy.subscribe_stream: %v", err)
|
||
}
|
||
}
|
||
|
||
if c.Map.PublishProxyName != "" && !slices.Contains(proxyNames, c.Map.PublishProxyName) {
|
||
return fmt.Errorf("map publish proxy with name \"%s\" not found", c.Map.PublishProxyName)
|
||
}
|
||
if c.Map.PublishProxyEnabled && c.Map.PublishProxyName == DefaultProxyName {
|
||
if err := validateProxy("default", cfg.Channel.Proxy.MapPublish); err != nil {
|
||
return fmt.Errorf("in channel.proxy.map_publish: %v", err)
|
||
}
|
||
}
|
||
|
||
if c.Map.RemoveProxyName != "" && !slices.Contains(proxyNames, c.Map.RemoveProxyName) {
|
||
return fmt.Errorf("map remove proxy with name \"%s\" not found", c.Map.RemoveProxyName)
|
||
}
|
||
if c.Map.RemoveProxyEnabled && c.Map.RemoveProxyName == DefaultProxyName {
|
||
if err := validateProxy("default", cfg.Channel.Proxy.MapRemove); err != nil {
|
||
return fmt.Errorf("in channel.proxy.map_remove: %v", err)
|
||
}
|
||
}
|
||
|
||
if c.Map.ClientKey != "" && !slices.Contains([]string{"client_id", "user_id"}, c.Map.ClientKey) {
|
||
return fmt.Errorf("unknown map.client_key: %q (valid: \"client_id\", \"user_id\")", c.Map.ClientKey)
|
||
}
|
||
// map.client_key and the publish/remove proxy both decide the final key.
|
||
// When a proxy is configured, it is solely responsible for keying (it may
|
||
// echo the client's key or override). Allowing both at once silently lets
|
||
// the proxy win over client_key, which surprises users who expect
|
||
// client_key to force the keying. Reject the combination at config-load,
|
||
// naming the actually-conflicting proxy field.
|
||
if c.Map.ClientKey != "" && c.Map.PublishProxyEnabled {
|
||
return fmt.Errorf("map.client_key is not compatible with map.publish_proxy_enabled: the proxy is responsible for keying when enabled")
|
||
}
|
||
if c.Map.ClientKey != "" && c.Map.RemoveProxyEnabled {
|
||
return fmt.Errorf("map.client_key is not compatible with map.remove_proxy_enabled: the proxy is responsible for keying when enabled")
|
||
}
|
||
|
||
if c.SubscriptionType != "" && !slices.Contains([]string{"stream", "map", "map_clients", "map_users", "shared_poll"}, c.SubscriptionType) {
|
||
return fmt.Errorf("unknown subscription_type: %q", c.SubscriptionType)
|
||
}
|
||
if c.SubscriptionType == "shared_poll" {
|
||
if cfg.SharedPoll.HMACSecretKey == "" {
|
||
return fmt.Errorf("shared_poll.hmac_secret_key is required when subscription_type is \"shared_poll\"")
|
||
}
|
||
if c.SharedPoll.ProxyName != "" && !slices.Contains(proxyNames, c.SharedPoll.ProxyName) {
|
||
return fmt.Errorf("shared poll proxy with name %q not found", c.SharedPoll.ProxyName)
|
||
}
|
||
sharedPollProxyName := c.SharedPoll.ProxyName
|
||
if sharedPollProxyName == "" {
|
||
sharedPollProxyName = DefaultProxyName
|
||
}
|
||
if sharedPollProxyName == DefaultProxyName {
|
||
if err := validateProxy("default", cfg.Channel.Proxy.SharedPollRefresh); err != nil {
|
||
return fmt.Errorf("in channel.proxy.shared_poll_refresh: %v", err)
|
||
}
|
||
}
|
||
if !slices.Contains([]string{"", "versionless", "versioned"}, c.SharedPoll.Mode) {
|
||
return fmt.Errorf("invalid shared_poll mode: %q", c.SharedPoll.Mode)
|
||
}
|
||
if c.SharedPoll.PublishEnabled && (c.SharedPoll.Mode == "" || c.SharedPoll.Mode == "versionless") {
|
||
return fmt.Errorf("shared_poll publish_enabled is incompatible with versionless mode (requires explicit versions)")
|
||
}
|
||
}
|
||
if c.Map.Mode != "" && !slices.Contains([]string{"ephemeral", "recoverable", "persistent"}, c.Map.Mode) {
|
||
return fmt.Errorf("unknown map.mode: %q (valid: \"ephemeral\", \"recoverable\", \"persistent\")", c.Map.Mode)
|
||
}
|
||
hasMapType := c.SubscriptionType == "map" || c.SubscriptionType == "map_clients" || c.SubscriptionType == "map_users"
|
||
if hasMapType {
|
||
if c.Map.Mode == "" {
|
||
return fmt.Errorf("map.mode is required when subscription_type is a map type")
|
||
}
|
||
}
|
||
mapHasExpiry := c.Map.Mode == "ephemeral" || c.Map.Mode == "recoverable"
|
||
if mapHasExpiry {
|
||
if c.Map.KeyTTL == 0 {
|
||
return fmt.Errorf("map.key_ttl is required when map.mode is %q", c.Map.Mode)
|
||
}
|
||
if c.Map.KeyTTL.ToDuration() < 0 {
|
||
return fmt.Errorf("map.key_ttl must be positive")
|
||
}
|
||
}
|
||
if c.Map.Mode == "persistent" && c.Map.KeyTTL != 0 {
|
||
return fmt.Errorf("map.key_ttl must not be set when map.mode is \"persistent\" (entries don't expire)")
|
||
}
|
||
// map_clients and map_users rely on TTL as the cleanup fallback: map_clients
|
||
// uses MapRemove on disconnect with TTL as the safety net for transient
|
||
// remove failures; map_users is *only* cleaned up by TTL (no remove on
|
||
// disconnect by design). Persistent mode disables TTL, which means stale
|
||
// presence entries can linger indefinitely. Refuse the combination.
|
||
if c.Map.Mode == "persistent" && (c.SubscriptionType == "map_clients" || c.SubscriptionType == "map_users") {
|
||
return fmt.Errorf("map.mode %q is not allowed with subscription_type %q (presence entries require TTL-based cleanup; use \"ephemeral\" or \"recoverable\")", c.Map.Mode, c.SubscriptionType)
|
||
}
|
||
if c.Map.Mode == "ephemeral" {
|
||
if c.Map.StreamSize > 0 {
|
||
return fmt.Errorf("map.stream_size must be 0 for map.mode \"ephemeral\"")
|
||
}
|
||
if c.Map.StreamTTL != 0 {
|
||
return fmt.Errorf("map.stream_ttl must be 0 for map.mode \"ephemeral\"")
|
||
}
|
||
if c.Map.MetaTTL != 0 {
|
||
return fmt.Errorf("map.meta_ttl must be 0 for map.mode \"ephemeral\"")
|
||
}
|
||
}
|
||
mapHasStream := c.Map.Mode == "recoverable" || c.Map.Mode == "persistent"
|
||
if mapHasStream {
|
||
if c.Map.StreamSize < 0 {
|
||
return fmt.Errorf("map.stream_size must be non-negative")
|
||
}
|
||
if c.Map.StreamTTL.ToDuration() < 0 {
|
||
return fmt.Errorf("map.stream_ttl must be non-negative")
|
||
}
|
||
if c.Map.MetaTTL.ToDuration() < 0 {
|
||
return fmt.Errorf("map.meta_ttl must be non-negative")
|
||
}
|
||
if c.Map.MetaTTL != 0 {
|
||
effectiveStreamTTL := c.Map.StreamTTL.ToDuration()
|
||
if effectiveStreamTTL == 0 {
|
||
effectiveStreamTTL = time.Minute
|
||
}
|
||
if c.Map.MetaTTL.ToDuration() < effectiveStreamTTL {
|
||
return fmt.Errorf("map.meta_ttl (%s) must be >= map.stream_ttl (%s) (metadata must outlive stream)", c.Map.MetaTTL, configtypes.Duration(effectiveStreamTTL))
|
||
}
|
||
}
|
||
}
|
||
if c.Map.RemoveClientOnUnsubscribe && !hasMapType {
|
||
return fmt.Errorf("map.remove_client_on_unsubscribe requires subscription_type to be a map type")
|
||
}
|
||
|
||
// Map presence prefixes must resolve to a namespace whose subscription_type
|
||
// is the matching map-presence flavour. Otherwise publishes to those
|
||
// channels would silently fail at runtime.
|
||
if c.MapClientsPresenceChannelPrefix != "" {
|
||
if err := validatePresenceChannelPrefix(cfg, "map_clients_presence_channel_prefix", c.MapClientsPresenceChannelPrefix, "map_clients"); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
if c.MapUsersPresenceChannelPrefix != "" {
|
||
if err := validatePresenceChannelPrefix(cfg, "map_users_presence_channel_prefix", c.MapUsersPresenceChannelPrefix, "map_users"); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
// Map page-size invariants. Zero means "use default" — the runtime path
|
||
// fills in sensible values — but any non-zero combination must satisfy
|
||
// min <= default <= max so clamping never produces surprising results.
|
||
if c.Map.MinPageSize < 0 {
|
||
return fmt.Errorf("map.min_page_size must not be negative")
|
||
}
|
||
if c.Map.MaxPageSize < 0 {
|
||
return fmt.Errorf("map.max_page_size must not be negative")
|
||
}
|
||
if c.Map.DefaultPageSize < 0 {
|
||
return fmt.Errorf("map.default_page_size must not be negative")
|
||
}
|
||
if c.Map.MinPageSize > 0 && c.Map.MaxPageSize > 0 && c.Map.MinPageSize > c.Map.MaxPageSize {
|
||
return fmt.Errorf("map.min_page_size (%d) must not exceed map.max_page_size (%d)", c.Map.MinPageSize, c.Map.MaxPageSize)
|
||
}
|
||
if c.Map.DefaultPageSize > 0 && c.Map.MaxPageSize > 0 && c.Map.DefaultPageSize > c.Map.MaxPageSize {
|
||
return fmt.Errorf("map.default_page_size (%d) must not exceed map.max_page_size (%d)", c.Map.DefaultPageSize, c.Map.MaxPageSize)
|
||
}
|
||
if c.Map.DefaultPageSize > 0 && c.Map.MinPageSize > 0 && c.Map.DefaultPageSize < c.Map.MinPageSize {
|
||
return fmt.Errorf("map.default_page_size (%d) must not be below map.min_page_size (%d)", c.Map.DefaultPageSize, c.Map.MinPageSize)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// validatePresenceChannelPrefix checks that prefix, when prepended to a
|
||
// channel name, resolves under the configured NamespaceBoundary to a namespace
|
||
// whose subscription_type is `expectedType`. Caught at config-load so typos
|
||
// in the prefix don't surface only when the first map_publish fails.
|
||
func validatePresenceChannelPrefix(cfg Config, fieldName, prefix, expectedType string) error {
|
||
boundary := cfg.Channel.NamespaceBoundary
|
||
var nsName string
|
||
if boundary != "" {
|
||
idx := strings.Index(prefix, boundary)
|
||
if idx >= 0 {
|
||
nsName = prefix[:idx]
|
||
}
|
||
}
|
||
opts, ok, err := channelOpts(&cfg, nsName)
|
||
if err != nil {
|
||
return fmt.Errorf("%s: %v", fieldName, err)
|
||
}
|
||
if !ok {
|
||
return fmt.Errorf("%s %q: namespace %q does not exist", fieldName, prefix, nsName)
|
||
}
|
||
if opts.SubscriptionType != expectedType {
|
||
return fmt.Errorf("%s %q: target namespace %q must have subscription_type=%q (got %q)", fieldName, prefix, nsName, expectedType, opts.SubscriptionType)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func validateRpcOptions(opts configtypes.RpcOptions, rpcProxyNames []string) error {
|
||
if opts.ProxyName != "" && !slices.Contains(rpcProxyNames, opts.ProxyName) {
|
||
return fmt.Errorf("proxy %s not found for rpc", opts.ProxyName)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
var proxyNamePattern = "^[-a-zA-Z0-9_.]{2,}$"
|
||
var proxyNameRe = regexp.MustCompile(proxyNamePattern)
|
||
|
||
var consumerNamePattern = "^[a-zA-Z0-9_]{2,}$"
|
||
var consumerNameRe = regexp.MustCompile(consumerNamePattern)
|
||
|
||
func validateSecondPrecisionDuration(duration configtypes.Duration) error {
|
||
if duration > 0 && duration.ToDuration()%time.Second != 0 {
|
||
return fmt.Errorf("malformed duration %s, sub-second precision is not supported for this key", duration)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func validateProxy(name string, p configtypes.Proxy) error {
|
||
if !proxyNameRe.MatchString(name) {
|
||
return fmt.Errorf("invalid proxy name: %s, must match %s regular expression", name, proxyNamePattern)
|
||
}
|
||
if p.Timeout == 0 {
|
||
return errors.New("timeout not set")
|
||
}
|
||
if p.Endpoint == "" {
|
||
return errors.New("endpoint not set")
|
||
}
|
||
if err := validateStatusTransforms(p.ProxyCommon.HTTP.StatusToCodeTransforms); err != nil {
|
||
return fmt.Errorf("in status_to_code_transforms: %v", err)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// Now Centrifugo uses https://github.com/tidwall/gjson to extract custom claims from JWT. So technically
|
||
// we could support extracting from nested objects using dot syntax, like "centrifugo.user". But for now
|
||
// not using this feature to keep things simple until necessary.
|
||
var customClaimRe = regexp.MustCompile("^[a-zA-Z_]+$")
|
||
|
||
func validateTokens(cfg Config) error {
|
||
if cfg.Client.Token.UserIDClaim != "" {
|
||
if !customClaimRe.MatchString(cfg.Client.Token.UserIDClaim) {
|
||
return fmt.Errorf("invalid token custom user ID claim: %s, must match %s regular expression", cfg.Client.Token.UserIDClaim, customClaimRe.String())
|
||
}
|
||
}
|
||
if cfg.Client.SubscriptionToken.UserIDClaim != "" {
|
||
if !customClaimRe.MatchString(cfg.Client.SubscriptionToken.UserIDClaim) {
|
||
return fmt.Errorf("invalid subscription token custom user ID claim: %s, must match %s regular expression", cfg.Client.SubscriptionToken.UserIDClaim, customClaimRe.String())
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func validateStatusTransforms(transforms []configtypes.HttpStatusToCodeTransform) error {
|
||
for i, transform := range transforms {
|
||
if transform.StatusCode == 0 {
|
||
return fmt.Errorf("status_code should be set in status_to_code_transforms[%d]", i)
|
||
}
|
||
if transform.ToDisconnect.Code == 0 && transform.ToError.Code == 0 {
|
||
return fmt.Errorf("no error or disconnect code set in status_to_code_transforms[%d]", i)
|
||
}
|
||
if transform.ToDisconnect.Code > 0 && transform.ToError.Code > 0 {
|
||
return fmt.Errorf("only error or disconnect code can be set in status_to_code_transforms[%d], but not both", i)
|
||
}
|
||
if !tools.IsASCII(transform.ToDisconnect.Reason) {
|
||
return fmt.Errorf("status_to_code_transforms[%d] disconnect reason must be ASCII", i)
|
||
}
|
||
if !tools.IsASCII(transform.ToError.Message) {
|
||
return fmt.Errorf("status_to_code_transforms[%d] error message must be ASCII", i)
|
||
}
|
||
const reasonOrMessageMaxLength = 123 // limit comes from WebSocket close reason length limit. See https://datatracker.ietf.org/doc/html/rfc6455.
|
||
if len(transform.ToError.Message) > reasonOrMessageMaxLength {
|
||
return fmt.Errorf("status_to_code_transforms[%d] item error message can be up to %d characters long", i, reasonOrMessageMaxLength)
|
||
}
|
||
if len(transform.ToDisconnect.Reason) > reasonOrMessageMaxLength {
|
||
return fmt.Errorf("status_to_code_transforms[%d] disconnect reason can be up to %d characters long", i, reasonOrMessageMaxLength)
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func validateConnectCodeTransforms(transforms []configtypes.ConnectCodeToHTTPResponseTransform) error {
|
||
for i, transform := range transforms {
|
||
if transform.Code == 0 {
|
||
return fmt.Errorf("code should be set in connect_code_to_http_response.transforms[%d]", i)
|
||
}
|
||
if transform.To.StatusCode == 0 {
|
||
return fmt.Errorf("status_code should be set in connect_code_to_http_response.transforms[%d].to", i)
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func validateCodeToUniDisconnectTransforms(transforms configtypes.UniConnectCodeToDisconnectTransforms) error {
|
||
for i, t := range transforms {
|
||
if t.Code == 0 {
|
||
return fmt.Errorf("no code specified in transforms[%d]", i)
|
||
}
|
||
if t.To.Code == 0 {
|
||
return fmt.Errorf("no disconnect code specified in transforms[%d].to", i)
|
||
}
|
||
if !tools.IsASCII(t.To.Reason) {
|
||
return fmt.Errorf("disconnect reason must be ASCII in transforms[%d].to", i)
|
||
}
|
||
}
|
||
return nil
|
||
}
|