暂存

framework/dataType/include/KubeSphereDeployments.hpp

@@ -0,0 +1,86 @@
+/*
+ * @Author: Your Name lishengyin@sz-sunwin.com
+ * @Date: 2022-04-26 15:33:34
+ * @LastEditors: lishengyin
+ * @LastEditTime: 2022-06-27 15:32:01
+ * @FilePath: /ins/framework/dataType/include/KubeSphereDeployments.hpp
+ * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
+ */
+
+#ifndef __KUBESPHEREDEPLOYMENTS_HPP_
+#define __KUBESPHEREDEPLOYMENTS_HPP_
+
+#include "K8sServerBase.hpp"
+
+
+class KubeSphereDeployments:public MsgBase
+{
+public:
+    std::string NAME;
+    std::string NAMESPACE;
+    std::string UID;
+    std::string LABELS;
+    std::string CONTAINERS;
+    std::string PHASE;
+    std::string CONDITIONS;
+
+public:
+    KubeSphereDeployments(){}
+    ~KubeSphereDeployments(){}
+
+    /**
+     * @description: objectToJson
+     * @param {string&} str
+     * @return {*}
+     */    
+    void ObjectToJson(std::string& str) override;
+
+    /**
+     * @description: objectTojson
+     * @return {*}
+     */    
+    void ObjectToJson(rapidjson::Writer<rapidjson::StringBuffer>& writer) override;
+
+    /**
+     * @description: jsonToObject
+     * @param {string&} json
+     * @return {*}
+     */    
+    bool jsonToObject(const std::string& json) override;
+
+    /**
+     * @description: jsonToObject
+     * @param {Value&} object
+     * @return {*}
+     */    
+    bool jsonToObject(const rapidjson::Value& object) override;
+
+    /**
+     * @description: ObjectToSql
+     * @param {string&} sql
+     * @return {*}
+     */    
+    virtual bool ObjectToSql(std::string& sql) override;
+
+    /**
+     * @description: ObjectToSql后处理
+     * @param {string&} sql
+     * @return {*}
+     */ 
+    virtual bool ObjectToSqlBack(std::string & sql) override;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#endif

framework/dataType/include/KubeSphereTempalte.hpp

@@ -0,0 +1,77 @@
+/*
+ * @Author: Your Name lishengyin@sz-sunwin.com
+ * @Date: 2022-04-26 15:33:34
+ * @LastEditors: lishengyin
+ * @LastEditTime: 2022-06-27 16:57:42
+ * @FilePath: /ins/framework/dataType/include/KubeSphereTempalte.hpp
+ * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
+ */
+
+#ifndef __KubeSphereTempalte_HPP_
+#define __KubeSphereTempalte_HPP_
+
+#include "K8sServerBase.hpp"
+
+
+class KubeSphereTempalte:public MsgBase
+{
+public:
+    std::string CONTENTTYPE;
+    std::string DATA;
+
+public:
+    KubeSphereTempalte(){}
+    ~KubeSphereTempalte(){}
+
+    /**
+     * @description: objectToJson
+     * @param {string&} str
+     * @return {*}
+     */    
+    void ObjectToJson(std::string& str) override;
+
+    /**
+     * @description: objectTojson
+     * @return {*}
+     */    
+    void ObjectToJson(rapidjson::Writer<rapidjson::StringBuffer>& writer) override;
+
+    /**
+     * @description: jsonToObject
+     * @param {string&} json
+     * @return {*}
+     */    
+    bool jsonToObject(const std::string& json) override;
+
+    /**
+     * @description: jsonToObject
+     * @param {Value&} object
+     * @return {*}
+     */    
+    bool jsonToObject(const rapidjson::Value& object) override;
+
+    /**
+     * @description: ObjectToSql
+     * @param {string&} sql
+     * @return {*}
+     */    
+    virtual bool ObjectToSql(std::string& sql) override;
+
+    /**
+     * @description: ObjectToSql后处理
+     * @param {string&} sql
+     * @return {*}
+     */ 
+    virtual bool ObjectToSqlBack(std::string & sql) override;
+};
+
+
+
+
+
+
+
+
+
+
+#endif

framework/dataType/include/dataTypeList.hpp

@@ -4,7 +4,7 @@
  * @Autor: lishengyin
  * @Date: 2022-04-07 15:29:26
  * @LastEditors: lishengyin
- * @LastEditTime: 2022-06-21 16:38:08
+ * @LastEditTime: 2022-06-27 16:59:27
  */
 #ifndef __DATATYPELIST_HPP_
 #define __DATATYPELIST_HPP_
@@ -26,6 +26,7 @@
 #include "HttpToken.hpp"
 #include "InsAIList.hpp"
 #include "InsAIInfo.hpp"
-
+#include "KubeSphereDeployments.hpp"
+#include "KubeSphereTempalte.hpp"
 
 #endif

framework/dataType/src/KubeSphereDeployments.cpp

@@ -0,0 +1,125 @@
+/*
+ * @Description: 
+ * @Version: 1.0
+ * @Autor: lishengyin
+ * @Date: 2022-04-26 15:35:49
+ * @LastEditors: lishengyin
+ * @LastEditTime: 2022-06-27 15:39:13
+ */
+#include "KubeSphereDeployments.hpp"
+
+/**
+ * @description: objectToJson
+ * @return {*}
+ */
+void KubeSphereDeployments::ObjectToJson(rapidjson::Writer<rapidjson::StringBuffer>& writer){
+
+    writer.StartObject();
+
+    writer.Key("NAME");
+    writer.String(NAME.c_str());
+
+    writer.Key("NAMESPACE");
+    writer.String(NAMESPACE.c_str());
+
+    writer.Key("UID");
+    writer.String(UID.c_str());
+
+    writer.Key("LABELS");
+    writer.String(LABELS.c_str());
+
+    writer.Key("CONTAINERS");
+    writer.String(CONTAINERS.c_str());
+
+    writer.Key("PHASE");
+    writer.String(PHASE.c_str());
+
+    writer.Key("CONDITIONS");
+    writer.String(CONDITIONS.c_str());
+
+    writer.Key("CONDITIONS");
+    writer.String(CONDITIONS.c_str());
+
+    writer.EndObject();
+}
+
+/**
+ * @description: objectToJson
+ * @param {string&} str
+ * @return {*}
+ */    
+void KubeSphereDeployments::ObjectToJson(std::string& str){
+    
+}
+
+/**
+ * @description: jsonToObject
+ * @param {string&} json
+ * @return {*}
+ */    
+bool KubeSphereDeployments::jsonToObject(const std::string& json){
+
+    return true;
+}
+
+/**
+ * @description: jsonToObject
+ * @param {Value&} object
+ * @return {*}
+ */    
+bool KubeSphereDeployments::jsonToObject(const rapidjson::Value& object){
+    const auto end = object.MemberEnd();
+    if (end == object.FindMember("metadata") || !object["metadata"].IsObject()) {
+        return false;
+    }else{
+        const rapidjson::Value& obj = object["metadata"];
+        if(end != obj.FindMember("name")) this->NAME = obj["name"].GetString();
+        if(end != obj.FindMember("uid")) this->UID = obj["uid"].GetString();
+        if(end != obj.FindMember("namespace")) this->NAMESPACE = obj["namespace"].GetString();
+        if(end != obj.FindMember("labels")) this->LABELS = this->objectToJson(obj["labels"]);
+    }
+    if(end == object.FindMember("status") || !object["status"].IsObject()){
+        return false;
+    }else{
+        const rapidjson::Value& obj = object["status"];
+        //if(end != obj.FindMember("phase")) this->PHASE = obj["phase"].GetString();
+        if(end != obj.FindMember("conditions")) this->CONDITIONS = this->objectToJson(obj["conditions"]);
+    }
+    // if(end == object.FindMember("spec") || !object["spec"].IsObject()){
+    //     return false;
+    // }else{
+    //     const rapidjson::Value& obj = object["spec"];
+    //     if(end != obj.FindMember("containers")) this->CONTAINERS = this->objectToJson(obj["containers"]);
+    // }
+    return true;
+}
+
+
+/**
+ * @description: ObjectToSql
+ * @param {string&} sql
+ * @return {*}
+ */    
+bool KubeSphereDeployments::ObjectToSql(std::string& sql){
+    SqlStream sqlStream("insert into InsServerDB.`InsKsDeployments` (UID, USERID, NAME, NAMESPACE, LABELS, CONTAINERS, PHASE, CONDITIONS, ISDELETE, UPDATED_TIME) \
+        values  ('?','?','?','?','?','?','?','?',0, '?')\
+        on duplicate key update UID=VALUES(UID), USERID=VALUES(USERID), NAME=VALUES(NAME), NAMESPACE=VALUES(NAMESPACE),\
+        LABELS=VALUES(LABELS) ,CONTAINERS=VALUES(CONTAINERS), PHASE=VALUES(PHASE),\
+        CONDITIONS=VALUES(CONDITIONS), ISDELETE=VALUES(ISDELETE), UPDATED_TIME=VALUES(UPDATED_TIME)");
+
+    sqlStream << UID  << USERID << NAME << NAMESPACE << LABELS << CONTAINERS << PHASE << CONDITIONS << DATATIME;
+    sql = (std::string)sqlStream;
+    return true;
+}
+
+/**
+ * @description: ObjectToSql后处理
+ * @param {string&} sql
+ * @return {*}
+ */ 
+bool KubeSphereDeployments::ObjectToSqlBack(std::string & sql){
+    SqlStream sqlStream("UPDATE InsServerDB.`InsKsDeployments` SET ISDELETE = 1 WHERE UPDATED_TIME != '?'");
+    sqlStream << DATATIME;
+    sql = (std::string)sqlStream;
+    return true;
+}

framework/dataType/src/KubeSphereTempalte.cpp

@@ -0,0 +1,69 @@
+/*
+ * @Description: 
+ * @Version: 1.0
+ * @Autor: lishengyin
+ * @Date: 2022-04-26 16:42:14
+ * @LastEditors: lishengyin
+ * @LastEditTime: 2022-06-27 16:58:59
+ */
+#include "KubeSphereTempalte.hpp"
+
+/**
+ * @description: ObjectToJson
+ * @return {*}
+ */
+void KubeSphereTempalte::ObjectToJson(rapidjson::Writer<rapidjson::StringBuffer>& writer){
+    writer.StartObject();
+
+    writer.Key("CONTENTTYPE");
+    writer.String(CONTENTTYPE.c_str());
+
+    writer.Key("DATA");
+    writer.String(DATA.c_str());
+
+    writer.EndObject();
+}
+
+/**
+ * @description: objectToJson
+ * @param {string&} str
+ * @return {*}
+ */    
+void KubeSphereTempalte::ObjectToJson(std::string& str) {
+}
+
+/**
+ * @description: jsonToObject
+ * @param {string&} json
+ * @return {*}
+ */    
+bool KubeSphereTempalte::jsonToObject(const std::string& json) {
+    return true;
+}
+
+/**
+ * @description: jsonToObject
+ * @param {Value&} object
+ * @return {*}
+ */    
+bool KubeSphereTempalte::jsonToObject(const rapidjson::Value& object){
+    return true;
+}
+
+/**
+ * @description: ObjectToSql
+ * @param {string&} sql
+ * @return {*}
+ */    
+bool KubeSphereTempalte::ObjectToSql(std::string& sql) {
+    return true;
+}
+
+/**
+ * @description: ObjectToSql后处理
+ * @param {string&} sql
+ * @return {*}
+ */ 
+bool KubeSphereTempalte::ObjectToSqlBack(std::string & sql){
+    return true;
+}

modules/GetCenter/src/GetCenter.cpp

@@ -4,7 +4,7 @@
  * @Autor: lishengyin
  * @Date: 2022-04-02 13:58:50
  * @LastEditors: lishengyin
- * @LastEditTime: 2022-06-17 11:46:45
+ * @LastEditTime: 2022-06-27 11:51:29
  */
 #include "GetCenter.hpp"
 #include "Disposition.hpp"
@@ -147,7 +147,7 @@ namespace ins{
             else if(type == "kubesphere") clinet = std::make_shared<httplib::Client>(disposition->k8s_IP, disposition->k8s_port);
             if(clinet == nullptr || line[0] == "") return false;
             SqlStream sqlStream(line[0].c_str());
-            if(type == "kubesphere") sqlStream << "system-base";
+            if(type == "kubesphere") sqlStream << Disposition::getPtr()->getWorkspace();
             std::string request = (std::string)sqlStream;
             httplib::Headers headers;
             // token认证

modules/ProcessingIt/include/ParserJson.hpp

@@ -3,8 +3,8 @@
  * @Version: 1.0
  * @Autor: lishengyin
  * @Date: 2022-04-12 15:40:03
- * @LastEditors: Your Name lishengyin@sz-sunwin.com
- * @LastEditTime: 2022-06-16 22:04:04
+ * @LastEditors: lishengyin
+ * @LastEditTime: 2022-06-27 15:26:26
  */
 #ifndef __PARSERJSON_HPP_
 #define __PARSERJSON_HPP_
@@ -72,6 +72,7 @@ namespace ins
                 else if(line[1] == "KubeSphereNodes") msg = std::make_shared<KubeSphereResourcesMsg<KubeSphereNodes>>();
                 else if(line[1] == "KubeSpherePods") msg = std::make_shared<KubeSphereResourcesMsg<KubeSpherePods>>();
                 else if(line[1] == "KubeSphereServers") msg = std::make_shared<KubeSphereResourcesMsg<KubeSphereServers>>();
+                else if(line[1] == "KubeSphereDeployments") msg = std::make_shared<KubeSphereResourcesMsg<KubeSphereDeployments>>();
             }
             return msg;
         }

