341 lines
12 KiB
Python
341 lines
12 KiB
Python
# 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.
|
|
|
|
from debtcollector import removals
|
|
from keystoneauth1 import adapter
|
|
from keystoneauth1 import identity
|
|
from keystoneauth1 import session
|
|
|
|
import manilaclient
|
|
from manilaclient.common import constants
|
|
from manilaclient.common import httpclient
|
|
from manilaclient import exceptions
|
|
from manilaclient.v2 import availability_zones
|
|
from manilaclient.v2 import limits
|
|
from manilaclient.v2 import messages
|
|
from manilaclient.v2 import qos_types
|
|
from manilaclient.v2 import quota_classes
|
|
from manilaclient.v2 import quotas
|
|
from manilaclient.v2 import resource_locks
|
|
from manilaclient.v2 import scheduler_stats
|
|
from manilaclient.v2 import security_services
|
|
from manilaclient.v2 import services
|
|
from manilaclient.v2 import share_access_rules
|
|
from manilaclient.v2 import share_backups
|
|
from manilaclient.v2 import share_export_locations
|
|
from manilaclient.v2 import share_group_snapshots
|
|
from manilaclient.v2 import share_group_type_access
|
|
from manilaclient.v2 import share_group_types
|
|
from manilaclient.v2 import share_groups
|
|
from manilaclient.v2 import share_instance_export_locations
|
|
from manilaclient.v2 import share_instances
|
|
from manilaclient.v2 import share_network_subnets
|
|
from manilaclient.v2 import share_networks
|
|
from manilaclient.v2 import share_replica_export_locations
|
|
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_snapshot_instance_export_locations
|
|
from manilaclient.v2 import share_snapshot_instances
|
|
from manilaclient.v2 import share_snapshots
|
|
from manilaclient.v2 import share_transfers
|
|
from manilaclient.v2 import share_type_access
|
|
from manilaclient.v2 import share_types
|
|
from manilaclient.v2 import shares
|
|
|
|
|
|
class Client:
|
|
"""Top-level object to access the OpenStack Manila API.
|
|
|
|
Create an instance with your creds::
|
|
|
|
>>> client = Client(username=USERNAME,
|
|
password=PASSWORD,
|
|
auth_url=AUTH_URL,
|
|
project_name=PROJECT_NAME)
|
|
|
|
Or, alternatively, you can create a client instance using the
|
|
keystoneauth1.session API::
|
|
|
|
>>> from keystoneauth1.identity import v3
|
|
>>> from keystoneauth1 import session
|
|
>>> from manilaclient import client
|
|
>>> auth = v3.Password(auth_url=AUTH_URL,
|
|
username=USERNAME,
|
|
user_domain_name=USER_DOMAIN_NAME,
|
|
password=PASSWORD,
|
|
project_name=PROJECT_ID,
|
|
project_domain_name=PROJECT_DOMAIN_NAME)
|
|
>>> sess = session.Session(auth=auth)
|
|
>>> manila = client.Client(VERSION, session=sess)
|
|
|
|
Then call methods on its managers::
|
|
|
|
>>> client.shares.list()
|
|
...
|
|
"""
|
|
|
|
@removals.removed_kwarg(
|
|
'use_keyring',
|
|
message='This parameter is no longer supported and has no effect.',
|
|
version='5.8.0',
|
|
removal_version='6.0.0',
|
|
)
|
|
@removals.removed_kwarg(
|
|
'force_new_token',
|
|
message='This parameter is no longer supported and has no effect.',
|
|
version='5.8.0',
|
|
removal_version='6.0.0',
|
|
)
|
|
@removals.removed_kwarg(
|
|
'cached_token_lifetime',
|
|
message='This parameter is no longer supported and has no effect.',
|
|
version='5.8.0',
|
|
removal_version='6.0.0',
|
|
)
|
|
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
|
|
|
|
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:
|
|
# Modern path - session provided by caller (e.g., OSC plugin)
|
|
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:
|
|
# Legacy path - create auth plugin and session ourselves
|
|
auth, ks_session = self._get_keystone_auth_and_session()
|
|
self.keystone_client = adapter.LegacyJsonAdapter(
|
|
session=ks_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)
|
|
|
|
if not input_auth_token:
|
|
raise RuntimeError("Not Authorized")
|
|
|
|
if not service_catalog_url:
|
|
# Use keystoneauth1 session endpoint discovery
|
|
service_catalog_url = self.keystone_client.session.get_endpoint(
|
|
self.keystone_client.auth,
|
|
interface=endpoint_type,
|
|
service_type=service_type,
|
|
region_name=region_name,
|
|
)
|
|
|
|
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.transfers = share_transfers.ShareTransferManager(self)
|
|
self.messages = messages.MessageManager(self)
|
|
self.qos_types = qos_types.QosTypeManager(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.resource_locks = resource_locks.ResourceLockManager(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( # noqa: E501
|
|
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.share_backups = share_backups.ShareBackupManager(self)
|
|
|
|
self._load_extensions(extensions)
|
|
|
|
def _load_extensions(self, extensions):
|
|
if not extensions:
|
|
return
|
|
|
|
for extension in extensions:
|
|
if extension.manager_class:
|
|
setattr(self, extension.name, extension.manager_class(self))
|
|
|
|
def _get_keystone_auth_and_session(self):
|
|
"""Create keystoneauth1 auth plugin and session for authentication.
|
|
|
|
Returns:
|
|
tuple: (auth_plugin, session) for use with keystoneauth1
|
|
"""
|
|
# Create session with SSL settings
|
|
if self.insecure:
|
|
verify = False
|
|
else:
|
|
verify = self.cacert or True
|
|
ks_session = session.Session(verify=verify, cert=self.cert)
|
|
|
|
# Discover Keystone v3 endpoint
|
|
ks_discover = session.discover.Discover(ks_session, self.auth_url)
|
|
auth_url = ks_discover.url_for('v3.0')
|
|
if not auth_url:
|
|
raise exceptions.CommandError(
|
|
'Unable to determine the Keystone version to authenticate '
|
|
'with using the given auth_url.'
|
|
)
|
|
|
|
# Create v3 Password auth plugin
|
|
auth = identity.v3.Password(
|
|
auth_url=auth_url,
|
|
username=self.username,
|
|
password=self.password,
|
|
user_id=self.user_id,
|
|
user_domain_name=self.user_domain_name,
|
|
user_domain_id=self.user_domain_id,
|
|
project_id=self.project_id or self.tenant_id,
|
|
project_name=self.project_name,
|
|
project_domain_name=self.project_domain_name,
|
|
project_domain_id=self.project_domain_id,
|
|
)
|
|
|
|
return auth, ks_session
|