Merge "Add support for cache clean and prune APIs"

Author: Zuul

glanceclient/tests/unit/v2/test_cache.py

@@ -70,6 +70,21 @@
             ['http://node1.example', 'http://node2.example'],
         ),
     },
+    '/v2/cache/clean': {
+        'POST': (
+            {},
+            '',
+        ),
+    },
+    '/v2/cache/prune': {
+        'POST': (
+            {},
+            {
+                'total_files_pruned': 5,
+                'total_bytes_pruned': 104857600,
+            },
+        ),
+    },
 }
 
 
@@ -176,3 +191,31 @@ def test_list_cached_nodes_not_supported(self, mock_has_version):
         self.assertRaises(exc.HTTPNotImplemented,
                           self.controller.list_cached_nodes,
                           '3a4560a1-e585-443e-9b39-553b46ec92d1')
+
+    @mock.patch.object(common_utils, 'has_version')
+    def test_cache_clean(self, mock_has_version):
+        mock_has_version.return_value = True
+        self.controller.clean()
+        expect = [('POST', '/v2/cache/clean', {}, None)]
+        self.assertEqual(expect, self.api.calls)
+
+    @mock.patch.object(common_utils, 'has_version')
+    def test_cache_prune(self, mock_has_version):
+        mock_has_version.return_value = True
+        result = self.controller.prune()
+        expect = [('POST', '/v2/cache/prune', {}, None)]
+        self.assertEqual(expect, self.api.calls)
+        self.assertEqual(5, result['total_files_pruned'])
+        self.assertEqual(104857600, result['total_bytes_pruned'])
+
+    @mock.patch.object(common_utils, 'has_version')
+    def test_cache_clean_not_supported(self, mock_has_version):
+        mock_has_version.return_value = False
+        self.assertRaises(exc.HTTPNotImplemented,
+                          self.controller.clean)
+
+    @mock.patch.object(common_utils, 'has_version')
+    def test_cache_prune_not_supported(self, mock_has_version):
+        mock_has_version.return_value = False
+        self.assertRaises(exc.HTTPNotImplemented,
+                          self.controller.prune)

glanceclient/tests/unit/v2/test_shell_v2.py

@@ -4031,3 +4031,91 @@ def test_do_cache_clear_endpoint_not_provided(self):
             mock_exit.assert_called_once_with(
                 'Direct server endpoint needs to be provided. Do '
                 'not use loadbalanced or catalog endpoints.')
+
+    def _test_cache_clean(self, supported=True, forbidden=False):
+        args = self._make_args({})
+        with mock.patch.object(self.gc.cache, 'clean') as mocked_cache_clean:
+            if supported:
+                mocked_cache_clean.return_value = None
+            else:
+                mocked_cache_clean.side_effect = exc.HTTPNotImplemented
+            if forbidden:
+                mocked_cache_clean.side_effect = exc.HTTPForbidden
+
+            test_shell.do_cache_clean(self.gc, args)
+            if supported:
+                mocked_cache_clean.assert_called_once_with()
+
+    def test_do_cache_clean(self):
+        self._test_cache_clean()
+
+    def test_do_cache_clean_unsupported(self):
+        with mock.patch(
+                'glanceclient.common.utils.print_err') as mock_print_err:
+            self._test_cache_clean(supported=False)
+            mock_print_err.assert_called_once_with(
+                "'HTTP HTTPNotImplemented': Unable to clean the image cache.")
+
+    def test_do_cache_clean_forbidden(self):
+        with mock.patch(
+                'glanceclient.common.utils.print_err') as mock_print_err:
+            self._test_cache_clean(forbidden=True)
+            mock_print_err.assert_called_once_with(
+                "You are not permitted to clean the image cache.")
+
+    def test_do_cache_clean_endpoint_not_provided(self):
+        args = self._make_args({})
+        self.gc.endpoint_provided = False
+        with mock.patch('glanceclient.common.utils.exit') as mock_exit:
+            test_shell.do_cache_clean(self.gc, args)
+            mock_exit.assert_called_once_with(
+                'Direct server endpoint needs to be provided. Do '
+                'not use loadbalanced or catalog endpoints.')
+
+    def _test_cache_prune(self, supported=True, forbidden=False):
+        args = self._make_args({})
+        with mock.patch.object(self.gc.cache, 'prune') as mocked_cache_prune:
+            if supported:
+                mocked_cache_prune.return_value = {
+                    'total_files_pruned': 5,
+                    'total_bytes_pruned': 104857600,
+                }
+            else:
+                mocked_cache_prune.side_effect = exc.HTTPNotImplemented
+            if forbidden:
+                mocked_cache_prune.side_effect = exc.HTTPForbidden
+
+            with mock.patch('builtins.print') as mock_print:
+                test_shell.do_cache_prune(self.gc, args)
+                if supported and not forbidden:
+                    mocked_cache_prune.assert_called_once_with()
+                    mock_print.assert_called_once_with(
+                        'Pruned 5 file(s), 104857600 byte(s).')
+
+    def test_do_cache_prune(self):
+        self._test_cache_prune()
+
+    def test_do_cache_prune_unsupported(self):
+        with mock.patch(
+                'glanceclient.common.utils.print_err') as mock_print_err:
+            self._test_cache_prune(supported=False)
+            mock_print_err.assert_called_once_with(
+                "'HTTP HTTPNotImplemented': Unable to prune the image cache.")
+
+    def test_do_cache_prune_forbidden(self):
+        with mock.patch(
+                'glanceclient.common.utils.print_err') as mock_print_err:
+            self._test_cache_prune(forbidden=True)
+            mock_print_err.assert_called_once_with(
+                "You are not permitted to prune the image cache.")
+
+    def test_do_cache_prune_endpoint_not_provided(self):
+        args = self._make_args({})
+        self.gc.endpoint_provided = False
+        with mock.patch('glanceclient.common.utils.exit') as mock_exit:
+            mock_exit.side_effect = SystemExit
+            self.assertRaises(SystemExit,
+                              test_shell.do_cache_prune, self.gc, args)
+            mock_exit.assert_called_once_with(
+                'Direct server endpoint needs to be provided. Do not use '
+                'loadbalanced or catalog endpoints.')

