func (app *Application) Start() {
address := Config.GetString("Address")
port := Config.GetInt("Port")
debug := Config.GetBool("Debug")
tmplPath := Config.GetString("TemplatePath")
listen := fmt.Sprintf("%s:%d", address, port)
templates = loadTemplate()
watcher = NewWatcher()
watcher.Listen(tmplPath)
mux := http.NewServeMux()
if debug {
mux.Handle("/debug/pprof", http.HandlerFunc(pprof.Index))
mux.Handle("/debug/pprof/cmdline", http.HandlerFunc(pprof.Cmdline))
mux.Handle("/debug/pprof/profile", http.HandlerFunc(pprof.Profile))
mux.Handle("/debug/pprof/symbol", http.HandlerFunc(pprof.Symbol))
mux.Handle("/debug/pprof/heap", pprof.Handler("heap"))
mux.Handle("/debug/pprof/block", pprof.Handler("block"))
mux.Handle("/debug/pprof/goroutine", pprof.Handler("goroutine"))
mux.Handle("/debug/pprof/threadcreate", pprof.Handler("threadcreate"))
}
mux.Handle("/", app.Route)
l, err := net.Listen("tcp", listen)
if err != nil {
log.Fatal(err)
}
log.Println("Listening on " + listen + "...")
log.Fatal(http.Serve(l, mux))
}
func (s *httpServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
switch req.URL.Path {
case "/registration":
s.registerHandler(w, req)
case "/ping":
s.pingHandler(w, req)
case "/info":
s.infoHandler(w, req)
case "/debug/pprof":
httpprof.Index(w, req)
case "/debug/pprof/cmdline":
httpprof.Cmdline(w, req)
case "/debug/pprof/symbol":
httpprof.Symbol(w, req)
case "/debug/pprof/heap":
httpprof.Handler("heap").ServeHTTP(w, req)
case "/debug/pprof/goroutine":
httpprof.Handler("goroutine").ServeHTTP(w, req)
case "/debug/pprof/profile":
httpprof.Profile(w, req)
case "/debug/pprof/block":
httpprof.Handler("block").ServeHTTP(w, req)
case "/debug/pprof/threadcreate":
httpprof.Handler("threadcreate").ServeHTTP(w, req)
default:
log.Printf("ERROR: 404 %s", req.URL.Path)
util.ApiResponse(w, 404, "NOT_FOUND", nil)
}
}
// Run starts the web application and serves HTTP requests for s
func (s *Server) Run(addr string) {
s.initServer()
if s.muxrouter == nil {
s.muxrouter = mux.NewRouter()
}
if s.Config.Profiler {
s.muxrouter.Handle("/debug/pprof", http.HandlerFunc(pprof.Index))
s.muxrouter.Handle("/debug/pprof/cmdline", http.HandlerFunc(pprof.Cmdline))
s.muxrouter.Handle("/debug/pprof/profile", http.HandlerFunc(pprof.Profile))
s.muxrouter.Handle("/debug/pprof/symbol", http.HandlerFunc(pprof.Symbol))
s.muxrouter.Handle("/debug/pprof/heap", pprof.Handler("heap"))
s.muxrouter.Handle("/debug/pprof/goroutine", pprof.Handler("goroutine"))
s.muxrouter.Handle("/debug/pprof/threadcreate", pprof.Handler("threadcreate"))
s.muxrouter.Handle("/debug/pprof/block", pprof.Handler("block"))
}
s.muxrouter.Handle("/", s)
s.Logger.Printf("serving %s\n", addr)
l, err := net.Listen("tcp", addr)
if err != nil {
log.Fatal("ListenAndServe:", err)
}
s.l = l
err = http.Serve(s.l, s.muxrouter)
s.l.Close()
}
func main() {
doProfile := flag.Bool("profile", false, "profile app")
flag.Parse()
go cpu.Monitor()
go net.Monitor("eth0")
r := martini.Classic()
r.Get("/containers/:id/mem", containerMemUsageHandler)
r.Get("/containers/:id/cpu", containerCpuUsageHandler)
r.Get("/containers/:id/net", containerNetUsageHandler)
if *doProfile {
log.Println("Enable profiling")
r.Get("/debug/pprof", pprof.Index)
r.Get("/debug/pprof/cmdline", pprof.Cmdline)
r.Get("/debug/pprof/profile", pprof.Profile)
r.Get("/debug/pprof/symbol", pprof.Symbol)
r.Post("/debug/pprof/symbol", pprof.Symbol)
r.Get("/debug/pprof/block", pprof.Handler("block").ServeHTTP)
r.Get("/debug/pprof/heap", pprof.Handler("heap").ServeHTTP)
r.Get("/debug/pprof/goroutine", pprof.Handler("goroutine").ServeHTTP)
r.Get("/debug/pprof/threadcreate", pprof.Handler("threadcreate").ServeHTTP)
}
r.Run()
}
func (s *httpServer) debugRouter(w http.ResponseWriter, req *http.Request) error {
switch req.URL.Path {
case "/debug":
util.NegotiateAPIResponseWrapper(w, req,
func() (interface{}, error) { return s.doDebug(req) })
case "/debug/pprof":
httpprof.Index(w, req)
case "/debug/pprof/cmdline":
httpprof.Cmdline(w, req)
case "/debug/pprof/symbol":
httpprof.Symbol(w, req)
case "/debug/pprof/heap":
httpprof.Handler("heap").ServeHTTP(w, req)
case "/debug/pprof/goroutine":
httpprof.Handler("goroutine").ServeHTTP(w, req)
case "/debug/pprof/profile":
httpprof.Profile(w, req)
case "/debug/pprof/block":
httpprof.Handler("block").ServeHTTP(w, req)
case "/debug/pprof/threadcreate":
httpprof.Handler("threadcreate").ServeHTTP(w, req)
default:
return errors.New(fmt.Sprintf("404 %s", req.URL.Path))
}
return nil
}
// RegisterDebug adds handlers for /debug/vars (expvar) and /debug/pprof (net/http/pprof) support
func (this *HttpWeb) RegisterDebug(m *martini.ClassicMartini) {
m.Get("/debug/vars", func(w http.ResponseWriter, r *http.Request) {
// from expvar.go, since the expvarHandler isn't exported :(
w.Header().Set("Content-Type", "application/json; charset=utf-8")
fmt.Fprintf(w, "{\n")
first := true
expvar.Do(func(kv expvar.KeyValue) {
if !first {
fmt.Fprintf(w, ",\n")
}
first = false
fmt.Fprintf(w, "%q: %s", kv.Key, kv.Value)
})
fmt.Fprintf(w, "\n}\n")
})
// list all the /debug/ endpoints we want
m.Get("/debug/pprof", pprof.Index)
m.Get("/debug/pprof/cmdline", pprof.Cmdline)
m.Get("/debug/pprof/profile", pprof.Profile)
m.Get("/debug/pprof/symbol", pprof.Symbol)
m.Post("/debug/pprof/symbol", pprof.Symbol)
m.Get("/debug/pprof/block", pprof.Handler("block").ServeHTTP)
m.Get("/debug/pprof/heap", pprof.Handler("heap").ServeHTTP)
m.Get("/debug/pprof/goroutine", pprof.Handler("goroutine").ServeHTTP)
m.Get("/debug/pprof/threadcreate", pprof.Handler("threadcreate").ServeHTTP)
}
func newHTTPServer(ctx *Context) *httpServer {
log := http_api.Log(nsqlookupLog)
// debug log only print when error or the level is larger than debug.
debugLog := http_api.DebugLog(nsqlookupLog)
router := httprouter.New()
router.HandleMethodNotAllowed = true
router.PanicHandler = http_api.LogPanicHandler(nsqlookupLog)
router.NotFound = http_api.LogNotFoundHandler(nsqlookupLog)
router.MethodNotAllowed = http_api.LogMethodNotAllowedHandler(nsqlookupLog)
s := &httpServer{
ctx: ctx,
router: router,
}
router.Handle("GET", "/ping", http_api.Decorate(s.pingHandler, log, http_api.PlainText))
// v1 negotiate
router.Handle("GET", "/debug", http_api.Decorate(s.doDebug, log, http_api.NegotiateVersion))
router.Handle("GET", "/lookup", http_api.Decorate(s.doLookup, debugLog, http_api.NegotiateVersion))
router.Handle("GET", "/topics", http_api.Decorate(s.doTopics, log, http_api.NegotiateVersion))
router.Handle("GET", "/channels", http_api.Decorate(s.doChannels, log, http_api.NegotiateVersion))
router.Handle("GET", "/nodes", http_api.Decorate(s.doNodes, log, http_api.NegotiateVersion))
router.Handle("GET", "/listlookup", http_api.Decorate(s.doListLookup, log, http_api.NegotiateVersion))
router.Handle("GET", "/cluster/stats", http_api.Decorate(s.doClusterStats, debugLog, http_api.V1))
router.Handle("POST", "/cluster/node/remove", http_api.Decorate(s.doRemoveClusterDataNode, log, http_api.V1))
router.Handle("POST", "/cluster/upgrade/begin", http_api.Decorate(s.doClusterBeginUpgrade, log, http_api.V1))
router.Handle("POST", "/cluster/upgrade/done", http_api.Decorate(s.doClusterFinishUpgrade, log, http_api.V1))
router.Handle("POST", "/cluster/lookupd/tombstone", http_api.Decorate(s.doClusterTombstoneLookupd, log, http_api.V1))
// only v1
router.Handle("POST", "/loglevel/set", http_api.Decorate(s.doSetLogLevel, log, http_api.V1))
router.Handle("POST", "/topic/create", http_api.Decorate(s.doCreateTopic, log, http_api.V1))
router.Handle("PUT", "/topic/create", http_api.Decorate(s.doCreateTopic, log, http_api.V1))
router.Handle("POST", "/topic/delete", http_api.Decorate(s.doDeleteTopic, log, http_api.V1))
router.Handle("POST", "/topic/partition/expand", http_api.Decorate(s.doChangeTopicPartitionNum, log, http_api.V1))
router.Handle("POST", "/topic/partition/move", http_api.Decorate(s.doMoveTopicParition, log, http_api.V1))
router.Handle("POST", "/topic/meta/update", http_api.Decorate(s.doChangeTopicDynamicParam, log, http_api.V1))
//router.Handle("POST", "/channel/create", http_api.Decorate(s.doCreateChannel, log, http_api.V1))
//router.Handle("POST", "/channel/delete", http_api.Decorate(s.doDeleteChannel, log, http_api.V1))
router.Handle("POST", "/topic/tombstone", http_api.Decorate(s.doTombstoneTopicProducer, log, http_api.V1))
router.Handle("GET", "/info", http_api.Decorate(s.doInfo, log, http_api.NegotiateVersion))
// debug
router.HandlerFunc("GET", "/debug/pprof", pprof.Index)
router.HandlerFunc("GET", "/debug/pprof/cmdline", pprof.Cmdline)
router.HandlerFunc("GET", "/debug/pprof/symbol", pprof.Symbol)
router.HandlerFunc("POST", "/debug/pprof/symbol", pprof.Symbol)
router.HandlerFunc("GET", "/debug/pprof/profile", pprof.Profile)
router.HandlerFunc("GET", "/debug/pprof/trace", pprof.Trace)
router.Handler("GET", "/debug/pprof/heap", pprof.Handler("heap"))
router.Handler("GET", "/debug/pprof/goroutine", pprof.Handler("goroutine"))
router.Handler("GET", "/debug/pprof/block", pprof.Handler("block"))
router.Handle("PUT", "/debug/setblockrate", http_api.Decorate(HandleBlockRate, log, http_api.PlainText))
router.Handler("GET", "/debug/pprof/threadcreate", pprof.Handler("threadcreate"))
return s
}
func AttachProfiler(router *mux.Router) {
router.HandleFunc("/debug/pprof/", pprof.Index)
router.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
router.HandleFunc("/debug/pprof/profile", pprof.Profile)
router.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
router.HandleFunc("/debug/pprof/heap", pprof.Handler("heap").ServeHTTP)
router.HandleFunc("/debug/pprof/goroutine", pprof.Handler("goroutine").ServeHTTP)
router.HandleFunc("/debug/pprof/threadcreate", pprof.Handler("threadcreate").ServeHTTP)
}
func (s *httpServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
switch req.URL.Path {
case "/pub":
fallthrough
case "/put":
s.putHandler(w, req)
case "/mpub":
fallthrough
case "/mput":
s.mputHandler(w, req)
case "/stats":
s.statsHandler(w, req)
case "/ping":
s.pingHandler(w, req)
case "/info":
s.infoHandler(w, req)
case "/empty_topic":
s.emptyTopicHandler(w, req)
case "/delete_topic":
s.deleteTopicHandler(w, req)
case "/pause_topic":
s.pauseTopicHandler(w, req)
case "/unpause_topic":
s.pauseTopicHandler(w, req)
case "/empty_channel":
s.emptyChannelHandler(w, req)
case "/delete_channel":
s.deleteChannelHandler(w, req)
case "/pause_channel":
s.pauseChannelHandler(w, req)
case "/unpause_channel":
s.pauseChannelHandler(w, req)
case "/create_topic":
s.createTopicHandler(w, req)
case "/create_channel":
s.createChannelHandler(w, req)
case "/debug/pprof":
httpprof.Index(w, req)
case "/debug/pprof/cmdline":
httpprof.Cmdline(w, req)
case "/debug/pprof/symbol":
httpprof.Symbol(w, req)
case "/debug/pprof/heap":
httpprof.Handler("heap").ServeHTTP(w, req)
case "/debug/pprof/goroutine":
httpprof.Handler("goroutine").ServeHTTP(w, req)
case "/debug/pprof/profile":
httpprof.Profile(w, req)
case "/debug/pprof/block":
httpprof.Handler("block").ServeHTTP(w, req)
case "/debug/pprof/threadcreate":
httpprof.Handler("threadcreate").ServeHTTP(w, req)
default:
log.Printf("ERROR: 404 %s", req.URL.Path)
util.ApiResponse(w, 404, "NOT_FOUND", nil)
}
}
func main() {
log.Println("Starting go-sig/web")
if path := os.Getenv("IMG_PATH"); path != "" {
imageRoot = path
}
log.Printf("Using image root: %s", imageRoot)
if _, err := os.Stat(imageRoot); os.IsNotExist(err) {
os.MkdirAll(imageRoot, 0750)
}
if procs := os.Getenv("PROCS"); procs != "" {
if p, err := strconv.Atoi(procs); err != nil {
runtime.GOMAXPROCS(p)
}
}
if key := os.Getenv("AES_KEY"); key != "" {
util.AES_KEY = []byte(key)
}
disableLogging := os.Getenv("DISABLE_LOGGING")
if disableLogging == "1" || disableLogging == "true" {
log.SetOutput(new(NullWriter))
}
// Routes
log.Println("Mapping routes...")
goji.Get("/", index)
// Setup static files
static := web.New()
static.Get("/assets/*", http.StripPrefix("/assets/", http.FileServer(http.Dir(publicPath))))
http.Handle("/assets/", static)
profile := os.Getenv("ENABLE_DEBUG")
if profile == "1" || profile == "true" {
log.Println("Mapping debug routes...")
goji.Handle("/debug/pprof/", pprof.Index)
goji.Handle("/debug/pprof/cmdline", pprof.Cmdline)
goji.Handle("/debug/pprof/profile", pprof.Profile)
goji.Handle("/debug/pprof/symbol", pprof.Symbol)
goji.Handle("/debug/pprof/block", pprof.Handler("block").ServeHTTP)
goji.Handle("/debug/pprof/heap", pprof.Handler("heap").ServeHTTP)
goji.Handle("/debug/pprof/goroutine", pprof.Handler("goroutine").ServeHTTP)
goji.Handle("/debug/pprof/threadcreate", pprof.Handler("threadcreate").ServeHTTP)
}
// Generators
log.Println("Registering generators...")
registerGenerator(new(rs3.BoxGoalGenerator))
registerGenerator(new(multi.MultiGoalGenerator))
//registerGenerator(new(rs3.ExampleGenerator))
// Serve
goji.Serve()
}
func newHTTPServer(ctx *context, tlsEnabled bool, tlsRequired bool) *httpServer {
log := http_api.Log(nsqd.NsqLogger())
router := httprouter.New()
router.HandleMethodNotAllowed = true
router.PanicHandler = http_api.LogPanicHandler(nsqd.NsqLogger())
router.NotFound = http_api.LogNotFoundHandler(nsqd.NsqLogger())
router.MethodNotAllowed = http_api.LogMethodNotAllowedHandler(nsqd.NsqLogger())
s := &httpServer{
ctx: ctx,
tlsEnabled: tlsEnabled,
tlsRequired: tlsRequired,
router: router,
}
router.Handle("GET", "/ping", http_api.Decorate(s.pingHandler, log, http_api.PlainText))
router.Handle("POST", "/loglevel/set", http_api.Decorate(s.doSetLogLevel, log, http_api.V1))
router.Handle("GET", "/info", http_api.Decorate(s.doInfo, log, http_api.NegotiateVersion))
// v1 negotiate
router.Handle("POST", "/pub", http_api.Decorate(s.doPUB, http_api.NegotiateVersion))
router.Handle("POST", "/pubtrace", http_api.Decorate(s.doPUBTrace, http_api.V1))
router.Handle("POST", "/mpub", http_api.Decorate(s.doMPUB, http_api.NegotiateVersion))
router.Handle("GET", "/stats", http_api.Decorate(s.doStats, log, http_api.NegotiateVersion))
router.Handle("GET", "/coordinator/stats", http_api.Decorate(s.doCoordStats, log, http_api.V1))
router.Handle("GET", "/message/stats", http_api.Decorate(s.doMessageStats, log, http_api.V1))
router.Handle("GET", "/message/historystats", http_api.Decorate(s.doMessageHistoryStats, log, http_api.V1))
router.Handle("POST", "/message/trace/enable", http_api.Decorate(s.enableMessageTrace, log, http_api.V1))
router.Handle("POST", "/message/trace/disable", http_api.Decorate(s.disableMessageTrace, log, http_api.V1))
router.Handle("POST", "/channel/pause", http_api.Decorate(s.doPauseChannel, log, http_api.V1))
router.Handle("POST", "/channel/unpause", http_api.Decorate(s.doPauseChannel, log, http_api.V1))
router.Handle("POST", "/channel/create", http_api.Decorate(s.doCreateChannel, log, http_api.V1))
router.Handle("POST", "/channel/delete", http_api.Decorate(s.doDeleteChannel, log, http_api.V1))
router.Handle("POST", "/channel/empty", http_api.Decorate(s.doEmptyChannel, log, http_api.V1))
router.Handle("POST", "/channel/setoffset", http_api.Decorate(s.doSetChannelOffset, log, http_api.V1))
router.Handle("POST", "/channel/setorder", http_api.Decorate(s.doSetChannelOrder, log, http_api.V1))
router.Handle("GET", "/config/:opt", http_api.Decorate(s.doConfig, log, http_api.V1))
router.Handle("PUT", "/config/:opt", http_api.Decorate(s.doConfig, log, http_api.V1))
//router.Handle("POST", "/topic/delete", http_api.Decorate(s.doDeleteTopic, http_api.DeprecatedAPI, log, http_api.V1))
// debug
router.HandlerFunc("GET", "/debug/pprof/", pprof.Index)
router.HandlerFunc("GET", "/debug/pprof/cmdline", pprof.Cmdline)
router.HandlerFunc("GET", "/debug/pprof/symbol", pprof.Symbol)
router.HandlerFunc("POST", "/debug/pprof/symbol", pprof.Symbol)
router.HandlerFunc("GET", "/debug/pprof/profile", pprof.Profile)
router.HandlerFunc("GET", "/debug/pprof/trace", pprof.Trace)
router.Handler("GET", "/debug/pprof/heap", pprof.Handler("heap"))
router.Handler("GET", "/debug/pprof/goroutine", pprof.Handler("goroutine"))
router.Handler("GET", "/debug/pprof/block", pprof.Handler("block"))
router.Handle("PUT", "/debug/setblockrate", http_api.Decorate(setBlockRateHandler, log, http_api.V1))
router.Handler("GET", "/debug/pprof/threadcreate", pprof.Handler("threadcreate"))
return s
}
func registerProfilerController(router *mux.Router) {
router.HandleFunc("/debug/pprof/", pprof.Index)
router.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
router.HandleFunc("/debug/pprof/profile", pprof.Profile)
router.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
router.Handle("/debug/pprof/goroutine", pprof.Handler("goroutine"))
router.Handle("/debug/pprof/heap", pprof.Handler("heap"))
router.Handle("/debug/pprof/threadcreate", pprof.Handler("threadcreate"))
router.Handle("/debug/pprof/block", pprof.Handler("block"))
}
func newHTTPServer(ctx *Context) *httpServer {
log := http_api.Log(ctx.nsqlookupd.opts.Logger)
router := httprouter.New()
router.HandleMethodNotAllowed = true
router.PanicHandler = http_api.LogPanicHandler(ctx.nsqlookupd.opts.Logger)
router.NotFound = http_api.LogNotFoundHandler(ctx.nsqlookupd.opts.Logger)
router.MethodNotAllowed = http_api.LogMethodNotAllowedHandler(ctx.nsqlookupd.opts.Logger)
s := &httpServer{
ctx: ctx,
router: router,
}
router.Handle("GET", "/ping", http_api.Decorate(s.pingHandler, log, http_api.PlainText))
// v1 negotiate
router.Handle("GET", "/debug", http_api.Decorate(s.doDebug, log, http_api.NegotiateVersion))
router.Handle("GET", "/lookup", http_api.Decorate(s.doLookup, log, http_api.NegotiateVersion))
router.Handle("GET", "/topics", http_api.Decorate(s.doTopics, log, http_api.NegotiateVersion))
router.Handle("GET", "/channels", http_api.Decorate(s.doChannels, log, http_api.NegotiateVersion))
router.Handle("GET", "/nodes", http_api.Decorate(s.doNodes, log, http_api.NegotiateVersion))
// only v1
router.Handle("POST", "/topic/create", http_api.Decorate(s.doCreateTopic, log, http_api.V1))
router.Handle("POST", "/topic/delete", http_api.Decorate(s.doDeleteTopic, log, http_api.V1))
router.Handle("POST", "/channel/create", http_api.Decorate(s.doCreateChannel, log, http_api.V1))
router.Handle("POST", "/channel/delete", http_api.Decorate(s.doDeleteChannel, log, http_api.V1))
router.Handle("POST", "/topic/tombstone", http_api.Decorate(s.doTombstoneTopicProducer, log, http_api.V1))
// deprecated, v1 negotiate
router.Handle("GET", "/info", http_api.Decorate(s.doInfo, log, http_api.NegotiateVersion))
router.Handle("POST", "/create_topic", http_api.Decorate(s.doCreateTopic, log, http_api.NegotiateVersion))
router.Handle("POST", "/delete_topic", http_api.Decorate(s.doDeleteTopic, log, http_api.NegotiateVersion))
router.Handle("POST", "/create_channel", http_api.Decorate(s.doCreateChannel, log, http_api.NegotiateVersion))
router.Handle("POST", "/delete_channel", http_api.Decorate(s.doDeleteChannel, log, http_api.NegotiateVersion))
router.Handle("POST", "/tombstone_topic_producer", http_api.Decorate(s.doTombstoneTopicProducer, log, http_api.NegotiateVersion))
router.Handle("GET", "/create_topic", http_api.Decorate(s.doCreateTopic, log, http_api.NegotiateVersion))
router.Handle("GET", "/delete_topic", http_api.Decorate(s.doDeleteTopic, log, http_api.NegotiateVersion))
router.Handle("GET", "/create_channel", http_api.Decorate(s.doCreateChannel, log, http_api.NegotiateVersion))
router.Handle("GET", "/delete_channel", http_api.Decorate(s.doDeleteChannel, log, http_api.NegotiateVersion))
router.Handle("GET", "/tombstone_topic_producer", http_api.Decorate(s.doTombstoneTopicProducer, log, http_api.NegotiateVersion))
// debug
router.HandlerFunc("GET", "/debug/pprof", pprof.Index)
router.HandlerFunc("GET", "/debug/pprof/cmdline", pprof.Cmdline)
router.HandlerFunc("GET", "/debug/pprof/symbol", pprof.Symbol)
router.HandlerFunc("POST", "/debug/pprof/symbol", pprof.Symbol)
router.HandlerFunc("GET", "/debug/pprof/profile", pprof.Profile)
router.Handler("GET", "/debug/pprof/heap", pprof.Handler("heap"))
router.Handler("GET", "/debug/pprof/goroutine", pprof.Handler("goroutine"))
router.Handler("GET", "/debug/pprof/block", pprof.Handler("block"))
router.Handler("GET", "/debug/pprof/threadcreate", pprof.Handler("threadcreate"))
return s
}
func Enable(address string) {
http.Handle("/", http.RedirectHandler("/debug/pprof", http.StatusMovedPermanently))
http.Handle("/debug/pprof/block", pprof.Handler("block"))
http.Handle("/debug/pprof/heap", pprof.Handler("heap"))
http.Handle("/debug/pprof/goroutine", pprof.Handler("goroutine"))
http.Handle("/debug/pprof/threadcreate", pprof.Handler("threadcreate"))
go http.ListenAndServe(address, nil)
logrus.Debug("pprof listening in address %s", address)
}
func profilerSetup(mainRouter *mux.Router) {
var r = mainRouter.PathPrefix(debugPathPrefix).Subrouter()
r.HandleFunc("/vars", expVars)
r.HandleFunc("/pprof/", pprof.Index)
r.HandleFunc("/pprof/cmdline", pprof.Cmdline)
r.HandleFunc("/pprof/profile", pprof.Profile)
r.HandleFunc("/pprof/symbol", pprof.Symbol)
r.HandleFunc("/pprof/block", pprof.Handler("block").ServeHTTP)
r.HandleFunc("/pprof/heap", pprof.Handler("heap").ServeHTTP)
r.HandleFunc("/pprof/goroutine", pprof.Handler("goroutine").ServeHTTP)
r.HandleFunc("/pprof/threadcreate", pprof.Handler("threadcreate").ServeHTTP)
}
func AttachProfiler(router *mux.Router) {
router.HandleFunc("/debug/pprof/", pprof.Index)
router.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
router.HandleFunc("/debug/pprof/profile", pprof.Profile)
router.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
// Manually add support for paths linked to by index page at /debug/pprof/
router.Handle("/debug/pprof/goroutine", pprof.Handler("goroutine"))
router.Handle("/debug/pprof/heap", pprof.Handler("heap"))
router.Handle("/debug/pprof/threadcreate", pprof.Handler("threadcreate"))
router.Handle("/debug/pprof/block", pprof.Handler("block"))
}
func CreateDebugEndpoints(router *mux.Router, debugUser, debugPassword string) {
logging.Log.Infof("Creating debug handlers")
router.HandleFunc("/debug/pprof", authenticate(http.HandlerFunc(pprof.Index), debugUser, debugPassword))
router.HandleFunc("/debug/pprof/cmdline", authenticate(http.HandlerFunc(pprof.Cmdline), debugUser, debugPassword))
router.HandleFunc("/debug/pprof/profile", authenticate(http.HandlerFunc(pprof.Profile), debugUser, debugPassword))
router.HandleFunc("/debug/pprof/symbol", authenticate(http.HandlerFunc(pprof.Symbol), debugUser, debugPassword))
router.HandleFunc("/debug/pprof/goroutine", authenticate(pprof.Handler("goroutine").ServeHTTP, debugUser, debugPassword))
router.HandleFunc("/debug/pprof/heap", authenticate(pprof.Handler("heap").ServeHTTP, debugUser, debugPassword))
router.HandleFunc("/debug/pprof/threadcreate", authenticate(pprof.Handler("threadcreate").ServeHTTP, debugUser, debugPassword))
router.HandleFunc("/debug/pprof/block", authenticate(pprof.Handler("block").ServeHTTP, debugUser, debugPassword))
}
func profilerSetup(mainRouter *mux.Router, path string) {
var r = mainRouter.PathPrefix(path).Subrouter()
r.HandleFunc("/pprof/", pprof.Index)
r.HandleFunc("/pprof/cmdline", pprof.Cmdline)
r.HandleFunc("/pprof/profile", pprof.Profile)
r.HandleFunc("/pprof/symbol", pprof.Symbol)
r.HandleFunc("/debug/pprof/trace", pprof.Trace)
r.HandleFunc("/pprof/block", pprof.Handler("block").ServeHTTP)
r.HandleFunc("/pprof/heap", pprof.Handler("heap").ServeHTTP)
r.HandleFunc("/pprof/goroutine", pprof.Handler("goroutine").ServeHTTP)
r.HandleFunc("/pprof/threadcreate", pprof.Handler("threadcreate").ServeHTTP)
}
// admin-port entry point, once started never shutsdown.
func (p *Projector) mainAdminPort(reqch chan ap.Request) {
p.admind.Register(reqVbmap)
p.admind.Register(reqFailoverLog)
p.admind.Register(reqMutationFeed)
p.admind.Register(reqRestartVbuckets)
p.admind.Register(reqShutdownVbuckets)
p.admind.Register(reqAddBuckets)
p.admind.Register(reqDelBuckets)
p.admind.Register(reqAddInstances)
p.admind.Register(reqDelInstances)
p.admind.Register(reqRepairEndpoints)
p.admind.Register(reqShutdownFeed)
p.admind.Register(reqStats)
p.admind.RegisterHTTPHandler("/stats", p.handleStats)
p.admind.RegisterHTTPHandler("/settings", p.handleSettings)
// debug pprof hanlders.
blockHandler := pprof.Handler("block")
grHandler := pprof.Handler("goroutine")
hpHandler := pprof.Handler("heap")
tcHandler := pprof.Handler("threadcreate")
profHandler := pprof.Handler("profile")
p.admind.RegisterHTTPHandler("/debug/pprof", pprof.Index)
p.admind.RegisterHTTPHandler("/debug/pprof/block", blockHandler)
p.admind.RegisterHTTPHandler("/debug/pprof/goroutine", grHandler)
p.admind.RegisterHTTPHandler("/debug/pprof/heap", hpHandler)
p.admind.RegisterHTTPHandler("/debug/pprof/threadcreate", tcHandler)
p.admind.RegisterHTTPHandler("/debug/pprof/profile", profHandler)
expvar.Publish("projector", expvar.Func(p.doStatistics))
p.admind.Start()
loop:
for {
select {
case req, ok := <-reqch:
if ok == false {
break loop
}
// a go-routine is spawned so that requests to
// different feeds can be simultaneously executed.
go p.handleRequest(req, angioToken)
angioToken++
if angioToken >= 0xFFFE {
angioToken = 1
}
}
}
p.admind.Stop()
logging.Infof("%v ... adminport stopped\n", p.logPrefix)
}
// Run starts the web application and serves HTTP requests for s
func (s *Server) Run(addr string) {
addrs := strings.Split(addr, ":")
s.Config.Addr = addrs[0]
s.Config.Port, _ = strconv.Atoi(addrs[1])
s.initServer()
mux := http.NewServeMux()
if s.Config.Profiler {
mux.Handle("/debug/pprof", http.HandlerFunc(pprof.Index))
mux.Handle("/debug/pprof/heap", pprof.Handler("heap"))
mux.Handle("/debug/pprof/block", pprof.Handler("block"))
mux.Handle("/debug/pprof/goroutine", pprof.Handler("goroutine"))
mux.Handle("/debug/pprof/threadcreate", pprof.Handler("threadcreate"))
mux.Handle("/debug/pprof/cmdline", http.HandlerFunc(pprof.Cmdline))
mux.Handle("/debug/pprof/profile", http.HandlerFunc(pprof.Profile))
mux.Handle("/debug/pprof/symbol", http.HandlerFunc(pprof.Symbol))
mux.Handle("/debug/pprof/startcpuprof", http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
StartCPUProfile()
}))
mux.Handle("/debug/pprof/stopcpuprof", http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
StopCPUProfile()
}))
mux.Handle("/debug/pprof/memprof", http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
runtime.GC()
runtimePprof.WriteHeapProfile(rw)
}))
mux.Handle("/debug/pprof/gc", http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
PrintGCSummary(rw)
}))
}
if c, err := XHook.Call("MuxHandle", mux); err == nil {
if ret := XHook.Value(c, 0); ret != nil {
mux = ret.(*http.ServeMux)
}
}
mux.Handle("/", s)
s.Logger.Infof("http server is listening %s", addr)
l, err := net.Listen("tcp", addr)
if err != nil {
s.Logger.Error("ListenAndServe:", err)
}
s.l = l
err = http.Serve(s.l, mux)
s.l.Close()
}
func registerPProf(h func(string, func(http.ResponseWriter, *http.Request))) {
h("/debug/pprof/", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
pprof.Index(w, r)
})
h("/debug/pprof/cmdline", pprof.Cmdline)
h("/debug/pprof/profile", pprof.Profile)
h("/debug/pprof/symbol", pprof.Symbol)
h("/debug/pprof/block", pprof.Handler("block").ServeHTTP)
h("/debug/pprof/heap", pprof.Handler("heap").ServeHTTP)
h("/debug/pprof/goroutine", pprof.Handler("goroutine").ServeHTTP)
h("/debug/pprof/threadcreate", pprof.Handler("threadcreate").ServeHTTP)
}
func Profiler() http.Handler {
r := chi.NewRouter()
r.Handle("/vars", expVars)
r.Handle("/pprof/", pprof.Index)
r.Handle("/pprof/cmdline", pprof.Cmdline)
r.Handle("/pprof/profile", pprof.Profile)
r.Handle("/pprof/symbol", pprof.Symbol)
r.Handle("/pprof/block", pprof.Handler("block").ServeHTTP)
r.Handle("/pprof/heap", pprof.Handler("heap").ServeHTTP)
r.Handle("/pprof/goroutine", pprof.Handler("goroutine").ServeHTTP)
r.Handle("/pprof/threadcreate", pprof.Handler("threadcreate").ServeHTTP)
return r
}
// RegisterProfiler will add handlers for pprof endpoints if
// the config has them enabled.
func RegisterProfiler(cfg *config.Server, mx *mux.Router) {
if !cfg.EnablePProf {
return
}
mx.HandleFunc("/debug/pprof/", pprof.Index)
mx.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
mx.HandleFunc("/debug/pprof/profile", pprof.Profile)
mx.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
// Manually add support for paths linked to by index page at /debug/pprof/
mx.Handle("/debug/pprof/goroutine", pprof.Handler("goroutine"))
mx.Handle("/debug/pprof/heap", pprof.Handler("heap"))
mx.Handle("/debug/pprof/threadcreate", pprof.Handler("threadcreate"))
mx.Handle("/debug/pprof/block", pprof.Handler("block"))
}
func (s *Server) RunTLS(addr string, cert string, key string) {
s.initServer()
mux := http.NewServeMux()
mux.Handle("/debug/pprof/cmdline", http.HandlerFunc(pprof.Cmdline))
mux.Handle("/debug/pprof/profile", http.HandlerFunc(pprof.Profile))
mux.Handle("/debug/pprof/heap", pprof.Handler("heap"))
mux.Handle("/debug/pprof/symbol", http.HandlerFunc(pprof.Symbol))
mux.Handle("/", s)
s.Logger.Printf("web.go serving %s\n", addr)
/*
l, err := net.Listen("tcp", addr)
if err != nil {
log.Fatal("ListenAndServe:", err)
}
s.l = l
err = http.Serve(s.l, mux)
s.l.Close()
*/
err := http.ListenAndServeTLS(addr, cert, key, mux)
if err != nil {
log.Fatal("ListenAndServe:", err)
}
}
// Handler returns an http.HandlerFunc that returns pprof profiles
// and additional metrics.
// The handler must be accessible through the "/debug/_gom" route
// in order for gom to display the stats from the debugged program.
// See the godoc examples for usage.
func Handler() http.HandlerFunc {
// TODO(jbd): enable block profile.
return func(w http.ResponseWriter, r *http.Request) {
switch r.URL.Query().Get("view") {
case "profile":
name := r.URL.Query().Get("name")
if name == "profile" {
httppprof.Profile(w, r)
return
}
httppprof.Handler(name).ServeHTTP(w, r)
return
case "symbol":
httppprof.Symbol(w, r)
return
}
n := &stats{
Goroutine: pprof.Lookup("goroutine").Count(),
Thread: pprof.Lookup("threadcreate").Count(),
Block: pprof.Lookup("block").Count(),
Timestamp: time.Now().Unix(),
}
err := json.NewEncoder(w).Encode(n)
if err != nil {
w.WriteHeader(500)
fmt.Fprint(w, err)
}
}
}
func (a *App) maybeRegisterPProfHandlers() {
if enableProfiling, _ := a.Cfg.GetBool("gop", "enable_profiling_urls", false); enableProfiling && !a.configHandlersEnabled {
a.HandleFunc("/debug/pprof/cmdline", func(g *Req) error {
pprof.Cmdline(g.W, g.R)
return nil
})
a.HandleFunc("/debug/pprof/symbol", func(g *Req) error {
pprof.Symbol(g.W, g.R)
return nil
})
a.HandleFunc("/debug/pprof/profile", func(g *Req) error {
pprof.Profile(g.W, g.R)
return nil
})
a.HandleFunc("/debug/pprof/{profile_name}", func(g *Req) error {
vars := mux.Vars(g.R)
h := pprof.Handler(vars["profile_name"])
h.ServeHTTP(g.W, g.R)
return nil
})
a.configHandlersEnabled = true
}
}
func handler() http.Handler {
info := struct {
Profiles []*pprof.Profile
Token string
}{
Profiles: pprof.Profiles(),
}
h := func(w http.ResponseWriter, r *http.Request) {
// get the last path, allowing this to be mounted under any prefix
split := strings.Split(r.URL.Path, "/")
name := split[len(split)-1]
switch name {
case "":
// Index page.
if err := indexTmpl.Execute(w, info); err != nil {
fmt.Fprintf(w, "something went wrong - %s", err)
return
}
case "cmdline":
nhpprof.Cmdline(w, r)
case "profile":
nhpprof.Profile(w, r)
case "trace":
nhpprof.Trace(w, r)
case "symbol":
nhpprof.Symbol(w, r)
default:
// Provides access to all profiles under runtime/pprof
nhpprof.Handler(name).ServeHTTP(w, r)
}
}
return http.HandlerFunc(h)
}
func (hs *httpSrv) debugRuntime(w http.ResponseWriter, req *http.Request, s string) {
setPub(w)
if s == "heap" {
runtime.GC()
}
httpprof.Handler(s).ServeHTTP(w, req)
return
}
//Runs the web application and serves http requests
func (s *Server) Run(addr string) {
s.initServer()
mux := http.NewServeMux()
if s.profile {
mux.Handle("/debug/pprof/cmdline", http.HandlerFunc(pprof.Cmdline))
mux.Handle("/debug/pprof/profile", http.HandlerFunc(pprof.Profile))
mux.Handle("/debug/pprof/heap", pprof.Handler("heap"))
mux.Handle("/debug/pprof/block", pprof.Handler("block"))
mux.Handle("/debug/pprof/routine", pprof.Handler("goroutine"))
mux.Handle("/debug/pprof/symbol", http.HandlerFunc(pprof.Symbol))
}
mux.Handle("/", s)
var l net.Listener
var err error
if s.Config.TLSConfig != nil {
s.Logger.Printf("web.go serving %s [SSL]", addr)
cert, err := tls.LoadX509KeyPair(s.Config.TLSConfig.Cert, s.Config.TLSConfig.Key)
if err != nil {
log.Fatal("Load tls cert/key:", err)
}
tlsc := tls.Config{}
tlsc.NextProtos = []string{"http/1.1"}
tlsc.Certificates = []tls.Certificate{cert}
l, err = tls.Listen("tcp", addr, &tlsc)
} else {
s.Logger.Printf("web.go serving %s", addr)
l, err = net.Listen("tcp", addr)
}
if err != nil {
log.Fatal("ListenAndServe:", err)
}
if l == nil {
log.Fatal("ListenAndServe failed")
}
s.l = l
err = http.Serve(s.l, mux)
s.l.Close()
}
func (sctx *serveCtx) registerPprof() {
f := func(s string, h http.Handler) {
if sctx.userHandlers[s] != nil {
plog.Warningf("path %s already registered by user handler", s)
return
}
sctx.userHandlers[s] = h
}
f(pprofPrefix+"/", http.HandlerFunc(pprof.Index))
f(pprofPrefix+"/profile", http.HandlerFunc(pprof.Profile))
f(pprofPrefix+"/symbol", http.HandlerFunc(pprof.Symbol))
f(pprofPrefix+"/cmdline", http.HandlerFunc(pprof.Cmdline))
f(pprofPrefix+"/trace", http.HandlerFunc(pprof.Trace))
f(pprofPrefix+"/heap", pprof.Handler("heap"))
f(pprofPrefix+"/goroutine", pprof.Handler("goroutine"))
f(pprofPrefix+"/threadcreate", pprof.Handler("threadcreate"))
f(pprofPrefix+"/block", pprof.Handler("block"))
}
