gocache

README

Cache is a package which implements a unified interface for various Golang based cache.

Current drivers include:

• In-memory LRU cache github.com/bradberger/gocache/drivers/lru
• memcached
• Redis via redigo
• github.com/patricknm/go-cache
• App Engine memcache
• Go-radix
• FreeCache
• BigCache
• Golang-lru
• A bridge driver to [github.com/bradberger/gokv]((https://godoc.org/github.com/bradberger/gokv) which can implement anything which implements the kv.Store interface, currently including:
  • AppEngine datastore
  • BoltDB
  • DiskV
  • LevelDB

More drivers are most welcome! Just make sure they meet at least the "cache".Cache interface and are unit tested.

Documentation

Overview

Package gocache implements a set of drivers and a common interface for working with different cache systems

Index

• Constants
• Variables
• type Client
  • func New() *Client
  • func (c *Client) AddNode(name string, node cache.Cache) error
  • func (c *Client) Del(key string) (err error)
  • func (c *Client) Exists(key string) (exists bool)
  • func (c *Client) Get(key string, dstVal interface{}) (err error)
  • func (c *Client) GetTimeout(dur time.Duration)
  • func (c *Client) RemoveNode(name string) error
  • func (c *Client) ReplaceNode(name string, node cache.Cache) error
  • func (c *Client) ReplicateToN(numNodes int) error
  • func (c *Client) Set(key string, value interface{}, exp time.Duration) (err error)
  • func (c *Client) SetNode(name string, node cache.Cache) error
  • func (c *Client) SetReplicateMethod(m ReplicationMethod)
  • func (c *Client) SetRetrievalMethod(m RetrievalMethod)
  • func (c *Client) SetTimeout(dur time.Duration)
• type ReplicationMethod
• type RetrievalMethod

Constants

const (
	// ReplicateAsync indicates that replication will be done asyncronously.
	// Set commands will return without error as soon as at least one node has
	// the value
	ReplicateAsync ReplicationMethod = iota

	// ReplicateSync indicates that replication will be done syncronously.
	// Set commands will return without error only if all nodes return without error
	ReplicateSync = iota

	// RetrieveSync indicates that get commands(get, exists) will be send to one
	// node at a time starting with the closest node, and the first result will be used
	RetrieveSync RetrievalMethod = iota

	// RetrieveAsync indicates that get commands(get, exists) will be send in parallel
	// to the given nodes, and the first result will be used
	RetrieveAsync = iota
)

Variables

var (
	// ErrGetTimeout indicates a retrieval command timed out
	ErrGetTimeout = errors.New("get timeout")
	// ErrSetTimeout indicates a storage command timed out
	ErrSetTimeout = errors.New("set timeout")
)

Types

type Client

type Client struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

Client is a cache client with built in replication to any number of different caches. This allows replication and syncronization across various caches using the set of drivers available as subpackages, including Memcached, Redis, in-memory caches, and more.

func New

func New() *Client

New returns a new initialized cache Client with no nodes.

func (*Client) AddNode

func (c *Client) AddNode(name string, node cache.Cache) error

AddNode adds a cache node with the given name, but only if it doesn't already exist

func (*Client) Del

func (c *Client) Del(key string) (err error)

Del implements the "cache.Cache".Del() interface. It deletes the given key across all replicated nodes and returns error if any of those delete operations fail.

func (*Client) Exists

func (c *Client) Exists(key string) (exists bool)

Exists implements the "cache.Cache".Exists() interface

func (*Client) Get

func (c *Client) Get(key string, dstVal interface{}) (err error)

Get implements the "cache.Cache".Get() interface. It checks nodes in order of priority, and returns success if the value exists on any of them.

func (*Client) GetTimeout

func (c *Client) GetTimeout(dur time.Duration)

GetTimeout updates the get command timeout duration

func (*Client) RemoveNode

func (c *Client) RemoveNode(name string) error

RemoveNode removes a node with the given name from the node list

func (*Client) ReplaceNode

func (c *Client) ReplaceNode(name string, node cache.Cache) error

ReplaceNode adds a cache node with the given name, but only if it already exists

func (*Client) ReplicateToN

func (c *Client) ReplicateToN(numNodes int) error

ReplicateToN sets how many nodes each key should be replicated to

func (*Client) Set

func (c *Client) Set(key string, value interface{}, exp time.Duration) (err error)

Set implements the "cache.Cache".Set() interface

func (*Client) SetNode

func (c *Client) SetNode(name string, node cache.Cache) error

SetNode sets the cache node with the given name, regardless of whether it already exists or not

func (*Client) SetReplicateMethod

func (c *Client) SetReplicateMethod(m ReplicationMethod)

SetReplicateMethod sets the replication method

func (*Client) SetRetrievalMethod

func (c *Client) SetRetrievalMethod(m RetrievalMethod)

SetRetrievalMethod sets the retrieval method

func (*Client) SetTimeout

func (c *Client) SetTimeout(dur time.Duration)

SetTimeout updates the set command timeout duration

type ReplicationMethod

type ReplicationMethod int

ReplicationMethod determines whether replication takes place asyncronously or syncronously. Use ReplicateAsync for asyncronous replication, ReplicateSync for syncronous replication.

type RetrievalMethod

type RetrievalMethod int

RetrievalMethod determines whether get commands (get, exists) are sent to all nodes simultaneously or are sent one-by-one.