refactor: package

This commit is contained in:
liwei committed 2021-03-25 19:38:23 +08:00
1 parent 359f28bb1f
commit ede6a9834d
55 files changed
+279 -237

No files matched your search

+74
View File
@@ -0,0 +1,74 @@
package main
import (
"github.com/monkeyWie/gopeed-core/pkg/protocol/bt/metainfo"
"github.com/monkeyWie/gopeed-core/pkg/protocol/bt/peer"
"github.com/monkeyWie/gopeed-core/pkg/protocol/bt/torrent"
log "github.com/sirupsen/logrus"
)
func main() {
log.SetLevel(log.DebugLevel)
torrent := buildTorrent()
torrent.Download("e:/testbt/download")
}
func buildTorrent() *torrent.Torrent {
// metaInfo, err := metainfo.ParseFromFile("../testdata/Game.of.Thrones.S08E05.720p.WEB.H264-MEMENTO.torrent")
metaInfo, err := metainfo.ParseFromFile("../../testdata/office.torrent")
if err != nil {
panic(err)
}
metaInfo.AnnounceList[0] = append(metaInfo.AnnounceList[0], []string{
"udp://tracker.coppersurfer.tk:6969/announce",
"udp://tracker.leechers-paradise.org:6969/announce",
"udp://tracker.opentrackr.org:1337/announce",
"udp://p4p.arenabg.com:1337/announce",
"udp://9.rarbg.to:2710/announce",
"udp://9.rarbg.me:2710/announce",
"udp://tracker.internetwarriors.net:1337/announce",
"udp://exodus.desync.com:6969/announce",
"udp://tracker.tiny-vps.com:6969/announce",
"udp://tracker.sbsub.com:2710/announce",
"udp://retracker.lanta-net.ru:2710/announce",
"udp://open.stealth.si:80/announce",
"udp://open.demonii.si:1337/announce",
"udp://tracker.torrent.eu.org:451/announce",
"udp://tracker.moeking.me:6969/announce",
"udp://tracker.cyberia.is:6969/announce",
"udp://denis.stalker.upeer.me:6969/announce",
"udp://ipv4.tracker.harry.lu:80/announce",
"udp://explodie.org:6969/announce",
"udp://zephir.monocul.us:6969/announce",
"udp://xxxtor.com:2710/announce",
"udp://valakas.rollo.dnsabr.com:2710/announce",
"udp://tracker.zerobytes.xyz:1337/announce",
"udp://tracker.yoshi210.com:6969/announce",
"udp://tracker.uw0.xyz:6969/announce",
"udp://tracker.swateam.org.uk:2710/announce",
"udp://tracker.nyaa.uk:6969/announce",
"udp://tracker.filemail.com:6969/announce",
"udp://tracker.ds.is:6969/announce",
"udp://retracker.sevstar.net:2710/announce",
"udp://retracker.netbynet.ru:2710/announce",
"udp://retracker.akado-ural.ru:80/announce",
"udp://opentracker.i2p.rocks:6969/announce",
"udp://opentor.org:2710/announce",
"udp://open.nyap2p.com:6969/announce",
"udp://chihaya.toss.li:9696/announce",
"udp://bt2.archive.org:6969/announce",
"udp://bt1.archive.org:6969/announce",
"udp://www.loushao.net:8080/announce",
"udp://tracker4.itzmx.com:2710/announce",
"udp://tracker3.itzmx.com:6961/announce",
"udp://tracker2.itzmx.com:6961/announce",
"udp://tracker.lelux.fi:6969/announce",
"udp://tracker.kamigami.org:2710/announce",
"udp://tracker.dler.org:6969/announce",
"udp://tr.bangumi.moe:6969/announce",
"udp://qg.lorzl.gq:2710/announce",
"udp://bt2.54new.com:8080/announce",
}...)
return torrent.NewTorrent(peer.GenPeerID(), metaInfo)
}
+464
View File
@@ -0,0 +1,464 @@
package torrent
import (
"bufio"
"crypto/sha1"
"encoding/binary"
"errors"
"fmt"
"github.com/RoaringBitmap/roaring"
"io"
"net"
"os"
"path"
"path/filepath"
"time"
"github.com/cenkalti/mse"
"github.com/monkeyWie/gopeed-core/pkg/protocol/bt/metainfo"
"github.com/monkeyWie/gopeed-core/pkg/protocol/bt/peer"
"github.com/monkeyWie/gopeed-core/pkg/protocol/bt/peer/message"
log "github.com/sirupsen/logrus"
)
// 现在主流客户端的block大小都是16KB
const blockSize = 2 << 13
const keepaliveTimeout = 60 * 2
var errPieceCheckFailed = errors.New("piece check failed")
var keepaliveData = make([]byte, 4)
type peerConn struct {
torrent *Torrent
peer *peer.Peer
conn net.Conn
// this client is choking the peer
amChoking bool
// this client is interested in the peer
amInterested bool
// peer is choking this client
peerChoking bool
// peer is interested in this client
peerInterested bool
// 上一次收到包的时间
lastReciveTime int64
bitfield *message.Bitfield
readyEnd bool
downloadedCh chan error
disconnectCh chan error
// block下载队列,官方推荐为5
blockQueueCh chan interface{}
}
func newPeerConn(torrent *Torrent, peer *peer.Peer) *peerConn {
return &peerConn{
torrent: torrent,
peer: peer,
}
}
// 使用MSE加密来避免运营商对bt流量的封锁,基本上现在市面上BT客户端都默认开启了,不用MSE的话很多Peer拒绝连接
// see http://wiki.vuze.com/w/Message_Stream_Encryption
func (pc *peerConn) dialMse() error {
conn, err := net.DialTimeout("tcp", pc.peer.Address(), time.Second*time.Duration(30))
if err != nil {
return err
}
mseConn := mse.WrapConn(conn)
infoHash := pc.torrent.MetaInfo.GetInfoHash()
_, err = mseConn.HandshakeOutgoing(infoHash[:], mse.PlainText, nil)
if err != nil {
mseConn.Close()
return err
}
pc.conn = mseConn
return nil
}
// Handshake of Peer wire protocol
// see https://wiki.theory.org/index.php/BitTorrentSpecification#Handshake
func (pc *peerConn) handshake() (*peer.Handshake, error) {
handshakeRes, err := func() (*peer.Handshake, error) {
handshakeReq := peer.NewHandshake([8]byte{}, pc.torrent.MetaInfo.GetInfoHash(), pc.torrent.PeerID)
_, err := pc.conn.Write(handshakeReq.Encode())
if err != nil {
return nil, err
}
var read [68]byte
_, err = io.ReadFull(pc.conn, read[:])
if err != nil {
return nil, err
}
handshakeRes := &peer.Handshake{}
err = handshakeRes.Decode(read[:])
if err != nil {
return nil, err
}
// InfoHash不匹配
if handshakeRes.InfoHash != handshakeReq.InfoHash {
return nil, fmt.Errorf("info_hash not currently serving")
}
return handshakeRes, nil
}()
if err != nil {
pc.conn.Close()
return nil, err
}
// init state
pc.amChoking = true
pc.amInterested = false
pc.peerChoking = true
pc.peerInterested = false
return handshakeRes, nil
}
func (pc *peerConn) handleKeepalive() {
pc.lastReciveTime = time.Now().Unix()
for {
time.Sleep(time.Minute * 2)
// 如果超过两分钟没有响应,则断开连接
if time.Now().Unix()-pc.lastReciveTime > keepaliveTimeout {
pc.conn.Close()
break
}
// 两分钟发送一次心跳包
_, err := pc.conn.Write(keepaliveData)
if err != nil {
pc.conn.Close()
break
}
}
}
// 准备下载
func (pc *peerConn) ready() error {
if err := pc.dialMse(); err != nil {
return fmt.Errorf("tcp dial error %w", err)
}
if _, err := pc.handshake(); err != nil {
return fmt.Errorf("handshake error %w", err)
}
pc.readyEnd = false
readyCh := make(chan bool)
pc.disconnectCh = make(chan error)
go pc.handleKeepalive()
go func() {
scanner := bufio.NewScanner(pc.conn)
scanner.Split(message.SplitMessage)
for scanner.Scan() {
pc.lastReciveTime = time.Now().Unix()
buf := scanner.Bytes()
length := binary.BigEndian.Uint32(buf[:4])
if length == 0 {
// keepalive
} else {
switch message.ID(buf[4]) {
case message.IdChoke:
break
case message.IdUnchoke:
pc.handleUnchoke(readyCh)
break
case message.IdInterested:
break
case message.IdNotInterested:
break
case message.IdHave:
break
case message.IdBitfield:
pc.handleBitfield(buf)
break
case message.IdRequest:
break
case message.IdPiece:
pc.handlePiece(buf)
break
case message.IdCancel:
break
}
}
}
// 还未下载完成时连接断开
err := scanner.Err()
if err == nil {
err = io.EOF
}
pc.disconnectCh <- err
close(pc.disconnectCh)
}()
err := func() error {
select {
case status := <-readyCh:
if status {
return nil
}
return errors.New("ready fail")
case <-time.After(time.Second * 30):
// 30秒之后超时
return errors.New("ready time out")
}
}()
if err != nil {
pc.conn.Close()
return err
}
return nil
}
// 下载指定piece
func (pc *peerConn) downloadPiece(index int) (err error) {
pieceLength := pc.torrent.MetaInfo.GetPieceLength(index)
pc.downloadedCh = make(chan error)
pc.blockQueueCh = make(chan interface{}, 5)
defer close(pc.blockQueueCh)
// 按块下载分片
blockCount := pc.torrent.pieceStates.states[index].blockCount
for i := 0; i < blockCount; i++ {
offset := blockSize * i
// 如果已经下载过就跳过
if pc.torrent.pieceStates.isBlockDone(index, offset) {
continue
}
var blockLength uint32
if i == blockCount-1 {
// 最后一个block大小需要计算出来
blockLength = uint32(pieceLength - offset)
} else {
blockLength = blockSize
}
// block下载排队
select {
case pc.blockQueueCh <- nil:
break
case err = <-pc.downloadedCh:
break
case err = <-pc.disconnectCh:
break
}
// 如果连接出现问题或下载失败直接返回异常
if err != nil {
pc.conn.Close()
return
}
// 发起request,对方会响应piece
_, err = pc.conn.Write(message.BuildRequest(uint32(index), uint32(offset), blockLength).Encode())
if err != nil {
break
}
}
select {
case err = <-pc.downloadedCh:
break
case err = <-pc.disconnectCh:
break
}
if err != nil {
pc.conn.Close()
}
return
}
func (pc *peerConn) handleUnchoke(readyCh chan<- bool) {
pc.peerChoking = false
// 已经处理过Unchoke信号
if pc.readyEnd {
return
}
pc.readyEnd = true
// 如果客户端对peer感兴趣并且peer没有choked客户端,就可以开始下载了
if pc.amInterested {
readyCh <- true
} else {
readyCh <- false
}
close(readyCh)
}
func (pc *peerConn) handleBitfield(buf []byte) {
pc.bitfield = message.NewBitfield()
pc.bitfield.Decode(buf)
have := pc.getHavePieces(pc.bitfield)
if len(have) > 0 {
// 表示对该peer感兴趣,并且不choked该peer
pc.conn.Write(message.NewInterested().Encode())
pc.amInterested = true
pc.conn.Write(message.NewUnchoke().Encode())
pc.amChoking = false
} else {
pc.conn.Close()
}
}
// 处理下载响应,每次接收到响应直接将block写入到对应文件中
func (pc *peerConn) handlePiece(buf []byte) {
piece := message.NewPiece()
piece.Decode(buf)
info := pc.torrent.MetaInfo.Info
fds := pc.torrent.MetaInfo.GetFileDetails()
blockLength := int64(len(piece.Block))
pieceBegin := int64(piece.Index) * int64(info.PieceLength)
blockBegin := pieceBegin + int64(piece.Begin)
// 计算block对应要写到的文件偏移
var fileBlocks []*fileBlock
if len(info.Files) == 0 {
// 单文件
fileBlocks = append(fileBlocks, &fileBlock{
filepath: info.Name,
fileSeek: blockBegin,
blockBegin: 0,
blockEnd: blockLength,
})
} else {
// 获取要写入的第一个文件和偏移
writeIndex := getWriteFile(blockBegin, fds)
// block对应种子的偏移
blockFileBegin := blockBegin
// block对应文件的偏移
var blockSeek int64 = 0
for _, f := range fds[writeIndex:] {
// 计算文件可剩余写入字节数
fileWritable := f.End - blockFileBegin
// 计算block剩余写入字节数
blockWritable := blockLength - blockSeek
fb := &fileBlock{
filepath: filepath.Join(f.Path...),
fileSeek: blockFileBegin - f.Begin,
blockBegin: blockSeek,
}
if fileWritable >= blockWritable {
// 若够block写入直接跳出循环
fb.blockEnd = blockSeek + blockWritable
fileBlocks = append(fileBlocks, fb)
break
} else {
// 否则计算剩余可写字节数,写入到下一个文件中
fb.blockEnd = blockSeek + fileWritable
fileBlocks = append(fileBlocks, fb)
blockFileBegin = f.End
blockSeek += fileWritable
}
}
}
// 开始写入文件
for _, f := range fileBlocks {
err := func() error {
name := filepath.Join(pc.torrent.Path, f.filepath)
file, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE, 0644)
if err != nil {
return err
}
defer file.Close()
_, err = file.WriteAt(piece.Block[f.blockBegin:f.blockEnd], f.fileSeek)
if err != nil {
return err
}
return nil
}()
if err != nil {
pc.downloadedCh <- errPieceCheckFailed
pc.conn.Close()
return
}
}
pc.torrent.pieceStates.setBlockDone(int(piece.Index), int(piece.Begin))
// 出队
<-pc.blockQueueCh
log.Debugf("piece:%d block:%d", piece.Index, piece.Begin)
// piece全部下载完
if pc.torrent.pieceStates.isPieceDone(int(piece.Index)) {
// 计算piece对应的文件偏移
sha1 := sha1.New()
pieceLength := pc.torrent.MetaInfo.GetPieceLength(int(piece.Index))
writeIndex := getWriteFile(pieceBegin, fds)
fileBegin := pieceBegin - fds[writeIndex].Begin
for _, fd := range fds[writeIndex:] {
func() {
file, err := os.Open(path.Join(pc.torrent.Path, fd.Path[0]))
if err != nil {
panic(err)
}
defer file.Close()
_, err = file.Seek(fileBegin, 0)
if err != nil {
panic(err)
}
written, err := io.CopyN(sha1, file, int64(pieceLength))
if err != nil {
if err != io.EOF {
panic(err)
}
}
pieceLength -= int(written)
}()
if pieceLength > 0 {
// 继续读下个文件
fileBegin = 0
} else {
break
}
}
// 断开连接 TODO 用连接池进行复用
pc.conn.Close()
// 校验piece SHA-1 hash
downHash := [20]byte{}
copy(downHash[:], sha1.Sum(nil))
if downHash == pc.torrent.MetaInfo.Info.Pieces[piece.Index] {
// piece下载完成
pc.downloadedCh <- nil
} else {
pc.downloadedCh <- errPieceCheckFailed
}
close(pc.downloadedCh)
}
}
// 获取piece对应要写入的文件
// TODO 使用sort.Search二分查找法检索
func getWriteFile(pieceBegin int64, fds []*metainfo.FileDetail) int {
for i, f := range fds {
if f.Begin <= pieceBegin && f.End > pieceBegin {
return i
}
}
return -1
}
type fileBlock struct {
filepath string
fileSeek int64
blockBegin int64
blockEnd int64
}
// 获取peer能提供需要下载的文件分片
func (pc *peerConn) getHavePieces(bitfield *message.Bitfield) []uint32 {
had := roaring.New()
for i := 0; i < pc.torrent.pieceStates.size(); i++ {
if pc.torrent.pieceStates.getState(i) == stateFinish {
had.AddInt(i)
}
}
return bitfield.Provide(had)
}
// 获取要写入到的文件
/*func (ps *peerConn) getWriteFile(request *message.Request) string {
info := ps.torrent.MetaInfo.Info
// 单文件
if len(info.Files) == 0 {
return info.Name
} else {
request.Index * info.PieceLength + be
for i := 0; i < len(info.Files); i++ {
}
}
}
*/
+122
View File
@@ -0,0 +1,122 @@
package torrent
import (
"fmt"
"github.com/monkeyWie/gopeed-core/pkg/protocol/bt/peer"
"github.com/monkeyWie/gopeed-core/pkg/protocol/bt/tracker"
"os"
"sync"
"testing"
"time"
)
func Test_peerState_ready(t *testing.T) {
ps := getUsablePeer()
fmt.Println("get a peer")
// 下载前准备
err := ps.ready()
fmt.Println("ready end")
if err != nil {
fmt.Println(ps.peer.Address())
t.Fatal(err)
}
}
func Test_peerState_downloadPiece(t *testing.T) {
ps := getUsablePeer()
fmt.Println("get a peer")
// 下载前准备
err := ps.ready()
if err != nil {
t.Fatal(err)
}
have := ps.getHavePieces(ps.bitfield)
fmt.Printf("download is ready,have %d\n", len(have))
if len(have) > 0 {
// 获取分片的长度
for _, index := range have {
fmt.Printf("download index %d\n", index)
ps.downloadPiece(int(index))
}
return
}
}
// 获取一个能连接上的peer
func getUsablePeer() *peerConn {
ch := getUsablePeerMore()
ps := <-ch
return ps
}
// 获取多个能连接上的peer
func getUsablePeerMore() chan *peerConn {
torrent := buildTorrent()
tracker := &tracker.Tracker{
PeerID: torrent.PeerID,
MetaInfo: torrent.MetaInfo,
}
peers := <-tracker.Tracker()
ch := make(chan *peerConn)
for i := range peers {
go peerTest(torrent, peers[i], ch)
}
return ch
}
func peerTest(torrent *Torrent, peer *peer.Peer, ch chan *peerConn) {
ps := &peerConn{
torrent: torrent,
peer: peer,
}
// 连接至peer
err := ps.ready()
if err != nil {
return
}
ps.conn.Close()
ch <- ps
}
func TestSome(t *testing.T) {
ch := make(chan interface{})
go func() {
time.Sleep(time.Second)
select {
case ch <- nil:
fmt.Println("write")
case <-time.After(time.Second * 3):
fmt.Println("timeout")
}
}()
time.Sleep(time.Second * 5)
r := <-ch
fmt.Println(r)
fmt.Println("111")
}
func TestSome2(t *testing.T) {
wg := sync.WaitGroup{}
wg.Add(10)
file, err := os.OpenFile("e:/testbt/test.data", os.O_RDWR|os.O_CREATE, 0644)
for i := 0; i < 10; i++ {
go func(i int) {
for j := 0; j < 100; j++ {
if err != nil {
panic(err)
}
_, err = file.WriteAt([]byte{byte(i)}, int64(i*8))
}
wg.Done()
}(i)
}
wg.Wait()
}
+99
View File
@@ -0,0 +1,99 @@
package torrent
import (
"sync"
"time"
"github.com/monkeyWie/gopeed-core/pkg/protocol/bt/peer"
"github.com/monkeyWie/gopeed-core/pkg/protocol/bt/tracker"
)
type peerPool struct {
torrent *Torrent
states map[*peer.Peer]*peerState
lock *sync.Mutex
}
type peerState struct {
// 是否在被使用
using bool
// 下载失败次数
errors int
}
func newPeerPool(torrent *Torrent) *peerPool {
return &peerPool{
torrent: torrent,
lock: &sync.Mutex{},
states: map[*peer.Peer]*peerState{},
}
}
func (pp *peerPool) fetch() {
tracker := &tracker.Tracker{
PeerID: pp.torrent.PeerID,
MetaInfo: pp.torrent.MetaInfo,
}
go func() {
for {
// 当peer数量少于200个时重新发起一次tracker
if len(pp.states) < 200 {
go func() {
for peers := range tracker.Tracker() {
pp.put(peers)
}
}()
}
// 每2分钟检测一次
time.Sleep(time.Minute * 2)
}
}()
}
func (pp *peerPool) put(peers []*peer.Peer) {
pp.lock.Lock()
defer pp.lock.Unlock()
for _, peer := range peers {
if _, ok := pp.states[peer]; !ok {
pp.states[peer] = &peerState{
using: false,
errors: 0,
}
}
}
}
func (pp *peerPool) get() *peer.Peer {
pp.lock.Lock()
defer pp.lock.Unlock()
for peer, state := range pp.states {
if !state.using {
state.using = true
return peer
}
}
return nil
}
// 将peer重新放回池中,等待使用
func (pp *peerPool) release(peer *peer.Peer) {
pp.lock.Lock()
defer pp.lock.Unlock()
pp.states[peer].using = false
pp.states[peer].errors = 0
}
// 标记peer为不可用,超过3次则剔除该peer
func (pp *peerPool) unavailable(peer *peer.Peer) {
pp.lock.Lock()
defer pp.lock.Unlock()
pp.states[peer].using = false
pp.states[peer].errors++
if pp.states[peer].errors > 3 {
delete(pp.states, peer)
}
}
+109
View File
@@ -0,0 +1,109 @@
package torrent
import (
"github.com/monkeyWie/gopeed-core/pkg/protocol/bt/metainfo"
"math"
"sync"
"github.com/RoaringBitmap/roaring"
)
type state int
const (
stateReady = iota
stateDownloading
stateFinish
)
// 所有piece的下载状态
type pieceStates struct {
lock *sync.RWMutex
// 所有piece的block下载进度
states map[int]*pieceState
}
type pieceState struct {
state state
// piece中block的个数
blockCount int
// piece中block的下载记录
blockRecord *roaring.Bitmap
}
func newPiecesState(meta *metainfo.MetaInfo) *pieceStates {
pieceCount := len(meta.Info.Pieces)
ps := &pieceStates{
lock: &sync.RWMutex{},
states: make(map[int]*pieceState, pieceCount),
}
for i := 0; i < pieceCount; i++ {
ps.states[i] = &pieceState{
state: stateReady,
blockCount: int(math.Ceil(float64(meta.GetPieceLength(i)) / blockSize)),
blockRecord: roaring.New(),
}
}
return ps
}
func (ps *pieceStates) getState(index int) state {
ps.lock.RLock()
defer ps.lock.RUnlock()
return ps.states[index].state
}
func (ps *pieceStates) setState(index int, state state) {
ps.lock.Lock()
defer ps.lock.Unlock()
ps.states[index].state = state
}
func (ps *pieceStates) size() int {
return len(ps.states)
}
func (ps *pieceStates) getLeft() int {
ps.lock.RLock()
defer ps.lock.RUnlock()
count := 0
for _, v := range ps.states {
if v.state == stateReady || v.state == stateDownloading {
count++
}
}
return count
}
func (ps *pieceStates) isDone() bool {
ps.lock.RLock()
defer ps.lock.RUnlock()
for _, v := range ps.states {
if v.state == stateReady || v.state == stateDownloading {
return false
}
}
return true
}
func (ps *pieceStates) isPieceDone(index int) bool {
ps.lock.RLock()
defer ps.lock.RUnlock()
state := ps.states[index]
return uint64(state.blockCount) == state.blockRecord.GetCardinality()
}
// 指定piece下的某个block是否下载完成
func (ps *pieceStates) isBlockDone(pieceIndex int, blockIndex int) bool {
return ps.states[pieceIndex].blockRecord.ContainsInt(blockIndex)
}
// 指定piece下的某个block下载完成
func (ps *pieceStates) setBlockDone(pieceIndex int, blockIndex int) {
ps.states[pieceIndex].blockRecord.AddInt(blockIndex)
}
// 清空指定piece下所有的block下载记录
func (ps *pieceStates) clearBlocks(index int) {
ps.states[index].blockRecord.Clear()
}
+83
View File
@@ -0,0 +1,83 @@
package torrent
import (
"errors"
"time"
"github.com/monkeyWie/gopeed-core/pkg/protocol/bt/metainfo"
log "github.com/sirupsen/logrus"
)
type Torrent struct {
PeerID [20]byte
MetaInfo *metainfo.MetaInfo
pieceStates *pieceStates
peerPool *peerPool
Path string
}
func NewTorrent(peerID [20]byte, metaInfo *metainfo.MetaInfo) *Torrent {
torrent := &Torrent{
PeerID: peerID,
MetaInfo: metaInfo,
pieceStates: newPiecesState(metaInfo),
}
return torrent
}
func (t *Torrent) Download(path string) {
t.Path = path
t.peerPool = newPeerPool(t)
t.peerPool.fetch()
pieceQueueCh := make(chan interface{}, 128)
defer close(pieceQueueCh)
downloadedCh := make(chan interface{})
defer close(downloadedCh)
for i := 0; i < len(t.MetaInfo.Info.Pieces); i++ {
// 加入下载队列
pieceQueueCh <- nil
go func(index int) {
t.pieceStates.setState(index, stateDownloading)
// 一直下载到成功
for {
peer := t.peerPool.get()
if peer == nil {
time.Sleep(time.Second * 10)
continue
}
pc := newPeerConn(t, peer)
err := pc.ready()
if err != nil {
t.peerPool.unavailable(peer)
} else {
err = pc.downloadPiece(index)
if err != nil {
log.Debugf("piece %d download fail:%s", index, err.Error())
// 下载失败
t.peerPool.unavailable(peer)
if errors.Is(err, errPieceCheckFailed) {
// piece校验失败,需要重新下载过一遍,清空block记录
t.pieceStates.clearBlocks(index)
}
continue
} else {
// 下载完成
t.pieceStates.setState(index, stateFinish)
t.peerPool.release(peer)
log.Debugf("piece %d download success,total:%d,left:%d", index, t.pieceStates.size(), t.pieceStates.getLeft())
if t.pieceStates.isDone() {
downloadedCh <- nil
}
break
}
}
}
<-pieceQueueCh
}(i)
}
<-downloadedCh
log.Debug("download end")
}
+77
View File
@@ -0,0 +1,77 @@
package torrent
import (
"github.com/monkeyWie/gopeed-core/pkg/protocol/bt/metainfo"
"github.com/monkeyWie/gopeed-core/pkg/protocol/bt/peer"
log "github.com/sirupsen/logrus"
"testing"
)
func init() {
log.SetLevel(log.DebugLevel)
}
func TestTorrent_Download(t *testing.T) {
torrent := buildTorrent()
torrent.Download("e:/testbt/download")
}
func buildTorrent() *Torrent {
// metaInfo, err := metainfo.ParseFromFile("../testdata/Game.of.Thrones.S08E05.720p.WEB.H264-MEMENTO.torrent")
metaInfo, err := metainfo.ParseFromFile("../testdata/office.torrent")
if err != nil {
panic(err)
}
metaInfo.AnnounceList[0] = append(metaInfo.AnnounceList[0], []string{
"udp://tracker.coppersurfer.tk:6969/announce",
"udp://tracker.leechers-paradise.org:6969/announce",
"udp://tracker.opentrackr.org:1337/announce",
"udp://p4p.arenabg.com:1337/announce",
"udp://9.rarbg.to:2710/announce",
"udp://9.rarbg.me:2710/announce",
"udp://tracker.internetwarriors.net:1337/announce",
"udp://exodus.desync.com:6969/announce",
"udp://tracker.tiny-vps.com:6969/announce",
"udp://tracker.sbsub.com:2710/announce",
"udp://retracker.lanta-net.ru:2710/announce",
"udp://open.stealth.si:80/announce",
"udp://open.demonii.si:1337/announce",
"udp://tracker.torrent.eu.org:451/announce",
"udp://tracker.moeking.me:6969/announce",
"udp://tracker.cyberia.is:6969/announce",
"udp://denis.stalker.upeer.me:6969/announce",
"udp://ipv4.tracker.harry.lu:80/announce",
"udp://explodie.org:6969/announce",
"udp://zephir.monocul.us:6969/announce",
"udp://xxxtor.com:2710/announce",
"udp://valakas.rollo.dnsabr.com:2710/announce",
"udp://tracker.zerobytes.xyz:1337/announce",
"udp://tracker.yoshi210.com:6969/announce",
"udp://tracker.uw0.xyz:6969/announce",
"udp://tracker.swateam.org.uk:2710/announce",
"udp://tracker.nyaa.uk:6969/announce",
"udp://tracker.filemail.com:6969/announce",
"udp://tracker.ds.is:6969/announce",
"udp://retracker.sevstar.net:2710/announce",
"udp://retracker.netbynet.ru:2710/announce",
"udp://retracker.akado-ural.ru:80/announce",
"udp://opentracker.i2p.rocks:6969/announce",
"udp://opentor.org:2710/announce",
"udp://open.nyap2p.com:6969/announce",
"udp://chihaya.toss.li:9696/announce",
"udp://bt2.archive.org:6969/announce",
"udp://bt1.archive.org:6969/announce",
"udp://www.loushao.net:8080/announce",
"udp://tracker4.itzmx.com:2710/announce",
"udp://tracker3.itzmx.com:6961/announce",
"udp://tracker2.itzmx.com:6961/announce",
"udp://tracker.lelux.fi:6969/announce",
"udp://tracker.kamigami.org:2710/announce",
"udp://tracker.dler.org:6969/announce",
"udp://tr.bangumi.moe:6969/announce",
"udp://qg.lorzl.gq:2710/announce",
"udp://bt2.54new.com:8080/announce",
}...)
return NewTorrent(peer.GenPeerID(), metaInfo)
}