Add support for VMware PhotonOS (#909)

Also added a new (currently experimental) systemd-networkd renderer,
and includes a small refactor to cc_resolv_conf.py to support the
resolved.conf used by systemd-resolved.

2 files changed, 249 insertions, 1 deletions

diff --git a/cloudinit/net/networkd.py b/cloudinit/net/networkd.py
new file mode 100644
index 00000000..71f87995
--- /dev/null
+++ b/cloudinit/net/networkd.py
@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+# vi: ts=4 expandtab
+#
+# Copyright (C) 2021 VMware Inc.
+#
+# Author: Shreenidhi Shedi <yesshedi@gmail.com>
+#
+# This file is part of cloud-init. See LICENSE file for license information.
+
+import os
+
+
+from . import renderer
+from cloudinit import util
+from cloudinit import subp
+from cloudinit import log as logging
+from collections import OrderedDict
+
+LOG = logging.getLogger(__name__)
+
+
+class CfgParser:
+    def __init__(self):
+        self.conf_dict = OrderedDict({
+            'Match': [],
+            'Link': [],
+            'Network': [],
+            'DHCPv4': [],
+            'DHCPv6': [],
+            'Address': [],
+            'Route': [],
+        })
+
+    def update_section(self, sec, key, val):
+        for k in self.conf_dict.keys():
+            if k == sec:
+                self.conf_dict[k].append(key+'='+str(val))
+                self.conf_dict[k].sort()
+
+    def get_final_conf(self):
+        contents = ''
+        for k, v in self.conf_dict.items():
+            if not v:
+                continue
+            contents += '['+k+']\n'
+            for e in v:
+                contents += e + '\n'
+            contents += '\n'
+
+        return contents
+
+    def dump_data(self, target_fn):
+        if not target_fn:
+            LOG.warning('Target file not given')
+            return
+
+        contents = self.get_final_conf()
+        LOG.debug('Final content: %s', contents)
+        util.write_file(target_fn, contents)
+
+
+class Renderer(renderer.Renderer):
+    """
+    Renders network information in /etc/systemd/network
+
+    This Renderer is currently experimental and doesn't support all the
+    use cases supported by the other renderers yet.
+    """
+
+    def __init__(self, config=None):
+        if not config:
+            config = {}
+        self.resolved_conf = config.get('resolved_conf_fn',
+                                        '/etc/systemd/resolved.conf')
+        self.network_conf_dir = config.get('network_conf_dir',
+                                           '/etc/systemd/network/')
+
+    def generate_match_section(self, iface, cfg):
+        sec = 'Match'
+        match_dict = {
+            'name': 'Name',
+            'driver': 'Driver',
+            'mac_address': 'MACAddress'
+        }
+
+        if not iface:
+            return
+
+        for k, v in match_dict.items():
+            if k in iface and iface[k]:
+                cfg.update_section(sec, v, iface[k])
+
+        return iface['name']
+
+    def generate_link_section(self, iface, cfg):
+        sec = 'Link'
+
+        if not iface:
+            return
+
+        if 'mtu' in iface and iface['mtu']:
+            cfg.update_section(sec, 'MTUBytes', iface['mtu'])
+
+    def parse_routes(self, conf, cfg):
+        sec = 'Route'
+        for k, v in conf.items():
+            if k == 'gateway':
+                cfg.update_section(sec, 'Gateway', v)
+            elif k == 'network':
+                tmp = v
+                if 'prefix' in conf:
+                    tmp += '/' + str(conf['prefix'])
+                cfg.update_section(sec, 'Destination', tmp)
+            elif k == 'metric':
+                cfg.update_section(sec, 'Metric', v)
+
+    def parse_subnets(self, iface, cfg):
+        dhcp = 'no'
+        for e in iface.get('subnets', []):
+            t = e['type']
+            if t == 'dhcp4' or t == 'dhcp':
+                if dhcp == 'no':
+                    dhcp = 'ipv4'
+                elif dhcp == 'ipv6':
+                    dhcp = 'yes'
+            elif t == 'dhcp6':
+                if dhcp == 'no':
+                    dhcp = 'ipv6'
+                elif dhcp == 'ipv4':
+                    dhcp = 'yes'
+            if 'routes' in e and e['routes']:
+                for i in e['routes']:
+                    self.parse_routes(i, cfg)
+            elif 'address' in e:
+                for k, v in e.items():
+                    if k == 'address':
+                        tmp = v
+                        if 'prefix' in e:
+                            tmp += '/' + str(e['prefix'])
+                        cfg.update_section('Address', 'Address', tmp)
+                    elif k == 'gateway':
+                        cfg.update_section('Route', 'Gateway', v)
+                    elif k == 'dns_nameservers':
+                        cfg.update_section('Network', 'DNS', ' '.join(v))
+                    elif k == 'dns_search':
+                        cfg.update_section('Network', 'Domains', ' '.join(v))
+
+        cfg.update_section('Network', 'DHCP', dhcp)
+
+    # This is to accommodate extra keys present in VMware config
+    def dhcp_domain(self, d, cfg):
+        for item in ['dhcp4domain', 'dhcp6domain']:
+            if item not in d:
+                continue
+            ret = str(d[item]).casefold()
+            try:
+                ret = util.translate_bool(ret)
+                ret = 'yes' if ret else 'no'
+            except ValueError:
+                if ret != 'route':
+                    LOG.warning('Invalid dhcp4domain value - %s', ret)
+                    ret = 'no'
+            if item == 'dhcp4domain':
+                section = 'DHCPv4'
+            else:
+                section = 'DHCPv6'
+            cfg.update_section(section, 'UseDomains', ret)
+
+    def parse_dns(self, iface, cfg, ns):
+        sec = 'Network'
+
+        dns_cfg_map = {
+            'search': 'Domains',
+            'nameservers': 'DNS',
+            'addresses': 'DNS',
+        }
+
+        dns = iface.get('dns')
+        if not dns and ns.version == 1:
+            dns = {
+                'search': ns.dns_searchdomains,
+                'nameservers': ns.dns_nameservers,
+            }
+        elif not dns and ns.version == 2:
+            return
+
+        for k, v in dns_cfg_map.items():
+            if k in dns and dns[k]:
+                cfg.update_section(sec, v, ' '.join(dns[k]))
+
+    def create_network_file(self, link, conf, nwk_dir):
+        net_fn_owner = 'systemd-network'
+
+        LOG.debug('Setting Networking Config for %s', link)
+
+        net_fn = nwk_dir + '10-cloud-init-' + link + '.network'
+        util.write_file(net_fn, conf)
+        util.chownbyname(net_fn, net_fn_owner, net_fn_owner)
+
+    def render_network_state(self, network_state, templates=None, target=None):
+        fp_nwkd = self.network_conf_dir
+        if target:
+            fp_nwkd = subp.target_path(target) + fp_nwkd
+
+        util.ensure_dir(os.path.dirname(fp_nwkd))
+
+        ret_dict = self._render_content(network_state)
+        for k, v in ret_dict.items():
+            self.create_network_file(k, v, fp_nwkd)
+
+    def _render_content(self, ns):
+        ret_dict = {}
+        for iface in ns.iter_interfaces():
+            cfg = CfgParser()
+
+            link = self.generate_match_section(iface, cfg)
+            self.generate_link_section(iface, cfg)
+            self.parse_subnets(iface, cfg)
+            self.parse_dns(iface, cfg, ns)
+
+            for route in ns.iter_routes():
+                self.parse_routes(route, cfg)
+
+            if ns.version == 2:
+                name = iface['name']
+                # network state doesn't give dhcp domain info
+                # using ns.config as a workaround here
+                self.dhcp_domain(ns.config['ethernets'][name], cfg)
+
+            ret_dict.update({link: cfg.get_final_conf()})
+
+        return ret_dict
+
+
+def available(target=None):
+    expected = ['systemctl']
+    search = ['/usr/bin', '/bin']
+    for p in expected:
+        if not subp.which(p, search=search, target=target):
+            return False
+    return True
+
+
+def network_state_to_networkd(ns):
+    renderer = Renderer({})
+    return renderer._render_content(ns)
diff --git a/cloudinit/net/renderers.py b/cloudinit/net/renderers.py
index e2de4d55..c3931a98 100644
--- a/cloudinit/net/renderers.py
+++ b/cloudinit/net/renderers.py
@@ -4,6 +4,7 @@ from . import eni
 from . import freebsd
 from . import netbsd
 from . import netplan
+from . import networkd
 from . import RendererNotFoundError
 from . import openbsd
 from . import sysconfig
@@ -13,12 +14,13 @@ NAME_TO_RENDERER = {
     "freebsd": freebsd,
     "netbsd": netbsd,
     "netplan": netplan,
+    "networkd": networkd,
     "openbsd": openbsd,
     "sysconfig": sysconfig,
 }
 
 DEFAULT_PRIORITY = ["eni", "sysconfig", "netplan", "freebsd",
-                    "netbsd", "openbsd"]
+                    "netbsd", "openbsd", "networkd"]
 
 
 def search(priority=None, target=None, first=False):