python-openstackclient/openstackclient/compute/client.py
Dean Troyer 4289ddd47a Low-level Compute v2 API: security group
api.compute.APIv2 starts with security group functions.

novaclient 8.0 is now released without support for the previously
deprecated nova-net functions, so include a new low-level REST
implementation of the removed APIs.

Change-Id: Id007535f0598226a8202716232313e37fe6247f9
2017-04-11 02:08:04 -05:00

154 lines
4.8 KiB
Python

# Copyright 2012-2013 OpenStack Foundation
#
# 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 logging
from osc_lib import exceptions
from osc_lib import utils
from openstackclient.i18n import _
LOG = logging.getLogger(__name__)
DEFAULT_API_VERSION = '2.1'
API_VERSION_OPTION = 'os_compute_api_version'
API_NAME = 'compute'
API_VERSIONS = {
"2": "novaclient.client",
"2.1": "novaclient.client",
}
COMPUTE_API_TYPE = 'compute'
COMPUTE_API_VERSIONS = {
'2': 'openstackclient.api.compute_v2.APIv2',
}
# Save the microversion if in use
_compute_api_version = None
def make_client(instance):
"""Returns a compute service client."""
# Defer client import until we actually need them
from novaclient import client as nova_client
if _compute_api_version is not None:
version = _compute_api_version
else:
version = instance._api_version[API_NAME]
from novaclient import api_versions
# convert to APIVersion object
version = api_versions.get_api_version(version)
if version.is_latest():
import novaclient
# NOTE(RuiChen): executing version discovery make sense, but that need
# an initialized REST client, it's not available now,
# fallback to use the max version of novaclient side.
version = novaclient.API_MAX_VERSION
LOG.debug('Instantiating compute client for %s', version)
compute_api = utils.get_client_class(
API_NAME,
version.ver_major,
COMPUTE_API_VERSIONS,
)
LOG.debug('Instantiating compute api: %s', compute_api)
# Set client http_log_debug to True if verbosity level is high enough
http_log_debug = utils.get_effective_log_level() <= logging.DEBUG
extensions = [ext for ext in nova_client.discover_extensions(version)
if ext.name == "list_extensions"]
# Remember interface only if it is set
kwargs = utils.build_kwargs_dict('endpoint_type', instance.interface)
client = nova_client.Client(
version,
session=instance.session,
extensions=extensions,
http_log_debug=http_log_debug,
timings=instance.timing,
region_name=instance.region_name,
**kwargs
)
client.api = compute_api(
session=instance.session,
service_type=COMPUTE_API_TYPE,
endpoint=instance.get_endpoint_for_service_type(
COMPUTE_API_TYPE,
region_name=instance.region_name,
interface=instance.interface,
)
)
return client
def build_option_parser(parser):
"""Hook to add global options"""
parser.add_argument(
'--os-compute-api-version',
metavar='<compute-api-version>',
default=utils.env('OS_COMPUTE_API_VERSION'),
help=_("Compute API version, default=%s "
"(Env: OS_COMPUTE_API_VERSION)") % DEFAULT_API_VERSION
)
return parser
def check_api_version(check_version):
"""Validate version supplied by user
Returns:
* True if version is OK
* False if the version has not been checked and the previous plugin
check should be performed
* throws an exception if the version is no good
TODO(dtroyer): make the exception thrown a version-related one
"""
# Defer client imports until we actually need them
import novaclient
from novaclient import api_versions
global _compute_api_version
# Copy some logic from novaclient 3.3.0 for basic version detection
# NOTE(dtroyer): This is only enough to resume operations using API
# version 2.0 or any valid version supplied by the user.
_compute_api_version = api_versions.get_api_version(check_version)
# Bypass X.latest format microversion
if not _compute_api_version.is_latest():
if _compute_api_version > api_versions.APIVersion("2.0"):
if not _compute_api_version.matches(
novaclient.API_MIN_VERSION,
novaclient.API_MAX_VERSION,
):
msg = _("versions supported by client: %(min)s - %(max)s") % {
"min": novaclient.API_MIN_VERSION.get_string(),
"max": novaclient.API_MAX_VERSION.get_string(),
}
raise exceptions.CommandError(msg)
return True