Defined structures for /exec and /signal response.

[src/xds/xds-server.git] / lib / apiv1 / make.go

diff --git a/lib/apiv1/make.go b/lib/apiv1/make.go
index 77f9ec3..6e0c7d6 100644 (file)
--- a/lib/apiv1/make.go
+++ b/lib/apiv1/make.go
@@ -9,13 +9,14 @@ import (
        "strconv"
 
        "github.com/gin-gonic/gin"
-       "github.com/iotbzh/xds-server/lib/common"
+       common "github.com/iotbzh/xds-common/golib"
 )
 
 // MakeArgs is the parameters (json format) of /make command
 type MakeArgs struct {
        ID            string   `json:"id"`
-       SdkID         string   `json:"sdkid"` // sdk ID to use for setting env
+       SdkID         string   `json:"sdkID"` // sdk ID to use for setting env
+       CmdID         string   `json:"cmdID"` // command unique ID
        Args          []string `json:"args"`  // args to pass to make command
        Env           []string `json:"env"`
        RPath         string   `json:"rpath"`         // relative path into project
@@ -67,20 +68,26 @@ func (s *APIService) buildMake(c *gin.Context) {
        }
 
        // Allow to pass id in url (/make/:id) or as JSON argument
-       id := c.Param("id")
-       if id == "" {
-               id = args.ID
+       idArg := c.Param("id")
+       if idArg == "" {
+               idArg = args.ID
        }
-       if id == "" {
+       if idArg == "" {
                common.APIError(c, "Invalid id")
                return
        }
-
-       prj := s.mfolder.GetFolderFromID(id)
-       if prj == nil {
+       id, err := s.mfolders.ResolveID(idArg)
+       if err != nil {
+               common.APIError(c, err.Error())
+               return
+       }
+       pf := s.mfolders.Get(id)
+       if pf == nil {
                common.APIError(c, "Unknown id")
                return
        }
+       folder := *pf
+       prj := folder.GetConfig()
 
        execTmo := args.CmdTimeout
        if execTmo == 0 {
@@ -92,11 +99,11 @@ func (s *APIService) buildMake(c *gin.Context) {
 
        // Define callback for output
        var oCB common.EmitOutputCB
-       oCB = func(sid string, id int, stdout, stderr string, data *map[string]interface{}) {
+       oCB = func(sid string, cmdID string, stdout, stderr string, data *map[string]interface{}) {
                // IO socket can be nil when disconnected
                so := s.sessions.IOSocketGet(sid)
                if so == nil {
-                       s.log.Infof("%s not emitted: WS closed - sid: %s - msg id:%d", MakeOutEvent, sid, id)
+                       s.log.Infof("%s not emitted: WS closed - sid: %s - msg id:%s", MakeOutEvent, sid, cmdID)
                        return
                }
 
@@ -112,7 +119,7 @@ func (s *APIService) buildMake(c *gin.Context) {
 
                // FIXME replace by .BroadcastTo a room
                err := (*so).Emit(MakeOutEvent, MakeOutMsg{
-                       CmdID:     strconv.Itoa(id),
+                       CmdID:     cmdID,
                        Timestamp: time.Now().String(),
                        Stdout:    stdout,
                        Stderr:    stderr,
@@ -123,13 +130,13 @@ func (s *APIService) buildMake(c *gin.Context) {
        }
 
        // Define callback for output
-       eCB := func(sid string, id int, code int, err error, data *map[string]interface{}) {
-               s.log.Debugf("Command [Cmd ID %d] exited: code %d, error: %v", id, code, err)
+       eCB := func(sid string, cmdID string, code int, err error, data *map[string]interface{}) {
+               s.log.Debugf("Command [Cmd ID %s] exited: code %d, error: %v", cmdID, code, err)
 
                // IO socket can be nil when disconnected
                so := s.sessions.IOSocketGet(sid)
                if so == nil {
-                       s.log.Infof("%s not emitted - WS closed (id:%d", MakeExitEvent, id)
+                       s.log.Infof("%s not emitted - WS closed (id:%s", MakeExitEvent, cmdID)
                        return
                }
 
@@ -138,7 +145,7 @@ func (s *APIService) buildMake(c *gin.Context) {
                exitImm := (*data)["ExitImmediate"].(bool)
 
                // XXX - workaround to be sure that Syncthing detected all changes
-               if err := s.mfolder.ForceSync(prjID); err != nil {
+               if err := s.mfolders.ForceSync(prjID); err != nil {
                        s.log.Errorf("Error while syncing folder %s: %v", prjID, err)
                }
                if !exitImm {
@@ -147,7 +154,7 @@ func (s *APIService) buildMake(c *gin.Context) {
                        tmo := 60
                        for t := tmo; t > 0; t-- {
                                s.log.Debugf("Wait file insync for %s (%d/%d)", prjID, t, tmo)
-                               if sync, err := s.mfolder.IsFolderInSync(prjID); sync || err != nil {
+                               if sync, err := s.mfolders.IsFolderInSync(prjID); sync || err != nil {
                                        if err != nil {
                                                s.log.Errorf("ERROR IsFolderInSync (%s): %v", prjID, err)
                                        }
@@ -159,7 +166,7 @@ func (s *APIService) buildMake(c *gin.Context) {
 
                // FIXME replace by .BroadcastTo a room
                e := (*so).Emit(MakeExitEvent, MakeExitMsg{
-                       CmdID:     strconv.Itoa(id),
+                       CmdID:     id,
                        Timestamp: time.Now().String(),
                        Code:      code,
                        Error:     err,
@@ -169,8 +176,11 @@ func (s *APIService) buildMake(c *gin.Context) {
                }
        }
 
-       cmdID := makeCommandID
-       makeCommandID++
+       // Unique ID for each commands
+       if args.CmdID == "" {
+               args.CmdID = s.cfg.ServerUID[:18] + "_" + strconv.Itoa(makeCommandID)
+               makeCommandID++
+       }
        cmd := []string{}
 
        // Retrieve env command regarding Sdk ID
@@ -179,19 +189,19 @@ func (s *APIService) buildMake(c *gin.Context) {
                cmd = append(cmd, "&&")
        }
 
-       cmd = append(cmd, "cd", prj.GetFullPath(args.RPath), "&&", "make")
+       cmd = append(cmd, "cd", folder.GetFullPath(args.RPath), "&&", "make")
        if len(args.Args) > 0 {
                cmd = append(cmd, args.Args...)
        }
 
-       s.log.Debugf("Execute [Cmd ID %d]: %v", cmdID, cmd)
+       s.log.Debugf("Execute [Cmd ID %d]: %v", args.CmdID, cmd)
 
        data := make(map[string]interface{})
        data["ID"] = prj.ID
        data["RootPath"] = prj.RootPath
        data["ExitImmediate"] = args.ExitImmediate
 
-       err := common.ExecPipeWs(cmd, args.Env, sop, sess.ID, cmdID, execTmo, s.log, oCB, eCB, &data)
+       err = common.ExecPipeWs(cmd, args.Env, sop, sess.ID, args.CmdID, execTmo, s.log, oCB, eCB, &data)
        if err != nil {
                common.APIError(c, err.Error())
                return
@@ -200,6 +210,6 @@ func (s *APIService) buildMake(c *gin.Context) {
        c.JSON(http.StatusOK,
                gin.H{
                        "status": "OK",
-                       "cmdID":  cmdID,
+                       "cmdID":  args.CmdID,
                })
 }