removed all references to "transaction"
This commit is contained in:
Jimmy Zelinskie
parent
31e618c8d9
commit
9382ac482e
10 changed files with 1698 additions and 1708 deletions
|
|
@ -58,8 +58,6 @@ type Config struct {
|
|||
MinAnnounce Duration `json:"min_announce"`
|
||||
ReadTimeout Duration `json:"read_timeout"`
|
||||
DefaultNumWant int `json:"default_num_want"`
|
||||
|
||||
TxRetries int `json:"tx_retries"`
|
||||
}
|
||||
|
||||
// Open is a shortcut to open a file, read it, and generate a Config.
|
||||
|
|
|
|||
|
|
@ -30,8 +30,6 @@
|
|||
"announce": "30m",
|
||||
"min_announce": "15m",
|
||||
"read_timeout": "20s",
|
||||
"default_num_want": 50,
|
||||
|
||||
"tx_retries": 3
|
||||
"default_num_want": 50
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,25 +23,22 @@ func (s Server) serveAnnounce(w http.ResponseWriter, r *http.Request) {
|
|||
return
|
||||
}
|
||||
|
||||
// Retry failed transactions a specified number of times
|
||||
for i := 0; i < s.conf.TxRetries; i++ {
|
||||
|
||||
// Start a transaction
|
||||
tx, err := s.dbConnPool.Get()
|
||||
// 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(tx, passkey)
|
||||
user, err := validateUser(conn, passkey)
|
||||
if err != nil {
|
||||
fail(err, w, r)
|
||||
return
|
||||
}
|
||||
|
||||
// Check if the user's client is whitelisted
|
||||
whitelisted, err := tx.ClientWhitelisted(parsePeerID(peerID))
|
||||
whitelisted, err := conn.ClientWhitelisted(parsePeerID(peerID))
|
||||
if err != nil {
|
||||
log.Panicf("server: %s", err)
|
||||
}
|
||||
|
|
@ -51,7 +48,7 @@ func (s Server) serveAnnounce(w http.ResponseWriter, r *http.Request) {
|
|||
}
|
||||
|
||||
// Find the specified torrent
|
||||
torrent, exists, err := tx.FindTorrent(infohash)
|
||||
torrent, exists, err := conn.FindTorrent(infohash)
|
||||
if err != nil {
|
||||
log.Panicf("server: %s", err)
|
||||
}
|
||||
|
|
@ -62,7 +59,7 @@ func (s Server) serveAnnounce(w http.ResponseWriter, r *http.Request) {
|
|||
|
||||
// If the torrent was pruned and the user is seeding, unprune it
|
||||
if !torrent.Active && left == 0 {
|
||||
err := tx.MarkActive(torrent)
|
||||
err := conn.MarkActive(torrent)
|
||||
if err != nil {
|
||||
log.Panicf("server: %s", err)
|
||||
}
|
||||
|
|
@ -89,13 +86,13 @@ func (s Server) serveAnnounce(w http.ResponseWriter, r *http.Request) {
|
|||
// Guarantee that no user is in both pools
|
||||
case seeder && leecher:
|
||||
if left == 0 {
|
||||
err := tx.RemoveLeecher(torrent, peer)
|
||||
err := conn.RemoveLeecher(torrent, peer)
|
||||
if err != nil {
|
||||
log.Panicf("server: %s", err)
|
||||
}
|
||||
leecher = false
|
||||
} else {
|
||||
err := tx.RemoveSeeder(torrent, peer)
|
||||
err := conn.RemoveSeeder(torrent, peer)
|
||||
if err != nil {
|
||||
log.Panicf("server: %s", err)
|
||||
}
|
||||
|
|
@ -104,14 +101,14 @@ func (s Server) serveAnnounce(w http.ResponseWriter, r *http.Request) {
|
|||
|
||||
case seeder:
|
||||
// Update the peer with the stats from the request
|
||||
err := tx.SetSeeder(torrent, peer)
|
||||
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 := tx.SetLeecher(torrent, peer)
|
||||
err := conn.SetLeecher(torrent, peer)
|
||||
if err != nil {
|
||||
log.Panicf("server: %s", err)
|
||||
}
|
||||
|
|
@ -127,17 +124,17 @@ func (s Server) serveAnnounce(w http.ResponseWriter, r *http.Request) {
|
|||
|
||||
if left == 0 {
|
||||
// Save the peer as a new seeder
|
||||
err := tx.AddSeeder(torrent, peer)
|
||||
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 := tx.IncrementSlots(user)
|
||||
err := conn.IncrementSlots(user)
|
||||
if err != nil {
|
||||
log.Panicf("server: %s", err)
|
||||
}
|
||||
err = tx.AddLeecher(torrent, peer)
|
||||
err = conn.AddLeecher(torrent, peer)
|
||||
if err != nil {
|
||||
log.Panicf("server: %s", err)
|
||||
}
|
||||
|
|
@ -148,29 +145,29 @@ func (s Server) serveAnnounce(w http.ResponseWriter, r *http.Request) {
|
|||
switch {
|
||||
case event == "stopped" || event == "paused":
|
||||
if seeder {
|
||||
err := tx.RemoveSeeder(torrent, peer)
|
||||
err := conn.RemoveSeeder(torrent, peer)
|
||||
if err != nil {
|
||||
log.Panicf("server: %s", err)
|
||||
}
|
||||
}
|
||||
if leecher {
|
||||
err := tx.RemoveLeecher(torrent, peer)
|
||||
err := conn.RemoveLeecher(torrent, peer)
|
||||
if err != nil {
|
||||
log.Panicf("server: %s", err)
|
||||
}
|
||||
err = tx.DecrementSlots(user)
|
||||
err = conn.DecrementSlots(user)
|
||||
if err != nil {
|
||||
log.Panicf("server: %s", err)
|
||||
}
|
||||
}
|
||||
|
||||
case event == "completed":
|
||||
err := tx.RecordSnatch(user, torrent)
|
||||
err := conn.RecordSnatch(user, torrent)
|
||||
if err != nil {
|
||||
log.Panicf("server: %s", err)
|
||||
}
|
||||
if leecher {
|
||||
err := tx.LeecherFinished(torrent, peer)
|
||||
err := conn.LeecherFinished(torrent, peer)
|
||||
if err != nil {
|
||||
log.Panicf("server: %s", err)
|
||||
}
|
||||
|
|
@ -178,7 +175,7 @@ func (s Server) serveAnnounce(w http.ResponseWriter, r *http.Request) {
|
|||
|
||||
case leecher && left == 0:
|
||||
// A leecher completed but the event was never received
|
||||
err := tx.LeecherFinished(torrent, peer)
|
||||
err := conn.LeecherFinished(torrent, peer)
|
||||
if err != nil {
|
||||
log.Panicf("server: %s", err)
|
||||
}
|
||||
|
|
@ -237,9 +234,6 @@ func (s Server) serveAnnounce(w http.ResponseWriter, r *http.Request) {
|
|||
}
|
||||
}
|
||||
writeBencoded(w, "e")
|
||||
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
func (s Server) validateAnnounceQuery(r *http.Request) (compact bool, numWant int, infohash, peerID, event, ip string, port, uploaded, downloaded, left uint64, err error) {
|
||||
|
|
|
|||
|
|
@ -22,15 +22,15 @@ func (s *Server) serveScrape(w http.ResponseWriter, r *http.Request) {
|
|||
return
|
||||
}
|
||||
|
||||
// Start a transaction
|
||||
tx, err := s.dbConnPool.Get()
|
||||
// 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(tx, passkey)
|
||||
_, err = validateUser(conn, passkey)
|
||||
if err != nil {
|
||||
fail(err, w, r)
|
||||
return
|
||||
|
|
@ -40,7 +40,7 @@ func (s *Server) serveScrape(w http.ResponseWriter, r *http.Request) {
|
|||
writeBencoded(w, "files")
|
||||
if pq.Infohashes != nil {
|
||||
for _, infohash := range pq.Infohashes {
|
||||
torrent, exists, err := tx.FindTorrent(infohash)
|
||||
torrent, exists, err := conn.FindTorrent(infohash)
|
||||
if err != nil {
|
||||
log.Panicf("server: %s", err)
|
||||
}
|
||||
|
|
@ -50,7 +50,7 @@ func (s *Server) serveScrape(w http.ResponseWriter, r *http.Request) {
|
|||
}
|
||||
}
|
||||
} else if infohash, exists := pq.Params["info_hash"]; exists {
|
||||
torrent, exists, err := tx.FindTorrent(infohash)
|
||||
torrent, exists, err := conn.FindTorrent(infohash)
|
||||
if err != nil {
|
||||
log.Panicf("server: %s", err)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -117,13 +117,13 @@ func fail(err error, w http.ResponseWriter, r *http.Request) {
|
|||
w.(http.Flusher).Flush()
|
||||
}
|
||||
|
||||
func validateUser(tx tracker.Conn, dir string) (*storage.User, error) {
|
||||
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]
|
||||
|
||||
user, exists, err := tx.FindUser(passkey)
|
||||
user, exists, err := conn.FindUser(passkey)
|
||||
if err != nil {
|
||||
log.Panicf("server: %s", err)
|
||||
}
|
||||
|
|
|
|||
563
storage/tracker/redis/conn_test.go
Normal file
563
storage/tracker/redis/conn_test.go
Normal file
|
|
@ -0,0 +1,563 @@
|
|||
// Copyright 2013 The Chihaya Authors. All rights reserved.
|
||||
// Use of this source code is governed by the BSD 2-Clause license,
|
||||
// which can be found in the LICENSE file.
|
||||
|
||||
package redis
|
||||
|
||||
import (
|
||||
"math/rand"
|
||||
"os"
|
||||
"reflect"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"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
|
||||
|
||||
testPool, err := tracker.Open(conf)
|
||||
panicOnErr(err)
|
||||
|
||||
newConn, err := testPool.Get()
|
||||
panicOnErr(err)
|
||||
|
||||
return newConn
|
||||
}
|
||||
|
||||
func TestFindUserSuccess(t *testing.T) {
|
||||
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))
|
||||
}
|
||||
|
||||
func TestFindUserFail(t *testing.T) {
|
||||
conn := createTestConn()
|
||||
testUser := createTestUser()
|
||||
|
||||
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()
|
||||
|
||||
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))
|
||||
|
||||
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()
|
||||
|
||||
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))
|
||||
|
||||
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-"
|
||||
|
||||
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"
|
||||
|
||||
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))
|
||||
|
||||
userSnatches := testUser.Snatches
|
||||
torrentSnatches := testTorrent.Snatches
|
||||
|
||||
panicOnErr(conn.RecordSnatch(testUser, testTorrent))
|
||||
|
||||
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))
|
||||
}
|
||||
|
||||
func TestMarkActive(t *testing.T) {
|
||||
conn := createTestConn()
|
||||
testTorrent := createTestTorrent()
|
||||
testTorrent.Active = false
|
||||
panicOnErr(conn.AddTorrent(testTorrent))
|
||||
|
||||
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))
|
||||
}
|
||||
|
||||
func TestClientWhitelistRemove(t *testing.T) {
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAddSeeder(t *testing.T) {
|
||||
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))
|
||||
}
|
||||
|
||||
func TestAddLeecher(t *testing.T) {
|
||||
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))
|
||||
}
|
||||
|
||||
func TestRemoveSeeder(t *testing.T) {
|
||||
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)
|
||||
}
|
||||
|
||||
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))
|
||||
|
||||
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))
|
||||
|
||||
r := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||||
testSeeder.Uploaded += uint64(r.Int63())
|
||||
|
||||
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))
|
||||
}
|
||||
|
||||
func TestSetLeecher(t *testing.T) {
|
||||
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())
|
||||
|
||||
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
|
||||
|
||||
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))
|
||||
}
|
||||
|
||||
func TestDecrementSlots(t *testing.T) {
|
||||
conn := createTestConn()
|
||||
testUser := createTestUser()
|
||||
panicOnErr(conn.AddUser(testUser))
|
||||
numSlots := testUser.Slots
|
||||
|
||||
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))
|
||||
}
|
||||
|
||||
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
|
||||
|
||||
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))
|
||||
}
|
||||
|
||||
// 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())
|
||||
|
||||
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))
|
||||
}
|
||||
|
||||
func TestParallelFindUser(t *testing.T) {
|
||||
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))
|
||||
}
|
||||
|
||||
func TestParallelFindTorrent(t *testing.T) {
|
||||
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))
|
||||
}
|
||||
|
||||
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()))
|
||||
|
||||
for i := 0; i < 10; i++ {
|
||||
testSeeder.Uploaded += uint64(r.Int63())
|
||||
|
||||
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))
|
||||
}
|
||||
|
||||
func TestParallelAddLeecher(t *testing.T) {
|
||||
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)
|
||||
|
||||
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))
|
||||
}
|
||||
|
|
@ -90,26 +90,26 @@ func (p *Pool) Close() error {
|
|||
}
|
||||
|
||||
func (p *Pool) Get() (tracker.Conn, error) {
|
||||
retTx := &Tx{
|
||||
newConn := &Conn{
|
||||
conf: p.conf,
|
||||
done: false,
|
||||
Conn: p.pool.Get(),
|
||||
}
|
||||
return retTx, nil
|
||||
return newConn, nil
|
||||
}
|
||||
|
||||
type Tx struct {
|
||||
type Conn struct {
|
||||
conf *config.DataStore
|
||||
done bool
|
||||
redis.Conn
|
||||
}
|
||||
|
||||
func (tx *Tx) close() {
|
||||
if tx.done {
|
||||
panic("redis: transaction closed twice")
|
||||
func (conn *Conn) close() {
|
||||
if conn.done {
|
||||
panic("redis: connection closed twice")
|
||||
}
|
||||
tx.done = true
|
||||
tx.Conn.Close()
|
||||
conn.done = true
|
||||
conn.Conn.Close()
|
||||
}
|
||||
|
||||
// createUser takes a string slice of length 14 and returns a pointer to a new
|
||||
|
|
@ -158,7 +158,7 @@ func createUser(userVals []string) (*storage.User, error) {
|
|||
// If the field values cannot be converted to the correct type,
|
||||
// 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 (tx *Tx) createTorrent(torrentVals []string) (*storage.Torrent, error) {
|
||||
func (conn *Conn) createTorrent(torrentVals []string) (*storage.Torrent, error) {
|
||||
if len(torrentVals) != 14 {
|
||||
return nil, ErrCreateTorrent
|
||||
}
|
||||
|
|
@ -185,11 +185,11 @@ func (tx *Tx) createTorrent(torrentVals []string) (*storage.Torrent, error) {
|
|||
return nil, err
|
||||
}
|
||||
}
|
||||
torrent.Seeders, err = tx.getPeers(torrent.ID, SeedersPrefix)
|
||||
torrent.Seeders, err = conn.getPeers(torrent.ID, SeedersPrefix)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
torrent.Leechers, err = tx.getPeers(torrent.ID, LeechersPrefix)
|
||||
torrent.Leechers, err = conn.getPeers(torrent.ID, LeechersPrefix)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
|
@ -198,9 +198,9 @@ func (tx *Tx) createTorrent(torrentVals []string) (*storage.Torrent, error) {
|
|||
|
||||
// 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 (tx *Tx) setPeer(peer *storage.Peer) error {
|
||||
hashKey := tx.conf.Prefix + getPeerHashKey(peer)
|
||||
_, err := tx.Do("HMSET", hashKey,
|
||||
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,
|
||||
|
|
@ -218,14 +218,14 @@ func (tx *Tx) setPeer(peer *storage.Peer) error {
|
|||
// and removes the peer information.
|
||||
// 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 (tx *Tx) removePeer(peer *storage.Peer, peerTypePrefix string) error {
|
||||
setKey := tx.conf.Prefix + getPeerSetKey(peerTypePrefix, peer)
|
||||
_, err := tx.Do("SREM", setKey, getPeerHashKey(peer))
|
||||
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 := tx.conf.Prefix + getPeerHashKey(peer)
|
||||
_, err = tx.Do("DEL", hashKey)
|
||||
hashKey := conn.conf.Prefix + getPeerHashKey(peer)
|
||||
_, err = conn.Do("DEL", hashKey)
|
||||
return nil
|
||||
}
|
||||
|
||||
|
|
@ -234,17 +234,17 @@ func (tx *Tx) removePeer(peer *storage.Peer, peerTypePrefix string) error {
|
|||
// This function will not return an error if the peer to remove doesn't exist.
|
||||
// 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 (tx *Tx) removePeers(torrentID uint64, peers map[string]storage.Peer, peerTypePrefix string) error {
|
||||
func (conn *Conn) removePeers(torrentID uint64, peers map[string]storage.Peer, peerTypePrefix string) error {
|
||||
for _, peer := range peers {
|
||||
hashKey := tx.conf.Prefix + getPeerHashKey(&peer)
|
||||
_, err := tx.Do("DEL", hashKey)
|
||||
hashKey := conn.conf.Prefix + getPeerHashKey(&peer)
|
||||
_, err := conn.Do("DEL", hashKey)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
delete(peers, storage.PeerMapKey(&peer))
|
||||
}
|
||||
setKey := tx.conf.Prefix + peerTypePrefix + strconv.FormatUint(torrentID, 36)
|
||||
_, err := tx.Do("DEL", setKey)
|
||||
setKey := conn.conf.Prefix + peerTypePrefix + strconv.FormatUint(torrentID, 36)
|
||||
_, err := conn.Do("DEL", setKey)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -268,14 +268,14 @@ func getPeerSetKey(typePrefix string, peer *storage.Peer) string {
|
|||
// 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 (tx *Tx) addPeers(peers map[string]storage.Peer, peerTypePrefix string) error {
|
||||
func (conn *Conn) addPeers(peers map[string]storage.Peer, peerTypePrefix string) error {
|
||||
for _, peer := range peers {
|
||||
setKey := tx.conf.Prefix + getPeerSetKey(peerTypePrefix, &peer)
|
||||
_, err := tx.Do("SADD", setKey, getPeerHashKey(&peer))
|
||||
setKey := conn.conf.Prefix + getPeerSetKey(peerTypePrefix, &peer)
|
||||
_, err := conn.Do("SADD", setKey, getPeerHashKey(&peer))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
tx.setPeer(&peer)
|
||||
conn.setPeer(&peer)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
|
@ -322,17 +322,17 @@ func createPeer(peerVals []string) (*storage.Peer, error) {
|
|||
|
||||
// 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 (tx *Tx) getPeers(torrentID uint64, peerTypePrefix string) (peers map[string]storage.Peer, err error) {
|
||||
func (conn *Conn) getPeers(torrentID uint64, peerTypePrefix string) (peers map[string]storage.Peer, err error) {
|
||||
peers = make(map[string]storage.Peer)
|
||||
setKey := tx.conf.Prefix + peerTypePrefix + strconv.FormatUint(torrentID, 36)
|
||||
peerStrings, err := redis.Strings(tx.Do("SMEMBERS", setKey))
|
||||
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 := tx.conf.Prefix + peerHashKey
|
||||
peerVals, err := redis.Strings(tx.Do("HGETALL", hashKey))
|
||||
hashKey := conn.conf.Prefix + peerHashKey
|
||||
peerVals, err := redis.Strings(conn.Do("HGETALL", hashKey))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
|
@ -351,9 +351,9 @@ func (tx *Tx) getPeers(torrentID uint64, peerTypePrefix string) (peers map[strin
|
|||
// 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 (tx *Tx) AddTorrent(t *storage.Torrent) error {
|
||||
hashkey := tx.conf.Prefix + TorrentPrefix + t.Infohash
|
||||
_, err := tx.Do("HMSET", hashkey,
|
||||
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,
|
||||
|
|
@ -365,11 +365,11 @@ func (tx *Tx) AddTorrent(t *storage.Torrent) error {
|
|||
return err
|
||||
}
|
||||
|
||||
err = tx.addPeers(t.Seeders, SeedersPrefix)
|
||||
err = conn.addPeers(t.Seeders, SeedersPrefix)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = tx.addPeers(t.Leechers, LeechersPrefix)
|
||||
err = conn.addPeers(t.Leechers, LeechersPrefix)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -379,18 +379,18 @@ func (tx *Tx) AddTorrent(t *storage.Torrent) error {
|
|||
// 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 (tx *Tx) RemoveTorrent(t *storage.Torrent) error {
|
||||
hashkey := tx.conf.Prefix + TorrentPrefix + t.Infohash
|
||||
_, err := tx.Do("DEL", hashkey)
|
||||
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 = tx.removePeers(t.ID, t.Seeders, SeedersPrefix)
|
||||
err = conn.removePeers(t.ID, t.Seeders, SeedersPrefix)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = tx.removePeers(t.ID, t.Leechers, LeechersPrefix)
|
||||
err = conn.removePeers(t.ID, t.Leechers, LeechersPrefix)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -399,9 +399,9 @@ func (tx *Tx) RemoveTorrent(t *storage.Torrent) error {
|
|||
|
||||
// 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 (tx *Tx) AddUser(u *storage.User) error {
|
||||
hashkey := tx.conf.Prefix + UserPrefix + u.Passkey
|
||||
_, err := tx.Do("HMSET", hashkey,
|
||||
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,
|
||||
|
|
@ -417,9 +417,9 @@ func (tx *Tx) AddUser(u *storage.User) error {
|
|||
|
||||
// RemoveUser removes the user's hash from Redis.
|
||||
// This function does not return an error if the user doesn't exist.
|
||||
func (tx *Tx) RemoveUser(u *storage.User) error {
|
||||
hashkey := tx.conf.Prefix + UserPrefix + u.Passkey
|
||||
_, err := tx.Do("DEL", hashkey)
|
||||
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
|
||||
}
|
||||
|
|
@ -429,10 +429,10 @@ func (tx *Tx) RemoveUser(u *storage.User) error {
|
|||
// 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 (tx *Tx) FindUser(passkey string) (*storage.User, bool, error) {
|
||||
hashkey := tx.conf.Prefix + UserPrefix + passkey
|
||||
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(tx.Do("HGETALL", hashkey))
|
||||
userStrings, err := redis.Strings(conn.Do("HGETALL", hashkey))
|
||||
if err != nil {
|
||||
return nil, false, err
|
||||
} else if len(userStrings) == 0 {
|
||||
|
|
@ -448,16 +448,16 @@ func (tx *Tx) FindUser(passkey string) (*storage.User, bool, error) {
|
|||
// 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 (tx *Tx) FindTorrent(infohash string) (*storage.Torrent, bool, error) {
|
||||
hashkey := tx.conf.Prefix + TorrentPrefix + infohash
|
||||
torrentStrings, err := redis.Strings(tx.Do("HGETALL", hashkey))
|
||||
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
|
||||
}
|
||||
|
||||
foundTorrent, err := tx.createTorrent(torrentStrings)
|
||||
foundTorrent, err := conn.createTorrent(torrentStrings)
|
||||
if err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
|
|
@ -467,41 +467,41 @@ func (tx *Tx) FindTorrent(infohash string) (*storage.Torrent, bool, error) {
|
|||
// 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 (tx *Tx) ClientWhitelisted(peerID string) (exists bool, err error) {
|
||||
key := tx.conf.Prefix + "whitelist"
|
||||
return redis.Bool(tx.Do("SISMEMBER", key, peerID))
|
||||
func (conn *Conn) ClientWhitelisted(peerID string) (exists bool, err error) {
|
||||
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 (tx *Tx) WhitelistClient(peerID string) error {
|
||||
key := tx.conf.Prefix + "whitelist"
|
||||
_, err := tx.Do("SADD", key, peerID)
|
||||
func (conn *Conn) WhitelistClient(peerID string) error {
|
||||
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 (tx *Tx) UnWhitelistClient(peerID string) error {
|
||||
key := tx.conf.Prefix + "whitelist"
|
||||
_, err := tx.Do("SREM", key, peerID)
|
||||
func (conn *Conn) UnWhitelistClient(peerID string) error {
|
||||
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.
|
||||
// This modifies the arguments as well as the hash field in Redis.
|
||||
// This is a multiple action command, it's not internally atomic.
|
||||
func (tx *Tx) RecordSnatch(user *storage.User, torrent *storage.Torrent) error {
|
||||
func (conn *Conn) RecordSnatch(user *storage.User, torrent *storage.Torrent) error {
|
||||
|
||||
torrentKey := tx.conf.Prefix + TorrentPrefix + torrent.Infohash
|
||||
snatchCount, err := redis.Int(tx.Do("HINCRBY", torrentKey, "snatches", 1))
|
||||
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 := tx.conf.Prefix + UserPrefix + user.Passkey
|
||||
snatchCount, err = redis.Int(tx.Do("HINCRBY", userKey, "snatches", 1))
|
||||
userKey := conn.conf.Prefix + UserPrefix + user.Passkey
|
||||
snatchCount, err = redis.Int(conn.Do("HINCRBY", userKey, "snatches", 1))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -512,9 +512,9 @@ func (tx *Tx) RecordSnatch(user *storage.User, torrent *storage.Torrent) error {
|
|||
// 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 (tx *Tx) MarkActive(torrent *storage.Torrent) error {
|
||||
hashkey := tx.conf.Prefix + TorrentPrefix + torrent.Infohash
|
||||
activeExists, err := redis.Int(tx.Do("HSET", hashkey, "active", true))
|
||||
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
|
||||
}
|
||||
|
|
@ -529,9 +529,9 @@ func (tx *Tx) MarkActive(torrent *storage.Torrent) error {
|
|||
// 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 (tx *Tx) MarkInactive(torrent *storage.Torrent) error {
|
||||
hashkey := tx.conf.Prefix + TorrentPrefix + torrent.Infohash
|
||||
activeExists, err := redis.Int(tx.Do("HSET", hashkey, "active", false))
|
||||
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
|
||||
}
|
||||
|
|
@ -539,7 +539,7 @@ func (tx *Tx) MarkInactive(torrent *storage.Torrent) error {
|
|||
// HSET returns 1 if hash didn't exist before
|
||||
if activeExists == 1 {
|
||||
// Clean-up incomplete torrent
|
||||
_, err = tx.Do("DEL", hashkey)
|
||||
_, err = conn.Do("DEL", hashkey)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -552,13 +552,13 @@ func (tx *Tx) MarkInactive(torrent *storage.Torrent) error {
|
|||
// 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 leecher already exists.
|
||||
// This is a multiple action command, it's not internally atomic.
|
||||
func (tx *Tx) AddLeecher(torrent *storage.Torrent, peer *storage.Peer) error {
|
||||
setKey := tx.conf.Prefix + LeechersPrefix + strconv.FormatUint(torrent.ID, 36)
|
||||
_, err := tx.Do("SADD", setKey, getPeerHashKey(peer))
|
||||
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 = tx.setPeer(peer)
|
||||
err = conn.setPeer(peer)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -573,8 +573,8 @@ func (tx *Tx) AddLeecher(torrent *storage.Torrent, peer *storage.Peer) error {
|
|||
// This modifies the torrent argument, as well as the peer's hash in Redis.
|
||||
// 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 (tx *Tx) SetLeecher(t *storage.Torrent, p *storage.Peer) error {
|
||||
err := tx.setPeer(p)
|
||||
func (conn *Conn) SetLeecher(t *storage.Torrent, p *storage.Peer) error {
|
||||
err := conn.setPeer(p)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -585,8 +585,8 @@ func (tx *Tx) SetLeecher(t *storage.Torrent, p *storage.Peer) error {
|
|||
// 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 (tx *Tx) RemoveLeecher(t *storage.Torrent, p *storage.Peer) error {
|
||||
err := tx.removePeer(p, LeechersPrefix)
|
||||
func (conn *Conn) RemoveLeecher(t *storage.Torrent, p *storage.Peer) error {
|
||||
err := conn.removePeer(p, LeechersPrefix)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -597,19 +597,19 @@ func (tx *Tx) RemoveLeecher(t *storage.Torrent, p *storage.Peer) error {
|
|||
// 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 (tx *Tx) LeecherFinished(torrent *storage.Torrent, peer *storage.Peer) error {
|
||||
func (conn *Conn) LeecherFinished(torrent *storage.Torrent, peer *storage.Peer) error {
|
||||
torrentIdKey := strconv.FormatUint(torrent.ID, 36)
|
||||
seederSetKey := tx.conf.Prefix + SeedersPrefix + torrentIdKey
|
||||
leecherSetKey := tx.conf.Prefix + LeechersPrefix + torrentIdKey
|
||||
seederSetKey := conn.conf.Prefix + SeedersPrefix + torrentIdKey
|
||||
leecherSetKey := conn.conf.Prefix + LeechersPrefix + torrentIdKey
|
||||
|
||||
_, err := tx.Do("SMOVE", leecherSetKey, seederSetKey, getPeerHashKey(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 = tx.setPeer(peer)
|
||||
err = conn.setPeer(peer)
|
||||
return err
|
||||
}
|
||||
|
||||
|
|
@ -617,13 +617,13 @@ func (tx *Tx) LeecherFinished(torrent *storage.Torrent, peer *storage.Peer) erro
|
|||
// 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 seeder already exists.
|
||||
// This is a multiple action command, it's not internally atomic.
|
||||
func (tx *Tx) AddSeeder(torrent *storage.Torrent, peer *storage.Peer) error {
|
||||
setKey := tx.conf.Prefix + SeedersPrefix + strconv.FormatUint(torrent.ID, 36)
|
||||
_, err := tx.Do("SADD", setKey, getPeerHashKey(peer))
|
||||
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 = tx.setPeer(peer)
|
||||
err = conn.setPeer(peer)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -638,8 +638,8 @@ func (tx *Tx) AddSeeder(torrent *storage.Torrent, peer *storage.Peer) error {
|
|||
// This modifies the torrent argument, as well as the peer's hash in Redis.
|
||||
// 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 (tx *Tx) SetSeeder(t *storage.Torrent, p *storage.Peer) error {
|
||||
err := tx.setPeer(p)
|
||||
func (conn *Conn) SetSeeder(t *storage.Torrent, p *storage.Peer) error {
|
||||
err := conn.setPeer(p)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -650,8 +650,8 @@ func (tx *Tx) SetSeeder(t *storage.Torrent, p *storage.Peer) error {
|
|||
// 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 (tx *Tx) RemoveSeeder(t *storage.Torrent, p *storage.Peer) error {
|
||||
err := tx.removePeer(p, SeedersPrefix)
|
||||
func (conn *Conn) RemoveSeeder(t *storage.Torrent, p *storage.Peer) error {
|
||||
err := conn.removePeer(p, SeedersPrefix)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -661,9 +661,9 @@ func (tx *Tx) RemoveSeeder(t *storage.Torrent, p *storage.Peer) error {
|
|||
|
||||
// IncrementSlots increment a user's Slots by one.
|
||||
// This function modifies the argument as well as the hash field in Redis.
|
||||
func (tx *Tx) IncrementSlots(u *storage.User) error {
|
||||
hashkey := tx.conf.Prefix + UserPrefix + u.Passkey
|
||||
slotCount, err := redis.Int(tx.Do("HINCRBY", hashkey, "slots", 1))
|
||||
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
|
||||
}
|
||||
|
|
@ -673,9 +673,9 @@ func (tx *Tx) IncrementSlots(u *storage.User) error {
|
|||
|
||||
// IncrementSlots increment a user's Slots by one.
|
||||
// This function modifies the argument as well as the hash field in Redis.
|
||||
func (tx *Tx) DecrementSlots(u *storage.User) error {
|
||||
hashkey := tx.conf.Prefix + UserPrefix + u.Passkey
|
||||
slotCount, err := redis.Int(tx.Do("HINCRBY", hashkey, "slots", -1))
|
||||
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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,14 +12,14 @@ import (
|
|||
|
||||
func BenchmarkSuccessfulFindUser(b *testing.B) {
|
||||
b.StopTimer()
|
||||
tx := createTestTx()
|
||||
conn := createTestConn()
|
||||
testUser := createTestUser()
|
||||
panicOnErr(tx.AddUser(testUser))
|
||||
panicOnErr(conn.AddUser(testUser))
|
||||
b.StartTimer()
|
||||
|
||||
for bCount := 0; bCount < b.N; bCount++ {
|
||||
|
||||
foundUser, found, err := tx.FindUser(testUser.Passkey)
|
||||
foundUser, found, err := conn.FindUser(testUser.Passkey)
|
||||
panicOnErr(err)
|
||||
if !found {
|
||||
b.Error("user not found", testUser)
|
||||
|
|
@ -30,19 +30,19 @@ func BenchmarkSuccessfulFindUser(b *testing.B) {
|
|||
}
|
||||
// Cleanup
|
||||
b.StopTimer()
|
||||
panicOnErr(tx.RemoveUser(testUser))
|
||||
panicOnErr(conn.RemoveUser(testUser))
|
||||
b.StartTimer()
|
||||
}
|
||||
|
||||
func BenchmarkFailedFindUser(b *testing.B) {
|
||||
b.StopTimer()
|
||||
tx := createTestTx()
|
||||
conn := createTestConn()
|
||||
testUser := createTestUser()
|
||||
b.StartTimer()
|
||||
|
||||
for bCount := 0; bCount < b.N; bCount++ {
|
||||
|
||||
_, found, err := tx.FindUser(testUser.Passkey)
|
||||
_, found, err := conn.FindUser(testUser.Passkey)
|
||||
panicOnErr(err)
|
||||
if found {
|
||||
b.Error("user not found", testUser)
|
||||
|
|
@ -52,14 +52,14 @@ func BenchmarkFailedFindUser(b *testing.B) {
|
|||
|
||||
func BenchmarkSuccessfulFindTorrent(b *testing.B) {
|
||||
b.StopTimer()
|
||||
tx := createTestTx()
|
||||
conn := createTestConn()
|
||||
testTorrent := createTestTorrent()
|
||||
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
panicOnErr(conn.AddTorrent(testTorrent))
|
||||
b.StartTimer()
|
||||
|
||||
for bCount := 0; bCount < b.N; bCount++ {
|
||||
foundTorrent, found, err := tx.FindTorrent(testTorrent.Infohash)
|
||||
foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
|
||||
panicOnErr(err)
|
||||
if !found {
|
||||
b.Error("torrent not found", testTorrent)
|
||||
|
|
@ -71,18 +71,18 @@ func BenchmarkSuccessfulFindTorrent(b *testing.B) {
|
|||
}
|
||||
// Cleanup
|
||||
b.StopTimer()
|
||||
panicOnErr(tx.RemoveTorrent(testTorrent))
|
||||
panicOnErr(conn.RemoveTorrent(testTorrent))
|
||||
b.StartTimer()
|
||||
}
|
||||
|
||||
func BenchmarkFailFindTorrent(b *testing.B) {
|
||||
b.StopTimer()
|
||||
tx := createTestTx()
|
||||
conn := createTestConn()
|
||||
testTorrent := createTestTorrent()
|
||||
b.StartTimer()
|
||||
|
||||
for bCount := 0; bCount < b.N; bCount++ {
|
||||
foundTorrent, found, err := tx.FindTorrent(testTorrent.Infohash)
|
||||
foundTorrent, found, err := conn.FindTorrent(testTorrent.Infohash)
|
||||
panicOnErr(err)
|
||||
if found {
|
||||
b.Error("torrent found", foundTorrent)
|
||||
|
|
@ -92,13 +92,13 @@ func BenchmarkFailFindTorrent(b *testing.B) {
|
|||
|
||||
func BenchmarkSuccessfulClientWhitelisted(b *testing.B) {
|
||||
b.StopTimer()
|
||||
tx := createTestTx()
|
||||
conn := createTestConn()
|
||||
testPeerID := "-lt0D30-"
|
||||
panicOnErr(tx.WhitelistClient(testPeerID))
|
||||
panicOnErr(conn.WhitelistClient(testPeerID))
|
||||
b.StartTimer()
|
||||
|
||||
for bCount := 0; bCount < b.N; bCount++ {
|
||||
found, err := tx.ClientWhitelisted(testPeerID)
|
||||
found, err := conn.ClientWhitelisted(testPeerID)
|
||||
panicOnErr(err)
|
||||
if !found {
|
||||
b.Error("peerID not found", testPeerID)
|
||||
|
|
@ -106,18 +106,18 @@ func BenchmarkSuccessfulClientWhitelisted(b *testing.B) {
|
|||
}
|
||||
// Cleanup
|
||||
b.StopTimer()
|
||||
panicOnErr(tx.UnWhitelistClient(testPeerID))
|
||||
panicOnErr(conn.UnWhitelistClient(testPeerID))
|
||||
b.StartTimer()
|
||||
}
|
||||
|
||||
func BenchmarkFailClientWhitelisted(b *testing.B) {
|
||||
b.StopTimer()
|
||||
tx := createTestTx()
|
||||
conn := createTestConn()
|
||||
testPeerID2 := "TIX0192"
|
||||
b.StartTimer()
|
||||
|
||||
for bCount := 0; bCount < b.N; bCount++ {
|
||||
found, err := tx.ClientWhitelisted(testPeerID2)
|
||||
found, err := conn.ClientWhitelisted(testPeerID2)
|
||||
panicOnErr(err)
|
||||
if found {
|
||||
b.Error("peerID found", testPeerID2)
|
||||
|
|
@ -127,45 +127,45 @@ func BenchmarkFailClientWhitelisted(b *testing.B) {
|
|||
|
||||
func BenchmarkRecordSnatch(b *testing.B) {
|
||||
b.StopTimer()
|
||||
tx := createTestTx()
|
||||
conn := createTestConn()
|
||||
testTorrent := createTestTorrent()
|
||||
testUser := createTestUser()
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
panicOnErr(tx.AddUser(testUser))
|
||||
panicOnErr(conn.AddTorrent(testTorrent))
|
||||
panicOnErr(conn.AddUser(testUser))
|
||||
b.StartTimer()
|
||||
|
||||
for bCount := 0; bCount < b.N; bCount++ {
|
||||
panicOnErr(tx.RecordSnatch(testUser, testTorrent))
|
||||
panicOnErr(conn.RecordSnatch(testUser, testTorrent))
|
||||
}
|
||||
// Cleanup
|
||||
b.StopTimer()
|
||||
panicOnErr(tx.RemoveTorrent(testTorrent))
|
||||
panicOnErr(tx.RemoveUser(testUser))
|
||||
panicOnErr(conn.RemoveTorrent(testTorrent))
|
||||
panicOnErr(conn.RemoveUser(testUser))
|
||||
b.StartTimer()
|
||||
}
|
||||
|
||||
func BenchmarkMarkActive(b *testing.B) {
|
||||
b.StopTimer()
|
||||
tx := createTestTx()
|
||||
conn := createTestConn()
|
||||
testTorrent := createTestTorrent()
|
||||
testTorrent.Active = false
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
panicOnErr(conn.AddTorrent(testTorrent))
|
||||
b.StartTimer()
|
||||
|
||||
for bCount := 0; bCount < b.N; bCount++ {
|
||||
panicOnErr(tx.MarkActive(testTorrent))
|
||||
panicOnErr(conn.MarkActive(testTorrent))
|
||||
}
|
||||
// Cleanup
|
||||
b.StopTimer()
|
||||
panicOnErr(tx.RemoveTorrent(testTorrent))
|
||||
panicOnErr(conn.RemoveTorrent(testTorrent))
|
||||
b.StartTimer()
|
||||
}
|
||||
|
||||
func BenchmarkAddSeeder(b *testing.B) {
|
||||
b.StopTimer()
|
||||
tx := createTestTx()
|
||||
conn := createTestConn()
|
||||
testTorrent := createTestTorrent()
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
panicOnErr(conn.AddTorrent(testTorrent))
|
||||
b.StartTimer()
|
||||
|
||||
for bCount := 0; bCount < b.N; bCount++ {
|
||||
|
|
@ -173,42 +173,42 @@ func BenchmarkAddSeeder(b *testing.B) {
|
|||
testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
|
||||
b.StartTimer()
|
||||
|
||||
panicOnErr(tx.AddSeeder(testTorrent, testSeeder))
|
||||
panicOnErr(conn.AddSeeder(testTorrent, testSeeder))
|
||||
}
|
||||
// Cleanup
|
||||
b.StopTimer()
|
||||
panicOnErr(tx.RemoveTorrent(testTorrent))
|
||||
panicOnErr(conn.RemoveTorrent(testTorrent))
|
||||
b.StartTimer()
|
||||
}
|
||||
|
||||
func BenchmarkRemoveSeeder(b *testing.B) {
|
||||
b.StopTimer()
|
||||
tx := createTestTx()
|
||||
conn := createTestConn()
|
||||
testTorrent := createTestTorrent()
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
panicOnErr(conn.AddTorrent(testTorrent))
|
||||
testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
|
||||
b.StartTimer()
|
||||
|
||||
for bCount := 0; bCount < b.N; bCount++ {
|
||||
b.StopTimer()
|
||||
tx.AddSeeder(testTorrent, testSeeder)
|
||||
conn.AddSeeder(testTorrent, testSeeder)
|
||||
b.StartTimer()
|
||||
|
||||
panicOnErr(tx.RemoveSeeder(testTorrent, testSeeder))
|
||||
panicOnErr(conn.RemoveSeeder(testTorrent, testSeeder))
|
||||
}
|
||||
// Cleanup
|
||||
b.StopTimer()
|
||||
panicOnErr(tx.RemoveTorrent(testTorrent))
|
||||
panicOnErr(conn.RemoveTorrent(testTorrent))
|
||||
b.StartTimer()
|
||||
}
|
||||
|
||||
func BenchmarkSetSeeder(b *testing.B) {
|
||||
b.StopTimer()
|
||||
tx := createTestTx()
|
||||
conn := createTestConn()
|
||||
testTorrent := createTestTorrent()
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
panicOnErr(conn.AddTorrent(testTorrent))
|
||||
testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
|
||||
panicOnErr(tx.AddSeeder(testTorrent, testSeeder))
|
||||
panicOnErr(conn.AddSeeder(testTorrent, testSeeder))
|
||||
r := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||||
b.StartTimer()
|
||||
|
||||
|
|
@ -217,72 +217,72 @@ func BenchmarkSetSeeder(b *testing.B) {
|
|||
testSeeder.Uploaded += uint64(r.Int63())
|
||||
b.StartTimer()
|
||||
|
||||
tx.SetSeeder(testTorrent, testSeeder)
|
||||
conn.SetSeeder(testTorrent, testSeeder)
|
||||
}
|
||||
// Cleanup
|
||||
b.StopTimer()
|
||||
panicOnErr(tx.RemoveTorrent(testTorrent))
|
||||
panicOnErr(conn.RemoveTorrent(testTorrent))
|
||||
b.StartTimer()
|
||||
}
|
||||
|
||||
func BenchmarkIncrementSlots(b *testing.B) {
|
||||
b.StopTimer()
|
||||
tx := createTestTx()
|
||||
conn := createTestConn()
|
||||
testUser := createTestUser()
|
||||
panicOnErr(tx.AddUser(testUser))
|
||||
panicOnErr(conn.AddUser(testUser))
|
||||
b.StartTimer()
|
||||
|
||||
for bCount := 0; bCount < b.N; bCount++ {
|
||||
panicOnErr(tx.IncrementSlots(testUser))
|
||||
panicOnErr(conn.IncrementSlots(testUser))
|
||||
}
|
||||
// Cleanup
|
||||
b.StopTimer()
|
||||
panicOnErr(tx.RemoveUser(testUser))
|
||||
panicOnErr(conn.RemoveUser(testUser))
|
||||
b.StartTimer()
|
||||
}
|
||||
|
||||
func BenchmarkLeecherFinished(b *testing.B) {
|
||||
b.StopTimer()
|
||||
tx := createTestTx()
|
||||
conn := createTestConn()
|
||||
testTorrent := createTestTorrent()
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
panicOnErr(conn.AddTorrent(testTorrent))
|
||||
b.StartTimer()
|
||||
|
||||
for bCount := 0; bCount < b.N; bCount++ {
|
||||
b.StopTimer()
|
||||
testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
|
||||
panicOnErr(tx.AddLeecher(testTorrent, testLeecher))
|
||||
panicOnErr(conn.AddLeecher(testTorrent, testLeecher))
|
||||
testLeecher.Left = 0
|
||||
b.StartTimer()
|
||||
|
||||
panicOnErr(tx.LeecherFinished(testTorrent, testLeecher))
|
||||
panicOnErr(conn.LeecherFinished(testTorrent, testLeecher))
|
||||
}
|
||||
// Cleanup
|
||||
b.StopTimer()
|
||||
panicOnErr(tx.RemoveTorrent(testTorrent))
|
||||
panicOnErr(conn.RemoveTorrent(testTorrent))
|
||||
b.StartTimer()
|
||||
}
|
||||
|
||||
// This is a comparision to the Leecher finished function
|
||||
func BenchmarkRemoveLeecherAddSeeder(b *testing.B) {
|
||||
b.StopTimer()
|
||||
tx := createTestTx()
|
||||
conn := createTestConn()
|
||||
testTorrent := createTestTorrent()
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
panicOnErr(conn.AddTorrent(testTorrent))
|
||||
b.StartTimer()
|
||||
|
||||
for bCount := 0; bCount < b.N; bCount++ {
|
||||
b.StopTimer()
|
||||
testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
|
||||
panicOnErr(tx.AddLeecher(testTorrent, testLeecher))
|
||||
panicOnErr(conn.AddLeecher(testTorrent, testLeecher))
|
||||
testLeecher.Left = 0
|
||||
b.StartTimer()
|
||||
|
||||
panicOnErr(tx.RemoveLeecher(testTorrent, testLeecher))
|
||||
panicOnErr(tx.AddSeeder(testTorrent, testLeecher))
|
||||
panicOnErr(conn.RemoveLeecher(testTorrent, testLeecher))
|
||||
panicOnErr(conn.AddSeeder(testTorrent, testLeecher))
|
||||
}
|
||||
// Cleanup
|
||||
b.StopTimer()
|
||||
tx.RemoveTorrent(testTorrent)
|
||||
conn.RemoveTorrent(testTorrent)
|
||||
b.StartTimer()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -83,7 +83,7 @@ func panicOnErr(err error) {
|
|||
}
|
||||
}
|
||||
|
||||
func createTestRedisTx() *Tx {
|
||||
func createTestRedisConn() *Conn {
|
||||
testConfig, err := config.Open(os.Getenv("TESTCONFIGPATH"))
|
||||
conf := &testConfig.Cache
|
||||
panicOnErr(err)
|
||||
|
|
@ -98,7 +98,7 @@ func createTestRedisTx() *Tx {
|
|||
},
|
||||
}
|
||||
|
||||
txObj := &Tx{
|
||||
newConn := &Conn{
|
||||
conf: testPool.conf,
|
||||
done: false,
|
||||
Conn: testPool.pool.Get(),
|
||||
|
|
@ -106,9 +106,9 @@ func createTestRedisTx() *Tx {
|
|||
panicOnErr(err)
|
||||
|
||||
// Test connection before returning
|
||||
_, err = txObj.Do("PING")
|
||||
_, err = newConn.Do("PING")
|
||||
panicOnErr(err)
|
||||
return txObj
|
||||
return newConn
|
||||
}
|
||||
|
||||
func createTestUser() *storage.User {
|
||||
|
|
@ -145,39 +145,39 @@ func createTestTorrent() *storage.Torrent {
|
|||
}
|
||||
|
||||
func TestValidPeers(t *testing.T) {
|
||||
testTx := createTestRedisTx()
|
||||
testConn := createTestRedisConn()
|
||||
testTorrentID := createTestTorrentID()
|
||||
testPeers := createTestPeers(testTorrentID, 3)
|
||||
|
||||
panicOnErr(testTx.addPeers(testPeers, "test:"))
|
||||
peerMap, err := testTx.getPeers(testTorrentID, "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(testTx.removePeers(testTorrentID, testPeers, "test:"))
|
||||
panicOnErr(testConn.removePeers(testTorrentID, testPeers, "test:"))
|
||||
}
|
||||
|
||||
func TestInvalidPeers(t *testing.T) {
|
||||
testTx := createTestRedisTx()
|
||||
testConn := createTestRedisConn()
|
||||
testTorrentID := createTestTorrentID()
|
||||
testPeers := createTestPeers(testTorrentID, 3)
|
||||
tempPeer := createTestPeer(createTestUserID(), testTorrentID)
|
||||
testPeers[storage.PeerMapKey(tempPeer)] = *tempPeer
|
||||
|
||||
panicOnErr(testTx.addPeers(testPeers, "test:"))
|
||||
panicOnErr(testConn.addPeers(testPeers, "test:"))
|
||||
// Imitate a peer being removed during get
|
||||
hashKey := testTx.conf.Prefix + getPeerHashKey(tempPeer)
|
||||
_, err := testTx.Do("DEL", hashKey)
|
||||
hashKey := testConn.conf.Prefix + getPeerHashKey(tempPeer)
|
||||
_, err := testConn.Do("DEL", hashKey)
|
||||
panicOnErr(err)
|
||||
|
||||
peerMap, err := testTx.getPeers(testTorrentID, "test:")
|
||||
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(testTx.removePeers(testTorrentID, testPeers, "test:"))
|
||||
panicOnErr(testConn.removePeers(testTorrentID, testPeers, "test:"))
|
||||
if len(testPeers) != 0 {
|
||||
t.Errorf("All peers not removed, %d peers remain!", len(testPeers))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,563 +0,0 @@
|
|||
// Copyright 2013 The Chihaya Authors. All rights reserved.
|
||||
// Use of this source code is governed by the BSD 2-Clause license,
|
||||
// which can be found in the LICENSE file.
|
||||
|
||||
package redis
|
||||
|
||||
import (
|
||||
"math/rand"
|
||||
"os"
|
||||
"reflect"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/pushrax/chihaya/config"
|
||||
"github.com/pushrax/chihaya/storage"
|
||||
"github.com/pushrax/chihaya/storage/tracker"
|
||||
)
|
||||
|
||||
func createTestTx() tracker.Conn {
|
||||
testConfig, err := config.Open(os.Getenv("TESTCONFIGPATH"))
|
||||
panicOnErr(err)
|
||||
conf := &testConfig.Cache
|
||||
|
||||
testPool, err := tracker.Open(conf)
|
||||
panicOnErr(err)
|
||||
|
||||
txObj, err := testPool.Get()
|
||||
panicOnErr(err)
|
||||
|
||||
return txObj
|
||||
}
|
||||
|
||||
func TestFindUserSuccess(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testUser := createTestUser()
|
||||
|
||||
panicOnErr(tx.AddUser(testUser))
|
||||
foundUser, found, err := tx.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(tx.RemoveUser(testUser))
|
||||
}
|
||||
|
||||
func TestFindUserFail(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testUser := createTestUser()
|
||||
|
||||
foundUser, found, err := tx.FindUser(testUser.Passkey)
|
||||
panicOnErr(err)
|
||||
if found {
|
||||
t.Error("user found", foundUser)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRemoveUser(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testUser := createTestUser()
|
||||
|
||||
panicOnErr(tx.AddUser(testUser))
|
||||
err := tx.RemoveUser(testUser)
|
||||
panicOnErr(err)
|
||||
foundUser, found, err := tx.FindUser(testUser.Passkey)
|
||||
panicOnErr(err)
|
||||
if found {
|
||||
t.Error("removed user found", foundUser)
|
||||
}
|
||||
}
|
||||
|
||||
func TestFindTorrentSuccess(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testTorrent := createTestTorrent()
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
|
||||
foundTorrent, found, err := tx.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(tx.RemoveTorrent(testTorrent))
|
||||
}
|
||||
|
||||
func TestFindTorrentFail(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testTorrent := createTestTorrent()
|
||||
|
||||
foundTorrent, found, err := tx.FindTorrent(testTorrent.Infohash)
|
||||
panicOnErr(err)
|
||||
if found {
|
||||
t.Error("torrent found", foundTorrent)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRemoveTorrent(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testTorrent := createTestTorrent()
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
|
||||
panicOnErr(tx.RemoveTorrent(testTorrent))
|
||||
foundTorrent, found, err := tx.FindTorrent(testTorrent.Infohash)
|
||||
panicOnErr(err)
|
||||
if found {
|
||||
t.Error("removed torrent found", foundTorrent)
|
||||
}
|
||||
// Cleanup
|
||||
panicOnErr(tx.RemoveTorrent(testTorrent))
|
||||
}
|
||||
|
||||
func TestClientWhitelistSuccess(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testPeerID := "-lt0D30-"
|
||||
|
||||
panicOnErr(tx.WhitelistClient(testPeerID))
|
||||
found, err := tx.ClientWhitelisted(testPeerID)
|
||||
panicOnErr(err)
|
||||
if !found {
|
||||
t.Error("peerID not found", testPeerID)
|
||||
}
|
||||
// Cleanup
|
||||
panicOnErr(tx.UnWhitelistClient(testPeerID))
|
||||
}
|
||||
|
||||
func TestClientWhitelistFail(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testPeerID2 := "TIX0192"
|
||||
|
||||
found, err := tx.ClientWhitelisted(testPeerID2)
|
||||
panicOnErr(err)
|
||||
if found {
|
||||
t.Error("peerID found", testPeerID2)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRecordSnatch(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testTorrent := createTestTorrent()
|
||||
testUser := createTestUser()
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
panicOnErr(tx.AddUser(testUser))
|
||||
|
||||
userSnatches := testUser.Snatches
|
||||
torrentSnatches := testTorrent.Snatches
|
||||
|
||||
panicOnErr(tx.RecordSnatch(testUser, testTorrent))
|
||||
|
||||
foundTorrent, _, err := tx.FindTorrent(testTorrent.Infohash)
|
||||
panicOnErr(err)
|
||||
foundUser, _, err := tx.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(tx.RemoveTorrent(testTorrent))
|
||||
panicOnErr(tx.RemoveUser(testUser))
|
||||
}
|
||||
|
||||
func TestMarkActive(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testTorrent := createTestTorrent()
|
||||
testTorrent.Active = false
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
|
||||
panicOnErr(tx.MarkActive(testTorrent))
|
||||
foundTorrent, _, err := tx.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(tx.RemoveTorrent(testTorrent))
|
||||
}
|
||||
|
||||
func TestClientWhitelistRemove(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testPeerID := "-lt0D30-"
|
||||
panicOnErr(tx.WhitelistClient(testPeerID))
|
||||
panicOnErr(tx.UnWhitelistClient(testPeerID))
|
||||
|
||||
found, err := tx.ClientWhitelisted(testPeerID)
|
||||
panicOnErr(err)
|
||||
if found {
|
||||
t.Error("removed peerID found", testPeerID)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAddSeeder(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testTorrent := createTestTorrent()
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
|
||||
|
||||
panicOnErr(tx.AddSeeder(testTorrent, testSeeder))
|
||||
foundTorrent, found, err := tx.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(tx.RemoveTorrent(testTorrent))
|
||||
}
|
||||
|
||||
func TestAddLeecher(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testTorrent := createTestTorrent()
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
|
||||
|
||||
panicOnErr(tx.AddLeecher(testTorrent, testLeecher))
|
||||
foundTorrent, found, err := tx.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(tx.RemoveTorrent(testTorrent))
|
||||
}
|
||||
|
||||
func TestRemoveSeeder(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testTorrent := createTestTorrent()
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
|
||||
panicOnErr(tx.AddSeeder(testTorrent, testSeeder))
|
||||
|
||||
panicOnErr(tx.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 := tx.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(tx.RemoveTorrent(testTorrent))
|
||||
}
|
||||
|
||||
func TestRemoveLeecher(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testTorrent := createTestTorrent()
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
|
||||
panicOnErr(tx.AddLeecher(testTorrent, testLeecher))
|
||||
|
||||
panicOnErr(tx.RemoveLeecher(testTorrent, testLeecher))
|
||||
foundTorrent, found, err := tx.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(tx.RemoveTorrent(testTorrent))
|
||||
}
|
||||
|
||||
func TestSetSeeder(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testTorrent := createTestTorrent()
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
|
||||
panicOnErr(tx.AddSeeder(testTorrent, testSeeder))
|
||||
|
||||
r := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||||
testSeeder.Uploaded += uint64(r.Int63())
|
||||
|
||||
panicOnErr(tx.SetSeeder(testTorrent, testSeeder))
|
||||
|
||||
foundTorrent, _, err := tx.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(tx.RemoveTorrent(testTorrent))
|
||||
}
|
||||
|
||||
func TestSetLeecher(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testTorrent := createTestTorrent()
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
|
||||
panicOnErr(tx.AddLeecher(testTorrent, testLeecher))
|
||||
|
||||
r := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||||
testLeecher.Uploaded += uint64(r.Int63())
|
||||
|
||||
panicOnErr(tx.SetLeecher(testTorrent, testLeecher))
|
||||
foundTorrent, _, err := tx.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(tx.RemoveTorrent(testTorrent))
|
||||
}
|
||||
|
||||
func TestIncrementSlots(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testUser := createTestUser()
|
||||
panicOnErr(tx.AddUser(testUser))
|
||||
numSlots := testUser.Slots
|
||||
|
||||
panicOnErr(tx.IncrementSlots(testUser))
|
||||
foundUser, _, err := tx.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(tx.RemoveUser(testUser))
|
||||
}
|
||||
|
||||
func TestDecrementSlots(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testUser := createTestUser()
|
||||
panicOnErr(tx.AddUser(testUser))
|
||||
numSlots := testUser.Slots
|
||||
|
||||
panicOnErr(tx.DecrementSlots(testUser))
|
||||
foundUser, _, err := tx.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(tx.RemoveUser(testUser))
|
||||
}
|
||||
|
||||
func TestLeecherFinished(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testTorrent := createTestTorrent()
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
|
||||
panicOnErr(tx.AddLeecher(testTorrent, testLeecher))
|
||||
testLeecher.Left = 0
|
||||
|
||||
panicOnErr(tx.LeecherFinished(testTorrent, testLeecher))
|
||||
|
||||
foundTorrent, _, err := tx.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(tx.RemoveTorrent(testTorrent))
|
||||
}
|
||||
|
||||
// Add, update, verify remove
|
||||
func TestUpdatePeer(t *testing.T) {
|
||||
tx := createTestTx()
|
||||
testTorrent := createTestTorrent()
|
||||
testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
panicOnErr(tx.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(tx.SetSeeder(testTorrent, testSeeder))
|
||||
|
||||
panicOnErr(tx.RemoveSeeder(testTorrent, testSeeder))
|
||||
foundTorrent, _, err := tx.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(tx.RemoveTorrent(testTorrent))
|
||||
}
|
||||
|
||||
func TestParallelFindUser(t *testing.T) {
|
||||
t.Parallel()
|
||||
if testing.Short() {
|
||||
t.Skip()
|
||||
}
|
||||
tx := createTestTx()
|
||||
testUserSuccess := createTestUser()
|
||||
testUserFail := createTestUser()
|
||||
panicOnErr(tx.AddUser(testUserSuccess))
|
||||
|
||||
for i := 0; i < 10; i++ {
|
||||
foundUser, found, err := tx.FindUser(testUserFail.Passkey)
|
||||
panicOnErr(err)
|
||||
if found {
|
||||
t.Error("user found", foundUser)
|
||||
}
|
||||
foundUser, found, err = tx.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(tx.RemoveUser(testUserSuccess))
|
||||
}
|
||||
|
||||
func TestParallelFindTorrent(t *testing.T) {
|
||||
t.Parallel()
|
||||
if testing.Short() {
|
||||
t.Skip()
|
||||
}
|
||||
tx := createTestTx()
|
||||
testTorrentSuccess := createTestTorrent()
|
||||
testTorrentFail := createTestTorrent()
|
||||
panicOnErr(tx.AddTorrent(testTorrentSuccess))
|
||||
|
||||
for i := 0; i < 10; i++ {
|
||||
foundTorrent, found, err := tx.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 = tx.FindTorrent(testTorrentFail.Infohash)
|
||||
panicOnErr(err)
|
||||
if found {
|
||||
t.Error("torrent found", foundTorrent)
|
||||
}
|
||||
}
|
||||
// Cleanup
|
||||
panicOnErr(tx.RemoveTorrent(testTorrentSuccess))
|
||||
}
|
||||
|
||||
func TestParallelSetSeeder(t *testing.T) {
|
||||
t.Parallel()
|
||||
if testing.Short() {
|
||||
t.Skip()
|
||||
}
|
||||
tx := createTestTx()
|
||||
testTorrent := createTestTorrent()
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
testSeeder := createTestPeer(createTestUserID(), testTorrent.ID)
|
||||
panicOnErr(tx.AddSeeder(testTorrent, testSeeder))
|
||||
r := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||||
|
||||
for i := 0; i < 10; i++ {
|
||||
testSeeder.Uploaded += uint64(r.Int63())
|
||||
|
||||
panicOnErr(tx.SetSeeder(testTorrent, testSeeder))
|
||||
|
||||
foundTorrent, _, err := tx.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(tx.RemoveTorrent(testTorrent))
|
||||
}
|
||||
|
||||
func TestParallelAddLeecher(t *testing.T) {
|
||||
t.Parallel()
|
||||
if testing.Short() {
|
||||
t.Skip()
|
||||
}
|
||||
tx := createTestTx()
|
||||
testTorrent := createTestTorrent()
|
||||
panicOnErr(tx.AddTorrent(testTorrent))
|
||||
|
||||
for i := 0; i < 10; i++ {
|
||||
testLeecher := createTestPeer(createTestUserID(), testTorrent.ID)
|
||||
|
||||
panicOnErr(tx.AddLeecher(testTorrent, testLeecher))
|
||||
|
||||
foundTorrent, found, err := tx.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(tx.RemoveTorrent(testTorrent))
|
||||
}
|
||||
Loading…
Add table
Reference in a new issue