source/UserApp/src/UserApp.cpp

@@ -4,7 +4,7 @@
  * @Autor: lishengyin
  * @Date: 2022-04-06 08:46:28
  * @LastEditors: lishengyin
- * @LastEditTime: 2022-06-23 17:19:57
+ * @LastEditTime: 2022-06-27 09:52:01
  */
 #include "UserApp.hpp"
 #include <drogon/drogon.h>
@@ -47,7 +47,6 @@ namespace ins{
             return ERR;
         }
         DebugL << "GetCenter initialization successfully" << endl;
-        
         Sectorpower::getPtr()->setEnable(true);
         return OK;
     }

source/controllers/include/api_v1_K8s.hpp

@@ -21,17 +21,15 @@ class K8s : public drogon::HttpController<K8s>
       
       METHOD_ADD(K8s::getServers, "/Servers?token={1}", Get, "LoginFilter");
       METHOD_ADD(K8s::postServers, "/Servers?token={1}", Post, "LoginFilter");
-      METHOD_ADD(K8s::putServers, "/Servers?token={1}", Put, "LoginFilter");
-      METHOD_ADD(K8s::deleteServers, "/Servers?token={1}", Delete, "LoginFilter");
+      METHOD_ADD(K8s::putServers, "/Servers?token={1}&name={2}", Put, "LoginFilter");
+      METHOD_ADD(K8s::deleteServers, "/Servers?token={1}&name={2}", Delete, "LoginFilter");
 
       METHOD_ADD(K8s::getPods, "/Pods?token={1}", Get, "LoginFilter");
