conn

package
v0.0.0-...-3dadef2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 11, 2016 License: BSD-3-Clause Imports: 25 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	DefaultBytesBufferedPerFlow = 1 << 20
)

Variables

View Source 
var (
	ErrMissingSetupOption       = verror.Register("v.io/x/ref/runtime/internal/flow/conn.MissingSetupOption", verror.NoRetry, "{1:}{2:} missing required setup option{:3}.")
	ErrUnexpectedMsg            = verror.Register("v.io/x/ref/runtime/internal/flow/conn.UnexpectedMsg", verror.NoRetry, "{1:}{2:} unexpected message type{:3}.")
	ErrConnectionClosed         = verror.Register("v.io/x/ref/runtime/internal/flow/conn.ConnectionClosed", verror.NoRetry, "{1:}{2:} connection closed.")
	ErrRemoteError              = verror.Register("v.io/x/ref/runtime/internal/flow/conn.RemoteError", verror.NoRetry, "{1:}{2:} remote end received err{:3}.")
	ErrSend                     = verror.Register("v.io/x/ref/runtime/internal/flow/conn.Send", verror.NoRetry, "{1:}{2:} failure sending {3} message to {4}{:5}.")
	ErrRecv                     = verror.Register("v.io/x/ref/runtime/internal/flow/conn.Recv", verror.NoRetry, "{1:}{2:} error reading from {3}{:4}")
	ErrCounterOverflow          = verror.Register("v.io/x/ref/runtime/internal/flow/conn.CounterOverflow", verror.NoRetry, "{1:}{2:} A remote process has sent more data than allowed.")
	ErrBlessingsFlowClosed      = verror.Register("v.io/x/ref/runtime/internal/flow/conn.BlessingsFlowClosed", verror.NoRetry, "{1:}{2:} The blessings flow was closed with error{:3}.")
	ErrInvalidChannelBinding    = verror.Register("v.io/x/ref/runtime/internal/flow/conn.InvalidChannelBinding", verror.NoRetry, "{1:}{2:} The channel binding was invalid.")
	ErrNoPublicKey              = verror.Register("v.io/x/ref/runtime/internal/flow/conn.NoPublicKey", verror.NoRetry, "{1:}{2:} No public key was received by the remote end.")
	ErrDialingNonServer         = verror.Register("v.io/x/ref/runtime/internal/flow/conn.DialingNonServer", verror.NoRetry, "{1:}{2:} You are attempting to dial on a connection with no remote server: {:3}.")
	ErrAcceptorBlessingsMissing = verror.Register("v.io/x/ref/runtime/internal/flow/conn.AcceptorBlessingsMissing", verror.NoRetry, "{1:}{2:} The acceptor did not send blessings.")
	ErrDialerBlessingsMissing   = verror.Register("v.io/x/ref/runtime/internal/flow/conn.DialerBlessingsMissing", verror.NoRetry, "{1:}{2:} The dialer did not send blessings.")
	ErrBlessingsNotBound        = verror.Register("v.io/x/ref/runtime/internal/flow/conn.BlessingsNotBound", verror.NoRetry, "{1:}{2:} blessings not bound to connection remote public key")
	ErrInvalidPeerFlow          = verror.Register("v.io/x/ref/runtime/internal/flow/conn.InvalidPeerFlow", verror.NoRetry, "{1:}{2:} peer has chosen flow id from local domain.")
	ErrChannelTimeout           = verror.Register("v.io/x/ref/runtime/internal/flow/conn.ChannelTimeout", verror.NoRetry, "{1:}{2:} the channel has become unresponsive.")
	ErrCannotDecryptBlessings   = verror.Register("v.io/x/ref/runtime/internal/flow/conn.CannotDecryptBlessings", verror.NoRetry, "{1:}{2:} cannot decrypt the encrypted blessings sent by peer{:3}")
	ErrCannotDecryptDischarges  = verror.Register("v.io/x/ref/runtime/internal/flow/conn.CannotDecryptDischarges", verror.NoRetry, "{1:}{2:} cannot decrypt the encrypted discharges sent by peer{:3}")
	ErrCannotEncryptBlessings   = verror.Register("v.io/x/ref/runtime/internal/flow/conn.CannotEncryptBlessings", verror.NoRetry, "{1:}{2:} cannot encyrpt blessings for peer {3}{:4}")
	ErrCannotEncryptDischarges  = verror.Register("v.io/x/ref/runtime/internal/flow/conn.CannotEncryptDischarges", verror.NoRetry, "{1:}{2:} cannot encrypt discharges for peers {3}{:4}")
	ErrNoCrypter                = verror.Register("v.io/x/ref/runtime/internal/flow/conn.NoCrypter", verror.NoRetry, "{1:}{2:} no blessings-based crypter available")
	ErrNoPrivateKey             = verror.Register("v.io/x/ref/runtime/internal/flow/conn.NoPrivateKey", verror.NoRetry, "{1:}{2:} no blessings private key available for decryption")
	ErrIdleConnKilled           = verror.Register("v.io/x/ref/runtime/internal/flow/conn.IdleConnKilled", verror.NoRetry, "{1:}{2:} Connection killed because idle expiry was reached.")
)

