store

package
v0.6.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 15, 2025 License: Apache-2.0 Imports: 18 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	CKeyPartsDelimiter = ":"
	CWildcardSelector  = "*"
)

Variables

This section is empty.

Functions

func BucketLockIDToTokensConverter 

func BucketLockIDToTokensConverter(id entity.BucketLockID) ([]string, error)

func BucketReplicationPolicyDestinationToStringConverter 

func BucketReplicationPolicyDestinationToStringConverter(value entity.BucketReplicationPolicyDestination) (string, error)

func BucketReplicationPolicyIDToTokensConverter 

func BucketReplicationPolicyIDToTokensConverter(id entity.BucketReplicationPolicyID) ([]string, error)

func BucketReplicationPolicyToStringConverter 

func BucketReplicationPolicyToStringConverter(value entity.BucketReplicationPolicy) (string, error)

func BucketReplicationPolicyToTokensConverter 

func BucketReplicationPolicyToTokensConverter(value entity.BucketReplicationPolicy) ([]string, error)

func BucketRoutingPolicyIDToTokensConverter 

func BucketRoutingPolicyIDToTokensConverter(id entity.BucketRoutingPolicyID) ([]string, error)

func ConsistencyCheckIDToStringConverter 

func ConsistencyCheckIDToStringConverter(value entity.ConsistencyCheckID) (string, error)

func ConsistencyCheckIDToTokensConverter 

func ConsistencyCheckIDToTokensConverter(id entity.ConsistencyCheckID) ([]string, error)

func ConsistencyCheckObjectIDToTokensConverter 

func ConsistencyCheckObjectIDToTokensConverter(id entity.ConsistencyCheckObjectID) ([]string, error)

func ConsistencyCheckSetEntryToStringConverter 

func ConsistencyCheckSetEntryToStringConverter(value entity.ConsistencyCheckSetEntry) (string, error)

func ConsistencyCheckSetIDToTokensConverter 

func ConsistencyCheckSetIDToTokensConverter(id entity.ConsistencyCheckSetID) ([]string, error)

func ConsistencyCheckSettingsToStringConverter 

func ConsistencyCheckSettingsToStringConverter(value entity.ConsistencyCheckSettings) (string, error)

func DeserializeNumber 

func DeserializeNumber[T Numeric](value string) (T, error)

func EmptyStructToTokensConverter 

func EmptyStructToTokensConverter(id struct{}) ([]string, error)

func Float64ToUint8Converter 

func Float64ToUint8Converter(value float64) (uint8, error)

func ObjectLockIDToTokensConverter 

func ObjectLockIDToTokensConverter(id entity.ObjectLockID) ([]string, error)

func ObjectVersionIDToTokensConverter 

func ObjectVersionIDToTokensConverter(id entity.VersionedObjectID) ([]string, error)

func ObjectVersionInfoToStringConverter 

func ObjectVersionInfoToStringConverter(value rclone.ObjectVersionInfo) (string, error)

func SerializeNumber 

func SerializeNumber[T Numeric](value T) (string, error)

func SingleTokenToStringConverter 

func SingleTokenToStringConverter(tokens []string) (string, error)

func StringToBucketReplicationPolicyConverter 

func StringToBucketReplicationPolicyConverter(value string) (entity.BucketReplicationPolicy, error)

func StringToBucketReplicationPolicyDestinationConverter 

func StringToBucketReplicationPolicyDestinationConverter(value string) (entity.BucketReplicationPolicyDestination, error)

func StringToConsistencyCheckIDConverter 

func StringToConsistencyCheckIDConverter(value string) (entity.ConsistencyCheckID, error)

func StringToConsistencyCheckSetEntryConverter 

func StringToConsistencyCheckSetEntryConverter(value string) (entity.ConsistencyCheckSetEntry, error)

func StringToConsistencyCheckSettingsConverter 

func StringToConsistencyCheckSettingsConverter(value string) (entity.ConsistencyCheckSettings, error)

func StringToObjectVersionInfoConverter 

func StringToObjectVersionInfoConverter(value string) (rclone.ObjectVersionInfo, error)

func StringToSingleTokenConverter 

func StringToSingleTokenConverter(id string) ([]string, error)

func StringToUserReplicationPolicyConverter 

func StringToUserReplicationPolicyConverter(value string) (entity.UserReplicationPolicy, error)

func StringValueConverter 

func StringValueConverter(value string) (string, error)

func TokensToBucketLockIDConverter 

func TokensToBucketLockIDConverter(tokens []string) (entity.BucketLockID, error)

func TokensToBucketReplicationPolicyConverter 

func TokensToBucketReplicationPolicyConverter(values []string) (entity.BucketReplicationPolicy, error)

func TokensToBucketReplicationPolicyIDConverter 

func TokensToBucketReplicationPolicyIDConverter(tokens []string) (entity.BucketReplicationPolicyID, error)

func TokensToBucketRoutingPolicyIDConverter 

func TokensToBucketRoutingPolicyIDConverter(tokens []string) (entity.BucketRoutingPolicyID, error)

---------------- Converters ----------------

func TokensToConsistencyCheckIDConverter 

func TokensToConsistencyCheckIDConverter(tokens []string) (entity.ConsistencyCheckID, error)

func TokensToConsistencyCheckObjectIDConverter 

func TokensToConsistencyCheckObjectIDConverter(tokens []string) (entity.ConsistencyCheckObjectID, error)

func TokensToConsistencyCheckSetIDConverter 

func TokensToConsistencyCheckSetIDConverter(tokens []string) (entity.ConsistencyCheckSetID, error)

func TokensToEmptyStructConverter 

func TokensToEmptyStructConverter(tokens []string) (struct{}, error)

func TokensToObjectLockIDConverter 

func TokensToObjectLockIDConverter(tokens []string) (entity.ObjectLockID, error)

func TokensToObjectVersionIDConverter 

func TokensToObjectVersionIDConverter(tokens []string) (entity.VersionedObjectID, error)

func TokensToUniversalReplicationID 

func TokensToUniversalReplicationID(values []string) (entity.UniversalReplicationID, error)

func TokensToUserReplicationPolicy 

func TokensToUserReplicationPolicy(values []string) (entity.UserReplicationPolicy, error)

func Uint8ToFloat64Converter 

func Uint8ToFloat64Converter(value uint8) (float64, error)

func UniversalReplicationIDToStringConverter 

func UniversalReplicationIDToStringConverter(value entity.UniversalReplicationID) (string, error)

func UniversalReplicationIDToTokensConverter 

func UniversalReplicationIDToTokensConverter(value entity.UniversalReplicationID) ([]string, error)

-------------------------------- ID converters --------------------------------

func UserReplicationPolicyToStringConverter 

func UserReplicationPolicyToStringConverter(value entity.UserReplicationPolicy) (string, error)

func UserReplicationPolicyToTokensConverter 

