Change Id format

[akiradeveloper]

Raft node can be identified by its address because it is unique. This is why lol defines Id = Address.

My idea is change this to Id = (Label, Address). This change will make it easy to

1. Read the log: If address is used as Id in the log, it is difficult to read. If it is shorter like "ND1", it will become easy to identify.
2. Match different Ids: You may make a Raft cluster on k8s. How to match Pod's label and lol's node? If we use the same label in both layers, matching becomes easy.

Also, as the label is shorter than Address it is much efficient to compare two labels instead of addresses. This will be a bit of optimization.

[akiradeveloper]

If we do Multi-Raft #131 we should add raft-group-id to the log like

ND1(gid=3): Send RPC to ND5(gid=3)

This should be also considered.

[akiradeveloper]

idea:

• Id will be changed to (Id, Url) where Id is unique u64. (Uniqueness is guaranteed by the admin)
• In initialization, we set only (Id).
• In AddServer, we give (Id, Url) so receiver can get binding Id -> Url.
• In RemoveServer, we give (Id) so receiver can remove binding Id -> Url if exists.
• The log format wil be change to "ND{Id}> xxxx".

[akiradeveloper]

Just to avoid deep copy, some library is making such effort. https://sixtyfps.io/releases/0.1.1/docs/rust/sixtyfps/struct.sharedstring

[akiradeveloper]

In 0.8, I will use tonic::transport::Uri as Id. (https://docs.rs/tonic/0.5.2/tonic/transport/struct.Uri.html)

pub struct Id(Arc<tonic::transport::Uri>);

Id should be both Serialize and Deserialize to be saved on RaftStorage and vice versa.

[akiradeveloper]

This requires Uri to be Ser/Der. Since the class is from http crate. This serde implementation can be used https://crates.io/crates/http-serde

Implement the same thing by myself is not hard but not worthy to maintain.

[akiradeveloper]

Quick experiment.

diff --git a/lol-core/Cargo.toml b/lol-core/Cargo.toml
index 4587bcf..7199fe0 100644
--- a/lol-core/Cargo.toml
+++ b/lol-core/Cargo.toml
@@ -23,7 +23,8 @@ rand = "0.8"
 async-trait = "0.1"
 async-stream = "0.3"
 futures = "0.3"
-serde = { version = "1.0", features = ["derive"] }
+serde = { version = "1.0", features = ["derive", "rc"] }
+http-serde = "1.0.3"
 serde_bytes = "0.11"
 bincode = "1.3"
 log = "0.4"
diff --git a/lol-core/src/connection.rs b/lol-core/src/connection.rs
index 3b0cfa7..af8c404 100644
--- a/lol-core/src/connection.rs
+++ b/lol-core/src/connection.rs
@@ -40,7 +40,8 @@ pub mod gateway {
                 core: true,
                 message: core_message::Req::serialize(&req),
             };
-            let endpoint = Endpoint::from_shared(id)?;
+            // let endpoint = Endpoint::from_shared(id)?;
+            let endpoint: Endpoint = id.into();
             let mut conn = RaftClient::connect(endpoint).await?;
             let res = conn.request_process(req).await?.into_inner();
             let res = core_message::Rep::deserialize(&res.message).unwrap();
diff --git a/lol-core/src/lib.rs b/lol-core/src/lib.rs
index eaa3212..ee94a3a 100644
--- a/lol-core/src/lib.rs
+++ b/lol-core/src/lib.rs
@@ -124,14 +124,23 @@ impl PartialEq for Clock {
     }
 }

-/// Unique identifier of a Raft node.
-///
-/// Id must satisfy these two conditions:
-/// 1. Id can identify a node in the cluster.
-/// 2. any client or other nodes in the cluster can access this node by the Id.
-///
-/// Typically, the form of Id is (http|https)://(hostname|ip):port
-pub type Id = String;
+#[derive(serde::Serialize, serde::Deserialize, Clone, PartialEq, Eq, Hash, Debug)]
+struct UriWrapper(
+    #[serde(with = "http_serde::uri")]
+    tonic::transport::Uri
+);
+#[derive(serde::Serialize, serde::Deserialize, Clone, PartialEq, Eq, Hash, Debug)]
+pub struct Id(Arc<UriWrapper>);
+impl From<tonic::transport::Uri> for Id {
+    fn from(x: tonic::transport::Uri) -> Id {
+        unimplemented!()
+    }
+}
+impl From<Id> for tonic::transport::Endpoint {
+    fn from(x: Id) -> tonic::transport::Endpoint {
+        unimplemented!()
+    }
+}

[akiradeveloper]

Cloning Uri seems to be light-weight.

#[derive(Clone)]
pub struct Uri {
    scheme: Scheme,
    authority: Authority,
    path_and_query: PathAndQuery,
}

Because Scheme isn't a string but a enum type

#[derive(Copy, Clone, Debug)]
pub(super) enum Protocol {
    Http,
    Https,
}

impl Scheme {
    /// HTTP protocol scheme
    pub const HTTP: Scheme = Scheme {
        inner: Scheme2::Standard(Protocol::Http),
    };

    /// HTTP protocol over TLS.
    pub const HTTPS: Scheme = Scheme {
        inner: Scheme2::Standard(Protocol::Https),
    };

And Authority part is backed by a ByteStr

/// Represents the authority component of a URI.
#[derive(Clone)]
pub struct Authority {
    pub(super) data: ByteStr,
}

which is backed by Bytes.

pub(crate) struct ByteStr {
    // Invariant: bytes contains valid UTF-8
    bytes: Bytes,
}

PathAndQuery is a pair of ByteStr and a u16.

#[derive(Clone)]
pub struct PathAndQuery {
    pub(super) data: ByteStr,
    pub(super) query: u16,
}

Using ByteStr in part must be a developer's intention to make cloning cheap. So we shouldn't wrap it in Arc but use it directly. This way, the link in document will be directed to http's.