143 lines
4.9 KiB
Python
143 lines
4.9 KiB
Python
# Copyright [2015] Hewlett-Packard Development Company, L.P.
|
|
# 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 oslo_log import log as logging
|
|
|
|
from trove.common.clients import create_guest_client
|
|
from trove.common.db import models as guest_models
|
|
from trove.common import exception
|
|
from trove.common import timeutils
|
|
from trove.db import get_db_api
|
|
from trove.instance import models as base_models
|
|
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
|
|
def load_and_verify(context, instance_id,
|
|
enabled_datastore=['mysql', 'mariadb']):
|
|
"""Check instance datastore.
|
|
|
|
Some API operations are only supported for some specific datastores.
|
|
"""
|
|
instance = base_models.Instance.load(context, instance_id)
|
|
|
|
if instance.datastore.name not in enabled_datastore:
|
|
raise exception.UnprocessableEntity(
|
|
f"Operation not supported for datastore {instance.datastore.name}."
|
|
)
|
|
|
|
if not instance.is_datastore_running:
|
|
raise exception.UnprocessableEntity(
|
|
"Instance %s is not ready, status: %s." %
|
|
(instance.id, instance.datastore_status.status)
|
|
)
|
|
|
|
return instance
|
|
|
|
|
|
class Root(object):
|
|
|
|
@classmethod
|
|
def load(cls, context, instance_id):
|
|
load_and_verify(context, instance_id,
|
|
enabled_datastore=['mysql', 'mariadb', 'postgresql'])
|
|
# TODO(pdmars): remove the is_root_enabled call from the guest agent,
|
|
# just check the database for this information.
|
|
# If the root history returns null or raises an exception, the root
|
|
# user hasn't been enabled.
|
|
try:
|
|
root_history = RootHistory.load(context, instance_id)
|
|
except exception.NotFound:
|
|
return False
|
|
if not root_history:
|
|
return False
|
|
return True
|
|
|
|
@classmethod
|
|
def create(cls, context, instance_id, root_password,
|
|
cluster_instances_list=None):
|
|
load_and_verify(context, instance_id,
|
|
enabled_datastore=['mysql', 'mariadb', 'postgresql'])
|
|
if root_password:
|
|
root = create_guest_client(context,
|
|
instance_id).enable_root_with_password(
|
|
root_password)
|
|
else:
|
|
root = create_guest_client(context, instance_id).enable_root()
|
|
|
|
root_user = guest_models.DatastoreUser.deserialize(root,
|
|
verify=False)
|
|
root_user.make_root()
|
|
|
|
# if cluster_instances_list none, then root create is called for
|
|
# single instance, adding an RootHistory entry for the instance_id
|
|
if cluster_instances_list is None:
|
|
RootHistory.create(context, instance_id)
|
|
|
|
return root_user
|
|
|
|
@classmethod
|
|
def delete(cls, context, instance_id):
|
|
load_and_verify(context, instance_id,
|
|
enabled_datastore=['mysql', 'mariadb', 'postgresql'])
|
|
create_guest_client(context, instance_id).disable_root()
|
|
|
|
|
|
class ClusterRoot(Root):
|
|
|
|
@classmethod
|
|
def create(cls, context, instance_id, root_password,
|
|
cluster_instances_list=None):
|
|
root_user = super(ClusterRoot, cls).create(context, instance_id,
|
|
root_password,
|
|
cluster_instances_list=None)
|
|
|
|
if cluster_instances_list:
|
|
for instance in cluster_instances_list:
|
|
RootHistory.create(context, instance)
|
|
|
|
return root_user
|
|
|
|
|
|
class RootHistory(object):
|
|
|
|
_auto_generated_attrs = ['id']
|
|
_data_fields = ['instance_id', 'user', 'created']
|
|
_table_name = 'root_enabled_history'
|
|
|
|
def __init__(self, instance_id, user):
|
|
self.id = instance_id
|
|
self.user = user
|
|
self.created = timeutils.utcnow()
|
|
|
|
def save(self):
|
|
LOG.debug("Saving %(name)s: %(dict)s",
|
|
{'name': self.__class__.__name__, 'dict': self.__dict__})
|
|
return get_db_api().save(self)
|
|
|
|
@classmethod
|
|
def load(cls, context, instance_id):
|
|
history = get_db_api().find_by(cls, id=instance_id)
|
|
return history
|
|
|
|
@classmethod
|
|
def create(cls, context, instance_id):
|
|
history = cls.load(context, instance_id)
|
|
if history is not None:
|
|
return history
|
|
history = RootHistory(instance_id, context.user)
|
|
return history.save()
|