api: unexport api struct fields (#1229)

pkg/api/api.go

@@ -65,13 +65,13 @@ type Service interface {
 }
 
 type server struct {
-	Tags        *tags.Tags
-	Storer      storage.Storer
-	Resolver    resolver.Interface
-	Pss         pss.Interface
-	Traversal   traversal.Service
-	Logger      logging.Logger
-	Tracer      *tracing.Tracer
+	tags        *tags.Tags
+	storer      storage.Storer
+	resolver    resolver.Interface
+	pss         pss.Interface
+	traversal   traversal.Service
+	logger      logging.Logger
+	tracer      *tracing.Tracer
 	feedFactory feeds.Factory
 	Options
 	http.Handler
@@ -95,15 +95,15 @@ const (
 // New will create a and initialize a new API service.
 func New(tags *tags.Tags, storer storage.Storer, resolver resolver.Interface, pss pss.Interface, traversalService traversal.Service, feedFactory feeds.Factory, logger logging.Logger, tracer *tracing.Tracer, o Options) Service {
 	s := &server{
-		Tags:        tags,
-		Storer:      storer,
-		Resolver:    resolver,
-		Pss:         pss,
-		Traversal:   traversalService,
+		tags:        tags,
+		storer:      storer,
+		resolver:    resolver,
+		pss:         pss,
+		traversal:   traversalService,
 		feedFactory: feedFactory,
 		Options:     o,
-		Logger:      logger,
-		Tracer:      tracer,
+		logger:      logger,
+		tracer:      tracer,
 		metrics:     newMetrics(),
 		quit:        make(chan struct{}),
 	}
@@ -115,7 +115,7 @@ func New(tags *tags.Tags, storer storage.Storer, resolver resolver.Interface, ps
 
 // Close hangs up running websockets on shutdown.
 func (s *server) Close() error {
-	s.Logger.Info("api shutting down")
+	s.logger.Info("api shutting down")
 	close(s.quit)
 
 	done := make(chan struct{})
@@ -138,7 +138,7 @@ func (s *server) Close() error {
 func (s *server) getOrCreateTag(tagUid string) (*tags.Tag, bool, error) {
 	// if tag ID is not supplied, create a new tag
 	if tagUid == "" {
-		tag, err := s.Tags.Create(0)
+		tag, err := s.tags.Create(0)
 		if err != nil {
 			return nil, false, fmt.Errorf("cannot create tag: %w", err)
 		}
@@ -153,11 +153,11 @@ func (s *server) getTag(tagUid string) (*tags.Tag, error) {
 	if err != nil {
 		return nil, fmt.Errorf("cannot parse taguid: %w", err)
 	}
-	return s.Tags.Get(uint32(uid))
+	return s.tags.Get(uint32(uid))
 }
 
 func (s *server) resolveNameOrAddress(str string) (swarm.Address, error) {
-	log := s.Logger
+	log := s.logger
 
 	// Try and parse the name as a bzz address.
 	addr, err := swarm.ParseHexAddress(str)
@@ -167,13 +167,13 @@ func (s *server) resolveNameOrAddress(str string) (swarm.Address, error) {
 	}
 
 	// If no resolver is not available, return an error.
-	if s.Resolver == nil {
+	if s.resolver == nil {
 		return swarm.ZeroAddress, errNoResolver
 	}
 
 	// Try and resolve the name using the provided resolver.
 	log.Debugf("name resolve: attempting to resolve %s to bzz address", str)
-	addr, err = s.Resolver.Resolve(str)
+	addr, err = s.resolver.Resolve(str)
 	if err == nil {
 		log.Tracef("name resolve: resolved name %s to %s", str, addr)
 		return addr, nil
@@ -197,18 +197,18 @@ func requestEncrypt(r *http.Request) bool {
 func (s *server) newTracingHandler(spanName string) func(h http.Handler) http.Handler {
 	return func(h http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			ctx, err := s.Tracer.WithContextFromHTTPHeaders(r.Context(), r.Header)
+			ctx, err := s.tracer.WithContextFromHTTPHeaders(r.Context(), r.Header)
 			if err != nil && !errors.Is(err, tracing.ErrContextNotFound) {
-				s.Logger.Debugf("span '%s': extract tracing context: %v", spanName, err)
+				s.logger.Debugf("span '%s': extract tracing context: %v", spanName, err)
 				// ignore
 			}
 
-			span, _, ctx := s.Tracer.StartSpanFromContext(ctx, spanName, s.Logger)
+			span, _, ctx := s.tracer.StartSpanFromContext(ctx, spanName, s.logger)
 			defer span.Finish()
 
-			err = s.Tracer.AddContextHTTPHeader(ctx, r.Header)
+			err = s.tracer.AddContextHTTPHeader(ctx, r.Header)
 			if err != nil {
-				s.Logger.Debugf("span '%s': inject tracing context: %v", spanName, err)
+				s.logger.Debugf("span '%s': inject tracing context: %v", spanName, err)
 				// ignore
 			}
 

pkg/api/bytes.go

@@ -23,7 +23,7 @@ type bytesPostResponse struct {
 
 // bytesUploadHandler handles upload of raw binary data of arbitrary length.
 func (s *server) bytesUploadHandler(w http.ResponseWriter, r *http.Request) {
-	logger := tracing.NewLoggerWithTraceID(r.Context(), s.Logger)
+	logger := tracing.NewLoggerWithTraceID(r.Context(), s.logger)
 
 	tag, created, err := s.getOrCreateTag(r.Header.Get(SwarmTagHeader))
 	if err != nil {
@@ -38,8 +38,8 @@ func (s *server) bytesUploadHandler(w http.ResponseWriter, r *http.Request) {
 		if estimatedTotalChunks := requestCalculateNumberOfChunks(r); estimatedTotalChunks > 0 {
 			err = tag.IncN(tags.TotalChunks, estimatedTotalChunks)
 			if err != nil {
-				s.Logger.Debugf("bytes upload: increment tag: %v", err)
-				s.Logger.Error("bytes upload: increment tag")
+				s.logger.Debugf("bytes upload: increment tag: %v", err)
+				s.logger.Error("bytes upload: increment tag")
 				jsonhttp.InternalServerError(w, "increment tag")
 				return
 			}
@@ -49,7 +49,7 @@ func (s *server) bytesUploadHandler(w http.ResponseWriter, r *http.Request) {
 	// Add the tag to the context
 	ctx := sctx.SetTag(r.Context(), tag)
 
-	pipe := builder.NewPipelineBuilder(ctx, s.Storer, requestModePut(r), requestEncrypt(r))
+	pipe := builder.NewPipelineBuilder(ctx, s.storer, requestModePut(r), requestEncrypt(r))
 	address, err := builder.FeedPipeline(ctx, pipe, r.Body, r.ContentLength)
 	if err != nil {
 		logger.Debugf("bytes upload: split write all: %v", err)
@@ -75,7 +75,7 @@ func (s *server) bytesUploadHandler(w http.ResponseWriter, r *http.Request) {
 
 // bytesGetHandler handles retrieval of raw binary data of arbitrary length.
 func (s *server) bytesGetHandler(w http.ResponseWriter, r *http.Request) {
-	logger := tracing.NewLoggerWithTraceID(r.Context(), s.Logger).Logger
+	logger := tracing.NewLoggerWithTraceID(r.Context(), s.logger).Logger
 	nameOrHex := mux.Vars(r)["address"]
 
 	address, err := s.resolveNameOrAddress(nameOrHex)

pkg/api/bzz.go

@@ -34,8 +34,8 @@ import (
 )
 
 func (s *server) bzzDownloadHandler(w http.ResponseWriter, r *http.Request) {
-	logger := tracing.NewLoggerWithTraceID(r.Context(), s.Logger)
-	ls := loadsave.New(s.Storer, storage.ModePutRequest, false)
+	logger := tracing.NewLoggerWithTraceID(r.Context(), s.logger)
+	ls := loadsave.New(s.storer, storage.ModePutRequest, false)
 	feedDereferenced := false
 
 	targets := r.URL.Query().Get("targets")
@@ -62,7 +62,7 @@ func (s *server) bzzDownloadHandler(w http.ResponseWriter, r *http.Request) {
 
 FETCH:
 	// read manifest entry
-	j, _, err := joiner.New(ctx, s.Storer, address)
+	j, _, err := joiner.New(ctx, s.storer, address)
 	if err != nil {
 		logger.Debugf("bzz download: joiner manifest entry %s: %v", address, err)
 		logger.Errorf("bzz download: joiner %s", address)
@@ -104,8 +104,8 @@ FETCH:
 			feedDereferenced = true
 			curBytes, err := cur.MarshalBinary()
 			if err != nil {
-				s.Logger.Debugf("bzz download: marshal feed index: %v", err)
-				s.Logger.Error("bzz download: marshal index")
+				s.logger.Debugf("bzz download: marshal feed index: %v", err)
+				s.logger.Error("bzz download: marshal index")
 				jsonhttp.InternalServerError(w, "marshal index")
 				return
 			}
@@ -129,7 +129,7 @@ FETCH:
 	}
 
 	// read metadata
-	j, _, err = joiner.New(ctx, s.Storer, e.Metadata())
+	j, _, err = joiner.New(ctx, s.storer, e.Metadata())
 	if err != nil {
 		logger.Debugf("bzz download: joiner metadata %s: %v", address, err)
 		logger.Errorf("bzz download: joiner %s", address)
@@ -251,13 +251,13 @@ FETCH:
 
 func (s *server) serveManifestEntry(w http.ResponseWriter, r *http.Request, address, manifestEntryAddress swarm.Address, etag bool) {
 	var (
-		logger = tracing.NewLoggerWithTraceID(r.Context(), s.Logger)
+		logger = tracing.NewLoggerWithTraceID(r.Context(), s.logger)
 		ctx    = r.Context()
 		buf    = bytes.NewBuffer(nil)
 	)
 
 	// read file entry
-	j, _, err := joiner.New(ctx, s.Storer, manifestEntryAddress)
+	j, _, err := joiner.New(ctx, s.storer, manifestEntryAddress)
 	if err != nil {
 		logger.Debugf("bzz download: joiner read file entry %s: %v", address, err)
 		logger.Errorf("bzz download: joiner read file entry %s", address)
@@ -282,7 +282,7 @@ func (s *server) serveManifestEntry(w http.ResponseWriter, r *http.Request, addr
 	}
 
 	// read file metadata
-	j, _, err = joiner.New(ctx, s.Storer, fe.Metadata())
+	j, _, err = joiner.New(ctx, s.storer, fe.Metadata())
 	if err != nil {
 		logger.Debugf("bzz download: joiner read file entry %s: %v", address, err)
 		logger.Errorf("bzz download: joiner read file entry %s", address)

pkg/api/chunk.go

@@ -37,8 +37,8 @@ func (s *server) chunkUploadHandler(w http.ResponseWriter, r *http.Request) {
 	if h := r.Header.Get(SwarmTagHeader); h != "" {
 		tag, err = s.getTag(h)
 		if err != nil {
-			s.Logger.Debugf("chunk upload: get tag: %v", err)
-			s.Logger.Error("chunk upload: get tag")
+			s.logger.Debugf("chunk upload: get tag: %v", err)
+			s.logger.Error("chunk upload: get tag")
 			jsonhttp.BadRequest(w, "cannot get tag")
 			return
 
@@ -50,8 +50,8 @@ func (s *server) chunkUploadHandler(w http.ResponseWriter, r *http.Request) {
 		// increment the StateSplit here since we dont have a splitter for the file upload
 		err = tag.Inc(tags.StateSplit)
 		if err != nil {
-			s.Logger.Debugf("chunk upload: increment tag: %v", err)
-			s.Logger.Error("chunk upload: increment tag")
+			s.logger.Debugf("chunk upload: increment tag: %v", err)
+			s.logger.Error("chunk upload: increment tag")
 			jsonhttp.InternalServerError(w, "increment tag")
 			return
 		}
@@ -62,15 +62,15 @@ func (s *server) chunkUploadHandler(w http.ResponseWriter, r *http.Request) {
 		if jsonhttp.HandleBodyReadError(err, w) {
 			return
 		}
-		s.Logger.Debugf("chunk upload: read chunk data error: %v", err)
-		s.Logger.Error("chunk upload: read chunk data error")
+		s.logger.Debugf("chunk upload: read chunk data error: %v", err)
+		s.logger.Error("chunk upload: read chunk data error")
 		jsonhttp.InternalServerError(w, "cannot read chunk data")
 		return
 	}
 
 	if len(data) < swarm.SpanSize {
-		s.Logger.Debug("chunk upload: not enough data")
-		s.Logger.Error("chunk upload: data length")
+		s.logger.Debug("chunk upload: not enough data")
+		s.logger.Error("chunk upload: data length")
 		jsonhttp.BadRequest(w, "data length")
 		return
 	}
@@ -80,8 +80,8 @@ func (s *server) chunkUploadHandler(w http.ResponseWriter, r *http.Request) {
 
 	err = hasher.SetSpanBytes(data[:swarm.SpanSize])
 	if err != nil {
-		s.Logger.Debugf("chunk upload: set span: %v", err)
-		s.Logger.Error("chunk upload: span error")
+		s.logger.Debugf("chunk upload: set span: %v", err)
+		s.logger.Error("chunk upload: span error")
 		jsonhttp.InternalServerError(w, "span error")
 		return
 	}
@@ -94,17 +94,17 @@ func (s *server) chunkUploadHandler(w http.ResponseWriter, r *http.Request) {
 	address := swarm.NewAddress(hasher.Sum(nil))
 	chunk := swarm.NewChunk(address, data)
 
-	seen, err := s.Storer.Put(ctx, requestModePut(r), chunk)
+	seen, err := s.storer.Put(ctx, requestModePut(r), chunk)
 	if err != nil {
-		s.Logger.Debugf("chunk upload: chunk write error: %v, addr %s", err, address)
-		s.Logger.Error("chunk upload: chunk write error")
+		s.logger.Debugf("chunk upload: chunk write error: %v, addr %s", err, address)
+		s.logger.Error("chunk upload: chunk write error")
 		jsonhttp.BadRequest(w, "chunk write error")
 		return
 	} else if len(seen) > 0 && seen[0] && tag != nil {
 		err := tag.Inc(tags.StateSeen)
 		if err != nil {
-			s.Logger.Debugf("chunk upload: increment tag", err)
-			s.Logger.Error("chunk upload: increment tag")
+			s.logger.Debugf("chunk upload: increment tag", err)
+			s.logger.Error("chunk upload: increment tag")
 			jsonhttp.BadRequest(w, "increment tag")
 			return
 		}
@@ -114,8 +114,8 @@ func (s *server) chunkUploadHandler(w http.ResponseWriter, r *http.Request) {
 		// indicate that the chunk is stored
 		err = tag.Inc(tags.StateStored)
 		if err != nil {
-			s.Logger.Debugf("chunk upload: increment tag", err)
-			s.Logger.Error("chunk upload: increment tag")
+			s.logger.Debugf("chunk upload: increment tag", err)
+			s.logger.Error("chunk upload: increment tag")
 			jsonhttp.InternalServerError(w, "increment tag")
 			return
 		}
@@ -137,27 +137,27 @@ func (s *server) chunkGetHandler(w http.ResponseWriter, r *http.Request) {
 
 	address, err := s.resolveNameOrAddress(nameOrHex)
 	if err != nil {
-		s.Logger.Debugf("chunk: parse chunk address %s: %v", nameOrHex, err)
-		s.Logger.Error("chunk: parse chunk address error")
+		s.logger.Debugf("chunk: parse chunk address %s: %v", nameOrHex, err)
+		s.logger.Error("chunk: parse chunk address error")
 		jsonhttp.NotFound(w, nil)
 		return
 	}
 
-	chunk, err := s.Storer.Get(ctx, storage.ModeGetRequest, address)
+	chunk, err := s.storer.Get(ctx, storage.ModeGetRequest, address)
 	if err != nil {
 		if errors.Is(err, storage.ErrNotFound) {
-			s.Logger.Tracef("chunk: chunk not found. addr %s", address)
+			s.logger.Tracef("chunk: chunk not found. addr %s", address)
 			jsonhttp.NotFound(w, "chunk not found")
 			return
 
 		}
 		if errors.Is(err, netstore.ErrRecoveryAttempt) {
-			s.Logger.Tracef("chunk: chunk recovery initiated. addr %s", address)
+			s.logger.Tracef("chunk: chunk recovery initiated. addr %s", address)
 			jsonhttp.Accepted(w, "chunk recovery initiated. retry after sometime.")
 			return
 		}
-		s.Logger.Debugf("chunk: chunk read error: %v ,addr %s", err, address)
-		s.Logger.Error("chunk: chunk read error")
+		s.logger.Debugf("chunk: chunk read error: %v ,addr %s", err, address)
+		s.logger.Error("chunk: chunk read error")
 		jsonhttp.InternalServerError(w, "chunk read error")
 		return
 	}

pkg/api/dirs.go

@@ -43,7 +43,7 @@ const (
 
 // dirUploadHandler uploads a directory supplied as a tar in an HTTP request
 func (s *server) dirUploadHandler(w http.ResponseWriter, r *http.Request) {
-	logger := tracing.NewLoggerWithTraceID(r.Context(), s.Logger)
+	logger := tracing.NewLoggerWithTraceID(r.Context(), s.logger)
 	err := validateRequest(r)
 	if err != nil {
 		logger.Errorf("dir upload, validate request")
@@ -62,10 +62,10 @@ func (s *server) dirUploadHandler(w http.ResponseWriter, r *http.Request) {
 
 	// Add the tag to the context
 	ctx := sctx.SetTag(r.Context(), tag)
-	p := requestPipelineFn(s.Storer, r)
+	p := requestPipelineFn(s.storer, r)
 	encrypt := requestEncrypt(r)
-	l := loadsave.New(s.Storer, requestModePut(r), encrypt)
-	reference, err := storeDir(ctx, encrypt, r.Body, s.Logger, p, l, r.Header.Get(SwarmIndexDocumentHeader), r.Header.Get(SwarmErrorDocumentHeader), tag, created)
+	l := loadsave.New(s.storer, requestModePut(r), encrypt)
+	reference, err := storeDir(ctx, encrypt, r.Body, s.logger, p, l, r.Header.Get(SwarmIndexDocumentHeader), r.Header.Get(SwarmErrorDocumentHeader), tag, created)
 	if err != nil {
 		logger.Debugf("dir upload: store dir err: %v", err)
 		logger.Errorf("dir upload: store dir")

pkg/api/feed.go

@@ -40,16 +40,16 @@ type feedReferenceResponse struct {
 func (s *server) feedGetHandler(w http.ResponseWriter, r *http.Request) {
 	owner, err := hex.DecodeString(mux.Vars(r)["owner"])
 	if err != nil {
-		s.Logger.Debugf("feed get: decode owner: %v", err)
-		s.Logger.Error("feed get: bad owner")
+		s.logger.Debugf("feed get: decode owner: %v", err)
+		s.logger.Error("feed get: bad owner")
 		jsonhttp.BadRequest(w, "bad owner")
 		return
 	}
 
 	topic, err := hex.DecodeString(mux.Vars(r)["topic"])
 	if err != nil {
-		s.Logger.Debugf("feed get: decode topic: %v", err)
-		s.Logger.Error("feed get: bad topic")
+		s.logger.Debugf("feed get: decode topic: %v", err)
+		s.logger.Error("feed get: bad topic")
 		jsonhttp.BadRequest(w, "bad topic")
 		return
 	}
@@ -59,8 +59,8 @@ func (s *server) feedGetHandler(w http.ResponseWriter, r *http.Request) {
 	if atStr != "" {
 		at, err = strconv.ParseInt(atStr, 10, 64)
 		if err != nil {
-			s.Logger.Debugf("feed get: decode at: %v", err)
-			s.Logger.Error("feed get: bad at")
+			s.logger.Debugf("feed get: decode at: %v", err)
+			s.logger.Error("feed get: bad at")
 			jsonhttp.BadRequest(w, "bad at")
 			return
 		}
@@ -71,48 +71,48 @@ func (s *server) feedGetHandler(w http.ResponseWriter, r *http.Request) {
 	f := feeds.New(topic, common.BytesToAddress(owner))
 	lookup, err := s.feedFactory.NewLookup(feeds.Sequence, f)
 	if err != nil {
-		s.Logger.Debugf("feed get: new lookup: %v", err)
-		s.Logger.Error("feed get: new lookup")
+		s.logger.Debugf("feed get: new lookup: %v", err)
+		s.logger.Error("feed get: new lookup")
 		jsonhttp.InternalServerError(w, "new lookup")
 		return
 	}
 
 	ch, cur, next, err := lookup.At(r.Context(), at, 0)
 	if err != nil {
-		s.Logger.Debugf("feed get: lookup: %v", err)
-		s.Logger.Error("feed get: lookup error")
+		s.logger.Debugf("feed get: lookup: %v", err)
+		s.logger.Error("feed get: lookup error")
 		jsonhttp.NotFound(w, "lookup failed")
 		return
 	}
 
 	// KLUDGE: if a feed was never updated, the chunk will be nil
 	if ch == nil {
-		s.Logger.Debugf("feed get: no update found: %v", err)
-		s.Logger.Error("feed get: no update found")
+		s.logger.Debugf("feed get: no update found: %v", err)
+		s.logger.Error("feed get: no update found")
 		jsonhttp.NotFound(w, "lookup failed")
 		return
 	}
 
 	ref, _, err := parseFeedUpdate(ch)
 	if err != nil {
-		s.Logger.Debugf("feed get: parse update: %v", err)
-		s.Logger.Error("feed get: parse update")
+		s.logger.Debugf("feed get: parse update: %v", err)
+		s.logger.Error("feed get: parse update")
 		jsonhttp.InternalServerError(w, "parse update")
 		return
 	}
 
 	curBytes, err := cur.MarshalBinary()
 	if err != nil {
-		s.Logger.Debugf("feed get: marshal current index: %v", err)
-		s.Logger.Error("feed get: marshal index")
+		s.logger.Debugf("feed get: marshal current index: %v", err)
+		s.logger.Error("feed get: marshal index")
 		jsonhttp.InternalServerError(w, "marshal index")
 		return
 	}
 
 	nextBytes, err := next.MarshalBinary()
 	if err != nil {
-		s.Logger.Debugf("feed get: marshal next index: %v", err)
-		s.Logger.Error("feed get: marshal index")
+		s.logger.Debugf("feed get: marshal next index: %v", err)
+		s.logger.Error("feed get: marshal index")
 		jsonhttp.InternalServerError(w, "marshal index")
 		return
 	}
@@ -127,24 +127,24 @@ func (s *server) feedGetHandler(w http.ResponseWriter, r *http.Request) {
 func (s *server) feedPostHandler(w http.ResponseWriter, r *http.Request) {
 	owner, err := hex.DecodeString(mux.Vars(r)["owner"])
 	if err != nil {
-		s.Logger.Debugf("feed put: decode owner: %v", err)
-		s.Logger.Error("feed put: bad owner")
+		s.logger.Debugf("feed put: decode owner: %v", err)
+		s.logger.Error("feed put: bad owner")
 		jsonhttp.BadRequest(w, "bad owner")
 		return
 	}
 
 	topic, err := hex.DecodeString(mux.Vars(r)["topic"])
 	if err != nil {
-		s.Logger.Debugf("feed put: decode topic: %v", err)
-		s.Logger.Error("feed put: bad topic")
+		s.logger.Debugf("feed put: decode topic: %v", err)
+		s.logger.Error("feed put: bad topic")
 		jsonhttp.BadRequest(w, "bad topic")
 		return
 	}
-	l := loadsave.New(s.Storer, requestModePut(r), false)
+	l := loadsave.New(s.storer, requestModePut(r), false)
 	feedManifest, err := manifest.NewDefaultManifest(l, false)
 	if err != nil {
-		s.Logger.Debugf("feed put: new manifest: %v", err)
-		s.Logger.Error("feed put: new manifest")
+		s.logger.Debugf("feed put: new manifest: %v", err)
+		s.logger.Error("feed put: new manifest")
 		jsonhttp.InternalServerError(w, "create manifest")
 		return
 	}
@@ -160,15 +160,15 @@ func (s *server) feedPostHandler(w http.ResponseWriter, r *http.Request) {
 	// a feed manifest stores the metadata at the root "/" path
 	err = feedManifest.Add(r.Context(), "/", manifest.NewEntry(swarm.NewAddress(emptyAddr), meta))
 	if err != nil {
-		s.Logger.Debugf("feed post: add manifest entry: %v", err)
-		s.Logger.Error("feed post: add manifest entry")
+		s.logger.Debugf("feed post: add manifest entry: %v", err)
+		s.logger.Error("feed post: add manifest entry")
 		jsonhttp.InternalServerError(w, nil)
 		return
 	}
 	ref, err := feedManifest.Store(r.Context())
 	if err != nil {
-		s.Logger.Debugf("feed post: store manifest: %v", err)
-		s.Logger.Error("feed post: store manifest")
+		s.logger.Debugf("feed post: store manifest: %v", err)
+		s.logger.Error("feed post: store manifest")
 		jsonhttp.InternalServerError(w, nil)
 		return
 	}

pkg/api/file.go

@@ -47,7 +47,7 @@ type fileUploadResponse struct {
 func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
 	var (
 		reader                  io.Reader
-		logger                  = tracing.NewLoggerWithTraceID(r.Context(), s.Logger)
+		logger                  = tracing.NewLoggerWithTraceID(r.Context(), s.logger)
 		fileName, contentLength string
 		fileSize                uint64
 		contentType             = r.Header.Get("Content-Type")
@@ -74,8 +74,8 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
 		if estimatedTotalChunks := requestCalculateNumberOfChunks(r); estimatedTotalChunks > 0 {
 			err = tag.IncN(tags.TotalChunks, estimatedTotalChunks)
 			if err != nil {
-				s.Logger.Debugf("file upload: increment tag: %v", err)
-				s.Logger.Error("file upload: increment tag")
+				s.logger.Debugf("file upload: increment tag: %v", err)
+				s.logger.Error("file upload: increment tag")
 				jsonhttp.InternalServerError(w, "increment tag")
 				return
 			}
@@ -164,7 +164,7 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
 		reader = tmp
 	}
 
-	p := requestPipelineFn(s.Storer, r)
+	p := requestPipelineFn(s.storer, r)
 
 	// first store the file and get its reference
 	fr, err := p(ctx, reader, int64(fileSize))
@@ -200,8 +200,8 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
 		estimatedTotalChunks := calculateNumberOfChunks(int64(len(metadataBytes)), requestEncrypt(r))
 		err = tag.IncN(tags.TotalChunks, estimatedTotalChunks+1)
 		if err != nil {
-			s.Logger.Debugf("file upload: increment tag: %v", err)
-			s.Logger.Error("file upload: increment tag")
+			s.logger.Debugf("file upload: increment tag: %v", err)
+			s.logger.Error("file upload: increment tag")
 			jsonhttp.InternalServerError(w, "increment tag")
 			return
 		}
@@ -258,7 +258,7 @@ type fileUploadInfo struct {
 
 // fileDownloadHandler downloads the file given the entry's reference.
 func (s *server) fileDownloadHandler(w http.ResponseWriter, r *http.Request) {
-	logger := tracing.NewLoggerWithTraceID(r.Context(), s.Logger)
+	logger := tracing.NewLoggerWithTraceID(r.Context(), s.logger)
 	nameOrHex := mux.Vars(r)["addr"]
 
 	address, err := s.resolveNameOrAddress(nameOrHex)
@@ -275,7 +275,7 @@ func (s *server) fileDownloadHandler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// read entry
-	j, _, err := joiner.New(r.Context(), s.Storer, address)
+	j, _, err := joiner.New(r.Context(), s.storer, address)
 	if err != nil {
 		logger.Debugf("file download: joiner %s: %v", address, err)
 		logger.Errorf("file download: joiner %s", address)
@@ -311,7 +311,7 @@ func (s *server) fileDownloadHandler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// read metadata
-	j, _, err = joiner.New(r.Context(), s.Storer, e.Metadata())
+	j, _, err = joiner.New(r.Context(), s.storer, e.Metadata())
 	if err != nil {
 		logger.Debugf("file download: joiner %s: %v", address, err)
 		logger.Errorf("file download: joiner %s", address)
@@ -346,13 +346,13 @@ func (s *server) fileDownloadHandler(w http.ResponseWriter, r *http.Request) {
 
 // downloadHandler contains common logic for dowloading Swarm file from API
 func (s *server) downloadHandler(w http.ResponseWriter, r *http.Request, reference swarm.Address, additionalHeaders http.Header, etag bool) {
-	logger := tracing.NewLoggerWithTraceID(r.Context(), s.Logger)
+	logger := tracing.NewLoggerWithTraceID(r.Context(), s.logger)
 	targets := r.URL.Query().Get("targets")
 	if targets != "" {
 		r = r.WithContext(sctx.SetTargets(r.Context(), targets))
 	}
 
-	reader, l, err := joiner.New(r.Context(), s.Storer, reference)
+	reader, l, err := joiner.New(r.Context(), s.storer, reference)
 	if err != nil {
 		if errors.Is(err, storage.ErrNotFound) {
 			logger.Debugf("api download: not found %s: %v", reference, err)

pkg/api/pin_bytes.go

@@ -19,25 +19,25 @@ import (
 func (s *server) pinBytes(w http.ResponseWriter, r *http.Request) {
 	addr, err := swarm.ParseHexAddress(mux.Vars(r)["address"])
 	if err != nil {
-		s.Logger.Debugf("pin bytes: parse address: %v", err)
-		s.Logger.Error("pin bytes: parse address")
+		s.logger.Debugf("pin bytes: parse address: %v", err)
+		s.logger.Error("pin bytes: parse address")
 		jsonhttp.BadRequest(w, "bad address")
 		return
 	}
 
-	has, err := s.Storer.Has(r.Context(), addr)
+	has, err := s.storer.Has(r.Context(), addr)
 	if err != nil {
-		s.Logger.Debugf("pin bytes: localstore has: %v", err)
-		s.Logger.Error("pin bytes: store")
+		s.logger.Debugf("pin bytes: localstore has: %v", err)
+		s.logger.Error("pin bytes: store")
 		jsonhttp.InternalServerError(w, err)
 		return
 	}
 
 	if !has {
-		_, err := s.Storer.Get(r.Context(), storage.ModeGetRequest, addr)
+		_, err := s.storer.Get(r.Context(), storage.ModeGetRequest, addr)
 		if err != nil {
-			s.Logger.Debugf("pin chunk: netstore get: %v", err)
-			s.Logger.Error("pin chunk: netstore")
+			s.logger.Debugf("pin chunk: netstore get: %v", err)
+			s.logger.Error("pin chunk: netstore")
 
 			jsonhttp.NotFound(w, nil)
 			return
@@ -48,17 +48,17 @@ func (s *server) pinBytes(w http.ResponseWriter, r *http.Request) {
 
 	chunkAddressFn := s.pinChunkAddressFn(ctx, addr)
 
-	err = s.Traversal.TraverseBytesAddresses(ctx, addr, chunkAddressFn)
+	err = s.traversal.TraverseBytesAddresses(ctx, addr, chunkAddressFn)
 	if err != nil {
-		s.Logger.Debugf("pin bytes: traverse chunks: %v, addr %s", err, addr)
+		s.logger.Debugf("pin bytes: traverse chunks: %v, addr %s", err, addr)
 
 		if errors.Is(err, traversal.ErrInvalidType) {
-			s.Logger.Error("pin bytes: invalid type")
+			s.logger.Error("pin bytes: invalid type")
 			jsonhttp.BadRequest(w, "invalid type")
 			return
 		}
 
-		s.Logger.Error("pin bytes: cannot pin")
+		s.logger.Error("pin bytes: cannot pin")
 		jsonhttp.InternalServerError(w, "cannot pin")
 		return
 	}
@@ -70,16 +70,16 @@ func (s *server) pinBytes(w http.ResponseWriter, r *http.Request) {
 func (s *server) unpinBytes(w http.ResponseWriter, r *http.Request) {
 	addr, err := swarm.ParseHexAddress(mux.Vars(r)["address"])
 	if err != nil {
-		s.Logger.Debugf("pin bytes: parse address: %v", err)
-		s.Logger.Error("pin bytes: parse address")
+		s.logger.Debugf("pin bytes: parse address: %v", err)
+		s.logger.Error("pin bytes: parse address")
 		jsonhttp.BadRequest(w, "bad address")
 		return
 	}
 
-	has, err := s.Storer.Has(r.Context(), addr)
+	has, err := s.storer.Has(r.Context(), addr)
 	if err != nil {
-		s.Logger.Debugf("pin bytes: localstore has: %v", err)
-		s.Logger.Error("pin bytes: store")
+		s.logger.Debugf("pin bytes: localstore has: %v", err)
+		s.logger.Error("pin bytes: store")
 		jsonhttp.InternalServerError(w, err)
 		return
 	}
@@ -93,17 +93,17 @@ func (s *server) unpinBytes(w http.ResponseWriter, r *http.Request) {
 
 	chunkAddressFn := s.unpinChunkAddressFn(ctx, addr)
 
-	err = s.Traversal.TraverseBytesAddresses(ctx, addr, chunkAddressFn)
+	err = s.traversal.TraverseBytesAddresses(ctx, addr, chunkAddressFn)
 	if err != nil {
-		s.Logger.Debugf("pin bytes: traverse chunks: %v, addr %s", err, addr)
+		s.logger.Debugf("pin bytes: traverse chunks: %v, addr %s", err, addr)
 
 		if errors.Is(err, traversal.ErrInvalidType) {
-			s.Logger.Error("pin bytes: invalid type")
+			s.logger.Error("pin bytes: invalid type")
 			jsonhttp.BadRequest(w, "invalid type")
 			return
 		}
 
-		s.Logger.Error("pin bytes: cannot unpin")
+		s.logger.Error("pin bytes: cannot unpin")
 		jsonhttp.InternalServerError(w, "cannot unpin")
 		return
 	}

pkg/api/pin_bzz.go

@@ -19,25 +19,25 @@ import (
 func (s *server) pinBzz(w http.ResponseWriter, r *http.Request) {
 	addr, err := swarm.ParseHexAddress(mux.Vars(r)["address"])
 	if err != nil {
-		s.Logger.Debugf("pin bzz: parse address: %v", err)
-		s.Logger.Error("pin bzz: parse address")
+		s.logger.Debugf("pin bzz: parse address: %v", err)
+		s.logger.Error("pin bzz: parse address")
 		jsonhttp.BadRequest(w, "bad address")
 		return
 	}
 
-	has, err := s.Storer.Has(r.Context(), addr)
+	has, err := s.storer.Has(r.Context(), addr)
 	if err != nil {
-		s.Logger.Debugf("pin bzz: localstore has: %v", err)
-		s.Logger.Error("pin bzz: store")
+		s.logger.Debugf("pin bzz: localstore has: %v", err)
+		s.logger.Error("pin bzz: store")
 		jsonhttp.InternalServerError(w, err)
 		return
 	}
 
 	if !has {
-		_, err := s.Storer.Get(r.Context(), storage.ModeGetRequest, addr)
+		_, err := s.storer.Get(r.Context(), storage.ModeGetRequest, addr)
 		if err != nil {
-			s.Logger.Debugf("pin chunk: netstore get: %v", err)
-			s.Logger.Error("pin chunk: netstore")
+			s.logger.Debugf("pin chunk: netstore get: %v", err)
+			s.logger.Error("pin chunk: netstore")
 
 			jsonhttp.NotFound(w, nil)
 			return
@@ -48,17 +48,17 @@ func (s *server) pinBzz(w http.ResponseWriter, r *http.Request) {
 
 	chunkAddressFn := s.pinChunkAddressFn(ctx, addr)
 
-	err = s.Traversal.TraverseManifestAddresses(ctx, addr, chunkAddressFn)
+	err = s.traversal.TraverseManifestAddresses(ctx, addr, chunkAddressFn)
 	if err != nil {
-		s.Logger.Debugf("pin bzz: traverse chunks: %v, addr %s", err, addr)
+		s.logger.Debugf("pin bzz: traverse chunks: %v, addr %s", err, addr)
 
 		if errors.Is(err, traversal.ErrInvalidType) {
-			s.Logger.Error("pin bzz: invalid type")
+			s.logger.Error("pin bzz: invalid type")
 			jsonhttp.BadRequest(w, "invalid type")
 			return
 		}
 
-		s.Logger.Error("pin bzz: cannot pin")
+		s.logger.Error("pin bzz: cannot pin")
 		jsonhttp.InternalServerError(w, "cannot pin")
 		return
 	}
@@ -70,16 +70,16 @@ func (s *server) pinBzz(w http.ResponseWriter, r *http.Request) {
 func (s *server) unpinBzz(w http.ResponseWriter, r *http.Request) {
 	addr, err := swarm.ParseHexAddress(mux.Vars(r)["address"])
 	if err != nil {
-		s.Logger.Debugf("pin bzz: parse address: %v", err)
-		s.Logger.Error("pin bzz: parse address")
+		s.logger.Debugf("pin bzz: parse address: %v", err)
+		s.logger.Error("pin bzz: parse address")
 		jsonhttp.BadRequest(w, "bad address")
 		return
 	}
 
-	has, err := s.Storer.Has(r.Context(), addr)
+	has, err := s.storer.Has(r.Context(), addr)
 	if err != nil {
-		s.Logger.Debugf("pin bzz: localstore has: %v", err)
-		s.Logger.Error("pin bzz: store")
+		s.logger.Debugf("pin bzz: localstore has: %v", err)
+		s.logger.Error("pin bzz: store")
 		jsonhttp.InternalServerError(w, err)
 		return
 	}
@@ -93,17 +93,17 @@ func (s *server) unpinBzz(w http.ResponseWriter, r *http.Request) {
 
 	chunkAddressFn := s.unpinChunkAddressFn(ctx, addr)
 
-	err = s.Traversal.TraverseManifestAddresses(ctx, addr, chunkAddressFn)
+	err = s.traversal.TraverseManifestAddresses(ctx, addr, chunkAddressFn)
 	if err != nil {
-		s.Logger.Debugf("pin bzz: traverse chunks: %v, addr %s", err, addr)
+		s.logger.Debugf("pin bzz: traverse chunks: %v, addr %s", err, addr)
 
 		if errors.Is(err, traversal.ErrInvalidType) {
-			s.Logger.Error("pin bzz: invalid type")
+			s.logger.Error("pin bzz: invalid type")
 			jsonhttp.BadRequest(w, "invalid type")
 			return
 		}
 
-		s.Logger.Error("pin bzz: cannot unpin")
+		s.logger.Error("pin bzz: cannot unpin")
 		jsonhttp.InternalServerError(w, "cannot unpin")
 		return
 	}

pkg/api/pin_files.go

@@ -19,25 +19,25 @@ import (
 func (s *server) pinFile(w http.ResponseWriter, r *http.Request) {
 	addr, err := swarm.ParseHexAddress(mux.Vars(r)["address"])
 	if err != nil {
-		s.Logger.Debugf("pin files: parse address: %v", err)
-		s.Logger.Error("pin files: parse address")
+		s.logger.Debugf("pin files: parse address: %v", err)
+		s.logger.Error("pin files: parse address")
 		jsonhttp.BadRequest(w, "bad address")
 		return
 	}
 
-	has, err := s.Storer.Has(r.Context(), addr)
+	has, err := s.storer.Has(r.Context(), addr)
 	if err != nil {
-		s.Logger.Debugf("pin files: localstore has: %v", err)
-		s.Logger.Error("pin files: store")
+		s.logger.Debugf("pin files: localstore has: %v", err)
+		s.logger.Error("pin files: store")
 		jsonhttp.InternalServerError(w, err)
 		return
 	}
 
 	if !has {
-		_, err := s.Storer.Get(r.Context(), storage.ModeGetRequest, addr)
+		_, err := s.storer.Get(r.Context(), storage.ModeGetRequest, addr)
 		if err != nil {
-			s.Logger.Debugf("pin chunk: netstore get: %v", err)
-			s.Logger.Error("pin chunk: netstore")
+			s.logger.Debugf("pin chunk: netstore get: %v", err)
+			s.logger.Error("pin chunk: netstore")
 
 			jsonhttp.NotFound(w, nil)
 			return
@@ -48,17 +48,17 @@ func (s *server) pinFile(w http.ResponseWriter, r *http.Request) {
 
 	chunkAddressFn := s.pinChunkAddressFn(ctx, addr)
 
-	err = s.Traversal.TraverseFileAddresses(ctx, addr, chunkAddressFn)
+	err = s.traversal.TraverseFileAddresses(ctx, addr, chunkAddressFn)
 	if err != nil {
-		s.Logger.Debugf("pin files: traverse chunks: %v, addr %s", err, addr)
+		s.logger.Debugf("pin files: traverse chunks: %v, addr %s", err, addr)
 
 		if errors.Is(err, traversal.ErrInvalidType) {
-			s.Logger.Error("pin files: invalid type")
+			s.logger.Error("pin files: invalid type")
 			jsonhttp.BadRequest(w, "invalid type")
 			return
 		}
 
-		s.Logger.Error("pin files: cannot pin")
+		s.logger.Error("pin files: cannot pin")
 		jsonhttp.InternalServerError(w, "cannot pin")
 		return
 	}
@@ -70,16 +70,16 @@ func (s *server) pinFile(w http.ResponseWriter, r *http.Request) {
 func (s *server) unpinFile(w http.ResponseWriter, r *http.Request) {
 	addr, err := swarm.ParseHexAddress(mux.Vars(r)["address"])
 	if err != nil {
-		s.Logger.Debugf("pin files: parse address: %v", err)
-		s.Logger.Error("pin files: parse address")
+		s.logger.Debugf("pin files: parse address: %v", err)
+		s.logger.Error("pin files: parse address")
 		jsonhttp.BadRequest(w, "bad address")
 		return
 	}
 
-	has, err := s.Storer.Has(r.Context(), addr)
+	has, err := s.storer.Has(r.Context(), addr)
 	if err != nil {
-		s.Logger.Debugf("pin files: localstore has: %v", err)
-		s.Logger.Error("pin files: store")
+		s.logger.Debugf("pin files: localstore has: %v", err)
+		s.logger.Error("pin files: store")
 		jsonhttp.InternalServerError(w, err)
 		return
 	}
@@ -93,17 +93,17 @@ func (s *server) unpinFile(w http.ResponseWriter, r *http.Request) {
 
 	chunkAddressFn := s.unpinChunkAddressFn(ctx, addr)
 
-	err = s.Traversal.TraverseFileAddresses(ctx, addr, chunkAddressFn)
+	err = s.traversal.TraverseFileAddresses(ctx, addr, chunkAddressFn)
 	if err != nil {
-		s.Logger.Debugf("pin files: traverse chunks: %v, addr %s", err, addr)
+		s.logger.Debugf("pin files: traverse chunks: %v, addr %s", err, addr)
 
 		if errors.Is(err, traversal.ErrInvalidType) {
-			s.Logger.Error("pin files: invalid type")
+			s.logger.Error("pin files: invalid type")
 			jsonhttp.BadRequest(w, "invalid type")
 			return
 		}
 
-		s.Logger.Error("pin files: cannot unpin")
+		s.logger.Error("pin files: cannot unpin")
 		jsonhttp.InternalServerError(w, "cannot unpin")
 		return
 	}

pkg/api/pss.go

@@ -37,8 +37,8 @@ func (s *server) pssPostHandler(w http.ResponseWriter, r *http.Request) {
 	for _, v := range tgts {
 		target, err := hex.DecodeString(v)
 		if err != nil || len(target) > targetMaxLength {
-			s.Logger.Debugf("pss send: bad targets: %v", err)
-			s.Logger.Error("pss send: bad targets")
+			s.logger.Debugf("pss send: bad targets: %v", err)
+			s.logger.Error("pss send: bad targets")
 			jsonhttp.BadRequest(w, nil)
 			return
 		}
@@ -55,8 +55,8 @@ func (s *server) pssPostHandler(w http.ResponseWriter, r *http.Request) {
 		var err error
 		recipient, err = pss.ParseRecipient(recipientQueryString)
 		if err != nil {
-			s.Logger.Debugf("pss recipient: %v", err)
-			s.Logger.Error("pss recipient")
+			s.logger.Debugf("pss recipient: %v", err)
+			s.logger.Error("pss recipient")
 			jsonhttp.BadRequest(w, nil)
 			return
 		}
@@ -64,16 +64,16 @@ func (s *server) pssPostHandler(w http.ResponseWriter, r *http.Request) {
 
 	payload, err := ioutil.ReadAll(r.Body)
 	if err != nil {
-		s.Logger.Debugf("pss read payload: %v", err)
-		s.Logger.Error("pss read payload")
+		s.logger.Debugf("pss read payload: %v", err)
+		s.logger.Error("pss read payload")
 		jsonhttp.InternalServerError(w, nil)
 		return
 	}
 
-	err = s.Pss.Send(r.Context(), topic, payload, recipient, targets)
+	err = s.pss.Send(r.Context(), topic, payload, recipient, targets)
 	if err != nil {
-		s.Logger.Debugf("pss send payload: %v. topic: %s", err, topicVar)
-		s.Logger.Error("pss send payload")
+		s.logger.Debugf("pss send payload: %v. topic: %s", err, topicVar)
+		s.logger.Error("pss send payload")
 		jsonhttp.InternalServerError(w, nil)
 		return
 	}
@@ -91,8 +91,8 @@ func (s *server) pssWsHandler(w http.ResponseWriter, r *http.Request) {
 
 	conn, err := upgrader.Upgrade(w, r, nil)
 	if err != nil {
-		s.Logger.Debugf("pss ws: upgrade: %v", err)
-		s.Logger.Error("pss ws: cannot upgrade")
+		s.logger.Debugf("pss ws: upgrade: %v", err)
+		s.logger.Error("pss ws: cannot upgrade")
 		jsonhttp.InternalServerError(w, nil)
 		return
 	}
@@ -116,14 +116,14 @@ func (s *server) pumpWs(conn *websocket.Conn, t string) {
 		ticker.Stop()
 		_ = conn.Close()
 	}()
-	cleanup := s.Pss.Register(topic, func(_ context.Context, m []byte) {
+	cleanup := s.pss.Register(topic, func(_ context.Context, m []byte) {
 		dataC <- m
 	})
 
 	defer cleanup()
 
 	conn.SetCloseHandler(func(code int, text string) error {
-		s.Logger.Debugf("pss handler: client gone. code %d message %s", code, text)
+		s.logger.Debugf("pss handler: client gone. code %d message %s", code, text)
 		close(gone)
 		return nil
 	})
@@ -133,13 +133,13 @@ func (s *server) pumpWs(conn *websocket.Conn, t string) {
 		case b := <-dataC:
 			err = conn.SetWriteDeadline(time.Now().Add(writeDeadline))
 			if err != nil {
-				s.Logger.Debugf("pss set write deadline: %v", err)
+				s.logger.Debugf("pss set write deadline: %v", err)
 				return
 			}
 
 			err = conn.WriteMessage(websocket.BinaryMessage, b)
 			if err != nil {
-				s.Logger.Debugf("pss write to websocket: %v", err)
+				s.logger.Debugf("pss write to websocket: %v", err)
 				return
 			}
 
@@ -147,12 +147,12 @@ func (s *server) pumpWs(conn *websocket.Conn, t string) {
 			// shutdown
 			err = conn.SetWriteDeadline(time.Now().Add(writeDeadline))
 			if err != nil {
-				s.Logger.Debugf("pss set write deadline: %v", err)
+				s.logger.Debugf("pss set write deadline: %v", err)
 				return
 			}
 			err = conn.WriteMessage(websocket.CloseMessage, []byte{})
 			if err != nil {
-				s.Logger.Debugf("pss write close message: %v", err)
+				s.logger.Debugf("pss write close message: %v", err)
 			}
 			return
 		case <-gone:
@@ -161,7 +161,7 @@ func (s *server) pumpWs(conn *websocket.Conn, t string) {
 		case <-ticker.C:
 			err = conn.SetWriteDeadline(time.Now().Add(writeDeadline))
 			if err != nil {
-				s.Logger.Debugf("pss set write deadline: %v", err)
+				s.logger.Debugf("pss set write deadline: %v", err)
 				return
 			}
 			if err = conn.WriteMessage(websocket.PingMessage, nil); err != nil {

pkg/api/router.go

@@ -190,7 +190,7 @@ func (s *server) setupRouting() {
 	)
 
 	s.Handler = web.ChainHandlers(
-		httpaccess.NewHTTPAccessLogHandler(s.Logger, logrus.InfoLevel, s.Tracer, "api access"),
+		httpaccess.NewHTTPAccessLogHandler(s.logger, logrus.InfoLevel, s.tracer, "api access"),
 		handlers.CompressHandler,
 		// todo: add recovery handler
 		s.pageviewMetricsHandler,
@@ -214,7 +214,7 @@ func (s *server) setupRouting() {
 func (s *server) gatewayModeForbidEndpointHandler(h http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if s.GatewayMode {
-			s.Logger.Tracef("gateway mode: forbidden %s", r.URL.String())
+			s.logger.Tracef("gateway mode: forbidden %s", r.URL.String())
 			jsonhttp.Forbidden(w, nil)
 			return
 		}
@@ -226,12 +226,12 @@ func (s *server) gatewayModeForbidHeadersHandler(h http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if s.GatewayMode {
 			if strings.ToLower(r.Header.Get(SwarmPinHeader)) == "true" {
-				s.Logger.Tracef("gateway mode: forbidden pinning %s", r.URL.String())
+				s.logger.Tracef("gateway mode: forbidden pinning %s", r.URL.String())
 				jsonhttp.Forbidden(w, "pinning is disabled")
 				return
 			}
 			if strings.ToLower(r.Header.Get(SwarmEncryptHeader)) == "true" {
-				s.Logger.Tracef("gateway mode: forbidden encryption %s", r.URL.String())
+				s.logger.Tracef("gateway mode: forbidden encryption %s", r.URL.String())
 				jsonhttp.Forbidden(w, "encryption is disabled")
 				return
 			}

pkg/api/soc.go

@@ -28,31 +28,31 @@ type socPostResponse struct {
 func (s *server) socUploadHandler(w http.ResponseWriter, r *http.Request) {
 	owner, err := hex.DecodeString(mux.Vars(r)["owner"])
 	if err != nil {
-		s.Logger.Debugf("soc upload: bad owner: %v", err)
-		s.Logger.Error("soc upload: %v", errBadRequestParams)
+		s.logger.Debugf("soc upload: bad owner: %v", err)
+		s.logger.Error("soc upload: %v", errBadRequestParams)
 		jsonhttp.BadRequest(w, "bad owner")
 		return
 	}
 	id, err := hex.DecodeString(mux.Vars(r)["id"])
 	if err != nil {
-		s.Logger.Debugf("soc upload: bad id: %v", err)
-		s.Logger.Error("soc upload: %v", errBadRequestParams)
+		s.logger.Debugf("soc upload: bad id: %v", err)
+		s.logger.Error("soc upload: %v", errBadRequestParams)
 		jsonhttp.BadRequest(w, "bad id")
 		return
 	}
 
 	sigStr := r.URL.Query().Get("sig")
 	if sigStr == "" {
-		s.Logger.Debugf("soc upload: empty signature")
-		s.Logger.Error("soc upload: empty signature")
+		s.logger.Debugf("soc upload: empty signature")
+		s.logger.Error("soc upload: empty signature")
 		jsonhttp.BadRequest(w, "empty signature")
 		return
 	}
 
 	sig, err := hex.DecodeString(sigStr)
 	if err != nil {
-		s.Logger.Debugf("soc upload: bad signature: %v", err)
-		s.Logger.Error("soc upload: bad signature")
+		s.logger.Debugf("soc upload: bad signature: %v", err)
+		s.logger.Error("soc upload: bad signature")
 		jsonhttp.BadRequest(w, "bad signature")
 		return
 	}
@@ -62,55 +62,55 @@ func (s *server) socUploadHandler(w http.ResponseWriter, r *http.Request) {
 		if jsonhttp.HandleBodyReadError(err, w) {
 			return
 		}
-		s.Logger.Debugf("soc upload: read chunk data error: %v", err)
-		s.Logger.Error("soc upload: read chunk data error")
+		s.logger.Debugf("soc upload: read chunk data error: %v", err)
+		s.logger.Error("soc upload: read chunk data error")
 		jsonhttp.InternalServerError(w, "cannot read chunk data")
 		return
 	}
 
 	if len(data) < swarm.SpanSize {
-		s.Logger.Debugf("soc upload: chunk data too short")
-		s.Logger.Error("soc upload: %v", errBadRequestParams)
+		s.logger.Debugf("soc upload: chunk data too short")
+		s.logger.Error("soc upload: %v", errBadRequestParams)
 		jsonhttp.BadRequest(w, "short chunk data")
 		return
 	}
 
 	if len(data) > swarm.ChunkSize+swarm.SpanSize {
-		s.Logger.Debugf("soc upload: chunk data exceeds %d bytes", swarm.ChunkSize+swarm.SpanSize)
-		s.Logger.Error("soc upload: chunk data error")
+		s.logger.Debugf("soc upload: chunk data exceeds %d bytes", swarm.ChunkSize+swarm.SpanSize)
+		s.logger.Error("soc upload: chunk data error")
 		jsonhttp.RequestEntityTooLarge(w, "payload too large")
 		return
 	}
 
 	ch, err := chunk(data)
 	if err != nil {
-		s.Logger.Debugf("soc upload: create content addressed chunk: %v", err)
-		s.Logger.Error("soc upload: chunk data error")
+		s.logger.Debugf("soc upload: create content addressed chunk: %v", err)
+		s.logger.Error("soc upload: chunk data error")
 		jsonhttp.BadRequest(w, "chunk data error")
 		return
 	}
 
 	chunk, err := soc.NewSignedChunk(id, ch, owner, sig)
 	if err != nil {
-		s.Logger.Debugf("soc upload: read chunk data error: %v", err)
-		s.Logger.Error("soc upload: read chunk data error")
+		s.logger.Debugf("soc upload: read chunk data error: %v", err)
+		s.logger.Error("soc upload: read chunk data error")
 		jsonhttp.InternalServerError(w, "cannot read chunk data")
 		return
 	}
 
 	if !soc.Valid(chunk) {
-		s.Logger.Debugf("soc upload: invalid chunk: %v", err)
-		s.Logger.Error("soc upload: invalid chunk")
+		s.logger.Debugf("soc upload: invalid chunk: %v", err)
+		s.logger.Error("soc upload: invalid chunk")
 		jsonhttp.Unauthorized(w, "invalid chunk")
 		return
 
 	}
 	ctx := r.Context()
 
-	_, err = s.Storer.Put(ctx, requestModePut(r), chunk)
+	_, err = s.storer.Put(ctx, requestModePut(r), chunk)
 	if err != nil {
-		s.Logger.Debugf("soc upload: chunk write error: %v", err)
-		s.Logger.Error("soc upload: chunk write error")
+		s.logger.Debugf("soc upload: chunk write error: %v", err)
+		s.logger.Error("soc upload: chunk write error")
 		jsonhttp.BadRequest(w, "chunk write error")
 		return
 	}

pkg/api/tag.go

@@ -50,8 +50,8 @@ func (s *server) createTagHandler(w http.ResponseWriter, r *http.Request) {
 		if jsonhttp.HandleBodyReadError(err, w) {
 			return
 		}
-		s.Logger.Debugf("create tag: read request body error: %v", err)
-		s.Logger.Error("create tag: read request body error")
+		s.logger.Debugf("create tag: read request body error: %v", err)
+		s.logger.Error("create tag: read request body error")
 		jsonhttp.InternalServerError(w, "cannot read request")
 		return
 	}
@@ -60,17 +60,17 @@ func (s *server) createTagHandler(w http.ResponseWriter, r *http.Request) {
 	if len(body) > 0 {
 		err = json.Unmarshal(body, &tagr)
 		if err != nil {
-			s.Logger.Debugf("create tag: unmarshal tag name error: %v", err)
-			s.Logger.Errorf("create tag: unmarshal tag name error")
+			s.logger.Debugf("create tag: unmarshal tag name error: %v", err)
+			s.logger.Errorf("create tag: unmarshal tag name error")
 			jsonhttp.InternalServerError(w, "error unmarshaling metadata")
 			return
 		}
 	}
 
-	tag, err := s.Tags.Create(0)
+	tag, err := s.tags.Create(0)
 	if err != nil {
-		s.Logger.Debugf("create tag: tag create error: %v", err)
-		s.Logger.Error("create tag: tag create error")
+		s.logger.Debugf("create tag: tag create error: %v", err)
+		s.logger.Error("create tag: tag create error")
 		jsonhttp.InternalServerError(w, "cannot create tag")
 		return
 	}
@@ -83,22 +83,22 @@ func (s *server) getTagHandler(w http.ResponseWriter, r *http.Request) {
 
 	id, err := strconv.Atoi(idStr)
 	if err != nil {
-		s.Logger.Debugf("get tag: parse id  %s: %v", idStr, err)
-		s.Logger.Error("get tag: parse id")
+		s.logger.Debugf("get tag: parse id  %s: %v", idStr, err)
+		s.logger.Error("get tag: parse id")
 		jsonhttp.BadRequest(w, "invalid id")
 		return
 	}
 
-	tag, err := s.Tags.Get(uint32(id))
+	tag, err := s.tags.Get(uint32(id))
 	if err != nil {
 		if errors.Is(err, tags.ErrNotFound) {
-			s.Logger.Debugf("get tag: tag not present: %v, id %s", err, idStr)
-			s.Logger.Error("get tag: tag not present")
+			s.logger.Debugf("get tag: tag not present: %v, id %s", err, idStr)
+			s.logger.Error("get tag: tag not present")
 			jsonhttp.NotFound(w, "tag not present")
 			return
 		}
-		s.Logger.Debugf("get tag: tag %v: %v", idStr, err)
-		s.Logger.Errorf("get tag: %v", idStr)
+		s.logger.Debugf("get tag: tag %v: %v", idStr, err)
+		s.logger.Errorf("get tag: %v", idStr)
 		jsonhttp.InternalServerError(w, "cannot get tag")
 		return
 	}
@@ -112,27 +112,27 @@ func (s *server) deleteTagHandler(w http.ResponseWriter, r *http.Request) {
 
 	id, err := strconv.Atoi(idStr)
 	if err != nil {
-		s.Logger.Debugf("delete tag: parse id  %s: %v", idStr, err)
-		s.Logger.Error("delete tag: parse id")
+		s.logger.Debugf("delete tag: parse id  %s: %v", idStr, err)
+		s.logger.Error("delete tag: parse id")
 		jsonhttp.BadRequest(w, "invalid id")
 		return
 	}
 
-	tag, err := s.Tags.Get(uint32(id))
+	tag, err := s.tags.Get(uint32(id))
 	if err != nil {
 		if errors.Is(err, tags.ErrNotFound) {
-			s.Logger.Debugf("delete tag: tag not present: %v, id %s", err, idStr)
-			s.Logger.Error("delete tag: tag not present")
+			s.logger.Debugf("delete tag: tag not present: %v, id %s", err, idStr)
+			s.logger.Error("delete tag: tag not present")
 			jsonhttp.NotFound(w, "tag not present")
 			return
 		}
-		s.Logger.Debugf("delete tag: tag %v: %v", idStr, err)
-		s.Logger.Errorf("delete tag: %v", idStr)
+		s.logger.Debugf("delete tag: tag %v: %v", idStr, err)
+		s.logger.Errorf("delete tag: %v", idStr)
 		jsonhttp.InternalServerError(w, "cannot get tag")
 		return
 	}
 
-	s.Tags.Delete(tag.Uid)
+	s.tags.Delete(tag.Uid)
 	jsonhttp.NoContent(w)
 }
 
@@ -141,8 +141,8 @@ func (s *server) doneSplitHandler(w http.ResponseWriter, r *http.Request) {
 
 	id, err := strconv.Atoi(idStr)
 	if err != nil {
-		s.Logger.Debugf("done split tag: parse id  %s: %v", idStr, err)
-		s.Logger.Error("done split tag: parse id")
+		s.logger.Debugf("done split tag: parse id  %s: %v", idStr, err)
+		s.logger.Error("done split tag: parse id")
 		jsonhttp.BadRequest(w, "invalid id")
 		return
 	}
@@ -152,8 +152,8 @@ func (s *server) doneSplitHandler(w http.ResponseWriter, r *http.Request) {
 		if jsonhttp.HandleBodyReadError(err, w) {
 			return
 		}
-		s.Logger.Debugf("done split tag: read request body error: %v", err)
-		s.Logger.Error("done split tag: read request body error")
+		s.logger.Debugf("done split tag: read request body error: %v", err)
+		s.logger.Error("done split tag: read request body error")
 		jsonhttp.InternalServerError(w, "cannot read request")
 		return
 	}
@@ -162,31 +162,31 @@ func (s *server) doneSplitHandler(w http.ResponseWriter, r *http.Request) {
 	if len(body) > 0 {
 		err = json.Unmarshal(body, &tagr)
 		if err != nil {
-			s.Logger.Debugf("done split tag: unmarshal tag name error: %v", err)
-			s.Logger.Errorf("done split tag: unmarshal tag name error")
+			s.logger.Debugf("done split tag: unmarshal tag name error: %v", err)
+			s.logger.Errorf("done split tag: unmarshal tag name error")
 			jsonhttp.InternalServerError(w, "error unmarshaling metadata")
 			return
 		}
 	}
 
-	tag, err := s.Tags.Get(uint32(id))
+	tag, err := s.tags.Get(uint32(id))
 	if err != nil {
 		if errors.Is(err, tags.ErrNotFound) {
-			s.Logger.Debugf("done split: tag not present: %v, id %s", err, idStr)
-			s.Logger.Error("done split: tag not present")
+			s.logger.Debugf("done split: tag not present: %v, id %s", err, idStr)
+			s.logger.Error("done split: tag not present")
 			jsonhttp.NotFound(w, "tag not present")
 			return
 		}
-		s.Logger.Debugf("done split: tag %v: %v", idStr, err)
-		s.Logger.Errorf("done split: %v", idStr)
+		s.logger.Debugf("done split: tag %v: %v", idStr, err)
+		s.logger.Errorf("done split: %v", idStr)
 		jsonhttp.InternalServerError(w, "cannot get tag")
 		return
 	}
 
 	_, err = tag.DoneSplit(tagr.Address)
 	if err != nil {
-		s.Logger.Debugf("done split: failed for address %v", tagr.Address)
-		s.Logger.Errorf("done split: failed for address %v", tagr.Address)
+		s.logger.Debugf("done split: failed for address %v", tagr.Address)
+		s.logger.Errorf("done split: failed for address %v", tagr.Address)
 		jsonhttp.InternalServerError(w, nil)
 		return
 	}
@@ -202,24 +202,24 @@ func (s *server) listTagsHandler(w http.ResponseWriter, r *http.Request) {
 	if v := r.URL.Query().Get("offset"); v != "" {
 		offset, err = strconv.Atoi(v)
 		if err != nil {
-			s.Logger.Debugf("list tags: parse offset: %v", err)
-			s.Logger.Errorf("list tags: bad offset")
+			s.logger.Debugf("list tags: parse offset: %v", err)
+			s.logger.Errorf("list tags: bad offset")
 			jsonhttp.BadRequest(w, "bad offset")
 		}
 	}
 	if v := r.URL.Query().Get("limit"); v != "" {
 		limit, err = strconv.Atoi(v)
 		if err != nil {
-			s.Logger.Debugf("list tags: parse limit: %v", err)
-			s.Logger.Errorf("list tags: bad limit")
+			s.logger.Debugf("list tags: parse limit: %v", err)
+			s.logger.Errorf("list tags: bad limit")
 			jsonhttp.BadRequest(w, "bad limit")
 		}
 	}
 
-	tagList, err := s.Tags.ListAll(r.Context(), offset, limit)
+	tagList, err := s.tags.ListAll(r.Context(), offset, limit)
 	if err != nil {
-		s.Logger.Debugf("list tags: listing: %v", err)
-		s.Logger.Errorf("list tags: listing")
+		s.logger.Debugf("list tags: listing: %v", err)
+		s.logger.Errorf("list tags: listing")
 		jsonhttp.InternalServerError(w, err)
 		return
 	}