Remove implements of zmq ipc

diff --git a/register_service.sh b/register_service.sh
index 8c4510b..8117826 100755 (executable)
--- a/register_service.sh
+++ b/register_service.sh
@@ -9,13 +9,13 @@ echo "  Create Edge-Orchestration Binary"
 echo "-------------------------------------"
 
 BASE_DIR=$( cd "$(dirname "$0")" ; pwd )
-ZMQ_VERSION="zmq_4_x"
+# ZMQ_VERSION="zmq_4_x"s
 
 export GOARCH=amd64
 export GOPATH=$GOPATH:$BASE_DIR:$BASE_DIR/vendor
 
-go build -tags $ZMQ_VERSION -a -o $BASE_DIR/bin/$SERVICE_BIN orchestration || exit 1
-# go build -tags $ZMQ_VERSION -a -ldflags '-extldflags "-static"' -o $BASE_DIR/bin/$SERVICE_BIN orchestration
+# go build -tags $ZMQ_VERSION -a -o $BASE_DIR/bin/$SERVICE_BIN orchestration || exit 1
+go build -a -ldflags '-extldflags "-static"' -o $BASE_DIR/bin/$SERVICE_BIN orchestration
 
 ls -al $BASE_DIR/bin
 

diff --git a/src/restapi/v1/restapi.go b/src/restapi/v1/restapi.go
index df95ffe..5262db7 100644 (file)
--- a/src/restapi/v1/restapi.go
+++ b/src/restapi/v1/restapi.go
@@ -71,19 +71,19 @@ func APIV1ServicemgrServicesDelete(w http.ResponseWriter, r *http.Request) {
        log.Printf("[%s] APIV1ServicemgrServicesDelete", logPrefix)
 }
 
-// APIV1ServicemgrServicesGet function
-func APIV1ServicemgrServicesGet(w http.ResponseWriter, r *http.Request) {
-       log.Printf("[%s] APIV1ServicemgrServicesGet", logPrefix)
-}
-
 // 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)
                writeJSONResponse(w, data, http.StatusOK)
+       } else if err == servicemgr.ErrInvalidService {
+               data := servicemgr.ServiceCreationResponse{Status: servicemgr.ConstServiceNotFound}
+               dataBytes, _ := json.Marshal(data)
+               writeJSONResponse(w, dataBytes, http.StatusNotFound)
        } else {
                writeJSONResponse(w, nil, http.StatusBadRequest)
        }
