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