func UserReplicationPolicyToTokensConverter(value entity.UserReplicationPolicy) ([]string, error)

Types

type BucketLocker 

type BucketLocker struct {
	RedisIDKeyLocker[entity.BucketLockID]
}

func NewBucketLocker 

func NewBucketLocker(client redis.Cmdable, overlap time.Duration) *BucketLocker

type BucketReplicationPolicyStore 

type BucketReplicationPolicyStore struct {
	// contains filtered or unexported fields
}

--------------------------------bucket replication policies--------------------------------

func NewBucketReplicationPolicyStore 

func NewBucketReplicationPolicyStore(client redis.Cmdable) *BucketReplicationPolicyStore

func (*BucketReplicationPolicyStore) AddOp 

func (r *BucketReplicationPolicyStore) AddOp(ctx context.Context, id entity.BucketReplicationPolicy) OperationStatus

Add adds a new bucket replication policy. Validation must be done before calling this method. Can be part of a transaction.

func (*BucketReplicationPolicyStore) ExistsForUser 

func (r *BucketReplicationPolicyStore) ExistsForUser(ctx context.Context, user string) (bool, error)

func (*BucketReplicationPolicyStore) Get 

func (r *BucketReplicationPolicyStore) Get(ctx context.Context, id entity.BucketReplicationPolicyID) ([]entity.BucketReplicationPolicy, error)

func (*BucketReplicationPolicyStore) GetOp 

func (r *BucketReplicationPolicyStore) GetOp(ctx context.Context, id entity.BucketReplicationPolicyID) OperationResult[[]entity.BucketReplicationPolicy]

func (*BucketReplicationPolicyStore) IsDestinationInUse 

func (r *BucketReplicationPolicyStore) IsDestinationInUse(ctx context.Context, policy entity.BucketReplicationPolicy) (bool, error)

func (*BucketReplicationPolicyStore) RemoveOp 

func (r *BucketReplicationPolicyStore) RemoveOp(ctx context.Context, id entity.BucketReplicationPolicy) OperationStatus

func (*BucketReplicationPolicyStore) TxExecutor 

func (r *BucketReplicationPolicyStore) TxExecutor() Executor[redis.Pipeliner]

func (*BucketReplicationPolicyStore) WithExecutor 

func (r *BucketReplicationPolicyStore) WithExecutor(exec Executor[redis.Pipeliner]) *BucketReplicationPolicyStore

type BucketReplicationStatusStore 

type BucketReplicationStatusStore struct {
	// contains filtered or unexported fields
}

func NewBucketReplicationStatusStore 

func NewBucketReplicationStatusStore(client redis.Cmdable) *BucketReplicationStatusStore

func (*BucketReplicationStatusStore) AddOp 

func (r *BucketReplicationStatusStore) AddOp(ctx context.Context, id entity.BucketReplicationPolicy, status entity.ReplicationStatus) OperationStatus

func (*BucketReplicationStatusStore) ArchieveOp 

func (r *BucketReplicationStatusStore) ArchieveOp(ctx context.Context, id entity.BucketReplicationPolicy) OperationStatus

func (*BucketReplicationStatusStore) DeleteOp 

func (r *BucketReplicationStatusStore) DeleteOp(ctx context.Context, id entity.BucketReplicationPolicy) OperationStatus

func (*BucketReplicationStatusStore) GetOp 

func (r *BucketReplicationStatusStore) GetOp(ctx context.Context, id entity.BucketReplicationPolicy) OperationResult[entity.ReplicationStatus]

func (*BucketReplicationStatusStore) List 

func (r *BucketReplicationStatusStore) List(ctx context.Context, user string) (map[entity.BucketReplicationPolicy]entity.ReplicationStatus, error)

func (*BucketReplicationStatusStore) TxExecutor 

func (r *BucketReplicationStatusStore) TxExecutor() Executor[redis.Pipeliner]

func (*BucketReplicationStatusStore) WithExecutor 

func (r *BucketReplicationStatusStore) WithExecutor(exec Executor[redis.Pipeliner]) *BucketReplicationStatusStore

type BucketReplicationSwitchStore 

type BucketReplicationSwitchStore struct {
	// contains filtered or unexported fields
}

func NewBucketReplicationSwitchStore 

func NewBucketReplicationSwitchStore(client redis.Cmdable) *BucketReplicationSwitchStore

func (*BucketReplicationSwitchStore) Create 

func (r *BucketReplicationSwitchStore) Create(ctx context.Context, replicationID entity.BucketReplicationPolicy, value entity.ReplicationSwitchInfo) error

func (*BucketReplicationSwitchStore) CreateOp 

func (r *BucketReplicationSwitchStore) CreateOp(ctx context.Context, replicationID entity.BucketReplicationPolicy, value entity.ReplicationSwitchInfo) OperationStatus

func (*BucketReplicationSwitchStore) DeleteOp 

func (r *BucketReplicationSwitchStore) DeleteOp(ctx context.Context, id entity.BucketReplicationPolicyID) OperationStatus

func (*BucketReplicationSwitchStore) Get 

func (r *BucketReplicationSwitchStore) Get(ctx context.Context, id entity.BucketReplicationPolicyID) (entity.ReplicationSwitchInfo, error)

func (*BucketReplicationSwitchStore) GetOp 

func (r *BucketReplicationSwitchStore) GetOp(ctx context.Context, id entity.BucketReplicationPolicyID) OperationResult[entity.ReplicationSwitchInfo]

func (*BucketReplicationSwitchStore) IsZeroDowntimeActiveOp 

func (r *BucketReplicationSwitchStore) IsZeroDowntimeActiveOp(ctx context.Context, id entity.BucketReplicationPolicyID) OperationResult[bool]

func (*BucketReplicationSwitchStore) TxExecutor 

func (r *BucketReplicationSwitchStore) TxExecutor() Executor[redis.Pipeliner]

func (*BucketReplicationSwitchStore) UpdateDowntimeOpts 

func (r *BucketReplicationSwitchStore) UpdateDowntimeOpts(ctx context.Context, replication entity.BucketReplicationPolicy, value *entity.ReplicationSwitchDowntimeOpts) error

func (*BucketReplicationSwitchStore) UpdateDowntimeOptsOp 

func (r *BucketReplicationSwitchStore) UpdateDowntimeOptsOp(ctx context.Context, replication entity.BucketReplicationPolicy, value *entity.ReplicationSwitchDowntimeOpts) OperationStatus

func (*BucketReplicationSwitchStore) UpdateStatusOp 

func (r *BucketReplicationSwitchStore) UpdateStatusOp(ctx context.Context, replicationID entity.BucketReplicationPolicy, prevStatus, newStatus entity.ReplicationSwitchStatus, message string) OperationStatus

func (*BucketReplicationSwitchStore) WithExecutor 

func (r *BucketReplicationSwitchStore) WithExecutor(exec Executor[redis.Pipeliner]) *BucketReplicationSwitchStore

