rename frontends to frontend

frontend/http/bencode/bencode.go

@@ -0,0 +1,33 @@
+// Copyright 2016 Jimmy Zelinskie
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package bencode implements bencoding of data as defined in BEP 3 using
+// type assertion over reflection for performance.
+package bencode
+
+// Dict represents a bencode dictionary.
+type Dict map[string]interface{}
+
+// NewDict allocates the memory for a Dict.
+func NewDict() Dict {
+	return make(Dict)
+}
+
+// List represents a bencode list.
+type List []interface{}
+
+// NewList allocates the memory for a List.
+func NewList() List {
+	return make(List, 0)
+}

frontend/http/bencode/decoder.go

@@ -0,0 +1,145 @@
+// Copyright 2016 Jimmy Zelinskie
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bencode
+
+import (
+	"bufio"
+	"bytes"
+	"errors"
+	"io"
+	"strconv"
+)
+
+// A Decoder reads bencoded objects from an input stream.
+type Decoder struct {
+	r *bufio.Reader
+}
+
+// NewDecoder returns a new decoder that reads from r.
+func NewDecoder(r io.Reader) *Decoder {
+	return &Decoder{r: bufio.NewReader(r)}
+}
+
+// Decode unmarshals the next bencoded value in the stream.
+func (dec *Decoder) Decode() (interface{}, error) {
+	return unmarshal(dec.r)
+}
+
+// Unmarshal deserializes and returns the bencoded value in buf.
+func Unmarshal(buf []byte) (interface{}, error) {
+	r := bufio.NewReader(bytes.NewBuffer(buf))
+	return unmarshal(r)
+}
+
+// unmarshal reads bencoded values from a bufio.Reader
+func unmarshal(r *bufio.Reader) (interface{}, error) {
+	tok, err := r.ReadByte()
+	if err != nil {
+		return nil, err
+	}
+
+	switch tok {
+	case 'i':
+		return readTerminatedInt(r, 'e')
+
+	case 'l':
+		list := NewList()
+		for {
+			ok, err := readTerminator(r, 'e')
+			if err != nil {
+				return nil, err
+			} else if ok {
+				break
+			}
+
+			v, err := unmarshal(r)
+			if err != nil {
+				return nil, err
+			}
+			list = append(list, v)
+		}
+		return list, nil
+
+	case 'd':
+		dict := NewDict()
+		for {
+			ok, err := readTerminator(r, 'e')
+			if err != nil {
+				return nil, err
+			} else if ok {
+				break
+			}
+
+			v, err := unmarshal(r)
+			if err != nil {
+				return nil, err
+			}
+
+			key, ok := v.(string)
+			if !ok {
+				return nil, errors.New("bencode: non-string map key")
+			}
+
+			dict[key], err = unmarshal(r)
+			if err != nil {
+				return nil, err
+			}
+		}
+		return dict, nil
+
+	default:
+		err = r.UnreadByte()
+		if err != nil {
+			return nil, err
+		}
+
+		length, err := readTerminatedInt(r, ':')
+		if err != nil {
+			return nil, errors.New("bencode: unknown input sequence")
+		}
+
+		buf := make([]byte, length)
+		n, err := r.Read(buf)
+
+		if err != nil {
+			return nil, err
+		} else if int64(n) != length {
+			return nil, errors.New("bencode: short read")
+		}
+
+		return string(buf), nil
+	}
+}
+
+func readTerminator(r io.ByteScanner, term byte) (bool, error) {
+	tok, err := r.ReadByte()
+	if err != nil {
+		return false, err
+	} else if tok == term {
+		return true, nil
+	}
+	return false, r.UnreadByte()
+}
+
+func readTerminatedInt(r *bufio.Reader, term byte) (int64, error) {
+	buf, err := r.ReadSlice(term)
+	if err != nil {
+		return 0, err
+	} else if len(buf) <= 1 {
+		return 0, errors.New("bencode: empty integer field")
+	}
+
+	return strconv.ParseInt(string(buf[:len(buf)-1]), 10, 64)
+}

frontend/http/bencode/decoder_test.go