Functions

func NewErrAcceptorBlessingsMissing 

func NewErrAcceptorBlessingsMissing(ctx *context.T) error

NewErrAcceptorBlessingsMissing returns an error with the ErrAcceptorBlessingsMissing ID.

func NewErrBlessingsFlowClosed 

func NewErrBlessingsFlowClosed(ctx *context.T, err error) error

NewErrBlessingsFlowClosed returns an error with the ErrBlessingsFlowClosed ID.

func NewErrBlessingsNotBound 

func NewErrBlessingsNotBound(ctx *context.T) error

NewErrBlessingsNotBound returns an error with the ErrBlessingsNotBound ID.

func NewErrCannotDecryptBlessings 

func NewErrCannotDecryptBlessings(ctx *context.T, err error) error

NewErrCannotDecryptBlessings returns an error with the ErrCannotDecryptBlessings ID.

func NewErrCannotDecryptDischarges 

func NewErrCannotDecryptDischarges(ctx *context.T, err error) error

NewErrCannotDecryptDischarges returns an error with the ErrCannotDecryptDischarges ID.

func NewErrCannotEncryptBlessings 

func NewErrCannotEncryptBlessings(ctx *context.T, peers []security.BlessingPattern, err error) error

NewErrCannotEncryptBlessings returns an error with the ErrCannotEncryptBlessings ID.

func NewErrCannotEncryptDischarges 

func NewErrCannotEncryptDischarges(ctx *context.T, peers []security.BlessingPattern, err error) error

NewErrCannotEncryptDischarges returns an error with the ErrCannotEncryptDischarges ID.

func NewErrChannelTimeout 

func NewErrChannelTimeout(ctx *context.T) error

NewErrChannelTimeout returns an error with the ErrChannelTimeout ID.

func NewErrConnectionClosed 

func NewErrConnectionClosed(ctx *context.T) error

NewErrConnectionClosed returns an error with the ErrConnectionClosed ID.

func NewErrCounterOverflow 

func NewErrCounterOverflow(ctx *context.T) error

NewErrCounterOverflow returns an error with the ErrCounterOverflow ID.

func NewErrDialerBlessingsMissing 

func NewErrDialerBlessingsMissing(ctx *context.T) error

NewErrDialerBlessingsMissing returns an error with the ErrDialerBlessingsMissing ID.

func NewErrDialingNonServer 

func NewErrDialingNonServer(ctx *context.T, ep string) error

NewErrDialingNonServer returns an error with the ErrDialingNonServer ID.

func NewErrIdleConnKilled 

func NewErrIdleConnKilled(ctx *context.T) error

NewErrIdleConnKilled returns an error with the ErrIdleConnKilled ID.

func NewErrInvalidChannelBinding 

func NewErrInvalidChannelBinding(ctx *context.T) error

NewErrInvalidChannelBinding returns an error with the ErrInvalidChannelBinding ID.

func NewErrInvalidPeerFlow 

func NewErrInvalidPeerFlow(ctx *context.T) error

NewErrInvalidPeerFlow returns an error with the ErrInvalidPeerFlow ID.

func NewErrMissingSetupOption 

func NewErrMissingSetupOption(ctx *context.T, option string) error

NewErrMissingSetupOption returns an error with the ErrMissingSetupOption ID.

func NewErrNoCrypter 

func NewErrNoCrypter(ctx *context.T) error

