Enum MessageKind

pub enum MessageKind {
    Hello(Capabilities),
    Welcome {
        recipient: Option<Uuid>,
        info: Capabilities,
    },
    InvalidUuid(Uuid),
    MismatchingVersions(Uuid),
    Event(Event),
    FastForward(Request),
    FastForwardReply(Response),
    Sync(Request),
    SyncReply(Response),
    HashCheck(Request),
    HashCheckReply(Response),
    LogCheck {
        conversation_uuid: Uuid,
        check: LogCheck,
    },
    LogCheckReply {
        conversation_uuid: Uuid,
        check: LogCheck,
    },
    Cancelled(Uuid),
    Disconnect,
    User {
        recipient: Option<Uuid>,
        data: Vec<u8>,
    },
}

The kinds of messages with their data. Part of a Message.

On direct messages, send a conversation UUID which can be Self::Cancelled.

Variants

Hello(Capabilities)

The client sending this is connecting to the network.

Will declare it’s capabilities.

Replies

Expects a Self::Welcome, Self::InvalidUuid, or Self::MismatchingVersions.

Welcome

Response to the Self::Hello message.

These capabilities are our own, giving the remote information about us.

When the inner recipient is None, this updates the other piers’ information about the client. Else, it’s just a response to a greeting.

Fields

recipient: Option<Uuid>

The target of this message.

info: Capabilities

Which capabilities we have.

InvalidUuid(Uuid)

The sender of MessageKind::Hello of the contained Uuid uses an occupied UUID.

If a critical count of piers respond with this, change UUID and send Self::Hello again.

MismatchingVersions(Uuid)

The Capabilities::version() is not compatible.

The sending client (with the contained Uuid) will not add UUID of the Self::Hello message to the known clients. The sender of the Hello should ignore all future messages from this client.

Event(Event)

A client has new data to share.

FastForward(Request)

A client tries to get the most recent data. Contains the list of which documents were edited and size at last session.

Replies

You should respond with a Self::FastForwardReply. That contains which resources you should sync.

Then, send a Self::Sync request and handle the actual data transmission.

FastForwardReply(Response)

A reply to a Self::FastForward request.

Sync(Request)

A request to get the diffs and sync the specified resources.

SyncReply(Response)

The response with hashes of the specified resources.

HashCheck(Request)

Requests all the hashes of all the resources specified in resource::Matcher.

HashCheckReply(Response)

A reply with all the hashes of all the requested files.

LogCheck

Checks the internal event UUID log.

Replies

Always send back a Self::LogCheckReply to tell others which “version” you have.

Wait a few seconds (e.g. 10) and then call Manager::assure_log_check. If any discrepancy is found, you should send back a Self::HashCheck. If everything is ok, don’t respond.

Fields

conversation_uuid: Uuid

The UUID of this check conversation.

check: LogCheck

The data of the check.

LogCheckReply

A reply to Self::LogCheck.

This is used to determine which “version” of the data is the correct one. This should not be responded to, but maybe kept a few seconds to keep the piers with the “correct version”.

Fields

conversation_uuid: Uuid

The UUID of this check conversation.

check: LogCheck

The data of the check.

Cancelled(Uuid)

The target client cancelled the request.

This may be the result of too many requests. Should not be sent as a signal of not supporting the feature.

If a pier requests a check from all and we’ve reached our limit, don’t send this.

Disconnect

The sender is disconnecting.

User

Data sent by the user for other users. This can be useful when wanting to send other metadata along with the usual message exchange.

Fields

recipient: Option<Uuid>

The recipient for this message. Will be sent and accepted by all if this is None.

data: Vec<u8>

The data the user wants to transmit to recipient.

Trait Implementations

impl Clone for MessageKind

fn clone(&self) -> MessageKind

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MessageKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MessageKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for MessageKind

fn eq(&self, other: &MessageKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for MessageKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for MessageKind

impl StructuralPartialEq for MessageKind