17 fusefs "bazil.org/fuse/fs"
18 _ "github.com/anacrolix/envpprof"
19 "github.com/anacrolix/missinggo"
20 "github.com/stretchr/testify/assert"
21 "github.com/stretchr/testify/require"
22 netContext "golang.org/x/net/context"
24 "github.com/anacrolix/torrent"
25 "github.com/anacrolix/torrent/data/mmap"
26 "github.com/anacrolix/torrent/internal/testutil"
27 "github.com/anacrolix/torrent/metainfo"
31 log.SetFlags(log.Flags() | log.Lshortfile)
34 func TestTCPAddrString(t *testing.T) {
35 l, err := net.Listen("tcp4", "localhost:0")
40 c, err := net.Dial("tcp", l.Addr().String())
45 ras := c.RemoteAddr().String()
47 IP: net.IPv4(127, 0, 0, 1),
48 Port: missinggo.AddrPort(l.Addr()),
56 type testLayout struct {
60 Metainfo *metainfo.MetaInfo
63 func (me *testLayout) Destroy() error {
64 return os.RemoveAll(me.BaseDir)
67 func newGreetingLayout() (tl testLayout, err error) {
68 tl.BaseDir, err = ioutil.TempDir("", "torrentfs")
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)
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()
91 err := layout.Destroy()
96 client, err := torrent.NewClient(&torrent.Config{
97 DataDir: filepath.Join(layout.BaseDir, "incomplete"),
98 DisableTrackers: true,
100 ListenAddr: "redonk",
104 NoDefaultBlocklist: true,
110 client.AddTorrent(layout.Metainfo)
112 fuseConn, err := fuse.Mount(layout.MountDir)
114 msg := fmt.Sprintf("error mounting: %s", err)
115 if strings.Contains(err.Error(), "fuse") || err.Error() == "exit status 71" {
121 server := fusefs.New(fuseConn, &fusefs.Config{
122 Debug: func(msg interface{}) {
129 if err := fuseConn.MountError; err != nil {
130 t.Fatalf("mount error: %s", err)
132 // Read the greeting file, though it will never be available. This should
133 // "wedge" FUSE, requiring the fs object to be forcibly destroyed. The
134 // read call will return with a FS error.
136 _, err := ioutil.ReadFile(filepath.Join(layout.MountDir, layout.Metainfo.Info.Name))
138 t.Fatal("expected error reading greeting")
142 // Wait until the read has blocked inside the filesystem code.
144 for fs.blockedReads != 1 {
152 err = fuse.Unmount(layout.MountDir)
154 t.Logf("error unmounting: %s", err)
155 time.Sleep(time.Millisecond)
161 err = fuseConn.Close()
163 t.Fatalf("error closing fuse conn: %s", err)
167 func TestDownloadOnDemand(t *testing.T) {
168 layout, err := newGreetingLayout()
169 require.NoError(t, err)
170 defer layout.Destroy()
171 seeder, err := torrent.NewClient(&torrent.Config{
172 DataDir: layout.Completed,
173 DisableTrackers: true,
175 ListenAddr: "localhost:0",
178 NoDefaultBlocklist: true,
179 // Ensure that the metainfo is obtained over the wire, since we added
180 // the torrent to the seeder by magnet.
181 DisableMetainfoCache: true,
183 seeder.SetIPBlockList(nil)
184 require.NoError(t, err)
186 testutil.ExportStatusWriter(seeder, "s")
187 _, err = seeder.AddMagnet(fmt.Sprintf("magnet:?xt=urn:btih:%x", layout.Metainfo.Info.Hash))
188 require.NoError(t, err)
189 leecher, err := torrent.NewClient(&torrent.Config{
190 DisableTrackers: true,
192 ListenAddr: "localhost:0",
195 NoDefaultBlocklist: true,
197 TorrentDataOpener: func(info *metainfo.Info) torrent.Data {
198 ret, _ := mmap.TorrentData(info, filepath.Join(layout.BaseDir, "download"))
202 // This can be used to check if clients can connect to other clients
205 // PeerID: seeder.PeerID(),
207 leecher.SetIPBlockList(nil)
208 testutil.ExportStatusWriter(leecher, "l")
209 defer leecher.Close()
210 leecherTorrent, _ := leecher.AddTorrent(layout.Metainfo)
211 leecherTorrent.AddPeers([]torrent.Peer{
213 IP: missinggo.AddrIP(seeder.ListenAddr()),
214 Port: missinggo.AddrPort(seeder.ListenAddr()),
220 node, _ := root.(fusefs.NodeStringLookuper).Lookup(netContext.Background(), "greeting")
222 node.Attr(netContext.Background(), &attr)
224 resp := &fuse.ReadResponse{
225 Data: make([]byte, size),
227 node.(fusefs.HandleReader).Read(netContext.Background(), &fuse.ReadRequest{
230 assert.EqualValues(t, testutil.GreetingFileContents, resp.Data)
233 func TestIsSubPath(t *testing.T) {
234 for _, case_ := range []struct {
240 {"a/b", "a/bc", false},
241 {"a/b", "a/b", false},
242 {"a/b", "a/b/c", true},
243 {"a/b", "a//b", false},
245 assert.Equal(t, case_.is, isSubPath(case_.parent, case_.child))