coosld/kubo
1
0
Fork 0
mirror of https://github.com/ipfs/kubo.git synced 2026-02-21 10:27:46 +08:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

big squash commit

Browse Source 
excerpt of commit messages:
- update postrun functions in core/commands
- sharness: allow setting -i with TEST_IMMEDIATE=1
- cmds Run func returns error now
- gx update cmdkit to 1.1.2 and cmds to 2.0.0-beta1

License: MIT
Signed-off-by: keks <keks@cryptoscope.co>
This commit is contained in:
keks 2018-04-13 16:14:30 +02:00 committed by Steven Allen
parent 61f31e5dc0
commit 908ffddc1b
38 changed files with 489 additions and 647 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
cmd/ipfs/daemon.go
View File

@ -21,12 +21,12 @@ import (
fsrepo "github.com/ipfs/go-ipfs/repo/fsrepo"
migrate "github.com/ipfs/go-ipfs/repo/fsrepo/migrations"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
mprome "gx/ipfs/QmUHHsirrDtP6WEHhE8SZeG672CLqDJn6XGzAHnvBHUiA3/go-metrics-prometheus"
"gx/ipfs/QmV6FjemM1K8oXjrvuq3wuVWWoU2TLDPmNnKrxHzY3v6Ai/go-multiaddr-net"
"gx/ipfs/QmYYv3QFnfQbiwmi1tpkgKF8o4xFnZoBrvpupTiGJwL9nH/client_golang/prometheus"
ma "gx/ipfs/QmYmsdtJ3HsodkePE3eU3TsCaP2YvPZJ4LoXnNkDE5Tpt7/go-multiaddr"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
const (
@ -184,11 +184,11 @@ func defaultMux(path string) corehttp.ServeOption {
}
}
func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) {
func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) error {
// Inject metrics before we do anything
err := mprome.Inject()
if err != nil {
log.Errorf("Injecting prometheus handler for metrics failed with message: %s\n", err.Error())
return fmt.Errorf("Injecting prometheus handler for metrics failed with message %s", err.Error())
}
// let the user know we're going.
@ -227,8 +227,7 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment
err := initWithDefaults(os.Stdout, cfg, profiles)
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
}
}
@ -238,8 +237,7 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment
repo, err := fsrepo.Open(cctx.ConfigRoot)
switch err {
default:
re.SetError(err, cmdkit.ErrNormal)
return
return err
case fsrepo.ErrNeedMigration:
domigrate, found := req.Options[migrateKwd].(bool)
fmt.Println("Found outdated fs-repo, migrations need to be run.")
@ -251,8 +249,7 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment
if !domigrate {
fmt.Println("Not running migrations of fs-repo now.")
fmt.Println("Please get fs-repo-migrations from https://dist.ipfs.io")
re.SetError(fmt.Errorf("fs-repo requires migration"), cmdkit.ErrNormal)
return
return fmt.Errorf("fs-repo requires migration")
}
err = migrate.RunMigration(fsrepo.RepoVersion)
@ -261,14 +258,12 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment
fmt.Printf(" %s\n", err)
fmt.Println("If you think this is a bug, please file an issue and include this whole log output.")
fmt.Println(" https://github.com/ipfs/fs-repo-migrations")
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
repo, err = fsrepo.Open(cctx.ConfigRoot)
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
case nil:
break
@ -276,8 +271,7 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment
cfg, err := cctx.GetConfig()
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
offline, _ := req.Options[offlineKwd].(bool)
@ -303,8 +297,7 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment
if routingOption == routingOptionDefaultKwd {
cfg, err := repo.Config()
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
routingOption = cfg.Routing.Type
@ -314,8 +307,7 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment
}
switch routingOption {
case routingOptionSupernodeKwd:
re.SetError(errors.New("supernode routing was never fully implemented and has been removed"), cmdkit.ErrNormal)
return
return errors.New("supernode routing was never fully implemented and has been removed")
case routingOptionDHTClientKwd:
ncfg.Routing = core.DHTClientOption
case routingOptionDHTKwd:
@ -323,15 +315,13 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment
case routingOptionNoneKwd:
ncfg.Routing = core.NilRouterOption
default:
re.SetError(fmt.Errorf("unrecognized routing option: %s", routingOption), cmdkit.ErrNormal)
return
return fmt.Errorf("unrecognized routing option: %s", routingOption)
}
node, err := core.NewNode(req.Context, ncfg)
if err != nil {
log.Error("error from node construction: ", err)
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
node.SetLocal(false)
@ -361,29 +351,24 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment
// construct api endpoint - every time
apiErrc, err := serveHTTPApi(req, cctx)
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
// construct fuse mountpoints - if the user provided the --mount flag
mount, _ := req.Options[mountKwd].(bool)
if mount && offline {
re.SetError(errors.New("mount is not currently supported in offline mode"),
cmdkit.ErrClient)
return
return cmdkit.Errorf(cmdkit.ErrClient, "mount is not currently supported in offline mode")
}
if mount {
if err := mountFuse(req, cctx); err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
}
// repo blockstore GC - if --enable-gc flag is present
gcErrc, err := maybeRunGC(req, node)
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
// construct http gateway - if it is set in the config
@ -392,8 +377,7 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment
var err error
gwErrc, err = serveHTTPGateway(req, cctx)
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
}
@ -405,10 +389,11 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment
// TODO(cryptix): our fuse currently doesnt follow this pattern for graceful shutdown
for err := range merge(apiErrc, gwErrc, gcErrc) {
if err != nil {
log.Error(err)
re.SetError(err, cmdkit.ErrNormal)
return err
}
}
return nil
}
// serveHTTPApi collects options, creates listener, prints status message and starts serving requests

18
cmd/ipfs/init.go
View File

@ -16,9 +16,9 @@ import (
namesys "github.com/ipfs/go-ipfs/namesys"
fsrepo "github.com/ipfs/go-ipfs/repo/fsrepo"
"gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
"gx/ipfs/QmYVqYJTVjetcf1guieEgWpK1PZtHPytP624vKzTF1P3r2/go-ipfs-config"
"gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
const (
@ -72,11 +72,10 @@ environment variable:
return nil
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
cctx := env.(*oldcmds.Context)
if cctx.Online {
res.SetError(errors.New("init must be run offline only"), cmdkit.ErrNormal)
return
return cmdkit.Error{Message: "init must be run offline only"}
}
empty, _ := req.Options["empty-repo"].(bool)
@ -88,14 +87,12 @@ environment variable:
if f != nil {
confFile, err := f.NextFile()
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
conf = &config.Config{}
if err := json.NewDecoder(confFile).Decode(conf); err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
}
@ -106,10 +103,7 @@ environment variable:
profiles = strings.Split(profile, ",")
}
if err := doInit(os.Stdout, cctx.ConfigRoot, empty, nBitsForKeypair, profiles, conf); err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
}
return doInit(os.Stdout, cctx.ConfigRoot, empty, nBitsForKeypair, profiles, conf)
},
}

2
cmd/ipfs/ipfs.go
View File

