anor-api 0.1.1

Anor API Service
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

use anor_storage::storage::storage_item::StorageItem;
use anor_utils::config::Config;
use std::io::prelude::*;
use std::net::TcpStream;
use std::sync::Arc;

pub trait SocketClient {
    fn with_config(config: Arc<Config>) -> Self;
    fn connect(&mut self) -> std::io::Result<()>;
    fn disconnect(&mut self) -> std::io::Result<()>;
    fn insert(&self, storage_item: StorageItem);
    fn update(&mut self, key: &str, storage_item: StorageItem) -> std::io::Result<()>;
    fn get(&mut self, key: &str) -> std::io::Result<StorageItem>;
    fn remove(&self, key: &str) -> bool;
    fn keys(&self) -> Vec<String>;
    fn clear(&self);
    fn flush(&self);
}
pub struct StorageApiClient {
    stream: Option<TcpStream>,
    config: Arc<Config>,
}

impl SocketClient for StorageApiClient {
    fn with_config(config: Arc<Config>) -> Self {
        StorageApiClient {
            stream: None,
            config,
        }
    }

    fn connect(&mut self) -> std::io::Result<()> {
        assert!(self.config.remote.is_some());
        let config_remote = self.config.remote.as_ref().unwrap();
        assert!(!config_remote.nodes.is_empty());
        let remote_address = config_remote.nodes[0];

        let stream = TcpStream::connect(remote_address)?;

        let local_addr = stream.local_addr().unwrap();
        log::info!("connected to {} as {}", remote_address, local_addr);

        stream.set_nodelay(true).expect("set_nodelay call failed");

        self.stream = Some(stream);
        Ok(())
    }

    fn disconnect(&mut self) -> std::io::Result<()> {
        let stream = self.stream.as_mut().unwrap();
        stream.flush()?;
        self.stream = None;
        Ok(())
    }

/*
    fn set_item(&mut self, key: String) -> std::io::Result<()> {
        let stream = self.stream.as_mut().unwrap();
        stream.write_all(key.as_bytes())?;
        // stream.shutdown(std::net::Shutdown::Write).unwrap();
        stream.flush().unwrap();
        Ok(())
    }

    fn get_item(&mut self, _key: String) -> std::io::Result<()> {
        let stream = self.stream.as_mut().unwrap();
        let mut buf = [0; 128];
        stream.write_all(&buf)?;
        stream.read_exact(&mut buf)?;
        Ok(())
    }
*/

    fn insert(&self, storage_item: StorageItem) {
        todo!()
    }

    fn update(&mut self, key: &str, storage_item: StorageItem) -> std::io::Result<()> {
        todo!()
    }

    fn get(&mut self, key: &str) -> std::io::Result<StorageItem> {
        todo!()
    }

    fn remove(&self, key: &str) -> bool {
        todo!()
    }

    fn keys(&self) -> Vec<String> {
        vec![]
    }

    fn clear(&self) {
        todo!()
    }

    fn flush(&self) {
        todo!()
    }
}