def handle(self, request, data):
try:
if not os.path.exists(enum.EMAIL_CFG_FILE):
os.mknod(enum.EMAIL_CFG_FILE)
cfgparser = ConfigParser.ConfigParser()
cfgparser.read(enum.EMAIL_CFG_FILE)
if cfg_tool.getOption(cfgparser, 'receiver', 'receiver'):
receiver = json.loads(
cfg_tool.getOption(cfgparser, 'receiver', 'receiver'))
else:
receiver = []
new_addr = str(data.get('address'))
receiver.append(new_addr)
cfg_tool.setOption(cfgparser, 'receiver', 'receiver',
json.dumps(receiver))
cfgparser.write(open(enum.EMAIL_CFG_FILE, 'w'))
operate_log(
request.user.username, request.user.roles,
"add mail-receiver \"" + data.get('address') + "\" success")
return True
except Exception as e:
operate_log(
request.user.username, request.user.roles,
"add mail-receiver \"" + data.get('address') + "\" error")
return False
def action(self, request, obj_id):
"""apply revoke"""
apply = applydisk.objects.filter(id=obj_id)
apply.update(status='2')
operate_log(request.user.username,
request.user.roles,
apply[0].name+" disk check reject")
def delete(self, request, obj_id):
api.keystone.tenant_delete(request, obj_id)
for row in self.table.data:
if row.id == obj_id:
name = row.name
operate_log(request.user.username, request.user.roles,
name + " tenant delete")
def action(self, request, obj_id):
if obj_id == request.user.id:
messages.info(
request,
_('You cannot disable the user you are '
'currently logged in as.'))
return
if self.enabled:
api.keystone.user_update_enabled(request, obj_id, False)
self.current_past_action = DISABLE
name = '-'
for row in self.table.data:
if row.id == obj_id:
name = row.name
break
operate_log(request.user.username, request.user.roles,
name + " user disable ")
else:
api.keystone.user_update_enabled(request, obj_id, True)
self.current_past_action = ENABLE
name = '-'
for row in self.table.data:
if row.id == obj_id:
name = row.name
break
operate_log(request.user.username, request.user.roles,
name + " user enable ")
def _create_network(self, request, data):
try:
params = {
'name': data['net_name'],
'admin_state_up': (data['admin_state'] == 'True')
}
if api.neutron.is_port_profiles_supported():
params['net_profile_id'] = data['net_profile_id']
network = api.neutron.network_create(request, **params)
network.set_id_as_name_if_empty()
self.context['net_id'] = network.id
msg = _('Network "%s" was successfully created.') % network.name
operate_log(request.user.username, request.user.roles,
params["name"] + " create network")
LOG.debug(msg)
return network
except Exception as e:
msg = (_('Failed to create network "%(network)s": %(reason)s') % {
"network": data['net_name'],
"reason": e
})
LOG.info(msg)
redirect = self.get_failure_url()
exceptions.handle(request, msg, redirect=redirect)
return False
def handle(self, request, data):
try:
if not os.path.exists(enum.EMAIL_CFG_FILE):
os.mknod(enum.EMAIL_CFG_FILE, 0777)
cfgparser = ConfigParser.ConfigParser()
cfgparser.read(enum.EMAIL_CFG_FILE)
cfg_tool.setOption(cfgparser, 'server', 'ipaddress',
data.get('server_address'))
cfg_tool.setOption(cfgparser, 'server', 'port',
data.get('server_port'))
cfg_tool.setOption(cfgparser, 'sender', 'address',
data.get('sender_address'))
cfg_tool.setOption(cfgparser, 'sender', 'user',
data.get('sender_username'))
if data.get('sender_password'):
cfg_tool.setOption(
cfgparser, 'sender', 'password',
base64.b64encode(data.get('sender_password')))
cfgparser.write(open(enum.EMAIL_CFG_FILE, 'w'))
operate_log(request.user.username, request.user.roles,
"alter alarm-mail settings success")
return True
except Exception as e:
operate_log(request.user.username, request.user.roles,
"alter alarm-mail settings error")
return False
def handle(self, request, context):
try:
self.object = \
api.nova.aggregate_create(
request,
name=context['name'],
availability_zone=context['availability_zone'])
operate_log(request.user.username,
request.user.roles,
context["name"] + "aggragate create")
except Exception:
exceptions.handle(request, _('Unable to create host aggregate.'))
return False
context_hosts_aggregate = context['hosts_aggregate']
for host in context_hosts_aggregate:
try:
api.nova.add_host_to_aggregate(request, self.object.id, host)
except Exception:
exceptions.handle(
request, _('Error adding Hosts to the aggregate.'))
return False
return True
def action(self, request, obj_id):
"""
apply revoke
"""
apply_instances = apply.objects.filter(id=obj_id)
apply_instances.update(status='2')
operate_log(request.user.username, request.user.roles,
apply_instances[0].name + " instances check reject")
def delete(self, request, obj_id):
api.network.security_group_delete(request, obj_id)
name = "-"
for row in self.table.data:
if row.id == obj_id:
name = row.name
operate_log(request.user.username, request.user.roles,
name + " security_groups delete")
def delete(self, request, obj_id):
api.glance.image_delete(request, obj_id)
name = '-'
for row in self.table.data:
if row.id == obj_id:
name = row.name
operate_log(request.user.username, request.user.roles,
name + " image delete")
def delete(self, request, obj_id):
"""
apply delete
"""
apply_instances = apply.objects.filter(id=obj_id)
apply_instances.update(status='5')
operate_log(request.user.username, request.user.roles,
apply_instances[0].name + " instances drop")
def handle(self, request, data):
try:
api.nova.server_update(request, data['instance_id'], data['name'])
operate_log(request.user.username, request.user.roles,
data["name"] + " instance update")
except Exception:
exceptions.handle(request, ignore=True)
return False
return True
def delete(self, request, obj_id):
# username = api.keystone.user_get(request, obj_id)
api.keystone.user_delete(request, obj_id)
name = '-'
for row in self.table.data:
if row.id == obj_id:
name = row.name
break
operate_log(request.user.username, request.user.roles,
name + " user delete ")
def handle(self, request, data):
try:
api.network.floating_ip_associate(request, data['ip_id'],
data['instance_id'])
operate_log(request.user.username, request.user.roles,
"floating ip associate")
except Exception:
exceptions.handle(request)
return False
return True
def action(self, request, obj_id):
try:
api.nova.server_delete(request, obj_id)
name = '-'
for row in self.table.data:
if row.id == obj_id:
name = row.name
operate_log(request.user.username,
request.user.roles,
name + " instance delete")
except Exception:
exceptions.handle(request, _("Unable to delete instance."))
def action(self, request, obj_id):
try:
api.nova.server_start(request, obj_id)
name = '-'
for row in self.table.data:
if row.id == obj_id:
name = row.name
operate_log(request.user.username,
request.user.roles,
name + " instance start")
except Exception as e:
LOG.error('Error to StartInstance: %s' % str(e))
def action(self, request, obj_id):
try:
treatedalarm_model = treatedalarm(event_id=obj_id)
treatedalarm_model.save()
operate_log(request.user.username,
request.user.roles,
"alarm-event \""+obj_id+"\" treat success")
except Exception as e:
operate_log(request.user.username,
request.user.roles,
"alarm-event \""+obj_id+"\" treat error")
exceptions.handle(request,
_('Unable to enable the policy.'))
def handle(self, request, context):
instance_id = context.get('instance_id', None)
flavor = context.get('flavor', None)
disk_config = context.get('disk_config', None)
try:
api.nova.server_resize(request, instance_id, flavor, disk_config)
operate_log(request.user.username,
request.user.roles,
context["name"]+" instance resize")
return True
except Exception:
exceptions.handle(request)
return False
def handle(self, request, data):
# Glance does not really do anything with container_format at the
# moment. It requires it is set to the same disk_format for the three
# Amazon image types, otherwise it just treats them as 'bare.' As such
# we will just set that to be that here instead of bothering the user
# with asking them for information we can already determine.
if data['disk_format'] in (
'ami',
'aki',
'ari',
):
container_format = data['disk_format']
else:
container_format = 'bare'
meta = {
'is_public': data['is_public'],
'protected': data['protected'],
'disk_format': data['disk_format'],
'container_format': container_format,
'min_disk': (data['minimum_disk'] or 0),
'min_ram': (data['minimum_ram'] or 0),
'name': data['name'],
'properties': {}
}
if data['description']:
meta['properties']['description'] = data['description']
if data['architecture']:
meta['properties']['architecture'] = data['architecture']
if (settings.HORIZON_IMAGES_ALLOW_UPLOAD and policy.check(
(("image", "upload_image"), ), request)
and data.get('image_file', None)):
meta['data'] = self.files['image_file']
else:
meta['copy_from'] = data['copy_from']
try:
image = api.glance.image_create(request, **meta)
operate_log(request.user.username, request.user.roles,
meta["name"] + " image create")
messages.success(
request,
_('Your image %s has been queued for creation.') %
data['name'])
return image
except Exception:
exceptions.handle(request, _('Unable to create new image.'))
def handle(self, request, data):
try:
sg = api.network.security_group_create(request, data['name'],
data['description'])
operate_log(request.user.username, request.user.roles,
data["name"] + " srcurity group create")
messages.success(
request,
_('Successfully created security group: %s') % data['name'])
return sg
except Exception:
redirect = reverse("horizon:project:access_and_security:index")
exceptions.handle(request,
_('Unable to create security group.'),
redirect=redirect)
def action(self, request, obj_id):
try:
cfgparser = ConfigParser.ConfigParser()
cfgparser.read(enum.EMAIL_CFG_FILE)
receiver = cfg_tool.getOption(cfgparser, 'receiver', 'receiver')
if receiver:
arr = json.loads(receiver)
arr.remove(obj_id)
cfg_tool.setOption(cfgparser, 'receiver', 'receiver',
json.dumps(arr))
cfgparser.write(open(enum.EMAIL_CFG_FILE, 'w'))
operate_log(request.user.username, request.user.roles,
"delete mail-receiver \"" + obj_id + "\" success")
except Exception as e:
operate_log(request.user.username, request.user.roles,
"delete mail-receiver \"" + obj_id + "\" error")
def handle(self, request, data):
id = self.initial['id']
name = data['name']
availability_zone = data['availability_zone']
aggregate = {'name': name}
if availability_zone:
aggregate['availability_zone'] = availability_zone
try:
api.nova.aggregate_update(request, id, aggregate)
operate_log(request.user.username, request.user.roles,
data["name"] + "aggregate update")
message = _('Successfully updated aggregate: "%s."') \
% data['name']
messages.success(request, message)
except Exception:
exceptions.handle(request, _('Unable to update the aggregate.'))
return True
def handle(self, request, data):
# Update the default quotas.
# `fixed_ips` update for quota class is not supported by novaclient
nova_data = dict([(key, data[key]) for key in ALL_NOVA_QUOTA_FIELDS
if key != 'fixed_ips'])
try:
nova.default_quota_update(request, **nova_data)
if base.is_service_enabled(request, 'volume'):
cinder_data = dict([(key, data[key])
for key in quotas.CINDER_QUOTA_FIELDS])
cinder.default_quota_update(request, **cinder_data)
operate_log(request.user.username, request.user.roles,
"defaults update")
except Exception:
exceptions.handle(request, _('Unable to update default quotas.'))
return True
def action(self, request, obj_id):
try:
alarmpolicy_data = alarmpolicy.objects.get(id=obj_id)
policys_id = getattr(alarmpolicy_data, 'policys_id', '')
if policys_id:
policys_arr = policys_id.split(',')
for p_id in policys_arr:
api.ceilometer.delete_alarm(request, p_id)
alarmpolicy_data.delete()
operate_log(
request.user.username, request.user.roles,
"\"" + getattr(alarmpolicy_data, 'name', '') +
"\" alarm-policy delete success")
except Exception as e:
operate_log(
request.user.username, request.user.roles,
"\"" + getattr(alarmpolicy_data, 'name', '') +
"\" alarm-policy delete error")
def delete(self, request, obj_id):
obj = self.table.get_object_by_id(obj_id)
name = self.table.get_object_display(obj)
try:
api.neutron.router_delete(request, obj_id)
operate_log(request.user.username,
request.user.roles,
name + " router delete")
except q_ext.NeutronClientException as e:
msg = _('Unable to delete router "%s"') % e
LOG.info(msg)
messages.error(request, msg)
redirect = reverse(self.redirect_url)
raise exceptions.Http302(redirect, message=msg)
except Exception:
msg = _('Unable to delete router "%s"') % name
LOG.info(msg)
exceptions.handle(request, msg)
def handle(self, request, data):
try:
requestapi = RequestApi()
data['uuid'] = data.get('id')
res = requestapi.deleteRequestInfo('api/heterogeneous/platforms/' + data.get('id'),data)
if res and type(res) == type({}):
if res.get('action') == 'success':
operate_log(request.user.username,
request.user.roles,
str(data.get("name")) + "synchronize date")
return True
elif res.get('action') == 'failed' and res.get('is_auto') == True:
err_msg = 'The plat is syncing, you can not delete it.'
messages.error(request,_(err_msg))
return False
except Exception as e:
exceptions.handle(request,
_('Unable to synchronize the control center.'))
return False
def handle(self, request, data):
try:
params = {
'admin_state_up': (data['admin_state'] == 'True'),
'name': data['name']
}
network = api.neutron.network_update(request, data['network_id'],
**params)
operate_log(request.user.username, request.user.roles,
data["name"] + " network updated")
msg = _('Network %s was successfully updated.') % data['name']
LOG.debug(msg)
messages.success(request, msg)
return network
except Exception:
msg = _('Failed to update network %s') % data['name']
LOG.info(msg)
redirect = reverse(self.failure_url)
exceptions.handle(request, msg, redirect=redirect)
def handle(self, request, data):
try:
snapshot = api.nova.snapshot_create(request, data['instance_id'],
data['name'])
# NOTE(gabriel): This API call is only to display a pretty name.
instance = api.nova.server_get(request, data['instance_id'])
vals = {"name": data['name'], "inst": instance.name}
operate_log(request.user.username, request.user.roles,
data["name"] + " snapshot create")
messages.success(
request,
_('Snapshot "%(name)s" created for '
'instance "%(inst)s"') % vals)
return snapshot
except Exception:
redirect = reverse("horizon:project:instances:index")
exceptions.handle(request,
_('Unable to create snapshot.'),
redirect=redirect)
def handle(self, request, data):
try:
rule = api.network.security_group_rule_create(
request, filters.get_int_or_uuid(data['id']),
data['direction'], data['ethertype'], data['ip_protocol'],
data['from_port'], data['to_port'], data['cidr'],
data['security_group'])
messages.success(request,
_('Successfully added rule: %s') % unicode(rule))
operate_log(request.user.username, request.user.roles,
"srcurity group rule create")
return rule
except Exception:
redirect = reverse(
"horizon:project:access_and_security:"
"security_groups:detail",
args=[data['id']])
exceptions.handle(request,
_('Unable to add rule to security group.'),
redirect=redirect)
def action(self, request, obj_id):
try:
api.nova.server_stop(request, obj_id)
name = '-'
for row in self.table.data:
if row.id == obj_id:
name = row.name
operate_log(request.user.username,
request.user.roles,
name + " instance stop")
except Exception as e:
LOG.error('Error to StopInstance: %s' % str(e))
status = ''
for row in self.table.data:
if row.id == obj_id:
status = row.status
break
if status == 'SUSPENDED':
messages.error(request, _('Instance in vm_state suspended. Cannot stop while the instance is in this state.'))
raise
