def update_own_password(self, body):
token = authen.get_token(self.request)
user_id = authen.get_user(self.request)['id']
yield identify.update_user_own_password(token, user_id, **body)
user = yield identify.get_user_by_id(user_id)
log.write(self.request, log.Type.USER, user['name'],
log.Operator.RESET_PASS, user['name'])
self.response(Response())
def delete_user(self, user_id):
user = yield identify.get_user_by_id(user_id)
if not user:
raise UserNotExist
yield identify.delete_user(user_id)
log.write(self.request, log.Type.USER, user['name'],
log.Operator.DELETE, user['displayname'])
self.response(Response())
def update_image_ws(self, image_id, params):
img = yield get_image(image_id)
if not img:
raise ImageNotExsit
ret = yield update_image(image_id, **params)
log.write(self.request, log.Type.IMAGE, ret['name'],
log.Operator.UPDATE, ret['os'])
self.response(Response())
def del_vm_nic(self, vm_id, port_id):
vm = yield compute.get_server(vm_id, detailed=False)
port = yield compute.get_port(port_id)
if not vm or not port:
raise InvalidateParam(args=['vm_id'])
yield compute.del_vm_nic(vm, port_id)
log.write(self.request, log.Type.VM, vm['name'], log.Operator.DEL_NIC,
port.get("name") + " " + port.get("ip"))
self.response(Response())
def set_tenant_user_role(self, user_id, tenant_id, body):
user = yield identify.get_user_by_id(user_id)
yield identify.set_user_role(user_id, body['role'], tenant_id)
t = yield get_tenant_by_id(tenant_id)
if body['role'] == 'tenant_admin':
log.write(self.request, log.Type.TENANT, t['name'],
log.Operator.SET_TENANT_ROLE, user['displayname'])
else:
log.write(self.request, log.Type.TENANT, t['name'],
log.Operator.CANCEL_TENANT_ROLE, user['displayname'])
self.response(Response())
def update_volume(self, volume_id, volume):
vm_des = volume.get('des')
vm_display_name = volume.get('displayname')
params = {'displayname': vm_display_name, 'des': vm_des}
volume = yield get_volume(volume_id, detailed=False)
if not volume:
raise VolumeNotExist(args=[volume_id])
volume_name = yield update_volume(volume_id, **params)
log.write(self.request, log.Type.VDISK, volume_name,
log.Operator.UPDATE, vm_display_name)
self.response(Response())
def create_image_ws(self, img):
location = img.get('url', None)
if not location:
filename = img.get('filename', None)
if not filename:
raise Exception("neither 'url' nor 'filename' found.")
location = 'file:///tmp/' + filename
img['location'] = location
result = yield create_image(img)
log.write(self.request, log.Type.IMAGE, img['name'],
log.Operator.CREATE, img['os'])
self.response(Response(result=result))
def delete_image_ws(self, image_id):
try:
img = yield get_image(image_id)
if not img or (img and img.get("status") != "active"):
raise ImageNotExsit
yield delete_image(image_id)
log.write(self.request, log.Type.IMAGE, img['name'],
log.Operator.DELETE, img['os'])
except BaseException as e:
LOG.error("delete_image_ws error : %s" % e)
raise e
self.response(Response())
def set_user_role(self, body):
user = yield user_mapping(body["name"])
yield identify.set_user_role(user.get("id"), body['role'],
body.get("tenant"))
if body['role'] == 'sys_admin':
log.write(self.request, log.Type.USER, user['name'],
log.Operator.SET_ADMIN_ROLE, user['displayname'])
else:
log.write(self.request, log.Type.USER, user['name'],
log.Operator.CANCEL_ADMIN_ROLE, user['displayname'])
self.response(Response())
def add_vm_nic(self, vm_id, body):
vlan_id = body.get("vlan_id")
subnet_id = body.get("subnet_id")
ip = body.get("ip")
mac = body.get("mac")
vlan = yield get_network(vlan_id)
vm = yield compute.get_server(vm_id, detailed=False)
if not vm or not vlan:
raise InvalidateParam(args=['vm_id'])
fixed_ip = yield compute.add_vm_nic(vm, vlan_id, subnet_id, ip, mac)
log.write(self.request, log.Type.VM, vm['name'], log.Operator.ADD_NIC,
vlan.get("name") + " " + fixed_ip)
self.response(Response())
def create_volume(self, volume):
volume = CloudVolume(**volume)
if volume.user_id:
users = yield list_tenant_users(volume.tenant_id)
user_ids = [user_item["id"] for user_item in users]
if volume.user_id not in user_ids:
raise VolumeTenantUserUnmatch(args=[{
"user_id": volume.user_id
}])
created_volume = yield create_volume(**volume.__dict__)
display_name = volume.displayname \
if volume.displayname else volume.name
for v in created_volume["names"]:
log.write(self.request, log.Type.VDISK, v, log.Operator.CREATE,
display_name)
self.response(Response(result={"batch": created_volume['batch_name']}))
def vm_user(self, body):
"""
:param body:
{
"vm-user": [{
"user_id": "83d546cc-3975-4890-8c31-e8c859203d9b",
"vm_id": "e603b2a7-4854-4368-8bfb-e68d0ac6c170"
}]
}
:return:
"""
vm_u = body.get("vm-user")
if not vm_u:
raise InvalidateParam(args=['vm-user'])
for v_u in vm_u:
vm_id = v_u.get("vm_id")
u_id = v_u.get("user_id")
vm = yield compute.get_server(vm_id)
if not vm:
raise VmNotExist(args=["vm_id"])
vm_tenant_id = vm["tenant"]["id"]
users = yield list_tenant_users(vm_tenant_id)
user_ids = [user_item["id"] for user_item in users]
if not user_ids or u_id not in user_ids:
raise VmTenantUserUnmatch(args=[{"user_id": u_id}])
for v_u in vm_u:
vm_id = v_u.get("vm_id")
u_id = v_u.get("user_id")
vm = yield compute.get_server(vm_id)
user = yield get_user_by_id(u_id)
attch_vol = yield compute.list_server_attach_volume(vm_id)
for vol_item in attch_vol:
vol_id = vol_item["volume_id"]
yield set_volume_user(vol_id, u_id)
yield compute.set_vm_user(vm_id, u_id)
log.write(
self.request, log.Type.VM, vm['name'], log.Operator.SET_USER,
vm['displayname'] + " " +
gen_network_comment(vm['network'].values()) + " " +
user['displayname'])
self.response(Response())
def del_volume(self, volume_id):
volume = yield get_volume(volume_id)
if volume:
if volume.get("status") in (VDISK_STATUS_ATTACH,
VDISK_STATUS_BACKUP,
VDISK_STATUS_DELETE,
VDISK_STATUS_RECOVER):
raise VolumeOperationFailed
volume_meta = volume['metadata'] \
if volume['metadata'] else {}
volume_meta['status'] = VDISK_STATUS_DELETE
yield set_metadata(volume_id=volume_id, metadata=volume_meta)
yield clean_vm_or_volume_snapshot(volume['name'])
yield delete_volume(volume_id)
else:
raise VolumeNotExist
log.write(self.request, log.Type.VDISK, volume['name'],
log.Operator.DELETE, volume['metadata']['displayname'])
self.response(Response())
def volume_user(self, body):
volume_u = body.get("volume-user")
if not volume_u:
raise InvalidateParam(args=['volume-user'])
for v_u in volume_u:
volume_id = v_u.get("volume_id")
volume = yield get_volume(volume_id, detailed=False)
if not volume:
raise VolumeNotExist(args=[volume_id])
users = yield list_tenant_users(volume.get("tenant_id"))
user_ids = [user_item["id"] for user_item in users]
if user_ids and v_u.get("user_id") not in user_ids:
raise VolumeTenantUserUnmatch(
args=[{
"user_id": v_u.get("user_id")
}])
for v_u in volume_u:
result = yield set_volume_user(v_u.get("volume_id"),
v_u.get("user_id"))
log.write(self.request, log.Type.VDISK, result['name'],
log.Operator.SET_USER,
result['displayname'] + " " + result['user'])
self.response(Response())
def clear_alarm(self, id):
alarm_info = yield ALARM.clear(id)
log.write(self.request, log.Type.ALARM, id, log.Operator.REMOVE,
alarm_info[0]["target"] + ' ' + alarm_info[0]["message"])
self.response(Response())
def edit(self, body):
config.update(body['name'], body['value'])
log.write(self.request, log.Type.GLOBAL_SETTINGS, body['name'],
log.Operator.UPDATE, '')
self.response(Response())
def update_password(self, user_id, body):
yield identify.update_user_password(user_id, body['password'])
user = yield identify.get_user_by_id(user_id)
log.write(self.request, log.Type.USER, user['name'],
log.Operator.RESET_PASS, user['displayname'])
self.response(Response())
def update_user(self, user_id, body):
t = yield identify.update_user(user_id, **body)
log.write(self.request, log.Type.USER, t['name'], log.Operator.UPDATE,
t['displayname'])
self.response(Response(result=t))
def create_user(self, body):
t = yield identify.create_user(**body)
log.write(self.request, log.Type.USER, body['name'],
log.Operator.CREATE, body['displayname'])
self.response(Response(result=t))
def update_user_enable(self, user_id, body):
yield identify.update_user_enable(user_id, body['enable'])
user = yield identify.get_user_by_id(user_id)
log.write(self.request, log.Type.USER, user['name'],
log.Operator.UPDATE, user['displayname'])
self.response(Response())
