[#137] Add index page support

Signed-off-by: Nikita Zinkevich <n.zinkevich@yadro.com>

cmd/http-gw/app.go

@@ -90,6 +90,7 @@ type (
 		defaultTimestamp    bool
 		zipCompression      bool
 		clientCut           bool
+		returnIndexPage     bool
 		bufferMaxSizeForPut uint64
 		namespaceHeader     string
 		defaultNamespaces   []string
@@ -176,12 +177,24 @@ func (s *appSettings) ZipCompression() bool {
 	return s.zipCompression
 }
 
+func (s *appSettings) ReturnIndexPage() bool {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.returnIndexPage
+}
+
 func (s *appSettings) setZipCompression(val bool) {
 	s.mu.Lock()
 	s.zipCompression = val
 	s.mu.Unlock()
 }
 
+func (s *appSettings) setReturnIndexPage(val bool) {
+	s.mu.Lock()
+	s.returnIndexPage = val
+	s.mu.Unlock()
+}
+
 func (s *appSettings) ClientCut() bool {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
@@ -498,6 +511,7 @@ func (a *app) configReload(ctx context.Context) {
 func (a *app) updateSettings() {
 	a.settings.setDefaultTimestamp(a.cfg.GetBool(cfgUploaderHeaderEnableDefaultTimestamp))
 	a.settings.setZipCompression(a.cfg.GetBool(cfgZipCompression))
+	a.settings.setReturnIndexPage(a.cfg.GetBool(cfgReturnIndexPage))
 	a.settings.setClientCut(a.cfg.GetBool(cfgClientCut))
 	a.settings.setBufferMaxSizeForPut(a.cfg.GetUint64(cfgBufferMaxSizeForPut))
 	a.settings.setNamespaceHeader(a.cfg.GetString(cfgResolveNamespaceHeader))

cmd/http-gw/settings.go

@@ -60,6 +60,8 @@ const (
 
 	cfgReconnectInterval = "reconnect_interval"
 
+	cfgReturnIndexPage = "return_index_page"
+
 	// Web.
 	cfgWebReadBufferSize     = "web.read_buffer_size"
 	cfgWebWriteBufferSize    = "web.write_buffer_size"
@@ -191,6 +193,8 @@ func settings() *viper.Viper {
 	// pool:
 	v.SetDefault(cfgPoolErrorThreshold, defaultPoolErrorThreshold)
 
+	v.SetDefault(cfgReturnIndexPage, false)
+
 	// frostfs:
 	v.SetDefault(cfgBufferMaxSizeForPut, defaultBufferMaxSizeForPut)
 

config/config.yaml

@@ -101,6 +101,9 @@ request_timeout: 5s # Timeout to check node health during rebalance.
 rebalance_timer: 30s # Interval to check nodes health.
 pool_error_threshold: 100 # The number of errors on connection after which node is considered as unhealthy.
 
+# enable index page to see objects list for specified container and prefix
+return_index_page: false
+
 zip:
   compression: false # Enable zip compression to download files by common prefix.
 

docs/api.md

@@ -95,12 +95,12 @@ The `filename` field from the multipart form will be set as `FileName` attribute
 
 ## Get object
 
-Route: `/get/{cid}/{oid}?[download=true]`
+Route: `/get/{cid}/{oid}?[download=false]`
 
 | Route parameter | Type   | Description                                                                                                                                                |
 |-----------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `cid`           | Single | Base58 encoded container ID or container name from NNS.                                                                                                    |
-| `oid`           | Single | Base58 encoded object ID.                                                                                                                                  |
+| `cid`           | Single | Base58 encoded `container ID` or `container name` from NNS or `bucket name`.                                                                               |
+| `oid`           | Single | Base58 encoded `object ID`. Also could be `S3 object name` if `cid` is specified as bucket name.                                                           |
 | `download`      | Query  | Set the `Content-Disposition` header as `attachment` in response.<br/> This make the browser to download object as file instead of showing it on the page. |
 
 ### Methods

docs/gate-configuration.md

@@ -73,18 +73,20 @@ request_timeout: 5s
 rebalance_timer: 30s
 pool_error_threshold: 100
 reconnect_interval: 1m
+return_index_page: false
 ```
 
-| Parameter              | Type       | SIGHUP reload | Default value  | Description                                                                        |
-|------------------------|------------|---------------|----------------|------------------------------------------------------------------------------------|
-| `rpc_endpoint`         | `string`   | yes           |                | The address of the RPC host to which the gateway connects to resolve bucket names. |
-| `resolve_order`        | `[]string` | yes           | `[nns, dns]`   | Order of bucket name resolvers to use.                                             |
-| `connect_timeout`      | `duration` |               | `10s`          | Timeout to connect to a node.                                                      |
-| `stream_timeout`       | `duration` |               | `10s`          | Timeout for individual operations in streaming RPC.                                |
-| `request_timeout`      | `duration` |               | `15s`          | Timeout to check node health during rebalance.                                     |
-| `rebalance_timer`      | `duration` |               | `60s`          | Interval to check node health.                                                     |
-| `pool_error_threshold` | `uint32`   |               | `100`          | The number of errors on connection after which node is considered as unhealthy.    |
-| `reconnect_interval`   | `duration` | no            | `1m`           | Listeners reconnection interval.                                                   |
+| Parameter              | Type       | SIGHUP reload | Default value | Description                                                                                     |
+|------------------------|------------|---------------|---------------|-------------------------------------------------------------------------------------------------|
+| `rpc_endpoint`         | `string`   | yes           |               | The address of the RPC host to which the gateway connects to resolve bucket names.              |
+| `resolve_order`        | `[]string` | yes           | `[nns, dns]`  | Order of bucket name resolvers to use.                                                          |
+| `connect_timeout`      | `duration` |               | `10s`         | Timeout to connect to a node.                                                                   |
+| `stream_timeout`       | `duration` |               | `10s`         | Timeout for individual operations in streaming RPC.                                             |
+| `request_timeout`      | `duration` |               | `15s`         | Timeout to check node health during rebalance.                                                  |
+| `rebalance_timer`      | `duration` |               | `60s`         | Interval to check node health.                                                                  |
+| `pool_error_threshold` | `uint32`   |               | `100`         | The number of errors on connection after which node is considered as unhealthy.                 |
+| `reconnect_interval`   | `duration` | no            | `1m`          | Listeners reconnection interval.                                                                |
+| `return_index_page`    | `bool`     | yes           | `false`       | Whether to return index HTML-page in cases when S3 object name from path recognized as a prefix |
 
 # `wallet` section
 

internal/api/tree.go

@@ -8,6 +8,7 @@ import (
 type NodeVersion struct {
 	BaseNodeVersion
 	DeleteMarker bool
+	IsPrefixNode bool
 }
 
 // BaseNodeVersion is minimal node info from tree service.

internal/frostfs/services/pool_wrapper.go

@@ -4,7 +4,9 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"io"
 
+	"git.frostfs.info/TrueCloudLab/frostfs-http-gw/internal/data"
 	"git.frostfs.info/TrueCloudLab/frostfs-http-gw/tokens"
 	"git.frostfs.info/TrueCloudLab/frostfs-http-gw/tree"
 	treepool "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/pool/tree"
@@ -15,16 +17,16 @@ type GetNodeByPathResponseInfoWrapper struct {
 	response *grpcService.GetNodeByPathResponse_Info
 }
 
-func (n GetNodeByPathResponseInfoWrapper) GetNodeID() uint64 {
-	return n.response.GetNodeId()
+func (n GetNodeByPathResponseInfoWrapper) GetNodeID() []uint64 {
+	return []uint64{n.response.GetNodeId()}
 }
 
 func (n GetNodeByPathResponseInfoWrapper) GetParentID() uint64 {
 	return n.response.GetParentId()
 }
 
-func (n GetNodeByPathResponseInfoWrapper) GetTimestamp() uint64 {
-	return n.response.GetTimestamp()
+func (n GetNodeByPathResponseInfoWrapper) GetTimestamp() []uint64 {
+	return []uint64{n.response.GetTimestamp()}
 }
 
 func (n GetNodeByPathResponseInfoWrapper) GetMeta() []tree.Meta {
@@ -89,3 +91,73 @@ func handleError(err error) error {
 
 	return err
 }
+
+func (w *PoolWrapper) GetSubTree(ctx context.Context, bktInfo *data.BucketInfo, treeID string, rootID []uint64, depth uint32, sort bool) ([]tree.NodeResponse, error) {
+	order := treepool.NoneOrder
+	if sort {
+		order = treepool.AscendingOrder
+	}
+	poolPrm := treepool.GetSubTreeParams{
+		CID:         bktInfo.CID,
+		TreeID:      treeID,
+		RootID:      rootID,
+		Depth:       depth,
+		BearerToken: getBearer(ctx),
+		Order:       order,
+	}
+	if len(rootID) == 1 && rootID[0] == 0 {
+		// storage node interprets 'nil' value as []uint64{0}
+		// gate wants to send 'nil' value instead of []uint64{0}, because
+		// it provides compatibility with previous tree service api where
+		// single uint64(0) value is dropped from signature
+		poolPrm.RootID = nil
+	}
+
+	subTreeReader, err := w.p.GetSubTree(ctx, poolPrm)
+	if err != nil {
+		return nil, handleError(err)
+	}
+
+	var subtree []tree.NodeResponse
+
+	node, err := subTreeReader.Next()
+	for err == nil {
+		subtree = append(subtree, GetSubTreeResponseBodyWrapper{node})
+		node, err = subTreeReader.Next()
+	}
+	if err != nil && err != io.EOF {
+		return nil, handleError(err)
+	}
+
+	return subtree, nil
+}
+
+type GetSubTreeResponseBodyWrapper struct {
+	response *grpcService.GetSubTreeResponse_Body
+}
+
+func (n GetSubTreeResponseBodyWrapper) GetNodeID() []uint64 {
+	return n.response.GetNodeId()
+}
+
+func (n GetSubTreeResponseBodyWrapper) GetParentID() []uint64 {
+	resp := n.response.GetParentId()
+	if resp == nil {
+		// storage sends nil that should be interpreted as []uint64{0}
+		// due to protobuf compatibility, see 'GetSubTree' function
+		return []uint64{0}
+	}
+	return resp
+}
+
+func (n GetSubTreeResponseBodyWrapper) GetTimestamp() []uint64 {
+	return n.response.GetTimestamp()
+}
+
+func (n GetSubTreeResponseBodyWrapper) GetMeta() []tree.Meta {
+	res := make([]tree.Meta, len(n.response.Meta))
+	for i, value := range n.response.Meta {
+		res[i] = value
+	}
+	return res
+}

internal/handler/browse.go

@@ -0,0 +1,93 @@
+package handler
+
+import (
+	_ "embed"
+	"encoding/json"
+	"strconv"
+	"strings"
+	"text/template"
+	"time"
+
+	"git.frostfs.info/TrueCloudLab/frostfs-http-gw/utils"
+	"github.com/valyala/fasthttp"
+	"go.uber.org/zap"
+)
+
+const dateFormat = "02-01-2006 15:04"
+
+type (
+	timestamp      time.Time
+	BrowsePageData struct {
+		BucketName,
+		Prefix string
+		Objects []ResponseObject
+	}
+	ResponseObject struct {
+		OID      string    `json:"OID"`
+		Created  timestamp `json:"Created"`
+		FileName string    `json:"FileName"`
+		Size     string    `json:"Size"`
+	}
+)
+
+//go:embed templates/browse.gotmpl
+var browseTemplate string
+
+func (t *timestamp) UnmarshalJSON(b []byte) error {
+	var strMillis string
+	err := json.Unmarshal(b, &strMillis)
+	if err != nil {
+		return err
+	}
+	millis, err := strconv.ParseInt(strMillis, 10, 64)
+	if err != nil {
+		return err
+	}
+
+	*t = timestamp(time.UnixMilli(millis))
+
+	return nil
+}
+
+func formatDate(date timestamp) string {
+	if time.Time(date).IsZero() {
+		return ""
+	}
+
+	return time.Time(date).Format(dateFormat)
+}
+
+func (h *Handler) browseObjects(c *fasthttp.RequestCtx, bucketName, prefix string) {
+	var log = h.log.With(zap.String("bucket", bucketName))
+	ctx := utils.GetContextFromRequest(c)
+	nodes, err := h.listObjects(ctx, bucketName, prefix)
+	if err != nil {
+		logAndSendBucketError(c, log, err)
+		return
+	}
+	jsonNodes, err := json.Marshal(nodes)
+	if err != nil {
+		logAndSendBucketError(c, log, err)
+		return
+	}
+	respObjects := make([]ResponseObject, len(nodes))
+	if err = json.Unmarshal(jsonNodes, &respObjects); err != nil {
+		logAndSendBucketError(c, log, err)
+		return
+	}
+	tmpl, err := template.New("browse").Funcs(template.FuncMap{
+		"formatDate": formatDate,
+	}).Parse(browseTemplate)
+	if err != nil {
+		logAndSendBucketError(c, log, err)
+		return
+	}
+	if err = tmpl.Execute(c, &BrowsePageData{
+		BucketName: bucketName,
+		Prefix:     strings.TrimRight(prefix, "/"),
+		Objects:    respObjects,
+	}); err != nil {
+		logAndSendBucketError(c, log, err)
+		return
+	}
+}

internal/handler/handler.go

@@ -30,6 +30,7 @@ type Config interface {
 	DefaultTimestamp() bool
 	ZipCompression() bool
 	ClientCut() bool
+	ReturnIndexPage() bool
 	BufferMaxSizeForPut() uint64
 	NamespaceHeader() string
 }
@@ -155,6 +156,8 @@ type Handler struct {
 	cache             *cache.BucketCache
 }
 
+type ListType int
+
 type AppParams struct {
 	Logger   *zap.Logger
 	FrostFS  FrostFS
@@ -208,41 +211,46 @@ func (h *Handler) byAddress(c *fasthttp.RequestCtx, f func(context.Context, requ
 
 // byObjectName is a wrapper for function (e.g. request.headObject, request.receiveFile) that
 // prepares request and object address to it.
-func (h *Handler) byObjectName(req *fasthttp.RequestCtx, f func(context.Context, request, oid.Address)) {
+func (h *Handler) byObjectName(c *fasthttp.RequestCtx, f func(context.Context, request, oid.Address)) {
 	var (
-		bucketname = req.UserValue("cid").(string)
-		key        = req.UserValue("oid").(string)
+		bucketname = c.UserValue("cid").(string)
+		key        = c.UserValue("oid").(string)
 		log        = h.log.With(zap.String("bucketname", bucketname), zap.String("key", key))
 	)
 
 	unescapedKey, err := url.QueryUnescape(key)
 	if err != nil {
-		logAndSendBucketError(req, log, err)
+		logAndSendBucketError(c, log, err)
 		return
 	}
 
-	ctx := utils.GetContextFromRequest(req)
+	ctx := utils.GetContextFromRequest(c)
 
 	bktInfo, err := h.getBucketInfo(ctx, bucketname, log)
 	if err != nil {
-		logAndSendBucketError(req, log, err)
+		logAndSendBucketError(c, log, err)
 		return
 	}
 
 	foundOid, err := h.tree.GetLatestVersion(ctx, &bktInfo.CID, unescapedKey)
+	needIndexPage := h.config.ReturnIndexPage()
 	if err != nil {
 		if errors.Is(err, tree.ErrNodeAccessDenied) {
-			response.Error(req, "Access Denied", fasthttp.StatusForbidden)
+			response.Error(c, "Access Denied", fasthttp.StatusForbidden)
 			return
 		}
-		log.Error(logs.GetLatestObjectVersion, zap.Error(err))
-
-		response.Error(req, "object wasn't found", fasthttp.StatusNotFound)
+		if needIndexPage {
+			h.browseObjects(c, bucketname, key)
+		}
+		return
+	}
+	if foundOid.IsPrefixNode && needIndexPage {
+		h.browseObjects(c, bucketname, key)
 		return
 	}
 	if foundOid.DeleteMarker {
 		log.Error(logs.ObjectWasDeleted)
-		response.Error(req, "object deleted", fasthttp.StatusNotFound)
+		response.Error(c, "object deleted", fasthttp.StatusNotFound)
 		return
 	}
 
@@ -250,7 +258,7 @@ func (h *Handler) byObjectName(req *fasthttp.RequestCtx, f func(context.Context,
 	addr.SetContainer(bktInfo.CID)
 	addr.SetObject(foundOid.OID)
 
-	f(ctx, *h.newRequest(req, log), addr)
+	f(ctx, *h.newRequest(c, log), addr)
 }
 
 // byAttribute is a wrapper similar to byAddress.
@@ -379,3 +387,32 @@ func (h *Handler) readContainer(ctx context.Context, cnrID cid.ID) (*data.Bucket
 
 	return bktInfo, err
 }
+
+func (h *Handler) listObjects(ctx context.Context, bucketName, prefix string) ([]map[string]string, error) {
+	var (
+		log = h.log.With(zap.String("bucket", bucketName))
+	)
+	bucketInfo, err := h.getBucketInfo(ctx, bucketName, log)
+	if err != nil {
+		return nil, err
+	}
+	nodes, _, err := h.tree.GetSubTreeByPrefix(ctx, bucketInfo, prefix, true)
+	if err != nil {
+		return nil, err
+	}
+
+	var objects = make([]map[string]string, 0, len(nodes))
+	for _, node := range nodes {
+		meta := node.GetMeta()
+		if meta == nil {
+			continue
+		}
+		var obj = make(map[string]string, len(meta))
+		for _, m := range meta {
+			obj[m.GetKey()] = string(m.GetValue())
+		}
+		objects = append(objects, obj)
+	}
+
+	return objects, nil
+}

internal/handler/handler_test.go

@@ -12,6 +12,7 @@ import (
 	"time"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-http-gw/internal/cache"
+	"git.frostfs.info/TrueCloudLab/frostfs-http-gw/internal/data"
 	"git.frostfs.info/TrueCloudLab/frostfs-http-gw/internal/handler/middleware"
 	"git.frostfs.info/TrueCloudLab/frostfs-http-gw/resolver"
 	"git.frostfs.info/TrueCloudLab/frostfs-http-gw/tree"
@@ -37,6 +38,10 @@ func (t *treeClientMock) GetNodes(context.Context, *tree.GetNodesParams) ([]tree
 	return nil, nil
 }
 
+func (t *treeClientMock) GetSubTree(context.Context, *data.BucketInfo, string, []uint64, uint32, bool) ([]tree.NodeResponse, error) {
+	return nil, nil
+}
+
 type configMock struct {
 }
 
@@ -48,6 +53,10 @@ func (c *configMock) ZipCompression() bool {
 	return false
 }
 
+func (c *configMock) ReturnIndexPage() bool {
+	return false
+}
+
 func (c *configMock) ClientCut() bool {
 	return false
 }

internal/handler/templates/browse.gotmpl

@@ -0,0 +1,58 @@
+{{$bucketName := .BucketName}}
+{{$prefix := .Prefix }}
+<!DOCTYPE html>
+<head>
+    <style>
+        table {
+            width: 100%;
+            border-collapse: collapse;
+        }
+        table, th, td {
+            border: 1px solid black;
+        }
+        th, td {
+            padding: 10px;
+            text-align: left;
+        }
+        th {
+            background-color: #f2f2f2;
+        }
+    </style>
+</head>
+<html lang="en">
+<head><title>Index of {{$bucketName}}{{if $prefix}}/{{$prefix}}/{{end}}</title></head>
+<body>
+    <h1>Index of {{$bucketName}}{{if $prefix}}/{{$prefix}}/{{end}}</h1>
+    <table>
+        <thead>
+            <tr>
+                <th>Filename</th>
+                <th>Size (bytes)</th>
+                <th>Created</th>
+            </tr>
+        </thead>
+        <tbody>
+            {{if $prefix}}
+                <tr>
+                    <td><a href="../">../</a></td>
+                    <td></td>
+                    <td></td>
+                </tr>
+            {{end}}
+            {{range .Objects}}
+                {{if .FileName}}
+                    <tr>
+                        <td>
+                            <a href="/get/{{ $bucketName }}/{{if $prefix}}{{$prefix}}/{{end}}{{.FileName}}{{if not .Size}}/{{end}}?download=true">
+                                {{.FileName}}{{if not .Size}}/{{end}}
+                            </a>
+                        </td>
+                        <td>{{.Size}}</td>
+                        <td>{{ formatDate .Created }}</td>
+                    </tr>
+                {{end}}
+            {{end}}
+        </tbody>
+    </table>
+</body>
+</html>

internal/handler/upload.go

@@ -43,22 +43,22 @@ func (pr *putResponse) encode(w io.Writer) error {
 }
 
 // Upload handles multipart upload request.
-func (h *Handler) Upload(req *fasthttp.RequestCtx) {
+func (h *Handler) Upload(c *fasthttp.RequestCtx) {
 	var (
 		file       MultipartFile
 		idObj      oid.ID
 		addr       oid.Address
-		scid, _    = req.UserValue("cid").(string)
+		scid, _    = c.UserValue("cid").(string)
 		log        = h.log.With(zap.String("cid", scid))
-		bodyStream = req.RequestBodyStream()
+		bodyStream = c.RequestBodyStream()
 		drainBuf   = make([]byte, drainBufSize)
 	)
 
-	ctx := utils.GetContextFromRequest(req)
+	ctx := utils.GetContextFromRequest(c)
 
 	bktInfo, err := h.getBucketInfo(ctx, scid, log)
 	if err != nil {
-		logAndSendBucketError(req, log, err)
+		logAndSendBucketError(c, log, err)
 		return
 	}
 
@@ -75,21 +75,21 @@ func (h *Handler) Upload(req *fasthttp.RequestCtx) {
 			zap.Error(err),
 		)
 	}()
-	boundary := string(req.Request.Header.MultipartFormBoundary())
+	boundary := string(c.Request.Header.MultipartFormBoundary())
 	if file, err = fetchMultipartFile(h.log, bodyStream, boundary); err != nil {
 		log.Error(logs.CouldNotReceiveMultipartForm, zap.Error(err))
-		response.Error(req, "could not receive multipart/form: "+err.Error(), fasthttp.StatusBadRequest)
+		response.Error(c, "could not receive multipart/form: "+err.Error(), fasthttp.StatusBadRequest)
 		return
 	}
-	filtered, err := filterHeaders(h.log, &req.Request.Header)
+	filtered, err := filterHeaders(h.log, &c.Request.Header)
 	if err != nil {
 		log.Error(logs.CouldNotProcessHeaders, zap.Error(err))
-		response.Error(req, err.Error(), fasthttp.StatusBadRequest)
+		response.Error(c, err.Error(), fasthttp.StatusBadRequest)
 		return
 	}
 
 	now := time.Now()
-	if rawHeader := req.Request.Header.Peek(fasthttp.HeaderDate); rawHeader != nil {
+	if rawHeader := c.Request.Header.Peek(fasthttp.HeaderDate); rawHeader != nil {
 		if parsed, err := time.Parse(http.TimeFormat, string(rawHeader)); err != nil {
 			log.Warn(logs.CouldNotParseClientTime, zap.String("Date header", string(rawHeader)), zap.Error(err))
 		} else {
@@ -97,9 +97,9 @@ func (h *Handler) Upload(req *fasthttp.RequestCtx) {
 		}
 	}
 
-	if err = utils.PrepareExpirationHeader(req, h.frostfs, filtered, now); err != nil {
+	if err = utils.PrepareExpirationHeader(c, h.frostfs, filtered, now); err != nil {
 		log.Error(logs.CouldNotPrepareExpirationHeader, zap.Error(err))
-		response.Error(req, "could not prepare expiration header: "+err.Error(), fasthttp.StatusBadRequest)
+		response.Error(c, "could not prepare expiration header: "+err.Error(), fasthttp.StatusBadRequest)
 		return
 	}
 
@@ -143,7 +143,7 @@ func (h *Handler) Upload(req *fasthttp.RequestCtx) {
 	}
 
 	if idObj, err = h.frostfs.CreateObject(ctx, prm); err != nil {
-		h.handlePutFrostFSErr(req, err)
+		h.handlePutFrostFSErr(c, err)
 		return
 	}
 
@@ -151,9 +151,9 @@ func (h *Handler) Upload(req *fasthttp.RequestCtx) {
 	addr.SetContainer(bktInfo.CID)
 
 	// Try to return the response, otherwise, if something went wrong, throw an error.
-	if err = newPutResponse(addr).encode(req); err != nil {
+	if err = newPutResponse(addr).encode(c); err != nil {
 		log.Error(logs.CouldNotEncodeResponse, zap.Error(err))
-		response.Error(req, "could not encode response", fasthttp.StatusBadRequest)
+		response.Error(c, "could not encode response", fasthttp.StatusBadRequest)
 
 		return
 	}
@@ -170,8 +170,8 @@ func (h *Handler) Upload(req *fasthttp.RequestCtx) {
 		}
 	}
 	// Report status code and content type.
-	req.Response.SetStatusCode(fasthttp.StatusOK)
-	req.Response.Header.SetContentType(jsonHeader)
+	c.Response.SetStatusCode(fasthttp.StatusOK)
+	c.Response.Header.SetContentType(jsonHeader)
 }
 
 func (h *Handler) handlePutFrostFSErr(r *fasthttp.RequestCtx, err error) {

internal/logs/logs.go

@@ -49,7 +49,7 @@ const (
 	AddedPathUploadCid                                                    = "added path /upload/{cid}"                                                               // Info in ../../app.go
 	AddedPathGetCidOid                                                    = "added path /get/{cid}/{oid}"                                                            // Info in ../../app.go
 	AddedPathGetByAttributeCidAttrKeyAttrVal                              = "added path /get_by_attribute/{cid}/{attr_key}/{attr_val:*}"                             // Info in ../../app.go
-	AddedPathZipCidPrefix                                                 = "added path /zip/{cid}/{prefix}"                                                         // Info in ../../app.go
+	AddedPathZipCidPrefix                                                 = "added path /zip/{cid}/{prefix:*}"                                                       // Info in ../../app.go
 	Request                                                               = "request"                                                                                // Info in ../../app.go
 	CouldNotFetchAndStoreBearerToken                                      = "could not fetch and store bearer token"                                                 // Error in ../../app.go
 	FailedToAddServer                                                     = "failed to add server"                                                                   // Warn in ../../app.go

tokens/bearer-token.go

@@ -52,8 +52,8 @@ func BearerTokenFromCookie(h *fasthttp.RequestHeader) []byte {
 
 // StoreBearerTokenAppCtx extracts a bearer token from the header or cookie and stores
 // it in the application context.
-func StoreBearerTokenAppCtx(ctx context.Context, req *fasthttp.RequestCtx) (context.Context, error) {
-	tkn, err := fetchBearerToken(req)
+func StoreBearerTokenAppCtx(ctx context.Context, c *fasthttp.RequestCtx) (context.Context, error) {
+	tkn, err := fetchBearerToken(c)
 	if err != nil {
 		return nil, err
 	}

tree/tree.go

@@ -2,11 +2,13 @@ package tree
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"strings"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-http-gw/internal/api"
 	"git.frostfs.info/TrueCloudLab/frostfs-http-gw/internal/api/layer"
+	"git.frostfs.info/TrueCloudLab/frostfs-http-gw/internal/data"
 	cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
 	oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
 )
@@ -20,6 +22,7 @@ type (
 	// Each method must return ErrNodeNotFound or ErrNodeAccessDenied if relevant.
 	ServiceClient interface {
 		GetNodes(ctx context.Context, p *GetNodesParams) ([]NodeResponse, error)
+		GetSubTree(ctx context.Context, bktInfo *data.BucketInfo, treeID string, rootID []uint64, depth uint32, sort bool) ([]NodeResponse, error)
 	}
 
 	treeNode struct {
@@ -29,6 +32,7 @@ type (
 
 	GetNodesParams struct {
 		CnrID      cid.ID
+		BktInfo    *data.BucketInfo
 		TreeID     string
 		Path       []string
 		Meta       []string
@@ -54,6 +58,7 @@ const (
 
 	// keys for delete marker nodes.
 	isDeleteMarkerKV = "IsDeleteMarker"
+	sizeKV           = "Size"
 
 	// versionTree -- ID of a tree with object versions.
 	versionTree = "version"
@@ -73,26 +78,31 @@ type Meta interface {
 
 type NodeResponse interface {
 	GetMeta() []Meta
-	GetTimestamp() uint64
+	GetTimestamp() []uint64
+	GetNodeID() []uint64
+}
+
+type SubTreeStream interface {
+	Next() (NodeResponse, error)
 }
 
 func newTreeNode(nodeInfo NodeResponse) (*treeNode, error) {
-	treeNode := &treeNode{
+	tNode := &treeNode{
 		Meta: make(map[string]string, len(nodeInfo.GetMeta())),
 	}
 
 	for _, kv := range nodeInfo.GetMeta() {
 		switch kv.GetKey() {
 		case oidKV:
-			if err := treeNode.ObjID.DecodeString(string(kv.GetValue())); err != nil {
+			if err := tNode.ObjID.DecodeString(string(kv.GetValue())); err != nil {
 				return nil, err
 			}
 		default:
-			treeNode.Meta[kv.GetKey()] = string(kv.GetValue())
+			tNode.Meta[kv.GetKey()] = string(kv.GetValue())
 		}
 	}
 
-	return treeNode, nil
+	return tNode, nil
 }
 
 func (n *treeNode) Get(key string) (string, bool) {
@@ -106,40 +116,30 @@ func (n *treeNode) FileName() (string, bool) {
 }
 
 func newNodeVersion(node NodeResponse) (*api.NodeVersion, error) {
-	treeNode, err := newTreeNode(node)
+	tNode, err := newTreeNode(node)
 	if err != nil {
 		return nil, fmt.Errorf("invalid tree node: %w", err)
 	}
 
-	return newNodeVersionFromTreeNode(treeNode), nil
+	return newNodeVersionFromTreeNode(tNode), nil
 }
 
 func newNodeVersionFromTreeNode(treeNode *treeNode) *api.NodeVersion {
 	_, isDeleteMarker := treeNode.Get(isDeleteMarkerKV)
-
+	size, _ := treeNode.Get(sizeKV)
 	version := &api.NodeVersion{
 		BaseNodeVersion: api.BaseNodeVersion{
 			OID: treeNode.ObjID,
 		},
 		DeleteMarker: isDeleteMarker,
+		IsPrefixNode: size == "",
 	}
 
 	return version
 }
 
 func (c *Tree) GetLatestVersion(ctx context.Context, cnrID *cid.ID, objectName string) (*api.NodeVersion, error) {
-	meta := []string{oidKV, isDeleteMarkerKV}
-	path := pathFromName(objectName)
-
-	p := &GetNodesParams{
-		CnrID:      *cnrID,
-		TreeID:     versionTree,
-		Path:       path,
-		Meta:       meta,
-		LatestOnly: false,
-		AllAttrs:   false,
-	}
-	nodes, err := c.service.GetNodes(ctx, p)
+	nodes, err := c.GetVersions(ctx, cnrID, objectName)
 	if err != nil {
 		return nil, err
 	}
@@ -152,6 +152,22 @@ func (c *Tree) GetLatestVersion(ctx context.Context, cnrID *cid.ID, objectName s
 	return newNodeVersion(latestNode)
 }
 
+func (c *Tree) GetVersions(ctx context.Context, cnrID *cid.ID, objectName string) ([]NodeResponse, error) {
+	meta := []string{oidKV, isDeleteMarkerKV, sizeKV}
+	path := pathFromName(objectName)
+
+	p := &GetNodesParams{
+		CnrID:      *cnrID,
+		TreeID:     versionTree,
+		Path:       path,
+		Meta:       meta,
+		LatestOnly: false,
+		AllAttrs:   false,
+	}
+
+	return c.service.GetNodes(ctx, p)
+}
+
 func getLatestNode(nodes []NodeResponse) (NodeResponse, error) {
 	var (
 		maxCreationTime uint64
@@ -160,8 +176,8 @@ func getLatestNode(nodes []NodeResponse) (NodeResponse, error) {
 
 	for i, node := range nodes {
 		currentCreationTime := node.GetTimestamp()
-		if checkExistOID(node.GetMeta()) && currentCreationTime > maxCreationTime {
-			maxCreationTime = currentCreationTime
+		if checkExistOID(node.GetMeta()) && getMaxTimestamp(node) > maxCreationTime {
+			maxCreationTime = currentCreationTime[0]
 			targetIndexNode = i
 		}
 	}
@@ -187,3 +203,149 @@ func checkExistOID(meta []Meta) bool {
 func pathFromName(objectName string) []string {
 	return strings.Split(objectName, separator)
 }
+
+func (c *Tree) GetSubTreeByPrefix(ctx context.Context, bktInfo *data.BucketInfo, prefix string, latestOnly bool) ([]NodeResponse, string, error) {
+	rootID, tailPrefix, err := c.determinePrefixNode(ctx, bktInfo, versionTree, prefix)
+	if err != nil {
+		if errors.Is(err, layer.ErrNodeNotFound) {
+			return nil, "", nil
+		}
+		return nil, "", err
+	}
+
+	subTree, err := c.service.GetSubTree(ctx, bktInfo, versionTree, rootID, 2, false)
+	if err != nil {
+		if errors.Is(err, layer.ErrNodeNotFound) {
+			return nil, "", nil
+		}
+		return nil, "", err
+	}
+
+	nodesMap := make(map[string][]NodeResponse, len(subTree))
+	for _, node := range subTree {
+		if MultiID(rootID).Equal(node.GetNodeID()) {
+			continue
+		}
+
+		fileName := getFilename(node)
+		if !strings.HasPrefix(fileName, tailPrefix) {
+			continue
+		}
+
+		nodes := nodesMap[fileName]
+
+		// Add all nodes if flag latestOnly is false.
+		// Add all intermediate nodes
+		// and only latest leaf (object) nodes. To do this store and replace last leaf (object) node in nodes[0]
+		if len(nodes) == 0 {
+			nodes = []NodeResponse{node}
+		} else if !latestOnly || isIntermediate(node) {
+			nodes = append(nodes, node)
+		} else if isIntermediate(nodes[0]) {
+			nodes = append([]NodeResponse{node}, nodes...)
+		} else if getMaxTimestamp(node) > getMaxTimestamp(nodes[0]) {
+			nodes[0] = node
+		}
+
+		nodesMap[fileName] = nodes
+	}
+
+	result := make([]NodeResponse, 0, len(subTree))
+	for _, nodes := range nodesMap {
+		result = append(result, nodes...)
+	}
+
+	return result, strings.TrimSuffix(prefix, tailPrefix), nil
+}
+
+func (c *Tree) determinePrefixNode(ctx context.Context, bktInfo *data.BucketInfo, treeID, prefix string) ([]uint64, string, error) {
+	rootID := []uint64{0}
+	path := strings.Split(prefix, separator)
+	tailPrefix := path[len(path)-1]
+
+	if len(path) > 1 {
+		var err error
+		rootID, err = c.getPrefixNodeID(ctx, bktInfo, treeID, path[:len(path)-1])
+		if err != nil {
+			return nil, "", err
+		}
+	}
+
+	return rootID, tailPrefix, nil
+}
+
+func (c *Tree) getPrefixNodeID(ctx context.Context, bktInfo *data.BucketInfo, treeID string, prefixPath []string) ([]uint64, error) {
+	p := &GetNodesParams{
+		CnrID:      bktInfo.CID,
+		BktInfo:    bktInfo,
+		TreeID:     treeID,
+		Path:       prefixPath,
+		LatestOnly: false,
+		AllAttrs:   true,
+	}
+	nodes, err := c.service.GetNodes(ctx, p)
+	if err != nil {
+		return nil, err
+	}
+
+	var intermediateNodes []uint64
+	for _, node := range nodes {
+		if isIntermediate(node) {
+			intermediateNodes = append(intermediateNodes, node.GetNodeID()...)
+		}
+	}
+
+	if len(intermediateNodes) == 0 {
+		return nil, layer.ErrNodeNotFound
+	}
+
+	return intermediateNodes, nil
+}
+
+func getFilename(node NodeResponse) string {
+	for _, kv := range node.GetMeta() {
+		if kv.GetKey() == FileNameKey {
+			return string(kv.GetValue())
+		}
+	}
+
+	return ""
+}
+
+func isIntermediate(node NodeResponse) bool {
+	if len(node.GetMeta()) != 1 {
+		return false
+	}
+
+	return node.GetMeta()[0].GetKey() == FileNameKey
+}
+
+func getMaxTimestamp(node NodeResponse) uint64 {
+	var maxTimestamp uint64
+
+	for _, timestamp := range node.GetTimestamp() {
+		if timestamp > maxTimestamp {
+			maxTimestamp = timestamp
+		}
+	}
+
+	return maxTimestamp
+}
+
+type MultiID []uint64
+
+func (m MultiID) Equal(id MultiID) bool {
+	seen := make(map[uint64]struct{}, len(m))
+
+	for i := range m {
+		seen[m[i]] = struct{}{}
+	}
+
+	for i := range id {
+		if _, ok := seen[id[i]]; !ok {
+			return false
+		}
+	}
+
+	return true
+}

tree/tree_test.go

@@ -24,8 +24,8 @@ type nodeResponse struct {
 	timestamp uint64
 }
 
-func (n nodeResponse) GetTimestamp() uint64 {
-	return n.timestamp
+func (n nodeResponse) GetTimestamp() []uint64 {
+	return []uint64{n.timestamp}
 }
 
 func (n nodeResponse) GetMeta() []Meta {
@@ -36,6 +36,10 @@ func (n nodeResponse) GetMeta() []Meta {
 	return res
 }
 
+func (n nodeResponse) GetNodeID() []uint64 {
+	return nil
+}
+
 func TestGetLatestNode(t *testing.T) {
 	for _, tc := range []struct {
 		name        string