[vmware] Cache images as VM templates

Upon user request, the driver can cache the image as a VM Template
and reuse that to create the volume(s). This feature is useful
when creating many volumes in parallel from the same image.

Users can request the image cache feature when creating the volume,
by passing the use_image_cache='true' as a property (metadata).

The feature must be enabled per backend, for example:
```
[vmware]
enable_image_cache = true
```
This will enable the image cache feature for the vmware backend.

The image templates will then be stored in a folder similar to the
volumes folder: OpensStack/Project (vmware_image_cache)/Volumes,
where {backend}_image_cache is used as a project name.

The driver will periodically delete the cached images that are
expired. The expiry time can be controlled via the property
`image_cache_age_seconds` set on the backend configuration.

Only images smaller than the configured `image_cache_max_size_gb`
will be cached.

Change-Id: I6f5e481f6997a180a455b47abe525b93bcf9aa4e

Author: leust

cinder/tests/unit/volume/drivers/vmware/test_vmware_vmdk.py

@@ -123,6 +123,8 @@ def setUp(self):
             vmware_random_datastore_range=None,
             vmware_datastores_as_pools=False,
             allow_pulling_images_from_url=False,
+            enable_image_cache=False,
+            image_cache_max_size_gb=0,
         )
 
         self._db = mock.Mock()
@@ -287,6 +289,7 @@ def _create_volume_dict(self,
                 'size': size,
                 'volume_attachment': attachment,
                 'project_id': project_id,
+                'metadata': {},
                 }
 
     def _create_volume_obj(self,
@@ -838,6 +841,68 @@ def test_copy_image_to_volume_with_extend_backing(self, vmware_disk_type):
     def test_copy_image_to_volume_with_ova_container(self):
         self._test_copy_image_to_volume(container_format='ova')
 
+    @ddt.data(
+        ({'enable_image_cache': False},
+         False),
+        ({'enable_image_cache': True, 'use_image_cache': 'N/A'},
+         False),
+        ({'enable_image_cache': True, 'use_image_cache': 'true',
+          'image_cache_max_size_gb': 1, 'image_size': 2 * units.Gi},
+         False),
+        ({'enable_image_cache': True, 'use_image_cache': 'true',
+          'image_cache_max_size_gb': 2, 'image_size': 2 * units.Gi},
+         True)
+    )
+    @ddt.unpack
+    @mock.patch.object(VMDK_DRIVER, '_do_copy_image_to_volume')
+    @mock.patch.object(VMDK_DRIVER, 'volumeops')
+    @mock.patch.object(VMDK_DRIVER, '_extend_backing')
+    @mock.patch.object(VMDK_DRIVER, '_create_volume_from_cached_image')
+    @mock.patch.object(VMDK_DRIVER, '_get_cached_image_backing')
+    def test_copy_image_to_volume_cached(self, params, expected,
+                                         mock_get_cached_backing,
+                                         mock_create_from_cached,
+                                         mock_extend_backing,
+                                         mock_volumeops,
+                                         mock_do_copy_image):
+        self._config.enable_image_cache = (
+            params.get('enable_image_cache', False))
+        self._config.image_cache_max_size_gb = (
+            params.get('image_cache_max_size_gb', 0))
+
+        volume = self._create_volume_dict()
+
+        use_image_cache = params.get('use_image_cache')
+        if use_image_cache:
+            volume['metadata']['use_image_cache'] = use_image_cache
+
+        backing = mock.sentinel.backing
+        mock_volumeops.get_backing.return_value = backing
+        mock_volumeops.get_disk_size.return_value = self.VOL_SIZE * units.Gi
+
+        mock_get_cached_backing.return_value = mock.sentinel.backing
+
+        image_service = mock.Mock()
+        image_meta = self._create_image_meta(
+            size=params.get('image_size', 1 * units.Gi))
+        image_service.show.return_value = image_meta
+
+        self._driver.copy_image_to_volume(
+            mock.sentinel.context, volume, image_service, self.IMAGE_ID)
+
+        if expected:
+            mock_do_copy_image.assert_not_called()
+            mock_get_cached_backing.assert_called_once_with(
+                mock.sentinel.context, volume,
+                image_service, self.IMAGE_ID, image_meta)
+            mock_create_from_cached.assert_called_once_with(
+                volume, backing)
+        else:
+            mock_get_cached_backing.assert_not_called()
+            mock_do_copy_image.assert_called_once_with(
+                mock.sentinel.context, volume,
+                image_service, self.IMAGE_ID, image_meta)
+
     @mock.patch('cinder.volume.drivers.vmware.vmdk.VMwareVcVmdkDriver.'
                 '_get_disk_type')
     @mock.patch.object(VMDK_DRIVER, '_check_disk_conversion')