258 lines
9.9 KiB
Python
258 lines
9.9 KiB
Python
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
|
|
|
# Copyright 2011 OpenStack LLC.
|
|
# 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.
|
|
|
|
import routes
|
|
import webob.exc
|
|
|
|
from reddwarf.common import cfg
|
|
from reddwarf.common import exception
|
|
from reddwarf.common import pagination
|
|
from reddwarf.common import utils
|
|
from reddwarf.common import wsgi
|
|
from reddwarf.extensions.mysql.common import populate_databases
|
|
from reddwarf.extensions.mysql.common import populate_users
|
|
from reddwarf.instance import models, views
|
|
from reddwarf.openstack.common import log as logging
|
|
from reddwarf.openstack.common.gettextutils import _
|
|
|
|
|
|
CONF = cfg.CONF
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
|
|
class api_validation:
|
|
""" api validation wrapper """
|
|
def __init__(self, action=None):
|
|
self.action = action
|
|
|
|
def __call__(self, f):
|
|
"""
|
|
Apply validation of the api body
|
|
"""
|
|
def wrapper(*args, **kwargs):
|
|
body = kwargs['body']
|
|
if self.action == 'create':
|
|
InstanceController._validate(body)
|
|
return f(*args, **kwargs)
|
|
return wrapper
|
|
|
|
|
|
class InstanceController(wsgi.Controller):
|
|
"""Controller for instance functionality"""
|
|
|
|
def action(self, req, body, tenant_id, id):
|
|
LOG.info("req : '%s'\n\n" % req)
|
|
LOG.info("Comitting an ACTION again instance %s for tenant '%s'"
|
|
% (id, tenant_id))
|
|
if not body:
|
|
raise exception.BadRequest(_("Invalid request body."))
|
|
context = req.environ[wsgi.CONTEXT_KEY]
|
|
instance = models.Instance.load(context, id)
|
|
_actions = {
|
|
'restart': self._action_restart,
|
|
'resize': self._action_resize,
|
|
'reset_password': self._action_reset_password
|
|
}
|
|
selected_action = None
|
|
for key in body:
|
|
if key in _actions:
|
|
if selected_action is not None:
|
|
msg = _("Only one action can be specified per request.")
|
|
raise exception.BadRequest(msg)
|
|
selected_action = _actions[key]
|
|
else:
|
|
msg = _("Invalid instance action: %s") % key
|
|
raise exception.BadRequest(msg)
|
|
|
|
if selected_action:
|
|
return selected_action(instance, body)
|
|
else:
|
|
raise exception.BadRequest(_("Invalid request body."))
|
|
|
|
def _action_restart(self, instance, body):
|
|
instance.restart()
|
|
return wsgi.Result(None, 202)
|
|
|
|
def _action_resize(self, instance, body):
|
|
"""
|
|
Handles 2 cases
|
|
1. resize volume
|
|
body only contains {volume: {size: x}}
|
|
2. resize instance
|
|
body only contains {flavorRef: http.../2}
|
|
|
|
If the body has both we will throw back an error.
|
|
"""
|
|
options = {
|
|
'volume': self._action_resize_volume,
|
|
'flavorRef': self._action_resize_flavor
|
|
}
|
|
selected_option = None
|
|
args = None
|
|
for key in options:
|
|
if key in body['resize']:
|
|
if selected_option is not None:
|
|
msg = _("Not allowed to resize volume and flavor at the "
|
|
"same time.")
|
|
raise exception.BadRequest(msg)
|
|
selected_option = options[key]
|
|
args = body['resize'][key]
|
|
|
|
if selected_option:
|
|
return selected_option(instance, args)
|
|
else:
|
|
raise exception.BadRequest(_("Missing resize arguments."))
|
|
|
|
def _action_resize_volume(self, instance, volume):
|
|
InstanceController._validate_resize_volume(volume)
|
|
instance.resize_volume(volume['size'])
|
|
return wsgi.Result(None, 202)
|
|
|
|
def _action_resize_flavor(self, instance, flavorRef):
|
|
new_flavor_id = utils.get_id_from_href(flavorRef)
|
|
instance.resize_flavor(new_flavor_id)
|
|
return wsgi.Result(None, 202)
|
|
|
|
def _action_reset_password(self, instance, body):
|
|
raise webob.exc.HTTPNotImplemented()
|
|
|
|
def index(self, req, tenant_id):
|
|
"""Return all instances."""
|
|
LOG.info(_("req : '%s'\n\n") % req)
|
|
LOG.info(_("Indexing a database instance for tenant '%s'") % tenant_id)
|
|
context = req.environ[wsgi.CONTEXT_KEY]
|
|
servers, marker = models.Instances.load(context)
|
|
view = views.InstancesView(servers, req=req)
|
|
paged = pagination.SimplePaginatedDataView(req.url, 'instances', view,
|
|
marker)
|
|
return wsgi.Result(paged.data(), 200)
|
|
|
|
def show(self, req, tenant_id, id):
|
|
"""Return a single instance."""
|
|
LOG.info(_("req : '%s'\n\n") % req)
|
|
LOG.info(_("Showing a database instance for tenant '%s'") % tenant_id)
|
|
LOG.info(_("id : '%s'\n\n") % id)
|
|
|
|
context = req.environ[wsgi.CONTEXT_KEY]
|
|
server = models.load_instance_with_guest(models.DetailInstance,
|
|
context, id)
|
|
return wsgi.Result(views.InstanceDetailView(server,
|
|
req=req).data(), 200)
|
|
|
|
def delete(self, req, tenant_id, id):
|
|
"""Delete a single instance."""
|
|
LOG.info(_("req : '%s'\n\n") % req)
|
|
LOG.info(_("Deleting a database instance for tenant '%s'") % tenant_id)
|
|
LOG.info(_("id : '%s'\n\n") % id)
|
|
# TODO(hub-cap): turn this into middleware
|
|
context = req.environ[wsgi.CONTEXT_KEY]
|
|
instance = models.load_any_instance(context, id)
|
|
instance.delete()
|
|
# TODO(cp16net): need to set the return code correctly
|
|
return wsgi.Result(None, 202)
|
|
|
|
@api_validation(action="create")
|
|
def create(self, req, body, tenant_id):
|
|
# TODO(hub-cap): turn this into middleware
|
|
LOG.info(_("Creating a database instance for tenant '%s'") % tenant_id)
|
|
LOG.info(_("req : '%s'\n\n") % req)
|
|
LOG.info(_("body : '%s'\n\n") % body)
|
|
context = req.environ[wsgi.CONTEXT_KEY]
|
|
# Set the service type to mysql if its not in the request
|
|
service_type = (body['instance'].get('service_type') or
|
|
CONF.service_type)
|
|
service = models.ServiceImage.find_by(service_name=service_type)
|
|
image_id = service['image_id']
|
|
name = body['instance']['name']
|
|
flavor_ref = body['instance']['flavorRef']
|
|
flavor_id = utils.get_id_from_href(flavor_ref)
|
|
databases = populate_databases(body['instance'].get('databases', []))
|
|
users = populate_users(body['instance'].get('users', []))
|
|
if body['instance'].get('volume', None) is not None:
|
|
try:
|
|
volume_size = int(body['instance']['volume']['size'])
|
|
except ValueError as e:
|
|
raise exception.BadValue(msg=e)
|
|
else:
|
|
volume_size = None
|
|
|
|
instance = models.Instance.create(context, name, flavor_id,
|
|
image_id, databases, users,
|
|
service_type, volume_size)
|
|
|
|
view = views.InstanceDetailView(instance, req=req)
|
|
return wsgi.Result(view.data(), 200)
|
|
|
|
@staticmethod
|
|
def _validate_body_not_empty(body):
|
|
"""Check that the body is not empty"""
|
|
if not body:
|
|
msg = "The request contains an empty body"
|
|
raise exception.ReddwarfError(msg)
|
|
|
|
@staticmethod
|
|
def _validate_resize_volume(volume):
|
|
"""
|
|
We are going to check that volume resizing data is present.
|
|
"""
|
|
if 'size' not in volume:
|
|
raise exception.BadRequest(
|
|
"Missing 'size' property of 'volume' in request body.")
|
|
InstanceController._validate_volume_size(volume['size'])
|
|
|
|
@staticmethod
|
|
def _validate_volume_size(size):
|
|
"""Validate the various possible errors for volume size"""
|
|
try:
|
|
volume_size = float(size)
|
|
except (ValueError, TypeError) as err:
|
|
LOG.error(err)
|
|
msg = ("Required element/key - instance volume 'size' was not "
|
|
"specified as a number (value was %s)." % size)
|
|
raise exception.ReddwarfError(msg)
|
|
if int(volume_size) != volume_size or int(volume_size) < 1:
|
|
msg = ("Volume 'size' needs to be a positive "
|
|
"integer value, %s cannot be accepted."
|
|
% volume_size)
|
|
raise exception.ReddwarfError(msg)
|
|
|
|
@staticmethod
|
|
def _validate(body):
|
|
"""Validate that the request has all the required parameters"""
|
|
InstanceController._validate_body_not_empty(body)
|
|
|
|
try:
|
|
body['instance']
|
|
body['instance']['flavorRef']
|
|
name = body['instance'].get('name', '').strip()
|
|
if not name:
|
|
raise exception.MissingKey(key='name')
|
|
if CONF.reddwarf_volume_support:
|
|
if body['instance'].get('volume', None):
|
|
if body['instance']['volume'].get('size', None):
|
|
volume_size = body['instance']['volume']['size']
|
|
InstanceController._validate_volume_size(volume_size)
|
|
else:
|
|
raise exception.MissingKey(key="size")
|
|
else:
|
|
raise exception.MissingKey(key="volume")
|
|
|
|
except KeyError as e:
|
|
LOG.error(_("Create Instance Required field(s) - %s") % e)
|
|
raise exception.ReddwarfError("Required element/key - %s "
|
|
"was not specified" % e)
|