CiscoConfParse Methods

This is the methods available for CiscoConfParse :

find_all_children(linespec, exactmatch=False, ignore_ws=False)

Returns the parents matching the linespec, and all their children. This method is different than find_children(), because find_all_children() finds children of children. find_children() only finds immediate children.

Parameters

linespecstr: Text regular expression for the line to be matched
exactmatchbool: boolean that controls whether partial matches are valid
ignore_wsbool: boolean that controls whether whitespace is ignored

Returns

list: A list of matching configuration lines

Examples

Suppose you are interested in finding all archive statements in the following configuration…

username ddclient password 7 107D3D232342041E3A
archive
 log config
  logging enable
  hidekeys
 path ftp://ns.foo.com//tftpboot/Foo-archive
!

Using the config above, we expect to find the following config lines…

archive
 log config
  logging enable
  hidekeys
 path ftp://ns.foo.com//tftpboot/Foo-archive

We would accomplish this by querying find_all_children(‘^archive’)…

>>> from ciscoconfparse import CiscoConfParse
>>> config = ['username ddclient password 7 107D3D232342041E3A',
...           'archive',
...           ' log config',
...           '  logging enable',
...           '  hidekeys',
...           ' path ftp://ns.foo.com//tftpboot/Foo-archive',
...           '!',
...     ]
>>> p = CiscoConfParse(config)
>>> p.find_all_children('^archive')
['archive', ' log config', '  logging enable', '  hidekeys', ' path ftp://ns.foo.com//tftpboot/Foo-archive']
>>>

find_blocks(linespec, exactmatch=False, ignore_ws=False)

Find all siblings matching the linespec, then find all parents of those siblings. Return a list of config lines sorted by line number, lowest first. Note: any children of the siblings should NOT be returned.

Parameters

linespecstr: Text regular expression for the line to be matched
exactmatchbool: boolean that controls whether partial matches are valid
ignore_wsbool: boolean that controls whether whitespace is ignored

Returns

list: A list of matching configuration lines

Examples

This example finds bandwidth percent statements in following config, the siblings of those bandwidth percent statements, as well as the parent configuration statements required to access them.

!
policy-map EXTERNAL_CBWFQ
 class IP_PREC_HIGH
  priority percent 10
  police cir percent 10
    conform-action transmit
    exceed-action drop
 class IP_PREC_MEDIUM
  bandwidth percent 50
  queue-limit 100
 class class-default
  bandwidth percent 40
  queue-limit 100
policy-map SHAPE_HEIR
 class ALL
  shape average 630000
  service-policy EXTERNAL_CBWFQ
!

The following config lines should be returned:

policy-map EXTERNAL_CBWFQ
 class IP_PREC_MEDIUM
  bandwidth percent 50
  queue-limit 100
 class class-default
  bandwidth percent 40
  queue-limit 100

We do this by quering find_blocks(‘bandwidth percent’)…

>>> from ciscoconfparse import CiscoConfParse
>>> config = ['!', 
...           'policy-map EXTERNAL_CBWFQ', 
...           ' class IP_PREC_HIGH', 
...           '  priority percent 10', 
...           '  police cir percent 10', 
...           '    conform-action transmit', 
...           '    exceed-action drop', 
...           ' class IP_PREC_MEDIUM', 
...           '  bandwidth percent 50', 
...           '  queue-limit 100', 
...           ' class class-default', 
...           '  bandwidth percent 40', 
...           '  queue-limit 100', 
...           'policy-map SHAPE_HEIR', 
...           ' class ALL', 
...           '  shape average 630000', 
...           '  service-policy EXTERNAL_CBWFQ', 
...           '!',
...     ]
>>> p = CiscoConfParse(config)
>>> p.find_blocks('bandwidth percent')
['policy-map EXTERNAL_CBWFQ', ' class IP_PREC_MEDIUM', '  bandwidth percent 50', '  queue-limit 100', ' class class-default', '  bandwidth percent 40', '  queue-limit 100']
>>>
>>> p.find_blocks(' class class-default')
['policy-map EXTERNAL_CBWFQ', ' class IP_PREC_HIGH', ' class IP_PREC_MEDIUM', ' class class-default']
>>>

find_children(linespec, exactmatch=False, ignore_ws=False)

Returns the parents matching the linespec, and their immediate children. This method is different than find_all_children(), because find_all_children() finds children of children. find_children() only finds immediate children.

Parameters

linespecstr: Text regular expression for the line to be matched
exactmatchbool: boolean that controls whether partial matches are valid
ignore_wsbool: boolean that controls whether whitespace is ignored

Returns

list: A list of matching configuration lines

Examples

>>> from ciscoconfparse import CiscoConfParse
>>> config = ['username ddclient password 7 107D3D232342041E3A',
...           'archive',
...           ' log config',
...           '  logging enable',
...           '  hidekeys',
...           ' path ftp://ns.foo.com//tftpboot/Foo-archive',
...           '!',
...     ]
>>> p = CiscoConfParse(config)
>>> p.find_children('^archive')
['archive', ' log config', ' path ftp://ns.foo.com//tftpboot/Foo-archive']
>>>

