diff --git a/cinder/opts.py b/cinder/opts.py index 54c1015c38a..ca83068fdc7 100644 --- a/cinder/opts.py +++ b/cinder/opts.py @@ -226,6 +226,7 @@ def list_opts(): cinder_volume_drivers_netapp_options.netapp_eseries_opts, cinder_volume_drivers_netapp_options.netapp_nfs_extra_opts, cinder_volume_drivers_netapp_options.netapp_san_opts, + cinder_volume_drivers_netapp_options.netapp_replication_opts, cinder_volume_drivers_ibm_storwize_svc_storwizesvciscsi. storwize_svc_iscsi_opts, cinder_backup_drivers_glusterfs.glusterfsbackup_service_opts, diff --git a/cinder/tests/unit/volume/drivers/netapp/dataontap/client/fakes.py b/cinder/tests/unit/volume/drivers/netapp/dataontap/client/fakes.py index f6431071105..2d64e62fdc2 100644 --- a/cinder/tests/unit/volume/drivers/netapp/dataontap/client/fakes.py +++ b/cinder/tests/unit/volume/drivers/netapp/dataontap/client/fakes.py @@ -68,6 +68,10 @@ FAKE_NA_SERVER_API_1_20.set_vfiler('filer') FAKE_NA_SERVER_API_1_20.set_vserver('server') FAKE_NA_SERVER_API_1_20.set_api_version(1, 20) +VOLUME_VSERVER_NAME = 'fake_vserver' +VOLUME_NAMES = ('volume1', 'volume2') +VOLUME_NAME = 'volume1' + FAKE_QUERY = {'volume-attributes': None} @@ -104,6 +108,20 @@ NO_RECORDS_RESPONSE = etree.XML(""" """) +VOLUME_GET_NAME_RESPONSE = etree.XML(""" + + + + + %(volume)s + %(vserver)s + + + + 1 + +""" % {'volume': VOLUME_NAMES[0], 'vserver': VOLUME_VSERVER_NAME}) + INVALID_GET_ITER_RESPONSE_NO_ATTRIBUTES = etree.XML(""" 1 @@ -697,9 +715,6 @@ VOLUME_GET_ITER_CAPACITY_RESPONSE = etree.XML(""" 'total_size': VOLUME_SIZE_TOTAL, }) -VOLUME_VSERVER_NAME = 'fake_vserver' -VOLUME_NAMES = ('volume1', 'volume2') - VOLUME_GET_ITER_LIST_RESPONSE = etree.XML(""" @@ -733,6 +748,7 @@ VOLUME_GET_ITER_SSC_RESPONSE = etree.XML(""" /%(volume)s %(volume)s %(vserver)s + rw false @@ -744,7 +760,15 @@ VOLUME_GET_ITER_SSC_RESPONSE = etree.XML(""" true none + 5 + 12345 + + default + + + en_US + 1 @@ -761,6 +785,11 @@ VOLUME_INFO_SSC = { 'junction-path': '/%s' % VOLUME_NAMES[0], 'aggregate': VOLUME_AGGREGATE_NAMES[0], 'space-guarantee-enabled': True, + 'language': 'en_US', + 'percentage-snapshot-reserve': '5', + 'snapshot-policy': 'default', + 'type': 'rw', + 'size': '12345', 'space-guarantee': 'none', 'qos-policy-group': 'fake_qos_policy_group_name', } @@ -782,27 +811,6 @@ VOLUME_DEDUPE_INFO_SSC = { 'dedupe': True, } -SNAPMIRROR_GET_ITER_RESPONSE = etree.XML(""" - - - - %(vserver)s:%(volume2)s - %(volume2)s - %(vserver)s - %(vserver)s:%(volume1)s - %(volume1)s - %(vserver)s - - - 1 - -""" % { - 'volume1': VOLUME_NAMES[0], - 'volume2': VOLUME_NAMES[1], - 'vserver': VOLUME_VSERVER_NAME, -}) - - STORAGE_DISK_GET_ITER_RESPONSE_PAGE_1 = etree.XML(""" @@ -1123,3 +1131,139 @@ ISCSI_INITIATOR_GET_AUTH_ELEM = etree.XML(""" ISCSI_INITIATOR_AUTH_LIST_INFO_FAILURE = etree.XML(""" """ % INITIATOR_IQN) + +CLUSTER_NAME = 'fake_cluster' +REMOTE_CLUSTER_NAME = 'fake_cluster_2' +CLUSTER_ADDRESS_1 = 'fake_cluster_address' +CLUSTER_ADDRESS_2 = 'fake_cluster_address_2' +VSERVER_NAME = 'fake_vserver' +VSERVER_NAME_2 = 'fake_vserver_2' +SM_SOURCE_VSERVER = 'fake_source_vserver' +SM_SOURCE_VOLUME = 'fake_source_volume' +SM_DEST_VSERVER = 'fake_destination_vserver' +SM_DEST_VOLUME = 'fake_destination_volume' + +CLUSTER_PEER_GET_ITER_RESPONSE = etree.XML(""" + + + + + %(addr1)s + %(addr2)s + + available + %(cluster)s + fake_uuid + + %(addr1)s + + %(remote_cluster)s + fake_serial_number + 60 + + + 1 + +""" % { + 'addr1': CLUSTER_ADDRESS_1, + 'addr2': CLUSTER_ADDRESS_2, + 'cluster': CLUSTER_NAME, + 'remote_cluster': REMOTE_CLUSTER_NAME, +}) + +CLUSTER_PEER_POLICY_GET_RESPONSE = etree.XML(""" + + + + false + 8 + + + +""") + +VSERVER_PEER_GET_ITER_RESPONSE = etree.XML(""" + + + + + snapmirror + + %(cluster)s + peered + %(vserver2)s + %(vserver1)s + + + 2 + +""" % { + 'cluster': CLUSTER_NAME, + 'vserver1': VSERVER_NAME, + 'vserver2': VSERVER_NAME_2 +}) + +SNAPMIRROR_GET_ITER_RESPONSE = etree.XML(""" + + + + %(vserver)s:%(volume2)s + %(volume2)s + fake_destination_node + %(vserver)s + fake_snapshot + 1442701782 + false + true + 2187 + 109 + 1442701890 + test:manila + 1171456 + initialize + 0 + snapmirrored + fake_snapshot + 1442701782 + DPDefault + v2 + ea8bfcc6-5f1d-11e5-8446-123478563412 + idle + data_protection + daily + %(vserver)s:%(volume1)s + %(volume1)s + %(vserver)s + fake_destination_vserver + + + 1 + +""" % { + 'volume1': VOLUME_NAMES[0], + 'volume2': VOLUME_NAMES[1], + 'vserver': VOLUME_VSERVER_NAME, +}) + +SNAPMIRROR_GET_ITER_FILTERED_RESPONSE = etree.XML(""" + + + + fake_destination_vserver + fake_destination_volume + true + snapmirrored + daily + fake_source_vserver + fake_source_volume + + + 1 + +""") + +SNAPMIRROR_INITIALIZE_RESULT = etree.XML(""" + + succeeded + +""") diff --git a/cinder/tests/unit/volume/drivers/netapp/dataontap/client/test_client_cmode.py b/cinder/tests/unit/volume/drivers/netapp/dataontap/client/test_client_cmode.py index 78df0d2ad98..7b493c7ebf3 100644 --- a/cinder/tests/unit/volume/drivers/netapp/dataontap/client/test_client_cmode.py +++ b/cinder/tests/unit/volume/drivers/netapp/dataontap/client/test_client_cmode.py @@ -1385,6 +1385,7 @@ class NetAppCmodeClientTestCase(test.TestCase): 'name': None, 'owning-vserver-name': None, 'junction-path': None, + 'type': None, 'containing-aggregate-name': None, }, 'volume-mirror-attributes': { @@ -1394,9 +1395,17 @@ class NetAppCmodeClientTestCase(test.TestCase): 'volume-space-attributes': { 'is-space-guarantee-enabled': None, 'space-guarantee': None, + 'percentage-snapshot-reserve': None, + 'size': None, }, 'volume-qos-attributes': { 'policy-group-name': None, + }, + 'volume-snapshot-attributes': { + 'snapshot-policy': None, + }, + 'volume-language-attributes': { + 'language-code': None, } }, }, @@ -1417,6 +1426,193 @@ class NetAppCmodeClientTestCase(test.TestCase): self.client.get_flexvol, flexvol_name=fake_client.VOLUME_NAMES[0]) + def test_create_flexvol(self): + self.mock_object(self.client, 'send_request') + + self.client.create_flexvol( + fake_client.VOLUME_NAME, fake_client.VOLUME_AGGREGATE_NAME, 100) + + volume_create_args = { + 'containing-aggr-name': fake_client.VOLUME_AGGREGATE_NAME, + 'size': '100g', + 'volume': fake_client.VOLUME_NAME, + 'volume-type': 'rw', + 'junction-path': '/%s' % fake_client.VOLUME_NAME, + } + + self.client.send_request.assert_called_once_with('volume-create', + volume_create_args) + + @ddt.data('dp', 'rw', None) + def test_create_volume_with_extra_specs(self, volume_type): + + self.mock_object(self.client, 'enable_flexvol_dedupe') + self.mock_object(self.client, 'enable_flexvol_compression') + self.mock_object(self.client, 'send_request') + + self.client.create_flexvol( + fake_client.VOLUME_NAME, fake_client.VOLUME_AGGREGATE_NAME, 100, + space_guarantee_type='volume', language='en-US', + snapshot_policy='default', dedupe_enabled=True, + compression_enabled=True, snapshot_reserve=15, + volume_type=volume_type) + + volume_create_args = { + 'containing-aggr-name': fake_client.VOLUME_AGGREGATE_NAME, + 'size': '100g', + 'volume': fake_client.VOLUME_NAME, + 'space-reserve': 'volume', + 'language-code': 'en-US', + 'volume-type': volume_type, + 'percentage-snapshot-reserve': '15', + } + + if volume_type != 'dp': + volume_create_args['snapshot-policy'] = 'default' + volume_create_args['junction-path'] = ('/%s' % + fake_client.VOLUME_NAME) + + self.client.send_request.assert_called_with('volume-create', + volume_create_args) + self.client.enable_flexvol_dedupe.assert_called_once_with( + fake_client.VOLUME_NAME) + self.client.enable_flexvol_compression.assert_called_once_with( + fake_client.VOLUME_NAME) + + def test_flexvol_exists(self): + + api_response = netapp_api.NaElement( + fake_client.VOLUME_GET_NAME_RESPONSE) + self.mock_object(self.client, + 'send_iter_request', + mock.Mock(return_value=api_response)) + + result = self.client.flexvol_exists(fake_client.VOLUME_NAME) + + volume_get_iter_args = { + 'query': { + 'volume-attributes': { + 'volume-id-attributes': { + 'name': fake_client.VOLUME_NAME + } + } + }, + 'desired-attributes': { + 'volume-attributes': { + 'volume-id-attributes': { + 'name': None + } + } + } + } + + self.client.send_iter_request.assert_has_calls([ + mock.call('volume-get-iter', volume_get_iter_args)]) + self.assertTrue(result) + + def test_flexvol_exists_not_found(self): + + api_response = netapp_api.NaElement(fake_client.NO_RECORDS_RESPONSE) + self.mock_object(self.client, + 'send_request', + mock.Mock(return_value=api_response)) + + self.assertFalse(self.client.flexvol_exists(fake_client.VOLUME_NAME)) + + def test_rename_flexvol(self): + + self.mock_object(self.client, 'send_request') + + self.client.rename_flexvol(fake_client.VOLUME_NAME, 'new_name') + + volume_rename_api_args = { + 'volume': fake_client.VOLUME_NAME, + 'new-volume-name': 'new_name', + } + + self.client.send_request.assert_called_once_with( + 'volume-rename', volume_rename_api_args) + + def test_mount_flexvol_default_junction_path(self): + + self.mock_object(self.client, 'send_request') + + self.client.mount_flexvol(fake_client.VOLUME_NAME) + + volume_mount_args = { + 'volume-name': fake_client.VOLUME_NAME, + 'junction-path': '/%s' % fake_client.VOLUME_NAME, + } + + self.client.send_request.assert_has_calls([ + mock.call('volume-mount', volume_mount_args)]) + + def test_mount_flexvol(self): + + self.mock_object(self.client, 'send_request') + fake_path = '/fake_path' + + self.client.mount_flexvol(fake_client.VOLUME_NAME, + junction_path=fake_path) + + volume_mount_args = { + 'volume-name': fake_client.VOLUME_NAME, + 'junction-path': fake_path, + } + + self.client.send_request.assert_has_calls([ + mock.call('volume-mount', volume_mount_args)]) + + def test_enable_flexvol_dedupe(self): + + self.mock_object(self.client, 'send_request') + + self.client.enable_flexvol_dedupe(fake_client.VOLUME_NAME) + + sis_enable_args = {'path': '/vol/%s' % fake_client.VOLUME_NAME} + + self.client.send_request.assert_called_once_with('sis-enable', + sis_enable_args) + + def test_disable_flexvol_dedupe(self): + + self.mock_object(self.client, 'send_request') + + self.client.disable_flexvol_dedupe(fake_client.VOLUME_NAME) + + sis_disable_args = {'path': '/vol/%s' % fake_client.VOLUME_NAME} + + self.client.send_request.assert_called_once_with('sis-disable', + sis_disable_args) + + def test_enable_flexvol_compression(self): + + self.mock_object(self.client, 'send_request') + + self.client.enable_flexvol_compression(fake_client.VOLUME_NAME) + + sis_set_config_args = { + 'path': '/vol/%s' % fake_client.VOLUME_NAME, + 'enable-compression': 'true' + } + + self.client.send_request.assert_called_once_with('sis-set-config', + sis_set_config_args) + + def test_disable_flexvol_compression(self): + + self.mock_object(self.client, 'send_request') + + self.client.disable_flexvol_compression(fake_client.VOLUME_NAME) + + sis_set_config_args = { + 'path': '/vol/%s' % fake_client.VOLUME_NAME, + 'enable-compression': 'false' + } + + self.client.send_request.assert_called_once_with('sis-set-config', + sis_set_config_args) + def test_get_flexvol_dedupe_info(self): api_response = netapp_api.NaElement( @@ -2161,3 +2357,793 @@ class NetAppCmodeClientTestCase(test.TestCase): self.assertRaises(exception.SnapshotNotFound, self.client.get_snapshot, expected_vol_name, expected_snapshot_name) + + def test_create_cluster_peer(self): + + self.mock_object(self.client, 'send_request') + + self.client.create_cluster_peer(['fake_address_1', 'fake_address_2'], + 'fake_user', 'fake_password', + 'fake_passphrase') + + cluster_peer_create_args = { + 'peer-addresses': [ + {'remote-inet-address': 'fake_address_1'}, + {'remote-inet-address': 'fake_address_2'}, + ], + 'user-name': 'fake_user', + 'password': 'fake_password', + 'passphrase': 'fake_passphrase', + } + self.client.send_request.assert_has_calls([ + mock.call('cluster-peer-create', cluster_peer_create_args)]) + + def test_get_cluster_peers(self): + + api_response = netapp_api.NaElement( + fake_client.CLUSTER_PEER_GET_ITER_RESPONSE) + self.mock_object(self.client, + 'send_iter_request', + mock.Mock(return_value=api_response)) + + result = self.client.get_cluster_peers() + + cluster_peer_get_iter_args = {} + self.client.send_iter_request.assert_has_calls([ + mock.call('cluster-peer-get-iter', cluster_peer_get_iter_args)]) + + expected = [{ + 'active-addresses': [ + fake_client.CLUSTER_ADDRESS_1, + fake_client.CLUSTER_ADDRESS_2 + ], + 'availability': 'available', + 'cluster-name': fake_client.CLUSTER_NAME, + 'cluster-uuid': 'fake_uuid', + 'peer-addresses': [fake_client.CLUSTER_ADDRESS_1], + 'remote-cluster-name': fake_client.REMOTE_CLUSTER_NAME, + 'serial-number': 'fake_serial_number', + 'timeout': '60', + }] + + self.assertEqual(expected, result) + + def test_get_cluster_peers_single(self): + + api_response = netapp_api.NaElement( + fake_client.CLUSTER_PEER_GET_ITER_RESPONSE) + self.mock_object(self.client, + 'send_iter_request', + mock.Mock(return_value=api_response)) + + self.client.get_cluster_peers( + remote_cluster_name=fake_client.CLUSTER_NAME) + + cluster_peer_get_iter_args = { + 'query': { + 'cluster-peer-info': { + 'remote-cluster-name': fake_client.CLUSTER_NAME, + } + }, + } + self.client.send_iter_request.assert_has_calls([ + mock.call('cluster-peer-get-iter', cluster_peer_get_iter_args)]) + + def test_get_cluster_peers_not_found(self): + + api_response = netapp_api.NaElement(fake_client.NO_RECORDS_RESPONSE) + self.mock_object(self.client, + 'send_iter_request', + mock.Mock(return_value=api_response)) + + result = self.client.get_cluster_peers( + remote_cluster_name=fake_client.CLUSTER_NAME) + + self.assertEqual([], result) + self.assertTrue(self.client.send_iter_request.called) + + def test_delete_cluster_peer(self): + + self.mock_object(self.client, 'send_request') + + self.client.delete_cluster_peer(fake_client.CLUSTER_NAME) + + cluster_peer_delete_args = {'cluster-name': fake_client.CLUSTER_NAME} + self.client.send_request.assert_has_calls([ + mock.call('cluster-peer-delete', cluster_peer_delete_args)]) + + def test_get_cluster_peer_policy(self): + + self.client.features.add_feature('CLUSTER_PEER_POLICY') + + api_response = netapp_api.NaElement( + fake_client.CLUSTER_PEER_POLICY_GET_RESPONSE) + self.mock_object(self.client, + 'send_request', + mock.Mock(return_value=api_response)) + + result = self.client.get_cluster_peer_policy() + + expected = { + 'is-unauthenticated-access-permitted': False, + 'passphrase-minimum-length': 8, + } + self.assertEqual(expected, result) + self.assertTrue(self.client.send_request.called) + + def test_get_cluster_peer_policy_not_supported(self): + + result = self.client.get_cluster_peer_policy() + + self.assertEqual({}, result) + + def test_set_cluster_peer_policy_not_supported(self): + + self.mock_object(self.client, 'send_request') + + self.client.set_cluster_peer_policy() + + self.assertFalse(self.client.send_request.called) + + def test_set_cluster_peer_policy_no_arguments(self): + + self.client.features.add_feature('CLUSTER_PEER_POLICY') + self.mock_object(self.client, 'send_request') + + self.client.set_cluster_peer_policy() + + self.assertFalse(self.client.send_request.called) + + def test_set_cluster_peer_policy(self): + + self.client.features.add_feature('CLUSTER_PEER_POLICY') + self.mock_object(self.client, 'send_request') + + self.client.set_cluster_peer_policy( + is_unauthenticated_access_permitted=True, + passphrase_minimum_length=12) + + cluster_peer_policy_modify_args = { + 'is-unauthenticated-access-permitted': 'true', + 'passphrase-minlength': '12', + } + self.client.send_request.assert_has_calls([ + mock.call('cluster-peer-policy-modify', + cluster_peer_policy_modify_args)]) + + def test_create_vserver_peer(self): + + self.mock_object(self.client, 'send_request') + + self.client.create_vserver_peer('fake_vserver', 'fake_vserver_peer') + + vserver_peer_create_args = { + 'vserver': 'fake_vserver', + 'peer-vserver': 'fake_vserver_peer', + 'applications': [ + {'vserver-peer-application': 'snapmirror'}, + ], + } + self.client.send_request.assert_has_calls([ + mock.call('vserver-peer-create', vserver_peer_create_args)]) + + def test_delete_vserver_peer(self): + + self.mock_object(self.client, 'send_request') + + self.client.delete_vserver_peer('fake_vserver', 'fake_vserver_peer') + + vserver_peer_delete_args = { + 'vserver': 'fake_vserver', + 'peer-vserver': 'fake_vserver_peer', + } + self.client.send_request.assert_has_calls([ + mock.call('vserver-peer-delete', vserver_peer_delete_args)]) + + def test_accept_vserver_peer(self): + + self.mock_object(self.client, 'send_request') + + self.client.accept_vserver_peer('fake_vserver', 'fake_vserver_peer') + + vserver_peer_accept_args = { + 'vserver': 'fake_vserver', + 'peer-vserver': 'fake_vserver_peer', + } + self.client.send_request.assert_has_calls([ + mock.call('vserver-peer-accept', vserver_peer_accept_args)]) + + def test_get_vserver_peers(self): + + api_response = netapp_api.NaElement( + fake_client.VSERVER_PEER_GET_ITER_RESPONSE) + self.mock_object(self.client, + 'send_iter_request', + mock.Mock(return_value=api_response)) + + result = self.client.get_vserver_peers( + vserver_name=fake_client.VSERVER_NAME, + peer_vserver_name=fake_client.VSERVER_NAME_2) + + vserver_peer_get_iter_args = { + 'query': { + 'vserver-peer-info': { + 'vserver': fake_client.VSERVER_NAME, + 'peer-vserver': fake_client.VSERVER_NAME_2, + } + }, + } + self.client.send_iter_request.assert_has_calls([ + mock.call('vserver-peer-get-iter', vserver_peer_get_iter_args)]) + + expected = [{ + 'vserver': 'fake_vserver', + 'peer-vserver': 'fake_vserver_2', + 'peer-state': 'peered', + 'peer-cluster': 'fake_cluster' + }] + self.assertEqual(expected, result) + + def test_get_vserver_peers_not_found(self): + + api_response = netapp_api.NaElement(fake_client.NO_RECORDS_RESPONSE) + self.mock_object(self.client, + 'send_iter_request', + mock.Mock(return_value=api_response)) + + result = self.client.get_vserver_peers( + vserver_name=fake_client.VSERVER_NAME, + peer_vserver_name=fake_client.VSERVER_NAME_2) + + self.assertEqual([], result) + self.assertTrue(self.client.send_iter_request.called) + + def test_ensure_snapmirror_v2(self): + + self.assertIsNone(self.client._ensure_snapmirror_v2()) + + def test_ensure_snapmirror_v2_not_supported(self): + + self.client.features.add_feature('SNAPMIRROR_V2', supported=False) + + self.assertRaises(exception.NetAppDriverException, + self.client._ensure_snapmirror_v2) + + @ddt.data({'schedule': 'fake_schedule', 'policy': 'fake_policy'}, + {'schedule': None, 'policy': None}) + @ddt.unpack + def test_create_snapmirror(self, schedule, policy): + self.mock_object(self.client, 'send_request') + + self.client.create_snapmirror( + fake_client.SM_SOURCE_VSERVER, fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, fake_client.SM_DEST_VOLUME, + schedule=schedule, policy=policy) + + snapmirror_create_args = { + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + 'relationship-type': 'data_protection', + } + if schedule: + snapmirror_create_args['schedule'] = schedule + if policy: + snapmirror_create_args['policy'] = policy + self.client.send_request.assert_has_calls([ + mock.call('snapmirror-create', snapmirror_create_args)]) + + def test_create_snapmirror_already_exists(self): + mock_send_req = mock.Mock(side_effect=netapp_api.NaApiError( + code=netapp_api.ERELATION_EXISTS)) + self.mock_object(self.client, 'send_request', mock_send_req) + + self.client.create_snapmirror( + fake_client.SM_SOURCE_VSERVER, fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, fake_client.SM_DEST_VOLUME) + + snapmirror_create_args = { + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + 'relationship-type': 'data_protection', + } + self.client.send_request.assert_has_calls([ + mock.call('snapmirror-create', snapmirror_create_args)]) + + def test_create_snapmirror_error(self): + mock_send_req = mock.Mock(side_effect=netapp_api.NaApiError( + code=0)) + self.mock_object(self.client, 'send_request', mock_send_req) + + self.assertRaises(netapp_api.NaApiError, + self.client.create_snapmirror, + fake_client.SM_SOURCE_VSERVER, + fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, + fake_client.SM_DEST_VOLUME) + self.assertTrue(self.client.send_request.called) + + @ddt.data( + { + 'source_snapshot': 'fake_snapshot', + 'transfer_priority': 'fake_priority' + }, + { + 'source_snapshot': None, + 'transfer_priority': None + } + ) + @ddt.unpack + def test_initialize_snapmirror(self, source_snapshot, transfer_priority): + + api_response = netapp_api.NaElement( + fake_client.SNAPMIRROR_INITIALIZE_RESULT) + self.mock_object(self.client, + 'send_request', + mock.Mock(return_value=api_response)) + + result = self.client.initialize_snapmirror( + fake_client.SM_SOURCE_VSERVER, fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, fake_client.SM_DEST_VOLUME, + source_snapshot=source_snapshot, + transfer_priority=transfer_priority) + + snapmirror_initialize_args = { + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + } + if source_snapshot: + snapmirror_initialize_args['source-snapshot'] = source_snapshot + if transfer_priority: + snapmirror_initialize_args['transfer-priority'] = transfer_priority + self.client.send_request.assert_has_calls([ + mock.call('snapmirror-initialize', snapmirror_initialize_args)]) + + expected = { + 'operation-id': None, + 'status': 'succeeded', + 'jobid': None, + 'error-code': None, + 'error-message': None + } + self.assertEqual(expected, result) + + @ddt.data(True, False) + def test_release_snapmirror(self, relationship_info_only): + + self.mock_object(self.client, 'send_request') + + self.client.release_snapmirror( + fake_client.SM_SOURCE_VSERVER, fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, fake_client.SM_DEST_VOLUME, + relationship_info_only=relationship_info_only) + + snapmirror_release_args = { + 'query': { + 'snapmirror-destination-info': { + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + 'relationship-info-only': ('true' if relationship_info_only + else 'false'), + } + } + } + self.client.send_request.assert_has_calls([ + mock.call('snapmirror-release-iter', snapmirror_release_args)]) + + def test_quiesce_snapmirror(self): + + self.mock_object(self.client, 'send_request') + + self.client.quiesce_snapmirror( + fake_client.SM_SOURCE_VSERVER, fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, fake_client.SM_DEST_VOLUME) + + snapmirror_quiesce_args = { + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + } + self.client.send_request.assert_has_calls([ + mock.call('snapmirror-quiesce', snapmirror_quiesce_args)]) + + @ddt.data(True, False) + def test_abort_snapmirror(self, clear_checkpoint): + + self.mock_object(self.client, 'send_request') + + self.client.abort_snapmirror( + fake_client.SM_SOURCE_VSERVER, fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, fake_client.SM_DEST_VOLUME, + clear_checkpoint=clear_checkpoint) + + snapmirror_abort_args = { + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + 'clear-checkpoint': 'true' if clear_checkpoint else 'false', + } + self.client.send_request.assert_has_calls([ + mock.call('snapmirror-abort', snapmirror_abort_args)]) + + def test_abort_snapmirror_no_transfer_in_progress(self): + mock_send_req = mock.Mock(side_effect=netapp_api.NaApiError( + code=netapp_api.ENOTRANSFER_IN_PROGRESS)) + self.mock_object(self.client, 'send_request', mock_send_req) + + self.client.abort_snapmirror( + fake_client.SM_SOURCE_VSERVER, fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, fake_client.SM_DEST_VOLUME) + + snapmirror_abort_args = { + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + 'clear-checkpoint': 'false', + } + self.client.send_request.assert_has_calls([ + mock.call('snapmirror-abort', snapmirror_abort_args)]) + + def test_abort_snapmirror_error(self): + mock_send_req = mock.Mock(side_effect=netapp_api.NaApiError(code=0)) + self.mock_object(self.client, 'send_request', mock_send_req) + + self.assertRaises(netapp_api.NaApiError, + self.client.abort_snapmirror, + fake_client.SM_SOURCE_VSERVER, + fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, + fake_client.SM_DEST_VOLUME) + + def test_break_snapmirror(self): + + self.mock_object(self.client, 'send_request') + + self.client.break_snapmirror( + fake_client.SM_SOURCE_VSERVER, fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, fake_client.SM_DEST_VOLUME) + + snapmirror_break_args = { + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + } + self.client.send_request.assert_has_calls([ + mock.call('snapmirror-break', snapmirror_break_args)]) + + @ddt.data( + { + 'schedule': 'fake_schedule', + 'policy': 'fake_policy', + 'tries': 5, + 'max_transfer_rate': 1024, + }, + { + 'schedule': None, + 'policy': None, + 'tries': None, + 'max_transfer_rate': None, + } + ) + @ddt.unpack + def test_modify_snapmirror(self, schedule, policy, tries, + max_transfer_rate): + + self.mock_object(self.client, 'send_request') + + self.client.modify_snapmirror( + fake_client.SM_SOURCE_VSERVER, fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, fake_client.SM_DEST_VOLUME, + schedule=schedule, policy=policy, tries=tries, + max_transfer_rate=max_transfer_rate) + + snapmirror_modify_args = { + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + } + if schedule: + snapmirror_modify_args['schedule'] = schedule + if policy: + snapmirror_modify_args['policy'] = policy + if tries: + snapmirror_modify_args['tries'] = tries + if max_transfer_rate: + snapmirror_modify_args['max-transfer-rate'] = max_transfer_rate + self.client.send_request.assert_has_calls([ + mock.call('snapmirror-modify', snapmirror_modify_args)]) + + def test_delete_snapmirror(self): + + self.mock_object(self.client, 'send_request') + + self.client.delete_snapmirror( + fake_client.SM_SOURCE_VSERVER, fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, fake_client.SM_DEST_VOLUME) + + snapmirror_delete_args = { + 'query': { + 'snapmirror-info': { + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + } + } + } + self.client.send_request.assert_has_calls([ + mock.call('snapmirror-destroy-iter', snapmirror_delete_args)]) + + def test_update_snapmirror(self): + + self.mock_object(self.client, 'send_request') + + self.client.update_snapmirror( + fake_client.SM_SOURCE_VSERVER, fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, fake_client.SM_DEST_VOLUME) + + snapmirror_update_args = { + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + } + self.client.send_request.assert_has_calls([ + mock.call('snapmirror-update', snapmirror_update_args)]) + + def test_update_snapmirror_already_transferring(self): + mock_send_req = mock.Mock(side_effect=netapp_api.NaApiError( + code=netapp_api.ETRANSFER_IN_PROGRESS)) + self.mock_object(self.client, 'send_request', mock_send_req) + + self.client.update_snapmirror( + fake_client.SM_SOURCE_VSERVER, fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, fake_client.SM_DEST_VOLUME) + + snapmirror_update_args = { + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + } + self.client.send_request.assert_has_calls([ + mock.call('snapmirror-update', snapmirror_update_args)]) + + def test_update_snapmirror_already_transferring_two(self): + mock_send_req = mock.Mock(side_effect=netapp_api.NaApiError( + code=netapp_api.EANOTHER_OP_ACTIVE)) + self.mock_object(self.client, 'send_request', mock_send_req) + + self.client.update_snapmirror( + fake_client.SM_SOURCE_VSERVER, fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, fake_client.SM_DEST_VOLUME) + + snapmirror_update_args = { + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + } + self.client.send_request.assert_has_calls([ + mock.call('snapmirror-update', snapmirror_update_args)]) + + def test_update_snapmirror_error(self): + mock_send_req = mock.Mock(side_effect=netapp_api.NaApiError(code=0)) + self.mock_object(self.client, 'send_request', mock_send_req) + + self.assertRaises(netapp_api.NaApiError, + self.client.update_snapmirror, + fake_client.SM_SOURCE_VSERVER, + fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, + fake_client.SM_DEST_VOLUME) + + def test_resume_snapmirror(self): + self.mock_object(self.client, 'send_request') + + self.client.resume_snapmirror( + fake_client.SM_SOURCE_VSERVER, fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, fake_client.SM_DEST_VOLUME) + + snapmirror_resume_args = { + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + } + self.client.send_request.assert_has_calls([ + mock.call('snapmirror-resume', snapmirror_resume_args)]) + + def test_resume_snapmirror_not_quiesed(self): + mock_send_req = mock.Mock(side_effect=netapp_api.NaApiError( + code=netapp_api.ERELATION_NOT_QUIESCED)) + self.mock_object(self.client, 'send_request', mock_send_req) + + self.client.resume_snapmirror( + fake_client.SM_SOURCE_VSERVER, fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, fake_client.SM_DEST_VOLUME) + + snapmirror_resume_args = { + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + } + self.client.send_request.assert_has_calls([ + mock.call('snapmirror-resume', snapmirror_resume_args)]) + + def test_resume_snapmirror_error(self): + mock_send_req = mock.Mock(side_effect=netapp_api.NaApiError(code=0)) + self.mock_object(self.client, 'send_request', mock_send_req) + + self.assertRaises(netapp_api.NaApiError, + self.client.resume_snapmirror, + fake_client.SM_SOURCE_VSERVER, + fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, + fake_client.SM_DEST_VOLUME) + + def test_resync_snapmirror(self): + self.mock_object(self.client, 'send_request') + + self.client.resync_snapmirror( + fake_client.SM_SOURCE_VSERVER, fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, fake_client.SM_DEST_VOLUME) + + snapmirror_resync_args = { + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + } + self.client.send_request.assert_has_calls([ + mock.call('snapmirror-resync', snapmirror_resync_args)]) + + def test__get_snapmirrors(self): + + api_response = netapp_api.NaElement( + fake_client.SNAPMIRROR_GET_ITER_RESPONSE) + self.mock_object(self.client, + 'send_iter_request', + mock.Mock(return_value=api_response)) + + desired_attributes = { + 'snapmirror-info': { + 'source-vserver': None, + 'source-volume': None, + 'destination-vserver': None, + 'destination-volume': None, + 'is-healthy': None, + } + } + + result = self.client._get_snapmirrors( + fake_client.SM_SOURCE_VSERVER, fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, fake_client.SM_DEST_VOLUME, + desired_attributes=desired_attributes) + + snapmirror_get_iter_args = { + 'query': { + 'snapmirror-info': { + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + }, + }, + 'desired-attributes': { + 'snapmirror-info': { + 'source-vserver': None, + 'source-volume': None, + 'destination-vserver': None, + 'destination-volume': None, + 'is-healthy': None, + }, + }, + } + self.client.send_iter_request.assert_has_calls([ + mock.call('snapmirror-get-iter', snapmirror_get_iter_args)]) + self.assertEqual(1, len(result)) + + def test__get_snapmirrors_not_found(self): + + api_response = netapp_api.NaElement(fake_client.NO_RECORDS_RESPONSE) + self.mock_object(self.client, + 'send_iter_request', + mock.Mock(return_value=api_response)) + + result = self.client._get_snapmirrors() + + self.client.send_iter_request.assert_has_calls([ + mock.call('snapmirror-get-iter', {})]) + + self.assertEqual([], result) + + def test_get_snapmirrors(self): + + api_response = netapp_api.NaElement( + fake_client.SNAPMIRROR_GET_ITER_FILTERED_RESPONSE) + self.mock_object(self.client, + 'send_iter_request', + mock.Mock(return_value=api_response)) + + desired_attributes = ['source-vserver', 'source-volume', + 'destination-vserver', 'destination-volume', + 'is-healthy', 'mirror-state', 'schedule'] + + result = self.client.get_snapmirrors( + fake_client.SM_SOURCE_VSERVER, fake_client.SM_SOURCE_VOLUME, + fake_client.SM_DEST_VSERVER, fake_client.SM_DEST_VOLUME, + desired_attributes=desired_attributes) + + snapmirror_get_iter_args = { + 'query': { + 'snapmirror-info': { + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + }, + }, + 'desired-attributes': { + 'snapmirror-info': { + 'source-vserver': None, + 'source-volume': None, + 'destination-vserver': None, + 'destination-volume': None, + 'is-healthy': None, + 'mirror-state': None, + 'schedule': None, + }, + }, + } + + expected = [{ + 'source-vserver': fake_client.SM_SOURCE_VSERVER, + 'source-volume': fake_client.SM_SOURCE_VOLUME, + 'destination-vserver': fake_client.SM_DEST_VSERVER, + 'destination-volume': fake_client.SM_DEST_VOLUME, + 'is-healthy': 'true', + 'mirror-state': 'snapmirrored', + 'schedule': 'daily', + }] + + self.client.send_iter_request.assert_has_calls([ + mock.call('snapmirror-get-iter', snapmirror_get_iter_args)]) + self.assertEqual(expected, result) + + def test_get_provisioning_options_from_flexvol(self): + + self.mock_object(self.client, 'get_flexvol', + mock.Mock(return_value=fake_client.VOLUME_INFO_SSC)) + self.mock_object(self.client, 'get_flexvol_dedupe_info', mock.Mock( + return_value=fake_client.VOLUME_DEDUPE_INFO_SSC)) + + expected_prov_opts = { + 'aggregate': 'fake_aggr1', + 'compression_enabled': False, + 'dedupe_enabled': True, + 'language': 'en_US', + 'size': 1, + 'snapshot_policy': 'default', + 'snapshot_reserve': '5', + 'space_guarantee_type': 'none', + 'volume_type': 'rw' + } + + actual_prov_opts = self.client.get_provisioning_options_from_flexvol( + fake_client.VOLUME_NAME) + + self.assertEqual(expected_prov_opts, actual_prov_opts) diff --git a/cinder/tests/unit/volume/drivers/netapp/dataontap/fakes.py b/cinder/tests/unit/volume/drivers/netapp/dataontap/fakes.py index 0c84b7094b7..dbbac893ca0 100644 --- a/cinder/tests/unit/volume/drivers/netapp/dataontap/fakes.py +++ b/cinder/tests/unit/volume/drivers/netapp/dataontap/fakes.py @@ -34,6 +34,7 @@ EXPORT_PATH = '/fake/export/path' NFS_SHARE = '%s:%s' % (SHARE_IP, EXPORT_PATH) HOST_STRING = '%s@%s#%s' % (HOST_NAME, BACKEND_NAME, POOL_NAME) NFS_HOST_STRING = '%s@%s#%s' % (HOST_NAME, BACKEND_NAME, NFS_SHARE) +AGGREGATE = 'aggr1' FLEXVOL = 'openstack-flexvol' NFS_FILE_PATH = 'nfsvol' PATH = '/vol/%s/%s' % (POOL_NAME, LUN_NAME) diff --git a/cinder/tests/unit/volume/drivers/netapp/dataontap/performance/test_perf_cmode.py b/cinder/tests/unit/volume/drivers/netapp/dataontap/performance/test_perf_cmode.py index da52f356a22..caf2bee9e96 100644 --- a/cinder/tests/unit/volume/drivers/netapp/dataontap/performance/test_perf_cmode.py +++ b/cinder/tests/unit/volume/drivers/netapp/dataontap/performance/test_perf_cmode.py @@ -331,6 +331,16 @@ class PerformanceCmodeLibraryTestCase(test.TestCase): self.assertAlmostEqual(expected, result) + def test__update_for_failover(self): + self.mock_object(self.perf_library, 'update_performance_cache') + mock_client = mock.Mock(name='FAKE_ZAPI_CLIENT') + + self.perf_library._update_for_failover(mock_client, self.fake_volumes) + + self.assertEqual(mock_client, self.perf_library.zapi_client) + self.perf_library.update_performance_cache.assert_called_once_with( + self.fake_volumes) + def test_get_aggregates_for_pools(self): result = self.perf_library._get_aggregates_for_pools(self.fake_volumes) diff --git a/cinder/tests/unit/volume/drivers/netapp/dataontap/test_block_7mode.py b/cinder/tests/unit/volume/drivers/netapp/dataontap/test_block_7mode.py index 53471b57a27..a3f43b92b2b 100644 --- a/cinder/tests/unit/volume/drivers/netapp/dataontap/test_block_7mode.py +++ b/cinder/tests/unit/volume/drivers/netapp/dataontap/test_block_7mode.py @@ -47,7 +47,10 @@ class NetAppBlockStorage7modeLibraryTestCase(test.TestCase): def setUp(self): super(NetAppBlockStorage7modeLibraryTestCase, self).setUp() - kwargs = {'configuration': self.get_config_7mode()} + kwargs = { + 'configuration': self.get_config_7mode(), + 'host': 'openstack@7modeblock', + } self.library = block_7mode.NetAppBlockStorage7modeLibrary( 'driver', 'protocol', **kwargs) diff --git a/cinder/tests/unit/volume/drivers/netapp/dataontap/test_block_base.py b/cinder/tests/unit/volume/drivers/netapp/dataontap/test_block_base.py index a2294950414..253bda3b93f 100644 --- a/cinder/tests/unit/volume/drivers/netapp/dataontap/test_block_base.py +++ b/cinder/tests/unit/volume/drivers/netapp/dataontap/test_block_base.py @@ -28,11 +28,12 @@ import uuid import ddt import mock from oslo_log import versionutils +from oslo_service import loopingcall from oslo_utils import units import six from cinder import exception -from cinder.i18n import _, _LW +from cinder.i18n import _LW from cinder import test from cinder.tests.unit.volume.drivers.netapp.dataontap import fakes as fake import cinder.tests.unit.volume.drivers.netapp.fakes as na_fakes @@ -48,7 +49,10 @@ class NetAppBlockStorageLibraryTestCase(test.TestCase): def setUp(self): super(NetAppBlockStorageLibraryTestCase, self).setUp() - kwargs = {'configuration': self.get_config_base()} + kwargs = { + 'configuration': self.get_config_base(), + 'host': 'openstack@netappblock', + } self.library = block_base.NetAppBlockStorageLibrary( 'driver', 'protocol', **kwargs) self.library.zapi_client = mock.Mock() @@ -740,11 +744,11 @@ class NetAppBlockStorageLibraryTestCase(test.TestCase): def test_setup_error_invalid_lun_os(self): self.library.configuration.netapp_lun_ostype = 'unknown' self.library.do_setup(mock.Mock()) + self.assertRaises(exception.NetAppDriverException, self.library.check_for_setup_error) - msg = _("Invalid value for NetApp configuration" - " option netapp_lun_ostype.") - block_base.LOG.error.assert_called_once_with(msg) + + block_base.LOG.error.assert_called_once_with(mock.ANY) @mock.patch.object(na_utils, 'check_flags', mock.Mock()) @mock.patch.object(block_base, 'LOG', mock.Mock()) @@ -756,9 +760,7 @@ class NetAppBlockStorageLibraryTestCase(test.TestCase): self.assertRaises(exception.NetAppDriverException, self.library.check_for_setup_error) - msg = _("Invalid value for NetApp configuration" - " option netapp_host_type.") - block_base.LOG.error.assert_called_once_with(msg) + block_base.LOG.error.assert_called_once_with(mock.ANY) @mock.patch.object(na_utils, 'check_flags', mock.Mock()) def test_check_for_setup_error_both_config(self): @@ -767,9 +769,13 @@ class NetAppBlockStorageLibraryTestCase(test.TestCase): self.library.do_setup(mock.Mock()) self.zapi_client.get_lun_list.return_value = ['lun1'] self.library._extract_and_populate_luns = mock.Mock() + mock_start_periodic_tasks = self.mock_object( + self.library, '_start_periodic_tasks') self.library.check_for_setup_error() + self.library._extract_and_populate_luns.assert_called_once_with( ['lun1']) + mock_start_periodic_tasks.assert_called_once_with() @mock.patch.object(na_utils, 'check_flags', mock.Mock()) def test_check_for_setup_error_no_os_host(self): @@ -778,9 +784,29 @@ class NetAppBlockStorageLibraryTestCase(test.TestCase): self.library.do_setup(mock.Mock()) self.zapi_client.get_lun_list.return_value = ['lun1'] self.library._extract_and_populate_luns = mock.Mock() + mock_start_periodic_tasks = self.mock_object( + self.library, '_start_periodic_tasks') + self.library.check_for_setup_error() self.library._extract_and_populate_luns.assert_called_once_with( ['lun1']) + mock_start_periodic_tasks.assert_called_once_with() + + def test_start_periodic_tasks(self): + + mock_handle_housekeeping_tasks = self.mock_object( + self.library, '_handle_housekeeping_tasks') + + housekeeping_periodic_task = mock.Mock() + mock_loopingcall = self.mock_object( + loopingcall, 'FixedIntervalLoopingCall', + mock.Mock(return_value=housekeeping_periodic_task)) + + self.library._start_periodic_tasks() + + mock_loopingcall.assert_called_once_with( + mock_handle_housekeeping_tasks) + self.assertTrue(housekeeping_periodic_task.start.called) def test_delete_volume(self): mock_delete_lun = self.mock_object(self.library, '_delete_lun') diff --git a/cinder/tests/unit/volume/drivers/netapp/dataontap/test_block_cmode.py b/cinder/tests/unit/volume/drivers/netapp/dataontap/test_block_cmode.py index 335ae3df9f7..56036183ff0 100644 --- a/cinder/tests/unit/volume/drivers/netapp/dataontap/test_block_cmode.py +++ b/cinder/tests/unit/volume/drivers/netapp/dataontap/test_block_cmode.py @@ -25,12 +25,16 @@ from oslo_service import loopingcall from cinder import exception from cinder import test import cinder.tests.unit.volume.drivers.netapp.dataontap.fakes as fake +from cinder.tests.unit.volume.drivers.netapp.dataontap.utils import fakes as\ + fake_utils import cinder.tests.unit.volume.drivers.netapp.fakes as na_fakes from cinder.volume.drivers.netapp.dataontap import block_base from cinder.volume.drivers.netapp.dataontap import block_cmode from cinder.volume.drivers.netapp.dataontap.client import api as netapp_api from cinder.volume.drivers.netapp.dataontap.client import client_base from cinder.volume.drivers.netapp.dataontap.performance import perf_cmode +from cinder.volume.drivers.netapp.dataontap.utils import data_motion +from cinder.volume.drivers.netapp.dataontap.utils import utils as config_utils from cinder.volume.drivers.netapp import utils as na_utils @@ -41,7 +45,10 @@ class NetAppBlockStorageCmodeLibraryTestCase(test.TestCase): def setUp(self): super(NetAppBlockStorageCmodeLibraryTestCase, self).setUp() - kwargs = {'configuration': self.get_config_cmode()} + kwargs = { + 'configuration': self.get_config_cmode(), + 'host': 'openstack@cdotblock', + } self.library = block_cmode.NetAppBlockStorageCmodeLibrary( 'driver', 'protocol', **kwargs) @@ -82,6 +89,9 @@ class NetAppBlockStorageCmodeLibraryTestCase(test.TestCase): @mock.patch.object(block_base.NetAppBlockStorageLibrary, 'do_setup') def test_do_setup(self, super_do_setup, mock_check_flags): self.mock_object(client_base.Client, '_init_ssh_client') + self.mock_object( + config_utils, 'get_backend_configuration', + mock.Mock(return_value=self.get_config_cmode())) context = mock.Mock() self.library.do_setup(context) @@ -94,8 +104,6 @@ class NetAppBlockStorageCmodeLibraryTestCase(test.TestCase): block_base.NetAppBlockStorageLibrary, 'check_for_setup_error') mock_check_api_permissions = self.mock_object( self.library.ssc_library, 'check_api_permissions') - mock_start_periodic_tasks = self.mock_object( - self.library, '_start_periodic_tasks') mock_get_pool_map = self.mock_object( self.library, '_get_flexvol_to_pool_map', mock.Mock(return_value={'fake_map': None})) @@ -104,7 +112,6 @@ class NetAppBlockStorageCmodeLibraryTestCase(test.TestCase): self.assertEqual(1, super_check_for_setup_error.call_count) mock_check_api_permissions.assert_called_once_with() - self.assertEqual(1, mock_start_periodic_tasks.call_count) mock_get_pool_map.assert_called_once_with() def test_check_for_setup_error_no_filtered_pools(self): @@ -112,7 +119,6 @@ class NetAppBlockStorageCmodeLibraryTestCase(test.TestCase): 'check_for_setup_error') mock_check_api_permissions = self.mock_object( self.library.ssc_library, 'check_api_permissions') - self.mock_object(self.library, '_start_periodic_tasks') self.mock_object( self.library, '_get_flexvol_to_pool_map', mock.Mock(return_value={})) @@ -122,6 +128,51 @@ class NetAppBlockStorageCmodeLibraryTestCase(test.TestCase): mock_check_api_permissions.assert_called_once_with() + def test_start_periodic_tasks(self): + + mock_update_ssc = self.mock_object( + self.library, '_update_ssc') + super_start_periodic_tasks = self.mock_object( + block_base.NetAppBlockStorageLibrary, '_start_periodic_tasks') + + update_ssc_periodic_task = mock.Mock() + mock_loopingcall = self.mock_object( + loopingcall, 'FixedIntervalLoopingCall', + mock.Mock(return_value=update_ssc_periodic_task)) + + self.library._start_periodic_tasks() + + mock_loopingcall.assert_called_once_with(mock_update_ssc) + self.assertTrue(update_ssc_periodic_task.start.called) + mock_update_ssc.assert_called_once_with() + super_start_periodic_tasks.assert_called_once_with() + + @ddt.data({'replication_enabled': True, 'failed_over': False}, + {'replication_enabled': True, 'failed_over': True}, + {'replication_enabled': False, 'failed_over': False}) + @ddt.unpack + def test_handle_housekeeping_tasks(self, replication_enabled, failed_over): + ensure_mirrors = self.mock_object(data_motion.DataMotionMixin, + 'ensure_snapmirrors') + self.mock_object(self.library.ssc_library, 'get_ssc_flexvol_names', + mock.Mock(return_value=fake_utils.SSC.keys())) + self.library.replication_enabled = replication_enabled + self.library.failed_over = failed_over + super_handle_housekeeping_tasks = self.mock_object( + block_base.NetAppBlockStorageLibrary, '_handle_housekeeping_tasks') + + self.library._handle_housekeeping_tasks() + + super_handle_housekeeping_tasks.assert_called_once_with() + (self.zapi_client.remove_unused_qos_policy_groups. + assert_called_once_with()) + if replication_enabled and not failed_over: + ensure_mirrors.assert_called_once_with( + self.library.configuration, self.library.backend_name, + fake_utils.SSC.keys()) + else: + self.assertFalse(ensure_mirrors.called) + def test_find_mapped_lun_igroup(self): igroups = [fake.IGROUP1] self.zapi_client.get_igroup_by_initiators.return_value = igroups @@ -590,25 +641,67 @@ class NetAppBlockStorageCmodeLibraryTestCase(test.TestCase): self.zapi_client.move_lun.assert_called_once_with( '/vol/FAKE_CMODE_VOL1/name', '/vol/FAKE_CMODE_VOL1/volume') - def test_start_periodic_tasks(self): + @ddt.data({'secondary_id': 'dev0', 'configured_targets': ['dev1']}, + {'secondary_id': 'dev3', 'configured_targets': ['dev1', 'dev2']}, + {'secondary_id': 'dev1', 'configured_targets': []}, + {'secondary_id': None, 'configured_targets': []}) + @ddt.unpack + def test_failover_host_invalid_replication_target(self, secondary_id, + configured_targets): + """This tests executes a method in the DataMotionMixin.""" + self.library.backend_name = 'dev0' + self.mock_object(data_motion.DataMotionMixin, + 'get_replication_backend_names', + mock.Mock(return_value=configured_targets)) + complete_failover_call = self.mock_object( + data_motion.DataMotionMixin, '_complete_failover') - mock_update_ssc = self.mock_object( - self.library, '_update_ssc') - mock_remove_unused_qos_policy_groups = self.mock_object( - self.zapi_client, 'remove_unused_qos_policy_groups') + self.assertRaises(exception.InvalidReplicationTarget, + self.library.failover_host, 'fake_context', [], + secondary_id=secondary_id) + self.assertFalse(complete_failover_call.called) - update_ssc_periodic_task = mock.Mock() - harvest_qos_periodic_task = mock.Mock() - side_effect = [update_ssc_periodic_task, harvest_qos_periodic_task] - mock_loopingcall = self.mock_object( - loopingcall, 'FixedIntervalLoopingCall', - mock.Mock(side_effect=side_effect)) + def test_failover_host_unable_to_failover(self): + """This tests executes a method in the DataMotionMixin.""" + self.library.backend_name = 'dev0' + self.mock_object( + data_motion.DataMotionMixin, '_complete_failover', + mock.Mock(side_effect=exception.NetAppDriverException)) + self.mock_object(data_motion.DataMotionMixin, + 'get_replication_backend_names', + mock.Mock(return_value=['dev1', 'dev2'])) + self.mock_object(self.library.ssc_library, 'get_ssc_flexvol_names', + mock.Mock(return_value=fake_utils.SSC.keys())) + self.mock_object(self.library, '_update_zapi_client') - self.library._start_periodic_tasks() + self.assertRaises(exception.UnableToFailOver, + self.library.failover_host, 'fake_context', [], + secondary_id='dev1') + data_motion.DataMotionMixin._complete_failover.assert_called_once_with( + 'dev0', ['dev1', 'dev2'], fake_utils.SSC.keys(), [], + failover_target='dev1') + self.assertFalse(self.library._update_zapi_client.called) - mock_loopingcall.assert_has_calls([ - mock.call(mock_update_ssc), - mock.call(mock_remove_unused_qos_policy_groups)]) - self.assertTrue(update_ssc_periodic_task.start.called) - self.assertTrue(harvest_qos_periodic_task.start.called) - mock_update_ssc.assert_called_once_with() + def test_failover_host(self): + """This tests executes a method in the DataMotionMixin.""" + self.library.backend_name = 'dev0' + self.mock_object(data_motion.DataMotionMixin, '_complete_failover', + mock.Mock(return_value=('dev1', []))) + self.mock_object(data_motion.DataMotionMixin, + 'get_replication_backend_names', + mock.Mock(return_value=['dev1', 'dev2'])) + self.mock_object(self.library.ssc_library, 'get_ssc_flexvol_names', + mock.Mock(return_value=fake_utils.SSC.keys())) + self.mock_object(self.library, '_update_zapi_client') + + actual_active, vol_updates = self.library.failover_host( + 'fake_context', [], secondary_id='dev1') + + data_motion.DataMotionMixin._complete_failover.assert_called_once_with( + 'dev0', ['dev1', 'dev2'], fake_utils.SSC.keys(), [], + failover_target='dev1') + self.library._update_zapi_client.assert_called_once_with('dev1') + self.assertTrue(self.library.failed_over) + self.assertEqual('dev1', self.library.failed_over_backend_name) + self.assertEqual('dev1', actual_active) + self.assertEqual([], vol_updates) diff --git a/cinder/tests/unit/volume/drivers/netapp/dataontap/test_nfs_7mode.py b/cinder/tests/unit/volume/drivers/netapp/dataontap/test_nfs_7mode.py index 8f666c0bd7e..82f62b5f081 100644 --- a/cinder/tests/unit/volume/drivers/netapp/dataontap/test_nfs_7mode.py +++ b/cinder/tests/unit/volume/drivers/netapp/dataontap/test_nfs_7mode.py @@ -33,7 +33,10 @@ class NetApp7modeNfsDriverTestCase(test.TestCase): def setUp(self): super(NetApp7modeNfsDriverTestCase, self).setUp() - kwargs = {'configuration': self.get_config_7mode()} + kwargs = { + 'configuration': self.get_config_7mode(), + 'host': 'openstack@7modenfs', + } with mock.patch.object(utils, 'get_root_helper', return_value=mock.Mock()): diff --git a/cinder/tests/unit/volume/drivers/netapp/dataontap/test_nfs_base.py b/cinder/tests/unit/volume/drivers/netapp/dataontap/test_nfs_base.py index 10cb64dd63e..9e68320da92 100644 --- a/cinder/tests/unit/volume/drivers/netapp/dataontap/test_nfs_base.py +++ b/cinder/tests/unit/volume/drivers/netapp/dataontap/test_nfs_base.py @@ -25,6 +25,7 @@ import ddt import mock from os_brick.remotefs import remotefs as remotefs_brick from oslo_concurrency import processutils +from oslo_service import loopingcall from oslo_utils import units import shutil @@ -56,7 +57,10 @@ class NetAppNfsDriverTestCase(test.TestCase): self.fake_mount_point = fake.MOUNT_POINT self.ctxt = context.RequestContext('fake', 'fake', auth_token=True) - kwargs = {'configuration': configuration} + kwargs = { + 'configuration': configuration, + 'host': 'openstack@netappnfs', + } with mock.patch.object(utils, 'get_root_helper', return_value=mock.Mock()): @@ -92,6 +96,33 @@ class NetAppNfsDriverTestCase(test.TestCase): self.assertEqual(expected_reserved_percentage, round(result['reserved_percentage'])) + def test_check_for_setup_error(self): + super_check_for_setup_error = self.mock_object( + nfs.NfsDriver, 'check_for_setup_error') + mock_start_periodic_tasks = self.mock_object( + self.driver, '_start_periodic_tasks') + + self.driver.check_for_setup_error() + + super_check_for_setup_error.assert_called_once_with() + mock_start_periodic_tasks.assert_called_once_with() + + def test_start_periodic_tasks(self): + + mock_handle_housekeeping_tasks = self.mock_object( + self.driver, '_handle_housekeeping_tasks') + + housekeeping_periodic_task = mock.Mock() + mock_loopingcall = self.mock_object( + loopingcall, 'FixedIntervalLoopingCall', + mock.Mock(return_value=housekeeping_periodic_task)) + + self.driver._start_periodic_tasks() + + mock_loopingcall.assert_called_once_with( + mock_handle_housekeeping_tasks) + self.assertTrue(housekeeping_periodic_task.start.called) + def test_get_capacity_info_ipv4_share(self): expected = fake.CAPACITY_VALUES self.driver.zapi_client = mock.Mock() diff --git a/cinder/tests/unit/volume/drivers/netapp/dataontap/test_nfs_cmode.py b/cinder/tests/unit/volume/drivers/netapp/dataontap/test_nfs_cmode.py index 63c97936d2d..2cdb6c0f233 100644 --- a/cinder/tests/unit/volume/drivers/netapp/dataontap/test_nfs_cmode.py +++ b/cinder/tests/unit/volume/drivers/netapp/dataontap/test_nfs_cmode.py @@ -35,6 +35,8 @@ from cinder.volume.drivers.netapp.dataontap.client import client_cmode from cinder.volume.drivers.netapp.dataontap import nfs_base from cinder.volume.drivers.netapp.dataontap import nfs_cmode from cinder.volume.drivers.netapp.dataontap.performance import perf_cmode +from cinder.volume.drivers.netapp.dataontap.utils import data_motion +from cinder.volume.drivers.netapp.dataontap.utils import utils as config_utils from cinder.volume.drivers.netapp import utils as na_utils from cinder.volume.drivers import nfs from cinder.volume import utils as volume_utils @@ -45,7 +47,10 @@ class NetAppCmodeNfsDriverTestCase(test.TestCase): def setUp(self): super(NetAppCmodeNfsDriverTestCase, self).setUp() - kwargs = {'configuration': self.get_config_cmode()} + kwargs = { + 'configuration': self.get_config_cmode(), + 'host': 'openstack@nfscmode', + } with mock.patch.object(utils, 'get_root_helper', return_value=mock.Mock()): @@ -72,11 +77,42 @@ class NetAppCmodeNfsDriverTestCase(test.TestCase): config.netapp_copyoffload_tool_path = 'copyoffload_tool_path' return config + @ddt.data({'active_backend_id': None, 'targets': ['dev1', 'dev2']}, + {'active_backend_id': None, 'targets': []}, + {'active_backend_id': 'dev1', 'targets': []}, + {'active_backend_id': 'dev1', 'targets': ['dev1', 'dev2']}) + @ddt.unpack + def test_init_driver_for_replication(self, active_backend_id, + targets): + kwargs = { + 'configuration': self.get_config_cmode(), + 'host': 'openstack@nfscmode', + 'active_backend_id': active_backend_id, + } + self.mock_object(data_motion.DataMotionMixin, + 'get_replication_backend_names', + mock.Mock(return_value=targets)) + with mock.patch.object(utils, 'get_root_helper', + return_value=mock.Mock()): + with mock.patch.object(remotefs_brick, 'RemoteFsClient', + return_value=mock.Mock()): + nfs_driver = nfs_cmode.NetAppCmodeNfsDriver(**kwargs) + + self.assertEqual(active_backend_id, + nfs_driver.failed_over_backend_name) + self.assertEqual(active_backend_id is not None, + nfs_driver.failed_over) + self.assertEqual(len(targets) > 0, + nfs_driver.replication_enabled) + @mock.patch.object(perf_cmode, 'PerformanceCmodeLibrary', mock.Mock()) @mock.patch.object(client_cmode, 'Client', mock.Mock()) @mock.patch.object(nfs.NfsDriver, 'do_setup') @mock.patch.object(na_utils, 'check_flags') def test_do_setup(self, mock_check_flags, mock_super_do_setup): + self.mock_object( + config_utils, 'get_backend_configuration', + mock.Mock(return_value=self.get_config_cmode())) self.driver.do_setup(mock.Mock()) self.assertTrue(mock_check_flags.called) @@ -94,6 +130,7 @@ class NetAppCmodeNfsDriverTestCase(test.TestCase): 'driver_version': self.driver.VERSION, 'pools': {}, 'sparse_copy_volume': True, + 'replication_enabled': False, 'storage_protocol': 'nfs', 'vendor_name': 'NetApp', 'volume_backend_name': 'NetApp_NFS_Cluster_direct', @@ -342,8 +379,6 @@ class NetAppCmodeNfsDriverTestCase(test.TestCase): def test_check_for_setup_error(self): super_check_for_setup_error = self.mock_object( nfs_base.NetAppNfsDriver, 'check_for_setup_error') - mock_start_periodic_tasks = self.mock_object( - self.driver, '_start_periodic_tasks') mock_check_api_permissions = self.mock_object( self.driver.ssc_library, 'check_api_permissions') @@ -351,7 +386,51 @@ class NetAppCmodeNfsDriverTestCase(test.TestCase): self.assertEqual(1, super_check_for_setup_error.call_count) mock_check_api_permissions.assert_called_once_with() - self.assertEqual(1, mock_start_periodic_tasks.call_count) + + def test_start_periodic_tasks(self): + + mock_update_ssc = self.mock_object( + self.driver, '_update_ssc') + super_start_periodic_tasks = self.mock_object( + nfs_base.NetAppNfsDriver, '_start_periodic_tasks') + + update_ssc_periodic_task = mock.Mock() + mock_loopingcall = self.mock_object( + loopingcall, 'FixedIntervalLoopingCall', + mock.Mock(return_value=update_ssc_periodic_task)) + + self.driver._start_periodic_tasks() + + mock_loopingcall.assert_called_once_with(mock_update_ssc) + self.assertTrue(update_ssc_periodic_task.start.called) + mock_update_ssc.assert_called_once_with() + super_start_periodic_tasks.assert_called_once_with() + + @ddt.data({'replication_enabled': True, 'failed_over': False}, + {'replication_enabled': True, 'failed_over': True}, + {'replication_enabled': False, 'failed_over': False}) + @ddt.unpack + def test_handle_housekeeping_tasks(self, replication_enabled, failed_over): + ensure_mirrors = self.mock_object(data_motion.DataMotionMixin, + 'ensure_snapmirrors') + self.mock_object(self.driver.ssc_library, 'get_ssc_flexvol_names', + mock.Mock(return_value=fake_ssc.SSC.keys())) + self.driver.replication_enabled = replication_enabled + self.driver.failed_over = failed_over + super_handle_housekeeping_tasks = self.mock_object( + nfs_base.NetAppNfsDriver, '_handle_housekeeping_tasks') + + self.driver._handle_housekeeping_tasks() + + super_handle_housekeeping_tasks.assert_called_once_with() + (self.driver.zapi_client.remove_unused_qos_policy_groups. + assert_called_once_with()) + if replication_enabled and not failed_over: + ensure_mirrors.assert_called_once_with( + self.driver.configuration, self.driver.backend_name, + fake_ssc.SSC.keys()) + else: + self.assertFalse(ensure_mirrors.called) def test_delete_volume(self): fake_provider_location = 'fake_provider_location' @@ -836,29 +915,6 @@ class NetAppCmodeNfsDriverTestCase(test.TestCase): mock_get_info.assert_has_calls([mock.call(fake.NFS_VOLUME)]) super_unmanage.assert_has_calls([mock.call(fake.NFS_VOLUME)]) - def test_start_periodic_tasks(self): - - mock_update_ssc = self.mock_object(self.driver, '_update_ssc') - mock_remove_unused_qos_policy_groups = self.mock_object( - self.driver.zapi_client, - 'remove_unused_qos_policy_groups') - - update_ssc_periodic_task = mock.Mock() - harvest_qos_periodic_task = mock.Mock() - side_effect = [update_ssc_periodic_task, harvest_qos_periodic_task] - mock_loopingcall = self.mock_object( - loopingcall, 'FixedIntervalLoopingCall', - mock.Mock(side_effect=side_effect)) - - self.driver._start_periodic_tasks() - - mock_loopingcall.assert_has_calls([ - mock.call(mock_update_ssc), - mock.call(mock_remove_unused_qos_policy_groups)]) - self.assertTrue(update_ssc_periodic_task.start.called) - self.assertTrue(harvest_qos_periodic_task.start.called) - mock_update_ssc.assert_called_once_with() - @ddt.data({'has_space': True, 'type_match': True, 'expected': True}, {'has_space': True, 'type_match': False, 'expected': False}, {'has_space': False, 'type_match': True, 'expected': False}, @@ -1220,3 +1276,68 @@ class NetAppCmodeNfsDriverTestCase(test.TestCase): self.driver._copy_from_remote_cache.assert_called_once_with( fake.VOLUME, fake.IMAGE_FILE_ID, cache_result[0]) self.assertFalse(self.driver._post_clone_image.called) + + @ddt.data({'secondary_id': 'dev0', 'configured_targets': ['dev1']}, + {'secondary_id': 'dev3', 'configured_targets': ['dev1', 'dev2']}, + {'secondary_id': 'dev1', 'configured_targets': []}, + {'secondary_id': None, 'configured_targets': []}) + @ddt.unpack + def test_failover_host_invalid_replication_target(self, secondary_id, + configured_targets): + """This tests executes a method in the DataMotionMixin.""" + self.driver.backend_name = 'dev0' + self.mock_object(data_motion.DataMotionMixin, + 'get_replication_backend_names', + mock.Mock(return_value=configured_targets)) + complete_failover_call = self.mock_object( + data_motion.DataMotionMixin, '_complete_failover') + + self.assertRaises(exception.InvalidReplicationTarget, + self.driver.failover_host, 'fake_context', [], + secondary_id=secondary_id) + self.assertFalse(complete_failover_call.called) + + def test_failover_host_unable_to_failover(self): + """This tests executes a method in the DataMotionMixin.""" + self.driver.backend_name = 'dev0' + self.mock_object( + data_motion.DataMotionMixin, '_complete_failover', + mock.Mock(side_effect=exception.NetAppDriverException)) + self.mock_object(data_motion.DataMotionMixin, + 'get_replication_backend_names', + mock.Mock(return_value=['dev1', 'dev2'])) + self.mock_object(self.driver.ssc_library, 'get_ssc_flexvol_names', + mock.Mock(return_value=fake_ssc.SSC.keys())) + self.mock_object(self.driver, '_update_zapi_client') + + self.assertRaises(exception.UnableToFailOver, + self.driver.failover_host, 'fake_context', [], + secondary_id='dev1') + data_motion.DataMotionMixin._complete_failover.assert_called_once_with( + 'dev0', ['dev1', 'dev2'], fake_ssc.SSC.keys(), [], + failover_target='dev1') + self.assertFalse(self.driver._update_zapi_client.called) + + def test_failover_host(self): + """This tests executes a method in the DataMotionMixin.""" + self.driver.backend_name = 'dev0' + self.mock_object(data_motion.DataMotionMixin, '_complete_failover', + mock.Mock(return_value=('dev1', []))) + self.mock_object(data_motion.DataMotionMixin, + 'get_replication_backend_names', + mock.Mock(return_value=['dev1', 'dev2'])) + self.mock_object(self.driver.ssc_library, 'get_ssc_flexvol_names', + mock.Mock(return_value=fake_ssc.SSC.keys())) + self.mock_object(self.driver, '_update_zapi_client') + + actual_active, vol_updates = self.driver.failover_host( + 'fake_context', [], secondary_id='dev1') + + data_motion.DataMotionMixin._complete_failover.assert_called_once_with( + 'dev0', ['dev1', 'dev2'], fake_ssc.SSC.keys(), [], + failover_target='dev1') + self.driver._update_zapi_client.assert_called_once_with('dev1') + self.assertTrue(self.driver.failed_over) + self.assertEqual('dev1', self.driver.failed_over_backend_name) + self.assertEqual('dev1', actual_active) + self.assertEqual([], vol_updates) diff --git a/cinder/tests/unit/volume/drivers/netapp/dataontap/utils/fakes.py b/cinder/tests/unit/volume/drivers/netapp/dataontap/utils/fakes.py index 5d2abceaafe..e104f9098ed 100644 --- a/cinder/tests/unit/volume/drivers/netapp/dataontap/utils/fakes.py +++ b/cinder/tests/unit/volume/drivers/netapp/dataontap/utils/fakes.py @@ -13,6 +13,10 @@ # License for the specific language governing permissions and limitations # under the License. +from cinder.volume import configuration +from cinder.volume import driver +from cinder.volume.drivers.netapp import options as na_opts + SSC_VSERVER = 'fake_vserver' SSC_VOLUMES = ('volume1', 'volume2') SSC_VOLUME_MAP = { @@ -101,3 +105,31 @@ SSC_AGGREGATE_INFO = { 'netapp_hybrid_aggregate': True, }, } + +PROVISIONING_OPTS = { + 'aggregate': 'fake_aggregate', + 'thin_provisioned': True, + 'snapshot_policy': None, + 'language': 'en_US', + 'dedupe_enabled': False, + 'compression_enabled': False, + 'snapshot_reserve': '12', + 'volume_type': 'rw', + 'size': 20, +} + + +def get_fake_cmode_config(backend_name): + + config = configuration.Configuration(driver.volume_opts, + config_group=backend_name) + config.append_config_values(na_opts.netapp_proxy_opts) + config.append_config_values(na_opts.netapp_connection_opts) + config.append_config_values(na_opts.netapp_transport_opts) + config.append_config_values(na_opts.netapp_basicauth_opts) + config.append_config_values(na_opts.netapp_provisioning_opts) + config.append_config_values(na_opts.netapp_cluster_opts) + config.append_config_values(na_opts.netapp_san_opts) + config.append_config_values(na_opts.netapp_replication_opts) + + return config diff --git a/cinder/tests/unit/volume/drivers/netapp/dataontap/utils/test_capabilities.py b/cinder/tests/unit/volume/drivers/netapp/dataontap/utils/test_capabilities.py index fbb82a2ac9b..d8df5833af2 100644 --- a/cinder/tests/unit/volume/drivers/netapp/dataontap/utils/test_capabilities.py +++ b/cinder/tests/unit/volume/drivers/netapp/dataontap/utils/test_capabilities.py @@ -153,6 +153,16 @@ class CapabilitiesLibraryTestCase(test.TestCase): mock_get_ssc_aggregate_info.assert_has_calls([ mock.call('aggr1'), mock.call('aggr2')]) + def test__update_for_failover(self): + self.mock_object(self.ssc_library, 'update_ssc') + flexvol_map = {'volume1': fake.SSC_VOLUME_MAP['volume1']} + mock_client = mock.Mock(name='FAKE_ZAPI_CLIENT') + + self.ssc_library._update_for_failover(mock_client, flexvol_map) + + self.assertEqual(mock_client, self.ssc_library.zapi_client) + self.ssc_library.update_ssc.assert_called_once_with(flexvol_map) + @ddt.data({'lun_space_guarantee': True}, {'lun_space_guarantee': False}) @ddt.unpack diff --git a/cinder/tests/unit/volume/drivers/netapp/dataontap/utils/test_data_motion.py b/cinder/tests/unit/volume/drivers/netapp/dataontap/utils/test_data_motion.py new file mode 100644 index 00000000000..6906d9f33d5 --- /dev/null +++ b/cinder/tests/unit/volume/drivers/netapp/dataontap/utils/test_data_motion.py @@ -0,0 +1,749 @@ +# 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. + +import time + +import copy +import ddt +import mock +from oslo_config import cfg + +from cinder import exception +from cinder import test +from cinder.tests.unit.volume.drivers.netapp.dataontap.utils import fakes +from cinder.volume import configuration +from cinder.volume import driver +from cinder.volume.drivers.netapp.dataontap.client import api as netapp_api +from cinder.volume.drivers.netapp.dataontap.client import client_cmode +from cinder.volume.drivers.netapp.dataontap.utils import data_motion +from cinder.volume.drivers.netapp.dataontap.utils import utils +from cinder.volume.drivers.netapp import options as na_opts + + +CONF = cfg.CONF + + +@ddt.ddt +class NetAppCDOTDataMotionMixinTestCase(test.TestCase): + + def setUp(self): + super(NetAppCDOTDataMotionMixinTestCase, self).setUp() + self.dm_mixin = data_motion.DataMotionMixin() + self.src_backend = 'backend1' + self.dest_backend = 'backend2' + self.src_vserver = 'source_vserver' + self.dest_vserver = 'dest_vserver' + self._setup_mock_config() + self.mock_cmode_client = self.mock_object(client_cmode, 'Client') + self.src_flexvol_name = 'volume_c02d497a_236c_4852_812a_0d39373e312a' + self.dest_flexvol_name = self.src_flexvol_name + self.mock_src_client = mock.Mock() + self.mock_dest_client = mock.Mock() + self.config = fakes.get_fake_cmode_config(self.src_backend) + self.mock_object(utils, 'get_backend_configuration', + mock.Mock(side_effect=[self.mock_dest_config, + self.mock_src_config])) + self.mock_object(utils, 'get_client_for_backend', + mock.Mock(side_effect=[self.mock_dest_client, + self.mock_src_client])) + + def _setup_mock_config(self): + self.mock_src_config = configuration.Configuration( + driver.volume_opts, config_group=self.src_backend) + self.mock_dest_config = configuration.Configuration( + driver.volume_opts, config_group=self.dest_backend) + + for config in (self.mock_src_config, self.mock_dest_config): + config.append_config_values(na_opts.netapp_proxy_opts) + config.append_config_values(na_opts.netapp_connection_opts) + config.append_config_values(na_opts.netapp_transport_opts) + config.append_config_values(na_opts.netapp_basicauth_opts) + config.append_config_values(na_opts.netapp_provisioning_opts) + config.append_config_values(na_opts.netapp_cluster_opts) + config.append_config_values(na_opts.netapp_san_opts) + config.append_config_values(na_opts.netapp_replication_opts) + config.netapp_snapmirror_quiesce_timeout = 10 + + CONF.set_override('netapp_vserver', self.src_vserver, + group=self.src_backend, enforce_type=True) + CONF.set_override('netapp_vserver', self.dest_vserver, + group=self.dest_backend, enforce_type=True) + + @ddt.data(None, [], [{'some_key': 'some_value'}]) + def test_get_replication_backend_names_none(self, replication_device): + CONF.set_override('replication_device', replication_device, + group=self.src_backend, enforce_type=True) + + devices = self.dm_mixin.get_replication_backend_names(self.config) + + self.assertEqual(0, len(devices)) + + @ddt.data([{'backend_id': 'xyzzy'}, {'backend_id': 'spoon!'}], + [{'backend_id': 'foobar'}]) + def test_get_replication_backend_names_valid(self, replication_device): + CONF.set_override('replication_device', replication_device, + group=self.src_backend, enforce_type=True) + + devices = self.dm_mixin.get_replication_backend_names(self.config) + + self.assertEqual(len(replication_device), len(devices)) + + def test_get_snapmirrors(self): + self.mock_object(self.mock_dest_client, 'get_snapmirrors') + + self.dm_mixin.get_snapmirrors(self.src_backend, + self.dest_backend, + self.src_flexvol_name, + self.dest_flexvol_name) + + self.mock_dest_client.get_snapmirrors.assert_called_with( + self.src_vserver, self.src_flexvol_name, + self.dest_vserver, self.dest_flexvol_name, + desired_attributes=['relationship-status', + 'mirror-state', + 'source-vserver', + 'source-volume', + 'destination-vserver', + 'destination-volume', + 'last-transfer-end-timestamp', + 'lag-time']) + self.assertEqual(1, self.mock_dest_client.get_snapmirrors.call_count) + + @ddt.data([], ['backend1'], ['backend1', 'backend2']) + def test_get_replication_backend_stats(self, replication_backend_names): + self.mock_object(self.dm_mixin, 'get_replication_backend_names', + mock.Mock(return_value=replication_backend_names)) + enabled_stats = { + 'replication_count': len(replication_backend_names), + 'replication_targets': replication_backend_names, + 'replication_type': 'async', + } + expected_stats = { + 'replication_enabled': len(replication_backend_names) > 0, + } + if len(replication_backend_names) > 0: + expected_stats.update(enabled_stats) + + actual_stats = self.dm_mixin.get_replication_backend_stats(self.config) + + self.assertDictMatch(expected_stats, actual_stats) + + @ddt.data(None, [], + [{'backend_id': 'replication_backend_2', 'aggr2': 'aggr20'}]) + def test_get_replication_aggregate_map_none(self, replication_aggr_map): + + self.mock_object(utils, 'get_backend_configuration', + mock.Mock(return_value=self.config)) + CONF.set_override('netapp_replication_aggregate_map', + replication_aggr_map, + group=self.src_backend, enforce_type=True) + + aggr_map = self.dm_mixin._get_replication_aggregate_map( + self.src_backend, 'replication_backend_1') + + self.assertEqual(0, len(aggr_map)) + + @ddt.data([{'backend_id': 'replication_backend_1', 'aggr1': 'aggr10'}], + [{'backend_id': 'replication_backend_1', 'aggr1': 'aggr10'}, + {'backend_id': 'replication_backend_2', 'aggr2': 'aggr20'}]) + def test_get_replication_aggregate_map_valid(self, replication_aggr_map): + self.mock_object(utils, 'get_backend_configuration', + mock.Mock(return_value=self.config)) + CONF.set_override('netapp_replication_aggregate_map', + replication_aggr_map, group=self.src_backend, + enforce_type=True) + + aggr_map = self.dm_mixin._get_replication_aggregate_map( + self.src_backend, 'replication_backend_1') + + self.assertDictMatch({'aggr1': 'aggr10'}, aggr_map) + + @ddt.data(True, False) + def test_create_snapmirror_dest_flexvol_exists(self, dest_exists): + mock_dest_client = mock.Mock() + self.mock_object(mock_dest_client, 'flexvol_exists', + mock.Mock(return_value=dest_exists)) + self.mock_object(mock_dest_client, 'get_snapmirrors', + mock.Mock(return_value=None)) + create_destination_flexvol = self.mock_object( + self.dm_mixin, 'create_destination_flexvol') + self.mock_object(utils, 'get_client_for_backend', + mock.Mock(return_value=mock_dest_client)) + + self.dm_mixin.create_snapmirror(self.src_backend, + self.dest_backend, + self.src_flexvol_name, + self.dest_flexvol_name) + + if not dest_exists: + create_destination_flexvol.assert_called_once_with( + self.src_backend, self.dest_backend, self.src_flexvol_name, + self.dest_flexvol_name) + else: + self.assertFalse(create_destination_flexvol.called) + mock_dest_client.create_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name, schedule='hourly') + mock_dest_client.initialize_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name) + + @ddt.data('uninitialized', 'broken-off', 'snapmirrored') + def test_create_snapmirror_snapmirror_exists_state(self, mirror_state): + mock_dest_client = mock.Mock() + existing_snapmirrors = [{'mirror-state': mirror_state}] + self.mock_object(self.dm_mixin, 'create_destination_flexvol') + self.mock_object(utils, 'get_client_for_backend', + mock.Mock(return_value=mock_dest_client)) + self.mock_object(mock_dest_client, 'flexvol_exists', + mock.Mock(return_value=True)) + self.mock_object(mock_dest_client, 'get_snapmirrors', + mock.Mock(return_value=existing_snapmirrors)) + + self.dm_mixin.create_snapmirror(self.src_backend, + self.dest_backend, + self.src_flexvol_name, + self.dest_flexvol_name) + + self.assertFalse(mock_dest_client.create_snapmirror.called) + self.assertFalse(mock_dest_client.initialize_snapmirror.called) + self.assertFalse(self.dm_mixin.create_destination_flexvol.called) + if mirror_state == 'snapmirrored': + self.assertFalse(mock_dest_client.resume_snapmirror.called) + self.assertFalse(mock_dest_client.resync_snapmirror.called) + else: + mock_dest_client.resume_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, + self.dest_vserver, self.dest_flexvol_name) + mock_dest_client.resume_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, + self.dest_vserver, self.dest_flexvol_name) + + @ddt.data('resume_snapmirror', 'resync_snapmirror') + def test_create_snapmirror_snapmirror_exists_repair_exception(self, + failed_call): + mock_dest_client = mock.Mock() + mock_exception_log = self.mock_object(data_motion.LOG, 'exception') + existing_snapmirrors = [{'mirror-state': 'broken-off'}] + self.mock_object(self.dm_mixin, 'create_destination_flexvol') + self.mock_object(utils, 'get_client_for_backend', + mock.Mock(return_value=mock_dest_client)) + self.mock_object(mock_dest_client, 'flexvol_exists', + mock.Mock(return_value=True)) + self.mock_object(mock_dest_client, 'get_snapmirrors', + mock.Mock(return_value=existing_snapmirrors)) + self.mock_object(mock_dest_client, failed_call, + mock.Mock(side_effect=netapp_api.NaApiError)) + + self.dm_mixin.create_snapmirror(self.src_backend, + self.dest_backend, + self.src_flexvol_name, + self.dest_flexvol_name) + + self.assertFalse(mock_dest_client.create_snapmirror.called) + self.assertFalse(mock_dest_client.initialize_snapmirror.called) + self.assertFalse(self.dm_mixin.create_destination_flexvol.called) + mock_dest_client.resume_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, + self.dest_vserver, self.dest_flexvol_name) + mock_dest_client.resume_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, + self.dest_vserver, self.dest_flexvol_name) + self.assertEqual(1, mock_exception_log.call_count) + + def test_delete_snapmirror(self): + mock_src_client = mock.Mock() + mock_dest_client = mock.Mock() + self.mock_object(utils, 'get_client_for_backend', + mock.Mock(side_effect=[mock_dest_client, + mock_src_client])) + + self.dm_mixin.delete_snapmirror(self.src_backend, + self.dest_backend, + self.src_flexvol_name, + self.dest_flexvol_name) + + mock_dest_client.abort_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name, clear_checkpoint=False) + mock_dest_client.delete_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name) + mock_src_client.release_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name) + + def test_delete_snapmirror_does_not_exist(self): + """Ensure delete succeeds when the snapmirror does not exist.""" + mock_src_client = mock.Mock() + mock_dest_client = mock.Mock() + mock_dest_client.abort_snapmirror.side_effect = netapp_api.NaApiError( + code=netapp_api.EAPIERROR) + self.mock_object(utils, 'get_client_for_backend', + mock.Mock(side_effect=[mock_dest_client, + mock_src_client])) + + self.dm_mixin.delete_snapmirror(self.src_backend, + self.dest_backend, + self.src_flexvol_name, + self.dest_flexvol_name) + + mock_dest_client.abort_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name, clear_checkpoint=False) + mock_dest_client.delete_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name) + mock_src_client.release_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name) + + def test_delete_snapmirror_error_deleting(self): + """Ensure delete succeeds when the snapmirror does not exist.""" + mock_src_client = mock.Mock() + mock_dest_client = mock.Mock() + mock_dest_client.delete_snapmirror.side_effect = netapp_api.NaApiError( + code=netapp_api.ESOURCE_IS_DIFFERENT + ) + self.mock_object(utils, 'get_client_for_backend', + mock.Mock(side_effect=[mock_dest_client, + mock_src_client])) + + self.dm_mixin.delete_snapmirror(self.src_backend, + self.dest_backend, + self.src_flexvol_name, + self.dest_flexvol_name) + + mock_dest_client.abort_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name, clear_checkpoint=False) + mock_dest_client.delete_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name) + mock_src_client.release_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name) + + def test_delete_snapmirror_error_releasing(self): + """Ensure delete succeeds when the snapmirror does not exist.""" + mock_src_client = mock.Mock() + mock_dest_client = mock.Mock() + mock_src_client.release_snapmirror.side_effect = ( + netapp_api.NaApiError(code=netapp_api.EOBJECTNOTFOUND)) + self.mock_object(utils, 'get_client_for_backend', + mock.Mock(side_effect=[mock_dest_client, + mock_src_client])) + + self.dm_mixin.delete_snapmirror(self.src_backend, + self.dest_backend, + self.src_flexvol_name, + self.dest_flexvol_name) + + mock_dest_client.abort_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name, clear_checkpoint=False) + mock_dest_client.delete_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name) + mock_src_client.release_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name) + + def test_delete_snapmirror_without_release(self): + mock_src_client = mock.Mock() + mock_dest_client = mock.Mock() + self.mock_object(utils, 'get_client_for_backend', + mock.Mock(side_effect=[mock_dest_client, + mock_src_client])) + + self.dm_mixin.delete_snapmirror(self.src_backend, + self.dest_backend, + self.src_flexvol_name, + self.dest_flexvol_name, + release=False) + + mock_dest_client.abort_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name, clear_checkpoint=False) + mock_dest_client.delete_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name) + self.assertFalse(mock_src_client.release_snapmirror.called) + + def test_delete_snapmirror_source_unreachable(self): + mock_src_client = mock.Mock() + mock_dest_client = mock.Mock() + self.mock_object(utils, 'get_client_for_backend', + mock.Mock(side_effect=[mock_dest_client, + Exception])) + + self.dm_mixin.delete_snapmirror(self.src_backend, + self.dest_backend, + self.src_flexvol_name, + self.dest_flexvol_name) + + mock_dest_client.abort_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name, clear_checkpoint=False) + mock_dest_client.delete_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name) + + self.assertFalse(mock_src_client.release_snapmirror.called) + + def test_quiesce_then_abort_timeout(self): + self.mock_object(time, 'sleep') + mock_get_snapmirrors = mock.Mock( + return_value=[{'relationship-status': 'transferring'}]) + self.mock_object(self.mock_dest_client, 'get_snapmirrors', + mock_get_snapmirrors) + + self.dm_mixin.quiesce_then_abort(self.src_backend, + self.dest_backend, + self.src_flexvol_name, + self.dest_flexvol_name) + + self.mock_dest_client.get_snapmirrors.assert_called_with( + self.src_vserver, self.src_flexvol_name, + self.dest_vserver, self.dest_flexvol_name, + desired_attributes=['relationship-status', 'mirror-state']) + self.assertEqual(2, self.mock_dest_client.get_snapmirrors.call_count) + self.mock_dest_client.quiesce_snapmirror.assert_called_with( + self.src_vserver, self.src_flexvol_name, + self.dest_vserver, self.dest_flexvol_name) + self.mock_dest_client.abort_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name, clear_checkpoint=False) + + def test_update_snapmirror(self): + self.mock_object(self.mock_dest_client, 'get_snapmirrors') + + self.dm_mixin.update_snapmirror(self.src_backend, + self.dest_backend, + self.src_flexvol_name, + self.dest_flexvol_name) + + self.mock_dest_client.update_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, + self.dest_vserver, self.dest_flexvol_name) + + def test_quiesce_then_abort_wait_for_quiesced(self): + self.mock_object(time, 'sleep') + self.mock_object(self.mock_dest_client, 'get_snapmirrors', + mock.Mock(side_effect=[ + [{'relationship-status': 'transferring'}], + [{'relationship-status': 'quiesced'}]])) + + self.dm_mixin.quiesce_then_abort(self.src_backend, + self.dest_backend, + self.src_flexvol_name, + self.dest_flexvol_name) + + self.mock_dest_client.get_snapmirrors.assert_called_with( + self.src_vserver, self.src_flexvol_name, + self.dest_vserver, self.dest_flexvol_name, + desired_attributes=['relationship-status', 'mirror-state']) + self.assertEqual(2, self.mock_dest_client.get_snapmirrors.call_count) + self.mock_dest_client.quiesce_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, + self.dest_vserver, self.dest_flexvol_name) + + def test_break_snapmirror(self): + self.mock_object(self.dm_mixin, 'quiesce_then_abort') + + self.dm_mixin.break_snapmirror(self.src_backend, + self.dest_backend, + self.src_flexvol_name, + self.dest_flexvol_name) + + self.dm_mixin.quiesce_then_abort.assert_called_once_with( + self.src_backend, self.dest_backend, + self.src_flexvol_name, self.dest_flexvol_name) + self.mock_dest_client.break_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, + self.dest_vserver, self.dest_flexvol_name) + self.mock_dest_client.mount_flexvol.assert_called_once_with( + self.dest_flexvol_name) + + def test_break_snapmirror_wait_for_quiesced(self): + self.mock_object(self.dm_mixin, 'quiesce_then_abort') + + self.dm_mixin.break_snapmirror(self.src_backend, + self.dest_backend, + self.src_flexvol_name, + self.dest_flexvol_name) + + self.dm_mixin.quiesce_then_abort.assert_called_once_with( + self.src_backend, self.dest_backend, + self.src_flexvol_name, self.dest_flexvol_name,) + self.mock_dest_client.break_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, + self.dest_vserver, self.dest_flexvol_name) + self.mock_dest_client.mount_flexvol.assert_called_once_with( + self.dest_flexvol_name) + + def test_resync_snapmirror(self): + self.dm_mixin.resync_snapmirror(self.src_backend, + self.dest_backend, + self.src_flexvol_name, + self.dest_flexvol_name) + + self.mock_dest_client.resync_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, + self.dest_vserver, self.dest_flexvol_name) + + def test_resume_snapmirror(self): + self.dm_mixin.resume_snapmirror(self.src_backend, + self.dest_backend, + self.src_flexvol_name, + self.dest_flexvol_name) + + self.mock_dest_client.resume_snapmirror.assert_called_once_with( + self.src_vserver, self.src_flexvol_name, self.dest_vserver, + self.dest_flexvol_name) + + @ddt.data({'size': 1, 'aggr_map': {}}, + {'size': 1, 'aggr_map': {'aggr02': 'aggr20'}}, + {'size': None, 'aggr_map': {'aggr01': 'aggr10'}}) + @ddt.unpack + def test_create_destination_flexvol_exception(self, size, aggr_map): + self.mock_object( + self.mock_src_client, 'get_provisioning_options_from_flexvol', + mock.Mock(return_value={'size': size, 'aggregate': 'aggr01'})) + self.mock_object(self.dm_mixin, '_get_replication_aggregate_map', + mock.Mock(return_value=aggr_map)) + mock_client_call = self.mock_object( + self.mock_dest_client, 'create_flexvol') + + self.assertRaises(exception.NetAppDriverException, + self.dm_mixin.create_destination_flexvol, + self.src_backend, self.dest_backend, + self.src_flexvol_name, self.dest_flexvol_name) + if size: + self.dm_mixin._get_replication_aggregate_map.\ + assert_called_once_with(self.src_backend, self.dest_backend) + else: + self.assertFalse( + self.dm_mixin._get_replication_aggregate_map.called) + self.assertFalse(mock_client_call.called) + + def test_create_destination_flexvol(self): + aggr_map = { + fakes.PROVISIONING_OPTS['aggregate']: 'aggr01', + 'aggr20': 'aggr02', + } + provisioning_opts = copy.deepcopy(fakes.PROVISIONING_OPTS) + expected_prov_opts = copy.deepcopy(fakes.PROVISIONING_OPTS) + expected_prov_opts.pop('volume_type', None) + expected_prov_opts.pop('size', None) + expected_prov_opts.pop('aggregate', None) + mock_get_provisioning_opts_call = self.mock_object( + self.mock_src_client, 'get_provisioning_options_from_flexvol', + mock.Mock(return_value=provisioning_opts)) + self.mock_object(self.dm_mixin, '_get_replication_aggregate_map', + mock.Mock(return_value=aggr_map)) + mock_client_call = self.mock_object( + self.mock_dest_client, 'create_flexvol') + + retval = self.dm_mixin.create_destination_flexvol( + self.src_backend, self.dest_backend, + self.src_flexvol_name, self.dest_flexvol_name) + + self.assertIsNone(retval) + mock_get_provisioning_opts_call.assert_called_once_with( + self.src_flexvol_name) + self.dm_mixin._get_replication_aggregate_map.assert_called_once_with( + self.src_backend, self.dest_backend) + mock_client_call.assert_called_once_with( + self.dest_flexvol_name, 'aggr01', fakes.PROVISIONING_OPTS['size'], + volume_type='dp', **expected_prov_opts) + + def test_ensure_snapmirrors(self): + flexvols = ['nvol1', 'nvol2'] + replication_backends = ['fallback1', 'fallback2'] + self.mock_object(self.dm_mixin, 'get_replication_backend_names', + mock.Mock(return_value=replication_backends)) + self.mock_object(self.dm_mixin, 'create_snapmirror') + expected_calls = [ + mock.call(self.src_backend, replication_backends[0], + flexvols[0], flexvols[0]), + mock.call(self.src_backend, replication_backends[0], + flexvols[1], flexvols[1]), + mock.call(self.src_backend, replication_backends[1], + flexvols[0], flexvols[0]), + mock.call(self.src_backend, replication_backends[1], + flexvols[1], flexvols[1]), + ] + + retval = self.dm_mixin.ensure_snapmirrors(self.mock_src_config, + self.src_backend, + flexvols) + + self.assertIsNone(retval) + self.dm_mixin.get_replication_backend_names.assert_called_once_with( + self.mock_src_config) + self.dm_mixin.create_snapmirror.assert_has_calls(expected_calls) + + def test_break_snapmirrors(self): + flexvols = ['nvol1', 'nvol2'] + replication_backends = ['fallback1', 'fallback2'] + side_effects = [None, netapp_api.NaApiError, None, None] + self.mock_object(self.dm_mixin, 'get_replication_backend_names', + mock.Mock(return_value=replication_backends)) + self.mock_object(self.dm_mixin, 'break_snapmirror', + mock.Mock(side_effect=side_effects)) + mock_exc_log = self.mock_object(data_motion.LOG, 'exception') + expected_calls = [ + mock.call(self.src_backend, replication_backends[0], + flexvols[0], flexvols[0]), + mock.call(self.src_backend, replication_backends[0], + flexvols[1], flexvols[1]), + mock.call(self.src_backend, replication_backends[1], + flexvols[0], flexvols[0]), + mock.call(self.src_backend, replication_backends[1], + flexvols[1], flexvols[1]), + ] + + failed_to_break = self.dm_mixin.break_snapmirrors( + self.mock_src_config, self.src_backend, flexvols, 'fallback1') + + self.assertEqual(1, len(failed_to_break)) + self.assertEqual(1, mock_exc_log.call_count) + self.dm_mixin.get_replication_backend_names.assert_called_once_with( + self.mock_src_config) + self.dm_mixin.break_snapmirror.assert_has_calls(expected_calls) + + def test_update_snapmirrors(self): + flexvols = ['nvol1', 'nvol2'] + replication_backends = ['fallback1', 'fallback2'] + self.mock_object(self.dm_mixin, 'get_replication_backend_names', + mock.Mock(return_value=replication_backends)) + side_effects = [None, netapp_api.NaApiError, None, None] + self.mock_object(self.dm_mixin, 'update_snapmirror', + mock.Mock(side_effect=side_effects)) + expected_calls = [ + mock.call(self.src_backend, replication_backends[0], + flexvols[0], flexvols[0]), + mock.call(self.src_backend, replication_backends[0], + flexvols[1], flexvols[1]), + mock.call(self.src_backend, replication_backends[1], + flexvols[0], flexvols[0]), + mock.call(self.src_backend, replication_backends[1], + flexvols[1], flexvols[1]), + ] + + retval = self.dm_mixin.update_snapmirrors(self.mock_src_config, + self.src_backend, + flexvols) + + self.assertIsNone(retval) + self.dm_mixin.get_replication_backend_names.assert_called_once_with( + self.mock_src_config) + self.dm_mixin.update_snapmirror.assert_has_calls(expected_calls) + + @ddt.data([{'destination-volume': 'nvol3', 'lag-time': '3223'}, + {'destination-volume': 'nvol5', 'lag-time': '32'}], + []) + def test__choose_failover_target_no_failover_targets(self, snapmirrors): + flexvols = ['nvol1', 'nvol2'] + replication_backends = ['fallback1', 'fallback2'] + mock_debug_log = self.mock_object(data_motion.LOG, 'debug') + self.mock_object(self.dm_mixin, 'get_snapmirrors', + mock.Mock(return_value=snapmirrors)) + + target = self.dm_mixin._choose_failover_target( + self.src_backend, flexvols, replication_backends) + + self.assertIsNone(target) + self.assertEqual(2, mock_debug_log.call_count) + + def test__choose_failover_target(self): + flexvols = ['nvol1', 'nvol2'] + replication_backends = ['fallback1', 'fallback2'] + target_1_snapmirrors = [ + {'destination-volume': 'nvol3', 'lag-time': '12'}, + {'destination-volume': 'nvol1', 'lag-time': '1541'}, + {'destination-volume': 'nvol2', 'lag-time': '16'}, + ] + target_2_snapmirrors = [ + {'destination-volume': 'nvol2', 'lag-time': '717'}, + {'destination-volume': 'nvol1', 'lag-time': '323'}, + {'destination-volume': 'nvol3', 'lag-time': '720'}, + ] + mock_debug_log = self.mock_object(data_motion.LOG, 'debug') + self.mock_object(self.dm_mixin, 'get_snapmirrors', + mock.Mock(side_effect=[target_1_snapmirrors, + target_2_snapmirrors])) + + target = self.dm_mixin._choose_failover_target( + self.src_backend, flexvols, replication_backends) + + self.assertEqual('fallback2', target) + self.assertFalse(mock_debug_log.called) + + def test__failover_host_no_suitable_target(self): + flexvols = ['nvol1', 'nvol2'] + replication_backends = ['fallback1', 'fallback2'] + self.mock_object(self.dm_mixin, '_choose_failover_target', + mock.Mock(return_value=None)) + self.mock_object(utils, 'get_backend_configuration') + self.mock_object(self.dm_mixin, 'update_snapmirrors') + self.mock_object(self.dm_mixin, 'break_snapmirrors') + + self.assertRaises(exception.NetAppDriverException, + self.dm_mixin._complete_failover, + self.src_backend, replication_backends, flexvols, + [], failover_target=None) + self.assertFalse(utils.get_backend_configuration.called) + self.assertFalse(self.dm_mixin.update_snapmirrors.called) + self.assertFalse(self.dm_mixin.break_snapmirrors.called) + + @ddt.data('fallback1', None) + def test__failover_host(self, failover_target): + flexvols = ['nvol1', 'nvol2', 'nvol3'] + replication_backends = ['fallback1', 'fallback2'] + volumes = [ + {'id': 'xyzzy', 'host': 'openstack@backend1#nvol1'}, + {'id': 'foobar', 'host': 'openstack@backend1#nvol2'}, + {'id': 'waldofred', 'host': 'openstack@backend1#nvol3'}, + ] + expected_volume_updates = [ + { + 'volume_id': 'xyzzy', + 'updates': {'replication_status': 'failed-over'}, + }, + { + 'volume_id': 'foobar', + 'updates': {'replication_status': 'failed-over'}, + }, + { + 'volume_id': 'waldofred', + 'updates': {'replication_status': 'error'}, + }, + ] + expected_active_backend_name = failover_target or 'fallback2' + self.mock_object(self.dm_mixin, '_choose_failover_target', + mock.Mock(return_value='fallback2')) + self.mock_object(utils, 'get_backend_configuration') + self.mock_object(self.dm_mixin, 'update_snapmirrors') + self.mock_object(self.dm_mixin, 'break_snapmirrors', + mock.Mock(return_value=['nvol3'])) + + actual_active_backend_name, actual_volume_updates = ( + self.dm_mixin._complete_failover( + self.src_backend, replication_backends, flexvols, + volumes, failover_target=failover_target) + ) + + self.assertEqual(expected_active_backend_name, + actual_active_backend_name) + self.assertEqual(expected_volume_updates, actual_volume_updates) diff --git a/cinder/tests/unit/volume/drivers/netapp/dataontap/utils/test_utils.py b/cinder/tests/unit/volume/drivers/netapp/dataontap/utils/test_utils.py new file mode 100644 index 00000000000..d903859f85f --- /dev/null +++ b/cinder/tests/unit/volume/drivers/netapp/dataontap/utils/test_utils.py @@ -0,0 +1,103 @@ +# 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. + + +import ddt +import mock +from oslo_config import cfg + +from cinder import exception +from cinder import test +from cinder.tests.unit.volume.drivers.netapp.dataontap.utils import fakes +from cinder.volume.drivers.netapp.dataontap.client import client_cmode +from cinder.volume.drivers.netapp.dataontap.utils import utils + +CONF = cfg.CONF + + +@ddt.ddt +class NetAppCDOTDataMotionTestCase(test.TestCase): + + def setUp(self): + super(NetAppCDOTDataMotionTestCase, self).setUp() + self.backend = 'backend1' + self.mock_cmode_client = self.mock_object(client_cmode, 'Client') + self.config = fakes.get_fake_cmode_config(self.backend) + CONF.set_override('volume_backend_name', self.backend, + group=self.backend, enforce_type=True) + CONF.set_override('netapp_transport_type', 'https', + group=self.backend, enforce_type=True) + CONF.set_override('netapp_login', 'fake_user', + group=self.backend, enforce_type=True) + CONF.set_override('netapp_password', 'fake_password', + group=self.backend, enforce_type=True) + CONF.set_override('netapp_server_hostname', 'fake_hostname', + group=self.backend, enforce_type=True) + CONF.set_override('netapp_server_port', 8866, + group=self.backend, enforce_type=True) + + def test_get_backend_configuration(self): + self.mock_object(utils, 'CONF') + CONF.set_override('netapp_vserver', 'fake_vserver', + group=self.backend, enforce_type=True) + utils.CONF.list_all_sections.return_value = [self.backend] + + config = utils.get_backend_configuration(self.backend) + + self.assertEqual('fake_vserver', config.netapp_vserver) + + def test_get_backend_configuration_different_backend_name(self): + self.mock_object(utils, 'CONF') + CONF.set_override('netapp_vserver', 'fake_vserver', + group=self.backend, enforce_type=True) + CONF.set_override('volume_backend_name', 'fake_backend_name', + group=self.backend, enforce_type=True) + utils.CONF.list_all_sections.return_value = [self.backend] + + config = utils.get_backend_configuration(self.backend) + + self.assertEqual('fake_vserver', config.netapp_vserver) + self.assertEqual('fake_backend_name', config.volume_backend_name) + + @ddt.data([], ['fake_backend1', 'fake_backend2']) + def test_get_backend_configuration_not_configured(self, conf_sections): + self.mock_object(utils, 'CONF') + utils.CONF.list_all_sections.return_value = conf_sections + + self.assertRaises(exception.ConfigNotFound, + utils.get_backend_configuration, + self.backend) + + def test_get_client_for_backend(self): + self.mock_object(utils, 'get_backend_configuration', + mock.Mock(return_value=self.config)) + + utils.get_client_for_backend(self.backend) + + self.mock_cmode_client.assert_called_once_with( + hostname='fake_hostname', password='fake_password', + username='fake_user', transport_type='https', port=8866, + trace=mock.ANY, vserver=None) + + def test_get_client_for_backend_with_vserver(self): + self.mock_object(utils, 'get_backend_configuration', + mock.Mock(return_value=self.config)) + + CONF.set_override('netapp_vserver', 'fake_vserver', + group=self.backend, enforce_type=True) + + utils.get_client_for_backend(self.backend) + + self.mock_cmode_client.assert_called_once_with( + hostname='fake_hostname', password='fake_password', + username='fake_user', transport_type='https', port=8866, + trace=mock.ANY, vserver='fake_vserver') diff --git a/cinder/tests/unit/volume/drivers/netapp/test_common.py b/cinder/tests/unit/volume/drivers/netapp/test_common.py index 34caf4162d4..fe50b1a8351 100644 --- a/cinder/tests/unit/volume/drivers/netapp/test_common.py +++ b/cinder/tests/unit/volume/drivers/netapp/test_common.py @@ -85,8 +85,11 @@ class NetAppDriverFactoryTestCase(test.TestCase): def get_full_class_name(obj): return obj.__module__ + '.' + obj.__class__.__name__ - kwargs = {'configuration': na_fakes.create_configuration(), - 'app_version': 'fake_info'} + kwargs = { + 'configuration': na_fakes.create_configuration(), + 'app_version': 'fake_info', + 'host': 'fakehost@fakebackend', + } registry = na_common.NETAPP_UNIFIED_DRIVER_REGISTRY @@ -98,8 +101,11 @@ class NetAppDriverFactoryTestCase(test.TestCase): def test_create_driver_case_insensitive(self): - kwargs = {'configuration': na_fakes.create_configuration(), - 'app_version': 'fake_info'} + kwargs = { + 'configuration': na_fakes.create_configuration(), + 'app_version': 'fake_info', + 'host': 'fakehost@fakebackend', + } driver = na_common.NetAppDriver.create_driver('ONTAP_CLUSTER', 'FC', **kwargs) @@ -108,8 +114,11 @@ class NetAppDriverFactoryTestCase(test.TestCase): def test_create_driver_invalid_family(self): - kwargs = {'configuration': na_fakes.create_configuration(), - 'app_version': 'fake_info'} + kwargs = { + 'configuration': na_fakes.create_configuration(), + 'app_version': 'fake_info', + 'host': 'fakehost@fakebackend', + } self.assertRaises(exception.InvalidInput, na_common.NetAppDriver.create_driver, @@ -117,8 +126,11 @@ class NetAppDriverFactoryTestCase(test.TestCase): def test_create_driver_invalid_protocol(self): - kwargs = {'configuration': na_fakes.create_configuration(), - 'app_version': 'fake_info'} + kwargs = { + 'configuration': na_fakes.create_configuration(), + 'app_version': 'fake_info', + 'host': 'fakehost@fakebackend', + } self.assertRaises(exception.InvalidInput, na_common.NetAppDriver.create_driver, diff --git a/cinder/volume/drivers/netapp/dataontap/block_base.py b/cinder/volume/drivers/netapp/dataontap/block_base.py index 318127dba91..b736c9b1883 100644 --- a/cinder/volume/drivers/netapp/dataontap/block_base.py +++ b/cinder/volume/drivers/netapp/dataontap/block_base.py @@ -32,6 +32,7 @@ import uuid from oslo_log import log as logging from oslo_log import versionutils +from oslo_service import loopingcall from oslo_utils import excutils from oslo_utils import units import six @@ -46,6 +47,7 @@ from cinder.volume import utils as volume_utils from cinder.zonemanager import utils as fczm_utils LOG = logging.getLogger(__name__) +HOUSEKEEPING_INTERVAL_SECONDS = 600 # ten minutes class NetAppLun(object): @@ -103,6 +105,8 @@ class NetAppBlockStorageLibrary(object): self.lun_space_reservation = 'true' self.lookup_service = fczm_utils.create_lookup_service() self.app_version = kwargs.get("app_version", "unknown") + self.host = kwargs.get('host') + self.backend_name = self.host.split('@')[1] self.configuration = kwargs['configuration'] self.configuration.append_config_values(na_opts.netapp_connection_opts) @@ -167,6 +171,21 @@ class NetAppBlockStorageLibrary(object): self._extract_and_populate_luns(lun_list) LOG.debug("Success getting list of LUNs from server.") + self._start_periodic_tasks() + + def _start_periodic_tasks(self): + """Start recurring tasks common to all Data ONTAP block drivers.""" + + # Start the task that runs other housekeeping tasks, such as deletion + # of previously soft-deleted storage artifacts. + housekeeping_periodic_task = loopingcall.FixedIntervalLoopingCall( + self._handle_housekeeping_tasks) + housekeeping_periodic_task.start( + interval=HOUSEKEEPING_INTERVAL_SECONDS, initial_delay=0) + + def _handle_housekeeping_tasks(self): + """Handle various cleanup activities.""" + def get_pool(self, volume): """Return pool name where volume resides. diff --git a/cinder/volume/drivers/netapp/dataontap/block_cmode.py b/cinder/volume/drivers/netapp/dataontap/block_cmode.py index 3be46c59f7b..acad15497b8 100644 --- a/cinder/volume/drivers/netapp/dataontap/block_cmode.py +++ b/cinder/volume/drivers/netapp/dataontap/block_cmode.py @@ -33,20 +33,21 @@ from cinder import exception from cinder.i18n import _ from cinder import utils from cinder.volume.drivers.netapp.dataontap import block_base -from cinder.volume.drivers.netapp.dataontap.client import client_cmode from cinder.volume.drivers.netapp.dataontap.performance import perf_cmode from cinder.volume.drivers.netapp.dataontap.utils import capabilities +from cinder.volume.drivers.netapp.dataontap.utils import data_motion +from cinder.volume.drivers.netapp.dataontap.utils import utils as cmode_utils from cinder.volume.drivers.netapp import options as na_opts from cinder.volume.drivers.netapp import utils as na_utils LOG = logging.getLogger(__name__) -QOS_CLEANUP_INTERVAL_SECONDS = 60 SSC_UPDATE_INTERVAL_SECONDS = 3600 # hourly @six.add_metaclass(utils.TraceWrapperMetaclass) -class NetAppBlockStorageCmodeLibrary(block_base.NetAppBlockStorageLibrary): +class NetAppBlockStorageCmodeLibrary(block_base.NetAppBlockStorageLibrary, + data_motion.DataMotionMixin): """NetApp block storage library for Data ONTAP (Cluster-mode).""" REQUIRED_CMODE_FLAGS = ['netapp_vserver'] @@ -57,27 +58,42 @@ class NetAppBlockStorageCmodeLibrary(block_base.NetAppBlockStorageLibrary): **kwargs) self.configuration.append_config_values(na_opts.netapp_cluster_opts) self.driver_mode = 'cluster' + self.failed_over_backend_name = kwargs.get('active_backend_id') + self.failed_over = self.failed_over_backend_name is not None + self.replication_enabled = ( + True if self.get_replication_backend_names( + self.configuration) else False) def do_setup(self, context): super(NetAppBlockStorageCmodeLibrary, self).do_setup(context) na_utils.check_flags(self.REQUIRED_CMODE_FLAGS, self.configuration) - self.vserver = self.configuration.netapp_vserver - - self.zapi_client = client_cmode.Client( - transport_type=self.configuration.netapp_transport_type, - username=self.configuration.netapp_login, - password=self.configuration.netapp_password, - hostname=self.configuration.netapp_server_hostname, - port=self.configuration.netapp_server_port, - vserver=self.vserver) + # cDOT API client + self.zapi_client = cmode_utils.get_client_for_backend( + self.failed_over_backend_name or self.backend_name) + self.vserver = self.zapi_client.vserver + # Performance monitoring library self.perf_library = perf_cmode.PerformanceCmodeLibrary( self.zapi_client) + + # Storage service catalog self.ssc_library = capabilities.CapabilitiesLibrary( self.driver_protocol, self.vserver, self.zapi_client, self.configuration) + def _update_zapi_client(self, backend_name): + """Set cDOT API client for the specified config backend stanza name.""" + + self.zapi_client = cmode_utils.get_client_for_backend(backend_name) + self.vserver = self.zapi_client.vserver + self.ssc_library._update_for_failover(self.zapi_client, + self._get_flexvol_to_pool_map()) + ssc = self.ssc_library.get_ssc() + self.perf_library._update_for_failover(self.zapi_client, ssc) + # Clear LUN table cache + self.lun_table = {} + def check_for_setup_error(self): """Check that the driver is working and can communicate.""" self.ssc_library.check_api_permissions() @@ -89,9 +105,9 @@ class NetAppBlockStorageCmodeLibrary(block_base.NetAppBlockStorageLibrary): raise exception.NetAppDriverException(msg) super(NetAppBlockStorageCmodeLibrary, self).check_for_setup_error() - self._start_periodic_tasks() def _start_periodic_tasks(self): + """Start recurring tasks for NetApp cDOT block drivers.""" # Note(cknight): Run the task once in the current thread to prevent a # race with the first invocation of _update_volume_stats. @@ -104,12 +120,32 @@ class NetAppBlockStorageCmodeLibrary(block_base.NetAppBlockStorageLibrary): interval=SSC_UPDATE_INTERVAL_SECONDS, initial_delay=SSC_UPDATE_INTERVAL_SECONDS) - # Start the task that harvests soft-deleted QoS policy groups. - harvest_qos_periodic_task = loopingcall.FixedIntervalLoopingCall( - self.zapi_client.remove_unused_qos_policy_groups) - harvest_qos_periodic_task.start( - interval=QOS_CLEANUP_INTERVAL_SECONDS, - initial_delay=QOS_CLEANUP_INTERVAL_SECONDS) + super(NetAppBlockStorageCmodeLibrary, self)._start_periodic_tasks() + + def _handle_housekeeping_tasks(self): + """Handle various cleanup activities.""" + (super(NetAppBlockStorageCmodeLibrary, self). + _handle_housekeeping_tasks()) + + # Harvest soft-deleted QoS policy groups + self.zapi_client.remove_unused_qos_policy_groups() + + active_backend = self.failed_over_backend_name or self.backend_name + + LOG.debug("Current service state: Replication enabled: %(" + "replication)s. Failed-Over: %(failed)s. Active Backend " + "ID: %(active)s", + { + 'replication': self.replication_enabled, + 'failed': self.failed_over, + 'active': active_backend, + }) + + # Create pool mirrors if whole-backend replication configured + if self.replication_enabled and not self.failed_over: + self.ensure_snapmirrors( + self.configuration, self.backend_name, + self.ssc_library.get_ssc_flexvol_names()) def _create_lun(self, volume_name, lun_name, size, metadata, qos_policy_group_name=None): @@ -118,8 +154,9 @@ class NetAppBlockStorageCmodeLibrary(block_base.NetAppBlockStorageLibrary): self.zapi_client.create_lun( volume_name, lun_name, size, metadata, qos_policy_group_name) - def _create_lun_handle(self, metadata): + def _create_lun_handle(self, metadata, vserver=None): """Returns LUN handle based on filer type.""" + vserver = vserver or self.vserver return '%s:%s' % (self.vserver, metadata['Path']) def _find_mapped_lun_igroup(self, path, initiator_list): @@ -186,7 +223,7 @@ class NetAppBlockStorageCmodeLibrary(block_base.NetAppBlockStorageLibrary): def _update_volume_stats(self, filter_function=None, goodness_function=None): - """Retrieve stats info from vserver.""" + """Retrieve backend stats.""" LOG.debug('Updating volume stats') data = {} @@ -199,6 +236,7 @@ class NetAppBlockStorageCmodeLibrary(block_base.NetAppBlockStorageLibrary): filter_function=filter_function, goodness_function=goodness_function) data['sparse_copy_volume'] = True + data.update(self.get_replication_backend_stats(self.configuration)) self.zapi_client.provide_ems(self, self.driver_name, self.app_version) self._stats = data @@ -368,3 +406,8 @@ class NetAppBlockStorageCmodeLibrary(block_base.NetAppBlockStorageLibrary): qos_policy_group_info = None self._mark_qos_policy_group_for_deletion(qos_policy_group_info) super(NetAppBlockStorageCmodeLibrary, self).unmanage(volume) + + def failover_host(self, context, volumes, secondary_id=None): + """Failover a backend to a secondary replication target.""" + + return self._failover_host(volumes, secondary_id=secondary_id) diff --git a/cinder/volume/drivers/netapp/dataontap/client/api.py b/cinder/volume/drivers/netapp/dataontap/client/api.py index 8ce048cdd39..a4d2c2d6b22 100644 --- a/cinder/volume/drivers/netapp/dataontap/client/api.py +++ b/cinder/volume/drivers/netapp/dataontap/client/api.py @@ -37,10 +37,18 @@ from cinder import utils LOG = logging.getLogger(__name__) +EAPIERROR = '13001' EAPIPRIVILEGE = '13003' EAPINOTFOUND = '13005' -ESIS_CLONE_NOT_LICENSED = '14956' ESNAPSHOTNOTALLOWED = '13023' +ESIS_CLONE_NOT_LICENSED = '14956' +EOBJECTNOTFOUND = '15661' +ESOURCE_IS_DIFFERENT = '17105' +ERELATION_EXISTS = '17122' +ERELATION_NOT_QUIESCED = '17127' +ENOTRANSFER_IN_PROGRESS = '17130' +EANOTHER_OP_ACTIVE = '17131' +ETRANSFER_IN_PROGRESS = '17137' class NaServer(object): diff --git a/cinder/volume/drivers/netapp/dataontap/client/client_base.py b/cinder/volume/drivers/netapp/dataontap/client/client_base.py index 7435d12928f..797492b3074 100644 --- a/cinder/volume/drivers/netapp/dataontap/client/client_base.py +++ b/cinder/volume/drivers/netapp/dataontap/client/client_base.py @@ -73,6 +73,11 @@ class Client(object): minor = res.get_child_content('minor-version') return major, minor + def _strip_xml_namespace(self, string): + if string.startswith('{') and '}' in string: + return string.split('}', 1)[1] + return string + def check_is_naelement(self, elem): """Checks if object is instance of NaElement.""" if not isinstance(elem, netapp_api.NaElement): diff --git a/cinder/volume/drivers/netapp/dataontap/client/client_cmode.py b/cinder/volume/drivers/netapp/dataontap/client/client_cmode.py index d6f34c3368e..c2b1853853b 100644 --- a/cinder/volume/drivers/netapp/dataontap/client/client_cmode.py +++ b/cinder/volume/drivers/netapp/dataontap/client/client_cmode.py @@ -20,6 +20,7 @@ import math import re from oslo_log import log as logging +from oslo_utils import units import six from cinder import exception @@ -61,6 +62,7 @@ class Client(client_base.Client): ontapi_1_30 = ontapi_version >= (1, 30) ontapi_1_100 = ontapi_version >= (1, 100) + self.features.add_feature('SNAPMIRROR_V2', supported=ontapi_1_20) self.features.add_feature('USER_CAPABILITY_LIST', supported=ontapi_1_20) self.features.add_feature('SYSTEM_METRICS', supported=ontapi_1_2x) @@ -70,6 +72,7 @@ class Client(client_base.Client): self.features.add_feature('ADVANCED_DISK_PARTITIONING', supported=ontapi_1_30) self.features.add_feature('BACKUP_CLONE_PARAM', supported=ontapi_1_100) + self.features.add_feature('CLUSTER_PEER_POLICY', supported=ontapi_1_30) def _invoke_vserver_api(self, na_element, vserver): server = copy.copy(self.connection) @@ -890,6 +893,7 @@ class Client(client_base.Client): 'owning-vserver-name': None, 'junction-path': None, 'containing-aggregate-name': None, + 'type': None, }, 'volume-mirror-attributes': { 'is-data-protection-mirror': None, @@ -898,10 +902,18 @@ class Client(client_base.Client): 'volume-space-attributes': { 'is-space-guarantee-enabled': None, 'space-guarantee': None, + 'percentage-snapshot-reserve': None, + 'size': None, }, 'volume-qos-attributes': { 'policy-group-name': None, - } + }, + 'volume-snapshot-attributes': { + 'snapshot-policy': None, + }, + 'volume-language-attributes': { + 'language-code': None, + }, }, }, } @@ -924,6 +936,10 @@ class Client(client_base.Client): 'volume-space-attributes') or netapp_api.NaElement('none') volume_qos_attributes = volume_attributes.get_child_by_name( 'volume-qos-attributes') or netapp_api.NaElement('none') + volume_snapshot_attributes = volume_attributes.get_child_by_name( + 'volume-snapshot-attributes') or netapp_api.NaElement('none') + volume_language_attributes = volume_attributes.get_child_by_name( + 'volume-language-attributes') or netapp_api.NaElement('none') volume = { 'name': volume_id_attributes.get_child_content('name'), @@ -933,13 +949,22 @@ class Client(client_base.Client): 'junction-path'), 'aggregate': volume_id_attributes.get_child_content( 'containing-aggregate-name'), + 'type': volume_id_attributes.get_child_content('type'), 'space-guarantee-enabled': strutils.bool_from_string( volume_space_attributes.get_child_content( 'is-space-guarantee-enabled')), 'space-guarantee': volume_space_attributes.get_child_content( 'space-guarantee'), + 'percentage-snapshot-reserve': ( + volume_space_attributes.get_child_content( + 'percentage-snapshot-reserve')), + 'size': volume_space_attributes.get_child_content('size'), 'qos-policy-group': volume_qos_attributes.get_child_content( - 'policy-group-name') + 'policy-group-name'), + 'snapshot-policy': volume_snapshot_attributes.get_child_content( + 'snapshot-policy'), + 'language': volume_language_attributes.get_child_content( + 'language-code'), } return volume @@ -1015,6 +1040,106 @@ class Client(client_base.Client): return True + def create_flexvol(self, flexvol_name, aggregate_name, size_gb, + space_guarantee_type=None, snapshot_policy=None, + language=None, dedupe_enabled=False, + compression_enabled=False, snapshot_reserve=None, + volume_type='rw'): + + """Creates a volume.""" + api_args = { + 'containing-aggr-name': aggregate_name, + 'size': six.text_type(size_gb) + 'g', + 'volume': flexvol_name, + 'volume-type': volume_type, + } + if volume_type == 'dp': + snapshot_policy = None + else: + api_args['junction-path'] = '/%s' % flexvol_name + if snapshot_policy is not None: + api_args['snapshot-policy'] = snapshot_policy + if space_guarantee_type: + api_args['space-reserve'] = space_guarantee_type + if language is not None: + api_args['language-code'] = language + if snapshot_reserve is not None: + api_args['percentage-snapshot-reserve'] = six.text_type( + snapshot_reserve) + self.send_request('volume-create', api_args) + + # cDOT compression requires that deduplication be enabled. + if dedupe_enabled or compression_enabled: + self.enable_flexvol_dedupe(flexvol_name) + if compression_enabled: + self.enable_flexvol_compression(flexvol_name) + + def flexvol_exists(self, volume_name): + """Checks if a flexvol exists on the storage array.""" + LOG.debug('Checking if volume %s exists', volume_name) + + api_args = { + 'query': { + 'volume-attributes': { + 'volume-id-attributes': { + 'name': volume_name, + }, + }, + }, + 'desired-attributes': { + 'volume-attributes': { + 'volume-id-attributes': { + 'name': None, + }, + }, + }, + } + result = self.send_iter_request('volume-get-iter', api_args) + return self._has_records(result) + + def rename_flexvol(self, orig_flexvol_name, new_flexvol_name): + """Set flexvol name.""" + api_args = { + 'volume': orig_flexvol_name, + 'new-volume-name': new_flexvol_name, + } + self.send_request('volume-rename', api_args) + + def mount_flexvol(self, flexvol_name, junction_path=None): + """Mounts a volume on a junction path.""" + api_args = { + 'volume-name': flexvol_name, + 'junction-path': (junction_path if junction_path + else '/%s' % flexvol_name) + } + self.send_request('volume-mount', api_args) + + def enable_flexvol_dedupe(self, flexvol_name): + """Enable deduplication on volume.""" + api_args = {'path': '/vol/%s' % flexvol_name} + self.send_request('sis-enable', api_args) + + def disable_flexvol_dedupe(self, flexvol_name): + """Disable deduplication on volume.""" + api_args = {'path': '/vol/%s' % flexvol_name} + self.send_request('sis-disable', api_args) + + def enable_flexvol_compression(self, flexvol_name): + """Enable compression on volume.""" + api_args = { + 'path': '/vol/%s' % flexvol_name, + 'enable-compression': 'true' + } + self.send_request('sis-set-config', api_args) + + def disable_flexvol_compression(self, flexvol_name): + """Disable compression on volume.""" + api_args = { + 'path': '/vol/%s' % flexvol_name, + 'enable-compression': 'false' + } + self.send_request('sis-set-config', api_args) + @utils.trace_method def delete_file(self, path_to_file): """Delete file at path.""" @@ -1400,3 +1525,492 @@ class Client(client_base.Client): 'volume %(vol)s.') msg_args = {'snap': snapshot_name, 'vol': volume_name} raise exception.VolumeBackendAPIException(data=msg % msg_args) + + def create_cluster_peer(self, addresses, username=None, password=None, + passphrase=None): + """Creates a cluster peer relationship.""" + + api_args = { + 'peer-addresses': [ + {'remote-inet-address': address} for address in addresses + ], + } + if username: + api_args['user-name'] = username + if password: + api_args['password'] = password + if passphrase: + api_args['passphrase'] = passphrase + + self.send_request('cluster-peer-create', api_args) + + def get_cluster_peers(self, remote_cluster_name=None): + """Gets one or more cluster peer relationships.""" + + api_args = {} + if remote_cluster_name: + api_args['query'] = { + 'cluster-peer-info': { + 'remote-cluster-name': remote_cluster_name, + } + } + + result = self.send_iter_request('cluster-peer-get-iter', api_args) + if not self._has_records(result): + return [] + + cluster_peers = [] + + for cluster_peer_info in result.get_child_by_name( + 'attributes-list').get_children(): + + cluster_peer = { + 'active-addresses': [], + 'peer-addresses': [] + } + + active_addresses = cluster_peer_info.get_child_by_name( + 'active-addresses') or netapp_api.NaElement('none') + for address in active_addresses.get_children(): + cluster_peer['active-addresses'].append(address.get_content()) + + peer_addresses = cluster_peer_info.get_child_by_name( + 'peer-addresses') or netapp_api.NaElement('none') + for address in peer_addresses.get_children(): + cluster_peer['peer-addresses'].append(address.get_content()) + + cluster_peer['availability'] = cluster_peer_info.get_child_content( + 'availability') + cluster_peer['cluster-name'] = cluster_peer_info.get_child_content( + 'cluster-name') + cluster_peer['cluster-uuid'] = cluster_peer_info.get_child_content( + 'cluster-uuid') + cluster_peer['remote-cluster-name'] = ( + cluster_peer_info.get_child_content('remote-cluster-name')) + cluster_peer['serial-number'] = ( + cluster_peer_info.get_child_content('serial-number')) + cluster_peer['timeout'] = cluster_peer_info.get_child_content( + 'timeout') + + cluster_peers.append(cluster_peer) + + return cluster_peers + + def delete_cluster_peer(self, cluster_name): + """Deletes a cluster peer relationship.""" + + api_args = {'cluster-name': cluster_name} + self.send_request('cluster-peer-delete', api_args) + + def get_cluster_peer_policy(self): + """Gets the cluster peering policy configuration.""" + + if not self.features.CLUSTER_PEER_POLICY: + return {} + + result = self.send_request('cluster-peer-policy-get') + + attributes = result.get_child_by_name( + 'attributes') or netapp_api.NaElement('none') + cluster_peer_policy = attributes.get_child_by_name( + 'cluster-peer-policy') or netapp_api.NaElement('none') + + policy = { + 'is-unauthenticated-access-permitted': + cluster_peer_policy.get_child_content( + 'is-unauthenticated-access-permitted'), + 'passphrase-minimum-length': + cluster_peer_policy.get_child_content( + 'passphrase-minimum-length'), + } + + if policy['is-unauthenticated-access-permitted'] is not None: + policy['is-unauthenticated-access-permitted'] = ( + strutils.bool_from_string( + policy['is-unauthenticated-access-permitted'])) + if policy['passphrase-minimum-length'] is not None: + policy['passphrase-minimum-length'] = int( + policy['passphrase-minimum-length']) + + return policy + + def set_cluster_peer_policy(self, is_unauthenticated_access_permitted=None, + passphrase_minimum_length=None): + """Modifies the cluster peering policy configuration.""" + + if not self.features.CLUSTER_PEER_POLICY: + return + + if (is_unauthenticated_access_permitted is None and + passphrase_minimum_length is None): + return + + api_args = {} + if is_unauthenticated_access_permitted is not None: + api_args['is-unauthenticated-access-permitted'] = ( + 'true' if strutils.bool_from_string( + is_unauthenticated_access_permitted) else 'false') + if passphrase_minimum_length is not None: + api_args['passphrase-minlength'] = six.text_type( + passphrase_minimum_length) + + self.send_request('cluster-peer-policy-modify', api_args) + + def create_vserver_peer(self, vserver_name, peer_vserver_name): + """Creates a Vserver peer relationship for SnapMirrors.""" + api_args = { + 'vserver': vserver_name, + 'peer-vserver': peer_vserver_name, + 'applications': [ + {'vserver-peer-application': 'snapmirror'}, + ], + } + self.send_request('vserver-peer-create', api_args) + + def delete_vserver_peer(self, vserver_name, peer_vserver_name): + """Deletes a Vserver peer relationship.""" + + api_args = {'vserver': vserver_name, 'peer-vserver': peer_vserver_name} + self.send_request('vserver-peer-delete', api_args) + + def accept_vserver_peer(self, vserver_name, peer_vserver_name): + """Accepts a pending Vserver peer relationship.""" + + api_args = {'vserver': vserver_name, 'peer-vserver': peer_vserver_name} + self.send_request('vserver-peer-accept', api_args) + + def get_vserver_peers(self, vserver_name=None, peer_vserver_name=None): + """Gets one or more Vserver peer relationships.""" + + api_args = None + if vserver_name or peer_vserver_name: + api_args = {'query': {'vserver-peer-info': {}}} + if vserver_name: + api_args['query']['vserver-peer-info']['vserver'] = ( + vserver_name) + if peer_vserver_name: + api_args['query']['vserver-peer-info']['peer-vserver'] = ( + peer_vserver_name) + + result = self.send_iter_request('vserver-peer-get-iter', api_args) + if not self._has_records(result): + return [] + + vserver_peers = [] + + for vserver_peer_info in result.get_child_by_name( + 'attributes-list').get_children(): + + vserver_peer = { + 'vserver': vserver_peer_info.get_child_content('vserver'), + 'peer-vserver': + vserver_peer_info.get_child_content('peer-vserver'), + 'peer-state': + vserver_peer_info.get_child_content('peer-state'), + 'peer-cluster': + vserver_peer_info.get_child_content('peer-cluster'), + } + vserver_peers.append(vserver_peer) + + return vserver_peers + + def _ensure_snapmirror_v2(self): + """Verify support for SnapMirror control plane v2.""" + if not self.features.SNAPMIRROR_V2: + msg = _('SnapMirror features require Data ONTAP 8.2 or later.') + raise exception.NetAppDriverException(msg) + + def create_snapmirror(self, source_vserver, source_volume, + destination_vserver, destination_volume, + schedule=None, policy=None, + relationship_type='data_protection'): + """Creates a SnapMirror relationship (cDOT 8.2 or later only).""" + self._ensure_snapmirror_v2() + + api_args = { + 'source-volume': source_volume, + 'source-vserver': source_vserver, + 'destination-volume': destination_volume, + 'destination-vserver': destination_vserver, + 'relationship-type': relationship_type, + } + if schedule: + api_args['schedule'] = schedule + if policy: + api_args['policy'] = policy + + try: + self.send_request('snapmirror-create', api_args) + except netapp_api.NaApiError as e: + if e.code != netapp_api.ERELATION_EXISTS: + raise + + def initialize_snapmirror(self, source_vserver, source_volume, + destination_vserver, destination_volume, + source_snapshot=None, transfer_priority=None): + """Initializes a SnapMirror relationship (cDOT 8.2 or later only).""" + self._ensure_snapmirror_v2() + + api_args = { + 'source-volume': source_volume, + 'source-vserver': source_vserver, + 'destination-volume': destination_volume, + 'destination-vserver': destination_vserver, + } + if source_snapshot: + api_args['source-snapshot'] = source_snapshot + if transfer_priority: + api_args['transfer-priority'] = transfer_priority + + result = self.send_request('snapmirror-initialize', api_args) + + result_info = {} + result_info['operation-id'] = result.get_child_content( + 'result-operation-id') + result_info['status'] = result.get_child_content('result-status') + result_info['jobid'] = result.get_child_content('result-jobid') + result_info['error-code'] = result.get_child_content( + 'result-error-code') + result_info['error-message'] = result.get_child_content( + 'result-error-message') + + return result_info + + def release_snapmirror(self, source_vserver, source_volume, + destination_vserver, destination_volume, + relationship_info_only=False): + """Removes a SnapMirror relationship on the source endpoint.""" + self._ensure_snapmirror_v2() + + api_args = { + 'query': { + 'snapmirror-destination-info': { + 'source-volume': source_volume, + 'source-vserver': source_vserver, + 'destination-volume': destination_volume, + 'destination-vserver': destination_vserver, + 'relationship-info-only': ('true' if relationship_info_only + else 'false'), + } + } + } + self.send_request('snapmirror-release-iter', api_args) + + def quiesce_snapmirror(self, source_vserver, source_volume, + destination_vserver, destination_volume): + """Disables future transfers to a SnapMirror destination.""" + self._ensure_snapmirror_v2() + + api_args = { + 'source-volume': source_volume, + 'source-vserver': source_vserver, + 'destination-volume': destination_volume, + 'destination-vserver': destination_vserver, + } + self.send_request('snapmirror-quiesce', api_args) + + def abort_snapmirror(self, source_vserver, source_volume, + destination_vserver, destination_volume, + clear_checkpoint=False): + """Stops ongoing transfers for a SnapMirror relationship.""" + self._ensure_snapmirror_v2() + + api_args = { + 'source-volume': source_volume, + 'source-vserver': source_vserver, + 'destination-volume': destination_volume, + 'destination-vserver': destination_vserver, + 'clear-checkpoint': 'true' if clear_checkpoint else 'false', + } + try: + self.send_request('snapmirror-abort', api_args) + except netapp_api.NaApiError as e: + if e.code != netapp_api.ENOTRANSFER_IN_PROGRESS: + raise + + def break_snapmirror(self, source_vserver, source_volume, + destination_vserver, destination_volume): + """Breaks a data protection SnapMirror relationship.""" + self._ensure_snapmirror_v2() + + api_args = { + 'source-volume': source_volume, + 'source-vserver': source_vserver, + 'destination-volume': destination_volume, + 'destination-vserver': destination_vserver, + } + self.send_request('snapmirror-break', api_args) + + def modify_snapmirror(self, source_vserver, source_volume, + destination_vserver, destination_volume, + schedule=None, policy=None, tries=None, + max_transfer_rate=None): + """Modifies a SnapMirror relationship.""" + self._ensure_snapmirror_v2() + + api_args = { + 'source-volume': source_volume, + 'source-vserver': source_vserver, + 'destination-volume': destination_volume, + 'destination-vserver': destination_vserver, + } + if schedule: + api_args['schedule'] = schedule + if policy: + api_args['policy'] = policy + if tries is not None: + api_args['tries'] = tries + if max_transfer_rate is not None: + api_args['max-transfer-rate'] = max_transfer_rate + + self.send_request('snapmirror-modify', api_args) + + def delete_snapmirror(self, source_vserver, source_volume, + destination_vserver, destination_volume): + """Destroys a SnapMirror relationship.""" + self._ensure_snapmirror_v2() + + api_args = { + 'query': { + 'snapmirror-info': { + 'source-volume': source_volume, + 'source-vserver': source_vserver, + 'destination-volume': destination_volume, + 'destination-vserver': destination_vserver, + } + } + } + self.send_request('snapmirror-destroy-iter', api_args) + + def update_snapmirror(self, source_vserver, source_volume, + destination_vserver, destination_volume): + """Schedules a SnapMirror update.""" + self._ensure_snapmirror_v2() + + api_args = { + 'source-volume': source_volume, + 'source-vserver': source_vserver, + 'destination-volume': destination_volume, + 'destination-vserver': destination_vserver, + } + try: + self.send_request('snapmirror-update', api_args) + except netapp_api.NaApiError as e: + if (e.code != netapp_api.ETRANSFER_IN_PROGRESS and + e.code != netapp_api.EANOTHER_OP_ACTIVE): + raise + + def resume_snapmirror(self, source_vserver, source_volume, + destination_vserver, destination_volume): + """Resume a SnapMirror relationship if it is quiesced.""" + self._ensure_snapmirror_v2() + + api_args = { + 'source-volume': source_volume, + 'source-vserver': source_vserver, + 'destination-volume': destination_volume, + 'destination-vserver': destination_vserver, + } + try: + self.send_request('snapmirror-resume', api_args) + except netapp_api.NaApiError as e: + if e.code != netapp_api.ERELATION_NOT_QUIESCED: + raise + + def resync_snapmirror(self, source_vserver, source_volume, + destination_vserver, destination_volume): + """Resync a SnapMirror relationship.""" + self._ensure_snapmirror_v2() + + api_args = { + 'source-volume': source_volume, + 'source-vserver': source_vserver, + 'destination-volume': destination_volume, + 'destination-vserver': destination_vserver, + } + self.send_request('snapmirror-resync', api_args) + + def _get_snapmirrors(self, source_vserver=None, source_volume=None, + destination_vserver=None, destination_volume=None, + desired_attributes=None): + + query = None + if (source_vserver or source_volume or destination_vserver or + destination_volume): + query = {'snapmirror-info': {}} + if source_volume: + query['snapmirror-info']['source-volume'] = source_volume + if destination_volume: + query['snapmirror-info']['destination-volume'] = ( + destination_volume) + if source_vserver: + query['snapmirror-info']['source-vserver'] = source_vserver + if destination_vserver: + query['snapmirror-info']['destination-vserver'] = ( + destination_vserver) + + api_args = {} + if query: + api_args['query'] = query + if desired_attributes: + api_args['desired-attributes'] = desired_attributes + + result = self.send_iter_request('snapmirror-get-iter', api_args) + if not self._has_records(result): + return [] + else: + return result.get_child_by_name('attributes-list').get_children() + + def get_snapmirrors(self, source_vserver, source_volume, + destination_vserver, destination_volume, + desired_attributes=None): + """Gets one or more SnapMirror relationships. + + Either the source or destination info may be omitted. + Desired attributes should be a flat list of attribute names. + """ + self._ensure_snapmirror_v2() + + if desired_attributes is not None: + desired_attributes = { + 'snapmirror-info': {attr: None for attr in desired_attributes}, + } + + result = self._get_snapmirrors( + source_vserver=source_vserver, + source_volume=source_volume, + destination_vserver=destination_vserver, + destination_volume=destination_volume, + desired_attributes=desired_attributes) + + snapmirrors = [] + + for snapmirror_info in result: + snapmirror = {} + for child in snapmirror_info.get_children(): + name = self._strip_xml_namespace(child.get_name()) + snapmirror[name] = child.get_content() + snapmirrors.append(snapmirror) + + return snapmirrors + + def get_provisioning_options_from_flexvol(self, flexvol_name): + """Get a dict of provisioning options matching existing flexvol.""" + + flexvol_info = self.get_flexvol(flexvol_name=flexvol_name) + dedupe_info = self.get_flexvol_dedupe_info(flexvol_name) + + provisioning_opts = { + 'aggregate': flexvol_info['aggregate'], + # space-guarantee can be 'none', 'file', 'volume' + 'space_guarantee_type': flexvol_info.get('space-guarantee'), + 'snapshot_policy': flexvol_info['snapshot-policy'], + 'language': flexvol_info['language'], + 'dedupe_enabled': dedupe_info['dedupe'], + 'compression_enabled': dedupe_info['compression'], + 'snapshot_reserve': flexvol_info['percentage-snapshot-reserve'], + 'volume_type': flexvol_info['type'], + 'size': int(math.ceil(float(flexvol_info['size']) / units.Gi)), + } + + return provisioning_opts diff --git a/cinder/volume/drivers/netapp/dataontap/fc_7mode.py b/cinder/volume/drivers/netapp/dataontap/fc_7mode.py index bd5113c8624..9691e384955 100644 --- a/cinder/volume/drivers/netapp/dataontap/fc_7mode.py +++ b/cinder/volume/drivers/netapp/dataontap/fc_7mode.py @@ -129,3 +129,6 @@ class NetApp7modeFibreChannelDriver(driver.BaseVD, return self.library.create_consistencygroup_from_src( group, volumes, cgsnapshot=cgsnapshot, snapshots=snapshots, source_cg=source_cg, source_vols=source_vols) + + def failover_host(self, context, volumes, secondary_id=None): + raise NotImplementedError() diff --git a/cinder/volume/drivers/netapp/dataontap/fc_cmode.py b/cinder/volume/drivers/netapp/dataontap/fc_cmode.py index 391f4222339..fa610d6735b 100644 --- a/cinder/volume/drivers/netapp/dataontap/fc_cmode.py +++ b/cinder/volume/drivers/netapp/dataontap/fc_cmode.py @@ -129,3 +129,7 @@ class NetAppCmodeFibreChannelDriver(driver.BaseVD, return self.library.create_consistencygroup_from_src( group, volumes, cgsnapshot=cgsnapshot, snapshots=snapshots, source_cg=source_cg, source_vols=source_vols) + + def failover_host(self, context, volumes, secondary_id=None): + return self.library.failover_host( + context, volumes, secondary_id=secondary_id) diff --git a/cinder/volume/drivers/netapp/dataontap/iscsi_7mode.py b/cinder/volume/drivers/netapp/dataontap/iscsi_7mode.py index f523cb5fe1d..442d329cace 100644 --- a/cinder/volume/drivers/netapp/dataontap/iscsi_7mode.py +++ b/cinder/volume/drivers/netapp/dataontap/iscsi_7mode.py @@ -126,3 +126,6 @@ class NetApp7modeISCSIDriver(driver.BaseVD, return self.library.create_consistencygroup_from_src( group, volumes, cgsnapshot=cgsnapshot, snapshots=snapshots, source_cg=source_cg, source_vols=source_vols) + + def failover_host(self, context, volumes, secondary_id=None): + raise NotImplementedError() diff --git a/cinder/volume/drivers/netapp/dataontap/iscsi_cmode.py b/cinder/volume/drivers/netapp/dataontap/iscsi_cmode.py index 29e8d25d9df..2076caca513 100644 --- a/cinder/volume/drivers/netapp/dataontap/iscsi_cmode.py +++ b/cinder/volume/drivers/netapp/dataontap/iscsi_cmode.py @@ -126,3 +126,7 @@ class NetAppCmodeISCSIDriver(driver.BaseVD, return self.library.create_consistencygroup_from_src( group, volumes, cgsnapshot=cgsnapshot, snapshots=snapshots, source_cg=source_cg, source_vols=source_vols) + + def failover_host(self, context, volumes, secondary_id=None): + return self.library.failover_host( + context, volumes, secondary_id=secondary_id) diff --git a/cinder/volume/drivers/netapp/dataontap/nfs_base.py b/cinder/volume/drivers/netapp/dataontap/nfs_base.py index 6d4c361791e..3653348138e 100644 --- a/cinder/volume/drivers/netapp/dataontap/nfs_base.py +++ b/cinder/volume/drivers/netapp/dataontap/nfs_base.py @@ -32,6 +32,7 @@ import time from oslo_concurrency import processutils from oslo_config import cfg from oslo_log import log as logging +from oslo_service import loopingcall from oslo_utils import units import six from six.moves import urllib @@ -49,6 +50,7 @@ from cinder.volume import utils as volume_utils LOG = logging.getLogger(__name__) CONF = cfg.CONF +HOUSEKEEPING_INTERVAL_SECONDS = 600 # ten minutes @six.add_metaclass(utils.TraceWrapperWithABCMetaclass) @@ -76,6 +78,7 @@ class NetAppNfsDriver(driver.ManageableVD, self.configuration.append_config_values(na_opts.netapp_transport_opts) self.configuration.append_config_values(na_opts.netapp_img_cache_opts) self.configuration.append_config_values(na_opts.netapp_nfs_extra_opts) + self.backend_name = self.host.split('@')[1] def do_setup(self, context): super(NetAppNfsDriver, self).do_setup(context) @@ -86,6 +89,20 @@ class NetAppNfsDriver(driver.ManageableVD, def check_for_setup_error(self): """Returns an error if prerequisites aren't met.""" super(NetAppNfsDriver, self).check_for_setup_error() + self._start_periodic_tasks() + + def _start_periodic_tasks(self): + """Start recurring tasks common to all Data ONTAP NFS drivers.""" + + # Start the task that runs other housekeeping tasks, such as deletion + # of previously soft-deleted storage artifacts. + housekeeping_periodic_task = loopingcall.FixedIntervalLoopingCall( + self._handle_housekeeping_tasks) + housekeeping_periodic_task.start( + interval=HOUSEKEEPING_INTERVAL_SECONDS, initial_delay=0) + + def _handle_housekeeping_tasks(self): + """Handle various cleanup activities.""" def get_pool(self, volume): """Return pool name where volume resides. diff --git a/cinder/volume/drivers/netapp/dataontap/nfs_cmode.py b/cinder/volume/drivers/netapp/dataontap/nfs_cmode.py index 001eee42d36..75c9a7c0b46 100644 --- a/cinder/volume/drivers/netapp/dataontap/nfs_cmode.py +++ b/cinder/volume/drivers/netapp/dataontap/nfs_cmode.py @@ -34,23 +34,24 @@ from cinder.i18n import _, _LE, _LI, _LW from cinder.image import image_utils from cinder import interface from cinder import utils -from cinder.volume.drivers.netapp.dataontap.client import client_cmode from cinder.volume.drivers.netapp.dataontap import nfs_base from cinder.volume.drivers.netapp.dataontap.performance import perf_cmode from cinder.volume.drivers.netapp.dataontap.utils import capabilities +from cinder.volume.drivers.netapp.dataontap.utils import data_motion +from cinder.volume.drivers.netapp.dataontap.utils import utils as cmode_utils from cinder.volume.drivers.netapp import options as na_opts from cinder.volume.drivers.netapp import utils as na_utils from cinder.volume import utils as volume_utils LOG = logging.getLogger(__name__) -QOS_CLEANUP_INTERVAL_SECONDS = 60 SSC_UPDATE_INTERVAL_SECONDS = 3600 # hourly @interface.volumedriver @six.add_metaclass(utils.TraceWrapperWithABCMetaclass) -class NetAppCmodeNfsDriver(nfs_base.NetAppNfsDriver): +class NetAppCmodeNfsDriver(nfs_base.NetAppNfsDriver, + data_motion.DataMotionMixin): """NetApp NFS driver for Data ONTAP (Cluster-mode).""" REQUIRED_CMODE_FLAGS = ['netapp_vserver'] @@ -58,34 +59,48 @@ class NetAppCmodeNfsDriver(nfs_base.NetAppNfsDriver): def __init__(self, *args, **kwargs): super(NetAppCmodeNfsDriver, self).__init__(*args, **kwargs) self.configuration.append_config_values(na_opts.netapp_cluster_opts) + self.failed_over_backend_name = kwargs.get('active_backend_id') + self.failed_over = self.failed_over_backend_name is not None + self.replication_enabled = ( + True if self.get_replication_backend_names( + self.configuration) else False) def do_setup(self, context): """Do the customized set up on client for cluster mode.""" super(NetAppCmodeNfsDriver, self).do_setup(context) na_utils.check_flags(self.REQUIRED_CMODE_FLAGS, self.configuration) - self.vserver = self.configuration.netapp_vserver - - self.zapi_client = client_cmode.Client( - transport_type=self.configuration.netapp_transport_type, - username=self.configuration.netapp_login, - password=self.configuration.netapp_password, - hostname=self.configuration.netapp_server_hostname, - port=self.configuration.netapp_server_port, - vserver=self.vserver) + # cDOT API client + self.zapi_client = cmode_utils.get_client_for_backend( + self.failed_over_backend_name or self.backend_name) + self.vserver = self.zapi_client.vserver + # Performance monitoring library self.perf_library = perf_cmode.PerformanceCmodeLibrary( self.zapi_client) + + # Storage service catalog self.ssc_library = capabilities.CapabilitiesLibrary( 'nfs', self.vserver, self.zapi_client, self.configuration) + def _update_zapi_client(self, backend_name): + """Set cDOT API client for the specified config backend stanza name.""" + + self.zapi_client = cmode_utils.get_client_for_backend(backend_name) + self.vserver = self.zapi_client.vserver + self.ssc_library._update_for_failover(self.zapi_client, + self._get_flexvol_to_pool_map()) + ssc = self.ssc_library.get_ssc() + self.perf_library._update_for_failover(self.zapi_client, ssc) + + @utils.trace_method def check_for_setup_error(self): """Check that the driver is working and can communicate.""" super(NetAppCmodeNfsDriver, self).check_for_setup_error() self.ssc_library.check_api_permissions() - self._start_periodic_tasks() def _start_periodic_tasks(self): + """Start recurring tasks for NetApp cDOT NFS driver.""" # Note(cknight): Run the task once in the current thread to prevent a # race with the first invocation of _update_volume_stats. @@ -98,12 +113,31 @@ class NetAppCmodeNfsDriver(nfs_base.NetAppNfsDriver): interval=SSC_UPDATE_INTERVAL_SECONDS, initial_delay=SSC_UPDATE_INTERVAL_SECONDS) - # Start the task that harvests soft-deleted QoS policy groups. - harvest_qos_periodic_task = loopingcall.FixedIntervalLoopingCall( - self.zapi_client.remove_unused_qos_policy_groups) - harvest_qos_periodic_task.start( - interval=QOS_CLEANUP_INTERVAL_SECONDS, - initial_delay=QOS_CLEANUP_INTERVAL_SECONDS) + super(NetAppCmodeNfsDriver, self)._start_periodic_tasks() + + def _handle_housekeeping_tasks(self): + """Handle various cleanup activities.""" + super(NetAppCmodeNfsDriver, self)._handle_housekeeping_tasks() + + # Harvest soft-deleted QoS policy groups + self.zapi_client.remove_unused_qos_policy_groups() + + active_backend = self.failed_over_backend_name or self.backend_name + + LOG.debug("Current service state: Replication enabled: %(" + "replication)s. Failed-Over: %(failed)s. Active Backend " + "ID: %(active)s", + { + 'replication': self.replication_enabled, + 'failed': self.failed_over, + 'active': active_backend, + }) + + # Create pool mirrors if whole-backend replication configured + if self.replication_enabled and not self.failed_over: + self.ensure_snapmirrors( + self.configuration, self.backend_name, + self.ssc_library.get_ssc_flexvol_names()) def _do_qos_for_volume(self, volume, extra_specs, cleanup=True): try: @@ -166,6 +200,7 @@ class NetAppCmodeNfsDriver(nfs_base.NetAppNfsDriver): filter_function=self.get_filter_function(), goodness_function=self.get_goodness_function()) data['sparse_copy_volume'] = True + data.update(self.get_replication_backend_stats(self.configuration)) self._spawn_clean_cache_job() self.zapi_client.provide_ems(self, netapp_backend, self._app_version) @@ -638,3 +673,8 @@ class NetAppCmodeNfsDriver(nfs_base.NetAppNfsDriver): pass super(NetAppCmodeNfsDriver, self).unmanage(volume) + + def failover_host(self, context, volumes, secondary_id=None): + """Failover a backend to a secondary replication target.""" + + return self._failover_host(volumes, secondary_id=secondary_id) diff --git a/cinder/volume/drivers/netapp/dataontap/performance/perf_cmode.py b/cinder/volume/drivers/netapp/dataontap/performance/perf_cmode.py index e85c83d1169..d086019f025 100644 --- a/cinder/volume/drivers/netapp/dataontap/performance/perf_cmode.py +++ b/cinder/volume/drivers/netapp/dataontap/performance/perf_cmode.py @@ -113,6 +113,10 @@ class PerformanceCmodeLibrary(perf_base.PerformanceLibrary): return self.pool_utilization.get(pool_name, perf_base.DEFAULT_UTILIZATION) + def _update_for_failover(self, zapi_client, ssc_pools): + self.zapi_client = zapi_client + self.update_performance_cache(ssc_pools) + def _get_aggregates_for_pools(self, ssc_pools): """Get the set of aggregates that contain the specified pools.""" diff --git a/cinder/volume/drivers/netapp/dataontap/utils/capabilities.py b/cinder/volume/drivers/netapp/dataontap/utils/capabilities.py index a5fcb796250..8447b8dc9a4 100644 --- a/cinder/volume/drivers/netapp/dataontap/utils/capabilities.py +++ b/cinder/volume/drivers/netapp/dataontap/utils/capabilities.py @@ -88,6 +88,11 @@ class CapabilitiesLibrary(object): return copy.deepcopy(self.ssc) + def get_ssc_flexvol_names(self): + """Get the names of the FlexVols in the Storage Service Catalog.""" + ssc = self.get_ssc() + return ssc.keys() + def get_ssc_for_flexvol(self, flexvol_name): """Get map of Storage Service Catalog entries for a single flexvol.""" @@ -133,6 +138,11 @@ class CapabilitiesLibrary(object): self.ssc = ssc + def _update_for_failover(self, zapi_client, flexvol_map): + + self.zapi_client = zapi_client + self.update_ssc(flexvol_map) + def _get_ssc_flexvol_info(self, flexvol_name): """Gather flexvol info and recast into SSC-style volume stats.""" diff --git a/cinder/volume/drivers/netapp/dataontap/utils/data_motion.py b/cinder/volume/drivers/netapp/dataontap/utils/data_motion.py new file mode 100644 index 00000000000..066435c1a5f --- /dev/null +++ b/cinder/volume/drivers/netapp/dataontap/utils/data_motion.py @@ -0,0 +1,640 @@ +# Copyright (c) 2016 Alex Meade. 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. +""" +NetApp Data ONTAP data motion library. + +This library handles transferring data from a source to a destination. Its +responsibility is to handle this as efficiently as possible given the +location of the data's source and destination. This includes cloning, +SnapMirror, and copy-offload as improvements to brute force data transfer. +""" + +from oslo_config import cfg +from oslo_log import log +from oslo_utils import excutils + +from cinder import exception +from cinder import utils +from cinder.i18n import _, _LE, _LI +from cinder.objects import fields +from cinder.volume.drivers.netapp.dataontap.client import api as netapp_api +from cinder.volume.drivers.netapp.dataontap.utils import utils as config_utils +from cinder.volume import utils as volume_utils + +LOG = log.getLogger(__name__) +CONF = cfg.CONF +ENTRY_DOES_NOT_EXIST = "(entry doesn't exist)" +QUIESCE_RETRY_INTERVAL = 5 + + +class DataMotionMixin(object): + + def get_replication_backend_names(self, config): + """Get the backend names for all configured replication targets.""" + + backend_names = [] + + replication_devices = config.safe_get('replication_device') + if replication_devices: + for replication_device in replication_devices: + backend_id = replication_device.get('backend_id') + if backend_id: + backend_names.append(backend_id) + + return backend_names + + def get_replication_backend_stats(self, config): + """Get the driver replication info for merging into volume stats.""" + + backend_names = self.get_replication_backend_names(config) + + if len(backend_names) > 0: + stats = { + 'replication_enabled': True, + 'replication_count': len(backend_names), + 'replication_targets': backend_names, + 'replication_type': 'async', + } + else: + stats = {'replication_enabled': False} + + return stats + + def _get_replication_aggregate_map(self, src_backend_name, + target_backend_name): + """Get the aggregate mapping config between src and destination.""" + + aggregate_map = {} + + config = config_utils.get_backend_configuration(src_backend_name) + + all_replication_aggregate_maps = config.safe_get( + 'netapp_replication_aggregate_map') + if all_replication_aggregate_maps: + for replication_aggregate_map in all_replication_aggregate_maps: + if (replication_aggregate_map.get('backend_id') == + target_backend_name): + replication_aggregate_map.pop('backend_id') + aggregate_map = replication_aggregate_map + break + + return aggregate_map + + def get_snapmirrors(self, src_backend_name, dest_backend_name, + src_flexvol_name=None, dest_flexvol_name=None): + """Get info regarding SnapMirror relationship/s for given params.""" + dest_backend_config = config_utils.get_backend_configuration( + dest_backend_name) + dest_vserver = dest_backend_config.netapp_vserver + dest_client = config_utils.get_client_for_backend( + dest_backend_name, vserver_name=dest_vserver) + + src_backend_config = config_utils.get_backend_configuration( + src_backend_name) + src_vserver = src_backend_config.netapp_vserver + + snapmirrors = dest_client.get_snapmirrors( + src_vserver, src_flexvol_name, + dest_vserver, dest_flexvol_name, + desired_attributes=[ + 'relationship-status', + 'mirror-state', + 'source-vserver', + 'source-volume', + 'destination-vserver', + 'destination-volume', + 'last-transfer-end-timestamp', + 'lag-time', + ]) + return snapmirrors + + def create_snapmirror(self, src_backend_name, dest_backend_name, + src_flexvol_name, dest_flexvol_name): + """Set up a SnapMirror relationship b/w two FlexVols (cinder pools) + + 1. Create SnapMirror relationship + 2. Initialize data transfer asynchronously + + If a SnapMirror relationship already exists and is broken off or + quiesced, resume and re-sync the mirror. + """ + dest_backend_config = config_utils.get_backend_configuration( + dest_backend_name) + dest_vserver = dest_backend_config.netapp_vserver + dest_client = config_utils.get_client_for_backend( + dest_backend_name, vserver_name=dest_vserver) + + source_backend_config = config_utils.get_backend_configuration( + src_backend_name) + src_vserver = source_backend_config.netapp_vserver + + # 1. Create destination 'dp' FlexVol if it doesn't exist + if not dest_client.flexvol_exists(dest_flexvol_name): + self.create_destination_flexvol(src_backend_name, + dest_backend_name, + src_flexvol_name, + dest_flexvol_name) + + # 2. Check if SnapMirror relationship exists + existing_mirrors = dest_client.get_snapmirrors( + src_vserver, src_flexvol_name, dest_vserver, dest_flexvol_name) + + msg_payload = { + 'src_vserver': src_vserver, + 'src_volume': src_flexvol_name, + 'dest_vserver': dest_vserver, + 'dest_volume': dest_flexvol_name, + } + + # 3. Create and initialize SnapMirror if it doesn't already exist + if not existing_mirrors: + # TODO(gouthamr): Change the schedule from hourly to a config value + msg = ("Creating a SnapMirror relationship between " + "%(src_vserver)s:%(src_volume)s and %(dest_vserver)s:" + "%(dest_volume)s.") + LOG.debug(msg, msg_payload) + + dest_client.create_snapmirror(src_vserver, + src_flexvol_name, + dest_vserver, + dest_flexvol_name, + schedule='hourly') + + msg = ("Initializing SnapMirror transfers between " + "%(src_vserver)s:%(src_volume)s and %(dest_vserver)s:" + "%(dest_volume)s.") + LOG.debug(msg, msg_payload) + + # Initialize async transfer of the initial data + dest_client.initialize_snapmirror(src_vserver, + src_flexvol_name, + dest_vserver, + dest_flexvol_name) + + # 4. Try to repair SnapMirror if existing + else: + snapmirror = existing_mirrors[0] + if snapmirror.get('mirror-state') != 'snapmirrored': + try: + msg = ("SnapMirror between %(src_vserver)s:%(src_volume)s " + "and %(dest_vserver)s:%(dest_volume)s is in " + "'%(state)s' state. Attempting to repair it.") + msg_payload['state'] = snapmirror.get('mirror-state') + LOG.debug(msg, msg_payload) + dest_client.resume_snapmirror(src_vserver, + src_flexvol_name, + dest_vserver, + dest_flexvol_name) + dest_client.resync_snapmirror(src_vserver, + src_flexvol_name, + dest_vserver, + dest_flexvol_name) + except netapp_api.NaApiError: + LOG.exception(_LE("Could not re-sync SnapMirror.")) + + def delete_snapmirror(self, src_backend_name, dest_backend_name, + src_flexvol_name, dest_flexvol_name, release=True): + """Ensure all information about a SnapMirror relationship is removed. + + 1. Abort SnapMirror + 2. Delete the SnapMirror + 3. Release SnapMirror to cleanup SnapMirror metadata and snapshots + """ + dest_backend_config = config_utils.get_backend_configuration( + dest_backend_name) + dest_vserver = dest_backend_config.netapp_vserver + dest_client = config_utils.get_client_for_backend( + dest_backend_name, vserver_name=dest_vserver) + + source_backend_config = config_utils.get_backend_configuration( + src_backend_name) + src_vserver = source_backend_config.netapp_vserver + + # 1. Abort any ongoing transfers + try: + dest_client.abort_snapmirror(src_vserver, + src_flexvol_name, + dest_vserver, + dest_flexvol_name, + clear_checkpoint=False) + except netapp_api.NaApiError: + # Snapmirror is already deleted + pass + + # 2. Delete SnapMirror Relationship and cleanup destination snapshots + try: + dest_client.delete_snapmirror(src_vserver, + src_flexvol_name, + dest_vserver, + dest_flexvol_name) + except netapp_api.NaApiError as e: + with excutils.save_and_reraise_exception() as exc_context: + if (e.code == netapp_api.EOBJECTNOTFOUND or + e.code == netapp_api.ESOURCE_IS_DIFFERENT or + ENTRY_DOES_NOT_EXIST in e.message): + LOG.info(_LI('No SnapMirror relationship to delete.')) + exc_context.reraise = False + + if release: + # If the source is unreachable, do not perform the release + try: + src_client = config_utils.get_client_for_backend( + src_backend_name, vserver_name=src_vserver) + except Exception: + src_client = None + # 3. Cleanup SnapMirror relationship on source + try: + if src_client: + src_client.release_snapmirror(src_vserver, + src_flexvol_name, + dest_vserver, + dest_flexvol_name) + except netapp_api.NaApiError as e: + with excutils.save_and_reraise_exception() as exc_context: + if (e.code == netapp_api.EOBJECTNOTFOUND or + e.code == netapp_api.ESOURCE_IS_DIFFERENT or + ENTRY_DOES_NOT_EXIST in e.message): + # Handle the case where the SnapMirror is already + # cleaned up + exc_context.reraise = False + + def update_snapmirror(self, src_backend_name, dest_backend_name, + src_flexvol_name, dest_flexvol_name): + """Schedule a SnapMirror update on the backend.""" + dest_backend_config = config_utils.get_backend_configuration( + dest_backend_name) + dest_vserver = dest_backend_config.netapp_vserver + dest_client = config_utils.get_client_for_backend( + dest_backend_name, vserver_name=dest_vserver) + + source_backend_config = config_utils.get_backend_configuration( + src_backend_name) + src_vserver = source_backend_config.netapp_vserver + + # Update SnapMirror + dest_client.update_snapmirror(src_vserver, + src_flexvol_name, + dest_vserver, + dest_flexvol_name) + + def quiesce_then_abort(self, src_backend_name, dest_backend_name, + src_flexvol_name, dest_flexvol_name): + """Quiesce a SnapMirror and wait with retries before aborting.""" + dest_backend_config = config_utils.get_backend_configuration( + dest_backend_name) + dest_vserver = dest_backend_config.netapp_vserver + dest_client = config_utils.get_client_for_backend( + dest_backend_name, vserver_name=dest_vserver) + + source_backend_config = config_utils.get_backend_configuration( + src_backend_name) + src_vserver = source_backend_config.netapp_vserver + + # 1. Attempt to quiesce, then abort + dest_client.quiesce_snapmirror(src_vserver, + src_flexvol_name, + dest_vserver, + dest_flexvol_name) + + retries = (source_backend_config.netapp_snapmirror_quiesce_timeout / + QUIESCE_RETRY_INTERVAL) + + @utils.retry(exception.NetAppDriverException, + interval=QUIESCE_RETRY_INTERVAL, + retries=retries, backoff_rate=1) + def wait_for_quiesced(): + snapmirror = dest_client.get_snapmirrors( + src_vserver, src_flexvol_name, dest_vserver, + dest_flexvol_name, + desired_attributes=['relationship-status', 'mirror-state'])[0] + if snapmirror.get('relationship-status') != 'quiesced': + msg = _("SnapMirror relationship is not quiesced.") + raise exception.NetAppDriverException(reason=msg) + + try: + wait_for_quiesced() + except exception.NetAppDriverException: + dest_client.abort_snapmirror(src_vserver, + src_flexvol_name, + dest_vserver, + dest_flexvol_name, + clear_checkpoint=False) + + def break_snapmirror(self, src_backend_name, dest_backend_name, + src_flexvol_name, dest_flexvol_name): + """Break SnapMirror relationship. + + 1. Quiesce any ongoing SnapMirror transfers + 2. Wait until SnapMirror finishes transfers and enters quiesced state + 3. Break SnapMirror + 4. Mount the destination volume so it is given a junction path + """ + dest_backend_config = config_utils.get_backend_configuration( + dest_backend_name) + dest_vserver = dest_backend_config.netapp_vserver + dest_client = config_utils.get_client_for_backend( + dest_backend_name, vserver_name=dest_vserver) + + source_backend_config = config_utils.get_backend_configuration( + src_backend_name) + src_vserver = source_backend_config.netapp_vserver + + # 1. Attempt to quiesce, then abort + self.quiesce_then_abort(src_backend_name, dest_backend_name, + src_flexvol_name, dest_flexvol_name) + + # 2. Break SnapMirror + dest_client.break_snapmirror(src_vserver, + src_flexvol_name, + dest_vserver, + dest_flexvol_name) + + # 3. Mount the destination volume and create a junction path + dest_client.mount_flexvol(dest_flexvol_name) + + def resync_snapmirror(self, src_backend_name, dest_backend_name, + src_flexvol_name, dest_flexvol_name): + """Re-sync (repair / re-establish) SnapMirror relationship.""" + dest_backend_config = config_utils.get_backend_configuration( + dest_backend_name) + dest_vserver = dest_backend_config.netapp_vserver + dest_client = config_utils.get_client_for_backend( + dest_backend_name, vserver_name=dest_vserver) + + source_backend_config = config_utils.get_backend_configuration( + src_backend_name) + src_vserver = source_backend_config.netapp_vserver + + dest_client.resync_snapmirror(src_vserver, + src_flexvol_name, + dest_vserver, + dest_flexvol_name) + + def resume_snapmirror(self, src_backend_name, dest_backend_name, + src_flexvol_name, dest_flexvol_name): + """Resume SnapMirror relationship from a quiesced state.""" + dest_backend_config = config_utils.get_backend_configuration( + dest_backend_name) + dest_vserver = dest_backend_config.netapp_vserver + dest_client = config_utils.get_client_for_backend( + dest_backend_name, vserver_name=dest_vserver) + + source_backend_config = config_utils.get_backend_configuration( + src_backend_name) + src_vserver = source_backend_config.netapp_vserver + + dest_client.resume_snapmirror(src_vserver, + src_flexvol_name, + dest_vserver, + dest_flexvol_name) + + def create_destination_flexvol(self, src_backend_name, dest_backend_name, + src_flexvol_name, dest_flexvol_name): + """Create a SnapMirror mirror target FlexVol for a given source.""" + dest_backend_config = config_utils.get_backend_configuration( + dest_backend_name) + dest_vserver = dest_backend_config.netapp_vserver + dest_client = config_utils.get_client_for_backend( + dest_backend_name, vserver_name=dest_vserver) + + source_backend_config = config_utils.get_backend_configuration( + src_backend_name) + src_vserver = source_backend_config.netapp_vserver + src_client = config_utils.get_client_for_backend( + src_backend_name, vserver_name=src_vserver) + + provisioning_options = ( + src_client.get_provisioning_options_from_flexvol( + src_flexvol_name) + ) + + # Remove size and volume_type + size = provisioning_options.pop('size', None) + if not size: + msg = _("Unable to read the size of the source FlexVol (%s) " + "to create a SnapMirror destination.") + raise exception.NetAppDriverException(msg % src_flexvol_name) + provisioning_options.pop('volume_type', None) + + source_aggregate = provisioning_options.pop('aggregate') + aggregate_map = self._get_replication_aggregate_map( + src_backend_name, dest_backend_name) + + if not aggregate_map.get(source_aggregate): + msg = _("Unable to find configuration matching the source " + "aggregate (%s) and the destination aggregate. Option " + "netapp_replication_aggregate_map may be incorrect.") + raise exception.NetAppDriverException( + message=msg % source_aggregate) + + destination_aggregate = aggregate_map[source_aggregate] + + # NOTE(gouthamr): The volume is intentionally created as a Data + # Protection volume; junction-path will be added on breaking + # the mirror. + dest_client.create_flexvol(dest_flexvol_name, + destination_aggregate, + size, + volume_type='dp', + **provisioning_options) + + def ensure_snapmirrors(self, config, src_backend_name, src_flexvol_names): + """Ensure all the SnapMirrors needed for whole-backend replication.""" + backend_names = self.get_replication_backend_names(config) + for dest_backend_name in backend_names: + for src_flexvol_name in src_flexvol_names: + + dest_flexvol_name = src_flexvol_name + + self.create_snapmirror(src_backend_name, + dest_backend_name, + src_flexvol_name, + dest_flexvol_name) + + def break_snapmirrors(self, config, src_backend_name, src_flexvol_names, + chosen_target): + """Break all existing SnapMirror relationships for a given back end.""" + failed_to_break = [] + backend_names = self.get_replication_backend_names(config) + for dest_backend_name in backend_names: + for src_flexvol_name in src_flexvol_names: + + dest_flexvol_name = src_flexvol_name + try: + self.break_snapmirror(src_backend_name, + dest_backend_name, + src_flexvol_name, + dest_flexvol_name) + except netapp_api.NaApiError: + msg = _("Unable to break SnapMirror between FlexVol " + "%(src)s and Flexvol %(dest)s. Associated volumes " + "will have their replication state set to error.") + payload = { + 'src': ':'.join([src_backend_name, src_flexvol_name]), + 'dest': ':'.join([dest_backend_name, + dest_flexvol_name]), + } + if dest_backend_name == chosen_target: + failed_to_break.append(src_flexvol_name) + LOG.exception(msg, payload) + + return failed_to_break + + def update_snapmirrors(self, config, src_backend_name, src_flexvol_names): + """Update all existing SnapMirror relationships on a given back end.""" + backend_names = self.get_replication_backend_names(config) + for dest_backend_name in backend_names: + for src_flexvol_name in src_flexvol_names: + + dest_flexvol_name = src_flexvol_name + try: + self.update_snapmirror(src_backend_name, + dest_backend_name, + src_flexvol_name, + dest_flexvol_name) + except netapp_api.NaApiError: + # Ignore any errors since the current source may be + # unreachable + pass + + def _choose_failover_target(self, backend_name, flexvols, + replication_targets): + target_lag_times = [] + + for target in replication_targets: + all_target_mirrors = self.get_snapmirrors( + backend_name, target, None, None) + flexvol_mirrors = self._filter_and_sort_mirrors( + all_target_mirrors, flexvols) + + if not flexvol_mirrors: + msg = ("Ignoring replication target %(target)s because no " + "SnapMirrors were found for any of the flexvols " + "in (%(flexvols)s).") + payload = { + 'flexvols': ', '.join(flexvols), + 'target': target, + } + LOG.debug(msg, payload) + continue + + target_lag_times.append( + { + 'target': target, + 'highest-lag-time': flexvol_mirrors[0]['lag-time'], + } + ) + + # The best target is one with the least 'worst' lag time. + best_target = (sorted(target_lag_times, + key=lambda x: int(x['highest-lag-time']))[0] + if len(target_lag_times) > 0 else {}) + + return best_target.get('target') + + def _filter_and_sort_mirrors(self, mirrors, flexvols): + """Return mirrors reverse-sorted by lag time. + + The 'slowest' mirror determines the best update that occurred on a + given replication target. + """ + filtered_mirrors = list(filter(lambda x: x.get('destination-volume') + in flexvols, mirrors)) + sorted_mirrors = sorted(filtered_mirrors, + key=lambda x: int(x.get('lag-time')), + reverse=True) + + return sorted_mirrors + + def _complete_failover(self, source_backend_name, replication_targets, + flexvols, volumes, failover_target=None): + """Failover a backend to a secondary replication target.""" + volume_updates = [] + + active_backend_name = failover_target or self._choose_failover_target( + source_backend_name, flexvols, replication_targets) + + if active_backend_name is None: + msg = _("No suitable host was found to failover.") + raise exception.NetAppDriverException(msg) + + source_backend_config = config_utils.get_backend_configuration( + source_backend_name) + + # 1. Start an update to try to get a last minute transfer before we + # quiesce and break + self.update_snapmirrors(source_backend_config, source_backend_name, + flexvols) + # 2. Break SnapMirrors + failed_to_break = self.break_snapmirrors(source_backend_config, + source_backend_name, + flexvols, active_backend_name) + + # 3. Update cinder volumes within this host + for volume in volumes: + replication_status = fields.ReplicationStatus.FAILED_OVER + volume_pool = volume_utils.extract_host(volume['host'], + level='pool') + if volume_pool in failed_to_break: + replication_status = 'error' + + volume_update = { + 'volume_id': volume['id'], + 'updates': { + 'replication_status': replication_status, + }, + } + volume_updates.append(volume_update) + + return active_backend_name, volume_updates + + def _failover_host(self, volumes, secondary_id=None): + + if secondary_id == self.backend_name: + msg = _("Cannot failover to the same host as the primary.") + raise exception.InvalidReplicationTarget(reason=msg) + + replication_targets = self.get_replication_backend_names( + self.configuration) + + if not replication_targets: + msg = _("No replication targets configured for backend " + "%s. Cannot failover.") + raise exception.InvalidReplicationTarget(reason=msg % self.host) + elif secondary_id and secondary_id not in replication_targets: + msg = _("%(target)s is not among replication targets configured " + "for back end %(host)s. Cannot failover.") + payload = { + 'target': secondary_id, + 'host': self.host, + } + raise exception.InvalidReplicationTarget(reason=msg % payload) + + flexvols = self.ssc_library.get_ssc_flexvol_names() + + try: + active_backend_name, volume_updates = self._complete_failover( + self.backend_name, replication_targets, flexvols, volumes, + failover_target=secondary_id) + except exception.NetAppDriverException as e: + msg = _("Could not complete failover: %s") % e + raise exception.UnableToFailOver(reason=msg) + + # Update the ZAPI client to the backend we failed over to + self._update_zapi_client(active_backend_name) + + self.failed_over = True + self.failed_over_backend_name = active_backend_name + + return active_backend_name, volume_updates diff --git a/cinder/volume/drivers/netapp/dataontap/utils/utils.py b/cinder/volume/drivers/netapp/dataontap/utils/utils.py new file mode 100644 index 00000000000..b79b92c193b --- /dev/null +++ b/cinder/volume/drivers/netapp/dataontap/utils/utils.py @@ -0,0 +1,74 @@ +# 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. +""" +Utilities for NetApp FAS drivers. + +This module contains common utilities to be used by one or more +NetApp FAS drivers to achieve the desired functionality. +""" + +from oslo_config import cfg +from oslo_log import log + +from cinder import exception +from cinder.i18n import _ +from cinder import utils +from cinder.volume import configuration +from cinder.volume import driver +from cinder.volume.drivers.netapp.dataontap.client import client_cmode +from cinder.volume.drivers.netapp import options as na_opts + +LOG = log.getLogger(__name__) +CONF = cfg.CONF + + +def get_backend_configuration(backend_name): + """Get a cDOT configuration object for a specific backend.""" + + config_stanzas = CONF.list_all_sections() + if backend_name not in config_stanzas: + msg = _("Could not find backend stanza %(backend_name)s in " + "configuration. Available stanzas are %(stanzas)s") + params = { + "stanzas": config_stanzas, + "backend_name": backend_name, + } + raise exception.ConfigNotFound(message=msg % params) + + config = configuration.Configuration(driver.volume_opts, + config_group=backend_name) + config.append_config_values(na_opts.netapp_proxy_opts) + config.append_config_values(na_opts.netapp_connection_opts) + config.append_config_values(na_opts.netapp_transport_opts) + config.append_config_values(na_opts.netapp_basicauth_opts) + config.append_config_values(na_opts.netapp_provisioning_opts) + config.append_config_values(na_opts.netapp_cluster_opts) + config.append_config_values(na_opts.netapp_san_opts) + config.append_config_values(na_opts.netapp_replication_opts) + + return config + + +def get_client_for_backend(backend_name, vserver_name=None): + """Get a cDOT API client for a specific backend.""" + + config = get_backend_configuration(backend_name) + client = client_cmode.Client( + transport_type=config.netapp_transport_type, + username=config.netapp_login, + password=config.netapp_password, + hostname=config.netapp_server_hostname, + port=config.netapp_server_port, + vserver=vserver_name or config.netapp_vserver, + trace=utils.TRACE_API) + + return client diff --git a/cinder/volume/drivers/netapp/options.py b/cinder/volume/drivers/netapp/options.py index 0967b1827b5..4d3564424cf 100644 --- a/cinder/volume/drivers/netapp/options.py +++ b/cinder/volume/drivers/netapp/options.py @@ -25,6 +25,7 @@ place to ensure re usability and better management of configuration options. """ from oslo_config import cfg +from oslo_config import types NETAPP_SIZE_MULTIPLIER_DEFAULT = 1.2 @@ -187,6 +188,30 @@ netapp_san_opts = [ 'is only utilized when the storage protocol is ' 'configured to use iSCSI or FC.')), ] +netapp_replication_opts = [ + cfg.MultiOpt('netapp_replication_aggregate_map', + item_type=types.Dict(), + help="Multi opt of dictionaries to represent the aggregate " + "mapping between source and destination back ends when " + "using whole back end replication. For every " + "source aggregate associated with a cinder pool (NetApp " + "FlexVol), you would need to specify the destination " + "aggregate on the replication target device. A " + "replication target device is configured with the " + "configuration option replication_device. Specify this " + "option as many times as you have replication devices. " + "Each entry takes the standard dict config form: " + "netapp_replication_aggregate_map = " + "backend_id:," + "src_aggr_name1:dest_aggr_name1," + "src_aggr_name2:dest_aggr_name2,..."), + cfg.IntOpt('netapp_snapmirror_quiesce_timeout', + min=0, + default=3600, # One Hour + help='The maximum time in seconds to wait for existing ' + 'SnapMirror transfers to complete before aborting ' + 'during a failover.'), ] + CONF = cfg.CONF CONF.register_opts(netapp_proxy_opts) CONF.register_opts(netapp_connection_opts) @@ -199,3 +224,4 @@ CONF.register_opts(netapp_img_cache_opts) CONF.register_opts(netapp_eseries_opts) CONF.register_opts(netapp_nfs_extra_opts) CONF.register_opts(netapp_san_opts) +CONF.register_opts(netapp_replication_opts) diff --git a/releasenotes/notes/netapp-cDOT-whole-backend-replication-support-59d7537fe3d0eb05.yaml b/releasenotes/notes/netapp-cDOT-whole-backend-replication-support-59d7537fe3d0eb05.yaml new file mode 100644 index 00000000000..16864456d2e --- /dev/null +++ b/releasenotes/notes/netapp-cDOT-whole-backend-replication-support-59d7537fe3d0eb05.yaml @@ -0,0 +1,8 @@ +--- +features: + - Added host-level (whole back end replication - v2.1) replication support + to the NetApp cDOT drivers (iSCSI, FC, NFS). +upgrade: + - While configuring NetApp cDOT back ends, new configuration options + ('replication_device' and 'netapp_replication_aggregate_map') must be + added in order to use the host-level failover feature.