type BucketRoutingStore 

type BucketRoutingStore struct {
	// contains filtered or unexported fields
}

func NewBucketRoutingStore 

func NewBucketRoutingStore(client redis.Cmdable) *BucketRoutingStore

func (*BucketRoutingStore) BlockOp 

func (r *BucketRoutingStore) BlockOp(ctx context.Context, id entity.BucketRoutingPolicyID) OperationStatus

func (*BucketRoutingStore) DeleteOp 

func (r *BucketRoutingStore) DeleteOp(ctx context.Context, id entity.BucketRoutingPolicyID) OperationStatus

func (*BucketRoutingStore) GetOp 

func (r *BucketRoutingStore) GetOp(ctx context.Context, id entity.BucketRoutingPolicyID) OperationResult[string]

Can be part of a transaction.

func (*BucketRoutingStore) SetOp 

func (r *BucketRoutingStore) SetOp(ctx context.Context, id entity.BucketRoutingPolicyID, toStorage string) OperationStatus

Can be part of a transaction.

func (*BucketRoutingStore) TxExecutor 

func (r *BucketRoutingStore) TxExecutor() Executor[redis.Pipeliner]

func (*BucketRoutingStore) UnblockOp 

func (r *BucketRoutingStore) UnblockOp(ctx context.Context, id entity.BucketRoutingPolicyID) OperationStatus

func (*BucketRoutingStore) WithExecutor 

func (r *BucketRoutingStore) WithExecutor(exec Executor[redis.Pipeliner]) *BucketRoutingStore

type CollectionConverter 

type CollectionConverter[F any, T any] interface {
	ConvertSingle(F) (T, error)
	ConvertMulti([]F) ([]T, error)
}

type ConsistencyCheckIDStore 

type ConsistencyCheckIDStore struct {
	RedisIDKeySet[struct{}, entity.ConsistencyCheckID]
}

func NewConsistencyCheckIDStore 

func NewConsistencyCheckIDStore(client redis.Cmdable) *ConsistencyCheckIDStore

func (*ConsistencyCheckIDStore) WithExecutor 

func (r *ConsistencyCheckIDStore) WithExecutor(exec Executor[redis.Pipeliner]) *ConsistencyCheckIDStore

type ConsistencyCheckListStateStore 

type ConsistencyCheckListStateStore struct {
	RedisIDKeyValue[entity.ConsistencyCheckObjectID, string]
}

func NewConsistencyCheckListStateStore 

func NewConsistencyCheckListStateStore(client redis.Cmdable) *ConsistencyCheckListStateStore

func (*ConsistencyCheckListStateStore) WithExecutor 

func (r *ConsistencyCheckListStateStore) WithExecutor(exec Executor[redis.Pipeliner]) *ConsistencyCheckListStateStore

type ConsistencyCheckSetStore 

type ConsistencyCheckSetStore struct {
	RedisIDKeySet[entity.ConsistencyCheckSetID, entity.ConsistencyCheckSetEntry]
}

func NewConsistencyCheckSetStore 

func NewConsistencyCheckSetStore(client redis.Cmdable) *ConsistencyCheckSetStore

func (*ConsistencyCheckSetStore) Add 

func (r *ConsistencyCheckSetStore) Add(ctx context.Context, id entity.ConsistencyCheckSetID, entry entity.ConsistencyCheckSetEntry, storageCount uint8) error

func (*ConsistencyCheckSetStore) AddOp 

func (r *ConsistencyCheckSetStore) AddOp(ctx context.Context, id entity.ConsistencyCheckSetID, entry entity.ConsistencyCheckSetEntry, storageCount uint8) OperationStatus

func (*ConsistencyCheckSetStore) WithExecutor 

func (r *ConsistencyCheckSetStore) WithExecutor(exec Executor[redis.Pipeliner]) *ConsistencyCheckSetStore

type ConsistencyCheckSettingsStore 

type ConsistencyCheckSettingsStore struct {
	RedisIDKeyValue[entity.ConsistencyCheckID, entity.ConsistencyCheckSettings]
}

func NewConsistencyCheckSettingsStore 

func NewConsistencyCheckSettingsStore(client redis.Cmdable) *ConsistencyCheckSettingsStore

func (*ConsistencyCheckSettingsStore) WithExecutor 

func (r *ConsistencyCheckSettingsStore) WithExecutor(exec Executor[redis.Pipeliner]) *ConsistencyCheckSettingsStore

type ErrorCollector 

type ErrorCollector func() error

type Executor 

type Executor[T any] interface {
	Get() T
	Exec(ctx context.Context) error
}

type Lock 

type Lock struct {
	// contains filtered or unexported fields
}

func NewLock 

func NewLock(logger *zerolog.Logger, lock *redislock.Lock, overlap time.Duration) *Lock

func (*Lock) Do 

func (r *Lock) Do(ctx context.Context, refresh time.Duration, work func() error) error

func (*Lock) Refresh 

func (r *Lock) Refresh(ctx context.Context, duration time.Duration) error

func (*Lock) Release 

func (r *Lock) Release(ctx context.Context)

type LockOpt 

type LockOpt interface {
	// contains filtered or unexported methods
}

func WithDuration 

func WithDuration(d time.Duration) LockOpt

func WithRetry 

func WithRetry(retry bool) LockOpt

type MultiToSingleValueConverter 

type MultiToSingleValueConverter[F any, T any] func([]F) (T, error)

type MultiValueConverter 

type MultiValueConverter[F any, T any] func([]F) ([]T, error)

type Numeric 

type Numeric interface {
	int | int64 | uint64 | float32 | float64
}

type ObjectLocker 

type ObjectLocker struct {
	RedisIDKeyLocker[entity.ObjectLockID]
}

func NewObjectLocker 

func NewObjectLocker(client redis.Cmdable, overlap time.Duration) *ObjectLocker

type ObjectVersionInfoStore 

type ObjectVersionInfoStore struct {
	RedisIDKeyList[entity.VersionedObjectID, rclone.ObjectVersionInfo]
}

func NewObjectVersionInfoStore 

func NewObjectVersionInfoStore(client redis.Cmdable) *ObjectVersionInfoStore

func (*ObjectVersionInfoStore) WithExecutor 

func (r *ObjectVersionInfoStore) WithExecutor(exec Executor[redis.Pipeliner]) *ObjectVersionInfoStore

type OperationResult 

type OperationResult[T any] interface {
	Get() (T, error)
	Status() OperationStatus
}

type OperationStatus 

type OperationStatus interface {
	Get() error
}

type Page 

type Page[T any] struct {
	Entries []T
	Next    uint64
}

type Pager 

type Pager struct {
	From  uint64
	Count uint64
}

func NewPager 

func NewPager(from uint64, count uint64) Pager

type RedisCommonStore 

type RedisCommonStore struct {
	// contains filtered or unexported fields
}

