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() (tl testLayout, err error) {
  66         tl.BaseDir, err = ioutil.TempDir("", "torrentfs")
  67         if err != nil {
  68                 return
  69         }
  70         tl.Completed = filepath.Join(tl.BaseDir, "completed")
  71         os.Mkdir(tl.Completed, 0o777)
  72         tl.MountDir = filepath.Join(tl.BaseDir, "mnt")
  73         os.Mkdir(tl.MountDir, 0o777)
  74         testutil.CreateDummyTorrentData(tl.Completed)
  75         tl.Metainfo = testutil.GreetingMetaInfo()
  76         return
  77 }
  78
  79 // Unmount without first killing the FUSE connection while there are FUSE
  80 // operations blocked inside the filesystem code.
  81 func TestUnmountWedged(t *testing.T) {
  82         layout, err := newGreetingLayout()
  83         require.NoError(t, err)
  84         defer func() {
  85                 err := layout.Destroy()
  86                 if err != nil {
  87                         t.Log(err)
  88                 }
  89         }()
  90         cfg := torrent.NewDefaultClientConfig()
  91         cfg.DataDir = filepath.Join(layout.BaseDir, "incomplete")
  92         cfg.DisableTrackers = true
  93         cfg.NoDHT = true
  94         cfg.DisableTCP = true
  95         cfg.DisableUTP = true
  96         client, err := torrent.NewClient(cfg)
  97         require.NoError(t, err)
  98         defer client.Close()
  99         tt, err := client.AddTorrent(layout.Metainfo)
 100         require.NoError(t, err)
 101         fs := New(client)
 102         fuseConn, err := fuse.Mount(layout.MountDir)
 103         if err != nil {
 104                 switch err.Error() {
 105                 case "cannot locate OSXFUSE":
 106                         fallthrough
 107                 case "fusermount: exit status 1":
 108                         t.Skip(err)
 109                 }
 110                 t.Fatal(err)
 111         }
 112         go func() {
 113                 server := fusefs.New(fuseConn, &fusefs.Config{
 114                         Debug: func(msg interface{}) {
 115                                 t.Log(msg)
 116                         },
 117                 })
 118                 server.Serve(fs)
 119         }()
 120         <-fuseConn.Ready
 121         if err := fuseConn.MountError; err != nil {
 122                 t.Fatalf("mount error: %s", err)
 123         }
 124         ctx, cancel := context.WithCancel(context.Background())
 125         // Read the greeting file, though it will never be available. This should
 126         // "wedge" FUSE, requiring the fs object to be forcibly destroyed. The
 127         // read call will return with a FS error.
 128         go func() {
 129                 <-ctx.Done()
 130                 fs.mu.Lock()
 131                 fs.event.Broadcast()
 132                 fs.mu.Unlock()
 133         }()
 134         go func() {
 135                 defer cancel()
 136                 _, err := ioutil.ReadFile(filepath.Join(layout.MountDir, tt.Info().Name))
 137                 require.Error(t, err)
 138         }()
 139
 140         // Wait until the read has blocked inside the filesystem code.
 141         fs.mu.Lock()
 142         for fs.blockedReads != 1 && ctx.Err() == nil {
 143                 fs.event.Wait()
 144         }
 145         fs.mu.Unlock()
 146
 147         fs.Destroy()
 148
 149         for {
 150                 err = fuse.Unmount(layout.MountDir)
 151                 if err != nil {
 152                         t.Logf("error unmounting: %s", err)
 153                         time.Sleep(time.Millisecond)
 154                 } else {
 155                         break
 156                 }
 157         }
 158
 159         err = fuseConn.Close()
 160         assert.NoError(t, err)
 161 }
 162
 163 func TestDownloadOnDemand(t *testing.T) {
 164         layout, err := newGreetingLayout()
 165         require.NoError(t, err)
 166         defer layout.Destroy()
 167         cfg := torrent.NewDefaultClientConfig()
 168         cfg.DataDir = layout.Completed
 169         cfg.DisableTrackers = true
 170         cfg.NoDHT = true
 171         cfg.Seed = true
 172         cfg.ListenPort = 0
 173         cfg.ListenHost = torrent.LoopbackListenHost
 174         seeder, err := torrent.NewClient(cfg)
 175         require.NoError(t, err)
 176         defer seeder.Close()
 177         defer testutil.ExportStatusWriter(seeder, "s", t)()
 178         // Just to mix things up, the seeder starts with the data, but the leecher
 179         // starts with the metainfo.
 180         seederTorrent, err := seeder.AddMagnet(fmt.Sprintf("magnet:?xt=urn:btih:%s", layout.Metainfo.HashInfoBytes().HexString()))
 181         require.NoError(t, err)
 182         go func() {
 183                 // Wait until we get the metainfo, then check for the data.
 184                 <-seederTorrent.GotInfo()
 185                 seederTorrent.VerifyData()
 186         }()
 187         cfg = torrent.NewDefaultClientConfig()
 188         cfg.DisableTrackers = true
 189         cfg.NoDHT = true
 190         cfg.DisableTCP = true
 191         cfg.DefaultStorage = storage.NewMMap(filepath.Join(layout.BaseDir, "download"))
 192         cfg.ListenHost = torrent.LoopbackListenHost
 193         cfg.ListenPort = 0
 194         leecher, err := torrent.NewClient(cfg)
 195         require.NoError(t, err)
 196         testutil.ExportStatusWriter(leecher, "l", t)()
 197         defer leecher.Close()
 198         leecherTorrent, err := leecher.AddTorrent(layout.Metainfo)
 199         require.NoError(t, err)
 200         leecherTorrent.AddClientPeer(seeder)
 201         fs := New(leecher)
 202         defer fs.Destroy()
 203         root, _ := fs.Root()
 204         node, _ := root.(fusefs.NodeStringLookuper).Lookup(context.Background(), "greeting")
 205         var attr fuse.Attr
 206         node.Attr(context.Background(), &attr)
 207         size := attr.Size
 208         data := make([]byte, size)
 209         h, err := node.(fusefs.NodeOpener).Open(context.TODO(), nil, nil)
 210         require.NoError(t, err)
 211
 212         // torrent.Reader.Read no longer tries to fill the entire read buffer, so this is a ReadFull for
 213         // fusefs.
 214         var n int
 215         for n < len(data) {
 216                 resp := fuse.ReadResponse{Data: data[n:]}
 217                 err := h.(fusefs.HandleReader).Read(context.Background(), &fuse.ReadRequest{
 218                         Size:   int(size) - n,
 219                         Offset: int64(n),
 220                 }, &resp)
 221                 assert.NoError(t, err)
 222                 n += len(resp.Data)
 223         }
 224
 225         assert.EqualValues(t, testutil.GreetingFileContents, data)
 226 }
 227
 228 func TestIsSubPath(t *testing.T) {
 229         for _, case_ := range []struct {
 230                 parent, child string
 231                 is            bool
 232         }{
 233                 {"", "", false},
 234                 {"", "/", true},
 235                 {"", "a", true},
 236                 {"a/b", "a/bc", false},
 237                 {"a/b", "a/b", false},
 238                 {"a/b", "a/b/c", true},
 239                 {"a/b", "a//b", false},
 240         } {
 241                 assert.Equal(t, case_.is, isSubPath(case_.parent, case_.child))
 242         }
 243 }