def _render_interface_del_commands(self, want, have): """ The command generator for delete commands w.r.t member interfaces :rtype: A list :returns: the commands necessary to update member interfaces """ commands = [] if not want: want = {} have_members = have.get("members") if have_members: have_members = param_list_to_dict(deepcopy(have_members), unique_key="member") want_members = param_list_to_dict(deepcopy(want).get( "members", []), unique_key="member") for key in have_members: if key not in want_members: member_cmd = ["no bundle id"] pad_commands(member_cmd, key) commands.extend(member_cmd) return commands
def set_state(self, want, have): """Select the appropriate function based on the state provided :param want: the desired configuration as a dictionary :param have: the current configuration as a dictionary :rtype: A list :returns: the commands necessary to migrate the current configuration to the desired configuration """ state = self._module.params["state"] if ( state in ("merged", "replaced", "overridden", "rendered") and not want ): self._module.fail_json( msg="value of config parameter must not be empty for state {0}".format( state ) ) want = param_list_to_dict(want, remove_key=False) have = param_list_to_dict(have, remove_key=False) if state == "overridden": commands = self._state_overridden(want, have) elif state == "deleted": commands = self._state_deleted(want, have) elif state == "merged" or state == "rendered": commands = self._state_merged(want, have) elif state == "replaced": commands = self._state_replaced(want, have) return commands
def set_state(self, want, have): """ Select the appropriate function based on the state provided :param want: the desired configuration as a dictionary :param have: the current configuration as a dictionary :rtype: A list :returns: the commands necessary to migrate the current configuration to the desired configuration """ state = self._module.params['state'] want = param_list_to_dict(want) if want else dict() have = param_list_to_dict(have) if have else dict() if state == 'overridden': kwargs = {'self': self, 'want': want, 'have': have} commands = self._state_overridden(**kwargs) elif state == 'deleted': kwargs = {'self': self, 'want': want, 'have': have} commands = self._state_deleted(**kwargs) elif state == 'merged': kwargs = {'self': self, 'want': want, 'have': have} commands = self._state_merged(**kwargs) elif state == 'replaced': kwargs = {'self': self, 'want': want, 'have': have} commands = self._state_replaced(**kwargs) return commands
def generate_addrfam_commands(want, have): commands = [] want = param_list_to_dict(want, unique_key='vrf') if have: have = param_list_to_dict(have, unique_key='vrf') else: have = dict() for vrf, stats in iteritems(want): vrf_commands = [] if stats.get('redistribute'): vrf_commands.extend( generate_redistribute_commands( stats['redistribute'], have.get(vrf, {}).get('redistribute', []))) if stats.get('networks'): network_commands = generate_network_commands( stats['networks'], have.get(vrf, {}).get('networks', [])) vrf_commands.extend(network_commands) if stats.get('neighbors'): neighbor_commands = generate_af_neighbor_commands( stats['neighbors'], have.get(vrf, {}).get('neighbors')) vrf_commands.extend(neighbor_commands) if vrf_commands or vrf not in have: vrf_commands.insert(0, 'address-family ipv4 vrf {}'.format(vrf)) vrf_commands.append('exit-address-family') commands.extend(vrf_commands) return commands
def _purge_attribs(self, intf): """ The command generator for purging attributes :rtype: A list :returns: the commands necessary to purge attributes """ commands = [] have_copy = deepcopy(intf) members = have_copy.pop("members", []) to_delete = dict_delete(have_copy, remove_empties({"name": have_copy["name"]})) if to_delete: for key, value in iteritems(flatten_dict( remove_empties(to_delete))): commands.append( self._compute_commands(key=key, value=value, remove=True)) if commands: pad_commands(commands, intf["name"]) if members: members = param_list_to_dict(deepcopy(members), unique_key="member") for key in members: member_cmd = ["no bundle id"] pad_commands(member_cmd, key) commands.extend(member_cmd) return commands
def generate_neighbor_commands(want, have): commands = [] w_neighbors = param_list_to_dict(want, unique_key='neighbor') if have: h_neighbors = param_list_to_dict(have, unique_key='neighbor') else: h_neighbors = dict() diff = dict_diff(h_neighbors, w_neighbors) for w_neighbor, stats in iteritems(diff): if w_neighbor not in h_neighbors: commands.append('neighbor {} remote-as {}'.format( w_neighbor, stats['remote_as'])) for key, value in iteritems(stats): if key == 'remote_as' or value is None: continue if key == 'enabled': if value is False and value != h_neighbors.get(w_neighbor).get( 'enabled', True): commands.append('neighbor {} shutdown'.format(w_neighbor)) if value and value != h_neighbors.get(w_neighbor).get( 'enabled', True): commands.append( 'no neighbor {} shutdown'.format(w_neighbor)) elif key == 'timers': if value.get('connect'): commands.append('neighbor {} timers connect {}'.format( w_neighbor, value['connect'])) else: if value.get('keepalive') is None or value.get( 'holdtime') is None: raise ValueError( 'keepalive and holdtime required together') commands.append('neighbor {} timers {} {}'.format( w_neighbor, value['keepalive'], value['holdtime'])) else: commands.append('neighbor {} {} {}'.format( w_neighbor, key.replace('_', '-'), value)) return commands
def set_state(self, want, have): """ Select the appropriate function based on the state provided :param want: the desired configuration as a dictionary :param have: the current configuration as a dictionary :rtype: A list :returns: the commands necessary to migrate the current configuration to the desired configuration """ state = self._module.params['state'] want = param_list_to_dict(want, "vlan_id", remove_key=False) have = param_list_to_dict(have, "vlan_id", remove_key=False) if state == 'overridden': commands = self._state_overridden(want, have) elif state == 'deleted': commands = self._state_deleted(want, have) elif state == 'merged': commands = self._state_merged(want, have) elif state == 'replaced': commands = self._state_replaced(want, have) return commands
def set_state(self, want, have): """ Select the appropriate function based on the state provided :param want: the desired configuration as a dictionary :param have: the current configuration as a dictionary :rtype: A list :returns: the commands necessary to migrate the current configuration to the desired configuration """ state = self._module.params["state"] want = param_list_to_dict(want) have = param_list_to_dict(have) if state == "overridden": commands = self._state_overridden(want, have) elif state == "deleted": commands = self._state_deleted(want, have) elif state == "merged": commands = self._state_merged(want, have) elif state == "replaced": commands = self._state_replaced(want, have) return commands
def generate_af_neighbor_commands(want, have): commands = [] w_neighbors = param_list_to_dict(want, unique_key='neighbor') if have: h_neighbors = param_list_to_dict(have, unique_key='neighbor') else: h_neighbors = dict() diff = dict_diff(h_neighbors, w_neighbors) for w_neighbor, stats in iteritems(diff): if w_neighbor not in h_neighbors: commands.append('neighbor {} remote-as {}'.format( w_neighbor, stats['remote_as'])) for key, value in iteritems(stats): if key == 'remote_as' or value is None: continue if key == 'maximum_prefix': commands.append('neighbor {} maximum-prefix {}'.format( w_neighbor, value)) elif key == 'prefix_list_in': commands.append('neighbor {} prefix-list {} in'.format( w_neighbor, value)) elif key == 'prefix_list_out': commands.append('neighbor {} prefix-list {} out'.format( w_neighbor, value)) else: if value and value != h_neighbors.get(w_neighbor, {}).get( key, False): commands.append('neighbor {} {}'.format( w_neighbor, key.replace('_', '-'), value)) elif not value and value != h_neighbors.get( w_neighbor, {}).get(key, False): commands.append('no neighbor {} {}'.format( w_neighbor, key.replace('_', '-'), value)) return commands
def test_param_list_to_dict(): params = [ dict(name="interface1", mtu=1400), dict(name="interface2", speed="10G"), dict(name="interface3"), ] assert utils.param_list_to_dict(params) == { "interface1": dict(mtu=1400), "interface2": dict(speed="10G"), "interface3": dict(), } params = [ dict(vlan_id=1, name="management"), dict(vlan_id=10, name="voice"), dict(vlan_id=99, name="guest"), ] assert utils.param_list_to_dict( params, unique_key="vlan_id", remove_key=False ) == { 1: dict(vlan_id=1, name="management"), 10: dict(vlan_id=10, name="voice"), 99: dict(vlan_id=99, name="guest"), }
def generate_redistribute_commands(want, have): commands = [] h_protocols = param_list_to_dict(have, unique_key='protocol') for redistribute in want: w_protocol = redistribute['protocol'] if w_protocol in h_protocols and h_protocols[w_protocol].get( 'route_map') and not redistribute.get('route_map'): commands.append('no redistribute {}'.format(w_protocol)) if remove_empties(redistribute) not in have: if redistribute.get('route_map'): commands.append('redistribute {} route-map {}'.format( redistribute['protocol'], redistribute['route_map'])) else: commands.append('redistribute {}'.format( redistribute['protocol'])) return commands