func NewRedisCommonStore 

func NewRedisCommonStore(client redis.Cmdable, keyPrefix string) *RedisCommonStore

func (*RedisCommonStore) GroupExecutor 

func (r *RedisCommonStore) GroupExecutor() *RedisExecutor

func (*RedisCommonStore) JoinParts 

func (r *RedisCommonStore) JoinParts(keyParts ...string) string

func (*RedisCommonStore) MakeKey 

func (r *RedisCommonStore) MakeKey(keyParts ...string) string

func (*RedisCommonStore) MakeWildcardSelector 

func (r *RedisCommonStore) MakeWildcardSelector(keyParts ...string) string

func (*RedisCommonStore) SplitKey 

func (r *RedisCommonStore) SplitKey(key string) []string

func (*RedisCommonStore) TxExecutor 

func (r *RedisCommonStore) TxExecutor() *RedisExecutor

type RedisExecutor 

type RedisExecutor struct {
	// contains filtered or unexported fields
}

func NewRedisExecutor 

func NewRedisExecutor(client redis.Pipeliner) *RedisExecutor

func (*RedisExecutor) Exec 

func (r *RedisExecutor) Exec(ctx context.Context) error

func (*RedisExecutor) Get 

func (r *RedisExecutor) Get() redis.Pipeliner

type RedisFailedOperationResult 

type RedisFailedOperationResult[T any] struct {
	// contains filtered or unexported fields
}

func NewRedisFailedOperationResult 

func NewRedisFailedOperationResult[T any](err error) *RedisFailedOperationResult[T]

func (*RedisFailedOperationResult[T]) Get 

func (r *RedisFailedOperationResult[T]) Get() (T, error)

func (*RedisFailedOperationResult[T]) Status 

func (r *RedisFailedOperationResult[T]) Status() OperationStatus

type RedisFailedOperationStatus 

type RedisFailedOperationStatus struct {
	// contains filtered or unexported fields
}

func NewRedisFailedOperationStatus 

func NewRedisFailedOperationStatus(err error) *RedisFailedOperationStatus

func (*RedisFailedOperationStatus) Get 

func (r *RedisFailedOperationStatus) Get() error

type RedisIDCommonStore 

type RedisIDCommonStore[ID any] struct {
	RedisCommonStore
	// contains filtered or unexported fields
}

func NewRedisIDCommonStore 

func NewRedisIDCommonStore[ID any](client redis.Cmdable, keyPrefix string, tokenizeID SingleToMultiValueConverter[ID, string], restoreID MultiToSingleValueConverter[string, ID]) *RedisIDCommonStore[ID]

func (*RedisIDCommonStore[ID]) Drop 

func (r *RedisIDCommonStore[ID]) Drop(ctx context.Context, id ID) (uint64, error)

func (*RedisIDCommonStore[ID]) DropIDs 

func (r *RedisIDCommonStore[ID]) DropIDs(ctx context.Context, keyParts ...string) (uint64, error)

func (*RedisIDCommonStore[ID]) DropIDsOp 

func (r *RedisIDCommonStore[ID]) DropIDsOp(ctx context.Context, keyParts ...string) OperationResult[uint64]

func (*RedisIDCommonStore[ID]) DropOp 

func (r *RedisIDCommonStore[ID]) DropOp(ctx context.Context, id ID) OperationResult[uint64]

func (*RedisIDCommonStore[ID]) GetAllIDs 

func (r *RedisIDCommonStore[ID]) GetAllIDs(ctx context.Context, keyParts ...string) ([]ID, error)

func (*RedisIDCommonStore[ID]) GetIDs 

func (r *RedisIDCommonStore[ID]) GetIDs(ctx context.Context, pager Pager, keyParts ...string) (Page[ID], error)

func (*RedisIDCommonStore[ID]) GetIDsOp 

func (r *RedisIDCommonStore[ID]) GetIDsOp(ctx context.Context, pager Pager, keyParts ...string) OperationResult[Page[ID]]

func (*RedisIDCommonStore[ID]) HasIDs 

func (r *RedisIDCommonStore[ID]) HasIDs(ctx context.Context, keyParts ...string) (bool, error)

func (*RedisIDCommonStore[ID]) HasIDsOp 

func (r *RedisIDCommonStore[ID]) HasIDsOp(ctx context.Context, keyParts ...string) OperationResult[bool]

func (*RedisIDCommonStore[ID]) MakeKey 

func (r *RedisIDCommonStore[ID]) MakeKey(id ID) (string, error)

func (*RedisIDCommonStore[ID]) RestoreID 

func (r *RedisIDCommonStore[ID]) RestoreID(key string) (ID, error)

type RedisIDKeyCounter 

type RedisIDKeyCounter[ID any, V Numeric] struct {
	RedisIDKeyValue[ID, V]
}

func NewRedisIDKeyCounter 

func NewRedisIDKeyCounter[ID any, V Numeric](client redis.Cmdable, keyPrefix string,
	tokenizeID SingleToMultiValueConverter[ID, string], restoreID MultiToSingleValueConverter[string, ID]) *RedisIDKeyCounter[ID, V]

func (*RedisIDKeyCounter[ID, V]) Decrement 

func (r *RedisIDKeyCounter[ID, V]) Decrement(ctx context.Context, id ID) (V, error)

func (*RedisIDKeyCounter[ID, V]) DecrementByN 

func (r *RedisIDKeyCounter[ID, V]) DecrementByN(ctx context.Context, id ID, n V) (V, error)

func (*RedisIDKeyCounter[ID, V]) DecrementByNOp 

func (r *RedisIDKeyCounter[ID, V]) DecrementByNOp(ctx context.Context, id ID, n V) OperationResult[V]

func (*RedisIDKeyCounter[ID, V]) DecrementOp 

func (r *RedisIDKeyCounter[ID, V]) DecrementOp(ctx context.Context, id ID) OperationResult[V]

func (*RedisIDKeyCounter[ID, V]) Increment 

func (r *RedisIDKeyCounter[ID, V]) Increment(ctx context.Context, id ID) (V, error)

func (*RedisIDKeyCounter[ID, V]) IncrementByN 

func (r *RedisIDKeyCounter[ID, V]) IncrementByN(ctx context.Context, id ID, n V) (V, error)

func (*RedisIDKeyCounter[ID, V]) IncrementByNOp 

func (r *RedisIDKeyCounter[ID, V]) IncrementByNOp(ctx context.Context, id ID, n V) OperationResult[V]

func (*RedisIDKeyCounter[ID, V]) IncrementOp 

func (r *RedisIDKeyCounter[ID, V]) IncrementOp(ctx context.Context, id ID) OperationResult[V]

func (*RedisIDKeyCounter[ID, V]) WithExecutorProvider 

func (r *RedisIDKeyCounter[ID, V]) WithExecutorProvider(executor Executor[redis.Cmdable]) *RedisIDKeyCounter[ID, V]

