# Copyright 2014, Rackspace, US, Inc.
#
# 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.
"""API over the nova service.
"""
from collections import OrderedDict
from django.http import HttpResponse
from django.template.defaultfilters import slugify
from django.utils import http as utils_http
from django.utils.translation import ugettext_lazy as _
from django.views import generic
from horizon import exceptions as hz_exceptions
from novaclient import exceptions
from openstack_dashboard import api
from openstack_dashboard.api.rest import json_encoder
from openstack_dashboard.api.rest import urls
from openstack_dashboard.api.rest import utils as rest_utils
from openstack_dashboard.usage import quotas
import six
@urls.register
[docs]class Snapshots(generic.View):
"""API for nova snapshots.
"""
url_regex = r'nova/snapshots/$'
@rest_utils.ajax(data_required=True)
[docs] def post(self, request):
instance_id = request.DATA['instance_id']
name = request.DATA['name']
result = api.nova.snapshot_create(request,
instance_id=instance_id,
name=name)
return result
@urls.register
[docs]class Keypairs(generic.View):
"""API for nova keypairs.
"""
url_regex = r'nova/keypairs/$'
@rest_utils.ajax()
[docs] def get(self, request):
"""Get a list of keypairs associated with the current logged-in
account.
The listing result is an object with property "items".
"""
result = api.nova.keypair_list(request)
return {'items': [u.to_dict() for u in result]}
@rest_utils.ajax(data_required=True)
[docs] def post(self, request):
"""Create a keypair.
Create a keypair using the parameters supplied in the POST
application/json object. The parameters are:
:param name: the name to give the keypair
:param public_key: (optional) a key to import
This returns the new keypair object on success.
"""
if 'public_key' in request.DATA:
new = api.nova.keypair_import(request, request.DATA['name'],
request.DATA['public_key'])
else:
new = api.nova.keypair_create(request, request.DATA['name'])
return rest_utils.CreatedResponse(
'/api/nova/keypairs/%s' % utils_http.urlquote(new.name),
new.to_dict()
)
@urls.register
[docs]class Keypair(generic.View):
url_regex = r'nova/keypairs/(?P<keypair_name>.+)/$'
[docs] def get(self, request, keypair_name):
"""Creates a new keypair and associates it to the current project.
* Since the response for this endpoint creates a new keypair and
is not idempotent, it normally would be represented by a POST HTTP
request. However, this solution was adopted as it
would support automatic file download across browsers.
:param keypair_name: the name to associate the keypair to
:param regenerate: (optional) if set to the string 'true',
replaces the existing keypair with a new keypair
This returns the new keypair object on success.
"""
try:
regenerate = request.GET.get('regenerate') == 'true'
if regenerate:
api.nova.keypair_delete(request, keypair_name)
keypair = api.nova.keypair_create(request, keypair_name)
except exceptions.Conflict:
return HttpResponse(status=409)
except Exception:
return HttpResponse(status=500)
else:
response = HttpResponse(content_type='application/binary')
response['Content-Disposition'] = ('attachment; filename=%s.pem'
% slugify(keypair_name))
response.write(keypair.private_key)
response['Content-Length'] = str(len(response.content))
return response
@urls.register
[docs]class Services(generic.View):
"""API for nova services.
"""
url_regex = r'nova/services/$'
@rest_utils.ajax()
[docs] def get(self, request):
"""Get a list of nova services.
Will return HTTP 501 status code if the service_list extension is
not supported.
"""
if api.base.is_service_enabled(request, 'compute') \
and api.nova.extension_supported('Services', request):
result = api.nova.service_list(request)
return {'items': [u.to_dict() for u in result]}
else:
raise rest_utils.AjaxError(501, '')
@urls.register
[docs]class AvailabilityZones(generic.View):
"""API for nova availability zones.
"""
url_regex = r'nova/availzones/$'
@rest_utils.ajax()
[docs] def get(self, request):
"""Get a list of availability zones.
The following get parameters may be passed in the GET
request:
:param detailed: If this equals "true" then the result will
include more detail.
The listing result is an object with property "items".
"""
detailed = request.GET.get('detailed') == 'true'
result = api.nova.availability_zone_list(request, detailed)
return {'items': [u.to_dict() for u in result]}
@urls.register
[docs]class Limits(generic.View):
"""API for nova limits.
"""
url_regex = r'nova/limits/$'
@rest_utils.ajax(json_encoder=json_encoder.NaNJSONEncoder)
[docs] def get(self, request):
"""Get an object describing the current project limits.
Note: the Horizon API doesn't support any other project (tenant) but
the underlying client does...
The following get parameters may be passed in the GET
request:
:param reserved: Take into account the reserved limits. Reserved limits
may be instances in the rebuild process for example.
The result is an object with limits as properties.
"""
reserved = request.GET.get('reserved') == 'true'
result = api.nova.tenant_absolute_limits(request, reserved)
return result
@urls.register
[docs]class ServerActions(generic.View):
"""API over all server actions.
"""
url_regex = r'nova/servers/(?P<server_id>[^/]+)/actions/$'
@rest_utils.ajax()
[docs] def get(self, request, server_id):
"""Get a list of server actions.
The listing result is an object with property "items". Each item is
an action taken against the given server.
Example GET:
http://localhost/api/nova/servers/abcd/actions/
"""
actions = api.nova.instance_action_list(request, server_id)
return {'items': [s.to_dict() for s in actions]}
@urls.register
[docs]class SecurityGroups(generic.View):
"""API over all server security groups.
"""
url_regex = r'nova/servers/(?P<server_id>[^/]+)/security-groups/$'
@rest_utils.ajax()
[docs] def get(self, request, server_id):
"""Get a list of server security groups.
The listing result is an object with property "items". Each item is
security group associated with this server.
Example GET:
http://localhost/api/nova/servers/abcd/security-groups/
"""
groups = api.network.server_security_groups(request, server_id)
return {'items': [s.to_dict() for s in groups]}
@urls.register
[docs]class Volumes(generic.View):
"""API over all server volumes.
"""
url_regex = r'nova/servers/(?P<server_id>[^/]+)/volumes/$'
@rest_utils.ajax()
[docs] def get(self, request, server_id):
"""Get a list of server volumes.
The listing result is an object with property "items". Each item is
a volume.
Example GET:
http://localhost/api/nova/servers/abcd/volumes/
"""
volumes = api.nova.instance_volumes_list(request, server_id)
return {'items': [s.to_dict() for s in volumes]}
@urls.register
[docs]class RemoteConsoleInfo(generic.View):
"""API for remote console information.
"""
url_regex = r'nova/servers/(?P<server_id>[^/]+)/console-info/$'
@rest_utils.ajax()
[docs] def post(self, request, server_id):
"""Gets information about an available remote console for the given
server.
Example POST:
http://localhost/api/nova/servers/abcd/console-info/
"""
console_type = request.DATA.get('console_type', 'AUTO')
CONSOLES = OrderedDict([('VNC', api.nova.server_vnc_console),
('SPICE', api.nova.server_spice_console),
('RDP', api.nova.server_rdp_console),
('SERIAL', api.nova.server_serial_console)])
"""Get a tuple of console url and console type."""
if console_type == 'AUTO':
check_consoles = CONSOLES
else:
try:
check_consoles = {console_type: CONSOLES[console_type]}
except KeyError:
msg = _('Console type "%s" not supported.') % console_type
raise hz_exceptions.NotAvailable(msg)
# Ugly workaround due novaclient API change from 2.17 to 2.18.
try:
httpnotimplemented = exceptions.HttpNotImplemented
except AttributeError:
httpnotimplemented = exceptions.HTTPNotImplemented
for con_type, api_call in six.iteritems(check_consoles):
try:
console = api_call(request, server_id)
# If not supported, don't log it to avoid lot of errors in case
# of AUTO.
except httpnotimplemented:
continue
except Exception:
continue
if con_type == 'SERIAL':
console_url = console.url
else:
console_url = "%s&%s(%s)" % (
console.url,
utils_http.urlencode({'title': _("Console")}),
server_id)
return {"type": con_type, "url": console_url}
raise hz_exceptions.NotAvailable(_('No available console found.'))
@urls.register
[docs]class ConsoleOutput(generic.View):
"""API for console output.
"""
url_regex = r'nova/servers/(?P<server_id>[^/]+)/console-output/$'
@rest_utils.ajax()
[docs] def post(self, request, server_id):
"""Get a list of lines of console output.
The listing result is an object with property "items". Each item is
a line of output from the server.
Example GET:
http://localhost/api/nova/servers/abcd/console-output/
"""
log_length = request.DATA.get('length', 100)
console_lines = api.nova.server_console_output(request, server_id,
tail_length=log_length)
return {"lines": [x for x in console_lines.split('\n')]}
@urls.register
[docs]class Servers(generic.View):
"""API over all servers.
"""
url_regex = r'nova/servers/$'
_optional_create = [
'block_device_mapping', 'block_device_mapping_v2', 'nics', 'meta',
'availability_zone', 'instance_count', 'admin_pass', 'disk_config',
'config_drive', 'scheduler_hints'
]
@rest_utils.ajax()
[docs] def get(self, request):
"""Get a list of servers.
The listing result is an object with property "items". Each item is
a server.
Example GET:
http://localhost/api/nova/servers
"""
servers = api.nova.server_list(request)[0]
return {'items': [s.to_dict() for s in servers]}
@rest_utils.ajax(data_required=True)
[docs] def post(self, request):
"""Create a server.
Create a server using the parameters supplied in the POST
application/json object. The required parameters as specified by
the underlying novaclient are:
:param name: The new server name.
:param source_id: The ID of the image to use.
:param flavor_id: The ID of the flavor to use.
:param key_name: (optional extension) name of previously created
keypair to inject into the instance.
:param user_data: user data to pass to be exposed by the metadata
server this can be a file type object as well or a
string.
:param security_groups: An array of one or more objects with a "name"
attribute.
Other parameters are accepted as per the underlying novaclient:
"block_device_mapping", "block_device_mapping_v2", "nics", "meta",
"availability_zone", "instance_count", "admin_pass", "disk_config",
"config_drive", "scheduler_hints"
This returns the new server object on success.
"""
try:
args = (
request,
request.DATA['name'],
request.DATA['source_id'],
request.DATA['flavor_id'],
request.DATA['key_name'],
request.DATA['user_data'],
request.DATA['security_groups'],
)
except KeyError as e:
raise rest_utils.AjaxError(400, 'missing required parameter '
"'%s'" % e.args[0])
kw = {}
for name in self._optional_create:
if name in request.DATA:
kw[name] = request.DATA[name]
new = api.nova.server_create(*args, **kw)
return rest_utils.CreatedResponse(
'/api/nova/servers/%s' % utils_http.urlquote(new.id),
new.to_dict()
)
@urls.register
[docs]class Server(generic.View):
"""API for retrieving a single server
"""
url_regex = r'nova/servers/(?P<server_id>[^/]+|default)$'
@rest_utils.ajax()
[docs] def get(self, request, server_id):
"""Get a specific server
http://localhost/api/nova/servers/1
"""
return api.nova.server_get(request, server_id).to_dict()
@rest_utils.ajax(data_required=True)
[docs] def post(self, request, server_id):
"""Perform a change to a server
"""
operation = request.DATA.get('operation', 'none')
operations = {
'stop': api.nova.server_stop,
'start': api.nova.server_start,
'pause': api.nova.server_pause,
'unpause': api.nova.server_unpause,
'suspend': api.nova.server_suspend,
'resume': api.nova.server_resume,
'hard_reboot': lambda r, s: api.nova.server_reboot(r, s, False),
'soft_reboot': lambda r, s: api.nova.server_reboot(r, s, True),
}
return operations[operation](request, server_id)
@rest_utils.ajax()
[docs] def delete(self, request, server_id):
api.nova.server_delete(request, server_id)
@urls.register
[docs]class ServerGroups(generic.View):
"""API for nova server groups.
"""
url_regex = r'nova/servergroups/$'
@rest_utils.ajax()
[docs] def get(self, request):
"""Get a list of server groups.
The listing result is an object with property "items".
"""
result = api.nova.server_group_list(request)
return {'items': [u.to_dict() for u in result]}
@urls.register
@urls.register
[docs]class Extensions(generic.View):
"""API for nova extensions.
"""
url_regex = r'nova/extensions/$'
@rest_utils.ajax()
[docs] def get(self, request):
"""Get a list of extensions.
The listing result is an object with property "items". Each item is
an image.
Example GET:
http://localhost/api/nova/extensions
"""
result = api.nova.list_extensions(request)
return {'items': [e.to_dict() for e in result]}
@urls.register
[docs]class Flavors(generic.View):
"""API for nova flavors.
"""
url_regex = r'nova/flavors/$'
@rest_utils.ajax()
[docs] def get(self, request):
"""Get a list of flavors.
The listing result is an object with property "items". Each item is
a flavor. By default this will return the flavors for the user's
current project. If the user is admin, public flavors will also be
returned.
:param is_public: For a regular user, set to True to see all public
flavors. For an admin user, set to False to not see public flavors.
:param get_extras: Also retrieve the extra specs.
Example GET:
http://localhost/api/nova/flavors?is_public=true
"""
is_public = request.GET.get('is_public')
is_public = (is_public and is_public.lower() == 'true')
get_extras = request.GET.get('get_extras')
get_extras = bool(get_extras and get_extras.lower() == 'true')
flavors = api.nova.flavor_list(request, is_public=is_public,
get_extras=get_extras)
result = {'items': []}
for flavor in flavors:
d = flavor.to_dict()
if get_extras:
d['extras'] = flavor.extras
result['items'].append(d)
return result
@rest_utils.ajax(data_required=True)
[docs] def post(self, request):
flavor_access = request.DATA.get('flavor_access', [])
flavor_id = request.DATA['id']
is_public = not flavor_access
flavor = api.nova.flavor_create(request,
name=request.DATA['name'],
memory=request.DATA['ram'],
vcpu=request.DATA['vcpus'],
disk=request.DATA['disk'],
ephemeral=request
.DATA['OS-FLV-EXT-DATA:ephemeral'],
swap=request.DATA['swap'],
flavorid=flavor_id,
is_public=is_public
)
for project in flavor_access:
api.nova.add_tenant_to_flavor(
request, flavor.id, project.get('id'))
return rest_utils.CreatedResponse(
'/api/nova/flavors/%s' % flavor.id,
flavor.to_dict()
)
@urls.register
[docs]class Flavor(generic.View):
"""API for retrieving a single flavor
"""
url_regex = r'nova/flavors/(?P<flavor_id>[^/]+)/$'
@rest_utils.ajax()
[docs] def get(self, request, flavor_id):
"""Get a specific flavor
:param get_extras: Also retrieve the extra specs.
Example GET:
http://localhost/api/nova/flavors/1
"""
get_extras = self.extract_boolean(request, 'get_extras')
get_access_list = self.extract_boolean(request, 'get_access_list')
flavor = api.nova.flavor_get(request, flavor_id, get_extras=get_extras)
result = flavor.to_dict()
# Bug: nova API stores and returns empty string when swap equals 0
# https://bugs.launchpad.net/nova/+bug/1408954
if 'swap' in result and result['swap'] == '':
result['swap'] = 0
if get_extras:
result['extras'] = flavor.extras
if get_access_list and not flavor.is_public:
access_list = [item.tenant_id for item in
api.nova.flavor_access_list(request, flavor_id)]
result['access-list'] = access_list
return result
@rest_utils.ajax()
[docs] def delete(self, request, flavor_id):
api.nova.flavor_delete(request, flavor_id)
@rest_utils.ajax(data_required=True)
[docs] def patch(self, request, flavor_id):
flavor_access = request.DATA.get('flavor_access', [])
is_public = not flavor_access
# Grab any existing extra specs, because flavor edit is currently
# implemented as a delete followed by a create.
extras_dict = api.nova.flavor_get_extras(request, flavor_id, raw=True)
# Mark the existing flavor as deleted.
api.nova.flavor_delete(request, flavor_id)
# Then create a new flavor with the same name but a new ID.
# This is in the same try/except block as the delete call
# because if the delete fails the API will error out because
# active flavors can't have the same name.
flavor = api.nova.flavor_create(request,
name=request.DATA['name'],
memory=request.DATA['ram'],
vcpu=request.DATA['vcpus'],
disk=request.DATA['disk'],
ephemeral=request
.DATA['OS-FLV-EXT-DATA:ephemeral'],
swap=request.DATA['swap'],
flavorid=flavor_id,
is_public=is_public
)
for project in flavor_access:
api.nova.add_tenant_to_flavor(
request, flavor.id, project.get('id'))
if extras_dict:
api.nova.flavor_extra_set(request, flavor.id, extras_dict)
@urls.register
@urls.register
@urls.register
[docs]class DefaultQuotaSets(generic.View):
"""API for getting default quotas for nova
"""
url_regex = r'nova/quota-sets/defaults/$'
@rest_utils.ajax()
[docs] def get(self, request):
"""Get the values for Nova specific quotas
Example GET:
http://localhost/api/nova/quota-sets/defaults/
"""
if api.base.is_service_enabled(request, 'compute'):
quota_set = api.nova.default_quota_get(request,
request.user.tenant_id)
disabled_quotas = quotas.get_disabled_quotas(request)
filtered_quotas = [quota for quota in quota_set
if quota.name not in disabled_quotas]
result = [{
'display_name': quotas.QUOTA_NAMES.get(
quota.name,
quota.name.replace("_", " ").title()
) + '',
'name': quota.name,
'limit': quota.limit
} for quota in filtered_quotas]
return {'items': result}
else:
raise rest_utils.AjaxError(501, _('Service Nova is disabled.'))
@rest_utils.ajax(data_required=True)
[docs] def patch(self, request):
"""Update the values for Nova specific quotas
This method returns HTTP 204 (no content) on success.
"""
if api.base.is_service_enabled(request, 'compute'):
disabled_quotas = quotas.get_disabled_quotas(request)
all_quotas = quotas.NOVA_QUOTA_FIELDS + quotas.MISSING_QUOTA_FIELDS
filtered_quotas = [quota for quota in all_quotas
if quota not in disabled_quotas]
request_data = {
key: request.DATA.get(key, None) for key in filtered_quotas
}
nova_data = {key: value for key, value in request_data.items()
if value is not None}
api.nova.default_quota_update(request, **nova_data)
else:
raise rest_utils.AjaxError(501, _('Service Nova is disabled.'))
@urls.register
[docs]class EditableQuotaSets(generic.View):
"""API for editable quotas.
"""
url_regex = r'nova/quota-sets/editable/$'
@rest_utils.ajax()
[docs] def get(self, request):
"""Get a list of editable quota fields.
The listing result is an object with property "items". Each item
is an editable quota. Returns an empty list in case no editable
quota is found.
"""
disabled_quotas = quotas.get_disabled_quotas(request)
editable_quotas = [quota for quota in quotas.QUOTA_FIELDS
if quota not in disabled_quotas]
return {'items': editable_quotas}
@urls.register
[docs]class QuotaSets(generic.View):
"""API for setting quotas for a given project.
"""
url_regex = r'nova/quota-sets/(?P<project_id>[0-9a-f]+)$'
@rest_utils.ajax(data_required=True)
[docs] def patch(self, request, project_id):
"""Update a single project quota data.
The PATCH data should be an application/json object with the
attributes to set to new quota values.
This method returns HTTP 204 (no content) on success.
"""
disabled_quotas = quotas.get_disabled_quotas(request)
if api.base.is_service_enabled(request, 'compute'):
nova_data = {
key: request.DATA[key] for key in quotas.NOVA_QUOTA_FIELDS
if key not in disabled_quotas
}
api.nova.tenant_quota_update(request, project_id, **nova_data)
else:
raise rest_utils.AjaxError(501, _('Service Nova is disabled.'))