33f6d78c3a
Raising NEW exception is bad practice, because we lose TraceBack.
So all places like:
except SomeException as e:
raise e
should be replaced by
except SomeException:
raise
If we are doing some other actions before reraising we should
store information about exception then do all actions and then
reraise it. This is caused by eventlet bug. It lost information
about exception if it switch threads.
fixes bug 1191730
Change-Id: Ic2be96e9f03d2ca46d060caf6f6f7f713a1d6b82
392 lines
12 KiB
Python
392 lines
12 KiB
Python
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
|
|
|
# Copyright (c) 2012 NetApp, Inc.
|
|
# All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
"""Unit tests for the NetApp-specific NFS driver module."""
|
|
|
|
from cinder import context
|
|
from cinder import exception
|
|
from cinder import test
|
|
|
|
from cinder.volume import configuration as conf
|
|
from cinder.volume.drivers.netapp import api
|
|
from cinder.volume.drivers.netapp import nfs as netapp_nfs
|
|
from lxml import etree
|
|
from mox import IgnoreArg
|
|
from mox import IsA
|
|
from mox import MockObject
|
|
|
|
import mox
|
|
|
|
|
|
def create_configuration():
|
|
configuration = mox.MockObject(conf.Configuration)
|
|
configuration.append_config_values(mox.IgnoreArg())
|
|
return configuration
|
|
|
|
|
|
class FakeVolume(object):
|
|
def __init__(self, size=0):
|
|
self.size = size
|
|
self.id = hash(self)
|
|
self.name = None
|
|
|
|
def __getitem__(self, key):
|
|
return self.__dict__[key]
|
|
|
|
|
|
class FakeSnapshot(object):
|
|
def __init__(self, volume_size=0):
|
|
self.volume_name = None
|
|
self.name = None
|
|
self.volume_id = None
|
|
self.volume_size = volume_size
|
|
self.user_id = None
|
|
self.status = None
|
|
|
|
def __getitem__(self, key):
|
|
return self.__dict__[key]
|
|
|
|
|
|
class FakeResponce(object):
|
|
def __init__(self, status):
|
|
"""
|
|
:param status: Either 'failed' or 'passed'
|
|
"""
|
|
self.Status = status
|
|
|
|
if status == 'failed':
|
|
self.Reason = 'Sample error'
|
|
|
|
|
|
class NetappDirectCmodeNfsDriverTestCase(test.TestCase):
|
|
"""Test direct NetApp C Mode driver."""
|
|
def setUp(self):
|
|
super(NetappDirectCmodeNfsDriverTestCase, self).setUp()
|
|
self._custom_setup()
|
|
|
|
def test_create_snapshot(self):
|
|
"""Test snapshot can be created and deleted."""
|
|
mox = self.mox
|
|
drv = self._driver
|
|
|
|
mox.StubOutWithMock(drv, '_clone_volume')
|
|
drv._clone_volume(IgnoreArg(), IgnoreArg(), IgnoreArg())
|
|
mox.ReplayAll()
|
|
|
|
drv.create_snapshot(FakeSnapshot())
|
|
|
|
mox.VerifyAll()
|
|
|
|
def test_create_volume_from_snapshot(self):
|
|
"""Tests volume creation from snapshot."""
|
|
drv = self._driver
|
|
mox = self.mox
|
|
volume = FakeVolume(1)
|
|
snapshot = FakeSnapshot(2)
|
|
|
|
self.assertRaises(exception.CinderException,
|
|
drv.create_volume_from_snapshot,
|
|
volume,
|
|
snapshot)
|
|
|
|
snapshot = FakeSnapshot(1)
|
|
|
|
location = '127.0.0.1:/nfs'
|
|
expected_result = {'provider_location': location}
|
|
mox.StubOutWithMock(drv, '_clone_volume')
|
|
mox.StubOutWithMock(drv, '_get_volume_location')
|
|
drv._clone_volume(IgnoreArg(), IgnoreArg(), IgnoreArg())
|
|
drv._get_volume_location(IgnoreArg()).AndReturn(location)
|
|
|
|
mox.ReplayAll()
|
|
|
|
loc = drv.create_volume_from_snapshot(volume, snapshot)
|
|
|
|
self.assertEquals(loc, expected_result)
|
|
|
|
mox.VerifyAll()
|
|
|
|
def _prepare_delete_snapshot_mock(self, snapshot_exists):
|
|
drv = self._driver
|
|
mox = self.mox
|
|
|
|
mox.StubOutWithMock(drv, '_get_provider_location')
|
|
mox.StubOutWithMock(drv, '_volume_not_present')
|
|
|
|
if snapshot_exists:
|
|
mox.StubOutWithMock(drv, '_execute')
|
|
mox.StubOutWithMock(drv, '_get_volume_path')
|
|
|
|
drv._get_provider_location(IgnoreArg())
|
|
drv._volume_not_present(IgnoreArg(), IgnoreArg())\
|
|
.AndReturn(not snapshot_exists)
|
|
|
|
if snapshot_exists:
|
|
drv._get_volume_path(IgnoreArg(), IgnoreArg())
|
|
drv._execute('rm', None, run_as_root=True)
|
|
|
|
mox.ReplayAll()
|
|
|
|
return mox
|
|
|
|
def test_delete_existing_snapshot(self):
|
|
drv = self._driver
|
|
mox = self._prepare_delete_snapshot_mock(True)
|
|
|
|
drv.delete_snapshot(FakeSnapshot())
|
|
|
|
mox.VerifyAll()
|
|
|
|
def test_delete_missing_snapshot(self):
|
|
drv = self._driver
|
|
mox = self._prepare_delete_snapshot_mock(False)
|
|
|
|
drv.delete_snapshot(FakeSnapshot())
|
|
|
|
mox.VerifyAll()
|
|
|
|
def test_cloned_volume_size_fail(self):
|
|
volume_clone_fail = FakeVolume(1)
|
|
volume_src = FakeVolume(2)
|
|
try:
|
|
self._driver.create_cloned_volume(volume_clone_fail,
|
|
volume_src)
|
|
raise AssertionError()
|
|
except exception.CinderException:
|
|
pass
|
|
|
|
def _custom_setup(self):
|
|
kwargs = {}
|
|
kwargs['netapp_mode'] = 'proxy'
|
|
kwargs['configuration'] = create_configuration()
|
|
self._driver = netapp_nfs.NetAppDirectCmodeNfsDriver(
|
|
**kwargs)
|
|
|
|
def test_check_for_setup_error(self):
|
|
mox = self.mox
|
|
drv = self._driver
|
|
required_flags = [
|
|
'netapp_transport_type',
|
|
'netapp_login',
|
|
'netapp_password',
|
|
'netapp_server_hostname',
|
|
'netapp_server_port']
|
|
|
|
# set required flags
|
|
for flag in required_flags:
|
|
setattr(drv.configuration, flag, None)
|
|
# check exception raises when flags are not set
|
|
self.assertRaises(exception.CinderException,
|
|
drv.check_for_setup_error)
|
|
|
|
# set required flags
|
|
for flag in required_flags:
|
|
setattr(drv.configuration, flag, 'val')
|
|
|
|
mox.ReplayAll()
|
|
|
|
drv.check_for_setup_error()
|
|
|
|
mox.VerifyAll()
|
|
|
|
# restore initial FLAGS
|
|
for flag in required_flags:
|
|
delattr(drv.configuration, flag)
|
|
|
|
def test_do_setup(self):
|
|
mox = self.mox
|
|
drv = self._driver
|
|
|
|
mox.StubOutWithMock(drv, 'check_for_setup_error')
|
|
mox.StubOutWithMock(drv, '_get_client')
|
|
mox.StubOutWithMock(drv, '_do_custom_setup')
|
|
|
|
drv.check_for_setup_error()
|
|
drv._get_client()
|
|
drv._do_custom_setup(IgnoreArg())
|
|
|
|
mox.ReplayAll()
|
|
|
|
drv.do_setup(IsA(context.RequestContext))
|
|
|
|
mox.VerifyAll()
|
|
|
|
def _prepare_clone_mock(self, status):
|
|
drv = self._driver
|
|
mox = self.mox
|
|
|
|
volume = FakeVolume()
|
|
setattr(volume, 'provider_location', '127.0.0.1:/nfs')
|
|
|
|
mox.StubOutWithMock(drv, '_get_host_ip')
|
|
mox.StubOutWithMock(drv, '_get_export_path')
|
|
mox.StubOutWithMock(drv, '_get_if_info_by_ip')
|
|
mox.StubOutWithMock(drv, '_get_vol_by_junc_vserver')
|
|
mox.StubOutWithMock(drv, '_clone_file')
|
|
|
|
drv._get_host_ip(IgnoreArg()).AndReturn('127.0.0.1')
|
|
drv._get_export_path(IgnoreArg()).AndReturn('/nfs')
|
|
drv._get_if_info_by_ip('127.0.0.1').AndReturn(
|
|
self._prepare_info_by_ip_response())
|
|
drv._get_vol_by_junc_vserver('openstack', '/nfs').AndReturn('nfsvol')
|
|
drv._clone_file('nfsvol', 'volume_name', 'clone_name',
|
|
'openstack')
|
|
return mox
|
|
|
|
def _prepare_info_by_ip_response(self):
|
|
res = """<attributes-list>
|
|
<net-interface-info>
|
|
<address>127.0.0.1</address>
|
|
<administrative-status>up</administrative-status>
|
|
<current-node>fas3170rre-cmode-01</current-node>
|
|
<current-port>e1b-1165</current-port>
|
|
<data-protocols>
|
|
<data-protocol>nfs</data-protocol>
|
|
</data-protocols>
|
|
<dns-domain-name>none</dns-domain-name>
|
|
<failover-group/>
|
|
<failover-policy>disabled</failover-policy>
|
|
<firewall-policy>data</firewall-policy>
|
|
<home-node>fas3170rre-cmode-01</home-node>
|
|
<home-port>e1b-1165</home-port>
|
|
<interface-name>nfs_data1</interface-name>
|
|
<is-auto-revert>false</is-auto-revert>
|
|
<is-home>true</is-home>
|
|
<netmask>255.255.255.0</netmask>
|
|
<netmask-length>24</netmask-length>
|
|
<operational-status>up</operational-status>
|
|
<role>data</role>
|
|
<routing-group-name>c10.63.165.0/24</routing-group-name>
|
|
<use-failover-group>disabled</use-failover-group>
|
|
<vserver>openstack</vserver>
|
|
</net-interface-info></attributes-list>"""
|
|
response_el = etree.XML(res)
|
|
return api.NaElement(response_el).get_children()
|
|
|
|
def test_clone_volume(self):
|
|
drv = self._driver
|
|
mox = self._prepare_clone_mock('pass')
|
|
|
|
mox.ReplayAll()
|
|
|
|
volume_name = 'volume_name'
|
|
clone_name = 'clone_name'
|
|
volume_id = volume_name + str(hash(volume_name))
|
|
|
|
drv._clone_volume(volume_name, clone_name, volume_id)
|
|
|
|
mox.VerifyAll()
|
|
|
|
|
|
class NetappDirect7modeNfsDriverTestCase(NetappDirectCmodeNfsDriverTestCase):
|
|
"""Test direct NetApp C Mode driver."""
|
|
def _custom_setup(self):
|
|
self._driver = netapp_nfs.NetAppDirect7modeNfsDriver(
|
|
configuration=create_configuration())
|
|
|
|
def test_check_for_setup_error(self):
|
|
mox = self.mox
|
|
drv = self._driver
|
|
required_flags = [
|
|
'netapp_transport_type',
|
|
'netapp_login',
|
|
'netapp_password',
|
|
'netapp_server_hostname',
|
|
'netapp_server_port']
|
|
|
|
# set required flags
|
|
for flag in required_flags:
|
|
setattr(drv.configuration, flag, None)
|
|
# check exception raises when flags are not set
|
|
self.assertRaises(exception.CinderException,
|
|
drv.check_for_setup_error)
|
|
|
|
# set required flags
|
|
for flag in required_flags:
|
|
setattr(drv.configuration, flag, 'val')
|
|
|
|
mox.ReplayAll()
|
|
|
|
drv.check_for_setup_error()
|
|
|
|
mox.VerifyAll()
|
|
|
|
# restore initial FLAGS
|
|
for flag in required_flags:
|
|
delattr(drv.configuration, flag)
|
|
|
|
def test_do_setup(self):
|
|
mox = self.mox
|
|
drv = self._driver
|
|
|
|
mox.StubOutWithMock(drv, 'check_for_setup_error')
|
|
mox.StubOutWithMock(drv, '_get_client')
|
|
mox.StubOutWithMock(drv, '_do_custom_setup')
|
|
|
|
drv.check_for_setup_error()
|
|
drv._get_client()
|
|
drv._do_custom_setup(IgnoreArg())
|
|
|
|
mox.ReplayAll()
|
|
|
|
drv.do_setup(IsA(context.RequestContext))
|
|
|
|
mox.VerifyAll()
|
|
|
|
def _prepare_clone_mock(self, status):
|
|
drv = self._driver
|
|
mox = self.mox
|
|
|
|
volume = FakeVolume()
|
|
setattr(volume, 'provider_location', '127.0.0.1:/nfs')
|
|
|
|
mox.StubOutWithMock(drv, '_get_export_path')
|
|
mox.StubOutWithMock(drv, '_get_actual_path_for_export')
|
|
mox.StubOutWithMock(drv, '_start_clone')
|
|
mox.StubOutWithMock(drv, '_wait_for_clone_finish')
|
|
if status == 'fail':
|
|
mox.StubOutWithMock(drv, '_clear_clone')
|
|
|
|
drv._get_export_path(IgnoreArg()).AndReturn('/nfs')
|
|
drv._get_actual_path_for_export(IgnoreArg()).AndReturn('/vol/vol1/nfs')
|
|
drv._start_clone(IgnoreArg(), IgnoreArg()).AndReturn(('1', '2'))
|
|
if status == 'fail':
|
|
drv._wait_for_clone_finish('1', '2').AndRaise(
|
|
api.NaApiError('error', 'error'))
|
|
drv._clear_clone('1')
|
|
else:
|
|
drv._wait_for_clone_finish('1', '2')
|
|
return mox
|
|
|
|
def test_clone_volume_clear(self):
|
|
drv = self._driver
|
|
mox = self._prepare_clone_mock('fail')
|
|
|
|
mox.ReplayAll()
|
|
|
|
volume_name = 'volume_name'
|
|
clone_name = 'clone_name'
|
|
volume_id = volume_name + str(hash(volume_name))
|
|
try:
|
|
drv._clone_volume(volume_name, clone_name, volume_id)
|
|
except Exception as e:
|
|
if isinstance(e, api.NaApiError):
|
|
pass
|
|
else:
|
|
raise
|
|
|
|
mox.VerifyAll()
|