@ -5,7 +5,7 @@ import (
commands "github.com/ipfs/go-ipfs/core/commands"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
// This is the CLI root, used for executing commands accessible to CLI clients.

6
cmd/ipfs/main.go
View File

@ -24,9 +24,6 @@ import (
repo "github.com/ipfs/go-ipfs/repo"
fsrepo "github.com/ipfs/go-ipfs/repo/fsrepo"
"gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
"gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds/cli"
"gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds/http"
u "gx/ipfs/QmPdKqUcHGFdeSpvjVoaTRPPstGif9GBZb5Q56RVw9o69A/go-ipfs-util"
logging "gx/ipfs/QmRREK2CAZ5Re2Bd9zZFG6FeYDppUWt5cMgsoUEp3ktgSr/go-log"
manet "gx/ipfs/QmV6FjemM1K8oXjrvuq3wuVWWoU2TLDPmNnKrxHzY3v6Ai/go-multiaddr-net"
@ -34,6 +31,9 @@ import (
"gx/ipfs/QmYVqYJTVjetcf1guieEgWpK1PZtHPytP624vKzTF1P3r2/go-ipfs-config"
ma "gx/ipfs/QmYmsdtJ3HsodkePE3eU3TsCaP2YvPZJ4LoXnNkDE5Tpt7/go-multiaddr"
loggables "gx/ipfs/QmZ4zF1mBrt8C2mSCM4ZYE4aAnv78f7GvrzufJC4G5tecK/go-libp2p-loggables"
"gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
"gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds/cli"
"gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds/http"
madns "gx/ipfs/QmfXU2MhWoegxHoeMd3A2ytL2P6CY4FfqGWc23LTNWBwZt/go-multiaddr-dns"
)

12
commands/legacy/command.go
View File

@ -3,10 +3,10 @@ package legacy
import (
"io"
"gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
oldcmds "github.com/ipfs/go-ipfs/commands"
logging "gx/ipfs/QmRREK2CAZ5Re2Bd9zZFG6FeYDppUWt5cMgsoUEp3ktgSr/go-log"
"gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
var log = logging.Logger("cmds/lgc")
@ -29,17 +29,15 @@ func NewCommand(oldcmd *oldcmds.Command) *cmds.Command {
}
if oldcmd.Run != nil {
cmd.Run = func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) {
cmd.Run = func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) error {
oldReq := &requestWrapper{req, OldContext(env)}
res := &fakeResponse{req: oldReq, re: re, wait: make(chan struct{})}
errCh := make(chan error)
go res.Send(errCh)
oldcmd.Run(oldReq, res)
err := <-errCh
if err != nil {
log.Error(err)
}
return <-errCh
}
}

2
commands/legacy/legacy.go
View File

@ -4,7 +4,7 @@ import (
"io"
"runtime/debug"
"gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
"gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
oldcmds "github.com/ipfs/go-ipfs/commands"
)

64
commands/legacy/legacy_test.go
View File

@ -7,8 +7,8 @@ import (
"testing"
oldcmds "github.com/ipfs/go-ipfs/commands"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
cmdkit "gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
type WriteNopCloser struct {
@ -80,7 +80,7 @@ func TestNewCommand(t *testing.T) {
root.Call(req, re, &env)
expected := `{"Value":"Test."}
expected := `"Test."
`
if buf.String() != expected {
@ -114,7 +114,7 @@ func TestNewCommand(t *testing.T) {
}
func TestPipePair(t *testing.T) {
cmd := &cmds.Command{Type: "string"}
cmd := NewCommand(&oldcmds.Command{Type: "string"})
req, err := cmds.NewRequest(context.TODO(), nil, nil, nil, nil, cmd)
if err != nil {
@ -134,6 +134,11 @@ func TestPipePair(t *testing.T) {
t.Fatal(err)
}
err = re.Close()
if err != nil {
t.Fatal(err)
}
close(wait)
}()
@ -149,6 +154,57 @@ func TestPipePair(t *testing.T) {
t.Fatalf("expected value %#v but got %#v", expect, v)
}
<-wait
_, err = res.Next()
if err != io.EOF {
t.Fatal("expected io.EOF, got:", err)
}
<-wait
}
func TestChanPair(t *testing.T) {
cmd := NewCommand(&oldcmds.Command{Type: "string"})
req, err := cmds.NewRequest(context.TODO(), nil, nil, nil, nil, cmd)
if err != nil {
t.Fatal(err)
}
re, res := cmds.NewChanResponsePair(req)
wait := make(chan interface{})
expect := "abc"
go func() {
err := re.Emit(expect)
if err != nil {
t.Fatal(err)
}
err = re.Close()
if err != nil {
t.Fatal(err)
}
close(wait)
}()
v, err := res.Next()
if err != nil {
t.Fatal(err)
}
str, ok := v.(string)
if !ok {
t.Fatalf("expected type %T but got %T", expect, v)
}
if str != expect {
t.Fatalf("expected value %#v but got %#v", expect, v)
}
_, err = res.Next()
if err != io.EOF {
t.Fatal("expected io.EOF, got:", err)
}
<-wait
}

2
commands/legacy/request.go
View File

@ -7,9 +7,9 @@ import (
"os"
"reflect"
"gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit/files"
"gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
oldcmds "github.com/ipfs/go-ipfs/commands"
)

20
commands/legacy/response.go
View File

@ -7,8 +7,8 @@ import (
"reflect"
"sync"
"gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
"gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
oldcmds "github.com/ipfs/go-ipfs/commands"
)
@ -34,7 +34,10 @@ func (rw *responseWrapper) Output() interface{} {
// get first emitted value
x, err := rw.Next()
if err != nil {
return nil
ch := make(chan interface{})
log.Error(err)
close(ch)
return (<-chan interface{})(ch)
}
if e, ok := x.(*cmdkit.Error); ok {
ch := make(chan interface{})
@ -120,16 +123,13 @@ func (r *fakeResponse) Send(errCh chan<- error) {
defer close(errCh)
out := r.Output()
if out == nil {
// don't emit nil or Single{nil}
if out == nil || out == (cmds.Single{Value: nil}) {
return
}
if ch, ok := out.(chan interface{}); ok {
out = (<-chan interface{})(ch)
}
err := r.re.Emit(out)
errCh <- err
errCh <- r.re.Emit(out)
return
}
@ -141,7 +141,7 @@ func (r *fakeResponse) Request() oldcmds.Request {
// SetError forwards the call to the underlying ResponseEmitter
func (r *fakeResponse) SetError(err error, code cmdkit.ErrorType) {
defer r.once.Do(func() { close(r.wait) })
r.re.SetError(err, code)
r.re.CloseWithError(cmdkit.Errorf(code, err.Error()))
}
// Error is an empty stub

2
commands/request.go
View File

@ -10,10 +10,10 @@ import (
coreapi "github.com/ipfs/go-ipfs/core/coreapi"
coreiface "github.com/ipfs/go-ipfs/core/coreapi/interface"
"gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit/files"
config "gx/ipfs/QmYVqYJTVjetcf1guieEgWpK1PZtHPytP624vKzTF1P3r2/go-ipfs-config"
"gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
type Context struct {

104
core/commands/add.go
View File

@ -1,7 +1,6 @@
package commands
import (
"errors"
"fmt"
"io"
"os"
@ -16,13 +15,13 @@ import (
dagtest "gx/ipfs/QmXv5mwmQ74r4aiHcNeQ4GAmfB3aWJuqaE4WyDfDfvkgLM/go-merkledag/test"
blockservice "gx/ipfs/Qma2KhbQarYTkmSJAeaMGRAg8HAXAhEWK8ge4SReG7ZSD3/go-blockservice"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
mh "gx/ipfs/QmPnFwZ2JXKnXgMw8CdBPxn7FWh6LLdjUjxV1fKHuJnkr8/go-multihash"
pb "gx/ipfs/QmPtj12fdwuAqj9sBSTNUxBNu8kCGNp8b3o8yUzMm5GHpq/pb"
cidutil "gx/ipfs/QmQJSeE3CX4zos9qeaG8EhecEK9zvrTEfTG84J8C5NVRwt/go-cidutil"
mfs "gx/ipfs/QmRkrpnhZqDxTxwGCsDbuZMr7uCFZHH6SGfrcjgEQwxF3t/go-mfs"
cmdkit "gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
files "gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit/files"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
offline "gx/ipfs/QmcRC35JF2pJQneAxa5LdQBQRumWggccWErogSrCkS1h8T/go-ipfs-exchange-offline"
bstore "gx/ipfs/QmegPGspn3RpTMQ23Fd3GVVMopo1zsEMurudbFMZ5UXBLH/go-ipfs-blockstore"
)
@ -148,17 +147,15 @@ You can now check what blocks have been created by:
return nil
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
n, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
cfg, err := n.Repo.Config()
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
// check if repo will exceed storage limit if added
// TODO: this doesn't handle the case if the hashed file is already in blocks (deduplicated)
@ -195,19 +192,14 @@ You can now check what blocks have been created by:
// nocopy -> filestoreEnabled
if nocopy && !cfg.Experimental.FilestoreEnabled {
res.SetError(filestore.ErrFilestoreNotEnabled, cmdkit.ErrClient)
return
return cmdkit.Errorf(cmdkit.ErrClient, filestore.ErrFilestoreNotEnabled.Error())
}
// nocopy -> rawblocks
if nocopy && !rawblks {
// fixed?
if rbset {
res.SetError(
fmt.Errorf("nocopy option requires '--raw-leaves' to be enabled as well"),
cmdkit.ErrNormal,
)
return
return fmt.Errorf("nocopy option requires '--raw-leaves' to be enabled as well")
}
// No, satisfy mandatory constraint.
rawblks = true
@ -216,11 +208,7 @@ You can now check what blocks have been created by:
// (hash != "sha2-256") -> CIDv1
if hashFunStr != "sha2-256" && cidVer == 0 {
if cidVerSet {
res.SetError(
errors.New("CIDv0 only supports sha2-256"),
cmdkit.ErrClient,
)
return
return cmdkit.Errorf(cmdkit.ErrClient, "CIDv0 only supports sha2-256")
}
cidVer = 1
}
@ -232,14 +220,12 @@ You can now check what blocks have been created by:
prefix, err := dag.PrefixForCidVersion(cidVer)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
hashFunCode, ok := mh.Names[strings.ToLower(hashFunStr)]
if !ok {
res.SetError(fmt.Errorf("unrecognized hash function: %s", strings.ToLower(hashFunStr)), cmdkit.ErrNormal)
return
return fmt.Errorf("unrecognized hash function: %s", strings.ToLower(hashFunStr))
}
prefix.MhType = hashFunCode
@ -252,8 +238,7 @@ You can now check what blocks have been created by:
NilRepo: true,
})
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
n = nilnode
}
@ -276,8 +261,7 @@ You can now check what blocks have been created by:
fileAdder, err := coreunix.NewAdder(req.Context, n.Pinning, n.Blockstore, dserv)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
fileAdder.Out = outChan
@ -307,8 +291,7 @@ You can now check what blocks have been created by:
emptyDirNode.SetCidBuilder(fileAdder.CidBuilder)
mr, err := mfs.NewRoot(req.Context, md, emptyDirNode, nil)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
fileAdder.SetMfsRoot(mr)
@ -352,24 +335,18 @@ You can now check what blocks have been created by:
err = addAllAndPin(req.Files)
}()
defer res.Close()
err = res.Emit(outChan)
if err != nil {
log.Error(err)
return
}
err = <-errCh
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return err
}
return <-errCh
},
PostRun: cmds.PostRunMap{
cmds.CLI: func(req *cmds.Request, re cmds.ResponseEmitter) cmds.ResponseEmitter {
reNext, res := cmds.NewChanResponsePair(req)
outChan := make(chan interface{})
cmds.CLI: func(res cmds.Response, re cmds.ResponseEmitter) error {
sizeChan := make(chan int64, 1)
outChan := make(chan interface{})
req := res.Request()
sizeFile, ok := req.Files.(files.SizeFile)
if ok {
@ -475,38 +452,33 @@ You can now check what blocks have been created by:
}
}
go func() {
// defer order important! First close outChan, then wait for output to finish, then close re
defer re.Close()
if e := res.Error(); e != nil {
close(outChan)
return e
}
if e := res.Error(); e != nil {
defer close(outChan)
re.SetError(e.Message, e.Code)
return
}
wait := make(chan struct{})
go progressBar(wait)
wait := make(chan struct{})
go progressBar(wait)
defer func() { <-wait }()
defer close(outChan)
defer func() { <-wait }()
defer close(outChan)
for {
v, err := res.Next()
if !cmds.HandleError(err, res, re) {
break
for {
v, err := res.Next()
if err != nil {
if err == io.EOF {
return nil
}
select {
case outChan <- v:
case <-req.Context.Done():
re.SetError(req.Context.Err(), cmdkit.ErrNormal)
return
}
return err
}
}()
return reNext
select {
case outChan <- v:
case <-req.Context.Done():
return req.Context.Err()
}
}
},
},
Type: coreunix.AddedObject{},

18
core/commands/bitswap.go
View File

@ -13,9 +13,9 @@ import (
decision "gx/ipfs/QmUyaGN3WPr3CTLai7DBvMikagK45V4fUi8p8cNRaJQoU1/go-bitswap/decision"
"gx/ipfs/QmPSBJL4momYnE7DcUyk2DVhD6rH488ZmHBGLbxNdhU44K/go-humanize"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
peer "gx/ipfs/QmQsErDt8Qgw1XrsXf2BpEzDgGWtB1YLsTAARBup5b6B9W/go-libp2p-peer"
cmdkit "gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
var BitswapCmd = &cmds.Command{
@ -92,31 +92,27 @@ var bitswapStatCmd = &cmds.Command{
ShortDescription: ``,
},
Type: bitswap.Stat{},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
nd, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
if !nd.OnlineMode() {
res.SetError(ErrNotOnline, cmdkit.ErrClient)
return
return cmdkit.Errorf(cmdkit.ErrClient, ErrNotOnline.Error())
}
bs, ok := nd.Exchange.(*bitswap.Bitswap)
if !ok {
res.SetError(e.TypeErr(bs, nd.Exchange), cmdkit.ErrNormal)
return
return e.TypeErr(bs, nd.Exchange)
}
st, err := bs.Stat()
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
cmds.EmitOnce(res, st)
return cmds.EmitOnce(res, st)
},
Encoders: cmds.EncoderMap{
cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {

96
core/commands/block.go
View File

@ -1,6 +1,7 @@
package commands
import (
"errors"
"fmt"
"io"
"os"
@ -11,9 +12,9 @@ import (
coreiface "github.com/ipfs/go-ipfs/core/coreapi/interface"
"github.com/ipfs/go-ipfs/core/coreapi/interface/options"
"gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
mh "gx/ipfs/QmPnFwZ2JXKnXgMw8CdBPxn7FWh6LLdjUjxV1fKHuJnkr8/go-multihash"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
cmdkit "gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
type BlockStat struct {
@ -59,32 +60,26 @@ on raw IPFS blocks. It outputs the following to stdout:
Arguments: []cmdkit.Argument{
cmdkit.StringArg("key", true, false, "The base58 multihash of an existing block to stat.").EnableStdin(),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
api, err := cmdenv.GetApi(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
p, err := coreiface.ParsePath(req.Arguments[0])
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
b, err := api.Block().Stat(req.Context, p)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
err = cmds.EmitOnce(res, &BlockStat{
return cmds.EmitOnce(res, &BlockStat{
Key: b.Path().Cid().String(),
Size: b.Size(),
})
if err != nil {
log.Error(err)
}
},
Type: BlockStat{},
Encoders: cmds.EncoderMap{
@ -111,29 +106,23 @@ It outputs to stdout, and <key> is a base58 encoded multihash.
Arguments: []cmdkit.Argument{
cmdkit.StringArg("key", true, false, "The base58 multihash of an existing block to get.").EnableStdin(),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
api, err := cmdenv.GetApi(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
p, err := coreiface.ParsePath(req.Arguments[0])
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
r, err := api.Block().Get(req.Context, p)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
err = res.Emit(r)
if err != nil {
log.Error(err)
}
return res.Emit(r)
},
}
@ -157,31 +146,26 @@ than 'sha2-256' or format to anything other than 'v0' will result in CIDv1.
cmdkit.StringOption("mhtype", "multihash hash function").WithDefault("sha2-256"),
cmdkit.IntOption("mhlen", "multihash hash length").WithDefault(-1),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
api, err := cmdenv.GetApi(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
file, err := req.Files.NextFile()
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
mhtype, _ := req.Options["mhtype"].(string)
mhtval, ok := mh.Names[mhtype]
if !ok {
err := fmt.Errorf("unrecognized multihash function: %s", mhtype)
res.SetError(err, cmdkit.ErrNormal)
return
return fmt.Errorf("unrecognized multihash function: %s", mhtype)
}
mhlen, ok := req.Options["mhlen"].(int)
if !ok {
res.SetError("missing option \"mhlen\"", cmdkit.ErrNormal)
return
return errors.New("missing option \"mhlen\"")
}
format, formatSet := req.Options["format"].(string)
@ -195,17 +179,13 @@ than 'sha2-256' or format to anything other than 'v0' will result in CIDv1.
p, err := api.Block().Put(req.Context, file, options.Block.Hash(mhtval, mhlen), options.Block.Format(format))
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
err = cmds.EmitOnce(res, &BlockStat{
return cmds.EmitOnce(res, &BlockStat{
Key: p.Path().Cid().String(),
Size: p.Size(),
})
if err != nil {
log.Error(err)
}
},
Encoders: cmds.EncoderMap{
cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
@ -235,11 +215,10 @@ It takes a list of base58 encoded multihashes to remove.
cmdkit.BoolOption("force", "f", "Ignore nonexistent blocks."),
cmdkit.BoolOption("quiet", "q", "Write minimal output."),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
api, err := cmdenv.GetApi(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
force, _ := req.Options["force"].(bool)
@ -249,43 +228,40 @@ It takes a list of base58 encoded multihashes to remove.
for _, b := range req.Arguments {
p, err := coreiface.ParsePath(b)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
rp, err := api.ResolvePath(req.Context, p)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
err = api.Block().Rm(req.Context, rp, options.Block.Force(force))
if err != nil {
res.Emit(&util.RemovedBlock{
err := res.Emit(&util.RemovedBlock{
Hash: rp.Cid().String(),
Error: err.Error(),
})
if err != nil {
return err
}
}
if !quiet {
res.Emit(&util.RemovedBlock{
err := res.Emit(&util.RemovedBlock{
Hash: rp.Cid().String(),
})
if err != nil {
return err
}
}
}
return nil
},
PostRun: cmds.PostRunMap{
cmds.CLI: func(req *cmds.Request, re cmds.ResponseEmitter) cmds.ResponseEmitter {
reNext, res := cmds.NewChanResponsePair(req)
go func() {
defer re.Close()
err := util.ProcRmOutput(res.Next, os.Stdout, os.Stderr)
cmds.HandleError(err, res, re)
}()
return reNext
cmds.CLI: func(res cmds.Response, re cmds.ResponseEmitter) error {
return util.ProcRmOutput(res.Next, os.Stdout, os.Stderr)
},
},
Type: util.RemovedBlock{},

79
core/commands/cat.go
View File

@ -10,8 +10,8 @@ import (
cmdenv "github.com/ipfs/go-ipfs/core/commands/cmdenv"
coreunix "github.com/ipfs/go-ipfs/core/coreunix"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
const progressBarMinSize = 1024 * 1024 * 8 // show progress bar for outputs > 8MiB
@ -29,34 +29,29 @@ var CatCmd = &cmds.Command{
cmdkit.IntOption("offset", "o", "Byte offset to begin reading from."),
cmdkit.IntOption("length", "l", "Maximum number of bytes to read."),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
node, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
if !node.OnlineMode() {
if err := node.SetupOfflineRouting(); err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
}
offset, _ := req.Options["offset"].(int)
if offset < 0 {
res.SetError(fmt.Errorf("cannot specify negative offset"), cmdkit.ErrNormal)
return
return fmt.Errorf("cannot specify negative offset")
}
max, found := req.Options["length"].(int)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
if max < 0 {
res.SetError(fmt.Errorf("cannot specify negative length"), cmdkit.ErrNormal)
return
return fmt.Errorf("cannot specify negative length")
}
if !found {
max = -1
@ -64,14 +59,12 @@ var CatCmd = &cmds.Command{
err = req.ParseBodyArgs()
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
readers, length, err := cat(req.Context, node, req.Arguments, int64(offset), int64(max))
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
/*
@ -88,48 +81,36 @@ var CatCmd = &cmds.Command{
// returned from io.Copy inside Emit, we need to take Emit errors and send
// them to the client. Usually we don't do that because it means the connection
// is broken or we supplied an illegal argument etc.
err = res.Emit(reader)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
}
return res.Emit(reader)
},
PostRun: cmds.PostRunMap{
cmds.CLI: func(req *cmds.Request, re cmds.ResponseEmitter) cmds.ResponseEmitter {
reNext, res := cmds.NewChanResponsePair(req)
cmds.CLI: func(res cmds.Response, re cmds.ResponseEmitter) error {
if res.Length() > 0 && res.Length() < progressBarMinSize {
return cmds.Copy(re, res)
}
go func() {
if res.Length() > 0 && res.Length() < progressBarMinSize {
if err := cmds.Copy(re, res); err != nil {
re.SetError(err, cmdkit.ErrNormal)
for {
v, err := res.Next()
if err != nil {
if err == io.EOF {
return nil
}
return
return err
}
// Copy closes by itself, so we must not do this before
defer re.Close()
for {
v, err := res.Next()
if !cmds.HandleError(err, res, re) {
break
}
switch val := v.(type) {
case io.Reader:
bar, reader := progressBarForReader(os.Stderr, val, int64(res.Length()))
bar.Start()
switch val := v.(type) {
case io.Reader:
bar, reader := progressBarForReader(os.Stderr, val, int64(res.Length()))
bar.Start()
err = re.Emit(reader)
if err != nil {
log.Error(err)
}
default:
log.Warningf("cat postrun: received unexpected type %T", val)
err = re.Emit(reader)
if err != nil {
return err
}
default:
log.Warningf("cat postrun: received unexpected type %T", val)
}
}()
return reNext
}
},
},
}

2
core/commands/cmdenv/env.go
View File

@ -7,8 +7,8 @@ import (
"github.com/ipfs/go-ipfs/core"
coreiface "github.com/ipfs/go-ipfs/core/coreapi/interface"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
config "gx/ipfs/QmYVqYJTVjetcf1guieEgWpK1PZtHPytP624vKzTF1P3r2/go-ipfs-config"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
// GetNode extracts the node from the environment.

9
core/commands/commands.go
View File

@ -13,8 +13,8 @@ import (
e "github.com/ipfs/go-ipfs/core/commands/e"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
type commandEncoder struct {
@ -68,13 +68,10 @@ func CommandsCmd(root *cmds.Command) *cmds.Command {
Options: []cmdkit.Option{
cmdkit.BoolOption(flagsOptionName, "f", "Show command flags"),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
rootCmd := cmd2outputCmd("ipfs", root)
rootCmd.showOpts, _ = req.Options[flagsOptionName].(bool)
err := cmds.EmitOnce(res, &rootCmd)
if err != nil {
log.Error(err)
}
return cmds.EmitOnce(res, &rootCmd)
},
Encoders: cmds.EncoderMap{
cmds.Text: func(req *cmds.Request) func(io.Writer) cmds.Encoder {

2
core/commands/commands_test.go
View File

@ -4,7 +4,7 @@ import (
"strings"
"testing"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
func collectPaths(prefix string, cmd *cmds.Command, out map[string]struct{}) {

66
core/commands/files.go
View File

@ -25,11 +25,11 @@ import (
humanize "gx/ipfs/QmPSBJL4momYnE7DcUyk2DVhD6rH488ZmHBGLbxNdhU44K/go-humanize"
cid "gx/ipfs/QmPSQnBKM9g7BaUcZCvswUJVscQ1ipjmwxN5PXCjkp9EQ7/go-cid"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
mh "gx/ipfs/QmPnFwZ2JXKnXgMw8CdBPxn7FWh6LLdjUjxV1fKHuJnkr8/go-multihash"
logging "gx/ipfs/QmRREK2CAZ5Re2Bd9zZFG6FeYDppUWt5cMgsoUEp3ktgSr/go-log"
mfs "gx/ipfs/QmRkrpnhZqDxTxwGCsDbuZMr7uCFZHH6SGfrcjgEQwxF3t/go-mfs"
cmdkit "gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
offline "gx/ipfs/QmcRC35JF2pJQneAxa5LdQBQRumWggccWErogSrCkS1h8T/go-ipfs-exchange-offline"
ipld "gx/ipfs/QmdDXJs4axxefSPgK6Y1QhpJWKuDPnGJiqgq4uncb4rFHL/go-ipld-format"
)
@ -108,23 +108,22 @@ var filesStatCmd = &cmds.Command{
cmdkit.BoolOption("size", "Print only size. Implies '--format=<cumulsize>'. Conflicts with other format options."),
cmdkit.BoolOption("with-local", "Compute the amount of the dag that is local, and if possible the total size"),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
_, err := statGetFormatOptions(req)
if err != nil {
res.SetError(err, cmdkit.ErrClient)
// REVIEW NOTE: We didn't return here before, was that correct?
return cmdkit.Errorf(cmdkit.ErrClient, err.Error())
}
node, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
path, err := checkPath(req.Arguments[0])
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
withLocal, _ := req.Options["with-local"].(bool)
@ -142,19 +141,16 @@ var filesStatCmd = &cmds.Command{
nd, err := getNodeFromPath(req.Context, node, dagserv, path)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
o, err := statNode(nd)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
if !withLocal {
cmds.EmitOnce(res, o)
return
return cmds.EmitOnce(res, o)
}
local, sizeLocal, err := walkBlock(req.Context, dagserv, nd)
@ -163,7 +159,7 @@ var filesStatCmd = &cmds.Command{
o.Local = local
o.SizeLocal = sizeLocal
cmds.EmitOnce(res, o)
return cmds.EmitOnce(res, o)
},
Encoders: cmds.EncoderMap{
cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
@ -729,11 +725,10 @@ stat' on the file or any of its ancestors.
cidVersionOption,
hashOption,
},
Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) error {
path, err := checkPath(req.Arguments[0])
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
create, _ := req.Options["create"].(bool)
@ -744,34 +739,29 @@ stat' on the file or any of its ancestors.
prefix, err := getPrefixNew(req)
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
nd, err := cmdenv.GetNode(env)
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
offset, _ := req.Options["offset"].(int)
if offset < 0 {
re.SetError(fmt.Errorf("cannot have negative write offset"), cmdkit.ErrNormal)
return
return fmt.Errorf("cannot have negative write offset")
}
if mkParents {
err := ensureContainingDirectoryExists(nd.FilesRoot, path, prefix)
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
}
fi, err := getFileHandle(nd.FilesRoot, path, create, prefix)
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
if rawLeavesDef {
fi.RawLeaves = rawLeaves
@ -779,41 +769,36 @@ stat' on the file or any of its ancestors.
wfd, err := fi.Open(mfs.OpenWriteOnly, flush)
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
defer func() {
err := wfd.Close()
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
re.CloseWithError(cmdkit.Errorf(cmdkit.ErrNormal, err.Error()))
}
}()
if trunc {
if err := wfd.Truncate(0); err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
}
count, countfound := req.Options["count"].(int)
if countfound && count < 0 {
re.SetError(fmt.Errorf("cannot have negative byte count"), cmdkit.ErrNormal)
return
return fmt.Errorf("cannot have negative byte count")
}
_, err = wfd.Seek(int64(offset), io.SeekStart)
if err != nil {
flog.Error("seekfail: ", err)
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
input, err := req.Files.NextFile()
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
var r io.Reader = input
@ -822,10 +807,7 @@ stat' on the file or any of its ancestors.
}
_, err = io.Copy(wfd, r)
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
}
return err
},
}

86
core/commands/filestore.go
View File

@ -14,8 +14,8 @@ import (
"github.com/ipfs/go-ipfs/filestore"
cid "gx/ipfs/QmPSQnBKM9g7BaUcZCvswUJVscQ1ipjmwxN5PXCjkp9EQ7/go-cid"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
var FileStoreCmd = &cmds.Command{
@ -49,11 +49,10 @@ The output is:
Options: []cmdkit.Option{
cmdkit.BoolOption("file-order", "sort the results based on the path of the backing file"),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
_, fs, err := getFilestore(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
args := req.Arguments
if len(args) > 0 {
@ -61,59 +60,50 @@ The output is:
return filestore.List(fs, c)
})
err = res.Emit(out)
if err != nil {
log.Error(err)
}
} else {
fileOrder, _ := req.Options["file-order"].(bool)
next, err := filestore.ListAll(fs, fileOrder)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
}
out := listResToChan(req.Context, next)
err = res.Emit(out)
if err != nil {
log.Error(err)
}
return res.Emit(out)
}
fileOrder, _ := req.Options["file-order"].(bool)
next, err := filestore.ListAll(fs, fileOrder)
if err != nil {
return err
}
out := listResToChan(req.Context, next)
return res.Emit(out)
},
PostRun: cmds.PostRunMap{
cmds.CLI: func(req *cmds.Request, re cmds.ResponseEmitter) cmds.ResponseEmitter {
reNext, res := cmds.NewChanResponsePair(req)
go func() {
defer re.Close()
var errors bool
for {
v, err := res.Next()
if !cmds.HandleError(err, res, re) {
cmds.CLI: func(res cmds.Response, re cmds.ResponseEmitter) error {
var errors bool
for {
v, err := res.Next()
if err != nil {
if err == io.EOF {
break
}
r, ok := v.(*filestore.ListRes)
if !ok {
log.Error(e.New(e.TypeErr(r, v)))
return
}
if r.ErrorMsg != "" {
errors = true
fmt.Fprintf(os.Stderr, "%s\n", r.ErrorMsg)
} else {
fmt.Fprintf(os.Stdout, "%s\n", r.FormatLong())
}
return err
}
if errors {
re.SetError("errors while displaying some entries", cmdkit.ErrNormal)
r, ok := v.(*filestore.ListRes)
if !ok {
// TODO or just return that error? why didn't we do that before?
log.Error(e.New(e.TypeErr(r, v)))
break
}
}()
return reNext
if r.ErrorMsg != "" {
errors = true
fmt.Fprintf(os.Stderr, "%s\n", r.ErrorMsg)
} else {
fmt.Fprintf(os.Stdout, "%s\n", r.FormatLong())
}
}
if errors {
return fmt.Errorf("errors while displaying some entries")
}
return nil
},
},
Type: filestore.ListRes{},

84
core/commands/get.go
View File

@ -14,12 +14,12 @@ import (
e "github.com/ipfs/go-ipfs/core/commands/e"
uarchive "gx/ipfs/QmPL8bYtbACcSFFiSr4s2du7Na382NxRADR8hC7D9FkEA2/go-unixfs/archive"
"gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
"gx/ipfs/QmPtj12fdwuAqj9sBSTNUxBNu8kCGNp8b3o8yUzMm5GHpq/pb"
tar "gx/ipfs/QmQine7gvHncNevKtG9QXxf3nXcwSj6aDDmMm52mHofEEp/tar-utils"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
path "gx/ipfs/QmX7uSbkNz76yNwBhuwYwRbhihLnJqM73VTCjS3UMJud9A/go-path"
dag "gx/ipfs/QmXv5mwmQ74r4aiHcNeQ4GAmfB3aWJuqaE4WyDfDfvkgLM/go-merkledag"
"gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
var ErrInvalidCompressionLevel = errors.New("compression level must be between 1 and 9")
@ -53,93 +53,79 @@ may also specify the level of compression by specifying '-l=<1-9>'.
_, err := getCompressOptions(req)
return err
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
cmplvl, err := getCompressOptions(req)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
node, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
p := path.Path(req.Arguments[0])
ctx := req.Context
dn, err := core.Resolve(ctx, node.Namesys, node.Resolver, p)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
switch dn := dn.(type) {
case *dag.ProtoNode:
size, err := dn.Size()
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
res.SetLength(size)
case *dag.RawNode:
res.SetLength(uint64(len(dn.RawData())))
default:
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
archive, _ := req.Options["archive"].(bool)
reader, err := uarchive.DagArchive(ctx, dn, p.String(), node.DAG, archive, cmplvl)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
res.Emit(reader)
return res.Emit(reader)
},
PostRun: cmds.PostRunMap{
cmds.CLI: func(req *cmds.Request, re cmds.ResponseEmitter) cmds.ResponseEmitter {
reNext, res := cmds.NewChanResponsePair(req)
cmds.CLI: func(res cmds.Response, re cmds.ResponseEmitter) error {
req := res.Request()
go func() {
defer re.Close()
v, err := res.Next()
if err != nil {
return err
}
v, err := res.Next()
if !cmds.HandleError(err, res, re) {
return
}
outReader, ok := v.(io.Reader)
if !ok {
// TODO or just return the error here?
log.Error(e.New(e.TypeErr(outReader, v)))
return nil
}
outReader, ok := v.(io.Reader)
if !ok {
log.Error(e.New(e.TypeErr(outReader, v)))
return
}
outPath := getOutPath(req)
outPath := getOutPath(req)
cmplvl, err := getCompressOptions(req)
if err != nil {
return err
}
cmplvl, err := getCompressOptions(req)
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
}
archive, _ := req.Options["archive"].(bool)
archive, _ := req.Options["archive"].(bool)
gw := getWriter{
Out: os.Stdout,
Err: os.Stderr,
Archive: archive,
Compression: cmplvl,
Size: int64(res.Length()),
}
gw := getWriter{
Out: os.Stdout,
Err: os.Stderr,
Archive: archive,
Compression: cmplvl,
Size: int64(res.Length()),
}
if err := gw.Write(outReader, outPath); err != nil {
re.SetError(err, cmdkit.ErrNormal)
}
}()
return reNext
return gw.Write(outReader, outPath)
},
},
}

2
core/commands/get_test.go
View File

@ -5,8 +5,8 @@ import (
"fmt"
"testing"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
cmdkit "gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
func TestGetOutputPath(t *testing.T) {

2
core/commands/helptext_test.go
View File

@ -4,7 +4,7 @@ import (
"strings"
"testing"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
func checkHelptextRecursive(t *testing.T, name []string, c *cmds.Command) {

48
core/commands/keystore.go
View File

@ -9,8 +9,8 @@ import (
"github.com/ipfs/go-ipfs/core/commands/e"
"github.com/ipfs/go-ipfs/core/coreapi/interface/options"
"gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
"gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
var KeyCmd = &cmds.Command{
@ -66,23 +66,20 @@ var keyGenCmd = &cmds.Command{
Arguments: []cmdkit.Argument{
cmdkit.StringArg("name", true, false, "name of key to create"),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
api, err := cmdenv.GetApi(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
typ, f := req.Options["type"].(string)
if !f {
res.SetError(fmt.Errorf("please specify a key type with --type"), cmdkit.ErrNormal)
return
return fmt.Errorf("please specify a key type with --type")
}
name := req.Arguments[0]
if name == "self" {
res.SetError(fmt.Errorf("cannot create key with name 'self'"), cmdkit.ErrNormal)
return
return fmt.Errorf("cannot create key with name 'self'")
}
opts := []options.KeyGenerateOption{options.Key.Type(typ)}
@ -95,11 +92,10 @@ var keyGenCmd = &cmds.Command{
key, err := api.Key().Generate(req.Context, name, opts...)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
cmds.EmitOnce(res, &KeyOutput{
return cmds.EmitOnce(res, &KeyOutput{
Name: name,
Id: key.ID().Pretty(),
})
@ -125,17 +121,15 @@ var keyListCmd = &cmds.Command{
Options: []cmdkit.Option{
cmdkit.BoolOption("l", "Show extra information about keys."),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
api, err := cmdenv.GetApi(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
keys, err := api.Key().List(req.Context)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
list := make([]KeyOutput, 0, len(keys))
@ -144,7 +138,7 @@ var keyListCmd = &cmds.Command{
list = append(list, KeyOutput{Name: key.Name(), Id: key.ID().Pretty()})
}
cmds.EmitOnce(res, &KeyOutputList{list})
return cmds.EmitOnce(res, &KeyOutputList{list})
},
Encoders: cmds.EncoderMap{
cmds.Text: keyOutputListMarshaler(),
@ -163,11 +157,10 @@ var keyRenameCmd = &cmds.Command{
Options: []cmdkit.Option{
cmdkit.BoolOption("force", "f", "Allow to overwrite an existing key."),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
api, err := cmdenv.GetApi(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
name := req.Arguments[0]
@ -176,11 +169,10 @@ var keyRenameCmd = &cmds.Command{
key, overwritten, err := api.Key().Rename(req.Context, name, newName, options.Key.Force(force))
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
cmds.EmitOnce(res, &KeyRenameOutput{
return cmds.EmitOnce(res, &KeyRenameOutput{
Was: name,
Now: newName,
Id: key.ID().Pretty(),
@ -215,11 +207,10 @@ var keyRmCmd = &cmds.Command{
Options: []cmdkit.Option{
cmdkit.BoolOption("l", "Show extra information about keys."),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
api, err := cmdenv.GetApi(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
names := req.Arguments
@ -228,14 +219,13 @@ var keyRmCmd = &cmds.Command{
for _, name := range names {
key, err := api.Key().Remove(req.Context, name)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
list = append(list, KeyOutput{Name: name, Id: key.ID().Pretty()})
}
cmds.EmitOnce(res, &KeyOutputList{list})
return cmds.EmitOnce(res, &KeyOutputList{list})
},
Encoders: cmds.EncoderMap{
cmds.Text: keyOutputListMarshaler(),

28
core/commands/name/ipns.go
View File

@ -12,11 +12,11 @@ import (
namesys "github.com/ipfs/go-ipfs/namesys"
nsopts "github.com/ipfs/go-ipfs/namesys/opts"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
logging "gx/ipfs/QmRREK2CAZ5Re2Bd9zZFG6FeYDppUWt5cMgsoUEp3ktgSr/go-log"
offline "gx/ipfs/QmSNe4MWVxZWk6UxxW2z2EKofFo4GdFzud1vfn1iVby3mj/go-ipfs-routing/offline"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
path "gx/ipfs/QmX7uSbkNz76yNwBhuwYwRbhihLnJqM73VTCjS3UMJud9A/go-path"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
var log = logging.Logger("core/commands/ipns")
@ -79,18 +79,16 @@ Resolve the value of a dnslink:
cmdkit.UintOption(dhtRecordCountOptionName, "dhtrc", "Number of records to request for DHT resolution."),
cmdkit.StringOption(dhtTimeoutOptionName, "dhtt", "Max time to collect values during DHT resolution eg \"30s\". Pass 0 for no timeout."),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
n, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
if !n.OnlineMode() {
err := n.SetupOfflineRouting()
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
}
@ -101,8 +99,7 @@ Resolve the value of a dnslink:
var resolver namesys.Resolver = n.Namesys
if local && nocache {
res.SetError(errors.New("cannot specify both local and nocache"), cmdkit.ErrNormal)
return
return errors.New("cannot specify both local and nocache")
}
if local {
@ -117,8 +114,7 @@ Resolve the value of a dnslink:
var name string
if len(req.Arguments) == 0 {
if n.Identity == "" {
res.SetError(errors.New("identity not loaded"), cmdkit.ErrNormal)
return
return errors.New("identity not loaded")
}
name = n.Identity.Pretty()
@ -140,12 +136,10 @@ Resolve the value of a dnslink:
if dhttok {
d, err := time.ParseDuration(dhtt)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
if d < 0 {
res.SetError(errors.New("DHT timeout value must be >= 0"), cmdkit.ErrNormal)
return
return errors.New("DHT timeout value must be >= 0")
}
ropts = append(ropts, nsopts.DhtTimeout(d))
}
@ -156,13 +150,11 @@ Resolve the value of a dnslink:
output, err := resolver.Resolve(req.Context, name, ropts...)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
// TODO: better errors (in the case of not finding the name, we get "failed to find any peer in table")
cmds.EmitOnce(res, &ResolvedPath{output})
return cmds.EmitOnce(res, &ResolvedPath{output})
},
Encoders: cmds.EncoderMap{
cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {

33
core/commands/name/ipnsps.go
View File

@ -1,7 +1,6 @@
package name
import (
"errors"
"fmt"
"io"
"strings"
@ -9,9 +8,9 @@ import (
"github.com/ipfs/go-ipfs/core/commands/cmdenv"
"github.com/ipfs/go-ipfs/core/commands/e"
"gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
"gx/ipfs/QmQsErDt8Qgw1XrsXf2BpEzDgGWtB1YLsTAARBup5b6B9W/go-libp2p-peer"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
"gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
"gx/ipfs/QmdHb9aBELnQKTVhvvA3hsQbRgUAwsWUzBP2vZ6Y5FBYvE/go-libp2p-record"
)
@ -48,14 +47,13 @@ var ipnspsStateCmd = &cmds.Command{
Helptext: cmdkit.HelpText{
Tagline: "Query the state of IPNS pubsub",
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
n, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
cmds.EmitOnce(res, &ipnsPubsubState{n.PSRouter != nil})
return cmds.EmitOnce(res, &ipnsPubsubState{n.PSRouter != nil})
},
Type: ipnsPubsubState{},
Encoders: cmds.EncoderMap{
@ -82,16 +80,14 @@ var ipnspsSubsCmd = &cmds.Command{
Helptext: cmdkit.HelpText{
Tagline: "Show current name subscriptions",
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
n, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
if n.PSRouter == nil {
res.SetError(errors.New("IPNS pubsub subsystem is not enabled"), cmdkit.ErrClient)
return
return cmdkit.Errorf(cmdkit.ErrClient, "IPNS pubsub subsystem is not enabled")
}
var paths []string
for _, key := range n.PSRouter.GetSubscriptions() {
@ -108,7 +104,7 @@ var ipnspsSubsCmd = &cmds.Command{
paths = append(paths, "/ipns/"+peer.IDB58Encode(pid))
}
cmds.EmitOnce(res, &stringList{paths})
return cmds.EmitOnce(res, &stringList{paths})
},
Type: stringList{},
Encoders: cmds.EncoderMap{
@ -120,28 +116,25 @@ var ipnspsCancelCmd = &cmds.Command{
Helptext: cmdkit.HelpText{
Tagline: "Cancel a name subscription",
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
n, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
if n.PSRouter == nil {
res.SetError(errors.New("IPNS pubsub subsystem is not enabled"), cmdkit.ErrClient)
return
return cmdkit.Errorf(cmdkit.ErrClient, "IPNS pubsub subsystem is not enabled")
}
name := req.Arguments[0]
name = strings.TrimPrefix(name, "/ipns/")
pid, err := peer.IDB58Decode(name)
if err != nil {
res.SetError(err, cmdkit.ErrClient)
return
return cmdkit.Errorf(cmdkit.ErrClient, err.Error())
}
ok := n.PSRouter.Cancel("/ipns/" + string(pid))
cmds.EmitOnce(res, &ipnsPubsubCancel{ok})
return cmds.EmitOnce(res, &ipnsPubsubCancel{ok})
},
Arguments: []cmdkit.Argument{
cmdkit.StringArg("name", true, false, "Name to cancel the subscription for."),

2
core/commands/name/name.go
View File

@ -1,8 +1,8 @@
package name
import (
"gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
"gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
type IpnsEntry struct {

37
core/commands/name/publish.go
View File

@ -12,11 +12,11 @@ import (
e "github.com/ipfs/go-ipfs/core/commands/e"
keystore "github.com/ipfs/go-ipfs/keystore"
"gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
crypto "gx/ipfs/QmPvyPwuCgJ7pDmrKDxRtsScJgBaM5h4EpRL2qQJsmXf4n/go-libp2p-crypto"
peer "gx/ipfs/QmQsErDt8Qgw1XrsXf2BpEzDgGWtB1YLsTAARBup5b6B9W/go-libp2p-peer"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
path "gx/ipfs/QmX7uSbkNz76yNwBhuwYwRbhihLnJqM73VTCjS3UMJud9A/go-path"
"gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
var (
@ -87,36 +87,31 @@ Alternatively, publish an <ipfs-path> using a valid PeerID (as listed by
cmdkit.StringOption(ttlOptionName, "Time duration this record should be cached for (caution: experimental)."),
cmdkit.StringOption(keyOptionName, "k", "Name of the key to be used or a valid PeerID, as listed by 'ipfs key list -l'. Default: <<default>>.").WithDefault("self"),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
n, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
allowOffline, _ := req.Options[allowOfflineOptionName].(bool)
if !n.OnlineMode() {
if !allowOffline {
res.SetError(errAllowOffline, cmdkit.ErrNormal)
return
return errAllowOffline
}
err := n.SetupOfflineRouting()
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
}
if n.Mounts.Ipns != nil && n.Mounts.Ipns.IsActive() {
res.SetError(errIpnsMount, cmdkit.ErrNormal)
return
return errIpnsMount
}
pstr := req.Arguments[0]
if n.Identity == "" {
res.SetError(errIdentityLoad, cmdkit.ErrNormal)
return
return errIdentityLoad
}
popts := new(publishOpts)
@ -126,8 +121,7 @@ Alternatively, publish an <ipfs-path> using a valid PeerID (as listed by
validtime, _ := req.Options[lifeTimeOptionName].(string)
d, err := time.ParseDuration(validtime)
if err != nil {
res.SetError(fmt.Errorf("error parsing lifetime option: %s", err), cmdkit.ErrNormal)
return
return fmt.Errorf("error parsing lifetime option: %s", err)
}
popts.pubValidTime = d
@ -136,8 +130,7 @@ Alternatively, publish an <ipfs-path> using a valid PeerID (as listed by
if ttl, found := req.Options[ttlOptionName].(string); found {
d, err := time.ParseDuration(ttl)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
ctx = context.WithValue(ctx, "ipns-publish-ttl", d)
@ -146,22 +139,20 @@ Alternatively, publish an <ipfs-path> using a valid PeerID (as listed by
kname, _ := req.Options[keyOptionName].(string)
k, err := keylookup(n, kname)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
pth, err := path.ParsePath(pstr)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
output, err := publish(ctx, n, k, pth, popts)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
cmds.EmitOnce(res, output)
return cmds.EmitOnce(res, output)
},
Encoders: cmds.EncoderMap{
cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {

4
core/commands/object/object.go
View File

@ -17,9 +17,9 @@ import (
"github.com/ipfs/go-ipfs/core/coreapi/interface/options"
cid "gx/ipfs/QmPSQnBKM9g7BaUcZCvswUJVscQ1ipjmwxN5PXCjkp9EQ7/go-cid"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
cmdkit "gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
dag "gx/ipfs/QmXv5mwmQ74r4aiHcNeQ4GAmfB3aWJuqaE4WyDfDfvkgLM/go-merkledag"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
ipld "gx/ipfs/QmdDXJs4axxefSPgK6Y1QhpJWKuDPnGJiqgq4uncb4rFHL/go-ipld-format"
)
@ -192,7 +192,7 @@ multihash.
return buf, nil
},
},
Type: Object{},
Type: &Object{},
}
var ObjectGetCmd = &oldcmds.Command{

20
core/commands/object/patch.go
View File

@ -12,8 +12,8 @@ import (
coreiface "github.com/ipfs/go-ipfs/core/coreapi/interface"
"github.com/ipfs/go-ipfs/core/coreapi/interface/options"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
cmdkit "gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
var ObjectPatchCmd = &cmds.Command{
@ -67,34 +67,30 @@ the limit will not be respected by the network.
cmdkit.StringArg("root", true, false, "The hash of the node to modify."),
cmdkit.FileArg("data", true, false, "Data to append.").EnableStdin(),
},
Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) error {
api, err := cmdenv.GetApi(env)
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
root, err := coreiface.ParsePath(req.Arguments[0])
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
data, err := req.Files.NextFile()
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
p, err := api.Object().AppendData(req.Context, root, data)
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
cmds.EmitOnce(re, &Object{Hash: p.Cid().String()})
return cmds.EmitOnce(re, &Object{Hash: p.Cid().String()})
},
Type: Object{},
Type: &Object{},
Encoders: cmds.EncoderMap{
cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, obj *Object) error {
_, err := fmt.Fprintln(w, obj.Hash)

72
core/commands/pubsub.go
View File

@ -3,6 +3,7 @@ package commands
import (
"context"
"encoding/binary"
"errors"
"fmt"
"io"
"net/http"
@ -15,10 +16,10 @@ import (
e "github.com/ipfs/go-ipfs/core/commands/e"
cid "gx/ipfs/QmPSQnBKM9g7BaUcZCvswUJVscQ1ipjmwxN5PXCjkp9EQ7/go-cid"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
blocks "gx/ipfs/QmRcHuYzAyswytBuMF78rj3LTChYszomRFXNg4685ZN1WM/go-block-format"
cmdkit "gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
floodsub "gx/ipfs/QmY1L5krVk8dv8d74uESmJTXGpoigVYqBVxXXz1aS8aFSb/go-libp2p-floodsub"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
pstore "gx/ipfs/Qmda4cPRvSRyox3SqgJN6DfSZGU5TtHufPTp9uXjFj71X6/go-libp2p-peerstore"
)
@ -73,29 +74,25 @@ This command outputs data in the following encodings:
Options: []cmdkit.Option{
cmdkit.BoolOption("discover", "try to discover other peers subscribed to the same topic"),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
n, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
// Must be online!
if !n.OnlineMode() {
res.SetError(ErrNotOnline, cmdkit.ErrClient)
return
return cmdkit.Errorf(cmdkit.ErrClient, ErrNotOnline.Error())
}
if n.Floodsub == nil {
res.SetError(fmt.Errorf("experimental pubsub feature not enabled. Run daemon with --enable-pubsub-experiment to use"), cmdkit.ErrNormal)
return
return fmt.Errorf("experimental pubsub feature not enabled. Run daemon with --enable-pubsub-experiment to use")
}
topic := req.Arguments[0]
sub, err := n.Floodsub.Subscribe(topic)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
defer sub.Cancel()
@ -120,13 +117,15 @@ This command outputs data in the following encodings:
for {
msg, err := sub.Next(req.Context)
if err == io.EOF || err == context.Canceled {
return
return nil
} else if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
res.Emit(msg)
err = res.Emit(msg)
if err != nil {
return err
}
}
},
Encoders: cmds.EncoderMap{
@ -206,38 +205,35 @@ To use, the daemon must be run with '--enable-pubsub-experiment'.
cmdkit.StringArg("topic", true, false, "Topic to publish to."),
cmdkit.StringArg("data", true, true, "Payload of message to publish.").EnableStdin(),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
n, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
// Must be online!
if !n.OnlineMode() {
res.SetError(ErrNotOnline, cmdkit.ErrClient)
return
return cmdkit.Errorf(cmdkit.ErrClient, ErrNotOnline.Error())
}
if n.Floodsub == nil {
res.SetError("experimental pubsub feature not enabled. Run daemon with --enable-pubsub-experiment to use.", cmdkit.ErrNormal)
return
return errors.New("experimental pubsub feature not enabled. Run daemon with --enable-pubsub-experiment to use.")
}
topic := req.Arguments[0]
err = req.ParseBodyArgs()
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
for _, data := range req.Arguments[1:] {
if err := n.Floodsub.Publish(topic, []byte(data)); err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
}
return nil
},
}
@ -253,25 +249,22 @@ to be used in a production environment.
To use, the daemon must be run with '--enable-pubsub-experiment'.
`,
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
n, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
// Must be online!
if !n.OnlineMode() {
res.SetError(ErrNotOnline, cmdkit.ErrClient)
return
return cmdkit.Errorf(cmdkit.ErrClient, ErrNotOnline.Error())
}
if n.Floodsub == nil {
res.SetError("experimental pubsub feature not enabled. Run daemon with --enable-pubsub-experiment to use.", cmdkit.ErrNormal)
return
return errors.New("experimental pubsub feature not enabled. Run daemon with --enable-pubsub-experiment to use.")
}
cmds.EmitOnce(res, stringList{n.Floodsub.GetTopics()})
return cmds.EmitOnce(res, stringList{n.Floodsub.GetTopics()})
},
Type: stringList{},
Encoders: cmds.EncoderMap{
@ -310,22 +303,19 @@ To use, the daemon must be run with '--enable-pubsub-experiment'.
Arguments: []cmdkit.Argument{
cmdkit.StringArg("topic", false, false, "topic to list connected peers of"),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
n, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
// Must be online!
if !n.OnlineMode() {
res.SetError(ErrNotOnline, cmdkit.ErrClient)
return
return cmdkit.Errorf(cmdkit.ErrClient, ErrNotOnline.Error())
}
if n.Floodsub == nil {
res.SetError(fmt.Errorf("experimental pubsub feature not enabled. Run daemon with --enable-pubsub-experiment to use"), cmdkit.ErrNormal)
return
return errors.New("experimental pubsub feature not enabled. Run daemon with --enable-pubsub-experiment to use")
}
var topic string
@ -340,7 +330,7 @@ To use, the daemon must be run with '--enable-pubsub-experiment'.
list.Strings = append(list.Strings, peer.Pretty())
}
sort.Strings(list.Strings)
cmds.EmitOnce(res, list)
return cmds.EmitOnce(res, list)
},
Type: stringList{},
Encoders: cmds.EncoderMap{

19
core/commands/repo.go
View File

@ -17,9 +17,9 @@ import (
fsrepo "github.com/ipfs/go-ipfs/repo/fsrepo"
cid "gx/ipfs/QmPSQnBKM9g7BaUcZCvswUJVscQ1ipjmwxN5PXCjkp9EQ7/go-cid"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
cmdkit "gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
config "gx/ipfs/QmYVqYJTVjetcf1guieEgWpK1PZtHPytP624vKzTF1P3r2/go-ipfs-config"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
bstore "gx/ipfs/QmegPGspn3RpTMQ23Fd3GVVMopo1zsEMurudbFMZ5UXBLH/go-ipfs-blockstore"
)
@ -99,7 +99,7 @@ order to reclaim hard disk space.
}
}
if errs {
res.SetError(fmt.Errorf("encountered errors during gc run"), cmdkit.ErrNormal)
outChan <- &GcResult{Error: "encountered errors during gc run"}
}
} else {
err := corerepo.CollectResult(req.Context(), gcOutChan, func(k cid.Cid) {
@ -165,33 +165,30 @@ Version string The repo version.
cmdkit.BoolOption("size-only", "Only report RepoSize and StorageMax."),
cmdkit.BoolOption("human", "Output sizes in MiB."),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
n, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
sizeOnly, _ := req.Options["size-only"].(bool)
if sizeOnly {
sizeStat, err := corerepo.RepoSize(req.Context, n)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
cmds.EmitOnce(res, &corerepo.Stat{
SizeStat: sizeStat,
})
return
return nil
}
stat, err := corerepo.RepoStat(req.Context, n)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
cmds.EmitOnce(res, &stat)
return cmds.EmitOnce(res, &stat)
},
Type: &corerepo.Stat{},
Encoders: cmds.EncoderMap{

2
core/commands/root.go
View File

@ -13,9 +13,9 @@ import (
ocmd "github.com/ipfs/go-ipfs/core/commands/object"
unixfs "github.com/ipfs/go-ipfs/core/commands/unixfs"
"gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
logging "gx/ipfs/QmRREK2CAZ5Re2Bd9zZFG6FeYDppUWt5cMgsoUEp3ktgSr/go-log"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
"gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
var log = logging.Logger("core/commands")

14
core/commands/shutdown.go
View File

@ -1,32 +1,30 @@
package commands
import (
"fmt"
cmdenv "github.com/ipfs/go-ipfs/core/commands/cmdenv"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
)
var daemonShutdownCmd = &cmds.Command{
Helptext: cmdkit.HelpText{
Tagline: "Shut down the ipfs daemon",
},
Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) error {
nd, err := cmdenv.GetNode(env)
if err != nil {
re.SetError(err, cmdkit.ErrNormal)
return
return err
}
if nd.LocalMode() {
re.SetError(fmt.Errorf("daemon not running"), cmdkit.ErrClient)
return
return cmdkit.Errorf(cmdkit.ErrClient, "daemon not running")
}
if err := nd.Process().Close(); err != nil {
log.Error("error while shutting down ipfs daemon:", err)
}
return nil
},
}

80
core/commands/stat.go
View File

@ -1,7 +1,6 @@
package commands
import (
"errors"
"fmt"
"io"
"os"
@ -10,10 +9,10 @@ import (
cmdenv "github.com/ipfs/go-ipfs/core/commands/cmdenv"
humanize "gx/ipfs/QmPSBJL4momYnE7DcUyk2DVhD6rH488ZmHBGLbxNdhU44K/go-humanize"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
peer "gx/ipfs/QmQsErDt8Qgw1XrsXf2BpEzDgGWtB1YLsTAARBup5b6B9W/go-libp2p-peer"
cmdkit "gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
protocol "gx/ipfs/QmZNkThpqfVXs9GNbexPrfBbXSLNYeKrE7jwFM2oqHbyqN/go-libp2p-protocol"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
metrics "gx/ipfs/QmdhwKw53CTV8EJSAsR1bpmMT5kXiWBgeAyv1EXeeDiXqR/go-libp2p-metrics"
)
@ -81,37 +80,32 @@ Example:
"ns", "us" (or "µs"), "ms", "s", "m", "h".`).WithDefault("1s"),
},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
nd, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
// Must be online!
if !nd.OnlineMode() {
res.SetError(ErrNotOnline, cmdkit.ErrClient)
return
return cmdkit.Errorf(cmdkit.ErrClient, ErrNotOnline.Error())
}
if nd.Reporter == nil {
res.SetError(fmt.Errorf("bandwidth reporter disabled in config"), cmdkit.ErrNormal)
return
return fmt.Errorf("bandwidth reporter disabled in config")
}
pstr, pfound := req.Options["peer"].(string)
tstr, tfound := req.Options["proto"].(string)
if pfound && tfound {
res.SetError(errors.New("please only specify peer OR protocol"), cmdkit.ErrClient)
return
return cmdkit.Errorf(cmdkit.ErrClient, "please only specify peer OR protocol")
}
var pid peer.ID
if pfound {
checkpid, err := peer.IDB58Decode(pstr)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
pid = checkpid
}
@ -119,8 +113,7 @@ Example:
timeS, _ := req.Options["interval"].(string)
interval, err := time.ParseDuration(timeS)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
doPoll, _ := req.Options["poll"].(bool)
@ -137,49 +130,44 @@ Example:
res.Emit(&totals)
}
if !doPoll {
return
return nil
}
select {
case <-time.After(interval):
case <-req.Context.Done():
return
break
}
}
},
Type: metrics.Stats{},
PostRun: cmds.PostRunMap{
cmds.CLI: func(req *cmds.Request, re cmds.ResponseEmitter) cmds.ResponseEmitter {
reNext, res := cmds.NewChanResponsePair(req)
go func() {
defer re.Close()
polling, _ := res.Request().Options["poll"].(bool)
if polling {
fmt.Fprintln(os.Stdout, "Total Up Total Down Rate Up Rate Down")
}
for {
v, err := res.Next()
if !cmds.HandleError(err, res, re) {
break
cmds.CLI: func(res cmds.Response, re cmds.ResponseEmitter) error {
polling, _ := res.Request().Options["poll"].(bool)
log.Debug("postrun polling:", polling)
if polling {
fmt.Fprintln(os.Stdout, "Total Up Total Down Rate Up Rate Down")
}
for {
v, err := res.Next()
if err != nil {
if err == io.EOF {
return nil
}
bs := v.(*metrics.Stats)
if !polling {
printStats(os.Stdout, bs)
return
}
fmt.Fprintf(os.Stdout, "%8s ", humanize.Bytes(uint64(bs.TotalOut)))
fmt.Fprintf(os.Stdout, "%8s ", humanize.Bytes(uint64(bs.TotalIn)))
fmt.Fprintf(os.Stdout, "%8s/s ", humanize.Bytes(uint64(bs.RateOut)))
fmt.Fprintf(os.Stdout, "%8s/s \r", humanize.Bytes(uint64(bs.RateIn)))
return err
}
}()
return reNext
bs := v.(*metrics.Stats)
if !polling {
printStats(os.Stdout, bs)
return nil
}
fmt.Fprintf(os.Stdout, "%8s ", humanize.Bytes(uint64(bs.TotalOut)))
fmt.Fprintf(os.Stdout, "%8s ", humanize.Bytes(uint64(bs.TotalIn)))
fmt.Fprintf(os.Stdout, "%8s/s ", humanize.Bytes(uint64(bs.RateOut)))
fmt.Fprintf(os.Stdout, "%8s/s \r", humanize.Bytes(uint64(bs.RateIn)))
}
},
},
}

33
core/commands/urlstore.go
View File

@ -12,9 +12,9 @@ import (
ihelper "gx/ipfs/QmPL8bYtbACcSFFiSr4s2du7Na382NxRADR8hC7D9FkEA2/go-unixfs/importer/helpers"
trickle "gx/ipfs/QmPL8bYtbACcSFFiSr4s2du7Na382NxRADR8hC7D9FkEA2/go-unixfs/importer/trickle"
cid "gx/ipfs/QmPSQnBKM9g7BaUcZCvswUJVscQ1ipjmwxN5PXCjkp9EQ7/go-cid"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
mh "gx/ipfs/QmPnFwZ2JXKnXgMw8CdBPxn7FWh6LLdjUjxV1fKHuJnkr8/go-multihash"
cmdkit "gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
chunk "gx/ipfs/QmdSeG9s4EQ9TGruJJS9Us38TQDZtMmFGwzTYUDVqNTURm/go-ipfs-chunker"
)
@ -50,48 +50,41 @@ time.
Arguments: []cmdkit.Argument{
cmdkit.StringArg("url", true, false, "URL to add to IPFS"),
},
Type: BlockStat{},
Type: &BlockStat{},
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) {
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
url := req.Arguments[0]
n, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
if !filestore.IsURL(url) {
res.SetError(fmt.Errorf("unsupported url syntax: %s", url), cmdkit.ErrNormal)
return
return fmt.Errorf("unsupported url syntax: %s", url)
}
cfg, err := n.Repo.Config()
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
if !cfg.Experimental.UrlstoreEnabled {
res.SetError(filestore.ErrUrlstoreNotEnabled, cmdkit.ErrNormal)
return
return filestore.ErrUrlstoreNotEnabled
}
useTrickledag, _ := req.Options[trickleOptionName].(bool)
hreq, err := http.NewRequest("GET", url, nil)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
hres, err := http.DefaultClient.Do(hreq)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
if hres.StatusCode != http.StatusOK {
res.SetError(fmt.Errorf("expected code 200, got: %d", hres.StatusCode), cmdkit.ErrNormal)
return
return fmt.Errorf("expected code 200, got: %d", hres.StatusCode)
}
chk := chunk.NewSizeSplitter(hres.Body, chunk.DefaultBlockSize)
@ -111,14 +104,14 @@ time.
}
root, err := layout(dbp.New(chk))
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
cmds.EmitOnce(res, BlockStat{
err = cmds.EmitOnce(res, &BlockStat{
Key: root.Cid().String(),
Size: int(hres.ContentLength),
})
return err
},
Encoders: cmds.EncoderMap{
cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, bs *BlockStat) error {

4
core/corehttp/commands.go
View File

@ -14,10 +14,10 @@ import (
"github.com/ipfs/go-ipfs/core"
corecommands "github.com/ipfs/go-ipfs/core/commands"
cmds "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
cmdsHttp "gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds/http"
path "gx/ipfs/QmX7uSbkNz76yNwBhuwYwRbhihLnJqM73VTCjS3UMJud9A/go-path"
config "gx/ipfs/QmYVqYJTVjetcf1guieEgWpK1PZtHPytP624vKzTF1P3r2/go-ipfs-config"
cmds "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds"
cmdsHttp "gx/ipfs/QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE/go-ipfs-cmds/http"
)
var (

4
package.json
View File

@ -300,9 +300,9 @@
"version": "3.0.11"
},
{
"hash": "QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi",
"hash": "QmZVPuwGNz2s9THwLS4psrJGam6NSEQMvDTaaZgNfqQBCE",
"name": "go-ipfs-cmds",
"version": "1.0.22"
"version": "2.0.0-beta2"
},
{
"hash": "QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky",

1
test/sharness/lib/test-lib.sh
View File

@ -26,6 +26,7 @@ fi
# it's too late to pass in --verbose, and --verbose is harder
# to pass through in some cases.
test "$TEST_VERBOSE" = 1 && verbose=t
test "$TEST_IMMEDIATE" = 1 && immediate=t
# source the common hashes first.
. lib/test-lib-hashes.sh