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