def delete_mesos_hpa(request, project_id, cluster_id, namespace, namespace_id, name): username = request.user.username access_token = request.user.token.access_token client = mesos.MesosClient(access_token, project_id, cluster_id, env=None) result = client.delete_hpa(namespace, name) if result.get('code') != 0: raise DeleteHPAError(_('删除HPA资源失败')) # 删除成功则更新状态 InstanceConfig.objects.filter(namespace=namespace_id, category=MesosResourceName.hpa.value, name=name).update( updator=username, oper_type=DELETE_INSTANCE, deleted_time=timezone.now(), is_deleted=True, is_bcs_success=True)
def mesos_containers(request, project_id, cluster_id, host_ips): """mesos taskgroup容器信息 """ client = mesos.MesosClient(request.user.token.access_token, project_id, cluster_id, None) rsp = client.get_taskgroup( host_ips, fields="data.containerStatuses.containerID,data.hostIP", ) if rsp.get("code") != ErrorCode.NoError: return {} containers = {} for info in rsp['data']: containers.setdefault(info.get("data", {}).get('hostIP'), 0) containers[info["data"]['hostIP']] += len( info["data"]["containerStatuses"]) return containers
def get_services_by_cluster_id(self, request, params, project_id, cluster_id, project_kind=MESOS_VALUE): """查询services """ access_token = request.user.token.access_token if project_kind == MESOS_VALUE: client = mesos.MesosClient( access_token, project_id, cluster_id, env=None) resp = client.get_services(params) else: client = k8s.K8SClient( access_token, project_id, cluster_id, env=None) resp = client.get_service(params) if resp.get("code") != ErrorCode.NoError: logger.error(u"bcs_api error: %s" % resp.get("message", "")) return resp.get("code", DEFAULT_ERROR_CODE), resp.get("message", _("请求出现异常!")) return ErrorCode.NoError, resp.get("data", [])
def delete_single_service(self, request, project_id, project_kind, cluster_id, namespace, namespace_id, name): username = request.user.username access_token = request.user.token.access_token if project_kind == MESOS_VALUE: client = mesos.MesosClient( access_token, project_id, cluster_id, env=None) resp = client.delete_service(namespace, name) s_cate = 'service' else: if namespace in K8S_SYS_NAMESPACE: return { "code": 400, "message": _("不允许操作系统命名空间[{}]").format(','.join(K8S_SYS_NAMESPACE)), } client = k8s.K8SClient( access_token, project_id, cluster_id, env=None) resp = client.delete_service(namespace, name) s_cate = 'K8sService' delete_svc_extended_routes(request, project_id, cluster_id, namespace, name) if resp.get("code") == ErrorCode.NoError: # 删除成功则更新状态 now_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') InstanceConfig.objects.filter( namespace=namespace_id, category=s_cate, name=name, ).update( creator=username, updator=username, oper_type=DELETE_INSTANCE, updated=now_time, deleted_time=now_time, is_deleted=True, is_bcs_success=True ) return { "code": resp.get("code"), "message": resp.get("message"), }
def delete_single_resource(self, request, project_id, project_kind, cluster_id, namespace, namespace_id, name): username = request.user.username access_token = request.user.token.access_token if project_kind == 2: client = mesos.MesosClient( access_token, project_id, cluster_id, env=None) curr_func = getattr(client, "delete_%s" % self.category) resp = curr_func(namespace, name) s_cate = self.mesos_cate else: if namespace in constants.K8S_SYS_NAMESPACE: return { "code": 400, "message": u"不允许操作系统命名空间[%s]" % ','.join(constants.K8S_SYS_NAMESPACE), } client = k8s.K8SClient( access_token, project_id, cluster_id, env=None) curr_func = getattr(client, "delete_%s" % self.category) resp = curr_func(namespace, name) s_cate = self.k8s_cate if resp.get("code") == ErrorCode.NoError: # 删除成功则更新状态 now_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') InstanceConfig.objects.filter( namespace=namespace_id, category=s_cate, name=name, ).update( creator=username, updator=username, oper_type=DELETE_INSTANCE, updated=now_time, deleted_time=now_time, is_deleted=True, is_bcs_success=True ) return { "code": resp.get("code"), "message": resp.get("message"), }
def list(self, request, project_id, cluster_id): """获取targets列表""" access_token = request.user.token.access_token if request.project.kind == ProjectKind.MESOS.value: client = mesos.MesosClient(access_token, project_id, cluster_id, env=None) resp = client.get_services({"env": "mesos"}) else: client = k8s.K8SClient(access_token, project_id, cluster_id, env=None) resp = client.get_service({"env": "k8s"}) data = self._filter_service(resp.get("data") or []) return Response(data)
def create_instance(access_token, cluster_id, ns, data, project_id=None, category="application", kind=2): """创建实例 """ if kind == 2: mesos_client = mesos.MesosClient( access_token, project_id, cluster_id, None ) if category == "application": resp = mesos_client.create_application(ns, data) else: resp = mesos_client.create_deployment(ns, data) else: client = k8s.K8SClient( access_token, project_id, cluster_id, None ) curr_func = getattr(client, FUNC_MAP[category] % "create") resp = curr_func(ns, data) resp = DEFAULT_RESPONSE return resp
def get_cluster_hpa_list(request, project_id, cluster_id, cluster_env, cluster_name, namespace=None): """获取基础hpa列表 """ access_token = request.user.token.access_token project_code = request.project.english_name hpa_list = [] try: if request.project.kind == ProjectKind.MESOS.value: client = mesos.MesosClient(access_token, project_id, cluster_id, env=cluster_env) hpa = client.list_hpa(namespace).get("data") or [] hpa_list = slz_mesos_hpa_info(hpa, project_code, cluster_name, cluster_env, cluster_id) else: client = k8s.K8SClient(access_token, project_id, cluster_id, env=cluster_env) hpa = client.list_hpa(namespace).get("items") or [] hpa_list = slz_k8s_hpa_info(hpa, project_code, cluster_name, cluster_env, cluster_id) except Exception as error: logger.error("get hpa list error, %s", error) return hpa_list
def update(self, request, project_id, cluster_id, namespace, name): namespace_id = self.get_namespace_id(request, project_id, cluster_id, namespace, name) # 校验查看权限 self.can_use(request, project_id, cluster_id, namespace_id) config = request.data['config'] # 下发配置 with log_client.ContextActivityLogClient( project_id=project_id, user=request.user.username, resource_type='ingress', resource=name, description=_("集群:{}, 更新mesos ingress:{}").format(cluster_id, name), ).log_modify(): client = mesos.MesosClient(request.user.token.access_token, project_id, cluster_id, env=None) client.update_custom_resource(name, namespace, config) # 集群,命名空间,ingress确定唯一 InstanceConfig.objects.filter(namespace=namespace_id, category='ingress', name=name, is_deleted=False).update( updator=request.user.username, updated=timezone.now(), is_bcs_success=True, config=config ) return response.Response()
def get_mesos_application_deploy_status( access_token, cluster_id, instance_name, project_id=None, category="application", field=None, namespace=None): """查询mesos下application和deployment的状态 """ mesos_client = mesos.MesosClient( access_token, project_id, cluster_id, None ) if category == "application": resp = mesos_client.get_mesos_app_instances( app_name=instance_name, field=field or "data.status", namespace=namespace, ) else: resp = mesos_client.get_deployment( name=instance_name, field=field or "data.status", namespace=namespace, ) return resp
def query_mesos_node_labels(access_token, project_id, cluster_nodes): # 需要支持跨集群操作 # cluster_nodes格式: {"cluster-id1": ["ip1", "ip2"], "cluster-id2": ["ip3", "ip4"]] node_labels = {cluster_id: {} for cluster_id in cluster_nodes} for cluster_id, node_ips in cluster_nodes.items(): client = mesos.MesosClient(access_token, project_id, cluster_id, None) # 现阶段查询标签仅接口仅支持get请求,而get请求有长度限制,因此,先查询集群下的所有节点的属性,然后通过inner_ip进行匹配 data = client.get_agent_attrs() ip_labels_map = { node["innerIP"]: [{ key: val["value"] } for key, val in (node.get("strings") or {}).items()] for node in data } for ip in node_ips: node_labels[cluster_id][ip] = ip_labels_map.get(ip) or [] # 当过滤的IP为空时,返回整个集群的节点标签 if not node_ips: node_labels[cluster_id] = ip_labels_map return node_labels
def get_deployments(access_token, project_id, project_kind, cluster_id, name=None): """查询deployment, 包含状态及对应的message""" if project_kind == ProjectKind.MESOS.value: namespace = MESOS_CLB_NAMESPACE client = mesos.MesosClient(access_token, project_id, cluster_id, None) resp = client.get_deployment_with_post( name=name, namespace=namespace, field='data.metadata.name,data.status,data.message' ) if resp.get('code') != ErrorCode.NoError: return {} # raise error_codes.APIError(f'get deployment status error, {resp.get("message")}') data = resp.get('data') or [] deployment_dict = {} for info in data: info_data = info.get('data') or {} metadata = info_data.get('metadata') or {} deployment_dict[(cluster_id, metadata.get('name'))] = { 'clb_status': info_data.get('status'), 'clb_message': info_data.get('message'), } return deployment_dict else: pass
def delete(self, request, project_id, cluster_id, namespace, name): namespace_id = self.get_namespace_id(request, project_id, cluster_id, namespace, name) # 校验查看权限 self.can_use(request, project_id, cluster_id, namespace_id) with log_client.ContextActivityLogClient( project_id=project_id, user=request.user.username, resource_type='ingress', resource=name, description=_("集群:{}, 删除mesos ingress:{}").format(cluster_id, name), ).log_delete(): client = mesos.MesosClient(request.user.token.access_token, project_id, cluster_id, env=None) client.delete_custom_resource(name, namespace) # 删除成功则更新记录 now_time = timezone.now() InstanceConfig.objects.filter(namespace=namespace_id, category='ingress', name=name).update( updator=request.user.username, updated=now_time, deleted_time=now_time, is_deleted=True, is_bcs_success=True, ) return response.Response()
def get_service_info(self, request, project_id, cluster_id, namespace, name): # noqa """获取单个 service 的信息""" project_kind = request.project.kind access_token = request.user.token.access_token params = { "env": "mesos" if project_kind == MESOS_VALUE else "k8s", "namespace": namespace, "name": name, } if project_kind == MESOS_VALUE: client = mesos.MesosClient(access_token, project_id, cluster_id, env=None) resp = client.get_services(params) # 跳转到模板集页面需要的参数 template_cate = 'mesos' relate_app_cate = 'application' else: client = k8s.K8SClient(access_token, project_id, cluster_id, env=None) resp = client.get_service(params) template_cate = 'k8s' relate_app_cate = 'deployment' if resp.get("code") != ErrorCode.NoError: raise ComponentError(resp.get("message")) resp_data = resp.get("data", []) if not resp_data: return APIResponse({ "code": 400, "message": _("查询不到 Service[{}] 的信息").format(name) }) s_data = resp_data[0].get('data', {}) labels = s_data.get('metadata', {}).get('labels') or {} # 获取命名空间的id namespace_id = app_utils.get_namespace_id(access_token, project_id, (cluster_id, namespace), cluster_id=cluster_id) instance_id = labels.get(LABLE_INSTANCE_ID) # 是否关联LB lb_balance = labels.get('BCSBALANCE') if lb_balance: s_data['isLinkLoadBalance'] = True s_data['metadata']['lb_labels'] = {'BCSBALANCE': lb_balance} else: s_data['isLinkLoadBalance'] = False lb_name = labels.get('BCSGROUP') # 获取模板集信息 template_id = labels.get(LABLE_TEMPLATE_ID) try: lasetest_ver = ShowVersion.objects.filter( template_id=template_id).order_by('-updated').first() show_version_name = lasetest_ver.name version_id = lasetest_ver.real_version_id version_entity = VersionedEntity.objects.get(id=version_id) except Exception: return APIResponse({ "code": 400, "message": _("模板集[id:{}]没有可用的版本,无法更新service").format(template_id) }) entity = version_entity.get_entity() # 获取更新人和创建人 annotations = s_data.get('metadata', {}).get('annotations', {}) creator = annotations.get(ANNOTATIONS_CREATOR, '') updator = annotations.get(ANNOTATIONS_UPDATOR, '') create_time = annotations.get(ANNOTATIONS_CREATE_TIME, '') update_time = annotations.get(ANNOTATIONS_UPDATE_TIME, '') # k8s 更新需要获取版本号 resource_version = s_data.get('metadata', {}).get('resourceVersion') or '' web_cache = annotations.get(ANNOTATIONS_WEB_CACHE) if not web_cache: # 备注中无,则从模板中获取,兼容mesos之前实例化过的模板数据 _services = entity.get('service') if entity else None _services_id_list = _services.split(',') if _services else [] _s = Service.objects.filter(id__in=_services_id_list, name=name).first() try: web_cache = _s.get_config.get('webCache') except Exception: pass else: try: web_cache = json.loads(web_cache) except Exception: pass s_data['webCache'] = web_cache deploy_tag_list = web_cache.get('deploy_tag_list') or [] app_weight = {} if project_kind == MESOS_VALUE: # 处理 mesos 中Service的关联数据 apps = entity.get('application') if entity else None application_id_list = apps.split(',') if apps else [] apps = Application.objects.filter(id__in=application_id_list) if apps: # 关联应用的权重 for key in labels: if key.startswith('BCS-WEIGHT-'): app_name = key[11:] _app = apps.filter(name=app_name).first() if _app: weight = int(labels[key]) app_weight[_app.app_id] = weight else: # 处理 k8s 中Service的关联数据 if not deploy_tag_list: _servs = entity.get('K8sService') if entity else None _serv_id_list = _servs.split(',') if _servs else [] _k8s_s = K8sService.objects.filter(id__in=_serv_id_list, name=name).first() if _k8s_s: deploy_tag_list = _k8s_s.get_deploy_tag_list() # 标签 和 备注 去除后台自动添加的 or_annotations = s_data.get('metadata', {}).get('annotations', {}) or_labels = s_data.get('metadata', {}).get('labels', {}) if or_labels: pub_keys = PUBLIC_LABELS.keys() show_labels = { key: or_labels[key] for key in or_labels if key not in pub_keys } s_data['metadata']['labels'] = show_labels if or_annotations: pub_an_keys = PUBLIC_ANNOTATIONS.keys() show_annotations = { key: or_annotations[key] for key in or_annotations if key not in pub_an_keys } remove_key(show_annotations, ANNOTATIONS_WEB_CACHE) s_data['metadata']['annotations'] = show_annotations return APIResponse({ "data": { 'service': [{ 'name': name, 'app_id': app_weight.keys(), 'app_weight': app_weight, 'deploy_tag_list': deploy_tag_list, 'config': s_data, 'version': version_id, 'lb_name': lb_name, 'instance_id': instance_id, 'namespace_id': namespace_id, 'cluster_id': cluster_id, 'namespace': namespace, 'creator': creator, 'updator': updator, 'create_time': create_time, 'update_time': update_time, 'show_version_name': show_version_name, 'resource_version': resource_version, 'template_id': template_id, 'template_cate': template_cate, 'relate_app_cate': relate_app_cate, }] } })
def handle_lb(username, access_token, project_id, lb_info, cc_app_id): """ 1. 组装 lb 配置文件 2. 调用 bcs api 创建 Deployment """ cluster_id = lb_info.get('cluster_id') # 查询zk的信息 zk_res = paas_cc.get_zk_config(access_token, project_id, cluster_id) if zk_res.get("code") != ErrorCode.NoError: logger.err('获取zk信息出错,%s' % zk_res) raise error_codes.APIError(_("获取zk信息出错")) try: zk_data = zk_res.get("data", [])[0] except Exception: logger.err('获取zk信息出错,%s' % zk_res) raise error_codes.APIError(_("获取zk信息出错")) bcs_zookeeper = zk_data.get('bcs_zookeeper') zookeeper = zk_data.get('zookeeper') # 查询仓库地址 jfrog_domain = paas_cc.get_jfrog_domain(access_token, project_id, cluster_id) if not jfrog_domain: jfrog_domain = DEFAUT_LB_JFROG_DOMAIN # 调度约束 try: intersection_item = json.loads(lb_info.get("data")) except Exception: logger.exception("命名空间中的调度约束信息出错") raise error_codes.JsonFormatError(_("命名空间中的调度约束信息出错")) new_intersection_item = handle_intersection_item(intersection_item) constraint = {"IntersectionItem": new_intersection_item} # vip 组装为labels try: ip_list = json.loads(lb_info.get('ip_list')) except Exception: logger.exception("命名空间中的IP集信息出错") raise error_codes.JsonFormatError(_("命名空间中的IP集信息出错")) labels = {} for i, ip in enumerate(ip_list): _key = "io.tencent.bcs.netsvc.requestip.%s" % i labels[_key] = ip lb_name = lb_info.get('name') # 配置文件中的变量赋值 now_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') # 获取 namespace data_dict = lb_info['data_dict'] if data_dict: data_dict = json.loads(data_dict) else: data_dict = {} if data_dict.get('image_url'): lb_jfrog_url = f'{jfrog_domain}{data_dict["image_url"]}' else: lb_jfrog_url = f'{jfrog_domain}/paas/public/mesos/bcs-loadbalance' resource_limit = data_dict.get('resources', {}).get('limits', {}) ns_name = get_namespace_name(access_token, project_id, data_dict) # 获取data标准日志输出 data_info = get_data_id_by_project_id(project_id) data_id = str(data_info.get('standard_data_id')) context = { 'SYS_PROJECT_KIND': 2, # 固定为mesos 'SYS_STANDARD_DATA_ID': data_id, 'SYS_CC_APP_ID': cc_app_id, 'SYS_PROJECT_ID': project_id, 'SYS_OPERATOR': username, 'SYS_CLUSTER_ID': cluster_id, 'SYS_BCSGROUP': lb_name, 'SYS_CC_ZK': zookeeper, 'SYS_BCS_ZK': bcs_zookeeper, 'SYS_CREATOR': username, 'SYS_UPDATOR': username, 'SYS_CREATE_TIME': now_time, 'SYS_UPDATE_TIME': now_time, 'SYS_JFROG_DOMAIN_URL': lb_jfrog_url, 'CPU': str(resource_limit.get('cpu', 1)), 'MEMORY': str(resource_limit.get('memory', 1024)), 'IMAGE_VERSION': data_dict.get('image_version') or '1.1.0', 'FORWARD_MODE': data_dict.get('forward_mode') or 'haproxy', 'SYS_NAMESPACE': ns_name, 'ETH_VALUE': data_dict.get('eth_value') or 'eth1', 'LB_ADMIN_PORT': DEFAULT_LB_ADMIN_PORT } # 组装 lb 配置文件 lb_config = copy.deepcopy(LB_SYS_CONFIG) lb_config['spec']['instance'] = data_dict.get('instance', 1) lb_config['constraint'] = constraint lb_config['spec']['template']['metadata']['labels'] = labels lb_config['spec']['template']['spec']['containers'][0]['ports'][0]['hostPort'] = \ data_dict.get('host_port') or 31000 # 处理网络模式 spec = lb_config.get('spec', {}).get('template', {}).get('spec', {}) spec['networkMode'] = data_dict.get('networkMode') spec['networkType'] = data_dict.get('networkType') spec['custom_value'] = data_dict.get('custom_value') lb_config = handel_custom_network_mode(lb_config) lb_config = json.dumps(lb_config) try: config_profile = render_mako_context(lb_config, context) except Exception: logger.exception(u"LoadBalance配置文件变量替换错误\nconfig:%s\ncontext:%s" % (lb_config, context)) raise ValidationError(_("配置文件中有未替换的变量")) config_profile = json.loads(config_profile) # 调用bcs api 创建 client = mesos.MesosClient(access_token, project_id, cluster_id, env=None) result = client.create_deployment(ns_name, config_profile) if not result.get('result'): error_msg = result.get('message', '') logger.error(f"命名空间[{ns_name}]下创建LoadBalance[{lb_name}]出错:{error_msg}") return False, error_msg return True, ''
def get_lb_status(access_token, project_id, lb_name, cluster_id, ns_name, field=None, lb_id=None): client = mesos.MesosClient(access_token, project_id, cluster_id, env=None) resp = client.get_deployment(name=lb_name, field=field or "data", namespace=ns_name) if resp.get("code") != ErrorCode.NoError: status_dict = { 'deployment_status': '', 'deployment_status_message': resp.get("message") } return False, status_dict try: resp_datas = resp.get("data", [])[0].get('data', {}) except Exception: status_dict = { 'deployment_status': "", 'deployment_status_message': '{}[{}]{}'.format(_("查询不到deployment"), lb_name, _("的状态")) } return False, status_dict status_dict = { 'deployment_status': resp_datas.get('status'), 'deployment_status_message': resp_datas.get('message') } if resp_datas.get('application_ext'): app_name = resp_datas.get('application_ext').get('name') else: app_name = resp_datas.get('application').get('name') # 需要 deployment 需要查询 Application 的状态 resp = client.get_mesos_app_instances(app_name=app_name, field=field or "data", namespace=ns_name) if resp.get("code") != ErrorCode.NoError: status_dict['application_status'] = '' status_dict['application_status_message'] = resp.get("message") return False, status_dict resp_data = resp.get("data", []) if not resp_data: logger.error("查询不到loadbalance[%s]的状态:%s" % (lb_name, resp_data)) status_dict['application_status'] = '' status_dict[ 'application_status_message'] = '{}application[{}]{}'.format( _("查询不到"), app_name, _("的状态")) return False, status_dict status = resp_data[0].get('data', {}).get('status') status_dict['application_status'] = status status_dict['application_status_message'] = resp_data[0].get( 'data', {}).get('message') if status in UNNORMAL_STATUS: logger.error(f"loadbalance[{lb_name}]的状态不正常:{resp_data}") return False, status_dict return True, status_dict
def get_cluster_ingresses(access_token, project_id, cluster_id): client = mesos.MesosClient(access_token, project_id, cluster_id, env=None) result = client.get_custom_resource_by_cluster() return result['items']
def _get_client(self, request, project_id, cluster_id): if request.project.kind == ProjectKind.MESOS.value: client = mesos.MesosClient(request.user.token.access_token, project_id, cluster_id, env=None) else: client = k8s.K8SClient(request.user.token.access_token, project_id, cluster_id, env=None) return client
def mesos_configmaps(self, access_token, project_id, cluster_id, fields): client = mesos.MesosClient(access_token, project_id, cluster_id, env=None) return client.get_configmaps(fields)
def delete_mesos_deployment(access_token, project_id, cluster_id, namespace, name): client = mesos.MesosClient(access_token, project_id, cluster_id, None) resp = client.delete_deployment(namespace, name) if resp.get('code') != ErrorCode.NoError: raise error_codes.APIError(f'delete mesos deployment error, {resp.get("message")}')
def get_cluster_hpa_list(request, project_id, cluster_id, cluster_env, cluster_name, namespace=None): """获取基础hpa列表 """ access_token = request.user.token.access_token project_code = request.project.english_name hpa_list = [] if request.project.coes == ProjectKind.MESOS.value: client = mesos.MesosClient(access_token, project_id, cluster_id, env=cluster_env) else: client = k8s.K8SClient(access_token, project_id, cluster_id, env=cluster_env) hpa = client.list_hpa(namespace).get('items') or [] for _config in hpa: labels = _config.get('metadata', {}).get('labels') or {} # 获取模板集信息 template_id = labels.get(instance_constants.LABLE_TEMPLATE_ID) # 资源来源 source_type = labels.get(instance_constants.SOURCE_TYPE_LABEL_KEY) if not source_type: source_type = "template" if template_id else "other" annotations = _config.get('metadata', {}).get('annotations') or {} namespace = _config['metadata']['namespace'] deployment_name = _config['spec']['scaleTargetRef']['name'] deployment_link = f'{settings.DEVOPS_HOST}/console/bcs/{project_code}/app/deployments/{deployment_name}/{namespace}/deployment' # noqa data = { 'cluster_name': cluster_name, 'environment': cluster_env, 'cluster_id': cluster_id, 'name': _config['metadata']['name'], 'namespace': namespace, 'max_replicas': _config['spec']['maxReplicas'], 'min_replicas': _config['spec']['minReplicas'], 'current_replicas': _config['status']['currentReplicas'], 'current_metrics_display': get_current_metrics_display(_config), 'current_metrics': get_current_metrics(_config), 'source_type': application_constants.SOURCE_TYPE_MAP.get(source_type), 'creator': annotations.get(instance_constants.ANNOTATIONS_CREATOR, ''), 'create_time': annotations.get(instance_constants.ANNOTATIONS_CREATE_TIME, ''), 'deployment_name': deployment_name, 'deployment_link': deployment_link } data['update_time'] = annotations.get( instance_constants.ANNOTATIONS_UPDATE_TIME, data['create_time']) data['updator'] = annotations.get( instance_constants.ANNOTATIONS_UPDATOR, data['creator']) hpa_list.append(data) return hpa_list
def handler_ingress(self, namespace, cluster_id, spec): client = mesos.MesosClient(self.access_token, self.project_id, cluster_id, env=None) client.create_custom_resource(namespace, spec)
def get_host_taskgroup(access_token, project_id, cluster_id, inner_ip_list): """查询mesos机器下taskgroup""" mesos_client = mesos.MesosClient(access_token, project_id, cluster_id, None) resp = mesos_client.get_taskgroup(inner_ip_list, fields="namespace") return resp.get("data")
def create_or_update_agent_labels(access_token, project_id, cluster_id, labels): client = mesos.MesosClient(access_token, project_id, cluster_id, None) return client.update_agent_attrs(labels)
def create_mesos_deployment(access_token, project_id, cluster_id, namespace, mesos_json): client = mesos.MesosClient(access_token, project_id, cluster_id, None) resp = client.create_deployment(namespace, mesos_json) if (resp.get('code') != ErrorCode.NoError) and ('already exist' not in resp.get('message', '')): raise error_codes.APIError(f'create mesos deployment error, {resp.get("message")}')