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.

15 files changed, 694 insertions, 37 deletions

diff --git a/cloudinit/cmd/devel/net_convert.py b/cloudinit/cmd/devel/net_convert.py
index 0668ffa3..5c649fd0 100755
--- a/cloudinit/cmd/devel/net_convert.py
+++ b/cloudinit/cmd/devel/net_convert.py
@@ -11,7 +11,7 @@ from cloudinit.sources import DataSourceAzure as azure
 from cloudinit.sources import DataSourceOVF as ovf
 
 from cloudinit import distros, safeyaml
-from cloudinit.net import eni, netplan, network_state, sysconfig
+from cloudinit.net import eni, netplan, networkd, network_state, sysconfig
 from cloudinit import log
 
 NAME = 'net-convert'
@@ -51,7 +51,7 @@ def get_parser(parser=None):
     parser.add_argument("--debug", action='store_true',
                         help='enable debug logging to stderr.')
     parser.add_argument("-O", "--output-kind",
-                        choices=['eni', 'netplan', 'sysconfig'],
+                        choices=['eni', 'netplan', 'networkd', 'sysconfig'],
                         required=True,
                         help="The network config format to emit")
     return parser
@@ -118,9 +118,14 @@ def handle_args(name, args):
         config['netplan_path'] = config['netplan_path'][1:]
         # enable some netplan features
         config['features'] = ['dhcp-use-domains', 'ipv6-mtu']
-    else:
+    elif args.output_kind == "networkd":
+        r_cls = networkd.Renderer
+        config = distro.renderer_configs.get('networkd')
+    elif args.output_kind == "sysconfig":
         r_cls = sysconfig.Renderer
         config = distro.renderer_configs.get('sysconfig')
