def checkpoint(filename, module): commands = [{ 'command': 'terminal dont-ask', 'output': 'text', }, { 'command': 'checkpoint file %s' % filename, 'output': 'text', }] run_commands(module, commands)
def save_config(module, result): result['changed'] = True if not module.check_mode: cmd = {'command': 'copy running-config startup-config', 'output': 'text'} run_commands(module, [cmd]) else: module.warn('Skipping command `copy running-config startup-config` ' 'due to check_mode. Configuration not copied to ' 'non-volatile storage')
def get_vpc(module): body = run_commands(module, ['show vpc | json'])[0] if body: domain = str(body['vpc-domain-id']) else: body = run_commands(module, ['show run vpc | inc domain'])[0] if body: domain = body.split()[2] else: domain = 'not configured' vpc = {} if domain != 'not configured': run = get_config(module, flags=['vpc all']) if run: vpc['domain'] = domain for key in PARAM_TO_DEFAULT_KEYMAP.keys(): vpc[key] = PARAM_TO_DEFAULT_KEYMAP.get(key) vpc['auto_recovery'] = get_auto_recovery_default(module) vpc_list = run.split('\n') for each in vpc_list: if 'role priority' in each: line = each.split() vpc['role_priority'] = line[-1] if 'system-priority' in each: line = each.split() vpc['system_priority'] = line[-1] if re.search(r'delay restore \d+', each): line = each.split() vpc['delay_restore'] = line[-1] if 'delay restore interface-vlan' in each: line = each.split() vpc['delay_restore_interface_vlan'] = line[-1] if 'delay restore orphan-port' in each: line = each.split() vpc['delay_restore_orphan_port'] = line[-1] if 'auto-recovery' in each: vpc['auto_recovery'] = False if 'no ' in each else True line = each.split() vpc['auto_recovery_reload_delay'] = line[-1] if 'peer-gateway' in each: vpc['peer_gw'] = False if 'no ' in each else True if 'peer-keepalive destination' in each: # destination is reqd; src & vrf are optional m = re.search( r'destination (?P<pkl_dest>[\d.]+)' r'(?:.* source (?P<pkl_src>[\d.]+))*' r'(?:.* vrf (?P<pkl_vrf>\S+))*', each) if m: for pkl in m.groupdict().keys(): if m.group(pkl): vpc[pkl] = m.group(pkl) return vpc
def execute_show_command(command, module): device_info = get_capabilities(module) network_api = device_info.get('network_api', 'nxapi') if network_api == 'cliconf': cmds = [command] body = run_commands(module, cmds) elif network_api == 'nxapi': cmds = {'command': command, 'output': 'text'} body = run_commands(module, cmds) return body
def get_auto_recovery_default(module): auto = False data = run_commands(module, ['show inventory | json'])[0] pid = data['TABLE_inv']['ROW_inv'][0]['productid'] if re.search(r'N7K', pid): auto = True elif re.search(r'N9K', pid): data = run_commands(module, ['show hardware | json'])[0] ver = data['kickstart_ver_str'] if re.search(r'7.0\(3\)F', ver): auto = True return auto
def main(): argument_spec = dict(flush_routes=dict(type='bool'), enforce_rtr_alert=dict(type='bool'), restart=dict(type='bool', default=False), state=dict(choices=['present', 'default'], default='present')) argument_spec.update(nxos_argument_spec) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) warnings = list() current = get_current(module) desired = get_desired(module) state = module.params['state'] commands = list() if state == 'default': if current['flush_routes']: commands.append('no ip igmp flush-routes') if current['enforce_rtr_alert']: commands.append('no ip igmp enforce-router-alert') elif state == 'present': ldict = { 'flush_routes': 'flush-routes', 'enforce_rtr_alert': 'enforce-router-alert' } for arg in ['flush_routes', 'enforce_rtr_alert']: if desired[arg] and not current[arg]: commands.append('ip igmp {0}'.format(ldict.get(arg))) elif current[arg] and not desired[arg]: commands.append('no ip igmp {0}'.format(ldict.get(arg))) result = {'changed': False, 'updates': commands, 'warnings': warnings} if commands: if not module.check_mode: load_config(module, commands) result['changed'] = True if module.params['restart']: cmd = {'command': 'restart igmp', 'output': 'text'} run_commands(module, cmd) module.exit_json(**result)
def get_udld_interface(module, interface): command = 'show run udld all | section ' + interface.title() + '$' interface_udld = {} mode = None mode_str = None try: body = run_commands(module, [{ 'command': command, 'output': 'text' }])[0] if 'aggressive' in body: mode = 'aggressive' mode_str = 'aggressive' elif 'no udld enable' in body: mode = 'disabled' mode_str = 'no udld enable' elif 'no udld disable' in body: mode = 'enabled' mode_str = 'no udld disable' elif 'udld disable' in body: mode = 'disabled' mode_str = 'udld disable' elif 'udld enable' in body: mode = 'enabled' mode_str = 'udld enable' interface_udld['mode'] = mode except (KeyError, AttributeError, IndexError): interface_udld = {} return interface_udld, mode_str
def match_facility_default(module, facility, want_level): ''' Check wanted facility to see if it matches current device default ''' matches_default = False # Sample output from show logging level command # Facility Default Severity Current Session Severity # -------- ---------------- ------------------------ # bfd 5 5 # # 0(emergencies) 1(alerts) 2(critical) # 3(errors) 4(warnings) 5(notifications) # 6(information) 7(debugging) regexl = r'\S+\s+(\d+)\s+(\d+)' cmd = { 'command': 'show logging level {0}'.format(facility), 'output': 'text' } facility_data = run_commands(module, cmd) for line in facility_data[0].split('\n'): mo = re.search(regexl, line) if mo and int(mo.group(1)) == int(want_level) and int( mo.group(2)) == int(want_level): matches_default = True return matches_default
def interface_is_portchannel(name, module): """Checks to see if an interface is part of portchannel bundle Args: interface (str): full name of interface, i.e. Ethernet1/1 Returns: True/False based on if interface is a member of a portchannel bundle """ intf_type = get_interface_type(name) if intf_type == 'ethernet': command = 'show interface {0} | json'.format(name) try: body = run_commands(module, [command])[0] interface_table = body['TABLE_interface']['ROW_interface'] except (KeyError, AttributeError, IndexError): interface_table = None if interface_table: state = interface_table.get('eth_bundle') if state: return True else: return False return False
def execute_show_command(command, module, output='text'): command = { 'command': command, 'output': output, } return run_commands(module, [command])
def get_switchport(port, module): """Gets current config of L2 switchport Args: device (Device): This is the device object of an NX-API enabled device using the Device class within device.py port (str): full name of interface, i.e. Ethernet1/1 Returns: dictionary with k/v pairs for L2 vlan config """ command = 'show interface {0} switchport | json'.format(port) try: body = run_commands(module, [command])[0] sp_table = body['TABLE_interface']['ROW_interface'] except (KeyError, AttributeError, IndexError): sp_table = None if sp_table: key_map = { "interface": "name", "oper_mode": "mode", "switchport": "switchport", "access_vlan": "access_vlan", "access_vlan_name": "access_vlan_name", "native_vlan": "native_vlan", "native_vlan_name": "native_vlan_name", "trunk_vlans": "trunk_vlans" } sp = apply_key_map(key_map, sp_table) return sp else: return {}
def execute_show_command(module, command, output='text'): cmds = [{ 'command': command, 'output': output, }] return run_commands(module, cmds)
def get_interface_mode(name, module): """Gets current mode of interface: layer2 or layer3 Args: device (Device): This is the device object of an NX-API enabled device using the Device class within device.py interface (string): full name of interface, i.e. Ethernet1/1, loopback10, port-channel20, vlan20 Returns: str: 'layer2' or 'layer3' """ command = 'show interface {0} | json'.format(name) intf_type = get_interface_type(name) mode = 'unknown' interface_table = {} try: body = run_commands(module, [command])[0] interface_table = body['TABLE_interface']['ROW_interface'] except (KeyError, AttributeError, IndexError): return mode if interface_table: # HACK FOR NOW if intf_type in ['ethernet', 'portchannel']: mode = str(interface_table.get('eth_mode', 'layer3')) if mode in ['access', 'trunk']: mode = 'layer2' if mode == 'routed': mode = 'layer3' elif intf_type == 'loopback' or intf_type == 'svi': mode = 'layer3' return mode
def get_ping_results(command, module): cmd = {'command': command, 'output': 'text'} ping = run_commands(module, [cmd])[0] if not ping: module.fail_json(msg="An unexpected error occurred. Check all params.", command=command, destination=module.params['dest'], vrf=module.params['vrf'], source=module.params['source']) elif "can't bind to address" in ping: module.fail_json(msg="Can't bind to source address.", command=command) elif "bad context" in ping: module.fail_json(msg="Wrong VRF name inserted.", command=command, vrf=module.params['vrf']) else: splitted_ping = ping.split('\n') reference_point = get_statistics_summary_line(splitted_ping) summary, ping_pass = get_summary(splitted_ping, reference_point) rtt = get_rtt(splitted_ping, summary['packet_loss'], reference_point + 2) return (summary, rtt, ping_pass)
def execute_show_command(command, module, text=False): if text: cmds = [{'command': command, 'output': 'text'}] else: cmds = [{'command': command, 'output': 'json'}] return run_commands(module, cmds)
def execute_show_command(command, module, output='json'): cmds = [{ 'command': command, 'output': output, }] body = run_commands(module, cmds) return body
def execute_show_command(command, module): command = { 'command': command, 'output': 'text', } return run_commands(module, command)
def get_available_features(feature, module): available_features = {} feature_regex = r'(?P<feature>\S+)\s+\d+\s+(?P<state>.*)' command = {'command': 'show feature', 'output': 'text'} try: body = run_commands(module, [command])[0] split_body = body.splitlines() except (KeyError, IndexError): return {} for line in split_body: try: match_feature = re.match(feature_regex, line, re.DOTALL) feature_group = match_feature.groupdict() feature = feature_group['feature'] state = feature_group['state'] except AttributeError: feature = '' state = '' if feature and state: if 'enabled' in state: state = 'enabled' if feature not in available_features: available_features[feature] = state else: if available_features[ feature] == 'disabled' and state == 'enabled': available_features[feature] = state return available_features
def execute_show_command(command, module): cmds = [{ 'command': command, 'output': 'text', }] return run_commands(module, cmds)
def get_system_mode(module): command = {'command': 'show system mode', 'output': 'text'} body = run_commands(module, [command])[0] if body and 'normal' in body.lower(): mode = 'normal' else: mode = 'maintenance' return mode
def execute_show_command(module, command): format = 'text' cmds = [{ 'command': command, 'output': format, }] output = run_commands(module, cmds) return output
def get_current(module): output = run_commands(module, { 'command': 'show running-config', 'output': 'text' }) return { 'flush_routes': 'ip igmp flush-routes' in output[0], 'enforce_rtr_alert': 'ip igmp enforce-router-alert' in output[0] }
def execute_show_commands(module, commands, output='text'): cmds = [] for command in to_list(commands): cmd = {'command': command, 'output': output, } cmds.append(cmd) body = run_commands(module, cmds) return body
def execute_show_command(command, module, text=False): command = { 'command': command, 'output': 'json', } if text: command['output'] = 'text' return run_commands(module, command)
def get_active_vpc_peer_link(module): peer_link = None try: body = run_commands(module, ['show vpc brief | json'])[0] peer_link = body['TABLE_peerlink']['ROW_peerlink']['peerlink-ifindex'] except (KeyError, AttributeError, TypeError): return peer_link return peer_link
def execute_show_command(command, module): if 'show run' not in command: output = 'json' else: output = 'text' cmds = [{ 'command': command, 'output': output, }] return run_commands(module, cmds)[0]
def run(self, command, output='text'): command_string = command command = {'command': command, 'output': output} resp = run_commands(self.module, [command], check_rc='retry_json') try: return resp[0] except IndexError: self.warnings.append( 'command %s failed, facts for this command will not be populated' % command_string) return None
def get_configured_track(module, ctrack): check_track = '{0}'.format(ctrack) track_exists = False command = 'show track' try: body = run_commands(module, {'command': command, 'output': 'text'}) match = re.findall(r'Track\s+(\d+)', body[0]) except IndexError: return None if check_track in match: track_exists = True return track_exists
def get_hsrp_group_unknown_enum(module, command, hsrp_table): '''Some older NXOS images fail to set the attr values when using structured output and instead set the values to <unknown enum>. This fallback method is a workaround that uses an unstructured (text) request to query the device a second time. 'sh_preempt' is currently the only attr affected. Add checks for other attrs as needed. ''' if 'unknown enum:' in hsrp_table['sh_preempt']: cmd = {'output': 'text', 'command': command.split('|')[0]} out = run_commands(module, cmd)[0] hsrp_table['sh_preempt'] = 'enabled' if ('may preempt' in out) else 'disabled' return hsrp_table
def execute_show_command(command, module): if 'show run' not in command: command = { 'command': command, 'output': 'json', } else: command = { 'command': command, 'output': 'text', } return run_commands(module, [command])