@@ -0,0 +1,96 @@
+// Copyright 2016 Jimmy Zelinskie
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bencode
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var unmarshalTests = []struct {
+	input    string
+	expected interface{}
+}{
+	{"i42e", int64(42)},
+	{"i-42e", int64(-42)},
+
+	{"7:example", "example"},
+
+	{"l3:one3:twoe", List{"one", "two"}},
+	{"le", List{}},
+
+	{"d3:one2:aa3:two2:bbe", Dict{"one": "aa", "two": "bb"}},
+	{"de", Dict{}},
+}
+
+func TestUnmarshal(t *testing.T) {
+	for _, tt := range unmarshalTests {
+		got, err := Unmarshal([]byte(tt.input))
+		assert.Nil(t, err, "unmarshal should not fail")
+		assert.Equal(t, got, tt.expected, "unmarshalled values should match the expected results")
+	}
+}
+
+type bufferLoop struct {
+	val string
+}
+
+func (r *bufferLoop) Read(b []byte) (int, error) {
+	n := copy(b, r.val)
+	return n, nil
+}
+
+func BenchmarkUnmarshalScalar(b *testing.B) {
+	d1 := NewDecoder(&bufferLoop{"7:example"})
+	d2 := NewDecoder(&bufferLoop{"i42e"})
+
+	for i := 0; i < b.N; i++ {
+		d1.Decode()
+		d2.Decode()
+	}
+}
+
+func TestUnmarshalLarge(t *testing.T) {
+	data := Dict{
+		"k1": List{"a", "b", "c"},
+		"k2": int64(42),
+		"k3": "val",
+		"k4": int64(-42),
+	}
+
+	buf, _ := Marshal(data)
+	dec := NewDecoder(&bufferLoop{string(buf)})
+
+	got, err := dec.Decode()
+	assert.Nil(t, err, "decode should not fail")
+	assert.Equal(t, got, data, "encoding and decoding should equal the original value")
+}
+
+func BenchmarkUnmarshalLarge(b *testing.B) {
+	data := map[string]interface{}{
+		"k1": []string{"a", "b", "c"},
+		"k2": 42,
+		"k3": "val",
+		"k4": uint(42),
+	}
+
+	buf, _ := Marshal(data)
+	dec := NewDecoder(&bufferLoop{string(buf)})
+
+	for i := 0; i < b.N; i++ {
+		dec.Decode()
+	}
+}

frontend/http/bencode/encoder.go

@@ -0,0 +1,173 @@
+// Copyright 2016 Jimmy Zelinskie
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bencode
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"strconv"
+	"time"
+)
+
+// An Encoder writes bencoded objects to an output stream.
+type Encoder struct {
+	w io.Writer
+}
+
+// NewEncoder returns a new encoder that writes to w.
+func NewEncoder(w io.Writer) *Encoder {
+	return &Encoder{w: w}
+}
+
+// Encode writes the bencoding of v to the stream.
+func (enc *Encoder) Encode(v interface{}) error {
+	return marshal(enc.w, v)
+}
+
+// Marshal returns the bencoding of v.
+func Marshal(v interface{}) ([]byte, error) {
+	buf := &bytes.Buffer{}
+	err := marshal(buf, v)
+	return buf.Bytes(), err
+}
+
+// Marshaler is the interface implemented by objects that can marshal
+// themselves.
+type Marshaler interface {
+	MarshalBencode() ([]byte, error)
+}
+
+// marshal writes types bencoded to an io.Writer
+func marshal(w io.Writer, data interface{}) error {
+	switch v := data.(type) {
+	case Marshaler:
+		bencoded, err := v.MarshalBencode()
+		if err != nil {
+			return err
+		}
+		_, err = w.Write(bencoded)
+		if err != nil {
+			return err
+		}
+
+	case string:
+		marshalString(w, v)
+
+	case int:
+		marshalInt(w, int64(v))
+
+	case uint:
+		marshalUint(w, uint64(v))
+
+	case int16:
+		marshalInt(w, int64(v))
+
+	case uint16:
+		marshalUint(w, uint64(v))
+
+	case int32:
+		marshalInt(w, int64(v))
+
+	case uint32:
+		marshalUint(w, uint64(v))
+
+	case int64:
+		marshalInt(w, v)
+
+	case uint64:
+		marshalUint(w, v)
+
+	case []byte:
+		marshalBytes(w, v)
+
+	case time.Duration: // Assume seconds
+		marshalInt(w, int64(v/time.Second))
+
+	case Dict:
+		marshal(w, map[string]interface{}(v))
+
+	case []Dict:
+		w.Write([]byte{'l'})
+		for _, val := range v {
+			err := marshal(w, val)
+			if err != nil {
+				return err
+			}
+		}
+		w.Write([]byte{'e'})
+
+	case map[string]interface{}:
+		w.Write([]byte{'d'})
+		for key, val := range v {
+			marshalString(w, key)
+			err := marshal(w, val)
+			if err != nil {
+				return err
+			}
+		}
+		w.Write([]byte{'e'})
+
+	case []string:
+		w.Write([]byte{'l'})
+		for _, val := range v {
+			err := marshal(w, val)
+			if err != nil {
+				return err
+			}
+		}
+		w.Write([]byte{'e'})
+
+	case List:
+		marshal(w, []interface{}(v))
+
+	case []interface{}:
+		w.Write([]byte{'l'})
+		for _, val := range v {
+			err := marshal(w, val)
+			if err != nil {
+				return err
+			}
+		}
+		w.Write([]byte{'e'})
+
+	default:
+		return fmt.Errorf("attempted to marshal unsupported type:\n%t", v)
+	}
+
+	return nil
+}
+
+func marshalInt(w io.Writer, v int64) {
+	w.Write([]byte{'i'})
+	w.Write([]byte(strconv.FormatInt(v, 10)))
+	w.Write([]byte{'e'})
+}
+
+func marshalUint(w io.Writer, v uint64) {
+	w.Write([]byte{'i'})
+	w.Write([]byte(strconv.FormatUint(v, 10)))
+	w.Write([]byte{'e'})
+}
+
+func marshalBytes(w io.Writer, v []byte) {
+	w.Write([]byte(strconv.Itoa(len(v))))
+	w.Write([]byte{':'})
+	w.Write(v)
+}
+
+func marshalString(w io.Writer, v string) {
+	marshalBytes(w, []byte(v))
+}

