shaba/virt-manager
1
0
Fork 0
mirror of https://github.com/virt-manager/virt-manager.git synced 2024-10-28 19:55:29 +03:00
Code Issues Projects Releases Wiki Activity
534e613d40
virt-manager/virtManager/createnet.py
Cole Robinson 5e9e444dec connection: Do non-VM polling on demand 
The goal here is to reduce the amount of tick() polling that we do by default.
For things like pools, networks, and interfaces, the constant polling is
not very helpful and causes CPU churn and slowness for remote connections.

Switch to a more on demand style. Pages that want new information for
these objects now request a priority tick that only refreshes the info
we want.

This isn't perfect, but neither was the previous solution in the face of
things like XML updates behind our back. The real solution here is libvirt
event support across the board.
2013-07-07 12:17:54 -04:00

1222 lines
47 KiB
Python
Raw Blame History

#
# Copyright (C) 2006-2007, 2013 Red Hat, Inc.
# Copyright (C) 2006 Hugh O. Brock <hbrock@redhat.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301 USA.
#
import logging
import re
import ipaddr
# pylint: disable=E0611
from gi.repository import Gtk
from gi.repository import Gdk
# pylint: enable=E0611
from virtManager.network import vmmNetwork
from virtManager.baseclass import vmmGObjectUI
PAGE_INTRO = 0
PAGE_NAME = 1
PAGE_IPV4 = 2
PAGE_IPV6 = 3
PAGE_MISC = 4
PAGE_SUMMARY = 5
class vmmCreateNetwork(vmmGObjectUI):
def __init__(self, conn):
vmmGObjectUI.__init__(self, "vmm-create-net.ui", "vmm-create-net")
self.conn = conn
self.builder.connect_signals({
"on_create_pages_switch_page" : self.page_changed,
"on_create_cancel_clicked" : self.close,
"on_vmm_create_delete_event" : self.close,
"on_create_forward_clicked" : self.forward,
"on_create_back_clicked" : self.back,
"on_create_finish_clicked" : self.finish,
"on_net_name_activate": self.forward,
"on_net_forward_toggled" : self.change_forward_type,
"on_net-ipv4-enable_toggled" : self.change_ipv4_enable,
"on_net-ipv4-network_changed": self.change_ipv4_network,
"on_net-dhcpv4-enable_toggled": self.change_dhcpv4_enable,
"on_net-dhcpv4-start_changed": self.change_dhcpv4_start,
"on_net-dhcpv4-end_changed": self.change_dhcpv4_end,
"on_net-ipv6-enable_toggled" : self.change_ipv6_enable,
"on_net-ipv6-network_changed": self.change_ipv6_network,
"on_net-dhcpv6-enable_toggled": self.change_dhcpv6_enable,
"on_net-dhcpv6-start_changed": self.change_dhcpv6_start,
"on_net-dhcpv6-end_changed": self.change_dhcpv6_end,
"on_net-routev4-enable_toggled": self.change_routev4_enable,
"on_net-routev4-network_changed": self.change_routev4_network,
"on_net-routev4-gateway_changed": self.change_routev4_gateway,
"on_net-routev6-enable_toggled": self.change_routev6_enable,
"on_net-routev6-network_changed": self.change_routev6_network,
"on_net-routev6-gateway_changed": self.change_routev6_gateway,
})
self.bind_escape_key_close()
finish_img = Gtk.Image.new_from_stock(Gtk.STOCK_QUIT,
Gtk.IconSize.BUTTON)
self.widget("create-finish").set_image(finish_img)
self.set_initial_state()
def show(self, parent):
logging.debug("Showing new network wizard")
self.reset_state()
self.topwin.set_transient_for(parent)
self.topwin.present()
def is_visible(self):
return self.topwin.get_visible()
def close(self, ignore1=None, ignore2=None):
logging.debug("Closing new network wizard")
self.topwin.hide()
return 1
def _cleanup(self):
self.conn = None
def set_initial_state(self):
notebook = self.widget("create-pages")
notebook.set_show_tabs(False)
black = Gdk.Color.parse("#000")[1]
for num in range(PAGE_SUMMARY + 1):
name = "page" + str(num) + "-title"
self.widget(name).modify_bg(Gtk.StateType.NORMAL, black)
fw_list = self.widget("net-forward")
# [ label, dev name ]
fw_model = Gtk.ListStore(str, str)
fw_list.set_model(fw_model)
text = Gtk.CellRendererText()
fw_list.pack_start(text, True)
fw_list.add_attribute(text, 'text', 0)
fw_model.append([_("Any physical device"), None])
for path in self.conn.list_net_device_paths():
net = self.conn.get_net_device(path)
fw_model.append([_("Physical device %s") % (net.get_name()),
net.get_name()])
mode_list = self.widget("net-forward-mode")
# [ label, mode ]
mode_model = Gtk.ListStore(str, str)
mode_list.set_model(mode_model)
text = Gtk.CellRendererText()
mode_list.pack_start(text, True)
mode_list.add_attribute(text, 'text', 0)
mode_model.append([_("NAT"), "nat"])
mode_model.append([_("Routed"), "route"])
def reset_state(self):
notebook = self.widget("create-pages")
notebook.set_current_page(0)
self.page_changed(None, None, 0)
self.widget("net-name").set_text("")
self.widget("net-name").set_sensitive(True)
self.widget("net-domain-name").set_text("")
self.widget("net-domain-name").set_sensitive(True)
self.widget("net-ipv4-enable").set_active(True)
self.widget("net-ipv4-network").set_text("192.168.100.0/24")
self.widget("net-ipv4-network").set_sensitive(True)
self.widget("net-dhcpv4-enable").set_active(True)
self.widget("net-dhcpv4-start").set_text("192.168.100.128")
self.widget("net-dhcpv4-end").set_text("192.168.100.254")
self.widget("net-dhcpv4-start").set_sensitive(True)
self.widget("net-dhcpv4-end").set_sensitive(True)
self.widget("net-ipv6-enable").set_active(False)
self.widget("net-ipv6-network").set_text("")
self.widget("net-ipv6-network").set_sensitive(True)
self.widget("net-dhcpv6-enable").set_active(False)
self.widget("net-dhcpv6-start").set_text("")
self.widget("net-dhcpv6-end").set_text("")
self.widget("net-forward-none").set_active(True)
self.widget("net-forward").set_active(0)
self.widget("net-forward-mode").set_active(0)
self.widget("net-enable-ipv6-networking").set_active(False)
def forward(self, ignore=None):
notebook = self.widget("create-pages")
if self.validate(notebook.get_current_page()) is not True:
return
self.widget("create-forward").grab_focus()
notebook.next_page()
def back(self, ignore=None):
notebook = self.widget("create-pages")
notebook.prev_page()
def change_ipv4_enable(self, ignore):
white = Gdk.Color.parse("#f0f0f0")[1]
net = self.widget("net-ipv4-network")
start = self.widget("net-dhcpv4-start")
end = self.widget("net-dhcpv4-end")
network = self.widget("net-routev4-network")
gateway = self.widget("net-routev4-gateway")
if self.get_config_ipv4_enable():
net.set_sensitive(True)
net.set_text("")
net.modify_bg(Gtk.StateType.NORMAL, white)
if self.get_config_dhcpv4_enable():
start.set_sensitive(True)
end.set_sensitive(True)
if self.get_config_routev4_enable():
network.set_sensitive(True)
gateway.set_sensitive(True)
else:
net.set_text("")
start.set_text("")
end.set_text("")
network.set_text("")
gateway.set_text("")
net.set_sensitive(False)
start.set_sensitive(False)
end.set_sensitive(False)
network.set_sensitive(False)
gateway.set_sensitive(False)
net.modify_bg(Gtk.StateType.NORMAL, white)
start.modify_bg(Gtk.StateType.NORMAL, white)
end.modify_bg(Gtk.StateType.NORMAL, white)
network.modify_bg(Gtk.StateType.NORMAL, white)
gateway.modify_bg(Gtk.StateType.NORMAL, white)
def change_ipv6_enable(self, ignore):
white = Gdk.Color.parse("#f0f0f0")[1]
net = self.widget("net-ipv6-network")
start = self.widget("net-dhcpv6-start")
end = self.widget("net-dhcpv6-end")
network = self.widget("net-routev6-network")
gateway = self.widget("net-routev6-gateway")
if self.get_config_ipv6_enable():
net.set_sensitive(True)
net.set_text("")
net.modify_bg(Gtk.StateType.NORMAL, white)
if self.get_config_dhcpv6_enable():
start.set_sensitive(True)
end.set_sensitive(True)
if self.get_config_routev6_enable():
network.set_sensitive(True)
gateway.set_sensitive(True)
else:
net.set_text("")
start.set_text("")
end.set_text("")
network.set_text("")
gateway.set_text("")
net.set_sensitive(False)
start.set_sensitive(False)
end.set_sensitive(False)
network.set_sensitive(False)
gateway.set_sensitive(False)
net.modify_bg(Gtk.StateType.NORMAL, white)
start.modify_bg(Gtk.StateType.NORMAL, white)
end.modify_bg(Gtk.StateType.NORMAL, white)
network.modify_bg(Gtk.StateType.NORMAL, white)
gateway.modify_bg(Gtk.StateType.NORMAL, white)
def change_ipv4_network(self, src):
ip = self.get_config_ip4()
green = Gdk.Color.parse("#c0ffc0")[1]
red = Gdk.Color.parse("#ffc0c0")[1]
black = Gdk.Color.parse("#000000")[1]
src.modify_text(Gtk.StateType.NORMAL, black)
# No IP specified or invalid IP
if ip is None or ip.version != 4:
src.modify_bg(Gtk.StateType.NORMAL, red)
self.widget("net-info-gateway").set_text("")
self.widget("net-info-type").set_text("")
self.widget("net-dhcpv4-start").set_text("")
self.widget("net-dhcpv4-end").set_text("")
self.widget("net-routev4-network").set_text("")
self.widget("net-routev4-gateway").set_text("")
return
# We've got a valid IP
if ip.numhosts < 16 or not ip.is_private:
src.modify_bg(Gtk.StateType.NORMAL, red)
else:
src.modify_bg(Gtk.StateType.NORMAL, green)
if ip.prefixlen == 32:
self.widget("net-info-gateway").set_text("")
else:
self.widget("net-info-gateway").set_text(str(ip.network + 1))
if ip.is_private:
self.widget("net-info-type").set_text(_("Private"))
else:
self.widget("net-info-type").set_text(_("Other/Public"))
if self.get_config_dhcpv4_enable():
self.widget("net-dhcpv4-start").set_sensitive(True)
self.widget("net-dhcpv4-end").set_sensitive(True)
start = int(ip.numhosts / 2)
end = int(ip.numhosts - 2)
self.widget("net-dhcpv4-start").set_text(str(ip.network + start))
self.widget("net-dhcpv4-end").set_text(str(ip.network + end))
else:
self.widget("net-dhcpv4-start").set_sensitive(False)
self.widget("net-dhcpv4-end").set_sensitive(False)
if self.get_config_routev4_enable():
self.widget("net-routev4-network").set_sensitive(True)
self.widget("net-routev4-gateway").set_sensitive(True)
else:
self.widget("net-routev4-network").set_sensitive(False)
self.widget("net-routev4-gateway").set_sensitive(False)
def change_ipv6_network(self, src):
ip = self.get_config_ip6()
green = Gdk.Color.parse("#c0ffc0")[1]
red = Gdk.Color.parse("#ffc0c0")[1]
black = Gdk.Color.parse("#000000")[1]
src.modify_text(Gtk.StateType.NORMAL, black)
# No IP specified or invalid IP
if ip is None or ip.version != 6:
src.modify_bg(Gtk.StateType.NORMAL, red)
self.widget("net-info-gateway-ip6").set_text("")
self.widget("net-info-type-ip6").set_text("")
self.widget("net-dhcpv6-start").set_text("")
self.widget("net-dhcpv6-end").set_text("")
self.widget("net-routev6-network").set_text("")
self.widget("net-routev6-gateway").set_text("")
return
color = green
if not ip.is_private:
color = red
if ip.prefixlen != 64:
color = red
src.modify_bg(Gtk.StateType.NORMAL, color)
if ip.prefixlen != 64:
self.widget("net-info-gateway-ip6").set_text("")
else:
self.widget("net-info-gateway-ip6").set_text(str(ip.network + 1))
if ip.is_private:
self.widget("net-info-type-ip6").set_text(_("Private"))
elif ip.is_reserved:
self.widget("net-info-type-ip6").set_text(_("Reserved"))
elif ip.is_unspecified:
self.widget("net-info-type-ip6").set_text(_("Unspecified"))
else:
self.widget("net-info-type-ip6").set_text(_("Other/Public"))
if self.get_config_dhcpv6_enable():
self.widget("net-dhcpv6-start").set_sensitive(True)
self.widget("net-dhcpv6-end").set_sensitive(True)
start = 256
end = 512 - 1
self.widget("net-dhcpv6-start").set_text(str(ip.network + start))
self.widget("net-dhcpv6-end").set_text(str(ip.network + end))
else:
self.widget("net-dhcpv6-start").set_sensitive(False)
self.widget("net-dhcpv6-end").set_sensitive(False)
if self.get_config_routev6_enable():
self.widget("net-routev6-network").set_sensitive(True)
self.widget("net-routev6-gateway").set_sensitive(True)
else:
self.widget("net-routev6-network").set_sensitive(False)
self.widget("net-routev6-gateway").set_sensitive(False)
def change_routev4_enable(self, ignore):
white = Gdk.Color.parse("#f0f0f0")[1]
ntwk = self.widget("net-routev4-network")
gway = self.widget("net-routev4-gateway")
ntwk.modify_bg(Gtk.StateType.NORMAL, white)
gway.modify_bg(Gtk.StateType.NORMAL, white)
ntwk.set_text("")
gway.set_text("")
if self.get_config_routev4_enable():
ntwk.set_sensitive(True)
gway.set_sensitive(True)
else:
ntwk.set_sensitive(False)
gway.set_sensitive(False)
def get_config_routev4_network(self):
if not self.get_config_routev4_enable():
return None
return self.widget("net-routev4-network").get_text()
def get_config_routev4_gateway(self):
if not self.get_config_routev4_enable():
return None
return self.widget("net-routev4-gateway").get_text()
def get_route_addr(self, addrStr):
if addrStr is None:
return None
try:
addr = ipaddr.IPNetwork(addrStr)
except:
addr = None
return addr
def change_routev4_network(self, src):
ntwk = self.get_config_routev4_network()
ipAddr = self.get_config_ip4()
black = Gdk.Color.parse("#000000")[1]
src.modify_text(Gtk.StateType.NORMAL, black)
if ipAddr is None or ntwk is None:
white = Gdk.Color.parse("#f0f0f0")[1]
src.modify_bg(Gtk.StateType.NORMAL, white)
return
addr = self.get_route_addr(ntwk)
red = Gdk.Color.parse("#ffc0c0")[1]
green = Gdk.Color.parse("#c0ffc0")[1]
color = green
if addr is None:
color = red
else:
if addr.version != 4:
color = red
if addr.prefixlen > 28:
color = red
src.modify_bg(Gtk.StateType.NORMAL, color)
def change_routev4_gateway(self, src):
gway = self.get_config_routev4_gateway()
ipAddr = self.get_config_ip4()
black = Gdk.Color.parse("#000000")[1]
src.modify_text(Gtk.StateType.NORMAL, black)
if ipAddr is None or gway is None:
white = Gdk.Color.parse("#f0f0f0")[1]
src.modify_bg(Gtk.StateType.NORMAL, white)
return
addr = self.get_route_addr(gway)
red = Gdk.Color.parse("#ffc0c0")[1]
green = Gdk.Color.parse("#c0ffc0")[1]
color = green
if addr is None:
color = red
else:
if addr.version != 4:
color = red
if not ipAddr.overlaps(addr):
color = red
if addr.prefixlen != 32:
color = red
src.modify_bg(Gtk.StateType.NORMAL, color)
def change_dhcpv4_enable(self, ignore):
white = Gdk.Color.parse("#f0f0f0")[1]
start = self.widget("net-dhcpv4-start")
end = self.widget("net-dhcpv4-end")
start.modify_bg(Gtk.StateType.NORMAL, white)
end.modify_bg(Gtk.StateType.NORMAL, white)
start.set_text("")
end.set_text("")
if not self.get_config_dhcpv4_enable():
start.set_sensitive(False)
end.set_sensitive(False)
else:
start.set_sensitive(True)
end.set_sensitive(True)
ip = self.get_config_ip4()
if ip:
start.set_text(str(ip.network + int(ip.numhosts / 2)))
end.set_text(str(ip.network + int(ip.numhosts - 2)))
def change_dhcpv4_start(self, src):
start = self.get_config_dhcpv4_start()
self.change_dhcpv4(src, start)
def change_dhcpv4_end(self, src):
end = self.get_config_dhcpv4_end()
self.change_dhcpv4(src, end)
def change_dhcpv4(self, src, addr):
ip = self.get_config_ip4()
black = Gdk.Color.parse("#000000")[1]
src.modify_text(Gtk.StateType.NORMAL, black)
if ip is None or addr is None:
white = Gdk.Color.parse("#f0f0f0")[1]
src.modify_bg(Gtk.StateType.NORMAL, white)
return
if addr.version != 4 or not ip.overlaps(addr):
red = Gdk.Color.parse("#ffc0c0")[1]
src.modify_bg(Gtk.StateType.NORMAL, red)
else:
green = Gdk.Color.parse("#c0ffc0")[1]
src.modify_bg(Gtk.StateType.NORMAL, green)
def change_routev6_enable(self, ignore):
white = Gdk.Color.parse("#f0f0f0")[1]
ntwk = self.widget("net-routev6-network")
gway = self.widget("net-routev6-gateway")
ntwk.modify_bg(Gtk.StateType.NORMAL, white)
gway.modify_bg(Gtk.StateType.NORMAL, white)
ntwk.set_text("")
gway.set_text("")
if self.get_config_routev6_enable():
ntwk.set_sensitive(True)
gway.set_sensitive(True)
else:
ntwk.set_sensitive(False)
gway.set_sensitive(False)
def get_config_routev6_network(self):
if not self.get_config_routev6_enable():
return None
return self.widget("net-routev6-network").get_text()
def get_config_routev6_gateway(self):
if not self.get_config_routev6_enable():
return None
return self.widget("net-routev6-gateway").get_text()
def change_routev6_network(self, src):
ntwk = self.get_config_routev6_network()
ip = self.get_config_ip6()
black = Gdk.Color.parse("#000000")[1]
src.modify_text(Gtk.StateType.NORMAL, black)
if ip is None or ntwk is None:
white = Gdk.Color.parse("#f0f0f0")[1]
src.modify_bg(Gtk.StateType.NORMAL, white)
return
addr = self.get_route_addr(ntwk)
red = Gdk.Color.parse("#ffc0c0")[1]
green = Gdk.Color.parse("#c0ffc0")[1]
color = green
if addr is None:
color = red
else:
if addr.version != 6:
color = red
if addr.prefixlen > 64:
color = red
src.modify_bg(Gtk.StateType.NORMAL, color)
def change_routev6_gateway(self, src):
gway = self.get_config_routev6_gateway()
ip = self.get_config_ip6()
black = Gdk.Color.parse("#000000")[1]
src.modify_text(Gtk.StateType.NORMAL, black)
if ip is None or gway is None:
white = Gdk.Color.parse("#f0f0f0")[1]
src.modify_bg(Gtk.StateType.NORMAL, white)
return
addr = self.get_route_addr(gway)
red = Gdk.Color.parse("#ffc0c0")[1]
green = Gdk.Color.parse("#c0ffc0")[1]
color = green
if addr is None:
color = red
else:
if addr.version != 6:
color = red
if not ip.overlaps(addr):
color = red
if addr.prefixlen != 128:
color = red
src.modify_bg(Gtk.StateType.NORMAL, color)
def change_dhcpv6_enable(self, ignore):
white = Gdk.Color.parse("#f0f0f0")[1]
start = self.widget("net-dhcpv6-start")
end = self.widget("net-dhcpv6-end")
start.modify_bg(Gtk.StateType.NORMAL, white)
end.modify_bg(Gtk.StateType.NORMAL, white)
start.set_text("")
end.set_text("")
if not self.get_config_dhcpv6_enable():
start.set_sensitive(False)
end.set_sensitive(False)
else:
start.set_sensitive(True)
end.set_sensitive(True)
ip = self.get_config_ip6()
if ip:
start.set_text(str(ip.network + 256))
end.set_text(str(ip.network + 511))
def change_dhcpv6_start(self, src):
start = self.get_config_dhcpv6_start()
self.change_dhcpv6(src, start)
def change_dhcpv6_end(self, src):
end = self.get_config_dhcpv6_end()
self.change_dhcpv6(src, end)
def change_dhcpv6(self, src, addr):
ip = self.get_config_ip6()
black = Gdk.Color.parse("#000000")[1]
src.modify_text(Gtk.StateType.NORMAL, black)
if ip is None or addr is None:
white = Gdk.Color.parse("#f0f0f0")[1]
src.modify_bg(Gtk.StateType.NORMAL, white)
return
if addr.version != 6 or not ip.overlaps(addr):
red = Gdk.Color.parse("#ffc0c0")[1]
src.modify_bg(Gtk.StateType.NORMAL, red)
else:
green = Gdk.Color.parse("#c0ffc0")[1]
src.modify_bg(Gtk.StateType.NORMAL, green)
def change_forward_type(self, ignore):
skip_fwd = self.widget("net-forward-none").get_active()
self.widget("net-forward-mode").set_sensitive(not skip_fwd)
self.widget("net-forward").set_sensitive(not skip_fwd)
def get_config_name(self):
return self.widget("net-name").get_text()
def get_config_domain_name(self):
return self.widget("net-domain-name").get_text()
def get_config_ip4(self):
if not self.get_config_ipv4_enable():
return None
try:
return ipaddr.IPNetwork(self.widget("net-ipv4-network").get_text())
except:
return None
def get_config_dhcpv4_start(self):
try:
return ipaddr.IPNetwork(self.widget("net-dhcpv4-start").get_text())
except:
return None
def get_config_dhcpv4_end(self):
try:
return ipaddr.IPNetwork(self.widget("net-dhcpv4-end").get_text())
except:
return None
def get_config_ip6(self):
if not self.get_config_ipv6_enable():
return None
try:
return ipaddr.IPNetwork(self.widget("net-ipv6-network").get_text())
except:
return None
def get_config_dhcpv6_start(self):
try:
return ipaddr.IPNetwork(self.widget("net-dhcpv6-start").get_text())
except:
return None
def get_config_dhcpv6_end(self):
try:
return ipaddr.IPNetwork(self.widget("net-dhcpv6-end").get_text())
except:
return None
def get_config_forwarding(self):
if self.widget("net-forward-none").get_active():
return [None, None]
else:
dev = self.widget("net-forward")
model = dev.get_model()
active = dev.get_active()
name = model[active][1]
mode_w = self.widget("net-forward-mode")
mode = mode_w.get_model()[mode_w.get_active()][1]
return [name, mode]
def get_config_ipv4_enable(self):
return self.widget("net-ipv4-enable").get_active()
def get_config_ipv6_enable(self):
return self.widget("net-ipv6-enable").get_active()
def get_config_dhcpv4_enable(self):
return self.widget("net-dhcpv4-enable").get_active()
def get_config_dhcpv6_enable(self):
return self.widget("net-dhcpv6-enable").get_active()
def get_config_routev4_enable(self):
return self.widget("net-routev4-enable").get_active()
def get_config_routev6_enable(self):
return self.widget("net-routev6-enable").get_active()
def populate_summary(self):
self.widget("summary-name").set_text(self.get_config_name())
self.widget("summary-domain").set_text(self.get_config_domain_name())
self.widget("summary-ip4-network").set_text("")
self.widget("summary-ip4-gateway").set_text("")
self.widget("summary-ip6-network").set_text("")
self.widget("summary-ip6-gateway").set_text("")
ip = self.get_config_ip4()
if ip:
self.widget("label-ip4-gateway").show()
self.widget("summary-ip4-gateway").show()
self.widget("label-ip4-network").set_text(_("Network Address / prefix:"))
self.widget("summary-ip4-network").set_text(str(ip))
self.widget("summary-ip4-gateway").set_text(str(ip.network + 1))
else:
self.widget("label-ip4-gateway").hide()
self.widget("summary-ip4-gateway").hide()
self.widget("label-ip4-network").set_text("IPv4 Network:")
self.widget("summary-ip4-network").set_text("Not Defined")
if ip and self.get_config_dhcpv4_enable():
self.widget("label-dhcp-end").show()
self.widget("summary-dhcp-end").show()
start = self.get_config_dhcpv4_start()
end = self.get_config_dhcpv4_end()
self.widget("label-dhcp-start").set_text("DHCPv4 Start Address:")
if start and end:
self.widget("summary-dhcp-start").set_text(str(start.network))
self.widget("summary-dhcp-end").set_text(str(end.network))
else:
self.widget("summary-dhcp-start").set_text("?")
self.widget("summary-dhcp-end").set_text("?")
else:
self.widget("label-dhcp-end").hide()
self.widget("summary-dhcp-end").hide()
self.widget("label-dhcp-start").set_text(_("DHCPv4 Status:"))
self.widget("summary-dhcp-start").set_text(_("Disabled"))
if ip and self.get_config_routev4_enable():
self.widget("label-routev4-network").show()
self.widget("label-routev4-gateway").show()
self.widget("summary-routev4-network").show()
self.widget("summary-routev4-gateway").show()
self.widget("summary-routev4-network").set_text("")
self.widget("summary-routev4-gateway").set_text("")
ntwk = self.get_config_routev4_network()
try:
naddr = ipaddr.IPNetwork(ntwk)
except:
naddr = None
gway = self.get_config_routev4_gateway()
try:
gaddr = ipaddr.IPNetwork(gway)
except:
gaddr = None
if naddr and gaddr:
self.widget("summary-routev4-network").set_text(str(naddr))
self.widget("summary-routev4-gateway").set_text(str(gaddr.network))
else:
self.widget("label-routev4-network").hide()
self.widget("label-routev4-gateway").hide()
self.widget("summary-routev4-network").hide()
self.widget("summary-routev4-gateway").hide()
forward_txt = ""
dev, mode = self.get_config_forwarding()
forward_txt = vmmNetwork.pretty_desc(mode, dev)
self.widget("summary-ipv4-forwarding").set_text(forward_txt)
ip = self.get_config_ip6()
if ip:
self.widget("label-ip6-gateway").show()
self.widget("summary-ip6-gateway").show()
self.widget("label-ip6-network").set_text(_("Network Address / prefix:"))
self.widget("summary-ip6-network").set_text(str(ip))
self.widget("summary-ip6-gateway").set_text(str(ip.network + 1))
else:
self.widget("label-ip6-gateway").hide()
self.widget("summary-ip6-gateway").hide()
self.widget("label-ip6-network").set_text(_("IPV6 Network:"))
self.widget("summary-ip6-network").set_text(_("Not Defined"))
if ip and self.get_config_dhcpv6_enable():
self.widget("label-dhcpv6-end").show()
self.widget("summary-dhcpv6-end").show()
start = self.get_config_dhcpv6_start()
end = self.get_config_dhcpv6_end()
self.widget("label-dhcpv6-start").set_text("DHCPv6 Start Address:")
if start and end:
self.widget("summary-dhcpv6-start").set_text(str(start.network))
self.widget("summary-dhcpv6-end").set_text(str(end.network))
else:
self.widget("summary-dhcpv6-start").set_text("?")
self.widget("summary-dhcpv6-end").set_text("?")
else:
self.widget("label-dhcpv6-end").hide()
self.widget("summary-dhcpv6-end").hide()
self.widget("label-dhcpv6-start").set_text(_("DHCPv6 Status:"))
self.widget("summary-dhcpv6-start").set_text(_("Disabled"))
if ip and self.get_config_routev6_enable():
self.widget("label-routev6-network").show()
self.widget("label-routev6-gateway").show()
self.widget("summary-routev6-network").show()
self.widget("summary-routev6-gateway").show()
self.widget("summary-routev6-network").set_text("")
self.widget("summary-routev6-gateway").set_text("")
ntwk = self.get_config_routev6_network()
try:
naddr = ipaddr.IPNetwork(ntwk)
except:
naddr = None
gway = self.get_config_routev6_gateway()
try:
gaddr = ipaddr.IPNetwork(gway)
except:
gaddr = None
if naddr and gaddr:
self.widget("summary-routev6-network").set_text(str(naddr))
self.widget("summary-routev6-gateway").set_text(str(gaddr.network))
else:
self.widget("label-routev6-network").hide()
self.widget("label-routev6-gateway").hide()
self.widget("summary-routev6-network").hide()
self.widget("summary-routev6-gateway").hide()
if ip:
self.widget("summary-ipv6-forwarding").set_text("Routed network")
else:
if self.widget("net-enable-ipv6-networking").get_active():
self.widget("summary-ipv6-forwarding").set_text("Isolated network, internal routing only")
else:
self.widget("summary-ipv6-forwarding").set_text("Isolated network")
def populate_ipv4(self):
if not self.get_config_ipv4_enable():
self.widget("net-ipv4-network").set_text("")
self.widget("net-dhcpv4-end").set_text("")
self.widget("net-dhcpv4-start").set_text("")
self.widget("net-ipv4-network").set_sensitive(False)
self.widget("net-dhcpv4-start").set_sensitive(False)
self.widget("net-dhcpv4-end").set_sensitive(False)
else:
self.widget("net-ipv4-network").set_sensitive(True)
if not self.get_config_dhcpv4_enable():
self.widget("net-dhcpv4-end").set_text("")
self.widget("net-dhcpv4-start").set_text("")
self.widget("net-dhcpv4-start").set_sensitive(False)
self.widget("net-dhcpv4-end").set_sensitive(False)
else:
ip = self.get_config_ip4()
if ip:
start = int(ip.numhosts / 2)
end = int(ip.numhosts - 2)
if self.widget("net-dhcpv4-start").get_text() == "":
self.widget("net-dhcpv4-start").set_text(str(ip.network + start))
self.widget("net-dhcpv4-end").set_text(str(ip.network + end))
self.widget("net-dhcpv4-start").set_sensitive(True)
self.widget("net-dhcpv4-end").set_sensitive(True)
def populate_ipv6(self):
if not self.get_config_ipv6_enable():
self.widget("net-ipv6-network").set_text("")
self.widget("net-dhcpv6-end").set_text("")
self.widget("net-dhcpv6-start").set_text("")
self.widget("net-ipv6-network").set_sensitive(False)
self.widget("net-dhcpv6-start").set_sensitive(False)
self.widget("net-dhcpv6-end").set_sensitive(False)
self.widget("net-routev6-network").set_sensitive(False)
self.widget("net-routev6-gateway").set_sensitive(False)
else:
self.widget("net-ipv6-network").set_sensitive(True)
if not self.get_config_dhcpv6_enable():
self.widget("net-dhcpv6-end").set_text("")
self.widget("net-dhcpv6-start").set_text("")
self.widget("net-dhcpv6-start").set_sensitive(False)
self.widget("net-dhcpv6-end").set_sensitive(False)
else:
ip = self.get_config_ip6()
if ip:
start = 256
end = 512 - 1
if self.widget("net-dhcpv6-start").get_text() == "":
self.widget("net-dhcpv6-start").set_text(str(ip.network + start))
self.widget("net-dhcpv6-end").set_text(str(ip.network + end))
self.widget("net-dhcpv6-start").set_sensitive(True)
self.widget("net-dhcpv6-end").set_sensitive(True)
if not self.get_config_routev6_enable():
self.widget("net-routev6-network").set_text("")
self.widget("net-routev6-gateway").set_text("")
self.widget("net-routev6-network").set_sensitive(False)
self.widget("net-routev6-gateway").set_sensitive(False)
else:
self.widget("net-routev6-network").set_text("")
self.widget("net-routev6-gateway").set_text("")
self.widget("net-routev6-network").set_sensitive(True)
self.widget("net-routev6-gateway").set_sensitive(True)
def populate_misc(self):
name = self.widget("net-name").get_text()
if self.widget("net-domain-name").get_text() == "":
self.widget("net-domain-name").set_text(name)
def page_changed(self, ignore1, ignore2, page_number):
if page_number == PAGE_NAME:
name_widget = self.widget("net-name")
name_widget.set_sensitive(True)
name_widget.grab_focus()
elif page_number == PAGE_IPV4:
self.populate_ipv4()
elif page_number == PAGE_IPV6:
self.populate_ipv6()
elif page_number == PAGE_MISC:
self.populate_misc()
elif page_number == PAGE_SUMMARY:
self.populate_summary()
if page_number == PAGE_INTRO:
self.widget("create-back").set_sensitive(False)
else:
self.widget("create-back").set_sensitive(True)
if page_number == PAGE_SUMMARY:
self.widget("create-forward").hide()
self.widget("create-finish").show()
self.widget("create-finish").grab_focus()
else:
self.widget("create-forward").show()
self.widget("create-finish").hide()
def finish(self, ignore):
name = self.get_config_name()
dev, mode = self.get_config_forwarding()
if self.widget("net-enable-ipv6-networking").get_active():
xml = "<network ipv6='yes'>\n"
else:
xml = "<network>\n"
xml += " <name>%s</name>\n" % name
domain_name = self.get_config_domain_name()
if len(domain_name) != 0:
xml += " <domain name='%s' />\n" % domain_name
if mode:
if dev is not None:
xml += " <forward mode='%s' dev='%s'/>\n" % (mode, dev)
else:
xml += " <forward mode='%s'/>\n" % mode
if self.get_config_ipv4_enable():
ip = self.get_config_ip4()
xml += " <ip address='%s' netmask='%s'>\n" % (str(ip.network + 1),
str(ip.netmask))
if self.get_config_dhcpv4_enable():
start = self.get_config_dhcpv4_start()
end = self.get_config_dhcpv4_end()
xml += " <dhcp>\n"
xml += " <range start='%s' end='%s'/>\n" % (str(start.network),
str(end.network))
xml += " </dhcp>\n"
xml += " </ip>\n"
if self.get_config_ipv6_enable():
ip = self.get_config_ip6()
xml += " <ip family='ipv6' address='%s' prefix='%s'>\n" % (str(ip.network + 1),
str(ip.prefixlen))
if self.get_config_dhcpv6_enable():
start = self.get_config_dhcpv6_start()
end = self.get_config_dhcpv6_end()
xml += " <dhcp>\n"
xml += " <range start='%s' end='%s'/>\n" % (str(start.network),
str(end.network))
xml += " </dhcp>\n"
xml += " </ip>\n"
ntwk = self.get_config_routev4_network()
try:
netaddr = ipaddr.IPNetwork(ntwk)
except:
netaddr = None
gway = self.get_config_routev4_gateway()
try:
gwaddr = ipaddr.IPNetwork(gway)
except:
gwaddr = None
if netaddr and gwaddr:
xml += "<route family='ipv4'"
xml += " address='%s'" % netaddr.network
xml += " prefix='%s'" % netaddr.prefixlen
xml += " gateway='%s' />" % gwaddr.network
ntwk = self.get_config_routev6_network()
try:
netaddr = ipaddr.IPNetwork(ntwk)
except:
netaddr = None
gway = self.get_config_routev6_gateway()
try:
gwaddr = ipaddr.IPNetwork(gway)
except:
gwaddr = None
if netaddr and gwaddr:
xml += "<route family='ipv6'"
xml += " address='%s'" % netaddr.network
xml += " prefix='%s'" % netaddr.prefixlen
xml += " gateway='%s' />" % gwaddr.network
xml += "</network>\n"
logging.debug("Generated network XML:\n" + xml)
try:
self.conn.create_network(xml)
except Exception, e:
self.err.show_err(_("Error creating virtual network: %s" % str(e)))
return
self.conn.schedule_priority_tick(pollnet=True)
self.close()
def validate_name(self):
name_widget = self.widget("net-name")
name = name_widget.get_text()
if len(name) > 50 or len(name) == 0:
retcode = self.err.val_err(_("Invalid Network Name"),
_("Network name must be non-blank and less than "
"50 characters"))
name_widget.grab_focus()
return retcode
if re.match("^[a-zA-Z0-9_]*$", name) is None:
return self.err.val_err(_("Invalid Network Name"),
_("Network name may contain alphanumeric and '_' "
"characters only"))
return True
def validate_ipv4(self):
if not self.get_config_ipv4_enable():
return True
ip = self.get_config_ip4()
if ip is None:
return self.err.val_err(_("Invalid Network Address"),
_("The network address could not be understood"))
if ip.version != 4:
return self.err.val_err(_("Invalid Network Address"),
_("The network must be an IPv4 address"))
if ip.numhosts < 16:
return self.err.val_err(_("Invalid Network Address"),
_("The network must address at least 16 addresses."))
if not ip.is_private:
res = self.err.yes_no(_("Check Network Address"),
_("The network should normally use a private IPv4 "
"address. Use this non-private address anyway?"))
if not res:
return False
enabled = self.get_config_dhcpv4_enable()
if enabled:
start = self.get_config_dhcpv4_start()
end = self.get_config_dhcpv4_end()
if start is None:
return self.err.val_err(_("Invalid DHCP Address"),
_("The DHCP start address could not be understood"))
if end is None:
return self.err.val_err(_("Invalid DHCP Address"),
_("The DHCP end address could not be understood"))
if not ip.overlaps(start):
return self.err.val_err(_("Invalid DHCP Address"),
(_("The DHCP start address is not with the network %s") %
(str(ip))))
if not ip.overlaps(end):
return self.err.val_err(_("Invalid DHCP Address"),
(_("The DHCP end address is not with the network %s") %
(str(ip))))
enabled = self.get_config_routev4_enable()
if enabled:
ntwk = self.get_config_routev4_network()
ntwkbad = False
gway = self.get_config_routev4_gateway()
gwaybad = False
if ntwk is None or gway is None:
return True
if ntwk == "" and gway == "":
return True
naddr = self.get_route_addr(ntwk)
if naddr is None:
ntwkbad = True
else:
if naddr.version != 4:
ntwkbad = True
if naddr.prefixlen > 28:
ntwkbad = True
gaddr = self.get_route_addr(gway)
if gaddr is None:
gwaybad = True
else:
if gaddr.version != 4:
gwaybad = True
if gaddr.prefixlen != 32:
gwaybad = True
if not ip.overlaps(gaddr):
gwaybad = True
if ntwkbad:
return self.err.val_err(_("Invalid static route"),
_("The network address is incorrect."))
if gwaybad:
return self.err.val_err(_("Invalid static route"),
_("The gateway address is incorrect."))
return True
def validate_ipv6(self):
if not self.get_config_ipv6_enable():
return True
ip = self.get_config_ip6()
if ip is None:
return self.err.val_err(_("Invalid Network Address"),
_("The network address could not be understood"))
if ip.version != 6:
return self.err.val_err(_("Invalid Network Address"),
_("The network must be an IPv6 address"))
if ip.prefixlen != 64:
return self.err.val_err(_("Invalid Network Address"),
_("For libvirt, the IPv6 network prefix must be /64"))
if not ip.is_private:
res = self.err.yes_no(_("Check Network Address"),
_("The network should normally use a private IPv4 "
"address. Use this non-private address anyway?"))
if not res:
return False
enabled = self.get_config_dhcpv6_enable()
if enabled:
start = self.get_config_dhcpv6_start()
end = self.get_config_dhcpv6_end()
if start is None:
return self.err.val_err(_("Invalid DHCPv6 Address"),
_("The DHCPv6 start address could not be understood"))
if end is None:
return self.err.val_err(_("Invalid DHCPv6 Address"),
_("The DHCPv6 end address could not be understood"))
if not ip.overlaps(start):
return self.err.val_err(_("Invalid DHCPv6 Address"),
(_("The DHCPv6 start address is not with the network %s") %
(str(ip))))
if not ip.overlaps(end):
return self.err.val_err(_("Invalid DHCPv6 Address"),
(_("The DHCPv6 end address is not with the network %s") %
(str(ip))))
enabled = self.get_config_routev6_enable()
if enabled:
ntwk = self.get_config_routev6_network()
ntwkbad = False
gway = self.get_config_routev6_gateway()
gwaybad = False
if ntwk is None or gway is None:
return True
if ntwk == "" and gway == "":
return True
naddr = self.get_route_addr(ntwk)
if naddr is None:
ntwkbad = True
else:
if naddr.version != 6:
ntwkbad = True
if naddr.prefixlen > 64:
ntwkbad = True
gaddr = self.get_route_addr(gway)
if gaddr is None:
gwaybad = True
else:
if gaddr.version != 6:
gwaybad = True
if gaddr.prefixlen != 128:
gwaybad = True
if not ip.overlaps(gaddr):
gwaybad = True
if ntwkbad:
return self.err.val_err(_("Invalid static route"),
_("The network address is incorrect."))
if gwaybad:
return self.err.val_err(_("Invalid static route"),
_("The gateway address is incorrect."))
return True
def validate_miscellaneous(self):
domain_name = self.widget("net-domain-name").get_text()
if len(domain_name) > 0:
if len(domain_name) > 16:
return self.err.val_err(_("Invalid Domain Name"),
_("Domain name must be less than 17 characters"))
if re.match("^[a-zA-Z0-9_]*$", domain_name) is None:
return self.err.val_err(_("Invalid Domain Name"),
_("Domain name may contain alphanumeric and '_' "
"characters only"))
if not self.widget("net-forward-dev").get_active():
return True
dev = self.widget("net-forward")
if dev.get_active() == -1:
return self.err.val_err(_("Invalid forwarding mode"),
_("Please select where the traffic should be forwarded"))
return True
def validate(self, page_num):
if page_num == PAGE_NAME:
return self.validate_name()
elif page_num == PAGE_IPV4:
return self.validate_ipv4()
elif page_num == PAGE_IPV6:
return self.validate_ipv6()
elif page_num == PAGE_MISC:
return self.validate_miscellaneous()
return True
Reference in New Issue View Git Blame Copy Permalink