frostfs-api-go/object/lock.go

package object

import (
	"errors"
	"fmt"

	lock "github.com/nspcc-dev/neofs-api-go/v2/lock/grpc"
	"github.com/nspcc-dev/neofs-api-go/v2/refs"
	refsGRPC "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
	"github.com/nspcc-dev/neofs-api-go/v2/rpc/grpc"
	"github.com/nspcc-dev/neofs-api-go/v2/rpc/message"
	"github.com/nspcc-dev/neofs-api-go/v2/util/proto"
)

// Lock represents object Lock message from NeoFS API V2 protocol.
type Lock struct {
	members []refs.ObjectID
}

// NumberOfMembers returns length of lock list.
func (x *Lock) NumberOfMembers() int {
	if x != nil {
		return len(x.members)
	}

	return 0
}

// IterateMembers passes members of the lock list to f.
func (x *Lock) IterateMembers(f func(refs.ObjectID)) {
	if x != nil {
		for i := range x.members {
			f(x.members[i])
		}
	}
}

// SetMembers sets list of locked members.
// Arg must not be mutated for the duration of the Lock.
func (x *Lock) SetMembers(ids []refs.ObjectID) {
	x.members = ids
}

const (
	_ = iota
	fNumLockMembers
)

// StableMarshal encodes the Lock into Protocol Buffers binary format
// with direct field order.
func (x *Lock) StableMarshal(buf []byte) []byte {
	if x == nil || len(x.members) == 0 {
		return []byte{}
	}

	if buf == nil {
		buf = make([]byte, x.StableSize())
	}

	var offset int

	for i := range x.members {
		offset += proto.NestedStructureMarshal(fNumLockMembers, buf[offset:], &x.members[i])
	}

	return buf
}

// StableSize size of the buffer required to write the Lock in Protocol Buffers
// binary format.
func (x *Lock) StableSize() (sz int) {
	if x != nil {
		for i := range x.members {
			sz += proto.NestedStructureSize(fNumLockMembers, &x.members[i])
		}
	}

	return
}

// Unmarshal decodes the Lock from its Protocol Buffers binary format.
func (x *Lock) Unmarshal(data []byte) error {
	return message.Unmarshal(x, data, new(lock.Lock))
}

func (x *Lock) ToGRPCMessage() grpc.Message {
	var m *lock.Lock

	if x != nil {
		m = new(lock.Lock)

		var members []*refsGRPC.ObjectID

		if x.members != nil {
			members = make([]*refsGRPC.ObjectID, len(x.members))

			for i := range x.members {
				members[i] = x.members[i].ToGRPCMessage().(*refsGRPC.ObjectID)
			}
		}

		m.SetMembers(members)
	}

	return m
}

func (x *Lock) FromGRPCMessage(m grpc.Message) error {
	v, ok := m.(*lock.Lock)
	if !ok {
		return message.NewUnexpectedMessageType(m, v)
	}

	members := v.GetMembers()
	if members == nil {
		x.members = nil
	} else {
		x.members = make([]refs.ObjectID, len(members))
		var err error

		for i := range x.members {
			err = x.members[i].FromGRPCMessage(members[i])
			if err != nil {
				return err
			}
		}
	}

	return nil
}

// WriteLock writes Lock to the Object as a payload content.
// The object must not be nil.
func WriteLock(obj *Object, lock Lock) {
	hdr := obj.GetHeader()
	if hdr == nil {
		hdr = new(Header)
		obj.SetHeader(hdr)
	}

	hdr.SetObjectType(TypeLock)

	payload := lock.StableMarshal(nil)
	obj.SetPayload(payload)
}

// ReadLock reads Lock from the Object payload content.
func ReadLock(lock *Lock, obj Object) error {
	payload := obj.GetPayload()
	if len(payload) == 0 {
		return errors.New("empty payload")
	}

	err := lock.Unmarshal(payload)
	if err != nil {
		return fmt.Errorf("decode lock content from payload: %w", err)
	}

	return nil
}