357 lines
14 KiB
Python
357 lines
14 KiB
Python
# Copyright 2015 Huawei Technologies Co., Ltd.
|
|
# 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.
|
|
|
|
|
|
from cinderclient import client as c_client
|
|
from cinderclient import exceptions as c_exceptions
|
|
import glanceclient as g_client
|
|
import glanceclient.exc as g_exceptions
|
|
from neutronclient.common import exceptions as q_exceptions
|
|
from neutronclient.neutron import client as q_client
|
|
from novaclient import api_versions
|
|
from novaclient import client as n_client
|
|
from novaclient import exceptions as n_exceptions
|
|
from oslo_config import cfg
|
|
from oslo_log import log as logging
|
|
from requests import exceptions as r_exceptions
|
|
|
|
from tricircle.common import constants as cons
|
|
from tricircle.common import exceptions
|
|
|
|
|
|
client_opts = [
|
|
cfg.IntOpt('cinder_timeout',
|
|
default=60,
|
|
help='timeout for cinder client in seconds'),
|
|
cfg.IntOpt('glance_timeout',
|
|
default=60,
|
|
help='timeout for glance client in seconds'),
|
|
cfg.IntOpt('neutron_timeout',
|
|
default=60,
|
|
help='timeout for neutron client in seconds'),
|
|
cfg.IntOpt('nova_timeout',
|
|
default=60,
|
|
help='timeout for nova client in seconds'),
|
|
]
|
|
cfg.CONF.register_opts(client_opts, group='client')
|
|
|
|
|
|
LIST, CREATE, DELETE, GET, ACTION, UPDATE = 1, 2, 4, 8, 16, 32
|
|
operation_index_map = {'list': LIST, 'create': CREATE, 'delete': DELETE,
|
|
'get': GET, 'action': ACTION, 'update': UPDATE}
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
|
|
def _transform_filters(filters):
|
|
filter_dict = {}
|
|
for query_filter in filters:
|
|
# only eq filter supported at first
|
|
if query_filter['comparator'] != 'eq':
|
|
continue
|
|
key = query_filter['key']
|
|
value = query_filter['value']
|
|
filter_dict[key] = value
|
|
return filter_dict
|
|
|
|
|
|
class ResourceHandle(object):
|
|
def __init__(self, auth_url):
|
|
self.auth_url = auth_url
|
|
self.endpoint_url = None
|
|
|
|
def is_endpoint_url_set(self):
|
|
return self.endpoint_url is not None
|
|
|
|
def update_endpoint_url(self, url):
|
|
self.endpoint_url = url
|
|
|
|
|
|
class GlanceResourceHandle(ResourceHandle):
|
|
service_type = cons.ST_GLANCE
|
|
support_resource = {'image': LIST | GET}
|
|
|
|
def _get_client(self, cxt):
|
|
return g_client.Client('1',
|
|
token=cxt.auth_token,
|
|
auth_url=self.auth_url,
|
|
endpoint=self.endpoint_url,
|
|
timeout=cfg.CONF.client.glance_timeout)
|
|
|
|
def handle_list(self, cxt, resource, filters):
|
|
try:
|
|
client = self._get_client(cxt)
|
|
collection = '%ss' % resource
|
|
return [res.to_dict() for res in getattr(
|
|
client, collection).list(filters=_transform_filters(filters))]
|
|
except g_exceptions.InvalidEndpoint:
|
|
self.endpoint_url = None
|
|
raise exceptions.EndpointNotAvailable('glance',
|
|
client.http_client.endpoint)
|
|
|
|
def handle_get(self, cxt, resource, resource_id):
|
|
try:
|
|
client = self._get_client(cxt)
|
|
collection = '%ss' % resource
|
|
return getattr(client, collection).get(resource_id).to_dict()
|
|
except g_exceptions.InvalidEndpoint:
|
|
self.endpoint_url = None
|
|
raise exceptions.EndpointNotAvailable('glance',
|
|
client.http_client.endpoint)
|
|
except g_exceptions.HTTPNotFound:
|
|
LOG.debug("%(resource)s %(resource_id)s not found",
|
|
{'resource': resource, 'resource_id': resource_id})
|
|
|
|
|
|
class NeutronResourceHandle(ResourceHandle):
|
|
service_type = cons.ST_NEUTRON
|
|
support_resource = {
|
|
'network': LIST | CREATE | DELETE | GET,
|
|
'subnet': LIST | CREATE | DELETE | GET | UPDATE,
|
|
'port': LIST | CREATE | DELETE | GET,
|
|
'router': LIST | CREATE | DELETE | ACTION | GET | UPDATE,
|
|
'security_group': LIST | CREATE | GET,
|
|
'security_group_rule': LIST | CREATE | DELETE,
|
|
'floatingip': LIST | CREATE | UPDATE | DELETE}
|
|
|
|
def _get_client(self, cxt):
|
|
return q_client.Client('2.0',
|
|
token=cxt.auth_token,
|
|
auth_url=self.auth_url,
|
|
endpoint_url=self.endpoint_url,
|
|
timeout=cfg.CONF.client.neutron_timeout)
|
|
|
|
def handle_list(self, cxt, resource, filters):
|
|
try:
|
|
client = self._get_client(cxt)
|
|
collection = '%ss' % resource
|
|
search_opts = _transform_filters(filters)
|
|
return [res for res in getattr(
|
|
client, 'list_%s' % collection)(**search_opts)[collection]]
|
|
except q_exceptions.ConnectionFailed:
|
|
self.endpoint_url = None
|
|
raise exceptions.EndpointNotAvailable(
|
|
'neutron', client.httpclient.endpoint_url)
|
|
|
|
def handle_create(self, cxt, resource, *args, **kwargs):
|
|
try:
|
|
client = self._get_client(cxt)
|
|
ret = getattr(client, 'create_%s' % resource)(
|
|
*args, **kwargs)
|
|
if resource in ret:
|
|
return ret[resource]
|
|
else:
|
|
return ret['%ss' % resource]
|
|
except q_exceptions.ConnectionFailed:
|
|
self.endpoint_url = None
|
|
raise exceptions.EndpointNotAvailable(
|
|
'neutron', client.httpclient.endpoint_url)
|
|
|
|
def handle_update(self, cxt, resource, *args, **kwargs):
|
|
try:
|
|
client = self._get_client(cxt)
|
|
return getattr(client, 'update_%s' % resource)(
|
|
*args, **kwargs)[resource]
|
|
except q_exceptions.ConnectionFailed:
|
|
self.endpoint_url = None
|
|
raise exceptions.EndpointNotAvailable(
|
|
'neutron', client.httpclient.endpoint_url)
|
|
|
|
def handle_get(self, cxt, resource, resource_id):
|
|
try:
|
|
client = self._get_client(cxt)
|
|
return getattr(client, 'show_%s' % resource)(resource_id)[resource]
|
|
except q_exceptions.ConnectionFailed:
|
|
self.endpoint_url = None
|
|
raise exceptions.EndpointNotAvailable(
|
|
'neutron', client.httpclient.endpoint_url)
|
|
except q_exceptions.NotFound:
|
|
LOG.debug("%(resource)s %(resource_id)s not found",
|
|
{'resource': resource, 'resource_id': resource_id})
|
|
|
|
def handle_delete(self, cxt, resource, resource_id):
|
|
try:
|
|
client = self._get_client(cxt)
|
|
return getattr(client, 'delete_%s' % resource)(resource_id)
|
|
except q_exceptions.ConnectionFailed:
|
|
self.endpoint_url = None
|
|
raise exceptions.EndpointNotAvailable(
|
|
'neutron', client.httpclient.endpoint_url)
|
|
except q_exceptions.NotFound:
|
|
LOG.debug("Delete %(resource)s %(resource_id)s which not found",
|
|
{'resource': resource, 'resource_id': resource_id})
|
|
|
|
def handle_action(self, cxt, resource, action, *args, **kwargs):
|
|
try:
|
|
client = self._get_client(cxt)
|
|
return getattr(client, '%s_%s' % (action, resource))(*args,
|
|
**kwargs)
|
|
except q_exceptions.ConnectionFailed:
|
|
self.endpoint_url = None
|
|
raise exceptions.EndpointNotAvailable(
|
|
'neutron', client.httpclient.endpoint_url)
|
|
|
|
|
|
def _convert_into_with_meta(item, resp):
|
|
return resp, item
|
|
|
|
|
|
class NovaResourceHandle(ResourceHandle):
|
|
service_type = cons.ST_NOVA
|
|
support_resource = {'flavor': LIST,
|
|
'server': LIST | CREATE | DELETE | GET | ACTION,
|
|
'aggregate': LIST | CREATE | DELETE | ACTION,
|
|
'server_volume': ACTION}
|
|
|
|
def _get_client(self, cxt):
|
|
cli = n_client.Client(api_versions.APIVersion(cxt.nova_micro_version),
|
|
auth_token=cxt.auth_token,
|
|
auth_url=self.auth_url,
|
|
timeout=cfg.CONF.client.nova_timeout)
|
|
cli.set_management_url(
|
|
self.endpoint_url.replace('$(tenant_id)s', cxt.tenant))
|
|
return cli
|
|
|
|
def _adapt_resource(self, resource):
|
|
if resource == 'server_volume':
|
|
return 'volume'
|
|
else:
|
|
return resource
|
|
|
|
def handle_list(self, cxt, resource, filters):
|
|
try:
|
|
resource = self._adapt_resource(resource)
|
|
client = self._get_client(cxt)
|
|
collection = '%ss' % resource
|
|
# only server list supports filter
|
|
if resource == 'server':
|
|
search_opts = _transform_filters(filters)
|
|
return [res.to_dict() for res in getattr(
|
|
client, collection).list(search_opts=search_opts)]
|
|
else:
|
|
return [res.to_dict() for res in getattr(client,
|
|
collection).list()]
|
|
except r_exceptions.ConnectTimeout:
|
|
self.endpoint_url = None
|
|
raise exceptions.EndpointNotAvailable('nova',
|
|
client.client.management_url)
|
|
|
|
def handle_create(self, cxt, resource, *args, **kwargs):
|
|
try:
|
|
resource = self._adapt_resource(resource)
|
|
client = self._get_client(cxt)
|
|
collection = '%ss' % resource
|
|
return getattr(client, collection).create(
|
|
*args, **kwargs).to_dict()
|
|
except r_exceptions.ConnectTimeout:
|
|
self.endpoint_url = None
|
|
raise exceptions.EndpointNotAvailable('nova',
|
|
client.client.management_url)
|
|
|
|
def handle_get(self, cxt, resource, resource_id):
|
|
try:
|
|
resource = self._adapt_resource(resource)
|
|
client = self._get_client(cxt)
|
|
collection = '%ss' % resource
|
|
return getattr(client, collection).get(resource_id).to_dict()
|
|
except r_exceptions.ConnectTimeout:
|
|
self.endpoint_url = None
|
|
raise exceptions.EndpointNotAvailable('nova',
|
|
client.client.management_url)
|
|
except n_exceptions.NotFound:
|
|
LOG.debug("%(resource)s %(resource_id)s not found",
|
|
{'resource': resource, 'resource_id': resource_id})
|
|
|
|
def handle_delete(self, cxt, resource, resource_id):
|
|
try:
|
|
resource = self._adapt_resource(resource)
|
|
client = self._get_client(cxt)
|
|
collection = '%ss' % resource
|
|
return getattr(client, collection).delete(resource_id)
|
|
except r_exceptions.ConnectTimeout:
|
|
self.endpoint_url = None
|
|
raise exceptions.EndpointNotAvailable('nova',
|
|
client.client.management_url)
|
|
except n_exceptions.NotFound:
|
|
LOG.debug("Delete %(resource)s %(resource_id)s which not found",
|
|
{'resource': resource, 'resource_id': resource_id})
|
|
|
|
def handle_action(self, cxt, resource, action, *args, **kwargs):
|
|
try:
|
|
resource = self._adapt_resource(resource)
|
|
client = self._get_client(cxt)
|
|
collection = '%ss' % resource
|
|
resource_manager = getattr(client, collection)
|
|
resource_manager.convert_into_with_meta = _convert_into_with_meta
|
|
# NOTE(zhiyuan) yes, this is a dirty hack. but the original
|
|
# implementation hides response object which is needed
|
|
return getattr(resource_manager, action)(*args, **kwargs)
|
|
except r_exceptions.ConnectTimeout:
|
|
self.endpoint_url = None
|
|
raise exceptions.EndpointNotAvailable('nova',
|
|
client.client.management_url)
|
|
|
|
|
|
class CinderResourceHandle(ResourceHandle):
|
|
service_type = cons.ST_CINDER
|
|
support_resource = {'volume': LIST | CREATE | DELETE | GET | ACTION,
|
|
'transfer': CREATE | ACTION}
|
|
|
|
def _get_client(self, cxt):
|
|
cli = c_client.Client('2',
|
|
auth_url=self.auth_url,
|
|
timeout=cfg.CONF.client.cinder_timeout)
|
|
cli.client.set_management_url(
|
|
self.endpoint_url.replace('$(tenant_id)s', cxt.tenant))
|
|
cli.client.auth_token = cxt.auth_token
|
|
return cli
|
|
|
|
def handle_get(self, cxt, resource, resource_id):
|
|
try:
|
|
client = self._get_client(cxt)
|
|
collection = '%ss' % resource
|
|
res = getattr(client, collection).get(resource_id)
|
|
info = {}
|
|
info.update(res._info)
|
|
return info
|
|
except r_exceptions.ConnectTimeout:
|
|
self.endpoint_url = None
|
|
raise exceptions.EndpointNotAvailable('cinder',
|
|
client.client.management_url)
|
|
|
|
def handle_delete(self, cxt, resource, resource_id):
|
|
try:
|
|
client = self._get_client(cxt)
|
|
collection = '%ss' % resource
|
|
return getattr(client, collection).delete(resource_id)
|
|
except r_exceptions.ConnectTimeout:
|
|
self.endpoint_url = None
|
|
raise exceptions.EndpointNotAvailable('cinder',
|
|
client.client.management_url)
|
|
except c_exceptions.NotFound:
|
|
LOG.debug("Delete %(resource)s %(resource_id)s which not found",
|
|
{'resource': resource, 'resource_id': resource_id})
|
|
|
|
def handle_action(self, cxt, resource, action, *args, **kwargs):
|
|
try:
|
|
client = self._get_client(cxt)
|
|
collection = '%ss' % resource
|
|
resource_manager = getattr(client, collection)
|
|
getattr(resource_manager, action)(*args, **kwargs)
|
|
except r_exceptions.ConnectTimeout:
|
|
self.endpoint_url = None
|
|
raise exceptions.EndpointNotAvailable('cinder',
|
|
client.client.management_url)
|