summaryrefslogtreecommitdiffstats
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/apiv1/agent.go3
-rw-r--r--lib/apiv1/apiv1.go12
-rw-r--r--lib/apiv1/config.go7
-rw-r--r--lib/apiv1/events.go147
-rw-r--r--lib/apiv1/exec.go322
-rw-r--r--lib/apiv1/folders.go50
-rw-r--r--lib/apiv1/make.go28
-rw-r--r--lib/crosssdk/sdks.go3
-rw-r--r--lib/folder/folder-interface.go68
-rw-r--r--lib/folder/folder-pathmap.go115
-rw-r--r--lib/model/folder.go110
-rw-r--r--lib/model/folders.go388
-rw-r--r--lib/syncthing/folder-st.go170
-rw-r--r--lib/syncthing/st.go79
-rw-r--r--lib/syncthing/stEvent.go265
-rw-r--r--lib/syncthing/stfolder.go121
-rw-r--r--lib/webserver/server.go24
-rw-r--r--lib/xdsconfig/config.go27
-rw-r--r--lib/xdsconfig/fileconfig.go40
-rw-r--r--lib/xdsconfig/folderconfig.go85
-rw-r--r--lib/xdsconfig/foldersconfig.go47
21 files changed, 1661 insertions, 450 deletions
diff --git a/lib/apiv1/agent.go b/lib/apiv1/agent.go
index 651f246..925f12b 100644
--- a/lib/apiv1/agent.go
+++ b/lib/apiv1/agent.go
@@ -11,6 +11,7 @@ import (
common "github.com/iotbzh/xds-common/golib"
)
+// XDSAgentTarball .
type XDSAgentTarball struct {
OS string `json:"os"`
Arch string `json:"arch"`
@@ -18,6 +19,8 @@ type XDSAgentTarball struct {
RawVersion string `json:"raw-version"`
FileURL string `json:"fileUrl"`
}
+
+// XDSAgentInfo .
type XDSAgentInfo struct {
Tarballs []XDSAgentTarball `json:"tarballs"`
}
diff --git a/lib/apiv1/apiv1.go b/lib/apiv1/apiv1.go
index 7fa69e9..262f513 100644
--- a/lib/apiv1/apiv1.go
+++ b/lib/apiv1/apiv1.go
@@ -16,19 +16,19 @@ type APIService struct {
apiRouter *gin.RouterGroup
sessions *session.Sessions
cfg *xdsconfig.Config
- mfolder *model.Folder
+ mfolders *model.Folders
sdks *crosssdk.SDKs
log *logrus.Logger
}
// New creates a new instance of API service
-func New(r *gin.Engine, sess *session.Sessions, cfg *xdsconfig.Config, mfolder *model.Folder, sdks *crosssdk.SDKs) *APIService {
+func New(r *gin.Engine, sess *session.Sessions, cfg *xdsconfig.Config, mfolders *model.Folders, sdks *crosssdk.SDKs) *APIService {
s := &APIService{
router: r,
sessions: sess,
apiRouter: r.Group("/api/v1"),
cfg: cfg,
- mfolder: mfolder,
+ mfolders: mfolders,
sdks: sdks,
log: cfg.Log,
}
@@ -42,6 +42,7 @@ func New(r *gin.Engine, sess *session.Sessions, cfg *xdsconfig.Config, mfolder *
s.apiRouter.GET("/folders", s.getFolders)
s.apiRouter.GET("/folder/:id", s.getFolder)
s.apiRouter.POST("/folder", s.addFolder)
+ s.apiRouter.POST("/folder/sync/:id", s.syncFolder)
s.apiRouter.DELETE("/folder/:id", s.delFolder)
s.apiRouter.GET("/sdks", s.getSdks)
@@ -52,6 +53,11 @@ func New(r *gin.Engine, sess *session.Sessions, cfg *xdsconfig.Config, mfolder *
s.apiRouter.POST("/exec", s.execCmd)
s.apiRouter.POST("/exec/:id", s.execCmd)
+ s.apiRouter.POST("/signal", s.execSignalCmd)
+
+ s.apiRouter.GET("/events", s.eventsList)
+ s.apiRouter.POST("/events/register", s.eventsRegister)
+ s.apiRouter.POST("/events/unregister", s.eventsUnRegister)
return s
}
diff --git a/lib/apiv1/config.go b/lib/apiv1/config.go
index 662ec8e..4b53217 100644
--- a/lib/apiv1/config.go
+++ b/lib/apiv1/config.go
@@ -36,10 +36,5 @@ func (s *APIService) setConfig(c *gin.Context) {
s.log.Debugln("SET config: ", cfgArg)
- if err := s.mfolder.UpdateAll(cfgArg); err != nil {
- common.APIError(c, err.Error())
- return
- }
-
- c.JSON(http.StatusOK, s.cfg)
+ common.APIError(c, "Not Supported")
}
diff --git a/lib/apiv1/events.go b/lib/apiv1/events.go
new file mode 100644
index 0000000..da8298c
--- /dev/null
+++ b/lib/apiv1/events.go
@@ -0,0 +1,147 @@
+package apiv1
+
+import (
+ "net/http"
+ "time"
+
+ "github.com/iotbzh/xds-server/lib/folder"
+
+ "github.com/gin-gonic/gin"
+ common "github.com/iotbzh/xds-common/golib"
+)
+
+// EventArgs is the parameters (json format) of /events/register command
+type EventRegisterArgs struct {
+ Name string `json:"name"`
+ ProjectID string `json:"filterProjectID"`
+}
+
+type EventUnRegisterArgs struct {
+ Name string `json:"name"`
+ ID int `json:"id"`
+}
+
+// EventMsg Message send
+type EventMsg struct {
+ Time string `json:"time"`
+ Type string `json:"type"`
+ Folder folder.FolderConfig `json:"folder"`
+}
+
+// EventEvent Event send in WS when an internal event (eg. Syncthing event is received)
+const EventEventAll = "event:all"
+const EventEventType = "event:" // following by event type
+
+// eventsList Registering for events that will be send over a WS
+func (s *APIService) eventsList(c *gin.Context) {
+
+}
+
+// eventsRegister Registering for events that will be send over a WS
+func (s *APIService) eventsRegister(c *gin.Context) {
+ var args EventRegisterArgs
+
+ if c.BindJSON(&args) != nil {
+ common.APIError(c, "Invalid arguments")
+ return
+ }
+
+ sess := s.sessions.Get(c)
+ if sess == nil {
+ common.APIError(c, "Unknown sessions")
+ return
+ }
+
+ evType := "FolderStateChanged"
+ if args.Name != evType {
+ common.APIError(c, "Unsupported event name")
+ return
+ }
+
+ /* XXX - to be removed if no plan to support "generic" event
+ var cbFunc st.EventsCB
+ cbFunc = func(ev st.Event, data *st.EventsCBData) {
+
+ evid, _ := strconv.Atoi((*data)["id"].(string))
+ ssid := (*data)["sid"].(string)
+ so := s.sessions.IOSocketGet(ssid)
+ if so == nil {
+ s.log.Infof("Event %s not emitted - sid: %s", ev.Type, ssid)
+
+ // Consider that client disconnected, so unregister this event
+ s.mfolders.SThg.Events.UnRegister(ev.Type, evid)
+ return
+ }
+
+ msg := EventMsg{
+ Time: ev.Time,
+ Type: ev.Type,
+ Data: ev.Data,
+ }
+
+ if err := (*so).Emit(EventEventAll, msg); err != nil {
+ s.log.Errorf("WS Emit Event : %v", err)
+ }
+
+ if err := (*so).Emit(EventEventType+ev.Type, msg); err != nil {
+ s.log.Errorf("WS Emit Event : %v", err)
+ }
+ }
+
+ data := make(st.EventsCBData)
+ data["sid"] = sess.ID
+
+ id, err := s.mfolders.SThg.Events.Register(args.Name, cbFunc, args.ProjectID, &data)
+ */
+
+ var cbFunc folder.EventCB
+ cbFunc = func(cfg *folder.FolderConfig, data *folder.EventCBData) {
+ ssid := (*data)["sid"].(string)
+ so := s.sessions.IOSocketGet(ssid)
+ if so == nil {
+ //s.log.Infof("Event %s not emitted - sid: %s", ev.Type, ssid)
+
+ // Consider that client disconnected, so unregister this event
+ // SEB FIXMEs.mfolders.RegisterEventChange(ev.Type)
+ return
+ }
+
+ msg := EventMsg{
+ Time: time.Now().String(),
+ Type: evType,
+ Folder: *cfg,
+ }
+
+ if err := (*so).Emit(EventEventType+evType, msg); err != nil {
+ s.log.Errorf("WS Emit Folder StateChanged event : %v", err)
+ }
+ }
+ data := make(folder.EventCBData)
+ data["sid"] = sess.ID
+
+ err := s.mfolders.RegisterEventChange(args.ProjectID, &cbFunc, &data)
+ if err != nil {
+ common.APIError(c, err.Error())
+ return
+ }
+
+ c.JSON(http.StatusOK, gin.H{"status": "OK"})
+}
+
+// eventsRegister Registering for events that will be send over a WS
+func (s *APIService) eventsUnRegister(c *gin.Context) {
+ var args EventUnRegisterArgs
+
+ if c.BindJSON(&args) != nil || args.Name == "" || args.ID < 0 {
+ common.APIError(c, "Invalid arguments")
+ return
+ }
+ /* TODO
+ if err := s.mfolders.SThg.Events.UnRegister(args.Name, args.ID); err != nil {
+ common.APIError(c, err.Error())
+ return
+ }
+ c.JSON(http.StatusOK, gin.H{"status": "OK"})
+ */
+ common.APIError(c, "Not implemented yet")
+}
diff --git a/lib/apiv1/exec.go b/lib/apiv1/exec.go
index 654ff64..6300dba 100644
--- a/lib/apiv1/exec.go
+++ b/lib/apiv1/exec.go
@@ -1,53 +1,88 @@
package apiv1
import (
+ "fmt"
"net/http"
+ "os"
+ "regexp"
"strconv"
"strings"
"time"
"github.com/gin-gonic/gin"
common "github.com/iotbzh/xds-common/golib"
+ "github.com/iotbzh/xds-common/golib/eows"
+ "github.com/kr/pty"
)
-// ExecArgs JSON parameters of /exec command
-type ExecArgs struct {
- ID string `json:"id" binding:"required"`
- SdkID string `json:"sdkid"` // sdk ID to use for setting env
- Cmd string `json:"cmd" binding:"required"`
- Args []string `json:"args"`
- Env []string `json:"env"`
- RPath string `json:"rpath"` // relative path into project
- ExitImmediate bool `json:"exitImmediate"` // when true, exit event sent immediately when command exited (IOW, don't wait file synchronization)
- CmdTimeout int `json:"timeout"` // command completion timeout in Second
-}
+type (
+ // ExecArgs JSON parameters of /exec command
+ ExecArgs struct {
+ ID string `json:"id" binding:"required"`
+ SdkID string `json:"sdkid"` // sdk ID to use for setting env
+ Cmd string `json:"cmd" binding:"required"`
+ Args []string `json:"args"`
+ Env []string `json:"env"`
+ RPath string `json:"rpath"` // relative path into project
+ TTY bool `json:"tty"` // Use a tty, specific to gdb --tty option
+ TTYGdbserverFix bool `json:"ttyGdbserverFix"` // Set to true to activate gdbserver workaround about inferior output
+ ExitImmediate bool `json:"exitImmediate"` // when true, exit event sent immediately when command exited (IOW, don't wait file synchronization)
+ CmdTimeout int `json:"timeout"` // command completion timeout in Second
+ }
-// ExecOutMsg Message send on each output (stdout+stderr) of executed command
-type ExecOutMsg struct {
- CmdID string `json:"cmdID"`
- Timestamp string `json:"timestamp"`
- Stdout string `json:"stdout"`
- Stderr string `json:"stderr"`
-}
+ // ExecInMsg Message used to received input characters (stdin)
+ ExecInMsg struct {
+ CmdID string `json:"cmdID"`
+ Timestamp string `json:"timestamp"`
+ Stdin string `json:"stdin"`
+ }
-// ExecExitMsg Message send when executed command exited
-type ExecExitMsg struct {
- CmdID string `json:"cmdID"`
- Timestamp string `json:"timestamp"`
- Code int `json:"code"`
- Error error `json:"error"`
-}
+ // ExecOutMsg Message used to send output characters (stdout+stderr)
+ ExecOutMsg struct {
+ CmdID string `json:"cmdID"`
+ Timestamp string `json:"timestamp"`
+ Stdout string `json:"stdout"`
+ Stderr string `json:"stderr"`
+ }
+
+ // ExecExitMsg Message sent when executed command exited
+ ExecExitMsg struct {
+ CmdID string `json:"cmdID"`
+ Timestamp string `json:"timestamp"`
+ Code int `json:"code"`
+ Error error `json:"error"`
+ }
+
+ // ExecSignalArgs JSON parameters of /exec/signal command
+ ExecSignalArgs struct {
+ CmdID string `json:"cmdID" binding:"required"` // command id
+ Signal string `json:"signal" binding:"required"` // signal number
+ }
+)
-// ExecOutEvent Event send in WS when characters are received
-const ExecOutEvent = "exec:output"
+const (
+ // ExecInEvent Event send in WS when characters are sent (stdin)
+ ExecInEvent = "exec:input"
-// ExecExitEvent Event send in WS when program exited
-const ExecExitEvent = "exec:exit"
+ // ExecOutEvent Event send in WS when characters are received (stdout or stderr)
+ ExecOutEvent = "exec:output"
+
+ // ExecExitEvent Event send in WS when program exited
+ ExecExitEvent = "exec:exit"
+
+ // ExecInferiorInEvent Event send in WS when characters are sent to an inferior (used by gdb inferior/tty)
+ ExecInferiorInEvent = "exec:inferior-input"
+
+ // ExecInferiorOutEvent Event send in WS when characters are received by an inferior
+ ExecInferiorOutEvent = "exec:inferior-output"
+)
var execCommandID = 1
// ExecCmd executes remotely a command
func (s *APIService) execCmd(c *gin.Context) {
+ var gdbPty, gdbTty *os.File
+ var err error
var args ExecArgs
if c.BindJSON(&args) != nil {
common.APIError(c, "Invalid arguments")
@@ -78,41 +113,123 @@ func (s *APIService) execCmd(c *gin.Context) {
return
}
- prj := s.mfolder.GetFolderFromID(id)
- if prj == nil {
+ f := s.mfolders.Get(id)
+ if f == nil {
common.APIError(c, "Unknown id")
return
}
+ folder := *f
+ prj := folder.GetConfig()
- execTmo := args.CmdTimeout
- if execTmo == 0 {
+ // Build command line
+ cmd := []string{}
+ // Setup env var regarding Sdk ID (used for example to setup cross toolchain)
+ if envCmd := s.sdks.GetEnvCmd(args.SdkID, prj.DefaultSdk); len(envCmd) > 0 {
+ cmd = append(cmd, envCmd...)
+ cmd = append(cmd, "&&")
+ } else {
+ // It's an error if no envcmd found while a sdkid has been provided
+ if args.SdkID != "" {
+ common.APIError(c, "Unknown sdkid")
+ return
+ }
+ }
+
+ cmd = append(cmd, "cd", folder.GetFullPath(args.RPath))
+ // FIXME - add 'exec' prevents to use syntax:
+ // xds-exec -l debug -c xds-config.env -- "cd build && cmake .."
+ // but exec is mandatory to allow to pass correctly signals
+ // As workaround, exec is set for now on client side (eg. in xds-gdb)
+ //cmd = append(cmd, "&&", "exec", args.Cmd)
+ cmd = append(cmd, "&&", args.Cmd)
+
+ // Process command arguments
+ cmdArgs := make([]string, len(args.Args)+1)
+ copy(cmdArgs, args.Args)
+
+ // Allocate pts if tty if used
+ if args.TTY {
+ gdbPty, gdbTty, err = pty.Open()
+ if err != nil {
+ common.APIError(c, err.Error())
+ return
+ }
+
+ s.log.Debugf("Client command tty: %v %v\n", gdbTty.Name(), gdbTty.Name())
+ cmdArgs = append(cmdArgs, "--tty="+gdbTty.Name())
+ }
+
+ // Unique ID for each commands
+ cmdID := strconv.Itoa(execCommandID)
+ execCommandID++
+
+ // Create new execution over WS context
+ execWS := eows.New(strings.Join(cmd, " "), cmdArgs, sop, sess.ID, cmdID)
+ execWS.Log = s.log
+
+ // Append client project dir to environment
+ execWS.Env = append(args.Env, "CLIENT_PROJECT_DIR="+prj.ClientPath)
+
+ // Set command execution timeout
+ if args.CmdTimeout == 0 {
+ // 0 : default timeout
// TODO get default timeout from config.json file
- execTmo = 24 * 60 * 60 // 1 day
+ execWS.CmdExecTimeout = 24 * 60 * 60 // 1 day
+ } else {
+ execWS.CmdExecTimeout = args.CmdTimeout
}
- // Define callback for output
- var oCB common.EmitOutputCB
- oCB = func(sid string, id int, stdout, stderr string, data *map[string]interface{}) {
+ // Define callback for input (stdin)
+ execWS.InputEvent = ExecInEvent
+ execWS.InputCB = func(e *eows.ExecOverWS, stdin string) (string, error) {
+ s.log.Debugf("STDIN <<%v>>", strings.Replace(stdin, "\n", "\\n", -1))
+
+ // Handle Ctrl-D
+ if len(stdin) == 1 && stdin == "\x04" {
+ // Close stdin
+ errMsg := fmt.Errorf("close stdin: %v", stdin)
+ return "", errMsg
+ }
+
+ // Set correct path
+ data := e.UserData
+ rootPath := (*data)["RootPath"].(string)
+ clientPath := (*data)["ClientPath"].(string)
+ stdin = strings.Replace(stdin, clientPath, rootPath+"/"+clientPath, -1)
+
+ return stdin, nil
+ }
+
+ // Define callback for output (stdout+stderr)
+ execWS.OutputCB = func(e *eows.ExecOverWS, stdout, stderr string) {
// IO socket can be nil when disconnected
- so := s.sessions.IOSocketGet(sid)
+ so := s.sessions.IOSocketGet(e.Sid)
if so == nil {
- s.log.Infof("%s not emitted: WS closed - sid: %s - msg id:%d", ExecOutEvent, sid, id)
+ s.log.Infof("%s not emitted: WS closed (sid:%s, msgid:%s)", ExecOutEvent, e.Sid, e.CmdID)
return
}
// Retrieve project ID and RootPath
+ data := e.UserData
prjID := (*data)["ID"].(string)
prjRootPath := (*data)["RootPath"].(string)
+ gdbServerTTY := (*data)["gdbServerTTY"].(string)
// Cleanup any references to internal rootpath in stdout & stderr
stdout = strings.Replace(stdout, prjRootPath, "", -1)
stderr = strings.Replace(stderr, prjRootPath, "", -1)
- s.log.Debugf("%s emitted - WS sid %s - id:%d - prjID:%s", ExecOutEvent, sid, id, prjID)
+ s.log.Debugf("%s emitted - WS sid[4:] %s - id:%s - prjID:%s", ExecOutEvent, e.Sid[4:], e.CmdID, prjID)
+ if stdout != "" {
+ s.log.Debugf("STDOUT <<%v>>", strings.Replace(stdout, "\n", "\\n", -1))
+ }
+ if stderr != "" {
+ s.log.Debugf("STDERR <<%v>>", strings.Replace(stderr, "\n", "\\n", -1))
+ }
// FIXME replace by .BroadcastTo a room
err := (*so).Emit(ExecOutEvent, ExecOutMsg{
- CmdID: strconv.Itoa(id),
+ CmdID: e.CmdID,
Timestamp: time.Now().String(),
Stdout: stdout,
Stderr: stderr,
@@ -120,25 +237,58 @@ func (s *APIService) execCmd(c *gin.Context) {
if err != nil {
s.log.Errorf("WS Emit : %v", err)
}
+
+ // XXX - Workaround due to gdbserver bug that doesn't redirect
+ // inferior output (https://bugs.eclipse.org/bugs/show_bug.cgi?id=437532#c13)
+ if gdbServerTTY == "workaround" && len(stdout) > 1 && stdout[0] == '&' {
+
+ // Extract and cleanup string like &"bla bla\n"
+ re := regexp.MustCompile("&\"(.*)\"")
+ rer := re.FindAllStringSubmatch(stdout, -1)
+ out := ""
+ if rer != nil && len(rer) > 0 {
+ for _, o := range rer {
+ if len(o) >= 1 {
+ out = strings.Replace(o[1], "\\n", "\n", -1)
+ out = strings.Replace(out, "\\r", "\r", -1)
+ out = strings.Replace(out, "\\t", "\t", -1)
+
+ s.log.Debugf("STDOUT INFERIOR: <<%v>>", out)
+ err := (*so).Emit(ExecInferiorOutEvent, ExecOutMsg{
+ CmdID: e.CmdID,
+ Timestamp: time.Now().String(),
+ Stdout: out,
+ Stderr: "",
+ })
+ if err != nil {
+ s.log.Errorf("WS Emit : %v", err)
+ }
+ }
+ }
+ } else {
+ s.log.Errorf("INFERIOR out parsing error: stdout=<%v>", stdout)
+ }
+ }
}
// 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)
+ execWS.ExitCB = func(e *eows.ExecOverWS, code int, err error) {
+ s.log.Debugf("Command [Cmd ID %s] exited: code %d, error: %v", e.CmdID, code, err)
// IO socket can be nil when disconnected
- so := s.sessions.IOSocketGet(sid)
+ so := s.sessions.IOSocketGet(e.Sid)
if so == nil {
- s.log.Infof("%s not emitted - WS closed (id:%d", ExecExitEvent, id)
+ s.log.Infof("%s not emitted - WS closed (id:%s)", ExecExitEvent, e.CmdID)
return
}
// Retrieve project ID and RootPath
+ data := e.UserData
prjID := (*data)["ID"].(string)
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 {
@@ -146,8 +296,8 @@ func (s *APIService) execCmd(c *gin.Context) {
// FIXME pass as argument
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 {
+ s.log.Debugf("Wait file in-sync for %s (%d/%d)", prjID, t, tmo)
+ if sync, err := s.mfolders.IsFolderInSync(prjID); sync || err != nil {
if err != nil {
s.log.Errorf("ERROR IsFolderInSync (%s): %v", prjID, err)
}
@@ -157,44 +307,73 @@ func (s *APIService) execCmd(c *gin.Context) {
}
}
+ // Close client tty
+ if gdbPty != nil {
+ gdbPty.Close()
+ }
+ if gdbTty != nil {
+ gdbTty.Close()
+ }
+
// FIXME replace by .BroadcastTo a room
- e := (*so).Emit(ExecExitEvent, ExecExitMsg{
- CmdID: strconv.Itoa(id),
+ errSoEmit := (*so).Emit(ExecExitEvent, ExecExitMsg{
+ CmdID: e.CmdID,
Timestamp: time.Now().String(),
Code: code,
Error: err,
})
- if e != nil {
- s.log.Errorf("WS Emit : %v", e)
+ if errSoEmit != nil {
+ s.log.Errorf("WS Emit : %v", errSoEmit)
}
}
- cmdID := execCommandID
- execCommandID++
- cmd := []string{}
-
- // Setup env var regarding Sdk ID (used for example to setup cross toolchain)
- if envCmd := s.sdks.GetEnvCmd(args.SdkID, prj.DefaultSdk); len(envCmd) > 0 {
- cmd = append(cmd, envCmd...)
- cmd = append(cmd, "&&")
+ // User data (used within callbacks)
+ data := make(map[string]interface{})
+ data["ID"] = prj.ID
+ data["RootPath"] = prj.RootPath
+ data["ClientPath"] = prj.ClientPath
+ data["ExitImmediate"] = args.ExitImmediate
+ if args.TTY && args.TTYGdbserverFix {
+ data["gdbServerTTY"] = "workaround"
+ } else {
+ data["gdbServerTTY"] = ""
}
+ execWS.UserData = &data
- cmd = append(cmd, "cd", prj.GetFullPath(args.RPath), "&&", args.Cmd)
- if len(args.Args) > 0 {
- cmd = append(cmd, args.Args...)
+ // Start command execution
+ s.log.Debugf("Execute [Cmd ID %s]: %v %v", execWS.CmdID, execWS.Cmd, execWS.Args)
+
+ err = execWS.Start()
+ if err != nil {
+ common.APIError(c, err.Error())
+ return
}
- // Append client project dir to environment
- args.Env = append(args.Env, "CLIENT_PROJECT_DIR="+prj.RelativePath)
+ c.JSON(http.StatusOK,
+ gin.H{
+ "status": "OK",
+ "cmdID": execWS.CmdID,
+ })
+}
- s.log.Debugf("Execute [Cmd ID %d]: %v", cmdID, cmd)
+// ExecCmd executes remotely a command
+func (s *APIService) execSignalCmd(c *gin.Context) {
+ var args ExecSignalArgs
- data := make(map[string]interface{})
- data["ID"] = prj.ID
- data["RootPath"] = prj.RootPath
- data["ExitImmediate"] = args.ExitImmediate
+ if c.BindJSON(&args) != nil {
+ common.APIError(c, "Invalid arguments")
+ return
+ }
+
+ s.log.Debugf("Signal %s for command ID %s", args.Signal, args.CmdID)
+
+ e := eows.GetEows(args.CmdID)
+ if e == nil {
+ common.APIError(c, "unknown cmdID")
+ return
+ }
- err := common.ExecPipeWs(cmd, args.Env, sop, sess.ID, cmdID, execTmo, s.log, oCB, eCB, &data)
+ err := e.Signal(args.Signal)
if err != nil {
common.APIError(c, err.Error())
return
@@ -203,6 +382,5 @@ func (s *APIService) execCmd(c *gin.Context) {
c.JSON(http.StatusOK,
gin.H{
"status": "OK",
- "cmdID": cmdID,
})
}
diff --git a/lib/apiv1/folders.go b/lib/apiv1/folders.go
index 44bda24..cf56c3f 100644
--- a/lib/apiv1/folders.go
+++ b/lib/apiv1/folders.go
@@ -2,49 +2,39 @@ package apiv1
import (
"net/http"
- "strconv"
"github.com/gin-gonic/gin"
common "github.com/iotbzh/xds-common/golib"
- "github.com/iotbzh/xds-server/lib/xdsconfig"
+ "github.com/iotbzh/xds-server/lib/folder"
)
// getFolders returns all folders configuration
func (s *APIService) getFolders(c *gin.Context) {
- confMut.Lock()
- defer confMut.Unlock()
-
- c.JSON(http.StatusOK, s.cfg.Folders)
+ c.JSON(http.StatusOK, s.mfolders.GetConfigArr())
}
// getFolder returns a specific folder configuration
func (s *APIService) getFolder(c *gin.Context) {
- id, err := strconv.Atoi(c.Param("id"))
- if err != nil || id < 0 || id > len(s.cfg.Folders) {
+ f := s.mfolders.Get(c.Param("id"))
+ if f == nil {
common.APIError(c, "Invalid id")
return
}
- confMut.Lock()
- defer confMut.Unlock()
-
- c.JSON(http.StatusOK, s.cfg.Folders[id])
+ c.JSON(http.StatusOK, (*f).GetConfig())
}
// addFolder adds a new folder to server config
func (s *APIService) addFolder(c *gin.Context) {
- var cfgArg xdsconfig.FolderConfig
+ var cfgArg folder.FolderConfig
if c.BindJSON(&cfgArg) != nil {
common.APIError(c, "Invalid arguments")
return
}
- confMut.Lock()
- defer confMut.Unlock()
-
s.log.Debugln("Add folder config: ", cfgArg)
- newFld, err := s.mfolder.UpdateFolder(cfgArg)
+ newFld, err := s.mfolders.Add(cfgArg)
if err != nil {
common.APIError(c, err.Error())
return
@@ -53,25 +43,31 @@ func (s *APIService) addFolder(c *gin.Context) {
c.JSON(http.StatusOK, newFld)
}
-// delFolder deletes folder from server config
-func (s *APIService) delFolder(c *gin.Context) {
+// syncFolder force synchronization of folder files
+func (s *APIService) syncFolder(c *gin.Context) {
id := c.Param("id")
- if id == "" {
- common.APIError(c, "Invalid id")
+
+ s.log.Debugln("Sync folder id: ", id)
+
+ err := s.mfolders.ForceSync(id)
+ if err != nil {
+ common.APIError(c, err.Error())
return
}
- confMut.Lock()
- defer confMut.Unlock()
+ c.JSON(http.StatusOK, "")
+}
+
+// delFolder deletes folder from server config
+func (s *APIService) delFolder(c *gin.Context) {
+ id := c.Param("id")
s.log.Debugln("Delete folder id ", id)
- var delEntry xdsconfig.FolderConfig
- var err error
- if delEntry, err = s.mfolder.DeleteFolder(id); err != nil {
+ delEntry, err := s.mfolders.Delete(id)
+ if err != nil {
common.APIError(c, err.Error())
return
}
c.JSON(http.StatusOK, delEntry)
-
}
diff --git a/lib/apiv1/make.go b/lib/apiv1/make.go
index 5cd98c6..cf76476 100644
--- a/lib/apiv1/make.go
+++ b/lib/apiv1/make.go
@@ -76,11 +76,13 @@ func (s *APIService) buildMake(c *gin.Context) {
return
}
- prj := s.mfolder.GetFolderFromID(id)
- if prj == nil {
+ 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 +94,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 +114,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 +125,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 +140,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 +149,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 +161,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,7 +171,7 @@ func (s *APIService) buildMake(c *gin.Context) {
}
}
- cmdID := makeCommandID
+ cmdID := strconv.Itoa(makeCommandID)
makeCommandID++
cmd := []string{}
@@ -179,7 +181,7 @@ 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...)
}
diff --git a/lib/crosssdk/sdks.go b/lib/crosssdk/sdks.go
index 35a9998..0da0d1b 100644
--- a/lib/crosssdk/sdks.go
+++ b/lib/crosssdk/sdks.go
@@ -36,6 +36,9 @@ func Init(cfg *xdsconfig.Config, log *logrus.Logger) (*SDKs, error) {
defer s.mutex.Unlock()
for _, d := range dirs {
+ if !common.IsDir(d) {
+ continue
+ }
sdk, err := NewCrossSDK(d)
if err != nil {
log.Debugf("Error while processing SDK dir=%s, err=%s", d, err.Error())
diff --git a/lib/folder/folder-interface.go b/lib/folder/folder-interface.go
new file mode 100644
index 0000000..c04cbd7
--- /dev/null
+++ b/lib/folder/folder-interface.go
@@ -0,0 +1,68 @@
+package folder
+
+// FolderType definition
+type FolderType int
+
+const (
+ TypePathMap = 1
+ TypeCloudSync = 2
+ TypeCifsSmb = 3
+)
+
+// Folder Status definition
+const (
+ StatusErrorConfig = "ErrorConfig"
+ StatusDisable = "Disable"
+ StatusEnable = "Enable"
+ StatusPause = "Pause"
+ StatusSyncing = "Syncing"
+)
+
+type EventCBData map[string]interface{}
+type EventCB func(cfg *FolderConfig, data *EventCBData)
+
+// IFOLDER Folder interface
+type IFOLDER interface {
+ NewUID(suffix string) string // Get a new folder UUID
+ Add(cfg FolderConfig) (*FolderConfig, error) // Add a new folder
+ GetConfig() FolderConfig // Get folder public configuration
+ GetFullPath(dir string) string // Get folder full path
+ Remove() error // Remove a folder
+ RegisterEventChange(cb *EventCB, data *EventCBData) error // Request events registration (sent through WS)
+ UnRegisterEventChange() error // Un-register events
+ Sync() error // Force folder files synchronization
+ IsInSync() (bool, error) // Check if folder files are in-sync
+}
+
+// FolderConfig is the config for one folder
+type FolderConfig struct {
+ ID string `json:"id"`
+ Label string `json:"label"`
+ ClientPath string `json:"path"`
+ Type FolderType `json:"type"`
+ Status string `json:"status"`
+ IsInSync bool `json:"isInSync"`
+ DefaultSdk string `json:"defaultSdk"`
+
+ // Not exported fields from REST API point of view
+ RootPath string `json:"-"`
+
+ // FIXME: better to define an equivalent to union data and then implement
+ // UnmarshalJSON/MarshalJSON to decode/encode according to Type value
+ // Data interface{} `json:"data"`
+
+ // Specific data depending on which Type is used
+ DataPathMap PathMapConfig `json:"dataPathMap,omitempty"`
+ DataCloudSync CloudSyncConfig `json:"dataCloudSync,omitempty"`
+}
+
+// PathMapConfig Path mapping specific data
+type PathMapConfig struct {
+ ServerPath string `json:"serverPath"`
+}
+
+// CloudSyncConfig CloudSync (AKA Syncthing) specific data
+type CloudSyncConfig struct {
+ SyncThingID string `json:"syncThingID"`
+ BuilderSThgID string `json:"builderSThgID"`
+}
diff --git a/lib/folder/folder-pathmap.go b/lib/folder/folder-pathmap.go
new file mode 100644
index 0000000..f73f271
--- /dev/null
+++ b/lib/folder/folder-pathmap.go
@@ -0,0 +1,115 @@
+package folder
+
+import (
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+
+ common "github.com/iotbzh/xds-common/golib"
+ "github.com/iotbzh/xds-server/lib/xdsconfig"
+ uuid "github.com/satori/go.uuid"
+)
+
+// IFOLDER interface implementation for native/path mapping folders
+
+// PathMap .
+type PathMap struct {
+ globalConfig *xdsconfig.Config
+ config FolderConfig
+}
+
+// NewFolderPathMap Create a new instance of PathMap
+func NewFolderPathMap(gc *xdsconfig.Config) *PathMap {
+ f := PathMap{
+ globalConfig: gc,
+ }
+ return &f
+}
+
+// NewUID Get a UUID
+func (f *PathMap) NewUID(suffix string) string {
+ return uuid.NewV1().String() + "_" + suffix
+}
+
+// Add a new folder
+func (f *PathMap) Add(cfg FolderConfig) (*FolderConfig, error) {
+ if cfg.DataPathMap.ServerPath == "" {
+ return nil, fmt.Errorf("ServerPath must be set")
+ }
+
+ // Use shareRootDir if ServerPath is a relative path
+ dir := cfg.DataPathMap.ServerPath
+ if !filepath.IsAbs(dir) {
+ dir = filepath.Join(f.globalConfig.FileConf.ShareRootDir, dir)
+ }
+
+ // Sanity check
+ if !common.Exists(dir) {
+ // try to create if not existing
+ if err := os.MkdirAll(dir, 0755); err != nil {
+ return nil, fmt.Errorf("Cannot create ServerPath directory: %s", dir)
+ }
+ }
+ if !common.Exists(dir) {
+ return nil, fmt.Errorf("ServerPath directory is not accessible: %s", dir)
+ }
+ file, err := ioutil.TempFile(dir, "xds_pathmap_check")
+ if err != nil {
+ return nil, fmt.Errorf("ServerPath sanity check error: %s", err.Error())
+ }
+ defer os.Remove(file.Name())
+
+ msg := "sanity check PathMap Add folder"
+ n, err := file.Write([]byte(msg))
+ if err != nil || n != len(msg) {
+ return nil, fmt.Errorf("ServerPath sanity check error: %s", err.Error())
+ }
+
+ f.config = cfg
+ f.config.RootPath = dir
+ f.config.DataPathMap.ServerPath = dir
+ f.config.IsInSync = true
+ f.config.Status = StatusEnable
+
+ return &f.config, nil
+}
+
+// GetConfig Get public part of folder config
+func (f *PathMap) GetConfig() FolderConfig {
+ return f.config
+}
+
+// GetFullPath returns the full path
+func (f *PathMap) GetFullPath(dir string) string {
+ if &dir == nil {
+ return f.config.DataPathMap.ServerPath
+ }
+ return filepath.Join(f.config.DataPathMap.ServerPath, dir)
+}
+
+// Remove a folder
+func (f *PathMap) Remove() error {
+ // nothing to do
+ return nil
+}
+
+// RegisterEventChange requests registration for folder change event
+func (f *PathMap) RegisterEventChange(cb *EventCB, data *EventCBData) error {
+ return nil
+}
+
+// UnRegisterEventChange remove registered callback
+func (f *PathMap) UnRegisterEventChange() error {
+ return nil
+}
+
+// Sync Force folder files synchronization
+func (f *PathMap) Sync() error {
+ return nil
+}
+
+// IsInSync Check if folder files are in-sync
+func (f *PathMap) IsInSync() (bool, error) {
+ return true, nil
+}
diff --git a/lib/model/folder.go b/lib/model/folder.go
deleted file mode 100644
index 56a46b1..0000000
--- a/lib/model/folder.go
+++ /dev/null
@@ -1,110 +0,0 @@
-package model
-
-import (
- "fmt"
-
- common "github.com/iotbzh/xds-common/golib"
- "github.com/iotbzh/xds-server/lib/syncthing"
- "github.com/iotbzh/xds-server/lib/xdsconfig"
-)
-
-// Folder Represent a an XDS folder
-type Folder struct {
- Conf *xdsconfig.Config
- SThg *st.SyncThing
-}
-
-// NewFolder Create a new instance of Model Folder
-func NewFolder(cfg *xdsconfig.Config, st *st.SyncThing) *Folder {
- return &Folder{
- Conf: cfg,
- SThg: st,
- }
-}
-
-// GetFolderFromID retrieves the Folder config from id
-func (c *Folder) GetFolderFromID(id string) *xdsconfig.FolderConfig {
- if idx := c.Conf.Folders.GetIdx(id); idx != -1 {
- return &c.Conf.Folders[idx]
- }
- return nil
-}
-
-// UpdateAll updates all the current configuration
-func (c *Folder) UpdateAll(newCfg xdsconfig.Config) error {
- return fmt.Errorf("Not Supported")
- /*
- if err := VerifyConfig(newCfg); err != nil {
- return err
- }
-
- // TODO: c.Builder = c.Builder.Update(newCfg.Builder)
- c.Folders = c.Folders.Update(newCfg.Folders)
-
- // FIXME To be tested & improved error handling
- for _, f := range c.Folders {
- if err := c.SThg.FolderChange(st.FolderChangeArg{
- ID: f.ID,
- Label: f.Label,
- RelativePath: f.RelativePath,
- SyncThingID: f.SyncThingID,
- ShareRootDir: c.FileConf.ShareRootDir,
- }); err != nil {
- return err
- }
- }
-
- return nil
- */
-}
-
-// UpdateFolder updates a specific folder into the current configuration
-func (c *Folder) UpdateFolder(newFolder xdsconfig.FolderConfig) (xdsconfig.FolderConfig, error) {
- // rootPath should not be empty
- if newFolder.RootPath == "" {
- newFolder.RootPath = c.Conf.FileConf.ShareRootDir
- }
-
- // Sanity check of folder settings
- if err := newFolder.Verify(); err != nil {
- return xdsconfig.FolderConfig{}, err
- }
-
- // Normalize path (needed for Windows path including bashlashes)
- newFolder.RelativePath = common.PathNormalize(newFolder.RelativePath)
-
- // Update config folder
- c.Conf.Folders = c.Conf.Folders.Update(xdsconfig.FoldersConfig{newFolder})
-
- // Update Syncthing folder
- err := c.SThg.FolderChange(newFolder)
-
- newFolder.BuilderSThgID = c.Conf.Builder.SyncThingID // FIXME - should be removed after local ST config rework
- newFolder.Status = xdsconfig.FolderStatusEnable
-
- return newFolder, err
-}
-
-// DeleteFolder deletes a specific folder
-func (c *Folder) DeleteFolder(id string) (xdsconfig.FolderConfig, error) {
- var fld xdsconfig.FolderConfig
- var err error
-
- if err = c.SThg.FolderDelete(id); err != nil {
- return fld, err
- }
-
- c.Conf.Folders, fld, err = c.Conf.Folders.Delete(id)
-
- return fld, err
-}
-
-// ForceSync Force the synchronization of a folder
-func (c *Folder) ForceSync(id string) error {
- return c.SThg.FolderScan(id, "")
-}
-
-// IsFolderInSync Returns true when folder is in sync
-func (c *Folder) IsFolderInSync(id string) (bool, error) {
- return c.SThg.IsFolderInSync(id)
-}
diff --git a/lib/model/folders.go b/lib/model/folders.go
new file mode 100644
index 0000000..ed0078e
--- /dev/null
+++ b/lib/model/folders.go
@@ -0,0 +1,388 @@
+package model
+
+import (
+ "encoding/xml"
+ "fmt"
+ "log"
+ "os"
+ "path/filepath"
+ "strings"
+ "time"
+
+ "github.com/Sirupsen/logrus"
+ common "github.com/iotbzh/xds-common/golib"
+ "github.com/iotbzh/xds-server/lib/folder"
+ "github.com/iotbzh/xds-server/lib/syncthing"
+ "github.com/iotbzh/xds-server/lib/xdsconfig"
+ "github.com/syncthing/syncthing/lib/sync"
+)
+
+// Folders Represent a an XDS folders
+type Folders struct {
+ fileOnDisk string
+ Conf *xdsconfig.Config
+ Log *logrus.Logger
+ SThg *st.SyncThing
+ folders map[string]*folder.IFOLDER
+ registerCB []RegisteredCB
+}
+
+type RegisteredCB struct {
+ cb *folder.EventCB
+ data *folder.EventCBData
+}
+
+// Mutex to make add/delete atomic
+var fcMutex = sync.NewMutex()
+var ffMutex = sync.NewMutex()
+
+// FoldersNew Create a new instance of Model Folders
+func FoldersNew(cfg *xdsconfig.Config, st *st.SyncThing) *Folders {
+ file, _ := xdsconfig.FoldersConfigFilenameGet()
+ return &Folders{
+ fileOnDisk: file,
+ Conf: cfg,
+ Log: cfg.Log,
+ SThg: st,
+ folders: make(map[string]*folder.IFOLDER),
+ registerCB: []RegisteredCB{},
+ }
+}
+
+// LoadConfig Load folders configuration from disk
+func (f *Folders) LoadConfig() error {
+ var flds []folder.FolderConfig
+ var stFlds []folder.FolderConfig
+
+ // load from disk
+ if f.Conf.Options.NoFolderConfig {
+ f.Log.Infof("Don't read folder config file (-no-folderconfig option is set)")
+ } else if f.fileOnDisk != "" {
+ f.Log.Infof("Use folder config file: %s", f.fileOnDisk)
+ err := foldersConfigRead(f.fileOnDisk, &flds)
+ if err != nil {
+ if strings.HasPrefix(err.Error(), "No folder config") {
+ f.Log.Warnf(err.Error())
+ } else {
+ return err
+ }
+ }
+ } else {
+ f.Log.Warnf("Folders config filename not set")
+ }
+
+ // Retrieve initial Syncthing config (just append don't overwrite existing ones)
+ if f.SThg != nil {
+ f.Log.Infof("Retrieve syncthing folder config")
+ if err := f.SThg.FolderLoadFromStConfig(&stFlds); err != nil {
+ // Don't exit on such error, just log it
+ f.Log.Errorf(err.Error())
+ }
+ }
+
+ // Merge syncthing folders into XDS folders
+ for _, stf := range stFlds {
+ found := false
+ for i, xf := range flds {
+ if xf.ID == stf.ID {
+ found = true
+ // sanity check
+ if xf.Type != folder.TypeCloudSync {
+ flds[i].Status = folder.StatusErrorConfig
+ }
+ break
+ }
+ }
+ // add it
+ if !found {
+ flds = append(flds, stf)
+ }
+ }
+
+ // Detect ghost project
+ // (IOW existing in xds file config and not in syncthing database)
+ for i, xf := range flds {
+ // only for syncthing project
+ if xf.Type != folder.TypeCloudSync {
+ continue
+ }
+ found := false
+ for _, stf := range stFlds {
+ if stf.ID == xf.ID {
+ found = true
+ break
+ }
+ }
+ if !found {
+ flds[i].Status = folder.StatusErrorConfig
+ }
+ }
+
+ // Update folders
+ f.Log.Infof("Loading initial folders config: %d folders found", len(flds))
+ for _, fc := range flds {
+ if _, err := f.createUpdate(fc, false, true); err != nil {
+ return err
+ }
+ }
+
+ // Save config on disk
+ err := f.SaveConfig()
+
+ return err
+}
+
+// SaveConfig Save folders configuration to disk
+func (f *Folders) SaveConfig() error {
+ if f.fileOnDisk == "" {
+ return fmt.Errorf("Folders config filename not set")
+ }
+
+ // FIXME: buffered save or avoid to write on disk each time
+ return foldersConfigWrite(f.fileOnDisk, f.getConfigArrUnsafe())
+}
+
+// Get returns the folder config or nil if not existing
+func (f *Folders) Get(id string) *folder.IFOLDER {
+ if id == "" {
+ return nil
+ }
+ fc, exist := f.folders[id]
+ if !exist {
+ return nil
+ }
+ return fc
+}
+
+// GetConfigArr returns the config of all folders as an array
+func (f *Folders) GetConfigArr() []folder.FolderConfig {
+ fcMutex.Lock()
+ defer fcMutex.Unlock()
+
+ return f.getConfigArrUnsafe()
+}
+
+// getConfigArrUnsafe Same as GetConfigArr without mutex protection
+func (f *Folders) getConfigArrUnsafe() []folder.FolderConfig {
+ var conf []folder.FolderConfig
+
+ for _, v := range f.folders {
+ conf = append(conf, (*v).GetConfig())
+ }
+ return conf
+}
+
+// Add adds a new folder
+func (f *Folders) Add(newF folder.FolderConfig) (*folder.FolderConfig, error) {
+ return f.createUpdate(newF, true, false)
+}
+
+// CreateUpdate creates or update a folder
+func (f *Folders) createUpdate(newF folder.FolderConfig, create bool, initial bool) (*folder.FolderConfig, error) {
+
+ fcMutex.Lock()
+ defer fcMutex.Unlock()
+
+ // Sanity check
+ if _, exist := f.folders[newF.ID]; create && exist {
+ return nil, fmt.Errorf("ID already exists")
+ }
+ if newF.ClientPath == "" {
+ return nil, fmt.Errorf("ClientPath must be set")
+ }
+
+ // Create a new folder object
+ var fld folder.IFOLDER
+ switch newF.Type {
+ // SYNCTHING
+ case folder.TypeCloudSync:
+ if f.SThg == nil {
+ return nil, fmt.Errorf("ClownSync type not supported (syncthing not initialized)")
+ }
+ fld = f.SThg.NewFolderST(f.Conf)
+ // PATH MAP
+ case folder.TypePathMap:
+ fld = folder.NewFolderPathMap(f.Conf)
+ default:
+ return nil, fmt.Errorf("Unsupported folder type")
+ }
+
+ // Set default value if needed
+ if newF.Status == "" {
+ newF.Status = folder.StatusDisable
+ }
+ if newF.Label == "" {
+ newF.Label = filepath.Base(newF.ClientPath) + "_" + newF.ID[0:8]
+ }
+
+ // Allocate a new UUID
+ if create {
+ i := len(newF.Label)
+ if i > 20 {
+ i = 20
+ }
+ newF.ID = fld.NewUID(newF.Label[:i])
+ }
+ if !create && newF.ID == "" {
+ return nil, fmt.Errorf("Cannot update folder with null ID")
+ }
+
+ // Normalize path (needed for Windows path including bashlashes)
+ newF.ClientPath = common.PathNormalize(newF.ClientPath)
+
+ // Add new folder
+ newFolder, err := fld.Add(newF)
+ if err != nil {
+ newF.Status = folder.StatusErrorConfig
+ log.Printf("ERROR Adding folder: %v\n", err)
+ return newFolder, err
+ }
+
+ // Add to folders list
+ f.folders[newF.ID] = &fld
+
+ // Save config on disk
+ if !initial {
+ if err := f.SaveConfig(); err != nil {
+ return newFolder, err
+ }
+ }
+
+ // Register event change callback
+ for _, rcb := range f.registerCB {
+ if err := fld.RegisterEventChange(rcb.cb, rcb.data); err != nil {
+ return newFolder, err
+ }
+ }
+
+ // Force sync after creation
+ // (need to defer to be sure that WS events will arrive after HTTP creation reply)
+ go func() {
+ time.Sleep(time.Millisecond * 500)
+ fld.Sync()
+ }()
+
+ return newFolder, nil
+}
+
+// Delete deletes a specific folder
+func (f *Folders) Delete(id string) (folder.FolderConfig, error) {
+ var err error
+
+ fcMutex.Lock()
+ defer fcMutex.Unlock()
+
+ fld := folder.FolderConfig{}
+ fc, exist := f.folders[id]
+ if !exist {
+ return fld, fmt.Errorf("unknown id")
+ }
+
+ fld = (*fc).GetConfig()
+
+ if err = (*fc).Remove(); err != nil {
+ return fld, err
+ }
+
+ delete(f.folders, id)
+
+ // Save config on disk
+ err = f.SaveConfig()
+
+ return fld, err
+}
+
+// RegisterEventChange requests registration for folder event change
+func (f *Folders) RegisterEventChange(id string, cb *folder.EventCB, data *folder.EventCBData) error {
+
+ flds := make(map[string]*folder.IFOLDER)
+ if id != "" {
+ // Register to a specific folder
+ flds[id] = f.Get(id)
+ } else {
+ // Register to all folders
+ flds = f.folders
+ f.registerCB = append(f.registerCB, RegisteredCB{cb: cb, data: data})
+ }
+
+ for _, fld := range flds {
+ err := (*fld).RegisterEventChange(cb, data)
+ if err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+// ForceSync Force the synchronization of a folder
+func (f *Folders) ForceSync(id string) error {
+ fc := f.Get(id)
+ if fc == nil {
+ return fmt.Errorf("Unknown id")
+ }
+ return (*fc).Sync()
+}
+
+// IsFolderInSync Returns true when folder is in sync
+func (f *Folders) IsFolderInSync(id string) (bool, error) {
+ fc := f.Get(id)
+ if fc == nil {
+ return false, fmt.Errorf("Unknown id")
+ }
+ return (*fc).IsInSync()
+}
+
+//*** Private functions ***
+
+// Use XML format and not json to be able to save/load all fields including
+// ones that are masked in json (IOW defined with `json:"-"`)
+type xmlFolders struct {
+ XMLName xml.Name `xml:"folders"`
+ Version string `xml:"version,attr"`
+ Folders []folder.FolderConfig `xml:"folders"`
+}
+
+// foldersConfigRead reads folders config from disk
+func foldersConfigRead(file string, folders *[]folder.FolderConfig) error {
+ if !common.Exists(file) {
+ return fmt.Errorf("No folder config file found (%s)", file)
+ }
+
+ ffMutex.Lock()
+ defer ffMutex.Unlock()
+
+ fd, err := os.Open(file)
+ defer fd.Close()
+ if err != nil {
+ return err
+ }
+
+ data := xmlFolders{}
+ err = xml.NewDecoder(fd).Decode(&data)
+ if err == nil {
+ *folders = data.Folders
+ }
+ return err
+}
+
+// foldersConfigWrite writes folders config on disk
+func foldersConfigWrite(file string, folders []folder.FolderConfig) error {
+ ffMutex.Lock()
+ defer ffMutex.Unlock()
+
+ fd, err := os.OpenFile(file, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
+ defer fd.Close()
+ if err != nil {
+ return err
+ }
+
+ data := &xmlFolders{
+ Version: "1",
+ Folders: folders,
+ }
+
+ enc := xml.NewEncoder(fd)
+ enc.Indent("", " ")
+ return enc.Encode(data)
+}
diff --git a/lib/syncthing/folder-st.go b/lib/syncthing/folder-st.go
new file mode 100644
index 0000000..da27062
--- /dev/null
+++ b/lib/syncthing/folder-st.go
@@ -0,0 +1,170 @@
+package st
+
+import (
+ "fmt"
+ "path/filepath"
+
+ "github.com/iotbzh/xds-server/lib/folder"
+ "github.com/iotbzh/xds-server/lib/xdsconfig"
+ uuid "github.com/satori/go.uuid"
+ "github.com/syncthing/syncthing/lib/config"
+)
+
+// IFOLDER interface implementation for syncthing
+
+// STFolder .
+type STFolder struct {
+ globalConfig *xdsconfig.Config
+ st *SyncThing
+ fConfig folder.FolderConfig
+ stfConfig config.FolderConfiguration
+ eventIDs []int
+ eventChangeCB *folder.EventCB
+ eventChangeCBData *folder.EventCBData
+}
+
+// NewFolderST Create a new instance of STFolder
+func (s *SyncThing) NewFolderST(gc *xdsconfig.Config) *STFolder {
+ return &STFolder{
+ globalConfig: gc,
+ st: s,
+ }
+}
+
+// NewUID Get a UUID
+func (f *STFolder) NewUID(suffix string) string {
+ i := len(f.st.MyID)
+ if i > 15 {
+ i = 15
+ }
+ return uuid.NewV1().String()[:14] + f.st.MyID[:i] + "_" + suffix
+}
+
+// Add a new folder
+func (f *STFolder) Add(cfg folder.FolderConfig) (*folder.FolderConfig, error) {
+
+ // Sanity check
+ if cfg.DataCloudSync.SyncThingID == "" {
+ return nil, fmt.Errorf("device id not set (SyncThingID field)")
+ }
+
+ // rootPath should not be empty
+ if cfg.RootPath == "" {
+ cfg.RootPath = f.globalConfig.FileConf.ShareRootDir
+ }
+
+ f.fConfig = cfg
+
+ f.fConfig.DataCloudSync.BuilderSThgID = f.st.MyID // FIXME - should be removed after local ST config rework
+
+ // Update Syncthing folder
+ // (expect if status is ErrorConfig)
+ // TODO: add cache to avoid multiple requests on startup
+ if f.fConfig.Status != folder.StatusErrorConfig {
+ id, err := f.st.FolderChange(f.fConfig)
+ if err != nil {
+ return nil, err
+ }
+
+ f.stfConfig, err = f.st.FolderConfigGet(id)
+ if err != nil {
+ f.fConfig.Status = folder.StatusErrorConfig
+ return nil, err
+ }
+
+ // Register to events to update folder status
+ for _, evName := range []string{EventStateChanged, EventFolderPaused} {
+ evID, err := f.st.Events.Register(evName, f.cbEventState, id, nil)
+ if err != nil {
+ return nil, err
+ }
+ f.eventIDs = append(f.eventIDs, evID)
+ }
+
+ f.fConfig.IsInSync = false // will be updated later by events
+ f.fConfig.Status = folder.StatusEnable
+ }
+
+ return &f.fConfig, nil
+}
+
+// GetConfig Get public part of folder config
+func (f *STFolder) GetConfig() folder.FolderConfig {
+ return f.fConfig
+}
+
+// GetFullPath returns the full path
+func (f *STFolder) GetFullPath(dir string) string {
+ if &dir == nil {
+ dir = ""
+ }
+ if filepath.IsAbs(dir) {
+ return filepath.Join(f.fConfig.RootPath, dir)
+ }
+ return filepath.Join(f.fConfig.RootPath, f.fConfig.ClientPath, dir)
+}
+
+// Remove a folder
+func (f *STFolder) Remove() error {
+ return f.st.FolderDelete(f.stfConfig.ID)
+}
+
+// RegisterEventChange requests registration for folder event change
+func (f *STFolder) RegisterEventChange(cb *folder.EventCB, data *folder.EventCBData) error {
+ f.eventChangeCB = cb
+ f.eventChangeCBData = data
+ return nil
+}
+
+// UnRegisterEventChange remove registered callback
+func (f *STFolder) UnRegisterEventChange() error {
+ f.eventChangeCB = nil
+ f.eventChangeCBData = nil
+ return nil
+}
+
+// Sync Force folder files synchronization
+func (f *STFolder) Sync() error {
+ return f.st.FolderScan(f.stfConfig.ID, "")
+}
+
+// IsInSync Check if folder files are in-sync
+func (f *STFolder) IsInSync() (bool, error) {
+ sts, err := f.st.IsFolderInSync(f.stfConfig.ID)
+ if err != nil {
+ return false, err
+ }
+ f.fConfig.IsInSync = sts
+ return sts, nil
+}
+
+// callback use to update IsInSync status
+func (f *STFolder) cbEventState(ev Event, data *EventsCBData) {
+ prevSync := f.fConfig.IsInSync
+ prevStatus := f.fConfig.Status
+
+ switch ev.Type {
+
+ case EventStateChanged:
+ to := ev.Data["to"]
+ switch to {
+ case "scanning", "syncing":
+ f.fConfig.Status = folder.StatusSyncing
+ case "idle":
+ f.fConfig.Status = folder.StatusEnable
+ }
+ f.fConfig.IsInSync = (to == "idle")
+
+ case EventFolderPaused:
+ if f.fConfig.Status == folder.StatusEnable {
+ f.fConfig.Status = folder.StatusPause
+ }
+ f.fConfig.IsInSync = false
+ }
+
+ if f.eventChangeCB != nil &&
+ (prevSync != f.fConfig.IsInSync || prevStatus != f.fConfig.Status) {
+ cpConf := f.fConfig
+ (*f.eventChangeCB)(&cpConf, f.eventChangeCBData)
+ }
+}
diff --git a/lib/syncthing/st.go b/lib/syncthing/st.go
index 3380cda..5086994 100644
--- a/lib/syncthing/st.go
+++ b/lib/syncthing/st.go
@@ -27,11 +27,13 @@ import (
// SyncThing .
type SyncThing struct {
- BaseURL string
- APIKey string
- Home string
- STCmd *exec.Cmd
- STICmd *exec.Cmd
+ BaseURL string
+ APIKey string
+ Home string
+ STCmd *exec.Cmd
+ STICmd *exec.Cmd
+ MyID string
+ Connected bool
// Private fields
binDir string
@@ -41,6 +43,7 @@ type SyncThing struct {
conf *xdsconfig.Config
client *common.HTTPClient
log *logrus.Logger
+ Events *Events
}
// ExitChan Channel used for process exit
@@ -125,6 +128,9 @@ func NewSyncThing(conf *xdsconfig.Config, log *logrus.Logger) *SyncThing {
conf: conf,
}
+ // Create Events monitoring
+ s.Events = s.NewEventListener()
+
return &s
}
@@ -211,13 +217,13 @@ func (s *SyncThing) Start() (*exec.Cmd, error) {
env := []string{
"STNODEFAULTFOLDER=1",
"STNOUPGRADE=1",
- "STNORESTART=1",
+ "STNORESTART=1", // FIXME SEB remove ?
}
s.STCmd, err = s.startProc("syncthing", args, env, &s.exitSTChan)
// Use autogenerated apikey if not set by config.json
- if s.APIKey == "" {
+ if err == nil && s.APIKey == "" {
if fd, err := os.Open(filepath.Join(s.Home, "config.xml")); err == nil {
defer fd.Close()
if b, err := ioutil.ReadAll(fd); err == nil {
@@ -296,6 +302,7 @@ func (s *SyncThing) StopInotify() {
// Connect Establish HTTP connection with Syncthing
func (s *SyncThing) Connect() error {
var err error
+ s.Connected = false
s.client, err = common.HTTPNewClient(s.BaseURL,
common.HTTPClientConfig{
URLPrefix: "/rest",
@@ -312,9 +319,22 @@ func (s *SyncThing) Connect() error {
return fmt.Errorf("ERROR: cannot connect to Syncthing (null client)")
}
- s.client.SetLogger(s.log)
+ // Redirect HTTP log into a file
+ s.client.SetLogLevel(s.conf.Log.Level.String())
+ s.client.LoggerPrefix = "SYNCTHING: "
+ s.client.LoggerOut = s.conf.LogVerboseOut
+
+ s.MyID, err = s.IDGet()
+ if err != nil {
+ return fmt.Errorf("ERROR: cannot retrieve ID")
+ }
+
+ s.Connected = true
+
+ // Start events monitoring
+ err = s.Events.Start()
- return nil
+ return err
}
// IDGet returns the Syncthing ID of Syncthing instance running locally
@@ -360,44 +380,3 @@ func (s *SyncThing) IsConfigInSync() (bool, error) {
}
return d.ConfigInSync, nil
}
-
-// FolderStatus Returns all information about the current
-func (s *SyncThing) FolderStatus(folderID string) (*FolderStatus, error) {
- var data []byte
- var res FolderStatus
- if folderID == "" {
- return nil, fmt.Errorf("folderID not set")
- }
- if err := s.client.HTTPGet("db/status?folder="+folderID, &data); err != nil {
- return nil, err
- }
- if err := json.Unmarshal(data, &res); err != nil {
- return nil, err
- }
- return &res, nil
-}
-
-// IsFolderInSync Returns true when folder is in sync
-func (s *SyncThing) IsFolderInSync(folderID string) (bool, error) {
- // FIXME better to detected FolderCompletion event (/rest/events)
- // See https://docs.syncthing.net/dev/events.html
- sts, err := s.FolderStatus(folderID)
- if err != nil {
- return false, err
- }
- return sts.NeedBytes == 0, nil
-}
-
-// FolderScan Request immediate folder scan.
-// Scan all folders if folderID param is empty
-func (s *SyncThing) FolderScan(folderID string, subpath string) error {
- url := "db/scan"
- if folderID != "" {
- url += "?folder=" + folderID
-
- if subpath != "" {
- url += "&sub=" + subpath
- }
- }
- return s.client.HTTPPost(url, "")
-}
diff --git a/lib/syncthing/stEvent.go b/lib/syncthing/stEvent.go
new file mode 100644
index 0000000..9ca8b78
--- /dev/null
+++ b/lib/syncthing/stEvent.go
@@ -0,0 +1,265 @@
+package st
+
+import (
+ "encoding/json"
+ "fmt"
+ "os"
+ "strconv"
+ "strings"
+ "time"
+
+ "github.com/Sirupsen/logrus"
+)
+
+// Events .
+type Events struct {
+ MonitorTime time.Duration
+ Debug bool
+
+ stop chan bool
+ st *SyncThing
+ log *logrus.Logger
+ cbArr map[string][]cbMap
+}
+
+type Event struct {
+ Type string `json:"type"`
+ Time time.Time `json:"time"`
+ Data map[string]string `json:"data"`
+}
+
+type EventsCBData map[string]interface{}
+type EventsCB func(ev Event, cbData *EventsCBData)
+
+const (
+ EventFolderCompletion string = "FolderCompletion"
+ EventFolderSummary string = "FolderSummary"
+ EventFolderPaused string = "FolderPaused"
+ EventFolderResumed string = "FolderResumed"
+ EventFolderErrors string = "FolderErrors"
+ EventStateChanged string = "StateChanged"
+)
+
+var EventsAll string = EventFolderCompletion + "|" +
+ EventFolderSummary + "|" +
+ EventFolderPaused + "|" +
+ EventFolderResumed + "|" +
+ EventFolderErrors + "|" +
+ EventStateChanged
+
+type STEvent struct {
+ // Per-subscription sequential event ID. Named "id" for backwards compatibility with the REST API
+ SubscriptionID int `json:"id"`
+ // Global ID of the event across all subscriptions
+ GlobalID int `json:"globalID"`
+ Time time.Time `json:"time"`
+ Type string `json:"type"`
+ Data map[string]interface{} `json:"data"`
+}
+
+type cbMap struct {
+ id int
+ cb EventsCB
+ filterID string
+ data *EventsCBData
+}
+
+// NewEventListener Create a new instance of Event listener
+func (s *SyncThing) NewEventListener() *Events {
+ _, dbg := os.LookupEnv("XDS_DEBUG_STEVENTS") // set to add more debug log
+ return &Events{
+ MonitorTime: 100, // in Milliseconds
+ Debug: dbg,
+ stop: make(chan bool, 1),
+ st: s,
+ log: s.log,
+ cbArr: make(map[string][]cbMap),
+ }
+}
+
+// Start starts event monitoring loop
+func (e *Events) Start() error {
+ go e.monitorLoop()
+ return nil
+}
+
+// Stop stops event monitoring loop
+func (e *Events) Stop() {
+ e.stop <- true
+}
+
+// Register Add a listener on an event
+func (e *Events) Register(evName string, cb EventsCB, filterID string, data *EventsCBData) (int, error) {
+ if evName == "" || !strings.Contains(EventsAll, evName) {
+ return -1, fmt.Errorf("Unknown event name")
+ }
+ if data == nil {
+ data = &EventsCBData{}
+ }
+
+ cbList := []cbMap{}
+ if _, ok := e.cbArr[evName]; ok {
+ cbList = e.cbArr[evName]
+ }
+
+ id := len(cbList)
+ (*data)["id"] = strconv.Itoa(id)
+
+ e.cbArr[evName] = append(cbList, cbMap{id: id, cb: cb, filterID: filterID, data: data})
+
+ return id, nil
+}
+
+// UnRegister Remove a listener event
+func (e *Events) UnRegister(evName string, id int) error {
+ cbKey, ok := e.cbArr[evName]
+ if !ok {
+ return fmt.Errorf("No event registered to such name")
+ }
+
+ // FIXME - NOT TESTED
+ if id >= len(cbKey) {
+ return fmt.Errorf("Invalid id")
+ } else if id == len(cbKey) {
+ e.cbArr[evName] = cbKey[:id-1]
+ } else {
+ e.cbArr[evName] = cbKey[id : id+1]
+ }
+
+ return nil
+}
+
+// GetEvents returns the Syncthing events
+func (e *Events) getEvents(since int) ([]STEvent, error) {
+ var data []byte
+ ev := []STEvent{}
+ url := "events"
+ if since != -1 {
+ url += "?since=" + strconv.Itoa(since)
+ }
+ if err := e.st.client.HTTPGet(url, &data); err != nil {
+ return ev, err
+ }
+ err := json.Unmarshal(data, &ev)
+ return ev, err
+}
+
+// Loop to monitor Syncthing events
+func (e *Events) monitorLoop() {
+ e.log.Infof("Event monitoring running...")
+ since := 0
+ cntErrConn := 0
+ cntErrRetry := 1
+ for {
+ select {
+ case <-e.stop:
+ e.log.Infof("Event monitoring exited")
+ return
+
+ case <-time.After(e.MonitorTime * time.Millisecond):
+
+ if !e.st.Connected {
+ cntErrConn++
+ time.Sleep(time.Second)
+ if cntErrConn > cntErrRetry {
+ e.log.Error("ST Event monitor: ST connection down")
+ cntErrConn = 0
+ cntErrRetry *= 2
+ if _, err := e.getEvents(since); err == nil {
+ e.st.Connected = true
+ cntErrRetry = 1
+ // XXX - should we reset since value ?
+ goto readEvent
+ }
+ }
+ continue
+ }
+
+ readEvent:
+ stEvArr, err := e.getEvents(since)
+ if err != nil {
+ e.log.Errorf("Syncthing Get Events: %v", err)
+ e.st.Connected = false
+ continue
+ }
+
+ // Process events
+ for _, stEv := range stEvArr {
+ since = stEv.SubscriptionID
+ if e.Debug {
+ e.log.Warnf("ST EVENT: %d %s\n %v", stEv.GlobalID, stEv.Type, stEv)
+ }
+
+ cbKey, ok := e.cbArr[stEv.Type]
+ if !ok {
+ continue
+ }
+
+ evData := Event{
+ Type: stEv.Type,
+ Time: stEv.Time,
+ }
+
+ // Decode Events
+ // FIXME: re-define data struct for each events
+ // instead of map of string and use JSON marshing/unmarshing
+ fID := ""
+ evData.Data = make(map[string]string)
+ switch stEv.Type {
+
+ case EventFolderCompletion:
+ fID = convString(stEv.Data["folder"])
+ evData.Data["completion"] = convFloat64(stEv.Data["completion"])
+
+ case EventFolderSummary:
+ fID = convString(stEv.Data["folder"])
+ evData.Data["needBytes"] = convInt64(stEv.Data["needBytes"])
+ evData.Data["state"] = convString(stEv.Data["state"])
+
+ case EventFolderPaused, EventFolderResumed:
+ fID = convString(stEv.Data["id"])
+ evData.Data["label"] = convString(stEv.Data["label"])
+
+ case EventFolderErrors:
+ fID = convString(stEv.Data["folder"])
+ // TODO decode array evData.Data["errors"] = convString(stEv.Data["errors"])
+
+ case EventStateChanged:
+ fID = convString(stEv.Data["folder"])
+ evData.Data["from"] = convString(stEv.Data["from"])
+ evData.Data["to"] = convString(stEv.Data["to"])
+
+ default:
+ e.log.Warnf("Unsupported event type")
+ }
+
+ if fID != "" {
+ evData.Data["id"] = fID
+ }
+
+ // Call all registered callbacks
+ for _, c := range cbKey {
+ if e.Debug {
+ e.log.Warnf("EVENT CB fID=%s, filterID=%s", fID, c.filterID)
+ }
+ // Call when filterID is not set or when it matches
+ if c.filterID == "" || (fID != "" && fID == c.filterID) {
+ c.cb(evData, c.data)
+ }
+ }
+ }
+ }
+ }
+}
+
+func convString(d interface{}) string {
+ return d.(string)
+}
+
+func convFloat64(d interface{}) string {
+ return strconv.FormatFloat(d.(float64), 'f', -1, 64)
+}
+
+func convInt64(d interface{}) string {
+ return strconv.FormatInt(d.(int64), 10)
+}
diff --git a/lib/syncthing/stfolder.go b/lib/syncthing/stfolder.go
index 661e19d..70ac70a 100644
--- a/lib/syncthing/stfolder.go
+++ b/lib/syncthing/stfolder.go
@@ -1,34 +1,77 @@
package st
import (
+ "encoding/json"
+ "fmt"
"path/filepath"
"strings"
- "github.com/iotbzh/xds-server/lib/xdsconfig"
+ "github.com/iotbzh/xds-server/lib/folder"
"github.com/syncthing/syncthing/lib/config"
"github.com/syncthing/syncthing/lib/protocol"
)
+// FolderLoadFromStConfig Load/Retrieve folder config from syncthing database
+func (s *SyncThing) FolderLoadFromStConfig(f *[]folder.FolderConfig) error {
+
+ defaultSdk := "" // cannot know which was the default sdk
+
+ stCfg, err := s.ConfigGet()
+ if err != nil {
+ return err
+ }
+ if len(stCfg.Devices) < 1 {
+ return fmt.Errorf("Cannot load syncthing config: no device defined")
+ }
+ devID := stCfg.Devices[0].DeviceID.String()
+ if devID == s.MyID {
+ if len(stCfg.Devices) < 2 {
+ return fmt.Errorf("Cannot load syncthing config: no valid device found")
+ }
+ devID = stCfg.Devices[1].DeviceID.String()
+ }
+
+ for _, stFld := range stCfg.Folders {
+ cliPath := strings.TrimPrefix(stFld.RawPath, s.conf.FileConf.ShareRootDir)
+ if cliPath == "" {
+ cliPath = stFld.RawPath
+ }
+ *f = append(*f, folder.FolderConfig{
+ ID: stFld.ID,
+ Label: stFld.Label,
+ ClientPath: strings.TrimRight(cliPath, "/"),
+ Type: folder.TypeCloudSync,
+ Status: folder.StatusDisable,
+ DefaultSdk: defaultSdk,
+ RootPath: s.conf.FileConf.ShareRootDir,
+ DataCloudSync: folder.CloudSyncConfig{SyncThingID: devID},
+ })
+ }
+
+ return nil
+}
+
// FolderChange is called when configuration has changed
-func (s *SyncThing) FolderChange(f xdsconfig.FolderConfig) error {
+func (s *SyncThing) FolderChange(f folder.FolderConfig) (string, error) {
// Get current config
stCfg, err := s.ConfigGet()
if err != nil {
s.log.Errorln(err)
- return err
+ return "", err
}
+ stClientID := f.DataCloudSync.SyncThingID
// Add new Device if needed
var devID protocol.DeviceID
- if err := devID.UnmarshalText([]byte(f.SyncThingID)); err != nil {
- s.log.Errorf("not a valid device id (err %v)\n", err)
- return err
+ if err := devID.UnmarshalText([]byte(stClientID)); err != nil {
+ s.log.Errorf("not a valid device id (err %v)", err)
+ return "", err
}
newDevice := config.DeviceConfiguration{
DeviceID: devID,
- Name: f.SyncThingID,
+ Name: stClientID,
Addresses: []string{"dynamic"},
}
@@ -49,13 +92,13 @@ func (s *SyncThing) FolderChange(f xdsconfig.FolderConfig) error {
label = strings.Split(id, "/")[0]
}
if id = f.ID; id == "" {
- id = f.SyncThingID[0:15] + "_" + label
+ id = stClientID[0:15] + "_" + label
}
folder := config.FolderConfiguration{
ID: id,
Label: label,
- RawPath: filepath.Join(s.conf.FileConf.ShareRootDir, f.RelativePath),
+ RawPath: filepath.Join(s.conf.FileConf.ShareRootDir, f.ClientPath),
}
if s.conf.FileConf.SThgConf.RescanIntervalS > 0 {
@@ -85,7 +128,7 @@ func (s *SyncThing) FolderChange(f xdsconfig.FolderConfig) error {
s.log.Errorln(err)
}
- return nil
+ return id, nil
}
// FolderDelete is called to delete a folder config
@@ -110,3 +153,61 @@ func (s *SyncThing) FolderDelete(id string) error {
return nil
}
+
+// FolderConfigGet Returns the configuration of a specific folder
+func (s *SyncThing) FolderConfigGet(folderID string) (config.FolderConfiguration, error) {
+ fc := config.FolderConfiguration{}
+ if folderID == "" {
+ return fc, fmt.Errorf("folderID not set")
+ }
+ cfg, err := s.ConfigGet()
+ if err != nil {
+ return fc, err
+ }
+ for _, f := range cfg.Folders {
+ if f.ID == folderID {
+ fc = f
+ return fc, nil
+ }
+ }
+ return fc, fmt.Errorf("id not found")
+}
+
+// FolderStatus Returns all information about the current
+func (s *SyncThing) FolderStatus(folderID string) (*FolderStatus, error) {
+ var data []byte
+ var res FolderStatus
+ if folderID == "" {
+ return nil, fmt.Errorf("folderID not set")
+ }
+ if err := s.client.HTTPGet("db/status?folder="+folderID, &data); err != nil {
+ return nil, err
+ }
+ if err := json.Unmarshal(data, &res); err != nil {
+ return nil, err
+ }
+ return &res, nil
+}
+
+// IsFolderInSync Returns true when folder is in sync
+func (s *SyncThing) IsFolderInSync(folderID string) (bool, error) {
+ sts, err := s.FolderStatus(folderID)
+ if err != nil {
+ return false, err
+ }
+ return sts.NeedBytes == 0 && sts.State == "idle", nil
+}
+
+// FolderScan Request immediate folder scan.
+// Scan all folders if folderID param is empty
+func (s *SyncThing) FolderScan(folderID string, subpath string) error {
+ url := "db/scan"
+ if folderID != "" {
+ url += "?folder=" + folderID
+
+ if subpath != "" {
+ url += "&sub=" + subpath
+ }
+ }
+ return s.client.HTTPPost(url, "")
+}
diff --git a/lib/webserver/server.go b/lib/webserver/server.go
index 8fd7e44..8639b66 100644
--- a/lib/webserver/server.go
+++ b/lib/webserver/server.go
@@ -2,6 +2,7 @@ package webserver
import (
"fmt"
+ "log"
"net/http"
"os"
@@ -26,7 +27,7 @@ type Server struct {
webApp *gin.RouterGroup
cfg *xdsconfig.Config
sessions *session.Sessions
- mfolder *model.Folder
+ mfolders *model.Folders
sdks *crosssdk.SDKs
log *logrus.Logger
stop chan struct{} // signals intentional stop
@@ -36,20 +37,21 @@ const indexFilename = "index.html"
const cookieMaxAge = "3600"
// New creates an instance of Server
-func New(cfg *xdsconfig.Config, mfolder *model.Folder, sdks *crosssdk.SDKs, log *logrus.Logger) *Server {
+func New(cfg *xdsconfig.Config, mfolders *model.Folders, sdks *crosssdk.SDKs, logr *logrus.Logger) *Server {
// Setup logging for gin router
- if log.Level == logrus.DebugLevel {
+ if logr.Level == logrus.DebugLevel {
gin.SetMode(gin.DebugMode)
} else {
gin.SetMode(gin.ReleaseMode)
}
- // TODO
- // - try to bind gin DefaultWriter & DefaultErrorWriter to logrus logger
- // - try to fix pb about isTerminal=false when out is in VSC Debug Console
- //gin.DefaultWriter = ??
- //gin.DefaultErrorWriter = ??
+ // Redirect gin logs into another logger (LogVerboseOut may be stderr or a file)
+ gin.DefaultWriter = cfg.LogVerboseOut
+ gin.DefaultErrorWriter = cfg.LogVerboseOut
+ log.SetOutput(cfg.LogVerboseOut)
+
+ // FIXME - fix pb about isTerminal=false when out is in VSC Debug Console
// Creates gin router
r := gin.New()
@@ -61,9 +63,9 @@ func New(cfg *xdsconfig.Config, mfolder *model.Folder, sdks *crosssdk.SDKs, log
webApp: nil,
cfg: cfg,
sessions: nil,
- mfolder: mfolder,
+ mfolders: mfolders,
sdks: sdks,
- log: log,
+ log: logr,
stop: make(chan struct{}),
}
@@ -84,7 +86,7 @@ func (s *Server) Serve() error {
s.sessions = session.NewClientSessions(s.router, s.log, cookieMaxAge)
// Create REST API
- s.api = apiv1.New(s.router, s.sessions, s.cfg, s.mfolder, s.sdks)
+ s.api = apiv1.New(s.router, s.sessions, s.cfg, s.mfolders, s.sdks)
// Websocket routes
s.sIOServer, err = socketio.NewServer(nil)
diff --git a/lib/xdsconfig/config.go b/lib/xdsconfig/config.go
index f2d0710..82ca97f 100644
--- a/lib/xdsconfig/config.go
+++ b/lib/xdsconfig/config.go
@@ -2,7 +2,7 @@ package xdsconfig
import (
"fmt"
-
+ "io"
"os"
"github.com/Sirupsen/logrus"
@@ -16,11 +16,20 @@ type Config struct {
APIVersion string `json:"apiVersion"`
VersionGitTag string `json:"gitTag"`
Builder BuilderConfig `json:"builder"`
- Folders FoldersConfig `json:"folders"`
// Private (un-exported fields in REST GET /config route)
- FileConf FileConfig `json:"-"`
- Log *logrus.Logger `json:"-"`
+ Options Options `json:"-"`
+ FileConf FileConfig `json:"-"`
+ Log *logrus.Logger `json:"-"`
+ LogVerboseOut io.Writer `json:"-"`
+}
+
+// Options set at the command line
+type Options struct {
+ ConfigFile string
+ LogLevel string
+ LogFile string
+ NoFolderConfig bool
}
// Config default values
@@ -41,7 +50,13 @@ func Init(cliCtx *cli.Context, log *logrus.Logger) (*Config, error) {
APIVersion: DefaultAPIVersion,
VersionGitTag: cliCtx.App.Metadata["git-tag"].(string),
Builder: BuilderConfig{},
- Folders: FoldersConfig{},
+
+ Options: Options{
+ ConfigFile: cliCtx.GlobalString("config"),
+ LogLevel: cliCtx.GlobalString("log"),
+ LogFile: cliCtx.GlobalString("logfile"),
+ NoFolderConfig: cliCtx.GlobalBool("no-folderconfig"),
+ },
FileConf: FileConfig{
WebAppDir: "webapp/dist",
ShareRootDir: DefaultShareDir,
@@ -52,7 +67,7 @@ func Init(cliCtx *cli.Context, log *logrus.Logger) (*Config, error) {
}
// config file settings overwrite default config
- err = updateConfigFromFile(&c, cliCtx.GlobalString("config"))
+ err = readGlobalConfig(&c, c.Options.ConfigFile)
if err != nil {
return nil, err
}
diff --git a/lib/xdsconfig/fileconfig.go b/lib/xdsconfig/fileconfig.go
index 90c1aad..2dbf884 100644
--- a/lib/xdsconfig/fileconfig.go
+++ b/lib/xdsconfig/fileconfig.go
@@ -11,6 +11,16 @@ import (
common "github.com/iotbzh/xds-common/golib"
)
+const (
+ // ConfigDir Directory in user HOME directory where xds config will be saved
+ ConfigDir = ".xds"
+ // GlobalConfigFilename Global config filename
+ GlobalConfigFilename = "config.json"
+ // FoldersConfigFilename Folders config filename
+ FoldersConfigFilename = "server-config_folders.xml"
+)
+
+// SyncThingConf definition
type SyncThingConf struct {
BinDir string `json:"binDir"`
Home string `json:"home"`
@@ -19,6 +29,7 @@ type SyncThingConf struct {
RescanIntervalS int `json:"rescanIntervalS"`
}
+// FileConfig is the JSON structure of xds-server config file (config.json)
type FileConfig struct {
WebAppDir string `json:"webAppDir"`
ShareRootDir string `json:"shareRootDir"`
@@ -28,21 +39,21 @@ type FileConfig struct {
LogsDir string `json:"logsDir"`
}
-// getConfigFromFile reads configuration from a config file.
+// readGlobalConfig reads configuration from a config file.
// Order to determine which config file is used:
// 1/ from command line option: "--config myConfig.json"
// 2/ $HOME/.xds/config.json file
// 3/ <current_dir>/config.json file
// 4/ <xds-server executable dir>/config.json file
-
-func updateConfigFromFile(c *Config, confFile string) error {
+func readGlobalConfig(c *Config, confFile string) error {
searchIn := make([]string, 0, 3)
if confFile != "" {
searchIn = append(searchIn, confFile)
}
if usr, err := user.Current(); err == nil {
- searchIn = append(searchIn, path.Join(usr.HomeDir, ".xds", "config.json"))
+ searchIn = append(searchIn, path.Join(usr.HomeDir, ConfigDir,
+ GlobalConfigFilename))
}
cwd, err := os.Getwd()
if err == nil {
@@ -70,7 +81,6 @@ func updateConfigFromFile(c *Config, confFile string) error {
// TODO move on viper package to support comments in JSON and also
// bind with flags (command line options)
// see https://github.com/spf13/viper#working-with-flags
-
fd, _ := os.Open(*cFile)
defer fd.Close()
fCfg := FileConfig{}
@@ -79,14 +89,15 @@ func updateConfigFromFile(c *Config, confFile string) error {
}
// Support environment variables (IOW ${MY_ENV_VAR} syntax) in config.json
- for _, field := range []*string{
+ vars := []*string{
&fCfg.WebAppDir,
&fCfg.ShareRootDir,
&fCfg.SdkRootDir,
- &fCfg.LogsDir,
- &fCfg.SThgConf.Home,
- &fCfg.SThgConf.BinDir} {
-
+ &fCfg.LogsDir}
+ if fCfg.SThgConf != nil {
+ vars = append(vars, &fCfg.SThgConf.Home, &fCfg.SThgConf.BinDir)
+ }
+ for _, field := range vars {
var err error
if *field, err = common.ResolveEnvVar(*field); err != nil {
return err
@@ -123,3 +134,12 @@ func updateConfigFromFile(c *Config, confFile string) error {
c.FileConf = fCfg
return nil
}
+
+// FoldersConfigFilenameGet
+func FoldersConfigFilenameGet() (string, error) {
+ usr, err := user.Current()
+ if err != nil {
+ return "", err
+ }
+ return path.Join(usr.HomeDir, ConfigDir, FoldersConfigFilename), nil
+}
diff --git a/lib/xdsconfig/folderconfig.go b/lib/xdsconfig/folderconfig.go
deleted file mode 100644
index bb2b56f..0000000
--- a/lib/xdsconfig/folderconfig.go
+++ /dev/null
@@ -1,85 +0,0 @@
-package xdsconfig
-
-import (
- "fmt"
- "log"
- "path/filepath"
-)
-
-// FolderType constances
-const (
- FolderTypeDocker = 0
- FolderTypeWindowsSubsystem = 1
- FolderTypeCloudSync = 2
-
- FolderStatusErrorConfig = "ErrorConfig"
- FolderStatusDisable = "Disable"
- FolderStatusEnable = "Enable"
-)
-
-// FolderType is the type of sharing folder
-type FolderType int
-
-// FolderConfig is the config for one folder
-type FolderConfig struct {
- ID string `json:"id" binding:"required"`
- Label string `json:"label"`
- RelativePath string `json:"path"`
- Type FolderType `json:"type"`
- SyncThingID string `json:"syncThingID"`
- BuilderSThgID string `json:"builderSThgID"`
- Status string `json:"status"`
- DefaultSdk string `json:"defaultSdk"`
-
- // Not exported fields
- RootPath string `json:"-"`
-}
-
-// NewFolderConfig creates a new folder object
-func NewFolderConfig(id, label, rootDir, path string, defaultSdk string) FolderConfig {
- return FolderConfig{
- ID: id,
- Label: label,
- RelativePath: path,
- Type: FolderTypeCloudSync,
- SyncThingID: "",
- Status: FolderStatusDisable,
- RootPath: rootDir,
- DefaultSdk: defaultSdk,
- }
-}
-
-// GetFullPath returns the full path
-func (c *FolderConfig) GetFullPath(dir string) string {
- if &dir == nil {
- dir = ""
- }
- if filepath.IsAbs(dir) {
- return filepath.Join(c.RootPath, dir)
- }
- return filepath.Join(c.RootPath, c.RelativePath, dir)
-}
-
-// Verify is called to verify that a configuration is valid
-func (c *FolderConfig) Verify() error {
- var err error
-
- if c.Type != FolderTypeCloudSync {
- err = fmt.Errorf("Unsupported folder type")
- }
-
- if c.SyncThingID == "" {
- err = fmt.Errorf("device id not set (SyncThingID field)")
- }
-
- if c.RootPath == "" {
- err = fmt.Errorf("RootPath must not be empty")
- }
-
- if err != nil {
- c.Status = FolderStatusErrorConfig
- log.Printf("ERROR Verify: %v\n", err)
- }
-
- return err
-}
diff --git a/lib/xdsconfig/foldersconfig.go b/lib/xdsconfig/foldersconfig.go
deleted file mode 100644
index 4ad16df..0000000
--- a/lib/xdsconfig/foldersconfig.go
+++ /dev/null
@@ -1,47 +0,0 @@
-package xdsconfig
-
-import (
- "fmt"
-)
-
-// FoldersConfig contains all the folder configurations
-type FoldersConfig []FolderConfig
-
-// GetIdx returns the index of the folder matching id in FoldersConfig array
-func (c FoldersConfig) GetIdx(id string) int {
- for i := range c {
- if id == c[i].ID {
- return i
- }
- }
- return -1
-}
-
-// Update is used to fully update or add a new FolderConfig
-func (c FoldersConfig) Update(newCfg FoldersConfig) FoldersConfig {
- for i := range newCfg {
- found := false
- for j := range c {
- if newCfg[i].ID == c[j].ID {
- c[j] = newCfg[i]
- found = true
- break
- }
- }
- if !found {
- c = append(c, newCfg[i])
- }
- }
- return c
-}
-
-// Delete is used to delete a folder matching id in FoldersConfig array
-func (c FoldersConfig) Delete(id string) (FoldersConfig, FolderConfig, error) {
- if idx := c.GetIdx(id); idx != -1 {
- f := c[idx]
- c = append(c[:idx], c[idx+1:]...)
- return c, f, nil
- }
-
- return c, FolderConfig{}, fmt.Errorf("invalid id")
-}