redsync

package module
v4.0.5-0...-a871a9a Latest Latest
Warning

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

Go to latest
Published: Feb 4, 2021 License: BSD-3-Clause Imports: 7 Imported by: 0

README

Redsync

Build Status

Redsync provides a Redis-based distributed mutual exclusion lock implementation for Go as described in this post. A reference library (by antirez) for Ruby is available at github.com/antirez/redlock-rb.

Installation

Install Redsync using the go get command:

$ go get github.com/go-redsync/redsync/v4

Two driver implementations will be installed; however, only the one used will be included in your project.

See the examples folder for usage of each driver.

Documentation

Usage

Error handling is simplified to panic for shorter example.

package main

import (
	goredislib "github.com/go-redis/redis/v8"
	"github.com/go-redsync/redsync/v4"
	"github.com/go-redsync/redsync/v4/redis/goredis/v8"
)

func main() {
	// Create a pool with go-redis (or redigo) which is the pool redisync will
	// use while communicating with Redis. This can also be any pool that
	// implements the `redis.Pool` interface.
	client := goredislib.NewClient(&goredislib.Options{
		Addr: "localhost:6379",
	})
	pool := goredis.NewPool(client) // or, pool := redigo.NewPool(...)

	// Create an instance of redisync to be used to obtain a mutual exclusion
	// lock.
	rs := redsync.New(pool)

	// Obtain a new mutex by using the same name for all instances wanting the
	// same lock.
	mutexname := "my-global-mutex"
	mutex := rs.NewMutex(mutexname)

	// Obtain a lock for our given mutex. After this is successful, no one else
	// can obtain the same lock (the same mutex name) until we unlock it.
	if err := mutex.Lock(); err != nil {
		panic(err)
	}

	// Do your work that requires the lock.

	// Release the lock so other processes or threads can obtain a lock.
	if ok, err := mutex.Unlock(); !ok || err != nil {
		panic("unlock failed")
	}
}

Contributing

Contributions are welcome.

License

Redsync is available under the BSD (3-Clause) License.

Disclaimer

This code implements an algorithm which is currently a proposal, it was not formally analyzed. Make sure to understand how it works before using it in production environments.

Documentation

Overview

Package redsync provides a Redis-based distributed mutual exclusion lock implementation as described in the post http://redis.io/topics/distlock.

Values containing the types defined in this package should not be copied.

Index

Constants

This section is empty.

Variables

View Source
var ErrFailed = errors.New("redsync: failed to acquire lock")

Functions

This section is empty.

Types

type DelayFunc

type DelayFunc func(tries int) time.Duration

A DelayFunc is used to decide the amount of time to wait between retries.

type Mutex

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

A Mutex is a distributed mutual exclusion lock.

func (*Mutex) Extend

func (m *Mutex) Extend() (bool, error)

Extend resets the mutex's expiry and returns the status of expiry extension.

func (*Mutex) ExtendContext

func (m *Mutex) ExtendContext(ctx context.Context) (bool, error)

Extend resets the mutex's expiry and returns the status of expiry extension.

func (*Mutex) Lock

func (m *Mutex) Lock() error

Lock locks m. In case it returns an error on failure, you may retry to acquire the lock by calling this method again.

func (*Mutex) LockContext

func (m *Mutex) LockContext(ctx context.Context) error

Lock locks m. In case it returns an error on failure, you may retry to acquire the lock by calling this method again.

func (*Mutex) Unlock

func (m *Mutex) Unlock() (bool, error)

Unlock unlocks m and returns the status of unlock.

func (*Mutex) UnlockContext

func (m *Mutex) UnlockContext(ctx context.Context) (bool, error)

Unlock unlocks m and returns the status of unlock.

func (*Mutex) Valid

func (m *Mutex) Valid() (bool, error)

func (*Mutex) ValidContext

func (m *Mutex) ValidContext(ctx context.Context) (bool, error)

type Option

type Option interface {
	Apply(*Mutex)
}

An Option configures a mutex.

func WithDriftFactor

func WithDriftFactor(factor float64) Option

WithDriftFactor can be used to set the clock drift factor.

func WithExpiry

func WithExpiry(expiry time.Duration) Option

WithExpiry can be used to set the expiry of a mutex to the given value.

func WithGenValueFunc

func WithGenValueFunc(genValueFunc func() (string, error)) Option

WithGenValueFunc can be used to set the custom value generator.

func WithRetryDelay

func WithRetryDelay(delay time.Duration) Option

WithRetryDelay can be used to set the amount of time to wait between retries.

func WithRetryDelayFunc

func WithRetryDelayFunc(delayFunc DelayFunc) Option

WithRetryDelayFunc can be used to override default delay behavior.

func WithTries

func WithTries(tries int) Option

WithTries can be used to set the number of times lock acquire is attempted.

type OptionFunc

type OptionFunc func(*Mutex)

OptionFunc is a function that configures a mutex.

func (OptionFunc) Apply

func (f OptionFunc) Apply(mutex *Mutex)

Apply calls f(mutex)

type Redsync

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

Redsync provides a simple method for creating distributed mutexes using multiple Redis connection pools.

func New

func New(pools ...redis.Pool) *Redsync

New creates and returns a new Redsync instance from given Redis connection pools.

func (*Redsync) NewMutex

func (r *Redsync) NewMutex(name string, options ...Option) *Mutex

NewMutex returns a new distributed mutex with given name.

Directories

Path Synopsis
examples

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL