def cc_search_topo(request, obj_id, category, biz_cc_id, supplier_account):
"""
@summary: 查询对象拓扑
@param request:
@param biz_cc_id:
@return:
"""
with_internal_module = request.GET.get("with_internal_module", False)
client = get_client_by_user(request.user.username)
kwargs = {"bk_biz_id": biz_cc_id, "bk_supplier_account": supplier_account}
cc_result = client.cc.search_biz_inst_topo(kwargs)
if not cc_result["result"]:
message = handle_api_error("cc", "cc.search_biz_inst_topo", kwargs,
cc_result)
logger.error(message)
result = {"result": False, "data": [], "message": message}
return JsonResponse(result)
if with_internal_module:
inter_result = client.cc.get_biz_internal_module(kwargs)
if not inter_result["result"]:
message = handle_api_error("cc", "cc.get_biz_internal_module",
kwargs, inter_result)
logger.error(message)
result = {"result": False, "data": [], "message": message}
return JsonResponse(result)
cc_result["data"] = insert_inter_result_to_topo_data(
inter_result["data"], cc_result["data"])
if category in ["normal", "prev"]:
cc_topo = cc_format_topo_data(cc_result["data"], obj_id, category)
else:
cc_topo = []
return JsonResponse({"result": True, "data": cc_topo})
def schedule(self, data, parent_data, callback_data=None):
client = get_client_by_user(parent_data.get_one_of_inputs("executor"))
biz_cc_id = parent_data.get_one_of_inputs("biz_cc_id")
get_job_instance_log_kwargs = {
"bk_scope_type": JobBizScopeType.BIZ.value,
"bk_scope_id": str(biz_cc_id),
"bk_biz_id": biz_cc_id,
"job_instance_id": data.outputs.job_inst_id,
}
get_job_instance_log_return = client.job.get_job_instance_log(get_job_instance_log_kwargs)
if not get_job_instance_log_return["result"]:
err_message = handle_api_error(
"JOB", "job.get_job_instance_log", get_job_instance_log_kwargs, get_job_instance_log_return
)
data.set_outputs("ex_data", err_message)
return False
else:
job_status = get_job_instance_log_return["data"][0]["status"]
if job_status == 3:
self.finish_schedule()
return True
elif job_status > 3:
err_message = handle_api_error(
"JOB", "job.get_job_instance_log", get_job_instance_log_kwargs, get_job_instance_log_return
)
data.set_outputs("ex_data", err_message)
return False
def _batch_request(
func, params, get_data=lambda x: x["data"]["list"], get_count=lambda x: x["data"]["count"], limit=500,
):
"""
gsekit 并发请求接口
:param func: 请求方法
:param params: 请求参数
:param get_data: 获取数据函数
:param get_count: 获取总数函数
:param limit: 一次请求数量
:return: 请求结果
"""
# 请求第一次获取总数
result = func(page_param={"page": 1, "pagesize": limit}, **params)
if not result["result"]:
message = handle_api_error("[batch_request]", func.__name__, params, result)
logger.error(message)
raise ApiRequestError(message)
count = get_count(result)
data = []
start = 1
# 根据请求总数并发请求
pool = ThreadPool()
params_and_future_list = []
page_count = int(count / 500) + 1
while start <= page_count:
request_params = {"page_param": {"pagesize": limit, "page": start}}
request_params.update(params)
params_and_future_list.append(
{"params": request_params, "future": pool.apply_async(func, kwds=request_params)}
)
start += 1
pool.close()
pool.join()
# 取值
for params_and_future in params_and_future_list:
result = params_and_future["future"].get()
if not result:
message = handle_api_error("[batch_request]", func.__name__, params, result)
logger.error(message)
raise ApiRequestError(message)
data.extend(get_data(result))
return data
def get_host_id_by_inner_ip(executor, logger, bk_cloud_id: int, bk_biz_id: int,
ip_list: list):
"""
根据inner_ip获取bk_host_id 对应关系dict
"""
client = BKNodeManClient(username=executor)
kwargs = {
"bk_biz_id": [bk_biz_id],
"pagesize":
-1,
"conditions": [{
"key": "inner_ip",
"value": ip_list
}, {
"key": "bk_cloud_id",
"value": [bk_cloud_id]
}],
}
result = client.search_host_plugin(**kwargs)
if not result["result"]:
error = handle_api_error(__group_name__, "nodeman.search_host_plugin",
kwargs, result)
logger.error(error)
return {}
return {
host["inner_ip"]: host["bk_host_id"]
for host in result["data"]["list"]
}
def execute(self, data, parent_data):
method = self.host_lock_method()
executor = parent_data.get_one_of_inputs("executor")
biz_cc_id = parent_data.get_one_of_inputs("biz_cc_id")
client = get_client_by_user(executor)
if parent_data.get_one_of_inputs("language"):
setattr(client, "language",
parent_data.get_one_of_inputs("language"))
translation.activate(parent_data.get_one_of_inputs("language"))
cc_host_ip = data.get_one_of_inputs("cc_host_ip")
id_info = cc_get_ips_info_by_str(executor, biz_cc_id, cc_host_ip)
if id_info["invalid_ip"]:
data.outputs.ex_data = _("无法从配置平台(CMDB)查询到对应 IP，请确认输入的 IP 是否合法")
return False
host_list = [_ip["HostID"] for _ip in id_info["ip_result"]]
cc_host_lock_kwargs = {"id_list": host_list}
cc_host_lock_method = getattr(client.cc, method)
cc_host_lock_result = cc_host_lock_method(cc_host_lock_kwargs)
if cc_host_lock_result["result"]:
return True
message = handle_api_error(__group_name__,
"cc.{method}".format(method=method),
cc_host_lock_kwargs, cc_host_lock_result)
data.set_outputs("ex_data", message)
self.logger.error(message)
return False
def cmdb_get_mainline_object_topo(request, bk_biz_id, bk_supplier_account=""):
"""
@summary: 获取配置平台业务拓扑模型
@param request:
@param bk_biz_id:
@param bk_supplier_account:
@return:
"""
kwargs = {
"bk_biz_id": bk_biz_id,
"bk_supplier_account": bk_supplier_account,
}
client = get_client_by_user(request.user.username)
cc_result = client.cc.get_mainline_object_topo(kwargs)
if not cc_result["result"]:
message = handle_api_error(_("配置平台(CMDB)"), "cc.get_mainline_object_topo", kwargs, cc_result)
if cc_result.get("code", 0) == HTTP_AUTH_FORBIDDEN_CODE:
logger.warning(message)
raise RawAuthFailedException(permissions=cc_result.get("permission", []))
return JsonResponse({"result": cc_result["result"], "code": cc_result["code"], "message": message})
data = cc_result["data"]
for bk_obj in data:
if bk_obj["bk_obj_id"] == "host":
bk_obj["bk_obj_name"] = "IP"
result = {"result": cc_result["result"], "code": cc_result["code"], "data": cc_result["data"]}
return JsonResponse(result)
def cc_search_object_attribute_all(request, obj_id, biz_cc_id,
supplier_account):
"""
@summary: 获取对象全部属性
@param request:
@return:
"""
client = get_client_by_user(request.user.username)
kwargs = {
"bk_obj_id": obj_id,
"bk_supplier_account": supplier_account,
"bk_biz_id": int(biz_cc_id)
}
cc_result = client.cc.search_object_attribute(kwargs)
if not cc_result["result"]:
message = handle_api_error("cc", "cc.search_object_attribute", kwargs,
cc_result)
logger.error(message)
result = {"result": False, "data": [], "message": message}
return JsonResponse(result)
obj_property = []
for item in cc_result["data"]:
obj_property.append({
"value": item["bk_property_id"],
"text": item["bk_property_name"]
})
return JsonResponse({"result": True, "data": obj_property})
def _job_get_scripts_data(request, biz_cc_id=None):
client = get_client_by_user(request.user.username)
source_type = request.GET.get("type")
script_type = request.GET.get("script_type")
if source_type == "public":
kwargs = None
script_result = client.job.get_public_script_list()
api_name = "job.get_public_script_list"
else:
kwargs = {
"bk_scope_type": JobBizScopeType.BIZ.value,
"bk_scope_id": str(biz_cc_id),
"bk_biz_id": biz_cc_id,
"is_public": False,
"script_type": script_type or 0,
}
script_result = client.job.get_script_list(kwargs)
api_name = "job.get_script_list"
if not script_result["result"]:
message = handle_api_error("job", api_name, kwargs, script_result)
logger.error(message)
result = {"result": False, "message": message}
return result
return script_result
def schedule(self, data, parent_data, callback_data=None):
"""
gsekit-轮询服务重启结果
"""
executor = parent_data.get_one_of_inputs("executor")
client = BKGseKitClient(executor)
job_task_id = data.outputs.gsekit_job_task_id
job_task_status = client.job_status(job_task_id=job_task_id)
self.logger.info("gsekit job {id} with status {status}".format(
id=job_task_id, status=job_task_status))
if not job_task_status["result"]:
err_message = handle_api_error("gsekit",
"gsekit.check_job_task_status",
job_task_id, job_task_status)
data.set_outputs("ex_data", err_message)
return False
code = job_task_status["data"]["status"]
if code == JobStatus.SUCCEEDED:
self.finish_schedule()
return True
elif code in (JobStatus.PENDING, JobStatus.RUNNING):
return True
else:
self.logger.error(
"unexpect gsekit job task status code: {}, gsekit response: {}"
.format(code, job_task_status))
data.set_outputs(
"ex_data",
"unexpect gsekit job task status code: {}".format(code))
return False
def nodeman_get_plugin_version(request, plugin, os_type):
"""根据系统获取插件版本"""
client = BKNodeManClient(username=request.user.username)
kwargs = {"name": plugin, "os": os_type.upper()}
plugin_version_list = client.plugin_package(**kwargs)
if not plugin_version_list["result"]:
message = handle_api_error(_("节点管理(NODEMAN)"),
"nodeman.plugin_package", {},
plugin_version_list)
logger.error(message)
return JsonResponse({
"result": plugin_version_list["result"],
"code": plugin_version_list.get("code", "-1"),
"message": message
})
data = plugin_version_list["data"]
result = [{
"text": version["version"],
"value": version["version"]
} for version in data]
plugin_version_list["data"] = result
return JsonResponse(plugin_version_list)
def cc_get_service_category_topo(request, biz_cc_id, supplier_account):
"""
获取指定biz_cc_id模板类型拓扑
:param request:
:param biz_cc_id:
:param supplier_account:
:return:
- 请求成功
{
"result": True,
"message": "success",
"data": [
{
"value": "1-1",
"label": "1-1",
children: [{"value": "2-1", "label": "2-1"},]
},
...
]
}
- 请求失败 {"result": False, "data": [], "message": message}
"""
client = get_client_by_user(request.user.username)
kwargs = {
"bk_biz_id": int(biz_cc_id),
"bk_supplier_account": supplier_account
}
list_service_category_return = client.cc.list_service_category(kwargs)
if not list_service_category_return["result"]:
message = handle_api_error("cc", "cc.list_service_category", kwargs,
list_service_category_return)
logger.error(message)
return JsonResponse({"result": False, "data": [], "message": message})
service_categories = list_service_category_return["data"]["info"]
topo_merged_by_id = {
sc["id"]: {
"value": sc["id"],
"label": sc["name"],
"children": []
}
for sc in service_categories if sc["bk_parent_id"] == 0
}
for sc in service_categories:
if sc["bk_parent_id"] not in topo_merged_by_id:
continue
topo_merged_by_id[sc["bk_parent_id"]]["children"].append({
"value":
sc["id"],
"label":
sc["name"]
})
# 筛选两层结构的拓扑
service_category_topo = [
topo for topo in topo_merged_by_id.values() if topo["children"]
]
return JsonResponse({
"result": True,
"data": service_category_topo,
"message": "success"
})
def cc_search_create_object_attribute(request, obj_id, biz_cc_id,
supplier_account):
client = get_client_by_user(request.user.username)
kwargs = {
"bk_obj_id": obj_id,
"bk_supplier_account": supplier_account,
"bk_biz_id": int(biz_cc_id)
}
cc_result = client.cc.search_object_attribute(kwargs)
if not cc_result["result"]:
message = handle_api_error("cc", "cc.search_object_attribute", kwargs,
cc_result)
logger.error(message)
result = {"result": False, "data": [], "message": message}
return JsonResponse(result)
obj_property = []
for item in cc_result["data"]:
if item["editable"]:
prop_dict = cc_attribute_type_to_table_type(item)
# 集群/模块名称设置为必填项
if item["bk_property_id"] in ["bk_set_name", "bk_module_name"]:
prop_dict["attrs"]["validation"] = [{"type": "required"}]
obj_property.append(prop_dict)
return JsonResponse({"result": True, "data": obj_property})
def get_biz_internal_module(username, bk_biz_id, bk_supplier_account):
"""
@summary: 根据业务ID获取业务空闲机, 故障机和待回收模块
@param bk_biz_id:
@param bk_supplier_account:
@return:
"""
client = get_client_by_user(username)
params = {
"bk_biz_id": bk_biz_id,
"bk_supplier_account": bk_supplier_account
}
get_biz_internal_module_return = client.cc.get_biz_internal_module(params)
if not get_biz_internal_module_return["result"]:
message = handle_api_error("cc", "cc.get_biz_internal_module", params,
get_biz_internal_module_return)
logger.error(message)
raise ApiRequestError(message)
result = []
for get_biz_internal_module_option in get_biz_internal_module_return[
"data"]["module"]:
result.append({
"id": get_biz_internal_module_option["bk_module_id"],
"name": get_biz_internal_module_option["bk_module_name"],
})
return {"result": True, "data": result, "message": "success"}
def jobv3_get_job_plan_detail(request, biz_cc_id, job_plan_id):
"""
根据作业执行方案 ID 查询作业执行方案详情
@param request:
@param biz_cc_id: 业务 ID
@param job_plan_id: 作业执行方案 ID
@return:
"""
client = get_client_by_user(request.user.username)
bk_scope_type = request.GET.get("bk_scope_type", JobBizScopeType.BIZ.value)
kwargs = {
"bk_scope_type": bk_scope_type,
"bk_scope_id": str(biz_cc_id),
"bk_biz_id": biz_cc_id,
"job_plan_id": job_plan_id,
}
jobv3_result = client.jobv3.get_job_plan_detail(kwargs)
if not jobv3_result["result"]:
message = handle_api_error("jobv3", "get_job_plan_detail", kwargs,
jobv3_result)
logger.error(message)
result = {"result": False, "message": message}
return JsonResponse(result)
plan_detail = jobv3_result["data"]
global_var = []
if not plan_detail:
message = _("请求作业平台执行方案详情返回数据为空: {}").format(jobv3_result)
logger.error(message)
return JsonResponse({"result": False, "message": message})
for var in plan_detail.get("global_var_list") or []:
# 1-字符串, 2-命名空间, 3-IP, 4-密码, 5-数组
if var["type"] in JOBV3_VAR_CATEGORY_GLOBAL_VARS:
value = var.get("value", "")
elif var["type"] == JOBV3_VAR_CATEGORY_IP:
value = ",".join([
"{plat_id}:{ip}".format(plat_id=ip_item["bk_cloud_id"],
ip=ip_item["ip"])
for ip_item in var.get("server", {}).get("ip_list") or []
])
else:
message = "unknow type var: {}".format(var)
logger.error(message)
result = {"result": False, "message": message}
return JsonResponse(result)
global_var.append({
"id": var["id"],
"type": var.get("type", 1),
"name": var["name"],
"value": value,
"description": var["description"],
})
return JsonResponse({"result": True, "data": global_var})
def esb_get_systems(request):
client = get_client_by_user(request.user.username)
esb_data = client.esb.get_systems()
if not esb_data['result']:
message = handle_api_error(system='esb',
api_name='get_systems',
params={},
result=esb_data)
return JsonResponse({'result': False, 'message': message})
result = {'result': True, 'data': esb_data['data']}
return JsonResponse(result)
def esb_get_components(request):
client = get_client_by_user(request.user.username)
system_names = json.loads(request.GET.get('system_names', '[]'))
esb_data = client.esb.get_components({'system_names': system_names})
if not esb_data['result']:
message = handle_api_error(system='esb',
api_name='get_components',
params={},
result=esb_data)
return JsonResponse({'result': False, 'message': message})
result = {'result': True, 'data': esb_data['data']}
return JsonResponse(result)
def get_nodeman_rsa_public_key(executor, logger):
"""
拉取节点管理rsa公钥
"""
client = BKNodeManClient(username=executor)
get_rsa_result = client.get_rsa_public_key(executor)
if not get_rsa_result["result"]:
error = handle_api_error(__group_name__, "nodeman.get_rsa_public_key",
executor, get_rsa_result)
logger.error(error)
return False, None
content = get_rsa_result["data"][0]["content"]
name = get_rsa_result["data"][0]["name"]
return True, {"name": name, "content": content}
def cc_find_host_by_topo(request, biz_cc_id):
"""
批量查询拓扑节点下的主机数量
@param request:
@param biz_cc_id: cc id
@return:
"""
# 模块ID列表，以 , 分割，例如 123,234,345
bk_inst_id = request.GET.get("bk_inst_id", "")
client = get_client_by_user(request.user.username)
# 去除split后的空字符串
bk_inst_id = filter(lambda x: x, bk_inst_id.split(","))
params_list = [{
"bk_biz_id": int(biz_cc_id),
"bk_inst_id": int(inst_id),
"bk_obj_id": "module",
"fields": ["bk_host_id"],
"page": {
"start": 0,
"limit": 1
},
} for inst_id in bk_inst_id]
result_list = batch_execute_func(client.cc.find_host_by_topo, params_list)
data = []
failed_request_message = []
for result in result_list:
func_result = result["result"]
if not func_result["result"]:
message = handle_api_error("cc", "find_host_by_topo",
result["params"], func_result)
failed_request_message.append(message)
else:
data.append({
"bk_inst_id": result["params"]["bk_inst_id"],
"host_count": func_result["data"]["count"]
})
if failed_request_message:
return JsonResponse({
"result": False,
"data": [],
"message": "\n".join(failed_request_message)
})
return JsonResponse({"result": True, "data": data})
def get_set_property(operator):
"""
@summary: 获取集群所有的属性
@return:
"""
client = get_client_by_user(operator)
kwargs = {"bk_obj_id": "set"}
cc_result = client.cc.search_object_attribute(**kwargs)
if not cc_result["result"]:
message = handle_api_error("cc", "search_object_attribute", kwargs,
cc_result)
logger.error(message)
raise ApiRequestError(message)
obj_property = ["bk_set_id"]
for item in cc_result["data"]:
obj_property.append(item["bk_property_id"])
return obj_property
def execute(self, data, parent_data):
executor = parent_data.get_one_of_inputs("executor")
biz_cc_id = data.get_one_of_inputs("biz_cc_id",
parent_data.inputs.biz_cc_id)
gsekit_bk_env = data.get_one_of_inputs("gsekit_bk_env")
gsekit_job_object_choices = data.get_one_of_inputs(
"gsekit_job_object_choices")
gsekit_job_action_choices = data.get_one_of_inputs(
"gsekit_job_action_choices")
gsekit_set = data.get_one_of_inputs("gsekit_set")
gsekit_module = data.get_one_of_inputs("gsekit_module")
gsekit_service_id = data.get_one_of_inputs("gsekit_service_id")
gsekit_process_name = data.get_one_of_inputs("gsekit_process_name")
gsekit_process_id = data.get_one_of_inputs("gsekit_process_id")
scope_param = {
"bk_set_env": gsekit_bk_env,
"bk_set_ids": [gsekit_set],
"bk_module_ids": [gsekit_module],
"bk_service_ids": [gsekit_service_id], # 服务实例id 列表
"bk_process_names": [gsekit_process_name],
"bk_process_ids": [gsekit_process_id],
}
client = BKGseKitClient(executor)
job_result = client.create_job(
bk_biz_id=biz_cc_id,
job_object=gsekit_job_object_choices,
job_action=gsekit_job_action_choices,
scope=scope_param,
)
self.logger.info(
"start gsekit job task with param {0}".format(scope_param))
if job_result["result"]:
job_id = job_result["data"]["job_id"]
data.set_outputs("gsekit_job_task_id", job_id)
return True
else:
self.logger.error(
"unexpect gsekit job task: {}, gsekit response: {}".format(
scope_param, job_result))
err_message = handle_api_error("gsekit", "gsekit.", scope_param,
job_result)
data.set_outputs("ex_data", err_message)
return False
def cc_search_status_options(request, biz_cc_id):
client = get_client_by_user(request.user.username)
kwargs = {
"bk_biz_id": int(biz_cc_id),
"bk_obj_id": "set",
}
result = client.cc.search_object_attribute(kwargs)
options = []
for data in result["data"]:
if data["bk_property_id"] == "bk_service_status":
for option in data["option"]:
options.append({"text": option["name"], "value": option["id"]})
if not options:
message = handle_api_error("cc", "cc.search_object_attribute", kwargs,
result)
logger.error(message)
result = {"result": False, "data": [], "message": message}
return JsonResponse(result)
return JsonResponse({"result": True, "data": options})
def nodeman_get_ap_list(request):
client = BKNodeManClient(username=request.user.username)
ap_list = client.ap_list()
if not ap_list["result"]:
message = handle_api_error(_("节点管理(NODEMAN)"), "nodeman.ap_list", {},
ap_list)
logger.error(message)
return JsonResponse({
"result": ap_list["result"],
"code": ap_list.get("code", "-1"),
"message": message
})
data = ap_list["data"]
result = [{"text": ap["name"], "value": ap["id"]} for ap in data]
ap_list["data"] = result
return JsonResponse(ap_list)
def execute(self, data, parent_data):
executor = parent_data.get_one_of_inputs("executor")
client = BKItsmClient(username=executor)
verifier = data.get_one_of_inputs("bk_verifier")
title = data.get_one_of_inputs("bk_approve_title")
approve_content = data.get_one_of_inputs("bk_approve_content")
kwargs = {
"creator":
executor,
"fields": [
{
"key": "title",
"value": title
},
{
"key": "APPROVER",
"value": verifier.replace(" ", "")
},
{
"key": "APPROVAL_CONTENT",
"value": approve_content
},
],
"fast_approval":
True,
"meta": {
"callback_url":
get_node_callback_url(self.root_pipeline_id, self.id,
getattr(self, "version", ""))
},
}
result = client.create_ticket(**kwargs)
if not result["result"]:
message = handle_api_error(__group_name__, "itsm.create_ticket",
kwargs, result)
self.logger.error(message)
data.outputs.ex_data = message
return False
data.outputs.sn = result["data"]["sn"]
return True
def get_service_template_list(username, bk_biz_id, bk_supplier_account):
"""
@summary: 批量获取服务模板列表
@param username: 执行接口用户名
@param bk_biz_id: 业务id
@param bk_supplier_account:
@return: [{'id':'', 'name':''}, {'id':'', 'name':''}]
"""
client = get_client_by_user(username)
kwargs = {
"bk_biz_id": int(bk_biz_id),
"bk_supplier_account": bk_supplier_account
}
list_service_template_return = client.cc.list_service_template(kwargs)
if not list_service_template_return["result"]:
message = handle_api_error("cc", "cc.list_service_template", kwargs,
list_service_template_return)
logger.error(message)
raise ApiRequestError(message)
return list_service_template_return["data"]["info"]
def cc_list_service_category(request, biz_cc_id, bk_parent_id,
supplier_account):
"""
查询指定节点bk_parent_id的所有子服务分类
url: /pipeline/cc_list_service_category/biz_cc_id/bk_parent_id/
:param request:
:param biz_cc_id:
:param bk_parent_id: 父服务分类id, 根id = 0
:param supplier_account:
:return:
- 请求成功 {"result": True, "data": service_categories, "message": "success"}
- service_categories: [{"value" : 服务分类id, "label": 服务分类名称}, ...]
- 请求失败 {"result": False, "data": [], "message": message}
"""
client = get_client_by_user(request.user.username)
kwargs = {
"bk_biz_id": int(biz_cc_id),
"bk_supplier_account": supplier_account
}
list_service_category_return = client.cc.list_service_category(kwargs)
if not list_service_category_return["result"]:
message = handle_api_error("cc", "cc.list_service_category", kwargs,
list_service_category_return)
logger.error(message)
return JsonResponse({"result": False, "data": [], "message": message})
service_categories_untreated = list_service_category_return["data"]["info"]
service_categories = []
for category_untreated in service_categories_untreated:
if category_untreated["bk_parent_id"] != int(bk_parent_id):
continue
category = {
"value": category_untreated["id"],
"label": category_untreated["name"]
}
service_categories.append(category)
return JsonResponse({
"result": True,
"data": service_categories,
"message": "success"
})
def get_module_list(username, bk_biz_id, kwargs=None):
"""
@summary: 查询模块
@param kwargs:
@param username: 执行用户名
@param bk_biz_id: 业务id
@return: [{'bk_module_id':'', 'bk_module_name':''}...]
"""
client = get_client_by_user(username)
params = {
"bk_biz_id": bk_biz_id,
}
if kwargs:
params.update(kwargs)
module_list_result = client.cc.find_module_batch(params)
if not module_list_result["result"]:
message = handle_api_error("cc", "cc.find_module_batch", kwargs,
module_list_result)
logger.error(message)
raise ApiRequestError(message)
return module_list_result["data"]
def nodeman_get_plugin_list(request, category):
"""获取插件列表"""
client = BKNodeManClient(username=request.user.username)
plugin_list = client.plugin_process(category)
if not plugin_list["result"]:
message = handle_api_error(_("节点管理(NODEMAN)"),
"nodeman.plugin_process", {}, plugin_list)
logger.error(message)
return JsonResponse({
"result": plugin_list["result"],
"code": plugin_list.get("code", "-1"),
"message": message
})
data = plugin_list["data"]
result = [{"text": ap["name"], "value": ap["name"]} for ap in data]
plugin_list["data"] = result
return JsonResponse(plugin_list)
def get_job_tagged_ip_dict(client,
service_logger,
job_instance_id,
bk_biz_id,
job_scope_type=JobBizScopeType.BIZ.value):
"""根据job步骤执行标签获取 IP 分组"""
kwargs = {
"bk_scope_type": job_scope_type,
"bk_scope_id": str(bk_biz_id),
"bk_biz_id": bk_biz_id,
"job_instance_id": job_instance_id,
"return_ip_result": True,
}
result = client.jobv3.get_job_instance_status(kwargs)
if not result["result"]:
message = handle_api_error(
__group_name__,
"jobv3.get_job_instance_status",
kwargs,
result,
)
service_logger.warning(message)
return False, message
step_instance = result["data"]["step_instance_list"][-1]
step_ip_result_list = step_instance["step_ip_result_list"]
tagged_ip_dict = {}
for step_ip_result in step_ip_result_list:
tag_key = step_ip_result["tag"]
if not tag_key:
continue
if tag_key in tagged_ip_dict:
tagged_ip_dict[tag_key] += f",{step_ip_result['ip']}"
else:
tagged_ip_dict[tag_key] = step_ip_result["ip"]
return True, tagged_ip_dict
def nodeman_get_cloud_area(request):
client = BKNodeManClient(username=request.user.username)
cloud_area_result = client.cloud_list()
if not cloud_area_result["result"]:
message = handle_api_error(_("节点管理(NODEMAN)"), "nodeman.cloud_list",
{}, cloud_area_result)
logger.error(message)
return JsonResponse({
"result": cloud_area_result["result"],
"code": cloud_area_result.get("code", "-1"),
"message": message
})
data = cloud_area_result["data"]
result = [{
"text": cloud["bk_cloud_name"],
"value": cloud["bk_cloud_id"]
} for cloud in data]
cloud_area_result["data"] = result
return JsonResponse(cloud_area_result)
def cc_list_service_template(request, biz_cc_id, supplier_account):
"""
获取服务模板
url: /pipeline/cc_list_service_template/biz_cc_id/
:param request:
:param biz_cc_id:
:param supplier_account:
:return:
- 请求成功 {"result": True, "data": service_templates, "message": "success"}
- service_templates： [{"value" : 模板名_模板id, "text": 模板名}, ...]
- 请求失败 {"result": False, "data": [], "message": message}
"""
client = get_client_by_user(request.user.username)
kwargs = {
"bk_biz_id": int(biz_cc_id),
"bk_supplier_account": supplier_account
}
list_service_template_return = client.cc.list_service_template(kwargs)
if not list_service_template_return["result"]:
message = handle_api_error("cc", "cc.list_service_template", kwargs,
list_service_template_return)
logger.error(message)
return JsonResponse({"result": False, "data": [], "message": message})
service_templates = []
service_templates_untreated = list_service_template_return["data"]["info"]
for template_untreated in service_templates_untreated:
template = {
"value":
"{name}_{id}".format(name=template_untreated["name"],
id=template_untreated["id"]),
"text":
template_untreated["name"],
}
service_templates.append(template)
return JsonResponse({
"result": True,
"data": service_templates,
"message": "success"
})
