From 10f91133ed66e7e8273f9f512e5bb67b39c788c9 Mon Sep 17 00:00:00 2001 From: hweawer Date: Sun, 18 Jan 2026 22:38:04 +0100 Subject: [PATCH 01/32] Tracing putTag --- build-index/cmd/cmd.go | 5 ++- build-index/tagserver/server.go | 48 ++++++++++++++++++++++------ build-index/tagserver/server_test.go | 4 ++- go.mod | 9 +++++- go.sum | 21 +++++++++--- utils/log/log.go | 23 +++++++++++++ 6 files changed, 94 insertions(+), 16 deletions(-) diff --git a/build-index/cmd/cmd.go b/build-index/cmd/cmd.go index 77f123cab..55687ada0 100644 --- a/build-index/cmd/cmd.go +++ b/build-index/cmd/cmd.go @@ -37,6 +37,7 @@ import ( "github.com/uber/kraken/utils/log" "github.com/uber-go/tally" + "go.opentelemetry.io/otel" "go.uber.org/zap" ) @@ -215,6 +216,7 @@ func Run(flags *Flags, opts ...Option) { if err != nil { log.Fatalf("Error creating tag type manager: %s", err) } + tracer := otel.Tracer("kraken-build-index") server := tagserver.New( config.TagServer, @@ -227,7 +229,8 @@ func Run(flags *Flags, opts ...Option) { remotes, tagReplicationManager, tagclient.NewProvider(tls), - depResolver) + depResolver, + tracer) go func() { log.Fatal(server.ListenAndServe()) }() diff --git a/build-index/tagserver/server.go b/build-index/tagserver/server.go index 70811717d..15cce014e 100644 --- a/build-index/tagserver/server.go +++ b/build-index/tagserver/server.go @@ -44,6 +44,10 @@ import ( "github.com/go-chi/chi" chimiddleware "github.com/go-chi/chi/middleware" "github.com/uber-go/tally" + "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp" + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/trace" ) // Server provides tag operations for the build-index. @@ -63,6 +67,8 @@ type Server struct { // For checking if a tag has all dependent blobs. depResolver tagtype.DependencyResolver + + tracer trace.Tracer } // New creates a new Server. @@ -78,6 +84,7 @@ func New( tagReplicationManager persistedretry.Manager, provider tagclient.Provider, depResolver tagtype.DependencyResolver, + tracer trace.Tracer, ) *Server { config = config.applyDefaults() @@ -97,6 +104,7 @@ func New( tagReplicationManager: tagReplicationManager, provider: provider, depResolver: depResolver, + tracer: tracer, } } @@ -109,8 +117,12 @@ func (s *Server) Handler() http.Handler { r.Get("/health", handler.Wrap(s.healthHandler)) r.Get("/readiness", handler.Wrap(s.readinessCheckHandler)) + tracingMiddleware := otelhttp.NewMiddleware("kraken-build-index", + otelhttp.WithTracerProvider(otel.GetTracerProvider())) + + // Docker push endpoint + r.With(tracingMiddleware).Put("/tags/{tag}/digest/{digest}", handler.Wrap(s.putTagHandler)) - r.Put("/tags/{tag}/digest/{digest}", handler.Wrap(s.putTagHandler)) r.Head("/tags/{tag}", handler.Wrap(s.hasTagHandler)) r.Get("/tags/{tag}", handler.Wrap(s.getTagHandler)) @@ -170,44 +182,62 @@ func (s *Server) readinessCheckHandler(w http.ResponseWriter, r *http.Request) e } func (s *Server) putTagHandler(w http.ResponseWriter, r *http.Request) error { + ctx, span := s.tracer.Start(r.Context(), "build_index.put_tag") + defer span.End() + tag, err := httputil.ParseParam(r, "tag") if err != nil { + span.RecordError(err) return err } d, err := httputil.ParseDigest(r, "digest") if err != nil { + span.RecordError(err) return err } replicate, err := strconv.ParseBool(httputil.GetQueryArg(r, "replicate", "false")) if err != nil { + span.RecordError(err) return fmt.Errorf("parse query arg `replicate`: %w", err) } - log.With("tag", tag, "digest", d.String(), "replicate", replicate).Info("Putting tag") + span.SetAttributes( + attribute.String("tag", tag), + attribute.String("digest", d.String()), + attribute.Bool("replicate", replicate), + ) + + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "replicate", replicate).Info("Putting tag") deps, err := s.depResolver.Resolve(tag, d) if err != nil { - log.With("tag", tag, "digest", d.String(), "error", err).Error("Failed to resolve dependencies") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "error", err).Error("Failed to resolve dependencies") + span.RecordError(err) return fmt.Errorf("resolve dependencies: %w", err) } - log.With("tag", tag, "digest", d.String(), "dependency_count", len(deps)).Debug("Resolved dependencies") + span.SetAttributes(attribute.Int("dependency_count", len(deps))) + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "dependency_count", len(deps)).Debug("Resolved dependencies") if err := s.putTag(tag, d, deps); err != nil { - log.With("tag", tag, "digest", d.String(), "error", err).Error("Failed to put tag") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "error", err).Error("Failed to put tag") + span.RecordError(err) return err } - log.With("tag", tag, "digest", d.String()).Info("Successfully put tag") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String()).Info("Successfully put tag") if replicate { - log.With("tag", tag, "digest", d.String()).Info("Starting tag replication") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String()).Info("Starting tag replication") if err := s.replicateTag(tag, d, deps); err != nil { - log.With("tag", tag, "digest", d.String(), "error", err).Error("Failed to replicate tag") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "error", err).Error("Failed to replicate tag") + span.RecordError(err) return err } - log.With("tag", tag, "digest", d.String()).Info("Successfully replicated tag") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String()).Info("Successfully replicated tag") } + + span.SetAttributes(attribute.Bool("success", true)) w.WriteHeader(http.StatusOK) return nil } diff --git a/build-index/tagserver/server_test.go b/build-index/tagserver/server_test.go index 90abefbfa..b6de3ff8b 100644 --- a/build-index/tagserver/server_test.go +++ b/build-index/tagserver/server_test.go @@ -43,6 +43,7 @@ import ( mockblobclient "github.com/uber/kraken/mocks/origin/blobclient" "github.com/uber/kraken/utils/httputil" "github.com/uber/kraken/utils/testutil" + "go.opentelemetry.io/otel/trace/noop" ) const ( @@ -125,7 +126,8 @@ func (m *serverMocks) handler() http.Handler { m.remotes, m.tagReplicationManager, m.provider, - m.depResolver).Handler() + m.depResolver, + noop.NewTracerProvider().Tracer("test")).Handler() } func newClusterClient(addr string) tagclient.Client { diff --git a/go.mod b/go.mod index 9ef49e565..d0979a12d 100644 --- a/go.mod +++ b/go.mod @@ -30,9 +30,12 @@ require ( github.com/pressly/goose v2.6.0+incompatible github.com/satori/go.uuid v1.2.0 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72 - github.com/stretchr/testify v1.7.4 + github.com/stretchr/testify v1.8.4 github.com/uber-go/tally v3.3.11+incompatible github.com/willf/bitset v0.0.0-20190228212526-18bd95f470f9 + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.46.0 + go.opentelemetry.io/otel v1.21.0 + go.opentelemetry.io/otel/trace v1.21.0 go.uber.org/atomic v1.5.0 go.uber.org/zap v1.10.0 golang.org/x/net v0.41.0 @@ -67,7 +70,10 @@ require ( github.com/docker/go-metrics v0.0.0-20181218153428-b84716841b82 // indirect github.com/docker/go-units v0.4.0 // indirect github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 // indirect + github.com/felixge/httpsnoop v1.0.4 // indirect github.com/garyburd/redigo v0.0.0-20150301180006-535138d7bcd7 // indirect + github.com/go-logr/logr v1.3.0 // indirect + github.com/go-logr/stdr v1.2.2 // indirect github.com/go-sql-driver/mysql v1.5.0 // indirect github.com/gofrs/uuid v0.0.0-20190320161447-2593f3d8aa45 // indirect github.com/gogo/googleapis v1.4.1 // indirect @@ -100,6 +106,7 @@ require ( github.com/yvasiyarov/gorelic v0.0.0-20180809112600-635ca6035f23 // indirect github.com/yvasiyarov/newrelic_platform_go v0.0.0-20160601141957-9c099fbc30e9 // indirect go.opencensus.io v0.22.3 // indirect + go.opentelemetry.io/otel/metric v1.21.0 // indirect go.uber.org/multierr v1.4.0 // indirect go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee // indirect golang.org/x/crypto v0.40.0 // indirect diff --git a/go.sum b/go.sum index d701d4e13..3fdfb3fb1 100644 --- a/go.sum +++ b/go.sum @@ -173,6 +173,8 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.m github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= github.com/erikstmartin/go-testdb v0.0.0-20160219214506-8d10e4a1bae5 h1:Yzb9+7DPaBjB8zlTR87/ElzFsnQfuHnVUVqpZZIcV5Y= github.com/erikstmartin/go-testdb v0.0.0-20160219214506-8d10e4a1bae5/go.mod h1:a2zkGnVExMxdzMo3M0Hi/3sEU+cWnZpSni0O6/Yb/P0= +github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= +github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= github.com/frankban/quicktest v1.11.3/go.mod h1:wRf/ReqHper53s+kmmSZizM8NamnL3IM0I9ntUbOk+k= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= github.com/garyburd/redigo v0.0.0-20150301180006-535138d7bcd7 h1:LofdAjjjqCSXMwLGgOgnE+rdPuvX9DxCqaHwKy7i/ko= @@ -190,6 +192,11 @@ github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas= github.com/go-logr/logr v0.2.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.3.0 h1:2y3SDp0ZXuc6/cjLSZ+Q3ir+QB9T/iG5yYRXqsagWSY= +github.com/go-logr/logr v1.3.0/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-openapi/jsonpointer v0.0.0-20160704185906-46af16f9f7b1/go.mod h1:+35s3my2LFTysnkMfxsJBAMHj/DoqoB9knIWoYG/Vk0= github.com/go-openapi/jsonpointer v0.19.2/go.mod h1:3akKfEdA7DF1sugOqz1dVQHBcuDBPKZGEoHC/NkiQRg= github.com/go-openapi/jsonpointer v0.19.3/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg= @@ -454,16 +461,14 @@ github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/y github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= -github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.7.4 h1:wZRexSlwd7ZXfKINDLsO4r7WBt3gTKONc6K/VesHvHM= -github.com/stretchr/testify v1.7.4/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635 h1:kdXcSzyDtseVEc4yCz2qF8ZrQvIDBJLl4S1c3GCXmoI= github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww= github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= @@ -499,6 +504,14 @@ go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.3 h1:8sGtKOrtQqkN1bp2AtX+misvLIlOmsEsNd+9NIcPEm8= go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.46.0 h1:1eHu3/pUSWaOgltNK3WJFaywKsTIr/PwvHyDmi0lQA0= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.46.0/go.mod h1:HyABWq60Uy1kjJSa2BVOxUVao8Cdick5AWSKPutqy6U= +go.opentelemetry.io/otel v1.21.0 h1:hzLeKBZEL7Okw2mGzZ0cc4k/A7Fta0uoPgaJCr8fsFc= +go.opentelemetry.io/otel v1.21.0/go.mod h1:QZzNPQPm1zLX4gZK4cMi+71eaorMSGT3A4znnUvNNEo= +go.opentelemetry.io/otel/metric v1.21.0 h1:tlYWfeo+Bocx5kLEloTjbcDwBuELRrIFxwdQ36PlJu4= +go.opentelemetry.io/otel/metric v1.21.0/go.mod h1:o1p3CA8nNHW8j5yuQLdc1eeqEaPfzug24uvsyIEJRWM= +go.opentelemetry.io/otel/trace v1.21.0 h1:WD9i5gzvoUPuXIXH24ZNBudiarZDKuekPqi/E8fpfLc= +go.opentelemetry.io/otel/trace v1.21.0/go.mod h1:LGbsEB0f9LGjN+OZaQQ26sohbOmiMR+BaslueVtS/qQ= go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.5.0 h1:OI5t8sDa1Or+q8AeE+yKeB/SDYioSHAgcVljj9JIETY= diff --git a/utils/log/log.go b/utils/log/log.go index 021d35609..f2d54a625 100644 --- a/utils/log/log.go +++ b/utils/log/log.go @@ -18,6 +18,9 @@ package log // and hides out some initialization details import ( + "context" + + "go.opentelemetry.io/otel/trace" "go.uber.org/zap" "go.uber.org/zap/zapcore" ) @@ -170,3 +173,23 @@ func Fatalw(msg string, keysAndValues ...interface{}) { func With(args ...interface{}) *zap.SugaredLogger { return Default().With(args...) } + +// WithTraceContext returns a logger with trace_id and span_id fields extracted from the context. +// If the context doesn't contain a valid span, returns the default logger. +// +// Usage: +// ctx, span := tracer.Start(r.Context(), "operation") +// defer span.End() +// log.WithTraceContext(ctx).With("key", "value").Info("message") +// +// Output will include: {"trace_id": "abc123...", "span_id": "def456...", "key": "value", "message": "..."} +func WithTraceContext(ctx context.Context) *zap.SugaredLogger { + spanCtx := trace.SpanContextFromContext(ctx) + if spanCtx.IsValid() { + return Default().With( + "trace_id", spanCtx.TraceID().String(), + "span_id", spanCtx.SpanID().String(), + ) + } + return Default() +} From ba94f3c2fbe651004644f6391e7b91ee317f0cc9 Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 19 Jan 2026 10:39:11 +0100 Subject: [PATCH 02/32] Nginx and logs in functions --- build-index/tagserver/server.go | 45 +++++++++++++++++---------------- nginx/config/build-index.go | 4 +++ 2 files changed, 27 insertions(+), 22 deletions(-) diff --git a/build-index/tagserver/server.go b/build-index/tagserver/server.go index 15cce014e..d2ae3484e 100644 --- a/build-index/tagserver/server.go +++ b/build-index/tagserver/server.go @@ -14,6 +14,7 @@ package tagserver import ( + "context" "encoding/json" "fmt" "io" @@ -219,7 +220,7 @@ func (s *Server) putTagHandler(w http.ResponseWriter, r *http.Request) error { span.SetAttributes(attribute.Int("dependency_count", len(deps))) log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "dependency_count", len(deps)).Debug("Resolved dependencies") - if err := s.putTag(tag, d, deps); err != nil { + if err := s.putTag(ctx, tag, d, deps); err != nil { log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "error", err).Error("Failed to put tag") span.RecordError(err) return err @@ -229,7 +230,7 @@ func (s *Server) putTagHandler(w http.ResponseWriter, r *http.Request) error { if replicate { log.WithTraceContext(ctx).With("tag", tag, "digest", d.String()).Info("Starting tag replication") - if err := s.replicateTag(tag, d, deps); err != nil { + if err := s.replicateTag(ctx, tag, d, deps); err != nil { log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "error", err).Error("Failed to replicate tag") span.RecordError(err) return err @@ -439,7 +440,7 @@ func (s *Server) replicateTagHandler(w http.ResponseWriter, r *http.Request) err log.With("tag", tag, "digest", d.String(), "dependency_count", len(deps)).Debug("Resolved dependencies for replication") - if err := s.replicateTag(tag, d, deps); err != nil { + if err := s.replicateTag(r.Context(), tag, d, deps); err != nil { log.With("tag", tag, "digest", d.String()).Errorf("Failed to replicate tag: %s", err) return err } @@ -491,8 +492,8 @@ func (s *Server) getOriginHandler(w http.ResponseWriter, r *http.Request) error return nil } -func (s *Server) putTag(tag string, d core.Digest, deps core.DigestList) error { - log.With("tag", tag, "digest", d.String(), "dependency_count", len(deps)).Debug("Validating tag dependencies") +func (s *Server) putTag(ctx context.Context, tag string, d core.Digest, deps core.DigestList) error { + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "dependency_count", len(deps)).Debug("Validating tag dependencies") for _, dep := range deps { if _, err := s.localOriginClient.Stat(tag, dep); err == blobclient.ErrBlobNotFound { @@ -502,18 +503,18 @@ func (s *Server) putTag(tag string, d core.Digest, deps core.DigestList) error { } } - log.With("tag", tag, "digest", d.String()).Debug("All dependencies validated successfully") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String()).Debug("All dependencies validated successfully") if err := s.store.Put(tag, d, 0); err != nil { return fmt.Errorf("storage: %w", err) } - log.With("tag", tag, "digest", d.String()).Info("Tag stored locally") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String()).Info("Tag stored locally") neighbors := s.neighbors.Resolve() neighborCount := len(neighbors) - log.With("tag", tag, "digest", d.String(), "neighbor_count", neighborCount).Debug("Starting neighbor replication") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "neighbor_count", neighborCount).Debug("Starting neighbor replication") var delay time.Duration var successes int @@ -521,46 +522,46 @@ func (s *Server) putTag(tag string, d core.Digest, deps core.DigestList) error { delay += s.config.DuplicatePutStagger client := s.provider.Provide(addr) if err := client.DuplicatePut(tag, d, delay); err != nil { - log.With("tag", tag, "digest", d.String(), "neighbor", addr, "delay", delay, "error", err).Error("Failed to duplicate put to neighbor") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "neighbor", addr, "delay", delay, "error", err).Error("Failed to duplicate put to neighbor") } else { successes++ - log.With("tag", tag, "digest", d.String(), "neighbor", addr, "delay", delay).Debug("Successfully duplicated put to neighbor") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "neighbor", addr, "delay", delay).Debug("Successfully duplicated put to neighbor") } } - log.With("tag", tag, "digest", d.String(), "total_neighbors", neighborCount, "successful_neighbors", successes, "failed_neighbors", neighborCount-successes).Info("Completed neighbor replication") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "total_neighbors", neighborCount, "successful_neighbors", successes, "failed_neighbors", neighborCount-successes).Info("Completed neighbor replication") if len(neighbors) != 0 && successes == 0 { s.stats.Counter("duplicate_put_failures").Inc(1) - log.With("tag", tag, "digest", d.String(), "neighbor_count", neighborCount).Error("All neighbor replications failed") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "neighbor_count", neighborCount).Error("All neighbor replications failed") } return nil } -func (s *Server) replicateTag(tag string, d core.Digest, deps core.DigestList) error { +func (s *Server) replicateTag(ctx context.Context, tag string, d core.Digest, deps core.DigestList) error { destinations := s.remotes.Match(tag) - log.With("tag", tag, "digest", d.String(), "destination_count", len(destinations)).Debug("Checking remote destinations for tag replication") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "destination_count", len(destinations)).Debug("Checking remote destinations for tag replication") if len(destinations) == 0 { - log.With("tag", tag, "digest", d.String()).Debug("No remote destinations configured for tag") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String()).Debug("No remote destinations configured for tag") return nil } - log.With("tag", tag, "digest", d.String(), "destinations", destinations).Info("Adding remote replication tasks") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "destinations", destinations).Info("Adding remote replication tasks") for _, dest := range destinations { task := tagreplication.NewTask(tag, d, deps, dest, 0) if err := s.tagReplicationManager.Add(task); err != nil { return fmt.Errorf("add replicate task: %w", err) } - log.With("tag", tag, "digest", d.String(), "destination", dest).Debug("Added remote replication task") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "destination", dest).Debug("Added remote replication task") } neighbors := s.neighbors.Resolve() neighborCount := len(neighbors) - log.With("tag", tag, "digest", d.String(), "neighbor_count", neighborCount).Debug("Notifying neighbors about remote replication") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "neighbor_count", neighborCount).Debug("Notifying neighbors about remote replication") var delay time.Duration var successes int @@ -568,18 +569,18 @@ func (s *Server) replicateTag(tag string, d core.Digest, deps core.DigestList) e delay += s.config.DuplicateReplicateStagger client := s.provider.Provide(addr) if err := client.DuplicateReplicate(tag, d, deps, delay); err != nil { - log.With("tag", tag, "digest", d.String(), "neighbor", addr, "delay", delay).Errorf("Failed to notify neighbor about replication: %s", err) + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "neighbor", addr, "delay", delay).Errorf("Failed to notify neighbor about replication: %s", err) } else { successes++ - log.With("tag", tag, "digest", d.String(), "neighbor", addr, "delay", delay).Debug("Successfully notified neighbor about replication") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "neighbor", addr, "delay", delay).Debug("Successfully notified neighbor about replication") } } - log.With("tag", tag, "digest", d.String(), "remote_destinations", len(destinations), "notified_neighbors", successes, "failed_neighbors", neighborCount-successes).Info("Completed remote replication setup") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "remote_destinations", len(destinations), "notified_neighbors", successes, "failed_neighbors", neighborCount-successes).Info("Completed remote replication setup") if len(neighbors) != 0 && successes == 0 { s.stats.Counter("duplicate_replicate_failures").Inc(1) - log.With("tag", tag, "digest", d.String(), "neighbor_count", neighborCount).Error("All neighbor replication notifications failed") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "neighbor_count", neighborCount).Error("All neighbor replication notifications failed") } return nil } diff --git a/nginx/config/build-index.go b/nginx/config/build-index.go index a7a7ca670..73ad55481 100644 --- a/nginx/config/build-index.go +++ b/nginx/config/build-index.go @@ -31,6 +31,10 @@ server { access_log {{.access_log_path}}; error_log {{.error_log_path}}; + proxy_set_header traceparent $http_traceparent; + proxy_set_header tracestate $http_tracestate; + proxy_set_header jaeger-debug-id $http_jaeger_debug_id; + {{healthEndpoint "build-index"}} location / { From bba1aae87e6859191a23fd96c6e013ee0a94de58 Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 19 Jan 2026 13:00:42 +0100 Subject: [PATCH 03/32] Tracing executor tasks --- build-index/cmd/cmd.go | 5 +- build-index/tagserver/server.go | 26 ++++- build-index/tagserver/server_test.go | 6 +- build-index/tagstore/store.go | 7 +- build-index/tagstore/store_test.go | 5 +- lib/persistedretry/writeback/executor.go | 103 ++++++++++++++-- lib/persistedretry/writeback/executor_test.go | 4 +- lib/persistedretry/writeback/store.go | 14 ++- lib/persistedretry/writeback/task.go | 93 +++++++++++++++ localdb/migrations/00003_writeback_tracing.go | 64 ++++++++++ mocks/agent/agentclient/client.go | 16 +-- mocks/build-index/tagclient/client.go | 94 +++++++-------- mocks/build-index/tagclient/provider.go | 12 +- mocks/build-index/tagstore/filestore.go | 20 ++-- mocks/build-index/tagstore/store.go | 25 ++-- .../build-index/tagtype/dependencyresolver.go | 12 +- mocks/io/mock_closer.go | 48 -------- mocks/lib/backend/gcsbackend/gcs.go | 28 ++--- .../lib/backend/hdfsbackend/webhdfs/client.go | 32 ++--- mocks/lib/backend/s3backend/s3.go | 24 ++-- .../lib/containerruntime/containerd/client.go | 12 +- .../dockerdaemon/dockerclient.go | 12 +- mocks/lib/containerruntime/factory.go | 16 +-- .../transfer/imagetransferer.go | 32 ++--- mocks/lib/hashring/ring.go | 24 ++-- mocks/lib/hashring/watcher.go | 12 +- mocks/lib/healthcheck/checker.go | 12 +- mocks/lib/healthcheck/filter.go | 12 +- mocks/lib/healthcheck/passivefilter.go | 16 +-- mocks/lib/hostlist/list.go | 12 +- mocks/lib/persistedretry/executor.go | 16 +-- mocks/lib/persistedretry/manager.go | 24 ++-- mocks/lib/persistedretry/store.go | 40 +++---- .../tagreplication/remotevalidator.go | 12 +- mocks/lib/persistedretry/task.go | 24 ++-- mocks/lib/store/filereadwriter.go | 44 +++---- .../torrent/scheduler/reloadablescheduler.go | 32 ++--- mocks/lib/torrent/scheduler/scheduler.go | 28 ++--- mocks/origin/blobclient/client.go | 110 +++++++++--------- mocks/origin/blobclient/clientresolver.go | 12 +- mocks/origin/blobclient/clusterclient.go | 70 +++++------ mocks/origin/blobclient/clusterprovider.go | 12 +- mocks/origin/blobclient/provider.go | 12 +- mocks/tracker/announceclient/client.go | 65 +---------- mocks/tracker/metainfoclient/client.go | 12 +- mocks/tracker/originstore/store.go | 12 +- mocks/tracker/peerstore/store.go | 20 ++-- mocks/utils/dedup/intervaltask.go | 12 +- mocks/utils/dedup/taskrunner.go | 12 +- mocks/utils/httputil/roundtripper.go | 12 +- origin/blobserver/server.go | 19 +-- origin/cmd/cmd.go | 4 +- 52 files changed, 776 insertions(+), 626 deletions(-) create mode 100644 localdb/migrations/00003_writeback_tracing.go delete mode 100644 mocks/io/mock_closer.go diff --git a/build-index/cmd/cmd.go b/build-index/cmd/cmd.go index 55687ada0..b32abd3f8 100644 --- a/build-index/cmd/cmd.go +++ b/build-index/cmd/cmd.go @@ -201,11 +201,13 @@ func Run(flags *Flags, opts ...Option) { log.Fatalf("Error creating tag replication manager: %s", err) } + tracer := otel.Tracer("kraken-build-index") + writeBackManager, err := persistedretry.NewManager( config.WriteBack, stats, writeback.NewStore(localDB), - writeback.NewExecutor(stats, ss, backends)) + writeback.NewExecutor(stats, ss, backends, tracer)) if err != nil { log.Fatalf("Error creating write-back manager: %s", err) } @@ -216,7 +218,6 @@ func Run(flags *Flags, opts ...Option) { if err != nil { log.Fatalf("Error creating tag type manager: %s", err) } - tracer := otel.Tracer("kraken-build-index") server := tagserver.New( config.TagServer, diff --git a/build-index/tagserver/server.go b/build-index/tagserver/server.go index d2ae3484e..52ba722aa 100644 --- a/build-index/tagserver/server.go +++ b/build-index/tagserver/server.go @@ -139,7 +139,7 @@ func (s *Server) Handler() http.Handler { "/internal/duplicate/remotes/tags/{tag}/digest/{digest}", handler.Wrap(s.duplicateReplicateTagHandler)) - r.Put( + r.With(tracingMiddleware).Put( "/internal/duplicate/tags/{tag}/digest/{digest}", handler.Wrap(s.duplicatePutTagHandler)) @@ -244,30 +244,44 @@ func (s *Server) putTagHandler(w http.ResponseWriter, r *http.Request) error { } func (s *Server) duplicatePutTagHandler(w http.ResponseWriter, r *http.Request) error { + ctx, span := s.tracer.Start(r.Context(), "build_index.duplicate_put_tag") + defer span.End() + tag, err := httputil.ParseParam(r, "tag") if err != nil { + span.RecordError(err) return err } d, err := httputil.ParseDigest(r, "digest") if err != nil { + span.RecordError(err) return err } var req tagclient.DuplicatePutRequest if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + span.RecordError(err) return handler.Errorf("decode body: %s", err) } delay := req.Delay - log.With("tag", tag, "digest", d.String(), "delay", delay).Debug("Received duplicate put request from neighbor") + span.SetAttributes( + attribute.String("tag", tag), + attribute.String("digest", d.String()), + attribute.Int64("delay_ms", delay.Milliseconds()), + ) + + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "delay", delay).Debug("Received duplicate put request from neighbor") - if err := s.store.Put(tag, d, delay); err != nil { - log.With("tag", tag, "digest", d.String(), "delay", delay, "error", err).Error("Failed to store tag from duplicate put") + if err := s.store.Put(ctx, tag, d, delay); err != nil { + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "delay", delay, "error", err).Error("Failed to store tag from duplicate put") + span.RecordError(err) return handler.Errorf("storage: %s", err) } - log.With("tag", tag, "digest", d.String(), "delay", delay).Info("Successfully stored tag from duplicate put") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "delay", delay).Info("Successfully stored tag from duplicate put") + span.SetAttributes(attribute.Bool("success", true)) w.WriteHeader(http.StatusOK) return nil } @@ -505,7 +519,7 @@ func (s *Server) putTag(ctx context.Context, tag string, d core.Digest, deps cor log.WithTraceContext(ctx).With("tag", tag, "digest", d.String()).Debug("All dependencies validated successfully") - if err := s.store.Put(tag, d, 0); err != nil { + if err := s.store.Put(ctx, tag, d, 0); err != nil { return fmt.Errorf("storage: %w", err) } diff --git a/build-index/tagserver/server_test.go b/build-index/tagserver/server_test.go index b6de3ff8b..2e5ec3826 100644 --- a/build-index/tagserver/server_test.go +++ b/build-index/tagserver/server_test.go @@ -231,7 +231,7 @@ func TestPut(t *testing.T) { mocks.depResolver.EXPECT().Resolve(tag, digest).Return(core.DigestList{digest}, nil) mocks.originClient.EXPECT().Stat(tag, digest).Return(core.NewBlobInfo(256), nil) - mocks.store.EXPECT().Put(tag, digest, time.Duration(0)).Return(nil) + mocks.store.EXPECT().Put(gomock.Any(), tag, digest, time.Duration(0)).Return(nil) mocks.provider.EXPECT().Provide(_testNeighbor).Return(neighborClient) neighborClient.EXPECT().DuplicatePut( tag, digest, mocks.config.DuplicateReplicateStagger).Return(nil) @@ -294,7 +294,7 @@ func TestDuplicatePut(t *testing.T) { digest := core.DigestFixture() delay := 5 * time.Minute - mocks.store.EXPECT().Put(tag, digest, delay).Return(nil) + mocks.store.EXPECT().Put(gomock.Any(), tag, digest, delay).Return(nil) require.NoError(client.DuplicatePut(tag, digest, delay)) } @@ -541,7 +541,7 @@ func TestPutAndReplicate(t *testing.T) { gomock.InOrder( mocks.depResolver.EXPECT().Resolve(tag, digest).Return(core.DigestList{digest}, nil), mocks.originClient.EXPECT().Stat(tag, digest).Return(core.NewBlobInfo(256), nil), - mocks.store.EXPECT().Put(tag, digest, time.Duration(0)).Return(nil), + mocks.store.EXPECT().Put(gomock.Any(), tag, digest, time.Duration(0)).Return(nil), mocks.provider.EXPECT().Provide(_testNeighbor).Return(neighborClient), neighborClient.EXPECT().DuplicatePut( tag, digest, mocks.config.DuplicateReplicateStagger).Return(nil), diff --git a/build-index/tagstore/store.go b/build-index/tagstore/store.go index a959fdd53..88c81d7e8 100644 --- a/build-index/tagstore/store.go +++ b/build-index/tagstore/store.go @@ -15,6 +15,7 @@ package tagstore import ( "bytes" + "context" "errors" "fmt" "io" @@ -48,7 +49,7 @@ type FileStore interface { // Store defines tag storage operations. type Store interface { - Put(tag string, d core.Digest, writeBackDelay time.Duration) error + Put(ctx context.Context, tag string, d core.Digest, writeBackDelay time.Duration) error Get(tag string) (core.Digest, error) } @@ -95,7 +96,7 @@ func New( return s } -func (s *tagStore) Put(tag string, d core.Digest, writeBackDelay time.Duration) error { +func (s *tagStore) Put(ctx context.Context, tag string, d core.Digest, writeBackDelay time.Duration) error { if err := s.writeTagToDisk(tag, d); err != nil { return fmt.Errorf("write tag to disk: %s", err) } @@ -103,7 +104,7 @@ func (s *tagStore) Put(tag string, d core.Digest, writeBackDelay time.Duration) return fmt.Errorf("set persist metadata: %s", err) } - task := writeback.NewTask(tag, tag, writeBackDelay) + task := writeback.NewTaskWithContext(ctx, tag, tag, writeBackDelay) return s.writeBackStrategy(task) } diff --git a/build-index/tagstore/store_test.go b/build-index/tagstore/store_test.go index c23fe4a02..861137ef8 100644 --- a/build-index/tagstore/store_test.go +++ b/build-index/tagstore/store_test.go @@ -14,6 +14,7 @@ package tagstore_test import ( + "context" "fmt" "io" "testing" @@ -81,7 +82,7 @@ func TestPutAndGetFromDisk(t *testing.T) { mocks.writeBackManager.EXPECT().Add( writeback.MatchTask(writeback.NewTask(tag, tag, 0))).Return(nil) - require.NoError(store.Put(tag, digest, 0)) + require.NoError(store.Put(context.Background(), tag, digest, 0)) result, err := store.Get(tag) require.NoError(err) @@ -102,7 +103,7 @@ func TestPutAndGetFromDiskWriteThrough(t *testing.T) { mocks.writeBackManager.EXPECT().SyncExec( writeback.MatchTask(writeback.NewTask(tag, tag, 0))).Return(nil) - require.NoError(store.Put(tag, digest, 0)) + require.NoError(store.Put(context.Background(), tag, digest, 0)) result, err := store.Get(tag) require.NoError(err) diff --git a/lib/persistedretry/writeback/executor.go b/lib/persistedretry/writeback/executor.go index 4b4105ed1..84d4f0d32 100644 --- a/lib/persistedretry/writeback/executor.go +++ b/lib/persistedretry/writeback/executor.go @@ -14,6 +14,7 @@ package writeback import ( + "context" "fmt" "os" "time" @@ -25,6 +26,10 @@ import ( "github.com/uber/kraken/lib/store/metadata" "github.com/uber/kraken/utils/closers" "github.com/uber/kraken/utils/log" + + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/codes" + "go.opentelemetry.io/otel/trace" ) // FileStore defines store operations required for write-back. @@ -38,19 +43,21 @@ type Executor struct { stats tally.Scope fs FileStore backends *backend.Manager + tracer trace.Tracer } // NewExecutor creates a new Executor. func NewExecutor( stats tally.Scope, fs FileStore, - backends *backend.Manager) *Executor { - + backends *backend.Manager, + tracer trace.Tracer, +) *Executor { stats = stats.Tagged(map[string]string{ "module": "writebackexecutor", }) - return &Executor{stats, fs, backends} + return &Executor{stats, fs, backends, tracer} } // Name returns the executor name. @@ -58,6 +65,40 @@ func (e *Executor) Name() string { return "writeback" } +// buildSpanOptions creates span options for the writeback execution span. +// If the task has trace context from the original request, it adds a span link +// to enable navigation between the async writeback and the original request in Jaeger. +// It also records whether the original request was sampled for debugging. +func buildSpanOptions(t *Task) []trace.SpanStartOption { + opts := []trace.SpanStartOption{ + trace.WithAttributes( + attribute.String("namespace", t.Namespace), + attribute.String("blob.name", t.Name), + attribute.Int("task.failures", t.Failures), + attribute.Int64("task.age_ms", time.Since(t.CreatedAt).Milliseconds()), + ), + } + + if t.HasTraceContext() { + if originSpanCtx := t.SpanContext(); originSpanCtx.IsValid() { + opts = append(opts, + trace.WithLinks(trace.Link{ + SpanContext: originSpanCtx, + Attributes: []attribute.KeyValue{ + attribute.String("link.type", "origin_request"), + }, + }), + trace.WithAttributes( + attribute.String("origin.trace_id", t.TraceID), + attribute.Bool("origin.sampled", originSpanCtx.IsSampled()), + ), + ) + } + } + + return opts +} + // Exec uploads the cache file corresponding to r's digest to the remote backend // that matches r's namespace. func (e *Executor) Exec(r persistedretry.Task) error { @@ -65,33 +106,59 @@ func (e *Executor) Exec(r persistedretry.Task) error { if !ok { return fmt.Errorf("expected *Task, got %T", r) } - if err := e.upload(t); err != nil { + + ctx, span := e.tracer.Start(context.Background(), "writeback.exec", buildSpanOptions(t)...) + defer span.End() + + if err := e.upload(ctx, t); err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, err.Error()) return err } + err := e.fs.DeleteCacheFileMetadata(t.Name, &metadata.Persist{}) if err != nil && !os.IsNotExist(err) { + span.RecordError(err) + span.SetStatus(codes.Error, "delete persist metadata failed") return fmt.Errorf("delete persist metadata: %s", err) } + + span.SetStatus(codes.Ok, "writeback completed") return nil } -func (e *Executor) upload(t *Task) error { +func (e *Executor) upload(ctx context.Context, t *Task) error { + ctx, span := e.tracer.Start(ctx, "writeback.upload", + trace.WithAttributes( + attribute.String("blob.name", t.Name), + ), + ) + defer span.End() + start := time.Now() - log.With("namespace", t.Namespace, "name", t.Name).Info("Uploading cache file to the remote backend") + log.WithTraceContext(ctx).With("namespace", t.Namespace, "name", t.Name).Info("Uploading cache file to the remote backend") client, err := e.backends.GetClient(t.Namespace) if err != nil { if err == backend.ErrNamespaceNotFound { - log.With( + log.WithTraceContext(ctx).With( "namespace", t.Namespace, "name", t.Name).Info("Dropping writeback for unconfigured namespace") + span.SetAttributes(attribute.Bool("upload.dropped", true)) + span.SetAttributes(attribute.String("upload.drop_reason", "namespace_not_found")) return nil } + span.RecordError(err) + span.SetStatus(codes.Error, "get client failed") return fmt.Errorf("get client: %s", err) } + // Check if already uploaded (stat check) if _, err := client.Stat(t.Namespace, t.Name); err == nil { // File already uploaded, no-op. + log.WithTraceContext(ctx).With("namespace", t.Namespace, "name", t.Name).Debug("Blob already exists in backend, skipping upload") + span.SetAttributes(attribute.Bool("upload.skipped", true)) + span.SetAttributes(attribute.String("upload.skip_reason", "already_exists")) return nil } @@ -100,20 +167,36 @@ func (e *Executor) upload(t *Task) error { if os.IsNotExist(err) { // Nothing we can do about this but make noise and drop the task. e.stats.Counter("missing_files").Inc(1) - log.With("name", t.Name).Error("Invariant violation: writeback cache file missing") + log.WithTraceContext(ctx).With("name", t.Name).Error("Invariant violation: writeback cache file missing") + span.SetAttributes(attribute.Bool("upload.dropped", true)) + span.SetAttributes(attribute.String("upload.drop_reason", "file_missing")) + span.RecordError(err) return nil } + span.RecordError(err) + span.SetStatus(codes.Error, "get file failed") return fmt.Errorf("get file: %s", err) } defer closers.Close(f) if err := client.Upload(t.Namespace, t.Name, f); err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, "upload failed") return fmt.Errorf("upload: %s", err) } - log.With("namespace", t.Namespace, "name", t.Name).Info("Uploaded cache file to remote backend") + + uploadDuration := time.Since(start) + log.WithTraceContext(ctx).With("namespace", t.Namespace, "name", t.Name, "duration_ms", uploadDuration.Milliseconds()).Info("Uploaded cache file to remote backend") + + span.SetAttributes( + attribute.Int64("upload.duration_ms", uploadDuration.Milliseconds()), + attribute.Int64("task.lifetime_ms", time.Since(t.CreatedAt).Milliseconds()), + attribute.Bool("upload.success", true), + ) + span.SetStatus(codes.Ok, "upload completed") // We don't want to time noops nor errors. - e.stats.Timer("upload").Record(time.Since(start)) + e.stats.Timer("upload").Record(uploadDuration) e.stats.Timer("lifetime").Record(time.Since(t.CreatedAt)) return nil diff --git a/lib/persistedretry/writeback/executor_test.go b/lib/persistedretry/writeback/executor_test.go index bfa652cab..a1104dceb 100644 --- a/lib/persistedretry/writeback/executor_test.go +++ b/lib/persistedretry/writeback/executor_test.go @@ -29,6 +29,7 @@ import ( mockbackend "github.com/uber/kraken/mocks/lib/backend" "github.com/uber/kraken/utils/mockutil" "github.com/uber/kraken/utils/testutil" + "go.opentelemetry.io/otel" ) type executorMocks struct { @@ -55,7 +56,8 @@ func newExecutorMocks(t *testing.T) (*executorMocks, func()) { } func (m *executorMocks) new() *Executor { - return NewExecutor(tally.NoopScope, m.cas, m.backends) + tracer := otel.Tracer("test-writeback") + return NewExecutor(tally.NoopScope, m.cas, m.backends, tracer) } func (m *executorMocks) client(namespace string) *mockbackend.MockClient { diff --git a/lib/persistedretry/writeback/store.go b/lib/persistedretry/writeback/store.go index 29aea16a4..d4c6758c9 100644 --- a/lib/persistedretry/writeback/store.go +++ b/lib/persistedretry/writeback/store.go @@ -122,7 +122,7 @@ func (s *Store) Find(query interface{}) ([]persistedretry.Task, error) { switch q := query.(type) { case *NameQuery: err = s.db.Select(&tasks, ` - SELECT namespace, name, created_at, last_attempt, failures, delay + SELECT namespace, name, created_at, last_attempt, failures, delay, trace_id, span_id, trace_flags FROM writeback_task WHERE name=? `, q.name) @@ -143,14 +143,20 @@ func (s *Store) addWithStatus(r persistedretry.Task, status string) error { last_attempt, failures, delay, - status + status, + trace_id, + span_id, + trace_flags ) VALUES ( :namespace, :name, :last_attempt, :failures, :delay, - %q + %q, + :trace_id, + :span_id, + :trace_flags ) `, status) t, ok := r.(*Task) @@ -169,7 +175,7 @@ func (s *Store) addWithStatus(r persistedretry.Task, status string) error { func (s *Store) selectStatus(status string) ([]persistedretry.Task, error) { var tasks []*Task err := s.db.Select(&tasks, ` - SELECT namespace, name, created_at, last_attempt, failures, delay + SELECT namespace, name, created_at, last_attempt, failures, delay, trace_id, span_id, trace_flags FROM writeback_task WHERE status=? `, status) diff --git a/lib/persistedretry/writeback/task.go b/lib/persistedretry/writeback/task.go index d98287ab7..c27eaf6a1 100644 --- a/lib/persistedretry/writeback/task.go +++ b/lib/persistedretry/writeback/task.go @@ -14,10 +14,12 @@ package writeback import ( + "context" "fmt" "time" "github.com/uber/kraken/core" + "go.opentelemetry.io/otel/trace" ) // Task contains information to write back a blob to remote storage. @@ -29,11 +31,17 @@ type Task struct { Failures int `db:"failures"` Delay time.Duration `db:"delay"` + // Trace context for linking async execution back to original request. + TraceID string `db:"trace_id"` + SpanID string `db:"span_id"` + TraceFlags string `db:"trace_flags"` // Hex string of trace flags (e.g., "01" if sampled) + // Deprecated. Use name instead. Digest core.Digest `db:"digest"` } // NewTask creates a new Task. +// Deprecated: Use NewTaskWithContext to preserve trace context. func NewTask(namespace, name string, delay time.Duration) *Task { return &Task{ Namespace: namespace, @@ -43,6 +51,91 @@ func NewTask(namespace, name string, delay time.Duration) *Task { } } +// NewTaskWithContext creates a new Task and captures the trace context from ctx. +// This allows the async writeback execution to be linked to the original request trace. +// It also captures TraceFlags to preserve the sampling decision. +func NewTaskWithContext(ctx context.Context, namespace, name string, delay time.Duration) *Task { + t := &Task{ + Namespace: namespace, + Name: name, + CreatedAt: time.Now(), + Delay: delay, + } + + // Capture trace context if available + if spanCtx := trace.SpanContextFromContext(ctx); spanCtx.IsValid() { + t.TraceID = spanCtx.TraceID().String() + t.SpanID = spanCtx.SpanID().String() + t.TraceFlags = spanCtx.TraceFlags().String() + } + + return t +} + +// HasTraceContext returns true if the task has captured trace context. +func (t *Task) HasTraceContext() bool { + return t.TraceID != "" && t.SpanID != "" +} + +// SpanContext reconstructs a trace.SpanContext from the stored trace IDs. +// Returns an invalid SpanContext if the task has no trace context or if parsing fails. +func (t *Task) SpanContext() trace.SpanContext { + if !t.HasTraceContext() { + return trace.SpanContext{} + } + + traceID, err := trace.TraceIDFromHex(t.TraceID) + if err != nil { + return trace.SpanContext{} + } + + spanID, err := trace.SpanIDFromHex(t.SpanID) + if err != nil { + return trace.SpanContext{} + } + + // Parse TraceFlags to preserve sampling decision + var traceFlags trace.TraceFlags + if t.TraceFlags != "" { + traceFlags = trace.TraceFlags(parseHexByte(t.TraceFlags)) + } + + return trace.NewSpanContext(trace.SpanContextConfig{ + TraceID: traceID, + SpanID: spanID, + TraceFlags: traceFlags, + Remote: true, + }) +} + +// parseHexByte parses a hex string (e.g., "01") to a byte. +func parseHexByte(s string) byte { + if len(s) != 2 { + return 0 + } + var b byte + for _, c := range s { + b <<= 4 + switch { + case c >= '0' && c <= '9': + b |= byte(c - '0') + case c >= 'a' && c <= 'f': + b |= byte(c - 'a' + 10) + case c >= 'A' && c <= 'F': + b |= byte(c - 'A' + 10) + } + } + return b +} + +// IsSampled returns true if the original request was sampled. +func (t *Task) IsSampled() bool { + if !t.HasTraceContext() { + return false + } + return t.SpanContext().IsSampled() +} + func (t *Task) String() string { return fmt.Sprintf("writeback.Task(namespace=%s, name=%s)", t.Namespace, t.Name) } diff --git a/localdb/migrations/00003_writeback_tracing.go b/localdb/migrations/00003_writeback_tracing.go new file mode 100644 index 000000000..2aff4d0ce --- /dev/null +++ b/localdb/migrations/00003_writeback_tracing.go @@ -0,0 +1,64 @@ +// Copyright (c) 2016-2019 Uber Technologies, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +package migrations + +import ( + "database/sql" + + "github.com/pressly/goose" +) + +func init() { + goose.AddMigration(up00003, down00003) +} + +func up00003(tx *sql.Tx) error { + // Add trace_id, span_id, and trace_flags columns for linking async writeback to original request trace + _, err := tx.Exec(` + ALTER TABLE writeback_task ADD COLUMN trace_id text DEFAULT ''; + `) + if err != nil { + return err + } + _, err = tx.Exec(` + ALTER TABLE writeback_task ADD COLUMN span_id text DEFAULT ''; + `) + if err != nil { + return err + } + _, err = tx.Exec(` + ALTER TABLE writeback_task ADD COLUMN trace_flags text DEFAULT ''; + `) + return err +} + +func down00003(tx *sql.Tx) error { + _, err := tx.Exec(` + CREATE TABLE writeback_task_backup AS SELECT namespace, name, created_at, last_attempt, status, failures, delay FROM writeback_task; + DROP TABLE writeback_task; + CREATE TABLE writeback_task ( + namespace text NOT NULL, + name text NOT NULL, + created_at timestamp DEFAULT CURRENT_TIMESTAMP, + last_attempt timestamp NOT NULL, + status text NOT NULL, + failures integer NOT NULL, + delay integer NOT NULL, + PRIMARY KEY(namespace, name) + ); + INSERT INTO writeback_task SELECT * FROM writeback_task_backup; + DROP TABLE writeback_task_backup; + `) + return err +} diff --git a/mocks/agent/agentclient/client.go b/mocks/agent/agentclient/client.go index a95e39c9d..04b851fb2 100644 --- a/mocks/agent/agentclient/client.go +++ b/mocks/agent/agentclient/client.go @@ -12,30 +12,30 @@ import ( core "github.com/uber/kraken/core" ) -// MockClient is a mock of Client interface +// MockClient is a mock of Client interface. type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder } -// MockClientMockRecorder is the mock recorder for MockClient +// MockClientMockRecorder is the mock recorder for MockClient. type MockClientMockRecorder struct { mock *MockClient } -// NewMockClient creates a new mock instance +// NewMockClient creates a new mock instance. func NewMockClient(ctrl *gomock.Controller) *MockClient { mock := &MockClient{ctrl: ctrl} mock.recorder = &MockClientMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockClient) EXPECT() *MockClientMockRecorder { return m.recorder } -// Download mocks base method +// Download mocks base method. func (m *MockClient) Download(arg0 string, arg1 core.Digest) (io.ReadCloser, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Download", arg0, arg1) @@ -44,13 +44,13 @@ func (m *MockClient) Download(arg0 string, arg1 core.Digest) (io.ReadCloser, err return ret0, ret1 } -// Download indicates an expected call of Download +// Download indicates an expected call of Download. func (mr *MockClientMockRecorder) Download(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockClient)(nil).Download), arg0, arg1) } -// GetTag mocks base method +// GetTag mocks base method. func (m *MockClient) GetTag(arg0 string) (core.Digest, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTag", arg0) @@ -59,7 +59,7 @@ func (m *MockClient) GetTag(arg0 string) (core.Digest, error) { return ret0, ret1 } -// GetTag indicates an expected call of GetTag +// GetTag indicates an expected call of GetTag. func (mr *MockClientMockRecorder) GetTag(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTag", reflect.TypeOf((*MockClient)(nil).GetTag), arg0) diff --git a/mocks/build-index/tagclient/client.go b/mocks/build-index/tagclient/client.go index 5443d6c3f..7877fadd1 100644 --- a/mocks/build-index/tagclient/client.go +++ b/mocks/build-index/tagclient/client.go @@ -1,10 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. // Source: github.com/uber/kraken/build-index/tagclient (interfaces: Client) -// -// Generated by this command: -// -// mockgen -package mocktagclient . Client -// // Package mocktagclient is a generated GoMock package. package mocktagclient @@ -23,7 +18,6 @@ import ( type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder - isgomock struct{} } // MockClientMockRecorder is the mock recorder for MockClient. @@ -58,121 +52,121 @@ func (mr *MockClientMockRecorder) CheckReadiness() *gomock.Call { } // DuplicatePut mocks base method. -func (m *MockClient) DuplicatePut(tag string, d core.Digest, delay time.Duration) error { +func (m *MockClient) DuplicatePut(arg0 string, arg1 core.Digest, arg2 time.Duration) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DuplicatePut", tag, d, delay) + ret := m.ctrl.Call(m, "DuplicatePut", arg0, arg1, arg2) ret0, _ := ret[0].(error) return ret0 } // DuplicatePut indicates an expected call of DuplicatePut. -func (mr *MockClientMockRecorder) DuplicatePut(tag, d, delay interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) DuplicatePut(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DuplicatePut", reflect.TypeOf((*MockClient)(nil).DuplicatePut), tag, d, delay) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DuplicatePut", reflect.TypeOf((*MockClient)(nil).DuplicatePut), arg0, arg1, arg2) } // DuplicateReplicate mocks base method. -func (m *MockClient) DuplicateReplicate(tag string, d core.Digest, dependencies core.DigestList, delay time.Duration) error { +func (m *MockClient) DuplicateReplicate(arg0 string, arg1 core.Digest, arg2 core.DigestList, arg3 time.Duration) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DuplicateReplicate", tag, d, dependencies, delay) + ret := m.ctrl.Call(m, "DuplicateReplicate", arg0, arg1, arg2, arg3) ret0, _ := ret[0].(error) return ret0 } // DuplicateReplicate indicates an expected call of DuplicateReplicate. -func (mr *MockClientMockRecorder) DuplicateReplicate(tag, d, dependencies, delay interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) DuplicateReplicate(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DuplicateReplicate", reflect.TypeOf((*MockClient)(nil).DuplicateReplicate), tag, d, dependencies, delay) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DuplicateReplicate", reflect.TypeOf((*MockClient)(nil).DuplicateReplicate), arg0, arg1, arg2, arg3) } // Get mocks base method. -func (m *MockClient) Get(tag string) (core.Digest, error) { +func (m *MockClient) Get(arg0 string) (core.Digest, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Get", tag) + ret := m.ctrl.Call(m, "Get", arg0) ret0, _ := ret[0].(core.Digest) ret1, _ := ret[1].(error) return ret0, ret1 } // Get indicates an expected call of Get. -func (mr *MockClientMockRecorder) Get(tag interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) Get(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClient)(nil).Get), tag) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClient)(nil).Get), arg0) } // Has mocks base method. -func (m *MockClient) Has(tag string) (bool, error) { +func (m *MockClient) Has(arg0 string) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Has", tag) + ret := m.ctrl.Call(m, "Has", arg0) ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } // Has indicates an expected call of Has. -func (mr *MockClientMockRecorder) Has(tag interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) Has(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Has", reflect.TypeOf((*MockClient)(nil).Has), tag) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Has", reflect.TypeOf((*MockClient)(nil).Has), arg0) } // List mocks base method. -func (m *MockClient) List(prefix string) ([]string, error) { +func (m *MockClient) List(arg0 string) ([]string, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "List", prefix) + ret := m.ctrl.Call(m, "List", arg0) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) return ret0, ret1 } // List indicates an expected call of List. -func (mr *MockClientMockRecorder) List(prefix interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) List(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockClient)(nil).List), prefix) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockClient)(nil).List), arg0) } // ListRepository mocks base method. -func (m *MockClient) ListRepository(repo string) ([]string, error) { +func (m *MockClient) ListRepository(arg0 string) ([]string, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListRepository", repo) + ret := m.ctrl.Call(m, "ListRepository", arg0) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) return ret0, ret1 } // ListRepository indicates an expected call of ListRepository. -func (mr *MockClientMockRecorder) ListRepository(repo interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) ListRepository(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRepository", reflect.TypeOf((*MockClient)(nil).ListRepository), repo) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRepository", reflect.TypeOf((*MockClient)(nil).ListRepository), arg0) } // ListRepositoryWithPagination mocks base method. -func (m *MockClient) ListRepositoryWithPagination(repo string, filter tagclient.ListFilter) (tagmodels.ListResponse, error) { +func (m *MockClient) ListRepositoryWithPagination(arg0 string, arg1 tagclient.ListFilter) (tagmodels.ListResponse, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListRepositoryWithPagination", repo, filter) + ret := m.ctrl.Call(m, "ListRepositoryWithPagination", arg0, arg1) ret0, _ := ret[0].(tagmodels.ListResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // ListRepositoryWithPagination indicates an expected call of ListRepositoryWithPagination. -func (mr *MockClientMockRecorder) ListRepositoryWithPagination(repo, filter interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) ListRepositoryWithPagination(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRepositoryWithPagination", reflect.TypeOf((*MockClient)(nil).ListRepositoryWithPagination), repo, filter) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRepositoryWithPagination", reflect.TypeOf((*MockClient)(nil).ListRepositoryWithPagination), arg0, arg1) } // ListWithPagination mocks base method. -func (m *MockClient) ListWithPagination(prefix string, filter tagclient.ListFilter) (tagmodels.ListResponse, error) { +func (m *MockClient) ListWithPagination(arg0 string, arg1 tagclient.ListFilter) (tagmodels.ListResponse, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListWithPagination", prefix, filter) + ret := m.ctrl.Call(m, "ListWithPagination", arg0, arg1) ret0, _ := ret[0].(tagmodels.ListResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // ListWithPagination indicates an expected call of ListWithPagination. -func (mr *MockClientMockRecorder) ListWithPagination(prefix, filter interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) ListWithPagination(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWithPagination", reflect.TypeOf((*MockClient)(nil).ListWithPagination), prefix, filter) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWithPagination", reflect.TypeOf((*MockClient)(nil).ListWithPagination), arg0, arg1) } // Origin mocks base method. @@ -191,43 +185,43 @@ func (mr *MockClientMockRecorder) Origin() *gomock.Call { } // Put mocks base method. -func (m *MockClient) Put(tag string, d core.Digest) error { +func (m *MockClient) Put(arg0 string, arg1 core.Digest) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Put", tag, d) + ret := m.ctrl.Call(m, "Put", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // Put indicates an expected call of Put. -func (mr *MockClientMockRecorder) Put(tag, d interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) Put(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockClient)(nil).Put), tag, d) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockClient)(nil).Put), arg0, arg1) } // PutAndReplicate mocks base method. -func (m *MockClient) PutAndReplicate(tag string, d core.Digest) error { +func (m *MockClient) PutAndReplicate(arg0 string, arg1 core.Digest) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PutAndReplicate", tag, d) + ret := m.ctrl.Call(m, "PutAndReplicate", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // PutAndReplicate indicates an expected call of PutAndReplicate. -func (mr *MockClientMockRecorder) PutAndReplicate(tag, d interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) PutAndReplicate(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAndReplicate", reflect.TypeOf((*MockClient)(nil).PutAndReplicate), tag, d) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAndReplicate", reflect.TypeOf((*MockClient)(nil).PutAndReplicate), arg0, arg1) } // Replicate mocks base method. -func (m *MockClient) Replicate(tag string) error { +func (m *MockClient) Replicate(arg0 string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Replicate", tag) + ret := m.ctrl.Call(m, "Replicate", arg0) ret0, _ := ret[0].(error) return ret0 } // Replicate indicates an expected call of Replicate. -func (mr *MockClientMockRecorder) Replicate(tag interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) Replicate(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Replicate", reflect.TypeOf((*MockClient)(nil).Replicate), tag) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Replicate", reflect.TypeOf((*MockClient)(nil).Replicate), arg0) } diff --git a/mocks/build-index/tagclient/provider.go b/mocks/build-index/tagclient/provider.go index 08a6143ae..e4f867422 100644 --- a/mocks/build-index/tagclient/provider.go +++ b/mocks/build-index/tagclient/provider.go @@ -11,30 +11,30 @@ import ( tagclient "github.com/uber/kraken/build-index/tagclient" ) -// MockProvider is a mock of Provider interface +// MockProvider is a mock of Provider interface. type MockProvider struct { ctrl *gomock.Controller recorder *MockProviderMockRecorder } -// MockProviderMockRecorder is the mock recorder for MockProvider +// MockProviderMockRecorder is the mock recorder for MockProvider. type MockProviderMockRecorder struct { mock *MockProvider } -// NewMockProvider creates a new mock instance +// NewMockProvider creates a new mock instance. func NewMockProvider(ctrl *gomock.Controller) *MockProvider { mock := &MockProvider{ctrl: ctrl} mock.recorder = &MockProviderMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockProvider) EXPECT() *MockProviderMockRecorder { return m.recorder } -// Provide mocks base method +// Provide mocks base method. func (m *MockProvider) Provide(arg0 string) tagclient.Client { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Provide", arg0) @@ -42,7 +42,7 @@ func (m *MockProvider) Provide(arg0 string) tagclient.Client { return ret0 } -// Provide indicates an expected call of Provide +// Provide indicates an expected call of Provide. func (mr *MockProviderMockRecorder) Provide(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Provide", reflect.TypeOf((*MockProvider)(nil).Provide), arg0) diff --git a/mocks/build-index/tagstore/filestore.go b/mocks/build-index/tagstore/filestore.go index 032192b20..038085b8b 100644 --- a/mocks/build-index/tagstore/filestore.go +++ b/mocks/build-index/tagstore/filestore.go @@ -13,30 +13,30 @@ import ( metadata "github.com/uber/kraken/lib/store/metadata" ) -// MockFileStore is a mock of FileStore interface +// MockFileStore is a mock of FileStore interface. type MockFileStore struct { ctrl *gomock.Controller recorder *MockFileStoreMockRecorder } -// MockFileStoreMockRecorder is the mock recorder for MockFileStore +// MockFileStoreMockRecorder is the mock recorder for MockFileStore. type MockFileStoreMockRecorder struct { mock *MockFileStore } -// NewMockFileStore creates a new mock instance +// NewMockFileStore creates a new mock instance. func NewMockFileStore(ctrl *gomock.Controller) *MockFileStore { mock := &MockFileStore{ctrl: ctrl} mock.recorder = &MockFileStoreMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockFileStore) EXPECT() *MockFileStoreMockRecorder { return m.recorder } -// CreateCacheFile mocks base method +// CreateCacheFile mocks base method. func (m *MockFileStore) CreateCacheFile(arg0 string, arg1 io.Reader) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateCacheFile", arg0, arg1) @@ -44,13 +44,13 @@ func (m *MockFileStore) CreateCacheFile(arg0 string, arg1 io.Reader) error { return ret0 } -// CreateCacheFile indicates an expected call of CreateCacheFile +// CreateCacheFile indicates an expected call of CreateCacheFile. func (mr *MockFileStoreMockRecorder) CreateCacheFile(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheFile", reflect.TypeOf((*MockFileStore)(nil).CreateCacheFile), arg0, arg1) } -// GetCacheFileReader mocks base method +// GetCacheFileReader mocks base method. func (m *MockFileStore) GetCacheFileReader(arg0 string) (base.FileReader, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetCacheFileReader", arg0) @@ -59,13 +59,13 @@ func (m *MockFileStore) GetCacheFileReader(arg0 string) (base.FileReader, error) return ret0, ret1 } -// GetCacheFileReader indicates an expected call of GetCacheFileReader +// GetCacheFileReader indicates an expected call of GetCacheFileReader. func (mr *MockFileStoreMockRecorder) GetCacheFileReader(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCacheFileReader", reflect.TypeOf((*MockFileStore)(nil).GetCacheFileReader), arg0) } -// SetCacheFileMetadata mocks base method +// SetCacheFileMetadata mocks base method. func (m *MockFileStore) SetCacheFileMetadata(arg0 string, arg1 metadata.Metadata) (bool, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SetCacheFileMetadata", arg0, arg1) @@ -74,7 +74,7 @@ func (m *MockFileStore) SetCacheFileMetadata(arg0 string, arg1 metadata.Metadata return ret0, ret1 } -// SetCacheFileMetadata indicates an expected call of SetCacheFileMetadata +// SetCacheFileMetadata indicates an expected call of SetCacheFileMetadata. func (mr *MockFileStoreMockRecorder) SetCacheFileMetadata(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCacheFileMetadata", reflect.TypeOf((*MockFileStore)(nil).SetCacheFileMetadata), arg0, arg1) diff --git a/mocks/build-index/tagstore/store.go b/mocks/build-index/tagstore/store.go index 2677cb90d..44ae486fa 100644 --- a/mocks/build-index/tagstore/store.go +++ b/mocks/build-index/tagstore/store.go @@ -5,6 +5,7 @@ package mocktagstore import ( + context "context" reflect "reflect" time "time" @@ -12,30 +13,30 @@ import ( core "github.com/uber/kraken/core" ) -// MockStore is a mock of Store interface +// MockStore is a mock of Store interface. type MockStore struct { ctrl *gomock.Controller recorder *MockStoreMockRecorder } -// MockStoreMockRecorder is the mock recorder for MockStore +// MockStoreMockRecorder is the mock recorder for MockStore. type MockStoreMockRecorder struct { mock *MockStore } -// NewMockStore creates a new mock instance +// NewMockStore creates a new mock instance. func NewMockStore(ctrl *gomock.Controller) *MockStore { mock := &MockStore{ctrl: ctrl} mock.recorder = &MockStoreMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockStore) EXPECT() *MockStoreMockRecorder { return m.recorder } -// Get mocks base method +// Get mocks base method. func (m *MockStore) Get(arg0 string) (core.Digest, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Get", arg0) @@ -44,22 +45,22 @@ func (m *MockStore) Get(arg0 string) (core.Digest, error) { return ret0, ret1 } -// Get indicates an expected call of Get +// Get indicates an expected call of Get. func (mr *MockStoreMockRecorder) Get(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockStore)(nil).Get), arg0) } -// Put mocks base method -func (m *MockStore) Put(arg0 string, arg1 core.Digest, arg2 time.Duration) error { +// Put mocks base method. +func (m *MockStore) Put(arg0 context.Context, arg1 string, arg2 core.Digest, arg3 time.Duration) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2, arg3) ret0, _ := ret[0].(error) return ret0 } -// Put indicates an expected call of Put -func (mr *MockStoreMockRecorder) Put(arg0, arg1, arg2 interface{}) *gomock.Call { +// Put indicates an expected call of Put. +func (mr *MockStoreMockRecorder) Put(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockStore)(nil).Put), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockStore)(nil).Put), arg0, arg1, arg2, arg3) } diff --git a/mocks/build-index/tagtype/dependencyresolver.go b/mocks/build-index/tagtype/dependencyresolver.go index d58e417d9..753400ffb 100644 --- a/mocks/build-index/tagtype/dependencyresolver.go +++ b/mocks/build-index/tagtype/dependencyresolver.go @@ -11,30 +11,30 @@ import ( core "github.com/uber/kraken/core" ) -// MockDependencyResolver is a mock of DependencyResolver interface +// MockDependencyResolver is a mock of DependencyResolver interface. type MockDependencyResolver struct { ctrl *gomock.Controller recorder *MockDependencyResolverMockRecorder } -// MockDependencyResolverMockRecorder is the mock recorder for MockDependencyResolver +// MockDependencyResolverMockRecorder is the mock recorder for MockDependencyResolver. type MockDependencyResolverMockRecorder struct { mock *MockDependencyResolver } -// NewMockDependencyResolver creates a new mock instance +// NewMockDependencyResolver creates a new mock instance. func NewMockDependencyResolver(ctrl *gomock.Controller) *MockDependencyResolver { mock := &MockDependencyResolver{ctrl: ctrl} mock.recorder = &MockDependencyResolverMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockDependencyResolver) EXPECT() *MockDependencyResolverMockRecorder { return m.recorder } -// Resolve mocks base method +// Resolve mocks base method. func (m *MockDependencyResolver) Resolve(arg0 string, arg1 core.Digest) (core.DigestList, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Resolve", arg0, arg1) @@ -43,7 +43,7 @@ func (m *MockDependencyResolver) Resolve(arg0 string, arg1 core.Digest) (core.Di return ret0, ret1 } -// Resolve indicates an expected call of Resolve +// Resolve indicates an expected call of Resolve. func (mr *MockDependencyResolverMockRecorder) Resolve(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resolve", reflect.TypeOf((*MockDependencyResolver)(nil).Resolve), arg0, arg1) diff --git a/mocks/io/mock_closer.go b/mocks/io/mock_closer.go deleted file mode 100644 index cadd4819a..000000000 --- a/mocks/io/mock_closer.go +++ /dev/null @@ -1,48 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: io (interfaces: Closer) - -// Package mock_io is a generated GoMock package. -package mock_io - -import ( - reflect "reflect" - - gomock "github.com/golang/mock/gomock" -) - -// MockCloser is a mock of Closer interface. -type MockCloser struct { - ctrl *gomock.Controller - recorder *MockCloserMockRecorder -} - -// MockCloserMockRecorder is the mock recorder for MockCloser. -type MockCloserMockRecorder struct { - mock *MockCloser -} - -// NewMockCloser creates a new mock instance. -func NewMockCloser(ctrl *gomock.Controller) *MockCloser { - mock := &MockCloser{ctrl: ctrl} - mock.recorder = &MockCloserMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockCloser) EXPECT() *MockCloserMockRecorder { - return m.recorder -} - -// Close mocks base method. -func (m *MockCloser) Close() error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") - ret0, _ := ret[0].(error) - return ret0 -} - -// Close indicates an expected call of Close. -func (mr *MockCloserMockRecorder) Close() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockCloser)(nil).Close)) -} diff --git a/mocks/lib/backend/gcsbackend/gcs.go b/mocks/lib/backend/gcsbackend/gcs.go index 856586570..74f4d1883 100644 --- a/mocks/lib/backend/gcsbackend/gcs.go +++ b/mocks/lib/backend/gcsbackend/gcs.go @@ -13,30 +13,30 @@ import ( iterator "google.golang.org/api/iterator" ) -// MockGCS is a mock of GCS interface +// MockGCS is a mock of GCS interface. type MockGCS struct { ctrl *gomock.Controller recorder *MockGCSMockRecorder } -// MockGCSMockRecorder is the mock recorder for MockGCS +// MockGCSMockRecorder is the mock recorder for MockGCS. type MockGCSMockRecorder struct { mock *MockGCS } -// NewMockGCS creates a new mock instance +// NewMockGCS creates a new mock instance. func NewMockGCS(ctrl *gomock.Controller) *MockGCS { mock := &MockGCS{ctrl: ctrl} mock.recorder = &MockGCSMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockGCS) EXPECT() *MockGCSMockRecorder { return m.recorder } -// Download mocks base method +// Download mocks base method. func (m *MockGCS) Download(arg0 string, arg1 io.Writer) (int64, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Download", arg0, arg1) @@ -45,13 +45,13 @@ func (m *MockGCS) Download(arg0 string, arg1 io.Writer) (int64, error) { return ret0, ret1 } -// Download indicates an expected call of Download +// Download indicates an expected call of Download. func (mr *MockGCSMockRecorder) Download(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockGCS)(nil).Download), arg0, arg1) } -// GetObjectIterator mocks base method +// GetObjectIterator mocks base method. func (m *MockGCS) GetObjectIterator(arg0 string) iterator.Pageable { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetObjectIterator", arg0) @@ -59,13 +59,13 @@ func (m *MockGCS) GetObjectIterator(arg0 string) iterator.Pageable { return ret0 } -// GetObjectIterator indicates an expected call of GetObjectIterator +// GetObjectIterator indicates an expected call of GetObjectIterator. func (mr *MockGCSMockRecorder) GetObjectIterator(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectIterator", reflect.TypeOf((*MockGCS)(nil).GetObjectIterator), arg0) } -// NextPage mocks base method +// NextPage mocks base method. func (m *MockGCS) NextPage(arg0 *iterator.Pager) ([]string, string, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "NextPage", arg0) @@ -75,13 +75,13 @@ func (m *MockGCS) NextPage(arg0 *iterator.Pager) ([]string, string, error) { return ret0, ret1, ret2 } -// NextPage indicates an expected call of NextPage +// NextPage indicates an expected call of NextPage. func (mr *MockGCSMockRecorder) NextPage(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NextPage", reflect.TypeOf((*MockGCS)(nil).NextPage), arg0) } -// ObjectAttrs mocks base method +// ObjectAttrs mocks base method. func (m *MockGCS) ObjectAttrs(arg0 string) (*storage.ObjectAttrs, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ObjectAttrs", arg0) @@ -90,13 +90,13 @@ func (m *MockGCS) ObjectAttrs(arg0 string) (*storage.ObjectAttrs, error) { return ret0, ret1 } -// ObjectAttrs indicates an expected call of ObjectAttrs +// ObjectAttrs indicates an expected call of ObjectAttrs. func (mr *MockGCSMockRecorder) ObjectAttrs(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectAttrs", reflect.TypeOf((*MockGCS)(nil).ObjectAttrs), arg0) } -// Upload mocks base method +// Upload mocks base method. func (m *MockGCS) Upload(arg0 string, arg1 io.Reader) (int64, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Upload", arg0, arg1) @@ -105,7 +105,7 @@ func (m *MockGCS) Upload(arg0 string, arg1 io.Reader) (int64, error) { return ret0, ret1 } -// Upload indicates an expected call of Upload +// Upload indicates an expected call of Upload. func (mr *MockGCSMockRecorder) Upload(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upload", reflect.TypeOf((*MockGCS)(nil).Upload), arg0, arg1) diff --git a/mocks/lib/backend/hdfsbackend/webhdfs/client.go b/mocks/lib/backend/hdfsbackend/webhdfs/client.go index 3e6612981..672b5c159 100644 --- a/mocks/lib/backend/hdfsbackend/webhdfs/client.go +++ b/mocks/lib/backend/hdfsbackend/webhdfs/client.go @@ -12,30 +12,30 @@ import ( webhdfs "github.com/uber/kraken/lib/backend/hdfsbackend/webhdfs" ) -// MockClient is a mock of Client interface +// MockClient is a mock of Client interface. type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder } -// MockClientMockRecorder is the mock recorder for MockClient +// MockClientMockRecorder is the mock recorder for MockClient. type MockClientMockRecorder struct { mock *MockClient } -// NewMockClient creates a new mock instance +// NewMockClient creates a new mock instance. func NewMockClient(ctrl *gomock.Controller) *MockClient { mock := &MockClient{ctrl: ctrl} mock.recorder = &MockClientMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockClient) EXPECT() *MockClientMockRecorder { return m.recorder } -// Create mocks base method +// Create mocks base method. func (m *MockClient) Create(arg0 string, arg1 io.Reader) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Create", arg0, arg1) @@ -43,13 +43,13 @@ func (m *MockClient) Create(arg0 string, arg1 io.Reader) error { return ret0 } -// Create indicates an expected call of Create +// Create indicates an expected call of Create. func (mr *MockClientMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockClient)(nil).Create), arg0, arg1) } -// GetFileStatus mocks base method +// GetFileStatus mocks base method. func (m *MockClient) GetFileStatus(arg0 string) (webhdfs.FileStatus, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetFileStatus", arg0) @@ -58,13 +58,13 @@ func (m *MockClient) GetFileStatus(arg0 string) (webhdfs.FileStatus, error) { return ret0, ret1 } -// GetFileStatus indicates an expected call of GetFileStatus +// GetFileStatus indicates an expected call of GetFileStatus. func (mr *MockClientMockRecorder) GetFileStatus(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFileStatus", reflect.TypeOf((*MockClient)(nil).GetFileStatus), arg0) } -// ListFileStatus mocks base method +// ListFileStatus mocks base method. func (m *MockClient) ListFileStatus(arg0 string) ([]webhdfs.FileStatus, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListFileStatus", arg0) @@ -73,13 +73,13 @@ func (m *MockClient) ListFileStatus(arg0 string) ([]webhdfs.FileStatus, error) { return ret0, ret1 } -// ListFileStatus indicates an expected call of ListFileStatus +// ListFileStatus indicates an expected call of ListFileStatus. func (mr *MockClientMockRecorder) ListFileStatus(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFileStatus", reflect.TypeOf((*MockClient)(nil).ListFileStatus), arg0) } -// Mkdirs mocks base method +// Mkdirs mocks base method. func (m *MockClient) Mkdirs(arg0 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Mkdirs", arg0) @@ -87,13 +87,13 @@ func (m *MockClient) Mkdirs(arg0 string) error { return ret0 } -// Mkdirs indicates an expected call of Mkdirs +// Mkdirs indicates an expected call of Mkdirs. func (mr *MockClientMockRecorder) Mkdirs(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Mkdirs", reflect.TypeOf((*MockClient)(nil).Mkdirs), arg0) } -// Open mocks base method +// Open mocks base method. func (m *MockClient) Open(arg0 string, arg1 io.Writer) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Open", arg0, arg1) @@ -101,13 +101,13 @@ func (m *MockClient) Open(arg0 string, arg1 io.Writer) error { return ret0 } -// Open indicates an expected call of Open +// Open indicates an expected call of Open. func (mr *MockClientMockRecorder) Open(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockClient)(nil).Open), arg0, arg1) } -// Rename mocks base method +// Rename mocks base method. func (m *MockClient) Rename(arg0, arg1 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Rename", arg0, arg1) @@ -115,7 +115,7 @@ func (m *MockClient) Rename(arg0, arg1 string) error { return ret0 } -// Rename indicates an expected call of Rename +// Rename indicates an expected call of Rename. func (mr *MockClientMockRecorder) Rename(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockClient)(nil).Rename), arg0, arg1) diff --git a/mocks/lib/backend/s3backend/s3.go b/mocks/lib/backend/s3backend/s3.go index f37de7652..5e9592c51 100644 --- a/mocks/lib/backend/s3backend/s3.go +++ b/mocks/lib/backend/s3backend/s3.go @@ -13,30 +13,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockS3 is a mock of S3 interface +// MockS3 is a mock of S3 interface. type MockS3 struct { ctrl *gomock.Controller recorder *MockS3MockRecorder } -// MockS3MockRecorder is the mock recorder for MockS3 +// MockS3MockRecorder is the mock recorder for MockS3. type MockS3MockRecorder struct { mock *MockS3 } -// NewMockS3 creates a new mock instance +// NewMockS3 creates a new mock instance. func NewMockS3(ctrl *gomock.Controller) *MockS3 { mock := &MockS3{ctrl: ctrl} mock.recorder = &MockS3MockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockS3) EXPECT() *MockS3MockRecorder { return m.recorder } -// Download mocks base method +// Download mocks base method. func (m *MockS3) Download(arg0 io.WriterAt, arg1 *s3.GetObjectInput, arg2 ...func(*s3manager.Downloader)) (int64, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} @@ -49,14 +49,14 @@ func (m *MockS3) Download(arg0 io.WriterAt, arg1 *s3.GetObjectInput, arg2 ...fun return ret0, ret1 } -// Download indicates an expected call of Download +// Download indicates an expected call of Download. func (mr *MockS3MockRecorder) Download(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockS3)(nil).Download), varargs...) } -// HeadObject mocks base method +// HeadObject mocks base method. func (m *MockS3) HeadObject(arg0 *s3.HeadObjectInput) (*s3.HeadObjectOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "HeadObject", arg0) @@ -65,13 +65,13 @@ func (m *MockS3) HeadObject(arg0 *s3.HeadObjectInput) (*s3.HeadObjectOutput, err return ret0, ret1 } -// HeadObject indicates an expected call of HeadObject +// HeadObject indicates an expected call of HeadObject. func (mr *MockS3MockRecorder) HeadObject(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadObject", reflect.TypeOf((*MockS3)(nil).HeadObject), arg0) } -// ListObjectsV2Pages mocks base method +// ListObjectsV2Pages mocks base method. func (m *MockS3) ListObjectsV2Pages(arg0 *s3.ListObjectsV2Input, arg1 func(*s3.ListObjectsV2Output, bool) bool) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListObjectsV2Pages", arg0, arg1) @@ -79,13 +79,13 @@ func (m *MockS3) ListObjectsV2Pages(arg0 *s3.ListObjectsV2Input, arg1 func(*s3.L return ret0 } -// ListObjectsV2Pages indicates an expected call of ListObjectsV2Pages +// ListObjectsV2Pages indicates an expected call of ListObjectsV2Pages. func (mr *MockS3MockRecorder) ListObjectsV2Pages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2Pages", reflect.TypeOf((*MockS3)(nil).ListObjectsV2Pages), arg0, arg1) } -// Upload mocks base method +// Upload mocks base method. func (m *MockS3) Upload(arg0 *s3manager.UploadInput, arg1 ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0} @@ -98,7 +98,7 @@ func (m *MockS3) Upload(arg0 *s3manager.UploadInput, arg1 ...func(*s3manager.Upl return ret0, ret1 } -// Upload indicates an expected call of Upload +// Upload indicates an expected call of Upload. func (mr *MockS3MockRecorder) Upload(arg0 interface{}, arg1 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0}, arg1...) diff --git a/mocks/lib/containerruntime/containerd/client.go b/mocks/lib/containerruntime/containerd/client.go index 9507fde6d..bbbdc0489 100644 --- a/mocks/lib/containerruntime/containerd/client.go +++ b/mocks/lib/containerruntime/containerd/client.go @@ -11,30 +11,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockClient is a mock of Client interface +// MockClient is a mock of Client interface. type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder } -// MockClientMockRecorder is the mock recorder for MockClient +// MockClientMockRecorder is the mock recorder for MockClient. type MockClientMockRecorder struct { mock *MockClient } -// NewMockClient creates a new mock instance +// NewMockClient creates a new mock instance. func NewMockClient(ctrl *gomock.Controller) *MockClient { mock := &MockClient{ctrl: ctrl} mock.recorder = &MockClientMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockClient) EXPECT() *MockClientMockRecorder { return m.recorder } -// PullImage mocks base method +// PullImage mocks base method. func (m *MockClient) PullImage(arg0 context.Context, arg1, arg2, arg3 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PullImage", arg0, arg1, arg2, arg3) @@ -42,7 +42,7 @@ func (m *MockClient) PullImage(arg0 context.Context, arg1, arg2, arg3 string) er return ret0 } -// PullImage indicates an expected call of PullImage +// PullImage indicates an expected call of PullImage. func (mr *MockClientMockRecorder) PullImage(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullImage", reflect.TypeOf((*MockClient)(nil).PullImage), arg0, arg1, arg2, arg3) diff --git a/mocks/lib/containerruntime/dockerdaemon/dockerclient.go b/mocks/lib/containerruntime/dockerdaemon/dockerclient.go index d270571f1..f3ae596dc 100644 --- a/mocks/lib/containerruntime/dockerdaemon/dockerclient.go +++ b/mocks/lib/containerruntime/dockerdaemon/dockerclient.go @@ -11,30 +11,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockDockerClient is a mock of DockerClient interface +// MockDockerClient is a mock of DockerClient interface. type MockDockerClient struct { ctrl *gomock.Controller recorder *MockDockerClientMockRecorder } -// MockDockerClientMockRecorder is the mock recorder for MockDockerClient +// MockDockerClientMockRecorder is the mock recorder for MockDockerClient. type MockDockerClientMockRecorder struct { mock *MockDockerClient } -// NewMockDockerClient creates a new mock instance +// NewMockDockerClient creates a new mock instance. func NewMockDockerClient(ctrl *gomock.Controller) *MockDockerClient { mock := &MockDockerClient{ctrl: ctrl} mock.recorder = &MockDockerClientMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockDockerClient) EXPECT() *MockDockerClientMockRecorder { return m.recorder } -// PullImage mocks base method +// PullImage mocks base method. func (m *MockDockerClient) PullImage(arg0 context.Context, arg1, arg2 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PullImage", arg0, arg1, arg2) @@ -42,7 +42,7 @@ func (m *MockDockerClient) PullImage(arg0 context.Context, arg1, arg2 string) er return ret0 } -// PullImage indicates an expected call of PullImage +// PullImage indicates an expected call of PullImage. func (mr *MockDockerClientMockRecorder) PullImage(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullImage", reflect.TypeOf((*MockDockerClient)(nil).PullImage), arg0, arg1, arg2) diff --git a/mocks/lib/containerruntime/factory.go b/mocks/lib/containerruntime/factory.go index 9031eb42f..65b6447c8 100644 --- a/mocks/lib/containerruntime/factory.go +++ b/mocks/lib/containerruntime/factory.go @@ -12,30 +12,30 @@ import ( dockerdaemon "github.com/uber/kraken/lib/containerruntime/dockerdaemon" ) -// MockFactory is a mock of Factory interface +// MockFactory is a mock of Factory interface. type MockFactory struct { ctrl *gomock.Controller recorder *MockFactoryMockRecorder } -// MockFactoryMockRecorder is the mock recorder for MockFactory +// MockFactoryMockRecorder is the mock recorder for MockFactory. type MockFactoryMockRecorder struct { mock *MockFactory } -// NewMockFactory creates a new mock instance +// NewMockFactory creates a new mock instance. func NewMockFactory(ctrl *gomock.Controller) *MockFactory { mock := &MockFactory{ctrl: ctrl} mock.recorder = &MockFactoryMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockFactory) EXPECT() *MockFactoryMockRecorder { return m.recorder } -// ContainerdClient mocks base method +// ContainerdClient mocks base method. func (m *MockFactory) ContainerdClient() containerd.Client { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ContainerdClient") @@ -43,13 +43,13 @@ func (m *MockFactory) ContainerdClient() containerd.Client { return ret0 } -// ContainerdClient indicates an expected call of ContainerdClient +// ContainerdClient indicates an expected call of ContainerdClient. func (mr *MockFactoryMockRecorder) ContainerdClient() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerdClient", reflect.TypeOf((*MockFactory)(nil).ContainerdClient)) } -// DockerClient mocks base method +// DockerClient mocks base method. func (m *MockFactory) DockerClient() dockerdaemon.DockerClient { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DockerClient") @@ -57,7 +57,7 @@ func (m *MockFactory) DockerClient() dockerdaemon.DockerClient { return ret0 } -// DockerClient indicates an expected call of DockerClient +// DockerClient indicates an expected call of DockerClient. func (mr *MockFactoryMockRecorder) DockerClient() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DockerClient", reflect.TypeOf((*MockFactory)(nil).DockerClient)) diff --git a/mocks/lib/dockerregistry/transfer/imagetransferer.go b/mocks/lib/dockerregistry/transfer/imagetransferer.go index c1760fd53..56a8c3ede 100644 --- a/mocks/lib/dockerregistry/transfer/imagetransferer.go +++ b/mocks/lib/dockerregistry/transfer/imagetransferer.go @@ -12,30 +12,30 @@ import ( base "github.com/uber/kraken/lib/store/base" ) -// MockImageTransferer is a mock of ImageTransferer interface +// MockImageTransferer is a mock of ImageTransferer interface. type MockImageTransferer struct { ctrl *gomock.Controller recorder *MockImageTransfererMockRecorder } -// MockImageTransfererMockRecorder is the mock recorder for MockImageTransferer +// MockImageTransfererMockRecorder is the mock recorder for MockImageTransferer. type MockImageTransfererMockRecorder struct { mock *MockImageTransferer } -// NewMockImageTransferer creates a new mock instance +// NewMockImageTransferer creates a new mock instance. func NewMockImageTransferer(ctrl *gomock.Controller) *MockImageTransferer { mock := &MockImageTransferer{ctrl: ctrl} mock.recorder = &MockImageTransfererMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockImageTransferer) EXPECT() *MockImageTransfererMockRecorder { return m.recorder } -// Download mocks base method +// Download mocks base method. func (m *MockImageTransferer) Download(arg0 string, arg1 core.Digest) (base.FileReader, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Download", arg0, arg1) @@ -44,13 +44,13 @@ func (m *MockImageTransferer) Download(arg0 string, arg1 core.Digest) (base.File return ret0, ret1 } -// Download indicates an expected call of Download +// Download indicates an expected call of Download. func (mr *MockImageTransfererMockRecorder) Download(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockImageTransferer)(nil).Download), arg0, arg1) } -// GetTag mocks base method +// GetTag mocks base method. func (m *MockImageTransferer) GetTag(arg0 string) (core.Digest, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTag", arg0) @@ -59,13 +59,13 @@ func (m *MockImageTransferer) GetTag(arg0 string) (core.Digest, error) { return ret0, ret1 } -// GetTag indicates an expected call of GetTag +// GetTag indicates an expected call of GetTag. func (mr *MockImageTransfererMockRecorder) GetTag(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTag", reflect.TypeOf((*MockImageTransferer)(nil).GetTag), arg0) } -// ListTags mocks base method +// ListTags mocks base method. func (m *MockImageTransferer) ListTags(arg0 string) ([]string, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTags", arg0) @@ -74,13 +74,13 @@ func (m *MockImageTransferer) ListTags(arg0 string) ([]string, error) { return ret0, ret1 } -// ListTags indicates an expected call of ListTags +// ListTags indicates an expected call of ListTags. func (mr *MockImageTransfererMockRecorder) ListTags(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTags", reflect.TypeOf((*MockImageTransferer)(nil).ListTags), arg0) } -// PutTag mocks base method +// PutTag mocks base method. func (m *MockImageTransferer) PutTag(arg0 string, arg1 core.Digest) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PutTag", arg0, arg1) @@ -88,13 +88,13 @@ func (m *MockImageTransferer) PutTag(arg0 string, arg1 core.Digest) error { return ret0 } -// PutTag indicates an expected call of PutTag +// PutTag indicates an expected call of PutTag. func (mr *MockImageTransfererMockRecorder) PutTag(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutTag", reflect.TypeOf((*MockImageTransferer)(nil).PutTag), arg0, arg1) } -// Stat mocks base method +// Stat mocks base method. func (m *MockImageTransferer) Stat(arg0 string, arg1 core.Digest) (*core.BlobInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Stat", arg0, arg1) @@ -103,13 +103,13 @@ func (m *MockImageTransferer) Stat(arg0 string, arg1 core.Digest) (*core.BlobInf return ret0, ret1 } -// Stat indicates an expected call of Stat +// Stat indicates an expected call of Stat. func (mr *MockImageTransfererMockRecorder) Stat(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockImageTransferer)(nil).Stat), arg0, arg1) } -// Upload mocks base method +// Upload mocks base method. func (m *MockImageTransferer) Upload(arg0 string, arg1 core.Digest, arg2 base.FileReader) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Upload", arg0, arg1, arg2) @@ -117,7 +117,7 @@ func (m *MockImageTransferer) Upload(arg0 string, arg1 core.Digest, arg2 base.Fi return ret0 } -// Upload indicates an expected call of Upload +// Upload indicates an expected call of Upload. func (mr *MockImageTransfererMockRecorder) Upload(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upload", reflect.TypeOf((*MockImageTransferer)(nil).Upload), arg0, arg1, arg2) diff --git a/mocks/lib/hashring/ring.go b/mocks/lib/hashring/ring.go index 06381d6b1..a42574abe 100644 --- a/mocks/lib/hashring/ring.go +++ b/mocks/lib/hashring/ring.go @@ -11,30 +11,30 @@ import ( core "github.com/uber/kraken/core" ) -// MockRing is a mock of Ring interface +// MockRing is a mock of Ring interface. type MockRing struct { ctrl *gomock.Controller recorder *MockRingMockRecorder } -// MockRingMockRecorder is the mock recorder for MockRing +// MockRingMockRecorder is the mock recorder for MockRing. type MockRingMockRecorder struct { mock *MockRing } -// NewMockRing creates a new mock instance +// NewMockRing creates a new mock instance. func NewMockRing(ctrl *gomock.Controller) *MockRing { mock := &MockRing{ctrl: ctrl} mock.recorder = &MockRingMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockRing) EXPECT() *MockRingMockRecorder { return m.recorder } -// Contains mocks base method +// Contains mocks base method. func (m *MockRing) Contains(arg0 string) bool { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Contains", arg0) @@ -42,13 +42,13 @@ func (m *MockRing) Contains(arg0 string) bool { return ret0 } -// Contains indicates an expected call of Contains +// Contains indicates an expected call of Contains. func (mr *MockRingMockRecorder) Contains(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Contains", reflect.TypeOf((*MockRing)(nil).Contains), arg0) } -// Locations mocks base method +// Locations mocks base method. func (m *MockRing) Locations(arg0 core.Digest) []string { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Locations", arg0) @@ -56,31 +56,31 @@ func (m *MockRing) Locations(arg0 core.Digest) []string { return ret0 } -// Locations indicates an expected call of Locations +// Locations indicates an expected call of Locations. func (mr *MockRingMockRecorder) Locations(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Locations", reflect.TypeOf((*MockRing)(nil).Locations), arg0) } -// Monitor mocks base method +// Monitor mocks base method. func (m *MockRing) Monitor(arg0 <-chan struct{}) { m.ctrl.T.Helper() m.ctrl.Call(m, "Monitor", arg0) } -// Monitor indicates an expected call of Monitor +// Monitor indicates an expected call of Monitor. func (mr *MockRingMockRecorder) Monitor(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Monitor", reflect.TypeOf((*MockRing)(nil).Monitor), arg0) } -// Refresh mocks base method +// Refresh mocks base method. func (m *MockRing) Refresh() { m.ctrl.T.Helper() m.ctrl.Call(m, "Refresh") } -// Refresh indicates an expected call of Refresh +// Refresh indicates an expected call of Refresh. func (mr *MockRingMockRecorder) Refresh() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Refresh", reflect.TypeOf((*MockRing)(nil).Refresh)) diff --git a/mocks/lib/hashring/watcher.go b/mocks/lib/hashring/watcher.go index 6c37c889b..035b069b6 100644 --- a/mocks/lib/hashring/watcher.go +++ b/mocks/lib/hashring/watcher.go @@ -11,36 +11,36 @@ import ( stringset "github.com/uber/kraken/utils/stringset" ) -// MockWatcher is a mock of Watcher interface +// MockWatcher is a mock of Watcher interface. type MockWatcher struct { ctrl *gomock.Controller recorder *MockWatcherMockRecorder } -// MockWatcherMockRecorder is the mock recorder for MockWatcher +// MockWatcherMockRecorder is the mock recorder for MockWatcher. type MockWatcherMockRecorder struct { mock *MockWatcher } -// NewMockWatcher creates a new mock instance +// NewMockWatcher creates a new mock instance. func NewMockWatcher(ctrl *gomock.Controller) *MockWatcher { mock := &MockWatcher{ctrl: ctrl} mock.recorder = &MockWatcherMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockWatcher) EXPECT() *MockWatcherMockRecorder { return m.recorder } -// Notify mocks base method +// Notify mocks base method. func (m *MockWatcher) Notify(arg0 stringset.Set) { m.ctrl.T.Helper() m.ctrl.Call(m, "Notify", arg0) } -// Notify indicates an expected call of Notify +// Notify indicates an expected call of Notify. func (mr *MockWatcherMockRecorder) Notify(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Notify", reflect.TypeOf((*MockWatcher)(nil).Notify), arg0) diff --git a/mocks/lib/healthcheck/checker.go b/mocks/lib/healthcheck/checker.go index 3e83cafff..f8d7a5512 100644 --- a/mocks/lib/healthcheck/checker.go +++ b/mocks/lib/healthcheck/checker.go @@ -11,30 +11,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockChecker is a mock of Checker interface +// MockChecker is a mock of Checker interface. type MockChecker struct { ctrl *gomock.Controller recorder *MockCheckerMockRecorder } -// MockCheckerMockRecorder is the mock recorder for MockChecker +// MockCheckerMockRecorder is the mock recorder for MockChecker. type MockCheckerMockRecorder struct { mock *MockChecker } -// NewMockChecker creates a new mock instance +// NewMockChecker creates a new mock instance. func NewMockChecker(ctrl *gomock.Controller) *MockChecker { mock := &MockChecker{ctrl: ctrl} mock.recorder = &MockCheckerMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockChecker) EXPECT() *MockCheckerMockRecorder { return m.recorder } -// Check mocks base method +// Check mocks base method. func (m *MockChecker) Check(arg0 context.Context, arg1 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Check", arg0, arg1) @@ -42,7 +42,7 @@ func (m *MockChecker) Check(arg0 context.Context, arg1 string) error { return ret0 } -// Check indicates an expected call of Check +// Check indicates an expected call of Check. func (mr *MockCheckerMockRecorder) Check(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Check", reflect.TypeOf((*MockChecker)(nil).Check), arg0, arg1) diff --git a/mocks/lib/healthcheck/filter.go b/mocks/lib/healthcheck/filter.go index 14e2045cb..b89be1a78 100644 --- a/mocks/lib/healthcheck/filter.go +++ b/mocks/lib/healthcheck/filter.go @@ -11,30 +11,30 @@ import ( stringset "github.com/uber/kraken/utils/stringset" ) -// MockFilter is a mock of Filter interface +// MockFilter is a mock of Filter interface. type MockFilter struct { ctrl *gomock.Controller recorder *MockFilterMockRecorder } -// MockFilterMockRecorder is the mock recorder for MockFilter +// MockFilterMockRecorder is the mock recorder for MockFilter. type MockFilterMockRecorder struct { mock *MockFilter } -// NewMockFilter creates a new mock instance +// NewMockFilter creates a new mock instance. func NewMockFilter(ctrl *gomock.Controller) *MockFilter { mock := &MockFilter{ctrl: ctrl} mock.recorder = &MockFilterMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockFilter) EXPECT() *MockFilterMockRecorder { return m.recorder } -// Run mocks base method +// Run mocks base method. func (m *MockFilter) Run(arg0 stringset.Set) stringset.Set { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Run", arg0) @@ -42,7 +42,7 @@ func (m *MockFilter) Run(arg0 stringset.Set) stringset.Set { return ret0 } -// Run indicates an expected call of Run +// Run indicates an expected call of Run. func (mr *MockFilterMockRecorder) Run(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockFilter)(nil).Run), arg0) diff --git a/mocks/lib/healthcheck/passivefilter.go b/mocks/lib/healthcheck/passivefilter.go index 5eba0605f..e295582fb 100644 --- a/mocks/lib/healthcheck/passivefilter.go +++ b/mocks/lib/healthcheck/passivefilter.go @@ -11,42 +11,42 @@ import ( stringset "github.com/uber/kraken/utils/stringset" ) -// MockPassiveFilter is a mock of PassiveFilter interface +// MockPassiveFilter is a mock of PassiveFilter interface. type MockPassiveFilter struct { ctrl *gomock.Controller recorder *MockPassiveFilterMockRecorder } -// MockPassiveFilterMockRecorder is the mock recorder for MockPassiveFilter +// MockPassiveFilterMockRecorder is the mock recorder for MockPassiveFilter. type MockPassiveFilterMockRecorder struct { mock *MockPassiveFilter } -// NewMockPassiveFilter creates a new mock instance +// NewMockPassiveFilter creates a new mock instance. func NewMockPassiveFilter(ctrl *gomock.Controller) *MockPassiveFilter { mock := &MockPassiveFilter{ctrl: ctrl} mock.recorder = &MockPassiveFilterMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockPassiveFilter) EXPECT() *MockPassiveFilterMockRecorder { return m.recorder } -// Failed mocks base method +// Failed mocks base method. func (m *MockPassiveFilter) Failed(arg0 string) { m.ctrl.T.Helper() m.ctrl.Call(m, "Failed", arg0) } -// Failed indicates an expected call of Failed +// Failed indicates an expected call of Failed. func (mr *MockPassiveFilterMockRecorder) Failed(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Failed", reflect.TypeOf((*MockPassiveFilter)(nil).Failed), arg0) } -// Run mocks base method +// Run mocks base method. func (m *MockPassiveFilter) Run(arg0 stringset.Set) stringset.Set { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Run", arg0) @@ -54,7 +54,7 @@ func (m *MockPassiveFilter) Run(arg0 stringset.Set) stringset.Set { return ret0 } -// Run indicates an expected call of Run +// Run indicates an expected call of Run. func (mr *MockPassiveFilterMockRecorder) Run(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockPassiveFilter)(nil).Run), arg0) diff --git a/mocks/lib/hostlist/list.go b/mocks/lib/hostlist/list.go index da492f9d9..9340edf98 100644 --- a/mocks/lib/hostlist/list.go +++ b/mocks/lib/hostlist/list.go @@ -11,30 +11,30 @@ import ( stringset "github.com/uber/kraken/utils/stringset" ) -// MockList is a mock of List interface +// MockList is a mock of List interface. type MockList struct { ctrl *gomock.Controller recorder *MockListMockRecorder } -// MockListMockRecorder is the mock recorder for MockList +// MockListMockRecorder is the mock recorder for MockList. type MockListMockRecorder struct { mock *MockList } -// NewMockList creates a new mock instance +// NewMockList creates a new mock instance. func NewMockList(ctrl *gomock.Controller) *MockList { mock := &MockList{ctrl: ctrl} mock.recorder = &MockListMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockList) EXPECT() *MockListMockRecorder { return m.recorder } -// Resolve mocks base method +// Resolve mocks base method. func (m *MockList) Resolve() stringset.Set { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Resolve") @@ -42,7 +42,7 @@ func (m *MockList) Resolve() stringset.Set { return ret0 } -// Resolve indicates an expected call of Resolve +// Resolve indicates an expected call of Resolve. func (mr *MockListMockRecorder) Resolve() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resolve", reflect.TypeOf((*MockList)(nil).Resolve)) diff --git a/mocks/lib/persistedretry/executor.go b/mocks/lib/persistedretry/executor.go index 0b24f6a53..05b4ecaf2 100644 --- a/mocks/lib/persistedretry/executor.go +++ b/mocks/lib/persistedretry/executor.go @@ -11,30 +11,30 @@ import ( persistedretry "github.com/uber/kraken/lib/persistedretry" ) -// MockExecutor is a mock of Executor interface +// MockExecutor is a mock of Executor interface. type MockExecutor struct { ctrl *gomock.Controller recorder *MockExecutorMockRecorder } -// MockExecutorMockRecorder is the mock recorder for MockExecutor +// MockExecutorMockRecorder is the mock recorder for MockExecutor. type MockExecutorMockRecorder struct { mock *MockExecutor } -// NewMockExecutor creates a new mock instance +// NewMockExecutor creates a new mock instance. func NewMockExecutor(ctrl *gomock.Controller) *MockExecutor { mock := &MockExecutor{ctrl: ctrl} mock.recorder = &MockExecutorMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockExecutor) EXPECT() *MockExecutorMockRecorder { return m.recorder } -// Exec mocks base method +// Exec mocks base method. func (m *MockExecutor) Exec(arg0 persistedretry.Task) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Exec", arg0) @@ -42,13 +42,13 @@ func (m *MockExecutor) Exec(arg0 persistedretry.Task) error { return ret0 } -// Exec indicates an expected call of Exec +// Exec indicates an expected call of Exec. func (mr *MockExecutorMockRecorder) Exec(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockExecutor)(nil).Exec), arg0) } -// Name mocks base method +// Name mocks base method. func (m *MockExecutor) Name() string { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Name") @@ -56,7 +56,7 @@ func (m *MockExecutor) Name() string { return ret0 } -// Name indicates an expected call of Name +// Name indicates an expected call of Name. func (mr *MockExecutorMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockExecutor)(nil).Name)) diff --git a/mocks/lib/persistedretry/manager.go b/mocks/lib/persistedretry/manager.go index 0a023ad8a..bf30f07f4 100644 --- a/mocks/lib/persistedretry/manager.go +++ b/mocks/lib/persistedretry/manager.go @@ -11,30 +11,30 @@ import ( persistedretry "github.com/uber/kraken/lib/persistedretry" ) -// MockManager is a mock of Manager interface +// MockManager is a mock of Manager interface. type MockManager struct { ctrl *gomock.Controller recorder *MockManagerMockRecorder } -// MockManagerMockRecorder is the mock recorder for MockManager +// MockManagerMockRecorder is the mock recorder for MockManager. type MockManagerMockRecorder struct { mock *MockManager } -// NewMockManager creates a new mock instance +// NewMockManager creates a new mock instance. func NewMockManager(ctrl *gomock.Controller) *MockManager { mock := &MockManager{ctrl: ctrl} mock.recorder = &MockManagerMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockManager) EXPECT() *MockManagerMockRecorder { return m.recorder } -// Add mocks base method +// Add mocks base method. func (m *MockManager) Add(arg0 persistedretry.Task) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Add", arg0) @@ -42,25 +42,25 @@ func (m *MockManager) Add(arg0 persistedretry.Task) error { return ret0 } -// Add indicates an expected call of Add +// Add indicates an expected call of Add. func (mr *MockManagerMockRecorder) Add(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockManager)(nil).Add), arg0) } -// Close mocks base method +// Close mocks base method. func (m *MockManager) Close() { m.ctrl.T.Helper() m.ctrl.Call(m, "Close") } -// Close indicates an expected call of Close +// Close indicates an expected call of Close. func (mr *MockManagerMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockManager)(nil).Close)) } -// Find mocks base method +// Find mocks base method. func (m *MockManager) Find(arg0 interface{}) ([]persistedretry.Task, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0) @@ -69,13 +69,13 @@ func (m *MockManager) Find(arg0 interface{}) ([]persistedretry.Task, error) { return ret0, ret1 } -// Find indicates an expected call of Find +// Find indicates an expected call of Find. func (mr *MockManagerMockRecorder) Find(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockManager)(nil).Find), arg0) } -// SyncExec mocks base method +// SyncExec mocks base method. func (m *MockManager) SyncExec(arg0 persistedretry.Task) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SyncExec", arg0) @@ -83,7 +83,7 @@ func (m *MockManager) SyncExec(arg0 persistedretry.Task) error { return ret0 } -// SyncExec indicates an expected call of SyncExec +// SyncExec indicates an expected call of SyncExec. func (mr *MockManagerMockRecorder) SyncExec(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncExec", reflect.TypeOf((*MockManager)(nil).SyncExec), arg0) diff --git a/mocks/lib/persistedretry/store.go b/mocks/lib/persistedretry/store.go index f40679fd3..e5d8c8cff 100644 --- a/mocks/lib/persistedretry/store.go +++ b/mocks/lib/persistedretry/store.go @@ -11,30 +11,30 @@ import ( persistedretry "github.com/uber/kraken/lib/persistedretry" ) -// MockStore is a mock of Store interface +// MockStore is a mock of Store interface. type MockStore struct { ctrl *gomock.Controller recorder *MockStoreMockRecorder } -// MockStoreMockRecorder is the mock recorder for MockStore +// MockStoreMockRecorder is the mock recorder for MockStore. type MockStoreMockRecorder struct { mock *MockStore } -// NewMockStore creates a new mock instance +// NewMockStore creates a new mock instance. func NewMockStore(ctrl *gomock.Controller) *MockStore { mock := &MockStore{ctrl: ctrl} mock.recorder = &MockStoreMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockStore) EXPECT() *MockStoreMockRecorder { return m.recorder } -// AddFailed mocks base method +// AddFailed mocks base method. func (m *MockStore) AddFailed(arg0 persistedretry.Task) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddFailed", arg0) @@ -42,13 +42,13 @@ func (m *MockStore) AddFailed(arg0 persistedretry.Task) error { return ret0 } -// AddFailed indicates an expected call of AddFailed +// AddFailed indicates an expected call of AddFailed. func (mr *MockStoreMockRecorder) AddFailed(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddFailed", reflect.TypeOf((*MockStore)(nil).AddFailed), arg0) } -// AddPending mocks base method +// AddPending mocks base method. func (m *MockStore) AddPending(arg0 persistedretry.Task) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddPending", arg0) @@ -56,13 +56,13 @@ func (m *MockStore) AddPending(arg0 persistedretry.Task) error { return ret0 } -// AddPending indicates an expected call of AddPending +// AddPending indicates an expected call of AddPending. func (mr *MockStoreMockRecorder) AddPending(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPending", reflect.TypeOf((*MockStore)(nil).AddPending), arg0) } -// Find mocks base method +// Find mocks base method. func (m *MockStore) Find(arg0 interface{}) ([]persistedretry.Task, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0) @@ -71,13 +71,13 @@ func (m *MockStore) Find(arg0 interface{}) ([]persistedretry.Task, error) { return ret0, ret1 } -// Find indicates an expected call of Find +// Find indicates an expected call of Find. func (mr *MockStoreMockRecorder) Find(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockStore)(nil).Find), arg0) } -// GetFailed mocks base method +// GetFailed mocks base method. func (m *MockStore) GetFailed() ([]persistedretry.Task, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetFailed") @@ -86,13 +86,13 @@ func (m *MockStore) GetFailed() ([]persistedretry.Task, error) { return ret0, ret1 } -// GetFailed indicates an expected call of GetFailed +// GetFailed indicates an expected call of GetFailed. func (mr *MockStoreMockRecorder) GetFailed() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFailed", reflect.TypeOf((*MockStore)(nil).GetFailed)) } -// GetPending mocks base method +// GetPending mocks base method. func (m *MockStore) GetPending() ([]persistedretry.Task, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetPending") @@ -101,13 +101,13 @@ func (m *MockStore) GetPending() ([]persistedretry.Task, error) { return ret0, ret1 } -// GetPending indicates an expected call of GetPending +// GetPending indicates an expected call of GetPending. func (mr *MockStoreMockRecorder) GetPending() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPending", reflect.TypeOf((*MockStore)(nil).GetPending)) } -// MarkFailed mocks base method +// MarkFailed mocks base method. func (m *MockStore) MarkFailed(arg0 persistedretry.Task) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "MarkFailed", arg0) @@ -115,13 +115,13 @@ func (m *MockStore) MarkFailed(arg0 persistedretry.Task) error { return ret0 } -// MarkFailed indicates an expected call of MarkFailed +// MarkFailed indicates an expected call of MarkFailed. func (mr *MockStoreMockRecorder) MarkFailed(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkFailed", reflect.TypeOf((*MockStore)(nil).MarkFailed), arg0) } -// MarkPending mocks base method +// MarkPending mocks base method. func (m *MockStore) MarkPending(arg0 persistedretry.Task) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "MarkPending", arg0) @@ -129,13 +129,13 @@ func (m *MockStore) MarkPending(arg0 persistedretry.Task) error { return ret0 } -// MarkPending indicates an expected call of MarkPending +// MarkPending indicates an expected call of MarkPending. func (mr *MockStoreMockRecorder) MarkPending(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkPending", reflect.TypeOf((*MockStore)(nil).MarkPending), arg0) } -// Remove mocks base method +// Remove mocks base method. func (m *MockStore) Remove(arg0 persistedretry.Task) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Remove", arg0) @@ -143,7 +143,7 @@ func (m *MockStore) Remove(arg0 persistedretry.Task) error { return ret0 } -// Remove indicates an expected call of Remove +// Remove indicates an expected call of Remove. func (mr *MockStoreMockRecorder) Remove(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockStore)(nil).Remove), arg0) diff --git a/mocks/lib/persistedretry/tagreplication/remotevalidator.go b/mocks/lib/persistedretry/tagreplication/remotevalidator.go index 4fa26be9d..c029835e8 100644 --- a/mocks/lib/persistedretry/tagreplication/remotevalidator.go +++ b/mocks/lib/persistedretry/tagreplication/remotevalidator.go @@ -10,30 +10,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockRemoteValidator is a mock of RemoteValidator interface +// MockRemoteValidator is a mock of RemoteValidator interface. type MockRemoteValidator struct { ctrl *gomock.Controller recorder *MockRemoteValidatorMockRecorder } -// MockRemoteValidatorMockRecorder is the mock recorder for MockRemoteValidator +// MockRemoteValidatorMockRecorder is the mock recorder for MockRemoteValidator. type MockRemoteValidatorMockRecorder struct { mock *MockRemoteValidator } -// NewMockRemoteValidator creates a new mock instance +// NewMockRemoteValidator creates a new mock instance. func NewMockRemoteValidator(ctrl *gomock.Controller) *MockRemoteValidator { mock := &MockRemoteValidator{ctrl: ctrl} mock.recorder = &MockRemoteValidatorMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockRemoteValidator) EXPECT() *MockRemoteValidatorMockRecorder { return m.recorder } -// Valid mocks base method +// Valid mocks base method. func (m *MockRemoteValidator) Valid(arg0, arg1 string) bool { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Valid", arg0, arg1) @@ -41,7 +41,7 @@ func (m *MockRemoteValidator) Valid(arg0, arg1 string) bool { return ret0 } -// Valid indicates an expected call of Valid +// Valid indicates an expected call of Valid. func (mr *MockRemoteValidatorMockRecorder) Valid(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Valid", reflect.TypeOf((*MockRemoteValidator)(nil).Valid), arg0, arg1) diff --git a/mocks/lib/persistedretry/task.go b/mocks/lib/persistedretry/task.go index bb9dec4d8..41589df0f 100644 --- a/mocks/lib/persistedretry/task.go +++ b/mocks/lib/persistedretry/task.go @@ -11,30 +11,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockTask is a mock of Task interface +// MockTask is a mock of Task interface. type MockTask struct { ctrl *gomock.Controller recorder *MockTaskMockRecorder } -// MockTaskMockRecorder is the mock recorder for MockTask +// MockTaskMockRecorder is the mock recorder for MockTask. type MockTaskMockRecorder struct { mock *MockTask } -// NewMockTask creates a new mock instance +// NewMockTask creates a new mock instance. func NewMockTask(ctrl *gomock.Controller) *MockTask { mock := &MockTask{ctrl: ctrl} mock.recorder = &MockTaskMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockTask) EXPECT() *MockTaskMockRecorder { return m.recorder } -// GetFailures mocks base method +// GetFailures mocks base method. func (m *MockTask) GetFailures() int { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetFailures") @@ -42,13 +42,13 @@ func (m *MockTask) GetFailures() int { return ret0 } -// GetFailures indicates an expected call of GetFailures +// GetFailures indicates an expected call of GetFailures. func (mr *MockTaskMockRecorder) GetFailures() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFailures", reflect.TypeOf((*MockTask)(nil).GetFailures)) } -// GetLastAttempt mocks base method +// GetLastAttempt mocks base method. func (m *MockTask) GetLastAttempt() time.Time { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetLastAttempt") @@ -56,13 +56,13 @@ func (m *MockTask) GetLastAttempt() time.Time { return ret0 } -// GetLastAttempt indicates an expected call of GetLastAttempt +// GetLastAttempt indicates an expected call of GetLastAttempt. func (mr *MockTaskMockRecorder) GetLastAttempt() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastAttempt", reflect.TypeOf((*MockTask)(nil).GetLastAttempt)) } -// Ready mocks base method +// Ready mocks base method. func (m *MockTask) Ready() bool { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Ready") @@ -70,13 +70,13 @@ func (m *MockTask) Ready() bool { return ret0 } -// Ready indicates an expected call of Ready +// Ready indicates an expected call of Ready. func (mr *MockTaskMockRecorder) Ready() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ready", reflect.TypeOf((*MockTask)(nil).Ready)) } -// Tags mocks base method +// Tags mocks base method. func (m *MockTask) Tags() map[string]string { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Tags") @@ -84,7 +84,7 @@ func (m *MockTask) Tags() map[string]string { return ret0 } -// Tags indicates an expected call of Tags +// Tags indicates an expected call of Tags. func (mr *MockTaskMockRecorder) Tags() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tags", reflect.TypeOf((*MockTask)(nil).Tags)) diff --git a/mocks/lib/store/filereadwriter.go b/mocks/lib/store/filereadwriter.go index 7ae49bede..4b9d99e09 100644 --- a/mocks/lib/store/filereadwriter.go +++ b/mocks/lib/store/filereadwriter.go @@ -10,30 +10,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockFileReadWriter is a mock of FileReadWriter interface +// MockFileReadWriter is a mock of FileReadWriter interface. type MockFileReadWriter struct { ctrl *gomock.Controller recorder *MockFileReadWriterMockRecorder } -// MockFileReadWriterMockRecorder is the mock recorder for MockFileReadWriter +// MockFileReadWriterMockRecorder is the mock recorder for MockFileReadWriter. type MockFileReadWriterMockRecorder struct { mock *MockFileReadWriter } -// NewMockFileReadWriter creates a new mock instance +// NewMockFileReadWriter creates a new mock instance. func NewMockFileReadWriter(ctrl *gomock.Controller) *MockFileReadWriter { mock := &MockFileReadWriter{ctrl: ctrl} mock.recorder = &MockFileReadWriterMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockFileReadWriter) EXPECT() *MockFileReadWriterMockRecorder { return m.recorder } -// Cancel mocks base method +// Cancel mocks base method. func (m *MockFileReadWriter) Cancel() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Cancel") @@ -41,13 +41,13 @@ func (m *MockFileReadWriter) Cancel() error { return ret0 } -// Cancel indicates an expected call of Cancel +// Cancel indicates an expected call of Cancel. func (mr *MockFileReadWriterMockRecorder) Cancel() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cancel", reflect.TypeOf((*MockFileReadWriter)(nil).Cancel)) } -// Close mocks base method +// Close mocks base method. func (m *MockFileReadWriter) Close() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Close") @@ -55,13 +55,13 @@ func (m *MockFileReadWriter) Close() error { return ret0 } -// Close indicates an expected call of Close +// Close indicates an expected call of Close. func (mr *MockFileReadWriterMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockFileReadWriter)(nil).Close)) } -// Commit mocks base method +// Commit mocks base method. func (m *MockFileReadWriter) Commit() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Commit") @@ -69,13 +69,13 @@ func (m *MockFileReadWriter) Commit() error { return ret0 } -// Commit indicates an expected call of Commit +// Commit indicates an expected call of Commit. func (mr *MockFileReadWriterMockRecorder) Commit() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockFileReadWriter)(nil).Commit)) } -// Read mocks base method +// Read mocks base method. func (m *MockFileReadWriter) Read(arg0 []byte) (int, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Read", arg0) @@ -84,13 +84,13 @@ func (m *MockFileReadWriter) Read(arg0 []byte) (int, error) { return ret0, ret1 } -// Read indicates an expected call of Read +// Read indicates an expected call of Read. func (mr *MockFileReadWriterMockRecorder) Read(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockFileReadWriter)(nil).Read), arg0) } -// ReadAt mocks base method +// ReadAt mocks base method. func (m *MockFileReadWriter) ReadAt(arg0 []byte, arg1 int64) (int, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ReadAt", arg0, arg1) @@ -99,13 +99,13 @@ func (m *MockFileReadWriter) ReadAt(arg0 []byte, arg1 int64) (int, error) { return ret0, ret1 } -// ReadAt indicates an expected call of ReadAt +// ReadAt indicates an expected call of ReadAt. func (mr *MockFileReadWriterMockRecorder) ReadAt(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadAt", reflect.TypeOf((*MockFileReadWriter)(nil).ReadAt), arg0, arg1) } -// Seek mocks base method +// Seek mocks base method. func (m *MockFileReadWriter) Seek(arg0 int64, arg1 int) (int64, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Seek", arg0, arg1) @@ -114,13 +114,13 @@ func (m *MockFileReadWriter) Seek(arg0 int64, arg1 int) (int64, error) { return ret0, ret1 } -// Seek indicates an expected call of Seek +// Seek indicates an expected call of Seek. func (mr *MockFileReadWriterMockRecorder) Seek(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seek", reflect.TypeOf((*MockFileReadWriter)(nil).Seek), arg0, arg1) } -// Size mocks base method +// Size mocks base method. func (m *MockFileReadWriter) Size() int64 { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Size") @@ -128,13 +128,13 @@ func (m *MockFileReadWriter) Size() int64 { return ret0 } -// Size indicates an expected call of Size +// Size indicates an expected call of Size. func (mr *MockFileReadWriterMockRecorder) Size() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Size", reflect.TypeOf((*MockFileReadWriter)(nil).Size)) } -// Write mocks base method +// Write mocks base method. func (m *MockFileReadWriter) Write(arg0 []byte) (int, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Write", arg0) @@ -143,13 +143,13 @@ func (m *MockFileReadWriter) Write(arg0 []byte) (int, error) { return ret0, ret1 } -// Write indicates an expected call of Write +// Write indicates an expected call of Write. func (mr *MockFileReadWriterMockRecorder) Write(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockFileReadWriter)(nil).Write), arg0) } -// WriteAt mocks base method +// WriteAt mocks base method. func (m *MockFileReadWriter) WriteAt(arg0 []byte, arg1 int64) (int, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "WriteAt", arg0, arg1) @@ -158,7 +158,7 @@ func (m *MockFileReadWriter) WriteAt(arg0 []byte, arg1 int64) (int, error) { return ret0, ret1 } -// WriteAt indicates an expected call of WriteAt +// WriteAt indicates an expected call of WriteAt. func (mr *MockFileReadWriterMockRecorder) WriteAt(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteAt", reflect.TypeOf((*MockFileReadWriter)(nil).WriteAt), arg0, arg1) diff --git a/mocks/lib/torrent/scheduler/reloadablescheduler.go b/mocks/lib/torrent/scheduler/reloadablescheduler.go index 6da074ce4..a8d5318b7 100644 --- a/mocks/lib/torrent/scheduler/reloadablescheduler.go +++ b/mocks/lib/torrent/scheduler/reloadablescheduler.go @@ -13,30 +13,30 @@ import ( connstate "github.com/uber/kraken/lib/torrent/scheduler/connstate" ) -// MockReloadableScheduler is a mock of ReloadableScheduler interface +// MockReloadableScheduler is a mock of ReloadableScheduler interface. type MockReloadableScheduler struct { ctrl *gomock.Controller recorder *MockReloadableSchedulerMockRecorder } -// MockReloadableSchedulerMockRecorder is the mock recorder for MockReloadableScheduler +// MockReloadableSchedulerMockRecorder is the mock recorder for MockReloadableScheduler. type MockReloadableSchedulerMockRecorder struct { mock *MockReloadableScheduler } -// NewMockReloadableScheduler creates a new mock instance +// NewMockReloadableScheduler creates a new mock instance. func NewMockReloadableScheduler(ctrl *gomock.Controller) *MockReloadableScheduler { mock := &MockReloadableScheduler{ctrl: ctrl} mock.recorder = &MockReloadableSchedulerMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockReloadableScheduler) EXPECT() *MockReloadableSchedulerMockRecorder { return m.recorder } -// BlacklistSnapshot mocks base method +// BlacklistSnapshot mocks base method. func (m *MockReloadableScheduler) BlacklistSnapshot() ([]connstate.BlacklistedConn, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "BlacklistSnapshot") @@ -45,13 +45,13 @@ func (m *MockReloadableScheduler) BlacklistSnapshot() ([]connstate.BlacklistedCo return ret0, ret1 } -// BlacklistSnapshot indicates an expected call of BlacklistSnapshot +// BlacklistSnapshot indicates an expected call of BlacklistSnapshot. func (mr *MockReloadableSchedulerMockRecorder) BlacklistSnapshot() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlacklistSnapshot", reflect.TypeOf((*MockReloadableScheduler)(nil).BlacklistSnapshot)) } -// Download mocks base method +// Download mocks base method. func (m *MockReloadableScheduler) Download(arg0 string, arg1 core.Digest) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Download", arg0, arg1) @@ -59,13 +59,13 @@ func (m *MockReloadableScheduler) Download(arg0 string, arg1 core.Digest) error return ret0 } -// Download indicates an expected call of Download +// Download indicates an expected call of Download. func (mr *MockReloadableSchedulerMockRecorder) Download(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockReloadableScheduler)(nil).Download), arg0, arg1) } -// Probe mocks base method +// Probe mocks base method. func (m *MockReloadableScheduler) Probe() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Probe") @@ -73,25 +73,25 @@ func (m *MockReloadableScheduler) Probe() error { return ret0 } -// Probe indicates an expected call of Probe +// Probe indicates an expected call of Probe. func (mr *MockReloadableSchedulerMockRecorder) Probe() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Probe", reflect.TypeOf((*MockReloadableScheduler)(nil).Probe)) } -// Reload mocks base method +// Reload mocks base method. func (m *MockReloadableScheduler) Reload(arg0 scheduler.Config) { m.ctrl.T.Helper() m.ctrl.Call(m, "Reload", arg0) } -// Reload indicates an expected call of Reload +// Reload indicates an expected call of Reload. func (mr *MockReloadableSchedulerMockRecorder) Reload(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reload", reflect.TypeOf((*MockReloadableScheduler)(nil).Reload), arg0) } -// RemoveTorrent mocks base method +// RemoveTorrent mocks base method. func (m *MockReloadableScheduler) RemoveTorrent(arg0 core.Digest) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveTorrent", arg0) @@ -99,19 +99,19 @@ func (m *MockReloadableScheduler) RemoveTorrent(arg0 core.Digest) error { return ret0 } -// RemoveTorrent indicates an expected call of RemoveTorrent +// RemoveTorrent indicates an expected call of RemoveTorrent. func (mr *MockReloadableSchedulerMockRecorder) RemoveTorrent(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTorrent", reflect.TypeOf((*MockReloadableScheduler)(nil).RemoveTorrent), arg0) } -// Stop mocks base method +// Stop mocks base method. func (m *MockReloadableScheduler) Stop() { m.ctrl.T.Helper() m.ctrl.Call(m, "Stop") } -// Stop indicates an expected call of Stop +// Stop indicates an expected call of Stop. func (mr *MockReloadableSchedulerMockRecorder) Stop() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockReloadableScheduler)(nil).Stop)) diff --git a/mocks/lib/torrent/scheduler/scheduler.go b/mocks/lib/torrent/scheduler/scheduler.go index 0a99befe6..5ff9e1da8 100644 --- a/mocks/lib/torrent/scheduler/scheduler.go +++ b/mocks/lib/torrent/scheduler/scheduler.go @@ -12,30 +12,30 @@ import ( connstate "github.com/uber/kraken/lib/torrent/scheduler/connstate" ) -// MockScheduler is a mock of Scheduler interface +// MockScheduler is a mock of Scheduler interface. type MockScheduler struct { ctrl *gomock.Controller recorder *MockSchedulerMockRecorder } -// MockSchedulerMockRecorder is the mock recorder for MockScheduler +// MockSchedulerMockRecorder is the mock recorder for MockScheduler. type MockSchedulerMockRecorder struct { mock *MockScheduler } -// NewMockScheduler creates a new mock instance +// NewMockScheduler creates a new mock instance. func NewMockScheduler(ctrl *gomock.Controller) *MockScheduler { mock := &MockScheduler{ctrl: ctrl} mock.recorder = &MockSchedulerMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockScheduler) EXPECT() *MockSchedulerMockRecorder { return m.recorder } -// BlacklistSnapshot mocks base method +// BlacklistSnapshot mocks base method. func (m *MockScheduler) BlacklistSnapshot() ([]connstate.BlacklistedConn, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "BlacklistSnapshot") @@ -44,13 +44,13 @@ func (m *MockScheduler) BlacklistSnapshot() ([]connstate.BlacklistedConn, error) return ret0, ret1 } -// BlacklistSnapshot indicates an expected call of BlacklistSnapshot +// BlacklistSnapshot indicates an expected call of BlacklistSnapshot. func (mr *MockSchedulerMockRecorder) BlacklistSnapshot() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlacklistSnapshot", reflect.TypeOf((*MockScheduler)(nil).BlacklistSnapshot)) } -// Download mocks base method +// Download mocks base method. func (m *MockScheduler) Download(arg0 string, arg1 core.Digest) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Download", arg0, arg1) @@ -58,13 +58,13 @@ func (m *MockScheduler) Download(arg0 string, arg1 core.Digest) error { return ret0 } -// Download indicates an expected call of Download +// Download indicates an expected call of Download. func (mr *MockSchedulerMockRecorder) Download(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockScheduler)(nil).Download), arg0, arg1) } -// Probe mocks base method +// Probe mocks base method. func (m *MockScheduler) Probe() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Probe") @@ -72,13 +72,13 @@ func (m *MockScheduler) Probe() error { return ret0 } -// Probe indicates an expected call of Probe +// Probe indicates an expected call of Probe. func (mr *MockSchedulerMockRecorder) Probe() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Probe", reflect.TypeOf((*MockScheduler)(nil).Probe)) } -// RemoveTorrent mocks base method +// RemoveTorrent mocks base method. func (m *MockScheduler) RemoveTorrent(arg0 core.Digest) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveTorrent", arg0) @@ -86,19 +86,19 @@ func (m *MockScheduler) RemoveTorrent(arg0 core.Digest) error { return ret0 } -// RemoveTorrent indicates an expected call of RemoveTorrent +// RemoveTorrent indicates an expected call of RemoveTorrent. func (mr *MockSchedulerMockRecorder) RemoveTorrent(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTorrent", reflect.TypeOf((*MockScheduler)(nil).RemoveTorrent), arg0) } -// Stop mocks base method +// Stop mocks base method. func (m *MockScheduler) Stop() { m.ctrl.T.Helper() m.ctrl.Call(m, "Stop") } -// Stop indicates an expected call of Stop +// Stop indicates an expected call of Stop. func (mr *MockSchedulerMockRecorder) Stop() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockScheduler)(nil).Stop)) diff --git a/mocks/origin/blobclient/client.go b/mocks/origin/blobclient/client.go index 8ef989f9e..813f3b2a7 100644 --- a/mocks/origin/blobclient/client.go +++ b/mocks/origin/blobclient/client.go @@ -1,10 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. // Source: github.com/uber/kraken/origin/blobclient (interfaces: Client) -// -// Generated by this command: -// -// mockgen -package mockblobclient . Client -// // Package mockblobclient is a generated GoMock package. package mockblobclient @@ -22,7 +17,6 @@ import ( type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder - isgomock struct{} } // MockClientMockRecorder is the mock recorder for MockClient. @@ -71,74 +65,74 @@ func (mr *MockClientMockRecorder) CheckReadiness() *gomock.Call { } // DeleteBlob mocks base method. -func (m *MockClient) DeleteBlob(d core.Digest) error { +func (m *MockClient) DeleteBlob(arg0 core.Digest) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteBlob", d) + ret := m.ctrl.Call(m, "DeleteBlob", arg0) ret0, _ := ret[0].(error) return ret0 } // DeleteBlob indicates an expected call of DeleteBlob. -func (mr *MockClientMockRecorder) DeleteBlob(d any) *gomock.Call { +func (mr *MockClientMockRecorder) DeleteBlob(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBlob", reflect.TypeOf((*MockClient)(nil).DeleteBlob), d) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBlob", reflect.TypeOf((*MockClient)(nil).DeleteBlob), arg0) } // DownloadBlob mocks base method. -func (m *MockClient) DownloadBlob(namespace string, d core.Digest, dst io.Writer) error { +func (m *MockClient) DownloadBlob(arg0 string, arg1 core.Digest, arg2 io.Writer) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DownloadBlob", namespace, d, dst) + ret := m.ctrl.Call(m, "DownloadBlob", arg0, arg1, arg2) ret0, _ := ret[0].(error) return ret0 } // DownloadBlob indicates an expected call of DownloadBlob. -func (mr *MockClientMockRecorder) DownloadBlob(namespace, d, dst any) *gomock.Call { +func (mr *MockClientMockRecorder) DownloadBlob(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadBlob", reflect.TypeOf((*MockClient)(nil).DownloadBlob), namespace, d, dst) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadBlob", reflect.TypeOf((*MockClient)(nil).DownloadBlob), arg0, arg1, arg2) } // DuplicateUploadBlob mocks base method. -func (m *MockClient) DuplicateUploadBlob(namespace string, d core.Digest, blob io.Reader, delay time.Duration) error { +func (m *MockClient) DuplicateUploadBlob(arg0 string, arg1 core.Digest, arg2 io.Reader, arg3 time.Duration) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DuplicateUploadBlob", namespace, d, blob, delay) + ret := m.ctrl.Call(m, "DuplicateUploadBlob", arg0, arg1, arg2, arg3) ret0, _ := ret[0].(error) return ret0 } // DuplicateUploadBlob indicates an expected call of DuplicateUploadBlob. -func (mr *MockClientMockRecorder) DuplicateUploadBlob(namespace, d, blob, delay any) *gomock.Call { +func (mr *MockClientMockRecorder) DuplicateUploadBlob(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DuplicateUploadBlob", reflect.TypeOf((*MockClient)(nil).DuplicateUploadBlob), namespace, d, blob, delay) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DuplicateUploadBlob", reflect.TypeOf((*MockClient)(nil).DuplicateUploadBlob), arg0, arg1, arg2, arg3) } // ForceCleanup mocks base method. -func (m *MockClient) ForceCleanup(ttl time.Duration) error { +func (m *MockClient) ForceCleanup(arg0 time.Duration) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ForceCleanup", ttl) + ret := m.ctrl.Call(m, "ForceCleanup", arg0) ret0, _ := ret[0].(error) return ret0 } // ForceCleanup indicates an expected call of ForceCleanup. -func (mr *MockClientMockRecorder) ForceCleanup(ttl any) *gomock.Call { +func (mr *MockClientMockRecorder) ForceCleanup(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceCleanup", reflect.TypeOf((*MockClient)(nil).ForceCleanup), ttl) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceCleanup", reflect.TypeOf((*MockClient)(nil).ForceCleanup), arg0) } // GetMetaInfo mocks base method. -func (m *MockClient) GetMetaInfo(namespace string, d core.Digest) (*core.MetaInfo, error) { +func (m *MockClient) GetMetaInfo(arg0 string, arg1 core.Digest) (*core.MetaInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMetaInfo", namespace, d) + ret := m.ctrl.Call(m, "GetMetaInfo", arg0, arg1) ret0, _ := ret[0].(*core.MetaInfo) ret1, _ := ret[1].(error) return ret0, ret1 } // GetMetaInfo indicates an expected call of GetMetaInfo. -func (mr *MockClientMockRecorder) GetMetaInfo(namespace, d any) *gomock.Call { +func (mr *MockClientMockRecorder) GetMetaInfo(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetaInfo", reflect.TypeOf((*MockClient)(nil).GetMetaInfo), namespace, d) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetaInfo", reflect.TypeOf((*MockClient)(nil).GetMetaInfo), arg0, arg1) } // GetPeerContext mocks base method. @@ -157,116 +151,116 @@ func (mr *MockClientMockRecorder) GetPeerContext() *gomock.Call { } // Locations mocks base method. -func (m *MockClient) Locations(d core.Digest) ([]string, error) { +func (m *MockClient) Locations(arg0 core.Digest) ([]string, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Locations", d) + ret := m.ctrl.Call(m, "Locations", arg0) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) return ret0, ret1 } // Locations indicates an expected call of Locations. -func (mr *MockClientMockRecorder) Locations(d any) *gomock.Call { +func (mr *MockClientMockRecorder) Locations(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Locations", reflect.TypeOf((*MockClient)(nil).Locations), d) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Locations", reflect.TypeOf((*MockClient)(nil).Locations), arg0) } // OverwriteMetaInfo mocks base method. -func (m *MockClient) OverwriteMetaInfo(d core.Digest, pieceLength int64) error { +func (m *MockClient) OverwriteMetaInfo(arg0 core.Digest, arg1 int64) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "OverwriteMetaInfo", d, pieceLength) + ret := m.ctrl.Call(m, "OverwriteMetaInfo", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // OverwriteMetaInfo indicates an expected call of OverwriteMetaInfo. -func (mr *MockClientMockRecorder) OverwriteMetaInfo(d, pieceLength any) *gomock.Call { +func (mr *MockClientMockRecorder) OverwriteMetaInfo(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OverwriteMetaInfo", reflect.TypeOf((*MockClient)(nil).OverwriteMetaInfo), d, pieceLength) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OverwriteMetaInfo", reflect.TypeOf((*MockClient)(nil).OverwriteMetaInfo), arg0, arg1) } // PrefetchBlob mocks base method. -func (m *MockClient) PrefetchBlob(namespace string, d core.Digest) error { +func (m *MockClient) PrefetchBlob(arg0 string, arg1 core.Digest) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PrefetchBlob", namespace, d) + ret := m.ctrl.Call(m, "PrefetchBlob", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // PrefetchBlob indicates an expected call of PrefetchBlob. -func (mr *MockClientMockRecorder) PrefetchBlob(namespace, d any) *gomock.Call { +func (mr *MockClientMockRecorder) PrefetchBlob(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrefetchBlob", reflect.TypeOf((*MockClient)(nil).PrefetchBlob), namespace, d) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrefetchBlob", reflect.TypeOf((*MockClient)(nil).PrefetchBlob), arg0, arg1) } // ReplicateToRemote mocks base method. -func (m *MockClient) ReplicateToRemote(namespace string, d core.Digest, remoteDNS string) error { +func (m *MockClient) ReplicateToRemote(arg0 string, arg1 core.Digest, arg2 string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReplicateToRemote", namespace, d, remoteDNS) + ret := m.ctrl.Call(m, "ReplicateToRemote", arg0, arg1, arg2) ret0, _ := ret[0].(error) return ret0 } // ReplicateToRemote indicates an expected call of ReplicateToRemote. -func (mr *MockClientMockRecorder) ReplicateToRemote(namespace, d, remoteDNS any) *gomock.Call { +func (mr *MockClientMockRecorder) ReplicateToRemote(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicateToRemote", reflect.TypeOf((*MockClient)(nil).ReplicateToRemote), namespace, d, remoteDNS) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicateToRemote", reflect.TypeOf((*MockClient)(nil).ReplicateToRemote), arg0, arg1, arg2) } // Stat mocks base method. -func (m *MockClient) Stat(namespace string, d core.Digest) (*core.BlobInfo, error) { +func (m *MockClient) Stat(arg0 string, arg1 core.Digest) (*core.BlobInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Stat", namespace, d) + ret := m.ctrl.Call(m, "Stat", arg0, arg1) ret0, _ := ret[0].(*core.BlobInfo) ret1, _ := ret[1].(error) return ret0, ret1 } // Stat indicates an expected call of Stat. -func (mr *MockClientMockRecorder) Stat(namespace, d any) *gomock.Call { +func (mr *MockClientMockRecorder) Stat(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockClient)(nil).Stat), namespace, d) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockClient)(nil).Stat), arg0, arg1) } // StatLocal mocks base method. -func (m *MockClient) StatLocal(namespace string, d core.Digest) (*core.BlobInfo, error) { +func (m *MockClient) StatLocal(arg0 string, arg1 core.Digest) (*core.BlobInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StatLocal", namespace, d) + ret := m.ctrl.Call(m, "StatLocal", arg0, arg1) ret0, _ := ret[0].(*core.BlobInfo) ret1, _ := ret[1].(error) return ret0, ret1 } // StatLocal indicates an expected call of StatLocal. -func (mr *MockClientMockRecorder) StatLocal(namespace, d any) *gomock.Call { +func (mr *MockClientMockRecorder) StatLocal(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatLocal", reflect.TypeOf((*MockClient)(nil).StatLocal), namespace, d) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatLocal", reflect.TypeOf((*MockClient)(nil).StatLocal), arg0, arg1) } // TransferBlob mocks base method. -func (m *MockClient) TransferBlob(d core.Digest, blob io.Reader) error { +func (m *MockClient) TransferBlob(arg0 core.Digest, arg1 io.Reader) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TransferBlob", d, blob) + ret := m.ctrl.Call(m, "TransferBlob", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // TransferBlob indicates an expected call of TransferBlob. -func (mr *MockClientMockRecorder) TransferBlob(d, blob any) *gomock.Call { +func (mr *MockClientMockRecorder) TransferBlob(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransferBlob", reflect.TypeOf((*MockClient)(nil).TransferBlob), d, blob) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransferBlob", reflect.TypeOf((*MockClient)(nil).TransferBlob), arg0, arg1) } // UploadBlob mocks base method. -func (m *MockClient) UploadBlob(namespace string, d core.Digest, blob io.Reader) error { +func (m *MockClient) UploadBlob(arg0 string, arg1 core.Digest, arg2 io.Reader) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UploadBlob", namespace, d, blob) + ret := m.ctrl.Call(m, "UploadBlob", arg0, arg1, arg2) ret0, _ := ret[0].(error) return ret0 } // UploadBlob indicates an expected call of UploadBlob. -func (mr *MockClientMockRecorder) UploadBlob(namespace, d, blob any) *gomock.Call { +func (mr *MockClientMockRecorder) UploadBlob(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadBlob", reflect.TypeOf((*MockClient)(nil).UploadBlob), namespace, d, blob) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadBlob", reflect.TypeOf((*MockClient)(nil).UploadBlob), arg0, arg1, arg2) } diff --git a/mocks/origin/blobclient/clientresolver.go b/mocks/origin/blobclient/clientresolver.go index 8e385aa0f..39103a5b1 100644 --- a/mocks/origin/blobclient/clientresolver.go +++ b/mocks/origin/blobclient/clientresolver.go @@ -12,30 +12,30 @@ import ( blobclient "github.com/uber/kraken/origin/blobclient" ) -// MockClientResolver is a mock of ClientResolver interface +// MockClientResolver is a mock of ClientResolver interface. type MockClientResolver struct { ctrl *gomock.Controller recorder *MockClientResolverMockRecorder } -// MockClientResolverMockRecorder is the mock recorder for MockClientResolver +// MockClientResolverMockRecorder is the mock recorder for MockClientResolver. type MockClientResolverMockRecorder struct { mock *MockClientResolver } -// NewMockClientResolver creates a new mock instance +// NewMockClientResolver creates a new mock instance. func NewMockClientResolver(ctrl *gomock.Controller) *MockClientResolver { mock := &MockClientResolver{ctrl: ctrl} mock.recorder = &MockClientResolverMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockClientResolver) EXPECT() *MockClientResolverMockRecorder { return m.recorder } -// Resolve mocks base method +// Resolve mocks base method. func (m *MockClientResolver) Resolve(arg0 core.Digest) ([]blobclient.Client, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Resolve", arg0) @@ -44,7 +44,7 @@ func (m *MockClientResolver) Resolve(arg0 core.Digest) ([]blobclient.Client, err return ret0, ret1 } -// Resolve indicates an expected call of Resolve +// Resolve indicates an expected call of Resolve. func (mr *MockClientResolverMockRecorder) Resolve(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resolve", reflect.TypeOf((*MockClientResolver)(nil).Resolve), arg0) diff --git a/mocks/origin/blobclient/clusterclient.go b/mocks/origin/blobclient/clusterclient.go index 7334d48cd..cd8f0dcb1 100644 --- a/mocks/origin/blobclient/clusterclient.go +++ b/mocks/origin/blobclient/clusterclient.go @@ -1,10 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. // Source: github.com/uber/kraken/origin/blobclient (interfaces: ClusterClient) -// -// Generated by this command: -// -// mockgen -package mockblobclient . ClusterClient -// // Package mockblobclient is a generated GoMock package. package mockblobclient @@ -21,7 +16,6 @@ import ( type MockClusterClient struct { ctrl *gomock.Controller recorder *MockClusterClientMockRecorder - isgomock struct{} } // MockClusterClientMockRecorder is the mock recorder for MockClusterClient. @@ -56,116 +50,116 @@ func (mr *MockClusterClientMockRecorder) CheckReadiness() *gomock.Call { } // DownloadBlob mocks base method. -func (m *MockClusterClient) DownloadBlob(namespace string, d core.Digest, dst io.Writer) error { +func (m *MockClusterClient) DownloadBlob(arg0 string, arg1 core.Digest, arg2 io.Writer) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DownloadBlob", namespace, d, dst) + ret := m.ctrl.Call(m, "DownloadBlob", arg0, arg1, arg2) ret0, _ := ret[0].(error) return ret0 } // DownloadBlob indicates an expected call of DownloadBlob. -func (mr *MockClusterClientMockRecorder) DownloadBlob(namespace, d, dst any) *gomock.Call { +func (mr *MockClusterClientMockRecorder) DownloadBlob(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadBlob", reflect.TypeOf((*MockClusterClient)(nil).DownloadBlob), namespace, d, dst) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadBlob", reflect.TypeOf((*MockClusterClient)(nil).DownloadBlob), arg0, arg1, arg2) } // GetMetaInfo mocks base method. -func (m *MockClusterClient) GetMetaInfo(namespace string, d core.Digest) (*core.MetaInfo, error) { +func (m *MockClusterClient) GetMetaInfo(arg0 string, arg1 core.Digest) (*core.MetaInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMetaInfo", namespace, d) + ret := m.ctrl.Call(m, "GetMetaInfo", arg0, arg1) ret0, _ := ret[0].(*core.MetaInfo) ret1, _ := ret[1].(error) return ret0, ret1 } // GetMetaInfo indicates an expected call of GetMetaInfo. -func (mr *MockClusterClientMockRecorder) GetMetaInfo(namespace, d any) *gomock.Call { +func (mr *MockClusterClientMockRecorder) GetMetaInfo(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetaInfo", reflect.TypeOf((*MockClusterClient)(nil).GetMetaInfo), namespace, d) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetaInfo", reflect.TypeOf((*MockClusterClient)(nil).GetMetaInfo), arg0, arg1) } // OverwriteMetaInfo mocks base method. -func (m *MockClusterClient) OverwriteMetaInfo(d core.Digest, pieceLength int64) error { +func (m *MockClusterClient) OverwriteMetaInfo(arg0 core.Digest, arg1 int64) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "OverwriteMetaInfo", d, pieceLength) + ret := m.ctrl.Call(m, "OverwriteMetaInfo", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // OverwriteMetaInfo indicates an expected call of OverwriteMetaInfo. -func (mr *MockClusterClientMockRecorder) OverwriteMetaInfo(d, pieceLength any) *gomock.Call { +func (mr *MockClusterClientMockRecorder) OverwriteMetaInfo(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OverwriteMetaInfo", reflect.TypeOf((*MockClusterClient)(nil).OverwriteMetaInfo), d, pieceLength) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OverwriteMetaInfo", reflect.TypeOf((*MockClusterClient)(nil).OverwriteMetaInfo), arg0, arg1) } // Owners mocks base method. -func (m *MockClusterClient) Owners(d core.Digest) ([]core.PeerContext, error) { +func (m *MockClusterClient) Owners(arg0 core.Digest) ([]core.PeerContext, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Owners", d) + ret := m.ctrl.Call(m, "Owners", arg0) ret0, _ := ret[0].([]core.PeerContext) ret1, _ := ret[1].(error) return ret0, ret1 } // Owners indicates an expected call of Owners. -func (mr *MockClusterClientMockRecorder) Owners(d any) *gomock.Call { +func (mr *MockClusterClientMockRecorder) Owners(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Owners", reflect.TypeOf((*MockClusterClient)(nil).Owners), d) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Owners", reflect.TypeOf((*MockClusterClient)(nil).Owners), arg0) } // PrefetchBlob mocks base method. -func (m *MockClusterClient) PrefetchBlob(namespace string, d core.Digest) error { +func (m *MockClusterClient) PrefetchBlob(arg0 string, arg1 core.Digest) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PrefetchBlob", namespace, d) + ret := m.ctrl.Call(m, "PrefetchBlob", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // PrefetchBlob indicates an expected call of PrefetchBlob. -func (mr *MockClusterClientMockRecorder) PrefetchBlob(namespace, d any) *gomock.Call { +func (mr *MockClusterClientMockRecorder) PrefetchBlob(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrefetchBlob", reflect.TypeOf((*MockClusterClient)(nil).PrefetchBlob), namespace, d) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrefetchBlob", reflect.TypeOf((*MockClusterClient)(nil).PrefetchBlob), arg0, arg1) } // ReplicateToRemote mocks base method. -func (m *MockClusterClient) ReplicateToRemote(namespace string, d core.Digest, remoteDNS string) error { +func (m *MockClusterClient) ReplicateToRemote(arg0 string, arg1 core.Digest, arg2 string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReplicateToRemote", namespace, d, remoteDNS) + ret := m.ctrl.Call(m, "ReplicateToRemote", arg0, arg1, arg2) ret0, _ := ret[0].(error) return ret0 } // ReplicateToRemote indicates an expected call of ReplicateToRemote. -func (mr *MockClusterClientMockRecorder) ReplicateToRemote(namespace, d, remoteDNS any) *gomock.Call { +func (mr *MockClusterClientMockRecorder) ReplicateToRemote(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicateToRemote", reflect.TypeOf((*MockClusterClient)(nil).ReplicateToRemote), namespace, d, remoteDNS) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicateToRemote", reflect.TypeOf((*MockClusterClient)(nil).ReplicateToRemote), arg0, arg1, arg2) } // Stat mocks base method. -func (m *MockClusterClient) Stat(namespace string, d core.Digest) (*core.BlobInfo, error) { +func (m *MockClusterClient) Stat(arg0 string, arg1 core.Digest) (*core.BlobInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Stat", namespace, d) + ret := m.ctrl.Call(m, "Stat", arg0, arg1) ret0, _ := ret[0].(*core.BlobInfo) ret1, _ := ret[1].(error) return ret0, ret1 } // Stat indicates an expected call of Stat. -func (mr *MockClusterClientMockRecorder) Stat(namespace, d any) *gomock.Call { +func (mr *MockClusterClientMockRecorder) Stat(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockClusterClient)(nil).Stat), namespace, d) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockClusterClient)(nil).Stat), arg0, arg1) } // UploadBlob mocks base method. -func (m *MockClusterClient) UploadBlob(namespace string, d core.Digest, blob io.ReadSeeker) error { +func (m *MockClusterClient) UploadBlob(arg0 string, arg1 core.Digest, arg2 io.ReadSeeker) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UploadBlob", namespace, d, blob) + ret := m.ctrl.Call(m, "UploadBlob", arg0, arg1, arg2) ret0, _ := ret[0].(error) return ret0 } // UploadBlob indicates an expected call of UploadBlob. -func (mr *MockClusterClientMockRecorder) UploadBlob(namespace, d, blob any) *gomock.Call { +func (mr *MockClusterClientMockRecorder) UploadBlob(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadBlob", reflect.TypeOf((*MockClusterClient)(nil).UploadBlob), namespace, d, blob) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadBlob", reflect.TypeOf((*MockClusterClient)(nil).UploadBlob), arg0, arg1, arg2) } diff --git a/mocks/origin/blobclient/clusterprovider.go b/mocks/origin/blobclient/clusterprovider.go index 6971163cd..2626792f4 100644 --- a/mocks/origin/blobclient/clusterprovider.go +++ b/mocks/origin/blobclient/clusterprovider.go @@ -11,30 +11,30 @@ import ( blobclient "github.com/uber/kraken/origin/blobclient" ) -// MockClusterProvider is a mock of ClusterProvider interface +// MockClusterProvider is a mock of ClusterProvider interface. type MockClusterProvider struct { ctrl *gomock.Controller recorder *MockClusterProviderMockRecorder } -// MockClusterProviderMockRecorder is the mock recorder for MockClusterProvider +// MockClusterProviderMockRecorder is the mock recorder for MockClusterProvider. type MockClusterProviderMockRecorder struct { mock *MockClusterProvider } -// NewMockClusterProvider creates a new mock instance +// NewMockClusterProvider creates a new mock instance. func NewMockClusterProvider(ctrl *gomock.Controller) *MockClusterProvider { mock := &MockClusterProvider{ctrl: ctrl} mock.recorder = &MockClusterProviderMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockClusterProvider) EXPECT() *MockClusterProviderMockRecorder { return m.recorder } -// Provide mocks base method +// Provide mocks base method. func (m *MockClusterProvider) Provide(arg0 string) (blobclient.ClusterClient, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Provide", arg0) @@ -43,7 +43,7 @@ func (m *MockClusterProvider) Provide(arg0 string) (blobclient.ClusterClient, er return ret0, ret1 } -// Provide indicates an expected call of Provide +// Provide indicates an expected call of Provide. func (mr *MockClusterProviderMockRecorder) Provide(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Provide", reflect.TypeOf((*MockClusterProvider)(nil).Provide), arg0) diff --git a/mocks/origin/blobclient/provider.go b/mocks/origin/blobclient/provider.go index 816a11139..9ba73a2ac 100644 --- a/mocks/origin/blobclient/provider.go +++ b/mocks/origin/blobclient/provider.go @@ -11,30 +11,30 @@ import ( blobclient "github.com/uber/kraken/origin/blobclient" ) -// MockProvider is a mock of Provider interface +// MockProvider is a mock of Provider interface. type MockProvider struct { ctrl *gomock.Controller recorder *MockProviderMockRecorder } -// MockProviderMockRecorder is the mock recorder for MockProvider +// MockProviderMockRecorder is the mock recorder for MockProvider. type MockProviderMockRecorder struct { mock *MockProvider } -// NewMockProvider creates a new mock instance +// NewMockProvider creates a new mock instance. func NewMockProvider(ctrl *gomock.Controller) *MockProvider { mock := &MockProvider{ctrl: ctrl} mock.recorder = &MockProviderMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockProvider) EXPECT() *MockProviderMockRecorder { return m.recorder } -// Provide mocks base method +// Provide mocks base method. func (m *MockProvider) Provide(arg0 string) blobclient.Client { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Provide", arg0) @@ -42,7 +42,7 @@ func (m *MockProvider) Provide(arg0 string) blobclient.Client { return ret0 } -// Provide indicates an expected call of Provide +// Provide indicates an expected call of Provide. func (mr *MockProviderMockRecorder) Provide(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Provide", reflect.TypeOf((*MockProvider)(nil).Provide), arg0) diff --git a/mocks/tracker/announceclient/client.go b/mocks/tracker/announceclient/client.go index 35cc21ec7..7ad24b799 100644 --- a/mocks/tracker/announceclient/client.go +++ b/mocks/tracker/announceclient/client.go @@ -1,10 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. // Source: github.com/uber/kraken/tracker/announceclient (interfaces: Client) -// -// Generated by this command: -// -// mockgen -typed -package mockannounceclient . Client -// // Package mockannounceclient is a generated GoMock package. package mockannounceclient @@ -41,9 +36,9 @@ func (m *MockClient) EXPECT() *MockClientMockRecorder { } // Announce mocks base method. -func (m *MockClient) Announce(d core.Digest, h core.InfoHash, complete bool, version int) ([]*core.PeerInfo, time.Duration, error) { +func (m *MockClient) Announce(arg0 core.Digest, arg1 core.InfoHash, arg2 bool, arg3 int) ([]*core.PeerInfo, time.Duration, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Announce", d, h, complete, version) + ret := m.ctrl.Call(m, "Announce", arg0, arg1, arg2, arg3) ret0, _ := ret[0].([]*core.PeerInfo) ret1, _ := ret[1].(time.Duration) ret2, _ := ret[2].(error) @@ -51,33 +46,9 @@ func (m *MockClient) Announce(d core.Digest, h core.InfoHash, complete bool, ver } // Announce indicates an expected call of Announce. -func (mr *MockClientMockRecorder) Announce(d, h, complete, version interface{}) *MockClientAnnounceCall { +func (mr *MockClientMockRecorder) Announce(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Announce", reflect.TypeOf((*MockClient)(nil).Announce), d, h, complete, version) - return &MockClientAnnounceCall{Call: call} -} - -// MockClientAnnounceCall wrap *gomock.Call -type MockClientAnnounceCall struct { - *gomock.Call -} - -// Return rewrite *gomock.Call.Return -func (c *MockClientAnnounceCall) Return(arg0 []*core.PeerInfo, arg1 time.Duration, arg2 error) *MockClientAnnounceCall { - c.Call = c.Call.Return(arg0, arg1, arg2) - return c -} - -// Do rewrite *gomock.Call.Do -func (c *MockClientAnnounceCall) Do(f func(core.Digest, core.InfoHash, bool, int) ([]*core.PeerInfo, time.Duration, error)) *MockClientAnnounceCall { - c.Call = c.Call.Do(f) - return c -} - -// DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *MockClientAnnounceCall) DoAndReturn(f func(core.Digest, core.InfoHash, bool, int) ([]*core.PeerInfo, time.Duration, error)) *MockClientAnnounceCall { - c.Call = c.Call.DoAndReturn(f) - return c + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Announce", reflect.TypeOf((*MockClient)(nil).Announce), arg0, arg1, arg2, arg3) } // CheckReadiness mocks base method. @@ -89,31 +60,7 @@ func (m *MockClient) CheckReadiness() error { } // CheckReadiness indicates an expected call of CheckReadiness. -func (mr *MockClientMockRecorder) CheckReadiness() *MockClientCheckReadinessCall { +func (mr *MockClientMockRecorder) CheckReadiness() *gomock.Call { mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckReadiness", reflect.TypeOf((*MockClient)(nil).CheckReadiness)) - return &MockClientCheckReadinessCall{Call: call} -} - -// MockClientCheckReadinessCall wrap *gomock.Call -type MockClientCheckReadinessCall struct { - *gomock.Call -} - -// Return rewrite *gomock.Call.Return -func (c *MockClientCheckReadinessCall) Return(arg0 error) *MockClientCheckReadinessCall { - c.Call = c.Call.Return(arg0) - return c -} - -// Do rewrite *gomock.Call.Do -func (c *MockClientCheckReadinessCall) Do(f func() error) *MockClientCheckReadinessCall { - c.Call = c.Call.Do(f) - return c -} - -// DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *MockClientCheckReadinessCall) DoAndReturn(f func() error) *MockClientCheckReadinessCall { - c.Call = c.Call.DoAndReturn(f) - return c + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckReadiness", reflect.TypeOf((*MockClient)(nil).CheckReadiness)) } diff --git a/mocks/tracker/metainfoclient/client.go b/mocks/tracker/metainfoclient/client.go index 88be3eb6f..9a859c10e 100644 --- a/mocks/tracker/metainfoclient/client.go +++ b/mocks/tracker/metainfoclient/client.go @@ -11,30 +11,30 @@ import ( core "github.com/uber/kraken/core" ) -// MockClient is a mock of Client interface +// MockClient is a mock of Client interface. type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder } -// MockClientMockRecorder is the mock recorder for MockClient +// MockClientMockRecorder is the mock recorder for MockClient. type MockClientMockRecorder struct { mock *MockClient } -// NewMockClient creates a new mock instance +// NewMockClient creates a new mock instance. func NewMockClient(ctrl *gomock.Controller) *MockClient { mock := &MockClient{ctrl: ctrl} mock.recorder = &MockClientMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockClient) EXPECT() *MockClientMockRecorder { return m.recorder } -// Download mocks base method +// Download mocks base method. func (m *MockClient) Download(arg0 string, arg1 core.Digest) (*core.MetaInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Download", arg0, arg1) @@ -43,7 +43,7 @@ func (m *MockClient) Download(arg0 string, arg1 core.Digest) (*core.MetaInfo, er return ret0, ret1 } -// Download indicates an expected call of Download +// Download indicates an expected call of Download. func (mr *MockClientMockRecorder) Download(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockClient)(nil).Download), arg0, arg1) diff --git a/mocks/tracker/originstore/store.go b/mocks/tracker/originstore/store.go index dd411a283..4e5fcbc66 100644 --- a/mocks/tracker/originstore/store.go +++ b/mocks/tracker/originstore/store.go @@ -11,30 +11,30 @@ import ( core "github.com/uber/kraken/core" ) -// MockStore is a mock of Store interface +// MockStore is a mock of Store interface. type MockStore struct { ctrl *gomock.Controller recorder *MockStoreMockRecorder } -// MockStoreMockRecorder is the mock recorder for MockStore +// MockStoreMockRecorder is the mock recorder for MockStore. type MockStoreMockRecorder struct { mock *MockStore } -// NewMockStore creates a new mock instance +// NewMockStore creates a new mock instance. func NewMockStore(ctrl *gomock.Controller) *MockStore { mock := &MockStore{ctrl: ctrl} mock.recorder = &MockStoreMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockStore) EXPECT() *MockStoreMockRecorder { return m.recorder } -// GetOrigins mocks base method +// GetOrigins mocks base method. func (m *MockStore) GetOrigins(arg0 core.Digest) ([]*core.PeerInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetOrigins", arg0) @@ -43,7 +43,7 @@ func (m *MockStore) GetOrigins(arg0 core.Digest) ([]*core.PeerInfo, error) { return ret0, ret1 } -// GetOrigins indicates an expected call of GetOrigins +// GetOrigins indicates an expected call of GetOrigins. func (mr *MockStoreMockRecorder) GetOrigins(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrigins", reflect.TypeOf((*MockStore)(nil).GetOrigins), arg0) diff --git a/mocks/tracker/peerstore/store.go b/mocks/tracker/peerstore/store.go index 735763586..784ab9f2a 100644 --- a/mocks/tracker/peerstore/store.go +++ b/mocks/tracker/peerstore/store.go @@ -11,42 +11,42 @@ import ( core "github.com/uber/kraken/core" ) -// MockStore is a mock of Store interface +// MockStore is a mock of Store interface. type MockStore struct { ctrl *gomock.Controller recorder *MockStoreMockRecorder } -// MockStoreMockRecorder is the mock recorder for MockStore +// MockStoreMockRecorder is the mock recorder for MockStore. type MockStoreMockRecorder struct { mock *MockStore } -// NewMockStore creates a new mock instance +// NewMockStore creates a new mock instance. func NewMockStore(ctrl *gomock.Controller) *MockStore { mock := &MockStore{ctrl: ctrl} mock.recorder = &MockStoreMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockStore) EXPECT() *MockStoreMockRecorder { return m.recorder } -// Close mocks base method +// Close mocks base method. func (m *MockStore) Close() { m.ctrl.T.Helper() m.ctrl.Call(m, "Close") } -// Close indicates an expected call of Close +// Close indicates an expected call of Close. func (mr *MockStoreMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStore)(nil).Close)) } -// GetPeers mocks base method +// GetPeers mocks base method. func (m *MockStore) GetPeers(arg0 core.InfoHash, arg1 int) ([]*core.PeerInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetPeers", arg0, arg1) @@ -55,13 +55,13 @@ func (m *MockStore) GetPeers(arg0 core.InfoHash, arg1 int) ([]*core.PeerInfo, er return ret0, ret1 } -// GetPeers indicates an expected call of GetPeers +// GetPeers indicates an expected call of GetPeers. func (mr *MockStoreMockRecorder) GetPeers(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPeers", reflect.TypeOf((*MockStore)(nil).GetPeers), arg0, arg1) } -// UpdatePeer mocks base method +// UpdatePeer mocks base method. func (m *MockStore) UpdatePeer(arg0 core.InfoHash, arg1 *core.PeerInfo) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdatePeer", arg0, arg1) @@ -69,7 +69,7 @@ func (m *MockStore) UpdatePeer(arg0 core.InfoHash, arg1 *core.PeerInfo) error { return ret0 } -// UpdatePeer indicates an expected call of UpdatePeer +// UpdatePeer indicates an expected call of UpdatePeer. func (mr *MockStoreMockRecorder) UpdatePeer(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePeer", reflect.TypeOf((*MockStore)(nil).UpdatePeer), arg0, arg1) diff --git a/mocks/utils/dedup/intervaltask.go b/mocks/utils/dedup/intervaltask.go index eed6d226c..ea3e3adc2 100644 --- a/mocks/utils/dedup/intervaltask.go +++ b/mocks/utils/dedup/intervaltask.go @@ -10,36 +10,36 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockIntervalTask is a mock of IntervalTask interface +// MockIntervalTask is a mock of IntervalTask interface. type MockIntervalTask struct { ctrl *gomock.Controller recorder *MockIntervalTaskMockRecorder } -// MockIntervalTaskMockRecorder is the mock recorder for MockIntervalTask +// MockIntervalTaskMockRecorder is the mock recorder for MockIntervalTask. type MockIntervalTaskMockRecorder struct { mock *MockIntervalTask } -// NewMockIntervalTask creates a new mock instance +// NewMockIntervalTask creates a new mock instance. func NewMockIntervalTask(ctrl *gomock.Controller) *MockIntervalTask { mock := &MockIntervalTask{ctrl: ctrl} mock.recorder = &MockIntervalTaskMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockIntervalTask) EXPECT() *MockIntervalTaskMockRecorder { return m.recorder } -// Run mocks base method +// Run mocks base method. func (m *MockIntervalTask) Run() { m.ctrl.T.Helper() m.ctrl.Call(m, "Run") } -// Run indicates an expected call of Run +// Run indicates an expected call of Run. func (mr *MockIntervalTaskMockRecorder) Run() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockIntervalTask)(nil).Run)) diff --git a/mocks/utils/dedup/taskrunner.go b/mocks/utils/dedup/taskrunner.go index b9128205e..b68281d0d 100644 --- a/mocks/utils/dedup/taskrunner.go +++ b/mocks/utils/dedup/taskrunner.go @@ -11,30 +11,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockTaskRunner is a mock of TaskRunner interface +// MockTaskRunner is a mock of TaskRunner interface. type MockTaskRunner struct { ctrl *gomock.Controller recorder *MockTaskRunnerMockRecorder } -// MockTaskRunnerMockRecorder is the mock recorder for MockTaskRunner +// MockTaskRunnerMockRecorder is the mock recorder for MockTaskRunner. type MockTaskRunnerMockRecorder struct { mock *MockTaskRunner } -// NewMockTaskRunner creates a new mock instance +// NewMockTaskRunner creates a new mock instance. func NewMockTaskRunner(ctrl *gomock.Controller) *MockTaskRunner { mock := &MockTaskRunner{ctrl: ctrl} mock.recorder = &MockTaskRunnerMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockTaskRunner) EXPECT() *MockTaskRunnerMockRecorder { return m.recorder } -// Run mocks base method +// Run mocks base method. func (m *MockTaskRunner) Run(arg0 interface{}) (interface{}, time.Duration) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Run", arg0) @@ -43,7 +43,7 @@ func (m *MockTaskRunner) Run(arg0 interface{}) (interface{}, time.Duration) { return ret0, ret1 } -// Run indicates an expected call of Run +// Run indicates an expected call of Run. func (mr *MockTaskRunnerMockRecorder) Run(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockTaskRunner)(nil).Run), arg0) diff --git a/mocks/utils/httputil/roundtripper.go b/mocks/utils/httputil/roundtripper.go index 1e97b476d..0c6885bd1 100644 --- a/mocks/utils/httputil/roundtripper.go +++ b/mocks/utils/httputil/roundtripper.go @@ -11,30 +11,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockRoundTripper is a mock of RoundTripper interface +// MockRoundTripper is a mock of RoundTripper interface. type MockRoundTripper struct { ctrl *gomock.Controller recorder *MockRoundTripperMockRecorder } -// MockRoundTripperMockRecorder is the mock recorder for MockRoundTripper +// MockRoundTripperMockRecorder is the mock recorder for MockRoundTripper. type MockRoundTripperMockRecorder struct { mock *MockRoundTripper } -// NewMockRoundTripper creates a new mock instance +// NewMockRoundTripper creates a new mock instance. func NewMockRoundTripper(ctrl *gomock.Controller) *MockRoundTripper { mock := &MockRoundTripper{ctrl: ctrl} mock.recorder = &MockRoundTripperMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockRoundTripper) EXPECT() *MockRoundTripperMockRecorder { return m.recorder } -// RoundTrip mocks base method +// RoundTrip mocks base method. func (m *MockRoundTripper) RoundTrip(arg0 *http.Request) (*http.Response, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RoundTrip", arg0) @@ -43,7 +43,7 @@ func (m *MockRoundTripper) RoundTrip(arg0 *http.Request) (*http.Response, error) return ret0, ret1 } -// RoundTrip indicates an expected call of RoundTrip +// RoundTrip indicates an expected call of RoundTrip. func (mr *MockRoundTripperMockRecorder) RoundTrip(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoundTrip", reflect.TypeOf((*MockRoundTripper)(nil).RoundTrip), arg0) diff --git a/origin/blobserver/server.go b/origin/blobserver/server.go index 51381732b..6666c601b 100644 --- a/origin/blobserver/server.go +++ b/origin/blobserver/server.go @@ -14,6 +14,7 @@ package blobserver import ( + "context" "encoding/json" "fmt" "io" @@ -690,14 +691,14 @@ func (s *Server) commitTransferHandler(w http.ResponseWriter, r *http.Request) e return nil } -func (s *Server) handleUploadConflict(err error, namespace string, d core.Digest) error { +func (s *Server) handleUploadConflict(ctx context.Context, err error, namespace string, d core.Digest) error { if herr, ok := err.(*handler.Error); ok && herr.GetStatus() == http.StatusConflict { // Even if the blob was already uploaded and committed to cache, it's // still possible that adding the write-back task failed. Clients short // circuit on conflict and return success, so we must make sure that if we // tell a client to stop before commit, the blob has been written back. log.With("namespace", namespace, "digest", d.Hex()).Debug("Handling upload conflict, ensuring write-back") - if err := s.writeBack(namespace, d, 0); err != nil { + if err := s.writeBack(ctx, namespace, d, 0); err != nil { log.With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to ensure write-back on conflict: %s", err) return err } @@ -719,7 +720,7 @@ func (s *Server) startClusterUploadHandler(w http.ResponseWriter, r *http.Reques uid, err := s.uploader.start(d) if err != nil { log.With("namespace", namespace, "digest", d.Hex()).Warnf("Failed to start cluster upload: %s", err) - return s.handleUploadConflict(err, namespace, d) + return s.handleUploadConflict(r.Context(), err, namespace, d) } setUploadLocation(w, uid) w.WriteHeader(http.StatusOK) @@ -748,7 +749,7 @@ func (s *Server) patchClusterUploadHandler(w http.ResponseWriter, r *http.Reques log.With("namespace", namespace, "digest", d.Hex(), "uid", uid, "start", start, "end", end).Debug("Patching cluster upload chunk") if err := s.uploader.patch(d, uid, r.Body, start, end); err != nil { log.With("namespace", namespace, "digest", d.Hex(), "uid", uid).Errorf("Failed to patch cluster upload: %s", err) - return s.handleUploadConflict(err, namespace, d) + return s.handleUploadConflict(r.Context(), err, namespace, d) } log.With("namespace", namespace, "digest", d.Hex(), "uid", uid, "start", start, "end", end).Debug("Successfully patched upload chunk") return nil @@ -774,9 +775,9 @@ func (s *Server) commitClusterUploadHandler(w http.ResponseWriter, r *http.Reque log.With("namespace", namespace, "digest", d.Hex(), "uid", uid).Info("Committing cluster upload") if err := s.uploader.commit(d, uid); err != nil { log.With("namespace", namespace, "digest", d.Hex(), "uid", uid).Errorf("Failed to commit cluster upload: %s", err) - return s.handleUploadConflict(err, namespace, d) + return s.handleUploadConflict(r.Context(), err, namespace, d) } - if err := s.writeBack(namespace, d, 0); err != nil { + if err := s.writeBack(r.Context(), namespace, d, 0); err != nil { log.With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to write back blob: %s", err) return err } @@ -842,7 +843,7 @@ func (s *Server) duplicateCommitClusterUploadHandler(w http.ResponseWriter, r *h log.With("namespace", namespace, "digest", d.Hex(), "uid", uid).Errorf("Failed to commit duplicate upload: %s", err) return err } - if err := s.writeBack(namespace, d, delay); err != nil { + if err := s.writeBack(r.Context(), namespace, d, delay); err != nil { log.With("namespace", namespace, "digest", d.Hex(), "delay", delay).Errorf("Failed to write back duplicate: %s", err) return err } @@ -850,13 +851,13 @@ func (s *Server) duplicateCommitClusterUploadHandler(w http.ResponseWriter, r *h return nil } -func (s *Server) writeBack(namespace string, d core.Digest, delay time.Duration) error { +func (s *Server) writeBack(ctx context.Context, namespace string, d core.Digest, delay time.Duration) error { log.With("namespace", namespace, "digest", d.Hex(), "delay", delay).Debug("Starting write-back process") if _, err := s.cas.SetCacheFileMetadata(d.Hex(), metadata.NewPersist(true)); err != nil { log.With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to set persist metadata: %s", err) return handler.Errorf("set persist metadata: %s", err) } - task := writeback.NewTask(namespace, d.Hex(), delay) + task := writeback.NewTaskWithContext(ctx, namespace, d.Hex(), delay) if err := s.writeBackManager.Add(task); err != nil { log.With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to add write-back task: %s", err) return handler.Errorf("add write-back task: %s", err) diff --git a/origin/cmd/cmd.go b/origin/cmd/cmd.go index 4c8c1537c..05b8d6724 100644 --- a/origin/cmd/cmd.go +++ b/origin/cmd/cmd.go @@ -46,6 +46,7 @@ import ( "github.com/andres-erbsen/clock" "github.com/go-chi/chi" "github.com/uber-go/tally" + "go.opentelemetry.io/otel" "go.uber.org/zap" ) @@ -202,11 +203,12 @@ func Run(flags *Flags, opts ...Option) { log.Fatalf("Error creating local db: %s", err) } + tracer := otel.Tracer("kraken-origin") writeBackManager, err := persistedretry.NewManager( config.WriteBack, stats, writeback.NewStore(localDB), - writeback.NewExecutor(stats, cas, backendManager)) + writeback.NewExecutor(stats, cas, backendManager, tracer)) if err != nil { log.Fatalf("Error creating write-back manager: %s", err) } From 32bb84630601a9bcb2991aec5b823626162e48ef Mon Sep 17 00:00:00 2001 From: hweawer Date: Tue, 20 Jan 2026 13:11:23 +0100 Subject: [PATCH 04/32] Revert mocks --- mocks/agent/agentclient/client.go | 16 +-- mocks/build-index/tagclient/client.go | 94 ++++++++------- mocks/build-index/tagclient/provider.go | 12 +- mocks/build-index/tagstore/filestore.go | 20 ++-- mocks/build-index/tagstore/store.go | 25 ++-- .../build-index/tagtype/dependencyresolver.go | 12 +- mocks/io/mock_closer.go | 48 ++++++++ mocks/lib/backend/gcsbackend/gcs.go | 28 ++--- .../lib/backend/hdfsbackend/webhdfs/client.go | 32 ++--- mocks/lib/backend/s3backend/s3.go | 24 ++-- .../lib/containerruntime/containerd/client.go | 12 +- .../dockerdaemon/dockerclient.go | 12 +- mocks/lib/containerruntime/factory.go | 16 +-- .../transfer/imagetransferer.go | 32 ++--- mocks/lib/hashring/ring.go | 24 ++-- mocks/lib/hashring/watcher.go | 12 +- mocks/lib/healthcheck/checker.go | 12 +- mocks/lib/healthcheck/filter.go | 12 +- mocks/lib/healthcheck/passivefilter.go | 16 +-- mocks/lib/hostlist/list.go | 12 +- mocks/lib/persistedretry/executor.go | 16 +-- mocks/lib/persistedretry/manager.go | 24 ++-- mocks/lib/persistedretry/store.go | 40 +++---- .../tagreplication/remotevalidator.go | 12 +- mocks/lib/persistedretry/task.go | 24 ++-- mocks/lib/store/filereadwriter.go | 44 +++---- .../torrent/scheduler/reloadablescheduler.go | 32 ++--- mocks/lib/torrent/scheduler/scheduler.go | 28 ++--- mocks/origin/blobclient/client.go | 110 +++++++++--------- mocks/origin/blobclient/clientresolver.go | 12 +- mocks/origin/blobclient/clusterclient.go | 70 ++++++----- mocks/origin/blobclient/clusterprovider.go | 12 +- mocks/origin/blobclient/provider.go | 12 +- mocks/tracker/announceclient/client.go | 65 ++++++++++- mocks/tracker/metainfoclient/client.go | 12 +- mocks/tracker/originstore/store.go | 12 +- mocks/tracker/peerstore/store.go | 20 ++-- mocks/utils/dedup/intervaltask.go | 12 +- mocks/utils/dedup/taskrunner.go | 12 +- mocks/utils/httputil/roundtripper.go | 12 +- 40 files changed, 585 insertions(+), 467 deletions(-) create mode 100644 mocks/io/mock_closer.go diff --git a/mocks/agent/agentclient/client.go b/mocks/agent/agentclient/client.go index 04b851fb2..a95e39c9d 100644 --- a/mocks/agent/agentclient/client.go +++ b/mocks/agent/agentclient/client.go @@ -12,30 +12,30 @@ import ( core "github.com/uber/kraken/core" ) -// MockClient is a mock of Client interface. +// MockClient is a mock of Client interface type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder } -// MockClientMockRecorder is the mock recorder for MockClient. +// MockClientMockRecorder is the mock recorder for MockClient type MockClientMockRecorder struct { mock *MockClient } -// NewMockClient creates a new mock instance. +// NewMockClient creates a new mock instance func NewMockClient(ctrl *gomock.Controller) *MockClient { mock := &MockClient{ctrl: ctrl} mock.recorder = &MockClientMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockClient) EXPECT() *MockClientMockRecorder { return m.recorder } -// Download mocks base method. +// Download mocks base method func (m *MockClient) Download(arg0 string, arg1 core.Digest) (io.ReadCloser, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Download", arg0, arg1) @@ -44,13 +44,13 @@ func (m *MockClient) Download(arg0 string, arg1 core.Digest) (io.ReadCloser, err return ret0, ret1 } -// Download indicates an expected call of Download. +// Download indicates an expected call of Download func (mr *MockClientMockRecorder) Download(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockClient)(nil).Download), arg0, arg1) } -// GetTag mocks base method. +// GetTag mocks base method func (m *MockClient) GetTag(arg0 string) (core.Digest, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTag", arg0) @@ -59,7 +59,7 @@ func (m *MockClient) GetTag(arg0 string) (core.Digest, error) { return ret0, ret1 } -// GetTag indicates an expected call of GetTag. +// GetTag indicates an expected call of GetTag func (mr *MockClientMockRecorder) GetTag(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTag", reflect.TypeOf((*MockClient)(nil).GetTag), arg0) diff --git a/mocks/build-index/tagclient/client.go b/mocks/build-index/tagclient/client.go index 7877fadd1..5443d6c3f 100644 --- a/mocks/build-index/tagclient/client.go +++ b/mocks/build-index/tagclient/client.go @@ -1,5 +1,10 @@ // Code generated by MockGen. DO NOT EDIT. // Source: github.com/uber/kraken/build-index/tagclient (interfaces: Client) +// +// Generated by this command: +// +// mockgen -package mocktagclient . Client +// // Package mocktagclient is a generated GoMock package. package mocktagclient @@ -18,6 +23,7 @@ import ( type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder + isgomock struct{} } // MockClientMockRecorder is the mock recorder for MockClient. @@ -52,121 +58,121 @@ func (mr *MockClientMockRecorder) CheckReadiness() *gomock.Call { } // DuplicatePut mocks base method. -func (m *MockClient) DuplicatePut(arg0 string, arg1 core.Digest, arg2 time.Duration) error { +func (m *MockClient) DuplicatePut(tag string, d core.Digest, delay time.Duration) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DuplicatePut", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "DuplicatePut", tag, d, delay) ret0, _ := ret[0].(error) return ret0 } // DuplicatePut indicates an expected call of DuplicatePut. -func (mr *MockClientMockRecorder) DuplicatePut(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) DuplicatePut(tag, d, delay interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DuplicatePut", reflect.TypeOf((*MockClient)(nil).DuplicatePut), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DuplicatePut", reflect.TypeOf((*MockClient)(nil).DuplicatePut), tag, d, delay) } // DuplicateReplicate mocks base method. -func (m *MockClient) DuplicateReplicate(arg0 string, arg1 core.Digest, arg2 core.DigestList, arg3 time.Duration) error { +func (m *MockClient) DuplicateReplicate(tag string, d core.Digest, dependencies core.DigestList, delay time.Duration) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DuplicateReplicate", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "DuplicateReplicate", tag, d, dependencies, delay) ret0, _ := ret[0].(error) return ret0 } // DuplicateReplicate indicates an expected call of DuplicateReplicate. -func (mr *MockClientMockRecorder) DuplicateReplicate(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) DuplicateReplicate(tag, d, dependencies, delay interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DuplicateReplicate", reflect.TypeOf((*MockClient)(nil).DuplicateReplicate), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DuplicateReplicate", reflect.TypeOf((*MockClient)(nil).DuplicateReplicate), tag, d, dependencies, delay) } // Get mocks base method. -func (m *MockClient) Get(arg0 string) (core.Digest, error) { +func (m *MockClient) Get(tag string) (core.Digest, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Get", arg0) + ret := m.ctrl.Call(m, "Get", tag) ret0, _ := ret[0].(core.Digest) ret1, _ := ret[1].(error) return ret0, ret1 } // Get indicates an expected call of Get. -func (mr *MockClientMockRecorder) Get(arg0 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) Get(tag interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClient)(nil).Get), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClient)(nil).Get), tag) } // Has mocks base method. -func (m *MockClient) Has(arg0 string) (bool, error) { +func (m *MockClient) Has(tag string) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Has", arg0) + ret := m.ctrl.Call(m, "Has", tag) ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } // Has indicates an expected call of Has. -func (mr *MockClientMockRecorder) Has(arg0 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) Has(tag interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Has", reflect.TypeOf((*MockClient)(nil).Has), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Has", reflect.TypeOf((*MockClient)(nil).Has), tag) } // List mocks base method. -func (m *MockClient) List(arg0 string) ([]string, error) { +func (m *MockClient) List(prefix string) ([]string, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "List", arg0) + ret := m.ctrl.Call(m, "List", prefix) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) return ret0, ret1 } // List indicates an expected call of List. -func (mr *MockClientMockRecorder) List(arg0 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) List(prefix interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockClient)(nil).List), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockClient)(nil).List), prefix) } // ListRepository mocks base method. -func (m *MockClient) ListRepository(arg0 string) ([]string, error) { +func (m *MockClient) ListRepository(repo string) ([]string, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListRepository", arg0) + ret := m.ctrl.Call(m, "ListRepository", repo) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) return ret0, ret1 } // ListRepository indicates an expected call of ListRepository. -func (mr *MockClientMockRecorder) ListRepository(arg0 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) ListRepository(repo interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRepository", reflect.TypeOf((*MockClient)(nil).ListRepository), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRepository", reflect.TypeOf((*MockClient)(nil).ListRepository), repo) } // ListRepositoryWithPagination mocks base method. -func (m *MockClient) ListRepositoryWithPagination(arg0 string, arg1 tagclient.ListFilter) (tagmodels.ListResponse, error) { +func (m *MockClient) ListRepositoryWithPagination(repo string, filter tagclient.ListFilter) (tagmodels.ListResponse, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListRepositoryWithPagination", arg0, arg1) + ret := m.ctrl.Call(m, "ListRepositoryWithPagination", repo, filter) ret0, _ := ret[0].(tagmodels.ListResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // ListRepositoryWithPagination indicates an expected call of ListRepositoryWithPagination. -func (mr *MockClientMockRecorder) ListRepositoryWithPagination(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) ListRepositoryWithPagination(repo, filter interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRepositoryWithPagination", reflect.TypeOf((*MockClient)(nil).ListRepositoryWithPagination), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRepositoryWithPagination", reflect.TypeOf((*MockClient)(nil).ListRepositoryWithPagination), repo, filter) } // ListWithPagination mocks base method. -func (m *MockClient) ListWithPagination(arg0 string, arg1 tagclient.ListFilter) (tagmodels.ListResponse, error) { +func (m *MockClient) ListWithPagination(prefix string, filter tagclient.ListFilter) (tagmodels.ListResponse, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListWithPagination", arg0, arg1) + ret := m.ctrl.Call(m, "ListWithPagination", prefix, filter) ret0, _ := ret[0].(tagmodels.ListResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // ListWithPagination indicates an expected call of ListWithPagination. -func (mr *MockClientMockRecorder) ListWithPagination(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) ListWithPagination(prefix, filter interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWithPagination", reflect.TypeOf((*MockClient)(nil).ListWithPagination), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWithPagination", reflect.TypeOf((*MockClient)(nil).ListWithPagination), prefix, filter) } // Origin mocks base method. @@ -185,43 +191,43 @@ func (mr *MockClientMockRecorder) Origin() *gomock.Call { } // Put mocks base method. -func (m *MockClient) Put(arg0 string, arg1 core.Digest) error { +func (m *MockClient) Put(tag string, d core.Digest) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Put", arg0, arg1) + ret := m.ctrl.Call(m, "Put", tag, d) ret0, _ := ret[0].(error) return ret0 } // Put indicates an expected call of Put. -func (mr *MockClientMockRecorder) Put(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) Put(tag, d interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockClient)(nil).Put), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockClient)(nil).Put), tag, d) } // PutAndReplicate mocks base method. -func (m *MockClient) PutAndReplicate(arg0 string, arg1 core.Digest) error { +func (m *MockClient) PutAndReplicate(tag string, d core.Digest) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PutAndReplicate", arg0, arg1) + ret := m.ctrl.Call(m, "PutAndReplicate", tag, d) ret0, _ := ret[0].(error) return ret0 } // PutAndReplicate indicates an expected call of PutAndReplicate. -func (mr *MockClientMockRecorder) PutAndReplicate(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) PutAndReplicate(tag, d interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAndReplicate", reflect.TypeOf((*MockClient)(nil).PutAndReplicate), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAndReplicate", reflect.TypeOf((*MockClient)(nil).PutAndReplicate), tag, d) } // Replicate mocks base method. -func (m *MockClient) Replicate(arg0 string) error { +func (m *MockClient) Replicate(tag string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Replicate", arg0) + ret := m.ctrl.Call(m, "Replicate", tag) ret0, _ := ret[0].(error) return ret0 } // Replicate indicates an expected call of Replicate. -func (mr *MockClientMockRecorder) Replicate(arg0 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) Replicate(tag interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Replicate", reflect.TypeOf((*MockClient)(nil).Replicate), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Replicate", reflect.TypeOf((*MockClient)(nil).Replicate), tag) } diff --git a/mocks/build-index/tagclient/provider.go b/mocks/build-index/tagclient/provider.go index e4f867422..08a6143ae 100644 --- a/mocks/build-index/tagclient/provider.go +++ b/mocks/build-index/tagclient/provider.go @@ -11,30 +11,30 @@ import ( tagclient "github.com/uber/kraken/build-index/tagclient" ) -// MockProvider is a mock of Provider interface. +// MockProvider is a mock of Provider interface type MockProvider struct { ctrl *gomock.Controller recorder *MockProviderMockRecorder } -// MockProviderMockRecorder is the mock recorder for MockProvider. +// MockProviderMockRecorder is the mock recorder for MockProvider type MockProviderMockRecorder struct { mock *MockProvider } -// NewMockProvider creates a new mock instance. +// NewMockProvider creates a new mock instance func NewMockProvider(ctrl *gomock.Controller) *MockProvider { mock := &MockProvider{ctrl: ctrl} mock.recorder = &MockProviderMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockProvider) EXPECT() *MockProviderMockRecorder { return m.recorder } -// Provide mocks base method. +// Provide mocks base method func (m *MockProvider) Provide(arg0 string) tagclient.Client { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Provide", arg0) @@ -42,7 +42,7 @@ func (m *MockProvider) Provide(arg0 string) tagclient.Client { return ret0 } -// Provide indicates an expected call of Provide. +// Provide indicates an expected call of Provide func (mr *MockProviderMockRecorder) Provide(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Provide", reflect.TypeOf((*MockProvider)(nil).Provide), arg0) diff --git a/mocks/build-index/tagstore/filestore.go b/mocks/build-index/tagstore/filestore.go index 038085b8b..032192b20 100644 --- a/mocks/build-index/tagstore/filestore.go +++ b/mocks/build-index/tagstore/filestore.go @@ -13,30 +13,30 @@ import ( metadata "github.com/uber/kraken/lib/store/metadata" ) -// MockFileStore is a mock of FileStore interface. +// MockFileStore is a mock of FileStore interface type MockFileStore struct { ctrl *gomock.Controller recorder *MockFileStoreMockRecorder } -// MockFileStoreMockRecorder is the mock recorder for MockFileStore. +// MockFileStoreMockRecorder is the mock recorder for MockFileStore type MockFileStoreMockRecorder struct { mock *MockFileStore } -// NewMockFileStore creates a new mock instance. +// NewMockFileStore creates a new mock instance func NewMockFileStore(ctrl *gomock.Controller) *MockFileStore { mock := &MockFileStore{ctrl: ctrl} mock.recorder = &MockFileStoreMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockFileStore) EXPECT() *MockFileStoreMockRecorder { return m.recorder } -// CreateCacheFile mocks base method. +// CreateCacheFile mocks base method func (m *MockFileStore) CreateCacheFile(arg0 string, arg1 io.Reader) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateCacheFile", arg0, arg1) @@ -44,13 +44,13 @@ func (m *MockFileStore) CreateCacheFile(arg0 string, arg1 io.Reader) error { return ret0 } -// CreateCacheFile indicates an expected call of CreateCacheFile. +// CreateCacheFile indicates an expected call of CreateCacheFile func (mr *MockFileStoreMockRecorder) CreateCacheFile(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheFile", reflect.TypeOf((*MockFileStore)(nil).CreateCacheFile), arg0, arg1) } -// GetCacheFileReader mocks base method. +// GetCacheFileReader mocks base method func (m *MockFileStore) GetCacheFileReader(arg0 string) (base.FileReader, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetCacheFileReader", arg0) @@ -59,13 +59,13 @@ func (m *MockFileStore) GetCacheFileReader(arg0 string) (base.FileReader, error) return ret0, ret1 } -// GetCacheFileReader indicates an expected call of GetCacheFileReader. +// GetCacheFileReader indicates an expected call of GetCacheFileReader func (mr *MockFileStoreMockRecorder) GetCacheFileReader(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCacheFileReader", reflect.TypeOf((*MockFileStore)(nil).GetCacheFileReader), arg0) } -// SetCacheFileMetadata mocks base method. +// SetCacheFileMetadata mocks base method func (m *MockFileStore) SetCacheFileMetadata(arg0 string, arg1 metadata.Metadata) (bool, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SetCacheFileMetadata", arg0, arg1) @@ -74,7 +74,7 @@ func (m *MockFileStore) SetCacheFileMetadata(arg0 string, arg1 metadata.Metadata return ret0, ret1 } -// SetCacheFileMetadata indicates an expected call of SetCacheFileMetadata. +// SetCacheFileMetadata indicates an expected call of SetCacheFileMetadata func (mr *MockFileStoreMockRecorder) SetCacheFileMetadata(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCacheFileMetadata", reflect.TypeOf((*MockFileStore)(nil).SetCacheFileMetadata), arg0, arg1) diff --git a/mocks/build-index/tagstore/store.go b/mocks/build-index/tagstore/store.go index 44ae486fa..2677cb90d 100644 --- a/mocks/build-index/tagstore/store.go +++ b/mocks/build-index/tagstore/store.go @@ -5,7 +5,6 @@ package mocktagstore import ( - context "context" reflect "reflect" time "time" @@ -13,30 +12,30 @@ import ( core "github.com/uber/kraken/core" ) -// MockStore is a mock of Store interface. +// MockStore is a mock of Store interface type MockStore struct { ctrl *gomock.Controller recorder *MockStoreMockRecorder } -// MockStoreMockRecorder is the mock recorder for MockStore. +// MockStoreMockRecorder is the mock recorder for MockStore type MockStoreMockRecorder struct { mock *MockStore } -// NewMockStore creates a new mock instance. +// NewMockStore creates a new mock instance func NewMockStore(ctrl *gomock.Controller) *MockStore { mock := &MockStore{ctrl: ctrl} mock.recorder = &MockStoreMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockStore) EXPECT() *MockStoreMockRecorder { return m.recorder } -// Get mocks base method. +// Get mocks base method func (m *MockStore) Get(arg0 string) (core.Digest, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Get", arg0) @@ -45,22 +44,22 @@ func (m *MockStore) Get(arg0 string) (core.Digest, error) { return ret0, ret1 } -// Get indicates an expected call of Get. +// Get indicates an expected call of Get func (mr *MockStoreMockRecorder) Get(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockStore)(nil).Get), arg0) } -// Put mocks base method. -func (m *MockStore) Put(arg0 context.Context, arg1 string, arg2 core.Digest, arg3 time.Duration) error { +// Put mocks base method +func (m *MockStore) Put(arg0 string, arg1 core.Digest, arg2 time.Duration) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2) ret0, _ := ret[0].(error) return ret0 } -// Put indicates an expected call of Put. -func (mr *MockStoreMockRecorder) Put(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +// Put indicates an expected call of Put +func (mr *MockStoreMockRecorder) Put(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockStore)(nil).Put), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockStore)(nil).Put), arg0, arg1, arg2) } diff --git a/mocks/build-index/tagtype/dependencyresolver.go b/mocks/build-index/tagtype/dependencyresolver.go index 753400ffb..d58e417d9 100644 --- a/mocks/build-index/tagtype/dependencyresolver.go +++ b/mocks/build-index/tagtype/dependencyresolver.go @@ -11,30 +11,30 @@ import ( core "github.com/uber/kraken/core" ) -// MockDependencyResolver is a mock of DependencyResolver interface. +// MockDependencyResolver is a mock of DependencyResolver interface type MockDependencyResolver struct { ctrl *gomock.Controller recorder *MockDependencyResolverMockRecorder } -// MockDependencyResolverMockRecorder is the mock recorder for MockDependencyResolver. +// MockDependencyResolverMockRecorder is the mock recorder for MockDependencyResolver type MockDependencyResolverMockRecorder struct { mock *MockDependencyResolver } -// NewMockDependencyResolver creates a new mock instance. +// NewMockDependencyResolver creates a new mock instance func NewMockDependencyResolver(ctrl *gomock.Controller) *MockDependencyResolver { mock := &MockDependencyResolver{ctrl: ctrl} mock.recorder = &MockDependencyResolverMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockDependencyResolver) EXPECT() *MockDependencyResolverMockRecorder { return m.recorder } -// Resolve mocks base method. +// Resolve mocks base method func (m *MockDependencyResolver) Resolve(arg0 string, arg1 core.Digest) (core.DigestList, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Resolve", arg0, arg1) @@ -43,7 +43,7 @@ func (m *MockDependencyResolver) Resolve(arg0 string, arg1 core.Digest) (core.Di return ret0, ret1 } -// Resolve indicates an expected call of Resolve. +// Resolve indicates an expected call of Resolve func (mr *MockDependencyResolverMockRecorder) Resolve(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resolve", reflect.TypeOf((*MockDependencyResolver)(nil).Resolve), arg0, arg1) diff --git a/mocks/io/mock_closer.go b/mocks/io/mock_closer.go new file mode 100644 index 000000000..cadd4819a --- /dev/null +++ b/mocks/io/mock_closer.go @@ -0,0 +1,48 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: io (interfaces: Closer) + +// Package mock_io is a generated GoMock package. +package mock_io + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" +) + +// MockCloser is a mock of Closer interface. +type MockCloser struct { + ctrl *gomock.Controller + recorder *MockCloserMockRecorder +} + +// MockCloserMockRecorder is the mock recorder for MockCloser. +type MockCloserMockRecorder struct { + mock *MockCloser +} + +// NewMockCloser creates a new mock instance. +func NewMockCloser(ctrl *gomock.Controller) *MockCloser { + mock := &MockCloser{ctrl: ctrl} + mock.recorder = &MockCloserMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockCloser) EXPECT() *MockCloserMockRecorder { + return m.recorder +} + +// Close mocks base method. +func (m *MockCloser) Close() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) + return ret0 +} + +// Close indicates an expected call of Close. +func (mr *MockCloserMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockCloser)(nil).Close)) +} diff --git a/mocks/lib/backend/gcsbackend/gcs.go b/mocks/lib/backend/gcsbackend/gcs.go index 74f4d1883..856586570 100644 --- a/mocks/lib/backend/gcsbackend/gcs.go +++ b/mocks/lib/backend/gcsbackend/gcs.go @@ -13,30 +13,30 @@ import ( iterator "google.golang.org/api/iterator" ) -// MockGCS is a mock of GCS interface. +// MockGCS is a mock of GCS interface type MockGCS struct { ctrl *gomock.Controller recorder *MockGCSMockRecorder } -// MockGCSMockRecorder is the mock recorder for MockGCS. +// MockGCSMockRecorder is the mock recorder for MockGCS type MockGCSMockRecorder struct { mock *MockGCS } -// NewMockGCS creates a new mock instance. +// NewMockGCS creates a new mock instance func NewMockGCS(ctrl *gomock.Controller) *MockGCS { mock := &MockGCS{ctrl: ctrl} mock.recorder = &MockGCSMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockGCS) EXPECT() *MockGCSMockRecorder { return m.recorder } -// Download mocks base method. +// Download mocks base method func (m *MockGCS) Download(arg0 string, arg1 io.Writer) (int64, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Download", arg0, arg1) @@ -45,13 +45,13 @@ func (m *MockGCS) Download(arg0 string, arg1 io.Writer) (int64, error) { return ret0, ret1 } -// Download indicates an expected call of Download. +// Download indicates an expected call of Download func (mr *MockGCSMockRecorder) Download(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockGCS)(nil).Download), arg0, arg1) } -// GetObjectIterator mocks base method. +// GetObjectIterator mocks base method func (m *MockGCS) GetObjectIterator(arg0 string) iterator.Pageable { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetObjectIterator", arg0) @@ -59,13 +59,13 @@ func (m *MockGCS) GetObjectIterator(arg0 string) iterator.Pageable { return ret0 } -// GetObjectIterator indicates an expected call of GetObjectIterator. +// GetObjectIterator indicates an expected call of GetObjectIterator func (mr *MockGCSMockRecorder) GetObjectIterator(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectIterator", reflect.TypeOf((*MockGCS)(nil).GetObjectIterator), arg0) } -// NextPage mocks base method. +// NextPage mocks base method func (m *MockGCS) NextPage(arg0 *iterator.Pager) ([]string, string, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "NextPage", arg0) @@ -75,13 +75,13 @@ func (m *MockGCS) NextPage(arg0 *iterator.Pager) ([]string, string, error) { return ret0, ret1, ret2 } -// NextPage indicates an expected call of NextPage. +// NextPage indicates an expected call of NextPage func (mr *MockGCSMockRecorder) NextPage(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NextPage", reflect.TypeOf((*MockGCS)(nil).NextPage), arg0) } -// ObjectAttrs mocks base method. +// ObjectAttrs mocks base method func (m *MockGCS) ObjectAttrs(arg0 string) (*storage.ObjectAttrs, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ObjectAttrs", arg0) @@ -90,13 +90,13 @@ func (m *MockGCS) ObjectAttrs(arg0 string) (*storage.ObjectAttrs, error) { return ret0, ret1 } -// ObjectAttrs indicates an expected call of ObjectAttrs. +// ObjectAttrs indicates an expected call of ObjectAttrs func (mr *MockGCSMockRecorder) ObjectAttrs(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectAttrs", reflect.TypeOf((*MockGCS)(nil).ObjectAttrs), arg0) } -// Upload mocks base method. +// Upload mocks base method func (m *MockGCS) Upload(arg0 string, arg1 io.Reader) (int64, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Upload", arg0, arg1) @@ -105,7 +105,7 @@ func (m *MockGCS) Upload(arg0 string, arg1 io.Reader) (int64, error) { return ret0, ret1 } -// Upload indicates an expected call of Upload. +// Upload indicates an expected call of Upload func (mr *MockGCSMockRecorder) Upload(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upload", reflect.TypeOf((*MockGCS)(nil).Upload), arg0, arg1) diff --git a/mocks/lib/backend/hdfsbackend/webhdfs/client.go b/mocks/lib/backend/hdfsbackend/webhdfs/client.go index 672b5c159..3e6612981 100644 --- a/mocks/lib/backend/hdfsbackend/webhdfs/client.go +++ b/mocks/lib/backend/hdfsbackend/webhdfs/client.go @@ -12,30 +12,30 @@ import ( webhdfs "github.com/uber/kraken/lib/backend/hdfsbackend/webhdfs" ) -// MockClient is a mock of Client interface. +// MockClient is a mock of Client interface type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder } -// MockClientMockRecorder is the mock recorder for MockClient. +// MockClientMockRecorder is the mock recorder for MockClient type MockClientMockRecorder struct { mock *MockClient } -// NewMockClient creates a new mock instance. +// NewMockClient creates a new mock instance func NewMockClient(ctrl *gomock.Controller) *MockClient { mock := &MockClient{ctrl: ctrl} mock.recorder = &MockClientMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockClient) EXPECT() *MockClientMockRecorder { return m.recorder } -// Create mocks base method. +// Create mocks base method func (m *MockClient) Create(arg0 string, arg1 io.Reader) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Create", arg0, arg1) @@ -43,13 +43,13 @@ func (m *MockClient) Create(arg0 string, arg1 io.Reader) error { return ret0 } -// Create indicates an expected call of Create. +// Create indicates an expected call of Create func (mr *MockClientMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockClient)(nil).Create), arg0, arg1) } -// GetFileStatus mocks base method. +// GetFileStatus mocks base method func (m *MockClient) GetFileStatus(arg0 string) (webhdfs.FileStatus, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetFileStatus", arg0) @@ -58,13 +58,13 @@ func (m *MockClient) GetFileStatus(arg0 string) (webhdfs.FileStatus, error) { return ret0, ret1 } -// GetFileStatus indicates an expected call of GetFileStatus. +// GetFileStatus indicates an expected call of GetFileStatus func (mr *MockClientMockRecorder) GetFileStatus(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFileStatus", reflect.TypeOf((*MockClient)(nil).GetFileStatus), arg0) } -// ListFileStatus mocks base method. +// ListFileStatus mocks base method func (m *MockClient) ListFileStatus(arg0 string) ([]webhdfs.FileStatus, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListFileStatus", arg0) @@ -73,13 +73,13 @@ func (m *MockClient) ListFileStatus(arg0 string) ([]webhdfs.FileStatus, error) { return ret0, ret1 } -// ListFileStatus indicates an expected call of ListFileStatus. +// ListFileStatus indicates an expected call of ListFileStatus func (mr *MockClientMockRecorder) ListFileStatus(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFileStatus", reflect.TypeOf((*MockClient)(nil).ListFileStatus), arg0) } -// Mkdirs mocks base method. +// Mkdirs mocks base method func (m *MockClient) Mkdirs(arg0 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Mkdirs", arg0) @@ -87,13 +87,13 @@ func (m *MockClient) Mkdirs(arg0 string) error { return ret0 } -// Mkdirs indicates an expected call of Mkdirs. +// Mkdirs indicates an expected call of Mkdirs func (mr *MockClientMockRecorder) Mkdirs(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Mkdirs", reflect.TypeOf((*MockClient)(nil).Mkdirs), arg0) } -// Open mocks base method. +// Open mocks base method func (m *MockClient) Open(arg0 string, arg1 io.Writer) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Open", arg0, arg1) @@ -101,13 +101,13 @@ func (m *MockClient) Open(arg0 string, arg1 io.Writer) error { return ret0 } -// Open indicates an expected call of Open. +// Open indicates an expected call of Open func (mr *MockClientMockRecorder) Open(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockClient)(nil).Open), arg0, arg1) } -// Rename mocks base method. +// Rename mocks base method func (m *MockClient) Rename(arg0, arg1 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Rename", arg0, arg1) @@ -115,7 +115,7 @@ func (m *MockClient) Rename(arg0, arg1 string) error { return ret0 } -// Rename indicates an expected call of Rename. +// Rename indicates an expected call of Rename func (mr *MockClientMockRecorder) Rename(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockClient)(nil).Rename), arg0, arg1) diff --git a/mocks/lib/backend/s3backend/s3.go b/mocks/lib/backend/s3backend/s3.go index 5e9592c51..f37de7652 100644 --- a/mocks/lib/backend/s3backend/s3.go +++ b/mocks/lib/backend/s3backend/s3.go @@ -13,30 +13,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockS3 is a mock of S3 interface. +// MockS3 is a mock of S3 interface type MockS3 struct { ctrl *gomock.Controller recorder *MockS3MockRecorder } -// MockS3MockRecorder is the mock recorder for MockS3. +// MockS3MockRecorder is the mock recorder for MockS3 type MockS3MockRecorder struct { mock *MockS3 } -// NewMockS3 creates a new mock instance. +// NewMockS3 creates a new mock instance func NewMockS3(ctrl *gomock.Controller) *MockS3 { mock := &MockS3{ctrl: ctrl} mock.recorder = &MockS3MockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockS3) EXPECT() *MockS3MockRecorder { return m.recorder } -// Download mocks base method. +// Download mocks base method func (m *MockS3) Download(arg0 io.WriterAt, arg1 *s3.GetObjectInput, arg2 ...func(*s3manager.Downloader)) (int64, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} @@ -49,14 +49,14 @@ func (m *MockS3) Download(arg0 io.WriterAt, arg1 *s3.GetObjectInput, arg2 ...fun return ret0, ret1 } -// Download indicates an expected call of Download. +// Download indicates an expected call of Download func (mr *MockS3MockRecorder) Download(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockS3)(nil).Download), varargs...) } -// HeadObject mocks base method. +// HeadObject mocks base method func (m *MockS3) HeadObject(arg0 *s3.HeadObjectInput) (*s3.HeadObjectOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "HeadObject", arg0) @@ -65,13 +65,13 @@ func (m *MockS3) HeadObject(arg0 *s3.HeadObjectInput) (*s3.HeadObjectOutput, err return ret0, ret1 } -// HeadObject indicates an expected call of HeadObject. +// HeadObject indicates an expected call of HeadObject func (mr *MockS3MockRecorder) HeadObject(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadObject", reflect.TypeOf((*MockS3)(nil).HeadObject), arg0) } -// ListObjectsV2Pages mocks base method. +// ListObjectsV2Pages mocks base method func (m *MockS3) ListObjectsV2Pages(arg0 *s3.ListObjectsV2Input, arg1 func(*s3.ListObjectsV2Output, bool) bool) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListObjectsV2Pages", arg0, arg1) @@ -79,13 +79,13 @@ func (m *MockS3) ListObjectsV2Pages(arg0 *s3.ListObjectsV2Input, arg1 func(*s3.L return ret0 } -// ListObjectsV2Pages indicates an expected call of ListObjectsV2Pages. +// ListObjectsV2Pages indicates an expected call of ListObjectsV2Pages func (mr *MockS3MockRecorder) ListObjectsV2Pages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2Pages", reflect.TypeOf((*MockS3)(nil).ListObjectsV2Pages), arg0, arg1) } -// Upload mocks base method. +// Upload mocks base method func (m *MockS3) Upload(arg0 *s3manager.UploadInput, arg1 ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0} @@ -98,7 +98,7 @@ func (m *MockS3) Upload(arg0 *s3manager.UploadInput, arg1 ...func(*s3manager.Upl return ret0, ret1 } -// Upload indicates an expected call of Upload. +// Upload indicates an expected call of Upload func (mr *MockS3MockRecorder) Upload(arg0 interface{}, arg1 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0}, arg1...) diff --git a/mocks/lib/containerruntime/containerd/client.go b/mocks/lib/containerruntime/containerd/client.go index bbbdc0489..9507fde6d 100644 --- a/mocks/lib/containerruntime/containerd/client.go +++ b/mocks/lib/containerruntime/containerd/client.go @@ -11,30 +11,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockClient is a mock of Client interface. +// MockClient is a mock of Client interface type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder } -// MockClientMockRecorder is the mock recorder for MockClient. +// MockClientMockRecorder is the mock recorder for MockClient type MockClientMockRecorder struct { mock *MockClient } -// NewMockClient creates a new mock instance. +// NewMockClient creates a new mock instance func NewMockClient(ctrl *gomock.Controller) *MockClient { mock := &MockClient{ctrl: ctrl} mock.recorder = &MockClientMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockClient) EXPECT() *MockClientMockRecorder { return m.recorder } -// PullImage mocks base method. +// PullImage mocks base method func (m *MockClient) PullImage(arg0 context.Context, arg1, arg2, arg3 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PullImage", arg0, arg1, arg2, arg3) @@ -42,7 +42,7 @@ func (m *MockClient) PullImage(arg0 context.Context, arg1, arg2, arg3 string) er return ret0 } -// PullImage indicates an expected call of PullImage. +// PullImage indicates an expected call of PullImage func (mr *MockClientMockRecorder) PullImage(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullImage", reflect.TypeOf((*MockClient)(nil).PullImage), arg0, arg1, arg2, arg3) diff --git a/mocks/lib/containerruntime/dockerdaemon/dockerclient.go b/mocks/lib/containerruntime/dockerdaemon/dockerclient.go index f3ae596dc..d270571f1 100644 --- a/mocks/lib/containerruntime/dockerdaemon/dockerclient.go +++ b/mocks/lib/containerruntime/dockerdaemon/dockerclient.go @@ -11,30 +11,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockDockerClient is a mock of DockerClient interface. +// MockDockerClient is a mock of DockerClient interface type MockDockerClient struct { ctrl *gomock.Controller recorder *MockDockerClientMockRecorder } -// MockDockerClientMockRecorder is the mock recorder for MockDockerClient. +// MockDockerClientMockRecorder is the mock recorder for MockDockerClient type MockDockerClientMockRecorder struct { mock *MockDockerClient } -// NewMockDockerClient creates a new mock instance. +// NewMockDockerClient creates a new mock instance func NewMockDockerClient(ctrl *gomock.Controller) *MockDockerClient { mock := &MockDockerClient{ctrl: ctrl} mock.recorder = &MockDockerClientMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockDockerClient) EXPECT() *MockDockerClientMockRecorder { return m.recorder } -// PullImage mocks base method. +// PullImage mocks base method func (m *MockDockerClient) PullImage(arg0 context.Context, arg1, arg2 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PullImage", arg0, arg1, arg2) @@ -42,7 +42,7 @@ func (m *MockDockerClient) PullImage(arg0 context.Context, arg1, arg2 string) er return ret0 } -// PullImage indicates an expected call of PullImage. +// PullImage indicates an expected call of PullImage func (mr *MockDockerClientMockRecorder) PullImage(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullImage", reflect.TypeOf((*MockDockerClient)(nil).PullImage), arg0, arg1, arg2) diff --git a/mocks/lib/containerruntime/factory.go b/mocks/lib/containerruntime/factory.go index 65b6447c8..9031eb42f 100644 --- a/mocks/lib/containerruntime/factory.go +++ b/mocks/lib/containerruntime/factory.go @@ -12,30 +12,30 @@ import ( dockerdaemon "github.com/uber/kraken/lib/containerruntime/dockerdaemon" ) -// MockFactory is a mock of Factory interface. +// MockFactory is a mock of Factory interface type MockFactory struct { ctrl *gomock.Controller recorder *MockFactoryMockRecorder } -// MockFactoryMockRecorder is the mock recorder for MockFactory. +// MockFactoryMockRecorder is the mock recorder for MockFactory type MockFactoryMockRecorder struct { mock *MockFactory } -// NewMockFactory creates a new mock instance. +// NewMockFactory creates a new mock instance func NewMockFactory(ctrl *gomock.Controller) *MockFactory { mock := &MockFactory{ctrl: ctrl} mock.recorder = &MockFactoryMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockFactory) EXPECT() *MockFactoryMockRecorder { return m.recorder } -// ContainerdClient mocks base method. +// ContainerdClient mocks base method func (m *MockFactory) ContainerdClient() containerd.Client { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ContainerdClient") @@ -43,13 +43,13 @@ func (m *MockFactory) ContainerdClient() containerd.Client { return ret0 } -// ContainerdClient indicates an expected call of ContainerdClient. +// ContainerdClient indicates an expected call of ContainerdClient func (mr *MockFactoryMockRecorder) ContainerdClient() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerdClient", reflect.TypeOf((*MockFactory)(nil).ContainerdClient)) } -// DockerClient mocks base method. +// DockerClient mocks base method func (m *MockFactory) DockerClient() dockerdaemon.DockerClient { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DockerClient") @@ -57,7 +57,7 @@ func (m *MockFactory) DockerClient() dockerdaemon.DockerClient { return ret0 } -// DockerClient indicates an expected call of DockerClient. +// DockerClient indicates an expected call of DockerClient func (mr *MockFactoryMockRecorder) DockerClient() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DockerClient", reflect.TypeOf((*MockFactory)(nil).DockerClient)) diff --git a/mocks/lib/dockerregistry/transfer/imagetransferer.go b/mocks/lib/dockerregistry/transfer/imagetransferer.go index 56a8c3ede..c1760fd53 100644 --- a/mocks/lib/dockerregistry/transfer/imagetransferer.go +++ b/mocks/lib/dockerregistry/transfer/imagetransferer.go @@ -12,30 +12,30 @@ import ( base "github.com/uber/kraken/lib/store/base" ) -// MockImageTransferer is a mock of ImageTransferer interface. +// MockImageTransferer is a mock of ImageTransferer interface type MockImageTransferer struct { ctrl *gomock.Controller recorder *MockImageTransfererMockRecorder } -// MockImageTransfererMockRecorder is the mock recorder for MockImageTransferer. +// MockImageTransfererMockRecorder is the mock recorder for MockImageTransferer type MockImageTransfererMockRecorder struct { mock *MockImageTransferer } -// NewMockImageTransferer creates a new mock instance. +// NewMockImageTransferer creates a new mock instance func NewMockImageTransferer(ctrl *gomock.Controller) *MockImageTransferer { mock := &MockImageTransferer{ctrl: ctrl} mock.recorder = &MockImageTransfererMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockImageTransferer) EXPECT() *MockImageTransfererMockRecorder { return m.recorder } -// Download mocks base method. +// Download mocks base method func (m *MockImageTransferer) Download(arg0 string, arg1 core.Digest) (base.FileReader, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Download", arg0, arg1) @@ -44,13 +44,13 @@ func (m *MockImageTransferer) Download(arg0 string, arg1 core.Digest) (base.File return ret0, ret1 } -// Download indicates an expected call of Download. +// Download indicates an expected call of Download func (mr *MockImageTransfererMockRecorder) Download(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockImageTransferer)(nil).Download), arg0, arg1) } -// GetTag mocks base method. +// GetTag mocks base method func (m *MockImageTransferer) GetTag(arg0 string) (core.Digest, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTag", arg0) @@ -59,13 +59,13 @@ func (m *MockImageTransferer) GetTag(arg0 string) (core.Digest, error) { return ret0, ret1 } -// GetTag indicates an expected call of GetTag. +// GetTag indicates an expected call of GetTag func (mr *MockImageTransfererMockRecorder) GetTag(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTag", reflect.TypeOf((*MockImageTransferer)(nil).GetTag), arg0) } -// ListTags mocks base method. +// ListTags mocks base method func (m *MockImageTransferer) ListTags(arg0 string) ([]string, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTags", arg0) @@ -74,13 +74,13 @@ func (m *MockImageTransferer) ListTags(arg0 string) ([]string, error) { return ret0, ret1 } -// ListTags indicates an expected call of ListTags. +// ListTags indicates an expected call of ListTags func (mr *MockImageTransfererMockRecorder) ListTags(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTags", reflect.TypeOf((*MockImageTransferer)(nil).ListTags), arg0) } -// PutTag mocks base method. +// PutTag mocks base method func (m *MockImageTransferer) PutTag(arg0 string, arg1 core.Digest) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PutTag", arg0, arg1) @@ -88,13 +88,13 @@ func (m *MockImageTransferer) PutTag(arg0 string, arg1 core.Digest) error { return ret0 } -// PutTag indicates an expected call of PutTag. +// PutTag indicates an expected call of PutTag func (mr *MockImageTransfererMockRecorder) PutTag(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutTag", reflect.TypeOf((*MockImageTransferer)(nil).PutTag), arg0, arg1) } -// Stat mocks base method. +// Stat mocks base method func (m *MockImageTransferer) Stat(arg0 string, arg1 core.Digest) (*core.BlobInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Stat", arg0, arg1) @@ -103,13 +103,13 @@ func (m *MockImageTransferer) Stat(arg0 string, arg1 core.Digest) (*core.BlobInf return ret0, ret1 } -// Stat indicates an expected call of Stat. +// Stat indicates an expected call of Stat func (mr *MockImageTransfererMockRecorder) Stat(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockImageTransferer)(nil).Stat), arg0, arg1) } -// Upload mocks base method. +// Upload mocks base method func (m *MockImageTransferer) Upload(arg0 string, arg1 core.Digest, arg2 base.FileReader) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Upload", arg0, arg1, arg2) @@ -117,7 +117,7 @@ func (m *MockImageTransferer) Upload(arg0 string, arg1 core.Digest, arg2 base.Fi return ret0 } -// Upload indicates an expected call of Upload. +// Upload indicates an expected call of Upload func (mr *MockImageTransfererMockRecorder) Upload(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upload", reflect.TypeOf((*MockImageTransferer)(nil).Upload), arg0, arg1, arg2) diff --git a/mocks/lib/hashring/ring.go b/mocks/lib/hashring/ring.go index a42574abe..06381d6b1 100644 --- a/mocks/lib/hashring/ring.go +++ b/mocks/lib/hashring/ring.go @@ -11,30 +11,30 @@ import ( core "github.com/uber/kraken/core" ) -// MockRing is a mock of Ring interface. +// MockRing is a mock of Ring interface type MockRing struct { ctrl *gomock.Controller recorder *MockRingMockRecorder } -// MockRingMockRecorder is the mock recorder for MockRing. +// MockRingMockRecorder is the mock recorder for MockRing type MockRingMockRecorder struct { mock *MockRing } -// NewMockRing creates a new mock instance. +// NewMockRing creates a new mock instance func NewMockRing(ctrl *gomock.Controller) *MockRing { mock := &MockRing{ctrl: ctrl} mock.recorder = &MockRingMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockRing) EXPECT() *MockRingMockRecorder { return m.recorder } -// Contains mocks base method. +// Contains mocks base method func (m *MockRing) Contains(arg0 string) bool { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Contains", arg0) @@ -42,13 +42,13 @@ func (m *MockRing) Contains(arg0 string) bool { return ret0 } -// Contains indicates an expected call of Contains. +// Contains indicates an expected call of Contains func (mr *MockRingMockRecorder) Contains(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Contains", reflect.TypeOf((*MockRing)(nil).Contains), arg0) } -// Locations mocks base method. +// Locations mocks base method func (m *MockRing) Locations(arg0 core.Digest) []string { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Locations", arg0) @@ -56,31 +56,31 @@ func (m *MockRing) Locations(arg0 core.Digest) []string { return ret0 } -// Locations indicates an expected call of Locations. +// Locations indicates an expected call of Locations func (mr *MockRingMockRecorder) Locations(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Locations", reflect.TypeOf((*MockRing)(nil).Locations), arg0) } -// Monitor mocks base method. +// Monitor mocks base method func (m *MockRing) Monitor(arg0 <-chan struct{}) { m.ctrl.T.Helper() m.ctrl.Call(m, "Monitor", arg0) } -// Monitor indicates an expected call of Monitor. +// Monitor indicates an expected call of Monitor func (mr *MockRingMockRecorder) Monitor(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Monitor", reflect.TypeOf((*MockRing)(nil).Monitor), arg0) } -// Refresh mocks base method. +// Refresh mocks base method func (m *MockRing) Refresh() { m.ctrl.T.Helper() m.ctrl.Call(m, "Refresh") } -// Refresh indicates an expected call of Refresh. +// Refresh indicates an expected call of Refresh func (mr *MockRingMockRecorder) Refresh() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Refresh", reflect.TypeOf((*MockRing)(nil).Refresh)) diff --git a/mocks/lib/hashring/watcher.go b/mocks/lib/hashring/watcher.go index 035b069b6..6c37c889b 100644 --- a/mocks/lib/hashring/watcher.go +++ b/mocks/lib/hashring/watcher.go @@ -11,36 +11,36 @@ import ( stringset "github.com/uber/kraken/utils/stringset" ) -// MockWatcher is a mock of Watcher interface. +// MockWatcher is a mock of Watcher interface type MockWatcher struct { ctrl *gomock.Controller recorder *MockWatcherMockRecorder } -// MockWatcherMockRecorder is the mock recorder for MockWatcher. +// MockWatcherMockRecorder is the mock recorder for MockWatcher type MockWatcherMockRecorder struct { mock *MockWatcher } -// NewMockWatcher creates a new mock instance. +// NewMockWatcher creates a new mock instance func NewMockWatcher(ctrl *gomock.Controller) *MockWatcher { mock := &MockWatcher{ctrl: ctrl} mock.recorder = &MockWatcherMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockWatcher) EXPECT() *MockWatcherMockRecorder { return m.recorder } -// Notify mocks base method. +// Notify mocks base method func (m *MockWatcher) Notify(arg0 stringset.Set) { m.ctrl.T.Helper() m.ctrl.Call(m, "Notify", arg0) } -// Notify indicates an expected call of Notify. +// Notify indicates an expected call of Notify func (mr *MockWatcherMockRecorder) Notify(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Notify", reflect.TypeOf((*MockWatcher)(nil).Notify), arg0) diff --git a/mocks/lib/healthcheck/checker.go b/mocks/lib/healthcheck/checker.go index f8d7a5512..3e83cafff 100644 --- a/mocks/lib/healthcheck/checker.go +++ b/mocks/lib/healthcheck/checker.go @@ -11,30 +11,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockChecker is a mock of Checker interface. +// MockChecker is a mock of Checker interface type MockChecker struct { ctrl *gomock.Controller recorder *MockCheckerMockRecorder } -// MockCheckerMockRecorder is the mock recorder for MockChecker. +// MockCheckerMockRecorder is the mock recorder for MockChecker type MockCheckerMockRecorder struct { mock *MockChecker } -// NewMockChecker creates a new mock instance. +// NewMockChecker creates a new mock instance func NewMockChecker(ctrl *gomock.Controller) *MockChecker { mock := &MockChecker{ctrl: ctrl} mock.recorder = &MockCheckerMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockChecker) EXPECT() *MockCheckerMockRecorder { return m.recorder } -// Check mocks base method. +// Check mocks base method func (m *MockChecker) Check(arg0 context.Context, arg1 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Check", arg0, arg1) @@ -42,7 +42,7 @@ func (m *MockChecker) Check(arg0 context.Context, arg1 string) error { return ret0 } -// Check indicates an expected call of Check. +// Check indicates an expected call of Check func (mr *MockCheckerMockRecorder) Check(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Check", reflect.TypeOf((*MockChecker)(nil).Check), arg0, arg1) diff --git a/mocks/lib/healthcheck/filter.go b/mocks/lib/healthcheck/filter.go index b89be1a78..14e2045cb 100644 --- a/mocks/lib/healthcheck/filter.go +++ b/mocks/lib/healthcheck/filter.go @@ -11,30 +11,30 @@ import ( stringset "github.com/uber/kraken/utils/stringset" ) -// MockFilter is a mock of Filter interface. +// MockFilter is a mock of Filter interface type MockFilter struct { ctrl *gomock.Controller recorder *MockFilterMockRecorder } -// MockFilterMockRecorder is the mock recorder for MockFilter. +// MockFilterMockRecorder is the mock recorder for MockFilter type MockFilterMockRecorder struct { mock *MockFilter } -// NewMockFilter creates a new mock instance. +// NewMockFilter creates a new mock instance func NewMockFilter(ctrl *gomock.Controller) *MockFilter { mock := &MockFilter{ctrl: ctrl} mock.recorder = &MockFilterMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockFilter) EXPECT() *MockFilterMockRecorder { return m.recorder } -// Run mocks base method. +// Run mocks base method func (m *MockFilter) Run(arg0 stringset.Set) stringset.Set { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Run", arg0) @@ -42,7 +42,7 @@ func (m *MockFilter) Run(arg0 stringset.Set) stringset.Set { return ret0 } -// Run indicates an expected call of Run. +// Run indicates an expected call of Run func (mr *MockFilterMockRecorder) Run(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockFilter)(nil).Run), arg0) diff --git a/mocks/lib/healthcheck/passivefilter.go b/mocks/lib/healthcheck/passivefilter.go index e295582fb..5eba0605f 100644 --- a/mocks/lib/healthcheck/passivefilter.go +++ b/mocks/lib/healthcheck/passivefilter.go @@ -11,42 +11,42 @@ import ( stringset "github.com/uber/kraken/utils/stringset" ) -// MockPassiveFilter is a mock of PassiveFilter interface. +// MockPassiveFilter is a mock of PassiveFilter interface type MockPassiveFilter struct { ctrl *gomock.Controller recorder *MockPassiveFilterMockRecorder } -// MockPassiveFilterMockRecorder is the mock recorder for MockPassiveFilter. +// MockPassiveFilterMockRecorder is the mock recorder for MockPassiveFilter type MockPassiveFilterMockRecorder struct { mock *MockPassiveFilter } -// NewMockPassiveFilter creates a new mock instance. +// NewMockPassiveFilter creates a new mock instance func NewMockPassiveFilter(ctrl *gomock.Controller) *MockPassiveFilter { mock := &MockPassiveFilter{ctrl: ctrl} mock.recorder = &MockPassiveFilterMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockPassiveFilter) EXPECT() *MockPassiveFilterMockRecorder { return m.recorder } -// Failed mocks base method. +// Failed mocks base method func (m *MockPassiveFilter) Failed(arg0 string) { m.ctrl.T.Helper() m.ctrl.Call(m, "Failed", arg0) } -// Failed indicates an expected call of Failed. +// Failed indicates an expected call of Failed func (mr *MockPassiveFilterMockRecorder) Failed(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Failed", reflect.TypeOf((*MockPassiveFilter)(nil).Failed), arg0) } -// Run mocks base method. +// Run mocks base method func (m *MockPassiveFilter) Run(arg0 stringset.Set) stringset.Set { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Run", arg0) @@ -54,7 +54,7 @@ func (m *MockPassiveFilter) Run(arg0 stringset.Set) stringset.Set { return ret0 } -// Run indicates an expected call of Run. +// Run indicates an expected call of Run func (mr *MockPassiveFilterMockRecorder) Run(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockPassiveFilter)(nil).Run), arg0) diff --git a/mocks/lib/hostlist/list.go b/mocks/lib/hostlist/list.go index 9340edf98..da492f9d9 100644 --- a/mocks/lib/hostlist/list.go +++ b/mocks/lib/hostlist/list.go @@ -11,30 +11,30 @@ import ( stringset "github.com/uber/kraken/utils/stringset" ) -// MockList is a mock of List interface. +// MockList is a mock of List interface type MockList struct { ctrl *gomock.Controller recorder *MockListMockRecorder } -// MockListMockRecorder is the mock recorder for MockList. +// MockListMockRecorder is the mock recorder for MockList type MockListMockRecorder struct { mock *MockList } -// NewMockList creates a new mock instance. +// NewMockList creates a new mock instance func NewMockList(ctrl *gomock.Controller) *MockList { mock := &MockList{ctrl: ctrl} mock.recorder = &MockListMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockList) EXPECT() *MockListMockRecorder { return m.recorder } -// Resolve mocks base method. +// Resolve mocks base method func (m *MockList) Resolve() stringset.Set { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Resolve") @@ -42,7 +42,7 @@ func (m *MockList) Resolve() stringset.Set { return ret0 } -// Resolve indicates an expected call of Resolve. +// Resolve indicates an expected call of Resolve func (mr *MockListMockRecorder) Resolve() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resolve", reflect.TypeOf((*MockList)(nil).Resolve)) diff --git a/mocks/lib/persistedretry/executor.go b/mocks/lib/persistedretry/executor.go index 05b4ecaf2..0b24f6a53 100644 --- a/mocks/lib/persistedretry/executor.go +++ b/mocks/lib/persistedretry/executor.go @@ -11,30 +11,30 @@ import ( persistedretry "github.com/uber/kraken/lib/persistedretry" ) -// MockExecutor is a mock of Executor interface. +// MockExecutor is a mock of Executor interface type MockExecutor struct { ctrl *gomock.Controller recorder *MockExecutorMockRecorder } -// MockExecutorMockRecorder is the mock recorder for MockExecutor. +// MockExecutorMockRecorder is the mock recorder for MockExecutor type MockExecutorMockRecorder struct { mock *MockExecutor } -// NewMockExecutor creates a new mock instance. +// NewMockExecutor creates a new mock instance func NewMockExecutor(ctrl *gomock.Controller) *MockExecutor { mock := &MockExecutor{ctrl: ctrl} mock.recorder = &MockExecutorMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockExecutor) EXPECT() *MockExecutorMockRecorder { return m.recorder } -// Exec mocks base method. +// Exec mocks base method func (m *MockExecutor) Exec(arg0 persistedretry.Task) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Exec", arg0) @@ -42,13 +42,13 @@ func (m *MockExecutor) Exec(arg0 persistedretry.Task) error { return ret0 } -// Exec indicates an expected call of Exec. +// Exec indicates an expected call of Exec func (mr *MockExecutorMockRecorder) Exec(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockExecutor)(nil).Exec), arg0) } -// Name mocks base method. +// Name mocks base method func (m *MockExecutor) Name() string { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Name") @@ -56,7 +56,7 @@ func (m *MockExecutor) Name() string { return ret0 } -// Name indicates an expected call of Name. +// Name indicates an expected call of Name func (mr *MockExecutorMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockExecutor)(nil).Name)) diff --git a/mocks/lib/persistedretry/manager.go b/mocks/lib/persistedretry/manager.go index bf30f07f4..0a023ad8a 100644 --- a/mocks/lib/persistedretry/manager.go +++ b/mocks/lib/persistedretry/manager.go @@ -11,30 +11,30 @@ import ( persistedretry "github.com/uber/kraken/lib/persistedretry" ) -// MockManager is a mock of Manager interface. +// MockManager is a mock of Manager interface type MockManager struct { ctrl *gomock.Controller recorder *MockManagerMockRecorder } -// MockManagerMockRecorder is the mock recorder for MockManager. +// MockManagerMockRecorder is the mock recorder for MockManager type MockManagerMockRecorder struct { mock *MockManager } -// NewMockManager creates a new mock instance. +// NewMockManager creates a new mock instance func NewMockManager(ctrl *gomock.Controller) *MockManager { mock := &MockManager{ctrl: ctrl} mock.recorder = &MockManagerMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockManager) EXPECT() *MockManagerMockRecorder { return m.recorder } -// Add mocks base method. +// Add mocks base method func (m *MockManager) Add(arg0 persistedretry.Task) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Add", arg0) @@ -42,25 +42,25 @@ func (m *MockManager) Add(arg0 persistedretry.Task) error { return ret0 } -// Add indicates an expected call of Add. +// Add indicates an expected call of Add func (mr *MockManagerMockRecorder) Add(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockManager)(nil).Add), arg0) } -// Close mocks base method. +// Close mocks base method func (m *MockManager) Close() { m.ctrl.T.Helper() m.ctrl.Call(m, "Close") } -// Close indicates an expected call of Close. +// Close indicates an expected call of Close func (mr *MockManagerMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockManager)(nil).Close)) } -// Find mocks base method. +// Find mocks base method func (m *MockManager) Find(arg0 interface{}) ([]persistedretry.Task, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0) @@ -69,13 +69,13 @@ func (m *MockManager) Find(arg0 interface{}) ([]persistedretry.Task, error) { return ret0, ret1 } -// Find indicates an expected call of Find. +// Find indicates an expected call of Find func (mr *MockManagerMockRecorder) Find(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockManager)(nil).Find), arg0) } -// SyncExec mocks base method. +// SyncExec mocks base method func (m *MockManager) SyncExec(arg0 persistedretry.Task) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SyncExec", arg0) @@ -83,7 +83,7 @@ func (m *MockManager) SyncExec(arg0 persistedretry.Task) error { return ret0 } -// SyncExec indicates an expected call of SyncExec. +// SyncExec indicates an expected call of SyncExec func (mr *MockManagerMockRecorder) SyncExec(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncExec", reflect.TypeOf((*MockManager)(nil).SyncExec), arg0) diff --git a/mocks/lib/persistedretry/store.go b/mocks/lib/persistedretry/store.go index e5d8c8cff..f40679fd3 100644 --- a/mocks/lib/persistedretry/store.go +++ b/mocks/lib/persistedretry/store.go @@ -11,30 +11,30 @@ import ( persistedretry "github.com/uber/kraken/lib/persistedretry" ) -// MockStore is a mock of Store interface. +// MockStore is a mock of Store interface type MockStore struct { ctrl *gomock.Controller recorder *MockStoreMockRecorder } -// MockStoreMockRecorder is the mock recorder for MockStore. +// MockStoreMockRecorder is the mock recorder for MockStore type MockStoreMockRecorder struct { mock *MockStore } -// NewMockStore creates a new mock instance. +// NewMockStore creates a new mock instance func NewMockStore(ctrl *gomock.Controller) *MockStore { mock := &MockStore{ctrl: ctrl} mock.recorder = &MockStoreMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockStore) EXPECT() *MockStoreMockRecorder { return m.recorder } -// AddFailed mocks base method. +// AddFailed mocks base method func (m *MockStore) AddFailed(arg0 persistedretry.Task) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddFailed", arg0) @@ -42,13 +42,13 @@ func (m *MockStore) AddFailed(arg0 persistedretry.Task) error { return ret0 } -// AddFailed indicates an expected call of AddFailed. +// AddFailed indicates an expected call of AddFailed func (mr *MockStoreMockRecorder) AddFailed(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddFailed", reflect.TypeOf((*MockStore)(nil).AddFailed), arg0) } -// AddPending mocks base method. +// AddPending mocks base method func (m *MockStore) AddPending(arg0 persistedretry.Task) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddPending", arg0) @@ -56,13 +56,13 @@ func (m *MockStore) AddPending(arg0 persistedretry.Task) error { return ret0 } -// AddPending indicates an expected call of AddPending. +// AddPending indicates an expected call of AddPending func (mr *MockStoreMockRecorder) AddPending(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPending", reflect.TypeOf((*MockStore)(nil).AddPending), arg0) } -// Find mocks base method. +// Find mocks base method func (m *MockStore) Find(arg0 interface{}) ([]persistedretry.Task, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Find", arg0) @@ -71,13 +71,13 @@ func (m *MockStore) Find(arg0 interface{}) ([]persistedretry.Task, error) { return ret0, ret1 } -// Find indicates an expected call of Find. +// Find indicates an expected call of Find func (mr *MockStoreMockRecorder) Find(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockStore)(nil).Find), arg0) } -// GetFailed mocks base method. +// GetFailed mocks base method func (m *MockStore) GetFailed() ([]persistedretry.Task, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetFailed") @@ -86,13 +86,13 @@ func (m *MockStore) GetFailed() ([]persistedretry.Task, error) { return ret0, ret1 } -// GetFailed indicates an expected call of GetFailed. +// GetFailed indicates an expected call of GetFailed func (mr *MockStoreMockRecorder) GetFailed() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFailed", reflect.TypeOf((*MockStore)(nil).GetFailed)) } -// GetPending mocks base method. +// GetPending mocks base method func (m *MockStore) GetPending() ([]persistedretry.Task, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetPending") @@ -101,13 +101,13 @@ func (m *MockStore) GetPending() ([]persistedretry.Task, error) { return ret0, ret1 } -// GetPending indicates an expected call of GetPending. +// GetPending indicates an expected call of GetPending func (mr *MockStoreMockRecorder) GetPending() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPending", reflect.TypeOf((*MockStore)(nil).GetPending)) } -// MarkFailed mocks base method. +// MarkFailed mocks base method func (m *MockStore) MarkFailed(arg0 persistedretry.Task) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "MarkFailed", arg0) @@ -115,13 +115,13 @@ func (m *MockStore) MarkFailed(arg0 persistedretry.Task) error { return ret0 } -// MarkFailed indicates an expected call of MarkFailed. +// MarkFailed indicates an expected call of MarkFailed func (mr *MockStoreMockRecorder) MarkFailed(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkFailed", reflect.TypeOf((*MockStore)(nil).MarkFailed), arg0) } -// MarkPending mocks base method. +// MarkPending mocks base method func (m *MockStore) MarkPending(arg0 persistedretry.Task) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "MarkPending", arg0) @@ -129,13 +129,13 @@ func (m *MockStore) MarkPending(arg0 persistedretry.Task) error { return ret0 } -// MarkPending indicates an expected call of MarkPending. +// MarkPending indicates an expected call of MarkPending func (mr *MockStoreMockRecorder) MarkPending(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkPending", reflect.TypeOf((*MockStore)(nil).MarkPending), arg0) } -// Remove mocks base method. +// Remove mocks base method func (m *MockStore) Remove(arg0 persistedretry.Task) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Remove", arg0) @@ -143,7 +143,7 @@ func (m *MockStore) Remove(arg0 persistedretry.Task) error { return ret0 } -// Remove indicates an expected call of Remove. +// Remove indicates an expected call of Remove func (mr *MockStoreMockRecorder) Remove(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockStore)(nil).Remove), arg0) diff --git a/mocks/lib/persistedretry/tagreplication/remotevalidator.go b/mocks/lib/persistedretry/tagreplication/remotevalidator.go index c029835e8..4fa26be9d 100644 --- a/mocks/lib/persistedretry/tagreplication/remotevalidator.go +++ b/mocks/lib/persistedretry/tagreplication/remotevalidator.go @@ -10,30 +10,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockRemoteValidator is a mock of RemoteValidator interface. +// MockRemoteValidator is a mock of RemoteValidator interface type MockRemoteValidator struct { ctrl *gomock.Controller recorder *MockRemoteValidatorMockRecorder } -// MockRemoteValidatorMockRecorder is the mock recorder for MockRemoteValidator. +// MockRemoteValidatorMockRecorder is the mock recorder for MockRemoteValidator type MockRemoteValidatorMockRecorder struct { mock *MockRemoteValidator } -// NewMockRemoteValidator creates a new mock instance. +// NewMockRemoteValidator creates a new mock instance func NewMockRemoteValidator(ctrl *gomock.Controller) *MockRemoteValidator { mock := &MockRemoteValidator{ctrl: ctrl} mock.recorder = &MockRemoteValidatorMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockRemoteValidator) EXPECT() *MockRemoteValidatorMockRecorder { return m.recorder } -// Valid mocks base method. +// Valid mocks base method func (m *MockRemoteValidator) Valid(arg0, arg1 string) bool { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Valid", arg0, arg1) @@ -41,7 +41,7 @@ func (m *MockRemoteValidator) Valid(arg0, arg1 string) bool { return ret0 } -// Valid indicates an expected call of Valid. +// Valid indicates an expected call of Valid func (mr *MockRemoteValidatorMockRecorder) Valid(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Valid", reflect.TypeOf((*MockRemoteValidator)(nil).Valid), arg0, arg1) diff --git a/mocks/lib/persistedretry/task.go b/mocks/lib/persistedretry/task.go index 41589df0f..bb9dec4d8 100644 --- a/mocks/lib/persistedretry/task.go +++ b/mocks/lib/persistedretry/task.go @@ -11,30 +11,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockTask is a mock of Task interface. +// MockTask is a mock of Task interface type MockTask struct { ctrl *gomock.Controller recorder *MockTaskMockRecorder } -// MockTaskMockRecorder is the mock recorder for MockTask. +// MockTaskMockRecorder is the mock recorder for MockTask type MockTaskMockRecorder struct { mock *MockTask } -// NewMockTask creates a new mock instance. +// NewMockTask creates a new mock instance func NewMockTask(ctrl *gomock.Controller) *MockTask { mock := &MockTask{ctrl: ctrl} mock.recorder = &MockTaskMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockTask) EXPECT() *MockTaskMockRecorder { return m.recorder } -// GetFailures mocks base method. +// GetFailures mocks base method func (m *MockTask) GetFailures() int { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetFailures") @@ -42,13 +42,13 @@ func (m *MockTask) GetFailures() int { return ret0 } -// GetFailures indicates an expected call of GetFailures. +// GetFailures indicates an expected call of GetFailures func (mr *MockTaskMockRecorder) GetFailures() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFailures", reflect.TypeOf((*MockTask)(nil).GetFailures)) } -// GetLastAttempt mocks base method. +// GetLastAttempt mocks base method func (m *MockTask) GetLastAttempt() time.Time { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetLastAttempt") @@ -56,13 +56,13 @@ func (m *MockTask) GetLastAttempt() time.Time { return ret0 } -// GetLastAttempt indicates an expected call of GetLastAttempt. +// GetLastAttempt indicates an expected call of GetLastAttempt func (mr *MockTaskMockRecorder) GetLastAttempt() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastAttempt", reflect.TypeOf((*MockTask)(nil).GetLastAttempt)) } -// Ready mocks base method. +// Ready mocks base method func (m *MockTask) Ready() bool { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Ready") @@ -70,13 +70,13 @@ func (m *MockTask) Ready() bool { return ret0 } -// Ready indicates an expected call of Ready. +// Ready indicates an expected call of Ready func (mr *MockTaskMockRecorder) Ready() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ready", reflect.TypeOf((*MockTask)(nil).Ready)) } -// Tags mocks base method. +// Tags mocks base method func (m *MockTask) Tags() map[string]string { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Tags") @@ -84,7 +84,7 @@ func (m *MockTask) Tags() map[string]string { return ret0 } -// Tags indicates an expected call of Tags. +// Tags indicates an expected call of Tags func (mr *MockTaskMockRecorder) Tags() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tags", reflect.TypeOf((*MockTask)(nil).Tags)) diff --git a/mocks/lib/store/filereadwriter.go b/mocks/lib/store/filereadwriter.go index 4b9d99e09..7ae49bede 100644 --- a/mocks/lib/store/filereadwriter.go +++ b/mocks/lib/store/filereadwriter.go @@ -10,30 +10,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockFileReadWriter is a mock of FileReadWriter interface. +// MockFileReadWriter is a mock of FileReadWriter interface type MockFileReadWriter struct { ctrl *gomock.Controller recorder *MockFileReadWriterMockRecorder } -// MockFileReadWriterMockRecorder is the mock recorder for MockFileReadWriter. +// MockFileReadWriterMockRecorder is the mock recorder for MockFileReadWriter type MockFileReadWriterMockRecorder struct { mock *MockFileReadWriter } -// NewMockFileReadWriter creates a new mock instance. +// NewMockFileReadWriter creates a new mock instance func NewMockFileReadWriter(ctrl *gomock.Controller) *MockFileReadWriter { mock := &MockFileReadWriter{ctrl: ctrl} mock.recorder = &MockFileReadWriterMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockFileReadWriter) EXPECT() *MockFileReadWriterMockRecorder { return m.recorder } -// Cancel mocks base method. +// Cancel mocks base method func (m *MockFileReadWriter) Cancel() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Cancel") @@ -41,13 +41,13 @@ func (m *MockFileReadWriter) Cancel() error { return ret0 } -// Cancel indicates an expected call of Cancel. +// Cancel indicates an expected call of Cancel func (mr *MockFileReadWriterMockRecorder) Cancel() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cancel", reflect.TypeOf((*MockFileReadWriter)(nil).Cancel)) } -// Close mocks base method. +// Close mocks base method func (m *MockFileReadWriter) Close() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Close") @@ -55,13 +55,13 @@ func (m *MockFileReadWriter) Close() error { return ret0 } -// Close indicates an expected call of Close. +// Close indicates an expected call of Close func (mr *MockFileReadWriterMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockFileReadWriter)(nil).Close)) } -// Commit mocks base method. +// Commit mocks base method func (m *MockFileReadWriter) Commit() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Commit") @@ -69,13 +69,13 @@ func (m *MockFileReadWriter) Commit() error { return ret0 } -// Commit indicates an expected call of Commit. +// Commit indicates an expected call of Commit func (mr *MockFileReadWriterMockRecorder) Commit() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockFileReadWriter)(nil).Commit)) } -// Read mocks base method. +// Read mocks base method func (m *MockFileReadWriter) Read(arg0 []byte) (int, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Read", arg0) @@ -84,13 +84,13 @@ func (m *MockFileReadWriter) Read(arg0 []byte) (int, error) { return ret0, ret1 } -// Read indicates an expected call of Read. +// Read indicates an expected call of Read func (mr *MockFileReadWriterMockRecorder) Read(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockFileReadWriter)(nil).Read), arg0) } -// ReadAt mocks base method. +// ReadAt mocks base method func (m *MockFileReadWriter) ReadAt(arg0 []byte, arg1 int64) (int, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ReadAt", arg0, arg1) @@ -99,13 +99,13 @@ func (m *MockFileReadWriter) ReadAt(arg0 []byte, arg1 int64) (int, error) { return ret0, ret1 } -// ReadAt indicates an expected call of ReadAt. +// ReadAt indicates an expected call of ReadAt func (mr *MockFileReadWriterMockRecorder) ReadAt(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadAt", reflect.TypeOf((*MockFileReadWriter)(nil).ReadAt), arg0, arg1) } -// Seek mocks base method. +// Seek mocks base method func (m *MockFileReadWriter) Seek(arg0 int64, arg1 int) (int64, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Seek", arg0, arg1) @@ -114,13 +114,13 @@ func (m *MockFileReadWriter) Seek(arg0 int64, arg1 int) (int64, error) { return ret0, ret1 } -// Seek indicates an expected call of Seek. +// Seek indicates an expected call of Seek func (mr *MockFileReadWriterMockRecorder) Seek(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seek", reflect.TypeOf((*MockFileReadWriter)(nil).Seek), arg0, arg1) } -// Size mocks base method. +// Size mocks base method func (m *MockFileReadWriter) Size() int64 { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Size") @@ -128,13 +128,13 @@ func (m *MockFileReadWriter) Size() int64 { return ret0 } -// Size indicates an expected call of Size. +// Size indicates an expected call of Size func (mr *MockFileReadWriterMockRecorder) Size() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Size", reflect.TypeOf((*MockFileReadWriter)(nil).Size)) } -// Write mocks base method. +// Write mocks base method func (m *MockFileReadWriter) Write(arg0 []byte) (int, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Write", arg0) @@ -143,13 +143,13 @@ func (m *MockFileReadWriter) Write(arg0 []byte) (int, error) { return ret0, ret1 } -// Write indicates an expected call of Write. +// Write indicates an expected call of Write func (mr *MockFileReadWriterMockRecorder) Write(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockFileReadWriter)(nil).Write), arg0) } -// WriteAt mocks base method. +// WriteAt mocks base method func (m *MockFileReadWriter) WriteAt(arg0 []byte, arg1 int64) (int, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "WriteAt", arg0, arg1) @@ -158,7 +158,7 @@ func (m *MockFileReadWriter) WriteAt(arg0 []byte, arg1 int64) (int, error) { return ret0, ret1 } -// WriteAt indicates an expected call of WriteAt. +// WriteAt indicates an expected call of WriteAt func (mr *MockFileReadWriterMockRecorder) WriteAt(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteAt", reflect.TypeOf((*MockFileReadWriter)(nil).WriteAt), arg0, arg1) diff --git a/mocks/lib/torrent/scheduler/reloadablescheduler.go b/mocks/lib/torrent/scheduler/reloadablescheduler.go index a8d5318b7..6da074ce4 100644 --- a/mocks/lib/torrent/scheduler/reloadablescheduler.go +++ b/mocks/lib/torrent/scheduler/reloadablescheduler.go @@ -13,30 +13,30 @@ import ( connstate "github.com/uber/kraken/lib/torrent/scheduler/connstate" ) -// MockReloadableScheduler is a mock of ReloadableScheduler interface. +// MockReloadableScheduler is a mock of ReloadableScheduler interface type MockReloadableScheduler struct { ctrl *gomock.Controller recorder *MockReloadableSchedulerMockRecorder } -// MockReloadableSchedulerMockRecorder is the mock recorder for MockReloadableScheduler. +// MockReloadableSchedulerMockRecorder is the mock recorder for MockReloadableScheduler type MockReloadableSchedulerMockRecorder struct { mock *MockReloadableScheduler } -// NewMockReloadableScheduler creates a new mock instance. +// NewMockReloadableScheduler creates a new mock instance func NewMockReloadableScheduler(ctrl *gomock.Controller) *MockReloadableScheduler { mock := &MockReloadableScheduler{ctrl: ctrl} mock.recorder = &MockReloadableSchedulerMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockReloadableScheduler) EXPECT() *MockReloadableSchedulerMockRecorder { return m.recorder } -// BlacklistSnapshot mocks base method. +// BlacklistSnapshot mocks base method func (m *MockReloadableScheduler) BlacklistSnapshot() ([]connstate.BlacklistedConn, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "BlacklistSnapshot") @@ -45,13 +45,13 @@ func (m *MockReloadableScheduler) BlacklistSnapshot() ([]connstate.BlacklistedCo return ret0, ret1 } -// BlacklistSnapshot indicates an expected call of BlacklistSnapshot. +// BlacklistSnapshot indicates an expected call of BlacklistSnapshot func (mr *MockReloadableSchedulerMockRecorder) BlacklistSnapshot() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlacklistSnapshot", reflect.TypeOf((*MockReloadableScheduler)(nil).BlacklistSnapshot)) } -// Download mocks base method. +// Download mocks base method func (m *MockReloadableScheduler) Download(arg0 string, arg1 core.Digest) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Download", arg0, arg1) @@ -59,13 +59,13 @@ func (m *MockReloadableScheduler) Download(arg0 string, arg1 core.Digest) error return ret0 } -// Download indicates an expected call of Download. +// Download indicates an expected call of Download func (mr *MockReloadableSchedulerMockRecorder) Download(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockReloadableScheduler)(nil).Download), arg0, arg1) } -// Probe mocks base method. +// Probe mocks base method func (m *MockReloadableScheduler) Probe() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Probe") @@ -73,25 +73,25 @@ func (m *MockReloadableScheduler) Probe() error { return ret0 } -// Probe indicates an expected call of Probe. +// Probe indicates an expected call of Probe func (mr *MockReloadableSchedulerMockRecorder) Probe() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Probe", reflect.TypeOf((*MockReloadableScheduler)(nil).Probe)) } -// Reload mocks base method. +// Reload mocks base method func (m *MockReloadableScheduler) Reload(arg0 scheduler.Config) { m.ctrl.T.Helper() m.ctrl.Call(m, "Reload", arg0) } -// Reload indicates an expected call of Reload. +// Reload indicates an expected call of Reload func (mr *MockReloadableSchedulerMockRecorder) Reload(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reload", reflect.TypeOf((*MockReloadableScheduler)(nil).Reload), arg0) } -// RemoveTorrent mocks base method. +// RemoveTorrent mocks base method func (m *MockReloadableScheduler) RemoveTorrent(arg0 core.Digest) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveTorrent", arg0) @@ -99,19 +99,19 @@ func (m *MockReloadableScheduler) RemoveTorrent(arg0 core.Digest) error { return ret0 } -// RemoveTorrent indicates an expected call of RemoveTorrent. +// RemoveTorrent indicates an expected call of RemoveTorrent func (mr *MockReloadableSchedulerMockRecorder) RemoveTorrent(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTorrent", reflect.TypeOf((*MockReloadableScheduler)(nil).RemoveTorrent), arg0) } -// Stop mocks base method. +// Stop mocks base method func (m *MockReloadableScheduler) Stop() { m.ctrl.T.Helper() m.ctrl.Call(m, "Stop") } -// Stop indicates an expected call of Stop. +// Stop indicates an expected call of Stop func (mr *MockReloadableSchedulerMockRecorder) Stop() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockReloadableScheduler)(nil).Stop)) diff --git a/mocks/lib/torrent/scheduler/scheduler.go b/mocks/lib/torrent/scheduler/scheduler.go index 5ff9e1da8..0a99befe6 100644 --- a/mocks/lib/torrent/scheduler/scheduler.go +++ b/mocks/lib/torrent/scheduler/scheduler.go @@ -12,30 +12,30 @@ import ( connstate "github.com/uber/kraken/lib/torrent/scheduler/connstate" ) -// MockScheduler is a mock of Scheduler interface. +// MockScheduler is a mock of Scheduler interface type MockScheduler struct { ctrl *gomock.Controller recorder *MockSchedulerMockRecorder } -// MockSchedulerMockRecorder is the mock recorder for MockScheduler. +// MockSchedulerMockRecorder is the mock recorder for MockScheduler type MockSchedulerMockRecorder struct { mock *MockScheduler } -// NewMockScheduler creates a new mock instance. +// NewMockScheduler creates a new mock instance func NewMockScheduler(ctrl *gomock.Controller) *MockScheduler { mock := &MockScheduler{ctrl: ctrl} mock.recorder = &MockSchedulerMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockScheduler) EXPECT() *MockSchedulerMockRecorder { return m.recorder } -// BlacklistSnapshot mocks base method. +// BlacklistSnapshot mocks base method func (m *MockScheduler) BlacklistSnapshot() ([]connstate.BlacklistedConn, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "BlacklistSnapshot") @@ -44,13 +44,13 @@ func (m *MockScheduler) BlacklistSnapshot() ([]connstate.BlacklistedConn, error) return ret0, ret1 } -// BlacklistSnapshot indicates an expected call of BlacklistSnapshot. +// BlacklistSnapshot indicates an expected call of BlacklistSnapshot func (mr *MockSchedulerMockRecorder) BlacklistSnapshot() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlacklistSnapshot", reflect.TypeOf((*MockScheduler)(nil).BlacklistSnapshot)) } -// Download mocks base method. +// Download mocks base method func (m *MockScheduler) Download(arg0 string, arg1 core.Digest) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Download", arg0, arg1) @@ -58,13 +58,13 @@ func (m *MockScheduler) Download(arg0 string, arg1 core.Digest) error { return ret0 } -// Download indicates an expected call of Download. +// Download indicates an expected call of Download func (mr *MockSchedulerMockRecorder) Download(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockScheduler)(nil).Download), arg0, arg1) } -// Probe mocks base method. +// Probe mocks base method func (m *MockScheduler) Probe() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Probe") @@ -72,13 +72,13 @@ func (m *MockScheduler) Probe() error { return ret0 } -// Probe indicates an expected call of Probe. +// Probe indicates an expected call of Probe func (mr *MockSchedulerMockRecorder) Probe() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Probe", reflect.TypeOf((*MockScheduler)(nil).Probe)) } -// RemoveTorrent mocks base method. +// RemoveTorrent mocks base method func (m *MockScheduler) RemoveTorrent(arg0 core.Digest) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveTorrent", arg0) @@ -86,19 +86,19 @@ func (m *MockScheduler) RemoveTorrent(arg0 core.Digest) error { return ret0 } -// RemoveTorrent indicates an expected call of RemoveTorrent. +// RemoveTorrent indicates an expected call of RemoveTorrent func (mr *MockSchedulerMockRecorder) RemoveTorrent(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTorrent", reflect.TypeOf((*MockScheduler)(nil).RemoveTorrent), arg0) } -// Stop mocks base method. +// Stop mocks base method func (m *MockScheduler) Stop() { m.ctrl.T.Helper() m.ctrl.Call(m, "Stop") } -// Stop indicates an expected call of Stop. +// Stop indicates an expected call of Stop func (mr *MockSchedulerMockRecorder) Stop() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockScheduler)(nil).Stop)) diff --git a/mocks/origin/blobclient/client.go b/mocks/origin/blobclient/client.go index 813f3b2a7..8ef989f9e 100644 --- a/mocks/origin/blobclient/client.go +++ b/mocks/origin/blobclient/client.go @@ -1,5 +1,10 @@ // Code generated by MockGen. DO NOT EDIT. // Source: github.com/uber/kraken/origin/blobclient (interfaces: Client) +// +// Generated by this command: +// +// mockgen -package mockblobclient . Client +// // Package mockblobclient is a generated GoMock package. package mockblobclient @@ -17,6 +22,7 @@ import ( type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder + isgomock struct{} } // MockClientMockRecorder is the mock recorder for MockClient. @@ -65,74 +71,74 @@ func (mr *MockClientMockRecorder) CheckReadiness() *gomock.Call { } // DeleteBlob mocks base method. -func (m *MockClient) DeleteBlob(arg0 core.Digest) error { +func (m *MockClient) DeleteBlob(d core.Digest) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteBlob", arg0) + ret := m.ctrl.Call(m, "DeleteBlob", d) ret0, _ := ret[0].(error) return ret0 } // DeleteBlob indicates an expected call of DeleteBlob. -func (mr *MockClientMockRecorder) DeleteBlob(arg0 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) DeleteBlob(d any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBlob", reflect.TypeOf((*MockClient)(nil).DeleteBlob), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBlob", reflect.TypeOf((*MockClient)(nil).DeleteBlob), d) } // DownloadBlob mocks base method. -func (m *MockClient) DownloadBlob(arg0 string, arg1 core.Digest, arg2 io.Writer) error { +func (m *MockClient) DownloadBlob(namespace string, d core.Digest, dst io.Writer) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DownloadBlob", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "DownloadBlob", namespace, d, dst) ret0, _ := ret[0].(error) return ret0 } // DownloadBlob indicates an expected call of DownloadBlob. -func (mr *MockClientMockRecorder) DownloadBlob(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) DownloadBlob(namespace, d, dst any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadBlob", reflect.TypeOf((*MockClient)(nil).DownloadBlob), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadBlob", reflect.TypeOf((*MockClient)(nil).DownloadBlob), namespace, d, dst) } // DuplicateUploadBlob mocks base method. -func (m *MockClient) DuplicateUploadBlob(arg0 string, arg1 core.Digest, arg2 io.Reader, arg3 time.Duration) error { +func (m *MockClient) DuplicateUploadBlob(namespace string, d core.Digest, blob io.Reader, delay time.Duration) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DuplicateUploadBlob", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "DuplicateUploadBlob", namespace, d, blob, delay) ret0, _ := ret[0].(error) return ret0 } // DuplicateUploadBlob indicates an expected call of DuplicateUploadBlob. -func (mr *MockClientMockRecorder) DuplicateUploadBlob(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) DuplicateUploadBlob(namespace, d, blob, delay any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DuplicateUploadBlob", reflect.TypeOf((*MockClient)(nil).DuplicateUploadBlob), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DuplicateUploadBlob", reflect.TypeOf((*MockClient)(nil).DuplicateUploadBlob), namespace, d, blob, delay) } // ForceCleanup mocks base method. -func (m *MockClient) ForceCleanup(arg0 time.Duration) error { +func (m *MockClient) ForceCleanup(ttl time.Duration) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ForceCleanup", arg0) + ret := m.ctrl.Call(m, "ForceCleanup", ttl) ret0, _ := ret[0].(error) return ret0 } // ForceCleanup indicates an expected call of ForceCleanup. -func (mr *MockClientMockRecorder) ForceCleanup(arg0 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) ForceCleanup(ttl any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceCleanup", reflect.TypeOf((*MockClient)(nil).ForceCleanup), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceCleanup", reflect.TypeOf((*MockClient)(nil).ForceCleanup), ttl) } // GetMetaInfo mocks base method. -func (m *MockClient) GetMetaInfo(arg0 string, arg1 core.Digest) (*core.MetaInfo, error) { +func (m *MockClient) GetMetaInfo(namespace string, d core.Digest) (*core.MetaInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMetaInfo", arg0, arg1) + ret := m.ctrl.Call(m, "GetMetaInfo", namespace, d) ret0, _ := ret[0].(*core.MetaInfo) ret1, _ := ret[1].(error) return ret0, ret1 } // GetMetaInfo indicates an expected call of GetMetaInfo. -func (mr *MockClientMockRecorder) GetMetaInfo(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) GetMetaInfo(namespace, d any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetaInfo", reflect.TypeOf((*MockClient)(nil).GetMetaInfo), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetaInfo", reflect.TypeOf((*MockClient)(nil).GetMetaInfo), namespace, d) } // GetPeerContext mocks base method. @@ -151,116 +157,116 @@ func (mr *MockClientMockRecorder) GetPeerContext() *gomock.Call { } // Locations mocks base method. -func (m *MockClient) Locations(arg0 core.Digest) ([]string, error) { +func (m *MockClient) Locations(d core.Digest) ([]string, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Locations", arg0) + ret := m.ctrl.Call(m, "Locations", d) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) return ret0, ret1 } // Locations indicates an expected call of Locations. -func (mr *MockClientMockRecorder) Locations(arg0 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) Locations(d any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Locations", reflect.TypeOf((*MockClient)(nil).Locations), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Locations", reflect.TypeOf((*MockClient)(nil).Locations), d) } // OverwriteMetaInfo mocks base method. -func (m *MockClient) OverwriteMetaInfo(arg0 core.Digest, arg1 int64) error { +func (m *MockClient) OverwriteMetaInfo(d core.Digest, pieceLength int64) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "OverwriteMetaInfo", arg0, arg1) + ret := m.ctrl.Call(m, "OverwriteMetaInfo", d, pieceLength) ret0, _ := ret[0].(error) return ret0 } // OverwriteMetaInfo indicates an expected call of OverwriteMetaInfo. -func (mr *MockClientMockRecorder) OverwriteMetaInfo(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) OverwriteMetaInfo(d, pieceLength any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OverwriteMetaInfo", reflect.TypeOf((*MockClient)(nil).OverwriteMetaInfo), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OverwriteMetaInfo", reflect.TypeOf((*MockClient)(nil).OverwriteMetaInfo), d, pieceLength) } // PrefetchBlob mocks base method. -func (m *MockClient) PrefetchBlob(arg0 string, arg1 core.Digest) error { +func (m *MockClient) PrefetchBlob(namespace string, d core.Digest) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PrefetchBlob", arg0, arg1) + ret := m.ctrl.Call(m, "PrefetchBlob", namespace, d) ret0, _ := ret[0].(error) return ret0 } // PrefetchBlob indicates an expected call of PrefetchBlob. -func (mr *MockClientMockRecorder) PrefetchBlob(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) PrefetchBlob(namespace, d any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrefetchBlob", reflect.TypeOf((*MockClient)(nil).PrefetchBlob), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrefetchBlob", reflect.TypeOf((*MockClient)(nil).PrefetchBlob), namespace, d) } // ReplicateToRemote mocks base method. -func (m *MockClient) ReplicateToRemote(arg0 string, arg1 core.Digest, arg2 string) error { +func (m *MockClient) ReplicateToRemote(namespace string, d core.Digest, remoteDNS string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReplicateToRemote", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "ReplicateToRemote", namespace, d, remoteDNS) ret0, _ := ret[0].(error) return ret0 } // ReplicateToRemote indicates an expected call of ReplicateToRemote. -func (mr *MockClientMockRecorder) ReplicateToRemote(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) ReplicateToRemote(namespace, d, remoteDNS any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicateToRemote", reflect.TypeOf((*MockClient)(nil).ReplicateToRemote), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicateToRemote", reflect.TypeOf((*MockClient)(nil).ReplicateToRemote), namespace, d, remoteDNS) } // Stat mocks base method. -func (m *MockClient) Stat(arg0 string, arg1 core.Digest) (*core.BlobInfo, error) { +func (m *MockClient) Stat(namespace string, d core.Digest) (*core.BlobInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Stat", arg0, arg1) + ret := m.ctrl.Call(m, "Stat", namespace, d) ret0, _ := ret[0].(*core.BlobInfo) ret1, _ := ret[1].(error) return ret0, ret1 } // Stat indicates an expected call of Stat. -func (mr *MockClientMockRecorder) Stat(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) Stat(namespace, d any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockClient)(nil).Stat), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockClient)(nil).Stat), namespace, d) } // StatLocal mocks base method. -func (m *MockClient) StatLocal(arg0 string, arg1 core.Digest) (*core.BlobInfo, error) { +func (m *MockClient) StatLocal(namespace string, d core.Digest) (*core.BlobInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StatLocal", arg0, arg1) + ret := m.ctrl.Call(m, "StatLocal", namespace, d) ret0, _ := ret[0].(*core.BlobInfo) ret1, _ := ret[1].(error) return ret0, ret1 } // StatLocal indicates an expected call of StatLocal. -func (mr *MockClientMockRecorder) StatLocal(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) StatLocal(namespace, d any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatLocal", reflect.TypeOf((*MockClient)(nil).StatLocal), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatLocal", reflect.TypeOf((*MockClient)(nil).StatLocal), namespace, d) } // TransferBlob mocks base method. -func (m *MockClient) TransferBlob(arg0 core.Digest, arg1 io.Reader) error { +func (m *MockClient) TransferBlob(d core.Digest, blob io.Reader) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TransferBlob", arg0, arg1) + ret := m.ctrl.Call(m, "TransferBlob", d, blob) ret0, _ := ret[0].(error) return ret0 } // TransferBlob indicates an expected call of TransferBlob. -func (mr *MockClientMockRecorder) TransferBlob(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) TransferBlob(d, blob any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransferBlob", reflect.TypeOf((*MockClient)(nil).TransferBlob), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransferBlob", reflect.TypeOf((*MockClient)(nil).TransferBlob), d, blob) } // UploadBlob mocks base method. -func (m *MockClient) UploadBlob(arg0 string, arg1 core.Digest, arg2 io.Reader) error { +func (m *MockClient) UploadBlob(namespace string, d core.Digest, blob io.Reader) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UploadBlob", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "UploadBlob", namespace, d, blob) ret0, _ := ret[0].(error) return ret0 } // UploadBlob indicates an expected call of UploadBlob. -func (mr *MockClientMockRecorder) UploadBlob(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) UploadBlob(namespace, d, blob any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadBlob", reflect.TypeOf((*MockClient)(nil).UploadBlob), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadBlob", reflect.TypeOf((*MockClient)(nil).UploadBlob), namespace, d, blob) } diff --git a/mocks/origin/blobclient/clientresolver.go b/mocks/origin/blobclient/clientresolver.go index 39103a5b1..8e385aa0f 100644 --- a/mocks/origin/blobclient/clientresolver.go +++ b/mocks/origin/blobclient/clientresolver.go @@ -12,30 +12,30 @@ import ( blobclient "github.com/uber/kraken/origin/blobclient" ) -// MockClientResolver is a mock of ClientResolver interface. +// MockClientResolver is a mock of ClientResolver interface type MockClientResolver struct { ctrl *gomock.Controller recorder *MockClientResolverMockRecorder } -// MockClientResolverMockRecorder is the mock recorder for MockClientResolver. +// MockClientResolverMockRecorder is the mock recorder for MockClientResolver type MockClientResolverMockRecorder struct { mock *MockClientResolver } -// NewMockClientResolver creates a new mock instance. +// NewMockClientResolver creates a new mock instance func NewMockClientResolver(ctrl *gomock.Controller) *MockClientResolver { mock := &MockClientResolver{ctrl: ctrl} mock.recorder = &MockClientResolverMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockClientResolver) EXPECT() *MockClientResolverMockRecorder { return m.recorder } -// Resolve mocks base method. +// Resolve mocks base method func (m *MockClientResolver) Resolve(arg0 core.Digest) ([]blobclient.Client, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Resolve", arg0) @@ -44,7 +44,7 @@ func (m *MockClientResolver) Resolve(arg0 core.Digest) ([]blobclient.Client, err return ret0, ret1 } -// Resolve indicates an expected call of Resolve. +// Resolve indicates an expected call of Resolve func (mr *MockClientResolverMockRecorder) Resolve(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resolve", reflect.TypeOf((*MockClientResolver)(nil).Resolve), arg0) diff --git a/mocks/origin/blobclient/clusterclient.go b/mocks/origin/blobclient/clusterclient.go index cd8f0dcb1..7334d48cd 100644 --- a/mocks/origin/blobclient/clusterclient.go +++ b/mocks/origin/blobclient/clusterclient.go @@ -1,5 +1,10 @@ // Code generated by MockGen. DO NOT EDIT. // Source: github.com/uber/kraken/origin/blobclient (interfaces: ClusterClient) +// +// Generated by this command: +// +// mockgen -package mockblobclient . ClusterClient +// // Package mockblobclient is a generated GoMock package. package mockblobclient @@ -16,6 +21,7 @@ import ( type MockClusterClient struct { ctrl *gomock.Controller recorder *MockClusterClientMockRecorder + isgomock struct{} } // MockClusterClientMockRecorder is the mock recorder for MockClusterClient. @@ -50,116 +56,116 @@ func (mr *MockClusterClientMockRecorder) CheckReadiness() *gomock.Call { } // DownloadBlob mocks base method. -func (m *MockClusterClient) DownloadBlob(arg0 string, arg1 core.Digest, arg2 io.Writer) error { +func (m *MockClusterClient) DownloadBlob(namespace string, d core.Digest, dst io.Writer) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DownloadBlob", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "DownloadBlob", namespace, d, dst) ret0, _ := ret[0].(error) return ret0 } // DownloadBlob indicates an expected call of DownloadBlob. -func (mr *MockClusterClientMockRecorder) DownloadBlob(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockClusterClientMockRecorder) DownloadBlob(namespace, d, dst any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadBlob", reflect.TypeOf((*MockClusterClient)(nil).DownloadBlob), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadBlob", reflect.TypeOf((*MockClusterClient)(nil).DownloadBlob), namespace, d, dst) } // GetMetaInfo mocks base method. -func (m *MockClusterClient) GetMetaInfo(arg0 string, arg1 core.Digest) (*core.MetaInfo, error) { +func (m *MockClusterClient) GetMetaInfo(namespace string, d core.Digest) (*core.MetaInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMetaInfo", arg0, arg1) + ret := m.ctrl.Call(m, "GetMetaInfo", namespace, d) ret0, _ := ret[0].(*core.MetaInfo) ret1, _ := ret[1].(error) return ret0, ret1 } // GetMetaInfo indicates an expected call of GetMetaInfo. -func (mr *MockClusterClientMockRecorder) GetMetaInfo(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockClusterClientMockRecorder) GetMetaInfo(namespace, d any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetaInfo", reflect.TypeOf((*MockClusterClient)(nil).GetMetaInfo), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetaInfo", reflect.TypeOf((*MockClusterClient)(nil).GetMetaInfo), namespace, d) } // OverwriteMetaInfo mocks base method. -func (m *MockClusterClient) OverwriteMetaInfo(arg0 core.Digest, arg1 int64) error { +func (m *MockClusterClient) OverwriteMetaInfo(d core.Digest, pieceLength int64) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "OverwriteMetaInfo", arg0, arg1) + ret := m.ctrl.Call(m, "OverwriteMetaInfo", d, pieceLength) ret0, _ := ret[0].(error) return ret0 } // OverwriteMetaInfo indicates an expected call of OverwriteMetaInfo. -func (mr *MockClusterClientMockRecorder) OverwriteMetaInfo(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockClusterClientMockRecorder) OverwriteMetaInfo(d, pieceLength any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OverwriteMetaInfo", reflect.TypeOf((*MockClusterClient)(nil).OverwriteMetaInfo), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OverwriteMetaInfo", reflect.TypeOf((*MockClusterClient)(nil).OverwriteMetaInfo), d, pieceLength) } // Owners mocks base method. -func (m *MockClusterClient) Owners(arg0 core.Digest) ([]core.PeerContext, error) { +func (m *MockClusterClient) Owners(d core.Digest) ([]core.PeerContext, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Owners", arg0) + ret := m.ctrl.Call(m, "Owners", d) ret0, _ := ret[0].([]core.PeerContext) ret1, _ := ret[1].(error) return ret0, ret1 } // Owners indicates an expected call of Owners. -func (mr *MockClusterClientMockRecorder) Owners(arg0 interface{}) *gomock.Call { +func (mr *MockClusterClientMockRecorder) Owners(d any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Owners", reflect.TypeOf((*MockClusterClient)(nil).Owners), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Owners", reflect.TypeOf((*MockClusterClient)(nil).Owners), d) } // PrefetchBlob mocks base method. -func (m *MockClusterClient) PrefetchBlob(arg0 string, arg1 core.Digest) error { +func (m *MockClusterClient) PrefetchBlob(namespace string, d core.Digest) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PrefetchBlob", arg0, arg1) + ret := m.ctrl.Call(m, "PrefetchBlob", namespace, d) ret0, _ := ret[0].(error) return ret0 } // PrefetchBlob indicates an expected call of PrefetchBlob. -func (mr *MockClusterClientMockRecorder) PrefetchBlob(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockClusterClientMockRecorder) PrefetchBlob(namespace, d any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrefetchBlob", reflect.TypeOf((*MockClusterClient)(nil).PrefetchBlob), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrefetchBlob", reflect.TypeOf((*MockClusterClient)(nil).PrefetchBlob), namespace, d) } // ReplicateToRemote mocks base method. -func (m *MockClusterClient) ReplicateToRemote(arg0 string, arg1 core.Digest, arg2 string) error { +func (m *MockClusterClient) ReplicateToRemote(namespace string, d core.Digest, remoteDNS string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReplicateToRemote", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "ReplicateToRemote", namespace, d, remoteDNS) ret0, _ := ret[0].(error) return ret0 } // ReplicateToRemote indicates an expected call of ReplicateToRemote. -func (mr *MockClusterClientMockRecorder) ReplicateToRemote(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockClusterClientMockRecorder) ReplicateToRemote(namespace, d, remoteDNS any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicateToRemote", reflect.TypeOf((*MockClusterClient)(nil).ReplicateToRemote), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicateToRemote", reflect.TypeOf((*MockClusterClient)(nil).ReplicateToRemote), namespace, d, remoteDNS) } // Stat mocks base method. -func (m *MockClusterClient) Stat(arg0 string, arg1 core.Digest) (*core.BlobInfo, error) { +func (m *MockClusterClient) Stat(namespace string, d core.Digest) (*core.BlobInfo, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Stat", arg0, arg1) + ret := m.ctrl.Call(m, "Stat", namespace, d) ret0, _ := ret[0].(*core.BlobInfo) ret1, _ := ret[1].(error) return ret0, ret1 } // Stat indicates an expected call of Stat. -func (mr *MockClusterClientMockRecorder) Stat(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockClusterClientMockRecorder) Stat(namespace, d any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockClusterClient)(nil).Stat), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockClusterClient)(nil).Stat), namespace, d) } // UploadBlob mocks base method. -func (m *MockClusterClient) UploadBlob(arg0 string, arg1 core.Digest, arg2 io.ReadSeeker) error { +func (m *MockClusterClient) UploadBlob(namespace string, d core.Digest, blob io.ReadSeeker) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UploadBlob", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "UploadBlob", namespace, d, blob) ret0, _ := ret[0].(error) return ret0 } // UploadBlob indicates an expected call of UploadBlob. -func (mr *MockClusterClientMockRecorder) UploadBlob(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockClusterClientMockRecorder) UploadBlob(namespace, d, blob any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadBlob", reflect.TypeOf((*MockClusterClient)(nil).UploadBlob), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadBlob", reflect.TypeOf((*MockClusterClient)(nil).UploadBlob), namespace, d, blob) } diff --git a/mocks/origin/blobclient/clusterprovider.go b/mocks/origin/blobclient/clusterprovider.go index 2626792f4..6971163cd 100644 --- a/mocks/origin/blobclient/clusterprovider.go +++ b/mocks/origin/blobclient/clusterprovider.go @@ -11,30 +11,30 @@ import ( blobclient "github.com/uber/kraken/origin/blobclient" ) -// MockClusterProvider is a mock of ClusterProvider interface. +// MockClusterProvider is a mock of ClusterProvider interface type MockClusterProvider struct { ctrl *gomock.Controller recorder *MockClusterProviderMockRecorder } -// MockClusterProviderMockRecorder is the mock recorder for MockClusterProvider. +// MockClusterProviderMockRecorder is the mock recorder for MockClusterProvider type MockClusterProviderMockRecorder struct { mock *MockClusterProvider } -// NewMockClusterProvider creates a new mock instance. +// NewMockClusterProvider creates a new mock instance func NewMockClusterProvider(ctrl *gomock.Controller) *MockClusterProvider { mock := &MockClusterProvider{ctrl: ctrl} mock.recorder = &MockClusterProviderMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockClusterProvider) EXPECT() *MockClusterProviderMockRecorder { return m.recorder } -// Provide mocks base method. +// Provide mocks base method func (m *MockClusterProvider) Provide(arg0 string) (blobclient.ClusterClient, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Provide", arg0) @@ -43,7 +43,7 @@ func (m *MockClusterProvider) Provide(arg0 string) (blobclient.ClusterClient, er return ret0, ret1 } -// Provide indicates an expected call of Provide. +// Provide indicates an expected call of Provide func (mr *MockClusterProviderMockRecorder) Provide(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Provide", reflect.TypeOf((*MockClusterProvider)(nil).Provide), arg0) diff --git a/mocks/origin/blobclient/provider.go b/mocks/origin/blobclient/provider.go index 9ba73a2ac..816a11139 100644 --- a/mocks/origin/blobclient/provider.go +++ b/mocks/origin/blobclient/provider.go @@ -11,30 +11,30 @@ import ( blobclient "github.com/uber/kraken/origin/blobclient" ) -// MockProvider is a mock of Provider interface. +// MockProvider is a mock of Provider interface type MockProvider struct { ctrl *gomock.Controller recorder *MockProviderMockRecorder } -// MockProviderMockRecorder is the mock recorder for MockProvider. +// MockProviderMockRecorder is the mock recorder for MockProvider type MockProviderMockRecorder struct { mock *MockProvider } -// NewMockProvider creates a new mock instance. +// NewMockProvider creates a new mock instance func NewMockProvider(ctrl *gomock.Controller) *MockProvider { mock := &MockProvider{ctrl: ctrl} mock.recorder = &MockProviderMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockProvider) EXPECT() *MockProviderMockRecorder { return m.recorder } -// Provide mocks base method. +// Provide mocks base method func (m *MockProvider) Provide(arg0 string) blobclient.Client { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Provide", arg0) @@ -42,7 +42,7 @@ func (m *MockProvider) Provide(arg0 string) blobclient.Client { return ret0 } -// Provide indicates an expected call of Provide. +// Provide indicates an expected call of Provide func (mr *MockProviderMockRecorder) Provide(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Provide", reflect.TypeOf((*MockProvider)(nil).Provide), arg0) diff --git a/mocks/tracker/announceclient/client.go b/mocks/tracker/announceclient/client.go index 7ad24b799..35cc21ec7 100644 --- a/mocks/tracker/announceclient/client.go +++ b/mocks/tracker/announceclient/client.go @@ -1,5 +1,10 @@ // Code generated by MockGen. DO NOT EDIT. // Source: github.com/uber/kraken/tracker/announceclient (interfaces: Client) +// +// Generated by this command: +// +// mockgen -typed -package mockannounceclient . Client +// // Package mockannounceclient is a generated GoMock package. package mockannounceclient @@ -36,9 +41,9 @@ func (m *MockClient) EXPECT() *MockClientMockRecorder { } // Announce mocks base method. -func (m *MockClient) Announce(arg0 core.Digest, arg1 core.InfoHash, arg2 bool, arg3 int) ([]*core.PeerInfo, time.Duration, error) { +func (m *MockClient) Announce(d core.Digest, h core.InfoHash, complete bool, version int) ([]*core.PeerInfo, time.Duration, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Announce", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "Announce", d, h, complete, version) ret0, _ := ret[0].([]*core.PeerInfo) ret1, _ := ret[1].(time.Duration) ret2, _ := ret[2].(error) @@ -46,9 +51,33 @@ func (m *MockClient) Announce(arg0 core.Digest, arg1 core.InfoHash, arg2 bool, a } // Announce indicates an expected call of Announce. -func (mr *MockClientMockRecorder) Announce(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) Announce(d, h, complete, version interface{}) *MockClientAnnounceCall { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Announce", reflect.TypeOf((*MockClient)(nil).Announce), arg0, arg1, arg2, arg3) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Announce", reflect.TypeOf((*MockClient)(nil).Announce), d, h, complete, version) + return &MockClientAnnounceCall{Call: call} +} + +// MockClientAnnounceCall wrap *gomock.Call +type MockClientAnnounceCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockClientAnnounceCall) Return(arg0 []*core.PeerInfo, arg1 time.Duration, arg2 error) *MockClientAnnounceCall { + c.Call = c.Call.Return(arg0, arg1, arg2) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockClientAnnounceCall) Do(f func(core.Digest, core.InfoHash, bool, int) ([]*core.PeerInfo, time.Duration, error)) *MockClientAnnounceCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockClientAnnounceCall) DoAndReturn(f func(core.Digest, core.InfoHash, bool, int) ([]*core.PeerInfo, time.Duration, error)) *MockClientAnnounceCall { + c.Call = c.Call.DoAndReturn(f) + return c } // CheckReadiness mocks base method. @@ -60,7 +89,31 @@ func (m *MockClient) CheckReadiness() error { } // CheckReadiness indicates an expected call of CheckReadiness. -func (mr *MockClientMockRecorder) CheckReadiness() *gomock.Call { +func (mr *MockClientMockRecorder) CheckReadiness() *MockClientCheckReadinessCall { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckReadiness", reflect.TypeOf((*MockClient)(nil).CheckReadiness)) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckReadiness", reflect.TypeOf((*MockClient)(nil).CheckReadiness)) + return &MockClientCheckReadinessCall{Call: call} +} + +// MockClientCheckReadinessCall wrap *gomock.Call +type MockClientCheckReadinessCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockClientCheckReadinessCall) Return(arg0 error) *MockClientCheckReadinessCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockClientCheckReadinessCall) Do(f func() error) *MockClientCheckReadinessCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockClientCheckReadinessCall) DoAndReturn(f func() error) *MockClientCheckReadinessCall { + c.Call = c.Call.DoAndReturn(f) + return c } diff --git a/mocks/tracker/metainfoclient/client.go b/mocks/tracker/metainfoclient/client.go index 9a859c10e..88be3eb6f 100644 --- a/mocks/tracker/metainfoclient/client.go +++ b/mocks/tracker/metainfoclient/client.go @@ -11,30 +11,30 @@ import ( core "github.com/uber/kraken/core" ) -// MockClient is a mock of Client interface. +// MockClient is a mock of Client interface type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder } -// MockClientMockRecorder is the mock recorder for MockClient. +// MockClientMockRecorder is the mock recorder for MockClient type MockClientMockRecorder struct { mock *MockClient } -// NewMockClient creates a new mock instance. +// NewMockClient creates a new mock instance func NewMockClient(ctrl *gomock.Controller) *MockClient { mock := &MockClient{ctrl: ctrl} mock.recorder = &MockClientMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockClient) EXPECT() *MockClientMockRecorder { return m.recorder } -// Download mocks base method. +// Download mocks base method func (m *MockClient) Download(arg0 string, arg1 core.Digest) (*core.MetaInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Download", arg0, arg1) @@ -43,7 +43,7 @@ func (m *MockClient) Download(arg0 string, arg1 core.Digest) (*core.MetaInfo, er return ret0, ret1 } -// Download indicates an expected call of Download. +// Download indicates an expected call of Download func (mr *MockClientMockRecorder) Download(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockClient)(nil).Download), arg0, arg1) diff --git a/mocks/tracker/originstore/store.go b/mocks/tracker/originstore/store.go index 4e5fcbc66..dd411a283 100644 --- a/mocks/tracker/originstore/store.go +++ b/mocks/tracker/originstore/store.go @@ -11,30 +11,30 @@ import ( core "github.com/uber/kraken/core" ) -// MockStore is a mock of Store interface. +// MockStore is a mock of Store interface type MockStore struct { ctrl *gomock.Controller recorder *MockStoreMockRecorder } -// MockStoreMockRecorder is the mock recorder for MockStore. +// MockStoreMockRecorder is the mock recorder for MockStore type MockStoreMockRecorder struct { mock *MockStore } -// NewMockStore creates a new mock instance. +// NewMockStore creates a new mock instance func NewMockStore(ctrl *gomock.Controller) *MockStore { mock := &MockStore{ctrl: ctrl} mock.recorder = &MockStoreMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockStore) EXPECT() *MockStoreMockRecorder { return m.recorder } -// GetOrigins mocks base method. +// GetOrigins mocks base method func (m *MockStore) GetOrigins(arg0 core.Digest) ([]*core.PeerInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetOrigins", arg0) @@ -43,7 +43,7 @@ func (m *MockStore) GetOrigins(arg0 core.Digest) ([]*core.PeerInfo, error) { return ret0, ret1 } -// GetOrigins indicates an expected call of GetOrigins. +// GetOrigins indicates an expected call of GetOrigins func (mr *MockStoreMockRecorder) GetOrigins(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrigins", reflect.TypeOf((*MockStore)(nil).GetOrigins), arg0) diff --git a/mocks/tracker/peerstore/store.go b/mocks/tracker/peerstore/store.go index 784ab9f2a..735763586 100644 --- a/mocks/tracker/peerstore/store.go +++ b/mocks/tracker/peerstore/store.go @@ -11,42 +11,42 @@ import ( core "github.com/uber/kraken/core" ) -// MockStore is a mock of Store interface. +// MockStore is a mock of Store interface type MockStore struct { ctrl *gomock.Controller recorder *MockStoreMockRecorder } -// MockStoreMockRecorder is the mock recorder for MockStore. +// MockStoreMockRecorder is the mock recorder for MockStore type MockStoreMockRecorder struct { mock *MockStore } -// NewMockStore creates a new mock instance. +// NewMockStore creates a new mock instance func NewMockStore(ctrl *gomock.Controller) *MockStore { mock := &MockStore{ctrl: ctrl} mock.recorder = &MockStoreMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockStore) EXPECT() *MockStoreMockRecorder { return m.recorder } -// Close mocks base method. +// Close mocks base method func (m *MockStore) Close() { m.ctrl.T.Helper() m.ctrl.Call(m, "Close") } -// Close indicates an expected call of Close. +// Close indicates an expected call of Close func (mr *MockStoreMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStore)(nil).Close)) } -// GetPeers mocks base method. +// GetPeers mocks base method func (m *MockStore) GetPeers(arg0 core.InfoHash, arg1 int) ([]*core.PeerInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetPeers", arg0, arg1) @@ -55,13 +55,13 @@ func (m *MockStore) GetPeers(arg0 core.InfoHash, arg1 int) ([]*core.PeerInfo, er return ret0, ret1 } -// GetPeers indicates an expected call of GetPeers. +// GetPeers indicates an expected call of GetPeers func (mr *MockStoreMockRecorder) GetPeers(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPeers", reflect.TypeOf((*MockStore)(nil).GetPeers), arg0, arg1) } -// UpdatePeer mocks base method. +// UpdatePeer mocks base method func (m *MockStore) UpdatePeer(arg0 core.InfoHash, arg1 *core.PeerInfo) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdatePeer", arg0, arg1) @@ -69,7 +69,7 @@ func (m *MockStore) UpdatePeer(arg0 core.InfoHash, arg1 *core.PeerInfo) error { return ret0 } -// UpdatePeer indicates an expected call of UpdatePeer. +// UpdatePeer indicates an expected call of UpdatePeer func (mr *MockStoreMockRecorder) UpdatePeer(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePeer", reflect.TypeOf((*MockStore)(nil).UpdatePeer), arg0, arg1) diff --git a/mocks/utils/dedup/intervaltask.go b/mocks/utils/dedup/intervaltask.go index ea3e3adc2..eed6d226c 100644 --- a/mocks/utils/dedup/intervaltask.go +++ b/mocks/utils/dedup/intervaltask.go @@ -10,36 +10,36 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockIntervalTask is a mock of IntervalTask interface. +// MockIntervalTask is a mock of IntervalTask interface type MockIntervalTask struct { ctrl *gomock.Controller recorder *MockIntervalTaskMockRecorder } -// MockIntervalTaskMockRecorder is the mock recorder for MockIntervalTask. +// MockIntervalTaskMockRecorder is the mock recorder for MockIntervalTask type MockIntervalTaskMockRecorder struct { mock *MockIntervalTask } -// NewMockIntervalTask creates a new mock instance. +// NewMockIntervalTask creates a new mock instance func NewMockIntervalTask(ctrl *gomock.Controller) *MockIntervalTask { mock := &MockIntervalTask{ctrl: ctrl} mock.recorder = &MockIntervalTaskMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockIntervalTask) EXPECT() *MockIntervalTaskMockRecorder { return m.recorder } -// Run mocks base method. +// Run mocks base method func (m *MockIntervalTask) Run() { m.ctrl.T.Helper() m.ctrl.Call(m, "Run") } -// Run indicates an expected call of Run. +// Run indicates an expected call of Run func (mr *MockIntervalTaskMockRecorder) Run() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockIntervalTask)(nil).Run)) diff --git a/mocks/utils/dedup/taskrunner.go b/mocks/utils/dedup/taskrunner.go index b68281d0d..b9128205e 100644 --- a/mocks/utils/dedup/taskrunner.go +++ b/mocks/utils/dedup/taskrunner.go @@ -11,30 +11,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockTaskRunner is a mock of TaskRunner interface. +// MockTaskRunner is a mock of TaskRunner interface type MockTaskRunner struct { ctrl *gomock.Controller recorder *MockTaskRunnerMockRecorder } -// MockTaskRunnerMockRecorder is the mock recorder for MockTaskRunner. +// MockTaskRunnerMockRecorder is the mock recorder for MockTaskRunner type MockTaskRunnerMockRecorder struct { mock *MockTaskRunner } -// NewMockTaskRunner creates a new mock instance. +// NewMockTaskRunner creates a new mock instance func NewMockTaskRunner(ctrl *gomock.Controller) *MockTaskRunner { mock := &MockTaskRunner{ctrl: ctrl} mock.recorder = &MockTaskRunnerMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockTaskRunner) EXPECT() *MockTaskRunnerMockRecorder { return m.recorder } -// Run mocks base method. +// Run mocks base method func (m *MockTaskRunner) Run(arg0 interface{}) (interface{}, time.Duration) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Run", arg0) @@ -43,7 +43,7 @@ func (m *MockTaskRunner) Run(arg0 interface{}) (interface{}, time.Duration) { return ret0, ret1 } -// Run indicates an expected call of Run. +// Run indicates an expected call of Run func (mr *MockTaskRunnerMockRecorder) Run(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockTaskRunner)(nil).Run), arg0) diff --git a/mocks/utils/httputil/roundtripper.go b/mocks/utils/httputil/roundtripper.go index 0c6885bd1..1e97b476d 100644 --- a/mocks/utils/httputil/roundtripper.go +++ b/mocks/utils/httputil/roundtripper.go @@ -11,30 +11,30 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockRoundTripper is a mock of RoundTripper interface. +// MockRoundTripper is a mock of RoundTripper interface type MockRoundTripper struct { ctrl *gomock.Controller recorder *MockRoundTripperMockRecorder } -// MockRoundTripperMockRecorder is the mock recorder for MockRoundTripper. +// MockRoundTripperMockRecorder is the mock recorder for MockRoundTripper type MockRoundTripperMockRecorder struct { mock *MockRoundTripper } -// NewMockRoundTripper creates a new mock instance. +// NewMockRoundTripper creates a new mock instance func NewMockRoundTripper(ctrl *gomock.Controller) *MockRoundTripper { mock := &MockRoundTripper{ctrl: ctrl} mock.recorder = &MockRoundTripperMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockRoundTripper) EXPECT() *MockRoundTripperMockRecorder { return m.recorder } -// RoundTrip mocks base method. +// RoundTrip mocks base method func (m *MockRoundTripper) RoundTrip(arg0 *http.Request) (*http.Response, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RoundTrip", arg0) @@ -43,7 +43,7 @@ func (m *MockRoundTripper) RoundTrip(arg0 *http.Request) (*http.Response, error) return ret0, ret1 } -// RoundTrip indicates an expected call of RoundTrip. +// RoundTrip indicates an expected call of RoundTrip func (mr *MockRoundTripperMockRecorder) RoundTrip(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoundTrip", reflect.TypeOf((*MockRoundTripper)(nil).RoundTrip), arg0) From c56651d81c768e6c1810fd59a1861b905f060b5e Mon Sep 17 00:00:00 2001 From: hweawer Date: Tue, 20 Jan 2026 14:10:29 +0100 Subject: [PATCH 05/32] Fix storage mock --- mocks/agent/agentclient/client.go | 17 +++++++++-------- mocks/build-index/tagstore/store.go | 12 +++++++----- 2 files changed, 16 insertions(+), 13 deletions(-) diff --git a/mocks/agent/agentclient/client.go b/mocks/agent/agentclient/client.go index a95e39c9d..6d15a2c24 100644 --- a/mocks/agent/agentclient/client.go +++ b/mocks/agent/agentclient/client.go @@ -5,6 +5,7 @@ package mockagentclient import ( + context "context" io "io" reflect "reflect" @@ -36,31 +37,31 @@ func (m *MockClient) EXPECT() *MockClientMockRecorder { } // Download mocks base method -func (m *MockClient) Download(arg0 string, arg1 core.Digest) (io.ReadCloser, error) { +func (m *MockClient) Download(arg0 context.Context, arg1 string, arg2 core.Digest) (io.ReadCloser, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Download", arg0, arg1) + ret := m.ctrl.Call(m, "Download", arg0, arg1, arg2) ret0, _ := ret[0].(io.ReadCloser) ret1, _ := ret[1].(error) return ret0, ret1 } // Download indicates an expected call of Download -func (mr *MockClientMockRecorder) Download(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) Download(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockClient)(nil).Download), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockClient)(nil).Download), arg0, arg1, arg2) } // GetTag mocks base method -func (m *MockClient) GetTag(arg0 string) (core.Digest, error) { +func (m *MockClient) GetTag(arg0 context.Context, arg1 string) (core.Digest, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTag", arg0) + ret := m.ctrl.Call(m, "GetTag", arg0, arg1) ret0, _ := ret[0].(core.Digest) ret1, _ := ret[1].(error) return ret0, ret1 } // GetTag indicates an expected call of GetTag -func (mr *MockClientMockRecorder) GetTag(arg0 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) GetTag(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTag", reflect.TypeOf((*MockClient)(nil).GetTag), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTag", reflect.TypeOf((*MockClient)(nil).GetTag), arg0, arg1) } diff --git a/mocks/build-index/tagstore/store.go b/mocks/build-index/tagstore/store.go index 2677cb90d..d3b43fa3f 100644 --- a/mocks/build-index/tagstore/store.go +++ b/mocks/build-index/tagstore/store.go @@ -5,10 +5,12 @@ package mocktagstore import ( + "context" reflect "reflect" time "time" gomock "github.com/golang/mock/gomock" + core "github.com/uber/kraken/core" ) @@ -50,16 +52,16 @@ func (mr *MockStoreMockRecorder) Get(arg0 interface{}) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockStore)(nil).Get), arg0) } -// Put mocks base method -func (m *MockStore) Put(arg0 string, arg1 core.Digest, arg2 time.Duration) error { +// Put mocks base metho +func (m *MockStore) Put(arg0 context.Context, arg1 string, arg2 core.Digest, arg3 time.Duration) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2, arg3) ret0, _ := ret[0].(error) return ret0 } // Put indicates an expected call of Put -func (mr *MockStoreMockRecorder) Put(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockStoreMockRecorder) Put(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockStore)(nil).Put), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockStore)(nil).Put), arg0, arg1, arg2, arg3) } From e48032147fc41e768ac35f73d495d9319b43e590 Mon Sep 17 00:00:00 2001 From: hweawer Date: Tue, 20 Jan 2026 14:52:27 +0100 Subject: [PATCH 06/32] Partially revert --- build-index/cmd/cmd.go | 5 ++-- build-index/tagserver/server.go | 24 ++++--------------- build-index/tagstore/store.go | 7 +++--- build-index/tagstore/store_test.go | 5 ++-- lib/persistedretry/writeback/executor.go | 5 ++-- lib/persistedretry/writeback/executor_test.go | 3 +-- mocks/agent/agentclient/client.go | 17 +++++++------ mocks/build-index/tagstore/store.go | 12 ++++------ origin/blobserver/server.go | 19 +++++++-------- origin/cmd/cmd.go | 4 +--- 10 files changed, 39 insertions(+), 62 deletions(-) diff --git a/build-index/cmd/cmd.go b/build-index/cmd/cmd.go index b32abd3f8..55687ada0 100644 --- a/build-index/cmd/cmd.go +++ b/build-index/cmd/cmd.go @@ -201,13 +201,11 @@ func Run(flags *Flags, opts ...Option) { log.Fatalf("Error creating tag replication manager: %s", err) } - tracer := otel.Tracer("kraken-build-index") - writeBackManager, err := persistedretry.NewManager( config.WriteBack, stats, writeback.NewStore(localDB), - writeback.NewExecutor(stats, ss, backends, tracer)) + writeback.NewExecutor(stats, ss, backends)) if err != nil { log.Fatalf("Error creating write-back manager: %s", err) } @@ -218,6 +216,7 @@ func Run(flags *Flags, opts ...Option) { if err != nil { log.Fatalf("Error creating tag type manager: %s", err) } + tracer := otel.Tracer("kraken-build-index") server := tagserver.New( config.TagServer, diff --git a/build-index/tagserver/server.go b/build-index/tagserver/server.go index 52ba722aa..34ca53d5c 100644 --- a/build-index/tagserver/server.go +++ b/build-index/tagserver/server.go @@ -244,44 +244,30 @@ func (s *Server) putTagHandler(w http.ResponseWriter, r *http.Request) error { } func (s *Server) duplicatePutTagHandler(w http.ResponseWriter, r *http.Request) error { - ctx, span := s.tracer.Start(r.Context(), "build_index.duplicate_put_tag") - defer span.End() - tag, err := httputil.ParseParam(r, "tag") if err != nil { - span.RecordError(err) return err } d, err := httputil.ParseDigest(r, "digest") if err != nil { - span.RecordError(err) return err } var req tagclient.DuplicatePutRequest if err := json.NewDecoder(r.Body).Decode(&req); err != nil { - span.RecordError(err) return handler.Errorf("decode body: %s", err) } delay := req.Delay - span.SetAttributes( - attribute.String("tag", tag), - attribute.String("digest", d.String()), - attribute.Int64("delay_ms", delay.Milliseconds()), - ) - - log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "delay", delay).Debug("Received duplicate put request from neighbor") + log.With("tag", tag, "digest", d.String(), "delay", delay).Debug("Received duplicate put request from neighbor") - if err := s.store.Put(ctx, tag, d, delay); err != nil { - log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "delay", delay, "error", err).Error("Failed to store tag from duplicate put") - span.RecordError(err) + if err := s.store.Put(tag, d, delay); err != nil { + log.With("tag", tag, "digest", d.String(), "delay", delay, "error", err).Error("Failed to store tag from duplicate put") return handler.Errorf("storage: %s", err) } - log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "delay", delay).Info("Successfully stored tag from duplicate put") + log.With("tag", tag, "digest", d.String(), "delay", delay).Info("Successfully stored tag from duplicate put") - span.SetAttributes(attribute.Bool("success", true)) w.WriteHeader(http.StatusOK) return nil } @@ -519,7 +505,7 @@ func (s *Server) putTag(ctx context.Context, tag string, d core.Digest, deps cor log.WithTraceContext(ctx).With("tag", tag, "digest", d.String()).Debug("All dependencies validated successfully") - if err := s.store.Put(ctx, tag, d, 0); err != nil { + if err := s.store.Put(tag, d, 0); err != nil { return fmt.Errorf("storage: %w", err) } diff --git a/build-index/tagstore/store.go b/build-index/tagstore/store.go index 88c81d7e8..a959fdd53 100644 --- a/build-index/tagstore/store.go +++ b/build-index/tagstore/store.go @@ -15,7 +15,6 @@ package tagstore import ( "bytes" - "context" "errors" "fmt" "io" @@ -49,7 +48,7 @@ type FileStore interface { // Store defines tag storage operations. type Store interface { - Put(ctx context.Context, tag string, d core.Digest, writeBackDelay time.Duration) error + Put(tag string, d core.Digest, writeBackDelay time.Duration) error Get(tag string) (core.Digest, error) } @@ -96,7 +95,7 @@ func New( return s } -func (s *tagStore) Put(ctx context.Context, tag string, d core.Digest, writeBackDelay time.Duration) error { +func (s *tagStore) Put(tag string, d core.Digest, writeBackDelay time.Duration) error { if err := s.writeTagToDisk(tag, d); err != nil { return fmt.Errorf("write tag to disk: %s", err) } @@ -104,7 +103,7 @@ func (s *tagStore) Put(ctx context.Context, tag string, d core.Digest, writeBack return fmt.Errorf("set persist metadata: %s", err) } - task := writeback.NewTaskWithContext(ctx, tag, tag, writeBackDelay) + task := writeback.NewTask(tag, tag, writeBackDelay) return s.writeBackStrategy(task) } diff --git a/build-index/tagstore/store_test.go b/build-index/tagstore/store_test.go index 861137ef8..c23fe4a02 100644 --- a/build-index/tagstore/store_test.go +++ b/build-index/tagstore/store_test.go @@ -14,7 +14,6 @@ package tagstore_test import ( - "context" "fmt" "io" "testing" @@ -82,7 +81,7 @@ func TestPutAndGetFromDisk(t *testing.T) { mocks.writeBackManager.EXPECT().Add( writeback.MatchTask(writeback.NewTask(tag, tag, 0))).Return(nil) - require.NoError(store.Put(context.Background(), tag, digest, 0)) + require.NoError(store.Put(tag, digest, 0)) result, err := store.Get(tag) require.NoError(err) @@ -103,7 +102,7 @@ func TestPutAndGetFromDiskWriteThrough(t *testing.T) { mocks.writeBackManager.EXPECT().SyncExec( writeback.MatchTask(writeback.NewTask(tag, tag, 0))).Return(nil) - require.NoError(store.Put(context.Background(), tag, digest, 0)) + require.NoError(store.Put(tag, digest, 0)) result, err := store.Get(tag) require.NoError(err) diff --git a/lib/persistedretry/writeback/executor.go b/lib/persistedretry/writeback/executor.go index 84d4f0d32..009256083 100644 --- a/lib/persistedretry/writeback/executor.go +++ b/lib/persistedretry/writeback/executor.go @@ -20,6 +20,7 @@ import ( "time" "github.com/uber-go/tally" + "github.com/uber/kraken/lib/backend" "github.com/uber/kraken/lib/persistedretry" "github.com/uber/kraken/lib/store" @@ -27,6 +28,7 @@ import ( "github.com/uber/kraken/utils/closers" "github.com/uber/kraken/utils/log" + "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/codes" "go.opentelemetry.io/otel/trace" @@ -51,13 +53,12 @@ func NewExecutor( stats tally.Scope, fs FileStore, backends *backend.Manager, - tracer trace.Tracer, ) *Executor { stats = stats.Tagged(map[string]string{ "module": "writebackexecutor", }) - return &Executor{stats, fs, backends, tracer} + return &Executor{stats, fs, backends, otel.Tracer("kraken-writeback")} } // Name returns the executor name. diff --git a/lib/persistedretry/writeback/executor_test.go b/lib/persistedretry/writeback/executor_test.go index a1104dceb..4a39ea9e2 100644 --- a/lib/persistedretry/writeback/executor_test.go +++ b/lib/persistedretry/writeback/executor_test.go @@ -56,8 +56,7 @@ func newExecutorMocks(t *testing.T) (*executorMocks, func()) { } func (m *executorMocks) new() *Executor { - tracer := otel.Tracer("test-writeback") - return NewExecutor(tally.NoopScope, m.cas, m.backends, tracer) + return NewExecutor(tally.NoopScope, m.cas, m.backends) } func (m *executorMocks) client(namespace string) *mockbackend.MockClient { diff --git a/mocks/agent/agentclient/client.go b/mocks/agent/agentclient/client.go index 6d15a2c24..a95e39c9d 100644 --- a/mocks/agent/agentclient/client.go +++ b/mocks/agent/agentclient/client.go @@ -5,7 +5,6 @@ package mockagentclient import ( - context "context" io "io" reflect "reflect" @@ -37,31 +36,31 @@ func (m *MockClient) EXPECT() *MockClientMockRecorder { } // Download mocks base method -func (m *MockClient) Download(arg0 context.Context, arg1 string, arg2 core.Digest) (io.ReadCloser, error) { +func (m *MockClient) Download(arg0 string, arg1 core.Digest) (io.ReadCloser, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Download", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "Download", arg0, arg1) ret0, _ := ret[0].(io.ReadCloser) ret1, _ := ret[1].(error) return ret0, ret1 } // Download indicates an expected call of Download -func (mr *MockClientMockRecorder) Download(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) Download(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockClient)(nil).Download), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockClient)(nil).Download), arg0, arg1) } // GetTag mocks base method -func (m *MockClient) GetTag(arg0 context.Context, arg1 string) (core.Digest, error) { +func (m *MockClient) GetTag(arg0 string) (core.Digest, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTag", arg0, arg1) + ret := m.ctrl.Call(m, "GetTag", arg0) ret0, _ := ret[0].(core.Digest) ret1, _ := ret[1].(error) return ret0, ret1 } // GetTag indicates an expected call of GetTag -func (mr *MockClientMockRecorder) GetTag(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) GetTag(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTag", reflect.TypeOf((*MockClient)(nil).GetTag), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTag", reflect.TypeOf((*MockClient)(nil).GetTag), arg0) } diff --git a/mocks/build-index/tagstore/store.go b/mocks/build-index/tagstore/store.go index d3b43fa3f..2677cb90d 100644 --- a/mocks/build-index/tagstore/store.go +++ b/mocks/build-index/tagstore/store.go @@ -5,12 +5,10 @@ package mocktagstore import ( - "context" reflect "reflect" time "time" gomock "github.com/golang/mock/gomock" - core "github.com/uber/kraken/core" ) @@ -52,16 +50,16 @@ func (mr *MockStoreMockRecorder) Get(arg0 interface{}) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockStore)(nil).Get), arg0) } -// Put mocks base metho -func (m *MockStore) Put(arg0 context.Context, arg1 string, arg2 core.Digest, arg3 time.Duration) error { +// Put mocks base method +func (m *MockStore) Put(arg0 string, arg1 core.Digest, arg2 time.Duration) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2) ret0, _ := ret[0].(error) return ret0 } // Put indicates an expected call of Put -func (mr *MockStoreMockRecorder) Put(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockStoreMockRecorder) Put(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockStore)(nil).Put), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockStore)(nil).Put), arg0, arg1, arg2) } diff --git a/origin/blobserver/server.go b/origin/blobserver/server.go index 6666c601b..51381732b 100644 --- a/origin/blobserver/server.go +++ b/origin/blobserver/server.go @@ -14,7 +14,6 @@ package blobserver import ( - "context" "encoding/json" "fmt" "io" @@ -691,14 +690,14 @@ func (s *Server) commitTransferHandler(w http.ResponseWriter, r *http.Request) e return nil } -func (s *Server) handleUploadConflict(ctx context.Context, err error, namespace string, d core.Digest) error { +func (s *Server) handleUploadConflict(err error, namespace string, d core.Digest) error { if herr, ok := err.(*handler.Error); ok && herr.GetStatus() == http.StatusConflict { // Even if the blob was already uploaded and committed to cache, it's // still possible that adding the write-back task failed. Clients short // circuit on conflict and return success, so we must make sure that if we // tell a client to stop before commit, the blob has been written back. log.With("namespace", namespace, "digest", d.Hex()).Debug("Handling upload conflict, ensuring write-back") - if err := s.writeBack(ctx, namespace, d, 0); err != nil { + if err := s.writeBack(namespace, d, 0); err != nil { log.With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to ensure write-back on conflict: %s", err) return err } @@ -720,7 +719,7 @@ func (s *Server) startClusterUploadHandler(w http.ResponseWriter, r *http.Reques uid, err := s.uploader.start(d) if err != nil { log.With("namespace", namespace, "digest", d.Hex()).Warnf("Failed to start cluster upload: %s", err) - return s.handleUploadConflict(r.Context(), err, namespace, d) + return s.handleUploadConflict(err, namespace, d) } setUploadLocation(w, uid) w.WriteHeader(http.StatusOK) @@ -749,7 +748,7 @@ func (s *Server) patchClusterUploadHandler(w http.ResponseWriter, r *http.Reques log.With("namespace", namespace, "digest", d.Hex(), "uid", uid, "start", start, "end", end).Debug("Patching cluster upload chunk") if err := s.uploader.patch(d, uid, r.Body, start, end); err != nil { log.With("namespace", namespace, "digest", d.Hex(), "uid", uid).Errorf("Failed to patch cluster upload: %s", err) - return s.handleUploadConflict(r.Context(), err, namespace, d) + return s.handleUploadConflict(err, namespace, d) } log.With("namespace", namespace, "digest", d.Hex(), "uid", uid, "start", start, "end", end).Debug("Successfully patched upload chunk") return nil @@ -775,9 +774,9 @@ func (s *Server) commitClusterUploadHandler(w http.ResponseWriter, r *http.Reque log.With("namespace", namespace, "digest", d.Hex(), "uid", uid).Info("Committing cluster upload") if err := s.uploader.commit(d, uid); err != nil { log.With("namespace", namespace, "digest", d.Hex(), "uid", uid).Errorf("Failed to commit cluster upload: %s", err) - return s.handleUploadConflict(r.Context(), err, namespace, d) + return s.handleUploadConflict(err, namespace, d) } - if err := s.writeBack(r.Context(), namespace, d, 0); err != nil { + if err := s.writeBack(namespace, d, 0); err != nil { log.With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to write back blob: %s", err) return err } @@ -843,7 +842,7 @@ func (s *Server) duplicateCommitClusterUploadHandler(w http.ResponseWriter, r *h log.With("namespace", namespace, "digest", d.Hex(), "uid", uid).Errorf("Failed to commit duplicate upload: %s", err) return err } - if err := s.writeBack(r.Context(), namespace, d, delay); err != nil { + if err := s.writeBack(namespace, d, delay); err != nil { log.With("namespace", namespace, "digest", d.Hex(), "delay", delay).Errorf("Failed to write back duplicate: %s", err) return err } @@ -851,13 +850,13 @@ func (s *Server) duplicateCommitClusterUploadHandler(w http.ResponseWriter, r *h return nil } -func (s *Server) writeBack(ctx context.Context, namespace string, d core.Digest, delay time.Duration) error { +func (s *Server) writeBack(namespace string, d core.Digest, delay time.Duration) error { log.With("namespace", namespace, "digest", d.Hex(), "delay", delay).Debug("Starting write-back process") if _, err := s.cas.SetCacheFileMetadata(d.Hex(), metadata.NewPersist(true)); err != nil { log.With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to set persist metadata: %s", err) return handler.Errorf("set persist metadata: %s", err) } - task := writeback.NewTaskWithContext(ctx, namespace, d.Hex(), delay) + task := writeback.NewTask(namespace, d.Hex(), delay) if err := s.writeBackManager.Add(task); err != nil { log.With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to add write-back task: %s", err) return handler.Errorf("add write-back task: %s", err) diff --git a/origin/cmd/cmd.go b/origin/cmd/cmd.go index 05b8d6724..4c8c1537c 100644 --- a/origin/cmd/cmd.go +++ b/origin/cmd/cmd.go @@ -46,7 +46,6 @@ import ( "github.com/andres-erbsen/clock" "github.com/go-chi/chi" "github.com/uber-go/tally" - "go.opentelemetry.io/otel" "go.uber.org/zap" ) @@ -203,12 +202,11 @@ func Run(flags *Flags, opts ...Option) { log.Fatalf("Error creating local db: %s", err) } - tracer := otel.Tracer("kraken-origin") writeBackManager, err := persistedretry.NewManager( config.WriteBack, stats, writeback.NewStore(localDB), - writeback.NewExecutor(stats, cas, backendManager, tracer)) + writeback.NewExecutor(stats, cas, backendManager)) if err != nil { log.Fatalf("Error creating write-back manager: %s", err) } From fceac88ab499d63bc365b52bb8d4f9424ff06ac3 Mon Sep 17 00:00:00 2001 From: hweawer Date: Tue, 20 Jan 2026 14:56:57 +0100 Subject: [PATCH 07/32] Revert mock --- build-index/tagserver/server_test.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/build-index/tagserver/server_test.go b/build-index/tagserver/server_test.go index 2e5ec3826..b6de3ff8b 100644 --- a/build-index/tagserver/server_test.go +++ b/build-index/tagserver/server_test.go @@ -231,7 +231,7 @@ func TestPut(t *testing.T) { mocks.depResolver.EXPECT().Resolve(tag, digest).Return(core.DigestList{digest}, nil) mocks.originClient.EXPECT().Stat(tag, digest).Return(core.NewBlobInfo(256), nil) - mocks.store.EXPECT().Put(gomock.Any(), tag, digest, time.Duration(0)).Return(nil) + mocks.store.EXPECT().Put(tag, digest, time.Duration(0)).Return(nil) mocks.provider.EXPECT().Provide(_testNeighbor).Return(neighborClient) neighborClient.EXPECT().DuplicatePut( tag, digest, mocks.config.DuplicateReplicateStagger).Return(nil) @@ -294,7 +294,7 @@ func TestDuplicatePut(t *testing.T) { digest := core.DigestFixture() delay := 5 * time.Minute - mocks.store.EXPECT().Put(gomock.Any(), tag, digest, delay).Return(nil) + mocks.store.EXPECT().Put(tag, digest, delay).Return(nil) require.NoError(client.DuplicatePut(tag, digest, delay)) } @@ -541,7 +541,7 @@ func TestPutAndReplicate(t *testing.T) { gomock.InOrder( mocks.depResolver.EXPECT().Resolve(tag, digest).Return(core.DigestList{digest}, nil), mocks.originClient.EXPECT().Stat(tag, digest).Return(core.NewBlobInfo(256), nil), - mocks.store.EXPECT().Put(gomock.Any(), tag, digest, time.Duration(0)).Return(nil), + mocks.store.EXPECT().Put(tag, digest, time.Duration(0)).Return(nil), mocks.provider.EXPECT().Provide(_testNeighbor).Return(neighborClient), neighborClient.EXPECT().DuplicatePut( tag, digest, mocks.config.DuplicateReplicateStagger).Return(nil), From 299db879b0afa93a9260de92900562bbb7aba3f8 Mon Sep 17 00:00:00 2001 From: hweawer Date: Tue, 20 Jan 2026 14:59:38 +0100 Subject: [PATCH 08/32] Update --- build-index/tagserver/server.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build-index/tagserver/server.go b/build-index/tagserver/server.go index 34ca53d5c..d2ae3484e 100644 --- a/build-index/tagserver/server.go +++ b/build-index/tagserver/server.go @@ -139,7 +139,7 @@ func (s *Server) Handler() http.Handler { "/internal/duplicate/remotes/tags/{tag}/digest/{digest}", handler.Wrap(s.duplicateReplicateTagHandler)) - r.With(tracingMiddleware).Put( + r.Put( "/internal/duplicate/tags/{tag}/digest/{digest}", handler.Wrap(s.duplicatePutTagHandler)) From c26711895255f4f6be73af52f329a03ca7c79d01 Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 26 Jan 2026 10:56:40 +0100 Subject: [PATCH 09/32] Remove changes to executor --- lib/persistedretry/writeback/executor.go | 104 ++---------------- lib/persistedretry/writeback/executor_test.go | 1 - 2 files changed, 10 insertions(+), 95 deletions(-) diff --git a/lib/persistedretry/writeback/executor.go b/lib/persistedretry/writeback/executor.go index 009256083..4b4105ed1 100644 --- a/lib/persistedretry/writeback/executor.go +++ b/lib/persistedretry/writeback/executor.go @@ -14,24 +14,17 @@ package writeback import ( - "context" "fmt" "os" "time" "github.com/uber-go/tally" - "github.com/uber/kraken/lib/backend" "github.com/uber/kraken/lib/persistedretry" "github.com/uber/kraken/lib/store" "github.com/uber/kraken/lib/store/metadata" "github.com/uber/kraken/utils/closers" "github.com/uber/kraken/utils/log" - - "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/trace" ) // FileStore defines store operations required for write-back. @@ -45,20 +38,19 @@ type Executor struct { stats tally.Scope fs FileStore backends *backend.Manager - tracer trace.Tracer } // NewExecutor creates a new Executor. func NewExecutor( stats tally.Scope, fs FileStore, - backends *backend.Manager, -) *Executor { + backends *backend.Manager) *Executor { + stats = stats.Tagged(map[string]string{ "module": "writebackexecutor", }) - return &Executor{stats, fs, backends, otel.Tracer("kraken-writeback")} + return &Executor{stats, fs, backends} } // Name returns the executor name. @@ -66,40 +58,6 @@ func (e *Executor) Name() string { return "writeback" } -// buildSpanOptions creates span options for the writeback execution span. -// If the task has trace context from the original request, it adds a span link -// to enable navigation between the async writeback and the original request in Jaeger. -// It also records whether the original request was sampled for debugging. -func buildSpanOptions(t *Task) []trace.SpanStartOption { - opts := []trace.SpanStartOption{ - trace.WithAttributes( - attribute.String("namespace", t.Namespace), - attribute.String("blob.name", t.Name), - attribute.Int("task.failures", t.Failures), - attribute.Int64("task.age_ms", time.Since(t.CreatedAt).Milliseconds()), - ), - } - - if t.HasTraceContext() { - if originSpanCtx := t.SpanContext(); originSpanCtx.IsValid() { - opts = append(opts, - trace.WithLinks(trace.Link{ - SpanContext: originSpanCtx, - Attributes: []attribute.KeyValue{ - attribute.String("link.type", "origin_request"), - }, - }), - trace.WithAttributes( - attribute.String("origin.trace_id", t.TraceID), - attribute.Bool("origin.sampled", originSpanCtx.IsSampled()), - ), - ) - } - } - - return opts -} - // Exec uploads the cache file corresponding to r's digest to the remote backend // that matches r's namespace. func (e *Executor) Exec(r persistedretry.Task) error { @@ -107,59 +65,33 @@ func (e *Executor) Exec(r persistedretry.Task) error { if !ok { return fmt.Errorf("expected *Task, got %T", r) } - - ctx, span := e.tracer.Start(context.Background(), "writeback.exec", buildSpanOptions(t)...) - defer span.End() - - if err := e.upload(ctx, t); err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, err.Error()) + if err := e.upload(t); err != nil { return err } - err := e.fs.DeleteCacheFileMetadata(t.Name, &metadata.Persist{}) if err != nil && !os.IsNotExist(err) { - span.RecordError(err) - span.SetStatus(codes.Error, "delete persist metadata failed") return fmt.Errorf("delete persist metadata: %s", err) } - - span.SetStatus(codes.Ok, "writeback completed") return nil } -func (e *Executor) upload(ctx context.Context, t *Task) error { - ctx, span := e.tracer.Start(ctx, "writeback.upload", - trace.WithAttributes( - attribute.String("blob.name", t.Name), - ), - ) - defer span.End() - +func (e *Executor) upload(t *Task) error { start := time.Now() - log.WithTraceContext(ctx).With("namespace", t.Namespace, "name", t.Name).Info("Uploading cache file to the remote backend") + log.With("namespace", t.Namespace, "name", t.Name).Info("Uploading cache file to the remote backend") client, err := e.backends.GetClient(t.Namespace) if err != nil { if err == backend.ErrNamespaceNotFound { - log.WithTraceContext(ctx).With( + log.With( "namespace", t.Namespace, "name", t.Name).Info("Dropping writeback for unconfigured namespace") - span.SetAttributes(attribute.Bool("upload.dropped", true)) - span.SetAttributes(attribute.String("upload.drop_reason", "namespace_not_found")) return nil } - span.RecordError(err) - span.SetStatus(codes.Error, "get client failed") return fmt.Errorf("get client: %s", err) } - // Check if already uploaded (stat check) if _, err := client.Stat(t.Namespace, t.Name); err == nil { // File already uploaded, no-op. - log.WithTraceContext(ctx).With("namespace", t.Namespace, "name", t.Name).Debug("Blob already exists in backend, skipping upload") - span.SetAttributes(attribute.Bool("upload.skipped", true)) - span.SetAttributes(attribute.String("upload.skip_reason", "already_exists")) return nil } @@ -168,36 +100,20 @@ func (e *Executor) upload(ctx context.Context, t *Task) error { if os.IsNotExist(err) { // Nothing we can do about this but make noise and drop the task. e.stats.Counter("missing_files").Inc(1) - log.WithTraceContext(ctx).With("name", t.Name).Error("Invariant violation: writeback cache file missing") - span.SetAttributes(attribute.Bool("upload.dropped", true)) - span.SetAttributes(attribute.String("upload.drop_reason", "file_missing")) - span.RecordError(err) + log.With("name", t.Name).Error("Invariant violation: writeback cache file missing") return nil } - span.RecordError(err) - span.SetStatus(codes.Error, "get file failed") return fmt.Errorf("get file: %s", err) } defer closers.Close(f) if err := client.Upload(t.Namespace, t.Name, f); err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, "upload failed") return fmt.Errorf("upload: %s", err) } - - uploadDuration := time.Since(start) - log.WithTraceContext(ctx).With("namespace", t.Namespace, "name", t.Name, "duration_ms", uploadDuration.Milliseconds()).Info("Uploaded cache file to remote backend") - - span.SetAttributes( - attribute.Int64("upload.duration_ms", uploadDuration.Milliseconds()), - attribute.Int64("task.lifetime_ms", time.Since(t.CreatedAt).Milliseconds()), - attribute.Bool("upload.success", true), - ) - span.SetStatus(codes.Ok, "upload completed") + log.With("namespace", t.Namespace, "name", t.Name).Info("Uploaded cache file to remote backend") // We don't want to time noops nor errors. - e.stats.Timer("upload").Record(uploadDuration) + e.stats.Timer("upload").Record(time.Since(start)) e.stats.Timer("lifetime").Record(time.Since(t.CreatedAt)) return nil diff --git a/lib/persistedretry/writeback/executor_test.go b/lib/persistedretry/writeback/executor_test.go index 4a39ea9e2..bfa652cab 100644 --- a/lib/persistedretry/writeback/executor_test.go +++ b/lib/persistedretry/writeback/executor_test.go @@ -29,7 +29,6 @@ import ( mockbackend "github.com/uber/kraken/mocks/lib/backend" "github.com/uber/kraken/utils/mockutil" "github.com/uber/kraken/utils/testutil" - "go.opentelemetry.io/otel" ) type executorMocks struct { From ce87a862629985a79020efab3e6042783f9d4aab Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 26 Jan 2026 11:04:13 +0100 Subject: [PATCH 10/32] Separate DB operations --- lib/persistedretry/writeback/store.go | 14 ++-- localdb/migrations/00003_writeback_tracing.go | 64 ------------------- 2 files changed, 4 insertions(+), 74 deletions(-) delete mode 100644 localdb/migrations/00003_writeback_tracing.go diff --git a/lib/persistedretry/writeback/store.go b/lib/persistedretry/writeback/store.go index d4c6758c9..29aea16a4 100644 --- a/lib/persistedretry/writeback/store.go +++ b/lib/persistedretry/writeback/store.go @@ -122,7 +122,7 @@ func (s *Store) Find(query interface{}) ([]persistedretry.Task, error) { switch q := query.(type) { case *NameQuery: err = s.db.Select(&tasks, ` - SELECT namespace, name, created_at, last_attempt, failures, delay, trace_id, span_id, trace_flags + SELECT namespace, name, created_at, last_attempt, failures, delay FROM writeback_task WHERE name=? `, q.name) @@ -143,20 +143,14 @@ func (s *Store) addWithStatus(r persistedretry.Task, status string) error { last_attempt, failures, delay, - status, - trace_id, - span_id, - trace_flags + status ) VALUES ( :namespace, :name, :last_attempt, :failures, :delay, - %q, - :trace_id, - :span_id, - :trace_flags + %q ) `, status) t, ok := r.(*Task) @@ -175,7 +169,7 @@ func (s *Store) addWithStatus(r persistedretry.Task, status string) error { func (s *Store) selectStatus(status string) ([]persistedretry.Task, error) { var tasks []*Task err := s.db.Select(&tasks, ` - SELECT namespace, name, created_at, last_attempt, failures, delay, trace_id, span_id, trace_flags + SELECT namespace, name, created_at, last_attempt, failures, delay FROM writeback_task WHERE status=? `, status) diff --git a/localdb/migrations/00003_writeback_tracing.go b/localdb/migrations/00003_writeback_tracing.go deleted file mode 100644 index 2aff4d0ce..000000000 --- a/localdb/migrations/00003_writeback_tracing.go +++ /dev/null @@ -1,64 +0,0 @@ -// Copyright (c) 2016-2019 Uber Technologies, Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -package migrations - -import ( - "database/sql" - - "github.com/pressly/goose" -) - -func init() { - goose.AddMigration(up00003, down00003) -} - -func up00003(tx *sql.Tx) error { - // Add trace_id, span_id, and trace_flags columns for linking async writeback to original request trace - _, err := tx.Exec(` - ALTER TABLE writeback_task ADD COLUMN trace_id text DEFAULT ''; - `) - if err != nil { - return err - } - _, err = tx.Exec(` - ALTER TABLE writeback_task ADD COLUMN span_id text DEFAULT ''; - `) - if err != nil { - return err - } - _, err = tx.Exec(` - ALTER TABLE writeback_task ADD COLUMN trace_flags text DEFAULT ''; - `) - return err -} - -func down00003(tx *sql.Tx) error { - _, err := tx.Exec(` - CREATE TABLE writeback_task_backup AS SELECT namespace, name, created_at, last_attempt, status, failures, delay FROM writeback_task; - DROP TABLE writeback_task; - CREATE TABLE writeback_task ( - namespace text NOT NULL, - name text NOT NULL, - created_at timestamp DEFAULT CURRENT_TIMESTAMP, - last_attempt timestamp NOT NULL, - status text NOT NULL, - failures integer NOT NULL, - delay integer NOT NULL, - PRIMARY KEY(namespace, name) - ); - INSERT INTO writeback_task SELECT * FROM writeback_task_backup; - DROP TABLE writeback_task_backup; - `) - return err -} From ed5ea031450fbfaf7581bff30e2a0b68643cbbed Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 26 Jan 2026 11:07:56 +0100 Subject: [PATCH 11/32] DecodeString --- lib/persistedretry/writeback/store.go | 2 +- lib/persistedretry/writeback/task.go | 17 +++-------------- 2 files changed, 4 insertions(+), 15 deletions(-) diff --git a/lib/persistedretry/writeback/store.go b/lib/persistedretry/writeback/store.go index 29aea16a4..3496a2ea5 100644 --- a/lib/persistedretry/writeback/store.go +++ b/lib/persistedretry/writeback/store.go @@ -30,7 +30,7 @@ type Store struct { } // NewStore creates a new Store. -func NewStore(db *sqlx.DB) *Store { +func sNewStore(db *sqlx.DB) *Store { return &Store{db} } diff --git a/lib/persistedretry/writeback/task.go b/lib/persistedretry/writeback/task.go index c27eaf6a1..155f3a13c 100644 --- a/lib/persistedretry/writeback/task.go +++ b/lib/persistedretry/writeback/task.go @@ -110,22 +110,11 @@ func (t *Task) SpanContext() trace.SpanContext { // parseHexByte parses a hex string (e.g., "01") to a byte. func parseHexByte(s string) byte { - if len(s) != 2 { + b, err := hex.DecodeString(s) + if err != nil || len(b) != 1 { return 0 } - var b byte - for _, c := range s { - b <<= 4 - switch { - case c >= '0' && c <= '9': - b |= byte(c - '0') - case c >= 'a' && c <= 'f': - b |= byte(c - 'a' + 10) - case c >= 'A' && c <= 'F': - b |= byte(c - 'A' + 10) - } - } - return b + return b[0] } // IsSampled returns true if the original request was sampled. From ff8f723466297a694b66efb6e3177248642571e1 Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 26 Jan 2026 11:08:54 +0100 Subject: [PATCH 12/32] Fix typo --- lib/persistedretry/writeback/store.go | 2 +- lib/persistedretry/writeback/task.go | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/lib/persistedretry/writeback/store.go b/lib/persistedretry/writeback/store.go index 3496a2ea5..29aea16a4 100644 --- a/lib/persistedretry/writeback/store.go +++ b/lib/persistedretry/writeback/store.go @@ -30,7 +30,7 @@ type Store struct { } // NewStore creates a new Store. -func sNewStore(db *sqlx.DB) *Store { +func NewStore(db *sqlx.DB) *Store { return &Store{db} } diff --git a/lib/persistedretry/writeback/task.go b/lib/persistedretry/writeback/task.go index 155f3a13c..c897ccc9b 100644 --- a/lib/persistedretry/writeback/task.go +++ b/lib/persistedretry/writeback/task.go @@ -15,11 +15,13 @@ package writeback import ( "context" + "encoding/hex" "fmt" "time" - "github.com/uber/kraken/core" "go.opentelemetry.io/otel/trace" + + "github.com/uber/kraken/core" ) // Task contains information to write back a blob to remote storage. From 0441e8af103dd6d03bec1563981587c6c76e263c Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 26 Jan 2026 11:15:39 +0100 Subject: [PATCH 13/32] Database persistence for writeback trace context --- lib/persistedretry/writeback/store.go | 14 ++-- localdb/migrations/00003_writeback_tracing.go | 64 +++++++++++++++++++ 2 files changed, 74 insertions(+), 4 deletions(-) create mode 100644 localdb/migrations/00003_writeback_tracing.go diff --git a/lib/persistedretry/writeback/store.go b/lib/persistedretry/writeback/store.go index 29aea16a4..d4c6758c9 100644 --- a/lib/persistedretry/writeback/store.go +++ b/lib/persistedretry/writeback/store.go @@ -122,7 +122,7 @@ func (s *Store) Find(query interface{}) ([]persistedretry.Task, error) { switch q := query.(type) { case *NameQuery: err = s.db.Select(&tasks, ` - SELECT namespace, name, created_at, last_attempt, failures, delay + SELECT namespace, name, created_at, last_attempt, failures, delay, trace_id, span_id, trace_flags FROM writeback_task WHERE name=? `, q.name) @@ -143,14 +143,20 @@ func (s *Store) addWithStatus(r persistedretry.Task, status string) error { last_attempt, failures, delay, - status + status, + trace_id, + span_id, + trace_flags ) VALUES ( :namespace, :name, :last_attempt, :failures, :delay, - %q + %q, + :trace_id, + :span_id, + :trace_flags ) `, status) t, ok := r.(*Task) @@ -169,7 +175,7 @@ func (s *Store) addWithStatus(r persistedretry.Task, status string) error { func (s *Store) selectStatus(status string) ([]persistedretry.Task, error) { var tasks []*Task err := s.db.Select(&tasks, ` - SELECT namespace, name, created_at, last_attempt, failures, delay + SELECT namespace, name, created_at, last_attempt, failures, delay, trace_id, span_id, trace_flags FROM writeback_task WHERE status=? `, status) diff --git a/localdb/migrations/00003_writeback_tracing.go b/localdb/migrations/00003_writeback_tracing.go new file mode 100644 index 000000000..2aff4d0ce --- /dev/null +++ b/localdb/migrations/00003_writeback_tracing.go @@ -0,0 +1,64 @@ +// Copyright (c) 2016-2019 Uber Technologies, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +package migrations + +import ( + "database/sql" + + "github.com/pressly/goose" +) + +func init() { + goose.AddMigration(up00003, down00003) +} + +func up00003(tx *sql.Tx) error { + // Add trace_id, span_id, and trace_flags columns for linking async writeback to original request trace + _, err := tx.Exec(` + ALTER TABLE writeback_task ADD COLUMN trace_id text DEFAULT ''; + `) + if err != nil { + return err + } + _, err = tx.Exec(` + ALTER TABLE writeback_task ADD COLUMN span_id text DEFAULT ''; + `) + if err != nil { + return err + } + _, err = tx.Exec(` + ALTER TABLE writeback_task ADD COLUMN trace_flags text DEFAULT ''; + `) + return err +} + +func down00003(tx *sql.Tx) error { + _, err := tx.Exec(` + CREATE TABLE writeback_task_backup AS SELECT namespace, name, created_at, last_attempt, status, failures, delay FROM writeback_task; + DROP TABLE writeback_task; + CREATE TABLE writeback_task ( + namespace text NOT NULL, + name text NOT NULL, + created_at timestamp DEFAULT CURRENT_TIMESTAMP, + last_attempt timestamp NOT NULL, + status text NOT NULL, + failures integer NOT NULL, + delay integer NOT NULL, + PRIMARY KEY(namespace, name) + ); + INSERT INTO writeback_task SELECT * FROM writeback_task_backup; + DROP TABLE writeback_task_backup; + `) + return err +} From 98587d65d526bce19db81e5694779d46e48bfe5e Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 26 Jan 2026 11:54:54 +0100 Subject: [PATCH 14/32] feat(origin): add tracing to blob upload handlers --- origin/blobserver/server.go | 124 ++++++++++++++++++++++++++++++++---- 1 file changed, 111 insertions(+), 13 deletions(-) diff --git a/origin/blobserver/server.go b/origin/blobserver/server.go index 51381732b..a4cb55ea7 100644 --- a/origin/blobserver/server.go +++ b/origin/blobserver/server.go @@ -14,6 +14,7 @@ package blobserver import ( + "context" "encoding/json" "fmt" "io" @@ -47,6 +48,11 @@ import ( "github.com/uber/kraken/utils/listener" "github.com/uber/kraken/utils/log" "github.com/uber/kraken/utils/stringset" + + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/codes" + "go.opentelemetry.io/otel/trace" ) const _operation = "operation" @@ -67,6 +73,7 @@ type Server struct { metaInfoGenerator *metainfogen.Generator uploader *uploader writeBackManager persistedretry.Manager + tracer trace.Tracer // This is an unfortunate coupling between the p2p client and the blob server. // Tracker queries the origin cluster to discover which origins can seed @@ -112,6 +119,7 @@ func New( metaInfoGenerator: metaInfoGenerator, uploader: newUploader(cas), writeBackManager: writeBackManager, + tracer: otel.Tracer("kraken-origin"), pctx: pctx, }, nil } @@ -707,50 +715,105 @@ func (s *Server) handleUploadConflict(err error, namespace string, d core.Digest // startClusterUploadHandler initializes an upload for external uploads. func (s *Server) startClusterUploadHandler(w http.ResponseWriter, r *http.Request) error { + ctx, span := s.tracer.Start(r.Context(), "origin.start_upload", + trace.WithSpanKind(trace.SpanKindServer), + trace.WithAttributes( + attribute.String("component", "origin"), + attribute.String("operation", "start_cluster_upload"), + ), + ) + defer span.End() + d, err := httputil.ParseDigest(r, "digest") if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, "parse digest failed") return err } namespace, err := httputil.ParseParam(r, "namespace") if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, "parse namespace failed") return err } - log.With("namespace", namespace, "digest", d.Hex()).Info("Starting cluster upload") + + span.SetAttributes( + attribute.String("namespace", namespace), + attribute.String("blob.digest", d.Hex()), + ) + + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex()).Info("Starting cluster upload") uid, err := s.uploader.start(d) if err != nil { - log.With("namespace", namespace, "digest", d.Hex()).Warnf("Failed to start cluster upload: %s", err) + span.RecordError(err) + span.SetStatus(codes.Error, "start upload failed") + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex()).Warnf("Failed to start cluster upload: %s", err) return s.handleUploadConflict(err, namespace, d) } + + span.SetAttributes(attribute.String("upload.uid", uid)) setUploadLocation(w, uid) w.WriteHeader(http.StatusOK) - log.With("namespace", namespace, "digest", d.Hex(), "uid", uid).Info("Successfully started cluster upload") + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "uid", uid).Info("Successfully started cluster upload") + span.SetStatus(codes.Ok, "upload started") return nil } // patchClusterUploadHandler uploads a chunk of a blob for external uploads. func (s *Server) patchClusterUploadHandler(w http.ResponseWriter, r *http.Request) error { + ctx, span := s.tracer.Start(r.Context(), "origin.patch_upload", + trace.WithSpanKind(trace.SpanKindServer), + trace.WithAttributes( + attribute.String("component", "origin"), + attribute.String("operation", "patch_cluster_upload"), + ), + ) + defer span.End() + d, err := httputil.ParseDigest(r, "digest") if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, "parse digest failed") return err } namespace, err := httputil.ParseParam(r, "namespace") if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, "parse namespace failed") return err } uid, err := httputil.ParseParam(r, "uid") if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, "parse uid failed") return err } start, end, err := parseContentRange(r.Header) if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, "parse content range failed") return err } - log.With("namespace", namespace, "digest", d.Hex(), "uid", uid, "start", start, "end", end).Debug("Patching cluster upload chunk") + + chunkSize := end - start + span.SetAttributes( + attribute.String("namespace", namespace), + attribute.String("blob.digest", d.Hex()), + attribute.String("upload.uid", uid), + attribute.Int64("upload.chunk_start", start), + attribute.Int64("upload.chunk_end", end), + attribute.Int64("upload.chunk_size", chunkSize), + ) + + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "uid", uid, "start", start, "end", end).Debug("Patching cluster upload chunk") if err := s.uploader.patch(d, uid, r.Body, start, end); err != nil { - log.With("namespace", namespace, "digest", d.Hex(), "uid", uid).Errorf("Failed to patch cluster upload: %s", err) + span.RecordError(err) + span.SetStatus(codes.Error, "patch upload failed") + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "uid", uid).Errorf("Failed to patch cluster upload: %s", err) return s.handleUploadConflict(err, namespace, d) } - log.With("namespace", namespace, "digest", d.Hex(), "uid", uid, "start", start, "end", end).Debug("Successfully patched upload chunk") + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "uid", uid, "start", start, "end", end).Debug("Successfully patched upload chunk") + span.SetStatus(codes.Ok, "chunk uploaded") return nil } @@ -758,37 +821,66 @@ func (s *Server) patchClusterUploadHandler(w http.ResponseWriter, r *http.Reques // meaning the blob will be written back to remote storage in a non-blocking // fashion. func (s *Server) commitClusterUploadHandler(w http.ResponseWriter, r *http.Request) error { + ctx, span := s.tracer.Start(r.Context(), "origin.commit_upload", + trace.WithSpanKind(trace.SpanKindServer), + trace.WithAttributes( + attribute.String("component", "origin"), + attribute.String("operation", "commit_cluster_upload"), + ), + ) + defer span.End() + d, err := httputil.ParseDigest(r, "digest") if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, "parse digest failed") return err } namespace, err := httputil.ParseParam(r, "namespace") if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, "parse namespace failed") return err } uid, err := httputil.ParseParam(r, "uid") if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, "parse uid failed") return err } - log.With("namespace", namespace, "digest", d.Hex(), "uid", uid).Info("Committing cluster upload") + span.SetAttributes( + attribute.String("namespace", namespace), + attribute.String("blob.digest", d.Hex()), + attribute.String("upload.uid", uid), + ) + + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "uid", uid).Info("Committing cluster upload") if err := s.uploader.commit(d, uid); err != nil { - log.With("namespace", namespace, "digest", d.Hex(), "uid", uid).Errorf("Failed to commit cluster upload: %s", err) + span.RecordError(err) + span.SetStatus(codes.Error, "commit upload failed") + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "uid", uid).Errorf("Failed to commit cluster upload: %s", err) return s.handleUploadConflict(err, namespace, d) } + + // Note: Trace context propagation to writeback task will be added in a future commit if err := s.writeBack(namespace, d, 0); err != nil { - log.With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to write back blob: %s", err) + span.RecordError(err) + span.SetStatus(codes.Error, "writeback initiation failed") + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to write back blob: %s", err) return err } + // Get blob size for replication logging fi, err := s.cas.GetCacheFileStat(d.Hex()) var blobSize int64 if err == nil { blobSize = fi.Size() } + span.SetAttributes(attribute.Int64("blob.size_bytes", blobSize)) replicateStart := time.Now() - log.With("namespace", namespace, "digest", d.Hex(), "size_bytes", blobSize).Debug("Replicating upload to other origins") + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "size_bytes", blobSize).Debug("Replicating upload to other origins") err = s.applyToReplicas(d, func(i int, client blobclient.Client) error { replicaStart := time.Now() delay := s.config.DuplicateWriteBackStagger * time.Duration(i+1) @@ -805,12 +897,18 @@ func (s *Server) commitClusterUploadHandler(w http.ResponseWriter, r *http.Reque log.With("namespace", namespace, "digest", d.Hex(), "replica", client.Addr(), "size_bytes", blobSize, "duration_s", duration.Seconds()).Debug("Successfully duplicated upload") return nil }) + replicateDuration := time.Since(replicateStart) + span.SetAttributes(attribute.Int64("replication.duration_ms", replicateDuration.Milliseconds())) + if err != nil { s.metrics.duplicateWritebackErrors.Inc(1) - replicateDuration := time.Since(replicateStart) - log.With("namespace", namespace, "digest", d.Hex(), "replication_duration_m", replicateDuration.Seconds()).Errorf("Error duplicating write-back task to replicas: %s", err) + span.RecordError(err) + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "replication_duration_ms", replicateDuration.Milliseconds()).Errorf("Error duplicating write-back task to replicas: %s", err) + // Don't fail the commit if replication fails - blob is still uploaded } - log.With("namespace", namespace, "digest", d.Hex()).Info("Successfully committed cluster upload") + + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex()).Info("Successfully committed cluster upload") + span.SetStatus(codes.Ok, "upload committed and replicated") return nil } From 25aac666fd09c8e1baf165fa0cd32c4faccbb8b9 Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 26 Jan 2026 11:58:25 +0100 Subject: [PATCH 15/32] Remove context import --- origin/blobserver/server.go | 1 - 1 file changed, 1 deletion(-) diff --git a/origin/blobserver/server.go b/origin/blobserver/server.go index a4cb55ea7..cec6ec946 100644 --- a/origin/blobserver/server.go +++ b/origin/blobserver/server.go @@ -14,7 +14,6 @@ package blobserver import ( - "context" "encoding/json" "fmt" "io" From d432533591607889cd4ac4b5fb83b3a4d316cf09 Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 26 Jan 2026 12:32:36 +0100 Subject: [PATCH 16/32] otel middleware --- origin/blobserver/server.go | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/origin/blobserver/server.go b/origin/blobserver/server.go index cec6ec946..d5ed95e41 100644 --- a/origin/blobserver/server.go +++ b/origin/blobserver/server.go @@ -48,6 +48,7 @@ import ( "github.com/uber/kraken/utils/log" "github.com/uber/kraken/utils/stringset" + "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/codes" @@ -135,6 +136,9 @@ func (s *Server) Handler() http.Handler { r.Use(middleware.StatusCounter(s.stats)) r.Use(middleware.LatencyTimer(s.stats)) + tracingMiddleware := otelhttp.NewMiddleware("kraken-origin", + otelhttp.WithTracerProvider(otel.GetTracerProvider())) + // Public endpoints: r.Get("/health", handler.Wrap(s.healthCheckHandler)) @@ -142,9 +146,9 @@ func (s *Server) Handler() http.Handler { r.Get("/blobs/{digest}/locations", handler.Wrap(s.getLocationsHandler)) - r.Post("/namespace/{namespace}/blobs/{digest}/uploads", handler.Wrap(s.startClusterUploadHandler)) - r.Patch("/namespace/{namespace}/blobs/{digest}/uploads/{uid}", handler.Wrap(s.patchClusterUploadHandler)) - r.Put("/namespace/{namespace}/blobs/{digest}/uploads/{uid}", handler.Wrap(s.commitClusterUploadHandler)) + r.With(tracingMiddleware).Post("/namespace/{namespace}/blobs/{digest}/uploads", handler.Wrap(s.startClusterUploadHandler)) + r.With(tracingMiddleware).Patch("/namespace/{namespace}/blobs/{digest}/uploads/{uid}", handler.Wrap(s.patchClusterUploadHandler)) + r.With(tracingMiddleware).Put("/namespace/{namespace}/blobs/{digest}/uploads/{uid}", handler.Wrap(s.commitClusterUploadHandler)) r.Get("/namespace/{namespace}/blobs/{digest}", handler.Wrap(s.downloadBlobHandler)) r.Post("/namespace/{namespace}/blobs/{digest}/prefetch", handler.Wrap(s.prefetchBlobHandler)) From f2c8b22ea5cd944b44c2e19c1e4b61430a928928 Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 26 Jan 2026 12:54:10 +0100 Subject: [PATCH 17/32] feat(tracing): propagate trace context to writeback tasks in build-index and origin --- build-index/tagserver/server.go | 11 ++++--- build-index/tagserver/server_test.go | 6 ++-- build-index/tagstore/store.go | 12 +++++-- mocks/build-index/tagstore/store.go | 9 ++--- origin/blobserver/server.go | 49 ++++++++++++++++------------ 5 files changed, 51 insertions(+), 36 deletions(-) diff --git a/build-index/tagserver/server.go b/build-index/tagserver/server.go index d2ae3484e..52720fd6f 100644 --- a/build-index/tagserver/server.go +++ b/build-index/tagserver/server.go @@ -259,14 +259,15 @@ func (s *Server) duplicatePutTagHandler(w http.ResponseWriter, r *http.Request) } delay := req.Delay - log.With("tag", tag, "digest", d.String(), "delay", delay).Debug("Received duplicate put request from neighbor") + ctx := r.Context() + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "delay", delay).Debug("Received duplicate put request from neighbor") - if err := s.store.Put(tag, d, delay); err != nil { - log.With("tag", tag, "digest", d.String(), "delay", delay, "error", err).Error("Failed to store tag from duplicate put") + if err := s.store.Put(ctx, tag, d, delay); err != nil { + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "delay", delay, "error", err).Error("Failed to store tag from duplicate put") return handler.Errorf("storage: %s", err) } - log.With("tag", tag, "digest", d.String(), "delay", delay).Info("Successfully stored tag from duplicate put") + log.WithTraceContext(ctx).With("tag", tag, "digest", d.String(), "delay", delay).Info("Successfully stored tag from duplicate put") w.WriteHeader(http.StatusOK) return nil @@ -505,7 +506,7 @@ func (s *Server) putTag(ctx context.Context, tag string, d core.Digest, deps cor log.WithTraceContext(ctx).With("tag", tag, "digest", d.String()).Debug("All dependencies validated successfully") - if err := s.store.Put(tag, d, 0); err != nil { + if err := s.store.Put(ctx, tag, d, 0); err != nil { return fmt.Errorf("storage: %w", err) } diff --git a/build-index/tagserver/server_test.go b/build-index/tagserver/server_test.go index b6de3ff8b..2e5ec3826 100644 --- a/build-index/tagserver/server_test.go +++ b/build-index/tagserver/server_test.go @@ -231,7 +231,7 @@ func TestPut(t *testing.T) { mocks.depResolver.EXPECT().Resolve(tag, digest).Return(core.DigestList{digest}, nil) mocks.originClient.EXPECT().Stat(tag, digest).Return(core.NewBlobInfo(256), nil) - mocks.store.EXPECT().Put(tag, digest, time.Duration(0)).Return(nil) + mocks.store.EXPECT().Put(gomock.Any(), tag, digest, time.Duration(0)).Return(nil) mocks.provider.EXPECT().Provide(_testNeighbor).Return(neighborClient) neighborClient.EXPECT().DuplicatePut( tag, digest, mocks.config.DuplicateReplicateStagger).Return(nil) @@ -294,7 +294,7 @@ func TestDuplicatePut(t *testing.T) { digest := core.DigestFixture() delay := 5 * time.Minute - mocks.store.EXPECT().Put(tag, digest, delay).Return(nil) + mocks.store.EXPECT().Put(gomock.Any(), tag, digest, delay).Return(nil) require.NoError(client.DuplicatePut(tag, digest, delay)) } @@ -541,7 +541,7 @@ func TestPutAndReplicate(t *testing.T) { gomock.InOrder( mocks.depResolver.EXPECT().Resolve(tag, digest).Return(core.DigestList{digest}, nil), mocks.originClient.EXPECT().Stat(tag, digest).Return(core.NewBlobInfo(256), nil), - mocks.store.EXPECT().Put(tag, digest, time.Duration(0)).Return(nil), + mocks.store.EXPECT().Put(gomock.Any(), tag, digest, time.Duration(0)).Return(nil), mocks.provider.EXPECT().Provide(_testNeighbor).Return(neighborClient), neighborClient.EXPECT().DuplicatePut( tag, digest, mocks.config.DuplicateReplicateStagger).Return(nil), diff --git a/build-index/tagstore/store.go b/build-index/tagstore/store.go index a959fdd53..bbaa18502 100644 --- a/build-index/tagstore/store.go +++ b/build-index/tagstore/store.go @@ -15,6 +15,7 @@ package tagstore import ( "bytes" + "context" "errors" "fmt" "io" @@ -48,7 +49,7 @@ type FileStore interface { // Store defines tag storage operations. type Store interface { - Put(tag string, d core.Digest, writeBackDelay time.Duration) error + Put(ctx context.Context, tag string, d core.Digest, writeBackDelay time.Duration) error Get(tag string) (core.Digest, error) } @@ -95,15 +96,20 @@ func New( return s } -func (s *tagStore) Put(tag string, d core.Digest, writeBackDelay time.Duration) error { +func (s *tagStore) Put(ctx context.Context, tag string, d core.Digest, writeBackDelay time.Duration) error { + log.WithTraceContext(ctx).With("tag", tag, "digest", d.Hex(), "delay", writeBackDelay).Debug("Starting tag put operation") + if err := s.writeTagToDisk(tag, d); err != nil { + log.WithTraceContext(ctx).With("tag", tag, "error", err).Error("Failed to write tag to disk") return fmt.Errorf("write tag to disk: %s", err) } if _, err := s.fs.SetCacheFileMetadata(tag, metadata.NewPersist(true)); err != nil { + log.WithTraceContext(ctx).With("tag", tag, "error", err).Error("Failed to set persist metadata") return fmt.Errorf("set persist metadata: %s", err) } + task := writeback.NewTaskWithContext(ctx, tag, tag, writeBackDelay) + log.WithTraceContext(ctx).With("tag", tag, "has_trace", task.HasTraceContext()).Debug("Created writeback task with trace context") - task := writeback.NewTask(tag, tag, writeBackDelay) return s.writeBackStrategy(task) } diff --git a/mocks/build-index/tagstore/store.go b/mocks/build-index/tagstore/store.go index 2677cb90d..5bd9e8004 100644 --- a/mocks/build-index/tagstore/store.go +++ b/mocks/build-index/tagstore/store.go @@ -5,6 +5,7 @@ package mocktagstore import ( + context "context" reflect "reflect" time "time" @@ -51,15 +52,15 @@ func (mr *MockStoreMockRecorder) Get(arg0 interface{}) *gomock.Call { } // Put mocks base method -func (m *MockStore) Put(arg0 string, arg1 core.Digest, arg2 time.Duration) error { +func (m *MockStore) Put(arg0 context.Context, arg1 string, arg2 core.Digest, arg3 time.Duration) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2, arg3) ret0, _ := ret[0].(error) return ret0 } // Put indicates an expected call of Put -func (mr *MockStoreMockRecorder) Put(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockStoreMockRecorder) Put(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockStore)(nil).Put), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockStore)(nil).Put), arg0, arg1, arg2, arg3) } diff --git a/origin/blobserver/server.go b/origin/blobserver/server.go index d5ed95e41..29dd9fb19 100644 --- a/origin/blobserver/server.go +++ b/origin/blobserver/server.go @@ -14,6 +14,7 @@ package blobserver import ( + "context" "encoding/json" "fmt" "io" @@ -701,15 +702,15 @@ func (s *Server) commitTransferHandler(w http.ResponseWriter, r *http.Request) e return nil } -func (s *Server) handleUploadConflict(err error, namespace string, d core.Digest) error { +func (s *Server) handleUploadConflict(ctx context.Context, err error, namespace string, d core.Digest) error { if herr, ok := err.(*handler.Error); ok && herr.GetStatus() == http.StatusConflict { // Even if the blob was already uploaded and committed to cache, it's // still possible that adding the write-back task failed. Clients short // circuit on conflict and return success, so we must make sure that if we // tell a client to stop before commit, the blob has been written back. - log.With("namespace", namespace, "digest", d.Hex()).Debug("Handling upload conflict, ensuring write-back") - if err := s.writeBack(namespace, d, 0); err != nil { - log.With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to ensure write-back on conflict: %s", err) + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex()).Debug("Handling upload conflict, ensuring write-back") + if err := s.writeBack(ctx, namespace, d, 0); err != nil { + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to ensure write-back on conflict: %s", err) return err } } @@ -751,7 +752,7 @@ func (s *Server) startClusterUploadHandler(w http.ResponseWriter, r *http.Reques span.RecordError(err) span.SetStatus(codes.Error, "start upload failed") log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex()).Warnf("Failed to start cluster upload: %s", err) - return s.handleUploadConflict(err, namespace, d) + return s.handleUploadConflict(ctx, err, namespace, d) } span.SetAttributes(attribute.String("upload.uid", uid)) @@ -813,7 +814,7 @@ func (s *Server) patchClusterUploadHandler(w http.ResponseWriter, r *http.Reques span.RecordError(err) span.SetStatus(codes.Error, "patch upload failed") log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "uid", uid).Errorf("Failed to patch cluster upload: %s", err) - return s.handleUploadConflict(err, namespace, d) + return s.handleUploadConflict(ctx, err, namespace, d) } log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "uid", uid, "start", start, "end", end).Debug("Successfully patched upload chunk") span.SetStatus(codes.Ok, "chunk uploaded") @@ -863,11 +864,10 @@ func (s *Server) commitClusterUploadHandler(w http.ResponseWriter, r *http.Reque span.RecordError(err) span.SetStatus(codes.Error, "commit upload failed") log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "uid", uid).Errorf("Failed to commit cluster upload: %s", err) - return s.handleUploadConflict(err, namespace, d) + return s.handleUploadConflict(ctx, err, namespace, d) } - // Note: Trace context propagation to writeback task will be added in a future commit - if err := s.writeBack(namespace, d, 0); err != nil { + if err := s.writeBack(ctx, namespace, d, 0); err != nil { span.RecordError(err) span.SetStatus(codes.Error, "writeback initiation failed") log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to write back blob: %s", err) @@ -938,35 +938,42 @@ func (s *Server) duplicateCommitClusterUploadHandler(w http.ResponseWriter, r *h } delay := dr.Delay - log.With("namespace", namespace, "digest", d.Hex(), "uid", uid, "delay", delay).Info("Committing duplicate upload") + ctx := r.Context() + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "uid", uid, "delay", delay).Info("Committing duplicate upload") if err := s.uploader.commit(d, uid); err != nil { - log.With("namespace", namespace, "digest", d.Hex(), "uid", uid).Errorf("Failed to commit duplicate upload: %s", err) + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "uid", uid).Errorf("Failed to commit duplicate upload: %s", err) return err } - if err := s.writeBack(namespace, d, delay); err != nil { - log.With("namespace", namespace, "digest", d.Hex(), "delay", delay).Errorf("Failed to write back duplicate: %s", err) + if err := s.writeBack(ctx, namespace, d, delay); err != nil { + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "delay", delay).Errorf("Failed to write back duplicate: %s", err) return err } - log.With("namespace", namespace, "digest", d.Hex(), "delay", delay).Info("Successfully committed duplicate upload") + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "delay", delay).Info("Successfully committed duplicate upload") return nil } -func (s *Server) writeBack(namespace string, d core.Digest, delay time.Duration) error { - log.With("namespace", namespace, "digest", d.Hex(), "delay", delay).Debug("Starting write-back process") +func (s *Server) writeBack(ctx context.Context, namespace string, d core.Digest, delay time.Duration) error { + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "delay", delay).Debug("Starting write-back process") + if _, err := s.cas.SetCacheFileMetadata(d.Hex(), metadata.NewPersist(true)); err != nil { - log.With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to set persist metadata: %s", err) + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to set persist metadata: %s", err) return handler.Errorf("set persist metadata: %s", err) } - task := writeback.NewTask(namespace, d.Hex(), delay) + + task := writeback.NewTaskWithContext(ctx, namespace, d.Hex(), delay) + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "has_trace", task.HasTraceContext()).Debug("Created writeback task with trace context") + if err := s.writeBackManager.Add(task); err != nil { - log.With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to add write-back task: %s", err) + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to add write-back task: %s", err) return handler.Errorf("add write-back task: %s", err) } + if err := s.metaInfoGenerator.Generate(d); err != nil { - log.With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to generate metainfo during write-back: %s", err) + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex()).Errorf("Failed to generate metainfo during write-back: %s", err) return handler.Errorf("generate metainfo: %s", err) } - log.With("namespace", namespace, "digest", d.Hex()).Debug("Successfully scheduled write-back") + + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex()).Debug("Successfully scheduled write-back") return nil } From e0847edcae0eb0e68a2ef76f24c18576e0dffc70 Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 26 Jan 2026 13:02:44 +0100 Subject: [PATCH 18/32] Update tagstore tests --- build-index/tagstore/store_test.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/build-index/tagstore/store_test.go b/build-index/tagstore/store_test.go index c23fe4a02..861137ef8 100644 --- a/build-index/tagstore/store_test.go +++ b/build-index/tagstore/store_test.go @@ -14,6 +14,7 @@ package tagstore_test import ( + "context" "fmt" "io" "testing" @@ -81,7 +82,7 @@ func TestPutAndGetFromDisk(t *testing.T) { mocks.writeBackManager.EXPECT().Add( writeback.MatchTask(writeback.NewTask(tag, tag, 0))).Return(nil) - require.NoError(store.Put(tag, digest, 0)) + require.NoError(store.Put(context.Background(), tag, digest, 0)) result, err := store.Get(tag) require.NoError(err) @@ -102,7 +103,7 @@ func TestPutAndGetFromDiskWriteThrough(t *testing.T) { mocks.writeBackManager.EXPECT().SyncExec( writeback.MatchTask(writeback.NewTask(tag, tag, 0))).Return(nil) - require.NoError(store.Put(tag, digest, 0)) + require.NoError(store.Put(context.Background(), tag, digest, 0)) result, err := store.Get(tag) require.NoError(err) From 8f71806317fb13b3d9d2951076cfb88c9c5e5eca Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 26 Jan 2026 13:12:16 +0100 Subject: [PATCH 19/32] feat(tracing): add trace-aware logging to writeback executor --- lib/persistedretry/writeback/executor.go | 101 +++++++++++++++++++++-- 1 file changed, 92 insertions(+), 9 deletions(-) diff --git a/lib/persistedretry/writeback/executor.go b/lib/persistedretry/writeback/executor.go index 4b4105ed1..5c80872ed 100644 --- a/lib/persistedretry/writeback/executor.go +++ b/lib/persistedretry/writeback/executor.go @@ -14,6 +14,7 @@ package writeback import ( + "context" "fmt" "os" "time" @@ -25,6 +26,8 @@ import ( "github.com/uber/kraken/lib/store/metadata" "github.com/uber/kraken/utils/closers" "github.com/uber/kraken/utils/log" + + "go.opentelemetry.io/otel/trace" ) // FileStore defines store operations required for write-back. @@ -44,8 +47,8 @@ type Executor struct { func NewExecutor( stats tally.Scope, fs FileStore, - backends *backend.Manager) *Executor { - + backends *backend.Manager, +) *Executor { stats = stats.Tagged(map[string]string{ "module": "writebackexecutor", }) @@ -65,33 +68,91 @@ func (e *Executor) Exec(r persistedretry.Task) error { if !ok { return fmt.Errorf("expected *Task, got %T", r) } - if err := e.upload(t); err != nil { + + // Extract context from task for trace propagation + // Tasks from public endpoints will have trace context, internal tasks may not + ctx := e.getContextFromTask(t) + + log.WithTraceContext(ctx).With( + "namespace", t.Namespace, + "name", t.Name, + "has_trace_context", t.HasTraceContext(), + ).Debug("Executing writeback task") + + if err := e.upload(ctx, t); err != nil { + log.WithTraceContext(ctx).With( + "namespace", t.Namespace, + "name", t.Name, + "error", err, + ).Error("Failed to upload during writeback") return err } + err := e.fs.DeleteCacheFileMetadata(t.Name, &metadata.Persist{}) if err != nil && !os.IsNotExist(err) { + log.WithTraceContext(ctx).With( + "namespace", t.Namespace, + "name", t.Name, + "error", err, + ).Error("Failed to delete persist metadata") return fmt.Errorf("delete persist metadata: %s", err) } + + log.WithTraceContext(ctx).With( + "namespace", t.Namespace, + "name", t.Name, + ).Debug("Successfully completed writeback task") + return nil } -func (e *Executor) upload(t *Task) error { +// getContextFromTask extracts trace context from a task if available. +// Returns context.Background() if no trace context is present. +func (e *Executor) getContextFromTask(t *Task) context.Context { + if !t.HasTraceContext() { + return context.Background() + } + + spanCtx := t.SpanContext() + if !spanCtx.IsValid() { + return context.Background() + } + + // Create a context with the span context for logging correlation + return trace.ContextWithSpanContext(context.Background(), spanCtx) +} + +func (e *Executor) upload(ctx context.Context, t *Task) error { start := time.Now() - log.With("namespace", t.Namespace, "name", t.Name).Info("Uploading cache file to the remote backend") + log.WithTraceContext(ctx).With( + "namespace", t.Namespace, + "name", t.Name, + ).Info("Uploading cache file to the remote backend") + client, err := e.backends.GetClient(t.Namespace) if err != nil { if err == backend.ErrNamespaceNotFound { - log.With( + log.WithTraceContext(ctx).With( "namespace", t.Namespace, - "name", t.Name).Info("Dropping writeback for unconfigured namespace") + "name", t.Name, + ).Info("Dropping writeback for unconfigured namespace") return nil } + log.WithTraceContext(ctx).With( + "namespace", t.Namespace, + "name", t.Name, + "error", err, + ).Error("Failed to get backend client") return fmt.Errorf("get client: %s", err) } if _, err := client.Stat(t.Namespace, t.Name); err == nil { // File already uploaded, no-op. + log.WithTraceContext(ctx).With( + "namespace", t.Namespace, + "name", t.Name, + ).Debug("File already exists in backend, skipping upload") return nil } @@ -100,17 +161,39 @@ func (e *Executor) upload(t *Task) error { if os.IsNotExist(err) { // Nothing we can do about this but make noise and drop the task. e.stats.Counter("missing_files").Inc(1) - log.With("name", t.Name).Error("Invariant violation: writeback cache file missing") + log.WithTraceContext(ctx).With( + "namespace", t.Namespace, + "name", t.Name, + ).Error("Invariant violation: writeback cache file missing") return nil } + log.WithTraceContext(ctx).With( + "namespace", t.Namespace, + "name", t.Name, + "error", err, + ).Error("Failed to get cache file reader") return fmt.Errorf("get file: %s", err) } defer closers.Close(f) + log.WithTraceContext(ctx).With( + "namespace", t.Namespace, + "name", t.Name, + ).Debug("Starting backend upload") + if err := client.Upload(t.Namespace, t.Name, f); err != nil { + log.WithTraceContext(ctx).With( + "namespace", t.Namespace, + "name", t.Name, + "error", err, + ).Error("Backend upload failed") return fmt.Errorf("upload: %s", err) } - log.With("namespace", t.Namespace, "name", t.Name).Info("Uploaded cache file to remote backend") + + log.WithTraceContext(ctx).With( + "namespace", t.Namespace, + "name", t.Name, + ).Info("Uploaded cache file to remote backend") // We don't want to time noops nor errors. e.stats.Timer("upload").Record(time.Since(start)) From 9ecc7272e613171beff837e2cf9443986d37889f Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 26 Jan 2026 15:09:39 +0100 Subject: [PATCH 20/32] feat: add SendTracingContext option to httputil for OpenTelemetry trace propagation --- utils/httputil/httputil.go | 47 ++++++++++++++++++++++++++++---------- 1 file changed, 35 insertions(+), 12 deletions(-) diff --git a/utils/httputil/httputil.go b/utils/httputil/httputil.go index cfd506a26..de0d11595 100644 --- a/utils/httputil/httputil.go +++ b/utils/httputil/httputil.go @@ -28,6 +28,8 @@ import ( "github.com/uber/kraken/core" "github.com/uber/kraken/utils/handler" + + "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp" ) var retryableCodes = map[int]struct{}{ @@ -133,14 +135,15 @@ func IsNetworkError(err error) bool { } type sendOptions struct { - body io.Reader - timeout time.Duration - acceptedCodes map[int]bool - headers map[string]string - redirect func(req *http.Request, via []*http.Request) error - retry retryOptions - transport http.RoundTripper - ctx context.Context + body io.Reader + timeout time.Duration + acceptedCodes map[int]bool + headers map[string]string + redirect func(req *http.Request, via []*http.Request) error + retry retryOptions + transport http.RoundTripper + ctx context.Context + tracingContext bool // This is not a valid http option. It provides a way to override // parts of the url. For example, url.Scheme can be changed from @@ -278,6 +281,16 @@ func SendContext(ctx context.Context) SendOption { return func(o *sendOptions) { o.ctx = ctx } } +// SendTracingContext sets the context and enables OpenTelemetry trace context +// propagation via HTTP headers. The transport will be wrapped with otelhttp +// after all options are applied. +func SendTracingContext(ctx context.Context) SendOption { + return func(o *sendOptions) { + o.ctx = ctx + o.tracingContext = true + } +} + // Send sends an HTTP request. May return NetworkError or StatusError (see above). func Send(method, rawurl string, options ...SendOption) (*http.Response, error) { u, err := url.Parse(rawurl) @@ -299,6 +312,16 @@ func Send(method, rawurl string, options ...SendOption) (*http.Response, error) o(opts) } + // Apply tracing context wrapping AFTER all other options are processed + // This ensures SendTLS and other transport options are respected + if opts.tracingContext { + baseTransport := opts.transport + if baseTransport == nil { + baseTransport = http.DefaultTransport + } + opts.transport = otelhttp.NewTransport(baseTransport) + } + req, err := newRequest(method, opts) if err != nil { return nil, err @@ -381,8 +404,8 @@ func Delete(url string, options ...SendOption) (*http.Response, error) { // PollAccepted wraps GET requests for endpoints which require 202-polling. func PollAccepted( - url string, b backoff.BackOff, options ...SendOption) (*http.Response, error) { - + url string, b backoff.BackOff, options ...SendOption, +) (*http.Response, error) { b.Reset() for { resp, err := Get(url, options...) @@ -456,8 +479,8 @@ func newRequest(method string, opts *sendOptions) (*http.Request, error) { } func fallbackToHTTP( - client *http.Client, method string, opts *sendOptions) (*http.Response, error) { - + client *http.Client, method string, opts *sendOptions, +) (*http.Response, error) { req, err := newRequest(method, opts) if err != nil { return nil, err From 16ad6d1822b82390140b2ef2f01673d8c7974ddd Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 26 Jan 2026 14:21:40 +0100 Subject: [PATCH 21/32] feat: client side tracing upload path --- lib/dockerregistry/transfer/rw_transferer.go | 25 +++++++++- mocks/origin/blobclient/client.go | 9 ++-- mocks/origin/blobclient/clusterclient.go | 9 ++-- origin/blobclient/client.go | 34 +++++++++++-- origin/blobclient/cluster_client.go | 51 +++++++++++++++----- origin/blobclient/uploader.go | 31 +++++++++--- origin/blobserver/cluster_client_test.go | 11 +++-- origin/blobserver/server.go | 6 +-- origin/blobserver/server_test.go | 19 ++++---- 9 files changed, 148 insertions(+), 47 deletions(-) diff --git a/lib/dockerregistry/transfer/rw_transferer.go b/lib/dockerregistry/transfer/rw_transferer.go index 2d7d9a0df..d39b19699 100644 --- a/lib/dockerregistry/transfer/rw_transferer.go +++ b/lib/dockerregistry/transfer/rw_transferer.go @@ -14,6 +14,7 @@ package transfer import ( + "context" "fmt" "os" @@ -26,6 +27,11 @@ import ( "github.com/docker/distribution/uuid" "github.com/uber-go/tally" + + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/codes" + "go.opentelemetry.io/otel/trace" ) // ReadWriteTransferer is a Transferer for proxy. Uploads/downloads blobs via the @@ -37,6 +43,7 @@ type ReadWriteTransferer struct { tags tagclient.Client originCluster blobclient.ClusterClient cas *store.CAStore + tracer trace.Tracer } // NewReadWriteTransferer creates a new ReadWriteTransferer. @@ -57,6 +64,7 @@ func NewReadWriteTransferer( tags: tags, originCluster: originCluster, cas: cas, + tracer: otel.Tracer("kraken-registry-transfer"), } } @@ -131,11 +139,26 @@ func (t *ReadWriteTransferer) downloadFromOrigin(namespace string, d core.Digest func (t *ReadWriteTransferer) Upload( namespace string, d core.Digest, blob store.FileReader, ) error { - if err := t.originCluster.UploadBlob(namespace, d, blob); err != nil { + ctx, span := t.tracer.Start(context.Background(), "registry.upload_blob", + trace.WithSpanKind(trace.SpanKindClient), + trace.WithAttributes( + attribute.String("component", "registry-transfer"), + attribute.String("operation", "upload_blob"), + attribute.String("namespace", namespace), + attribute.String("blob.digest", d.Hex()), + ), + ) + defer span.End() + + if err := t.originCluster.UploadBlob(ctx, namespace, d, blob); err != nil { t.failureStats.Counter("upload_blob").Inc(1) + span.RecordError(err) + span.SetStatus(codes.Error, "upload failed") return err } + t.successStats.Counter("upload_blob").Inc(1) + span.SetStatus(codes.Ok, "upload completed") return nil } diff --git a/mocks/origin/blobclient/client.go b/mocks/origin/blobclient/client.go index 8ef989f9e..9ba0f7fd7 100644 --- a/mocks/origin/blobclient/client.go +++ b/mocks/origin/blobclient/client.go @@ -10,6 +10,7 @@ package mockblobclient import ( + "context" io "io" reflect "reflect" time "time" @@ -258,15 +259,15 @@ func (mr *MockClientMockRecorder) TransferBlob(d, blob any) *gomock.Call { } // UploadBlob mocks base method. -func (m *MockClient) UploadBlob(namespace string, d core.Digest, blob io.Reader) error { +func (m *MockClient) UploadBlob(ctx context.Context, namespace string, d core.Digest, blob io.Reader) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UploadBlob", namespace, d, blob) + ret := m.ctrl.Call(m, "UploadBlob", ctx, namespace, d, blob) ret0, _ := ret[0].(error) return ret0 } // UploadBlob indicates an expected call of UploadBlob. -func (mr *MockClientMockRecorder) UploadBlob(namespace, d, blob any) *gomock.Call { +func (mr *MockClientMockRecorder) UploadBlob(ctx, namespace, d, blob any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadBlob", reflect.TypeOf((*MockClient)(nil).UploadBlob), namespace, d, blob) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadBlob", reflect.TypeOf((*MockClient)(nil).UploadBlob), ctx, namespace, d, blob) } diff --git a/mocks/origin/blobclient/clusterclient.go b/mocks/origin/blobclient/clusterclient.go index 7334d48cd..543f4d57e 100644 --- a/mocks/origin/blobclient/clusterclient.go +++ b/mocks/origin/blobclient/clusterclient.go @@ -10,6 +10,7 @@ package mockblobclient import ( + "context" io "io" reflect "reflect" @@ -157,15 +158,15 @@ func (mr *MockClusterClientMockRecorder) Stat(namespace, d any) *gomock.Call { } // UploadBlob mocks base method. -func (m *MockClusterClient) UploadBlob(namespace string, d core.Digest, blob io.ReadSeeker) error { +func (m *MockClusterClient) UploadBlob(ctx context.Context, namespace string, d core.Digest, blob io.ReadSeeker) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UploadBlob", namespace, d, blob) + ret := m.ctrl.Call(m, "UploadBlob", ctx, namespace, d, blob) ret0, _ := ret[0].(error) return ret0 } // UploadBlob indicates an expected call of UploadBlob. -func (mr *MockClusterClientMockRecorder) UploadBlob(namespace, d, blob any) *gomock.Call { +func (mr *MockClusterClientMockRecorder) UploadBlob(ctx, namespace, d, blob any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadBlob", reflect.TypeOf((*MockClusterClient)(nil).UploadBlob), namespace, d, blob) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadBlob", reflect.TypeOf((*MockClusterClient)(nil).UploadBlob), ctx, namespace, d, blob) } diff --git a/origin/blobclient/client.go b/origin/blobclient/client.go index 598da246f..b34ce12ba 100644 --- a/origin/blobclient/client.go +++ b/origin/blobclient/client.go @@ -14,6 +14,7 @@ package blobclient import ( + "context" "crypto/tls" "encoding/json" "errors" @@ -31,6 +32,11 @@ import ( "github.com/uber/kraken/core" "github.com/uber/kraken/utils/httputil" "github.com/uber/kraken/utils/memsize" + + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/codes" + "go.opentelemetry.io/otel/trace" ) var _ Client = &HTTPClient{} @@ -50,7 +56,7 @@ type Client interface { GetMetaInfo(namespace string, d core.Digest) (*core.MetaInfo, error) OverwriteMetaInfo(d core.Digest, pieceLength int64) error - UploadBlob(namespace string, d core.Digest, blob io.Reader) error + UploadBlob(ctx context.Context, namespace string, d core.Digest, blob io.Reader) error DuplicateUploadBlob(namespace string, d core.Digest, blob io.Reader, delay time.Duration) error DownloadBlob(namespace string, d core.Digest, dst io.Writer) error @@ -68,6 +74,7 @@ type HTTPClient struct { addr string chunkSize uint64 tls *tls.Config + tracer trace.Tracer } // Option allows setting optional HTTPClient parameters. @@ -88,6 +95,7 @@ func New(addr string, opts ...Option) *HTTPClient { c := &HTTPClient{ addr: addr, chunkSize: 32 * memsize.MB, + tracer: otel.Tracer("kraken-origin-client"), } for _, opt := range opts { opt(c) @@ -188,9 +196,27 @@ func (c *HTTPClient) TransferBlob(d core.Digest, blob io.Reader) error { // UploadBlob uploads and replicates blob to the origin cluster, asynchronously // backing the blob up to the remote storage configured for namespace. -func (c *HTTPClient) UploadBlob(namespace string, d core.Digest, blob io.Reader) error { - uc := newUploadClient(c.addr, namespace, _publicUpload, 0, c.tls) - return runChunkedUpload(uc, d, blob, int64(c.chunkSize)) +func (c *HTTPClient) UploadBlob(ctx context.Context, namespace string, d core.Digest, blob io.Reader) error { + ctx, span := c.tracer.Start(ctx, "blobclient.upload_blob", + trace.WithSpanKind(trace.SpanKindClient), + trace.WithAttributes( + attribute.String("component", "origin-client"), + attribute.String("operation", "upload_blob"), + attribute.String("namespace", namespace), + attribute.String("blob.digest", d.Hex()), + ), + ) + defer span.End() + + uc := newUploadClientWithContext(ctx, c.addr, namespace, _publicUpload, 0, c.tls) + if err := runChunkedUpload(uc, d, blob, int64(c.chunkSize)); err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, "upload failed") + return err + } + + span.SetStatus(codes.Ok, "upload completed") + return nil } // DuplicateUploadBlob duplicates an blob upload request, which will attempt to diff --git a/origin/blobclient/cluster_client.go b/origin/blobclient/cluster_client.go index 923c3994e..2bc03cad3 100644 --- a/origin/blobclient/cluster_client.go +++ b/origin/blobclient/cluster_client.go @@ -14,6 +14,7 @@ package blobclient import ( + "context" "errors" "fmt" "io" @@ -30,6 +31,11 @@ import ( "github.com/uber/kraken/utils/errutil" "github.com/uber/kraken/utils/httputil" "github.com/uber/kraken/utils/log" + + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/codes" + "go.opentelemetry.io/otel/trace" ) // Locations queries cluster for the locations of d. @@ -82,7 +88,7 @@ var _ ClusterClient = &clusterClient{} // location resolution and retries. type ClusterClient interface { CheckReadiness() error - UploadBlob(namespace string, d core.Digest, blob io.ReadSeeker) error + UploadBlob(ctx context.Context, namespace string, d core.Digest, blob io.ReadSeeker) error DownloadBlob(namespace string, d core.Digest, dst io.Writer) error PrefetchBlob(namespace string, d core.Digest) error GetMetaInfo(namespace string, d core.Digest) (*core.MetaInfo, error) @@ -123,42 +129,65 @@ func (c *clusterClient) CheckReadiness() error { } // UploadBlob uploads blob to origin cluster. See Client.UploadBlob for more details. -func (c *clusterClient) UploadBlob(namespace string, d core.Digest, blob io.ReadSeeker) (err error) { +func (c *clusterClient) UploadBlob(ctx context.Context, namespace string, d core.Digest, blob io.ReadSeeker) (err error) { + ctx, span := otel.Tracer("kraken-origin-cluster").Start(ctx, "cluster.upload_blob", + trace.WithSpanKind(trace.SpanKindClient), + trace.WithAttributes( + attribute.String("component", "origin-cluster-client"), + attribute.String("operation", "upload_blob"), + attribute.String("namespace", namespace), + attribute.String("blob.digest", d.Hex()), + ), + ) + defer span.End() + clients, err := c.resolver.Resolve(d) if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, "failed to resolve clients") return fmt.Errorf("resolve clients: %s", err) } - logger := log.With("namespace", namespace, "digest", d.Hex()) - logger.Debug("Starting blob upload to origin cluster") + + span.SetAttributes(attribute.Int("cluster.origin_count", len(clients))) + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex()).Debug("Starting blob upload to origin cluster") // We prefer the origin with highest hashing score so the first origin will handle // replication to origins with lower score. This is because we want to reduce upload // conflicts between local replicas. for i, client := range clients { originAddr := client.Addr() - attemptLogger := logger.With("origin", originAddr, "attempt", i) + span.SetAttributes(attribute.Int("cluster.attempt", i)) - attemptLogger.Debug("Attempting blob upload to origin") - err = client.UploadBlob(namespace, d, blob) + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "origin", originAddr, "attempt", i).Debug("Attempting blob upload to origin") + err = client.UploadBlob(ctx, namespace, d, blob) if err == nil { - attemptLogger.Debug("Blob upload succeeded") + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "origin", originAddr).Debug("Blob upload succeeded") + span.SetAttributes(attribute.String("cluster.successful_origin", originAddr)) + span.SetStatus(codes.Ok, "upload succeeded") return nil } - attemptLogger.With("error", err).Error("Blob upload failed") + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "origin", originAddr, "error", err).Error("Blob upload failed") // Non-retryable error - don't try other origins if !httputil.IsNetworkError(err) && !httputil.IsRetryable(err) { + span.RecordError(err) + span.SetStatus(codes.Error, "non-retryable error") return err } // Allow retry on another origin if the current upstream is temporarily // unavailable or under high load. - attemptLogger.Debug("Rewinding blob reader for retry") + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "origin", originAddr, "attempt", i).Debug("Rewinding blob reader for retry") if _, seekErr := blob.Seek(0, io.SeekStart); seekErr != nil { - attemptLogger.With("error", seekErr).Error("Failed to rewind blob reader for retry") + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "error", seekErr).Error("Failed to rewind blob reader for retry") + span.RecordError(seekErr) + span.SetStatus(codes.Error, "failed to rewind blob") return fmt.Errorf("rewind blob for retry after %d attempts: %w", i, seekErr) } } + + span.RecordError(err) + span.SetStatus(codes.Error, "all origins failed") return err } diff --git a/origin/blobclient/uploader.go b/origin/blobclient/uploader.go index 5aff4ccb1..bd339c36b 100644 --- a/origin/blobclient/uploader.go +++ b/origin/blobclient/uploader.go @@ -15,6 +15,7 @@ package blobclient import ( "bytes" + "context" "crypto/tls" "encoding/json" "errors" @@ -91,8 +92,8 @@ func (c *transferClient) start(d core.Digest) (uid string, err error) { } func (c *transferClient) patch( - d core.Digest, uid string, start, stop int64, chunk io.Reader) error { - + d core.Digest, uid string, start, stop int64, chunk io.Reader, +) error { _, err := httputil.Patch( fmt.Sprintf("http://%s/internal/blobs/%s/uploads/%s", c.addr, d, uid), httputil.SendBody(chunk), @@ -120,6 +121,7 @@ const ( // uploadClient executes chunked uploads for external cluster upload operations. type uploadClient struct { + ctx context.Context addr string namespace string uploadType uploadType @@ -128,15 +130,29 @@ type uploadClient struct { } func newUploadClient( - addr string, namespace string, t uploadType, delay time.Duration, tls *tls.Config) *uploadClient { + addr string, namespace string, t uploadType, delay time.Duration, tls *tls.Config, +) *uploadClient { + return newUploadClientWithContext(context.Background(), addr, namespace, t, delay, tls) +} - return &uploadClient{addr, namespace, t, delay, tls} +func newUploadClientWithContext( + ctx context.Context, addr string, namespace string, t uploadType, delay time.Duration, tls *tls.Config, +) *uploadClient { + return &uploadClient{ + ctx: ctx, + addr: addr, + namespace: namespace, + uploadType: t, + delay: delay, + tls: tls, + } } func (c *uploadClient) start(d core.Digest) (uid string, err error) { r, err := httputil.Post( fmt.Sprintf("http://%s/namespace/%s/blobs/%s/uploads", c.addr, url.PathEscape(c.namespace), d), + httputil.SendTracingContext(c.ctx), httputil.SendTLS(c.tls)) if err != nil { return "", err @@ -149,11 +165,12 @@ func (c *uploadClient) start(d core.Digest) (uid string, err error) { } func (c *uploadClient) patch( - d core.Digest, uid string, start, stop int64, chunk io.Reader) error { - + d core.Digest, uid string, start, stop int64, chunk io.Reader, +) error { _, err := httputil.Patch( fmt.Sprintf("http://%s/namespace/%s/blobs/%s/uploads/%s", c.addr, url.PathEscape(c.namespace), d, uid), + httputil.SendTracingContext(c.ctx), httputil.SendBody(chunk), httputil.SendHeaders(map[string]string{ "Content-Range": fmt.Sprintf("%d-%d", start, stop), @@ -183,8 +200,10 @@ func (c *uploadClient) commit(d core.Digest, uid string) error { default: return fmt.Errorf("unknown upload type: %d", c.uploadType) } + _, err := httputil.Put( fmt.Sprintf(template, c.addr, url.PathEscape(c.namespace), d, uid), + httputil.SendTracingContext(c.ctx), httputil.SendTimeout(15*time.Minute), httputil.SendBody(body), httputil.SendTLS(c.tls)) diff --git a/origin/blobserver/cluster_client_test.go b/origin/blobserver/cluster_client_test.go index 6fdc6dd7f..40e2677a3 100644 --- a/origin/blobserver/cluster_client_test.go +++ b/origin/blobserver/cluster_client_test.go @@ -15,6 +15,7 @@ package blobserver import ( "bytes" + "context" "io" "testing" "time" @@ -56,7 +57,7 @@ func TestClusterClientResilientToUnavailableMasters(t *testing.T) { s.writeBackManager.EXPECT().Add( writeback.MatchTask(writeback.NewTask( backend.NoopNamespace, blob.Digest.Hex(), 0))).Return(nil) - require.NoError(cc.UploadBlob(backend.NoopNamespace, blob.Digest, store.NewBufferFileReader(blob.Content))) + require.NoError(cc.UploadBlob(context.Background(), backend.NoopNamespace, blob.Digest, store.NewBufferFileReader(blob.Content))) bi, err := cc.Stat(backend.NoopNamespace, blob.Digest) require.NoError(err) @@ -91,7 +92,7 @@ func TestClusterClientReturnsErrorOnNoAvailability(t *testing.T) { blob := core.NewBlobFixture() - require.Error(cc.UploadBlob(backend.NoopNamespace, blob.Digest, store.NewBufferFileReader(blob.Content))) + require.Error(cc.UploadBlob(context.Background(), backend.NoopNamespace, blob.Digest, store.NewBufferFileReader(blob.Content))) _, err := cc.Stat(backend.NoopNamespace, blob.Digest) require.Error(err) @@ -180,11 +181,11 @@ func TestPollSkipsOriginOnRetryableError(t *testing.T) { reader := store.NewBufferFileReader(blob.Content) mockClient1.EXPECT().Addr().Return("client1").AnyTimes() - mockClient1.EXPECT().UploadBlob(namespace, blob.Digest, reader).Return(httputil.StatusError{Status: 503}) + mockClient1.EXPECT().UploadBlob(context.Background(), namespace, blob.Digest, reader).Return(httputil.StatusError{Status: 503}) mockClient2.EXPECT().Addr().Return("client2").AnyTimes() - mockClient2.EXPECT().UploadBlob(namespace, blob.Digest, reader).Return(nil) + mockClient2.EXPECT().UploadBlob(context.Background(), namespace, blob.Digest, reader).Return(nil) - require.NoError(cc.UploadBlob(namespace, blob.Digest, reader)) + require.NoError(cc.UploadBlob(context.Background(), namespace, blob.Digest, reader)) } func TestClusterClientReturnsErrorOnNoAvailableOrigins(t *testing.T) { diff --git a/origin/blobserver/server.go b/origin/blobserver/server.go index 29dd9fb19..37310aadb 100644 --- a/origin/blobserver/server.go +++ b/origin/blobserver/server.go @@ -316,10 +316,10 @@ func (s *Server) replicateToRemoteHandler(w http.ResponseWriter, r *http.Request if err != nil { return err } - return s.replicateToRemote(namespace, d, remote) + return s.replicateToRemote(r.Context(), namespace, d, remote) } -func (s *Server) replicateToRemote(namespace string, d core.Digest, remoteDNS string) error { +func (s *Server) replicateToRemote(ctx context.Context, namespace string, d core.Digest, remoteDNS string) error { start := time.Now() fi, err := s.cas.GetCacheFileStat(d.Hex()) @@ -347,7 +347,7 @@ func (s *Server) replicateToRemote(namespace string, d core.Digest, remoteDNS st log.With("namespace", namespace, "digest", d.Hex(), "remote", remoteDNS, "size_bytes", blobSize, "duration_s", duration.Seconds()).Errorf("Failed to get remote cluster provider: %s", err) return handler.Errorf("remote cluster provider: %s", err) } - if err := remote.UploadBlob(namespace, d, f); err != nil { + if err := remote.UploadBlob(ctx, namespace, d, f); err != nil { duration := time.Since(start) log.With("namespace", namespace, "digest", d.Hex(), "remote", remoteDNS, "size_bytes", blobSize, "duration_s", duration.Seconds()).Errorf("Failed to upload blob to remote: %s", err) return err diff --git a/origin/blobserver/server_test.go b/origin/blobserver/server_test.go index 1f2d16ca3..0663be9b3 100644 --- a/origin/blobserver/server_test.go +++ b/origin/blobserver/server_test.go @@ -15,6 +15,7 @@ package blobserver import ( "bytes" + "context" "errors" "fmt" "io" @@ -597,7 +598,7 @@ func TestReplicateToRemote(t *testing.T) { remoteCluster := s.expectRemoteCluster(remote) remoteCluster.EXPECT().UploadBlob( - namespace, blob.Digest, mockutil.MatchReader(blob.Content)).Return(nil) + context.Background(), namespace, blob.Digest, mockutil.MatchReader(blob.Content)).Return(nil) require.NoError(cp.Provide(master1).ReplicateToRemote(namespace, blob.Digest, remote)) } @@ -656,7 +657,7 @@ func TestReplicateToRemoteWhenBlobInStorageBackend(t *testing.T) { remoteCluster := s.expectRemoteCluster(remote) remoteCluster.EXPECT().UploadBlob( - namespace, blob.Digest, mockutil.MatchReader(blob.Content)).Return(nil) + context.Background(), namespace, blob.Digest, mockutil.MatchReader(blob.Content)).Return(nil) require.NoError(testutil.PollUntilTrue(5*time.Second, func() bool { err := cp.Provide(master1).ReplicateToRemote(namespace, blob.Digest, remote) @@ -685,7 +686,7 @@ func TestUploadBlobDuplicatesWriteBackTaskToReplicas(t *testing.T) { s2.writeBackManager.EXPECT().Add( writeback.MatchTask(writeback.NewTask(namespace, blob.Digest.Hex(), 30*time.Minute))) - err := cp.Provide(s1.host).UploadBlob(namespace, blob.Digest, bytes.NewReader(blob.Content)) + err := cp.Provide(s1.host).UploadBlob(context.Background(), namespace, blob.Digest, bytes.NewReader(blob.Content)) require.NoError(err) ensureHasBlob(t, cp.Provide(s1.host), namespace, blob) @@ -718,12 +719,12 @@ func TestUploadBlobRetriesWriteBackFailure(t *testing.T) { // Upload should "fail" because we failed to add a write-back task, but blob // should still be present. - err := cp.Provide(s.host).UploadBlob(namespace, blob.Digest, bytes.NewReader(blob.Content)) + err := cp.Provide(s.host).UploadBlob(context.Background(), namespace, blob.Digest, bytes.NewReader(blob.Content)) require.Error(err) ensureHasBlob(t, cp.Provide(s.host), namespace, blob) // Uploading again should succeed. - err = cp.Provide(s.host).UploadBlob(namespace, blob.Digest, bytes.NewReader(blob.Content)) + err = cp.Provide(s.host).UploadBlob(context.Background(), namespace, blob.Digest, bytes.NewReader(blob.Content)) require.NoError(err) // Shouldn't be able to delete blob since it is still being written back. @@ -748,7 +749,7 @@ func TestUploadBlobResilientToDuplicationFailure(t *testing.T) { s.writeBackManager.EXPECT().Add( writeback.MatchTask(writeback.NewTask(namespace, blob.Digest.Hex(), 0))).Return(nil) - err := cp.Provide(s.host).UploadBlob(namespace, blob.Digest, bytes.NewReader(blob.Content)) + err := cp.Provide(s.host).UploadBlob(context.Background(), namespace, blob.Digest, bytes.NewReader(blob.Content)) require.NoError(err) ensureHasBlob(t, cp.Provide(s.host), namespace, blob) @@ -772,7 +773,7 @@ func TestForceCleanupTTL(t *testing.T) { s.writeBackManager.EXPECT().Add( writeback.MatchTask(writeback.NewTask(namespace, blob.Digest.Hex(), 0))).Return(nil) - require.NoError(client.UploadBlob(namespace, blob.Digest, bytes.NewReader(blob.Content))) + require.NoError(client.UploadBlob(context.Background(), namespace, blob.Digest, bytes.NewReader(blob.Content))) ensureHasBlob(t, client, namespace, blob) @@ -817,7 +818,7 @@ func TestForceCleanupNonOwner(t *testing.T) { s2.writeBackManager.EXPECT().Add( writeback.MatchTask(writeback.NewTask(namespace, blob.Digest.Hex(), 30*time.Minute))) - require.NoError(client.UploadBlob(namespace, blob.Digest, bytes.NewReader(blob.Content))) + require.NoError(client.UploadBlob(context.Background(), namespace, blob.Digest, bytes.NewReader(blob.Content))) ensureHasBlob(t, client, namespace, blob) @@ -849,7 +850,7 @@ func TestForceCleanupWriteBackFailures(t *testing.T) { s.writeBackManager.EXPECT().Add(writeback.MatchTask(task)).Return(nil) - require.NoError(client.UploadBlob(namespace, blob.Digest, bytes.NewReader(blob.Content))) + require.NoError(client.UploadBlob(context.Background(), namespace, blob.Digest, bytes.NewReader(blob.Content))) ensureHasBlob(t, client, namespace, blob) From f1c78843712ad6ec7cd6dc0fb90180f10029292b Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 26 Jan 2026 14:34:37 +0100 Subject: [PATCH 22/32] fix: gomock --- origin/blobserver/cluster_client_test.go | 4 ++-- origin/blobserver/server_test.go | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/origin/blobserver/cluster_client_test.go b/origin/blobserver/cluster_client_test.go index 40e2677a3..d5400d826 100644 --- a/origin/blobserver/cluster_client_test.go +++ b/origin/blobserver/cluster_client_test.go @@ -181,9 +181,9 @@ func TestPollSkipsOriginOnRetryableError(t *testing.T) { reader := store.NewBufferFileReader(blob.Content) mockClient1.EXPECT().Addr().Return("client1").AnyTimes() - mockClient1.EXPECT().UploadBlob(context.Background(), namespace, blob.Digest, reader).Return(httputil.StatusError{Status: 503}) + mockClient1.EXPECT().UploadBlob(gomock.Any(), namespace, blob.Digest, reader).Return(httputil.StatusError{Status: 503}) mockClient2.EXPECT().Addr().Return("client2").AnyTimes() - mockClient2.EXPECT().UploadBlob(context.Background(), namespace, blob.Digest, reader).Return(nil) + mockClient2.EXPECT().UploadBlob(gomock.Any(), namespace, blob.Digest, reader).Return(nil) require.NoError(cc.UploadBlob(context.Background(), namespace, blob.Digest, reader)) } diff --git a/origin/blobserver/server_test.go b/origin/blobserver/server_test.go index 0663be9b3..c36adcac2 100644 --- a/origin/blobserver/server_test.go +++ b/origin/blobserver/server_test.go @@ -598,7 +598,7 @@ func TestReplicateToRemote(t *testing.T) { remoteCluster := s.expectRemoteCluster(remote) remoteCluster.EXPECT().UploadBlob( - context.Background(), namespace, blob.Digest, mockutil.MatchReader(blob.Content)).Return(nil) + gomock.Any(), namespace, blob.Digest, mockutil.MatchReader(blob.Content)).Return(nil) require.NoError(cp.Provide(master1).ReplicateToRemote(namespace, blob.Digest, remote)) } @@ -657,7 +657,7 @@ func TestReplicateToRemoteWhenBlobInStorageBackend(t *testing.T) { remoteCluster := s.expectRemoteCluster(remote) remoteCluster.EXPECT().UploadBlob( - context.Background(), namespace, blob.Digest, mockutil.MatchReader(blob.Content)).Return(nil) + gomock.Any(), namespace, blob.Digest, mockutil.MatchReader(blob.Content)).Return(nil) require.NoError(testutil.PollUntilTrue(5*time.Second, func() bool { err := cp.Provide(master1).ReplicateToRemote(namespace, blob.Digest, remote) From 2f4f62362694b9e1060aef409ce90fe9c47b5bc1 Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 26 Jan 2026 15:15:36 +0100 Subject: [PATCH 23/32] feat(origin): pass trace headers in the nginx --- nginx/config/origin.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/nginx/config/origin.go b/nginx/config/origin.go index 7627c3a3e..d79ccfed2 100644 --- a/nginx/config/origin.go +++ b/nginx/config/origin.go @@ -31,6 +31,10 @@ server { # Committing large blobs might take a while. proxy_read_timeout {{.proxy_read_timeout}}; + proxy_set_header traceparent $http_traceparent; + proxy_set_header tracestate $http_tracestate; + proxy_set_header jaeger-debug-id $http_jaeger_debug_id; + {{healthEndpoint .server}} location / { From 507411fa67ca9575b959033669418af1b0e047d2 Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 26 Jan 2026 18:02:10 +0100 Subject: [PATCH 24/32] feat: Add tracing to origin DownloadBlob operation --- build-index/tagtype/docker_resolver.go | 3 +- build-index/tagtype/docker_resolver_test.go | 26 +++++------ build-index/tagtype/map_test.go | 2 +- lib/dockerregistry/transfer/rw_transferer.go | 43 +++++++++++++++++-- .../transfer/rw_transferer_test.go | 2 +- mocks/origin/blobclient/client.go | 8 ++-- mocks/origin/blobclient/clusterclient.go | 8 ++-- origin/blobclient/client.go | 28 ++++++++++-- origin/blobclient/cluster_client.go | 27 ++++++++++-- origin/blobserver/cluster_client_test.go | 16 +++---- origin/blobserver/server_test.go | 2 +- origin/blobserver/testutils_test.go | 7 +-- proxy/proxyserver/prefetch.go | 7 +-- proxy/proxyserver/preheat.go | 3 +- proxy/proxyserver/server_test.go | 22 +++++----- 15 files changed, 145 insertions(+), 59 deletions(-) diff --git a/build-index/tagtype/docker_resolver.go b/build-index/tagtype/docker_resolver.go index 1d480de5c..6be4a5e34 100644 --- a/build-index/tagtype/docker_resolver.go +++ b/build-index/tagtype/docker_resolver.go @@ -15,6 +15,7 @@ package tagtype import ( "bytes" + "context" "fmt" "github.com/cenkalti/backoff" @@ -53,7 +54,7 @@ func (r *dockerResolver) downloadManifest(tag string, d core.Digest) (distributi attempt++ buf.Reset() - err := r.originClient.DownloadBlob(tag, d, buf) + err := r.originClient.DownloadBlob(context.Background(), tag, d, buf) if err == nil { return nil } diff --git a/build-index/tagtype/docker_resolver_test.go b/build-index/tagtype/docker_resolver_test.go index 463813cd0..d0468ee85 100644 --- a/build-index/tagtype/docker_resolver_test.go +++ b/build-index/tagtype/docker_resolver_test.go @@ -79,7 +79,7 @@ func TestDockerResolver_DownloadManifest_Success(t *testing.T) { // Expect successful download on first attempt mockOrigin.EXPECT(). - DownloadBlob(tag, manifest, mockutil.MatchWriter(manifestBytes)). + DownloadBlob(gomock.Any(), tag, manifest, mockutil.MatchWriter(manifestBytes)). Return(nil) result, err := resolver.downloadManifest(tag, manifest) @@ -93,10 +93,10 @@ func TestDockerResolver_DownloadManifest_RetryOnBlobNotFound(t *testing.T) { // First attempt fails with blob not found, second succeeds gomock.InOrder( mockOrigin.EXPECT(). - DownloadBlob(tag, manifest, gomock.Any()). + DownloadBlob(gomock.Any(), tag, manifest, gomock.Any()). Return(blobclient.ErrBlobNotFound), mockOrigin.EXPECT(). - DownloadBlob(tag, manifest, mockutil.MatchWriter(manifestBytes)). + DownloadBlob(gomock.Any(), tag, manifest, mockutil.MatchWriter(manifestBytes)). Return(nil), ) @@ -113,7 +113,7 @@ func TestDockerResolver_DownloadManifest_ExhaustedRetries(t *testing.T) { // All attempts fail with blob not found (MaxRetries=3, so 4 total attempts) mockOrigin.EXPECT(). - DownloadBlob(tag, manifest, gomock.Any()). + DownloadBlob(gomock.Any(), tag, manifest, gomock.Any()). Return(blobclient.ErrBlobNotFound). Times(4) @@ -133,7 +133,7 @@ func TestDockerResolver_DownloadManifest_PermanentError(t *testing.T) { permanentErr := httputil.StatusError{Status: 401} mockOrigin.EXPECT(). - DownloadBlob(tag, manifest, gomock.Any()). + DownloadBlob(gomock.Any(), tag, manifest, gomock.Any()). Return(permanentErr). Times(1) // Should only be called once, no retries @@ -151,14 +151,14 @@ func TestDockerResolver_DownloadManifest_BufferResetBetweenRetries(t *testing.T) // Second attempt succeeds with full data gomock.InOrder( mockOrigin.EXPECT(). - DownloadBlob(tag, manifest, gomock.Any()). + DownloadBlob(gomock.Any(), tag, manifest, gomock.Any()). DoAndReturn(func(tag string, d core.Digest, dst io.Writer) error { _, err := dst.Write(partialData) require.NoError(err) return blobclient.ErrBlobNotFound }), mockOrigin.EXPECT(). - DownloadBlob(tag, manifest, mockutil.MatchWriter(manifestBytes)). + DownloadBlob(gomock.Any(), tag, manifest, mockutil.MatchWriter(manifestBytes)). Return(nil), ) @@ -176,7 +176,7 @@ func TestDockerResolver_DownloadManifest_InvalidManifestFormat(t *testing.T) { // Download succeeds but returns invalid manifest data mockOrigin.EXPECT(). - DownloadBlob(tag, manifest, gomock.Any()). + DownloadBlob(gomock.Any(), tag, manifest, gomock.Any()). DoAndReturn(func(tag string, d core.Digest, dst io.Writer) error { _, err := dst.Write([]byte("invalid manifest json")) require.NoError(err) @@ -193,7 +193,7 @@ func TestDockerResolver_Resolve_Success(t *testing.T) { require, _, resolver, mockOrigin, tag, layers, manifest, manifestBytes := setupDockerResolverTestWithManifest(t) mockOrigin.EXPECT(). - DownloadBlob(tag, manifest, mockutil.MatchWriter(manifestBytes)). + DownloadBlob(gomock.Any(), tag, manifest, mockutil.MatchWriter(manifestBytes)). Return(nil) deps, err := resolver.Resolve(tag, manifest) @@ -209,7 +209,7 @@ func TestDockerResolver_Resolve_DownloadError(t *testing.T) { // All retries exhausted mockOrigin.EXPECT(). - DownloadBlob(tag, manifest, gomock.Any()). + DownloadBlob(gomock.Any(), tag, manifest, gomock.Any()). Return(blobclient.ErrBlobNotFound). Times(4) @@ -225,13 +225,13 @@ func TestDockerResolver_Resolve_WithRetries(t *testing.T) { // Fails twice, succeeds on third attempt gomock.InOrder( mockOrigin.EXPECT(). - DownloadBlob(tag, manifest, gomock.Any()). + DownloadBlob(gomock.Any(), tag, manifest, gomock.Any()). Return(blobclient.ErrBlobNotFound), mockOrigin.EXPECT(). - DownloadBlob(tag, manifest, gomock.Any()). + DownloadBlob(gomock.Any(), tag, manifest, gomock.Any()). Return(blobclient.ErrBlobNotFound), mockOrigin.EXPECT(). - DownloadBlob(tag, manifest, mockutil.MatchWriter(manifestBytes)). + DownloadBlob(gomock.Any(), tag, manifest, mockutil.MatchWriter(manifestBytes)). Return(nil), ) diff --git a/build-index/tagtype/map_test.go b/build-index/tagtype/map_test.go index dcade6c5d..d64a77415 100644 --- a/build-index/tagtype/map_test.go +++ b/build-index/tagtype/map_test.go @@ -47,7 +47,7 @@ func TestMapResolveDocker(t *testing.T) { layers := core.DigestListFixture(3) manifest, b := dockerutil.ManifestFixture(layers[0], layers[1], layers[2]) - originClient.EXPECT().DownloadBlob(tag, manifest, mockutil.MatchWriter(b)).Return(nil) + originClient.EXPECT().DownloadBlob(gomock.Any(), tag, manifest, mockutil.MatchWriter(b)).Return(nil) deps, err := m.Resolve(tag, manifest) require.NoError(err) diff --git a/lib/dockerregistry/transfer/rw_transferer.go b/lib/dockerregistry/transfer/rw_transferer.go index d39b19699..35accc7fa 100644 --- a/lib/dockerregistry/transfer/rw_transferer.go +++ b/lib/dockerregistry/transfer/rw_transferer.go @@ -99,39 +99,76 @@ func (t *ReadWriteTransferer) originStat(namespace string, d core.Digest) (*core // Download downloads the blob of name into the file store and returns a reader // to the newly downloaded file. func (t *ReadWriteTransferer) Download(namespace string, d core.Digest) (store.FileReader, error) { + ctx, span := t.tracer.Start(context.Background(), "registry.download_blob", + trace.WithSpanKind(trace.SpanKindClient), + trace.WithAttributes( + attribute.String("component", "registry-transfer"), + attribute.String("operation", "download_blob"), + attribute.String("namespace", namespace), + attribute.String("blob.digest", d.Hex()), + ), + ) + defer span.End() + blob, err := t.cas.GetCacheFileReader(d.Hex()) if err == nil { + span.SetAttributes(attribute.String("cache.status", "hit")) + span.SetStatus(codes.Ok, "cache hit") return blob, nil } if os.IsNotExist(err) { - return t.downloadFromOrigin(namespace, d) + span.SetAttributes(attribute.String("cache.status", "miss")) + return t.downloadFromOrigin(ctx, namespace, d) } + span.RecordError(err) + span.SetStatus(codes.Error, "cache read error") return nil, fmt.Errorf("get cache file: %s", err) } -func (t *ReadWriteTransferer) downloadFromOrigin(namespace string, d core.Digest) (store.FileReader, error) { +func (t *ReadWriteTransferer) downloadFromOrigin(ctx context.Context, namespace string, d core.Digest) (store.FileReader, error) { + ctx, span := t.tracer.Start(ctx, "registry.download_from_origin", + trace.WithAttributes( + attribute.String("namespace", namespace), + attribute.String("blob.digest", d.Hex()), + ), + ) + defer span.End() + tmp := fmt.Sprintf("%s.%s", d.Hex(), uuid.Generate().String()) if err := t.cas.CreateUploadFile(tmp, 0); err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, "failed to create upload file") return nil, fmt.Errorf("create upload file: %s", err) } w, err := t.cas.GetUploadFileReadWriter(tmp) if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, "failed to get upload writer") return nil, fmt.Errorf("get upload writer: %s", err) } defer closers.Close(w) - if err := t.originCluster.DownloadBlob(namespace, d, w); err != nil { + if err := t.originCluster.DownloadBlob(ctx, namespace, d, w); err != nil { if err == blobclient.ErrBlobNotFound { + span.SetStatus(codes.Error, "blob not found") return nil, ErrBlobNotFound } + span.RecordError(err) + span.SetStatus(codes.Error, "origin download failed") return nil, fmt.Errorf("origin: %s", err) } if err := t.cas.MoveUploadFileToCache(tmp, d.Hex()); err != nil && !os.IsExist(err) { + span.RecordError(err) + span.SetStatus(codes.Error, "failed to move to cache") return nil, fmt.Errorf("move upload file to cache: %s", err) } blob, err := t.cas.GetCacheFileReader(d.Hex()) if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, "failed to read cached blob") return nil, fmt.Errorf("get cache file: %s", err) } + + span.SetStatus(codes.Ok, "download completed") return blob, nil } diff --git a/lib/dockerregistry/transfer/rw_transferer_test.go b/lib/dockerregistry/transfer/rw_transferer_test.go index 681949fe0..d9b86899c 100644 --- a/lib/dockerregistry/transfer/rw_transferer_test.go +++ b/lib/dockerregistry/transfer/rw_transferer_test.go @@ -71,7 +71,7 @@ func TestReadWriteTransfererDownloadCachesBlob(t *testing.T) { blob := core.NewBlobFixture() mocks.originCluster.EXPECT().DownloadBlob( - namespace, blob.Digest, mockutil.MatchWriter(blob.Content)).Return(nil) + gomock.Any(), namespace, blob.Digest, mockutil.MatchWriter(blob.Content)).Return(nil) // Downloading multiple times should only call blob download once. for i := 0; i < 10; i++ { diff --git a/mocks/origin/blobclient/client.go b/mocks/origin/blobclient/client.go index 9ba0f7fd7..26fd496f9 100644 --- a/mocks/origin/blobclient/client.go +++ b/mocks/origin/blobclient/client.go @@ -86,17 +86,17 @@ func (mr *MockClientMockRecorder) DeleteBlob(d any) *gomock.Call { } // DownloadBlob mocks base method. -func (m *MockClient) DownloadBlob(namespace string, d core.Digest, dst io.Writer) error { +func (m *MockClient) DownloadBlob(arg0 context.Context, arg1 string, arg2 core.Digest, arg3 io.Writer) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DownloadBlob", namespace, d, dst) + ret := m.ctrl.Call(m, "DownloadBlob", arg0, arg1, arg2, arg3) ret0, _ := ret[0].(error) return ret0 } // DownloadBlob indicates an expected call of DownloadBlob. -func (mr *MockClientMockRecorder) DownloadBlob(namespace, d, dst any) *gomock.Call { +func (mr *MockClientMockRecorder) DownloadBlob(arg0, arg1, arg2, arg3 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadBlob", reflect.TypeOf((*MockClient)(nil).DownloadBlob), namespace, d, dst) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadBlob", reflect.TypeOf((*MockClient)(nil).DownloadBlob), arg0, arg1, arg2, arg3) } // DuplicateUploadBlob mocks base method. diff --git a/mocks/origin/blobclient/clusterclient.go b/mocks/origin/blobclient/clusterclient.go index 543f4d57e..0d48e600b 100644 --- a/mocks/origin/blobclient/clusterclient.go +++ b/mocks/origin/blobclient/clusterclient.go @@ -57,17 +57,17 @@ func (mr *MockClusterClientMockRecorder) CheckReadiness() *gomock.Call { } // DownloadBlob mocks base method. -func (m *MockClusterClient) DownloadBlob(namespace string, d core.Digest, dst io.Writer) error { +func (m *MockClusterClient) DownloadBlob(arg0 context.Context, arg1 string, arg2 core.Digest, arg3 io.Writer) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DownloadBlob", namespace, d, dst) + ret := m.ctrl.Call(m, "DownloadBlob", arg0, arg1, arg2, arg3) ret0, _ := ret[0].(error) return ret0 } // DownloadBlob indicates an expected call of DownloadBlob. -func (mr *MockClusterClientMockRecorder) DownloadBlob(namespace, d, dst any) *gomock.Call { +func (mr *MockClusterClientMockRecorder) DownloadBlob(arg0, arg1, arg2, arg3 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadBlob", reflect.TypeOf((*MockClusterClient)(nil).DownloadBlob), namespace, d, dst) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DownloadBlob", reflect.TypeOf((*MockClusterClient)(nil).DownloadBlob), arg0, arg1, arg2, arg3) } // GetMetaInfo mocks base method. diff --git a/origin/blobclient/client.go b/origin/blobclient/client.go index b34ce12ba..679cbf31c 100644 --- a/origin/blobclient/client.go +++ b/origin/blobclient/client.go @@ -59,7 +59,7 @@ type Client interface { UploadBlob(ctx context.Context, namespace string, d core.Digest, blob io.Reader) error DuplicateUploadBlob(namespace string, d core.Digest, blob io.Reader, delay time.Duration) error - DownloadBlob(namespace string, d core.Digest, dst io.Writer) error + DownloadBlob(ctx context.Context, namespace string, d core.Digest, dst io.Writer) error PrefetchBlob(namespace string, d core.Digest) error ReplicateToRemote(namespace string, d core.Digest, remoteDNS string) error @@ -232,17 +232,39 @@ func (c *HTTPClient) DuplicateUploadBlob( // (i.e. still downloading), returns 202 httputil.StatusError, indicating that // the request should be retried later. If not blob exists for d, returns a 404 // httputil.StatusError. -func (c *HTTPClient) DownloadBlob(namespace string, d core.Digest, dst io.Writer) error { +func (c *HTTPClient) DownloadBlob(ctx context.Context, namespace string, d core.Digest, dst io.Writer) error { + ctx, span := c.tracer.Start(ctx, "blobclient.download_blob", + trace.WithSpanKind(trace.SpanKindClient), + trace.WithAttributes( + attribute.String("component", "origin-client"), + attribute.String("operation", "download_blob"), + attribute.String("namespace", namespace), + attribute.String("blob.digest", d.Hex()), + attribute.String("origin.address", c.addr), + ), + ) + defer span.End() + r, err := httputil.Get( fmt.Sprintf("http://%s/namespace/%s/blobs/%s", c.addr, url.PathEscape(namespace), d), + httputil.SendTracingContext(ctx), httputil.SendTLS(c.tls)) if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, "download request failed") return err } defer closers.Close(r.Body) - if _, err := io.Copy(dst, r.Body); err != nil { + + written, err := io.Copy(dst, r.Body) + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, "failed to copy response body") return fmt.Errorf("copy body: %s", err) } + + span.SetAttributes(attribute.Int64("blob.size_bytes", written)) + span.SetStatus(codes.Ok, "download completed") return nil } diff --git a/origin/blobclient/cluster_client.go b/origin/blobclient/cluster_client.go index 2bc03cad3..6caaaf488 100644 --- a/origin/blobclient/cluster_client.go +++ b/origin/blobclient/cluster_client.go @@ -89,7 +89,7 @@ var _ ClusterClient = &clusterClient{} type ClusterClient interface { CheckReadiness() error UploadBlob(ctx context.Context, namespace string, d core.Digest, blob io.ReadSeeker) error - DownloadBlob(namespace string, d core.Digest, dst io.Writer) error + DownloadBlob(ctx context.Context, namespace string, d core.Digest, dst io.Writer) error PrefetchBlob(namespace string, d core.Digest) error GetMetaInfo(namespace string, d core.Digest) (*core.MetaInfo, error) Stat(namespace string, d core.Digest) (*core.BlobInfo, error) @@ -245,12 +245,33 @@ func (c *clusterClient) OverwriteMetaInfo(d core.Digest, pieceLength int64) erro } // DownloadBlob pulls a blob from the origin cluster. -func (c *clusterClient) DownloadBlob(namespace string, d core.Digest, dst io.Writer) error { +func (c *clusterClient) DownloadBlob(ctx context.Context, namespace string, d core.Digest, dst io.Writer) error { + ctx, span := otel.Tracer("kraken-origin-cluster").Start(ctx, "cluster.download_blob", + trace.WithSpanKind(trace.SpanKindClient), + trace.WithAttributes( + attribute.String("component", "origin-cluster-client"), + attribute.String("operation", "download_blob"), + attribute.String("namespace", namespace), + attribute.String("blob.digest", d.Hex()), + ), + ) + defer span.End() + + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex()).Debug("Starting blob download from origin cluster") + err := Poll(c.resolver, c.defaultPollBackOff(), d, func(client Client) error { - return client.DownloadBlob(namespace, d, dst) + return client.DownloadBlob(ctx, namespace, d, dst) }) if httputil.IsNotFound(err) { + span.SetStatus(codes.Error, "blob not found") err = ErrBlobNotFound + } else if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, "download failed") + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex(), "error", err).Error("Blob download failed") + } else { + span.SetStatus(codes.Ok, "download completed") + log.WithTraceContext(ctx).With("namespace", namespace, "digest", d.Hex()).Debug("Blob download succeeded") } return err } diff --git a/origin/blobserver/cluster_client_test.go b/origin/blobserver/cluster_client_test.go index d5400d826..c4e427a40 100644 --- a/origin/blobserver/cluster_client_test.go +++ b/origin/blobserver/cluster_client_test.go @@ -69,7 +69,7 @@ func TestClusterClientResilientToUnavailableMasters(t *testing.T) { require.NotNil(mi) var buf bytes.Buffer - require.NoError(cc.DownloadBlob(backend.NoopNamespace, blob.Digest, &buf)) + require.NoError(cc.DownloadBlob(context.Background(), backend.NoopNamespace, blob.Digest, &buf)) require.Equal(string(blob.Content), buf.String()) peers, err := cc.Owners(blob.Digest) @@ -100,7 +100,7 @@ func TestClusterClientReturnsErrorOnNoAvailability(t *testing.T) { _, err = cc.GetMetaInfo(backend.NoopNamespace, blob.Digest) require.Error(err) - require.Error(cc.DownloadBlob(backend.NoopNamespace, blob.Digest, io.Discard)) + require.Error(cc.DownloadBlob(context.Background(), backend.NoopNamespace, blob.Digest, io.Discard)) _, err = cc.Owners(blob.Digest) require.Error(err) @@ -124,14 +124,14 @@ func TestPollSkipsOriginOnTimeout(t *testing.T) { []blobclient.Client{mockClient1, mockClient2}, nil) mockClient1.EXPECT().DownloadBlob( - namespace, blob.Digest, nil).Return(httputil.StatusError{Status: 202}).MinTimes(1) + gomock.Any(), namespace, blob.Digest, nil).Return(httputil.StatusError{Status: 202}).MinTimes(1) mockClient1.EXPECT().Addr().Return("client1") - mockClient2.EXPECT().DownloadBlob(namespace, blob.Digest, nil).Return(nil) + mockClient2.EXPECT().DownloadBlob(gomock.Any(), namespace, blob.Digest, nil).Return(nil) b := backoff.WithMaxRetries(backoff.NewConstantBackOff(100*time.Millisecond), 5) require.NoError(blobclient.Poll(mockResolver, b, blob.Digest, func(c blobclient.Client) error { - return c.DownloadBlob(namespace, blob.Digest, nil) + return c.DownloadBlob(context.Background(), namespace, blob.Digest, nil) })) } @@ -151,14 +151,14 @@ func TestPollSkipsOriginOnNetworkErrors(t *testing.T) { mockResolver.EXPECT().Resolve(blob.Digest).Return([]blobclient.Client{mockClient1, mockClient2}, nil) - mockClient1.EXPECT().DownloadBlob(namespace, blob.Digest, nil).Return(httputil.NetworkError{}) + mockClient1.EXPECT().DownloadBlob(gomock.Any(), namespace, blob.Digest, nil).Return(httputil.NetworkError{}) mockClient1.EXPECT().Addr().Return("client1") - mockClient2.EXPECT().DownloadBlob(namespace, blob.Digest, nil).Return(nil) + mockClient2.EXPECT().DownloadBlob(gomock.Any(), namespace, blob.Digest, nil).Return(nil) b := backoff.WithMaxRetries(backoff.NewConstantBackOff(100*time.Millisecond), 5) require.NoError(blobclient.Poll(mockResolver, b, blob.Digest, func(c blobclient.Client) error { - return c.DownloadBlob(namespace, blob.Digest, nil) + return c.DownloadBlob(context.Background(), namespace, blob.Digest, nil) })) } diff --git a/origin/blobserver/server_test.go b/origin/blobserver/server_test.go index c36adcac2..9ccc0ae2f 100644 --- a/origin/blobserver/server_test.go +++ b/origin/blobserver/server_test.go @@ -261,7 +261,7 @@ func TestDownloadBlobNotFound(t *testing.T) { backendClient := s.backendClient(namespace, false) backendClient.EXPECT().Stat(namespace, d.Hex()).Return(nil, backenderrors.ErrBlobNotFound) - err := cp.Provide(master1).DownloadBlob(namespace, d, io.Discard) + err := cp.Provide(master1).DownloadBlob(context.Background(), namespace, d, io.Discard) require.Error(err) require.Equal(http.StatusNotFound, err.(httputil.StatusError).Status) } diff --git a/origin/blobserver/testutils_test.go b/origin/blobserver/testutils_test.go index c1dab8afb..d81f1fe52 100644 --- a/origin/blobserver/testutils_test.go +++ b/origin/blobserver/testutils_test.go @@ -15,6 +15,7 @@ package blobserver import ( "bytes" + "context" "testing" "time" @@ -105,8 +106,8 @@ type testServer struct { } func newTestServer( - t *testing.T, host string, ring hashring.Ring, cp *testClientProvider) *testServer { - + t *testing.T, host string, ring hashring.Ring, cp *testClientProvider, +) *testServer { var cleanup testutil.Cleanup defer cleanup.Recover() @@ -186,6 +187,6 @@ func computeBlobForHosts(ring hashring.Ring, hosts ...string) *core.BlobFixture func ensureHasBlob(t *testing.T, c blobclient.Client, namespace string, blob *core.BlobFixture) { var buf bytes.Buffer - require.NoError(t, c.DownloadBlob(namespace, blob.Digest, &buf)) + require.NoError(t, c.DownloadBlob(context.Background(), namespace, blob.Digest, &buf)) require.Equal(t, string(blob.Content), buf.String()) } diff --git a/proxy/proxyserver/prefetch.go b/proxy/proxyserver/prefetch.go index 1b30f7d55..07b58a9fa 100644 --- a/proxy/proxyserver/prefetch.go +++ b/proxy/proxyserver/prefetch.go @@ -2,6 +2,7 @@ package proxyserver import ( "bytes" + "context" "encoding/json" "errors" "fmt" @@ -234,7 +235,7 @@ func (ph *PrefetchHandler) preparePrefetch(w http.ResponseWriter, r *http.Reques buf := &bytes.Buffer{} startTime = time.Now() - if err := ph.clusterClient.DownloadBlob(namespace, digest, buf); err != nil { + if err := ph.clusterClient.DownloadBlob(context.Background(), namespace, digest, buf); err != nil { ph.metrics.Counter("download_manifest_error").Inc(1) logger.With("error", err).Error("Failed to download manifest blob") writeInternalError(w, fmt.Sprintf("error downloading manifest blob: %s", err), reqBody.TraceId) @@ -273,7 +274,7 @@ func (ph *PrefetchHandler) downloadBlobs(input *prefetchInput) { go func(blob blobInfo) { defer wg.Done() blobStart := time.Now() - err := ph.clusterClient.DownloadBlob(input.namespace, blob.digest, io.Discard) + err := ph.clusterClient.DownloadBlob(context.Background(), input.namespace, blob.digest, io.Discard) blobDuration := time.Since(blobStart) ph.metrics.Timer("blob_download_time").Record(blobDuration) ph.metrics.Counter("bytes_downloaded").Inc(blob.size) @@ -361,7 +362,7 @@ func (ph *PrefetchHandler) processManifestList(logger *zap.SugaredLogger, namesp } buf := &bytes.Buffer{} startTime := time.Now() - if err := ph.clusterClient.DownloadBlob(namespace, digest, buf); err != nil { + if err := ph.clusterClient.DownloadBlob(context.Background(), namespace, digest, buf); err != nil { ph.metrics.Counter("download_manifest_error").Inc(1) logger.With("error", err).Error("Failed to download manifest blob") continue diff --git a/proxy/proxyserver/preheat.go b/proxy/proxyserver/preheat.go index 2d036c921..fa22672c4 100644 --- a/proxy/proxyserver/preheat.go +++ b/proxy/proxyserver/preheat.go @@ -15,6 +15,7 @@ package proxyserver import ( "bytes" + "context" "encoding/json" "fmt" "net/http" @@ -107,7 +108,7 @@ func (ph *PreheatHandler) fetchManifest(repo, digest string) (distribution.Manif time.Sleep(interval) interval = interval * 2 } - if err := ph.clusterClient.DownloadBlob(repo, d, buf); err == nil { + if err := ph.clusterClient.DownloadBlob(context.Background(), repo, d, buf); err == nil { break } else if err == blobclient.ErrBlobNotFound { continue diff --git a/proxy/proxyserver/server_test.go b/proxy/proxyserver/server_test.go index 8b7c73f93..845b20ca7 100644 --- a/proxy/proxyserver/server_test.go +++ b/proxy/proxyserver/server_test.go @@ -14,21 +14,23 @@ package proxyserver import ( + "bytes" + "encoding/json" "errors" "fmt" "io" "net/http" "net/url" "testing" + "time" + + "github.com/golang/mock/gomock" "github.com/uber/kraken/utils/dockerutil" "github.com/uber/kraken/utils/httputil" - "bytes" - "encoding/json" - "time" - "github.com/stretchr/testify/require" + "github.com/uber/kraken/core" "github.com/uber/kraken/utils/mockutil" ) @@ -136,7 +138,7 @@ func TestPreheat(t *testing.T) { b, _ := json.Marshal(notification) - mocks.originClient.EXPECT().DownloadBlob(repo, manifest, mockutil.MatchWriter(bs)).Return(nil) + mocks.originClient.EXPECT().DownloadBlob(gomock.Any(), repo, manifest, mockutil.MatchWriter(bs)).Return(nil) mocks.originClient.EXPECT().GetMetaInfo(repo, layers[0]).Return(nil, nil) mocks.originClient.EXPECT().GetMetaInfo(repo, layers[1]).Return(nil, nil) mocks.originClient.EXPECT().GetMetaInfo(repo, layers[2]).Return(nil, nil) @@ -202,9 +204,9 @@ func TestPrefetchV1(t *testing.T) { tagRequest := url.QueryEscape(fmt.Sprintf("%s/%s", namespace, tag)) mocks.tagClient.EXPECT().Get(tagRequest).Return(manifest, nil) - mocks.originClient.EXPECT().DownloadBlob(namespace, manifest, mockutil.MatchWriter(bs)).Return(nil) - mocks.originClient.EXPECT().DownloadBlob(namespace, layers[1], io.Discard).Return(nil) - mocks.originClient.EXPECT().DownloadBlob(namespace, layers[2], io.Discard).Return(nil) + mocks.originClient.EXPECT().DownloadBlob(gomock.Any(), namespace, manifest, mockutil.MatchWriter(bs)).Return(nil) + mocks.originClient.EXPECT().DownloadBlob(gomock.Any(), namespace, layers[1], io.Discard).Return(nil) + mocks.originClient.EXPECT().DownloadBlob(gomock.Any(), namespace, layers[2], io.Discard).Return(nil) _, err := httputil.Post( fmt.Sprintf("http://%s/proxy/v1/registry/prefetch", addr), httputil.SendBody(bytes.NewReader(b))) @@ -233,7 +235,7 @@ func TestPrefetchV2(t *testing.T) { tagRequest := url.QueryEscape(fmt.Sprintf("%s/%s", namespace, tag)) mocks.tagClient.EXPECT().Get(tagRequest).Return(manifest, nil) - mocks.originClient.EXPECT().DownloadBlob(namespace, manifest, mockutil.MatchWriter(bs)).Return(nil) + mocks.originClient.EXPECT().DownloadBlob(gomock.Any(), namespace, manifest, mockutil.MatchWriter(bs)).Return(nil) mocks.originClient.EXPECT().PrefetchBlob(namespace, layers[1]).Return(nil) mocks.originClient.EXPECT().PrefetchBlob(namespace, layers[2]).Return(nil) @@ -279,7 +281,7 @@ func TestPrefetchV2OriginError(t *testing.T) { tagRequest := url.QueryEscape(fmt.Sprintf("%s/%s", namespace, tag)) mocks.tagClient.EXPECT().Get(tagRequest).Return(manifest, nil) - mocks.originClient.EXPECT().DownloadBlob(namespace, manifest, mockutil.MatchWriter(bs)).Return(nil) + mocks.originClient.EXPECT().DownloadBlob(gomock.Any(), namespace, manifest, mockutil.MatchWriter(bs)).Return(nil) mocks.originClient.EXPECT().PrefetchBlob(namespace, layers[1]).Return(errors.New("foo err")) mocks.originClient.EXPECT().PrefetchBlob(namespace, layers[2]).Return(nil) From 8ae75b4fafb712b04690893db19d1b4419e15c35 Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 26 Jan 2026 18:17:15 +0100 Subject: [PATCH 25/32] fix: Fix tests --- build-index/tagtype/docker_resolver_test.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/build-index/tagtype/docker_resolver_test.go b/build-index/tagtype/docker_resolver_test.go index d0468ee85..c6d3911a6 100644 --- a/build-index/tagtype/docker_resolver_test.go +++ b/build-index/tagtype/docker_resolver_test.go @@ -14,6 +14,7 @@ package tagtype import ( + "context" "io" "testing" "time" @@ -152,7 +153,7 @@ func TestDockerResolver_DownloadManifest_BufferResetBetweenRetries(t *testing.T) gomock.InOrder( mockOrigin.EXPECT(). DownloadBlob(gomock.Any(), tag, manifest, gomock.Any()). - DoAndReturn(func(tag string, d core.Digest, dst io.Writer) error { + DoAndReturn(func(ctx context.Context, tag string, d core.Digest, dst io.Writer) error { _, err := dst.Write(partialData) require.NoError(err) return blobclient.ErrBlobNotFound @@ -177,7 +178,7 @@ func TestDockerResolver_DownloadManifest_InvalidManifestFormat(t *testing.T) { // Download succeeds but returns invalid manifest data mockOrigin.EXPECT(). DownloadBlob(gomock.Any(), tag, manifest, gomock.Any()). - DoAndReturn(func(tag string, d core.Digest, dst io.Writer) error { + DoAndReturn(func(ctx context.Context, tag string, d core.Digest, dst io.Writer) error { _, err := dst.Write([]byte("invalid manifest json")) require.NoError(err) return nil From b27beb78a17ce19bb10aae7be388eb89d4cf6878 Mon Sep 17 00:00:00 2001 From: hweawer Date: Wed, 28 Jan 2026 10:22:19 +0100 Subject: [PATCH 26/32] feat(proxy): Tracing prefetch api --- proxy/proxyserver/prefetch.go | 165 +++++++++++++++++++++---------- proxy/proxyserver/server.go | 11 ++- proxy/proxyserver/server_test.go | 14 +-- 3 files changed, 126 insertions(+), 64 deletions(-) diff --git a/proxy/proxyserver/prefetch.go b/proxy/proxyserver/prefetch.go index 07b58a9fa..6dbba6a3b 100644 --- a/proxy/proxyserver/prefetch.go +++ b/proxy/proxyserver/prefetch.go @@ -22,7 +22,11 @@ import ( "github.com/uber/kraken/origin/blobclient" "github.com/uber/kraken/utils/httputil" "github.com/uber/kraken/utils/log" - "go.uber.org/zap" + + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/codes" + "go.opentelemetry.io/otel/trace" ) // Constants for prefetch status. @@ -43,6 +47,7 @@ type PrefetchHandler struct { metrics tally.Scope getManifestLatency tally.Histogram getTagLatency tally.Histogram + tracer trace.Tracer } // blobInfo holds digest and size information for a blob. @@ -53,8 +58,7 @@ type blobInfo struct { // Request and response payloads. type prefetchBody struct { - Tag string `json:"tag"` - TraceId string `json:"trace_id"` + Tag string `json:"tag"` } type prefetchResponse struct { @@ -62,7 +66,6 @@ type prefetchResponse struct { Prefetched bool `json:"prefetched"` Status string `json:"status"` Message string `json:"message"` - TraceId string `json:"trace_id"` } type prefetchError struct { @@ -70,7 +73,6 @@ type prefetchError struct { Prefetched bool `json:"prefetched"` Status string `json:"status"` Message string `json:"message"` - TraceId string `json:"trace_id,omitempty"` } type TagParser interface { @@ -121,28 +123,27 @@ func NewPrefetchHandler( metrics: m, getManifestLatency: m.Histogram("download_manifest_latency", tally.MustMakeExponentialDurationBuckets(1*time.Second, 2, 12)), getTagLatency: m.Histogram("get_tag_latency", tally.MustMakeExponentialDurationBuckets(100*time.Millisecond, 2, 10)), + tracer: otel.Tracer("kraken-proxy-prefetch"), } } // newPrefetchSuccessResponse constructs a successful response. -func newPrefetchSuccessResponse(tag, msg, traceId string) *prefetchResponse { +func newPrefetchSuccessResponse(tag, msg string) *prefetchResponse { return &prefetchResponse{ Tag: tag, Prefetched: true, Status: StatusSuccess, Message: msg, - TraceId: traceId, } } // newPrefetchError constructs an error response. -func newPrefetchError(status int, msg, traceId string) *prefetchError { +func newPrefetchError(status int, msg string) *prefetchError { return &prefetchError{ Error: http.StatusText(status), Prefetched: false, Status: StatusFailure, Message: msg, - TraceId: traceId, } } @@ -164,16 +165,16 @@ func writeJSON(w http.ResponseWriter, status int, payload interface{}) { } } -func writeBadRequestError(w http.ResponseWriter, msg, traceId string) { - writeJSON(w, http.StatusBadRequest, newPrefetchError(http.StatusBadRequest, msg, traceId)) +func writeBadRequestError(w http.ResponseWriter, msg string) { + writeJSON(w, http.StatusBadRequest, newPrefetchError(http.StatusBadRequest, msg)) } -func writeInternalError(w http.ResponseWriter, msg, traceId string) { - writeJSON(w, http.StatusInternalServerError, newPrefetchError(http.StatusInternalServerError, msg, traceId)) +func writeInternalError(w http.ResponseWriter, msg string) { + writeJSON(w, http.StatusInternalServerError, newPrefetchError(http.StatusInternalServerError, msg)) } -func writePrefetchResponse(w http.ResponseWriter, tag, msg, traceId string) { - writeJSON(w, http.StatusOK, newPrefetchSuccessResponse(tag, msg, traceId)) +func writePrefetchResponse(w http.ResponseWriter, tag, msg string) { + writeJSON(w, http.StatusOK, newPrefetchSuccessResponse(tag, msg)) } // HandleV1 processes the prefetch request. @@ -184,7 +185,7 @@ func (ph *PrefetchHandler) HandleV1(w http.ResponseWriter, r *http.Request) { } ph.metrics.Counter("initiated").Inc(1) - writePrefetchResponse(w, input.tag, "prefetching initiated successfully", input.traceID) + writePrefetchResponse(w, input.tag, "prefetching initiated successfully") if ph.v1Synchronous { ph.downloadBlobs(input) @@ -195,78 +196,116 @@ func (ph *PrefetchHandler) HandleV1(w http.ResponseWriter, r *http.Request) { } type prefetchInput struct { + ctx context.Context blobs []blobInfo namespace string - logger *zap.SugaredLogger tag string - traceID string } // preparePrefetch parses the request, calls build-index to get the image manifest SHA, // downloads the manifest(s) from the origin cluster, parses them, and returns the blobs layers to prefetch. // If an error occurs, preparePrefetch returns the appropriate HTTP response. func (ph *PrefetchHandler) preparePrefetch(w http.ResponseWriter, r *http.Request) (res *prefetchInput, errOccurred bool) { + ctx, span := ph.tracer.Start(r.Context(), "prefetch.prepare", + trace.WithSpanKind(trace.SpanKindServer), + trace.WithAttributes( + attribute.String("component", "proxy-prefetch"), + attribute.String("operation", "prepare_prefetch"), + ), + ) + defer span.End() + ph.metrics.Counter("requests").Inc(1) var reqBody prefetchBody if err := json.NewDecoder(r.Body).Decode(&reqBody); err != nil { - writeBadRequestError(w, fmt.Sprintf("failed to decode request body: %s", err), "") - log.With("error", err).Error("Failed to decode request body") + span.RecordError(err) + span.SetStatus(codes.Error, "failed to decode request body") + writeBadRequestError(w, fmt.Sprintf("failed to decode request body: %s", err)) + log.WithTraceContext(ctx).With("error", err).Error("Failed to decode request body") return nil, true } - logger := log.With("trace_id", reqBody.TraceId) + + span.SetAttributes(attribute.String("image.tag", reqBody.Tag)) namespace, tag, err := ph.tagParser.ParseTag(reqBody.Tag) if err != nil { - writeBadRequestError(w, fmt.Sprintf("tag: %s, invalid tag format: %s", reqBody.Tag, err), reqBody.TraceId) + span.RecordError(err) + span.SetStatus(codes.Error, "invalid tag format") + writeBadRequestError(w, fmt.Sprintf("tag: %s, invalid tag format: %s", reqBody.Tag, err)) return nil, true } + span.SetAttributes( + attribute.String("image.namespace", namespace), + attribute.String("image.name", tag), + ) + tagRequest := url.QueryEscape(fmt.Sprintf("%s/%s", namespace, tag)) startTime := time.Now() digest, err := ph.tagClient.Get(tagRequest) if err != nil { ph.metrics.Counter("get_tag_error").Inc(1) - logger.With("error", err).Error("Failed to get manifest tag") - writeInternalError(w, fmt.Sprintf("tag request: %s, failed to get tag: %s", tagRequest, err), reqBody.TraceId) + span.RecordError(err) + span.SetStatus(codes.Error, "failed to get manifest tag") + log.WithTraceContext(ctx).With("error", err).Error("Failed to get manifest tag") + writeInternalError(w, fmt.Sprintf("tag request: %s, failed to get tag: %s", tagRequest, err)) return nil, true } ph.getTagLatency.RecordDuration(time.Since(startTime)) - logger.Infof("Namespace: %s, Tag: %s", namespace, tag) + span.SetAttributes(attribute.String("manifest.digest", digest.Hex())) + log.WithTraceContext(ctx).Infof("Namespace: %s, Tag: %s", namespace, tag) buf := &bytes.Buffer{} startTime = time.Now() - if err := ph.clusterClient.DownloadBlob(context.Background(), namespace, digest, buf); err != nil { + if err := ph.clusterClient.DownloadBlob(ctx, namespace, digest, buf); err != nil { ph.metrics.Counter("download_manifest_error").Inc(1) - logger.With("error", err).Error("Failed to download manifest blob") - writeInternalError(w, fmt.Sprintf("error downloading manifest blob: %s", err), reqBody.TraceId) + span.RecordError(err) + span.SetStatus(codes.Error, "failed to download manifest") + log.WithTraceContext(ctx).With("error", err).Error("Failed to download manifest blob") + writeInternalError(w, fmt.Sprintf("error downloading manifest blob: %s", err)) return nil, true } ph.getManifestLatency.RecordDuration(time.Since(startTime)) // Process manifest (ManifestList or single Manifest) - blobs, err := ph.processManifest(logger, namespace, buf.Bytes()) + blobs, err := ph.processManifest(ctx, namespace, buf.Bytes()) if err != nil { - writeInternalError(w, fmt.Sprintf("failed to process manifest: %s", err), reqBody.TraceId) + span.RecordError(err) + span.SetStatus(codes.Error, "failed to process manifest") + writeInternalError(w, fmt.Sprintf("failed to process manifest: %s", err)) return nil, true } + span.SetAttributes(attribute.Int("blobs.count", len(blobs))) + span.SetStatus(codes.Ok, "prepare completed") + return &prefetchInput{ + ctx: ctx, blobs: blobs, namespace: namespace, - logger: logger, tag: tag, - traceID: reqBody.TraceId, }, false } // downloadBlobs downloads blobs in parallel. func (ph *PrefetchHandler) downloadBlobs(input *prefetchInput) { + ctx, span := ph.tracer.Start(input.ctx, "prefetch.download_blobs", + trace.WithAttributes( + attribute.String("component", "proxy-prefetch"), + attribute.String("operation", "download_blobs"), + attribute.String("image.namespace", input.namespace), + attribute.String("image.tag", input.tag), + attribute.Int("blobs.total", len(input.blobs)), + ), + ) + defer span.End() + var wg sync.WaitGroup var mu sync.Mutex var errList []error for _, b := range input.blobs { - if ph.shouldSkipPrefetch(b, input.logger) { + if ph.shouldSkipPrefetch(input.ctx, b) { continue } @@ -274,7 +313,7 @@ func (ph *PrefetchHandler) downloadBlobs(input *prefetchInput) { go func(blob blobInfo) { defer wg.Done() blobStart := time.Now() - err := ph.clusterClient.DownloadBlob(context.Background(), input.namespace, blob.digest, io.Discard) + err := ph.clusterClient.DownloadBlob(ctx, input.namespace, blob.digest, io.Discard) blobDuration := time.Since(blobStart) ph.metrics.Timer("blob_download_time").Record(blobDuration) ph.metrics.Counter("bytes_downloaded").Inc(blob.size) @@ -295,16 +334,20 @@ func (ph *PrefetchHandler) downloadBlobs(input *prefetchInput) { if len(errList) > 0 { ph.metrics.Counter("failed").Inc(1) + span.RecordError(errors.Join(errList...)) + span.SetStatus(codes.Error, fmt.Sprintf("%d blob downloads failed", len(errList))) for _, err := range errList { - input.logger.With("error", err).Error("Error downloading blob") + log.WithTraceContext(input.ctx).With("error", err).Error("Error downloading blob") } + } else { + span.SetStatus(codes.Ok, "all blobs downloaded") } } // Skip blobs that are outside the size range [min, max] -func (ph *PrefetchHandler) shouldSkipPrefetch(b blobInfo, logger *zap.SugaredLogger) bool { +func (ph *PrefetchHandler) shouldSkipPrefetch(ctx context.Context, b blobInfo) bool { if b.size < ph.minBlobSizeBytes { - logger.With( + log.WithTraceContext(ctx).With( "digest", b.digest, "size", b.size, "min_threshold", ph.minBlobSizeBytes, @@ -313,7 +356,7 @@ func (ph *PrefetchHandler) shouldSkipPrefetch(b blobInfo, logger *zap.SugaredLog return true } if b.size > ph.maxBlobSizeBytes { - logger.With( + log.WithTraceContext(ctx).With( "digest", b.digest, "size", b.size, "max_threshold", ph.maxBlobSizeBytes, @@ -325,9 +368,9 @@ func (ph *PrefetchHandler) shouldSkipPrefetch(b blobInfo, logger *zap.SugaredLog } // processManifest handles both ManifestLists and single Manifests. -func (ph *PrefetchHandler) processManifest(logger *zap.SugaredLogger, namespace string, manifestBytes []byte) ([]blobInfo, error) { +func (ph *PrefetchHandler) processManifest(ctx context.Context, namespace string, manifestBytes []byte) ([]blobInfo, error) { // Attempt to process as a manifest list. - blobs, err := ph.tryProcessManifestList(logger, namespace, manifestBytes) + blobs, err := ph.tryProcessManifestList(ctx, namespace, manifestBytes) if err == nil && len(blobs) > 0 { return blobs, nil } @@ -335,24 +378,24 @@ func (ph *PrefetchHandler) processManifest(logger *zap.SugaredLogger, namespace // Fallback to single manifest. var manifest schema2.Manifest if err := json.NewDecoder(bytes.NewReader(manifestBytes)).Decode(&manifest); err != nil { - logger.With("namespace", namespace).Errorf("Failed to parse single manifest: %v", err) + log.WithTraceContext(ctx).With("namespace", namespace).Errorf("Failed to parse single manifest: %v", err) return nil, fmt.Errorf("invalid single manifest: %w", err) } return ph.processLayers(manifest.Layers) } // tryProcessManifestList attempts to decode a manifest list. -func (ph *PrefetchHandler) tryProcessManifestList(logger *zap.SugaredLogger, namespace string, manifestBytes []byte) ([]blobInfo, error) { +func (ph *PrefetchHandler) tryProcessManifestList(ctx context.Context, namespace string, manifestBytes []byte) ([]blobInfo, error) { var manifestList manifestlist.ManifestList if err := json.NewDecoder(bytes.NewReader(manifestBytes)).Decode(&manifestList); err != nil || len(manifestList.Manifests) == 0 { return nil, fmt.Errorf("not a valid manifest list") } - logger.With("namespace", namespace).Info("Processing manifest list") - return ph.processManifestList(logger, namespace, manifestList) + log.WithTraceContext(ctx).With("namespace", namespace).Info("Processing manifest list") + return ph.processManifestList(ctx, namespace, manifestList) } // processManifestList processes a manifest list. -func (ph *PrefetchHandler) processManifestList(logger *zap.SugaredLogger, namespace string, manifestList manifestlist.ManifestList) ([]blobInfo, error) { +func (ph *PrefetchHandler) processManifestList(ctx context.Context, namespace string, manifestList manifestlist.ManifestList) ([]blobInfo, error) { var allBlobs []blobInfo for _, descriptor := range manifestList.Manifests { manifestDigestHex := descriptor.Digest.Hex() @@ -362,9 +405,9 @@ func (ph *PrefetchHandler) processManifestList(logger *zap.SugaredLogger, namesp } buf := &bytes.Buffer{} startTime := time.Now() - if err := ph.clusterClient.DownloadBlob(context.Background(), namespace, digest, buf); err != nil { + if err := ph.clusterClient.DownloadBlob(ctx, namespace, digest, buf); err != nil { ph.metrics.Counter("download_manifest_error").Inc(1) - logger.With("error", err).Error("Failed to download manifest blob") + log.WithTraceContext(ctx).With("error", err).Error("Failed to download manifest blob") continue } ph.getManifestLatency.RecordDuration(time.Since(startTime)) @@ -411,23 +454,36 @@ func (ph *PrefetchHandler) HandleV2(w http.ResponseWriter, r *http.Request) { err := ph.triggerPrefetchBlobs(input) if err != nil { - writeInternalError(w, fmt.Sprintf("failed to trigger image prefetch: %s", err), input.traceID) - input.logger.Errorf("Failed to trigger image prefetch") + writeInternalError(w, fmt.Sprintf("failed to trigger image prefetch: %s", err)) + log.WithTraceContext(input.ctx).Errorf("Failed to trigger image prefetch") return } ph.metrics.Counter("initiated").Inc(1) - writePrefetchResponse(w, input.tag, "prefetching initiated successfully", input.traceID) + writePrefetchResponse(w, input.tag, "prefetching initiated successfully") } // triggerPrefetchBlobs triggers a blob prefetch for all blobs in parallel. func (ph *PrefetchHandler) triggerPrefetchBlobs(input *prefetchInput) error { + ctx, span := ph.tracer.Start(input.ctx, "prefetch.trigger_prefetch", + trace.WithAttributes( + attribute.String("component", "proxy-prefetch"), + attribute.String("operation", "trigger_prefetch"), + attribute.String("image.namespace", input.namespace), + attribute.String("image.tag", input.tag), + attribute.Int("blobs.total", len(input.blobs)), + ), + ) + defer span.End() + + _ = ctx // PrefetchBlob doesn't accept context yet + var wg sync.WaitGroup var mu sync.Mutex var errList []error for _, b := range input.blobs { - if ph.shouldSkipPrefetch(b, input.logger) { + if ph.shouldSkipPrefetch(input.ctx, b) { continue } @@ -445,7 +501,12 @@ func (ph *PrefetchHandler) triggerPrefetchBlobs(input *prefetchInput) error { wg.Wait() if len(errList) != 0 { - return fmt.Errorf("at least one layer could not be prefetched: %w", errors.Join(errList...)) + err := fmt.Errorf("at least one layer could not be prefetched: %w", errors.Join(errList...)) + span.RecordError(err) + span.SetStatus(codes.Error, fmt.Sprintf("%d prefetch requests failed", len(errList))) + return err } + + span.SetStatus(codes.Ok, "all prefetch requests triggered") return nil } diff --git a/proxy/proxyserver/server.go b/proxy/proxyserver/server.go index 0e53e0790..5d9062ec9 100644 --- a/proxy/proxyserver/server.go +++ b/proxy/proxyserver/server.go @@ -27,6 +27,9 @@ import ( "github.com/uber/kraken/lib/middleware" "github.com/uber/kraken/origin/blobclient" "github.com/uber/kraken/utils/handler" + + "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp" + "go.opentelemetry.io/otel" ) // Server defines the proxy HTTP server. @@ -62,9 +65,13 @@ func (s *Server) Handler() http.Handler { r.Get("/health", handler.Wrap(s.healthHandler)) + // Add tracing middleware for prefetch/preheat endpoints + tracingMiddleware := otelhttp.NewMiddleware("kraken-proxy", + otelhttp.WithTracerProvider(otel.GetTracerProvider())) + r.Post("/registry/notifications", handler.Wrap(s.preheatHandler.Handle)) - r.Post("/proxy/v1/registry/prefetch", s.prefetchHandler.HandleV1) - r.Post("/proxy/v2/registry/prefetch", s.prefetchHandler.HandleV2) + r.With(tracingMiddleware).Post("/proxy/v1/registry/prefetch", s.prefetchHandler.HandleV1) + r.With(tracingMiddleware).Post("/proxy/v2/registry/prefetch", s.prefetchHandler.HandleV2) // Serves /debug/pprof endpoints. r.Mount("/", http.DefaultServeMux) diff --git a/proxy/proxyserver/server_test.go b/proxy/proxyserver/server_test.go index 845b20ca7..4cdbd0f4a 100644 --- a/proxy/proxyserver/server_test.go +++ b/proxy/proxyserver/server_test.go @@ -170,8 +170,7 @@ func TestPrefetchV1MalformedTag(t *testing.T) { addr := mocks.startServer() b, _ := json.Marshal(prefetchBody{ - TraceId: "abc", - Tag: "invalid", + Tag: "invalid", }) _, err := httputil.Post( @@ -198,8 +197,7 @@ func TestPrefetchV1(t *testing.T) { manifest, bs := dockerutil.ManifestFixture(layers[0], layers[1], layers[2]) b, _ := json.Marshal(prefetchBody{ - Tag: fmt.Sprintf("%s/%s/%s", repo, namespace, tag), - TraceId: "abc", + Tag: fmt.Sprintf("%s/%s/%s", repo, namespace, tag), }) tagRequest := url.QueryEscape(fmt.Sprintf("%s/%s", namespace, tag)) @@ -229,8 +227,7 @@ func TestPrefetchV2(t *testing.T) { manifest, bs := dockerutil.ManifestFixture(layers[0], layers[1], layers[2]) b, _ := json.Marshal(prefetchBody{ - Tag: fmt.Sprintf("%s/%s/%s", repo, namespace, tag), - TraceId: "abc", + Tag: fmt.Sprintf("%s/%s/%s", repo, namespace, tag), }) tagRequest := url.QueryEscape(fmt.Sprintf("%s/%s", namespace, tag)) @@ -252,7 +249,6 @@ func TestPrefetchV2(t *testing.T) { require.Equal(prefetchResponse{ Message: "prefetching initiated successfully", - TraceId: "abc", Status: "success", Tag: "abcdef:v1.0.0", Prefetched: true, @@ -275,8 +271,7 @@ func TestPrefetchV2OriginError(t *testing.T) { manifest, bs := dockerutil.ManifestFixture(layers[0], layers[1], layers[2]) b, _ := json.Marshal(prefetchBody{ - Tag: fmt.Sprintf("%s/%s/%s", repo, namespace, tag), - TraceId: "abc", + Tag: fmt.Sprintf("%s/%s/%s", repo, namespace, tag), }) tagRequest := url.QueryEscape(fmt.Sprintf("%s/%s", namespace, tag)) @@ -297,7 +292,6 @@ func TestPrefetchV2OriginError(t *testing.T) { require.NoError(err) require.Equal(prefetchResponse{ Message: fmt.Sprintf("failed to trigger image prefetch: at least one layer could not be prefetched: digest %q, namespace %q, blob prefetch failure: foo err", layers[1], namespace), - TraceId: "abc", Status: "failure", Prefetched: false, }, resBody) From 767ae7c2c3765dcf665e7fc5a300c63427c0a1d0 Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 9 Mar 2026 14:16:55 +0100 Subject: [PATCH 27/32] fix: fix --- utils/httputil/httputil.go | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/utils/httputil/httputil.go b/utils/httputil/httputil.go index 82121afff..392a949a7 100644 --- a/utils/httputil/httputil.go +++ b/utils/httputil/httputil.go @@ -27,14 +27,9 @@ import ( "github.com/go-chi/chi" "github.com/uber/kraken/core" "github.com/uber/kraken/utils/handler" -<<<<<<< HEAD - - "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp" -======= "github.com/uber/kraken/utils/log" "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp" "go.opentelemetry.io/otel/trace" ->>>>>>> master ) var retryableCodes = map[int]struct{}{ @@ -321,16 +316,6 @@ func Send(method, rawurl string, options ...SendOption) (*http.Response, error) o(opts) } -<<<<<<< HEAD - // Apply tracing context wrapping AFTER all other options are processed - // This ensures SendTLS and other transport options are respected - if opts.tracingContext { - baseTransport := opts.transport - if baseTransport == nil { - baseTransport = http.DefaultTransport - } - opts.transport = otelhttp.NewTransport(baseTransport) -======= baseTransport := opts.transport if baseTransport == nil { baseTransport = http.DefaultTransport @@ -342,7 +327,6 @@ func Send(method, rawurl string, options ...SendOption) (*http.Response, error) opts.transport = otelhttp.NewTransport(baseTransport) } else { opts.transport = baseTransport ->>>>>>> master } req, err := newRequest(method, opts) From b4d9847371d39475d7bd65467f46a156ec5341d7 Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 9 Mar 2026 14:17:50 +0100 Subject: [PATCH 28/32] fix: fix --- utils/httputil/httputil.go | 27 ++++++++------------------- 1 file changed, 8 insertions(+), 19 deletions(-) diff --git a/utils/httputil/httputil.go b/utils/httputil/httputil.go index 392a949a7..9fb9e9ee2 100644 --- a/utils/httputil/httputil.go +++ b/utils/httputil/httputil.go @@ -139,15 +139,14 @@ func IsNetworkError(err error) bool { } type sendOptions struct { - body io.Reader - timeout time.Duration - acceptedCodes map[int]bool - headers map[string]string - redirect func(req *http.Request, via []*http.Request) error - retry retryOptions - transport http.RoundTripper - ctx context.Context - tracingContext bool + body io.Reader + timeout time.Duration + acceptedCodes map[int]bool + headers map[string]string + redirect func(req *http.Request, via []*http.Request) error + retry retryOptions + transport http.RoundTripper + ctx context.Context // This is not a valid http option. It provides a way to override // parts of the url. For example, url.Scheme can be changed from @@ -285,16 +284,6 @@ func SendContext(ctx context.Context) SendOption { return func(o *sendOptions) { o.ctx = ctx } } -// SendTracingContext sets the context and enables OpenTelemetry trace context -// propagation via HTTP headers. The transport will be wrapped with otelhttp -// after all options are applied. -func SendTracingContext(ctx context.Context) SendOption { - return func(o *sendOptions) { - o.ctx = ctx - o.tracingContext = true - } -} - // Send sends an HTTP request. May return NetworkError or StatusError (see above). func Send(method, rawurl string, options ...SendOption) (*http.Response, error) { u, err := url.Parse(rawurl) From 8bedd6824a7aeb38c5110d1561a76968320f85e8 Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 9 Mar 2026 14:22:48 +0100 Subject: [PATCH 29/32] fix: fix err --- proxy/proxyserver/server_test.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/proxy/proxyserver/server_test.go b/proxy/proxyserver/server_test.go index 46495af31..92e57b45d 100644 --- a/proxy/proxyserver/server_test.go +++ b/proxy/proxyserver/server_test.go @@ -170,7 +170,7 @@ func TestPrefetchV1MalformedTag(t *testing.T) { addr := mocks.startServer() - b, _ := json.Marshal(prefetchBody{ + b, err := json.Marshal(prefetchBody{ Tag: "invalid", }) require.NoError(err) @@ -198,7 +198,7 @@ func TestPrefetchV1(t *testing.T) { layers := core.DigestListFixture(3) manifest, bs := dockerutil.ManifestFixture(layers[0], layers[1], layers[2]) - b, _ := json.Marshal(prefetchBody{ + b, err := json.Marshal(prefetchBody{ Tag: fmt.Sprintf("%s/%s/%s", repo, namespace, tag), }) require.NoError(err) @@ -208,7 +208,7 @@ func TestPrefetchV1(t *testing.T) { mocks.originClient.EXPECT().DownloadBlob(gomock.Any(), namespace, manifest, mockutil.MatchWriter(bs)).Return(nil) mocks.originClient.EXPECT().DownloadBlob(gomock.Any(), namespace, layers[1], io.Discard).Return(nil) mocks.originClient.EXPECT().DownloadBlob(gomock.Any(), namespace, layers[2], io.Discard).Return(nil) - _, err := httputil.Post( + _, err = httputil.Post( fmt.Sprintf("http://%s/proxy/v1/registry/prefetch", addr), httputil.SendBody(bytes.NewReader(b))) require.NoError(err) @@ -229,7 +229,7 @@ func TestPrefetchV2(t *testing.T) { layers := core.DigestListFixture(3) manifest, bs := dockerutil.ManifestFixture(layers[0], layers[1], layers[2]) - b, _ := json.Marshal(prefetchBody{ + b, err := json.Marshal(prefetchBody{ Tag: fmt.Sprintf("%s/%s/%s", repo, namespace, tag), }) require.NoError(err) @@ -274,7 +274,7 @@ func TestPrefetchV2OriginError(t *testing.T) { layers := core.DigestListFixture(3) manifest, bs := dockerutil.ManifestFixture(layers[0], layers[1], layers[2]) - b, _ := json.Marshal(prefetchBody{ + b, err := json.Marshal(prefetchBody{ Tag: fmt.Sprintf("%s/%s/%s", repo, namespace, tag), }) require.NoError(err) From 5b535eda16e591b2fa66d55207080fddcdd8f30c Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 9 Mar 2026 14:32:09 +0100 Subject: [PATCH 30/32] Update proxy/proxyserver/prefetch.go Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- proxy/proxyserver/prefetch.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proxy/proxyserver/prefetch.go b/proxy/proxyserver/prefetch.go index 6dbba6a3b..e022f3a29 100644 --- a/proxy/proxyserver/prefetch.go +++ b/proxy/proxyserver/prefetch.go @@ -337,7 +337,7 @@ func (ph *PrefetchHandler) downloadBlobs(input *prefetchInput) { span.RecordError(errors.Join(errList...)) span.SetStatus(codes.Error, fmt.Sprintf("%d blob downloads failed", len(errList))) for _, err := range errList { - log.WithTraceContext(input.ctx).With("error", err).Error("Error downloading blob") + log.WithTraceContext(ctx).With("error", err).Error("Error downloading blob") } } else { span.SetStatus(codes.Ok, "all blobs downloaded") From ce80978c7656954b4500c819108bc0641dad8f6e Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 9 Mar 2026 14:42:10 +0100 Subject: [PATCH 31/32] fix: fix comments --- proxy/proxyserver/prefetch.go | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/proxy/proxyserver/prefetch.go b/proxy/proxyserver/prefetch.go index e022f3a29..92901f530 100644 --- a/proxy/proxyserver/prefetch.go +++ b/proxy/proxyserver/prefetch.go @@ -207,7 +207,6 @@ type prefetchInput struct { // If an error occurs, preparePrefetch returns the appropriate HTTP response. func (ph *PrefetchHandler) preparePrefetch(w http.ResponseWriter, r *http.Request) (res *prefetchInput, errOccurred bool) { ctx, span := ph.tracer.Start(r.Context(), "prefetch.prepare", - trace.WithSpanKind(trace.SpanKindServer), trace.WithAttributes( attribute.String("component", "proxy-prefetch"), attribute.String("operation", "prepare_prefetch"), @@ -305,7 +304,7 @@ func (ph *PrefetchHandler) downloadBlobs(input *prefetchInput) { var errList []error for _, b := range input.blobs { - if ph.shouldSkipPrefetch(input.ctx, b) { + if ph.shouldSkipPrefetch(ctx, b) { continue } @@ -476,14 +475,12 @@ func (ph *PrefetchHandler) triggerPrefetchBlobs(input *prefetchInput) error { ) defer span.End() - _ = ctx // PrefetchBlob doesn't accept context yet - var wg sync.WaitGroup var mu sync.Mutex var errList []error for _, b := range input.blobs { - if ph.shouldSkipPrefetch(input.ctx, b) { + if ph.shouldSkipPrefetch(ctx, b) { continue } From 45b9950376a5846ce5365c8890997a95dee55ad4 Mon Sep 17 00:00:00 2001 From: hweawer Date: Mon, 9 Mar 2026 15:28:29 +0100 Subject: [PATCH 32/32] fix context --- proxy/proxyserver/prefetch.go | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/proxy/proxyserver/prefetch.go b/proxy/proxyserver/prefetch.go index 92901f530..76e84ae8e 100644 --- a/proxy/proxyserver/prefetch.go +++ b/proxy/proxyserver/prefetch.go @@ -188,15 +188,14 @@ func (ph *PrefetchHandler) HandleV1(w http.ResponseWriter, r *http.Request) { writePrefetchResponse(w, input.tag, "prefetching initiated successfully") if ph.v1Synchronous { - ph.downloadBlobs(input) + ph.downloadBlobs(r.Context(), input) } else { // Download blobs asynchronously. - go ph.downloadBlobs(input) + go ph.downloadBlobs(r.Context(), input) } } type prefetchInput struct { - ctx context.Context blobs []blobInfo namespace string tag string @@ -279,7 +278,6 @@ func (ph *PrefetchHandler) preparePrefetch(w http.ResponseWriter, r *http.Reques span.SetStatus(codes.Ok, "prepare completed") return &prefetchInput{ - ctx: ctx, blobs: blobs, namespace: namespace, tag: tag, @@ -287,8 +285,8 @@ func (ph *PrefetchHandler) preparePrefetch(w http.ResponseWriter, r *http.Reques } // downloadBlobs downloads blobs in parallel. -func (ph *PrefetchHandler) downloadBlobs(input *prefetchInput) { - ctx, span := ph.tracer.Start(input.ctx, "prefetch.download_blobs", +func (ph *PrefetchHandler) downloadBlobs(ctx context.Context, input *prefetchInput) { + ctx, span := ph.tracer.Start(ctx, "prefetch.download_blobs", trace.WithAttributes( attribute.String("component", "proxy-prefetch"), attribute.String("operation", "download_blobs"), @@ -451,10 +449,10 @@ func (ph *PrefetchHandler) HandleV2(w http.ResponseWriter, r *http.Request) { return } - err := ph.triggerPrefetchBlobs(input) + err := ph.triggerPrefetchBlobs(r.Context(), input) if err != nil { writeInternalError(w, fmt.Sprintf("failed to trigger image prefetch: %s", err)) - log.WithTraceContext(input.ctx).Errorf("Failed to trigger image prefetch") + log.WithTraceContext(r.Context()).Errorf("Failed to trigger image prefetch") return } @@ -463,8 +461,8 @@ func (ph *PrefetchHandler) HandleV2(w http.ResponseWriter, r *http.Request) { } // triggerPrefetchBlobs triggers a blob prefetch for all blobs in parallel. -func (ph *PrefetchHandler) triggerPrefetchBlobs(input *prefetchInput) error { - ctx, span := ph.tracer.Start(input.ctx, "prefetch.trigger_prefetch", +func (ph *PrefetchHandler) triggerPrefetchBlobs(ctx context.Context, input *prefetchInput) error { + ctx, span := ph.tracer.Start(ctx, "prefetch.trigger_prefetch", trace.WithAttributes( attribute.String("component", "proxy-prefetch"), attribute.String("operation", "trigger_prefetch"),