build dependencies version lock

1、测试代码，开源用户尽量不要使用；
2、包含Kafka-HA的相关功能，在v2.8.0_e的基础上，补充按照clientId切换的功能；
3、基于v2.8.0_e拉的分支；

.gitignore

@@ -111,3 +111,4 @@ dist/
 dist/*
 kafka-manager-web/src/main/resources/templates/
 .DS_Store
+kafka-manager-console/package-lock.json

Dockerfile

@@ -0,0 +1,41 @@
+ARG MAVEN_VERSION=3.8.4-openjdk-8-slim
+ARG JAVA_VERSION=8-jdk-alpine3.9
+FROM maven:${MAVEN_VERSION} AS builder
+ARG CONSOLE_ENABLE=true
+
+WORKDIR /opt
+COPY . .
+COPY distribution/conf/settings.xml /root/.m2/settings.xml
+
+# whether to build console
+RUN set -eux; \
+    if [ $CONSOLE_ENABLE = 'false' ]; then \
+        sed -i "/kafka-manager-console/d" pom.xml; \
+    fi \
+    && mvn -Dmaven.test.skip=true clean install -U
+
+FROM openjdk:${JAVA_VERSION}
+
+RUN sed -i 's/dl-cdn.alpinelinux.org/mirrors.aliyun.com/g' /etc/apk/repositories && apk add --no-cache tini
+
+ENV TZ=Asia/Shanghai
+ENV AGENT_HOME=/opt/agent/
+
+COPY --from=builder /opt/kafka-manager-web/target/kafka-manager.jar /opt
+COPY --from=builder /opt/container/dockerfiles/docker-depends/config.yaml $AGENT_HOME
+COPY --from=builder /opt/container/dockerfiles/docker-depends/jmx_prometheus_javaagent-0.15.0.jar $AGENT_HOME
+COPY --from=builder /opt/distribution/conf/application-docker.yml /opt
+
+WORKDIR /opt
+
+ENV JAVA_AGENT="-javaagent:$AGENT_HOME/jmx_prometheus_javaagent-0.15.0.jar=9999:$AGENT_HOME/config.yaml"
+ENV JAVA_HEAP_OPTS="-Xms1024M -Xmx1024M -Xmn100M "
+ENV JAVA_OPTS="-verbose:gc  \
+    -XX:MaxMetaspaceSize=256M  -XX:+DisableExplicitGC -XX:+UseStringDeduplication \
+    -XX:+UseG1GC  -XX:+HeapDumpOnOutOfMemoryError   -XX:-UseContainerSupport"
+
+EXPOSE 8080 9999
+
+ENTRYPOINT ["tini", "--"]
+
+CMD [ "sh", "-c", "java -jar $JAVA_AGENT $JAVA_HEAP_OPTS $JAVA_OPTS kafka-manager.jar --spring.config.location=application-docker.yml"]

README.md

@@ -1,20 +1,21 @@
 
 ---
 
-![kafka-manager-logo](./docs/assets/images/common/logo_name.png)
+![logikm_logo](https://user-images.githubusercontent.com/71620349/125024570-9e07a100-e0b3-11eb-8ebc-22e73e056771.png)
 
 **一站式`Apache Kafka`集群指标监控与运维管控平台**
 
+`LogiKM开源至今备受关注，考虑到开源项目应该更贴合Apache Kafka未来发展方向，经项目组慎重考虑，预计22年下半年将其品牌升级成Know Streaming，届时项目名称和Logo也将统一更新，感谢大家一如既往的支持，敬请期待！`
 
-
-阅读本README文档，您可以了解到滴滴Logi-KafkaManager的用户群体、产品定位等信息，并通过体验地址，快速体验Kafka集群指标监控与运维管控的全流程。<br>若滴滴Logi-KafkaManager已在贵司的生产环境进行使用，并想要获得官方更好地支持和指导，可以通过[`OCE认证`](http://obsuite.didiyun.com/open/openAuth)，加入官方交流平台。
+阅读本README文档，您可以了解到滴滴Logi-KafkaManager的用户群体、产品定位等信息，并通过体验地址，快速体验Kafka集群指标监控与运维管控的全流程。
 
 
 ## 1 产品简介
 滴滴Logi-KafkaManager脱胎于滴滴内部多年的Kafka运营实践经验，是面向Kafka用户、Kafka运维人员打造的共享多租户Kafka云平台。专注于Kafka运维管控、监控告警、资源治理等核心场景，经历过大规模集群、海量大数据的考验。内部满意度高达90%的同时，还与多家知名企业达成商业化合作。
 
 ### 1.1 快速体验地址
-- 体验地址 http://117.51.146.109:8080  账号密码 admin/admin
+
+- 体验地址 http://117.51.150.133:8080  账号密码 admin/admin
 
 ### 1.2 体验地图
 相比较于同类产品的用户视角单一（大多为管理员视角），滴滴Logi-KafkaManager建立了基于分角色、多场景视角的体验地图。分别是：**用户体验地图、运维体验地图、运营体验地图**
@@ -54,38 +55,56 @@
 ## 2 相关文档
 
 ### 2.1 产品文档
-- [滴滴Logi-KafkaManager 安装手册](docs/install_guide/install_guide_cn.md)
-- [滴滴Logi-KafkaManager 接入集群](docs/user_guide/add_cluster/add_cluster.md)
-- [滴滴Logi-KafkaManager 用户使用手册](docs/user_guide/user_guide_cn.md)
-- [滴滴Logi-KafkaManager FAQ](docs/user_guide/faq.md)
+- [滴滴LogiKM 安装手册](docs/install_guide/install_guide_cn.md)
+- [滴滴LogiKM 接入集群](docs/user_guide/add_cluster/add_cluster.md)
+- [滴滴LogiKM 用户使用手册](docs/user_guide/user_guide_cn.md)
+- [滴滴LogiKM FAQ](docs/user_guide/faq.md)
 
 ### 2.2 社区文章
 - [滴滴云官网产品介绍](https://www.didiyun.com/production/logi-KafkaManager.html)
 - [7年沉淀之作--滴滴Logi日志服务套件](https://mp.weixin.qq.com/s/-KQp-Qo3WKEOc9wIR2iFnw)
-- [滴滴Logi-KafkaManager 一站式Kafka监控与管控平台](https://mp.weixin.qq.com/s/9qSZIkqCnU6u9nLMvOOjIQ)
-- [滴滴Logi-KafkaManager 开源之路](https://xie.infoq.cn/article/0223091a99e697412073c0d64)
-- [滴滴Logi-KafkaManager 系列视频教程](https://mp.weixin.qq.com/s/9X7gH0tptHPtfjPPSdGO8g)
-- [kafka实践（十五）：滴滴开源Kafka管控平台 Logi-KafkaManager研究--A叶子叶来](https://blog.csdn.net/yezonggang/article/details/113106244)
+- [滴滴LogiKM 一站式Kafka监控与管控平台](https://mp.weixin.qq.com/s/9qSZIkqCnU6u9nLMvOOjIQ)
+- [滴滴LogiKM 开源之路](https://xie.infoq.cn/article/0223091a99e697412073c0d64)
+- [滴滴LogiKM 系列视频教程](https://space.bilibili.com/442531657/channel/seriesdetail?sid=571649)
+- [kafka最强最全知识图谱](https://www.szzdzhp.com/kafka/)
+- [滴滴LogiKM新用户入门系列文章专栏 --石臻臻](https://www.szzdzhp.com/categories/LogIKM/)
+- [kafka实践（十五）：滴滴开源Kafka管控平台 LogiKM研究--A叶子叶来](https://blog.csdn.net/yezonggang/article/details/113106244)
+- [基于云原生应用管理平台Rainbond安装 滴滴LogiKM](https://www.rainbond.com/docs/opensource-app/logikm/?channel=logikm)
 
 ## 3 滴滴Logi开源用户交流群
 
-
 ![image](https://user-images.githubusercontent.com/5287750/111266722-e531d800-8665-11eb-9242-3484da5a3099.png)  
-微信加群：关注公众号 Obsuite(官方公众号) 回复 "Logi加群"  
 
-![dingding_group](./docs/assets/images/common/dingding_group.jpg)  
-钉钉群ID：32821440
+想跟各个大佬交流Kafka Es 等中间件/大数据相关技术请 加微信进群。
 
+微信加群：添加<font color=red>mike_zhangliang</font>、<font color=red>danke-x</font>的微信号备注Logi加群或关注公众号 云原生可观测性 回复 "Logi加群"
 
-## 4 OCE认证
-OCE是一个认证机制和交流平台，为滴滴Logi-KafkaManager生产用户量身打造，我们会为OCE企业提供更好的技术支持，比如专属的技术沙龙、企业一对一的交流机会、专属的答疑群等，如果贵司Logi-KafkaManager上了生产，[快来加入吧](http://obsuite.didiyun.com/open/openAuth)
+## 4 知识星球
 
+<img width="447" alt="image" src="https://user-images.githubusercontent.com/71620349/147314042-843a371a-48c0-4d9a-a65e-ca40236f3300.png">
+
+<br>
+<center>
+  ✅我们正在组建国内最大最权威的
+</center>
+<br>
+<center>
+<font color=red size=5><b>【Kafka中文社区】</b></font>
+</center>
+  
+在这里你可以结交各大互联网Kafka大佬以及3000+Kafka爱好者，一起实现知识共享，实时掌控最新行业资讯，期待您的加入中～https://z.didi.cn/5gSF9  
+
+<font color=red size=5>有问必答~！  </font>
+
+<font color=red size=5>互动有礼~！  </font>
+
+PS:提问请尽量把问题一次性描述清楚，并告知环境信息情况哦～！如使用版本、操作步骤、报错/警告信息等，方便大V们快速解答～
 
 ## 5 项目成员
 
 ### 5.1 内部核心人员
 
-`iceyuhui`、`liuyaguang`、`limengmonty`、`zhangliangmike`、`nullhuangyiming`、`zengqiao`、`eilenexuzhe`、`huangjiaweihjw`、`zhaoyinrui`、`marzkonglingxu`、`joysunchao`
+`iceyuhui`、`liuyaguang`、`limengmonty`、`zhangliangmike`、`zhaoqingrong`、`xiepeng`、`nullhuangyiming`、`zengqiao`、`eilenexuzhe`、`huangjiaweihjw`、`zhaoyinrui`、`marzkonglingxu`、`joysunchao`、`石臻臻`
 
 
 ### 5.2 外部贡献者
@@ -95,4 +114,4 @@ OCE是一个认证机制和交流平台，为滴滴Logi-KafkaManager生产用户
 
 ## 6 协议
 
-`kafka-manager`基于`Apache-2.0`协议进行分发和使用，更多信息参见[协议文件](./LICENSE)
+`LogiKM`基于`Apache-2.0`协议进行分发和使用，更多信息参见[协议文件](./LICENSE)

Releases_Notes.md

@@ -7,6 +7,83 @@
 
 --- 
 
+## v2.6.0
+
+版本上线时间：2022-01-24
+
+### 能力提升
+- 增加简单回退工具类
+
+### 体验优化
+- 补充周期任务说明文档
+- 补充集群安装部署使用说明文档
+- 升级Swagger、SpringFramework、SpringBoot、EChats版本
+- 优化Task模块的日志输出
+- 优化corn表达式解析失败后退出无任何日志提示问题
+- Ldap用户接入时，增加部门及邮箱信息等
+- 对Jmx模块，增加连接失败后的回退机制及错误日志优化
+- 增加线程池、客户端池可配置
+- 删除无用的jmx_prometheus_javaagent-0.14.0.jar
+- 优化迁移任务名称
+- 优化创建Region时，Region容量信息不能立即被更新问题
+- 引入lombok
+- 更新视频教程
+- 优化kcm_script.sh脚本中的LogiKM地址为可通过程序传入
+- 第三方接口及网关接口，增加是否跳过登录的开关
+- extends模块相关配置调整为非必须在application.yml中配置
+
+### bug修复
+- 修复批量往DB写入空指标数组时报SQL语法异常的问题
+- 修复网关增加配置及修改配置时，version不变化问题
+- 修复集群列表页，提示框遮挡问题
+- 修复对高版本Broker元信息协议解析失败的问题
+- 修复Dockerfile执行时提示缺少application.yml文件的问题
+- 修复逻辑集群更新时，会报空指针的问题
+
+## v2.4.1+
+
+版本上线时间：2021-05-21
+
+### 能力提升
+- 增加直接增加权限和配额的接口(v2.4.1)
+- 增加接口调用可绕过登录的功能(v2.4.1)
+
+### 体验优化
+- tomcat 版本提升至8.5.66(v2.4.2)
+- op接口优化，拆分util接口为topic、leader两类接口(v2.4.1)
+- 简化Gateway配置的Key长度(v2.4.1)
+
+### bug修复
+- 修复页面展示版本错误问题(v2.4.2)
+
+
+## v2.4.0
+
+版本上线时间：2021-05-18
+
+
+### 能力提升
+
+- 增加App与Topic自动化审批开关
+- Broker元信息中增加Rack信息
+- 升级MySQL 驱动，支持MySQL 8+
+- 增加操作记录查询界面
+
+### 体验优化
+
+- FAQ告警组说明优化
+- 用户手册共享及 独享集群概念优化
+- 用户管理界面，前端限制用户删除自己
+
+### bug修复
+
+- 修复op-util类中创建Topic失败的接口
+- 周期同步Topic到DB的任务修复，将Topic列表查询从缓存调整为直接查DB
+- 应用下线审批失败的功能修复，将权限为0(无权限)的数据进行过滤
+- 修复登录及权限绕过的漏洞
+- 修复研发角色展示接入集群、暂停监控等按钮的问题
+
+
 ## v2.3.0
 
 版本上线时间：2021-02-08

build.sh

@@ -1,72 +0,0 @@
-#!/bin/bash
-workspace=$(cd $(dirname $0) && pwd -P)
-cd $workspace
-
-## constant
-OUTPUT_DIR=./output
-KM_VERSION=2.3.1
-APP_NAME=kafka-manager
-APP_DIR=${APP_NAME}-${KM_VERSION}
-
-MYSQL_TABLE_SQL_FILE=./docs/install_guide/create_mysql_table.sql
-CONFIG_FILE=./kafka-manager-web/src/main/resources/application.yml
-
-## function
-function build() {
-    # 编译命令
-	  mvn -U clean package -Dmaven.test.skip=true
-
-    local sc=$?
-    if [ $sc -ne 0 ];then
-    	## 编译失败, 退出码为 非0
-        echo "$APP_NAME build error"
-        exit $sc
-    else
-        echo "$APP_NAME build ok"
-    fi
-}
-
-function make_output() {
-    # 新建output目录
-    rm -rf ${OUTPUT_DIR} &>/dev/null
-    mkdir -p ${OUTPUT_DIR}/${APP_DIR} &>/dev/null
-
-    # 填充output目录, output内的内容
-    (
-          cp -rf ${MYSQL_TABLE_SQL_FILE} ${OUTPUT_DIR}/${APP_DIR} &&       # 拷贝 sql 初始化脚本      至output目录
-          cp -rf ${CONFIG_FILE} ${OUTPUT_DIR}/${APP_DIR} &&                # 拷贝 application.yml   至output目录
-
-          # 拷贝程序包到output路径
-          cp kafka-manager-web/target/kafka-manager-web-${KM_VERSION}-SNAPSHOT.jar ${OUTPUT_DIR}/${APP_DIR}/${APP_NAME}.jar
-          echo -e "make output ok."
-    ) || { echo -e "make output error"; exit 2; } # 填充output目录失败后, 退出码为 非0
-}
-
-function make_package() {
-	# 压缩output目录
-	(
-	    cd ${OUTPUT_DIR} && tar cvzf ${APP_DIR}.tar.gz ${APP_DIR}
-      echo -e "make package ok."
-	) || { echo -e "make package error"; exit 2; } # 压缩output目录失败后, 退出码为 非0
-}
-
-##########################################
-## main
-## 其中,
-## 		1.进行编译
-##		2.生成部署包output
-##		3.生成tar.gz压缩包
-##########################################
-
-# 1.进行编译
-build
-
-# 2.生成部署包output
-make_output
-
-# 3.生成tar.gz压缩包
-make_package
-
-# 编译成功
-echo -e "build done"
-exit 0

container/dockerfiles/Dockerfile

@@ -1,44 +0,0 @@
-FROM openjdk:8-jdk-alpine3.9
-
-LABEL author="yangvipguang"
-
-ENV  VERSION 2.1.0
-ENV  JAR_PATH kafka-manager-web/target
-COPY $JAR_PATH/kafka-manager-web-$VERSION-SNAPSHOT.jar /tmp/app.jar
-COPY $JAR_PATH/application.yml  /km/
-
-RUN sed -i 's/dl-cdn.alpinelinux.org/mirrors.aliyun.com/g' /etc/apk/repositories
-RUN apk add --no-cache --virtual .build-deps \
-    font-adobe-100dpi \
-    ttf-dejavu \
-    fontconfig \ 
-    curl \
-    apr \
-    apr-util \
-    apr-dev \
-    tomcat-native \
-    && apk del .build-deps
-
-ENV AGENT_HOME /opt/agent/
-
-WORKDIR /tmp
-COPY docker-depends/config.yaml    $AGENT_HOME
-COPY docker-depends/jmx_prometheus_javaagent-0.14.0.jar $AGENT_HOME
-
-ENV JAVA_AGENT="-javaagent:$AGENT_HOME/jmx_prometheus_javaagent-0.14.0.jar=9999:$AGENT_HOME/config.yaml"
-
-ENV JAVA_HEAP_OPTS="-Xms1024M -Xmx1024M -Xmn100M "
-
-ENV JAVA_OPTS="-verbose:gc  \
-               -XX:+PrintGC -XX:+PrintGCDetails -XX:+PrintHeapAtGC -Xloggc:/tmp/gc.log -XX:+PrintGCDateStamps  -XX:+PrintGCTimeStamps \
-               -XX:MaxMetaspaceSize=256M  -XX:+DisableExplicitGC -XX:+UseStringDeduplication \
-               -XX:+UseG1GC  -XX:+HeapDumpOnOutOfMemoryError   -XX:-UseContainerSupport" 
-#-Xlog:gc -Xlog:gc* -Xlog:gc+heap=trace  -Xlog:safepoint
-
-EXPOSE 8080  9999
-
-ENTRYPOINT ["sh","-c","java     -jar    $JAVA_HEAP_OPTS  $JAVA_OPTS /tmp/app.jar --spring.config.location=/km/application.yml"]
-
-## 默认不带Prometheus JMX监控，需要可以自行取消以下注释并注释上面一行默认Entrypoint 命令。
-## ENTRYPOINT ["sh","-c","java     -jar  $JAVA_AGENT  $JAVA_HEAP_OPTS  $JAVA_OPTS /tmp/app.jar --spring.config.location=/km/application.yml"]
-

container/dockerfiles/mysql/Dockerfile

@@ -0,0 +1,13 @@
+FROM mysql:5.7.37
+
+COPY mysqld.cnf /etc/mysql/mysql.conf.d/
+ENV TZ=Asia/Shanghai
+ENV MYSQL_ROOT_PASSWORD=root
+
+RUN apt-get update \
+    && apt -y install wget \
+    && wget https://ghproxy.com/https://raw.githubusercontent.com/didi/LogiKM/master/distribution/conf/create_mysql_table.sql -O /docker-entrypoint-initdb.d/create_mysql_table.sql
+
+EXPOSE 3306
+
+VOLUME ["/var/lib/mysql"]

container/dockerfiles/mysql/mysqld.cnf

@@ -0,0 +1,24 @@
+[client]
+default-character-set = utf8  
+
+[mysqld]
+character_set_server = utf8  
+pid-file        = /var/run/mysqld/mysqld.pid
+socket          = /var/run/mysqld/mysqld.sock
+datadir         = /var/lib/mysql
+symbolic-links=0
+
+max_allowed_packet = 10M
+sort_buffer_size = 1M
+read_rnd_buffer_size = 2M
+max_connections=2000
+
+lower_case_table_names=1
+character-set-server=utf8
+
+max_allowed_packet = 1G
+sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
+group_concat_max_len = 102400
+default-time-zone = '+08:00'
+[mysql]
+default-character-set = utf8

container/helm/Chart.lock

@@ -0,0 +1,6 @@
+dependencies:
+- name: mysql
+  repository: https://charts.bitnami.com/bitnami
+  version: 8.6.3
+digest: sha256:d250c463c1d78ba30a24a338a06a551503c7a736621d974fe4999d2db7f6143e
+generated: "2021-06-24T11:34:54.625217+08:00"

container/helm/Chart.yaml

@@ -1,6 +1,6 @@
 apiVersion: v2
 name: didi-km
-description: A Helm chart for Kubernetes
+description: Logi-KafkaManager
 
 # A chart can be either an 'application' or a 'library' chart.
 #
@@ -21,4 +21,9 @@ version: 0.1.0
 # incremented each time you make changes to the application. Versions are not expected to
 # follow Semantic Versioning. They should reflect the version the application is using.
 # It is recommended to use it with quotes.
-appVersion: "1.16.0"
+appVersion: "2.4.2"
+dependencies:
+  - condition: mysql.enabled
+    name: mysql
+    repository: https://charts.bitnami.com/bitnami
+    version: 8.x.x

container/helm/templates/configmap.yaml

@@ -1,7 +1,17 @@
+{{- define "datasource.mysql" -}}
+{{- if .Values.mysql.enabled }}
+    {{- printf "%s-mysql" (include "didi-km.fullname" .) -}}
+{{- else -}}
+    {{- printf "%s" .Values.externalDatabase.host -}}
+{{- end -}}
+{{- end -}}
+
 apiVersion: v1
 kind: ConfigMap
 metadata:
-  name: km-cm
+  name: {{ include "didi-km.fullname" . }}-configs
+  labels:
+    {{- include "didi-km.labels" . | nindent 4 }}
 data:
   application.yml: |
     server:
@@ -17,9 +27,9 @@ data:
         name: kafkamanager
       datasource:
         kafka-manager:
-          jdbc-url: jdbc:mysql://xxxxx:3306/kafka-manager?characterEncoding=UTF-8&serverTimezone=GMT%2B8&useSSL=false
-          username: admin
-          password: admin
+          jdbc-url: jdbc:mysql://{{ include "datasource.mysql" . }}:3306/{{ .Values.mysql.auth.database }}?characterEncoding=UTF-8&serverTimezone=GMT%2B8&useSSL=false
+          username: {{ .Values.mysql.auth.username }}
+          password: {{ .Values.mysql.auth.password }}
           driver-class-name: com.mysql.jdbc.Driver
       main:
         allow-bean-definition-overriding: true
@@ -45,7 +55,7 @@ data:
         didi:
           app-topic-metrics-enabled: false
           topic-request-time-metrics-enabled: false
-          topic-throttled-metrics: false
+          topic-throttled-metrics-enabled: false
         save-days: 7
 
     # 任务相关的开关
@@ -54,7 +64,19 @@ data:
         sync-topic-enabled: false # 未落盘的Topic定期同步到DB中
 
     account:
+      # ldap settings
       ldap:
+        enabled: false
+        url: ldap://127.0.0.1:389/
+        basedn: dc=tsign,dc=cn
+        factory: com.sun.jndi.ldap.LdapCtxFactory
+        filter: sAMAccountName
+        security:
+          authentication: simple
+          principal: cn=admin,dc=tsign,dc=cn
+          credentials: admin
+        auth-user-registration: false
+        auth-user-registration-role: normal
 
     kcm:
       enabled: false

container/helm/templates/deployment.yaml

@@ -42,6 +42,10 @@ spec:
             protocol: TCP
           resources:
             {{- toYaml .Values.resources | nindent 12 }}
+          volumeMounts:
+          - name: configs
+            mountPath: /tmp/application.yml
+            subPath:  application.yml
       {{- with .Values.nodeSelector }}
       nodeSelector:
         {{- toYaml . | nindent 8 }}
@@ -54,3 +58,7 @@ spec:
       tolerations:
         {{- toYaml . | nindent 8 }}
       {{- end }}
+      volumes:
+      - name: configs
+        configMap:
+          name: {{ include "didi-km.fullname" . }}-configs

container/helm/values.yaml

@@ -5,13 +5,14 @@
 replicaCount: 1
 
 image:
-  repository: docker.io/yangvipguang/km
+  repository: docker.io/fengxsong/logi-kafka-manager
   pullPolicy: IfNotPresent
   # Overrides the image tag whose default is the chart appVersion.
-  tag: "v18"
+  tag: "v2.4.2"
 
 imagePullSecrets: []
 nameOverride: ""
+# fullnameOverride must set same as release name
 fullnameOverride: "km"
 
 serviceAccount:
@@ -59,10 +60,10 @@ resources:
   # resources, such as Minikube. If you do want to specify resources, uncomment the following
   # lines, adjust them as necessary, and remove the curly braces after 'resources:'.
   limits:
-    cpu: 50m
+    cpu: 500m
     memory: 2048Mi
   requests:
-    cpu: 10m
+    cpu: 100m
     memory: 200Mi
 
 autoscaling:
@@ -77,3 +78,16 @@ nodeSelector: {}
 tolerations: []
 
 affinity: {}
+
+# more configurations are set with configmap in file template/configmap.yaml
+externalDatabase:
+  host: ""
+mysql:
+  # if enabled is set to false, then you should manually specified externalDatabase.host
+  enabled: true
+  architecture: standalone
+  auth:
+    rootPassword: "s3cretR00t"
+    database: "logi_kafka_manager"
+    username: "logi_kafka_manager"
+    password: "n0tp@55w0rd"

distribution/bin/shutdown.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+cd `dirname $0`/../target
+target_dir=`pwd`
+
+pid=`ps ax | grep -i 'kafka-manager' | grep ${target_dir} | grep java | grep -v grep | awk '{print $1}'`
+if [ -z "$pid" ] ; then
+        echo "No kafka-manager running."
+        exit -1;
+fi
+
+echo "The kafka-manager (${pid}) is running..."
+
+kill ${pid}
+
+echo "Send shutdown request to kafka-manager (${pid}) OK"

distribution/bin/startup.sh

@@ -0,0 +1,81 @@
+error_exit ()
+{
+    echo "ERROR: $1 !!"
+    exit 1
+}
+
+[ ! -e "$JAVA_HOME/bin/java" ] && JAVA_HOME=$HOME/jdk/java
+[ ! -e "$JAVA_HOME/bin/java" ] && JAVA_HOME=/usr/java
+[ ! -e "$JAVA_HOME/bin/java" ] && unset JAVA_HOME
+
+if [ -z "$JAVA_HOME" ]; then
+  if $darwin; then
+
+    if [ -x '/usr/libexec/java_home' ] ; then
+      export JAVA_HOME=`/usr/libexec/java_home`
+
+    elif [ -d "/System/Library/Frameworks/JavaVM.framework/Versions/CurrentJDK/Home" ]; then
+      export JAVA_HOME="/System/Library/Frameworks/JavaVM.framework/Versions/CurrentJDK/Home"
+    fi
+  else
+    JAVA_PATH=`dirname $(readlink -f $(which javac))`
+    if [ "x$JAVA_PATH" != "x" ]; then
+      export JAVA_HOME=`dirname $JAVA_PATH 2>/dev/null`
+    fi
+  fi
+  if [ -z "$JAVA_HOME" ]; then
+        error_exit "Please set the JAVA_HOME variable in your environment, We need java(x64)! jdk8 or later is better!"
+  fi
+fi
+
+
+
+
+export WEB_SERVER="kafka-manager"
+export JAVA_HOME
+export JAVA="$JAVA_HOME/bin/java"
+export BASE_DIR=`cd $(dirname $0)/..; pwd`
+export CUSTOM_SEARCH_LOCATIONS=file:${BASE_DIR}/conf/
+
+
+#===========================================================================================
+# JVM Configuration
+#===========================================================================================
+
+JAVA_OPT="${JAVA_OPT} -server -Xms2g -Xmx2g -Xmn1g -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=320m"
+JAVA_OPT="${JAVA_OPT} -XX:-OmitStackTraceInFastThrow -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=${BASE_DIR}/logs/java_heapdump.hprof"
+
+## jdk版本高的情况 有些 参数废弃了
+JAVA_MAJOR_VERSION=$($JAVA -version 2>&1 | sed -E -n 's/.* version "([0-9]*).*$/\1/p')
+if [[ "$JAVA_MAJOR_VERSION" -ge "9" ]] ; then
+  JAVA_OPT="${JAVA_OPT} -Xlog:gc*:file=${BASE_DIR}/logs/km_gc.log:time,tags:filecount=10,filesize=102400"
+else
+  JAVA_OPT="${JAVA_OPT} -Djava.ext.dirs=${JAVA_HOME}/jre/lib/ext:${JAVA_HOME}/lib/ext"
+  JAVA_OPT="${JAVA_OPT} -Xloggc:${BASE_DIR}/logs/km_gc.log -verbose:gc -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+PrintGCTimeStamps -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=10 -XX:GCLogFileSize=100M"
+
+fi
+
+JAVA_OPT="${JAVA_OPT} -jar ${BASE_DIR}/target/${WEB_SERVER}.jar"
+JAVA_OPT="${JAVA_OPT} --spring.config.additional-location=${CUSTOM_SEARCH_LOCATIONS}"
+JAVA_OPT="${JAVA_OPT} --logging.config=${BASE_DIR}/conf/logback-spring.xml"
+JAVA_OPT="${JAVA_OPT} --server.max-http-header-size=524288"
+
+
+
+if [ ! -d "${BASE_DIR}/logs" ]; then
+  mkdir ${BASE_DIR}/logs
+fi
+
+echo "$JAVA ${JAVA_OPT}"
+
+# check the start.out log output file
+if [ ! -f "${BASE_DIR}/logs/start.out" ]; then
+  touch "${BASE_DIR}/logs/start.out"
+fi
+# start
+echo -e "---- 启动脚本 ------\n $JAVA ${JAVA_OPT}" > ${BASE_DIR}/logs/start.out 2>&1 &
+
+
+nohup $JAVA ${JAVA_OPT} >> ${BASE_DIR}/logs/start.out 2>&1 &
+
+echo "${WEB_SERVER} is starting，you can check the ${BASE_DIR}/logs/start.out"

distribution/conf/application-docker.yml

@@ -0,0 +1,28 @@
+
+## kafka-manager的配置文件，该文件中的配置会覆盖默认配置
+## 下面的配置信息基本就是jar中的 application.yml默认配置了;
+## 可以只修改自己变更的配置,其他的删除就行了; 比如只配置一下mysql
+
+
+server:
+  port: 8080
+  tomcat:
+    accept-count: 1000
+    max-connections: 10000
+    max-threads: 800
+    min-spare-threads: 100
+
+spring:
+  application:
+    name: kafkamanager
+    version: 2.6.0
+  profiles:
+    active: dev
+  datasource:
+    kafka-manager:
+      jdbc-url: jdbc:mysql://${LOGI_MYSQL_HOST:mysql}:${LOGI_MYSQL_PORT:3306}/${LOGI_MYSQL_DATABASE:logi_kafka_manager}?characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8
+      username: ${LOGI_MYSQL_USER:root}
+      password: ${LOGI_MYSQL_PASSWORD:root}
+      driver-class-name: com.mysql.cj.jdbc.Driver
+  main:
+    allow-bean-definition-overriding: true

distribution/conf/application.yml

@@ -0,0 +1,28 @@
+
+## kafka-manager的配置文件，该文件中的配置会覆盖默认配置
+## 下面的配置信息基本就是jar中的 application.yml默认配置了;
+## 可以只修改自己变更的配置,其他的删除就行了; 比如只配置一下mysql
+
+
+server:
+  port: 8080
+  tomcat:
+    accept-count: 1000
+    max-connections: 10000
+    max-threads: 800
+    min-spare-threads: 100
+
+spring:
+  application:
+    name: kafkamanager
+  profiles:
+    active: dev
+  datasource:
+    kafka-manager:
+      jdbc-url: jdbc:mysql://localhost:3306/logi_kafka_manager?characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8
+      username: root
+      password: 123456
+      driver-class-name: com.mysql.cj.jdbc.Driver
+  main:
+    allow-bean-definition-overriding: true
+

distribution/conf/application.yml.example

@@ -0,0 +1,135 @@
+
+## kafka-manager的配置文件，该文件中的配置会覆盖默认配置
+## 下面的配置信息基本就是jar中的 application.yml默认配置了;
+## 可以只修改自己变更的配置,其他的删除就行了; 比如只配置一下mysql
+
+
+server:
+  port: 8080
+  tomcat:
+    accept-count: 1000
+    max-connections: 10000
+    max-threads: 800
+    min-spare-threads: 100
+
+spring:
+  application:
+    name: kafkamanager
+  profiles:
+    active: dev
+  datasource:
+    kafka-manager:
+      jdbc-url: jdbc:mysql://localhost:3306/logi_kafka_manager?characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8
+      username: root
+      password: 123456
+      driver-class-name: com.mysql.cj.jdbc.Driver
+  main:
+    allow-bean-definition-overriding: true
+
+  servlet:
+    multipart:
+      max-file-size: 100MB
+      max-request-size: 100MB
+
+logging:
+  config: classpath:logback-spring.xml
+
+custom:
+  idc: cn
+  store-metrics-task:
+    community:
+      topic-metrics-enabled: true
+    didi: # 滴滴Kafka特有的指标
+      app-topic-metrics-enabled: false
+      topic-request-time-metrics-enabled: false
+      topic-throttled-metrics-enabled: false
+
+# 任务相关的配置
+task:
+  op:
+    sync-topic-enabled: false                       # 未落盘的Topic定期同步到DB中
+    order-auto-exec:                                # 工单自动化审批线程的开关
+      topic-enabled: false                          # Topic工单自动化审批开关, false:关闭自动化审批, true:开启
+      app-enabled: false                            # App工单自动化审批开关, false:关闭自动化审批, true:开启
+  metrics:
+    collect:                                # 收集指标
+      broker-metrics-enabled: true          # 收集Broker指标
+    sink:                                       # 上报指标
+      cluster-metrics:                          # 上报cluster指标
+        sink-db-enabled: true                   # 上报到db
+      broker-metrics:                           # 上报broker指标
+        sink-db-enabled: true                   # 上报到db
+    delete:                                           # 删除指标
+      delete-limit-size: 1000                         # 单次删除的批大小
+      cluster-metrics-save-days: 14                   # 集群指标保存天数
+      broker-metrics-save-days: 14                    # Broker指标保存天数
+      topic-metrics-save-days: 7                      # Topic指标保存天数
+      topic-request-time-metrics-save-days: 7         # Topic请求耗时指标保存天数
+      topic-throttled-metrics-save-days: 7            # Topic限流指标保存天数
+      app-topic-metrics-save-days: 7                  # App+Topic指标保存天数
+
+thread-pool:
+  collect-metrics:
+    thread-num: 256  # 收集指标线程池大小
+    queue-size: 5000 # 收集指标线程池的queue大小
+  api-call:
+    thread-num: 16   # api服务线程池大小
+    queue-size: 5000 # api服务线程池的queue大小
+
+client-pool:
+  kafka-consumer:
+    min-idle-client-num: 24       # 最小空闲客户端数
+    max-idle-client-num: 24       # 最大空闲客户端数
+    max-total-client-num: 24      # 最大客户端数
+    borrow-timeout-unit-ms: 3000  # 租借超时时间，单位毫秒
+
+account:
+  jump-login:
+    gateway-api: false            # 网关接口
+    third-part-api: false         # 第三方接口
+  ldap:
+    enabled: false
+    url: ldap://127.0.0.1:389/
+    basedn: dc=tsign,dc=cn
+    factory: com.sun.jndi.ldap.LdapCtxFactory
+    filter: sAMAccountName
+    security:
+      authentication: simple
+      principal: cn=admin,dc=tsign,dc=cn
+      credentials: admin
+    auth-user-registration: true
+    auth-user-registration-role: normal
+
+kcm:                                  # 集群安装部署，仅安装broker
+  enabled: false                      # 是否开启
+  s3:                                   # s3 存储服务
+    endpoint: s3.didiyunapi.com
+    access-key: 1234567890
+    secret-key: 0987654321
+    bucket: logi-kafka
+  n9e:                                  # 夜莺
+    base-url: http://127.0.0.1:8004     # 夜莺job服务地址
+    user-token: 12345678                # 用户的token
+    timeout: 300                        # 当台操作的超时时间
+    account: root                       # 操作时使用的账号
+    script-file: kcm_script.sh          # 脚本，已内置好，在源码的kcm模块内，此处配置无需修改
+    logikm-url: http://127.0.0.1:8080   # logikm部署地址，部署时kcm_script.sh会调用logikm检查部署中的一些状态
+
+monitor:
+  enabled: false
+  n9e:
+    nid: 2
+    user-token: 1234567890
+    mon:
+      base-url: http://127.0.0.1:8000 # 夜莺v4版本，默认端口统一调整为了8000
+    sink:
+      base-url: http://127.0.0.1:8000 # 夜莺v4版本，默认端口统一调整为了8000
+    rdb:
+      base-url: http://127.0.0.1:8000 # 夜莺v4版本，默认端口统一调整为了8000
+
+notify:
+  kafka:
+    cluster-id: 95
+    topic-name: didi-kafka-notify
+  order:
+    detail-url: http://127.0.0.1

distribution/conf/create_mysql_table.sql

@@ -13,6 +13,9 @@ CREATE TABLE `account` (
   `username` varchar(128) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL DEFAULT '' COMMENT '用户名',
   `password` varchar(128) NOT NULL DEFAULT '' COMMENT '密码',
   `role` tinyint(8) NOT NULL DEFAULT '0' COMMENT '角色类型, 0:普通用户 1:研发 2:运维',
+  `department` varchar(256) DEFAULT '' COMMENT '部门名',
+  `display_name` varchar(256) DEFAULT '' COMMENT '用户姓名',
+  `mail` varchar(256) DEFAULT '' COMMENT '邮箱',
   `status` int(16) NOT NULL DEFAULT '0' COMMENT '0标识使用中，-1标识已废弃',
   `gmt_create` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
   `gmt_modify` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间',
@@ -210,11 +213,11 @@ CREATE TABLE `gateway_config` (
   PRIMARY KEY (`id`),
   UNIQUE KEY `uniq_type_name` (`type`,`name`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='gateway配置';
-INSERT INTO gateway_config(type, name, value, `version`) values('SERVICE_DISCOVERY_QUEUE_SIZE', 'SERVICE_DISCOVERY_QUEUE_SIZE', 100000000, 1);
-INSERT INTO gateway_config(type, name, value, `version`) values('SERVICE_DISCOVERY_APPID_RATE', 'SERVICE_DISCOVERY_APPID_RATE', 100000000, 1);
-INSERT INTO gateway_config(type, name, value, `version`) values('SERVICE_DISCOVERY_IP_RATE', 'SERVICE_DISCOVERY_IP_RATE', 100000000, 1);
-INSERT INTO gateway_config(type, name, value, `version`) values('SERVICE_DISCOVERY_SP_RATE', 'app_01234567', 100000000, 1);
-INSERT INTO gateway_config(type, name, value, `version`) values('SERVICE_DISCOVERY_SP_RATE', '192.168.0.1', 100000000, 1);
+INSERT INTO gateway_config(type, name, value, `version`, `description`) values('SD_QUEUE_SIZE', 'SD_QUEUE_SIZE', 100000000, 1, '任意集群队列大小');
+INSERT INTO gateway_config(type, name, value, `version`, `description`) values('SD_APP_RATE', 'SD_APP_RATE', 100000000, 1, '任意一个App限速');
+INSERT INTO gateway_config(type, name, value, `version`, `description`) values('SD_IP_RATE', 'SD_IP_RATE', 100000000, 1, '任意一个IP限速');
+INSERT INTO gateway_config(type, name, value, `version`, `description`) values('SD_SP_RATE', 'app_01234567', 100000000, 1, '指定App限速');
+INSERT INTO gateway_config(type, name, value, `version`, `description`) values('SD_SP_RATE', '192.168.0.1', 100000000, 1, '指定IP限速');
 
 --
 -- Table structure for table `heartbeat`
@@ -588,4 +591,7 @@ CREATE TABLE `work_order` (
   `gmt_create` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
   `gmt_modify` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间',
   PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='工单表';
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='工单表';
+
+
+ALTER TABLE `topic_connections` ADD COLUMN `client_id` VARCHAR(1024) NOT NULL DEFAULT '' COMMENT '客户端ID' AFTER `client_version`;

distribution/conf/logback-spring.xml

@@ -0,0 +1,215 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration scan="true" scanPeriod="10 seconds">
+    <contextName>logback</contextName>
+    <property name="log.path" value="./logs" />
+
+    <!-- 彩色日志 -->
+    <!-- 彩色日志依赖的渲染类 -->
+    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
+    <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
+    <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
+    <!-- 彩色日志格式 -->
+    <property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>
+
+    <!--输出到控制台-->
+    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
+        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+            <level>info</level>
+        </filter>
+        <encoder>
+            <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
+            <charset>UTF-8</charset>
+        </encoder>
+    </appender>
+
+
+    <!--输出到文件-->
+
+    <!-- 时间滚动输出 level为 DEBUG 日志 -->
+    <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <file>${log.path}/log_debug.log</file>
+        <!--日志文件输出格式-->
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+            <charset>UTF-8</charset> <!-- 设置字符集 -->
+        </encoder>
+        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+            <!-- 日志归档 -->
+            <fileNamePattern>${log.path}/log_debug_%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
+                <maxFileSize>100MB</maxFileSize>
+            </timeBasedFileNamingAndTriggeringPolicy>
+            <!--日志文件保留天数-->
+            <maxHistory>7</maxHistory>
+        </rollingPolicy>
+        <!-- 此日志文件只记录debug级别的 -->
+        <filter class="ch.qos.logback.classic.filter.LevelFilter">
+            <level>debug</level>
+            <onMatch>ACCEPT</onMatch>
+            <onMismatch>DENY</onMismatch>
+        </filter>
+    </appender>
+
+    <!-- 时间滚动输出 level为 INFO 日志 -->
+    <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <!-- 正在记录的日志文件的路径及文件名 -->
+        <file>${log.path}/log_info.log</file>
+        <!--日志文件输出格式-->
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+            <charset>UTF-8</charset>
+        </encoder>
+        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+            <!-- 每天日志归档路径以及格式 -->
+            <fileNamePattern>${log.path}/log_info_%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
+                <maxFileSize>100MB</maxFileSize>
+            </timeBasedFileNamingAndTriggeringPolicy>
+            <!--日志文件保留天数-->
+            <maxHistory>7</maxHistory>
+        </rollingPolicy>
+        <!-- 此日志文件只记录info级别的 -->
+        <filter class="ch.qos.logback.classic.filter.LevelFilter">
+            <level>info</level>
+            <onMatch>ACCEPT</onMatch>
+            <onMismatch>DENY</onMismatch>
+        </filter>
+    </appender>
+
+    <!-- 时间滚动输出 level为 WARN 日志 -->
+    <appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <!-- 正在记录的日志文件的路径及文件名 -->
+        <file>${log.path}/log_warn.log</file>
+        <!--日志文件输出格式-->
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
+        </encoder>
+        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+            <fileNamePattern>${log.path}/log_warn_%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
+                <maxFileSize>100MB</maxFileSize>
+            </timeBasedFileNamingAndTriggeringPolicy>
+            <!--日志文件保留天数-->
+            <maxHistory>7</maxHistory>
+        </rollingPolicy>
+        <!-- 此日志文件只记录warn级别的 -->
+        <filter class="ch.qos.logback.classic.filter.LevelFilter">
+            <level>warn</level>
+            <onMatch>ACCEPT</onMatch>
+            <onMismatch>DENY</onMismatch>
+        </filter>
+    </appender>
+
+
+    <!-- 时间滚动输出 level为 ERROR 日志 -->
+    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <!-- 正在记录的日志文件的路径及文件名 -->
+        <file>${log.path}/log_error.log</file>
+        <!--日志文件输出格式-->
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
+        </encoder>
+        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+            <fileNamePattern>${log.path}/log_error_%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
+                <maxFileSize>100MB</maxFileSize>
+            </timeBasedFileNamingAndTriggeringPolicy>
+            <!--日志文件保留天数-->
+            <maxHistory>7</maxHistory>
+        </rollingPolicy>
+        <!-- 此日志文件只记录ERROR级别的 -->
+        <filter class="ch.qos.logback.classic.filter.LevelFilter">
+            <level>ERROR</level>
+            <onMatch>ACCEPT</onMatch>
+            <onMismatch>DENY</onMismatch>
+        </filter>
+    </appender>
+
+    <!-- Metrics信息收集日志 -->
+    <appender name="COLLECTOR_METRICS_LOGGER" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <file>${log.path}/metrics/collector_metrics.log</file>
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+            <charset>UTF-8</charset>
+        </encoder>
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+            <fileNamePattern>${log.path}/metrics/collector_metrics_%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
+                <maxFileSize>100MB</maxFileSize>
+            </timeBasedFileNamingAndTriggeringPolicy>
+            <maxHistory>3</maxHistory>
+        </rollingPolicy>
+    </appender>
+
+    <!-- Metrics信息收集日志 -->
+    <appender name="API_METRICS_LOGGER" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <file>${log.path}/metrics/api_metrics.log</file>
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+            <charset>UTF-8</charset>
+        </encoder>
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+            <fileNamePattern>${log.path}/metrics/api_metrics_%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
+                <maxFileSize>100MB</maxFileSize>
+            </timeBasedFileNamingAndTriggeringPolicy>
+            <maxHistory>3</maxHistory>
+        </rollingPolicy>
+    </appender>
+
+    <!-- Metrics信息收集日志 -->
+    <appender name="SCHEDULED_TASK_LOGGER" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <file>${log.path}/metrics/scheduled_tasks.log</file>
+        <encoder>
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+            <charset>UTF-8</charset>
+        </encoder>
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+            <fileNamePattern>${log.path}/metrics/scheduled_tasks_%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
+                <maxFileSize>100MB</maxFileSize>
+            </timeBasedFileNamingAndTriggeringPolicy>
+            <maxHistory>5</maxHistory>
+        </rollingPolicy>
+    </appender>
+
+    <logger name="COLLECTOR_METRICS_LOGGER" level="DEBUG" additivity="false">
+        <appender-ref ref="COLLECTOR_METRICS_LOGGER"/>
+    </logger>
+    <logger name="API_METRICS_LOGGER" level="DEBUG" additivity="false">
+        <appender-ref ref="API_METRICS_LOGGER"/>
+    </logger>
+    <logger name="SCHEDULED_TASK_LOGGER" level="DEBUG" additivity="false">
+        <appender-ref ref="SCHEDULED_TASK_LOGGER"/>
+    </logger>
+
+    <logger name="org.apache.ibatis" level="INFO" additivity="false" />
+    <logger name="org.mybatis.spring" level="INFO" additivity="false" />
+    <logger name="com.github.miemiedev.mybatis.paginator" level="INFO" additivity="false" />
+
+    <root level="info">
+        <appender-ref ref="CONSOLE" />
+        <appender-ref ref="DEBUG_FILE" />
+        <appender-ref ref="INFO_FILE" />
+        <appender-ref ref="WARN_FILE" />
+        <appender-ref ref="ERROR_FILE" />
+        <!--<appender-ref ref="METRICS_LOG" />-->
+    </root>
+
+    <!--生产环境:输出到文件-->
+    <!--<springProfile name="pro">-->
+        <!--<root level="info">-->
+            <!--<appender-ref ref="CONSOLE" />-->
+            <!--<appender-ref ref="DEBUG_FILE" />-->
+            <!--<appender-ref ref="INFO_FILE" />-->
+            <!--<appender-ref ref="ERROR_FILE" />-->
+            <!--<appender-ref ref="WARN_FILE" />-->
+        <!--</root>-->
+    <!--</springProfile>-->
+</configuration>

distribution/conf/settings.xml

@@ -0,0 +1,10 @@
+<settings>
+    <mirrors>
+        <mirror>
+            <id>aliyunmaven</id>
+            <mirrorOf>*</mirrorOf>
+            <name>阿里云公共仓库</name>
+            <url>https://maven.aliyun.com/repository/public</url>
+        </mirror>
+    </mirrors>
+</settings>

distribution/pom.xml

@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+    <parent>
+        <artifactId>kafka-manager</artifactId>
+        <groupId>com.xiaojukeji.kafka</groupId>
+        <version>${kafka-manager.revision}</version>
+    </parent>
+
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>distribution</artifactId>
+    <name>distribution</name>
+    <packaging>pom</packaging>
+
+    <dependencies>
+        <dependency>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>kafka-manager-web</artifactId>
+            <version>${kafka-manager.revision}</version>
+        </dependency>
+    </dependencies>
+
+    <profiles>
+
+        <profile>
+            <id>release-kafka-manager</id>
+            <dependencies>
+                <dependency>
+                    <groupId>${project.groupId}</groupId>
+                    <artifactId>kafka-manager-web</artifactId>
+                    <version>${kafka-manager.revision}</version>
+                </dependency>
+            </dependencies>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-assembly-plugin</artifactId>
+                        <configuration>
+                            <descriptors>
+                                <descriptor>release-km.xml</descriptor>
+                            </descriptors>
+                            <tarLongFileMode>posix</tarLongFileMode>
+                        </configuration>
+                        <executions>
+                            <execution>
+                                <id>make-assembly</id>
+                                <phase>install</phase>
+                                <goals>
+                                    <goal>single</goal>
+                                </goals>
+                            </execution>
+                        </executions>
+                    </plugin>
+                </plugins>
+                <finalName>kafka-manager</finalName>
+            </build>
+        </profile>
+    </profiles>
+</project>

distribution/readme.md

@@ -0,0 +1,22 @@
+## 说明
+
+### 1.创建mysql数据库文件
+> conf/create_mysql_table.sql
+
+### 2. 修改配置文件
+> conf/application.yml.example
+> 请将application.yml.example 复制一份改名为application.yml；
+> 并放在同级目录下(conf/); 并修改成自己的配置
+> 这里的优先级比jar包内配置文件的默认值高; 
+> 
+
+### 3.启动/关闭kafka-manager
+> sh bin/startup.sh    启动
+> 
+> sh shutdown.sh       关闭
+> 
+
+
+### 4.升级jar包
+> 如果是升级, 可以看看文件 `upgrade_config.md` 的配置变更历史;
+> 

distribution/release-km.xml

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<assembly>
+    <id>${project.version}</id>
+    <includeBaseDirectory>true</includeBaseDirectory>
+    <formats>
+        <format>dir</format>
+        <format>tar.gz</format>
+        <format>zip</format>
+    </formats>
+    <fileSets>
+        <fileSet>
+            <includes>
+                <include>conf/**</include>
+            </includes>
+        </fileSet>
+
+        <fileSet>
+            <includes>
+                <include>bin/*</include>
+            </includes>
+            <fileMode>0755</fileMode>
+        </fileSet>
+    </fileSets>
+    <files>
+
+
+        <file>
+            <source>readme.md</source>
+            <destName>readme.md</destName>
+        </file>
+        <file>
+            <source>upgrade_config.md</source>
+            <destName>upgrade_config.md</destName>
+        </file>
+        <file>
+            <!--打好的jar包名称和放置目录-->
+            <source>../kafka-manager-web/target/kafka-manager.jar</source>
+            <outputDirectory>target/</outputDirectory>
+        </file>
+    </files>
+
+    <moduleSets>
+        <moduleSet>
+            <useAllReactorProjects>true</useAllReactorProjects>
+            <includes>
+                <include>com.xiaojukeji.kafka:kafka-manager-web</include>
+            </includes>
+        </moduleSet>
+    </moduleSets>
+</assembly>

distribution/upgrade_config.md

@@ -1,13 +1,17 @@
 
----
+## 版本升级配置变更
+> 本文件 从 V2.2.0 开始记录; 如果配置有变更则会填写到下文中; 如果没有,则表示无变更;
+> 当您从一个很低的版本升级时候,应该依次执行中间有过变更的sql脚本
+
 
-![kafka-manager-logo](../../assets/images/common/logo_name.png)
 
 **一站式`Apache Kafka`集群指标监控与运维管控平台**
 
 --- 
 
-# 升级至`2.2.0`版本
+### 1.升级至`V2.2.0`版本
+
+#### 1.mysql变更
 
 `2.2.0`版本在`cluster`表及`logical_cluster`各增加了一个字段，因此需要执行下面的sql进行字段的增加。
 
@@ -25,3 +29,24 @@ UPDATE `logical_cluster` SET `identification`=`name` WHERE id>=0;
 ALTER TABLE `logical_cluster` ADD INDEX `uniq_identification` (`identification` ASC);
 ```
 
+### 升级至`2.3.0`版本
+
+#### 1.mysql变更
+`2.3.0`版本在`gateway_config`表增加了一个描述说明的字段，因此需要执行下面的sql进行字段的增加。
+
+```sql
+ALTER TABLE `gateway_config` 
+ADD COLUMN `description` TEXT NULL COMMENT '描述信息' AFTER `version`;
+```
+
+### 升级至`2.6.0`版本
+
+#### 1.mysql变更
+`2.6.0`版本在`account`表增加用户姓名，部门名，邮箱三个字段，因此需要执行下面的sql进行字段的增加。
+
+```sql
+ALTER TABLE `account`
+ADD COLUMN `display_name` VARCHAR(256) NOT NULL DEFAULT '' COMMENT '用户名' AFTER `role`,
+ADD COLUMN `department` VARCHAR(256) NOT NULL DEFAULT '' COMMENT '部门名' AFTER `display_name`,
+ADD COLUMN `mail` VARCHAR(256) NOT NULL DEFAULT '' COMMENT '邮箱' AFTER `department`;
+```

docs/dev_guide/LogiKM单元测试和集成测试.md

@@ -0,0 +1,47 @@
+
+---
+
+![kafka-manager-logo](../assets/images/common/logo_name.png)
+
+**一站式`Apache Kafka`集群指标监控与运维管控平台**
+
+--- 
+
+
+# LogiKM单元测试和集成测试
+
+## 1、单元测试
+### 1.1 单元测试介绍
+单元测试又称模块测试，是针对软件设计的最小单位——程序模块进行正确性检验的测试工作。
+其目的在于检查每个程序单元能否正确实现详细设计说明中的模块功能、性能、接口和设计约束等要求，
+发现各模块内部可能存在的各种错误。单元测试需要从程序的内部结构出发设计测试用例。
+多个模块可以平行地独立进行单元测试。
+
+### 1.2 LogiKM单元测试思路
+LogiKM单元测试思路主要是测试Service层的方法，通过罗列方法的各种参数，
+判断方法返回的结果是否符合预期。单元测试的基类加了@SpringBootTest注解，即每次运行单测用例都启动容器
+
+### 1.3 LogiKM单元测试注意事项
+1. 单元测试用例在kafka-manager-core以及kafka-manager-extends下的test包中
+2. 配置在resources/application.yml，包括运行单元测试用例启用的数据库配置等等
+3. 编译打包项目时，加上参数-DskipTests可不执行测试用例，例如使用命令行mvn -DskipTests进行打包
+
+
+
+
+## 2、集成测试
+### 2.1 集成测试介绍
+集成测试又称组装测试，是一种黑盒测试。通常在单元测试的基础上，将所有的程序模块进行有序的、递增的测试。
+集成测试是检验程序单元或部件的接口关系，逐步集成为符合概要设计要求的程序部件或整个系统。
+
+### 2.2 LogiKM集成测试思路
+LogiKM集成测试主要思路是对Controller层的接口发送Http请求。
+通过罗列测试用例，模拟用户的操作，对接口发送Http请求，判断结果是否达到预期。
+本地运行集成测试用例时，无需加@SpringBootTest注解（即无需每次运行测试用例都启动容器）
+
+### 2.3 LogiKM集成测试注意事项
+1. 集成测试用例在kafka-manager-web的test包下 
+2. 因为对某些接口发送Http请求需要先登陆，比较麻烦，可以绕过登陆，方法可见教程见docs -> user_guide -> call_api_bypass_login
+3. 集成测试的配置在resources/integrationTest-settings.properties文件下，包括集群地址，zk地址的配置等等
+4. 如果需要运行集成测试用例，需要本地先启动LogiKM项目
+5. 编译打包项目时，加上参数-DskipTests可不执行测试用例，例如使用命令行mvn -DskipTests进行打包

docs/dev_guide/connect_jmx_failed.md

@@ -29,6 +29,7 @@
 - `JMX`配置错误：见`2、解决方法`。
 - 存在防火墙或者网络限制：网络通的另外一台机器`telnet`试一下看是否可以连接上。
 - 需要进行用户名及密码的认证：见`3、解决方法 —— 认证的JMX`。
+- 当logikm和kafka不在同一台机器上时,kafka的Jmx端口不允许其他机器访问:见`4、解决方法`。
 
 
 错误日志例子：
@@ -98,4 +99,9 @@ fi
 SQL的例子：
 ```sql
 UPDATE cluster SET jmx_properties='{ "maxConn": 10,	"username": "xxxxx", "password": "xxxx", "openSSL": false }' where id={xxx};
-```
+```
+### 4、解决方法 —— 不允许其他机器访问
+![1971b46243fe1d547063ee55b1505ed](https://user-images.githubusercontent.com/2869938/154413486-f6531946-8c4c-447e-aa2e-b112e5e623d6.png)
+
+该图中的127.0.0.1表明该端口只允许本机访问.
+在cdh中可以点击配置->搜索jmx->寻找broker_java_opts 修改com.sun.management.jmxremote.host和java.rmi.server.hostname为本机ip

docs/dev_guide/drawio/KCM实现原理.drawio

@@ -0,0 +1,89 @@
+<mxfile host="65bd71144e">
+    <diagram id="bhaMuW99Q1BzDTtcfRXp" name="Page-1">
+        <mxGraphModel dx="1138" dy="830" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="1169" pageHeight="827" math="0" shadow="0">
+            <root>
+                <mxCell id="0"/>
+                <mxCell id="1" parent="0"/>
+                <mxCell id="11" value="待部署Kafka-Broker的机器" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;labelPosition=center;verticalLabelPosition=bottom;align=center;verticalAlign=top;dashed=1;" vertex="1" parent="1">
+                    <mxGeometry x="380" y="240" width="320" height="240" as="geometry"/>
+                </mxCell>
+                <mxCell id="24" value="" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;labelPosition=center;verticalLabelPosition=bottom;align=center;verticalAlign=top;dashed=1;fillColor=#eeeeee;strokeColor=#36393d;" vertex="1" parent="1">
+                    <mxGeometry x="410" y="310" width="260" height="160" as="geometry"/>
+                </mxCell>
+                <mxCell id="6" style="edgeStyle=none;html=1;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" edge="1" parent="1" source="2" target="3">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="7" value="调用夜莺接口，&lt;br&gt;创建集群安装部署任务" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="6">
+                    <mxGeometry x="-0.0875" y="1" relative="1" as="geometry">
+                        <mxPoint x="9" y="1" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="9" style="edgeStyle=none;html=1;" edge="1" parent="1" source="2" target="4">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="10" value="通过版本管理，将Kafka的安装包，&lt;br&gt;server配置上传到s3中" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="9">
+                    <mxGeometry x="0.0125" y="2" relative="1" as="geometry">
+                        <mxPoint as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="2" value="LogiKM" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="40" y="100" width="120" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="12" style="edgeStyle=none;html=1;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;" edge="1" parent="1" source="3" target="5">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="13" value="1、下发任务脚本(kcm_script.sh)；&lt;br&gt;2、下发任务操作命令；" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="12">
+                    <mxGeometry x="-0.0731" y="2" relative="1" as="geometry">
+                        <mxPoint x="-2" y="-16" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="3" value="夜莺——任务中心" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;" vertex="1" parent="1">
+                    <mxGeometry x="480" y="100" width="120" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="4" value="S3" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="40" y="310" width="120" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="5" value="夜莺——Agent(&lt;font color=&quot;#ff3333&quot;&gt;代理执行kcm_script.sh脚本&lt;/font&gt;)" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#d5e8d4;strokeColor=#82b366;" vertex="1" parent="1">
+                    <mxGeometry x="400" y="260" width="280" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="22" style="edgeStyle=orthogonalEdgeStyle;html=1;entryX=1;entryY=0.5;entryDx=0;entryDy=0;fontColor=#FF3333;exitX=0;exitY=0.5;exitDx=0;exitDy=0;" edge="1" parent="1" source="14" target="4">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="25" value="下载安装包" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];fontColor=#000000;" vertex="1" connectable="0" parent="22">
+                    <mxGeometry x="0.2226" y="-2" relative="1" as="geometry">
+                        <mxPoint x="27" y="2" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="14" value="执行kcm_script.sh脚本：下载安装包" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#eeeeee;strokeColor=#36393d;" vertex="1" parent="1">
+                    <mxGeometry x="425" y="320" width="235" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="18" value="执行kcm_script.sh脚本：安装" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#eeeeee;strokeColor=#36393d;" vertex="1" parent="1">
+                    <mxGeometry x="425" y="350" width="235" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="19" value="执行kcm_script.sh脚本：检查安装结果" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#eeeeee;strokeColor=#36393d;" vertex="1" parent="1">
+                    <mxGeometry x="425" y="380" width="235" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="23" style="edgeStyle=orthogonalEdgeStyle;html=1;entryX=0.5;entryY=0;entryDx=0;entryDy=0;fontColor=#FF3333;exitX=1;exitY=0.5;exitDx=0;exitDy=0;" edge="1" parent="1" source="20" target="2">
+                    <mxGeometry relative="1" as="geometry">
+                        <Array as="points">
+                            <mxPoint x="770" y="420"/>
+                            <mxPoint x="770" y="40"/>
+                            <mxPoint x="100" y="40"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="26" value="检查副本同步状态" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];fontColor=#000000;" vertex="1" connectable="0" parent="23">
+                    <mxGeometry x="-0.3344" relative="1" as="geometry">
+                        <mxPoint as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="20" value="执行kcm_script.sh脚本：检查副本同步" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#eeeeee;strokeColor=#36393d;" vertex="1" parent="1">
+                    <mxGeometry x="425" y="410" width="235" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="21" value="执行kcm_script.sh脚本：结束" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#eeeeee;strokeColor=#36393d;" vertex="1" parent="1">
+                    <mxGeometry x="425" y="440" width="235" height="20" as="geometry"/>
+                </mxCell>
+            </root>
+        </mxGraphModel>
+    </diagram>
+</mxfile>

docs/dev_guide/dynamic_config_manager.md

@@ -14,6 +14,8 @@
 - 1、Topic定时同步任务
 - 2、专家服务——Topic分区热点
 - 3、专家服务——Topic分区不足
+- 4、专家服务——Topic资源治理
+- 5、账单配置
 
 
 ## 1、Topic定时同步任务
@@ -119,4 +121,49 @@ TOPIC_INSUFFICIENT_PARTITION_CONFIG
     50
   ]
 }
-```
+```
+## 4、专家服务——Topic资源治理
+
+首先，我们认为在一定的时间长度内，Topic的分区offset没有任何变化的Topic，即没有数据写入的Topic，为过期的Topic。
+
+Topic分区不足相关的动态配置(页面在运维管控->平台管理->配置管理)：
+
+配置Key：
+```
+EXPIRED_TOPIC_CONFIG
+```
+
+配置Value：
+```json
+{
+  "minExpiredDay": 30,  #过期时间大于此值才显示,
+  "filterRegex": ".*XXX\\s+", #忽略符合此正则规则的Topic
+  "ignoreClusterIdList": [  # 忽略的集群
+    50
+  ]
+}
+```
+
+## 5、账单配置
+
+Logi-KafkaManager除了作为Kafka运维管控平台之外，实际上还会有一些资源定价相关的功能。
+
+当前定价方式：当月Topic的maxAvgDay天的峰值的均值流量作为Topic的使用额度。使用的额度 * 单价 * 溢价(预留buffer) 就等于当月的费用。
+详细的计算逻辑见：com.xiaojukeji.kafka.manager.task.dispatch.biz.CalKafkaTopicBill; 和 com.xiaojukeji.kafka.manager.task.dispatch.biz.CalTopicStatistics;
+
+这块在计算Topic的费用的配置如下所示：
+
+配置Key：
+```
+KAFKA_TOPIC_BILL_CONFIG
+```
+
+配置Value：
+
+```json
+{ 
+  "maxAvgDay": 10, # 使用额度的计算规则
+  "quotaRatio": 1.5, # 溢价率
+  "priseUnitMB": 100 # 单价，即单MB/s流量多少钱
+}
+```

docs/dev_guide/upgrade_manual/logi-km-v2.3.0.md

@@ -1,17 +0,0 @@
-
----
-
-![kafka-manager-logo](../../assets/images/common/logo_name.png)
-
-**一站式`Apache Kafka`集群指标监控与运维管控平台**
-
---- 
-
-# 升级至`2.3.0`版本
-
-`2.3.0`版本在`gateway_config`表增加了一个描述说明的字段，因此需要执行下面的sql进行字段的增加。
-
-```sql
-ALTER TABLE `gateway_config` 
-ADD COLUMN `description` TEXT NULL COMMENT '描述信息' AFTER `version`;
-```

docs/dev_guide/周期任务说明文档.md

@@ -0,0 +1,39 @@
+---
+
+![kafka-manager-logo](../assets/images/common/logo_name.png)
+
+**一站式`Apache Kafka`集群指标监控与运维管控平台**
+
+--- 
+
+
+| 定时任务名称或方法名                   | 所在类                                 | 详细说明                                   | cron            | cron说明                                | 线程数量 |
+| -------------------------------------- | -------------------------------------- | ------------------------------------------ | --------------- | --------------------------------------- | -------- |
+| calKafkaBill                           | CalKafkaTopicBill                      | 计算Kafka使用账单                          | 0 0 1 * * ？    | 每天凌晨1点执行一次                     | 1        |
+| calRegionCapacity                      | CalRegionCapacity                      | 计算Region容量                             | 0 0 0/12 * * ？ | 每隔12小时执行一次，在0分钟0秒时触发    | 1        |
+| calTopicStatistics                     | CalTopicStatistics                     | 定时计算Topic统计数据                      | 0 0 0/4 * * ?   | 每隔4小时执行一次，在0分钟0秒时触发     | 5        |
+| flushBrokerTable                       | FlushBrokerTable                       | 定时刷新BrokerTable数据                    | 0 0 0/1 * * ?   | 每隔1小时执行一次，在0分钟0秒时触发     | 1        |
+| flushExpiredTopic                      | FlushExpiredTopic                      | 定期更新过期Topic                          | 0 0 0/5 * * ?   | 每隔5小时执行一次，在0分钟0秒时触发     | 1        |
+| syncClusterTaskState                   | SyncClusterTaskState                   | 同步更新集群任务状态                       | 0 0/1 * * * ?   | 每隔1分钟执行一次，在每分钟的0秒时触发  | 1        |
+| newCollectAndPublishCGData             | CollectAndPublishCGData                | 收集并发布消费者指标数据                   | 30 0/1 * * * ?  | 每隔1分钟执行一次，在每分钟的30秒时触发 | 10       |
+| collectAndPublishCommunityTopicMetrics | CollectAndPublishCommunityTopicMetrics | Topic社区指标收集                          | 31 0/1 * * * ?  | 每隔1分钟执行一次，在每分钟的30秒时触发 | 5        |
+| collectAndPublishTopicThrottledMetrics | CollectAndPublishTopicThrottledMetrics | 收集和发布Topic限流信息                    | 11 0/1 * * * ?  | 每隔1分钟执行一次，在每分钟的11秒时触发 | 5        |
+| deleteMetrics                          | DeleteMetrics                          | 定期删除Metrics信息                        | 0 0/2 * * * ?   | 每隔2分钟执行一次，在每分钟的0秒时触发  | 1        |
+| storeDiDiAppTopicMetrics               | StoreDiDiAppTopicMetrics               | JMX中获取appId维度的流量信息存DB           | 41 0/1 * * * ?  | 每隔1分钟执行一次，在每分钟的41秒时触发 | 5        |
+| storeDiDiTopicRequestTimeMetrics       | StoreDiDiTopicRequestTimeMetrics       | JMX中获取的TopicRequestTimeMetrics信息存DB | 51 0/1 * * * ?  | 每隔1分钟执行一次，在每分钟的51秒时触发 | 5        |
+| autoHandleTopicOrder                   | AutoHandleTopicOrder                   | 定时自动处理Topic相关工单                  | 0 0/1 * * * ?   | 每隔1分钟执行一次，在每分钟的0秒时触发  | 1        |
+| automatedHandleOrder                   | AutomatedHandleOrder                   | 工单自动化审批                             | 0 0/1 * * * ?   | 每隔1分钟执行一次，在每分钟的0秒时触发  | 1        |
+| flushReassignment                      | FlushReassignment                      | 定时处理分区迁移任务                       | 0 0/1 * * * ?   | 每隔1分钟执行一次，在每分钟的0秒时触发  | 1        |
+| syncTopic2DB                           | SyncTopic2DB                           | 定期将未落盘的Topic刷新到DB中              | 0 0/2 * * * ?   | 每隔2分钟执行一次，在每分钟的0秒时触发  | 1        |
+| sinkCommunityTopicMetrics2Monitor      | SinkCommunityTopicMetrics2Monitor      | 定时上报Topic监控指标                      | 1 0/1 * * * ?   | 每隔1分钟执行一次，在每分钟的1秒时触发  | 5        |
+| flush方法                              | LogicalClusterMetadataManager          | 定时刷新逻辑集群元数据到缓存中             | 0/30 * * * * ?  | 每隔30秒执行一次                        | 1        |
+| flush方法                              | AccountServiceImpl                     | 定时刷新account信息到缓存中                | 0/5 * * * * ?   | 每隔5秒执行一次                         | 1        |
+| ipFlush方法                            | HeartBeat                              | 定时获取管控平台所在机器IP等信息到DB       | 0/10 * * * * ?  | 每隔10秒执行一次                        | 1        |
+| flushTopicMetrics方法                  | FlushTopicMetrics                      | 定时刷新topic指标到缓存中                  | 5 0/1 * * * ?   | 每隔1分钟执行一次，在每分钟的5秒时触发  | 1        |
+| schedule方法                           | FlushBKConsumerGroupMetadata           | 定时刷新broker上消费组信息到缓存中         | 15 0/1 * * * ?  | 每隔1分钟执行一次，在每分钟的15秒时触发 |  1        |
+| flush方法                              | FlushClusterMetadata                   | 定时刷新物理集群元信息到缓存中             | 0/30 * * * * ?  | 每隔30秒执行一次                        | 1         |
+| flush方法                              | FlushTopicProperties                   | 定时刷新物理集群配置到缓存中               | 25 0/1 * * * ?  | 每隔1分钟执行一次，在每分钟的25秒时触发 | 1         |
+| schedule方法                           | FlushZKConsumerGroupMetadata           | 定时刷新zk上的消费组信息到缓存中           | 35 0/1 * * * ?  | 每隔1分钟执行一次，在每分钟的35秒时触发 | 1         |
+
+
+

docs/dev_guide/如何使用集群安装部署功能.md

@@ -0,0 +1,89 @@
+
+---
+
+![kafka-manager-logo](../assets/images/common/logo_name.png)
+
+**一站式`Apache Kafka`集群指标监控与运维管控平台**
+
+--- 
+
+# 如何使用集群安装部署功能？
+
+[TOC]
+
+## 1、实现原理
+
+![KCM实现原理](./assets/kcm/kcm_principle.png)
+
+- LogiKM上传安装包到S3服务；
+- LogiKM调用夜莺-Job服务接口，创建执行[kcm_script.sh](https://github.com/didi/LogiKM/blob/master/kafka-manager-extends/kafka-manager-kcm/src/main/resources/kcm_script.sh)脚本的任务，kcm_script.sh脚本是安装部署Kafka集群的脚本；
+- 夜莺将任务脚本下发到具体的机器上，通过夜莺Agent执行该脚本；
+- kcm_script.sh脚本会进行Kafka-Broker的安装部署；
+
+
+---
+
+## 2、使用方式
+
+### 2.1、第一步：修改配置
+
+**配置application.yml文件**
+```yaml
+# 
+kcm:
+  enabled: false                      # 是否开启，将其修改为true
+  s3:                                   # s3 存储服务
+    endpoint: s3.didiyunapi.com
+    access-key: 1234567890
+    secret-key: 0987654321
+    bucket: logi-kafka
+  n9e:                                  # 夜莺
+    base-url: http://127.0.0.1:8004     # 夜莺job服务地址
+    user-token: 12345678                # 用户的token
+    timeout: 300                        # 单台操作的超时时间
+    account: root                       # 操作时使用的账号
+    script-file: kcm_script.sh          # 脚本，已内置好，在源码的kcm模块内，此处配置无需修改
+    logikm-url: http://127.0.0.1:8080   # logikm部署地址，部署时kcm_script.sh会调用logikm检查部署中的一些状态，这里只需要填写 http://IP:PORT 就可以了
+
+
+account:
+  jump-login:
+    gateway-api: false            # 网关接口
+    third-part-api: false         # 第三方接口，将其修改为true，即允许未登录情况下调用开放的第三方接口
+```
+
+### 2.2、第二步：检查服务
+
+**检查s3服务**
+- 测试 "运维管控-》集群运维-》版本管理" 页面的上传，查看等功能是否都正常。如果存在不正常，则需要查看s3的配置是否正确；
+- 如果都没有问题，则上传Kafka的以.tgz结尾的安装包以及server.properties文件；
+  
+**检查夜莺Job服务**
+- 创建一个job任务，机器选择需要安装Kafka集群的机器，然后执行的命令是echo "Hello LogiKM"，看能否被成功执行。如果不行，则需要检查夜莺的安装；
+- 如果没有问题则表示夜莺和所需部署的机器之间的交互是没有问题的；
+
+### 2.3、第三步：接入集群
+
+在LogiKM的 “运维管控-》集群列表” 中接入需要安装部署的集群，**PS：此时是允许接入一个没有任何Broker的空的Kafka集群**，其中对的bootstrapServers配置搭建完成后的Kafka集群地址就可以了，而ZK地址必须和集群的server.properties中的ZK地址保持一致；
+
+### 2.4、第四步：部署集群
+
+- 打开LogiKM的 “运维管控-》集群运维-》集群任务” 页面，点击 “新建集群任务” 按钮；
+- 选择集群、任务类型、包版本、server配置及填写主机列表，然后点击确认，即可在夜莺的Job服务中心中创建一个任务出来。**PS：如果创建失败，可以看一下日志我为什么创建失败**；
+- 随后可以点击详情及状态对任务进行操作；
+
+### 2.5、可能问题
+
+#### 2.5.1、问题一：任务执行超时、失败等
+
+进入夜莺Job服务中心，查看对应的任务的相关日志；
+
+- 提示安装包下载失败，则需要查看对应的s3服务是否可以直接wget下载安装包，如果不可以则需要对kcm_script.sh脚本进行修改；
+- 提示调用LogiKM失败，则可以使用postman手动测试一下kcm_script.sh脚本调用LogiKM的那个接口是否有问题，如果存在问题则进行相应的修改；PS：具体接口见kcm_script.sh脚本
+
+
+## 3、备注说明
+
+- 集群安装部署，仅安装部署Kafka-Broker，不安装Kafka的ZK服务；
+- 安装部署中，有任何定制化的需求，例如修改安装的目录等，可以通过修改kcm_script.sh脚本实现；
+- kcm_script.sh脚本位置：[kcm_script.sh](https://github.com/didi/LogiKM/blob/master/kafka-manager-extends/kafka-manager-kcm/src/main/resources/kcm_script.sh)；

docs/dev_guide/如何增加上报监控系统指标.md

@@ -0,0 +1,53 @@
+
+---
+
+![kafka-manager-logo](../assets/images/common/logo_name.png)
+
+**一站式`Apache Kafka`集群指标监控与运维管控平台**
+
+--- 
+
+# 如何增加上报监控系统指标？
+
+## 0、前言
+
+LogiKM是 **一站式`Apache Kafka`集群指标监控与运维管控平台** ，当前会将消费Lag，Topic流量等指标上报到监控系统中，从而方便用户在监控系统中对这些指标配置监控告警规则，进而达到监控自身客户端是否正常的目的。
+
+那么，如果我们想增加一个新的监控指标，应该如何做呢，比如我们想监控Broker的流量，监控Broker的存活信息，监控集群Controller个数等等。
+
+在具体介绍之前，我们大家都知道，Kafka监控相关的信息，基本都存储于Broker、Jmx以及ZK中。当前LogiKM也已经具备从这三个地方获取数据的基本能力，因此基于LogiKM我们再获取其他指标，总体上还是非常方便的。
+
+这里我们就以已经获取到的Topic流量信息为例，看LogiKM如何实现Topic指标的获取并上报的。
+
+---
+
+## 1、确定指标位置
+
+基于对Kafka的了解，我们知道Topic流量信息这个指标是存储于Jmx中的，因此我们需要从Jmx中获取。大家如果对于自己所需要获取的指标存储在何处不太清楚的，可以加入我们维护的Kafka中文社区(README中有二维码)中今天沟通交流。
+
+---
+
+## 2、指标获取
+
+Topic流量指标的获取详细见图中说明。
+
+![Topic流量指标采集说明](./assets/increase_the_indicators_reported_to_monitor_system/collect_topic_metrics.jpg)
+
+---
+
+## 3、指标上报
+
+上一步我们已经采集到Topic流量指标了，下一步就是将该指标上报到监控系统，这块只需要按照监控系统要求的格式，将数据上报即可。
+
+LogiKM中有一个monitor模块，具体的如下图所示：
+
+![指标上报](./assets/increase_the_indicators_reported_to_monitor_system/sink_metrcis.png)
+
+
+## 4、补充说明 
+
+监控系统对接的相关内容见：
+
+[监控系统集成](./monitor_system_integrate_with_self.md)
+
+[监控系统集成例子——集成夜莺](./monitor_system_integrate_with_n9e.md)

docs/didi/Kafka主备切换流程简介.md

@@ -0,0 +1,97 @@
+
+---
+
+![kafka-manager-logo](../assets/images/common/logo_name.png)
+
+**一站式`Apache Kafka`集群指标监控与运维管控平台**
+
+--- 
+
+# Kafka主备切换流程简介
+
+## 1、客户端读写流程
+
+在介绍Kafka主备切换流程之前，我们先来了解一下客户端通过我们自研的网关的大致读写流程。
+
+![基于网关的生产消费流程](./assets/Kafka基于网关的生产消费流程.png)
+
+
+如上图所示，客户端读写流程大致为：
+1. 客户端：向网关请求Topic元信息；
+2. 网关：发现客户端使用的KafkaUser是A集群的KafkaUser，因此将Topic元信息请求转发到A集群；
+3. A集群：收到网关的Topic元信息，处理并返回给网关；
+4. 网关：将集群A返回的结果，返回给客户端；
+5. 客户端：从Topic元信息中，获取到Topic实际位于集群A，然后客户端会连接集群A进行生产消费；
+
+**备注：客户端为Kafka原生客户端，无任何定制。**
+
+---
+
+## 2、主备切换流程
+
+介绍完基于网关的客户端读写流程之后，我们再来看一下主备高可用版的Kafka，需要如何进行主备切换。
+
+### 2.1、大体流程
+
+![Kafka主备切换流程](./assets/Kafka主备切换流程.png)
+
+图有点多，总结起来就是：
+1. 先阻止客户端数据的读写；
+2. 等待主备数据同步完成；
+3. 调整主备集群数据同步方向；
+4. 调整配置，引导客户端到备集群进行读写；
+
+
+### 2.2、详细操作
+
+看完大体流程，我们再来看一下实际操作的命令。
+
+```bash
+1. 阻止用户生产和消费
+bin/kafka-configs.sh --zookeeper ${主集群A的ZK地址} --entity-type users --entity-name ${客户端使用的kafkaUser} --add-config didi.ha.active.cluster=None --alter
+
+
+2. 等待FetcherLag 和 Offset 同步
+无需操作，仅需检查主备Topic的Offset是否一致了。
+
+
+3. 取消备集群B向主集群A进行同步数据的配置
+bin/kafka-configs.sh --zookeeper ${备集群B的ZK地址} --entity-type ha-topics --entity-name ${Topic名称} --delete-config didi.ha.remote.cluster --alter
+
+
+4. 增加主集群A向备集群B进行同步数据的配置
+bin/kafka-configs.sh --zookeeper ${主集群A的ZK地址} --entity-type ha-topics --entity-name ${Topic名称} --add-config didi.ha.remote.cluster=${备集群B的集群ID} --alter
+
+
+5. 修改主集群A，备集群B，网关中，kafkaUser对应的集群，从而引导请求走向备集群
+bin/kafka-configs.sh --zookeeper ${主集群A的ZK地址} --entity-type users --entity-name ${客户端使用的kafkaUser} --add-config didi.ha.active.cluster=${备集群B的集群ID} --alter
+
+bin/kafka-configs.sh --zookeeper ${备集群B的ZK地址} --entity-type users --entity-name ${客户端使用的kafkaUser} --add-config didi.ha.active.cluster=${备集群B的集群ID} --alter
+
+bin/kafka-configs.sh --zookeeper ${网关的ZK地址} --entity-type users --entity-name ${客户端使用的kafkaUser} --add-config didi.ha.active.cluster=${备集群B的集群ID} --alter
+```
+
+---
+
+## 3、FAQ 
+
+**问题一：使用中，有没有什么需要注意的地方？**
+
+1. 主备切换是按照KafkaUser维度进行切换的，因此建议**不同服务之间，使用不同的KafkaUser**。这不仅有助于主备切换，也有助于做权限管控等。
+2. 在建立主备关系的过程中，如果主Topic的数据量比较大，建议逐步建立主备关系，避免一次性建立太多主备关系的Topic导致主集群需要被同步大量数据从而出现压力。
+ 
+
+**问题二：消费客户端如果重启之后，会不会导致变成从最旧或者最新的数据开始消费？**
+
+不会。主备集群，会相互同步__consumer_offsets这个Topic的数据，因此客户端在主集群的消费进度信息，也会被同步到备集群，客户端在备集群进行消费时，也会从上次提交在主集群Topic的位置开始消费。
+ 
+
+**问题三：如果是类似Flink任务，是自己维护消费进度的程序，在主备切换之后，会不会存在数据丢失或者重复消费的情况？**
+
+如果Flink自己管理好了消费进度，那么就不会。因为主备集群之间的数据同步就和一个集群内的副本同步一样，备集群会将主集群Topic中的Offset信息等都同步过来，因此不会。
+ 
+
+**问题四：可否做到不重启客户端？**
+
+即将开发完成的高可用版Kafka二期将具备该能力，敬请期待。
+ 

docs/didi/drawio/Kafka主备切换流程.drawio

@@ -0,0 +1,367 @@
+<mxfile host="65bd71144e">
+    <diagram id="bhaMuW99Q1BzDTtcfRXp" name="Page-1">
+        <mxGraphModel dx="1384" dy="785" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="1169" pageHeight="827" math="0" shadow="0">
+            <root>
+                <mxCell id="0"/>
+                <mxCell id="1" parent="0"/>
+                <mxCell id="81" value="1、主集群拒绝客户端的写入" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#FFFFFF;strokeColor=#d79b00;labelPosition=center;verticalLabelPosition=top;align=center;verticalAlign=bottom;fontSize=16;" vertex="1" parent="1">
+                    <mxGeometry x="630" y="70" width="490" height="380" as="geometry"/>
+                </mxCell>
+                <mxCell id="79" value="主备高可用集群稳定时的状态" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#FFFFFF;strokeColor=#d79b00;labelPosition=center;verticalLabelPosition=top;align=center;verticalAlign=bottom;fontSize=16;" vertex="1" parent="1">
+                    <mxGeometry x="30" y="70" width="490" height="380" as="geometry"/>
+                </mxCell>
+                <mxCell id="27" value="Kafka——主集群A" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=top;align=center;verticalAlign=bottom;" parent="1" vertex="1">
+                    <mxGeometry x="200" y="100" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="32" value="Zookeeper" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" parent="1" vertex="1">
+                    <mxGeometry x="210" y="110" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="33" value="Kafka-Brokers" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" parent="1" vertex="1">
+                    <mxGeometry x="210" y="150" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="36" value="Kafka网关" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=bottom;align=center;verticalAlign=top;" parent="1" vertex="1">
+                    <mxGeometry x="200" y="220" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="37" value="Zookeeper" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" parent="1" vertex="1">
+                    <mxGeometry x="210" y="230" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="38" value="Kafka-Gateways" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" parent="1" vertex="1">
+                    <mxGeometry x="210" y="270" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="63" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=1;entryY=0.5;entryDx=0;entryDy=0;" edge="1" parent="1" source="39" target="27">
+                    <mxGeometry relative="1" as="geometry">
+                        <Array as="points">
+                            <mxPoint x="440" y="380"/>
+                            <mxPoint x="440" y="140"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="64" value="备集群B 不断向 主集群A &lt;br&gt;发送Fetch请求，&lt;br&gt;从而同步主集群A的数据" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="63">
+                    <mxGeometry x="-0.05" y="-4" relative="1" as="geometry">
+                        <mxPoint x="6" y="-10" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="39" value="Kafka——备集群B" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=bottom;align=center;verticalAlign=top;" parent="1" vertex="1">
+                    <mxGeometry x="200" y="340" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="40" value="Zookeeper" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" parent="1" vertex="1">
+                    <mxGeometry x="210" y="350" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="41" value="Kafka-Brokers" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" parent="1" vertex="1">
+                    <mxGeometry x="210" y="390" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="57" style="html=1;entryX=0;entryY=0.5;entryDx=0;entryDy=0;strokeColor=default;startArrow=classic;startFill=1;" parent="1" source="42" target="27" edge="1">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="58" value="对主集群进行读写" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="57" vertex="1" connectable="0">
+                    <mxGeometry x="-0.0724" y="1" relative="1" as="geometry">
+                        <mxPoint x="-6" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="42" value="Kafka-Client" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" parent="1" vertex="1">
+                    <mxGeometry x="40" y="240" width="120" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="65" value="Kafka——主集群A" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=top;align=center;verticalAlign=bottom;" vertex="1" parent="1">
+                    <mxGeometry x="800" y="100" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="66" value="Zookeeper(修改ZK)" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#FF3333;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="810" y="110" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="67" value="Kafka-Brokers" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="810" y="150" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="68" value="Kafka网关" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=bottom;align=center;verticalAlign=top;" vertex="1" parent="1">
+                    <mxGeometry x="800" y="220" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="69" value="Zookeeper" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="810" y="230" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="70" value="Kafka-Gateways" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="810" y="270" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="71" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=1;entryY=0.5;entryDx=0;entryDy=0;" edge="1" parent="1" source="73" target="65">
+                    <mxGeometry relative="1" as="geometry">
+                        <Array as="points">
+                            <mxPoint x="1040" y="380"/>
+                            <mxPoint x="1040" y="140"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="72" value="备集群B 不断向 主集群A&lt;br&gt;发送Fetch请求，&lt;br&gt;从而同步主集群A的数据" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="71">
+                    <mxGeometry x="-0.05" y="-4" relative="1" as="geometry">
+                        <mxPoint x="6" y="-10" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="73" value="Kafka——备集群B" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=bottom;align=center;verticalAlign=top;" vertex="1" parent="1">
+                    <mxGeometry x="800" y="340" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="74" value="Zookeeper" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="810" y="350" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="75" value="Kafka-Brokers" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="810" y="390" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="76" style="html=1;entryX=0;entryY=0.5;entryDx=0;entryDy=0;strokeColor=#FF3333;startArrow=none;startFill=0;strokeWidth=3;endArrow=none;endFill=0;dashed=1;" edge="1" parent="1" source="78" target="65">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="77" value="对主集群进行读写会出现失败" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];fontColor=#FF3333;fontSize=13;" vertex="1" connectable="0" parent="76">
+                    <mxGeometry x="-0.0724" y="1" relative="1" as="geometry">
+                        <mxPoint x="-6" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="78" value="Kafka-Client" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="640" y="240" width="120" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="82" value="2、等待主备同步完成，避免丢数据" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#FFFFFF;strokeColor=#d79b00;labelPosition=center;verticalLabelPosition=top;align=center;verticalAlign=bottom;fontSize=16;" vertex="1" parent="1">
+                    <mxGeometry x="630" y="590" width="490" height="380" as="geometry"/>
+                </mxCell>
+                <mxCell id="83" value="Kafka——主集群A" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=top;align=center;verticalAlign=bottom;" vertex="1" parent="1">
+                    <mxGeometry x="800" y="620" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="84" value="Zookeeper" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="810" y="630" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="85" value="Kafka-Brokers" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="810" y="670" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="86" value="Kafka网关" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=bottom;align=center;verticalAlign=top;" vertex="1" parent="1">
+                    <mxGeometry x="800" y="740" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="87" value="Zookeeper" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="810" y="750" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="88" value="Kafka-Gateways" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="810" y="790" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="89" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=1;entryY=0.5;entryDx=0;entryDy=0;" edge="1" parent="1" source="91" target="83">
+                    <mxGeometry relative="1" as="geometry">
+                        <Array as="points">
+                            <mxPoint x="1040" y="900"/>
+                            <mxPoint x="1040" y="660"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="90" value="备集群B 不断向 主集群A&lt;br&gt;发送Fetch请求，&lt;br&gt;从而同步主集群A的&lt;br&gt;指定Topic的数据" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="89">
+                    <mxGeometry x="-0.05" y="-4" relative="1" as="geometry">
+                        <mxPoint x="6" y="-10" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="91" value="Kafka——备集群B" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=bottom;align=center;verticalAlign=top;" vertex="1" parent="1">
+                    <mxGeometry x="800" y="860" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="92" value="Zookeeper" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="810" y="870" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="93" value="Kafka-Brokers" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="810" y="910" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="94" style="html=1;entryX=0;entryY=0.5;entryDx=0;entryDy=0;strokeColor=#FF3333;startArrow=none;startFill=0;strokeWidth=3;endArrow=none;endFill=0;dashed=1;" edge="1" parent="1" source="96" target="83">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="95" value="对主集群进行读写会出现失败" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];fontColor=#FF3333;fontSize=13;" vertex="1" connectable="0" parent="94">
+                    <mxGeometry x="-0.0724" y="1" relative="1" as="geometry">
+                        <mxPoint x="-6" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="96" value="Kafka-Client" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="640" y="760" width="120" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="97" value="3、Topic粒度数据同步方向调整，由主集群A向备集群B同步数据" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#FFFFFF;strokeColor=#d79b00;labelPosition=center;verticalLabelPosition=top;align=center;verticalAlign=bottom;fontSize=16;" vertex="1" parent="1">
+                    <mxGeometry x="30" y="590" width="490" height="380" as="geometry"/>
+                </mxCell>
+                <mxCell id="98" value="Kafka——主集群A" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=top;align=center;verticalAlign=bottom;" vertex="1" parent="1">
+                    <mxGeometry x="200" y="620" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="99" value="Zookeeper" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="210" y="630" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="100" value="Kafka-Brokers" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="210" y="670" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="101" value="Kafka网关" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=bottom;align=center;verticalAlign=top;" vertex="1" parent="1">
+                    <mxGeometry x="200" y="740" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="102" value="Zookeeper" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="210" y="750" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="103" value="Kafka-Gateways" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="210" y="790" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="104" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=1;entryY=0.5;entryDx=0;entryDy=0;endArrow=none;endFill=0;strokeColor=#FF3333;strokeWidth=1;startArrow=classic;startFill=1;" edge="1" parent="1" source="106" target="98">
+                    <mxGeometry relative="1" as="geometry">
+                        <Array as="points">
+                            <mxPoint x="440" y="900"/>
+                            <mxPoint x="440" y="660"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="105" value="&lt;span style=&quot;font-size: 11px;&quot;&gt;主集群A 不断向 备集群B&lt;/span&gt;&lt;br style=&quot;font-size: 11px;&quot;&gt;&lt;span style=&quot;font-size: 11px;&quot;&gt;发送Fetch请求，&lt;/span&gt;&lt;br style=&quot;font-size: 11px;&quot;&gt;&lt;span style=&quot;font-size: 11px;&quot;&gt;从而同步备集群B的&lt;br&gt;指定Topic的数据&lt;/span&gt;" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];fontColor=#FF3333;fontSize=13;" vertex="1" connectable="0" parent="104">
+                    <mxGeometry x="-0.05" y="-4" relative="1" as="geometry">
+                        <mxPoint x="-4" y="-10" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="106" value="Kafka——备集群B" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=bottom;align=center;verticalAlign=top;" vertex="1" parent="1">
+                    <mxGeometry x="200" y="860" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="107" value="Zookeeper" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="210" y="870" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="108" value="Kafka-Brokers" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="210" y="910" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="109" style="html=1;entryX=0;entryY=0.5;entryDx=0;entryDy=0;strokeColor=#FF3333;startArrow=none;startFill=0;strokeWidth=3;endArrow=none;endFill=0;dashed=1;" edge="1" parent="1" source="111" target="98">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="110" value="对主集群进行读写会出现失败" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];fontColor=#FF3333;fontSize=13;" vertex="1" connectable="0" parent="109">
+                    <mxGeometry x="-0.0724" y="1" relative="1" as="geometry">
+                        <mxPoint x="-6" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="111" value="Kafka-Client" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="40" y="760" width="120" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="127" value="4、修改ZK，使得客户端使用的KafkaUser对应的集群为备集群B" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#FFFFFF;strokeColor=#d79b00;labelPosition=center;verticalLabelPosition=top;align=center;verticalAlign=bottom;fontSize=16;" vertex="1" parent="1">
+                    <mxGeometry x="30" y="1110" width="490" height="380" as="geometry"/>
+                </mxCell>
+                <mxCell id="128" value="Kafka——主集群A" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=top;align=center;verticalAlign=bottom;" vertex="1" parent="1">
+                    <mxGeometry x="200" y="1140" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="130" value="Kafka-Brokers" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="210" y="1190" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="131" value="Kafka网关" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=bottom;align=center;verticalAlign=top;" vertex="1" parent="1">
+                    <mxGeometry x="200" y="1260" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="132" value="Zookeeper(修改ZK)" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#FF3333;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="210" y="1270" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="133" value="Kafka-Gateways" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="210" y="1310" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="134" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=1;entryY=0.5;entryDx=0;entryDy=0;endArrow=none;endFill=0;strokeColor=#000000;strokeWidth=1;startArrow=classic;startFill=1;" edge="1" parent="1" source="136" target="128">
+                    <mxGeometry relative="1" as="geometry">
+                        <Array as="points">
+                            <mxPoint x="440" y="1420"/>
+                            <mxPoint x="440" y="1180"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="135" value="&lt;span style=&quot;color: rgb(0 , 0 , 0) ; font-size: 11px&quot;&gt;主集群A 不断向 备集群B&lt;/span&gt;&lt;br style=&quot;color: rgb(0 , 0 , 0) ; font-size: 11px&quot;&gt;&lt;span style=&quot;color: rgb(0 , 0 , 0) ; font-size: 11px&quot;&gt;发送Fetch请求，&lt;/span&gt;&lt;br style=&quot;color: rgb(0 , 0 , 0) ; font-size: 11px&quot;&gt;&lt;span style=&quot;color: rgb(0 , 0 , 0) ; font-size: 11px&quot;&gt;从而同步备集群B的&lt;br&gt;指定Topic的数据&lt;/span&gt;" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];fontColor=#FF3333;fontSize=13;" vertex="1" connectable="0" parent="134">
+                    <mxGeometry x="-0.05" y="-4" relative="1" as="geometry">
+                        <mxPoint x="-4" y="-10" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="136" value="Kafka——备集群B" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=bottom;align=center;verticalAlign=top;" vertex="1" parent="1">
+                    <mxGeometry x="200" y="1380" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="138" value="Kafka-Brokers" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="210" y="1430" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="139" style="html=1;entryX=0;entryY=0.5;entryDx=0;entryDy=0;strokeColor=#FF3333;startArrow=none;startFill=0;strokeWidth=3;endArrow=none;endFill=0;dashed=1;" edge="1" parent="1" source="141" target="128">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="140" value="对主集群进行读写会出现失败" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];fontColor=#FF3333;fontSize=13;" vertex="1" connectable="0" parent="139">
+                    <mxGeometry x="-0.0724" y="1" relative="1" as="geometry">
+                        <mxPoint x="-6" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="141" value="Kafka-Client" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="40" y="1280" width="120" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="142" value="5、重启客户端，网关将请求转向集群B" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#FFFFFF;strokeColor=#d79b00;labelPosition=center;verticalLabelPosition=top;align=center;verticalAlign=bottom;fontSize=16;" vertex="1" parent="1">
+                    <mxGeometry x="630" y="1110" width="490" height="380" as="geometry"/>
+                </mxCell>
+                <mxCell id="143" value="Kafka——主集群A" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=top;align=center;verticalAlign=bottom;" vertex="1" parent="1">
+                    <mxGeometry x="800" y="1140" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="144" value="Zookeeper" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="810" y="1150" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="145" value="Kafka-Brokers" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="810" y="1190" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="146" value="Kafka网关" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=bottom;align=center;verticalAlign=top;" vertex="1" parent="1">
+                    <mxGeometry x="800" y="1260" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="148" value="Kafka-Gateways" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="810" y="1310" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="149" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=1;entryY=0.5;entryDx=0;entryDy=0;endArrow=none;endFill=0;strokeColor=#000000;strokeWidth=1;startArrow=classic;startFill=1;" edge="1" parent="1" source="151" target="143">
+                    <mxGeometry relative="1" as="geometry">
+                        <Array as="points">
+                            <mxPoint x="1040" y="1420"/>
+                            <mxPoint x="1040" y="1180"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="150" value="&lt;span style=&quot;color: rgb(0 , 0 , 0) ; font-size: 11px&quot;&gt;主集群A 不断向 备集群B&lt;/span&gt;&lt;br style=&quot;color: rgb(0 , 0 , 0) ; font-size: 11px&quot;&gt;&lt;span style=&quot;color: rgb(0 , 0 , 0) ; font-size: 11px&quot;&gt;发送Fetch请求，&lt;/span&gt;&lt;br style=&quot;color: rgb(0 , 0 , 0) ; font-size: 11px&quot;&gt;&lt;span style=&quot;color: rgb(0 , 0 , 0) ; font-size: 11px&quot;&gt;从而同步备集群B的&lt;br&gt;指定Topic的数据&lt;/span&gt;" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];fontColor=#FF3333;fontSize=13;" vertex="1" connectable="0" parent="149">
+                    <mxGeometry x="-0.05" y="-4" relative="1" as="geometry">
+                        <mxPoint x="-4" y="-10" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="151" value="Kafka——备集群B" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=bottom;align=center;verticalAlign=top;" vertex="1" parent="1">
+                    <mxGeometry x="800" y="1380" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="152" value="Zookeeper" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="810" y="1390" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="153" value="Kafka-Brokers" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="810" y="1430" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="156" value="Kafka-Client" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="640" y="1280" width="120" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="157" style="html=1;entryX=0;entryY=0.5;entryDx=0;entryDy=0;strokeColor=default;startArrow=classic;startFill=1;exitX=0.5;exitY=1;exitDx=0;exitDy=0;" edge="1" parent="1" source="156" target="151">
+                    <mxGeometry relative="1" as="geometry">
+                        <mxPoint x="529.9966666666667" y="1400" as="sourcePoint"/>
+                        <mxPoint x="613.3299999999999" y="1300" as="targetPoint"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="158" value="对B集群进行读写" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="157">
+                    <mxGeometry x="-0.0724" y="1" relative="1" as="geometry">
+                        <mxPoint x="-6" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="159" value="Zookeeper(修改ZK)" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#FF3333;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="210" y="1150" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="160" value="Zookeeper(修改ZK)" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#FF3333;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="210" y="1390" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="161" value="Zookeeper" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="810" y="1270" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="162" value="" style="shape=flexArrow;endArrow=classic;html=1;fontSize=13;fontColor=#FF3333;strokeColor=#000000;strokeWidth=1;fillColor=#9999FF;" edge="1" parent="1">
+                    <mxGeometry width="50" height="50" relative="1" as="geometry">
+                        <mxPoint x="550" y="259.5" as="sourcePoint"/>
+                        <mxPoint x="600" y="259.5" as="targetPoint"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="163" value="" style="shape=flexArrow;endArrow=classic;html=1;fontSize=13;fontColor=#FF3333;strokeColor=#000000;strokeWidth=1;fillColor=#9999FF;" edge="1" parent="1">
+                    <mxGeometry width="50" height="50" relative="1" as="geometry">
+                        <mxPoint x="879.5" y="490" as="sourcePoint"/>
+                        <mxPoint x="879.5" y="540" as="targetPoint"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="164" value="" style="shape=flexArrow;endArrow=classic;html=1;fontSize=13;fontColor=#FF3333;strokeColor=#000000;strokeWidth=1;fillColor=#9999FF;" edge="1" parent="1">
+                    <mxGeometry width="50" height="50" relative="1" as="geometry">
+                        <mxPoint x="274.5" y="1010" as="sourcePoint"/>
+                        <mxPoint x="274.5" y="1060" as="targetPoint"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="165" value="" style="shape=flexArrow;endArrow=classic;html=1;fontSize=13;fontColor=#FF3333;strokeColor=#000000;strokeWidth=1;fillColor=#9999FF;" edge="1" parent="1">
+                    <mxGeometry width="50" height="50" relative="1" as="geometry">
+                        <mxPoint x="550" y="1309" as="sourcePoint"/>
+                        <mxPoint x="600" y="1309" as="targetPoint"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="167" value="" style="shape=flexArrow;endArrow=classic;html=1;fontSize=13;fontColor=#FF3333;strokeColor=#000000;strokeWidth=1;fillColor=#9999FF;" edge="1" parent="1">
+                    <mxGeometry width="50" height="50" relative="1" as="geometry">
+                        <mxPoint x="606" y="779.5" as="sourcePoint"/>
+                        <mxPoint x="550" y="779.5" as="targetPoint"/>
+                    </mxGeometry>
+                </mxCell>
+            </root>
+        </mxGraphModel>
+    </diagram>
+</mxfile>

docs/didi/drawio/Kafka基于网关的生产消费流程.drawio

@@ -0,0 +1,95 @@
+<mxfile host="65bd71144e">
+    <diagram id="bhaMuW99Q1BzDTtcfRXp" name="Page-1">
+        <mxGraphModel dx="1344" dy="785" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="1169" pageHeight="827" math="0" shadow="0">
+            <root>
+                <mxCell id="0"/>
+                <mxCell id="1" parent="0"/>
+                <mxCell id="27" value="Kafka集群--A" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=top;align=center;verticalAlign=bottom;" vertex="1" parent="1">
+                    <mxGeometry x="320" y="40" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="32" value="Zookeeper" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="330" y="50" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="33" value="Kafka-Brokers" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="330" y="90" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="47" style="edgeStyle=orthogonalEdgeStyle;html=1;entryX=1;entryY=0.25;entryDx=0;entryDy=0;exitX=1;exitY=0.75;exitDx=0;exitDy=0;" edge="1" parent="1" source="36" target="27">
+                    <mxGeometry relative="1" as="geometry">
+                        <Array as="points">
+                            <mxPoint x="560" y="260"/>
+                            <mxPoint x="560" y="60"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="51" value="2、网关发现是A集群的KafkaUser，&lt;br&gt;网关将请求转发到A集群" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="47">
+                    <mxGeometry x="-0.0444" y="-1" relative="1" as="geometry">
+                        <mxPoint x="49" y="72" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="55" style="edgeStyle=orthogonalEdgeStyle;html=1;exitX=0;exitY=0.5;exitDx=0;exitDy=0;entryX=1;entryY=0.5;entryDx=0;entryDy=0;" edge="1" parent="1" source="36" target="42">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="56" value="4、网关返回Topic元信息" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="55">
+                    <mxGeometry x="0.2125" relative="1" as="geometry">
+                        <mxPoint x="17" y="-10" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="36" value="Kafka网关" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=bottom;align=center;verticalAlign=top;" vertex="1" parent="1">
+                    <mxGeometry x="320" y="200" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="37" value="Zookeeper" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="330" y="210" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="38" value="Kafka-Gateways" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="330" y="250" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="39" value="Kafka集群--B" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#cdeb8b;strokeColor=#36393d;labelPosition=center;verticalLabelPosition=bottom;align=center;verticalAlign=top;" vertex="1" parent="1">
+                    <mxGeometry x="320" y="360" width="160" height="80" as="geometry"/>
+                </mxCell>
+                <mxCell id="40" value="Zookeeper" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1">
+                    <mxGeometry x="330" y="370" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="41" value="Kafka-Brokers" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="330" y="410" width="140" height="20" as="geometry"/>
+                </mxCell>
+                <mxCell id="57" style="html=1;entryX=0;entryY=0.5;entryDx=0;entryDy=0;strokeColor=default;startArrow=classic;startFill=1;" edge="1" parent="1" source="42" target="27">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="58" value="5、通过Topic元信息，&lt;br&gt;客户端直接访问A集群进行生产消费" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="57">
+                    <mxGeometry x="-0.0724" y="1" relative="1" as="geometry">
+                        <mxPoint x="-6" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="42" value="Kafka-Client" style="rounded=0;whiteSpace=wrap;html=1;absoluteArcSize=1;arcSize=14;strokeWidth=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+                    <mxGeometry x="40" y="220" width="120" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="48" style="html=1;entryX=0;entryY=0.75;entryDx=0;entryDy=0;exitX=0.5;exitY=1;exitDx=0;exitDy=0;edgeStyle=orthogonalEdgeStyle;" edge="1" parent="1" source="42" target="36">
+                    <mxGeometry relative="1" as="geometry">
+                        <mxPoint x="490" y="250" as="sourcePoint"/>
+                        <mxPoint x="490" y="90" as="targetPoint"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="50" value="1、请求Topic元信息" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="48">
+                    <mxGeometry x="-0.3373" y="-1" relative="1" as="geometry">
+                        <mxPoint x="17" y="7" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="49" style="edgeStyle=orthogonalEdgeStyle;html=1;entryX=1;entryY=0.25;entryDx=0;entryDy=0;exitX=1;exitY=0.75;exitDx=0;exitDy=0;" edge="1" parent="1" source="27" target="36">
+                    <mxGeometry relative="1" as="geometry">
+                        <mxPoint x="640" y="60" as="sourcePoint"/>
+                        <mxPoint x="490" y="70" as="targetPoint"/>
+                        <Array as="points">
+                            <mxPoint x="520" y="100"/>
+                            <mxPoint x="520" y="220"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="52" value="3、A集群返回&lt;br&gt;Topic元信息给网关" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="49">
+                    <mxGeometry x="-0.03" y="-1" relative="1" as="geometry">
+                        <mxPoint x="-19" y="3" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+            </root>
+        </mxGraphModel>
+    </diagram>
+</mxfile>

docs/install_guide/config_description.md

@@ -51,13 +51,16 @@ custom:
     didi:
       app-topic-metrics-enabled: false # 滴滴埋入的指标, 社区AK不存在该指标，因此默认关闭
       topic-request-time-metrics-enabled: false # 滴滴埋入的指标, 社区AK不存在该指标，因此默认关闭
-      topic-throttled-metrics: false # 滴滴埋入的指标, 社区AK不存在该指标，因此默认关闭
+      topic-throttled-metrics-enabled: false # 滴滴埋入的指标, 社区AK不存在该指标，因此默认关闭
     save-days: 7 #指标在DB中保持的天数，-1表示永久保存，7表示保存近7天的数据
 
 # 任务相关的开关
 task:
   op:
     sync-topic-enabled: false # 未落盘的Topic定期同步到DB中
+    order-auto-exec:          # 工单自动化审批线程的开关
+      topic-enabled: false      # Topic工单自动化审批开关, false:关闭自动化审批, true:开启
+      app-enabled: false        # App工单自动化审批开关, false:关闭自动化审批, true:开启
 
 account: # ldap相关的配置, 社区版本暂时支持不够完善，可以先忽略，欢迎贡献代码对这块做优化
   ldap:

docs/install_guide/install_guide_cn.md

@@ -31,17 +31,23 @@
 
 **2、源代码进行打包**
 
-下载好代码之后，进入`Logi-KafkaManager`的主目录，执行`sh build.sh`命令即可，执行完成之后会在`output/kafka-manager-xxx`目录下面生成一个jar包。
+下载好代码之后，进入`Logi-KafkaManager`的主目录，执行`mvn -Prelease-kafka-manager -Dmaven.test.skip=true clean install -U  `命令即可，
+执行完成之后会在`distribution/target`目录下面生成一个`kafka-manager-*.tar.gz`。
+和一个`kafka-manager-*.zip` 文件,随便任意一个压缩包都可以; 
+当然此时同级目录有一个已经解压好的文件夹;
 
-对于`windows`环境的用户，估计执行不了`sh build.sh`命令，因此可以直接执行`mvn install`，然后在`kafka-manager-web/target`目录下生成一个kafka-manager-web-xxx.jar的包。
 
-获取到jar包之后，我们继续下面的步骤。
 
 ---
 
-## 3、MySQL-DB初始化
+## 3. 解压安装包
+解压完成后; 在文件目录中可以看到有`kafka-manager/conf/create_mysql_table.sql` 有个mysql初始化文件
+先初始化DB
 
-执行[create_mysql_table.sql](create_mysql_table.sql)中的SQL命令，从而创建所需的MySQL库及表，默认创建的库名是`logi_kafka_manager`。
+      
+## 4、MySQL-DB初始化
+
+执行[create_mysql_table.sql](../../distribution/conf/create_mysql_table.sql)中的SQL命令，从而创建所需的MySQL库及表，默认创建的库名是`logi_kafka_manager`。
 
 ```
 # 示例：
@@ -50,15 +56,38 @@ mysql -uXXXX -pXXX -h XXX.XXX.XXX.XXX -PXXXX < ./create_mysql_table.sql
 
 ---
 
-## 4、启动
+## 5.修该配置
+请将`conf/application.yml.example` 文件复制一份出来命名为`application.yml` 放在同级目录:conf/application.yml ;
+并且修改配置; 当然不修改的话 就会用默认的配置;
+至少 mysql配置成自己的吧
 
-```
-# application.yml 是配置文件，最简单的是仅修改MySQL相关的配置即可启动
 
-nohup java -jar kafka-manager.jar --spring.config.location=./application.yml > /dev/null 2>&1 &
-```
+## 6、启动/关闭
+解压包中有启动和关闭脚本 
+`kafka-manager/bin/shutdown.sh`
+`kafka-manager/bin/startup.sh`
 
-### 5、使用
+执行 sh startup.sh 启动
+执行 sh shutdown.sh 关闭
+
+
+
+### 6、使用
 
 本地启动的话，访问`http://localhost:8080`，输入帐号及密码(默认`admin/admin`)进行登录。更多参考：[kafka-manager 用户使用手册](../user_guide/user_guide_cn.md)
 
+### 7. 升级
+
+如果是升级版本,请查看文件 [kafka-manager 升级手册](../../distribution/upgrade_config.md) 
+ 在您下载的启动包(V2.5及其后)中也有记录,在 kafka-manager/upgrade_config.md 中
+
+
+### 8. 在IDE中启动
+> 如果想参与开发或者想在IDE中启动的话
+> 先执行  `mvn -Dmaven.test.skip=true clean install -U ` 
+> 
+> 然后这个时候可以选择去 [pom.xml](../../pom.xml) 中将`kafka-manager-console`模块注释掉;
+> 注释是因为每次install的时候都会把前端文件`kafka-manager-console`重新打包进`kafka-manager-web`
+> 
+> 完事之后,只需要直接用IDE启动运行`kafka-manager-web`模块中的
+> com.xiaojukeji.kafka.manager.web.MainApplication main方法就行了

docs/install_guide/install_guide_docker_cn.md

@@ -0,0 +1,132 @@
+---
+
+![kafka-manager-logo](../assets/images/common/logo_name.png)
+
+**一站式`Apache Kafka`集群指标监控与运维管控平台**
+
+---
+
+
+## 基于Docker部署Logikm
+
+为了方便用户快速的在自己的环境搭建Logikm，可使用docker快速搭建
+
+### 部署Mysql
+
+```shell
+docker run --name mysql -p 3306:3306 -d registry.cn-hangzhou.aliyuncs.com/zqqq/logikm-mysql:5.7.37
+```
+
+可选变量参考[文档](https://hub.docker.com/_/mysql)
+
+默认参数
+
+* MYSQL_ROOT_PASSWORD：root
+
+
+
+### 部署Logikm Allinone
+
+> 前后端部署在一起
+
+```shell
+docker run --name logikm -p 8080:8080 --link mysql -d registry.cn-hangzhou.aliyuncs.com/zqqq/logikm:2.6.0
+```
+
+参数详解：
+
+* -p 映射容器8080端口至宿主机的8080
+* --link 连接mysql容器
+
+
+
+### 部署前后端分离
+
+#### 部署后端 Logikm-backend
+
+```shell
+docker run --name logikm-backend --link mysql -d registry.cn-hangzhou.aliyuncs.com/zqqq/logikm-backend:2.6.0
+```
+
+可选参数：
+
+* -e LOGI_MYSQL_HOST mysql连接地址，默认mysql
+* -e LOGI_MYSQL_PORT mysql端口，默认3306
+* -e LOGI_MYSQL_DATABASE 数据库，默认logi_kafka_manager
+* -e LOGI_MYSQL_USER mysql用户名，默认root
+* -e LOGI_MYSQL_PASSWORD mysql密码，默认root
+
+#### 部署前端 Logikm-front
+
+```shell
+docker run --name logikm-front -p 8088:80 --link logikm-backend -d registry.cn-hangzhou.aliyuncs.com/zqqq/logikm-front:2.6.0
+```
+
+
+
+### Logi后端可配置参数
+
+docker run 运行参数 -e 可指定环境变量如下
+
+| 环境变量            | 变量解释      | 默认值             |
+| ------------------- | ------------- | ------------------ |
+| LOGI_MYSQL_HOST     | mysql连接地址 | mysql              |
+| LOGI_MYSQL_PORT     | mysql端口     | 3306               |
+| LOGI_MYSQL_DATABASE | 数据库        | logi_kafka_manager |
+| LOGI_MYSQL_USER     | mysql用户名   | root               |
+| LOGI_MYSQL_PASSWORD | mysql密码     | root               |
+
+
+
+
+## 基于Docker源码构建
+
+根据此文档用户可自行通过Docker 源码构建 Logikm
+
+### 构建Mysql
+
+```shell
+docker build -t mysql:{TAG} -f container/dockerfiles/mysql/Dockerfile container/dockerfiles/mysql
+```
+
+### 构建Allinone
+
+将前后端打包在一起
+
+```shell
+docker build -t logikm:{TAG} .
+```
+
+可选参数 --build-arg ：
+
+* MAVEN_VERSION   maven镜像tag
+* JAVA_VERSION   java镜像tag
+
+
+
+### 构建前后端分离
+
+前后端分离打包
+
+#### 构建后端
+
+```shell
+docker build --build-arg CONSOLE_ENABLE=false -t logikm-backend:{TAG} .
+```
+
+参数：
+
+* MAVEN_VERSION   maven镜像tag
+* JAVA_VERSION   java镜像tag
+
+* CONSOLE_ENABLE=false 不构建console模块
+
+#### 构建前端
+
+```shell
+docker build -t logikm-front:{TAG} -f kafka-manager-console/Dockerfile kafka-manager-console
+```
+
+可选参数：
+
+* --build-arg：OUTPUT_PATH 修改默认打包输出路径，默认当前目录下的dist

docs/user_guide/call_api_bypass_login.md

@@ -0,0 +1,49 @@
+
+---
+
+![kafka-manager-logo](../assets/images/common/logo_name.png)
+
+**一站式`Apache Kafka`集群指标监控与运维管控平台**
+
+--- 
+
+# 登录绕过
+
+## 背景
+
+现在除了开放出来的第三方接口，其他接口都需要走登录认证。
+
+但是第三方接口不多，开放出来的能力有限，但是登录的接口又需要登录，非常的麻烦。
+
+因此，新增了一个登录绕过的功能，为一些紧急临时的需求，提供一个调用不需要登录的能力。
+
+## 使用方式
+
+步骤一：接口调用时，在header中，增加如下信息：
+```shell
+# 表示开启登录绕过
+Trick-Login-Switch : on
+
+# 登录绕过的用户, 这里可以是admin, 或者是其他的, 但是必须在运维管控->平台管理->用户管理中设置了该用户。
+Trick-Login-User : admin
+```
+
+ 
+
+步骤二：在运维管控->平台管理->平台配置上，设置允许了该用户以绕过的方式登录
+```shell
+# 设置的key，必须是这个
+SECURITY.TRICK_USERS
+
+# 设置的value，是json数组的格式，例如
+[ "admin", "logi"]
+```
+
+ 
+
+步骤三：解释说明
+
+设置完成上面两步之后，就可以直接调用需要登录的接口了。
+
+但是还有一点需要注意，绕过的用户仅能调用他有权限的接口，比如一个普通用户，那么他就只能调用普通的接口，不能去调用运维人员的接口。
+

docs/user_guide/faq.md

@@ -20,8 +20,17 @@
 - 8、`topic biz data not exist`错误及处理方式
 - 9、进程启动后，如何查看API文档
 - 10、如何创建告警组？
-- 11、连接信息、耗时信息为什么没有数据？
+- 11、连接信息、耗时信息、磁盘信息为什么没有数据？
 - 12、逻辑集群申请审批通过之后为什么看不到逻辑集群？
+- 13、heartbeat表关联业务和使用场景是什么？
+- 14、集群的删除，是否会真正的删除集群？
+- 15、APP(应用)如何被使用起来？
+- 16、为什么下线应用提示operation forbidden？
+- 17、删除Topic成功，为什么过一会儿之后又出现了？
+- 18、如何在不登录的情况下，调用一些需要登录的接口？
+- 19、为什么无法看到连接信息、耗时信息等指标？
+- 20、AppID鉴权、生产消费配额不起作用
+- 21、如何查看周期任务说明文档
 
 ---
 
@@ -70,7 +79,7 @@
 
 - 3、数据库时区问题。
 
-检查MySQL的topic_metrics表，查看是否有数据，如果有数据，那么再检查设置的时区是否正确。
+检查MySQL的cluster表的gmt_modify字段，做一个update动作，看这个gmt_modify时间是否是当前时间，如果不是，那么就是时区问题了。时区不对问题具体可以搜索一下看如何解决。
 
 ---
 
@@ -113,11 +122,14 @@
 
 ### 10、如何创建告警组？
 
-这块需要配合监控系统进行使用，现在默认已经实现了夜莺的对接，当然也可以对接自己内部的监控系统，不过需要实现一些接口。
+告警组的创建需要到Logi-KM对接的监控系统中创建，比如我们现在默认是对接了夜莺，那么告警组需要到夜莺中创建，如果没有安装夜莺，那么需要安装一下夜莺并进行对接。当然，这里也可以对接自己内部的监控系统，不过需要实现一些接口。
 
 具体的文档可见：[监控功能对接夜莺](../dev_guide/monitor_system_integrate_with_n9e.md)、[监控功能对接其他系统](../dev_guide/monitor_system_integrate_with_self.md)
 
-### 11、连接信息、耗时信息为什么没有数据？
+那么在夜莺中，如何创建告警组呢？
+需要前往夜莺平台-用户资源中心-团队管理中新建团队。新建过团队之后再次回到Logi-KM中刷新页面就可以在该下拉框中选择告警接收组了。
+
+### 11、连接信息、耗时信息、磁盘信息为什么没有数据？
 
 这块需要结合滴滴内部的kafka-gateway一同使用才会有数据，滴滴kafka-gateway暂未开源。
 
@@ -126,3 +138,82 @@
 逻辑集群的申请与审批仅仅只是一个工单流程，并不会去实际创建逻辑集群，逻辑集群的创建还需要手动去创建。
 
 具体的操作可见：[kafka-manager 接入集群](add_cluster/add_cluster.md)。
+
+
+### 13、heartbeat表关联业务和使用场景是什么？
+
+做任务抢占用的。
+
+KM支持HA的方式部署，那么部署多台的时候，就会出现每一台都可能去做指标收集的事情，这块就使用heartbeat表做KM的存活性判断，然后进行任务的抢占或者是均衡。
+
+更多详细的内容，可以看一下源码中，heartbeat表在哪里被使用了。
+
+
+### 14、集群的删除，是否会真正的删除集群？
+
+Logi-KM的运维管控，集群列表中的集群删除，仅仅只是将该集群从Logi-KM中进行删除，并不会对真正的物理集群做什么操作。
+
+
+### 15、APP(应用)如何被使用起来？
+
+app在Logi-KM中可以近似理解为租户，或者是kafka里面的一个账号的概念。
+
+界面中显示的app信息、权限信息等，在平台层面仅仅只是控制Topic或集群在平台上的可见性，如果使用的是社区版本的Kafka，那么实际上是不能真正的管控到客户端对Topic的生产和消费。
+
+但是如果是使用的滴滴的Kafka-Gateway，那么是可以做到对客户端的生产和消费的权限管控。滴滴的Kafka-Gateway暂未开源，属于企业服务，具体的可以入群交流，群地址在README中。
+
+
+### 16、为什么下线应用提示operation forbidden？
+
+**原因一：**
+
+该应用还存在对Topic的权限，因此导致下线失败。具体查看的位置在"Topic管理-》应用管理-》详情"，可以看到应用对哪些Topic还有权限。
+
+只有当权限全部去除之后，才可以下线应用。
+
+**原因二：**
+
+使用的是2.4.0之前的旧版本，旧版本存在缓存更新的BUG，建议升级至最新的版本，或者简单粗暴的就是重启一下KM。
+
+
+### 17、删除Topic成功，为什么过一会儿之后又出现了？
+
+**原因说明：**
+
+Logi-KM会去请求Topic的endoffset信息，要获取这个信息就需要发送metadata请求，发送metadata请求的时候，如果集群允许自动创建Topic，那么当Topic不存在时，就会自动将该Topic创建出来。
+
+
+**问题解决：**
+
+因为在Logi-KM上，禁止Kafka客户端内部元信息获取这个动作非常的难做到，因此短时间内这个问题不好从Logi-KM上解决。
+
+当然，对于不存在的Topic，Logi-KM是不会进行元信息请求的，因此也不用担心会莫名其妙的创建一个Topic出来。
+
+但是，另外一点，对于开启允许Topic自动创建的集群，建议是关闭该功能，开启是非常危险的，如果关闭之后，Logi-KM也不会有这个问题。
+
+最后这里举个开启这个配置后，非常危险的代码例子吧：
+
+```java
+for (int i= 0; i < 100000; ++i) {
+    // 如果是客户端类似这样写的，那么一启动，那么将创建10万个Topic出来，集群元信息瞬间爆炸，controller可能就不可服务了。
+    producer.send(new ProducerRecord<String, String>("logi_km" + i,"hello logi_km"));
+}
+```
+
+### 18、如何在不登录的情况下，调用一些需要登录的接口？
+
+具体见：[登录绕过](./call_api_bypass_login.md)
+
+### 19、为什么无法看到连接信息、耗时信息等指标？
+连接信息、耗时信息等指标依赖于滴滴kafka-gateway和滴滴Kafka引擎，通过gateway可获取到连接到该Topic的应用情况，提高对Topic的管控能力。通过滴滴Kafka引擎的自带埋点，可获取到耗时信息，提升Topic生产消费时的可观测性。这部分内容是属于商业版的范畴，暂未开源。如有需要，可进行商业合作。
+
+具体见：[滴滴Logi-KafkaManager开源版和商业版特性对比](../开源版与商业版特性对比.md)
+
+### 20、AppID鉴权、生产消费配额不起作用？
+AppID鉴权、生产消费配额依赖于滴滴kafka-gateway，通过gateway进行身份鉴权和生产消费限流，可避免用户无限制的使用集群的流量，流量大的用户会耗尽系统资源从而影响其他用户的使用，造成集群的节点故障。这部分内容是属于商业版的范畴，暂未开源。如有需要，可进行商业合作。
+
+具体见：[滴滴Logi-KafkaManager开源版和商业版特性对比](../开源版与商业版特性对比.md)
+
+### 20、如何查看周期任务说明文档
+
+具体见：[周期任务说明文档](../dev_guide/周期任务说明文档.md)

docs/user_guide/monitor_desc.md

@@ -4,11 +4,16 @@
 
 ---
 
+## 报警策略-监控指标说明
+
+| 指标 | 含义 |备注  |
+| --- | --- | --- |
+| online-kafka-consumer-lag | 消费时，按照分区的维度进行监控lag数  | lag表示有多少数据没有被消费，因为按照分区的维度监控，所以告警时一般会有分区信息 |
+| online-kafka-consumer-maxLag | 消费时，按照整个Topic的维度，监控Topic所有的分区里面的那个最大的lag | 比如每个分区的lag分别是3、5、7，那么maxLag的值就是max(3,5,7)=7 |
+| online-kafka-consumer-maxDelayTime | 消费时，按照Topic维度监控预计的消费延迟  | 这块是按照lag和messagesIn之间的关系计算出来的，可能会有误差 |
 
 ## 报警策略-报警函数介绍
 
-
-
 | 类别 | 函数 | 含义 |函数文案 |备注  |
 | --- | --- | --- | --- | --- |
 | 发生次数 |all，n  | 最近$n个周期内，全发生 | 连续发生(all) |  |

docs/user_guide/user_guide_cn.md

@@ -609,10 +609,10 @@ Lag：表示该消费客户端是否有堆积；等于 partition offset-consume
 
 集群类型：选择创建的集群为“独享”还是“独立”。
 
-* 独享集群意味着，您独自拥有一个
-集群；
+* 独享集群意味着， 您拥有一个集群中，部分broker的使用权限。
 
-* 独立集群意味着，您拥有一个集群中，部分broker的使用权限。
+* 独立集群意味着，您独自拥有一个
+  物理集群；
 
 * <font color = red>共享集群意味着，大家共用一个集群及其中broker。</font>
 

docs/开源版与商业版特性对比.md

@@ -0,0 +1,55 @@
+
+---
+
+![kafka-manager-logo](assets/images/common/logo_name.png)
+
+**一站式`Apache Kafka`集群指标监控与运维管控平台**
+
+--- 
+
+**开源版、商业版对比**
+
+纲要：Logi-KafakManager的商业特性是强依赖于滴滴Kafka Gateway和滴滴kafka引擎。
+滴滴KafkaGateway主要负责：服务发现、安全管控（身份鉴权、生产消费鉴权等）、流量管控（应用配额等）等；
+滴滴Kafka引擎主要负责：更丰富的监控指标（broker实时耗时、压缩指标、分区落盘等）、磁盘过载保护等
+备注：两个版本的产品功能页面是一样的。区别在于开源版未使用滴滴KafkaGateway（滴滴Kafka引擎），部分产品功能/功能不起作用或者页面无数据
+
+
+
+
+| 模块 |对比指标  |底层依赖  |开源版  |商业版  |备注  |
+| --- | --- | --- | --- | --- | --- |
+| 服务发现 | bootstrap地址变更对客户端无影响 | Gateway |  |  是|  |
+| 安全管控 | 身份鉴权（appID+password） | Gateway |  | 是 |  |
+|  | 权限鉴权（Topic+appID） | Gateway |  | 是 |  |
+| 指标监控 | Topic实时流量、历史流量 |  | 是 | 是 |  |
+|  | Broker实时耗时、历史耗时 | 引擎 |  | 是 |  |
+|  | 分区落盘 | 引擎 |  | 是 |  |
+|  | Topic里的数据压缩格式 | 引擎 |  | 是 |  |
+|  | 连接信息（Topic上有哪些应用连接） | Gateway |  |  是|  |
+|  | 流量管控（应用配额、生产消费限流等） | Gateway |  | 是 |  |
+| 监控报警 |  |  | 是 | 是 | 监控指标上报，需对接外部监控系统（夜莺or企业内部监控系统） |
+| Topic运维 | 申请分区 |  | 是 | 是 |  |
+|  | 调整配额 | Gateway |  |  | 是 |
+|  | Topic数据采样 |  | 是 | 是 |  |
+|  | 消费组管理（重置消费偏移等） |  | 是 | 是 |  |
+| 集群管理 | 集群接入（部署） |  | 是 | 是 | 需手动部署集群，或借助外部的自动化部署系统（夜莺）来部署系统 |
+|  | 集群指标监控 |  | 是 | 是 |  |
+|  | 按照Region、逻辑集群进行管理 |  | 是 | 是 |  |
+|  | Topic迁移 |  | 是 |  是|  |
+|  | 集群任务（集群版本管理、升级、扩缩容、回滚等） |  | 是 | 是 | 需借助夜莺或自动化部署系统来实现 |
+|  | 磁盘过载保护 | 引擎 |  | 是 |  |
+|  | 指定broker作为优选controller | Gateway |  | 是 |  |
+| Gateway管理 | 管理 Gateway的配置文件 | Gateway |  | 是 |  |
+| 资源治理 | 专家服务（Topic分区热点、Topic分区不足、Topic长期未使用、Topic流量异常） |  | 是 | 是 | 开源版：具备问题发现与基础的问题解决能力；商业版：可在此基础上，融入滴滴内部的资源治理经验，提供更加专家化的问题解决方法 |
+|  | 健康分 |  | 是 | 是 | 开源版：具备基础的健康分算法；商业版：可融入更多的指标统计，及定制化的健康分算法 |
+| 运营管理 | 资源审批（应用申请、Topic申请、分区申请、配额申请、集群申请等，都需要通过工单进行审批） |  |是  | 是 |  |
+|  | 账单体系（根据流量核算Topic、集群费用） |  | 是 |  是|  |
+
+
+**总结**
+
+滴滴LogiKM的商业特性体现在滴滴Kafka Gateway、滴滴Kafka引擎、内部沉淀出的资源治理专家经验、可定制化的健康分算法。
+从场景来看，滴滴Logi-KafkaManager的开源版本在kafka集群运维、的Topic管理、监控告警、资源治理等kafka核心场景都充分开源用户的使用需求并且有着出色的表现。而商业版相较于开源版在安全管控、流量管控、更丰富的指标监控、资源治理专家经验的具有明显提升，更加符合企业业务需求。
+除此之外，商业版还可根据企业实际需求对平台源码进行定制化改造，并提供运维保障，稳定性保障，运营保障等服务。
+

kafka-manager-common/pom.xml

@@ -21,15 +21,12 @@
         <java_target_version>1.8</java_target_version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <file_encoding>UTF-8</file_encoding>
-
-        <spring-version>5.1.3.RELEASE</spring-version>
     </properties>
 
     <dependencies>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-web</artifactId>
-            <version>${spring-version}</version>
         </dependency>
 
         <!-- http -->
@@ -109,5 +106,21 @@
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
         </dependency>
+
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.baomidou</groupId>
+            <artifactId>mybatis-plus-boot-starter</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.hibernate.validator</groupId>
+            <artifactId>hibernate-validator</artifactId>
+        </dependency>
     </dependencies>
 </project>

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/ApiLevelEnum.java

@@ -1,19 +0,0 @@
-package com.xiaojukeji.kafka.manager.common.bizenum;
-
-/**
- * @author zengqiao
- * @date 20/7/27
- */
-public enum ApiLevelEnum {
-    LEVEL_0(0),
-    LEVEL_1(1),
-    LEVEL_2(2),
-    LEVEL_3(3)
-    ;
-
-    private int level;
-
-    ApiLevelEnum(int level) {
-        this.level = level;
-    }
-}

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/ConsumeHealthEnum.java

