def _get_vservers_from_replicas(self, context, replica_list, new_replica):
active_replica = self.find_active_replica(replica_list)
dm_session = data_motion.DataMotionSession()
vserver = dm_session.get_vserver_from_share(active_replica)
peer_vserver = dm_session.get_vserver_from_share(new_replica)
return vserver, peer_vserver
def create_share_from_snapshot(self,
context,
share,
snapshot,
share_server=None,
parent_share=None):
# NOTE(dviroel): If both parent and child shares are in the same host,
# they belong to the same cluster, and we can skip all the processing
# below.
if parent_share['host'] != share['host']:
# 1. Retrieve source and destination vservers from source and
# destination shares
new_share = copy.deepcopy(share.to_dict())
new_share['share_server'] = share_server.to_dict()
dm_session = data_motion.DataMotionSession()
src_vserver = dm_session.get_vserver_from_share(parent_share)
dest_vserver = dm_session.get_vserver_from_share(new_share)
# 2. Retrieve the source share host's client and cluster name
src_share_host = share_utils.extract_host(parent_share['host'],
level='backend_name')
src_share_client = data_motion.get_client_for_backend(
src_share_host, vserver_name=src_vserver)
# Cluster name is needed for setting up the vserver peering
src_share_cluster_name = src_share_client.get_cluster_name()
# 3. Retrieve new share host's client
dest_share_host = share_utils.extract_host(new_share['host'],
level='backend_name')
dest_share_client = data_motion.get_client_for_backend(
dest_share_host, vserver_name=dest_vserver)
dest_share_cluster_name = dest_share_client.get_cluster_name()
# If source and destination shares are placed in a different
# clusters, we'll need the both vserver peered.
if src_share_cluster_name != dest_share_cluster_name:
if not self._get_vserver_peers(dest_vserver, src_vserver):
# 3.1. Request vserver peer creation from new_replica's
# host to active replica's host
dest_share_client.create_vserver_peer(
dest_vserver,
src_vserver,
peer_cluster_name=src_share_cluster_name)
# 3.2. Accepts the vserver peering using active replica
# host's client
src_share_client.accept_vserver_peer(
src_vserver, dest_vserver)
return (super(NetAppCmodeMultiSVMFileStorageLibrary,
self).create_share_from_snapshot(
context,
share,
snapshot,
share_server=share_server,
parent_share=parent_share))
def setUp(self):
super(NetAppCDOTDataMotionSessionTestCase, self).setUp()
self.source_backend = 'backend1'
self.dest_backend = 'backend2'
config = configuration.Configuration(driver.share_opts,
config_group=self.source_backend)
config.append_config_values(na_opts.netapp_cluster_opts)
config.append_config_values(na_opts.netapp_connection_opts)
config.append_config_values(na_opts.netapp_basicauth_opts)
config.append_config_values(na_opts.netapp_transport_opts)
config.append_config_values(na_opts.netapp_support_opts)
config.append_config_values(na_opts.netapp_provisioning_opts)
config.append_config_values(na_opts.netapp_data_motion_opts)
self.mock_object(data_motion, "get_backend_configuration",
mock.Mock(return_value=config))
self.mock_cmode_client = self.mock_object(client_cmode,
"NetAppCmodeClient",
mock.Mock())
self.dm_session = data_motion.DataMotionSession()
self.fake_src_share = copy.deepcopy(fake.SHARE)
self.fake_src_share_server = copy.deepcopy(fake.SHARE_SERVER)
self.source_vserver = 'source_vserver'
self.source_backend_name = (
self.fake_src_share_server['host'].split('@')[1])
self.fake_src_share_server['backend_details']['vserver_name'] = (
self.source_vserver)
self.fake_src_share['share_server'] = self.fake_src_share_server
self.fake_src_share['id'] = 'c02d497a-236c-4852-812a-0d39373e312a'
self.fake_src_vol_name = 'share_c02d497a_236c_4852_812a_0d39373e312a'
self.fake_dest_share = copy.deepcopy(fake.SHARE)
self.fake_dest_share_server = copy.deepcopy(fake.SHARE_SERVER_2)
self.dest_vserver = 'dest_vserver'
self.dest_backend_name = (
self.fake_dest_share_server['host'].split('@')[1])
self.fake_dest_share_server['backend_details']['vserver_name'] = (
self.dest_vserver)
self.fake_dest_share['share_server'] = self.fake_dest_share_server
self.fake_dest_share['id'] = '34fbaf57-745d-460f-8270-3378c2945e30'
self.fake_dest_vol_name = 'share_34fbaf57_745d_460f_8270_3378c2945e30'
self.mock_src_client = mock.Mock()
self.mock_dest_client = mock.Mock()
self.mock_object(
data_motion, 'get_client_for_backend',
mock.Mock(
side_effect=[self.mock_dest_client, self.mock_src_client]))
self.mock_object(
self.dm_session, 'get_client_and_vserver_name',
mock.Mock(side_effect=[(
self.mock_src_client,
self.source_vserver), (self.mock_dest_client,
self.dest_vserver)]))
def test_get_client_and_vserver_name(self):
dm_session = data_motion.DataMotionSession()
client = mock.Mock()
self.mock_object(data_motion, 'get_client_for_backend',
mock.Mock(return_value=client))
result = dm_session.get_client_and_vserver_name(fake.SHARE_SERVER)
expected = (client,
fake.SHARE_SERVER['backend_details']['vserver_name'])
self.assertEqual(expected, result)
data_motion.get_client_for_backend.assert_called_once_with(
fake.BACKEND_NAME, vserver_name=fake.VSERVER1)