-      METHOD_ADD(K8s::postPods, "/Pods?token={1}", Post, "LoginFilter");
-      METHOD_ADD(K8s::putPods, "/Pods?token={1}", Put, "LoginFilter");
       METHOD_ADD(K8s::deletePods, "/Pods?token={1}&name={2}",Delete, "LoginFilter");
-
+      
       METHOD_ADD(K8s::getDeployment,"/Deployment?token={1}", Get, "LoginFilter");
       METHOD_ADD(K8s::postDeployment,"/Deployment?token={1}", Post, "LoginFilter");
-      METHOD_ADD(K8s::putDeployment,"/Deployment?token={1}", Put, "LoginFilter");
+      METHOD_ADD(K8s::putDeployment,"/Deployment?token={1}&name={2}", Put, "LoginFilter");
       METHOD_ADD(K8s::deleteDeployment,"/Deployment?token={1}&name={2}", Delete, "LoginFilter");
 
     METHOD_LIST_END
@@ -42,22 +40,17 @@ class K8s : public drogon::HttpController<K8s>
     // Servers
     void getServers(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback,  std::string token);
     void postServers(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback,  std::string token);
-    void putServers(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback,  std::string token);
-    void patchServers(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback,  std::string token);
-    void deleteServers(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback,  std::string token);
+    void putServers(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback,  std::string token, std::string name);
+    void deleteServers(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback,  std::string token, std::string name);
 
     // Pods  
     void getPods(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token);
