def test_migration_start(self):
share = "fake_share"
host = "fake_host"
version = api_versions.APIVersion('2.29')
manager = shares.ShareManager(
api=fakes.FakeClient(api_version=version))
with mock.patch.object(manager, "_action",
mock.Mock(return_value="fake")):
result = manager.migration_start(
share, host, force_host_assisted_migration=True,
preserve_metadata=True, writable=True, nondisruptive=True,
preserve_snapshots=True)
manager._action.assert_called_once_with(
'migration_start', share, {
"host": host,
"force_host_assisted_migration": True,
"preserve_metadata": True,
"writable": True,
"nondisruptive": True,
"preserve_snapshots": True,
"new_share_network_id": None,
"new_share_type_id": None,
})
self.assertEqual("fake", result)
def test_migration_cancel(self):
share = "fake_share"
manager = shares.ShareManager(api=fakes.FakeClient())
with mock.patch.object(manager, "_action",
mock.Mock(return_value="fake")):
result = manager.migration_cancel(share)
manager._action.assert_called_once_with("migration_cancel", share)
self.assertEqual("fake", result)
def test_revert_to_snapshot_not_supported(self):
share = 'fake_share'
snapshot = 'fake_snapshot'
version = api_versions.APIVersion("2.26")
mock_microversion = mock.Mock(api_version=version)
manager = shares.ShareManager(api=mock_microversion)
self.assertRaises(client_exceptions.UnsupportedVersion,
manager.revert_to_snapshot, share, snapshot)
def test_force_delete_share(self, microversion, action_name):
share = "fake_share"
version = api_versions.APIVersion(microversion)
mock_microversion = mock.Mock(api_version=version)
manager = shares.ShareManager(api=mock_microversion)
with mock.patch.object(manager, "_action",
mock.Mock(return_value="fake")):
result = manager.force_delete(share)
manager._action.assert_called_once_with(action_name, share)
self.assertEqual("fake", result)
def test_reset_task_state(self):
share = "fake_share"
state = "fake_state"
manager = shares.ShareManager(api=fakes.FakeClient())
with mock.patch.object(manager, "_action",
mock.Mock(return_value="fake")):
result = manager.reset_task_state(share, state)
manager._action.assert_called_once_with(
"reset_task_state", share, {'task_state': state})
self.assertEqual("fake", result)
def test_unmanage_share_v2_7(self):
share = "fake_share"
version = api_versions.APIVersion("2.7")
mock_microversion = mock.Mock(api_version=version)
manager = shares.ShareManager(api=mock_microversion)
with mock.patch.object(manager, "_action",
mock.Mock(return_value="fake")):
result = manager.unmanage(share)
manager._action.assert_called_once_with("unmanage", share)
self.assertEqual("fake", result)
def test_migration_get_progress(self):
share = "fake_share"
version = api_versions.APIVersion("2.13")
mock_microversion = mock.Mock(api_version=version)
manager = shares.ShareManager(api=mock_microversion)
with mock.patch.object(manager, "_action",
mock.Mock(return_value="fake")):
result = manager.migration_get_progress(share)
manager._action.assert_called_once_with(
"migration_get_progress", share)
self.assertEqual("fake", result)
def test_manage_share(self,
microversion,
resource_path,
is_public=False,
share_server_id=None):
service_host = "fake_service_host"
protocol = "fake_protocol"
export_path = "fake_export_path"
driver_options = "fake_driver_options"
share_type = "fake_share_type"
name = "foo_name"
description = "bar_description"
expected_body = {
"service_host": service_host,
"share_type": share_type,
"protocol": protocol,
"export_path": export_path,
"driver_options": driver_options,
"name": name,
"description": description,
"share_server_id": share_server_id,
}
version = api_versions.APIVersion(microversion)
if version >= api_versions.APIVersion('2.8'):
expected_body["is_public"] = is_public
mock_microversion = mock.Mock(api_version=version)
manager = shares.ShareManager(api=mock_microversion)
with mock.patch.object(manager, "_create",
mock.Mock(return_value="fake")):
if version < api_versions.APIVersion('2.8'):
result = manager.manage(service_host, protocol, export_path,
driver_options, share_type, name,
description)
elif (api_versions.APIVersion('2.8') <= version <
api_versions.APIVersion('2.49')):
result = manager.manage(service_host, protocol, export_path,
driver_options, share_type, name,
description, is_public)
else:
result = manager.manage(service_host, protocol, export_path,
driver_options, share_type, name,
description, is_public,
share_server_id)
self.assertEqual(manager._create.return_value, result)
manager._create.assert_called_once_with(resource_path,
{"share": expected_body},
"share")
def test_shrink_share(self, microversion, action_name):
size = 123
share = "fake_share"
version = api_versions.APIVersion(microversion)
mock_microversion = mock.Mock(api_version=version)
manager = shares.ShareManager(api=mock_microversion)
with mock.patch.object(manager, "_action",
mock.Mock(return_value="fake")):
result = manager.shrink(share, size)
manager._action.assert_called_once_with(
action_name, share, {"new_size": size})
self.assertEqual("fake", result)
def test_deny_access_to_share(self, microversion, action_name):
access_id = "fake_access_id"
share = "fake_share"
version = api_versions.APIVersion(microversion)
mock_microversion = mock.Mock(api_version=version)
manager = shares.ShareManager(api=mock_microversion)
with mock.patch.object(manager, "_action",
mock.Mock(return_value="fake")):
result = manager.deny(share, access_id)
manager._action.assert_called_once_with(
action_name, share, {"access_id": access_id})
self.assertEqual("fake", result)
def test_reset_share_state(self, microversion, action_name):
state = "available"
share = "fake_share"
version = api_versions.APIVersion(microversion)
mock_microversion = mock.Mock(api_version=version)
manager = shares.ShareManager(api=mock_microversion)
with mock.patch.object(manager, "_action",
mock.Mock(return_value="fake")):
result = manager.reset_state(share, state)
manager._action.assert_called_once_with(
action_name, share, {"status": state})
self.assertEqual("fake", result)
def test_unmanage_share_v2_6(self, share):
version = api_versions.APIVersion("2.6")
mock_microversion = mock.Mock(api_version=version)
manager = shares.ShareManager(api=mock_microversion)
with mock.patch.object(manager, "_action",
mock.Mock(return_value="fake")):
result = manager.unmanage(share)
self.assertFalse(manager._action.called)
self.assertNotEqual("fake", result)
self.assertEqual(manager.api.client.post.return_value, result)
manager.api.client.post.assert_called_once_with(
"/os-share-unmanage/1234/unmanage")
def test_reset_task_state(self):
share = "fake_share"
state = "fake_state"
version = api_versions.APIVersion("2.13")
mock_microversion = mock.Mock(api_version=version)
manager = shares.ShareManager(api=mock_microversion)
with mock.patch.object(manager, "_action",
mock.Mock(return_value="fake")):
result = manager.reset_task_state(share, state)
manager._action.assert_called_once_with(
"reset_task_state", share, {'task_state': state})
self.assertEqual("fake", result)
def test_allow_access_to_share_error_invalid_access(
self, access_to, access_type, microversion):
access = ('foo', {'access': 'bar'})
access_level = 'fake_access_level'
share = 'fake_share'
version = api_versions.APIVersion(microversion)
mock_microversion = mock.Mock(api_version=version)
manager = shares.ShareManager(api=mock_microversion)
with mock.patch.object(manager, '_action',
mock.Mock(return_value=access)):
self.assertRaises(exceptions.CommandError, manager.allow, share,
access_type, access_to, access_level)
manager._action.assert_not_called()
def test_revert_to_snapshot(self):
share = 'fake_share'
snapshot = 'fake_snapshot'
version = api_versions.APIVersion("2.27")
mock_microversion = mock.Mock(api_version=version)
manager = shares.ShareManager(api=mock_microversion)
mock_action = self.mock_object(
manager, '_action', mock.Mock(return_value='fake'))
result = manager.revert_to_snapshot(share, snapshot)
self.assertEqual('fake', result)
mock_action.assert_called_once_with(
'revert', 'fake_share', info={'snapshot_id': 'fake_snapshot'})
def test_allow_access_to_share(self, access_to, access_type,
action_name, microversion):
access = ('foo', {'access': 'bar'})
access_level = 'fake_access_level'
share = 'fake_share'
version = api_versions.APIVersion(microversion)
mock_microversion = mock.Mock(api_version=version)
manager = shares.ShareManager(api=mock_microversion)
with mock.patch.object(manager, '_action',
mock.Mock(return_value=access)):
result = manager.allow(share, access_type, access_to, access_level)
manager._action.assert_called_once_with(
action_name, share, {'access_level': access_level,
'access_type': access_type,
'access_to': access_to})
self.assertEqual('bar', result)
def test_migrate_share(self, microversion, action_name):
share = "fake_share"
host = "fake_host"
force_host_copy = "fake_force_host_copy"
version = api_versions.APIVersion(microversion)
mock_microversion = mock.Mock(api_version=version)
manager = shares.ShareManager(api=mock_microversion)
with mock.patch.object(manager, "_action",
mock.Mock(return_value="fake")):
result = manager.migrate_share(share, host, force_host_copy)
manager._action.assert_called_once_with(
action_name, share, {
"host": host,
"force_host_copy": force_host_copy
})
self.assertEqual("fake", result)
def test_extend_share(self, microversion, action_name, force):
size = 123
share = "fake_share"
version = api_versions.APIVersion(microversion)
mock_microversion = mock.Mock(api_version=version)
manager = shares.ShareManager(api=mock_microversion)
with mock.patch.object(manager, "_action",
mock.Mock(return_value="fake")):
if not force:
result = manager.extend(share, size)
manager._action.assert_called_once_with(
action_name, share, {"new_size": size})
else:
result = manager.extend(share, size, force=force)
manager._action.assert_called_once_with(
action_name, share, {"new_size": size,
"force": "true"})
self.assertEqual("fake", result)
def test_allow_access_to_share(self, microversion, action_name):
access_level = "fake_access_level"
access_to = "fake_access_to"
access_type = "fake_access_type"
share = "fake_share"
access = ("foo", {"access": "bar"})
version = api_versions.APIVersion(microversion)
mock_microversion = mock.Mock(api_version=version)
manager = shares.ShareManager(api=mock_microversion)
with mock.patch.object(manager, "_action",
mock.Mock(return_value=access)):
result = manager.allow(share, access_type, access_to, access_level)
manager._action.assert_called_once_with(
action_name, share, {"access_level": access_level,
"access_type": access_type,
"access_to": access_to})
self.assertEqual("bar", result)
def __init__(self,
username=None,
api_key=None,
project_id=None,
auth_url=None,
insecure=False,
timeout=None,
tenant_id=None,
project_name=None,
region_name=None,
endpoint_type='publicURL',
extensions=None,
service_type=constants.V2_SERVICE_TYPE,
service_name=None,
retries=None,
http_log_debug=False,
input_auth_token=None,
session=None,
auth=None,
cacert=None,
service_catalog_url=None,
user_agent='python-manilaclient',
use_keyring=False,
force_new_token=False,
cached_token_lifetime=300,
api_version=manilaclient.API_MIN_VERSION,
user_id=None,
user_domain_id=None,
user_domain_name=None,
project_domain_id=None,
project_domain_name=None,
cert=None,
password=None,
**kwargs):
self.username = username
self.password = password or api_key
self.tenant_id = tenant_id or project_id
self.tenant_name = project_name
self.user_id = user_id
self.project_id = project_id or tenant_id
self.project_name = project_name
self.user_domain_id = user_domain_id
self.user_domain_name = user_domain_name
self.project_domain_id = project_domain_id
self.project_domain_name = project_domain_name
self.endpoint_type = endpoint_type
self.auth_url = auth_url
self.region_name = region_name
self.cacert = cacert
self.cert = cert
self.insecure = insecure
self.use_keyring = use_keyring
self.force_new_token = force_new_token
self.cached_token_lifetime = cached_token_lifetime
service_name = kwargs.get("share_service_name", service_name)
def check_deprecated_arguments():
deprecated = {
'share_service_name': 'service_name',
'proxy_tenant_id': None,
'proxy_token': None,
'os_cache': 'use_keyring',
'api_key': 'password',
}
for arg, replacement in six.iteritems(deprecated):
if kwargs.get(arg, None) is None:
continue
replacement_msg = ""
if replacement is not None:
replacement_msg = " Use %s instead." % replacement
msg = "Argument %(arg)s is deprecated.%(repl)s" % {
'arg': arg,
'repl': replacement_msg
}
warnings.warn(msg)
check_deprecated_arguments()
if input_auth_token and not service_catalog_url:
msg = ("For token-based authentication you should "
"provide 'input_auth_token' and 'service_catalog_url'.")
raise exceptions.ClientException(msg)
self.project_id = tenant_id if tenant_id is not None else project_id
self.keystone_client = None
self.session = session
# NOTE(u_glide): token authorization has highest priority.
# That's why session and/or password will be ignored
# if token is provided.
if not input_auth_token:
if session:
self.keystone_client = adapter.LegacyJsonAdapter(
session=session,
auth=auth,
interface=endpoint_type,
service_type=service_type,
service_name=service_name,
region_name=region_name)
input_auth_token = self.keystone_client.session.get_token(auth)
else:
self.keystone_client = self._get_keystone_client()
input_auth_token = self.keystone_client.auth_token
if not input_auth_token:
raise RuntimeError("Not Authorized")
if session and not service_catalog_url:
service_catalog_url = self.keystone_client.session.get_endpoint(
auth, interface=endpoint_type, service_type=service_type)
elif not service_catalog_url:
catalog = self.keystone_client.service_catalog.get_endpoints(
service_type)
for catalog_entry in catalog.get(service_type, []):
if (catalog_entry.get("interface")
== (endpoint_type.lower().split("url")[0])
or catalog_entry.get(endpoint_type)):
if (region_name and not region_name == (catalog_entry.get(
"region", catalog_entry.get("region_id")))):
continue
service_catalog_url = catalog_entry.get(
"url", catalog_entry.get(endpoint_type))
break
if not service_catalog_url:
raise RuntimeError("Could not find Manila endpoint in catalog")
self.api_version = api_version
self.client = httpclient.HTTPClient(service_catalog_url,
input_auth_token,
user_agent,
insecure=insecure,
cacert=cacert,
timeout=timeout,
retries=retries,
http_log_debug=http_log_debug,
api_version=self.api_version)
self.limits = limits.LimitsManager(self)
self.services = services.ServiceManager(self)
self.security_services = security_services.SecurityServiceManager(self)
self.share_networks = share_networks.ShareNetworkManager(self)
self.quota_classes = quota_classes.QuotaClassSetManager(self)
self.quotas = quotas.QuotaSetManager(self)
self.shares = shares.ShareManager(self)
self.share_instances = share_instances.ShareInstanceManager(self)
self.share_snapshots = share_snapshots.ShareSnapshotManager(self)
self.share_types = share_types.ShareTypeManager(self)
self.share_type_access = share_type_access.ShareTypeAccessManager(self)
self.share_servers = share_servers.ShareServerManager(self)
self.pools = scheduler_stats.PoolManager(self)
self.consistency_groups = (
consistency_groups.ConsistencyGroupManager(self))
self.cg_snapshots = (
cg_snapshots.ConsistencyGroupSnapshotManager(self))
self._load_extensions(extensions)
def __init__(self,
username=None,
project_id=None,
auth_url=None,
insecure=False,
timeout=None,
tenant_id=None,
project_name=None,
region_name=None,
endpoint_type='publicURL',
extensions=None,
service_type=constants.V2_SERVICE_TYPE,
service_name=None,
retries=None,
http_log_debug=False,
input_auth_token=None,
session=None,
auth=None,
cacert=None,
service_catalog_url=None,
user_agent='python-manilaclient',
use_keyring=False,
force_new_token=False,
cached_token_lifetime=300,
api_version=manilaclient.API_MIN_VERSION,
user_id=None,
user_domain_id=None,
user_domain_name=None,
project_domain_id=None,
project_domain_name=None,
cert=None,
password=None,
**kwargs):
self.username = username
self.password = password
self.tenant_id = tenant_id or project_id
self.tenant_name = project_name
self.user_id = user_id
self.project_id = project_id or tenant_id
self.project_name = project_name
self.user_domain_id = user_domain_id
self.user_domain_name = user_domain_name
self.project_domain_id = project_domain_id
self.project_domain_name = project_domain_name
self.endpoint_type = endpoint_type
self.auth_url = auth_url
self.region_name = region_name
self.cacert = cacert
self.cert = cert
self.insecure = insecure
self.use_keyring = use_keyring
self.force_new_token = force_new_token
self.cached_token_lifetime = cached_token_lifetime
if input_auth_token and not service_catalog_url:
msg = ("For token-based authentication you should "
"provide 'input_auth_token' and 'service_catalog_url'.")
raise exceptions.ClientException(msg)
self.project_id = tenant_id if tenant_id is not None else project_id
self.keystone_client = None
self.session = session
# NOTE(u_glide): token authorization has highest priority.
# That's why session and/or password will be ignored
# if token is provided.
if not input_auth_token:
if session:
self.keystone_client = adapter.LegacyJsonAdapter(
session=session,
auth=auth,
interface=endpoint_type,
service_type=service_type,
service_name=service_name,
region_name=region_name)
input_auth_token = self.keystone_client.session.get_token(auth)
else:
self.keystone_client = self._get_keystone_client()
input_auth_token = self.keystone_client.auth_token
if not input_auth_token:
raise RuntimeError("Not Authorized")
if session and not service_catalog_url:
service_catalog_url = self.keystone_client.session.get_endpoint(
auth, interface=endpoint_type, service_type=service_type)
elif not service_catalog_url:
catalog = self.keystone_client.service_catalog.get_endpoints(
service_type)
for catalog_entry in catalog.get(service_type, []):
if (catalog_entry.get("interface")
== (endpoint_type.lower().split("url")[0])
or catalog_entry.get(endpoint_type)):
if (region_name and not region_name == (catalog_entry.get(
"region", catalog_entry.get("region_id")))):
continue
service_catalog_url = catalog_entry.get(
"url", catalog_entry.get(endpoint_type))
break
if not service_catalog_url:
raise RuntimeError("Could not find Manila endpoint in catalog")
self.api_version = api_version
self.client = httpclient.HTTPClient(service_catalog_url,
input_auth_token,
user_agent,
insecure=insecure,
cacert=cacert,
cert=cert,
timeout=timeout,
retries=retries,
http_log_debug=http_log_debug,
api_version=self.api_version)
self.availability_zones = availability_zones.AvailabilityZoneManager(
self)
self.limits = limits.LimitsManager(self)
self.messages = messages.MessageManager(self)
self.services = services.ServiceManager(self)
self.security_services = security_services.SecurityServiceManager(self)
self.share_networks = share_networks.ShareNetworkManager(self)
self.share_network_subnets = (
share_network_subnets.ShareNetworkSubnetManager(self))
self.quota_classes = quota_classes.QuotaClassSetManager(self)
self.quotas = quotas.QuotaSetManager(self)
self.shares = shares.ShareManager(self)
self.share_export_locations = (
share_export_locations.ShareExportLocationManager(self))
self.share_groups = share_groups.ShareGroupManager(self)
self.share_group_snapshots = (
share_group_snapshots.ShareGroupSnapshotManager(self))
self.share_group_type_access = (
share_group_type_access.ShareGroupTypeAccessManager(self))
self.share_group_types = share_group_types.ShareGroupTypeManager(self)
self.share_instances = share_instances.ShareInstanceManager(self)
self.share_instance_export_locations = (
share_instance_export_locations.ShareInstanceExportLocationManager(
self))
self.share_snapshots = share_snapshots.ShareSnapshotManager(self)
self.share_snapshot_instances = (
share_snapshot_instances.ShareSnapshotInstanceManager(self))
self.share_snapshot_export_locations = (
share_snapshot_export_locations.ShareSnapshotExportLocationManager(
self))
self.share_snapshot_instance_export_locations = (
share_snapshot_instance_export_locations.
ShareSnapshotInstanceExportLocationManager(self))
self.share_types = share_types.ShareTypeManager(self)
self.share_type_access = share_type_access.ShareTypeAccessManager(self)
self.share_servers = share_servers.ShareServerManager(self)
self.share_replicas = share_replicas.ShareReplicaManager(self)
self.share_replica_export_locations = (
share_replica_export_locations.ShareReplicaExportLocationManager(
self))
self.pools = scheduler_stats.PoolManager(self)
self.share_access_rules = (
share_access_rules.ShareAccessRuleManager(self))
self._load_extensions(extensions)
from manilaclient.v2 import share_instances
from manilaclient.v2 import share_networks
from manilaclient.v2 import share_replicas
from manilaclient.v2 import share_servers
from manilaclient.v2 import share_snapshot_export_locations
from manilaclient.v2 import share_snapshots
from manilaclient.v2 import share_types
from manilaclient.v2 import shares
class FakeAPIClient(object):
client = "fake_client"
share = shares.Share(
shares.ShareManager(FakeAPIClient), {
'id': "11023e92-8008-4c8b-8059-7f2293ff3887",
'status': 'available',
'size': 40,
'name': 'Share name',
'description': 'Share description',
'share_proto': 'NFS',
'metadata': {},
'created_at': '2014-01-27 10:30:00',
'share_server_id': '1',
'share_network_id': '7f3d1c33-8d00-4511-29df-a2def31f3b5d',
'availability_zone': 'Test AZ',
'replication_type': 'readable',
'share_group_id': 'fake_share_group_id',
'mount_snapshot_support': False
})
from manilaclient.v2 import shares
except ImportError:
# NOTE(vponomaryov): If we got here then we have old manilaclient.
from manilaclient.v1 import quotas
from manilaclient.v1 import security_services
from manilaclient.v1 import share_networks
from manilaclient.v1 import share_snapshots
from manilaclient.v1 import shares
from manilaclient.v2 import share_export_locations
from openstack_dashboard import api
from openstack_dashboard.usage import quotas as usage_quotas
share = shares.Share(
shares.ShareManager(None), {
'id': "11023e92-8008-4c8b-8059-7f2293ff3887",
'status': 'available',
'size': 40,
'name': 'Share name',
'description': 'Share description',
'share_proto': 'NFS',
'metadata': {},
'created_at': '2014-01-27 10:30:00',
'share_server_id': '1',
'share_network_id': '7f3d1c33-8d00-4511-29df-a2def31f3b5d',
'availability_zone': 'Test AZ'
})
nameless_share = shares.Share(
shares.ShareManager(None), {
