diff --git a/api/object.go b/api/object.go index cef672a97..f53dbb5ac 100644 --- a/api/object.go +++ b/api/object.go @@ -83,7 +83,7 @@ type ( Object *Object `json:"object,omitempty"` } - // GetObjectResponse is the response type for the /worker/object endpoint. + // GetObjectResponse is the response type for the GET /worker/object endpoint. GetObjectResponse struct { Content io.ReadCloser `json:"content"` ContentType string `json:"contentType"` @@ -91,6 +91,16 @@ type ( Range *DownloadRange `json:"range,omitempty"` Size int64 `json:"size"` Metadata ObjectUserMetadata `json:"metadata"` + // NOTE: keep HeadObjectResponse in sync with this type + } + + // HeadObjectResponse is the response type for the HEAD /worker/object endpoint. + HeadObjectResponse struct { + ContentType string `json:"contentType"` + LastModified string `json:"lastModified"` + Range *DownloadRange `json:"range,omitempty"` + Size int64 `json:"size"` + Metadata ObjectUserMetadata `json:"metadata"` } // ObjectsDeleteRequest is the request type for the /bus/objects/list endpoint. @@ -135,6 +145,46 @@ type ( } ) +func ParseObjectHeadResponseFrom(header http.Header) (HeadObjectResponse, error) { + // parse size + var size int64 + _, err := fmt.Sscan(header.Get("Content-Length"), &size) + if err != nil { + return HeadObjectResponse{}, err + } + + // parse range + var r *DownloadRange + if cr := header.Get("Content-Range"); cr != "" { + dr, err := ParseDownloadRange(cr) + if err != nil { + return HeadObjectResponse{}, err + } + r = &dr + + // if a range is set, the size is the size extracted from the range + // since Content-Length will then only be the length of the returned + // range. + size = dr.Size + } + + // parse headers + headers := make(map[string]string) + for k, v := range header { + if len(v) > 0 { + headers[k] = v[0] + } + } + + return HeadObjectResponse{ + ContentType: header.Get("Content-Type"), + LastModified: header.Get("Last-Modified"), + Range: r, + Size: size, + Metadata: ExtractObjectUserMetadataFrom(headers), + }, nil +} + func ExtractObjectUserMetadataFrom(metadata map[string]string) ObjectUserMetadata { oum := make(map[string]string) for k, v := range metadata { @@ -206,6 +256,10 @@ type ( Batch bool } + HeadObjectOptions struct { + Range DownloadRange + } + DownloadObjectOptions struct { GetObjectOptions Range DownloadRange @@ -301,6 +355,16 @@ func (opts DeleteObjectOptions) Apply(values url.Values) { } } +func (opts HeadObjectOptions) ApplyHeaders(h http.Header) { + if opts.Range != (DownloadRange{}) { + if opts.Range.Length == -1 { + h.Set("Range", fmt.Sprintf("bytes=%v-", opts.Range.Offset)) + } else { + h.Set("Range", fmt.Sprintf("bytes=%v-%v", opts.Range.Offset, opts.Range.Offset+opts.Range.Length-1)) + } + } +} + func (opts GetObjectOptions) Apply(values url.Values) { if opts.Prefix != "" { values.Set("prefix", opts.Prefix) diff --git a/internal/test/e2e/metadata_test.go b/internal/test/e2e/metadata_test.go index b71078eef..d11f6ba4e 100644 --- a/internal/test/e2e/metadata_test.go +++ b/internal/test/e2e/metadata_test.go @@ -33,27 +33,42 @@ func TestObjectMetadata(t *testing.T) { } // upload the object - _, err := w.UploadObject(context.Background(), bytes.NewReader([]byte(t.Name())), api.DefaultBucketName, t.Name(), opts) + data := []byte(t.Name()) + _, err := w.UploadObject(context.Background(), bytes.NewReader(data), api.DefaultBucketName, t.Name(), opts) if err != nil { t.Fatal(err) } // get the object from the bus and assert it has the metadata - ress, err := b.Object(context.Background(), api.DefaultBucketName, t.Name(), api.GetObjectOptions{}) + or, err := b.Object(context.Background(), api.DefaultBucketName, t.Name(), api.GetObjectOptions{}) if err != nil { t.Fatal(err) } - if !reflect.DeepEqual(ress.Object.Metadata, opts.Metadata) { - t.Fatal("metadata mismatch", ress.Object.Metadata) + if !reflect.DeepEqual(or.Object.Metadata, opts.Metadata) { + t.Fatal("metadata mismatch", or.Object.Metadata) } // get the object from the worker and assert it has the metadata - res, err := w.GetObject(context.Background(), api.DefaultBucketName, t.Name(), api.DownloadObjectOptions{}) + gor, err := w.GetObject(context.Background(), api.DefaultBucketName, t.Name(), api.DownloadObjectOptions{}) if err != nil { t.Fatal(err) } - if !reflect.DeepEqual(res.Metadata, opts.Metadata) { - t.Fatal("metadata mismatch", res.Metadata) + if !reflect.DeepEqual(gor.Metadata, opts.Metadata) { + t.Fatal("metadata mismatch", gor.Metadata) + } + + // perform a HEAD request and assert the headers are all present + hor, err := w.HeadObject(context.Background(), api.DefaultBucketName, t.Name(), api.HeadObjectOptions{Range: api.DownloadRange{Offset: 1, Length: 1}}) + if err != nil { + t.Fatal(err) + } else if !reflect.DeepEqual(hor, &api.HeadObjectResponse{ + ContentType: or.Object.ContentType(), + LastModified: or.Object.LastModified(), + Range: &api.DownloadRange{Offset: 1, Length: 1, Size: int64(len(data))}, + Size: int64(len(data)), + Metadata: gor.Metadata, + }) { + t.Fatalf("unexpected response: %+v", hor) } // re-upload the object @@ -63,11 +78,11 @@ func TestObjectMetadata(t *testing.T) { } // assert metadata was removed - res, err = w.GetObject(context.Background(), api.DefaultBucketName, t.Name(), api.DownloadObjectOptions{}) + gor, err = w.GetObject(context.Background(), api.DefaultBucketName, t.Name(), api.DownloadObjectOptions{}) if err != nil { t.Fatal(err) } - if len(res.Metadata) > 0 { - t.Fatal("unexpected metadata", res.Metadata) + if len(gor.Metadata) > 0 { + t.Fatal("unexpected metadata", gor.Metadata) } } diff --git a/worker/client/client.go b/worker/client/client.go index f45789093..ff8625541 100644 --- a/worker/client/client.go +++ b/worker/client/client.go @@ -77,13 +77,49 @@ func (c *Client) DownloadStats() (resp api.DownloadStatsResponse, err error) { return } +// HeadObject returns the metadata of the object at the given path. +func (c *Client) HeadObject(ctx context.Context, bucket, path string, opts api.HeadObjectOptions) (*api.HeadObjectResponse, error) { + c.c.Custom("HEAD", fmt.Sprintf("/objects/%s", path), nil, nil) + + if strings.HasSuffix(path, "/") { + return nil, errors.New("the given path is a directory, HEAD can only be performed on objects") + } + + values := url.Values{} + values.Set("bucket", url.QueryEscape(bucket)) + path += "?" + values.Encode() + + // TODO: support HEAD in jape client + req, err := http.NewRequestWithContext(ctx, "HEAD", fmt.Sprintf("%s/objects/%s", c.c.BaseURL, path), nil) + if err != nil { + panic(err) + } + req.SetBasicAuth("", c.c.WithContext(ctx).Password) + opts.ApplyHeaders(req.Header) + + resp, err := http.DefaultClient.Do(req) + if err != nil { + return nil, err + } + if resp.StatusCode != 200 && resp.StatusCode != 206 { + err, _ := io.ReadAll(resp.Body) + _ = resp.Body.Close() + return nil, errors.New(string(err)) + } + + head, err := api.ParseObjectHeadResponseFrom(resp.Header) + if err != nil { + return nil, err + } + return &head, nil +} + // GetObject returns the object at given path alongside its metadata. func (c *Client) GetObject(ctx context.Context, bucket, path string, opts api.DownloadObjectOptions) (*api.GetObjectResponse, error) { if strings.HasSuffix(path, "/") { return nil, errors.New("the given path is a directory, use ObjectEntries instead") } - // Start download. path = api.ObjectPathEscape(path) body, header, err := c.object(ctx, bucket, path, opts) if err != nil { @@ -96,41 +132,18 @@ func (c *Client) GetObject(ctx context.Context, bucket, path string, opts api.Do } }() - // Parse header. - var size int64 - _, err = fmt.Sscan(header.Get("Content-Length"), &size) + head, err := api.ParseObjectHeadResponseFrom(header) if err != nil { return nil, err } - var r *api.DownloadRange - if cr := header.Get("Content-Range"); cr != "" { - dr, err := api.ParseDownloadRange(cr) - if err != nil { - return nil, err - } - r = &dr - - // If a range is set, the size is the size extracted from the range - // since Content-Length will then only be the length of the returned - // range. - size = dr.Size - } - - // Parse headers. - headers := make(map[string]string) - for k, v := range header { - if len(v) > 0 { - headers[k] = v[0] - } - } return &api.GetObjectResponse{ Content: body, - ContentType: header.Get("Content-Type"), - LastModified: header.Get("Last-Modified"), - Range: r, - Size: size, - Metadata: api.ExtractObjectUserMetadataFrom(headers), + ContentType: head.ContentType, + LastModified: head.LastModified, + Range: head.Range, + Size: head.Size, + Metadata: head.Metadata, }, nil } diff --git a/worker/serve.go b/worker/serve.go index 76c1fb2d5..25d0c0412 100644 --- a/worker/serve.go +++ b/worker/serve.go @@ -76,9 +76,6 @@ func serveContent(rw http.ResponseWriter, req *http.Request, obj api.Object, dow } }() - // create a content reader - rs := newContentReader(pr, obj, offset) - // fetch the content type, if not set and we can't infer it from object's // name we default to application/octet-stream, that is important because we // have to avoid http.ServeContent to sniff the content type as it would @@ -87,17 +84,20 @@ func serveContent(rw http.ResponseWriter, req *http.Request, obj api.Object, dow if contentType == "" { contentType = "application/octet-stream" } + rw.Header().Set("Content-Type", contentType) // set the response headers, no need to set Last-Modified header as // serveContent does that for us rw.Header().Set("ETag", api.FormatETag(obj.ETag)) - rw.Header().Set("Content-Type", contentType) // set the user metadata headers for k, v := range obj.Metadata { rw.Header().Set(fmt.Sprintf("%s%s", api.ObjectMetadataPrefix, k), v) } + // create a content reader + rs := newContentReader(pr, obj, offset) + http.ServeContent(rw, req, obj.Name, obj.ModTime.Std(), rs) return http.StatusOK, nil } diff --git a/worker/worker.go b/worker/worker.go index b335a5f6c..91786c481 100644 --- a/worker/worker.go +++ b/worker/worker.go @@ -860,6 +860,46 @@ func (w *worker) uploadsStatsHandlerGET(jc jape.Context) { }) } +func (w *worker) objectsHandlerHEAD(jc jape.Context) { + // parse bucket + bucket := api.DefaultBucketName + if jc.DecodeForm("bucket", &bucket) != nil { + return + } + + // parse path + path := jc.PathParam("path") + if path == "" || strings.HasSuffix(path, "/") { + jc.Error(fmt.Errorf("directories are not accepted"), http.StatusBadRequest) + return + } + + // fetch object metadata + res, err := w.bus.Object(jc.Request.Context(), bucket, path, api.GetObjectOptions{ + OnlyMetadata: true, + }) + if errors.Is(err, api.ErrObjectNotFound) { + jc.Error(err, http.StatusNotFound) + return + } else if err != nil { + jc.Error(err, http.StatusInternalServerError) + return + } else if res.Object == nil { + jc.Error(api.ErrObjectNotFound, http.StatusInternalServerError) // should never happen but checking because we deref. later + return + } + + // serve the content + status, err := serveContent(jc.ResponseWriter, jc.Request, *res.Object, func(io.Writer, int64, int64) error { return nil }) + if errors.Is(err, http_range.ErrInvalid) || errors.Is(err, errMultiRangeNotSupported) { + jc.Error(err, http.StatusBadRequest) + } else if errors.Is(err, http_range.ErrNoOverlap) { + jc.Error(err, http.StatusRequestedRangeNotSatisfiable) + } else if err != nil { + jc.Error(err, status) + } +} + func (w *worker) objectsHandlerGET(jc jape.Context) { jc.Custom(nil, []api.ObjectMetadata{}) @@ -1366,6 +1406,7 @@ func (w *worker) Handler() http.Handler { "GET /stats/uploads": w.uploadsStatsHandlerGET, "POST /slab/migrate": w.slabMigrateHandler, + "HEAD /objects/*path": w.objectsHandlerHEAD, "GET /objects/*path": w.objectsHandlerGET, "PUT /objects/*path": w.objectsHandlerPUT, "DELETE /objects/*path": w.objectsHandlerDELETE,