class TriggerUnconfigConfigEthernetInterface(TriggerUnconfigConfig): """Unconfigure and reapply the whole configurations of dynamically learned Ethernet interface(s).""" __description__ = """Unconfigure and reapply the whole configurations of dynamically learned Ethernet interface(s). trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 method (`str`): Method to recover the device configuration, Support methods: 'checkpoint': Rollback the configuration by checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 static: The keys below are dynamically learnt by default. However, they can also be set to a custom value when provided in the trigger datafile. interface: `str` (e.g) interface: '(?P<interface>Ethernet1*)' (Regex supported) OR interface: 'Ethernet1/1/1' (Specific value) steps: 1. Learn Interface Ops object and store the "up" Ethernet interface(s) if has any, otherwise, SKIP the trigger 2. Save the current device configurations through "method" which user uses 3. Unconfigure the learned Ethernet interface(s) from step 1 with Interface Conf object 4. Verify the configurations are all gone for the learned Ethernet interface(s) 5. Recover the device configurations to the one in step 2 6. Learn Interface Ops again and verify it is the same as the Ops in step 1 """ def remove_related_subinterface(item, interface, **kwargs): # Easiest way is to split at the dot, and see if it exists in name modified_item = item.split('.')[0] # If it remained the same, dont waste time if item == modified_item: return False # See if the modified_item exists in the list of name if modified_item in interface: return True return False mapping = Mapping(requirements={'ops.interface.interface.Interface':{ 'requirements':[['info', '(?P<interface>(GigabitEthernet|gigabitEthernet|Ethernet|ethernet)[0-9\/]+$)', 'enabled', True], ['info', '(?P<interface>(GigabitEthernet|gigabitEthernet|Ethernet|ethernet)[0-9\/]+$)', 'port_channel', 'port_channel_member', False], ['info', '(?P<interface>(GigabitEthernet|gigabitEthernet|Ethernet|ethernet)[0-9\/]+$)', 'oper_status', 'up']], 'exclude': interface_exclude}}, config_info={'conf.interface.Interface':{ 'requirements':[], 'verify_conf':False, 'kwargs':{'mandatory':{'name': '(?P<interface>.*)', 'attach': False}}}}, verify_ops={'ops.interface.interface.Interface':{ 'requirements':[['info', '(?P<interface>.*)', 'vrf', 'default'], ['info', '(?P<interface>.*)', 'enabled', False], ['info', '(?P<interface>.*)', 'oper_status', 'down'], ['info', '(?P<interface>.*)', 'delay', '(\d+)'], ['info', '(?P<interface>.*)', 'bandwidth', '(\d+)'], ['info', '(?P<interface>.*)', 'encapsulation', 'encapsulation', '(\S+)'], ['info', '(?P<interface>.*)', 'mac_address', '(\S+)'], ['info', '(?P<interface>.*)', 'medium', '(\S+)'], ['info', '(?P<interface>.*)', 'mtu', '(\d+)'], ['info', '(?P<interface>.*)', 'port_channel', 'port_channel_member', False]], 'exclude': interface_exclude +\ [remove_related_subinterface, '(Vlan.*)']}}, num_values={'interface': 1})
class TriggerShutNoShutBgpNeighbors(TriggerShutNoShut): """Shut and unshut the dynamically learned BGP neighbore(s).""" __description__ = """Shut and unshut the dynamically learned BGP neighbore(s). trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 static: The keys below are dynamically learnt by default. However, they can also be set to a custom value when provided in the trigger datafile. instance: `str` vrf: `str` neighbor: `str` bgp_id: `int` (e.g) interface: '(?P<interface>Ethernet1*)' (Regex supported) OR interface: 'Ethernet1/1/1' (Specific value) steps: 1. Learn BGP Ops object and verify if has established state, otherwise, Skip the trigger. 2. Shut the BGP neighbor that learned from step 1 with BGP Conf object 3. Verify the state of learned neighbor(s) from step 2 is "down" 4. Unshut the BGP neighbor(s) 5. Learn BGP Ops again and verify it is the same as the Ops in step 1 """ mapping = Mapping(\ requirements={\ 'ops.bgp.bgp.Bgp': { 'requirements':[\ ['info', 'instance', '(?P<instance>.*)', 'vrf', '(?P<vrf>.*)', 'neighbor', '(?P<neighbor>.*)', 'session_state', 'established'], ['info', 'instance', '(?P<instance>.*)', 'bgp_id', '(?P<bgp_id>.*)']], 'all_keys':True, 'kwargs': {'attributes':['info']}, 'exclude': bgp_exclude}}, config_info={\ 'conf.bgp.Bgp': { 'requirements':[\ ['device_attr', '{uut}', 'vrf_attr', '(?P<vrf>.*)', 'neighbor_attr', '(?P<neighbor>.*)', 'nbr_shutdown', True]], 'verify_conf':False, 'kwargs':{'mandatory':{'bgp_id': '(?P<bgp_id>.*)'}}}}, verify_ops={\ 'ops.bgp.bgp.Bgp': { 'requirements':[\ ['info', 'instance', '(?P<instance>.*)', 'vrf', '(?P<vrf>.*)', 'neighbor', '(?P<neighbor>.*)', 'session_state', 'idle'], ['info', 'instance', '(?P<instance>.*)', 'vrf', '(?P<vrf>.*)', 'neighbor', '(?P<neighbor>.*)', 'shutdown', True]], 'kwargs': {'attributes':['info']}, 'exclude': bgp_exclude}}, num_values={'instance':1, 'vrf':1, 'neighbor': 'all'})
class TriggerUnconfigConfigVxlanNveOverlayInterface(TriggerUnconfigConfig): """Unconfigure and reapply the dynamically learned Nve onverlay interface(s).""" __description__ = """Unconfigure and reapply the dynamically learned Nve onverlay interface(s). trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 steps: 1. Learn VxLan Ops object and verify if has any "up" Nve interface(s), otherwise, SKIP the trigger 2. Unconfigure the learned Nve interface(s) from step 1 with Interface Conf object 3. Verify the state of learned Nve interface(s) from step 2 is removed 4. Reapply the configuration of Nve interface(s) with checkpoint 5. Learn VxLan Ops again and verify it is the same as the Ops in step 1 """ # Mapping of Information between Ops and Conf # Also permit to dictate which key to verify mapping = Mapping( requirements={ 'ops.vxlan.vxlan.Vxlan': { 'requirements': [['nve', '(?P<name>.*)', 'if_state', 'up']], 'kwargs': { 'attributes': ['nve[(.*)][if_state]', 'nve[(.*)][vni][(.*)][vni]'] }, 'exclude': nve_exclude } }, config_info={ 'conf.interface.Interface': { 'requirements': [], 'verify_conf': False, 'kwargs': { 'mandatory': { 'name': '(?P<name>.*)', 'attach': False } } } }, verify_ops={ 'ops.vxlan.vxlan.Vxlan': { 'requirements': [['nve', '(?P<name>.*)']], 'kwargs': { 'attributes': ['nve[(.*)][if_state]', 'nve[(.*)][vni][(.*)][vni]'] }, 'exclude': nve_exclude } }, num_values={'name': 1})
class TriggerShutNoShutBgp(TriggerShutNoShut): """Shut BGP protocol by shutdown the dynamically learned BGP process, then unshut it by restart bpm. """ __description__ = """Shut BGP protocol by shutdown the dynamically learned BGP process, then unshut it by restart bpm. trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 static: The keys below are dynamically learnt by default. However, they can also be set to a custom value when provided in the trigger datafile. instance: `str` (e.g) interface: '(?P<interface>Ethernet1*)' (Regex supported) OR interface: 'Ethernet1/1/1' (Specific value) steps: 1. Learn BGP Ops object and store the BGP instance(s) if has any, otherwise, SKIP the trigger 2. Do "process shutdown bgp" 3. Verify the state of BGP instance(s) is "KILLED" 4. Do "process restart bpm" 5. Learn BGP Ops again and verify it is the same as the Ops in step 1 """ # Mapping of Information between Ops and Conf # Also permit to dictates which key to verify mapping = Mapping(requirements={ 'ops.bgp.bgp.Bgp': { 'requirements': [['info', 'instance', '(?P<instance>.*)', '(?P<instance_info>.*)']], 'kwargs': { 'attributes': ['info'] }, 'exclude': bgp_exclude } }, verify_ops={ 'ops.bgp.bgp.Bgp': { 'requirements': [[ 'info', 'instance', '(?P<instance>.*)', 'protocol_state', 'KILLED' ], [ 'info', 'instance', '(?P<instance>.*)', '(.*)' ]], 'kwargs': { 'attributes': ['info'] }, 'exclude': bgp_exclude } }, num_values={'instance': 'all'})
class TriggerUnconfigConfigPhysicalTrunkInterface(TriggerUnconfigConfig): """Unconfigure and reapply the whole configurations of dynamically learned physical trunk interface(s).""" __description__ = """Unconfigure and reapply the whole configurations of dynamically learned physical trunk interface(s). trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 method (`str`): Method to recover the device configuration, Support methods: 'checkpoint': Rollback the configuration by checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 static: The keys below are dynamically learnt by default. However, they can also be set to a custom value when provided in the trigger datafile. interface: `str` port_channel_int: `str` (e.g) interface: '(?P<interface>Ethernet1*)' (Regex supported) OR interface: 'Ethernet1/1/1' (Specific value) steps: 1. Learn Interface Ops object and store the "up" physical trunk interface(s) if has any, otherwise, SKIP the trigger 2. Save the current device configurations through "method" which user uses 3. Unconfigure the learned physical trunk interface(s) from step 1 with Interface Conf object 4. Verify the learned physical trunk interface(s) are "down" 5. Recover the device configurations to the one in step 2 6. Learn Interface Ops again and verify it is the same as the Ops in step 1 """ # Mapping of Information between Ops and Conf # Also permit to dictate which key to verify mapping = Mapping(requirements={'ops.interface.interface.Interface':{ 'requirements':[['info', '(?P<interface>\w+Ethernet[\d\/\.]+)', 'switchport_mode', 'trunk'], ['info', '(?P<interface>\w+Ethernet[\d\/\.]+)', 'port_channel', 'port_channel_int', '(?P<port_channel_int>.*)']], 'exclude': interface_exclude}}, config_info={'conf.interface.Interface':{ 'requirements':[], 'verify_conf':False, 'kwargs':{'mandatory':{'name': '(?P<interface>.*)', 'attach': False}}}}, verify_ops={'ops.interface.interface.Interface':{ 'requirements':[['info', '(?P<interface>.*)', 'oper_status', 'down'], ['info', '(?P<interface>.*)', 'enabled', False], ['info', '(?P<interface>.*)', 'port_channel', 'port_channel_member', False], ['info', '(?P<interface>.*)', 'mac_address', '([\w\.]+)'], ['info', '(?P<interface>.*)', '(.*)'], ['info', '(?P<port_channel_int>.*)', 'port_channel', 'port_channel_member_intfs', '(.*)'], ['info', '(Port-channel.*)', 'mac_address', '(.*)'], ['info', '(Port-channel.*)', 'phys_address', '(.*)']], 'exclude': interface_exclude}}, num_values={'interface':1})
class TriggerAddRemoveBgpNeighborRoutemapPrefixlist(TriggerAddRemove): """Apply the inbound dynamically learned "prefix-list" route-map to the dynamically learned BGP neighbor(s), and remove the added route-map configurations. """ __description__ = """Apply the inbound dynamically learned "prefix-list" route-map to the dynamically learned BGP neighbor(s), and remove the added route-map configurations. trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iterations when looping is needed, in second. Default: 15 method (`str`): Method to recover the device configuration, Support methods: 'checkpoint': Rollback the configuration by checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iterations when looping is needed, in second. Default: 15 static: The keys below are dynamically learnt by default. However, they can also be set to a custom value when provided in the trigger datafile. instance: `str` vrf: `str` address_family: `str` neighbor: `str` policy_definition: `str` statements: `str` bgp_id: `int` bgp_table_version: `int` (e.g) interface: '(?P<interface>Ethernet1*)' (Regex supported) OR interface: 'Ethernet1/1/1' (Specific value) steps: 1. Learn BGP Ops object and store the BGP neighbor(s) if has any, otherwise, SKIP the trigger. Learn RoutePolicy Ops object to store the route-map name with prefix-list configured if has any, otherwise, SKIP the trigger 2. Save the current device configurations through "method" which user uses 3. Add the configuration of the inbound route-map (step 1) to learned BGP neighbor(s) from step 1 with BGP Conf object 4. Verify the BGP neighbor(s) from step 3 has inbound route-map (step 1) configured 5. Remove the route-map (step 1) configurations from the learned BGP neighbor(s) from step 1 6. Recover the device configurations to the one in step 2 7. Learn BGP Ops again and verify it is the same as the Ops in step 1 """ mapping = Mapping( requirements={ 'ops.route_policy.route_policy.RoutePolicy': { 'requirements': [[ 'info', '(?P<policy_definition>.*)', 'statements', '(?P<statements>.*)', 'conditions', 'match_prefix_list', '(?P<match_prefix_list>.*)' ]], 'exclude': route_map_exclude }, 'ops.bgp.bgp.Bgp': { 'requirements': [[ 'info', 'instance', '(?P<instance>.*)', 'vrf', '(?P<vrf>.*)', 'neighbor', '(?P<neighbor>.*)', 'address_family', '(?P<address_family>.*)', 'bgp_table_version', '(?P<bgp_table_version>.*)' ], [ 'info', 'instance', '(?P<instance>.*)', 'bgp_id', '(?P<bgp_id>.*)' ]], 'all_keys': True, 'kwargs': { 'attributes': ['info'] }, 'exclude': bgp_exclude } }, config_info={ 'conf.bgp.Bgp': { 'requirements': [[ 'device_attr', '{uut}', 'vrf_attr', '(?P<vrf>.*)', 'neighbor_attr', '(?P<neighbor>.*)', 'address_family_attr', '(?P<address_family>.*)', 'nbr_af_route_map_name_in', '(?P<policy_definition>.*)' ]], 'verify_conf': False, 'kwargs': { 'mandatory': { 'bgp_id': '(?P<bgp_id>.*)' } } } }, verify_ops={ 'ops.bgp.bgp.Bgp': { 'requirements': [[ 'info', 'instance', '(?P<instance>.*)', 'vrf', '(?P<vrf>.*)', 'neighbor', '(?P<neighbor>.*)', 'address_family', '(?P<address_family>.*)', 'route_map_name_in', '(?P<policy_definition>.*)' ]], 'kwargs': { 'attributes': ['info'] }, 'exclude': bgp_exclude } }, num_values={ 'policy_definition': 1, 'statements': 'all', 'match_prefix_list': 1, 'instance': 1, 'vrf': 1, 'address_family': 1, 'neighbor': 1, 'bgp_id': 1, 'bgp_table_version': 1 })
class TriggerSwitchover(CommonSwitchover): """Do switchover on device.""" __description__ = """Do switchover on device. trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 static: The keys below are dynamically learnt by default. However, they can also be set to a custom value when provided in the trigger datafile. active_rp: `str` standby_rp: `str` (e.g) interface: '(?P<interface>Ethernet1*)' (Regex supported) OR interface: 'Ethernet1/1/1' (Specific value) steps: 1. Learn Platform Ops object and store the "active" RP and "standby" RP if has any, otherwise, SKIP the trigger 2. Do switchover by command "redundancy force-switchover" 3. Learn Platform Ops again and verify the roles of "active" RP and "standby" RP are swapped, and verify left attributes from the ops are the same as the Ops in step 1 4. Update platform PTS if feature pts is enabled, Update global/local veirifications if enabled """ # Mapping of Information between Ops and Conf # Also permit to dictates which key to verify mapping = Mapping(requirements={'ops.platform.platform.Platform':{ 'requirements': [\ [['slot', 'rp', '(?P<active_rp>.*)', 'redundancy_state', 'ACTIVE'], ['slot', 'rp', '(?P<active_rp>.*)', 'state', 'ok, active']], [['slot', 'rp', '(?P<standby_rp>.*)', 'redundancy_state', 'STANDBY HOT'], ['slot', 'rp', '(?P<standby_rp>.*)', 'state', 'ok, standby']], [['redundancy_communication', True]], ], 'all_keys': True, 'exclude': platform_exclude}}, verify_ops={'ops.platform.platform.Platform':{ 'requirements': [\ ['slot', 'rp', '(?P<active_rp>.*)', 'redundancy_state', 'STANDBY HOT'], ['slot', 'rp', '(?P<active_rp>.*)', 'state', 'ok, standby'], ['slot', 'rp', '(?P<standby_rp>.*)', 'redundancy_state', 'ACTIVE'], ['slot', 'rp', '(?P<standby_rp>.*)', 'state', 'ok, active']], 'exclude': platform_exclude}}, num_values={'active_rp':1, 'standby_rp':1})
class TriggerUnconfigConfigMsdpSaFilterIn(TriggerUnconfigConfig): """Unconfigure and reapply the whole configurations of dynamically learned MSDP peer(s) sa-filter in.""" __description__ = """Unconfigure and reapply the whole configurations of dynamically learned MSDP peer(s) sa-filter in. trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 method (`str`): Method to recover the device configuration, Support methods: 'checkpoint': Rollback the configuration by checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 static: The keys below are dynamically learnt by default. However, they can also be set to a custom value when provided in the trigger datafile. vrf: `str` peer: `str` sa_filter_in: `str` (e.g) interface: '(?P<interface>Ethernet1*)' (Regex supported) OR interface: 'Ethernet1/1/1' (Specific value) steps: 1. Learn Msdp Ops object and store the "established" MSDP peer(s) sa-filter in if has any, otherwise, SKIP the trigger 2. Save the current device configurations through "method" which user uses 3. Unconfigure the learned MSDP peer(s) sa-filter in from step 1 with Msdp Conf object 4. Verify the MSDP peer(s) sa-filter in from step 3 are no longer existed 5. Recover the device configurations to the one in step 2 6. Learn Msdp Ops again and verify it is the same as the Ops in step 1 """ # Mapping of Information between Ops and Conf # Also permit to dictate which key to verify mapping = Mapping(requirements={'ops.msdp.msdp.Msdp':{ 'requirements':[\ ['info', 'vrf', '(?P<vrf>.*)', 'peer', '(?P<peer>.*)', 'session_state', 'established'], ['info', 'vrf', '(?P<vrf>.*)', 'peer', '(?P<peer>.*)', 'sa_filter', 'in', '(?P<sa_filter_in>.*)']], 'kwargs':{'attributes': [ 'info[vrf][(.*)][peer][(.*)][session_state]', 'info[vrf][(.*)][peer][(.*)][sa_filter]']}, 'exclude': msdp_exclude}}, config_info={'conf.msdp.Msdp':{ 'requirements':[ ['device_attr', '{uut}', 'vrf_attr', '(?P<vrf>.*)', 'peer_attr', '(?P<peer>.*)', 'sa_filter_in','(?P<sa_filter_in>.*)']], 'verify_conf':False, 'kwargs':{}}}, verify_ops={'ops.msdp.msdp.Msdp':{ 'requirements':[\ ['info', 'vrf', '(?P<vrf>.*)', 'peer', '(?P<peer>.*)', 'sa_filter', NotExists('in')]], # , '(?P<sa_filter_in>.*)' 'kwargs':{'attributes': ['info[vrf][(.*)][peer][(.*)][session_state]', 'info[vrf][(.*)][peer][(.*)][sa_filter]']}, 'exclude': msdp_exclude}}, num_values={'vrf': 1, 'peer':1})
class TriggerAddRemoveIgmpVersion(TriggerAddRemove): """Apply Igmp interface version, and remove added Igmp interface version""" __description__ = """Apply Igmp interface version, and remove added Igmp interface version. trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 method (`str`): Method to recover the device configuration, Support methods: 'checkpoint': Rollback the configuration by checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 steps: 1. Learn Igmp Ops object and store the Igmp which interface version is default value. 2. Save the current device configurations through "method" which user uses 3. Add the configuration of igmp interface version with Igmp Conf object 4. Verify the igmp interface version from step 3 has configured 5. Remove the igmp interface version configurations. 6. Recover the device configurations to the one in step 2 7. Learn Igmp Ops again and verify it is the same as the Ops in step 1 """ ADD_VERSION = 3 # Mapping of Information between Ops and Conf # Also permit to dictate which key to verify mapping = Mapping(requirements={ 'ops.igmp.igmp.Igmp':{ 'requirements':[\ ['info', 'vrfs', '(?P<vrf>.*)', 'interfaces', '(?P<igmp_intf>.*)', 'enable', True], ['info', 'vrfs', '(?P<vrf>.*)', 'interfaces', '(?P<igmp_intf>.*)', 'version', '(?P<version>2)']], 'all_keys': True, 'kwargs':{'attributes': [ 'info[vrfs][(.*)]']}, 'exclude': igmp_exclude}}, config_info={'conf.igmp.Igmp':{ 'requirements':[ ['device_attr', '{uut}', 'vrf_attr', '(?P<vrf>.*)', 'interface_attr', '(?P<igmp_intf>.*)', 'version', ADD_VERSION]], 'verify_conf':False, 'kwargs':{}}}, verify_ops={ 'ops.igmp.igmp.Igmp':{ 'requirements':[\ ['info', 'vrfs', '(?P<vrf>.*)', 'interfaces', '(?P<igmp_intf>.*)', 'version', ADD_VERSION]], 'missing': False, 'kwargs':{'attributes': [ 'info[vrfs][(.*)]']}, 'exclude': igmp_exclude}}, num_values={'vrf': 1, 'igmp_intf': 1})
class TriggerAddRemoveNveAdvertiseVirtualRmac(TriggerAddRemove): """Add Virtual rmac advertised under vxlan and then restore the configuration by reapplying the whole running configuration""" __description__ = """Add msite bgw delay restore time under Vxlan then restore the configuration by reapplying the whole running configuration trigger_datafile: Mandatory Arguments: timeout: max_time (`int`): Maximum wait time for the trigger in seconds. Default: 180 interval (`int`): Wait time between iteration when looping is needed in seconds. Default: 15 method (`str`): Method to recover the device configuration. Supported methods: 'checkpoint': Rollback the configuration using checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional Arguments: tgn_timeout (`int`): Maximum wait time for all traffic streams to be restored to the reference rate in seconds. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed in seconds. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger in seconds. Default: 180 interval (`int`): Wait time between iteration when looping is needed in seconds. Default: 15 static: The keys below are dynamically learnt by default. However, they can also be set to a custom value when provided in the trigger datafile. nve_name: `str` (e.g) interface: '(?P<interface>Ethernet1*)' (Regex supported) OR interface: 'Ethernet1/1/1' (Specific value) Steps: 1. Learn Vxlan Ops configured on device. SKIP the trigger if there is no vxlan configured on the device. 2. Save the current device configurations using "method" specified. 3. Add virtual rmac advertised that using Genie Interface Conf. 4. Verify the newly Virtual rmac advertised under Vxlan is reflected in device configuration. 5. Restore the device configuration to the original configuration saved in step 2. 6. Learn Vxlan Ops again and verify it is the same as the Ops in step 1. """ mapping = Mapping(requirements={ 'ops.vxlan.vxlan.Vxlan': { 'requirements': [['nve', '(?P<nve_name>.*)', 'if_state', 'up'], ['nve', '(?P<nve_name>.*)', 'adv_vmac', False]], 'kwargs': { 'attributes': [ 'nve[(.*)][adv_vmac]', 'nve[(.*)][if_state]', 'nve[(.*)][vni]', 'bgp_l2vpn_evpn', 'l2route' ] }, 'all_keys': True, 'exclude': vxlan_exclude + multisite_exclude + l2route_exclude } }, config_info={ 'conf.interface.Interface': { 'requirements': [['nve_adv_virtual_rmac', True]], 'verify_conf': False, 'kwargs': { 'mandatory': { 'name': '(?P<nve_name>.*)', 'attach': False } } } }, verify_ops={ 'ops.vxlan.vxlan.Vxlan': { 'requirements': [['nve', '(?P<nve_name>.*)', 'if_state', 'up'], ['nve', '(?P<nve_name>.*)', 'adv_vmac', True]], 'kwargs': { 'attributes': [ 'nve[(.*)][adv_vmac]', 'nve[(.*)][if_state]', 'nve[(.*)][vni]', 'bgp_l2vpn_evpn', 'l2route' ] }, 'exclude': vxlan_exclude + ['bgp_l2vpn_evpn', 'l2route'] } }, num_values={'nve_name': 1})
class TriggerAddRemoveNveMultisiteBgwInterface(TriggerAddRemove): """Add multisite bgw interface under vxlan and then restore the configuration by reapplying the whole running configuration""" __description__ = """Add Add multisite bgw interface under Vxlan then restore the configuration by reapplying the whole running configuration trigger_datafile: Mandatory Arguments: timeout: max_time (`int`): Maximum wait time for the trigger in seconds. Default: 180 interval (`int`): Wait time between iteration when looping is needed in seconds. Default: 15 method (`str`): Method to recover the device configuration. Supported methods: 'checkpoint': Rollback the configuration using checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional Arguments: tgn_timeout (`int`): Maximum wait time for all traffic streams to be restored to the reference rate in seconds. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed in seconds. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger in seconds. Default: 180 interval (`int`): Wait time between iteration when looping is needed in seconds. Default: 15 static: The keys below are dynamically learnt by default. However, they can also be set to a custom value when provided in the trigger datafile. nve_name: `str` source_if: `str` (e.g) interface: '(?P<interface>Ethernet1*)' (Regex supported) OR interface: 'Ethernet1/1/1' (Specific value) Steps: 1. Learn Vxlan Ops configured on device. SKIP the trigger if there is no Vxlan configured on the device. 2. Save the current device configurations using "method" specified. 3. Add multisite bgw interface that using Genie Interface Conf. 4. Verify the newly multisite bgw interface under Vxlan is reflected in device configuration. 5. Restore the device configuration to the original configuration saved in step 2. 6. Learn Vxlan Ops again and verify it is the same as the Ops in step 1. """ # configuration steps callable # adding new value for multisite bgw interface def configure_multisite_bgw_interface(self, conf_obj, unconfig, **kwargs): ret = "" for key in self.keys: if key['source_if'] != key['intf_name']: ret = key['intf_name'] self.keys[0]['multisite_bgw_intf'] = ret conf_obj.nve_multisite_bgw_intf = ret if not unconfig: conf_obj.build_config() else: conf_obj.build_unconfig(apply=True, attributes={'nve_multisite_bgw_intf': ret}) @aetest.test def verify_configuration(self, uut, abstract, steps): # modify self.keys to modify the multisite bgw interface value for item in self.mapping.keys: try: ret = item['multisite_bgw_intf'] req = ['nve', '(?P<nve_name>.*)', 'multisite_bgw_if'] req.insert(len(req), ret) self.mapping._verify_ops_dict['ops.vxlan.vxlan.Vxlan'][ 'requirements'].append(req) log.info("\n\nVerifying the following requirements: {req}". format(req=req)) except Exception as e: self.failed('Failed to verify the ' 'added feature', from_exception=e) super().verify_configuration(uut, abstract, steps) mapping = Mapping(requirements={'ops.vxlan.vxlan.Vxlan':{ 'requirements': [[['nve', '(?P<nve_name>.*)', 'source_if', '(?P<source_if>.*)']], [['nve', '(?P<nve_name>.*)', NotExists('multisite_bgw_if')]]], 'all_keys': True, 'kwargs': {'attributes': ['nve']}, 'exclude': vxlan_exclude}, 'ops.interface.interface.Interface':{ 'requirements': [['info', '(?P<intf_name>loopback.*)', 'oper_status', 'up']], 'kwargs': {'attributes': ['info']}, 'exclude': interface_exclude}}, config_info={'conf.interface.Interface': { 'requirements': [[partial(configure_multisite_bgw_interface,\ nve_multisite_bgw_intf='(?P<source_if>.*)')]], 'verify_conf': False, 'kwargs': {'mandatory': {'name': '(?P<nve_name>.*)', 'attach': False}}}}, verify_ops={'ops.vxlan.vxlan.Vxlan': { 'requirements': [], 'kwargs': {'attributes': ['nve']}, 'exclude': vxlan_exclude}}, num_values={'nve_name':'all', 'source_if': 'all', 'intf_name':'all'})
class TriggerModifyPimNeighborFilter(TriggerModify): """Modify dynamically learned PIM interface(s)'s neighbor-filter then restore the configuration by reapplying the whole running configuration.""" __description__ = """Modify dynamically learned PIM interface(s)'s neighbor-filter then restore the configuration by reapplying the whole running configuration. trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 method (`str`): Method to recover the device configuration, Support methods: 'checkpoint': Rollback the configuration by checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 static: The keys below are dynamically learnt by default. However, they can also be set to a custom value when provided in the trigger datafile. vrf: `str` address_family: `str` interface: `str` neighbor_filter: `str` (e.g) interface: '(?P<interface>Ethernet1*)' (Regex supported) OR interface: 'Ethernet1/1/1' (Specific value) steps: 1. Learn Pim Ops object and store the PIM interface(s)'s neighbor-filter if has any, otherwise, SKIP the trigger 2. Save the current device configurations through "method" which user uses 3. Modify the learned PIM interface(s)'s neighbor-filter from step 1 with Pim Conf object 4. Verify the PIM interface(s)'s neighbor-filter from step 3 is reflected in device configuration 5. Recover the device configurations to the one in step 2 6. Learn Pim Ops again and verify it is the same as the Ops in step 1 """ MODIFY_NAME = 'modified_pim_neighbor_policy' # Mapping of Information between Ops and Conf # Also permit to dictate which key to verify mapping = Mapping(requirements={ 'ops.pim.pim.Pim':{ 'requirements':[\ ['info', 'vrf', '(?P<vrf>.*)', 'interfaces', '(?P<interface>.*)', 'address_family', '(?P<address_family>.*)', 'neighbor_filter', '(?P<neighbor_filter>.*)'], ['info', 'vrf', '(?P<vrf>.*)', 'interfaces', '(?P<interface>.*)', 'address_family', '(?P<address_family>.*)', 'oper_status', 'up']], 'kwargs':{'attributes': [ 'info[vrf][(.*)][interfaces][(.*)][address_family][(.*)][oper_status]', 'info[vrf][(.*)][interfaces][(.*)][address_family][(.*)][neighbor_filter]']}, 'exclude': pim_exclude}}, config_info={'conf.pim.Pim':{ 'requirements':[ ['device_attr', '{uut}', 'vrf_attr', '(?P<vrf>.*)', 'address_family_attr', '(?P<address_family>.*)', 'interface_attr', '(?P<interface>.*)', 'neighbor_filter', MODIFY_NAME]], 'verify_conf':False, 'kwargs':{}}}, verify_ops={ 'ops.pim.pim.Pim':{ 'requirements':[\ ['info', 'vrf', '(?P<vrf>.*)', 'interfaces', '(?P<interface>.*)', 'address_family', '(?P<address_family>.*)', 'neighbor_filter', MODIFY_NAME], ['info', 'vrf', '(?P<vrf>.*)', 'interfaces', '(?P<interface>.*)', 'address_family', '(?P<address_family>.*)', 'oper_status', 'up']], 'kwargs':{'attributes': [ 'info[vrf][(.*)][interfaces][(.*)][address_family][(.*)][oper_status]', 'info[vrf][(.*)][interfaces][(.*)][address_family][(.*)][neighbor_filter]']}, 'exclude': pim_exclude}}, num_values={'vrf': 1, 'address_family': 1, 'interface': 1})
class TriggerUnconfigConfigVlanVnsegment(TriggerUnconfigConfig): """Unconfigure and reapply the whole configurations of dynamically learned vlan(s).""" __description__ = """Unconfigure and reapply the whole configurations of dynamically learned vlan(s). trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 method (`str`): Method to recover the device configuration, Support methods: 'checkpoint': Rollback the configuration by checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout when the previous timeout has been exhausted, to make sure the devices are recovered before ending the trigger max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 static: The keys below are dynamically learnt by default. However, they can also be set to a custom value when provided in the trigger datafile. vlan: `str` vn_segment_id: `int` (e.g) interface: '(?P<interface>Ethernet1*)' (Regex supported) OR interface: 'Ethernet1/1/1' (Specific value) steps: 1. Learn Vlan Ops object and store the "unshut" vlan(s) if has any, otherwise, SKIP the trigger 2. Save the current device configurations through "method" which user uses 3. Unconfigure the learned vn_segment_id with Vlan Conf object 4. Verify the vlan(s) from step 3 are no longer existed 5. Recover the device configurations to the one in step 2 6. Learn Vlan Ops again and verify it is the same as the Ops in step 1 """ # Mapping of Information between Ops and Conf # Also permit to dictates which key to verify mapping = Mapping(requirements={ 'ops.vlan.vlan.Vlan': { 'requirements': [[ 'info', 'vlans', '(?P<vlan>.*)', 'vn_segment_id', '(?P<vn_segment_id>.*)' ]], 'kwargs': { 'attributes': ['info[vlans][(.*)][vn_segment_id]'] }, 'all_keys': True, 'exclude': vlan_exclude } }, config_info={ 'conf.vlan.Vlan': { 'requirements': [[ 'device_attr', '{uut}', 'vlan_attr', '(?P<vlan>.*)', 'vn_segment_id', '(?P<vn_segment_id>.*)' ]], 'verify_conf': False, 'kwargs': {} } }, verify_ops={ 'ops.vlan.vlan.Vlan': { 'requirements': [['info', 'vlans', NotExists('(?P<vlan>.*)')]], 'kwargs': { 'attributes': ['info[vlans][(.*)][vn_segment_id]'] }, 'exclude': vlan_exclude } }, num_values={'vlan': 1})
class TriggerUnconfigConfigEthernetInterfaceSub(TriggerUnconfigConfig): """Unconfigure and reapply the whole configurations of dynamically learned Ethernet SubInterface(s).""" __description__ = """Unconfigure and reapply the whole configurations of dynamically learned Ethernet SubInterface(s). trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 method (`str`): Method to recover the device configuration, Support methods: 'checkpoint': Rollback the configuration by checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 static: The keys below are dynamically learnt by default. However, they can also be set to a custom value when provided in the trigger datafile. interface: `str` (e.g) interface: '(?P<interface>Ethernet1*)' (Regex supported) OR interface: 'Ethernet1/1/1' (Specific value) steps: 1. Learn Interface Ops object and store the "up" Ethernet SubInterface(s) if has any, otherwise, SKIP the trigger 2. Save the current device configurations through "method" which user uses 3. Unconfigure the learned Ethernet SubInterface(s) from step 1 with Interface Conf object 4. Verify the learned Ethernet SubInterface(s) are no longer existed 5. Recover the device configurations to the one in step 2 6. Learn Interface Ops again and verify it is the same as the Ops in step 1 """ mapping = Mapping(requirements={ 'ops.interface.interface.Interface': { 'requirements': [[ 'info', '(?P<interface>(GigabitEthernet|gigabitEthernet|Ethernet|ethernet)[0-9\/]+\.[0-9]+)', 'enabled', True ], [ 'info', '(?P<interface>(GigabitEthernet|gigabitEthernet|Ethernet|ethernet)[0-9\/]+\.[0-9]+)', 'oper_status', 'up' ]], 'exclude': interface_exclude } }, config_info={ 'conf.interface.Interface': { 'requirements': [], 'verify_conf': False, 'kwargs': { 'mandatory': { 'name': '(?P<interface>.*)', 'attach': False } } } }, verify_ops={ 'ops.interface.interface.Interface': { 'requirements': [['info', NotExists('(?P<interface>.*)')]], 'exclude': interface_exclude + ['(Vlan.*)'] } }, num_values={'interface': 1})
class TriggerShutNoShutDot1xInterface(TriggerShutNoShut): """Shut and unshut the dynamically learned Dot1x Ethernet interface(s).""" __description__ = """Shut and unshut the dynamically learned Dot1x Ethernet interface(s). trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 static: The keys below are dynamically learnt by default. However, they can also be set to a custom value when provided in the trigger datafile. interface: `str` vlan: `str` client: `str` (e.g) interface: '(?P<interface>Ethernet1*)' (Regex supported) OR interface: 'Ethernet1/1/1' (Specific value) steps: 1. Learn Interface Ops object and store the "up" Ethernet interface(s) if has any, otherwise, SKIP the trigger, then check if the status of dot1x is 'auth', and the peer mac-address in UUT's table is 'static', if not, SKIP the trigger And Learn Dot1x Ops object and store the dot1x interface whcih are from the interface ops. 2. Shut the learned Dot1x Ethernet interface(s) from step 1 with Interface Conf object 3. Verify the state of learned Dot1x Ethernet interface(s) from step 2 is "down" 4. Unshut the Dot1x Ethernet interface(s) with Interface Conf object 5. Learn Interface Ops again and verify it is the same as the Ops in step 1 """ # Mapping of Information between Ops and Conf # Also permit to dictate which key to verify mapping = Mapping( requirements={ 'ops.interface.interface.Interface': { 'requirements': [[ 'info', '(?P<interface>\w+Ethernet[\d\/]+$)', 'enabled', True ], ['info', '(?P<interface>.*)', 'switchport_enable', True], [ 'info', '(?P<interface>.*)', 'switchport_mode', 'static access' ], ['info', '(?P<interface>.*)', 'oper_status', 'up']], 'all_keys': True, 'kwargs': { 'attributes': [ 'info[(.*)][switchport_mode]', 'info[(.*)][oper_status]', 'info[(.*)][enabled]', 'info[(.*)][switchport_enable]', 'info[(.*)][operational_mode]' ] }, 'exclude': interface_exclude }, 'ops.fdb.fdb.Fdb': { 'requirements': [ [ 'info', 'mac_table', 'vlans', '(?P<vlan>.*)', 'mac_addresses', '(?P<client>.*)', 'interfaces', '(?P<interface>.*)', 'entry_type', 'static' ] ], 'all_keys': True, 'kwargs': { 'attributes': ['info[mac_table][vlans][(.*)]'] }, 'exclude': fdb_exclude + ['mac_addresses'] }, 'ops.dot1x.dot1x.Dot1x': { 'requirements': [ [ 'info', 'interfaces', '(?P<interface>.*)', 'clients', '(?P<client>.*)', 'status', 'authorized' ] ], 'kwargs': { 'attributes': ['info[interfaces][(.*)][clients][(.*)][status]'] }, 'all_keys': True, 'exclude': dot1x_exclude } }, config_info={ 'conf.interface.Interface': { 'requirements': [['enabled', False]], 'verify_conf': False, 'kwargs': { 'mandatory': { 'name': '(?P<interface>.*)', 'attach': False } } } }, verify_ops={ 'ops.interface.interface.Interface': { 'requirements': [['info', '(?P<interface>.*)', 'enabled', False], ['info', '(?P<interface>.*)', 'oper_status', 'down'], ['info', '(?P<interface>.*)', 'switchport_enable', False]], 'kwargs': { 'attributes': [ 'info[(.*)][switchport_mode]', 'info[(.*)][oper_status]', 'info[(.*)][enabled]', 'info[(.*)][switchport_enable]', 'info[(.*)][operational_mode]' ] }, 'exclude': interface_exclude }, 'ops.fdb.fdb.Fdb': { 'requirements': [[ 'info', 'mac_table', 'vlans', '(?P<vlan>.*)', 'mac_addresses', NotExists('(?P<client>.*)') ]], 'kwargs': { 'attributes': ['info[mac_table][vlans][(.*)]'] }, 'exclude': fdb_exclude + ['mac_addresses'] }, 'ops.dot1x.dot1x.Dot1x': { 'requirements': [['info', 'interfaces', NotExists('(?P<interface>.*)')]], 'kwargs': { 'attributes': ['info[interfaces][(.*)][clients][(.*)][status]'] }, 'all_keys': True, 'exclude': dot1x_exclude + ['attributes'] } }, num_values={'interface': 'all'})
class TriggerAddRemoveIgmpEnable(TriggerAddRemove): """Apply the Igmp interface enable, add remove added Igmp interface enable""" __description__ = """Apply the Igmp interface enable, add remove added Igmp interface enable. trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 method (`str`): Method to recover the device configuration, Support methods: 'checkpoint': Rollback the configuration by checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 steps: 1. Learn Igmp Ops/Conf object and store the Igmp interface enable, learn Interface ops to get interface with ip address and not same to the existing igmp interface. 2. Save the current device configurations through "method" which user uses 3. Add the configuration of interface as igmp originator-id with Igmp Conf object 4. Verify the igmp interface enable from step 3 has configured 5. Remove the igmp interface enable configurations. 6. Recover the device configurations to the one in step 2 7. Learn Igmp Ops again and verify it is the same as the Ops in step 1 """ @aetest.setup def verify_prerequisite(self, uut, abstract, steps, timeout): # learn existing igmp interfaces super().verify_prerequisite(uut, abstract, steps, timeout) igmp_keys = self.mapping.keys # learn interafce ops to get ipv4 up interfaces self.mapping.requirements = {} self.mapping.requirements['ops.interface.interface.Interface'] = \ {'requirements':[['info', '(?P<igmp_intf>^(?!mgmt).*)', 'ipv4', '(?P<ip>.*)', 'ip', '(?P<address>.*)'], ['info', '(?P<igmp_intf>.*)', 'vrf', '(?P<add_igmp_intf_vrf>.*)']], 'all_keys': True, 'kwargs':{'attributes': [ 'info[(.*)][ipv4][(.*)][ip]', 'info[(.*)][vrf]']}, 'exclude': interface_exclude} super().verify_prerequisite(uut, abstract, steps, timeout) intf_keys = self.mapping.keys # find interface with steps.start("Extracting ipv4 interfaces " "which are not igmp interfaces") as step: add_keys = {} for item in intf_keys: if all(item['igmp_intf'] not in \ i['igmp_intf'] for i in igmp_keys): # attach the add value to mapping keys add_keys.update({ 'add_igmp_intf': item['igmp_intf'], 'add_igmp_intf_vrf': item['add_igmp_intf_vrf'] }) break if not add_keys: step.skipped('Could not find up ipv4 interface which is ' 'not existed igmp interface') self.skipped( 'Could not find up ipv4 interface which is ' 'not existed igmp interface', goto=['next_tc']) self.mapping.keys = [add_keys] # Mapping of Information between Ops and Conf # Also permit to dictate which key to verify mapping = Mapping(requirements={'ops.igmp.igmp.Igmp':{ 'requirements':[\ ['info', 'vrfs', '(?P<vrf>.*)', 'interfaces', '(?P<igmp_intf>.*)']], 'kwargs':{'attributes': [ 'info[vrfs][(.*)][interfaces]']}, 'exclude': igmp_exclude}}, config_info={'conf.igmp.Igmp':{ 'requirements':[ ['device_attr', '{uut}', 'vrf_attr', '(?P<add_igmp_intf_vrf>.*)', 'interface_attr', '(?P<add_igmp_intf>.*)', 'enable', True]], 'verify_conf':False, 'kwargs':{}}}, verify_ops={'ops.igmp.igmp.Igmp':{ 'requirements':[\ ['info', 'vrfs', '(?P<add_igmp_intf_vrf>.*)', 'interfaces', '(?P<add_igmp_intf>.*)', 'enable', True]], 'kwargs':{'attributes': ['info[vrfs][(.*)][interfaces]']}, 'exclude': igmp_exclude}}, num_values={'vrf': 'all', 'igmp_intf': 'all'})
class TriggerModifyVlanVnsegment(TriggerModify): """Modify and revert the vnsegemnt for dynamically learned vlan(s).""" __description__ = """Modify and revert the vnsegemnt for dynamically learned vlan(s). trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 method (`str`): Method to recover the device configuration, Support methods: 'checkpoint': Rollback the configuration by checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 static: The keys below are dynamically learnt by default. However, they can also be set to a custom value when provided in the trigger datafile. vlan: `str` vn_segment: `int` (e.g) interface: '(?P<interface>Ethernet1*)' (Regex supported) OR interface: 'Ethernet1/1/1' (Specific value) steps: 1. Learn Vlan Ops object and store the vlan which is active and has vnsegment. SKIP the trigger if there is no VLAN(s) found 2. Save the current device configurations through "method" which user uses 3. Modify the vnsegment of the learned VLAN from step 1 with VLAN Conf object 4. Verify the vnsegment of the learned VLAN from step 3 changes to the modified value in step 3, 5. Recover the device configurations to the one in step 2 6. Learn VLAN Ops again and verify it is the same as the Ops in step 1 """ VN_SEGMENT = 1111 @aetest.test def modify_configuration(self, uut, abstract, steps): '''Modify configuration on the uut device Args: uut (`obj`): Device object. abstract (`obj`): Abstract object. steps (`step obj`): aetest step object Returns: None Raises: pyATS Results ''' # Flap vlan for config change to take effect cmd = "vlan (?P<vlan>.*)\n" \ " no vn-segment\n" \ " vn-segment {}\n".format(self.VN_SEGMENT) x = re.findall(r'\S+|\n', cmd) req = self.mapping._path_population([x], uut) req_str = [] for item in req[0]: req_str.append(str(item)) cmd = ' '.join(req_str) try: uut.configure(cmd) except Exception as e: self.failed('Failed to modify the configuration', from_exception=e) # Mapping of Information between Ops and Conf # Also permit to dictates which key to verify mapping = Mapping(requirements={'ops.vlan.vlan.Vlan':{ 'requirements':[['info', 'vlans', '(?P<vlan>.*)', 'state', 'active'], ['info', 'vlans', '(?P<vlan>.*)', 'vn_segment_id', '(?P<vn_segment>^(?!1111).*)$']], 'kwargs':{'attributes':['info[vlans][(.*)][vn_segment_id]', 'info[vlans][(.*)][state]']}, 'all_keys':True, 'exclude': vlan_exclude}}, config_info={'conf.vlan.Vlan':{ 'requirements':[['device_attr', '{uut}', 'vlan_attr', '(?P<vlan>.*)',\ 'vn_segment_id', VN_SEGMENT]], 'verify_conf':False, 'kwargs':{}}}, verify_ops={'ops.vlan.vlan.Vlan':{ 'requirements':[['info','vlans','(?P<vlan>.*)','state','active'], ['info','vlans','(?P<vlan>.*)','vn_segment_id',VN_SEGMENT]], 'kwargs':{'attributes':['info[vlans][(.*)][vn_segment_id]', 'info[vlans][(.*)][state]']}, 'exclude': vlan_exclude}}, num_values={'vlan': 1})
class TriggerAddRemoveIgmpStaticGroup(TriggerAddRemove): """Apply the Igmp interface static-group, and remove added Igmp interface static-group""" __description__ = """Apply the Igmp interface static-group, and remove added Igmp interface static-group. trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 method (`str`): Method to recover the device configuration, Support methods: 'checkpoint': Rollback the configuration by checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 steps: 1. Learn Igmp Ops object and store the Igmp interface(s) which does not have added static-group. 2. Save the current device configurations through "method" which user uses 3. Add the configuration of igmp interface static-group with Igmp Conf object 4. Verify the igmp interface static-group from step 3 has configured 5. Remove the igmp interface static-group configurations. 6. Recover the device configurations to the one in step 2 7. Learn Igmp Ops again and verify it is the same as the Ops in step 1 """ ADD_STATIC_GROUP = '234.1.1.2 *' @aetest.setup def verify_prerequisite(self, uut, abstract, steps, timeout, add_igmp_group=None): self.timeout = timeout try: self.pre_snap = self.mapping.learn_ops(device=uut, abstract=abstract, steps=steps, timeout=timeout) except Exception as e: self.errored("Section failed due to: '{e}'".format(e=e)) # nothing in the static groups, # then learn if any groups to have some vrf interface value if any(not item for item in self.mapping.keys): self.mapping.requirements['ops.igmp.igmp.Igmp']['requirements'] = \ [['info', 'vrfs', '(?P<vrf>.*)', 'interfaces', '(?P<igmp_intf>.*)', 'group', '(?P<group>.*)', '(?P<dummy>.*)']] # incase there is nothing learned try: self.pre_snap = self.mapping.learn_ops(device=uut, abstract=abstract, steps=steps, timeout=timeout) except Exception as e: self.errored("Section failed due to: '{e}'".format(e=e)) if any(not item for item in self.mapping.keys): self.skipped('Cannot learn the feature', goto=['next_tc']) with steps.start("Check if added group %s not in the " "existing groups" % self.ADD_STATIC_GROUP) as step: # learn igmp ops to have existing igmp interfaces if any(self.ADD_STATIC_GROUP in \ item.get('static_group', '') for item in self.mapping.keys): if add_igmp_group: self.ADD_STATIC_GROUP = add_igmp_group else: self.skipped('Could not find static_group does not ' 'include the added group %s' % self.ADD_STATIC_GROUP, goto=['next_tc']) # attach the add value to mapping keys [ item.update({ 'add_igmp_group': self.ADD_STATIC_GROUP.split()[0], 'add_igmp_source': self.ADD_STATIC_GROUP.split()[1], 'add_igmp_group_key': self.ADD_STATIC_GROUP }) for item in self.mapping.keys ] step.passed('Will add group %s' % self.ADD_STATIC_GROUP) # Mapping of Information between Ops and Conf # Also permit to dictate which key to verify mapping = Mapping(requirements={ 'ops.igmp.igmp.Igmp':{ 'requirements':[\ ['info', 'vrfs', '(?P<vrf>.*)', 'interfaces', '(?P<igmp_intf>.*)', 'static_group', '(?P<static_group>.*)', 'group', '(?P<group>.*)']], 'all_keys': True, 'kwargs':{'attributes': [ 'info[vrfs][(.*)][interfaces][(.*)][join_group][(.*)]', 'info[vrfs][(.*)][interfaces][(.*)][static_group][(.*)]', 'info[vrfs][(.*)][interfaces][(.*)][group][(.*)]']}, 'exclude': igmp_exclude}}, config_info={'conf.igmp.Igmp':{ 'requirements':[ [partial(configure_add_attributes, # callable configuration add_obj=IgmpGroup, base=[['device_attr', '{uut}', 'vrf_attr', '(?P<vrf>.*)', 'interface_attr', '(?P<igmp_intf>.*)']], add_attribute=[['static_group', '(?P<add_igmp_group>.*)'], ['static_group_source_addr', '(?P<add_igmp_source>.*)'],], add_method='add_groups', )]], 'verify_conf':False, 'kwargs':{}}}, verify_ops={ 'ops.igmp.igmp.Igmp':{ 'requirements':[\ ['info', 'vrfs', '(?P<vrf>.*)', 'interfaces', '(?P<igmp_intf>.*)', 'static_group', '(?P<add_igmp_group_key>.*)', 'group', '(?P<add_igmp_group>.*)'], ['info', 'vrfs', '(?P<vrf>.*)', 'interfaces', '(?P<igmp_intf>.*)', 'static_group', '(?P<add_igmp_group_key>.*)', 'source', '(?P<add_igmp_source>.*)'], ['info', 'vrfs', '(?P<vrf>.*)', 'interfaces', '(?P<igmp_intf>.*)', 'group', '(?P<add_igmp_group>.*)', 'last_reporter', '([\w\.]+)']], 'kwargs':{'attributes': [ 'info[vrfs][(.*)][interfaces][(.*)][join_group][(.*)]', 'info[vrfs][(.*)][interfaces][(.*)][static_group][(.*)]', 'info[vrfs][(.*)][interfaces][(.*)][group][(.*)]']}, 'exclude': igmp_exclude}}, num_values={'vrf': 1, 'igmp_intf': 1, 'static_group': 1, 'group': 1, 'source': 1})
class TriggerDisableEnablePim(TriggerDisableEnable): """Disable and enable feature Pim.""" __description__ = """Disable and enable feature Pim. trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 method (`str`): Method to recover the device configuration, Support methods: 'checkpoint': Rollback the configuration by checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 steps: 1. Learn Mcast Ops object and store the Mcast vrf(s) with ipv4 feature enabled if has any, otherwise, SKIP the trigger 2. Save the current device configurations through "method" which user uses 3. Disable pim feature with command "no feature pim" via Mcast Conf object 4. Verify the state of feature pim is "disabled" 5. Recover the device configurations to the one in step 2 6. Verify the state of feature pim is "enabled" and learn Mcast Ops again and verify it is the same as the Ops in step 1 """ mapping = Mapping(requirements={'ops.mcast.mcast.Mcast':{ 'requirements':[\ ['info', 'vrf', '(?P<vrf>.*)', 'address_family', 'ipv4', 'enable', True]], 'kwargs':{'attributes':['info']}, 'exclude': mcast_exclude}}, config_info={'conf.mcast.Mcast':{ 'requirements':[['device_attr', '{uut}', 'vrf_attr', None, 'address_family_attr', 'ipv4', 'enabled', True]], 'verify_conf':False}}, verify_ops={'ops.mcast.mcsat.Mcast':{ 'requirements':[\ ['info', 'vrf', '(?P<vrf>.*)', 'address_family', 'ipv4', 'enable', False]], 'kwargs':{'attributes':['info']}, 'exclude': mcast_exclude}}) # feature name # used for creating checkpoint name and log information feature_name = 'pim'
class TriggerModifyLldpTimer(TriggerModify): """Modify and revert the LLDP timer""" __description__ = """Modify and revert the LLDP timer. trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 method (`str`): Method to recover the device configuration, Support methods: 'checkpoint': Rollback the configuration by checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 steps: 1. Learn LLDP Ops object to check if LLDP enabled on peer routers, otherwise SKIP the trigger 2. Save the current device configurations through "method" which user uses 3. Modify the LLDP timer to user defined value with LLDP Conf object on peer routers 4. Verify the LLDP timer from step 3 changes to the modified value in step 3, verify LLDP neighbors are not changed 5. Recover the device configurations to the one in step 2 6. Learn LLDP Ops again and verify it is the same as the Ops in step 1 """ mapping = Mapping(requirements={'ops.lldp.lldp.Lldp': { 'requirements':[\ ['info', 'enabled', True], ['info', 'interfaces', '(?P<intf>.*)', 'neighbors', '(?P<peer>.*)', 'neighbor_id', '(?P<neighbor>.*)'] ], 'all_keys': True, 'kwargs':{'attributes':['info[enabled]', 'info[interfaces][(.*)][neighbors][(.*)]']}, 'exclude': lldp_exclude}}, config_info={'conf.lldp.Lldp':{ 'requirements':[['device_attr', '{uut}', 'hello_timer', 5]], 'verify_conf':False, 'kwargs':{}}}, verify_ops={'ops.lldp.lldp.Lldp':{ 'requirements':[['info', 'hello_timer', 5],], 'kwargs':{'attributes':['info[hello_timer]', 'info[enabled]', 'info[interfaces][(.*)][neighbors][(.*)]']}, 'exclude': lldp_exclude}}, num_values={'intf': 'all', 'neighbor': 1, 'peer': 'all'})
class TriggerSwitchover(CommonSwitchover): """Do switchover on device.""" __description__ = """Do switchover on device. trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 steps: 1. Learn Platform Ops object and store the "active" RP and "standby" RP if has any, otherwise, SKIP the trigger 2. Do switchover by command "redundancy force-switchover" 3. Learn Platform Ops again and verify the roles of "active" RP and "standby" RP are swapped, and verify left attributes from the ops are the same as the Ops in step 1 4. Update platform PTS if feature pts is enabled, Update global/local veirifications if enabled """ @aetest.setup def verify_prerequisite(self, uut, abstract, steps, timeout): '''Learn Ops object and verify the requirements. If the requirements are not satisfied, then skip to the next testcase. Args: uut (`obj`): Device object. abstract (`obj`): Abstract object. steps (`step obj`): aetest step object timeout (`timeout obj`): Timeout Object Returns: None Raises: pyATS Results ''' self.timeout = timeout try: self.pre_snap = self.mapping.learn_ops(device=uut, abstract=abstract, steps=steps, timeout=self.timeout) except Exception as e: self.skipped('Cannot learn the feature', from_exception=e, goto=['next_tc']) for stp in steps.details: if stp.result.name == 'skipped': self.skipped('Cannot learn the feature', goto=['next_tc']) self.print_local_verifications() # get and store the member priority list try: out = ShowPlatform(device=uut).parse() # inital priority storage priority_dict = {} priority_list = [] if 'slot' in out: for slot in out['slot']: for rp in out['slot'][slot]['rp']: if out['slot'][slot]['rp'][rp]['role'] == 'Member': priority_dict[slot] = \ out['slot'][slot]['rp'][rp]['priority'] priority_list.append( out['slot'][slot]['rp'][rp]['priority']) if len(list(set(priority_list))) != 1: # sorted the slot priority priority_list = sorted(priority_dict.items(), key=lambda x: x[1]) # update the verify_ops requirements for ops, requirements in self.mapping._verify_ops_dict.items( ): if 'platform' in ops: self.mapping._verify_ops_dict[ops][ 'requirements'].append([ 'slot', 'rp', '{}'.format(priority_list[-1][0]), 'swstack_role', 'Standby' ]) else: # update the verify_ops requirements for ops, requirements in self.mapping._verify_ops_dict.items( ): if 'platform' in ops: self.mapping._verify_ops_dict[ops][ 'requirements'].append([ 'slot', 'rp', '(?P<members>.*)', 'swstack_role', '(Standby|Member)' ]) except Exception as e: log.warn('Cannot get the member priority. \n{}'.format(str(e))) # Mapping of Information between Ops and Conf # Also permit to dictates which key to verify mapping = Mapping(requirements={'ops.platform.platform.Platform':{ 'requirements': [\ [['slot', 'rp', '(?P<active_rp>.*)', 'swstack_role', 'Active'], ['slot', 'rp', '(?P<active_rp>.*)', 'state', 'Ready']], [['slot', 'rp', '(?P<standby_rp>.*)', 'swstack_role', 'Standby'], ['slot', 'rp', '(?P<standby_rp>.*)', 'state', 'Ready']], [['slot', 'rp', '(?P<members>.*)', 'swstack_role', 'Member'], ['slot', 'rp', '(?P<members>.*)', 'state', 'Ready']], [['redundancy_communication', True]], ], 'all_keys': True, 'exclude': platform_exclude}}, verify_ops={'ops.platform.platform.Platform':{ 'requirements': [\ ['slot', 'rp', '(?P<active_rp>.*)', 'swstack_role', 'Member'], ['slot', 'rp', '(?P<standby_rp>.*)', 'swstack_role', 'Active']], 'exclude': platform_exclude}}, num_values={'active_rp':1, 'standby_rp':1, 'members': 'all'})
class TriggerAddRemovePimNeighborFilter(TriggerAddRemove): """Apply the Pim interface(s)'s neighbor-filter, add remove added Pim interface(s)'s neighbor-filter""" __description__ = """Apply the Pim interface(s)'s neighbor-filter, add remove added Pim interface(s)'s neighbor-filter. trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 method (`str`): Method to recover the device configuration, Support methods: 'checkpoint': Rollback the configuration by checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 steps: 1. Learn Pim Ops/Conf object and store the Pim interface(s)'s neighbor-filter. 2. Save the current device configurations through "method" which user uses 3. Add the configuration of Pim interface(s)'s neighbor-filter with Pim Conf object 4. Verify the Pim interface(s)'s neighbor-filter from step 3 has configured 5. Remove the Pim interface(s)'s neighbor-filter configurations. 6. Recover the device configurations to the one in step 2 7. Learn Pim Ops again and verify it is the same as the Ops in step 1 """ ADD_NAME = 'added_pim_neighbor_policy' # Mapping of Information between Ops and Conf # Also permit to dictate which key to verify mapping = Mapping(requirements={ 'ops.pim.pim.Pim':{ 'requirements':[\ ['info', 'vrf', '(?P<vrf>.*)', 'interfaces', '(?P<pim_intf>.*)', 'address_family', '(?P<af>.*)', NotExists('neighbor_filter')], ['info', 'vrf', '(?P<vrf>.*)', 'interfaces', '(?P<pim_intf>.*)', 'address_family', '(?P<af>.*)', 'oper_status', 'up']], 'kwargs':{'attributes': [ 'info[vrf][(.*)][interfaces][(.*)][address_family][(.*)][oper_status]', 'info[vrf][(.*)][interfaces][(.*)][address_family][(.*)][neighbor_filter]']}, 'exclude': pim_exclude}}, config_info={'conf.pim.Pim':{ 'requirements':[ ['device_attr', '{uut}', 'vrf_attr', '(?P<vrf>.*)', 'address_family_attr', '(?P<af>.*)', 'interface_attr', '(?P<pim_intf>.*)', 'neighbor_filter', ADD_NAME]], 'verify_conf':False, 'kwargs':{}}}, verify_ops={ 'ops.pim.pim.Pim':{ 'requirements':[\ ['info', 'vrf', '(?P<vrf>.*)', 'interfaces', '(?P<pim_intf>.*)', 'address_family', '(?P<af>.*)', 'neighbor_filter', ADD_NAME], ['info', 'vrf', '(?P<vrf>.*)', 'interfaces', '(?P<pim_intf>.*)', 'address_family', '(?P<af>.*)', 'oper_status', 'up']], 'kwargs':{'attributes': [ 'info[vrf][(.*)][interfaces][(.*)][address_family][(.*)][oper_status]', 'info[vrf][(.*)][interfaces][(.*)][address_family][(.*)][neighbor_filter]']}, 'exclude': pim_exclude}}, num_values={'vrf': 1, 'af': 1, 'pim_intf': 1})
class TriggerReloadStandbyRP(TriggerReloadWithPriority): """Reload standby switch on device.""" __description__ = """Reload standby switch on device. trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 lcRole (`str`): The role of LC which is 'standby' Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 static: The keys below are dynamically learnt by default. However, they can also be set to a custom value when provided in the trigger datafile. standby_rp: `str` members: `str` (e.g) interface: '(?P<interface>Ethernet1*)' (Regex supported) OR interface: 'Ethernet1/1/1' (Specific value) steps: 1. Learn Platform Ops object and store the "standby" switch and "member" switch(es) if has any, otherwise, SKIP the trigger 2. Do reload by command "reload slot <lc>" 3. Learn Platform Ops again and verify role of "standby" switch changes to "member", verify the role of "member" switch with highest priority changes to "standby", and verify left attributes from the ops are the same as the Ops in step 1 4. Update platform PTS if feature pts is enabled, Update global/local veirifications if enabled """ # Mapping of Information between Ops and Conf # Also permit to dictates which key to verify mapping = Mapping(requirements={'ops.platform.platform.Platform':{ 'requirements': [\ [['slot', 'rp', '(?P<standby_rp>.*)', 'swstack_role', 'Standby'], ['slot', 'rp', '(?P<standby_rp>.*)', 'state', 'Ready']], [['slot', 'rp', '(?P<members>.*)', 'swstack_role', 'Member'], ['slot', 'rp', '(?P<members>.*)', 'state', 'Ready']], [['redundancy_communication', True]], ], 'all_keys': True, 'exclude': platform_exclude}}, verify_ops={'ops.platform.platform.Platform':{ 'requirements': [\ ['slot', 'rp', '(?P<standby_rp>.*)', 'swstack_role', 'Member']], 'exclude': platform_exclude}}, num_values={'standby_rp':1, 'members': 'all'})
class TriggerModifyIgmpVersion(TriggerModify): """Modify dynamically learned enabled Igmp interface(s) version then restore the configuration by reapplying the whole running configuration.""" __description__ = """Modify dynamically learned enabled Igmp interface(s) version then restore the configuration by reapplying the whole running configuration. trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 method (`str`): Method to recover the device configuration, Support methods: 'checkpoint': Rollback the configuration by checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 static: The keys below are dynamically learnt by default. However, they can also be set to a custom value when provided in the trigger datafile. interface: `str` vrf: `str` (e.g) interface: '(?P<interface>Ethernet1*)' (Regex supported) OR interface: 'Ethernet1/1/1' (Specific value) steps: 1. Learn Igmp Ops object and store the Igmp interface version if has any, otherwise, SKIP the trigger 2. Save the current device configurations through "method" which user uses 3. Modify the learned Igmp interface version from step 1 with Igmp Conf object 4. Verify the Igmp interface version from step 3 is reflected in device configuration 5. Recover the device configurations to the one in step 2 6. Learn Igmp Ops again and verify it is the same as the Ops in step 1 """ # Mapping of Information between Ops and Conf # Also permit to dictate which key to verify mapping = Mapping(requirements={ 'ops.igmp.igmp.Igmp':{ 'requirements':[\ ['info', 'vrfs', '(?P<vrf>.*)', 'interfaces', '(?P<interface>.*)', 'enable', True], ['info', 'vrfs', '(?P<vrf>.*)', 'interfaces', '(?P<interface>.*)', 'version', '(?P<version>2)']], 'all_keys': True, 'kwargs':{'attributes': [ 'info[vrfs][(.*)]']}, 'exclude': igmp_exclude}}, config_info={'conf.igmp.Igmp':{ 'requirements':[ ['device_attr', '{uut}', 'vrf_attr', '(?P<vrf>.*)', 'interface_attr', '(?P<interface>.*)', 'version', 3]], 'verify_conf':False, 'kwargs':{}}}, verify_ops={ 'ops.igmp.igmp.Igmp':{ 'requirements':[\ ['info', 'vrfs', '(?P<vrf>.*)', 'interfaces', '(?P<interface>.*)', 'version', 3]], 'kwargs':{'attributes': [ 'info[vrfs][(.*)]']}, 'exclude': igmp_exclude}}, num_values={'vrf': 1, 'interface': 1})
class TriggerUnconfigConfigMldVersion(TriggerUnconfigConfig): """Unconfigure and reapply the whole configurations of dynamically learned enabled Mld interface(s)'s version.""" __description__ = """Unconfigure and reapply the whole configurations of dynamically learned enabled Mld interface(s)'s version. trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 method (`str`): Method to recover the device configuration, Support methods: 'checkpoint': Rollback the configuration by checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 steps: 1. Learn Mld Ops object and store the enabled Mld interface(s)'s version if has any, otherwise, SKIP the trigger 2. Save the current device configurations through "method" which user uses 3. Unconfigure the learned Mld interface(s)'s version from step 1 with Mld Conf object 4. Verify the Mld interface(s)'s version from step 3 are no longer existed 5. Recover the device configurations to the one in step 2 6. Learn Mld Ops again and verify it is the same as the Ops in step 1 """ # Mapping of Information between Ops and Conf # Also permit to dictate which key to verify mapping = Mapping(requirements={ 'ops.mld.mld.Mld':{ 'requirements':[\ ['info', 'vrfs', '(?P<vrf>.*)', 'interfaces', '(?P<mld_intf>.*)', 'enable', True], ['info', 'vrfs', '(?P<vrf>.*)', 'interfaces', '(?P<mld_intf>.*)', 'version', '(?P<version>^(?!2).*)']], 'all_keys': True, 'kwargs':{'attributes': [ 'info[vrfs][(.*)]']}, 'exclude': mld_exclude}}, config_info={'conf.mld.Mld':{ 'requirements':[ ['device_attr', '{uut}', 'vrf_attr', '(?P<vrf>.*)', 'interface_attr', '(?P<mld_intf>.*)', 'version', '(?P<version>.*)']], 'verify_conf':False, 'kwargs':{}}}, verify_ops={ 'ops.mld.mld.Mld':{ 'requirements':[\ ['info', 'vrfs', '(?P<vrf>.*)', 'interfaces', '(?P<mld_intf>.*)', 'version', 2]], 'missing': False, 'kwargs':{'attributes': [ 'info[vrfs][(.*)]']}, 'exclude': mld_exclude}}, num_values={'vrf': 1, 'mld_intf': 1})
class TriggerShutNoShutEthernetInterface(TriggerShutNoShut): """Shut and unshut the dynamically learned Ethernet interface(s).""" __description__ = """Shut and unshut the dynamically learned Ethernet interface(s). trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 static: The keys below are dynamically learnt by default. However, they can also be set to a custom value when provided in the trigger datafile. interface: `str` (e.g) interface: '(?P<interface>Ethernet1*)' (Regex supported) OR interface: 'Ethernet1/1/1' (Specific value) steps: 1. Learn Interface Ops object and store the "up" Ethernet interface(s) and "False" port channel member, if has any, otherwise, SKIP the trigger. 2. Shut the learned Ethernet interface(s) from step 1 with Interface Conf object 3. Verify the state of learned Ethernet interface(s) from step 2 is "down" 4. Unshut the Ethernet interface(s) with Interface Conf object 5. Learn Interface Ops again and verify it is the same as the Ops in step 1 """ def remove_related_subinterface(item, interface, **kwargs): """Check if interface (item) needs to remove sub-interfaces by checking with the given main interface (name). Args: item (`str`): Interface name to be checked if need to remove the sub-interfaces. interface (`str`): Interface name that needs to remove the sub-interfaces. **kwargs: Arbitrary keyword arguments. Returns: True: The item interface which needs sub-interfaces removal False: The item interface which doesn't need sub-interfaces removal """ # Easiest way is to split at the dot, and see if it exists in name modified_item = item.split('.')[0] # If it remained the same, dont waste time if item == modified_item: return False # See if the modified_item exists in the list of name if modified_item in interface: return True return False # Mapping of Information between Ops and Conf # Also permit to dictate which key to verify mapping = Mapping(requirements={'ops.interface.interface.Interface':{ 'requirements':[\ ['info', '(?P<interface>(\w+(e|E)thernet[\d\/]|\w+(g|G)ig[\w\/])+$)', 'oper_status', 'up'], ['info', '(?P<interface>.*)', 'port_channel', 'port_channel_member', False]], 'exclude': interface_exclude, 'kwargs': {'attributes': ['info[(.*)][switchport_enable]', 'info[(.*)][enabled]', 'info[(.*)][oper_status]', 'info[(.*)][port_channel]']}, 'include_management_interface': False}}, config_info={'conf.interface.Interface':{ 'requirements':[['enabled', False]], 'verify_conf':False, 'kwargs':{'mandatory':{'name': '(?P<interface>.*)', 'attach': False}}}}, verify_ops={'ops.interface.interface.Interface':{ 'requirements':[\ ['info', '(?P<interface>.*)', 'enabled', False], ['info', '(?P<interface>.*)', 'oper_status', 'down'], ['info', '(?P<interface>.*)', 'switchport_enable', False]], 'kwargs': {'attributes': ['info[(.*)][switchport_enable]', 'info[(.*)][enabled]', 'info[(.*)][oper_status]', 'info[(.*)][port_channel]']}, 'exclude': interface_exclude +\ [remove_related_subinterface]}}, num_values={'interface': 1})
def get_ops_diff(new, original, exclude=None, modified_path=None, keys=None): '''Diff two ops object with ignoring the keys from the exclude list Args: Mandatory: new (`obj`) : Ops object. original (`obj`) : Ops object. Optional: exclude (`list`) : Keys/attributs to ignore in the diff. modified_path (`list`) : List of items that needs to be checked. The item is following the ops attributes path in a list. keys (`list`) : List of items that contains the key values for the 'modified_path' regexp items. Returns: None Raises: AssertionError: When diff is found ValueError: When required attributes are not in the ops Example: >>> ops_diff(new = <bgp_ops_obj>, original = <bgp_ops_obj>, exclude = ['up_time', 'keepalive', 'maker'], modified_path = [['info', 'instance', '(?P<instance>.*)', 'vrf', '(?P<vrf>.*)', 'neighbor', '(?P<neighbor>.*)', 'remote_as', '900']], keys = [{'instance': '1', 'vrf': 'default', 'neighbor': '10.4.1.1'}, {'instance': '1', 'vrf': 'VRF1', 'neighbor': '10.16.2.2'},]) ''' def _modify_ops_snapshot(original, current, path): # First does path exists in original, except the value r = R(path[:-1] + ['(.*)']) ret = find([original], r, filter_=False) if not ret: raise ValueError( "'{p}' does not exist on original snapshot " "as per the original trigger requirement".format(p=path)) _modify_value(current, path[:-1], ret[0][0]) def _modify_value(snapshot, path, value): for p in path[:-1]: try: snapshot = snapshot[p] except (TypeError): snapshot = getattr(snapshot, p) if isinstance(snapshot, dict): snapshot[path[-1]] = value else: setattr(snapshot, path[-1], value) if modified_path and keys: mapping = Mapping() for req in modified_path: # use mapping internal function to populate the path with learned values req = mapping._populate_path([req], new.device, keys=keys) rs = [R(requirement) for requirement in req] # want to print one by one for rs_item in rs: ret = find([new], rs_item, filter_=False, all_keys=True) if not ret: # return rs_item.args raise ValueError("'{req}' does not exists in " "'{o}'".format(req=rs_item.args, o=new)) # Let's modify the ops value to be equal to the original # snapshot. This will allow for comparing the other keys for require in req: try: _modify_ops_snapshot(original=original, current=new, path=require) except Exception as e: return diff = Diff(original, new, exclude=(exclude or []) + ['maker', 'callables', 'device', 'diff_ignore']) diff.findDiff() if diff.diffs: log.error("Current ops is not equal to the initial Snapshot " "taken on device {d}.\n{e}".format(e=str(diff), d=getattr( new, 'device', 'name'))) raise AssertionError( "Current ops is not equal to the initial Snapshot " "taken on device {d}.\n{e}".format(e=str(diff), d=getattr( new, 'device', 'name')))
class TriggerShutNoShutIpv4SviInterface(TriggerShutNoShut): """Shut and unshut Learned Vlan interface(s) with ipv4 configured.""" __description__ = """Shut and unshut Learned Vlan interface(s) with ipv4 configured. trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 static: The keys below are dynamically learnt by default. However, they can also be set to a custom value when provided in the trigger datafile. interface: `str` (e.g) interface: '(?P<interface>Ethernet1*)' (Regex supported) OR interface: 'Ethernet1/1/1' (Specific value) steps: 1. Learn Interface Ops object and store the "up" Vlan interface(s) with ipv4 configured if has any, otherwise, SKIP the trigger 2. Shut the learned Vlan interface(s) from step 1 with Interface Conf object 3. Verify the state of learned Vlan interface(s) from step 2 is "down" 4. Unshut the Vlan interface(s) with Interface Conf object 5. Learn Interface Ops again and verify it is the same as the Ops in step 1 """ # Mapping of Information between Ops and Conf # Also permit to dictate which key to verify mapping = Mapping( requirements={ 'ops.interface.interface.Interface': { 'requirements': [['info', '(?P<interface>Vlan[0-9]+)', 'enabled', True], [ 'info', '(?P<interface>.*)', 'ipv4', '(?P<ip>.*)', 'ip', '(?P<ipaddr>.*)' ], [ 'info', '(?P<interface>.*)', 'port_channel', 'port_channel_member', False ], ['info', '(?P<interface>.*)', 'oper_status', 'up']], 'all_keys': True, 'kwargs': { 'attributes': [ 'info[(.*)][port_channel]', 'info[(.*)][enabled]', 'info[(.*)][oper_status]', 'info[(.*)][ipv4][(.*)]' ] }, 'exclude': interface_exclude } }, config_info={ 'conf.interface.Interface': { 'requirements': [['enabled', False]], 'verify_conf': False, 'kwargs': { 'mandatory': { 'name': '(?P<interface>.*)', 'attach': False } } } }, verify_ops={ 'ops.interface.interface.Interface': { 'requirements': [['info', '(?P<interface>.*)', 'enabled', False], ['info', '(?P<interface>.*)', 'oper_status', 'down'], ['info', '(?P<interface>.*)', 'switchport_enable', False]], 'kwargs': { 'attributes': [ 'info[(.*)][port_channel]', 'info[(.*)][enabled]', 'info[(.*)][oper_status]', 'info[(.*)][ipv4][(.*)]' ] }, 'exclude': interface_exclude } }, num_values={'interface': 1})
class TriggerModifyLoopbackInterfaceIp(TriggerModify): """Modify and revert the ipv4 address for dynamically learned Loopback interface(s).""" __description__ = """Modify and revert the ipv4 address for dynamically learned Loopback interface(s). trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 method (`str`): Method to recover the device configuration, Support methods: 'checkpoint': Rollback the configuration by checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iteration when looping is needed, in second. Default: 15 steps: 1. Learn Interface Ops object and store the "up" "ipv4" Loopback interface(s) if has any, otherwise, SKIP the trigger 2. Save the current device configurations through "method" which user uses 3. Modify the ipv4 address of the learned Loopback interface(s) from step 1 with Interface Conf object 4. Verify the ipv4 address of the learned Loopback interface(s) from step 3 changes to the modified value in step 3 5. Recover the device configurations to the one in step 2 6. Learn Interface Ops again and verify it is the same as the Ops in step 1 """ # configuration steps callable def configure_intf_ip(self, conf_obj, ip, mask, **kwargs): ipv4 = IPv4Addr(device=kwargs['device']) ipv4.ipv4 = IPv4Address(ip) ipv4.prefix_length = mask conf_obj.add_ipv4addr(ipv4) conf_obj.build_config() # Mapping of Information between Ops and Conf # Also permit to dictates which key to verify mapping = Mapping(requirements={'ops.interface.interface.Interface':{ 'requirements': [['info', '(?P<name>[l|L]oopback\d+)', 'ipv4', '(?P<ip_mask>.*)', 'ip', '(?P<ip>.*)'], ['info', '(?P<name>[l|L]oopback\d+)', 'ipv4', '(?P<ip_mask>.*)', 'prefix_length', '(?P<mask>.*)']], 'all_keys':True, 'exclude': interface_exclude, 'all_keys': True}}, config_info={'conf.interface.Interface':{ 'requirements':[[partial(configure_intf_ip, ip='10.254.254.254', mask='32')]], 'verify_conf':False, 'kwargs':{'mandatory':{'name': '(?P<name>.*)', 'attach': False}}}}, verify_ops={'ops.interface.interface.Interface':{ 'requirements': [['info', '(?P<name>.*)', 'ipv4', '10.254.254.254/32', 'prefix_length', '32'], ['info', '(?P<name>.*)', 'ipv4', '10.254.254.254/32', 'ip', '10.254.254.254']], 'exclude': interface_exclude}}, num_values={'name': 1, 'ip_mask': 1, 'ip' : 'all', 'mask': 'all'})
class TriggerAddRemoveL3EtherchannelPagp(TriggerAddRemove): """Apply the configuration for L3 Etherchannel in PAGP mode, and remove the added Etherchannel in PAGP mode """ __description__ = """Apply the configuration for L3 Etherchannel in PAGP mode, and remove the added Etherchannel in PAGP mode. trigger_datafile: Mandatory: timeout: max_time (`int`): Maximum wait time for the trigger, in second. Default: 180 interval (`int`): Wait time between iterations when looping is needed, in second. Default: 15 method (`str`): Method to recover the device configuration, Support methods: 'checkpoint': Rollback the configuration by checkpoint (nxos), archive file (iosxe), load the saved running-config file on disk (iosxr) Optional: tgn_timeout (`int`): Maximum wait time for all traffic threads to be restored to the reference rate, in second. Default: 60 tgn_delay (`int`): Wait time between each poll to verify if traffic is resumed, in second. Default: 10 timeout_recovery: Buffer recovery timeout make sure devices are recovered at the end of the trigger execution. Used when previous timeouts have been exhausted. max_time (`int`): Maximum wait time for the last step of the trigger, in second. Default: 180 interval (`int`): Wait time between iterations when looping is needed, in second. Default: 15 steps: 1. Learn Interface Ops object to select up interfaces. Learn LAG ops object to find port-channle interfaces which does not exists. 2. Save the current device configurations through "method" which user uses 3. Add the configuration of Etherchannel in PAGP mode with interface Conf object, Add ip address configuration to the learned port-channel interfaces 4. Verify the interfaces are in the por-channle interfaces from step 3 has configured 5. Remove the Etherchannel and port-channel configurations. 6. Recover the device configurations to the one in step 2 7. Learn LAG Ops again and verify it is the same as the Ops in step 1 """ counters_port = [] counters_keys = [[ 'interface', '(?P<bundle_intf>.*)', 'out', 'ucast_pkts', '(.*)' ]] # ping info pre_ping_info = [{ 'src': 'uut', 'dest': 'helper', 'ping': { 'proto': 'ip', 'count': 20, 'size': 64, 'extd_ping': 'n', 'ping_packet_timeout': 2 }, 'timeout_interval': 5, 'timeout_max_time': 60, 'exp_succ_perc': 100, 'peer_num': 1 }, { 'src': 'helper', 'dest': 'uut', 'ping': { 'proto': 'ip', 'count': 100, 'size': 64, 'extd_ping': 'n', 'ping_packet_timeout': 2 }, 'timeout_interval': 5, 'timeout_max_time': 60, 'exp_succ_perc': 100, 'peer_num': 1 }] @aetest.processors( pre=[partial(ping_devices, ping_parameters=pre_ping_info)], post=[ partial(check_interface_counters, ports=counters_port, keys=counters_keys, threshold='islargerthan(100)') ]) @aetest.test def verify_configuration(self, uut, abstract, steps): super().verify_configuration(uut, abstract, steps) mapping = Mapping(requirements={'ops.lag.lag.Lag':{ 'requirements':[\ ['info', 'interfaces', '(?P<bundle_intf>.*)', NotExists('members')], ['info', 'interfaces', '(?P<bundle_intf>.*)', 'bundle_id', '(?P<bundle_id>.*)']], 'all_keys': True, 'kwargs':{'attributes':['info[interfaces][(.*)]']}, 'exclude': lag_exclude}, 'ops.interface.interface.Interface':{ 'requirements':[['info', '(?P<intf>\w+Ethernet[\d\/]+$)', 'switchport_enable', False], ['info', '(?P<intf>\w+Ethernet[\d\/]+$)', 'oper_status', 'up']], 'kwargs': {'attributes': ['info[(.*)][switchport_enable]', 'info[(.*)][operational_mode]', 'info[(.*)][oper_status]', 'info[(.*)][enabled]', 'info[(.*)][port_channel]']}, 'exclude': interface_exclude}}, config_info={'conf.interface.Interface':{ 'requirements':[['lag_bundle_id', '(?P<bundle_id>.*)'], ['lag_activity', 'desirable']], 'verify_conf':False, 'kwargs':{'mandatory':{'name': '(?P<intf>.*)', 'attach': False}}}}, verify_ops={'ops.lag.lag.Lag':{ 'requirements': [\ ['info', 'interfaces', '(?P<bundle_intf>.*)', 'bundle_id', '(?P<bundle_id>.*)'], ['info', 'interfaces', '(?P<bundle_intf>.*)', 'protocol', 'pagp'], ['info', 'interfaces', '(?P<bundle_intf>.*)', 'oper_status', 'up'], ['info', 'interfaces', '(?P<bundle_intf>.*)', 'name', '(?P<bundle_intf>.*)'], ['info', 'interfaces', '(?P<bundle_intf>.*)', 'members', '(?P<intf>.*)', 'bundled', True]], 'kwargs':{'attributes':['info[interfaces][(.*)]']}, 'exclude': lag_exclude + ['attribute']}, 'ops.interface.interface.Interface':{ 'requirements':[['info', '(?P<intf>\w+Ethernet[\d\/]+$)', 'switchport_enable', False], ['info', '(?P<intf>\w+Ethernet[\d\/]+$)', 'oper_status', 'up'], ['info', '(?P<bundle_intf>.*)', 'oper_status', 'up'], ['info', '(?P<bundle_intf>.*)', 'enabled', True], ['info', '(?P<bundle_intf>.*)', 'oper_status', 'up'], ['info', '(?P<bundle_intf>.*)', 'port_channel', 'port_channel_member', True], ['info', '(?P<bundle_intf>.*)', 'port_channel', 'port_channel_member_intfs', '(.*)']], 'kwargs': {'attributes': ['info[(.*)][switchport_enable]', 'info[(.*)][operational_mode]', 'info[(.*)][oper_status]', 'info[(.*)][enabled]', 'info[(.*)][port_channel]']}, 'exclude': interface_exclude}}, num_values={'intf':'all', 'bundle_id': 1})