NewErrNoCrypter returns an error with the ErrNoCrypter ID.

func NewErrNoPrivateKey 

func NewErrNoPrivateKey(ctx *context.T) error

NewErrNoPrivateKey returns an error with the ErrNoPrivateKey ID.

func NewErrNoPublicKey 

func NewErrNoPublicKey(ctx *context.T) error

NewErrNoPublicKey returns an error with the ErrNoPublicKey ID.

func NewErrRecv 

func NewErrRecv(ctx *context.T, src string, err error) error

NewErrRecv returns an error with the ErrRecv ID.

func NewErrRemoteError 

func NewErrRemoteError(ctx *context.T, msg string) error

NewErrRemoteError returns an error with the ErrRemoteError ID.

func NewErrSend 

func NewErrSend(ctx *context.T, typ string, dest string, err error) error

NewErrSend returns an error with the ErrSend ID.

func NewErrUnexpectedMsg 

func NewErrUnexpectedMsg(ctx *context.T, typ string) error

NewErrUnexpectedMsg returns an error with the ErrUnexpectedMsg ID.

func VDLReadBlessingsFlowMessage 

func VDLReadBlessingsFlowMessage(dec vdl.Decoder, x *BlessingsFlowMessage) error

Types

type Blessings 

type Blessings struct {
	Blessings security.Blessings
	BKey      uint64
}

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) VDLIsZero 

func (x Blessings) VDLIsZero() bool

func (*Blessings) VDLRead 

func (x *Blessings) VDLRead(dec vdl.Decoder) error

func (Blessings) VDLReflect 

func (Blessings) VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/runtime/internal/flow/conn.Blessings"`
})

func (Blessings) VDLWrite 

func (x Blessings) VDLWrite(enc vdl.Encoder) error

type BlessingsFlowMessage 

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(__BlessingsFlowMessageReflect)
	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.

type BlessingsFlowMessageBlessings 

type BlessingsFlowMessageBlessings struct{ Value Blessings }

BlessingsFlowMessageBlessings represents field Blessings of the BlessingsFlowMessage union type.

func (BlessingsFlowMessageBlessings) Index 

func (x BlessingsFlowMessageBlessings) Index() int

func (BlessingsFlowMessageBlessings) Interface 

func (x BlessingsFlowMessageBlessings) Interface() interface{}

func (BlessingsFlowMessageBlessings) Name 

func (x BlessingsFlowMessageBlessings) Name() string

func (BlessingsFlowMessageBlessings) VDLIsZero 

func (x BlessingsFlowMessageBlessings) VDLIsZero() bool

func (BlessingsFlowMessageBlessings) VDLReflect 

func (x BlessingsFlowMessageBlessings) VDLReflect(__BlessingsFlowMessageReflect)

func (BlessingsFlowMessageBlessings) VDLWrite 

func (x BlessingsFlowMessageBlessings) VDLWrite(enc vdl.Encoder) error

type BlessingsFlowMessageDischarges 

type BlessingsFlowMessageDischarges struct{ Value Discharges }

BlessingsFlowMessageDischarges represents field Discharges of the BlessingsFlowMessage union type.

func (BlessingsFlowMessageDischarges) Index 

func (x BlessingsFlowMessageDischarges) Index() int

func (BlessingsFlowMessageDischarges) Interface 

func (x BlessingsFlowMessageDischarges) Interface() interface{}

func (BlessingsFlowMessageDischarges) Name 

func (x BlessingsFlowMessageDischarges) Name() string

func (BlessingsFlowMessageDischarges) VDLIsZero 

func (x BlessingsFlowMessageDischarges) VDLIsZero() bool

func (BlessingsFlowMessageDischarges) VDLReflect 

func (x BlessingsFlowMessageDischarges) VDLReflect(__BlessingsFlowMessageReflect)

func (BlessingsFlowMessageDischarges) VDLWrite 

func (x BlessingsFlowMessageDischarges) VDLWrite(enc vdl.Encoder) error

type BlessingsFlowMessageEncryptedBlessings 

type BlessingsFlowMessageEncryptedBlessings struct{ Value EncryptedBlessings }

BlessingsFlowMessageEncryptedBlessings represents field EncryptedBlessings of the BlessingsFlowMessage union type.

