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()