Merge branch 'master' into pipline

src/main/java/cn/qg/holmes/controller/k8s/EnvTemplateController.java

+package cn.qg.holmes.controller.k8s;
+
+import cn.qg.holmes.common.JsonResult;
+import cn.qg.holmes.config.annotation.RequiresPermissions;
+import cn.qg.holmes.entity.k8s.EnvTemplate;
+import cn.qg.holmes.entity.k8s.EnvTemplateDetail;
+import cn.qg.holmes.entity.k8s.EnvTemplateVo;
+import cn.qg.holmes.service.k8s.EnvTemplateDetailService;
+import cn.qg.holmes.service.k8s.EnvTemplateService;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@CrossOrigin
+@RestController
+@RequestMapping("/env/template")
+public class EnvTemplateController {
+
+    @Autowired
+    EnvTemplateService envTemplateService;
+
+    @Autowired
+    EnvTemplateDetailService envTemplateDetailService;
+
+    @GetMapping("/list")
+    public JsonResult getTemplateList(@RequestParam(defaultValue = "1") Integer pageNum,
+                                      @RequestParam(defaultValue = "10") Integer pageSize) {
+        IPage<EnvTemplate> envTemplateIPage = new Page<>(pageNum, pageSize);
+        IPage<EnvTemplate> IPage = envTemplateService.page(envTemplateIPage);
+        List<EnvTemplate> envTemplateList = IPage.getRecords();
+        List<EnvTemplateVo> envTemplateVoList = new ArrayList<>();
+        QueryWrapper<EnvTemplateDetail> queryWrapper = new QueryWrapper<>();
+        for (EnvTemplate envTemplate: envTemplateList) {
+            EnvTemplateVo envTemplateVo = new EnvTemplateVo();
+            envTemplateVo.setEnvTemplate(envTemplate);
+
+            queryWrapper.eq("template_id", envTemplate.getId());
+            List<EnvTemplateDetail> envTemplateDetailList = envTemplateDetailService.list(queryWrapper);
+            envTemplateVo.setEnvTemplateDetailList(envTemplateDetailList);
+            envTemplateVoList.add(envTemplateVo);
+            queryWrapper.clear();
+        }
+        Map<String, Object> map = new HashMap<>();
+        map.put("total",  IPage.getTotal());
+        map.put("list", envTemplateVoList);
+        return JsonResult.buildSuccessResult(map);
+    }
+
+    /**
+     * 获取所有的模板及其关联的服务
+     * @return
+     */
+    @GetMapping("/getAll")
+    public JsonResult getTemplateByName() {
+        List<Map<String, Object>> resultList = new ArrayList<>();
+        List<EnvTemplate> envTemplateList = envTemplateService.list();
+        QueryWrapper<EnvTemplateDetail> queryWrapper = new QueryWrapper<>();
+        for (EnvTemplate envTemplate: envTemplateList) {
+            Map<String, Object> map = new HashMap<>();
+            map.put("id", envTemplate.getId());
+            map.put("name", envTemplate.getName());
+            map.put("updateTime", envTemplate.getUpdateTime());
+            queryWrapper.eq("template_id", envTemplate.getId());
+            List<EnvTemplateDetail> envTemplateDetailList = envTemplateDetailService.list(queryWrapper);
+            for (EnvTemplateDetail envTemplateDetail: envTemplateDetailList) {
+                List<EnvTemplateDetail> envTemplateDetailListTemp;
+                if (map.containsKey(envTemplateDetail.getLabel())) {
+                    envTemplateDetailListTemp = (List<EnvTemplateDetail>) map.get(envTemplateDetail.getLabel());
+                } else {
+                    envTemplateDetailListTemp = new ArrayList<>();
+                }
+                envTemplateDetailListTemp.add(envTemplateDetail);
+                map.put(envTemplateDetail.getLabel(), envTemplateDetailListTemp);
+            }
+            queryWrapper.clear();
+            resultList.add(map);
+        }
+        return JsonResult.buildSuccessResult(resultList);
+    }
+
+    /**
+     * 新建模板
+     * @param envTemplateVo 模板虚拟实体类
+     * @return
+     */
+    @RequiresPermissions("docker:envTemplate:create")
+    @PostMapping("/create")
+    public JsonResult saveEnvTemplate(@RequestBody EnvTemplateVo envTemplateVo) {
+        EnvTemplate envTemplate = envTemplateVo.getEnvTemplate();
+        QueryWrapper<EnvTemplate> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("name", envTemplate.getName());
+        if (envTemplateService.getOne(queryWrapper) != null) {
+            return JsonResult.buildErrorStateResult("模板已存在！", false);
+        }
+        // 保存模板
+        if (!envTemplateService.save(envTemplate)) {
+            return JsonResult.buildErrorStateResult("模板创建失败！", false);
+        }
+        // 模板详情列表设置模板id
+        Integer templateId = envTemplateService.getOne(queryWrapper).getId();
+        List<EnvTemplateDetail> envTemplateDetailList = envTemplateVo.getEnvTemplateDetailList();
+        for (EnvTemplateDetail envTemplateDetail: envTemplateDetailList) {
+            envTemplateDetail.setTemplateId(templateId);
+        }
+        // 保存模板详情
+        if (!envTemplateDetailService.saveBatch(envTemplateDetailList)) {
+            return JsonResult.buildErrorStateResult("模板详情保存失败！", false);
+        }
+        return JsonResult.buildSuccessResult(true);
+    }
+
+    /**
+     * 编辑模板及模板详情
+     * @param envTemplateVo 模板列表
+     * @return
+     */
+    @RequiresPermissions("docker:envTemplate:modify")
+    @PostMapping("/modify")
+    public JsonResult modifyEnvTemplate(@RequestBody EnvTemplateVo envTemplateVo) {
+        EnvTemplate envTemplate = envTemplateVo.getEnvTemplate();
+        if (!envTemplateService.updateById(envTemplate)) {
+            return JsonResult.buildErrorStateResult("模板更新失败！", false);
+        }
+        // 参数传过来的列表
+        List<EnvTemplateDetail> envTemplateDetailList = envTemplateVo.getEnvTemplateDetailList();
+        // 查询出数据库里该模板的所有条目
+        QueryWrapper<EnvTemplateDetail> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("template_id", envTemplate.getId());
+        List<EnvTemplateDetail> envTemplateDetailListDb = envTemplateDetailService.list(queryWrapper);
+
+        // 删除传参里没有的
+        for (EnvTemplateDetail envTemplateDetailDb: envTemplateDetailListDb) {
+            boolean delete = true;
+            for (EnvTemplateDetail envTemplateDetail: envTemplateDetailList) {
+                if (envTemplateDetail.getId() != null) {
+                    if (envTemplateDetail.getId().equals(envTemplateDetailDb.getId())) {
+                        delete = false;
+                        break;
+                    }
+                }
+            }
+            if (delete) {
+                envTemplateDetailService.removeById(envTemplateDetailDb.getId());
+            }
+        }
+        // 设置一下templateId
+        envTemplateDetailList.forEach(envTemplateDetail -> {
+            envTemplateDetail.setTemplateId(envTemplate.getId());
+        });
+        // 剩余的批量新增/修改
+        if (!envTemplateDetailService.saveOrUpdateBatch(envTemplateDetailList)) {
+            return JsonResult.buildErrorStateResult("更新模板详情失败！", false);
+        }
+        return JsonResult.buildSuccessResult("模板更新成功");
+    }
+
+    /**
+     *
+     * @param templateId 模板id
+     * @return
+     */
+    @RequiresPermissions("docker:envTemplate:delete")
+    @PostMapping("/delete")
+    public JsonResult deleteEnvTemplate(@RequestParam Integer templateId) {
+       if (!envTemplateService.removeById(templateId)) {
+           return JsonResult.buildErrorStateResult("模板删除失败！", false);
+       }
+       QueryWrapper<EnvTemplateDetail> queryWrapper = new QueryWrapper<>();
+       queryWrapper.eq("template_id", templateId);
+       if (!envTemplateDetailService.remove(queryWrapper)) {
+           return JsonResult.buildErrorStateResult("模板详情删除失败", false);
+       }
+       return JsonResult.buildSuccessResult("模板删除成功！");
+    }
+}

