cache

package
v0.0.0-...-43a62c1 Latest Latest
Warning

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

Go to latest
Published: Jan 28, 2023 License: MIT Imports: 14 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source
var (
	FileCachePath           = "cache"     // cache directory
	FileCacheFileSuffix     = ".bin"      // cache file suffix
	FileCacheDirectoryLevel = 2           // cache file deep level if auto generated cache files.
	FileCacheEmbedExpiry    time.Duration // cache expire time, default is no expire forever.
)

FileCache Config

View Source
var (
	// DefaultEvery means the clock time of recycling the expired cache items in memory.
	DefaultEvery = 60 // 1 minute
)

Functions

func ClearAll

func ClearAll() error

func Decr

func Decr(key string) error

func Delete

func Delete(key string) error

func FileGetContents

func FileGetContents(filename string) (data []byte, e error)

FileGetContents Get bytes to file. if non-exist, create this file.

func FilePutContents

func FilePutContents(filename string, content []byte) error

FilePutContents Put bytes to file. if non-exist, create this file.

func Get

func Get(key string) interface{}

func GetBool

func GetBool(v interface{}) bool

GetBool convert interface to bool.

func GetFloat64

func GetFloat64(v interface{}) float64

GetFloat64 convert interface to float64.

func GetInt

func GetInt(v interface{}) int

GetInt convert interface to int.

func GetInt64

func GetInt64(v interface{}) int64

GetInt64 convert interface to int64.

func GetMulti

func GetMulti(keys []string) []interface{}

func GetString

func GetString(v interface{}) string

GetString convert interface to string.

func GobDecode

func GobDecode(data []byte, to *FileCacheItem) error

GobDecode Gob decodes file cache item.

func GobEncode

func GobEncode(data interface{}) ([]byte, error)

GobEncode Gob encodes file cache item.

func Incr

func Incr(key string) error

func InitCache

func InitCache(adapterName, config string) (err error)

func IsExist

func IsExist(key string) bool

func Put

func Put(key string, val interface{}, ttl time.Duration) error

func Register

func Register(name string, adapter Instance)

Register makes a cache adapter available by the adapter name. If Register is called twice with the same name or if driver is nil, it panics.

func StartAndGC

func StartAndGC(cfg string) error

Types

type Cache

type Cache interface {
	Get(key string) interface{}                                   // get cached value by key.
	GetMulti(keys []string) []interface{}                         // GetMulti is a batch version of Get.
	Put(key string, val interface{}, timeout time.Duration) error // set cached value with key and expire time.
	Delete(key string) error                                      // delete cached value by key.
	Incr(key string) error                                        // increase cached int value by key, as a counter.
	Decr(key string) error                                        // decrease cached int value by key, as a counter.
	IsExist(key string) bool                                      // check if cached value exists or not.
	ClearAll() error                                              // clear all cache.
	StartAndGC(config string) error                               // start gc routine based on config string settings.
}

func NewCache

func NewCache(adapterName, config string) (adapter Cache, err error)

NewCache Create a new cache driver by adapter name and config string. config need to be correct JSON as string: {"interval":360}. it will start gc automatically.

func NewFileCache

func NewFileCache() Cache

NewFileCache Create new file cache with no config. the level and expiry need set in method StartAndGC as config string.

func NewMemoryCache

func NewMemoryCache() Cache

NewMemoryCache returns a new MemoryCache.

type FileCache

type FileCache struct {
	CachePath      string
	FileSuffix     string
	DirectoryLevel int
	EmbedExpiry    int
}

FileCache is cache adapter for file storage.

func (*FileCache) ClearAll

func (fc *FileCache) ClearAll() error

ClearAll will clean cached files. not implemented.

func (*FileCache) Decr

func (fc *FileCache) Decr(key string) error

Decr will decrease cached int value.

func (*FileCache) Delete

func (fc *FileCache) Delete(key string) error

Delete file cache value.

func (*FileCache) Get

func (fc *FileCache) Get(key string) interface{}

Get value from file cache. if non-exist or expired, return empty string.

func (*FileCache) GetMulti

func (fc *FileCache) GetMulti(keys []string) []interface{}

GetMulti gets values from file cache. if non-exist or expired, return empty string.

func (*FileCache) Incr

func (fc *FileCache) Incr(key string) error

Incr will increase cached int value. fc value is saving forever unless Delete.

func (*FileCache) Init

func (fc *FileCache) Init()

Init will make new dir for file cache if not exist.

func (*FileCache) IsExist

func (fc *FileCache) IsExist(key string) bool

IsExist check value is exist.

func (*FileCache) Put

func (fc *FileCache) Put(key string, val interface{}, timeout time.Duration) error

Put value into file cache. timeout means how long to keep this file, unit of ms. if timeout equals FileCacheEmbedExpiry(default is 0), cache this item forever.

func (*FileCache) StartAndGC

func (fc *FileCache) StartAndGC(config string) error

StartAndGC will start and begin gc for file cache. the config need to be like {CachePath:"/cache","FileSuffix":".bin","DirectoryLevel":2,"EmbedExpiry":0}

type FileCacheItem

type FileCacheItem struct {
	Data       interface{}
	LastAccess time.Time
	Expired    time.Time
}

FileCacheItem is basic unit of file cache adapter. it contains data and expire time.

type Instance

type Instance func() Cache

Instance is a function create a new Cache Instance

type MemoryCache

type MemoryCache struct {
	sync.RWMutex

	Every int // run an expiration check Every clock time
	// contains filtered or unexported fields
}

MemoryCache is Memory cache adapter. it contains a RW locker for safe map storage.

func (*MemoryCache) ClearAll

func (bc *MemoryCache) ClearAll() error

ClearAll will delete all cache in memory.

func (*MemoryCache) Decr

func (bc *MemoryCache) Decr(key string) error

Decr decrease counter in memory.

func (*MemoryCache) Delete

func (bc *MemoryCache) Delete(name string) error

Delete cache in memory.

func (*MemoryCache) Get

func (bc *MemoryCache) Get(name string) interface{}

Get cache from memory. if non-existed or expired, return nil.

func (*MemoryCache) GetMulti

func (bc *MemoryCache) GetMulti(names []string) []interface{}

GetMulti gets caches from memory. if non-existed or expired, return nil.

func (*MemoryCache) Incr

func (bc *MemoryCache) Incr(key string) error

Incr increase cache counter in memory. it supports int,int32,int64,uint,uint32,uint64.

func (*MemoryCache) IsExist

func (bc *MemoryCache) IsExist(name string) bool

IsExist check cache exist in memory.

func (*MemoryCache) Put

func (bc *MemoryCache) Put(name string, value interface{}, lifespan time.Duration) error

Put cache to memory. if lifespan is 0, it will be forever till restart.

func (*MemoryCache) StartAndGC

func (bc *MemoryCache) StartAndGC(config string) error

StartAndGC start memory cache. it will check expiration in every clock time.

type MemoryItem

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

MemoryItem store memory cache item.

Jump to

Keyboard shortcuts

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