Fix docker images detection on Redhat like distro.
[src/xds/xds-server.git] / main.go
diff --git a/main.go b/main.go
index 060a927..c73d881 100644 (file)
--- a/main.go
+++ b/main.go
@@ -8,7 +8,6 @@ import (
        "os/exec"
        "os/signal"
        "path/filepath"
-       "strings"
        "syscall"
        "time"
 
@@ -48,7 +47,7 @@ type Context struct {
        SThg        *st.SyncThing
        SThgCmd     *exec.Cmd
        SThgInotCmd *exec.Cmd
-       MFolder     *model.Folder
+       MFolders    *model.Folders
        SDKs        *crosssdk.SDKs
        WWWServer   *webserver.Server
        Exit        chan os.Signal
@@ -99,7 +98,15 @@ func handlerSigTerm(ctx *Context) {
                ctx.Log.Infof("Stoping Web server...")
                ctx.WWWServer.Stop()
        }
-       os.Exit(1)
+       os.Exit(0)
+}
+
+// Helper function to log message on both stdout and logger
+func logPrint(ctx *Context, format string, args ...interface{}) {
+       fmt.Printf(format, args...)
+       if ctx.Log.Out != os.Stdout {
+               ctx.Log.Infof(format, args...)
+       }
 }
 
 // XDS Server application main routine
@@ -112,55 +119,60 @@ func xdsApp(cliCtx *cli.Context) error {
        // Load config
        cfg, err := xdsconfig.Init(ctx.Cli, ctx.Log)
        if err != nil {
-               return cli.NewExitError(err, 2)
+               return cli.NewExitError(err, -2)
        }
        ctx.Config = cfg
 
-       // Logs redirected into a file when logsDir is set
-       logfilename := cliCtx.GlobalString("logfile")
-       if ctx.Config.FileConf.LogsDir != "" && logfilename != "stdout" {
-               if logfilename == "" {
-                       logfilename = "xds-server.log"
-               }
-               // is it an absolute path ?
-               logFile := logfilename
-               if logfilename[0] == '.' || logfilename[0] != '/' {
-                       logFile = filepath.Join(ctx.Config.FileConf.LogsDir, logfilename)
+       // Logs redirected into a file when logfile option or logsDir config is set
+       ctx.Config.LogVerboseOut = os.Stderr
+       if ctx.Config.FileConf.LogsDir != "" {
+               if ctx.Config.Options.LogFile != "stdout" {
+                       logFile := ctx.Config.Options.LogFile
+
+                       fdL, err := os.OpenFile(logFile, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
+                       if err != nil {
+                               msgErr := fmt.Sprintf("Cannot create log file %s", logFile)
+                               return cli.NewExitError(msgErr, int(syscall.EPERM))
+                       }
+                       ctx.Log.Out = fdL
+
+                       logPrint(ctx, "Logging file: %s\n", logFile)
                }
-               fmt.Printf("Logging file: %s\n", logFile)
-               fdL, err := os.OpenFile(logFile, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
+
+               logFileHTTPReq := filepath.Join(ctx.Config.FileConf.LogsDir, "xds-server-verbose.log")
+               fdLH, err := os.OpenFile(logFileHTTPReq, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
                if err != nil {
-                       msgErr := fmt.Sprintf("Cannot create log file %s", logFile)
+                       msgErr := fmt.Sprintf("Cannot create log file %s", logFileHTTPReq)
                        return cli.NewExitError(msgErr, int(syscall.EPERM))
                }
-               ctx.Log.Out = fdL
-       }
-
-       // FIXME - add a builder interface and support other builder type (eg. native)
-       builderType := "syncthing"
+               ctx.Config.LogVerboseOut = fdLH
 
-       switch builderType {
-       case "syncthing":
+               logPrint(ctx, "Logging file for HTTP requests: %s\n", logFileHTTPReq)
+       }
 
-               // Start local instance of Syncthing and Syncthing-notify
+       // Create syncthing instance when section "syncthing" is present in config.json
+       if ctx.Config.FileConf.SThgConf != nil {
                ctx.SThg = st.NewSyncThing(ctx.Config, ctx.Log)
+       }
 
+       // Start local instance of Syncthing and Syncthing-notify
+       if ctx.SThg != nil {
                ctx.Log.Infof("Starting Syncthing...")
                ctx.SThgCmd, err = ctx.SThg.Start()
                if err != nil {
-                       return cli.NewExitError(err, 2)
+                       return cli.NewExitError(err, -4)
                }
-               fmt.Printf("Syncthing started (PID %d)\n", ctx.SThgCmd.Process.Pid)
+               logPrint(ctx, "Syncthing started (PID %d)\n", ctx.SThgCmd.Process.Pid)
 
                ctx.Log.Infof("Starting Syncthing-inotify...")
                ctx.SThgInotCmd, err = ctx.SThg.StartInotify()
                if err != nil {
-                       return cli.NewExitError(err, 2)
+                       return cli.NewExitError(err, -4)
                }
-               fmt.Printf("Syncthing-inotify started (PID %d)\n", ctx.SThgInotCmd.Process.Pid)
+               logPrint(ctx, "Syncthing-inotify started (PID %d)\n", ctx.SThgInotCmd.Process.Pid)
 
                // Establish connection with local Syncthing (retry if connection fail)
-               fmt.Printf("Establishing connection with Syncthing...\n")
+               logPrint(ctx, "Establishing connection with Syncthing...\n")
                time.Sleep(2 * time.Second)
                maxRetry := 30
                retry := maxRetry
@@ -174,64 +186,39 @@ func xdsApp(cliCtx *cli.Context) error {
                        retry--
                }
                if err != nil || retry == 0 {
-                       return cli.NewExitError(err, 2)
+                       return cli.NewExitError(err, -4)
                }
 
-               // Retrieve Syncthing config
-               id, err := ctx.SThg.IDGet()
-               if err != nil {
-                       return cli.NewExitError(err, 2)
-               }
-
-               if ctx.Config.Builder, err = xdsconfig.NewBuilderConfig(id); err != nil {
-                       return cli.NewExitError(err, 2)
-               }
-
-               // Retrieve initial Syncthing config
-
-               // FIXME: cannot retrieve default SDK, need to save on disk or somewhere
-               // else all config to be able to restore it.
-               defaultSdk := ""
-               stCfg, err := ctx.SThg.ConfigGet()
-               if err != nil {
-                       return cli.NewExitError(err, 2)
-               }
-               for _, stFld := range stCfg.Folders {
-                       relativePath := strings.TrimPrefix(stFld.RawPath, ctx.Config.FileConf.ShareRootDir)
-                       if relativePath == "" {
-                               relativePath = stFld.RawPath
-                       }
-
-                       newFld := xdsconfig.NewFolderConfig(stFld.ID,
-                               stFld.Label,
-                               ctx.Config.FileConf.ShareRootDir,
-                               strings.TrimRight(relativePath, "/"),
-                               defaultSdk)
-                       ctx.Config.Folders = ctx.Config.Folders.Update(xdsconfig.FoldersConfig{newFld})
+               // FIXME: do we still need Builder notion ? if no cleanup
+               if ctx.Config.Builder, err = xdsconfig.NewBuilderConfig(ctx.SThg.MyID); err != nil {
+                       return cli.NewExitError(err, -4)
                }
+       }
 
-               // Init model folder
-               ctx.MFolder = model.NewFolder(ctx.Config, ctx.SThg)
+       // Init model folder
+       ctx.MFolders = model.FoldersNew(ctx.Config, ctx.SThg)
 
-       default:
-               err = fmt.Errorf("Unsupported builder type")
-               return cli.NewExitError(err, 3)
+       // Load initial folders config from disk
+       if err := ctx.MFolders.LoadConfig(); err != nil {
+               return cli.NewExitError(err, -5)
        }
 
        // Init cross SDKs
        ctx.SDKs, err = crosssdk.Init(ctx.Config, ctx.Log)
        if err != nil {
-               return cli.NewExitError(err, 2)
+               return cli.NewExitError(err, -6)
        }
 
-       // Create and start Web Server
-       ctx.WWWServer = webserver.New(ctx.Config, ctx.MFolder, ctx.SDKs, ctx.Log)
+       // Create Web Server
+       ctx.WWWServer = webserver.New(ctx.Config, ctx.MFolders, ctx.SDKs, ctx.Log)
+
+       // Run Web Server until exit requested (blocking call)
        if err = ctx.WWWServer.Serve(); err != nil {
                ctx.Log.Println(err)
-               return cli.NewExitError(err, 3)
+               return cli.NewExitError(err, -7)
        }
 
-       return cli.NewExitError("Program exited ", 4)
+       return cli.NewExitError("Program exited ", -99)
 }
 
 // main
@@ -271,6 +258,11 @@ func main() {
                        Usage:  "filename where logs will be redirected (default stdout)\n\t",
                        EnvVar: "LOG_FILENAME",
                },
+               cli.BoolFlag{
+                       Name:   "no-folderconfig, nfc",
+                       Usage:  fmt.Sprintf("Do not read folder config file (%s)\n\t", xdsconfig.FoldersConfigFilename),
+                       EnvVar: "NO_FOLDERCONFIG",
+               },
        }
 
        // only one action: Web Server