微调

common/src/main/java/cn/reghao/autodop/common/dagent/app/api/AppOps.java

@@ -5,5 +5,6 @@ package cn.reghao.autodop.common.dagent.app.api;
  * @date 2020-12-25 19:15:00
  */
 public enum AppOps {
-    appDeployOps, appLogOps, appStatusOps, appStartOps, appStopOps, appRestartOps
+    // dmaster RPC 调用时返回
+    appDeployOps, appLogOps, appStatusOps, appRestartOps, appStopOps, appStartOps
 }

common/src/main/java/cn/reghao/autodop/common/dagent/machine/api/data/MachineLog.java

@@ -1,17 +1,16 @@
 package cn.reghao.autodop.common.dagent.machine.api.data;
 
-//import cn.reghao.autodop.dmaster.common.db.orm.BaseDocument;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
-//import org.springframework.data.mongodb.core.mapping.Document;
 
 /**
+ * dagent 日志
+ *
  * @author reghao
  * @date 2020-10-22 15:45:29
  */
 @Data
 @EqualsAndHashCode(callSuper = false)
-//@Document("MachineLog")
 public class MachineLog {
     private String machineId;
     private long timestamp;

dagent/src/main/java/cn/reghao/autodop/dagent/app/App.java

@@ -32,7 +32,6 @@ public class App {
             case docker:
                 try {
                     dockerAppServiceImpl.deploy(appDeployArgs);
-                    return RpcResult.success("ok");
                 } catch (DockerException e) {
                     e.printStackTrace();
                     return RpcResult.fail(ExceptionUtil.errorMsg(e));
@@ -41,39 +40,93 @@ public class App {
                 zipAppServiceImpl.deploy(appDeployArgs);
                 break;
             default:
-                log.error("没有这种打包类型...");
+                return RpcResult.error("没有这种打包类型...");
         }
 
-        return RpcResult.success("test");
+        return RpcResult.success("ok");
     }
 
     public RpcResult log(String payload) {
         AppLogArgs appLogArgs = (AppLogArgs) JsonConverter.jsonToObject(payload, AppLogArgs.class);
-        return RpcResult.success("test");
+        switch (PackerType.valueOf(appLogArgs.getPackerType())) {
+            case docker:
+                break;
+            case zip:
+                break;
+            default:
+                return RpcResult.error("没有这种打包类型...");
+        }
+
+        return RpcResult.success("ok");
     }
 
     public RpcResult status(String payload) {
         AppIdArgs appIdArgs = (AppIdArgs) JsonConverter.jsonToObject(payload, AppIdArgs.class);
-        return RpcResult.success("test");
+        switch (PackerType.valueOf(appIdArgs.getPackerType())) {
+            case docker:
+                break;
+            case zip:
+                break;
+            default:
+                return RpcResult.error("没有这种打包类型...");
+        }
+
+        return RpcResult.success("ok");
     }
 
-    public RpcResult start(String payload) {
+    public RpcResult restart(String payload) {
         AppIdArgs appIdArgs = (AppIdArgs) JsonConverter.jsonToObject(payload, AppIdArgs.class);
-        return RpcResult.success("test");
+        switch (PackerType.valueOf(appIdArgs.getPackerType())) {
+            case docker:
+                break;
+            case zip:
+                break;
+            default:
+                return RpcResult.error("没有这种打包类型...");
+        }
+
+        return RpcResult.success("ok");
     }
 
     public RpcResult stop(String payload) {
         AppIdArgs appIdArgs = (AppIdArgs) JsonConverter.jsonToObject(payload, AppIdArgs.class);
-        return RpcResult.success("test");
+        switch (PackerType.valueOf(appIdArgs.getPackerType())) {
+            case docker:
+                break;
+            case zip:
+                break;
+            default:
+                return RpcResult.error("没有这种打包类型...");
+        }
+
+        return RpcResult.success("ok");
     }
 
-    public RpcResult restart(String payload) {
+    public RpcResult start(String payload) {
         AppIdArgs appIdArgs = (AppIdArgs) JsonConverter.jsonToObject(payload, AppIdArgs.class);
-        return RpcResult.success("test");
+        switch (PackerType.valueOf(appIdArgs.getPackerType())) {
+            case docker:
+                break;
+            case zip:
+                break;
+            default:
+                return RpcResult.error("没有这种打包类型...");
+        }
+
+        return RpcResult.success("ok");
     }
 
     public RpcResult run(String payload) {
         AppIdArgs appIdArgs = (AppIdArgs) JsonConverter.jsonToObject(payload, AppIdArgs.class);
-        return RpcResult.success("test");
+        switch (PackerType.valueOf(appIdArgs.getPackerType())) {
+            case docker:
+                break;
+            case zip:
+                break;
+            default:
+                return RpcResult.error("没有这种打包类型...");
+        }
+
+        return RpcResult.success("ok");
     }
 }

dagent/src/main/java/cn/reghao/autodop/dagent/utils/amqp/AppMessageDispatcher.java → dagent/src/main/java/cn/reghao/autodop/dagent/utils/amqp/AppDispatcher.java

@@ -12,10 +12,10 @@ import org.springframework.stereotype.Component;
  */
 @Slf4j
 @Component
-public class AppMessageDispatcher {
+public class AppDispatcher {
     public App app;
     
-    public AppMessageDispatcher(App app) {
+    public AppDispatcher(App app) {
         this.app = app;
     }
 
@@ -34,6 +34,15 @@ public class AppMessageDispatcher {
             case appStatusOps:
                 log.info("返回应用状态...");
                 return app.status(payload);
+            case appRestartOps:
+                log.info("返回应用状态...");
+                return app.status(payload);
+            case appStopOps:
+                log.info("返回应用状态...");
+                return app.status(payload);
+            case appStartOps:
+                log.info("返回应用状态...");
+                return app.status(payload);
             default:
                 log.error("AppOps 中没有相应类型...");
                 return RpcResult.error("AppOps 中没有相应类型...");

dagent/src/main/java/cn/reghao/autodop/dagent/utils/amqp/MachineMessageDispatcher.java → dagent/src/main/java/cn/reghao/autodop/dagent/utils/amqp/MachineDispatcher.java

@@ -12,10 +12,10 @@ import org.springframework.stereotype.Component;
  */
 @Slf4j
 @Component
-public class MachineMessageDispatcher {
+public class MachineDispatcher {
     private Machine machine;
 
-    public MachineMessageDispatcher(Machine machine) {
+    public MachineDispatcher(Machine machine) {
         this.machine = machine;
     }
 

dagent/src/main/java/cn/reghao/autodop/dagent/utils/amqp/RabbitConsumer.java

@@ -25,15 +25,15 @@ import java.lang.management.ManagementFactory;
 @Component
 public class RabbitConsumer implements ChannelAwareMessageListener {
     private RabbitTemplate rabbitTemplate;
-    private MachineMessageDispatcher machineMessageDispatcher;
-    private AppMessageDispatcher appMessageDispatcher;
+    private MachineDispatcher machineDispatcher;
+    private AppDispatcher appDispatcher;
 
     public RabbitConsumer(RabbitTemplate rabbitTemplate,
-                          MachineMessageDispatcher machineMessageDispatcher,
-                          AppMessageDispatcher appMessageDispatcher) {
+                          MachineDispatcher machineDispatcher,
+                          AppDispatcher appDispatcher) {
         this.rabbitTemplate = rabbitTemplate;
-        this.machineMessageDispatcher = machineMessageDispatcher;
-        this.appMessageDispatcher = appMessageDispatcher;
+        this.machineDispatcher = machineDispatcher;
+        this.appDispatcher = appDispatcher;
     }
 
     @Override
@@ -60,19 +60,19 @@ public class RabbitConsumer implements ChannelAwareMessageListener {
             switch (MessageType.valueOf(type)) {
                 case machineType:
                     if (isRpc) {
-                        RpcResult rpcResult = machineMessageDispatcher.rpcDispatch(ops, payload);
+                        RpcResult rpcResult = machineDispatcher.rpcDispatch(ops, payload);
                         rpcReply(messageProperties, rpcResult);
                     } else {
-                        machineMessageDispatcher.dispatch(ops, payload);
+                        machineDispatcher.dispatch(ops, payload);
                         channel.basicAck(msg.getMessageProperties().getDeliveryTag(), false);
                     }
                     break;
                 case appType:
                     if (isRpc) {
-                        RpcResult rpcResult = appMessageDispatcher.rpcDispatch(ops, payload);
+                        RpcResult rpcResult = appDispatcher.rpcDispatch(ops, payload);
                         rpcReply(messageProperties, rpcResult);
                     } else {
-                        appMessageDispatcher.dispatch(ops, payload);
+                        appDispatcher.dispatch(ops, payload);
                         channel.basicAck(msg.getMessageProperties().getDeliveryTag(), false);
                     }
                     break;