435 lines
14 KiB
Rust
435 lines
14 KiB
Rust
use anyhow::{bail, format_err, Error};
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_json::Value;
|
|
|
|
use crate::tools::nom::{
|
|
parse_complete, parse_error, parse_failure,
|
|
multispace0, multispace1, notspace1, parse_u64, IResult,
|
|
};
|
|
|
|
use nom::{
|
|
bytes::complete::{tag, take_while, take_while1},
|
|
combinator::{opt},
|
|
sequence::{preceded},
|
|
character::complete::{line_ending},
|
|
multi::{many0,many1},
|
|
};
|
|
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub struct ZFSPoolVDevState {
|
|
pub name: String,
|
|
pub lvl: u64,
|
|
#[serde(skip_serializing_if="Option::is_none")]
|
|
pub state: Option<String>,
|
|
#[serde(skip_serializing_if="Option::is_none")]
|
|
pub read: Option<u64>,
|
|
#[serde(skip_serializing_if="Option::is_none")]
|
|
pub write: Option<u64>,
|
|
#[serde(skip_serializing_if="Option::is_none")]
|
|
pub cksum: Option<u64>,
|
|
#[serde(skip_serializing_if="Option::is_none")]
|
|
pub msg: Option<String>,
|
|
}
|
|
|
|
fn expand_tab_length(input: &str) -> usize {
|
|
input.chars().map(|c| if c == '\t' { 8 } else { 1 }).sum()
|
|
}
|
|
|
|
fn parse_zpool_status_vdev(i: &str) -> IResult<&str, ZFSPoolVDevState> {
|
|
|
|
let (n, indent) = multispace0(i)?;
|
|
|
|
let indent_len = expand_tab_length(indent);
|
|
|
|
if (indent_len & 1) != 0 {
|
|
return Err(parse_failure(n, "wrong indent length"));
|
|
}
|
|
let i = n;
|
|
|
|
let indent_level = (indent_len as u64)/2;
|
|
|
|
let (i, vdev_name) = notspace1(i)?;
|
|
|
|
if let Ok((n, _)) = preceded(multispace0, line_ending)(i) { // sepecial device
|
|
let vdev = ZFSPoolVDevState {
|
|
name: vdev_name.to_string(),
|
|
lvl: indent_level,
|
|
state: None,
|
|
read: None,
|
|
write: None,
|
|
cksum: None,
|
|
msg: None,
|
|
};
|
|
return Ok((n, vdev));
|
|
}
|
|
|
|
let (i, state) = preceded(multispace1, notspace1)(i)?;
|
|
let (i, read) = preceded(multispace1, parse_u64)(i)?;
|
|
let (i, write) = preceded(multispace1, parse_u64)(i)?;
|
|
let (i, cksum) = preceded(multispace1, parse_u64)(i)?;
|
|
let (i, msg) = opt(preceded(multispace1, take_while(|c| c != '\n')))(i)?;
|
|
let (i, _) = line_ending(i)?;
|
|
|
|
let vdev = ZFSPoolVDevState {
|
|
name: vdev_name.to_string(),
|
|
lvl: indent_level,
|
|
state: Some(state.to_string()),
|
|
read: Some(read),
|
|
write: Some(write),
|
|
cksum: Some(cksum),
|
|
msg: msg.map(String::from),
|
|
};
|
|
|
|
Ok((i, vdev))
|
|
}
|
|
|
|
fn parse_zpool_status_tree(i: &str) -> IResult<&str, Vec<ZFSPoolVDevState>> {
|
|
|
|
// skip header
|
|
let (i, _) = tag("NAME")(i)?;
|
|
let (i, _) = multispace1(i)?;
|
|
let (i, _) = tag("STATE")(i)?;
|
|
let (i, _) = multispace1(i)?;
|
|
let (i, _) = tag("READ")(i)?;
|
|
let (i, _) = multispace1(i)?;
|
|
let (i, _) = tag("WRITE")(i)?;
|
|
let (i, _) = multispace1(i)?;
|
|
let (i, _) = tag("CKSUM")(i)?;
|
|
let (i, _) = line_ending(i)?;
|
|
|
|
// parse vdev list
|
|
many1(parse_zpool_status_vdev)(i)
|
|
}
|
|
|
|
fn space_indented_line(indent: usize) -> impl Fn(&str) -> IResult<&str, &str> {
|
|
move |i| {
|
|
let mut len = 0;
|
|
let mut n = i;
|
|
loop {
|
|
if n.starts_with('\t') {
|
|
len += 8;
|
|
n = &n[1..];
|
|
} else if n.starts_with(' ') {
|
|
len += 1;
|
|
n = &n[1..];
|
|
} else {
|
|
break;
|
|
}
|
|
if len >= indent { break; }
|
|
};
|
|
if len != indent {
|
|
return Err(parse_error(i, "not correctly indented"));
|
|
}
|
|
|
|
take_while1(|c| c != '\n')(n)
|
|
}
|
|
}
|
|
|
|
fn parse_zpool_status_field(i: &str) -> IResult<&str, (String, String)> {
|
|
let (i, prefix) = take_while1(|c| c != ':')(i)?;
|
|
let (i, _) = tag(":")(i)?;
|
|
let (i, mut value) = take_while(|c| c != '\n')(i)?;
|
|
if value.starts_with(' ') { value = &value[1..]; }
|
|
|
|
let (mut i, _) = line_ending(i)?;
|
|
|
|
let field = prefix.trim().to_string();
|
|
|
|
let prefix_len = expand_tab_length(prefix);
|
|
|
|
let indent: usize = prefix_len + 2;
|
|
|
|
let parse_continuation = opt(space_indented_line(indent));
|
|
|
|
let mut value = value.to_string();
|
|
|
|
if field == "config" {
|
|
let (n, _) = line_ending(i)?;
|
|
i = n;
|
|
}
|
|
|
|
loop {
|
|
let (n, cont) = parse_continuation(i)?;
|
|
|
|
if let Some(cont) = cont {
|
|
let (n, _) = line_ending(n)?;
|
|
i = n;
|
|
if !value.is_empty() { value.push('\n'); }
|
|
value.push_str(cont);
|
|
} else {
|
|
if field == "config" {
|
|
let (n, _) = line_ending(i)?;
|
|
value.push('\n');
|
|
i = n;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
Ok((i, (field, value)))
|
|
}
|
|
|
|
pub fn parse_zpool_status_config_tree(i: &str) -> Result<Vec<ZFSPoolVDevState>, Error> {
|
|
parse_complete("zfs status config tree", i, parse_zpool_status_tree)
|
|
}
|
|
|
|
fn parse_zpool_status(input: &str) -> Result<Vec<(String, String)>, Error> {
|
|
parse_complete("zfs status output", &input, many0(parse_zpool_status_field))
|
|
}
|
|
|
|
pub fn vdev_list_to_tree(vdev_list: &[ZFSPoolVDevState]) -> Result<Value, Error> {
|
|
indented_list_to_tree(vdev_list, |vdev| {
|
|
let node = serde_json::to_value(vdev).unwrap();
|
|
(node, vdev.lvl)
|
|
})
|
|
}
|
|
|
|
fn indented_list_to_tree<'a, T, F, I>(items: I, to_node: F) -> Result<Value, Error>
|
|
where
|
|
T: 'a,
|
|
I: IntoIterator<Item = &'a T>,
|
|
F: Fn(&T) -> (Value, u64),
|
|
{
|
|
use serde_json::Map;
|
|
use std::mem::replace;
|
|
|
|
let mut stack = Vec::<(Map<String, Value>, u64, Vec<Value>)>::new(); // (node, level, children)
|
|
// hold current node and the children of the current parent (as that's where we insert)
|
|
let mut cur_node = Map::<String, Value>::new();
|
|
let mut cur_level = 0;
|
|
let mut children_of_parent = Vec::new();
|
|
|
|
cur_node.insert("name".to_string(), Value::String("root".to_string()));
|
|
|
|
for item in items {
|
|
let (node, node_level) = to_node(&item);
|
|
let vdev_level = 1 + node_level;
|
|
let mut node = match node {
|
|
Value::Object(map) => map,
|
|
_ => bail!("to_node returned wrong type"),
|
|
};
|
|
|
|
node.insert("leaf".to_string(), Value::Bool(true));
|
|
|
|
// if required, go back up (possibly multiple levels):
|
|
while vdev_level < cur_level {
|
|
children_of_parent.push(Value::Object(cur_node));
|
|
let mut prev = // could be better with rust issue #372 resolved...
|
|
stack.pop().ok_or_else(|| format_err!("broken item list: stack underrun"))?;
|
|
prev.0.insert("children".to_string(), Value::Array(children_of_parent));
|
|
prev.0.insert("leaf".to_string(), Value::Bool(false));
|
|
cur_node = prev.0;
|
|
cur_level = prev.1;
|
|
children_of_parent = prev.2;
|
|
|
|
if vdev_level > cur_level {
|
|
// when we encounter misimatching levels like "0, 2, 1" instead of "0, 1, 2, 1"
|
|
bail!("broken indentation between levels");
|
|
}
|
|
}
|
|
|
|
if vdev_level > cur_level {
|
|
// indented further, push our current state and start a new "map"
|
|
stack.push((
|
|
replace(&mut cur_node, node),
|
|
replace(&mut cur_level, vdev_level),
|
|
replace(&mut children_of_parent, Vec::new()),
|
|
));
|
|
} else {
|
|
// same indentation level, add to children of the previous level:
|
|
children_of_parent.push(Value::Object(
|
|
replace(&mut cur_node, node),
|
|
));
|
|
}
|
|
}
|
|
|
|
while !stack.is_empty() {
|
|
children_of_parent.push(Value::Object(cur_node));
|
|
let mut prev = // could be better with rust issue #372 resolved...
|
|
stack.pop().ok_or_else(|| format_err!("broken item list: stack underrun"))?;
|
|
prev.0.insert("children".to_string(), Value::Array(children_of_parent));
|
|
if !stack.is_empty() {
|
|
prev.0.insert("leaf".to_string(), Value::Bool(false));
|
|
}
|
|
cur_node = prev.0;
|
|
children_of_parent = prev.2;
|
|
}
|
|
|
|
Ok(Value::Object(cur_node))
|
|
}
|
|
|
|
#[test]
|
|
fn test_vdev_list_to_tree() {
|
|
const DEFAULT: ZFSPoolVDevState = ZFSPoolVDevState {
|
|
name: String::new(),
|
|
lvl: 0,
|
|
state: None,
|
|
read: None,
|
|
write: None,
|
|
cksum: None,
|
|
msg: None,
|
|
};
|
|
|
|
let input = vec![
|
|
//ZFSPoolVDevState { name: "root".to_string(), lvl: 0, ..DEFAULT },
|
|
ZFSPoolVDevState { name: "vdev1".to_string(), lvl: 1, ..DEFAULT },
|
|
ZFSPoolVDevState { name: "vdev1-disk1".to_string(), lvl: 2, ..DEFAULT },
|
|
ZFSPoolVDevState { name: "vdev1-disk2".to_string(), lvl: 2, ..DEFAULT },
|
|
ZFSPoolVDevState { name: "vdev2".to_string(), lvl: 1, ..DEFAULT },
|
|
ZFSPoolVDevState { name: "vdev2-g1".to_string(), lvl: 2, ..DEFAULT },
|
|
ZFSPoolVDevState { name: "vdev2-g1-d1".to_string(), lvl: 3, ..DEFAULT },
|
|
ZFSPoolVDevState { name: "vdev2-g1-d2".to_string(), lvl: 3, ..DEFAULT },
|
|
ZFSPoolVDevState { name: "vdev2-g2".to_string(), lvl: 2, ..DEFAULT },
|
|
ZFSPoolVDevState { name: "vdev3".to_string(), lvl: 1, ..DEFAULT },
|
|
ZFSPoolVDevState { name: "vdev4".to_string(), lvl: 1, ..DEFAULT },
|
|
ZFSPoolVDevState { name: "vdev4-g1".to_string(), lvl: 2, ..DEFAULT },
|
|
ZFSPoolVDevState { name: "vdev4-g1-d1".to_string(), lvl: 3, ..DEFAULT },
|
|
ZFSPoolVDevState { name: "vdev4-g1-d1-x1".to_string(), lvl: 4, ..DEFAULT },
|
|
ZFSPoolVDevState { name: "vdev4-g2".to_string(), lvl: 2, ..DEFAULT }, // up by 2
|
|
];
|
|
|
|
const EXPECTED: &str = "{\
|
|
\"children\":[{\
|
|
\"children\":[{\
|
|
\"leaf\":true,\
|
|
\"lvl\":2,\"name\":\"vdev1-disk1\"\
|
|
},{\
|
|
\"leaf\":true,\
|
|
\"lvl\":2,\"name\":\"vdev1-disk2\"\
|
|
}],\
|
|
\"leaf\":false,\
|
|
\"lvl\":1,\"name\":\"vdev1\"\
|
|
},{\
|
|
\"children\":[{\
|
|
\"children\":[{\
|
|
\"leaf\":true,\
|
|
\"lvl\":3,\"name\":\"vdev2-g1-d1\"\
|
|
},{\
|
|
\"leaf\":true,\
|
|
\"lvl\":3,\"name\":\"vdev2-g1-d2\"\
|
|
}],\
|
|
\"leaf\":false,\
|
|
\"lvl\":2,\"name\":\"vdev2-g1\"\
|
|
},{\
|
|
\"leaf\":true,\
|
|
\"lvl\":2,\"name\":\"vdev2-g2\"\
|
|
}],\
|
|
\"leaf\":false,\
|
|
\"lvl\":1,\"name\":\"vdev2\"\
|
|
},{\
|
|
\"leaf\":true,\
|
|
\"lvl\":1,\"name\":\"vdev3\"\
|
|
},{\
|
|
\"children\":[{\
|
|
\"children\":[{\
|
|
\"children\":[{\
|
|
\"leaf\":true,\
|
|
\"lvl\":4,\"name\":\"vdev4-g1-d1-x1\"\
|
|
}],\
|
|
\"leaf\":false,\
|
|
\"lvl\":3,\"name\":\"vdev4-g1-d1\"\
|
|
}],\
|
|
\"leaf\":false,\
|
|
\"lvl\":2,\"name\":\"vdev4-g1\"\
|
|
},{\
|
|
\"leaf\":true,\
|
|
\"lvl\":2,\"name\":\"vdev4-g2\"\
|
|
}],\
|
|
\"leaf\":false,\
|
|
\"lvl\":1,\"name\":\"vdev4\"\
|
|
}],\
|
|
\"name\":\"root\"\
|
|
}";
|
|
let expected: Value = serde_json::from_str(EXPECTED)
|
|
.expect("failed to parse expected json value");
|
|
|
|
let tree = vdev_list_to_tree(&input)
|
|
.expect("failed to turn valid vdev list into a tree");
|
|
assert_eq!(tree, expected);
|
|
}
|
|
|
|
pub fn zpool_status(pool: &str) -> Result<Vec<(String, String)>, Error> {
|
|
|
|
let mut command = std::process::Command::new("zpool");
|
|
command.args(&["status", "-p", "-P", pool]);
|
|
|
|
let output = crate::tools::run_command(command, None)?;
|
|
|
|
parse_zpool_status(&output)
|
|
}
|
|
|
|
#[test]
|
|
fn test_zpool_status_parser() -> Result<(), Error> {
|
|
|
|
let output = r###" pool: tank
|
|
state: DEGRADED
|
|
status: One or more devices could not be opened. Sufficient replicas exist for
|
|
the pool to continue functioning in a degraded state.
|
|
action: Attach the missing device and online it using 'zpool online'.
|
|
see: http://www.sun.com/msg/ZFS-8000-2Q
|
|
scrub: none requested
|
|
config:
|
|
|
|
NAME STATE READ WRITE CKSUM
|
|
tank DEGRADED 0 0 0
|
|
mirror-0 DEGRADED 0 0 0
|
|
c1t0d0 ONLINE 0 0 0
|
|
c1t2d0 ONLINE 0 0 0
|
|
c1t1d0 UNAVAIL 0 0 0 cannot open
|
|
mirror-1 DEGRADED 0 0 0
|
|
tank1 DEGRADED 0 0 0
|
|
tank2 DEGRADED 0 0 0
|
|
|
|
errors: No known data errors
|
|
"###;
|
|
|
|
let key_value_list = parse_zpool_status(&output)?;
|
|
for (k, v) in key_value_list {
|
|
println!("{} => {}", k,v);
|
|
if k == "config" {
|
|
let vdev_list = parse_zpool_status_config_tree(&v)?;
|
|
let _tree = vdev_list_to_tree(&vdev_list);
|
|
//println!("TREE1 {}", serde_json::to_string_pretty(&tree)?);
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_zpool_status_parser2() -> Result<(), Error> {
|
|
|
|
// Note: this input create TABS
|
|
let output = r###" pool: btest
|
|
state: ONLINE
|
|
scan: none requested
|
|
config:
|
|
|
|
NAME STATE READ WRITE CKSUM
|
|
btest ONLINE 0 0 0
|
|
mirror-0 ONLINE 0 0 0
|
|
/dev/sda1 ONLINE 0 0 0
|
|
/dev/sda2 ONLINE 0 0 0
|
|
mirror-1 ONLINE 0 0 0
|
|
/dev/sda3 ONLINE 0 0 0
|
|
/dev/sda4 ONLINE 0 0 0
|
|
logs
|
|
/dev/sda5 ONLINE 0 0 0
|
|
|
|
errors: No known data errors
|
|
"###;
|
|
|
|
let key_value_list = parse_zpool_status(&output)?;
|
|
for (k, v) in key_value_list {
|
|
println!("{} => {}", k,v);
|
|
if k == "config" {
|
|
let vdev_list = parse_zpool_status_config_tree(&v)?;
|
|
let _tree = vdev_list_to_tree(&vdev_list);
|
|
//println!("TREE1 {}", serde_json::to_string_pretty(&tree)?);
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|