frontend/http/bencode/encoder_test.go

@@ -0,0 +1,81 @@
+// Copyright 2016 Jimmy Zelinskie
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bencode
+
+import (
+	"bytes"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var marshalTests = []struct {
+	input    interface{}
+	expected []string
+}{
+	{int(42), []string{"i42e"}},
+	{int(-42), []string{"i-42e"}},
+	{uint(43), []string{"i43e"}},
+	{int64(44), []string{"i44e"}},
+	{uint64(45), []string{"i45e"}},
+	{int16(44), []string{"i44e"}},
+	{uint16(45), []string{"i45e"}},
+
+	{"example", []string{"7:example"}},
+	{[]byte("example"), []string{"7:example"}},
+	{30 * time.Minute, []string{"i1800e"}},
+
+	{[]string{"one", "two"}, []string{"l3:one3:twoe", "l3:two3:onee"}},
+	{[]interface{}{"one", "two"}, []string{"l3:one3:twoe", "l3:two3:onee"}},
+	{[]string{}, []string{"le"}},
+
+	{map[string]interface{}{"one": "aa", "two": "bb"}, []string{"d3:one2:aa3:two2:bbe", "d3:two2:bb3:one2:aae"}},
+	{map[string]interface{}{}, []string{"de"}},
+}
+
+func TestMarshal(t *testing.T) {
+	for _, test := range marshalTests {
+		got, err := Marshal(test.input)
+		assert.Nil(t, err, "marshal should not fail")
+		assert.Contains(t, test.expected, string(got), "the marshaled result should be one of the expected permutations")
+	}
+}
+
+func BenchmarkMarshalScalar(b *testing.B) {
+	buf := &bytes.Buffer{}
+	encoder := NewEncoder(buf)
+
+	for i := 0; i < b.N; i++ {
+		encoder.Encode("test")
+		encoder.Encode(123)
+	}
+}
+
+func BenchmarkMarshalLarge(b *testing.B) {
+	data := map[string]interface{}{
+		"k1": []string{"a", "b", "c"},
+		"k2": 42,
+		"k3": "val",
+		"k4": uint(42),
+	}
+
+	buf := &bytes.Buffer{}
+	encoder := NewEncoder(buf)
+
+	for i := 0; i < b.N; i++ {
+		encoder.Encode(data)
+	}
+}

frontend/http/frontend.go

@@ -0,0 +1,197 @@
+// Copyright 2016 Jimmy Zelinskie
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package http implements a BitTorrent frontend via the HTTP protocol as
+// described in BEP 3 and BEP 23.
+package http
+
+import (
+	"net"
+	"net/http"
+	"time"
+
+	"github.com/julienschmidt/httprouter"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/tylerb/graceful"
+	"golang.org/x/net/context"
+
+	"github.com/jzelinskie/trakr/frontend"
+)
+
+func init() {
+	prometheus.MustRegister(promResponseDurationMilliseconds)
+	recordResponseDuration("action", nil, time.Second)
+}
+
+var promResponseDurationMilliseconds = prometheus.NewHistogramVec(
+	prometheus.HistogramOpts{
+		Name:    "trakr_http_response_duration_milliseconds",
+		Help:    "The duration of time it takes to receive and write a response to an API request",
+		Buckets: prometheus.ExponentialBuckets(9.375, 2, 10),
+	},
+	[]string{"action", "error"},
+)
+
+// recordResponseDuration records the duration of time to respond to a Request
+// in milliseconds .
+func recordResponseDuration(action string, err error, duration time.Duration) {
+	var errString string
+	if err != nil {
+		errString = err.Error()
+	}
+
+	promResponseDurationMilliseconds.
+		WithLabelValues(action, errString).
+		Observe(float64(duration.Nanoseconds()) / float64(time.Millisecond))
+}
+
+// Config represents all of the configurable options for an HTTP BitTorrent
+// Frontend.
+type Config struct {
+	Addr            string
+	ReadTimeout     time.Duration
+	WriteTimeout    time.Duration
+	RequestTimeout  time.Duration
+	AllowIPSpoofing bool
+	RealIPHeader    string
+}
+
+// Frontend holds the state of an HTTP BitTorrent Frontend.
+type Frontend struct {
+	grace *graceful.Server
+
+	frontend.TrackerFuncs
+	Config
+}
+
+// NewFrontend allocates a new instance of a Frontend.
+func NewFrontend(funcs frontend.TrackerFuncs, cfg Config) *Frontend {
+	return &Frontend{
+		TrackerFuncs: funcs,
+		Config:       cfg,
+	}
+}
+
+// Stop provides a thread-safe way to shutdown a currently running Tracker.
+func (t *Frontend) Stop() {
+	t.grace.Stop(t.grace.Timeout)
+	<-t.grace.StopChan()
+}
+
+func (t *Frontend) handler() http.Handler {
+	router := httprouter.New()
+	router.GET("/announce", t.announceRoute)
+	router.GET("/scrape", t.scrapeRoute)
+	return router
+}
+
+// ListenAndServe listens on the TCP network address t.Addr and blocks serving
+// BitTorrent requests until t.Stop() is called or an error is returned.
+func (t *Frontend) ListenAndServe() error {
+	t.grace = &graceful.Server{
+		Server: &http.Server{
+			Addr:         t.Addr,
+			Handler:      t.handler(),
+			ReadTimeout:  t.ReadTimeout,
+			WriteTimeout: t.WriteTimeout,
+		},
+		Timeout:          t.RequestTimeout,
+		NoSignalHandling: 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")
+			}
+		},
+	}
+	t.grace.SetKeepAlivesEnabled(false)
+
+	if err := t.grace.ListenAndServe(); err != nil {
+		if opErr, ok := err.(*net.OpError); !ok || (ok && opErr.Op != "accept") {
+			panic("http: failed to gracefully run HTTP server: " + err.Error())
+		}
+	}
+
+	return nil
+}
+
+// announceRoute parses and responds to an Announce by using t.TrackerFuncs.
+func (t *Frontend) announceRoute(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
+	var err error
+	start := time.Now()
+	defer recordResponseDuration("announce", err, time.Since(start))
+
+	req, err := ParseAnnounce(r, t.RealIPHeader, t.AllowIPSpoofing)
+	if err != nil {
+		WriteError(w, err)
+		return
+	}
+
+	resp, err := t.HandleAnnounce(context.TODO(), req)
+	if err != nil {
+		WriteError(w, err)
+		return
+	}
+
+	err = WriteAnnounceResponse(w, resp)
+	if err != nil {
+		WriteError(w, err)
+		return
+	}
+
+	if t.AfterAnnounce != nil {
+		go t.AfterAnnounce(req, resp)
+	}
+}
+
+// scrapeRoute parses and responds to a Scrape by using t.TrackerFuncs.
+func (t *Frontend) scrapeRoute(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
+	var err error
+	start := time.Now()
+	defer recordResponseDuration("scrape", err, time.Since(start))
+
+	req, err := ParseScrape(r)
+	if err != nil {
+		WriteError(w, err)
+		return
+	}
+
+	resp, err := t.HandleScrape(context.TODO(), req)
+	if err != nil {
+		WriteError(w, err)
+		return
+	}
+
+	err = WriteScrapeResponse(w, resp)
+	if err != nil {
+		WriteError(w, err)
+		return
+	}
+
+	if t.AfterScrape != nil {
+		go t.AfterScrape(req, resp)
+	}
+}

