reader.go

   1 package torrent
   2
   3 import (
   4         "errors"
   5         "io"
   6         "os"
   7 )
   8
   9 // Accesses torrent data via a client.
  10 type Reader struct {
  11         t          *Torrent
  12         pos        int64
  13         responsive bool
  14         readahead  int64
  15 }
  16
  17 var _ io.ReadCloser = &Reader{}
  18
  19 // Don't wait for pieces to complete and be verified. Read calls return as
  20 // soon as they can when the underlying chunks become available.
  21 func (r *Reader) SetResponsive() {
  22         r.responsive = true
  23 }
  24
  25 // Configure the number of bytes ahead of a read that should also be
  26 // prioritized in preparation for further reads.
  27 func (r *Reader) SetReadahead(readahead int64) {
  28         r.readahead = readahead
  29 }
  30
  31 func (r *Reader) raisePriorities(off int64, n int) {
  32         if r.responsive {
  33                 r.t.cl.addUrgentRequests(r.t.torrent, off, n)
  34         }
  35         if !r.responsive || r.readahead != 0 {
  36                 r.t.cl.readRaisePiecePriorities(r.t.torrent, off, int64(n)+r.readahead)
  37         }
  38 }
  39
  40 func (r *Reader) readable(off int64) (ret bool) {
  41         // log.Println("readable", off)
  42         // defer func() {
  43         //      log.Println("readable", ret)
  44         // }()
  45         req, ok := r.t.offsetRequest(off)
  46         if !ok {
  47                 panic(off)
  48         }
  49         if r.responsive {
  50                 return r.t.haveChunk(req)
  51         }
  52         return r.t.pieceComplete(int(req.Index))
  53 }
  54
  55 // How many bytes are available to read. Max is the most we could require.
  56 func (r *Reader) available(off, max int64) (ret int64) {
  57         for max > 0 {
  58                 req, ok := r.t.offsetRequest(off)
  59                 if !ok {
  60                         break
  61                 }
  62                 if !r.t.haveChunk(req) {
  63                         break
  64                 }
  65                 len1 := int64(req.Length) - (off - r.t.requestOffset(req))
  66                 max -= len1
  67                 ret += len1
  68                 off += len1
  69         }
  70         // Ensure that ret hasn't exceeded our original max.
  71         if max < 0 {
  72                 ret += max
  73         }
  74         return
  75 }
  76
  77 func (r *Reader) waitReadable(off int64) {
  78         r.t.cl.event.Wait()
  79 }
  80
  81 func (r *Reader) ReadAt(b []byte, off int64) (n int, err error) {
  82         for {
  83                 var n1 int
  84                 n1, err = r.readAt(b, off)
  85                 n += n1
  86                 b = b[n1:]
  87                 off += int64(n1)
  88                 if err != nil || len(b) == 0 || n1 == 0 {
  89                         return
  90                 }
  91         }
  92 }
  93
  94 func (r *Reader) Read(b []byte) (n int, err error) {
  95         n, err = r.readAt(b, r.pos)
  96         r.pos += int64(n)
  97         return
  98 }
  99
 100 // Must only return EOF at the end of the torrent.
 101 func (r *Reader) readAt(b []byte, pos int64) (n int, err error) {
 102         // defer func() {
 103         //      log.Println(pos, n, err)
 104         // }()
 105         maxLen := r.t.torrent.Info.TotalLength() - pos
 106         if maxLen <= 0 {
 107                 err = io.EOF
 108                 return
 109         }
 110         if int64(len(b)) > maxLen {
 111                 b = b[:maxLen]
 112         }
 113 again:
 114         r.t.cl.mu.Lock()
 115         r.raisePriorities(pos, len(b))
 116         for !r.readable(pos) {
 117                 r.raisePriorities(pos, len(b))
 118                 r.waitReadable(pos)
 119         }
 120         avail := r.available(pos, int64(len(b)))
 121         // log.Println("available", avail)
 122         r.t.cl.mu.Unlock()
 123         b1 := b[:avail]
 124         pi := int(pos / r.t.Info().PieceLength)
 125         tp := &r.t.torrent.Pieces[pi]
 126         ip := r.t.Info().Piece(pi)
 127         po := pos % ip.Length()
 128         if int64(len(b1)) > ip.Length()-po {
 129                 b1 = b1[:ip.Length()-po]
 130         }
 131         tp.pendingWritesMutex.Lock()
 132         for tp.pendingWrites != 0 {
 133                 tp.noPendingWrites.Wait()
 134         }
 135         tp.pendingWritesMutex.Unlock()
 136         n, err = dataReadAt(r.t.data, b1, pos)
 137         if n != 0 {
 138                 err = nil
 139                 return
 140         }
 141         if err == io.ErrUnexpectedEOF {
 142                 goto again
 143         }
 144         return
 145 }
 146
 147 func (r *Reader) Close() error {
 148         r.t = nil
 149         return nil
 150 }
 151
 152 func (r *Reader) Seek(off int64, whence int) (ret int64, err error) {
 153         switch whence {
 154         case os.SEEK_SET:
 155                 r.pos = off
 156         case os.SEEK_CUR:
 157                 r.pos += off
 158         case os.SEEK_END:
 159                 r.pos = r.t.torrent.Info.TotalLength() + off
 160         default:
 161                 err = errors.New("bad whence")
 162         }
 163         ret = r.pos
 164         return
 165 }