func realInit(w http.ResponseWriter, r *http.Request) bool {
ctx := appengine.NewContext(r)
errf := func(format string, args ...interface{}) bool {
ctx.Errorf("In init: "+format, args...)
http.Error(w, fmt.Sprintf(format, args...), 500)
return false
}
config, err := serverconfig.Load("./config.json")
if err != nil {
return errf("Could not load server config: %v", err)
}
// Update the config to use the URL path derived from the first App Engine request.
// TODO(bslatkin): Support hostnames that aren't x.appspot.com
scheme := "http"
if r.TLS != nil {
scheme = "https"
}
baseURL := fmt.Sprintf("%s://%s/", scheme, appengine.DefaultVersionHostname(ctx))
ctx.Infof("baseurl = %q", baseURL)
root.mux = http.NewServeMux()
_, err = config.InstallHandlers(root.mux, baseURL, r)
if err != nil {
return errf("Error installing handlers: %v", err)
}
return true
}
func main() {
flag.Parse()
if *flagVersion {
fmt.Fprintf(os.Stderr, "camlistored version: %s\n", buildinfo.Version())
return
}
fileName, err := findConfigFile(*flagConfigFile)
if err != nil {
exitf("Error finding config file %q: %v", fileName, err)
}
log.Printf("Using config file %s", fileName)
config, err := serverconfig.Load(fileName)
if err != nil {
exitf("Could not load server config: %v", err)
}
ws := webserver.New()
listen, baseURL := listenAndBaseURL(config)
setupTLS(ws, config, listen)
err = config.InstallHandlers(ws, baseURL, nil)
if err != nil {
exitf("Error parsing config: %v", err)
}
err = ws.Listen(listen)
if err != nil {
exitf("Listen: %v", err)
}
urlOpened := false
if config.UIPath != "" {
uiURL := ws.ListenURL() + config.UIPath
if baseURL != "" {
uiURL = baseURL + config.UIPath
}
log.Printf("UI available at %s", uiURL)
if runtime.GOOS == "windows" {
// Might be double-clicking an icon with no shell window?
// Just open the URL for them.
urlOpened = true
go osutil.OpenURL(uiURL)
}
}
if *flagConfigFile == "" && !urlOpened {
go osutil.OpenURL(ws.ListenURL())
}
go ws.Serve()
go handleSignals()
if flagPollParent {
osutil.DieOnParentDeath()
}
select {}
}
func main() {
flag.Parse()
if *flagVersion {
fmt.Fprintf(os.Stderr, "camlistored version: %s\n", buildinfo.Version())
return
}
shutdownc := make(chan io.Closer, 1) // receives io.Closer to cleanly shut down
go handleSignals(shutdownc)
fileName, isNewConfig, err := findConfigFile(*flagConfigFile)
if err != nil {
exitf("Error finding config file %q: %v", fileName, err)
}
log.Printf("Using config file %s", fileName)
config, err := serverconfig.Load(fileName)
if err != nil {
exitf("Could not load server config: %v", err)
}
ws := webserver.New()
listen, baseURL := listenAndBaseURL(config)
setupTLS(ws, config, listen)
shutdownCloser, err := config.InstallHandlers(ws, baseURL, nil)
if err != nil {
exitf("Error parsing config: %v", err)
}
shutdownc <- shutdownCloser
err = ws.Listen(listen)
if err != nil {
exitf("Listen: %v", err)
}
urlToOpen := ws.ListenURL()
if baseURL != "" {
urlToOpen = baseURL
}
if !isNewConfig {
// user may like to configure the server at the initial startup,
// open UI if this is not the first run with a new config file.
urlToOpen += config.UIPath
}
log.Printf("Available on %s", urlToOpen)
if *flagOpenBrowser {
go osutil.OpenURL(urlToOpen)
}
go ws.Serve()
if flagPollParent {
osutil.DieOnParentDeath()
}
select {}
}
func main() {
flag.Parse()
fileName, err := findConfigFile(*flagConfigFile)
if err != nil {
exitf("Error finding config file %q: %v", fileName, err)
}
log.Printf("Using config file %s", fileName)
config, err := serverconfig.Load(fileName)
if err != nil {
exitf("Could not load server config: %v", err)
}
ws := webserver.New()
baseURL := config.RequiredString("baseURL")
listen := *webserver.Listen
if listen == "" {
// if command line was empty, use value in config
listen = strings.TrimLeft(baseURL, "http://")
listen = strings.TrimLeft(listen, "https://")
} else {
// else command line takes precedence
scheme := strings.Split(baseURL, "://")[0]
baseURL = scheme + "://" + listen
}
setupTLS(ws, config, listen)
err = config.InstallHandlers(ws, baseURL, nil)
if err != nil {
exitf("Error parsing config: %v", err)
}
ws.Listen(listen)
urlOpened := false
if config.UIPath != "" {
uiURL := ws.BaseURL() + config.UIPath
log.Printf("UI available at %s", uiURL)
if runtime.GOOS == "windows" {
// Might be double-clicking an icon with no shell window?
// Just open the URL for them.
urlOpened = true
go osutil.OpenURL(uiURL)
}
}
if *flagConfigFile == "" && !urlOpened {
go func() {
err := osutil.OpenURL(baseURL)
if err != nil {
log.Printf("Failed to open %s in browser: %v", baseURL, err)
}
}()
}
go ws.Serve()
handleSignals()
}
func (c *reindexdpCmd) RunCommand(args []string) error {
var path string
switch {
case len(args) == 0:
cfg, err := serverconfig.Load(osutil.UserServerConfigPath())
if err != nil {
return err
}
prefixes, ok := cfg.Obj["prefixes"].(map[string]interface{})
if !ok {
return fmt.Errorf("No 'prefixes' object in low-level (or converted) config file %s", osutil.UserServerConfigPath())
}
paths := []string{}
for prefix, vei := range prefixes {
pmap, ok := vei.(map[string]interface{})
if !ok {
log.Printf("prefix %q value is a %T, not an object", prefix, vei)
continue
}
pconf := jsonconfig.Obj(pmap)
handlerType := pconf.RequiredString("handler")
handlerArgs := pconf.OptionalObject("handlerArgs")
// no pconf.Validate, as this is a recover tool
if handlerType != "storage-diskpacked" {
continue
}
if handlerArgs == nil {
log.Printf("no handlerArgs for %q", prefix)
continue
}
aconf := jsonconfig.Obj(handlerArgs)
path = aconf.RequiredString("path")
// no aconv.Validate, as this is a recover tool
if path != "" {
paths = append(paths, path)
}
}
if len(paths) == 0 {
return fmt.Errorf("Server config file %s doesn't specify a disk-packed storage handler.",
osutil.UserServerConfigPath())
}
if len(paths) > 1 {
return fmt.Errorf("Ambiguity. Server config file %s d specify more than 1 disk-packed storage handler. Please specify one of: %v", osutil.UserServerConfigPath(), paths)
}
path = paths[0]
case len(args) == 1:
path = args[0]
default:
return errors.New("More than 1 argument not allowed")
}
if path == "" {
return errors.New("no path is given/found")
}
return diskpacked.Reindex(path, c.overwrite)
}
func main() {
flag.Parse()
fileName, err := findConfigFile(*flagConfigFile)
if err != nil {
exitf("Error finding config file %q: %v", fileName, err)
}
log.Printf("Using config file %s", fileName)
config, err := serverconfig.Load(fileName)
if err != nil {
exitf("Could not load server config: %v", err)
}
ws := webserver.New()
listen, baseURL := listenAndBaseURL(config)
setupTLS(ws, config, listen)
err = config.InstallHandlers(ws, baseURL, nil)
if err != nil {
exitf("Error parsing config: %v", err)
}
err = ws.Listen(listen)
if err != nil {
exitf("Listen: %v", err)
}
urlOpened := false
if config.UIPath != "" {
uiURL := ws.ListenURL() + config.UIPath
log.Printf("UI available at %s", uiURL)
if runtime.GOOS == "windows" {
// Might be double-clicking an icon with no shell window?
// Just open the URL for them.
urlOpened = true
go osutil.OpenURL(uiURL)
}
}
if *flagConfigFile == "" && !urlOpened {
go func() {
err := osutil.OpenURL(ws.ListenURL())
if err != nil {
log.Printf("Failed to open %s in browser: %v", baseURL, err)
}
}()
}
go ws.Serve()
go handleSignals()
select {}
}
func (c *reindexdpCmd) RunCommand(args []string) error {
var path string
switch {
case len(args) == 0:
cfg, err := serverconfig.Load(osutil.UserServerConfigPath())
if err != nil {
return err
}
prefixes := cfg.RequiredObject("prefixes")
if err := cfg.Validate(); err != nil {
return fmt.Errorf("configuration error in root object's keys: %v", err)
}
for prefix, vei := range prefixes {
pmap, ok := vei.(map[string]interface{})
if !ok {
log.Printf("prefix %q value is a %T, not an object", prefix, vei)
continue
}
pconf := jsonconfig.Obj(pmap)
handlerType := pconf.RequiredString("handler")
handlerArgs := pconf.OptionalObject("handlerArgs")
// no pconf.Validate, as this is a recover tool
if handlerType != "storage-diskpacked" {
continue
}
if handlerArgs == nil {
log.Printf("no handlerArgs for %q", prefix)
continue
}
aconf := jsonconfig.Obj(handlerArgs)
path = aconf.RequiredString("path")
// no aconv.Validate, as this is a recover tool
if path != "" {
break
}
}
case len(args) == 1:
path = args[0]
default:
return errors.New("More than 1 argument not allowed")
}
if path == "" {
return errors.New("no path is given/found")
}
return diskpacked.Reindex(path, c.overwrite)
}
func (c *dumpconfigCmd) RunCommand(args []string) error {
var file string
switch {
case len(args) == 0:
file = osutil.UserServerConfigPath()
case len(args) == 1:
file = args[0]
default:
return errors.New("More than 1 argument not allowed")
}
cfg, err := serverconfig.Load(file)
if err != nil {
return err
}
ll, err := json.MarshalIndent(cfg.Obj, "", " ")
if err != nil {
return err
}
_, err = os.Stdout.Write(ll)
return err
}
// Main sends on up when it's running, and shuts down when it receives from down.
func Main(up chan<- struct{}, down <-chan struct{}) {
flag.Parse()
if *flagVersion {
fmt.Fprintf(os.Stderr, "camlistored version: %s\nGo version: %s (%s/%s)\n",
buildinfo.Version(), runtime.Version(), runtime.GOOS, runtime.GOARCH)
return
}
if *flagReindex {
index.SetImpendingReindex()
}
log.Printf("Starting camlistored version %s; Go %s (%s/%s)", buildinfo.Version(), runtime.Version(),
runtime.GOOS, runtime.GOARCH)
shutdownc := make(chan io.Closer, 1) // receives io.Closer to cleanly shut down
go handleSignals(shutdownc)
fileName, isNewConfig, err := findConfigFile(*flagConfigFile)
if err != nil {
exitf("Error finding config file %q: %v", fileName, err)
}
log.Printf("Using config file %s", fileName)
config, err := serverconfig.Load(fileName)
if err != nil {
exitf("Could not load server config: %v", err)
}
ws := webserver.New()
listen, baseURL := listenAndBaseURL(config)
setupTLS(ws, config, listen)
err = ws.Listen(listen)
if err != nil {
exitf("Listen: %v", err)
}
if baseURL == "" {
baseURL = ws.ListenURL()
}
shutdownCloser, err := config.InstallHandlers(ws, baseURL, *flagReindex, nil)
if err != nil {
exitf("Error parsing config: %v", err)
}
shutdownc <- shutdownCloser
urlToOpen := baseURL
if !isNewConfig {
// user may like to configure the server at the initial startup,
// open UI if this is not the first run with a new config file.
urlToOpen += config.UIPath
}
log.Printf("Available on %s", urlToOpen)
if *flagOpenBrowser {
go osutil.OpenURL(urlToOpen)
}
go ws.Serve()
if flagPollParent {
osutil.DieOnParentDeath()
}
// Block forever, except during tests.
up <- struct{}{}
<-down
osExit(0)
}