status-go/vendor/github.com/ethereum/go-ethereum/cmd/swarm/manifest.go

330 lines
8.6 KiB
Go
Raw Normal View History

// Copyright 2017 The go-ethereum Authors
2017-02-27 12:40:42 +00:00
// This file is part of go-ethereum.
//
// go-ethereum is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// go-ethereum is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
// Command MANIFEST update
package main
import (
"encoding/json"
"fmt"
2017-02-27 12:40:42 +00:00
"mime"
"path/filepath"
"strings"
"github.com/ethereum/go-ethereum/cmd/utils"
"github.com/ethereum/go-ethereum/swarm/api"
swarm "github.com/ethereum/go-ethereum/swarm/api/client"
"gopkg.in/urfave/cli.v1"
2017-02-27 12:40:42 +00:00
)
func add(ctx *cli.Context) {
args := ctx.Args()
if len(args) < 3 {
utils.Fatalf("Need atleast three arguments <MHASH> <path> <HASH> [<content-type>]")
2017-02-27 12:40:42 +00:00
}
var (
mhash = args[0]
path = args[1]
hash = args[2]
2017-02-27 12:40:42 +00:00
ctype string
2017-02-27 12:40:42 +00:00
wantManifest = ctx.GlobalBoolT(SwarmWantManifestFlag.Name)
mroot api.Manifest
2017-02-27 12:40:42 +00:00
)
if len(args) > 3 {
ctype = args[3]
} else {
ctype = mime.TypeByExtension(filepath.Ext(path))
}
newManifest := addEntryToManifest(ctx, mhash, path, hash, ctype)
2017-02-27 12:40:42 +00:00
fmt.Println(newManifest)
if !wantManifest {
// Print the manifest. This is the only output to stdout.
mrootJSON, _ := json.MarshalIndent(mroot, "", " ")
fmt.Println(string(mrootJSON))
return
}
}
func update(ctx *cli.Context) {
args := ctx.Args()
if len(args) < 3 {
utils.Fatalf("Need atleast three arguments <MHASH> <path> <HASH>")
2017-02-27 12:40:42 +00:00
}
var (
mhash = args[0]
path = args[1]
hash = args[2]
2017-02-27 12:40:42 +00:00
ctype string
2017-02-27 12:40:42 +00:00
wantManifest = ctx.GlobalBoolT(SwarmWantManifestFlag.Name)
mroot api.Manifest
2017-02-27 12:40:42 +00:00
)
if len(args) > 3 {
ctype = args[3]
} else {
ctype = mime.TypeByExtension(filepath.Ext(path))
}
newManifest := updateEntryInManifest(ctx, mhash, path, hash, ctype)
2017-02-27 12:40:42 +00:00
fmt.Println(newManifest)
if !wantManifest {
// Print the manifest. This is the only output to stdout.
mrootJSON, _ := json.MarshalIndent(mroot, "", " ")
fmt.Println(string(mrootJSON))
return
}
}
func remove(ctx *cli.Context) {
args := ctx.Args()
if len(args) < 2 {
utils.Fatalf("Need atleast two arguments <MHASH> <path>")
2017-02-27 12:40:42 +00:00
}
var (
mhash = args[0]
path = args[1]
2017-02-27 12:40:42 +00:00
wantManifest = ctx.GlobalBoolT(SwarmWantManifestFlag.Name)
mroot api.Manifest
2017-02-27 12:40:42 +00:00
)
newManifest := removeEntryFromManifest(ctx, mhash, path)
2017-02-27 12:40:42 +00:00
fmt.Println(newManifest)
if !wantManifest {
// Print the manifest. This is the only output to stdout.
mrootJSON, _ := json.MarshalIndent(mroot, "", " ")
fmt.Println(string(mrootJSON))
return
}
}
func addEntryToManifest(ctx *cli.Context, mhash, path, hash, ctype string) string {
2017-02-27 12:40:42 +00:00
var (
bzzapi = strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
client = swarm.NewClient(bzzapi)
longestPathEntry = api.ManifestEntry{}
2017-02-27 12:40:42 +00:00
)
mroot, err := client.DownloadManifest(mhash)
2017-02-27 12:40:42 +00:00
if err != nil {
utils.Fatalf("Manifest download failed: %v", err)
2017-02-27 12:40:42 +00:00
}
//TODO: check if the "hash" to add is valid and present in swarm
_, err = client.DownloadManifest(hash)
2017-02-27 12:40:42 +00:00
if err != nil {
utils.Fatalf("Hash to add is not present: %v", err)
2017-02-27 12:40:42 +00:00
}
// See if we path is in this Manifest or do we have to dig deeper
for _, entry := range mroot.Entries {
if path == entry.Path {
utils.Fatalf("Path %s already present, not adding anything", path)
} else {
2017-02-27 12:40:42 +00:00
if entry.ContentType == "application/bzz-manifest+json" {
prfxlen := strings.HasPrefix(path, entry.Path)
if prfxlen && len(path) > len(longestPathEntry.Path) {
longestPathEntry = entry
}
}
}
}
if longestPathEntry.Path != "" {
// Load the child Manifest add the entry there
newPath := path[len(longestPathEntry.Path):]
newHash := addEntryToManifest(ctx, longestPathEntry.Hash, newPath, hash, ctype)
2017-02-27 12:40:42 +00:00
// Replace the hash for parent Manifests
newMRoot := &api.Manifest{}
2017-02-27 12:40:42 +00:00
for _, entry := range mroot.Entries {
if longestPathEntry.Path == entry.Path {
entry.Hash = newHash
}
newMRoot.Entries = append(newMRoot.Entries, entry)
}
mroot = newMRoot
} else {
// Add the entry in the leaf Manifest
newEntry := api.ManifestEntry{
2017-02-27 12:40:42 +00:00
Hash: hash,
Path: path,
2017-02-27 12:40:42 +00:00
ContentType: ctype,
}
mroot.Entries = append(mroot.Entries, newEntry)
}
newManifestHash, err := client.UploadManifest(mroot)
2017-02-27 12:40:42 +00:00
if err != nil {
utils.Fatalf("Manifest upload failed: %v", err)
2017-02-27 12:40:42 +00:00
}
return newManifestHash
}
func updateEntryInManifest(ctx *cli.Context, mhash, path, hash, ctype string) string {
2017-02-27 12:40:42 +00:00
var (
bzzapi = strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
client = swarm.NewClient(bzzapi)
newEntry = api.ManifestEntry{}
longestPathEntry = api.ManifestEntry{}
2017-02-27 12:40:42 +00:00
)
mroot, err := client.DownloadManifest(mhash)
2017-02-27 12:40:42 +00:00
if err != nil {
utils.Fatalf("Manifest download failed: %v", err)
2017-02-27 12:40:42 +00:00
}
//TODO: check if the "hash" with which to update is valid and present in swarm
// See if we path is in this Manifest or do we have to dig deeper
for _, entry := range mroot.Entries {
if path == entry.Path {
newEntry = entry
} else {
2017-02-27 12:40:42 +00:00
if entry.ContentType == "application/bzz-manifest+json" {
prfxlen := strings.HasPrefix(path, entry.Path)
if prfxlen && len(path) > len(longestPathEntry.Path) {
longestPathEntry = entry
}
}
}
}
if longestPathEntry.Path == "" && newEntry.Path == "" {
utils.Fatalf("Path %s not present in the Manifest, not setting anything", path)
2017-02-27 12:40:42 +00:00
}
if longestPathEntry.Path != "" {
// Load the child Manifest add the entry there
newPath := path[len(longestPathEntry.Path):]
newHash := updateEntryInManifest(ctx, longestPathEntry.Hash, newPath, hash, ctype)
2017-02-27 12:40:42 +00:00
// Replace the hash for parent Manifests
newMRoot := &api.Manifest{}
2017-02-27 12:40:42 +00:00
for _, entry := range mroot.Entries {
if longestPathEntry.Path == entry.Path {
entry.Hash = newHash
}
newMRoot.Entries = append(newMRoot.Entries, entry)
}
mroot = newMRoot
}
if newEntry.Path != "" {
// Replace the hash for leaf Manifest
newMRoot := &api.Manifest{}
2017-02-27 12:40:42 +00:00
for _, entry := range mroot.Entries {
if newEntry.Path == entry.Path {
myEntry := api.ManifestEntry{
2017-02-27 12:40:42 +00:00
Hash: hash,
Path: entry.Path,
2017-02-27 12:40:42 +00:00
ContentType: ctype,
}
newMRoot.Entries = append(newMRoot.Entries, myEntry)
} else {
newMRoot.Entries = append(newMRoot.Entries, entry)
}
}
mroot = newMRoot
}
newManifestHash, err := client.UploadManifest(mroot)
2017-02-27 12:40:42 +00:00
if err != nil {
utils.Fatalf("Manifest upload failed: %v", err)
2017-02-27 12:40:42 +00:00
}
return newManifestHash
}
func removeEntryFromManifest(ctx *cli.Context, mhash, path string) string {
2017-02-27 12:40:42 +00:00
var (
bzzapi = strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
client = swarm.NewClient(bzzapi)
entryToRemove = api.ManifestEntry{}
longestPathEntry = api.ManifestEntry{}
2017-02-27 12:40:42 +00:00
)
mroot, err := client.DownloadManifest(mhash)
2017-02-27 12:40:42 +00:00
if err != nil {
utils.Fatalf("Manifest download failed: %v", err)
2017-02-27 12:40:42 +00:00
}
// See if we path is in this Manifest or do we have to dig deeper
for _, entry := range mroot.Entries {
if path == entry.Path {
entryToRemove = entry
} else {
2017-02-27 12:40:42 +00:00
if entry.ContentType == "application/bzz-manifest+json" {
prfxlen := strings.HasPrefix(path, entry.Path)
if prfxlen && len(path) > len(longestPathEntry.Path) {
longestPathEntry = entry
}
}
}
}
if longestPathEntry.Path == "" && entryToRemove.Path == "" {
utils.Fatalf("Path %s not present in the Manifest, not removing anything", path)
2017-02-27 12:40:42 +00:00
}
if longestPathEntry.Path != "" {
// Load the child Manifest remove the entry there
newPath := path[len(longestPathEntry.Path):]
newHash := removeEntryFromManifest(ctx, longestPathEntry.Hash, newPath)
2017-02-27 12:40:42 +00:00
// Replace the hash for parent Manifests
newMRoot := &api.Manifest{}
2017-02-27 12:40:42 +00:00
for _, entry := range mroot.Entries {
if longestPathEntry.Path == entry.Path {
entry.Hash = newHash
}
newMRoot.Entries = append(newMRoot.Entries, entry)
}
mroot = newMRoot
}
if entryToRemove.Path != "" {
// remove the entry in this Manifest
newMRoot := &api.Manifest{}
2017-02-27 12:40:42 +00:00
for _, entry := range mroot.Entries {
if entryToRemove.Path != entry.Path {
newMRoot.Entries = append(newMRoot.Entries, entry)
}
}
mroot = newMRoot
}
newManifestHash, err := client.UploadManifest(mroot)
2017-02-27 12:40:42 +00:00
if err != nil {
utils.Fatalf("Manifest upload failed: %v", err)
2017-02-27 12:40:42 +00:00
}
return newManifestHash
}