glanceclient/v2/cache.py

@@ -28,7 +28,7 @@ def is_supported(self, version):
             return True
         else:
             raise exc.HTTPNotImplemented(
-                'Glance does not support image caching API (v2.14)')
+                'Glance does not support image caching API (%s)' % version)
 
     @utils.add_req_id_to_object()
     def list(self):
@@ -67,3 +67,17 @@ def list_cached_nodes(self, image_id):
             url = '/v2/cache/nodes/%s' % image_id
             resp, body = self.http_client.get(url)
             return body, resp
+
+    @utils.add_req_id_to_object()
+    def clean(self):
+        if self.is_supported('v2.18'):
+            url = '/v2/cache/clean'
+            resp, body = self.http_client.post(url)
+            return body, resp
+
+    @utils.add_req_id_to_object()
+    def prune(self):
+        if self.is_supported('v2.18'):
+            url = '/v2/cache/prune'
+            resp, body = self.http_client.post(url)
+            return body, resp

glanceclient/v2/shell.py

@@ -1643,6 +1643,41 @@ def do_cache_delete(gc, args):
             utils.print_err(msg)
 
 
+def do_cache_clean(gc, args):
+    """Clean invalid and stalled cached images."""
+    if not gc.endpoint_provided:
+        utils.exit("Direct server endpoint needs to be provided. Do not use "
+                   "loadbalanced or catalog endpoints.")
+    try:
+        gc.cache.clean()
+    except exc.HTTPForbidden:
+        msg = _("You are not permitted to clean the image cache.")
+        utils.print_err(msg)
+    except exc.HTTPException as e:
+        msg = _("'%s': Unable to clean the image cache." % e)
+        utils.print_err(msg)
+
+
+def do_cache_prune(gc, args):
+    """Prune cached images to reduce cache size."""
+    if not gc.endpoint_provided:
+        utils.exit("Direct server endpoint needs to be provided. Do not use "
+                   "loadbalanced or catalog endpoints.")
+    try:
+        result = gc.cache.prune()
+        if result:
+            print(_("Pruned %(files)d file(s), %(bytes)d byte(s).") % {
+                'files': result.get('total_files_pruned', 0),
+                'bytes': result.get('total_bytes_pruned', 0),
+            })
+    except exc.HTTPForbidden:
+        msg = _("You are not permitted to prune the image cache.")
+        utils.print_err(msg)
+    except exc.HTTPException as e:
+        msg = _("'%s': Unable to prune the image cache." % e)
+        utils.print_err(msg)
+
+
 def do_cache_list(gc, args):
     """Get cache state."""
     if not gc.endpoint_provided:

releasenotes/notes/cache-clean-prune-api-support.yaml

@@ -0,0 +1,14 @@
+---
+features:
+  - |
+    Client support has been added for the Glance Image API v2.18 cache
+    maintenance endpoints. The following commands have been added to the
+    command line interface:
+
+    * ``cache-clean`` - Clean invalid cache entries and stalled incomplete
+      images
+    * ``cache-prune`` - Prune cached images when the cache size exceeds the
+      maximum configured size
+
+    These commands require a direct glance-api server endpoint and are only
+    available when image caching is enabled on the Glance service.