FLW code uses regex that are too strict/don't match newer zookeeper versions

[ilikeorangutans]

This breaks with newer versions of zookeeper. We might need to loosen the regex or simplify the code.

zk/flw.go

Lines 23 to 127 in 80ada0a

	func FLWSrvr(servers []string, timeout time.Duration) ([]*ServerStats, bool) {
	// different parts of the regular expression that are required to parse the srvr output
	const (
	zrVer = `^Zookeeper version: ([A-Za-z0-9\.\-]+), built on (\d\d/\d\d/\d\d\d\d \d\d:\d\d [A-Za-z0-9:\+\-]+)`
	zrLat = `^Latency min/avg/max: (\d+)/([0-9.]+)/(\d+)`
	zrNet = `^Received: (\d+).*\n^Sent: (\d+).*\n^Connections: (\d+).*\n^Outstanding: (\d+)`
	zrState = `^Zxid: (0x[A-Za-z0-9]+).*\n^Mode: (\w+).*\n^Node count: (\d+)`
	)
	// build the regex from the pieces above
	re, err := regexp.Compile(fmt.Sprintf(`(?m:\A%v.*\n%v.*\n%v.*\n%v)`, zrVer, zrLat, zrNet, zrState))
	if err != nil {
	return nil, false
	}
	imOk := true
	servers = FormatServers(servers)
	ss := make([]*ServerStats, len(servers))
	for i := range ss {
	response, err := fourLetterWord(servers[i], "srvr", timeout)
	if err != nil {
	ss[i] = &ServerStats{Server: servers[i], Error: err}
	imOk = false
	continue
	}
	matches := re.FindAllStringSubmatch(string(response), -1)
	if matches == nil {
	err := fmt.Errorf("unable to parse fields from zookeeper response (no regex matches)")
	ss[i] = &ServerStats{Server: servers[i], Error: err}
	imOk = false
	continue
	}
	match := matches[0][1:]
	// determine current server
	var srvrMode Mode
	switch match[10] {
	case "leader":
	srvrMode = ModeLeader
	case "follower":
	srvrMode = ModeFollower
	case "standalone":
	srvrMode = ModeStandalone
	default:
	srvrMode = ModeUnknown
	}
	buildTime, err := time.Parse("01/02/2006 15:04 MST", match[1])
	if err != nil {
	ss[i] = &ServerStats{Server: servers[i], Error: err}
	imOk = false
	continue
	}
	parsedInt, err := strconv.ParseInt(match[9], 0, 64)
	if err != nil {
	ss[i] = &ServerStats{Server: servers[i], Error: err}
	imOk = false
	continue
	}
	// the ZxID value is an int64 with two int32s packed inside
	// the high int32 is the epoch (i.e., number of leader elections)
	// the low int32 is the counter
	epoch := int32(parsedInt >> 32)
	counter := int32(parsedInt & 0xFFFFFFFF)
	// within the regex above, these values must be numerical
	// so we can avoid useless checking of the error return value
	minLatency, _ := strconv.ParseInt(match[2], 0, 64)
	avgLatency, _ := strconv.ParseFloat(match[3], 64)
	maxLatency, _ := strconv.ParseInt(match[4], 0, 64)
	recv, _ := strconv.ParseInt(match[5], 0, 64)
	sent, _ := strconv.ParseInt(match[6], 0, 64)
	cons, _ := strconv.ParseInt(match[7], 0, 64)
	outs, _ := strconv.ParseInt(match[8], 0, 64)
	ncnt, _ := strconv.ParseInt(match[11], 0, 64)
	ss[i] = &ServerStats{
	Server: servers[i],
	Sent: sent,
	Received: recv,
	NodeCount: ncnt,
	MinLatency: minLatency,
	AvgLatency: avgLatency,
	MaxLatency: maxLatency,
	Connections: cons,
	Outstanding: outs,
	Epoch: epoch,
	Counter: counter,
	BuildTime: buildTime,
	Mode: srvrMode,
	Version: match[0],
	}
	}
	return ss, imOk
	}

[ilikeorangutans]

CC @jpfourny