--- /dev/null
+use anyhow::{bail, Error};
+use serde_json::{json, Value};
+use ::serde::{Deserialize, Serialize};
+
+use nom::{
+ error::VerboseError,
+ bytes::complete::{tag, take_while, take_while1},
+ combinator::{map_res, all_consuming, recognize, opt},
+ sequence::{preceded},
+ character::complete::{digit1, line_ending},
+ multi::{many0},
+};
+
+type IResult<I, O, E = VerboseError<I>> = Result<(I, O), nom::Err<E>>;
+
+/// Recognizes zero or more spaces and tabs (but not carage returns or line feeds)
+fn multispace0(i: &str) -> IResult<&str, &str> {
+ take_while(|c| c == ' ' || c == '\t')(i)
+}
+
+// Recognizes one or more spaces and tabs (but not carage returns or line feeds)
+fn multispace1(i: &str) -> IResult<&str, &str> {
+ take_while1(|c| c == ' ' || c == '\t')(i)
+}
+
+/// Recognizes one or more non-whitespace-characters
+fn notspace1(i: &str) -> IResult<&str, &str> {
+ take_while1(|c| !(c == ' ' || c == '\t' || c == '\n'))(i)
+}
+
+fn parse_u64(i: &str) -> IResult<&str, u64> {
+ map_res(recognize(digit1), str::parse)(i)
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ZFSPoolVDevState {
+ pub name: String,
+ pub lvl: u64,
+ pub state: String,
+ pub read: u64,
+ pub write: u64,
+ pub cksum: u64,
+ #[serde(skip_serializing_if="Option::is_none")]
+ pub msg: Option<String>,
+}
+
+fn parse_zpool_status_vdev(i: &str) -> IResult<&str, ZFSPoolVDevState> {
+
+ let (i, indent) = multispace0(i)?;
+ let (i, vdev_name) = notspace1(i)?;
+ 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.len() as u64)/2,
+ state: state.to_string(),
+ read, write, 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
+ many0(parse_zpool_status_vdev)(i)
+}
+
+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 indent = (0..prefix.len()+2).fold(String::new(), |mut acc, _| { acc.push(' '); acc });
+
+ let parse_continuation = opt(preceded(tag(indent.as_str()), take_while1(|c| c != '\n')));
+
+ 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> {
+ match all_consuming(parse_zpool_status_tree)(&i) {
+ Err(nom::Err::Error(err)) |
+ Err(nom::Err::Failure(err)) => {
+ bail!("unable to parse zfs status config tree - {}", nom::error::convert_error(&i, err));
+ }
+ Err(err) => {
+ bail!("unable to parse zfs status config tree: {}", err);
+ }
+ Ok((_, data)) => Ok(data),
+ }
+}
+
+fn parse_zpool_status(i: &str) -> Result<Vec<(String, String)>, Error> {
+ match all_consuming(many0(parse_zpool_status_field))(i) {
+ Err(nom::Err::Error(err)) |
+ Err(nom::Err::Failure(err)) => {
+ bail!("unable to parse zfs status output - {}", nom::error::convert_error(i, err));
+ }
+ Err(err) => {
+ bail!("unable to parse zfs status output - {}", err);
+ }
+ Ok((_, data)) => Ok(data),
+ }
+}
+
+pub fn vdev_list_to_tree(vdev_list: &[ZFSPoolVDevState]) -> Value {
+
+ #[derive(Debug)]
+ struct TreeNode<'a> {
+ vdev: &'a ZFSPoolVDevState,
+ children: Vec<usize>
+ }
+
+ fn node_to_json(node_idx: usize, nodes: &[TreeNode]) -> Value {
+ let node = &nodes[node_idx];
+ let mut v = serde_json::to_value(node.vdev).unwrap();
+ if node.children.is_empty() {
+ v["leaf"] = true.into();
+ } else {
+ v["leaf"] = false.into();
+ v["children"] = json!([]);
+ for child in node.children .iter(){
+ let c = node_to_json(*child, nodes);
+ v["children"].as_array_mut().unwrap().push(c);
+ }
+ }
+ v
+ }
+
+ let mut nodes: Vec<TreeNode> = vdev_list.into_iter().map(|vdev| {
+ TreeNode {
+ vdev: vdev,
+ children: Vec::new(),
+ }
+ }).collect();
+
+ let mut stack: Vec<usize> = Vec::new();
+
+ let mut root_children: Vec<usize> = Vec::new();
+
+ for idx in 0..nodes.len() {
+
+ if stack.is_empty() {
+ root_children.push(idx);
+ stack.push(idx);
+ continue;
+ }
+
+ let node_lvl = nodes[idx].vdev.lvl;
+
+ let stacked_node = &mut nodes[*(stack.last().unwrap())];
+ let last_lvl = stacked_node.vdev.lvl;
+
+ if node_lvl > last_lvl {
+ stacked_node.children.push(idx);
+ } else if node_lvl == last_lvl {
+ stack.pop();
+ match stack.last() {
+ Some(parent) => nodes[*parent].children.push(idx),
+ None => root_children.push(idx),
+ }
+ } else {
+ loop {
+ if stack.is_empty() {
+ root_children.push(idx);
+ break;
+ }
+
+ let stacked_node = &mut nodes[*(stack.last().unwrap())];
+ if node_lvl <= stacked_node.vdev.lvl {
+ stack.pop();
+ } else {
+ stacked_node.children.push(idx);
+ break;
+ }
+ }
+ }
+
+ stack.push(idx);
+ }
+
+ let mut result = json!({
+ "name": "root",
+ "children": json!([]),
+ });
+
+ for child in root_children {
+ let c = node_to_json(child, &nodes);
+ result["children"].as_array_mut().unwrap().push(c);
+ }
+
+ result
+}
+
+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(())
+}
projects / proxmox-backup.git / commitdiff