dnmapper/bin/routerparsers.py

#!/usr/bin/env python

from __future__ import print_function

import re
import socket

from collections import OrderedDict

class RouterParserException(Exception):
	pass

def err(msg):
	raise RouterParserException(msg)


def getBGPData(ip, asno):
	rawData = getDataFromHost(ip)
	if not rawData:
		err("Could not get data from host (empty response)")

	router = parseBGPData(rawData, asno)

	router["ip"] = ip

	return router

def getDataFromHost(ip):
	socket.setdefaulttimeout(5)
	x = socket.socket()
	x.connect((ip, 6556))
	f = x.makefile()
	data = f.read()
	x.close()

	return data

def parseBGPData(raw, asno):
	d = re.search(r"(?:^|\n)<<<(quagga|bird)>>>\n(.*?)(?:$|<<<[^\n]+>>>)", raw, re.DOTALL)

	if not d:
		err("Data not found in check mk output")

	# mkify
	raw = d.group(2).split("\n")
	arr = filter(lambda _z: _z, map(lambda _y: filter(lambda _x: _x, re.split(r"\s+", _y)), raw))

	# parse for bird/quagga
	result = None

	if d.group(1) == "quagga":
		result = parseQuagga(arr, raw, asno)
	else:
		result = parseBird(arr, raw, asno)

	return result


def parseQuagga(data, raw, asno):
	status = _quaggaFindCommand(data, "show ip bgp sum")
	if status[0][0:3] != ['BGP', 'router', 'identifier']:
		print(status)
		err("Couldn't find router id in quagga output")

	peers = _quaggaFindNeighbors(data)
	if asno and int(asno) != int(status[0][7]):
		err("AS number (%s) does not match as number from quagga (%s)" % (asno, status[0][7]))

	routes = _quaggaFindRoutes(raw)

	return {"local_id": status[0][3].strip(","), "local_as": int(status[0][7]), "peers": peers, "routes": routes}

def parseBird(data, raw, asno):
	status = _birdFindTable(data, "show status")
	if status[2][0] != "1011-Router":
		err("Couldn't find router id in bird output")
	peers = filter(lambda _x: _x["type"] == "BGP", _birdMakeProtocols(data))

	if asno == None:
		err("Host is bird")
		# FIXME

	routes = _birdFindRoutes(data)

	return {"local_id": status[2][3], "local_as": int(asno), "peers": peers, "routes": routes}

def _birdFindTable(info, command):
	""" find command output of a bird command, e.g. "show bgp neighbors" """
	command = ["bird>"] + command.split(" ")
	commandInfo = []
	editNextLine = False
	for line in info:
		if not commandInfo:
			if line == command:
				commandInfo.append(line)
				editNextLine = True
		else:
			if editNextLine:
				editNextLine = False
				commandInfo.append(line[1:])
			elif line[0] == "bird>":
				return commandInfo
			else:
				commandInfo.append(line)
	return []

def _birdFindProtocols(info):
	""" return a list of tuples (protoname, protoinfo) """
	protocolTable = _birdFindTable(info, "show protocols all")
	protocols = OrderedDict()
	currProto = None
	for line in protocolTable[2:]:
		if line[0][0:4] == "1002":
			currProto = line[0][5:]
			protocols[currProto] = [[currProto] + line[1:]]
		elif currProto == None:
			err("No proto selected, couldn't parse line:", line)
		else:
			protocols[currProto].append(line)

	return protocols

def _birdMakeProtocols(info):
	""" Parse birds show protocols all output """
	# proto: name, type, description, state (up/down?), up-since
	#		routes imported, exported, preferred
	#		also: routing stats (
	# bgp special stuff: state, neighbor (address, as, id) (id not available when down)
	#   state (established, active)
	#   if error, last error is avilable
	protocols = []
	for proto, data in _birdFindProtocols(info).iteritems():
		protoInfo = {
			"name": proto,
			"type": data[0][1],
			"table": data[0][2],
			"state": data[0][3],
			"last_change": data[0][4],
			"info": " ".join(data[0][5:]),
			"description": " ".join(data[1][2:]),
			"routes": {
				"imported": data[5][1],
				"exported": data[5][3],
				"preferred": data[5][5],
			}
		}
		if protoInfo["type"] == "BGP":
			found = False
			for n, line in enumerate(data):
				if line[0:2] == ["BGP", "state:"]:
					found = True
					protoInfo["BGP"] = {
						"state": data[n][2],
						"online": data[n][2] == "Established",
						"neighbor_address": data[n+1][2],
						"neighbor_as": int(data[n+2][2]),
						"neighbor_id": data[n+3][2] if len(data) > n+3 and data[n+3][0:2] == ["Neighbor", "ID:"] else None,
						"last_error": " ".join(data[n+3][2:]) if len(data) > n+3 and data[n+3][0:2] == ["Last", "error:"] else None,
					}

			if not found:
				protoInfo["BGP"] = None

		protocols.append(protoInfo)

	return protocols


