feat: add DSN/URL connection string support for PostgreSQL and Redis (#11729)

This commit is contained in:
Mridang Agarwalla
2026-03-20 15:21:15 +00:00
committed by GitHub
parent dad4565d5d
commit 471ed4a5d7
25 changed files with 810 additions and 302 deletions
+5 -1
View File
@@ -38,11 +38,15 @@ func StartConnectors(conf *CachesConfig, client *database.DB) (Connectors, error
if conf == nil {
return Connectors{}, nil
}
redisConnector, err := redis.NewConnector(conf.Connectors.Redis)
if err != nil {
return Connectors{}, fmt.Errorf("start redis connector: %w", err)
}
return Connectors{
Config: *conf,
Memory: gomap.NewConnector(conf.Connectors.Memory),
Postgres: pg.NewConnector(conf.Connectors.Postgres, client),
Redis: redis.NewConnector(conf.Connectors.Redis),
Redis: redisConnector,
}, nil
}
+90 -3
View File
@@ -2,6 +2,7 @@ package redis
import (
"crypto/tls"
"fmt"
"time"
"github.com/redis/go-redis/v9"
@@ -10,6 +11,14 @@ import (
type Config struct {
Enabled bool
// URL is a full Redis connection URL. When set, individual connection
// fields (Addr, Username, Password, Network, EnableTLS) are ignored.
// Pool, timeout, retry, and circuit breaker settings can still be used as overlays.
// Format: redis://user:password@host:port[/db] or rediss://... for TLS.
// Note: the DB number in the URL path is ignored for cache DB selection.
// ZITADEL derives the actual DB from DBOffset + purpose; use /0 or omit the /db path.
URL string
// The network type, either tcp or unix.
// Default is tcp.
Network string
@@ -114,14 +123,91 @@ type Connector struct {
Config Config
}
func NewConnector(config Config) *Connector {
func NewConnector(config Config) (*Connector, error) {
if !config.Enabled {
return nil
return nil, nil
}
var opts *redis.Options
if config.URL != "" {
var err error
opts, err = optionsFromURL(config)
if err != nil {
return nil, err
}
} else {
opts = optionsFromConfig(config)
}
return &Connector{
Client: redis.NewClient(optionsFromConfig(config)),
Client: redis.NewClient(opts),
Config: config,
}, nil
}
func optionsFromURL(c Config) (*redis.Options, error) {
opts, err := redis.ParseURL(c.URL)
if err != nil {
return nil, fmt.Errorf("invalid Redis URL: %w", err)
}
opts.Protocol = 3
opts.ContextTimeoutEnabled = true
if c.ClientName != "" {
opts.ClientName = c.ClientName
}
if c.MaxRetries != 0 {
opts.MaxRetries = c.MaxRetries
}
if c.MinRetryBackoff != 0 {
opts.MinRetryBackoff = c.MinRetryBackoff
}
if c.MaxRetryBackoff != 0 {
opts.MaxRetryBackoff = c.MaxRetryBackoff
}
if c.DialTimeout != 0 {
opts.DialTimeout = c.DialTimeout
}
if c.ReadTimeout != 0 {
opts.ReadTimeout = c.ReadTimeout
}
if c.WriteTimeout != 0 {
opts.WriteTimeout = c.WriteTimeout
}
if c.PoolFIFO {
opts.PoolFIFO = c.PoolFIFO
}
if c.PoolSize != 0 {
opts.PoolSize = c.PoolSize
}
if c.PoolTimeout != 0 {
opts.PoolTimeout = c.PoolTimeout
}
if c.MinIdleConns != 0 {
opts.MinIdleConns = c.MinIdleConns
}
if c.MaxIdleConns != 0 {
opts.MaxIdleConns = c.MaxIdleConns
}
if c.MaxActiveConns != 0 {
opts.MaxActiveConns = c.MaxActiveConns
}
if c.ConnMaxIdleTime != 0 {
opts.ConnMaxIdleTime = c.ConnMaxIdleTime
}
if c.ConnMaxLifetime != 0 {
opts.ConnMaxLifetime = c.ConnMaxLifetime
}
opts.DisableIdentity = c.DisableIndentity
if c.IdentitySuffix != "" {
opts.IdentitySuffix = c.IdentitySuffix
}
opts.Limiter = newLimiter(c.CircuitBreaker, c.MaxActiveConns)
return opts, nil
}
func optionsFromConfig(c Config) *redis.Options {
@@ -140,6 +226,7 @@ func optionsFromConfig(c Config) *redis.Options {
WriteTimeout: c.WriteTimeout,
ContextTimeoutEnabled: true,
PoolFIFO: c.PoolFIFO,
PoolSize: c.PoolSize,
PoolTimeout: c.PoolTimeout,
MinIdleConns: c.MinIdleConns,
MaxIdleConns: c.MaxIdleConns,
+187
View File
@@ -0,0 +1,187 @@
package redis
import (
"testing"
"time"
"github.com/alicebob/miniredis/v2"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestOptionsFromURL(t *testing.T) {
t.Run("basic URL", func(t *testing.T) {
c := Config{URL: "redis://localhost:6379/0"}
opts, err := optionsFromURL(c)
require.NoError(t, err)
assert.Equal(t, "localhost:6379", opts.Addr)
assert.Equal(t, 0, opts.DB)
assert.Equal(t, 3, opts.Protocol)
assert.True(t, opts.ContextTimeoutEnabled)
})
t.Run("with auth", func(t *testing.T) {
c := Config{URL: "redis://myuser:mypass@host:6380/2"}
opts, err := optionsFromURL(c)
require.NoError(t, err)
assert.Equal(t, "host:6380", opts.Addr)
assert.Equal(t, "myuser", opts.Username)
assert.Equal(t, "mypass", opts.Password)
assert.Equal(t, 2, opts.DB)
})
t.Run("TLS via rediss scheme", func(t *testing.T) {
c := Config{URL: "rediss://host:6380/0"}
opts, err := optionsFromURL(c)
require.NoError(t, err)
assert.NotNil(t, opts.TLSConfig)
})
t.Run("password only auth", func(t *testing.T) {
c := Config{URL: "redis://:secret@host:6379/0"}
opts, err := optionsFromURL(c)
require.NoError(t, err)
assert.Equal(t, "", opts.Username)
assert.Equal(t, "secret", opts.Password)
})
t.Run("URL without DB number", func(t *testing.T) {
c := Config{URL: "redis://localhost:6379"}
opts, err := optionsFromURL(c)
require.NoError(t, err)
assert.Equal(t, "localhost:6379", opts.Addr)
assert.Equal(t, 0, opts.DB)
})
t.Run("overlays pool settings", func(t *testing.T) {
c := Config{
URL: "redis://localhost:6379/0",
PoolSize: 42,
MaxActiveConns: 100,
MinIdleConns: 5,
}
opts, err := optionsFromURL(c)
require.NoError(t, err)
assert.Equal(t, 42, opts.PoolSize)
assert.Equal(t, 100, opts.MaxActiveConns)
assert.Equal(t, 5, opts.MinIdleConns)
})
t.Run("overlays timeout settings", func(t *testing.T) {
c := Config{
URL: "redis://localhost:6379/0",
DialTimeout: 10 * time.Second,
ReadTimeout: 5 * time.Second,
}
opts, err := optionsFromURL(c)
require.NoError(t, err)
assert.Equal(t, 10*time.Second, opts.DialTimeout)
assert.Equal(t, 5*time.Second, opts.ReadTimeout)
})
t.Run("overlays retry settings", func(t *testing.T) {
c := Config{
URL: "redis://localhost:6379/0",
MaxRetries: 5,
}
opts, err := optionsFromURL(c)
require.NoError(t, err)
assert.Equal(t, 5, opts.MaxRetries)
})
t.Run("overlays client name", func(t *testing.T) {
c := Config{
URL: "redis://localhost:6379/0",
ClientName: "zitadel",
}
opts, err := optionsFromURL(c)
require.NoError(t, err)
assert.Equal(t, "zitadel", opts.ClientName)
})
t.Run("overlays circuit breaker", func(t *testing.T) {
c := Config{
URL: "redis://localhost:6379/0",
CircuitBreaker: &CBConfig{
MaxConsecutiveFailures: 10,
},
MaxActiveConns: 50,
}
opts, err := optionsFromURL(c)
require.NoError(t, err)
assert.NotNil(t, opts.Limiter)
})
t.Run("invalid URL returns error", func(t *testing.T) {
c := Config{URL: "garbage://???"}
_, err := optionsFromURL(c)
require.Error(t, err)
})
}
func TestOptionsFromConfig(t *testing.T) {
t.Run("maps all fields", func(t *testing.T) {
c := Config{
Addr: "myhost:6380",
Username: "user",
Password: "pass",
PoolSize: 42,
MaxRetries: 5,
}
opts := optionsFromConfig(c)
assert.Equal(t, "myhost:6380", opts.Addr)
assert.Equal(t, "user", opts.Username)
assert.Equal(t, "pass", opts.Password)
assert.Equal(t, 42, opts.PoolSize)
assert.Equal(t, 5, opts.MaxRetries)
assert.Equal(t, 3, opts.Protocol)
assert.True(t, opts.ContextTimeoutEnabled)
})
t.Run("EnableTLS sets TLSConfig", func(t *testing.T) {
c := Config{Addr: "host:6379", EnableTLS: true}
opts := optionsFromConfig(c)
assert.NotNil(t, opts.TLSConfig)
})
}
func TestNewConnector(t *testing.T) {
t.Run("disabled returns nil without error", func(t *testing.T) {
c, err := NewConnector(Config{Enabled: false, URL: "redis://localhost:6379/0"})
require.NoError(t, err)
assert.Nil(t, c)
})
t.Run("URL mode connects to miniredis", func(t *testing.T) {
server := miniredis.RunT(t)
url := "redis://" + server.Addr() + "/0"
c, err := NewConnector(Config{
Enabled: true,
URL: url,
DisableIndentity: true,
})
require.NoError(t, err)
require.NotNil(t, c)
t.Cleanup(func() { c.Close() })
})
t.Run("legacy mode connects to miniredis", func(t *testing.T) {
server := miniredis.RunT(t)
c, err := NewConnector(Config{
Enabled: true,
Addr: server.Addr(),
DisableIndentity: true,
})
require.NoError(t, err)
require.NotNil(t, c)
t.Cleanup(func() { c.Close() })
})
t.Run("invalid URL errors", func(t *testing.T) {
_, err := NewConnector(Config{
Enabled: true,
URL: "garbage://???",
})
require.Error(t, err)
})
}
+2 -1
View File
@@ -705,7 +705,8 @@ func prepareCache(t *testing.T, conf cache.Config, options ...func(*Config)) (ca
for _, option := range options {
option(&connConfig)
}
connector := NewConnector(connConfig)
connector, err := NewConnector(connConfig)
require.NoError(t, err)
t.Cleanup(func() {
connector.Close()
server.Close()