def update_network_subnet(self, subnet_id, params):
"""
Update network
:param subnet_id:
:param params: json: dns, name, gateway
:return:
"""
LOG.debug(
"Enter update_network_subnet, old network_id is %s, new network params is %s"
% (subnet_id, params))
change_info = {"name": "", "dns": "", "gateway": ""}
for key in change_info:
change_info[key] = params[key] if key in params else ""
change_info["id"] = subnet_id
subnet = yield get_subnet(subnet_id)
if not subnet:
raise SubNetNotExist
network = yield get_network(subnet.get("network_id"))
if not network:
raise NetworkNotExist
yield update_subnet(subnet, change_info)
model_name = change_info["name"] if change_info["name"] else subnet[
"name"]
optLog.write(self.request, Type.NETWORK, network["name"],
Operator.EDIT_SUBNET, model_name)
self.response(Response())
def create_server(self, body):
""""""
body['metadata'] = compute.Metadata(**body['metadata'])
vm = compute.Server(**body)
if not vm.cores:
raise InvalidateParam(args=['cores'])
if not vm.memory:
raise InvalidateParam(args=['memory'])
if not vm.image:
raise InvalidateParam(args=['image'])
if not vm.metadata.extend.get("displayname"):
raise InvalidateParam(args=['metadata.extend.displayname'])
if vm.metadata.extend.get("keepalive") not in (0, 1):
raise InvalidateParam(args=['metadata.extend.keepalive'])
if not vm.tenant:
raise InvalidateParam(args=['tenant'])
if not vm.network:
for network in vm.network:
if not network.vlan:
raise InvalidateParam(args=['network.vlan'])
server = yield compute.create_server(vm)
for s in server['name_ips']:
optLog.write(
self.request, Type.VM, s['name'], Operator.CREATE,
vm.metadata.extend.get("displayname") + " " +
",".join(s['ips']))
self.response(Response(result={"batch": server['name']}))
def create_network_subnet(self, params):
"""
Create network
:param params: vlan params
"""
LOG.debug("Enter create_network_subnet, params is %s" % params)
subnet = SubNet(params)
network = yield get_network(subnet.network_id)
if not network:
raise NetworkNotExist
cidr_ip_range = tuple(netaddr.IPNetwork(subnet.cidr))
cidr_start = int(cidr_ip_range[0])
cidr_end = int(cidr_ip_range[-1])
for ip in subnet.ips:
start = int(netaddr.IPAddress(ip.get("start")))
end = int(netaddr.IPAddress(ip.get("end")))
if start < cidr_start or end > cidr_end:
raise IpNotInCidr
subnet_select = yield get_subnet_db(network_id=subnet.network_id,
name=subnet.name)
if subnet_select:
raise SubNetNameExist
subnet_select = yield get_subnet_db()
subnet_cidr_ips = set(
[int(ip) for ip in netaddr.IPNetwork(subnet.cidr)])
cidrs_ips = (set((int(ip) for ip in netaddr.IPNetwork(item["cidr"])))
for item in subnet_select)
for item in cidrs_ips:
if item.intersection(subnet_cidr_ips):
raise SubNetCidrExist
yield create_subnet(subnet)
optLog.write(self.request, Type.NETWORK, network.get("name"),
Operator.CRATE_SUBNET, subnet.name)
self.response(Response())
def update_network(self, network_id, params):
"""
Update network
:param network_id:
:param params: json: dns, name, gateway
:return:
"""
network = yield get_network(network_id)
if not network:
raise NetworkNotExist
change_info = {"name": ""}
for key in change_info:
change_info[key] = params[key] if key in params else ""
change_info["id"] = network_id
old_network = yield get_network(network_id)
if not old_network:
raise NetworkNotExist
yield update_network(old_network, change_info)
model_name = change_info["name"] if change_info[
"name"] else old_network["name"]
optLog.write(self.request, Type.NETWORK, old_network["name"],
Operator.UPDATE, model_name)
LOG.debug(
"Leave update_network, old network_id is %s, new network params is %s"
% (network_id, params))
self.response(Response())
def update_app(self, app_serial, body):
try:
app_name = body['name']
description = body['description']
sql = ("UPDATE manor.manor_app_instance "
"SET app_name='%s',app_description='%s' "
"WHERE app_serial='%s'") % (app_name, description,
app_serial)
execute(sql)
vms = yield list_app_resources(app_serial)
for vm in vms:
yield update_vm_display_name(vm['vm_id'], app_name)
rs = yield DBUtil().query(
("select * from manor.manor_app_instance "
"where app_serial='%s'") % app_serial)
seq = rs[0]['app_id']
optLog.write(self.request, optLog.Type.APP_INSTANCE, seq,
Operator.UPDATE, '%s' % app_name)
self.response(generals.gen_response({'result': 'ok'}))
except Exception as detail:
logging.getLogger('manor').error(generals.trace())
raise detail
def update_host(self, hyper_id, ipmi):
new_ipmi = host_package.Host(**ipmi)
yield host_package.update_host(hyper_id, new_ipmi.__dict__)
host = yield host_package.query_host(id=int(hyper_id))
optLog.write(self.request, Type.HOST, host[0]['name'], Operator.UPDATE,
'')
self.response(Response())
def resize_server(self, vm_id, body):
""" extend vm setting: cores and memory
:param vm_id: id of vm
:param body: extend setting：
{
"cores": 1,
"memory": 1,
}
"""
vm = yield compute.get_server(vm_id=vm_id)
if not vm:
raise VmNotExist
cores = body['cores']
memory = body['memory']
if vm_id and memory and cores:
yield compute.resize(vm, cores, memory)
else:
raise InvalidateParam(args=['cores', 'memory'])
optLog.write(
self.request, Type.VM, vm['name'], Operator.MODIFY_SETTING,
vm['displayname'] + " " +
gen_network_comment(vm['network'].values()))
self.response(Response())
def attach_volume(self, attachment):
volume_id = attachment['volume_id']
server_id = attachment['vm_id']
volume = yield get_volume(volume_id, detailed=True)
server = yield compute.get_server(vm_id=server_id)
if not volume or not server:
raise InvalidateParam(args=['vm_id', 'volume_id'])
volume_project = unicode(volume['tenant'].get("id", None))
server_project = unicode(server['tenant'].get("id", None))
if volume_project and server_project and server_project != volume_project:
raise AttachBeyondDomainError
volume_user = unicode(volume['user'].get("id", None))
server_user = unicode(server['user'].get("id", None))
if volume_user and server_user and volume_user != server_user:
raise AttachBeyondDomainError
yield compute.attach_server_volume(volume_id=volume_id,
server_id=server_id)
optLog.write(
self.request, optLog.Type.VDISK, volume['name'],
optLog.Operator.ATTACH,
volume['metadata']['displayname'] + ">>" + server['name'] + " " +
gen_network_comment(server['network'].values()))
self.response(Response())
def add_users(self, tenant_id, body):
tenant = yield identify.get_tenant_by_id(tenant_id)
for user_name in body:
user = yield user_mapping(user_name)
yield identify.add_tenant_user(tenant_id, user.get("id"))
optLog.write(self.request, Type.TENANT, tenant['name'],
Operator.ADD_USER, user['displayname'])
self.response(Response())
def delete_tenant_host(self, tenant_id, host_id):
yield delete_tenant_host(tenant_id, int(host_id))
host_info = yield list_simple_hosts(host_id=host_id)
for host in host_info:
pass
tenant = yield get_tenant_by_id(tenant_id)
optLog.write(self.request, Type.TENANT, tenant['name'],
Operator.CONFIG_TENANT_DELETE_HOST, host['name'])
self.response(Response())
def set_quota(self, tenant_id, body):
tenant = yield identify.get_tenant_by_id(tenant_id)
for quota in body:
yield identify.update_quota_limit(tenant_id,
name=quota['quota_name'],
limit=quota['quota_limit'])
optLog.write(self.request, Type.TENANT, tenant['name'],
Operator.MODIFY_QUOTA, '')
self.response(Response())
def set_tenant_subnet(self, tenant_id, body):
subnet_ids = body['subnet_ids']
yield set_tenant_subnet(tenant_id, subnet_ids)
tenant = yield get_tenant_by_id(tenant_id)
for subnet_id in subnet_ids:
subnet = yield get_subnet(subnet_id)
optLog.write(self.request, Type.TENANT, tenant['name'],
Operator.CONFIG_NETWORK, subnet['name'])
self.response(Response())
def delete_tenant(self, tenant_id, internal=False):
tenant = yield identify.get_tenant_by_id(tenant_id)
if not tenant:
raise TenantNotExist
if internal:
try:
for name in identify.get_quota_names():
q = yield identify.get_quota(tenant_id, name)
if q and q.get("quota_used") != 0:
region = yield rg.list_region(
CONF.keystone.region_name)
raise TenantDeleteFailed(region[0].get("displayname"))
yield identify.delete_quotas(tenant_id)
yield delete_tnr_from_ecloud(tenant_id)
except Exception as e:
LOG.error("delete tenant error:%s" % e)
LOG.error(trace())
raise e
else:
regions = yield rg.list_region()
for region in regions:
if region["region"] == CONF.keystone.region_name:
for name in identify.get_quota_names():
q = yield identify.get_quota(tenant_id, name)
if q.get("quota_used") != 0:
raise TenantDeleteFailed()
continue
servers_url = "%s/tenant/%s?internal=true" % \
(region['url'], tenant_id)
try:
res = yield async_request(url=servers_url,
token=get_token(self.request),
body=None,
method="DELETE")
if res and res.get("success") is False and res.get(
"msg") == TenantDeleteFailed.msg:
raise TenantDeleteFailed
except Exception as e:
LOG.error(
"delete tenant quota from another region error:%s" % e)
LOG.error(trace())
if e.message == TenantDeleteFailed.msg:
raise TenantDeleteFailed(args=[region['displayname']])
raise rg.RegionException(args=[region['displayname']])
try:
yield identify.delete_quotas(tenant_id)
yield delete_tnr_from_ecloud(tenant_id)
yield identify.delete_tenant(tenant_id)
except Exception as e:
LOG.error("delete tenant error:%s" % e)
LOG.error(trace())
region = yield rg.list_region(CONF.keystone.region_name)
raise TenantDeleteFailed(region[0].get("displayname"))
optLog.write(self.request, Type.TENANT, tenant['name'],
Operator.DELETE, '')
self.response(Response())
def create_network(self, params):
"""
Create network
:param params: vlan params
"""
LOG.debug("Enter create_network, params is %s" % params)
network_obj = Network(params)
yield create_network(network_obj)
optLog.write(self.request, Type.NETWORK, network_obj.name,
Operator.CREATE, '')
self.response(Response())
def delete_template(self, name):
template_path = cfgutils.getval('app', 'template_path')
with open('%s/%s.yaml' % (template_path, name)) as f:
tmp = f.read()
t_content = yaml.safe_load(tmp)
template = '%s/%s.yaml' % (template_path, name)
shutil.rmtree('%s/_%s' % (template_path, name))
os.remove(template)
optLog.write(self.request, optLog.Type.APP_TEMPLATE, name,
Operator.DELETE, '%s' % t_content['label'])
self.response(generals.gen_response('ok'))
def set_tenant_hosts(self, tenant_id, body):
hosts = body.get("host_ids")
if not tenant_id:
raise InvalidateParam
hosts_info = yield list_simple_hosts(host_id=hosts)
tenant = yield get_tenant_by_id(tenant_id)
yield set_tenant_hosts(tenant_id, hosts)
for host in hosts_info:
optLog.write(self.request, Type.TENANT, tenant['name'],
Operator.CONFIG_TENANT_ADD_HOST, host['name'])
self.response(Response())
def update_tenant(self, tenant_id, body):
tenant = yield identify.get_tenant_by_id(tenant_id)
if not tenant:
raise TenantNotExist
db = dbpools.get_keystone()
cur = yield db.execute("select name from project where id = %s ",
(tenant_id, ))
old_tenant_name = cur.fetchone()
t = yield identify.update_tenant(tenant_id, **body)
optLog.write(self.request, Type.TENANT, old_tenant_name['name'],
Operator.UPDATE, t['name'])
self.response(Response(result=t))
def delete_network(self, network_id):
"""
Delete network by id
:param network_id: network's id
"""
network = yield get_network(network_id)
if not network:
raise NetworkNotExist
yield delete_network(network_id)
optLog.write(self.request, Type.NETWORK, network['name'],
Operator.DELETE, '')
self.response(Response())
def set_tenant_subnet_ips(self, subnet_id, tenant_id, body):
ips = body.get("ips")
if not tenant_id:
raise InvalidateParam
subnet = yield get_subnet(subnet_id)
if not subnet:
raise SubNetNotExist
tenant = yield get_tenant_by_id(tenant_id)
yield set_tenant_subnet_ips(subnet_id, tenant_id, ips)
optLog.write(self.request, Type.TENANT, tenant['name'],
Operator.CONFIG_TENANT_IP, subnet['name'])
self.response(Response())
def license_upload(self):
"""
上传凭证
:return:
"""
private_key = self.request.arguments.get("private_key")[0]
result = license.license_upload(self, private_key)
optLog.write(self.request, Type.LICENSE, "license", Operator.UPLOAD,
"license")
if result.get("date_interval") is False:
self.response(Response(msg=LicenseOverdue.msg, success=False))
self.response(Response(result=result))
def delete_server_by_batch(self, batch):
vm_info = yield compute.list_server(batch=batch,
detailed=True,
with_task=False)
if not vm_info:
raise VmNotExist(args=['batch', batch])
for info in vm_info:
yield del_server(info["id"], delete_volume_ids=list())
optLog.write(
self.request, Type.VM, str(info["name"]), Operator.DELETE,
str(info["displayname"]) + " " +
gen_network_comment(info['network'].values()))
self.response(Response())
def update_snapshot_snapshot(self, snapshot_id, params):
try:
snapshot = yield snapshot_package.get_snapshot(snapshot_id)
except BaseException as e:
LOG.error("snapshot is not exist %s", e)
LOG.error(trace())
raise SnapShotNotExist
volume_name = yield snapshot_package.update_snapshot(
snapshot_id, params.get("name"), params.get("des"))
name = volume_name[len("ecloud-snapshot-"):]
optLog.write(self.request, Type.SNAPSHOT, name, Operator.UPDATE,
params.get("name"))
self.response(Response())
def control_server(self, body):
""" to start\stop\reboot instance
:param body:
"""
ids = body['ids']
action = body['action']
LOG.debug("vm control action is %s starting", action)
vmnames = yield compute.control(action, ids)
LOG.debug("vm control action is %s end", action)
for vm in vmnames:
optLog.write(
self.request, Type.VM, vm['name'], action, vm['displayname'] +
" " + gen_network_comment(vm['network'].values()))
self.response(Response())
def delete_snapshot(self, snapshot_id):
"""
:param snapshot_id:
:return:
"""
snapshot = yield snapshot_package.get_snapshot(snapshot_id)
if not snapshot:
raise SnapShotNotExist
snapshot_info = yield snapshot_package.delete_snapshot(snapshot_id)
snapshot_name = snapshot_info["name"]
name = snapshot_name[len("ecloud-snapshot-"):]
optLog.write(self.request, Type.SNAPSHOT, name, Operator.DELETE,
snapshot_info["metadata"].get("displayname", ""))
self.response(Response())
def detach_volume(self, attachment):
volume_id = attachment['volume_id']
server_id = attachment['vm_id']
volume = yield get_volume(volume_id, detailed=True)
server = yield compute.get_server(vm_id=server_id, detailed=True)
if not volume or not server:
raise InvalidateParam(args=['vm_id', 'volume_id'])
yield compute.detach_server_volume(server_id=server_id,
volume_id=volume_id)
optLog.write(
self.request, optLog.Type.VDISK, volume['name'],
optLog.Operator.DETACH,
volume['metadata']['displayname'] + ">>" + server['name'] + " " +
gen_network_comment(server['network'].values()))
self.response(Response())
def change_status(self, name, body):
t_path = cfgutils.getval('app', 'template_path')
with open('%s/%s.yaml' % (t_path, name)) as f:
tmp = f.read()
t_content = yaml.safe_load(tmp)
value = json.loads(self.request.body)['value']
t_content['status'] = value
tmp_f = str(uuid.uuid1())
with codecs.open('%s/%s' % (t_path, tmp_f), 'w', 'utf-8') as f:
f.write(yaml.safe_dump(t_content))
os.rename('%s/%s' % (t_path, tmp_f), '%s/%s.yaml' % (t_path, name))
optLog.write(self.request, optLog.Type.APP_TEMPLATE, name,
Operator.ONLINE if value == 1 else Operator.OFFLINE,
'%s' % t_content['label'])
self.response(generals.gen_response('ok'))
def remove_users(self, tenant_id):
users = self.get_argument('users').split(',')
tenant = yield identify.get_tenant_by_id(tenant_id)
usernames = []
for user_id in users:
user = yield identify.get_user_by_id(user_id)
role = yield identify.get_user_role(user_id, tenant_id)
yield identify.remove_tenant_user(tenant_id, user_id, role['id'])
usernames.append(user['displayname'])
# clear volumes of this user
yield clear_user_volumes(tenant_id, user_id)
# clear vms of this user
yield clear_vm_user(tenant_id, user_id)
optLog.write(self.request, Type.TENANT, tenant['name'],
Operator.REMOVE_USER, user['displayname'])
self.response(Response())
def delete_network_subnet(self, subnet_id):
"""
Delete network by id
:param subnet_id: subnet's id
"""
LOG.debug("Enter delete_network_subnet, subnet_id is %s" % subnet_id)
subnet = yield get_subnet(subnet_id)
if not subnet:
raise SubNetNotExist
network = yield get_network(subnet.get("network_id"))
if not network:
raise NetworkNotExist
yield delete_subnet(subnet_id)
optLog.write(self.request, Type.NETWORK, network['name'],
Operator.DELETE_SUBNET, subnet['name'])
self.response(Response())
def recover_snapshot(self, snapshot_id):
"""
:param snapshot_id:
:param params:
:return:
"""
snapshot_info = yield snapshot_package.get_snapshot(snapshot_id,
detailed=True)
if not snapshot_info:
raise SnapShotNotExist
name = snapshot_info["name"][len("ecloud-snapshot-"):]
restore_result = yield snapshot_package.snapshot_recover(snapshot_info)
optLog.write(self.request, Type.SNAPSHOT, name, Operator.RESTORE,
snapshot_info["metadata"].get("displayname", ""))
LOG.debug("Leave restore_volume_snapshot method, id is %s" % id)
self.response(Response(result={"result": restore_result}))
def delete_server(self, vm_id, delete_volume_ids=None):
""" delete vm and delete vm attach volumes
:param vm_id: the id of to delete vm
:param delete_volume_ids: the ids of to delete attach volume
"""
try:
vm_info = {}
if vm_id.startswith("vm-"):
server_task = yield get_task_flow(name=vm_id)
if server_task:
server_task = server_task[0]
params = server_task.get("param")
server_info = params["body"]["server"]
vm_info["network"] = server_info["networks"]
vm_info["name"] = server_info["name"]
vm_info["displayname"] = server_info["displayname"]
else:
vm_infos = yield compute.list_server(vm_ids=vm_id,
with_task=False)
if not vm_infos:
raise VmNotExist(args=['vm_id', vm_id])
vm_info = vm_infos[0]
info = vm_info
if delete_volume_ids:
delete_volume_ids = delete_volume_ids.split(",")
else:
delete_volume_ids = []
if not vm_id.startswith("vm-"):
yield snapshot.clean_vm_or_volume_snapshot(info["name"])
if delete_volume_ids:
del_volumes = yield list_volume(detailed=False,
volume_id=delete_volume_ids)
for del_volume_item in del_volumes:
yield snapshot.clean_vm_or_volume_snapshot(
del_volume_item["name"])
optLog.write(self.request, Type.VDISK,
str(del_volume_item["name"]), Operator.DELETE,
str(del_volume_item["name"]))
yield del_server(vm_id, delete_volume_ids=delete_volume_ids)
optLog.write(
self.request, Type.VM, str(info["name"]), Operator.DELETE,
str(info["displayname"]) + " " +
gen_network_comment(info['network'].values()))
self.response(Response())
except Exception as e:
LOG.error("delete_server error: %s" % e)
raise e