def _birdFindRoutes(info):
	output = _birdFindTable(info, "show route all")
	if len(output) < 1:
		# no data found
		return None

	def handleCandidate(routes, candidate):
		if candidate:
			# path, nexthop, network
			for key in ["path", "nexthop", "network", "iBGP"]:
				if key not in candidate:
					return
			route = {"prefix": candidate["network"], "nexthop": candidate["nexthop"], "path": candidate["path"], "iBGP": candidate["iBGP"]}
			routes.append(route)
			pass

	routes = []
	candidate = None
	lastIP = None
	for line in output:
		if line[0].startswith("1007-"):
			# new route!
			handleCandidate(routes, candidate)
			if line[0] != "1007-":
				# line has a network, use it!
				lastIP = line[0][5:]
			candidate = {"network": lastIP, "iBGP": None}

		elif candidate is not None:
			# search bgp attributes
			if line[0] == "1012-":
				pass
				k, v = line[1], line[2:]
			else:
				k, v = line[0], line[1:]

			k = k.rstrip(":")
			if k == "BGP.next_hop":
				candidate["nexthop"] = v[0]
			elif k == "BGP.as_path":
				candidate["path"] = v


	handleCandidate(routes, candidate)

	return routes


def _quaggaFindCommand(info, cmd):
	# ['core-frunde#', 'show', 'ip', 'bgp', 'sum']
	# ['core-frunde#', 'show', 'ip', 'bgp', 'neighbors']
	output = []
	cmd = cmd.split(" ")
	prompt = None
	for line in info:
		if line[1:] == cmd:
			prompt = line[0]
		elif line[0] == prompt:
			# done
			return output
		elif prompt != None:
			output.append(line)

	err("Could not find command '%s' in output" % " ".join(cmd))

def _quaggaFindNeighbors(info):
	#['BGP', 'neighbor', 'is', '10.50.1.2,', 'remote', 'AS', '65001,', 'local', 'AS', '65001,', 'internal', 'link']
	output = _quaggaFindCommand(info, "show ip bgp neighbors")
	start = ["BGP", "neighbor", "is"]

	curr = None
	rawNeighbors = []
	for line in output:
		if line[0:3] == start:
			if curr:
				rawNeighbors.append(curr)
			curr = [line]
		elif curr:
			curr.append(line)
		else:
			err("Could not find start of neighbors")

	if curr:
		rawNeighbors.append(curr)
		curr = None

	neighbors = []
	neighborDict = OrderedDict()
	for raw in rawNeighbors:
		descrIdx = 1 if raw[1][0] == "Description:" else 0
		if raw[descrIdx + 1][0] == "Hostname:":
			descrIdx += 1

		peerdict = {
			"neighbor_address": raw[0][3].rstrip(","),
			"neighbor_as": int(raw[0][6].rstrip(",")),
			"local_as": int(raw[0][9].rstrip(",")),
			"description": " ".join(raw[1][1:]) if descrIdx else "No description",
			"neighbor_id": raw[1+descrIdx][6].strip(","),
			"state": raw[2+descrIdx][3].strip(","),
			"routes": {
				"imported": 0,
			},
			"BGP": {
				"state": raw[2+descrIdx][3].strip(","),
				"online": raw[2+descrIdx][3].strip(",") == "Established",
				"neighbor_id": raw[1+descrIdx][6].strip(","),
				"neighbor_address": raw[0][3].rstrip(","),
				"neighbor_as": int(raw[0][6].rstrip(",")),
				"state": raw[2+descrIdx][3].strip(","),
			},
		}

		for line in raw:
			if line[1:3] == ["accepted", "prefixes"]:
				# woooo
				peerdict["routes"]["imported"] = int(line[0])
				break

		neighbors.append(peerdict)
		neighborDict[peerdict["neighbor_address"]] = peerdict

	return neighbors

def _quaggaFindRoutes(raw):
	# from # show ip bgp to Total number of prefixes XX
	# BGP table version is 0, local router ID is 10.50.0.1
	# *> 10.3.14.0/27     10.75.0.22                             0 65002 65112 i
	cmdre = re.compile(r"^([^\s#]+#) show ip bgp$")
	routere = re.compile(r"^(?P<status>.)(?P<status2>.)(?P<origin>.)(?P<network>[0-9./]+)?\s+(?P<nexthop>[0-9./]+)[\s0-9i?]+$")

	# find output
	output = []
	prompt = None
	for line in raw:
		if not prompt:
			m = cmdre.match(line)
			if m:
				prompt = m.group(1) + " "
		else:
			if line.startswith(prompt):
				break
			else:
				output.append(line)

	if len(output) < 1:
		# no data found
		return None

	routes = []
	foundTable = False
	lastIP = None
	for line in output:
		if not foundTable:
			if line.endswith("Metric LocPrf Weight Path"):
				foundTable = True
		else:
			if line != '':
				if line.startswith("Total number of prefixes") or line.startswith("Displayed "):
					break
				else:
					# parse one route line
					#print(line)
					m = routere.match(line)
					d = m.groupdict()
					if d["network"]:
						lastIP = d["network"]
					else:
						d["network"] = lastIP

					# "parse" path (everything after 61 chars, but no i)
					path = filter(lambda _x: _x not in ('', 'i'), line[61:].split(" "))

					# currently skip incomplete routes
					if '?' not in path:
						route = {"prefix": d["network"], "nexthop": d["nexthop"], "path": path, "iBGP": d["origin"] == "i"}
						routes.append(route)

	return routes