frostfs-http-gw/internal/handler/utils.go

package handler

import (
	"context"
	"errors"
	"fmt"
	"strings"

	"git.frostfs.info/TrueCloudLab/frostfs-http-gw/internal/layer"
	"git.frostfs.info/TrueCloudLab/frostfs-http-gw/internal/logs"
	"git.frostfs.info/TrueCloudLab/frostfs-http-gw/tokens"
	"git.frostfs.info/TrueCloudLab/frostfs-http-gw/utils"
	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/bearer"
	cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object"
	oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
	"github.com/valyala/fasthttp"
	"go.uber.org/zap"
)

func bearerToken(ctx context.Context) *bearer.Token {
	if tkn, err := tokens.LoadBearerToken(ctx); err == nil {
		return tkn
	}
	return nil
}

func isDir(name string) bool {
	return name == "" || strings.HasSuffix(name, "/")
}

func loadAttributes(attrs []object.Attribute) map[string]string {
	result := make(map[string]string)
	for _, attr := range attrs {
		result[attr.Key()] = attr.Value()
	}
	return result
}

func isValidToken(s string) bool {
	for _, c := range s {
		if c <= ' ' || c > 127 {
			return false
		}
		if strings.ContainsRune("()<>@,;:\\\"/[]?={}", c) {
			return false
		}
	}
	return true
}

func isValidValue(s string) bool {
	for _, c := range s {
		// HTTP specification allows for more technically, but we don't want to escape things.
		if c < ' ' || c > 127 || c == '"' {
			return false
		}
	}
	return true
}

func (h *Handler) reqLogger(ctx context.Context) *zap.Logger {
	return utils.GetReqLogOrDefault(ctx, h.log)
}

func (h *Handler) logAndSendError(ctx context.Context, c *fasthttp.RequestCtx, msg string, err error, additional ...zap.Field) {
	utils.GetReqLogOrDefault(ctx, h.log).Error(msg,
		append([]zap.Field{zap.Error(err), logs.TagField(logs.TagDatapath)}, additional...)...)

	msg, code := formErrorResponse(err)
	ResponseError(c, msg, code)
}

func newAddress(cnr cid.ID, obj oid.ID) oid.Address {
	var addr oid.Address
	addr.SetContainer(cnr)
	addr.SetObject(obj)
	return addr
}

// setIfNotExist sets key value to map if key is not present yet.
func setIfNotExist(m map[string]string, key, value string) {
	if _, ok := m[key]; !ok {
		m[key] = value
	}
}

func ResponseError(r *fasthttp.RequestCtx, msg string, code int) {
	r.Error(msg+"\n", code)
}

func formErrorResponse(err error) (string, int) {
	switch {
	case errors.Is(err, ErrAccessDenied):
		return fmt.Sprintf("Storage Access Denied:\n%v", err), fasthttp.StatusForbidden
	case errors.Is(err, layer.ErrNodeAccessDenied):
		return fmt.Sprintf("Tree Access Denied:\n%v", err), fasthttp.StatusForbidden
	case errors.Is(err, ErrQuotaLimitReached):
		return fmt.Sprintf("Quota Reached:\n%v", err), fasthttp.StatusConflict
	case errors.Is(err, ErrContainerNotFound):
		return fmt.Sprintf("Container Not Found:\n%v", err), fasthttp.StatusNotFound
	case errors.Is(err, ErrObjectNotFound):
		return fmt.Sprintf("Object Not Found:\n%v", err), fasthttp.StatusNotFound
	case errors.Is(err, layer.ErrNodeNotFound):
		return fmt.Sprintf("Tree Node Not Found:\n%v", err), fasthttp.StatusNotFound
	case errors.Is(err, ErrGatewayTimeout):
		return fmt.Sprintf("Gateway Timeout:\n%v", err), fasthttp.StatusGatewayTimeout
	default:
		return fmt.Sprintf("Bad Request:\n%v", err), fasthttp.StatusBadRequest
	}
}