From 343b3358a1b019ba4f01a4d85c7567329933142f Mon Sep 17 00:00:00 2001 From: Justin Li Date: Thu, 17 Jul 2014 00:54:53 -0400 Subject: [PATCH] Move NewAnnounce and NewScrape to http, since they are an implementation detail --- http/api.go | 4 +- http/tracker.go | 100 +++++++++++++++++++++++++++++++++++++++ tracker/models/models.go | 96 +------------------------------------ 3 files changed, 104 insertions(+), 96 deletions(-) create mode 100644 http/tracker.go diff --git a/http/api.go b/http/api.go index 84f73e5..1ea023d 100644 --- a/http/api.go +++ b/http/api.go @@ -28,7 +28,7 @@ func (s *Server) check(w http.ResponseWriter, r *http.Request, p httprouter.Para } func (s *Server) serveAnnounce(w http.ResponseWriter, r *http.Request, p httprouter.Params) (int, error) { - ann, err := models.NewAnnounce(s.config, r, p) + ann, err := NewAnnounce(s.config, r, p) writer := &Writer{w} if err == models.ErrMalformedRequest { @@ -46,7 +46,7 @@ func (s *Server) serveAnnounce(w http.ResponseWriter, r *http.Request, p httprou } func (s *Server) serveScrape(w http.ResponseWriter, r *http.Request, p httprouter.Params) (int, error) { - scrape, err := models.NewScrape(s.config, r, p) + scrape, err := NewScrape(s.config, r, p) writer := &Writer{w} if err == models.ErrMalformedRequest { diff --git a/http/tracker.go b/http/tracker.go new file mode 100644 index 0000000..ab313df --- /dev/null +++ b/http/tracker.go @@ -0,0 +1,100 @@ +// Copyright 2014 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 ( + "net/http" + + "github.com/julienschmidt/httprouter" + + "github.com/chihaya/chihaya/config" + "github.com/chihaya/chihaya/models/query" + "github.com/chihaya/chihaya/tracker/models" +) + +// NewAnnounce parses an HTTP request and generates a models.Announce. +func NewAnnounce(cfg *config.Config, r *http.Request, p httprouter.Params) (*models.Announce, error) { + q, err := query.New(r.URL.RawQuery) + if err != nil { + return nil, err + } + + compact := q.Params["compact"] != "0" + event, _ := q.Params["event"] + numWant := q.RequestedPeerCount(cfg.NumWantFallback) + + infohash, exists := q.Params["info_hash"] + if !exists { + return nil, models.ErrMalformedRequest + } + + peerID, exists := q.Params["peer_id"] + if !exists { + return nil, models.ErrMalformedRequest + } + + ip, err := q.RequestedIP(r) + if err != nil { + return nil, models.ErrMalformedRequest + } + + port, err := q.Uint64("port") + if err != nil { + return nil, models.ErrMalformedRequest + } + + left, err := q.Uint64("left") + if err != nil { + return nil, models.ErrMalformedRequest + } + + downloaded, err := q.Uint64("downloaded") + if err != nil { + return nil, models.ErrMalformedRequest + } + + uploaded, err := q.Uint64("uploaded") + if err != nil { + return nil, models.ErrMalformedRequest + } + + return &models.Announce{ + Config: cfg, + Compact: compact, + Downloaded: downloaded, + Event: event, + IP: ip, + Infohash: infohash, + Left: left, + NumWant: numWant, + Passkey: p.ByName("passkey"), + PeerID: peerID, + Port: port, + Uploaded: uploaded, + }, nil +} + +// NewScrape parses an HTTP request and generates a models.Scrape. +func NewScrape(cfg *config.Config, r *http.Request, p httprouter.Params) (*models.Scrape, error) { + q, err := query.New(r.URL.RawQuery) + if err != nil { + return nil, err + } + + if q.Infohashes == nil { + if _, exists := q.Params["info_hash"]; !exists { + // There aren't any infohashes. + return nil, models.ErrMalformedRequest + } + q.Infohashes = []string{q.Params["info_hash"]} + } + + return &models.Scrape{ + Config: cfg, + + Passkey: p.ByName("passkey"), + Infohashes: q.Infohashes, + }, nil +} diff --git a/tracker/models/models.go b/tracker/models/models.go index c0777e9..694ad6b 100644 --- a/tracker/models/models.go +++ b/tracker/models/models.go @@ -7,13 +7,10 @@ package models import ( "errors" "net" - "net/http" "strconv" "time" "github.com/chihaya/chihaya/config" - "github.com/chihaya/chihaya/models/query" - "github.com/julienschmidt/httprouter" ) var ( @@ -117,8 +114,7 @@ type User struct { // Announce is an Announce by a Peer. type Announce struct { - Config *config.Config `json:"config"` - Request *http.Request `json:"request"` + Config *config.Config `json:"config"` Compact bool `json:"compact"` Downloaded uint64 `json:"downloaded"` @@ -133,69 +129,6 @@ type Announce struct { Uploaded uint64 `json:"uploaded"` } -// NewAnnounce parses an HTTP request and generates an Announce. -func NewAnnounce(cfg *config.Config, r *http.Request, p httprouter.Params) (*Announce, error) { - q, err := query.New(r.URL.RawQuery) - if err != nil { - return nil, err - } - - compact := q.Params["compact"] != "0" - event, _ := q.Params["event"] - numWant := q.RequestedPeerCount(cfg.NumWantFallback) - - infohash, exists := q.Params["info_hash"] - if !exists { - return nil, ErrMalformedRequest - } - - peerID, exists := q.Params["peer_id"] - if !exists { - return nil, ErrMalformedRequest - } - - ip, err := q.RequestedIP(r) - if err != nil { - return nil, ErrMalformedRequest - } - - port, err := q.Uint64("port") - if err != nil { - return nil, ErrMalformedRequest - } - - left, err := q.Uint64("left") - if err != nil { - return nil, ErrMalformedRequest - } - - downloaded, err := q.Uint64("downloaded") - if err != nil { - return nil, ErrMalformedRequest - } - - uploaded, err := q.Uint64("uploaded") - if err != nil { - return nil, ErrMalformedRequest - } - - return &Announce{ - Config: cfg, - Request: r, - Compact: compact, - Downloaded: downloaded, - Event: event, - IP: ip, - Infohash: infohash, - Left: left, - NumWant: numWant, - Passkey: p.ByName("passkey"), - PeerID: peerID, - Port: port, - Uploaded: uploaded, - }, nil -} - // ClientID returns the part of a PeerID that identifies a Peer's client // software. func (a Announce) ClientID() (clientID string) { @@ -268,33 +201,8 @@ func NewAnnounceDelta(a *Announce, p *Peer, u *User, t *Torrent, created, snatch // Scrape is a Scrape by a Peer. type Scrape struct { - Config *config.Config `json:"config"` - Request *http.Request `json:"request"` + Config *config.Config `json:"config"` Passkey string Infohashes []string } - -// NewScrape parses an HTTP request and generates a Scrape. -func NewScrape(cfg *config.Config, r *http.Request, p httprouter.Params) (*Scrape, error) { - q, err := query.New(r.URL.RawQuery) - if err != nil { - return nil, err - } - - if q.Infohashes == nil { - if _, exists := q.Params["info_hash"]; !exists { - // There aren't any infohashes. - return nil, ErrMalformedRequest - } - q.Infohashes = []string{q.Params["info_hash"]} - } - - return &Scrape{ - Config: cfg, - Request: r, - - Passkey: p.ByName("passkey"), - Infohashes: q.Infohashes, - }, nil -}