121 lines
3.0 KiB
Go
121 lines
3.0 KiB
Go
package blobstor
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
|
|
"github.com/klauspost/compress/zstd"
|
|
"github.com/nspcc-dev/neofs-node/pkg/core/object"
|
|
storagelog "github.com/nspcc-dev/neofs-node/pkg/local_object_storage/internal/log"
|
|
objectSDK "github.com/nspcc-dev/neofs-sdk-go/object"
|
|
oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
|
|
)
|
|
|
|
// PutPrm groups the parameters of Put operation.
|
|
type PutPrm struct {
|
|
rwObject
|
|
}
|
|
|
|
// PutRes groups the resulting values of Put operation.
|
|
type PutRes struct {
|
|
roBlobovniczaID
|
|
}
|
|
|
|
// Put saves the object in BLOB storage.
|
|
//
|
|
// If object is "big", BlobStor saves the object in shallow dir.
|
|
// Otherwise, BlobStor saves the object in blobonicza. In this
|
|
// case the identifier of blobovnicza is returned.
|
|
//
|
|
// Returns any error encountered that
|
|
// did not allow to completely save the object.
|
|
func (b *BlobStor) Put(prm PutPrm) (PutRes, error) {
|
|
// marshal object
|
|
data, err := prm.obj.Marshal()
|
|
if err != nil {
|
|
return PutRes{}, fmt.Errorf("could not marshal the object: %w", err)
|
|
}
|
|
|
|
return b.PutRaw(object.AddressOf(prm.obj), data, b.NeedsCompression(prm.obj))
|
|
}
|
|
|
|
// NeedsCompression returns true if the object should be compressed.
|
|
// For an object to be compressed 2 conditions must hold:
|
|
// 1. Compression is enabled in settings.
|
|
// 2. Object MIME Content-Type is allowed for compression.
|
|
func (b *BlobStor) NeedsCompression(obj *objectSDK.Object) bool {
|
|
if !b.compressionEnabled || len(b.uncompressableContentTypes) == 0 {
|
|
return b.compressionEnabled
|
|
}
|
|
|
|
for _, attr := range obj.Attributes() {
|
|
if attr.Key() == objectSDK.AttributeContentType {
|
|
for _, value := range b.uncompressableContentTypes {
|
|
match := false
|
|
switch {
|
|
case len(value) > 0 && value[len(value)-1] == '*':
|
|
match = strings.HasPrefix(attr.Value(), value[:len(value)-1])
|
|
case len(value) > 0 && value[0] == '*':
|
|
match = strings.HasSuffix(attr.Value(), value[1:])
|
|
default:
|
|
match = attr.Value() == value
|
|
}
|
|
if match {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return b.compressionEnabled
|
|
}
|
|
|
|
// PutRaw saves an already marshaled object in BLOB storage.
|
|
func (b *BlobStor) PutRaw(addr oid.Address, data []byte, compress bool) (PutRes, error) {
|
|
big := b.isBig(data)
|
|
|
|
if big {
|
|
var err error
|
|
if compress {
|
|
err = b.fsTree.PutStream(addr, func(f *os.File) error {
|
|
enc, _ := zstd.NewWriter(f) // nil error if no options are provided
|
|
if _, err := enc.Write(data); err != nil {
|
|
return err
|
|
}
|
|
return enc.Close()
|
|
})
|
|
} else {
|
|
err = b.fsTree.Put(addr, data)
|
|
}
|
|
if err != nil {
|
|
return PutRes{}, err
|
|
}
|
|
|
|
storagelog.Write(b.log, storagelog.AddressField(addr), storagelog.OpField("fstree PUT"))
|
|
|
|
return PutRes{}, nil
|
|
}
|
|
|
|
if compress {
|
|
data = b.compressor(data)
|
|
}
|
|
|
|
// save object in blobovnicza
|
|
res, err := b.blobovniczas.put(addr, data)
|
|
if err != nil {
|
|
return PutRes{}, err
|
|
}
|
|
|
|
return PutRes{
|
|
roBlobovniczaID: roBlobovniczaID{
|
|
blobovniczaID: res,
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
// checks if object is "big".
|
|
func (b *BlobStor) isBig(data []byte) bool {
|
|
return uint64(len(data)) > b.smallSizeLimit
|
|
}
|