Modify restAPI handler followed changed restAPI URI

diff --git a/src/restapi/v1/restapi.go b/src/restapi/v1/restapi.go
index 2c3977bbb073491f33254d049a8a38a27683fd93..d4b09c480b1463a31a19407e1c801e1841f59176 100644 (file)
--- a/src/restapi/v1/restapi.go
+++ b/src/restapi/v1/restapi.go
@@ -15,6 +15,9 @@ import (
        "log"
        "net/http"
        "servicemgr"
+       "strconv"
+
+       "github.com/gorilla/mux"
 )
 
 // APIV1DeviceResourceUsageCPUGet function
@@ -53,16 +56,6 @@ func APIV1DeviceResourceUsageNetworkGet(w http.ResponseWriter, r *http.Request)
        writeJSONResponse(w, data, http.StatusOK)
 }
 
-// APIV1ServicemgrServiceDelete function
-func APIV1ServicemgrServiceDelete(w http.ResponseWriter, r *http.Request) {
-       log.Printf("[%s] APIV1ServicemgrServiceDelete", logPrefix)
-
-       servicemgr.StopServiceHandler(w, r)
-       w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-       data := []byte("Your Request Path is " + r.URL.Path)
-       writeJSONResponse(w, data, http.StatusOK)
-}
-
 // APIV1ServicemgrServiceGet function
 func APIV1ServicemgrServiceGet(w http.ResponseWriter, r *http.Request) {
        log.Printf("[%s] APIV1ServicemgrServiceGet", logPrefix)
@@ -71,16 +64,6 @@ func APIV1ServicemgrServiceGet(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
 }
 
-// APIV1ServicemgrServicePost function
-func APIV1ServicemgrServicePost(w http.ResponseWriter, r *http.Request) {
-       log.Printf("[%s] APIV1ServicemgrServicePost", logPrefix)
-
-       go servicemgr.Run(servicemgr.StartServiceHandler(w, r))
-       w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-       data := []byte("Your Request Path is " + r.URL.Path)
-       writeJSONResponse(w, data, http.StatusOK)
-}
-
 // APIV1ServicemgrServiceServiceIDGet function
 func APIV1ServicemgrServiceServiceIDGet(w http.ResponseWriter, r *http.Request) {
        log.Printf("[%s] APIV1ServicemgrServiceServiceIDGet", logPrefix)
@@ -89,6 +72,68 @@ func APIV1ServicemgrServiceServiceIDGet(w http.ResponseWriter, r *http.Request)
        w.WriteHeader(http.StatusOK)
 }
 
+// APIV1ServicemgrServicesPost function
+func APIV1ServicemgrServicesPost(w http.ResponseWriter, r *http.Request) {
+       log.Printf("[%s] APIV1ServicemgrServicesPost", logPrefix)
+
+       serviceParam, err := servicemgr.CreateServiceHandler(w, r)
+       if err == nil {
+               data := servicemgr.Create(serviceParam)
+               w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+               writeJSONResponse(w, data, http.StatusOK)
+       } else {
+               w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+               w.WriteHeader(http.StatusBadRequest)
+       }
+}
+
+// APIV1ServicemgrServicesServiceIDPost function
+func APIV1ServicemgrServicesServiceIDPost(w http.ResponseWriter, r *http.Request) {
+       log.Printf("[%s] APIV1ServicemgrServiceIDPost", logPrefix)
+
+       vars := mux.Vars(r)
+       serviceID := vars["serviceid"]
+       id, err := strconv.ParseUint(serviceID, 10, 64)
+
+       exist, _ := servicemgr.ServiceNameMap.Get(id)
+
+       if exist == nil || err != nil {
+               smbytes, _ := json.Marshal(servicemgr.ServiceCreationResponse{"NOTFOUND"})
+               writeJSONResponse(w, smbytes, http.StatusBadRequest)
+       } else {
+               distService, _ := servicemgr.ExecuteServiceHandler(w, r, id)
+               go servicemgr.Run(distService, id)
+
+               w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+               smbytes, _ := json.Marshal(servicemgr.ServiceCreationResponse{"OK"})
+               writeJSONResponse(w, smbytes, http.StatusBadRequest)
+       }
+}
+
+// APIV1ServicemgrEventServiceIDPost function
+func APIV1ServicemgrEventServiceIDPost(w http.ResponseWriter, r *http.Request) {
+
+}
+
+// APIV1ServicemgrServicesServiceIDDelete function
+func APIV1ServicemgrServicesServiceIDDelete(w http.ResponseWriter, r *http.Request) {
+       log.Printf("[%s] APIV1ServicemgrServicesServiceIDDelete", logPrefix)
+
+       vars := mux.Vars(r)
+       serviceID := vars["serviceid"]
+       id, err := strconv.ParseUint(serviceID, 10, 64)
+
+       if len(serviceID) == 0 || err != nil {
+               w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+               w.WriteHeader(http.StatusBadRequest)
+       } else {
+               go servicemgr.DeleteServiceHandler(w, r, id)
+
+               w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+               w.WriteHeader(http.StatusOK)
+       }
+}
+
 func writeJSONResponse(w http.ResponseWriter, data []byte, status int) {
        log.Printf("[%s] writeJSONResponse: %s", logPrefix, data)
        w.Header().Set("Content-Type", "application/json; charset=UTF-8")

diff --git a/src/restapi/v1/routers.go b/src/restapi/v1/routers.go
index 50d195099e423e9793a25df31b9203f008a6865a..27e229f5f0482ff5f36a0acb3147c9bb32fe0f9a 100644 (file)
--- a/src/restapi/v1/routers.go
+++ b/src/restapi/v1/routers.go
@@ -88,10 +88,10 @@ var routes = Routes{
        },
 
        Route{
-               "APIV1ServicemgrServiceDelete",
+               "APIV1ServicemgrServicesServiceIDDelete",
                strings.ToUpper("Delete"),
-               "/api/v1/servicemgr/service",
-               APIV1ServicemgrServiceDelete,
+               "/api/v1/servicemgr/services/{serviceid}",
+               APIV1ServicemgrServicesServiceIDDelete,
        },
 
        Route{
@@ -102,16 +102,30 @@ var routes = Routes{
        },
 
        Route{
-               "APIV1ServicemgrServicePost",
+               "APIV1ServicemgrEventServiceIDPost",
                strings.ToUpper("Post"),
-               "/api/v1/servicemgr/service",
-               APIV1ServicemgrServicePost,
+               "/api/v1/servicmgr/event/{serviceid}",
+               APIV1ServicemgrEventServiceIDPost,
+       },
+
+       Route{
+               "APIV1ServicemgrServicesServiceIDPost",
+               strings.ToUpper("Post"),
+               "/api/v1/servicemgr/services/{serviceid}",
+               APIV1ServicemgrServicesServiceIDPost,
+       },
+
+       Route{
+               "APIV1ServicemgrServicesPost",
+               strings.ToUpper("Post"),
+               "/api/v1/servicemgr/services",
+               APIV1ServicemgrServicesPost,
        },
 
        Route{
                "APIV1ServicemgrServiceServiceIDGet",
                strings.ToUpper("Get"),
-               "/api/v1/servicemgr/service/{serviceID}",
+               "/api/v1/servicemgr/service/{serviceid}",
                APIV1ServicemgrServiceServiceIDGet,
        },
 }

diff --git a/src/servicemgr/main.go b/src/servicemgr/main.go
index ab4661484eb0607031b7b209035b5cd0aaac74a0..4b95d4c20aee2813039514cd32bd1bbd9e44f78b 100644 (file)
--- a/src/servicemgr/main.go
+++ b/src/servicemgr/main.go
@@ -2,13 +2,14 @@ package servicemgr
 
 import (
        "encoding/json"
-       "fmt"
-       "io"
+       "errors"
        "log"
        "net/http"
-       "os"
+       "os/exec"
 )
 
+var errInvalidService = errors.New("It is Invalid Service")
+
 func checkHTTPError(w http.ResponseWriter, err error) {
        if err != nil {
                http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -16,81 +17,67 @@ func checkHTTPError(w http.ResponseWriter, err error) {
        }
 }
 
-// StartServiceHandler func
-func StartServiceHandler(w http.ResponseWriter, req *http.Request) DistService {
+// CreateServiceHandler function
+func CreateServiceHandler(w http.ResponseWriter, req *http.Request) (ServiceParam, error) {
        decoder := json.NewDecoder(req.Body)
 
-       distService := DistService{}
-       err := decoder.Decode(&distService)
+       serviceParam := ServiceParam{}
+       err := decoder.Decode(&serviceParam)
        if err != nil {
-               panic(err)
+               log.Println(err)
+               return serviceParam, err
        }
 
-       return distService
+       return serviceParam, nil
 }
 
-// StopServiceHandler func
-func StopServiceHandler(w http.ResponseWriter, req *http.Request) {
+// ExecuteServiceHandler function
+func ExecuteServiceHandler(w http.ResponseWriter, req *http.Request, serviceID uint64) (DistService, error) {
        decoder := json.NewDecoder(req.Body)
 
        distService := DistService{}
        err := decoder.Decode(&distService)
        if err != nil {
-               panic(err)
+               return distService, err
        }
 
-       cmd, exists := ServiceCmdMap[distService.ServiceName]
+       return distService, nil
+}
+
+// DeleteServiceHandler function
+func DeleteServiceHandler(w http.ResponseWriter, req *http.Request, serviceID uint64) error {
+       cmd, exists := ServiceCmdMap.Get(serviceID)
+       command, _ := cmd.(*exec.Cmd)
+
+       name, _ := ServiceNameMap.Get(serviceID)
+       serviceName, _ := name.(string)
 
        if exists {
-               err = cmd.Process.Kill()
+               err := command.Process.Kill()
                if err != nil {
                        log.Println("Error occured from Process.Kill() : ", err)
+                       return err
                }
-
-               delete(ServiceCmdMap, distService.ServiceName)
        } else {
-               log.Println(distService.ServiceName, "is not exist service")
+               log.Println(serviceName, "is not exist service")
        }
-}
-
-func startServiceHandlerForm(w http.ResponseWriter, req *http.Request) ExecutionType {
-       mr, err := req.MultipartReader()
-       checkHTTPError(w, err)
 
-       executionInfo := ExecutionType{}
-       index := 0
-       executionInfo.ServiceInfo.FileItem = make([]FileItem, 10, 100)
-
-       for {
-               part, err := mr.NextPart()
-
-               if err == io.EOF {
-                       break
-               }
-               checkHTTPError(w, err)
-
-               if part.FormName() == "file" {
-                       fmt.Println("index", index, part.FileName())
-                       outfile, err := os.Create("./storage/" + part.FileName())
-                       defer outfile.Close()
-                       executionInfo.ServiceInfo.FileItem[index].FileName = part.FileName()
-                       fmt.Println("FileName:", executionInfo.ServiceInfo.FileItem[index].FileName)
-
-                       checkHTTPError(w, err)
-
-                       _, err = io.Copy(outfile, part)
-                       checkHTTPError(w, err)
-
-                       index++
-               } else if part.FormName() == "executionCommand" {
-                       jsonDecoder := json.NewDecoder(part)
+       return nil
+}
 
-                       err = jsonDecoder.Decode(&executionInfo)
-                       checkHTTPError(w, err)
+// dataPathHandler function
+func dataPathHandler(w http.ResponseWriter, req *http.Request, serviceID uint64, data string) error {
+       msg, exists := ServiceMsgMap.Get(serviceID)
 
-                       fmt.Println(executionInfo.Name, executionInfo.ParamStr, executionInfo.ServiceType)
-               }
+       if exists {
+               inputData, _ := msg.(chan string)
+               inputData <- data
+       } else {
+               name, _ := ServiceNameMap.Get(serviceID)
+               serviceName, _ := name.(string)
+               log.Println(serviceName, "is not exist service")
+               return errInvalidService
        }
 
-       return executionInfo
+       return nil
 }