Improve performance of UI when InfluxDB is slow (#200)

* Run InfluxDB and other requests concurrently

* Lazy loading for Gardens

* Add lazy loading to weather clients

* Rename get_full to include_data

* Don't swap full card for weather clients

* Fix HTMX swapping for Garden cards

* Rename lazy load endpoints and query params

* Fix lint

* Add ctx to WeatherClient methods

* Fix remaining issues

* Fix tests after rebase

Author: calvinmclean

deploy/configs/prometheus/prometheus.yml

@@ -7,4 +7,4 @@ scrape_configs:
       - targets: ["localhost:9090"]
   - job_name: garden-app
     static_configs:
-      - targets: ["garden-app:8080"]
+      - targets: ["host.docker.internal:8080", "garden-app:8080"]

garden-app/integration_tests/testdata/config.yml

@@ -10,9 +10,7 @@ influxdb:
   org: "garden"
   bucket: "garden"
 storage:
-  driver: sqlite
-  options:
-    data_source_name: "file:mem-integration-test?mode=memory&cache=shared"
+  connection_string: "file:mem-integration-test?mode=memory&cache=shared"
 
 controller:
   topic_prefix: "test"

garden-app/pkg/cache/cache.go

@@ -0,0 +1,75 @@
+// Package cache provides a simple in-memory cache with TTL support.
+package cache
+
+import (
+	"sync"
+	"time"
+)
+
+// Entry represents a cached value with its expiration time.
+type Entry[T any] struct {
+	Value      T
+	Expiration time.Time
+}
+
+// Cache is a generic in-memory cache with TTL support.
+// T is the type of values stored in the cache.
+type Cache[T any] struct {
+	mu      sync.RWMutex
+	entries map[string]Entry[T]
+	ttl     time.Duration
+}
+
+// New creates a new Cache with the specified TTL for all entries.
+func New[T any](ttl time.Duration) *Cache[T] {
+	return &Cache[T]{
+		entries: make(map[string]Entry[T]),
+		ttl:     ttl,
+	}
+}
+
+// Get retrieves a value from the cache by key.
+// Returns the value and true if found and not expired, otherwise returns zero value and false.
+func (c *Cache[T]) Get(key string) (T, bool) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	entry, exists := c.entries[key]
+	if !exists || time.Now().After(entry.Expiration) {
+		var zero T
+		return zero, false
+	}
+	return entry.Value, true
+}
+
+// Set stores a value in the cache with the configured TTL.
+func (c *Cache[T]) Set(key string, value T) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.entries[key] = Entry[T]{
+		Value:      value,
+		Expiration: time.Now().Add(c.ttl),
+	}
+}
+
+// Delete removes a value from the cache by key.
+func (c *Cache[T]) Delete(key string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	delete(c.entries, key)
+}
+
+// Clear removes all entries from the cache.
+func (c *Cache[T]) Clear() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.entries = make(map[string]Entry[T])
+}
+
+// Size returns the number of entries in the cache (including expired ones).
+func (c *Cache[T]) Size() int {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	return len(c.entries)
+}

garden-app/pkg/cache/cache_test.go

