package service import ( "github.com/nspcc-dev/neofs-api-go/internal" "github.com/pkg/errors" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" ) type ( // MetaHeader contains meta information of request. // It provides methods to get or set meta information meta header. // Also contains methods to reset and restore meta header. // Also contains methods to get or set request protocol version MetaHeader interface { ResetMeta() RequestMetaHeader RestoreMeta(RequestMetaHeader) // TTLRequest to verify and update ttl requests. GetTTL() uint32 SetTTL(uint32) // EpochHeader gives possibility to get or set epoch in RPC Requests. EpochHeader // VersionHeader allows get or set version of protocol request VersionHeader // RawHeader allows to get and set raw option of request RawHeader } // EpochHeader interface gives possibility to get or set epoch in RPC Requests. EpochHeader interface { GetEpoch() uint64 SetEpoch(v uint64) } // VersionHeader allows get or set version of protocol request VersionHeader interface { GetVersion() uint32 SetVersion(uint32) } // RawHeader is an interface of the container of a boolean Raw value RawHeader interface { GetRaw() bool SetRaw(bool) } // TTLCondition is closure, that allows to validate request with ttl. TTLCondition func(ttl uint32) error ) const ( // ZeroTTL is empty ttl, should produce ErrZeroTTL. ZeroTTL = iota // NonForwardingTTL is a ttl that allows direct connections only. NonForwardingTTL // SingleForwardingTTL is a ttl that allows connections through another node. SingleForwardingTTL ) const ( // ErrZeroTTL is raised when zero ttl is passed. ErrZeroTTL = internal.Error("zero ttl") // ErrIncorrectTTL is raised when NonForwardingTTL is passed and NodeRole != InnerRingNode. ErrIncorrectTTL = internal.Error("incorrect ttl") ) // SetVersion sets protocol version to ResponseMetaHeader. func (m *ResponseMetaHeader) SetVersion(v uint32) { m.Version = v } // SetEpoch sets Epoch to ResponseMetaHeader. func (m *ResponseMetaHeader) SetEpoch(v uint64) { m.Epoch = v } // SetVersion sets protocol version to RequestMetaHeader. func (m *RequestMetaHeader) SetVersion(v uint32) { m.Version = v } // SetTTL sets TTL to RequestMetaHeader. func (m *RequestMetaHeader) SetTTL(v uint32) { m.TTL = v } // SetEpoch sets Epoch to RequestMetaHeader. func (m *RequestMetaHeader) SetEpoch(v uint64) { m.Epoch = v } // SetRaw is a Raw field setter. func (m *RequestMetaHeader) SetRaw(raw bool) { m.Raw = raw } // ResetMeta returns current value and sets RequestMetaHeader to empty value. func (m *RequestMetaHeader) ResetMeta() RequestMetaHeader { cp := *m m.Reset() return cp } // RestoreMeta sets current RequestMetaHeader to passed value. func (m *RequestMetaHeader) RestoreMeta(v RequestMetaHeader) { *m = v } // IRNonForwarding condition that allows NonForwardingTTL only for IR func IRNonForwarding(role NodeRole) TTLCondition { return func(ttl uint32) error { if ttl == NonForwardingTTL && role != InnerRingNode { return ErrIncorrectTTL } return nil } } // ProcessRequestTTL validates and update ttl requests. func ProcessRequestTTL(req MetaHeader, cond ...TTLCondition) error { ttl := req.GetTTL() if ttl == ZeroTTL { return status.New(codes.InvalidArgument, ErrZeroTTL.Error()).Err() } for i := range cond { if cond[i] == nil { continue } // check specific condition: if err := cond[i](ttl); err != nil { if st, ok := status.FromError(errors.Cause(err)); ok { return st.Err() } return status.New(codes.InvalidArgument, err.Error()).Err() } } req.SetTTL(ttl - 1) return nil }