Provide an option to not cache bootable iso ramdisks

The behavior when a bootable iso is provided behind an http server is
to download and serve the image from the conductor; the image is
removed only when the node is undeployed.
In certain cases, for example on large deployments, this could cause
undesired behaviors, like the conductor nodes running out of disk storage.
We provide an option to avoid this event directly using the original url of
the bootable iso that is then served directly by the external http server
where it is hosted.

Change-Id: I6ecbe8ae4c775f5a39b68ff698bde655795e5db7

ironic/conf/deploy.py

@@ -193,6 +193,22 @@ opts = [
                        'cleaning operations to fail due to the possible '
                        'operational security risk of data being retained '
                        'between deployments of the bare metal node.')),
+    cfg.StrOpt('ramdisk_image_download_source',
+               choices=[('http', _('In case the ramdisk is already a bootable '
+                                   'iso, using this option it will be '
+                                   'directly provided by an external HTTP '
+                                   'service using its full url.')),
+                        ('local', _('This is the default behavior. '
+                                    'The image is downloaded, prepared and '
+                                    'cached locally, to be served from '
+                                    'the conductor.'))],
+               default='local',
+               mutable=True,
+               help=_('Specifies whether a boot iso image should be served '
+                      'from its own original location using the image source '
+                      'url directly, or if ironic should cache the image on '
+                      'the conductor and serve it from ironic\'s own http '
+                      'server.')),
 ]
 
 

ironic/drivers/modules/image_utils.py

@@ -404,7 +404,7 @@ def _prepare_iso_image(task, kernel_href, ramdisk_href,
     :param kernel_href: URL or Glance UUID of the kernel to use
     :param ramdisk_href: URL or Glance UUID of the ramdisk to use
     :param bootloader_href: URL or Glance UUID of the EFI bootloader
-         image to use when creating UEFI bootbable ISO
+         image to use when creating UEFI bootable ISO
     :param root_uuid: optional uuid of the root partition.
     :param params: a dictionary containing 'parameter name'->'value'
         mapping to be passed to kernel command line.
@@ -423,6 +423,15 @@ def _prepare_iso_image(task, kernel_href, ramdisk_href,
             "building ISO, or explicit ISO for %(node)s") %
             {'node': task.node.uuid})
 
+    # NOTE(rpittau): if base_iso is defined as http address, we just access
+    # it directly.
+    if base_iso and CONF.deploy.ramdisk_image_download_source == 'http':
+        if base_iso.startswith(('http://', 'https://')):
+            return base_iso
+        LOG.debug("ramdisk_image_download_source set to http but "
+                  "boot_iso is not an HTTP URL: %(boot_iso)s",
+                  {"boot_iso": base_iso})
+
     img_handler = ImageHandler(task.node.driver)
     k_param = img_handler.kernel_params
 

ironic/tests/unit/drivers/modules/test_image_utils.py

@@ -553,6 +553,36 @@ class RedfishImageUtilsTestCase(db_base.DbTestCase):
                 root_uuid='1be26c0b-03f2-4d2e-ae87-c02d7f33c123',
                 base_iso='/path/to/baseiso', inject_files=None)
 
+    def test__prepare_iso_image_bootable_iso(self):
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=True) as task:
+            base_image_url = 'http://bearmetal.net/boot.iso'
+            self.config(ramdisk_image_download_source='http', group='deploy')
+            url = image_utils._prepare_iso_image(
+                task, None, None, bootloader_href=None, root_uuid=None,
+                base_iso=base_image_url)
+            self.assertEqual(url, base_image_url)
+
+    @mock.patch.object(image_utils.ImageHandler, 'publish_image',
+                       autospec=True)
+    @mock.patch.object(images, 'create_boot_iso', autospec=True)
+    def test__prepare_iso_image_bootable_iso_file(self, mock_create_boot_iso,
+                                                  mock_publish_image):
+        with task_manager.acquire(self.context, self.node.uuid,
+                                  shared=True) as task:
+            base_image_url = '/path/to/baseiso'
+            self.config(ramdisk_image_download_source='http', group='deploy')
+            image_utils._prepare_iso_image(
+                task, 'http://kernel/img', 'http://ramdisk/img',
+                bootloader_href=None, root_uuid=task.node.uuid,
+                base_iso=base_image_url)
+            mock_create_boot_iso.assert_called_once_with(
+                mock.ANY, mock.ANY, 'http://kernel/img', 'http://ramdisk/img',
+                esp_image_href=None,
+                root_uuid='1be26c0b-03f2-4d2e-ae87-c02d7f33c123',
+                kernel_params='nofb nomodeset vga=normal', boot_mode='bios',
+                base_iso='/path/to/baseiso', inject_files=None)
+
     def test__find_param(self):
         param_dict = {
             'ilo_deploy_kernel': 'kernel',

releasenotes/notes/option-no-cache-http-ramdisk-62fc29cdd1d5b152.yaml

@@ -0,0 +1,14 @@
+---
+fixes:
+  - |
+    The behavior when a bootable iso ramdisk is provided behind an http server
+    is to download and serve the image from the conductor; the image is
+    removed only when the node is undeployed.
+    In certain cases, for example on large deployments, this could cause
+    undesired behaviors, like the conductor nodes running out of disk
+    storage.
+    To avoid this event we provide an option
+    ``[deploy]ramdisk_image_download_source`` to be able to tell the ramdisk
+    interface to directly use the bootable iso url from its original source
+    instead of downloading it and serving it from the conductor node.
+    The default behavior is unchanged.