diff --git a/config/config.go b/config/config.go
index dde644b..537d6f8 100644
--- a/config/config.go
+++ b/config/config.go
@@ -6,83 +6,83 @@
package config
import (
- "encoding/json"
- "io"
- "os"
- "time"
+ "encoding/json"
+ "io"
+ "os"
+ "time"
)
type Duration struct {
- time.Duration
+ time.Duration
}
func (d *Duration) MarshalJSON() ([]byte, error) {
- return json.Marshal(d.String())
+ return json.Marshal(d.String())
}
func (d *Duration) UnmarshalJSON(b []byte) error {
- var str string
- err := json.Unmarshal(b, &str)
- d.Duration, err = time.ParseDuration(str)
- return err
+ var str string
+ err := json.Unmarshal(b, &str)
+ d.Duration, err = time.ParseDuration(str)
+ return err
}
// DataStore represents the configuration used to connect to a data store.
type DataStore struct {
- Driver string `json:"driver"`
- Network string `json:"network`
- Host string `json:"host"`
- Port string `json:"port"`
- Username string `json:"user"`
- Password string `json:"pass"`
- Schema string `json:"schema,omitempty"`
- Encoding string `json:"encoding,omitempty"`
- Prefix string `json:"prefix,omitempty"`
+ Driver string `json:"driver"`
+ Network string `json:"network`
+ Host string `json:"host"`
+ Port string `json:"port"`
+ Username string `json:"user"`
+ Password string `json:"pass"`
+ Schema string `json:"schema,omitempty"`
+ Encoding string `json:"encoding,omitempty"`
+ Prefix string `json:"prefix,omitempty"`
- MaxIdleConns int `json:"max_idle_conns,omitempty"`
- IdleTimeout *Duration `json:"idle_timeout,omitempty"`
+ MaxIdleConns int `json:"max_idle_conns,omitempty"`
+ IdleTimeout *Duration `json:"idle_timeout,omitempty"`
}
// Config represents a configuration for a server.Server.
type Config struct {
- Addr string `json:"addr"`
- PubAddr string `json:"pub_addr"`
- Cache DataStore `json:"cache"`
- Storage DataStore `json:"storage"`
+ Addr string `json:"addr"`
+ PubAddr string `json:"pub_addr"`
+ Cache DataStore `json:"cache"`
+ Storage DataStore `json:"storage"`
- Private bool `json:"private"`
- Freeleech bool `json:"freeleech"`
- Slots bool `json:"slots"`
+ Private bool `json:"private"`
+ Freeleech bool `json:"freeleech"`
+ Slots bool `json:"slots"`
- Announce Duration `json:"announce"`
- MinAnnounce Duration `json:"min_announce"`
- ReadTimeout Duration `json:"read_timeout"`
- DefaultNumWant int `json:"default_num_want"`
+ Announce Duration `json:"announce"`
+ MinAnnounce Duration `json:"min_announce"`
+ ReadTimeout Duration `json:"read_timeout"`
+ DefaultNumWant int `json:"default_num_want"`
}
// Open is a shortcut to open a file, read it, and generate a Config.
// It supports relative and absolute paths.
func Open(path string) (*Config, error) {
- expandedPath := os.ExpandEnv(path)
- f, err := os.Open(expandedPath)
- if err != nil {
- return nil, err
- }
- defer f.Close()
+ expandedPath := os.ExpandEnv(path)
+ f, err := os.Open(expandedPath)
+ if err != nil {
+ return nil, err
+ }
+ defer f.Close()
- conf, err := newConfig(f)
- if err != nil {
- return nil, err
- }
- return conf, nil
+ conf, err := newConfig(f)
+ if err != nil {
+ return nil, err
+ }
+ return conf, nil
}
// New decodes JSON from a Reader into a Config.
func newConfig(raw io.Reader) (*Config, error) {
- conf := &Config{}
- err := json.NewDecoder(raw).Decode(conf)
- if err != nil {
- return nil, err
- }
- return conf, nil
+ conf := &Config{}
+ err := json.NewDecoder(raw).Decode(conf)
+ if err != nil {
+ return nil, err
+ }
+ return conf, nil
}
diff --git a/server/announce.go b/server/announce.go
index 42970b4..31927d9 100644
--- a/server/announce.go
+++ b/server/announce.go
@@ -5,351 +5,351 @@
package server
import (
- "errors"
- "log"
- "net/http"
- "path"
- "strconv"
- "time"
+ "errors"
+ "log"
+ "net/http"
+ "path"
+ "strconv"
+ "time"
- "github.com/pushrax/chihaya/storage"
+ "github.com/pushrax/chihaya/storage"
)
func (s Server) serveAnnounce(w http.ResponseWriter, r *http.Request) {
- // Parse the required parameters off of a query
- compact, numWant, infohash, peerID, event, ip, port, uploaded, downloaded, left, err := s.validateAnnounceQuery(r)
- if err != nil {
- fail(err, w, r)
- return
- }
+ // Parse the required parameters off of a query
+ compact, numWant, infohash, peerID, event, ip, port, uploaded, downloaded, left, err := s.validateAnnounceQuery(r)
+ if err != nil {
+ fail(err, w, r)
+ return
+ }
- // Get a connection to the tracker db
- conn, err := s.dbConnPool.Get()
- if err != nil {
- log.Panicf("server: %s", err)
- }
+ // Get a connection to the tracker db
+ conn, err := s.dbConnPool.Get()
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
- // Validate the user's passkey
- passkey, _ := path.Split(r.URL.Path)
- user, err := validateUser(conn, passkey)
- if err != nil {
- fail(err, w, r)
- return
- }
+ // Validate the user's passkey
+ passkey, _ := path.Split(r.URL.Path)
+ user, err := validateUser(conn, passkey)
+ if err != nil {
+ fail(err, w, r)
+ return
+ }
- // Check if the user's client is whitelisted
- whitelisted, err := conn.ClientWhitelisted(parsePeerID(peerID))
- if err != nil {
- log.Panicf("server: %s", err)
- }
- if !whitelisted {
- fail(errors.New("Your client is not approved"), w, r)
- return
- }
+ // Check if the user's client is whitelisted
+ whitelisted, err := conn.ClientWhitelisted(parsePeerID(peerID))
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
+ if !whitelisted {
+ fail(errors.New("Your client is not approved"), w, r)
+ return
+ }
- // Find the specified torrent
- torrent, exists, err := conn.FindTorrent(infohash)
- if err != nil {
- log.Panicf("server: %s", err)
- }
- if !exists {
- fail(errors.New("This torrent does not exist"), w, r)
- return
- }
+ // Find the specified torrent
+ torrent, exists, err := conn.FindTorrent(infohash)
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
+ if !exists {
+ fail(errors.New("This torrent does not exist"), w, r)
+ return
+ }
- // If the torrent was pruned and the user is seeding, unprune it
- if !torrent.Active && left == 0 {
- err := conn.MarkActive(torrent)
- if err != nil {
- log.Panicf("server: %s", err)
- }
- }
+ // If the torrent was pruned and the user is seeding, unprune it
+ if !torrent.Active && left == 0 {
+ err := conn.MarkActive(torrent)
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
+ }
- // Create a new peer object from the request
- peer := &storage.Peer{
- ID: peerID,
- UserID: user.ID,
- TorrentID: torrent.ID,
- IP: ip,
- Port: port,
- Uploaded: uploaded,
- Downloaded: downloaded,
- Left: left,
- LastAnnounce: time.Now().Unix(),
- }
+ // Create a new peer object from the request
+ peer := &storage.Peer{
+ ID: peerID,
+ UserID: user.ID,
+ TorrentID: torrent.ID,
+ IP: ip,
+ Port: port,
+ Uploaded: uploaded,
+ Downloaded: downloaded,
+ Left: left,
+ LastAnnounce: time.Now().Unix(),
+ }
- // Look for the user in in the pool of seeders and leechers
- _, seeder := torrent.Seeders[storage.PeerMapKey(peer)]
- _, leecher := torrent.Leechers[storage.PeerMapKey(peer)]
+ // Look for the user in in the pool of seeders and leechers
+ _, seeder := torrent.Seeders[storage.PeerMapKey(peer)]
+ _, leecher := torrent.Leechers[storage.PeerMapKey(peer)]
- switch {
- // Guarantee that no user is in both pools
- case seeder && leecher:
- if left == 0 {
- err := conn.RemoveLeecher(torrent, peer)
- if err != nil {
- log.Panicf("server: %s", err)
- }
- leecher = false
- } else {
- err := conn.RemoveSeeder(torrent, peer)
- if err != nil {
- log.Panicf("server: %s", err)
- }
- seeder = false
- }
+ switch {
+ // Guarantee that no user is in both pools
+ case seeder && leecher:
+ if left == 0 {
+ err := conn.RemoveLeecher(torrent, peer)
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
+ leecher = false
+ } else {
+ err := conn.RemoveSeeder(torrent, peer)
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
+ seeder = false
+ }
- case seeder:
- // Update the peer with the stats from the request
- err := conn.SetSeeder(torrent, peer)
- if err != nil {
- log.Panicf("server: %s", err)
- }
+ case seeder:
+ // Update the peer with the stats from the request
+ err := conn.SetSeeder(torrent, peer)
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
- case leecher:
- // Update the peer with the stats from the request
- err := conn.SetLeecher(torrent, peer)
- if err != nil {
- log.Panicf("server: %s", err)
- }
+ case leecher:
+ // Update the peer with the stats from the request
+ err := conn.SetLeecher(torrent, peer)
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
- default:
- // Check the user's slots to see if they're allowed to leech
- if s.conf.Slots && user.Slots != -1 && left != 0 {
- if user.SlotsUsed >= user.Slots {
- fail(errors.New("You've run out of download slots."), w, r)
- return
- }
- }
+ default:
+ // Check the user's slots to see if they're allowed to leech
+ if s.conf.Slots && user.Slots != -1 && left != 0 {
+ if user.SlotsUsed >= user.Slots {
+ fail(errors.New("You've run out of download slots."), w, r)
+ return
+ }
+ }
- if left == 0 {
- // Save the peer as a new seeder
- err := conn.AddSeeder(torrent, peer)
- if err != nil {
- log.Panicf("server: %s", err)
- }
- } else {
- // Save the peer as a new leecher and increment the user's slots
- err := conn.IncrementSlots(user)
- if err != nil {
- log.Panicf("server: %s", err)
- }
- err = conn.AddLeecher(torrent, peer)
- if err != nil {
- log.Panicf("server: %s", err)
- }
- }
- }
+ if left == 0 {
+ // Save the peer as a new seeder
+ err := conn.AddSeeder(torrent, peer)
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
+ } else {
+ // Save the peer as a new leecher and increment the user's slots
+ err := conn.IncrementSlots(user)
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
+ err = conn.AddLeecher(torrent, peer)
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
+ }
+ }
- // Handle any events in the request
- switch {
- case event == "stopped" || event == "paused":
- if seeder {
- err := conn.RemoveSeeder(torrent, peer)
- if err != nil {
- log.Panicf("server: %s", err)
- }
- }
- if leecher {
- err := conn.RemoveLeecher(torrent, peer)
- if err != nil {
- log.Panicf("server: %s", err)
- }
- err = conn.DecrementSlots(user)
- if err != nil {
- log.Panicf("server: %s", err)
- }
- }
+ // Handle any events in the request
+ switch {
+ case event == "stopped" || event == "paused":
+ if seeder {
+ err := conn.RemoveSeeder(torrent, peer)
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
+ }
+ if leecher {
+ err := conn.RemoveLeecher(torrent, peer)
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
+ err = conn.DecrementSlots(user)
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
+ }
- case event == "completed":
- err := conn.RecordSnatch(user, torrent)
- if err != nil {
- log.Panicf("server: %s", err)
- }
- if leecher {
- err := conn.LeecherFinished(torrent, peer)
- if err != nil {
- log.Panicf("server: %s", err)
- }
- }
+ case event == "completed":
+ err := conn.RecordSnatch(user, torrent)
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
+ if leecher {
+ err := conn.LeecherFinished(torrent, peer)
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
+ }
- case leecher && left == 0:
- // A leecher completed but the event was never received
- err := conn.LeecherFinished(torrent, peer)
- if err != nil {
- log.Panicf("server: %s", err)
- }
- }
+ case leecher && left == 0:
+ // A leecher completed but the event was never received
+ err := conn.LeecherFinished(torrent, peer)
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
+ }
- if ip != peer.IP || port != peer.Port {
- peer.Port = port
- peer.IP = ip
- }
+ if ip != peer.IP || port != peer.Port {
+ peer.Port = port
+ peer.IP = ip
+ }
- // Generate the response
- seedCount := len(torrent.Seeders)
- leechCount := len(torrent.Leechers)
+ // Generate the response
+ seedCount := len(torrent.Seeders)
+ leechCount := len(torrent.Leechers)
- writeBencoded(w, "d")
- writeBencoded(w, "complete")
- writeBencoded(w, seedCount)
- writeBencoded(w, "incomplete")
- writeBencoded(w, leechCount)
- writeBencoded(w, "interval")
- writeBencoded(w, s.conf.Announce.Duration)
- writeBencoded(w, "min interval")
- writeBencoded(w, s.conf.MinAnnounce.Duration)
+ writeBencoded(w, "d")
+ writeBencoded(w, "complete")
+ writeBencoded(w, seedCount)
+ writeBencoded(w, "incomplete")
+ writeBencoded(w, leechCount)
+ writeBencoded(w, "interval")
+ writeBencoded(w, s.conf.Announce.Duration)
+ writeBencoded(w, "min interval")
+ writeBencoded(w, s.conf.MinAnnounce.Duration)
- if numWant > 0 && event != "stopped" && event != "paused" {
- writeBencoded(w, "peers")
- var peerCount, count int
+ if numWant > 0 && event != "stopped" && event != "paused" {
+ writeBencoded(w, "peers")
+ var peerCount, count int
- if compact {
- if left > 0 {
- peerCount = minInt(numWant, leechCount)
- } else {
- peerCount = minInt(numWant, leechCount+seedCount-1)
- }
- writeBencoded(w, strconv.Itoa(peerCount*6))
- writeBencoded(w, ":")
- } else {
- writeBencoded(w, "l")
- }
+ if compact {
+ if left > 0 {
+ peerCount = minInt(numWant, leechCount)
+ } else {
+ peerCount = minInt(numWant, leechCount+seedCount-1)
+ }
+ writeBencoded(w, strconv.Itoa(peerCount*6))
+ writeBencoded(w, ":")
+ } else {
+ writeBencoded(w, "l")
+ }
- if left > 0 {
- // If they're seeding, give them only leechers
- writeLeechers(w, torrent, count, numWant, compact)
- } else {
- // If they're leeching, prioritize giving them seeders
- writeSeeders(w, torrent, count, numWant, compact)
- writeLeechers(w, torrent, count, numWant, compact)
- }
+ if left > 0 {
+ // If they're seeding, give them only leechers
+ writeLeechers(w, torrent, count, numWant, compact)
+ } else {
+ // If they're leeching, prioritize giving them seeders
+ writeSeeders(w, torrent, count, numWant, compact)
+ writeLeechers(w, torrent, count, numWant, compact)
+ }
- if compact && peerCount != count {
- log.Panicf("Calculated peer count (%d) != real count (%d)", peerCount, count)
- }
+ if compact && peerCount != count {
+ log.Panicf("Calculated peer count (%d) != real count (%d)", peerCount, count)
+ }
- if !compact {
- writeBencoded(w, "e")
- }
- }
- writeBencoded(w, "e")
+ if !compact {
+ writeBencoded(w, "e")
+ }
+ }
+ writeBencoded(w, "e")
}
func (s Server) validateAnnounceQuery(r *http.Request) (compact bool, numWant int, infohash, peerID, event, ip string, port, uploaded, downloaded, left uint64, err error) {
- pq, err := parseQuery(r.URL.RawQuery)
- if err != nil {
- return false, 0, "", "", "", "", 0, 0, 0, 0, err
- }
+ pq, err := parseQuery(r.URL.RawQuery)
+ if err != nil {
+ return false, 0, "", "", "", "", 0, 0, 0, 0, err
+ }
- compact = pq.Params["compact"] == "1"
- numWant = requestedPeerCount(s.conf.DefaultNumWant, pq)
- infohash, _ = pq.Params["info_hash"]
- peerID, _ = pq.Params["peer_id"]
- event, _ = pq.Params["event"]
- ip, _ = requestedIP(r, pq)
- port, portErr := pq.getUint64("port")
- uploaded, uploadedErr := pq.getUint64("uploaded")
- downloaded, downloadedErr := pq.getUint64("downloaded")
- left, leftErr := pq.getUint64("left")
+ compact = pq.Params["compact"] == "1"
+ numWant = requestedPeerCount(s.conf.DefaultNumWant, pq)
+ infohash, _ = pq.Params["info_hash"]
+ peerID, _ = pq.Params["peer_id"]
+ event, _ = pq.Params["event"]
+ ip, _ = requestedIP(r, pq)
+ port, portErr := pq.getUint64("port")
+ uploaded, uploadedErr := pq.getUint64("uploaded")
+ downloaded, downloadedErr := pq.getUint64("downloaded")
+ left, leftErr := pq.getUint64("left")
- if infohash == "" ||
- peerID == "" ||
- ip == "" ||
- portErr != nil ||
- uploadedErr != nil ||
- downloadedErr != nil ||
- leftErr != nil {
- return false, 0, "", "", "", "", 0, 0, 0, 0, errors.New("Malformed request")
- }
- return
+ if infohash == "" ||
+ peerID == "" ||
+ ip == "" ||
+ portErr != nil ||
+ uploadedErr != nil ||
+ downloadedErr != nil ||
+ leftErr != nil {
+ return false, 0, "", "", "", "", 0, 0, 0, 0, errors.New("Malformed request")
+ }
+ return
}
func requestedPeerCount(fallback int, pq *parsedQuery) int {
- if numWantStr, exists := pq.Params["numWant"]; exists {
- numWant, err := strconv.Atoi(numWantStr)
- if err != nil {
- return fallback
- }
- return numWant
- }
- return fallback
+ if numWantStr, exists := pq.Params["numWant"]; exists {
+ numWant, err := strconv.Atoi(numWantStr)
+ if err != nil {
+ return fallback
+ }
+ return numWant
+ }
+ return fallback
}
func requestedIP(r *http.Request, pq *parsedQuery) (string, error) {
- ip, ok := pq.Params["ip"]
- ipv4, okv4 := pq.Params["ipv4"]
- xRealIPs, xRealOk := pq.Params["X-Real-Ip"]
+ ip, ok := pq.Params["ip"]
+ ipv4, okv4 := pq.Params["ipv4"]
+ xRealIPs, xRealOk := pq.Params["X-Real-Ip"]
- switch {
- case ok:
- return ip, nil
+ switch {
+ case ok:
+ return ip, nil
- case okv4:
- return ipv4, nil
+ case okv4:
+ return ipv4, nil
- case xRealOk && len(xRealIPs) > 0:
- return string(xRealIPs[0]), nil
+ case xRealOk && len(xRealIPs) > 0:
+ return string(xRealIPs[0]), nil
- default:
- portIndex := len(r.RemoteAddr) - 1
- for ; portIndex >= 0; portIndex-- {
- if r.RemoteAddr[portIndex] == ':' {
- break
- }
- }
- if portIndex != -1 {
- return r.RemoteAddr[0:portIndex], nil
- }
- return "", errors.New("Failed to parse IP address")
- }
+ default:
+ portIndex := len(r.RemoteAddr) - 1
+ for ; portIndex >= 0; portIndex-- {
+ if r.RemoteAddr[portIndex] == ':' {
+ break
+ }
+ }
+ if portIndex != -1 {
+ return r.RemoteAddr[0:portIndex], nil
+ }
+ return "", errors.New("Failed to parse IP address")
+ }
}
func minInt(a, b int) int {
- if a < b {
- return a
- }
- return b
+ if a < b {
+ return a
+ }
+ return b
}
func writeSeeders(w http.ResponseWriter, t *storage.Torrent, count, numWant int, compact bool) {
- for _, seed := range t.Seeders {
- if count >= numWant {
- break
- }
- if compact {
- // TODO writeBencoded(w, compactAddr)
- } else {
- writeBencoded(w, "d")
- writeBencoded(w, "ip")
- writeBencoded(w, seed.IP)
- writeBencoded(w, "peer id")
- writeBencoded(w, seed.ID)
- writeBencoded(w, "port")
- writeBencoded(w, seed.Port)
- writeBencoded(w, "e")
- }
- count++
- }
+ for _, seed := range t.Seeders {
+ if count >= numWant {
+ break
+ }
+ if compact {
+ // TODO writeBencoded(w, compactAddr)
+ } else {
+ writeBencoded(w, "d")
+ writeBencoded(w, "ip")
+ writeBencoded(w, seed.IP)
+ writeBencoded(w, "peer id")
+ writeBencoded(w, seed.ID)
+ writeBencoded(w, "port")
+ writeBencoded(w, seed.Port)
+ writeBencoded(w, "e")
+ }
+ count++
+ }
}
func writeLeechers(w http.ResponseWriter, t *storage.Torrent, count, numWant int, compact bool) {
- for _, leech := range t.Leechers {
- if count >= numWant {
- break
- }
- if compact {
- // TODO writeBencoded(w, compactAddr)
- } else {
- writeBencoded(w, "d")
- writeBencoded(w, "ip")
- writeBencoded(w, leech.IP)
- writeBencoded(w, "peer id")
- writeBencoded(w, leech.ID)
- writeBencoded(w, "port")
- writeBencoded(w, leech.Port)
- writeBencoded(w, "e")
- }
- count++
- }
+ for _, leech := range t.Leechers {
+ if count >= numWant {
+ break
+ }
+ if compact {
+ // TODO writeBencoded(w, compactAddr)
+ } else {
+ writeBencoded(w, "d")
+ writeBencoded(w, "ip")
+ writeBencoded(w, leech.IP)
+ writeBencoded(w, "peer id")
+ writeBencoded(w, leech.ID)
+ writeBencoded(w, "port")
+ writeBencoded(w, leech.Port)
+ writeBencoded(w, "e")
+ }
+ count++
+ }
}
diff --git a/server/scrape.go b/server/scrape.go
index abdb376..3e34efb 100644
--- a/server/scrape.go
+++ b/server/scrape.go
@@ -5,72 +5,72 @@
package server
import (
- "errors"
- "io"
- "log"
- "net/http"
- "path"
+ "errors"
+ "io"
+ "log"
+ "net/http"
+ "path"
- "github.com/pushrax/chihaya/storage"
+ "github.com/pushrax/chihaya/storage"
)
func (s *Server) serveScrape(w http.ResponseWriter, r *http.Request) {
- // Parse the query
- pq, err := parseQuery(r.URL.RawQuery)
- if err != nil {
- fail(errors.New("Error parsing query"), w, r)
- return
- }
+ // Parse the query
+ pq, err := parseQuery(r.URL.RawQuery)
+ if err != nil {
+ fail(errors.New("Error parsing query"), w, r)
+ return
+ }
- // Get a connection to the tracker db
- conn, err := s.dbConnPool.Get()
- if err != nil {
- log.Fatal(err)
- }
+ // Get a connection to the tracker db
+ conn, err := s.dbConnPool.Get()
+ if err != nil {
+ log.Fatal(err)
+ }
- // Find and validate the user
- passkey, _ := path.Split(r.URL.Path)
- _, err = validateUser(conn, passkey)
- if err != nil {
- fail(err, w, r)
- return
- }
+ // Find and validate the user
+ passkey, _ := path.Split(r.URL.Path)
+ _, err = validateUser(conn, passkey)
+ if err != nil {
+ fail(err, w, r)
+ return
+ }
- io.WriteString(w, "d")
- writeBencoded(w, "files")
- if pq.Infohashes != nil {
- for _, infohash := range pq.Infohashes {
- torrent, exists, err := conn.FindTorrent(infohash)
- if err != nil {
- log.Panicf("server: %s", err)
- }
- if exists {
- writeBencoded(w, infohash)
- writeScrapeInfo(w, torrent)
- }
- }
- } else if infohash, exists := pq.Params["info_hash"]; exists {
- torrent, exists, err := conn.FindTorrent(infohash)
- if err != nil {
- log.Panicf("server: %s", err)
- }
- if exists {
- writeBencoded(w, infohash)
- writeScrapeInfo(w, torrent)
- }
- }
- io.WriteString(w, "e")
+ io.WriteString(w, "d")
+ writeBencoded(w, "files")
+ if pq.Infohashes != nil {
+ for _, infohash := range pq.Infohashes {
+ torrent, exists, err := conn.FindTorrent(infohash)
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
+ if exists {
+ writeBencoded(w, infohash)
+ writeScrapeInfo(w, torrent)
+ }
+ }
+ } else if infohash, exists := pq.Params["info_hash"]; exists {
+ torrent, exists, err := conn.FindTorrent(infohash)
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
+ if exists {
+ writeBencoded(w, infohash)
+ writeScrapeInfo(w, torrent)
+ }
+ }
+ io.WriteString(w, "e")
- w.(http.Flusher).Flush()
+ w.(http.Flusher).Flush()
}
func writeScrapeInfo(w io.Writer, torrent *storage.Torrent) {
- io.WriteString(w, "d")
- writeBencoded(w, "complete")
- writeBencoded(w, len(torrent.Seeders))
- writeBencoded(w, "downloaded")
- writeBencoded(w, torrent.Snatches)
- writeBencoded(w, "incomplete")
- writeBencoded(w, len(torrent.Leechers))
- io.WriteString(w, "e")
+ io.WriteString(w, "d")
+ writeBencoded(w, "complete")
+ writeBencoded(w, len(torrent.Seeders))
+ writeBencoded(w, "downloaded")
+ writeBencoded(w, torrent.Snatches)
+ writeBencoded(w, "incomplete")
+ writeBencoded(w, len(torrent.Leechers))
+ io.WriteString(w, "e")
}
diff --git a/server/server.go b/server/server.go
index b41cba2..9d00d81 100644
--- a/server/server.go
+++ b/server/server.go
@@ -6,140 +6,140 @@
package server
import (
- "errors"
- "io"
- "log"
- "net"
- "net/http"
- "path"
- "strconv"
- "sync/atomic"
- "time"
+ "errors"
+ "io"
+ "log"
+ "net"
+ "net/http"
+ "path"
+ "strconv"
+ "sync/atomic"
+ "time"
- "github.com/etix/stoppableListener"
+ "github.com/etix/stoppableListener"
- "github.com/pushrax/chihaya/config"
- "github.com/pushrax/chihaya/storage"
- "github.com/pushrax/chihaya/storage/tracker"
+ "github.com/pushrax/chihaya/config"
+ "github.com/pushrax/chihaya/storage"
+ "github.com/pushrax/chihaya/storage/tracker"
)
type Server struct {
- conf *config.Config
- listener *stoppableListener.StoppableListener
- dbConnPool tracker.Pool
+ conf *config.Config
+ listener *stoppableListener.StoppableListener
+ dbConnPool tracker.Pool
- startTime time.Time
+ startTime time.Time
- deltaRequests int64
- rpm int64
+ deltaRequests int64
+ rpm int64
- http.Server
+ http.Server
}
func New(conf *config.Config) (*Server, error) {
- pool, err := tracker.Open(&conf.Cache)
- if err != nil {
- return nil, err
- }
+ pool, err := tracker.Open(&conf.Cache)
+ if err != nil {
+ return nil, err
+ }
- s := &Server{
- conf: conf,
- dbConnPool: pool,
- Server: http.Server{
- Addr: conf.Addr,
- ReadTimeout: conf.ReadTimeout.Duration,
- },
- }
- s.Server.Handler = s
+ s := &Server{
+ conf: conf,
+ dbConnPool: pool,
+ Server: http.Server{
+ Addr: conf.Addr,
+ ReadTimeout: conf.ReadTimeout.Duration,
+ },
+ }
+ s.Server.Handler = s
- return s, nil
+ return s, nil
}
func (s *Server) ListenAndServe() error {
- l, err := net.Listen("tcp", s.Addr)
- if err != nil {
- return err
- }
- sl := stoppableListener.Handle(l)
- s.listener = sl
- s.startTime = time.Now()
+ l, err := net.Listen("tcp", s.Addr)
+ if err != nil {
+ return err
+ }
+ sl := stoppableListener.Handle(l)
+ s.listener = sl
+ s.startTime = time.Now()
- go s.updateStats()
- s.Serve(s.listener)
+ go s.updateStats()
+ s.Serve(s.listener)
- return nil
+ return nil
}
func (s *Server) Stop() error {
- s.listener.Stop <- true
- err := s.dbConnPool.Close()
- if err != nil {
- return err
- }
- return s.listener.Close()
+ s.listener.Stop <- true
+ err := s.dbConnPool.Close()
+ if err != nil {
+ return err
+ }
+ return s.listener.Close()
}
func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
- defer atomic.AddInt64(&s.deltaRequests, 1)
- r.Close = true
+ defer atomic.AddInt64(&s.deltaRequests, 1)
+ r.Close = true
- switch r.URL.Path {
- case "/stats":
- s.serveStats(w, r)
- return
- case "/add":
- s.serveAdd(w, r)
- return
- case "/remove":
- s.serveRemove(w, r)
- return
- }
+ switch r.URL.Path {
+ case "/stats":
+ s.serveStats(w, r)
+ return
+ case "/add":
+ s.serveAdd(w, r)
+ return
+ case "/remove":
+ s.serveRemove(w, r)
+ return
+ }
- _, action := path.Split(r.URL.Path)
- switch action {
- case "announce":
- s.serveAnnounce(w, r)
- return
- case "scrape":
- s.serveScrape(w, r)
- return
- default:
- fail(errors.New("Unknown action"), w, r)
- return
- }
+ _, action := path.Split(r.URL.Path)
+ switch action {
+ case "announce":
+ s.serveAnnounce(w, r)
+ return
+ case "scrape":
+ s.serveScrape(w, r)
+ return
+ default:
+ fail(errors.New("Unknown action"), w, r)
+ return
+ }
}
func fail(err error, w http.ResponseWriter, r *http.Request) {
- errmsg := err.Error()
- message := "d14:failure reason" + strconv.Itoa(len(errmsg)) + ":" + errmsg + "e"
- length, _ := io.WriteString(w, message)
- w.Header().Add("Content-Length", string(length))
- w.(http.Flusher).Flush()
+ errmsg := err.Error()
+ message := "d14:failure reason" + strconv.Itoa(len(errmsg)) + ":" + errmsg + "e"
+ length, _ := io.WriteString(w, message)
+ w.Header().Add("Content-Length", string(length))
+ w.(http.Flusher).Flush()
}
func validateUser(conn tracker.Conn, dir string) (*storage.User, error) {
- if len(dir) != 34 {
- return nil, errors.New("Passkey is invalid")
- }
- passkey := dir[1:33]
+ if len(dir) != 34 {
+ return nil, errors.New("Passkey is invalid")
+ }
+ passkey := dir[1:33]
- user, exists, err := conn.FindUser(passkey)
- if err != nil {
- log.Panicf("server: %s", err)
- }
- if !exists {
- return nil, errors.New("User not found")
- }
+ user, exists, err := conn.FindUser(passkey)
+ if err != nil {
+ log.Panicf("server: %s", err)
+ }
+ if !exists {
+ return nil, errors.New("User not found")
+ }
- return user, nil
+ return user, nil
}
// Takes a peer_id and returns a ClientID
func parsePeerID(peerID string) (clientID string) {
- if peerID[0] == '-' {
- clientID = peerID[1:7]
- } else {
- clientID = peerID[0:6]
- }
- return
+ if peerID[0] == '-' {
+ clientID = peerID[1:7]
+ } else {
+ clientID = peerID[0:6]
+ }
+ return
}
diff --git a/server/stats.go b/server/stats.go
index df94099..6e0a074 100644
--- a/server/stats.go
+++ b/server/stats.go
@@ -5,35 +5,35 @@
package server
import (
- "encoding/json"
- "net/http"
- "sync/atomic"
- "time"
+ "encoding/json"
+ "net/http"
+ "sync/atomic"
+ "time"
- "github.com/pushrax/chihaya/config"
+ "github.com/pushrax/chihaya/config"
)
type stats struct {
- Uptime config.Duration `json:"uptime"`
- RPM int64 `json:"req_per_min"`
+ Uptime config.Duration `json:"uptime"`
+ RPM int64 `json:"req_per_min"`
}
func (s *Server) serveStats(w http.ResponseWriter, r *http.Request) {
- w.Header().Set("Content-Type", "application/json")
+ w.Header().Set("Content-Type", "application/json")
- stats, _ := json.Marshal(&stats{
- config.Duration{time.Now().Sub(s.startTime)},
- s.rpm,
- })
+ stats, _ := json.Marshal(&stats{
+ config.Duration{time.Now().Sub(s.startTime)},
+ s.rpm,
+ })
- length, _ := w.Write(stats)
- w.Header().Set("Content-Length", string(length))
- w.(http.Flusher).Flush()
+ length, _ := w.Write(stats)
+ w.Header().Set("Content-Length", string(length))
+ w.(http.Flusher).Flush()
}
func (s *Server) updateStats() {
- for _ = range time.NewTicker(time.Minute).C {
- s.rpm = s.deltaRequests
- atomic.StoreInt64(&s.deltaRequests, 0)
- }
+ for _ = range time.NewTicker(time.Minute).C {
+ s.rpm = s.deltaRequests
+ atomic.StoreInt64(&s.deltaRequests, 0)
+ }
}
diff --git a/server/stats_test.go b/server/stats_test.go
index d0fb0eb..0c1816f 100644
--- a/server/stats_test.go
+++ b/server/stats_test.go
@@ -5,51 +5,51 @@
package server
import (
- "errors"
- "net/http"
- "net/http/httptest"
- "os"
- "testing"
+ "errors"
+ "net/http"
+ "net/http/httptest"
+ "os"
+ "testing"
- "github.com/pushrax/chihaya/config"
+ "github.com/pushrax/chihaya/config"
- _ "github.com/pushrax/chihaya/storage/backend/batter"
- _ "github.com/pushrax/chihaya/storage/tracker/redis"
+ _ "github.com/pushrax/chihaya/storage/backend/batter"
+ _ "github.com/pushrax/chihaya/storage/tracker/redis"
)
func newTestServer() (*Server, error) {
- testConfig, err := config.Open(os.Getenv("TESTCONFIGPATH"))
- if err != nil {
- return nil, err
- }
+ testConfig, err := config.Open(os.Getenv("TESTCONFIGPATH"))
+ if err != nil {
+ return nil, err
+ }
- s, err := New(testConfig)
- if err != nil {
- return nil, err
- }
+ s, err := New(testConfig)
+ if err != nil {
+ return nil, err
+ }
- return s, nil
+ return s, nil
}
func TestStats(t *testing.T) {
- s, err := newTestServer()
- if err != nil {
- t.Error(err)
- }
+ s, err := newTestServer()
+ if err != nil {
+ t.Error(err)
+ }
- r, err := http.NewRequest("GET", "127.0.0.1:80/stats", nil)
- if err != nil {
- t.Error(err)
- }
+ r, err := http.NewRequest("GET", "127.0.0.1:80/stats", nil)
+ if err != nil {
+ t.Error(err)
+ }
- w := httptest.NewRecorder()
- s.serveStats(w, r)
+ w := httptest.NewRecorder()
+ s.serveStats(w, r)
- if w.Code != 200 {
- t.Error(errors.New("/stats did not return HTTP 200"))
- }
+ if w.Code != 200 {
+ t.Error(errors.New("/stats did not return HTTP 200"))
+ }
- if w.Header()["Content-Type"][0] != "application/json" {
- t.Error(errors.New("/stats did not return the proper Content-Type header"))
- }
+ if w.Header()["Content-Type"][0] != "application/json" {
+ t.Error(errors.New("/stats did not return the proper Content-Type header"))
+ }
}
diff --git a/storage/tracker/redis/conn_test.go b/storage/tracker/redis/conn_test.go
index 2893c6f..11f4439 100644
--- a/storage/tracker/redis/conn_test.go
+++ b/storage/tracker/redis/conn_test.go
@@ -5,559 +5,559 @@
package redis
import (
- "math/rand"
- "os"
- "reflect"
- "testing"
- "time"
+ "math/rand"
+ "os"
+ "reflect"
+ "testing"
+ "time"
- "github.com/pushrax/chihaya/config"
- "github.com/pushrax/chihaya/storage"
- "github.com/pushrax/chihaya/storage/tracker"
+ "github.com/pushrax/chihaya/config"
+ "github.com/pushrax/chihaya/storage"
+ "github.com/pushrax/chihaya/storage/tracker"
)
func createTestConn() tracker.Conn {
- testConfig, err := config.Open(os.Getenv("TESTCONFIGPATH"))
- panicOnErr(err)
- conf := &testConfig.Cache
+ testConfig, err := config.Open(os.Getenv("TESTCONFIGPATH"))
+ panicOnErr(err)
+ conf := &testConfig.Cache
- testPool, err := tracker.Open(conf)
- panicOnErr(err)
+ testPool, err := tracker.Open(conf)
+ panicOnErr(err)
- newConn, err := testPool.Get()
- panicOnErr(err)
+ newConn, err := testPool.Get()
+ panicOnErr(err)
- return newConn
+ return newConn
}
func TestFindUserSuccess(t *testing.T) {
- conn := createTestConn()
- testUser := createTestUser()
+ conn := createTestConn()
+ testUser := createTestUser()
- panicOnErr(conn.AddUser(testUser))
- foundUser, found, err := conn.FindUser(testUser.Passkey)
- panicOnErr(err)
- if !found {
- t.Error("user not found", testUser)
- }
- if *foundUser != *testUser {
- t.Error("found user mismatch", *foundUser, testUser)
- }
- // Cleanup
- panicOnErr(conn.RemoveUser(testUser))
+ panicOnErr(conn.AddUser(testUser))
+ foundUser, found, err := conn.FindUser(testUser.Passkey)
+ panicOnErr(err)
+ if !found {
+ t.Error("user not found", testUser)
+ }
+ if *foundUser != *testUser {
+ t.Error("found user mismatch", *foundUser, testUser)
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveUser(testUser))
}
func TestFindUserFail(t *testing.T) {
- conn := createTestConn()
- testUser := createTestUser()
+ conn := createTestConn()
+ testUser := createTestUser()
- foundUser, found, err := conn.FindUser(testUser.Passkey)
- panicOnErr(err)
- if found {
- t.Error("user found", foundUser)
- }
+ foundUser, found, err := conn.FindUser(testUser.Passkey)
+ panicOnErr(err)
+ if found {
+ t.Error("user found", foundUser)
+ }
}
func TestRemoveUser(t *testing.T) {
- conn := createTestConn()
- testUser := createTestUser()
+ conn := createTestConn()
+ testUser := createTestUser()
- panicOnErr(conn.AddUser(testUser))
- err := conn.RemoveUser(testUser)
- panicOnErr(err)
- foundUser, found, err := conn.FindUser(testUser.Passkey)
- panicOnErr(err)
- if found {
- t.Error("removed user found", foundUser)
- }
+ panicOnErr(conn.AddUser(testUser))
+ err := conn.RemoveUser(testUser)
+ panicOnErr(err)
+ foundUser, found, err := conn.FindUser(testUser.Passkey)
+ panicOnErr(err)
+ if found {
+ t.Error("removed user found", foundUser)
+ }
}
func TestFindTorrentSuccess(t *testing.T) {
- conn := createTestConn()
- testTorrent := createTestTorrent()
- panicOnErr(conn.AddTorrent(testTorrent))
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ panicOnErr(conn.AddTorrent(testTorrent))
- foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
- panicOnErr(err)
- if !found {
- t.Error("torrent not found", testTorrent)
- }
- if !reflect.DeepEqual(foundTorrent, testTorrent) {
- t.Error("found torrent mismatch", foundTorrent, testTorrent)
- }
- // Cleanup
- panicOnErr(conn.RemoveTorrent(testTorrent))
+ foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
+ panicOnErr(err)
+ if !found {
+ t.Error("torrent not found", testTorrent)
+ }
+ if !reflect.DeepEqual(foundTorrent, testTorrent) {
+ t.Error("found torrent mismatch", foundTorrent, testTorrent)
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveTorrent(testTorrent))
}
func TestFindTorrentFail(t *testing.T) {
- conn := createTestConn()
- testTorrent := createTestTorrent()
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
- foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
- panicOnErr(err)
- if found {
- t.Error("torrent found", foundTorrent)
- }
+ foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
+ panicOnErr(err)
+ if found {
+ t.Error("torrent found", foundTorrent)
+ }
}
func TestRemoveTorrent(t *testing.T) {
- conn := createTestConn()
- testTorrent := createTestTorrent()
- panicOnErr(conn.AddTorrent(testTorrent))
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ panicOnErr(conn.AddTorrent(testTorrent))
- panicOnErr(conn.RemoveTorrent(testTorrent))
- foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
- panicOnErr(err)
- if found {
- t.Error("removed torrent found", foundTorrent)
- }
- // Cleanup
- panicOnErr(conn.RemoveTorrent(testTorrent))
+ panicOnErr(conn.RemoveTorrent(testTorrent))
+ foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
+ panicOnErr(err)
+ if found {
+ t.Error("removed torrent found", foundTorrent)
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveTorrent(testTorrent))
}
func TestClientWhitelistSuccess(t *testing.T) {
- conn := createTestConn()
- testPeerID := "-lt0D30-"
+ conn := createTestConn()
+ testPeerID := "-lt0D30-"
- panicOnErr(conn.WhitelistClient(testPeerID))
- found, err := conn.ClientWhitelisted(testPeerID)
- panicOnErr(err)
- if !found {
- t.Error("peerID not found", testPeerID)
- }
- // Cleanup
- panicOnErr(conn.UnWhitelistClient(testPeerID))
+ panicOnErr(conn.WhitelistClient(testPeerID))
+ found, err := conn.ClientWhitelisted(testPeerID)
+ panicOnErr(err)
+ if !found {
+ t.Error("peerID not found", testPeerID)
+ }
+ // Cleanup
+ panicOnErr(conn.UnWhitelistClient(testPeerID))
}
func TestClientWhitelistFail(t *testing.T) {
- conn := createTestConn()
- testPeerID2 := "TIX0192"
+ conn := createTestConn()
+ testPeerID2 := "TIX0192"
- found, err := conn.ClientWhitelisted(testPeerID2)
- panicOnErr(err)
- if found {
- t.Error("peerID found", testPeerID2)
- }
+ found, err := conn.ClientWhitelisted(testPeerID2)
+ panicOnErr(err)
+ if found {
+ t.Error("peerID found", testPeerID2)
+ }
}
func TestRecordSnatch(t *testing.T) {
- conn := createTestConn()
- testTorrent := createTestTorrent()
- testUser := createTestUser()
- panicOnErr(conn.AddTorrent(testTorrent))
- panicOnErr(conn.AddUser(testUser))
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ testUser := createTestUser()
+ panicOnErr(conn.AddTorrent(testTorrent))
+ panicOnErr(conn.AddUser(testUser))
- userSnatches := testUser.Snatches
- torrentSnatches := testTorrent.Snatches
+ userSnatches := testUser.Snatches
+ torrentSnatches := testTorrent.Snatches
- panicOnErr(conn.RecordSnatch(testUser, testTorrent))
+ panicOnErr(conn.RecordSnatch(testUser, testTorrent))
- foundTorrent, _, err := conn.FindTorrent(testTorrent.Infohash)
- panicOnErr(err)
- foundUser, _, err := conn.FindUser(testUser.Passkey)
- panicOnErr(err)
+ foundTorrent, _, err := conn.FindTorrent(testTorrent.Infohash)
+ panicOnErr(err)
+ foundUser, _, err := conn.FindUser(testUser.Passkey)
+ panicOnErr(err)
- if testUser.Snatches != userSnatches+1 {
- t.Error("snatch not recorded to local user", testUser.Snatches, userSnatches+1)
- }
- if testTorrent.Snatches != torrentSnatches+1 {
- t.Error("snatch not recorded to local torrent")
- }
- if foundUser.Snatches != userSnatches+1 {
- t.Error("snatch not recorded to cached user", foundUser.Snatches, userSnatches+1)
- }
- if foundTorrent.Snatches != torrentSnatches+1 {
- t.Error("snatch not recorded to cached torrent")
- }
- // Cleanup
- panicOnErr(conn.RemoveTorrent(testTorrent))
- panicOnErr(conn.RemoveUser(testUser))
+ if testUser.Snatches != userSnatches+1 {
+ t.Error("snatch not recorded to local user", testUser.Snatches, userSnatches+1)
+ }
+ if testTorrent.Snatches != torrentSnatches+1 {
+ t.Error("snatch not recorded to local torrent")
+ }
+ if foundUser.Snatches != userSnatches+1 {
+ t.Error("snatch not recorded to cached user", foundUser.Snatches, userSnatches+1)
+ }
+ if foundTorrent.Snatches != torrentSnatches+1 {
+ t.Error("snatch not recorded to cached torrent")
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveTorrent(testTorrent))
+ panicOnErr(conn.RemoveUser(testUser))
}
func TestMarkActive(t *testing.T) {
- conn := createTestConn()
- testTorrent := createTestTorrent()
- testTorrent.Active = false
- panicOnErr(conn.AddTorrent(testTorrent))
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ testTorrent.Active = false
+ panicOnErr(conn.AddTorrent(testTorrent))
- panicOnErr(conn.MarkActive(testTorrent))
- foundTorrent, _, err := conn.FindTorrent(testTorrent.Infohash)
- panicOnErr(err)
+ panicOnErr(conn.MarkActive(testTorrent))
+ foundTorrent, _, err := conn.FindTorrent(testTorrent.Infohash)
+ panicOnErr(err)
- if foundTorrent.Active != true {
- t.Error("cached torrent not activated")
- }
- if testTorrent.Active != true {
- t.Error("cached torrent not activated")
- }
- // Cleanup
- panicOnErr(conn.RemoveTorrent(testTorrent))
+ if foundTorrent.Active != true {
+ t.Error("cached torrent not activated")
+ }
+ if testTorrent.Active != true {
+ t.Error("cached torrent not activated")
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveTorrent(testTorrent))
}
func TestClientWhitelistRemove(t *testing.T) {
- conn := createTestConn()
- testPeerID := "-lt0D30-"
- panicOnErr(conn.WhitelistClient(testPeerID))
- panicOnErr(conn.UnWhitelistClient(testPeerID))
+ conn := createTestConn()
+ testPeerID := "-lt0D30-"
+ panicOnErr(conn.WhitelistClient(testPeerID))
+ panicOnErr(conn.UnWhitelistClient(testPeerID))
- found, err := conn.ClientWhitelisted(testPeerID)
- panicOnErr(err)
- if found {
- t.Error("removed peerID found", testPeerID)
- }
+ found, err := conn.ClientWhitelisted(testPeerID)
+ panicOnErr(err)
+ if found {
+ t.Error("removed peerID found", testPeerID)
+ }
}
func TestAddSeeder(t *testing.T) {
- conn := createTestConn()
- testTorrent := createTestTorrent()
- panicOnErr(conn.AddTorrent(testTorrent))
- testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ panicOnErr(conn.AddTorrent(testTorrent))
+ testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
- panicOnErr(conn.AddSeeder(testTorrent, testSeeder))
- foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
- panicOnErr(err)
- foundSeeder, found := foundTorrent.Seeders[storage.PeerMapKey(testSeeder)]
- if found && foundSeeder != *testSeeder {
- t.Error("seeder not added to cache", testSeeder)
- }
- foundSeeder, found = testTorrent.Seeders[storage.PeerMapKey(testSeeder)]
- if found && foundSeeder != *testSeeder {
- t.Error("seeder not added to local", testSeeder)
- }
- // Cleanup
- panicOnErr(conn.RemoveTorrent(testTorrent))
+ panicOnErr(conn.AddSeeder(testTorrent, testSeeder))
+ foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
+ panicOnErr(err)
+ foundSeeder, found := foundTorrent.Seeders[storage.PeerMapKey(testSeeder)]
+ if found && foundSeeder != *testSeeder {
+ t.Error("seeder not added to cache", testSeeder)
+ }
+ foundSeeder, found = testTorrent.Seeders[storage.PeerMapKey(testSeeder)]
+ if found && foundSeeder != *testSeeder {
+ t.Error("seeder not added to local", testSeeder)
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveTorrent(testTorrent))
}
func TestAddLeecher(t *testing.T) {
- conn := createTestConn()
- testTorrent := createTestTorrent()
- panicOnErr(conn.AddTorrent(testTorrent))
- testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ panicOnErr(conn.AddTorrent(testTorrent))
+ testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
- panicOnErr(conn.AddLeecher(testTorrent, testLeecher))
- foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
- panicOnErr(err)
- foundLeecher, found := foundTorrent.Leechers[storage.PeerMapKey(testLeecher)]
- if found && foundLeecher != *testLeecher {
- t.Error("leecher not added to cache", testLeecher)
- }
- foundLeecher, found = testTorrent.Leechers[storage.PeerMapKey(testLeecher)]
- if found && foundLeecher != *testLeecher {
- t.Error("leecher not added to local", testLeecher)
- }
- // Cleanup
- panicOnErr(conn.RemoveTorrent(testTorrent))
+ panicOnErr(conn.AddLeecher(testTorrent, testLeecher))
+ foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
+ panicOnErr(err)
+ foundLeecher, found := foundTorrent.Leechers[storage.PeerMapKey(testLeecher)]
+ if found && foundLeecher != *testLeecher {
+ t.Error("leecher not added to cache", testLeecher)
+ }
+ foundLeecher, found = testTorrent.Leechers[storage.PeerMapKey(testLeecher)]
+ if found && foundLeecher != *testLeecher {
+ t.Error("leecher not added to local", testLeecher)
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveTorrent(testTorrent))
}
func TestRemoveSeeder(t *testing.T) {
- conn := createTestConn()
- testTorrent := createTestTorrent()
- panicOnErr(conn.AddTorrent(testTorrent))
- testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
- panicOnErr(conn.AddSeeder(testTorrent, testSeeder))
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ panicOnErr(conn.AddTorrent(testTorrent))
+ testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
+ panicOnErr(conn.AddSeeder(testTorrent, testSeeder))
- panicOnErr(conn.RemoveSeeder(testTorrent, testSeeder))
- foundSeeder, found := testTorrent.Seeders[storage.PeerMapKey(testSeeder)]
- if found || foundSeeder == *testSeeder {
- t.Error("seeder not removed from local", foundSeeder)
- }
+ panicOnErr(conn.RemoveSeeder(testTorrent, testSeeder))
+ foundSeeder, found := testTorrent.Seeders[storage.PeerMapKey(testSeeder)]
+ if found || foundSeeder == *testSeeder {
+ t.Error("seeder not removed from local", foundSeeder)
+ }
- foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
- panicOnErr(err)
- foundSeeder, found = foundTorrent.Seeders[storage.PeerMapKey(testSeeder)]
- if found || foundSeeder == *testSeeder {
- t.Error("seeder not removed from cache", foundSeeder, *testSeeder)
- }
- // Cleanup
- panicOnErr(conn.RemoveTorrent(testTorrent))
+ foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
+ panicOnErr(err)
+ foundSeeder, found = foundTorrent.Seeders[storage.PeerMapKey(testSeeder)]
+ if found || foundSeeder == *testSeeder {
+ t.Error("seeder not removed from cache", foundSeeder, *testSeeder)
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveTorrent(testTorrent))
}
func TestRemoveLeecher(t *testing.T) {
- conn := createTestConn()
- testTorrent := createTestTorrent()
- panicOnErr(conn.AddTorrent(testTorrent))
- testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
- panicOnErr(conn.AddLeecher(testTorrent, testLeecher))
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ panicOnErr(conn.AddTorrent(testTorrent))
+ testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
+ panicOnErr(conn.AddLeecher(testTorrent, testLeecher))
- panicOnErr(conn.RemoveLeecher(testTorrent, testLeecher))
- foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
- panicOnErr(err)
- foundLeecher, found := foundTorrent.Leechers[storage.PeerMapKey(testLeecher)]
- if found || foundLeecher == *testLeecher {
- t.Error("leecher not removed from cache", foundLeecher, *testLeecher)
- }
- foundLeecher, found = testTorrent.Leechers[storage.PeerMapKey(testLeecher)]
- if found || foundLeecher == *testLeecher {
- t.Error("leecher not removed from local", foundLeecher, *testLeecher)
- }
- // Cleanup
- panicOnErr(conn.RemoveTorrent(testTorrent))
+ panicOnErr(conn.RemoveLeecher(testTorrent, testLeecher))
+ foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
+ panicOnErr(err)
+ foundLeecher, found := foundTorrent.Leechers[storage.PeerMapKey(testLeecher)]
+ if found || foundLeecher == *testLeecher {
+ t.Error("leecher not removed from cache", foundLeecher, *testLeecher)
+ }
+ foundLeecher, found = testTorrent.Leechers[storage.PeerMapKey(testLeecher)]
+ if found || foundLeecher == *testLeecher {
+ t.Error("leecher not removed from local", foundLeecher, *testLeecher)
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveTorrent(testTorrent))
}
func TestSetSeeder(t *testing.T) {
- conn := createTestConn()
- testTorrent := createTestTorrent()
- panicOnErr(conn.AddTorrent(testTorrent))
- testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
- panicOnErr(conn.AddSeeder(testTorrent, testSeeder))
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ panicOnErr(conn.AddTorrent(testTorrent))
+ testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
+ panicOnErr(conn.AddSeeder(testTorrent, testSeeder))
- r := rand.New(rand.NewSource(time.Now().UnixNano()))
- testSeeder.Uploaded += uint64(r.Int63())
+ r := rand.New(rand.NewSource(time.Now().UnixNano()))
+ testSeeder.Uploaded += uint64(r.Int63())
- panicOnErr(conn.SetSeeder(testTorrent, testSeeder))
+ panicOnErr(conn.SetSeeder(testTorrent, testSeeder))
- foundTorrent, _, err := conn.FindTorrent(testTorrent.Infohash)
- panicOnErr(err)
- foundSeeder, _ := foundTorrent.Seeders[storage.PeerMapKey(testSeeder)]
- if foundSeeder != *testSeeder {
- t.Error("seeder not updated in cache", foundSeeder, *testSeeder)
- }
- foundSeeder, _ = testTorrent.Seeders[storage.PeerMapKey(testSeeder)]
- if foundSeeder != *testSeeder {
- t.Error("seeder not updated in local", foundSeeder, *testSeeder)
- }
- // Cleanup
- panicOnErr(conn.RemoveTorrent(testTorrent))
+ foundTorrent, _, err := conn.FindTorrent(testTorrent.Infohash)
+ panicOnErr(err)
+ foundSeeder, _ := foundTorrent.Seeders[storage.PeerMapKey(testSeeder)]
+ if foundSeeder != *testSeeder {
+ t.Error("seeder not updated in cache", foundSeeder, *testSeeder)
+ }
+ foundSeeder, _ = testTorrent.Seeders[storage.PeerMapKey(testSeeder)]
+ if foundSeeder != *testSeeder {
+ t.Error("seeder not updated in local", foundSeeder, *testSeeder)
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveTorrent(testTorrent))
}
func TestSetLeecher(t *testing.T) {
- conn := createTestConn()
- testTorrent := createTestTorrent()
- panicOnErr(conn.AddTorrent(testTorrent))
- testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
- panicOnErr(conn.AddLeecher(testTorrent, testLeecher))
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ panicOnErr(conn.AddTorrent(testTorrent))
+ testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
+ panicOnErr(conn.AddLeecher(testTorrent, testLeecher))
- r := rand.New(rand.NewSource(time.Now().UnixNano()))
- testLeecher.Uploaded += uint64(r.Int63())
+ r := rand.New(rand.NewSource(time.Now().UnixNano()))
+ testLeecher.Uploaded += uint64(r.Int63())
- panicOnErr(conn.SetLeecher(testTorrent, testLeecher))
- foundTorrent, _, err := conn.FindTorrent(testTorrent.Infohash)
- panicOnErr(err)
- foundLeecher, _ := foundTorrent.Leechers[storage.PeerMapKey(testLeecher)]
- if foundLeecher != *testLeecher {
- t.Error("leecher not updated in cache", testLeecher)
- }
- foundLeecher, _ = testTorrent.Leechers[storage.PeerMapKey(testLeecher)]
- if foundLeecher != *testLeecher {
- t.Error("leecher not updated in local", testLeecher)
- }
- // Cleanup
- panicOnErr(conn.RemoveTorrent(testTorrent))
+ panicOnErr(conn.SetLeecher(testTorrent, testLeecher))
+ foundTorrent, _, err := conn.FindTorrent(testTorrent.Infohash)
+ panicOnErr(err)
+ foundLeecher, _ := foundTorrent.Leechers[storage.PeerMapKey(testLeecher)]
+ if foundLeecher != *testLeecher {
+ t.Error("leecher not updated in cache", testLeecher)
+ }
+ foundLeecher, _ = testTorrent.Leechers[storage.PeerMapKey(testLeecher)]
+ if foundLeecher != *testLeecher {
+ t.Error("leecher not updated in local", testLeecher)
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveTorrent(testTorrent))
}
func TestIncrementSlots(t *testing.T) {
- conn := createTestConn()
- testUser := createTestUser()
- panicOnErr(conn.AddUser(testUser))
- numSlots := testUser.Slots
+ conn := createTestConn()
+ testUser := createTestUser()
+ panicOnErr(conn.AddUser(testUser))
+ numSlots := testUser.Slots
- panicOnErr(conn.IncrementSlots(testUser))
- foundUser, _, err := conn.FindUser(testUser.Passkey)
- panicOnErr(err)
+ panicOnErr(conn.IncrementSlots(testUser))
+ foundUser, _, err := conn.FindUser(testUser.Passkey)
+ panicOnErr(err)
- if foundUser.Slots != numSlots+1 {
- t.Error("cached slots not incremented")
- }
- if testUser.Slots != numSlots+1 {
- t.Error("local slots not incremented")
- }
- // Cleanup
- panicOnErr(conn.RemoveUser(testUser))
+ if foundUser.Slots != numSlots+1 {
+ t.Error("cached slots not incremented")
+ }
+ if testUser.Slots != numSlots+1 {
+ t.Error("local slots not incremented")
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveUser(testUser))
}
func TestDecrementSlots(t *testing.T) {
- conn := createTestConn()
- testUser := createTestUser()
- panicOnErr(conn.AddUser(testUser))
- numSlots := testUser.Slots
+ conn := createTestConn()
+ testUser := createTestUser()
+ panicOnErr(conn.AddUser(testUser))
+ numSlots := testUser.Slots
- panicOnErr(conn.DecrementSlots(testUser))
- foundUser, _, err := conn.FindUser(testUser.Passkey)
- panicOnErr(err)
+ panicOnErr(conn.DecrementSlots(testUser))
+ foundUser, _, err := conn.FindUser(testUser.Passkey)
+ panicOnErr(err)
- if foundUser.Slots != numSlots-1 {
- t.Error("cached slots not incremented")
- }
- if testUser.Slots != numSlots-1 {
- t.Error("local slots not incremented")
- }
- // Cleanup
- panicOnErr(conn.RemoveUser(testUser))
+ if foundUser.Slots != numSlots-1 {
+ t.Error("cached slots not incremented")
+ }
+ if testUser.Slots != numSlots-1 {
+ t.Error("local slots not incremented")
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveUser(testUser))
}
func TestLeecherFinished(t *testing.T) {
- conn := createTestConn()
- testTorrent := createTestTorrent()
- panicOnErr(conn.AddTorrent(testTorrent))
- testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
- panicOnErr(conn.AddLeecher(testTorrent, testLeecher))
- testLeecher.Left = 0
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ panicOnErr(conn.AddTorrent(testTorrent))
+ testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
+ panicOnErr(conn.AddLeecher(testTorrent, testLeecher))
+ testLeecher.Left = 0
- panicOnErr(conn.LeecherFinished(testTorrent, testLeecher))
+ panicOnErr(conn.LeecherFinished(testTorrent, testLeecher))
- foundTorrent, _, err := conn.FindTorrent(testTorrent.Infohash)
- panicOnErr(err)
- foundSeeder, _ := foundTorrent.Seeders[storage.PeerMapKey(testLeecher)]
- if foundSeeder != *testLeecher {
- t.Error("seeder not added to cache", foundSeeder, *testLeecher)
- }
- foundSeeder, _ = foundTorrent.Leechers[storage.PeerMapKey(testLeecher)]
- if foundSeeder == *testLeecher {
- t.Error("leecher not removed from cache", testLeecher)
- }
- foundSeeder, _ = testTorrent.Seeders[storage.PeerMapKey(testLeecher)]
- if foundSeeder != *testLeecher {
- t.Error("seeder not added to local", testLeecher)
- }
- foundSeeder, _ = testTorrent.Leechers[storage.PeerMapKey(testLeecher)]
- if foundSeeder == *testLeecher {
- t.Error("leecher not removed from local", testLeecher)
- }
- // Cleanup
- panicOnErr(conn.RemoveTorrent(testTorrent))
+ foundTorrent, _, err := conn.FindTorrent(testTorrent.Infohash)
+ panicOnErr(err)
+ foundSeeder, _ := foundTorrent.Seeders[storage.PeerMapKey(testLeecher)]
+ if foundSeeder != *testLeecher {
+ t.Error("seeder not added to cache", foundSeeder, *testLeecher)
+ }
+ foundSeeder, _ = foundTorrent.Leechers[storage.PeerMapKey(testLeecher)]
+ if foundSeeder == *testLeecher {
+ t.Error("leecher not removed from cache", testLeecher)
+ }
+ foundSeeder, _ = testTorrent.Seeders[storage.PeerMapKey(testLeecher)]
+ if foundSeeder != *testLeecher {
+ t.Error("seeder not added to local", testLeecher)
+ }
+ foundSeeder, _ = testTorrent.Leechers[storage.PeerMapKey(testLeecher)]
+ if foundSeeder == *testLeecher {
+ t.Error("leecher not removed from local", testLeecher)
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveTorrent(testTorrent))
}
// Add, update, verify remove
func TestUpdatePeer(t *testing.T) {
- conn := createTestConn()
- testTorrent := createTestTorrent()
- testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
- panicOnErr(conn.AddTorrent(testTorrent))
- panicOnErr(conn.AddSeeder(testTorrent, testSeeder))
- // Update a seeder, set it, then check to make sure it updated
- r := rand.New(rand.NewSource(time.Now().UnixNano()))
- testSeeder.Uploaded += uint64(r.Int63())
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
+ panicOnErr(conn.AddTorrent(testTorrent))
+ panicOnErr(conn.AddSeeder(testTorrent, testSeeder))
+ // Update a seeder, set it, then check to make sure it updated
+ r := rand.New(rand.NewSource(time.Now().UnixNano()))
+ testSeeder.Uploaded += uint64(r.Int63())
- panicOnErr(conn.SetSeeder(testTorrent, testSeeder))
+ panicOnErr(conn.SetSeeder(testTorrent, testSeeder))
- panicOnErr(conn.RemoveSeeder(testTorrent, testSeeder))
- foundTorrent, _, err := conn.FindTorrent(testTorrent.Infohash)
- panicOnErr(err)
- if seeder, exists := foundTorrent.Seeders[storage.PeerMapKey(testSeeder)]; exists {
- t.Error("seeder not removed from cache", seeder)
- }
- if seeder, exists := testTorrent.Seeders[storage.PeerMapKey(testSeeder)]; exists {
- t.Error("seeder not removed from local", seeder)
- }
- // Cleanup
- panicOnErr(conn.RemoveTorrent(testTorrent))
+ panicOnErr(conn.RemoveSeeder(testTorrent, testSeeder))
+ foundTorrent, _, err := conn.FindTorrent(testTorrent.Infohash)
+ panicOnErr(err)
+ if seeder, exists := foundTorrent.Seeders[storage.PeerMapKey(testSeeder)]; exists {
+ t.Error("seeder not removed from cache", seeder)
+ }
+ if seeder, exists := testTorrent.Seeders[storage.PeerMapKey(testSeeder)]; exists {
+ t.Error("seeder not removed from local", seeder)
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveTorrent(testTorrent))
}
func TestParallelFindUser(t *testing.T) {
- t.Parallel()
- if testing.Short() {
- t.Skip()
- }
- conn := createTestConn()
- testUserSuccess := createTestUser()
- testUserFail := createTestUser()
- panicOnErr(conn.AddUser(testUserSuccess))
+ t.Parallel()
+ if testing.Short() {
+ t.Skip()
+ }
+ conn := createTestConn()
+ testUserSuccess := createTestUser()
+ testUserFail := createTestUser()
+ panicOnErr(conn.AddUser(testUserSuccess))
- for i := 0; i < 10; i++ {
- foundUser, found, err := conn.FindUser(testUserFail.Passkey)
- panicOnErr(err)
- if found {
- t.Error("user found", foundUser)
- }
- foundUser, found, err = conn.FindUser(testUserSuccess.Passkey)
- panicOnErr(err)
- if !found {
- t.Error("user not found", testUserSuccess)
- }
- if *foundUser != *testUserSuccess {
- t.Error("found user mismatch", *foundUser, testUserSuccess)
- }
- }
- // Cleanup
- panicOnErr(conn.RemoveUser(testUserSuccess))
+ for i := 0; i < 10; i++ {
+ foundUser, found, err := conn.FindUser(testUserFail.Passkey)
+ panicOnErr(err)
+ if found {
+ t.Error("user found", foundUser)
+ }
+ foundUser, found, err = conn.FindUser(testUserSuccess.Passkey)
+ panicOnErr(err)
+ if !found {
+ t.Error("user not found", testUserSuccess)
+ }
+ if *foundUser != *testUserSuccess {
+ t.Error("found user mismatch", *foundUser, testUserSuccess)
+ }
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveUser(testUserSuccess))
}
func TestParallelFindTorrent(t *testing.T) {
- t.Parallel()
- if testing.Short() {
- t.Skip()
- }
- conn := createTestConn()
- testTorrentSuccess := createTestTorrent()
- testTorrentFail := createTestTorrent()
- panicOnErr(conn.AddTorrent(testTorrentSuccess))
+ t.Parallel()
+ if testing.Short() {
+ t.Skip()
+ }
+ conn := createTestConn()
+ testTorrentSuccess := createTestTorrent()
+ testTorrentFail := createTestTorrent()
+ panicOnErr(conn.AddTorrent(testTorrentSuccess))
- for i := 0; i < 10; i++ {
- foundTorrent, found, err := conn.FindTorrent(testTorrentSuccess.Infohash)
- panicOnErr(err)
- if !found {
- t.Error("torrent not found", testTorrentSuccess)
- }
- if !reflect.DeepEqual(foundTorrent, testTorrentSuccess) {
- t.Error("found torrent mismatch", foundTorrent, testTorrentSuccess)
- }
- foundTorrent, found, err = conn.FindTorrent(testTorrentFail.Infohash)
- panicOnErr(err)
- if found {
- t.Error("torrent found", foundTorrent)
- }
- }
- // Cleanup
- panicOnErr(conn.RemoveTorrent(testTorrentSuccess))
+ for i := 0; i < 10; i++ {
+ foundTorrent, found, err := conn.FindTorrent(testTorrentSuccess.Infohash)
+ panicOnErr(err)
+ if !found {
+ t.Error("torrent not found", testTorrentSuccess)
+ }
+ if !reflect.DeepEqual(foundTorrent, testTorrentSuccess) {
+ t.Error("found torrent mismatch", foundTorrent, testTorrentSuccess)
+ }
+ foundTorrent, found, err = conn.FindTorrent(testTorrentFail.Infohash)
+ panicOnErr(err)
+ if found {
+ t.Error("torrent found", foundTorrent)
+ }
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveTorrent(testTorrentSuccess))
}
func TestParallelSetSeeder(t *testing.T) {
- t.Parallel()
- if testing.Short() {
- t.Skip()
- }
- conn := createTestConn()
- testTorrent := createTestTorrent()
- panicOnErr(conn.AddTorrent(testTorrent))
- testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
- panicOnErr(conn.AddSeeder(testTorrent, testSeeder))
- r := rand.New(rand.NewSource(time.Now().UnixNano()))
+ t.Parallel()
+ if testing.Short() {
+ t.Skip()
+ }
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ panicOnErr(conn.AddTorrent(testTorrent))
+ testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
+ panicOnErr(conn.AddSeeder(testTorrent, testSeeder))
+ r := rand.New(rand.NewSource(time.Now().UnixNano()))
- for i := 0; i < 10; i++ {
- testSeeder.Uploaded += uint64(r.Int63())
+ for i := 0; i < 10; i++ {
+ testSeeder.Uploaded += uint64(r.Int63())
- panicOnErr(conn.SetSeeder(testTorrent, testSeeder))
+ panicOnErr(conn.SetSeeder(testTorrent, testSeeder))
- foundTorrent, _, err := conn.FindTorrent(testTorrent.Infohash)
- panicOnErr(err)
- foundSeeder, _ := foundTorrent.Seeders[storage.PeerMapKey(testSeeder)]
- if foundSeeder != *testSeeder {
- t.Error("seeder not updated in cache", foundSeeder, *testSeeder)
- }
- foundSeeder, _ = testTorrent.Seeders[storage.PeerMapKey(testSeeder)]
- if foundSeeder != *testSeeder {
- t.Error("seeder not updated in local", foundSeeder, *testSeeder)
- }
- }
- // Cleanup
- panicOnErr(conn.RemoveTorrent(testTorrent))
+ foundTorrent, _, err := conn.FindTorrent(testTorrent.Infohash)
+ panicOnErr(err)
+ foundSeeder, _ := foundTorrent.Seeders[storage.PeerMapKey(testSeeder)]
+ if foundSeeder != *testSeeder {
+ t.Error("seeder not updated in cache", foundSeeder, *testSeeder)
+ }
+ foundSeeder, _ = testTorrent.Seeders[storage.PeerMapKey(testSeeder)]
+ if foundSeeder != *testSeeder {
+ t.Error("seeder not updated in local", foundSeeder, *testSeeder)
+ }
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveTorrent(testTorrent))
}
func TestParallelAddLeecher(t *testing.T) {
- t.Parallel()
- if testing.Short() {
- t.Skip()
- }
- conn := createTestConn()
- testTorrent := createTestTorrent()
- panicOnErr(conn.AddTorrent(testTorrent))
+ t.Parallel()
+ if testing.Short() {
+ t.Skip()
+ }
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ panicOnErr(conn.AddTorrent(testTorrent))
- for i := 0; i < 10; i++ {
- testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
+ for i := 0; i < 10; i++ {
+ testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
- panicOnErr(conn.AddLeecher(testTorrent, testLeecher))
+ panicOnErr(conn.AddLeecher(testTorrent, testLeecher))
- foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
- panicOnErr(err)
- foundLeecher, found := foundTorrent.Leechers[storage.PeerMapKey(testLeecher)]
- if found && foundLeecher != *testLeecher {
- t.Error("leecher not added to cache", testLeecher)
- }
- foundLeecher, found = testTorrent.Leechers[storage.PeerMapKey(testLeecher)]
- if found && foundLeecher != *testLeecher {
- t.Error("leecher not added to local", testLeecher)
- }
- }
- // Cleanup
- panicOnErr(conn.RemoveTorrent(testTorrent))
+ foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
+ panicOnErr(err)
+ foundLeecher, found := foundTorrent.Leechers[storage.PeerMapKey(testLeecher)]
+ if found && foundLeecher != *testLeecher {
+ t.Error("leecher not added to cache", testLeecher)
+ }
+ foundLeecher, found = testTorrent.Leechers[storage.PeerMapKey(testLeecher)]
+ if found && foundLeecher != *testLeecher {
+ t.Error("leecher not added to local", testLeecher)
+ }
+ }
+ // Cleanup
+ panicOnErr(conn.RemoveTorrent(testTorrent))
}
diff --git a/storage/tracker/redis/redis.go b/storage/tracker/redis/redis.go
index d96500f..a445247 100644
--- a/storage/tracker/redis/redis.go
+++ b/storage/tracker/redis/redis.go
@@ -24,92 +24,92 @@
package redis
import (
- "errors"
- "strconv"
- "time"
+ "errors"
+ "strconv"
+ "time"
- "github.com/garyburd/redigo/redis"
+ "github.com/garyburd/redigo/redis"
- "github.com/pushrax/chihaya/config"
- "github.com/pushrax/chihaya/storage"
- "github.com/pushrax/chihaya/storage/tracker"
+ "github.com/pushrax/chihaya/config"
+ "github.com/pushrax/chihaya/storage"
+ "github.com/pushrax/chihaya/storage/tracker"
)
var (
- ErrCreateUser = errors.New("redis: Incorrect reply length for user")
- ErrCreateTorrent = errors.New("redis: Incorrect reply length for torrent")
- ErrCreatePeer = errors.New("redis: Incorrect reply length for peer")
- ErrMarkActive = errors.New("redis: Torrent doesn't exist")
+ ErrCreateUser = errors.New("redis: Incorrect reply length for user")
+ ErrCreateTorrent = errors.New("redis: Incorrect reply length for torrent")
+ ErrCreatePeer = errors.New("redis: Incorrect reply length for peer")
+ ErrMarkActive = errors.New("redis: Torrent doesn't exist")
- SeedersPrefix = "seeders:"
- LeechersPrefix = "leechers:"
- TorrentPrefix = "torrent:"
- UserPrefix = "user:"
- PeerPrefix = "peer:"
+ SeedersPrefix = "seeders:"
+ LeechersPrefix = "leechers:"
+ TorrentPrefix = "torrent:"
+ UserPrefix = "user:"
+ PeerPrefix = "peer:"
)
type driver struct{}
// New creates and returns a tracker.Pool.
func (d *driver) New(conf *config.DataStore) tracker.Pool {
- return &Pool{
- conf: conf,
- pool: redis.Pool{
- MaxIdle: conf.MaxIdleConns,
- IdleTimeout: conf.IdleTimeout.Duration,
- Dial: makeDialFunc(conf),
- TestOnBorrow: testOnBorrow,
- },
- }
+ return &Pool{
+ conf: conf,
+ pool: redis.Pool{
+ MaxIdle: conf.MaxIdleConns,
+ IdleTimeout: conf.IdleTimeout.Duration,
+ Dial: makeDialFunc(conf),
+ TestOnBorrow: testOnBorrow,
+ },
+ }
}
// makeDialFunc configures and returns a new redis.Dial struct using the specified configuration.
func makeDialFunc(conf *config.DataStore) func() (redis.Conn, error) {
- return func() (conn redis.Conn, err error) {
- conn, err = redis.Dial(conf.Network, conf.Host+":"+conf.Port)
- if err != nil {
- return nil, err
- }
- return conn, nil
- }
+ return func() (conn redis.Conn, err error) {
+ conn, err = redis.Dial(conf.Network, conf.Host+":"+conf.Port)
+ if err != nil {
+ return nil, err
+ }
+ return conn, nil
+ }
}
// testOnBorrow pings the Redis instance
func testOnBorrow(c redis.Conn, t time.Time) error {
- _, err := c.Do("PING")
- return err
+ _, err := c.Do("PING")
+ return err
}
type Pool struct {
- conf *config.DataStore
- pool redis.Pool
+ conf *config.DataStore
+ pool redis.Pool
}
func (p *Pool) Close() error {
- return p.pool.Close()
+ return p.pool.Close()
}
func (p *Pool) Get() (tracker.Conn, error) {
- newConn := &Conn{
- conf: p.conf,
- done: false,
- Conn: p.pool.Get(),
- }
- return newConn, nil
+ newConn := &Conn{
+ conf: p.conf,
+ done: false,
+ Conn: p.pool.Get(),
+ }
+ return newConn, nil
}
type Conn struct {
- conf *config.DataStore
- done bool
- redis.Conn
+ conf *config.DataStore
+ done bool
+ redis.Conn
}
func (conn *Conn) close() {
- if conn.done {
- panic("redis: connection closed twice")
- }
- conn.done = true
- conn.Conn.Close()
+ if conn.done {
+ panic("redis: connection closed twice")
+ }
+ conn.done = true
+ conn.Conn.Close()
}
// createUser takes a string slice of length 14 and returns a pointer to a new
@@ -120,33 +120,33 @@ func (conn *Conn) close() {
// If the field value string cannot be converted to the correct type,
// createUser will return a nil user and the conversion error.
func createUser(userVals []string) (*storage.User, error) {
- if len(userVals) != 14 {
- return nil, ErrCreateUser
- }
- var user storage.User
- var err error
- for index, userString := range userVals {
- switch userString {
- case "id":
- user.ID, err = strconv.ParseUint(userVals[index+1], 10, 64)
- case "passkey":
- user.Passkey = userVals[index+1]
- case "up_multiplier":
- user.UpMultiplier, err = strconv.ParseFloat(userVals[index+1], 64)
- case "down_multiplier":
- user.DownMultiplier, err = strconv.ParseFloat(userVals[index+1], 64)
- case "slots":
- user.Slots, err = strconv.ParseInt(userVals[index+1], 10, 64)
- case "slots_used":
- user.SlotsUsed, err = strconv.ParseInt(userVals[index+1], 10, 64)
- case "snatches":
- user.Snatches, err = strconv.ParseUint(userVals[index+1], 10, 64)
- }
- if err != nil {
- return nil, err
- }
- }
- return &user, nil
+ if len(userVals) != 14 {
+ return nil, ErrCreateUser
+ }
+ var user storage.User
+ var err error
+ for index, userString := range userVals {
+ switch userString {
+ case "id":
+ user.ID, err = strconv.ParseUint(userVals[index+1], 10, 64)
+ case "passkey":
+ user.Passkey = userVals[index+1]
+ case "up_multiplier":
+ user.UpMultiplier, err = strconv.ParseFloat(userVals[index+1], 64)
+ case "down_multiplier":
+ user.DownMultiplier, err = strconv.ParseFloat(userVals[index+1], 64)
+ case "slots":
+ user.Slots, err = strconv.ParseInt(userVals[index+1], 10, 64)
+ case "slots_used":
+ user.SlotsUsed, err = strconv.ParseInt(userVals[index+1], 10, 64)
+ case "snatches":
+ user.Snatches, err = strconv.ParseUint(userVals[index+1], 10, 64)
+ }
+ if err != nil {
+ return nil, err
+ }
+ }
+ return &user, nil
}
// createTorrent takes a string slice of length 14 and returns a pointer to a new storage.Torrent
@@ -159,59 +159,59 @@ func createUser(userVals []string) (*storage.User, error) {
// createTorrent will return a nil user and the conversion error.
// After converting the torrent fields, the seeders and leechers are populated by redis.getPeers
func (conn *Conn) createTorrent(torrentVals []string) (*storage.Torrent, error) {
- if len(torrentVals) != 14 {
- return nil, ErrCreateTorrent
- }
- var torrent storage.Torrent
- var err error
- for index, torrentString := range torrentVals {
- switch torrentString {
- case "id":
- torrent.ID, err = strconv.ParseUint(torrentVals[index+1], 10, 64)
- case "infohash":
- torrent.Infohash = torrentVals[index+1]
- case "active":
- torrent.Active, err = strconv.ParseBool(torrentVals[index+1])
- case "snatches":
- torrent.Snatches, err = strconv.ParseUint(torrentVals[index+1], 10, 32)
- case "up_multiplier":
- torrent.UpMultiplier, err = strconv.ParseFloat(torrentVals[index+1], 64)
- case "down_multiplier":
- torrent.DownMultiplier, err = strconv.ParseFloat(torrentVals[index+1], 64)
- case "last_action":
- torrent.LastAction, err = strconv.ParseInt(torrentVals[index+1], 10, 64)
- }
- if err != nil {
- return nil, err
- }
- }
- torrent.Seeders, err = conn.getPeers(torrent.ID, SeedersPrefix)
- if err != nil {
- return nil, err
- }
- torrent.Leechers, err = conn.getPeers(torrent.ID, LeechersPrefix)
- if err != nil {
- return nil, err
- }
- return &torrent, nil
+ if len(torrentVals) != 14 {
+ return nil, ErrCreateTorrent
+ }
+ var torrent storage.Torrent
+ var err error
+ for index, torrentString := range torrentVals {
+ switch torrentString {
+ case "id":
+ torrent.ID, err = strconv.ParseUint(torrentVals[index+1], 10, 64)
+ case "infohash":
+ torrent.Infohash = torrentVals[index+1]
+ case "active":
+ torrent.Active, err = strconv.ParseBool(torrentVals[index+1])
+ case "snatches":
+ torrent.Snatches, err = strconv.ParseUint(torrentVals[index+1], 10, 32)
+ case "up_multiplier":
+ torrent.UpMultiplier, err = strconv.ParseFloat(torrentVals[index+1], 64)
+ case "down_multiplier":
+ torrent.DownMultiplier, err = strconv.ParseFloat(torrentVals[index+1], 64)
+ case "last_action":
+ torrent.LastAction, err = strconv.ParseInt(torrentVals[index+1], 10, 64)
+ }
+ if err != nil {
+ return nil, err
+ }
+ }
+ torrent.Seeders, err = conn.getPeers(torrent.ID, SeedersPrefix)
+ if err != nil {
+ return nil, err
+ }
+ torrent.Leechers, err = conn.getPeers(torrent.ID, LeechersPrefix)
+ if err != nil {
+ return nil, err
+ }
+ return &torrent, nil
}
// setPeer writes or overwrites peer information, stored as a Redis hash.
// The hash fields names are the same as the JSON tags on the storage.Peer struct.
func (conn *Conn) setPeer(peer *storage.Peer) error {
- hashKey := conn.conf.Prefix + getPeerHashKey(peer)
- _, err := conn.Do("HMSET", hashKey,
- "id", peer.ID,
- "user_id", peer.UserID,
- "torrent_id", peer.TorrentID,
- "ip", peer.IP,
- "port", peer.Port,
- "uploaded", peer.Uploaded,
- "downloaded", peer.Downloaded,
- "left", peer.Left,
- "last_announce", peer.LastAnnounce)
+ hashKey := conn.conf.Prefix + getPeerHashKey(peer)
+ _, err := conn.Do("HMSET", hashKey,
+ "id", peer.ID,
+ "user_id", peer.UserID,
+ "torrent_id", peer.TorrentID,
+ "ip", peer.IP,
+ "port", peer.Port,
+ "uploaded", peer.Uploaded,
+ "downloaded", peer.Downloaded,
+ "left", peer.Left,
+ "last_announce", peer.LastAnnounce)
- return err
+ return err
}
// removePeer removes the given peer from the specified peer set (seeder or leecher),
@@ -219,14 +219,14 @@ func (conn *Conn) setPeer(peer *storage.Peer) error {
// This function calls multiple redis commands, it's not internally atomic.
// This function will not return an error if the peer to remove doesn't exist.
func (conn *Conn) removePeer(peer *storage.Peer, peerTypePrefix string) error {
- setKey := conn.conf.Prefix + getPeerSetKey(peerTypePrefix, peer)
- _, err := conn.Do("SREM", setKey, getPeerHashKey(peer))
- if err != nil {
- return err
- }
- hashKey := conn.conf.Prefix + getPeerHashKey(peer)
- _, err = conn.Do("DEL", hashKey)
- return nil
+ setKey := conn.conf.Prefix + getPeerSetKey(peerTypePrefix, peer)
+ _, err := conn.Do("SREM", setKey, getPeerHashKey(peer))
+ if err != nil {
+ return err
+ }
+ hashKey := conn.conf.Prefix + getPeerHashKey(peer)
+ _, err = conn.Do("DEL", hashKey)
+ return nil
}
// removePeers removes all peers from specified peer set (seeders or leechers),
@@ -235,20 +235,20 @@ func (conn *Conn) removePeer(peer *storage.Peer, peerTypePrefix string) error {
// This function will only delete the peer set if all the individual peer deletions were successful
// This function calls multiple redis commands, it's not internally atomic.
func (conn *Conn) removePeers(torrentID uint64, peers map[string]storage.Peer, peerTypePrefix string) error {
- for _, peer := range peers {
- hashKey := conn.conf.Prefix + getPeerHashKey(&peer)
- _, err := conn.Do("DEL", hashKey)
- if err != nil {
- return err
- }
- delete(peers, storage.PeerMapKey(&peer))
- }
- setKey := conn.conf.Prefix + peerTypePrefix + strconv.FormatUint(torrentID, 36)
- _, err := conn.Do("DEL", setKey)
- if err != nil {
- return err
- }
- return nil
+ for _, peer := range peers {
+ hashKey := conn.conf.Prefix + getPeerHashKey(&peer)
+ _, err := conn.Do("DEL", hashKey)
+ if err != nil {
+ return err
+ }
+ delete(peers, storage.PeerMapKey(&peer))
+ }
+ setKey := conn.conf.Prefix + peerTypePrefix + strconv.FormatUint(torrentID, 36)
+ _, err := conn.Do("DEL", setKey)
+ if err != nil {
+ return err
+ }
+ return nil
}
// getPeerHashKey returns a string with the peer.ID, encoded peer.UserID, and encoded peer.TorrentID,
@@ -256,28 +256,28 @@ func (conn *Conn) removePeers(torrentID uint64, peers map[string]storage.Peer, p
// This key corresponds to a Redis hash type with fields containing a peer's data.
// The peer hashkey relies on the combination of peerID, userID, and torrentID being unique.
func getPeerHashKey(peer *storage.Peer) string {
- return peer.ID + ":" + strconv.FormatUint(peer.UserID, 36) + ":" + strconv.FormatUint(peer.TorrentID, 36)
+ return peer.ID + ":" + strconv.FormatUint(peer.UserID, 36) + ":" + strconv.FormatUint(peer.TorrentID, 36)
}
// getPeerSetKey returns a string that is the peer's encoded torrentID appended to the typePrefix
// This key corresponds to a torrent's pool of leechers or seeders
func getPeerSetKey(typePrefix string, peer *storage.Peer) string {
- return typePrefix + strconv.FormatUint(peer.TorrentID, 36)
+ return typePrefix + strconv.FormatUint(peer.TorrentID, 36)
}
// addPeers adds each peer's key to the specified peer set and saves the peer's information.
// This function will not return an error if the peer already exists in the set.
// This function calls multiple redis commands, it's not internally atomic.
func (conn *Conn) addPeers(peers map[string]storage.Peer, peerTypePrefix string) error {
- for _, peer := range peers {
- setKey := conn.conf.Prefix + getPeerSetKey(peerTypePrefix, &peer)
- _, err := conn.Do("SADD", setKey, getPeerHashKey(&peer))
- if err != nil {
- return err
- }
- conn.setPeer(&peer)
- }
- return nil
+ for _, peer := range peers {
+ setKey := conn.conf.Prefix + getPeerSetKey(peerTypePrefix, &peer)
+ _, err := conn.Do("SADD", setKey, getPeerHashKey(&peer))
+ if err != nil {
+ return err
+ }
+ conn.setPeer(&peer)
+ }
+ return nil
}
// createPeer takes a slice of length 9 and returns a pointer to a new storage.Peer or an error.
@@ -287,205 +287,205 @@ func (conn *Conn) addPeers(peers map[string]storage.Peer, peerTypePrefix string)
// If the field value string cannot be converted to the correct type,
// the function will return a nil peer and the conversion error.
func createPeer(peerVals []string) (*storage.Peer, error) {
- if len(peerVals) != 18 {
- return nil, ErrCreatePeer
- }
- var peer storage.Peer
- var err error
- for index, peerString := range peerVals {
- switch peerString {
- case "id":
- peer.ID = peerVals[index+1]
- case "user_id":
- peer.UserID, err = strconv.ParseUint(peerVals[index+1], 10, 64)
- case "torrent_id":
- peer.TorrentID, err = strconv.ParseUint(peerVals[index+1], 10, 64)
- case "ip":
- peer.IP = peerVals[index+1]
- case "port":
- peer.Port, err = strconv.ParseUint(peerVals[index+1], 10, 64)
- case "uploaded":
- peer.Uploaded, err = strconv.ParseUint(peerVals[index+1], 10, 64)
- case "downloaded":
- peer.Downloaded, err = strconv.ParseUint(peerVals[index+1], 10, 64)
- case "left":
- peer.Left, err = strconv.ParseUint(peerVals[index+1], 10, 64)
- case "last_announce":
- peer.LastAnnounce, err = strconv.ParseInt(peerVals[index+1], 10, 64)
- }
- if err != nil {
- return nil, err
- }
- }
- return &peer, nil
+ if len(peerVals) != 18 {
+ return nil, ErrCreatePeer
+ }
+ var peer storage.Peer
+ var err error
+ for index, peerString := range peerVals {
+ switch peerString {
+ case "id":
+ peer.ID = peerVals[index+1]
+ case "user_id":
+ peer.UserID, err = strconv.ParseUint(peerVals[index+1], 10, 64)
+ case "torrent_id":
+ peer.TorrentID, err = strconv.ParseUint(peerVals[index+1], 10, 64)
+ case "ip":
+ peer.IP = peerVals[index+1]
+ case "port":
+ peer.Port, err = strconv.ParseUint(peerVals[index+1], 10, 64)
+ case "uploaded":
+ peer.Uploaded, err = strconv.ParseUint(peerVals[index+1], 10, 64)
+ case "downloaded":
+ peer.Downloaded, err = strconv.ParseUint(peerVals[index+1], 10, 64)
+ case "left":
+ peer.Left, err = strconv.ParseUint(peerVals[index+1], 10, 64)
+ case "last_announce":
+ peer.LastAnnounce, err = strconv.ParseInt(peerVals[index+1], 10, 64)
+ }
+ if err != nil {
+ return nil, err
+ }
+ }
+ return &peer, nil
}
// getPeers returns a map of peers from a specified torrent's peer set(seeders or leechers).
// This is a multiple action command, it's not internally atomic.
func (conn *Conn) getPeers(torrentID uint64, peerTypePrefix string) (peers map[string]storage.Peer, err error) {
- peers = make(map[string]storage.Peer)
- setKey := conn.conf.Prefix + peerTypePrefix + strconv.FormatUint(torrentID, 36)
- peerStrings, err := redis.Strings(conn.Do("SMEMBERS", setKey))
- if err != nil {
- return nil, err
- }
- // Keys map to peer objects stored in hashes
- for _, peerHashKey := range peerStrings {
- hashKey := conn.conf.Prefix + peerHashKey
- peerVals, err := redis.Strings(conn.Do("HGETALL", hashKey))
- if err != nil {
- return nil, err
- }
- if len(peerVals) == 0 {
- continue
- }
- peer, err := createPeer(peerVals)
- if err != nil {
- return nil, err
- }
- peers[storage.PeerMapKey(peer)] = *peer
- }
- return
+ peers = make(map[string]storage.Peer)
+ setKey := conn.conf.Prefix + peerTypePrefix + strconv.FormatUint(torrentID, 36)
+ peerStrings, err := redis.Strings(conn.Do("SMEMBERS", setKey))
+ if err != nil {
+ return nil, err
+ }
+ // Keys map to peer objects stored in hashes
+ for _, peerHashKey := range peerStrings {
+ hashKey := conn.conf.Prefix + peerHashKey
+ peerVals, err := redis.Strings(conn.Do("HGETALL", hashKey))
+ if err != nil {
+ return nil, err
+ }
+ if len(peerVals) == 0 {
+ continue
+ }
+ peer, err := createPeer(peerVals)
+ if err != nil {
+ return nil, err
+ }
+ peers[storage.PeerMapKey(peer)] = *peer
+ }
+ return
}
// AddTorrent writes/overwrites torrent information and saves peers from both peer sets.
// The hash fields names are the same as the JSON tags on the storage.Torrent struct.
// This is a multiple action command, it's not internally atomic.
func (conn *Conn) AddTorrent(t *storage.Torrent) error {
- hashkey := conn.conf.Prefix + TorrentPrefix + t.Infohash
- _, err := conn.Do("HMSET", hashkey,
- "id", t.ID,
- "infohash", t.Infohash,
- "active", t.Active,
- "snatches", t.Snatches,
- "up_multiplier", t.UpMultiplier,
- "down_multiplier", t.DownMultiplier,
- "last_action", t.LastAction)
- if err != nil {
- return err
- }
+ hashkey := conn.conf.Prefix + TorrentPrefix + t.Infohash
+ _, err := conn.Do("HMSET", hashkey,
+ "id", t.ID,
+ "infohash", t.Infohash,
+ "active", t.Active,
+ "snatches", t.Snatches,
+ "up_multiplier", t.UpMultiplier,
+ "down_multiplier", t.DownMultiplier,
+ "last_action", t.LastAction)
+ if err != nil {
+ return err
+ }
- err = conn.addPeers(t.Seeders, SeedersPrefix)
- if err != nil {
- return err
- }
- err = conn.addPeers(t.Leechers, LeechersPrefix)
- if err != nil {
- return err
- }
- return nil
+ err = conn.addPeers(t.Seeders, SeedersPrefix)
+ if err != nil {
+ return err
+ }
+ err = conn.addPeers(t.Leechers, LeechersPrefix)
+ if err != nil {
+ return err
+ }
+ return nil
}
// RemoveTorrent deletes the torrent's Redis hash and then deletes all peers.
// This function will not return an error if the torrent has already been removed.
// This is a multiple action command, it's not internally atomic.
func (conn *Conn) RemoveTorrent(t *storage.Torrent) error {
- hashkey := conn.conf.Prefix + TorrentPrefix + t.Infohash
- _, err := conn.Do("DEL", hashkey)
- if err != nil {
- return err
- }
- // Remove seeders and leechers as well
- err = conn.removePeers(t.ID, t.Seeders, SeedersPrefix)
- if err != nil {
- return err
- }
- err = conn.removePeers(t.ID, t.Leechers, LeechersPrefix)
- if err != nil {
- return err
- }
- return nil
+ hashkey := conn.conf.Prefix + TorrentPrefix + t.Infohash
+ _, err := conn.Do("DEL", hashkey)
+ if err != nil {
+ return err
+ }
+ // Remove seeders and leechers as well
+ err = conn.removePeers(t.ID, t.Seeders, SeedersPrefix)
+ if err != nil {
+ return err
+ }
+ err = conn.removePeers(t.ID, t.Leechers, LeechersPrefix)
+ if err != nil {
+ return err
+ }
+ return nil
}
// AddUser writes/overwrites user information to a Redis hash.
// The hash fields names are the same as the JSON tags on the storage.user struct.
func (conn *Conn) AddUser(u *storage.User) error {
- hashkey := conn.conf.Prefix + UserPrefix + u.Passkey
- _, err := conn.Do("HMSET", hashkey,
- "id", u.ID,
- "passkey", u.Passkey,
- "up_multiplier", u.UpMultiplier,
- "down_multiplier", u.DownMultiplier,
- "slots", u.Slots,
- "slots_used", u.SlotsUsed,
- "snatches", u.Snatches)
- if err != nil {
- return err
- }
- return nil
+ hashkey := conn.conf.Prefix + UserPrefix + u.Passkey
+ _, err := conn.Do("HMSET", hashkey,
+ "id", u.ID,
+ "passkey", u.Passkey,
+ "up_multiplier", u.UpMultiplier,
+ "down_multiplier", u.DownMultiplier,
+ "slots", u.Slots,
+ "slots_used", u.SlotsUsed,
+ "snatches", u.Snatches)
+ if err != nil {
+ return err
+ }
+ return nil
}
// RemoveUser removes the user's hash from Redis.
// This function does not return an error if the user doesn't exist.
func (conn *Conn) RemoveUser(u *storage.User) error {
- hashkey := conn.conf.Prefix + UserPrefix + u.Passkey
- _, err := conn.Do("DEL", hashkey)
- if err != nil {
- return err
- }
- return nil
+ hashkey := conn.conf.Prefix + UserPrefix + u.Passkey
+ _, err := conn.Do("DEL", hashkey)
+ if err != nil {
+ return err
+ }
+ return nil
}
// FindUser returns a pointer to a new user struct and true if the user exists,
// or nil and false if the user doesn't exist.
// This function does not return an error if the torrent doesn't exist.
func (conn *Conn) FindUser(passkey string) (*storage.User, bool, error) {
- hashkey := conn.conf.Prefix + UserPrefix + passkey
- // Consider using HGETALL instead of HVALS here for robustness
- userStrings, err := redis.Strings(conn.Do("HGETALL", hashkey))
- if err != nil {
- return nil, false, err
- } else if len(userStrings) == 0 {
- return nil, false, nil
- }
- foundUser, err := createUser(userStrings)
- if err != nil {
- return nil, false, err
- }
- return foundUser, true, nil
+ hashkey := conn.conf.Prefix + UserPrefix + passkey
+ // Consider using HGETALL instead of HVALS here for robustness
+ userStrings, err := redis.Strings(conn.Do("HGETALL", hashkey))
+ if err != nil {
+ return nil, false, err
+ } else if len(userStrings) == 0 {
+ return nil, false, nil
+ }
+ foundUser, err := createUser(userStrings)
+ if err != nil {
+ return nil, false, err
+ }
+ return foundUser, true, nil
}
// FindTorrent returns a pointer to a new torrent struct and true if the torrent exists,
// or nil and false if the torrent doesn't exist.
// This is a multiple action command, it's not internally atomic.
func (conn *Conn) FindTorrent(infohash string) (*storage.Torrent, bool, error) {
- hashkey := conn.conf.Prefix + TorrentPrefix + infohash
- torrentStrings, err := redis.Strings(conn.Do("HGETALL", hashkey))
- if err != nil {
- return nil, false, err
- } else if len(torrentStrings) == 0 {
- return nil, false, nil
- }
+ hashkey := conn.conf.Prefix + TorrentPrefix + infohash
+ torrentStrings, err := redis.Strings(conn.Do("HGETALL", hashkey))
+ if err != nil {
+ return nil, false, err
+ } else if len(torrentStrings) == 0 {
+ return nil, false, nil
+ }
- foundTorrent, err := conn.createTorrent(torrentStrings)
- if err != nil {
- return nil, false, err
- }
- return foundTorrent, true, nil
+ foundTorrent, err := conn.createTorrent(torrentStrings)
+ if err != nil {
+ return nil, false, err
+ }
+ return foundTorrent, true, nil
}
// ClientWhitelisted returns true if the ClientID exists in the Client set.
// This function does not parse the client ID from the peer ID.
// The clientID must match exactly to a member of the set.
func (conn *Conn) ClientWhitelisted(peerID string) (exists bool, err error) {
- key := conn.conf.Prefix + "whitelist"
- return redis.Bool(conn.Do("SISMEMBER", key, peerID))
+ key := conn.conf.Prefix + "whitelist"
+ return redis.Bool(conn.Do("SISMEMBER", key, peerID))
}
// WhitelistClient adds a client ID to the client whitelist set.
// This function does not return an error if the client ID is already in the set.
func (conn *Conn) WhitelistClient(peerID string) error {
- key := conn.conf.Prefix + "whitelist"
- _, err := conn.Do("SADD", key, peerID)
- return err
+ key := conn.conf.Prefix + "whitelist"
+ _, err := conn.Do("SADD", key, peerID)
+ return err
}
// UnWhitelistClient removes a client ID from the client whitelist set
// This function does not return an error if the client ID is not in the set.
func (conn *Conn) UnWhitelistClient(peerID string) error {
- key := conn.conf.Prefix + "whitelist"
- _, err := conn.Do("SREM", key, peerID)
- return err
+ key := conn.conf.Prefix + "whitelist"
+ _, err := conn.Do("SREM", key, peerID)
+ return err
}
// RecordSnatch increments the snatch counter on the torrent and user by one.
@@ -493,59 +493,59 @@ func (conn *Conn) UnWhitelistClient(peerID string) error {
// This is a multiple action command, it's not internally atomic.
func (conn *Conn) RecordSnatch(user *storage.User, torrent *storage.Torrent) error {
- torrentKey := conn.conf.Prefix + TorrentPrefix + torrent.Infohash
- snatchCount, err := redis.Int(conn.Do("HINCRBY", torrentKey, "snatches", 1))
- if err != nil {
- return err
- }
- torrent.Snatches = uint64(snatchCount)
+ torrentKey := conn.conf.Prefix + TorrentPrefix + torrent.Infohash
+ snatchCount, err := redis.Int(conn.Do("HINCRBY", torrentKey, "snatches", 1))
+ if err != nil {
+ return err
+ }
+ torrent.Snatches = uint64(snatchCount)
- userKey := conn.conf.Prefix + UserPrefix + user.Passkey
- snatchCount, err = redis.Int(conn.Do("HINCRBY", userKey, "snatches", 1))
- if err != nil {
- return err
- }
- user.Snatches = uint64(snatchCount)
- return nil
+ userKey := conn.conf.Prefix + UserPrefix + user.Passkey
+ snatchCount, err = redis.Int(conn.Do("HINCRBY", userKey, "snatches", 1))
+ if err != nil {
+ return err
+ }
+ user.Snatches = uint64(snatchCount)
+ return nil
}
// MarkActive sets the active field of the torrent to true.
// This modifies the argument as well as the hash field in Redis.
// This function will return ErrMarkActive if the torrent does not exist.
func (conn *Conn) MarkActive(torrent *storage.Torrent) error {
- hashkey := conn.conf.Prefix + TorrentPrefix + torrent.Infohash
- activeExists, err := redis.Int(conn.Do("HSET", hashkey, "active", true))
- if err != nil {
- return err
- }
- torrent.Active = true
- // HSET returns 1 if hash didn't exist before
- if activeExists == 1 {
- return ErrMarkActive
- }
- return nil
+ hashkey := conn.conf.Prefix + TorrentPrefix + torrent.Infohash
+ activeExists, err := redis.Int(conn.Do("HSET", hashkey, "active", true))
+ if err != nil {
+ return err
+ }
+ torrent.Active = true
+ // HSET returns 1 if hash didn't exist before
+ if activeExists == 1 {
+ return ErrMarkActive
+ }
+ return nil
}
// MarkInactive sets the active field of the torrent to false.
// This modifies the argument as well as the hash field in Redis.
// This function will return ErrMarkActive if the torrent does not exist.
func (conn *Conn) MarkInactive(torrent *storage.Torrent) error {
- hashkey := conn.conf.Prefix + TorrentPrefix + torrent.Infohash
- activeExists, err := redis.Int(conn.Do("HSET", hashkey, "active", false))
- if err != nil {
- return err
- }
- torrent.Active = false
- // HSET returns 1 if hash didn't exist before
- if activeExists == 1 {
- // Clean-up incomplete torrent
- _, err = conn.Do("DEL", hashkey)
- if err != nil {
- return err
- }
- return ErrMarkActive
- }
- return nil
+ hashkey := conn.conf.Prefix + TorrentPrefix + torrent.Infohash
+ activeExists, err := redis.Int(conn.Do("HSET", hashkey, "active", false))
+ if err != nil {
+ return err
+ }
+ torrent.Active = false
+ // HSET returns 1 if hash didn't exist before
+ if activeExists == 1 {
+ // Clean-up incomplete torrent
+ _, err = conn.Do("DEL", hashkey)
+ if err != nil {
+ return err
+ }
+ return ErrMarkActive
+ }
+ return nil
}
// AddLeecher adds a new peer to a torrent's leecher set.
@@ -553,20 +553,20 @@ func (conn *Conn) MarkInactive(torrent *storage.Torrent) error {
// This function does not return an error if the leecher already exists.
// This is a multiple action command, it's not internally atomic.
func (conn *Conn) AddLeecher(torrent *storage.Torrent, peer *storage.Peer) error {
- setKey := conn.conf.Prefix + LeechersPrefix + strconv.FormatUint(torrent.ID, 36)
- _, err := conn.Do("SADD", setKey, getPeerHashKey(peer))
- if err != nil {
- return err
- }
- err = conn.setPeer(peer)
- if err != nil {
- return err
- }
- if torrent.Leechers == nil {
- torrent.Leechers = make(map[string]storage.Peer)
- }
- torrent.Leechers[storage.PeerMapKey(peer)] = *peer
- return nil
+ setKey := conn.conf.Prefix + LeechersPrefix + strconv.FormatUint(torrent.ID, 36)
+ _, err := conn.Do("SADD", setKey, getPeerHashKey(peer))
+ if err != nil {
+ return err
+ }
+ err = conn.setPeer(peer)
+ if err != nil {
+ return err
+ }
+ if torrent.Leechers == nil {
+ torrent.Leechers = make(map[string]storage.Peer)
+ }
+ torrent.Leechers[storage.PeerMapKey(peer)] = *peer
+ return nil
}
// SetLeecher updates a torrent's leecher.
@@ -574,43 +574,43 @@ func (conn *Conn) AddLeecher(torrent *storage.Torrent, peer *storage.Peer) error
// Setting assumes that the peer is already a leecher, and only needs to be updated.
// This function does not return an error if the leecher does not exist or is not in the torrent's leecher set.
func (conn *Conn) SetLeecher(t *storage.Torrent, p *storage.Peer) error {
- err := conn.setPeer(p)
- if err != nil {
- return err
- }
- t.Leechers[storage.PeerMapKey(p)] = *p
- return nil
+ err := conn.setPeer(p)
+ if err != nil {
+ return err
+ }
+ t.Leechers[storage.PeerMapKey(p)] = *p
+ return nil
}
// RemoveLeecher removes the given peer from a torrent's leecher set.
// This modifies the torrent argument, as well as the torrent's set and peer's hash in Redis.
// This function does not return an error if the peer doesn't exist, or is not in the set.
func (conn *Conn) RemoveLeecher(t *storage.Torrent, p *storage.Peer) error {
- err := conn.removePeer(p, LeechersPrefix)
- if err != nil {
- return err
- }
- delete(t.Leechers, storage.PeerMapKey(p))
- return nil
+ err := conn.removePeer(p, LeechersPrefix)
+ if err != nil {
+ return err
+ }
+ delete(t.Leechers, storage.PeerMapKey(p))
+ return nil
}
// LeecherFinished moves a peer's hashkey from a torrent's leecher set to the seeder set and updates the peer.
// This modifies the torrent argument, as well as the torrent's set and peer's hash in Redis.
// This function does not return an error if the peer doesn't exist or is not in the torrent's leecher set.
func (conn *Conn) LeecherFinished(torrent *storage.Torrent, peer *storage.Peer) error {
- torrentIdKey := strconv.FormatUint(torrent.ID, 36)
- seederSetKey := conn.conf.Prefix + SeedersPrefix + torrentIdKey
- leecherSetKey := conn.conf.Prefix + LeechersPrefix + torrentIdKey
+ torrentIdKey := strconv.FormatUint(torrent.ID, 36)
+ seederSetKey := conn.conf.Prefix + SeedersPrefix + torrentIdKey
+ leecherSetKey := conn.conf.Prefix + LeechersPrefix + torrentIdKey
- _, err := conn.Do("SMOVE", leecherSetKey, seederSetKey, getPeerHashKey(peer))
- if err != nil {
- return err
- }
- torrent.Seeders[storage.PeerMapKey(peer)] = *peer
- delete(torrent.Leechers, storage.PeerMapKey(peer))
+ _, err := conn.Do("SMOVE", leecherSetKey, seederSetKey, getPeerHashKey(peer))
+ if err != nil {
+ return err
+ }
+ torrent.Seeders[storage.PeerMapKey(peer)] = *peer
+ delete(torrent.Leechers, storage.PeerMapKey(peer))
- err = conn.setPeer(peer)
- return err
+ err = conn.setPeer(peer)
+ return err
}
// AddSeeder adds a new peer to a torrent's seeder set.
@@ -618,20 +618,20 @@ func (conn *Conn) LeecherFinished(torrent *storage.Torrent, peer *storage.Peer)
// This function does not return an error if the seeder already exists.
// This is a multiple action command, it's not internally atomic.
func (conn *Conn) AddSeeder(torrent *storage.Torrent, peer *storage.Peer) error {
- setKey := conn.conf.Prefix + SeedersPrefix + strconv.FormatUint(torrent.ID, 36)
- _, err := conn.Do("SADD", setKey, getPeerHashKey(peer))
- if err != nil {
- return err
- }
- err = conn.setPeer(peer)
- if err != nil {
- return err
- }
- if torrent.Seeders == nil {
- torrent.Seeders = make(map[string]storage.Peer)
- }
- torrent.Seeders[storage.PeerMapKey(peer)] = *peer
- return nil
+ setKey := conn.conf.Prefix + SeedersPrefix + strconv.FormatUint(torrent.ID, 36)
+ _, err := conn.Do("SADD", setKey, getPeerHashKey(peer))
+ if err != nil {
+ return err
+ }
+ err = conn.setPeer(peer)
+ if err != nil {
+ return err
+ }
+ if torrent.Seeders == nil {
+ torrent.Seeders = make(map[string]storage.Peer)
+ }
+ torrent.Seeders[storage.PeerMapKey(peer)] = *peer
+ return nil
}
// SetSeeder updates a torrent's seeder.
@@ -639,51 +639,51 @@ func (conn *Conn) AddSeeder(torrent *storage.Torrent, peer *storage.Peer) error
// Setting assumes that the peer is already a seeder, and only needs to be updated.
// This function does not return an error if the seeder does not exist or is not in the torrent's seeder set.
func (conn *Conn) SetSeeder(t *storage.Torrent, p *storage.Peer) error {
- err := conn.setPeer(p)
- if err != nil {
- return err
- }
- t.Seeders[storage.PeerMapKey(p)] = *p
- return nil
+ err := conn.setPeer(p)
+ if err != nil {
+ return err
+ }
+ t.Seeders[storage.PeerMapKey(p)] = *p
+ return nil
}
// RemoveSeeder removes the given peer from a torrent's seeder set.
// This modifies the torrent argument, as well as the torrent's set and peer's hash in Redis.
// This function does not return an error if the peer doesn't exist, or is not in the set.
func (conn *Conn) RemoveSeeder(t *storage.Torrent, p *storage.Peer) error {
- err := conn.removePeer(p, SeedersPrefix)
- if err != nil {
- return err
- }
- delete(t.Seeders, storage.PeerMapKey(p))
- return nil
+ err := conn.removePeer(p, SeedersPrefix)
+ if err != nil {
+ return err
+ }
+ delete(t.Seeders, storage.PeerMapKey(p))
+ return nil
}
// IncrementSlots increment a user's Slots by one.
// This function modifies the argument as well as the hash field in Redis.
func (conn *Conn) IncrementSlots(u *storage.User) error {
- hashkey := conn.conf.Prefix + UserPrefix + u.Passkey
- slotCount, err := redis.Int(conn.Do("HINCRBY", hashkey, "slots", 1))
- if err != nil {
- return err
- }
- u.Slots = int64(slotCount)
- return nil
+ hashkey := conn.conf.Prefix + UserPrefix + u.Passkey
+ slotCount, err := redis.Int(conn.Do("HINCRBY", hashkey, "slots", 1))
+ if err != nil {
+ return err
+ }
+ u.Slots = int64(slotCount)
+ return nil
}
// IncrementSlots increment a user's Slots by one.
// This function modifies the argument as well as the hash field in Redis.
func (conn *Conn) DecrementSlots(u *storage.User) error {
- hashkey := conn.conf.Prefix + UserPrefix + u.Passkey
- slotCount, err := redis.Int(conn.Do("HINCRBY", hashkey, "slots", -1))
- if err != nil {
- return err
- }
- u.Slots = int64(slotCount)
- return nil
+ hashkey := conn.conf.Prefix + UserPrefix + u.Passkey
+ slotCount, err := redis.Int(conn.Do("HINCRBY", hashkey, "slots", -1))
+ if err != nil {
+ return err
+ }
+ u.Slots = int64(slotCount)
+ return nil
}
// init registers the redis driver
func init() {
- tracker.Register("redis", &driver{})
+ tracker.Register("redis", &driver{})
}
diff --git a/storage/tracker/redis/redis_bench_test.go b/storage/tracker/redis/redis_bench_test.go
index 530b466..e8634c6 100644
--- a/storage/tracker/redis/redis_bench_test.go
+++ b/storage/tracker/redis/redis_bench_test.go
@@ -5,284 +5,284 @@
package redis
import (
- "math/rand"
- "testing"
- "time"
+ "math/rand"
+ "testing"
+ "time"
)
func BenchmarkSuccessfulFindUser(b *testing.B) {
- b.StopTimer()
- conn := createTestConn()
- testUser := createTestUser()
- panicOnErr(conn.AddUser(testUser))
- b.StartTimer()
+ b.StopTimer()
+ conn := createTestConn()
+ testUser := createTestUser()
+ panicOnErr(conn.AddUser(testUser))
+ b.StartTimer()
- for bCount := 0; bCount < b.N; bCount++ {
+ for bCount := 0; bCount < b.N; bCount++ {
- foundUser, found, err := conn.FindUser(testUser.Passkey)
- panicOnErr(err)
- if !found {
- b.Error("user not found", testUser)
- }
- if *foundUser != *testUser {
- b.Error("found user mismatch", *foundUser, testUser)
- }
- }
- // Cleanup
- b.StopTimer()
- panicOnErr(conn.RemoveUser(testUser))
- b.StartTimer()
+ foundUser, found, err := conn.FindUser(testUser.Passkey)
+ panicOnErr(err)
+ if !found {
+ b.Error("user not found", testUser)
+ }
+ if *foundUser != *testUser {
+ b.Error("found user mismatch", *foundUser, testUser)
+ }
+ }
+ // Cleanup
+ b.StopTimer()
+ panicOnErr(conn.RemoveUser(testUser))
+ b.StartTimer()
}
func BenchmarkFailedFindUser(b *testing.B) {
- b.StopTimer()
- conn := createTestConn()
- testUser := createTestUser()
- b.StartTimer()
+ b.StopTimer()
+ conn := createTestConn()
+ testUser := createTestUser()
+ b.StartTimer()
- for bCount := 0; bCount < b.N; bCount++ {
+ for bCount := 0; bCount < b.N; bCount++ {
- _, found, err := conn.FindUser(testUser.Passkey)
- panicOnErr(err)
- if found {
- b.Error("user not found", testUser)
- }
- }
+ _, found, err := conn.FindUser(testUser.Passkey)
+ panicOnErr(err)
+ if found {
+ b.Error("user not found", testUser)
+ }
+ }
}
func BenchmarkSuccessfulFindTorrent(b *testing.B) {
- b.StopTimer()
- conn := createTestConn()
- testTorrent := createTestTorrent()
+ b.StopTimer()
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
- panicOnErr(conn.AddTorrent(testTorrent))
- b.StartTimer()
+ panicOnErr(conn.AddTorrent(testTorrent))
+ b.StartTimer()
- for bCount := 0; bCount < b.N; bCount++ {
- foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
- panicOnErr(err)
- if !found {
- b.Error("torrent not found", testTorrent)
- }
- // Incomplete comparison as maps make struct not nativly comparable
- if foundTorrent.Infohash != testTorrent.Infohash {
- b.Error("found torrent mismatch", foundTorrent, testTorrent)
- }
- }
- // Cleanup
- b.StopTimer()
- panicOnErr(conn.RemoveTorrent(testTorrent))
- b.StartTimer()
+ for bCount := 0; bCount < b.N; bCount++ {
+ foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
+ panicOnErr(err)
+ if !found {
+ b.Error("torrent not found", testTorrent)
+ }
+ // Incomplete comparison as maps make struct not nativly comparable
+ if foundTorrent.Infohash != testTorrent.Infohash {
+ b.Error("found torrent mismatch", foundTorrent, testTorrent)
+ }
+ }
+ // Cleanup
+ b.StopTimer()
+ panicOnErr(conn.RemoveTorrent(testTorrent))
+ b.StartTimer()
}
func BenchmarkFailFindTorrent(b *testing.B) {
- b.StopTimer()
- conn := createTestConn()
- testTorrent := createTestTorrent()
- b.StartTimer()
+ b.StopTimer()
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ b.StartTimer()
- for bCount := 0; bCount < b.N; bCount++ {
- foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
- panicOnErr(err)
- if found {
- b.Error("torrent found", foundTorrent)
- }
- }
+ for bCount := 0; bCount < b.N; bCount++ {
+ foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
+ panicOnErr(err)
+ if found {
+ b.Error("torrent found", foundTorrent)
+ }
+ }
}
func BenchmarkSuccessfulClientWhitelisted(b *testing.B) {
- b.StopTimer()
- conn := createTestConn()
- testPeerID := "-lt0D30-"
- panicOnErr(conn.WhitelistClient(testPeerID))
- b.StartTimer()
+ b.StopTimer()
+ conn := createTestConn()
+ testPeerID := "-lt0D30-"
+ panicOnErr(conn.WhitelistClient(testPeerID))
+ b.StartTimer()
- for bCount := 0; bCount < b.N; bCount++ {
- found, err := conn.ClientWhitelisted(testPeerID)
- panicOnErr(err)
- if !found {
- b.Error("peerID not found", testPeerID)
- }
- }
- // Cleanup
- b.StopTimer()
- panicOnErr(conn.UnWhitelistClient(testPeerID))
- b.StartTimer()
+ for bCount := 0; bCount < b.N; bCount++ {
+ found, err := conn.ClientWhitelisted(testPeerID)
+ panicOnErr(err)
+ if !found {
+ b.Error("peerID not found", testPeerID)
+ }
+ }
+ // Cleanup
+ b.StopTimer()
+ panicOnErr(conn.UnWhitelistClient(testPeerID))
+ b.StartTimer()
}
func BenchmarkFailClientWhitelisted(b *testing.B) {
- b.StopTimer()
- conn := createTestConn()
- testPeerID2 := "TIX0192"
- b.StartTimer()
+ b.StopTimer()
+ conn := createTestConn()
+ testPeerID2 := "TIX0192"
+ b.StartTimer()
- for bCount := 0; bCount < b.N; bCount++ {
- found, err := conn.ClientWhitelisted(testPeerID2)
- panicOnErr(err)
- if found {
- b.Error("peerID found", testPeerID2)
- }
- }
+ for bCount := 0; bCount < b.N; bCount++ {
+ found, err := conn.ClientWhitelisted(testPeerID2)
+ panicOnErr(err)
+ if found {
+ b.Error("peerID found", testPeerID2)
+ }
+ }
}
func BenchmarkRecordSnatch(b *testing.B) {
- b.StopTimer()
- conn := createTestConn()
- testTorrent := createTestTorrent()
- testUser := createTestUser()
- panicOnErr(conn.AddTorrent(testTorrent))
- panicOnErr(conn.AddUser(testUser))
- b.StartTimer()
+ b.StopTimer()
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ testUser := createTestUser()
+ panicOnErr(conn.AddTorrent(testTorrent))
+ panicOnErr(conn.AddUser(testUser))
+ b.StartTimer()
- for bCount := 0; bCount < b.N; bCount++ {
- panicOnErr(conn.RecordSnatch(testUser, testTorrent))
- }
- // Cleanup
- b.StopTimer()
- panicOnErr(conn.RemoveTorrent(testTorrent))
- panicOnErr(conn.RemoveUser(testUser))
- b.StartTimer()
+ for bCount := 0; bCount < b.N; bCount++ {
+ panicOnErr(conn.RecordSnatch(testUser, testTorrent))
+ }
+ // Cleanup
+ b.StopTimer()
+ panicOnErr(conn.RemoveTorrent(testTorrent))
+ panicOnErr(conn.RemoveUser(testUser))
+ b.StartTimer()
}
func BenchmarkMarkActive(b *testing.B) {
- b.StopTimer()
- conn := createTestConn()
- testTorrent := createTestTorrent()
- testTorrent.Active = false
- panicOnErr(conn.AddTorrent(testTorrent))
- b.StartTimer()
+ b.StopTimer()
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ testTorrent.Active = false
+ panicOnErr(conn.AddTorrent(testTorrent))
+ b.StartTimer()
- for bCount := 0; bCount < b.N; bCount++ {
- panicOnErr(conn.MarkActive(testTorrent))
- }
- // Cleanup
- b.StopTimer()
- panicOnErr(conn.RemoveTorrent(testTorrent))
- b.StartTimer()
+ for bCount := 0; bCount < b.N; bCount++ {
+ panicOnErr(conn.MarkActive(testTorrent))
+ }
+ // Cleanup
+ b.StopTimer()
+ panicOnErr(conn.RemoveTorrent(testTorrent))
+ b.StartTimer()
}
func BenchmarkAddSeeder(b *testing.B) {
- b.StopTimer()
- conn := createTestConn()
- testTorrent := createTestTorrent()
- panicOnErr(conn.AddTorrent(testTorrent))
- b.StartTimer()
+ b.StopTimer()
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ panicOnErr(conn.AddTorrent(testTorrent))
+ b.StartTimer()
- for bCount := 0; bCount < b.N; bCount++ {
- b.StopTimer()
- testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
- b.StartTimer()
+ for bCount := 0; bCount < b.N; bCount++ {
+ b.StopTimer()
+ testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
+ b.StartTimer()
- panicOnErr(conn.AddSeeder(testTorrent, testSeeder))
- }
- // Cleanup
- b.StopTimer()
- panicOnErr(conn.RemoveTorrent(testTorrent))
- b.StartTimer()
+ panicOnErr(conn.AddSeeder(testTorrent, testSeeder))
+ }
+ // Cleanup
+ b.StopTimer()
+ panicOnErr(conn.RemoveTorrent(testTorrent))
+ b.StartTimer()
}
func BenchmarkRemoveSeeder(b *testing.B) {
- b.StopTimer()
- conn := createTestConn()
- testTorrent := createTestTorrent()
- panicOnErr(conn.AddTorrent(testTorrent))
- testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
- b.StartTimer()
+ b.StopTimer()
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ panicOnErr(conn.AddTorrent(testTorrent))
+ testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
+ b.StartTimer()
- for bCount := 0; bCount < b.N; bCount++ {
- b.StopTimer()
- conn.AddSeeder(testTorrent, testSeeder)
- b.StartTimer()
+ for bCount := 0; bCount < b.N; bCount++ {
+ b.StopTimer()
+ conn.AddSeeder(testTorrent, testSeeder)
+ b.StartTimer()
- panicOnErr(conn.RemoveSeeder(testTorrent, testSeeder))
- }
- // Cleanup
- b.StopTimer()
- panicOnErr(conn.RemoveTorrent(testTorrent))
- b.StartTimer()
+ panicOnErr(conn.RemoveSeeder(testTorrent, testSeeder))
+ }
+ // Cleanup
+ b.StopTimer()
+ panicOnErr(conn.RemoveTorrent(testTorrent))
+ b.StartTimer()
}
func BenchmarkSetSeeder(b *testing.B) {
- b.StopTimer()
- conn := createTestConn()
- testTorrent := createTestTorrent()
- panicOnErr(conn.AddTorrent(testTorrent))
- testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
- panicOnErr(conn.AddSeeder(testTorrent, testSeeder))
- r := rand.New(rand.NewSource(time.Now().UnixNano()))
- b.StartTimer()
+ b.StopTimer()
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ panicOnErr(conn.AddTorrent(testTorrent))
+ testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
+ panicOnErr(conn.AddSeeder(testTorrent, testSeeder))
+ r := rand.New(rand.NewSource(time.Now().UnixNano()))
+ b.StartTimer()
- for bCount := 0; bCount < b.N; bCount++ {
- b.StopTimer()
- testSeeder.Uploaded += uint64(r.Int63())
- b.StartTimer()
+ for bCount := 0; bCount < b.N; bCount++ {
+ b.StopTimer()
+ testSeeder.Uploaded += uint64(r.Int63())
+ b.StartTimer()
- conn.SetSeeder(testTorrent, testSeeder)
- }
- // Cleanup
- b.StopTimer()
- panicOnErr(conn.RemoveTorrent(testTorrent))
- b.StartTimer()
+ conn.SetSeeder(testTorrent, testSeeder)
+ }
+ // Cleanup
+ b.StopTimer()
+ panicOnErr(conn.RemoveTorrent(testTorrent))
+ b.StartTimer()
}
func BenchmarkIncrementSlots(b *testing.B) {
- b.StopTimer()
- conn := createTestConn()
- testUser := createTestUser()
- panicOnErr(conn.AddUser(testUser))
- b.StartTimer()
+ b.StopTimer()
+ conn := createTestConn()
+ testUser := createTestUser()
+ panicOnErr(conn.AddUser(testUser))
+ b.StartTimer()
- for bCount := 0; bCount < b.N; bCount++ {
- panicOnErr(conn.IncrementSlots(testUser))
- }
- // Cleanup
- b.StopTimer()
- panicOnErr(conn.RemoveUser(testUser))
- b.StartTimer()
+ for bCount := 0; bCount < b.N; bCount++ {
+ panicOnErr(conn.IncrementSlots(testUser))
+ }
+ // Cleanup
+ b.StopTimer()
+ panicOnErr(conn.RemoveUser(testUser))
+ b.StartTimer()
}
func BenchmarkLeecherFinished(b *testing.B) {
- b.StopTimer()
- conn := createTestConn()
- testTorrent := createTestTorrent()
- panicOnErr(conn.AddTorrent(testTorrent))
- b.StartTimer()
+ b.StopTimer()
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ panicOnErr(conn.AddTorrent(testTorrent))
+ b.StartTimer()
- for bCount := 0; bCount < b.N; bCount++ {
- b.StopTimer()
- testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
- panicOnErr(conn.AddLeecher(testTorrent, testLeecher))
- testLeecher.Left = 0
- b.StartTimer()
+ for bCount := 0; bCount < b.N; bCount++ {
+ b.StopTimer()
+ testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
+ panicOnErr(conn.AddLeecher(testTorrent, testLeecher))
+ testLeecher.Left = 0
+ b.StartTimer()
- panicOnErr(conn.LeecherFinished(testTorrent, testLeecher))
- }
- // Cleanup
- b.StopTimer()
- panicOnErr(conn.RemoveTorrent(testTorrent))
- b.StartTimer()
+ panicOnErr(conn.LeecherFinished(testTorrent, testLeecher))
+ }
+ // Cleanup
+ b.StopTimer()
+ panicOnErr(conn.RemoveTorrent(testTorrent))
+ b.StartTimer()
}
// This is a comparision to the Leecher finished function
func BenchmarkRemoveLeecherAddSeeder(b *testing.B) {
- b.StopTimer()
- conn := createTestConn()
- testTorrent := createTestTorrent()
- panicOnErr(conn.AddTorrent(testTorrent))
- b.StartTimer()
+ b.StopTimer()
+ conn := createTestConn()
+ testTorrent := createTestTorrent()
+ panicOnErr(conn.AddTorrent(testTorrent))
+ b.StartTimer()
- for bCount := 0; bCount < b.N; bCount++ {
- b.StopTimer()
- testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
- panicOnErr(conn.AddLeecher(testTorrent, testLeecher))
- testLeecher.Left = 0
- b.StartTimer()
+ for bCount := 0; bCount < b.N; bCount++ {
+ b.StopTimer()
+ testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
+ panicOnErr(conn.AddLeecher(testTorrent, testLeecher))
+ testLeecher.Left = 0
+ b.StartTimer()
- panicOnErr(conn.RemoveLeecher(testTorrent, testLeecher))
- panicOnErr(conn.AddSeeder(testTorrent, testLeecher))
- }
- // Cleanup
- b.StopTimer()
- conn.RemoveTorrent(testTorrent)
- b.StartTimer()
+ panicOnErr(conn.RemoveLeecher(testTorrent, testLeecher))
+ panicOnErr(conn.AddSeeder(testTorrent, testLeecher))
+ }
+ // Cleanup
+ b.StopTimer()
+ conn.RemoveTorrent(testTorrent)
+ b.StartTimer()
}
diff --git a/storage/tracker/redis/redis_test.go b/storage/tracker/redis/redis_test.go
index 9ae7d2b..828f86a 100644
--- a/storage/tracker/redis/redis_test.go
+++ b/storage/tracker/redis/redis_test.go
@@ -5,180 +5,180 @@
package redis
import (
- "crypto/rand"
- "fmt"
- "io"
- "os"
- "strconv"
- "testing"
+ "crypto/rand"
+ "fmt"
+ "io"
+ "os"
+ "strconv"
+ "testing"
- "github.com/garyburd/redigo/redis"
+ "github.com/garyburd/redigo/redis"
- "github.com/pushrax/chihaya/config"
- "github.com/pushrax/chihaya/storage"
+ "github.com/pushrax/chihaya/config"
+ "github.com/pushrax/chihaya/storage"
)
var (
- testTorrentIDChannel chan uint64
- testUserIDChannel chan uint64
- testPeerIDChannel chan int
+ testTorrentIDChannel chan uint64
+ testUserIDChannel chan uint64
+ testPeerIDChannel chan int
)
func init() {
- testTorrentIDChannel = make(chan uint64, 100)
- testUserIDChannel = make(chan uint64, 100)
- testPeerIDChannel = make(chan int, 100)
- // Sync access to ID counter with buffered global channels
- go func() {
- for i := 0; ; i++ {
- testTorrentIDChannel <- uint64(i)
- }
- }()
- go func() {
- for i := 0; ; i++ {
- testUserIDChannel <- uint64(i)
- }
- }()
- go func() {
- for i := 0; ; i++ {
- testPeerIDChannel <- i
- }
- }()
+ testTorrentIDChannel = make(chan uint64, 100)
+ testUserIDChannel = make(chan uint64, 100)
+ testPeerIDChannel = make(chan int, 100)
+ // Sync access to ID counter with buffered global channels
+ go func() {
+ for i := 0; ; i++ {
+ testTorrentIDChannel <- uint64(i)
+ }
+ }()
+ go func() {
+ for i := 0; ; i++ {
+ testUserIDChannel <- uint64(i)
+ }
+ }()
+ go func() {
+ for i := 0; ; i++ {
+ testPeerIDChannel <- i
+ }
+ }()
}
func createTestTorrentID() uint64 {
- return <-testTorrentIDChannel
+ return <-testTorrentIDChannel
}
func createTestUserID() uint64 {
- return <-testUserIDChannel
+ return <-testUserIDChannel
}
func createTestPeerID() string {
- return "-testPeerID-" + strconv.Itoa(<-testPeerIDChannel)
+ return "-testPeerID-" + strconv.Itoa(<-testPeerIDChannel)
}
func createTestInfohash() string {
- uuid := make([]byte, 40)
- n, err := io.ReadFull(rand.Reader, uuid)
- if n != len(uuid) || err != nil {
- panic(err)
- }
- return string(uuid)
+ uuid := make([]byte, 40)
+ n, err := io.ReadFull(rand.Reader, uuid)
+ if n != len(uuid) || err != nil {
+ panic(err)
+ }
+ return string(uuid)
}
func createTestPasskey() string {
- uuid := make([]byte, 40)
- n, err := io.ReadFull(rand.Reader, uuid)
- if n != len(uuid) || err != nil {
- panic(err)
- }
- return string(uuid)
+ uuid := make([]byte, 40)
+ n, err := io.ReadFull(rand.Reader, uuid)
+ if n != len(uuid) || err != nil {
+ panic(err)
+ }
+ return string(uuid)
}
func panicOnErr(err error) {
- if err != nil {
- fmt.Println(err)
- panic(err)
- }
+ if err != nil {
+ fmt.Println(err)
+ panic(err)
+ }
}
func createTestRedisConn() *Conn {
- testConfig, err := config.Open(os.Getenv("TESTCONFIGPATH"))
- conf := &testConfig.Cache
- panicOnErr(err)
+ testConfig, err := config.Open(os.Getenv("TESTCONFIGPATH"))
+ conf := &testConfig.Cache
+ panicOnErr(err)
- testPool := &Pool{
- conf: conf,
- pool: redis.Pool{
- MaxIdle: conf.MaxIdleConns,
- IdleTimeout: conf.IdleTimeout.Duration,
- Dial: makeDialFunc(conf),
- TestOnBorrow: testOnBorrow,
- },
- }
+ testPool := &Pool{
+ conf: conf,
+ pool: redis.Pool{
+ MaxIdle: conf.MaxIdleConns,
+ IdleTimeout: conf.IdleTimeout.Duration,
+ Dial: makeDialFunc(conf),
+ TestOnBorrow: testOnBorrow,
+ },
+ }
- newConn := &Conn{
- conf: testPool.conf,
- done: false,
- Conn: testPool.pool.Get(),
- }
- panicOnErr(err)
+ newConn := &Conn{
+ conf: testPool.conf,
+ done: false,
+ Conn: testPool.pool.Get(),
+ }
+ panicOnErr(err)
- // Test connection before returning
- _, err = newConn.Do("PING")
- panicOnErr(err)
- return newConn
+ // Test connection before returning
+ _, err = newConn.Do("PING")
+ panicOnErr(err)
+ return newConn
}
func createTestUser() *storage.User {
- return &storage.User{ID: createTestUserID(), Passkey: createTestPasskey(),
- UpMultiplier: 1.01, DownMultiplier: 1.0, Slots: 4, SlotsUsed: 2, Snatches: 7}
+ return &storage.User{ID: createTestUserID(), Passkey: createTestPasskey(),
+ UpMultiplier: 1.01, DownMultiplier: 1.0, Slots: 4, SlotsUsed: 2, Snatches: 7}
}
func createTestPeer(userID uint64, torrentID uint64) *storage.Peer {
- return &storage.Peer{ID: createTestPeerID(), UserID: userID, TorrentID: torrentID,
- IP: "127.0.0.1", Port: 6889, Uploaded: 1024, Downloaded: 3000, Left: 4200, LastAnnounce: 11}
+ return &storage.Peer{ID: createTestPeerID(), UserID: userID, TorrentID: torrentID,
+ IP: "127.0.0.1", Port: 6889, Uploaded: 1024, Downloaded: 3000, Left: 4200, LastAnnounce: 11}
}
func createTestPeers(torrentID uint64, num int) map[string]storage.Peer {
- testPeers := make(map[string]storage.Peer)
- for i := 0; i < num; i++ {
- tempPeer := createTestPeer(createTestUserID(), torrentID)
- testPeers[storage.PeerMapKey(tempPeer)] = *tempPeer
- }
- return testPeers
+ testPeers := make(map[string]storage.Peer)
+ for i := 0; i < num; i++ {
+ tempPeer := createTestPeer(createTestUserID(), torrentID)
+ testPeers[storage.PeerMapKey(tempPeer)] = *tempPeer
+ }
+ return testPeers
}
func createTestTorrent() *storage.Torrent {
- torrentInfohash := createTestInfohash()
- torrentID := createTestTorrentID()
+ torrentInfohash := createTestInfohash()
+ torrentID := createTestTorrentID()
- testSeeders := createTestPeers(torrentID, 4)
- testLeechers := createTestPeers(torrentID, 2)
+ testSeeders := createTestPeers(torrentID, 4)
+ testLeechers := createTestPeers(torrentID, 2)
- testTorrent := storage.Torrent{ID: torrentID, Infohash: torrentInfohash, Active: true,
- Seeders: testSeeders, Leechers: testLeechers, Snatches: 11, UpMultiplier: 1.0, DownMultiplier: 1.0, LastAction: 0}
- return &testTorrent
+ testTorrent := storage.Torrent{ID: torrentID, Infohash: torrentInfohash, Active: true,
+ Seeders: testSeeders, Leechers: testLeechers, Snatches: 11, UpMultiplier: 1.0, DownMultiplier: 1.0, LastAction: 0}
+ return &testTorrent
}
func TestValidPeers(t *testing.T) {
- testConn := createTestRedisConn()
- testTorrentID := createTestTorrentID()
- testPeers := createTestPeers(testTorrentID, 3)
+ testConn := createTestRedisConn()
+ testTorrentID := createTestTorrentID()
+ testPeers := createTestPeers(testTorrentID, 3)
- panicOnErr(testConn.addPeers(testPeers, "test:"))
- peerMap, err := testConn.getPeers(testTorrentID, "test:")
- panicOnErr(err)
- if len(peerMap) != len(testPeers) {
- t.Error("Num Peers not equal ", len(peerMap), len(testPeers))
- }
- panicOnErr(testConn.removePeers(testTorrentID, testPeers, "test:"))
+ panicOnErr(testConn.addPeers(testPeers, "test:"))
+ peerMap, err := testConn.getPeers(testTorrentID, "test:")
+ panicOnErr(err)
+ if len(peerMap) != len(testPeers) {
+ t.Error("Num Peers not equal ", len(peerMap), len(testPeers))
+ }
+ panicOnErr(testConn.removePeers(testTorrentID, testPeers, "test:"))
}
func TestInvalidPeers(t *testing.T) {
- testConn := createTestRedisConn()
- testTorrentID := createTestTorrentID()
- testPeers := createTestPeers(testTorrentID, 3)
- tempPeer := createTestPeer(createTestUserID(), testTorrentID)
- testPeers[storage.PeerMapKey(tempPeer)] = *tempPeer
+ testConn := createTestRedisConn()
+ testTorrentID := createTestTorrentID()
+ testPeers := createTestPeers(testTorrentID, 3)
+ tempPeer := createTestPeer(createTestUserID(), testTorrentID)
+ testPeers[storage.PeerMapKey(tempPeer)] = *tempPeer
- panicOnErr(testConn.addPeers(testPeers, "test:"))
- // Imitate a peer being removed during get
- hashKey := testConn.conf.Prefix + getPeerHashKey(tempPeer)
- _, err := testConn.Do("DEL", hashKey)
- panicOnErr(err)
+ panicOnErr(testConn.addPeers(testPeers, "test:"))
+ // Imitate a peer being removed during get
+ hashKey := testConn.conf.Prefix + getPeerHashKey(tempPeer)
+ _, err := testConn.Do("DEL", hashKey)
+ panicOnErr(err)
- peerMap, err := testConn.getPeers(testTorrentID, "test:")
- panicOnErr(err)
- // Expect 1 less peer due to delete
- if len(peerMap) != len(testPeers)-1 {
- t.Error("Num Peers not equal ", len(peerMap), len(testPeers)-1)
- }
- panicOnErr(testConn.removePeers(testTorrentID, testPeers, "test:"))
- if len(testPeers) != 0 {
- t.Errorf("All peers not removed, %d peers remain!", len(testPeers))
- }
+ peerMap, err := testConn.getPeers(testTorrentID, "test:")
+ panicOnErr(err)
+ // Expect 1 less peer due to delete
+ if len(peerMap) != len(testPeers)-1 {
+ t.Error("Num Peers not equal ", len(peerMap), len(testPeers)-1)
+ }
+ panicOnErr(testConn.removePeers(testTorrentID, testPeers, "test:"))
+ if len(testPeers) != 0 {
+ t.Errorf("All peers not removed, %d peers remain!", len(testPeers))
+ }
}