def remove_trunk_vlan(self, interface_id, vlan):
interface = self.get_interface(interface_id)
if vlan not in interface.trunk_vlans:
raise UnknownVlan(vlan)
with self.config(), self.interface(interface_id):
self.ssh.do('switchport trunk allowed vlan remove {}'.format(vlan))
def remove_vrrp_group(self, vlan_id, group_id):
config = self.query(one_interface_vlan(vlan_id))
if len(config.xpath(
"data/configuration/interfaces/interface/unit")) < 1:
raise UnknownVlan(vlan_id)
address_node = first(
config.xpath(
"data/configuration/interfaces/interface/unit/family"
"/inet/address/vrrp-group/name[text()=\"{}\"]/../..".format(
group_id)))
if address_node is None:
raise VrrpDoesNotExistForVlan(vlan=vlan_id, vrrp_group_id=group_id)
vrrp_node = to_ele("""
<vrrp-group operation="delete">
<name>{group_id}</name>
</vrrp-group>""".format(group_id=group_id))
update = Update()
update.add_interface(
irb_address_update(vlan_id,
first_text(address_node.xpath("name")),
children=[vrrp_node]))
self._push(update)
def remove_vlan(self, number):
try:
self.node.enable(["show vlan {}".format(number)], strict=True)
except CommandError:
raise UnknownVlan(number)
self.node.config(["no interface Vlan{}".format(number), "no vlan {}".format(number)])
def add_trunk_vlan(self, interface_id, vlan):
interface_data = self.get_interface_data(interface_id)
actual_port_mode = resolve_port_mode(interface_data)
if actual_port_mode == "access":
raise InterfaceInWrongPortMode("access")
vlans = self.get_vlans()
if not [v for v in vlans if v.number == vlan]:
raise UnknownVlan(vlan)
with self.config(), self.interface(interface_id):
if actual_port_mode is None:
self.set("switchport mode trunk")
actual_port_mode = "trunk"
if actual_port_mode == "trunk":
if has_trunk_vlans(interface_data):
self.set("switchport {} allowed vlan add {}", actual_port_mode, vlan) \
.on_result_matching(".*VLAN does not exist.*", UnknownVlan, vlan)
else:
self.set("switchport {} allowed vlan {}", actual_port_mode, vlan) \
.on_result_matching(".*VLAN does not exist.*", UnknownVlan, vlan)
else:
self.set("switchport {} allowed vlan add {}", actual_port_mode, vlan) \
.on_result_matching(".*VLAN does not exist.*", UnknownVlan, vlan)
def set_access_vlan(self, interface_id, vlan):
update_attributes = []
update_vlan_members = []
config = self.query(all_interfaces, self.custom_strategies.all_vlans)
self.custom_strategies.vlan_node(config, vlan)
interface_node = self.get_interface_config(interface_id, config)
interface = self.node_to_interface(interface_node, config)
if interface.port_mode == TRUNK:
raise InterfaceInWrongPortMode("trunk")
elif self.get_port_mode(interface_node) is None:
update_attributes.append(
self.custom_strategies.get_interface_port_mode_update_element(
"access"))
if interface.access_vlan != vlan:
self.custom_strategies.update_vlan_members(interface_node,
update_vlan_members,
vlan)
if update_attributes or update_vlan_members:
update = Update()
update.add_interface(
self.custom_strategies.interface_update(
interface_id, "0", update_attributes, update_vlan_members))
try:
self._push_interface_update(interface_id, update)
except RPCError as e:
if "No vlan matches vlan tag" in e.message:
raise UnknownVlan(vlan)
raise
def get_vlan(self, number):
result = self.shell.do("show vlan id {}".format(number))
if regex.match(".*\^.*", result[0]):
raise BadVlanNumber()
elif regex.match("^ERROR", result[0]):
raise UnknownVlan(number)
else:
return parse_vlan_list(result)[0]
def get_vlan(self, number):
config = self.query(one_vlan_by_vlan_id(number), all_interfaces)
if config.xpath("data/configuration/vlans/vlan"):
vlan_node = config.xpath("data/configuration/vlans/vlan")[0]
return self.get_vlan_from_node(vlan_node, config)
else:
raise UnknownVlan(number)
def get_vlan_config(self, number, config):
vlan_node = first(
config.xpath(
"data/configuration/vlans/vlan/vlan-id[text()=\"{}\"]/..".
format(number)))
if vlan_node is None:
raise UnknownVlan(number)
return vlan_node
def get_vlan_interfaces(self, vlan_number):
result = self.shell.do("show vlan id {}".format(vlan_number))
if regex.match(".*\^.*", result[0]):
raise BadVlanNumber()
elif regex.match("^ERROR", result[0]):
raise UnknownVlan(vlan_number)
return self.parse_interface_from_vlan_list(vlan_number, result)
def vlan_node(self, config, number):
vlan_node = first(
config.xpath(
"data/configuration/bridge-domains/domain/vlan-id[text()=\"{}\"]/.."
.format(number)))
if vlan_node is None:
raise UnknownVlan(number)
return vlan_node
def get_vlan_interfaces(self, vlan_number):
result = self.shell.do("show vlan id {}".format(vlan_number), wait_for=("--More-- or (q)uit", "#"), include_last_line=True)
while len(result) > 0 and "--More--" in result[-1]:
result += self.shell.send_key("m", wait_for=("--More-- or (q)uit", "#"), include_last_line=True)
if regex.match(".*\^.*", result[0]):
raise BadVlanNumber()
elif regex.match("^ERROR", result[0]):
raise UnknownVlan(vlan_number)
return self.parse_interface_from_vlan_list(vlan_number, result)
def get_vlan_interfaces(self, vlan_number):
interfaces = []
result = self._show_vlan(vlan_number)
if result[0].startswith("Error"):
raise UnknownVlan(vlan_number)
for line in result:
if regex.match("(Untagged|Statically tagged) Ports\s+: (.*)$", line):
for real_name in _to_real_names(parse_if_ranges(regex[1])):
interfaces.append(real_name)
return interfaces
def get_vlan_interfaces(self, vlan_number):
config = self.query(one_vlan_by_vlan_id(vlan_number), all_interfaces)
if not config.xpath("data/configuration/vlans/vlan"):
raise UnknownVlan(vlan_number)
vlan_node = config.xpath("data/configuration/vlans/vlan")[0]
interface_nodes = config.xpath(
"data/configuration/interfaces/interface")
return self.get_vlan_interfaces_from_node(vlan_node, interface_nodes)
def remove_trunk_vlan(self, interface_id, vlan):
interface = self.get_interface(interface_id)
if vlan not in interface.trunk_vlans:
raise UnknownVlan(vlan)
commands = [
"interface {}".format(interface_id),
"switchport trunk allowed vlan remove {}".format(vlan)
]
self.node.config(commands)
def get_vlan(self, vlan_number):
result = self.page_reader.do(self.shell,
"show vlan id {}".format(vlan_number))
if regex.match(".*\^.*", result[0]):
raise BadVlanNumber()
elif regex.match("^ERROR", result[0]):
raise UnknownVlan(vlan_number)
vlan = parse_vlan_list(result)[0]
return vlan
def _get_vlan(self, vlan_number, include_vif_data=False):
result = self._show_vlan(vlan_number)
if result[0].startswith("Error"):
raise UnknownVlan(vlan_number)
vlan = VlanBrocade(vlan_number)
for line in result:
if regex.match(".*PORT-VLAN \d*, Name ([^,]+),.*", line):
vlan.name = regex[0] if regex[0] != "[None]" else None
vlan.name = vlan.name if vlan.name != "DEFAULT-VLAN" else "default"
elif regex.match(".*Associated Virtual Interface Id: (\d+).*", line):
vlan.vlan_interface_name = regex[0]
if include_vif_data:
add_interface_vlan_data(vlan, self.shell.do("show running-config interface ve {}".format(regex[0])))
return vlan
def set_interface_native_vlan(self, interface_id, vlan):
port_mode_node = None
native_vlan_id_node = None
config = self.query(all_interfaces, self.custom_strategies.all_vlans)
self.custom_strategies.vlan_node(config, vlan)
interface_node = self.get_interface_config(interface_id, config)
interface = self.node_to_interface(interface_node, config)
actual_port_mode = self.get_port_mode(interface_node)
if actual_port_mode is ACCESS:
raise InterfaceInWrongPortMode("access")
elif actual_port_mode is None:
port_mode_node = self.custom_strategies.get_interface_port_mode_update_element(
"trunk")
if vlan in interface.trunk_vlans:
raise VlanAlreadyInTrunk(vlan)
elif interface.trunk_native_vlan != vlan:
native_vlan_id_node = to_ele(
"<native-vlan-id>{}</native-vlan-id>".format(vlan))
if native_vlan_id_node is not None:
interface = self.custom_strategies.interface_update(
interface_id, "0",
[port_mode_node] if port_mode_node is not None else [])
self.custom_strategies.set_native_vlan_id_node(
interface, native_vlan_id_node)
update = Update()
update.add_interface(interface)
try:
self._push_interface_update(interface_id, update)
except RPCError as e:
if "No vlan matches vlan tag" in e.message:
raise UnknownVlan(vlan)
raise
def set_access_vlan(self, interface_id, vlan):
update_attributes = []
update_vlan_members = []
config = self.query(all_interfaces, all_vlans)
self.get_vlan_config(vlan, config)
interface_node = self.get_interface_config(interface_id, config)
interface = self.node_to_interface(interface_node, config)
if interface.port_mode == TRUNK:
raise InterfaceInWrongPortMode("trunk")
elif self.get_port_mode(interface_node) is None:
update_attributes.append(
self.custom_strategies.get_interface_port_mode_update_element(
"access"))
if interface.access_vlan != vlan:
if interface_node is not None:
for members in interface_node.xpath(
"unit/family/ethernet-switching/vlan/members"):
update_vlan_members.append(
to_ele(
'<members operation="delete">{}</members>'.format(
members.text)))
update_vlan_members.append(
to_ele("<members>{}</members>".format(vlan)))
if update_attributes or update_vlan_members:
update = Update()
update.add_interface(
interface_update(interface_id, "0", update_attributes,
update_vlan_members))
try:
self._push_interface_update(interface_id, update)
except RPCError as e:
if "No vlan matches vlan tag" in e.message:
raise UnknownVlan(vlan)
raise
def remove_ip_from_vlan(self, vlan_number, ip_network):
config = self.query(one_interface_vlan(vlan_number))
if len(config.xpath(
"data/configuration/interfaces/interface/unit")) < 1:
raise UnknownVlan(vlan_number)
for addr_node in config.xpath(
"data/configuration/interfaces/interface/unit/family/inet/address/name"
):
address = IPNetwork(addr_node.text)
if ip_network in address:
update = Update()
update.add_interface(
irb_address_update(vlan_number,
ip_network,
operation="delete"))
self._push(update)
return
raise UnknownIP(ip_network)
def get_vlan(self, number):
try:
vlans_result, interfaces_result = self.node.enable(
["show vlan {}".format(number), "show interfaces Vlan{}".format(number)], strict=True)
vlans_info = vlans_result['result']
interfaces_info = interfaces_result['result']
except CommandError as e:
if "not found in current VLAN database" in e.command_error:
raise UnknownVlan(number)
elif "Invalid input" in e.command_error:
raise BadVlanNumber()
elif "Interface does not exist" in e.command_error:
vlans_info = e.output[1]
interfaces_info = {"interfaces": {}}
else:
raise
vlans = _extract_vlans(vlans_info)
_apply_interface_data(interfaces_info, vlans)
self._apply_interface_vlan_data(vlans)
return vlans[0]
def _get_vlan_run_conf(self, vlan_number):
run_config = self._show_run_vlan(vlan_number)
if not run_config:
raise UnknownVlan(vlan_number)
return run_config
def add_vrrp_group(self,
vlan_number,
group_id,
ips=None,
priority=None,
hello_interval=None,
dead_interval=None,
track_id=None,
track_decrement=None):
config = self.query(one_interface_vlan(vlan_number))
if len(config.xpath(
"data/configuration/interfaces/interface/unit")) < 1:
raise UnknownVlan(vlan_number)
adresses = [
IPNetwork(addr_node.text) for addr_node in config.xpath(
"data/configuration/interfaces/interface/unit/family/inet/address/name"
)
]
parent_address = self._get_address_that_contains_all_ips(adresses, ips)
vrrp_node = to_ele("""
<vrrp-group>
<name>{group_id}</name>
<priority>{priority}</priority>
<preempt>
<hold-time>{preempt_hold_time}</hold-time>
</preempt>
<accept-data/>
<authentication-type>simple</authentication-type>
<authentication-key>{auth}</authentication-key>
<track>
<route>
<route_address>{tracking}</route_address>
<routing-instance>default</routing-instance>
<priority-cost>{tracking_decrement}</priority-cost>
</route>
</track>
</vrrp-group>""".format(vlan_number=vlan_number,
parent_address=parent_address,
group_id=group_id,
vip=ips[0],
preempt_hold_time=PREEMPT_HOLD_TIME,
priority=priority,
auth="VLAN{}".format(vlan_number),
tracking=track_id,
tracking_decrement=track_decrement))
for ip in ips:
vrrp_node.append(
to_ele("<virtual-address>{}</virtual-address>".format(ip)))
update = Update()
update.add_interface(
irb_address_update(vlan_number,
parent_address,
children=[vrrp_node]))
self._push(update)
