Error catalogue

Reference · generated · every public error type in the workspace, variant by variant, with the meaning its documentation states

The table is read from the source, so a variant that exists is listed and a variant that is gone disappears. The troubleshooting guide gives remedies for the errors a user meets from the command line.

`ConflationError` in `dev_ring/dev-stages`

Defined in dev_ring/dev-stages/src/conflation/mod.rs.

Variant	Meaning
`Saturated`	More keys than ring slots. Nothing in this module raises it; a [`KeyExtractor`] that enforces the bound may.
`PayloadTooShort`	Payload is shorter than the configured key-extraction range.
`PayloadTooLarge`	The payload is longer than [`MAX_LOGICAL_PAYLOAD`].
`Source`	The [`Source`] behind a drainer has failed for good; its own error is carried as the cause.

`BasketError` in `mesh/mesh-basket`

Defined in mesh/mesh-basket/src/lib.rs.

Variant	Meaning
`Sqlite`	The SQLite engine failed.
`Io`	Creating the basket file’s directory failed.
`InvalidQuery`	The [`QuerySpec`] is invalid: a time-bucket aggregate of zero seconds.
`Poisoned`	A thread panicked holding the connection; surface the error rather than retry on this `Basket`.

`DevError` in `mesh/mesh-client`

Defined in mesh/mesh-client/src/error.rs.

Variant	Meaning
`NoDaemon`	`PMS_DAEMON` names neither a `unix://` path nor a `ws://` or `wss://` URL.
`ForeignDaemon`	The socket at the default path, `/tmp/pms.sock`, is served by another user. Anyone may create that path before the daemon does, and a client connected to it would hand that user everything it sends, so the client does not use it.
`VersionMismatch`	The protocol version the daemon speaks is not supported by this client.
`Transport`	The client could not connect, or start its runtime or threads.
`Tls`	The TLS handshake of a `wss://` endpoint failed: the daemon’s certificate chains to none of the roots the client trusts (webpki-roots’ and those given with `MeshOptions::with_tls_root_pem`) or does not name the host, the daemon does not speak TLS, or a root given is not a PEM certificate. Nothing was sent.
`Protocol`	A request could not be serialized, or the WebSocket handshake did not accept the port subprotocol.
`Daemon`	The daemon returned an `error` op: in reply to a request, or unprompted just before it closed the connection (`limit_exceeded` at its connection cap, `payload_too_large` after a frame over its limit), which every call still waiting and `Mesh::wait` then report. Every code but `auth_failed`, which is [`DevError::AuthFailed`].
`AuthFailed`	The daemon refused the attach with `auth_failed` and closed the connection: it allows only the keys it lists and this key is not one, or it requires a key (`MeshOptions::with_identity`) and the attach carried none, or the proof did not verify, or it came too late. `Mesh::wait` and every call still waiting report it too.
`KeyFile`	A key file could not be made, read or used (`MeshOptions::with_identity_file`, `identity`): it cannot be opened, its group or others may read or write it, or it holds no key. `path` is empty when no random bytes could be had for a new key.
`NotAttached`	Called before `attach` succeeded.
`DisconnectedDuringRpc`	The call got no answer: the connection had already ended when it was made, or ended without answering it.
`Timeout`	The daemon did not answer within `MeshOptions::rpc_timeout`, and the call was cancelled (see `Mesh::late_replies`).
`QueueFull`	The call was refused, having sent nothing, because the client’s queue toward the daemon stayed full until its deadline (see `client::COMMAND_QUEUE`): the daemon reads more slowly than calls are made, or has stopped. The call may be retried.
`ReentrantCall`	A blocking call was made on a thread in an async runtime’s context (a task’s, or a `spawn_blocking` or `block_in_place` closure’s), where blocking would deadlock or panic. Call from a plain `std::thread`, or from a subscription callback, which runs on one.
`Disconnected`	The connection ended, not by a detach the daemon acknowledged and with no error from the daemon: it closed the connection, or a write failed. `Mesh::wait` and every call still waiting report it.
`Silent`	The daemon sent nothing for `MeshOptions::silence_limit` while the client waited for it, and the client closed the connection; `Mesh::wait` and every call still waiting report it. A stopped daemon or host looks like this.
`MeshDropped`	A `WeakMesh` was upgraded after every `Mesh` of its connection had been dropped, which closed the connection. Nothing was sent.

