Adopt Black and isort (SC-700) (#1157)

Applied Black and isort, fixed any linting issues, updated tox.ini
and CI.

1 files changed, 384 insertions, 275 deletions

diff --git a/cloudinit/config/cc_chef.py b/cloudinit/config/cc_chef.py
index ed734d1c..67889683 100644
--- a/cloudinit/config/cc_chef.py
+++ b/cloudinit/config/cc_chef.py
@@ -13,87 +13,91 @@ import json
 import os
 from textwrap import dedent
 
-from cloudinit import subp
+from cloudinit import subp, temp_utils, templater, url_helper, util
 from cloudinit.config.schema import get_meta_doc, validate_cloudconfig_schema
-from cloudinit import templater
-from cloudinit import temp_utils
-from cloudinit import url_helper
-from cloudinit import util
 from cloudinit.settings import PER_ALWAYS
 
-
 RUBY_VERSION_DEFAULT = "1.8"
 
-CHEF_DIRS = tuple([
-    '/etc/chef',
-    '/var/log/chef',
-    '/var/lib/chef',
-    '/var/cache/chef',
-    '/var/backups/chef',
-    '/var/run/chef',
-])
-REQUIRED_CHEF_DIRS = tuple([
-    '/etc/chef',
-])
+CHEF_DIRS = tuple(
+    [
+        "/etc/chef",
+        "/var/log/chef",
+        "/var/lib/chef",
+        "/var/cache/chef",
+        "/var/backups/chef",
+        "/var/run/chef",
+    ]
+)
+REQUIRED_CHEF_DIRS = tuple(
+    [
+        "/etc/chef",
+    ]
+)
 
 # Used if fetching chef from a omnibus style package
 OMNIBUS_URL = "https://www.chef.io/chef/install.sh"
 OMNIBUS_URL_RETRIES = 5
 
-CHEF_VALIDATION_PEM_PATH = '/etc/chef/validation.pem'
-CHEF_ENCRYPTED_DATA_BAG_PATH = '/etc/chef/encrypted_data_bag_secret'
-CHEF_ENVIRONMENT = '_default'
-CHEF_FB_PATH = '/etc/chef/firstboot.json'
+CHEF_VALIDATION_PEM_PATH = "/etc/chef/validation.pem"
+CHEF_ENCRYPTED_DATA_BAG_PATH = "/etc/chef/encrypted_data_bag_secret"
+CHEF_ENVIRONMENT = "_default"
+CHEF_FB_PATH = "/etc/chef/firstboot.json"
 CHEF_RB_TPL_DEFAULTS = {
     # These are ruby symbols...
-    'ssl_verify_mode': ':verify_none',
-    'log_level': ':info',
+    "ssl_verify_mode": ":verify_none",
+    "log_level": ":info",
     # These are not symbols...
-    'log_location': '/var/log/chef/client.log',
-    'validation_key': CHEF_VALIDATION_PEM_PATH,
-    'validation_cert': None,
-    'client_key': '/etc/chef/client.pem',
-    'json_attribs': CHEF_FB_PATH,
-    'file_cache_path': '/var/cache/chef',
-    'file_backup_path': '/var/backups/chef',
-    'pid_file': '/var/run/chef/client.pid',
-    'show_time': True,
-    'encrypted_data_bag_secret': None,
+    "log_location": "/var/log/chef/client.log",
+    "validation_key": CHEF_VALIDATION_PEM_PATH,
+    "validation_cert": None,
+    "client_key": "/etc/chef/client.pem",
+    "json_attribs": CHEF_FB_PATH,
+    "file_cache_path": "/var/cache/chef",
+    "file_backup_path": "/var/backups/chef",
+    "pid_file": "/var/run/chef/client.pid",
+    "show_time": True,
+    "encrypted_data_bag_secret": None,
 }
-CHEF_RB_TPL_BOOL_KEYS = frozenset(['show_time'])
-CHEF_RB_TPL_PATH_KEYS = frozenset([
-    'log_location',
-    'validation_key',
-    'client_key',
-    'file_cache_path',
-    'json_attribs',
-    'pid_file',
-    'encrypted_data_bag_secret',
-])
+CHEF_RB_TPL_BOOL_KEYS = frozenset(["show_time"])
+CHEF_RB_TPL_PATH_KEYS = frozenset(
+    [
+        "log_location",
+        "validation_key",
+        "client_key",
+        "file_cache_path",
+        "json_attribs",
+        "pid_file",
+        "encrypted_data_bag_secret",
+    ]
+)
 CHEF_RB_TPL_KEYS = list(CHEF_RB_TPL_DEFAULTS.keys())
 CHEF_RB_TPL_KEYS.extend(CHEF_RB_TPL_BOOL_KEYS)
 CHEF_RB_TPL_KEYS.extend(CHEF_RB_TPL_PATH_KEYS)
-CHEF_RB_TPL_KEYS.extend([
-    'server_url',
-    'node_name',
-    'environment',
-    'validation_name',
-    'chef_license',
-])
+CHEF_RB_TPL_KEYS.extend(
+    [
+        "server_url",
+        "node_name",
+        "environment",
+        "validation_name",
+        "chef_license",
+    ]
+)
 CHEF_RB_TPL_KEYS = frozenset(CHEF_RB_TPL_KEYS)
-CHEF_RB_PATH = '/etc/chef/client.rb'
-CHEF_EXEC_PATH = '/usr/bin/chef-client'
-CHEF_EXEC_DEF_ARGS = tuple(['-d', '-i', '1800', '-s', '20'])
+CHEF_RB_PATH = "/etc/chef/client.rb"
+CHEF_EXEC_PATH = "/usr/bin/chef-client"
+CHEF_EXEC_DEF_ARGS = tuple(["-d", "-i", "1800", "-s", "20"])
 
 
 frequency = PER_ALWAYS
 distros = ["all"]
 
 meta = {
-    'id': 'cc_chef',
-    'name': 'Chef',
-    'title': 'module that configures, starts and installs chef',
-    'description': dedent("""\
+    "id": "cc_chef",
+    "name": "Chef",
+    "title": "module that configures, starts and installs chef",
+    "description": dedent(
+        """\
         This module enables chef to be installed (from packages,
         gems, or from omnibus). Before this occurs, chef configuration is
         written to disk (validation.pem, client.pem, firstboot.json,
@@ -101,9 +105,12 @@ meta = {
         /var/log/chef and so-on). If configured, chef will be
         installed and started in either daemon or non-daemon mode.
         If run in non-daemon mode, post run actions are executed to do
-        finishing activities such as removing validation.pem."""),
-    'distros': distros,
-    'examples': [dedent("""
+        finishing activities such as removing validation.pem."""
+    ),
+    "distros": distros,
+    "examples": [
+        dedent(
+            """
         chef:
           directories:
             - /etc/chef
@@ -124,180 +131,237 @@ meta = {
           omnibus_url_retries: 2
           server_url: https://chef.yourorg.com:4000
           ssl_verify_mode: :verify_peer
-          validation_name: yourorg-validator""")],
-    'frequency': frequency,
+          validation_name: yourorg-validator"""
+        )
+    ],
+    "frequency": frequency,
 }
 
 schema = {
-    'type': 'object',
-    'properties': {
-        'chef': {
-            'type': 'object',
-            'additionalProperties': False,
-            'properties': {
-                'directories': {
-                    'type': 'array',
-                    'items': {
-                        'type': 'string'
-                    },
-                    'uniqueItems': True,
-                    'description': dedent("""\
+    "type": "object",
+    "properties": {
+        "chef": {
+            "type": "object",
+            "additionalProperties": False,
+            "properties": {
+                "directories": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "uniqueItems": True,
+                    "description": dedent(
+                        """\
                         Create the necessary directories for chef to run. By
                         default, it creates the following directories:
 
-                        {chef_dirs}""").format(
+                        {chef_dirs}"""
+                    ).format(
                         chef_dirs="\n".join(
                             ["   - ``{}``".format(d) for d in CHEF_DIRS]
                         )
-                    )
+                    ),
                 },
-                'validation_cert': {
-                    'type': 'string',
-                    'description': dedent("""\
+                "validation_cert": {
+                    "type": "string",
+                    "description": dedent(
+                        """\
                         Optional string to be written to file validation_key.
                         Special value ``system`` means set use existing file.
-                        """)
+                        """
+                    ),
                 },
-                'validation_key': {
-                    'type': 'string',
-                    'default': CHEF_VALIDATION_PEM_PATH,
-                    'description': dedent("""\
+                "validation_key": {
+                    "type": "string",
+                    "default": CHEF_VALIDATION_PEM_PATH,
+                    "description": dedent(
+                        """\
                         Optional path for validation_cert. default to
-                        ``{}``.""".format(CHEF_VALIDATION_PEM_PATH))
+                        ``{}``.""".format(
+                            CHEF_VALIDATION_PEM_PATH
+                        )
+                    ),
                 },
-                'firstboot_path': {
-                    'type': 'string',
-                    'default': CHEF_FB_PATH,
-                    'description': dedent("""\
+                "firstboot_path": {
+                    "type": "string",
+                    "default": CHEF_FB_PATH,
+                    "description": dedent(
+                        """\
                         Path to write run_list and initial_attributes keys that
                         should also be present in this configuration, defaults
-                        to ``{}``.""".format(CHEF_FB_PATH))
+                        to ``{}``.""".format(
+                            CHEF_FB_PATH
+                        )
+                    ),
                 },
-                'exec': {
-                    'type': 'boolean',
-                    'default': False,
-                    'description': dedent("""\
+                "exec": {
+                    "type": "boolean",
+                    "default": False,
+                    "description": dedent(
+                        """\
                         define if we should run or not run chef (defaults to
                         false, unless a gem installed is requested where this
-                        will then default to true).""")
+                        will then default to true)."""
+                    ),
                 },
-                'client_key': {
-                    'type': 'string',
-                    'default': CHEF_RB_TPL_DEFAULTS['client_key'],
-                    'description': dedent("""\
+                "client_key": {
+                    "type": "string",
+                    "default": CHEF_RB_TPL_DEFAULTS["client_key"],
+                    "description": dedent(
+                        """\
                         Optional path for client_cert. default to
-                        ``{}``.""".format(CHEF_RB_TPL_DEFAULTS['client_key']))
+                        ``{}``.""".format(
+                            CHEF_RB_TPL_DEFAULTS["client_key"]
+                        )
+                    ),
                 },
-                'encrypted_data_bag_secret': {
-                    'type': 'string',
-                    'default': None,
-                    'description': dedent("""\
+                "encrypted_data_bag_secret": {
+                    "type": "string",
+                    "default": None,
+                    "description": dedent(
+                        """\
                         Specifies the location of the secret key used by chef
                         to encrypt data items. By default, this path is set
                         to None, meaning that chef will have to look at the
                         path ``{}`` for it.
-                        """.format(CHEF_ENCRYPTED_DATA_BAG_PATH))
+                        """.format(
+                            CHEF_ENCRYPTED_DATA_BAG_PATH
+                        )
+                    ),
                 },
-                'environment': {
-                    'type': 'string',
-                    'default': CHEF_ENVIRONMENT,
-                    'description': dedent("""\
+                "environment": {
+                    "type": "string",
+                    "default": CHEF_ENVIRONMENT,
+                    "description": dedent(
+                        """\
                         Specifies which environment chef will use. By default,
                         it will use the ``{}`` configuration.
-                        """.format(CHEF_ENVIRONMENT))
+                        """.format(
+                            CHEF_ENVIRONMENT
+                        )
+                    ),
                 },
-                'file_backup_path': {
-                    'type': 'string',
-                    'default': CHEF_RB_TPL_DEFAULTS['file_backup_path'],
-                    'description': dedent("""\
+                "file_backup_path": {
+                    "type": "string",
+                    "default": CHEF_RB_TPL_DEFAULTS["file_backup_path"],
+                    "description": dedent(
+                        """\
                         Specifies the location in which backup files are
                         stored. By default, it uses the
                         ``{}`` location.""".format(
-                            CHEF_RB_TPL_DEFAULTS['file_backup_path']))
+                            CHEF_RB_TPL_DEFAULTS["file_backup_path"]
+                        )
+                    ),
                 },
-                'file_cache_path': {
-                    'type': 'string',
-                    'default': CHEF_RB_TPL_DEFAULTS['file_cache_path'],
-                    'description': dedent("""\
+                "file_cache_path": {
+                    "type": "string",
+                    "default": CHEF_RB_TPL_DEFAULTS["file_cache_path"],
+                    "description": dedent(
+                        """\
                         Specifies the location in which chef cache files will
                         be saved. By default, it uses the ``{}``
                         location.""".format(
-                            CHEF_RB_TPL_DEFAULTS['file_cache_path']))
+                            CHEF_RB_TPL_DEFAULTS["file_cache_path"]
+                        )
+                    ),
                 },
-                'json_attribs': {
-                    'type': 'string',
-                    'default': CHEF_FB_PATH,
-                    'description': dedent("""\
+                "json_attribs": {
+                    "type": "string",
+                    "default": CHEF_FB_PATH,
+                    "description": dedent(
+                        """\
                         Specifies the location in which some chef json data is
                         stored. By default, it uses the
-                        ``{}`` location.""".format(CHEF_FB_PATH))
+                        ``{}`` location.""".format(
+                            CHEF_FB_PATH
+                        )
+                    ),
                 },
-                'log_level': {
-                    'type': 'string',
-                    'default': CHEF_RB_TPL_DEFAULTS['log_level'],
-                    'description': dedent("""\
+                "log_level": {
+                    "type": "string",
+                    "default": CHEF_RB_TPL_DEFAULTS["log_level"],
+                    "description": dedent(
+                        """\
                         Defines the level of logging to be stored in the log
                         file. By default this value is set to ``{}``.
-                        """.format(CHEF_RB_TPL_DEFAULTS['log_level']))
+                        """.format(
+                            CHEF_RB_TPL_DEFAULTS["log_level"]
+                        )
+                    ),
                 },
-                'log_location': {
-                    'type': 'string',
-                    'default': CHEF_RB_TPL_DEFAULTS['log_location'],
-                    'description': dedent("""\
+                "log_location": {
+                    "type": "string",
+                    "default": CHEF_RB_TPL_DEFAULTS["log_location"],
+                    "description": dedent(
+                        """\
                         Specifies the location of the chef lof file. By
                         default, the location is specified at
                         ``{}``.""".format(
-                            CHEF_RB_TPL_DEFAULTS['log_location']))
+                            CHEF_RB_TPL_DEFAULTS["log_location"]
+                        )
+                    ),
                 },
-                'node_name': {
-                    'type': 'string',
-                    'description': dedent("""\
+                "node_name": {
+                    "type": "string",
+                    "description": dedent(
+                        """\
                         The name of the node to run. By default, we will
-                        use th instance id as the node name.""")
+                        use th instance id as the node name."""
+                    ),
                 },
-                'omnibus_url': {
-                    'type': 'string',
-                    'default': OMNIBUS_URL,
-                    'description': dedent("""\
+                "omnibus_url": {
+                    "type": "string",
+                    "default": OMNIBUS_URL,
+                    "description": dedent(
+                        """\
                         Omnibus URL if chef should be installed through
                         Omnibus. By default, it uses the
-                        ``{}``.""".format(OMNIBUS_URL))
+                        ``{}``.""".format(
+                            OMNIBUS_URL
+                        )
+                    ),
                 },
-                'omnibus_url_retries': {
-                    'type': 'integer',
-                    'default': OMNIBUS_URL_RETRIES,
-                    'description': dedent("""\
+                "omnibus_url_retries": {
+                    "type": "integer",
+                    "default": OMNIBUS_URL_RETRIES,
+                    "description": dedent(
+                        """\
                         The number of retries that will be attempted to reach
-                        the Omnibus URL""")
+                        the Omnibus URL"""
+                    ),
                 },
-                'omnibus_version': {
-                    'type': 'string',
-                    'description': dedent("""\
+                "omnibus_version": {
+                    "type": "string",
+                    "description": dedent(
+                        """\
                         Optional version string to require for omnibus
-                        install.""")
+                        install."""
+                    ),
                 },
-                'pid_file': {
-                    'type': 'string',
-                    'default': CHEF_RB_TPL_DEFAULTS['pid_file'],
-                    'description': dedent("""\
+                "pid_file": {
+                    "type": "string",
+                    "default": CHEF_RB_TPL_DEFAULTS["pid_file"],
+                    "description": dedent(
+                        """\
                         The location in which a process identification
                         number (pid) is saved. By default, it saves
                         in the ``{}`` location.""".format(
-                            CHEF_RB_TPL_DEFAULTS['pid_file']))
+                            CHEF_RB_TPL_DEFAULTS["pid_file"]
+                        )
+                    ),
                 },
-                'server_url': {
-                    'type': 'string',
-                    'description': 'The URL for the chef server'
+                "server_url": {
+                    "type": "string",
+                    "description": "The URL for the chef server",
                 },
-                'show_time': {
-                    'type': 'boolean',
-                    'default': True,
-                    'description': 'Show time in chef logs'
+                "show_time": {
+                    "type": "boolean",
+                    "default": True,
+                    "description": "Show time in chef logs",
                 },
-                'ssl_verify_mode': {
-                    'type': 'string',
-                    'default': CHEF_RB_TPL_DEFAULTS['ssl_verify_mode'],
-                    'description': dedent("""\
+                "ssl_verify_mode": {
+                    "type": "string",
+                    "default": CHEF_RB_TPL_DEFAULTS["ssl_verify_mode"],
+                    "description": dedent(
+                        """\
                         Set the verify mode for HTTPS requests. We can have
                         two possible values for this parameter:
 
@@ -306,67 +370,76 @@ schema = {
                             - ``:verify_peer``: Validate all SSL certificates.
 
                         By default, the parameter is set as ``{}``.
-                        """.format(CHEF_RB_TPL_DEFAULTS['ssl_verify_mode']))
+                        """.format(
+                            CHEF_RB_TPL_DEFAULTS["ssl_verify_mode"]
+                        )
+                    ),
                 },
-                'validation_name': {
-                    'type': 'string',
-                    'description': dedent("""\
+                "validation_name": {
+                    "type": "string",
+                    "description": dedent(
+                        """\
                         The name of the chef-validator key that Chef Infra
                         Client uses to access the Chef Infra Server during
-                        the initial Chef Infra Client run.""")
+                        the initial Chef Infra Client run."""
+                    ),
                 },
-                'force_install': {
-                    'type': 'boolean',
-                    'default': False,
-                    'description': dedent("""\
+                "force_install": {
+                    "type": "boolean",
+                    "default": False,
+                    "description": dedent(
+                        """\
                         If set to ``True``, forces chef installation, even
-                        if it is already installed.""")
+                        if it is already installed."""
+                    ),
                 },
-                'initial_attributes': {
-                    'type': 'object',
-                    'items': {
-                        'type': 'string'
-                    },
-                    'description': dedent("""\
+                "initial_attributes": {
+                    "type": "object",
+                    "items": {"type": "string"},
+                    "description": dedent(
+                        """\
                         Specify a list of initial attributes used by the
-                        cookbooks.""")
+                        cookbooks."""
+                    ),
                 },
-                'install_type': {
-                    'type': 'string',
-                    'default': 'packages',
-                    'description': dedent("""\
+                "install_type": {
+                    "type": "string",
+                    "default": "packages",
+                    "description": dedent(
+                        """\
                         The type of installation for chef. It can be one of
                         the following values:
 
                             - ``packages``
                             - ``gems``
-                            - ``omnibus``""")
+                            - ``omnibus``"""
+                    ),
                 },
-                'run_list': {
-                    'type': 'array',
-                    'items': {
-                        'type': 'string'
-                    },
-                    'description': 'A run list for a first boot json.'
+                "run_list": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "A run list for a first boot json.",
                 },
                 "chef_license": {
-                    'type': 'string',
-                    'description': dedent("""\
+                    "type": "string",
+                    "description": dedent(
+                        """\
                         string that indicates if user accepts or not license
-                        related to some of chef products""")
-                }
-            }
+                        related to some of chef products"""
+                    ),
+                },
+            },
         }
-    }
+    },
 }
 
 __doc__ = get_meta_doc(meta, schema)
 
 
 def post_run_chef(chef_cfg, log):
-    delete_pem = util.get_cfg_option_bool(chef_cfg,
-                                          'delete_validation_post_exec',
-                                          default=False)
+    delete_pem = util.get_cfg_option_bool(
+        chef_cfg, "delete_validation_post_exec", default=False
+    )
     if delete_pem and os.path.isfile(CHEF_VALIDATION_PEM_PATH):
         os.unlink(CHEF_VALIDATION_PEM_PATH)
 
@@ -389,16 +462,20 @@ def get_template_params(iid, chef_cfg, log):
             else:
                 params[k] = util.get_cfg_option_str(chef_cfg, k)
     # These ones are overwritten to be exact values...
-    params.update({
-        'generated_by': util.make_header(),
-        'node_name': util.get_cfg_option_str(chef_cfg, 'node_name',
-                                             default=iid),
-        'environment': util.get_cfg_option_str(chef_cfg, 'environment',
-                                               default='_default'),
-        # These two are mandatory...
-        'server_url': chef_cfg['server_url'],
-        'validation_name': chef_cfg['validation_name'],
-    })
+    params.update(
+        {
+            "generated_by": util.make_header(),
+            "node_name": util.get_cfg_option_str(
+                chef_cfg, "node_name", default=iid
+            ),
+            "environment": util.get_cfg_option_str(
+                chef_cfg, "environment", default="_default"
+            ),
+            # These two are mandatory...
+            "server_url": chef_cfg["server_url"],
+            "validation_name": chef_cfg["validation_name"],
+        }
+    )
     return params
 
 
@@ -406,35 +483,38 @@ def handle(name, cfg, cloud, log, _args):
     """Handler method activated by cloud-init."""
 
     # If there isn't a chef key in the configuration don't do anything
-    if 'chef' not in cfg:
-        log.debug(("Skipping module named %s,"
-                   " no 'chef' key in configuration"), name)
+    if "chef" not in cfg:
+        log.debug(
+            "Skipping module named %s, no 'chef' key in configuration", name
+        )
         return
 
     validate_cloudconfig_schema(cfg, schema)
-    chef_cfg = cfg['chef']
+    chef_cfg = cfg["chef"]
 
     # Ensure the chef directories we use exist
-    chef_dirs = util.get_cfg_option_list(chef_cfg, 'directories')
+    chef_dirs = util.get_cfg_option_list(chef_cfg, "directories")
     if not chef_dirs:
         chef_dirs = list(CHEF_DIRS)
     for d in itertools.chain(chef_dirs, REQUIRED_CHEF_DIRS):
         util.ensure_dir(d)
 
-    vkey_path = chef_cfg.get('validation_key', CHEF_VALIDATION_PEM_PATH)
-    vcert = chef_cfg.get('validation_cert')
+    vkey_path = chef_cfg.get("validation_key", CHEF_VALIDATION_PEM_PATH)
+    vcert = chef_cfg.get("validation_cert")
     # special value 'system' means do not overwrite the file
     # but still render the template to contain 'validation_key'
     if vcert:
         if vcert != "system":
             util.write_file(vkey_path, vcert)
         elif not os.path.isfile(vkey_path):
-            log.warning("chef validation_cert provided as 'system', but "
-                        "validation_key path '%s' does not exist.",
-                        vkey_path)
+            log.warning(
+                "chef validation_cert provided as 'system', but "
+                "validation_key path '%s' does not exist.",
+                vkey_path,
+            )
 
     # Create the chef config from template
-    template_fn = cloud.get_template_filename('chef_client.rb')
+    template_fn = cloud.get_template_filename("chef_client.rb")
     if template_fn:
         iid = str(cloud.datasource.get_instance_id())
         params = get_template_params(iid, chef_cfg, log)
@@ -448,32 +528,33 @@ def handle(name, cfg, cloud, log, _args):
         util.ensure_dirs(param_paths)
         templater.render_to_file(template_fn, CHEF_RB_PATH, params)
     else:
-        log.warning("No template found, not rendering to %s",
-                    CHEF_RB_PATH)
+        log.warning("No template found, not rendering to %s", CHEF_RB_PATH)
 
     # Set the firstboot json
-    fb_filename = util.get_cfg_option_str(chef_cfg, 'firstboot_path',
-                                          default=CHEF_FB_PATH)
+    fb_filename = util.get_cfg_option_str(
+        chef_cfg, "firstboot_path", default=CHEF_FB_PATH
+    )
     if not fb_filename:
         log.info("First boot path empty, not writing first boot json file")
     else:
         initial_json = {}
-        if 'run_list' in chef_cfg:
-            initial_json['run_list'] = chef_cfg['run_list']
-        if 'initial_attributes' in chef_cfg:
-            initial_attributes = chef_cfg['initial_attributes']
+        if "run_list" in chef_cfg:
+            initial_json["run_list"] = chef_cfg["run_list"]
+        if "initial_attributes" in chef_cfg:
+            initial_attributes = chef_cfg["initial_attributes"]
             for k in list(initial_attributes.keys()):
                 initial_json[k] = initial_attributes[k]
         util.write_file(fb_filename, json.dumps(initial_json))
 
     # Try to install chef, if its not already installed...
-    force_install = util.get_cfg_option_bool(chef_cfg,
-                                             'force_install', default=False)
+    force_install = util.get_cfg_option_bool(
+        chef_cfg, "force_install", default=False
+    )
     installed = subp.is_exe(CHEF_EXEC_PATH)
     if not installed or force_install:
         run = install_chef(cloud, chef_cfg, log)
     elif installed:
-        run = util.get_cfg_option_bool(chef_cfg, 'exec', default=False)
+        run = util.get_cfg_option_bool(chef_cfg, "exec", default=False)
     else:
         run = False
     if run:
@@ -482,18 +563,21 @@ def handle(name, cfg, cloud, log, _args):
 
 
 def run_chef(chef_cfg, log):
-    log.debug('Running chef-client')
+    log.debug("Running chef-client")
     cmd = [CHEF_EXEC_PATH]
-    if 'exec_arguments' in chef_cfg:
-        cmd_args = chef_cfg['exec_arguments']
+    if "exec_arguments" in chef_cfg:
+        cmd_args = chef_cfg["exec_arguments"]
         if isinstance(cmd_args, (list, tuple)):
             cmd.extend(cmd_args)
         elif isinstance(cmd_args, str):
             cmd.append(cmd_args)
         else:
-            log.warning("Unknown type %s provided for chef"
-                        " 'exec_arguments' expected list, tuple,"
-                        " or string", type(cmd_args))
+            log.warning(
+                "Unknown type %s provided for chef"
+                " 'exec_arguments' expected list, tuple,"
+                " or string",
+                type(cmd_args),
+            )
             cmd.extend(CHEF_EXEC_DEF_ARGS)
     else:
         cmd.extend(CHEF_EXEC_DEF_ARGS)
@@ -507,16 +591,16 @@ def subp_blob_in_tempfile(blob, *args, **kwargs):
     The 'args' argument to subp will be updated with the full path to the
     filename as the first argument.
     """
-    basename = kwargs.pop('basename', "subp_blob")
+    basename = kwargs.pop("basename", "subp_blob")
 
-    if len(args) == 0 and 'args' not in kwargs:
+    if len(args) == 0 and "args" not in kwargs:
         args = [tuple()]
 
     # Use tmpdir over tmpfile to avoid 'text file busy' on execute
     with temp_utils.tempdir(needs_exe=True) as tmpd:
         tmpf = os.path.join(tmpd, basename)
-        if 'args' in kwargs:
-            kwargs['args'] = [tmpf] + list(kwargs['args'])
+        if "args" in kwargs:
+            kwargs["args"] = [tmpf] + list(kwargs["args"])
         else:
             args = list(args)
             args[0] = [tmpf] + args[0]
@@ -543,36 +627,39 @@ def install_chef_from_omnibus(url=None, retries=None, omnibus_version=None):
     if omnibus_version is None:
         args = []
     else:
-        args = ['-v', omnibus_version]
+        args = ["-v", omnibus_version]
     content = url_helper.readurl(url=url, retries=retries).contents
     return subp_blob_in_tempfile(
-        blob=content, args=args,
-        basename='chef-omnibus-install', capture=False)
+        blob=content, args=args, basename="chef-omnibus-install", capture=False
+    )
 
 
 def install_chef(cloud, chef_cfg, log):
     # If chef is not installed, we install chef based on 'install_type'
-    install_type = util.get_cfg_option_str(chef_cfg, 'install_type',
-                                           'packages')
-    run = util.get_cfg_option_bool(chef_cfg, 'exec', default=False)
+    install_type = util.get_cfg_option_str(
+        chef_cfg, "install_type", "packages"
+    )
+    run = util.get_cfg_option_bool(chef_cfg, "exec", default=False)
     if install_type == "gems":
         # This will install and run the chef-client from gems
-        chef_version = util.get_cfg_option_str(chef_cfg, 'version', None)
-        ruby_version = util.get_cfg_option_str(chef_cfg, 'ruby_version',
-                                               RUBY_VERSION_DEFAULT)
+        chef_version = util.get_cfg_option_str(chef_cfg, "version", None)
+        ruby_version = util.get_cfg_option_str(
+            chef_cfg, "ruby_version", RUBY_VERSION_DEFAULT
+        )
         install_chef_from_gems(ruby_version, chef_version, cloud.distro)
         # Retain backwards compat, by preferring True instead of False
         # when not provided/overriden...
-        run = util.get_cfg_option_bool(chef_cfg, 'exec', default=True)
-    elif install_type == 'packages':
+        run = util.get_cfg_option_bool(chef_cfg, "exec", default=True)
+    elif install_type == "packages":
         # This will install and run the chef-client from packages
-        cloud.distro.install_packages(('chef',))
-    elif install_type == 'omnibus':
+        cloud.distro.install_packages(("chef",))
+    elif install_type == "omnibus":
         omnibus_version = util.get_cfg_option_str(chef_cfg, "omnibus_version")
         install_chef_from_omnibus(
             url=util.get_cfg_option_str(chef_cfg, "omnibus_url"),
             retries=util.get_cfg_option_int(chef_cfg, "omnibus_url_retries"),
-            omnibus_version=omnibus_version)
+            omnibus_version=omnibus_version,
+        )
     else:
         log.warning("Unknown chef install type '%s'", install_type)
         run = False
@@ -581,25 +668,47 @@ def install_chef(cloud, chef_cfg, log):
 
 def get_ruby_packages(version):
     # return a list of packages needed to install ruby at version
-    pkgs = ['ruby%s' % version, 'ruby%s-dev' % version]
+    pkgs = ["ruby%s" % version, "ruby%s-dev" % version]
     if version == "1.8":
-        pkgs.extend(('libopenssl-ruby1.8', 'rubygems1.8'))
+        pkgs.extend(("libopenssl-ruby1.8", "rubygems1.8"))
     return pkgs
 
 
 def install_chef_from_gems(ruby_version, chef_version, distro):
     distro.install_packages(get_ruby_packages(ruby_version))
-    if not os.path.exists('/usr/bin/gem'):
-        util.sym_link('/usr/bin/gem%s' % ruby_version, '/usr/bin/gem')
-    if not os.path.exists('/usr/bin/ruby'):
-        util.sym_link('/usr/bin/ruby%s' % ruby_version, '/usr/bin/ruby')
+    if not os.path.exists("/usr/bin/gem"):
+        util.sym_link("/usr/bin/gem%s" % ruby_version, "/usr/bin/gem")
+    if not os.path.exists("/usr/bin/ruby"):
+        util.sym_link("/usr/bin/ruby%s" % ruby_version, "/usr/bin/ruby")
     if chef_version:
-        subp.subp(['/usr/bin/gem', 'install', 'chef',
-                   '-v %s' % chef_version, '--no-ri',
-                   '--no-rdoc', '--bindir', '/usr/bin', '-q'], capture=False)
+        subp.subp(
+            [
+                "/usr/bin/gem",
+                "install",
+                "chef",
+                "-v %s" % chef_version,
+                "--no-ri",
+                "--no-rdoc",
+                "--bindir",
+                "/usr/bin",
+                "-q",
+            ],
+            capture=False,
+        )
     else:
-        subp.subp(['/usr/bin/gem', 'install', 'chef',
-                   '--no-ri', '--no-rdoc', '--bindir',
-                   '/usr/bin', '-q'], capture=False)
+        subp.subp(
+            [
+                "/usr/bin/gem",
+                "install",
+                "chef",
+                "--no-ri",
+                "--no-rdoc",
+                "--bindir",
+                "/usr/bin",
+                "-q",
+            ],
+            capture=False,
+        )
+
 
 # vi: ts=4 expandtab