mirror of
https://github.com/retspen/webvirtcloud
synced 2026-11-08 11:16:47 +00:00
39933fce7f
On a running network the change did nothing, yet the page said the range was changed; a network without a range or an unknown address family ended in a server error. Each is refused now with the reason: stop the network first, or the network has no such range. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
423 lines
16 KiB
Python
423 lines
16 KiB
Python
from libvirt import (
|
|
VIR_NETWORK_SECTION_IP_DHCP_HOST,
|
|
VIR_NETWORK_UPDATE_AFFECT_CONFIG,
|
|
VIR_NETWORK_UPDATE_AFFECT_LIVE,
|
|
VIR_NETWORK_UPDATE_COMMAND_ADD_LAST,
|
|
VIR_NETWORK_UPDATE_COMMAND_DELETE,
|
|
VIR_NETWORK_UPDATE_COMMAND_MODIFY, libvirtError)
|
|
from lxml import etree
|
|
from vrtManager import util
|
|
import ipaddress
|
|
|
|
from vrtManager.connection import wvmConnect
|
|
|
|
|
|
def network_size(subnet, dhcp=None):
|
|
"""
|
|
Func return gateway, mask and dhcp pool.
|
|
"""
|
|
net = ipaddress.ip_network(subnet, strict=False)
|
|
gateway = str(net.network_address + 1)
|
|
if net.version == 4:
|
|
mask = str(net.netmask)
|
|
dhcp_pool = [str(net.network_address + 2), str(net.broadcast_address - 1)]
|
|
else:
|
|
mask = str(net.prefixlen)
|
|
dhcp_pool = [str(net.network_address + 256), str(net.network_address + 511)]
|
|
|
|
return (gateway, mask, dhcp_pool) if dhcp else (gateway, mask, None)
|
|
|
|
|
|
class wvmNetworks(wvmConnect):
|
|
def get_networks_info(self):
|
|
get_networks = self.get_networks()
|
|
networks = []
|
|
for network in get_networks:
|
|
net = self.get_network(network)
|
|
net_status = net.isActive()
|
|
try:
|
|
net_bridge = net.bridgeName()
|
|
except libvirtError:
|
|
net_bridge = util.get_xml_path(net.XMLDesc(0), "/network/forward/interface/@dev")
|
|
|
|
net_forward = util.get_xml_path(net.XMLDesc(0), "/network/forward/@mode")
|
|
networks.append({
|
|
"name": network,
|
|
"status": net_status,
|
|
"device": net_bridge,
|
|
"forward": net_forward
|
|
})
|
|
|
|
return networks
|
|
|
|
def define_network(self, xml):
|
|
self.wvm.networkDefineXML(xml)
|
|
|
|
def create_network(
|
|
self,
|
|
name,
|
|
forward,
|
|
ipv4,
|
|
gateway,
|
|
mask,
|
|
dhcp4,
|
|
ipv6,
|
|
gateway6,
|
|
prefix6,
|
|
dhcp6,
|
|
bridge,
|
|
openvswitch,
|
|
fixed=False,
|
|
):
|
|
esc_name = util.xml_escape(str(name))
|
|
esc_forward = util.xml_escape(str(forward)) if forward else ""
|
|
esc_bridge = util.xml_escape(str(bridge)) if bridge else ""
|
|
esc_gateway = util.xml_escape(str(gateway)) if gateway else ""
|
|
esc_mask = util.xml_escape(str(mask)) if mask else ""
|
|
esc_gateway6 = util.xml_escape(str(gateway6)) if gateway6 else ""
|
|
esc_prefix6 = util.xml_escape(str(prefix6)) if prefix6 else ""
|
|
|
|
xml = f"""
|
|
<network>
|
|
<name>{esc_name}</name>"""
|
|
if forward in ["nat", "route", "bridge"]:
|
|
xml += f"""<forward mode='{esc_forward}'/>"""
|
|
if forward == "macvtap":
|
|
xml += f"""<forward mode='bridge'>
|
|
<interface dev='{esc_bridge}'/>
|
|
</forward>"""
|
|
else:
|
|
xml += """<bridge """
|
|
if forward in ["nat", "route", "none"]:
|
|
xml += """stp='on' delay='0'"""
|
|
if forward == "bridge":
|
|
xml += f"""name='{esc_bridge}'"""
|
|
xml += """/>"""
|
|
if openvswitch is True:
|
|
xml += """<virtualport type='openvswitch'/>"""
|
|
if forward not in ["bridge", "macvtap"]:
|
|
if ipv4:
|
|
xml += f"""<ip address='{esc_gateway}' netmask='{esc_mask}'>"""
|
|
if dhcp4:
|
|
dhcp4_0 = util.xml_escape(str(dhcp4[0]))
|
|
dhcp4_1 = util.xml_escape(str(dhcp4[1]))
|
|
xml += f"""<dhcp>
|
|
<range start='{dhcp4_0}' end='{dhcp4_1}' />"""
|
|
if fixed:
|
|
fist_oct = int(dhcp4[0].strip().split(".")[3])
|
|
last_oct = int(dhcp4[1].strip().split(".")[3])
|
|
gw_prefix = util.xml_escape(str(gateway)[:-2])
|
|
for ip in range(fist_oct, last_oct + 1):
|
|
xml += f"""<host mac='{util.randomMAC()}' ip='{gw_prefix}.{ip}' />"""
|
|
xml += """</dhcp>"""
|
|
xml += """</ip>"""
|
|
if ipv6:
|
|
xml += f"""<ip family='ipv6' address='{esc_gateway6}' prefix='{esc_prefix6}'>"""
|
|
if dhcp6:
|
|
dhcp6_0 = util.xml_escape(str(dhcp6[0]))
|
|
dhcp6_1 = util.xml_escape(str(dhcp6[1]))
|
|
xml += f"""<dhcp>
|
|
<range start='{dhcp6_0}' end='{dhcp6_1}' />"""
|
|
xml += """</dhcp>"""
|
|
xml += """</ip>"""
|
|
xml += """</network>"""
|
|
self.define_network(xml)
|
|
net = self.get_network(name)
|
|
net.create()
|
|
net.setAutostart(1)
|
|
|
|
|
|
class wvmNetwork(wvmConnect):
|
|
def __init__(self, host, login, passwd, conn, net):
|
|
wvmConnect.__init__(self, host, login, passwd, conn)
|
|
self.leases = None
|
|
self.net = self.get_network(net)
|
|
self.parent_count = len(self.get_ip_networks())
|
|
|
|
def get_name(self):
|
|
return self.net.name()
|
|
|
|
def _XMLDesc(self, flags):
|
|
return self.net.XMLDesc(flags)
|
|
|
|
def get_autostart(self):
|
|
return self.net.autostart()
|
|
|
|
def set_autostart(self, value):
|
|
self.net.setAutostart(value)
|
|
|
|
def is_active(self):
|
|
return self.net.isActive()
|
|
|
|
def get_uuid(self):
|
|
return self.net.UUIDString()
|
|
|
|
def get_bridge_device(self):
|
|
try:
|
|
return self.net.bridgeName()
|
|
except Exception:
|
|
return util.get_xml_path(self._XMLDesc(0), "/network/forward/interface/@dev")
|
|
|
|
def start(self):
|
|
self.net.create()
|
|
|
|
def _vms_on_it(self, running_only):
|
|
name = self.net.name()
|
|
return self.domains_using(
|
|
lambda domain: domain.xpath("devices/interface[@type='network']/source[@network=$name]", name=name),
|
|
running_only,
|
|
)
|
|
|
|
def stop(self):
|
|
"""Refused while a running VM is on it: that VM would be cut off."""
|
|
if vms := self._vms_on_it(running_only=True):
|
|
raise util.OperationError(f"Network {self.net.name()} is in use by the running VMs {', '.join(vms)}; "
|
|
"shut them down or remove their network cards first")
|
|
self.net.destroy()
|
|
|
|
def delete(self):
|
|
"""Refused while a VM's definition names it: that VM would no longer start."""
|
|
if vms := self._vms_on_it(running_only=False):
|
|
raise util.OperationError(f"VMs {', '.join(vms)} use network {self.net.name()} and would no longer "
|
|
"start; remove their network cards first")
|
|
self.net.undefine()
|
|
|
|
def update(self, command, section, xml, parentIndex, flags=0):
|
|
return self.net.update(command, section, parentIndex, xml, flags)
|
|
|
|
def get_ip_networks(self):
|
|
ip_networks = {}
|
|
xml = self._XMLDesc(0)
|
|
if util.get_xml_path(xml, "/network/ip") is None:
|
|
return ip_networks
|
|
tree = etree.fromstring(xml)
|
|
ips = tree.findall(".ip")
|
|
for ip in ips:
|
|
address_str = ip.get("address")
|
|
netmask_str = ip.get("netmask")
|
|
prefix = ip.get("prefix")
|
|
family = ip.get("family", "ipv4")
|
|
mask = prefix if prefix is not None else netmask_str
|
|
if address_str and mask:
|
|
ret = ipaddress.ip_network(f"{address_str}/{mask}", strict=False)
|
|
elif address_str:
|
|
ret = ipaddress.ip_address(address_str)
|
|
else:
|
|
continue
|
|
ip_networks[family] = ret
|
|
return ip_networks
|
|
|
|
def get_network_mac(self):
|
|
xml = self._XMLDesc(0)
|
|
return util.get_xml_path(xml, "/network/mac/@address")
|
|
|
|
def get_network_forward(self):
|
|
xml = self._XMLDesc(0)
|
|
fw = util.get_xml_path(xml, "/network/forward/@mode")
|
|
forward_dev = util.get_xml_path(xml, "/network/forward/@dev")
|
|
return [fw, forward_dev]
|
|
|
|
def get_dhcp_range(self, family="ipv4"):
|
|
xml = self._XMLDesc(0)
|
|
if family == "ipv4":
|
|
dhcpstart = util.get_xml_path(xml, "/network/ip[not(@family='ipv6')]/dhcp/range[1]/@start")
|
|
dhcpend = util.get_xml_path(xml, "/network/ip[not(@family='ipv6')]/dhcp/range[1]/@end")
|
|
if family == "ipv6":
|
|
dhcpstart = util.get_xml_path(xml, "/network/ip[@family='ipv6']/dhcp/range[1]/@start")
|
|
dhcpend = util.get_xml_path(xml, "/network/ip[@family='ipv6']/dhcp/range[1]/@end")
|
|
|
|
return None if not dhcpstart or not dhcpend else [ipaddress.ip_address(dhcpstart), ipaddress.ip_address(dhcpend)]
|
|
|
|
def get_dhcp_range_start(self, family="ipv4"):
|
|
dhcp = self.get_dhcp_range(family)
|
|
return dhcp[0] if dhcp else None
|
|
|
|
def get_dhcp_range_end(self, family="ipv4"):
|
|
dhcp = self.get_dhcp_range(family)
|
|
return dhcp[1] if dhcp else None
|
|
|
|
def can_pxe(self):
|
|
xml = self._XMLDesc(0)
|
|
forward = self.get_network_forward()[0]
|
|
if forward and forward != "nat":
|
|
return True
|
|
return bool(util.get_xml_path(xml, "/network/ip/dhcp/bootp/@file"))
|
|
|
|
def get_dhcp_host_addr(self, family="ipv4"):
|
|
result = []
|
|
tree = etree.fromstring(self._XMLDesc(0))
|
|
for ipdhcp in tree.findall("./ip"):
|
|
if family == "ipv4":
|
|
if ipdhcp.get("family") is not None:
|
|
continue
|
|
hosts = ipdhcp.findall("./dhcp/host")
|
|
for host in hosts:
|
|
host_ip = host.get("ip")
|
|
mac = host.get("mac")
|
|
name = host.get("name", "")
|
|
result.append({"ip": host_ip, "mac": mac, "name": name})
|
|
return result
|
|
if family == "ipv6":
|
|
hosts = tree.xpath("./ip[@family='ipv6']/dhcp/host")
|
|
for host in hosts:
|
|
host_ip = host.get("ip")
|
|
host_id = host.get("id")
|
|
name = host.get("name", "")
|
|
result.append({"ip": host_ip, "id": host_id, "name": name})
|
|
return result
|
|
|
|
def modify_dhcp_range(self, range_start, range_end, family="ipv4"):
|
|
"""Refused while the network runs: the running network would keep the old range."""
|
|
if self.is_active():
|
|
raise util.OperationError(f"Stop network {self.net.name()} to change its DHCP range")
|
|
tree = etree.fromstring(self._XMLDesc(0))
|
|
ip = {"ipv4": "ip[not(@family='ipv6')]", "ipv6": "ip[@family='ipv6']"}.get(family)
|
|
dhcp_range = tree.xpath(f"{ip}/dhcp/range") if ip else []
|
|
if not dhcp_range:
|
|
raise util.OperationError(f"Network {self.net.name()} has no {family} DHCP range")
|
|
dhcp_range[0].set("start", range_start)
|
|
dhcp_range[0].set("end", range_end)
|
|
self.wvm.networkDefineXML(etree.tostring(tree).decode())
|
|
|
|
def delete_fixed_address(self, ip, family="ipv4"):
|
|
tree = etree.fromstring(self._XMLDesc(0))
|
|
if family == "ipv4":
|
|
hosts = tree.xpath("/network/ip[not(@family='ipv6')]/dhcp/host")
|
|
parent_index = self.parent_count - 2
|
|
if family == "ipv6":
|
|
hosts = tree.xpath("/network/ip[@family='ipv6']/dhcp/host")
|
|
parent_index = self.parent_count - 1
|
|
for h in hosts:
|
|
if h.get("ip") == ip:
|
|
h_name = util.xml_escape(h.get("name") or "")
|
|
name_attr = f' name="{h_name}"' if h.get("name") else ""
|
|
ip_esc = util.xml_escape(ip)
|
|
if family == "ipv4":
|
|
h_mac = util.xml_escape(h.get("mac") or "")
|
|
new_xml = f'<host mac="{h_mac}"{name_attr} ip="{ip_esc}"/>'
|
|
if family == "ipv6":
|
|
h_id = util.xml_escape(h.get("id") or "")
|
|
new_xml = f'<host id="{h_id}"{name_attr} ip="{ip_esc}"/>'
|
|
|
|
self.update(
|
|
VIR_NETWORK_UPDATE_COMMAND_DELETE,
|
|
VIR_NETWORK_SECTION_IP_DHCP_HOST,
|
|
new_xml,
|
|
parent_index,
|
|
VIR_NETWORK_UPDATE_AFFECT_LIVE | VIR_NETWORK_UPDATE_AFFECT_CONFIG,
|
|
)
|
|
break
|
|
|
|
def modify_fixed_address(self, name, address, mac_duid, family="ipv4"):
|
|
tree = etree.fromstring(self._XMLDesc(0))
|
|
name_esc = util.xml_escape(name) if name else ""
|
|
name_attr = f' name="{name_esc}"' if name else ""
|
|
mac_esc = util.xml_escape(mac_duid)
|
|
ip_addr = ipaddress.ip_address(address)
|
|
if family == "ipv4":
|
|
new_xml = f'<host mac="{mac_esc}"{name_attr} ip="{ip_addr}"/>'
|
|
hosts = tree.xpath("./ip[not(@family='ipv6')]/dhcp/host")
|
|
compare_var = "mac"
|
|
parent_index = self.parent_count - 2
|
|
if family == "ipv6":
|
|
new_xml = f'<host id="{mac_esc}"{name_attr} ip="{ip_addr}"/>'
|
|
hosts = tree.xpath("./ip[@family='ipv6']/dhcp/host")
|
|
compare_var = "id"
|
|
parent_index = self.parent_count - 1
|
|
new_host_xml = etree.fromstring(new_xml)
|
|
host = next((h for h in hosts if h.get(compare_var) == mac_duid), None)
|
|
if host is None:
|
|
self.update(
|
|
VIR_NETWORK_UPDATE_COMMAND_ADD_LAST,
|
|
VIR_NETWORK_SECTION_IP_DHCP_HOST,
|
|
new_xml,
|
|
parent_index,
|
|
VIR_NETWORK_UPDATE_AFFECT_LIVE | VIR_NETWORK_UPDATE_AFFECT_CONFIG,
|
|
)
|
|
else:
|
|
# change the host
|
|
if host.get("name") == new_host_xml.get("name") and host.get("ip") == new_host_xml.get("ip"):
|
|
return False
|
|
else:
|
|
self.update(
|
|
VIR_NETWORK_UPDATE_COMMAND_MODIFY,
|
|
VIR_NETWORK_SECTION_IP_DHCP_HOST,
|
|
new_xml,
|
|
parent_index,
|
|
VIR_NETWORK_UPDATE_AFFECT_LIVE | VIR_NETWORK_UPDATE_AFFECT_CONFIG,
|
|
)
|
|
|
|
def get_qos(self):
|
|
qos_values = {}
|
|
tree = etree.fromstring(self._XMLDesc(0))
|
|
qos = tree.xpath("/network/bandwidth")
|
|
if qos:
|
|
qos = qos[0]
|
|
|
|
in_qos = qos.find("inbound")
|
|
if in_qos is not None:
|
|
in_av = in_qos.get("average")
|
|
in_peak = in_qos.get("peak")
|
|
in_burst = in_qos.get("burst")
|
|
qos_values["inbound"] = {"average": in_av, "peak": in_peak, "burst": in_burst}
|
|
|
|
out_qos = qos.find("outbound")
|
|
if out_qos is not None:
|
|
out_av = out_qos.get("average")
|
|
out_peak = out_qos.get("peak")
|
|
out_burst = out_qos.get("burst")
|
|
qos_values["outbound"] = {"average": out_av, "peak": out_peak, "burst": out_burst}
|
|
return qos_values
|
|
|
|
def set_qos(self, direction, average, peak, burst):
|
|
if direction not in ("inbound", "outbound"):
|
|
raise ValueError("Direction must be inbound or outbound")
|
|
|
|
try:
|
|
average, peak, burst = int(average), int(peak), int(burst)
|
|
except ValueError:
|
|
raise ValueError("QoS rates must be whole numbers")
|
|
|
|
xml = f"<{direction} average='{average}' peak='{peak}' burst='{burst}'/>"
|
|
tree = etree.fromstring(self._XMLDesc(0))
|
|
|
|
band = tree.xpath("/network/bandwidth")
|
|
if len(band) == 0:
|
|
xml = f"<bandwidth>{xml}</bandwidth>"
|
|
tree.append(etree.fromstring(xml))
|
|
else:
|
|
direct = band[0].find(direction)
|
|
if direct is not None:
|
|
parent = direct.getparent()
|
|
parent.remove(direct)
|
|
parent.append(etree.fromstring(xml))
|
|
else:
|
|
band[0].append(etree.fromstring(xml))
|
|
new_xml = etree.tostring(tree).decode()
|
|
self.wvm.networkDefineXML(new_xml)
|
|
|
|
def unset_qos(self, direction):
|
|
# direction goes into the XPath below
|
|
if direction not in ("inbound", "outbound"):
|
|
raise ValueError("Direction must be inbound or outbound")
|
|
tree = etree.fromstring(self._XMLDesc(0))
|
|
for direct in tree.xpath(f"/network/bandwidth/{direction}"):
|
|
parent = direct.getparent()
|
|
parent.remove(direct)
|
|
|
|
self.wvm.networkDefineXML(etree.tostring(tree).decode())
|
|
|
|
def edit_network(self, new_xml):
|
|
self.wvm.networkDefineXML(new_xml)
|
|
|
|
def refresh_dhcp_leases(self):
|
|
try:
|
|
self.leases = self.net.DHCPLeases()
|
|
except Exception as e:
|
|
self.leases = []
|
|
raise util.OperationError(f"Error getting {self} DHCP leases: {e}") from e
|
|
|
|
def get_dhcp_leases(self):
|
|
if self.leases is None:
|
|
self.refresh_dhcp_leases()
|
|
return self.leases
|