Rework the rhel sysconfig writing/updating

so that it goes through a single function
which helps ensure correctness. Also write
to /etc/sysconfig/network when we have written
out devices to ensure that networking is on.

1 files changed, 64 insertions, 59 deletions

diff --git a/cloudinit/distros/rhel.py b/cloudinit/distros/rhel.py
index ec4dc2cc..c00627c6 100644
--- a/cloudinit/distros/rhel.py
+++ b/cloudinit/distros/rhel.py
@@ -26,6 +26,7 @@ from cloudinit import distros
 from cloudinit import helpers
 from cloudinit import log as logging
 from cloudinit import util
+from cloudinit import version
 
 from cloudinit.settings import PER_INSTANCE
 
@@ -55,6 +56,12 @@ D_QUOTE_CHARS = {
     '`': '\`',
 }
 
+def _make_sysconfig_bool(val):
+    if val:
+        return 'yes'
+    else:
+        return 'no'
+
 
 class Distro(distros.Distro):
 
@@ -76,9 +83,8 @@ class Distro(distros.Distro):
         if search_servers:
             contents.append("search %s" % (" ".join(search_servers)))
         if contents:
-            resolve_rw_fn = self._paths.join(False, "/etc/resolv.conf")
             contents.insert(0, '# Created by cloud-init')
-            util.write_file(resolve_rw_fn, "\n".join(contents), 0644)
+            util.write_file("/etc/resolv.conf", "\n".join(contents), 0644)
 
     def _write_network(self, settings):
         # TODO(harlowja) fix this... since this is the ubuntu format
@@ -88,81 +94,82 @@ class Distro(distros.Distro):
         # Make the intermediate format as the rhel format...
         nameservers = []
         searchservers = []
+        dev_names = entries.keys()
         for (dev, info) in entries.iteritems():
             net_fn = NETWORK_FN_TPL % (dev)
-            net_ro_fn = self._paths.join(True, net_fn)
-            (prev_exist, net_cfg) = self._read_conf(net_ro_fn)
-            net_cfg['DEVICE'] = dev
-            boot_proto = info.get('bootproto')
-            if boot_proto:
-                net_cfg['BOOTPROTO'] = boot_proto
-            net_mask = info.get('netmask')
-            if net_mask:
-                net_cfg["NETMASK"] = net_mask
-            addr = info.get('address')
-            if addr:
-                net_cfg["IPADDR"] = addr
-            if info.get('auto'):
-                net_cfg['ONBOOT'] = 'yes'
-            else:
-                net_cfg['ONBOOT'] = 'no'
-            gtway = info.get('gateway')
-            if gtway:
-                net_cfg["GATEWAY"] = gtway
-            bcast = info.get('broadcast')
-            if bcast:
-                net_cfg["BROADCAST"] = bcast
-            mac_addr = info.get('hwaddress')
-            if mac_addr:
-                net_cfg["MACADDR"] = mac_addr
-            lines = net_cfg.write()
+            net_cfg = {
+                'DEVICE': dev,
+                'NETMASK': info.get('netmask'),
+                'IPADDR': info.get('address'),
+                'BOOTPROTO': info.get('bootproto'),
+                'GATEWAY': info.get('gateway'),
+                'BROADCAST': info.get('broadcast'),
+                'MACADDR': info.get('hwaddress'),
+                'ONBOOT': _make_sysconfig_bool(info.get('auto')),
+            }
+            self._update_sysconfig_file(net_fn, net_cfg)
             if 'dns-nameservers' in info:
                 nameservers.extend(info['dns-nameservers'])
             if 'dns-search' in info:
                 searchservers.extend(info['dns-search'])
-            if not prev_exist:
-                lines.insert(0, '# Created by cloud-init')
-            w_contents = "\n".join(lines)
-            net_rw_fn = self._paths.join(False, net_fn)
-            util.write_file(net_rw_fn, w_contents, 0644)
         if nameservers or searchservers:
             self._write_resolve(nameservers, searchservers)
