853 lines
36 KiB
Python
853 lines
36 KiB
Python
#!/usr/bin/python3
|
|
#
|
|
# Copyright (C) 2022 Canonical, Ltd.
|
|
# Author: Lukas Märdian <slyon@ubuntu.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; version 3.
|
|
#
|
|
# 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, see <http://www.gnu.org/licenses/>.
|
|
|
|
'''netplan status command line'''
|
|
|
|
import json
|
|
import logging
|
|
import re
|
|
from netplan.netdef import NetplanRoute
|
|
|
|
import yaml
|
|
|
|
from .. import utils
|
|
from ..state import NetplanConfigState, SystemConfigState, JSON
|
|
from ..state_diff import DiffJSONEncoder, NetplanDiffState
|
|
|
|
|
|
MATCH_TAGS = re.compile(r'\[([a-z0-9]+)\].*\[\/\1\]')
|
|
RICH_OUTPUT = False
|
|
try:
|
|
from rich.console import Console
|
|
from rich.highlighter import RegexHighlighter
|
|
from rich.theme import Theme
|
|
|
|
class NetplanHighlighter(RegexHighlighter):
|
|
base_style = 'netplan.'
|
|
highlights = [
|
|
r'(^|[\s\/])(?P<int>\d+)([\s:]?\s|$)',
|
|
r'(?P<str>(\"|\').+(\"|\'))',
|
|
]
|
|
RICH_OUTPUT = True
|
|
except ImportError: # pragma: nocover (we mock RICH_OUTPUT, ignore the logging)
|
|
logging.debug("python3-rich not found, falling back to plain output")
|
|
|
|
|
|
class NetplanStatus(utils.NetplanCommand):
|
|
def __init__(self):
|
|
super().__init__(command_id='status',
|
|
description='Query networking state of the running system',
|
|
leaf=True)
|
|
self.all = False
|
|
self.state_diff = None
|
|
self.route_lookup_table_names = {}
|
|
|
|
def run(self):
|
|
self.parser.add_argument('ifname', nargs='?', type=str, default=None,
|
|
help='Show only this interface')
|
|
self.parser.add_argument('-a', '--all', action='store_true',
|
|
help='Show all interface data (incl. inactive)')
|
|
self.parser.add_argument('-v', '--verbose', action='store_true',
|
|
help='Show extra information')
|
|
self.parser.add_argument('-f', '--format', default='tabular',
|
|
help='Output in machine readable `json` or `yaml` format')
|
|
self.parser.add_argument('--diff', action='store_true',
|
|
help='Show the differences between the system\'s and netplan\'s states')
|
|
self.parser.add_argument('--diff-only', action='store_true',
|
|
help='Only show the differences between the system\'s and netplan\'s states')
|
|
self.parser.add_argument('--root-dir',
|
|
help='Search for configuration files in this root directory instead of /')
|
|
|
|
self.func = self.command
|
|
self.parse_args()
|
|
self.run_command()
|
|
|
|
def _create_pretty_print(self, _console_width):
|
|
if RICH_OUTPUT:
|
|
# TODO: Use a proper (subiquity?) color palette
|
|
theme = Theme({
|
|
'netplan.int': 'bold cyan',
|
|
'netplan.str': 'yellow',
|
|
'muted': 'grey62',
|
|
'online': 'green bold',
|
|
'offline': 'red bold',
|
|
'unknown': 'yellow bold',
|
|
'highlight': 'bold'
|
|
})
|
|
if self.diff:
|
|
theme = Theme({
|
|
'netplan.int': 'grey62',
|
|
'netplan.str': 'grey62',
|
|
'muted': 'grey62',
|
|
'online': 'green bold',
|
|
'offline': 'red bold',
|
|
'unknown': 'yellow bold',
|
|
'highlight': 'bold'
|
|
})
|
|
|
|
console = Console(highlighter=NetplanHighlighter(), theme=theme,
|
|
width=_console_width, emoji=False)
|
|
pprint = console.print
|
|
else:
|
|
pprint = self.plain_print
|
|
|
|
return pprint
|
|
|
|
def _get_interface_diff(self, ifname) -> dict:
|
|
if self.state_diff:
|
|
if diff := self.state_diff['interfaces'].get(ifname):
|
|
if diff.get('system_state') or diff.get('netplan_state'):
|
|
return diff
|
|
return {}
|
|
|
|
def _is_interface_missing_in_netplan(self, ifname) -> bool:
|
|
if self.state_diff:
|
|
if missing := self.state_diff.get('missing_interfaces_netplan'):
|
|
if ifname in missing:
|
|
return True
|
|
return False
|
|
|
|
def _get_missing_property_list(self, ifname: str, state: str, property: str) -> list[str]:
|
|
if self.state_diff:
|
|
if diff := self.state_diff['interfaces'].get(ifname):
|
|
return diff.get(state, {}).get(property, [])
|
|
return []
|
|
|
|
def _get_missing_property_str(self, ifname: str, state: str, property: str) -> str:
|
|
if self.state_diff:
|
|
if diff := self.state_diff['interfaces'].get(ifname):
|
|
return diff.get(state, {}).get(property, '')
|
|
return ''
|
|
|
|
def _get_missing_property_set(self, ifname: str, state: str, property: str) -> set:
|
|
if self.state_diff:
|
|
if diff := self.state_diff['interfaces'].get(ifname):
|
|
return diff.get(state, {}).get(property, set())
|
|
return set()
|
|
|
|
def _get_missing_property_bool(self, ifname: str, state: str, property: str) -> bool:
|
|
if self.state_diff:
|
|
if diff := self.state_diff['interfaces'].get(ifname):
|
|
return diff.get(state, {}).get(property, False)
|
|
return False
|
|
|
|
def _get_missing_netplan_addresses(self, ifname) -> list[str]:
|
|
return self._get_missing_property_list(ifname, 'netplan_state', 'missing_addresses')
|
|
|
|
def _get_missing_system_nameservers(self, ifname) -> list[str]:
|
|
return self._get_missing_property_list(ifname, 'system_state', 'missing_nameservers_addresses')
|
|
|
|
def _get_missing_netplan_nameservers(self, ifname) -> list[str]:
|
|
return self._get_missing_property_list(ifname, 'netplan_state', 'missing_nameservers_addresses')
|
|
|
|
def _get_missing_netplan_search(self, ifname) -> list[str]:
|
|
return self._get_missing_property_list(ifname, 'netplan_state', 'missing_nameservers_search')
|
|
|
|
def _get_missing_system_search(self, ifname) -> list[str]:
|
|
return self._get_missing_property_list(ifname, 'system_state', 'missing_nameservers_search')
|
|
|
|
def _get_missing_system_macaddress(self, ifname) -> str:
|
|
return self._get_missing_property_str(ifname, 'system_state', 'missing_macaddress')
|
|
|
|
def _get_missing_netplan_routes(self, ifname) -> set[NetplanRoute]:
|
|
return self._get_missing_property_set(ifname, 'netplan_state', 'missing_routes')
|
|
|
|
def _get_missing_system_routes(self, ifname) -> set[NetplanRoute]:
|
|
return self._get_missing_property_set(ifname, 'system_state', 'missing_routes')
|
|
|
|
def _is_missing_dhcp4_address(self, ifname) -> bool:
|
|
return self._get_missing_property_bool(ifname, 'system_state', 'missing_dhcp4_address')
|
|
|
|
def _is_missing_dhcp6_address(self, ifname) -> bool:
|
|
return self._get_missing_property_bool(ifname, 'system_state', 'missing_dhcp6_address')
|
|
|
|
def _get_missing_system_bond_link(self, ifname) -> str:
|
|
return self._get_missing_property_str(ifname, 'system_state', 'missing_bond_link')
|
|
|
|
def _get_missing_netplan_bond_link(self, ifname) -> str:
|
|
return self._get_missing_property_str(ifname, 'netplan_state', 'missing_bond_link')
|
|
|
|
def _get_missing_system_bridge_link(self, ifname) -> str:
|
|
return self._get_missing_property_str(ifname, 'system_state', 'missing_bridge_link')
|
|
|
|
def _get_missing_netplan_bridge_link(self, ifname) -> str:
|
|
return self._get_missing_property_str(ifname, 'netplan_state', 'missing_bridge_link')
|
|
|
|
def _get_missing_system_vrf_link(self, ifname) -> str:
|
|
return self._get_missing_property_str(ifname, 'system_state', 'missing_vrf_link')
|
|
|
|
def _get_missing_netplan_vrf_link(self, ifname) -> str:
|
|
return self._get_missing_property_str(ifname, 'netplan_state', 'missing_vrf_link')
|
|
|
|
def _get_missing_netplan_members(self, ifname) -> list[str]:
|
|
return self._get_missing_property_list(ifname, 'netplan_state', 'missing_interfaces')
|
|
|
|
def _get_missing_system_members(self, ifname) -> list[str]:
|
|
return self._get_missing_property_list(ifname, 'system_state', 'missing_interfaces')
|
|
|
|
def _get_missing_system_interfaces(self) -> dict:
|
|
if self.state_diff:
|
|
return self.state_diff.get('missing_interfaces_system', {})
|
|
return {}
|
|
|
|
def _has_diff(self, ifname) -> bool:
|
|
if self._is_interface_missing_in_netplan(ifname):
|
|
return True
|
|
if self.state_diff:
|
|
if diff := self.state_diff['interfaces'].get(ifname):
|
|
if diff.get('system_state') or diff.get('netplan_state'):
|
|
return True
|
|
return False
|
|
|
|
def _display_global_state(self, data):
|
|
global_state = data.get('netplan-global-state', {})
|
|
self.pprint(('{title:>'+self.PAD+'} {value}').format(
|
|
title='Online state:',
|
|
value='[online]online[/online]' if global_state.get('online', False) else '[offline]offline[/offline]',
|
|
))
|
|
ns = global_state.get('nameservers', {})
|
|
dns_addr: list = ns.get('addresses', [])
|
|
dns_mode: str = ns.get('mode')
|
|
dns_search: list = ns.get('search', [])
|
|
if dns_addr:
|
|
for i, val in enumerate(dns_addr):
|
|
self.pprint(('{title:>'+self.PAD+'} {value}[muted]{mode}[/muted]').format(
|
|
title='DNS Addresses:' if i == 0 else '',
|
|
value=val,
|
|
mode=' ({})'.format(dns_mode) if dns_mode else '',
|
|
))
|
|
if dns_search:
|
|
for i, val in enumerate(dns_search):
|
|
self.pprint(('{title:>'+self.PAD+'} {value}').format(
|
|
title='DNS Search:' if i == 0 else '',
|
|
value=val,
|
|
))
|
|
self.pprint()
|
|
|
|
def _display_interface_header(self, ifname: str, data):
|
|
state = data.get('operstate', 'UNKNOWN') + '/' + data.get('adminstate', 'UNKNOWN')
|
|
scolor = 'unknown'
|
|
if state == 'UP/UP':
|
|
state = 'UP'
|
|
scolor = 'online'
|
|
elif state == 'DOWN/DOWN':
|
|
state = 'DOWN'
|
|
scolor = 'offline'
|
|
full_type = data.get('type', 'other')
|
|
ssid = data.get('ssid')
|
|
tunnel_mode = data.get('tunnel_mode')
|
|
if full_type == 'wifi' and ssid:
|
|
full_type += ('/"' + ssid + '"')
|
|
elif full_type == 'tunnel' and tunnel_mode:
|
|
full_type += ('/' + tunnel_mode)
|
|
|
|
format = '[{col}]●[/{col}] {idx:>2}: {name} {type} [{col}]{state}[/{col}] ({backend}{netdef})'
|
|
netdef = ': [highlight]{}[/highlight]'.format(data.get('id')) if data.get('id') else ''
|
|
extra = ''
|
|
sign = ''
|
|
if self.diff:
|
|
if self._is_interface_missing_in_netplan(ifname):
|
|
sign = self.PLUS
|
|
format = '{sign} [{col}]●[/{col}] {idx:>2}: [green][highlight]{name} {type}'
|
|
format += ' [{col}]{state}[/{col}] ({backend}{netdef})[/highlight][/green]'
|
|
else:
|
|
format = ' [muted]● {idx:>2}: {name} {type} {state} ({backend}{netdef})[/muted]'
|
|
netdef = ': {}'.format(data.get('id')) if data.get('id') else ''
|
|
|
|
if not self.diff_only or self._has_diff(ifname):
|
|
self.pprint(format.format(
|
|
sign=sign,
|
|
col=scolor,
|
|
idx=data.get('index', '?'),
|
|
name=ifname,
|
|
type=full_type,
|
|
state=state,
|
|
backend=data.get('backend', 'unmanaged'),
|
|
netdef=netdef,
|
|
extra=extra,
|
|
))
|
|
|
|
def _display_mac_address(self, ifname: str, data):
|
|
if macaddress := data.get('macaddress'):
|
|
hide_macaddress = False
|
|
missing_system_macaddress = self._get_missing_system_macaddress(ifname)
|
|
format = '{title:>'+self.PAD+'} {mac}[muted]{vendor}[/muted]'
|
|
sign = ''
|
|
if self.diff and not missing_system_macaddress:
|
|
format = ' [muted]{title:>'+self.PAD+'} {mac}{vendor}[/muted]'
|
|
if self.diff_only:
|
|
hide_macaddress = True
|
|
elif self.diff and missing_system_macaddress:
|
|
sign = self.PLUS
|
|
format = '{sign} {title:>'+self.PAD+'} [green][highlight]{mac}{vendor}[/highlight][/green]'
|
|
|
|
if not hide_macaddress:
|
|
self.pprint((format).format(
|
|
sign=sign,
|
|
title='MAC Address:',
|
|
mac=macaddress,
|
|
vendor=' ({})'.format(data.get('vendor', '')) if data.get('vendor') else '',
|
|
))
|
|
|
|
if self.diff and missing_system_macaddress:
|
|
sign = self.MINUS
|
|
format = '{sign} {title:>'+self.PAD+'} [red][highlight]{mac}{vendor}[/highlight][/red]'
|
|
self.pprint((format).format(
|
|
sign=sign,
|
|
title='',
|
|
mac=missing_system_macaddress,
|
|
vendor=' ({})'.format(data.get('vendor', '')) if data.get('vendor') else '',
|
|
))
|
|
|
|
def _display_ip_addresses(self, ifname: str, data):
|
|
lst: list = data.get('addresses', [])
|
|
addresses_displayed = 0
|
|
if lst:
|
|
missing_netplan_addresses = self._get_missing_netplan_addresses(ifname)
|
|
for obj in lst:
|
|
sign = ''
|
|
hide_address = False
|
|
ip, extra = list(obj.items())[0] # get first (and only) address
|
|
prefix = extra.get('prefix', '')
|
|
flags = []
|
|
if extra.get('flags'): # flags
|
|
flags = extra.get('flags', [])
|
|
highlight_start = ''
|
|
highlight_end = ''
|
|
if not flags or 'dhcp' in flags:
|
|
highlight_start = '[highlight]'
|
|
highlight_end = '[/highlight]'
|
|
|
|
address = f'{ip}/{prefix}'
|
|
if self.diff and address not in missing_netplan_addresses:
|
|
format = ' [muted]{title:>'+self.PAD+'} {start}{ip}/{prefix}{end}{extra}[/muted]'
|
|
highlight_start = ''
|
|
highlight_end = ''
|
|
if self.diff_only:
|
|
hide_address = True
|
|
elif self.diff and address in missing_netplan_addresses:
|
|
sign = self.PLUS
|
|
format = '{sign} {title:>'+self.PAD+'} [green]{start}{ip}/{prefix}{extra}{end}[/green]'
|
|
highlight_start = '[highlight]'
|
|
highlight_end = '[/highlight]'
|
|
else:
|
|
format = '{title:>'+self.PAD+'} {start}{ip}/{prefix}{end}[muted]{extra}[/muted]'
|
|
|
|
if not hide_address:
|
|
self.pprint((format).format(
|
|
sign=sign,
|
|
title='Addresses:' if addresses_displayed == 0 else '',
|
|
ip=ip,
|
|
prefix=prefix,
|
|
extra=' ('+', '.join(flags)+')' if flags else '',
|
|
start=highlight_start,
|
|
end=highlight_end,
|
|
))
|
|
addresses_displayed += 1
|
|
|
|
if diff := self._get_interface_diff(ifname):
|
|
sign = self.MINUS
|
|
if missing_addresses := diff.get('system_state', {}).get('missing_addresses'):
|
|
for ip in missing_addresses:
|
|
self.pprint(('{sign} {title:>'+self.PAD+'} [highlight][red]{ip}[/red][/highlight]').format(
|
|
sign=sign,
|
|
title='Addresses:' if addresses_displayed == 0 else '',
|
|
ip=ip,
|
|
))
|
|
addresses_displayed += 1
|
|
if self._is_missing_dhcp4_address(ifname):
|
|
self.pprint(('{sign} {title:>'+self.PAD+'} [highlight][red]0.0.0.0/0 (dhcp)[/red][/highlight]').format(
|
|
sign=sign,
|
|
title='Addresses:' if addresses_displayed == 0 else '',
|
|
))
|
|
addresses_displayed += 1
|
|
if self._is_missing_dhcp6_address(ifname):
|
|
self.pprint(('{sign} {title:>'+self.PAD+'} [highlight][red]::/0 (dhcp)[/red][/highlight]').format(
|
|
sign=sign,
|
|
title='Addresses:' if addresses_displayed == 0 else '',
|
|
))
|
|
|
|
def _display_dns_addresses(self, ifname: str, data):
|
|
lst = data.get('dns_addresses', [])
|
|
nameservers_displayed = 0
|
|
if lst:
|
|
missing_netplan_nameservers = self._get_missing_netplan_nameservers(ifname)
|
|
for val in lst:
|
|
sign = ''
|
|
hide_nameserver = False
|
|
if self.diff and val not in missing_netplan_nameservers:
|
|
format = ' [muted]{title:>'+self.PAD+'} {value}[/muted]'
|
|
highlight_start = ''
|
|
highlight_end = ''
|
|
if self.diff_only:
|
|
hide_nameserver = True
|
|
elif self.diff and val in missing_netplan_nameservers:
|
|
sign = self.PLUS
|
|
format = '{sign} {title:>'+self.PAD+'} [green]{start}{value}{end}[/green]'
|
|
highlight_start = '[highlight]'
|
|
highlight_end = '[/highlight]'
|
|
else:
|
|
format = '{title:>'+self.PAD+'} {value}'
|
|
highlight_start = ''
|
|
highlight_end = ''
|
|
|
|
if not hide_nameserver:
|
|
self.pprint((format).format(
|
|
sign=sign,
|
|
title='DNS Addresses:' if nameservers_displayed == 0 else '',
|
|
value=val,
|
|
start=highlight_start,
|
|
end=highlight_end
|
|
))
|
|
nameservers_displayed += 1
|
|
|
|
if self._has_diff(ifname):
|
|
if missing_nameservers_addresses := self._get_missing_system_nameservers(ifname):
|
|
sign = self.MINUS
|
|
for ip in missing_nameservers_addresses:
|
|
self.pprint(('{sign} {title:>'+self.PAD+'} [red][highlight]{ip}[/highlight][/red]').format(
|
|
sign=sign,
|
|
title='DNS Addresses:' if nameservers_displayed == 0 else '',
|
|
ip=ip,
|
|
))
|
|
nameservers_displayed += 1
|
|
|
|
def _display_dns_search(self, ifname, data):
|
|
lst = data.get('dns_search', [])
|
|
searches_displayed = 0
|
|
if lst:
|
|
missing_netplan_search = self._get_missing_netplan_search(ifname)
|
|
for i, val in enumerate(lst):
|
|
sign = ''
|
|
hide_search = False
|
|
if self.diff and val not in missing_netplan_search:
|
|
format = ' [muted]{title:>'+self.PAD+'} {value}[/muted]'
|
|
highlight_start = ''
|
|
highlight_end = ''
|
|
if self.diff_only:
|
|
hide_search = True
|
|
elif self.diff and val in missing_netplan_search:
|
|
sign = self.PLUS
|
|
format = '{sign} {title:>'+self.PAD+'} [green]{start}{value}{end}[/green]'
|
|
highlight_start = '[highlight]'
|
|
highlight_end = '[/highlight]'
|
|
else:
|
|
format = '{title:>'+self.PAD+'} {value}'
|
|
highlight_start = ''
|
|
highlight_end = ''
|
|
|
|
if not hide_search:
|
|
self.pprint((format).format(
|
|
sign=sign,
|
|
title='DNS Search:' if searches_displayed == 0 else '',
|
|
value=val,
|
|
start=highlight_start,
|
|
end=highlight_end
|
|
))
|
|
searches_displayed += 1
|
|
|
|
if self._has_diff(ifname):
|
|
if missing_nameservers_search := self._get_missing_system_search(ifname):
|
|
sign = self.MINUS
|
|
for domain in missing_nameservers_search:
|
|
self.pprint(('{sign} {title:>'+self.PAD+'} [red][highlight]{domain}[/highlight][/red]').format(
|
|
sign=sign,
|
|
title='DNS Search:' if searches_displayed == 0 else '',
|
|
domain=domain,
|
|
))
|
|
searches_displayed += 1
|
|
|
|
def _display_routes(self, ifname, data):
|
|
lst = data.get('routes', [])
|
|
missing_netplan_routes = self._get_missing_netplan_routes(ifname)
|
|
missing_system_routes = self._get_missing_system_routes(ifname)
|
|
routes_displayed = 0
|
|
if lst:
|
|
if not self.route_lookup_table_names:
|
|
self.route_lookup_table_names = utils.route_table_lookup()
|
|
|
|
diff_state = NetplanDiffState(None, None)
|
|
routes = [diff_state._system_route_to_netplan(route) for route in lst]
|
|
if not self.verbose:
|
|
# filter out routes that are not in the main route table
|
|
routes = filter(lambda r: r.table == 254, routes)
|
|
for route in routes:
|
|
hide_route = False
|
|
default_start = ''
|
|
default_end = ''
|
|
if route.to == 'default':
|
|
default_start = '[highlight]'
|
|
default_end = '[/highlight]'
|
|
via = ''
|
|
if route.via:
|
|
via = ' via ' + route.via
|
|
src = ''
|
|
if route.from_addr:
|
|
src = ' from ' + route.from_addr
|
|
metric = ''
|
|
if route.metric < NetplanRoute._METRIC_UNSPEC_:
|
|
metric = ' metric ' + str(route.metric)
|
|
table = ''
|
|
if self.verbose and route.table > 0:
|
|
table = ' table {}'.format(self.route_lookup_table_names.get(route.table, route.table))
|
|
|
|
extra = []
|
|
if route.protocol and route.protocol != 'kernel':
|
|
proto = route.protocol
|
|
extra.append(proto)
|
|
if route.scope and route.scope != 'global':
|
|
scope = route.scope
|
|
extra.append(scope)
|
|
if route.type and route.type != 'unicast':
|
|
type = route.type
|
|
extra.append(type)
|
|
|
|
sign = ''
|
|
if self.diff and route not in missing_netplan_routes:
|
|
format = ' [muted]{title:>'+self.PAD+'} {start}{to}{via}{src}{metric}{table}{end}{extra}[/muted]'
|
|
default_start = ''
|
|
default_end = ''
|
|
if self.diff_only:
|
|
hide_route = True
|
|
elif self.diff and route in missing_netplan_routes:
|
|
sign = self.PLUS
|
|
format = '{sign} {title:>'+self.PAD+'} [green][highlight]{start}{to}{via}{src}{metric}'
|
|
format += '{table}{end}{extra}[/highlight][/green]'
|
|
else:
|
|
format = '{title:>'+self.PAD+'} {start}{to}{via}{src}{metric}{table}{end}[muted]{extra}[/muted]'
|
|
|
|
if not hide_route:
|
|
self.pprint(format.format(
|
|
sign=sign,
|
|
title='Routes:' if routes_displayed == 0 else '',
|
|
to=route.to,
|
|
via=via,
|
|
src=src,
|
|
metric=metric,
|
|
table=table,
|
|
extra=' ('+', '.join(extra)+')' if extra else '',
|
|
start=default_start,
|
|
end=default_end))
|
|
routes_displayed += 1
|
|
|
|
if self.diff:
|
|
for route in missing_system_routes:
|
|
via = ''
|
|
if route.via:
|
|
via = ' via ' + route.via
|
|
src = ''
|
|
if route.from_addr:
|
|
src = ' from ' + route.from_addr
|
|
metric = ''
|
|
if route.metric < NetplanRoute._METRIC_UNSPEC_:
|
|
metric = ' metric ' + str(route.metric)
|
|
table = ''
|
|
if self.verbose and route.table > 0:
|
|
table = ' table {}'.format(self.route_lookup_table_names.get(route.table, route.table))
|
|
|
|
extra = []
|
|
if route.scope and route.scope != 'global':
|
|
scope = route.scope
|
|
extra.append(scope)
|
|
if route.type and route.type != 'unicast':
|
|
type = route.type
|
|
extra.append(type)
|
|
|
|
sign = self.MINUS
|
|
format = '{sign} {title:>'+self.PAD+'} {start}[red]{to}{via}{src}{metric}{table}{extra}[/red]{end}'
|
|
self.pprint(format.format(
|
|
sign=sign,
|
|
title='Routes:' if routes_displayed == 0 else '',
|
|
to=route.to,
|
|
via=via,
|
|
src=src,
|
|
metric=metric,
|
|
table=table,
|
|
extra=' ('+', '.join(extra)+')' if extra else '',
|
|
start='[highlight]',
|
|
end='[/highlight]'))
|
|
routes_displayed += 1
|
|
|
|
def _display_bridge(self, ifname, data):
|
|
val = data.get('bridge')
|
|
if val:
|
|
missing_netplan_bridge_link = self._get_missing_netplan_bridge_link(ifname)
|
|
format = '{title:>'+self.PAD+'} {value}'
|
|
sign = ''
|
|
hide_bridge = False
|
|
if self.diff and not missing_netplan_bridge_link:
|
|
format = ' [muted]{title:>'+self.PAD+'} {value}[/muted]'
|
|
if self.diff_only:
|
|
hide_bridge = True
|
|
elif self.diff and missing_netplan_bridge_link:
|
|
sign = self.PLUS
|
|
format = '{sign} {title:>'+self.PAD+'} [highlight][green]{value}[/green][/highlight]'
|
|
val = missing_netplan_bridge_link
|
|
|
|
if not hide_bridge:
|
|
self.pprint((format).format(
|
|
sign=sign,
|
|
title='Bridge:',
|
|
value=val,
|
|
))
|
|
if missing_system_bridge_link := self._get_missing_system_bridge_link(ifname):
|
|
sign = self.MINUS
|
|
format = '{sign} {title:>'+self.PAD+'} [highlight][red]{value}[/red][/highlight]'
|
|
self.pprint((format).format(
|
|
sign=sign,
|
|
title='Bridge:',
|
|
value=missing_system_bridge_link,
|
|
))
|
|
|
|
def _display_bond(self, ifname, data):
|
|
val = data.get('bond')
|
|
if val:
|
|
missing_netplan_bond_link = self._get_missing_netplan_bond_link(ifname)
|
|
format = '{title:>'+self.PAD+'} {value}'
|
|
sign = ''
|
|
hide_bond = False
|
|
if self.diff and not missing_netplan_bond_link:
|
|
format = ' [muted]{title:>'+self.PAD+'} {value}[/muted]'
|
|
if self.diff_only:
|
|
hide_bond = True
|
|
elif self.diff and missing_netplan_bond_link:
|
|
sign = self.PLUS
|
|
format = '{sign} {title:>'+self.PAD+'} [highlight][green]{value}[/green][/highlight]'
|
|
val = missing_netplan_bond_link
|
|
|
|
if not hide_bond:
|
|
self.pprint((format).format(
|
|
sign=sign,
|
|
title='Bond:',
|
|
value=val,
|
|
))
|
|
if missing_system_bond_link := self._get_missing_system_bond_link(ifname):
|
|
sign = self.MINUS
|
|
format = '{sign} {title:>'+self.PAD+'} [highlight][red]{value}[/red][/highlight]'
|
|
self.pprint((format).format(
|
|
sign=sign,
|
|
title='Bond:',
|
|
value=missing_system_bond_link,
|
|
))
|
|
|
|
def _display_vrf(self, ifname, data):
|
|
val = data.get('vrf')
|
|
if val:
|
|
missing_netplan_vrf_link = self._get_missing_netplan_vrf_link(ifname)
|
|
format = '{title:>'+self.PAD+'} {value}'
|
|
sign = ''
|
|
hide_vrf = False
|
|
if self.diff and not missing_netplan_vrf_link:
|
|
format = ' [muted]{title:>'+self.PAD+'} {value}[/muted]'
|
|
if self.diff_only:
|
|
hide_vrf = True
|
|
elif self.diff and missing_netplan_vrf_link:
|
|
sign = self.PLUS
|
|
format = '{sign} {title:>'+self.PAD+'} [highlight][green]{value}[/green][/highlight]'
|
|
val = missing_netplan_vrf_link
|
|
|
|
if not hide_vrf:
|
|
self.pprint((format).format(
|
|
sign=sign,
|
|
title='VRF:',
|
|
value=val,
|
|
))
|
|
if missing_system_vrf_link := self._get_missing_system_vrf_link(ifname):
|
|
sign = self.MINUS
|
|
format = '{sign} {title:>'+self.PAD+'} [highlight][red]{value}[/red][/highlight]'
|
|
self.pprint((format).format(
|
|
sign=sign,
|
|
title='VRF:',
|
|
value=missing_system_vrf_link,
|
|
))
|
|
|
|
def _display_members(self, ifname: str, data):
|
|
lst = data.get('interfaces', [])
|
|
members_displayed = 0
|
|
if lst:
|
|
missing_netplan_interfaces = self._get_missing_netplan_members(ifname)
|
|
for val in lst:
|
|
sign = ''
|
|
hide_member = False
|
|
if self.diff and val not in missing_netplan_interfaces:
|
|
format = ' [muted]{title:>'+self.PAD+'} {value}[/muted]'
|
|
highlight_start = ''
|
|
highlight_end = ''
|
|
if self.diff_only:
|
|
hide_member = True
|
|
elif self.diff and val in missing_netplan_interfaces:
|
|
sign = self.PLUS
|
|
format = '{sign} {title:>'+self.PAD+'} [green]{start}{value}{end}[/green]'
|
|
highlight_start = '[highlight]'
|
|
highlight_end = '[/highlight]'
|
|
else:
|
|
format = '{title:>'+self.PAD+'} {value}'
|
|
highlight_start = ''
|
|
highlight_end = ''
|
|
|
|
if not hide_member:
|
|
self.pprint((format).format(
|
|
sign=sign,
|
|
title='Interfaces:' if members_displayed == 0 else '',
|
|
value=val,
|
|
start=highlight_start,
|
|
end=highlight_end,
|
|
))
|
|
members_displayed += 1
|
|
|
|
if self._has_diff(ifname):
|
|
if missing_members := self._get_missing_system_members(ifname):
|
|
sign = self.MINUS
|
|
for member in missing_members:
|
|
self.pprint(('{sign} {title:>'+self.PAD+'} [red][highlight]{member}[/highlight][/red]').format(
|
|
sign=sign,
|
|
title='Interfaces:' if members_displayed == 0 else '',
|
|
member=member,
|
|
))
|
|
members_displayed += 1
|
|
|
|
def _display_activation_mode(self, data):
|
|
val = data.get('activation_mode')
|
|
if val:
|
|
self.pprint(('{title:>'+self.PAD+'} {value}').format(
|
|
title='Activation Mode:',
|
|
value=val,
|
|
))
|
|
|
|
def _display_missing_interfaces(self):
|
|
missing_interfaces = self._get_missing_system_interfaces()
|
|
sign = self.MINUS
|
|
for index, (interface, properties) in enumerate(missing_interfaces.items(), 1):
|
|
# If we called netplan status for a single interface, ignore the rest
|
|
if self.ifname and self.ifname != interface:
|
|
continue
|
|
|
|
self.pprint('{sign} [{col}]● {idx:>2} {name} {type}[/{col}]'.format(
|
|
sign=sign,
|
|
col='red',
|
|
idx='',
|
|
name=interface,
|
|
type=properties.get('type'),
|
|
))
|
|
|
|
if index != len(missing_interfaces) and not self.ifname:
|
|
# linebreak only if it's not the last interfaces or the only one
|
|
self.pprint()
|
|
|
|
def plain_print(self, *args, **kwargs):
|
|
if len(args):
|
|
lst = list(args)
|
|
while True:
|
|
tags = MATCH_TAGS.findall(lst[0])
|
|
if not tags:
|
|
break
|
|
for tag in tags:
|
|
# remove matching opening and closing tag
|
|
lst[0] = lst[0].replace('[{}]'.format(tag), '')\
|
|
.replace('[/{}]'.format(tag), '')
|
|
return print(*lst, **kwargs)
|
|
return print(*args, **kwargs)
|
|
|
|
def pretty_print(self, data: JSON, total: int, _console_width=None) -> None:
|
|
self.pprint = self._create_pretty_print(_console_width)
|
|
self.PLUS = '[green]+[/green]'
|
|
self.MINUS = '[red]-[/red]'
|
|
self.PAD = '18'
|
|
if self.diff:
|
|
# In diff mode we shift the text 2 columns to the right so we can display
|
|
# + and - and maintain the alignment consistency
|
|
self.PAD = '20'
|
|
|
|
# Global state
|
|
if not self.diff:
|
|
self._display_global_state(data)
|
|
|
|
# Per interface
|
|
interfaces = [(key, data[key]) for key in data if key != 'netplan-global-state']
|
|
if self.diff_only:
|
|
# in diff-only mode we filter out interfaces that don't have any diff
|
|
interfaces = list(filter(lambda i: self._has_diff(i[0]), interfaces))
|
|
|
|
missing_interfaces = self._get_missing_system_interfaces()
|
|
for index, (ifname, ifconfig) in enumerate(interfaces, 1):
|
|
# If we called netplan status for a single interface, ignore the rest
|
|
if self.ifname and self.ifname != ifname:
|
|
continue
|
|
|
|
self._display_interface_header(ifname, ifconfig)
|
|
self._display_mac_address(ifname, ifconfig)
|
|
self._display_ip_addresses(ifname, ifconfig)
|
|
self._display_dns_addresses(ifname, ifconfig)
|
|
self._display_dns_search(ifname, ifconfig)
|
|
self._display_routes(ifname, ifconfig)
|
|
self._display_bridge(ifname, ifconfig)
|
|
self._display_bond(ifname, ifconfig)
|
|
self._display_vrf(ifname, ifconfig)
|
|
self._display_members(ifname, ifconfig)
|
|
self._display_activation_mode(ifconfig)
|
|
|
|
if not self.diff_only or self._has_diff(ifname):
|
|
# we only break to a new line if we still have data to display
|
|
if (index != len(interfaces) or len(missing_interfaces) > 0) and not self.ifname:
|
|
self.pprint()
|
|
|
|
if self.diff:
|
|
self._display_missing_interfaces()
|
|
|
|
hidden = total - len(interfaces)
|
|
if hidden > 0 and not self.diff:
|
|
self.pprint('\n{} inactive interfaces hidden. Use "--all" to show all.'.format(hidden))
|
|
|
|
if self.diff and not self.diff_only:
|
|
self.pprint(
|
|
'\nUse [yellow]"--diff-only"[/yellow] to omit the information that is consistent between the system and Netplan.'
|
|
)
|
|
|
|
def command(self):
|
|
# --diff-only implies --diff
|
|
if self.diff_only:
|
|
self.diff = True
|
|
|
|
# --diff needs data from all interfaces to work
|
|
if self.diff:
|
|
self.all = True
|
|
|
|
system_state = SystemConfigState(self.ifname, self.all)
|
|
|
|
output_format = self.format.lower()
|
|
|
|
if self.diff:
|
|
netplan_state = NetplanConfigState(rootdir=self.root_dir)
|
|
diff_state = NetplanDiffState(system_state, netplan_state)
|
|
|
|
self.state_diff = diff_state.get_diff(self.ifname)
|
|
|
|
if output_format == 'json':
|
|
print(json.dumps(self.state_diff, cls=DiffJSONEncoder))
|
|
return
|
|
elif output_format == 'yaml':
|
|
serialized = json.dumps(self.state_diff, cls=DiffJSONEncoder)
|
|
print(yaml.dump(json.loads(serialized)))
|
|
return
|
|
|
|
if output_format == 'json': # structural JSON output
|
|
print(json.dumps(system_state.get_data()))
|
|
elif output_format == 'yaml': # stuctural YAML output
|
|
print(yaml.dump(system_state.get_data()))
|
|
else: # pretty print, human readable output
|
|
self.pretty_print(system_state.get_data(), system_state.number_of_interfaces)
|