`AttachKeysError` in `mesh/mesh-hub`

Defined in mesh/mesh-hub/src/attach_keys.rs.

Variant	Meaning
`Read`	The file could not be read, or is not UTF-8.
`Line`	A line is neither blank, a comment, nor a key.

`DaemonError` in `mesh/mesh-hub`

Defined in mesh/mesh-hub/src/daemon.rs.

Variant	Meaning
`Signals`	A signal handler could not be installed; `signal` names it.
`Uds`	The Unix socket could not be claimed or served: another daemon holds the path, or the socket could not be bound.
`Ws`	The WebSocket address could not be bound or served.
`Metrics`	The metrics address could not be bound or served.
`Hub`	The hub could not be created; the string is the bridge’s reason.
`Basket`	The basket file could not be opened.
`StoreRefused`	The envelope store asked for could not be made (the runtime logged why), and the daemon will not run without it: attached processes would receive nothing.
`Links`	The links to other daemons could not be started: their configuration was refused, their address could not be bound, or a thread could not start.

`EmbedError` in `mesh/mesh-hub`

Defined in mesh/mesh-hub/src/embed.rs.

Variant	Meaning
`Runtime`	The async runtime could not be built, or the thread that watches the hub’s name for another owner could not be started.
`Hub`	The hub itself could not be created; the string is the bridge’s reason.
`Bind`	The listener could not bind, with the address it was asked for.
`Nowhere`	No bind was given, so there would have been nowhere to answer.
`Links`	The links to other daemons could not be started: their configuration was refused, their address could not be bound, or a thread could not start.

`BridgeError` in `mesh/mesh-hub`

Defined in mesh/mesh-hub/src/hub_bridge.rs.

Variant	Meaning
`Init`	The hub could not be created; the message is the runtime’s reason (see [`HubBridge::new`]).
`Dispatch`	The hub’s schema registry refused a send’s envelope; the message is the underlying error.
`TooLong`	A send’s channel or type name longer than [`MAX_CHANNEL_LEN`], or a filter string longer than [`MAX_PATTERN_LEN`]; nothing was published or subscribed, and the daemon answers `bad_request`.
`UnknownDestination`	A send’s destination is no node attached here, and none a linked peer announced; nothing was delivered, and the daemon answers `unknown_destination`.

`AnnounceError` in `mesh/mesh-hub`

Defined in mesh/mesh-hub/src/link/announce.rs.

Variant	Meaning
`Length`	The bytes are not the 47 of an announcement.
`Magic`	The bytes do not start with [`ANNOUNCE_MAGIC`].
`Version`	A version this build does not read.
`Port`	The announced port is zero.
`DaemonId`	The daemon id is not the fingerprint of the announced key.

`LinkPeerError` in `mesh/mesh-hub`

Defined in mesh/mesh-hub/src/link/mod.rs.

Variant	Meaning
`NoKey`	The text has no `=` between an address and a key.
`Address`	What comes before the `=` is not an IP address and port.
`Key`	What comes after the `=` is not 64 hex digits.

`LinkSetupError` in `mesh/mesh-hub`

Defined in mesh/mesh-hub/src/link/mod.rs.

Variant	Meaning
`NoPeers`	The configuration names no peer.
`OwnKey`	A peer has this daemon’s own key.
`OwnPeerKey`	A peer named by its key alone has this daemon’s own key.
`PeerKeysWithoutAnnounce`	Peers are named by their key alone, and nothing announces where they are.
`AnnounceGroup`	The announcement group is not an IPv4 multicast address, or its port is zero.
`AnnounceTtl`	The announcements’ TTL is not 1 to 255.
`AnnounceBind`	LAN announcement is asked for links bound to an IPv6 address, which an IPv4 announcement cannot give.
`Announce`	The announcement group could not be joined, or its sender set up.
`DuplicatePeer`	Two peers have one key, or keys with one daemon id.
`TrustedRelayNotPeer`	A key trusted as a relay is not a configured peer’s.
`DuplicateAddress`	Two peers have one address.
`Timing`	The heartbeat interval is zero, or not shorter than the silence limit, so a link that works would be taken down.
`Bind`	The link address could not be bound, or its socket set up.
`Thread`	A link thread could not be started.

