cache

package
v0.0.0-...-107dafa Latest Latest
Warning

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

 Go to latest Published: May 23, 2016 License: Apache-2.0 Imports: 13 Imported by: 0

Documentation

Overview

Package Cache contains the CacheManager and CacheStorage formal interface definitions, a SimpleCacheManager, AutoCacheManager and RedisCacheStorage implementations.

Package Cache contains ...

Index

Constants

View Source 
const CacheTreeRefPrefix = "attTreeRef"
View Source 
const TTL_INFINITY = -1

Variables

This section is empty.

Functions

func GetIdFieldStr 

func GetIdFieldStr(object interface{}) (string, error)

Return the "Id" field, if it exists, as a string val Error if object does't have an Id field

func GetKey 

func GetKey(value reflect.Value) (string, error)

Retrieve the cachekey for some object Error if object is not Cacheable AND is not possible to inter cacheKey

func GetKeys 

func GetKeys(qtd int) []string

func GetNameType 

func GetNameType(value interface{}) (string, reflect.Type)

func MinTTL 

func MinTTL(ttl1 int, ttl2 int) int

calculate the minimal ttl

Types

type Attribute 

type Attribute struct {
	Id    int
	Name  string
	Value string
}

func (*Attribute) DecodeMsg 

func (z *Attribute) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (Attribute) EncodeMsg 

func (z Attribute) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (Attribute) MarshalMsg 

func (z Attribute) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (Attribute) Msgsize 

func (z Attribute) Msgsize() (s int)

func (*Attribute) UnmarshalMsg 

func (z *Attribute) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type AutoCacheManager 

type AutoCacheManager struct {
	Ps CacheStorage
}

func (AutoCacheManager) GetCache 

func (c AutoCacheManager) GetCache(cacheKey string) (CacheRegistry, error)

get cache for only one cachekey

func (AutoCacheManager) GetCaches 

func (c AutoCacheManager) GetCaches(cacheKeys ...string) (map[string]CacheRegistry, error)

implement getCache operation that can recover child data in other cache registries.

func (AutoCacheManager) Invalidate 

func (c AutoCacheManager) Invalidate(cacheKeys ...string) error

invalidate cache registry

func (AutoCacheManager) SetCache 

func (c AutoCacheManager) SetCache(cacheRegistries ...CacheRegistry) error

set cache implementation

func (AutoCacheManager) Validade 

func (c AutoCacheManager) Validade() bool

type CacheManager 

type CacheManager interface {
	//set values to cache
	//SetCache(cacheKey string, cacheVal interface{}, ttl int) int
	SetCache(cacheRegistry ...CacheRegistry) error

	//recover value from cache
	//GetCache(cacheKey string) (interface{}, bool, int)
	GetCache(cacheKey string) (CacheRegistry, error)

	//recover value from cache
	//GetCache(cacheKey string) (interface{}, bool, int)
	GetCaches(cacheKey ...string) (map[string]CacheRegistry, error)

	//Invalidate cache registry. Means that this cache registry is not valid or consistent anymore.
	//Do not means that registry was deleted in original data source. This operation don't update parent registries,
	//removing references to this registry. Parent cache search must fail to find this registry,
	//meaning that all cache registry is inconsistent.
	//To represent a delete operation, updating parent registries, use exclusively the DeleteCache operation in UpdaterCacheManager interface.
	Invalidate(cacheKey ...string) error

	//validate readiness of cache operation
	Validade() bool
}

Define an basic contract for CacheManager A good cache manager implementation must optimize caching operations, like to cache child useful objects recursively, detect caching inconsistency, invalidate cache registries invalidate cacheKey and its dependencies etc Cachemanager get operations must return cache registry always, no matter registry exists or not

type CacheRegistry 

type CacheRegistry struct {
	CacheKey  string      //unique key in cache
	Payload   interface{} //payload to be cached, usually an byte array
	StoreTTL  float64     // Cache Time to Live duration
	CacheTime time.Time   //date when cache registry was created
	HasValue  bool        //return the presence of cached value on cache storage. Useful in batch operations and to avoid nil errors
	TypeName  string      //type name of payload. Only serializer implementation can see this attribute
}

CacheRegistry: Contains struct payload to be cached and additional information about cache registry Cachemanager operation must return cache registry always

func GetReg 

func GetReg(id int) CacheRegistry

func GetRegs 

func GetRegs(qtd int) []CacheRegistry

func (*CacheRegistry) DecodeMsg 

func (z *CacheRegistry) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*CacheRegistry) EncodeMsg 

func (z *CacheRegistry) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (CacheRegistry) GetTTLSeconds 

func (c CacheRegistry) GetTTLSeconds() float64

Calculates TTl of cache registry

func (*CacheRegistry) MarshalMsg 

func (z *CacheRegistry) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*CacheRegistry) Msgsize 

func (z *CacheRegistry) Msgsize() (s int)

func (*CacheRegistry) UnmarshalMsg 

func (z *CacheRegistry) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type CacheStorage 

type CacheStorage interface {
	//include cache registries
	SetValues(values ...CacheRegistry) error

	//recover cache values (map of values, map of hasValue bool, map of ttls, error)
	//GetValues(keys ...string) (map[string]interface{}, map[string]bool, map[string]int, error)
	GetValuesMap(keys ...string) (map[string]CacheRegistry, error)

	//delete cache values
	DeleteValues(cacheKey ...string) error
}

Basic contract for cache storage. Define basic key/value operations could be implemented with any kind of key/value persistence mechanism a good cachestorage implementation can store and recover data efficiently, like batch recover, using an go routine to store data, maybe how to inherity and share cache areas etc