-    void postPods(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token);
-    void putPods(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token);
-    void patchPods(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token);
     void deletePods(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token, std::string name);
 
     // Deployment
     void getDeployment(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token);
     void postDeployment(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token);
-    void putDeployment(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token);
-    void patchDeployment(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token);
+    void putDeployment(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token, std::string name);
     void deleteDeployment(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token, std::string name);
 };
 }

source/controllers/include/api_v1_apps.hpp

@@ -14,25 +14,22 @@ class apps : public drogon::HttpController<apps>
   public:
     METHOD_LIST_BEGIN
       // use METHOD_ADD to add your custom processing function here;
-      METHOD_ADD(apps::getTemplate, "/template?token={1}", Get, "LoginFilter"); // path is /api/v1/apps/template?token={1}
+      METHOD_ADD(apps::getTemplate, "/template?token={1}&name={2}", Get, "LoginFilter"); // path is /api/v1/apps/template?token={1}
       METHOD_ADD(apps::getAIList, "AIList?token={1}", Get, "LoginFilter");
 
       METHOD_ADD(apps::getAI, "AI?token={1}&name={2}", Get, "LoginFilter");
       METHOD_ADD(apps::postAI, "AI?token={1}&name={2}&uri={3}", Post, "LoginFilter");
       METHOD_ADD(apps::deleteAI, "AI?token={1}&name={2}", Delete, "LoginFilter");