+        if dev_names:
+            net_cfg = {
+                'NETWORKING': _make_sysconfig_bool(True),
+            }
+            self._update_sysconfig_file("/etc/sysconfig/network", net_cfg)
+        return dev_names
+
+    def _update_sysconfig_file(self, fn, adjustments, allow_empty=False):
+        if not adjustments:
+            return
+        (exists, contents) = self._read_conf(fn)
+        updated_am = 0
+        for (k, v) in adjustments.items():
+            if v is None:
+                continue
+            v = str(v)
+            if len(v) == 0 and not allow_empty:
+                continue
+            contents[k] = v
+            updated_am += 1
+        if updated_am:
+            lines = contents.write()
+            if not exists:
+                ci_ver = version.version_string()
+                lines.insert(0, '# Created by cloud-init v. %s' % (ci_ver))
+            util.write_file(fn, "\n".join(lines), 0644)
 
     def set_hostname(self, hostname):
-        out_fn = self._paths.join(False, '/etc/sysconfig/network')
-        self._write_hostname(hostname, out_fn)
-        if out_fn == '/etc/sysconfig/network':
-            # Only do this if we are running in non-adjusted root mode
-            LOG.debug("Setting hostname to %s", hostname)
-            util.subp(['hostname', hostname])
+        self._write_hostname(hostname, '/etc/sysconfig/network')
+        LOG.debug("Setting hostname to %s", hostname)
+        util.subp(['hostname', hostname])
 
     def apply_locale(self, locale, out_fn=None):
         if not out_fn:
-            out_fn = self._paths.join(False, '/etc/sysconfig/i18n')
-        ro_fn = self._paths.join(True, '/etc/sysconfig/i18n')
-        (_exists, contents) = self._read_conf(ro_fn)
-        contents['LANG'] = locale
-        w_contents = "\n".join(contents.write())
-        util.write_file(out_fn, w_contents, 0644)
+            out_fn = '/etc/sysconfig/i18n'
+        locale_cfg = {
+            'LANG': locale,
+        }
+        self._update_sysconfig_file(out_fn, locale_cfg)
 
     def _write_hostname(self, hostname, out_fn):
-        (_exists, contents) = self._read_conf(out_fn)
-        contents['HOSTNAME'] = hostname
-        w_contents = "\n".join(contents.write())
-        util.write_file(out_fn, w_contents, 0644)
+        host_cfg = {
+            'HOSTNAME':  hostname,
+        }
+        self._update_sysconfig_file(out_fn, host_cfg)
 
     def update_hostname(self, hostname, prev_file):
         hostname_prev = self._read_hostname(prev_file)
-        read_fn = self._paths.join(True, "/etc/sysconfig/network")
-        hostname_in_sys = self._read_hostname(read_fn)
+        hostname_in_sys = self._read_hostname("/etc/sysconfig/network")
         update_files = []
         if not hostname_prev or hostname_prev != hostname:
             update_files.append(prev_file)
         if (not hostname_in_sys or
             (hostname_in_sys == hostname_prev
              and hostname_in_sys != hostname)):
-            write_fn = self._paths.join(False, "/etc/sysconfig/network")
-            update_files.append(write_fn)
+            update_files.append("/etc/sysconfig/network")
         for fn in update_files:
             try:
                 self._write_hostname(hostname, fn)
@@ -200,12 +207,10 @@ class Distro(distros.Distro):
             raise RuntimeError(("Invalid timezone %s,"
                                 " no file found at %s") % (tz, tz_file))
         # Adjust the sysconfig clock zone setting
-        read_fn = self._paths.join(True, "/etc/sysconfig/clock")
-        (_exists, contents) = self._read_conf(read_fn)
-        contents['ZONE'] = tz
-        tz_contents = "\n".join(contents.write())
-        write_fn = self._paths.join(False, "/etc/sysconfig/clock")
-        util.write_file(write_fn, tz_contents)
+        clock_cfg = {
+            'ZONE': tz,
+        }
+        self._update_sysconfig_file("/etc/sysconfig/clock", clock_cfg)
         # This ensures that the correct tz will be used for the system
         util.copy(tz_file, self._paths.join(False, "/etc/localtime"))