rnacos 0.8.3

Nacos server re-implemented in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use std::collections::HashMap;
use std::sync::Arc;
use actix::prelude::*;
use serde::{Deserialize, Serialize};

pub struct SequenceManager{
    pub(crate) seq_info: HashMap<Arc<String>,u64>,
}

impl SequenceManager {

    fn get_last_id(&self,key:&Arc<String>) -> u64 {
        if let Some(v) = self.seq_info.get(key) {
            *v
        }
        else{
            0
        }
    }

    fn next_id(&mut self,key:Arc<String>,step:u64) -> u64 {
        let last_id = self.get_last_id(&key);
        let next_id = last_id + step;
        self.seq_info.insert(key,next_id);
        next_id
    }
}

impl Actor for SequenceManager {
    type Context = Context<Self>;

    fn started(&mut self, _ctx: &mut Self::Context) {
        log::info!("SequenceManager start")
    }
}

#[derive(Message, Clone, Debug, Serialize, Deserialize)]
#[rtype(result = "anyhow::Result<SequenceResult>")]
pub enum SequenceRequest{
    GetLastId(Arc<String>),
    GetNextId(Arc<String>,u64),
    SetLastId(Arc<String>,u64),
}

pub enum SequenceResult {
    LastId(u64),
    NextId(u64),
    None
}

impl Handler<SequenceRequest> for SequenceManager {
    type Result = anyhow::Result<SequenceResult>;

    fn handle(&mut self, msg: SequenceRequest, _ctx: &mut Self::Context) -> Self::Result {
        match msg {
            SequenceRequest::GetLastId(key) => {
                let v = self.get_last_id(&key);
                Ok(SequenceResult::LastId(v))
            }
            SequenceRequest::GetNextId(key, step) => {
                let v = self.next_id(key,step);
                Ok(SequenceResult::NextId(v))
            }
            SequenceRequest::SetLastId(key,last_id) => {
                self.seq_info.insert(key,last_id);
                Ok(SequenceResult::None)
            }
        }
    }
}

pub struct SequenceItem {
    cache_size: u64,
    batch_size: u64,
    last_id: u64,
    pub(crate) seq_addr: Addr<SequenceManager>,
    pub(crate) seq_key: Arc<String>,
    init: bool,
}

impl SequenceItem {
    pub fn new(seq_addr: Addr<SequenceManager>,seq_key: Arc<String>,batch_size:u64) -> Self {
        Self {
            seq_addr,
            seq_key,
            batch_size,
            cache_size:0,
            last_id:0,
            init: false,
        }
    }

    pub async fn init(&mut self) -> anyhow::Result<()> {
        let res = self.seq_addr.send(SequenceRequest::GetLastId(self.seq_key.clone())).await??;
        match res {
            SequenceResult::LastId(v) => {
                self.last_id=v;
                self.init=true;
            }
            _ => {}
        };
        Ok(())
    }

    pub fn set_table_last_id(&mut self, id: u64) -> anyhow::Result<()> {
        if (self.last_id + self.batch_size) < id {
            self.last_id = id;
            self.batch_size=0;
            self.init=true;
            self.seq_addr.do_send(SequenceRequest::SetLastId(self.seq_key.clone(),id));
        }
        Ok(())
    }

    pub fn next_id(&mut self) -> anyhow::Result<u64> {
        if !self.init {
            return Err(anyhow::anyhow!("The SequenceItem is not init,{}",&self.seq_key))
        }
        if self.cache_size == 0 {
            let cache_last_id = self.last_id + self.batch_size;
            self.seq_addr.do_send(SequenceRequest::SetLastId(self.seq_key.clone(),cache_last_id));
            self.cache_size = self.batch_size;
        }
        self.cache_size -= 1;
        self.last_id += 1;
        Ok(self.last_id)
    }
}