-      METHOD_ADD(apps::getDemo, "AIDEMO?token={1}", Get, "LoginFilter");
-
+      
     METHOD_LIST_END
     // your declaration of processing function maybe like this:
-    void getTemplate(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token);
+    void getTemplate(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token, std::string name);
     void getAIList(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token);
 
     // AI
     void getAI(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token, std::string name);
     void postAI(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token, std::string name, std::string uri);
     void deleteAI(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token, std::string name);
-
-    void getDemo(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token);
 };
 }
 }

source/controllers/src/api_v1_K8s.cpp

@@ -9,7 +9,6 @@
 
 using namespace api::v1;
 
-
 /**
  * @description: 获取Nodes
  * @param {HttpRequestPtr&} req
@@ -65,7 +64,7 @@ void K8s::getServers(const HttpRequestPtr& req, std::function<void (const HttpRe
      std::string token) {
     auto clientPtr = drogon::app().getDbClient();
     auto f = clientPtr->execSqlAsyncFuture("SELECT UID,NAME,NAMESPACE,LABELS,PORTS,CLUSTERIP,TYPE \
-         FROM InsServerDB.`InsKsServers` WHERE USERID = ? and ISDELETE = 0",ins::Disposition::getPtr()->getUserId());
+         FROM InsServerDB.`InsKsServers` WHERE USERID = ? and ISDELETE = 0", ins::Disposition::getPtr()->getUserId());
     try
     {
         auto SqlResult = f.get(); // Block until we get the result or catch the exception;
@@ -107,10 +106,19 @@ void K8s::getServers(const HttpRequestPtr& req, std::function<void (const HttpRe
  * @return {*}
  */
 void K8s::postServers(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback,  std::string token){
-    HttpResponsePtr resp;
-    resp = HttpResponse::newHttpResponse();
-    resp->setBody("postServers");
-    callback(resp);
+    ins::Disposition::Ptr disposition = ins::Disposition::getPtr();
+    std::string src = "http://"+ disposition->k8s_IP + ":" + std::to_string(disposition->k8s_port);
+    auto client = HttpClient::newHttpClient(src);
+    auto send_req = HttpRequest::newHttpRequest();
+    send_req->setMethod(drogon::Post);
+    send_req->setPath("/apis/apps/v1/namespaces/" + disposition->getWorkspace() +  "/services");
+    send_req->addHeader("Authorization", disposition->KsToken.token_type + " " + disposition->KsToken.access_token);
+    send_req->setContentTypeCode(req->getContentType());
+    send_req->setBody(req->getBody().data());
+    auto result = client->sendRequest(send_req);
+    auto *pluginPtr=app().getPlugin<httpHelper>();
+    auto request = pluginPtr->replyRequest(result,send_req->getMethod());
+    callback(request);
 }
 
 /**
@@ -120,11 +128,20 @@ void K8s::postServers(const HttpRequestPtr& req, std::function<void (const HttpR
  * @param {string} token
  * @return {*}
  */
