fs/torrentfs_test.go

   1 package torrentfs
   2
   3 import (
   4         "context"
   5         "fmt"
   6         "io/ioutil"
   7         "log"
   8         "net"
   9         _ "net/http/pprof"
  10         "os"
  11         "path/filepath"
  12         "testing"
  13         "time"
  14
  15         _ "github.com/anacrolix/envpprof"
  16         "github.com/anacrolix/fuse"
  17         fusefs "github.com/anacrolix/fuse/fs"
  18         "github.com/anacrolix/missinggo/v2"
  19         "github.com/stretchr/testify/assert"
  20         "github.com/stretchr/testify/require"
  21
  22         "github.com/anacrolix/torrent"
  23         "github.com/anacrolix/torrent/internal/testutil"
  24         "github.com/anacrolix/torrent/metainfo"
  25         "github.com/anacrolix/torrent/storage"
  26 )
  27
  28 func init() {
  29         log.SetFlags(log.Flags() | log.Lshortfile)
  30 }
  31
  32 func TestTCPAddrString(t *testing.T) {
  33         l, err := net.Listen("tcp4", "localhost:0")
  34         if err != nil {
  35                 t.Fatal(err)
  36         }
  37         defer l.Close()
  38         c, err := net.Dial("tcp", l.Addr().String())
  39         if err != nil {
  40                 t.Fatal(err)
  41         }
  42         defer c.Close()
  43         ras := c.RemoteAddr().String()
  44         ta := &net.TCPAddr{
  45                 IP:   net.IPv4(127, 0, 0, 1),
  46                 Port: missinggo.AddrPort(l.Addr()),
  47         }
  48         s := ta.String()
  49         if ras != s {
  50                 t.FailNow()
  51         }
  52 }
  53
  54 type testLayout struct {
  55         BaseDir   string
  56         MountDir  string
  57         Completed string
  58         Metainfo  *metainfo.MetaInfo
  59 }
  60
  61 func (tl *testLayout) Destroy() error {
  62         return os.RemoveAll(tl.BaseDir)
  63 }
  64
  65 func newGreetingLayout(t *testing.T) (tl testLayout, err error) {
  66         tl.BaseDir = t.TempDir()
  67         tl.Completed = filepath.Join(tl.BaseDir, "completed")
  68         os.Mkdir(tl.Completed, 0o777)
  69         tl.MountDir = filepath.Join(tl.BaseDir, "mnt")
  70         os.Mkdir(tl.MountDir, 0o777)
  71         testutil.CreateDummyTorrentData(tl.Completed)
  72         tl.Metainfo = testutil.GreetingMetaInfo()
  73         return
  74 }
  75
  76 // Unmount without first killing the FUSE connection while there are FUSE
  77 // operations blocked inside the filesystem code.
  78 func TestUnmountWedged(t *testing.T) {
  79         layout, err := newGreetingLayout(t)
  80         require.NoError(t, err)
  81         defer func() {
  82                 err := layout.Destroy()
  83                 if err != nil {
  84                         t.Log(err)
  85                 }
  86         }()
  87         cfg := torrent.NewDefaultClientConfig()
  88         cfg.DataDir = filepath.Join(layout.BaseDir, "incomplete")
  89         cfg.DisableTrackers = true
  90         cfg.NoDHT = true
  91         cfg.DisableTCP = true
  92         cfg.DisableUTP = true
  93         client, err := torrent.NewClient(cfg)
  94         require.NoError(t, err)
  95         defer client.Close()
  96         tt, err := client.AddTorrent(layout.Metainfo)
  97         require.NoError(t, err)
  98         fs := New(client)
  99         fuseConn, err := fuse.Mount(layout.MountDir)
 100         if err != nil {
 101                 switch err.Error() {
 102                 case "cannot locate OSXFUSE":
 103                         fallthrough
 104                 case "fusermount: exit status 1":
 105                         t.Skip(err)
 106                 }
 107                 t.Fatal(err)
 108         }
 109         go func() {
 110                 server := fusefs.New(fuseConn, &fusefs.Config{
 111                         Debug: func(msg interface{}) {
 112                                 t.Log(msg)
 113                         },
 114                 })
 115                 server.Serve(fs)
 116         }()
 117         <-fuseConn.Ready
 118         if err := fuseConn.MountError; err != nil {
 119                 t.Fatalf("mount error: %s", err)
 120         }
 121         ctx, cancel := context.WithCancel(context.Background())
 122         // Read the greeting file, though it will never be available. This should
 123         // "wedge" FUSE, requiring the fs object to be forcibly destroyed. The
 124         // read call will return with a FS error.
 125         go func() {
 126                 <-ctx.Done()
 127                 fs.mu.Lock()
 128                 fs.event.Broadcast()
 129                 fs.mu.Unlock()
 130         }()
 131         go func() {
 132                 defer cancel()
 133                 _, err := ioutil.ReadFile(filepath.Join(layout.MountDir, tt.Info().Name))
 134                 require.Error(t, err)
 135         }()
 136
 137         // Wait until the read has blocked inside the filesystem code.
 138         fs.mu.Lock()
 139         for fs.blockedReads != 1 && ctx.Err() == nil {
 140                 fs.event.Wait()
 141         }
 142         fs.mu.Unlock()
 143
 144         fs.Destroy()
 145
 146         for {
 147                 err = fuse.Unmount(layout.MountDir)
 148                 if err != nil {
 149                         t.Logf("error unmounting: %s", err)
 150                         time.Sleep(time.Millisecond)
 151                 } else {
 152                         break
 153                 }
 154         }
 155
 156         err = fuseConn.Close()
 157         assert.NoError(t, err)
 158 }
 159
 160 func TestDownloadOnDemand(t *testing.T) {
 161         layout, err := newGreetingLayout(t)
 162         require.NoError(t, err)
 163         defer layout.Destroy()
 164         cfg := torrent.NewDefaultClientConfig()
 165         cfg.DataDir = layout.Completed
 166         cfg.DisableTrackers = true
 167         cfg.NoDHT = true
 168         cfg.Seed = true
 169         cfg.ListenPort = 0
 170         cfg.ListenHost = torrent.LoopbackListenHost
 171         seeder, err := torrent.NewClient(cfg)
 172         require.NoError(t, err)
 173         defer seeder.Close()
 174         defer testutil.ExportStatusWriter(seeder, "s", t)()
 175         // Just to mix things up, the seeder starts with the data, but the leecher
 176         // starts with the metainfo.
 177         seederTorrent, err := seeder.AddMagnet(fmt.Sprintf("magnet:?xt=urn:btih:%s", layout.Metainfo.HashInfoBytes().HexString()))
 178         require.NoError(t, err)
 179         go func() {
 180                 // Wait until we get the metainfo, then check for the data.
 181                 <-seederTorrent.GotInfo()
 182                 seederTorrent.VerifyData()
 183         }()
 184         cfg = torrent.NewDefaultClientConfig()
 185         cfg.DisableTrackers = true
 186         cfg.NoDHT = true
 187         cfg.DisableTCP = true
 188         cfg.DefaultStorage = storage.NewMMap(filepath.Join(layout.BaseDir, "download"))
 189         cfg.ListenHost = torrent.LoopbackListenHost
 190         cfg.ListenPort = 0
 191         leecher, err := torrent.NewClient(cfg)
 192         require.NoError(t, err)
 193         testutil.ExportStatusWriter(leecher, "l", t)()
 194         defer leecher.Close()
 195         leecherTorrent, err := leecher.AddTorrent(layout.Metainfo)
 196         require.NoError(t, err)
 197         leecherTorrent.AddClientPeer(seeder)
 198         fs := New(leecher)
 199         defer fs.Destroy()
 200         root, _ := fs.Root()
 201         node, _ := root.(fusefs.NodeStringLookuper).Lookup(context.Background(), "greeting")
 202         var attr fuse.Attr
 203         node.Attr(context.Background(), &attr)
 204         size := attr.Size
 205         data := make([]byte, size)
 206         h, err := node.(fusefs.NodeOpener).Open(context.TODO(), nil, nil)
 207         require.NoError(t, err)
 208
 209         // torrent.Reader.Read no longer tries to fill the entire read buffer, so this is a ReadFull for
 210         // fusefs.
 211         var n int
 212         for n < len(data) {
 213                 resp := fuse.ReadResponse{Data: data[n:]}
 214                 err := h.(fusefs.HandleReader).Read(context.Background(), &fuse.ReadRequest{
 215                         Size:   int(size) - n,
 216                         Offset: int64(n),
 217                 }, &resp)
 218                 assert.NoError(t, err)
 219                 n += len(resp.Data)
 220         }
 221
 222         assert.EqualValues(t, testutil.GreetingFileContents, data)
 223 }
 224
 225 func TestIsSubPath(t *testing.T) {
 226         for _, case_ := range []struct {
 227                 parent, child string
 228                 is            bool
 229         }{
 230                 {"", "", false},
 231                 {"", "/", true},
 232                 {"", "a", true},
 233                 {"a/b", "a/bc", false},
 234                 {"a/b", "a/b", false},
 235                 {"a/b", "a/b/c", true},
 236                 {"a/b", "a//b", false},
 237         } {
 238                 assert.Equal(t, case_.is, isSubPath(case_.parent, case_.child))
 239         }
 240 }