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)
}
}