openstack
/
manila
Code Issues Proposed changes
Shared filesystem management project for OpenStack.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5063 Commits
7 Branches
35 MiB
 
 
 
Tree: 4f2e400a6b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4f2e400a6b'
${ noResults }
manila/manila/tests/share/drivers/glusterfs/test_layout_volume.py

977 lines
43 KiB
Raw Blame History 

  1. # Copyright (c) 2014 Red Hat, Inc.

  2. # All Rights Reserved.

  3. #

  4. #    Licensed under the Apache License, Version 2.0 (the "License"); you may

  5. #    not use this file except in compliance with the License. You may obtain

  6. #    a copy of the License at

  7. #

  8. #         http://www.apache.org/licenses/LICENSE-2.0

  9. #

  10. #    Unless required by applicable law or agreed to in writing, software

  11. #    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

  12. #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

  13. #    License for the specific language governing permissions and limitations

  14. #    under the License.

  15. 

  16. """ GlusterFS volume mapped share layout testcases.

  17. """

  18. 

  19. import re

  20. import shutil

  21. import tempfile

  22. from unittest import mock

  23. 

  24. import ddt

  25. from oslo_config import cfg

  26. 

  27. from manila.common import constants

  28. from manila import context

  29. from manila import exception

  30. from manila.share import configuration as config

  31. from manila.share.drivers.glusterfs import common

  32. from manila.share.drivers.glusterfs import layout_volume

  33. from manila import test

  34. from manila.tests import fake_utils

  35. 

  36. 

  37. CONF = cfg.CONF

  38. 

  39. 

  40. def new_share(**kwargs):

  41.     share = {

  42.         'id': 'fakeid',

  43.         'name': 'fakename',

  44.         'size': 1,

  45.         'share_proto': 'glusterfs',

  46.     }

  47.     share.update(kwargs)

  48.     return share

  49. 

  50. 

  51. def glusterXMLOut(**kwargs):

  52. 

  53.     template = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

  54. <cliOutput>

  55.   <opRet>%(ret)d</opRet>

  56.   <opErrno>%(errno)d</opErrno>

  57.   <opErrstr>fake error</opErrstr>

  58. </cliOutput>"""

  59. 

  60.     return template % kwargs, ''

  61. 

  62. 

  63. FAKE_UUID1 = '11111111-1111-1111-1111-111111111111'

  64. FAKE_UUID2 = '22222222-2222-2222-2222-222222222222'

  65. 

  66. 

  67. @ddt.ddt

  68. class GlusterfsVolumeMappedLayoutTestCase(test.TestCase):

  69.     """Tests GlusterfsVolumeMappedLayout."""

  70. 

  71.     def setUp(self):

  72.         super(GlusterfsVolumeMappedLayoutTestCase, self).setUp()

  73.         fake_utils.stub_out_utils_execute(self)

  74.         self._execute = fake_utils.fake_execute

  75.         self._context = context.get_admin_context()

  76. 

  77.         self.glusterfs_target1 = 'root@host1:/gv1'

  78.         self.glusterfs_target2 = 'root@host2:/gv2'

  79.         self.glusterfs_server1 = 'root@host1'

  80.         self.glusterfs_server2 = 'root@host2'

  81.         self.glusterfs_server1_volumes = 'manila-share-1-1G\nshare1'

  82.         self.glusterfs_server2_volumes = 'manila-share-2-2G\nshare2'

  83.         self.share1 = new_share(

  84.             export_location=self.glusterfs_target1,

  85.             status=constants.STATUS_AVAILABLE)

  86.         self.share2 = new_share(

  87.             export_location=self.glusterfs_target2,

  88.             status=constants.STATUS_AVAILABLE)

  89.         gmgr = common.GlusterManager

  90.         self.gmgr1 = gmgr(self.glusterfs_server1, self._execute, None, None,

  91.                           requires={'volume': False})

  92.         self.gmgr2 = gmgr(self.glusterfs_server2, self._execute, None, None,

  93.                           requires={'volume': False})

  94.         self.glusterfs_volumes_dict = (

  95.             {'root@host1:/manila-share-1-1G': {'size': 1},

  96.              'root@host2:/manila-share-2-2G': {'size': 2}})

  97.         self.glusterfs_used_vols = set([

  98.             'root@host1:/manila-share-1-1G',

  99.             'root@host2:/manila-share-2-2G'])

  100. 

  101.         CONF.set_default('glusterfs_servers',

  102.                          [self.glusterfs_server1, self.glusterfs_server2])

  103.         CONF.set_default('glusterfs_server_password',

  104.                          'fake_password')

  105.         CONF.set_default('glusterfs_path_to_private_key',

  106.                          '/fakepath/to/privatekey')

  107.         CONF.set_default('glusterfs_volume_pattern',

  108.                          r'manila-share-\d+-#{size}G$')

  109.         CONF.set_default('driver_handles_share_servers', False)

  110. 

  111.         self.fake_driver = mock.Mock()

  112.         self.mock_object(self.fake_driver, '_execute',

  113.                          self._execute)

  114.         self.fake_driver.GLUSTERFS_VERSION_MIN = (3, 6)

  115. 

  116.         self.fake_conf = config.Configuration(None)

  117.         self.mock_object(tempfile, 'mkdtemp',

  118.                          mock.Mock(return_value='/tmp/tmpKGHKJ'))

  119.         self.mock_object(common.GlusterManager, 'make_gluster_call')

  120. 

  121.         self.fake_private_storage = mock.Mock()

  122. 

  123.         with mock.patch.object(layout_volume.GlusterfsVolumeMappedLayout,

  124.                                '_glustermanager',

  125.                                side_effect=[self.gmgr1, self.gmgr2]):

  126.             self._layout = layout_volume.GlusterfsVolumeMappedLayout(

  127.                 self.fake_driver, configuration=self.fake_conf,

  128.                 private_storage=self.fake_private_storage)

  129.         self._layout.glusterfs_versions = {self.glusterfs_server1: ('3', '6'),

  130.                                            self.glusterfs_server2: ('3', '7')}

  131.         self.addCleanup(fake_utils.fake_execute_set_repliers, [])

  132.         self.addCleanup(fake_utils.fake_execute_clear_log)

  133. 

  134.     @ddt.data({"test_kwargs": {}, "requires": {"volume": True}},

  135.               {"test_kwargs": {'req_volume': False},

  136.                "requires": {"volume": False}})

  137.     @ddt.unpack

  138.     def test_glustermanager(self, test_kwargs, requires):

  139.         fake_obj = mock.Mock()

  140.         self.mock_object(common, 'GlusterManager',

  141.                          mock.Mock(return_value=fake_obj))

  142. 

  143.         ret = self._layout._glustermanager(self.glusterfs_target1,

  144.                                            **test_kwargs)

  145. 

  146.         common.GlusterManager.assert_called_once_with(

  147.             self.glusterfs_target1, self._execute,

  148.             self._layout.configuration.glusterfs_path_to_private_key,

  149.             self._layout.configuration.glusterfs_server_password,

  150.             requires=requires)

  151.         self.assertEqual(fake_obj, ret)

  152. 

  153.     def test_compile_volume_pattern(self):

  154.         volume_pattern = r'manila-share-\d+-(?P<size>\d+)G$'

  155. 

  156.         ret = self._layout._compile_volume_pattern()

  157. 

  158.         self.assertEqual(re.compile(volume_pattern), ret)

  159. 

  160.     @ddt.data({'root@host1:/manila-share-1-1G': 'NONE',

  161.                'root@host2:/manila-share-2-2G': None},

  162.               {'root@host1:/manila-share-1-1G': FAKE_UUID1,

  163.                'root@host2:/manila-share-2-2G': None},

  164.               {'root@host1:/manila-share-1-1G': 'foobarbaz',

  165.                'root@host2:/manila-share-2-2G': FAKE_UUID2},

  166.               {'root@host1:/manila-share-1-1G': FAKE_UUID1,

  167.                'root@host2:/manila-share-2-2G': FAKE_UUID2})

  168.     def test_fetch_gluster_volumes(self, sharemark):

  169.         vol1_qualified = 'root@host1:/manila-share-1-1G'

  170.         gmgr_vol1 = common.GlusterManager(vol1_qualified)

  171.         gmgr_vol1.get_vol_option = mock.Mock(

  172.             return_value=sharemark[vol1_qualified])

  173.         vol2_qualified = 'root@host2:/manila-share-2-2G'

  174.         gmgr_vol2 = common.GlusterManager(vol2_qualified)

  175.         gmgr_vol2.get_vol_option = mock.Mock(

  176.             return_value=sharemark[vol2_qualified])

  177.         self.mock_object(

  178.             self.gmgr1, 'gluster_call',

  179.             mock.Mock(return_value=(self.glusterfs_server1_volumes, '')))

  180.         self.mock_object(

  181.             self.gmgr2, 'gluster_call',

  182.             mock.Mock(return_value=(self.glusterfs_server2_volumes, '')))

  183.         _glustermanager_calls = (self.gmgr1, gmgr_vol1, self.gmgr2, gmgr_vol2)

  184.         self.mock_object(self._layout, '_glustermanager',

  185.                          mock.Mock(side_effect=_glustermanager_calls))

  186.         expected_output = {}

  187.         for q, d in self.glusterfs_volumes_dict.items():

  188.             if sharemark[q] not in (FAKE_UUID1, FAKE_UUID2):

  189.                 expected_output[q] = d

  190. 

  191.         ret = self._layout._fetch_gluster_volumes()

  192. 

  193.         test_args = ('volume', 'list')

  194.         self.gmgr1.gluster_call.assert_called_once_with(*test_args,

  195.                                                         log=mock.ANY)

  196.         self.gmgr2.gluster_call.assert_called_once_with(*test_args,

  197.                                                         log=mock.ANY)

  198.         gmgr_vol1.get_vol_option.assert_called_once_with(

  199.             'user.manila-share')

  200.         gmgr_vol2.get_vol_option.assert_called_once_with(

  201.             'user.manila-share')

  202.         self.assertEqual(expected_output, ret)

  203. 

  204.     def test_fetch_gluster_volumes_no_filter_used(self):

  205.         vol1_qualified = 'root@host1:/manila-share-1-1G'

  206.         gmgr_vol1 = common.GlusterManager(vol1_qualified)

  207.         gmgr_vol1.get_vol_option = mock.Mock()

  208.         vol2_qualified = 'root@host2:/manila-share-2-2G'

  209.         gmgr_vol2 = common.GlusterManager(vol2_qualified)

  210.         gmgr_vol2.get_vol_option = mock.Mock()

  211.         self.mock_object(

  212.             self.gmgr1, 'gluster_call',

  213.             mock.Mock(return_value=(self.glusterfs_server1_volumes, '')))

  214.         self.mock_object(

  215.             self.gmgr2, 'gluster_call',

  216.             mock.Mock(return_value=(self.glusterfs_server2_volumes, '')))

  217.         _glustermanager_calls = (self.gmgr1, gmgr_vol1, self.gmgr2, gmgr_vol2)

  218.         self.mock_object(self._layout, '_glustermanager',

  219.                          mock.Mock(side_effect=_glustermanager_calls))

  220.         expected_output = self.glusterfs_volumes_dict

  221. 

  222.         ret = self._layout._fetch_gluster_volumes(filter_used=False)

  223. 

  224.         test_args = ('volume', 'list')

  225.         self.gmgr1.gluster_call.assert_called_once_with(*test_args,

  226.                                                         log=mock.ANY)

  227.         self.gmgr2.gluster_call.assert_called_once_with(*test_args,

  228.                                                         log=mock.ANY)

  229.         self.assertFalse(gmgr_vol1.get_vol_option.called)

  230.         self.assertFalse(gmgr_vol2.get_vol_option.called)

  231.         self.assertEqual(expected_output, ret)

  232. 

  233.     def test_fetch_gluster_volumes_no_keymatch(self):

  234.         vol1_qualified = 'root@host1:/manila-share-1'

  235.         gmgr_vol1 = common.GlusterManager(vol1_qualified)

  236.         gmgr_vol1.get_vol_option = mock.Mock(return_value=None)

  237.         self._layout.configuration.glusterfs_servers = [self.glusterfs_server1]

  238.         self.mock_object(

  239.             self.gmgr1, 'gluster_call',

  240.             mock.Mock(return_value=('manila-share-1', '')))

  241.         _glustermanager_calls = (self.gmgr1, gmgr_vol1)

  242.         self.mock_object(self._layout, '_glustermanager',

  243.                          mock.Mock(side_effect=_glustermanager_calls))

  244.         self.mock_object(self._layout, 'volume_pattern',

  245.                          re.compile(r'manila-share-\d+(-(?P<size>\d+)G)?$'))

  246.         expected_output = {'root@host1:/manila-share-1': {'size': None}}

  247. 

  248.         ret = self._layout._fetch_gluster_volumes()

  249. 

  250.         test_args = ('volume', 'list')

  251.         self.gmgr1.gluster_call.assert_called_once_with(*test_args,

  252.                                                         log=mock.ANY)

  253.         self.assertEqual(expected_output, ret)

  254. 

  255.     def test_fetch_gluster_volumes_error(self):

  256.         test_args = ('volume', 'list')

  257. 

  258.         def raise_exception(*args, **kwargs):

  259.             if(args == test_args):

  260.                 raise exception.GlusterfsException()

  261. 

  262.         self._layout.configuration.glusterfs_servers = [self.glusterfs_server1]

  263.         self.mock_object(self.gmgr1, 'gluster_call',

  264.                          mock.Mock(side_effect=raise_exception))

  265.         self.mock_object(self._layout, '_glustermanager',

  266.                          mock.Mock(return_value=self.gmgr1))

  267.         self.mock_object(layout_volume.LOG, 'error')

  268. 

  269.         self.assertRaises(exception.GlusterfsException,

  270.                           self._layout._fetch_gluster_volumes)

  271. 

  272.         self.gmgr1.gluster_call.assert_called_once_with(*test_args,

  273.                                                         log=mock.ANY)

  274. 

  275.     def test_do_setup(self):

  276.         self._layout.configuration.glusterfs_servers = [self.glusterfs_server1]

  277.         self.mock_object(self.gmgr1, 'get_gluster_version',

  278.                          mock.Mock(return_value=('3', '6')))

  279.         self.mock_object(self._layout, '_glustermanager',

  280.                          mock.Mock(return_value=self.gmgr1))

  281.         self.mock_object(self._layout, '_fetch_gluster_volumes',

  282.                          mock.Mock(return_value=self.glusterfs_volumes_dict))

  283.         self.mock_object(self._layout, '_check_mount_glusterfs')

  284.         self._layout.gluster_used_vols = self.glusterfs_used_vols

  285.         self.mock_object(layout_volume.LOG, 'warning')

  286. 

  287.         self._layout.do_setup(self._context)

  288. 

  289.         self._layout._fetch_gluster_volumes.assert_called_once_with(

  290.             filter_used=False)

  291.         self._layout._check_mount_glusterfs.assert_called_once_with()

  292.         self.gmgr1.get_gluster_version.assert_called_once_with()

  293. 

  294.     def test_do_setup_unsupported_glusterfs_version(self):

  295.         self._layout.configuration.glusterfs_servers = [self.glusterfs_server1]

  296.         self.mock_object(self.gmgr1, 'get_gluster_version',

  297.                          mock.Mock(return_value=('3', '5')))

  298.         self.mock_object(self._layout, '_glustermanager',

  299.                          mock.Mock(return_value=self.gmgr1))

  300. 

  301.         self.assertRaises(exception.GlusterfsException,

  302.                           self._layout.do_setup, self._context)

  303. 

  304.         self.gmgr1.get_gluster_version.assert_called_once_with()

  305. 

  306.     @ddt.data(exception.GlusterfsException, RuntimeError)

  307.     def test_do_setup_get_gluster_version_fails(self, exc):

  308.         def raise_exception(*args, **kwargs):

  309.             raise exc

  310. 

  311.         self._layout.configuration.glusterfs_servers = [self.glusterfs_server1]

  312.         self.mock_object(self.gmgr1, 'get_gluster_version',

  313.                          mock.Mock(side_effect=raise_exception))

  314.         self.mock_object(self._layout, '_glustermanager',

  315.                          mock.Mock(return_value=self.gmgr1))

  316. 

  317.         self.assertRaises(exc, self._layout.do_setup, self._context)

  318. 

  319.         self.gmgr1.get_gluster_version.assert_called_once_with()

  320. 

  321.     def test_do_setup_glusterfs_no_volumes_provided_by_backend(self):

  322.         self._layout.configuration.glusterfs_servers = [self.glusterfs_server1]

  323.         self.mock_object(self.gmgr1, 'get_gluster_version',

  324.                          mock.Mock(return_value=('3', '6')))

  325.         self.mock_object(self._layout, '_glustermanager',

  326.                          mock.Mock(return_value=self.gmgr1))

  327.         self.mock_object(self._layout, '_fetch_gluster_volumes',

  328.                          mock.Mock(return_value={}))

  329. 

  330.         self.assertRaises(exception.GlusterfsException,

  331.                           self._layout.do_setup, self._context)

  332. 

  333.         self._layout._fetch_gluster_volumes.assert_called_once_with(

  334.             filter_used=False)

  335. 

  336.     def test_share_manager(self):

  337.         self.mock_object(self._layout, '_glustermanager',

  338.                          mock.Mock(return_value=self.gmgr1))

  339.         self.mock_object(self._layout.private_storage,

  340.                          'get', mock.Mock(return_value='host1:/gv1'))

  341. 

  342.         ret = self._layout._share_manager(self.share1)

  343. 

  344.         self._layout.private_storage.get.assert_called_once_with(

  345.             self.share1['id'], 'volume')

  346.         self._layout._glustermanager.assert_called_once_with('host1:/gv1')

  347.         self.assertEqual(self.gmgr1, ret)

  348. 

  349.     def test_share_manager_no_privdata(self):

  350.         self.mock_object(self._layout.private_storage,

  351.                          'get', mock.Mock(return_value=None))

  352. 

  353.         ret = self._layout._share_manager(self.share1)

  354. 

  355.         self._layout.private_storage.get.assert_called_once_with(

  356.             self.share1['id'], 'volume')

  357.         self.assertIsNone(ret)

  358. 

  359.     def test_ensure_share(self):

  360.         share = self.share1

  361.         gmgr1 = common.GlusterManager(self.glusterfs_target1, self._execute,

  362.                                       None, None)

  363.         gmgr1.set_vol_option = mock.Mock()

  364.         self.mock_object(self._layout, '_share_manager',

  365.                          mock.Mock(return_value=gmgr1))

  366. 

  367.         self._layout.ensure_share(self._context, share)

  368. 

  369.         self._layout._share_manager.assert_called_once_with(share)

  370.         self.assertIn(self.glusterfs_target1, self._layout.gluster_used_vols)

  371.         gmgr1.set_vol_option.assert_called_once_with(

  372.             'user.manila-share', share['id'])

  373. 

  374.     @ddt.data({"voldict": {"host:/share2G": {"size": 2}}, "used_vols": set(),

  375.                "size": 1, "expected": "host:/share2G"},

  376.               {"voldict": {"host:/share2G": {"size": 2}}, "used_vols": set(),

  377.                "size": 2, "expected": "host:/share2G"},

  378.               {"voldict": {"host:/share2G": {"size": 2}}, "used_vols": set(),

  379.                "size": None, "expected": "host:/share2G"},

  380.               {"voldict": {"host:/share2G": {"size": 2},

  381.                            "host:/share": {"size": None}},

  382.                "used_vols": set(["host:/share2G"]), "size": 1,

  383.                "expected": "host:/share"},

  384.               {"voldict": {"host:/share2G": {"size": 2},

  385.                            "host:/share": {"size": None}},

  386.                "used_vols": set(["host:/share2G"]), "size": 2,

  387.                "expected": "host:/share"},

  388.               {"voldict": {"host:/share2G": {"size": 2},

  389.                "host:/share": {"size": None}},

  390.                "used_vols": set(["host:/share2G"]), "size": 3,

  391.                "expected": "host:/share"},

  392.               {"voldict": {"host:/share2G": {"size": 2},

  393.                            "host:/share": {"size": None}},

  394.                "used_vols": set(["host:/share2G"]), "size": None,

  395.                "expected": "host:/share"},

  396.               {"voldict": {"host:/share": {}}, "used_vols": set(), "size": 1,

  397.                "expected": "host:/share"},

  398.               {"voldict": {"host:/share": {}}, "used_vols": set(),

  399.                "size": None, "expected": "host:/share"})

  400.     @ddt.unpack

  401.     def test_pop_gluster_vol(self, voldict, used_vols, size, expected):

  402.         gmgr = common.GlusterManager

  403.         gmgr1 = gmgr(expected, self._execute, None, None)

  404.         self._layout._fetch_gluster_volumes = mock.Mock(return_value=voldict)

  405.         self._layout.gluster_used_vols = used_vols

  406.         self._layout._glustermanager = mock.Mock(return_value=gmgr1)

  407.         self._layout.volume_pattern_keys = list(voldict.values())[0].keys()

  408. 

  409.         result = self._layout._pop_gluster_vol(size=size)

  410. 

  411.         self.assertEqual(expected, result)

  412.         self.assertIn(result, used_vols)

  413.         self._layout._fetch_gluster_volumes.assert_called_once_with()

  414.         self._layout._glustermanager.assert_called_once_with(result)

  415. 

  416.     @ddt.data({"voldict": {"share2G": {"size": 2}},

  417.                "used_vols": set(), "size": 3},

  418.               {"voldict": {"share2G": {"size": 2}},

  419.                "used_vols": set(["share2G"]), "size": None})

  420.     @ddt.unpack

  421.     def test_pop_gluster_vol_excp(self, voldict, used_vols, size):

  422.         self._layout._fetch_gluster_volumes = mock.Mock(return_value=voldict)

  423.         self._layout.gluster_used_vols = used_vols

  424.         self._layout.volume_pattern_keys = list(voldict.values())[0].keys()

  425. 

  426.         self.assertRaises(exception.GlusterfsException,

  427.                           self._layout._pop_gluster_vol, size=size)

  428. 

  429.         self._layout._fetch_gluster_volumes.assert_called_once_with()

  430.         self.assertFalse(

  431.             self.fake_driver._setup_via_manager.called)

  432. 

  433.     def test_push_gluster_vol(self):

  434.         self._layout.gluster_used_vols = set([

  435.             self.glusterfs_target1, self.glusterfs_target2])

  436. 

  437.         self._layout._push_gluster_vol(self.glusterfs_target2)

  438. 

  439.         self.assertEqual(1, len(self._layout.gluster_used_vols))

  440.         self.assertFalse(

  441.             self.glusterfs_target2 in self._layout.gluster_used_vols)

  442. 

  443.     def test_push_gluster_vol_excp(self):

  444.         self._layout.gluster_used_vols = set([self.glusterfs_target1])

  445.         self._layout.gluster_unused_vols_dict = {}

  446. 

  447.         self.assertRaises(exception.GlusterfsException,

  448.                           self._layout._push_gluster_vol,

  449.                           self.glusterfs_target2)

  450. 

  451.     @ddt.data({'vers_minor': '6',

  452.                'cmd': ['find', '/tmp/tmpKGHKJ', '-mindepth', '1',

  453.                        '-delete']},

  454.               {'vers_minor': '7',

  455.                'cmd': ['find', '/tmp/tmpKGHKJ', '-mindepth', '1', '!',

  456.                        '-path', '/tmp/tmpKGHKJ/.trashcan', '!', '-path',

  457.                        '/tmp/tmpKGHKJ/.trashcan/internal_op', '-delete']})

  458.     @ddt.unpack

  459.     def test_wipe_gluster_vol(self, vers_minor, cmd):

  460.         tmpdir = '/tmp/tmpKGHKJ'

  461.         gmgr = common.GlusterManager

  462.         gmgr1 = gmgr(self.glusterfs_target1, self._execute, None, None)

  463.         self._layout.glusterfs_versions = {

  464.             self.glusterfs_server1: ('3', vers_minor)}

  465. 

  466.         self.mock_object(tempfile, 'mkdtemp',

  467.                          mock.Mock(return_value=tmpdir))

  468.         self.mock_object(self.fake_driver, '_execute', mock.Mock())

  469.         self.mock_object(common, '_mount_gluster_vol', mock.Mock())

  470.         self.mock_object(common, '_umount_gluster_vol', mock.Mock())

  471.         self.mock_object(shutil, 'rmtree', mock.Mock())

  472. 

  473.         self._layout._wipe_gluster_vol(gmgr1)

  474. 

  475.         tempfile.mkdtemp.assert_called_once_with()

  476.         common._mount_gluster_vol.assert_called_once_with(

  477.             self.fake_driver._execute, gmgr1.export,

  478.             tmpdir)

  479.         kwargs = {'run_as_root': True}

  480.         self.fake_driver._execute.assert_called_once_with(

  481.             *cmd, **kwargs)

  482.         common._umount_gluster_vol.assert_called_once_with(

  483.             self.fake_driver._execute, tmpdir)

  484.         kwargs = {'ignore_errors': True}

  485.         shutil.rmtree.assert_called_once_with(tmpdir,

  486.                                               **kwargs)

  487. 

  488.     def test_wipe_gluster_vol_mount_fail(self):

  489.         tmpdir = '/tmp/tmpKGHKJ'

  490.         gmgr = common.GlusterManager

  491.         gmgr1 = gmgr(self.glusterfs_target1, self._execute, None, None)

  492.         self._layout.glusterfs_versions = {

  493.             self.glusterfs_server1: ('3', '6')}

  494.         self.mock_object(tempfile, 'mkdtemp',

  495.                          mock.Mock(return_value=tmpdir))

  496.         self.mock_object(self.fake_driver, '_execute', mock.Mock())

  497.         self.mock_object(common, '_mount_gluster_vol',

  498.                          mock.Mock(side_effect=exception.GlusterfsException))

  499.         self.mock_object(common, '_umount_gluster_vol', mock.Mock())

  500.         self.mock_object(shutil, 'rmtree', mock.Mock())

  501. 

  502.         self.assertRaises(exception.GlusterfsException,

  503.                           self._layout._wipe_gluster_vol,

  504.                           gmgr1)

  505. 

  506.         tempfile.mkdtemp.assert_called_once_with()

  507.         common._mount_gluster_vol.assert_called_once_with(

  508.             self.fake_driver._execute, gmgr1.export,

  509.             tmpdir)

  510.         self.assertFalse(self.fake_driver._execute.called)

  511.         self.assertFalse(common._umount_gluster_vol.called)

  512.         kwargs = {'ignore_errors': True}

  513.         shutil.rmtree.assert_called_once_with(tmpdir,

  514.                                               **kwargs)

  515. 

  516.     def test_wipe_gluster_vol_error_wiping_gluster_vol(self):

  517.         tmpdir = '/tmp/tmpKGHKJ'

  518.         gmgr = common.GlusterManager

  519.         gmgr1 = gmgr(self.glusterfs_target1, self._execute, None, None)

  520.         self._layout.glusterfs_versions = {

  521.             self.glusterfs_server1: ('3', '6')}

  522.         cmd = ['find', '/tmp/tmpKGHKJ', '-mindepth', '1', '-delete']

  523.         self.mock_object(tempfile, 'mkdtemp',

  524.                          mock.Mock(return_value=tmpdir))

  525.         self.mock_object(

  526.             self.fake_driver, '_execute',

  527.             mock.Mock(side_effect=exception.ProcessExecutionError))

  528.         self.mock_object(common, '_mount_gluster_vol', mock.Mock())

  529.         self.mock_object(common, '_umount_gluster_vol', mock.Mock())

  530.         self.mock_object(shutil, 'rmtree', mock.Mock())

  531. 

  532.         self.assertRaises(exception.GlusterfsException,

  533.                           self._layout._wipe_gluster_vol,

  534.                           gmgr1)

  535. 

  536.         tempfile.mkdtemp.assert_called_once_with()

  537.         common._mount_gluster_vol.assert_called_once_with(

  538.             self.fake_driver._execute, gmgr1.export,

  539.             tmpdir)

  540.         kwargs = {'run_as_root': True}

  541.         self.fake_driver._execute.assert_called_once_with(

  542.             *cmd, **kwargs)

  543.         common._umount_gluster_vol.assert_called_once_with(

  544.             self.fake_driver._execute, tmpdir)

  545.         kwargs = {'ignore_errors': True}

  546.         shutil.rmtree.assert_called_once_with(tmpdir,

  547.                                               **kwargs)

  548. 

  549.     def test_create_share(self):

  550.         self._layout._pop_gluster_vol = mock.Mock(

  551.             return_value=self.glusterfs_target1)

  552.         gmgr1 = common.GlusterManager(self.glusterfs_target1)

  553.         gmgr1.set_vol_option = mock.Mock()

  554.         self.mock_object(self._layout, '_glustermanager',

  555.                          mock.Mock(return_value=gmgr1))

  556.         self.mock_object(self.fake_driver, '_setup_via_manager',

  557.                          mock.Mock(return_value='host1:/gv1'))

  558. 

  559.         share = new_share()

  560.         exp_locn = self._layout.create_share(self._context, share)

  561. 

  562.         self._layout._pop_gluster_vol.assert_called_once_with(share['size'])

  563.         self.fake_driver._setup_via_manager.assert_called_once_with(

  564.             {'manager': gmgr1, 'share': share})

  565.         self._layout.private_storage.update.assert_called_once_with(

  566.             share['id'], {'volume': self.glusterfs_target1})

  567.         gmgr1.set_vol_option.assert_called_once_with(

  568.             'user.manila-share', share['id'])

  569.         self.assertEqual('host1:/gv1', exp_locn)

  570. 

  571.     def test_create_share_error(self):

  572.         self._layout._pop_gluster_vol = mock.Mock(

  573.             side_effect=exception.GlusterfsException)

  574. 

  575.         share = new_share()

  576.         self.assertRaises(exception.GlusterfsException,

  577.                           self._layout.create_share, self._context, share)

  578. 

  579.         self._layout._pop_gluster_vol.assert_called_once_with(

  580.             share['size'])

  581. 

  582.     @ddt.data(None, '', 'Eeyore')

  583.     def test_delete_share(self, clone_of):

  584.         self._layout._push_gluster_vol = mock.Mock()

  585.         self._layout._wipe_gluster_vol = mock.Mock()

  586.         gmgr = common.GlusterManager

  587.         gmgr1 = gmgr(self.glusterfs_target1, self._execute, None, None)

  588.         gmgr1.set_vol_option = mock.Mock()

  589.         gmgr1.get_vol_option = mock.Mock(return_value=clone_of)

  590.         self.mock_object(self._layout, '_glustermanager',

  591.                          mock.Mock(return_value=gmgr1))

  592.         self._layout.gluster_used_vols = set([self.glusterfs_target1])

  593. 

  594.         self._layout.delete_share(self._context, self.share1)

  595. 

  596.         gmgr1.get_vol_option.assert_called_once_with(

  597.             'user.manila-cloned-from')

  598.         self._layout._wipe_gluster_vol.assert_called_once_with(gmgr1)

  599.         self._layout._push_gluster_vol.assert_called_once_with(

  600.             self.glusterfs_target1)

  601.         self._layout.private_storage.delete.assert_called_once_with(

  602.             self.share1['id'])

  603.         gmgr1.set_vol_option.assert_has_calls([

  604.             mock.call('user.manila-share', 'NONE'),

  605.             mock.call('nfs.disable', 'on')

  606.         ])

  607. 

  608.     def test_delete_share_clone(self):

  609.         self._layout._push_gluster_vol = mock.Mock()

  610.         self._layout._wipe_gluster_vol = mock.Mock()

  611.         gmgr = common.GlusterManager

  612.         gmgr1 = gmgr(self.glusterfs_target1, self._execute, None, None)

  613.         gmgr1.gluster_call = mock.Mock()

  614.         gmgr1.get_vol_option = mock.Mock(return_value=FAKE_UUID1)

  615.         self.mock_object(self._layout, '_glustermanager',

  616.                          mock.Mock(return_value=gmgr1))

  617.         self._layout.gluster_used_vols = set([self.glusterfs_target1])

  618. 

  619.         self._layout.delete_share(self._context, self.share1)

  620. 

  621.         gmgr1.get_vol_option.assert_called_once_with(

  622.             'user.manila-cloned-from')

  623.         self.assertFalse(self._layout._wipe_gluster_vol.called)

  624.         self._layout._push_gluster_vol.assert_called_once_with(

  625.             self.glusterfs_target1)

  626.         self._layout.private_storage.delete.assert_called_once_with(

  627.             self.share1['id'])

  628.         gmgr1.gluster_call.assert_called_once_with(

  629.             'volume', 'delete', 'gv1')

  630. 

  631.     def test_delete_share_error(self):

  632.         self._layout._wipe_gluster_vol = mock.Mock()

  633.         self._layout._wipe_gluster_vol.side_effect = (

  634.             exception.GlusterfsException)

  635.         self._layout._push_gluster_vol = mock.Mock()

  636.         gmgr = common.GlusterManager

  637.         gmgr1 = gmgr(self.glusterfs_target1, self._execute, None, None)

  638.         gmgr1.get_vol_option = mock.Mock(return_value=None)

  639.         self.mock_object(self._layout, '_glustermanager',

  640.                          mock.Mock(return_value=gmgr1))

  641.         self._layout.gluster_used_vols = set([self.glusterfs_target1])

  642. 

  643.         self.assertRaises(exception.GlusterfsException,

  644.                           self._layout.delete_share, self._context,

  645.                           self.share1)

  646. 

  647.         self._layout._wipe_gluster_vol.assert_called_once_with(gmgr1)

  648.         self.assertFalse(self._layout._push_gluster_vol.called)

  649. 

  650.     def test_delete_share_missing_record(self):

  651.         self.mock_object(self._layout, '_share_manager',

  652.                          mock.Mock(return_value=None))

  653. 

  654.         self._layout.delete_share(self._context, self.share1)

  655. 

  656.         self._layout._share_manager.assert_called_once_with(self.share1)

  657. 

  658.     def test_create_snapshot(self):

  659.         self._layout.gluster_nosnap_vols_dict = {}

  660.         self._layout.glusterfs_versions = {self.glusterfs_server1: ('3', '6')}

  661.         gmgr = common.GlusterManager

  662.         gmgr1 = gmgr(self.glusterfs_target1, self._execute, None, None)

  663.         self._layout.gluster_used_vols = set([self.glusterfs_target1])

  664.         self.mock_object(gmgr1, 'gluster_call',

  665.                          mock.Mock(

  666.                              side_effect=(glusterXMLOut(ret=0, errno=0),)))

  667.         self.mock_object(self._layout, '_glustermanager',

  668.                          mock.Mock(return_value=gmgr1))

  669. 

  670.         snapshot = {

  671.             'id': 'fake_snap_id',

  672.             'share_id': self.share1['id'],

  673.             'share': self.share1

  674.         }

  675.         ret = self._layout.create_snapshot(self._context, snapshot)

  676. 

  677.         self.assertIsNone(ret)

  678.         args = ('--xml', 'snapshot', 'create', 'manila-fake_snap_id',

  679.                 gmgr1.volume)

  680.         gmgr1.gluster_call.assert_called_once_with(*args, log=mock.ANY)

  681. 

  682.     @ddt.data({'side_effect': (glusterXMLOut(ret=-1, errno=2),),

  683.                '_exception': exception.GlusterfsException},

  684.               {'side_effect': (('', ''),),

  685.                '_exception': exception.GlusterfsException})

  686.     @ddt.unpack

  687.     def test_create_snapshot_error(self, side_effect, _exception):

  688.         self._layout.gluster_nosnap_vols_dict = {}

  689.         self._layout.glusterfs_versions = {self.glusterfs_server1: ('3', '6')}

  690.         gmgr = common.GlusterManager

  691.         gmgr1 = gmgr(self.glusterfs_target1, self._execute, None, None)

  692.         self._layout.gluster_used_vols = set([self.glusterfs_target1])

  693.         self.mock_object(gmgr1, 'gluster_call',

  694.                          mock.Mock(side_effect=side_effect))

  695.         self.mock_object(self._layout, '_glustermanager',

  696.                          mock.Mock(return_value=gmgr1))

  697. 

  698.         snapshot = {

  699.             'id': 'fake_snap_id',

  700.             'share_id': self.share1['id'],

  701.             'share': self.share1

  702.         }

  703.         self.assertRaises(_exception, self._layout.create_snapshot,

  704.                           self._context, snapshot)

  705. 

  706.         args = ('--xml', 'snapshot', 'create', 'manila-fake_snap_id',

  707.                 gmgr1.volume)

  708.         gmgr1.gluster_call.assert_called_once_with(*args, log=mock.ANY)

  709. 

  710.     @ddt.data({"vers_minor": '6', "exctype": exception.GlusterfsException},

  711.               {"vers_minor": '7',

  712.                "exctype": exception.ShareSnapshotNotSupported})

  713.     @ddt.unpack

  714.     def test_create_snapshot_no_snap(self, vers_minor, exctype):

  715.         self._layout.gluster_nosnap_vols_dict = {}

  716.         self._layout.glusterfs_versions = {

  717.             self.glusterfs_server1: ('3', vers_minor)}

  718.         gmgr = common.GlusterManager

  719.         gmgr1 = gmgr(self.glusterfs_target1, self._execute, None, None)

  720.         self._layout.gluster_used_vols = set([self.glusterfs_target1])

  721.         self.mock_object(gmgr1, 'gluster_call',

  722.                          mock.Mock(

  723.                              side_effect=(glusterXMLOut(ret=-1, errno=0),)))

  724.         self.mock_object(self._layout, '_glustermanager',

  725.                          mock.Mock(return_value=gmgr1))

  726. 

  727.         snapshot = {

  728.             'id': 'fake_snap_id',

  729.             'share_id': self.share1['id'],

  730.             'share': self.share1

  731.         }

  732.         self.assertRaises(exctype, self._layout.create_snapshot, self._context,

  733.                           snapshot)

  734. 

  735.         args = ('--xml', 'snapshot', 'create', 'manila-fake_snap_id',

  736.                 gmgr1.volume)

  737.         gmgr1.gluster_call.assert_called_once_with(*args, log=mock.ANY)

  738. 

  739.     @ddt.data({"vers_minor": '6', "exctype": exception.GlusterfsException},

  740.               {"vers_minor": '7',

  741.                "exctype": exception.ShareSnapshotNotSupported})

  742.     @ddt.unpack

  743.     def test_create_snapshot_no_snap_cached(self, vers_minor, exctype):

  744.         self._layout.gluster_nosnap_vols_dict = {

  745.             self.glusterfs_target1: 'fake error'}

  746.         self._layout.glusterfs_versions = {

  747.             self.glusterfs_server1: ('3', vers_minor)}

  748.         self._layout.gluster_used_vols = set([self.glusterfs_target1])

  749.         gmgr = common.GlusterManager

  750.         gmgr1 = gmgr(self.glusterfs_target1, self._execute, None, None)

  751.         self.mock_object(self._layout, '_share_manager',

  752.                          mock.Mock(return_value=gmgr1))

  753. 

  754.         snapshot = {

  755.             'id': 'fake_snap_id',

  756.             'share_id': self.share1['id'],

  757.             'share': self.share1

  758.         }

  759.         self.assertRaises(exctype, self._layout.create_snapshot, self._context,

  760.                           snapshot)

  761. 

  762.     def test_find_actual_backend_snapshot_name(self):

  763.         gmgr = common.GlusterManager

  764.         gmgr1 = gmgr(self.share1['export_location'], self._execute, None, None)

  765.         self.mock_object(gmgr1, 'gluster_call',

  766.                          mock.Mock(return_value=('fake_snap_id_xyz', '')))

  767. 

  768.         snapshot = {

  769.             'id': 'fake_snap_id',

  770.             'share_id': self.share1['id'],

  771.             'share': self.share1

  772.         }

  773.         ret = self._layout._find_actual_backend_snapshot_name(gmgr1, snapshot)

  774. 

  775.         args = ('snapshot', 'list', gmgr1.volume, '--mode=script')

  776.         gmgr1.gluster_call.assert_called_once_with(*args, log=mock.ANY)

  777.         self.assertEqual('fake_snap_id_xyz', ret)

  778. 

  779.     @ddt.data('this is too bad', 'fake_snap_id_xyx\nfake_snap_id_pqr')

  780.     def test_find_actual_backend_snapshot_name_bad_snap_list(self, snaplist):

  781.         gmgr = common.GlusterManager

  782.         gmgr1 = gmgr(self.share1['export_location'], self._execute, None, None)

  783.         self.mock_object(gmgr1, 'gluster_call',

  784.                          mock.Mock(return_value=(snaplist, '')))

  785. 

  786.         snapshot = {

  787.             'id': 'fake_snap_id',

  788.             'share_id': self.share1['id'],

  789.             'share': self.share1

  790.         }

  791.         self.assertRaises(exception.GlusterfsException,

  792.                           self._layout._find_actual_backend_snapshot_name,

  793.                           gmgr1, snapshot)

  794. 

  795.         args = ('snapshot', 'list', gmgr1.volume, '--mode=script')

  796.         gmgr1.gluster_call.assert_called_once_with(*args, log=mock.ANY)

  797. 

  798.     @ddt.data({'glusterfs_target': 'root@host1:/gv1',

  799.                'glusterfs_server': 'root@host1'},

  800.               {'glusterfs_target': 'host1:/gv1',

  801.                'glusterfs_server': 'host1'})

  802.     @ddt.unpack

  803.     def test_create_share_from_snapshot(self, glusterfs_target,

  804.                                         glusterfs_server):

  805.         share = new_share()

  806.         snapshot = {

  807.             'id': 'fake_snap_id',

  808.             'share_instance': new_share(export_location=glusterfs_target),

  809.             'share_id': 'fake_share_id',

  810.         }

  811.         volume = ''.join(['manila-', share['id']])

  812.         new_vol_addr = ':/'.join([glusterfs_server, volume])

  813.         gmgr = common.GlusterManager

  814.         old_gmgr = gmgr(glusterfs_target, self._execute, None, None)

  815.         new_gmgr = gmgr(new_vol_addr, self._execute, None, None)

  816.         self._layout.gluster_used_vols = set([glusterfs_target])

  817.         self._layout.glusterfs_versions = {glusterfs_server: ('3', '7')}

  818.         self.mock_object(old_gmgr, 'gluster_call',

  819.                          mock.Mock(side_effect=[('', ''), ('', '')]))

  820.         self.mock_object(new_gmgr, 'gluster_call',

  821.                          mock.Mock(side_effect=[('', ''), ('', ''), ('', '')]))

  822.         self.mock_object(new_gmgr, 'get_vol_option',

  823.                          mock.Mock())

  824.         new_gmgr.get_vol_option.return_value = (

  825.             'glusterfs-server-1,client')

  826.         self.mock_object(self._layout, '_find_actual_backend_snapshot_name',

  827.                          mock.Mock(return_value='fake_snap_id_xyz'))

  828.         self.mock_object(self._layout, '_share_manager',

  829.                          mock.Mock(return_value=old_gmgr))

  830.         self.mock_object(self._layout, '_glustermanager',

  831.                          mock.Mock(return_value=new_gmgr))

  832.         self.mock_object(self.fake_driver, '_setup_via_manager',

  833.                          mock.Mock(return_value='host1:/gv1'))

  834. 

  835.         ret = self._layout.create_share_from_snapshot(

  836.             self._context, share, snapshot, None)

  837. 

  838.         (self._layout._find_actual_backend_snapshot_name.

  839.             assert_called_once_with(old_gmgr, snapshot))

  840.         args = (('snapshot', 'activate', 'fake_snap_id_xyz',

  841.                  'force', '--mode=script'),

  842.                 ('snapshot', 'clone', volume, 'fake_snap_id_xyz'))

  843.         old_gmgr.gluster_call.assert_has_calls(

  844.             [mock.call(*a, log=mock.ANY) for a in args])

  845.         args = (('volume', 'start', volume),

  846.                 ('volume', 'set', volume, 'user.manila-share', share['id']),

  847.                 ('volume', 'set', volume, 'user.manila-cloned-from',

  848.                  snapshot['share_id']))

  849.         new_gmgr.gluster_call.assert_has_calls(

  850.             [mock.call(*a, log=mock.ANY) for a in args], any_order=True)

  851.         self._layout._share_manager.assert_called_once_with(

  852.             snapshot['share_instance'])

  853.         self._layout._glustermanager.assert_called_once_with(

  854.             gmgr.parse(new_vol_addr))

  855.         self._layout.driver._setup_via_manager.assert_called_once_with(

  856.             {'manager': new_gmgr, 'share': share},

  857.             {'manager': old_gmgr, 'share': snapshot['share_instance']})

  858.         self._layout.private_storage.update.assert_called_once_with(

  859.             share['id'], {'volume': new_vol_addr})

  860.         self.assertIn(

  861.             new_vol_addr,

  862.             self._layout.gluster_used_vols)

  863.         self.assertEqual('host1:/gv1', ret)

  864. 

  865.     def test_create_share_from_snapshot_error_unsupported_gluster_version(

  866.             self):

  867.         glusterfs_target = 'root@host1:/gv1'

  868.         glusterfs_server = 'root@host1'

  869.         share = new_share()

  870.         volume = ''.join(['manila-', share['id']])

  871.         new_vol_addr = ':/'.join([glusterfs_server, volume])

  872.         gmgr = common.GlusterManager

  873.         old_gmgr = gmgr(glusterfs_target, self._execute, None, None)

  874.         new_gmgr = gmgr(new_vol_addr, self._execute, None, None)

  875.         self._layout.gluster_used_vols_dict = {glusterfs_target: old_gmgr}

  876.         self._layout.glusterfs_versions = {glusterfs_server: ('3', '6')}

  877.         self.mock_object(

  878.             old_gmgr, 'gluster_call',

  879.             mock.Mock(side_effect=[('', ''), ('', '')]))

  880.         self.mock_object(new_gmgr, 'get_vol_option',

  881.                          mock.Mock())

  882.         new_gmgr.get_vol_option.return_value = (

  883.             'glusterfs-server-1,client')

  884.         self.mock_object(self._layout, '_find_actual_backend_snapshot_name',

  885.                          mock.Mock(return_value='fake_snap_id_xyz'))

  886.         self.mock_object(self._layout, '_share_manager',

  887.                          mock.Mock(return_value=old_gmgr))

  888.         self.mock_object(self._layout, '_glustermanager',

  889.                          mock.Mock(return_value=new_gmgr))

  890. 

  891.         snapshot = {

  892.             'id': 'fake_snap_id',

  893.             'share_instance': new_share(export_location=glusterfs_target)

  894.         }

  895.         self.assertRaises(exception.GlusterfsException,

  896.                           self._layout.create_share_from_snapshot,

  897.                           self._context, share, snapshot)

  898. 

  899.         self.assertFalse(

  900.             self._layout._find_actual_backend_snapshot_name.called)

  901.         self.assertFalse(old_gmgr.gluster_call.called)

  902.         self._layout._share_manager.assert_called_once_with(

  903.             snapshot['share_instance'])

  904.         self.assertFalse(self._layout._glustermanager.called)

  905.         self.assertFalse(new_gmgr.get_vol_option.called)

  906.         self.assertFalse(new_gmgr.gluster_call.called)

  907.         self.assertNotIn(new_vol_addr,

  908.                          self._layout.glusterfs_versions.keys())

  909. 

  910.     def test_delete_snapshot(self):

  911.         self._layout.gluster_nosnap_vols_dict = {}

  912.         gmgr = common.GlusterManager

  913.         gmgr1 = gmgr(self.share1['export_location'], self._execute, None, None)

  914.         self._layout.gluster_used_vols = set([self.glusterfs_target1])

  915.         self.mock_object(self._layout, '_find_actual_backend_snapshot_name',

  916.                          mock.Mock(return_value='fake_snap_id_xyz'))

  917.         self.mock_object(

  918.             gmgr1, 'gluster_call',

  919.             mock.Mock(return_value=glusterXMLOut(ret=0, errno=0)))

  920.         self.mock_object(self._layout, '_glustermanager',

  921.                          mock.Mock(return_value=gmgr1))

  922.         snapshot = {

  923.             'id': 'fake_snap_id',

  924.             'share_id': self.share1['id'],

  925.             'share': self.share1

  926.         }

  927.         ret = self._layout.delete_snapshot(self._context, snapshot)

  928. 

  929.         self.assertIsNone(ret)

  930.         args = ('--xml', 'snapshot', 'delete', 'fake_snap_id_xyz',

  931.                 '--mode=script')

  932.         gmgr1.gluster_call.assert_called_once_with(*args, log=mock.ANY)

  933.         (self._layout._find_actual_backend_snapshot_name.

  934.             assert_called_once_with(gmgr1, snapshot))

  935. 

  936.     @ddt.data({'side_effect': (glusterXMLOut(ret=-1, errno=0),),

  937.                '_exception': exception.GlusterfsException},

  938.               {'side_effect': (('', ''),),

  939.                '_exception': exception.GlusterfsException})

  940.     @ddt.unpack

  941.     def test_delete_snapshot_error(self, side_effect, _exception):

  942.         self._layout.gluster_nosnap_vols_dict = {}

  943.         gmgr = common.GlusterManager

  944.         gmgr1 = gmgr(self.share1['export_location'], self._execute, None, None)

  945.         self._layout.gluster_used_vols = set([self.glusterfs_target1])

  946.         self.mock_object(self._layout, '_find_actual_backend_snapshot_name',

  947.                          mock.Mock(return_value='fake_snap_id_xyz'))

  948.         args = ('--xml', 'snapshot', 'delete', 'fake_snap_id_xyz',

  949.                 '--mode=script')

  950.         self.mock_object(

  951.             gmgr1, 'gluster_call',

  952.             mock.Mock(side_effect=side_effect))

  953.         self.mock_object(self._layout, '_glustermanager',

  954.                          mock.Mock(return_value=gmgr1))

  955. 

  956.         snapshot = {

  957.             'id': 'fake_snap_id',

  958.             'share_id': self.share1['id'],

  959.             'share': self.share1

  960.         }

  961.         self.assertRaises(_exception, self._layout.delete_snapshot,

  962.                           self._context, snapshot)

  963. 

  964.         gmgr1.gluster_call.assert_called_once_with(*args, log=mock.ANY)

  965.         (self._layout._find_actual_backend_snapshot_name.

  966.             assert_called_once_with(gmgr1, snapshot))

  967. 

  968.     @ddt.data(

  969.         ('manage_existing', ('share', 'driver_options'), {}),

  970.         ('unmanage', ('share',), {}),

  971.         ('extend_share', ('share', 'new_size'), {'share_server': None}),

  972.         ('shrink_share', ('share', 'new_size'), {'share_server': None}))

  973.     def test_nonimplemented_methods(self, method_invocation):

  974.         method, args, kwargs = method_invocation

  975.         self.assertRaises(NotImplementedError, getattr(self._layout, method),

  976.                           *args, **kwargs)