locker

README

go-locker

Distributed locking using Redis.

Example usage:

import (
	"context"
	"fmt"
	"sync"
	"time"

	"github.com/da440dil/go-locker"
	"github.com/go-redis/redis/v8"
)

func main() {
	client := redis.NewClient(&redis.Options{})
	defer client.Close()

	// Create locker.
	lkr := locker.NewLocker(client)
	ctx := context.Background()
	key := "key"
	err := client.Del(ctx, key).Err()
	requireNoError(err)

	lock := func() {
		// Try to apply lock.
		lr, err := lkr.Lock(ctx, key, time.Second)
		requireNoError(err)
		if !lr.OK() {
			fmt.Printf("Failed to apply lock, retry after %v\n", lr.TTL())
			return
		}
		fmt.Println("Lock applied")

		// Try to release lock.
		defer func() {
			ok, err := lr.Unlock(ctx)
			requireNoError(err)
			if ok {
				fmt.Println("Lock released")
			} else {
				fmt.Println("Failed to release lock")
			}
		}()

		time.Sleep(time.Millisecond * 100) // some code here

		// Optionally try to extend lock.
		r, err := lr.Lock.Lock(ctx, time.Second)
		requireNoError(err)
		if !r.OK() {
			fmt.Printf("Failed to extend lock, retry after %v\n", lr.TTL())
			return
		}
		fmt.Println("Lock extended")
	}

	var wg sync.WaitGroup
	wg.Add(2)
	for i := 0; i < 2; i++ {
		go func() {
			defer wg.Done()
			lock()
		}()
	}
	wg.Wait()
	// Output:
	// Lock applied
	// Failed to apply lock, retry after 999ms
	// Lock extended
	// Lock released
}

func requireNoError(err error) {
	if err != nil {
		panic(err)
	}
}

Documentation

Overview

Package locker provides functions for distributed locking.

Index

• Variables
• type Lock
  • func (lock Lock) Lock(ctx context.Context, ttl time.Duration) (Result, error)
  • func (lock Lock) Unlock(ctx context.Context) (bool, error)
• type LockResult
• type Locker
  • func NewLocker(client RedisClient) *Locker
  • func (locker *Locker) Lock(ctx context.Context, key string, ttl time.Duration) (LockResult, error)
• type RedisClient
• type Result
  • func (r Result) OK() bool
  • func (r Result) TTL() time.Duration

Variables

var ErrUnexpectedRedisResponse = errors.New("locker: unexpected redis response")

ErrUnexpectedRedisResponse is the error returned when Redis command returns response of unexpected type.

Types

type Lock

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

Lock implements distributed locking.

func (Lock) Lock

func (lock Lock) Lock(ctx context.Context, ttl time.Duration) (Result, error)

Lock applies the lock if it is not already applied, otherwise extends the lock TTL.

func (Lock) Unlock

func (lock Lock) Unlock(ctx context.Context) (bool, error)

Unlock releases the lock.

type LockResult

type LockResult struct {
	Lock
	Result
}

LockResult contains new lock and result of applying a lock.

type Locker

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

Locker defines parameters for creating new lock.

func NewLocker

func NewLocker(client RedisClient) *Locker

NewLocker creates new locker.

func (*Locker) Lock

func (locker *Locker) Lock(ctx context.Context, key string, ttl time.Duration) (LockResult, error)

Lock creates and applies new lock.

type RedisClient

type RedisClient interface {
	Eval(ctx context.Context, script string, keys []string, args ...interface{}) *redis.Cmd
	EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *redis.Cmd
	ScriptExists(ctx context.Context, hashes ...string) *redis.BoolSliceCmd
	ScriptLoad(ctx context.Context, script string) *redis.StringCmd
}

RedisClient is redis scripter interface.

type Result

type Result int64

Result of applying a lock.

func (Result) OK

func (r Result) OK() bool

OK is success flag of applying a lock.

func (Result) TTL

func (r Result) TTL() time.Duration

TTL of a lock. Makes sense if operation failed, otherwise ttl is less than 0.