frontend/http/parser.go

@@ -0,0 +1,151 @@
+// Copyright 2016 Jimmy Zelinskie
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package http
+
+import (
+	"net"
+	"net/http"
+
+	"github.com/jzelinskie/trakr/bittorrent"
+)
+
+// ParseAnnounce parses an bittorrent.AnnounceRequest from an http.Request.
+//
+// If allowIPSpoofing is true, IPs provided via params will be used.
+// If realIPHeader is not empty string, the first value of the HTTP Header with
+// that name will be used.
+func ParseAnnounce(r *http.Request, realIPHeader string, allowIPSpoofing bool) (*bittorrent.AnnounceRequest, error) {
+	qp, err := NewQueryParams(r.URL.RawQuery)
+	if err != nil {
+		return nil, err
+	}
+
+	request := &bittorrent.AnnounceRequest{Params: qp}
+
+	eventStr, _ := qp.String("event")
+	request.Event, err = bittorrent.NewEvent(eventStr)
+	if err != nil {
+		return nil, bittorrent.ClientError("failed to provide valid client event")
+	}
+
+	compactStr, _ := qp.String("compact")
+	request.Compact = compactStr != "" && compactStr != "0"
+
+	infoHashes := qp.InfoHashes()
+	if len(infoHashes) < 1 {
+		return nil, bittorrent.ClientError("no info_hash parameter supplied")
+	}
+	if len(infoHashes) > 1 {
+		return nil, bittorrent.ClientError("multiple info_hash parameters supplied")
+	}
+	request.InfoHash = infoHashes[0]
+
+	peerID, ok := qp.String("peer_id")
+	if !ok {
+		return nil, bittorrent.ClientError("failed to parse parameter: peer_id")
+	}
+	if len(peerID) != 20 {
+		return nil, bittorrent.ClientError("failed to provide valid peer_id")
+	}
+	request.Peer.ID = bittorrent.PeerIDFromString(peerID)
+
+	request.Left, err = qp.Uint64("left")
+	if err != nil {
+		return nil, bittorrent.ClientError("failed to parse parameter: left")
+	}
+
+	request.Downloaded, err = qp.Uint64("downloaded")
+	if err != nil {
+		return nil, bittorrent.ClientError("failed to parse parameter: downloaded")
+	}
+
+	request.Uploaded, err = qp.Uint64("uploaded")
+	if err != nil {
+		return nil, bittorrent.ClientError("failed to parse parameter: uploaded")
+	}
+
+	numwant, err := qp.Uint64("numwant")
+	if err != nil {
+		return nil, bittorrent.ClientError("failed to parse parameter: numwant")
+	}
+	request.NumWant = uint32(numwant)
+
+	port, err := qp.Uint64("port")
+	if err != nil {
+		return nil, bittorrent.ClientError("failed to parse parameter: port")
+	}
+	request.Peer.Port = uint16(port)
+
+	request.Peer.IP = requestedIP(r, qp, realIPHeader, allowIPSpoofing)
+	if request.Peer.IP == nil {
+		return nil, bittorrent.ClientError("failed to parse peer IP address")
+	}
+
+	return request, nil
+}
+
+// ParseScrape parses an bittorrent.ScrapeRequest from an http.Request.
+func ParseScrape(r *http.Request) (*bittorrent.ScrapeRequest, error) {
+	qp, err := NewQueryParams(r.URL.RawQuery)
+	if err != nil {
+		return nil, err
+	}
+
+	infoHashes := qp.InfoHashes()
+	if len(infoHashes) < 1 {
+		return nil, bittorrent.ClientError("no info_hash parameter supplied")
+	}
+
+	request := &bittorrent.ScrapeRequest{
+		InfoHashes: infoHashes,
+		Params:     qp,
+	}
+
+	return request, nil
+}
+
+// requestedIP determines the IP address for a BitTorrent client request.
+//
+// If allowIPSpoofing is true, IPs provided via params will be used.
+// If realIPHeader is not empty string, the first value of the HTTP Header with
+// that name will be used.
+func requestedIP(r *http.Request, p bittorrent.Params, realIPHeader string, allowIPSpoofing bool) net.IP {
+	if allowIPSpoofing {
+		if ipstr, ok := p.String("ip"); ok {
+			ip := net.ParseIP(ipstr)
+			return ip
+		}
+
+		if ipstr, ok := p.String("ipv4"); ok {
+			ip := net.ParseIP(ipstr)
+			return ip
+		}
+
+		if ipstr, ok := p.String("ipv6"); ok {
+			ip := net.ParseIP(ipstr)
+			return ip
+		}
+	}
+
+	if realIPHeader != "" {
+		if ips, ok := r.Header[realIPHeader]; ok && len(ips) > 0 {
+			ip := net.ParseIP(ips[0])
+			return ip
+		}
+	}
+
+	host, _, _ := net.SplitHostPort(r.RemoteAddr)
+	return net.ParseIP(host)
+}

