synlock

README

Synlock

Allows to construct distributed locks engine if you have:

• Redis
• Consul (not implemented yet)
• Postgres (not implemented yet)

Documentation

Index

• Variables
• type Mutex
• type Option
  • func WithErrorHandler(h func(key string, err error)) Option
• type Postgres
  • func NewPostgres(conf PostgresOpts) (_ *Postgres, err error)
  • func (r *Postgres) NewMutex(key int64) (Mutex, error)
• type PostgresMutex
  • func (s *PostgresMutex) Lock() error
  • func (s *PostgresMutex) Unlock() error
• type PostgresOpts
• type Redis
  • func NewRedis(conf RedisOpts, opts ...Option) (*Redis, error)
  • func (r *Redis) NewMutex(key int64) (Mutex, error)
• type RedisMutex
  • func MustRedisMutex(mu Mutex) *RedisMutex
  • func (s *RedisMutex) Lock() (err error)
  • func (s *RedisMutex) LockContext(ctx context.Context) (err error)
  • func (s *RedisMutex) Unlock() error
• type RedisOpts
• type Synlock
  • func New(conn string) (Synlock, error)

Variables

var (
	ErrRedisInvalidAddr     = errors.New("invalid redis address")
	ErrRedisKeyDoesNotExist = errors.New("key does not exist")
	ErrRedisInvalidPrefix   = errors.New("invalid redis key prefix")
)

var DefPostgresOpts = PostgresOpts{
	Host: "127.0.0.1",
	Port: "5432",
	DB:   "postgres",
	User: "postgres",
}

var DefRedisOpts = RedisOpts{
	Host:   "127.0.0.1",
	Port:   "6379",
	DB:     0,
	Prefix: "synlock",
}

var (
	ErrPostgresInvalidAddr = errors.New("invalid postgres address")
)

Types

type Mutex

type Mutex interface {
	Lock() error
	Unlock() error
}

type Option

type Option func(*options)

func WithErrorHandler

func WithErrorHandler(h func(key string, err error)) Option

type Postgres

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

func NewPostgres

func NewPostgres(conf PostgresOpts) (_ *Postgres, err error)

func (*Postgres) NewMutex

func (r *Postgres) NewMutex(key int64) (Mutex, error)

type PostgresMutex

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

func (*PostgresMutex) Lock

func (s *PostgresMutex) Lock() error

func (*PostgresMutex) Unlock

func (s *PostgresMutex) Unlock() error

type PostgresOpts

type PostgresOpts struct {
	Host           string
	Port           string
	DB             string
	User           string
	Pass           string
	MaxConnections int
}

type Redis

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

func NewRedis

func NewRedis(conf RedisOpts, opts ...Option) (*Redis, error)

func (*Redis) NewMutex

func (r *Redis) NewMutex(key int64) (Mutex, error)

type RedisMutex

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

func MustRedisMutex

func MustRedisMutex(mu Mutex) *RedisMutex

func (*RedisMutex) Lock

func (s *RedisMutex) Lock() (err error)

func (*RedisMutex) LockContext

func (s *RedisMutex) LockContext(ctx context.Context) (err error)

func (*RedisMutex) Unlock

func (s *RedisMutex) Unlock() error

type RedisOpts

type RedisOpts struct {
	Host, Port         string
	DB                 int
	Username, Password string
	TLSConfig          *tls.Config
	Prefix             string
}

type Synlock

type Synlock interface {
	NewMutex(key int64) (Mutex, error)
}

func New

func New(conn string) (Synlock, error)