@@ -24,18 +24,10 @@ public enum ConsumeHealthEnum {
         return code;
     }
 
-    public void setCode(Integer code) {
-        this.code = code;
-    }
-
     public String getMessage() {
         return message;
     }
 
-    public void setMessage(String message) {
-        this.message = message;
-    }
-
     @Override
     public String toString() {
         return "ConsumeHealthEnum{" +

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/DBStatusEnum.java

@@ -19,7 +19,10 @@ public enum DBStatusEnum {
         return status;
     }
 
-    public void setStatus(int status) {
-        this.status = status;
+    @Override
+    public String toString() {
+        return "DBStatusEnum{" +
+                "status=" + status +
+                '}';
     }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/IDCEnum.java

@@ -21,18 +21,10 @@ public enum IDCEnum {
         return idc;
     }
 
-    public void setIdc(String idc) {
-        this.idc = idc;
-    }
-
     public String getName() {
         return name;
     }
 
-    public void setName(String name) {
-        this.name = name;
-    }
-
     @Override
     public String toString() {
         return "IDCEnum{" +

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/JobLogBizTypEnum.java

@@ -0,0 +1,21 @@
+package com.xiaojukeji.kafka.manager.common.bizenum;
+
+import lombok.Getter;
+
+@Getter
+public enum JobLogBizTypEnum {
+    HA_SWITCH_JOB_LOG(100, "HA-主备切换日志"),
+
+    UNKNOWN(-1, "unknown"),
+
+        ;
+
+    JobLogBizTypEnum(int code, String msg) {
+        this.code = code;
+        this.msg = msg;
+    }
+
+    private final int code;
+
+    private final String msg;
+}

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/KafkaBrokerRoleEnum.java

@@ -21,10 +21,6 @@ public enum KafkaBrokerRoleEnum {
         return role;
     }
 
-    public void setRole(String role) {
-        this.role = role;
-    }
-
     @Override
     public String toString() {
         return "KafkaBrokerRoleEnum{" +

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/KafkaClientEnum.java

@@ -24,18 +24,10 @@ public enum KafkaClientEnum {
         return code;
     }
 
-    public void setCode(Integer code) {
-        this.code = code;
-    }
-
     public String getName() {
         return name;
     }
 
-    public void setName(String name) {
-        this.name = name;
-    }
-
     @Override
     public String toString() {
         return "KafkaClientEnum{" +

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/OffsetResetTypeEnum.java

@@ -18,4 +18,11 @@ public enum OffsetResetTypeEnum {
     public Integer getCode() {
         return code;
     }
+
+    @Override
+    public String toString() {
+        return "OffsetResetTypeEnum{" +
+                "code=" + code +
+                '}';
+    }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/OperateEnum.java

@@ -46,7 +46,7 @@ public enum  OperateEnum {
 
     public static boolean validate(Integer code) {
         if (code == null) {
-            return false;
+            return true;
         }
         for (OperateEnum state : OperateEnum.values()) {
             if (state.getCode() == code) {

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/OperationStatusEnum.java

@@ -27,4 +27,12 @@ public enum OperationStatusEnum {
     public String getMessage() {
         return message;
     }
+
+    @Override
+    public String toString() {
+        return "OperationStatusEnum{" +
+                "code=" + code +
+                ", message='" + message + '\'' +
+                '}';
+    }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/PeakFlowStatusEnum.java

@@ -15,9 +15,9 @@ public enum PeakFlowStatusEnum {
 
     ;
 
-    public Integer code;
+    private Integer code;
 
-    public String message;
+    private String message;
 
     PeakFlowStatusEnum(Integer code, String message) {
         this.code = code;
@@ -28,18 +28,10 @@ public enum PeakFlowStatusEnum {
         return code;
     }
 
-    public void setCode(Integer code) {
-        this.code = code;
-    }
-
     public String getMessage() {
         return message;
     }
 
-    public void setMessage(String message) {
-        this.message = message;
-    }
-
     @Override
     public String toString() {
         return "PeakFlowStatusEnum{" +

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/RebalanceDimensionEnum.java

@@ -29,4 +29,12 @@ public enum RebalanceDimensionEnum {
     public String getMessage() {
         return message;
     }
+
+    @Override
+    public String toString() {
+        return "RebalanceDimensionEnum{" +
+                "code=" + code +
+                ", message='" + message + '\'' +
+                '}';
+    }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/TaskActionEnum.java

@@ -1,11 +1,11 @@
-package com.xiaojukeji.kafka.manager.kcm.common.bizenum;
+package com.xiaojukeji.kafka.manager.common.bizenum;
 
 /**
  * 任务动作
  * @author zengqiao
  * @date 20/4/26
  */
-public enum ClusterTaskActionEnum {
+public enum TaskActionEnum {
     UNKNOWN("unknown"),
 
     START("start"),
@@ -17,13 +17,15 @@ public enum ClusterTaskActionEnum {
     REDO("redo"),
     KILL("kill"),
 
+    FORCE("force"),
+
     ROLLBACK("rollback"),
 
     ;
 
-    private String action;
+    private final String action;
 
-    ClusterTaskActionEnum(String action) {
+    TaskActionEnum(String action) {
         this.action = action;
     }
 

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/TaskStatusEnum.java

@@ -1,10 +1,13 @@
 package com.xiaojukeji.kafka.manager.common.bizenum;
 
+import lombok.Getter;
+
 /**
  * 任务状态
  * @author zengqiao
  * @date 2017/6/29.
  */
+@Getter
 public enum TaskStatusEnum {
     UNKNOWN(    -1, "未知"),
 
@@ -15,6 +18,7 @@ public enum TaskStatusEnum {
 
         RUNNING(    30, "运行中"),
             KILLING(    31, "杀死中"),
+            RUNNING_IN_TIMEOUT(    32, "超时运行中"),
 
         BLOCKED(    40, "暂停"),
 
@@ -30,43 +34,16 @@ public enum TaskStatusEnum {
 
     ;
 
-    private Integer code;
+    private final Integer code;
 
-    private String message;
+    private final String message;
 
     TaskStatusEnum(Integer code, String message) {
         this.code = code;
         this.message = message;
     }
 
-    public Integer getCode() {
-        return code;
-    }
-
-    public void setCode(Integer code) {
-        this.code = code;
-    }
-
-    public String getMessage() {
-        return message;
-    }
-
-    public void setMessage(String message) {
-        this.message = message;
-    }
-
-    @Override
-    public String toString() {
-        return "TaskStatusEnum{" +
-                "code=" + code +
-                ", message='" + message + '\'' +
-                '}';
-    }
-
     public static Boolean isFinished(Integer code) {
-        if (code >= FINISHED.getCode()) {
-            return true;
-        }
-        return false;
+        return code >= FINISHED.getCode();
     }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/TaskStatusReassignEnum.java

@@ -45,11 +45,6 @@ public enum TaskStatusReassignEnum {
     }
 
     public static Boolean isFinished(Integer code) {
-        if (SUCCEED.getCode().equals(code)
-                || FAILED.getCode().equals(code)
-                || CANCELED.getCode().equals(code)) {
-            return true;
-        }
-        return false;
+        return SUCCEED.getCode().equals(code) || FAILED.getCode().equals(code) || CANCELED.getCode().equals(code);
     }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/TopicAuthorityEnum.java

@@ -17,9 +17,9 @@ public enum TopicAuthorityEnum {
     OWNER(4, "可管理"),
     ;
 
-    private Integer code;
+    private final Integer code;
 
-    private String message;
+    private final String message;
 
     TopicAuthorityEnum(Integer code, String message) {
         this.code = code;
@@ -33,4 +33,22 @@ public enum TopicAuthorityEnum {
     public String getMessage() {
         return message;
     }
+
+    public static String getMsgByCode(Integer code) {
+        for (TopicAuthorityEnum authorityEnum: TopicAuthorityEnum.values()) {
+            if (authorityEnum.getCode().equals(code)) {
+                return authorityEnum.message;
+            }
+        }
+
+        return DENY.message;
+    }
+
+    @Override
+    public String toString() {
+        return "TopicAuthorityEnum{" +
+                "code=" + code +
+                ", message='" + message + '\'' +
+                '}';
+    }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/TopicExpiredStatusEnum.java

@@ -29,4 +29,12 @@ public enum TopicExpiredStatusEnum {
     public String getMessage() {
         return message;
     }
+
+    @Override
+    public String toString() {
+        return "TopicExpiredStatusEnum{" +
+                "status=" + status +
+                ", message='" + message + '\'' +
+                '}';
+    }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/TopicOffsetChangedEnum.java

@@ -23,18 +23,10 @@ public enum TopicOffsetChangedEnum {
         return code;
     }
 
-    public void setCode(Integer code) {
-        this.code = code;
-    }
-
     public String getMessage() {
         return message;
     }
 
-    public void setMessage(String message) {
-        this.message = message;
-    }
-
     @Override
     public String toString() {
         return "TopicOffsetChangedEnum{" +

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/gateway/GatewayConfigKeyEnum.java

@@ -5,17 +5,16 @@ package com.xiaojukeji.kafka.manager.common.bizenum.gateway;
  * @date 20/7/28
  */
 public enum GatewayConfigKeyEnum {
-    SD_CLUSTER_ID("SERVICE_DISCOVERY_CLUSTER_ID", "SERVICE_DISCOVERY_CLUSTER_ID"),
-    SD_QUEUE_SIZE("SERVICE_DISCOVERY_QUEUE_SIZE", "SERVICE_DISCOVERY_QUEUE_SIZE"),
-    SD_APP_ID_RATE("SERVICE_DISCOVERY_APPID_RATE", "SERVICE_DISCOVERY_APPID_RATE"),
-    SD_IP_RATE("SERVICE_DISCOVERY_IP_RATE", "SERVICE_DISCOVERY_IP_RATE"),
-    SD_SP_RATE("SERVICE_DISCOVERY_SP_RATE", "SERVICE_DISCOVERY_SP_RATE"),
-
+    SD_CLUSTER_ID("SD_CLUSTER_ID", "SD_CLUSTER_ID"),
+    SD_QUEUE_SIZE("SD_QUEUE_SIZE", "SD_QUEUE_SIZE"),
+    SD_APP_RATE("SD_APP_RATE", "SD_APP_RATE"),
+    SD_IP_RATE("SD_IP_RATE", "SD_IP_RATE"),
+    SD_SP_RATE("SD_SP_RATE", "SD_SP_RATE"),
     ;
 
-    private String configType;
+    private final String configType;
 
-    private String configName;
+    private final String configName;
 
     GatewayConfigKeyEnum(String configType, String configName) {
         this.configType = configType;
@@ -26,18 +25,10 @@ public enum GatewayConfigKeyEnum {
         return configType;
     }
 
-    public void setConfigType(String configType) {
-        this.configType = configType;
-    }
-
     public String getConfigName() {
         return configName;
     }
 
-    public void setConfigName(String configName) {
-        this.configName = configName;
-    }
-
     @Override
     public String toString() {
         return "GatewayConfigKeyEnum{" +

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/ha/HaRelationTypeEnum.java

@@ -0,0 +1,27 @@
+package com.xiaojukeji.kafka.manager.common.bizenum.ha;
+
+import lombok.Getter;
+
+/**
+ * @author zengqiao
+ * @date 20/7/28
+ */
+@Getter
+public enum HaRelationTypeEnum {
+    UNKNOWN(-1, "非高可用"),
+
+    STANDBY(0, "备"),
+
+    ACTIVE(1, "主"),
+
+    MUTUAL_BACKUP(2 , "互备");
+
+    private final int code;
+
+    private final String msg;
+
+    HaRelationTypeEnum(int code, String msg) {
+        this.code = code;
+        this.msg = msg;
+    }
+}

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/ha/HaResTypeEnum.java

@@ -0,0 +1,29 @@
+package com.xiaojukeji.kafka.manager.common.bizenum.ha;
+
+import lombok.Getter;
+
+/**
+ * @author zengqiao
+ * @date 20/7/28
+ */
+@Getter
+public enum HaResTypeEnum {
+    CLUSTER(0, "Cluster"),
+
+    TOPIC(1, "Topic"),
+
+    KAFKA_USER(2, "KafkaUser"),
+
+    KAFKA_USER_AND_CLIENT(3, "KafkaUserAndClient"),
+
+    ;
+
+    private final int code;
+
+    private final String msg;
+
+    HaResTypeEnum(int code, String msg) {
+        this.code = code;
+        this.msg = msg;
+    }
+}

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/ha/HaStatusEnum.java

@@ -0,0 +1,75 @@
+package com.xiaojukeji.kafka.manager.common.bizenum.ha;
+
+/**
+ * @author zengqiao
+ * @date 20/7/28
+ */
+public enum HaStatusEnum {
+    UNKNOWN(-1, "未知状态"),
+
+    STABLE(HaStatusEnum.STABLE_CODE, "稳定状态"),
+
+//    SWITCHING(HaStatusEnum.SWITCHING_CODE, "切换中"),
+        SWITCHING_PREPARE(
+                HaStatusEnum.SWITCHING_PREPARE_CODE,
+                "主备切换--源集群[%s]--预处理(阻止当前主Topic写入)"),
+
+        SWITCHING_WAITING_IN_SYNC(
+                HaStatusEnum.SWITCHING_WAITING_IN_SYNC_CODE,
+                "主备切换--目标集群[%s]--等待主与备Topic数据同步完成"),
+
+        SWITCHING_CLOSE_OLD_STANDBY_TOPIC_FETCH(
+                HaStatusEnum.SWITCHING_CLOSE_OLD_STANDBY_TOPIC_FETCH_CODE,
+                "主备切换--目标集群[%s]--关闭旧的备Topic的副本同步"),
+        SWITCHING_OPEN_NEW_STANDBY_TOPIC_FETCH(
+                HaStatusEnum.SWITCHING_OPEN_NEW_STANDBY_TOPIC_FETCH_CODE,
+                "主备切换--源集群[%s]--开启新的备Topic的副本同步"),
+
+        SWITCHING_CLOSEOUT(
+                HaStatusEnum.SWITCHING_CLOSEOUT_CODE,
+                "主备切换--目标集群[%s]--收尾(允许新的主Topic写入)"),
+
+    ;
+
+    public static final int UNKNOWN_CODE = -1;
+    public static final int STABLE_CODE = 0;
+
+    public static final int SWITCHING_CODE = 100;
+    public static final int SWITCHING_PREPARE_CODE = 101;
+
+    public static final int SWITCHING_WAITING_IN_SYNC_CODE = 102;
+    public static final int SWITCHING_CLOSE_OLD_STANDBY_TOPIC_FETCH_CODE = 103;
+    public static final int SWITCHING_OPEN_NEW_STANDBY_TOPIC_FETCH_CODE = 104;
+
+    public static final int SWITCHING_CLOSEOUT_CODE = 105;
+
+
+    private final int code;
+
+    private final String msg;
+
+    public int getCode() {
+        return code;
+    }
+
+    public String getMsg(String clusterName) {
+        if (this.code == UNKNOWN_CODE || this.code == STABLE_CODE) {
+            return this.msg;
+        }
+        return String.format(msg, clusterName);
+    }
+
+    HaStatusEnum(int code, String msg) {
+        this.code = code;
+        this.msg = msg;
+    }
+
+    public static Integer calProgress(Integer status) {
+        if (status == null || status == HaStatusEnum.STABLE_CODE || status == UNKNOWN_CODE) {
+            return 100;
+        }
+
+        // 最小进度为 1%
+        return Math.max(1, (status - 101) * 100 / 5);
+    }
+}

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/ha/job/HaJobActionEnum.java

@@ -0,0 +1,44 @@
+package com.xiaojukeji.kafka.manager.common.bizenum.ha.job;
+
+public enum HaJobActionEnum {
+    /**
+     *
+     */
+    START(1,"start"),
+
+    STOP(2, "stop"),
+
+    CANCEL(3,"cancel"),
+
+    CONTINUE(4,"continue"),
+
+    UNKNOWN(-1, "unknown");
+
+    HaJobActionEnum(int status, String value) {
+        this.status = status;
+        this.value = value;
+    }
+
+    private final int status;
+
+    private final String value;
+
+    public int getStatus() {
+        return status;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public static HaJobActionEnum valueOfStatus(int status) {
+        for (HaJobActionEnum statusEnum : HaJobActionEnum.values()) {
+            if (status == statusEnum.getStatus()) {
+                return statusEnum;
+            }
+        }
+
+        return HaJobActionEnum.UNKNOWN;
+    }
+
+}

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/bizenum/ha/job/HaJobStatusEnum.java

@@ -0,0 +1,75 @@
+package com.xiaojukeji.kafka.manager.common.bizenum.ha.job;
+
+import com.xiaojukeji.kafka.manager.common.bizenum.TaskStatusEnum;
+
+public enum HaJobStatusEnum {
+    /**执行中*/
+    RUNNING(TaskStatusEnum.RUNNING),
+    RUNNING_IN_TIMEOUT(TaskStatusEnum.RUNNING_IN_TIMEOUT),
+
+    SUCCESS(TaskStatusEnum.SUCCEED),
+
+    FAILED(TaskStatusEnum.FAILED),
+
+    UNKNOWN(TaskStatusEnum.UNKNOWN);
+
+    HaJobStatusEnum(TaskStatusEnum taskStatusEnum) {
+        this.status = taskStatusEnum.getCode();
+        this.value = taskStatusEnum.getMessage();
+    }
+
+    private final int status;
+
+    private final String value;
+
+    public int getStatus() {
+        return status;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public static HaJobStatusEnum valueOfStatus(int status) {
+        for (HaJobStatusEnum statusEnum : HaJobStatusEnum.values()) {
+            if (status == statusEnum.getStatus()) {
+                return statusEnum;
+            }
+        }
+
+        return HaJobStatusEnum.UNKNOWN;
+    }
+
+    public static HaJobStatusEnum getStatusBySubStatus(int totalJobNum,
+                                                       int successJobNu,
+                                                       int failedJobNu,
+                                                       int runningJobNu,
+                                                       int runningInTimeoutJobNu,
+                                                       int unknownJobNu) {
+        if (unknownJobNu > 0) {
+            return UNKNOWN;
+        }
+
+        if((failedJobNu + runningJobNu + runningInTimeoutJobNu + unknownJobNu) == 0) {
+            return SUCCESS;
+        }
+
+        if((runningJobNu + runningInTimeoutJobNu + unknownJobNu) == 0 && failedJobNu > 0) {
+            return FAILED;
+        }
+
+        if (runningInTimeoutJobNu > 0) {
+            return RUNNING_IN_TIMEOUT;
+        }
+
+        return RUNNING;
+    }
+
+    public static boolean isRunning(Integer jobStatus) {
+        return jobStatus != null && (RUNNING.status == jobStatus || RUNNING_IN_TIMEOUT.status == jobStatus);
+    }
+
+    public static boolean isFinished(Integer jobStatus) {
+        return jobStatus != null && (SUCCESS.status == jobStatus || FAILED.status == jobStatus);
+    }
+}

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/constant/ApiLevelContent.java

@@ -12,4 +12,7 @@ public class ApiLevelContent {
     public static final int LEVEL_NORMAL_3 = 3;
 
     public static final int LEVEL_DEFAULT_4 = 4;
+
+    private ApiLevelContent() {
+    }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/constant/ApiPrefix.java

@@ -22,4 +22,7 @@ public class ApiPrefix {
 
     // gateway
     public static final String GATEWAY_API_V1_PREFIX = "/gateway" + API_V1_PREFIX;
+
+    private ApiPrefix() {
+    }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/constant/ConfigConstant.java

@@ -30,4 +30,11 @@ public class ConfigConstant {
     public static final String BROKER_CAPACITY_LIMIT_CONFIG_KEY = "BROKER_CAPACITY_LIMIT_CONFIG";
 
     public static final String KAFKA_CLUSTER_DO_CONFIG_KEY = "KAFKA_CLUSTER_DO_CONFIG";
+
+    public static final String HA_SWITCH_JOB_TIMEOUT_UNIT_SEC_CONFIG_PREFIX = "HA_SWITCH_JOB_TIMEOUT_UNIT_SEC_CONFIG_CLUSTER";
+
+    public static final String HA_CONNECTION_ACTIVE_TIME_UNIT_MIN = "HA_CONNECTION_ACTIVE_TIME_UNIT_MIN";
+
+    private ConfigConstant() {
+    }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/constant/Constant.java

@@ -9,7 +9,7 @@ public class Constant {
 
     public static final Integer MAX_AVG_BYTES_DURATION = 10;
 
-    public static final Integer BATCH_INSERT_SIZE = 50;
+    public static final Integer BATCH_INSERT_SIZE = 30;
 
     public static final Integer DEFAULT_SESSION_TIMEOUT_UNIT_MS = 30000;
 
@@ -45,4 +45,7 @@ public class Constant {
     public static final Integer DEFAULT_MAX_CAL_TOPIC_EXPIRED_DAY = 90;
 
     public static final Integer INVALID_CODE = -1;
+
+    private Constant() {
+    }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/constant/KafkaConstant.java

@@ -16,4 +16,37 @@ public class KafkaConstant {
     public static final String CLIENT_VERSION_NAME_UNKNOWN = "unknown";
 
     public static final String RETENTION_MS_KEY = "retention.ms";
+
+    public static final String EXTERNAL_KEY = "EXTERNAL";
+
+    public static final String INTERNAL_KEY = "INTERNAL";
+
+    public static final String BOOTSTRAP_SERVERS = "bootstrap.servers";
+
+
+    /**
+     * HA
+     */
+
+    public static final String DIDI_KAFKA_ENABLE = "didi.kafka.enable";
+
+    public static final String DIDI_HA_REMOTE_CLUSTER = "didi.ha.remote.cluster";
+
+    // TODO 平台来管理配置，不需要底层来管理，因此可以删除该配置
+    public static final String DIDI_HA_SYNC_TOPIC_CONFIGS_ENABLED = "didi.ha.sync.topic.configs.enabled";
+
+    public static final String DIDI_HA_ACTIVE_CLUSTER = "didi.ha.active.cluster";
+
+    public static final String DIDI_HA_REMOTE_TOPIC = "didi.ha.remote.topic";
+
+    public static final String SECURITY_PROTOCOL = "security.protocol";
+
+    public static final String SASL_MECHANISM = "sasl.mechanism";
+
+    public static final String SASL_JAAS_CONFIG = "sasl.jaas.config";
+
+    public static final String NONE = "None";
+
+    private KafkaConstant() {
+    }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/constant/KafkaMetricsCollections.java

@@ -39,4 +39,7 @@ public class KafkaMetricsCollections {
      * Broker信息
      */
     public static final int BROKER_VERSION = 400;
+
+    private KafkaMetricsCollections() {
+    }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/constant/LogConstant.java

@@ -1,13 +0,0 @@
-package com.xiaojukeji.kafka.manager.common.constant;
-
-/**
- * @author zengqiao
- * @date 20/8/10
- */
-public class LogConstant {
-    public static final String COLLECTOR_METRICS_LOGGER = "COLLECTOR_METRICS_LOGGER";
-
-    public static final String API_METRICS_LOGGER = "API_METRICS_LOGGER";
-
-    public static final String SCHEDULED_TASK_LOGGER = "SCHEDULED_TASK_LOGGER";
-}

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/constant/LoginConstant.java

@@ -11,4 +11,7 @@ public class LoginConstant {
     public static final String COOKIE_CHINESE_USERNAME_KEY = "chineseName";
 
     public static final Integer COOKIE_OR_SESSION_MAX_AGE_UNIT_MS = 24 * 60 * 60 * 1000;
+
+    private LoginConstant() {
+    }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/constant/MsgConstant.java

@@ -0,0 +1,96 @@
+package com.xiaojukeji.kafka.manager.common.constant;
+
+/**
+ * 信息模版Constant
+ * @author zengqiao
+ * @date 22/03/03
+ */
+public class MsgConstant {
+    private MsgConstant() {
+    }
+
+    /**************************************************** Cluster ****************************************************/
+
+    public static String getClusterBizStr(Long clusterPhyId, String clusterName){
+        return String.format("集群ID:[%d] 集群名称:[%s]", clusterPhyId, clusterName);
+    }
+
+    public static String getClusterPhyNotExist(Long clusterPhyId) {
+        return String.format("集群ID:[%d] 不存在或者未加载", clusterPhyId);
+    }
+
+
+
+    /**************************************************** Broker ****************************************************/
+
+    public static String getBrokerNotExist(Long clusterPhyId, Integer brokerId) {
+        return String.format("集群ID:[%d] brokerId:[%d] 不存在或未存活", clusterPhyId, brokerId);
+    }
+
+    public static String getBrokerBizStr(Long clusterPhyId, Integer brokerId) {
+        return String.format("集群ID:[%d] brokerId:[%d]", clusterPhyId, brokerId);
+    }
+
+
+    /**************************************************** Topic ****************************************************/
+
+    public static String getTopicNotExist(Long clusterPhyId, String topicName) {
+        return String.format("集群ID:[%d] Topic名称:[%s] 不存在", clusterPhyId, topicName);
+    }
+
+    public static String getTopicBizStr(Long clusterPhyId, String topicName) {
+        return String.format("集群ID:[%d] Topic名称:[%s]", clusterPhyId, topicName);
+    }
+
+    public static String getTopicExtend(Long existPartitionNum, Long totalPartitionNum,String expandParam){
+        return  String.format("新增分区, 从:[%d] 增加到:[%d], 详细参数信息:[%s]", existPartitionNum,totalPartitionNum,expandParam);
+    }
+
+    public static String getClusterTopicKey(Long clusterPhyId, String topicName) {
+        return String.format("%d@%s", clusterPhyId, topicName);
+    }
+
+    /**************************************************** Partition ****************************************************/
+
+    public static String getPartitionNotExist(Long clusterPhyId, String topicName) {
+        return String.format("集群ID:[%d] Topic名称:[%s] 存在非法的分区ID", clusterPhyId, topicName);
+    }
+
+    public static String getPartitionNotExist(Long clusterPhyId, String topicName, Integer partitionId) {
+        return String.format("集群ID:[%d] Topic名称:[%s] 分区Id:[%d] 不存在", clusterPhyId, topicName, partitionId);
+    }
+
+    /**************************************************** KafkaUser ****************************************************/
+
+    public static String getKafkaUserBizStr(Long clusterPhyId, String kafkaUser) {
+        return String.format("集群ID:[%d] kafkaUser:[%s]", clusterPhyId, kafkaUser);
+    }
+
+    public static String getKafkaUserNotExist(Long clusterPhyId, String kafkaUser) {
+        return String.format("集群ID:[%d] kafkaUser:[%s] 不存在", clusterPhyId, kafkaUser);
+    }
+
+    public static String getKafkaUserDuplicate(Long clusterPhyId, String kafkaUser) {
+        return String.format("集群ID:[%d] kafkaUser:[%s] 已存在", clusterPhyId, kafkaUser);
+    }
+
+    /**************************************************** ha-Cluster ****************************************************/
+
+    public static String getActiveClusterDuplicate(Long clusterPhyId, String clusterName) {
+        return String.format("集群ID:[%d] 主集群:[%s] 已存在", clusterPhyId, clusterName);
+    }
+
+    /**************************************************** reassign ****************************************************/
+
+    public static String getReassignJobBizStr(Long jobId, Long clusterPhyId) {
+        return String.format("任务Id:[%d] 集群ID:[%s]", jobId, clusterPhyId);
+    }
+
+    public static String getJobIdCanNotNull() {
+        return "jobId不允许为空";
+    }
+
+    public static String getJobNotExist(Long jobId) {
+        return String.format("jobId:[%d] 不存在", jobId);
+    }
+}

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/constant/SystemCodeConstant.java

@@ -6,4 +6,7 @@ package com.xiaojukeji.kafka.manager.common.constant;
  */
 public class SystemCodeConstant {
     public static final String KAFKA_MANAGER = "kafka-manager";
+
+    private SystemCodeConstant() {
+    }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/constant/TopicCreationConstant.java

@@ -25,6 +25,8 @@ public class TopicCreationConstant {
 
     public static final String TOPIC_RETENTION_TIME_KEY_NAME = "retention.ms";
 
+    public static final String TOPIC_RETENTION_BYTES_KEY_NAME = "retention.bytes";
+
     public static final Long DEFAULT_QUOTA = 3 * 1024 * 1024L;
 
     public static Properties createNewProperties(Long retentionTime) {
@@ -54,4 +56,7 @@ public class TopicCreationConstant {
      * 单次自动化审批, 最多允许的通过单子
      */
     public static final Integer MAX_PASSED_ORDER_NUM_PER_TASK = 200;
+
+    private TopicCreationConstant() {
+    }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/constant/TopicSampleConstant.java

@@ -16,4 +16,7 @@ public class TopicSampleConstant {
     public static final Integer MAX_TIMEOUT_UNIT_MS = 10000;
     public static final Integer POLL_TIME_OUT_UNIT_MS = 2000;
     public static final Integer MAX_DATA_LENGTH_UNIT_BYTE = 2048;
+
+    private TopicSampleConstant() {
+    }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/constant/TrickLoginConstant.java

@@ -0,0 +1,24 @@
+package com.xiaojukeji.kafka.manager.common.constant;
+
+public class TrickLoginConstant {
+    /**
+     * HTTP Header key
+     */
+    public static final String TRICK_LOGIN_SWITCH = "Trick-Login-Switch";
+
+    public static final String TRICK_LOGIN_USER = "Trick-Login-User";
+
+    /**
+     * 配置允许 trick 登录用户名单
+     */
+    public static final String TRICK_LOGIN_LEGAL_USER_CONFIG_KEY = "SECURITY.TRICK_USERS";
+
+    /**
+     * 开关状态值
+     */
+    public static final String TRICK_LOGIN_SWITCH_ON = "on";
+    public static final String TRICK_LOGIN_SWITCH_OFF = "off";
+
+    private TrickLoginConstant() {
+    }
+}

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/BaseResult.java

@@ -0,0 +1,28 @@
+package com.xiaojukeji.kafka.manager.common.entity;
+
+import com.xiaojukeji.kafka.manager.common.constant.Constant;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.ToString;
+
+import java.io.Serializable;
+
+@Data
+@ToString
+public class BaseResult implements Serializable {
+    private static final long serialVersionUID = -5771016784021901099L;
+
+    @ApiModelProperty(value = "信息", example = "成功")
+    protected String message;
+
+    @ApiModelProperty(value = "状态", example = "0")
+    protected int code;
+
+    public boolean successful() {
+        return !this.failed();
+    }
+
+    public boolean failed() {
+        return !Constant.SUCCESS.equals(code);
+    }
+}

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/Result.java

@@ -1,21 +1,23 @@
 package com.xiaojukeji.kafka.manager.common.entity;
 
-import com.alibaba.fastjson.JSON;
-import com.xiaojukeji.kafka.manager.common.constant.Constant;
-
-import java.io.Serializable;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
 
 /**
  * @author huangyiminghappy@163.com
  * @date 2019-07-08
  */
-public class Result<T> implements Serializable {
-    private static final long serialVersionUID = -2772975319944108658L;
+@Data
+@ApiModel(description = "调用结果")
+public class Result<T> extends BaseResult {
+    @ApiModelProperty(value = "数据")
+    protected T data;
 
-    private T data;
-    private String message;
-    private String tips;
-    private int code;
+    public Result() {
+        this.code = ResultStatus.SUCCESS.getCode();
+        this.message = ResultStatus.SUCCESS.getMessage();
+    }
 
     public Result(T data) {
         this.data = data;
@@ -23,10 +25,6 @@ public class Result<T> implements Serializable {
         this.message = ResultStatus.SUCCESS.getMessage();
     }
 
-    public Result() {
-        this(null);
-    }
-
     public Result(Integer code, String message) {
         this.message = message;
         this.code = code;
@@ -38,98 +36,135 @@ public class Result<T> implements Serializable {
         this.code = code;
     }
 
-    public T getData()
-    {
-        return (T)this.data;
+    public static <T> Result<T> build(boolean succ) {
+        if (succ) {
+            return buildSuc();
+        }
+        return buildFail();
     }
 
-    public void setData(T data)
-    {
-        this.data = data;
+    public static <T> Result<T> buildFail() {
+        Result<T> result = new Result<>();
+        result.setCode(ResultStatus.FAIL.getCode());
+        result.setMessage(ResultStatus.FAIL.getMessage());
+        return result;
     }
 
-    public String getMessage()
-    {
-        return this.message;
+    public static <T> Result<T> build(boolean succ, T data) {
+        Result<T> result = new Result<>();
+        if (succ) {
+            result.setCode(ResultStatus.SUCCESS.getCode());
+            result.setMessage(ResultStatus.SUCCESS.getMessage());
+            result.setData(data);
+        } else {
+            result.setCode(ResultStatus.FAIL.getCode());
+            result.setMessage(ResultStatus.FAIL.getMessage());
+        }
+        return result;
     }
 
-    public void setMessage(String message)
-    {
-        this.message = message;
-    }
-
-    public String getTips() {
-        return tips;
-    }
-
-    public void setTips(String tips) {
-        this.tips = tips;
-    }
-
-    public int getCode()
-    {
-        return this.code;
-    }
-
-    public void setCode(int code)
-    {
-        this.code = code;
-    }
-
-    @Override
-    public String toString()
-    {
-        return JSON.toJSONString(this);
-    }
-
-    public static Result buildSuc() {
-        Result result = new Result();
+    public static <T> Result<T> buildSuc() {
+        Result<T> result = new Result<>();
         result.setCode(ResultStatus.SUCCESS.getCode());
         result.setMessage(ResultStatus.SUCCESS.getMessage());
         return result;
     }
 
     public static <T> Result<T> buildSuc(T data) {
-        Result<T> result = new Result<T>();
+        Result<T> result = new Result<>();
         result.setCode(ResultStatus.SUCCESS.getCode());
         result.setMessage(ResultStatus.SUCCESS.getMessage());
         result.setData(data);
         return result;
     }
 
-    public static <T> Result<T> buildGatewayFailure(String message) {
-        Result<T> result = new Result<T>();
-        result.setCode(ResultStatus.GATEWAY_INVALID_REQUEST.getCode());
-        result.setMessage(message);
-        result.setData(null);
-        return result;
-    }
-
     public static <T> Result<T> buildFailure(String message) {
-        Result<T> result = new Result<T>();
+        Result<T> result = new Result<>();
         result.setCode(ResultStatus.FAIL.getCode());
         result.setMessage(message);
         result.setData(null);
         return result;
     }
 
-    public static Result buildFrom(ResultStatus resultStatus) {
-        Result result = new Result();
-        result.setCode(resultStatus.getCode());
-        result.setMessage(resultStatus.getMessage());
+    public static <T> Result<T> buildFailure(String message,  T data) {
+        Result<T> result = new Result<>();
+        result.setCode(ResultStatus.FAIL.getCode());
+        result.setMessage(message);
+        result.setData(data);
         return result;
     }
 
-    public static Result buildFrom(ResultStatus resultStatus, Object data) {
-        Result result = new Result();
+    public static <T> Result<T> buildFailure(ResultStatus rs) {
+        Result<T> result = new Result<>();
+        result.setCode(rs.getCode());
+        result.setMessage(rs.getMessage());
+        result.setData(null);
+        return result;
+    }
+
+    public static <T> Result<T> buildGatewayFailure(String message) {
+        Result<T> result = new Result<>();
+        result.setCode(ResultStatus.GATEWAY_INVALID_REQUEST.getCode());
+        result.setMessage(message);
+        result.setData(null);
+        return result;
+    }
+
+    public static <T> Result<T> buildFrom(ResultStatus rs) {
+        Result<T> result = new Result<>();
+        result.setCode(rs.getCode());
+        result.setMessage(rs.getMessage());
+        return result;
+    }
+
+    public static <T> Result<T> buildFrom(ResultStatus resultStatus, T data) {
+        Result<T> result = new Result<>();
         result.setCode(resultStatus.getCode());
         result.setMessage(resultStatus.getMessage());
         result.setData(data);
         return result;
     }
 
-    public boolean failed() {
-        return !Constant.SUCCESS.equals(code);
+    public static <T> Result<T> buildFromRSAndMsg(ResultStatus resultStatus, String message) {
+        Result<T> result = new Result<>();
+        result.setCode(resultStatus.getCode());
+        result.setMessage(message);
+        result.setData(null);
+        return result;
     }
 
+    public static <T> Result<T> buildFromRSAndData(ResultStatus rs, T data) {
+        Result<T> result = new Result<>();
+        result.setCode(rs.getCode());
+        result.setMessage(rs.getMessage());
+        result.setData(data);
+        return result;
+    }
+
+    public static <T, U> Result<T> buildFromIgnoreData(Result<U> anotherResult) {
+        Result<T> result = new Result<>();
+        result.setCode(anotherResult.getCode());
+        result.setMessage(anotherResult.getMessage());
+        return result;
+    }
+
+    public static <T> Result<T> buildParamIllegal(String msg) {
+        Result<T> result = new Result<>();
+        result.setCode(ResultStatus.PARAM_ILLEGAL.getCode());
+        result.setMessage(ResultStatus.PARAM_ILLEGAL.getMessage() + ":" + msg + "，请检查后再提交！");
+        return result;
+    }
+
+    public boolean hasData(){
+        return !failed() && this.data != null;
+    }
+
+    @Override
+    public String toString() {
+        return "Result{" +
+                "message='" + message + '\'' +
+                ", code=" + code +
+                ", data=" + data +
+                '}';
+    }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/ResultStatus.java

@@ -23,6 +23,11 @@ public enum ResultStatus {
     API_CALL_EXCEED_LIMIT(1403, "api call exceed limit"),
     USER_WITHOUT_AUTHORITY(1404, "user without authority"),
     CHANGE_ZOOKEEPER_FORBIDDEN(1405, "change zookeeper forbidden"),
+    HA_CLUSTER_DELETE_FORBIDDEN(1409, "先删除主topic，才能删除该集群"),
+    HA_TOPIC_DELETE_FORBIDDEN(1410, "先解除高可用关系，才能删除该topic"),
+
+
+    APP_OFFLINE_FORBIDDEN(1406, "先下线topic，才能下线应用～"),
 
 
     TOPIC_OPERATION_PARAM_NULL_POINTER(1450, "参数错误"),
@@ -73,6 +78,8 @@ public enum ResultStatus {
     QUOTA_NOT_EXIST(7113, "quota not exist, please check clusterId, topicName and appId"),
     CONSUMER_GROUP_NOT_EXIST(7114, "consumerGroup not exist"),
     TOPIC_BIZ_DATA_NOT_EXIST(7115, "topic biz data not exist, please sync topic to db"),
+    SD_ZK_NOT_EXIST(7116, "SD_ZK未配置"),
+
 
     // 资源已存在
     RESOURCE_ALREADY_EXISTED(7200, "资源已经存在"),
@@ -85,6 +92,7 @@ public enum ResultStatus {
     RESOURCE_ALREADY_USED(7400, "资源早已被使用"),
 
 
+
     /**
      * 因为外部系统的问题, 操作时引起的错误, [8000, 9000)
      * ------------------------------------------------------------------------------------------
@@ -95,6 +103,7 @@ public enum ResultStatus {
     ZOOKEEPER_READ_FAILED(8021, "zookeeper read failed"),
     ZOOKEEPER_WRITE_FAILED(8022, "zookeeper write failed"),
     ZOOKEEPER_DELETE_FAILED(8023, "zookeeper delete failed"),
+    ZOOKEEPER_OPERATE_FAILED(8024, "zookeeper operate failed"),
 
     // 调用集群任务里面的agent失败
     CALL_CLUSTER_TASK_AGENT_FAILED(8030, " call cluster task agent failed"),

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/ao/ClusterDetailDTO.java

@@ -1,11 +1,14 @@
 package com.xiaojukeji.kafka.manager.common.entity.ao;
 
+import lombok.Data;
+
 import java.util.Date;
 
 /**
  * @author zengqiao
  * @date 20/4/23
  */
+@Data
 public class ClusterDetailDTO {
     private Long clusterId;
 
@@ -41,141 +44,9 @@ public class ClusterDetailDTO {
 
     private Integer regionNum;
 
-    public Long getClusterId() {
-        return clusterId;
-    }
+    private Integer haRelation;
 
-    public void setClusterId(Long clusterId) {
-        this.clusterId = clusterId;
-    }
-
-    public String getClusterName() {
-        return clusterName;
-    }
-
-    public void setClusterName(String clusterName) {
-        this.clusterName = clusterName;
-    }
-
-    public String getZookeeper() {
-        return zookeeper;
-    }
-
-    public void setZookeeper(String zookeeper) {
-        this.zookeeper = zookeeper;
-    }
-
-    public String getBootstrapServers() {
-        return bootstrapServers;
-    }
-
-    public void setBootstrapServers(String bootstrapServers) {
-        this.bootstrapServers = bootstrapServers;
-    }
-
-    public String getKafkaVersion() {
-        return kafkaVersion;
-    }
-
-    public void setKafkaVersion(String kafkaVersion) {
-        this.kafkaVersion = kafkaVersion;
-    }
-
-    public String getIdc() {
-        return idc;
-    }
-
-    public void setIdc(String idc) {
-        this.idc = idc;
-    }
-
-    public Integer getMode() {
-        return mode;
-    }
-
-    public void setMode(Integer mode) {
-        this.mode = mode;
-    }
-
-    public String getSecurityProperties() {
-        return securityProperties;
-    }
-
-    public void setSecurityProperties(String securityProperties) {
-        this.securityProperties = securityProperties;
-    }
-
-    public String getJmxProperties() {
-        return jmxProperties;
-    }
-
-    public void setJmxProperties(String jmxProperties) {
-        this.jmxProperties = jmxProperties;
-    }
-
-    public Integer getStatus() {
-        return status;
-    }
-
-    public void setStatus(Integer status) {
-        this.status = status;
-    }
-
-    public Date getGmtCreate() {
-        return gmtCreate;
-    }
-
-    public void setGmtCreate(Date gmtCreate) {
-        this.gmtCreate = gmtCreate;
-    }
-
-    public Date getGmtModify() {
-        return gmtModify;
-    }
-
-    public void setGmtModify(Date gmtModify) {
-        this.gmtModify = gmtModify;
-    }
-
-    public Integer getBrokerNum() {
-        return brokerNum;
-    }
-
-    public void setBrokerNum(Integer brokerNum) {
-        this.brokerNum = brokerNum;
-    }
-
-    public Integer getTopicNum() {
-        return topicNum;
-    }
-
-    public void setTopicNum(Integer topicNum) {
-        this.topicNum = topicNum;
-    }
-
-    public Integer getConsumerGroupNum() {
-        return consumerGroupNum;
-    }
-
-    public void setConsumerGroupNum(Integer consumerGroupNum) {
-        this.consumerGroupNum = consumerGroupNum;
-    }
-
-    public Integer getControllerId() {
-        return controllerId;
-    }
-
-    public void setControllerId(Integer controllerId) {
-        this.controllerId = controllerId;
-    }
-
-    public Integer getRegionNum() {
-        return regionNum;
-    }
-
-    public void setRegionNum(Integer regionNum) {
-        this.regionNum = regionNum;
-    }
+    private String mutualBackupClusterName;
 
     @Override
     public String toString() {
@@ -197,6 +68,8 @@ public class ClusterDetailDTO {
                 ", consumerGroupNum=" + consumerGroupNum +
                 ", controllerId=" + controllerId +
                 ", regionNum=" + regionNum +
+                ", haRelation=" + haRelation +
+                ", mutualBackupClusterName='" + mutualBackupClusterName + '\'' +
                 '}';
     }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/ao/RdTopicBasic.java

@@ -1,5 +1,7 @@
 package com.xiaojukeji.kafka.manager.common.entity.ao;
 
+import lombok.Data;
+
 import java.util.List;
 import java.util.Properties;
 
@@ -7,6 +9,7 @@ import java.util.Properties;
  * @author zengqiao
  * @date 20/6/10
  */
+@Data
 public class RdTopicBasic {
     private Long clusterId;
 
@@ -26,77 +29,7 @@ public class RdTopicBasic {
 
     private List<String> regionNameList;
 
-    public Long getClusterId() {
-        return clusterId;
-    }
-
-    public void setClusterId(Long clusterId) {
-        this.clusterId = clusterId;
-    }
-
-    public String getClusterName() {
-        return clusterName;
-    }
-
-    public void setClusterName(String clusterName) {
-        this.clusterName = clusterName;
-    }
-
-    public String getTopicName() {
-        return topicName;
-    }
-
-    public void setTopicName(String topicName) {
-        this.topicName = topicName;
-    }
-
-    public Long getRetentionTime() {
-        return retentionTime;
-    }
-
-    public void setRetentionTime(Long retentionTime) {
-        this.retentionTime = retentionTime;
-    }
-
-    public String getAppId() {
-        return appId;
-    }
-
-    public void setAppId(String appId) {
-        this.appId = appId;
-    }
-
-    public String getAppName() {
-        return appName;
-    }
-
-    public void setAppName(String appName) {
-        this.appName = appName;
-    }
-
-    public Properties getProperties() {
-        return properties;
-    }
-
-    public void setProperties(Properties properties) {
-        this.properties = properties;
-    }
-
-    public String getDescription() {
-        return description;
-    }
-
-    public void setDescription(String description) {
-        this.description = description;
-    }
-
-    public List<String> getRegionNameList() {
-        return regionNameList;
-    }
-
-    public void setRegionNameList(List<String> regionNameList) {
-        this.regionNameList = regionNameList;
-    }
+    private Integer haRelation;
 
     @Override
     public String toString() {
@@ -109,7 +42,8 @@ public class RdTopicBasic {
                 ", appName='" + appName + '\'' +
                 ", properties=" + properties +
                 ", description='" + description + '\'' +
-                ", regionNameList='" + regionNameList + '\'' +
+                ", regionNameList=" + regionNameList +
+                ", haRelation=" + haRelation +
                 '}';
     }
 }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/ao/common/FutureTaskDelayQueueData.java

@@ -0,0 +1,40 @@
+package com.xiaojukeji.kafka.manager.common.entity.ao.common;
+
+import lombok.Getter;
+
+import java.util.concurrent.Delayed;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+
+@Getter
+public class FutureTaskDelayQueueData<T> implements Delayed {
+    private final String taskName;
+
+    private final Future<T> futureTask;
+
+    private final long timeoutTimeUnitMs;
+
+    private final long createTimeUnitMs;
+
+    public FutureTaskDelayQueueData(String taskName, Future<T> futureTask, long timeoutTimeUnitMs) {
+        this.taskName = taskName;
+        this.futureTask = futureTask;
+        this.timeoutTimeUnitMs = timeoutTimeUnitMs;
+        this.createTimeUnitMs = System.currentTimeMillis();
+    }
+
+    @Override
+    public long getDelay(TimeUnit unit) {
+        return unit.convert(timeoutTimeUnitMs - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
+    }
+
+    @Override
+    public int compareTo(Delayed delayed) {
+        FutureTaskDelayQueueData<T> other = (FutureTaskDelayQueueData<T>) delayed;
+        if (this.timeoutTimeUnitMs == other.timeoutTimeUnitMs) {
+            return (this.timeoutTimeUnitMs + "_" + this.createTimeUnitMs).compareTo((other.timeoutTimeUnitMs + "_" + other.createTimeUnitMs));
+        }
+
+        return (this.timeoutTimeUnitMs - other.timeoutTimeUnitMs) <= 0 ? -1: 1;
+    }
+}

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/ao/common/IpPortData.java

@@ -0,0 +1,18 @@
+package com.xiaojukeji.kafka.manager.common.entity.ao.common;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.io.Serializable;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class IpPortData implements Serializable {
+    private static final long serialVersionUID = -428897032994630685L;
+
+    private String ip;
+
+    private String port;
+}

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/ao/config/expert/TopicExpiredConfig.java

@@ -10,6 +10,8 @@ import java.util.List;
 public class TopicExpiredConfig {
     private Integer minExpiredDay = 30;
 
+    private String filterRegex = "";
+
     private List<Long> ignoreClusterIdList = new ArrayList<>();
 
     public Integer getMinExpiredDay() {
@@ -28,10 +30,19 @@ public class TopicExpiredConfig {
         this.ignoreClusterIdList = ignoreClusterIdList;
     }
 
+    public String getFilterRegex() {
+        return filterRegex;
+    }
+
+    public void setFilterRegex(String filterRegex) {
+        this.filterRegex = filterRegex;
+    }
+
     @Override
     public String toString() {
         return "TopicExpiredConfig{" +
                 "minExpiredDay=" + minExpiredDay +
+                ", filterRegex='" + filterRegex + '\'' +
                 ", ignoreClusterIdList=" + ignoreClusterIdList +
                 '}';
     }

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/ao/gateway/TopicQuota.java

@@ -1,5 +1,7 @@
 package com.xiaojukeji.kafka.manager.common.entity.ao.gateway;
 
+import com.xiaojukeji.kafka.manager.common.entity.dto.gateway.TopicQuotaDTO;
+
 /**
  * @author zhongyuankai
  * @date 2020/4/27
@@ -65,4 +67,15 @@ public class TopicQuota {
                 ", consumeQuota=" + consumeQuota +
                 '}';
     }
+
+    public static TopicQuota buildFrom(TopicQuotaDTO dto) {
+        TopicQuota topicQuota = new TopicQuota();
+        topicQuota.setAppId(dto.getAppId());
+        topicQuota.setClusterId(dto.getClusterId());
+        topicQuota.setTopicName(dto.getTopicName());
+        topicQuota.setProduceQuota(dto.getProduceQuota());
+        topicQuota.setConsumeQuota(dto.getConsumeQuota());
+        return topicQuota;
+    }
+
 }