def admin_user(self, req, tenant_id, id):
"""Return admin user name for the specified instance."""
LOG.info(_("req : '%s'\n\n") % req)
LOG.info(_("Get admin user name for instance or group '%s'")%id)
if False==uuid.is_uuid_like(id):
msg = (_("Wrong id of instance or group."))
LOG.error(msg)
raise exception.BadRequest(msg)
group_id = None
context = req.environ[wsgi.CONTEXT_KEY]
try:
db_info = models.get_db_info(context, id)
group_id = db_info.group_id
except exception.NotFound:
LOG.debug("Not instance id %s"%id)
pass
if group_id==None:
try:
InstanceGroup.get_by_groupid(context, id)
group_id = id
except exception.NotFound:
msg = (_("Without find instance or group of the id"))
LOG.error(msg)
raise exception.BadRequest(msg)
group = InstanceGroup.get_by_groupid(context, group_id)
ret = {'admin_user': {"admin_user": group.admin_name}}
return wsgi.Result(ret, 202)
def show(self, req, tenant_id, id):
"""Return a single backup."""
LOG.debug("Showing a backup for tenant %s ID: '%s'"
% (tenant_id, id))
context = req.environ[wsgi.CONTEXT_KEY]
backup = Backup.get_by_id(context, id)
instance = get_db_info(context, backup.instance_id, None, True)
backup.instance_name = instance.name
return wsgi.Result(views.BackupView(backup).data(), 200)
def backups(self, req, tenant_id, id):
"""Return all backups for the specified instance."""
LOG.info(_LI("Listing backups for instance '%s'"),
id)
LOG.debug("req : '%s'\n\n", req)
context = req.environ[wsgi.CONTEXT_KEY]
backups, marker = backup_model.list_for_instance(context, id)
for b in backups:
instance = get_db_info(context, b.instance_id, None, True)
b.instance_name = instance.name
view = backup_views.BackupViews(backups)
paged = pagination.SimplePaginatedDataView(req.url, 'backups', view,
marker)
return wsgi.Result(paged.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)
datastore = req.GET.get('datastore')
context = req.environ[wsgi.CONTEXT_KEY]
backups, marker = Backup.list(context, datastore)
for b in backups:
instance = get_db_info(context, b.instance_id, None, True)
b.instance_name = instance.name
view = views.BackupViews(backups)
paged = pagination.SimplePaginatedDataView(req.url, 'backups', view,
marker)
return wsgi.Result(paged.data(), 200)
def create(cls, context, instance_id, group_id, name, location, size, binlog_start_time):
from trove.instance.models import get_db_info
instance = get_db_info(context, instance_id)
try:
db_info = super(DBBinlog, cls).create(
name=name,
location=location,
size=size,
binlog_start_time=binlog_start_time,
tenant_id=context.tenant,
instance_id=instance_id,
group_id=group_id,
deleted=False)
except exception.InvalidModelError as ex:
LOG.exception("Unable to create Binlog record:")
raise exception.BackupCreationError(str(ex))
return db_info
def create(self, req, body, tenant_id):
LOG.debug("Creating a Security Group Rule for tenant '%s'" % tenant_id)
context = req.environ[wsgi.CONTEXT_KEY]
self._validate_create_body(body)
sec_group_id = body['security_group_rule']['group_id']
sec_group = models.SecurityGroup.find_by(id=sec_group_id,
tenant_id=tenant_id,
deleted=False)
instance_id = (models.SecurityGroupInstanceAssociation.
get_instance_id_by_security_group_id(sec_group_id))
db_info = instance_models.get_db_info(context, id=instance_id)
manager = (DatastoreVersion.load_by_uuid(
db_info.datastore_version_id).manager)
tcp_ports = CONF.get(manager).tcp_ports
udp_ports = CONF.get(manager).udp_ports
def _create_rules(sec_group, ports, protocol):
rules = []
try:
for port_or_range in set(ports):
from_, to_ = utils.gen_ports(port_or_range)
rule = models.SecurityGroupRule.create_sec_group_rule(
sec_group, protocol, int(from_), int(to_),
body['security_group_rule']['cidr'], context,
CONF.os_region_name)
rules.append(rule)
except (ValueError, AttributeError) as e:
raise exception.BadRequest(msg=str(e))
return rules
tcp_rules = _create_rules(sec_group, tcp_ports, 'tcp')
udp_rules = _create_rules(sec_group, udp_ports, 'udp')
sec_group.save()
all_rules = tcp_rules + udp_rules
view = views.SecurityGroupRulesView(
all_rules, req, tenant_id).create()
return wsgi.Result(view, 201)
def create(self, req, body, tenant_id):
LOG.debug("Creating a Security Group Rule for tenant '%s'" % tenant_id)
context = req.environ[wsgi.CONTEXT_KEY]
self._validate_create_body(body)
sec_group_id = body['security_group_rule']['group_id']
sec_group = models.SecurityGroup.find_by(id=sec_group_id,
tenant_id=tenant_id,
deleted=False)
instance_id = (models.SecurityGroupInstanceAssociation.
get_instance_id_by_security_group_id(sec_group_id))
db_info = instance_models.get_db_info(context, id=instance_id)
manager = (DatastoreVersion.load_by_uuid(
db_info.datastore_version_id).manager)
tcp_ports = CONF.get(manager).tcp_ports
udp_ports = CONF.get(manager).udp_ports
def _create_rules(sec_group, ports, protocol):
rules = []
try:
for port_or_range in set(ports):
from_, to_ = utils.gen_ports(port_or_range)
rule = models.SecurityGroupRule.create_sec_group_rule(
sec_group, protocol, int(from_), int(to_),
body['security_group_rule']['cidr'], context)
rules.append(rule)
except (ValueError, AttributeError) as e:
raise exception.BadRequest(msg=str(e))
return rules
tcp_rules = _create_rules(sec_group, tcp_ports, 'tcp')
udp_rules = _create_rules(sec_group, udp_ports, 'udp')
sec_group.save()
all_rules = tcp_rules + udp_rules
view = views.SecurityGroupRulesView(
all_rules, req, tenant_id).create()
return wsgi.Result(view, 201)
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 or group '%s'")%id)
if False==uuid.is_uuid_like(id):
msg = (_("Wrong id of instance or group."))
LOG.error(msg)
raise exception.BadRequest(msg)
group_id = None
context = req.environ[wsgi.CONTEXT_KEY]
try:
db_info = models.get_db_info(context, id)
group_id = db_info.group_id
except exception.NotFound:
LOG.debug("Not instance id %s"%id)
pass
if group_id==None:
try:
InstanceGroup.get_by_groupid(context, id)
group_id = id
except exception.NotFound:
msg = (_("Without find instance or group of the id"))
LOG.error(msg)
raise exception.BadRequest(msg)
else:
try:
item = InstanceGroupItem.get_by_instance_id(context, id)
if item.type==DBInstanceType.READ_REPLI or item.type==DBInstanceType.STANDBY:
msg = (_("Without backups for the instance."))
LOG.error(msg)
raise exception.BadRequest(msg)
except exception.NotFound:
msg = (_("Without find instance group item information."))
LOG.error(msg)
raise exception.BadRequest(msg)
backups = backup_model.list_autobackup(context, group_id)
backups += backup_model.list_snapshot(context, group_id)
bks = []
#for backup in backups:
# instance = models.FreshInstance.load(context, backup.instance_id)
# backup.db_type = instance.service_type
# bks.append(backup)
#TODO(ksc-need-discuss) backup.db_type didn't used in backup view, really need it?
tmp = dict()
for backup in backups:
## autobackup's service_image_id is NULL
if backup.service_image_id:
if backup.service_image_id not in tmp:
#service_image = models.ServiceImage.find_by(id=backup.service_image_id)
#backup.db_type = service_image.service_name
#tmp[backup.service_image_id] = service_image.service_name
try:
#image_id may be is not exists in datastaore
datastore, datastore_version = ds_path_models.find_datastore_by_image_id(backup.service_image_id)
tmp[backup.service_image_id] = datastore.name
backup.db_type = datastore.name
except Exception:
backup.db_type = ""
else:
backup.db_type = tmp[backup.service_image_id]
else:
backup.db_type = ""
bks.append(backup)
backups = bks
LOG.debug('Getted backups %s'%backups)
return wsgi.Result(backup_views.BackupViews(backups).data(), 200)