frontend/http/query_params.go

@@ -0,0 +1,138 @@
+// Copyright 2016 Jimmy Zelinskie
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package http
+
+import (
+	"errors"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/jzelinskie/trakr/bittorrent"
+)
+
+// ErrKeyNotFound is returned when a provided key has no value associated with
+// it.
+var ErrKeyNotFound = errors.New("http: value for the provided key does not exist")
+
+// ErrInvalidInfohash is returned when parsing a query encounters an infohash
+// with invalid length.
+var ErrInvalidInfohash = errors.New("http: invalid infohash")
+
+// QueryParams parses an HTTP Query and implements the bittorrent.Params
+// interface with some additional helpers.
+type QueryParams struct {
+	query      string
+	params     map[string]string
+	infoHashes []bittorrent.InfoHash
+}
+
+// NewQueryParams parses a raw URL query.
+func NewQueryParams(query string) (*QueryParams, error) {
+	var (
+		keyStart, keyEnd int
+		valStart, valEnd int
+
+		onKey = true
+
+		q = &QueryParams{
+			query:      query,
+			infoHashes: nil,
+			params:     make(map[string]string),
+		}
+	)
+
+	for i, length := 0, len(query); i < length; i++ {
+		separator := query[i] == '&' || query[i] == ';' || query[i] == '?'
+		last := i == length-1
+
+		if separator || last {
+			if onKey && !last {
+				keyStart = i + 1
+				continue
+			}
+
+			if last && !separator && !onKey {
+				valEnd = i
+			}
+
+			keyStr, err := url.QueryUnescape(query[keyStart : keyEnd+1])
+			if err != nil {
+				return nil, err
+			}
+
+			var valStr string
+
+			if valEnd > 0 {
+				valStr, err = url.QueryUnescape(query[valStart : valEnd+1])
+				if err != nil {
+					return nil, err
+				}
+			}
+
+			if keyStr == "info_hash" {
+				if len(valStr) != 20 {
+					return nil, ErrInvalidInfohash
+				}
+				q.infoHashes = append(q.infoHashes, bittorrent.InfoHashFromString(valStr))
+			} else {
+				q.params[strings.ToLower(keyStr)] = valStr
+			}
+
+			valEnd = 0
+			onKey = true
+			keyStart = i + 1
+
+		} else if query[i] == '=' {
+			onKey = false
+			valStart = i + 1
+			valEnd = 0
+		} else if onKey {
+			keyEnd = i
+		} else {
+			valEnd = i
+		}
+	}
+
+	return q, nil
+}
+
+// String returns a string parsed from a query. Every key can be returned as a
+// string because they are encoded in the URL as strings.
+func (qp *QueryParams) String(key string) (string, bool) {
+	value, ok := qp.params[key]
+	return value, ok
+}
+
+// Uint64 returns a uint parsed from a query. After being called, it is safe to
+// cast the uint64 to your desired length.
+func (qp *QueryParams) Uint64(key string) (uint64, error) {
+	str, exists := qp.params[key]
+	if !exists {
+		return 0, ErrKeyNotFound
+	}
+
+	val, err := strconv.ParseUint(str, 10, 64)
+	if err != nil {
+		return 0, err
+	}
+
+	return val, nil
+}
+
+// InfoHashes returns a list of requested infohashes.
+func (qp *QueryParams) InfoHashes() []bittorrent.InfoHash {
+	return qp.infoHashes
+}

