1147 lines
38 KiB
Python
1147 lines
38 KiB
Python
#
|
|
# Copyright (C) 2008, 2013 Red Hat, Inc.
|
|
# Copyright (C) 2008 Cole Robinson <crobinso@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
|
|
|
|
from gi.repository import Gtk
|
|
from gi.repository import Gdk
|
|
|
|
from virtinst import Interface, InterfaceProtocol
|
|
|
|
from . import uiutil
|
|
from .baseclass import vmmGObjectUI
|
|
from .asyncjob import vmmAsyncJob
|
|
|
|
PAGE_TYPE = 0
|
|
PAGE_DETAILS = 1
|
|
|
|
DETAILS_BOND = 0
|
|
DETAILS_BRIDGE = 1
|
|
DETAILS_VLAN = 2
|
|
DETAILS_ETHERNET = 3
|
|
|
|
INTERFACE_ROW_KEY = 0
|
|
INTERFACE_ROW_SELECT = 1
|
|
INTERFACE_ROW_CANT_SELECT = 2
|
|
INTERFACE_ROW_NAME = 3
|
|
INTERFACE_ROW_TYPE = 4
|
|
INTERFACE_ROW_IS_DEFINED = 5
|
|
INTERFACE_ROW_IS_ACTIVE = 6
|
|
INTERFACE_ROW_IN_USE_BY = 7
|
|
INTERFACE_ROW_MAC = 8
|
|
|
|
BOND_PAGE_ARP = 0
|
|
BOND_PAGE_MII = 1
|
|
BOND_PAGE_DEFAULT = 2
|
|
|
|
IP_DHCP = 0
|
|
IP_STATIC = 1
|
|
IP_NONE = 2
|
|
|
|
|
|
class vmmCreateInterface(vmmGObjectUI):
|
|
__gsignals__ = {}
|
|
|
|
def __init__(self, conn):
|
|
vmmGObjectUI.__init__(self,
|
|
"createinterface.ui", "vmm-create-interface")
|
|
self.conn = conn
|
|
self.interface = None
|
|
|
|
self.bridge_config = self.widget("bridge-config")
|
|
self.bridge_config.set_transient_for(self.topwin)
|
|
|
|
self.bond_config = self.widget("bond-config")
|
|
self.bond_config.set_transient_for(self.topwin)
|
|
|
|
self.ip_config = self.widget("ip-config")
|
|
self.ip_config.set_transient_for(self.topwin)
|
|
|
|
self.ip_manually_changed = False
|
|
|
|
self.builder.connect_signals({
|
|
"on_vmm_create_interface_delete_event": self.close,
|
|
|
|
"on_cancel_clicked": self.close,
|
|
"on_back_clicked": self.back,
|
|
"on_forward_clicked": self.forward,
|
|
"on_finish_clicked": self.finish,
|
|
"on_pages_switch_page": self.page_changed,
|
|
|
|
"on_bridge_config_button_clicked": self.show_bridge_config,
|
|
"on_bond_config_button_clicked": self.show_bond_config,
|
|
"on_ip_config_button_clicked": self.show_ip_config,
|
|
"on_vlan_tag_changed": self.update_interface_name,
|
|
|
|
# Bridge config dialog
|
|
"on_bridge_config_delete_event": self.bridge_config_finish,
|
|
"on_bridge_ok_clicked": self.bridge_config_finish,
|
|
|
|
# IP config dialog
|
|
"on_ip_config_delete_event": self.ip_config_finish,
|
|
"on_ip_ok_clicked": self.ip_config_finish,
|
|
|
|
"on_ip_copy_interface_toggled": self.ip_copy_interface_toggled,
|
|
|
|
"on_ipv4_mode_changed": self.ipv4_mode_changed,
|
|
"on_ipv6_mode_changed": self.ipv6_mode_changed,
|
|
|
|
"on_ipv6_address_add_clicked": self.ipv6_address_add,
|
|
"on_ipv6_address_remove_clicked": self.ipv6_address_remove,
|
|
"on_ipv6_address_list_changed": self.ipv6_address_selected,
|
|
|
|
# Bond config dialog
|
|
"on_bond_config_delete_event": self.bond_config_finish,
|
|
"on_bond_ok_clicked": self.bond_config_finish,
|
|
|
|
"on_bond_monitor_mode_changed": self.bond_monitor_mode_changed,
|
|
})
|
|
self.bind_escape_key_close()
|
|
|
|
self.set_initial_state()
|
|
|
|
def show(self, parent):
|
|
logging.debug("Showing new interface wizard")
|
|
self.reset_state()
|
|
self.topwin.set_transient_for(parent)
|
|
self.topwin.present()
|
|
|
|
def show_bond_config(self, src):
|
|
ignore = src
|
|
logging.debug("Showing new interface bond config")
|
|
self.bond_config.show_all()
|
|
|
|
def show_bridge_config(self, src):
|
|
ignore = src
|
|
logging.debug("Showing new interface bridge config")
|
|
self.bridge_config.show_all()
|
|
|
|
def show_ip_config(self, src):
|
|
ignore = src
|
|
logging.debug("Showing new interface ip config")
|
|
self.ip_manually_changed = True
|
|
self.ip_config.show_all()
|
|
|
|
def close(self, ignore1=None, ignore2=None):
|
|
if self.topwin.is_visible():
|
|
logging.debug("Closing new interface wizard")
|
|
self.ip_config.hide()
|
|
self.bridge_config.hide()
|
|
self.bond_config.hide()
|
|
self.topwin.hide()
|
|
|
|
return 1
|
|
|
|
def _cleanup(self):
|
|
self.conn = None
|
|
self.interface = None
|
|
|
|
self.ip_config.destroy()
|
|
self.ip_config = None
|
|
|
|
self.bridge_config.destroy()
|
|
self.bridge_config = None
|
|
|
|
self.bond_config.destroy()
|
|
self.bond_config = None
|
|
|
|
|
|
###########################
|
|
# Initialization routines #
|
|
###########################
|
|
|
|
@staticmethod
|
|
def iface_in_use_by(conn, name):
|
|
use_str = ""
|
|
for iface in conn.list_interfaces():
|
|
if name in iface.get_slave_names():
|
|
if use_str:
|
|
use_str += ", "
|
|
use_str += iface.get_name()
|
|
|
|
return use_str
|
|
|
|
@staticmethod
|
|
def build_interface_startmode_combo(combo):
|
|
model = Gtk.ListStore(str)
|
|
combo.set_model(model)
|
|
uiutil.init_combo_text_column(combo, 0)
|
|
|
|
model.append(["none"])
|
|
model.append(["onboot"])
|
|
model.append(["hotplug"])
|
|
|
|
def set_initial_state(self):
|
|
self.widget("pages").set_show_tabs(False)
|
|
self.widget("bond-pages").set_show_tabs(False)
|
|
|
|
blue = Gdk.Color.parse("#0072A8")[1]
|
|
self.widget("header").modify_bg(Gtk.StateType.NORMAL, blue)
|
|
|
|
# Interface type
|
|
type_list = self.widget("interface-type")
|
|
type_model = Gtk.ListStore(str, str)
|
|
type_list.set_model(type_model)
|
|
uiutil.init_combo_text_column(type_list, 1)
|
|
type_model.append([Interface.INTERFACE_TYPE_BRIDGE,
|
|
_("Bridge")])
|
|
type_model.append([Interface.INTERFACE_TYPE_BOND,
|
|
_("Bond")])
|
|
type_model.append([Interface.INTERFACE_TYPE_ETHERNET,
|
|
_("Ethernet")])
|
|
type_model.append([Interface.INTERFACE_TYPE_VLAN,
|
|
_("VLAN")])
|
|
|
|
# Start mode
|
|
self.build_interface_startmode_combo(
|
|
self.widget("interface-startmode"))
|
|
|
|
# Parent/slave Interface list
|
|
slave_list = self.widget("interface-list")
|
|
# [ vmmInterface, selected, selectable, name, type, is defined,
|
|
# is active, in use by str, mac]
|
|
slave_model = Gtk.ListStore(object, bool, bool, str, str, bool, bool,
|
|
str, str)
|
|
slave_list.set_model(slave_model)
|
|
|
|
selectCol = Gtk.TreeViewColumn()
|
|
nameCol = Gtk.TreeViewColumn(_("Name"))
|
|
typeCol = Gtk.TreeViewColumn(_("Type"))
|
|
useCol = Gtk.TreeViewColumn(_("In use by"))
|
|
|
|
slave_list.append_column(selectCol)
|
|
slave_list.append_column(nameCol)
|
|
slave_list.append_column(typeCol)
|
|
slave_list.append_column(useCol)
|
|
|
|
chk = Gtk.CellRendererToggle()
|
|
chk.connect("toggled", self.interface_item_toggled, slave_list)
|
|
selectCol.pack_start(chk, False)
|
|
selectCol.add_attribute(chk, "active", INTERFACE_ROW_SELECT)
|
|
selectCol.add_attribute(chk, "inconsistent", INTERFACE_ROW_CANT_SELECT)
|
|
selectCol.set_sort_column_id(INTERFACE_ROW_CANT_SELECT)
|
|
|
|
txt = Gtk.CellRendererText()
|
|
nameCol.pack_start(txt, True)
|
|
nameCol.add_attribute(txt, "text", INTERFACE_ROW_NAME)
|
|
nameCol.set_sort_column_id(INTERFACE_ROW_NAME)
|
|
|
|
txt = Gtk.CellRendererText()
|
|
typeCol.pack_start(txt, True)
|
|
typeCol.add_attribute(txt, "text", INTERFACE_ROW_TYPE)
|
|
typeCol.set_sort_column_id(INTERFACE_ROW_TYPE)
|
|
slave_model.set_sort_column_id(INTERFACE_ROW_CANT_SELECT,
|
|
Gtk.SortType.ASCENDING)
|
|
|
|
txt = Gtk.CellRendererText()
|
|
useCol.pack_start(txt, True)
|
|
useCol.add_attribute(txt, "text", INTERFACE_ROW_IN_USE_BY)
|
|
useCol.set_sort_column_id(INTERFACE_ROW_IN_USE_BY)
|
|
|
|
# Bond config
|
|
mode_list = self.widget("bond-mode")
|
|
mode_model = Gtk.ListStore(str, str)
|
|
mode_list.set_model(mode_model)
|
|
uiutil.init_combo_text_column(mode_list, 0)
|
|
mode_model.append([_("System default"), None])
|
|
for m in Interface.INTERFACE_BOND_MODES:
|
|
mode_model.append([m, m])
|
|
|
|
mon_list = self.widget("bond-monitor-mode")
|
|
mon_model = Gtk.ListStore(str, str)
|
|
mon_list.set_model(mon_model)
|
|
uiutil.init_combo_text_column(mon_list, 0)
|
|
mon_model.append([_("System default"), None])
|
|
for m in Interface.INTERFACE_BOND_MONITOR_MODES:
|
|
mon_model.append([m, m])
|
|
|
|
validate_list = self.widget("arp-validate")
|
|
validate_model = Gtk.ListStore(str)
|
|
validate_list.set_model(validate_model)
|
|
uiutil.init_combo_text_column(validate_list, 0)
|
|
for m in Interface.INTERFACE_BOND_MONITOR_MODE_ARP_VALIDATE_MODES:
|
|
validate_model.append([m])
|
|
|
|
carrier_list = self.widget("mii-carrier")
|
|
carrier_model = Gtk.ListStore(str)
|
|
carrier_list.set_model(carrier_model)
|
|
uiutil.init_combo_text_column(carrier_list, 0)
|
|
for m in Interface.INTERFACE_BOND_MONITOR_MODE_MII_CARRIER_TYPES:
|
|
carrier_model.append([m])
|
|
|
|
# IP config
|
|
copy_iface = self.widget("ip-copy-interface-combo")
|
|
copy_model = Gtk.ListStore(str, object, bool)
|
|
copy_iface.set_model(copy_model)
|
|
uiutil.init_combo_text_column(copy_iface, 0)
|
|
|
|
ip_mode = self.widget("ipv4-mode")
|
|
ip_model = Gtk.ListStore(str)
|
|
ip_mode.set_model(ip_model)
|
|
uiutil.init_combo_text_column(ip_mode, 0)
|
|
ip_model.insert(IP_DHCP, ["DHCP"])
|
|
ip_model.insert(IP_STATIC, [_("Static")])
|
|
ip_model.insert(IP_NONE, [_("No configuration")])
|
|
|
|
ip_mode = self.widget("ipv6-mode")
|
|
ip_model = Gtk.ListStore(str)
|
|
ip_mode.set_model(ip_model)
|
|
uiutil.init_combo_text_column(ip_mode, 0)
|
|
ip_model.insert(IP_DHCP, ["DHCP"])
|
|
ip_model.insert(IP_STATIC, [_("Static")])
|
|
ip_model.insert(IP_NONE, [_("No configuration")])
|
|
|
|
v6_addr = self.widget("ipv6-address-list")
|
|
addr_model = Gtk.ListStore(str)
|
|
v6_addr.set_model(addr_model)
|
|
txt_col = Gtk.TreeViewColumn("")
|
|
v6_addr.append_column(txt_col)
|
|
txt = Gtk.CellRendererText()
|
|
txt.set_property("editable", True)
|
|
txt.connect("edited", self.ipv6_address_edited)
|
|
txt_col.pack_start(txt, True)
|
|
txt_col.add_attribute(txt, "text", 0)
|
|
|
|
def reset_state(self):
|
|
self.widget("pages").set_current_page(PAGE_TYPE)
|
|
self.page_changed(None, None, PAGE_TYPE)
|
|
|
|
self.widget("interface-type").set_active(0)
|
|
|
|
# General details
|
|
self.widget("interface-name-entry").set_text("")
|
|
self.widget("interface-name-label").set_text("")
|
|
self.widget("interface-startmode").set_active(0)
|
|
self.widget("interface-activate").set_active(False)
|
|
|
|
# Bridge config
|
|
self.widget("bridge-delay").set_value(0)
|
|
self.widget("bridge-stp").set_active(True)
|
|
|
|
# Bond config
|
|
self.widget("bond-mode").set_active(0)
|
|
self.widget("bond-monitor-mode").set_active(0)
|
|
|
|
self.widget("arp-interval").set_value(0)
|
|
self.widget("arp-target").set_text("")
|
|
self.widget("arp-validate").set_active(0)
|
|
|
|
self.widget("mii-frequency").set_value(0)
|
|
self.widget("mii-updelay").set_value(0)
|
|
self.widget("mii-downdelay").set_value(0)
|
|
self.widget("mii-carrier").set_active(0)
|
|
|
|
# IP config
|
|
self.ip_manually_changed = False
|
|
self.widget("ip-do-manual").set_active(True)
|
|
self.widget("ip-do-manual-box").set_current_page(0)
|
|
|
|
self.widget("ipv4-mode").set_active(IP_DHCP)
|
|
self.widget("ipv4-address").set_text("")
|
|
self.widget("ipv4-gateway").set_text("")
|
|
|
|
self.widget("ipv6-mode").set_active(IP_NONE)
|
|
self.widget("ipv6-autoconf").set_active(False)
|
|
self.widget("ipv6-gateway").set_text("")
|
|
self.widget("ipv6-address-list").get_model().clear()
|
|
self.ipv6_address_selected()
|
|
|
|
def populate_details_page(self):
|
|
itype = self.get_config_interface_type()
|
|
|
|
# Set up default interface name
|
|
self.widget("interface-name-entry").hide()
|
|
self.widget("interface-name-label").hide()
|
|
|
|
if itype in [Interface.INTERFACE_TYPE_BRIDGE,
|
|
Interface.INTERFACE_TYPE_BOND]:
|
|
widget = "interface-name-entry"
|
|
else:
|
|
widget = "interface-name-label"
|
|
|
|
self.widget(widget).show()
|
|
default_name = self.get_default_name()
|
|
self.set_interface_name(default_name)
|
|
|
|
# Make sure interface type specific fields are shown
|
|
type_dict = {
|
|
Interface.INTERFACE_TYPE_BRIDGE: "bridge",
|
|
Interface.INTERFACE_TYPE_BOND: "bond",
|
|
Interface.INTERFACE_TYPE_VLAN: "vlan",
|
|
}
|
|
|
|
for key, value in type_dict.items():
|
|
do_show = (key == itype)
|
|
self.widget("%s-label" % value).set_visible(do_show)
|
|
self.widget("%s-box" % value).set_visible(do_show)
|
|
|
|
if itype == Interface.INTERFACE_TYPE_BRIDGE:
|
|
self.update_bridge_desc()
|
|
|
|
elif itype == Interface.INTERFACE_TYPE_BOND:
|
|
self.update_bond_desc()
|
|
|
|
# Populate device list
|
|
self.populate_interface_list(itype)
|
|
|
|
self.update_ip_config()
|
|
|
|
def update_ip_config(self):
|
|
(is_manual, current_name,
|
|
ignore, ignore, ignore) = self.get_config_ip_info()
|
|
itype = self.get_config_interface_type()
|
|
ifaces = self.get_config_selected_interfaces()
|
|
|
|
copy_radio = self.widget("ip-copy-interface")
|
|
copy_combo = self.widget("ip-copy-interface-combo")
|
|
copy_model = copy_combo.get_model()
|
|
|
|
# Only select 'copy from' option if using bridge/bond/vlan
|
|
enable_copy = (itype in [Interface.INTERFACE_TYPE_BRIDGE,
|
|
Interface.INTERFACE_TYPE_BOND,
|
|
Interface.INTERFACE_TYPE_VLAN])
|
|
|
|
# Set defaults if required
|
|
copy_model.clear()
|
|
active_rows = []
|
|
inactive_rows = []
|
|
for row in ifaces:
|
|
is_defined = row[INTERFACE_ROW_IS_DEFINED]
|
|
name = row[INTERFACE_ROW_NAME]
|
|
label = name
|
|
sensitive = False
|
|
|
|
iface_obj = None
|
|
if is_defined:
|
|
iface_obj = self.conn.get_interface(name)
|
|
|
|
# We only want configured (aka interface API) interfaces with
|
|
# actually present <protocol> info
|
|
if not is_defined or not iface_obj:
|
|
label += " (" + _("Not configured") + ")"
|
|
elif not iface_obj.get_protocol_xml():
|
|
label += " (" + _("No IP configuration") + ")"
|
|
else:
|
|
sensitive = True
|
|
|
|
row = [label, iface_obj, sensitive]
|
|
if sensitive:
|
|
active_rows.append(row)
|
|
else:
|
|
inactive_rows.append(row)
|
|
|
|
# Make sure inactive rows are listed after active rows
|
|
for row in active_rows + inactive_rows:
|
|
copy_model.append(row)
|
|
|
|
if len(copy_model) == 0:
|
|
copy_model.append([_("No child interfaces selected."), None, False])
|
|
|
|
if not enable_copy:
|
|
copy_model.clear()
|
|
copy_model.append(["", None, False])
|
|
|
|
# Find default model selection
|
|
have_valid_copy = bool(active_rows)
|
|
|
|
# Re select previous selection, 0 otherwise
|
|
idx = 0
|
|
if not is_manual and current_name:
|
|
found_idx = 0
|
|
for row in copy_model:
|
|
if row[1] == current_name:
|
|
idx = found_idx
|
|
break
|
|
found_idx += 1
|
|
copy_combo.set_active(idx)
|
|
|
|
copy_radio.set_sensitive(enable_copy)
|
|
if not self.ip_manually_changed:
|
|
if (enable_copy and have_valid_copy):
|
|
copy_radio.set_active(True)
|
|
else:
|
|
self.widget("ip-do-manual").set_active(True)
|
|
|
|
self.update_ip_desc()
|
|
|
|
def populate_interface_list(self, itype):
|
|
iface_list = self.widget("interface-list")
|
|
model = iface_list.get_model()
|
|
model.clear()
|
|
|
|
ifilter = [Interface.INTERFACE_TYPE_ETHERNET]
|
|
msg = None
|
|
if itype == Interface.INTERFACE_TYPE_BRIDGE:
|
|
ifilter.append(Interface.INTERFACE_TYPE_VLAN)
|
|
ifilter.append(Interface.INTERFACE_TYPE_BOND)
|
|
msg = _("Choose interface(s) to bridge:")
|
|
|
|
elif itype == Interface.INTERFACE_TYPE_VLAN:
|
|
msg = _("Choose parent interface:")
|
|
elif itype == Interface.INTERFACE_TYPE_BOND:
|
|
msg = _("Choose interfaces to bond:")
|
|
elif itype == Interface.INTERFACE_TYPE_ETHERNET:
|
|
msg = _("Choose an unconfigured interface:")
|
|
|
|
self.widget("interface-list-text").set_text(msg)
|
|
|
|
nodedevs = {}
|
|
for phys in self.conn.filter_nodedevs("net"):
|
|
nodedevs[phys.xmlobj.interface] = [None,
|
|
False, False, phys.xmlobj.interface,
|
|
"ethernet", False, True, None,
|
|
phys.xmlobj.address]
|
|
|
|
row_dict = {}
|
|
for iface in self.conn.list_interfaces():
|
|
name = iface.get_name()
|
|
key = iface.get_xmlobj()
|
|
iface_type = iface.get_type()
|
|
active = iface.is_active()
|
|
name = iface.get_name()
|
|
|
|
if iface_type not in ifilter:
|
|
continue
|
|
|
|
if itype == Interface.INTERFACE_TYPE_ETHERNET:
|
|
# When adding an ethernet definition, we only want
|
|
# 'unconfigured' interfaces, so stuff in nodedevs that's
|
|
# not in returned by the interface APIs
|
|
if name in nodedevs:
|
|
del(nodedevs[name])
|
|
|
|
# We only want 'unconfigured' interfaces here
|
|
continue
|
|
|
|
if name in nodedevs:
|
|
# Interface was listed via nodedev APIs
|
|
row = nodedevs.pop(name)
|
|
row[INTERFACE_ROW_KEY] = key
|
|
row[INTERFACE_ROW_IS_DEFINED] = True
|
|
row[INTERFACE_ROW_IS_ACTIVE] = True
|
|
|
|
else:
|
|
# Brand new row
|
|
row = [key, False, False,
|
|
iface.get_name(), iface.get_type(), True,
|
|
active, None, iface.get_mac()]
|
|
row_dict[name] = row
|
|
|
|
for name, row in nodedevs.items():
|
|
try:
|
|
key = Interface(self.conn.get_backend())
|
|
key.type = Interface.INTERFACE_TYPE_ETHERNET
|
|
key.name = name
|
|
except Exception as e:
|
|
logging.debug("Error creating stub interface '%s': %s",
|
|
name, e)
|
|
continue
|
|
row[INTERFACE_ROW_KEY] = key
|
|
row_dict[name] = row
|
|
|
|
for row in row_dict.values():
|
|
name = row[INTERFACE_ROW_NAME]
|
|
row[INTERFACE_ROW_IN_USE_BY] = self.iface_in_use_by(self.conn,
|
|
name)
|
|
|
|
for row in row_dict.values():
|
|
model.append(row)
|
|
|
|
def get_default_name(self):
|
|
itype = self.get_config_interface_type()
|
|
|
|
name = _("No interface selected")
|
|
if itype == Interface.INTERFACE_TYPE_BRIDGE:
|
|
name = Interface.find_free_name(self.conn.get_backend(), "br")
|
|
elif itype == Interface.INTERFACE_TYPE_BOND:
|
|
name = Interface.find_free_name(self.conn.get_backend(), "bond")
|
|
else:
|
|
ifaces = self.get_config_selected_interfaces()
|
|
if len(ifaces) > 0:
|
|
iface = ifaces[0][INTERFACE_ROW_NAME]
|
|
|
|
if itype == Interface.INTERFACE_TYPE_VLAN:
|
|
tag = uiutil.spin_get_helper(self.widget("vlan-tag"))
|
|
name = "%s.%s" % (iface, int(tag))
|
|
|
|
elif itype == Interface.INTERFACE_TYPE_ETHERNET:
|
|
name = iface
|
|
|
|
return name
|
|
|
|
|
|
#########################
|
|
# get_config_* routines #
|
|
#########################
|
|
|
|
def get_config_interface_type(self):
|
|
return uiutil.get_list_selection(self.widget("interface-type"))
|
|
|
|
def set_interface_name(self, name):
|
|
if self.widget("interface-name-entry").get_visible():
|
|
widget = "interface-name-entry"
|
|
else:
|
|
widget = "interface-name-label"
|
|
|
|
self.widget(widget).set_text(name)
|
|
|
|
def get_config_interface_name(self):
|
|
if self.widget("interface-name-entry").get_visible():
|
|
return self.widget("interface-name-entry").get_text()
|
|
else:
|
|
return self.widget("interface-name-label").get_text()
|
|
|
|
def get_config_interface_startmode(self):
|
|
return uiutil.get_list_selection(self.widget("interface-startmode"))
|
|
|
|
def get_config_selected_interfaces(self):
|
|
iface_list = self.widget("interface-list")
|
|
model = iface_list.get_model()
|
|
ret = []
|
|
|
|
for row in model:
|
|
active = row[INTERFACE_ROW_SELECT]
|
|
|
|
if active:
|
|
ret.append(row)
|
|
|
|
return ret
|
|
|
|
def get_config_bridge_params(self):
|
|
delay = self.widget("bridge-delay").get_value()
|
|
stp = self.widget("bridge-stp").get_active()
|
|
return [delay, stp]
|
|
|
|
def get_config_ipv6_address_selection(self):
|
|
src = self.widget("ipv6-address-list")
|
|
selection = src.get_selection()
|
|
ignore, treepath = selection.get_selected()
|
|
return treepath
|
|
|
|
def get_config_ipv6_addresses(self):
|
|
src = self.widget("ipv6-address-list")
|
|
model = src.get_model()
|
|
return [x[0] for x in model]
|
|
|
|
################
|
|
# UI Listeners #
|
|
################
|
|
|
|
def interface_item_toggled(self, src, index, slave_list):
|
|
itype = self.get_config_interface_type()
|
|
active = src.get_active()
|
|
model = slave_list.get_model()
|
|
|
|
if itype in [Interface.INTERFACE_TYPE_ETHERNET,
|
|
Interface.INTERFACE_TYPE_VLAN]:
|
|
# Deselect any selected rows
|
|
for row in model:
|
|
if row == model[index]:
|
|
continue
|
|
row[INTERFACE_ROW_SELECT] = False
|
|
|
|
# Toggle the clicked row
|
|
model[index][INTERFACE_ROW_SELECT] = not active
|
|
|
|
self.update_interface_name()
|
|
self.update_ip_config()
|
|
|
|
def update_interface_name(self, ignore1=None, ignore2=None):
|
|
itype = self.get_config_interface_type()
|
|
if itype not in [Interface.INTERFACE_TYPE_VLAN,
|
|
Interface.INTERFACE_TYPE_ETHERNET]:
|
|
# The rest have editable name fields, so don't overwrite
|
|
return
|
|
|
|
name = self.get_default_name()
|
|
self.set_interface_name(name)
|
|
|
|
def bond_monitor_mode_changed(self, src):
|
|
value = uiutil.get_list_selection(src, column=1)
|
|
bond_pages = self.widget("bond-pages")
|
|
|
|
if value == "arpmon":
|
|
page = BOND_PAGE_ARP
|
|
elif value == "miimon":
|
|
page = BOND_PAGE_MII
|
|
else:
|
|
page = BOND_PAGE_DEFAULT
|
|
|
|
bond_pages.set_current_page(page)
|
|
|
|
def ip_copy_interface_toggled(self, src):
|
|
active = src.get_active()
|
|
|
|
self.widget("ip-copy-interface-box").set_sensitive(active)
|
|
self.widget("ip-do-manual-box").set_sensitive(not active)
|
|
|
|
def ipv4_mode_changed(self, src):
|
|
static = (src.get_active() == IP_STATIC)
|
|
self.widget("ipv4-static-box").set_sensitive(static)
|
|
|
|
def ipv6_mode_changed(self, src):
|
|
static = (src.get_active() == IP_STATIC)
|
|
self.widget("ipv6-static-box").set_sensitive(static)
|
|
|
|
def update_bridge_desc(self):
|
|
delay, stp = self.get_config_bridge_params()
|
|
txt = "STP %s" % (stp and "on" or "off")
|
|
txt += ", delay %.2f sec" % float(delay)
|
|
|
|
self.widget("bridge-config-label").set_text(txt)
|
|
|
|
def update_bond_desc(self):
|
|
mode = uiutil.get_list_selection(self.widget("bond-mode"))
|
|
mon = uiutil.get_list_selection(
|
|
self.widget("bond-monitor-mode"), column=1)
|
|
|
|
txt = mode
|
|
if mon:
|
|
txt += ", %s" % mon
|
|
|
|
self.widget("bond-config-label").set_text(txt)
|
|
|
|
def update_ip_desc(self):
|
|
is_manual, name, ipv4, ipv6, ignore = self.get_config_ip_info()
|
|
label = ""
|
|
|
|
if is_manual:
|
|
if ipv4:
|
|
label += "IPv4: %s" % (ipv4.dhcp and "DHCP" or _("Static"))
|
|
|
|
if ipv6:
|
|
if label:
|
|
label += ", "
|
|
label += "IPv6: "
|
|
|
|
mode_label = ""
|
|
if ipv6.autoconf and ipv6.dhcp:
|
|
mode_label += _("Autoconf") + " "
|
|
|
|
if ipv6.dhcp:
|
|
mode_label += "DHCP"
|
|
|
|
if not mode_label:
|
|
mode_label = _("Static")
|
|
|
|
label += mode_label
|
|
|
|
else:
|
|
if name:
|
|
label = _("Copy configuration from '%s'") % name
|
|
|
|
if not label:
|
|
label = _("No configuration")
|
|
|
|
self.widget("ip-config-label").set_text(label)
|
|
|
|
def get_config_ip_info(self):
|
|
if not self.widget("ip-label").get_visible():
|
|
return [True, None, None, None, None]
|
|
|
|
if not self.validate_ip_info():
|
|
return [True, None, None, None, None]
|
|
|
|
return self.build_ip_info()
|
|
|
|
def build_ip_info(self):
|
|
def build_ip(addr_str):
|
|
if not addr_str:
|
|
raise ValueError(_("Please enter an IP address"))
|
|
ret = addr_str.rsplit("/", 1)
|
|
address = ret[0]
|
|
prefix = None
|
|
if len(ret) > 1:
|
|
prefix = ret[1]
|
|
return address, prefix
|
|
|
|
is_manual = self.widget("ip-do-manual").get_active()
|
|
|
|
copy_row = uiutil.get_list_selected_row(
|
|
self.widget("ip-copy-interface-combo"))
|
|
|
|
v4_mode = self.widget("ipv4-mode").get_active()
|
|
v4_addr = self.widget("ipv4-address").get_text()
|
|
v4_gate = self.widget("ipv4-gateway").get_text()
|
|
|
|
v6_mode = self.widget("ipv6-mode").get_active()
|
|
v6_auto = self.widget("ipv6-autoconf").get_active()
|
|
v6_gate = self.widget("ipv6-gateway").get_text()
|
|
v6_addrlist = self.get_config_ipv6_addresses()
|
|
|
|
copy_name = None
|
|
proto_xml = None
|
|
ipv4 = None
|
|
ipv6 = None
|
|
|
|
if not is_manual:
|
|
copy_vmmiface = copy_row[1]
|
|
copy_cancopy = copy_row[2]
|
|
if copy_vmmiface and copy_cancopy:
|
|
copy_name = copy_vmmiface.get_name()
|
|
# We always want the inactive protocol XML, which
|
|
# will list the on disk config, not the run time config,
|
|
# which doesn't list DHCP
|
|
proto_xml = copy_vmmiface.get_protocol_xml(inactive=True)
|
|
|
|
else:
|
|
# Build IPv4 Info
|
|
if v4_mode != IP_NONE:
|
|
ipv4 = InterfaceProtocol(self.conn.get_backend())
|
|
ipv4.family = "ipv4"
|
|
ipv4.dhcp = bool(v4_mode == IP_DHCP)
|
|
if not ipv4.dhcp:
|
|
addr, prefix = build_ip(v4_addr)
|
|
if addr:
|
|
ipv4.add_ip(addr, prefix)
|
|
if v4_gate:
|
|
ipv4.gateway = v4_gate
|
|
|
|
# Build IPv6 Info
|
|
if v6_mode != IP_NONE:
|
|
ipv6 = InterfaceProtocol(self.conn.get_backend())
|
|
ipv6.family = "ipv6"
|
|
ipv6.dhcp = bool(v6_mode == IP_DHCP)
|
|
ipv6.autoconf = bool(v6_auto)
|
|
if not ipv6.dhcp:
|
|
if v6_gate:
|
|
ipv6.gateway = v6_gate
|
|
for v6_addr in v6_addrlist:
|
|
addr, prefix = build_ip(v6_addr)
|
|
if addr:
|
|
ipv6.add_ip(addr, prefix)
|
|
|
|
return [is_manual, copy_name, ipv4, ipv6, proto_xml]
|
|
|
|
def ipv6_address_add(self, src):
|
|
src = self.widget("ipv6-address-list")
|
|
model = src.get_model()
|
|
model.append(["Insert address/prefix"])
|
|
|
|
def ipv6_address_remove(self, src):
|
|
treepath = self.get_config_ipv6_address_selection()
|
|
src = self.widget("ipv6-address-list")
|
|
model = src.get_model()
|
|
if treepath is not None:
|
|
del(model[treepath])
|
|
|
|
def ipv6_address_edited(self, src, path, new_text):
|
|
src = self.widget("ipv6-address-list")
|
|
model = src.get_model()
|
|
row = model[path]
|
|
row[0] = new_text
|
|
|
|
def ipv6_address_selected(self, src=None):
|
|
ignore = src
|
|
treepath = self.get_config_ipv6_address_selection()
|
|
has_selection = (treepath is not None)
|
|
|
|
self.widget("ipv6-address-remove").set_sensitive(has_selection)
|
|
|
|
|
|
#######################
|
|
# Notebook navigation #
|
|
#######################
|
|
|
|
def back(self, src):
|
|
ignore = src
|
|
notebook = self.widget("pages")
|
|
curpage = notebook.get_current_page()
|
|
notebook.set_current_page(curpage - 1)
|
|
|
|
def forward(self, ignore):
|
|
notebook = self.widget("pages")
|
|
curpage = notebook.get_current_page()
|
|
|
|
if self.validate(notebook.get_current_page()) is not True:
|
|
return
|
|
|
|
self.widget("forward").grab_focus()
|
|
notebook.set_current_page(curpage + 1)
|
|
|
|
def page_changed(self, ignore1, ignore2, pagenum):
|
|
next_page = pagenum + 1
|
|
# Update page number
|
|
page_lbl = ("<span color='#59B0E2'>%s</span>" %
|
|
_("Step %(current_page)d of %(max_page)d") %
|
|
{'current_page': next_page, 'max_page': PAGE_DETAILS + 1})
|
|
self.widget("header-pagenum").set_markup(page_lbl)
|
|
|
|
if pagenum == 0:
|
|
self.widget("back").set_sensitive(False)
|
|
else:
|
|
self.widget("back").set_sensitive(True)
|
|
|
|
if pagenum == PAGE_DETAILS:
|
|
self.populate_details_page()
|
|
self.widget("forward").hide()
|
|
self.widget("finish").show()
|
|
self.widget("finish").grab_focus()
|
|
|
|
else:
|
|
self.widget("forward").show()
|
|
self.widget("finish").hide()
|
|
|
|
def validate(self, pagenum):
|
|
try:
|
|
if pagenum == PAGE_TYPE:
|
|
# Nothing to validate
|
|
return True
|
|
elif pagenum == PAGE_DETAILS:
|
|
return self.validate_details_page()
|
|
|
|
except Exception as e:
|
|
self.err.show_err(_("Uncaught error validating install "
|
|
"parameters: %s") % str(e))
|
|
return
|
|
|
|
def validate_details_page(self):
|
|
itype = self.get_config_interface_type()
|
|
name = self.get_config_interface_name()
|
|
start = self.get_config_interface_startmode()
|
|
ifaces = self.get_config_selected_interfaces()
|
|
|
|
if not name:
|
|
return self.err.val_err(_("An interface name is required."))
|
|
|
|
if (itype != Interface.INTERFACE_TYPE_BRIDGE and
|
|
len(ifaces) == 0):
|
|
return self.err.val_err(_("An interface must be selected"))
|
|
|
|
try:
|
|
iobj = Interface(self.conn.get_backend())
|
|
iobj.type = itype
|
|
iobj.name = name
|
|
iobj.start_mode = start
|
|
check_conflict = False
|
|
|
|
# Pull info from selected interfaces
|
|
if (itype == Interface.INTERFACE_TYPE_BRIDGE or
|
|
itype == Interface.INTERFACE_TYPE_BOND):
|
|
for row in ifaces:
|
|
if row[INTERFACE_ROW_IS_DEFINED]:
|
|
vmmiface = self.conn.get_interface(
|
|
row[INTERFACE_ROW_NAME])
|
|
|
|
# Use the inactive XML, which drops a bunch
|
|
# elements that might cause netcf to choke on
|
|
# for a sub-interface
|
|
xml = vmmiface.get_xmlobj(
|
|
inactive=True).get_xml_config()
|
|
else:
|
|
xml = row[INTERFACE_ROW_KEY].get_xml_config()
|
|
|
|
child = Interface(self.conn.get_backend(), parsexml=xml)
|
|
iobj.add_interface(child)
|
|
check_conflict = True
|
|
|
|
elif itype == Interface.INTERFACE_TYPE_VLAN:
|
|
iobj.parent_interface = ifaces[0][INTERFACE_ROW_NAME]
|
|
|
|
elif itype == Interface.INTERFACE_TYPE_ETHERNET:
|
|
iobj.macaddr = ifaces[0][INTERFACE_ROW_MAC]
|
|
|
|
# Warn about defined interfaces
|
|
defined_ifaces = ""
|
|
if check_conflict:
|
|
for row in ifaces:
|
|
if not row[INTERFACE_ROW_IS_DEFINED]:
|
|
continue
|
|
|
|
if defined_ifaces:
|
|
defined_ifaces += ", "
|
|
defined_ifaces += row[INTERFACE_ROW_NAME]
|
|
|
|
if defined_ifaces:
|
|
ret = self.err.yes_no(
|
|
_("The following interface(s) are already "
|
|
"configured:\n\n%s\n\nUsing these may overwrite "
|
|
"their existing configuration. Are you sure you "
|
|
"want to use the selected interface(s)?") %
|
|
defined_ifaces)
|
|
if not ret:
|
|
return ret
|
|
|
|
# Validate IP info (get_config validates for us)
|
|
(is_manual, copy_name, ipv4,
|
|
ipv6, proto_xml) = self.get_config_ip_info()
|
|
ignore = copy_name
|
|
|
|
if is_manual:
|
|
if ipv4:
|
|
iobj.add_protocol(ipv4)
|
|
if ipv6:
|
|
iobj.add_protocol(ipv6)
|
|
else:
|
|
for proto in proto_xml:
|
|
iobj.add_protocol(InterfaceProtocol(
|
|
self.conn.get_backend(),
|
|
parsexml=proto.get_xml_config()))
|
|
|
|
if itype == Interface.INTERFACE_TYPE_BRIDGE:
|
|
ret = self.validate_bridge(iobj)
|
|
elif itype == Interface.INTERFACE_TYPE_BOND:
|
|
ret = self.validate_bond(iobj)
|
|
elif itype == Interface.INTERFACE_TYPE_VLAN:
|
|
ret = self.validate_vlan(iobj)
|
|
elif itype == Interface.INTERFACE_TYPE_ETHERNET:
|
|
ret = self.validate_ethernet(iobj)
|
|
|
|
if not ret:
|
|
return ret
|
|
|
|
iobj.get_xml_config()
|
|
iobj.validate()
|
|
|
|
self.interface = iobj
|
|
except Exception as e:
|
|
return self.err.val_err(
|
|
_("Error setting interface parameters."), e)
|
|
|
|
return True
|
|
|
|
def validate_bridge(self, iobj):
|
|
delay = self.widget("bridge-delay").get_value()
|
|
stp = self.widget("bridge-stp").get_active()
|
|
|
|
iobj.stp = stp
|
|
iobj.delay = float(delay)
|
|
|
|
return True
|
|
|
|
|
|
def validate_bond(self, iobj):
|
|
mode = uiutil.get_list_selection(self.widget("bond-mode"), column=1)
|
|
mon = uiutil.get_list_selection(
|
|
self.widget("bond-monitor-mode"), column=1)
|
|
arp_val = uiutil.get_list_selection(self.widget("arp-validate"))
|
|
mii_car = uiutil.get_list_selection(self.widget("mii-carrier"))
|
|
|
|
# ARP params
|
|
arp_int = self.widget("arp-interval").get_value()
|
|
arp_tar = self.widget("arp-target").get_text()
|
|
|
|
# MII params
|
|
mii_freq = self.widget("mii-frequency").get_value()
|
|
mii_up = self.widget("mii-updelay").get_value()
|
|
mii_down = self.widget("mii-downdelay").get_value()
|
|
|
|
iobj.bond_mode = mode
|
|
|
|
if not mon:
|
|
# No monitor params, just return
|
|
return True
|
|
|
|
if mon == "arpmon":
|
|
iobj.arp_validate_mode = arp_val
|
|
iobj.arp_interval = int(arp_int)
|
|
iobj.arp_target = arp_tar or None
|
|
|
|
elif mon == "miimon":
|
|
iobj.mii_carrier_mode = mii_car
|
|
iobj.mii_frequency = int(mii_freq)
|
|
iobj.mii_updelay = int(mii_up)
|
|
iobj.mii_downdelay = int(mii_down)
|
|
|
|
return True
|
|
|
|
|
|
def validate_vlan(self, iobj):
|
|
idx = uiutil.spin_get_helper(self.widget("vlan-tag"))
|
|
|
|
iobj.tag = int(idx)
|
|
return True
|
|
|
|
|
|
def validate_ethernet(self, iobj):
|
|
ignore = iobj
|
|
return True
|
|
|
|
|
|
def validate_ip_info(self):
|
|
try:
|
|
self.build_ip_info()
|
|
except Exception as e:
|
|
self.err.show_err(_("Error validating IP configuration: %s") %
|
|
str(e))
|
|
return False
|
|
|
|
return True
|
|
|
|
####################
|
|
# Dialog callbacks #
|
|
####################
|
|
|
|
def bridge_config_finish(self, ignore1=None, ignore2=None):
|
|
self.update_bridge_desc()
|
|
self.bridge_config.hide()
|
|
return 1
|
|
|
|
def bond_config_finish(self, ignore1=None, ignore2=None):
|
|
self.update_bond_desc()
|
|
self.bond_config.hide()
|
|
return 1
|
|
|
|
def ip_config_finish(self, ignore1=None, ignore2=None):
|
|
if not self.validate_ip_info():
|
|
return
|
|
self.update_ip_desc()
|
|
self.ip_config.hide()
|
|
return 1
|
|
|
|
#####################
|
|
# Creation routines #
|
|
#####################
|
|
|
|
def _finish_cb(self, error, details):
|
|
self.reset_finish_cursor()
|
|
|
|
if error:
|
|
error = _("Error creating interface: '%s'") % error
|
|
self.err.show_err(error,
|
|
details=details)
|
|
else:
|
|
self.conn.schedule_priority_tick(polliface=True)
|
|
self.close()
|
|
|
|
def finish(self, src):
|
|
ignore = src
|
|
|
|
# Validate the final page
|
|
page = self.widget("pages").get_current_page()
|
|
if self.validate(page) is not True:
|
|
return False
|
|
|
|
activate = self.widget("interface-activate").get_active()
|
|
|
|
# Start the install
|
|
self.set_finish_cursor()
|
|
progWin = vmmAsyncJob(self.do_install, [activate],
|
|
self._finish_cb, [],
|
|
_("Creating virtual interface"),
|
|
_("The virtual interface is now being created."),
|
|
self.topwin)
|
|
progWin.run()
|
|
|
|
def do_install(self, asyncjob, activate):
|
|
meter = asyncjob.get_meter()
|
|
self.interface.install(meter, create=activate)
|
|
logging.debug("Install completed")
|