| package utils |
| |
| import ( |
| "fmt" |
| "regexp" |
| "strings" |
| ) |
| |
| // ParsedOutput is a data structure that holds the parsed output |
| // of certain shell commands whose output takes the form of a |
| // table. |
| type ParsedOutput map[string][]string |
| |
| // ParseColumns parses command outputs which are in a column table. |
| // The function takes in an optional titles argument which specifies the |
| // columns to parse. If this argument is missing, then all columns are parsed. |
| // |
| // Eg, ParseColumns(["r b swpd buff", |
| // "10 0 14831128 0"], |
| // ["r", "b"]) = map[string][]string { |
| // "r": ["10"] |
| // "b": ["0"]} |
| // |
| // The output needs to have titles on all its columns else the function will |
| // return an error: |
| // |
| // Eg ParseColumns([" total used", |
| // "Mem: 14520 12", |
| // "Swap: 0 0"], |
| // ["total", "used"]) |
| // err : "row has different number of columns from header row" |
| // |
| // Some edge cases that will be parsed by this function include: |
| // |
| // rows with repeated headers, eg with the output of iostat: |
| // [] string {"Device tps kB_read/s kB_wrtn/s kB_read kB_wrtn", |
| // "vdb 2.39 57.39 69.83 855576 1041132", |
| // " ", |
| // "Device tps kB_read/s kB_wrtn/s kB_read kB_wrtn", |
| // " ", |
| // "Device tps kB_read/s kB_wrtn/s kB_read kB_wrtn"} => |
| // map[string][]string { |
| // "tps" : {"2.39"}, |
| // "kB_read/s" : {"57.39"}, |
| // ... |
| // } |
| func ParseColumns(rows []string, titles ...string) (map[string][]string, error) { |
| |
| parsedOutput := ParsedOutput{} |
| // maps each column title to its index eg columns["r"] = 0 wth vmstat. |
| columns := make(map[string]int) |
| // header saves the row that contains the titles |
| var header string |
| |
| for i, row := range rows { |
| // skip empty lines |
| if row = strings.TrimSpace(row); row == "" { |
| continue |
| } |
| tokens := strings.Fields(row) |
| |
| if i == 0 { |
| header = row |
| // if no titles were specified, use all of them |
| if len(titles) == 0 { |
| titles = tokens |
| } |
| // map column title to its index eg "r" : 0 with vmstat |
| for index, str := range tokens { |
| columns[str] = index |
| } |
| continue |
| } |
| // if a row is similar to the row with headers, ignore it |
| if row == header { |
| continue |
| } |
| // checks that number of columns in row is equal to number of column |
| // titles that were in header. Thus trying to parse the rows below |
| // will return an error here: |
| // " total used", (len 2) |
| // "Mem: 14520 12", (len 3) |
| // "Swap: 0 0",(len 3) |
| if len(columns) != len(tokens) { |
| err := "row has different number of columns from header row: \n" + |
| "header row: \n %q \n " + |
| "current row: \n %q" |
| return nil, fmt.Errorf(err, header, row) |
| } |
| |
| // loop over titles, get index of each title using map, |
| // use that to get the actual values, add title and its value(s) to |
| // parsedOutput. |
| for _, title := range titles { |
| index, ok := columns[title] |
| if !ok { |
| return nil, fmt.Errorf("unknown column title %q", title) |
| } |
| // Get the actual value from the row. Eg, if 'r' is the title and |
| // the lines to parse were below, then index = 0 and tokens[index] = 5 |
| // "r b swpd ..." |
| // "5 0 0 ..." |
| value := tokens[index] |
| parsedOutput[title] = append(parsedOutput[title], value) |
| } |
| } |
| return parsedOutput, nil |
| } |
| |
| // ParseRows parses command outputs which are in a row table. It takes in a |
| // string which specifies the delimiter that separates row title from values. |
| // The function does not support '\n' as a delimiter for now. It takes in an |
| // optional titles argument which specifies which rows to parse. |
| // |
| // Eg, ParseRows(["avg-cpu: %user %nice %system %iowait %steal %idle"], |
| // [avg-cpu]) = map[string][]string { |
| // avg-cpu: [%user, %nice, %system, %iowait, %steal, %idle]} |
| // |
| // If the wrong delimiter is passed in, the function returns an error: |
| // |
| // Eg [FAIL] ParseRows(["Device tps kB_read/s kB_wrtn/s", |
| // "vdb 1.13 19.48 33.61" |
| // "vda 0.02 0.86 0.00"], ":", ["vda"]) |
| // err: "failed to split row into row title and value" |
| // |
| // Some edge cases parsed by this function include: |
| // |
| // Rows whose delimiter have whitespaces around it. For example, |
| // [] string { "processor: 7", |
| // "CPU family: 6"} => |
| // map[string][]string { |
| // "processor" : {"7"} |
| // "cpu family" : {"6"} |
| // } |
| // |
| // OR |
| // |
| // [] string { "processor : 7", |
| // "cpu family : 6"} => |
| // map[string][]string { |
| // "processor" : {"7"} |
| // "cpu family" : {"6"} |
| // } |
| func ParseRows(lines []string, delim string, titles ...string) (map[string][]string, error) { |
| |
| parsedOutput := ParsedOutput{} |
| // rows maps each row title to their value(s) which is the rest of the row |
| // after delimiter |
| rows := make(map[string][]string) |
| |
| for _, line := range lines { |
| // skip empty lines |
| if line = strings.TrimSpace(line); line == "" { |
| continue |
| } |
| tokens := strings.Split(line, delim) |
| // if row did not split, return an error. |
| if len(tokens) == 1 { |
| err := "failed to split %q by the delimiter %q" |
| return nil, fmt.Errorf(err, line, delim) |
| } |
| // removes white space from title |
| header := strings.TrimSpace(tokens[0]) |
| value := tokens[1:] |
| // remove any extra white spaces in the values. Since values is a |
| // slice, first join all the strings into 1 and split it. For example, |
| // |
| // "Architecture: x86_64" will be split into ["Architecture", " x86_64"] |
| // To remove the whitespaces in [ " x86_64"], join slice into |
| // "x86_64" then split to make it a slice again ["x86_64"]. |
| tokens = strings.Fields(strings.Join(value, " ")) |
| rows[header] = tokens |
| } |
| |
| // if no titles were passed, use all the row titles. |
| if len(titles) == 0 { |
| for key := range rows { |
| titles = append(titles, key) |
| } |
| } |
| // loop over titles passed to function (or initiliazed above), get their |
| // values from the map, add to parsedOutput |
| for _, title := range titles { |
| var values []string |
| var ok bool |
| if values, ok = rows[title]; !ok { |
| return nil, fmt.Errorf("unknown row title %q", title) |
| } |
| parsedOutput[title] = values |
| } |
| return parsedOutput, nil |
| } |
| |
| // ParseRowsAndColumns parses command outputs that have row and column headers. |
| // It takes in an optional titles argument which specifies the row column |
| // combination to parse. If the titles argument is missing, then an empty map |
| // is returned. |
| // |
| // Eg, ParseRowsAndColumns([" total used free shared", |
| // "Mem: 14520 12 14482 0", |
| // "Swap: 0 0 0 "], |
| // ["Mem:used", "Swap:total"]) = map[string][]string { |
| // "Mem:used": ["12"] |
| // "Swap:total" : ["0"]} |
| // |
| // The titles should be in the format "row:column". Else, an error is returned: |
| // |
| // Eg [FAIL], ParseRowsAndColumns([" total used free shared", |
| // "Mem: 14520 12 14482 0", |
| // "Swap: 0 0 0 "], |
| // ["Mem+used", "Swap+total"]) |
| // err : "title string not well-formatted" |
| // |
| // Here are some edge cases parsed by the function: |
| // |
| // Rows with non-empty strings on row 0 column 0 E.g., with iostat (The default is |
| // an empty string on row 0 column 0): |
| // "Device tps kB_read/s kB_wrtn/s kB_read kB_wrtn", |
| // "vdb 0.74 10.39 23.23 859900 1922916", |
| // "vda 0.01 0.46 0.00 37829 0" |
| func ParseRowsAndColumns(lines []string, titles ...string) (map[string][]string, error) { |
| |
| parsedOutput := make(ParsedOutput) |
| // columns maps column title to its index eg columns["total"] = 0 wth free. |
| columns := make(map[string]int) |
| // titlesMap maps a row title to columns titles based on the titles passed |
| // into function: |
| // Eg "Mem" : ["total", "used"] for "Mem:total", "Mem:used" |
| // "Swap": ["total", "used"] for "Swap:total", "Swap:used" |
| titlesMap := make(map[string][]string) |
| |
| // loop over titles and split them by row and column titles. |
| for _, title := range titles { |
| headers := strings.Split(strings.Trim(title, ":"), ":") |
| if length := len(headers); length == 2 { |
| titlesMap[headers[0]] = append(titlesMap[headers[0]], headers[1]) |
| } else { |
| err := "title string not well-formed: each title should " + |
| "be in the form <row>:<column>, where row is the name " + |
| "of the row header and column is the name of the " + |
| "column header but got %q" |
| return nil, fmt.Errorf(err, title) |
| } |
| } |
| |
| var diff int |
| // rows stores each title in rows as key and the rest of the row as value. |
| rows := make(map[string][]string) |
| // loop over each row, mapping its title to the rest of the row (which is |
| // its value). |
| for i, line := range lines { |
| tokens := strings.Fields(line) |
| if len(tokens) == 0 { |
| continue |
| } |
| |
| if i == 0 { |
| // Looking at the edge case example above (iostat's output), since |
| // rows are split by whitespaces, the index of "tps" will be 1 |
| // after split. When the second row is split, and divided into row |
| // title and values, the following will result: |
| // "vdb" : {"0.74", "10.39", "23.23", "859900", "1922916"} |
| // |
| // Index of column titles will be used to access values from slice |
| // above. Index of "tps" = 1 and index 1 of slice above is 10.39 |
| // (which is incorrect). The correct value is in index 0 (which we |
| // we would have gotten if col 0 row 0 was empty). To deal with this, |
| // if column 0 of row 0 is a non-empty string, then 1 is subtracted |
| // from the actual index of the rest of the colums in row 0. Thus the |
| // need for the diff variable. |
| exp := regexp.MustCompile(`\s*`) |
| chars := exp.Split(line, -1) |
| if chars[0] != "" { |
| diff = -1 |
| } |
| // map header name to its index |
| for index, str := range tokens { |
| columns[str] = index + diff |
| } |
| continue |
| } |
| rHeader := strings.Trim(tokens[0], ":") |
| //everything to the right of the row title is its value |
| rows[rHeader] = tokens[1:] |
| } |
| |
| // loop over the titlesMap and use the row titles to access all |
| // the values for that row. From those values, access the columns |
| // we're interested in |
| // Eg with free's output below: |
| // " total used free", (len 3) |
| // "Mem: 14520 13 14482", (len 4) |
| // "Swap: 0 0 0" (len 4) |
| // |
| // Assuming the titlesMap is: "Mem" : {"total", "used"} |
| // "Swap" : {"total", "used"} |
| // |
| // When we loop over the map above, we first access the values for the |
| // the row titles: "Mem": {"14520", "13", "14482"} |
| // "Swap": {"0", "0", "0"} |
| // Then to access the values we're interested eg "Mem:total", use the index of |
| // the column title "total" to index into the slice of values, i.e, |
| // columns["total"] = 0 which corresponds to "14520" in {"14520", "13", "14482"} |
| for rowTitle, colTitles := range titlesMap { |
| values := rows[rowTitle] |
| for _, columnTitle := range colTitles { |
| |
| index := columns[columnTitle] |
| value := values[index] |
| // combine the row and column title again when adding to the parsed |
| // output map. |
| combined := rowTitle + ":" + columnTitle |
| parsedOutput[combined] = append(parsedOutput[combined], value) |
| } |
| } |
| return parsedOutput, nil |
| } |
