fs/torrentfs_test.go

   1 package torrentfs
   2
   3 import (
   4         "fmt"
   5         "io/ioutil"
   6         "log"
   7         "net"
   8         _ "net/http/pprof"
   9         "os"
  10         "path/filepath"
  11         "strings"
  12         "testing"
  13         "time"
  14
  15         "bazil.org/fuse"
  16         fusefs "bazil.org/fuse/fs"
  17         _ "github.com/anacrolix/envpprof"
  18         "github.com/anacrolix/missinggo"
  19         "github.com/stretchr/testify/assert"
  20         "github.com/stretchr/testify/require"
  21         netContext "golang.org/x/net/context"
  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         client, err := torrent.NewClient(&torrent.Config{
  92                 DataDir:         filepath.Join(layout.BaseDir, "incomplete"),
  93                 DisableTrackers: true,
  94                 NoDHT:           true,
  95                 ListenAddr:      "redonk",
  96                 DisableTCP:      true,
  97                 DisableUTP:      true,
  98         })
  99         require.NoError(t, err)
 100         defer client.Close()
 101         _, err = client.AddTorrent(layout.Metainfo)
 102         require.NoError(t, err)
 103         fs := New(client)
 104         fuseConn, err := fuse.Mount(layout.MountDir)
 105         if err != nil {
 106                 msg := fmt.Sprintf("error mounting: %s", err)
 107                 if strings.Contains(err.Error(), "fuse") || err.Error() == "exit status 71" {
 108                         t.Skip(msg)
 109                 }
 110                 t.Fatal(msg)
 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         // Read the greeting file, though it will never be available. This should
 125         // "wedge" FUSE, requiring the fs object to be forcibly destroyed. The
 126         // read call will return with a FS error.
 127         go func() {
 128                 _, err := ioutil.ReadFile(filepath.Join(layout.MountDir, layout.Metainfo.Info.Name))
 129                 if err == nil {
 130                         t.Fatal("expected error reading greeting")
 131                 }
 132         }()
 133
 134         // Wait until the read has blocked inside the filesystem code.
 135         fs.mu.Lock()
 136         for fs.blockedReads != 1 {
 137                 fs.event.Wait()
 138         }
 139         fs.mu.Unlock()
 140
 141         fs.Destroy()
 142
 143         for {
 144                 err = fuse.Unmount(layout.MountDir)
 145                 if err != nil {
 146                         t.Logf("error unmounting: %s", err)
 147                         time.Sleep(time.Millisecond)
 148                 } else {
 149                         break
 150                 }
 151         }
 152
 153         err = fuseConn.Close()
 154         if err != nil {
 155                 t.Fatalf("error closing fuse conn: %s", err)
 156         }
 157 }
 158
 159 func TestDownloadOnDemand(t *testing.T) {
 160         layout, err := newGreetingLayout()
 161         require.NoError(t, err)
 162         defer layout.Destroy()
 163         seeder, err := torrent.NewClient(&torrent.Config{
 164                 DataDir:         layout.Completed,
 165                 DisableTrackers: true,
 166                 NoDHT:           true,
 167                 ListenAddr:      "localhost:0",
 168                 Seed:            true,
 169                 // Ensure that the metainfo is obtained over the wire, since we added
 170                 // the torrent to the seeder by magnet.
 171                 DisableMetainfoCache: true,
 172         })
 173         require.NoError(t, err)
 174         defer seeder.Close()
 175         testutil.ExportStatusWriter(seeder, "s")
 176         _, err = seeder.AddMagnet(fmt.Sprintf("magnet:?xt=urn:btih:%s", layout.Metainfo.Info.Hash.HexString()))
 177         require.NoError(t, err)
 178         leecher, err := torrent.NewClient(&torrent.Config{
 179                 DisableTrackers: true,
 180                 NoDHT:           true,
 181                 ListenAddr:      "localhost:0",
 182                 DisableTCP:      true,
 183                 DefaultStorage:  storage.NewMMap(filepath.Join(layout.BaseDir, "download")),
 184                 // This can be used to check if clients can connect to other clients
 185                 // with the same ID.
 186                 // PeerID: seeder.PeerID(),
 187         })
 188         require.NoError(t, err)
 189         testutil.ExportStatusWriter(leecher, "l")
 190         defer leecher.Close()
 191         leecherTorrent, _ := leecher.AddTorrent(layout.Metainfo)
 192         leecherTorrent.AddPeers([]torrent.Peer{
 193                 torrent.Peer{
 194                         IP:   missinggo.AddrIP(seeder.ListenAddr()),
 195                         Port: missinggo.AddrPort(seeder.ListenAddr()),
 196                 },
 197         })
 198         fs := New(leecher)
 199         defer fs.Destroy()
 200         root, _ := fs.Root()
 201         node, _ := root.(fusefs.NodeStringLookuper).Lookup(netContext.Background(), "greeting")
 202         var attr fuse.Attr
 203         node.Attr(netContext.Background(), &attr)
 204         size := attr.Size
 205         resp := &fuse.ReadResponse{
 206                 Data: make([]byte, size),
 207         }
 208         node.(fusefs.HandleReader).Read(netContext.Background(), &fuse.ReadRequest{
 209                 Size: int(size),
 210         }, resp)
 211         assert.EqualValues(t, testutil.GreetingFileContents, resp.Data)
 212 }
 213
 214 func TestIsSubPath(t *testing.T) {
 215         for _, case_ := range []struct {
 216                 parent, child string
 217                 is            bool
 218         }{
 219                 {"", "", false},
 220                 {"", "/", true},
 221                 {"a/b", "a/bc", false},
 222                 {"a/b", "a/b", false},
 223                 {"a/b", "a/b/c", true},
 224                 {"a/b", "a//b", false},
 225         } {
 226                 assert.Equal(t, case_.is, isSubPath(case_.parent, case_.child))
 227         }
 228 }