type RedisIDKeyHash 

type RedisIDKeyHash[ID any, V any] struct {
	RedisIDCommonStore[ID]
}

func NewRedisIDKeyHash 

func NewRedisIDKeyHash[ID any, V any](client redis.Cmdable, keyPrefix string,
	tokenizeID SingleToMultiValueConverter[ID, string], restoreID MultiToSingleValueConverter[string, ID]) *RedisIDKeyHash[ID, V]

func (*RedisIDKeyHash[ID, V]) DelField 

func (r *RedisIDKeyHash[ID, V]) DelField(ctx context.Context, id ID, fieldName string) (uint64, error)

func (*RedisIDKeyHash[ID, V]) DelFieldOp 

func (r *RedisIDKeyHash[ID, V]) DelFieldOp(ctx context.Context, id ID, fieldName string) OperationResult[uint64]

func (*RedisIDKeyHash[ID, V]) Get 

func (r *RedisIDKeyHash[ID, V]) Get(ctx context.Context, id ID) (V, error)

func (*RedisIDKeyHash[ID, V]) GetField 

func (r *RedisIDKeyHash[ID, V]) GetField(ctx context.Context, id ID, fieldName string) (string, error)

func (*RedisIDKeyHash[ID, V]) GetFieldOp 

func (r *RedisIDKeyHash[ID, V]) GetFieldOp(ctx context.Context, id ID, fieldName string) OperationResult[string]

func (*RedisIDKeyHash[ID, V]) GetOp 

func (r *RedisIDKeyHash[ID, V]) GetOp(ctx context.Context, id ID) OperationResult[V]

func (*RedisIDKeyHash[ID, V]) IncrementField 

func (r *RedisIDKeyHash[ID, V]) IncrementField(ctx context.Context, id ID, fieldName string) (int64, error)

func (*RedisIDKeyHash[ID, V]) IncrementFieldByN 

func (r *RedisIDKeyHash[ID, V]) IncrementFieldByN(ctx context.Context, id ID, fieldName string, value int64) (int64, error)

func (*RedisIDKeyHash[ID, V]) IncrementFieldByNIfExists 

func (r *RedisIDKeyHash[ID, V]) IncrementFieldByNIfExists(ctx context.Context, id ID, fieldName string, value int64) (int64, error)

func (*RedisIDKeyHash[ID, V]) IncrementFieldByNIfExistsOp 

func (r *RedisIDKeyHash[ID, V]) IncrementFieldByNIfExistsOp(ctx context.Context, id ID, fieldName string, value int64) OperationResult[int64]

func (*RedisIDKeyHash[ID, V]) IncrementFieldByNOp 

func (r *RedisIDKeyHash[ID, V]) IncrementFieldByNOp(ctx context.Context, id ID, fieldName string, value int64) OperationResult[int64]

func (*RedisIDKeyHash[ID, V]) IncrementFieldIfExists 

func (r *RedisIDKeyHash[ID, V]) IncrementFieldIfExists(ctx context.Context, id ID, fieldName string) (int64, error)

func (*RedisIDKeyHash[ID, V]) IncrementFieldIfExistsOp 

func (r *RedisIDKeyHash[ID, V]) IncrementFieldIfExistsOp(ctx context.Context, id ID, fieldName string) OperationResult[int64]

func (*RedisIDKeyHash[ID, V]) IncrementFieldOp 

func (r *RedisIDKeyHash[ID, V]) IncrementFieldOp(ctx context.Context, id ID, fieldName string) OperationResult[int64]

func (*RedisIDKeyHash[ID, V]) Len 

func (r *RedisIDKeyHash[ID, V]) Len(ctx context.Context, id ID) (int64, error)

func (*RedisIDKeyHash[ID, V]) LenOp 

func (r *RedisIDKeyHash[ID, V]) LenOp(ctx context.Context, id ID) OperationResult[int64]

func (*RedisIDKeyHash[ID, V]) Set 

func (r *RedisIDKeyHash[ID, V]) Set(ctx context.Context, id ID, value V) error

func (*RedisIDKeyHash[ID, V]) SetField 

func (r *RedisIDKeyHash[ID, V]) SetField(ctx context.Context, id ID, fieldName string, value any) (uint64, error)

func (*RedisIDKeyHash[ID, V]) SetFieldIfExists 

func (r *RedisIDKeyHash[ID, V]) SetFieldIfExists(ctx context.Context, id ID, fieldName string, value any) error

func (*RedisIDKeyHash[ID, V]) SetFieldIfExistsOp 

func (r *RedisIDKeyHash[ID, V]) SetFieldIfExistsOp(ctx context.Context, id ID, fieldName string, value any) OperationStatus

func (*RedisIDKeyHash[ID, V]) SetFieldOp 

func (r *RedisIDKeyHash[ID, V]) SetFieldOp(ctx context.Context, id ID, fieldName string, value any) OperationResult[uint64]

func (*RedisIDKeyHash[ID, V]) SetOp 

func (r *RedisIDKeyHash[ID, V]) SetOp(ctx context.Context, id ID, value V) OperationStatus

type RedisIDKeyList 

type RedisIDKeyList[ID any, V any] struct {
	RedisIDCommonStore[ID]
	// contains filtered or unexported fields
}

func NewRedisIDKeyList 

func NewRedisIDKeyList[ID any, V any](client redis.Cmdable, idPrefix string,
	tokenizeID SingleToMultiValueConverter[ID, string], restoreID MultiToSingleValueConverter[string, ID],
	serializeValue SingleValueConverter[V, string], deserializeValue SingleValueConverter[string, V]) *RedisIDKeyList[ID, V]

func (*RedisIDKeyList[ID, V]) AddLeft 

func (r *RedisIDKeyList[ID, V]) AddLeft(ctx context.Context, id ID, values ...V) error

func (*RedisIDKeyList[ID, V]) AddLeftOp 

func (r *RedisIDKeyList[ID, V]) AddLeftOp(ctx context.Context, id ID, values ...V) OperationStatus

func (*RedisIDKeyList[ID, V]) AddRight 

func (r *RedisIDKeyList[ID, V]) AddRight(ctx context.Context, id ID, values ...V) error

func (*RedisIDKeyList[ID, V]) AddRightOp 

func (r *RedisIDKeyList[ID, V]) AddRightOp(ctx context.Context, id ID, values ...V) OperationStatus

func (*RedisIDKeyList[ID, V]) Find 

func (r *RedisIDKeyList[ID, V]) Find(ctx context.Context, id ID, value V) (int64, error)

func (*RedisIDKeyList[ID, V]) FindOp 

func (r *RedisIDKeyList[ID, V]) FindOp(ctx context.Context, id ID, value V) OperationResult[int64]

func (*RedisIDKeyList[ID, V]) GetAll 

func (r *RedisIDKeyList[ID, V]) GetAll(ctx context.Context, id ID) ([]V, error)

