tracker/http/http.go

171 lines
4.6 KiB
Go
Raw Normal View History

2015-01-01 18:02:25 +01:00
// Copyright 2015 The Chihaya Authors. All rights reserved.
2014-07-02 03:40:29 +02:00
// Use of this source code is governed by the BSD 2-Clause license,
// which can be found in the LICENSE file.
2014-07-16 10:40:17 +02:00
// Package http implements an http-serving BitTorrent tracker.
2014-07-02 03:40:29 +02:00
package http
import (
"net"
2014-07-02 03:40:29 +02:00
"net/http"
"time"
"github.com/golang/glog"
"github.com/julienschmidt/httprouter"
"github.com/stretchr/graceful"
"github.com/chihaya/chihaya/config"
"github.com/chihaya/chihaya/stats"
"github.com/chihaya/chihaya/tracker"
2014-07-02 03:40:29 +02:00
)
// ResponseHandler is an HTTP handler that returns a status code.
type ResponseHandler func(http.ResponseWriter, *http.Request, httprouter.Params) (int, error)
2014-07-02 03:40:29 +02:00
// Server represents an HTTP serving torrent tracker.
type Server struct {
config *config.Config
tracker *tracker.Tracker
grace *graceful.Server
stopping bool
2014-07-02 03:40:29 +02:00
}
// makeHandler wraps our ResponseHandlers while timing requests, collecting,
// stats, logging, and handling errors.
2014-07-02 03:40:29 +02:00
func makeHandler(handler ResponseHandler) httprouter.Handle {
return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
2014-07-25 09:39:02 +02:00
var msg string
2014-07-02 03:40:29 +02:00
start := time.Now()
httpCode, err := handler(w, r, p)
2014-07-23 07:20:48 +02:00
duration := time.Since(start)
if err != nil {
2014-07-25 09:39:02 +02:00
msg = err.Error()
} else if httpCode != http.StatusOK {
msg = http.StatusText(httpCode)
}
if len(msg) > 0 {
http.Error(w, msg, httpCode)
stats.RecordEvent(stats.ErroredRequest)
2014-07-25 09:39:02 +02:00
}
if len(msg) > 0 || glog.V(2) {
2014-07-25 09:43:06 +02:00
reqString := r.URL.Path + " " + r.RemoteAddr
2014-07-23 08:25:15 +02:00
if glog.V(3) {
2014-07-25 09:39:02 +02:00
reqString = r.URL.RequestURI() + " " + r.RemoteAddr
2014-07-23 08:25:15 +02:00
}
2014-07-25 09:39:02 +02:00
if len(msg) > 0 {
2014-07-25 09:43:06 +02:00
glog.Errorf("[%d - %9s] %s (%s)", httpCode, duration, reqString, msg)
2014-07-25 09:39:02 +02:00
} else {
2014-07-25 09:43:06 +02:00
glog.Infof("[%d - %9s] %s", httpCode, duration, reqString)
2014-07-25 09:39:02 +02:00
}
}
2014-07-23 07:31:22 +02:00
stats.RecordEvent(stats.HandledRequest)
stats.RecordTiming(stats.ResponseTime, duration)
2014-07-02 03:40:29 +02:00
}
}
// newRouter returns a router with all the routes.
func newRouter(s *Server) *httprouter.Router {
2014-07-02 03:40:29 +02:00
r := httprouter.New()
2014-07-09 06:53:57 +02:00
2014-07-25 22:58:26 +02:00
if s.config.PrivateEnabled {
r.GET("/users/:passkey/announce", makeHandler(s.serveAnnounce))
r.GET("/users/:passkey/scrape", makeHandler(s.serveScrape))
2014-07-09 06:53:57 +02:00
r.PUT("/users/:passkey", makeHandler(s.putUser))
r.DELETE("/users/:passkey", makeHandler(s.delUser))
2014-07-02 03:40:29 +02:00
} else {
r.GET("/announce", makeHandler(s.serveAnnounce))
r.GET("/scrape", makeHandler(s.serveScrape))
2014-07-02 03:40:29 +02:00
}
2014-07-25 22:58:26 +02:00
if s.config.ClientWhitelistEnabled {
2015-02-08 08:20:48 +01:00
r.GET("/clients/:clientID", makeHandler(s.getClient))
r.PUT("/clients/:clientID", makeHandler(s.putClient))
r.DELETE("/clients/:clientID", makeHandler(s.delClient))
2014-07-09 06:53:57 +02:00
}
r.GET("/torrents/:infohash", makeHandler(s.getTorrent))
r.PUT("/torrents/:infohash", makeHandler(s.putTorrent))
r.DELETE("/torrents/:infohash", makeHandler(s.delTorrent))
r.GET("/check", makeHandler(s.check))
2014-07-22 07:19:09 +02:00
r.GET("/stats", makeHandler(s.stats))
2014-07-09 07:34:34 +02:00
2014-07-02 03:40:29 +02:00
return r
}
// connState is used by graceful in order to gracefully shutdown. It also
// keeps track of connection stats.
func (s *Server) connState(conn net.Conn, state http.ConnState) {
switch state {
case http.StateNew:
stats.RecordEvent(stats.AcceptedConnection)
case http.StateClosed:
stats.RecordEvent(stats.ClosedConnection)
case http.StateHijacked:
panic("connection impossibly hijacked")
// Ignore the following cases.
case http.StateActive, http.StateIdle:
default:
glog.Errorf("Connection transitioned to unknown state %s (%d)", state, state)
}
}
// Serve runs an HTTP server, blocking until the server has shut down.
func (s *Server) Serve(addr string) {
glog.V(0).Info("Starting HTTP on ", addr)
2014-07-02 03:40:29 +02:00
if s.config.HTTPListenLimit != 0 {
glog.V(0).Info("Limiting connections to ", s.config.HTTPListenLimit)
}
grace := &graceful.Server{
Timeout: s.config.HTTPRequestTimeout.Duration,
ConnState: s.connState,
ListenLimit: s.config.HTTPListenLimit,
Server: &http.Server{
Addr: addr,
Handler: newRouter(s),
ReadTimeout: s.config.HTTPReadTimeout.Duration,
WriteTimeout: s.config.HTTPWriteTimeout.Duration,
},
}
s.grace = grace
2014-08-27 00:03:44 +02:00
grace.SetKeepAlivesEnabled(false)
grace.ShutdownInitiated = func() { s.stopping = true }
2014-08-27 00:03:44 +02:00
2014-07-25 09:43:06 +02:00
if err := grace.ListenAndServe(); err != nil {
if opErr, ok := err.(*net.OpError); !ok || (ok && opErr.Op != "accept") {
glog.Errorf("Failed to gracefully run HTTP server: %s", err.Error())
return
}
2014-07-25 09:43:06 +02:00
}
glog.Info("HTTP server shut down cleanly")
}
// Stop cleanly shuts down the server.
func (s *Server) Stop() {
if !s.stopping {
s.grace.Stop(s.grace.Timeout)
}
}
// NewServer returns a new HTTP server for a given configuration and tracker.
func NewServer(cfg *config.Config, tkr *tracker.Tracker) *Server {
return &Server{
config: cfg,
tracker: tkr,
}
2014-07-02 03:40:29 +02:00
}