`DatagramError` in `mesh/mesh-hub`

Defined in mesh/mesh-hub/src/link/wire.rs.

Variant	Meaning
`Envelope`	The frame’s bytes are not a canonical envelope with its own id in the form a link writes: type 0, a zero origin and time, no flags and a raw payload.
`Pulse`	The frame’s Pulse does not name the envelope it carries, or names another daemon than the peer it came from.
`Kind`	The envelope’s type name is neither link type.
`Control`	A control message that does not decode.
`Forward`	A forward whose layout is not this build’s.
`Hello`	A Hello that is not a link Hello.
`TooLarge`	What would be sent is longer than a run of fragments carries.

`WsTlsError` in `mesh/mesh-hub`

Defined in mesh/mesh-hub/src/tls.rs.

Variant	Meaning
`Read`	A PEM file could not be read.
`Certificates`	The certificate chain holds no certificate, or is not PEM.
`Key`	The private key’s PEM holds no key, or is not PEM.
`Refused`	rustls refused the certificate and key: the key is not one it can sign with, or not the certificate’s.

`HubError` in `mesh/mesh-hub-runtime`

Defined in mesh/mesh-hub-runtime/src/lib.rs.

Variant	Meaning
`TemporalViolation`	A published pulse was not later than the last one accepted, the SIG-T05 invariant: clock skew or a replay. Nothing was written.
`Schema`	The schema registry refused the envelope.
`ReadOnly`	This hub did not create its ring, whose one writer is its creator; nothing was written. Publish by sending to the daemon instead.

`OwnerError` in `mesh/mesh-hub-runtime`

Defined in mesh/mesh-hub-runtime/src/lib.rs.

Variant	Meaning
`Owned`	A live hub owns the name; nothing was removed or created.
`Lock`	The name’s lock file could not be taken for a reason other than a live owner (see [`LockError`]); nothing was removed or created.
`Ring`	The hub name is invalid, or the hub’s ring could not be removed or created.

`LockError` in `mesh/mesh-hub-runtime`

Defined in mesh/mesh-hub-runtime/src/owner.rs.

Variant	Meaning
`Held`	A live process holds the lock: the hub name or the socket path has an owner, and nothing it guards was touched.
`Io`	The lock file could not be opened, locked or checked: the operating system’s error, such as `EACCES` for a directory this user cannot write.
`NotPlain`	The lock path names something other than a plain file with one name, such as a symbolic link or a hard-linked file, which could redirect the holder’s writes.
`Displaced`	The lock file was removed while its holder lived, and its ownership check ([`OwnerLock::set_ownership_check`]) says another owner has taken what it guards: the holder is displaced, and leaves the path to the next owner.

`CodecError` in `mesh/mesh-link`

Defined in mesh/mesh-link/src/codec.rs.

Variant	Meaning
`TooLarge`	A message, or a field in one, is longer than its cap.
`Truncated`	The bytes end inside the field that starts at `at`, or before the entries a count there declares.
`TrailingBytes`	Bytes follow the end of the message.
`UnknownVersion`	The encoding’s version is not one this build reads.
`UnknownKind`	A control message’s kind is not one this build knows.
`UnknownFlags`	An interest summary sets flag bits this build does not know.
`UnknownState`	A health notice’s state code is not one this build knows.
`BadPart`	An announcement’s part is not below its count of parts, or the count is 0 or above 64 (`MAX_ANNOUNCE_PARTS`).
`NotUtf8`	A text field that starts at `at` is not UTF-8.
`NotCanonical`	The bytes are well formed but not in the one form the encoding allows for their value, such as a set out of order; the reason says which rule they break.

`LinkError` in `mesh/mesh-link`

Defined in mesh/mesh-link/src/link.rs.

Variant	Meaning
`Closed`	The link is closed, here or at the peer.
`Encode`	A control message could not be encoded, as one past its cap cannot.
`Decode`	The peer sent bytes that are not a control message.
`EnvelopeTooLarge`	The envelope is longer than the link carries.

`OriginError` in `mesh/mesh-link`

Defined in mesh/mesh-link/src/origin.rs.

