Skip to content

M
mybee
Commit ff8e5fab authored by acud's avatar acud Committed by GitHub
Browse files
Options

add opentracing instrumentation to http package (#672) 

* add opentracing instrumentation to http package
parent f245cc88
Hide whitespace changes
Inline Side-by-side
Showing with 130 additions and 88 deletions
pkg/api/api.go
View file @ ff8e5fab
......@@ -134,3 +134,14 @@ func requestModePut(r *http.Request) storage.ModePut {
func requestEncrypt(r *http.Request) bool {
return strings.ToLower(r.Header.Get(SwarmEncryptHeader)) == "true"
}
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) {
span, _, ctx := s.Tracer.StartSpanFromContext(r.Context(), spanName, s.Logger)
defer span.Finish()
h.ServeHTTP(w, r.WithContext(ctx))
})
}
}
pkg/api/bytes.go
View file @ ff8e5fab
......@@ -12,6 +12,7 @@ import (
"github.com/ethersphere/bee/pkg/jsonhttp"
"github.com/ethersphere/bee/pkg/sctx"
"github.com/ethersphere/bee/pkg/swarm"
"github.com/ethersphere/bee/pkg/tracing"
"github.com/gorilla/mux"
)
......@@ -21,10 +22,12 @@ 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)
tag, created, err := s.getOrCreateTag(r.Header.Get(SwarmTagUidHeader))
if err != nil {
s.Logger.Debugf("bytes upload: get or create tag: %v", err)
s.Logger.Error("bytes upload: get or create tag")
logger.Debugf("bytes upload: get or create tag: %v", err)
logger.Error("bytes upload: get or create tag")
jsonhttp.InternalServerError(w, "cannot get or create tag")
return
}
......@@ -35,16 +38,16 @@ func (s *server) bytesUploadHandler(w http.ResponseWriter, r *http.Request) {
pipe := pipeline.NewPipelineBuilder(ctx, s.Storer, requestModePut(r), requestEncrypt(r))
address, err := pipeline.FeedPipeline(ctx, pipe, r.Body, r.ContentLength)
if err != nil {
s.Logger.Debugf("bytes upload: split write all: %v", err)
s.Logger.Error("bytes upload: split write all")
logger.Debugf("bytes upload: split write all: %v", err)
logger.Error("bytes upload: split write all")
jsonhttp.InternalServerError(w, nil)
return
}
if created {
_, err = tag.DoneSplit(address)
if err != nil {
s.Logger.Debugf("bytes upload: done split: %v", err)
s.Logger.Error("bytes upload: done split failed")
logger.Debugf("bytes upload: done split: %v", err)
logger.Error("bytes upload: done split failed")
jsonhttp.InternalServerError(w, nil)
return
}
......@@ -58,12 +61,13 @@ 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
nameOrHex := mux.Vars(r)["address"]
address, err := s.resolveNameOrAddress(nameOrHex)
if err != nil {
s.Logger.Debugf("bytes: parse address %s: %v", nameOrHex, err)
s.Logger.Error("bytes: parse address error")
logger.Debugf("bytes: parse address %s: %v", nameOrHex, err)
logger.Error("bytes: parse address error")
jsonhttp.BadRequest(w, "invalid address")
return
}
......
pkg/api/bzz.go
View file @ ff8e5fab
......@@ -19,9 +19,11 @@ import (
"github.com/ethersphere/bee/pkg/jsonhttp"
"github.com/ethersphere/bee/pkg/manifest"
"github.com/ethersphere/bee/pkg/sctx"
"github.com/ethersphere/bee/pkg/tracing"
)
func (s *server) bzzDownloadHandler(w http.ResponseWriter, r *http.Request) {
logger := tracing.NewLoggerWithTraceID(r.Context(), s.Logger)
targets := r.URL.Query().Get("targets")
r = r.WithContext(sctx.SetTargets(r.Context(), targets))
ctx := r.Context()
......@@ -31,8 +33,8 @@ func (s *server) bzzDownloadHandler(w http.ResponseWriter, r *http.Request) {
address, err := s.resolveNameOrAddress(nameOrHex)
if err != nil {
s.Logger.Debugf("bzz download: parse address %s: %v", nameOrHex, err)
s.Logger.Error("bzz download: parse address")
logger.Debugf("bzz download: parse address %s: %v", nameOrHex, err)
logger.Error("bzz download: parse address")
jsonhttp.BadRequest(w, "invalid address")
return
}
......@@ -45,16 +47,16 @@ func (s *server) bzzDownloadHandler(w http.ResponseWriter, r *http.Request) {
buf := bytes.NewBuffer(nil)
_, err = file.JoinReadAll(ctx, j, address, buf)
if err != nil {
s.Logger.Debugf("bzz download: read entry %s: %v", address, err)
s.Logger.Errorf("bzz download: read entry %s", address)
logger.Debugf("bzz download: read entry %s: %v", address, err)
logger.Errorf("bzz download: read entry %s", address)
jsonhttp.NotFound(w, nil)
return
}
e := &entry.Entry{}
err = e.UnmarshalBinary(buf.Bytes())
if err != nil {
s.Logger.Debugf("bzz download: unmarshal entry %s: %v", address, err)
s.Logger.Errorf("bzz download: unmarshal entry %s", address)
logger.Debugf("bzz download: unmarshal entry %s: %v", address, err)
logger.Errorf("bzz download: unmarshal entry %s", address)
jsonhttp.InternalServerError(w, "error unmarshaling entry")
return
}
......@@ -63,16 +65,16 @@ func (s *server) bzzDownloadHandler(w http.ResponseWriter, r *http.Request) {
buf = bytes.NewBuffer(nil)
_, err = file.JoinReadAll(ctx, j, e.Metadata(), buf)
if err != nil {
s.Logger.Debugf("bzz download: read metadata %s: %v", address, err)
s.Logger.Errorf("bzz download: read metadata %s", address)
logger.Debugf("bzz download: read metadata %s: %v", address, err)
logger.Errorf("bzz download: read metadata %s", address)
jsonhttp.NotFound(w, nil)
return
}
manifestMetadata := &entry.Metadata{}
err = json.Unmarshal(buf.Bytes(), manifestMetadata)
if err != nil {
s.Logger.Debugf("bzz download: unmarshal metadata %s: %v", address, err)
s.Logger.Errorf("bzz download: unmarshal metadata %s", address)
logger.Debugf("bzz download: unmarshal metadata %s: %v", address, err)
logger.Errorf("bzz download: unmarshal metadata %s", address)
jsonhttp.InternalServerError(w, "error unmarshaling metadata")
return
}
......@@ -86,16 +88,16 @@ func (s *server) bzzDownloadHandler(w http.ResponseWriter, r *http.Request) {
s.Storer,
)
if err != nil {
s.Logger.Debugf("bzz download: not manifest %s: %v", address, err)
s.Logger.Error("bzz download: not manifest")
logger.Debugf("bzz download: not manifest %s: %v", address, err)
logger.Error("bzz download: not manifest")
jsonhttp.BadRequest(w, "not manifest")
return
}
me, err := m.Lookup(path)
if err != nil {
s.Logger.Debugf("bzz download: invalid path %s/%s: %v", address, path, err)
s.Logger.Error("bzz download: invalid path")
logger.Debugf("bzz download: invalid path %s/%s: %v", address, path, err)
logger.Error("bzz download: invalid path")
if errors.Is(err, manifest.ErrNotFound) {
jsonhttp.NotFound(w, "path address not found")
......@@ -111,16 +113,16 @@ func (s *server) bzzDownloadHandler(w http.ResponseWriter, r *http.Request) {
buf = bytes.NewBuffer(nil)
_, err = file.JoinReadAll(ctx, j, manifestEntryAddress, buf)
if err != nil {
s.Logger.Debugf("bzz download: read file entry %s: %v", address, err)
s.Logger.Errorf("bzz download: read file entry %s", address)
logger.Debugf("bzz download: read file entry %s: %v", address, err)
logger.Errorf("bzz download: read file entry %s", address)
jsonhttp.NotFound(w, nil)
return
}
fe := &entry.Entry{}
err = fe.UnmarshalBinary(buf.Bytes())
if err != nil {
s.Logger.Debugf("bzz download: unmarshal file entry %s: %v", address, err)
s.Logger.Errorf("bzz download: unmarshal file entry %s", address)
logger.Debugf("bzz download: unmarshal file entry %s: %v", address, err)
logger.Errorf("bzz download: unmarshal file entry %s", address)
jsonhttp.InternalServerError(w, "error unmarshaling file entry")
return
}
......@@ -129,16 +131,16 @@ func (s *server) bzzDownloadHandler(w http.ResponseWriter, r *http.Request) {
buf = bytes.NewBuffer(nil)
_, err = file.JoinReadAll(ctx, j, fe.Metadata(), buf)
if err != nil {
s.Logger.Debugf("bzz download: read file metadata %s: %v", address, err)
s.Logger.Errorf("bzz download: read file metadata %s", address)
logger.Debugf("bzz download: read file metadata %s: %v", address, err)
logger.Errorf("bzz download: read file metadata %s", address)
jsonhttp.NotFound(w, nil)
return
}
fileMetadata := &entry.Metadata{}
err = json.Unmarshal(buf.Bytes(), fileMetadata)
if err != nil {
s.Logger.Debugf("bzz download: unmarshal metadata %s: %v", address, err)
s.Logger.Errorf("bzz download: unmarshal metadata %s", address)
logger.Debugf("bzz download: unmarshal metadata %s: %v", address, err)
logger.Errorf("bzz download: unmarshal metadata %s", address)
jsonhttp.InternalServerError(w, "error unmarshaling metadata")
return
}
......
pkg/api/dirs.go
View file @ ff8e5fab
......@@ -24,6 +24,7 @@ import (
"github.com/ethersphere/bee/pkg/sctx"
"github.com/ethersphere/bee/pkg/storage"
"github.com/ethersphere/bee/pkg/swarm"
"github.com/ethersphere/bee/pkg/tracing"
)
const (
......@@ -33,18 +34,19 @@ 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)
err := validateRequest(r)
if err != nil {
s.Logger.Errorf("dir upload, validate request")
s.Logger.Debugf("dir upload, validate request err: %v", err)
logger.Errorf("dir upload, validate request")
logger.Debugf("dir upload, validate request err: %v", err)
jsonhttp.BadRequest(w, "could not validate request")
return
}
tag, created, err := s.getOrCreateTag(r.Header.Get(SwarmTagUidHeader))
if err != nil {
s.Logger.Debugf("dir upload: get or create tag: %v", err)
s.Logger.Error("dir upload: get or create tag")
logger.Debugf("dir upload: get or create tag: %v", err)
logger.Error("dir upload: get or create tag")
jsonhttp.InternalServerError(w, "cannot get or create tag")
return
}
......@@ -54,16 +56,16 @@ func (s *server) dirUploadHandler(w http.ResponseWriter, r *http.Request) {
reference, err := storeDir(ctx, r.Body, s.Storer, requestModePut(r), s.Logger, requestEncrypt(r))
if err != nil {
s.Logger.Debugf("dir upload: store dir err: %v", err)
s.Logger.Errorf("dir upload: store dir")
logger.Debugf("dir upload: store dir err: %v", err)
logger.Errorf("dir upload: store dir")
jsonhttp.InternalServerError(w, "could not store dir")
return
}
if created {
_, err = tag.DoneSplit(reference)
if err != nil {
s.Logger.Debugf("dir upload: done split: %v", err)
s.Logger.Error("dir upload: done split failed")
logger.Debugf("dir upload: done split: %v", err)
logger.Error("dir upload: done split failed")
jsonhttp.InternalServerError(w, nil)
return
}
......@@ -92,7 +94,8 @@ func validateRequest(r *http.Request) error {
// storeDir stores all files recursively contained in the directory given as a tar
// it returns the hash for the uploaded manifest corresponding to the uploaded dir
func storeDir(ctx context.Context, reader io.ReadCloser, s storage.Storer, mode storage.ModePut, logger logging.Logger, encrypt bool) (swarm.Address, error) {
func storeDir(ctx context.Context, reader io.ReadCloser, s storage.Storer, mode storage.ModePut, log logging.Logger, encrypt bool) (swarm.Address, error) {
logger := tracing.NewLoggerWithTraceID(ctx, log)
dirManifest, err := manifest.NewDefaultManifest(encrypt, s)
if err != nil {
......
pkg/api/file.go
View file @ ff8e5fab
......@@ -27,6 +27,7 @@ import (
"github.com/ethersphere/bee/pkg/sctx"
"github.com/ethersphere/bee/pkg/storage"
"github.com/ethersphere/bee/pkg/swarm"
"github.com/ethersphere/bee/pkg/tracing"
"github.com/gorilla/mux"
)
......@@ -45,6 +46,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)
fileName, contentLength string
fileSize uint64
mode = requestModePut(r)
......@@ -53,16 +55,16 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
mediaType, params, err := mime.ParseMediaType(contentType)
if err != nil {
s.Logger.Debugf("file upload: parse content type header %q: %v", contentType, err)
s.Logger.Errorf("file upload: parse content type header %q", contentType)
logger.Debugf("file upload: parse content type header %q: %v", contentType, err)
logger.Errorf("file upload: parse content type header %q", contentType)
jsonhttp.BadRequest(w, "invalid content-type header")
return
}
tag, created, err := s.getOrCreateTag(r.Header.Get(SwarmTagUidHeader))
if err != nil {
s.Logger.Debugf("file upload: get or create tag: %v", err)
s.Logger.Error("file upload: get or create tag")
logger.Debugf("file upload: get or create tag: %v", err)
logger.Error("file upload: get or create tag")
jsonhttp.InternalServerError(w, "cannot get or create tag")
return
}
......@@ -76,8 +78,8 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
// read only the first part, as only one file upload is supported
part, err := mr.NextPart()
if err != nil {
s.Logger.Debugf("file upload: read multipart: %v", err)
s.Logger.Error("file upload: read multipart")
logger.Debugf("file upload: read multipart: %v", err)
logger.Error("file upload: read multipart")
jsonhttp.BadRequest(w, "invalid multipart/form-data")
return
}
......@@ -96,8 +98,8 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
br := bufio.NewReader(part)
buf, err := br.Peek(512)
if err != nil && err != io.EOF {
s.Logger.Debugf("file upload: read content type, file %q: %v", fileName, err)
s.Logger.Errorf("file upload: read content type, file %q", fileName)
logger.Debugf("file upload: read content type, file %q: %v", fileName, err)
logger.Errorf("file upload: read content type, file %q", fileName)
jsonhttp.BadRequest(w, "error reading content type")
return
}
......@@ -116,8 +118,8 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
if contentLength != "" {
fileSize, err = strconv.ParseUint(contentLength, 10, 64)
if err != nil {
s.Logger.Debugf("file upload: content length, file %q: %v", fileName, err)
s.Logger.Errorf("file upload: content length, file %q", fileName)
logger.Debugf("file upload: content length, file %q: %v", fileName, err)
logger.Errorf("file upload: content length, file %q", fileName)
jsonhttp.BadRequest(w, "invalid content length header")
return
}
......@@ -125,8 +127,8 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
// copy the part to a tmp file to get its size
tmp, err := ioutil.TempFile("", "bee-multipart")
if err != nil {
s.Logger.Debugf("file upload: create temporary file: %v", err)
s.Logger.Errorf("file upload: create temporary file")
logger.Debugf("file upload: create temporary file: %v", err)
logger.Errorf("file upload: create temporary file")
jsonhttp.InternalServerError(w, nil)
return
}
......@@ -134,14 +136,14 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
defer tmp.Close()
n, err := io.Copy(tmp, reader)
if err != nil {
s.Logger.Debugf("file upload: write temporary file: %v", err)
s.Logger.Error("file upload: write temporary file")
logger.Debugf("file upload: write temporary file: %v", err)
logger.Error("file upload: write temporary file")
jsonhttp.InternalServerError(w, nil)
return
}
if _, err := tmp.Seek(0, io.SeekStart); err != nil {
s.Logger.Debugf("file upload: seek to beginning of temporary file: %v", err)
s.Logger.Error("file upload: seek to beginning of temporary file")
logger.Debugf("file upload: seek to beginning of temporary file: %v", err)
logger.Error("file upload: seek to beginning of temporary file")
jsonhttp.InternalServerError(w, nil)
return
}
......@@ -153,8 +155,8 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
pipe := pipeline.NewPipelineBuilder(ctx, s.Storer, mode, requestEncrypt(r))
fr, err := pipeline.FeedPipeline(ctx, pipe, reader, int64(fileSize))
if err != nil {
s.Logger.Debugf("file upload: file store, file %q: %v", fileName, err)
s.Logger.Errorf("file upload: file store, file %q", fileName)
logger.Debugf("file upload: file store, file %q: %v", fileName, err)
logger.Errorf("file upload: file store, file %q", fileName)
jsonhttp.InternalServerError(w, "could not store file data")
return
}
......@@ -169,16 +171,16 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
m.MimeType = contentType
metadataBytes, err := json.Marshal(m)
if err != nil {
s.Logger.Debugf("file upload: metadata marshal, file %q: %v", fileName, err)
s.Logger.Errorf("file upload: metadata marshal, file %q", fileName)
logger.Debugf("file upload: metadata marshal, file %q: %v", fileName, err)
logger.Errorf("file upload: metadata marshal, file %q", fileName)
jsonhttp.InternalServerError(w, "metadata marshal error")
return
}
pipe = pipeline.NewPipelineBuilder(ctx, s.Storer, mode, requestEncrypt(r))
mr, err := pipeline.FeedPipeline(ctx, pipe, bytes.NewReader(metadataBytes), int64(len(metadataBytes)))
if err != nil {
s.Logger.Debugf("file upload: metadata store, file %q: %v", fileName, err)
s.Logger.Errorf("file upload: metadata store, file %q", fileName)
logger.Debugf("file upload: metadata store, file %q: %v", fileName, err)
logger.Errorf("file upload: metadata store, file %q", fileName)
jsonhttp.InternalServerError(w, "could not store metadata")
return
}
......@@ -187,24 +189,24 @@ func (s *server) fileUploadHandler(w http.ResponseWriter, r *http.Request) {
entrie := entry.New(fr, mr)
fileEntryBytes, err := entrie.MarshalBinary()
if err != nil {
s.Logger.Debugf("file upload: entry marshal, file %q: %v", fileName, err)
s.Logger.Errorf("file upload: entry marshal, file %q", fileName)
logger.Debugf("file upload: entry marshal, file %q: %v", fileName, err)
logger.Errorf("file upload: entry marshal, file %q", fileName)
jsonhttp.InternalServerError(w, "entry marshal error")
return
}
pipe = pipeline.NewPipelineBuilder(ctx, s.Storer, mode, requestEncrypt(r))
reference, err := pipeline.FeedPipeline(ctx, pipe, bytes.NewReader(fileEntryBytes), int64(len(fileEntryBytes)))
if err != nil {
s.Logger.Debugf("file upload: entry store, file %q: %v", fileName, err)
s.Logger.Errorf("file upload: entry store, file %q", fileName)
logger.Debugf("file upload: entry store, file %q: %v", fileName, err)
logger.Errorf("file upload: entry store, file %q", fileName)
jsonhttp.InternalServerError(w, "could not store entry")
return
}
if created {
_, err = tag.DoneSplit(reference)
if err != nil {
s.Logger.Debugf("file upload: done split: %v", err)
s.Logger.Error("file upload: done split failed")
logger.Debugf("file upload: done split: %v", err)
logger.Error("file upload: done split failed")
jsonhttp.InternalServerError(w, nil)
return
}
......@@ -227,34 +229,35 @@ 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)
nameOrHex := mux.Vars(r)["addr"]
address, err := s.resolveNameOrAddress(nameOrHex)
if err != nil {
s.Logger.Debugf("file download: parse file address %s: %v", nameOrHex, err)
s.Logger.Errorf("file download: parse file address %s", nameOrHex)
logger.Debugf("file download: parse file address %s: %v", nameOrHex, err)
logger.Errorf("file download: parse file address %s", nameOrHex)
jsonhttp.BadRequest(w, "invalid file address")
return
}
targets := r.URL.Query().Get("targets")
sctx.SetTargets(r.Context(), targets)
r = r.WithContext(sctx.SetTargets(r.Context(), targets))
// read entry.
j := seekjoiner.NewSimpleJoiner(s.Storer)
buf := bytes.NewBuffer(nil)
_, err = file.JoinReadAll(r.Context(), j, address, buf)
if err != nil {
s.Logger.Debugf("file download: read entry %s: %v", address, err)
s.Logger.Errorf("file download: read entry %s", address)
logger.Debugf("file download: read entry %s: %v", address, err)
logger.Errorf("file download: read entry %s", address)
jsonhttp.NotFound(w, nil)
return
}
e := &entry.Entry{}
err = e.UnmarshalBinary(buf.Bytes())
if err != nil {
s.Logger.Debugf("file download: unmarshal entry %s: %v", address, err)
s.Logger.Errorf("file download: unmarshal entry %s", address)
logger.Debugf("file download: unmarshal entry %s: %v", address, err)
logger.Errorf("file download: unmarshal entry %s", address)
jsonhttp.InternalServerError(w, "error unmarshaling entry")
return
}
......@@ -273,16 +276,16 @@ func (s *server) fileDownloadHandler(w http.ResponseWriter, r *http.Request) {
buf = bytes.NewBuffer(nil)
_, err = file.JoinReadAll(r.Context(), j, e.Metadata(), buf)
if err != nil {
s.Logger.Debugf("file download: read metadata %s: %v", nameOrHex, err)
s.Logger.Errorf("file download: read metadata %s", nameOrHex)
logger.Debugf("file download: read metadata %s: %v", nameOrHex, err)
logger.Errorf("file download: read metadata %s", nameOrHex)
jsonhttp.NotFound(w, nil)
return
}
metaData := &entry.Metadata{}
err = json.Unmarshal(buf.Bytes(), metaData)
if err != nil {
s.Logger.Debugf("file download: unmarshal metadata %s: %v", nameOrHex, err)
s.Logger.Errorf("file download: unmarshal metadata %s", nameOrHex)
logger.Debugf("file download: unmarshal metadata %s: %v", nameOrHex, err)
logger.Errorf("file download: unmarshal metadata %s", nameOrHex)
jsonhttp.InternalServerError(w, "error unmarshaling metadata")
return
}
......@@ -297,6 +300,7 @@ 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) {
logger := tracing.NewLoggerWithTraceID(r.Context(), s.Logger)
targets := r.URL.Query().Get("targets")
r = r.WithContext(sctx.SetTargets(r.Context(), targets))
......@@ -304,13 +308,13 @@ func (s *server) downloadHandler(w http.ResponseWriter, r *http.Request, referen
reader, l, err := rs.Join(r.Context(), reference)
if err != nil {
if errors.Is(err, storage.ErrNotFound) {
s.Logger.Debugf("api download: not found %s: %v", reference, err)
s.Logger.Error("api download: not found")
logger.Debugf("api download: not found %s: %v", reference, err)
logger.Error("api download: not found")
jsonhttp.NotFound(w, "not found")
return
}
s.Logger.Debugf("api download: invalid root chunk %s: %v", reference, err)
s.Logger.Error("api download: invalid root chunk")
logger.Debugf("api download: invalid root chunk %s: %v", reference, err)
logger.Error("api download: invalid root chunk")
jsonhttp.NotFound(w, nil)
return
}
......
pkg/api/router.go
View file @ ff8e5fab
......@@ -38,21 +38,36 @@ func (s *server) setupRouting() {
})
handle(router, "/files", jsonhttp.MethodHandler{
"POST": http.HandlerFunc(s.fileUploadHandler),
"POST": web.ChainHandlers(
s.newTracingHandler("files-upload"),
web.FinalHandlerFunc(s.fileUploadHandler),
),
})
handle(router, "/files/{addr}", jsonhttp.MethodHandler{
"GET": http.HandlerFunc(s.fileDownloadHandler),
"GET": web.ChainHandlers(
s.newTracingHandler("files-download"),
web.FinalHandlerFunc(s.fileDownloadHandler),
),
})
handle(router, "/dirs", jsonhttp.MethodHandler{
"POST": http.HandlerFunc(s.dirUploadHandler),
"POST": web.ChainHandlers(
s.newTracingHandler("dirs-upload"),
web.FinalHandlerFunc(s.dirUploadHandler),
),
})
handle(router, "/bytes", jsonhttp.MethodHandler{
"POST": http.HandlerFunc(s.bytesUploadHandler),
"POST": web.ChainHandlers(
s.newTracingHandler("bytes-upload"),
web.FinalHandlerFunc(s.bytesUploadHandler),
),
})
handle(router, "/bytes/{address}", jsonhttp.MethodHandler{
"GET": http.HandlerFunc(s.bytesGetHandler),
"GET": web.ChainHandlers(
s.newTracingHandler("bytes-download"),
web.FinalHandlerFunc(s.bytesGetHandler),
),
})
handle(router, "/chunks/{addr}", jsonhttp.MethodHandler{
......@@ -64,7 +79,10 @@ func (s *server) setupRouting() {
})
handle(router, "/bzz/{address}/{path:.*}", jsonhttp.MethodHandler{
"GET": http.HandlerFunc(s.bzzDownloadHandler),
"GET": web.ChainHandlers(
s.newTracingHandler("bzz-download"),
web.FinalHandlerFunc(s.bzzDownloadHandler),
),
})
handle(router, "/tags", web.ChainHandlers(
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment