src/tools/disks/zpool_status.rs

   1 use anyhow::{Error};
   2 use serde_json::{json, Value};
   3 use ::serde::{Deserialize, Serialize};
   4
   5 use crate::tools::nom::{
   6     parse_complete, parse_error, parse_failure,
   7     multispace0, multispace1, notspace1, parse_u64, IResult,
   8 };
   9
  10 use nom::{
  11     bytes::complete::{tag, take_while, take_while1},
  12     combinator::{opt},
  13     sequence::{preceded},
  14     character::complete::{line_ending},
  15     multi::{many0,many1},
  16 };
  17
  18
  19 #[derive(Debug, Serialize, Deserialize)]
  20 pub struct ZFSPoolVDevState {
  21     pub name: String,
  22     pub lvl: u64,
  23     #[serde(skip_serializing_if="Option::is_none")]
  24     pub state: Option<String>,
  25     #[serde(skip_serializing_if="Option::is_none")]
  26     pub read: Option<u64>,
  27     #[serde(skip_serializing_if="Option::is_none")]
  28     pub write: Option<u64>,
  29     #[serde(skip_serializing_if="Option::is_none")]
  30     pub cksum: Option<u64>,
  31     #[serde(skip_serializing_if="Option::is_none")]
  32     pub msg: Option<String>,
  33 }
  34
  35 fn expand_tab_length(input: &str) -> usize {
  36     input.chars().map(|c| if c == '\t' { 8 } else { 1 }).sum()
  37 }
  38
  39 fn parse_zpool_status_vdev(i: &str) -> IResult<&str, ZFSPoolVDevState> {
  40
  41     let (n, indent) = multispace0(i)?;
  42
  43     let indent_len = expand_tab_length(indent);
  44
  45     if (indent_len & 1) != 0 {
  46         return Err(parse_failure(n, "wrong indent length"));
  47     }
  48     let i = n;
  49
  50     let indent_level = (indent_len as u64)/2;
  51
  52     let (i, vdev_name) =  notspace1(i)?;
  53
  54     if let Ok((n, _)) = preceded(multispace0, line_ending)(i) { // sepecial device
  55         let vdev = ZFSPoolVDevState {
  56             name: vdev_name.to_string(),
  57             lvl: indent_level,
  58             state: None,
  59             read: None,
  60             write: None,
  61             cksum: None,
  62             msg: None,
  63         };
  64         return Ok((n, vdev));
  65     }
  66
  67     let (i, state) = preceded(multispace1, notspace1)(i)?;
  68     let (i, read) = preceded(multispace1, parse_u64)(i)?;
  69     let (i, write) = preceded(multispace1, parse_u64)(i)?;
  70     let (i, cksum) = preceded(multispace1, parse_u64)(i)?;
  71     let (i, msg) = opt(preceded(multispace1, take_while(|c| c != '\n')))(i)?;
  72     let (i, _) = line_ending(i)?;
  73
  74     let vdev = ZFSPoolVDevState {
  75         name: vdev_name.to_string(),
  76         lvl: indent_level,
  77         state: Some(state.to_string()),
  78         read: Some(read),
  79         write: Some(write),
  80         cksum: Some(cksum),
  81         msg: msg.map(String::from),
  82     };
  83
  84     Ok((i, vdev))
  85 }
  86
  87 fn parse_zpool_status_tree(i: &str) -> IResult<&str, Vec<ZFSPoolVDevState>> {
  88
  89     // skip header
  90     let (i, _) = tag("NAME")(i)?;
  91     let (i, _) = multispace1(i)?;
  92     let (i, _) = tag("STATE")(i)?;
  93     let (i, _) = multispace1(i)?;
  94     let (i, _) = tag("READ")(i)?;
  95     let (i, _) = multispace1(i)?;
  96     let (i, _) = tag("WRITE")(i)?;
  97     let (i, _) = multispace1(i)?;
  98     let (i, _) = tag("CKSUM")(i)?;
  99     let (i, _) = line_ending(i)?;
 100
 101     // parse vdev list
 102     many1(parse_zpool_status_vdev)(i)
 103 }
 104
 105 fn space_indented_line(indent: usize) -> impl Fn(&str) -> IResult<&str, &str> {
 106     move |i| {
 107         let mut len = 0;
 108         let mut n = i;
 109         loop {
 110             if n.starts_with('\t') {
 111                 len += 8;
 112                 n = &n[1..];
 113             } else if n.starts_with(' ') {
 114                 len += 1;
 115                 n = &n[1..];
 116             } else {
 117                 break;
 118             }
 119             if len >= indent { break; }
 120         };
 121         if len != indent {
 122             return Err(parse_error(i, "not correctly indented"));
 123         }
 124
 125         take_while1(|c| c != '\n')(n)
 126     }
 127 }
 128
 129 fn parse_zpool_status_field(i: &str) -> IResult<&str, (String, String)> {
 130     let (i, prefix) = take_while1(|c| c != ':')(i)?;
 131     let (i, _) = tag(":")(i)?;
 132     let (i, mut value) = take_while(|c| c != '\n')(i)?;
 133     if value.starts_with(' ') { value = &value[1..]; }
 134
 135     let (mut i, _) = line_ending(i)?;
 136
 137     let field = prefix.trim().to_string();
 138
 139     let prefix_len = expand_tab_length(prefix);
 140
 141     let indent: usize = prefix_len + 2;
 142
 143     let parse_continuation = opt(space_indented_line(indent));
 144
 145     let mut value = value.to_string();
 146
 147     if field == "config" {
 148         let (n, _) = line_ending(i)?;
 149         i = n;
 150     }
 151
 152     loop {
 153         let (n, cont) = parse_continuation(i)?;
 154
 155         if let Some(cont) = cont {
 156             let (n, _) = line_ending(n)?;
 157             i = n;
 158             if !value.is_empty() { value.push('\n'); }
 159             value.push_str(cont);
 160         } else {
 161             if field == "config" {
 162                 let (n, _) = line_ending(i)?;
 163                 value.push('\n');
 164                 i = n;
 165             }
 166             break;
 167         }
 168     }
 169
 170     Ok((i, (field, value)))
 171 }
 172
 173 pub fn parse_zpool_status_config_tree(i: &str) -> Result<Vec<ZFSPoolVDevState>, Error> {
 174     parse_complete("zfs status config tree", i, parse_zpool_status_tree)
 175 }
 176
 177 fn parse_zpool_status(input: &str) -> Result<Vec<(String, String)>, Error> {
 178     parse_complete("zfs status output", &input, many0(parse_zpool_status_field))
 179 }
 180
 181 pub fn vdev_list_to_tree(vdev_list: &[ZFSPoolVDevState]) -> Value {
 182
 183     #[derive(Debug)]
 184     struct TreeNode<'a> {
 185         vdev: &'a ZFSPoolVDevState,
 186         children: Vec<usize>
 187     }
 188
 189     fn node_to_json(node_idx: usize, nodes: &[TreeNode]) -> Value {
 190         let node = &nodes[node_idx];
 191         let mut v = serde_json::to_value(node.vdev).unwrap();
 192         if node.children.is_empty() {
 193             v["leaf"] = true.into();
 194         } else {
 195             v["leaf"] = false.into();
 196             v["children"] = json!([]);
 197             for child in node.children .iter(){
 198                 let c = node_to_json(*child, nodes);
 199                 v["children"].as_array_mut().unwrap().push(c);
 200             }
 201         }
 202         v
 203     }
 204
 205     let mut nodes: Vec<TreeNode> = vdev_list.into_iter().map(|vdev| {
 206         TreeNode {
 207             vdev: vdev,
 208             children: Vec::new(),
 209         }
 210     }).collect();
 211
 212     let mut stack: Vec<usize> = Vec::new();
 213
 214     let mut root_children: Vec<usize> = Vec::new();
 215
 216     for idx in 0..nodes.len() {
 217
 218         if stack.is_empty() {
 219             root_children.push(idx);
 220             stack.push(idx);
 221             continue;
 222         }
 223
 224         let node_lvl = nodes[idx].vdev.lvl;
 225
 226         let stacked_node = &mut nodes[*(stack.last().unwrap())];
 227         let last_lvl = stacked_node.vdev.lvl;
 228
 229         if node_lvl > last_lvl {
 230             stacked_node.children.push(idx);
 231         } else if node_lvl == last_lvl {
 232             stack.pop();
 233             match stack.last() {
 234                 Some(parent) => nodes[*parent].children.push(idx),
 235                 None => root_children.push(idx),
 236             }
 237         } else {
 238             loop {
 239                 if stack.is_empty() {
 240                     root_children.push(idx);
 241                     break;
 242                 }
 243
 244                 let stacked_node = &mut nodes[*(stack.last().unwrap())];
 245                 if node_lvl <= stacked_node.vdev.lvl {
 246                     stack.pop();
 247                 } else {
 248                     stacked_node.children.push(idx);
 249                     break;
 250                 }
 251             }
 252         }
 253
 254         stack.push(idx);
 255     }
 256
 257     let mut result = json!({
 258         "name": "root",
 259         "children": json!([]),
 260     });
 261
 262     for child in root_children {
 263         let c = node_to_json(child, &nodes);
 264         result["children"].as_array_mut().unwrap().push(c);
 265     }
 266
 267     result
 268 }
 269
 270 pub fn zpool_status(pool: &str) -> Result<Vec<(String, String)>, Error> {
 271
 272     let mut command = std::process::Command::new("zpool");
 273     command.args(&["status", "-p", "-P", pool]);
 274
 275     let output = crate::tools::run_command(command, None)?;
 276
 277     parse_zpool_status(&output)
 278 }
 279
 280 #[test]
 281 fn test_zpool_status_parser() -> Result<(), Error> {
 282
 283     let output = r###"  pool: tank
 284  state: DEGRADED
 285 status: One or more devices could not be opened.  Sufficient replicas exist for
 286         the pool to continue functioning in a degraded state.
 287 action: Attach the missing device and online it using 'zpool online'.
 288    see: http://www.sun.com/msg/ZFS-8000-2Q
 289  scrub: none requested
 290 config:
 291
 292         NAME        STATE     READ WRITE CKSUM
 293         tank        DEGRADED     0     0     0
 294           mirror-0  DEGRADED     0     0     0
 295             c1t0d0  ONLINE       0     0     0
 296             c1t2d0  ONLINE       0     0     0
 297             c1t1d0  UNAVAIL      0     0     0  cannot open
 298           mirror-1  DEGRADED     0     0     0
 299         tank1       DEGRADED     0     0     0
 300         tank2       DEGRADED     0     0     0
 301
 302 errors: No known data errors
 303 "###;
 304
 305     let key_value_list = parse_zpool_status(&output)?;
 306     for (k, v) in key_value_list {
 307         println!("{} => {}", k,v);
 308         if k == "config" {
 309             let vdev_list = parse_zpool_status_config_tree(&v)?;
 310             let _tree = vdev_list_to_tree(&vdev_list);
 311             //println!("TREE1 {}", serde_json::to_string_pretty(&tree)?);
 312         }
 313     }
 314
 315     Ok(())
 316 }
 317
 318 #[test]
 319 fn test_zpool_status_parser2() -> Result<(), Error> {
 320
 321     // Note: this input create TABS
 322     let output = r###"  pool: btest
 323  state: ONLINE
 324   scan: none requested
 325 config:
 326
 327         NAME           STATE     READ WRITE CKSUM
 328         btest          ONLINE       0     0     0
 329           mirror-0     ONLINE       0     0     0
 330             /dev/sda1  ONLINE       0     0     0
 331             /dev/sda2  ONLINE       0     0     0
 332           mirror-1     ONLINE       0     0     0
 333             /dev/sda3  ONLINE       0     0     0
 334             /dev/sda4  ONLINE       0     0     0
 335         logs
 336           /dev/sda5    ONLINE       0     0     0
 337
 338 errors: No known data errors
 339 "###;
 340
 341     let key_value_list = parse_zpool_status(&output)?;
 342     for (k, v) in key_value_list {
 343         println!("{} => {}", k,v);
 344         if k == "config" {
 345             let vdev_list = parse_zpool_status_config_tree(&v)?;
 346             let _tree = vdev_list_to_tree(&vdev_list);
 347             //println!("TREE1 {}", serde_json::to_string_pretty(&tree)?);
 348         }
 349     }
 350
 351     Ok(())
 352 }