Create in-memory store

Signed-off-by: Alano Terblanche <18033717+Benehiko@users.noreply.github.com>

Author: Benehiko

cli/config/configfile/file.go

@@ -9,6 +9,7 @@ import (
 	"strings"
 
 	"github.com/docker/cli/cli/config/credentials"
+	"github.com/docker/cli/cli/config/memory"
 	"github.com/docker/cli/cli/config/types"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
@@ -265,8 +266,16 @@ func (configFile *ConfigFile) GetCredentialsStore(registryHostname string) crede
 	// if DOCKER_AUTH_CONFIG is set, we need to use the env store instead
 	// it falls back to native or file store if a value is not found
 	// in the environment
-	if os.Getenv("DOCKER_AUTH_CONFIG") != "" {
-		return credentials.NewEnvStore(store)
+	if v, ok := os.LookupEnv("DOCKER_AUTH_CONFIG"); ok {
+		var credentials map[string]map[string]types.AuthConfig
+		if err := json.Unmarshal([]byte(v), &credentials); err != nil {
+			return store
+		}
+		auth, ok := credentials["auth"]
+		if !ok {
+			return store
+		}
+		return memory.NewInMemoryStore(auth, memory.WithFallbackStore(store))
 	}
 
 	return store

cli/config/credentials/env_store.go

@@ -0,0 +1,88 @@
+package memory
+
+import (
+	"errors"
+	"maps"
+
+	"github.com/docker/cli/cli/config/credentials"
+	"github.com/docker/cli/cli/config/types"
+)
+
+var errValueNotFound = errors.New("value not found")
+
+func IsErrValueNotFound(err error) bool {
+	return errors.Is(err, errValueNotFound)
+}
+
+type memoryStore struct {
+	memoryCredentials map[string]types.AuthConfig
+	fallbackStore     credentials.Store
+}
+
+func (e *memoryStore) Erase(serverAddress string) error {
+	delete(e.memoryCredentials, serverAddress)
+
+	if e.fallbackStore != nil {
+		if err := e.fallbackStore.Erase(serverAddress); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (e *memoryStore) Get(serverAddress string) (types.AuthConfig, error) {
+	authConfig, ok := e.memoryCredentials[serverAddress]
+	if !ok {
+		if e.fallbackStore != nil {
+			return e.fallbackStore.Get(serverAddress)
+		}
+		return types.AuthConfig{}, errValueNotFound
+	}
+	return authConfig, nil
+}
+
+func (e *memoryStore) GetAll() (map[string]types.AuthConfig, error) {
+	credentials := make(map[string]types.AuthConfig)
+
+	if e.fallbackStore != nil {
+		fileCredentials, err := e.fallbackStore.GetAll()
+		if err == nil {
+			credentials = fileCredentials
+		}
+	}
+
+	// override the file credentials with the env credentials
+	maps.Copy(credentials, e.memoryCredentials)
+	return credentials, nil
+}
+
+func (e *memoryStore) Store(authConfig types.AuthConfig) error {
+	e.memoryCredentials[authConfig.ServerAddress] = authConfig
+
+	if e.fallbackStore != nil {
+		return e.fallbackStore.Store(authConfig)
+	}
+	return nil
+}
+
+func WithFallbackStore(store credentials.Store) func(*memoryStore) {
+	return func(s *memoryStore) {
+		s.fallbackStore = store
+	}
+}
+
+// NewInMemoryStore creates a new credentials store
+// from config.
+//
+// Using the `WithFallbackStore` option, it can be configured to
+// use a fallback store to retrieve credentials.
+func NewInMemoryStore(config map[string]types.AuthConfig, opts ...func(*memoryStore)) credentials.Store {
+	m := &memoryStore{
+		memoryCredentials: config,
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}

cli/config/memory/env_store.go

@@ -1,74 +1,58 @@
-package credentials
+package memory
 
 import (
-	"encoding/json"
 	"testing"
 
 	"github.com/docker/cli/cli/config/types"
 	"gotest.tools/v3/assert"
 )
 
 func TestEnvStore(t *testing.T) {
-	envConfig := map[string]types.AuthConfig{
+	config := map[string]types.AuthConfig{
 		"https://example.com": {
 			Email:         "something-something",
 			ServerAddress: "https://example.com",
 			Auth:          "super_secret_token",
 		},
 	}
-	d, err := json.Marshal(map[string]map[string]types.AuthConfig{
-		"auth": envConfig,
-	})
-	assert.NilError(t, err)
-
-	t.Setenv("DOCKER_AUTH_CONFIG", string(d))
 
-	fileConfig := map[string]types.AuthConfig{
+	fallbackConfig := map[string]types.AuthConfig{
 		"https://only-in-file.com": {
 			Email:         "something-something",
 			ServerAddress: "https://only-in-file.com",
 			Auth:          "super_secret_token",
 		},
 	}
 
-	var saveCount int
-	fileStore := NewFileStore(&fakeStore{
-		configs: fileConfig,
-		saveFn: func(*fakeStore) error {
-			saveCount++
-			return nil
-		},
-	})
+	fallbackStore := NewInMemoryStore(fallbackConfig)
 
-	envStore := NewEnvStore(fileStore)
+	memoryStore := NewInMemoryStore(config, WithFallbackStore(fallbackStore))
 
 	t.Run("case=get credentials from env", func(t *testing.T) {
-		c, err := envStore.Get("https://example.com")
+		c, err := memoryStore.Get("https://example.com")
 		assert.NilError(t, err)
-		assert.Equal(t, c, envConfig["https://example.com"])
+		assert.Equal(t, c, config["https://example.com"])
 	})
 
 	t.Run("case=get credentials from file", func(t *testing.T) {
-		c, err := envStore.Get("https://only-in-file.com")
+		c, err := memoryStore.Get("https://only-in-file.com")
 		assert.NilError(t, err)
-		assert.Equal(t, c, fileConfig["https://only-in-file.com"])
+		assert.Equal(t, c, fallbackConfig["https://only-in-file.com"])
 	})
 
 	t.Run("case=storing credentials should not update env", func(t *testing.T) {
-		err := envStore.Store(types.AuthConfig{
+		err := memoryStore.Store(types.AuthConfig{
 			Email:         "not-in-env",
 			ServerAddress: "https://not-in-env",
 			Auth:          "not-in-env",
 		})
 		assert.NilError(t, err)
-		assert.Equal(t, saveCount, 1)
 	})
 
 	t.Run("case=delete credentials should not update env", func(t *testing.T) {
-		err := envStore.Erase("https://example.com")
-		assert.NilError(t, err)
-		c, err := envStore.Get("https://example.com")
+		err := memoryStore.Erase("https://example.com")
 		assert.NilError(t, err)
-		assert.Equal(t, c, envConfig["https://example.com"])
+		_, err = memoryStore.Get("https://example.com")
+		assert.Equal(t, IsErrValueNotFound(err), true)
 	})
 }