+    else:
+        raise RuntimeError("Invalid output_kind")
 
     r = r_cls(config=config)
     sys.stderr.write(''.join([
diff --git a/cloudinit/config/cc_ntp.py b/cloudinit/config/cc_ntp.py
index 70c24610..acf3251d 100644
--- a/cloudinit/config/cc_ntp.py
+++ b/cloudinit/config/cc_ntp.py
@@ -25,7 +25,7 @@ frequency = PER_INSTANCE
 NTP_CONF = '/etc/ntp.conf'
 NR_POOL_SERVERS = 4
 distros = ['almalinux', 'alpine', 'centos', 'debian', 'fedora', 'opensuse',
-           'rhel', 'rocky', 'sles', 'ubuntu']
+           'photon', 'rhel', 'rocky', 'sles', 'ubuntu']
 
 NTP_CLIENT_CONFIG = {
     'chrony': {
@@ -80,24 +80,37 @@ DISTRO_CLIENT_CONFIG = {
             'confpath': '/etc/chrony/chrony.conf',
         },
     },
-    'rhel': {
+    'opensuse': {
+        'chrony': {
+            'service_name': 'chronyd',
+        },
         'ntp': {
+            'confpath': '/etc/ntp.conf',
             'service_name': 'ntpd',
         },
-        'chrony': {
-            'service_name': 'chronyd',
+        'systemd-timesyncd': {
+            'check_exe': '/usr/lib/systemd/systemd-timesyncd',
         },
     },
-    'opensuse': {
+    'photon': {
         'chrony': {
             'service_name': 'chronyd',
         },
         'ntp': {
-            'confpath': '/etc/ntp.conf',
             'service_name': 'ntpd',
+            'confpath': '/etc/ntp.conf'
         },
         'systemd-timesyncd': {
             'check_exe': '/usr/lib/systemd/systemd-timesyncd',
+            'confpath': '/etc/systemd/timesyncd.conf',
+        },
+    },
+    'rhel': {
+        'ntp': {
+            'service_name': 'ntpd',
+        },
+        'chrony': {
+            'service_name': 'chronyd',
         },
     },
     'sles': {
@@ -551,7 +564,6 @@ def handle(name, cfg, cloud, log, _args):
     # Select which client is going to be used and get the configuration
     ntp_client_config = select_ntp_client(ntp_cfg.get('ntp_client'),
                                           cloud.distro)
-
     # Allow user ntp config to override distro configurations
     ntp_client_config = util.mergemanydict(
         [ntp_client_config, ntp_cfg.get('config', {})], reverse=True)
diff --git a/cloudinit/config/cc_resolv_conf.py b/cloudinit/config/cc_resolv_conf.py
index 466dad03..c51967e2 100644
--- a/cloudinit/config/cc_resolv_conf.py
+++ b/cloudinit/config/cc_resolv_conf.py
@@ -30,7 +30,7 @@ are configured correctly.
 
 **Module frequency:** per instance
 
-**Supported distros:** alpine, fedora, rhel, sles
+**Supported distros:** alpine, fedora, photon, rhel, sles
 
 **Config keys**::
 
@@ -47,18 +47,23 @@ are configured correctly.
 """
 
 from cloudinit import log as logging
-from cloudinit.settings import PER_INSTANCE
 from cloudinit import templater
+from cloudinit.settings import PER_INSTANCE
 from cloudinit import util
 
 LOG = logging.getLogger(__name__)
 
 frequency = PER_INSTANCE
 
-distros = ['alpine', 'fedora', 'opensuse', 'rhel', 'sles']
+distros = ['alpine', 'fedora', 'opensuse', 'photon', 'rhel', 'sles']
+
+RESOLVE_CONFIG_TEMPLATE_MAP = {
+    '/etc/resolv.conf': 'resolv.conf',
+    '/etc/systemd/resolved.conf': 'systemd.resolved.conf',
+}
 
 
-def generate_resolv_conf(template_fn, params, target_fname="/etc/resolv.conf"):
+def generate_resolv_conf(template_fn, params, target_fname):
     flags = []
     false_flags = []
 
@@ -104,12 +109,18 @@ def handle(name, cfg, cloud, log, _args):
     if "resolv_conf" not in cfg:
         log.warning("manage_resolv_conf True but no parameters provided!")
 
-    template_fn = cloud.get_template_filename('resolv.conf')
-    if not template_fn:
+    try:
+        template_fn = cloud.get_template_filename(
+            RESOLVE_CONFIG_TEMPLATE_MAP[cloud.distro.resolv_conf_fn])
+    except KeyError:
         log.warning("No template found, not rendering /etc/resolv.conf")
         return
 
-    generate_resolv_conf(template_fn=template_fn, params=cfg["resolv_conf"])
+    generate_resolv_conf(
+        template_fn=template_fn,
+        params=cfg["resolv_conf"],
+        target_fname=cloud.disro.resolve_conf_fn
+    )
     return
 
 # vi: ts=4 expandtab
diff --git a/cloudinit/config/cc_yum_add_repo.py b/cloudinit/config/cc_yum_add_repo.py
index 7daa6bd9..67f09686 100644
--- a/cloudinit/config/cc_yum_add_repo.py
+++ b/cloudinit/config/cc_yum_add_repo.py
@@ -18,7 +18,7 @@ entry, the config entry will be skipped.
 
 **Module frequency:** per always
 
-**Supported distros:** almalinux, centos, fedora, rhel, rocky
+**Supported distros:** almalinux, centos, fedora, photon, rhel, rocky
 
 **Config keys**::
 
@@ -36,7 +36,7 @@ from configparser import ConfigParser
 
 from cloudinit import util
 
-distros = ['almalinux', 'centos', 'fedora', 'rhel', 'rocky']
+distros = ['almalinux', 'centos', 'fedora', 'photon', 'rhel', 'rocky']
 
 
 def _canonicalize_id(repo_id):
diff --git a/cloudinit/config/tests/test_resolv_conf.py b/cloudinit/config/tests/test_resolv_conf.py
index 6546a0b5..45a06c22 100644
--- a/cloudinit/config/tests/test_resolv_conf.py
+++ b/cloudinit/config/tests/test_resolv_conf.py
@@ -1,9 +1,8 @@
-from unittest import mock
-
 import pytest
 
+from unittest import mock
 from cloudinit.config.cc_resolv_conf import generate_resolv_conf
-
+from tests.unittests.test_distros.test_create_users import MyBaseDistro
 
 EXPECTED_HEADER = """\
 # Your system has been configured with 'manage-resolv-conf' set to true.
@@ -14,22 +13,28 @@ EXPECTED_HEADER = """\
 
 
 class TestGenerateResolvConf:
+
+    dist = MyBaseDistro()
+    tmpl_fn = "templates/resolv.conf.tmpl"
+
     @mock.patch("cloudinit.config.cc_resolv_conf.templater.render_to_file")
-    def test_default_target_fname_is_etc_resolvconf(self, m_render_to_file):
-        generate_resolv_conf("templates/resolv.conf.tmpl", mock.MagicMock())
+    def test_dist_resolv_conf_fn(self, m_render_to_file):
+        self.dist.resolve_conf_fn = "/tmp/resolv-test.conf"
+        generate_resolv_conf(self.tmpl_fn,
+                             mock.MagicMock(),
+                             self.dist.resolve_conf_fn)
 
         assert [
-            mock.call(mock.ANY, "/etc/resolv.conf", mock.ANY)
+            mock.call(mock.ANY, self.dist.resolve_conf_fn, mock.ANY)
         ] == m_render_to_file.call_args_list
 
     @mock.patch("cloudinit.config.cc_resolv_conf.templater.render_to_file")
     def test_target_fname_is_used_if_passed(self, m_render_to_file):
-        generate_resolv_conf(
-            "templates/resolv.conf.tmpl", mock.MagicMock(), "/use/this/path"
-        )
+        path = "/use/this/path"
+        generate_resolv_conf(self.tmpl_fn, mock.MagicMock(), path)
 
         assert [
-            mock.call(mock.ANY, "/use/this/path", mock.ANY)
+            mock.call(mock.ANY, path, mock.ANY)
         ] == m_render_to_file.call_args_list
 
     # Patch in templater so we can assert on the actual generated content
@@ -75,7 +80,8 @@ class TestGenerateResolvConf:
     def test_flags_and_options(
         self, m_write_file, params, expected_extra_line
     ):
-        generate_resolv_conf("templates/resolv.conf.tmpl", params)
+        target_fn = "/etc/resolv.conf"
+        generate_resolv_conf(self.tmpl_fn, params, target_fn)
 
         expected_content = EXPECTED_HEADER
         if expected_extra_line is not None:
diff --git a/cloudinit/distros/__init__.py b/cloudinit/distros/__init__.py
index 57e33621..4991f42b 100755
--- a/cloudinit/distros/__init__.py
+++ b/cloudinit/distros/__init__.py
@@ -46,7 +46,8 @@ OSFAMILIES = {
     'debian': ['debian', 'ubuntu'],
     'freebsd': ['freebsd'],
     'gentoo': ['gentoo'],
-    'redhat': ['almalinux', 'amazon', 'centos', 'fedora', 'rhel', 'rocky'],
+    'redhat': ['almalinux', 'amazon', 'centos', 'fedora', 'photon', 'rhel',
+               'rocky'],
     'suse': ['opensuse', 'sles'],
 }
 
@@ -80,6 +81,7 @@ class Distro(persistence.CloudInitPickleMixin, metaclass=abc.ABCMeta):
 
     _ci_pkl_version = 1
     prefer_fqdn = False
+    resolve_conf_fn = "/etc/resolv.conf"
 
     def __init__(self, name, cfg, paths):
         self._paths = paths
diff --git a/cloudinit/distros/arch.py b/cloudinit/distros/arch.py
index f8385f7f..246e6fe7 100644
--- a/cloudinit/distros/arch.py
+++ b/cloudinit/distros/arch.py
@@ -25,7 +25,6 @@ LOG = logging.getLogger(__name__)
 class Distro(distros.Distro):
     locale_gen_fn = "/etc/locale.gen"
     network_conf_dir = "/etc/netctl"
-    resolve_conf_fn = "/etc/resolv.conf"
     init_cmd = ['systemctl']  # init scripts
     renderer_configs = {
         "netplan": {"netplan_path": "/etc/netplan/50-cloud-init.yaml",
diff --git a/cloudinit/distros/gentoo.py b/cloudinit/distros/gentoo.py
index e9b82602..68c03e7f 100644
--- a/cloudinit/distros/gentoo.py
+++ b/cloudinit/distros/gentoo.py
@@ -23,7 +23,6 @@ LOG = logging.getLogger(__name__)
 class Distro(distros.Distro):
     locale_conf_fn = '/etc/locale.gen'
     network_conf_fn = '/etc/conf.d/net'
-    resolve_conf_fn = '/etc/resolv.conf'
     hostname_conf_fn = '/etc/conf.d/hostname'
     init_cmd = ['rc-service']  # init scripts
 
diff --git a/cloudinit/distros/opensuse.py b/cloudinit/distros/opensuse.py
index 7ca0ef99..270cc189 100644
--- a/cloudinit/distros/opensuse.py
+++ b/cloudinit/distros/opensuse.py
@@ -27,7 +27,6 @@ class Distro(distros.Distro):
     locale_conf_fn = '/etc/sysconfig/language'
     network_conf_fn = '/etc/sysconfig/network/config'
     network_script_tpl = '/etc/sysconfig/network/ifcfg-%s'
-    resolve_conf_fn = '/etc/resolv.conf'
     route_conf_tpl = '/etc/sysconfig/network/ifroute-%s'
     systemd_hostname_conf_fn = '/etc/hostname'
     systemd_locale_conf_fn = '/etc/locale.conf'
diff --git a/cloudinit/distros/photon.py b/cloudinit/distros/photon.py
new file mode 100644
index 00000000..8b78f98f
--- /dev/null
+++ b/cloudinit/distros/photon.py
@@ -0,0 +1,355 @@
+#!/usr/bin/env python3
+# vi: ts=4 expandtab
+#
+# Copyright (C) 2021 VMware Inc.
+#
+# This file is part of cloud-init. See LICENSE file for license information.
+
+from cloudinit import util
+from cloudinit import subp
+from cloudinit import distros
+from cloudinit import helpers
+from cloudinit import log as logging
+from cloudinit.distros import net_util
+from cloudinit.settings import PER_INSTANCE
+from cloudinit.distros import rhel_util as rhutil
+from cloudinit.net.network_state import mask_to_net_prefix
+from cloudinit.distros.parsers.hostname import HostnameConf
+
+LOG = logging.getLogger(__name__)
+
+
+class Distro(distros.Distro):
+    hostname_conf_fn = '/etc/hostname'
+    network_conf_dir = '/etc/systemd/network/'
+    systemd_locale_conf_fn = '/etc/locale.conf'
+    resolve_conf_fn = '/etc/systemd/resolved.conf'
+
+    renderer_configs = {
+        'networkd': {
+            'resolv_conf_fn': resolve_conf_fn,
+            'network_conf_dir': network_conf_dir,
+        }
+    }
+
+    # Should be fqdn if we can use it
+    prefer_fqdn = True
+
+    def __init__(self, name, cfg, paths):
+        distros.Distro.__init__(self, name, cfg, paths)
+        # This will be used to restrict certain
+        # calls from repeatly happening (when they
+        # should only happen say once per instance...)
+        self._runner = helpers.Runners(paths)
+        self.osfamily = 'photon'
+        self.init_cmd = ['systemctl']
+
+    def exec_cmd(self, cmd, capture=False):
+        LOG.debug('Attempting to run: %s', cmd)
+        try:
+            (out, err) = subp.subp(cmd, capture=capture)
+            if err:
+                LOG.warning('Running %s resulted in stderr output: %s',
+                            cmd, err)
+            return True, out, err
+        except subp.ProcessExecutionError:
+            util.logexc(LOG, 'Command %s failed', cmd)
+            return False, None, None
+
+    def apply_locale(self, locale, out_fn=None):
+        # This has a dependancy on glibc-i18n, user need to manually install it
+        # and enable the option in cloud.cfg
+        if not out_fn:
+            out_fn = self.systemd_locale_conf_fn
+
+        locale_cfg = {
+            'LANG': locale,
+        }
+
+        rhutil.update_sysconfig_file(out_fn, locale_cfg)
+
+        # rhutil will modify /etc/locale.conf
+        # For locale change to take effect, reboot is needed or we can restart
+        # systemd-localed. This is equivalent of localectl
+        cmd = ['systemctl', 'restart', 'systemd-localed']
+        _ret, _out, _err = self.exec_cmd(cmd)
+
+    def install_packages(self, pkglist):
+        # self.update_package_sources()
+        self.package_command('install', pkgs=pkglist)
+
+    def _write_network_config(self, netconfig):
+        if isinstance(netconfig, str):
+            self._write_network_(netconfig)
+            return
+        return self._supported_write_network_config(netconfig)
+
+    def _bring_up_interfaces(self, device_names):
+        cmd = ['systemctl', 'restart', 'systemd-networkd', 'systemd-resolved']
+        LOG.debug('Attempting to run bring up interfaces using command %s',
+                  cmd)
+        ret, _out, _err = self.exec_cmd(cmd)
+        return ret
+
+    def _write_hostname(self, hostname, out_fn):
+        conf = None
+        try:
+            # Try to update the previous one
+            # Let's see if we can read it first.
+            conf = HostnameConf(util.load_file(out_fn))
+            conf.parse()
+        except IOError:
+            pass
+        if not conf:
+            conf = HostnameConf('')
+        conf.set_hostname(hostname)
+        util.write_file(out_fn, str(conf), mode=0o644)
+
+    def _read_system_hostname(self):
+        sys_hostname = self._read_hostname(self.hostname_conf_fn)
+        return (self.hostname_conf_fn, sys_hostname)
+
+    def _read_hostname(self, filename, default=None):
+        _ret, out, _err = self.exec_cmd(['hostname'])
+
+        return out if out else default
+
+    def _get_localhost_ip(self):
+        return '127.0.1.1'
+
+    def set_timezone(self, tz):
+        distros.set_etc_timezone(tz=tz, tz_file=self._find_tz_file(tz))
+
+    def package_command(self, command, args=None, pkgs=None):
+        if pkgs is None:
+            pkgs = []
+
+        cmd = ['tdnf', '-y']
+        if args and isinstance(args, str):
+            cmd.append(args)
+        elif args and isinstance(args, list):
+            cmd.extend(args)
+
+        cmd.append(command)
+
+        pkglist = util.expand_package_list('%s-%s', pkgs)
+        cmd.extend(pkglist)
+
+        # Allow the output of this to flow outwards (ie not be captured)
+        _ret, _out, _err = self.exec_cmd(cmd, capture=False)
+
+    def update_package_sources(self):
+        self._runner.run('update-sources', self.package_command,
+                         ['makecache'], freq=PER_INSTANCE)
+
+    def _generate_resolv_conf(self):
+        resolv_conf_fn = self.resolve_conf_fn
+        resolv_templ_fn = 'systemd.resolved.conf'
+
+        return resolv_conf_fn, resolv_templ_fn
+
+    def _write_network_(self, settings):
+        entries = net_util.translate_network(settings)
+        LOG.debug('Translated ubuntu style network settings %s into %s',
+                  settings, entries)
+        route_entries = []
+        route_entries = translate_routes(settings)
+        dev_names = entries.keys()
+        nameservers = []
+        searchdomains = []
+        # Format for systemd
+        for (dev, info) in entries.items():
+            if 'dns-nameservers' in info:
+                nameservers.extend(info['dns-nameservers'])
+            if 'dns-search' in info:
+                searchdomains.extend(info['dns-search'])
+            if dev == 'lo':
+                continue
+
+            net_fn = self.network_conf_dir + '10-cloud-init-' + dev
+            net_fn += '.network'
+            dhcp_enabled = 'no'
+            if info.get('bootproto') == 'dhcp':
+                if (settings.find('inet dhcp') >= 0 and
+                        settings.find('inet6 dhcp') >= 0):
+                    dhcp_enabled = 'yes'
+                else:
+                    if info.get('inet6') is True:
+                        dhcp_enabled = 'ipv6'
+                    else:
+                        dhcp_enabled = 'ipv4'
+
+            net_cfg = {
+                'Name': dev,
+                'DHCP': dhcp_enabled,
+            }
+
+            if info.get('hwaddress'):
+                net_cfg['MACAddress'] = info.get('hwaddress')
+            if info.get('address'):
+                net_cfg['Address'] = '%s' % (info.get('address'))
+                if info.get('netmask'):
+                    net_cfg['Address'] += '/%s' % (
+                        mask_to_net_prefix(info.get('netmask')))
+            if info.get('gateway'):
+                net_cfg['Gateway'] = info.get('gateway')
+            if info.get('dns-nameservers'):
+                net_cfg['DNS'] = str(
+                    tuple(info.get('dns-nameservers'))).replace(',', '')
+            if info.get('dns-search'):
+                net_cfg['Domains'] = str(
+                    tuple(info.get('dns-search'))).replace(',', '')
+            route_entry = []
+            if dev in route_entries:
+                route_entry = route_entries[dev]
+                route_index = 0
+                found = True
+                while found:
+                    route_name = 'routes.' + str(route_index)
+                    if route_name in route_entries[dev]:
+                        val = str(tuple(route_entries[dev][route_name]))
+                        val = val.replace(',', '')
+                        if val:
+                            net_cfg[route_name] = val
+                    else:
+                        found = False
+                    route_index += 1
+
+            if info.get('auto'):
+                self._write_interface_file(net_fn, net_cfg, route_entry)
+
+        resolve_data = []
+        new_resolve_data = []
+        with open(self.resolve_conf_fn, 'r') as rf:
+            resolve_data = rf.readlines()
+        LOG.debug('Old Resolve Data\n')
+        LOG.debug('%s', resolve_data)
+        for item in resolve_data:
+            if ((nameservers and ('DNS=' in item)) or
+                    (searchdomains and ('Domains=' in item))):
+                continue
+            else:
+                new_resolve_data.append(item)
+
+        new_resolve_data = new_resolve_data + \
+            convert_resolv_conf(nameservers, searchdomains)
+        LOG.debug('New resolve data\n')
+        LOG.debug('%s', new_resolve_data)
+        if nameservers or searchdomains:
+            util.write_file(self.resolve_conf_fn, ''.join(new_resolve_data))
+
+        return dev_names
+
+    def _write_interface_file(self, net_fn, net_cfg, route_entry):
+        if not net_cfg['Name']:
+            return
+        content = '[Match]\n'
+        content += 'Name=%s\n' % (net_cfg['Name'])
+        if 'MACAddress' in net_cfg:
+            content += 'MACAddress=%s\n' % (net_cfg['MACAddress'])
+        content += '[Network]\n'
+
+        if 'DHCP' in net_cfg and net_cfg['DHCP'] in {'yes', 'ipv4', 'ipv6'}:
+            content += 'DHCP=%s\n' % (net_cfg['DHCP'])
+        else:
+            if 'Address' in net_cfg:
+                content += 'Address=%s\n' % (net_cfg['Address'])
+            if 'Gateway' in net_cfg:
+                content += 'Gateway=%s\n' % (net_cfg['Gateway'])
+            if 'DHCP' in net_cfg and net_cfg['DHCP'] == 'no':
+                content += 'DHCP=%s\n' % (net_cfg['DHCP'])
+
+            route_index = 0
+            found = True
+            if route_entry:
+                while found:
+                    route_name = 'routes.' + str(route_index)
+                    if route_name in route_entry:
+                        content += '[Route]\n'
+                        if len(route_entry[route_name]) != 2:
+                            continue
+                        content += 'Gateway=%s\n' % (
+                            route_entry[route_name][0])
+                        content += 'Destination=%s\n' % (
+                            route_entry[route_name][1])
+                    else:
+                        found = False
+                    route_index += 1
+
+        util.write_file(net_fn, content)
+
+
+def convert_resolv_conf(nameservers, searchdomains):
+    ''' Returns a string formatted for resolv.conf '''
+    result = []
+    if nameservers:
+        nslist = 'DNS='
+        for ns in nameservers:
+            nslist = nslist + '%s ' % ns
+        nslist = nslist + '\n'
+        result.append(str(nslist))
+    if searchdomains:
+        sdlist = 'Domains='
+        for sd in searchdomains:
+            sdlist = sdlist + '%s ' % sd
+        sdlist = sdlist + '\n'
+        result.append(str(sdlist))
+    return result
+
+
+def translate_routes(settings):
+    entries = []
+    for line in settings.splitlines():
+        line = line.strip()
+        if not line or line.startswith('#'):
+            continue
+        split_up = line.split(None, 1)
+        if len(split_up) <= 1:
+            continue
+        entries.append(split_up)
+    consume = {}
+    ifaces = []
+    for (cmd, args) in entries:
+        if cmd == 'iface':
+            if consume:
+                ifaces.append(consume)
+                consume = {}
+            consume[cmd] = args
+        else:
+            consume[cmd] = args
+
+    absorb = False
+    for (cmd, args) in consume.items():
+        if cmd == 'iface':
+            absorb = True
+    if absorb:
+        ifaces.append(consume)
+    out_ifaces = {}
+    for info in ifaces:
+        if 'iface' not in info:
+            continue
+        iface_details = info['iface'].split(None)
+        dev_name = None
+        if len(iface_details) >= 1:
+            dev = iface_details[0].strip().lower()
+            if dev:
+                dev_name = dev
+        if not dev_name:
+            continue
+        route_info = {}
+        route_index = 0
+        found = True
+        while found:
+            route_name = 'routes.' + str(route_index)
+            if route_name in info:
+                val = info[route_name].split()
+                if val:
+                    route_info[route_name] = val
+            else:
+                found = False
+            route_index += 1
+        if dev_name in out_ifaces:
+            out_ifaces[dev_name].update(route_info)
+        else:
+            out_ifaces[dev_name] = route_info
+    return out_ifaces
diff --git a/cloudinit/distros/rhel.py b/cloudinit/distros/rhel.py
index 0c00a531..80a6f1d8 100644
--- a/cloudinit/distros/rhel.py
+++ b/cloudinit/distros/rhel.py
@@ -36,7 +36,6 @@ class Distro(distros.Distro):
     hostname_conf_fn = "/etc/sysconfig/network"
     systemd_hostname_conf_fn = "/etc/hostname"
     network_script_tpl = '/etc/sysconfig/network-scripts/ifcfg-%s'
-    resolve_conf_fn = "/etc/resolv.conf"
     tz_local_fn = "/etc/localtime"
     usr_lib_exec = "/usr/libexec"
     renderer_configs = {
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):
diff --git a/cloudinit/tests/test_util.py b/cloudinit/tests/test_util.py
index f9bc31be..a1ccb1dc 100644
--- a/cloudinit/tests/test_util.py
+++ b/cloudinit/tests/test_util.py
@@ -177,6 +177,17 @@ OS_RELEASE_UBUNTU = dedent("""\
     UBUNTU_CODENAME=xenial\n
 """)
 
+OS_RELEASE_PHOTON = ("""\
+        NAME="VMware Photon OS"
+        VERSION="4.0"
+        ID=photon
+        VERSION_ID=4.0
+        PRETTY_NAME="VMware Photon OS/Linux"
+        ANSI_COLOR="1;34"
+        HOME_URL="https://vmware.github.io/photon/"
+        BUG_REPORT_URL="https://github.com/vmware/photon/issues"
+""")
+
 
 class FakeCloud(object):
 
@@ -609,6 +620,15 @@ class TestGetLinuxDistro(CiTestCase):
         self.assertEqual(
             ('opensuse-tumbleweed', '20180920', platform.machine()), dist)
 
+    @mock.patch('cloudinit.util.load_file')
+    def test_get_linux_photon_os_release(self, m_os_release, m_path_exists):
+        """Verify we get the correct name and machine arch on PhotonOS"""
+        m_os_release.return_value = OS_RELEASE_PHOTON
+        m_path_exists.side_effect = TestGetLinuxDistro.os_release_exists
+        dist = util.get_linux_distro()
+        self.assertEqual(
+            ('photon', '4.0', 'VMware Photon OS/Linux'), dist)
+
     @mock.patch('platform.system')
     @mock.patch('platform.dist', create=True)
     def test_get_linux_distro_no_data(self, m_platform_dist,
diff --git a/cloudinit/util.py b/cloudinit/util.py
index f95dc435..7995c6c8 100644
--- a/cloudinit/util.py
+++ b/cloudinit/util.py
@@ -483,6 +483,8 @@ def get_linux_distro():
             # which will include both version codename and architecture
             # on all distributions.
             flavor = platform.machine()
+        elif distro_name == 'photon':
+            flavor = os_release.get('PRETTY_NAME', '')
         else:
             flavor = os_release.get('VERSION_CODENAME', '')
             if not flavor:
@@ -531,7 +533,7 @@ def system_info():
         linux_dist = info['dist'][0].lower()
         if linux_dist in (
                 'almalinux', 'alpine', 'arch', 'centos', 'debian', 'fedora',
-                'rhel', 'rocky', 'suse'):
+                'photon', 'rhel', 'rocky', 'suse'):
             var = linux_dist
         elif linux_dist in ('ubuntu', 'linuxmint', 'mint'):
             var = 'ubuntu'