find_children_w_parents(parentspec, childspec, ignore_ws=False)

Parse through the children of all parents matching parentspec, and return a list of children that matched the childspec.

Parameters

parentspecstr: Text regular expression for the line to be matched; this must match the parent’s line
childspecstr: Text regular expression for the line to be matched; this must match the child’s line
ignore_wsbool: boolean that controls whether whitespace is ignored

Returns

list: A list of matching child configuration lines

Examples

This example finds the port-security lines on FastEthernet0/1 in following config…

!
interface FastEthernet0/1
 switchport access vlan 532
 switchport port-security
 switchport port-security violation protect
 switchport port-security aging time 5
 switchport port-security aging type inactivity
 spanning-tree portfast
 spanning-tree bpduguard enable
!
interface FastEthernet0/2
 switchport access vlan 300
 spanning-tree portfast
 spanning-tree bpduguard enable
!
interface FastEthernet0/2
 duplex full
 speed 100
 switchport access vlan 300
 spanning-tree portfast
 spanning-tree bpduguard enable
!

The following lines should be returned:

switchport port-security
switchport port-security violation protect
switchport port-security aging time 5
switchport port-security aging type inactivity

We do this by quering find_children_w_parents(); we set our parent as ^interface and set the child as switchport port-security.

>>> from ciscoconfparse import CiscoConfParse
>>> config = ['!', 
...           'interface FastEthernet0/1', 
...           ' switchport access vlan 532', 
...           ' switchport port-security', 
...           ' switchport port-security violation protect', 
...           ' switchport port-security aging time 5', 
...           ' switchport port-security aging type inactivity', 
...           ' spanning-tree portfast', 
...           ' spanning-tree bpduguard enable', 
...           '!', 
...           'interface FastEthernet0/2', 
...           ' switchport access vlan 300', 
...           ' spanning-tree portfast', 
...           ' spanning-tree bpduguard enable', 
...           '!', 
...           'interface FastEthernet0/3', 
...           ' duplex full', 
...           ' speed 100', 
...           ' switchport access vlan 300', 
...           ' spanning-tree portfast', 
...           ' spanning-tree bpduguard enable', 
...           '!',
...     ]
>>> p = CiscoConfParse(config)
>>> p.find_children_w_parents('^interface\sFastEthernet0/1', 
... 'port-security')
[' switchport port-security', ' switchport port-security violation protect', ' switchport port-security aging time 5', ' switchport port-security aging type inactivity']
>>>

find_interface_objects(intfspec, exactmatch=True)

Find all IOSCfgLine or NXOSCfgLine objects whose text is an abbreviation for intfspec and return the objects in a python list.

Parameters

intfspecstr: A string which is the abbreviation (or full name) of the interface
exactmatchbool: Defaults to True; when True, this option requires intfspec match the whole interface name and number.

Returns

list: A list of matching IOSIntfLine objects

Notes

The configuration must be parsed with factory=True to use this method

Examples

