oc-modules-deploy模块后台代码迁移-白令海日志打印优化

soc-modules/soc-modules-deploy/src/main/java/com/xunmei/deploy/controller/BeringController.java

@@ -109,7 +109,7 @@ public class BeringController {
             return heartResponse;
         } catch (Exception e) {
             ResponseEntity responseEntity = ResponeError.Info(e.getMessage(), null);
-            logger.error("上送心跳出现异常：{}",e);
+            logger.error("白令海Rest接口-上送心跳出现异常：{}",e);
             return responseEntity;
         }
     }
@@ -120,7 +120,7 @@ public class BeringController {
     @PostMapping("/api/deploy/list")
     public Object putList(@RequestBody PutAppInfoVo putAppInfoVo, HttpServletResponse response, HttpServletRequest request){
         Map<String,Object> map = new HashMap<>();
-        logger.info("白令海推送应用清单:{}",JSONArray.toJSON(putAppInfoVo).toString());
+        logger.info("白令海Rest接口-推送应用清单: 传入参数={}",JSONArray.toJSON(putAppInfoVo).toString());
         try {
             //获取令牌
             String authorization = request.getHeader("Authorization");
@@ -136,18 +136,17 @@ public class BeringController {
             //获取秘钥(前置机id、注册码)
             String clientId = tokenCache.getClientId();
 
-            logger.info("白令海本次推送应用清单注册码:{}",clientId);
+            logger.info("白令海Rest接口-推送应用清单: 缓存中注册码={}",clientId);
 
-            if (!this.checkParam(putAppInfoVo)){
-                logger.error("白令海推送应用清单,参数校验不通过！");
+            if (!this.checkParam(clientId,putAppInfoVo)){
+                logger.error("白令海Rest接口-推送应用清单: 参数校验不通过！");
                 response.setStatus(400);
                 map.put("message","参数校验不通过！");
                 return map;
             }
             appInfoService.saveAppInfo(clientId,putAppInfoVo);
-            logger.info("保存白令海推送应用清单成功！");
         }catch (Exception e) {
-            logger.error("推送应用清单出现异常：{}",e);
+            logger.error("白令海Rest接口-推送应用清单: 出现异常{}",e);
             response.setStatus(400);
             map.put("message",e.getMessage());
         }
@@ -171,45 +170,45 @@ public class BeringController {
                 serverPort = Integer.valueOf(header_port);
             }
 
-            logger.info("获取应用清单，当前服务请求下载地址ip：{},端口：{}",serverName,serverPort);
+            logger.info("白令海Rest接口-获取应用清单：当前服务请求下载地址ip={},port={}",serverName,serverPort);
 
-            Map<String,Object> map = new HashMap<>();
+            JSONObject result = new JSONObject();
             String authorization = request.getHeader("Authorization");
             authorization = StringUtils.replace(authorization,"Bearer ","");
             String deployTimeStamp = request.getParameter("deployTimeStamp");
             //根据token获取主机信息
             TokenCache tokenCache = null;
-            String result = redisTemplateUtil.get(RedisPrefix.CACHE_TOKEN_TIMES + ":" + authorization);
-            if (org.apache.commons.lang3.StringUtils.isNotBlank(result)){
-                tokenCache =  JSON.parseObject(result, TokenCache.class);
+            String tokenTimes = redisTemplateUtil.get(RedisPrefix.CACHE_TOKEN_TIMES + ":" + authorization);
+            if (StringUtils.isNotBlank(tokenTimes)){
+                tokenCache =  JSON.parseObject(tokenTimes, TokenCache.class);
             }
             if(tokenCache == null){
-                logger.error(authorization + "令牌不合法！");
+                logger.error("白令海Rest接口-获取应用清单：Authorization={}匹配缓存失败！",authorization);
                 throw new RuntimeException(authorization + "令牌不合法！");
             }
 
             //获取秘钥
             String clientId = tokenCache.getClientId();
-
             HostInfo hostInfo = hostInfoService.getById(clientId);
+            if(hostInfo == null){
+                logger.error("白令海Rest接口-获取应用清单：主机id={},在表hostInfo中不存在",clientId);
+                return null;
+            }
 
             if(!hostInfo.getCoreTimeStamp().equals(UTCTimeUtils.getUtcStr2Long(deployTimeStamp))){
-                logger.error("部署中心时间戳和前置机时间戳不一致,部署中心时间:{},前置机请求时间{}",hostInfo.getCoreTimeStamp(),UTCTimeUtils.getUtcStr2Long(deployTimeStamp));
+                logger.error("白令海Rest接口-获取应用清单：主机id={},部署中心与前置机时间戳不一致,部署中心={},前置机={}",clientId,hostInfo.getCoreTimeStamp(),UTCTimeUtils.getUtcStr2Long(deployTimeStamp));
                 response.setStatus(304);
                 return "Not Modified";
             }
-
+            //todo：是否需要更新时间
             long coreTime = UTCTimeUtils.getUtcStr2Long(UTCTimeUtils.getUTCTimeStr());
-
             hostInfo.setCoreTimeStamp(coreTime);
             hostInfoService.updateById(hostInfo);
 
-            List<AppInfoExtend> infoList = appInfoExtendService.getByHostInfoId(clientId);
             List<AppInfoVo> avs = new ArrayList<>();
-            AppInfoVo av = null;
-            /**
-             * 白代理解析的是json，需要把json字符串转换为 json对象
-             */
+            AppInfoVo av;
+
+            List<AppInfoExtend> infoList = appInfoExtendService.getByHostInfoId(clientId);
             for (AppInfoExtend extend : infoList) {
                 av = new AppInfoVo();
                 av.setAppId(extend.getAppId());
@@ -220,16 +219,11 @@ public class BeringController {
                 av.setHash(extend.getHash());
                 av.setHashAlgorithm(extend.getHashAlgorithm());
                 av.setLogPath(extend.getLogPath());
-                String osArchitectures = extend.getOsArchitectures();
-                List<String> oss = JSONArray.parseArray(osArchitectures, String.class);
-                av.setOsArchitectures(oss);
-                List<String> ops = JSONArray.parseArray(extend.getOsPlatforms(), String.class);
-                av.setOsPlatforms(ops);
+                av.setOsArchitectures(JSONArray.parseArray(extend.getOsArchitectures(), String.class));
+                av.setOsPlatforms(JSONArray.parseArray(extend.getOsPlatforms(), String.class));
                 av.setProductName(extend.getProductName());
-                Object starts = JSON.parse(extend.getStart());
-                av.setStart(starts);
-                Object stops = JSON.parse(extend.getStop());
-                av.setStop(stops);
+                av.setStart(JSON.parse(extend.getStart()));
+                av.setStop(JSON.parse(extend.getStop()));
                 av.setVersion(extend.getVersion());
                 av.setRunAtStartup(extend.isRunAtStartup());
                 av.setGuardEnabled(extend.isRunAtStartup());
@@ -243,8 +237,7 @@ public class BeringController {
                     av.setVersion(task.getTargeVersion());
                 }
 
-                Object parse = JSON.parse(extend.getLivenessProbe());
-                av.setLivenessProbe(parse);
+                av.setLivenessProbe(JSON.parse(extend.getLivenessProbe()));
                 av.setWaitForReady(extend.getWaitForReady());
                 // 设置补丁相关数据
                 String hotfixesStr = extend.getHotfixes();
@@ -253,7 +246,6 @@ public class BeringController {
                 }
                 List<HotfixVo> hotfixVos = JSONObject.parseArray(hotfixesStr, HotfixVo.class);
                 if (!hotfixVos.isEmpty()) {
-                    //处理hotfixVos 下载路径
                     for (HotfixVo hotfixVo : hotfixVos) {
                         hotfixVo.setDownloadUrl("http://" + serverName + ":" + serverPort + hotfixVo.getDownloadUrl());
                     }
@@ -262,33 +254,42 @@ public class BeringController {
                 avs.add(av);
 
             }
-            map.put("timeStamp",UTCTimeUtils.getLong2UtcStr(coreTime));
-            map.put("apps",avs);
+            result.put("timeStamp",UTCTimeUtils.getLong2UtcStr(coreTime));
+            result.put("apps",avs);
 
-            logger.info("前置机:{},本次获取应用清单返回数据:{}",clientId,JSON.toJSONString(map));
-            return map;
+
+            logger.info("白令海Rest接口-获取应用清单：主机id={},返回数据={}",clientId,JSON.toJSONString(result));
+            return result;
         }catch (Exception e){
-            logger.error("获取应用清单出现异常",e);
+            logger.error("白令海Rest接口-获取应用清单：出现异常{}",e);
         }finally {
-            logger.info("获取应用清单逻辑结束！");
+            logger.info("白令海Rest接口-获取应用清单：执行完成");
         }
 
         return null;
     }
 
     /**
+     *  白令海Rest接口-报告应用部署状态（此接口给白令海调用，避免其打印错误日志）
+     */
+    @PostMapping("/api/deploy/report")
+    public Object report(){
+        return null;
+    }
+
+    /**
      * 白令海Rest接口-下载服务升级包
      */
     @GetMapping("/api/deploy/package/download/{id}")
     public void getAgentPackage(HttpServletResponse response, HttpServletRequest request, @PathVariable @Value("id") String id){
         UploadAppInfo uploadAppInfo = uploadAppInfoService.getById(id);
         if (null == uploadAppInfo){
-            logger.error("未找到对应升级文件：{}",id);
+            logger.error("白令海Rest接口-下载服务升级包：id={}未找到对应升级文件",id);
             return;
         }
         //升级包物理下载路径
         String downPath = uploadAppInfo.getDownPath();
-        logger.info("安装包下载地址：{}，安装包存放地址：{}",uploadAppInfo.getDownloadUrl(),downPath);
+        logger.info("白令海Rest接口-下载服务升级包：安装包下载地址={}，存放地址={}",uploadAppInfo.getDownloadUrl(),downPath);
         AgentFileUtil.downloadFile(downPath,uploadAppInfo.getAppName()+"_"+uploadAppInfo.getVersion(),request,response);
     }
 
@@ -305,7 +306,7 @@ public class BeringController {
             tasks = frontTaskService.getTasks(authorization);
         } catch (Exception e) {
             response.setStatus(500);
-            logger.error("白令海Rest接口-获取任务出现异常",e);
+            logger.error("白令海Rest接口-获取任务：出现异常{}",e);
         }
         return tasks;
     }
@@ -322,7 +323,7 @@ public class BeringController {
             return null;
         } catch (Exception e) {
             response.setStatus(500);
-            logger.error("白令海Rest接口-上送任务执行状态出现异常",e);
+            logger.error("白令海Rest接口-上送任务执行状态：出现异常",e);
         }
         return null;
     }
@@ -332,70 +333,87 @@ public class BeringController {
      */
     @PostMapping(value = "/api/deploy/frontend/synchronDate")
     public JSONObject synchronDate(){
-        Date date= new Date();
-        logger.info("x86心跳，收到来自前置机的同步时钟心跳信息,中心系统时间:"+date);
-        //构建返回信息，当前只要返回时间，VGS管理暂不考虑
         JSONObject result = new JSONObject();
+        String now = UTCTimeUtils.convertDateToStringByFormat(new Date(),"yyyy-MM-dd HH:mm:ss");
+        logger.info("主机iot服务Rest接口: 收到来自主机x86同步时钟心跳请求,中心系统时间={}",now);
+
         result.put("success","true");
         result.put("errorMessage","");
         JSONObject data = new JSONObject();
-        data.put("timeNow",UTCTimeUtils.convertDateToStringByFormat(date,"yyyy-MM-dd HH:mm:ss"));
+        data.put("timeNow",now);
         result.put("result",data);
+
         return result;
     }
 
 
     //推送应用清单：验证请求参数
-    private boolean checkParam(PutAppInfoVo putAppInfoVo){
+    private boolean checkParam(String clientId,PutAppInfoVo putAppInfoVo){
         List<AppInfoVo> apps = putAppInfoVo.getApps();
         if (!(null != apps && apps.size() >0)){
             return false;
         }
+        String errorMsg = "白令海Rest接口-推送应用清单: 注册码";
         for (int i = 0; i < apps.size(); i++) {
             AppInfoVo infoVo = apps.get(i);
             if (StringUtils.isEmpty(infoVo.getProductName())){
+                logger.error("{}={},传入参数apps中productName为空",errorMsg,clientId);
                 return false;
             }
             if (StringUtils.isEmpty(infoVo.getCode())){
+                logger.error("{}={},传入参数apps中code为空",errorMsg,clientId);
                 return false;
             }
             if (StringUtils.isEmpty(infoVo.getAppId())){
+                logger.error("{}={},传入参数apps中appId为空",errorMsg,clientId);
                 return false;
             }
             if (StringUtils.isEmpty(infoVo.getAppType())){
+                logger.error("{}={},传入参数apps中appType为空",errorMsg,clientId);
                 return false;
             }
             if (StringUtils.isEmpty(infoVo.getVersion())){
+                logger.error("{}={},传入参数apps中version为空",errorMsg,clientId);
                 return false;
             }
             if (StringUtils.isEmpty(infoVo.getAppName())){
+                logger.error("{}={},传入参数apps中appName为空",errorMsg,clientId);
                 return false;
             }
             if (StringUtils.isEmpty(infoVo.getDownloadUrl())){
+                logger.error("{}={},传入参数apps中downloadUrl为空",errorMsg,clientId);
                 return false;
             }
             if (StringUtils.isEmpty(infoVo.getCertificateAuthority())){
+                logger.error("{}={},传入参数apps中certificateAuthority为空",errorMsg,clientId);
                 return false;
             }
             if (StringUtils.isEmpty(infoVo.getHashAlgorithm())){
+                logger.error("{}={},传入参数apps中hashAlgorithm为空",errorMsg,clientId);
                 return false;
             }
             if (StringUtils.isEmpty(infoVo.getHash())){
+                logger.error("{}={},传入参数apps中hash为空",errorMsg,clientId);
                 return false;
             }
             if (null == infoVo.getOsArchitectures()){
+                logger.error("{}={},传入参数apps中osArchitectures为空",errorMsg,clientId);
                 return false;
             }
             if (null == infoVo.getOsPlatforms()){
+                logger.error("{}={},传入参数apps中osPlatforms为空",errorMsg,clientId);
                 return false;
             }
             if (null == infoVo.getStart()){
+                logger.error("{}={},传入参数apps中start为空",errorMsg,clientId);
                 return false;
             }
             if (null == infoVo.getStop()){
+                logger.error("{}={},传入参数apps中stop为空",errorMsg,clientId);
                 return false;
             }
             if (null == infoVo.getLivenessProbe()){
+                logger.error("{}={},传入参数apps中livenessProbe为空",errorMsg,clientId);
                 return false;
             }
         }

soc-modules/soc-modules-deploy/src/main/java/com/xunmei/deploy/controller/DataController.java

@@ -89,12 +89,12 @@ public class DataController extends BaseController{
      * 主机管理--批量升级
      */
     @PostMapping("/addHostBatch")
-    public AjaxResult addHostBatch(String zipId,@RequestParam("hostIds[]") String[] hostIds){
+    public AjaxResult addHostBatch(String zipId,@RequestParam("hostIds") String[] hostIds){
         try {
             String msg = upgradeBatchInfoService.addHostUpgradeBatch(zipId, hostIds);
             return AjaxResult.success(msg);
         } catch (Exception e) {
-            log.error("主机管理-批量升级出现异常：{}",e);
+            log.error("主机管理-批量升级：出现异常：{}",e);
             return AjaxResult.error("升级批次创建失败,"+e.getMessage());
         }
     }
@@ -150,18 +150,20 @@ public class DataController extends BaseController{
      *  主机管理--批量升级-先根据页面勾选的主机筛选出可升级的主机hostIds，返回给页面操作升级
      */
     @PostMapping("/validateHostBatch")
-    public AjaxResult validateHostBatch(String upgradeZipId,@RequestParam("hostIds[]") String[] hostIds){
+    public AjaxResult validateHostBatch(String upgradeZipId,@RequestParam("hostIds") String[] hostIds){
         if(StringUtils.isEmpty(upgradeZipId)){
+            log.error("主机管理--批量升级：前置验证，传入参数upgradeZipId为空");
             return AjaxResult.error("请选择升级包！");
         }
         if(hostIds == null || hostIds.length == 0){
+            log.error("主机管理--批量升级：前置验证，传入参数hostIds为空");
             return AjaxResult.error("请选择需要升级的主机！");
         }
         try {
             Map<String, Object> data = upgradeBatchInfoService.validateHostBatch(upgradeZipId, hostIds);
             return AjaxResult.success(data);
         } catch (Exception e) {
-            log.error("主机管理--批量升级-根据页面勾选的主机筛选出可升级的主机出现异常：{}",e);
+            log.error("主机管理--批量升级：前置验证，出现异常{}",e);
             return AjaxResult.error(e.getMessage());
         }
     }
@@ -204,7 +206,7 @@ public class DataController extends BaseController{
     public Message getUpgradeTaskByHostId(String hostId){
         try {
             List<UpgradeTask> list = upgradeTaskService.getByHostId(hostId);
-            return Message.success("获取获取任务成功！",list);
+            return Message.success("获取任务成功！",list);
         } catch (Exception e) {
             log.error("主机管理--删除主机-查询主机当前的升级任务出现异常：{}",e);
             return Message.error("获取任务失败,"+e.getMessage());

soc-modules/soc-modules-deploy/src/main/java/com/xunmei/deploy/service/AppInfoService.java

@@ -10,8 +10,4 @@ public interface AppInfoService extends IService<AppInfo> {
 
     void saveAppInfo(String clientId, PutAppInfoVo putAppInfoVo);
 
-    List<AppInfo> getByHostInfoId(String hostInfoId);
-
-    List<AppInfo> getByHostId(String hostInfoId);
-
 }

soc-modules/soc-modules-deploy/src/main/java/com/xunmei/deploy/service/impl/AppInfoServiceImpl.java

@@ -1,12 +1,10 @@
 package com.xunmei.deploy.service.impl;
 
-import cn.hutool.core.date.DateUtil;
 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.xunmei.common.core.utils.StringUtils;
 import com.xunmei.deploy.dao.AppInfoDao;
 import com.xunmei.deploy.dao.OperationParamDao;
 import com.xunmei.deploy.domain.*;
@@ -37,33 +35,6 @@ public class AppInfoServiceImpl extends ServiceImpl<AppInfoDao, AppInfo> impleme
     @Autowired
     private AppInfoExtendService extendService;
 
-    /**
-     * 处理数据
-     * @param vo
-     * @return
-     */
-    private AppInfo handleAppInfo(AppInfoVo vo,String clientId){
-        AppInfo info = new AppInfo();
-        BeanUtils.copyProperties(vo , info);
-
-        /**
-         * 对象转为json格式数据
-         */
-        info.setOsArchitectures(JSON.toJSONString(vo.getOsArchitectures()));
-        info.setOsPlatforms(JSON.toJSONString(vo.getOsPlatforms()));
-        info.setStart(JSON.toJSONString(vo.getStart()));
-        info.setStop(JSON.toJSONString(vo.getStop()));
-        info.setLivenessProbe(JSON.toJSONString(vo.getLivenessProbe()));
-        info.setHostInfoId(clientId);
-        info.setWaitForReady(vo.getWaitForReady());
-        // 上报清单保存补丁信息
-        if (null != vo.getHotfixes()) {
-            info.setHotfixes(JSON.toJSONString(vo.getHotfixes()));
-        }
-
-        return info;
-    }
-
     @Transactional(rollbackFor = Exception.class)
     @Override
     public void saveAppInfo(String clientId,PutAppInfoVo putAppInfoVo) {
@@ -71,12 +42,12 @@ public class AppInfoServiceImpl extends ServiceImpl<AppInfoDao, AppInfo> impleme
         HostInfo hostInfo = hostInfoService.getById(clientId);
 
         if (null == hostInfo){
-            logger.error("获取前置值信息为空：前置id：{}，时间：{}",clientId,DateUtil.now());
+            logger.error("推送应用清单：主机id={}在表hostInfo中不存在", clientId);
             return;
         }
         //部署中心时间戳  前置机时间戳 (两个都为0才是初次安装)
         if (hostInfo.getCoreTimeStamp() != 0 || hostInfo.getFrontTimeStamp() != 0){
-            logger.info("本次不为初次安装，时间：{}",DateUtil.now());
+            logger.info("推送应用清单：主机id={}非初次安装（初次安装-coreTimeStamp和frontTimeStamp均为0），跳过保存应用清单流程", clientId);
             return;
         }
 
@@ -98,8 +69,7 @@ public class AppInfoServiceImpl extends ServiceImpl<AppInfoDao, AppInfo> impleme
             JSONObject jsonObject = JSONObject.parseObject(info.getStart());
             List<String> commands = JSON.parseArray(jsonObject.get("command").toString(), String.class);
 
-            for (int j = 0; j < paramList.size(); j++) {
-                OperationParam param = paramList.get(j);
+            for (OperationParam param:paramList) {
                 if (info.getAppId().equals(param.getServerCode()) && param.getStatus() == 1){
                     if (commands != null && commands.size() > 0){
                         Iterator<String> iterator = commands.iterator();
@@ -125,15 +95,19 @@ public class AppInfoServiceImpl extends ServiceImpl<AppInfoDao, AppInfo> impleme
             saveInfos.add(info);
         }
         //保存数据--数据库有相同数据就修改
-        List<AppInfo> infoList = getByHostInfoId(clientId);
+        QueryWrapper<AppInfo> wrapper = new QueryWrapper<>();
+        wrapper.eq("host_info_id",clientId);
+        wrapper.orderByAsc("sort_app");
+        List<AppInfo> infoList = super.list(wrapper);
+
         List<AppInfoExtend> extendInfoList = extendService.getByHostInfoId(clientId);
         ArrayList<AppInfoExtend> extendList = new ArrayList<>();
 
         boolean isSpecial = false;
         for (AppInfo appInfo : saveInfos) {
-            for (int i = 0; i < infoList.size(); i++) {
-                if (appInfo.getAppId().equals(infoList.get(i).getAppId())){
-                    appInfo.setId(infoList.get(i).getId());
+            for (AppInfo bean:infoList) {
+                if (appInfo.getAppId().equals(bean.getAppId())){
+                    appInfo.setId(bean.getId());
                 }
             }
             if(appInfo.getAppId().equals("baseEnv") && appInfo.getVersion().equals("1.0.0")){
@@ -144,9 +118,9 @@ public class AppInfoServiceImpl extends ServiceImpl<AppInfoDao, AppInfo> impleme
             AppInfoExtend extend = new AppInfoExtend();
             BeanUtils.copyProperties(appInfo,extend);
             extend.setId(null);
-            for (int i = 0; i < extendInfoList.size(); i++) {
-                if (appInfo.getAppId().equals(extendInfoList.get(i).getAppId())){
-                    extend.setId(extendInfoList.get(i).getId());
+            for (AppInfoExtend bean:extendInfoList) {
+                if (extend.getAppId().equals(bean.getAppId())){
+                    extend.setId(bean.getId());
                 }
             }
             extendList.add(extend);
@@ -167,45 +141,39 @@ public class AppInfoServiceImpl extends ServiceImpl<AppInfoDao, AppInfo> impleme
         // 推送应用清单成功后设置主机的注册时间
         hostInfo.setRegisterDate(new Date());
         hostInfoService.updateById(hostInfo);
-
+        logger.info("推送应用清单：主机id={}存入数据库执行完成", clientId);
         if(isSpecial){
-
             TransactionSynchronizationManager.registerSynchronization(
-                    new TransactionSynchronizationAdapter() {
-                        @Override
-                        public void afterCommit() {
-                            //判断是否需要走升级逻辑
-                            upgradeBatchInfoService.specialUpgrade(hostInfo.getId());
-                        }
+                new TransactionSynchronizationAdapter() {
+                    @Override
+                    public void afterCommit() {
+                        //判断是否需要走升级逻辑
+                        upgradeBatchInfoService.specialUpgrade(hostInfo.getId());
                     }
+                }
             );
-
         }
     }
 
-    @Override
-    public List<AppInfo> getByHostInfoId(String hostInfoId){
-        QueryWrapper<AppInfo> wrapper = new QueryWrapper<>();
-        wrapper.eq("host_info_id",hostInfoId);
-        wrapper.orderByAsc("sort_app");
-        return super.list(wrapper);
-    }
 
-    @Override
-    public List<AppInfo> getByHostId(String hostInfoId){
-        List<AppInfo> infos = baseMapper.getByHostInfoId(hostInfoId);
-        if (null != infos && infos.size() > 0){
-            for (int i = 0; i < infos.size(); i++) {
-                AppInfo appInfo = infos.get(i);
-                if (StringUtils.isNotEmpty(appInfo.getHotfixes()) && !"[]".equals(appInfo.getHotfixes())){
-                    String hotfixes = appInfo.getHotfixes();
-                    List<String> list = JSON.parseArray(hotfixes, String.class);
-                    //降序排序
-                    Collections.reverse(list);
-                    appInfo.setVersion(appInfo.getVersion() + "-" +list.get(0));
-                }
-            }
+    /**
+     * 处理数据
+     */
+    private AppInfo handleAppInfo(AppInfoVo vo,String clientId){
+        AppInfo info = new AppInfo();
+        BeanUtils.copyProperties(vo , info);
+
+        info.setOsArchitectures(JSON.toJSONString(vo.getOsArchitectures()));
+        info.setOsPlatforms(JSON.toJSONString(vo.getOsPlatforms()));
+        info.setStart(JSON.toJSONString(vo.getStart()));
+        info.setStop(JSON.toJSONString(vo.getStop()));
+        info.setLivenessProbe(JSON.toJSONString(vo.getLivenessProbe()));
+        info.setHostInfoId(clientId);
+        info.setWaitForReady(vo.getWaitForReady());
+        if (null != vo.getHotfixes()) {
+            info.setHotfixes(JSON.toJSONString(vo.getHotfixes()));
         }
-        return infos;
+        return info;
     }
+
 }

soc-modules/soc-modules-deploy/src/main/java/com/xunmei/deploy/service/impl/BeringServiceImpl.java

@@ -75,64 +75,65 @@ public class BeringServiceImpl  extends ServiceImpl<HostInfoDao, HostInfo> imple
 
         //1.先判断请求参数是否合法
         if(tokenVo == null){
-            logger.error("主机获取令牌失败：参数不能为空!");
+            logger.error("主机获取令牌失败：传入参数为空!");
             throw new ServerException("主机获取令牌失败：参数不能为空!");
         }
-
+        logger.info("主机获取令牌start:{}",JSON.toJSONString(tokenVo));
         if(StringUtils.isEmpty(tokenVo.getClient_id())){
-            logger.error("主机获取令牌失败：主机ID不能为空!");
+            logger.error("主机获取令牌失败：传入client_id为空!");
             throw new ServerException("主机获取令牌失败：主机ID不能为空!");
         }
 
         MachineInfo machineInfo = tokenVo.getMachineInfo();
         if(machineInfo == null){
-            logger.error("主机获取令牌失败：计算机信息不能为空!");
+            logger.error("主机获取令牌失败：传入machineInfo为空!");
             throw new ServerException("主机获取令牌失败：计算机信息不能为空!");
         }
 
         if(StringUtils.isEmpty(tokenVo.getGrant_type())){
-            logger.error("主机获取令牌失败：认证类型不能为空!");
+            logger.error("主机获取令牌失败：传入grant_type为空!");
             throw new ServerException("主机获取令牌失败：认证类型不能为空!");
         }
         if(!tokenVo.getGrant_type().equals("client_credentials")){
-            logger.error("主机获取令牌失败：请求参数认证类型错误！");
+            logger.error("主机获取令牌失败：传入grant_type类型错误(值应为client_credentials)！");
             throw new ServerException("主机获取令牌失败：请求参数认证类型错误！");
         }
 
         //验证秘钥是否合法
         List<String> macs = machineInfo.getMacs();
         if (null == macs || macs.size() <= 0){
-            logger.error("主机获取令牌失败：计算机macs信息不能为空!");
+            logger.error("主机获取令牌失败：传入machineInfo内macs数组为空!");
             throw new ServerException("主机获取令牌失败：计算机macs信息不能为空!");
         }
 
         Collections.sort(macs);
-        String macss = StringUtils.join(macs.toArray(), "");
-
-        String str = macss + "zmoon";
+        String macsStr = StringUtils.join(macs.toArray(), "");
+        String str = macsStr + "zmoon";
 
         //md5加密--->按照生成规则生成后的秘钥
         String code = DigestUtils.md5DigestAsHex(str.getBytes());
-        if(!code.equals(tokenVo.getClient_secret())){
-            logger.error("主机获取令牌失败：主机秘钥认证失败！");
+        String clientSecret = tokenVo.getClient_secret();
+        if(!code.equals(clientSecret)){
+            logger.error("主机获取令牌失败：client_secret={}与machineInfo内macs数组解析算法不一致！",clientSecret);
             throw new ServerException("主机获取令牌失败：主机秘钥认证失败！");
         }
 
         //2.验证该秘钥是否在数据库中已经存在
         TokenCache tokenCache = null;
-        String result = redisTemplateUtil.get(RedisPrefix.CACHE_TOKENS + ":" + tokenVo.getClient_secret());
+        String result = redisTemplateUtil.get(RedisPrefix.CACHE_TOKENS + ":" + clientSecret);
         if (StringUtils.isNotBlank(result)){
             tokenCache =  JSON.parseObject(result, TokenCache.class);
         }
 
 
-        HostInfo hostInfo = baseMapper.selectById(tokenVo.getClient_secret());
+        HostInfo hostInfo = baseMapper.selectById(clientSecret);
         //秘钥验证成功且数据库无该秘钥，判断为数据库丢失数据，需要重新注册
         if (hostInfo == null){
+            logger.info("主机获取令牌：表hostInfo中不存在id={}主机(数据库注册数据丢失)",clientSecret);
             //判断是否允许重新注册
             SysConf sysConf = sysConfDao.getByCode("register_again");
             if ("1".equals(sysConf.getValue())){
-                logger.info("数据库注册数据丢失，程序允许主机重新注册！\n"+ JSON.toJSONString(machineInfo));
+                logger.info("主机获取令牌：程序允许主机重新注册,开始注册\n{}",clientSecret,JSON.toJSONString(machineInfo));
                 hostInfo = new HostInfo();
                 hostInfo.setId(code);
                 hostInfo.setHostName(machineInfo.getMachineName());
@@ -156,7 +157,7 @@ public class BeringServiceImpl  extends ServiceImpl<HostInfoDao, HostInfo> imple
                 tc.setClientSecret(hostInfo.getId());
                 redisTemplateUtil.set(RedisPrefix.CACHE_TOKENS + ":" +hostInfo.getId(),tc,2 * 60 * 60);
             }else {
-                logger.error("数据库注册数据丢失，程序不允许主机重新注册！\n"+ JSON.toJSONString(machineInfo));
+                logger.info("主机获取令牌：程序不允许主机重新注册,放弃注册\n{}",JSON.toJSONString(machineInfo));
             }
         }
 
@@ -188,9 +189,10 @@ public class BeringServiceImpl  extends ServiceImpl<HostInfoDao, HostInfo> imple
                 hostInfo.setExpiresIn(7200);
                 hostInfo.setAccessToken(newMd5);
                 hostInfo.setHostName(tokenVo.getMachineInfo().getMachineName());
-                logger.info("token不为空，时效超时，请求里面的ip 为："+tokenVo.getMachineInfo().getIpAddresses().toString());
                 hostInfo.setHostIp(tokenVo.getMachineInfo().getIpAddresses().toString());
                 baseMapper.updateById(hostInfo);
+
+                logger.info("主机获取令牌：主机ip={}，缓存token时效已过，删除缓存并重新设置",tokenVo.getMachineInfo().getIpAddresses().toString());
             }
         }else{
             //生成新的令牌 更新数据库与缓存
@@ -201,7 +203,6 @@ public class BeringServiceImpl  extends ServiceImpl<HostInfoDao, HostInfo> imple
             hostInfo.setScope("* identity");
             hostInfo.setTokenType("Bearer");
             hostInfo.setTokenCreateTime(System.currentTimeMillis());
-            logger.info("token为空，请求里面的ip 为："+tokenVo.getMachineInfo().getIpAddresses().toString());
             hostInfo.setHostName(tokenVo.getMachineInfo().getMachineName());
             hostInfo.setHostIp(tokenVo.getMachineInfo().getIpAddresses().toString());
             baseMapper.updateById(hostInfo);
@@ -215,7 +216,11 @@ public class BeringServiceImpl  extends ServiceImpl<HostInfoDao, HostInfo> imple
 
             redisTemplateUtil.set(RedisPrefix.CACHE_TOKENS + ":" + tokenVo.getClient_id(),tc,2 * 60 * 60);
             redisTemplateUtil.set(RedisPrefix.CACHE_TOKEN_TIMES + ":" + md5Token,tc,2 * 60 * 60);
+
+            logger.info("主机获取令牌：主机ip={}，缓存token为空，开始设置缓存",tokenVo.getMachineInfo().getIpAddresses().toString());
         }
+
+        logger.info("主机获取令牌：client_secret={}获取成功",clientSecret);
         return hostInfo;
     }
 
@@ -223,33 +228,33 @@ public class BeringServiceImpl  extends ServiceImpl<HostInfoDao, HostInfo> imple
     @Transactional(rollbackFor = Exception.class)
     public HeartResponse heartBeat(String authorization, HeartBeat heartBeat) throws Exception {
 
-        logger.info("心跳携带令牌：{}", authorization);
+        logger.info("主机节点心跳：Authorization={}", authorization);
         HeartResponse response = new HeartResponse();
         //参数严重
         String time = heartBeat.getTime();
         if(StringUtils.isBlank(time)){
-            logger.error("白令海节点计算机的UTC时间不能为空！");
+            logger.error("主机节点心跳：传入time为空");
             throw new RuntimeException("白令海节点计算机的UTC时间不能为空！");
         }
 
         String version = heartBeat.getVersion();
         if(StringUtils.isBlank(version)){
-            logger.error("白令海自身版本号不能为空！");
+            logger.error("主机节点心跳：传入version为空");
             throw new RuntimeException("白令海自身版本号不能为空！");
         }
 
         Boolean allowPrerelsease = heartBeat.getAllowPrerelease();
         if(allowPrerelsease == null){
-            logger.error("白令海允许升级到预发布版本不能为空！");
+            logger.error("主机节点心跳：传入allowPrerelease为空");
             throw new RuntimeException("白令海允许升级到预发布版本不能为空！");
 
         }
 
-//        String description = heartBeat.getDescription();
-//        if(StringUtils.isBlank(description)){
-//            logger.error("白令海节点描述不能为空！");
-//            throw new RuntimeException("白令海节点描述不能为空！");
-//        }
+        String description = heartBeat.getDescription();
+        if(description == null){
+            logger.error("主机节点心跳：传入description为null");
+            throw new RuntimeException("白令海节点描述不能为空！");
+        }
 
         //根据token获取主机信息
         TokenCache tokenCache = null;
@@ -259,7 +264,7 @@ public class BeringServiceImpl  extends ServiceImpl<HostInfoDao, HostInfo> imple
         }
 
         if(tokenCache == null){
-            logger.error(authorization + "令牌不合法！");
+            logger.error("主机节点心跳：Authorization={}匹配缓存失败！",authorization);
             throw new RuntimeException(authorization + "令牌不合法！");
         }
 
@@ -268,49 +273,44 @@ public class BeringServiceImpl  extends ServiceImpl<HostInfoDao, HostInfo> imple
 
         HostInfo hostInfo = hostInfoDao.selectById(clientId);
         if (null == hostInfo){
-            logger.error("主机{}在数据库不存在", clientId);
+            logger.error("主机节点心跳：主机id={}在表hostInfo中不存在", clientId);
+            throw new RuntimeException(authorization + "令牌不合法！");
         }
-        logger.info("主机{},心跳获取参数：{}", hostInfo.getId(), JSON.toJSONString(heartBeat));
+        logger.info("主机节点心跳：主机id={},传入参数：{}", clientId, JSON.toJSONString(heartBeat));
         //查询hostZipInfo信息是否存在，如果不存在，按照默认新建
+        String hostId = hostInfo.getId();
         QueryWrapper<HostZipInfo> qw = new QueryWrapper<>();
-        qw.eq("host_id",hostInfo.getId());
-
+        qw.eq("host_id",hostId);
         HostZipInfo hostZipInfo = hostZipInfoDao.selectOne(qw);
-        if(hostZipInfo == null){
-            String orgId = upgradeBatchInfoDao.getOrgId(hostInfo.getId());
+        String orgId = upgradeBatchInfoDao.getOrgId(hostId);
 
-            if(StringUtils.isNotEmpty(orgId) || "YCAF".equals(hostInfo.getHostName())){
+        if(hostZipInfo == null){
+            if(StringUtils.isNotEmpty(orgId)){
                 OrgVo org = orgVoDao.getByOrgId(orgId);
-                if(org == null && !"YCAF".equals(hostInfo.getHostName())){
+                if(org == null){
+                    logger.error("主机节点心跳：主机id={}的机构orgId={}在表sysOrg中不存在（hostZipInfo无记录）",clientId,orgId);
                     throw new RuntimeException("心跳异常：组织机构不存在,该机器组织机构id"+orgId);
                 }
                 hostZipInfo = new HostZipInfo();
                 hostZipInfo.setStatus(1);
                 hostZipInfo.setZipVersion(defaultVersion);
                 hostZipInfo.setTargetVersion(defaultVersion);
-                hostZipInfo.setHostId(hostInfo.getId());
-
+                hostZipInfo.setHostId(hostId);
                 hostZipInfo.setHostIp(hostInfo.getHostIp());
-                if (org != null){
-                    hostZipInfo.setOrgId(org.getOrgId()+"");
-                    hostZipInfo.setOrgName(org.getOrgName());
-                }else {
-                    hostZipInfo.setOrgId(null);
-                    hostZipInfo.setOrgName(null);
-                }
+                hostZipInfo.setOrgId(orgId);
+                hostZipInfo.setOrgName(org.getOrgName());
                 hostZipInfo.setHostName(hostInfo.getHostName());
 
-
                 hostZipInfoDao.insert(hostZipInfo);
             }
         }else{
             hostZipInfo.setHostName(hostInfo.getHostName());
             hostZipInfo.setHostIp(hostInfo.getHostIp());
-            hostZipInfo.setHostId(hostInfo.getId());
-            String orgId = upgradeBatchInfoDao.getOrgId(hostInfo.getId());
+            hostZipInfo.setHostId(hostId);
             if(StringUtils.isNotEmpty(orgId)){
                 OrgVo org = orgVoDao.getByOrgId(orgId);
                 if(org == null){
+                    logger.error("主机节点心跳：主机id={}的机构orgId={}在表sysOrg中不存在（hostZipInfo有记录）",clientId,orgId);
                     throw new RuntimeException("心跳异常：组织机构不存在,该机器组织机构id"+orgId);
                 }
                 hostZipInfo.setOrgId(orgId);
@@ -320,23 +320,19 @@ public class BeringServiceImpl  extends ServiceImpl<HostInfoDao, HostInfo> imple
         }
 
         //获取到心跳信息,获取缓存中是否有心跳信息。
-        HeartTimeVo heartTimeVo = null;
+        HeartTimeVo heartTimeVo;
+        long now = System.currentTimeMillis();
         String heartResult = redisTemplateUtil.get(RedisPrefix.CACHE_HEARTS + ":" + clientId);
-        if (org.apache.commons.lang3.StringUtils.isNotBlank(heartResult)){
-            heartTimeVo =  JSON.parseObject(heartResult, HeartTimeVo.class);
-        }
-        if(heartTimeVo == null){
+        if(StringUtils.isBlank(heartResult)){
             //缓存中不存在该token信息，缓存中添加心跳信息
             heartTimeVo = new HeartTimeVo();
-
             heartTimeVo.setClientId(tokenCache.getClientId());
-            heartTimeVo.setHeartTime(System.currentTimeMillis());
-            logger.info("第一次心跳向心跳缓存中添加信息：key:{},value:{}",clientId,JSON.toJSONString(heartTimeVo));
-            //缓存中添加
+            heartTimeVo.setHeartTime(now);
             redisTemplateUtil.set(RedisPrefix.CACHE_HEARTS + ":" + clientId,heartTimeVo,2 * 60 * 60);
+            logger.info("主机节点心跳：新增心跳缓存,key={},value={}",clientId,JSON.toJSONString(heartTimeVo));
         }else{
+            heartTimeVo =  JSON.parseObject(heartResult, HeartTimeVo.class);
             //存在该心跳，1.更新心态缓存
-            long now = System.currentTimeMillis();
             heartTimeVo.setHeartTime(now);
             if(hostInfo.getHostStatus() == 2){
                 //如果是离线状态，改为在线状态
@@ -345,19 +341,20 @@ public class BeringServiceImpl  extends ServiceImpl<HostInfoDao, HostInfo> imple
                 heartTimeVo.setHostStatus(1);
             }
             redisTemplateUtil.set(RedisPrefix.CACHE_HEARTS + ":" + clientId,heartTimeVo,2 * 60 * 60);
+            logger.info("主机节点心跳：更新心跳缓存,key={},value={}",clientId,JSON.toJSONString(heartTimeVo));
         }
 
         //调用是否生成任务清单判断，线程池开启线程
         frontTaskService.validateAppInfoList(clientId,heartBeat.getVersion());
-        //获取缓存中数据，告知白代理需要来弄一波任务清单推送了哦
         List<FrontTask> hasTask = null;
         String frontTaskResult = redisTemplateUtil.get(RedisPrefix.CACHE_FRONT_TASKS + ":" + clientId);
         if (StringUtils.isNotBlank(frontTaskResult)){
             hasTask = JSON.parseArray(frontTaskResult,FrontTask.class);
         }
         response.setHasTask(false);
+        //设置true，返回给白令海通知其调用中心获取应用清单接口
         if(hasTask != null && hasTask.size() > 0 ){
-            logger.info("判断{}需要推送任务清单:{}",clientId,JSON.toJSONString(hasTask));
+            logger.info("主机节点心跳：主机id={}推送任务清单:{}",clientId,JSON.toJSONString(hasTask));
             response.setHasTask(true);
         }
         response.setName("部署中心");
@@ -372,10 +369,10 @@ public class BeringServiceImpl  extends ServiceImpl<HostInfoDao, HostInfo> imple
 
         List<AppRunningInfo> appRunningInfos = heartBeat.getApps();
         if (null != appRunningInfos && appRunningInfos.size() > 0){
-            asyncService.asyncSaveOrUpdateBatch(appRunningInfos,hostInfo.getId());
+            asyncService.asyncSaveOrUpdateBatch(appRunningInfos,hostId);
         }
 
-        logger.info("心跳返回结果：{}",JSON.toJSONString(response));
+        logger.info("主机节点心跳：主机id={}执行成功，响应数据={}",clientId,JSON.toJSONString(response));
         return response;
     }
 

soc-modules/soc-modules-deploy/src/main/java/com/xunmei/deploy/service/impl/FrontTaskServiceImpl.java

@@ -4,6 +4,7 @@ import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.xunmei.common.core.utils.StringUtils;
 import com.xunmei.deploy.dao.AppInfoDao;
 import com.xunmei.deploy.dao.HostInfoDao;
 import com.xunmei.deploy.domain.AppInfo;
@@ -162,7 +163,7 @@ public class FrontTaskServiceImpl  extends ServiceImpl<FrontTaskDao, FrontTask>
         List<TaskVo> list = new ArrayList<>();
         //获取秘钥
         String hostId = this.getHostId(authorization);
-        logger.info("获取前置机:{}，开始获取任务清单",hostId);
+        logger.info("获取任务：主机id={}，开始执行",hostId);
 
         //获取指定的任务清单
         QueryWrapper<FrontTask> qw = new QueryWrapper<>();
@@ -181,7 +182,7 @@ public class FrontTaskServiceImpl  extends ServiceImpl<FrontTaskDao, FrontTask>
             frontTask.setTaskStartTime(new Date());
             baseMapper.updateById(frontTask);
         }
-        logger.info("获取前置机:{}，任务清单:{}",hostId, JSON.toJSONString(list));
+        logger.info("获取任务：主机id={}，响应数据={}",hostId, JSON.toJSONString(list));
         return list;
     }
 
@@ -189,40 +190,39 @@ public class FrontTaskServiceImpl  extends ServiceImpl<FrontTaskDao, FrontTask>
     @Async("asyncServiceExecutor")
     public void updateTask(String authorization, List<TaskVo> list) throws Exception {
         String hostId = getHostId(authorization);
-        logger.info("前置机hostId={},任务执行状态数据={}",hostId,JSON.toJSONString(list));
+        logger.info("上送任务执行状态：主机id={},传入参数={}",hostId,JSON.toJSONString(list));
+        Date now = new Date();
+
         for (TaskVo taskVo : list) {
-            logger.info("前置机hostId={},任务id:{},任务状态{}",hostId,taskVo.getId(),taskVo.getState());
-            FrontTask frontTask = baseMapper.selectById(taskVo.getId());
-            if(TaskStatus.FAIL.getStatus() == frontTask.getTaskStatus() ||
-                    TaskStatus.SUCCESS.getStatus() == frontTask.getTaskStatus()){
-                logger.info("前置机hostId={},任务id:{},任务已经成功或失败，不能继续修改任务状态！",hostId,taskVo.getId());
+            String taskId = taskVo.getId();
+            String stateReq = taskVo.getState();
+            String descriptionReq = taskVo.getDescription();
+            logger.info("上送任务执行状态：主机id={},任务id={},任务状态={}",hostId,taskId,stateReq);
+            FrontTask frontTask = baseMapper.selectById(taskId);
+            Integer taskStatus = frontTask.getTaskStatus();
+            if(TaskStatus.FAIL.getStatus() == taskStatus || TaskStatus.SUCCESS.getStatus() == taskStatus){
+                logger.info("上送任务执行状态：主机id={},任务id={},任务已经成功或失败，不能继续修改任务状态！",hostId,taskId);
                 continue;
             }
-            if(TaskStatus.FAIL.getStatusDesc().equals(taskVo.getState())){
+            if(TaskStatus.FAIL.getStatusDesc().equals(stateReq)){
                 frontTask.setTaskStatus(TaskStatus.FAIL.getStatus());
-                frontTask.setTaskEndTime(new Date());
-                frontTask.setTaskStatusDesc(taskVo.getDescription());
+                frontTask.setTaskEndTime(now);
+                frontTask.setTaskStatusDesc(descriptionReq);
                 //如果是获取应用清单任务失败 需要删除相关任务数据
                 if(TaskType.UPLOAD_APP_LIST.getStatus().equals(taskVo.getType())){
                     baseMapper.deleteById(frontTask);
                     continue;
                 }
-            }
-
-            if(TaskStatus.SUCCESS.getStatusDesc().equals(taskVo.getState())){
+            }else if(TaskStatus.SUCCESS.getStatusDesc().equals(stateReq)){
                 frontTask.setTaskStatus(TaskStatus.SUCCESS.getStatus());
-                frontTask.setTaskEndTime(new Date());
-                frontTask.setTaskStatusDesc(taskVo.getDescription());
-            }
-
-            if(TaskStatus.EXECUTING.getStatusDesc().equals(taskVo.getState())){
+                frontTask.setTaskEndTime(now);
+                frontTask.setTaskStatusDesc(descriptionReq);
+            }else if(TaskStatus.EXECUTING.getStatusDesc().equals(stateReq)){
                 frontTask.setTaskStatus(TaskStatus.EXECUTING.getStatus());
-                frontTask.setTaskStatusDesc(taskVo.getDescription());
-            }
-
-            if(TaskStatus.QUEUING.getStatusDesc().equals(taskVo.getState())){
+                frontTask.setTaskStatusDesc(descriptionReq);
+            }else if(TaskStatus.QUEUING.getStatusDesc().equals(stateReq)){
                 frontTask.setTaskStatus(TaskStatus.QUEUING.getStatus());
-                frontTask.setTaskStatusDesc(taskVo.getDescription());
+                frontTask.setTaskStatusDesc(descriptionReq);
             }
 
             baseMapper.updateById(frontTask);
@@ -232,6 +232,8 @@ public class FrontTaskServiceImpl  extends ServiceImpl<FrontTaskDao, FrontTask>
         wrapper.eq("task_status",TaskStatus.QUEUING.getStatusDesc());
         List<FrontTask> tasks = baseMapper.selectList(wrapper);
         redisTemplateUtil.set(RedisPrefix.CACHE_FRONT_TASKS + ":" + hostId,JSON.toJSONString(tasks),2 * 60 * 60);
+
+        logger.info("上送任务执行状态：主机id={},执行完成",hostId);
     }
 
     private List<FrontTask> handleTaskCaches(String hostId, List<FrontTask> taskCaches) {
@@ -253,7 +255,7 @@ public class FrontTaskServiceImpl  extends ServiceImpl<FrontTaskDao, FrontTask>
         //根据token获取主机信息
         TokenCache tokenCache = null;
         String result = redisTemplateUtil.get(RedisPrefix.CACHE_TOKEN_TIMES + ":" + authorization);
-        if (org.apache.commons.lang3.StringUtils.isNotBlank(result)){
+        if (StringUtils.isNotBlank(result)){
             tokenCache =  JSON.parseObject(result, TokenCache.class);
         }
         //获取秘钥

soc-modules/soc-modules-deploy/src/main/java/com/xunmei/deploy/service/impl/HostInfoServiceImpl.java

@@ -1,5 +1,6 @@
 package com.xunmei.deploy.service.impl;
 
+import com.alibaba.fastjson.JSON;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.core.metadata.OrderItem;
@@ -15,14 +16,12 @@ import com.xunmei.deploy.util.RedisTemplateUtil;
 import com.xunmei.deploy.vo.*;
 import com.xunmei.system.api.domain.SysUser;
 import org.apache.commons.lang3.StringUtils;
-import org.apache.ibatis.annotations.Param;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.DigestUtils;
-
 import javax.annotation.Resource;
 import java.util.*;
 import java.util.stream.Collectors;
@@ -47,42 +46,44 @@ public class HostInfoServiceImpl extends ServiceImpl<HostInfoDao, HostInfo> impl
     public HostInfo register(RegisterVo registerVo) throws Exception {
         //1.先判断请求参数是否合法
         if(registerVo == null){
-            logger.error("主机节点注册失败：参数不能为空!");
+            logger.error("主机节点注册失败：传入参数为空!");
             throw new RuntimeException("主机节点注册失败：参数不能为空!");
         }
-        if(StringUtils.isEmpty(registerVo.getCode())){
-            logger.error("主机节点注册失败：注册码不能为空!");
+        logger.info("主机节点注册start:{}",JSON.toJSONString(registerVo));
+        String registerCode = registerVo.getCode();
+        if(StringUtils.isEmpty(registerCode)){
+            logger.error("主机节点注册失败：传入code为空!");
             throw new RuntimeException("主机节点注册失败：注册码不能为空!");
         }
         MachineInfo machineInfo = registerVo.getMachineInfo();
         if(machineInfo == null){
-            logger.error("主机节点注册失败：计算机信息不能为空!");
+            logger.error("主机节点注册失败：传入machineInfo为空!");
             throw new RuntimeException("主机节点注册失败：计算机信息不能为空!");
         }
         List<String> macs = machineInfo.getMacs();
         if(macs.size() == 0){
-            logger.error("主机节点注册失败：MAC地址不能为空!");
+            logger.error("主机节点注册失败：传入machineInfo内macs数组为空!");
             throw new RuntimeException("主机节点注册失败：MAC地址不能为空!");
         }
         //2.验证注册码是否在数据库中已经存在
-        HostInfo hostInfo = baseMapper.selectById(registerVo.getCode());
+        HostInfo hostInfo = baseMapper.selectById(registerCode);
         if(hostInfo != null){
-            logger.error("数据库已有主机注册数据，主机内注册数据丢失,删除部署中心主机相关数据！");
+            logger.info("主机节点注册: 表hostInfo中已存在id={}主机（主机内注册数据丢失），开始执行-删除主机相关表并重新注册!",registerCode);
             //已注册  代表主机注册数据丢失   删除部署中心主机所有数据
             try{
                 this.deleteTableDataByHostId(hostInfo.getId(),true);
             }catch (Exception e){
-                logger.error("主机节点注册删除主机相关表出错:{}",e);
+                logger.error("主机节点注册：删除主机相关表出错:{}",e);
             }
         }
         //3.不存在，验证注册码是否合法
         //排序mac
         Collections.sort(macs);
-        String macss = StringUtils.join(macs.toArray(), "");
-        String str = macss + "zmoon";
+        String macsStr = StringUtils.join(macs.toArray(), "");
+        String str = macsStr + "zmoon";
         String code = DigestUtils.md5DigestAsHex(str.getBytes());
-        if(!code.equals(registerVo.getCode())){
-            logger.error("主机节点注册失败：无效的注册码！");
+        if(!code.equals(registerCode)){
+            logger.error("主机节点注册失败：code={}与machineInfo内macs数组解析算法不一致！",registerCode);
             throw new RuntimeException("主机节点注册失败：无效的注册码！");
         }
         // 4. 注册码合法，合法后保存数据库，且更新缓存数据
@@ -99,6 +100,7 @@ public class HostInfoServiceImpl extends ServiceImpl<HostInfoDao, HostInfo> impl
         try {
             baseMapper.insert(hostInfo);
         }catch (Exception e){
+            logger.error("主机节点注册：code={}保存表hostInfo出现异常：{}",registerCode,e);
             throw e;
         }
         //添加缓存信息
@@ -106,6 +108,8 @@ public class HostInfoServiceImpl extends ServiceImpl<HostInfoDao, HostInfo> impl
         tc.setClientId(hostInfo.getId());
         tc.setClientSecret(hostInfo.getId());
         redisTemplateUtil.set(RedisPrefix.CACHE_TOKENS + ":" + hostInfo.getId(),tc,2 * 60 * 60);
+
+        logger.info("主机节点注册：code={}注册成功",registerCode);
         return hostInfo;
     }
 

soc-modules/soc-modules-deploy/src/main/java/com/xunmei/deploy/service/impl/UpgradeBatchInfoServiceImpl.java

@@ -484,9 +484,11 @@ public class UpgradeBatchInfoServiceImpl extends ServiceImpl<UpgradeBatchInfoDao
          */
         ZipPackInfo zipPackInfo = zipPackInfoDao.selectById(zipId);
         if (null == zipPackInfo){
+            logger.error("主机管理--批量升级：前置验证，id={}在表ZipPackInfo中不存在",zipId);
             throw new RuntimeException("未找到对应升级包！");
         }
         if (StringUtils.isEmpty(zipPackInfo.getHostType())){
+            logger.error("主机管理--批量升级：前置验证，id={}在表ZipPackInfo中hostType为空",zipId);
             throw new RuntimeException("该升级包信息不完整，请删除后重新上传！");
         }
 
@@ -504,11 +506,6 @@ public class UpgradeBatchInfoServiceImpl extends ServiceImpl<UpgradeBatchInfoDao
         for (int i = 0; i < hostZipInfos.size(); i++) {
             HostZipInfo hostZipInfo = hostZipInfos.get(i);
             if ("ZMAF3XXX".equals(hostType)){
-                //不是ZA的主机都认为 适用讯美的升级包
-                if (!"YCAF".equals(hostZipInfo.getHostName())){
-                    hostCount += 1;
-                }
-            }else if ("YCAF".equals(hostType)){
                 if (hostType.equals(hostZipInfo.getHostName())){
                     hostCount += 1;
                 }
@@ -516,6 +513,7 @@ public class UpgradeBatchInfoServiceImpl extends ServiceImpl<UpgradeBatchInfoDao
         }
         //数量不相等，代表有中安和讯美的主机，不允许升级
         if (hostCount != hostZipInfos.size()){
+            logger.error("主机管理--批量升级：前置验证，id={}勾选的升级主机在表HostZipInfo中未全为ZMAF3XXX类型",zipId);
             throw new RuntimeException("该升级包只适用" + zipPackInfo.getHostTypeName() + "主机升级，升级主机中存在其他主机。请重新选择需要升级的主机！");
         }
         //所有机器版本和升级版本号一致
@@ -526,7 +524,7 @@ public class UpgradeBatchInfoServiceImpl extends ServiceImpl<UpgradeBatchInfoDao
             HostInfo hostInfo = hostInfoDao.selectById(hostZipInfo.getHostId());
             if(hostInfo.getIsPush() == 0){
                 //该主机未推送应用清单
-                logger.info("主机hostId={}放弃本次升级，原因：未推送应用清单",hostZipInfo.getHostId());
+                logger.info("主机管理--批量升级：前置验证，id={}勾选的升级主机hostId={}在表HostInfo中isPush为0，未推送应用清单放弃本次升级",zipId,hostZipInfo.getHostId());
                 continue;
             }
 
@@ -541,12 +539,12 @@ public class UpgradeBatchInfoServiceImpl extends ServiceImpl<UpgradeBatchInfoDao
                     String version = CommonUtils.compareToVersion(zipVersion, nowVersion);
                     if(!version.equals(zipVersion)){
                         //升级版本号小于当前版本号，不作任何处理
-                        logger.info("主机hostId={}放弃本次升级，原因：升级版本号小于当前版本号",hostZipInfo.getHostId());
+                        logger.info("主机管理--批量升级：前置验证，id={}勾选的升级主机hostId={}在表HostZipInfo中当前版本号，大于升级版本号放弃本次升级",zipId,hostZipInfo.getHostId());
                         continue;
                     }
                 }else{
                     //版本相同，不作任何处理
-                    logger.info("主机hostId={}放弃本次升级，原因：升级版本号与当前版本号一致",hostZipInfo.getHostId());
+                    logger.info("主机管理--批量升级：前置验证，id={}勾选的升级主机hostId={}在表HostZipInfo中当前版本号，与升级版本号一致放弃本次升级",zipId,hostZipInfo.getHostId());
                     continue;
                 }
             }else{
@@ -562,7 +560,7 @@ public class UpgradeBatchInfoServiceImpl extends ServiceImpl<UpgradeBatchInfoDao
                  */
                 String version = CommonUtils.compareToVersion(zipVersion, targetVersion);
                 if(version.equals(targetVersion)){
-                    logger.info("主机hostId={}放弃本次升级，原因：升级版本号与主机已在进行的升级目标版本号一致",hostZipInfo.getHostId());
+                    logger.info("主机管理--批量升级：前置验证，id={}勾选的升级主机hostId={}在表HostZipInfo中已在进行版本号，与升级版本号一致放弃本次升级",zipId,hostZipInfo.getHostId());
                     continue;
                 }
             }
@@ -570,17 +568,20 @@ public class UpgradeBatchInfoServiceImpl extends ServiceImpl<UpgradeBatchInfoDao
         }
 
         if(versionOk){
-            logger.info("选择的主机hostIds={}放弃本次升级，原因：选择的主机均已升级至此版本，无需进行升级！",hostIds);
+            logger.info("主机管理--批量升级：前置验证，id={}勾选的升级主机hostIds={}均已升级此版本，无需进行升级",zipId,hostIds);
             throw new RuntimeException("选择的主机均已升级至此版本，无需进行升级！");
         }
 
         int total = hostIds.length;
 
         if(hosts.size() == 0){
+            logger.info("主机管理--批量升级：前置验证，id={}勾选的升级主机hostIds={}，没有主机需要升级到{}",zipId,hostIds,zipPackInfo.getZipVersion());
             throw new RuntimeException("选择主机数:"+total+",没有主机需要升级到"+zipPackInfo.getZipVersion());
         }
 
         if(total != hosts.size()){
+            logger.info("主机管理--批量升级：前置验证，id={}勾选的升级主机hostIds={}，经检测，其中{}需执行升级，另外{}台主机软件因已是最新版本将忽略",zipId,hostIds,hosts.size(),(total-hosts.size()));
+
             String msg = "本次选择操作"+total+"台主机软件升级，经检测，" +
                     "其中"+hosts.size()+"台需执行升级，另外的"+(total-hosts.size())+"台因主机软件因已是最新版本，将自动忽略。点击“确认”继续”";
             map.put("msg",msg);

soc-modules/soc-modules-deploy/src/main/java/com/xunmei/deploy/service/impl/ZipPackInfoServiceImpl.java

@@ -48,12 +48,12 @@ public class ZipPackInfoServiceImpl extends ServiceImpl<ZipPackInfoDao, ZipPackI
             qw.eq("status",0);//状态为升级中
             long existUpgradeCount=hostZipInfoDao.selectCount(qw);
             if (existUpgradeCount>0){
+                logger.error("升级包管理：删除id={}失败，存在与该升级包相关的、状态为升级中的任务，不允许删除。",ids);
                 return AjaxResult.error("删除失败，存在与该升级包相关的、状态为升级中的任务，不允许删除。");
             }
-            logger.info("执行删除安装包操作，调用接口: delZip");
+            logger.info("升级包管理：删除id={}开始执行",ids);
 
             ZipPackInfo zipPackInfo = baseMapper.selectById(ids);
-            logger.info("开始删除安装包子包数据库记录，zip_id:{}",ids);
             //删除应用集合
             QueryWrapper<UploadAppInfo> wrapper = new QueryWrapper<>();
             wrapper.eq("zip_id",ids);
@@ -62,19 +62,18 @@ public class ZipPackInfoServiceImpl extends ServiceImpl<ZipPackInfoDao, ZipPackI
             if (!uploadAppInfoIds.isEmpty()) {
                 uploadAppInfoDao.deleteBatchIds(uploadAppInfoIds);
             }
-            logger.info("删除安装包子包数据库记录成功");
+            logger.info("升级包管理：删除id={}附属表UploadAppInfo记录成功",ids);
 
             //删除文件
-            logger.info("开始删除安装包，真实文件路径:{}",zipPackInfo.getZipPath());
             FileUtil.delFolder(zipPackInfo.getZipPath());
-            logger.info("根据真实路径删除文件成功，开始删除安装包数据库记录，ids:{}",ids);
+            logger.info("升级包管理：删除id={}服务器上真实路径文件成功",ids);
             baseMapper.deleteById(ids);
-            logger.info("删除安装包数据库记录完成");
+            logger.info("升级包管理：删除id={}主表ZipPackInfo记录成功",ids);
 
 
             return AjaxResult.success("删除成功！");
         } catch (Exception e) {
-            logger.error("升级包管理删除升级包出现异常：{}",e);
+            logger.error("升级包管理：删除id={}升级包出现异常：{}",ids,e);
             return AjaxResult.error("删除错误，"+e.getMessage());
         }