func (BlessingsFlowMessageEncryptedBlessings) Index 

func (x BlessingsFlowMessageEncryptedBlessings) Index() int

func (BlessingsFlowMessageEncryptedBlessings) Interface 

func (x BlessingsFlowMessageEncryptedBlessings) Interface() interface{}

func (BlessingsFlowMessageEncryptedBlessings) Name 

func (x BlessingsFlowMessageEncryptedBlessings) Name() string

func (BlessingsFlowMessageEncryptedBlessings) VDLIsZero 

func (x BlessingsFlowMessageEncryptedBlessings) VDLIsZero() bool

func (BlessingsFlowMessageEncryptedBlessings) VDLReflect 

func (x BlessingsFlowMessageEncryptedBlessings) VDLReflect(__BlessingsFlowMessageReflect)

func (BlessingsFlowMessageEncryptedBlessings) VDLWrite 

func (x BlessingsFlowMessageEncryptedBlessings) VDLWrite(enc vdl.Encoder) error

type BlessingsFlowMessageEncryptedDischarges 

type BlessingsFlowMessageEncryptedDischarges struct{ Value EncryptedDischarges }

BlessingsFlowMessageEncryptedDischarges represents field EncryptedDischarges of the BlessingsFlowMessage union type.

func (BlessingsFlowMessageEncryptedDischarges) Index 

func (x BlessingsFlowMessageEncryptedDischarges) Index() int

func (BlessingsFlowMessageEncryptedDischarges) Interface 

func (x BlessingsFlowMessageEncryptedDischarges) Interface() interface{}

func (BlessingsFlowMessageEncryptedDischarges) Name 

func (x BlessingsFlowMessageEncryptedDischarges) Name() string

func (BlessingsFlowMessageEncryptedDischarges) VDLIsZero 

func (x BlessingsFlowMessageEncryptedDischarges) VDLIsZero() bool

func (BlessingsFlowMessageEncryptedDischarges) VDLReflect 

func (x BlessingsFlowMessageEncryptedDischarges) VDLReflect(__BlessingsFlowMessageReflect)

func (BlessingsFlowMessageEncryptedDischarges) VDLWrite 

func (x BlessingsFlowMessageEncryptedDischarges) VDLWrite(enc vdl.Encoder) error

type BufferingFlow 

type BufferingFlow struct {
	flow.Flow
	// contains filtered or unexported fields
}

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 NewBufferingFlow 

func NewBufferingFlow(ctx *context.T, flw flow.Flow) *BufferingFlow

func (*BufferingFlow) Close 

func (b *BufferingFlow) Close() error

Close flushes the already written data and then closes the underlying Flow.

func (*BufferingFlow) Flush 

func (b *BufferingFlow) Flush() (err error)

Flush writes all buffered data to the underlying Flow.

func (*BufferingFlow) Write 

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 (*BufferingFlow) WriteMsg 

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 (*BufferingFlow) WriteMsgAndClose 

func (b *BufferingFlow) WriteMsgAndClose(data ...[]byte) (int, error)

WriteMsgAndClose writes all buffered data and closes the underlying Flow.

type Conn 

type Conn struct {
	// contains filtered or unexported fields
}

A Conn acts as a multiplexing encrypted channel that can host Flows.

func NewAccepted 

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.

func NewDialed 

