feat: add overriding auth provider for adding custom auth on top of another provider, add option for user-defined logger

Author: silenium-dev

examples/pull/main.go

@@ -2,29 +2,36 @@ package main
 
 import (
 	"context"
-	"fmt"
 	"github.com/distribution/reference"
+	"github.com/docker/docker/api/types/registry"
 	client2 "github.com/docker/docker/client"
 	"github.com/silenium-dev/docker-wrapper/pkg/client"
 	"github.com/silenium-dev/docker-wrapper/pkg/client/auth"
+	"go.uber.org/zap"
 	"time"
 )
 
 func main() {
+	logger := zap.Must(zap.NewDevelopment()).Sugar()
 	authProvider, err := auth.NewDefaultProvider()
 	if err != nil {
 		panic(err)
 	}
+	override := auth.NewOverridingProvider(
+		authProvider, map[string]registry.AuthConfig{},
+		auth.WithSugaredLogger(logger.With(zap.String("component", "auth-provider"))),
+	).WithOverride("quay.io", registry.AuthConfig{})
 	cli, err := client.NewWithOpts(
-		client.WithAuthProvider(authProvider),
+		client.WithAuthProvider(override),
 		client.FromEnv,
 		client.WithDockerOpts(client2.WithTimeout(time.Hour*1)),
+		client.WithSugaredLogger(logger.With(zap.String("component", "docker-client"))),
 	)
 	if err != nil {
 		panic(err)
 	}
-	//ref, err := reference.ParseDockerRef("quay.io/prometheus/node-exporter@sha256:a25fbdaa3e4d03e0d735fd03f231e9a48332ecf40ca209b2f103b1f970d1cde0")
-	ref, err := reference.ParseDockerRef("localstack/localstack:latest")
+	ref, err := reference.ParseDockerRef("quay.io/prometheus/prometheus:latest")
+	//ref, err := reference.ParseDockerRef("localstack/localstack:latest")
 	if err != nil {
 		panic(err)
 	}
@@ -34,14 +41,14 @@ func main() {
 	}
 	for state := range stateChan {
 		print("\033[2J")
-		fmt.Printf("%s\n", state.Status())
+		logger.Infof("%s", state.Status())
 		for idx, l := range state.Layers() {
-			fmt.Printf("%02d [%s]: %s\n", idx, l.Id(), l.Status())
+			logger.Infof("%02d [%s]: %s", idx, l.Id(), l.Status())
 		}
 	}
 	digest, err := cli.Pull(context.Background(), ref)
 	if err != nil {
 		panic(err)
 	}
-	fmt.Printf("Digest: %s\n", digest)
+	logger.Infof("Digest: %s\n", digest)
 }

go.mod

