def _delete_res(res_id):
try:
resources = ResourceModel.objects.get(res_id=res_id)
if len(resources):
os_ins_list = resources.os_ins_list
deploys = Deployment.objects.filter(resource_id=res_id)
for deploy in deploys:
env_ = get_CRP_url(deploy.environment)
crp_url = '%s%s' % (env_, 'api/deploy/deploys')
disconf_list = deploy.disconf_list
disconfs = []
for dis in disconf_list:
dis_ = dis.to_json()
disconfs.append(eval(dis_))
crp_data = {
"disconf_list": disconfs,
"resources_id": res_id,
"domain_list": [],
}
compute_list = resources.compute_list
domain_list = []
for compute in compute_list:
domain = compute.domain
domain_ip = compute.domain_ip
domain_list.append({
"domain": domain,
'domain_ip': domain_ip
})
crp_data['domain_list'] = domain_list
crp_data = json.dumps(crp_data)
requests.delete(crp_url, data=crp_data)
#deploy.delete()
# 调用CRP 删除资源
crp_data = {
"resources_id": resources.res_id,
"os_inst_id_list": resources.os_ins_list,
"vid_list": resources.vid_list,
}
env_ = get_CRP_url(resources.env)
crp_url = '%s%s' % (env_, 'api/resource/deletes')
crp_data = json.dumps(crp_data)
requests.delete(crp_url, data=crp_data)
cmdb_p_code = resources.cmdb_p_code
resources.delete()
# 回写CMDB
if CMDB_URL:
cmdb_url = '%s%s%s' % (CMDB_URL, 'cmdb/api/repores_delete/',
cmdb_p_code)
requests.delete(cmdb_url)
except Exception as e:
Log.logger.info(
'---- Scheduler_utuls _delete_res function Exception info is %s'
% (e))
def resource_reduce(resource, number, ips):
reduce_list = []
for os_ins in resource.os_ins_ip_list:
if os_ins.ip in ips:
reduce_list.append(os_ins)
reduce_list = random.sample(reduce_list, number)
os_inst_id_list = []
reduce_list = [eval(reduce_.to_json()) for reduce_ in reduce_list]
for os_ip_dict in reduce_list:
os_inst_id = os_ip_dict["os_ins_id"]
os_inst_id_list.append(os_inst_id)
crp_data = {
"resource_id": resource.res_id,
"resource_name": resource.resource_name,
"os_ins_ip_list": reduce_list,
"resource_type": resource.resource_type,
"cloud": resource.cloud,
"set_flag": 'reduce',
'syswin_project': 'uop'
}
env_ = get_CRP_url(resource.env)
crp_url = '%s%s' % (env_, 'api/resource/deletes')
crp_data = json.dumps(crp_data)
msg = requests.delete(crp_url, data=crp_data)
return msg
def put(self):
parser = reqparse.RequestParser()
parser.add_argument('env', type=str, location="json")
parser.add_argument('domain_ip', type=str, location="json")
args = parser.parse_args()
env = args.env
domain_ip = args.domain_ip
appinfo = []
app = {}
Data = dict()
try:
nginx_info = get_k8s_nginx(env)
ips = nginx_info.get("nginx_ips") if nginx_info.get(
"nginx_ips") else K8S_NGINX_IPS
nginx_port = nginx_info.get("nginx_port") if nginx_info.get(
"nginx_port") else K8S_NGINX_PORT
resources = ResourceModel.objects.filter(resource_type="app",
cloud="2",
env=env,
approval_status="success",
is_deleted=0)
for res in resources:
domain = res.domain
if domain:
app["domain"] = domain
app["domain_ip"] = domain_ip
app["nginx_port"] = nginx_port
app["ips"] = ips
appinfo.append(app)
Data["appinfo"] = appinfo
Data["action"] = "update_nginx"
data_str = json.dumps(Data)
CPR_URL = get_CRP_url(env)
url = CPR_URL + "api/deploy/deploys"
Log.logger.debug("Data args is " + str(Data))
Log.logger.debug("URL args is " + url)
headers = {
'Content-Type': 'application/json',
}
resp = requests.put(url=url, headers=headers, data=data_str)
if resp.json().get("code") == 200:
data = "Success"
code = 200
msg = "Update nginx info success"
else:
data = "Failed"
code = 400
msg = "Update nginx info Failed"
except Exception as e:
msg = "Update nginx info error {e}".format(e=str(e))
code = 500
data = "Error"
ret = response_data(code, msg, data)
return ret, code
def get(cls):
try:
ret = ConfigureEnvModel.objects.all()
envs = [{'id': env.id, 'name': env.name} for env in ret]
urls = [{
'url': get_CRP_url(e.get('id')),
'env': e.get('id')
} for e in envs]
headers = {'Content-Type': 'application/json'}
res_list = []
for url in urls:
Log.logger.info('[UOP] Get url: %s', url)
url_ = '%s%s' % (url.get('url'), 'api/az/uopStatistics')
Log.logger.info('[UOP] Get the whole url: %s', url_)
zone_items = ConfOpenstackModel.objects.filter(
env=url.get('env'),
availability_zone__exists=True).values_list(
'cloud', 'availability_zone')
zone_dict = defaultdict(list)
for k, v in zone_items:
zone_dict[k].append(v)
zone_dict['cloud1'] = zone_dict.pop('1', [])
zone_dict['cloud2'] = zone_dict.pop('2', [])
data_str = json.dumps({
"env": url.get("env"),
"info": zone_dict
})
try:
result = requests.get(url_,
headers=headers,
data=data_str,
timeout=10)
if result.json().get('code') == 200:
Log.logger.debug(url_ + ' ' + json.dumps(headers))
cur_res = result.json().get('result').get('res')
res_list.append({url.get('env'): cur_res})
except Exception as e:
res_list.append({url.get('env'): base_statistic_info})
Log.logger.error(
"Get info from crp error {e}".format(e=str(e)))
res = {'result': {'res': []}, 'code': 200}
res['result']['res'] = res_list
except Exception as e:
err_msg = str(e)
Log.logger.error('list az statistics err: %s' % err_msg)
res = {"code": 400, "result": {"res": "failed", "msg": err_msg}}
return res, 400
else:
return res, 200
def flush_crp_to_cmdb_by_osid(osid, env):
url = get_CRP_url(env)
crp_url = '%s%s' % (url, 'api/openstack/nova/state?os_inst_id=' + osid)
ret = requests.get(crp_url).json()
Log.logger.info("flush_crp_to_cmdb_by_osid crp result is:{}".format(ret))
if ret.get('code') == 200:
status = ret["result"]["vm_state"]
if CMDB_URL:
cmdb_url = CMDB_URL + "cmdb/api/vmdocker/status/"
ret = requests.put(cmdb_url,
data=json.dumps(
{"osid_status": [{
osid: status
}]})).json()
Log.logger.info(
"flush_crp_to_cmdb_by_osid cmdb result is:{}".format(ret))
def get(self):
code = 200
msg = ''
data = {}
parser = reqparse.RequestParser()
parser.add_argument('namespace', type=str)
parser.add_argument('resource_name', type=str)
parser.add_argument('env', type=str)
parser.add_argument('pod_name', type=str)
args = parser.parse_args()
namespace = args.namespace
resource_name = args.resource_name
pod_name = args.pod_name
env = args.env
try:
Data = {}
crp_url = get_CRP_url(env)
url = crp_url + "api/openstack/docker/logs/"
Data["resource_name"] = resource_name
Data["osid"] = pod_name
Data["namespace"] = namespace
Data["cloud"] = "2"
data_str = json.dumps(Data)
ret = requests.post(url,
data=data_str,
headers={'Content-Type': 'application/json'},
timeout=60)
res = ret.json()
code = res.get("code")
if code == 200:
logs = res.get("result").get("logs")
msg = "Get log success"
else:
code = 400
logs = ""
msg = "Get log failed"
data["logs"] = logs
except Exception as e:
msg = "Get log error {e}".format(e=str(e))
code = 500
data = "Error"
Log.logger.error(msg)
ret = response_data(code, msg, data)
return ret, code
def _delete_deploy(deploy_id):
try:
deploy = Deployment.objects.get(deploy_id=deploy_id)
if len(deploy):
env_ = get_CRP_url(deploy.environment)
crp_url = '%s%s' % (env_, 'api/deploy/deploys')
disconf_list = deploy.disconf_list
disconfs = []
for dis in disconf_list:
dis_ = dis.to_json()
disconfs.append(eval(dis_))
crp_data = {
"disconf_list": disconfs,
"resources_id": '',
"domain_list": [],
"resources_id": ''
}
res = ResourceModel.objects.get(res_id=deploy.resource_id)
if res:
crp_data['resources_id'] = res.res_id
compute_list = res.compute_list
domain_list = []
for compute in compute_list:
domain = compute.domain
domain_ip = compute.domain_ip
domain_list.append({
"domain": domain,
'domain_ip': domain_ip
})
crp_data['domain_list'] = domain_list
deploy.delete()
# 调用CRP 删除资源
crp_data = json.dumps(crp_data)
requests.delete(crp_url, data=crp_data)
# 回写CMDB
#cmdb_url = '%s%s%s'%(CMDB_URL, 'api/repores_delete/', resources.res_id)
#requests.delete(cmdb_url)
except Exception as e:
Log.logger.info(
'----Scheduler_utuls _delete_deploy function Exception info is %s'
% (e))
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('resource_name',
type=str,
required=True,
location='args')
parser.add_argument('project_name', type=str, location='args')
parser.add_argument('env', type=str, location='args')
parser.add_argument('version', type=str, location='args')
args = parser.parse_args()
version = args.version if args.version else 1
_env = get_CRP_url(args.env)
crp_url = '%s%s' % (_env, 'api/deploy/log_detail')
condition = 'resource_name={r}&project_name={p}&version={v}'.format(
r=args.resource_name, p=args.project_name, v=version)
request_url = "{url}?{p}".format(url=crp_url, p=condition)
res = requests.get(request_url)
return json.loads(res.text)
def put(self, res_id):
code = 200
res = ""
msg = {}
try:
resource = models.ResourceModel.objects.get(res_id=res_id)
except Exception as e:
code = 410
res = "Failed to find the rsource"
ret = {"code": code, "result": {"res": res, "msg": msg}}
return ret, code
set_flag = "res"
data = deal_crp_data(resource, set_flag)
data_str = json.dumps(data)
headers = {'Content-Type': 'application/json'}
try:
CPR_URL = get_CRP_url(data['env'])
msg = requests.post(CPR_URL + "api/resource/sets",
data=data_str,
headers=headers)
except Exception as e:
res = "failed to connect CRP service.{}".format(str(e))
code = 500
ret = {"code": code, "result": {"res": res}}
return ret, code
if msg.status_code != 202:
resource.reservation_status = "unreserved"
resource.save()
code = msg.status_code
res = "Failed to reserve resource."
resource.reservation_status = "set_fail"
resource.save()
else:
resource.reservation_status = "reserving"
resource.save()
code = 200
res = "Success in reserving resource."
ret = {"code": code, "result": {"res": res}}
return ret, code
def flush_crp_to_cmdb():
Log.logger.info(
'----------------flush_crp_to_cmdb job/5min----------------')
osid_status = []
now = datetime.datetime.now()
with db.app.app_context():
try:
envs = CRP_URL.items()
env_list = []
url_list = []
for env, url in envs:
if url not in url_list:
env_list.append(env)
url_list.append(url)
for env in env_list:
if not env:
continue
try:
K8sInfos = ConfigureK8sModel.objects.filter(env=env)
if K8sInfos:
for info in K8sInfos:
namespace = info.namespace_name
env_ = get_CRP_url(env)
crp_url = '%s%s' % (
env_, 'api/openstack/nova/states?namespace={}'.
format(namespace))
ret = requests.get(
crp_url,
timeout=290).json()["result"]["vm_info_dict"]
osid_status.append(ret)
else:
env_ = get_CRP_url(env)
crp_url = '%s%s' % (env_, 'api/openstack/nova/states')
ret = requests.get(
crp_url).json()["result"]["vm_info_dict"]
osid_status.append(ret)
except Exception as e:
Log.logger.error("Get vm info from crp error {}".format(e))
if osid_status:
for os in osid_status:
for k, v in os.items():
vms = Statusvm.objects.filter(osid=str(k))
if not vms:
q = "-".join(str(k).split("-")[:-2])
vms = Statusvm.objects.filter(
resource_name__icontains=q,
update_time__ne=now)
if vms:
vms[0].update(status=v[1],
osid=k,
ip=v[0],
update_time=now,
physical_server=v[-1])
if CMDB_URL:
cmdb_url = CMDB_URL + "cmdb/api/vmdocker/status/"
ret = requests.put(
cmdb_url,
data=json.dumps({"osid_status": osid_status})).json()
else:
Log.logger.info(
"flush_crp_to_cmdb crp->openstack result is null")
except Exception as exc:
Log.logger.error("flush_crp_to_cmdb error:{}".format(exc))
def post(self):
code = 200
parser = reqparse.RequestParser()
parser.add_argument('resource_name', type=str)
parser.add_argument('project_name', type=str)
parser.add_argument('module_name', type=str)
parser.add_argument('business_name', type=str)
parser.add_argument('cmdb2_project_id', type=str)
parser.add_argument('cmdb2_module_id', type=str)
parser.add_argument('department', type=str)
parser.add_argument('user_name', type=str)
parser.add_argument('user_id', type=str)
parser.add_argument('env', type=str)
parser.add_argument('formStatus', type=str)
parser.add_argument('approval_status', type=str)
parser.add_argument('resource_list', type=list, location='json')
parser.add_argument('compute_list', type=list, location='json')
parser.add_argument('cloud', type=str)
parser.add_argument('resource_type', type=str)
parser.add_argument('domain', type=str)
parser.add_argument('lb_methods', type=str)
parser.add_argument('namespace', type=str)
parser.add_argument('host_mapping', type=list, location='json')
parser.add_argument('network_id', type=str, default="")
parser.add_argument('scheduler_zone', type=str, default="")
parser.add_argument('agree', type=bool, default=True)
parser.add_argument('annotations', type=str, default="")
parser.add_argument('action',
type=str,
location='json',
default="admin_approve_allow")
parser.add_argument('deploy_name',
type=str,
required=True,
location='json')
parser.add_argument('initiator', type=str, location='json', default="")
parser.add_argument('release_notes',
type=str,
location='json',
default="")
parser.add_argument('mysql_exe_mode',
type=str,
location='json',
default="")
parser.add_argument('mysql_context',
type=str,
location='json',
default="")
parser.add_argument('redis_exe_mode',
type=str,
location='json',
default="")
parser.add_argument('redis_context',
type=str,
location='json',
default="")
parser.add_argument('mongodb_exe_mode',
type=str,
location='json',
default="")
parser.add_argument('mongodb_context',
type=str,
location='json',
default="")
parser.add_argument('approve_suggestion',
type=str,
location='json',
default="")
parser.add_argument('apply_status',
type=str,
location='json',
default="success")
parser.add_argument('approve_status',
type=str,
location='json',
default="success")
parser.add_argument('disconf', type=list, location='json', default=[])
parser.add_argument('database_password',
type=str,
location='json',
default="")
parser.add_argument('domain_ip', type=str, location='json', default="")
parser.add_argument('certificate',
type=str,
location='json',
default="")
parser.add_argument('named_url', type=str, location='json', default="")
args = parser.parse_args()
crp_url = get_CRP_url(args.env)
setattr(args, 'crp_url', crp_url)
project_name = args.project_name
env = args.env
# tag = time.time().__str__()[2:10]
# resource_name = "{project_name}-{env}-{tag}".format(project_name=project_name,env=env,tag=tag)
# setattr(args, 'resource_name', resource_name)
i_code, i_msg, cmdb2_project_id, module_id, business_id, project_name, module_name, business_name = get_item_id(
project_name)
if i_code == 200:
setattr(args, 'cmdb2_project_id', cmdb2_project_id)
setattr(args, 'module_id', module_id)
setattr(args, 'business_id', business_id)
setattr(args, 'module_name', module_name)
setattr(args, 'business_name', business_name)
res_deploy(args)
data = "success"
msg = "success"
setattr(args, 'crp_url', crp_url)
else:
data = "failed"
code = i_code
msg = i_msg
ret = response_data(code, msg, data)
return ret, code
def delete(cls):
parser = reqparse.RequestParser()
parser.add_argument('deploy_id', type=str)
parser.add_argument('user', type=str)
args = parser.parse_args()
user = args.user
deploy_id = args.deploy_id
Log.logger.info("delete deployment:{}".format(deploy_id))
try:
deploy = Deployment.objects.get(deploy_id=deploy_id)
if len(deploy):
env_ = get_CRP_url(deploy.environment)
crp_url = '%s%s' % (env_, 'api/deploy/deploys')
disconf_list = deploy.disconf_list
disconfs = []
for dis in disconf_list:
dis_ = dis.to_json()
disconfs.append(eval(dis_))
crp_data = {
"disconf_list": disconfs,
"resources_id": '',
"domain_list": [],
}
resm = ResourceModel.objects.filter(res_id=deploy.resource_id,is_deleted=0)
if resm:
for res in resm:
crp_data['resources_id'] = res.res_id
compute_list = res.compute_list
domain_list = []
for compute in compute_list:
domain = compute.domain
domain_ip = compute.domain_ip
domain_list.append({"domain": domain, 'domain_ip': domain_ip})
crp_data['domain_list'] = domain_list
# 调用CRP 删除nginx资源
d_count = ResourceModel.objects.filter(domain=domain,is_deleted=0).count()
#如果还有一个以上的工程使用这个domain 不删除
if d_count <= 1:
crp_data = json.dumps(crp_data)
requests.delete(crp_url, data=crp_data)
deploy.delete()
# 回写CMDB
# cmdb_url = '%s%s%s'%(CMDB_URL, 'api/repores_delete/', resources.res_id)
# requests.delete(cmdb_url)
except Exception as e:
Log.logger.info('----Scheduler_utuls _delete_deploy function Exception info is %s' % (e))
ret = {
'code': 500,
'result': {
'res': 'fail',
'msg': 'Delete deployment application failed.'
}
}
return ret, 500
# try:
# deploy = Deployment.objects.get(deploy_id=deploy_id)
# if len(deploy):
# env_ = get_CRP_url(deploy.environment)
# crp_url = '%s%s'%(env_, 'api/deploy/deploys')
# disconf_list = deploy.disconf_list
# disconfs = []
# for dis in disconf_list:
# dis_ = dis.to_json()
# disconfs.append(eval(dis_))
# crp_data = {
# "disconf_list" : disconfs,
# "resources_id": '',
# "domain_list":[],
# "resources_id": ''
# }
# res = ResourceModel.objects.get(res_id=deploy.resource_id)
# if res:
# #if hasattr(res, 'disconf_list'):
# #crp_data['disconf_list'] = res.disconf_list
# crp_data['resources_id'] = res.res_id
# compute_list = res.compute_list
# domain_list = []
# for compute in compute_list:
# domain = compute.domain
# domain_ip = compute.domain_ip
# domain_list.append({"domain": domain, 'domain_ip': domain_ip})
# crp_data['domain_list'] = domain_list
#
# deploy.delete()
# # 调用CRP 删除资源
# crp_data = json.dumps(crp_data)
# requests.delete(crp_url, data=crp_data)
# # 回写CMDB
# #cmdb_url = '%s%s%s'%(CMDB_URL, 'api/repores_delete/', resources.res_id)
# #requests.delete(cmdb_url)
#
# else:
# ret = {
# 'code': 200,
# 'result': {
# 'res': 'success',
# 'msg': 'deployment not found.'
# }
# }
# return ret, 200
# except Exception as e:
# print e
# ret = {
# 'code': 500,
# 'result': {
# 'res': 'fail',
# 'msg': 'Delete deployment application failed.'
# }
# }
# return ret, 500
ret = {
'code': 200,
'result': {
'res': 'success',
'msg': 'Delete deployment application success.'
}
}
return ret, 200
def delete_resource_deploy(res_id):
os_inst_ip_list = []
try:
resources_obj = ResourceModel.objects.filter(res_id=res_id)
if len(resources_obj):
resources = resources_obj[0]
resource_type = resources.resource_type
cloud = resources.cloud
env = resources.env
project_name = resources.project_name
deploys = Deployment.objects.filter(
resource_id=res_id,
deploy_type="deploy").order_by("-created_time")
disconfs = []
domain_list = []
domain_existed_list = []
domain_info_list = []
for deploy in deploys:
disconf_list = deploy.disconf_list
for dis in disconf_list:
dis_ = dis.to_json()
disconfs.append(eval(dis_))
app_image = eval(deploy.app_image)
for app in app_image:
domain = app.get("domain", "")
domain_path = app.get("domain_path", "")
domain_ip = app.get("domain_ip", "")
named_url = app.get("named_url", "")
d_count = ResourceModel.objects.filter(
domain=domain,
is_deleted=0,
resource_type=resource_type).count()
if d_count <= 1 and resource_type == "app" and domain_ip:
domain_list.append({
"domain": domain,
'domain_ip': domain_ip,
"named_url": named_url,
"cloud": cloud,
"resource_type": resource_type,
"project_name": project_name,
"domain_path": domain_path
})
elif resource_type == "kvm" and domain_ip:
domain_list.append({
"domain": domain,
'domain_ip': domain_ip,
"named_url": named_url,
"cloud": cloud,
"resource_type": resource_type,
"project_name": project_name,
"domain_path": domain_path
})
for dl in domain_list:
domain = dl.get("domain")
if domain not in domain_existed_list:
domain_existed_list.append(domain)
domain_info_list.append(dl)
crp_data = {
"disconf_list": disconfs,
"resource_id": res_id,
"domain_list": domain_info_list,
"set_flag": 'res',
"environment": env,
}
env_ = get_CRP_url(env)
crp_url = '%s%s' % (env_, 'api/deploy/deploys')
crp_data = json.dumps(crp_data)
requests.delete(crp_url, data=crp_data)
# 调用CRP 删除资源
namespace = None
compute_list = resources.compute_list
for compute in compute_list:
namespace = compute.namespace
os_ins_ip_list = resources.os_ins_ip_list
for os_ip in os_ins_ip_list:
os_ip_dict = {}
os_ip_dict["os_ins_id"] = os_ip["os_ins_id"]
os_ip_dict["os_vol_id"] = os_ip["os_vol_id"]
os_inst_ip_list.append(os_ip_dict)
crp_data = {
"resource_id": resources.res_id,
"resource_name": resources.resource_name,
"resource_type": resource_type,
"cloud": cloud,
"os_ins_ip_list": os_inst_ip_list,
"vid_list": resources.vid_list,
"set_flag": 'res',
'syswin_project': 'uop',
'namespace': namespace,
}
env_ = get_CRP_url(resources.env)
crp_url = '%s%s' % (env_, 'api/resource/deletes')
crp_data = json.dumps(crp_data)
requests.delete(crp_url, data=crp_data)
reservation_status = resources.reservation_status
#如果预留失败的直接删除数据库的记录
if reservation_status in [
"set_fail", "unreserved", "approval_fail", "revoke",
"reserving"
]:
if reservation_status in [
"reserving", "set_fail"
] and cloud == "2" and resource_type == "app":
resources.reservation_status = "deleting"
resources.save()
else:
deleted_date = datetime.datetime.now()
new_resource_name = resources.resource_name + '_' + str(
deleted_date)[20:-1]
resources.update(resource_name=new_resource_name,
is_deleted=1,
deleted_date=deleted_date,
reservation_status="delete_success")
else:
resources.reservation_status = "deleting"
resources.save()
deployments = Deployment.objects.filter(
resource_id=res_id).order_by("-created_time")
if deployments:
dep = deployments[0]
dep.deploy_result = "deleting"
dep.save()
#cmdb_p_code = resources.cmdb_p_code
#resources.is_deleted = 1
#resources.deleted_date = datetime.datetime.now()
#resources.save()
# 回写CMDB
#delete_cmdb1(cmdb_p_code)
#delete_uop(res_id)
#delete_cmdb2(res_id)
else:
ret = {
'code': 200,
'result': {
'res': 'success',
'msg': 'Resource not found.'
}
}
return ret, 200
except Exception as e:
Log.logger.error(str(e))
ret = {
'code': 500,
'result': {
'res': 'fail',
'msg':
'Delete resource application failed.{e}'.format(e=str(e))
}
}
return ret, 500
ret = {
'code': 200,
'result': {
'res': 'success',
'msg': 'Delete resource application success.'
}
}
return ret, 200
def post(self):
code = 200
res = ""
msg = {}
parser = reqparse.RequestParser()
parser.add_argument('resource_id', type=str)
parser.add_argument('approval_id', type=str)
parser.add_argument('compute_list', type=list, location='json')
args = parser.parse_args()
resource_id = args.resource_id
approval_id = args.approval_id
try:
resource = models.ResourceModel.objects.get(res_id=resource_id)
deployment = models.Deployment.objects.get(deploy_id=approval_id)
approval = models.Approval.objects.get(approval_id=approval_id)
except Exception as e:
Log.logger.error(str(e))
code = 410
res = "Failed to find the rsource"
ret = {"code": code, "result": {"res": res, "msg": msg}}
return ret, code
data = dict()
data['unit_id'] = resource.project_id
# data['network_id'] = resource.network_id.strip()
data['unit_name'] = resource.project
data['unit_des'] = ''
data['user_id'] = resource.user_id
data['username'] = resource.user_name
data['department'] = resource.department
data['created_time'] = str(resource.created_date)
data['resource_id'] = resource.res_id
data['resource_name'] = resource.resource_name
data['domain'] = resource.domain
data['project_id'] = resource.cmdb2_project_id
data['module_id'] = resource.cmdb2_module_id
data['department_id'] = resource.department_id
data['env'] = resource.env
data['docker_network_id'] = resource.docker_network_id
data['mysql_network_id'] = resource.mysql_network_id
data['redis_network_id'] = resource.redis_network_id
data['mongodb_network_id'] = resource.mongodb_network_id
data['cmdb_repo_id'] = resource.cmdb_p_code
data['cloud'] = resource.cloud
data['resource_type'] = resource.resource_type
data['set_flag'] = approval.capacity_status
data['syswin_project'] = 'uop'
data['project_name'] = resource.project_name
named_url_list = []
rets = models.ConfigureNamedModel.objects.filter(
env=resource.env).order_by("-create_time")
for ret in rets:
named_url_list.append(ret.url)
data["named_url_list"] = named_url_list
resource_list = resource.resource_list
compute_list = resource.compute_list
resource_type = resource.resource_type
number = 0
if resource_list:
res = []
for db_res in resource_list:
res.append({
"instance_name": db_res.ins_name,
"instance_id": db_res.ins_id,
"instance_type": db_res.ins_type,
"cpu": db_res.cpu,
"mem": db_res.mem,
"disk": db_res.disk,
"quantity": 0,
"version": db_res.version,
"volume_size": db_res.volume_size,
"image_id": db_res.image_id,
"network_id": db_res.network_id,
"flavor": db_res.flavor_id,
"volume_exp_size": db_res.volume_exp_size,
"image2_id": db_res.image2_id,
"flavor2": db_res.flavor2_id,
"availability_zone": db_res.availability_zone,
"port": db_res.port,
})
data['resource_list'] = res
ips = []
if compute_list:
com = []
for db_com in compute_list:
# for i in range(0, db_com.quantity):
meta = json.dumps(
db_com.docker_meta) if db_com.docker_meta else ""
url = db_com.url
capacity_list = db_com.capacity_list
for capacity_ in capacity_list:
if capacity_.capacity_id == approval_id:
if resource.cloud == "2" and resource_type == "app":
number = capacity_.end_number
else:
number = abs(capacity_.begin_number -
capacity_.end_number)
com.append({
"instance_name": db_com.ins_name,
"instance_id": db_com.ins_id,
"cpu": db_com.cpu,
"mem": db_com.mem,
"image_url": url,
"quantity": number,
"domain": db_com.domain,
"port": db_com.port,
"domain_ip": db_com.domain_ip,
"meta": meta,
"health_check": db_com.health_check,
"network_id": db_com.network_id,
"networkName": db_com.networkName,
"tenantName": db_com.tenantName,
"host_env": db_com.host_env,
"language_env": db_com.language_env,
"deploy_source": db_com.deploy_source,
"database_config": db_com.database_config,
"lb_methods": db_com.lb_methods,
"namespace": db_com.namespace,
"ready_probe_path": db_com.ready_probe_path,
"domain_path": db_com.domain_path,
"host_mapping": db_com.host_mapping,
"availability_zone": db_com.availability_zone,
"image_id": db_com.image_id,
"flavor": db_com.flavor_id,
"pom_path": db_com.pom_path,
"branch": db_com.branch,
"git_res_url": db_com.git_res_url,
"scheduler_zone": db_com.scheduler_zone,
})
ips.extend([ip for ip in db_com.ips])
data['compute_list'] = com
data_str = json.dumps(data)
headers = {'Content-Type': 'application/json'}
try:
cloud = resource.cloud
if cloud == '2' and resource_type == "app":
CPR_URL = get_CRP_url(data['env'])
msg = requests.post(CPR_URL + "api/resource/sets",
data=data_str,
headers=headers)
else:
if approval.capacity_status == 'increase':
CPR_URL = get_CRP_url(data['env'])
msg = requests.post(CPR_URL + "api/resource/sets",
data=data_str,
headers=headers)
elif approval.capacity_status == 'reduce':
msg = resource_reduce(resource, number, ips)
except Exception as e:
res = "failed to connect CRP service."
code = 500
ret = {"code": code, "result": {"res": res}}
return ret, code
if msg.status_code != 202:
code = msg.status_code
res = "Failed to capacity resource."
if approval.capacity_status == "increase":
deployment.deploy_result = "increase_fail"
elif approval.capacity_status == "reduce":
deployment.deploy_result = "reduce_fail"
else:
code = 200
res = "Success in capacity resource."
if approval.capacity_status == "increase":
deployment.deploy_result = "increasing"
elif approval.capacity_status == "reduce":
deployment.deploy_result = "reducing"
resource.save()
deployment.save()
ret = {"code": code, "result": {"res": res}}
return ret, code
def put(self):
"""
其他资源编辑审批通过，往crp发送数据
:return:
"""
code = 200
res = ""
msg = {}
parser = reqparse.RequestParser()
parser.add_argument('resource_id', type=str)
args = parser.parse_args()
resource_id = args.resource_id
try:
resource = models.ResourceModel.objects.get(res_id=resource_id)
except Exception as e:
Log.logger.error(str(e))
code = 410
res = "Failed to find the rsource"
ret = {"code": code, "result": {"res": res, "msg": msg}}
return ret, code
# 其他资源的修改
vid_list = resource.vid_list
number = vid_list.__str__()
try:
if number > 0:
# 对已经预留好的资源进程修改
resource_list = resource.resource_list
for res in resource_list:
quantity = res.quantity
if number < quantity: # 扩容
quantity = quantity - number
set_flag = "increase"
data = deal_crp_data(resource, set_flag, quantity)
data_str = json.dumps(data)
CPR_URL = get_CRP_url(data['env'])
headers = {'Content-Type': 'application/json'}
msg = requests.post(CPR_URL + "api/resource/sets",
data=data_str,
headers=headers)
elif number > quantity: # 缩容
ips = []
quantity = number - quantity
for os_ins in resource.os_ins_ip_list:
ip = os_ins.ip
ips.append(ip)
msg = resource_reduce(resource, quantity, ips)
else: # 既不扩容也不缩容
set_flag = "res"
quantity = "0"
data = deal_crp_data(resource, set_flag, quantity)
data_str = json.dumps(data)
CPR_URL = get_CRP_url(data['env'])
headers = {'Content-Type': 'application/json'}
msg = requests.post(CPR_URL + "api/resource/sets",
data=data_str,
headers=headers)
except Exception as e:
res = "UOP put resource failed.{}".format(str(e))
code = 500
ret = {"code": code, "result": {"res": res}}
return ret, code
if msg.status_code != 202:
code = msg.status_code
res = "Failed to reserve resource."
else:
resource.reservation_status = "reserving"
resource.save()
code = 200
res = "Success in reserving resource."
ret = {"code": code, "result": {"res": res}}
return ret, code
def reservation_post(args):
code = 200
res = ""
msg = {}
resource_id = args.resource_id
try:
resource = models.ResourceModel.objects.get(res_id=resource_id)
except Exception as e:
Log.logger.error(str(e))
code = 410
res = "Failed to find the rsource"
ret = {"code": code, "result": {"res": res, "msg": msg}}
return ret, code
os_ins_ip_list = resource.os_ins_ip_list
# 说明是对已有资源配置的审批
headers = {'Content-Type': 'application/json'}
if os_ins_ip_list:
flavor = None
volume_size = None
volume_exp_size = None
os_ins_ip_list = [eval(os_ins.to_json()) for os_ins in os_ins_ip_list]
resource_list = resource.resource_list
resource_id = resource.res_id
resource_type = resource.resource_type
if resource_list:
flavor = resource_list[0].flavor_id
volume_size = resource_list[0].volume_size
volume_exp_size = resource_list[0].volume_exp_size
data = dict()
data["set_flag"] = "config"
data["os_ins_ip_list"] = os_ins_ip_list
data["flavor"] = flavor if flavor else ''
data["cloud"] = resource.cloud
data["volume_size"] = volume_size if volume_size else 0
data["volume_exp_size"] = volume_exp_size if volume_exp_size else 0
data["syswin_project"] = "uop"
data["resource_id"] = resource_id
data["resource_type"] = resource_type
data['env'] = resource.env
data_str = json.dumps(data)
else:
set_flag = "res"
data = deal_crp_data(resource, set_flag)
data_str = json.dumps(data)
try:
Log.logger.info("Data args is %s", data)
if args.crp_url:
crp_url = args.crp_url
else:
crp_url = get_CRP_url(data['env'])
if os_ins_ip_list:
msg = requests.put(crp_url + "api/resource/sets",
data=data_str,
headers=headers)
else:
msg = requests.post(crp_url + "api/resource/sets",
data=data_str,
headers=headers)
code = 200
res = "Success in reserving or configing resource."
except Exception as e:
res = "failed to connect CRP service.{}".format(str(e))
code = 500
ret = {"code": code, "result": {"res": res}}
return ret, code
if msg.status_code != 202:
if os_ins_ip_list:
resource.reservation_status = "config_fail"
else:
resource.reservation_status = "set_fail"
else:
if os_ins_ip_list:
resource.reservation_status = "configing"
else:
resource.reservation_status = "reserving"
resource.save()
ret = {"code": code, "result": {"res": res}}
return ret, code
def put(cls, deploy_id):
try:
dep = Deployment.objects.get(deploy_id=deploy_id)
except Exception as e:
Log.logger.error("###Deployment error:{}".format(e.args))
code = 500
ret = {
'code': code,
'result': {
'res': 'fail',
'msg': "Deployment find error."
}
}
return ret
if not len(dep):
code = 200
ret = {
'code': code,
'result': {
'res': 'success',
'msg': "Deployment not find."
}
}
return ret
try:
parser = reqparse.RequestParser()
parser.add_argument('result', type=str)
parser.add_argument('ip', type=str)
parser.add_argument('res_type', type=str)
parser.add_argument('msg', type=str)
parser.add_argument('vm_state', type=str)
parser.add_argument('cluster_name', type=str)
parser.add_argument('end_flag', type=bool)
parser.add_argument('deploy_type', type=str)
parser.add_argument('unique_flag', type=str)
parser.add_argument('cloud', type=str)
parser.add_argument('deploy_name', type=str)
parser.add_argument('deploy_name', type=str)
parser.add_argument('o_domain', type=str)
parser.add_argument('o_port', type=str)
parser.add_argument('domain_flag', type=str)
parser.add_argument('war_url', type=str)
args = parser.parse_args()
Log.logger.info("args parser info:{}".format(args))
except Exception as e:
Log.logger.error("###parser error:{}".format(e.args))
return
dep.deploy_result = args.result
ip = args.ip
res_type = args.res_type
msg = args.msg
vm_state = args.vm_state
cluster_name = args.cluster_name
end_flag = args.end_flag
deploy_type = args.deploy_type
unique_flag = args.unique_flag
cloud = args.cloud
deploy_name = args.deploy_name
o_domain = args.o_domain
o_port = args.o_port
domain_flag = args.domain_flag
war_url = args.war_url
resource_id = dep.resource_id
status_record = StatusRecord()
status_record.res_id = resource_id
status_record.deploy_id = deploy_id
status_record.s_type = "%s_%s" % (deploy_type, res_type)
status_record.set_flag = "res"
status_record.created_time = datetime.datetime.now()
resource = ResourceModel.objects.get(res_id=resource_id)
if cloud == "2":
if dep.deploy_result == "success":
dep.deploy_result = "%s_success" % deploy_type
status_record.unique_flag = unique_flag
status_record.msg = "%s %s成功\n" % (mapping_msg_info.get(
res_type,
res_type), deploy_type_dict.get(deploy_type, deploy_type))
else:
dep.deploy_result = "%s_fail" % deploy_type
status_record.unique_flag = unique_flag
status_record.msg = "%s %s失败,错误日志为%s\n" % (
mapping_msg_info.get(res_type, res_type),
deploy_type_dict.get(deploy_type, deploy_type), msg)
status_record.save()
else:
if dep.deploy_result == "success":
if res_type == "docker":
dep.deploy_result = "%s_docker_success" % deploy_type
status_record.status = "%s_docker_success" % deploy_type
status_record.unique_flag = unique_flag
status_record.msg = "%s_docker:%s %s成功，状态为%s，所属集群为%s,%s" % (
deploy_type, ip,
deploy_type_dict.get(deploy_type, deploy_type),
vm_state, cluster_name, msg)
else:
dep.deploy_result = "%s_success" % deploy_type
status_record.unique_flag = unique_flag
status_record.msg = "%s %s成功" % (
mapping_msg_info.get(res_type, res_type),
deploy_type_dict.get(deploy_type, deploy_type))
elif dep.deploy_result == "fail":
if res_type == "docker":
dep.deploy_result = "%s_docker_fail" % deploy_type
status_record.status = "%s_docker_fail" % deploy_type
status_record.unique_flag = unique_flag
status_record.msg = "%s_docker:%s %s失败，状态为%s，所属集群为%s，错误日志为：%s" % (
deploy_type, ip,
deploy_type_dict.get(deploy_type, deploy_type),
vm_state, cluster_name, msg)
else:
status_record.status = "deploy_%s_fail" % res_type
status_record.msg = "deploy_%s:部署失败，错误日志为：%s" % (res_type,
msg)
status_record.unique_flag = unique_flag
status_record.save()
res_status, count = get_deploy_status(deploy_id, deploy_type,
res_type, unique_flag)
if res_status == True and end_flag == True:
dep.deploy_result = "%s_success" % deploy_type
create_status_record(
resource_id, deploy_id, deploy_type,
"%s成功\n" % deploy_type_dict.get(deploy_type, deploy_type),
"%s_success" % deploy_type, "res")
elif res_status == False and end_flag == True:
dep.deploy_result = "%s_fail" % deploy_type
create_status_record(
resource_id, deploy_id, deploy_type,
"%s失败\n" % deploy_type_dict.get(deploy_type, deploy_type),
"%s_fail" % deploy_type, "res")
# 如果回滚成功，修改部署版本
if args.result == "success" and deploy_type == "rollback":
resource.deploy_name = deploy_name
# 如果部署失败修改domain和port
if dep.deploy_result == "deploy_fail" and domain_flag == "True":
compute_list = resource.compute_list
for compute in compute_list:
compute.domain = o_domain
compute.port = o_port
#如果k8s应用部署成功，修改resource和statusvm表
if cloud == "2" and args.result == "success" and res_type in [
"docker", "kvm"
]:
resource_name = dep.resource_name
env = dep.environment
url = get_CRP_url(env)
updata_deployment_info(resource_name, env, url)
if deploy_type == "deploy" and args.result == "success" and war_url:
new_app_image = []
compute_list = resource.compute_list
app_image = eval(dep.app_image)
for app in app_image:
app["git_res_url"] = war_url
new_app_image.append(app)
dep.app_image = str(new_app_image)
for compute in compute_list:
compute.git_res_url = war_url
resource.save()
dep.save()
try:
p_code = ResourceModel.objects.get(res_id=resource_id).cmdb_p_code
# 修改cmdb部署状态信息
CMDB_URL = current_app.config['CMDB_URL']
if CMDB_URL:
deployment_url = CMDB_URL + "cmdb/api/repo/%s/" % p_code
Log.logger.info('deploy status: {}, {}'.format(
dep.deploy_result, p_code))
data = {
'property_list': [{
"type": "string",
"name": "部署状态",
"value": dep.deploy_result
}]
}
req = requests.put(deployment_url, data=json.dumps(data))
except Exception as e:
code = 500
ret = {
'code': code,
'result': {
'res': 'failed',
'msg': "Deployment update failed."
}
}
return ret
code = 200
ret = {
'code': code,
'result': {
'res': 'success',
'msg': "Deployment update success."
}
}
return ret, code
def deploy_to_crp(deploy_item, environment, database_password, appinfo,
disconf_server_info,deploy_type,deploy_name=None,crp_url=None):
resource_id = deploy_item.resource_id
res_obj = ResourceModel.objects.get(res_id=resource_id)
data = {
"deploy_id": deploy_item.deploy_id,
"appinfo": appinfo,
"disconf_server_info": disconf_server_info,
"deploy_type": deploy_type,
"dns": [],
"environment": environment,
"cloud":res_obj.cloud,
"resource_name":res_obj.resource_name,
"project_name": res_obj.project_name,
"resource_id": resource_id,
"deploy_name": deploy_name,
}
compute_list = res_obj.compute_list
if compute_list:
compute = compute_list[0]
namespace = compute.namespace
if namespace:
data["namespace"] = namespace
if appinfo: # 判断nginx信息，没有则不推送dns配置
for compute in compute_list:
dns_info = {'domain': compute.domain,
'domain_ip': compute.domain_ip,
'certificate': compute.certificate,
'named_url': compute.named_url,
}
data['dns'].append(dns_info)
docker_list = []
for compute in compute_list:
try:
url = compute.url
host_env = compute.host_env
deploy_source = compute.deploy_source
if compute.deploy_source == "git" and deploy_type in ["rollback","increase","reduce"]:
url = compute.git_res_url
deploy_source = "war"
docker_list.append(
{
'url': url,
'insname': compute.ins_name,
'ip': compute.ips,
'health_check':compute.health_check,
'host_env':host_env,
'language_env':compute.language_env,
'deploy_source':deploy_source,
'database_config':compute.database_config,
'flavor':str(compute.cpu) + str(compute.mem),
'host_mapping':compute.host_mapping,
'networkName':compute.networkName,
'tenantName':compute.tenantName,
'replicas': compute.quantity,
'ready_probe_path':compute.ready_probe_path,
'port': compute.port,
'pom_path': compute.pom_path,
'branch': compute.branch,
'scheduler_zone': compute.scheduler_zone,
}
)
except AttributeError as e:
Log.logger.error("Deploy to crp get docker info error {e}".format(e=str(e)))
data['docker'] = docker_list
#获取数据库信息
database_info = get_database_info(res_obj,database_password)
Log.logger.debug("#####uop database info {} ----{}".format(database_info,crp_url))
if database_info:
db_type = database_info["database"]
data[db_type] = database_info
err_msg = None
result = None
try:
if crp_url:
_crp_url = crp_url
else:
_crp_url = get_CRP_url(res_obj['env'])
_url = _crp_url + "api/deploy/deploys"
headers = {
'Content-Type': 'application/json',
}
# 上传disconf配置文件
upload_disconf_files_to_crp(disconf_info_list=disconf_server_info,crp_url=_crp_url)
file_paths = []
if deploy_item.mysql_context:
file_paths.append(('mysql', deploy_item.mysql_context))
if deploy_item.redis_context:
file_paths.append(('redis', deploy_item.redis_context))
if deploy_item.mongodb_context:
file_paths.append(('mongodb', deploy_item.mongodb_context))
if file_paths:
res = upload_files_to_crp(file_paths,_crp_url)
cont = json.loads(res.content)
if cont.get('code') == 200:
for type, path_filename in cont['file_info'].items():
if data.get(type):
data[type]['path_filename'] = path_filename
elif cont.get('code') == 500:
return 'upload sql file failed', result
Log.logger.debug("{} {}".format(crp_url, json.dumps(headers)))
data_str = json.dumps(data)
Log.logger.debug("Data args is " + str(data))
Log.logger.debug("Data args is " + str(data_str))
result = requests.post(url=_url, headers=headers, data=data_str)
result = json.dumps(result.json())
except requests.exceptions.ConnectionError as rq:
err_msg = str(rq)
Log.logger.error("deploy to crp error {err_msg}".format(err_msg=err_msg))
except BaseException as e:
err_msg = str(e)
Log.logger.error("deploy to crp error {err_msg}".format(err_msg=err_msg))
return err_msg, result
