def operator_log_list():
logger.info("/operator_log_list method=" + r.method)
try:
request_debug(r, logger)
op_log_handler = OperatorLogHandler()
col_filter = dict((key, r.args.get(key)) for key in r.args)
# rest interface pass time in millsecond, but python datetime
# use time in second
start_stamp_in_sec = float(col_filter['start']) / 1000
end_stamp_in_sec = float(col_filter['end']) / 1000
if 'start' in col_filter.keys():
start_time = datetime.utcfromtimestamp(start_stamp_in_sec)
# start_time = datetime.utcfromtimestamp(1553247740.0)
col_filter['opDate'] = {'$gte': start_time}
col_filter.pop('start')
if 'end' in col_filter.keys():
end_time = datetime.utcfromtimestamp(end_stamp_in_sec)
# end_time = datetime.utcfromtimestamp(1553247800.0)
col_filter['opDate']['$lte'] = end_time
col_filter.pop('end')
items = list(op_log_handler.list(filter_data=col_filter))
except:
raise NotFound(msg='get operation logs failed')
return make_ok_gaea_resp(resource='operator_logs', result=items)
def operator_log_create():
request_debug(r, logger)
if r.content_type.startswith("application/json"):
body = dict(r.get_json(force=True, silent=True))['operator_log']
else:
error_msg = "request header content-type is not supported, use application/json"
raise UnsupportedMediaType(msg=error_msg)
opDate = body.get('opDate', None)
opName = body.get('opName', '')
opObject = body.get('opObject', '')
opResult = body.get('opResult', {})
operator = body.get('operator', '')
opDetails = body.get('opDetails', '')
op_log_handler = OperatorLogHandler()
# id = uuid4().hex
try:
op_log = op_log_handler.create(opDate=opDate,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
return make_ok_gaea_resp(resource='operator_log', result=op_log)
except Exception as e:
msg = "operator_log create failed, error is {e}, method is {m}".format(
e=e, m=opName)
logger.error(msg)
raise InternalServerError(msg=msg)
def post(self, username):
args = user_password_parser.parse_args()
new_password = args["password"]
curUser = args["curUser"]
curPassword = args["curPassword"]
op_log_handler = OperatorLogHandler()
opName = 'ResetUserPassword'
opObject = "User"
operator = "admin"
opDetails = {}
opDetails['username'] = username
cur_time = datetime.datetime.utcnow()
user_obj = User()
userCurrent = user_obj.get_by_username(curUser)
# compare input password with password in db
if not bcrypt.checkpw(curPassword.encode('utf8'),
bytes(userCurrent.dbUser.password.encode())):
error_msg = "Wrong password"
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=400,
operator=operator,
errorMsg=error_msg,
opDetails=opDetails)
return {"error": "Wrong password", "success": False}, 400
user = user_obj.get_by_username(username)
if not user:
error_msg = "No such User"
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=400,
operator=operator,
errorMsg=error_msg,
opDetails=opDetails)
return {"error": "No such User", "success": False}, 400
salt = app.config.get("SALT", b"")
# reset user's passwordop_log_handler = OperatorLogHandler()
new_password = bcrypt.hashpw(new_password.encode('utf8'),
bytes(salt.encode()))
user.update_password(new_password.decode())
data = {"success": True}
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=200,
operator=operator,
opDetails=opDetails)
return data, 200
def post(self, user_id):
args = user_password_parser.parse_args()
origin_password, new_password = \
args["old_password"], args["new_password"]
op_log_handler = OperatorLogHandler()
opName = 'ChangePassword'
opObject = "User"
opDetails = {}
cur_time = datetime.datetime.utcnow()
user_obj = User()
user = user_obj.get_by_id(user_id)
operator = user.username
if not user:
error_msg = "No such User"
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=400,
operator=operator,
errorMsg=error_msg,
opDetails=opDetails)
return {"error": "No such User", "success": False}, 400
salt = app.config.get("SALT", b"")
password = bcrypt.hashpw(origin_password.encode('utf8'),
bytes(salt.encode()))
if not password.decode() == user.dbUser.password:
error_msg = "Invalid origin password"
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=400,
operator=operator,
errorMsg=error_msg,
opDetails=opDetails)
return {"error": "Invalid origin password", "success": False}, 400
new_password = bcrypt.hashpw(new_password.encode('utf8'),
bytes(salt.encode()))
user.update_password(new_password.decode())
data = {"success": True}
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=200,
operator=operator,
opDetails=opDetails)
return data, 200
def delete(self, user_id):
# add operating log
cur_time = datetime.datetime.utcnow()
opName = 'DeleteUser'
opObject = "User"
operator = "admin"
opDetails = {}
opDetails['user_id'] = user_id
op_log_handler = OperatorLogHandler()
try:
user = UserModel.objects.get(id=user_id)
except Exception:
error_msg = "Couldn't find user {id}".format(id=user_id)
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=404,
operator=operator,
errorMsg=error_msg,
opDetails=opDetails)
else:
user.delete()
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=200,
operator=operator,
opDetails=opDetails)
return {"status": "OK"}, 200
def post(self, **kwargs):
# add operating log
cur_time = datetime.datetime.utcnow()
opName = 'CreateUser'
opObject = "User"
operator = "admin"
opDetails = {}
op_log_handler = OperatorLogHandler()
args = user_create_parser.parse_args()
username, password = args["username"], args["password"]
opDetails['username'] = username
role, active = args["role"], args["active"]
balance = args["balance"]
active = active == "true"
salt = app.config.get("SALT", b"")
password = bcrypt.hashpw(password.encode('utf8'), bytes(salt.encode()))
status = "OK"
user_id = ""
try:
user = User(username,
password,
is_admin=role == ADMIN,
role=role,
active=active,
balance=balance)
user.save()
user_id = user.id
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=200,
operator=operator,
opDetails=opDetails)
except Exception as exc:
logger.error("exc %s", exc)
error_msg = "Fail to create user"
status = "FAIL"
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=500,
operator=operator,
errorMsg=error_msg,
opDetails=opDetails)
return {"status": status, "id": user_id}, 200
def organization_create():
request_debug(r, logger)
# add operating log
cur_time = datetime.datetime.utcnow()
# get current func name
opName = sys._getframe().f_code.co_name
opObject = "Organization"
operator = "admin"
opResult = {}
op_log_handler = OperatorLogHandler()
if r.content_type.startswith("application/json"):
body = dict(r.get_json(force=True, silent=True))['organization']
opDetails = body
else:
error_msg = "request header content-type is not supported, use application/json"
opResult['resDes'] = "ERROR"
opResult['resCode'] = 400
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator)
raise UnsupportedMediaType(error_msg)
name = body.get('name', None)
type = body.get('type', None)
domain = body.get('domain', None)
if name is None or name == '':
error_msg = "name is required and not allowed to be ''"
opResult['resDes'] = "ERROR"
opResult['resCode'] = 400
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
raise BadRequest(msg=error_msg)
# if there is '_' in name or ID of genesis.block, orderer couldn't
# start up, saying "failed: error converting config to map: Illegal characters in key: [Group]"
if '_' in name:
# aaa = BadRequest("'_' is not allowed in name or ID")
# # raise BadRequest("'_' is not allowed in name or ID")
# raise aaa
error_msg = '_ is not allowed in name or ID'
opResult['resDes'] = "ERROR"
opResult['resCode'] = 400
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
raise BadRequest(msg=error_msg)
if domain is None or domain == '':
error_msg = "domain is required and not allowed to be ''"
opResult['resDes'] = "ERROR"
opResult['resCode'] = 400
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
raise BadRequest(msg=error_msg)
if type is None:
error_msg = "type is required"
opResult['resDes'] = "ERROR"
opResult['resCode'] = 400
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
raise BadRequest(msg=error_msg)
if body['type'] not in ['peer', 'orderer']:
error_msg = "only peer or orderer type is supported"
opResult['resDes'] = "ERROR"
opResult['resCode'] = 400
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
raise BadRequest(msg=error_msg)
ordererHostnames = body.get('ordererHostnames', None)
peerNum = body.get('peerNum', None)
ca = body.get('ca', {})
id = uuid4().hex
description = body.get('description', "")
if body['type'] == 'peer':
if ordererHostnames is not None:
error_msg = "peer type organizations don't need ordererHostnames"
opResult['resDes'] = "ERROR"
opResult['resCode'] = 400
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
raise BadRequest(msg=error_msg)
if peerNum is None:
peerNum = 2
try:
result = org_handler().create(id=id,
name=name,
description=description,
type=type,
domain=domain,
peerNum=int(peerNum),
ca=ca,
ordererHostnames=[])
opResult['resDes'] = "OK"
opResult['resCode'] = 200
opResult['errorMsg'] = ''
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
return make_ok_gaea_resp('organization', result)
except Exception as e:
error_msg = "internal server error"
opResult['resDes'] = "ERROR"
opResult['resCode'] = 500
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
raise InternalServerError()
else:
if peerNum is not None:
error_msg = "orderer type organizations don't need peers"
opResult['resDes'] = "ERROR"
opResult['resCode'] = 400
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
raise BadRequest(msg=error_msg)
# userNum = body.get('userNum', None)
try:
result = org_handler().create(id=id,
name=name,
description=description,
type=type,
domain=domain,
ca=ca,
peerNum=0,
ordererHostnames=ordererHostnames)
opResult['resDes'] = "OK"
opResult['resCode'] = 200
opResult['errorMsg'] = ''
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
return make_ok_gaea_resp('organization', result)
except Exception as e:
error_msg = "internal server error"
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=500,
operator=operator,
errorMsg=error_msg,
opDetails=opDetails)
raise InternalServerError()
def organization_delete(organization_id):
request_debug(r, logger)
request_data = org_handler().get_by_id(organization_id)
# add operating log
cur_time = datetime.datetime.utcnow()
opName = sys._getframe().f_code.co_name
opObject = "Organization"
operator = "admin"
opResult = {}
opDetails = {}
opDetails['organization_id'] = organization_id
op_log_handler = OperatorLogHandler()
if request_data is not None and "id" in request_data:
if request_data.network is not None:
error_msg = "network has created, organization {} is forbidden to delete.".format(
organization_id)
logger.warning(error_msg)
opResult['resDes'] = "ERROR"
opResult['resCode'] = 500
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator)
raise Forbidden(msg=error_msg)
else:
pass
else:
error_msg = "organization delete without enough data"
logger.warning(error_msg)
opResult['resDes'] = "ERROR"
opResult['resCode'] = 404
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
raise NotFound(msg=error_msg)
logger.debug("host delete with id={0}".format(organization_id))
if org_handler().delete(id=organization_id):
opResult['resDes'] = "OK"
opResult['resCode'] = 200
opResult['errorMsg'] = ''
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
return make_ok_gaea_resp(resource='delete success!', result={})
else:
error_msg = "Failed to delete organization {}".format(organization_id)
logger.warning(error_msg)
opResult['resDes'] = "ERROR"
opResult['resCode'] = 500
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
raise InternalServerError(msg=error_msg)
def blockchain_network_create():
request_debug(r, logger)
# add operating log
# cur_time = datetime.datetime.utcnow()
cur_time = datetime.datetime.utcnow()
opName = sys._getframe().f_code.co_name
opObject = "Network"
operator = "admin"
op_log_handler = OperatorLogHandler()
if r.content_type.startswith("application/json"):
body = dict(r.get_json(force=True, silent=True))['blockchain_network']
opDetails = body
else:
error_msg = "request header content-type is not supported, use application/json"
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=400,
operator=operator,
errorMsg=error_msg)
raise UnsupportedMediaType(msg=error_msg)
name = body.get('name', None)
orderer_orgs = body.get('orderer_orgs', None)
peer_orgs = body.get('peer_orgs', None)
host_id = body.get('host_id', None)
if name is None or orderer_orgs is None or peer_orgs is None or host_id is None:
error_msg = "name, orderer(peer)_orgs and host_id must be provided in request body"
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=400,
operator=operator,
errorMsg=error_msg,
opDetails=opDetails)
raise BadRequest(msg=error_msg)
description = body.get('description', "")
fabric_version = body.get('fabric_version', None)
if fabric_version is None or (fabric_version != 'v1.1'
and fabric_version != 'v1.4'):
error_msg = "Now only fabric v1.1 and v1.4 is supported"
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=400,
operator=operator,
errorMsg=error_msg,
opDetails=opDetails)
raise BadRequest(msg=error_msg)
consensus_type = body.get('consensus_type', None)
if consensus_type is None:
consensus_type = 'kafka'
elif consensus_type not in ['kafka', 'solo']:
error_msg = 'consensus type {} is not supported'.format(consensus_type)
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=400,
operator=operator,
errorMsg=error_msg,
opDetails=opDetails)
raise BadRequest(msg=error_msg)
id = uuid4().hex
host = host_handler.get_active_host_by_id(host_id)
if not host:
error_msg = "Cannot find available host to create new network"
logger.error(error_msg)
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=500,
operator=operator,
errorMsg=error_msg,
opDetails=opDetails)
raise InternalServerError(msg=error_msg)
network_handler = BlockchainNetworkHandler()
try:
network = network_handler.create(id=id,
name=name,
description=description,
fabric_version=fabric_version,
orderer_orgs=orderer_orgs,
peer_orgs=peer_orgs,
host=host,
consensus_type=consensus_type,
create_ts=cur_time)
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=200,
operator=operator,
opDetails=opDetails)
return make_ok_gaea_resp(resource='blockchain_network', result=network)
except Exception as e:
error_msg = "blockchain_network create failed {}".format(e)
logger.error(error_msg)
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=500,
operator=operator,
errorMsg=error_msg,
opDetails=opDetails)
raise InternalServerError(msg=error_msg)
def blockchain_network_delete(blockchain_network_id):
network_handler = BlockchainNetworkHandler()
# add operating log
cur_time = datetime.datetime.utcnow()
opName = sys._getframe().f_code.co_name
opObject = "Network"
operator = "admin"
op_log_handler = OperatorLogHandler()
opDetails = {}
opDetails['blockchain_network_id'] = blockchain_network_id
try:
network = modelv2.BlockchainNetwork.objects.get(
id=blockchain_network_id)
if network.status == 'error':
host = network.host
host.update(pull__clusters=blockchain_network_id)
# if org has referenced network, remove
for peer_org in network.peer_orgs:
org_obj = modelv2.Organization.objects.get(id=peer_org)
org_obj.update(unset__network=network.id)
for orderer_org in network.orderer_orgs:
org_obj = modelv2.Organization.objects.get(id=orderer_org)
org_obj.update(unset__network=network.id)
network.delete()
filepath = '{}{}'.format(CELLO_MASTER_FABRIC_DIR, network.id)
os.system('rm -rf {}'.format(filepath))
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=200,
operator=operator,
opDetails=opDetails)
return make_ok_gaea_resp(resource='delete success!', result={})
except Exception as e:
error_msg = "blockchain_network {id} delete failed, for {err}".\
format(id = blockchain_network_id, err = e)
logger.error(error_msg)
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=404,
operator=operator,
errorMsg=error_msg,
opDetails=opDetails)
raise NotFound(msg=error_msg)
try:
network_handler.delete(network)
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=200,
operator=operator,
opDetails=opDetails)
return make_ok_gaea_resp(resource='delete success!', result={})
except Exception as e:
error_msg = "blockchain_network {id} delete failed, for {err}". \
format(id=blockchain_network_id, err=e)
logger.error(error_msg)
op_log_handler.record_operating_log(opDate=cur_time,
opName=opName,
opObject=opObject,
resCode=500,
operator=operator,
errorMsg=error_msg,
opDetails=opDetails)
raise InternalServerError(msg=error_msg)
def host_create():
request_debug(r, logger)
if r.content_type.startswith("application/json"):
body = dict(r.get_json(force=True, silent=True))
else:
body = r.form
# add operating log
cur_time = datetime.datetime.utcnow()
opName = sys._getframe().f_code.co_name
opObject = "Host"
operator = "admin"
opResult = {}
op_log_handler = OperatorLogHandler()
opDetails = body
name, worker_api, capacity, log_type, log_server, log_level, host_type = \
body['name'], body['worker_api'], body['capacity'], \
body['log_type'], body.get('log_server', ''), body['log_level'], \
body['host_type'] if 'host_type' in body else None
if "autofill" in body and body["autofill"] == "on":
autofill = "true"
else:
autofill = "false"
if "schedulable" in body and body["schedulable"] == "on":
schedulable = "true"
else:
schedulable = "false"
if host_type == "vsphere":
vcaddress = body['vc_address']
if vcaddress.find(":") == -1:
address = vcaddress
port = "443"
else:
address = vcaddress.split(':')[0]
port = vcaddress.split(':')[1]
logger.debug("address={}, port={}".format(address, port))
vmname = "cello-vsphere-" + str(uuid.uuid1())
vsphere_param = {
'vc': {
'address': address,
'port': port,
'username': body['vc_user'],
'password': body['vc_password'],
'network': body['vc_network'],
'vc_datastore': body['datastore'],
'vc_datacenter': body['datacenter'],
'vc_cluster': body['cluster'],
'template': body['vm_template']
},
'vm': {
'vmname': vmname,
'ip': body['vm_ip'],
'gateway': body['vm_gateway'],
'netmask': body['vm_netmask'],
'dns': body['vm_dns'],
'vcpus': int(body['vm_cpus']),
'memory': int(body['vm_memory'])
}
}
logger.debug(
"name={}, capacity={},"
"fillup={}, schedulable={}, log={}/{}, vsphere_param={}".format(
name, capacity, autofill, schedulable, log_type, log_server,
vsphere_param))
vsphere_must_have_params = {
'Name': name,
'Capacity': capacity,
'LoggingType': log_type,
'VCAddress': address,
'VCUser': body['vc_user'],
'VCPassword': body['vc_password'],
'VCNetwork': body['vc_network'],
'Datastore': body['datastore'],
'Datacenter': body['datacenter'],
'Cluster': body['cluster'],
'VMIp': body['vm_ip'],
'VMGateway': body['vm_gateway'],
'VMNetmask': body['vm_netmask']
}
for key in vsphere_must_have_params:
if vsphere_must_have_params[key] == '':
error_msg = "host POST without {} data".format(key)
logger.warning(error_msg)
return make_fail_resp(error=error_msg, data=body)
result = host_handler.create(name=name,
worker_api=worker_api,
capacity=int(capacity),
autofill=autofill,
schedulable=schedulable,
log_level=log_level,
log_type=log_type,
log_server=log_server,
host_type=host_type,
params=vsphere_param,
create_ts=cur_time)
elif host_type == 'kubernetes':
worker_api = body['worker_api']
k8s_param, error_msg = create_k8s_host(name, capacity, log_type, body)
if len(k8s_param) == 0:
opResult['resDes'] = "ERROR"
opResult['resCode'] = 400
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator)
return make_fail_resp(error=error_msg, data=r.form, code=400)
logger.debug(
"name={}, worker_api={}, capacity={},"
"fillup={}, schedulable={}, log={}/{}, k8s_param={}".format(
name, worker_api, capacity, autofill, schedulable, log_type,
log_server, k8s_param))
result = host_handler.create(name=name,
worker_api=worker_api,
capacity=int(capacity),
autofill=autofill,
schedulable=schedulable,
log_level=log_level,
log_type=log_type,
log_server=log_server,
host_type=host_type,
params=k8s_param,
create_ts=cur_time)
else:
logger.debug("name={}, worker_api={}, capacity={}"
"fillup={}, schedulable={}, log={}/{}".format(
name, worker_api, capacity, autofill, schedulable,
log_type, log_server))
if not name or not worker_api or not capacity or not log_type:
error_msg = "host POST without enough data"
logger.warning(error_msg)
opResult['resDes'] = "ERROR"
opResult['resCode'] = 400
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
return make_fail_resp(error=error_msg, data=body, code=400)
else:
host_type = host_type if host_type \
else detect_daemon_type(worker_api)
result = host_handler.create(name=name,
worker_api=worker_api,
capacity=int(capacity),
autofill=autofill,
schedulable=schedulable,
log_level=log_level,
log_type=log_type,
log_server=log_server,
host_type=host_type,
create_ts=cur_time)
logger.debug("result.msg={}".format(result.get('msg')))
if (host_type == "vsphere") and ('msg' in result):
vsphere_errmsg = result.get('msg')
error_msg = "Failed to create vsphere host {}".format(vsphere_errmsg)
logger.warning(error_msg)
#add operator log
opResult['resDes'] = "ERROR"
opResult['resCode'] = 500
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
return make_fail_resp(error=error_msg, data=body, code=500)
elif result:
logger.debug("host creation successfully")
opResult['resDes'] = "OK"
opResult['resCode'] = 200
opResult['errorMsg'] = ""
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
return make_ok_resp(code=CODE_CREATED)
else:
error_msg = "Failed to create host {}".format(body["name"])
logger.warning(error_msg)
opResult['resDes'] = "ERROR"
opResult['resCode'] = 500
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
return make_fail_resp(error=error_msg, data=body, code=500)
def host_delete():
request_debug(r, logger)
request_data = r.get_json(force=True, silent=True)
# add operating log
cur_time = datetime.datetime.utcnow()
opName = sys._getframe().f_code.co_name
opObject = "Host"
operator = "admin"
opResult = {}
op_log_handler = OperatorLogHandler()
opDetails = {}
if "id" in r.form:
host_id = r.form["id"]
elif "id" in request_data:
host_id = request_data.get("id")
opDetails['host_id'] = host_id
else:
error_msg = "host delete without enough data"
logger.warning(error_msg)
opResult['resDes'] = "ERROR"
opResult['resCode'] = 404
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator)
return make_fail_resp(error=error_msg, data=r.form, code=404)
logger.debug("host delete with id={0}".format(host_id))
if host_handler.delete(id=host_id):
opResult['resDes'] = "OK"
opResult['resCode'] = 200
opResult['errorMsg'] = ''
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
return make_ok_resp()
else:
error_msg = "Failed to delete host {}".format(host_id)
logger.warning(error_msg)
opResult['resDes'] = "ERROR"
opResult['resCode'] = 500
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
return make_fail_resp(error=error_msg, code=500)
def host_update():
request_debug(r, logger)
if r.content_type.startswith("application/json"):
body = dict(r.get_json(force=True, silent=True))
else:
body = r.form
# add operating log
cur_time = datetime.datetime.utcnow()
opName = sys._getframe().f_code.co_name
opObject = "Host"
operator = "admin"
opResult = {}
op_log_handler = OperatorLogHandler()
opDetails = body
if "id" not in body:
error_msg = "host PUT without enough data"
logger.warning(error_msg)
opResult['resDes'] = "ERROR"
opResult['resCode'] = 404
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
return make_fail_resp(error=error_msg, data=body, code=404)
else:
id, d = body["id"], {}
for k in body:
if k != "id":
d[k] = body.get(k)
result = host_handler.update(id, d)
if result:
logger.debug("host PUT successfully")
opResult['resDes'] = "OK"
opResult['resCode'] = 200
opResult['errorMsg'] = ''
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
return make_ok_resp()
else:
error_msg = "Failed to update host {}".format(result.get("name"))
logger.warning(error_msg)
opResult['resDes'] = "ERROR"
opResult['resCode'] = 500
opResult['errorMsg'] = error_msg
op_log_handler.create(opDate=cur_time,
opName=opName,
opObject=opObject,
opResult=opResult,
operator=operator,
opDetails=opDetails)
return make_fail_resp(error=error_msg, data=body, code=500)