// Scrape scrapes using UDP format
func (u UDPTracker) Scrape(files []data.FileRecord) []byte {
// Iterate all files, grabbing their statistics
stats := make([]udp.ScrapeStats, 0)
for _, file := range files {
stat := udp.ScrapeStats{}
// Seeders
stat.Seeders = uint32(file.Seeders())
// Completed
stat.Completed = uint32(file.Completed())
// Leechers
stat.Leechers = uint32(file.Leechers())
// Append to slice
stats = append(stats[:], stat)
}
// Create UDP scrape response
scrape := udp.ScrapeResponse{
Action: 2,
TransID: u.TransID,
FileStats: stats,
}
// Convert to UDP byte buffer
buf, err := scrape.MarshalBinary()
if err != nil {
log.Println(err.Error())
return u.Error("Could not create UDP scrape response")
}
return buf
}
// TestUDPTrackerScrape verifies that the UDP tracker scrape format is correct
func TestUDPTrackerScrape(t *testing.T) {
log.Println("TestUDPTrackerScrape()")
// Generate mock data.FileRecord
file := data.FileRecord{
InfoHash: "6465616462656566",
Verified: true,
}
// Save mock file
if !file.Save() {
t.Fatalf("Failed to save mock file")
}
// Store file in slice
files := make([]data.FileRecord, 0)
files = append(files[:], file)
// Create a UDP tracker, trigger a scrape
tracker := UDPTracker{TransID: uint32(1234)}
res := tracker.Scrape(files)
// Decode response
scrape := new(udp.ScrapeResponse)
err := scrape.UnmarshalBinary(res)
if err != nil {
t.Fatalf("Failed to decode UDP scrape response")
}
log.Println(scrape)
// Verify correct action
if scrape.Action != 2 {
t.Fatalf("Incorrect UDP action, expected 2")
}
// Encode response, verify same as before
scrapeBuf, err := scrape.MarshalBinary()
if err != nil {
t.Fatalf("Failed to encode UDP scrape response")
}
if !bytes.Equal(res, scrapeBuf) {
t.Fatalf("Byte slices are not identical")
}
// Delete mock file
if !file.Delete() {
t.Fatalf("Failed to delete mock file")
}
}
// Scrape scrapes using UDP format
func (u UDPTracker) Scrape(files []data.FileRecord) []byte {
// Buffered channel to receive UDP scrape stats structs
resChan := make(chan *orderedScrape, len(files))
// Assign index to each file to preserve order during concurrent operations
index := 0
// Iterate all files in parallel
for _, f := range files {
// Create orderedScrape, assign index to ensure correct return order during concurrent operations
o := orderedScrape{
Index: index,
File: udp.ScrapeStats{},
}
index++
go func(f data.FileRecord, o *orderedScrape) {
// Seeders count
var err error
seeders, err := f.Seeders()
if err != nil {
log.Println(err.Error())
}
o.File.Seeders = uint32(seeders)
// Completion count
completed, err := f.Completed()
if err != nil {
log.Println(err.Error())
}
o.File.Completed = uint32(completed)
// Leechers count
leechers, err := f.Leechers()
if err != nil {
log.Println(err.Error())
}
o.File.Leechers = uint32(leechers)
// Return results on channel
resChan <- o
}(f, &o)
}
// Fetch all results from channel
received := 0
stats := make([]udp.ScrapeStats, len(files), len(files))
for o := range resChan {
stats[o.Index] = o.File
received++
// Once all file stats are received, break loop
if received == len(files) {
break
}
}
// Close response channel
close(resChan)
// Create UDP scrape response
scrape := udp.ScrapeResponse{
Action: 2,
TransID: u.TransID,
FileStats: stats,
}
// Convert to UDP byte buffer
buf, err := scrape.MarshalBinary()
if err != nil {
log.Println(err.Error())
return u.Error(ErrScrapeFailure.Error())
}
return buf
}