>>> from ciscoconfparse import CiscoConfParse
>>> config = [
...     '!',
...     'interface Serial1/0',
...     ' ip address 1.1.1.1 255.255.255.252',
...     '!',
...     'interface Serial1/1',
...     ' ip address 1.1.1.5 255.255.255.252',
...     '!',
...     ]
>>> parse = CiscoConfParse(config, factory=True)
>>>
>>> parse.find_interface_objects('Se 1/0')
[<IOSIntfLine # 1 'Serial1/0' info: '1.1.1.1/30'>]
>>>

find_lineage(linespec, exactmatch=False)

Iterate through to the oldest ancestor of this object, and return a list of all ancestors / children in the direct line. Cousins or aunts / uncles are not returned. Note, all children of this object are returned.

Parameters

linespecstr: Text regular expression for the line to be matched
exactmatchbool: Defaults to False; when True, this option requires linespec the whole line (not merely a portion of the line)

Returns

list: A list of matching objects

find_lines(linespec, exactmatch=False, ignore_ws=False)

This method is the equivalent of a simple configuration grep (Case-sensitive).

Parameters

linespecstr: Text regular expression for the line to be matched
exactmatchbool: Defaults to False. When set True, this option requires linespec match the whole configuration line, instead of a portion of the configuration line.
ignore_wsbool: boolean that controls whether whitespace is ignored. Default is False.

Returns

list: A list of matching configuration lines

find_object_branches(branchspec=(), regex_flags=0)

This method iterates over a tuple of regular expressions in branchspec and returns the matching objects in a list of lists (consider it similar to a table of matching config objects). branchspec expects to start at some ancestor and walk through the nested object hierarchy (with no limit on depth).

Previous CiscoConfParse() methods only handled a single parent regex and single child regex (such as find_parents_w_child()).

This method dives beyond a simple parent-child relationship to include entire family ‘branches’ (i.e. parents, children, grand-children, great-grand-children, etc). The result of handling longer regex chains is that it flattens what would otherwise be nested loops in your scripts; this makes parsing heavily-nested configuratations like Palo-Alto and F5 much simpler. Of course, there are plenty of applications for “flatter” config formats like IOS.

This method returns a list of lists (of object ‘branches’) which are nested to the same depth required in branchspec. However, unlike most other CiscoConfParse() methods, it returns an explicit None if there is no object match. Returning None allows a single search over configs that may not be uniformly nested in every branch.

Parameters

branchspectuple: A tuple of python regular expressions to be matched.
regex_flags :: Chained regular expression flags, such as re.IGNORECASE|re.MULTILINE

Returns

list: A list of lists of matching IOSCfgLine objects

Examples

>>> from operator import attrgetter
>>> from ciscoconfparse import CiscoConfParse
>>> config = [
...     'ltm pool FOO {',
...     '  members {',
...     '    k8s-05.localdomain:8443 {',
...     '      address 192.0.2.5',
...     '      session monitor-enabled',
...     '      state up',
...     '    }',
...     '    k8s-06.localdomain:8443 {',
...     '      address 192.0.2.6',
...     '      session monitor-enabled',
...     '      state down',
...     '    }',
...     '  }',
...     '}',
...     'ltm pool BAR {',
...     '  members {',
...     '    k8s-07.localdomain:8443 {',
...     '      address 192.0.2.7',
...     '      session monitor-enabled',
...     '      state down',
...     '    }',
...     '  }',
...     '}',
...     ]
>>> parse = CiscoConfParse(config, syntax='junos', comment='#')
>>>
>>> branchspec = (r'ltm\spool', r'members', r'\S+?:\d+', r'state\sup')
>>> branches = parse.find_object_branches(branchspec=branchspec)
>>>
>>> # We found three branches
>>> len(branches)
3
>>> # Each branch must match the length of branchspec
>>> len(branches[0])
4
>>> # Print out one object 'branch'
>>> branches[0]
[<IOSCfgLine # 0 'ltm pool FOO'>, <IOSCfgLine # 1 '    members' (parent is # 0)>, <IOSCfgLine # 2 '        k8s-05.localdomain:8443' (parent is # 1)>, <IOSCfgLine # 5 '            state up' (parent is # 2)>]
>>>
>>> # Get the a list of text lines for this branch... 
>>> list(map(attrgetter('text'), branches[0]))
['ltm pool FOO', '    members', '        k8s-05.localdomain:8443', '            state up']
>>>
>>> # Get the config text of the root object of the branch...
>>> branches[0][0].text
'ltm pool FOO'
>>>
>>> # Note: `None` in branches[1][-1] because of no regex match
>>> branches[1]
[<IOSCfgLine # 0 'ltm pool FOO'>, <IOSCfgLine # 1 '    members' (parent is # 0)>, <IOSCfgLine # 6 '        k8s-06.localdomain:8443' (parent is # 1)>, None]
>>>
>>> branches[2]
[<IOSCfgLine # 10 'ltm pool BAR'>, <IOSCfgLine # 11 '    members' (parent is # 10)>, <IOSCfgLine # 12 '        k8s-07.localdomain:8443' (parent is # 11)>, None]

find_objects(linespec, exactmatch=False, ignore_ws=False)

Find all IOSCfgLine objects whose text matches linespec and return the IOSCfgLine objects in a python list. find_objects() is similar to find_lines(); however, the former returns a list of IOSCfgLine objects, while the latter returns a list of text configuration statements. Going forward, I strongly encourage people to start using find_objects() instead of find_lines().

Parameters

linespecstr: A string or python regular expression, which should be matched
exactmatchbool: Defaults to False. When set True, this option requires linespec match the whole configuration line, instead of a portion of the configuration line.
ignore_wsbool: boolean that controls whether whitespace is ignored. Default is False.

Returns

list: A list of matching IOSCfgLine objects

Examples

This example illustrates the difference between find_objects() and find_lines().

>>> from ciscoconfparse import CiscoConfParse
>>> config = [
...     '!',
...     'interface Serial1/0',
...     ' ip address 1.1.1.1 255.255.255.252',
...     '!',
...     'interface Serial1/1',
...     ' ip address 1.1.1.5 255.255.255.252',
...     '!',
...     ]
>>> parse = CiscoConfParse(config)
>>>
>>> parse.find_objects(r'^interface')
[<IOSCfgLine # 1 'interface Serial1/0'>, <IOSCfgLine # 4 'interface Serial1/1'>]
>>>
>>> parse.find_lines(r'^interface')
['interface Serial1/0', 'interface Serial1/1']
>>>

find_objects_dna(dnaspec, exactmatch=False)

Find all IOSCfgLine objects whose text matches dnaspec and return the IOSCfgLine objects in a python list.

Parameters

dnaspecstr: A string or python regular expression, which should be matched. This argument will be used to match dna attribute of the object
exactmatchbool: Defaults to False. When set True, this option requires dnaspec match the whole configuration line, instead of a portion of the configuration line.

Returns

list: A list of matching IOSCfgLine objects

Notes

find_objects_dna() requires the configuration to be parsed with factory=True

Examples

>>> from ciscoconfparse import CiscoConfParse
>>> config = [
...     '!',
...     'hostname MyRouterHostname',
...     '!',
...     ]
>>> parse = CiscoConfParse(config, factory=True, syntax='ios')
>>>
>>> obj_list = parse.find_objects_dna(r'Hostname')
>>> obj_list
[<IOSHostnameLine # 1 'MyRouterHostname'>]
>>>
>>> # The IOSHostnameLine object has a hostname attribute
>>> obj_list[0].hostname
'MyRouterHostname'

find_objects_w_all_children(parentspec, childspec, ignore_ws=False, recurse=False)

Return a list of parent IOSCfgLine objects, which matched the parentspec and whose children match all elements in childspec. Only the parent IOSCfgLine objects will be returned.

Parameters

parentspecstr: Text regular expression for the IOSCfgLine object to be matched; this must match the parent’s line
childspecstr: A list of text regular expressions to be matched among the children
ignore_wsbool: boolean that controls whether whitespace is ignored
recursebool: Set True if you want to search all children (children, grand children, great grand children, etc…)

Returns

list: A list of matching parent IOSCfgLine objects

Examples

This example uses find_objects_w_child() to find all ports that are members of access vlan 300 in following config…

!
interface FastEthernet0/1
 switchport access vlan 532
 spanning-tree vlan 532 cost 3
!
interface FastEthernet0/2
 switchport access vlan 300
 spanning-tree portfast
!
interface FastEthernet0/2
 duplex full
 speed 100
 switchport access vlan 300
 spanning-tree portfast
!

The following interfaces should be returned:

interface FastEthernet0/2
interface FastEthernet0/3

We do this by quering find_objects_w_all_children(); we set our parent as ^interface and set the childspec as [‘switchport access vlan 300’, ‘spanning-tree portfast’].

>>> from ciscoconfparse import CiscoConfParse
>>> config = ['!', 
...           'interface FastEthernet0/1', 
...           ' switchport access vlan 532', 
...           ' spanning-tree vlan 532 cost 3', 
...           '!', 
...           'interface FastEthernet0/2', 
...           ' switchport access vlan 300', 
...           ' spanning-tree portfast', 
...           '!', 
...           'interface FastEthernet0/3', 
...           ' duplex full', 
...           ' speed 100', 
...           ' switchport access vlan 300', 
...           ' spanning-tree portfast', 
...           '!',
...     ]
>>> p = CiscoConfParse(config)
>>> p.find_objects_w_all_children('^interface', 
...     ['switchport access vlan 300', 'spanning-tree portfast'])
...
[<IOSCfgLine # 5 'interface FastEthernet0/2'>, <IOSCfgLine # 9 'interface FastEthernet0/3'>]
>>>

find_objects_w_child(parentspec, childspec, ignore_ws=False, recurse=False)

Return a list of parent IOSCfgLine objects, which matched the parentspec and whose children match childspec. Only the parent IOSCfgLine objects will be returned.

Parameters

parentspecstr: Text regular expression for the IOSCfgLine object to be matched; this must match the parent’s line
childspecstr: Text regular expression for the line to be matched; this must match the child’s line
ignore_wsbool: boolean that controls whether whitespace is ignored
recursebool: Set True if you want to search all children (children, grand children, great grand children, etc…)

Returns

list: A list of matching parent IOSCfgLine objects

Examples

This example uses find_objects_w_child() to find all ports that are members of access vlan 300 in following config…

!
interface FastEthernet0/1
 switchport access vlan 532
 spanning-tree vlan 532 cost 3
!
interface FastEthernet0/2
 switchport access vlan 300
 spanning-tree portfast
!
interface FastEthernet0/3
 duplex full
 speed 100
 switchport access vlan 300
 spanning-tree portfast
!

The following interfaces should be returned:

interface FastEthernet0/2
interface FastEthernet0/3

We do this by quering find_objects_w_child(); we set our parent as ^interface and set the child as switchport access vlan 300.

>>> from ciscoconfparse import CiscoConfParse
>>> config = ['!', 
...           'interface FastEthernet0/1', 
...           ' switchport access vlan 532', 
...           ' spanning-tree vlan 532 cost 3', 
...           '!', 
...           'interface FastEthernet0/2', 
...           ' switchport access vlan 300', 
...           ' spanning-tree portfast', 
...           '!', 
...           'interface FastEthernet0/3', 
...           ' duplex full', 
...           ' speed 100', 
...           ' switchport access vlan 300', 
...           ' spanning-tree portfast', 
...           '!',
...     ]
>>> p = CiscoConfParse(config)
>>> p.find_objects_w_child('^interface', 
...     'switchport access vlan 300')
...
[<IOSCfgLine # 5 'interface FastEthernet0/2'>, <IOSCfgLine # 9 'interface FastEthernet0/3'>]
>>>

find_objects_w_missing_children(parentspec, childspec, ignore_ws=False)

Return a list of parent IOSCfgLine objects, which matched the parentspec and whose children do not match all elements in childspec. Only the parent IOSCfgLine objects will be returned.

Parameters

parentspecstr: Text regular expression for the IOSCfgLine object to be matched; this must match the parent’s line
childspecstr: A list of text regular expressions to be matched among the children
ignore_wsbool: boolean that controls whether whitespace is ignored

Returns

list: A list of matching parent IOSCfgLine objects

find_objects_w_parents(parentspec, childspec, ignore_ws=False)

Parse through the children of all parents matching parentspec, and return a list of child objects, which matched the childspec.

Parameters

parentspecstr: Text regular expression for the line to be matched; this must match the parent’s line
childspecstr: Text regular expression for the line to be matched; this must match the child’s line
ignore_wsbool: boolean that controls whether whitespace is ignored

Returns

list: A list of matching child objects

Examples

This example finds the object for “ge-0/0/0” under “interfaces” in the following config…

interfaces 
    ge-0/0/0 
        unit 0 
            family ethernet-switching 
                port-mode access
                vlan 
                    members VLAN_FOO
    ge-0/0/1 
        unit 0 
            family ethernet-switching 
                port-mode trunk
                vlan 
                    members all
                native-vlan-id 1
    vlan 
        unit 0 
            family inet 
                address 172.16.15.5/22

The following object should be returned:

<IOSCfgLine # 7 '    ge-0/0/1' (parent is # 0)>

We do this by quering find_objects_w_parents(); we set our parent as ^s*interface and set the child as ^s+ge-0/0/1.

>>> from ciscoconfparse import CiscoConfParse
>>> config = ['interfaces',
...           '    ge-0/0/0',
...           '        unit 0',
...           '            family ethernet-switching',
...           '                port-mode access',
...           '                vlan',
...           '                    members VLAN_FOO',
...           '    ge-0/0/1',
...           '        unit 0',
...           '            family ethernet-switching',
...           '                port-mode trunk',
...           '                vlan',
...           '                    members all',
...           '                native-vlan-id 1',
...           '    vlan',
...           '        unit 0',
...           '            family inet',
...           '                address 172.16.15.5/22',
...     ]
>>> p = CiscoConfParse(config)
>>> p.find_objects_w_parents('^\s*interfaces', 
... r'\s+ge-0/0/1')
[<IOSCfgLine # 7 '    ge-0/0/1' (parent is # 0)>]
>>>

find_objects_wo_child(parentspec, childspec, ignore_ws=False)

Return a list of parent IOSCfgLine objects, which matched the parentspec and whose children did not match childspec. Only the parent IOSCfgLine objects will be returned. For simplicity, this method only finds oldest_ancestors without immediate children that match.

Parameters

parentspecstr: Text regular expression for the IOSCfgLine object to be matched; this must match the parent’s line
childspecstr: Text regular expression for the line to be matched; this must match the child’s line
ignore_wsbool: boolean that controls whether whitespace is ignored

Returns

list: A list of matching parent configuration lines

Examples

This example finds all ports that are autonegotiating in the following config…

!
interface FastEthernet0/1
 switchport access vlan 532
 spanning-tree vlan 532 cost 3
!
interface FastEthernet0/2
 switchport access vlan 300
 spanning-tree portfast
!
interface FastEthernet0/2
 duplex full
 speed 100
 switchport access vlan 300
 spanning-tree portfast
!

The following interfaces should be returned:

interface FastEthernet0/1
interface FastEthernet0/2

We do this by quering find_objects_wo_child(); we set our parent as ^interface and set the child as speedsd+ (a regular-expression which matches the word ‘speed’ followed by an integer).

>>> from ciscoconfparse import CiscoConfParse
>>> config = ['!', 
...           'interface FastEthernet0/1', 
...           ' switchport access vlan 532', 
...           ' spanning-tree vlan 532 cost 3', 
...           '!', 
...           'interface FastEthernet0/2', 
...           ' switchport access vlan 300', 
...           ' spanning-tree portfast', 
...           '!', 
...           'interface FastEthernet0/3', 
...           ' duplex full', 
...           ' speed 100', 
...           ' switchport access vlan 300', 
...           ' spanning-tree portfast', 
...           '!',
...     ]
>>> p = CiscoConfParse(config)
>>> p.find_objects_wo_child(r'^interface', r'speed\s\d+')
[<IOSCfgLine # 1 'interface FastEthernet0/1'>, <IOSCfgLine # 5 'interface FastEthernet0/2'>]
>>>

find_parents_w_child(parentspec, childspec, ignore_ws=False)

Parse through all children matching childspec, and return a list of parents that matched the parentspec. Only the parent lines will be returned.

Parameters

parentspecstr: Text regular expression for the line to be matched; this must match the parent’s line
childspecstr: Text regular expression for the line to be matched; this must match the child’s line
ignore_wsbool: boolean that controls whether whitespace is ignored

Returns

list: A list of matching parent configuration lines

Examples

This example finds all ports that are members of access vlan 300 in following config…

!
interface FastEthernet0/1
 switchport access vlan 532
 spanning-tree vlan 532 cost 3
!
interface FastEthernet0/2
 switchport access vlan 300
 spanning-tree portfast
!
interface FastEthernet0/2
 duplex full
 speed 100
 switchport access vlan 300
 spanning-tree portfast
!

The following interfaces should be returned:

interface FastEthernet0/2
interface FastEthernet0/3

We do this by quering find_parents_w_child(); we set our parent as ^interface and set the child as switchport access vlan 300.

>>> from ciscoconfparse import CiscoConfParse
>>> config = ['!', 
...           'interface FastEthernet0/1', 
...           ' switchport access vlan 532', 
...           ' spanning-tree vlan 532 cost 3', 
...           '!', 
...           'interface FastEthernet0/2', 
...           ' switchport access vlan 300', 
...           ' spanning-tree portfast', 
...           '!', 
...           'interface FastEthernet0/3', 
...           ' duplex full', 
...           ' speed 100', 
...           ' switchport access vlan 300', 
...           ' spanning-tree portfast', 
...           '!',
...     ]
>>> p = CiscoConfParse(config)
>>> p.find_parents_w_child('^interface', 'switchport access vlan 300')
['interface FastEthernet0/2', 'interface FastEthernet0/3']
>>>

find_parents_wo_child(parentspec, childspec, ignore_ws=False)

Parse through all parents matching parentspec, and return a list of parents that did NOT have children match the childspec. For simplicity, this method only finds oldest_ancestors without immediate children that match.

Parameters

parentspecstr: Text regular expression for the line to be matched; this must match the parent’s line
childspecstr: Text regular expression for the line to be matched; this must match the child’s line
ignore_wsbool: boolean that controls whether whitespace is ignored

Returns

list: A list of matching parent configuration lines

Examples

This example finds all ports that are autonegotiating in the following config…

!
interface FastEthernet0/1
 switchport access vlan 532
 spanning-tree vlan 532 cost 3
!
interface FastEthernet0/2
 switchport access vlan 300
 spanning-tree portfast
!
interface FastEthernet0/2
 duplex full
 speed 100
 switchport access vlan 300
 spanning-tree portfast
!

The following interfaces should be returned:

interface FastEthernet0/1
interface FastEthernet0/2

We do this by quering find_parents_wo_child(); we set our parent as ^interface and set the child as speedsd+ (a regular-expression which matches the word ‘speed’ followed by an integer).

>>> from ciscoconfparse import CiscoConfParse
>>> config = ['!', 
...           'interface FastEthernet0/1', 
...           ' switchport access vlan 532', 
...           ' spanning-tree vlan 532 cost 3', 
...           '!', 
...           'interface FastEthernet0/2', 
...           ' switchport access vlan 300', 
...           ' spanning-tree portfast', 
...           '!', 
...           'interface FastEthernet0/3', 
...           ' duplex full', 
...           ' speed 100', 
...           ' switchport access vlan 300', 
...           ' spanning-tree portfast', 
...           '!',
...     ]
>>> p = CiscoConfParse(config)
>>> p.find_parents_wo_child('^interface', 'speed\s\d+')
['interface FastEthernet0/1', 'interface FastEthernet0/2']
>>>

has_line_with(linespec)

insert_after(linespec, insertstr=”, exactmatch=False, ignore_ws=False, atomic=False): Find all IOSCfgLine objects whose text matches linespec, and insert insertstr after those line objects

insert_after_child(parentspec, childspec, insertstr=”, exactmatch=False, excludespec=None, ignore_ws=False, atomic=False): Find all IOSCfgLine objects whose text matches linespec and have a child matching childspec, and insert an IOSCfgLine object for insertstr after those child objects.

insert_before(linespec, insertstr=”, exactmatch=False, ignore_ws=False, atomic=False): Find all objects whose text matches linespec, and insert ‘insertstr’ before those line objects

property ioscfg: A list containing all text configuration statements

property objs: An alias to the ConfigObjs attribute

property openargs: Fix for Py3.5 deprecation of universal newlines – Ref Github #114 also see https://softwareengineering.stackexchange.com/q/298677/23144

prepend_line(linespec): Unconditionally insert an IOSCfgLine object for linespec (a text line) at the top of the configuration

re_match_iter_typed(regex, group=1, result_type=<class ‘str’>, default=”, untyped_default=False)

Use regex to search the root parents in the config and return the contents of the regular expression group, at the integer group index, cast as result_type; if there is no match, default is returned.

Parameters

regexstr: A string or python compiled regular expression, which should be matched. This regular expression should contain parenthesis, which bound a match group.
groupint: An integer which specifies the desired regex group to be returned. group defaults to 1.
result_typetype: A type (typically one of: str, int, float, or IPv4Obj). All returned values are cast as result_type, which defaults to str.
defaultany: The default value to be returned, if there is no match. The default is an empty string.
untyped_defaultbool: Set True if you don’t want the default value to be typed

Returns

result_type: The text matched by the regular expression group; if there is no match, default is returned. All values are cast as result_type. The default result_type is str.

Notes

Only the first regex match is returned.

Examples

This example illustrates how you can use re_match_iter_typed() to get the first interface name listed in the config.

>>> import re
>>> from ciscoconfparse import CiscoConfParse
>>> config = [
...     '!',
...     'interface Serial1/0',
...     ' ip address 1.1.1.1 255.255.255.252',
...     '!',
...     'interface Serial2/0',
...     ' ip address 1.1.1.5 255.255.255.252',
...     '!',
...     ]
>>> parse = CiscoConfParse(config)
>>> parse.re_match_iter_typed(r'interface\s(\S+)')
'Serial1/0'
>>>

The following example retrieves the hostname from the configuration

>>> from ciscoconfparse import CiscoConfParse
>>> config = [
...     '!',
...     'hostname DEN-EDGE-01',
...     '!',
...     'interface Serial1/0',
...     ' ip address 1.1.1.1 255.255.255.252',
...     '!',
...     'interface Serial2/0',
...     ' ip address 1.1.1.5 255.255.255.252',
...     '!',
...     ]
>>> parse = CiscoConfParse(config)
>>> parse.re_match_iter_typed(r'^hostname\s+(\S+)')
'DEN-EDGE-01'
>>>

re_search_children(regex, recurse=False)

Use regex to search for root parents in the config with text matching regex. If recurse is False, only root parent objects are returned. A list of matching objects is returned.

This method is very similar to find_objects() (when recurse is True); however it was written in response to the use-case described in Github Issue #156.

Parameters

regexstr: A string or python regular expression, which should be matched.
recursebool: Set True if you want to search all objects, and not just the root parents

Returns

list: A list of matching IOSCfgLine objects which matched. If there is no match, an empty list() is returned.

replace_all_children(parentspec, childspec, replacestr, excludespec=None, exactmatch=False, atomic=False): Replace lines matching childspec within all children (recursive) of lines whilch match parentspec

replace_children(parentspec, childspec, replacestr, excludespec=None, exactmatch=False, atomic=False)

Replace lines matching childspec within the parentspec’s immediate children.

Parameters

parentspecstr: Text IOS configuration line
childspecstr: Text IOS configuration line, or regular expression
replacestrstr: Text IOS configuration, which should replace text matching childspec.
excludespecstr: A regular expression, which indicates childspec lines which must be skipped. If excludespec is None, no lines will be excluded.
exactmatchbool: Defaults to False. When set True, this option requires linespec match the whole configuration line, instead of a portion of the configuration line.

Returns

list: A list of changed IOSCfgLine instances.

Examples

replace_children() just searches through a parent’s child lines and replaces anything matching childspec with replacestr. This method is one of my favorites for quick and dirty standardization efforts if you know the commands are already there (just set inconsistently).

One very common use case is rewriting all vlan access numbers in a configuration. The following example sets storm-control broadcast level 0.5 on all GigabitEthernet ports.

>>> from ciscoconfparse import CiscoConfParse
>>> config = ['!', 
...           'interface GigabitEthernet1/1',
...           ' description {I have a broken storm-control config}',
...           ' switchport',
...           ' switchport mode access',
...           ' switchport access vlan 50',
...           ' switchport nonegotiate',
...           ' storm-control broadcast level 0.2',
...           '!'
...     ]
>>> p = CiscoConfParse(config)
>>> p.replace_children(r'^interface\sGigabit', r'broadcast\slevel\s\S+', 'broadcast level 0.5')
[' storm-control broadcast level 0.5']
>>>

One thing to remember about the last example, you cannot use a regular expression in replacestr; just use a normal python string.

replace_lines(linespec, replacestr, excludespec=None, exactmatch=False, atomic=False)

This method is a text search and replace (Case-sensitive). You can optionally exclude lines from replacement by including a string (or compiled regular expression) in excludespec.

Parameters

linespecstr: Text regular expression for the line to be matched
replacestrstr: Text used to replace strings matching linespec
excludespecstr: Text regular expression used to reject lines, which would otherwise be replaced. Default value of excludespec is None, which means nothing is excluded
exactmatchbool: boolean that controls whether partial matches are valid
atomicbool: boolean that controls whether the config is reparsed after replacement (default False)

Returns

list: A list of changed configuration lines

Examples

This example finds statements with EXTERNAL_CBWFQ in following config, and replaces all matching lines (in-place) with EXTERNAL_QOS. For the purposes of this example, let’s assume that we do not want to make changes to any descriptions on the policy.

!
policy-map EXTERNAL_CBWFQ
 description implement an EXTERNAL_CBWFQ policy
 class IP_PREC_HIGH
  priority percent 10
  police cir percent 10
    conform-action transmit
    exceed-action drop
 class IP_PREC_MEDIUM
  bandwidth percent 50
  queue-limit 100
 class class-default
  bandwidth percent 40
  queue-limit 100
policy-map SHAPE_HEIR
 class ALL
  shape average 630000
  service-policy EXTERNAL_CBWFQ
!

We do this by calling replace_lines(linespec=’EXTERNAL_CBWFQ’, replacestr=’EXTERNAL_QOS’, excludespec=’description’)…

>>> from ciscoconfparse import CiscoConfParse
>>> config = ['!', 
...           'policy-map EXTERNAL_CBWFQ', 
...           ' description implement an EXTERNAL_CBWFQ policy',
...           ' class IP_PREC_HIGH', 
...           '  priority percent 10', 
...           '  police cir percent 10', 
...           '    conform-action transmit', 
...           '    exceed-action drop', 
...           ' class IP_PREC_MEDIUM', 
...           '  bandwidth percent 50', 
...           '  queue-limit 100', 
...           ' class class-default', 
...           '  bandwidth percent 40', 
...           '  queue-limit 100', 
...           'policy-map SHAPE_HEIR', 
...           ' class ALL', 
...           '  shape average 630000', 
...           '  service-policy EXTERNAL_CBWFQ', 
...           '!',
...     ]
>>> p = CiscoConfParse(config)
>>> p.replace_lines('EXTERNAL_CBWFQ', 'EXTERNAL_QOS', 'description')
['policy-map EXTERNAL_QOS', '  service-policy EXTERNAL_QOS']
>>>
>>> # Now when we call `p.find_blocks('policy-map EXTERNAL_QOS')`, we get the
>>> # changed configuration, which has the replacements except on the
>>> # policy-map's description.
>>> p.find_blocks('EXTERNAL_QOS')
['policy-map EXTERNAL_QOS', ' description implement an EXTERNAL_CBWFQ policy', ' class IP_PREC_HIGH', ' class IP_PREC_MEDIUM', ' class class-default', 'policy-map SHAPE_HEIR', ' class ALL', '  shape average 630000', '  service-policy EXTERNAL_QOS']
>>>

req_cfgspec_all_diff(cfgspec, ignore_ws=False)

req_cfgspec_all_diff takes a list of required configuration lines, parses through the configuration, and ensures that none of cfgspec’s lines are missing from the configuration. req_cfgspec_all_diff returns a list of missing lines from the config.

One example use of this method is when you need to enforce routing protocol standards, or standards against interface configurations.

Examples

>>> from ciscoconfparse import CiscoConfParse
>>> config = [
...     'logging trap debugging',
...     'logging 172.28.26.15',
...     ] 
>>> p = CiscoConfParse(config)
>>> required_lines = [
...     "logging 172.28.26.15",
...     "logging 172.16.1.5",
...     ]
>>> diffs = p.req_cfgspec_all_diff(required_lines)
>>> diffs
['logging 172.16.1.5']
>>>

req_cfgspec_excl_diff(linespec, uncfgspec, cfgspec)

req_cfgspec_excl_diff accepts a linespec, an unconfig spec, and a list of required configuration elements. Return a list of configuration diffs to make the configuration comply. All other config lines matching the linespec that are not listed in the cfgspec will be removed with the uncfgspec regex.

Uses for this method include the need to enforce syslog, acl, or aaa standards.

Examples

>>> from ciscoconfparse import CiscoConfParse
>>> config = [
...     'logging trap debugging',
...     'logging 172.28.26.15',
...     ] 
>>> p = CiscoConfParse(config)
>>> required_lines = [
...     "logging 172.16.1.5",
...     "logging 1.10.20.30",
...     "logging 192.168.1.1",
...     ]
>>> linespec = "logging\s+\d+\.\d+\.\d+\.\d+"
>>> unconfspec = linespec
>>> diffs = p.req_cfgspec_excl_diff(linespec, unconfspec, 
...     required_lines)
>>> diffs
['no logging 172.28.26.15', 'logging 172.16.1.5', 'logging 1.10.20.30', 'logging 192.168.1.1']
>>>

save_as(filepath): Save a text copy of the configuration at filepath; this method uses the OperatingSystem’s native line separators (such as \r\n in Windows).

sync_diff(cfgspec, linespec, uncfgspec=None, ignore_order=True, remove_lines=True, debug=False)

sync_diff() accepts a list of required configuration elements, a linespec, and an unconfig spec. This method return a list of configuration diffs to make the configuration comply with cfgspec.

Parameters

cfgspeclist: A list of required configuration lines
linespecstr: A regular expression, which filters lines to be diff’d
uncfgspecstr: A regular expression, which is used to unconfigure lines. When ciscoconfparse removes a line, it takes the entire portion of the line that matches uncfgspec, and prepends “no” to it.
ignore_orderbool: Indicates whether the configuration should be reordered to minimize the number of diffs. Default: True (usually it’s a good idea to leave ignore_order True, except for ACL comparisions)
remove_linesbool: Indicates whether the lines which are not in cfgspec should be removed. Default: True. When remove_lines is True, all other config lines matching the linespec that are not listed in the cfgspec will be removed with the uncfgspec regex.
debugbool: Miscellaneous debugging; Default: False

Returns

list: A list of string configuration diffs
Uses for this method include the need to enforce syslog, acl, or
aaa standards.

Examples

>>> from ciscoconfparse import CiscoConfParse
>>> config = [
...     'logging trap debugging',
...     'logging 172.28.26.15',
...     ] 
>>> p = CiscoConfParse(config)
>>> required_lines = [
...     "logging 172.16.1.5",
...     "logging 1.10.20.30",
...     "logging 192.168.1.1",
...     ]
>>> linespec = "logging\s+\d+\.\d+\.\d+\.\d+"
>>> unconfspec = linespec
>>> diffs = p.sync_diff(required_lines, 
...     linespec, unconfspec) 
>>> diffs                     
['no logging 172.28.26.15', 'logging 172.16.1.5', 'logging 1.10.20.30', 'logging 192.168.1.1']
>>>


Reference : http://www.pennington.net/py/ciscoconfparse/api_CiscoConfParse.html

Related Posts

Leave a Comment Cancel reply