fs/torrentfs_test.go

   1 package torrentfs
   2
   3 import (
   4         "bytes"
   5         "fmt"
   6         "io/ioutil"
   7         "log"
   8         "net"
   9         "net/http"
  10         _ "net/http/pprof"
  11         "os"
  12         "path/filepath"
  13         "strconv"
  14         "strings"
  15         "testing"
  16         "time"
  17
  18         "bitbucket.org/anacrolix/go.torrent"
  19         "bitbucket.org/anacrolix/go.torrent/testutil"
  20         "bitbucket.org/anacrolix/go.torrent/util"
  21         "github.com/anacrolix/libtorgo/metainfo"
  22
  23         "bazil.org/fuse"
  24         fusefs "bazil.org/fuse/fs"
  25 )
  26
  27 func init() {
  28         go http.ListenAndServe(":6061", nil)
  29 }
  30
  31 func TestTCPAddrString(t *testing.T) {
  32         l, err := net.Listen("tcp4", "localhost:0")
  33         if err != nil {
  34                 t.Fatal(err)
  35         }
  36         defer l.Close()
  37         c, err := net.Dial("tcp", l.Addr().String())
  38         if err != nil {
  39                 t.Fatal(err)
  40         }
  41         defer c.Close()
  42         ras := c.RemoteAddr().String()
  43         ta := &net.TCPAddr{
  44                 IP:   net.IPv4(127, 0, 0, 1),
  45                 Port: util.AddrPort(l.Addr()),
  46         }
  47         s := ta.String()
  48         if ras != s {
  49                 t.FailNow()
  50         }
  51 }
  52
  53 type testLayout struct {
  54         BaseDir   string
  55         MountDir  string
  56         Completed string
  57         Metainfo  *metainfo.MetaInfo
  58 }
  59
  60 func (me *testLayout) Destroy() error {
  61         return os.RemoveAll(me.BaseDir)
  62 }
  63
  64 func newGreetingLayout() (tl testLayout, err error) {
  65         tl.BaseDir, err = ioutil.TempDir("", "torrentfs")
  66         if err != nil {
  67                 return
  68         }
  69         tl.Completed = filepath.Join(tl.BaseDir, "completed")
  70         os.Mkdir(tl.Completed, 0777)
  71         tl.MountDir = filepath.Join(tl.BaseDir, "mnt")
  72         os.Mkdir(tl.MountDir, 0777)
  73         name := testutil.CreateDummyTorrentData(tl.Completed)
  74         metaInfoBuf := &bytes.Buffer{}
  75         testutil.CreateMetaInfo(name, metaInfoBuf)
  76         tl.Metainfo, err = metainfo.Load(metaInfoBuf)
  77         log.Printf("%x", tl.Metainfo.Info.Pieces)
  78         return
  79 }
  80
  81 func TestUnmountWedged(t *testing.T) {
  82         layout, err := newGreetingLayout()
  83         if err != nil {
  84                 t.Fatal(err)
  85         }
  86         defer func() {
  87                 err := layout.Destroy()
  88                 if err != nil {
  89                         t.Log(err)
  90                 }
  91         }()
  92         client, err := torrent.NewClient(&torrent.Config{
  93                 DataDir:         filepath.Join(layout.BaseDir, "incomplete"),
  94                 DisableTrackers: true,
  95                 NoDHT:           true,
  96         })
  97         defer client.Stop()
  98         log.Printf("%+v", *layout.Metainfo)
  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                                 log.Print(msg)
 113                         },
 114                 }
 115                 server.Serve(fuseConn)
 116         }()
 117         <-fuseConn.Ready
 118         if err := fuseConn.MountError; err != nil {
 119                 log.Fatal(err)
 120         }
 121         go func() {
 122                 ioutil.ReadFile(filepath.Join(layout.MountDir, layout.Metainfo.Info.Name))
 123         }()
 124         time.Sleep(time.Second)
 125         fs.Destroy()
 126         time.Sleep(time.Second)
 127         err = fuse.Unmount(layout.MountDir)
 128         if err != nil {
 129                 log.Print(err)
 130         }
 131         err = fuseConn.Close()
 132         if err != nil {
 133                 t.Log(err)
 134         }
 135 }
 136
 137 func TestDownloadOnDemand(t *testing.T) {
 138         layout, err := newGreetingLayout()
 139         if err != nil {
 140                 t.Fatal(err)
 141         }
 142         seeder, err := torrent.NewClient(&torrent.Config{
 143                 DataDir:         layout.Completed,
 144                 DisableTrackers: true,
 145                 NoDHT:           true,
 146         })
 147         http.HandleFunc("/seeder", func(w http.ResponseWriter, req *http.Request) {
 148                 seeder.WriteStatus(w)
 149         })
 150         defer seeder.Stop()
 151         _, err = seeder.AddMagnet(fmt.Sprintf("magnet:?xt=urn:btih:%x", layout.Metainfo.Info.Hash))
 152         if err != nil {
 153                 t.Fatal(err)
 154         }
 155         leecher, err := torrent.NewClient(&torrent.Config{
 156                 DataDir:          filepath.Join(layout.BaseDir, "download"),
 157                 DownloadStrategy: torrent.NewResponsiveDownloadStrategy(0),
 158                 DisableTrackers:  true,
 159                 NoDHT:            true,
 160
 161                 // This can be used to check if clients can connect to other clients
 162                 // with the same ID.
 163
 164                 // PeerID: seeder.PeerID(),
 165         })
 166         http.HandleFunc("/leecher", func(w http.ResponseWriter, req *http.Request) {
 167                 leecher.WriteStatus(w)
 168         })
 169         defer leecher.Stop()
 170         leecher.AddTorrent(layout.Metainfo)
 171         var ih torrent.InfoHash
 172         util.CopyExact(ih[:], layout.Metainfo.Info.Hash)
 173         leecher.AddPeers(ih, []torrent.Peer{func() torrent.Peer {
 174                 _, port, err := net.SplitHostPort(seeder.ListenAddr().String())
 175                 if err != nil {
 176                         panic(err)
 177                 }
 178                 portInt64, err := strconv.ParseInt(port, 0, 0)
 179                 if err != nil {
 180                         panic(err)
 181                 }
 182                 return torrent.Peer{
 183                         IP:   net.IPv6loopback,
 184                         Port: int(portInt64),
 185                 }
 186         }()})
 187         fs := New(leecher)
 188         defer fs.Destroy()
 189         root, _ := fs.Root()
 190         node, _ := root.(fusefs.NodeStringLookuper).Lookup("greeting", nil)
 191         size := int(node.Attr().Size)
 192         resp := &fuse.ReadResponse{
 193                 Data: make([]byte, size),
 194         }
 195         node.(fusefs.HandleReader).Read(&fuse.ReadRequest{
 196                 Size: size,
 197         }, resp, nil)
 198         content := resp.Data
 199         if string(content) != testutil.GreetingFileContents {
 200                 t.FailNow()
 201         }
 202 }