type Cacheable 

type Cacheable interface {
	GetCacheKey() string
}

type Car 

type Car struct {
	CarId      int               `json:"carId"`
	CarName    string            `json:"carName"`
	Attributes []Attribute       `json:"specializations,omitempty"`
	FlagMap    map[string]string `json:"flagMap"`
	Ttl        int               `json:"-"`
}

func GetCar 

func GetCar(id int) Car

func (*Car) DecodeMsg 

func (z *Car) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*Car) EncodeMsg 

func (z *Car) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*Car) MarshalMsg 

func (z *Car) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*Car) Msgsize 

func (z *Car) Msgsize() (s int)

func (*Car) UnmarshalMsg 

func (z *Car) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type ExposeTTL 

type ExposeTTL interface {
	//teste
	GetTtl() float64
	SetTtl(float64) interface{}
}

means that some struct will define their own ttl. cacheRegistry will copy this ttl definition for cache operations

type RedisCacheStorage 

type RedisCacheStorage struct {
	Serializer Serializer // usually SerializerGOB implementation
	// contains filtered or unexported fields
}

Cache storage implementation using redis as key/value storage

func NewRedisCacheStorage 

func NewRedisCacheStorage(hostPort string, password string, maxIdle int, maxActive int, readTimeout int, cacheArea string, serializer Serializer) RedisCacheStorage

instantiate a new cachestorage redis

func (RedisCacheStorage) DeleteValues 

func (s RedisCacheStorage) DeleteValues(cacheKeys ...string) (retErr error)

delete values from redis

func (RedisCacheStorage) GetTTLMap 

func (s RedisCacheStorage) GetTTLMap(keys []string) (retTTLMap map[string]int)

Recover current ttl information about registries

func (RedisCacheStorage) GetValuesMap 

func (s RedisCacheStorage) GetValuesMap(cacheKeys ...string) (mapResp map[string]CacheRegistry, retError error)

recover all cacheregistries of keys

func (RedisCacheStorage) SetExpireTTL 

func (s RedisCacheStorage) SetExpireTTL(cacheRegistries ...CacheRegistry)

set defined ttl to the cache registries

func (RedisCacheStorage) SetValues 

func (s RedisCacheStorage) SetValues(registries ...CacheRegistry) (retErr error)

save informed registries on redis

type Serializer 

type Serializer interface {

	//register the type for future reference
	Register(sample interface{})

	// MarshalMsg implements msgp.Marshaler
	MarshalMsg(src CacheRegistry, b []byte) (o []byte, err error)

	// UnmarshalMsg implements msgp.Unmarshaler
	UnmarshalMsg(dest CacheRegistry, bts []byte) (resp interface{}, o []byte, err error)

	//prefix for this serializer, enable multiple serializer at same respository (redis)
	GetPrefix() string
}

type SerializerGOB 

type SerializerGOB struct {
}

func (SerializerGOB) GetPrefix 

func (s SerializerGOB) GetPrefix() string

func (SerializerGOB) MarshalMsg 

func (SerializerGOB) MarshalMsg(src CacheRegistry, b []byte) (o []byte, err error)

seralize an objeto to byte array

func (SerializerGOB) Register 

func (s SerializerGOB) Register(value interface{})

func (SerializerGOB) UnmarshalMsg 

func (SerializerGOB) UnmarshalMsg(dest CacheRegistry, bts []byte) (resp interface{}, o []byte, err error)

deserialize an byte array to object

type SimpleCacheManager 

type SimpleCacheManager struct {
	CacheStorage CacheStorage
}

func (SimpleCacheManager) GetCache 

func (c SimpleCacheManager) GetCache(cacheKey string) (CacheRegistry, error)

implement getCache operation that can recover child data in other cache registries.

func (SimpleCacheManager) GetCaches 

func (c SimpleCacheManager) GetCaches(cacheKeys ...string) (map[string]CacheRegistry, error)

implement getCache operation that can recover child data in other cache registries.

func (SimpleCacheManager) Invalidate 

func (c SimpleCacheManager) Invalidate(cacheKeys ...string) error

invalidate cache registry

func (SimpleCacheManager) SetCache 

func (c SimpleCacheManager) SetCache(cacheRegistry ...CacheRegistry) error

set cache implementation

func (SimpleCacheManager) Validade 

func (c SimpleCacheManager) Validade() bool

type Stats 

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

basic structure for statistics service

func NewStats 

func NewStats(name string) *Stats

create new stats object for cache statistics

func (*Stats) Hit 

func (st *Stats) Hit()

increment cache hit

func (*Stats) Miss 

func (st *Stats) Miss()

increment cache Miss

type UpdateCachedRelated 

type UpdateCachedRelated interface {
	//who is my parent
	ParentsKey() []string

	//For delete operation
	RemoveFromParent(interface{}) interface{}

	//For insert operations
	InsertInParent(interface{}) interface{}
}

Implementation of this interface means that struct knows how to update his relateds Cached, when the struct is deleted or inserted. There is nothing to do when struct is updated

type UpdaterCacheManager 

type UpdaterCacheManager interface {
	CacheManager // import all CacheManager definitions
	//Means that cache registry was deleted on the source, and that parent registries must be updated.
	DeleteCache(cacheRegistry CacheRegistry)
}

Define a extension contract to CacheManager, with DeleteCache operation. UpdateCacheManager contract can be used, actively, in events of Create, Update and Delete of registries. CacheManager can be used only, passively, in Read operations

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.