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