src/main/java/cn/qg/holmes/controller/k8s/K8sController.java

@@ -3,20 +3,26 @@ package cn.qg.holmes.controller.k8s;
 import cn.qg.holmes.common.JsonResult;
 import cn.qg.holmes.entity.auth.UserInfoVo;
 import cn.qg.holmes.entity.k8s.DockerProject;
+import cn.qg.holmes.entity.k8s.EnvTemplateDetail;
 import cn.qg.holmes.entity.k8s.ServiceCreateVo;
 import cn.qg.holmes.service.auth.TokenService;
 import cn.qg.holmes.service.k8s.*;
+import cn.qg.holmes.utils.RedisUtils;
 import com.alibaba.fastjson.JSON;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.jayway.jsonpath.JsonPath;
 import com.tencentcloudapi.tcr.v20190924.models.RepoInfo;
+import com.tencentcloudapi.tcr.v20190924.models.TagInfo;
+import io.fabric8.kubernetes.api.model.Namespace;
 import io.fabric8.kubernetes.api.model.ServicePort;
 import io.fabric8.kubernetes.api.model.apps.Deployment;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.*;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 /**
  * k8及容器操作相关接口
@@ -46,6 +52,15 @@ public class K8sController {
     @Autowired
     TokenService tokenService;
 
+    @Autowired
+    EnvTemplateService envTemplateService;
+
+    @Autowired
+    EnvTemplateDetailService envTemplateDetailService;
+
+    @Autowired
+    RedisUtils redisUtils;
+
     /**
      * 获取namespace列表
      * @return
@@ -398,6 +413,16 @@ public class K8sController {
         return JsonResult.buildSuccessResult(mqService.setDefinitions(host));
     }
 
+    /**
+     * 比较线上和测试mq
+     * @param host
+     * @return
+     */
+    @GetMapping("/mq/diff")
+    public JsonResult getMqDiffResult(@RequestParam String host) {
+        return JsonResult.buildSuccessResult(mqService.getMqDiff(host));
+    }
+
     /**
      * 情况测试环境redis
      * @param namespace 环境
@@ -425,8 +450,107 @@ public class K8sController {
     @PostMapping("/namespace/create")
     public JsonResult createNewNamespace(@RequestParam String name,
                                          @RequestParam String desc,
-                                         @RequestParam String owner) {
-        return JsonResult.buildSuccessResult(k8sService.createNewNamespace(name, desc, owner));
+                                         @RequestParam String owner,
+                                         @RequestParam String templateId) {
+        boolean createNamespace = k8sService.createNewNamespace(name, desc, owner);
+        if (!createNamespace) {
+            return JsonResult.buildErrorStateResult("环境创建失败！", false);
+        }
+        QueryWrapper<EnvTemplateDetail> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("template_id", templateId);
+        List<EnvTemplateDetail> envTemplateDetailList = envTemplateDetailService.list(queryWrapper);
+        for (EnvTemplateDetail envTemplateDetail: envTemplateDetailList) {
+            String label = envTemplateDetail.getLabel();
+            String image = envTemplateDetail.getTag();
+            String serviceName = envTemplateDetail.getServiceName();
+            String serviceType = envTemplateDetail.getServiceType();
+            String domain = envTemplateDetail.getDomain();
+            // 处理基础服务
+            if (label.equals("base")) {
+                switch (serviceType) {
+                    case "mysql":
+                        k8sService.createMysqlPvc(name);
+                        k8sService.createMysqlDeployment(name, image);
+                        k8sService.createMysqlService(name);
+                        break;
+                    case "mongodb":
+                        k8sService.createMongodbPvc(name);
+                        k8sService.createMongoDbDeployment(name, image);
+                        k8sService.createMongodbService(name);
+                        break;
+                    case "redis":
+                        k8sService.createRedisDeployment(name, image);
+                        k8sService.createRedisService(name);
+                        break;
+                    case "rabbitmq":
+                        k8sService.createRabbitmqPvc(name);
+                        k8sService.createRabbitmqDeployment(name, image);
+                        k8sService.createRabbitmqService(name);
+                    case "zookeeper":
+                        k8sService.createZookeeperPvc(name);
+                        k8sService.createZookeeperDeployment(name, image);
+                        k8sService.createZookeeperService(name);
+                    default:
+                        break;
+                }
+            }
+
+            if (label.equals("java")) {
+                ServiceCreateVo serviceCreateVo = new ServiceCreateVo();
+                serviceCreateVo.setServiceName(serviceName);
+                serviceCreateVo.setNamespace(name);
+                serviceCreateVo.setImage(image);
+                serviceCreateVo.setType(serviceType);
+                serviceCreateVo.setDebug(0);
+                serviceCreateVo.setMock(0);
+                serviceCreateVo.setLabel(label);
+                serviceCreateVo.setDomain(domain);
+
+                QueryWrapper<DockerProject> dockerProjectQueryWrapper = new QueryWrapper<>();
+                dockerProjectQueryWrapper
+                        .eq("project_name", serviceName)
+                        .eq("project_type", serviceType)
+                        .eq("is_active", 1)
+                        .eq("deploy_to_docker", 1);
+                DockerProject dockerProject = dockerProjectService.getOne(dockerProjectQueryWrapper);
+                dockerProjectQueryWrapper.clear();
+                if (dockerProject != null) {
+                    k8sService.createJavaDeployment(serviceCreateVo, dockerProject);
+                    k8sService.createJavaService(name, serviceName, serviceCreateVo.getDebug());
+                    k8sService.createIngress(name, serviceName, domain);
+                }
+            }
+            if (label.equals("ui") || label.equals("node")) {
+                ServiceCreateVo serviceCreateVo = new ServiceCreateVo();
+                serviceCreateVo.setServiceName(serviceName);
+                serviceCreateVo.setNamespace(name);
+                serviceCreateVo.setImage(image);
+                serviceCreateVo.setType(serviceType);
+                serviceCreateVo.setDebug(0);
+                serviceCreateVo.setMock(0);
+                serviceCreateVo.setLabel(label);
+                serviceCreateVo.setDomain(domain);
+
+                QueryWrapper<DockerProject> dockerProjectQueryWrapper = new QueryWrapper<>();
+                dockerProjectQueryWrapper
+                        .eq("project_name", serviceName)
+                        .eq("project_type", serviceType)
+                        .eq("is_active", 1)
+                        .eq("deploy_to_docker", 1);
+                DockerProject dockerProject = dockerProjectService.getOne(dockerProjectQueryWrapper);
+                dockerProjectQueryWrapper.clear();
+                if (dockerProject != null) {
+                    k8sService.createUIAndNodeDeployment(serviceCreateVo, dockerProject);
+                    k8sService.createUIAndNodeService(name, serviceName, serviceType, label);
+                    k8sService.createIngress(name, serviceName, domain);
+                }
+            }
+        }
+        // 删除相关缓存
+        redisUtils.del("k8s:namespace:all");
+        redisUtils.del("k8s:namespace:test");
+        redisUtils.del("k8s:namespace:dev");
+        return JsonResult.buildSuccessResult("环境创建成功");
     }
 
     /**
@@ -466,6 +590,65 @@ public class K8sController {
         return String.join("\n", resultList);
     }
 
+    /**
+     * 按照类型获取所有的服务
+     * @return
+     */
+    @GetMapping("/repo/getAll")
+    public JsonResult getAllRepos() {
+        List<Map<String, Object>> resultMapList = new ArrayList<>();
+        List<RepoInfo> repoInfoList = imageService.getRepoInfoList("qa-base");
+        Map<String, Object> base = new HashMap<>();
+        List<Map<String, String>> baseList = new ArrayList<>();
+        for (RepoInfo repoInfo: repoInfoList) {
+            String serviceName = repoInfo.getRepoName().split("/")[1];
+            TagInfo[] tagInfos = imageService.getImageListByService(repoInfo.getRepoName()).getTagInfo();
+            for (TagInfo tagInfo: tagInfos) {
+                Map<String, String> map = new HashMap<>();
+                map.put("serviceName", serviceName + ":" + tagInfo.getTagName());
+                map.put("serviceType", serviceName);
+                map.put("label", "base");
+                map.put("tag", "qa-base/" + serviceName + ":" + tagInfo.getTagName());
+                map.put("domain", serviceName + tagInfo.getTagName());
+                baseList.add(map);
+            }
+        }
+        base.put("type", "base");
+        base.put("repos", baseList);
+        resultMapList.add(base);
+
+        QueryWrapper<DockerProject> queryWrapper = new QueryWrapper<>();
+        queryWrapper.groupBy("project_type").select("project_type");
+        List<DockerProject> projectList = dockerProjectService.list(queryWrapper);
+        queryWrapper.clear();
+
+        for (DockerProject dp: projectList) {
+            String type = dp.getProjectType();
+            Map<String, Object> serviceMap = new HashMap<>();
+            List<Map<String, String>> serviceMapList = new ArrayList<>();
+            queryWrapper
+                    .eq("project_type", type)
+                    .eq("is_active", 1)
+                    .eq("deploy_to_docker", 1);
+            List<DockerProject> dockerProjectList = dockerProjectService.list(queryWrapper);
+            for (DockerProject dockerProject: dockerProjectList) {
+                Map<String, String> map = new HashMap<>();
+                map.put("serviceType", type);
+                map.put("label", type);
+                map.put("serviceName", dockerProject.getProjectName());
+                map.put("domain", dockerProject.getHostName().split("\\.")[0]);
+                map.put("tag", "qa-test/" + dockerProject.getProjectName() + ":latest");
+                serviceMapList.add(map);
+            }
+            serviceMap.put("type", type);
+            serviceMap.put("repos", serviceMapList);
+            resultMapList.add(serviceMap);
+            queryWrapper.clear();
+        }
+
+        return JsonResult.buildSuccessResult(resultMapList);
+    }
+
     /**
      * 给打包用的，获取dubbo接口
      * @param namespace 环境
@@ -479,7 +662,6 @@ public class K8sController {
                                @RequestParam String serviceType,
                                @RequestParam String serviceName,
                                @RequestParam String key) {
-        log.info("获取dubbo接口收到参数：{}, {}, {}, {}", namespace, serviceType, serviceName, key);
         List<ServicePort> servicePortList = k8sService.getServiceDetail(namespace, serviceName).getSpec().getPorts();
         Map<String, Object> serviceMap = new HashMap<>();
         List<Map<String, Object>> portMappingList = new ArrayList<>();
@@ -500,7 +682,10 @@ public class K8sController {
         serviceMap.put("portMappings", portMappingList);
         serviceMap.put("serviceName", serviceName);
         serviceMap.put("namespace", namespace);
-        log.info("返回结果为：{}", JSON.toJSONString(serviceMap));
-        return serviceMap.get(key).toString();
+        if (serviceMap.containsKey(key)) {
+            return serviceMap.get(key).toString();
+        } else {
+            return JSON.toJSONString(serviceMap);
+        }
     }
 }

src/main/java/cn/qg/holmes/entity/k8s/EnvTemplate.java

+package cn.qg.holmes.entity.k8s;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * 环境模板实体类
+ * @author libo
+ */
+@TableName(value = "env_template")
+@Data
+public class EnvTemplate {
+    @TableId(type = IdType.AUTO)
+    private Integer id;
+
+    private String name;
+
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private Date updateTime;
+}