@@ -9,6 +9,7 @@ require (
 	github.com/docker/docker v25.0.10+incompatible
 	github.com/docker/go-units v0.5.0
 	github.com/opencontainers/go-digest v1.0.0
+	go.uber.org/zap v1.27.0
 )
 
 require (
@@ -29,6 +30,7 @@ require (
 	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.37.0 // indirect
 	go.opentelemetry.io/otel/metric v1.37.0 // indirect
 	go.opentelemetry.io/otel/trace v1.37.0 // indirect
+	go.uber.org/multierr v1.11.0 // indirect
 	golang.org/x/sys v0.34.0 // indirect
 	golang.org/x/time v0.12.0 // indirect
 	gotest.tools/v3 v3.5.2 // indirect

go.sum

@@ -75,6 +75,12 @@ go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mx
 go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
 go.opentelemetry.io/proto/otlp v1.7.0 h1:jX1VolD6nHuFzOYso2E73H85i92Mv8JQYk0K9vz09os=
 go.opentelemetry.io/proto/otlp v1.7.0/go.mod h1:fSKjH6YJ7HDlwzltzyMj036AJ3ejJLCgCSHGj4efDDo=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
+go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
+go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=
+go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=

pkg/client/auth/api.go

@@ -0,0 +1,40 @@
+package auth
+
+import (
+	"github.com/distribution/reference"
+	"github.com/docker/docker/api/types/registry"
+	"go.uber.org/zap"
+)
+
+type Provider interface {
+	AuthConfig(ref reference.Named) registry.AuthConfig
+}
+
+type ProviderConfig struct {
+	Logger *zap.SugaredLogger
+}
+
+type Opt func(config *ProviderConfig)
+
+func WithLogger(logger *zap.Logger) Opt {
+	return func(config *ProviderConfig) {
+		config.Logger = logger.Sugar()
+	}
+}
+
+func WithSugaredLogger(logger *zap.SugaredLogger) Opt {
+	return func(config *ProviderConfig) {
+		config.Logger = logger
+	}
+}
+
+func renderConfig(opts []Opt) *ProviderConfig {
+	config := &ProviderConfig{}
+	for _, opt := range opts {
+		opt(config)
+	}
+	if config.Logger == nil {
+		config.Logger = zap.Must(zap.NewDevelopment()).Sugar()
+	}
+	return config
+}

pkg/client/auth/default.go

@@ -7,34 +7,35 @@ import (
 	"github.com/cpuguy83/dockercfg"
 	"github.com/distribution/reference"
 	"github.com/docker/docker/api/types/registry"
-	"log"
 	"os"
 )
 
 type DefaultAuthProvider struct {
 	authConfigs map[string]*registry.AuthConfig
+	config      *ProviderConfig
 }
 
 func (d *DefaultAuthProvider) AuthConfig(ref reference.Named) registry.AuthConfig {
 	domain := reference.Domain(ref)
 	if ac, ok := d.authConfigs[domain]; ok {
-		log.Printf("using auth config for %s", domain)
+		d.config.Logger.Debugf("using auth config for %s", domain)
 		return *ac
 	}
-	log.Printf("no auth config for %s", domain)
+	d.config.Logger.Debugf("no auth config for %s", domain)
 	return registry.AuthConfig{}
 }
 
-func NewDefaultProvider() (*DefaultAuthProvider, error) {
+func NewDefaultProvider(opts ...Opt) (*DefaultAuthProvider, error) {
+	config := renderConfig(opts)
+
 	authConfigs := map[string]*registry.AuthConfig{}
 
 	cfg, err := dockercfg.LoadDefaultConfig()
 	if err != nil && !errors.Is(err, os.ErrNotExist) {
-		log.Printf("failed to load docker config: %v", err)
+		config.Logger.Errorf("failed to load docker config: %v", err)
 		return nil, err
 	} else if errors.Is(err, os.ErrNotExist) {
-		log.Printf("docker config not found, using empty config")
-		return &DefaultAuthProvider{authConfigs}, nil
+		return &DefaultAuthProvider{authConfigs, config}, nil
 	}
 
 	for k, v := range cfg.AuthConfigs {
@@ -50,7 +51,7 @@ func NewDefaultProvider() (*DefaultAuthProvider, error) {
 		if ac.Username == "" && ac.Password == "" {
 			err := getCredentials(k, &cfg, ac)
 			if err != nil {
-				log.Printf("failed to get credentials for registry %s: %v", k, err)
+				config.Logger.Errorf("failed to get credentials for registry %s: %v", k, err)
 				continue
 			}
 		}
@@ -63,10 +64,10 @@ func NewDefaultProvider() (*DefaultAuthProvider, error) {
 	for k := range cfg.CredentialHelpers {
 		err := getCredentials(k, &cfg, authConfigs[k])
 		if err != nil {
-			log.Printf("failed to get credentials for registry %s: %v", k, err)
+			config.Logger.Errorf("failed to get credentials for registry %s: %v", k, err)
 		}
 	}
-	return &DefaultAuthProvider{authConfigs}, nil
+	return &DefaultAuthProvider{authConfigs, config}, nil
 }
 
 func getCredentials(registryHost string, cfg *dockercfg.Config, ac *registry.AuthConfig) error {

pkg/client/auth/overriding.go

@@ -0,0 +1,35 @@
+package auth
+
+import (
+	"github.com/distribution/reference"
+	"github.com/docker/docker/api/types/registry"
+	"maps"
+)
+
+type OverridingAuthProvider struct {
+	source    Provider
+	overrides map[string]registry.AuthConfig
+	config    *ProviderConfig
+}
+
+func NewOverridingProvider(
+	source Provider, overrides map[string]registry.AuthConfig, opts ...Opt,
+) *OverridingAuthProvider {
+	config := renderConfig(opts)
+	return &OverridingAuthProvider{source, overrides, config}
+}
+
+func (o *OverridingAuthProvider) WithOverride(domain string, ac registry.AuthConfig) *OverridingAuthProvider {
+	overrides := maps.Clone(o.overrides)
+	overrides[domain] = ac
+	return NewOverridingProvider(o.source, overrides)
+}
+
+func (o *OverridingAuthProvider) AuthConfig(ref reference.Named) registry.AuthConfig {
+	if ac, ok := o.overrides[reference.Domain(ref)]; ok {
+		o.config.Logger.Debugf("using override for %s", reference.Domain(ref))
+		return ac
+	}
+	o.config.Logger.Debugf("no override present for %s", reference.Domain(ref))
+	return o.source.AuthConfig(ref)
+}

pkg/client/client.go

@@ -1,20 +1,17 @@
 package client
 
 import (
-	"github.com/distribution/reference"
-	"github.com/docker/docker/api/types/registry"
 	"github.com/docker/docker/client"
+	"github.com/silenium-dev/docker-wrapper/pkg/client/auth"
+	"go.uber.org/zap"
 	"slices"
 )
 
-type AuthProvider interface {
-	AuthConfig(named reference.Named) registry.AuthConfig
-}
-
 type Client struct {
 	*client.Client
 	dockerOpts   []client.Opt
-	authProvider AuthProvider
+	authProvider auth.Provider
+	logger       *zap.SugaredLogger
 }
 
 type Opt func(*Client) error
@@ -27,6 +24,11 @@ func NewWithOpts(opts ...Opt) (*Client, error) {
 			return nil, err
 		}
 	}
+
+	if c.logger == nil {
+		c.logger = zap.Must(zap.NewDevelopment()).Sugar()
+	}
+
 	cli, err := client.NewClientWithOpts(c.dockerOpts...)
 	if err != nil {
 		return nil, err
@@ -39,13 +41,27 @@ func (c *Client) Close() error {
 	return c.Client.Close()
 }
 
-func WithAuthProvider(authProvider AuthProvider) Opt {
+func WithAuthProvider(authProvider auth.Provider) Opt {
 	return func(c *Client) error {
 		c.authProvider = authProvider
 		return nil
 	}
 }
 
+func WithSugaredLogger(logger *zap.SugaredLogger) Opt {
+	return func(c *Client) error {
+		c.logger = logger
+		return nil
+	}
+}
+
+func WithLogger(logger *zap.Logger) Opt {
+	return func(c *Client) error {
+		c.logger = logger.Sugar()
+		return nil
+	}
+}
+
 func WithDockerOpts(opts ...client.Opt) Opt {
 	return func(c *Client) error {
 		c.dockerOpts = slices.Concat(c.dockerOpts, opts)

pkg/client/pull.go

@@ -24,6 +24,7 @@ func (c *Client) PullWithEvents(ctx context.Context, ref reference.Named) (chan
 	var encodedAuth string
 	var err error
 	if c.authProvider != nil {
+		c.logger.Debugf("using configured auth provider")
 		encodedAuth, err = registry.EncodeAuthConfig(c.authProvider.AuthConfig(ref))
 		if err != nil {
 			return nil, err
@@ -44,8 +45,9 @@ func (c *Client) Pull(ctx context.Context, ref reference.Named) (digest.Digest,
 
 	var digestEvent *events.Digest
 	for event := range eventChan {
-		if _, ok := event.(*events.Digest); digestEvent == nil && ok {
-			digestEvent = event.(*events.Digest)
+		if ev, ok := event.(*events.Digest); digestEvent == nil && ok {
+			c.logger.Debugf("received digest event: %s", ev.String())
+			digestEvent = ev
 		}
 	}
 	if digestEvent == nil {

pkg/logging/logger.go

@@ -0,0 +1 @@
+package logging