mirror of
https://github.com/hanzokv/go.git
synced 2026-09-24 00:31:51 +00:00
zeekay
6994cf05aa
We do not use Redis. The client was a go-redis fork and still said so
everywhere: `package redis`, `redis.NewClient`, `redis://`, `extra/redisotel`.
Consumers wrote `redis.Client` against a Valkey-backed store called KV.
package redis -> package kv (93 decls)
redis.X -> kv.X (2,794 call sites)
"redis: …" errors -> "kv: …" (206)
extra/redis{otel,cmd,prometheus,census} -> extra/kv{otel,cmd,prometheus,census}
redis:// , rediss:// -> kv:// , kvs:// (ParseURL)
Redis*/*Redis* idents -> KV*/*KV*
REDIS_VERSION, REDIS_ENDPOINTS_CONFIG_PATH -> KV_*
I previously argued this rename was unsafe because much of it was "wire
contract". That was wrong, and the categorisation shows why: RESP command names
are GET/SET/HSET — they never contain the word. Of 5,771 occurrences only two
kinds were server-visible at all: the ParseURL scheme (we choose what we pass;
our configs already use kv://) and the CLIENT SETINFO lib-name label, which the
server merely records. Nothing here changes a byte of protocol.
Two things deliberately keep the old spelling:
RediSearch — names a specific external module the FT.* commands map to.
StoreDist — contains the letters by accident (sto-reDis-t), not the word.
Breaking for consumers by design: every import site must move redis.X -> kv.X.
Minor bump, never a major — this module stays v9 forever.
112 lines
3.5 KiB
Go
112 lines
3.5 KiB
Go
package kv
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"net"
|
|
"time"
|
|
|
|
"github.com/hanzokv/go/v9/internal/interfaces"
|
|
"github.com/hanzokv/go/v9/push"
|
|
)
|
|
|
|
// ErrInvalidCommand is returned when an invalid command is passed to ExecuteCommand.
|
|
var ErrInvalidCommand = errors.New("invalid command type")
|
|
|
|
// ErrInvalidPool is returned when the pool type is not supported.
|
|
var ErrInvalidPool = errors.New("invalid pool type")
|
|
|
|
// newClientAdapter creates a new client adapter for regular KV clients.
|
|
func newClientAdapter(client *baseClient) interfaces.ClientInterface {
|
|
return &clientAdapter{client: client}
|
|
}
|
|
|
|
// clientAdapter adapts a KV client to implement interfaces.ClientInterface.
|
|
type clientAdapter struct {
|
|
client *baseClient
|
|
}
|
|
|
|
// GetOptions returns the client options.
|
|
func (ca *clientAdapter) GetOptions() interfaces.OptionsInterface {
|
|
return &optionsAdapter{options: ca.client.opt}
|
|
}
|
|
|
|
// GetPushProcessor returns the client's push notification processor.
|
|
func (ca *clientAdapter) GetPushProcessor() interfaces.NotificationProcessor {
|
|
return &pushProcessorAdapter{processor: ca.client.pushProcessor}
|
|
}
|
|
|
|
// optionsAdapter adapts KV options to implement interfaces.OptionsInterface.
|
|
type optionsAdapter struct {
|
|
options *Options
|
|
}
|
|
|
|
// GetReadTimeout returns the read timeout.
|
|
func (oa *optionsAdapter) GetReadTimeout() time.Duration {
|
|
return oa.options.ReadTimeout
|
|
}
|
|
|
|
// GetWriteTimeout returns the write timeout.
|
|
func (oa *optionsAdapter) GetWriteTimeout() time.Duration {
|
|
return oa.options.WriteTimeout
|
|
}
|
|
|
|
// GetNetwork returns the network type.
|
|
func (oa *optionsAdapter) GetNetwork() string {
|
|
return oa.options.Network
|
|
}
|
|
|
|
// GetAddr returns the connection address.
|
|
func (oa *optionsAdapter) GetAddr() string {
|
|
return oa.options.Addr
|
|
}
|
|
|
|
// IsTLSEnabled returns true if TLS is enabled.
|
|
func (oa *optionsAdapter) IsTLSEnabled() bool {
|
|
return oa.options.TLSConfig != nil
|
|
}
|
|
|
|
// GetProtocol returns the protocol version.
|
|
func (oa *optionsAdapter) GetProtocol() int {
|
|
return oa.options.Protocol
|
|
}
|
|
|
|
// GetPoolSize returns the connection pool size.
|
|
func (oa *optionsAdapter) GetPoolSize() int {
|
|
return oa.options.PoolSize
|
|
}
|
|
|
|
// NewDialer returns a new dialer function for the connection.
|
|
func (oa *optionsAdapter) NewDialer() func(context.Context) (net.Conn, error) {
|
|
baseDialer := oa.options.NewDialer()
|
|
return func(ctx context.Context) (net.Conn, error) {
|
|
// Extract network and address from the options
|
|
network := oa.options.Network
|
|
addr := oa.options.Addr
|
|
return baseDialer(ctx, network, addr)
|
|
}
|
|
}
|
|
|
|
// pushProcessorAdapter adapts a push.NotificationProcessor to implement interfaces.NotificationProcessor.
|
|
type pushProcessorAdapter struct {
|
|
processor push.NotificationProcessor
|
|
}
|
|
|
|
// RegisterHandler registers a handler for a specific push notification name.
|
|
func (ppa *pushProcessorAdapter) RegisterHandler(pushNotificationName string, handler interface{}, protected bool) error {
|
|
if pushHandler, ok := handler.(push.NotificationHandler); ok {
|
|
return ppa.processor.RegisterHandler(pushNotificationName, pushHandler, protected)
|
|
}
|
|
return errors.New("handler must implement push.NotificationHandler")
|
|
}
|
|
|
|
// UnregisterHandler removes a handler for a specific push notification name.
|
|
func (ppa *pushProcessorAdapter) UnregisterHandler(pushNotificationName string) error {
|
|
return ppa.processor.UnregisterHandler(pushNotificationName)
|
|
}
|
|
|
|
// GetHandler returns the handler for a specific push notification name.
|
|
func (ppa *pushProcessorAdapter) GetHandler(pushNotificationName string) interface{} {
|
|
return ppa.processor.GetHandler(pushNotificationName)
|
|
}
|