src/tools/disks/zpool_status.rs

   1 use anyhow::{bail, format_err, Error};
   2 use serde::{Deserialize, Serialize};
   3 use serde_json::Value;
   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]) -> Result<Value, Error> {
 182     indented_list_to_tree(vdev_list, |vdev| {
 183         let node = serde_json::to_value(vdev).unwrap();
 184         (node, vdev.lvl)
 185     })
 186 }
 187
 188 fn indented_list_to_tree<'a, T, F, I>(items: I, to_node: F) -> Result<Value, Error>
 189 where
 190     T: 'a,
 191     I: IntoIterator<Item = &'a T>,
 192     F: Fn(&T) -> (Value, u64),
 193 {
 194     use serde_json::Map;
 195     use std::mem::replace;
 196
 197     let mut stack = Vec::<(Map<String, Value>, u64, Vec<Value>)>::new(); // (node, level, children)
 198     // hold current node and the children of the current parent (as that's where we insert)
 199     let mut cur_node = Map::<String, Value>::new();
 200     let mut cur_level = 0;
 201     let mut children_of_parent = Vec::new();
 202
 203     cur_node.insert("name".to_string(), Value::String("root".to_string()));
 204
 205     for item in items {
 206         let (node, node_level) = to_node(&item);
 207         let vdev_level = 1 + node_level;
 208         let mut node = match node {
 209             Value::Object(map) => map,
 210             _ => bail!("to_node returned wrong type"),
 211         };
 212
 213         node.insert("leaf".to_string(), Value::Bool(true));
 214
 215         // if required, go back up (possibly multiple levels):
 216         while vdev_level < cur_level {
 217             children_of_parent.push(Value::Object(cur_node));
 218             let mut prev = // could be better with rust issue #372 resolved...
 219                 stack.pop().ok_or_else(|| format_err!("broken item list: stack underrun"))?;
 220             prev.0.insert("children".to_string(), Value::Array(children_of_parent));
 221             prev.0.insert("leaf".to_string(), Value::Bool(false));
 222             cur_node = prev.0;
 223             cur_level = prev.1;
 224             children_of_parent = prev.2;
 225
 226             if vdev_level > cur_level {
 227                 // when we encounter misimatching levels like "0, 2, 1" instead of "0, 1, 2, 1"
 228                 bail!("broken indentation between levels");
 229             }
 230         }
 231
 232         if vdev_level > cur_level {
 233             // indented further, push our current state and start a new "map"
 234             stack.push((
 235                 replace(&mut cur_node, node),
 236                 replace(&mut cur_level, vdev_level),
 237                 replace(&mut children_of_parent, Vec::new()),
 238             ));
 239         } else {
 240             // same indentation level, add to children of the previous level:
 241             children_of_parent.push(Value::Object(
 242                 replace(&mut cur_node, node),
 243             ));
 244         }
 245     }
 246
 247     while !stack.is_empty() {
 248         children_of_parent.push(Value::Object(cur_node));
 249         let mut prev = // could be better with rust issue #372 resolved...
 250             stack.pop().ok_or_else(|| format_err!("broken item list: stack underrun"))?;
 251         prev.0.insert("children".to_string(), Value::Array(children_of_parent));
 252         if !stack.is_empty() {
 253             prev.0.insert("leaf".to_string(), Value::Bool(false));
 254         }
 255         cur_node = prev.0;
 256         children_of_parent = prev.2;
 257     }
 258
 259     Ok(Value::Object(cur_node))
 260 }
 261
 262 #[test]
 263 fn test_vdev_list_to_tree() {
 264     const DEFAULT: ZFSPoolVDevState = ZFSPoolVDevState {
 265         name: String::new(),
 266         lvl: 0,
 267         state: None,
 268         read: None,
 269         write: None,
 270         cksum: None,
 271         msg: None,
 272     };
 273
 274     let input = vec![
 275         //ZFSPoolVDevState { name: "root".to_string(), lvl: 0, ..DEFAULT },
 276         ZFSPoolVDevState { name: "vdev1".to_string(), lvl: 1, ..DEFAULT },
 277         ZFSPoolVDevState { name: "vdev1-disk1".to_string(), lvl: 2, ..DEFAULT },
 278         ZFSPoolVDevState { name: "vdev1-disk2".to_string(), lvl: 2, ..DEFAULT },
 279         ZFSPoolVDevState { name: "vdev2".to_string(), lvl: 1, ..DEFAULT },
 280         ZFSPoolVDevState { name: "vdev2-g1".to_string(), lvl: 2, ..DEFAULT },
 281         ZFSPoolVDevState { name: "vdev2-g1-d1".to_string(), lvl: 3, ..DEFAULT },
 282         ZFSPoolVDevState { name: "vdev2-g1-d2".to_string(), lvl: 3, ..DEFAULT },
 283         ZFSPoolVDevState { name: "vdev2-g2".to_string(), lvl: 2, ..DEFAULT },
 284         ZFSPoolVDevState { name: "vdev3".to_string(), lvl: 1, ..DEFAULT },
 285         ZFSPoolVDevState { name: "vdev4".to_string(), lvl: 1, ..DEFAULT },
 286         ZFSPoolVDevState { name: "vdev4-g1".to_string(), lvl: 2, ..DEFAULT },
 287         ZFSPoolVDevState { name: "vdev4-g1-d1".to_string(), lvl: 3, ..DEFAULT },
 288         ZFSPoolVDevState { name: "vdev4-g1-d1-x1".to_string(), lvl: 4, ..DEFAULT },
 289         ZFSPoolVDevState { name: "vdev4-g2".to_string(), lvl: 2, ..DEFAULT }, // up by 2
 290     ];
 291
 292     const EXPECTED: &str = "{\
 293         \"children\":[{\
 294             \"children\":[{\
 295                 \"leaf\":true,\
 296                 \"lvl\":2,\"name\":\"vdev1-disk1\"\
 297             },{\
 298                 \"leaf\":true,\
 299                 \"lvl\":2,\"name\":\"vdev1-disk2\"\
 300             }],\
 301             \"leaf\":false,\
 302             \"lvl\":1,\"name\":\"vdev1\"\
 303         },{\
 304             \"children\":[{\
 305                 \"children\":[{\
 306                     \"leaf\":true,\
 307                     \"lvl\":3,\"name\":\"vdev2-g1-d1\"\
 308                 },{\
 309                     \"leaf\":true,\
 310                     \"lvl\":3,\"name\":\"vdev2-g1-d2\"\
 311                 }],\
 312                 \"leaf\":false,\
 313                 \"lvl\":2,\"name\":\"vdev2-g1\"\
 314             },{\
 315                 \"leaf\":true,\
 316                 \"lvl\":2,\"name\":\"vdev2-g2\"\
 317             }],\
 318             \"leaf\":false,\
 319             \"lvl\":1,\"name\":\"vdev2\"\
 320         },{\
 321             \"leaf\":true,\
 322             \"lvl\":1,\"name\":\"vdev3\"\
 323         },{\
 324             \"children\":[{\
 325                 \"children\":[{\
 326                     \"children\":[{\
 327                         \"leaf\":true,\
 328                         \"lvl\":4,\"name\":\"vdev4-g1-d1-x1\"\
 329                     }],\
 330                     \"leaf\":false,\
 331                     \"lvl\":3,\"name\":\"vdev4-g1-d1\"\
 332                 }],\
 333                 \"leaf\":false,\
 334                 \"lvl\":2,\"name\":\"vdev4-g1\"\
 335             },{\
 336                 \"leaf\":true,\
 337                 \"lvl\":2,\"name\":\"vdev4-g2\"\
 338             }],\
 339             \"leaf\":false,\
 340             \"lvl\":1,\"name\":\"vdev4\"\
 341         }],\
 342         \"name\":\"root\"\
 343     }";
 344     let expected: Value = serde_json::from_str(EXPECTED)
 345         .expect("failed to parse expected json value");
 346
 347     let tree = vdev_list_to_tree(&input)
 348         .expect("failed to turn valid vdev list into a tree");
 349     assert_eq!(tree, expected);
 350 }
 351
 352 pub fn zpool_status(pool: &str) -> Result<Vec<(String, String)>, Error> {
 353
 354     let mut command = std::process::Command::new("zpool");
 355     command.args(&["status", "-p", "-P", pool]);
 356
 357     let output = crate::tools::run_command(command, None)?;
 358
 359     parse_zpool_status(&output)
 360 }
 361
 362 #[test]
 363 fn test_zpool_status_parser() -> Result<(), Error> {
 364
 365     let output = r###"  pool: tank
 366  state: DEGRADED
 367 status: One or more devices could not be opened.  Sufficient replicas exist for
 368         the pool to continue functioning in a degraded state.
 369 action: Attach the missing device and online it using 'zpool online'.
 370    see: http://www.sun.com/msg/ZFS-8000-2Q
 371  scrub: none requested
 372 config:
 373
 374         NAME        STATE     READ WRITE CKSUM
 375         tank        DEGRADED     0     0     0
 376           mirror-0  DEGRADED     0     0     0
 377             c1t0d0  ONLINE       0     0     0
 378             c1t2d0  ONLINE       0     0     0
 379             c1t1d0  UNAVAIL      0     0     0  cannot open
 380           mirror-1  DEGRADED     0     0     0
 381         tank1       DEGRADED     0     0     0
 382         tank2       DEGRADED     0     0     0
 383
 384 errors: No known data errors
 385 "###;
 386
 387     let key_value_list = parse_zpool_status(&output)?;
 388     for (k, v) in key_value_list {
 389         println!("{} => {}", k,v);
 390         if k == "config" {
 391             let vdev_list = parse_zpool_status_config_tree(&v)?;
 392             let _tree = vdev_list_to_tree(&vdev_list);
 393             //println!("TREE1 {}", serde_json::to_string_pretty(&tree)?);
 394         }
 395     }
 396
 397     Ok(())
 398 }
 399
 400 #[test]
 401 fn test_zpool_status_parser2() -> Result<(), Error> {
 402
 403     // Note: this input create TABS
 404     let output = r###"  pool: btest
 405  state: ONLINE
 406   scan: none requested
 407 config:
 408
 409         NAME           STATE     READ WRITE CKSUM
 410         btest          ONLINE       0     0     0
 411           mirror-0     ONLINE       0     0     0
 412             /dev/sda1  ONLINE       0     0     0
 413             /dev/sda2  ONLINE       0     0     0
 414           mirror-1     ONLINE       0     0     0
 415             /dev/sda3  ONLINE       0     0     0
 416             /dev/sda4  ONLINE       0     0     0
 417         logs
 418           /dev/sda5    ONLINE       0     0     0
 419
 420 errors: No known data errors
 421 "###;
 422
 423     let key_value_list = parse_zpool_status(&output)?;
 424     for (k, v) in key_value_list {
 425         println!("{} => {}", k,v);
 426         if k == "config" {
 427             let vdev_list = parse_zpool_status_config_tree(&v)?;
 428             let _tree = vdev_list_to_tree(&vdev_list);
 429             //println!("TREE1 {}", serde_json::to_string_pretty(&tree)?);
 430         }
 431     }
 432
 433     Ok(())
 434 }