Initial commit.

Signed-off-by: Sebastien Douheret <sebastien.douheret@iot.bzh>

12 files changed, 1353 insertions, 0 deletions

diff --git a/lib/agent/agent.go b/lib/agent/agent.go
new file mode 100644
index 0000000..80c97f7
--- /dev/null
+++ b/lib/agent/agent.go
@@ -0,0 +1,76 @@
+package agent
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"os/signal"
+	"syscall"
+
+	"github.com/Sirupsen/logrus"
+	"github.com/codegangsta/cli"
+	"github.com/iotbzh/xds-agent/lib/syncthing"
+	"github.com/iotbzh/xds-agent/lib/xdsconfig"
+	"github.com/iotbzh/xds-agent/lib/xdsserver"
+)
+
+// Context holds the Agent context structure
+type Context struct {
+	ProgName    string
+	Config      *xdsconfig.Config
+	Log         *logrus.Logger
+	SThg        *st.SyncThing
+	SThgCmd     *exec.Cmd
+	SThgInotCmd *exec.Cmd
+	WWWServer   *xdsserver.ServerService
+	Exit        chan os.Signal
+}
+
+// NewAgent Create a new instance of Agent
+func NewAgent(cliCtx *cli.Context) *Context {
+	var err error
+
+	// Set logger level and formatter
+	log := cliCtx.App.Metadata["logger"].(*logrus.Logger)
+
+	logLevel := cliCtx.GlobalString("log")
+	if logLevel == "" {
+		logLevel = "error" // FIXME get from Config DefaultLogLevel
+	}
+	if log.Level, err = logrus.ParseLevel(logLevel); err != nil {
+		fmt.Printf("Invalid log level : \"%v\"\n", logLevel)
+		os.Exit(1)
+	}
+	log.Formatter = &logrus.TextFormatter{}
+
+	// Define default configuration
+	ctx := Context{
+		ProgName: cliCtx.App.Name,
+		Log:      log,
+		Exit:     make(chan os.Signal, 1),
+	}
+
+	// register handler on SIGTERM / exit
+	signal.Notify(ctx.Exit, os.Interrupt, syscall.SIGTERM)
+	go handlerSigTerm(&ctx)
+
+	return &ctx
+}
+
+// Handle exit and properly stop/close all stuff
+func handlerSigTerm(ctx *Context) {
+	<-ctx.Exit
+	if ctx.SThg != nil {
+		ctx.Log.Infof("Stoping Syncthing... (PID %d)",
+			ctx.SThgCmd.Process.Pid)
+		ctx.Log.Infof("Stoping Syncthing-inotify... (PID %d)",
+			ctx.SThgInotCmd.Process.Pid)
+		ctx.SThg.Stop()
+		ctx.SThg.StopInotify()
+	}
+	if ctx.WWWServer != nil {
+		ctx.Log.Infof("Stoping Web server...")
+		ctx.WWWServer.Stop()
+	}
+	os.Exit(1)
+}
diff --git a/lib/apiv1/apiv1.go b/lib/apiv1/apiv1.go
new file mode 100644
index 0000000..734929b
--- /dev/null
+++ b/lib/apiv1/apiv1.go
@@ -0,0 +1,36 @@
+package apiv1
+
+import (
+	"github.com/Sirupsen/logrus"
+	"github.com/gin-gonic/gin"
+
+	"github.com/iotbzh/xds-agent/lib/session"
+	"github.com/iotbzh/xds-agent/lib/xdsconfig"
+)
+
+// APIService .
+type APIService struct {
+	router    *gin.Engine
+	apiRouter *gin.RouterGroup
+	sessions  *session.Sessions
+	cfg       *xdsconfig.Config
+	log       *logrus.Logger
+}
+
+// New creates a new instance of API service
+func New(sess *session.Sessions, conf *xdsconfig.Config, log *logrus.Logger, r *gin.Engine) *APIService {
+	s := &APIService{
+		router:    r,
+		sessions:  sess,
+		apiRouter: r.Group("/api/v1"),
+		cfg:       conf,
+		log:       log,
+	}
+
+	s.apiRouter.GET("/version", s.getVersion)
+
+	s.apiRouter.GET("/config", s.getConfig)
+	s.apiRouter.POST("/config", s.setConfig)
+
+	return s
+}
diff --git a/lib/apiv1/config.go b/lib/apiv1/config.go
new file mode 100644
index 0000000..79225f4
--- /dev/null
+++ b/lib/apiv1/config.go
@@ -0,0 +1,45 @@
+package apiv1
+
+import (
+	"net/http"
+	"sync"
+
+	"github.com/gin-gonic/gin"
+	"github.com/iotbzh/xds-agent/lib/common"
+	"github.com/iotbzh/xds-agent/lib/xdsconfig"
+)
+
+var confMut sync.Mutex
+
+// GetConfig returns the configuration
+func (s *APIService) getConfig(c *gin.Context) {
+	confMut.Lock()
+	defer confMut.Unlock()
+
+	c.JSON(http.StatusOK, s.cfg)
+}
+
+// SetConfig sets configuration
+func (s *APIService) setConfig(c *gin.Context) {
+	// FIXME - must be tested
+	c.JSON(http.StatusNotImplemented, "Not implemented")
+
+	var cfgArg xdsconfig.Config
+
+	if c.BindJSON(&cfgArg) != nil {
+		common.APIError(c, "Invalid arguments")
+		return
+	}
+
+	confMut.Lock()
+	defer confMut.Unlock()
+
+	s.log.Debugln("SET config: ", cfgArg)
+
+	if err := s.cfg.UpdateAll(cfgArg); err != nil {
+		common.APIError(c, err.Error())
+		return
+	}
+
+	c.JSON(http.StatusOK, s.cfg)
+}
diff --git a/lib/apiv1/version.go b/lib/apiv1/version.go
new file mode 100644
index 0000000..e022441
--- /dev/null
+++ b/lib/apiv1/version.go
@@ -0,0 +1,24 @@
+package apiv1
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+type version struct {
+	Version       string `json:"version"`
+	APIVersion    string `json:"apiVersion"`
+	VersionGitTag string `json:"gitTag"`
+}
+
+// getInfo : return various information about server
+func (s *APIService) getVersion(c *gin.Context) {
+	response := version{
+		Version:       s.cfg.Version,
+		APIVersion:    s.cfg.APIVersion,
+		VersionGitTag: s.cfg.VersionGitTag,
+	}
+
+	c.JSON(http.StatusOK, response)
+}
diff --git a/lib/common/error.go b/lib/common/error.go
new file mode 100644
index 0000000..d03c176
--- /dev/null
+++ b/lib/common/error.go
@@ -0,0 +1,13 @@
+package common
+
+import (
+	"github.com/gin-gonic/gin"
+)
+
+// APIError returns an uniform json formatted error
+func APIError(c *gin.Context, err string) {
+	c.JSON(500, gin.H{
+		"status": "error",
+		"error":  err,
+	})
+}
diff --git a/lib/common/httpclient.go b/lib/common/httpclient.go
new file mode 100644
index 0000000..40d7bc2
--- /dev/null
+++ b/lib/common/httpclient.go
@@ -0,0 +1,221 @@
+package common
+
+import (
+	"bytes"
+	"crypto/tls"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"strings"
+)
+
+type HTTPClient struct {
+	httpClient http.Client
+	endpoint   string
+	apikey     string
+	username   string
+	password   string
+	id         string
+	csrf       string
+	conf       HTTPClientConfig
+}
+
+type HTTPClientConfig struct {
+	URLPrefix           string
+	HeaderAPIKeyName    string
+	Apikey              string
+	HeaderClientKeyName string
+	CsrfDisable         bool
+}
+
+// Inspired by syncthing/cmd/cli
+
+const insecure = false
+
+// HTTPNewClient creates a new HTTP client to deal with Syncthing
+func HTTPNewClient(baseURL string, cfg HTTPClientConfig) (*HTTPClient, error) {
+
+	// Create w new Http client
+	httpClient := http.Client{
+		Transport: &http.Transport{
+			TLSClientConfig: &tls.Config{
+				InsecureSkipVerify: insecure,
+			},
+		},
+	}
+	client := HTTPClient{
+		httpClient: httpClient,
+		endpoint:   baseURL,
+		apikey:     cfg.Apikey,
+		conf:       cfg,
+		/* TODO - add user + pwd support
+		username:   c.GlobalString("username"),
+		password:   c.GlobalString("password"),
+		*/
+	}
+
+	if client.apikey == "" {
+		if err := client.getCidAndCsrf(); err != nil {
+			return nil, err
+		}
+	}
+	return &client, nil
+}
+
+// Send request to retrieve Client id and/or CSRF token
+func (c *HTTPClient) getCidAndCsrf() error {
+	request, err := http.NewRequest("GET", c.endpoint, nil)
+	if err != nil {
+		return err
+	}
+	if _, err := c.handleRequest(request); err != nil {
+		return err
+	}
+	if c.id == "" {
+		return errors.New("Failed to get device ID")
+	}
+	if !c.conf.CsrfDisable && c.csrf == "" {
+		return errors.New("Failed to get CSRF token")
+	}
+	return nil
+}
+
+// GetClientID returns the id
+func (c *HTTPClient) GetClientID() string {
+	return c.id
+}
+
+// formatURL Build full url by concatenating all parts
+func (c *HTTPClient) formatURL(endURL string) string {
+	url := c.endpoint
+	if !strings.HasSuffix(url, "/") {
+		url += "/"
+	}
+	url += strings.TrimLeft(c.conf.URLPrefix, "/")
+	if !strings.HasSuffix(url, "/") {
+		url += "/"
+	}
+	return url + strings.TrimLeft(endURL, "/")
+}
+
+// HTTPGet Send a Get request to client and return an error object
+func (c *HTTPClient) HTTPGet(url string, data *[]byte) error {
+	_, err := c.HTTPGetWithRes(url, data)
+	return err
+}
+
+// HTTPGetWithRes Send a Get request to client and return both response and error
+func (c *HTTPClient) HTTPGetWithRes(url string, data *[]byte) (*http.Response, error) {
+	request, err := http.NewRequest("GET", c.formatURL(url), nil)
+	if err != nil {
+		return nil, err
+	}
+	res, err := c.handleRequest(request)
+	if err != nil {
+		return res, err
+	}
+	if res.StatusCode != 200 {
+		return res, errors.New(res.Status)
+	}
+
+	*data = c.responseToBArray(res)
+
+	return res, nil
+}
+
+// HTTPPost Send a POST request to client and return an error object
+func (c *HTTPClient) HTTPPost(url string, body string) error {
+	_, err := c.HTTPPostWithRes(url, body)
+	return err
+}
+
+// HTTPPostWithRes Send a POST request to client and return both response and error
+func (c *HTTPClient) HTTPPostWithRes(url string, body string) (*http.Response, error) {
+	request, err := http.NewRequest("POST", c.formatURL(url), bytes.NewBufferString(body))
+	if err != nil {
+		return nil, err
+	}
+	res, err := c.handleRequest(request)
+	if err != nil {
+		return res, err
+	}
+	if res.StatusCode != 200 {
+		return res, errors.New(res.Status)
+	}
+	return res, nil
+}
+
+func (c *HTTPClient) responseToBArray(response *http.Response) []byte {
+	defer response.Body.Close()
+	bytes, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		// TODO improved error reporting
+		fmt.Println("ERROR: " + err.Error())
+	}
+	return bytes
+}
+
+func (c *HTTPClient) handleRequest(request *http.Request) (*http.Response, error) {
+	if c.conf.HeaderAPIKeyName != "" && c.apikey != "" {
+		request.Header.Set(c.conf.HeaderAPIKeyName, c.apikey)
+	}
+	if c.conf.HeaderClientKeyName != "" && c.id != "" {
+		request.Header.Set(c.conf.HeaderClientKeyName, c.id)
+	}
+	if c.username != "" || c.password != "" {
+		request.SetBasicAuth(c.username, c.password)
+	}
+	if c.csrf != "" {
+		request.Header.Set("X-CSRF-Token-"+c.id[:5], c.csrf)
+	}
+
+	response, err := c.httpClient.Do(request)
+	if err != nil {
+		return nil, err
+	}
+
+	// Detect client ID change
+	cid := response.Header.Get(c.conf.HeaderClientKeyName)
+	if cid != "" && c.id != cid {
+		c.id = cid
+	}
+
+	// Detect CSR token change
+	for _, item := range response.Cookies() {
+		if item.Name == "CSRF-Token-"+c.id[:5] {
+			c.csrf = item.Value
+			goto csrffound
+		}
+	}
+	// OK CSRF found
+csrffound:
+
+	if response.StatusCode == 404 {
+		return nil, errors.New("Invalid endpoint or API call")
+	} else if response.StatusCode == 401 {
+		return nil, errors.New("Invalid username or password")
+	} else if response.StatusCode == 403 {
+		if c.apikey == "" {
+			// Request a new Csrf for next requests
+			c.getCidAndCsrf()
+			return nil, errors.New("Invalid CSRF token")
+		}
+		return nil, errors.New("Invalid API key")
+	} else if response.StatusCode != 200 {
+		data := make(map[string]interface{})
+		// Try to decode error field of APIError struct
+		json.Unmarshal(c.responseToBArray(response), &data)
+		if err, found := data["error"]; found {
+			return nil, fmt.Errorf(err.(string))
+		} else {
+			body := strings.TrimSpace(string(c.responseToBArray(response)))
+			if body != "" {
+				return nil, fmt.Errorf(body)
+			}
+		}
+		return nil, errors.New("Unknown HTTP status returned: " + response.Status)
+	}
+	return response, nil
+}
diff --git a/lib/session/session.go b/lib/session/session.go
new file mode 100644
index 0000000..af05daa
--- /dev/null
+++ b/lib/session/session.go
@@ -0,0 +1,227 @@
+package session
+
+import (
+	"encoding/base64"
+	"strconv"
+	"time"
+
+	"github.com/Sirupsen/logrus"
+	"github.com/gin-gonic/gin"
+	"github.com/googollee/go-socket.io"
+	uuid "github.com/satori/go.uuid"
+	"github.com/syncthing/syncthing/lib/sync"
+)
+
+const sessionCookieName = "xds-agent-sid"
+const sessionHeaderName = "XDS-AGENT-SID"
+
+const sessionMonitorTime = 10 // Time (in seconds) to schedule monitoring session tasks
+
+const initSessionMaxAge = 10 // Initial session max age in seconds
+const maxSessions = 100000   // Maximum number of sessions in sessMap map
+
+const secureCookie = false // TODO: see https://github.com/astaxie/beego/blob/master/session/session.go#L218
+
+// ClientSession contains the info of a user/client session
+type ClientSession struct {
+	ID       string
+	WSID     string // only one WebSocket per client/session
+	MaxAge   int64
+	IOSocket *socketio.Socket
+
+	// private
+	expireAt time.Time
+	useCount int64
+}
+
+// Sessions holds client sessions
+type Sessions struct {
+	router       *gin.Engine
+	cookieMaxAge int64
+	sessMap      map[string]ClientSession
+	mutex        sync.Mutex
+	log          *logrus.Logger
+	stop         chan struct{} // signals intentional stop
+}
+
+// NewClientSessions .
+func NewClientSessions(router *gin.Engine, log *logrus.Logger, cookieMaxAge string) *Sessions {
+	ckMaxAge, err := strconv.ParseInt(cookieMaxAge, 10, 0)
+	if err != nil {
+		ckMaxAge = 0
+	}
+	s := Sessions{
+		router:       router,
+		cookieMaxAge: ckMaxAge,
+		sessMap:      make(map[string]ClientSession),
+		mutex:        sync.NewMutex(),
+		log:          log,
+		stop:         make(chan struct{}),
+	}
+	s.router.Use(s.Middleware())
+
+	// Start monitoring of sessions Map (use to manage expiration and cleanup)
+	go s.monitorSessMap()
+
+	return &s
+}
+
+// Stop sessions management
+func (s *Sessions) Stop() {
+	close(s.stop)
+}
+
+// Middleware is used to managed session
+func (s *Sessions) Middleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// FIXME Add CSRF management
+
+		// Get session
+		sess := s.Get(c)
+		if sess == nil {
+			// Allocate a new session key and put in cookie
+			sess = s.newSession("")
+		} else {
+			s.refresh(sess.ID)
+		}
+
+		// Set session in cookie and in header
+		// Do not set Domain to localhost (http://stackoverflow.com/questions/1134290/cookies-on-localhost-with-explicit-domain)
+		c.SetCookie(sessionCookieName, sess.ID, int(sess.MaxAge), "/", "",
+			secureCookie, false)
+		c.Header(sessionHeaderName, sess.ID)
+
+		// Save session id in gin metadata
+		c.Set(sessionCookieName, sess.ID)
+
+		c.Next()
+	}
+}
+
+// Get returns the client session for a specific ID
+func (s *Sessions) Get(c *gin.Context) *ClientSession {
+	var sid string
+
+	// First get from gin metadata
+	v, exist := c.Get(sessionCookieName)
+	if v != nil {
+		sid = v.(string)
+	}
+
+	// Then look in cookie
+	if !exist || sid == "" {
+		sid, _ = c.Cookie(sessionCookieName)
+	}
+
+	// Then look in Header
+	if sid == "" {
+		sid = c.Request.Header.Get(sessionCookieName)
+	}
+	if sid != "" {
+		s.mutex.Lock()
+		defer s.mutex.Unlock()
+		if key, ok := s.sessMap[sid]; ok {
+			// TODO: return a copy ???
+			return &key
+		}
+	}
+	return nil
+}
+
+// IOSocketGet Get socketio definition from sid
+func (s *Sessions) IOSocketGet(sid string) *socketio.Socket {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	sess, ok := s.sessMap[sid]
+	if ok {
+		return sess.IOSocket
+	}
+	return nil
+}
+
+// UpdateIOSocket updates the IO Socket definition for of a session
+func (s *Sessions) UpdateIOSocket(sid string, so *socketio.Socket) error {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	if _, ok := s.sessMap[sid]; ok {
+		sess := s.sessMap[sid]
+		if so == nil {
+			// Could be the case when socketio is closed/disconnected
+			sess.WSID = ""
+		} else {
+			sess.WSID = (*so).Id()
+		}
+		sess.IOSocket = so
+		s.sessMap[sid] = sess
+	}
+	return nil
+}
+
+// nesSession Allocate a new client session
+func (s *Sessions) newSession(prefix string) *ClientSession {
+	uuid := prefix + uuid.NewV4().String()
+	id := base64.URLEncoding.EncodeToString([]byte(uuid))
+	se := ClientSession{
+		ID:       id,
+		WSID:     "",
+		MaxAge:   initSessionMaxAge,
+		IOSocket: nil,
+		expireAt: time.Now().Add(time.Duration(initSessionMaxAge) * time.Second),
+		useCount: 0,
+	}
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	s.sessMap[se.ID] = se
+
+	s.log.Debugf("NEW session (%d): %s", len(s.sessMap), id)
+	return &se
+}
+
+// refresh Move this session ID to the head of the list
+func (s *Sessions) refresh(sid string) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	sess := s.sessMap[sid]
+	sess.useCount++
+	if sess.MaxAge < s.cookieMaxAge && sess.useCount > 1 {
+		sess.MaxAge = s.cookieMaxAge
+		sess.expireAt = time.Now().Add(time.Duration(sess.MaxAge) * time.Second)
+	}
+
+	// TODO - Add flood detection (like limit_req of nginx)
+	// (delayed request when to much requests in a short period of time)
+
+	s.sessMap[sid] = sess
+}
+
+func (s *Sessions) monitorSessMap() {
+	const dbgFullTrace = false // for debugging
+
+	for {
+		select {
+		case <-s.stop:
+			s.log.Debugln("Stop monitorSessMap")
+			return
+		case <-time.After(sessionMonitorTime * time.Second):
+			s.log.Debugf("Sessions Map size: %d", len(s.sessMap))
+			if dbgFullTrace {
+				s.log.Debugf("Sessions Map : %v", s.sessMap)
+			}
+
+			if len(s.sessMap) > maxSessions {
+				s.log.Errorln("TOO MUCH sessions, cleanup old ones !")
+			}
+
+			s.mutex.Lock()
+			for _, ss := range s.sessMap {
+				if ss.expireAt.Sub(time.Now()) < 0 {
+					s.log.Debugf("Delete expired session id: %s", ss.ID)
+					delete(s.sessMap, ss.ID)
+				}
+			}
+			s.mutex.Unlock()
+		}
+	}
+}
diff --git a/lib/syncthing/st.go b/lib/syncthing/st.go
new file mode 100644
index 0000000..e513876
--- /dev/null
+++ b/lib/syncthing/st.go
@@ -0,0 +1,242 @@
+package st
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"os"
+	"path"
+	"strings"
+	"syscall"
+	"time"
+
+	"fmt"
+
+	"os/exec"
+
+	"github.com/Sirupsen/logrus"
+	"github.com/iotbzh/xds-agent/lib/common"
+	"github.com/iotbzh/xds-agent/lib/xdsconfig"
+	"github.com/syncthing/syncthing/lib/config"
+)
+
+// SyncThing .
+type SyncThing struct {
+	BaseURL string
+	ApiKey  string
+	Home    string
+	STCmd   *exec.Cmd
+	STICmd  *exec.Cmd
+
+	// Private fields
+	binDir      string
+	exitSTChan  chan ExitChan
+	exitSTIChan chan ExitChan
+	client      *common.HTTPClient
+	log         *logrus.Logger
+}
+
+// Monitor process exit
+type ExitChan struct {
+	status int
+	err    error
+}
+
+// NewSyncThing creates a new instance of Syncthing
+//func NewSyncThing(url string, apiKey string, home string, log *logrus.Logger) *SyncThing {
+func NewSyncThing(conf *xdsconfig.SyncThingConf, log *logrus.Logger) *SyncThing {
+	url := conf.GuiAddress
+	apiKey := conf.GuiAPIKey
+	home := conf.Home
+
+	s := SyncThing{
+		BaseURL: url,
+		ApiKey:  apiKey,
+		Home:    home,
+		binDir:  conf.BinDir,
+		log:     log,
+	}
+
+	if s.BaseURL == "" {
+		s.BaseURL = "http://localhost:8384"
+	}
+	if s.BaseURL[0:7] != "http://" {
+		s.BaseURL = "http://" + s.BaseURL
+	}
+
+	return &s
+}
+
+// Start Starts syncthing process
+func (s *SyncThing) startProc(exeName string, args []string, env []string, eChan *chan ExitChan) (*exec.Cmd, error) {
+
+	// Kill existing process (useful for debug ;-) )
+	if os.Getenv("DEBUG_MODE") != "" {
+		exec.Command("bash", "-c", "pkill -9 "+exeName).Output()
+	}
+
+	path, err := exec.LookPath(path.Join(s.binDir, exeName))
+	if err != nil {
+		return nil, fmt.Errorf("Cannot find %s executable in %s", exeName, s.binDir)
+	}
+	cmd := exec.Command(path, args...)
+	cmd.Env = os.Environ()
+	for _, ev := range env {
+		cmd.Env = append(cmd.Env, ev)
+	}
+
+	err = cmd.Start()
+	if err != nil {
+		return nil, err
+	}
+
+	*eChan = make(chan ExitChan, 1)
+	go func(c *exec.Cmd) {
+		status := 0
+		cmdOut, err := c.StdoutPipe()
+		if err == nil {
+			s.log.Errorf("Pipe stdout error for : %s", err)
+		} else if cmdOut != nil {
+			stdOutput, _ := ioutil.ReadAll(cmdOut)
+			fmt.Printf("STDOUT: %s\n", stdOutput)
+		}
+		sts, err := c.Process.Wait()
+		if !sts.Success() {
+			s := sts.Sys().(syscall.WaitStatus)
+			status = s.ExitStatus()
+		}
+		*eChan <- ExitChan{status, err}
+	}(cmd)
+
+	return cmd, nil
+}
+
+// Start Starts syncthing process
+func (s *SyncThing) Start() (*exec.Cmd, error) {
+	var err error
+	args := []string{
+		"--home=" + s.Home,
+		"-no-browser",
+		"--gui-address=" + s.BaseURL,
+	}
+
+	if s.ApiKey != "" {
+		args = append(args, "-gui-apikey=\""+s.ApiKey+"\"")
+	}
+	if s.log.Level == logrus.DebugLevel {
+		args = append(args, "-verbose")
+	}
+
+	env := []string{
+		"STNODEFAULTFOLDER=1",
+	}
+
+	s.STCmd, err = s.startProc("syncthing", args, env, &s.exitSTChan)
+
+	return s.STCmd, err
+}
+
+// StartInotify Starts syncthing-inotify process
+func (s *SyncThing) StartInotify() (*exec.Cmd, error) {
+	var err error
+
+	args := []string{
+		"--home=" + s.Home,
+		"-target=" + s.BaseURL,
+	}
+	if s.log.Level == logrus.DebugLevel {
+		args = append(args, "-verbosity=4")
+	}
+
+	env := []string{}
+
+	s.STICmd, err = s.startProc("syncthing-inotify", args, env, &s.exitSTIChan)
+
+	return s.STICmd, err
+}
+
+func (s *SyncThing) stopProc(pname string, proc *os.Process, exit chan ExitChan) {
+	if err := proc.Signal(os.Interrupt); err != nil {
+		s.log.Errorf("Proc interrupt %s error: %s", pname, err.Error())
+
+		select {
+		case <-exit:
+		case <-time.After(time.Second):
+			// A bigger bonk on the head.
+			if err := proc.Signal(os.Kill); err != nil {
+				s.log.Errorf("Proc term %s error: %s", pname, err.Error())
+			}
+			<-exit
+		}
+	}
+	s.log.Infof("%s stopped (PID %d)", pname, proc.Pid)
+}
+
+// Stop Stops syncthing process
+func (s *SyncThing) Stop() {
+	if s.STCmd == nil {
+		return
+	}
+	s.stopProc("syncthing", s.STCmd.Process, s.exitSTChan)
+	s.STCmd = nil
+}
+
+// StopInotify Stops syncthing process
+func (s *SyncThing) StopInotify() {
+	if s.STICmd == nil {
+		return
+	}
+	s.stopProc("syncthing-inotify", s.STICmd.Process, s.exitSTIChan)
+	s.STICmd = nil
+}
+
+// Connect Establish HTTP connection with Syncthing
+func (s *SyncThing) Connect() error {
+	var err error
+	s.client, err = common.HTTPNewClient(s.BaseURL,
+		common.HTTPClientConfig{
+			URLPrefix:           "/rest",
+			HeaderClientKeyName: "X-Syncthing-ID",
+		})
+	if err != nil {
+		msg := ": " + err.Error()
+		if strings.Contains(err.Error(), "connection refused") {
+			msg = fmt.Sprintf("(url: %s)", s.BaseURL)
+		}
+		return fmt.Errorf("ERROR: cannot connect to Syncthing %s", msg)
+	}
+	if s.client == nil {
+		return fmt.Errorf("ERROR: cannot connect to Syncthing (null client)")
+	}
+	return nil
+}
+
+// IDGet returns the Syncthing ID of Syncthing instance running locally
+func (s *SyncThing) IDGet() (string, error) {
+	var data []byte
+	if err := s.client.HTTPGet("system/status", &data); err != nil {
+		return "", err
+	}
+	status := make(map[string]interface{})
+	json.Unmarshal(data, &status)
+	return status["myID"].(string), nil
+}
+
+// ConfigGet returns the current Syncthing configuration
+func (s *SyncThing) ConfigGet() (config.Configuration, error) {
+	var data []byte
+	config := config.Configuration{}
+	if err := s.client.HTTPGet("system/config", &data); err != nil {
+		return config, err
+	}
+	err := json.Unmarshal(data, &config)
+	return config, err
+}
+
+// ConfigSet set Syncthing configuration
+func (s *SyncThing) ConfigSet(cfg config.Configuration) error {
+	body, err := json.Marshal(cfg)
+	if err != nil {
+		return err
+	}
+	return s.client.HTTPPost("system/config", string(body))
+}
diff --git a/lib/syncthing/stfolder.go b/lib/syncthing/stfolder.go
new file mode 100644
index 0000000..d79e579
--- /dev/null
+++ b/lib/syncthing/stfolder.go
@@ -0,0 +1,116 @@
+package st
+
+import (
+	"path/filepath"
+	"strings"
+
+	"github.com/syncthing/syncthing/lib/config"
+	"github.com/syncthing/syncthing/lib/protocol"
+)
+
+// FIXME remove and use an interface on xdsconfig.FolderConfig
+type FolderChangeArg struct {
+	ID           string
+	Label        string
+	RelativePath string
+	SyncThingID  string
+	ShareRootDir string
+}
+
+// FolderChange is called when configuration has changed
+func (s *SyncThing) FolderChange(f FolderChangeArg) error {
+
+	// Get current config
+	stCfg, err := s.ConfigGet()
+	if err != nil {
+		s.log.Errorln(err)
+		return err
+	}
+
+	// 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
+	}
+
+	newDevice := config.DeviceConfiguration{
+		DeviceID:  devID,
+		Name:      f.SyncThingID,
+		Addresses: []string{"dynamic"},
+	}
+
+	var found = false
+	for _, device := range stCfg.Devices {
+		if device.DeviceID == devID {
+			found = true
+			break
+		}
+	}
+	if !found {
+		stCfg.Devices = append(stCfg.Devices, newDevice)
+	}
+
+	// Add or update Folder settings
+	var label, id string
+	if label = f.Label; label == "" {
+		label = strings.Split(id, "/")[0]
+	}
+	if id = f.ID; id == "" {
+		id = f.SyncThingID[0:15] + "_" + label
+	}
+
+	folder := config.FolderConfiguration{
+		ID:      id,
+		Label:   label,
+		RawPath: filepath.Join(f.ShareRootDir, f.RelativePath),
+	}
+
+	folder.Devices = append(folder.Devices, config.FolderDeviceConfiguration{
+		DeviceID: newDevice.DeviceID,
+	})
+
+	found = false
+	var fld config.FolderConfiguration
+	for _, fld = range stCfg.Folders {
+		if folder.ID == fld.ID {
+			fld = folder
+			found = true
+			break
+		}
+	}
+	if !found {
+		stCfg.Folders = append(stCfg.Folders, folder)
+		fld = stCfg.Folders[0]
+	}
+
+	err = s.ConfigSet(stCfg)
+	if err != nil {
+		s.log.Errorln(err)
+	}
+
+	return nil
+}
+
+// FolderDelete is called to delete a folder config
+func (s *SyncThing) FolderDelete(id string) error {
+	// Get current config
+	stCfg, err := s.ConfigGet()
+	if err != nil {
+		s.log.Errorln(err)
+		return err
+	}
+
+	for i, fld := range stCfg.Folders {
+		if id == fld.ID {
+			stCfg.Folders = append(stCfg.Folders[:i], stCfg.Folders[i+1:]...)
+			err = s.ConfigSet(stCfg)
+			if err != nil {
+				s.log.Errorln(err)
+				return err
+			}
+		}
+	}
+
+	return nil
+}
diff --git a/lib/xdsconfig/config.go b/lib/xdsconfig/config.go
new file mode 100644
index 0000000..1f53cbd
--- /dev/null
+++ b/lib/xdsconfig/config.go
@@ -0,0 +1,65 @@
+package xdsconfig
+
+import (
+	"fmt"
+
+	"os"
+
+	"github.com/Sirupsen/logrus"
+	"github.com/codegangsta/cli"
+)
+
+// Config parameters (json format) of /config command
+type Config struct {
+	Version       string `json:"version"`
+	APIVersion    string `json:"apiVersion"`
+	VersionGitTag string `json:"gitTag"`
+
+	// Private / un-exported fields
+	HTTPPort string `json:"-"`
+	FileConf *FileConfig
+	log      *logrus.Logger
+}
+
+// Config default values
+const (
+	DefaultAPIVersion = "1"
+	DefaultPort       = "8010"
+	DefaultLogLevel   = "error"
+)
+
+// Init loads the configuration on start-up
+func Init(ctx *cli.Context, log *logrus.Logger) (Config, error) {
+	var err error
+
+	// Define default configuration
+	c := Config{
+		Version:       ctx.App.Metadata["version"].(string),
+		APIVersion:    DefaultAPIVersion,
+		VersionGitTag: ctx.App.Metadata["git-tag"].(string),
+
+		HTTPPort: DefaultPort,
+		log:      log,
+	}
+
+	// config file settings overwrite default config
+	c.FileConf, err = updateConfigFromFile(&c, ctx.GlobalString("config"))
+	if err != nil {
+		return Config{}, err
+	}
+
+	return c, nil
+}
+
+// UpdateAll Update the current configuration
+func (c *Config) UpdateAll(newCfg Config) error {
+	return fmt.Errorf("Not Supported")
+}
+
+func dirExists(path string) bool {
+	_, err := os.Stat(path)
+	if os.IsNotExist(err) {
+		return false
+	}
+	return true
+}
diff --git a/lib/xdsconfig/fileconfig.go b/lib/xdsconfig/fileconfig.go
new file mode 100644
index 0000000..0c4828c
--- /dev/null
+++ b/lib/xdsconfig/fileconfig.go
@@ -0,0 +1,120 @@
+package xdsconfig
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/user"
+	"path"
+	"path/filepath"
+	"regexp"
+)
+
+type SyncThingConf struct {
+	BinDir     string `json:"binDir"`
+	Home       string `json:"home"`
+	GuiAddress string `json:"gui-address"`
+	GuiAPIKey  string `json:"gui-apikey"`
+}
+
+type FileConfig struct {
+	HTTPPort string         `json:"httpPort"`
+	SThgConf *SyncThingConf `json:"syncthing"`
+}
+
+// getConfigFromFile 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/agent-config.json file
+//  3/ <current_dir>/agent-config.json file
+//  4/ <executable dir>/agent-config.json file
+
+func updateConfigFromFile(c *Config, confFile string) (*FileConfig, 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", "agent-config.json"))
+	}
+	cwd, err := os.Getwd()
+	if err == nil {
+		searchIn = append(searchIn, path.Join(cwd, "agent-config.json"))
+	}
+	exePath, err := filepath.Abs(filepath.Dir(os.Args[0]))
+	if err == nil {
+		searchIn = append(searchIn, path.Join(exePath, "agent-config.json"))
+	}
+
+	var cFile *string
+	for _, p := range searchIn {
+		if _, err := os.Stat(p); err == nil {
+			cFile = &p
+			break
+		}
+	}
+	fCfg := FileConfig{}
+	if cFile == nil {
+		// No config file found
+		return &fCfg, nil
+	}
+
+	c.log.Infof("Use config file: %s", *cFile)
+
+	// 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()
+	if err := json.NewDecoder(fd).Decode(&fCfg); err != nil {
+		return nil, err
+	}
+
+	// Support environment variables (IOW ${MY_ENV_VAR} syntax) in agent-config.json
+	// TODO: better to use reflect package to iterate on fields and be more generic
+	var rep string
+
+	if rep, err = resolveEnvVar(fCfg.SThgConf.BinDir); err != nil {
+		return nil, err
+	}
+	fCfg.SThgConf.BinDir = path.Clean(rep)
+
+	if rep, err = resolveEnvVar(fCfg.SThgConf.Home); err != nil {
+		return nil, err
+	}
+	fCfg.SThgConf.Home = path.Clean(rep)
+
+	return &fCfg, nil
+}
+
+// resolveEnvVar Resolved environment variable regarding the syntax ${MYVAR}
+func resolveEnvVar(s string) (string, error) {
+	re := regexp.MustCompile("\\${(.*)}")
+	vars := re.FindAllStringSubmatch(s, -1)
+	res := s
+	for _, v := range vars {
+		val := os.Getenv(v[1])
+		if val == "" {
+			return res, fmt.Errorf("ERROR: %s env variable not defined", v[1])
+		}
+
+		rer := regexp.MustCompile("\\${" + v[1] + "}")
+		res = rer.ReplaceAllString(res, val)
+	}
+
+	return res, nil
+}
+
+// exists returns whether the given file or directory exists or not
+func exists(path string) bool {
+	_, err := os.Stat(path)
+	if err == nil {
+		return true
+	}
+	if os.IsNotExist(err) {
+		return false
+	}
+	return true
+}
diff --git a/lib/xdsserver/server.go b/lib/xdsserver/server.go
new file mode 100644
index 0000000..f0777e3
--- /dev/null
+++ b/lib/xdsserver/server.go
@@ -0,0 +1,168 @@
+package xdsserver
+
+import (
+	"net/http"
+
+	"github.com/Sirupsen/logrus"
+	"github.com/gin-gonic/gin"
+	"github.com/googollee/go-socket.io"
+	"github.com/iotbzh/xds-agent/lib/apiv1"
+	"github.com/iotbzh/xds-agent/lib/session"
+	"github.com/iotbzh/xds-agent/lib/xdsconfig"
+)
+
+// ServerService .
+type ServerService struct {
+	router    *gin.Engine
+	api       *apiv1.APIService
+	sIOServer *socketio.Server
+	webApp    *gin.RouterGroup
+	cfg       *xdsconfig.Config
+	sessions  *session.Sessions
+	log       *logrus.Logger
+	stop      chan struct{} // signals intentional stop
+}
+
+const indexFilename = "index.html"
+const cookieMaxAge = "3600"
+
+// NewServer creates an instance of ServerService
+func NewServer(conf *xdsconfig.Config, log *logrus.Logger) *ServerService {
+
+	// Setup logging for gin router
+	if log.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 = ??
+
+	// Creates gin router
+	r := gin.New()
+
+	svr := &ServerService{
+		router:    r,
+		api:       nil,
+		sIOServer: nil,
+		webApp:    nil,
+		cfg:       conf,
+		log:       log,
+		sessions:  nil,
+		stop:      make(chan struct{}),
+	}
+
+	return svr
+}
+
+// Serve starts a new instance of the Web Server
+func (s *ServerService) Serve() error {
+	var err error
+
+	// Setup middlewares
+	s.router.Use(gin.Logger())
+	s.router.Use(gin.Recovery())
+	s.router.Use(s.middlewareXDSDetails())
+	s.router.Use(s.middlewareCORS())
+
+	// Sessions manager
+	s.sessions = session.NewClientSessions(s.router, s.log, cookieMaxAge)
+
+	// Create REST API
+	s.api = apiv1.New(s.sessions, s.cfg, s.log, s.router)
+
+	// Websocket routes
+	s.sIOServer, err = socketio.NewServer(nil)
+	if err != nil {
+		s.log.Fatalln(err)
+	}
+
+	s.router.GET("/socket.io/", s.socketHandler)
+	s.router.POST("/socket.io/", s.socketHandler)
+	/* TODO: do we want to support ws://...  ?
+	s.router.Handle("WS", "/socket.io/", s.socketHandler)
+	s.router.Handle("WSS", "/socket.io/", s.socketHandler)
+	*/
+
+	// Serve in the background
+	serveError := make(chan error, 1)
+	go func() {
+		serveError <- http.ListenAndServe(":"+s.cfg.HTTPPort, s.router)
+	}()
+
+	// Wait for stop, restart or error signals
+	select {
+	case <-s.stop:
+		// Shutting down permanently
+		s.sessions.Stop()
+		s.log.Infoln("shutting down (stop)")
+	case err = <-serveError:
+		// Error due to listen/serve failure
+		s.log.Errorln(err)
+	}
+
+	return nil
+}
+
+// Stop web server
+func (s *ServerService) Stop() {
+	close(s.stop)
+}
+
+// Add details in Header
+func (s *ServerService) middlewareXDSDetails() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.Header("XDS-Agent-Version", s.cfg.Version)
+		c.Header("XDS-API-Version", s.cfg.APIVersion)
+		c.Next()
+	}
+}
+
+// CORS middleware
+func (s *ServerService) middlewareCORS() gin.HandlerFunc {
+	return func(c *gin.Context) {
+
+		if c.Request.Method == "OPTIONS" {
+			c.Header("Access-Control-Allow-Origin", "*")
+			c.Header("Access-Control-Allow-Headers", "Content-Type")
+			c.Header("Access-Control-Allow-Methods", "POST, DELETE, GET, PUT")
+			c.Header("Content-Type", "application/json")
+			c.Header("Access-Control-Max-Age", cookieMaxAge)
+			c.AbortWithStatus(204)
+			return
+		}
+
+		c.Next()
+	}
+}
+
+// socketHandler is the handler for the "main" websocket connection
+func (s *ServerService) socketHandler(c *gin.Context) {
+
+	// Retrieve user session
+	sess := s.sessions.Get(c)
+	if sess == nil {
+		c.JSON(500, gin.H{"error": "Cannot retrieve session"})
+		return
+	}
+
+	s.sIOServer.On("connection", func(so socketio.Socket) {
+		s.log.Debugf("WS Connected (SID=%v)", so.Id())
+		s.sessions.UpdateIOSocket(sess.ID, &so)
+
+		so.On("disconnection", func() {
+			s.log.Debugf("WS disconnected (SID=%v)", so.Id())
+			s.sessions.UpdateIOSocket(sess.ID, nil)
+		})
+	})
+
+	s.sIOServer.On("error", func(so socketio.Socket, err error) {
+		s.log.Errorf("WS SID=%v Error : %v", so.Id(), err.Error())
+	})
+
+	s.sIOServer.ServeHTTP(c.Writer, c.Request)
+}