136 lines
3.2 KiB
Go
136 lines
3.2 KiB
Go
// Package cache provides an interface for a cache of strings, aka text/gemini pages, and redirects.
|
|
// It is fully thread safe.
|
|
package cache
|
|
|
|
import (
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/makeworld-the-better-one/amfora/structs"
|
|
)
|
|
|
|
var pages = make(map[string]*structs.Page) // The actual cache
|
|
var urls = make([]string, 0) // Duplicate of the keys in the `pages` map, but in order of being added
|
|
var maxPages = 0 // Max allowed number of pages in cache
|
|
var maxSize = 0 // Max allowed cache size in bytes
|
|
var mu = sync.RWMutex{}
|
|
var timeout = time.Duration(0)
|
|
|
|
// SetMaxPages sets the max number of pages the cache can hold.
|
|
// A value <= 0 means infinite pages.
|
|
func SetMaxPages(max int) {
|
|
maxPages = max
|
|
}
|
|
|
|
// SetMaxSize sets the max size the page cache can be, in bytes.
|
|
// A value <= 0 means infinite size.
|
|
func SetMaxSize(max int) {
|
|
maxSize = max
|
|
}
|
|
|
|
// SetTimeout sets the max number of a seconds a page can still
|
|
// be valid for. A value <= 0 means forever.
|
|
func SetTimeout(t int) {
|
|
if t <= 0 {
|
|
timeout = time.Duration(0)
|
|
return
|
|
}
|
|
timeout = time.Duration(t) * time.Second
|
|
}
|
|
|
|
func removeIndex(s []string, i int) []string {
|
|
s[len(s)-1], s[i] = s[i], s[len(s)-1]
|
|
return s[:len(s)-1]
|
|
}
|
|
|
|
func removeURL(url string) {
|
|
for i := range urls {
|
|
if urls[i] == url {
|
|
urls = removeIndex(urls, i)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// AddPage adds a page to the cache, removing earlier pages as needed
|
|
// to keep the cache inside its limits.
|
|
//
|
|
// If your page is larger than the max cache size, the provided page
|
|
// will silently not be added to the cache.
|
|
func AddPage(p *structs.Page) {
|
|
if p.URL == "" {
|
|
// Just in case, these pages shouldn't be cached
|
|
return
|
|
}
|
|
|
|
if p.Size() > maxSize && maxSize > 0 {
|
|
// This page can never be added
|
|
return
|
|
}
|
|
|
|
// Remove earlier pages to make room for this one
|
|
// There should only ever be 1 page to remove at most,
|
|
// but this handles more just in case.
|
|
for NumPages() >= maxPages && maxPages > 0 {
|
|
RemovePage(urls[0])
|
|
}
|
|
// Do the same but for cache size
|
|
for SizePages()+p.Size() > maxSize && maxSize > 0 {
|
|
RemovePage(urls[0])
|
|
}
|
|
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
pages[p.URL] = p
|
|
// Remove the URL if it was already there, then add it to the end
|
|
removeURL(p.URL)
|
|
urls = append(urls, p.URL)
|
|
}
|
|
|
|
// RemovePage will remove a page from the cache.
|
|
// Even if the page doesn't exist there will be no error.
|
|
func RemovePage(url string) {
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
delete(pages, url)
|
|
removeURL(url)
|
|
}
|
|
|
|
// ClearPages removes all pages from the cache.
|
|
func ClearPages() {
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
pages = make(map[string]*structs.Page)
|
|
urls = make([]string, 0)
|
|
}
|
|
|
|
// SizePages returns the approx. current size of the cache in bytes.
|
|
func SizePages() int {
|
|
mu.RLock()
|
|
defer mu.RUnlock()
|
|
n := 0
|
|
for _, page := range pages {
|
|
n += page.Size()
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NumPages() int {
|
|
mu.RLock()
|
|
defer mu.RUnlock()
|
|
return len(pages)
|
|
}
|
|
|
|
// GetPage returns the page struct, and a bool indicating if the page was in the cache or not.
|
|
// (nil, false) is returned if the page isn't in the cache.
|
|
func GetPage(url string) (*structs.Page, bool) {
|
|
mu.RLock()
|
|
defer mu.RUnlock()
|
|
|
|
p, ok := pages[url]
|
|
if ok && (timeout == 0 || time.Since(p.MadeAt) < timeout) {
|
|
return p, ok
|
|
}
|
|
return nil, false
|
|
}
|