func initDB() (rcs *DBRcs, err error) { db_config := `#Database credentials db.user=fmd db.password=fmd db.host=localhost db.db=fmd ` simplewrite("config.test.ini", db_config) defer func() { os.Remove("config.test.ini") }() config, _ := util.ReadMzConfig("config.test.ini") rcs = new(DBRcs) if err = rcs.Init(config); err != nil { fmt.Printf("Error running Init on rcs: [%v]\n", err) return nil, err } // Reset the public schema in the test database if _, err = rcs.Db.Exec("drop schema if exists public cascade;"); err != nil { fmt.Printf("Error droping public schema: [%v]\n", err) return nil, err } if _, err = rcs.Db.Exec("create schema if not exists public;"); err != nil { fmt.Printf("Error creating public schema: [%v]\n", err) return nil, err } rcs.InitVersioning() return rcs, nil }
func main() { if _, err := flags.ParseArgs(&opts, os.Args); err != nil { log.Fatalf(err.Error()) return } // Configuration // TODO: switch to regular go flag package // defaults don't appear to work. if opts.ConfigFile == "" { opts.ConfigFile = "config.ini" } config, err := util.ReadMzConfig(opts.ConfigFile) if err != nil { log.Fatalf("Could not read config file %s: %s", opts.ConfigFile, err.Error()) return } fullVers := fmt.Sprintf("%s-%s", config.Get("VERSION", VERSION), getCodeVersion()) config.Override("VERSION", fullVers) config.Override("SERVER", SERVER) config.Override("ddl.create", opts.Ddlcreate) config.Override("ddl.downgrade", opts.Ddldowngrade) if opts.LogFile != "" { config.Override("logger.output", opts.LogFile) } if opts.Ddlupgrade { config.SetDefaultFlag("ddl.upgrade", true) } if opts.Ddllog { config.SetDefaultFlag("ddl.log", true) } sock_secret, _ := util.GenUUID4() config.SetDefault("ws.socket_secret", sock_secret) // Rest Config errChan := make(chan error) host := config.Get("host", "localhost") port := config.Get("port", "8080") if config.GetFlag("aws.get_hostname") { if hostname, err := util.GetAWSPublicHostname(); err == nil { config.SetDefault("ws_hostname", hostname) } if port != "80" { config.SetDefault("ws_hostname", config.Get("ws_hostname", "")+":"+port) } } // Partner cert pool contains the various self-signed certs that // partners may require to access their servers (for Proprietary // wake mechanisms like UDP) // This would be where you collect the certs and store them into // the config map as something like: // config["partnerCertPool"] = self.loadCerts() if opts.Profile != "" { log.Printf("Creating profile %s...\n", opts.Profile) f, err := os.Create(opts.Profile) if err != nil { log.Fatal(fmt.Sprintf("Profile creation failed:\n%s\n", err.Error())) return } defer func() { log.Printf("Writing app profile...\n") pprof.StopCPUProfile() }() pprof.StartCPUProfile(f) } if opts.MemProfile != "" { defer func() { profFile, err := os.Create(opts.MemProfile) if err != nil { log.Fatal(fmt.Sprintf("Memory Profile creation failed:\n%s\n", err.Error())) return } log.Printf("Writing memory profile...\n") pprof.WriteHeapProfile(profFile) profFile.Close() }() } runtime.GOMAXPROCS(runtime.NumCPU()) logger := util.NewLogger(config) metrics := util.NewMetrics(config.Get( "metrics.prefix", "wmf"), logger, config) if err != nil { logger.Error("main", "Unable to connect to database. Have you configured it yet?", nil) return } if hawkCount := config.Get("hawk.nonce_cache", "1000"); hawkCount != "1000" { count, err := strconv.ParseInt(hawkCount, 10, 32) if err != nil { log.Printf("Could not read hawk.nonce_cache, defaulting to 1000") } else { wmf.InitHawkNonces(count) } } handlers := wmf.NewHandler(config, logger, metrics) if handlers == nil { log.Fatalf("Could not start server. Please check config.ini") } // Signal handler sigChan := make(chan os.Signal) signal.Notify(sigChan, syscall.SIGINT, syscall.SIGHUP, syscall.SIGUSR1) var RESTMux = http.DefaultServeMux var WSMux = http.DefaultServeMux var verRoot = strings.SplitN(VERSION, ".", 2)[0] // REST calls RESTMux.HandleFunc(fmt.Sprintf("/%s/register/", verRoot), handlers.Register) RESTMux.HandleFunc(fmt.Sprintf("/%s/cmd/", verRoot), handlers.Cmd) // Web UI calls RESTMux.HandleFunc(fmt.Sprintf("/%s/queue/", verRoot), handlers.RestQueue) RESTMux.HandleFunc(fmt.Sprintf("/%s/state/", verRoot), handlers.State) RESTMux.HandleFunc(fmt.Sprintf("/%s/l10n/client.json", verRoot), handlers.Language) // Static files (served by nginx in production) if config.GetFlag("use_insecure_static") { RESTMux.HandleFunc("/bower_components/", handlers.Static) RESTMux.HandleFunc("/images/", handlers.Static) RESTMux.HandleFunc("/scripts/", handlers.Static) RESTMux.HandleFunc("/styles/", handlers.Static) } // Metrics RESTMux.HandleFunc("/metrics/", handlers.Metrics) // Operations call RESTMux.HandleFunc("/status/", handlers.Status) //Signin // set state nonce & check if valid at signin RESTMux.HandleFunc("/signin/", handlers.Signin) //Signout RESTMux.HandleFunc("/signout/", handlers.Signout) // Config option because there are other teams involved. auth := config.Get("fxa.redir_uri", "/oauth/") RESTMux.HandleFunc(auth, handlers.OAuthCallback) WSMux.Handle(fmt.Sprintf("/%s/ws/", verRoot), websocket.Handler(handlers.WSSocketHandler)) // Handle root calls as webUI // Get a list of registered devices for the currently logged in user RESTMux.HandleFunc(fmt.Sprintf("/%s/devices/", verRoot), handlers.UserDevices) // Get an object describing the data for a user's device // e.g. http://host/0/data/0123deviceid RESTMux.HandleFunc(fmt.Sprintf("/%s/data/", verRoot), handlers.InitDataJson) RESTMux.HandleFunc(fmt.Sprintf("/%s/validate/", verRoot), handlers.Validate) RESTMux.HandleFunc("/", handlers.Index) logger.Info("main", "startup...", util.Fields{"host": host, "port": port, "version": fullVers}) go func() { errChan <- http.ListenAndServe(host+":"+port, nil) }() select { case err := <-errChan: if err != nil { log.Fatalf("ListenAndServe: " + err.Error()) } case <-sigChan: logger.Info("main", "Shutting down...", nil) } }