class NetworkView(BaseView):
title = _("Network connections")
excerpt = _("Configure at least one interface this server can use to talk "
"to other machines, and which preferably provides sufficient "
"access for updates.")
def __init__(self, model, controller):
self.model = model
self.controller = controller
self.dev_to_table = {}
self.cur_netdevs = []
self.error = Text("", align='center')
self.device_colspecs = {
0: ColSpec(rpad=1),
3: ColSpec(min_width=15),
4: ColSpec(can_shrink=True, rpad=1),
}
self.device_pile = Pile(self._build_model_inputs())
self._create_bond_btn = menu_btn(_("Create bond"),
on_press=self._create_bond)
bp = button_pile([self._create_bond_btn])
bp.align = 'left'
rows = [
self.device_pile,
bp,
]
self.buttons = button_pile([
done_btn("TBD", on_press=self.done), # See _route_watcher
back_btn(_("Back"), on_press=self.cancel),
])
self.bottom = Pile([
('pack', self.buttons),
])
self.controller.network_event_receiver.add_default_route_watcher(
self._route_watcher)
self.error_showing = False
super().__init__(
screen(rows=rows,
buttons=self.bottom,
focus_buttons=True,
excerpt=_(self.excerpt)))
_action_INFO = _stretchy_shower(ViewInterfaceInfo)
_action_EDIT_WLAN = _stretchy_shower(NetworkConfigureWLANStretchy)
_action_EDIT_IPV4 = _stretchy_shower(EditNetworkStretchy, 4)
_action_EDIT_IPV6 = _stretchy_shower(EditNetworkStretchy, 6)
_action_EDIT_BOND = _stretchy_shower(BondStretchy)
_action_ADD_VLAN = _stretchy_shower(AddVlanStretchy)
def _action_DELETE(self, name, device):
with self.controller.context.child(name):
touched_devs = set()
if device.type == "bond":
for name in device.config['interfaces']:
touched_devs.add(self.model.get_netdev_by_name(name))
device.config = None
self.del_link(device)
for dev in touched_devs:
self.update_link(dev)
self.controller.apply_config()
def _action(self, sender, action, device):
action, meth = action
meth("{}/{}".format(device.name, action.name), device)
def _route_watcher(self, routes):
log.debug('view route_watcher %s', routes)
if routes:
label = _("Done")
else:
label = _("Continue without network")
self.buttons.base_widget[0].set_label(label)
self.buttons.width = max(
14,
widget_width(self.buttons.base_widget[0]),
widget_width(self.buttons.base_widget[1]),
)
def show_apply_spinner(self):
s = Spinner(self.controller.app.aio_loop)
s.start()
c = TablePile([
TableRow([
Text(_("Applying changes")),
s,
]),
],
align='center')
self.bottom.contents[0:0] = [
(c, self.bottom.options()),
(Text(""), self.bottom.options()),
]
def hide_apply_spinner(self):
if len(self.bottom.contents) > 2:
self.bottom.contents[0:2] = []
def _notes_for_device(self, dev):
notes = []
if dev.type == "eth" and not dev.info.is_connected:
notes.append(_("not connected"))
for dev2 in self.model.get_all_netdevs():
if dev2.type != "bond":
continue
if dev.name in dev2.config.get('interfaces', []):
notes.append(
_("enslaved to {device}").format(device=dev2.name))
break
if notes:
notes = ", ".join(notes)
else:
notes = '-'
return notes
def _address_rows_for_device(self, dev):
address_info = []
dhcp_addresses = dev.dhcp_addresses()
for v in 4, 6:
if dev.dhcp_enabled(v):
label = Text("DHCPv{v}".format(v=v))
addrs = dhcp_addresses.get(v)
if addrs:
address_info.extend([(label, Text(addr))
for addr in addrs])
elif dev.dhcp_state(v) == "PENDING":
s = Spinner(self.controller.app.aio_loop, align='left')
s.rate = 0.3
s.start()
address_info.append((label, s))
elif dev.dhcp_state(v) == "TIMEDOUT":
address_info.append((label, Text(_("timed out"))))
elif dev.dhcp_state(v) == "RECONFIGURE":
address_info.append((label, Text("-")))
else:
address_info.append((label,
Text(
_("unknown state {state}".format(
state=dev.dhcp_state(v))))))
else:
addrs = []
for ip in dev.config.get('addresses', []):
if addr_version(ip) == v:
addrs.append(str(ip))
if addrs:
address_info.append(
(Text(_('static')), Text(', '.join(addrs))))
if len(address_info) == 0:
# Do not show an interface as disabled if it is part of a bond or
# has a vlan on it.
if not dev.is_used:
reason = dev.disabled_reason
if reason is None:
reason = ""
address_info.append((Text(_("disabled")), Text(reason)))
rows = []
for label, value in address_info:
rows.append(TableRow([Text(""), label, (2, value)]))
return rows
def new_link(self, new_dev):
log.debug("new_link %s %s %s", new_dev.name, new_dev.ifindex,
(new_dev in self.cur_netdevs))
if new_dev in self.dev_to_table:
self.update_link(new_dev)
return
for i, cur_dev in enumerate(self.cur_netdevs):
if cur_dev.name > new_dev.name:
netdev_i = i
break
else:
netdev_i = len(self.cur_netdevs)
w = self._device_widget(new_dev, netdev_i)
self.device_pile.contents[netdev_i + 1:netdev_i + 1] = [
(w, self.device_pile.options('pack'))
]
def update_link(self, dev):
log.debug("update_link %s %s %s", dev.name, dev.ifindex,
(dev in self.cur_netdevs))
if dev not in self.cur_netdevs:
return
# Update the display of dev to represent the current state.
#
# The easiest way of doing this would be to just create a new table
# widget for the device and replace the current one with it. But that
# is jarring if the menu for the current device is open, so instead we
# overwrite the content of the first (menu) row of the old table with
# the contents of the first row of the new table, and replace all other
# rows of the old table with new content (which is OK as they cannot be
# focused).
old_table = self.dev_to_table[dev]
first_row = old_table.table_rows[0].base_widget
first_row.cells[1][1].set_text(dev.name)
first_row.cells[2][1].set_text(dev.type)
first_row.cells[3][1].set_text(self._notes_for_device(dev))
old_table.remove_rows(1, len(old_table.table_rows))
old_table.insert_rows(1, self._address_rows_for_device(dev))
def _remove_row(self, netdev_i):
# MonitoredFocusList clamps the focus position to the new
# length of the list when you remove elements but it doesn't
# check that that the element it moves the focus to is
# selectable...
new_length = len(self.device_pile.contents) - 1
refocus = self.device_pile.focus_position >= new_length
del self.device_pile.contents[netdev_i]
if refocus:
self.device_pile._select_last_selectable()
else:
while not self.device_pile.focus.selectable():
self.device_pile.focus_position += 1
self.device_pile.focus._select_first_selectable()
def del_link(self, dev):
log.debug("del_link %s %s %s", dev.name, dev.ifindex,
(dev in self.cur_netdevs))
# If a virtual device disappears while we still have config
# for it, we assume it will be back soon.
if dev.is_virtual and dev.config is not None:
return
if dev in self.cur_netdevs:
netdev_i = self.cur_netdevs.index(dev)
self._remove_row(netdev_i + 1)
del self.cur_netdevs[netdev_i]
del self.dev_to_table[dev]
if isinstance(self._w, StretchyOverlay):
stretchy = self._w.stretchy
if getattr(stretchy, 'device', None) is dev:
self.remove_overlay()
def _device_widget(self, dev, netdev_i=None):
# Create the widget for a nic. This consists of a Pile containing a
# table, an info line and a blank line. The first row of the table is
# the one that can be focused and has a menu for manipulating the nic,
# the other rows summarize its address config.
# [ name type notes ▸ ] \
# address info | <- table
# more address info /
# mac / vendor info / model info
# <blank line>
if netdev_i is None:
netdev_i = len(self.cur_netdevs)
self.cur_netdevs[netdev_i:netdev_i] = [dev]
actions = []
for action in NetDevAction:
meth = getattr(self, '_action_' + action.name)
opens_dialog = getattr(meth, 'opens_dialog', False)
if dev.supports_action(action):
actions.append(
(_(action.value), True, (action, meth), opens_dialog))
menu = ActionMenu(actions)
connect_signal(menu, 'action', self._action, dev)
trows = [
make_action_menu_row([
Text("["),
Text(dev.name),
Text(dev.type),
Text(self._notes_for_device(dev), wrap='clip'),
menu,
Text("]"),
], menu)
] + self._address_rows_for_device(dev)
table = TablePile(trows, colspecs=self.device_colspecs, spacing=2)
self.dev_to_table[dev] = table
table.bind(self.heading_table)
if dev.type == "vlan":
info = _("VLAN {id} on interface {link}").format(**dev.config)
elif dev.type == "bond":
info = _("bond master for {interfaces}").format(
interfaces=', '.join(dev.config['interfaces']))
else:
info = " / ".join(
[dev.info.hwaddr, dev.info.vendor, dev.info.model])
return Pile([
('pack', table),
('pack', Color.info_minor(Text(" " + info))),
('pack', Text("")),
])
def _build_model_inputs(self):
self.heading_table = TablePile([
TableRow([
Color.info_minor(Text(header)) for header in [
"",
"NAME",
"TYPE",
"NOTES",
"",
]
])
],
spacing=2,
colspecs=self.device_colspecs)
rows = [self.heading_table]
for dev in self.model.get_all_netdevs():
rows.append(self._device_widget(dev))
return rows
def _create_bond(self, sender=None):
stretchy = BondStretchy(self)
stretchy.attach_context(self.controller.context.child("add_bond"))
self.show_stretchy_overlay(stretchy)
def show_network_error(self, action, info=None):
self.error_showing = True
self.bottom.contents[0:0] = [
(Color.info_error(self.error), self.bottom.options()),
(Text(""), self.bottom.options()),
]
if action == 'stop-networkd':
exc = info[0]
self.error.set_text("Stopping systemd-networkd-failed: %r" %
(exc.stderr, ))
elif action == 'apply':
self.error.set_text("Network configuration could not be applied; "
"please verify your settings.")
elif action == 'timeout':
self.error.set_text("Network configuration timed out; "
"please verify your settings.")
elif action == 'down':
self.error.set_text("Downing network interfaces failed.")
elif action == 'add-vlan':
self.error.set_text("Failed to add a VLAN tag.")
elif action == 'rm-dev':
self.error.set_text("Failed to delete a virtual interface.")
else:
self.error.set_text("An unexpected error has occurred; "
"please verify your settings.")
def done(self, result=None):
if self.error_showing:
self.bottom.contents[0:2] = []
self.controller.network_event_receiver.remove_default_route_watcher(
self._route_watcher)
self.controller.done()
def cancel(self, button=None):
self.controller.network_event_receiver.remove_default_route_watcher(
self._route_watcher)
self.controller.cancel()
class NetworkView(BaseView):
title = _("Network connections")
excerpt = _("Configure at least one interface this server can use to talk "
"to other machines, and which preferably provides sufficient "
"access for updates.")
def __init__(self,
controller,
netdev_infos,
wlan_support_install_state="NOT_NEEDED"):
self.controller = controller
self.dev_name_to_table = {}
self.cur_netdev_names = []
self.error = Text("", align='center')
self.device_colspecs = {
0: ColSpec(rpad=1),
3: ColSpec(min_width=15),
4: ColSpec(can_shrink=True, rpad=1),
}
self.heading_table = TablePile([
TableRow([
Color.info_minor(Text(header)) for header in [
"",
"NAME",
"TYPE",
"NOTES",
"",
]
])
],
spacing=2,
colspecs=self.device_colspecs)
self.device_pile = Pile([self.heading_table])
for dev_info in netdev_infos:
self.new_link(dev_info)
self._create_bond_btn = menu_btn(_("Create bond"),
on_press=self._create_bond)
bp = button_pile([self._create_bond_btn])
bp.align = 'left'
rows = [
self.device_pile,
bp,
]
self.buttons = button_pile([
done_btn("TBD", on_press=self.done), # See _route_watcher
back_btn(_("Back"), on_press=self.cancel),
])
self.bottom = Pile([
('pack', self.buttons),
])
self.wlan_support_install_state_showing = False
self.error_showing = False
self.update_for_wlan_support_install_state(wlan_support_install_state)
super().__init__(
screen(rows=rows,
buttons=self.bottom,
focus_buttons=True,
excerpt=_(self.excerpt)))
async def _show_INFO(self, name):
info = await self.controller.app.wait_with_text_dialog(
self.controller.get_info_for_netdev(name),
"Loading info",
can_cancel=True)
stretchy = ViewInterfaceInfo(self, name, info)
stretchy.attach_context(self.controller.context.child("INFO"))
self.show_stretchy_overlay(stretchy)
def _action_INFO(self, name, dev_info):
self.controller.app.aio_loop.create_task(self._show_INFO(
dev_info.name))
_action_INFO.opens_dialog = True
_action_EDIT_WLAN = _stretchy_shower(NetworkConfigureWLANStretchy)
_action_EDIT_IPV4 = _stretchy_shower(EditNetworkStretchy, 4)
_action_EDIT_IPV6 = _stretchy_shower(EditNetworkStretchy, 6)
_action_ADD_VLAN = _stretchy_shower(AddVlanStretchy)
def _action_EDIT_BOND(self, name, dev_info):
stretchy = BondStretchy(self, dev_info,
self.get_candidate_bond_member_names())
stretchy.attach_context(self.controller.context.child(name))
self.show_stretchy_overlay(stretchy)
_action_EDIT_BOND.opens_dialog = True
def _action_DELETE(self, name, dev_info):
with self.controller.context.child(name):
self.controller.delete_link(dev_info.name)
self.del_link(dev_info)
def _action(self, sender, action, netdev_table):
action, meth = action
dev_info = netdev_table.dev_info
meth("{}/{}".format(dev_info.name, action.name), dev_info)
def update_default_routes(self, routes):
log.debug('view route_watcher %s', routes)
if routes:
label = _("Done")
else:
label = _("Continue without network")
self.buttons.base_widget[0].set_label(label)
self.buttons.width = max(
14,
widget_width(self.buttons.base_widget[0]),
widget_width(self.buttons.base_widget[1]),
)
def show_apply_spinner(self):
s = Spinner(self.controller.app.aio_loop)
s.start()
c = TablePile([
TableRow([
Text(_("Applying changes")),
s,
]),
],
align='center')
self.bottom.contents[0:0] = [
(c, self.bottom.options()),
(Text(""), self.bottom.options()),
]
def hide_apply_spinner(self):
if len(self.bottom.contents) > 2:
self.bottom.contents[0:2] = []
def new_link(self, new_dev_info):
log.debug("new_link %s %s", new_dev_info.name,
(new_dev_info.name in self.cur_netdev_names))
if new_dev_info.name in self.dev_name_to_table:
self.update_link(new_dev_info)
return
self.cur_netdev_names.append(new_dev_info.name)
self.cur_netdev_names.sort()
netdev_i = self.cur_netdev_names.index(new_dev_info.name)
device_table = NetworkDeviceTable(self, new_dev_info)
self.dev_name_to_table[new_dev_info.name] = device_table
self.device_pile.contents[netdev_i + 1:netdev_i + 1] = [
(device_table, self.device_pile.options('pack'))
]
def update_link(self, dev_info):
if isinstance(self._w, StretchyOverlay):
if hasattr(self._w.stretchy, 'update_link'):
self._w.stretchy.update_link(dev_info)
log.debug("update_link %s %s", dev_info.name,
(dev_info.name in self.cur_netdev_names))
if dev_info.name not in self.cur_netdev_names:
return
self.dev_name_to_table[dev_info.name].update(dev_info)
def _remove_row(self, netdev_i):
# MonitoredFocusList clamps the focus position to the new
# length of the list when you remove elements but it doesn't
# check that that the element it moves the focus to is
# selectable...
new_length = len(self.device_pile.contents) - 1
refocus = self.device_pile.focus_position >= new_length
del self.device_pile.contents[netdev_i]
if refocus:
self.device_pile._select_last_selectable()
else:
while not self.device_pile.focus.selectable():
self.device_pile.focus_position += 1
self.device_pile.focus._select_first_selectable()
def del_link(self, dev_info):
log.debug("del_link %s %s", dev_info.name,
(dev_info.name in self.cur_netdev_names))
# If a virtual device disappears while we still have config
# for it, we assume it will be back soon.
if dev_info.is_virtual and dev_info.has_config:
return
if dev_info.name in self.cur_netdev_names:
netdev_i = self.cur_netdev_names.index(dev_info.name)
self._remove_row(netdev_i + 1)
del self.cur_netdev_names[netdev_i]
del self.dev_name_to_table[dev_info.name]
if isinstance(self._w, StretchyOverlay):
stretchy = self._w.stretchy
if getattr(stretchy, 'device', None) is dev_info:
self.remove_overlay()
def get_candidate_bond_member_names(self):
names = []
for table in self.dev_name_to_table.values():
dev_info = table.dev_info
if dev_info.type in ("vlan", "bond"):
continue
if dev_info.bond_master is not None:
continue
names.append(dev_info.name)
return names
def _create_bond(self, sender=None):
stretchy = BondStretchy(self, None,
self.get_candidate_bond_member_names())
stretchy.attach_context(self.controller.context.child("add_bond"))
self.show_stretchy_overlay(stretchy)
def update_for_wlan_support_install_state(self, state):
if state == "NOT_NEEDED":
return
if self.error_showing:
start_i = 2
else:
start_i = 0
if self.wlan_support_install_state_showing:
end_i = start_i + 2
else:
end_i = start_i
self.wlan_support_install_state_showing = True
text = wlan_support_install_state_texts[state]
self.bottom.contents[start_i:end_i] = [
(Text(rewrap(text), align='center'), self.bottom.options()),
(Text(""), self.bottom.options()),
]
def show_network_error(self, action, info=None):
if not self.error_showing:
start_i = end_i = 0
self.error_showing = True
else:
start_i = 0
end_i = 2
self.bottom.contents[start_i:end_i] = [
(Color.info_error(self.error), self.bottom.options()),
(Text(""), self.bottom.options()),
]
if action == 'stop-networkd':
exc = info[0]
self.error.set_text("Stopping systemd-networkd-failed: %r" %
(exc.stderr, ))
elif action == 'apply':
self.error.set_text("Network configuration could not be applied; "
"please verify your settings.")
elif action == 'timeout':
self.error.set_text("Network configuration timed out; "
"please verify your settings.")
elif action == 'down':
self.error.set_text("Downing network interfaces failed.")
elif action == 'add-vlan':
self.error.set_text("Failed to add a VLAN tag.")
elif action == 'rm-dev':
self.error.set_text("Failed to delete a virtual interface.")
else:
self.error.set_text("An unexpected error has occurred; "
"please verify your settings.")
def done(self, result=None):
if self.error_showing:
self.bottom.contents[0:2] = []
self.controller.done()
def cancel(self, button=None):
self.controller.cancel()