frontend/http/query_params_test.go

@@ -0,0 +1,110 @@
+// Copyright 2016 Jimmy Zelinskie
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package http
+
+import (
+	"net/url"
+	"testing"
+)
+
+var (
+	baseAddr     = "https://www.subdomain.tracker.com:80/"
+	testInfoHash = "01234567890123456789"
+	testPeerID   = "-TEST01-6wfG2wk6wWLc"
+
+	ValidAnnounceArguments = []url.Values{
+		{"peer_id": {testPeerID}, "port": {"6881"}, "downloaded": {"1234"}, "left": {"4321"}},
+		{"peer_id": {testPeerID}, "ip": {"192.168.0.1"}, "port": {"6881"}, "downloaded": {"1234"}, "left": {"4321"}},
+		{"peer_id": {testPeerID}, "ip": {"192.168.0.1"}, "port": {"6881"}, "downloaded": {"1234"}, "left": {"4321"}, "numwant": {"28"}},
+		{"peer_id": {testPeerID}, "ip": {"192.168.0.1"}, "port": {"6881"}, "downloaded": {"1234"}, "left": {"4321"}, "event": {"stopped"}},
+		{"peer_id": {testPeerID}, "ip": {"192.168.0.1"}, "port": {"6881"}, "downloaded": {"1234"}, "left": {"4321"}, "event": {"started"}, "numwant": {"13"}},
+		{"peer_id": {testPeerID}, "port": {"6881"}, "downloaded": {"1234"}, "left": {"4321"}, "no_peer_id": {"1"}},
+		{"peer_id": {testPeerID}, "port": {"6881"}, "downloaded": {"1234"}, "left": {"4321"}, "compact": {"0"}, "no_peer_id": {"1"}},
+		{"peer_id": {testPeerID}, "port": {"6881"}, "downloaded": {"1234"}, "left": {"4321"}, "compact": {"0"}, "no_peer_id": {"1"}, "key": {"peerKey"}},
+		{"peer_id": {testPeerID}, "port": {"6881"}, "downloaded": {"1234"}, "left": {"4321"}, "compact": {"0"}, "no_peer_id": {"1"}, "key": {"peerKey"}, "trackerid": {"trackerId"}},
+		{"peer_id": {"%3Ckey%3A+0x90%3E"}, "port": {"6881"}, "downloaded": {"1234"}, "left": {"4321"}, "compact": {"0"}, "no_peer_id": {"1"}, "key": {"peerKey"}, "trackerid": {"trackerId"}},
+		{"peer_id": {"%3Ckey%3A+0x90%3E"}, "compact": {"1"}},
+		{"peer_id": {""}, "compact": {""}},
+	}
+
+	InvalidQueries = []string{
+		baseAddr + "announce/?" + "info_hash=%0%a",
+	}
+)
+
+func mapArrayEqual(boxed map[string][]string, unboxed map[string]string) bool {
+	if len(boxed) != len(unboxed) {
+		return false
+	}
+
+	for mapKey, mapVal := range boxed {
+		// Always expect box to hold only one element
+		if len(mapVal) != 1 || mapVal[0] != unboxed[mapKey] {
+			return false
+		}
+	}
+
+	return true
+}
+
+func TestValidQueries(t *testing.T) {
+	for parseIndex, parseVal := range ValidAnnounceArguments {
+		parsedQueryObj, err := NewQueryParams(baseAddr + "announce/?" + parseVal.Encode())
+		if err != nil {
+			t.Error(err)
+		}
+
+		if !mapArrayEqual(parseVal, parsedQueryObj.params) {
+			t.Errorf("Incorrect parse at item %d.\n Expected=%v\n Recieved=%v\n", parseIndex, parseVal, parsedQueryObj.params)
+		}
+	}
+}
+
+func TestInvalidQueries(t *testing.T) {
+	for parseIndex, parseStr := range InvalidQueries {
+		parsedQueryObj, err := NewQueryParams(parseStr)
+		if err == nil {
+			t.Error("Should have produced error", parseIndex)
+		}
+
+		if parsedQueryObj != nil {
+			t.Error("Should be nil after error", parsedQueryObj, parseIndex)
+		}
+	}
+}
+
+func BenchmarkParseQuery(b *testing.B) {
+	for bCount := 0; bCount < b.N; bCount++ {
+		for parseIndex, parseStr := range ValidAnnounceArguments {
+			parsedQueryObj, err := NewQueryParams(baseAddr + "announce/?" + parseStr.Encode())
+			if err != nil {
+				b.Error(err, parseIndex)
+				b.Log(parsedQueryObj)
+			}
+		}
+	}
+}
+
+func BenchmarkURLParseQuery(b *testing.B) {
+	for bCount := 0; bCount < b.N; bCount++ {
+		for parseIndex, parseStr := range ValidAnnounceArguments {
+			parsedQueryObj, err := url.ParseQuery(baseAddr + "announce/?" + parseStr.Encode())
+			if err != nil {
+				b.Error(err, parseIndex)
+				b.Log(parsedQueryObj)
+			}
+		}
+	}
+}

