How to parse result from ovs-vsctl get interface <interface> statistics

Result example:

{collisions=0, rx_bytes=258, rx_crc_err=0, rx_dropped=0, rx_errors=0, rx_frame_err=0, rx_over_err=0, rx_packets=3, tx_bytes=648, tx_dropped=0, tx_errors=0, tx_packets=8}

This format is like JSON, but not JSON.

Is there an easy way to parse this into map[string]int? Like json.Unmarshal(data, &value).

If that transport format is not recursively defined, i.e. a key cannot start a sub-structure, then its language is regular. As such, you can soundly parse it with Go's standard regexp package:

Playground link.

package main

import (
	"fmt"
	"regexp"
	"strconv"
)

const data = `{collisions=0, rx_bytes=258, rx_crc_err=0, rx_dropped=0, rx_errors=0, rx_frame_err=0, rx_over_err=0, rx_packets=3, tx_bytes=648, tx_dropped=0, tx_errors=0, tx_packets=8}`

const regex = `([a-z_]+)=([0-9]+)`

func main() {
	ms := regexp.MustCompile(regex).FindAllStringSubmatch(data, -1)

	vs := make(map[string]int)

	for _, m := range ms {
		v, _ := strconv.Atoi(m[2])
		vs[m[1]] = v
	}

	fmt.Printf("%#v\n", vs)
}

Regexp by @thwd is an elegant solution.

You can get a more efficient solution by using strings.Split() to split by comma-space (", ") to get the pairs, and then split again by the equal sign ("=") to get the key-value pairs. After that you just need to put these into a map:

func Parse(s string) (m map[string]int, err error) {
    if len(s) < 2 || s[0] != '{' || s[len(s)-1] != '}' {
        return nil, fmt.Errorf("Invalid input, no wrapping brackets!")
    }

    m = make(map[string]int)
    for _, v := range strings.Split(s[1:len(s)-1], ", ") {
        parts := strings.Split(v, "=")
        if len(parts) != 2 {
            return nil, fmt.Errorf("Equal sign not found in: %s", v)
        }
        if m[parts[0]], err = strconv.Atoi(parts[1]); err != nil {
            return nil, err
        }
    }
    return
}

Using it:

s := "{collisions=0, rx_bytes=258, ...}"

fmt.Println(Parse(s))

Try it on the <kbd>Go Playground</kbd>.

Note: If performance is important, this can be improved by not using strings.Split() in the outer loop, but instead searching for the comma "manually" and maintaining indices, and only "take out" substrings that represent actual keys and values (but this solution would be more complex).

Another solution...

...but this option is much slower so it is only viable if performance is not a key requirement: you can turn your input string into a valid JSON format and after that you can use json.Unmarshal(). Error checks omitted:

s := "{collisions=0, rx_bytes=258, ...}"

// Turn into valid JSON:
s = strings.Replace(s, `=`, `":`, -1)
s = strings.Replace(s, `, `, `, "`, -1)
s = strings.Replace(s, `{`, `{"`, -1)

// And now simply unmarshal:
m := make(map[string]int)
json.Unmarshal([]byte(s), &m)
fmt.Println(m)

Advantage of this solution is that this also works if the destination value you unmarhsal into is a struct:

// Unmarshal into a struct (you don't have to care about all fields)
st := struct {
    Collisions int `json:"collisions"`
    Rx_bytes   int `json:"rx_bytes"`
}{}
json.Unmarshal([]byte(s), &st)
fmt.Printf("%+v\n", st)

Try these on the <kbd>Go Playground</kbd>.