func (*RedisIDKeyList[ID, V]) GetAllOp 

func (r *RedisIDKeyList[ID, V]) GetAllOp(ctx context.Context, id ID) OperationResult[[]V]

func (*RedisIDKeyList[ID, V]) GetLeft 

func (r *RedisIDKeyList[ID, V]) GetLeft(ctx context.Context, id ID) (V, error)

Get first element from left end

func (*RedisIDKeyList[ID, V]) GetLeftOp 

func (r *RedisIDKeyList[ID, V]) GetLeftOp(ctx context.Context, id ID) OperationResult[V]

func (*RedisIDKeyList[ID, V]) GetOne 

func (r *RedisIDKeyList[ID, V]) GetOne(ctx context.Context, id ID, idx uint64) (V, error)

Get element at index

func (*RedisIDKeyList[ID, V]) GetOneOp 

func (r *RedisIDKeyList[ID, V]) GetOneOp(ctx context.Context, id ID, idx uint64) OperationResult[V]

func (*RedisIDKeyList[ID, V]) GetPage 

func (r *RedisIDKeyList[ID, V]) GetPage(ctx context.Context, id ID, pager Pager) ([]V, error)

func (*RedisIDKeyList[ID, V]) GetPageOp 

func (r *RedisIDKeyList[ID, V]) GetPageOp(ctx context.Context, id ID, pager Pager) OperationResult[[]V]

func (*RedisIDKeyList[ID, V]) GetRight 

func (r *RedisIDKeyList[ID, V]) GetRight(ctx context.Context, id ID) (V, error)

Get first element from right end

func (*RedisIDKeyList[ID, V]) GetRightOp 

func (r *RedisIDKeyList[ID, V]) GetRightOp(ctx context.Context, id ID) OperationResult[V]

type RedisIDKeyLocker 

type RedisIDKeyLocker[ID any] struct {
	RedisIDCommonStore[ID]
	// contains filtered or unexported fields
}

func NewRedisIDKeyLocker 

func NewRedisIDKeyLocker[ID any](client redis.Cmdable, keyPrefix string,
	tokenizeID SingleToMultiValueConverter[ID, string], restoreID MultiToSingleValueConverter[string, ID],
	overlap time.Duration) *RedisIDKeyLocker[ID]

func (*RedisIDKeyLocker[ID]) Lock 

func (r *RedisIDKeyLocker[ID]) Lock(ctx context.Context, id ID, opts ...LockOpt) (*Lock, error)

type RedisIDKeySet 

type RedisIDKeySet[ID any, V any] struct {
	RedisIDCommonStore[ID]
	// contains filtered or unexported fields
}

func NewRedisIDKeySet 

func NewRedisIDKeySet[ID any, V any](client redis.Cmdable, idPrefix string,
	tokenizeID SingleToMultiValueConverter[ID, string], restoreID MultiToSingleValueConverter[string, ID],
	serializeValue SingleValueConverter[V, string], deserializeValue SingleValueConverter[string, V]) *RedisIDKeySet[ID, V]

func (*RedisIDKeySet[ID, V]) Add 

func (r *RedisIDKeySet[ID, V]) Add(ctx context.Context, id ID, values ...V) (uint64, error)

func (*RedisIDKeySet[ID, V]) AddOp 

func (r *RedisIDKeySet[ID, V]) AddOp(ctx context.Context, id ID, values ...V) OperationResult[uint64]

func (*RedisIDKeySet[ID, V]) Get 

func (r *RedisIDKeySet[ID, V]) Get(ctx context.Context, id ID) ([]V, error)

func (*RedisIDKeySet[ID, V]) GetOp 

func (r *RedisIDKeySet[ID, V]) GetOp(ctx context.Context, id ID) OperationResult[[]V]

func (*RedisIDKeySet[ID, V]) IsMember 

func (r *RedisIDKeySet[ID, V]) IsMember(ctx context.Context, id ID, value V) (bool, error)

func (*RedisIDKeySet[ID, V]) IsMemberOp 

func (r *RedisIDKeySet[ID, V]) IsMemberOp(ctx context.Context, id ID, value V) OperationResult[bool]

func (*RedisIDKeySet[ID, V]) Remove 

func (r *RedisIDKeySet[ID, V]) Remove(ctx context.Context, id ID, values ...V) (uint64, error)

func (*RedisIDKeySet[ID, V]) RemoveOp 

func (r *RedisIDKeySet[ID, V]) RemoveOp(ctx context.Context, id ID, values ...V) OperationResult[uint64]

type RedisIDKeySortedSet 

type RedisIDKeySortedSet[ID any, V any, S any] struct {
	RedisIDCommonStore[ID]
	// contains filtered or unexported fields
}

func NewRedisIDKeySortedSet 

func NewRedisIDKeySortedSet[ID any, V any, S any](client redis.Cmdable, idPrefix string,
	tokenizeID SingleToMultiValueConverter[ID, string], restoreID MultiToSingleValueConverter[string, ID],
	serializeValue SingleValueConverter[V, string], deserializeValue SingleValueConverter[string, V],
	serializeScore SingleValueConverter[S, float64], deserializeScore SingleValueConverter[float64, S]) *RedisIDKeySortedSet[ID, V, S]

func (*RedisIDKeySortedSet[ID, V, S]) Add 

func (r *RedisIDKeySortedSet[ID, V, S]) Add(ctx context.Context, id ID, values ...ScoredSetEntry[V, S]) (uint64, error)

func (*RedisIDKeySortedSet[ID, V, S]) AddIfNotExists 

func (r *RedisIDKeySortedSet[ID, V, S]) AddIfNotExists(ctx context.Context, id ID, values ...ScoredSetEntry[V, S]) (uint64, error)

func (*RedisIDKeySortedSet[ID, V, S]) AddIfNotExistsOp 

func (r *RedisIDKeySortedSet[ID, V, S]) AddIfNotExistsOp(ctx context.Context, id ID, values ...ScoredSetEntry[V, S]) OperationResult[uint64]

func (*RedisIDKeySortedSet[ID, V, S]) AddOp 

func (r *RedisIDKeySortedSet[ID, V, S]) AddOp(ctx context.Context, id ID, values ...ScoredSetEntry[V, S]) OperationResult[uint64]

func (*RedisIDKeySortedSet[ID, V, S]) GetAll 

func (r *RedisIDKeySortedSet[ID, V, S]) GetAll(ctx context.Context, id ID) ([]ScoredSetEntry[V, S], error)

func (*RedisIDKeySortedSet[ID, V, S]) GetAllOp 

func (r *RedisIDKeySortedSet[ID, V, S]) GetAllOp(ctx context.Context, id ID) OperationResult[[]ScoredSetEntry[V, S]]

func (*RedisIDKeySortedSet[ID, V, S]) IsMember 