@@ -0,0 +1,234 @@
+package cache
+
+import (
+	"testing"
+	"time"
+)
+
+func TestCacheGetSet(t *testing.T) {
+	cache := New[string](100 * time.Millisecond)
+
+	// Test Get on empty cache
+	val, found := cache.Get("key1")
+	if found {
+		t.Error("expected key to not be found in empty cache")
+	}
+	if val != "" {
+		t.Errorf("expected empty string, got %q", val)
+	}
+
+	// Test Set and Get
+	cache.Set("key1", "value1")
+	val, found = cache.Get("key1")
+	if !found {
+		t.Error("expected key to be found after Set")
+	}
+	if val != "value1" {
+		t.Errorf("expected 'value1', got %q", val)
+	}
+
+	// Test Get on different key
+	_, found = cache.Get("key2")
+	if found {
+		t.Error("expected key2 to not be found")
+	}
+}
+
+func TestCacheExpiration(t *testing.T) {
+	cache := New[string](50 * time.Millisecond)
+
+	// Set a value
+	cache.Set("key1", "value1")
+
+	// Value should be available immediately
+	val, found := cache.Get("key1")
+	if !found {
+		t.Error("expected key to be found immediately after Set")
+	}
+	if val != "value1" {
+		t.Errorf("expected 'value1', got %q", val)
+	}
+
+	// Wait for expiration
+	time.Sleep(100 * time.Millisecond)
+
+	// Value should be expired now
+	val, found = cache.Get("key1")
+	if found {
+		t.Error("expected key to be expired after TTL")
+	}
+	if val != "" {
+		t.Errorf("expected empty string for expired key, got %q", val)
+	}
+}
+
+func TestCacheDelete(t *testing.T) {
+	cache := New[string](time.Minute)
+
+	// Set and then delete
+	cache.Set("key1", "value1")
+	cache.Delete("key1")
+
+	val, found := cache.Get("key1")
+	if found {
+		t.Error("expected key to not be found after Delete")
+	}
+	if val != "" {
+		t.Errorf("expected empty string after Delete, got %q", val)
+	}
+
+	// Delete non-existent key should not panic
+	cache.Delete("nonexistent")
+}
+
+func TestCacheClear(t *testing.T) {
+	cache := New[string](time.Minute)
+
+	// Set multiple values
+	cache.Set("key1", "value1")
+	cache.Set("key2", "value2")
+	cache.Set("key3", "value3")
+
+	// Clear all
+	cache.Clear()
+
+	// All should be gone
+	for _, key := range []string{"key1", "key2", "key3"} {
+		val, found := cache.Get(key)
+		if found {
+			t.Errorf("expected %s to not be found after Clear", key)
+		}
+		if val != "" {
+			t.Errorf("expected empty string for %s after Clear, got %q", key, val)
+		}
+	}
+}
+
+func TestCacheSize(t *testing.T) {
+	cache := New[string](time.Minute)
+
+	// Empty cache should have size 0
+	if cache.Size() != 0 {
+		t.Errorf("expected size 0 for empty cache, got %d", cache.Size())
+	}
+
+	// Add entries
+	cache.Set("key1", "value1")
+	cache.Set("key2", "value2")
+
+	if cache.Size() != 2 {
+		t.Errorf("expected size 2, got %d", cache.Size())
+	}
+
+	// Delete one
+	cache.Delete("key1")
+	if cache.Size() != 1 {
+		t.Errorf("expected size 1 after Delete, got %d", cache.Size())
+	}
+
+	// Clear
+	cache.Clear()
+	if cache.Size() != 0 {
+		t.Errorf("expected size 0 after Clear, got %d", cache.Size())
+	}
+}
+
+func TestCacheSizeIncludesExpired(t *testing.T) {
+	cache := New[string](50 * time.Millisecond)
+
+	// Set a value and let it expire
+	cache.Set("key1", "value1")
+	time.Sleep(100 * time.Millisecond)
+
+	// Size should still include expired entries
+	if cache.Size() != 1 {
+		t.Errorf("expected size 1 (including expired), got %d", cache.Size())
+	}
+
+	// But Get should not return it
+	_, found := cache.Get("key1")
+	if found {
+		t.Error("expected expired key to not be found via Get")
+	}
+}
+
+func TestCacheOverwrite(t *testing.T) {
+	cache := New[string](time.Minute)
+
+	// Set initial value
+	cache.Set("key1", "value1")
+
+	// Overwrite with new value
+	cache.Set("key1", "value2")
+
+	val, found := cache.Get("key1")
+	if !found {
+		t.Error("expected key to be found")
+	}
+	if val != "value2" {
+		t.Errorf("expected 'value2', got %q", val)
+	}
+
+	if cache.Size() != 1 {
+		t.Errorf("expected size 1 after overwrite, got %d", cache.Size())
+	}
+}
+
+func TestCacheDifferentTypes(t *testing.T) {
+	// Test with int type
+	intCache := New[int](time.Minute)
+	intCache.Set("key1", 42)
+	val, found := intCache.Get("key1")
+	if !found || val != 42 {
+		t.Errorf("expected 42, got %d (found=%v)", val, found)
+	}
+
+	// Test with struct type
+	type TestStruct struct {
+		Name  string
+		Value int
+	}
+	structCache := New[TestStruct](time.Minute)
+	structCache.Set("key1", TestStruct{Name: "test", Value: 123})
+	sval, found := structCache.Get("key1")
+	if !found || sval.Name != "test" || sval.Value != 123 {
+		t.Errorf("expected {test 123}, got %+v (found=%v)", sval, found)
+	}
+}
+
+func TestCacheConcurrentAccess(t *testing.T) {
+	cache := New[int](time.Minute)
+
+	// Run concurrent operations
+	done := make(chan bool, 10)
+
+	// Multiple goroutines writing
+	for i := 0; i < 5; i++ {
+		go func(id int) {
+			for j := 0; j < 100; j++ {
+				cache.Set(string(rune('a'+id)), j)
+			}
+			done <- true
+		}(i)
+	}
+
+	// Multiple goroutines reading
+	for i := 0; i < 5; i++ {
+		go func(id int) {
+			for j := 0; j < 100; j++ {
+				cache.Get(string(rune('a' + id)))
+			}
+			done <- true
+		}(i)
+	}
+
+	// Wait for all goroutines
+	for i := 0; i < 10; i++ {
+		<-done
+	}
+
+	// Cache should still be in a valid state
+	if cache.Size() != 5 {
+		t.Errorf("expected size 5, got %d", cache.Size())
+	}
+}