435 lines
15 KiB
Python
435 lines
15 KiB
Python
# Copyright 2013 Rackspace Hosting.
|
|
#
|
|
# 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 django.conf import settings
|
|
from horizon.utils import functions as utils
|
|
from horizon.utils.memoized import memoized # noqa
|
|
from keystoneauth1 import session
|
|
from keystoneclient.auth import token_endpoint
|
|
from novaclient import client as nova_client
|
|
from openstack_auth import utils as auth_utils
|
|
from openstack_dashboard.api import base
|
|
from oslo_log import log as logging
|
|
from troveclient.v1 import client
|
|
|
|
# Supported compute versions
|
|
NOVA_VERSIONS = base.APIVersionManager("compute", preferred_version=2)
|
|
NOVA_VERSIONS.load_supported_version(1.1,
|
|
{"client": nova_client, "version": 1.1})
|
|
NOVA_VERSIONS.load_supported_version(2, {"client": nova_client, "version": 2})
|
|
NOVA_VERSION = NOVA_VERSIONS.get_active_version()['version']
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
|
|
@memoized
|
|
def troveclient(request):
|
|
insecure = getattr(settings, 'OPENSTACK_SSL_NO_VERIFY', False)
|
|
cacert = getattr(settings, 'OPENSTACK_SSL_CACERT', None)
|
|
endpoint_type = getattr(settings, 'OPENSTACK_ENDPOINT_TYPE', 'publicURL')
|
|
region = request.user.services_region
|
|
|
|
endpoint = base.url_for(request, 'database')
|
|
auth_url, _ = auth_utils.fix_auth_url_version_prefix(
|
|
settings.OPENSTACK_KEYSTONE_URL)
|
|
auth = token_endpoint.Token(auth_url, request.user.token.id)
|
|
verify = not insecure and (cacert or True)
|
|
|
|
t_client = client.Client(session=session.Session(auth=auth, verify=verify),
|
|
service_type='database',
|
|
endpoint_type=endpoint_type,
|
|
region_name=region,
|
|
endpoint_override=endpoint)
|
|
return t_client
|
|
|
|
|
|
def cluster_list(request, marker=None):
|
|
page_size = utils.get_page_size(request)
|
|
return troveclient(request).clusters.list(limit=page_size, marker=marker)
|
|
|
|
|
|
def cluster_get(request, cluster_id):
|
|
return troveclient(request).clusters.get(cluster_id)
|
|
|
|
|
|
def cluster_delete(request, cluster_id):
|
|
return troveclient(request).clusters.delete(cluster_id)
|
|
|
|
|
|
def cluster_create(request, name, volume, flavor, num_instances,
|
|
datastore, datastore_version,
|
|
nics=None, root_password=None, locality=None):
|
|
instances = []
|
|
for i in range(num_instances):
|
|
instance = {}
|
|
instance["flavorRef"] = flavor
|
|
if volume > 0:
|
|
instance["volume"] = {'size': volume}
|
|
if nics:
|
|
instance["nics"] = [{"net-id": nics}]
|
|
instances.append(instance)
|
|
|
|
# TODO(saurabhs): vertica needs root password on cluster create
|
|
return troveclient(request).clusters.create(
|
|
name,
|
|
datastore,
|
|
datastore_version,
|
|
instances=instances,
|
|
locality=locality)
|
|
|
|
|
|
def cluster_grow(request, cluster_id, new_instances):
|
|
instances = []
|
|
for new_instance in new_instances:
|
|
instance = {}
|
|
instance["flavorRef"] = new_instance.flavor_id
|
|
if new_instance.volume > 0:
|
|
instance["volume"] = {'size': new_instance.volume}
|
|
if new_instance.name:
|
|
instance["name"] = new_instance.name
|
|
if new_instance.type:
|
|
instance["type"] = new_instance.type
|
|
if new_instance.related_to:
|
|
instance["related_to"] = new_instance.related_to
|
|
if new_instance.nics:
|
|
instance["nics"] = [{'net-id': new_instance.nics}]
|
|
instances.append(instance)
|
|
return troveclient(request).clusters.grow(cluster_id, instances)
|
|
|
|
|
|
def cluster_shrink(request, cluster_id, instances):
|
|
return troveclient(request).clusters.shrink(cluster_id, instances)
|
|
|
|
|
|
def create_cluster_root(request, cluster_id, password):
|
|
# It appears the code below depends on this trove change
|
|
# https://review.opendev.org/#/c/166954/. Comment out when that
|
|
# change merges.
|
|
# return troveclient(request).cluster.reset_root_password(cluster_id)
|
|
troveclient(request).root.create_cluster_root(cluster_id, password)
|
|
|
|
|
|
def instance_list(request, marker=None):
|
|
page_size = utils.get_page_size(request)
|
|
return troveclient(request).instances.list(limit=page_size, marker=marker)
|
|
|
|
|
|
def instance_list_all(request):
|
|
instances = instance_list(request)
|
|
marker = instances.next
|
|
while marker:
|
|
temp_instances = instance_list(request, marker=marker)
|
|
marker = temp_instances.next
|
|
for instance in temp_instances:
|
|
instances.append(instance)
|
|
instances.links = temp_instances.links
|
|
instances.next = None
|
|
return instances
|
|
|
|
|
|
def instance_get(request, instance_id):
|
|
return troveclient(request).instances.get(instance_id)
|
|
|
|
|
|
def instance_delete(request, instance_id):
|
|
return troveclient(request).instances.delete(instance_id)
|
|
|
|
|
|
def instance_create(request, name, volume, flavor, databases=None,
|
|
users=None, restore_point=None, nics=None,
|
|
datastore=None, datastore_version=None,
|
|
replica_of=None, replica_count=None,
|
|
volume_type=None, configuration=None, locality=None,
|
|
availability_zone=None):
|
|
# TODO(dklyle): adding conditional to support trove without volume
|
|
# support for now until API supports checking for volume support
|
|
if volume > 0:
|
|
volume_params = {'size': volume}
|
|
if volume_type:
|
|
volume_params['type'] = volume_type
|
|
else:
|
|
volume_params = None
|
|
return troveclient(request).instances.create(
|
|
name,
|
|
flavor,
|
|
volume=volume_params,
|
|
databases=databases,
|
|
users=users,
|
|
restorePoint=restore_point,
|
|
nics=nics,
|
|
datastore=datastore,
|
|
datastore_version=datastore_version,
|
|
replica_of=replica_of,
|
|
replica_count=replica_count,
|
|
configuration=configuration,
|
|
locality=locality,
|
|
availability_zone=availability_zone)
|
|
|
|
|
|
def instance_resize_volume(request, instance_id, size):
|
|
return troveclient(request).instances.resize_volume(instance_id, size)
|
|
|
|
|
|
def instance_resize(request, instance_id, flavor_id):
|
|
return troveclient(request).instances.resize_instance(instance_id,
|
|
flavor_id)
|
|
|
|
|
|
def instance_backups(request, instance_id):
|
|
return troveclient(request).instances.backups(instance_id)
|
|
|
|
|
|
def instance_restart(request, instance_id):
|
|
return troveclient(request).instances.restart(instance_id)
|
|
|
|
|
|
def instance_detach_replica(request, instance_id):
|
|
return troveclient(request).instances.edit(instance_id,
|
|
detach_replica_source=True)
|
|
|
|
|
|
def promote_to_replica_source(request, instance_id):
|
|
return troveclient(request).instances.promote_to_replica_source(
|
|
instance_id)
|
|
|
|
|
|
def eject_replica_source(request, instance_id):
|
|
return troveclient(request).instances.eject_replica_source(instance_id)
|
|
|
|
|
|
def instance_attach_configuration(request, instance_id, configuration):
|
|
return troveclient(request).instances.modify(instance_id,
|
|
configuration=configuration)
|
|
|
|
|
|
def instance_detach_configuration(request, instance_id):
|
|
return troveclient(request).instances.modify(instance_id)
|
|
|
|
|
|
def database_list(request, instance_id):
|
|
return troveclient(request).databases.list(instance_id)
|
|
|
|
|
|
def database_create(request, instance_id, db_name, character_set=None,
|
|
collation=None):
|
|
database = {'name': db_name}
|
|
if collation:
|
|
database['collate'] = collation
|
|
if character_set:
|
|
database['character_set'] = character_set
|
|
return troveclient(request).databases.create(instance_id, [database])
|
|
|
|
|
|
def database_delete(request, instance_id, db_name):
|
|
return troveclient(request).databases.delete(instance_id, db_name)
|
|
|
|
|
|
def backup_list(request):
|
|
return troveclient(request).backups.list()
|
|
|
|
|
|
def backup_get(request, backup_id):
|
|
return troveclient(request).backups.get(backup_id)
|
|
|
|
|
|
def backup_delete(request, backup_id):
|
|
return troveclient(request).backups.delete(backup_id)
|
|
|
|
|
|
def backup_create(request, name, instance_id, description=None,
|
|
parent_id=None):
|
|
return troveclient(request).backups.create(name, instance_id,
|
|
description, parent_id)
|
|
|
|
|
|
def nova_client_client(request):
|
|
insecure = getattr(settings, 'OPENSTACK_SSL_NO_VERIFY', False)
|
|
cacert = getattr(settings, 'OPENSTACK_SSL_CACERT', None)
|
|
endpoint_type = getattr(settings, 'OPENSTACK_ENDPOINT_TYPE', 'publicURL')
|
|
region = request.user.services_region
|
|
|
|
endpoint = base.url_for(request, 'compute')
|
|
auth_url, _ = auth_utils.fix_auth_url_version_prefix(
|
|
settings.OPENSTACK_KEYSTONE_URL)
|
|
auth = token_endpoint.Token(auth_url, request.user.token.id)
|
|
verify = not insecure and (cacert or True)
|
|
|
|
nova = nova_client.Client(
|
|
NOVA_VERSION,
|
|
session=session.Session(auth=auth, verify=verify),
|
|
endpoint_type=endpoint_type,
|
|
service_type='compute',
|
|
region_name=region,
|
|
endpoint_override=endpoint)
|
|
|
|
return nova
|
|
|
|
|
|
def flavor_list(request):
|
|
return nova_client_client(request).flavors.list()
|
|
|
|
|
|
def datastore_flavors(request, datastore_name=None,
|
|
datastore_version=None):
|
|
return flavor_list(request)
|
|
|
|
|
|
def flavor_get(request, flavor_id):
|
|
return nova_client_client(request).flavors.get(flavor_id)
|
|
|
|
|
|
def root_enable(request, instance_ids):
|
|
username, password = troveclient(request).root.create(instance_ids[0])
|
|
return username, password
|
|
|
|
|
|
def root_show(request, instance_id):
|
|
return troveclient(request).root.is_root_enabled(instance_id)
|
|
|
|
|
|
def root_disable(request, instance_id):
|
|
return troveclient(request).root.delete(instance_id)
|
|
|
|
|
|
def users_list(request, instance_id):
|
|
return troveclient(request).users.list(instance_id)
|
|
|
|
|
|
def user_create(request, instance_id, username, password,
|
|
host=None, databases=[]):
|
|
user = {'name': username, 'password': password, 'databases': databases}
|
|
if host:
|
|
user['host'] = host
|
|
|
|
return troveclient(request).users.create(instance_id, [user])
|
|
|
|
|
|
def user_delete(request, instance_id, user, host=None):
|
|
return troveclient(request).users.delete(instance_id, user, hostname=host)
|
|
|
|
|
|
def user_update_attributes(request, instance_id, name, host=None,
|
|
new_name=None, new_password=None, new_host=None):
|
|
new_attributes = {}
|
|
if new_name:
|
|
new_attributes['name'] = new_name
|
|
if new_password:
|
|
new_attributes['password'] = new_password
|
|
if new_host:
|
|
new_attributes['host'] = new_host
|
|
return troveclient(request).users.update_attributes(
|
|
instance_id, name, newuserattr=new_attributes, hostname=host)
|
|
|
|
|
|
def user_list_access(request, instance_id, username, host=None):
|
|
return troveclient(request).users.list_access(
|
|
instance_id, username, hostname=host)
|
|
|
|
|
|
def user_grant_access(request, instance_id, username, databases, host=None):
|
|
return troveclient(request).users.grant(
|
|
instance_id, username, databases, hostname=host)
|
|
|
|
|
|
def user_revoke_access(request, instance_id, username, database, host=None):
|
|
return troveclient(request).users.revoke(
|
|
instance_id, username, database, hostname=host)
|
|
|
|
|
|
def user_show_access(request, instance_id, username, host=None):
|
|
return troveclient(request).users.list_access(
|
|
instance_id, username, hostname=host)
|
|
|
|
|
|
def datastore_list(request):
|
|
return troveclient(request).datastores.list()
|
|
|
|
|
|
def datastore_version_list(request, datastore):
|
|
return troveclient(request).datastore_versions.list(datastore)
|
|
|
|
|
|
def log_list(request, instance_id):
|
|
return troveclient(request).instances.log_list(instance_id)
|
|
|
|
|
|
def log_enable(request, instance_id, log_name):
|
|
return troveclient(request).instances.log_action(instance_id, log_name,
|
|
enable=True)
|
|
|
|
|
|
def log_disable(request, instance_id, log_name):
|
|
return troveclient(request).instances.log_action(instance_id, log_name,
|
|
disable=True)
|
|
|
|
|
|
def log_publish(request, instance_id, log_name):
|
|
return troveclient(request).instances.log_action(instance_id, log_name,
|
|
publish=True)
|
|
|
|
|
|
def log_discard(request, instance_id, log_name):
|
|
return troveclient(request).instances.log_action(instance_id, log_name,
|
|
discard=True)
|
|
|
|
|
|
def log_tail(request, instance_id, log_name, publish, lines, swift=None):
|
|
return troveclient(request).instances.log_generator(instance_id,
|
|
log_name,
|
|
publish=publish,
|
|
lines=lines,
|
|
swift=swift)
|
|
|
|
|
|
def configuration_list(request):
|
|
return troveclient(request).configurations.list()
|
|
|
|
|
|
def configuration_get(request, group_id):
|
|
return troveclient(request).configurations.get(group_id)
|
|
|
|
|
|
def configuration_parameters_list(request, datastore, datastore_version):
|
|
return troveclient(request).configuration_parameters.parameters(
|
|
datastore, datastore_version)
|
|
|
|
|
|
def configuration_create(request,
|
|
name,
|
|
values,
|
|
description=None,
|
|
datastore=None,
|
|
datastore_version=None):
|
|
return troveclient(request).configurations.create(name,
|
|
values,
|
|
description,
|
|
datastore,
|
|
datastore_version)
|
|
|
|
|
|
def configuration_delete(request, group_id):
|
|
return troveclient(request).configurations.delete(group_id)
|
|
|
|
|
|
def configuration_instances(request, group_id):
|
|
return troveclient(request).configurations.instances(group_id)
|
|
|
|
|
|
def configuration_update(request, group_id, values):
|
|
return troveclient(request).configurations.update(group_id, values)
|
|
|
|
|
|
def configuration_default(request, instance_id):
|
|
return troveclient(request).instances.configuration(instance_id)
|