Refactor: remvoe Copy bound from NodeId

The `NodeId` type is currently defined as:

```rust
type NodeId: .. + Copy + .. + 'static;
```

This commit removes the `Copy` bound from `NodeId`.
This modification will allow the use of non-`Copy` types as `NodeId`,
providing greater flexibility for applications that prefer
variable-length strings or other non-`Copy` types for node
identification.

This change maintain compatibility by updating derived `Copy`
implementations with manual implementations:

```rust
// Before
#[derive(Copy...)]
pub struct LogId<NID: NodeId> {}

// After
impl<NID: Copy> Copy for LogId<NID> {}
```

- Fix: #1250

examples/memstore/src/log_store.rs

@@ -60,12 +60,12 @@ impl<C: RaftTypeConfig> LogStoreInner<C> {
  }
 
  async fn get_log_state(&mut self) -> Result<LogState<C>, StorageError<C>> {
- let last = self.log.iter().next_back().map(|(_, ent)| *ent.get_log_id());
+ let last = self.log.iter().next_back().map(|(_, ent)| ent.get_log_id().clone());
 
- let last_purged = self.last_purged_log_id;
+ let last_purged = self.last_purged_log_id.clone();
 
  let last = match last {
- None => last_purged,
+ None => last_purged.clone(),
  Some(x) => Some(x),
  };
 
@@ -81,16 +81,16 @@ impl<C: RaftTypeConfig> LogStoreInner<C> {
  }
 
  async fn read_committed(&mut self) -> Result<Option<LogId<C::NodeId>>, StorageError<C>> {
- Ok(self.committed)
+ Ok(self.committed.clone())
  }
 
  async fn save_vote(&mut self, vote: &Vote<C::NodeId>) -> Result<(), StorageError<C>> {
- self.vote = Some(*vote);
+ self.vote = Some(vote.clone());
  Ok(())
  }
 
  async fn read_vote(&mut self) -> Result<Option<Vote<C::NodeId>>, StorageError<C>> {
- Ok(self.vote)
+ Ok(self.vote.clone())
  }
 
  async fn append<I>(&mut self, entries: I, callback: IOFlushed<C>) -> Result<(), StorageError<C>>
@@ -116,8 +116,8 @@ impl<C: RaftTypeConfig> LogStoreInner<C> {
  async fn purge(&mut self, log_id: LogId<C::NodeId>) -> Result<(), StorageError<C>> {
  {
  let ld = &mut self.last_purged_log_id;
- assert!(*ld <= Some(log_id));
- *ld = Some(log_id);
+ assert!(ld.as_ref() <= Some(&log_id));
+ *ld = Some(log_id.clone());
  }
 
  {

openraft/src/core/heartbeat/event.rs

@@ -8,7 +8,7 @@ use crate::LogId;
 use crate::RaftTypeConfig;
 
 /// The information for broadcasting a heartbeat.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone)]
 #[derive(PartialEq, Eq)]
 pub struct HeartbeatEvent<C>
 where C: RaftTypeConfig

openraft/src/core/heartbeat/handle.rs

@@ -69,19 +69,19 @@ where C: RaftTypeConfig
  {
  for (target, node) in targets {
  tracing::debug!("id={} spawn HeartbeatWorker target={}", self.id, target);
- let network = network_factory.new_client(target, &node).await;
+ let network = network_factory.new_client(target.clone(), &node).await;
 
  let worker = HeartbeatWorker {
- id: self.id,
+ id: self.id.clone(),
  rx: self.rx.clone(),
  network,
- target,
+ target: target.clone(),
  node,
  config: self.config.clone(),
  tx_notification: tx_notification.clone(),
  };
 
- let span = tracing::span!(parent: &Span::current(), Level::DEBUG, "heartbeat", id=display(self.id), target=display(target));
+ let span = tracing::span!(parent: &Span::current(), Level::DEBUG, "heartbeat", id=display(&self.id), target=display(&target));
 
  let (tx_shutdown, rx_shutdown) = C::oneshot();
 

openraft/src/core/heartbeat/worker.rs

@@ -71,7 +71,7 @@ where
  _ = self.rx.changed().fuse() => {},
  }
 
- let heartbeat: Option<HeartbeatEvent<C>> = *self.rx.borrow_watched();
+ let heartbeat: Option<HeartbeatEvent<C>> = self.rx.borrow_watched().clone();
 
  // None is the initial value of the WatchReceiver, ignore it.
  let Some(heartbeat) = heartbeat else {
@@ -82,9 +82,9 @@ where
  let option = RPCOption::new(timeout);
 
  let payload = AppendEntriesRequest {
- vote: heartbeat.session_id.leader_vote.into_vote(),
+ vote: heartbeat.session_id.leader_vote.clone().into_vote(),
  prev_log_id: None,
- leader_commit: heartbeat.committed,
+ leader_commit: heartbeat.committed.clone(),
  entries: vec![],
  };
 
@@ -94,9 +94,9 @@ where
  match res {
  Ok(Ok(_)) => {
  let res = self.tx_notification.send(Notification::HeartbeatProgress {
- session_id: heartbeat.session_id,
+ session_id: heartbeat.session_id.clone(),
  sending_time: heartbeat.time,
- target: self.target,
+ target: self.target.clone(),
  });
 
  if res.is_err() {