fs/torrentfs_test.go

   1 package torrentfs
   2
   3 import (
   4         "bytes"
   5         "fmt"
   6         "io/ioutil"
   7         "net"
   8         "net/http"
   9         _ "net/http/pprof"
  10         "os"
  11         "path/filepath"
  12         "strconv"
  13         "strings"
  14         "testing"
  15         "time"
  16
  17         "github.com/anacrolix/torrent/data"
  18
  19         "golang.org/x/net/context"
  20
  21         "github.com/anacrolix/torrent"
  22         "github.com/anacrolix/torrent/data/mmap"
  23         "github.com/anacrolix/torrent/internal/testutil"
  24         "github.com/anacrolix/torrent/util"
  25
  26         "github.com/anacrolix/libtorgo/metainfo"
  27
  28         "bazil.org/fuse"
  29         fusefs "bazil.org/fuse/fs"
  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: util.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 (me *testLayout) Destroy() error {
  62         return os.RemoveAll(me.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         name := testutil.CreateDummyTorrentData(tl.Completed)
  75         metaInfoBuf := &bytes.Buffer{}
  76         testutil.CreateMetaInfo(name, metaInfoBuf)
  77         tl.Metainfo, err = metainfo.Load(metaInfoBuf)
  78         return
  79 }
  80
  81 // Unmount without first killing the FUSE connection while there are FUSE
  82 // operations blocked inside the filesystem code.
  83 func TestUnmountWedged(t *testing.T) {
  84         layout, err := newGreetingLayout()
  85         if err != nil {
  86                 t.Fatal(err)
  87         }
  88         defer func() {
  89                 err := layout.Destroy()
  90                 if err != nil {
  91                         t.Log(err)
  92                 }
  93         }()
  94         client, err := torrent.NewClient(&torrent.Config{
  95                 DataDir:         filepath.Join(layout.BaseDir, "incomplete"),
  96                 DisableTrackers: true,
  97                 NoDHT:           true,
  98
  99                 NoDefaultBlocklist: true,
 100         })
 101         defer client.Close()
 102         client.AddTorrent(layout.Metainfo)
 103         fs := New(client)
 104         fuseConn, err := fuse.Mount(layout.MountDir)
 105         if err != nil {
 106                 if strings.Contains(err.Error(), "fuse") {
 107                         t.Skip(err)
 108                 }
 109                 t.Fatal(err)
 110         }
 111         go func() {
 112                 server := fusefs.Server{
 113                         FS: fs,
 114                         Debug: func(msg interface{}) {
 115                                 t.Log(msg)
 116                         },
 117                 }
 118                 server.Serve(fuseConn)
 119         }()
 120         <-fuseConn.Ready
 121         if err := fuseConn.MountError; err != nil {
 122                 t.Fatal(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         if err != nil {
 162                 t.Fatal(err)
 163         }
 164         defer layout.Destroy()
 165         seeder, err := torrent.NewClient(&torrent.Config{
 166                 DataDir:         layout.Completed,
 167                 DisableTrackers: true,
 168                 NoDHT:           true,
 169                 ListenAddr:      ":0",
 170
 171                 NoDefaultBlocklist: true,
 172                 // Ensure that the metainfo is obtained over the wire, since we added
 173                 // the torrent to the seeder by magnet.
 174                 DisableMetainfoCache: true,
 175         })
 176         if err != nil {
 177                 t.Fatalf("error creating seeder client: %s", err)
 178         }
 179         seeder.SetIPBlockList(nil)
 180         defer seeder.Close()
 181         http.HandleFunc("/seeder", func(w http.ResponseWriter, req *http.Request) {
 182                 seeder.WriteStatus(w)
 183         })
 184         _, err = seeder.AddMagnet(fmt.Sprintf("magnet:?xt=urn:btih:%x", layout.Metainfo.Info.Hash))
 185         if err != nil {
 186                 t.Fatal(err)
 187         }
 188         leecher, err := torrent.NewClient(&torrent.Config{
 189                 DisableTrackers: true,
 190                 NoDHT:           true,
 191                 ListenAddr:      ":0",
 192                 DisableTCP:      true,
 193
 194                 NoDefaultBlocklist: true,
 195
 196                 TorrentDataOpener: func(info *metainfo.Info) data.Data {
 197                         ret, _ := mmap.TorrentData(info, filepath.Join(layout.BaseDir, "download"))
 198                         return ret
 199                 },
 200
 201                 // This can be used to check if clients can connect to other clients
 202                 // with the same ID.
 203
 204                 // PeerID: seeder.PeerID(),
 205         })
 206         leecher.SetIPBlockList(nil)
 207         http.HandleFunc("/leecher", func(w http.ResponseWriter, req *http.Request) {
 208                 leecher.WriteStatus(w)
 209         })
 210         defer leecher.Close()
 211         leecherTorrent, _ := leecher.AddTorrent(layout.Metainfo)
 212         leecherTorrent.AddPeers([]torrent.Peer{func() torrent.Peer {
 213                 _, port, err := net.SplitHostPort(seeder.ListenAddr().String())
 214                 if err != nil {
 215                         panic(err)
 216                 }
 217                 portInt64, err := strconv.ParseInt(port, 0, 0)
 218                 if err != nil {
 219                         panic(err)
 220                 }
 221                 return torrent.Peer{
 222                         IP: func() net.IP {
 223                                 ret, _ := net.ResolveIPAddr("ip", "localhost")
 224                                 return ret.IP
 225                         }(),
 226                         Port: int(portInt64),
 227                 }
 228         }()})
 229         fs := New(leecher)
 230         defer fs.Destroy()
 231         root, _ := fs.Root()
 232         node, _ := root.(fusefs.NodeStringLookuper).Lookup(context.Background(), "greeting")
 233         size := int(node.Attr().Size)
 234         resp := &fuse.ReadResponse{
 235                 Data: make([]byte, size),
 236         }
 237         node.(fusefs.HandleReader).Read(context.Background(), &fuse.ReadRequest{
 238                 Size: size,
 239         }, resp)
 240         content := resp.Data
 241         if string(content) != testutil.GreetingFileContents {
 242                 t.FailNow()
 243         }
 244 }