v.io: v.io/v23/flow/message Index | Files

package message

import "v.io/v23/flow/message"

Index

Package Files

errors.go message.go

Constants

const (
    // CloseFlag, when set on a Data message, indicates that the flow
    // should be closed after the payload for that message has been
    // processed.
    CloseFlag = 1 << iota
    // DisableEncryptionFlag, when set on a Data message, causes Append
    // and Read to behave specially.  During Append everything but the
    // Payload is serialized normally, but the Payload is left for the
    // caller to deal with.  Typically the caller will encrypt the
    // serialized result and send the unencrypted bytes as a raw follow
    // on message.  Read will expect to not find a payload, and the
    // caller will typically attach it by examining the next message on
    // the Conn.
    DisableEncryptionFlag
    // SideChannelFlag, when set on a OpenFlow message, marks the Flow
    // as a side channel. This means that the flow will not be counted
    // towards the "idleness" of the underlying connection.
    SideChannelFlag
)

data flags.

Variables

var (
    ErrInvalidMsg         = verror.NewID("InvalidMsg")
    ErrInvalidSetupOption = verror.NewID("InvalidSetupOption")
    ErrUnknownMsg         = verror.NewID("UnknownMsg")
    ErrMissingBlessings   = verror.NewID("MissingBlessings")
)

func Append Uses

func Append(ctx *context.T, m Message, to []byte) ([]byte, error)

Append serializes the message m and appends it to the given byte slice. The resulting slice is returned, as well as any error that occurs during serialization.

func FlowID Uses

func FlowID(m interface{}) uint64

FlowID returns the id of the flow this message is associated with for message types that are bound to a flow, zero otherwise.

func NewErrInvalidMsg Uses

func NewErrInvalidMsg(ctx *context.T, typ byte, size uint64, field uint64, err error) error

NewErrInvalidMsg creates an instance ErrInvalidMsg with the specified parameters which can be access by ParseErrInvalidMessage.

func ParseErrInvalidMessage Uses

func ParseErrInvalidMessage(err error) (typ byte, size uint64, field uint64, ok bool)

ParseErrInvalidMessage cracks open the parameter list created by NewErrInvalidMsg with appropriate checking. ok will be false if all of the error parameters are not located.

type AckLameDuck Uses

type AckLameDuck struct{}

AckLameDuck is sent in response to an EnterLameDuck message. After this message is received no more OpenFlow messages should arrive.

type Auth Uses

type Auth struct {
    BlessingsKey, DischargeKey uint64
    ChannelBinding             security.Signature
}

auth is used to complete the auth handshake.

type Data Uses

type Data struct {
    ID      uint64
    Flags   uint64
    Payload [][]byte
}

Data carries encrypted data for a specific flow.

func (*Data) String Uses

func (m *Data) String() string

type EnterLameDuck Uses

type EnterLameDuck struct{}

EnterLameDuck is sent as notification that the sender is entering lameduck mode. The receiver should stop opening new flows on this connection and respond with an AckLameDuck message.

type HealthCheckRequest Uses

type HealthCheckRequest struct{}

HealthCheckRequest is periodically sent to test the health of a channel.

type HealthCheckResponse Uses

type HealthCheckResponse struct{}

HealthCheckResponse messages are sent in response to HealthCheckRequest messages.

type Message Uses

type Message interface {
    // contains filtered or unexported methods
}

Message is implemented by all low-level messages defined by this package.

func Read Uses

func Read(ctx *context.T, from []byte) (Message, error)

Read reads a message contained in the byte slice 'from'.

type MultiProxyRequest Uses

type MultiProxyRequest struct{}

MultiProxyRequest is sent when a proxy wants to accept connections from another proxy.

type OpenFlow Uses

type OpenFlow struct {
    ID                         uint64
    InitialCounters            uint64
    BlessingsKey, DischargeKey uint64
    Flags                      uint64
    Payload                    [][]byte
}

OpenFlow is sent at the beginning of every new flow, it optionally contains payload.

func (*OpenFlow) String Uses

func (m *OpenFlow) String() string

type ProxyErrorResponse Uses

type ProxyErrorResponse struct {
    Error string
}

ProxyErrorResponse is send by a proxy in response to a ProxyServerRequest or MultiProxyRequest if the proxy encountered an error while responding to the request. It should be sent in lieu of a ProxyResponse.

func (*ProxyErrorResponse) String Uses

func (m *ProxyErrorResponse) String() string

type ProxyResponse Uses

type ProxyResponse struct {
    Endpoints []naming.Endpoint
}

ProxyResponse is sent by a proxy in response to a ProxyServerRequest or MultiProxyRequest. It notifies the server of the endpoints it should publish. Or, it notifies a requesting proxy of the endpoints it accepts connections from.

func (*ProxyResponse) String Uses

func (m *ProxyResponse) String() string

type ProxyServerRequest Uses

type ProxyServerRequest struct{}

ProxyServerRequest is sent when a server wants to listen through a proxy.

type Release Uses

type Release struct {
    Counters map[uint64]uint64
}

Release is sent as flows are read from locally. The counters inform remote writers that there is local buffer space available.

type Setup Uses

type Setup struct {
    Versions           version.RPCVersionRange
    PeerNaClPublicKey  *[32]byte
    PeerRemoteEndpoint naming.Endpoint
    PeerLocalEndpoint  naming.Endpoint
    Mtu                uint64
    SharedTokens       uint64
    // contains filtered or unexported fields
}

Setup is the first message over the wire. It negotiates protocol version and encryption options for connection. New fields to Setup must be added in order of creation. i.e. the order of the fields should not be changed.

func (*Setup) String Uses

func (m *Setup) String() string

type TearDown Uses

type TearDown struct {
    Message string
}

TearDown is sent over the wire before a connection is closed.

func (*TearDown) String Uses

func (m *TearDown) String() string

Package message imports 8 packages (graph) and is imported by 15 packages. Updated 2020-10-29. Refresh now. Tools for package owners.