mod.rs

#[tracing::instrument(level = "trace", skip(self, entries))]
    async fn apply_to_state_machine(
        &self,
        entries: &[&Entry<StateMachineRequest>],
    ) -> Result<Vec<ExampleResponse>, StorageError> {
        let mut res = Vec::with_capacity(entries.len());

        let mut state_machine = self.state_machine.write().await;

        for entry in entries {
            tracing::debug!(%entry.log_id, "replicate to state machine");

            state_machine.last_applied_log = Some(entry.log_id);

            match entry.payload {
                EntryPayload::Blank => res.push(ExampleResponse { value: None }),
                EntryPayload::Normal(ref req) => match req {
                    StateMachineRequest::AddUser { key, value } => {
                      state_machine.data.insert(key.clone(), value.clone());
                      res.push(ExampleResponse {
                        value: Some(value.clone()),
                      })
                    }
                    StateMachineRequest::AddNode { id, addr } => {
                      state_machine.nodes.insert(*id, addr.clone());
                      res.push(ExampleResponse {
                        value: Some(format!("cluster: {:?}", state_machine.nodes)),
                      })
                    }
                    StateMachineRequest::Batch { entries } => {
                      for entry in entries {
                        match entry {
                          StateMachineRequest::AddUser { key, value } => {
                            state_machine.data.insert(key.clone(), value.clone());
                          }
                          StateMachineRequest::AddNode { id, addr } => {
                            state_machine.nodes.insert(*id, addr.clone());
                          }
                          _ => {}
                        }
                      }
                      res.push(ExampleResponse {
                        value: Some("success".to_string()),
                      })
                    }
                },
                EntryPayload::Membership(ref mem) => {
                    state_machine.last_membership = Some(EffectiveMembership {
                        log_id: entry.log_id,
                        membership: mem.clone(),
                    });
                    res.push(ExampleResponse { value: None })
                }
            };
        }
        Ok(res)
    }