mirror of https://github.com/gabehf/Koito.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
111 lines
1.8 KiB
111 lines
1.8 KiB
package memkv
|
|
|
|
import (
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
type item struct {
|
|
value interface{}
|
|
expiresAt time.Time
|
|
}
|
|
|
|
type InMemoryStore struct {
|
|
data map[string]item
|
|
defaultExpiration time.Duration
|
|
mu sync.RWMutex
|
|
stopJanitor chan struct{}
|
|
}
|
|
|
|
var Store *InMemoryStore
|
|
|
|
func init() {
|
|
Store = NewStore(10 * time.Minute)
|
|
}
|
|
|
|
func NewStore(defaultExpiration time.Duration) *InMemoryStore {
|
|
s := &InMemoryStore{
|
|
data: make(map[string]item),
|
|
defaultExpiration: defaultExpiration,
|
|
stopJanitor: make(chan struct{}),
|
|
}
|
|
|
|
go s.janitor(1 * time.Minute)
|
|
|
|
return s
|
|
}
|
|
|
|
func (s *InMemoryStore) Set(key string, value interface{}, expiration ...time.Duration) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
exp := s.defaultExpiration
|
|
if len(expiration) > 0 {
|
|
exp = expiration[0]
|
|
}
|
|
|
|
var expiresAt time.Time
|
|
if exp > 0 {
|
|
expiresAt = time.Now().Add(exp)
|
|
}
|
|
|
|
s.data[key] = item{
|
|
value: value,
|
|
expiresAt: expiresAt,
|
|
}
|
|
}
|
|
|
|
func (s *InMemoryStore) Get(key string) (interface{}, bool) {
|
|
s.mu.RLock()
|
|
it, found := s.data[key]
|
|
s.mu.RUnlock()
|
|
|
|
if !found {
|
|
return nil, false
|
|
}
|
|
|
|
if !it.expiresAt.IsZero() && time.Now().After(it.expiresAt) {
|
|
s.Delete(key)
|
|
return nil, false
|
|
}
|
|
|
|
return it.value, true
|
|
}
|
|
|
|
func (s *InMemoryStore) Delete(key string) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
delete(s.data, key)
|
|
}
|
|
|
|
func (s *InMemoryStore) janitor(interval time.Duration) {
|
|
ticker := time.NewTicker(interval)
|
|
defer ticker.Stop()
|
|
|
|
for {
|
|
select {
|
|
case <-ticker.C:
|
|
s.cleanup()
|
|
case <-s.stopJanitor:
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *InMemoryStore) cleanup() {
|
|
now := time.Now()
|
|
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
for k, it := range s.data {
|
|
if !it.expiresAt.IsZero() && now.After(it.expiresAt) {
|
|
delete(s.data, k)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *InMemoryStore) Close() {
|
|
close(s.stopJanitor)
|
|
}
|