LBRYCommunity/tracker
1
0
Fork 0
Code Issues 1 Pull requests Packages Projects Releases Wiki Activity

removed all references to "transaction"

Browse source
This commit is contained in:
Jimmy Zelinskie 2013-11-23 23:48:38 -05:00
parent 31e618c8d9
commit 9382ac482e
10 changed files with 1698 additions and 1708 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
config/config.go
View file

@ -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.

4
config/example.json
View file

@ -30,8 +30,6 @@
"announce": "30m",
"min_announce": "15m",
"read_timeout": "20s",
"default_num_want": 50,
"tx_retries": 3
"default_num_want": 50
}

44
server/announce.go
View file

@ -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) {

10
server/scrape.go
View file

@ -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)
}

4
server/server.go
View file

@ -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
View 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))
}

208
storage/tracker/redis/redis.go
View file

@ -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
}

114
storage/tracker/redis/redis_bench_test.go
View file

@ -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()
}

28
storage/tracker/redis/redis_test.go
View file

@ -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))
}

563
storage/tracker/redis/tx_test.go
View file

@ -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))
}