src/main/java/cn/qg/holmes/entity/k8s/EnvTemplateDetail.java

+package cn.qg.holmes.entity.k8s;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+
+import java.util.Date;
+
+@Data
+@TableName(value = "env_template_detail")
+public class EnvTemplateDetail {
+    @TableId(type = IdType.AUTO)
+    private Integer id;
+
+    private String serviceName;
+
+    private String serviceType;
+
+    private String label;
+
+    private String domain;
+
+    private String tag;
+
+    private Integer templateId;
+
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private Date updateTime;
+}

src/main/java/cn/qg/holmes/entity/k8s/EnvTemplateVo.java

+package cn.qg.holmes.entity.k8s;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 创建环境模板虚拟实体类
+ */
+@Data
+public class EnvTemplateVo {
+
+    private EnvTemplate envTemplate;
+
+    private List<EnvTemplateDetail> envTemplateDetailList;
+}

src/main/java/cn/qg/holmes/mapper/k8s/EnvTemplateDetailMapper.java

+package cn.qg.holmes.mapper.k8s;
+
+import cn.qg.holmes.entity.k8s.EnvTemplateDetail;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+public interface EnvTemplateDetailMapper extends BaseMapper<EnvTemplateDetail> {
+}

src/main/java/cn/qg/holmes/mapper/k8s/EnvTemplateMapper.java