func NewDialed(
	ctx *context.T,
	conn flow.MsgReadWriteCloser,
	local, remote naming.Endpoint,
	versions version.RPCVersionRange,
	auth flow.PeerAuthorizer,
	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.

func (*Conn) Close 

func (c *Conn) Close(ctx *context.T, err error)

Close shuts down a conn.

func (*Conn) CloseIfIdle 

func (c *Conn) CloseIfIdle(ctx *context.T, idleExpiry time.Duration) bool

CloseIfIdle closes the connection if the conn has been idle for idleExpiry, returning true if it closed it.

func (*Conn) Closed 

func (c *Conn) Closed() <-chan struct{}

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 (*Conn) CommonVersion 

func (c *Conn) CommonVersion() version.RPCVersion

CommonVersion returns the RPCVersion negotiated between the local and remote endpoints.

func (*Conn) DebugString 

func (c *Conn) DebugString() string

func (*Conn) Dial 

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.

func (*Conn) EnterLameDuck 

func (c *Conn) EnterLameDuck(ctx *context.T) chan struct{}

EnterLameDuck enters lame duck mode, the returned channel will be closed when the remote end has ack'd or the Conn is closed.

func (*Conn) HasActiveFlows 

func (c *Conn) HasActiveFlows() bool

func (*Conn) IsEncapsulated 

func (c *Conn) IsEncapsulated() bool

func (*Conn) IsIdle 

func (c *Conn) IsIdle(ctx *context.T, idleExpiry time.Duration) bool

func (*Conn) LastUsed 

func (c *Conn) LastUsed() time.Time

LastUsed returns the time at which the Conn had bytes read or written on it.

func (*Conn) LocalBlessings 

func (c *Conn) LocalBlessings() security.Blessings

LocalBlessings returns the local blessings.

func (*Conn) LocalDischarges 

func (c *Conn) LocalDischarges() map[string]security.Discharge

LocalDischarges fetches the most recently sent discharges for the local ends blessings.

func (*Conn) LocalEndpoint 

func (c *Conn) LocalEndpoint() naming.Endpoint

LocalEndpoint returns the local vanadium Endpoint

func (*Conn) MTU 

func (c *Conn) MTU() uint64

MTU Returns the maximum transimission unit for the connection in bytes.

func (*Conn) MatchesRID 

func (c *Conn) MatchesRID(ep naming.Endpoint) bool

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).

func (*Conn) RTT 

func (c *Conn) RTT() time.Duration

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.

func (*Conn) RemoteBlessings 

func (c *Conn) RemoteBlessings() security.Blessings

RemoteBlessings returns the remote blessings.

func (*Conn) RemoteDischarges 

func (c *Conn) RemoteDischarges() map[string]security.Discharge

RemoteDischarges fetches the most recently received discharges for the remote ends blessings.

func (*Conn) RemoteEndpoint 

func (c *Conn) RemoteEndpoint() naming.Endpoint

RemoteEndpoint returns the remote vanadium Endpoint

func (*Conn) RemoteLameDuck 

func (c *Conn) RemoteLameDuck() bool

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.

func (*Conn) Status 

func (c *Conn) Status() Status

type Discharges 

type Discharges struct {
	Discharges []security.Discharge
	DKey       uint64
	BKey       uint64
}

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 (Discharges) VDLIsZero 

func (x Discharges) VDLIsZero() bool

func (*Discharges) VDLRead 

func (x *Discharges) VDLRead(dec vdl.Decoder) error

func (Discharges) VDLReflect 

func (Discharges) VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/runtime/internal/flow/conn.Discharges"`
})

func (Discharges) VDLWrite 

func (x Discharges) VDLWrite(enc vdl.Encoder) error

type EncryptedBlessings 

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 (EncryptedBlessings) VDLIsZero 

func (x EncryptedBlessings) VDLIsZero() bool

func (*EncryptedBlessings) VDLRead 

func (x *EncryptedBlessings) VDLRead(dec vdl.Decoder) error

func (EncryptedBlessings) VDLReflect 

func (EncryptedBlessings) VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/runtime/internal/flow/conn.EncryptedBlessings"`
})

func (EncryptedBlessings) VDLWrite 

func (x EncryptedBlessings) VDLWrite(enc vdl.Encoder) error

type EncryptedDischarges 

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 (EncryptedDischarges) VDLIsZero 

func (x EncryptedDischarges) VDLIsZero() bool

func (*EncryptedDischarges) VDLRead 

func (x *EncryptedDischarges) VDLRead(dec vdl.Decoder) error

func (EncryptedDischarges) VDLReflect 

func (EncryptedDischarges) VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/runtime/internal/flow/conn.EncryptedDischarges"`
})

func (EncryptedDischarges) VDLWrite 

func (x EncryptedDischarges) VDLWrite(enc vdl.Encoder) error

type FlowHandler 

type FlowHandler interface {
	// HandleFlow processes an accepted flow.
	HandleFlow(flow.Flow) error
}

A FlowHandler processes accepted flows.

type MTUer 

type MTUer interface {
	MTU() uint64
}

type Status 

type Status int
const (
	Active Status = iota
	EnteringLameDuck
	LameDuckAcknowledged
	Closing
	Closed
)

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.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.