LegacyNotPrimaryErrMsg is the error message that older MongoDB servers (see SERVER-50412 for versions) return when a write operation is erroneously sent to a non-primary node.
const LegacyNotPrimaryErrMsg = "not master"
TestServerAPIVersion is the most recent, stable variant of options.ServerAPIVersion. Only to be used in testing.
const TestServerAPIVersion = "1"
var (
// UnknownTransactionCommitResult is an error label for unknown transaction commit results.
UnknownTransactionCommitResult = "UnknownTransactionCommitResult"
// TransientTransactionError is an error label for transient errors with transactions.
TransientTransactionError = "TransientTransactionError"
// NetworkError is an error label for network errors.
NetworkError = "NetworkError"
// RetryableWriteError is an error label for retryable write errors.
RetryableWriteError = "RetryableWriteError"
// NoWritesPerformed is an error label indicated that no writes were performed for an operation.
NoWritesPerformed = "NoWritesPerformed"
// ErrCursorNotFound is the cursor not found error for legacy find operations.
ErrCursorNotFound = errors.New("cursor not found")
// ErrUnacknowledgedWrite is returned from functions that have an unacknowledged
// write concern.
ErrUnacknowledgedWrite = errors.New("unacknowledged write")
// ErrUnsupportedStorageEngine is returned when a retryable write is attempted against a server
// that uses a storage engine that does not support retryable writes
ErrUnsupportedStorageEngine = errors.New("this MongoDB deployment does not support retryable writes. Please add retryWrites=false to your connection string")
// ErrDeadlineWouldBeExceeded is returned when a Timeout set on an operation
// would be exceeded if the operation were sent to the server. It wraps
// context.DeadlineExceeded.
ErrDeadlineWouldBeExceeded = fmt.Errorf(
"operation not sent to server, as Timeout would be exceeded: %w",
context.DeadlineExceeded)
// ErrNegativeMaxTime is returned when MaxTime on an operation is a negative value.
ErrNegativeMaxTime = errors.New("a negative value was provided for MaxTime on an operation")
)
var (
// ErrNoDocCommandResponse occurs when the server indicated a response existed, but none was found.
ErrNoDocCommandResponse = errors.New("command returned no documents")
// ErrMultiDocCommandResponse occurs when the server sent multiple documents in response to a command.
ErrMultiDocCommandResponse = errors.New("command returned multiple documents")
// ErrReplyDocumentMismatch occurs when the number of documents returned in an OP_QUERY does not match the numberReturned field.
ErrReplyDocumentMismatch = errors.New("number of documents returned does not match numberReturned field")
// ErrNonPrimaryReadPref is returned when a read is attempted in a transaction with a non-primary read preference.
ErrNonPrimaryReadPref = errors.New("read preference in a transaction must be primary")
)
ErrDocumentTooLarge occurs when a document that is larger than the maximum size accepted by a server is passed to an insert command.
var ErrDocumentTooLarge = errors.New("an inserted document is too large")
ErrNoCursor is returned by NewCursorResponse when the database response does not contain a cursor.
var ErrNoCursor = errors.New("database response does not contain a cursor")
func CompressPayload(in []byte, opts CompressionOpts) ([]byte, error)
CompressPayload takes a byte slice and compresses it according to the options passed
func DecompressPayload(in []byte, opts CompressionOpts) ([]byte, error)
DecompressPayload takes a byte slice that has been compressed and undoes it according to the options passed
func ExtractErrorFromServerResponse(ctx context.Context, doc bsoncore.Document) error
ExtractErrorFromServerResponse extracts an error from a server response bsoncore.Document if there is one. Also used in testing for SDAM.
BatchCursor is a batch implementation of a cursor. It returns documents in entire batches instead of one at a time. An individual document cursor can be built on top of this batch cursor.
type BatchCursor struct {
// contains filtered or unexported fields
}
func NewBatchCursor(cr CursorResponse, clientSession *session.Client, clock *session.ClusterClock, opts CursorOptions) (*BatchCursor, error)
NewBatchCursor creates a new BatchCursor from the provided parameters.
func NewBatchCursorFromDocuments(documents []byte) *BatchCursor
NewBatchCursorFromDocuments returns a batch cursor with current batch set to a sequence-style DocumentSequence containing the provided documents.
func NewEmptyBatchCursor() *BatchCursor
NewEmptyBatchCursor returns a batch cursor that is empty.
func (bc *BatchCursor) Batch() *bsoncore.DocumentSequence
Batch will return a DocumentSequence for the current batch of documents. The returned DocumentSequence is only valid until the next call to Next or Close.
func (bc *BatchCursor) Close(ctx context.Context) error
Close closes this batch cursor.
func (bc *BatchCursor) Err() error
Err returns the latest error encountered.
func (bc *BatchCursor) ID() int64
ID returns the cursor ID for this batch cursor.
func (bc *BatchCursor) KillCursor(ctx context.Context) error
KillCursor kills cursor on server without closing batch cursor
func (bc *BatchCursor) Next(ctx context.Context) bool
Next indicates if there is another batch available. Returning false does not necessarily indicate that the cursor is closed. This method will return false when an empty batch is returned.
If Next returns true, there is a valid batch of documents available. If Next returns false, there is not a valid batch of documents available.
func (bc *BatchCursor) PostBatchResumeToken() bsoncore.Document
PostBatchResumeToken returns the latest seen post batch resume token.
func (bc *BatchCursor) Server() Server
Server returns the server for this cursor.
func (bc *BatchCursor) SetBatchSize(size int32)
SetBatchSize sets the batchSize for future getMore operations.
func (bc *BatchCursor) SetComment(comment interface{})
SetComment sets the comment for future getMore operations.
func (bc *BatchCursor) SetMaxTime(dur time.Duration)
SetMaxTime will set the maximum amount of time the server will allow the operations to execute. The server will error if this field is set but the cursor is not configured with awaitData=true.
The time.Duration value passed by this setter will be converted and rounded down to the nearest millisecond.
Batches contains the necessary information to batch split an operation. This is only used for write operations.
type Batches struct {
Identifier string
Documents []bsoncore.Document
Current []bsoncore.Document
Ordered *bool
}
func (b *Batches) AdvanceBatch(maxCount, targetBatchSize, maxDocSize int) error
AdvanceBatch splits the next batch using maxCount and targetBatchSize. This method will do nothing if the current batch has not been cleared. We do this so that when this is called during execute we can call it without first needing to check if we already have a batch, which makes the code simpler and makes retrying easier. The maxDocSize parameter is used to check that any one document is not too large. If the first document is bigger than targetBatchSize but smaller than maxDocSize, a batch of size 1 containing that document will be created.
func (b *Batches) ClearBatch()
ClearBatch clears the Current batch. This must be called before AdvanceBatch will advance to the next batch.
func (b *Batches) Valid() bool
Valid returns true if Batches contains both an identifier and the length of Documents is greater than zero.
CollectionInfoFn is a callback used to retrieve collection information.
type CollectionInfoFn func(ctx context.Context, db string, filter bsoncore.Document) (bsoncore.Document, error)
CompressionOpts holds settings for how to compress a payload
type CompressionOpts struct {
Compressor wiremessage.CompressorID
ZlibLevel int
ZstdLevel int
UncompressedSize int32
}
Compressor is an interface used to compress wire messages. If a Connection supports compression it should implement this interface as well. The CompressWireMessage method will be called during the execution of an operation if the wire message is allowed to be compressed.
type Compressor interface {
CompressWireMessage(src, dst []byte) ([]byte, error)
}
Connection represents a connection to a MongoDB server.
type Connection interface {
WriteWireMessage(context.Context, []byte) error
ReadWireMessage(ctx context.Context) ([]byte, error)
Description() description.Server
// Close closes any underlying connection and returns or frees any resources held by the
// connection. Close is idempotent and can be called multiple times, although subsequent calls
// to Close may return an error. A connection cannot be used after it is closed.
Close() error
ID() string
ServerConnectionID() *int64
DriverConnectionID() uint64 // TODO(GODRIVER-2824): change type to int64.
Address() address.Address
Stale() bool
}
Connector represents a type that can connect to a server.
type Connector interface {
Connect() error
}
Crypt is an interface implemented by types that can encrypt and decrypt instances of bsoncore.Document.
Users should rely on the driver's crypt type (used by default) for encryption and decryption unless they are perfectly confident in another implementation of Crypt.
type Crypt interface {
// Encrypt encrypts the given command.
Encrypt(ctx context.Context, db string, cmd bsoncore.Document) (bsoncore.Document, error)
// Decrypt decrypts the given command response.
Decrypt(ctx context.Context, cmdResponse bsoncore.Document) (bsoncore.Document, error)
// CreateDataKey creates a data key using the given KMS provider and options.
CreateDataKey(ctx context.Context, kmsProvider string, opts *options.DataKeyOptions) (bsoncore.Document, error)
// EncryptExplicit encrypts the given value with the given options.
EncryptExplicit(ctx context.Context, val bsoncore.Value, opts *options.ExplicitEncryptionOptions) (byte, []byte, error)
// EncryptExplicitExpression encrypts the given expression with the given options.
EncryptExplicitExpression(ctx context.Context, val bsoncore.Document, opts *options.ExplicitEncryptionOptions) (bsoncore.Document, error)
// DecryptExplicit decrypts the given encrypted value.
DecryptExplicit(ctx context.Context, subtype byte, data []byte) (bsoncore.Value, error)
// Close cleans up any resources associated with the Crypt instance.
Close()
// BypassAutoEncryption returns true if auto-encryption should be bypassed.
BypassAutoEncryption() bool
// RewrapDataKey attempts to rewrap the document data keys matching the filter, preparing the re-wrapped documents
// to be returned as a slice of bsoncore.Document.
RewrapDataKey(ctx context.Context, filter []byte, opts *options.RewrapManyDataKeyOptions) ([]bsoncore.Document, error)
}
func NewCrypt(opts *CryptOptions) Crypt
NewCrypt creates a new Crypt instance configured with the given AutoEncryptionOptions.
CryptOptions specifies options to configure a Crypt instance.
type CryptOptions struct {
MongoCrypt *mongocrypt.MongoCrypt
CollInfoFn CollectionInfoFn
KeyFn KeyRetrieverFn
MarkFn MarkCommandFn
TLSConfig map[string]*tls.Config
BypassAutoEncryption bool
BypassQueryAnalysis bool
}
CursorOptions are extra options that are required to construct a BatchCursor.
type CursorOptions struct {
BatchSize int32
Comment bsoncore.Value
MaxTimeMS int64
Limit int32
CommandMonitor *event.CommandMonitor
Crypt Crypt
ServerAPI *ServerAPIOptions
MarshalValueEncoderFn func(io.Writer) (*bson.Encoder, error)
}
CursorResponse represents the response from a command the results in a cursor. A BatchCursor can be constructed from a CursorResponse.
type CursorResponse struct {
Server Server
ErrorProcessor ErrorProcessor // This will only be set when pinning to a connection.
Connection PinnedConnection
Desc description.Server
FirstBatch *bsoncore.DocumentSequence
Database string
Collection string
ID int64
// contains filtered or unexported fields
}
func NewCursorResponse(info ResponseInfo) (CursorResponse, error)
NewCursorResponse constructs a cursor response from the given response and server. If the provided database response does not contain a cursor, it returns ErrNoCursor.
NewCursorResponse can be used within the ProcessResponse method for an operation.
Deployment is implemented by types that can select a server from a deployment.
type Deployment interface {
SelectServer(context.Context, description.ServerSelector) (Server, error)
Kind() description.TopologyKind
}
Disconnector represents a type that can disconnect from a server.
type Disconnector interface {
Disconnect(context.Context) error
}
Error is a command execution error from the database.
type Error struct {
Code int32
Message string
Labels []string
Name string
Wrapped error
TopologyVersion *description.TopologyVersion
Raw bsoncore.Document
}
func (e Error) Error() string
Error implements the error interface.
func (e Error) HasErrorLabel(label string) bool
HasErrorLabel returns true if the error contains the specified label.
func (e Error) NamespaceNotFound() bool
NamespaceNotFound returns true if this errors is a NamespaceNotFound error.
func (e Error) NetworkError() bool
NetworkError returns true if the error is a network error.
func (e Error) NodeIsRecovering() bool
NodeIsRecovering returns true if this error is a node is recovering error.
func (e Error) NodeIsShuttingDown() bool
NodeIsShuttingDown returns true if this error is a node is shutting down error.
func (e Error) NotPrimary() bool
NotPrimary returns true if this error is a not primary error.
func (e Error) RetryableRead() bool
RetryableRead returns true if the error is retryable for a read operation
func (e Error) RetryableWrite(wireVersion *description.VersionRange) bool
RetryableWrite returns true if the error is retryable for a write operation
func (e Error) UnsupportedStorageEngine() bool
UnsupportedStorageEngine returns whether e came as a result of an unsupported storage engine
func (e Error) Unwrap() error
Unwrap returns the underlying error.
ErrorProcessor implementations can handle processing errors, which may modify their internal state. If this type is implemented by a Server, then Operation.Execute will call it's ProcessError method after it decodes a wire message.
type ErrorProcessor interface {
ProcessError(err error, conn Connection) ProcessErrorResult
}
Expirable represents an expirable object.
type Expirable interface {
Expire() error
Alive() bool
}
HandshakeInformation contains information extracted from a MongoDB connection handshake. This is a helper type that augments description.Server by also tracking server connection ID and authentication-related fields. We use this type rather than adding authentication-related fields to description.Server to avoid retaining sensitive information in a user-facing type. The server connection ID is stored in this type because unlike description.Server, all handshakes are correlated with a single network connection.
type HandshakeInformation struct {
Description description.Server
SpeculativeAuthenticate bsoncore.Document
ServerConnectionID *int64
SaslSupportedMechs []string
}
Handshaker is the interface implemented by types that can perform a MongoDB handshake over a provided driver.Connection. This is used during connection initialization. Implementations must be goroutine safe.
type Handshaker interface {
GetHandshakeInformation(context.Context, address.Address, Connection) (HandshakeInformation, error)
FinishHandshake(context.Context, Connection) error
}
InvalidOperationError is returned from Validate and indicates that a required field is missing from an instance of Operation.
type InvalidOperationError struct{ MissingField string }
func (err InvalidOperationError) Error() string
KeyRetrieverFn is a callback used to retrieve keys from the key vault.
type KeyRetrieverFn func(ctx context.Context, filter bsoncore.Document) ([]bsoncore.Document, error)
LegacyOperationKind indicates if an operation is a legacy find, getMore, or killCursors. This is used in Operation.Execute, which will create legacy OP_QUERY, OP_GET_MORE, or OP_KILL_CURSORS instead of sending them as a command.
type LegacyOperationKind uint
These constants represent the three different kinds of legacy operations.
const (
LegacyNone LegacyOperationKind = iota
LegacyFind
LegacyGetMore
LegacyKillCursors
LegacyListCollections
LegacyListIndexes
LegacyHandshake
)
LocalAddresser is a type that is able to supply its local address
type LocalAddresser interface {
LocalAddress() address.Address
}
MarkCommandFn is a callback used to add encryption markings to a command.
type MarkCommandFn func(ctx context.Context, db string, cmd bsoncore.Document) (bsoncore.Document, error)
Operation is used to execute an operation. It contains all of the common code required to select a server, transform an operation into a command, write the command to a connection from the selected server, read a response from that connection, process the response, and potentially retry.
The required fields are Database, CommandFn, and Deployment. All other fields are optional.
While an Operation can be constructed manually, drivergen should be used to generate an implementation of an operation instead. This will ensure that there are helpers for constructing the operation and that this type isn't configured incorrectly.
type Operation struct {
// CommandFn is used to create the command that will be wrapped in a wire message and sent to
// the server. This function should only add the elements of the command and not start or end
// the enclosing BSON document. Per the command API, the first element must be the name of the
// command to run. This field is required.
CommandFn func(dst []byte, desc description.SelectedServer) ([]byte, error)
// Database is the database that the command will be run against. This field is required.
Database string
// Deployment is the MongoDB Deployment to use. While most of the time this will be multiple
// servers, commands that need to run against a single, preselected server can use the
// SingleServerDeployment type. Commands that need to run on a preselected connection can use
// the SingleConnectionDeployment type.
Deployment Deployment
// ProcessResponseFn is called after a response to the command is returned. The server is
// provided for types like Cursor that are required to run subsequent commands using the same
// server.
ProcessResponseFn func(ResponseInfo) error
// Selector is the server selector that's used during both initial server selection and
// subsequent selection for retries. Depending on the Deployment implementation, the
// SelectServer method may not actually be called.
Selector description.ServerSelector
// ReadPreference is the read preference that will be attached to the command. If this field is
// not specified a default read preference of primary will be used.
ReadPreference *readpref.ReadPref
// ReadConcern is the read concern used when running read commands. This field should not be set
// for write operations. If this field is set, it will be encoded onto the commands sent to the
// server.
ReadConcern *readconcern.ReadConcern
// MinimumReadConcernWireVersion specifies the minimum wire version to add the read concern to
// the command being executed.
MinimumReadConcernWireVersion int32
// WriteConcern is the write concern used when running write commands. This field should not be
// set for read operations. If this field is set, it will be encoded onto the commands sent to
// the server.
WriteConcern *writeconcern.WriteConcern
// MinimumWriteConcernWireVersion specifies the minimum wire version to add the write concern to
// the command being executed.
MinimumWriteConcernWireVersion int32
// Client is the session used with this operation. This can be either an implicit or explicit
// session. If the server selected does not support sessions and Client is specified the
// behavior depends on the session type. If the session is implicit, the session fields will not
// be encoded onto the command. If the session is explicit, an error will be returned. The
// caller is responsible for ensuring that this field is nil if the Deployment does not support
// sessions.
Client *session.Client
// Clock is a cluster clock, different from the one contained within a session.Client. This
// allows updating cluster times for a global cluster clock while allowing individual session's
// cluster clocks to be only updated as far as the last command that's been run.
Clock *session.ClusterClock
// RetryMode specifies how to retry. There are three modes that enable retry: RetryOnce,
// RetryOncePerCommand, and RetryContext. For more information about what these modes do, please
// refer to their definitions. Both RetryMode and Type must be set for retryability to be enabled.
// If Timeout is set on the Client, the operation will automatically retry as many times as
// possible unless RetryNone is used.
RetryMode *RetryMode
// Type specifies the kind of operation this is. There is only one mode that enables retry: Write.
// For more information about what this mode does, please refer to it's definition. Both Type and
// RetryMode must be set for retryability to be enabled.
Type Type
// Batches contains the documents that are split when executing a write command that potentially
// has more documents than can fit in a single command. This should only be specified for
// commands that are batch compatible. For more information, please refer to the definition of
// Batches.
Batches *Batches
// Legacy sets the legacy type for this operation. There are only 3 types that require legacy
// support: find, getMore, and killCursors. For more information about LegacyOperationKind,
// please refer to it's definition.
Legacy LegacyOperationKind
// CommandMonitor specifies the monitor to use for APM events. If this field is not set,
// no events will be reported.
CommandMonitor *event.CommandMonitor
// Crypt specifies a Crypt object to use for automatic client side encryption and decryption.
Crypt Crypt
// ServerAPI specifies options used to configure the API version sent to the server.
ServerAPI *ServerAPIOptions
// IsOutputAggregate specifies whether this operation is an aggregate with an output stage. If true,
// read preference will not be added to the command on wire versions < 13.
IsOutputAggregate bool
// MaxTime specifies the maximum amount of time to allow the operation to run on the server.
MaxTime *time.Duration
// Timeout is the amount of time that this operation can execute before returning an error. The default value
// nil, which means that the timeout of the operation's caller will be used.
Timeout *time.Duration
Logger *logger.Logger
// Name is the name of the operation. This is used when serializing
// OP_MSG as well as for logging server selection data.
Name string
// OmitCSOTMaxTimeMS omits the automatically-calculated "maxTimeMS" from the
// command when CSOT is enabled. It does not effect "maxTimeMS" set by
// [Operation.MaxTime].
OmitCSOTMaxTimeMS bool
// contains filtered or unexported fields
}
func (op Operation) Execute(ctx context.Context) error
Execute runs this operation.
func (op Operation) ExecuteExhaust(ctx context.Context, conn StreamerConnection) error
ExecuteExhaust reads a response from the provided StreamerConnection. This will error if the connection's CurrentlyStreaming function returns false.
func (op Operation) Validate() error
Validate validates this operation, ensuring the fields are set properly.
PinnedConnection represents a Connection that can be pinned by one or more cursors or transactions. Implementations of this interface should maintain the following invariants:
1. Each Pin* call should increment the number of references for the connection. 2. Each Unpin* call should decrement the number of references for the connection. 3. Calls to Close() should be ignored until all resources have unpinned the connection.
type PinnedConnection interface {
Connection
PinToCursor() error
PinToTransaction() error
UnpinFromCursor() error
UnpinFromTransaction() error
}
ProcessErrorResult represents the result of a ErrorProcessor.ProcessError() call. Exact values for this type can be checked directly (e.g. res == ServerMarkedUnknown), but it is recommended that applications use the ServerChanged() function instead.
type ProcessErrorResult int
const (
// NoChange indicates that the error did not affect the state of the server.
NoChange ProcessErrorResult = iota
// ServerMarkedUnknown indicates that the error only resulted in the server being marked as Unknown.
ServerMarkedUnknown
// ConnectionPoolCleared indicates that the error resulted in the server being marked as Unknown and its connection
// pool being cleared.
ConnectionPoolCleared
)
QueryFailureError is an error representing a command failure as a document.
type QueryFailureError struct {
Message string
Response bsoncore.Document
Wrapped error
}
func (e QueryFailureError) Error() string
Error implements the error interface.
func (e QueryFailureError) Unwrap() error
Unwrap returns the underlying error.
RTTMonitor represents a round-trip-time monitor.
type RTTMonitor interface {
// EWMA returns the exponentially weighted moving average observed round-trip time.
EWMA() time.Duration
// Min returns the minimum observed round-trip time over the window period.
Min() time.Duration
// P90 returns the 90th percentile observed round-trip time over the window period.
P90() time.Duration
// Stats returns stringified stats of the current state of the monitor.
Stats() string
}
ResponseError is an error parsing the response to a command.
type ResponseError struct {
Message string
Wrapped error
}
func NewCommandResponseError(msg string, err error) ResponseError
NewCommandResponseError creates a CommandResponseError.
func (e ResponseError) Error() string
Error implements the error interface.
ResponseInfo contains the context required to parse a server response.
type ResponseInfo struct {
ServerResponse bsoncore.Document
Server Server
Connection Connection
ConnectionDescription description.Server
CurrentIndex int
}
RetryMode specifies the way that retries are handled for retryable operations.
type RetryMode uint
These are the modes available for retrying. Note that if Timeout is specified on the Client, the operation will automatically retry as many times as possible within the context's deadline unless RetryNone is used.
const (
// RetryNone disables retrying.
RetryNone RetryMode = iota
// RetryOnce will enable retrying the entire operation once if Timeout is not specified.
RetryOnce
// RetryOncePerCommand will enable retrying each command associated with an operation if Timeout
// is not specified. For example, if an insert is batch split into 4 commands then each of
// those commands is eligible for one retry.
RetryOncePerCommand
// RetryContext will enable retrying until the context.Context's deadline is exceeded or it is
// cancelled.
RetryContext
)
func (rm RetryMode) Enabled() bool
Enabled returns if this RetryMode enables retrying.
RetryablePoolError is a connection pool error that can be retried while executing an operation.
type RetryablePoolError interface {
Retryable() bool
}
Server represents a MongoDB server. Implementations should pool connections and handle the retrieving and returning of connections.
type Server interface {
Connection(context.Context) (Connection, error)
// RTTMonitor returns the round-trip time monitor associated with this server.
RTTMonitor() RTTMonitor
}
ServerAPIOptions represents options used to configure the API version sent to the server when running commands.
type ServerAPIOptions struct {
ServerAPIVersion string
Strict *bool
DeprecationErrors *bool
}
func NewServerAPIOptions(serverAPIVersion string) *ServerAPIOptions
NewServerAPIOptions creates a new ServerAPIOptions configured with the provided serverAPIVersion.
func (s *ServerAPIOptions) SetDeprecationErrors(deprecationErrors bool) *ServerAPIOptions
SetDeprecationErrors specifies whether the server should return errors for deprecated features.
func (s *ServerAPIOptions) SetStrict(strict bool) *ServerAPIOptions
SetStrict specifies whether the server should return errors for features that are not part of the API version.
SingleConnectionDeployment is an implementation of Deployment that always returns the same Connection. This implementation should only be used for connection handshakes and server heartbeats as it does not implement ErrorProcessor, which is necessary for application operations.
type SingleConnectionDeployment struct{ C Connection }
func (scd SingleConnectionDeployment) Connection(context.Context) (Connection, error)
Connection implements the Server interface. It always returns the embedded connection.
func (SingleConnectionDeployment) Kind() description.TopologyKind
Kind implements the Deployment interface. It always returns description.Single.
func (scd SingleConnectionDeployment) RTTMonitor() RTTMonitor
RTTMonitor implements the driver.Server interface.
func (scd SingleConnectionDeployment) SelectServer(context.Context, description.ServerSelector) (Server, error)
SelectServer implements the Deployment interface. This method does not use the description.SelectedServer provided and instead returns itself. The Connections returned from the Connection method have a no-op Close method.
SingleServerDeployment is an implementation of Deployment that always returns a single server.
type SingleServerDeployment struct{ Server }
func (SingleServerDeployment) Kind() description.TopologyKind
Kind implements the Deployment interface. It always returns description.Single.
func (ssd SingleServerDeployment) SelectServer(context.Context, description.ServerSelector) (Server, error)
SelectServer implements the Deployment interface. This method does not use the description.SelectedServer provided and instead returns the embedded Server.
StreamerConnection represents a Connection that supports streaming wire protocol messages using the moreToCome and exhaustAllowed flags.
The SetStreaming and CurrentlyStreaming functions correspond to the moreToCome flag on server responses. If a response has moreToCome set, SetStreaming(true) will be called and CurrentlyStreaming() should return true.
CanStream corresponds to the exhaustAllowed flag. The operations layer will set exhaustAllowed on outgoing wire messages to inform the server that the driver supports streaming.
type StreamerConnection interface {
Connection
SetStreaming(bool)
CurrentlyStreaming() bool
SupportsStreaming() bool
}
Subscriber represents a type to which another type can subscribe. A subscription contains a channel that is updated with topology descriptions.
type Subscriber interface {
Subscribe() (*Subscription, error)
Unsubscribe(*Subscription) error
}
Subscription represents a subscription to topology updates. A subscriber can receive updates through the Updates field.
type Subscription struct {
Updates <-chan description.Topology
ID uint64
}
Type specifies whether an operation is a read, write, or unknown.
type Type uint
THese are the availables types of Type.
const (
Write Type
Read
)
WriteCommandError is an error for a write command.
type WriteCommandError struct {
WriteConcernError *WriteConcernError
WriteErrors WriteErrors
Labels []string
Raw bsoncore.Document
}
func (wce WriteCommandError) Error() string
func (wce WriteCommandError) HasErrorLabel(label string) bool
HasErrorLabel returns true if the error contains the specified label.
func (wce WriteCommandError) Retryable(wireVersion *description.VersionRange) bool
Retryable returns true if the error is retryable
func (wce WriteCommandError) UnsupportedStorageEngine() bool
UnsupportedStorageEngine returns whether or not the WriteCommandError comes from a retryable write being attempted against a server that has a storage engine where they are not supported
WriteConcernError is a write concern failure that occurred as a result of a write operation.
type WriteConcernError struct {
Name string
Code int64
Message string
Details bsoncore.Document
Labels []string
TopologyVersion *description.TopologyVersion
Raw bsoncore.Document
}
func (wce WriteConcernError) Error() string
func (wce WriteConcernError) NodeIsRecovering() bool
NodeIsRecovering returns true if this error is a node is recovering error.
func (wce WriteConcernError) NodeIsShuttingDown() bool
NodeIsShuttingDown returns true if this error is a node is shutting down error.
func (wce WriteConcernError) NotPrimary() bool
NotPrimary returns true if this error is a not primary error.
func (wce WriteConcernError) Retryable() bool
Retryable returns true if the error is retryable
WriteError is a non-write concern failure that occurred as a result of a write operation.
type WriteError struct {
Index int64
Code int64
Message string
Details bsoncore.Document
Raw bsoncore.Document
}
func (we WriteError) Error() string
WriteErrors is a group of non-write concern failures that occurred as a result of a write operation.
type WriteErrors []WriteError
func (we WriteErrors) Error() string
| Name | Synopsis |
|---|---|
| .. | |
| auth | Package auth is not for public use. |
| creds | |
| connstring | |
| dns | |
| drivertest | |
| integration | |
| mongocrypt | |
| options | |
| ocsp | |
| operation | |
| session | |
| topology | Package topology contains types that handles the discovery, monitoring, and selection of servers. |
| wiremessage | |