lib/apiv1/exec.go

   1 package apiv1
   2
   3 import (
   4         "fmt"
   5         "net/http"
   6         "os"
   7         "regexp"
   8         "strconv"
   9         "strings"
  10         "time"
  11
  12         "github.com/gin-gonic/gin"
  13         common "github.com/iotbzh/xds-common/golib"
  14         "github.com/iotbzh/xds-common/golib/eows"
  15         "github.com/kr/pty"
  16 )
  17
  18 type (
  19         // ExecArgs JSON parameters of /exec command
  20         ExecArgs struct {
  21                 ID              string   `json:"id" binding:"required"`
  22                 SdkID           string   `json:"sdkid"` // sdk ID to use for setting env
  23                 Cmd             string   `json:"cmd" binding:"required"`
  24                 Args            []string `json:"args"`
  25                 Env             []string `json:"env"`
  26                 RPath           string   `json:"rpath"`           // relative path into project
  27                 TTY             bool     `json:"tty"`             // Use a tty, specific to gdb --tty option
  28                 TTYGdbserverFix bool     `json:"ttyGdbserverFix"` // Set to true to activate gdbserver workaround about inferior output
  29                 ExitImmediate   bool     `json:"exitImmediate"`   // when true, exit event sent immediately when command exited (IOW, don't wait file synchronization)
  30                 CmdTimeout      int      `json:"timeout"`         // command completion timeout in Second
  31         }
  32
  33         // ExecInMsg Message used to received input characters (stdin)
  34         ExecInMsg struct {
  35                 CmdID     string `json:"cmdID"`
  36                 Timestamp string `json:"timestamp"`
  37                 Stdin     string `json:"stdin"`
  38         }
  39
  40         // ExecOutMsg Message used to send output characters (stdout+stderr)
  41         ExecOutMsg struct {
  42                 CmdID     string `json:"cmdID"`
  43                 Timestamp string `json:"timestamp"`
  44                 Stdout    string `json:"stdout"`
  45                 Stderr    string `json:"stderr"`
  46         }
  47
  48         // ExecExitMsg Message sent when executed command exited
  49         ExecExitMsg struct {
  50                 CmdID     string `json:"cmdID"`
  51                 Timestamp string `json:"timestamp"`
  52                 Code      int    `json:"code"`
  53                 Error     error  `json:"error"`
  54         }
  55
  56         // ExecSignalArgs JSON parameters of /exec/signal command
  57         ExecSignalArgs struct {
  58                 CmdID  string `json:"cmdID" binding:"required"`  // command id
  59                 Signal string `json:"signal" binding:"required"` // signal number
  60         }
  61 )
  62
  63 const (
  64         // ExecInEvent Event send in WS when characters are sent (stdin)
  65         ExecInEvent = "exec:input"
  66
  67         // ExecOutEvent Event send in WS when characters are received (stdout or stderr)
  68         ExecOutEvent = "exec:output"
  69
  70         // ExecExitEvent Event send in WS when program exited
  71         ExecExitEvent = "exec:exit"
  72
  73         // ExecInferiorInEvent Event send in WS when characters are sent to an inferior (used by gdb inferior/tty)
  74         ExecInferiorInEvent = "exec:inferior-input"
  75
  76         // ExecInferiorOutEvent Event send in WS when characters are received by an inferior
  77         ExecInferiorOutEvent = "exec:inferior-output"
  78 )
  79
  80 var execCommandID = 1
  81
  82 // ExecCmd executes remotely a command
  83 func (s *APIService) execCmd(c *gin.Context) {
  84         var gdbPty, gdbTty *os.File
  85         var err error
  86         var args ExecArgs
  87         if c.BindJSON(&args) != nil {
  88                 common.APIError(c, "Invalid arguments")
  89                 return
  90         }
  91
  92         // TODO: add permission ?
  93
  94         // Retrieve session info
  95         sess := s.sessions.Get(c)
  96         if sess == nil {
  97                 common.APIError(c, "Unknown sessions")
  98                 return
  99         }
 100         sop := sess.IOSocket
 101         if sop == nil {
 102                 common.APIError(c, "Websocket not established")
 103                 return
 104         }
 105
 106         // Allow to pass id in url (/exec/:id) or as JSON argument
 107         id := c.Param("id")
 108         if id == "" {
 109                 id = args.ID
 110         }
 111         if id == "" {
 112                 common.APIError(c, "Invalid id")
 113                 return
 114         }
 115
 116         f := s.mfolders.Get(id)
 117         if f == nil {
 118                 common.APIError(c, "Unknown id")
 119                 return
 120         }
 121         folder := *f
 122         prj := folder.GetConfig()
 123
 124         // Build command line
 125         cmd := []string{}
 126         // Setup env var regarding Sdk ID (used for example to setup cross toolchain)
 127         if envCmd := s.sdks.GetEnvCmd(args.SdkID, prj.DefaultSdk); len(envCmd) > 0 {
 128                 cmd = append(cmd, envCmd...)
 129                 cmd = append(cmd, "&&")
 130         } else {
 131                 // It's an error if no envcmd found while a sdkid has been provided
 132                 if args.SdkID != "" {
 133                         common.APIError(c, "Unknown sdkid")
 134                         return
 135                 }
 136         }
 137
 138         cmd = append(cmd, "cd", folder.GetFullPath(args.RPath))
 139         // FIXME - add 'exec' prevents to use syntax:
 140         //       xds-exec -l debug -c xds-config.env -- "cd build && cmake .."
 141         //  but exec is mandatory to allow to pass correctly signals
 142         //  As workaround, exec is set for now on client side (eg. in xds-gdb)
 143         //cmd = append(cmd, "&&", "exec", args.Cmd)
 144         cmd = append(cmd, "&&", args.Cmd)
 145
 146         // Process command arguments
 147         cmdArgs := make([]string, len(args.Args)+1)
 148         copy(cmdArgs, args.Args)
 149
 150         // Allocate pts if tty if used
 151         if args.TTY {
 152                 gdbPty, gdbTty, err = pty.Open()
 153                 if err != nil {
 154                         common.APIError(c, err.Error())
 155                         return
 156                 }
 157
 158                 s.log.Debugf("Client command tty: %v %v\n", gdbTty.Name(), gdbTty.Name())
 159                 cmdArgs = append(cmdArgs, "--tty="+gdbTty.Name())
 160         }
 161
 162         // Unique ID for each commands
 163         cmdID := strconv.Itoa(execCommandID)
 164         execCommandID++
 165
 166         // Create new execution over WS context
 167         execWS := eows.New(strings.Join(cmd, " "), cmdArgs, sop, sess.ID, cmdID)
 168         execWS.Log = s.log
 169
 170         // Append client project dir to environment
 171         execWS.Env = append(args.Env, "CLIENT_PROJECT_DIR="+prj.ClientPath)
 172
 173         // Set command execution timeout
 174         if args.CmdTimeout == 0 {
 175                 // 0 : default timeout
 176                 // TODO get default timeout from config.json file
 177                 execWS.CmdExecTimeout = 24 * 60 * 60 // 1 day
 178         } else {
 179                 execWS.CmdExecTimeout = args.CmdTimeout
 180         }
 181
 182         // Define callback for input (stdin)
 183         execWS.InputEvent = ExecInEvent
 184         execWS.InputCB = func(e *eows.ExecOverWS, stdin string) (string, error) {
 185                 s.log.Debugf("STDIN <<%v>>", strings.Replace(stdin, "\n", "\\n", -1))
 186
 187                 // Handle Ctrl-D
 188                 if len(stdin) == 1 && stdin == "\x04" {
 189                         // Close stdin
 190                         errMsg := fmt.Errorf("close stdin: %v", stdin)
 191                         return "", errMsg
 192                 }
 193
 194                 // Set correct path
 195                 data := e.UserData
 196                 rootPath := (*data)["RootPath"].(string)
 197                 clientPath := (*data)["ClientPath"].(string)
 198                 stdin = strings.Replace(stdin, clientPath, rootPath+"/"+clientPath, -1)
 199
 200                 return stdin, nil
 201         }
 202
 203         // Define callback for output (stdout+stderr)
 204         execWS.OutputCB = func(e *eows.ExecOverWS, stdout, stderr string) {
 205                 // IO socket can be nil when disconnected
 206                 so := s.sessions.IOSocketGet(e.Sid)
 207                 if so == nil {
 208                         s.log.Infof("%s not emitted: WS closed (sid:%s, msgid:%s)", ExecOutEvent, e.Sid, e.CmdID)
 209                         return
 210                 }
 211
 212                 // Retrieve project ID and RootPath
 213                 data := e.UserData
 214                 prjID := (*data)["ID"].(string)
 215                 prjRootPath := (*data)["RootPath"].(string)
 216                 gdbServerTTY := (*data)["gdbServerTTY"].(string)
 217
 218                 // Cleanup any references to internal rootpath in stdout & stderr
 219                 stdout = strings.Replace(stdout, prjRootPath, "", -1)
 220                 stderr = strings.Replace(stderr, prjRootPath, "", -1)
 221
 222                 s.log.Debugf("%s emitted - WS sid[4:] %s - id:%s - prjID:%s", ExecOutEvent, e.Sid[4:], e.CmdID, prjID)
 223                 if stdout != "" {
 224                         s.log.Debugf("STDOUT <<%v>>", strings.Replace(stdout, "\n", "\\n", -1))
 225                 }
 226                 if stderr != "" {
 227                         s.log.Debugf("STDERR <<%v>>", strings.Replace(stderr, "\n", "\\n", -1))
 228                 }
 229
 230                 // FIXME replace by .BroadcastTo a room
 231                 err := (*so).Emit(ExecOutEvent, ExecOutMsg{
 232                         CmdID:     e.CmdID,
 233                         Timestamp: time.Now().String(),
 234                         Stdout:    stdout,
 235                         Stderr:    stderr,
 236                 })
 237                 if err != nil {
 238                         s.log.Errorf("WS Emit : %v", err)
 239                 }
 240
 241                 // XXX - Workaround due to gdbserver bug that doesn't redirect
 242                 // inferior output (https://bugs.eclipse.org/bugs/show_bug.cgi?id=437532#c13)
 243                 if gdbServerTTY == "workaround" && len(stdout) > 1 && stdout[0] == '&' {
 244
 245                         // Extract and cleanup string like &"bla bla\n"
 246                         re := regexp.MustCompile("&\"(.*)\"")
 247                         rer := re.FindAllStringSubmatch(stdout, -1)
 248                         out := ""
 249                         if rer != nil && len(rer) > 0 {
 250                                 for _, o := range rer {
 251                                         if len(o) >= 1 {
 252                                                 out = strings.Replace(o[1], "\\n", "\n", -1)
 253                                                 out = strings.Replace(out, "\\r", "\r", -1)
 254                                                 out = strings.Replace(out, "\\t", "\t", -1)
 255
 256                                                 s.log.Debugf("STDOUT INFERIOR: <<%v>>", out)
 257                                                 err := (*so).Emit(ExecInferiorOutEvent, ExecOutMsg{
 258                                                         CmdID:     e.CmdID,
 259                                                         Timestamp: time.Now().String(),
 260                                                         Stdout:    out,
 261                                                         Stderr:    "",
 262                                                 })
 263                                                 if err != nil {
 264                                                         s.log.Errorf("WS Emit : %v", err)
 265                                                 }
 266                                         }
 267                                 }
 268                         } else {
 269                                 s.log.Errorf("INFERIOR out parsing error: stdout=<%v>", stdout)
 270                         }
 271                 }
 272         }
 273
 274         // Define callback for output
 275         execWS.ExitCB = func(e *eows.ExecOverWS, code int, err error) {
 276                 s.log.Debugf("Command [Cmd ID %s] exited: code %d, error: %v", e.CmdID, code, err)
 277
 278                 // IO socket can be nil when disconnected
 279                 so := s.sessions.IOSocketGet(e.Sid)
 280                 if so == nil {
 281                         s.log.Infof("%s not emitted - WS closed (id:%s)", ExecExitEvent, e.CmdID)
 282                         return
 283                 }
 284
 285                 // Retrieve project ID and RootPath
 286                 data := e.UserData
 287                 prjID := (*data)["ID"].(string)
 288                 exitImm := (*data)["ExitImmediate"].(bool)
 289
 290                 // XXX - workaround to be sure that Syncthing detected all changes
 291                 if err := s.mfolders.ForceSync(prjID); err != nil {
 292                         s.log.Errorf("Error while syncing folder %s: %v", prjID, err)
 293                 }
 294                 if !exitImm {
 295                         // Wait end of file sync
 296                         // FIXME pass as argument
 297                         tmo := 60
 298                         for t := tmo; t > 0; t-- {
 299                                 s.log.Debugf("Wait file in-sync for %s (%d/%d)", prjID, t, tmo)
 300                                 if sync, err := s.mfolders.IsFolderInSync(prjID); sync || err != nil {
 301                                         if err != nil {
 302                                                 s.log.Errorf("ERROR IsFolderInSync (%s): %v", prjID, err)
 303                                         }
 304                                         break
 305                                 }
 306                                 time.Sleep(time.Second)
 307                         }
 308                 }
 309
 310                 // Close client tty
 311                 if gdbPty != nil {
 312                         gdbPty.Close()
 313                 }
 314                 if gdbTty != nil {
 315                         gdbTty.Close()
 316                 }
 317
 318                 // FIXME replace by .BroadcastTo a room
 319                 errSoEmit := (*so).Emit(ExecExitEvent, ExecExitMsg{
 320                         CmdID:     e.CmdID,
 321                         Timestamp: time.Now().String(),
 322                         Code:      code,
 323                         Error:     err,
 324                 })
 325                 if errSoEmit != nil {
 326                         s.log.Errorf("WS Emit : %v", errSoEmit)
 327                 }
 328         }
 329
 330         // User data (used within callbacks)
 331         data := make(map[string]interface{})
 332         data["ID"] = prj.ID
 333         data["RootPath"] = prj.RootPath
 334         data["ClientPath"] = prj.ClientPath
 335         data["ExitImmediate"] = args.ExitImmediate
 336         if args.TTY && args.TTYGdbserverFix {
 337                 data["gdbServerTTY"] = "workaround"
 338         } else {
 339                 data["gdbServerTTY"] = ""
 340         }
 341         execWS.UserData = &data
 342
 343         // Start command execution
 344         s.log.Debugf("Execute [Cmd ID %s]: %v %v", execWS.CmdID, execWS.Cmd, execWS.Args)
 345
 346         err = execWS.Start()
 347         if err != nil {
 348                 common.APIError(c, err.Error())
 349                 return
 350         }
 351
 352         c.JSON(http.StatusOK,
 353                 gin.H{
 354                         "status": "OK",
 355                         "cmdID":  execWS.CmdID,
 356                 })
 357 }
 358
 359 // ExecCmd executes remotely a command
 360 func (s *APIService) execSignalCmd(c *gin.Context) {
 361         var args ExecSignalArgs
 362
 363         if c.BindJSON(&args) != nil {
 364                 common.APIError(c, "Invalid arguments")
 365                 return
 366         }
 367
 368         s.log.Debugf("Signal %s for command ID %s", args.Signal, args.CmdID)
 369
 370         e := eows.GetEows(args.CmdID)
 371         if e == nil {
 372                 common.APIError(c, "unknown cmdID")
 373                 return
 374         }
 375
 376         err := e.Signal(args.Signal)
 377         if err != nil {
 378                 common.APIError(c, err.Error())
 379                 return
 380         }
 381
 382         c.JSON(http.StatusOK,
 383                 gin.H{
 384                         "status": "OK",
 385                 })
 386 }