about summary refs log tree commit diff stats
path: root/cache.go
blob: fde11eef9ea1794afbb31d6563fb646671e3ca2f (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
package main

import (
	"errors"
	"io/ioutil"
	"strings"
	"sync"
	"time"
)

const cacheDuration = 1 * time.Minute

// Holds the cached responses
type page struct {
	raw     []byte
	expires time.Time
}

// Wraps the page cache map with a rwlock
type cacheWrapper struct {
	sync.RWMutex
	pages map[string]*page
}

// The actual page/response cache
var cache = &cacheWrapper{
	pages: make(map[string]*page),
}

// Checks if a page exists in the cache already.
// If it doesn't, creates an empty entry.
func (cache *cacheWrapper) checkedInit(path string) {
	cache.Lock()
	defer cache.Unlock()

	if cache.pages[path] == nil {
		cache.pages[path] = &page{
			raw:     []byte{},
			expires: time.Time{},
		}
	}
}

// Adds a given page to the cache with path as the key
func (cache *cacheWrapper) insert(path string, raw []byte) {
	cache.Lock()
	defer cache.Unlock()

	cache.pages[path] = &page{
		raw:     raw,
		expires: time.Now().Add(cacheDuration),
	}
}

// Returns true if the cached page is good.
// False if it's stale.
func (cache *cacheWrapper) isFresh(path string) bool {
	cache.RLock()
	defer cache.RUnlock()
	return time.Now().Before(cache.pages[path].expires)
}

// Wraps the two cache-checking functions.
// One for /, the other for various requests.
func (cache *cacheWrapper) bap(requestPath string) error {
	cache.checkedInit(requestPath)

	if cache.isFresh(requestPath) {
		return nil
	}

	var format, query string

	if requestPath != "/" {
		split := strings.Split(requestPath[1:], "/")
		format = split[0]
		query = split[1]
	}

	var bytes []byte
	var err error

	switch query {
	case "osversion":
		bytes, err = osVersionQuery(format)
	case "uptime":
		bytes, err = uptimeQuery(format)
	case "usercount":
		bytes, err = userCountQuery(format)
	case "pkgs":
		bytes, err = pkgsQuery(format)
	default:
		if requestPath == "/" {
			bytes, err = ioutil.ReadFile("web/index.txt")
		} else {
			err = errors.New("Invalid Query Type")
		}
	}

	if err != nil {
		return err
	}

	cache.insert(requestPath, bytes)
	return nil
}

// yoinks the raw data and expiry time to send to the requester
func (cache *cacheWrapper) yoink(path string) ([]byte, string) {
	cache.RLock()
	defer cache.RUnlock()

	return cache.pages[path].raw, cache.pages[path].expires.Format(time.RFC1123)
}