+package cn.qg.holmes.mapper.k8s;
+
+import cn.qg.holmes.entity.k8s.EnvTemplate;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+public interface EnvTemplateMapper extends BaseMapper<EnvTemplate> {
+}

src/main/java/cn/qg/holmes/service/k8s/EnvTemplateDetailService.java

+package cn.qg.holmes.service.k8s;
+
+import cn.qg.holmes.entity.k8s.EnvTemplateDetail;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+public interface EnvTemplateDetailService extends IService<EnvTemplateDetail> {
+}

src/main/java/cn/qg/holmes/service/k8s/EnvTemplateService.java

+package cn.qg.holmes.service.k8s;
+
+import cn.qg.holmes.entity.k8s.EnvTemplate;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+public interface EnvTemplateService extends IService<EnvTemplate> {
+}

src/main/java/cn/qg/holmes/service/k8s/ImageService.java

@@ -45,12 +45,13 @@ public class ImageService {
      * @param repoName 服务名
      * @return
      */
-    public Map<String, Object> getImageListByService(String repoName) {
+    public TagInfoResp getImageListByService(String repoName) {
         try {
             DescribeImagePersonalRequest request = new DescribeImagePersonalRequest();
             request.setRepoName(repoName);
             DescribeImagePersonalResponse response = tcrClient.DescribeImagePersonal(request);
-            return JSON.parseObject(DescribeImagePersonalResponse.toJsonString(response.getData()), Map.class);
+//            return JSON.parseObject(DescribeImagePersonalResponse.toJsonString(response.getData()), Map.class);
+            return response.getData();
         } catch (Exception e) {
             e.printStackTrace();
             return null;
@@ -97,7 +98,8 @@ public class ImageService {
 
     public static void main(String[] args) {
         ImageService imageService = new ImageService();
-        System.out.println(JSON.toJSONString(imageService.getRepoInfoList("qa-test")));
+//        System.out.println(JSON.toJSONString(imageService.getRepoInfoList("qa-base")));
+        System.out.println(JSON.toJSONString(imageService.getImageListByService("qa-base/mongodb")));
     }
 
 }

src/main/java/cn/qg/holmes/service/k8s/K8sService.java

@@ -324,7 +324,7 @@ public class K8sService {
         // 对象转列表
         List<Map<String, Object>> resultList = new ArrayList<>();
         for (Map<String, Object> map: podServiceMap.values()) {
-            if (map != null) {
+            if ((map != null) && (map.get("serviceName") != null))  {
                 resultList.add(map);
             }
         }
@@ -1402,7 +1402,7 @@ public class K8sService {
     public Service createMongodbService(String namespace) {
         Service mongodbService = new Service();
 
-        ObjectMeta objectMeta = buildObjectMeta("fe", "mongodb", "base");
+        ObjectMeta objectMeta = buildObjectMeta(namespace, "mongodb", "base");
 
         ServiceSpec serviceSpec = new ServiceSpec();
         serviceSpec.setType("NodePort");
@@ -1507,7 +1507,7 @@ public class K8sService {
         cpuRequest.setFormat("m");
         memoryRequest.setAmount("256");
         memoryRequest.setFormat("Mi");
-        cpuLimit.setAmount("250");
+        cpuLimit.setAmount("1024");
         cpuLimit.setFormat("m");
         memoryLimit.setAmount("512");
         memoryLimit.setFormat("Mi");
@@ -2200,30 +2200,81 @@ public class K8sService {
      * @param owner
      * @return
      */
-    public Namespace createNewNamespace(String name, String desc, String owner) {
-        Namespace namespace = new Namespace();
+    public boolean createNewNamespace(String name, String desc, String owner) {
+        try {
+            Namespace namespace = new Namespace();
+            ObjectMeta objectMeta = new ObjectMeta();
+            Map<String, String> annotations = new HashMap<>();
+            annotations.put("description", desc);
+            annotations.put("owner", owner);
+            objectMeta.setAnnotations(annotations);
+            objectMeta.setName(name);
+
+            NamespaceSpec namespaceSpec = new NamespaceSpec();
+            List<String> finalizers = new ArrayList<>();
+            finalizers.add("kubernetes");
+            namespaceSpec.setFinalizers(finalizers);
+
+            NamespaceStatus namespaceStatus = new NamespaceStatus();
+            namespaceStatus.setPhase("Active");
+
+            namespace.setApiVersion("v1");
+            namespace.setKind("Namespace");
+            namespace.setMetadata(objectMeta);
+            namespace.setSpec(namespaceSpec);
+            namespace.setStatus(namespaceStatus);
+            log.info("创建新的环境: {}", namespace.toString());
+            kubernetesClient.namespaces().create(namespace);
+            createQcloudRegistryKeySecret(name);
+            createTencenthHubKeySecret(name);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+        return true;
+    }
+
+    public Secret createQcloudRegistryKeySecret(String namespace) {
+        Secret secret = new Secret();
+
         ObjectMeta objectMeta = new ObjectMeta();
-        Map<String, String> annotations = new HashMap<>();
-        annotations.put("description", desc);
-        annotations.put("owner", owner);
-        objectMeta.setAnnotations(annotations);
-        objectMeta.setName(name);
-
-        NamespaceSpec namespaceSpec = new NamespaceSpec();
-        List<String> finalizers = new ArrayList<>();
-        finalizers.add("kubernetes");
-        namespaceSpec.setFinalizers(finalizers);
-
-        NamespaceStatus namespaceStatus = new NamespaceStatus();
-        namespaceStatus.setPhase("Active");
-
-        namespace.setApiVersion("v1");
-        namespace.setKind("Namespace");
-        namespace.setMetadata(objectMeta);
-        namespace.setSpec(namespaceSpec);
-        namespace.setStatus(namespaceStatus);
-        log.info("创建新的环境: {}", namespace.toString());
-        return kubernetesClient.namespaces().create(namespace);
+        Map<String, String> labels = new HashMap<>();
+        labels.put("qcloud-app", "qcloudregistrykey");
+        objectMeta.setLabels(labels);
+        objectMeta.setName("qcloudregistrykey");
+        objectMeta.setNamespace(namespace);
+
+        Map<String, String> data = new HashMap<>();
+        data.put(".dockercfg", "eyJjY3IuY2NzLnRlbmNlbnR5dW4uY29tIjp7InVzZXJuYW1lIjoiMTAwMDA4NjMyMjY5IiwicGFzc3dvcmQiOiJ7QXBwbGljYXRpb25Ub2tlbjo0MTM1NWY2OWQyY2U3ZWUyYmE2YjQxZmMxNzJlNzM0MH0iLCJlbWFpbCI6IjEwMDAwODYzMjI2OUBxcS5jb20iLCJhdXRoIjoiTVRBd01EQTROak15TWpZNU9udEJjSEJzYVdOaGRHbHZibFJ2YTJWdU9qUXhNelUxWmpZNVpESmpaVGRsWlRKaVlUWmlOREZtWXpFM01tVTNNelF3ZlE9PSJ9fQ==");
+
+        secret.setApiVersion("v1");
+        secret.setKind("Secret");
+        secret.setType("kubernetes.io/dockercfg");
+        secret.setMetadata(objectMeta);
+        secret.setData(data);
+        log.info("{}环境，创建新的secret：qcloudregistrykey", namespace);
+        return kubernetesClient.secrets().inNamespace(namespace).create(secret);
+    }
+
+    public Secret createTencenthHubKeySecret(String namespace) {
+        Secret secret = new Secret();
+
+        ObjectMeta objectMeta = new ObjectMeta();
+        Map<String, String> labels = new HashMap<>();
+        labels.put("qcloud-app", "tencenthubkey");
+        objectMeta.setLabels(labels);
+        objectMeta.setName("tencenthubkey");
+        objectMeta.setNamespace(namespace);
+
+        Map<String, String> data = new HashMap<>();
+        data.put(".dockercfg", "eyJodWIudGVuY2VudHl1bi5jb20iOnsidXNlcm5hbWUiOiIxMDAwMDg2MzIyNjkiLCJwYXNzd29yZCI6ImV5SmhiR2NpT2lKSVV6STFOaUlzSW5SNWNDSTZJa3BYVkNKOS5leUpsZUhBaU9qRTROell5T1RFME9EVXNJbXAwYVNJNklqVTVPVGRqTmpkaExUWmpaV1l0TkRGbE55MDVPRGsyTFdGaE16TTFPRGRpWW1ReE1TSXNJbWxoZENJNk1UVTJNRGt6TVRRNE5Td2libUptSWpveE5UWXdPVE14TkRnMUxDSnpkV0lpT2lJeE1EQXdNRGcyTXpJeU5qa2lmUS5ZWEl4TzBaWTg3QmNzSktLdW9lQ3gzYllLZ1RzMktNVElSeDd5dWVRdDZNIiwiZW1haWwiOiIxMDAwMDg2MzIyNjlAcXEuY29tIiwiYXV0aCI6Ik1UQXdNREE0TmpNeU1qWTVPbVY1U21oaVIyTnBUMmxLU1ZWNlNURk9hVWx6U1c1U05XTkRTVFpKYTNCWVZrTktPUzVsZVVwc1pVaEJhVTlxUlRST2VsbDVUMVJGTUU5RVZYTkpiWEF3WVZOSk5rbHFWVFZQVkdScVRtcGthRXhVV21wYVYxbDBUa1JHYkU1NU1EVlBSR3N5VEZkR2FFMTZUVEZQUkdScFdXMVJlRTFUU1hOSmJXeG9aRU5KTmsxVVZUSk5SR3Q2VFZSUk5FNVRkMmxpYlVwdFNXcHZlRTVVV1hkUFZFMTRUa1JuTVV4RFNucGtWMGxwVDJsSmVFMUVRWGROUkdjeVRYcEplVTVxYTJsbVVTNVpXRWw0VHpCYVdUZzNRbU56U2t0TGRXOWxRM2d6WWxsTFoxUnpNa3ROVkVsU2VEZDVkV1ZSZERaTiJ9fQ==");
+        secret.setApiVersion("v1");
+        secret.setKind("Secret");
+        secret.setType("kubernetes.io/dockercfg");
+        secret.setMetadata(objectMeta);
+        secret.setData(data);
+        log.info("{}环境，创建新的secret：qcloudregistrykey", namespace);
+        return kubernetesClient.secrets().inNamespace(namespace).create(secret);
     }
 
     /**
@@ -2257,13 +2308,14 @@ public class K8sService {
     }
 
     public static void main(String[] args) {
-//        K8sService k8sService = new K8sService();
-//        k8sService.createNewNamespace("test6", "dev", "黎博");
+        K8sService k8sService = new K8sService();
+        k8sService.createNewNamespace("test6", "dev", "黎博");
 //        k8sService.podTest();
 //        k8sService.getPodList("k8s");
 //        System.out.println(JSON.toJSONString(k8sService.getPodListNew("fe")));
 //        if (!k8sService.queryIfServiceExistByName("fe", "lxq-ui")) {
 //            k8sService.createUIAndNodeService("fe", "lxq-ui", "ui", "ui");
 //        }
+
     }
 }

src/main/java/cn/qg/holmes/service/k8s/MqService.java

@@ -16,6 +16,7 @@ public class MqService {
 
     /**
      * 获取MQ信息
+     *
      * @param host
      * @param auth
      * @return
@@ -29,6 +30,7 @@ public class MqService {
 
     /**
      * 同步线上MQ到测试
+     *
      * @param host
      * @return
      */
@@ -39,7 +41,7 @@ public class MqService {
             Map<String, Object> onlineDefinitions = getDefinitionsOfHost(ONLINE_MQ_URL, ONLINE_MQ_AUTH);
             List<Map<String, String>> permissionList = (List<Map<String, String>>) onlineDefinitions.get("permissions");
             List<Map<String, String>> qaPermissionList = new ArrayList<>();
-            for (Map<String, String> permission: permissionList) {
+            for (Map<String, String> permission : permissionList) {
                 if (permission.get("user").equals("rabbit_admin")) {
                     qaPermissionList.add(permission);
                     permission.put("user", "qa");
@@ -65,6 +67,71 @@ public class MqService {
         }
     }
 
+    /**
+     * 获取 sourceMapList 比 targetMapList 多出的元素
+     *
+     * @param sourceMapList
+     * @param targetMapList
+     * @return
+     */
+    public List<String> mqListCompare(List<Map<String, String>> sourceMapList, List<Map<String, String>> targetMapList) {
+        List<String> resultList = new ArrayList<>();
+        for (Map<String, String> sourceMap : sourceMapList) {
+            boolean flag = false;
+            for (Map<String, String> targetMap : targetMapList) {
+                if (sourceMap.get("name").equals(targetMap.get("name"))) {
+                    flag = true;
+                }
+            }
+            if (!flag) {
+                resultList.add(sourceMap.get("name"));
+            }
+        }
+        return resultList;
+    }
+
+    /**
+     * 比较测试环境与线上mq
+     * @param host 测试环境mq地址：ip+端口
+     * @return
+     */
+    public Map<String, Object> getMqDiff(String host) {
+        String ONLINE_MQ_URL = "http://172.30.3.140:15672";
+        String ONLINE_MQ_AUTH = "Basic cmFiYml0X2FkbWluOmFiYzEyMzQ=";
+        Map<String, Object> onlineDefinitions = getDefinitionsOfHost(ONLINE_MQ_URL, ONLINE_MQ_AUTH);
+        String qaMqUrl = "http://" + host;
+        String QA_MQ_AUTH = "Basic cWE6cWF0ZXN0";
+        Map<String, Object> qaDefinitions = getDefinitionsOfHost(qaMqUrl, QA_MQ_AUTH);
+        List<Map<String, String>> onlineHostList = (List<Map<String, String>>) onlineDefinitions.get("vhosts");
+        List<Map<String, String>> qaHostList = (List<Map<String, String>>) qaDefinitions.get("vhosts");
+        List<Map<String, String>> onlineQueueList = (List<Map<String, String>>) onlineDefinitions.get("queues");
+        List<Map<String, String>> qaQueueList = (List<Map<String, String>>) qaDefinitions.get("queues");
+        List<String> lostVhostList = mqListCompare(onlineHostList, qaHostList);
+        List<String> moreVhostList = mqListCompare(qaHostList, onlineHostList);
+        List<String> lostQueueList = mqListCompare(onlineQueueList, qaQueueList);
+        List<String> moreQueueList = mqListCompare(qaQueueList, onlineQueueList);
+        Map<String, Object> map = new HashMap<>();
+        Map<String, Object> lostMap = new HashMap<>();
+        lostMap.put("vhost", lostVhostList);
+        lostMap.put("queue", lostQueueList);
+        Map<String, Object> moreMap = new HashMap<>();
+        moreMap.put("vhost", moreVhostList);
+        moreMap.put("queue", moreQueueList);
+        if (lostVhostList.size() > 0 || lostQueueList.size() > 0) {
+            lostMap.put("show", true);
+        } else {
+            lostMap.put("show", false);
+        }
+        if (moreVhostList.size() > 0 || moreQueueList.size() > 0) {
+            moreMap.put("show", true);
+        } else {
+            moreMap.put("show", false);
+        }
+        map.put("lost", lostMap);
+        map.put("more", moreMap);
+        return map;
+    }
+
     public static void main(String[] args) {
         MqService mqService = new MqService();
         mqService.setDefinitions("172.17.5.17:31426");

src/main/java/cn/qg/holmes/service/k8s/impl/EnvTemplateDetailServiceImpl.java

+package cn.qg.holmes.service.k8s.impl;
+
+import cn.qg.holmes.entity.k8s.EnvTemplateDetail;
+import cn.qg.holmes.mapper.k8s.EnvTemplateDetailMapper;
+import cn.qg.holmes.service.k8s.EnvTemplateDetailService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.stereotype.Service;
+
+@Service
+public class EnvTemplateDetailServiceImpl extends ServiceImpl<EnvTemplateDetailMapper, EnvTemplateDetail> implements EnvTemplateDetailService {
+}

src/main/java/cn/qg/holmes/service/k8s/impl/EnvTemplateServiceImpl.java

+package cn.qg.holmes.service.k8s.impl;
+
+import cn.qg.holmes.entity.k8s.EnvTemplate;
+import cn.qg.holmes.mapper.k8s.EnvTemplateMapper;
+import cn.qg.holmes.service.k8s.EnvTemplateService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.stereotype.Service;
+
+@Service
+public class EnvTemplateServiceImpl extends ServiceImpl<EnvTemplateMapper, EnvTemplate> implements EnvTemplateService {
+}