class ServiceApi(Resource):
def __init__(self):
self.kuber = KubernetesRpcClient()
@time_log
def get(self, service_uuid):
try:
token = request.headers.get('token')
token_ret = token_auth(token)
except Exception, e:
log.error('Token check error, reason=%s' % e)
return request_result(201)
if request.args.get('pod') == 'pod':
parameters = token_ret.get('result')
parameters['service_uuid'] = service_uuid
parameters['rtype'] = 'pods_msg'
context = context_data(token, service_uuid, "read")
try:
ret = self.kuber.pod_msg(context, parameters)
except Exception, e:
log.error('get the pods messages error, reason=%s' % e)
return request_result(504)
return request_result(0, ret)
def disk_snapshot_create(self,
token,
snapshot_name,
description,
volume_uuid,
metadata=None):
"""
:param snapshot_name:
:param description:
:param metadata:
:param vm_uuid:
:return:
"""
context = context_data(token, 'vol_snap_pro_com', 'create',
self.local_ip)
parameters = {
'volume_uuid': volume_uuid,
'name': snapshot_name,
'description': description,
'metadata': metadata
}
try:
rpc_body = rpc_data("snap_cre", context, parameters)
self.rbtmq.rpc_call_client(self.queue, self.timeout, rpc_body)
except Exception, e:
log.error('create volume error., reason is: %s' % e)
raise Exception(e)
class AttachmentRouteApi(Resource):
def __init__(self):
self.attach = CinderRouteManager()
# 分离卷（即将卷从云机卸载）
def delete(self, volume_uuid):
try:
token = request.headers.get('token')
token_auth(token)
source_ip = request.headers.get('X-Real-IP')
if source_ip is None:
source_ip = request.remote_addr
except Exception, e:
log.error('Token check error, reason=%s' % e)
return request_result(201)
# try:
# param = json.loads(request.get_data())
# except Exception, e:
# log.error('parameters error, reason is: %s' % e)
# return request_result(101)
# volume_uuid = param.get('volume_uuid')
context = context_data(token, volume_uuid, "delete", source_ip)
return self.attach.attachment_delete(context=context,
volume_uuid=volume_uuid)
def clouddisk_create(self, context, parameters=None):
'''
:param context: {'token':string,
'source_ip':source_ip}
:param parameters: {size=int,
name=string,
v_type=string,
description=string,
snapshot_uuid=string,
source_volume_uuid=string}
:return:
'''
context = context_data(context.get('token'),
'vol_vol_pro_com',
'create',
context.get('source_ip'))
try:
rpc_body = rpc_data("clouddisk_cre", context, parameters)
return self.rbtmq.rpc_call_client(self.queue,
self.timeout,
rpc_body)
except Exception, e:
log.error('Rpc client exec error, reason=%s' % e)
return request_result(598)
def _retinfo(func):
def __retinfo(*args, **kwargs):
# security_rpcapi = SecurityRpcApi()
record_uuid = str(uuid.uuid4())
func_args = inspect.getcallargs(func, *args, **kwargs)
token = func_args.get('token')
source_ip = func_args.get('source_ip')
resource_uuid = func_args.get('resource_uuid')
resource_name = func_args.get('resource_name')
if token is None:
context = func_args.get('kwargs')
token = context.get('token')
source_ip = context.get('source_ip')
resource_uuid = context.get('resource_uuid')
resource_name = context.get('resource_name')
context = context_data(token, "sec_sec_usr_com", "create")
parameters = {
"record_uuid": record_uuid,
"source_ip": source_ip,
"resource_uuid": resource_uuid,
"resource_name": resource_name,
"resource_type": resource_type,
"action": action
}
security_rpcapi.operation_create(context, parameters)
try:
result = func(*args, **kwargs)
except Exception, e:
log.error('function(%s) exec error, reason=%s'
% (func.__name__, e))
result = request_result(601)
context = context_data(token, "sec_sec_usr_com", "update")
resource_uuid = result.get('result').get('resource_uuid')
resource_name = result.get('result').get('resource_name')
parameters = {
"record_uuid": record_uuid,
"return_code": result.get('status'),
"return_msg": result.get('msg'),
"resource_uuid": resource_uuid,
"resource_name": resource_name
}
security_rpcapi.operation_update(context, parameters)
return result
def clouddisk_info(self, token, volume_uuid):
context = context_data(token, volume_uuid, "read")
parameters = {'volume_uuid': volume_uuid}
try:
rpc_body = rpc_data("clouddisk_inf", context, parameters)
result = self.rbtmq.rpc_call_client(self.queue, self.timeout,
rpc_body)
except Exception, e:
log.error('RPC client exec error, reason is: %s' % e)
raise Exception(e)
def volume_message(self, dict_data):
token = dict_data.get('token')
monitors = [x for x in conf.VOLUMEIP.split(',')]
volume = dict_data.get('volume')
ret = []
ret_disk = []
for i in volume:
volume_uuid = i.get('volume_uuid')
context = context_data(token, volume_uuid, "read")
try:
volume_result = self.storage_api.disk_info(context)
log.info('get the volume message is:%s,type is %s' %
(ret, type(ret)))
if volume_result.get('status') != 0:
return False, False
except Exception, e:
log.error('get the volume message error, reason=%s' % e)
return False, False
volume_name = volume_result.get('result').get('volume_name')
pool_name = volume_result.get('result').get('pool_name')
image = volume_result.get('result').get('image_name')
fs_type = volume_result.get('result').get('fs_type')
readonly1 = i.get('readonly')
if readonly1 == 'True':
readonly = True
else:
readonly = False
volumes = {
"name": volume_name,
"rbd": {
"monitors": monitors,
"pool": pool_name,
"image": image,
"user": "******",
"keyring": "/etc/ceph/keyring",
"fsType": fs_type,
"readOnly": readonly
}
}
disk_msg = {
'name': volume_name,
'readOnly': readonly,
'mountPath': i.get('disk_path')
}
ret_disk.append(disk_msg)
ret.append(volumes)
class RouterRouteApi(Resource):
def __init__(self):
self.router = RouterRouteManager()
def get(self, router_uuid):
try:
token = request.headers.get('token')
token_auth(token)
except Exception, e:
log.error('Token check error, reason=%s' % e)
return request_result(201)
context = context_data(token, router_uuid, "read")
return self.router.router_detail_manager(context, router_uuid)
class SnapshotRouteApi(Resource):
def __init__(self):
self.snapshot = CinderRouteManager()
# detail
def get(self, snapshot_uuid):
try:
token = request.headers.get('token')
token_auth(token)
except Exception, e:
log.error('Token check error, reason=%s' % e)
return request_result(201)
context = context_data(token, snapshot_uuid, "read")
result = self.snapshot.snap_detail(context, snapshot_uuid)
return result
def clouddisk_unmount(self, token, volume_uuid):
"""
:param attachment_uuid:
:return:
"""
context = context_data(token, volume_uuid, "delete", self.local_ip)
parameters = {'volume_uuid': volume_uuid}
try:
rpc_body = rpc_data("attach_del", context, parameters)
result = self.rbtmq.rpc_call_client(self.queue, self.timeout,
rpc_body)
except Exception, e:
log.error('Rpc client exec error, reason=%s' % e)
raise Exception(e)
class FloatingipRouteApi(Resource):
def __init__(self):
self.floating_ip = NetworkRouteManager()
def get(self, floatingip_uuid):
try:
token = request.headers.get('token')
token_auth(token)
except Exception, e:
log.error('Token check error, reason=%s' % e)
return request_result(201)
context = context_data(token, floatingip_uuid, "read")
return self.floating_ip.floating_ip_detail_manager(
context, floatingip_uuid)
class PortRouteApi(Resource):
def __init__(self):
self.port = PortRouteManager()
def delete(self, port_uuid):
try:
token = request.headers.get('token')
token_auth(token)
source_ip = request.headers.get('X-Real-IP')
if source_ip is None:
source_ip = request.remote_addr
except Exception, e:
log.error('Token check error, reason=%s' % e)
return request_result(201)
context = context_data(token, port_uuid, "delete", source_ip)
return self.port.port_delete(context, port_uuid)
def disk_snapshot_revert(self, token, snapshot_uuid):
"""
:param token:
:param snapshot_uuid:
:return:
"""
context = context_data(token, snapshot_uuid, "delete", self.local_ip)
parameters = {'snapshot_uuid': snapshot_uuid}
try:
rpc_body = rpc_data("snap_rev", context, parameters)
self.rbtmq.rpc_call_client(self.queue, self.timeout, rpc_body)
except Exception, e:
log.error('Rpc client exec error, reason=%s' % e)
raise Exception(e)
class PortApi(Resource):
def __init__(self):
self.port = PortManager()
def post(self):
try:
token = request.headers.get('token')
token_auth(token)
source_ip = request.headers.get('X-Real-IP')
if source_ip is None:
source_ip = request.remote_addr
except Exception, e:
log.error('Token check error, reason=%s' % e)
return request_result(201)
parameters = request.get_data()
context = context_data(token, 'net_net_pro_com', 'create', source_ip)
return self.port.port_create(context, parameters)
def clouddisk_recovery(self, token, volume_uuid):
"""
:param token: string,
:param volume_uuid: string
:return:
"""
context = context_data(token, volume_uuid, 'update', self.local_ip)
parameters = {'volume_uuid': volume_uuid}
try:
rpc_body = rpc_data("clouddisk_rec", context, parameters)
result = self.rbtmq.rpc_call_client(self.queue, self.timeout,
rpc_body)
except Exception, e:
log.error('Rpc client exec error, reason=%s' % e)
raise Exception(e)
class UpApiDefine(Resource):
def __init__(self):
self.alarm = AlarmRpcClient()
def get(self, alarm_uuid):
try:
token = request.headers.get('token')
token_ret = token_auth(token)
except Exception, e:
log.error('Token check error, reason=%s' % e)
return request_result(201)
parameters = {'alarm_uuid': alarm_uuid}
parameters.update(token_ret.get('result'))
context = context_data(token, alarm_uuid, "read")
ret = self.alarm.only_detail_alarm(context, parameters)
return ret
def clouddisk_delete(self, token, volume_uuid, logic=0):
"""
:param token:
:param volume_uuid: string,
:param logic: 1(逻辑删除)/0（物理删除）}
:return:
"""
context = context_data(token, volume_uuid, 'delete', self.local_ip)
parameters = {'volume_uuid': volume_uuid, 'logic': logic}
try:
rpc_body = rpc_data("clouddisk_del", context, parameters)
result = self.rbtmq.rpc_call_client(self.queue, self.timeout,
rpc_body)
except Exception, e:
log.error('Rpc client exec error, reason=%s' % e)
raise Exception(e)
def disk_snapshot_delete(self, token, snapshot_uuid, logic=0):
"""
:param token:string,
:param snapshot_uuid:string,
:param logic: 1/0
:return:
"""
context = context_data(token, snapshot_uuid, "delete", self.local_ip)
parameters = {"snapshot_uuid": snapshot_uuid, "logic": logic}
try:
rpc_body = rpc_data("snap_del", context, parameters)
result = self.rbtmq.rpc_call_client(self.queue, self.timeout,
rpc_body)
except Exception, e:
log.error('Rpc client exec error, reason=%s' % e)
raise Exception(e)
def clouddisk_list(self, token, page_size=1000, page_num=1):
"""
:param token:
:param page_size int 可选
:param page_num int 可选
:return:
"""
context = context_data(token, 'vol_vol_usr_com', 'read')
parameters = {'page_size': page_size, 'page_num': page_num}
try:
rpc_body = rpc_data("clouddisk_lis", context, parameters)
result = self.rbtmq.rpc_call_client(self.queue, self.timeout,
rpc_body)
except Exception, e:
log.error('Rpc client exec error, reason=%s' % e)
raise Exception(e)
def disk_snapshot_revert(self, context, parameters):
'''
:param context:
:param parameters: {"snapshot_uuid":string}
:return:
'''
context = context_data(context.get('token'),
parameters.get('snapshot_uuid'),
'update',
context.get('source_ip'))
try:
rpc_body = rpc_data("snap_rev", context, parameters)
return self.rbtmq.rpc_cast_client(self.queue,
rpc_body)
except Exception, e:
log.error('Rpc client exec error, reason=%s' % e)
return request_result(598)
def clouddisk_mount(self, token, vm_uuid, volume_uuid):
"""
:param token:
:param vm_uuid:
:param volume_uuid:
:return:
"""
context = context_data(token, 'vol_attach_pro_com', 'create',
self.local_ip)
parameters = {'server_uuid': vm_uuid, 'volume_uuid': volume_uuid}
try:
rpc_body = rpc_data("attach_cre", context, parameters)
result = self.rbtmq.rpc_call_client(self.queue, self.timeout,
rpc_body)
except Exception, e:
log.error('Rpc client exec error, reason=%s' % e)
raise Exception(e)
class AdminService(Resource):
def __init__(self):
self.admin_service = AdminServiceRpcClient()
def get(self):
try:
token = request.headers.get('token')
token_ret = token_auth(token)
except Exception, e:
log.error('Token check error, reason=%s' % e)
return request_result(201)
context = context_data(token, "service_list", "read")
try:
ret = self.admin_service.get_all_services(context, token_ret)
except Exception, e:
log.error('error, reason is: %s' % e)
return request_result(601)
class CloudHostApi(Resource):
def __init__(self):
self.compute_api = compute_manager.ComputeManagerAPI()
@time_log
def get(self, cloudhost_uuid):
try:
token = request.headers.get('token')
token_auth(token)
except Exception, e:
log.warning('Token check error, token=%s, reason=%s' % (token, e))
return request_result(201)
context = context_data(token, cloudhost_uuid, "read")
return self.compute_api.cloudhost_info(context)
def put_using(self, dict_data):
token = dict_data.get('token')
volume_uuid = dict_data.get('volume_uuid')
context = context_data(token, volume_uuid, 'update')
parameters = {
'volume_status': dict_data.get('volume_status'),
'update': 'status'
}
try:
change_result = self.storage_api.disk_update(context, parameters)
log.info('change the volume status result is:%s, type is %s' %
(change_result, type(change_result)))
if change_result.get('status') != 0:
return False
except Exception, e:
log.error('change the volume status error, reason is: %s' % e)
return False
def billing_limit_check(token, resource_type, cost):
try:
log.debug('Start billing limit check, '
'token=%s, resource_type=%s, cost=%s'
% (token, resource_type, cost))
context = context_data(token, "bil_lmt_lmt_chk", "create")
parameters = {"resource_type": resource_type, "cost": cost}
limit = billing_rpcapi.BillingRpcApi().limit_check(context, parameters)
log.debug('Billing limit result=%s' % (limit))
status = limit['status']
if status != 0:
raise(Exception('Billing limit check error, '
'request code not equal 0'))
except Exception, e:
log.error('Billing limit local check error: reason=%s' % (e))
raise(Exception('Billing limit check error'))
def clouddisk_info(self, context, parameters={}):
'''
:param context:
:param parameters:{'page_size':int,
'page_num': int}
可选
:return:
'''
context = context_data(context.get('token'),
'vol_vol_usr_com',
'read')
try:
rpc_body = rpc_data("clouddisk_inf", context, parameters)
return self.rbtmq.rpc_call_client(self.queue,
self.timeout,
rpc_body)
except Exception, e:
log.error('Rpc client exec error, reason=%s' % e)
return request_result(598)
def clouddisk_recovery(self, context, parameters):
'''
:param context: {"token":string,
"source_ip"}
:param parameters: {"volume_uuid": string}
:return:
'''
context = context_data(context.get('token'),
parameters.get('volume_uuid'),
'update',
context.get('source_ip'))
try:
rpc_body = rpc_data("clouddisk_rec", context, parameters)
return self.rbtmq.rpc_call_client(self.queue,
self.timeout,
rpc_body)
except Exception, e:
log.error('Rpc client exec error, reason=%s' % e)
return request_result(598)
def disk_snapshot_delete(self, context, parameters):
'''
:param context: {"token":string,
"source_ip": string}
:param parameters:{"snapshot_uuid":string,
"logic":1/0}
:return:
'''
context = context_data(context.get('token'),
parameters.get('snapshot_uuid'),
"delete",
context.get('source_ip'))
try:
rpc_body = rpc_data("snap_del", context, parameters)
return self.rbtmq.rpc_call_client(self.queue,
self.timeout,
rpc_body)
except Exception, e:
log.error('Rpc client exec error, reason=%s' % e)
return request_result(598)
class CinderRouteApi(Resource):
def __init__(self):
self.cinder = CinderRouteManager()
def put(self, volume_uuid):
try:
token = request.headers.get('token')
token_auth(token)
source_ip = request.headers.get('X-Real-IP')
if source_ip is None:
source_ip = request.remote_addr
except Exception, e:
log.error('Token check error, reason=%s' % e)
return request_result(201)
context = context_data(token, volume_uuid, "update", source_ip)
try:
up_dict = json.loads(request.get_data())
except Exception, e:
log.error('request parameters(url) error, reason is: %s' % e)
return request_result(101)
def clouddisk_create(self,
token,
volume_name,
volume_size,
volume_type='lvm',
description=None,
snapshot_uuid=None,
source_volume_uuid=None):
"""
:param : 'token':string,
'source_ip':source_ip
:param : size=int,
:param : name=string,
:param : v_type=string,
:param : description=string,
:param : snapshot_uuid=string,
:param : source_volume_uuid=string}
:return:
"""
context = context_data(token, 'vol_vol_pro_com', 'create',
self.local_ip)
parameters = {
'size': volume_size,
'name': volume_name,
'v_type': volume_type,
'description': description,
'snapshot_uuid': snapshot_uuid,
'source_volume_uuid': source_volume_uuid
}
try:
rpc_body = rpc_data("clouddisk_cre", context, parameters)
result = self.rbtmq.rpc_call_client(self.queue, self.timeout,
rpc_body)
except Exception, e:
log.error('Rpc client exec error, reason=%s' % e)
raise Exception(e)
