lbcd/btcd.go

154 lines
4 KiB
Go
Raw Normal View History

2014-01-01 17:16:15 +01:00
// Copyright (c) 2013-2014 Conformal Systems LLC.
2013-08-06 23:55:22 +02:00
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package main
import (
"fmt"
"github.com/conformal/btcd/limits"
2013-08-06 23:55:22 +02:00
"net"
"net/http"
_ "net/http/pprof"
2013-08-06 23:55:22 +02:00
"os"
"runtime"
"runtime/pprof"
2013-08-06 23:55:22 +02:00
)
var (
cfg *config
shutdownChannel = make(chan bool)
2013-08-06 23:55:22 +02:00
)
2014-01-11 05:32:05 +01:00
// winServiceMain is only invoked on Windows. It detects when btcd is running
// as a service and reacts accordingly.
var winServiceMain func() (bool, error)
2013-08-06 23:55:22 +02:00
// btcdMain is the real main function for btcd. It is necessary to work around
// the fact that deferred functions do not run when os.Exit() is called. The
// optional serverChan parameter is mainly used by the service code to be
// notified with the server once it is setup so it can gracefully stop it when
// requested from the service control manager.
func btcdMain(serverChan chan<- *server) error {
// Load configuration and parse command line. This function also
// initializes logging and configures it accordingly.
2013-08-06 23:55:22 +02:00
tcfg, _, err := loadConfig()
if err != nil {
return err
}
cfg = tcfg
defer backendLog.Flush()
2013-08-06 23:55:22 +02:00
2013-10-15 22:54:00 +02:00
// Show version at startup.
btcdLog.Infof("Version %s", version())
2013-10-15 22:54:00 +02:00
// Enable http profiling server if requested.
if cfg.Profile != "" {
go func() {
listenAddr := net.JoinHostPort("", cfg.Profile)
btcdLog.Infof("Profile server listening on %s", listenAddr)
profileRedirect := http.RedirectHandler("/debug/pprof",
http.StatusSeeOther)
http.Handle("/", profileRedirect)
btcdLog.Errorf("%v", http.ListenAndServe(listenAddr, nil))
}()
}
// Write cpu profile if requested.
if cfg.CpuProfile != "" {
f, err := os.Create(cfg.CpuProfile)
if err != nil {
btcdLog.Errorf("Unable to create cpu profile: %v", err)
return err
}
pprof.StartCPUProfile(f)
defer f.Close()
defer pprof.StopCPUProfile()
}
// Perform upgrades to btcd as new versions require it.
2013-10-08 02:24:44 +02:00
if err := doUpgrades(); err != nil {
btcdLog.Errorf("%v", err)
return err
}
2013-08-06 23:55:22 +02:00
// Load the block database.
db, err := loadBlockDB()
if err != nil {
btcdLog.Errorf("%v", err)
2013-08-06 23:55:22 +02:00
return err
}
defer db.Close()
// Ensure the database is sync'd and closed on Ctrl+C.
addInterruptHandler(func() {
btcdLog.Infof("Gracefully shutting down the database...")
2013-08-06 23:55:22 +02:00
db.RollbackClose()
})
// Create server and start it.
server, err := newServer(cfg.Listeners, db, activeNetParams.btcnet)
2013-08-06 23:55:22 +02:00
if err != nil {
// TODO(oga) this logging could do with some beautifying.
btcdLog.Errorf("Unable to start server on %v: %v",
cfg.Listeners, err)
2013-08-06 23:55:22 +02:00
return err
}
addInterruptHandler(func() {
btcdLog.Infof("Gracefully shutting down the server...")
server.Stop()
server.WaitForShutdown()
})
2013-08-06 23:55:22 +02:00
server.Start()
if serverChan != nil {
serverChan <- server
}
2013-08-06 23:55:22 +02:00
// Monitor for graceful server shutdown and signal the main goroutine
// when done. This is done in a separate goroutine rather than waiting
// directly so the main goroutine can be signaled for shutdown by either
// a graceful shutdown or from the main interrupt handler. This is
// necessary since the main goroutine must be kept running long enough
// for the interrupt handler goroutine to finish.
go func() {
server.WaitForShutdown()
srvrLog.Infof("Server shutdown complete")
shutdownChannel <- true
}()
// Wait for shutdown signal from either a graceful server stop or from
// the interrupt handler.
<-shutdownChannel
btcdLog.Info("Shutdown complete")
2013-08-06 23:55:22 +02:00
return nil
}
func main() {
// Use all processor cores.
runtime.GOMAXPROCS(runtime.NumCPU())
// Up some limits.
if err := limits.SetLimits(); err != nil {
os.Exit(1)
}
// Call serviceMain on Windows to handle running as a service. When
// the return isService flag is true, exit now since we ran as a
// service. Otherwise, just fall through to normal operation.
if runtime.GOOS == "windows" {
isService, err := winServiceMain()
if err != nil {
fmt.Println(err)
os.Exit(1)
}
if isService {
os.Exit(0)
}
}
2013-08-06 23:55:22 +02:00
// Work around defer not working after os.Exit()
if err := btcdMain(nil); err != nil {
2013-08-06 23:55:22 +02:00
os.Exit(1)
}
}