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 }