FedP2P/fs/torrentfs_test.go

273 lines
6.3 KiB
Go
Raw Normal View History

package torrentfs
import (
"bytes"
2014-06-28 17:38:31 +08:00
"fmt"
"io/ioutil"
2015-04-07 23:43:50 +08:00
"log"
"net"
2014-08-21 16:07:06 +08:00
"net/http"
_ "net/http/pprof"
"os"
"path/filepath"
"strconv"
"strings"
"testing"
2015-01-11 10:21:14 +08:00
"time"
"bazil.org/fuse"
fusefs "bazil.org/fuse/fs"
_ "github.com/anacrolix/envpprof"
2015-08-03 22:29:01 +08:00
"github.com/anacrolix/missinggo"
"github.com/stretchr/testify/assert"
netContext "golang.org/x/net/context"
"github.com/anacrolix/torrent"
"github.com/anacrolix/torrent/data/mmap"
"github.com/anacrolix/torrent/internal/testutil"
2015-04-29 22:31:34 +08:00
"github.com/anacrolix/torrent/metainfo"
)
2015-04-07 23:43:50 +08:00
func init() {
log.SetFlags(log.Flags() | log.Lshortfile)
}
func TestTCPAddrString(t *testing.T) {
2014-11-20 10:01:03 +08:00
l, err := net.Listen("tcp4", "localhost:0")
if err != nil {
t.Fatal(err)
}
defer l.Close()
c, err := net.Dial("tcp", l.Addr().String())
if err != nil {
t.Fatal(err)
}
defer c.Close()
ras := c.RemoteAddr().String()
2014-11-20 10:01:03 +08:00
ta := &net.TCPAddr{
IP: net.IPv4(127, 0, 0, 1),
2015-08-03 22:29:01 +08:00
Port: missinggo.AddrPort(l.Addr()),
2014-11-20 10:01:03 +08:00
}
s := ta.String()
if ras != s {
t.FailNow()
}
}
2014-04-17 14:37:54 +08:00
type testLayout struct {
BaseDir string
MountDir string
Completed string
Metainfo *metainfo.MetaInfo
}
func (me *testLayout) Destroy() error {
return os.RemoveAll(me.BaseDir)
}
func newGreetingLayout() (tl testLayout, err error) {
tl.BaseDir, err = ioutil.TempDir("", "torrentfs")
if err != nil {
return
}
tl.Completed = filepath.Join(tl.BaseDir, "completed")
os.Mkdir(tl.Completed, 0777)
tl.MountDir = filepath.Join(tl.BaseDir, "mnt")
os.Mkdir(tl.MountDir, 0777)
name := testutil.CreateDummyTorrentData(tl.Completed)
metaInfoBuf := &bytes.Buffer{}
testutil.CreateMetaInfo(name, metaInfoBuf)
tl.Metainfo, err = metainfo.Load(metaInfoBuf)
return
}
2014-12-04 02:53:10 +08:00
// Unmount without first killing the FUSE connection while there are FUSE
// operations blocked inside the filesystem code.
2014-04-17 14:37:54 +08:00
func TestUnmountWedged(t *testing.T) {
layout, err := newGreetingLayout()
if err != nil {
t.Fatal(err)
}
defer func() {
2014-04-17 14:37:54 +08:00
err := layout.Destroy()
if err != nil {
t.Log(err)
}
}()
2014-08-21 16:07:06 +08:00
client, err := torrent.NewClient(&torrent.Config{
2014-04-17 14:37:54 +08:00
DataDir: filepath.Join(layout.BaseDir, "incomplete"),
DisableTrackers: true,
2014-08-21 16:07:06 +08:00
NoDHT: true,
ListenAddr: "redonk",
DisableTCP: true,
DisableUTP: true,
NoDefaultBlocklist: true,
2014-08-21 16:07:06 +08:00
})
if err != nil {
t.Fatal(err)
}
2015-03-08 14:28:14 +08:00
defer client.Close()
2014-04-17 14:37:54 +08:00
client.AddTorrent(layout.Metainfo)
2014-08-21 16:07:06 +08:00
fs := New(client)
2014-04-17 14:37:54 +08:00
fuseConn, err := fuse.Mount(layout.MountDir)
if err != nil {
msg := fmt.Sprintf("error mounting: %s", err)
if strings.Contains(err.Error(), "fuse") || err.Error() == "exit status 71" {
t.Skip(msg)
}
t.Fatal(msg)
2014-04-17 14:37:54 +08:00
}
go func() {
server := fusefs.New(fuseConn, &fusefs.Config{
2014-04-17 14:37:54 +08:00
Debug: func(msg interface{}) {
2014-12-04 02:53:10 +08:00
t.Log(msg)
2014-04-17 14:37:54 +08:00
},
})
server.Serve(fs)
2014-04-17 14:37:54 +08:00
}()
2015-01-11 10:21:14 +08:00
<-fuseConn.Ready
if err := fuseConn.MountError; err != nil {
t.Fatalf("mount error: %s", err)
2015-01-11 10:21:14 +08:00
}
2014-12-04 02:53:10 +08:00
// Read the greeting file, though it will never be available. This should
// "wedge" FUSE, requiring the fs object to be forcibly destroyed. The
// read call will return with a FS error.
2014-04-17 14:37:54 +08:00
go func() {
2014-12-04 02:53:10 +08:00
_, err := ioutil.ReadFile(filepath.Join(layout.MountDir, layout.Metainfo.Info.Name))
if err == nil {
t.Fatal("expected error reading greeting")
}
2014-04-17 14:37:54 +08:00
}()
2014-12-04 02:53:10 +08:00
// Wait until the read has blocked inside the filesystem code.
fs.mu.Lock()
for fs.blockedReads != 1 {
fs.event.Wait()
}
fs.mu.Unlock()
2014-04-17 14:37:54 +08:00
fs.Destroy()
2014-12-04 02:53:10 +08:00
for {
err = fuse.Unmount(layout.MountDir)
if err != nil {
t.Logf("error unmounting: %s", err)
2015-01-11 10:21:14 +08:00
time.Sleep(time.Millisecond)
2014-12-04 02:53:10 +08:00
} else {
break
}
2014-04-17 14:37:54 +08:00
}
2014-12-04 02:53:10 +08:00
2014-04-17 14:37:54 +08:00
err = fuseConn.Close()
if err != nil {
2014-12-04 02:53:10 +08:00
t.Fatalf("error closing fuse conn: %s", err)
2014-04-17 14:37:54 +08:00
}
}
func TestDownloadOnDemand(t *testing.T) {
layout, err := newGreetingLayout()
if err != nil {
t.Fatal(err)
}
2014-12-04 02:53:10 +08:00
defer layout.Destroy()
2014-08-21 16:07:06 +08:00
seeder, err := torrent.NewClient(&torrent.Config{
DataDir: layout.Completed,
2014-06-28 17:38:31 +08:00
DisableTrackers: true,
2014-08-21 16:07:06 +08:00
NoDHT: true,
ListenAddr: ":0",
2015-06-16 14:57:47 +08:00
Seed: true,
NoDefaultBlocklist: true,
// Ensure that the metainfo is obtained over the wire, since we added
// the torrent to the seeder by magnet.
DisableMetainfoCache: true,
2014-08-21 16:07:06 +08:00
})
if err != nil {
t.Fatalf("error creating seeder client: %s", err)
}
2014-12-01 17:28:39 +08:00
seeder.SetIPBlockList(nil)
2015-03-08 14:28:14 +08:00
defer seeder.Close()
2014-08-21 16:07:06 +08:00
http.HandleFunc("/seeder", func(w http.ResponseWriter, req *http.Request) {
seeder.WriteStatus(w)
})
_, err = seeder.AddMagnet(fmt.Sprintf("magnet:?xt=urn:btih:%x", layout.Metainfo.Info.Hash))
2014-06-28 17:38:31 +08:00
if err != nil {
t.Fatal(err)
}
2014-08-21 16:07:06 +08:00
leecher, err := torrent.NewClient(&torrent.Config{
DisableTrackers: true,
NoDHT: true,
ListenAddr: ":0",
DisableTCP: true,
NoDefaultBlocklist: true,
2015-10-01 22:16:50 +08:00
TorrentDataOpener: func(info *metainfo.Info) torrent.Data {
ret, _ := mmap.TorrentData(info, filepath.Join(layout.BaseDir, "download"))
return ret
},
// This can be used to check if clients can connect to other clients
// with the same ID.
// PeerID: seeder.PeerID(),
2014-08-21 16:07:06 +08:00
})
2014-12-01 17:28:39 +08:00
leecher.SetIPBlockList(nil)
2014-08-21 16:07:06 +08:00
http.HandleFunc("/leecher", func(w http.ResponseWriter, req *http.Request) {
leecher.WriteStatus(w)
})
2015-03-08 14:28:14 +08:00
defer leecher.Close()
leecherTorrent, _ := leecher.AddTorrent(layout.Metainfo)
leecherTorrent.AddPeers([]torrent.Peer{func() torrent.Peer {
_, port, err := net.SplitHostPort(seeder.ListenAddr().String())
if err != nil {
panic(err)
}
portInt64, err := strconv.ParseInt(port, 0, 0)
if err != nil {
panic(err)
}
return torrent.Peer{
IP: func() net.IP {
ret, _ := net.ResolveIPAddr("ip", "localhost")
return ret.IP
}(),
Port: int(portInt64),
}
}()})
2014-08-21 16:07:06 +08:00
fs := New(leecher)
2014-11-21 02:50:53 +08:00
defer fs.Destroy()
root, _ := fs.Root()
2015-06-02 22:14:55 +08:00
node, _ := root.(fusefs.NodeStringLookuper).Lookup(netContext.Background(), "greeting")
2015-03-25 14:25:24 +08:00
var attr fuse.Attr
node.Attr(netContext.Background(), &attr)
2015-03-25 14:25:24 +08:00
size := attr.Size
2014-11-21 02:50:53 +08:00
resp := &fuse.ReadResponse{
Data: make([]byte, size),
}
2015-06-02 22:14:55 +08:00
node.(fusefs.HandleReader).Read(netContext.Background(), &fuse.ReadRequest{
2015-03-25 14:25:24 +08:00
Size: int(size),
}, resp)
2014-11-21 02:50:53 +08:00
content := resp.Data
if string(content) != testutil.GreetingFileContents {
2015-04-07 23:43:50 +08:00
t.Fatalf("%q != %q", string(content), testutil.GreetingFileContents)
}
}
func TestIsSubPath(t *testing.T) {
for _, case_ := range []struct {
parent, child string
is bool
}{
{"", "", false},
{"", "/", true},
{"a/b", "a/bc", false},
{"a/b", "a/b", false},
{"a/b", "a/b/c", true},
{"a/b", "a//b", false},
} {
assert.Equal(t, case_.is, isSubPath(case_.parent, case_.child))
}
}