validateClusterLogicParams(ESLogicClusterDTO param, OperationEnum operation,
Integer projectId) {
return clusterLogicService.validateClusterLogicParams(param,operation,projectId);
}
/**
* “将具有给定 id 的集群加入到具有给定 id 的项目中。”
*
* 函数的第一行是注释。编译器会忽略注释
*
* @param logicClusterId 要加入的集群的 ID。
* @param joinProjectId 加入的项目ID
* @return 返回类型是 Result
*/
@Override
public Result joinClusterLogic(Long logicClusterId, Integer joinProjectId) {
final ESLogicClusterDTO param = new ESLogicClusterDTO();
param.setId(logicClusterId);
param.setProjectId(joinProjectId);
param.setType(clusterLogicService.getClusterLogicByIdThatNotContainsProjectId(logicClusterId).getType());
return Result.buildFrom(clusterLogicService.joinClusterLogic(param));
}
/**
* @param level level
* @return Result>
*/
@Override
public Result> getLogicClustersByLevel(Integer level) {
List list = ConvertUtil.list2List(clusterLogicService.listLogicClustersByLevelThatProjectIdStrConvertProjectIdList(level),
ClusterLogicVO.class);
for (ClusterLogicVO clusterLogicVO : list) {
List clusterPhyNames = clusterRegionService.listPhysicClusterNames(clusterLogicVO.getId());
clusterLogicVO.setPhyClusterAssociated(!AriusObjUtils.isEmptyList(clusterPhyNames));
clusterLogicVO.setAssociatedPhyClusterName(clusterPhyNames);
Optional.ofNullable(clusterLogicVO.getProjectId()).map(projectService::getProjectBriefByProjectId)
.map(ProjectBriefVO::getProjectName).ifPresent(clusterLogicVO::setProjectName);
}
return Result.buildSucc(list);
}
@Override
public Result>> listProjectClusterLogicIdsAndNames(Integer projectId) {
List> res = Lists.newArrayList();
List tempAuthLogicClusters = Lists.newArrayList();
if (AuthConstant.SUPER_PROJECT_ID.equals(projectId)) {
tempAuthLogicClusters.addAll(clusterLogicService.listAllClusterLogics());
} else {
tempAuthLogicClusters.addAll(clusterLogicService.getHasAuthClusterLogicsByProjectId(projectId));
}
for (ClusterLogic clusterLogic : tempAuthLogicClusters) {
Tuple logicClusterId2logicClusterNameTuple = new Tuple<>();
logicClusterId2logicClusterNameTuple.setV1(clusterLogic.getId());
logicClusterId2logicClusterNameTuple.setV2(clusterLogic.getName());
res.add(logicClusterId2logicClusterNameTuple);
}
return Result.buildSucc(res);
}
@Override
public Result> getProjectLogicClusterInfoByType(Integer projectId, Integer type) {
ESLogicClusterDTO logicClusterDTO = new ESLogicClusterDTO();
if (!AuthConstant.SUPER_PROJECT_ID.equals(projectId)) {
logicClusterDTO.setProjectId(projectId);
}
logicClusterDTO.setType(type);
return Result.buildSucc(
ConvertUtil.list2List(clusterLogicService.listClusterLogics(logicClusterDTO), ClusterLogicVO.class));
}
@Override
public Result> listMachineSpec() {
List esMachineNormsPOS = esMachineNormsService.listMachineNorms();
return Result.buildSucc(ConvertUtil.list2List(esMachineNormsPOS, ESClusterNodeSepcVO.class));
}
@Override
public ClusterLogicVO getClusterLogic(Long clusterLogicId, Integer currentProjectId) {
ClusterLogic clusterLogic = clusterLogicService.getClusterLogicByIdAndProjectId(clusterLogicId, currentProjectId);
ClusterLogicVO clusterLogicVO = ConvertUtil.obj2Obj(clusterLogic, ClusterLogicVO.class);
FUTURE_UTIL.runnableTask(() -> buildConsoleClusterVersions(clusterLogicVO))
.runnableTask(() -> buildOpLogicClusterPermission(clusterLogicVO, currentProjectId))
.runnableTask(
() -> Optional.ofNullable(projectService.getProjectBriefByProjectId(clusterLogicVO.getProjectId()))
.map(ProjectBriefVO::getProjectName).ifPresent(clusterLogicVO::setProjectName))
.runnableTask(() -> buildClusterNodeInfo(clusterLogicVO)).waitExecute();
return clusterLogicVO;
}
@Override
public Result addLogicClusterAndClusterRegions(ESLogicClusterWithRegionDTO param,
String operator) throws AdminOperateException {
return clusterRegionManager.batchBindRegionToClusterLogic(param, operator, Boolean.TRUE);
}
/**
* 删除逻辑集群 这里是及其容易触发操作超时的，
* 1.如果模板没有下线干净，那么这里就不能把逻辑集群下线干净，
* 2.如果索引没有下线干净，那么逻辑集群也是不能下线的，否则系统和数据库共同残留下来，业务侧就出现了问题
*
* @param logicClusterId logicclusterid
* @param operator
* @param projectId projectid
* @return {@link Result}<{@link Void}>
* @throws AdminOperateException
*/
@Transactional(rollbackFor = Exception.class)
@Override
public Result deleteLogicCluster(Long logicClusterId, String operator,
Integer projectId) {
//一个逻辑集群对应了多个项目的情况
final List clusterLogicList = clusterLogicService.listClusterLogicByIdThatProjectIdStrConvertProjectIdList(logicClusterId);
if (CollectionUtils.isEmpty(clusterLogicList)) {
return Result.buildSucc();
}
final ClusterLogic clusterLogic = clusterLogicList.stream()
.filter(c -> Objects.equals(c.getProjectId(), projectId)).findFirst()
.orElse(null);
if (Objects.isNull(clusterLogic)) {
return Result.buildFail(String.format("项目【%s】不存在逻辑集群",
projectService.getProjectBriefByProjectId(projectId).getProjectName()));
}
final Result checkProjectCorrectly = ProjectUtils.checkProjectCorrectly(ClusterLogic::getProjectId,
clusterLogic, projectId);
if (checkProjectCorrectly.failed()) {
return checkProjectCorrectly;
}
//获取逻辑模板和索引
ClusterLogicTemplateIndexDetailDTO templateIndexVO = getTemplateIndexVO(clusterLogic, projectId);
try {
//但是索引下线没有完成，导致了脏数据的产生
if (CollectionUtils.isNotEmpty( templateIndexVO.getCatIndexResults())||
CollectionUtils.isNotEmpty(templateIndexVO.getTemplates())){
return Result.buildFail(String.format(
"该集群下还有%d项模板资源、%d项索引资源，如需下线集群，请前往模板管理、索引管理下线掉对应的模板及索引",
Optional.ofNullable(templateIndexVO.getTemplates()).orElse(Collections.emptyList()).size(),
Optional.ofNullable(templateIndexVO.getCatIndexResults()).orElse(Collections.emptyList()).size()
));
}
if (clusterLogicList.size() == 1) {
//将region解绑
ClusterRegion clusterRegion = clusterRegionService.getRegionByLogicClusterId(logicClusterId);
if (Objects.nonNull(clusterRegion)) {
//将region解绑
Result unbindRes = clusterRegionService.unbindRegion(clusterRegion.getId(), logicClusterId,
operator);
if (unbindRes.failed()) {
throw new AdminOperateException(unbindRes.getMessage());
}
}
}
//删除逻辑集群
Result result = clusterLogicService.deleteClusterLogicById(logicClusterId, operator, projectId);
if (result.success()) {
SpringTool.publish(new ClusterLogicEvent(logicClusterId, projectId));
//操作记录 集群下线
operateRecordService.saveOperateRecordWithManualTrigger(clusterLogic.getName(), operator, projectId, logicClusterId,
OperateTypeEnum.MY_CLUSTER_OFFLINE);
return Result.buildSuccWithTips(result.getData(),
String.format("逻辑集群%s下线成功", clusterLogic.getName()));
}
return Result.buildFailWithMsg(result.getData(),String.format("逻辑集群%s下线失败,%s", clusterLogic.getName(),
result.getMessage()));
} catch (AdminOperateException | ElasticsearchTimeoutException e) {
LOGGER.error("class={}||method=deleteLogicCluster||clusterLogic={}||es operation errMsg={}",
getClass().getSimpleName(), clusterLogic.getName(), e);
// 这里必须显示事务回滚
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
return Result.buildFail(String.format("逻辑集群%s下线失败,, 请重新尝试下线集群,多次重试不成功,请联系管理员", clusterLogic.getName()));
} catch (Exception e) {
LOGGER.error("class={}||method=deleteLogicCluster||clusterLogic={}||es operation errMsg={}",
getClass().getSimpleName(), clusterLogic.getName(), e);
// 这里必须显示事务回滚
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
return Result.buildFail("操作失败,请联系管理员");
}
}
private ClusterLogicTemplateIndexDetailDTO getTemplateIndexVO(ClusterLogic clusterLogic,Integer projectId) {
IndexTemplateDTO param = new IndexTemplateDTO();
param.setResourceId(clusterLogic.getId());
param.setProjectId(projectId);
List indexTemplates = indexTemplateService.listLogicTemplates(param);
//通过逻辑集群获取index
List catIndexResults = esIndexCatService.syncGetIndexByCluster(clusterLogic.getName(),projectId);
ClusterLogicTemplateIndexDetailDTO templateIndexVO = new ClusterLogicTemplateIndexDetailDTO();
templateIndexVO.setCatIndexResults(catIndexResults);
templateIndexVO.setTemplates(indexTemplates);
return templateIndexVO;
}
@Override
public Result editLogicCluster(ESLogicClusterDTO param, String operator, Integer projectId) {
final ClusterLogic logic = clusterLogicService.getClusterLogicByIdAndProjectId(param.getId(), projectId);
Result result = clusterLogicService.editClusterLogic(param, operator, projectId);
if (result.success()) {
SpringTool.publish(new ClusterLogicEvent(param.getId(), projectId));
//操作记录 我的集群信息修改
if (StringUtils.isNotBlank(param.getMemo())) {
operateRecordService.saveOperateRecordWithManualTrigger(String.format("%s 修改集群描述，%s-->%s", logic.getName(), logic.getMemo(),
param.getMemo()), operator, projectId, param.getId(),OperateTypeEnum.MY_CLUSTER_INFO_MODIFY);
}
}
return result;
}
@Override
public PaginationResult pageGetClusterLogics(ClusterLogicConditionDTO condition,
Integer projectId) throws NotFindSubclassException, ESOperateException {
BaseHandle baseHandle = handleFactory.getByHandlerNamePer(CLUSTER_LOGIC.getPageSearchType());
if (baseHandle instanceof ClusterLogicPageSearchHandle) {
ClusterLogicPageSearchHandle pageSearchHandle = (ClusterLogicPageSearchHandle) baseHandle;
return pageSearchHandle.doPage(condition, projectId);
}
LOGGER.warn(
"class=ClusterLogicManagerImpl||method=pageGetConsoleClusterVOS||msg=failed to get the ClusterLogicPageSearchHandle");
return PaginationResult.buildFail("分页获取逻辑集群信息失败");
}
@Override
public boolean updateClusterLogicHealth(Long clusterLogicId) {
ESLogicClusterDTO updateLogicClusterDTO = new ESLogicClusterDTO();
Set clusterHealthSet = Sets.newHashSet();
updateLogicClusterDTO.setId(clusterLogicId);
try {
final ClusterRegion clusterRegion = clusterRegionService.getRegionByLogicClusterId(clusterLogicId);
if (Objects.isNull(clusterRegion)) {
LOGGER.error(
"class=ClusterLogicManagerImpl||method=updateClusterLogicHealth||clusterLogicId={}||errMsg=clusterLogicContext is empty",
clusterLogicId);
clusterHealthSet.add(UNKNOWN.getCode());
} else {
clusterHealthSet.add(esClusterService.syncGetClusterHealthEnum(clusterRegion.getPhyClusterName()).getCode());
}
updateLogicClusterDTO.setHealth(ClusterUtils.getClusterLogicHealthByClusterHealth(clusterHealthSet));
setClusterLogicInfo(updateLogicClusterDTO,clusterRegion);
clusterLogicService.editClusterLogicNotCheck(updateLogicClusterDTO);
} catch (Exception e) {
LOGGER.error("class=ClusterLogicManagerImpl||method=updateClusterLogicHealth||clusterLogicId={}||errMsg={}",
clusterLogicId, e.getMessage(), e);
return false;
}
return true;
}
@Override
public Result indexTemplateCount(Long clusterId, String operator,
Integer projectId) {
ClusterLogic clusterLogic = clusterLogicService.getClusterLogicByIdAndProjectId(clusterId,projectId);
ClusterLogicTemplateIndexDetailDTO detailVO = getTemplateIndexVO(clusterLogic,projectId);
ClusterLogicTemplateIndexCountVO countVO = new ClusterLogicTemplateIndexCountVO();
countVO.setCatIndexResults(detailVO.getCatIndexResults().size());
countVO.setTemplateLogicAggregates(detailVO.getTemplates().size());
return Result.buildSucc(countVO);
}
@Override
public Result estimatedDiskSize(Long clusterLogicId, Integer count) {
ClusterLogic clusterLogic =
clusterLogicService.getClusterLogicByIdThatNotContainsProjectId(clusterLogicId);
if (Objects.isNull(clusterLogic)){
return Result.buildFail("逻辑集群不存在");
}
String nodeSpec = clusterLogic.getDataNodeSpec();
if (StringUtils.isNotBlank(nodeSpec)) {
return Result.buildSucc(getUnitSize(nodeSpec.split("-")[2]) * count);
}
return Result.buildSucc(UNKNOWN_SIZE);
}
@Override
public Result getClusterDataNodeSpec(Long clusterLogicId){
ClusterRegion clusterRegion = clusterRegionService.getRegionByLogicClusterId(clusterLogicId);
Result> result = clusterRoleHostService.listByRegionId(clusterRegion.getId().intValue());
ClusterRoleHost clusterRoleHost = result.getData().stream().findFirst().orElse(null);
return Result.buildSucc(clusterRoleHost.getMachineSpec());
}
@Override
public Result> listClusterLogicNameByProjectId(Integer projectId) {
List tempAuthLogicClusters = Lists.newArrayList();
if (AuthConstant.SUPER_PROJECT_ID.equals(projectId)) {
tempAuthLogicClusters.addAll(clusterLogicService.listAllClusterLogics());
} else {
tempAuthLogicClusters.addAll(clusterLogicService.getHasAuthClusterLogicsByProjectId(projectId));
}
List names = tempAuthLogicClusters.stream().map(ClusterLogic::getName).collect(Collectors.toList());
if (CollectionUtils.isEmpty(names)){
return Result.buildFail("无集群信息，请前往集群管理-->我的集群，进行集群申请。");
}
return Result.buildSucc(names);
}
@Override
public Result>> getClusterRelationByProjectId(Integer projectId) {
List> collect;
if (AuthConstant.SUPER_PROJECT_ID.equals(projectId)) {
List phyList = clusterPhyService.listAllClusters();
collect = phyList.stream().map(
clusterPhy -> new Tuple<>(clusterPhy.getCluster(), ConvertUtil.obj2Obj(clusterPhy, ClusterPhyVO.class)))
.collect(Collectors.toList());
} else {
List logicList = clusterLogicService.getOwnedClusterLogicListByProjectId(projectId);
collect = logicList.stream()
.map(clusterLogic -> new Tuple<>(clusterLogic.getName(), getPhyNameByLogic(clusterLogic.getId())))
.collect(Collectors.toList());
}
return Result.buildSucc(collect);
}
@Override
public Result> getClusterLogicPlugins(Long clusterId) {
return Result
.buildSucc(ConvertUtil.list2List(clusterLogicService.getClusterLogicPlugins(clusterId), PluginVO.class));
}
@Override
public Result isLogicClusterRegionIsNotEmpty(Long logicClusterId) {
if (!clusterLogicService.existClusterLogicById(logicClusterId)) {
return Result.buildWithMsg(false, "逻辑集群不存在！");
}
ClusterRegion clusterRegion = clusterRegionService.getRegionByLogicClusterId(logicClusterId);
if (null == clusterRegion) {
return Result.buildWithMsg(false, "逻辑集群Region不存在！");
}
Result> roleHostResult = clusterRoleHostService
.listByRegionId(Math.toIntExact(clusterRegion.getId()));
return Result.buildSucc(roleHostResult.success() && CollectionUtils.isNotEmpty(roleHostResult.getData()));
}
/**************************************************** private method ****************************************************/
/**
* 设置磁盘使用信息
* @param clusterDTO
*/
public void setClusterLogicInfo(ESLogicClusterDTO clusterDTO,ClusterRegion clusterRegion) {
Result> result = clusterRoleHostService
.listByRegionId(Math.toIntExact(clusterRegion.getId()));
if (result.success()) {
List clusterRoleHostList = result.getData().stream().map(ClusterRoleHost::getNodeSet).collect(Collectors.toList());
Long diskTotal = 0L;
Long diskUsage = 0L;
Map> map = eSClusterNodeService
.syncGetNodesDiskUsage(clusterRegion.getPhyClusterName());
Set>> entries = map.entrySet();
for (Map.Entry> entry : entries) {
if (clusterRoleHostList.contains(entry.getKey())) {
diskTotal += entry.getValue().v1();
diskUsage += entry.getValue().v2();
}
}
//设置节点数
clusterDTO.setDataNodeNum(clusterRoleHostList.size());
clusterDTO.setDiskTotal(diskTotal);
clusterDTO.setDiskUsage(diskUsage);
double diskUsagePercent = diskUsage != 0L && diskTotal != 0L ? CommonUtils.divideDoubleAndFormatDouble(
diskUsage,
diskTotal, 2, 1) : 0.0;
clusterDTO.setDiskUsagePercent(diskUsagePercent);
}
//设置es集群版本
ClusterPhy physicalCluster = getLogicClusterAssignedPhysicalClusters(clusterDTO.getId());
if (physicalCluster == null) {
return;
}
clusterDTO.setEsClusterVersion(physicalCluster.getEsVersion());
}
private ClusterPhyVO getPhyNameByLogic(Long clusterLogicId) {
ClusterRegion clusterRegion = clusterRegionService.getRegionByLogicClusterId(clusterLogicId);
ClusterPhy clusterPhy = clusterPhyService.getClusterByName(clusterRegion.getPhyClusterName());
return ConvertUtil.obj2Obj(clusterPhy, ClusterPhyVO.class);
}
/**
* 构建OP逻辑集群权限
* @param clusterLogicVO 逻辑集群
* @param projectIdForAuthJudge 用于判断权限的应用id（供应用管理页面获取关联集群列表使用）
* ，为null则权限为运维人员权限（管理权限）
*/
private void buildOpLogicClusterPermission(ClusterLogicVO clusterLogicVO, Integer projectIdForAuthJudge) {
if (clusterLogicVO == null) {
return;
}
if (projectIdForAuthJudge == null) {
// 未指定需要判断权限的app，取运维人员权限
clusterLogicVO.setAuthId(null);
clusterLogicVO.setAuthType(ProjectClusterLogicAuthEnum.OWN.getCode());
clusterLogicVO.setPermissions(ProjectClusterLogicAuthEnum.OWN.getDesc());
} else {
// 指定了需要判断权限的app
buildLogicClusterPermission(clusterLogicVO, projectIdForAuthJudge);
}
}
/**
* 根据物理集群名获取对应的逻辑集群列表，若传入为空，则返回全量
* @param phyClusterName 物理集群的名称
* @return List 逻辑集群名称列表
*/
@Override
public List listClusterLogicNameByPhyName(String phyClusterName) {
//若传入为空，则返回全量
if (null == phyClusterName) {
return clusterLogicService.listAllClusterLogics()
.stream()
.map(ClusterLogic::getName)
.distinct()
.collect(Collectors.toList());
} else {
return getClusterPhyAssociatedClusterLogicNames(phyClusterName);
}
}
/**
* 返回与给定应用关联的逻辑集群名称列表
*
* @param projectId 项目id
* @return List 逻辑集群名称列表
*/
@Override
public List listClusterLogicNameByApp(Integer projectId) {
List clusterLogicList = clusterLogicService.getHasAuthClusterLogicsByProjectId(projectId);
List names = Lists.newArrayList();
for (ClusterLogic clusterLogic : clusterLogicList) {
names.add(clusterLogic.getName());
}
return names;
}
/**
* 返回与给定物理集群名称关联的逻辑集群名称列表
*
* @param phyClusterName 物理集群的名称。
* @return 与给定集群物理名称关联的集群逻辑名称列表。
*/
@Override
public List
# 1.KnowSearch简介
KnowSearch是面向Elasticsearch研发与运维人员，围绕集群、索引构建的零侵入、多租户的Elasticsearch GUI管控平台。历经滴滴PB级海量索引数据考验、金融级1000+ES集群运营实战打磨，围绕Elasticsearch构建的可见、可管、可控的服务体系。
- 围绕ES用户，构建了自助服务体系
- 量贩式集群/索引资源申请与管理
- 低门槛数据建模
- DSL/SQL灵活数据探查
- 基于DSL查询模板，自助问题诊断
- 围绕ES运维，构建了场景化运维服务体系
- 基于Dashboard集群问题主动发现
- 基于集群看板高频问题快速诊断
- 基于集群管理，存量5.X+版本集群全量纳管、高频集群与索引变更批量支持
- 基于原生ES网关，零侵入、插件化的构建查询/写入限流、权限校验、跨集群访问、DSL查询模板分析与管控能力
体验地址 http://101.43.178.205 ，用户名/密码：admin/admin123
# 4.文档资源
- [KnowSearch用户手册](doc/KnowSearch用户手册.md)
- [KnowSearch安装部署文档](doc/KnowSearch安装部署文档.md)
- [KnowSearch设计说明](doc/KnowSearch设计说明.md)
- [KnowSearch-GateWay设计说明](doc/KnowSearch-GateWay设计文档.md)
- [KnowSearch源码编译运行文档](doc/KnowSearch源码编译运行文档.md)
- [ElasticSearch最佳实践](doc/ElasticSearch最佳实践.md)
- [KnowSearch常见FAQ](doc/KnowSearch常见FAQ.md)
# 5.技术交流
微信加群：添加`PenceXie`的微信号备注KnowSearch加群，加群之前有劳点一下 Star，一个小小的 Star 是对KnowSearch作者们努力建设社区的动力。
如果有商业合作需求，也欢迎咨询。
================================================
FILE: Releases_Notes.md
================================================
# v0.3.1
版本上线时间：2022-12-30
## 能力提升
- KnowSearch工程，基于Metrics构建观测体系，指标通过Grafana展示
- 物理集群接入流程加入Kibana/Cerebro外联地址，集群详情支持跳转到对应地址
- 指标场景化设计，将指标看板细分为读写黄金指标、读写性能指标、读写热点指标、读写内存指标
## 体验优化
- 检索查询页面体验优化
- 物理集群-快捷命令操作体验优化
- 索引模板-禁用读写操作用户侧变更为工单形式
- 子页面详情页支持打开多个
- 一级二级页面展示优化，UI统一
- 用户管理新增删除能力，新增用户密码展示
- 指标看板支持对象多选
- 查询模板中【启/禁用】、【修改限流值】加入工单审批流程
- 下线kibana依赖
- 模块改动，将低频模块转移至【系统管理】中
## BUG修复
- 脚本初始化后，需要还原平台配置默认值
- 指标看板展示性能问题解决
- 实例名称兼容中文
# v0.2.3
版本上线时间：2022-04-24
## 能力提升
- 集群看板—索引视图中增加以.开头的系统索引。
- 集群看板增加指标监控项：stored_fields_memory。
- 集群看板—索引视图指标优化：索引写入耗时优化为单条文档耗时，merge\flush\refresh耗时优化为单次耗时。
- 指标拆解：网关写入量条/min拆为为写入吞吐量/min、写入请求量/min。
- 物理集群—接入集群节点校验是否属于一个集群。
- 编辑mapping不同步当前索引，在下次创建分区时生效。
- 增加模块：Dashboard。
- 集群看板—节点视图增加堆内存young/old区监控。
- 优化指标看板中起始位置曲线尖刺。
## 体验优化
- 集群看板—节点视图选择节点时，支持一次选择多个节点。
- 集群看板—总览视图指标查看时，多个图表可以联动显示。
- 指标布局优化，统一write queue与search queue的名称。
- 指标看板节点列表按指标大小排序。
- 集群总览自动刷新支持全页面刷新。
- 查询模板详情增加md5信息。
- 搜索框输入内容去除前后空格。
- 集群看板，时间筛选器起止时间跨度限制为7天内。
- 新建模板未开启索引模板服务时置灰相关项mapping和setting。
- 平台配置中的【值】长度上限修改为1000。
- 索引模板操作记录分类，mapping编辑部分优化。
- 搜索框支持回车查询。
- 总览视图新增堆内存使用率。
- 索引名称、索引模板名称展示优化（索引50 模板30字符）。
- 指标看板搜索框宽度，集群看板索引视图50字符，索引模板30字符，网关看板索引视图50字符。
## BUG修复
- 集群看板—节点视图merge,flush,refresh展示每分钟的次数（次/min）。
- DCDR版本校验、任务失败后可再次提交。
- 索引模板升版本，新增的版本号只加到当天分区，第二天新建的分区不加版本号后缀。
# v0.2.2
版本上线时间：2022-03-14
## 能力提升
- DCDR特性去除对Rack依赖，优化DCDR链路创建规范，新建链路时可以进行rack选择。
- admin和gateway中 xxx.yml 或者 xxx.properties中配置项port说明不明确。应该指明是http port 还是tcp port。
- 索引删除逻辑优化（索引管理页面新增close和open按钮，作用是打开或者关闭索引，用户可以选择close索引）。
- Elasticsearch元数据集群专项治理（包括增加routing以及索引index sort）。
- GateWay日志优化+Get Node Task记录，整体写入与查询问题。
- 2.3.3 存量ES集群版本全纳管，索引管理模板中check禁用读、禁用写。
- 网关原生模式：支持限流（支持appid粒度）、支持gateway对请求token校验。
- Kibana的DisCover模块代理逻辑（非dsl控制台也要数据隔离，带上物理集群名到gateway查询）。
- 增加Sense管控的集群路由能力。
- 元信息指标读写都在GateWay，网关看板指标保障准确（网关看板添加clientNode视图）。
- 指标看板-topN算法优化。
- 指标看板新增索引模板视图的指标监控。
## 体验优化
- 平台搜索框需要具备记录能力，切换不清空。
- 接入集群端口放开，不限制只能4位。之前是限制4位，后面放开为0-25535。
- 集群版本管理体验优化 ，新增版本标识：滴滴内部、开源。
- 集群名称默认物理名称+集群版本号（输入框加提示，规范用户操作）。
- 平台配置项的说明文档优化，配置说明优化（跳转至github文档说明）。
- 模板管理的操作项将平台能力与索引模板服务区分展示。
- 插件管理定义（物理集群插件管理分为平台能力插件、ES能能力插件）。
- 索引模板详情 Mapping、 Setting 、DCDR TAB页体验页面优化。
- 全平台集群下拉框需要支持搜索能力。
- 检索查询--索引查新--SQL查询页面体验优化。
- 指标配置新增黄金指标配置，点击一键勾选黄金指标。
- 容量规划概念统一为索引RollOver（shard调整和indexRollover 统一，索引模版服务名称由容量规划改为索引规划）。
- 索引模板管理页面加入物理集群筛选项。
- 指标图表可以同类中进行拖拽，指标配置顺序同步修改。
- 接入集群记录主机分为两种模式：自动获取、全量录入。
- LogIEM全平台列表排序支持全局排序。
- 新建集群增加节点规格输入框，物理集群详情-节点划分新增节点规格展示列。
- 筛选分片过多的集群 ：物理集群列表增加一列”活跃分片数“，支持排序。
- 索引模板mapping、setting等更新操作需要保留记录（旧mapping、setting和修改后的mapping setting）。
- 逻辑集群增加等级标识：核心、重要、一般。索引模板支持业务等级与逻辑集群绑定，新建模板时默认与所选集群业务等级一致，支持修改，升降等级均可。
- 集群接入增加所属资源类型：acs、vmware、信创（tce）。
- 检索查询-DSL模板改成查询诊断。
- 总览视图和节点视图中涉及到数量趋势、TASK耗时的指标名称改为（节点）执行任务数量、（节点）执行任务数耗时。
## bug修复
- 修复dcdr采集任务报错，自己的元数据es引擎根本没有DCDR的actionplugin。
- 修复DSL查询切换集群时报错问题（GET _cluster/health?v）。
- 修复网关看板--查询模板点击事件消失问题（可能是代码未合到主分支导致）。
- 统一集群看板的节点角色概念和物理集群详情中节点划分的角色概念。
- 集群状态statustype 0，1，2统一标准。
- 索引模板名称不支持大写字母，前端修复。
================================================
FILE: arius-admin/README.md
================================================
## 1. 项目背景
arius-admin-v2 致力于实现一套于对Elasticsearch元数据的管控平台，负责维护项目（APPID）、索引、Elasticsearch集群资源等信息的管理，并维护三者之前的关系；对外暴露restFul接口，以提供查询管控元数据的能力。
## 2. 模块划分
arius-admin-v2由10个主要的工程和扩展增值服务组成:
```java
arius-admin-rest 表现层1，可以直接封装Manager接口暴露成restful接口
arius-admin-task 表现层2，提供auv-job定时调度任务入口, 任务实现在arius-admin-biz/arius-admin-core中
arius-admin-common 基础组件层1，存放业务需要数据结构, 如Java POJO(entity、po)、公共工具方法、事件等
arius-admin-client 基础组件层2，存放业务需要的POJO(vo、dto)、枚举等, 并且提供客户端请求响应的数据实体。
arius-admin-biz 业务层1，负责对arius-admin-core中各种的业务逻辑进行聚合处理，提供表现层所需要的数据实体
arius-admin-extend 业务层2，扩展服务, 如容量规划等
arius-admin-core 核心层1，提供核心的管控能力, 主要的业务逻辑实现, 如集群、索引、项目等
arius-admin-metadata 核心层2，负责对Elasticsearch的元数据采集，如索引指标统计、节点指标统计, 提供的能力包括但不限于DSL分析、健康检查等
arius-admin-persistence 数据层1，负责对MySQL和Elasticsearch中的数据进行操作
arius-admin-remote 数据层2，获取第三方服务数据, 如访问文件存储系统、企业部门系统等
```
名词定义：
```java
resource: 逻辑资源
cluster: 物理ES集群
region: 一组ES DataNode组成的最小资源分配单位
```
## 3. 如何使用
可单独部署，也可配合网关 arius-gateway-v2 一同使用，致力于更高效的管控 Elasticsearch 元数据
### 3.1 配置
配置环境文件：application-xxx.properties
#### 3.1.1 更新ES数据集群名称
```java
es.update.cluster.name: {name}
es.client.cluster.port: {port}
```
#### 3.1.2 网关配置
es.gateway.url: {host}
es.gateway.port: {port}
es.appid: {appId1},{appId2},{appId3}
es.password: {passwd},{passwd},{passwd}
#### 3.1.3 数据源配置
datasource:
name: data
type: com.alibaba.druid.pool.DruidDataSource
druid:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://{host}:{port}/{dbName}?useUnicode=true&characterEncoding=utf8&jdbcCompliantTruncation=true&allowMultiQueries=true&useSSL=false
username: {username}
password: {password}
auv-job:
jdbc-url: jdbc:mysql://{host}:{port}/{dbName}?useUnicode=true&characterEncoding=utf8&jdbcCompliantTruncation=true&allowMultiQueries=true&useSSL=false
username: {username}
password: {password}
### 3.2 打包
mvn clean package -Dmaven.test.skip=true
### 3.3 运行
java -jar arius-admin-rest.jar --spring.profiles.active=xxx (test、dev)
================================================
FILE: arius-admin/arius-admin-biz/pom.xml
================================================