update xds-server package in docker
[src/xds/xds-server.git] / lib / xdsserver / xdsserver.go
1 /*
2  * Copyright (C) 2017-2018 "IoT.bzh"
3  * Author Sebastien Douheret <sebastien@iot.bzh>
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  *   http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 package xdsserver
19
20 import (
21         "fmt"
22         "os"
23         "os/exec"
24         "os/signal"
25         "path/filepath"
26         "syscall"
27         "time"
28
29         st "gerrit.automotivelinux.org/gerrit/src/xds/xds-server/lib/syncthing"
30         "gerrit.automotivelinux.org/gerrit/src/xds/xds-server/lib/xdsconfig"
31         "gerrit.automotivelinux.org/gerrit/src/xds/xds-server/lib/xsapiv1"
32         "github.com/Sirupsen/logrus"
33         "github.com/codegangsta/cli"
34 )
35
36 const cookieMaxAge = "3600"
37
38 // Context holds the XDS server context
39 type Context struct {
40         ProgName      string
41         Cli           *cli.Context
42         Config        *xdsconfig.Config
43         Log           *logrus.Logger
44         LogLevelSilly bool
45         LogSillyf     func(format string, args ...interface{})
46         SThg          *st.SyncThing
47         SThgCmd       *exec.Cmd
48         SThgInotCmd   *exec.Cmd
49         mfolders      *Folders
50         sdks          *SDKs
51         targets       *Targets
52         WWWServer     *WebServer
53         sessions      *Sessions
54         events        *Events
55         lock          Lock
56         Exit          chan os.Signal
57 }
58
59 // NewXdsServer Create a new instance of XDS server
60 func NewXdsServer(cliCtx *cli.Context) *Context {
61         var err error
62
63         // Set logger level and formatter
64         log := cliCtx.App.Metadata["logger"].(*logrus.Logger)
65
66         logLevel := cliCtx.GlobalString("log")
67         if logLevel == "" {
68                 logLevel = "error" // FIXME get from Config DefaultLogLevel
69         }
70         if log.Level, err = logrus.ParseLevel(logLevel); err != nil {
71                 fmt.Printf("Invalid log level : \"%v\"\n", logLevel)
72                 os.Exit(1)
73         }
74         log.Formatter = &logrus.TextFormatter{}
75
76         // Support silly logging (printed on log.debug)
77         sillyVal, sillyLog := os.LookupEnv("XDS_LOG_SILLY")
78         logSilly := sillyLog && sillyVal == "1"
79         sillyFunc := func(format string, args ...interface{}) {
80                 if logSilly {
81                         log.Debugf("SILLY: "+format, args...)
82                 }
83         }
84
85         // Define default configuration
86         ctx := Context{
87                 ProgName:      cliCtx.App.Name,
88                 Cli:           cliCtx,
89                 Log:           log,
90                 LogLevelSilly: logSilly,
91                 LogSillyf:     sillyFunc,
92                 lock:          Lock{LockCpt: 0},
93                 Exit:          make(chan os.Signal, 1),
94         }
95
96         // register handler on SIGTERM / exit
97         signal.Notify(ctx.Exit, os.Interrupt, syscall.SIGTERM)
98         go handlerSigTerm(&ctx)
99
100         return &ctx
101 }
102
103 // Run Main function called to run XDS Server
104 func (ctx *Context) Run() (int, error) {
105         var err error
106
107         // Logs redirected into a file when logfile option or logsDir config is set
108         ctx.Config.LogVerboseOut = os.Stderr
109         if ctx.Config.FileConf.LogsDir != "" {
110                 if ctx.Config.Options.LogFile != "stdout" {
111                         logFile := ctx.Config.Options.LogFile
112
113                         fdL, err := os.OpenFile(logFile, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
114                         if err != nil {
115                                 msgErr := fmt.Sprintf("Cannot create log file %s", logFile)
116                                 return int(syscall.EPERM), fmt.Errorf(msgErr)
117                         }
118                         ctx.Log.Out = fdL
119
120                         ctx._logPrint("Logging file: %s\n", logFile)
121                 }
122
123                 logFileHTTPReq := filepath.Join(ctx.Config.FileConf.LogsDir, "xds-server-verbose.log")
124                 fdLH, err := os.OpenFile(logFileHTTPReq, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
125                 if err != nil {
126                         msgErr := fmt.Sprintf("Cannot create log file %s", logFileHTTPReq)
127                         return int(syscall.EPERM), fmt.Errorf(msgErr)
128                 }
129                 ctx.Config.LogVerboseOut = fdLH
130
131                 ctx._logPrint("Logging file for HTTP requests:  %s\n", logFileHTTPReq)
132         }
133
134         // Create events management
135         ctx.events = EventsConstructor(ctx)
136
137         // Create syncthing instance when section "syncthing" is present in server-config.json
138         if ctx.Config.FileConf.SThgConf != nil {
139                 ctx.SThg = st.NewSyncThing(ctx.Config, ctx.Log)
140         }
141
142         // Start local instance of Syncthing and Syncthing-notify
143         if ctx.SThg != nil {
144                 ctx.Log.Infof("Starting Syncthing...")
145                 ctx.SThgCmd, err = ctx.SThg.Start()
146                 if err != nil {
147                         return -4, err
148                 }
149                 ctx._logPrint("Syncthing started (PID %d)\n", ctx.SThgCmd.Process.Pid)
150
151                 ctx.Log.Infof("Starting Syncthing-inotify...")
152                 ctx.SThgInotCmd, err = ctx.SThg.StartInotify()
153                 if err != nil {
154                         return -4, err
155                 }
156                 ctx._logPrint("Syncthing-inotify started (PID %d)\n", ctx.SThgInotCmd.Process.Pid)
157
158                 // Establish connection with local Syncthing (retry if connection fail)
159                 ctx._logPrint("Establishing connection with Syncthing...\n")
160                 time.Sleep(2 * time.Second)
161                 maxRetry := 30
162                 retry := maxRetry
163                 err = nil
164                 for retry > 0 {
165                         if err = ctx.SThg.Connect(); err == nil {
166                                 break
167                         }
168                         ctx.Log.Warningf("Establishing connection to Syncthing (retry %d/%d)", retry, maxRetry)
169                         time.Sleep(time.Second)
170                         retry--
171                 }
172                 if err != nil || retry == 0 {
173                         return -4, err
174                 }
175
176                 // FIXME: do we still need Builder notion ? if no cleanup
177                 if ctx.Config.Builder, err = xdsconfig.NewBuilderConfig(ctx.SThg.MyID); err != nil {
178                         return -4, err
179                 }
180                 ctx.Config.SupportedSharing[xsapiv1.TypeCloudSync] = true
181         }
182
183         // Init model folder
184         ctx.mfolders = FoldersConstructor(ctx)
185
186         // Load initial folders config from disk
187         if err := ctx.mfolders.LoadConfig(); err != nil {
188                 return -5, err
189         }
190
191         // Init cross SDKs
192         ctx.sdks, err = SDKsConstructor(ctx)
193         if err != nil {
194                 return -6, err
195         }
196
197         // Init target and terminals model
198         ctx.targets = TargetsConstructor(ctx)
199
200         // Load initial target & terminal config
201         if err := ctx.targets.LoadConfig(); err != nil {
202                 return -6, err
203         }
204
205         // Create Web Server
206         ctx.WWWServer = WebServerConstructor(ctx)
207
208         // Sessions manager
209         ctx.sessions = ClientSessionsConstructor(ctx, cookieMaxAge)
210
211         // Check if a new package version is available
212         // and monitor updates
213         MonitorUpdates(ctx)
214
215         // Run Web Server until exit requested (blocking call)
216         if err = ctx.WWWServer.Serve(); err != nil {
217                 ctx.Log.Println(err)
218                 return -7, err
219         }
220
221         return -99, fmt.Errorf("Program exited ")
222 }
223
224 // Helper function to log message on both stdout and logger
225 func (ctx *Context) _logPrint(format string, args ...interface{}) {
226         fmt.Printf(format, args...)
227         if ctx.Log.Out != os.Stdout {
228                 ctx.Log.Infof(format, args...)
229         }
230 }
231
232 // Handle exit and properly stop/close all stuff
233 func handlerSigTerm(ctx *Context) {
234         <-ctx.Exit
235         if ctx.SThg != nil {
236                 ctx.Log.Infof("Stoping Syncthing... (PID %d)", ctx.SThgCmd.Process.Pid)
237                 ctx.SThg.Stop()
238                 ctx.Log.Infof("Stoping Syncthing-inotify... (PID %d)", ctx.SThgInotCmd.Process.Pid)
239                 ctx.SThg.StopInotify()
240         }
241         if ctx.WWWServer != nil {
242                 ctx.Log.Infof("Stoping Web server...")
243                 ctx.WWWServer.Stop()
244         }
245         os.Exit(0)
246 }