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