Struct actix_raft::messages::ClientPayload

pub struct ClientPayload<D: AppData, R: AppDataResponse, E: AppError> { /* fields omitted */ }

A payload with an entry coming from a client request.

The entries of this payload will be appended to the Raft log and then applied to the Raft state machine according to the Raft protocol.

actix::Message

Applications using this Raft implementation are responsible for implementing the networking/transport layer which must move RPCs between nodes. Once the application instance recieves a Raft RPC, it must send the RPC to the Raft node via its actix::Addr and then return the response to the original sender.

The result type of calling the Raft actor with this message type is Result<ClientPayloadResponse, StorageError>. Applications built around this implementation of Raft will often need to perform their own custom logic in the storage layer and often times it is critical to be able to surface such errors to the application and its clients. To meet that end, ClientError allows for the communication of application specific errors.

Methods

impl<D: AppData, R: AppDataResponse, E: AppError> ClientPayload<D, R, E>

pub fn new(entry: EntryNormal<D>, response_mode: ResponseMode) -> Self

Create a new client payload instance with a normal entry type.

Trait Implementations

impl<D: Debug + AppData, R: Debug + AppDataResponse, E: Debug + AppError> Debug for ClientPayload<D, R, E>

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

Formats the value using the given formatter.

impl<'de, D: AppData, R: AppDataResponse, E: AppError> Deserialize<'de> for ClientPayload<D, R, E> where
    D: AppData, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<D: AppData, R: AppDataResponse, E: AppError, N: RaftNetwork<D>, S: RaftStorage<D, R, E>> Handler<ClientPayload<D, R, E>> for Raft<D, R, E, N, S>

type Result = ResponseActFuture<Self, ClientPayloadResponse<R>, ClientError<D, R, E>>

The type of value that this handler will return.

fn handle(
    &mut self,
    msg: ClientPayload<D, R, E>,
    _: &mut Self::Context
) -> Self::Result

Handle client requests.

impl<D: AppData, R: AppDataResponse, E: AppError> Message for ClientPayload<D, R, E>

type Result = Result<ClientPayloadResponse<R>, ClientError<D, R, E>>

The result type of this message.

impl<D: AppData, R: AppDataResponse, E: AppError> Serialize for ClientPayload<D, R, E> where
    D: AppData, 

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

Serialize this value into the given Serde serializer.