frontend/http/writer.go

@@ -0,0 +1,112 @@
+// Copyright 2016 Jimmy Zelinskie
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package http
+
+import (
+	"net/http"
+
+	"github.com/jzelinskie/trakr/bittorrent"
+	"github.com/jzelinskie/trakr/frontend/http/bencode"
+)
+
+// WriteError communicates an error to a BitTorrent client over HTTP.
+func WriteError(w http.ResponseWriter, err error) error {
+	message := "internal server error"
+	if _, clientErr := err.(bittorrent.ClientError); clientErr {
+		message = err.Error()
+	}
+
+	w.WriteHeader(http.StatusOK)
+	return bencode.NewEncoder(w).Encode(bencode.Dict{
+		"failure reason": message,
+	})
+}
+
+// WriteAnnounceResponse communicates the results of an Announce to a
+// BitTorrent client over HTTP.
+func WriteAnnounceResponse(w http.ResponseWriter, resp *bittorrent.AnnounceResponse) error {
+	bdict := bencode.Dict{
+		"complete":     resp.Complete,
+		"incomplete":   resp.Incomplete,
+		"interval":     resp.Interval,
+		"min interval": resp.MinInterval,
+	}
+
+	// Add the peers to the dictionary in the compact format.
+	if resp.Compact {
+		var IPv4CompactDict, IPv6CompactDict []byte
+
+		// Add the IPv4 peers to the dictionary.
+		for _, peer := range resp.IPv4Peers {
+			IPv4CompactDict = append(IPv4CompactDict, compact(peer)...)
+		}
+		if len(IPv4CompactDict) > 0 {
+			bdict["peers"] = IPv4CompactDict
+		}
+
+		// Add the IPv6 peers to the dictionary.
+		for _, peer := range resp.IPv6Peers {
+			IPv6CompactDict = append(IPv6CompactDict, compact(peer)...)
+		}
+		if len(IPv6CompactDict) > 0 {
+			bdict["peers6"] = IPv6CompactDict
+		}
+
+		return bencode.NewEncoder(w).Encode(bdict)
+	}
+
+	// Add the peers to the dictionary.
+	var peers []bencode.Dict
+	for _, peer := range resp.IPv4Peers {
+		peers = append(peers, dict(peer))
+	}
+	for _, peer := range resp.IPv6Peers {
+		peers = append(peers, dict(peer))
+	}
+	bdict["peers"] = peers
+
+	return bencode.NewEncoder(w).Encode(bdict)
+}
+
+// WriteScrapeResponse communicates the results of a Scrape to a BitTorrent
+// client over HTTP.
+func WriteScrapeResponse(w http.ResponseWriter, resp *bittorrent.ScrapeResponse) error {
+	filesDict := bencode.NewDict()
+	for infohash, scrape := range resp.Files {
+		filesDict[string(infohash[:])] = bencode.Dict{
+			"complete":   scrape.Complete,
+			"incomplete": scrape.Incomplete,
+		}
+	}
+
+	return bencode.NewEncoder(w).Encode(bencode.Dict{
+		"files": filesDict,
+	})
+}
+
+func compact(peer bittorrent.Peer) (buf []byte) {
+	buf = []byte(peer.IP)
+	buf = append(buf, byte(peer.Port>>8))
+	buf = append(buf, byte(peer.Port&0xff))
+	return
+}
+
+func dict(peer bittorrent.Peer) bencode.Dict {
+	return bencode.Dict{
+		"peer id": string(peer.ID[:]),
+		"ip":      peer.IP.String(),
+		"port":    peer.Port,
+	}
+}

frontend/http/writer_test.go

@@ -0,0 +1,47 @@
+// Copyright 2016 Jimmy Zelinskie
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package http
+
+import (
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/jzelinskie/trakr/bittorrent"
+)
+
+func TestWriteError(t *testing.T) {
+	var table = []struct {
+		reason, expected string
+	}{
+		{"hello world", "d14:failure reason11:hello worlde"},
+		{"what's up", "d14:failure reason9:what's upe"},
+	}
+
+	for _, tt := range table {
+		r := httptest.NewRecorder()
+		err := writeError(r, bittorrent.ClientError(tt.reason))
+		assert.Nil(t, err)
+		assert.Equal(t, r.Body.String(), tt.expected)
+	}
+}
+
+func TestWriteStatus(t *testing.T) {
+	r := httptest.NewRecorder()
+	err := writeError(r, bittorrent.ClientError("something is missing"))
+	assert.Nil(t, err)
+	assert.Equal(t, r.Body.String(), "d14:failure reason20:something is missinge")
+}