forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-18 09:53:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

swarm/...: Integrate encryption into swarm API

Browse source
This commit is contained in:
Balint Gabor 2018-03-30 17:19:33 +02:00
parent 167159bc3c
commit 9bd2e882e4
11 changed files with 551 additions and 485 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
swarm/api/api.go
View file

@ -39,7 +39,9 @@ import (
"github.com/ethereum/go-ethereum/swarm/storage"
)
var hashMatcher = regexp.MustCompile("^[0-9A-Fa-f]{64}")
// TODO: this is bad, it should not be hardcoded how long is a hash
var hashMatcher = regexp.MustCompile("^([0-9A-Fa-f]{64})([0-9A-Fa-f]{64})?")
type ErrResourceReturn struct {
key string
@ -230,9 +232,9 @@ func NewApi(dpa *storage.DPA, dns Resolver, resourceHandler *storage.ResourceHan
}
// to be used only in TEST
func (self *Api) Upload(uploadDir, index string) (hash string, err error) {
func (self *Api) Upload(uploadDir, index string, toEncrypt bool) (hash string, err error) {
fs := NewFileSystem(self)
hash, err = fs.Upload(uploadDir, index)
hash, err = fs.Upload(uploadDir, index, toEncrypt)
return hash, err
}
@ -241,9 +243,9 @@ func (self *Api) Retrieve(key storage.Key) storage.LazySectionReader {
return self.dpa.Retrieve(key)
}
func (self *Api) Store(data io.Reader, size int64) (key storage.Key, wait func(), err error) {
func (self *Api) Store(data io.Reader, size int64, toEncrypt bool) (key storage.Key, wait func(), err error) {
log.Debug("api.store", "size", size)
return self.dpa.Store(data, size, false)
return self.dpa.Store(data, size, toEncrypt)
}
type ErrResolve error
@ -283,17 +285,17 @@ func (self *Api) Resolve(uri *URI) (storage.Key, error) {
}
// Put provides singleton manifest creation on top of dpa store
func (self *Api) Put(content, contentType string) (k storage.Key, wait func(), err error) {
func (self *Api) Put(content, contentType string, toEncrypt bool) (k storage.Key, wait func(), err error) {
apiPutCount.Inc(1)
r := strings.NewReader(content)
key, waitContent, err := self.dpa.Store(r, int64(len(content)), false)
key, waitContent, err := self.dpa.Store(r, int64(len(content)), toEncrypt)
if err != nil {
apiPutFail.Inc(1)
return nil, nil, err
}
manifest := fmt.Sprintf(`{"entries":[{"hash":"%v","contentType":"%s"}]}`, key, contentType)
r = strings.NewReader(manifest)
key, waitManifest, err := self.dpa.Store(r, int64(len(manifest)), false)
key, waitManifest, err := self.dpa.Store(r, int64(len(manifest)), toEncrypt)
if err != nil {
apiPutFail.Inc(1)
return nil, nil, err

9
swarm/api/api_test.go
View file

@ -32,7 +32,7 @@ import (
"github.com/ethereum/go-ethereum/swarm/storage"
)
func testApi(t *testing.T, f func(*Api)) {
func testApi(t *testing.T, f func(*Api, bool)) {
datadir, err := ioutil.TempDir("", "bzz-test")
if err != nil {
t.Fatalf("unable to create temp dir: %v", err)
@ -43,7 +43,8 @@ func testApi(t *testing.T, f func(*Api)) {
return
}
api := NewApi(dpa, nil, nil)
f(api)
f(api, false)
f(api, true)
}
type testResponse struct {
@ -106,11 +107,11 @@ func testGet(t *testing.T, api *Api, bzzhash, path string) *testResponse {
}
func TestApiPut(t *testing.T) {
testApi(t, func(api *Api) {
testApi(t, func(api *Api, toEncrypt bool) {
content := "hello"
exp := expResponse(content, "text/plain", 0)
// exp := expResponse([]byte(content), "text/plain", 0)
key, wait, err := api.Put(content, exp.MimeType)
key, wait, err := api.Put(content, exp.MimeType, toEncrypt)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}

4
swarm/api/filesystem.go
View file

@ -47,7 +47,7 @@ func NewFileSystem(api *Api) *FileSystem {
// TODO: localpath should point to a manifest
//
// DEPRECATED: Use the HTTP API instead
func (self *FileSystem) Upload(lpath, index string) (string, error) {
func (self *FileSystem) Upload(lpath, index string, toEncrypt bool) (string, error) {
var list []*manifestTrieEntry
localpath, err := filepath.Abs(filepath.Clean(lpath))
if err != nil {
@ -114,7 +114,7 @@ func (self *FileSystem) Upload(lpath, index string) (string, error) {
stat, _ := f.Stat()
var hash storage.Key
var wait func()
hash, wait, err = self.api.dpa.Store(f, stat.Size(), false)
hash, wait, err = self.api.dpa.Store(f, stat.Size(), toEncrypt)
if hash != nil {
list[i].Hash = hash.Hex()
}

33
swarm/api/filesystem_test.go
View file

@ -29,9 +29,9 @@ import (
var testDownloadDir, _ = ioutil.TempDir(os.TempDir(), "bzz-test")
func testFileSystem(t *testing.T, f func(*FileSystem)) {
testApi(t, func(api *Api) {
f(NewFileSystem(api))
func testFileSystem(t *testing.T, f func(*FileSystem, bool)) {
testApi(t, func(api *Api, toEncrypt bool) {
f(NewFileSystem(api), toEncrypt)
})
}
@ -46,9 +46,9 @@ func readPath(t *testing.T, parts ...string) string {
}
func TestApiDirUpload0(t *testing.T) {
testFileSystem(t, func(fs *FileSystem) {
testFileSystem(t, func(fs *FileSystem, toEncrypt bool) {
api := fs.api
bzzhash, err := fs.Upload(filepath.Join("testdata", "test0"), "")
bzzhash, err := fs.Upload(filepath.Join("testdata", "test0"), "", toEncrypt)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
@ -74,20 +74,21 @@ func TestApiDirUpload0(t *testing.T) {
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
newbzzhash, err := fs.Upload(downloadDir, "")
newbzzhash, err := fs.Upload(downloadDir, "", toEncrypt)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if bzzhash != newbzzhash {
// TODO: currently the hash is not deterministic in the encrypted case
if !toEncrypt && bzzhash != newbzzhash {
t.Fatalf("download %v reuploaded has incorrect hash, expected %v, got %v", downloadDir, bzzhash, newbzzhash)
}
})
}
func TestApiDirUploadModify(t *testing.T) {
testFileSystem(t, func(fs *FileSystem) {
testFileSystem(t, func(fs *FileSystem, toEncrypt bool) {
api := fs.api
bzzhash, err := fs.Upload(filepath.Join("testdata", "test0"), "")
bzzhash, err := fs.Upload(filepath.Join("testdata", "test0"), "", toEncrypt)
if err != nil {
t.Errorf("unexpected error: %v", err)
return
@ -104,7 +105,7 @@ func TestApiDirUploadModify(t *testing.T) {
t.Errorf("unexpected error: %v", err)
return
}
hash, wait, err := api.Store(bytes.NewReader(index), int64(len(index)))
hash, wait, err := api.Store(bytes.NewReader(index), int64(len(index)), toEncrypt)
wait()
if err != nil {
t.Errorf("unexpected error: %v", err)
@ -144,9 +145,9 @@ func TestApiDirUploadModify(t *testing.T) {
}
func TestApiDirUploadWithRootFile(t *testing.T) {
testFileSystem(t, func(fs *FileSystem) {
testFileSystem(t, func(fs *FileSystem, toEncrypt bool) {
api := fs.api
bzzhash, err := fs.Upload(filepath.Join("testdata", "test0"), "index.html")
bzzhash, err := fs.Upload(filepath.Join("testdata", "test0"), "index.html", toEncrypt)
if err != nil {
t.Errorf("unexpected error: %v", err)
return
@ -160,9 +161,9 @@ func TestApiDirUploadWithRootFile(t *testing.T) {
}
func TestApiFileUpload(t *testing.T) {
testFileSystem(t, func(fs *FileSystem) {
testFileSystem(t, func(fs *FileSystem, toEncrypt bool) {
api := fs.api
bzzhash, err := fs.Upload(filepath.Join("testdata", "test0", "index.html"), "")
bzzhash, err := fs.Upload(filepath.Join("testdata", "test0", "index.html"), "", toEncrypt)
if err != nil {
t.Errorf("unexpected error: %v", err)
return
@ -176,9 +177,9 @@ func TestApiFileUpload(t *testing.T) {
}
func TestApiFileUploadWithRootFile(t *testing.T) {
testFileSystem(t, func(fs *FileSystem) {
testFileSystem(t, func(fs *FileSystem, toEncrypt bool) {
api := fs.api
bzzhash, err := fs.Upload(filepath.Join("testdata", "test0", "index.html"), "index.html")
bzzhash, err := fs.Upload(filepath.Join("testdata", "test0", "index.html"), "index.html", toEncrypt)
if err != nil {
t.Errorf("unexpected error: %v", err)
return

23
swarm/api/http/server.go
View file

@ -124,19 +124,30 @@ func (s *Server) HandlePostRaw(w http.ResponseWriter, r *Request) {
log.Debug("handle.post.raw", "ruid", r.ruid)
postRawCount.Inc(1)
toEncrypt := false
if r.uri.Addr == "encrypt" {
toEncrypt = true
}
if r.uri.Path != "" {
postRawFail.Inc(1)
Respond(w, r, "raw POST request cannot contain a path", http.StatusBadRequest)
return
}
if r.uri.Addr != "" && r.uri.Addr != "encrypt" {
postRawFail.Inc(1)
Respond(w, r, "raw POST request addr can only be empty or \"encrypt\"", http.StatusBadRequest)
return
}
if r.Header.Get("Content-Length") == "" {
postRawFail.Inc(1)
Respond(w, r, "missing Content-Length header in request", http.StatusBadRequest)
return
}
key, _, err := s.api.Store(r.Body, r.ContentLength)
key, _, err := s.api.Store(r.Body, r.ContentLength, toEncrypt)
if err != nil {
postRawFail.Inc(1)
Respond(w, r, err.Error(), http.StatusInternalServerError)
@ -176,7 +187,7 @@ func (s *Server) HandlePostFiles(w http.ResponseWriter, r *Request) {
}
log.Debug("resolved key", "ruid", r.ruid, "key", key)
} else {
key, err = s.api.NewManifest()
key, err = s.api.NewManifest(false)
if err != nil {
postFilesFail.Inc(1)
Respond(w, r, err.Error(), http.StatusInternalServerError)
@ -365,7 +376,7 @@ func (s *Server) HandlePostResource(w http.ResponseWriter, r *Request) {
Respond(w, r, err2.Error(), code)
return
}
m, err := s.api.NewResourceManifest(r.uri.Addr)
m, err := s.api.NewResourceManifest(r.uri.Addr, false)
if err != nil {
Respond(w, r, fmt.Sprintf("failed to create resource manifest: %v", err), http.StatusInternalServerError)
return
@ -840,14 +851,18 @@ func (s *Server) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
req.uri = uri
log.Debug("parsed request path", "ruid", req.ruid, "method", req.Method, "uri", req.uri)
log.Debug("parsed request path", "uri.Addr", req.uri.Addr, "uri.path", req.uri.Path, "uri.Scheme", req.uri.Scheme)
switch r.Method {
case "POST":
if uri.Raw() || uri.DeprecatedRaw() {
log.Debug("handlePostRaw")
s.HandlePostRaw(w, req)
} else if uri.Resource() {
log.Debug("handlePostResource")
s.HandlePostResource(w, req)
} else {
log.Debug("handlePostFiles")
s.HandlePostFiles(w, req)
}

6
swarm/api/http/server_test.go
View file

@ -218,7 +218,11 @@ func TestBzzResource(t *testing.T) {
}
func TestBzzGetPath(t *testing.T) {
// testBzzGetPath(false, t)
testBzzGetPath(true, t)
}
func testBzzGetPath(encrypted bool, t *testing.T) {
var err error
testmanifest := []string{
@ -246,7 +250,7 @@ func TestBzzGetPath(t *testing.T) {
for i, mf := range testmanifest {
reader[i] = bytes.NewReader([]byte(mf))
var wait func()
key[i], wait, err = srv.Dpa.Store(reader[i], int64(len(mf)), false)
key[i], wait, err = srv.Dpa.Store(reader[i], int64(len(mf)), encrypted)
if err != nil {
t.Fatal(err)
}

13
swarm/api/manifest.go
View file

@ -59,20 +59,20 @@ type ManifestList struct {
}
// NewManifest creates and stores a new, empty manifest
func (a *Api) NewManifest() (storage.Key, error) {
func (a *Api) NewManifest(toEncrypt bool) (storage.Key, error) {
var manifest Manifest
data, err := json.Marshal(&manifest)
if err != nil {
return nil, err
}
key, wait, err := a.Store(bytes.NewReader(data), int64(len(data)))
key, wait, err := a.Store(bytes.NewReader(data), int64(len(data)), toEncrypt)
wait()
return key, err
}
// Manifest hack for supporting Mutable Resource Updates from the bzz: scheme
// see swarm/api/api.go:Api.Get() for more information
func (a *Api) NewResourceManifest(resourceKey string) (storage.Key, error) {
func (a *Api) NewResourceManifest(resourceKey string, toEncrypt bool) (storage.Key, error) {
var manifest Manifest
entry := ManifestEntry{
Hash: resourceKey,
@ -83,7 +83,7 @@ func (a *Api) NewResourceManifest(resourceKey string) (storage.Key, error) {
if err != nil {
return nil, err
}
key, _, err := a.Store(bytes.NewReader(data), int64(len(data)))
key, _, err := a.Store(bytes.NewReader(data), int64(len(data)), toEncrypt)
return key, err
}
@ -104,7 +104,10 @@ func (a *Api) NewManifestWriter(key storage.Key, quitC chan bool) (*ManifestWrit
// AddEntry stores the given data and adds the resulting key to the manifest
func (m *ManifestWriter) AddEntry(data io.Reader, e *ManifestEntry) (storage.Key, error) {
key, _, err := m.api.Store(data, e.Size)
toEncrypt := (len(m.trie.hash) > m.trie.dpa.HashSize())
key, _, err := m.api.Store(data, e.Size, toEncrypt)
if err != nil {
return nil, err
}

4
swarm/api/storage.go
View file

@ -45,8 +45,8 @@ func NewStorage(api *Api) *Storage {
// its content type
//
// DEPRECATED: Use the HTTP API instead
func (self *Storage) Put(content, contentType string) (storage.Key, func(), error) {
return self.api.Put(content, contentType)
func (self *Storage) Put(content, contentType string, toEncrypt bool) (storage.Key, func(), error) {
return self.api.Put(content, contentType, toEncrypt)
}
// Get retrieves the content from bzzpath and reads the response in full

10
swarm/api/storage_test.go
View file

@ -20,18 +20,18 @@ import (
"testing"
)
func testStorage(t *testing.T, f func(*Storage)) {
testApi(t, func(api *Api) {
f(NewStorage(api))
func testStorage(t *testing.T, f func(*Storage, bool)) {
testApi(t, func(api *Api, toEncrypt bool) {
f(NewStorage(api), toEncrypt)
})
}
func TestStoragePutGet(t *testing.T) {
testStorage(t, func(api *Storage) {
testStorage(t, func(api *Storage, toEncrypt bool) {
content := "hello"
exp := expResponse(content, "text/plain", 0)
// exp := expResponse([]byte(content), "text/plain", 0)
bzzkey, wait, err := api.Put(content, exp.MimeType)
bzzkey, wait, err := api.Put(content, exp.MimeType, toEncrypt)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}

206
swarm/fuse/swarmfs_test.go
View file

@ -38,7 +38,7 @@ type fileInfo struct {
contents []byte
}
func createTestFilesAndUploadToSwarm(t *testing.T, api *api.Api, files map[string]fileInfo, uploadDir string) string {
func createTestFilesAndUploadToSwarm(t *testing.T, api *api.Api, files map[string]fileInfo, uploadDir string, toEncrypt bool) string {
os.RemoveAll(uploadDir)
for fname, finfo := range files {
@ -62,9 +62,9 @@ func createTestFilesAndUploadToSwarm(t *testing.T, api *api.Api, files map[strin
fd.Close()
}
bzzhash, err := api.Upload(uploadDir, "")
bzzhash, err := api.Upload(uploadDir, "", toEncrypt)
if err != nil {
t.Fatalf("Error uploading directory %v: %v", uploadDir, err)
t.Fatalf("Error uploading directory %v: %vm encryption: %v", uploadDir, err, toEncrypt)
}
return bzzhash
@ -171,7 +171,7 @@ func checkFile(t *testing.T, testMountDir, fname string, contents []byte) {
}
}
func getRandomBtes(size int) []byte {
func getRandomBytes(size int) []byte {
contents := make([]byte, size)
rand.Read(contents)
return contents
@ -198,23 +198,25 @@ func (ta *testAPI) mountListAndUnmount(t *testing.T) {
testUploadDir, _ := ioutil.TempDir(os.TempDir(), "fuse-source")
testMountDir, _ := ioutil.TempDir(os.TempDir(), "fuse-dest")
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["2.txt"] = fileInfo{0711, 333, 444, getRandomBtes(10)}
files["3.txt"] = fileInfo{0622, 333, 444, getRandomBtes(100)}
files["4.txt"] = fileInfo{0533, 333, 444, getRandomBtes(1024)}
files["5.txt"] = fileInfo{0544, 333, 444, getRandomBtes(10)}
files["6.txt"] = fileInfo{0555, 333, 444, getRandomBtes(10)}
files["7.txt"] = fileInfo{0666, 333, 444, getRandomBtes(10)}
files["8.txt"] = fileInfo{0777, 333, 333, getRandomBtes(10)}
files["11.txt"] = fileInfo{0777, 333, 444, getRandomBtes(10)}
files["111.txt"] = fileInfo{0777, 333, 444, getRandomBtes(10)}
files["two/2.txt"] = fileInfo{0777, 333, 444, getRandomBtes(10)}
files["two/2/2.txt"] = fileInfo{0777, 333, 444, getRandomBtes(10)}
files["two/2./2.txt"] = fileInfo{0777, 444, 444, getRandomBtes(10)}
files["twice/2.txt"] = fileInfo{0777, 444, 333, getRandomBtes(200)}
files["one/two/three/four/five/six/seven/eight/nine/10.txt"] = fileInfo{0777, 333, 444, getRandomBtes(10240)}
files["one/two/three/four/five/six/six"] = fileInfo{0777, 333, 444, getRandomBtes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["2.txt"] = fileInfo{0711, 333, 444, getRandomBytes(10)}
files["3.txt"] = fileInfo{0622, 333, 444, getRandomBytes(100)}
files["4.txt"] = fileInfo{0533, 333, 444, getRandomBytes(1024)}
files["5.txt"] = fileInfo{0544, 333, 444, getRandomBytes(10)}
files["6.txt"] = fileInfo{0555, 333, 444, getRandomBytes(10)}
files["7.txt"] = fileInfo{0666, 333, 444, getRandomBytes(10)}
files["8.txt"] = fileInfo{0777, 333, 333, getRandomBytes(10)}
files["11.txt"] = fileInfo{0777, 333, 444, getRandomBytes(10)}
files["111.txt"] = fileInfo{0777, 333, 444, getRandomBytes(10)}
files["two/2.txt"] = fileInfo{0777, 333, 444, getRandomBytes(10)}
files["two/2/2.txt"] = fileInfo{0777, 333, 444, getRandomBytes(10)}
files["two/2./2.txt"] = fileInfo{0777, 444, 444, getRandomBytes(10)}
files["twice/2.txt"] = fileInfo{0777, 444, 333, getRandomBytes(200)}
files["one/two/three/four/five/six/seven/eight/nine/10.txt"] = fileInfo{0777, 333, 444, getRandomBytes(10240)}
files["one/two/three/four/five/six/six"] = fileInfo{0777, 333, 444, getRandomBytes(10)}
for _, toEncrypt := range []bool{false, true} {
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir, toEncrypt)
swarmfs := mountDir(t, ta.api, files, bzzHash, testMountDir)
defer swarmfs.Stop()
@ -227,49 +229,55 @@ func (ta *testAPI) mountListAndUnmount(t *testing.T) {
if !isDirEmpty(testMountDir) {
t.Fatalf("unmount didnt work for %v", testMountDir)
}
}
}
func (ta *testAPI) maxMounts(t *testing.T) {
ta.runMaxMounts(false, t)
ta.runMaxMounts(true, t)
}
func (ta *testAPI) runMaxMounts(toEncrypt bool, t *testing.T) {
files := make(map[string]fileInfo)
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
uploadDir1, _ := ioutil.TempDir(os.TempDir(), "max-upload1")
bzzHash1 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir1)
bzzHash1 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir1, toEncrypt)
mount1, _ := ioutil.TempDir(os.TempDir(), "max-mount1")
swarmfs1 := mountDir(t, ta.api, files, bzzHash1, mount1)
defer swarmfs1.Stop()
files["2.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["2.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
uploadDir2, _ := ioutil.TempDir(os.TempDir(), "max-upload2")
bzzHash2 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir2)
bzzHash2 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir2, toEncrypt)
mount2, _ := ioutil.TempDir(os.TempDir(), "max-mount2")
swarmfs2 := mountDir(t, ta.api, files, bzzHash2, mount2)
defer swarmfs2.Stop()
files["3.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["3.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
uploadDir3, _ := ioutil.TempDir(os.TempDir(), "max-upload3")
bzzHash3 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir3)
bzzHash3 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir3, toEncrypt)
mount3, _ := ioutil.TempDir(os.TempDir(), "max-mount3")
swarmfs3 := mountDir(t, ta.api, files, bzzHash3, mount3)
defer swarmfs3.Stop()
files["4.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["4.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
uploadDir4, _ := ioutil.TempDir(os.TempDir(), "max-upload4")
bzzHash4 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir4)
bzzHash4 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir4, toEncrypt)
mount4, _ := ioutil.TempDir(os.TempDir(), "max-mount4")
swarmfs4 := mountDir(t, ta.api, files, bzzHash4, mount4)
defer swarmfs4.Stop()
files["5.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["5.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
uploadDir5, _ := ioutil.TempDir(os.TempDir(), "max-upload5")
bzzHash5 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir5)
bzzHash5 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir5, toEncrypt)
mount5, _ := ioutil.TempDir(os.TempDir(), "max-mount5")
swarmfs5 := mountDir(t, ta.api, files, bzzHash5, mount5)
defer swarmfs5.Stop()
files["6.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["6.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
uploadDir6, _ := ioutil.TempDir(os.TempDir(), "max-upload6")
bzzHash6 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir6)
bzzHash6 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir6, toEncrypt)
mount6, _ := ioutil.TempDir(os.TempDir(), "max-mount6")
os.RemoveAll(mount6)
@ -278,20 +286,20 @@ func (ta *testAPI) maxMounts(t *testing.T) {
if err == nil {
t.Fatalf("Error: Going beyond max mounts %v", bzzHash6)
}
}
func (ta *testAPI) remount(t *testing.T) {
for _, toEncrypt := range []bool{false, true} {
files := make(map[string]fileInfo)
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
uploadDir1, _ := ioutil.TempDir(os.TempDir(), "re-upload1")
bzzHash1 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir1)
bzzHash1 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir1, toEncrypt)
testMountDir1, _ := ioutil.TempDir(os.TempDir(), "re-mount1")
swarmfs := mountDir(t, ta.api, files, bzzHash1, testMountDir1)
defer swarmfs.Stop()
uploadDir2, _ := ioutil.TempDir(os.TempDir(), "re-upload2")
bzzHash2 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir2)
bzzHash2 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir2, toEncrypt)
testMountDir2, _ := ioutil.TempDir(os.TempDir(), "re-mount2")
// try mounting the same hash second time
@ -314,14 +322,16 @@ func (ta *testAPI) remount(t *testing.T) {
t.Fatalf("Error mounting hash %v", bzzHash2)
}
}
}
func (ta *testAPI) unmount(t *testing.T) {
for _, toEncrypt := range []bool{false, true} {
files := make(map[string]fileInfo)
uploadDir, _ := ioutil.TempDir(os.TempDir(), "ex-upload")
testMountDir, _ := ioutil.TempDir(os.TempDir(), "ex-mount")
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir)
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir, toEncrypt)
swarmfs := mountDir(t, ta.api, files, bzzHash, testMountDir)
defer swarmfs.Stop()
@ -335,21 +345,23 @@ func (ta *testAPI) unmount(t *testing.T) {
}
}
}
}
func (ta *testAPI) unmountWhenResourceBusy(t *testing.T) {
for _, toEncrypt := range []bool{false, true} {
files := make(map[string]fileInfo)
testUploadDir, _ := ioutil.TempDir(os.TempDir(), "ex-upload")
testMountDir, _ := ioutil.TempDir(os.TempDir(), "ex-mount")
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir, toEncrypt)
swarmfs := mountDir(t, ta.api, files, bzzHash, testMountDir)
defer swarmfs.Stop()
actualPath := filepath.Join(testMountDir, "2.txt")
d, err := os.OpenFile(actualPath, os.O_RDWR, os.FileMode(0700))
d.Write(getRandomBtes(10))
d.Write(getRandomBytes(10))
_, err = swarmfs.Unmount(testMountDir)
if err != nil {
@ -364,14 +376,16 @@ func (ta *testAPI) unmountWhenResourceBusy(t *testing.T) {
}
}
}
}
func (ta *testAPI) seekInMultiChunkFile(t *testing.T) {
for _, toEncrypt := range []bool{false, true} {
files := make(map[string]fileInfo)
testUploadDir, _ := ioutil.TempDir(os.TempDir(), "seek-upload")
testMountDir, _ := ioutil.TempDir(os.TempDir(), "seek-mount")
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10240)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10240)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir, toEncrypt)
swarmfs := mountDir(t, ta.api, files, bzzHash, testMountDir)
defer swarmfs.Stop()
@ -391,16 +405,18 @@ func (ta *testAPI) seekInMultiChunkFile(t *testing.T) {
}
d.Close()
}
}
func (ta *testAPI) createNewFile(t *testing.T) {
for _, toEncrypt := range []bool{false, true} {
files := make(map[string]fileInfo)
testUploadDir, _ := ioutil.TempDir(os.TempDir(), "create-upload")
testMountDir, _ := ioutil.TempDir(os.TempDir(), "create-mount")
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["five.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["six.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["five.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["six.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir, toEncrypt)
swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
defer swarmfs1.Stop()
@ -428,14 +444,16 @@ func (ta *testAPI) createNewFile(t *testing.T) {
checkFile(t, testMountDir, "2.txt", contents)
}
}
func (ta *testAPI) createNewFileInsideDirectory(t *testing.T) {
for _, toEncrypt := range []bool{false, true} {
files := make(map[string]fileInfo)
testUploadDir, _ := ioutil.TempDir(os.TempDir(), "createinsidedir-upload")
testMountDir, _ := ioutil.TempDir(os.TempDir(), "createinsidedir-mount")
files["one/1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
files["one/1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir, toEncrypt)
swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
defer swarmfs1.Stop()
@ -464,14 +482,16 @@ func (ta *testAPI) createNewFileInsideDirectory(t *testing.T) {
checkFile(t, testMountDir, "one/2.txt", contents)
}
}
func (ta *testAPI) createNewFileInsideNewDirectory(t *testing.T) {
for _, toEncrypt := range []bool{false, true} {
files := make(map[string]fileInfo)
testUploadDir, _ := ioutil.TempDir(os.TempDir(), "createinsidenewdir-upload")
testMountDir, _ := ioutil.TempDir(os.TempDir(), "createinsidenewdir-mount")
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir, toEncrypt)
swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
defer swarmfs1.Stop()
@ -501,16 +521,18 @@ func (ta *testAPI) createNewFileInsideNewDirectory(t *testing.T) {
checkFile(t, testMountDir, "one/2.txt", contents)
}
}
func (ta *testAPI) removeExistingFile(t *testing.T) {
for _, toEncrypt := range []bool{false, true} {
files := make(map[string]fileInfo)
testUploadDir, _ := ioutil.TempDir(os.TempDir(), "remove-upload")
testMountDir, _ := ioutil.TempDir(os.TempDir(), "remove-mount")
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["five.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["six.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["five.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["six.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir, toEncrypt)
swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
defer swarmfs1.Stop()
@ -529,16 +551,18 @@ func (ta *testAPI) removeExistingFile(t *testing.T) {
swarmfs2 := mountDir(t, ta.api, files, mi.LatestManifest, testMountDir)
defer swarmfs2.Stop()
}
}
func (ta *testAPI) removeExistingFileInsideDir(t *testing.T) {
for _, toEncrypt := range []bool{false, true} {
files := make(map[string]fileInfo)
testUploadDir, _ := ioutil.TempDir(os.TempDir(), "remove-upload")
testMountDir, _ := ioutil.TempDir(os.TempDir(), "remove-mount")
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["one/five.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["one/six.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["one/five.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["one/six.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir, toEncrypt)
swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
defer swarmfs1.Stop()
@ -557,17 +581,18 @@ func (ta *testAPI) removeExistingFileInsideDir(t *testing.T) {
swarmfs2 := mountDir(t, ta.api, files, mi.LatestManifest, testMountDir)
defer swarmfs2.Stop()
}
}
func (ta *testAPI) removeNewlyAddedFile(t *testing.T) {
for _, toEncrypt := range []bool{false, true} {
files := make(map[string]fileInfo)
testUploadDir, _ := ioutil.TempDir(os.TempDir(), "removenew-upload")
testMountDir, _ := ioutil.TempDir(os.TempDir(), "removenew-mount")
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["five.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["six.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["five.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["six.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir, toEncrypt)
swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
defer swarmfs1.Stop()
@ -602,16 +627,18 @@ func (ta *testAPI) removeNewlyAddedFile(t *testing.T) {
t.Fatalf("same contents different hash orig(%v): new(%v)", bzzHash, mi.LatestManifest)
}
}
}
func (ta *testAPI) addNewFileAndModifyContents(t *testing.T) {
for _, toEncrypt := range []bool{false, true} {
files := make(map[string]fileInfo)
testUploadDir, _ := ioutil.TempDir(os.TempDir(), "modifyfile-upload")
testMountDir, _ := ioutil.TempDir(os.TempDir(), "modifyfile-mount")
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["five.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["six.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["five.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["six.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir, toEncrypt)
swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
defer swarmfs1.Stop()
@ -672,16 +699,18 @@ func (ta *testAPI) addNewFileAndModifyContents(t *testing.T) {
checkFile(t, testMountDir, "2.txt", line1and2)
}
}
func (ta *testAPI) removeEmptyDir(t *testing.T) {
for _, toEncrypt := range []bool{false, true} {
files := make(map[string]fileInfo)
testUploadDir, _ := ioutil.TempDir(os.TempDir(), "rmdir-upload")
testMountDir, _ := ioutil.TempDir(os.TempDir(), "rmdir-mount")
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["five.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["six.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["five.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["six.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir, toEncrypt)
swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
defer swarmfs1.Stop()
@ -696,16 +725,18 @@ func (ta *testAPI) removeEmptyDir(t *testing.T) {
t.Fatalf("same contents different hash orig(%v): new(%v)", bzzHash, mi.LatestManifest)
}
}
}
func (ta *testAPI) removeDirWhichHasFiles(t *testing.T) {
for _, toEncrypt := range []bool{false, true} {
files := make(map[string]fileInfo)
testUploadDir, _ := ioutil.TempDir(os.TempDir(), "rmdir-upload")
testMountDir, _ := ioutil.TempDir(os.TempDir(), "rmdir-mount")
files["one/1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["two/five.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["two/six.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
files["one/1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["two/five.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["two/six.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir, toEncrypt)
swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
defer swarmfs1.Stop()
@ -725,20 +756,22 @@ func (ta *testAPI) removeDirWhichHasFiles(t *testing.T) {
swarmfs2 := mountDir(t, ta.api, files, mi.LatestManifest, testMountDir)
defer swarmfs2.Stop()
}
}
func (ta *testAPI) removeDirWhichHasSubDirs(t *testing.T) {
for _, toEncrypt := range []bool{false, true} {
files := make(map[string]fileInfo)
testUploadDir, _ := ioutil.TempDir(os.TempDir(), "rmsubdir-upload")
testMountDir, _ := ioutil.TempDir(os.TempDir(), "rmsubdir-mount")
files["one/1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["two/three/2.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["two/three/3.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["two/four/5.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["two/four/6.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["two/four/six/7.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
files["one/1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["two/three/2.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["two/three/3.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["two/four/5.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["two/four/6.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
files["two/four/six/7.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir, toEncrypt)
swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
defer swarmfs1.Stop()
@ -761,8 +794,10 @@ func (ta *testAPI) removeDirWhichHasSubDirs(t *testing.T) {
swarmfs2 := mountDir(t, ta.api, files, mi.LatestManifest, testMountDir)
defer swarmfs2.Stop()
}
}
func (ta *testAPI) appendFileContentsToEnd(t *testing.T) {
for _, toEncrypt := range []bool{false, true} {
files := make(map[string]fileInfo)
testUploadDir, _ := ioutil.TempDir(os.TempDir(), "appendlargefile-upload")
testMountDir, _ := ioutil.TempDir(os.TempDir(), "appendlargefile-mount")
@ -770,7 +805,7 @@ func (ta *testAPI) appendFileContentsToEnd(t *testing.T) {
line1 := make([]byte, 10)
rand.Read(line1)
files["1.txt"] = fileInfo{0700, 333, 444, line1}
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir, toEncrypt)
swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
defer swarmfs1.Stop()
@ -800,6 +835,7 @@ func (ta *testAPI) appendFileContentsToEnd(t *testing.T) {
checkFile(t, testMountDir, "1.txt", line1and2)
}
}
func TestFUSE(t *testing.T) {
datadir, err := ioutil.TempDir("", "fuse")

4
swarm/storage/dpa.go
View file

@ -100,3 +100,7 @@ func (self *DPA) Store(data io.Reader, size int64, toEncrypt bool) (key Key, wai
putter := NewHasherStore(self.ChunkStore, self.hashFunc, toEncrypt)
return PyramidSplit(data, putter, putter)
}
func (self *DPA) HashSize() int {
return self.hashFunc().Size()
}