def delete_debug_global(self):
""" Delete debug global """
conf_str = CE_MERGE_DEBUG_GLOBAL_HEADER
if self.debug_time_stamp:
conf_str += "<debugTimeStamp>DATE_MILLISECOND</debugTimeStamp>"
conf_str += CE_MERGE_DEBUG_GLOBAL_TAIL
recv_xml = set_nc_config(self.module, conf_str)
if "<ok/>" not in recv_xml:
self.module.fail_json(msg='Error: delete debug global failed.')
if self.debug_time_stamp:
cmd = "undo info-center timestamp debugging"
self.updates_cmd.append(cmd)
self.changed = True
def merge_dot1qtunnel_vlan(self, ifname, default_vlan):
"""Merge dot1qtunnel"""
change = False
conf_str = ""
self.updates_cmd.append("interface %s" % ifname)
if self.state == "present":
if self.intf_info["linkType"] == "dot1qtunnel":
if default_vlan and self.intf_info["pvid"] != default_vlan:
self.updates_cmd.append("port default vlan %s" %
default_vlan)
conf_str = CE_NC_SET_PORT % (ifname, "dot1qtunnel",
default_vlan, "", "")
change = True
else:
self.updates_cmd.append("port link-type dot1qtunnel")
if default_vlan:
self.updates_cmd.append("port default vlan %s" %
default_vlan)
conf_str = CE_NC_SET_PORT % (ifname, "dot1qtunnel",
default_vlan, "", "")
else:
conf_str = CE_NC_SET_PORT % (ifname, "dot1qtunnel", "1",
"", "")
change = True
elif self.state == "absent":
if self.intf_info["linkType"] == "dot1qtunnel":
if default_vlan and self.intf_info[
"pvid"] == default_vlan and default_vlan != "1":
self.updates_cmd.append("undo port default vlan %s" %
default_vlan)
conf_str = CE_NC_SET_PORT % (ifname, "dot1qtunnel", "1",
"", "")
change = True
if not change:
self.updates_cmd.pop() # remove interface
return
conf_str = "<config>" + conf_str + "</config>"
rcv_xml = set_nc_config(self.module, conf_str)
self.check_response(rcv_xml, "MERGE_DOT1QTUNNEL_PORT")
self.changed = True
def operate_static_route(self, version, prefix, mask, nhp_interface,
next_hop, vrf, destvrf, state):
"""operate ipv4 static route"""
description_xml = """\n"""
preference_xml = """\n"""
tag_xml = """\n"""
if next_hop is None:
next_hop = '0.0.0.0'
if nhp_interface is None:
nhp_interface = "Invalid0"
if vrf is None:
vpn_instance = "_public_"
else:
vpn_instance = vrf
if destvrf is None:
dest_vpn_instance = "_public_"
else:
dest_vpn_instance = destvrf
if self.description:
description_xml = CE_NC_SET_DESCRIPTION % self.description
if self.pref:
preference_xml = CE_NC_SET_PREFERENCE % self.pref
if self.tag:
tag_xml = CE_NC_SET_TAG % self.tag
if state == "present":
configxmlstr = CE_NC_SET_STATIC_ROUTE % (
vpn_instance, version, prefix, mask, nhp_interface,
dest_vpn_instance, next_hop, description_xml, preference_xml,
tag_xml)
else:
configxmlstr = CE_NC_DELETE_STATIC_ROUTE % (
vpn_instance, version, prefix, mask, nhp_interface,
dest_vpn_instance, next_hop)
conf_str = build_config_xml(configxmlstr)
recv_xml = set_nc_config(self.module, conf_str)
self.check_response(recv_xml, "OPERATE_STATIC_ROUTE")
def merge_debug_global(self):
""" Merge debug global """
conf_str = CE_MERGE_DEBUG_GLOBAL_HEADER
if self.debug_time_stamp:
conf_str += "<debugTimeStamp>%s</debugTimeStamp>" % self.debug_time_stamp.upper(
)
conf_str += CE_MERGE_DEBUG_GLOBAL_TAIL
recv_xml = set_nc_config(self.module, conf_str)
if "<ok/>" not in recv_xml:
self.module.fail_json(msg='Error: Merge debug global failed.')
if self.debug_time_stamp:
cmd = "info-center timestamp debugging " + TIME_STAMP_DICT.get(
self.debug_time_stamp)
self.updates_cmd.append(cmd)
self.changed = True
def config_delete_vni_peer_ip(self, nve_name, vni_id, peer_ip_list):
"""remove vni peer ip"""
for peer_ip in peer_ip_list:
if not self.is_vni_peer_list_exist(nve_name, vni_id, peer_ip):
self.module.fail_json(msg='Error: The %s does not exist' %
peer_ip)
config = False
nve_peer_info = list()
for nve_peer in self.nve_info["vni_peer_ips"]:
if nve_peer["vniId"] == vni_id:
nve_peer_info = nve_peer.get("peerAddr")
for peer in nve_peer_info:
if peer not in peer_ip_list:
config = True
if not config:
cfg_xml = CE_NC_DELETE_VNI_PEER_ADDRESS_IP_HEAD % (nve_name,
vni_id)
for peer_ip in peer_ip_list:
cfg_xml += CE_NC_DELETE_VNI_PEER_ADDRESS_IP_DELETE % peer_ip
cfg_xml += CE_NC_DELETE_VNI_PEER_ADDRESS_IP_END
else:
cfg_xml = CE_NC_DELETE_PEER_ADDRESS_IP_HEAD % (nve_name, vni_id)
for peer_ip in peer_ip_list:
cfg_xml += CE_NC_DELETE_VNI_PEER_ADDRESS_IP_DELETE % peer_ip
cfg_xml += CE_NC_DELETE_PEER_ADDRESS_IP_END
recv_xml = set_nc_config(self.module, cfg_xml)
self.check_response(recv_xml, "DELETE_VNI_PEER_IP")
self.updates_cmd.append("interface %s" % nve_name)
for peer_ip in peer_ip_list:
cmd_output = "undo vni %s head-end peer-list %s" % (vni_id,
peer_ip)
self.updates_cmd.append(cmd_output)
self.changed = True
def delete_debug_source(self):
""" Delete debug source """
if self.debug_enable == 'no_use' and not self.debug_level:
conf_str = CE_DELETE_DEBUG_SOURCE_HEADER
if self.module_name:
conf_str += "<moduleName>%s</moduleName>" % self.module_name
if self.channel_id:
conf_str += "<icChannelId>%s</icChannelId>" % self.channel_id
conf_str += CE_DELETE_DEBUG_SOURCE_TAIL
else:
conf_str = CE_MERGE_DEBUG_SOURCE_HEADER
if self.module_name:
conf_str += "<moduleName>%s</moduleName>" % self.module_name
if self.channel_id:
conf_str += "<icChannelId>%s</icChannelId>" % self.channel_id
if self.debug_enable != 'no_use':
conf_str += "<dbgEnFlg>%s</dbgEnFlg>" % CHANNEL_DEFAULT_DBG_STATE.get(
self.channel_id)
if self.debug_level:
conf_str += "<dbgEnLevel>%s</dbgEnLevel>" % CHANNEL_DEFAULT_DBG_LEVEL.get(
self.channel_id)
conf_str += CE_MERGE_DEBUG_SOURCE_TAIL
recv_xml = set_nc_config(self.module, conf_str)
if "<ok/>" not in recv_xml:
self.module.fail_json(msg='Error: Delete debug source failed.')
cmd = "undo info-center source"
if self.module_name:
cmd += " %s" % self.module_name
if self.channel_id:
cmd += " channel %s" % self.channel_id
if self.debug_enable != 'no_use':
cmd += " debug state"
if self.debug_level:
cmd += " level"
self.updates_cmd.append(cmd)
self.changed = True
def delete_mlag_global(self):
"""delete mlag global attribute info"""
xml_str = ''
if self.is_mlag_global_info_exist():
if self.mlag_priority_id:
cmd = "lacp m-lag priority %s" % self.mlag_priority_id
xml_str += '<lacpMlagPriority></lacpMlagPriority>'
self.cli_add_command(cmd, True)
if self.mlag_system_id:
cmd = "lacp m-lag system-id %s" % self.mlag_system_id
xml_str += '<lacpMlagSysId></lacpMlagSysId>'
self.cli_add_command(cmd, True)
if xml_str != '':
conf_str = CE_NC_SET_GLOBAL_LACP_MLAG_INFO_HEAD + xml_str + CE_NC_SET_GLOBAL_LACP_MLAG_INFO_TAIL
recv_xml = set_nc_config(self.module, conf_str)
if "<ok/>" not in recv_xml:
self.module.fail_json(
msg='Error: set mlag interface atrribute info failed.')
self.changed = True
def default_switchport(self, ifname):
"""Set interface default or unconfigured"""
change = False
if self.intf_info["linkType"] != "access":
self.updates_cmd.append("interface %s" % ifname)
self.updates_cmd.append("port link-type access")
self.updates_cmd.append("port default vlan 1")
change = True
else:
if self.intf_info["pvid"] != "1":
self.updates_cmd.append("interface %s" % ifname)
self.updates_cmd.append("port default vlan 1")
change = True
if not change:
return
conf_str = CE_NC_SET_DEFAULT_PORT % ifname
rcv_xml = set_nc_config(self.module, conf_str)
self.check_response(rcv_xml, "DEFAULT_INTF_VLAN")
self.changed = True
def merge_interface(self, ifname, description, admin_state, mode):
""" Merge interface attributes."""
xmlstr = ''
change = False
self.updates_cmd.append("interface %s" % ifname)
if description and self.intf_info["ifDescr"] != description:
xmlstr += CE_NC_XML_MERGE_INTF_DES % (ifname, description)
self.updates_cmd.append("description %s" % description)
change = True
if admin_state and is_admin_state_enable(self.intf_type) \
and self.intf_info["ifAdminStatus"] != admin_state:
xmlstr += CE_NC_XML_MERGE_INTF_STATUS % (ifname, admin_state)
change = True
if admin_state == "up":
self.updates_cmd.append("undo shutdown")
else:
self.updates_cmd.append("shutdown")
if is_portswitch_enalbe(self.intf_type):
if mode == "layer2" and self.intf_info["isL2SwitchPort"] != "true":
xmlstr += CE_NC_XML_MERGE_INTF_L2ENABLE % (ifname, 'enable')
self.updates_cmd.append("portswitch")
change = True
elif mode == "layer3" \
and self.intf_info["isL2SwitchPort"] != "false":
xmlstr += CE_NC_XML_MERGE_INTF_L2ENABLE % (ifname, 'disable')
self.updates_cmd.append("undo portswitch")
change = True
if not change:
return
conf_str = '<config> ' + xmlstr + ' </config>'
recv_xml = set_nc_config(self.module, conf_str)
self.check_response(recv_xml, "MERGE_INTF_ATTR")
self.changed = True
def set_mlag_global(self):
"""set mlag global attribute info"""
if self.is_mlag_global_info_change():
conf_str = CE_NC_SET_GLOBAL_LACP_MLAG_INFO_HEAD
if self.mlag_priority_id:
conf_str += "<lacpMlagPriority>%s</lacpMlagPriority>" % self.mlag_priority_id
if self.mlag_system_id:
conf_str += "<lacpMlagSysId>%s</lacpMlagSysId>" % self.mlag_system_id
conf_str += CE_NC_SET_GLOBAL_LACP_MLAG_INFO_TAIL
recv_xml = set_nc_config(self.module, conf_str)
if "<ok/>" not in recv_xml:
self.module.fail_json(
msg='Error: set mlag interface attribute info failed.')
if self.mlag_priority_id:
self.updates_cmd.append(
"lacp m-lag priority %s" % self.mlag_priority_id)
if self.mlag_system_id:
self.updates_cmd.append(
"lacp m-lag system-id %s" % self.mlag_system_id)
self.changed = True
def delete_dfs_group_nick(self):
conf_str = CE_NC_DELETE_DFS_GROUP_ATTRIBUTE_HEADER % self.dfs_group_id
conf_str = conf_str.replace('<groupInstance operation="delete">',
'<groupInstance>')
change = False
if self.nickname or self.pseudo_nickname:
conf_str += "<trillType operation='delete'>"
if self.nickname and self.dfs_group_info[
"localNickname"] == self.nickname:
conf_str += "<localNickname>%s</localNickname>" % self.nickname
change = True
self.updates_cmd.append("undo source nickname %s" %
self.nickname)
if self.pseudo_nickname and self.dfs_group_info[
"pseudoNickname"] == self.pseudo_nickname:
conf_str += "<pseudoNickname>%s</pseudoNickname>" % self.pseudo_nickname
if self.pseudo_priority and self.dfs_group_info[
"pseudoPriority"] == self.pseudo_priority:
self.updates_cmd.append(
"undo pseudo-nickname %s priority %s" %
(self.pseudo_nickname, self.pseudo_priority))
if not self.pseudo_priority:
self.updates_cmd.append("undo pseudo-nickname %s" %
self.pseudo_nickname)
change = True
conf_str += "</trillType>"
conf_str += CE_NC_DELETE_DFS_GROUP_ATTRIBUTE_TAIL
if change:
recv_xml = set_nc_config(self.module, conf_str)
if "<ok/>" not in recv_xml:
self.module.fail_json(
msg='Error: Delete DFS group attribute failed.')
self.changed = True
def merge_hybrid_vlan(self, ifname, pvid_vlan, tagged_vlans,
untagged_vlans):
"""Merge hybrid interface vlan"""
change = False
xmlstr = ""
pvid = ""
tagged = ""
untagged = ""
self.updates_cmd.append("interface %s" % ifname)
if tagged_vlans:
vlan_targed_list = self.vlan_range_to_list(tagged_vlans)
vlan_targed_map = self.vlan_list_to_bitmap(vlan_targed_list)
if untagged_vlans:
vlan_untarged_list = self.vlan_range_to_list(untagged_vlans)
vlan_untarged_map = self.vlan_list_to_bitmap(vlan_untarged_list)
if self.state == "present":
if self.intf_info["linkType"] == "hybrid":
if pvid_vlan and self.intf_info["pvid"] != pvid_vlan:
self.updates_cmd.append("port hybrid pvid vlan %s" %
pvid_vlan)
pvid = pvid_vlan
change = True
if tagged_vlans:
add_vlans = self.vlan_bitmap_add(
self.intf_info["trunkVlans"], vlan_targed_map)
if not is_vlan_bitmap_empty(add_vlans):
self.updates_cmd.append(
"port hybrid tagged vlan %s" %
tagged_vlans.replace(',', ' ').replace(
'-', ' to '))
tagged = "%s:%s" % (add_vlans, add_vlans)
change = True
if untagged_vlans:
add_vlans = self.vlan_bitmap_add(
self.intf_info["untagVlans"], vlan_untarged_map)
if not is_vlan_bitmap_empty(add_vlans):
self.updates_cmd.append(
"port hybrid untagged vlan %s" %
untagged_vlans.replace(',', ' ').replace(
'-', ' to '))
untagged = "%s:%s" % (add_vlans, add_vlans)
change = True
if pvid or tagged or untagged:
xmlstr += CE_NC_SET_PORT % (ifname, "hybrid", pvid, tagged,
untagged)
if not pvid:
xmlstr = xmlstr.replace("<pvid></pvid>", "")
if not tagged:
xmlstr = xmlstr.replace("<trunkVlans></trunkVlans>",
"")
if not untagged:
xmlstr = xmlstr.replace("<untagVlans></untagVlans>",
"")
else:
self.updates_cmd.append("port link-type hybrid")
change = True
if pvid_vlan:
self.updates_cmd.append("port hybrid pvid vlan %s" %
pvid_vlan)
pvid = pvid_vlan
if tagged_vlans:
self.updates_cmd.append(
"port hybrid tagged vlan %s" %
tagged_vlans.replace(',', ' ').replace('-', ' to '))
tagged = "%s:%s" % (vlan_targed_map, vlan_targed_map)
if untagged_vlans:
self.updates_cmd.append(
"port hybrid untagged vlan %s" %
untagged_vlans.replace(',', ' ').replace('-', ' to '))
untagged = "%s:%s" % (vlan_untarged_map, vlan_untarged_map)
if pvid or tagged or untagged:
xmlstr += CE_NC_SET_PORT % (ifname, "hybrid", pvid, tagged,
untagged)
if not pvid:
xmlstr = xmlstr.replace("<pvid></pvid>", "")
if not tagged:
xmlstr = xmlstr.replace("<trunkVlans></trunkVlans>",
"")
if not untagged:
xmlstr = xmlstr.replace("<untagVlans></untagVlans>",
"")
if not pvid_vlan and not tagged_vlans and not untagged_vlans:
xmlstr += CE_NC_SET_PORT_MODE % (ifname, "hybrid")
self.updates_cmd.append("undo port hybrid untagged vlan 1")
elif self.state == "absent":
if self.intf_info["linkType"] == "hybrid":
if pvid_vlan and self.intf_info[
"pvid"] == pvid_vlan and pvid_vlan != '1':
self.updates_cmd.append("undo port hybrid pvid vlan %s" %
pvid_vlan)
pvid = "1"
change = True
if tagged_vlans:
del_vlans = self.vlan_bitmap_del(
self.intf_info["trunkVlans"], vlan_targed_map)
if not is_vlan_bitmap_empty(del_vlans):
self.updates_cmd.append(
"undo port hybrid tagged vlan %s" %
tagged_vlans.replace(',', ' ').replace(
'-', ' to '))
undo_map = vlan_bitmap_undo(del_vlans)
tagged = "%s:%s" % (undo_map, del_vlans)
change = True
if untagged_vlans:
del_vlans = self.vlan_bitmap_del(
self.intf_info["untagVlans"], vlan_untarged_map)
if not is_vlan_bitmap_empty(del_vlans):
self.updates_cmd.append(
"undo port hybrid untagged vlan %s" %
untagged_vlans.replace(',', ' ').replace(
'-', ' to '))
undo_map = vlan_bitmap_undo(del_vlans)
untagged = "%s:%s" % (undo_map, del_vlans)
change = True
if pvid or tagged or untagged:
xmlstr += CE_NC_SET_PORT % (ifname, "hybrid", pvid, tagged,
untagged)
if not pvid:
xmlstr = xmlstr.replace("<pvid></pvid>", "")
if not tagged:
xmlstr = xmlstr.replace("<trunkVlans></trunkVlans>",
"")
if not untagged:
xmlstr = xmlstr.replace("<untagVlans></untagVlans>",
"")
if not change:
self.updates_cmd.pop()
return
conf_str = "<config>" + xmlstr + "</config>"
rcv_xml = set_nc_config(self.module, conf_str)
self.check_response(rcv_xml, "MERGE_HYBRID_PORT")
self.changed = True
def merge_trunk_vlan(self, ifname, pvid_vlan, trunk_vlans):
"""Merge trunk interface vlan"""
change = False
xmlstr = ""
pvid = ""
trunk = ""
self.updates_cmd.append("interface %s" % ifname)
if trunk_vlans:
vlan_list = self.vlan_range_to_list(trunk_vlans)
vlan_map = self.vlan_list_to_bitmap(vlan_list)
if self.state == "present":
if self.intf_info["linkType"] == "trunk":
if pvid_vlan and self.intf_info["pvid"] != pvid_vlan:
self.updates_cmd.append("port trunk pvid vlan %s" %
pvid_vlan)
pvid = pvid_vlan
change = True
if trunk_vlans:
add_vlans = self.vlan_bitmap_add(
self.intf_info["trunkVlans"], vlan_map)
if not is_vlan_bitmap_empty(add_vlans):
self.updates_cmd.append(
"port trunk allow-pass %s" %
trunk_vlans.replace(',', ' ').replace('-', ' to '))
trunk = "%s:%s" % (add_vlans, add_vlans)
change = True
if pvid or trunk:
xmlstr += CE_NC_SET_PORT % (ifname, "trunk", pvid, trunk,
"")
if not pvid:
xmlstr = xmlstr.replace("<pvid></pvid>", "")
if not trunk:
xmlstr = xmlstr.replace("<trunkVlans></trunkVlans>",
"")
else: # not trunk
self.updates_cmd.append("port link-type trunk")
change = True
if pvid_vlan:
self.updates_cmd.append("port trunk pvid vlan %s" %
pvid_vlan)
pvid = pvid_vlan
if trunk_vlans:
self.updates_cmd.append(
"port trunk allow-pass %s" %
trunk_vlans.replace(',', ' ').replace('-', ' to '))
trunk = "%s:%s" % (vlan_map, vlan_map)
if pvid or trunk:
xmlstr += CE_NC_SET_PORT % (ifname, "trunk", pvid, trunk,
"")
if not pvid:
xmlstr = xmlstr.replace("<pvid></pvid>", "")
if not trunk:
xmlstr = xmlstr.replace("<trunkVlans></trunkVlans>",
"")
if not pvid_vlan and not trunk_vlans:
xmlstr += CE_NC_SET_PORT_MODE % (ifname, "trunk")
self.updates_cmd.append(
"undo port trunk allow-pass vlan 1")
elif self.state == "absent":
if self.intf_info["linkType"] == "trunk":
if pvid_vlan and self.intf_info[
"pvid"] == pvid_vlan and pvid_vlan != '1':
self.updates_cmd.append("undo port trunk pvid vlan %s" %
pvid_vlan)
pvid = "1"
change = True
if trunk_vlans:
del_vlans = self.vlan_bitmap_del(
self.intf_info["trunkVlans"], vlan_map)
if not is_vlan_bitmap_empty(del_vlans):
self.updates_cmd.append(
"undo port trunk allow-pass %s" %
trunk_vlans.replace(',', ' ').replace('-', ' to '))
undo_map = vlan_bitmap_undo(del_vlans)
trunk = "%s:%s" % (undo_map, del_vlans)
change = True
if pvid or trunk:
xmlstr += CE_NC_SET_PORT % (ifname, "trunk", pvid, trunk,
"")
if not pvid:
xmlstr = xmlstr.replace("<pvid></pvid>", "")
if not trunk:
xmlstr = xmlstr.replace("<trunkVlans></trunkVlans>",
"")
if not change:
self.updates_cmd.pop()
return
conf_str = "<config>" + xmlstr + "</config>"
rcv_xml = set_nc_config(self.module, conf_str)
self.check_response(rcv_xml, "MERGE_TRUNK_PORT")
self.changed = True
def config_lldp(self):
"""Configure lldp enabled and mdn enabled parameters"""
if self.state == 'present':
if (self.enable_flag == 1
and self.lldpenable == 'enabled') and not self.conf_exsit:
if self.mdnstatus:
xml_str = CE_NC_MERGE_GLOBA_MDNENABLE_CONFIG % self.mdnstatus
ret_xml = set_nc_config(self.module, xml_str)
self.check_response(ret_xml, "MDN_ENABLE_CONFIG")
if self.lldpenable == 'enabled' and not self.conf_exsit:
xml_str = CE_NC_MERGE_GLOBA_LLDPENABLE_CONFIG % self.lldpenable
ret_xml = set_nc_config(self.module, xml_str)
self.check_response(ret_xml, "LLDP_ENABLE_CONFIG")
if self.mdnstatus:
xml_str = CE_NC_MERGE_GLOBA_MDNENABLE_CONFIG % self.mdnstatus
ret_xml = set_nc_config(self.module, xml_str)
self.check_response(ret_xml, "MDN_ENABLE_CONFIG")
if (self.enable_flag == 1) and not self.conf_exsit:
if self.mdnstatus:
xml_str = CE_NC_MERGE_GLOBA_MDNENABLE_CONFIG % self.mdnstatus
ret_xml = set_nc_config(self.module, xml_str)
self.check_response(ret_xml, "MDN_ENABLE_CONFIG")
if (self.lldpenable == 'enabled'
or self.enable_flag == 1) and not self.conf_exsit_lldp:
if self.hold_multiplier:
xml_str = CE_NC_MERGE_GLOBAL_LLDP_CONFIG_HEADER + \
(CE_NC_MERGE_GLOBAL_LLDP_CONFIG_HOLD_MULTIPLIER % self.hold_multiplier) + \
CE_NC_MERGE_GLOBAL_LLDP_CONFIG_TAIL
ret_xml = set_nc_config(self.module, xml_str)
self.check_response(ret_xml, "LLDP_CONFIG_INTERVAL")
if self.interval:
xml_str = CE_NC_MERGE_GLOBAL_LLDP_CONFIG_HEADER + \
(CE_NC_MERGE_GLOBAL_LLDP_CONFIG_INTERVAL % self.interval) + \
CE_NC_MERGE_GLOBAL_LLDP_CONFIG_TAIL
ret_xml = set_nc_config(self.module, xml_str)
self.check_response(ret_xml, "LLDP_CONFIG_INTERVAL")
if self.restart_delay:
xml_str = CE_NC_MERGE_GLOBAL_LLDP_CONFIG_HEADER + \
(CE_NC_MERGE_GLOBAL_LLDP_CONFIG_RESTART_DELAY % self.restart_delay) + \
CE_NC_MERGE_GLOBAL_LLDP_CONFIG_TAIL
ret_xml = set_nc_config(self.module, xml_str)
self.check_response(ret_xml, "LLDP_CONFIG_INTERVAL")
if self.transmit_delay:
xml_str = CE_NC_MERGE_GLOBAL_LLDP_CONFIG_HEADER + \
(CE_NC_MERGE_GLOBAL_LLDP_CONFIG_TRANSMIT_DELAY % self.transmit_delay) + \
CE_NC_MERGE_GLOBAL_LLDP_CONFIG_TAIL
ret_xml = set_nc_config(self.module, xml_str)
self.check_response(ret_xml, "LLDP_CONFIG_INTERVAL")
if self.notification_interval:
xml_str = CE_NC_MERGE_GLOBAL_LLDP_CONFIG_HEADER + \
(CE_NC_MERGE_GLOBAL_LLDP_CONFIG_NOTIFICATION_INTERVAL % self.notification_interval) + \
CE_NC_MERGE_GLOBAL_LLDP_CONFIG_TAIL
ret_xml = set_nc_config(self.module, xml_str)
self.check_response(ret_xml, "LLDP_CONFIG_INTERVAL")
if self.fast_count:
xml_str = CE_NC_MERGE_GLOBAL_LLDP_CONFIG_HEADER + \
(CE_NC_MERGE_GLOBAL_LLDP_CONFIG_FAST_COUNT % self.fast_count) + \
CE_NC_MERGE_GLOBAL_LLDP_CONFIG_TAIL
ret_xml = set_nc_config(self.module, xml_str)
self.check_response(ret_xml, "LLDP_CONFIG_INTERVAL")
if self.mdn_notification_interval:
xml_str = CE_NC_MERGE_GLOBAL_LLDP_CONFIG_HEADER + \
(CE_NC_MERGE_GLOBAL_LLDP_CONFIG_MDN_NOTIFICATION_INTERVAL % self.mdn_notification_interval) + \
CE_NC_MERGE_GLOBAL_LLDP_CONFIG_TAIL
ret_xml = set_nc_config(self.module, xml_str)
self.check_response(ret_xml, "LLDP_CONFIG_INTERVAL")
if self.management_address:
xml_str = CE_NC_MERGE_GLOBAL_LLDP_CONFIG_HEADER + \
(CE_NC_MERGE_GLOBAL_LLDP_CONFIG_MANAGEMENT_ADDRESS % self.management_address) + \
CE_NC_MERGE_GLOBAL_LLDP_CONFIG_TAIL
ret_xml = set_nc_config(self.module, xml_str)
self.check_response(ret_xml, "LLDP_CONFIG_INTERVAL")
if self.bind_name:
xml_str = CE_NC_MERGE_GLOBAL_LLDP_CONFIG_HEADER + \
(CE_NC_MERGE_GLOBAL_LLDP_CONFIG_BIND_NAME % self.bind_name) + \
CE_NC_MERGE_GLOBAL_LLDP_CONFIG_TAIL
ret_xml = set_nc_config(self.module, xml_str)
self.check_response(ret_xml, "LLDP_CONFIG_INTERVAL")
if self.lldpenable == 'disabled' and not self.conf_exsit:
xml_str = CE_NC_MERGE_GLOBA_LLDPENABLE_CONFIG % self.lldpenable
ret_xml = set_nc_config(self.module, xml_str)
self.check_response(ret_xml, "LLDP_DISABLE_CONFIG")
def merge_process(self):
"""merge ospf process"""
xml_area = ""
xml_str = ""
self.updates_cmd.append("ospf %s" % self.process_id)
# nexthop weight
xml_nh = ""
if self.nexthop_addr and self.is_nexthop_change():
xml_nh = CE_NC_XML_MERGE_NEXTHOP % (self.nexthop_addr,
self.nexthop_weight)
self.updates_cmd.append("nexthop %s weight %s" %
(self.nexthop_addr, self.nexthop_weight))
# max load balance
xml_lb = ""
if self.max_load_balance and self.ospf_info.get(
"maxLoadBalancing") != self.max_load_balance:
xml_lb = CE_NC_XML_SET_LB % self.max_load_balance
self.updates_cmd.append("maximum load-balancing %s" %
self.max_load_balance)
xml_topo = ""
if xml_lb or xml_nh:
xml_topo = CE_NC_XML_BUILD_MERGE_TOPO % (xml_nh + xml_lb)
if self.area:
self.updates_cmd.append("area %s" % self.get_area_ip())
xml_network = ""
xml_auth = ""
if self.addr and self.mask:
if not self.is_network_exist():
xml_network += CE_NC_XML_MERGE_NETWORKS % (
self.addr, self.get_wildcard_mask())
self.updates_cmd.append(
"network %s %s" %
(self.addr, self.get_wildcard_mask()))
# NOTE: for security, authentication config will always be update
if self.auth_mode:
xml_auth += CE_NC_XML_SET_AUTH_MODE % self.auth_mode
if self.auth_mode == "none":
self.updates_cmd.append("undo authentication-mode")
else:
self.updates_cmd.append("authentication-mode %s" %
self.auth_mode)
if self.auth_mode == "simple" and self.auth_text_simple:
xml_auth += CE_NC_XML_SET_AUTH_TEXT_SIMPLE % self.auth_text_simple
self.updates_cmd.pop()
self.updates_cmd.append(
"authentication-mode %s %s" %
(self.auth_mode, self.auth_text_simple))
if self.auth_mode in ["hmac-sha256", "hmac-sha256", "md5"]:
if self.auth_key_id and self.auth_text_md5:
xml_auth += CE_NC_XML_SET_AUTH_MD5 % (
self.auth_key_id, self.auth_text_md5)
self.updates_cmd.pop()
self.updates_cmd.append(
"authentication-mode %s %s %s" %
(self.auth_mode, self.auth_key_id,
self.auth_text_md5))
if xml_network or xml_auth or not self.is_area_exist():
xml_area += CE_NC_XML_BUILD_MERGE_AREA % (
self.get_area_ip(), xml_network + xml_auth)
elif self.is_area_exist():
self.updates_cmd.pop() # remove command: area
else:
pass
if xml_area or xml_topo:
xml_str = CE_NC_XML_BUILD_MERGE_PROCESS % (self.process_id,
xml_topo + xml_area)
recv_xml = set_nc_config(self.module, xml_str)
self.check_response(recv_xml, "MERGE_PROCESS")
self.changed = True
def main():
""" main """
argument_spec = dict(
rpc=dict(choices=['get', 'edit-config',
'execute-action', 'execute-cli'], required=True),
cfg_xml=dict(required=True)
)
argument_spec.update(ce_argument_spec)
module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True)
rpc = module.params['rpc']
cfg_xml = module.params['cfg_xml']
changed = False
end_state = dict()
if rpc == "get":
response = get_nc_config(module, cfg_xml)
if "<data/>" in response:
end_state["result"] = "<data/>"
else:
tmp1 = response.split(r"<data>")
tmp2 = tmp1[1].split(r"</data>")
result = tmp2[0].split("\n")
end_state["result"] = result
elif rpc == "edit-config":
response = set_nc_config(module, cfg_xml)
if "<ok/>" not in response:
module.fail_json(msg='rpc edit-config failed.')
changed = True
end_state["result"] = "ok"
elif rpc == "execute-action":
response = execute_nc_action(module, cfg_xml)
if "<ok/>" not in response:
module.fail_json(msg='rpc execute-action failed.')
changed = True
end_state["result"] = "ok"
elif rpc == "execute-cli":
response = execute_nc_cli(module, cfg_xml)
if "<data/>" in response:
end_state["result"] = "<data/>"
else:
tmp1 = response.split(r"<data>")
tmp2 = tmp1[1].split(r"</data>")
result = tmp2[0].split("\n")
end_state["result"] = result
else:
module.fail_json(msg='please input correct rpc.')
results = dict()
results['changed'] = changed
results['end_state'] = end_state
module.exit_json(**results)
def netconf_set_config(self, conf_str):
""" Set configure by netconf """
xml_str = set_nc_config(self.module, conf_str)
return xml_str
def config_evpn_instance(self):
"""Configure EVPN instance"""
self.updates_cmd.append("bridge-domain %s" % self.bridge_domain_id)
if self.evpn == 'disable':
xml_str = CE_NC_DELETE_EVPN_CONFIG % (self.bridge_domain_id,
self.bridge_domain_id)
recv_xml = set_nc_config(self.module, xml_str)
self.check_response(recv_xml, "MERGE_EVPN_BD_CONFIG")
self.updates_cmd.append(" undo evpn")
self.changed = True
return
xml_str = CE_NC_MERGE_EVPN_CONFIG_HEAD % (self.bridge_domain_id,
self.bridge_domain_id)
self.updates_cmd.append(" evpn")
# configure RD
if self.route_distinguisher:
if not self.existing['route_distinguisher']:
if self.route_distinguisher.lower() == 'auto':
xml_str += '<evpnAutoRD>true</evpnAutoRD>'
self.updates_cmd.append(" route-distinguisher auto")
else:
xml_str += '<evpnRD>%s</evpnRD>' % self.route_distinguisher
self.updates_cmd.append(" route-distinguisher %s" %
self.route_distinguisher)
# process VPN target list
vpn_target_export = copy.deepcopy(self.vpn_target_export)
vpn_target_import = copy.deepcopy(self.vpn_target_import)
if self.vpn_target_both:
for ele in self.vpn_target_both:
if ele not in vpn_target_export:
vpn_target_export.append(ele)
if ele not in vpn_target_import:
vpn_target_import.append(ele)
# config EVPN auto RTS
head_flag = False
if vpn_target_export:
for ele in vpn_target_export:
if ele.lower() == 'auto' and \
(not self.is_vpn_target_exist('export_extcommunity', ele.lower())):
if not head_flag:
xml_str += CE_NC_MERGE_EVPN_AUTORTS_HEAD
head_flag = True
xml_str += CE_NC_MERGE_EVPN_AUTORTS_CONTEXT % (
'export_extcommunity')
self.updates_cmd.append(
" vpn-target auto export-extcommunity")
if vpn_target_import:
for ele in vpn_target_import:
if ele.lower() == 'auto' and \
(not self.is_vpn_target_exist('import_extcommunity', ele.lower())):
if not head_flag:
xml_str += CE_NC_MERGE_EVPN_AUTORTS_HEAD
head_flag = True
xml_str += CE_NC_MERGE_EVPN_AUTORTS_CONTEXT % (
'import_extcommunity')
self.updates_cmd.append(
" vpn-target auto import-extcommunity")
if head_flag:
xml_str += CE_NC_MERGE_EVPN_AUTORTS_TAIL
# config EVPN RTS
head_flag = False
if vpn_target_export:
for ele in vpn_target_export:
if ele.lower() != 'auto' and \
(not self.is_vpn_target_exist('export_extcommunity', ele.lower())):
if not head_flag:
xml_str += CE_NC_MERGE_EVPN_RTS_HEAD
head_flag = True
xml_str += CE_NC_MERGE_EVPN_RTS_CONTEXT % (
'export_extcommunity', ele)
self.updates_cmd.append(
" vpn-target %s export-extcommunity" % ele)
if vpn_target_import:
for ele in vpn_target_import:
if ele.lower() != 'auto' and \
(not self.is_vpn_target_exist('import_extcommunity', ele.lower())):
if not head_flag:
xml_str += CE_NC_MERGE_EVPN_RTS_HEAD
head_flag = True
xml_str += CE_NC_MERGE_EVPN_RTS_CONTEXT % (
'import_extcommunity', ele)
self.updates_cmd.append(
" vpn-target %s import-extcommunity" % ele)
if head_flag:
xml_str += CE_NC_MERGE_EVPN_RTS_TAIL
xml_str += CE_NC_MERGE_EVPN_CONFIG_TAIL
recv_xml = set_nc_config(self.module, xml_str)
self.check_response(recv_xml, "MERGE_EVPN_BD_CONFIG")
self.changed = True
def operate_vrf_af(self):
"""config/delete vrf"""
vrf_target_operate = ''
if self.route_distinguisher is None:
route_d = ''
else:
route_d = self.route_distinguisher
if self.state == 'present':
if self.vrf_aftype:
if self.is_vrf_af_exist():
self.vrf_af_type_changed = False
else:
self.vrf_af_type_changed = True
configxmlstr = CE_NC_CREATE_VRF_AF % (
self.vrf, self.vrf_aftype, route_d, vrf_target_operate)
else:
self.vrf_af_type_changed = bool(self.is_vrf_af_exist())
if self.vpn_target_state == 'present':
if self.evpn is False and not self.is_vrf_rt_exist():
vrf_target_operate = CE_NC_CREATE_VRF_TARGET % (
self.vpn_target_type, self.vpn_target_value)
configxmlstr = CE_NC_CREATE_VRF_AF % (
self.vrf, self.vrf_aftype, route_d, vrf_target_operate)
self.vpn_target_changed = True
if self.evpn is True and not self.is_vrf_rt_exist():
vrf_target_operate = CE_NC_CREATE_EXTEND_VRF_TARGET % (
self.vpn_target_type, self.vpn_target_value)
configxmlstr = CE_NC_CREATE_VRF_AF % (
self.vrf, self.vrf_aftype, route_d, vrf_target_operate)
self.vpn_target_changed = True
elif self.vpn_target_state == 'absent':
if self.evpn is False and self.is_vrf_rt_exist():
vrf_target_operate = CE_NC_DELETE_VRF_TARGET % (
self.vpn_target_type, self.vpn_target_value)
configxmlstr = CE_NC_CREATE_VRF_AF % (
self.vrf, self.vrf_aftype, route_d, vrf_target_operate)
self.vpn_target_changed = True
if self.evpn is True and self.is_vrf_rt_exist():
vrf_target_operate = CE_NC_DELETE_EXTEND_VRF_TARGET % (
self.vpn_target_type, self.vpn_target_value)
configxmlstr = CE_NC_CREATE_VRF_AF % (
self.vrf, self.vrf_aftype, route_d, vrf_target_operate)
self.vpn_target_changed = True
else:
if self.route_distinguisher:
if not self.is_vrf_rd_exist():
configxmlstr = CE_NC_CREATE_VRF_AF % (
self.vrf, self.vrf_aftype, route_d,
vrf_target_operate)
self.vrf_rd_changed = True
else:
self.vrf_rd_changed = False
else:
if self.is_vrf_rd_exist():
configxmlstr = CE_NC_CREATE_VRF_AF % (
self.vrf, self.vrf_aftype, route_d,
vrf_target_operate)
self.vrf_rd_changed = True
else:
self.vrf_rd_changed = False
if not self.vrf_rd_changed and not self.vrf_af_type_changed and not self.vpn_target_changed:
self.changed = False
else:
self.changed = True
else:
if self.is_vrf_af_exist():
configxmlstr = CE_NC_DELETE_VRF_AF % (self.vrf,
self.vrf_aftype)
self.changed = True
else:
self.changed = False
if not self.changed:
return
conf_str = build_config_xml(configxmlstr)
recv_xml = set_nc_config(self.module, conf_str)
self.check_response(recv_xml, "OPERATE_VRF_AF")
def config_intf_dldp(self):
"""Config global dldp"""
if self.same_conf:
return
if self.state == "present":
enable = self.enable
if not self.enable:
enable = self.dldp_intf_conf['dldpEnable']
if enable == 'enable':
enable = 'true'
else:
enable = 'false'
mode_enable = self.mode_enable
if not self.mode_enable:
mode_enable = self.dldp_intf_conf['dldpCompatibleEnable']
if mode_enable == 'enable':
mode_enable = 'true'
else:
mode_enable = 'false'
local_mac = self.local_mac
if not self.local_mac:
local_mac = self.dldp_intf_conf['dldpLocalMac']
if self.enable == 'disable' and self.enable != self.dldp_intf_conf[
'dldpEnable']:
xml_str = CE_NC_DELETE_DLDP_INTF_CONFIG % self.interface
ret_xml = set_nc_config(self.module, xml_str)
self.check_response(ret_xml, "DELETE_DLDP_INTF_CONFIG")
elif self.dldp_intf_conf[
'dldpEnable'] == 'disable' and self.enable == 'enable':
xml_str = CE_NC_CREATE_DLDP_INTF_CONFIG % (
self.interface, 'true', mode_enable, local_mac)
ret_xml = set_nc_config(self.module, xml_str)
self.check_response(ret_xml, "CREATE_DLDP_INTF_CONFIG")
elif self.dldp_intf_conf['dldpEnable'] == 'enable':
if mode_enable == 'false':
local_mac = ''
xml_str = CE_NC_MERGE_DLDP_INTF_CONFIG % (
self.interface, enable, mode_enable, local_mac)
ret_xml = set_nc_config(self.module, xml_str)
self.check_response(ret_xml, "MERGE_DLDP_INTF_CONFIG")
if self.reset == 'enable':
xml_str = CE_NC_ACTION_RESET_INTF_DLDP % self.interface
ret_xml = execute_nc_action(self.module, xml_str)
self.check_response(ret_xml, "ACTION_RESET_INTF_DLDP")
self.changed = True
else:
if self.local_mac and judge_is_mac_same(
self.local_mac, self.dldp_intf_conf['dldpLocalMac']):
if self.dldp_intf_conf['dldpEnable'] == 'enable':
dldp_enable = 'true'
else:
dldp_enable = 'false'
if self.dldp_intf_conf['dldpCompatibleEnable'] == 'enable':
dldp_compat_enable = 'true'
else:
dldp_compat_enable = 'false'
xml_str = CE_NC_MERGE_DLDP_INTF_CONFIG % (
self.interface, dldp_enable, dldp_compat_enable, '')
ret_xml = set_nc_config(self.module, xml_str)
self.check_response(ret_xml, "UNDO_DLDP_INTF_LOCAL_MAC_CONFIG")
self.changed = True
def netconf_set_config(self, xml_str, xml_name):
"""netconf set config"""
rcv_xml = set_nc_config(self.module, xml_str)
if "<ok/>" not in rcv_xml:
self.module.fail_json(msg='Error: %s failed.' % xml_name)
def modify_dfs_group(self):
"""modify dfs group info"""
if self.is_dfs_group_info_change():
conf_str = CE_NC_MERGE_DFS_GROUP_INFO_HEADER % self.dfs_group_id
if self.priority_id and self.dfs_group_info[
"priority"] != self.priority_id:
conf_str += "<priority>%s</priority>" % self.priority_id
if self.ip_address and self.dfs_group_info[
"ipAddress"] != self.ip_address:
conf_str += "<ipAddress>%s</ipAddress>" % self.ip_address
if self.vpn_instance_name and self.dfs_group_info[
"srcVpnName"] != self.vpn_instance_name:
if not self.ip_address:
self.module.fail_json(
msg=
'Error: ip_address can not be null if vpn_instance_name is exist.'
)
conf_str += "<srcVpnName>%s</srcVpnName>" % self.vpn_instance_name
if self.nickname or self.pseudo_nickname or self.pseudo_priority:
conf_str += "<trillType>"
if self.nickname and self.dfs_group_info[
"localNickname"] != self.nickname:
conf_str += "<localNickname>%s</localNickname>" % self.nickname
if self.pseudo_nickname and self.dfs_group_info[
"pseudoNickname"] != self.pseudo_nickname:
conf_str += "<pseudoNickname>%s</pseudoNickname>" % self.pseudo_nickname
if self.pseudo_priority and self.dfs_group_info[
"pseudoPriority"] != self.pseudo_priority:
if not self.pseudo_nickname:
self.module.fail_json(
msg=
'Error: pseudo_nickname can not be null if pseudo_priority is exist.'
)
conf_str += "<pseudoPriority>%s</pseudoPriority>" % self.pseudo_priority
conf_str += "</trillType>"
conf_str += CE_NC_MERGE_DFS_GROUP_INFO_TAIL
recv_xml = set_nc_config(self.module, conf_str)
if "<ok/>" not in recv_xml:
self.module.fail_json(
msg='Error: Merge DFS group info failed.')
self.updates_cmd.append("dfs-group 1")
if self.priority_id:
self.updates_cmd.append("priority %s" % self.priority_id)
if self.ip_address:
if self.vpn_instance_name:
self.updates_cmd.append(
"source ip %s vpn-instance %s" %
(self.ip_address, self.vpn_instance_name))
else:
self.updates_cmd.append("source ip %s" % self.ip_address)
if self.nickname:
self.updates_cmd.append("source nickname %s" % self.nickname)
if self.pseudo_nickname:
if self.pseudo_priority:
self.updates_cmd.append(
"pseudo-nickname %s priority %s" %
(self.pseudo_nickname, self.pseudo_priority))
else:
self.updates_cmd.append("pseudo-nickname %s" %
self.pseudo_nickname)
self.changed = True
def netconf_set_config(self, conf_str):
""" Netconf set config """
xml_str = set_nc_config(self.module, conf_str)
return xml_str
def create_process(self):
"""Create ospf process"""
xml_area = ""
self.updates_cmd.append("ospf %s" % self.process_id)
xml_create = CE_NC_CREATE_PROCESS % self.process_id
set_nc_config(self.module, xml_create)
# nexthop weight
xml_nh = ""
if self.nexthop_addr:
xml_nh = CE_NC_XML_MERGE_NEXTHOP % (self.nexthop_addr,
self.nexthop_weight)
self.updates_cmd.append("nexthop %s weight %s" %
(self.nexthop_addr, self.nexthop_weight))
# max load balance
xml_lb = ""
if self.max_load_balance:
xml_lb = CE_NC_XML_SET_LB % self.max_load_balance
self.updates_cmd.append("maximum load-balancing %s" %
self.max_load_balance)
xml_topo = ""
if xml_lb or xml_nh:
xml_topo = CE_NC_XML_BUILD_TOPO % (xml_nh + xml_lb)
if self.area:
self.updates_cmd.append("area %s" % self.get_area_ip())
xml_auth = ""
xml_network = ""
# networks
if self.addr and self.mask:
xml_network = CE_NC_XML_MERGE_NETWORKS % (
self.addr, self.get_wildcard_mask())
self.updates_cmd.append("network %s %s" %
(self.addr, self.get_wildcard_mask()))
# authentication mode
if self.auth_mode:
xml_auth += CE_NC_XML_SET_AUTH_MODE % self.auth_mode
if self.auth_mode == "none":
self.updates_cmd.append("undo authentication-mode")
else:
self.updates_cmd.append("authentication-mode %s" %
self.auth_mode)
if self.auth_mode == "simple" and self.auth_text_simple:
xml_auth += CE_NC_XML_SET_AUTH_TEXT_SIMPLE % self.auth_text_simple
self.updates_cmd.pop()
self.updates_cmd.append(
"authentication-mode %s %s" %
(self.auth_mode, self.auth_text_simple))
if self.auth_mode in ["hmac-sha256", "hmac-sha256", "md5"]:
if self.auth_key_id and self.auth_text_md5:
xml_auth += CE_NC_XML_SET_AUTH_MD5 % (
self.auth_key_id, self.auth_text_md5)
self.updates_cmd.pop()
self.updates_cmd.append(
"authentication-mode %s %s %s" %
(self.auth_mode, self.auth_key_id,
self.auth_text_md5))
if xml_network or xml_auth or not self.is_area_exist():
xml_area += CE_NC_XML_BUILD_MERGE_AREA % (
self.get_area_ip(), xml_network + xml_auth)
xml_str = CE_NC_XML_BUILD_MERGE_PROCESS % (self.process_id,
xml_topo + xml_area)
recv_xml = set_nc_config(self.module, xml_str)
self.check_response(recv_xml, "CREATE_PROCESS")
self.changed = True