-void K8s::putServers(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback,  std::string token){
-    HttpResponsePtr resp;
-    resp = HttpResponse::newHttpResponse();
-    resp->setBody("putServers");
-    callback(resp);
+void K8s::putServers(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback,  std::string token, std::string name){
+    ins::Disposition::Ptr disposition = ins::Disposition::getPtr();
+    std::string src = "http://"+ disposition->k8s_IP + ":" + std::to_string(disposition->k8s_port);
+    auto client = HttpClient::newHttpClient(src);
+    auto send_req = HttpRequest::newHttpRequest();
+    send_req->setMethod(drogon::Post);
+    send_req->setPath("/apis/apps/v1/namespaces/" + disposition->getWorkspace() +  "/services/" + name);
+    send_req->addHeader("Authorization", disposition->KsToken.token_type + " " + disposition->KsToken.access_token);
+    send_req->setContentTypeCode(req->getContentType());
+    send_req->setBody(req->getBody().data());
+    auto result = client->sendRequest(send_req);
+    auto *pluginPtr=app().getPlugin<httpHelper>();
+    auto request = pluginPtr->replyRequest(result,send_req->getMethod());
+    callback(request);
 }
 
 /**
@@ -134,11 +151,18 @@ void K8s::putServers(const HttpRequestPtr& req, std::function<void (const HttpRe
  * @param {string} token
  * @return {*}
  */
-void K8s::deleteServers(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback,  std::string token){
-    HttpResponsePtr resp;
-    resp = HttpResponse::newHttpResponse();
-    resp->setBody("deleteServers");
-    callback(resp);
+void K8s::deleteServers(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback,  std::string token, std::string name){
+    ins::Disposition::Ptr disposition = ins::Disposition::getPtr();
+    std::string src = "http://"+ disposition->k8s_IP + ":" + std::to_string(disposition->k8s_port);
+    auto client = HttpClient::newHttpClient(src);
+    auto send_req = HttpRequest::newHttpRequest();
+    send_req->setMethod(drogon::Delete);
+    send_req->setPath("/apis/apps/v1/namespaces/" + disposition->getWorkspace() +  "/services/" + name);
+    send_req->addHeader("Authorization", disposition->KsToken.token_type + " " + disposition->KsToken.access_token);
+    auto result = client->sendRequest(send_req);
+    auto *pluginPtr=app().getPlugin<httpHelper>();
+    auto request = pluginPtr->replyRequest(result,send_req->getMethod());
+    callback(request);
 }
 
 /**
@@ -185,34 +209,6 @@ void K8s::getPods(const HttpRequestPtr& req, std::function<void (const HttpRespo
     }
 }
 
-/**
- * @description: postPods
- * @param {HttpRequestPtr&} req
- * @param {function<void (HttpResponsePtr &)>} &
- * @param {string} token
- * @return {*}
- */
-void K8s::postPods(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token){
-    HttpResponsePtr resp;
-    resp = HttpResponse::newHttpResponse();
-    resp->setBody("postPods");
-    callback(resp);
-}
-
-/**
- * @description: 
- * @param {HttpRequestPtr&} req
- * @param {function<void (HttpResponsePtr &)>} &
- * @param {string} token
- * @return {*}
- */
-void K8s::putPods(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token){
-    HttpResponsePtr resp;
-    resp = HttpResponse::newHttpResponse();
-    resp->setBody("putPods");
-    callback(resp);
-}
-
 
 /**
  * @description: 
@@ -243,10 +239,40 @@ void K8s::deletePods(const HttpRequestPtr& req, std::function<void (const HttpRe
  * @return {*}
  */
 void K8s::getDeployment(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token){
-    HttpResponsePtr resp;
-    resp = HttpResponse::newHttpResponse();
-    resp->setBody("getDeployment");
-    callback(resp);
+    auto clientPtr = drogon::app().getDbClient();
+    auto f = clientPtr->execSqlAsyncFuture("SELECT UID,NAME,NAMESPACE,LABELS,CONTAINERS,PHASE,CONDITIONS \
+         FROM InsServerDB.`InsKsDeployments` WHERE USERID = ? and ISDELETE = 0",ins::Disposition::getPtr()->getUserId());
+    try
+    {
+        auto SqlResult = f.get(); // Block until we get the result or catch the exception;
+        HttpResultMsg<KubeSphereDeployments, HttpNull> request;
+        for(auto line: SqlResult){
+            KubeSphereDeployments data;
+            data.UID = line["UID"].as<std::string>();
+            data.NAME = line["NAME"].as<std::string>();
+            data.NAMESPACE = line["NAMESPACE"].as<std::string>();
+            data.LABELS = line["LABELS"].as<std::string>();
+            data.CONTAINERS = line["CONTAINERS"].as<std::string>();
+            data.PHASE = line["PHASE"].as<std::string>();
+            data.CONDITIONS = line["CONDITIONS"].as<std::string>();
+            request.datas.push_back(data);
+        }
+        std::string json;
+        request.code = "200";
+        request.msg = "成功";
+        request.ok = true;
+        request.objectToJson(json);
+        HttpResponsePtr resp;
+        resp = HttpResponse::newHttpResponse();
+        resp->setBody(json);
+        callback(resp);
+    }
+    catch(const drogon::orm::DrogonDbException &e)
+    {
+        ErrorL << "error:" << e.base().what() << std::endl;
+        auto *pluginPtr=app().getPlugin<httpHelper>();
+        callback(pluginPtr->makeWrongReply(e.base().what()));
+    }
 }
 
 /**
@@ -257,10 +283,19 @@ void K8s::getDeployment(const HttpRequestPtr& req, std::function<void (const Htt
  * @return {*}
  */
 void K8s::postDeployment(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token){
-    HttpResponsePtr resp;
-    resp = HttpResponse::newHttpResponse();
-    resp->setBody("postDeployment");
-    callback(resp);
+    ins::Disposition::Ptr disposition = ins::Disposition::getPtr();
+    std::string src = "http://"+ disposition->k8s_IP + ":" + std::to_string(disposition->k8s_port);
+    auto client = HttpClient::newHttpClient(src);
+    auto send_req = HttpRequest::newHttpRequest();
+    send_req->setMethod(drogon::Post);
+    send_req->setPath("/apis/apps/v1/namespaces/" + disposition->getWorkspace() +  "/deployments");
+    send_req->addHeader("Authorization", disposition->KsToken.token_type + " " + disposition->KsToken.access_token);
+    send_req->setContentTypeCode(req->getContentType());
+    send_req->setBody(req->getBody().data());
+    auto result = client->sendRequest(send_req);
+    auto *pluginPtr=app().getPlugin<httpHelper>();
+    auto request = pluginPtr->replyRequest(result,send_req->getMethod());
+    callback(request);
 }
 
 /**
@@ -270,14 +305,22 @@ void K8s::postDeployment(const HttpRequestPtr& req, std::function<void (const Ht
  * @param {string} token
  * @return {*}
  */
-void K8s::putDeployment(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token){
-    HttpResponsePtr resp;
-    resp = HttpResponse::newHttpResponse();
-    resp->setBody("putDeployment");
-    callback(resp);
+void K8s::putDeployment(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token, std::string name){
+    ins::Disposition::Ptr disposition = ins::Disposition::getPtr();
+    std::string src = "http://"+ disposition->k8s_IP + ":" + std::to_string(disposition->k8s_port);
+    auto client = HttpClient::newHttpClient(src);
+    auto send_req = HttpRequest::newHttpRequest();
+    send_req->setMethod(drogon::Put);
+    send_req->setPath("/apis/apps/v1/namespaces/" + disposition->getWorkspace() +  "/deployments/" + name);
+    send_req->addHeader("Authorization", disposition->KsToken.token_type + " " + disposition->KsToken.access_token);
+    send_req->setContentTypeCode(req->getContentType());
+    send_req->setBody(req->getBody().data());
+    auto result = client->sendRequest(send_req);
+    auto *pluginPtr=app().getPlugin<httpHelper>();
+    auto request = pluginPtr->replyRequest(result,send_req->getMethod());
+    callback(request);
 }
 
-
 /**
  * @description: delete
  * @param {HttpRequestPtr&} req
@@ -286,8 +329,15 @@ void K8s::putDeployment(const HttpRequestPtr& req, std::function<void (const Htt
  */
 void K8s::deleteDeployment(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token, \
      std::string name){
-    HttpResponsePtr resp;
-    resp = HttpResponse::newHttpResponse();
-    resp->setBody("deleteDeployment");
-    callback(resp);
+    ins::Disposition::Ptr disposition = ins::Disposition::getPtr();
+    std::string src = "http://"+ disposition->k8s_IP + ":" + std::to_string(disposition->k8s_port);
+    auto client = HttpClient::newHttpClient(src);
+    auto send_req = HttpRequest::newHttpRequest();
+    send_req->setMethod(drogon::Delete);
+    send_req->setPath("/apis/apps/v1/namespaces/" + disposition->getWorkspace() +  "/deployments/" + name);
+    send_req->addHeader("Authorization", disposition->KsToken.token_type + " " + disposition->KsToken.access_token);
+    auto result = client->sendRequest(send_req);
+    auto *pluginPtr=app().getPlugin<httpHelper>();
+    auto request = pluginPtr->replyRequest(result,send_req->getMethod());
+    callback(request);
 }

source/controllers/src/api_v1_User.cpp

@@ -2,7 +2,7 @@
  * @Author: Your Name lishengyin@sz-sunwin.com
  * @Date: 2022-06-15 22:08:07
  * @LastEditors: lishengyin
- * @LastEditTime: 2022-06-16 08:54:25
+ * @LastEditTime: 2022-06-27 09:51:37
  * @FilePath: /ins/source/controllers/src/api_v1_User.cpp
  * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
  */
@@ -29,7 +29,6 @@ void User::login(const HttpRequestPtr &req,std::function<void (const HttpRespons
 
 void User::getInfo(const HttpRequestPtr &req, std::function<void (const HttpResponsePtr &)> &&callback, 
     std::string userId, const std::string &token)const{
-    
     //验证token有效性等
     //读数据库或缓存获取用户信息
     Json::Value ret;

source/controllers/src/api_v1_apps.cpp

@@ -18,11 +18,49 @@ using namespace api::v1;
  * @param {string} token
  * @return {*}
  */
-void apps::getTemplate(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token){
-    HttpResponsePtr resp;
-    resp = HttpResponse::newHttpResponse();
-    resp->setBody("getTemplate");
-    callback(resp);
+void apps::getTemplate(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token, std::string name){
+    auto clientPtr = drogon::app().getDbClient();
+    auto f = clientPtr->execSqlAsyncFuture("SELECT `DATA` FROM InsServerDB.`InsDataDescription` JOIN InsServerDB.InsKsTemplate ON InsServerDB.InsKsTemplate.DESCRIPTIONID = InsServerDB.InsDataDescription.DESCRIPTIONID  \
+            WHERE InsServerDB.InsDataDescription.USERID = ? AND InsServerDB.InsDataDescription.NAME = ?",ins::Disposition::getPtr()->getUserId(), name);
+    try{
+        auto SqlResult = f.get();
+        HttpResultMsg<KubeSphereTempalte, HttpNull> msg;
+        HttpResponsePtr resp;
+        std::string json;
+        if(SqlResult.empty()){
+            msg.code = "-5";
+            msg.msg = "失败, 该AI模板不存在";
+            msg.ok = false;
+            msg.objectToJson(json);
+            resp = HttpResponse::newHttpResponse();
+            resp->setBody(json);
+            callback(resp);
+            return;
+        }
+        if(SqlResult.size() > 1) WarnL << name <<  "模板不唯一" << endl;
+        ins::Disposition::Ptr disposition = ins::Disposition::getPtr();
+        std::string data;
+        for(auto line : SqlResult) {
+            data = line["DATA"].as<std::string>();
+        }
+        msg.code = "200";
+        msg.msg = "成功";
+        msg.ok = true;
+        KubeSphereTempalte t;
+        t.CONTENTTYPE = "application/json";
+        t.DATA = data;
+        msg.datas.push_back(t);
+        msg.objectToJson(json);
+        resp = HttpResponse::newHttpResponse();
+        resp->setBody(json);
+        callback(resp);
+    }
+    catch(const drogon::orm::DrogonDbException &e)
+    {
+        ErrorL << "error:" << e.base().what() << std::endl;
+        auto *pluginPtr=app().getPlugin<httpHelper>();
+        callback(pluginPtr->makeWrongReply(e.base().what()));
+    }
 }
 
 /**
@@ -178,33 +216,3 @@ void apps::deleteAI(const HttpRequestPtr& req, std::function<void (const HttpRes
     callback(request);
 }
 
-/**
- * @description: getDemo
- * @param {HttpRequestPtr&} req
- * @param {function<void (HttpResponsePtr &)>} &
- * @param {string} token
- * @return {*}
- */
-void apps::getDemo(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback, std::string token){
-    auto clientPtr = drogon::app().getDbClient();
-    auto f = clientPtr->execSqlAsyncFuture("SELECT * FROM `InsDataDescription`");
-    try
-    {
-        auto result = f.get(); // Block until we get the result or catch the exception;
-        std::cout << result.size() << " rows selected!" << std::endl;
-        std::string str;
-        for (auto row : result)
-        {
-            str += row["NAME"].as<std::string>();
-        }
-        HttpResponsePtr resp;
-        resp = HttpResponse::newHttpResponse();
-        resp->setBody(str);
-        callback(resp);
-    }
-    catch (const drogon::orm::DrogonDbException &e)
-    {
-        std::cerr << "error:" << e.base().what() << std::endl;
-    }
-}
-

source/plugins/src/httpHelper.cpp

@@ -49,7 +49,7 @@ HttpResponsePtr httpHelper::replyRequest(std::pair<ReqResult, HttpResponsePtr> r
     HttpResultMsg<HttpNull, HttpNull> msg;
     HttpResponsePtr resp;
     resp = HttpResponse::newHttpResponse();
-    std::string json;=[]
+    std::string json;
     if(result.first != ReqResult::Ok){
         ErrorL << "error while sending request to server! result " << result.first << std::endl;
         msg.code = "502";