def parseName(self, dc, cursor):
util.log_debug('NewVrfRouteVariableDecoder: parseName')
if not cursor.hasNext():
return
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
next = cursor.getNextToken()
util.log_debug(cursor.getNextToken())
global_found = False
if "global" == next:
cursor.advance()
decoderhandler.addTokenValue("global-address", "true")
global_found = True
elif "name" == next:
cursor.advance()
decoderhandler.addTokenValue("name", cursor.getNextToken())
cursor.advance()
elif "tag" == next:
cursor.advance()
decoderhandler.addTokenValue("tag", cursor.getNextToken())
cursor.advance()
elif "permanent" == next:
decoderhandler.addTokenValue("permanent", "true")
cursor.advance()
elif "track" == next:
cursor.advance()
decoderhandler.addTokenValue("track", cursor.getNextToken())
cursor.advance()
elif next is not None and "name" != next and "tag" != next and "track" != next and "permanent" != next:
decoderhandler.addTokenValue("metric", cursor.getNextToken())
cursor.advance()
elif not global_found:
decoderhandler.addTokenValue("global-address", "false")
self.parseName(dc, cursor)
def matchToken(self, configParserContext, configToken, idx, toks):
value = toks.get(idx)
util.log_debug('operation-type-matchtokenValue = %s' % (value))
if value in self.operation_types:
return 1
else:
return -1
def decodeToken(self, dc):
try:
util.log_info('SlaSourceIpTokenDecoder: Decode token')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
util.log_debug("TokenText : ", decoderhandler.getTokenText())
tokenText = decoderhandler.getTokenText()
tokenValue = decoderhandler.getValueAtCurrentIndex()
util.log_info('Value = %s' % (tokenValue))
decoderhandler.addTokenValue(tokenText, tokenValue)
##########
# block = decoderhandler.getCurrentBlock()
# lines = block.toString().split("\n")
# lines = [line.strip(' ') for line in lines]
# for each_line in lines:
# words = each_line.split(" ")
# for word in range(0, len(words)):
# if words[word] == "num-packets":
# decoderhandler.addTokenValue("num-packets", words[word+1])
# elif words[word] == "interval":
# decoderhandler.addTokenValue("interval", words[word+1])
# elif words[word] == "source-port":
# decoderhandler.addTokenValue("source-port", words[word+1])
##########
except Exception:
traceback.print_exc()
def parseFeatureState(self, dc, cursor):
util.log_debug(
'FeaturesVariableDecoder: parseFeatureState will describe the present state for the feature'
)
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
if not cursor.hasNext():
return
if "no" == cursor.getNextToken():
cursor.advance()
cursor.advance()
featurename = cursor.getNextToken()
if "tacacs+" == featurename:
featurename = "tacacs"
elif "domain" == featurename:
featurename = "domain-lookup"
decoderhandler.addTokenValue(featurename, "disable")
cursor.advance()
elif "feature" == cursor.getNextToken():
cursor.advance()
featurename = cursor.getNextToken()
if "tacacs+" == featurename:
featurename = "tacacs"
decoderhandler.addTokenValue(featurename, "enable")
cursor.advance()
elif "ip" == cursor.getNextToken():
featurename = "domain-lookup"
decoderhandler.addTokenValue(featurename, "enable")
def parseTag(self, dc, cursor):
util.log_debug('CiscoStaticRouterVariableDecoder: parseTag')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
if not cursor.hasNext():
return
next = cursor.getNextToken()
util.log_debug('CiscoStaticRouterVariableDecoder(parseTag) Next = %s' %
(next))
if "tag" == next:
cursor.advance()
util.log_debug(
'CiscoStaticRouterVariableDecoder(parseTag) tag is next = %s' %
(cursor.getNextToken()))
decoderhandler.addTokenValue("tag", cursor.getNextToken())
cursor.advance()
if "name" == next:
cursor.advance()
util.log_debug(
'CiscoStaticRouterVariableDecoder(parseTag) name is next = %s'
% (cursor.getNextToken()))
decoderhandler.addTokenValue("name", cursor.getNextToken())
cursor.advance()
if "name" != next and "tag" != next and next is not None:
util.log_debug(
'CiscoStaticRouterVariableDecoder(parseTag) metric next token = %s'
% (cursor.getNextToken()))
decoderhandler.addTokenValue("metric", cursor.getNextToken())
cursor.advance()
def decodeVariables(self, cpc, dc, context):
try:
util.log_info(
'RouterEigrpRedistVariableDecoder: Decoding variable')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
block = decoderhandler.getCurrentBlock()
tokens = Joiner.on(" ").join(block.getTokens())
tokens = tokens.split(" ")
print tokens
if "redistribute" not in tokens[0]:
util.log_debug(
'Does not look like a valid redistribute. redistribute = %s'
% (tokens))
return
decoderhandler.addTokenValue("protocol", tokens[1])
if tokens[1] == 'ospf':
decoderhandler.addTokenValue("ospf-id", tokens[2])
elif tokens[1] == 'eigrp' or tokens[1] == 'bgp':
decoderhandler.addTokenValue("as-number", tokens[2])
for i in range(1, len(tokens)):
i += 1
if tokens[i] == 'route-map':
decoderhandler.addTokenValue("route-map", tokens[i + 1])
if tokens[i] == 'metric':
decoderhandler.addTokenValue("bandwidth-metric",
tokens[i + 1])
decoderhandler.addTokenValue("delay-metric", tokens[i + 2])
decoderhandler.addTokenValue("reliability-metric",
tokens[i + 3])
decoderhandler.addTokenValue("load-metric", tokens[i + 4])
decoderhandler.addTokenValue("mtu", tokens[i + 5])
except Exception:
traceback.print_exc()
def parseConditionType(self, dc, cursor):
util.log_debug('ClassMapVariableTokenDecoder: parseConditionType')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
if not cursor.hasNext():
return
if "dscp" == cursor.getNextToken(
) or "qos-group" == cursor.getNextToken(
) or "protocol" == cursor.getNextToken():
conditiontype = cursor.getNextToken()
cursor.advance()
decoderhandler.addTokenValue("condition-type", conditiontype)
if "access-group" == cursor.getNextToken():
decoderhandler.addTokenValue("condition-type",
cursor.getNextToken())
cursor.advance()
cursor.advance()
if "ip" == cursor.getNextToken():
cursor.advance()
if "dscp" == cursor.getNextToken():
decoderhandler.addTokenValue("condition-type", "ip dscp")
global conditiontype
conditiontype = "ip dscp"
cursor.advance()
if "any" == cursor.getNextToken():
decoderhandler.addTokenValue("condition-type",
cursor.getNextToken())
if "vlan" == cursor.getNextToken():
conditiontype = cursor.getNextToken()
decoderhandler.addTokenValue("condition-type",
cursor.getNextToken())
cursor.advance()
def decodeVariables(self,cpc,dc,context):
try:
util.log_info('RouterOspfRedistVariableDecoder: Decoding variable')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
block = decoderhandler.getCurrentBlock()
tokens = Joiner.on(" ").join(block.getTokens())
tokens = tokens.split(" ")
print tokens
if "redistribute" not in tokens[0]:
util.log_debug('Does not look like a valid redistribute. redistribute = %s' % (tokens))
return
decoderhandler.addTokenValue("protocol", tokens[1])
if tokens[1] == 'ospf':
decoderhandler.addTokenValue("process-id-entry", tokens[2])
elif tokens[1] == 'eigrp':
decoderhandler.addTokenValue("eigrp-as-number", tokens[2])
elif tokens[1] == 'bgp':
decoderhandler.addTokenValue("bgp-as-number", tokens[2])
for i in range(1,len(tokens)):
i+=1
if tokens[i] == "metric":
decoderhandler.addTokenValue("value1", tokens[i+1])
if tokens[i] == "metric-type":
decoderhandler.addTokenValue("value2", tokens[i+1])
if tokens[i] == 'route-map':
decoderhandler.addTokenValue("route-map", tokens[i+1])
if tokens[i] == 'subnets':
decoderhandler.addTokenValue("subnet", "true")
if tokens[i] == 'tag':
decoderhandler.addTokenValue("tag", tokens[i+1])
except Exception:
traceback.print_exc()
def matchToken(self, configParserContext, configToken, idx, toks):
value = toks.get(idx)
util.log_debug('http-request-type-matchtokenValue = %s' % (value))
if value in self.http_request_types:
return 1
else:
return -1
def parseName(self, dc, cursor):
util.log_debug(
'VtyVariableDecoder: parseName will parse the value for Name, minvty and maxvty'
)
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
if not cursor.hasNext():
return
if "line" == cursor.getNextToken():
decoderhandler.addTokenValue(
"name",
Joiner.on(" ").join(
decoderhandler.getCurrentBlock().getTokens()))
cursor.advance()
cursor.advance()
else:
return
if not cursor.hasNext():
return
else:
decoderhandler.addTokenValue("min-vty", cursor.getNextToken())
cursor.advance()
if not cursor.hasNext():
return
else:
decoderhandler.addTokenValue("max-vty", cursor.getNextToken())
cursor.advance()
def parseTransportType(self, dc, cursor):
util.log_debug(
'VtyVariableDecoder: parseTransportType will parse the transport type'
)
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
if not cursor.hasNext():
return
if "transport" == cursor.getNextToken():
cursor.advance()
if "input" == cursor.getNextToken():
cursor.advance()
input_value = ""
while cursor.hasNext():
input_value = input_value + " " + cursor.getNextToken()
cursor.advance()
decoderhandler.addTokenValue("transport-types-in",
input_value.strip())
if "output" == cursor.getNextToken():
cursor.advance()
output_value = ""
while cursor.hasNext():
output_value = output_value + " " + cursor.getNextToken()
cursor.advance()
decoderhandler.addTokenValue("transport-types-out",
output_value.strip())
else:
return
def parseName(self, dc, cursor):
util.log_debug('NewRouteVariableDecoder: parseName')
if not cursor.hasNext():
return
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
next = cursor.getNextToken()
if "name" == next:
cursor.advance()
decoderhandler.addTokenValue("options/name", cursor.getNextToken())
cursor.advance()
elif "tag" == next:
cursor.advance()
decoderhandler.addTokenValue("options/tag", cursor.getNextToken())
cursor.advance()
elif "permanent" == next:
decoderhandler.addTokenValue("options/permanent", "true")
cursor.advance()
elif "track" == next:
cursor.advance()
decoderhandler.addTokenValue("options/track",
cursor.getNextToken())
cursor.advance()
elif "name" != next and "tag" != next and "track" != next and "permanent" != next and next is not None:
decoderhandler.addTokenValue("options/metric",
cursor.getNextToken())
cursor.advance()
self.parseName(dc, cursor)
def matchToken(self, configParserContext, configToken, idx, toks):
value = toks.get(idx)
util.log_debug('entry-number-matchtokenValue = %s' % (value))
match = re.search(self.responder_pattern, value)
if match is not None:
return 1
else:
return -1
def decodeToken(self, decoderContext):
try:
util.log_debug('NameServerTokenDecoder: Decode token')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(
decoderContext)
self.decodeNameServer(decoderContext)
except Exception:
traceback.print_exc()
def parseConditionType(self, dc, cursor):
util.log_debug('ClassMapHttpUrlVariableTokenDecoder: parseConditionType')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
if not cursor.hasNext():
return
if "protocol" == cursor.getNextToken():
conditiontype = cursor.getNextToken()
decoderhandler.addTokenValue("../condition-type", conditiontype)
cursor.advance()
def parseMatchValue(self, dc, cursor):
util.log_debug('ClassMapHttpUrlVariableTokenDecoder: parseMatchValue')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
if not cursor.hasNext():
return
if "http" == cursor.getNextToken():
matchtype = cursor.getNextToken()
decoderhandler.addTokenValue("../match-value", matchtype)
cursor.advance()
def parseNextHop(self, dc, cursor):
util.log_debug('CiscoStaticRouterVariableDecoder: parseNextHop')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
if not cursor.hasNext():
return
util.log_debug(
'CiscoStaticRouterVariableDecoder(parseNextHop): next-hop-ip token is = %s'
% (cursor.getNextToken()))
decoderhandler.addTokenValue("next-hop-ip", cursor.getNextToken())
cursor.advance()
def parseUrl(self, dc, cursor):
util.log_debug('ClassMapHttpUrlVariableTokenDecoder: parseUrl')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
if not cursor.hasNext():
return
if "url" == cursor.getNextToken():
cursor.advance()
url = cursor.getNextToken()
decoderhandler.addTokenValue("url", url)
cursor.advance()
def processService(self, cpc, dc, context, block):
util.log_debug('ObjectGroupServiceVariableDecoder: processNetwork')
compare = ['eq', 'lt', 'gt', 'range']
ip_protocol_list = [
'ahp', 'eigrp', 'esp', 'gre', 'icmp', 'igmp', 'ip', 'ipinip',
'nos', 'ospf', 'pcp', 'pim'
]
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
lines = block.toString().split("\n")
lines = [line.strip(' ') for line in lines]
util.log_info('BLOCK for obj service:', block)
for line in lines:
words = line.split(' ')
if words[0].isdigit():
decoderhandler.addTokenValue("name", words[0])
decoderhandler.addTokenValue("ip-protocol", words[0])
return
elif words[0] in ip_protocol_list:
decoderhandler.addTokenValue("name", words[0])
decoderhandler.addTokenValue("protocol", words[0])
return
elif words[0] == 'group-object':
util.log_debug('ObjectGroup')
else:
if InetAddressUtils.isIPv4Address(
words[0]) or words[0] == 'host':
return
decoderhandler.addTokenValue("protocol", words[0])
if len(words) - 1 >= 1:
if words[1] == 'source':
decoderhandler.addTokenValue("operation", words[1])
if words[2] in compare:
decoderhandler.addTokenValue("compare", words[2])
decoderhandler.addTokenValue("port", words[3])
if words[2] == 'range':
decoderhandler.addTokenValue("end-port", words[4])
decoderhandler.addTokenValue(
"name",
Joiner.on(" ").join(block.getTokens()))
elif words[1] in compare:
decoderhandler.addTokenValue("compare", words[1])
decoderhandler.addTokenValue("port", words[2])
if words[1] == 'range':
decoderhandler.addTokenValue("end-port", words[3])
decoderhandler.addTokenValue(
"name",
Joiner.on(" ").join(block.getTokens()))
else:
if words[0] == 'group-object':
decoderhandler.addTokenValue("group-object", words[1])
else:
decoderhandler.addTokenValue("port", words[1])
decoderhandler.addTokenValue(
"name",
Joiner.on(" ").join(block.getTokens()))
def processAccessList(self, cpc, dc, context, block):
util.log_debug('ObjectGroupVariableDecoder: processAccessList')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
cursor = util.TokenCursor(block.getTokens(), 1, None)
objectType = ''
objectName = ''
objectType = cursor.getNextToken()
cursor.advance()
objectName = cursor.getNextToken()
decoderhandler.addTokenValue("../../type", objectType)
decoderhandler.addTokenValue("../../name", objectName)
def decodeToken(self, dc):
try:
util.log_info('EfpServiceInstanceTokenDecoder: Decoding variable')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
util.log_debug("Block is : ", decoderhandler.getCurrentBlock())
tokenText = decoderhandler.getTokenText()
util.log_debug("Text :", tokenText)
tokenValue = decoderhandler.getValueAtCurrentIndex()
util.log_debug("Value :", tokenValue)
decoderhandler.addTokenValue(tokenText, tokenValue)
current_block = decoderhandler.getCurrentBlock().toString()
block_tokens = str(current_block).split(" ")
util.log_debug("Block_Tokens : ", block_tokens)
command_block = []
for cmds in block_tokens:
command_block.append(cmds.strip("\n"))
util.log_debug("command_block : ", command_block)
if 'trunk' in command_block:
decoderhandler.addTokenValue("$trunk", "true")
else:
decoderhandler.addTokenValue("$trunk", "false")
if 'symmetric' in command_block:
decoderhandler.addTokenValue("$symmetric", "true")
else:
decoderhandler.addTokenValue("$symmetric", "false")
if "encapsulation" in block_tokens:
i = command_block.index("encapsulation")
encap_type_list = [
'default', 'dot1ad', 'dot1q', 'priority-tagged', 'untagged'
]
encap_type = command_block[i + 1]
if encap_type in encap_type_list:
decoderhandler.addTokenValue("$encapsulation-type",
encap_type)
if 'add' in command_block:
vlanid = command_block[i + 3]
decoderhandler.addTokenValue("$vlan-id", vlanid)
else:
vlanid = command_block[i + 2]
decoderhandler.addTokenValue("$vlan-id", vlanid)
if "description" in block_tokens:
description_tokens = [
cmds.strip() for cmds in str(current_block).split("\n")
]
desc_pattern = '^description'
for i in range(len(description_tokens)):
if re.search(desc_pattern, description_tokens[i]):
desc_token = description_tokens[i].split("description")
desc_block = desc_token[1].strip()
decoderhandler.addTokenValue("$description",
desc_block)
except Exception:
traceback.print_exc()
def parseInterfaceName(self, dc, cursor):
util.log_debug('CiscoStaticRouterVariableDecoder: parseInterfaceName')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
if not cursor.hasNext():
return
if not InetAddressUtils.isIPv4Address(cursor.getNextToken()):
util.log_debug(
'CiscoStaticRouterVariableDecoder(parseInterfaceName): interface-name next token is = %s'
% (cursor.getNextToken()))
decoderhandler.addTokenValue("interface-name",
cursor.getNextToken())
cursor.advance()
def parseLogging(self, dc, cursor):
util.log_debug(
'VtyVariableDecoder: Logging synchronous enabled or not')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
if not cursor.hasNext():
return
if "logging" == cursor.getNextToken():
cursor.advance()
if "synchronous" == cursor.getNextToken():
decoderhandler.addTokenValue("logging-synchronous", "true")
else:
return
def parseTimeOut(self, dc, cursor):
util.log_debug(
'VtyVariableDecoder: TimeOut will parse the time out no.')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
if not cursor.hasNext():
return
if "exec-timeout" == cursor.getNextToken():
cursor.advance()
decoderhandler.addTokenValue("timeout", cursor.getNextToken())
cursor.advance()
else:
return
def parseVrf(self, dc, cursor):
util.log_debug('NewVrfRouteVariableDecoder: parseVrf')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
if not cursor.hasNext():
return
if "vrf" == cursor.getNextToken():
cursor.advance()
if not InetAddressUtils.isIPv4Address(cursor.getNextToken()):
decoderhandler.addTokenValue("../../../name",
cursor.getNextToken())
decoderhandler.addTokenValue("vrf-name", cursor.getNextToken())
cursor.advance()
def decodeToken(self, dc):
try:
util.log_info('TrackBooleanTokenDecoder: ')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
tokenText = decoderhandler.getTokenText()
util.log_debug('Token text = %s' % (tokenText))
value = decoderhandler.getValueAtCurrentIndex()
util.log_debug('Value = %s' % (value))
if value == 'or' or value == 'and':
decoderhandler.addTokenValue(tokenText, value)
except Exception:
traceback.print_exc()
def decodeToken(self, dc):
try:
util.log_info('MplsPriorityTokenDecoder: Decode token')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
token = dc.getToken()
value = decoderhandler.getValueAtCurrentIndex()
util.log_debug('Value = %s' %(value))
if int(value) >= 0 and int(value) <= 7:
dc.addTokenValue(token.getText(), value)
else:
return 1
except Exception:
traceback.print_exc()
def getEndIndex(self, curIdx, tokens):
try:
end = 0
if self.limit <= 0:
util.log_debug('Tokens size under getEndIndex is %s' %
tokens.size())
end = tokens.size()
else:
end = curIdx + self.limit
util.log_debug('End val under getEndIndex is %s' % end)
return end
except Exception:
traceback.print_exc()
def decodeToken(self, dc):
try:
util.log_info('PlatformConfigTypeTokenDecoder: Decode token')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
config = decoderhandler.getValueAtCurrentIndex()
util.log_debug('Configure = %s' % (config))
decoderhandler.addTokenValue("configure", config)
block = decoderhandler.getCurrentBlock()
lines = block.toString().split("\n")[0].strip(' ')
decoderhandler.addTokenValue("id", lines)
except Exception:
traceback.print_exc()
def decodeToken(self, dc):
try:
util.log_info('TrackIpTokenDecoder: ')
decoderhandler = tokendecoderhandler.TokenDecoderHandler(dc)
tokenText = decoderhandler.getTokenText()
util.log_debug('Token text = %s' % (tokenText))
value = decoderhandler.getValueAtCurrentIndex()
util.log_debug('Value = %s' % (value))
if value is not None and InetAddressUtils.isIPv4Address(value):
decoderhandler.addTokenValue(tokenText, value)
except Exception:
traceback.print_exc()
