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" })