--- a/pkg/controllers/cross.go	Sun Nov 25 17:15:44 2018 +0100
+++ b/pkg/controllers/cross.go	Sun Nov 25 19:25:27 2018 +0100
@@ -77,7 +77,7 @@
 	start := time.Now()
 	ctx := req.Context()
 
-	tree, err := octree.Cache.Get(
+	tree, err := octree.FromCache(
 		ctx, conn,
 		csi.Properties.Bottleneck, csi.Properties.Date.Time)
 

--- a/pkg/octree/cache.go	Sun Nov 25 17:15:44 2018 +0100
+++ b/pkg/octree/cache.go	Sun Nov 25 19:25:27 2018 +0100
@@ -31,7 +31,7 @@
 		tree     *Tree
 		access   time.Time
 	}
-	OctreeCache struct {
+	Cache struct {
 		sync.Mutex
 		entries map[cacheKey]*cacheEntry
 	}
@@ -61,42 +61,50 @@
 `
 )
 
-var Cache = OctreeCache{
+var cache = Cache{
 	entries: map[cacheKey]*cacheEntry{},
 }
 
 func init() {
-	go Cache.background()
+	go cache.background()
 }
 
-func (oc *OctreeCache) background() {
+func (c *Cache) background() {
 	for {
 		time.Sleep(cleanupCacheSleep)
-		oc.cleanup()
+		c.cleanup()
 	}
 }
 
-func (oc *OctreeCache) cleanup() {
-	oc.Lock()
-	defer oc.Unlock()
+func (c *Cache) cleanup() {
+	c.Lock()
+	defer c.Unlock()
 	good := time.Now().Add(-maxCacheAge)
-	for k, v := range oc.entries {
+	for k, v := range c.entries {
 		if v.access.Before(good) {
-			delete(oc.entries, k)
+			delete(c.entries, k)
 		}
 	}
 }
 
-func (oc *OctreeCache) Get(
+func FromCache(
 	ctx context.Context,
 	conn *sql.Conn,
 	bottleneck string, date time.Time,
 ) (*Tree, error) {
-	oc.Lock()
-	defer oc.Unlock()
+	return cache.get(ctx, conn, bottleneck, date)
+}
+
+func (c *Cache) get(
+	ctx context.Context,
+	conn *sql.Conn,
+	bottleneck string, date time.Time,
+) (*Tree, error) {
+	c.Lock()
+	defer c.Unlock()
 
 	key := cacheKey{date, bottleneck}
-	entry := oc.entries[key]
+	entry := c.entries[key]
 
 	var data []byte
 	var checksum string
@@ -140,21 +148,21 @@
 		return tree, nil
 	}
 
-	for len(oc.entries) >= maxCacheEntries {
+	for len(c.entries) >= maxCacheEntries {
 		// Evict the entry that is accessed the longest time ago.
 		var oldestKey cacheKey
 		oldest := now
 
-		for k, v := range oc.entries {
+		for k, v := range c.entries {
 			if v.access.Before(oldest) {
 				oldest = v.access
 				oldestKey = k
 			}
 		}
-		delete(oc.entries, oldestKey)
+		delete(c.entries, oldestKey)
 	}
 
-	oc.entries[key] = &cacheEntry{
+	c.entries[key] = &cacheEntry{
 		checksum: checksum,
 		tree:     tree,
 		access:   now,