package transformer import ( "context" "crypto/ecdsa" "crypto/sha256" "fmt" "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/checksum" "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object" oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id" "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/session" "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/version" "git.frostfs.info/TrueCloudLab/tzhash/tz" ) type payloadSizeLimiter struct { Params written, writtenCurrent uint64 current, parent *object.Object currentHashers, parentHashers []payloadChecksumHasher previous []oid.ID splitID *object.SplitID parAttrs []object.Attribute } type Params struct { Key *ecdsa.PrivateKey NextTarget ObjectTarget SessionToken *session.Object NetworkState EpochSource MaxSize uint64 WithoutHomomorphicHash bool } // NewPayloadSizeLimiter returns ObjectTarget instance that restricts payload length // of the writing object and writes generated objects to targets from initializer. // // Calculates and adds homomorphic hash to resulting objects only if withoutHomomorphicHash // is false. // // Objects w/ payload size less or equal than max size remain untouched. func NewPayloadSizeLimiter(p Params) ObjectTarget { return &payloadSizeLimiter{ Params: p, splitID: object.NewSplitID(), } } func (s *payloadSizeLimiter) WriteHeader(_ context.Context, hdr *object.Object) error { s.current = fromObject(hdr) s.initialize() return nil } func (s *payloadSizeLimiter) Write(ctx context.Context, p []byte) (int, error) { if err := s.writeChunk(ctx, p); err != nil { return 0, err } return len(p), nil } func (s *payloadSizeLimiter) Close(ctx context.Context) (*AccessIdentifiers, error) { return s.release(ctx, true) } func (s *payloadSizeLimiter) initialize() { s.current = fromObject(s.current) // if it is an object after the 1st if ln := len(s.previous); ln > 0 { // initialize parent object once (after 1st object) if ln == 1 { s.parent = fromObject(s.current) s.parentHashers = append(s.parentHashers[:0], s.currentHashers...) // return source attributes s.parent.SetAttributes(s.parAttrs...) } // set previous object to the last previous identifier s.current.SetPreviousID(s.previous[ln-1]) } s.initializeCurrent() } func fromObject(obj *object.Object) *object.Object { cnr, _ := obj.ContainerID() res := object.New() res.SetContainerID(cnr) res.SetOwnerID(obj.OwnerID()) res.SetAttributes(obj.Attributes()...) res.SetType(obj.Type()) // obj.SetSplitID creates splitHeader but we don't need to do it in case // of small objects, so we should make nil check. if obj.SplitID() != nil { res.SetSplitID(obj.SplitID()) } return res } func (s *payloadSizeLimiter) initializeCurrent() { // create payload hashers s.writtenCurrent = 0 s.initPayloadHashers() } func (s *payloadSizeLimiter) initPayloadHashers() { s.currentHashers = append(s.currentHashers[:0], payloadChecksumHasher{ hasher: sha256.New(), typ: checksum.SHA256, }) if !s.WithoutHomomorphicHash { s.currentHashers = append(s.currentHashers, payloadChecksumHasher{ hasher: tz.New(), typ: checksum.TZ, }) } } func (s *payloadSizeLimiter) release(ctx context.Context, finalize bool) (*AccessIdentifiers, error) { // Arg finalize is true only when called from Close method. // We finalize parent and generate linking objects only if it is more // than 1 object in split-chain. withParent := finalize && len(s.previous) > 0 if withParent { for i := range s.parentHashers { s.parentHashers[i].writeChecksum(s.parent) } s.parent.SetPayloadSize(s.written) s.current.SetParent(s.parent) } // release current object for i := range s.currentHashers { s.currentHashers[i].writeChecksum(s.current) } ids, err := s.fillHeader() if err != nil { return nil, fmt.Errorf("fillHeader: %w", err) } if err := s.NextTarget.WriteHeader(ctx, s.current); err != nil { return nil, fmt.Errorf("could not write header to next target: %w", err) } if _, err := s.NextTarget.Close(ctx); err != nil { return nil, fmt.Errorf("could not close next target: %w", err) } // save identifier of the released object s.previous = append(s.previous, ids.SelfID) if withParent { // generate and release linking object s.initializeLinking(ids.ParentHeader) s.initializeCurrent() if _, err := s.release(ctx, false); err != nil { return nil, fmt.Errorf("could not release linking object: %w", err) } } return ids, nil } func (s *payloadSizeLimiter) fillHeader() (*AccessIdentifiers, error) { curEpoch := s.NetworkState.CurrentEpoch() ver := version.Current() s.current.SetVersion(&ver) s.current.SetPayloadSize(s.writtenCurrent) s.current.SetSessionToken(s.SessionToken) s.current.SetCreationEpoch(curEpoch) var ( parID *oid.ID parHdr *object.Object ) if par := s.current.Parent(); par != nil && par.Signature() == nil { rawPar := object.NewFromV2(par.ToV2()) rawPar.SetSessionToken(s.SessionToken) rawPar.SetCreationEpoch(curEpoch) if err := object.SetIDWithSignature(*s.Key, rawPar); err != nil { return nil, fmt.Errorf("could not finalize parent object: %w", err) } id, _ := rawPar.ID() parID = &id parHdr = rawPar s.current.SetParent(parHdr) } if err := object.SetIDWithSignature(*s.Key, s.current); err != nil { return nil, fmt.Errorf("could not finalize object: %w", err) } id, _ := s.current.ID() return &AccessIdentifiers{ ParentID: parID, SelfID: id, ParentHeader: parHdr, }, nil } func (s *payloadSizeLimiter) initializeLinking(parHdr *object.Object) { s.current = fromObject(s.current) s.current.SetParent(parHdr) s.current.SetChildren(s.previous...) s.current.SetSplitID(s.splitID) } func (s *payloadSizeLimiter) writeChunk(ctx context.Context, chunk []byte) error { for { // statement is true if the previous write of bytes reached exactly the boundary. if s.written > 0 && s.written%s.MaxSize == 0 { if s.written == s.MaxSize { s.prepareFirstChild() } // we need to release current object if _, err := s.release(ctx, false); err != nil { return fmt.Errorf("could not release object: %w", err) } // initialize another object s.initialize() } var ( ln = uint64(len(chunk)) cut = ln leftToEdge = s.MaxSize - s.written%s.MaxSize ) // write bytes no further than the boundary of the current object if ln > leftToEdge { cut = leftToEdge } if err := s.writeHashes(ctx, chunk[:cut]); err != nil { return fmt.Errorf("could not write chunk to target: %w", err) } // increase written bytes counter s.writtenCurrent += cut s.written += cut if cut == ln { return nil } // if there are more bytes in buffer we call method again to start filling another object chunk = chunk[cut:] } } func (s *payloadSizeLimiter) writeHashes(ctx context.Context, chunk []byte) error { _, err := s.NextTarget.Write(ctx, chunk) if err != nil { return err } // The `Write` method of `hash.Hash` never returns an error. for i := range s.currentHashers { _, _ = s.currentHashers[i].hasher.Write(chunk) } for i := range s.parentHashers { _, _ = s.parentHashers[i].hasher.Write(chunk) } return nil } func (s *payloadSizeLimiter) prepareFirstChild() { // initialize split header with split ID on first object in chain s.current.InitRelations() s.current.SetSplitID(s.splitID) // cut source attributes s.parAttrs = s.current.Attributes() s.current.SetAttributes() // attributes will be added to parent in detachParent }