fs/torrentfs_test.go

   1 package torrentfs
   2
   3 import (
   4         "context"
   5         netContext "context"
   6         "fmt"
   7         "io/ioutil"
   8         "log"
   9         "net"
  10         _ "net/http/pprof"
  11         "os"
  12         "path/filepath"
  13         "testing"
  14         "time"
  15
  16         "bazil.org/fuse"
  17         fusefs "bazil.org/fuse/fs"
  18         _ "github.com/anacrolix/envpprof"
  19         "github.com/anacrolix/missinggo"
  20         "github.com/anacrolix/torrent"
  21         "github.com/anacrolix/torrent/internal/testutil"
  22         "github.com/anacrolix/torrent/metainfo"
  23         "github.com/anacrolix/torrent/storage"
  24         "github.com/stretchr/testify/assert"
  25         "github.com/stretchr/testify/require"
  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, 0777)
  72         tl.MountDir = filepath.Join(tl.BaseDir, "mnt")
  73         os.Mkdir(tl.MountDir, 0777)
  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.ListenHost = torrent.LoopbackListenHost
 173         seeder, err := torrent.NewClient(cfg)
 174         require.NoError(t, err)
 175         defer seeder.Close()
 176         defer testutil.ExportStatusWriter(seeder, "s")()
 177         // Just to mix things up, the seeder starts with the data, but the leecher
 178         // starts with the metainfo.
 179         seederTorrent, err := seeder.AddMagnet(fmt.Sprintf("magnet:?xt=urn:btih:%s", layout.Metainfo.HashInfoBytes().HexString()))
 180         require.NoError(t, err)
 181         go func() {
 182                 // Wait until we get the metainfo, then check for the data.
 183                 <-seederTorrent.GotInfo()
 184                 seederTorrent.VerifyData()
 185         }()
 186         cfg = torrent.NewDefaultClientConfig()
 187         cfg.DisableTrackers = true
 188         cfg.NoDHT = true
 189         cfg.DisableTCP = true
 190         cfg.DefaultStorage = storage.NewMMap(filepath.Join(layout.BaseDir, "download"))
 191         cfg.ListenHost = torrent.LoopbackListenHost
 192         leecher, err := torrent.NewClient(cfg)
 193         require.NoError(t, err)
 194         testutil.ExportStatusWriter(leecher, "l")()
 195         defer leecher.Close()
 196         leecherTorrent, err := leecher.AddTorrent(layout.Metainfo)
 197         require.NoError(t, err)
 198         leecherTorrent.AddClientPeer(seeder)
 199         fs := New(leecher)
 200         defer fs.Destroy()
 201         root, _ := fs.Root()
 202         node, _ := root.(fusefs.NodeStringLookuper).Lookup(netContext.Background(), "greeting")
 203         var attr fuse.Attr
 204         node.Attr(netContext.Background(), &attr)
 205         size := attr.Size
 206         resp := &fuse.ReadResponse{
 207                 Data: make([]byte, size),
 208         }
 209         h, err := node.(fusefs.NodeOpener).Open(context.TODO(), nil, nil)
 210         require.NoError(t, err)
 211         h.(fusefs.HandleReader).Read(netContext.Background(), &fuse.ReadRequest{
 212                 Size: int(size),
 213         }, resp)
 214         assert.EqualValues(t, testutil.GreetingFileContents, resp.Data)
 215 }
 216
 217 func TestIsSubPath(t *testing.T) {
 218         for _, case_ := range []struct {
 219                 parent, child string
 220                 is            bool
 221         }{
 222                 {"", "", false},
 223                 {"", "/", true},
 224                 {"", "a", true},
 225                 {"a/b", "a/bc", false},
 226                 {"a/b", "a/b", false},
 227                 {"a/b", "a/b/c", true},
 228                 {"a/b", "a//b", false},
 229         } {
 230                 assert.Equal(t, case_.is, isSubPath(case_.parent, case_.child))
 231         }
 232 }