tracker/server/http/server.go

// Copyright 2016 The Chihaya Authors. All rights reserved.
// Use of this source code is governed by the BSD 2-Clause license,
// which can be found in the LICENSE file.

package http

import (
	"errors"
	"log"
	"net"
	"net/http"

	"github.com/julienschmidt/httprouter"
	"github.com/tylerb/graceful"

	"github.com/chihaya/chihaya/config"
	"github.com/chihaya/chihaya/server"
	"github.com/chihaya/chihaya/server/http/query"
	"github.com/chihaya/chihaya/tracker"
)

func init() {
	server.Register("http", constructor)
}

func constructor(srvcfg *config.ServerConfig, tkr *tracker.Tracker) (server.Server, error) {
	cfg, err := newHTTPConfig(srvcfg)
	if err != nil {
		return nil, errors.New("http: invalid config: " + err.Error())
	}

	return &httpServer{
		cfg: cfg,
		tkr: tkr,
	}, nil
}

type httpServer struct {
	cfg      *httpConfig
	tkr      *tracker.Tracker
	grace    *graceful.Server
	stopping bool
}

func (s *httpServer) Start() {
	s.grace = &graceful.Server{
		Server: &http.Server{
			Addr:         s.cfg.Addr,
			Handler:      s.routes(),
			ReadTimeout:  s.cfg.ReadTimeout,
			WriteTimeout: s.cfg.WriteTimeout,
		},
		Timeout:           s.cfg.RequestTimeout,
		NoSignalHandling:  true,
		ShutdownInitiated: func() { s.stopping = true },
		ConnState: func(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("http: connection impossibly hijacked")

			// Ignore the following cases.
			case http.StateActive, http.StateIdle:

			default:
				panic("http: connection transitioned to unknown state")
			}
		},
	}
	s.grace.SetKeepAlivesEnabled(false)

	if err := s.grace.ListenAndServe(); err != nil {
		if opErr, ok := err.(*net.OpError); !ok || (ok && opErr.Op != "accept") {
			log.Printf("Failed to gracefully run HTTP server: %s", err.Error())
			return
		}
	}
}

func (s *httpServer) Stop() {
	if !s.stopping {
		s.grace.Stop(s.grace.Timeout)
	}

	s.grace = nil
	s.stopping = false
}

func (s *httpServer) routes() *httprouter.Router {
	r := httprouter.New()
	r.GET("/announce", s.serveAnnounce)
	r.GET("/scrape", s.serveScrape)
	return r
}

func (s *httpServer) serveAnnounce(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
	writer := &writer{w}

	q, err := query.New(r.URL.RawQuery)
	if err != nil {
		writer.writeError(err)
		return
	}

	req, err := q.AnnounceRequest()
	if err != nil {
		writer.writeError(err)
		return
	}

	resp, err := s.tkr.HandleAnnounce(req)
	if err != nil {
		writer.writeError(err)
		return
	}

	writer.writeAnnounceResponse(resp)
}

func (s *httpServer) serveScrape(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
	writer := &writer{w}

	q, err := query.New(r.URL.RawQuery)
	if err != nil {
		writer.writeError(err)
		return
	}

	req, err := q.ScrapeRequest()
	if err != nil {
		writer.writeError(err)
		return
	}

	resp, err := s.tkr.HandleScrape(req)
	if err != nil {
		writer.writeError(err)
		return
	}

	writer.writeScrapeResponse(resp)
}