feat(cli): addec cache

Signed-off-by: olivier dubo <olivier.dubo@ovhcloud.com>

Author: duboolivier

internal/completion/cache.go

@@ -0,0 +1,88 @@
+// SPDX-FileCopyrightText: 2025 OVH SAS <opensource@ovh.net>
+//
+// SPDX-License-Identifier: Apache-2.0
+
+package completion
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// completionCacheTTL is how long cached completion results remain valid.
+//
+// Shell completion runs as a brand new, short-lived process on every <tab>, so
+// an in-memory cache would be useless: results are cached on disk to avoid
+// hitting the API on every keystroke.
+const completionCacheTTL = 10 * time.Minute
+
+// completionCacheDir returns the directory where completion results are cached,
+// honouring XDG_CACHE_HOME. It returns "" if it cannot be determined.
+func completionCacheDir() string {
+	base := os.Getenv("XDG_CACHE_HOME")
+	if base == "" {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return ""
+		}
+		base = filepath.Join(home, ".cache")
+	}
+	return filepath.Join(base, "ovhcloud", "completion")
+}
+
+// readCachedSuggestions returns the cached suggestions for the given key when a
+// cache file exists and is younger than completionCacheTTL.
+func readCachedSuggestions(key string) ([]string, bool) {
+	dir := completionCacheDir()
+	if dir == "" {
+		return nil, false
+	}
+
+	path := filepath.Join(dir, key)
+	info, err := os.Stat(path)
+	if err != nil || time.Since(info.ModTime()) > completionCacheTTL {
+		return nil, false
+	}
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, false
+	}
+
+	trimmed := strings.Trim(string(data), "\n")
+	if trimmed == "" {
+		return []string{}, true
+	}
+	return strings.Split(trimmed, "\n"), true
+}
+
+// writeCachedSuggestions stores suggestions for the given key. It is best-effort:
+// any error (no cache dir, write failure...) is silently ignored so completion
+// never fails because of the cache. The write is atomic (temp file + rename).
+func writeCachedSuggestions(key string, suggestions []string) {
+	dir := completionCacheDir()
+	if dir == "" {
+		return
+	}
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return
+	}
+
+	tmp, err := os.CreateTemp(dir, key+".tmp-*")
+	if err != nil {
+		return
+	}
+	defer os.Remove(tmp.Name())
+
+	if _, err := tmp.WriteString(strings.Join(suggestions, "\n")); err != nil {
+		tmp.Close()
+		return
+	}
+	if err := tmp.Close(); err != nil {
+		return
+	}
+
+	_ = os.Rename(tmp.Name(), filepath.Join(dir, key))
+}

internal/completion/cache_test.go

@@ -0,0 +1,66 @@
+// SPDX-FileCopyrightText: 2025 OVH SAS <opensource@ovh.net>
+//
+// SPDX-License-Identifier: Apache-2.0
+
+package completion
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func TestCache_WriteThenRead(t *testing.T) {
+	t.Setenv("XDG_CACHE_HOME", t.TempDir())
+
+	want := []string{"proj-1\tProd", "proj-2\tPreprod"}
+	writeCachedSuggestions("cloud-projects", want)
+
+	got, ok := readCachedSuggestions("cloud-projects")
+	if !ok {
+		t.Fatal("expected cache hit right after write")
+	}
+	if len(got) != len(want) || got[0] != want[0] || got[1] != want[1] {
+		t.Errorf("got %q, want %q", got, want)
+	}
+}
+
+func TestCache_MissWhenAbsent(t *testing.T) {
+	t.Setenv("XDG_CACHE_HOME", t.TempDir())
+
+	if _, ok := readCachedSuggestions("cloud-projects"); ok {
+		t.Error("expected a cache miss when no cache file exists")
+	}
+}
+
+func TestCache_ExpiredByTTL(t *testing.T) {
+	t.Setenv("XDG_CACHE_HOME", t.TempDir())
+
+	writeCachedSuggestions("cloud-projects", []string{"proj-1"})
+
+	// Make the cache file older than the TTL.
+	path := filepath.Join(completionCacheDir(), "cloud-projects")
+	old := time.Now().Add(-completionCacheTTL - time.Minute)
+	if err := os.Chtimes(path, old, old); err != nil {
+		t.Fatalf("failed to age cache file: %v", err)
+	}
+
+	if _, ok := readCachedSuggestions("cloud-projects"); ok {
+		t.Error("expected a cache miss for an expired cache file")
+	}
+}
+
+func TestCache_EmptyResultIsCached(t *testing.T) {
+	t.Setenv("XDG_CACHE_HOME", t.TempDir())
+
+	writeCachedSuggestions("cloud-projects", []string{})
+
+	got, ok := readCachedSuggestions("cloud-projects")
+	if !ok {
+		t.Fatal("expected a cache hit for an empty (but valid) cached result")
+	}
+	if len(got) != 0 {
+		t.Errorf("expected no suggestions, got %q", got)
+	}
+}

internal/completion/completion.go

@@ -136,6 +136,14 @@ func CloudResourceWithChild(parentTemplate, childTemplate string) func(*cobra.Co
 // CloudProjects returns completion suggestions for the --cloud-project flag.
 // Each suggestion is "projectID\tName" so shells can display the project name alongside.
 func CloudProjects(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
+	const cacheKey = "cloud-projects"
+
+	// Completion runs on every <tab>: serve from the on-disk cache when it is
+	// still fresh to avoid an API call each time.
+	if cached, ok := readCachedSuggestions(cacheKey); ok {
+		return cached, cobra.ShellCompDirectiveNoFileComp
+	}
+
 	if httpLib.Client == nil {
 		httpLib.InitClient()
 	}
@@ -153,13 +161,15 @@ func CloudProjects(_ *cobra.Command, _ []string, _ string) ([]string, cobra.Shel
 		return nil, cobra.ShellCompDirectiveNoFileComp
 	}
 
-	var suggestions []string
+	suggestions := make([]string, 0, len(projects))
 	for _, project := range projects {
 		if project.Name != "" {
 			suggestions = append(suggestions, project.ID+"\t"+project.Name)
 		} else {
 			suggestions = append(suggestions, project.ID)
 		}
 	}
+
+	writeCachedSuggestions(cacheKey, suggestions)
 	return suggestions, cobra.ShellCompDirectiveNoFileComp
 }