func main() {
flag.Parse()
if *flagVersion {
fmt.Fprintf(os.Stderr, "hello version: %s\nGo version: %s (%s/%s)\n",
buildinfo.Version(), runtime.Version(), runtime.GOOS, runtime.GOARCH)
return
}
log.Printf("Starting hello version %s; Go %s (%s/%s)", buildinfo.Version(), runtime.Version(),
runtime.GOOS, runtime.GOARCH)
listenAddr, err := app.ListenAddress()
if err != nil {
log.Fatalf("Listen address: %v", err)
}
conf := appConfig()
ws := webserver.New()
ws.Handle("/", &helloHandler{who: conf.Word})
// TODO(mpl): handle status requests too. Camlistore will send an auth
// token in the extra config that should be used as the "password" for
// subsequent status requests.
if err := ws.Listen(listenAddr); err != nil {
log.Fatalf("Listen: %v", err)
}
ws.Serve()
}
func main() {
flag.Parse()
if *flagVersion {
fmt.Fprintf(os.Stderr, "publisher version: %s\nGo version: %s (%s/%s)\n",
buildinfo.Version(), runtime.Version(), runtime.GOOS, runtime.GOARCH)
return
}
logf("Starting publisher version %s; Go %s (%s/%s)", buildinfo.Version(), runtime.Version(),
runtime.GOOS, runtime.GOARCH)
listenAddr, err := app.ListenAddress()
if err != nil {
logger.Fatalf("Listen address: %v", err)
}
conf := appConfig()
ph := newPublishHandler(conf)
if err := ph.initRootNode(); err != nil {
logf("%v", err)
}
ws := webserver.New()
ws.Logger = logger
ws.Handle("/", ph)
if conf.HTTPSCert != "" && conf.HTTPSKey != "" {
ws.SetTLS(conf.HTTPSCert, conf.HTTPSKey)
}
if err := ws.Listen(listenAddr); err != nil {
logger.Fatalf("Listen: %v", err)
}
ws.Serve()
}
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()
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()
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 main() {
flag.Parse()
_, err := auth.FromEnv()
if err != nil {
log.Fatal(err)
}
ws := webserver.New()
ws.HandleFunc("/", handleRoot)
ws.HandleFunc("/camli/sig/", handleCamliSig)
ws.Serve()
}
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 main() {
flag.Parse()
if *flagVersion {
fmt.Fprintf(os.Stderr, "publisher version: %s\nGo version: %s (%s/%s)\n",
buildinfo.Version(), runtime.Version(), runtime.GOOS, runtime.GOARCH)
return
}
logf("Starting publisher version %s; Go %s (%s/%s)", buildinfo.Version(), runtime.Version(),
runtime.GOOS, runtime.GOARCH)
listenAddr, err := app.ListenAddress()
if err != nil {
logger.Fatalf("Listen address: %v", err)
}
conf, err := appConfig()
if err != nil {
logger.Fatalf("no app config: %v", err)
}
ph := newPublishHandler(conf)
masterQueryURL := os.Getenv("CAMLI_APP_MASTERQUERY_URL")
if masterQueryURL == "" {
logger.Fatalf("Publisher application needs a CAMLI_APP_MASTERQUERY_URL env var")
}
ph.masterQueryURL = masterQueryURL
if err := ph.initRootNode(); err != nil {
logf("%v", err)
} else {
if err := ph.setMasterQuery(ph.rootNode); err != nil {
logf("%v", err)
}
}
ws := webserver.New()
ws.Logger = logger
if err := setupTLS(ws, conf); err != nil {
logger.Fatal("could not setup TLS: %v", err)
}
ws.Handle("/", ph)
if err := ws.Listen(listenAddr); err != nil {
logger.Fatalf("Listen: %v", err)
}
ws.Serve()
}
// 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 legalprint.MaybePrint(os.Stderr) {
return
}
if env.OnGCE() {
log.SetOutput(gce.LogWriter())
}
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)
// In case we're running in a Docker container with no
// filesytem from which to load the root CAs, this
// conditionally installs a static set if necessary. We do
// this before we load the config file, which might come from
// an https URL.
httputil.InstallCerts()
config, isNewConfig, err := loadConfig(*flagConfigFile)
if err != nil {
exitf("Error loading config file: %v", err)
}
ws := webserver.New()
listen, baseURL := listenAndBaseURL(config)
hostname, err := certHostname(listen, baseURL)
if err != nil {
exitf("Bad baseURL or listen address: %v", err)
}
setupTLS(ws, config, hostname)
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
}
if *flagOpenBrowser {
go osutil.OpenURL(urlToOpen)
}
go ws.Serve()
if flagPollParent {
osutil.DieOnParentDeath()
}
if err := config.StartApps(); err != nil {
exitf("StartApps: %v", err)
}
for appName, appURL := range config.AppURL() {
addr, err := netutil.HostPort(appURL)
if err != nil {
log.Printf("Could not get app %v address: %v", appName, err)
continue
}
if err := netutil.AwaitReachable(addr, 5*time.Second); err != nil {
log.Printf("Could not reach app %v: %v", appName, err)
}
}
log.Printf("Available on %s", urlToOpen)
if env.OnGCE() && strings.HasPrefix(baseURL, "https://") {
go redirectFromHTTP(baseURL)
}
// Block forever, except during tests.
up <- struct{}{}
<-down
osExit(0)
}
// 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 := serverinit.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)
}