diff --git a/cmd/ipfs/daemon.go b/cmd/ipfs/daemon.go index 5705c3adc..0a3d62112 100644 --- a/cmd/ipfs/daemon.go +++ b/cmd/ipfs/daemon.go @@ -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 diff --git a/cmd/ipfs/init.go b/cmd/ipfs/init.go index f84c6672e..af0b9b3e5 100644 --- a/cmd/ipfs/init.go +++ b/cmd/ipfs/init.go @@ -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) }, } diff --git a/cmd/ipfs/ipfs.go b/cmd/ipfs/ipfs.go index f0ac65758..9c0fca1a4 100644 --- a/cmd/ipfs/ipfs.go +++ b/cmd/ipfs/ipfs.go @@ -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. diff --git a/cmd/ipfs/main.go b/cmd/ipfs/main.go index 390a5178a..e15d1e843 100644 --- a/cmd/ipfs/main.go +++ b/cmd/ipfs/main.go @@ -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" ) diff --git a/commands/legacy/command.go b/commands/legacy/command.go index 7a3bff2b1..cc350a446 100644 --- a/commands/legacy/command.go +++ b/commands/legacy/command.go @@ -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 } } diff --git a/commands/legacy/legacy.go b/commands/legacy/legacy.go index f18308225..018988a9a 100644 --- a/commands/legacy/legacy.go +++ b/commands/legacy/legacy.go @@ -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" ) diff --git a/commands/legacy/legacy_test.go b/commands/legacy/legacy_test.go index 3246d265c..93e6f589b 100644 --- a/commands/legacy/legacy_test.go +++ b/commands/legacy/legacy_test.go @@ -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 } diff --git a/commands/legacy/request.go b/commands/legacy/request.go index 77fdb9fc6..28d85ffdb 100644 --- a/commands/legacy/request.go +++ b/commands/legacy/request.go @@ -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" ) diff --git a/commands/legacy/response.go b/commands/legacy/response.go index e41cd99de..5dfb102b9 100644 --- a/commands/legacy/response.go +++ b/commands/legacy/response.go @@ -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 diff --git a/commands/request.go b/commands/request.go index b666942f2..b5b104ec3 100644 --- a/commands/request.go +++ b/commands/request.go @@ -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 { diff --git a/core/commands/add.go b/core/commands/add.go index 412dc85d9..79b59aafd 100644 --- a/core/commands/add.go +++ b/core/commands/add.go @@ -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{}, diff --git a/core/commands/bitswap.go b/core/commands/bitswap.go index 10581d356..70356c234 100644 --- a/core/commands/bitswap.go +++ b/core/commands/bitswap.go @@ -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 { diff --git a/core/commands/block.go b/core/commands/block.go index d56e793cd..333ed8518 100644 --- a/core/commands/block.go +++ b/core/commands/block.go @@ -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 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{}, diff --git a/core/commands/cat.go b/core/commands/cat.go index 559107828..5b0ef7603 100644 --- a/core/commands/cat.go +++ b/core/commands/cat.go @@ -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 + } }, }, } diff --git a/core/commands/cmdenv/env.go b/core/commands/cmdenv/env.go index 8d9385b1c..6037350c0 100644 --- a/core/commands/cmdenv/env.go +++ b/core/commands/cmdenv/env.go @@ -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. diff --git a/core/commands/commands.go b/core/commands/commands.go index 4b588c308..9f18452e3 100644 --- a/core/commands/commands.go +++ b/core/commands/commands.go @@ -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 { diff --git a/core/commands/commands_test.go b/core/commands/commands_test.go index a3bef025f..19656f9e1 100644 --- a/core/commands/commands_test.go +++ b/core/commands/commands_test.go @@ -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{}) { diff --git a/core/commands/files.go b/core/commands/files.go index ba325752c..c1936c673 100644 --- a/core/commands/files.go +++ b/core/commands/files.go @@ -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='. 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 }, } diff --git a/core/commands/filestore.go b/core/commands/filestore.go index 3fa5c9a37..171ccbfc0 100644 --- a/core/commands/filestore.go +++ b/core/commands/filestore.go @@ -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{}, diff --git a/core/commands/get.go b/core/commands/get.go index 39baac9f8..fb08e8bb3 100644 --- a/core/commands/get.go +++ b/core/commands/get.go @@ -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) }, }, } diff --git a/core/commands/get_test.go b/core/commands/get_test.go index cfd8061c1..ad6ffca9a 100644 --- a/core/commands/get_test.go +++ b/core/commands/get_test.go @@ -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) { diff --git a/core/commands/helptext_test.go b/core/commands/helptext_test.go index 4c1af7a93..f29d25436 100644 --- a/core/commands/helptext_test.go +++ b/core/commands/helptext_test.go @@ -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) { diff --git a/core/commands/keystore.go b/core/commands/keystore.go index ab00a31ff..3e32178b3 100644 --- a/core/commands/keystore.go +++ b/core/commands/keystore.go @@ -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(), diff --git a/core/commands/name/ipns.go b/core/commands/name/ipns.go index e97c395c7..1daabfc75 100644 --- a/core/commands/name/ipns.go +++ b/core/commands/name/ipns.go @@ -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 { diff --git a/core/commands/name/ipnsps.go b/core/commands/name/ipnsps.go index 92ccce979..3f5582a16 100644 --- a/core/commands/name/ipnsps.go +++ b/core/commands/name/ipnsps.go @@ -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."), diff --git a/core/commands/name/name.go b/core/commands/name/name.go index aed92249a..2adcb0068 100644 --- a/core/commands/name/name.go +++ b/core/commands/name/name.go @@ -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 { diff --git a/core/commands/name/publish.go b/core/commands/name/publish.go index c1489baeb..d2e2e02e5 100644 --- a/core/commands/name/publish.go +++ b/core/commands/name/publish.go @@ -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 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: <>.").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 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 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 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 { diff --git a/core/commands/object/object.go b/core/commands/object/object.go index aed2c6780..9beb61e47 100644 --- a/core/commands/object/object.go +++ b/core/commands/object/object.go @@ -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{ diff --git a/core/commands/object/patch.go b/core/commands/object/patch.go index 024ab0aec..4295231a4 100644 --- a/core/commands/object/patch.go +++ b/core/commands/object/patch.go @@ -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) diff --git a/core/commands/pubsub.go b/core/commands/pubsub.go index cc52b5cc9..9321a4fd4 100644 --- a/core/commands/pubsub.go +++ b/core/commands/pubsub.go @@ -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{ diff --git a/core/commands/repo.go b/core/commands/repo.go index 1e35964bc..efef1662c 100644 --- a/core/commands/repo.go +++ b/core/commands/repo.go @@ -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{ diff --git a/core/commands/root.go b/core/commands/root.go index 54bfe5965..07c06bd8e 100644 --- a/core/commands/root.go +++ b/core/commands/root.go @@ -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") diff --git a/core/commands/shutdown.go b/core/commands/shutdown.go index 404f24b96..49db62a74 100644 --- a/core/commands/shutdown.go +++ b/core/commands/shutdown.go @@ -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 }, } diff --git a/core/commands/stat.go b/core/commands/stat.go index 5e5d3a6f0..b57f0bb5a 100644 --- a/core/commands/stat.go +++ b/core/commands/stat.go @@ -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))) + } }, }, } diff --git a/core/commands/urlstore.go b/core/commands/urlstore.go index 6030884fa..151afeaf0 100644 --- a/core/commands/urlstore.go +++ b/core/commands/urlstore.go @@ -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 { diff --git a/core/corehttp/commands.go b/core/corehttp/commands.go index c4d6112cc..df9db75d3 100644 --- a/core/corehttp/commands.go +++ b/core/corehttp/commands.go @@ -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 ( diff --git a/package.json b/package.json index 9922db2e6..a16bd0084 100644 --- a/package.json +++ b/package.json @@ -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", diff --git a/test/sharness/lib/test-lib.sh b/test/sharness/lib/test-lib.sh index 4f60813ca..8a54a6abf 100644 --- a/test/sharness/lib/test-lib.sh +++ b/test/sharness/lib/test-lib.sh @@ -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