import "v.io/x/ref/runtime/internal/flow/conn"
nolint:golint
auth.go bufferingflow.go conn.go conn.vdl.go errors.go flow.go ibe.go message.go readq.go
const (
DefaultBytesBufferedPerFlow = 1 << 20
)var (
ErrMissingSetupOption = verror.NewID("MissingSetupOption")
ErrUnexpectedMsg = verror.NewID("UnexpectedMsg")
ErrConnectionClosed = verror.NewID("ConnectionClosed")
ErrRemoteError = verror.NewID("RemoteError")
ErrSend = verror.NewID("Send")
ErrRecv = verror.NewID("Recv")
ErrCounterOverflow = verror.NewID("CounterOverflow")
ErrBlessingsFlowClosed = verror.NewID("BlessingsFlowClosed")
ErrInvalidChannelBinding = verror.NewID("InvalidChannelBinding")
ErrNoPublicKey = verror.NewID("NoPublicKey")
ErrDialingNonServer = verror.NewID("DialingNonServer")
ErrAcceptorBlessingsMissing = verror.NewID("AcceptorBlessingsMissing")
ErrDialerBlessingsMissing = verror.NewID("DialerBlessingsMissing")
ErrBlessingsNotBound = verror.NewID("BlessingsNotBound")
ErrInvalidPeerFlow = verror.NewID("InvalidPeerFlow")
ErrChannelTimeout = verror.NewID("ChannelTimeout")
ErrCannotDecryptBlessings = verror.NewID("CannotDecryptBlessings")
ErrCannotDecryptDischarges = verror.NewID("CannotDecryptDischarges")
ErrCannotEncryptBlessings = verror.NewID("CannotEncryptBlessings")
ErrCannotEncryptDischarges = verror.NewID("CannotEncryptDischarges")
ErrNoCrypter = verror.NewID("NoCrypter")
ErrNoPrivateKey = verror.NewID("NoPrivateKey")
ErrIdleConnKilled = verror.NewID("IdleConnKilled")
)These were previously defined in errors.vdl using the ID values below rather than the more conventional Err<Name>.
func VDLReadBlessingsFlowMessage(dec vdl.Decoder, x *BlessingsFlowMessage) error
Blessings is used to transport blessings between the two ends of a Conn. Since blessings can be large, we try not to send them more than once by associating them with an integer key (BKey). Thereafter we refer to them by their key.
func (Blessings) VDLReflect(struct { Name string `vdl:"v.io/x/ref/runtime/internal/flow/conn.Blessings"` })
type BlessingsFlowMessage interface {
// Index returns the field index.
Index() int
// Interface returns the field value as an interface.
Interface() interface{}
// Name returns the field name.
Name() string
// VDLReflect describes the BlessingsFlowMessage union type.
VDLReflect(vdlBlessingsFlowMessageReflect)
VDLIsZero() bool
VDLWrite(vdl.Encoder) error
}BlessingsFlowMessage represents any single field of the BlessingsFlowMessage union type.
BlessingsFlowMessage is used to send either a Blessings, Discharges, EncryptedBlessings or EncryptedDischarges object over the wire.
BlessingsFlowMessageBlessings represents field Blessings of the BlessingsFlowMessage union type.
func (x BlessingsFlowMessageBlessings) Index() int
func (x BlessingsFlowMessageBlessings) Interface() interface{}
func (x BlessingsFlowMessageBlessings) Name() string
func (x BlessingsFlowMessageBlessings) VDLIsZero() bool
func (x BlessingsFlowMessageBlessings) VDLReflect(vdlBlessingsFlowMessageReflect)
func (x BlessingsFlowMessageBlessings) VDLWrite(enc vdl.Encoder) error
type BlessingsFlowMessageDischarges struct{ Value Discharges }BlessingsFlowMessageDischarges represents field Discharges of the BlessingsFlowMessage union type.
func (x BlessingsFlowMessageDischarges) Index() int
func (x BlessingsFlowMessageDischarges) Interface() interface{}
func (x BlessingsFlowMessageDischarges) Name() string
func (x BlessingsFlowMessageDischarges) VDLIsZero() bool
func (x BlessingsFlowMessageDischarges) VDLReflect(vdlBlessingsFlowMessageReflect)
func (x BlessingsFlowMessageDischarges) VDLWrite(enc vdl.Encoder) error
type BlessingsFlowMessageEncryptedBlessings struct{ Value EncryptedBlessings }BlessingsFlowMessageEncryptedBlessings represents field EncryptedBlessings of the BlessingsFlowMessage union type.
func (x BlessingsFlowMessageEncryptedBlessings) Index() int
func (x BlessingsFlowMessageEncryptedBlessings) Interface() interface{}
func (x BlessingsFlowMessageEncryptedBlessings) Name() string
func (x BlessingsFlowMessageEncryptedBlessings) VDLIsZero() bool
func (x BlessingsFlowMessageEncryptedBlessings) VDLReflect(vdlBlessingsFlowMessageReflect)
func (x BlessingsFlowMessageEncryptedBlessings) VDLWrite(enc vdl.Encoder) error
type BlessingsFlowMessageEncryptedDischarges struct{ Value EncryptedDischarges }BlessingsFlowMessageEncryptedDischarges represents field EncryptedDischarges of the BlessingsFlowMessage union type.
func (x BlessingsFlowMessageEncryptedDischarges) Index() int
func (x BlessingsFlowMessageEncryptedDischarges) Interface() interface{}
func (x BlessingsFlowMessageEncryptedDischarges) Name() string
func (x BlessingsFlowMessageEncryptedDischarges) VDLIsZero() bool
func (x BlessingsFlowMessageEncryptedDischarges) VDLReflect(vdlBlessingsFlowMessageReflect)
func (x BlessingsFlowMessageEncryptedDischarges) VDLWrite(enc vdl.Encoder) error
BufferingFlow wraps a Flow and buffers all its writes. It only truly writes to the underlying flow when the buffered data exceeds the MTU of the underlying channel, or Flush, Close, or WriteMsgAndClose is called.
func (b *BufferingFlow) Close() error
Close flushes the already written data and then closes the underlying Flow.
func (b *BufferingFlow) Flush() (err error)
Flush writes all buffered data to the underlying Flow.
func (b *BufferingFlow) Write(data []byte) (int, error)
Write buffers data until the underlying channels MTU is reached at which point it calls Write on the wrapped Flow.
func (b *BufferingFlow) WriteMsg(data ...[]byte) (int, error)
WriteMsg buffers data until the underlying channels MTU is reached at which point it calls WriteMsg on the wrapped Flow.
func (b *BufferingFlow) WriteMsgAndClose(data ...[]byte) (int, error)
WriteMsgAndClose writes all buffered data and closes the underlying Flow.
type Conn struct {
// contains filtered or unexported fields
}A Conn acts as a multiplexing encrypted channel that can host Flows.
func NewAccepted(
ctx *context.T,
lAuthorizedPeers []security.BlessingPattern,
conn flow.MsgReadWriteCloser,
local naming.Endpoint,
versions version.RPCVersionRange,
handshakeTimeout time.Duration,
channelTimeout time.Duration,
handler FlowHandler) (*Conn, error)NewAccepted accepts a new Conn on the given conn.
NOTE: that the FlowHandler must be called asynchronously since it may
block until this function returns.
func NewDialed(
ctx *context.T,
conn flow.MsgReadWriteCloser,
local, remote naming.Endpoint,
versions version.RPCVersionRange,
auth flow.PeerAuthorizer,
proxy bool,
handshakeTimeout time.Duration,
channelTimeout time.Duration,
handler FlowHandler) (c *Conn, names []string, rejected []security.RejectedBlessing, err error)NewDialed dials a new Conn on the given conn. In the case when it is not dialing a proxy, it can return an error indicating that the context was canceled (verror.ErrCanceled) along with a handshake completes within the specified handshakeTimeout duration. Or put another way, NewDialed will always waut for at most handshakeTimeout duration to complete the handshake even if the context is canceled. The behaviour is different for a proxy connection, in which case a cancelation is immediate and no attempt is made to establish the connection.
Close shuts down a conn.
CloseIfIdle closes the connection if the conn has been idle for idleExpiry, returning true if it closed it.
Closed returns a channel that will be closed after the Conn is shutdown. After this channel is closed it is guaranteed that all Dial calls will fail with an error and no more flows will be sent to the FlowHandler.
func (c *Conn) CommonVersion() version.RPCVersion
CommonVersion returns the RPCVersion negotiated between the local and remote endpoints.
func (c *Conn) Dial(ctx *context.T, blessings security.Blessings, discharges map[string]security.Discharge, remote naming.Endpoint, channelTimeout time.Duration, sideChannel bool) (flow.Flow, error)
Dial dials a new flow on the Conn.
EnterLameDuck enters lame duck mode, the returned channel will be closed when the remote end has ack'd or the Conn is closed.
LastUsed returns the time at which the Conn had bytes read or written on it.
LocalBlessings returns the local blessings.
LocalDischarges fetches the most recently sent discharges for the local ends blessings.
LocalEndpoint returns the local vanadium Endpoint
MTU Returns the maximum transimission unit for the connection in bytes.
MatchesRID returns true if the given endpoint matches the routing ID of the remote server. Also returns true if the given ep has the null routing id (in which case it is assumed that any connected server must be the target since nothing has been specified).
RTT returns the round trip time of a message to the remote end. Note the initial estimate of the RTT from the accepted side of a connection my be long because we don't fully factor out certificate verification time. The RTT will be updated with the receipt of every healthCheckResponse, so this overestimate doesn't remain for long when the channel timeout is low.
RemoteBlessings returns the remote blessings.
RemoteDischarges fetches the most recently received discharges for the remote ends blessings.
RemoteEndpoint returns the remote vanadium Endpoint
RemoteLameDuck returns true if the other end of the connection has announced that it is in lame duck mode indicating that new flows should not be dialed on this conn.
Discharges is used to transport discharges between the two ends of a Conn. Since discharges can be large, we try not to send them more than once by associating them with an integer key (DKey). Thereafter we refer to them by their key. Discharges also contains the BKey of the blessings with which the discharges are associated with.
func (x Discharges) VDLIsZero() bool
func (x *Discharges) VDLRead(dec vdl.Decoder) error
func (Discharges) VDLReflect(struct { Name string `vdl:"v.io/x/ref/runtime/internal/flow/conn.Discharges"` })
func (x Discharges) VDLWrite(enc vdl.Encoder) error
type EncryptedBlessings struct {
Ciphertexts []bcrypter.WireCiphertext
BKey uint64
}EncryptedBlessings is used to transport encrypted blessings between the two ends of a Conn. The encryption is with respect to a set of blessing patterns that define the set of peers that are allowed to see the blessings. Since encrypted blessings can be large, we try not to send them more than once by associating them with an integer key (BKey). Thereafter we refer to them by their key.
func (x EncryptedBlessings) VDLIsZero() bool
func (x *EncryptedBlessings) VDLRead(dec vdl.Decoder) error
func (EncryptedBlessings) VDLReflect(struct { Name string `vdl:"v.io/x/ref/runtime/internal/flow/conn.EncryptedBlessings"` })
func (x EncryptedBlessings) VDLWrite(enc vdl.Encoder) error
type EncryptedDischarges struct {
Ciphertexts []bcrypter.WireCiphertext
DKey uint64
BKey uint64
}EncryptedDischarges is used to transport encrypted discharges between the two ends of a Conn. The encryption is with respect to a set of blessing patterns that define the set of peers that are allowed to see the discharges. Since discharges can be large, we try not to send them more than once by associating them with an integer key (DKey). Thereafter we refer to them by their key. EncryptedDischarges also contains the BKey of the blessings with which the plaintext discharges are associated with.
func (x EncryptedDischarges) VDLIsZero() bool
func (x *EncryptedDischarges) VDLRead(dec vdl.Decoder) error
func (EncryptedDischarges) VDLReflect(struct { Name string `vdl:"v.io/x/ref/runtime/internal/flow/conn.EncryptedDischarges"` })
func (x EncryptedDischarges) VDLWrite(enc vdl.Encoder) error
type FlowHandler interface {
// HandleFlow processes an accepted flow.
HandleFlow(flow.Flow) error
}A FlowHandler processes accepted flows.
Note that this is a progression of states that can only go in one direction. We use inequality operators to see how far along in the progression we are, so the order of these is important.
Package conn imports 26 packages (graph) and is imported by 10 packages. Updated 2020-10-22. Refresh now. Tools for package owners.