def create(self, req, body, tenant_id):
context = req.environ[wsgi.CONTEXT_KEY]
data = body['backup']
instance_id = data['instance']
# verify that the instance exist
models.get_db_info(context, instance_id)
# verify that no other backup for this instance is running
running_backups = [b
for b in Backup.list_for_instance(instance_id)
if b.state != BackupState.COMPLETED
and b.state != BackupState.FAILED]
if len(running_backups) > 0:
raise exception.BackupAlreadyRunning(action='create',
backup_id=running_backups[
0].id)
self._verify_swift_auth_token(context)
backup = Backup.create(context, instance_id,
data['name'], data['description'])
api.API(context).create_backup(instance_id)
return wsgi.Result(views.BackupView(backup).data(), 202)
def delete(self, req, tenant_id, id):
context = req.environ[wsgi.CONTEXT_KEY]
# verify that this backup is not running
backup = Backup.get_by_id(id)
if backup.state != BackupState.COMPLETED and backup.state != \
BackupState.FAILED:
raise exception.BackupAlreadyRunning(action='delete',
backup_id=id)
self._verify_swift_auth_token(context)
api.API(context).delete_backup(id)
Backup.delete(id)
return wsgi.Result(None, 202)
def _create_resources():
client = create_nova_client(context)
security_groups = None
try:
flavor = client.flavors.get(flavor_id)
except nova_exceptions.NotFound:
raise exception.FlavorNotFound(uuid=flavor_id)
if backup_id is not None:
backup_info = Backup.get_by_id(backup_id)
if backup_info.is_running:
raise exception.BackupNotCompleteError(backup_id=backup_id)
location = backup_info.location
LOG.info(_("Checking if backup exist in '%s'") % location)
if not Backup.check_object_exist(context, location):
raise exception.BackupFileNotFound(location=location)
db_info = DBInstance.create(name=name,
flavor_id=flavor_id,
tenant_id=context.tenant,
volume_size=volume_size,
task_status=InstanceTasks.BUILDING)
LOG.debug(
_("Tenant %s created new Reddwarf instance %s...") %
(context.tenant, db_info.id))
service_status = InstanceServiceStatus.create(
instance_id=db_info.id, status=ServiceStatuses.NEW)
if CONF.reddwarf_dns_support:
dns_client = create_dns_client(context)
hostname = dns_client.determine_hostname(db_info.id)
db_info.hostname = hostname
db_info.save()
if CONF.reddwarf_security_groups_support:
security_group = SecurityGroup.create_for_instance(
db_info.id, context)
security_groups = [security_group["name"]]
task_api.API(context).create_instance(db_info.id, name, flavor_id,
flavor.ram, image_id,
databases, users,
service_type, volume_size,
security_groups, backup_id)
return SimpleInstance(context, db_info, service_status)
def _create_resources():
client = create_nova_client(context)
security_groups = None
try:
flavor = client.flavors.get(flavor_id)
except nova_exceptions.NotFound:
raise exception.FlavorNotFound(uuid=flavor_id)
if backup_id is not None:
backup_info = Backup.get_by_id(backup_id)
if backup_info.is_running:
raise exception.BackupNotCompleteError(backup_id=backup_id)
location = backup_info.location
LOG.info(_("Checking if backup exist in '%s'") % location)
if not Backup.check_object_exist(context, location):
raise exception.BackupFileNotFound(location=location)
db_info = DBInstance.create(name=name, flavor_id=flavor_id,
tenant_id=context.tenant,
volume_size=volume_size,
task_status=InstanceTasks.BUILDING)
LOG.debug(_("Tenant %s created new Reddwarf instance %s...")
% (context.tenant, db_info.id))
service_status = InstanceServiceStatus.create(
instance_id=db_info.id,
status=ServiceStatuses.NEW)
if CONF.reddwarf_dns_support:
dns_client = create_dns_client(context)
hostname = dns_client.determine_hostname(db_info.id)
db_info.hostname = hostname
db_info.save()
if CONF.reddwarf_security_groups_support:
security_group = SecurityGroup.create_for_instance(
db_info.id,
context)
security_groups = [security_group["name"]]
task_api.API(context).create_instance(db_info.id, name, flavor_id,
flavor.ram, image_id,
databases, users,
service_type, volume_size,
security_groups, backup_id)
return SimpleInstance(context, db_info, service_status)
def backups(self, req, tenant_id, id):
"""Return all backups for the specified instance."""
LOG.info(_("req : '%s'\n\n") % req)
LOG.info(_("Indexing backups for instance '%s'") % id)
backups = backup_model.list_for_instance(id)
return wsgi.Result(backup_views.BackupViews(backups).data(), 200)
def index(self, req, tenant_id):
"""
Return all backups information for a tenant ID.
"""
context = req.environ[wsgi.CONTEXT_KEY]
backups = Backup.list(context)
return wsgi.Result(views.BackupViews(backups).data(), 200)
def backups(self, req, tenant_id, id):
"""Return all backups for the specified instance."""
LOG.info(_("req : '%s'\n\n") % req)
LOG.info(_("Indexing backups for instance '%s'") %
id)
backups = backup_model.list_for_instance(id)
return wsgi.Result(backup_views.BackupViews(backups).data(), 200)
def index(self, req, tenant_id):
"""
Return all backups information for a tenant ID.
"""
LOG.debug("Listing Backups for tenant '%s'" % tenant_id)
context = req.environ[wsgi.CONTEXT_KEY]
backups = Backup.list(context)
return wsgi.Result(views.BackupViews(backups).data(), 200)
def create_backup(self, backup_id):
from reddwarf.backup.models import Backup, BackupState
backup = Backup.get_by_id(backup_id)
def finish_create_backup():
backup.state = BackupState.COMPLETED
backup.save()
self.event_spawn(1.0, finish_create_backup)
def create_backup(self, backup_id):
from reddwarf.backup.models import Backup, BackupState
backup = Backup.get_by_id(backup_id)
def finish_create_backup():
backup.state = BackupState.COMPLETED
backup.save()
self.event_spawn(1.0, finish_create_backup)
def create(self, req, body, tenant_id):
LOG.debug("Creating a Backup for tenant '%s'" % tenant_id)
self._validate_create_body(body)
context = req.environ[wsgi.CONTEXT_KEY]
data = body['backup']
instance = data['instance']
name = data['name']
desc = data.get('description')
backup = Backup.create(context, instance, name, desc)
return wsgi.Result(views.BackupView(backup).data(), 202)
def status(self):
### Check for taskmanager errors.
if self.db_info.task_status.is_error:
return InstanceStatus.ERROR
### Check for taskmanager status.
ACTION = self.db_info.task_status.action
if 'BUILDING' == ACTION:
if 'ERROR' == self.db_info.server_status:
return InstanceStatus.ERROR
return InstanceStatus.BUILD
if 'REBOOTING' == ACTION:
return InstanceStatus.REBOOT
if 'RESIZING' == ACTION:
return InstanceStatus.RESIZE
### Check for server status.
if self.db_info.server_status in [
"BUILD", "ERROR", "REBOOT", "RESIZE"
]:
return self.db_info.server_status
### Check if there is a backup running for this instance
if Backup.running(self.id):
return InstanceStatus.BACKUP
### Report as Shutdown while deleting, unless there's an error.
if 'DELETING' == ACTION:
if self.db_info.server_status in ["ACTIVE", "SHUTDOWN", "DELETED"]:
return InstanceStatus.SHUTDOWN
else:
msg = _("While shutting down instance (%s): server had "
"status (%s).")
LOG.error(msg % (self.id, self.db_info.server_status))
return InstanceStatus.ERROR
### Check against the service status.
# The service is only paused during a reboot.
if ServiceStatuses.PAUSED == self.service_status.status:
return InstanceStatus.REBOOT
# If the service status is NEW, then we are building.
if ServiceStatuses.NEW == self.service_status.status:
return InstanceStatus.BUILD
# For everything else we can look at the service status mapping.
return self.service_status.status.api_status
def status(self):
### Check for taskmanager errors.
if self.db_info.task_status.is_error:
return InstanceStatus.ERROR
### Check for taskmanager status.
ACTION = self.db_info.task_status.action
if 'BUILDING' == ACTION:
if 'ERROR' == self.db_info.server_status:
return InstanceStatus.ERROR
return InstanceStatus.BUILD
if 'REBOOTING' == ACTION:
return InstanceStatus.REBOOT
if 'RESIZING' == ACTION:
return InstanceStatus.RESIZE
### Check for server status.
if self.db_info.server_status in ["BUILD", "ERROR", "REBOOT",
"RESIZE"]:
return self.db_info.server_status
### Check if there is a backup running for this instance
if Backup.running(self.id):
return InstanceStatus.BACKUP
### Report as Shutdown while deleting, unless there's an error.
if 'DELETING' == ACTION:
if self.db_info.server_status in ["ACTIVE", "SHUTDOWN", "DELETED"]:
return InstanceStatus.SHUTDOWN
else:
msg = _("While shutting down instance (%s): server had "
"status (%s).")
LOG.error(msg % (self.id, self.db_info.server_status))
return InstanceStatus.ERROR
### Check against the service status.
# The service is only paused during a reboot.
if ServiceStatuses.PAUSED == self.service_status.status:
return InstanceStatus.REBOOT
# If the service status is NEW, then we are building.
if ServiceStatuses.NEW == self.service_status.status:
return InstanceStatus.BUILD
# For everything else we can look at the service status mapping.
return self.service_status.status.api_status
def validate_can_perform_action(self):
"""
Raises exception if an instance action cannot currently be performed.
"""
if self.db_info.server_status != 'ACTIVE':
status = self.db_info.server_status
elif self.db_info.task_status != InstanceTasks.NONE:
status = self.db_info.task_status
elif not self.service_status.status.action_is_allowed:
status = self.status
elif Backup.running(self.id):
status = InstanceStatus.BACKUP
else:
return
msg = ("Instance is not currently available for an action to be "
"performed (status was %s)." % status)
LOG.error(msg)
raise exception.UnprocessableEntity(msg)
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
if body['instance'].get('restorePoint', None) is not None:
backup_id = body['instance']['restorePoint']['backupId']
backup_info = backup_model.get_by_id(backup_id)
if not backup_info.state == BackupState.COMPLETED:
raise exception.BackupNotCompleteError(backup_id=backup_id)
# verify backup file exist in swift
location = backup_info.location
if not InstanceController._check_object_exist(context, location):
raise exception.BackupFileNotFound(location=location)
else:
backup_id = None
instance = models.Instance.create(context, name, flavor_id,
image_id, databases, users,
service_type, volume_size,
backup_id)
view = views.InstanceDetailView(instance, req=req)
return wsgi.Result(view.data(), 200)
def validate_can_perform_action(self):
"""
Raises exception if an instance action cannot currently be performed.
"""
status = None
if self.db_info.server_status != 'ACTIVE':
status = self.db_info.server_status
elif self.db_info.task_status != InstanceTasks.NONE:
status = self.db_info.task_status
elif not self.service_status.status.action_is_allowed:
status = self.status
elif Backup.running(self.id):
status = InstanceStatus.BACKUP
else:
return
msg = ("Instance is not currently available for an action to be "
"performed (status was %s)." % status)
LOG.error(msg)
raise exception.UnprocessableEntity(msg)
def delete(self, req, tenant_id, id):
LOG.debug("Delete Backup for tenant: %s, ID: %s" % (tenant_id, id))
context = req.environ[wsgi.CONTEXT_KEY]
Backup.delete(context, id)
return wsgi.Result(None, 202)
def show(self, req, tenant_id, id):
"""Return a single backup."""
LOG.info(_("Showing a backup for tenant '%s'") % tenant_id)
LOG.info(_("id : '%s'\n\n") % id)
backup = Backup.get_by_id(id)
return wsgi.Result(views.BackupView(backup).data(), 200)
