scst 0.3.4

iscsi-scst user interface implemention by 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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use std::path::Path;

use anyhow::Result;
use regex::Regex;
use serde::{Deserialize, Serialize};

use crate::{Layer, read_dir, read_fl};
#[derive(Serialize, Deserialize, Debug, Default)]
pub struct IOStat {
    bidi_cmd_count: usize,
    bidi_io_count_kb: usize,
    bidi_unaligned_cmd_count: usize,

    write_cmd_count: usize,
    write_io_count_kb: usize,
    write_unaligned_cmd_count: usize,

    read_cmd_count: usize,
    read_io_count_kb: usize,
    read_unaligned_cmd_count: usize,
}

#[derive(Serialize, Deserialize, Debug, Default)]
pub struct Session {
    #[serde(skip)]
    root: String,
    sid: String,
    thread_pid: String,
    initiator_name: String,

    ips: Vec<SessionIP>,
}

impl Session {
    pub fn sid(&self) -> &str {
        &self.sid
    }

    pub fn thread_pid(&self) -> &str {
        &self.thread_pid
    }

    pub fn initiator_name(&self) -> &str {
        &self.initiator_name
    }

    pub fn ips(&self) -> Vec<&SessionIP> {
        self.ips.iter().collect()
    }

    pub fn io_stat(&self) -> Result<IOStat> {
        read_stat(self.root())
    }
}

impl Layer for Session {
    fn root(&self) -> &Path {
        Path::new(&self.root)
    }

    fn load<P: AsRef<Path>>(&mut self, root: P) -> Result<()> {
        let root_ref = root.as_ref();
        self.root = root_ref.to_string_lossy().to_string();
        self.sid = read_fl(root_ref.join("sid"))?;
        self.thread_pid = read_fl(root_ref.join("thread_pid"))?;
        self.initiator_name = read_fl(root_ref.join("initiator_name"))?;

        let ip_re = Regex::new(r"^(?:\d{1,3}\.){3}\d{1,3}$")?;
        self.ips = read_dir(root_ref)?
            .filter_map(|res| res.ok())
            .filter(|entry| {
                entry.path().is_dir() && ip_re.is_match(&entry.file_name().to_string_lossy())
            })
            .filter_map(|entry| {
                let mut ip = SessionIP::default();
                ip.load(entry.path()).ok();
                Some(ip)
            })
            .collect();

        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default)]
pub struct SessionIP {
    #[serde(skip)]
    root: String,
    cid: String,
    ip: String,
    state: String,
    target_ip: String,
}

impl SessionIP {
    pub fn cid(&self) -> &str {
        &self.cid
    }

    pub fn ip(&self) -> &str {
        &self.ip
    }

    pub fn state(&self) -> &str {
        &self.state
    }

    pub fn target_ip(&self) -> &str {
        &self.target_ip
    }
}

impl Layer for SessionIP {
    fn root(&self) -> &Path {
        Path::new(&self.root)
    }

    fn load<P: AsRef<Path>>(&mut self, root: P) -> Result<()> {
        let root_ref = root.as_ref();
        self.root = root_ref.to_string_lossy().to_string();
        self.cid = read_fl(root_ref.join("cid"))?;
        self.ip = read_fl(root_ref.join("ip"))?;
        self.state = read_fl(root_ref.join("state"))?;
        self.target_ip = read_fl(root_ref.join("target_ip"))?;

        Ok(())
    }
}

pub fn read_stat<S: AsRef<Path>>(root: S) -> Result<IOStat> {
    let root_ref = root.as_ref();
    let bidi_cmd_count = read_fl(root_ref.join("bidi_cmd_count"))?.parse::<usize>()?;
    let bidi_io_count_kb = read_fl(root_ref.join("bidi_io_count_kb"))?.parse::<usize>()?;
    let bidi_unaligned_cmd_count =
        read_fl(root_ref.join("bidi_unaligned_cmd_count"))?.parse::<usize>()?;
    let write_cmd_count = read_fl(root_ref.join("write_cmd_count"))?.parse::<usize>()?;
    let write_io_count_kb = read_fl(root_ref.join("write_io_count_kb"))?.parse::<usize>()?;
    let write_unaligned_cmd_count =
        read_fl(root_ref.join("write_unaligned_cmd_count"))?.parse::<usize>()?;
    let read_cmd_count = read_fl(root_ref.join("read_cmd_count"))?.parse::<usize>()?;
    let read_io_count_kb = read_fl(root_ref.join("read_io_count_kb"))?.parse::<usize>()?;
    let read_unaligned_cmd_count =
        read_fl(root_ref.join("read_unaligned_cmd_count"))?.parse::<usize>()?;

    let stat = IOStat {
        bidi_cmd_count,
        bidi_io_count_kb,
        bidi_unaligned_cmd_count,
        write_cmd_count,
        write_io_count_kb,
        write_unaligned_cmd_count,
        read_cmd_count,
        read_io_count_kb,
        read_unaligned_cmd_count,
    };

    Ok(stat)
}