func (r *RedisIDKeySortedSet[ID, V, S]) IsMember(ctx context.Context, id ID, value V) (bool, error)

func (*RedisIDKeySortedSet[ID, V, S]) IsMemberOp 

func (r *RedisIDKeySortedSet[ID, V, S]) IsMemberOp(ctx context.Context, id ID, value V) OperationResult[bool]

func (*RedisIDKeySortedSet[ID, V, S]) Remove 

func (r *RedisIDKeySortedSet[ID, V, S]) Remove(ctx context.Context, id ID, values ...V) (uint64, error)

func (*RedisIDKeySortedSet[ID, V, S]) RemoveOp 

func (r *RedisIDKeySortedSet[ID, V, S]) RemoveOp(ctx context.Context, id ID, values ...V) OperationResult[uint64]

func (*RedisIDKeySortedSet[ID, V, S]) Size 

func (r *RedisIDKeySortedSet[ID, V, S]) Size(ctx context.Context, id ID) (uint64, error)

func (*RedisIDKeySortedSet[ID, V, S]) SizeOp 

func (r *RedisIDKeySortedSet[ID, V, S]) SizeOp(ctx context.Context, id ID) OperationResult[uint64]

type RedisIDKeyValue 

type RedisIDKeyValue[ID any, V any] struct {
	RedisIDCommonStore[ID]
	// contains filtered or unexported fields
}

func NewRedisIDKeyValue 

func NewRedisIDKeyValue[ID any, V any](
	client redis.Cmdable, keyPrefix string,
	tokenizeID SingleToMultiValueConverter[ID, string], restoreID MultiToSingleValueConverter[string, ID],
	serializeValue SingleValueConverter[V, string], deserializeValue SingleValueConverter[string, V]) *RedisIDKeyValue[ID, V]

func (*RedisIDKeyValue[ID, V]) Get 

func (r *RedisIDKeyValue[ID, V]) Get(ctx context.Context, id ID) (V, error)

func (*RedisIDKeyValue[ID, V]) GetOp 

func (r *RedisIDKeyValue[ID, V]) GetOp(ctx context.Context, id ID) OperationResult[V]

func (*RedisIDKeyValue[ID, V]) Set 

func (r *RedisIDKeyValue[ID, V]) Set(ctx context.Context, id ID, value V) error

func (*RedisIDKeyValue[ID, V]) SetIfNotExists 

func (r *RedisIDKeyValue[ID, V]) SetIfNotExists(ctx context.Context, id ID, value V) error

func (*RedisIDKeyValue[ID, V]) SetIfNotExistsOp 

func (r *RedisIDKeyValue[ID, V]) SetIfNotExistsOp(ctx context.Context, id ID, value V) OperationStatus

func (*RedisIDKeyValue[ID, V]) SetOp 

func (r *RedisIDKeyValue[ID, V]) SetOp(ctx context.Context, id ID, value V) OperationStatus

type RedisOperationResult 

type RedisOperationResult[T any] struct {
	// contains filtered or unexported fields
}

func NewRedisOperationResult 

func NewRedisOperationResult[T any](collect ValueCollector[T]) *RedisOperationResult[T]

func (*RedisOperationResult[T]) Get 

func (r *RedisOperationResult[T]) Get() (T, error)

func (*RedisOperationResult[T]) Status 

func (r *RedisOperationResult[T]) Status() OperationStatus

type RedisOperationStatus 

type RedisOperationStatus struct {
	// contains filtered or unexported fields
}

func JoinRedisOperationStatus 

func JoinRedisOperationStatus(message string, in ...OperationStatus) *RedisOperationStatus

func JoinRedisOperationStatusWithMessages 

func JoinRedisOperationStatusWithMessages(message string, in map[string]OperationStatus) *RedisOperationStatus

func NewRedisOperationStatus 

func NewRedisOperationStatus(confirm ErrorCollector) *RedisOperationStatus

func (*RedisOperationStatus) Get 

func (r *RedisOperationStatus) Get() error

type ReplicationStatusLocker 

type ReplicationStatusLocker struct {
	RedisIDKeyLocker[entity.UniversalReplicationID]
}

func NewReplicationStatusLocker 

func NewReplicationStatusLocker(client redis.Cmdable, overlap time.Duration) *ReplicationStatusLocker

type ScoredSetEntry 

type ScoredSetEntry[V any, S any] struct {
	Value V
	Score S
}

func NewScoredSetEntry 

func NewScoredSetEntry[V any, S any](value V, score S) *ScoredSetEntry[V, S]

type ScoredSetEntryToZConverter 

type ScoredSetEntryToZConverter[V any, S any] struct {
	// contains filtered or unexported fields
}

func NewScoredSetEntryToZConverter 

func NewScoredSetEntryToZConverter[V any, S any](
	convertValue SingleValueConverter[V, string], convertScore SingleValueConverter[S, float64]) *ScoredSetEntryToZConverter[V, S]

func (*ScoredSetEntryToZConverter[V, S]) Convert 

func (r *ScoredSetEntryToZConverter[V, S]) Convert(entry ScoredSetEntry[V, S]) (redis.Z, error)

type SimpleCollectionConverter 

type SimpleCollectionConverter[F any, T any] struct {
	// contains filtered or unexported fields
}

func NewSimpleCollectionConverter 

func NewSimpleCollectionConverter[F any, T any](convert SingleValueConverter[F, T]) *SimpleCollectionConverter[F, T]

func (*SimpleCollectionConverter[F, T]) ConvertMulti 

func (r *SimpleCollectionConverter[F, T]) ConvertMulti(values []F) ([]T, error)

func (*SimpleCollectionConverter[F, T]) ConvertSingle 

func (r *SimpleCollectionConverter[F, T]) ConvertSingle(value F) (T, error)

type SingleToMultiValueConverter 

type SingleToMultiValueConverter[F any, T any] func(F) ([]T, error)

type SingleValueConverter 

type SingleValueConverter[F any, T any] func(F) (T, error)

type UserLocker 

type UserLocker struct {
	RedisIDKeyLocker[string]
}

func NewUserLocker 

func NewUserLocker(client redis.Cmdable, overlap time.Duration) *UserLocker

type UserReplicationPolicyStore 

type UserReplicationPolicyStore struct {
	// contains filtered or unexported fields
}

func NewUserReplicationPolicyStore 

func NewUserReplicationPolicyStore(client redis.Cmdable) *UserReplicationPolicyStore

func (*UserReplicationPolicyStore) AddOp 

func (r *UserReplicationPolicyStore) AddOp(ctx context.Context, id entity.UserReplicationPolicy) OperationStatus

Add adds a new user replication policy. Validation must be done before calling this method. Can be part of a transaction.

func (*UserReplicationPolicyStore) Get 

func (r *UserReplicationPolicyStore) Get(ctx context.Context, user string) ([]entity.UserReplicationPolicy, error)

func (*UserReplicationPolicyStore) GetOp 

