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         "bazil.org/fuse"
  18         fusefs "bazil.org/fuse/fs"
  19         "github.com/anacrolix/libtorgo/metainfo"
  20         "golang.org/x/net/context"
  21
  22         "github.com/anacrolix/torrent"
  23         "github.com/anacrolix/torrent/data"
  24         "github.com/anacrolix/torrent/data/mmap"
  25         "github.com/anacrolix/torrent/internal/testutil"
  26         "github.com/anacrolix/torrent/util"
  27 )
  28
  29 func TestTCPAddrString(t *testing.T) {
  30         l, err := net.Listen("tcp4", "localhost:0")
  31         if err != nil {
  32                 t.Fatal(err)
  33         }
  34         defer l.Close()
  35         c, err := net.Dial("tcp", l.Addr().String())
  36         if err != nil {
  37                 t.Fatal(err)
  38         }
  39         defer c.Close()
  40         ras := c.RemoteAddr().String()
  41         ta := &net.TCPAddr{
  42                 IP:   net.IPv4(127, 0, 0, 1),
  43                 Port: util.AddrPort(l.Addr()),
  44         }
  45         s := ta.String()
  46         if ras != s {
  47                 t.FailNow()
  48         }
  49 }
  50
  51 type testLayout struct {
  52         BaseDir   string
  53         MountDir  string
  54         Completed string
  55         Metainfo  *metainfo.MetaInfo
  56 }
  57
  58 func (me *testLayout) Destroy() error {
  59         return os.RemoveAll(me.BaseDir)
  60 }
  61
  62 func newGreetingLayout() (tl testLayout, err error) {
  63         tl.BaseDir, err = ioutil.TempDir("", "torrentfs")
  64         if err != nil {
  65                 return
  66         }
  67         tl.Completed = filepath.Join(tl.BaseDir, "completed")
  68         os.Mkdir(tl.Completed, 0777)
  69         tl.MountDir = filepath.Join(tl.BaseDir, "mnt")
  70         os.Mkdir(tl.MountDir, 0777)
  71         name := testutil.CreateDummyTorrentData(tl.Completed)
  72         metaInfoBuf := &bytes.Buffer{}
  73         testutil.CreateMetaInfo(name, metaInfoBuf)
  74         tl.Metainfo, err = metainfo.Load(metaInfoBuf)
  75         return
  76 }
  77
  78 // Unmount without first killing the FUSE connection while there are FUSE
  79 // operations blocked inside the filesystem code.
  80 func TestUnmountWedged(t *testing.T) {
  81         layout, err := newGreetingLayout()
  82         if err != nil {
  83                 t.Fatal(err)
  84         }
  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
  96                 NoDefaultBlocklist: true,
  97         })
  98         defer client.Close()
  99         client.AddTorrent(layout.Metainfo)
 100         fs := New(client)
 101         fuseConn, err := fuse.Mount(layout.MountDir)
 102         if err != nil {
 103                 if strings.Contains(err.Error(), "fuse") {
 104                         t.Skip(err)
 105                 }
 106                 t.Fatal(err)
 107         }
 108         go func() {
 109                 server := fusefs.Server{
 110                         FS: fs,
 111                         Debug: func(msg interface{}) {
 112                                 t.Log(msg)
 113                         },
 114                 }
 115                 server.Serve(fuseConn)
 116         }()
 117         <-fuseConn.Ready
 118         if err := fuseConn.MountError; err != nil {
 119                 t.Fatal(err)
 120         }
 121         // Read the greeting file, though it will never be available. This should
 122         // "wedge" FUSE, requiring the fs object to be forcibly destroyed. The
 123         // read call will return with a FS error.
 124         go func() {
 125                 _, err := ioutil.ReadFile(filepath.Join(layout.MountDir, layout.Metainfo.Info.Name))
 126                 if err == nil {
 127                         t.Fatal("expected error reading greeting")
 128                 }
 129         }()
 130
 131         // Wait until the read has blocked inside the filesystem code.
 132         fs.mu.Lock()
 133         for fs.blockedReads != 1 {
 134                 fs.event.Wait()
 135         }
 136         fs.mu.Unlock()
 137
 138         fs.Destroy()
 139
 140         for {
 141                 err = fuse.Unmount(layout.MountDir)
 142                 if err != nil {
 143                         t.Logf("error unmounting: %s", err)
 144                         time.Sleep(time.Millisecond)
 145                 } else {
 146                         break
 147                 }
 148         }
 149
 150         err = fuseConn.Close()
 151         if err != nil {
 152                 t.Fatalf("error closing fuse conn: %s", err)
 153         }
 154 }
 155
 156 func TestDownloadOnDemand(t *testing.T) {
 157         layout, err := newGreetingLayout()
 158         if err != nil {
 159                 t.Fatal(err)
 160         }
 161         defer layout.Destroy()
 162         seeder, err := torrent.NewClient(&torrent.Config{
 163                 DataDir:         layout.Completed,
 164                 DisableTrackers: true,
 165                 NoDHT:           true,
 166                 ListenAddr:      ":0",
 167
 168                 NoDefaultBlocklist: 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         if err != nil {
 174                 t.Fatalf("error creating seeder client: %s", err)
 175         }
 176         seeder.SetIPBlockList(nil)
 177         defer seeder.Close()
 178         http.HandleFunc("/seeder", func(w http.ResponseWriter, req *http.Request) {
 179                 seeder.WriteStatus(w)
 180         })
 181         _, err = seeder.AddMagnet(fmt.Sprintf("magnet:?xt=urn:btih:%x", layout.Metainfo.Info.Hash))
 182         if err != nil {
 183                 t.Fatal(err)
 184         }
 185         leecher, err := torrent.NewClient(&torrent.Config{
 186                 DisableTrackers: true,
 187                 NoDHT:           true,
 188                 ListenAddr:      ":0",
 189                 DisableTCP:      true,
 190
 191                 NoDefaultBlocklist: true,
 192
 193                 TorrentDataOpener: func(info *metainfo.Info) data.Data {
 194                         ret, _ := mmap.TorrentData(info, filepath.Join(layout.BaseDir, "download"))
 195                         return ret
 196                 },
 197
 198                 // This can be used to check if clients can connect to other clients
 199                 // with the same ID.
 200
 201                 // PeerID: seeder.PeerID(),
 202         })
 203         leecher.SetIPBlockList(nil)
 204         http.HandleFunc("/leecher", func(w http.ResponseWriter, req *http.Request) {
 205                 leecher.WriteStatus(w)
 206         })
 207         defer leecher.Close()
 208         leecherTorrent, _ := leecher.AddTorrent(layout.Metainfo)
 209         leecherTorrent.AddPeers([]torrent.Peer{func() torrent.Peer {
 210                 _, port, err := net.SplitHostPort(seeder.ListenAddr().String())
 211                 if err != nil {
 212                         panic(err)
 213                 }
 214                 portInt64, err := strconv.ParseInt(port, 0, 0)
 215                 if err != nil {
 216                         panic(err)
 217                 }
 218                 return torrent.Peer{
 219                         IP: func() net.IP {
 220                                 ret, _ := net.ResolveIPAddr("ip", "localhost")
 221                                 return ret.IP
 222                         }(),
 223                         Port: int(portInt64),
 224                 }
 225         }()})
 226         fs := New(leecher)
 227         defer fs.Destroy()
 228         root, _ := fs.Root()
 229         node, _ := root.(fusefs.NodeStringLookuper).Lookup(context.Background(), "greeting")
 230         var attr fuse.Attr
 231         node.Attr(&attr)
 232         size := attr.Size
 233         resp := &fuse.ReadResponse{
 234                 Data: make([]byte, size),
 235         }
 236         node.(fusefs.HandleReader).Read(context.Background(), &fuse.ReadRequest{
 237                 Size: int(size),
 238         }, resp)
 239         content := resp.Data
 240         if string(content) != testutil.GreetingFileContents {
 241                 t.FailNow()
 242         }
 243 }