@@ -96,9 +96,10 @@ func APIV1ServicemgrServicesServiceIDDelete(w http.ResponseWriter, r *http.Reque
        vars := mux.Vars(r)
        serviceID := vars["serviceid"]
        id, err := strconv.ParseUint(serviceID, 10, 64)
+       name, _ := servicemgr.GetServiceName(id)
 
-       if len(serviceID) == 0 || err != nil {
-               smbytes, _ := json.Marshal(servicemgr.ServiceDestroyResponse{Return: "NOTFOUND"})
+       if len(name) == 0 || err != nil {
+               smbytes, _ := json.Marshal(servicemgr.ServiceDestroyResponse{Return: servicemgr.ConstServiceNotFound})
                writeJSONResponse(w, smbytes, http.StatusBadRequest)
        } else {
                go servicemgr.DeleteServiceHandler(w, r, id)
@@ -112,19 +113,23 @@ func APIV1ServicemgrServicesServiceIDDelete(w http.ResponseWriter, r *http.Reque
 func APIV1ServicemgrEventServiceIDPost(w http.ResponseWriter, r *http.Request) {
        log.Printf("[%s] APIV1ServicemgrEventServiceIDPost", logPrefix)
 
-       vars := mux.Vars(r)
-       serviceID := vars["serviceid"]
-       id, err := strconv.ParseUint(serviceID, 10, 64)
+       w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+       writeJSONResponse(w, nil, http.StatusNotImplemented)
 
-       if len(serviceID) == 0 || err != nil {
-               w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-               w.WriteHeader(http.StatusBadRequest)
-       } else {
-               servicemgr.DataPathHandler(w, r, id)
+       // @ TODO
+       // vars := mux.Vars(r)
+       // serviceID := vars["serviceid"]
+       // id, err := strconv.ParseUint(serviceID, 10, 64)
 
-               w.Header().Set("Content-Type", "application/json; charset=UTF-8")
-               w.WriteHeader(http.StatusOK)
-       }
+       // if len(serviceID) == 0 || err != nil {
+       //      w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+       //      w.WriteHeader(http.StatusBadRequest)
+       // } else {
+       //      servicemgr.DataPathHandler(w, r, id)
+
+       //      w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+       //      w.WriteHeader(http.StatusOK)
+       // }
 }
 
 // APIV1ServicemgrServicesServiceIDGet function
@@ -140,16 +145,18 @@ func APIV1ServicemgrServicesServiceIDPost(w http.ResponseWriter, r *http.Request
        serviceID := vars["serviceid"]
        id, _ := strconv.ParseUint(serviceID, 10, 64)
 
+       log.Println("[serviceID] :", id)
+
        exist, _ := servicemgr.GetServiceName(id)
+       distService, err := servicemgr.ExecuteServiceHandler(w, r, id)
 
-       if len(exist) != 0 {
-               smbytes, _ := json.Marshal(servicemgr.ServiceCreationResponse{Return: "NOTFOUND"})
+       if len(exist) == 0 || err != nil {
+               smbytes, _ := json.Marshal(servicemgr.ServiceExecutionResponse{Status: servicemgr.ConstServiceStatusFailed})
                writeJSONResponse(w, smbytes, http.StatusBadRequest)
        } else {
-               distService, _ := servicemgr.ExecuteServiceHandler(w, r, id)
                go servicemgr.Run(distService, id)
 
-               smbytes, _ := json.Marshal(servicemgr.ServiceCreationResponse{Return: "OK"})
+               smbytes, _ := json.Marshal(servicemgr.ServiceExecutionResponse{Status: servicemgr.ConstServiceStatusStarted})
                writeJSONResponse(w, smbytes, http.StatusOK)
        }
 }

diff --git a/src/servicemgr/http_handler.go b/src/servicemgr/http_handler.go
index 6d8e45b..b875f75 100644 (file)
--- a/src/servicemgr/http_handler.go
+++ b/src/servicemgr/http_handler.go
@@ -2,13 +2,13 @@ package servicemgr
 
 import (
        "encoding/json"
-       "errors"
        "log"
+       "net"
        "net/http"
+       "os/exec"
+       "strconv"
 )
 
-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)
@@ -22,10 +22,16 @@ func CreateServiceHandler(w http.ResponseWriter, req *http.Request) (servicePara
 
        err = decoder.Decode(&serviceParam)
        if err != nil {
-               log.Println(err)
+               log.Println(err.Error())
                return
        }
 
+       _, err = exec.LookPath(serviceParam.ServiceName)
+       if err != nil {
+               log.Println(err.Error())
+               err = ErrInvalidService
+       }
+
        return
 }
 
@@ -39,8 +45,17 @@ func ExecuteServiceHandler(w http.ResponseWriter, req *http.Request, serviceID u
        decoder := json.NewDecoder(req.Body)
        err = decoder.Decode(&distService)
        if err != nil {
+               log.Println(err.Error())
+               return
+       }
+
+       remoteAddr, _, err := net.SplitHostPort(req.RemoteAddr)
+       if err != nil {
+               log.Println(err.Error())
                return
        }
+       distService.SystemArgs = append(distService.SystemArgs, remoteAddr)
+       distService.SystemArgs = append(distService.SystemArgs, strconv.Itoa(ConstFWWellknownPort))
 
        return
 }
@@ -52,31 +67,32 @@ func DeleteServiceHandler(w http.ResponseWriter, req *http.Request, serviceID ui
                return
        }
 
-       err = cmd.Process.Kill()
-       if err != nil {
-               log.Println("Error occured from Process.Kill() : ", err)
-               return
+       if cmd.ProcessState.Exited() == false {
+               err = cmd.Process.Kill()
+               if err != nil {
+                       log.Println(err.Error())
+               }
        }
 
        return
 }
 
-// DataPathHandler function
-func DataPathHandler(w http.ResponseWriter, req *http.Request, serviceID uint64) (err error) {
-       msgChan, err := GetMsgChan(serviceID)
-       if err != nil {
-               return
-       }
+// @TODO DataPathHandler function (service <-> service)
+// func DataPathHandler(w http.ResponseWriter, req *http.Request, serviceID uint64) (err error) {
+//     msgChan, err := GetMsgChan(serviceID)
+//     if err != nil {
+//             return
+//     }
 
-       decoder := json.NewDecoder(req.Body)
-       msgFormat := MsgFormat{}
-       err = decoder.Decode(&msgFormat)
+//     decoder := json.NewDecoder(req.Body)
+//     msgFormat := MsgFormat{}
+//     err = decoder.Decode(&msgFormat)
 
-       if err != nil {
-               return
-       }
+//     if err != nil {
+//             return
+//     }
 
-       msgChan <- msgFormat
+//     msgChan <- msgFormat
 
-       return
-}
+//     return
+// }

diff --git a/src/servicemgr/service_agent.go b/src/servicemgr/service_agent.go
index 415f7f6..2d966e7 100644 (file)
--- a/src/servicemgr/service_agent.go
+++ b/src/servicemgr/service_agent.go
@@ -4,7 +4,7 @@ import (
        "encoding/json"
        "log"
        "os/exec"
-       "strconv"
+       "strings"
        "time"
 )
 
@@ -17,19 +17,16 @@ func makeTime() string {
 func Create(serviceParam ServiceParam) []byte {
        instanceCount := serviceParam.Count
 
-       ret := ServiceExecutionResponse{}
-       ret.ServiceList = make([]ServiceExecutionItem, instanceCount)
+       ret := ServiceCreationResponse{}
+       ret.Status = ConstServiceFound
+       ret.ServiceList = make([]ServiceCreationResponseItem, instanceCount)
 
        for index := 0; index < instanceCount; index++ {
                var cmd *exec.Cmd
 
-               log.Println("servicName: ", serviceParam.ServiceName)
-               id, msgChan, ctlChan := CreateServiceMap(cmd, serviceParam.ServiceName, serviceParam.AppName)
-               log.Println("id : ", id)
+               id, _, _ := CreateServiceMap(cmd, serviceParam.ServiceName, serviceParam.AppName)
 
-               go PushIpcZmq(id, msgChan, ctlChan)
-
-               serviceInfo := ServiceExecutionItem{id, makeTime()}
+               serviceInfo := ServiceCreationResponseItem{id, makeTime()}
                ret.ServiceList[index] = serviceInfo
        }
 
@@ -46,14 +43,14 @@ func Run(distService DistService, serviceID uint64) {
        }
 
        var args []string
-       for _, userParam := range distService.UserParam.Args {
+       for _, userParam := range distService.UserArgs {
                args = append(args, userParam)
        }
 
-       args = append(args, distService.SystemParam.IP)
-       args = append(args, strconv.Itoa(distService.SystemParam.Port))
        args = append(args, "--remote")
 
-       service := Service{serviceID, serviceName, args}
+       notificationTargetURL := strings.Join(distService.SystemArgs, ":")
+
+       service := Service{serviceID, serviceName, args, notificationTargetURL}
        service.execute()
 }