Merge ~jocave/plainbox-provider-resource:add-network-management-resource into plainbox-provider-resource:master

[Jonathan Cave]

Resource job that, for all network interfaces identified by udev (categories NETWORK and WIRELESS), applies a simple set of rules to work out what utility is responsible for managing it.

This includes parsing the netplan configuration files and testing to see if network-manager is available.

It is intended that this resource can than be used to filter network related jobs in test plans and hence eliminate the need to keep separate plans and launchers for specific utilities.

[Sylvain Pineau (sylvain-pineau)]

very useful and well written, +1

review: Approve

[Maciej Kisielewski (kissiel)]

Two comments below.

[Jonathan Cave (jocave)]

Addressed comments from kissiel

[Maciej Kisielewski (kissiel)]

Thanks for that syntactic sugar! +1

review: Approve

diff --git a/bin/net_if_management.py b/bin/net_if_management.py
new file mode 100755
index 0000000..1b08274
--- /dev/null
+++ b/bin/net_if_management.py
@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+# This file is part of Checkbox.
+#
+# Copyright 2019 Canonical Ltd.
+# Written by:
+#   Jonathan Cave <[e-mail]>
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+#
+# Checkbox 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 Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+
+from enum import Enum
+import subprocess as sp
+import sys
+
+from checkbox_support.parsers.netplan import Netplan
+from checkbox_support.parsers.udevadm import UdevadmParser, UdevResult
+
+
+class UdevInterfaceLister(UdevResult):
+
+    def __init__(self, categories):
+        self.categories = categories
+        self.names = []
+        cmd = 'udevadm info --export-db'
+        output = sp.check_output(cmd, shell=True).decode(sys.stdout.encoding)
+        udev = UdevadmParser(output)
+        udev.run(self)
+
+    def addDevice(self, device):
+        c = getattr(device, "category", None)
+        if c in self.categories:
+            p = getattr(device, "interface", None)
+            if p is not None:
+                self.names.append(p)
+
+
+class NmInterfaceState():
+
+    def __init__(self):
+        self.devices = {}
+        cmd = 'nmcli -v'
+        rc = sp.call(cmd, shell=True, stdout=sp.DEVNULL, stderr=sp.DEVNULL)
+        if rc != 0:
+            self.available = False
+            return
+        self.available = True
+        cmd = 'nmcli -t -f DEVICE,STATE d'
+        output = sp.check_output(cmd, shell=True).decode(sys.stdout.encoding)
+        for line in output.splitlines():
+            dev, state = line.strip().split(':')
+            self.devices[dev] = state
+
+
+class States(Enum):
+    unspecified = 'unspecified'
+    error = 'error'
+    networkd = 'networkd'
+    nm = 'NetworkManager'
+
+
+def main():
+    # Use udev as definitive source of network interfaces
+    all_interfaces = UdevInterfaceLister(['NETWORK', 'WIRELESS'])
+
+    # Get the neplan config
+    netplan_conf = Netplan()
+    netplan_conf.parse()
+
+    # Get the NetworkManager config
+    nm_conf = NmInterfaceState()
+
+    # fallback state
+    global_scope_manager = States.unspecified.value
+
+    # if netplan has a top-level renderer use that as default:
+    if netplan_conf.network.get('renderer'):
+        global_scope_manager = netplan_conf.network['renderer']
+
+    for n in all_interfaces.names:
+        print('device: {}'.format(n))
+        print('nmcli_available: {}'.format(nm_conf.available))
+
+        if n in netplan_conf.wifis:
+            category_scope_manager = netplan_conf.wifis.get('renderer')
+        elif n in netplan_conf.ethernets:
+            category_scope_manager = netplan_conf.ethernets.get('renderer')
+
+        # Netplan config indcates NM
+        if (global_scope_manager == States.nm.value or
+                category_scope_manager == States.nm.value):
+            # if NM isnt actually available this is a bad config
+            if not nm_conf.available:
+                print('managed_by: {}'.format(States.error.value))
+                print()
+                continue
+            # NM does not know the interface
+            if nm_conf.devices.get(n) is None:
+                print('managed_by: {}'.format(States.error.value))
+                print()
+                continue
+            # NM thinks it doesnt managed the device despite netplan config
+            if nm_conf.devices.get(n) == 'unmanaged':
+                print('managed_by: {}'.format(States.error.value))
+                print()
+                continue
+            print('managed_by: {}'.format(States.nm.value))
+            print()
+            continue
+
+        # No renderer specified
+        print('managed_by: {}'.format(States.networkd.value))
+        print()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/jobs/resource.pxu b/jobs/resource.pxu
index 3dc7f9e..9c142e4 100644
--- a/jobs/resource.pxu
+++ b/jobs/resource.pxu
@@ -429,3 +429,17 @@ plugin: resource
 estimated_duration: 1.0
 command:
   snapd_resource features
+
+id: net_if_management
+_summary: Identify what service is managing each physical network interface
+_description:
+ Network interfaces on Ubuntu systems are generally configured by either
+ systemd-networkd or NetworkManager. This configuration can be maintained using
+ the Netplan utility. This resource attempts to identify which "renderer" is
+ responsible for cofiguring an individual interface allowing appropriate tests
+ to be run.
+plugin: resource
+estimated_duration: 2.0
+user: root
+command:
+  net_if_management.py