Variant	Meaning
`NameTooLong`	The name is longer than a daemon admits at attach.
`NoDaemon`	The text has no `@` between a name and a daemon.
`BadDaemon`	The daemon is not 16 lowercase hex digits.

`RouteError` in `mesh/mesh-link`

Defined in mesh/mesh-link/src/router.rs.

Variant	Meaning
`UnknownPeer`	The daemon is not linked to this peer.
`LocalDaemon`	A daemon is not its own peer.
`ForeignNode`	A peer announced as its own a node another daemon qualifies.
`ViaNode`	A peer announced as reached through it a node of its own, or of this daemon.
`BadPart`	A part of an announcement outside its parts, or whose count of parts is not its generation’s.

`ProofError` in `mesh/mesh-port-protocol`

Defined in mesh/mesh-port-protocol/src/attach.rs.

Variant	Meaning
`Text`	The field’s text is not the padded standard base64 of as many bytes as the field holds.
`Key`	The public key is not an Ed25519 point, or is one of small order.
`Signature`	The signature is not the key’s over the challenge, the name and the connection, or is not in its canonical form.

`TextError` in `mesh/mesh-port-protocol`

Defined in mesh/mesh-port-protocol/src/attach.rs.

Variant	Meaning
`Base64`	Not padded standard base64.
`Length`	Base64 of the wrong number of bytes.

`Base64Error` in `mesh/mesh-port-protocol`

Defined in mesh/mesh-port-protocol/src/base64.rs.

Variant	Meaning
`Length`	The length is not a multiple of four.
`InvalidByte`	A byte outside the standard alphabet, whitespace and the URL-safe `-` and `_` included.
`Padding`	A `=` other than the one or two that end the text.
`TrailingBits`	The symbol before the padding sets bits that carry no data, which no encoder writes.

`FrameError` in `mesh/mesh-port-protocol`

Defined in mesh/mesh-port-protocol/src/framing.rs.

Variant	Meaning
`Oversized`	A frame longer than the decoder’s maximum, or a payload longer than a prefix can declare.

`ErrorCode` in `mesh/mesh-port-protocol`

Defined in mesh/mesh-port-protocol/src/lib.rs.

Variant	Meaning
`VersionUnsupported`	The client announced a protocol version this daemon does not speak.
`NotAttached`	The operation needs an attached connection.
`NameInUse`	Another attached connection already holds that name.
`BadFilter`	The subscribe filter could not be understood.
`UnknownSubscription`	The subscription id is unknown or belongs to another connection.
`PayloadTooLarge`	The payload exceeds what the daemon accepts.
`LimitExceeded`	A limit of the daemon’s connection policy was reached; the message names the limit and the flag that sets it. A Unix-socket connection past the connection cap gets it unprompted, without an id, and is closed.
`BadRequest`	The message is not a valid request: malformed JSON, a field missing or malformed, or a string longer than its cap.
`Internal`	The daemon failed internally; the message carries detail.
`AuthFailed`	A key-proof attach failed ([`attach`]): the proof did not verify, the key is not one the daemon allows, a `prove` came with no challenge pending or another request while one was, the challenge went unanswered past the daemon’s handshake timeout, or the daemon requires a key and the attach carried none. The daemon closes the connection after it.
`UnknownDestination`	A `send`’s `to` names no node this daemon can deliver to: none of its own attached clients, and none a linked peer daemon announced. The message names the node; nothing was delivered.

`SchemaError` in `mesh/mesh-schema`

Defined in mesh/mesh-schema/src/lib.rs.

Variant	Meaning
`TypeIdExists`	A schema with this `type_id` is already registered.
`NameExists`	A schema with this name is already registered.
`UnknownType`	No schema is registered under this `type_id`.
`ProducerNotAllowed`	The producing node is not on the schema’s producer ACL.
`ValidationFailed`	The payload failed the schema’s [`ValidationMode`]; carries the reason.

`TelemetryExportError` in `tools/pms-telemetry-export`

Defined in tools/pms-telemetry-export/src/lib.rs.

Variant	Meaning
`Encode`	Failed to render the metrics buffer into Prometheus text format.
`Register`	One of the canonical metrics failed to register against the Prometheus `Registry` — typically a duplicate-name collision when multiple `Metrics` instances share a registry.

Keyboard shortcuts

Pulse Mesh Daemon