src/tools/disks/zpool_status.rs

   1 use std::mem::replace;
   2
   3 use anyhow::{bail, Error};
   4 use serde::{Deserialize, Serialize};
   5 use serde_json::{Map, Value};
   6
   7 use crate::tools::nom::{
   8     parse_complete, parse_error, parse_failure,
   9     multispace0, multispace1, notspace1, parse_u64, IResult,
  10 };
  11
  12 use nom::{
  13     bytes::complete::{tag, take_while, take_while1},
  14     combinator::{opt},
  15     sequence::{preceded},
  16     character::complete::{line_ending},
  17     multi::{many0,many1},
  18 };
  19
  20
  21 #[derive(Debug, Serialize, Deserialize)]
  22 pub struct ZFSPoolVDevState {
  23     pub name: String,
  24     pub lvl: u64,
  25     #[serde(skip_serializing_if="Option::is_none")]
  26     pub state: Option<String>,
  27     #[serde(skip_serializing_if="Option::is_none")]
  28     pub read: Option<u64>,
  29     #[serde(skip_serializing_if="Option::is_none")]
  30     pub write: Option<u64>,
  31     #[serde(skip_serializing_if="Option::is_none")]
  32     pub cksum: Option<u64>,
  33     #[serde(skip_serializing_if="Option::is_none")]
  34     pub msg: Option<String>,
  35 }
  36
  37 fn expand_tab_length(input: &str) -> usize {
  38     input.chars().map(|c| if c == '\t' { 8 } else { 1 }).sum()
  39 }
  40
  41 fn parse_zpool_status_vdev(i: &str) -> IResult<&str, ZFSPoolVDevState> {
  42
  43     let (n, indent) = multispace0(i)?;
  44
  45     let indent_len = expand_tab_length(indent);
  46
  47     if (indent_len & 1) != 0 {
  48         return Err(parse_failure(n, "wrong indent length"));
  49     }
  50     let i = n;
  51
  52     let indent_level = (indent_len as u64)/2;
  53
  54     let (i, vdev_name) =  notspace1(i)?;
  55
  56     if let Ok((n, _)) = preceded(multispace0, line_ending)(i) { // special device
  57         let vdev = ZFSPoolVDevState {
  58             name: vdev_name.to_string(),
  59             lvl: indent_level,
  60             state: None,
  61             read: None,
  62             write: None,
  63             cksum: None,
  64             msg: None,
  65         };
  66         return Ok((n, vdev));
  67     }
  68
  69     let (i, state) = preceded(multispace1, notspace1)(i)?;
  70     if let Ok((n, _)) = preceded(multispace0, line_ending)(i) { // spares
  71         let vdev = ZFSPoolVDevState {
  72             name: vdev_name.to_string(),
  73             lvl: indent_level,
  74             state: Some(state.to_string()),
  75             read: None,
  76             write: None,
  77             cksum: None,
  78             msg: None,
  79         };
  80         return Ok((n, vdev));
  81     }
  82
  83     let (i, read) = preceded(multispace1, parse_u64)(i)?;
  84     let (i, write) = preceded(multispace1, parse_u64)(i)?;
  85     let (i, cksum) = preceded(multispace1, parse_u64)(i)?;
  86     let (i, msg) = opt(preceded(multispace1, take_while(|c| c != '\n')))(i)?;
  87     let (i, _) = line_ending(i)?;
  88
  89     let vdev = ZFSPoolVDevState {
  90         name: vdev_name.to_string(),
  91         lvl: indent_level,
  92         state: Some(state.to_string()),
  93         read: Some(read),
  94         write: Some(write),
  95         cksum: Some(cksum),
  96         msg: msg.map(String::from),
  97     };
  98
  99     Ok((i, vdev))
 100 }
 101
 102 fn parse_zpool_status_tree(i: &str) -> IResult<&str, Vec<ZFSPoolVDevState>> {
 103
 104     // skip header
 105     let (i, _) = tag("NAME")(i)?;
 106     let (i, _) = multispace1(i)?;
 107     let (i, _) = tag("STATE")(i)?;
 108     let (i, _) = multispace1(i)?;
 109     let (i, _) = tag("READ")(i)?;
 110     let (i, _) = multispace1(i)?;
 111     let (i, _) = tag("WRITE")(i)?;
 112     let (i, _) = multispace1(i)?;
 113     let (i, _) = tag("CKSUM")(i)?;
 114     let (i, _) = line_ending(i)?;
 115
 116     // parse vdev list
 117     many1(parse_zpool_status_vdev)(i)
 118 }
 119
 120 fn space_indented_line(indent: usize) -> impl Fn(&str) -> IResult<&str, &str> {
 121     move |i| {
 122         let mut len = 0;
 123         let mut n = i;
 124         loop {
 125             if n.starts_with('\t') {
 126                 len += 8;
 127             } else if n.starts_with(' ') {
 128                 len += 1;
 129             } else {
 130                 break;
 131             }
 132             n = &n[1..];
 133             if len >= indent { break; }
 134         };
 135         if len != indent {
 136             return Err(parse_error(i, "not correctly indented"));
 137         }
 138
 139         take_while1(|c| c != '\n')(n)
 140     }
 141 }
 142
 143 fn parse_zpool_status_field(i: &str) -> IResult<&str, (String, String)> {
 144     let (i, prefix) = take_while1(|c| c != ':')(i)?;
 145     let (i, _) = tag(":")(i)?;
 146     let (i, mut value) = take_while(|c| c != '\n')(i)?;
 147     if value.starts_with(' ') { value = &value[1..]; }
 148
 149     let (mut i, _) = line_ending(i)?;
 150
 151     let field = prefix.trim().to_string();
 152
 153     let prefix_len = expand_tab_length(prefix);
 154
 155     let indent: usize = prefix_len + 2;
 156
 157     let parse_continuation = opt(space_indented_line(indent));
 158
 159     let mut value = value.to_string();
 160
 161     if field == "config" {
 162         let (n, _) = line_ending(i)?;
 163         i = n;
 164     }
 165
 166     loop {
 167         let (n, cont) = parse_continuation(i)?;
 168
 169         if let Some(cont) = cont {
 170             let (n, _) = line_ending(n)?;
 171             i = n;
 172             if !value.is_empty() { value.push('\n'); }
 173             value.push_str(cont);
 174         } else {
 175             if field == "config" {
 176                 let (n, _) = line_ending(i)?;
 177                 value.push('\n');
 178                 i = n;
 179             }
 180             break;
 181         }
 182     }
 183
 184     Ok((i, (field, value)))
 185 }
 186
 187 pub fn parse_zpool_status_config_tree(i: &str) -> Result<Vec<ZFSPoolVDevState>, Error> {
 188     parse_complete("zfs status config tree", i, parse_zpool_status_tree)
 189 }
 190
 191 fn parse_zpool_status(input: &str) -> Result<Vec<(String, String)>, Error> {
 192     parse_complete("zfs status output", &input, many0(parse_zpool_status_field))
 193 }
 194
 195 pub fn vdev_list_to_tree(vdev_list: &[ZFSPoolVDevState]) -> Result<Value, Error> {
 196     indented_list_to_tree(vdev_list, |vdev| {
 197         let node = serde_json::to_value(vdev).unwrap();
 198         (node, vdev.lvl)
 199     })
 200 }
 201
 202 fn indented_list_to_tree<'a, T, F, I>(items: I, to_node: F) -> Result<Value, Error>
 203 where
 204     T: 'a,
 205     I: IntoIterator<Item = &'a T>,
 206     F: Fn(&T) -> (Value, u64),
 207 {
 208     struct StackItem {
 209         node: Map<String, Value>,
 210         level: u64,
 211         children_of_parent: Vec<Value>,
 212     }
 213
 214     let mut stack = Vec::<StackItem>::new();
 215     // hold current node and the children of the current parent (as that's where we insert)
 216     let mut cur = StackItem {
 217         node: Map::<String, Value>::new(),
 218         level: 0,
 219         children_of_parent: Vec::new(),
 220     };
 221
 222     for item in items {
 223         let (node, node_level) = to_node(&item);
 224         let vdev_level = 1 + node_level;
 225         let mut node = match node {
 226             Value::Object(map) => map,
 227             _ => bail!("to_node returned wrong type"),
 228         };
 229
 230         node.insert("leaf".to_string(), Value::Bool(true));
 231
 232         // if required, go back up (possibly multiple levels):
 233         while vdev_level < cur.level {
 234             cur.children_of_parent.push(Value::Object(cur.node));
 235             let mut parent = stack.pop().unwrap();
 236             parent.node.insert("children".to_string(), Value::Array(cur.children_of_parent));
 237             parent.node.insert("leaf".to_string(), Value::Bool(false));
 238             cur = parent;
 239
 240             if vdev_level > cur.level {
 241                 // when we encounter misimatching levels like "0, 2, 1" instead of "0, 1, 2, 1"
 242                 bail!("broken indentation between levels");
 243             }
 244         }
 245
 246         if vdev_level > cur.level {
 247             // indented further, push our current state and start a new "map"
 248             stack.push(StackItem {
 249                 node: replace(&mut cur.node, node),
 250                 level: replace(&mut cur.level, vdev_level),
 251                 children_of_parent: replace(&mut cur.children_of_parent, Vec::new()),
 252             });
 253         } else {
 254             // same indentation level, add to children of the previous level:
 255             cur.children_of_parent.push(Value::Object(
 256                 replace(&mut cur.node, node),
 257             ));
 258         }
 259     }
 260
 261     while !stack.is_empty() {
 262         cur.children_of_parent.push(Value::Object(cur.node));
 263         let mut parent = stack.pop().unwrap();
 264         parent.node.insert("children".to_string(), Value::Array(cur.children_of_parent));
 265         parent.node.insert("leaf".to_string(), Value::Bool(false));
 266         cur = parent;
 267     }
 268
 269     Ok(Value::Object(cur.node))
 270 }
 271
 272 #[test]
 273 fn test_vdev_list_to_tree() {
 274     const DEFAULT: ZFSPoolVDevState = ZFSPoolVDevState {
 275         name: String::new(),
 276         lvl: 0,
 277         state: None,
 278         read: None,
 279         write: None,
 280         cksum: None,
 281         msg: None,
 282     };
 283
 284     let input = vec![
 285         //ZFSPoolVDevState { name: "root".to_string(), lvl: 0, ..DEFAULT },
 286         ZFSPoolVDevState { name: "vdev1".to_string(), lvl: 1, ..DEFAULT },
 287         ZFSPoolVDevState { name: "vdev1-disk1".to_string(), lvl: 2, ..DEFAULT },
 288         ZFSPoolVDevState { name: "vdev1-disk2".to_string(), lvl: 2, ..DEFAULT },
 289         ZFSPoolVDevState { name: "vdev2".to_string(), lvl: 1, ..DEFAULT },
 290         ZFSPoolVDevState { name: "vdev2-g1".to_string(), lvl: 2, ..DEFAULT },
 291         ZFSPoolVDevState { name: "vdev2-g1-d1".to_string(), lvl: 3, ..DEFAULT },
 292         ZFSPoolVDevState { name: "vdev2-g1-d2".to_string(), lvl: 3, ..DEFAULT },
 293         ZFSPoolVDevState { name: "vdev2-g2".to_string(), lvl: 2, ..DEFAULT },
 294         ZFSPoolVDevState { name: "vdev3".to_string(), lvl: 1, ..DEFAULT },
 295         ZFSPoolVDevState { name: "vdev4".to_string(), lvl: 1, ..DEFAULT },
 296         ZFSPoolVDevState { name: "vdev4-g1".to_string(), lvl: 2, ..DEFAULT },
 297         ZFSPoolVDevState { name: "vdev4-g1-d1".to_string(), lvl: 3, ..DEFAULT },
 298         ZFSPoolVDevState { name: "vdev4-g1-d1-x1".to_string(), lvl: 4, ..DEFAULT },
 299         ZFSPoolVDevState { name: "vdev4-g2".to_string(), lvl: 2, ..DEFAULT }, // up by 2
 300     ];
 301
 302     const EXPECTED: &str = "{\
 303         \"children\":[{\
 304             \"children\":[{\
 305                 \"leaf\":true,\
 306                 \"lvl\":2,\"name\":\"vdev1-disk1\"\
 307             },{\
 308                 \"leaf\":true,\
 309                 \"lvl\":2,\"name\":\"vdev1-disk2\"\
 310             }],\
 311             \"leaf\":false,\
 312             \"lvl\":1,\"name\":\"vdev1\"\
 313         },{\
 314             \"children\":[{\
 315                 \"children\":[{\
 316                     \"leaf\":true,\
 317                     \"lvl\":3,\"name\":\"vdev2-g1-d1\"\
 318                 },{\
 319                     \"leaf\":true,\
 320                     \"lvl\":3,\"name\":\"vdev2-g1-d2\"\
 321                 }],\
 322                 \"leaf\":false,\
 323                 \"lvl\":2,\"name\":\"vdev2-g1\"\
 324             },{\
 325                 \"leaf\":true,\
 326                 \"lvl\":2,\"name\":\"vdev2-g2\"\
 327             }],\
 328             \"leaf\":false,\
 329             \"lvl\":1,\"name\":\"vdev2\"\
 330         },{\
 331             \"leaf\":true,\
 332             \"lvl\":1,\"name\":\"vdev3\"\
 333         },{\
 334             \"children\":[{\
 335                 \"children\":[{\
 336                     \"children\":[{\
 337                         \"leaf\":true,\
 338                         \"lvl\":4,\"name\":\"vdev4-g1-d1-x1\"\
 339                     }],\
 340                     \"leaf\":false,\
 341                     \"lvl\":3,\"name\":\"vdev4-g1-d1\"\
 342                 }],\
 343                 \"leaf\":false,\
 344                 \"lvl\":2,\"name\":\"vdev4-g1\"\
 345             },{\
 346                 \"leaf\":true,\
 347                 \"lvl\":2,\"name\":\"vdev4-g2\"\
 348             }],\
 349             \"leaf\":false,\
 350             \"lvl\":1,\"name\":\"vdev4\"\
 351         }],\
 352         \"leaf\":false\
 353    }";
 354     let expected: Value = serde_json::from_str(EXPECTED)
 355         .expect("failed to parse expected json value");
 356
 357     let tree = vdev_list_to_tree(&input)
 358         .expect("failed to turn valid vdev list into a tree");
 359     assert_eq!(tree, expected);
 360 }
 361
 362 pub fn zpool_status(pool: &str) -> Result<Vec<(String, String)>, Error> {
 363
 364     let mut command = std::process::Command::new("zpool");
 365     command.args(&["status", "-p", "-P", pool]);
 366
 367     let output = pbs_tools::run_command(command, None)?;
 368
 369     parse_zpool_status(&output)
 370 }
 371
 372 #[cfg(test)]
 373 fn test_parse(output: &str) -> Result<(), Error> {
 374     let mut found_config = false;
 375
 376     for (k, v) in parse_zpool_status(&output)? {
 377         println!("<{}> => '{}'", k, v);
 378         if k == "config" {
 379             let vdev_list = parse_zpool_status_config_tree(&v)?;
 380             let _tree = vdev_list_to_tree(&vdev_list);
 381             found_config = true;
 382         }
 383     }
 384     if !found_config {
 385         bail!("got zpool status without config key");
 386     }
 387
 388     Ok(())
 389 }
 390
 391 #[test]
 392 fn test_zpool_status_parser() -> Result<(), Error> {
 393
 394     let output = r###"  pool: tank
 395  state: DEGRADED
 396 status: One or more devices could not be opened.  Sufficient replicas exist for
 397         the pool to continue functioning in a degraded state.
 398 action: Attach the missing device and online it using 'zpool online'.
 399    see: http://www.sun.com/msg/ZFS-8000-2Q
 400  scrub: none requested
 401 config:
 402
 403         NAME        STATE     READ WRITE CKSUM
 404         tank        DEGRADED     0     0     0
 405           mirror-0  DEGRADED     0     0     0
 406             c1t0d0  ONLINE       0     0     0
 407             c1t2d0  ONLINE       0     0     0
 408             c1t1d0  UNAVAIL      0     0     0  cannot open
 409           mirror-1  DEGRADED     0     0     0
 410         tank1       DEGRADED     0     0     0
 411         tank2       DEGRADED     0     0     0
 412
 413 errors: No known data errors
 414 "###;
 415
 416     test_parse(output)
 417 }
 418
 419 #[test]
 420 fn test_zpool_status_parser2() -> Result<(), Error> {
 421
 422     // Note: this input create TABS
 423     let output = r###"  pool: btest
 424  state: ONLINE
 425   scan: none requested
 426 config:
 427
 428         NAME           STATE     READ WRITE CKSUM
 429         btest          ONLINE       0     0     0
 430           mirror-0     ONLINE       0     0     0
 431             /dev/sda1  ONLINE       0     0     0
 432             /dev/sda2  ONLINE       0     0     0
 433           mirror-1     ONLINE       0     0     0
 434             /dev/sda3  ONLINE       0     0     0
 435             /dev/sda4  ONLINE       0     0     0
 436         logs
 437           /dev/sda5    ONLINE       0     0     0
 438
 439 errors: No known data errors
 440 "###;
 441     test_parse(output)
 442 }
 443
 444 #[test]
 445 fn test_zpool_status_parser3() -> Result<(), Error> {
 446
 447     let output = r###"  pool: bt-est
 448  state: ONLINE
 449   scan: none requested
 450 config:
 451
 452         NAME           STATE     READ WRITE CKSUM
 453         bt-est          ONLINE       0     0     0
 454           mirror-0     ONLINE       0     0     0
 455             /dev/sda1  ONLINE       0     0     0
 456             /dev/sda2  ONLINE       0     0     0
 457           mirror-1     ONLINE       0     0     0
 458             /dev/sda3  ONLINE       0     0     0
 459             /dev/sda4  ONLINE       0     0     0
 460         logs
 461           /dev/sda5    ONLINE       0     0     0
 462
 463 errors: No known data errors
 464 "###;
 465
 466     test_parse(output)
 467 }
 468
 469 #[test]
 470 fn test_zpool_status_parser_spares() -> Result<(), Error> {
 471
 472     let output = r###"  pool: tank
 473  state: ONLINE
 474   scan: none requested
 475 config:
 476
 477         NAME           STATE     READ WRITE CKSUM
 478         tank          ONLINE       0     0     0
 479           mirror-0     ONLINE       0     0     0
 480             /dev/sda1  ONLINE       0     0     0
 481             /dev/sda2  ONLINE       0     0     0
 482           mirror-1     ONLINE       0     0     0
 483             /dev/sda3  ONLINE       0     0     0
 484             /dev/sda4  ONLINE       0     0     0
 485         logs
 486           /dev/sda5    ONLINE       0     0     0
 487         spares
 488           /dev/sdb     AVAIL
 489           /dev/sdc     AVAIL
 490
 491 errors: No known data errors
 492 "###;
 493
 494     test_parse(output)
 495 }