func (r *UserReplicationPolicyStore) GetOp(ctx context.Context, user string) OperationResult[[]entity.UserReplicationPolicy]

func (*UserReplicationPolicyStore) RemoveOp 

func (r *UserReplicationPolicyStore) RemoveOp(ctx context.Context, id entity.UserReplicationPolicy) OperationStatus

func (*UserReplicationPolicyStore) TxExecutor 

func (r *UserReplicationPolicyStore) TxExecutor() Executor[redis.Pipeliner]

func (*UserReplicationPolicyStore) WithExecutor 

func (r *UserReplicationPolicyStore) WithExecutor(exec Executor[redis.Pipeliner]) *UserReplicationPolicyStore

type UserReplicationStatusStore 

type UserReplicationStatusStore struct {
	// contains filtered or unexported fields
}

func NewUserReplicationStatusStore 

func NewUserReplicationStatusStore(client redis.Cmdable) *UserReplicationStatusStore

func (*UserReplicationStatusStore) AddOp 

func (r *UserReplicationStatusStore) AddOp(ctx context.Context, id entity.UserReplicationPolicy, status entity.ReplicationStatus) OperationStatus

func (*UserReplicationStatusStore) ArchieveOp 

func (r *UserReplicationStatusStore) ArchieveOp(ctx context.Context, id entity.UserReplicationPolicy) OperationStatus

func (*UserReplicationStatusStore) DeleteOp 

func (r *UserReplicationStatusStore) DeleteOp(ctx context.Context, id entity.UserReplicationPolicy) OperationStatus

func (*UserReplicationStatusStore) GetOp 

func (r *UserReplicationStatusStore) GetOp(ctx context.Context, id entity.UserReplicationPolicy) OperationResult[entity.ReplicationStatus]

func (*UserReplicationStatusStore) List 

func (r *UserReplicationStatusStore) List(ctx context.Context) (map[entity.UserReplicationPolicy]entity.ReplicationStatus, error)

func (*UserReplicationStatusStore) TxExecutor 

func (r *UserReplicationStatusStore) TxExecutor() Executor[redis.Pipeliner]

func (*UserReplicationStatusStore) WithExecutor 

func (r *UserReplicationStatusStore) WithExecutor(exec Executor[redis.Pipeliner]) *UserReplicationStatusStore

type UserReplicationSwitchStore 

type UserReplicationSwitchStore struct {
	// contains filtered or unexported fields
}

func NewUserReplicationSwitchStore 

func NewUserReplicationSwitchStore(client redis.Cmdable) *UserReplicationSwitchStore

func (*UserReplicationSwitchStore) Create 

func (r *UserReplicationSwitchStore) Create(ctx context.Context, replicationID entity.UserReplicationPolicy, value entity.ReplicationSwitchInfo) error

func (*UserReplicationSwitchStore) CreateOp 

func (r *UserReplicationSwitchStore) CreateOp(ctx context.Context, replicationID entity.UserReplicationPolicy, value entity.ReplicationSwitchInfo) OperationStatus

func (*UserReplicationSwitchStore) DeleteOp 

func (r *UserReplicationSwitchStore) DeleteOp(ctx context.Context, user string) OperationStatus

func (*UserReplicationSwitchStore) Get 

func (r *UserReplicationSwitchStore) Get(ctx context.Context, user string) (entity.ReplicationSwitchInfo, error)

func (*UserReplicationSwitchStore) GetOp 

func (r *UserReplicationSwitchStore) GetOp(ctx context.Context, user string) OperationResult[entity.ReplicationSwitchInfo]

func (*UserReplicationSwitchStore) IsZeroDowntimeActiveOp 

func (r *UserReplicationSwitchStore) IsZeroDowntimeActiveOp(ctx context.Context, user string) OperationResult[bool]

func (*UserReplicationSwitchStore) TxExecutor 

func (r *UserReplicationSwitchStore) TxExecutor() Executor[redis.Pipeliner]

func (*UserReplicationSwitchStore) UpdateDowntimeOpts 

func (r *UserReplicationSwitchStore) UpdateDowntimeOpts(ctx context.Context, replication entity.UserReplicationPolicy, value *entity.ReplicationSwitchDowntimeOpts) error

func (*UserReplicationSwitchStore) UpdateDowntimeOptsOp 

func (r *UserReplicationSwitchStore) UpdateDowntimeOptsOp(ctx context.Context, id entity.UserReplicationPolicy, value *entity.ReplicationSwitchDowntimeOpts) OperationStatus

func (*UserReplicationSwitchStore) UpdateStatusOp 

func (r *UserReplicationSwitchStore) UpdateStatusOp(ctx context.Context, replicationID entity.UserReplicationPolicy, prevStatus, newStatus entity.ReplicationSwitchStatus, message string) OperationStatus

func (*UserReplicationSwitchStore) WithExecutor 

func (r *UserReplicationSwitchStore) WithExecutor(exec Executor[redis.Pipeliner]) *UserReplicationSwitchStore

type UserRoutingStore 

type UserRoutingStore struct {
	// contains filtered or unexported fields
}

func NewUserRoutingStore 

func NewUserRoutingStore(client redis.Cmdable) *UserRoutingStore

func (*UserRoutingStore) BlockOp 

func (r *UserRoutingStore) BlockOp(ctx context.Context, user string) OperationStatus

func (*UserRoutingStore) DeleteOp 

func (r *UserRoutingStore) DeleteOp(ctx context.Context, user string) OperationStatus

func (*UserRoutingStore) GetOp 

func (r *UserRoutingStore) GetOp(ctx context.Context, user string) OperationResult[string]

func (*UserRoutingStore) SetOp 

func (r *UserRoutingStore) SetOp(ctx context.Context, user, toStorage string) OperationStatus

func (*UserRoutingStore) TxExecutor 

func (r *UserRoutingStore) TxExecutor() Executor[redis.Pipeliner]

func (*UserRoutingStore) UnblockOp 

func (r *UserRoutingStore) UnblockOp(ctx context.Context, user string) OperationStatus

func (*UserRoutingStore) WithExecutor 

func (r *UserRoutingStore) WithExecutor(exec Executor[redis.Pipeliner]) *UserRoutingStore

type ValueCollector 

type ValueCollector[V any] func() (V, error)

type ZToScoredSetEntryConverter 

type ZToScoredSetEntryConverter[V any, S any] struct {
	// contains filtered or unexported fields
}

func NewZToScoredSetEntryConverter 

func NewZToScoredSetEntryConverter[V any, S any](
	convertValue SingleValueConverter[string, V], convertScore SingleValueConverter[float64, S]) *ZToScoredSetEntryConverter[V, S]

func (*ZToScoredSetEntryConverter[V, S]) Convert 

func (r *ZToScoredSetEntryConverter[V, S]) Convert(entry redis.Z) (ScoredSetEntry[V, S], error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.