start adopting cmds3.0 - lots of errors!
- move go-ipfs-cmds/legacy to go-ipfs/commands/legacy - update cmds,cmdkit; go test ./... ok License: MIT Signed-off-by: keks <keks@cryptoscope.co>
keks committed
Nov 20, 2017 at 15:11 UTC
bd9576fa57a28a1eda14830ffd5bd7a9b18e83e4
71 files changed
+1281
-530
cmd/ipfs/daemon.go
+41
-71
@@ -13,17 +13,17 @@ import (
13
14
utilmain "github.com/ipfs/go-ipfs/cmd/ipfs/util"
15
"github.com/ipfs/go-ipfs/core"
16
- commands "github.com/ipfs/go-ipfs/core/commands"
16
+ oldcmds "github.com/ipfs/go-ipfs/core/commands"
17
corehttp "github.com/ipfs/go-ipfs/core/corehttp"
18
corerepo "github.com/ipfs/go-ipfs/core/corerepo"
19
nodeMount "github.com/ipfs/go-ipfs/fuse/node"
20
fsrepo "github.com/ipfs/go-ipfs/repo/fsrepo"
21
migrate "github.com/ipfs/go-ipfs/repo/fsrepo/migrations"
22
23
- cmds "gx/ipfs/QmP9vZfc5WSjfGTXmwX2EcicMFzmZ6fXn7HTdKYat6ccmH/go-ipfs-cmds"
24
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
23
"gx/ipfs/QmSGL5Uoa6gKHgBBwQG8u1CWKUC8ZnwaZiLgFVTFBR2bxr/go-multiaddr-net"
24
mprome "gx/ipfs/QmSk46nSD78YiuNojYMS8NW6hSCjH95JajqqzzoychZgef/go-metrics-prometheus"
25
+ cmds "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
26
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
27
ma "gx/ipfs/QmW8s4zTsUoX1Q6CeYxVKPyqSKbF7H1YDUyTostBtZ8DaG/go-multiaddr"
28
"gx/ipfs/QmX3QZ5jHEPidwUrymXV1iSCSUhdGxj15sm2gP4jKMef7B/client_golang/prometheus"
29
iconn "gx/ipfs/Qmf82zCaYV8bkztRRoGwwSHVkaYtP2UKBnhpjJz1uFGJjQ/go-libp2p-interface-conn"
@@ -181,9 +181,8 @@ func defaultMux(path string) corehttp.ServeOption {
181
}
182
}
183
184
-func daemonFunc(req cmds.Request, re cmds.ResponseEmitter) {
184
+func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env interface{}) {
185
// Inject metrics before we do anything
186
-
186
err := mprome.Inject()
187
if err != nil {
188
log.Errorf("Injecting prometheus handler for metrics failed with message: %s\n", err.Error())
@@ -192,22 +191,23 @@ func daemonFunc(req cmds.Request, re cmds.ResponseEmitter) {
191
// let the user know we're going.
192
fmt.Printf("Initializing daemon...\n")
193
195
- if managed, _, _ := req.Option(adjustFDLimitKwd).Bool(); managed {
194
+ managefd, _ := req.Options[adjustFDLimitKwd].(bool)
195
+ if managefd {
196
if err := utilmain.ManageFdLimit(); err != nil {
197
log.Errorf("setting file descriptor limit: %s", err)
198
}
199
}
200
201
- ctx := req.InvocContext()
201
+ ctx := env.(*oldcmds.Context)
202
203
go func() {
204
- <-req.Context().Done()
204
+ <-req.Context.Done()
205
fmt.Println("Received interrupt signal, shutting down...")
206
fmt.Println("(Hit ctrl-c again to force-shutdown the daemon.)")
207
}()
208
209
// check transport encryption flag.
210
- unencrypted, _, _ := req.Option(unencryptTransportKwd).Bool()
210
+ unencrypted, _ := req.Options[unencryptTransportKwd].(bool)
211
if unencrypted {
212
log.Warningf(`Running with --%s: All connections are UNENCRYPTED.
213
You will not be able to connect to regular encrypted networks.`, unencryptTransportKwd)
@@ -216,11 +216,7 @@ func daemonFunc(req cmds.Request, re cmds.ResponseEmitter) {
216
217
// first, whether user has provided the initialization flag. we may be
218
// running in an uninitialized state.
219
- initialize, _, err := req.Option(initOptionKwd).Bool()
220
- if err != nil {
221
- re.SetError(err, cmdkit.ErrNormal)
222
- return
223
- }
219
+ initialize, _ := req.Options[initOptionKwd].(bool)
220
221
if initialize {
222
@@ -242,7 +238,7 @@ func daemonFunc(req cmds.Request, re cmds.ResponseEmitter) {
238
re.SetError(err, cmdkit.ErrNormal)
239
return
240
case fsrepo.ErrNeedMigration:
245
- domigrate, found, _ := req.Option(migrateKwd).Bool()
241
+ domigrate, found := req.Options[migrateKwd].(bool)
242
fmt.Println("Found outdated fs-repo, migrations need to be run.")
243
244
if !found {
@@ -281,10 +277,10 @@ func daemonFunc(req cmds.Request, re cmds.ResponseEmitter) {
277
return
278
}
279
284
- offline, _, _ := req.Option(offlineKwd).Bool()
285
- pubsub, _, _ := req.Option(enableFloodSubKwd).Bool()
286
- ipnsps, _, _ := req.Option(enableIPNSPubSubKwd).Bool()
287
- mplex, _, _ := req.Option(enableMultiplexKwd).Bool()
280
+ offline, _ := req.Options[offlineKwd].(bool)
281
+ ipnsps, _, _ := req.Options[enableIPNSPubSubKwd].(bool)
282
+ pubsub, _ := req.Options[enableFloodSubKwd].(bool)
283
+ mplex, _ := req.Options[enableMultiplexKwd].(bool)
284
285
// Start assembling node config
286
ncfg := &core.BuildCfg{
@@ -299,11 +295,7 @@ func daemonFunc(req cmds.Request, re cmds.ResponseEmitter) {
295
//TODO(Kubuxu): refactor Online vs Offline by adding Permanent vs Ephemeral
296
}
297
302
- routingOption, _, err := req.Option(routingOptionKwd).String()
303
- if err != nil {
304
- re.SetError(err, cmdkit.ErrNormal)
305
- return
306
- }
298
+ routingOption, _ := req.Options[routingOptionKwd].(string)
299
switch routingOption {
300
case routingOptionSupernodeKwd:
301
re.SetError(errors.New("supernode routing was never fully implemented and has been removed"), cmdkit.ErrNormal)
@@ -319,7 +311,7 @@ func daemonFunc(req cmds.Request, re cmds.ResponseEmitter) {
311
return
312
}
313
322
- node, err := core.NewNode(req.Context(), ncfg)
314
+ node, err := core.NewNode(req.Context, ncfg)
315
if err != nil {
316
log.Error("error from node construction: ", err)
317
re.SetError(err, cmdkit.ErrNormal)
@@ -340,7 +332,7 @@ func daemonFunc(req cmds.Request, re cmds.ResponseEmitter) {
332
node.Close()
333
334
select {
343
- case <-req.Context().Done():
335
+ case <-req.Context.Done():
336
log.Info("Gracefully shut down daemon")
337
default:
338
}
@@ -351,25 +343,21 @@ func daemonFunc(req cmds.Request, re cmds.ResponseEmitter) {
343
}
344
345
// construct api endpoint - every time
354
- err, apiErrc := serveHTTPApi(req)
346
+ err, apiErrc := serveHTTPApi(req, ctx)
347
if err != nil {
348
re.SetError(err, cmdkit.ErrNormal)
349
return
350
}
351
352
// construct fuse mountpoints - if the user provided the --mount flag
361
- mount, _, err := req.Option(mountKwd).Bool()
362
- if err != nil {
363
- re.SetError(err, cmdkit.ErrNormal)
364
- return
365
- }
353
+ mount, _ := req.Options[mountKwd].(bool)
354
if mount && offline {
355
re.SetError(errors.New("mount is not currently supported in offline mode"),
356
cmdkit.ErrClient)
357
return
358
}
359
if mount {
372
- if err := mountFuse(req); err != nil {
360
+ if err := mountFuse(req, ctx); err != nil {
361
re.SetError(err, cmdkit.ErrNormal)
362
return
363
}
@@ -386,7 +374,7 @@ func daemonFunc(req cmds.Request, re cmds.ResponseEmitter) {
374
var gwErrc <-chan error
375
if len(cfg.Addresses.Gateway) > 0 {
376
var err error
389
- err, gwErrc = serveHTTPGateway(req)
377
+ err, gwErrc = serveHTTPGateway(req, ctx)
378
if err != nil {
379
re.SetError(err, cmdkit.ErrNormal)
380
return
@@ -408,16 +396,13 @@ func daemonFunc(req cmds.Request, re cmds.ResponseEmitter) {
396
}
397
398
// serveHTTPApi collects options, creates listener, prints status message and starts serving requests
411
-func serveHTTPApi(req cmds.Request) (error, <-chan error) {
412
- cfg, err := req.InvocContext().GetConfig()
399
+func serveHTTPApi(req *cmds.Request, cctx *oldcmds.Context) (error, <-chan error) {
400
+ cfg, err := cctx.GetConfig()
401
if err != nil {
402
return fmt.Errorf("serveHTTPApi: GetConfig() failed: %s", err), nil
403
}
404
417
- apiAddr, _, err := req.Option(commands.ApiOption).String()
418
- if err != nil {
419
- return fmt.Errorf("serveHTTPApi: %s", err), nil
420
- }
405
+ apiAddr, _ := req.Options[oldcmds.ApiOption].(string)
406
if apiAddr == "" {
407
apiAddr = cfg.Addresses.API
408
}
@@ -438,10 +423,7 @@ func serveHTTPApi(req cmds.Request) (error, <-chan error) {
423
// because this would open up the api to scripting vulnerabilities.
424
// only the webui objects are allowed.
425
// if you know what you're doing, go ahead and pass --unrestricted-api.
441
- unrestricted, _, err := req.Option(unrestrictedApiAccessKwd).Bool()
442
- if err != nil {
443
- return fmt.Errorf("serveHTTPApi: Option(%s) failed: %s", unrestrictedApiAccessKwd, err), nil
444
- }
426
+ unrestricted, _ := req.Options[unrestrictedApiAccessKwd].(bool)
427
gatewayOpt := corehttp.GatewayOption(false, corehttp.WebUIPaths...)
428
if unrestricted {
429
gatewayOpt = corehttp.GatewayOption(true, "/ipfs", "/ipns")
@@ -449,7 +431,7 @@ func serveHTTPApi(req cmds.Request) (error, <-chan error) {
431
432
var opts = []corehttp.ServeOption{
433
corehttp.MetricsCollectionOption("api"),
452
- corehttp.CommandsOption(*req.InvocContext()),
434
+ corehttp.CommandsOption(*cctx),
435
corehttp.WebUIOption,
436
gatewayOpt,
437
corehttp.VersionOption(),
@@ -463,7 +445,7 @@ func serveHTTPApi(req cmds.Request) (error, <-chan error) {
445
opts = append(opts, corehttp.RedirectOption("", cfg.Gateway.RootRedirect))
446
}
447
466
- node, err := req.InvocContext().ConstructNode()
448
+ node, err := cctx.ConstructNode()
449
if err != nil {
450
return fmt.Errorf("serveHTTPApi: ConstructNode() failed: %s", err), nil
451
}
@@ -512,8 +494,8 @@ func printSwarmAddrs(node *core.IpfsNode) {
494
}
495
496
// serveHTTPGateway collects options, creates listener, prints status message and starts serving requests
515
-func serveHTTPGateway(req cmds.Request) (error, <-chan error) {
516
- cfg, err := req.InvocContext().GetConfig()
497
+func serveHTTPGateway(req *cmds.Request, cctx *oldcmds.Context) (error, <-chan error) {
498
+ cfg, err := cctx.GetConfig()
499
if err != nil {
500
return fmt.Errorf("serveHTTPGateway: GetConfig() failed: %s", err), nil
501
}
@@ -523,10 +505,7 @@ func serveHTTPGateway(req cmds.Request) (error, <-chan error) {
505
return fmt.Errorf("serveHTTPGateway: invalid gateway address: %q (err: %s)", cfg.Addresses.Gateway, err), nil
506
}
507
526
- writable, writableOptionFound, err := req.Option(writableKwd).Bool()
527
- if err != nil {
528
- return fmt.Errorf("serveHTTPGateway: req.Option(%s) failed: %s", writableKwd, err), nil
529
- }
508
+ writable, writableOptionFound := req.Options[writableKwd].(bool)
509
if !writableOptionFound {
510
writable = cfg.Gateway.Writable
511
}
@@ -546,7 +525,7 @@ func serveHTTPGateway(req cmds.Request) (error, <-chan error) {
525
526
var opts = []corehttp.ServeOption{
527
corehttp.MetricsCollectionOption("gateway"),
549
- corehttp.CommandsROOption(*req.InvocContext()),
528
+ corehttp.CommandsROOption(*cctx),
529
corehttp.VersionOption(),
530
corehttp.IPNSHostnameOption(),
531
corehttp.GatewayOption(writable, "/ipfs", "/ipns"),
@@ -556,7 +535,7 @@ func serveHTTPGateway(req cmds.Request) (error, <-chan error) {
535
opts = append(opts, corehttp.RedirectOption("", cfg.Gateway.RootRedirect))
536
}
537
559
- node, err := req.InvocContext().ConstructNode()
538
+ node, err := cctx.ConstructNode()
539
if err != nil {
540
return fmt.Errorf("serveHTTPGateway: ConstructNode() failed: %s", err), nil
541
}
@@ -570,29 +549,23 @@ func serveHTTPGateway(req cmds.Request) (error, <-chan error) {
549
}
550
551
//collects options and opens the fuse mountpoint
573
-func mountFuse(req cmds.Request) error {
574
- cfg, err := req.InvocContext().GetConfig()
552
+func mountFuse(req *cmds.Request, cctx *oldcmds.Context) error {
553
+ cfg, err := cctx.GetConfig()
554
if err != nil {
555
return fmt.Errorf("mountFuse: GetConfig() failed: %s", err)
556
}
557
579
- fsdir, found, err := req.Option(ipfsMountKwd).String()
580
- if err != nil {
581
- return fmt.Errorf("mountFuse: req.Option(%s) failed: %s", ipfsMountKwd, err)
582
- }
558
+ fsdir, found := req.Options[ipfsMountKwd].(string)
559
if !found {
560
fsdir = cfg.Mounts.IPFS
561
}
562
587
- nsdir, found, err := req.Option(ipnsMountKwd).String()
588
- if err != nil {
589
- return fmt.Errorf("mountFuse: req.Option(%s) failed: %s", ipnsMountKwd, err)
590
- }
563
+ nsdir, found := req.Options[ipnsMountKwd].(string)
564
if !found {
565
nsdir = cfg.Mounts.IPNS
566
}
567
595
- node, err := req.InvocContext().ConstructNode()
568
+ node, err := cctx.ConstructNode()
569
if err != nil {
570
return fmt.Errorf("mountFuse: ConstructNode() failed: %s", err)
571
}
@@ -606,18 +579,15 @@ func mountFuse(req cmds.Request) error {
579
return nil
580
}
581
609
-func maybeRunGC(req cmds.Request, node *core.IpfsNode) (error, <-chan error) {
610
- enableGC, _, err := req.Option(enableGCKwd).Bool()
611
- if err != nil {
612
- return err, nil
613
- }
582
+func maybeRunGC(req *cmds.Request, node *core.IpfsNode) (error, <-chan error) {
583
+ enableGC, _ := req.Options[enableGCKwd].(bool)
584
if !enableGC {
585
return nil, nil
586
}
587
588
errc := make(chan error)
589
go func() {
620
- errc <- corerepo.PeriodicGC(req.Context(), node)
590
+ errc <- corerepo.PeriodicGC(req.Context, node)
591
close(errc)
592
}()
593
return nil, errc
cmd/ipfs/init.go
+1
-1
@@ -17,7 +17,7 @@ import (
17
config "github.com/ipfs/go-ipfs/repo/config"
18
fsrepo "github.com/ipfs/go-ipfs/repo/fsrepo"
19
20
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
20
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
21
)
22
23
const (
cmd/ipfs/ipfs.go
+3
-10
@@ -3,10 +3,10 @@ package main
3
import (
4
"fmt"
5
6
- oldcmds "github.com/ipfs/go-ipfs/commands"
6
commands "github.com/ipfs/go-ipfs/core/commands"
7
9
- cmds "gx/ipfs/QmP9vZfc5WSjfGTXmwX2EcicMFzmZ6fXn7HTdKYat6ccmH/go-ipfs-cmds"
8
+ lgc "github.com/ipfs/go-ipfs/commands/legacy"
9
+ cmds "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
10
)
11
12
// This is the CLI root, used for executing commands accessible to CLI clients.
@@ -24,7 +24,7 @@ var commandsClientCmd = commands.CommandsCmd(Root)
24
// They can override subcommands in commands.Root by defining a subcommand with the same name.
25
var localCommands = map[string]*cmds.Command{
26
"daemon": daemonCmd,
27
- "init": cmds.NewCommand(initCmd),
27
+ "init": lgc.NewCommand(initCmd),
28
"commands": commandsClientCmd,
29
}
30
var localMap = make(map[*cmds.Command]bool)
@@ -33,14 +33,7 @@ func init() {
33
// setting here instead of in literal to prevent initialization loop
34
// (some commands make references to Root)
35
Root.Subcommands = localCommands
36
- Root.OldSubcommands = map[string]*oldcmds.Command{}
36
38
- // copy all subcommands from commands.Root into this root (if they aren't already present)
39
- for k, v := range commands.Root.OldSubcommands {
40
- if _, found := Root.OldSubcommands[k]; !found {
41
- Root.OldSubcommands[k] = v
42
- }
43
- }
37
for k, v := range commands.Root.Subcommands {
38
if _, found := Root.Subcommands[k]; !found {
39
Root.Subcommands[k] = v
cmd/ipfs/main.go
+60
-77
@@ -18,6 +18,7 @@ import (
18
"syscall"
19
"time"
20
21
+ oldcmds "github.com/ipfs/go-ipfs/commands"
22
core "github.com/ipfs/go-ipfs/core"
23
coreCmds "github.com/ipfs/go-ipfs/core/commands"
24
"github.com/ipfs/go-ipfs/plugin/loader"
@@ -33,6 +34,10 @@ import (
34
manet "gx/ipfs/QmSGL5Uoa6gKHgBBwQG8u1CWKUC8ZnwaZiLgFVTFBR2bxr/go-multiaddr-net"
35
logging "gx/ipfs/QmSpJByNKFX1sCsHBEp3R73FL4NF6FnQTEGyNAXHm2GS52/go-log"
36
loggables "gx/ipfs/QmSvcDkiRwB8LuMhUtnvhum2C851Mproo75ZDD19jx43tD/go-libp2p-loggables"
37
+ "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
38
+ "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds/cli"
39
+ "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds/http"
40
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
41
ma "gx/ipfs/QmW8s4zTsUoX1Q6CeYxVKPyqSKbF7H1YDUyTostBtZ8DaG/go-multiaddr"
42
osh "gx/ipfs/QmXuBJ7DR6k3rmUEKtvVMhwjmXDuJgXXPUt4LQXKBMsU93/go-os-helper"
43
)
@@ -49,10 +54,9 @@ const (
54
)
55
56
type cmdInvocation struct {
52
- path []string
53
- cmd *cmds.Command
54
- req cmds.Request
57
+ req *cmds.Request
58
node *core.IpfsNode
59
+ ctx *oldcmds.Context
60
}
61
62
type exitErr int
@@ -100,12 +104,17 @@ func mainRet() int {
104
helpFunc = cli.LongHelp
105
}
106
103
- helpFunc("ipfs", Root, invoc.path, w)
107
+ var p []string
108
+ if invoc.req != nil {
109
+ p = invoc.req.Path
110
+ }
111
+
112
+ helpFunc("ipfs", Root, p, w)
113
}
114
115
// this is a message to tell the user how to get the help text
116
printMetaHelp := func(w io.Writer) {
108
- cmdPath := strings.Join(invoc.path, " ")
117
+ cmdPath := strings.Join(invoc.req.Path, " ")
118
fmt.Fprintf(w, "Use 'ipfs %s --help' for information about this command\n", cmdPath)
119
}
120
@@ -119,6 +128,9 @@ func mainRet() int {
128
}
129
}
130
131
+ intrh, ctx := invoc.SetupInterruptHandler(ctx)
132
+ defer intrh.Close()
133
+
134
// parse the commandline into a command invocation
135
parseErr := invoc.Parse(ctx, os.Args[1:])
136
@@ -142,7 +154,7 @@ func mainRet() int {
154
printErr(parseErr)
155
156
// this was a user error, print help.
145
- if invoc.cmd != nil {
157
+ if invoc.req != nil && invoc.req.Command != nil {
158
// we need a newline space.
159
fmt.Fprintf(os.Stderr, "\n")
160
printHelp(false, os.Stderr)
@@ -153,15 +165,12 @@ func mainRet() int {
165
// here we handle the cases where
166
// - commands with no Run func are invoked directly.
167
// - the main command is invoked.
156
- if invoc.cmd == nil || invoc.cmd.Run == nil {
168
+ if invoc.req == nil || invoc.req.Command == nil || invoc.req.Command.Run == nil {
169
printHelp(false, os.Stdout)
170
return 0
171
}
172
173
// ok, finally, run the command invocation.
162
- intrh, ctx := invoc.SetupInterruptHandler(ctx)
163
- defer intrh.Close()
164
-
174
err = invoc.Run(ctx)
175
if err != nil {
176
if code, ok := err.(exitErr); ok {
@@ -184,10 +193,7 @@ func mainRet() int {
193
func (i *cmdInvocation) Run(ctx context.Context) error {
194
195
// check if user wants to debug. option OR env var.
187
- debug, _, err := i.req.Option("debug").Bool()
188
- if err != nil {
189
- return err
190
- }
196
+ debug, _ := i.req.Options["debug"].(bool)
197
if debug || os.Getenv("IPFS_LOGGING") == "debug" {
198
u.Debug = true
199
logging.SetDebugLogging()
@@ -196,8 +202,7 @@ func (i *cmdInvocation) Run(ctx context.Context) error {
202
u.Debug = true
203
}
204
199
- err = callCommand(ctx, i.req, Root, i.cmd)
200
- return err
205
+ return callCommand(ctx, i.req, Root, i.ctx)
206
}
207
208
func (i *cmdInvocation) constructNodeFunc(ctx context.Context) func() (*core.IpfsNode, error) {
@@ -206,12 +211,7 @@ func (i *cmdInvocation) constructNodeFunc(ctx context.Context) func() (*core.Ipf
211
return nil, errors.New("constructing node without a request")
212
}
213
209
- cmdctx := i.req.InvocContext()
210
- if cmdctx == nil {
211
- return nil, errors.New("constructing node without a request context")
212
- }
213
-
214
- r, err := fsrepo.Open(i.req.InvocContext().ConfigRoot)
214
+ r, err := fsrepo.Open(i.ctx.ConfigRoot)
215
if err != nil { // repo is owned by the node
216
return nil, err
217
}
@@ -219,7 +219,7 @@ func (i *cmdInvocation) constructNodeFunc(ctx context.Context) func() (*core.Ipf
219
// ok everything is good. set it on the invocation (for ownership)
220
// and return it.
221
n, err = core.NewNode(ctx, &core.BuildCfg{
222
- Online: cmdctx.Online,
222
+ Online: i.ctx.Online,
223
Repo: r,
224
})
225
if err != nil {
@@ -244,11 +244,17 @@ func (i *cmdInvocation) close() {
244
func (i *cmdInvocation) Parse(ctx context.Context, args []string) error {
245
var err error
246
247
- i.req, i.cmd, i.path, err = cli.Parse(args, os.Stdin, Root)
247
+ i.req, err = cli.Parse(args, os.Stdin, Root)
248
if err != nil {
249
return err
250
}
251
252
+ //TODO remove this
253
+ //fmt.Printf("%#v\n", i.req)
254
+
255
+ // TODO(keks): pass this as arg to cli.Parse()
256
+ i.req.Context = ctx
257
+
258
repoPath, err := getRepoPath(i.req)
259
if err != nil {
260
return err
@@ -256,20 +262,22 @@ func (i *cmdInvocation) Parse(ctx context.Context, args []string) error {
262
log.Debugf("config path is %s", repoPath)
263
264
// this sets up the function that will initialize the config lazily.
259
- cmdctx := i.req.InvocContext()
260
- cmdctx.ConfigRoot = repoPath
261
- cmdctx.LoadConfig = loadConfig
265
+ if i.ctx == nil {
266
+ i.ctx = &oldcmds.Context{}
267
+ }
268
+ i.ctx.ConfigRoot = repoPath
269
+ i.ctx.LoadConfig = loadConfig
270
// this sets up the function that will initialize the node
271
// this is so that we can construct the node lazily.
264
- cmdctx.ConstructNode = i.constructNodeFunc(ctx)
272
+ i.ctx.ConstructNode = i.constructNodeFunc(ctx)
273
274
// if no encoding was specified by user, default to plaintext encoding
275
// (if command doesn't support plaintext, use JSON instead)
268
- if !i.req.Option("encoding").Found() {
269
- if i.req.Command().Encoders != nil && i.req.Command().Encoders[cmds.Text] != nil {
270
- i.req.SetOption("encoding", cmds.Text)
276
+ if enc := i.req.Options[cmds.EncShort]; enc == "" {
277
+ if i.req.Command.Encoders != nil && i.req.Command.Encoders[cmds.Text] != nil {
278
+ i.req.SetOption(cmds.EncShort, cmds.Text)
279
} else {
272
- i.req.SetOption("encoding", cmds.JSON)
280
+ i.req.SetOption(cmds.EncShort, cmds.JSON)
281
}
282
}
283
@@ -277,18 +285,12 @@ func (i *cmdInvocation) Parse(ctx context.Context, args []string) error {
285
}
286
287
func (i *cmdInvocation) requestedHelp() (short bool, long bool, err error) {
280
- longHelp, _, err := i.req.Option("help").Bool()
281
- if err != nil {
282
- return false, false, err
283
- }
284
- shortHelp, _, err := i.req.Option("h").Bool()
285
- if err != nil {
286
- return false, false, err
287
- }
288
+ longHelp, _ := i.req.Options["help"].(bool)
289
+ shortHelp, _ := i.req.Options["h"].(bool)
290
return longHelp, shortHelp, nil
291
}
292
291
-func callPreCommandHooks(ctx context.Context, details cmdDetails, req cmds.Request, root *cmds.Command) error {
293
+func callPreCommandHooks(ctx context.Context, details cmdDetails, req *cmds.Request, root *cmds.Command) error {
294
295
log.Event(ctx, "callPreCommandHooks", &details)
296
log.Debug("calling pre-command hooks...")
@@ -296,20 +298,16 @@ func callPreCommandHooks(ctx context.Context, details cmdDetails, req cmds.Reque
298
return nil
299
}
300
299
-func callCommand(ctx context.Context, req cmds.Request, root *cmds.Command, cmd *cmds.Command) error {
300
- log.Info(config.EnvDir, " ", req.InvocContext().ConfigRoot)
301
+func callCommand(ctx context.Context, req *cmds.Request, root *cmds.Command, cctx *oldcmds.Context) error {
302
+ log.Info(config.EnvDir, " ", cctx.ConfigRoot)
303
+ cmd := req.Command
304
302
- err := req.SetRootContext(ctx)
305
+ details, err := commandDetails(req.Path, root)
306
if err != nil {
307
return err
308
}
309
307
- details, err := commandDetails(req.Path(), root)
308
- if err != nil {
309
- return err
310
- }
311
-
312
- client, err := commandShouldRunOnDaemon(*details, req, root)
310
+ client, err := commandShouldRunOnDaemon(*details, req, root, cctx)
311
if err != nil {
312
return err
313
}
@@ -319,11 +317,7 @@ func callCommand(ctx context.Context, req cmds.Request, root *cmds.Command, cmd
317
return err
318
}
319
322
- encTypeStr, found, err := req.Option("encoding").String()
323
- if !found || err != nil {
324
- log.Error("error getting encoding - using JSON. reason: ", err)
325
- encTypeStr = "json"
326
- }
320
+ encTypeStr, _ := req.Options[cmds.EncShort].(string)
321
encType := cmds.EncodingType(encTypeStr)
322
323
var (
@@ -341,7 +335,7 @@ func callCommand(ctx context.Context, req cmds.Request, root *cmds.Command, cmd
335
}
336
337
if cmd.PreRun != nil {
344
- err = cmd.PreRun(req)
338
+ err = cmd.PreRun(req, cctx)
339
if err != nil {
340
return err
341
}
@@ -375,19 +369,14 @@ func callCommand(ctx context.Context, req cmds.Request, root *cmds.Command, cmd
369
} else {
370
log.Debug("executing command locally")
371
378
- pluginpath := filepath.Join(req.InvocContext().ConfigRoot, "plugins")
372
+ pluginpath := filepath.Join(cctx.ConfigRoot, "plugins")
373
if _, err := loader.LoadPlugins(pluginpath); err != nil {
374
return err
375
}
376
383
- err := req.SetRootContext(ctx)
384
- if err != nil {
385
- return err
386
- }
387
-
377
// Okay!!!!! NOW we can call the command.
378
go func() {
390
- err := root.Call(req, re)
379
+ err := root.Call(req, re, cctx)
380
if err != nil {
381
re.SetError(err, cmdkit.ErrNormal)
382
}
@@ -428,8 +417,8 @@ func commandDetails(path []string, root *cmds.Command) (*cmdDetails, error) {
417
// It returns a client if the command should be executed on a daemon and nil if
418
// it should be executed on a client. It returns an error if the command must
419
// NOT be executed on either.
431
-func commandShouldRunOnDaemon(details cmdDetails, req cmds.Request, root *cmds.Command) (http.Client, error) {
432
- path := req.Path()
420
+func commandShouldRunOnDaemon(details cmdDetails, req *cmds.Request, root *cmds.Command, cctx *oldcmds.Context) (http.Client, error) {
421
+ path := req.Path
422
// root command.
423
if len(path) < 1 {
424
return nil, nil
@@ -447,14 +436,11 @@ func commandShouldRunOnDaemon(details cmdDetails, req cmds.Request, root *cmds.C
436
// to this point so that we dont check unnecessarily
437
438
// did user specify an api to use for this command?
450
- apiAddrStr, _, err := req.Option(coreCmds.ApiOption).String()
451
- if err != nil {
452
- return nil, err
453
- }
439
+ apiAddrStr, _ := req.Options[coreCmds.ApiOption].(string)
440
455
- client, err := getApiClient(req.InvocContext().ConfigRoot, apiAddrStr)
441
+ client, err := getApiClient(cctx.ConfigRoot, apiAddrStr)
442
if err == repo.ErrApiNotRunning {
457
- if apiAddrStr != "" && req.Command() != daemonCmd {
443
+ if apiAddrStr != "" && req.Command != daemonCmd {
444
// if user SPECIFIED an api, and this cmd is not daemon
445
// we MUST use it. so error out.
446
return nil, err
@@ -469,7 +455,7 @@ func commandShouldRunOnDaemon(details cmdDetails, req cmds.Request, root *cmds.C
455
if details.cannotRunOnDaemon {
456
// check if daemon locked. legacy error text, for now.
457
log.Debugf("Command cannot run on daemon. Checking if daemon is locked")
472
- if daemonLocked, _ := fsrepo.LockedByOtherProcess(req.InvocContext().ConfigRoot); daemonLocked {
458
+ if daemonLocked, _ := fsrepo.LockedByOtherProcess(cctx.ConfigRoot); daemonLocked {
459
return nil, cmds.ClientError("ipfs daemon is running. please stop it to run this command")
460
}
461
return nil, nil
@@ -493,11 +479,8 @@ func isClientError(err error) bool {
479
return false
480
}
481
496
-func getRepoPath(req cmds.Request) (string, error) {
497
- repoOpt, found, err := req.Option("config").String()
498
- if err != nil {
499
- return "", err
500
- }
482
+func getRepoPath(req *cmds.Request) (string, error) {
483
+ repoOpt, found := req.Options["config"].(string)
484
if found && repoOpt != "" {
485
return repoOpt, nil
486
}
cmd/ipfs/main_test.go
+1
-1
@@ -3,7 +3,7 @@ package main
3
import (
4
"testing"
5
6
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
6
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
7
)
8
9
func TestIsCientErr(t *testing.T) {
cmd/ipfswatch/main.go
+1
@@ -9,6 +9,7 @@ import (
9
"path/filepath"
10
"syscall"
11
12
+ commands "github.com/ipfs/go-ipfs/commands"
13
core "github.com/ipfs/go-ipfs/core"
14
corehttp "github.com/ipfs/go-ipfs/core/corehttp"
15
coreunix "github.com/ipfs/go-ipfs/core/coreunix"
commands/command.go
+6
-4
@@ -15,8 +15,10 @@ import (
15
"reflect"
16
17
"github.com/ipfs/go-ipfs/path"
18
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
18
+
19
logging "gx/ipfs/QmSpJByNKFX1sCsHBEp3R73FL4NF6FnQTEGyNAXHm2GS52/go-log"
20
+ cmds "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
21
+ cmdkit "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
22
)
23
24
var log = logging.Logger("command")
@@ -283,9 +285,9 @@ func ClientError(msg string) error {
285
286
// global options, added to every command
287
var globalOptions = []cmdkit.Option{
286
- cmdkit.OptionEncodingType,
287
- cmdkit.OptionStreamChannels,
288
- cmdkit.OptionTimeout,
288
+ cmds.OptionEncodingType,
289
+ cmds.OptionStreamChannels,
290
+ cmds.OptionTimeout,
291
}
292
293
// the above array of Options, wrapped in a Command
commands/command_test.go
+3
-2
@@ -3,7 +3,8 @@ package commands
3
import (
4
"testing"
5
6
- cmdkit "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
6
+ cmds "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
7
+ cmdkit "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
8
)
9
10
func noop(req Request, res Response) {
@@ -58,7 +59,7 @@ func TestOptionValidation(t *testing.T) {
59
}
60
61
req, _ = NewRequest(nil, nil, nil, nil, nil, opts)
61
- req.SetOption(cmdkit.EncShort, "json")
62
+ req.SetOption(cmds.EncShort, "json")
63
res = cmd.Call(req)
64
if res.Error() != nil {
65
t.Error("Should have passed")
commands/legacy/command.go
new
+70
@@ -0,0 +1,70 @@
1
+package legacy
2
+
3
+import (
4
+ "io"
5
+
6
+ "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
7
+
8
+ oldcmds "github.com/ipfs/go-ipfs/commands"
9
+ logging "gx/ipfs/QmSpJByNKFX1sCsHBEp3R73FL4NF6FnQTEGyNAXHm2GS52/go-log"
10
+)
11
+
12
+var log = logging.Logger("cmds/lgc")
13
+
14
+// NewCommand returns a Command from an oldcmds.Command
15
+func NewCommand(oldcmd *oldcmds.Command) *cmds.Command {
16
+ if oldcmd == nil {
17
+ return nil
18
+ }
19
+ var cmd *cmds.Command
20
+
21
+ cmd = &cmds.Command{
22
+ Options: oldcmd.Options,
23
+ Arguments: oldcmd.Arguments,
24
+ Helptext: oldcmd.Helptext,
25
+ External: oldcmd.External,
26
+ Type: oldcmd.Type,
27
+
28
+ Subcommands: make(map[string]*cmds.Command),
29
+ }
30
+
31
+ if oldcmd.Run != nil {
32
+ cmd.Run = func(req *cmds.Request, re cmds.ResponseEmitter, env interface{}) {
33
+ oldReq := &requestWrapper{req, OldContext(env)}
34
+ res := &fakeResponse{req: oldReq, re: re, wait: make(chan struct{})}
35
+
36
+ errCh := make(chan error)
37
+ go res.Send(errCh)
38
+ oldcmd.Run(oldReq, res)
39
+ err := <-errCh
40
+ if err != nil {
41
+ log.Error(err)
42
+ }
43
+ }
44
+ }
45
+
46
+ if oldcmd.PreRun != nil {
47
+ cmd.PreRun = func(req *cmds.Request, env interface{}) error {
48
+ oldReq := &requestWrapper{req, OldContext(env)}
49
+ return oldcmd.PreRun(oldReq)
50
+ }
51
+ }
52
+
53
+ for name, sub := range oldcmd.Subcommands {
54
+ cmd.Subcommands[name] = NewCommand(sub)
55
+ }
56
+
57
+ cmd.Encoders = make(cmds.EncoderMap)
58
+
59
+ for encType, m := range oldcmd.Marshalers {
60
+ cmd.Encoders[cmds.EncodingType(encType)] = func(m oldcmds.Marshaler, encType oldcmds.EncodingType) func(req *cmds.Request) func(io.Writer) cmds.Encoder {
61
+ return func(req *cmds.Request) func(io.Writer) cmds.Encoder {
62
+ return func(w io.Writer) cmds.Encoder {
63
+ return NewMarshalerEncoder(req, m, w)
64
+ }
65
+ }
66
+ }(m, encType)
67
+ }
68
+
69
+ return cmd
70
+}
commands/legacy/legacy.go
new
+81
@@ -0,0 +1,81 @@
1
+package legacy
2
+
3
+import (
4
+ "io"
5
+ "runtime/debug"
6
+
7
+ "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
8
+
9
+ oldcmds "github.com/ipfs/go-ipfs/commands"
10
+)
11
+
12
+// MarshalerEncoder implements Encoder from a Marshaler
13
+type MarshalerEncoder struct {
14
+ m oldcmds.Marshaler
15
+ w io.Writer
16
+ req *cmds.Request
17
+}
18
+
19
+// NewMarshalerEncoder returns a new MarshalerEncoder
20
+func NewMarshalerEncoder(req *cmds.Request, m oldcmds.Marshaler, w io.Writer) *MarshalerEncoder {
21
+ me := &MarshalerEncoder{
22
+ m: m,
23
+ w: w,
24
+ req: req,
25
+ }
26
+
27
+ return me
28
+}
29
+
30
+// Encode encodes v onto the io.Writer w using Marshaler m, with both m and w passed in NewMarshalerEncoder
31
+func (me *MarshalerEncoder) Encode(v interface{}) error {
32
+ re, res := cmds.NewChanResponsePair(me.req)
33
+ go re.Emit(v)
34
+
35
+ r, err := me.m(&responseWrapper{Response: res})
36
+ if err != nil {
37
+ return err
38
+ }
39
+ if r == nil {
40
+ // behave like empty reader
41
+ return nil
42
+ }
43
+
44
+ _, err = io.Copy(me.w, r)
45
+ return err
46
+}
47
+
48
+func OldContext(env interface{}) *oldcmds.Context {
49
+ ctx, ok := env.(*oldcmds.Context)
50
+ if !ok {
51
+ log.Errorf("OldContext: env passed is not %T but %T\n%s", ctx, env, debug.Stack())
52
+ }
53
+
54
+ return ctx
55
+}
56
+
57
+/*
58
+// OldReqLog returns an oldcmds.ReqLog from a ReqLog
59
+func OldReqLog(newrl *ReqLog) *oldcmds.ReqLog {
60
+ if newrl == nil {
61
+ return nil
62
+ }
63
+
64
+ rl := &oldcmds.ReqLog{}
65
+
66
+ for _, rle := range newrl.Requests {
67
+ oldrle := &oldcmds.ReqLogEntry{
68
+ StartTime: rle.StartTime,
69
+ EndTime: rle.EndTime,
70
+ Active: rle.Active,
71
+ Command: rle.Command,
72
+ Options: rle.Options,
73
+ Args: rle.Args,
74
+ ID: rle.ID,
75
+ }
76
+ rl.AddEntry(oldrle)
77
+ }
78
+
79
+ return rl
80
+}
81
+*/
commands/legacy/legacy_test.go
new
+214
@@ -0,0 +1,214 @@
1
+package legacy
2
+
3
+import (
4
+ "bytes"
5
+ "context"
6
+ "io"
7
+ "testing"
8
+
9
+ oldcmds "github.com/ipfs/go-ipfs/commands"
10
+ cmds "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
11
+ cmdkit "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
12
+)
13
+
14
+type WriteNopCloser struct {
15
+ io.Writer
16
+}
17
+
18
+func (wc WriteNopCloser) Close() error {
19
+ return nil
20
+}
21
+
22
+func TestNewCommand(t *testing.T) {
23
+ root := &cmds.Command{
24
+ Subcommands: map[string]*cmds.Command{
25
+ "test": NewCommand(&oldcmds.Command{
26
+ Run: func(req oldcmds.Request, res oldcmds.Response) {
27
+ res.SetOutput("Test.")
28
+ },
29
+ Marshalers: map[oldcmds.EncodingType]oldcmds.Marshaler{
30
+ oldcmds.Text: func(res oldcmds.Response) (io.Reader, error) {
31
+ ch, ok := res.Output().(<-chan interface{})
32
+ if !ok {
33
+ t.Fatalf("output is not <-chan interface{} but %T", ch)
34
+ }
35
+
36
+ v := <-ch
37
+ str, ok := v.(string)
38
+ if !ok {
39
+ t.Fatalf("read value is not string but %T", v)
40
+ }
41
+
42
+ buf := bytes.NewBuffer(nil)
43
+ _, err := io.WriteString(buf, str)
44
+ if err != nil {
45
+ t.Fatal(err)
46
+ }
47
+
48
+ return buf, nil
49
+ },
50
+ },
51
+ Subcommands: map[string]*oldcmds.Command{
52
+ "sub": &oldcmds.Command{
53
+ Options: []cmdkit.Option{
54
+ cmdkit.NewOption(cmdkit.String, "test", "t", "some random test flag"),
55
+ },
56
+ },
57
+ },
58
+ }),
59
+ },
60
+ }
61
+
62
+ path := []string{"test"}
63
+ req, err := cmds.NewRequest(context.TODO(), path, nil, nil, nil, root)
64
+ if err != nil {
65
+ t.Fatal(err)
66
+ }
67
+
68
+ buf := bytes.NewBuffer(nil)
69
+
70
+ // test calling "test" command
71
+ testCmd := root.Subcommand("test")
72
+ enc := testCmd.Encoders[oldcmds.Text]
73
+ if enc == nil {
74
+ t.Fatal("got nil encoder")
75
+ }
76
+
77
+ re := cmds.NewWriterResponseEmitter(WriteNopCloser{buf}, req, enc)
78
+
79
+ var env oldcmds.Context
80
+
81
+ err = root.Call(req, re, &env)
82
+ if err != nil {
83
+ t.Fatal(err)
84
+ }
85
+
86
+ expected := "Test."
87
+
88
+ if buf.String() != expected {
89
+ t.Fatalf("expected string %#v but got %#v", expected, buf.String())
90
+ }
91
+
92
+ // test getting subcommand
93
+ subCmd := testCmd.Subcommand("sub")
94
+ if subCmd == nil {
95
+ t.Fatal("got nil subcommand")
96
+ }
97
+
98
+ if nOpts := len(subCmd.Options); nOpts != 1 {
99
+ t.Fatalf("subcommand has %v options, expected 1", nOpts)
100
+ }
101
+
102
+ opt := subCmd.Options[0]
103
+
104
+ if nNames := len(opt.Names()); nNames != 2 {
105
+ t.Fatalf("option has %v names, expected 2", nNames)
106
+ }
107
+
108
+ names := opt.Names()
109
+ if names[0] != "test" {
110
+ t.Fatalf("option has name %q, expected %q", names[0], "test")
111
+ }
112
+
113
+ if names[1] != "t" {
114
+ t.Fatalf("option has name %q, expected %q", names[1], "t")
115
+ }
116
+}
117
+
118
+func TestPipePair(t *testing.T) {
119
+ cmd := &cmds.Command{Type: "string"}
120
+
121
+ req, err := cmds.NewRequest(context.TODO(), nil, nil, nil, nil, cmd)
122
+ if err != nil {
123
+ t.Fatal(err)
124
+ }
125
+
126
+ r, w := io.Pipe()
127
+ re := cmds.NewWriterResponseEmitter(w, req, cmds.Encoders[cmds.JSON])
128
+ res := cmds.NewReaderResponse(r, cmds.JSON, req)
129
+
130
+ wait := make(chan interface{})
131
+
132
+ expect := "abc"
133
+ go func() {
134
+ err := re.Emit(expect)
135
+ if err != nil {
136
+ t.Fatal(err)
137
+ }
138
+
139
+ close(wait)
140
+ }()
141
+
142
+ v, err := res.Next()
143
+ if err != nil {
144
+ t.Fatal(err)
145
+ }
146
+ str, ok := v.(*string)
147
+ if !ok {
148
+ t.Fatalf("expected type %T but got %T", expect, v)
149
+ }
150
+ if *str != expect {
151
+ t.Fatalf("expected value %#v but got %#v", expect, v)
152
+ }
153
+
154
+ <-wait
155
+
156
+}
157
+
158
+func TestTeeEmitter(t *testing.T) {
159
+ req, err := cmds.NewRequest(nil, nil, nil, nil, nil, nil)
160
+ if err != nil {
161
+ t.Fatal(err)
162
+ }
163
+
164
+ buf1 := bytes.NewBuffer(nil)
165
+ re1 := cmds.NewWriterResponseEmitter(WriteNopCloser{buf1}, req, cmds.Encoders[cmds.Text])
166
+
167
+ buf2 := bytes.NewBuffer(nil)
168
+ re2 := cmds.NewWriterResponseEmitter(WriteNopCloser{buf2}, req, cmds.Encoders[cmds.Text])
169
+
170
+ re := cmds.NewTeeEmitter(re1, re2)
171
+
172
+ expect := "def"
173
+ err = re.Emit(expect)
174
+ if err != nil {
175
+ t.Fatal(err)
176
+ }
177
+
178
+ if buf1.String() != expect {
179
+ t.Fatal("expected %#v, got %#v", expect, buf1.String())
180
+ }
181
+
182
+ if buf2.String() != expect {
183
+ t.Fatal("expected %#v, got %#v", expect, buf2.String())
184
+ }
185
+}
186
+
187
+/*
188
+type teeErrorTestCase struct {
189
+ err1, err2 error
190
+ bothNil bool
191
+ errString string
192
+}
193
+
194
+func TestTeeError(t *testing.T) {
195
+ tcs := []teeErrorTestCase{
196
+ teeErrorTestCase{nil, nil, true, ""},
197
+ teeErrorTestCase{fmt.Errorf("error!"), nil, false, "1: error!"},
198
+ teeErrorTestCase{nil, fmt.Errorf("error!"), false, "2: error!"},
199
+ teeErrorTestCase{fmt.Errorf("error!"), fmt.Errorf("error!"), false, `1: error!
200
+2: error!`},
201
+ }
202
+
203
+ for i, tc := range tcs {
204
+ teeError := cmds.TeeError{tc.err1, tc.err2}
205
+ if teeError.BothNil() != tc.bothNil {
206
+ t.Fatalf("BothNil()/%d: expected %v but got %v", i, tc.bothNil, teeError.BothNil())
207
+ }
208
+
209
+ if teeError.Error() != tc.errString {
210
+ t.Fatalf("Error()/%d: expected %v but got %v", i, tc.errString, teeError.Error())
211
+ }
212
+ }
213
+}
214
+*/
commands/legacy/request.go
new
+194
@@ -0,0 +1,194 @@
1
+package legacy
2
+
3
+import (
4
+ "context"
5
+ "fmt"
6
+ "io"
7
+ "os"
8
+ "reflect"
9
+
10
+ "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
11
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
12
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit/files"
13
+
14
+ oldcmds "github.com/ipfs/go-ipfs/commands"
15
+)
16
+
17
+// requestWrapper implements a oldcmds.Request from an Request
18
+type requestWrapper struct {
19
+ req *cmds.Request
20
+ ctx *oldcmds.Context
21
+}
22
+
23
+// InvocContext retuns the invocation context of the oldcmds.Request.
24
+// It is faked using OldContext().
25
+func (r *requestWrapper) InvocContext() *oldcmds.Context {
26
+ return r.ctx
27
+}
28
+
29
+// SetInvocContext sets the invocation context. First the context is converted
30
+// to a Context using NewContext().
31
+func (r *requestWrapper) SetInvocContext(ctx oldcmds.Context) {
32
+ r.ctx = &ctx
33
+}
34
+
35
+// Command is an empty stub.
36
+func (r *requestWrapper) Command() *oldcmds.Command { return nil }
37
+
38
+func (r *requestWrapper) Arguments() []string {
39
+ return r.req.Arguments
40
+}
41
+
42
+func (r *requestWrapper) Context() context.Context {
43
+ return r.req.Context
44
+}
45
+
46
+func (r *requestWrapper) ConvertOptions() error {
47
+ return convertOptions(r.req)
48
+}
49
+
50
+func (r *requestWrapper) Files() files.File {
51
+ return r.req.Files
52
+}
53
+
54
+func (r *requestWrapper) Option(name string) *cmdkit.OptionValue {
55
+ var option cmdkit.Option
56
+
57
+ for _, def := range r.req.Command.Options {
58
+ for _, optName := range def.Names() {
59
+ if name == optName {
60
+ option = def
61
+ break
62
+ }
63
+ }
64
+ }
65
+ if option == nil {
66
+ return nil
67
+ }
68
+
69
+ // try all the possible names, break if we find a value
70
+ for _, n := range option.Names() {
71
+ val, found := r.req.Options[n]
72
+ if found {
73
+ return &cmdkit.OptionValue{val, found, option}
74
+ }
75
+ }
76
+
77
+ return &cmdkit.OptionValue{option.Default(), false, option}
78
+}
79
+
80
+func (r *requestWrapper) Options() cmdkit.OptMap {
81
+ return r.req.Options
82
+}
83
+
84
+func (r *requestWrapper) Path() []string {
85
+ return r.req.Path
86
+}
87
+
88
+func (r *requestWrapper) SetArguments(args []string) {
89
+ r.req.Arguments = args
90
+}
91
+
92
+func (r *requestWrapper) SetFiles(f files.File) {
93
+ r.req.Files = f
94
+}
95
+
96
+func (r *requestWrapper) SetOption(name string, v interface{}) {
97
+ r.req.SetOption(name, v)
98
+}
99
+
100
+func (r *requestWrapper) SetOptions(om cmdkit.OptMap) error {
101
+ r.req.Options = om
102
+ return convertOptions(r.req)
103
+}
104
+
105
+func (r *requestWrapper) SetRootContext(ctx context.Context) error {
106
+ r.req.Context = ctx
107
+ return nil
108
+}
109
+
110
+func (r *requestWrapper) Stdin() io.Reader {
111
+ return os.Stdin
112
+}
113
+
114
+func (r *requestWrapper) StringArguments() []string {
115
+ return r.req.Arguments
116
+}
117
+
118
+func (r *requestWrapper) Values() map[string]interface{} {
119
+ return nil
120
+}
121
+
122
+func (r *requestWrapper) VarArgs(f func(string) error) error {
123
+ if len(r.req.Arguments) >= len(r.req.Command.Arguments) {
124
+ for _, arg := range r.req.Arguments {
125
+ err := f(arg)
126
+ if err != nil {
127
+ return err
128
+ }
129
+ }
130
+ return nil
131
+ }
132
+
133
+ s, err := r.req.BodyArgs()
134
+ if err != nil {
135
+ return err
136
+ }
137
+
138
+ for s.Scan() {
139
+ err = f(s.Text())
140
+ if err != nil {
141
+ return err
142
+ }
143
+ }
144
+
145
+ return nil
146
+}
147
+
148
+// copied from go-ipfs-cmds/request.go
149
+func convertOptions(req *cmds.Request) error {
150
+ optDefSlice := req.Command.Options
151
+
152
+ optDefs := make(map[string]cmdkit.Option)
153
+ for _, def := range optDefSlice {
154
+ for _, name := range def.Names() {
155
+ optDefs[name] = def
156
+ }
157
+ }
158
+
159
+ for k, v := range req.Options {
160
+ opt, ok := optDefs[k]
161
+ if !ok {
162
+ continue
163
+ }
164
+
165
+ kind := reflect.TypeOf(v).Kind()
166
+ if kind != opt.Type() {
167
+ if str, ok := v.(string); ok {
168
+ val, err := opt.Parse(str)
169
+ if err != nil {
170
+ value := fmt.Sprintf("value %q", v)
171
+ if len(str) == 0 {
172
+ value = "empty value"
173
+ }
174
+ return fmt.Errorf("Could not convert %q to type %q (for option %q)",
175
+ value, opt.Type().String(), "-"+k)
176
+ }
177
+ req.Options[k] = val
178
+
179
+ } else {
180
+ return fmt.Errorf("Option %q should be type %q, but got type %q",
181
+ k, opt.Type().String(), kind.String())
182
+ }
183
+ }
184
+
185
+ for _, name := range opt.Names() {
186
+ if _, ok := req.Options[name]; name != k && ok {
187
+ return fmt.Errorf("Duplicate command options were provided (%q and %q)",
188
+ k, name)
189
+ }
190
+ }
191
+ }
192
+
193
+ return nil
194
+}
commands/legacy/response.go
new
+205
@@ -0,0 +1,205 @@
1
+package legacy
2
+
3
+import (
4
+ "context"
5
+ "io"
6
+ "os"
7
+ "reflect"
8
+ "sync"
9
+
10
+ "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
11
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
12
+
13
+ oldcmds "github.com/ipfs/go-ipfs/commands"
14
+)
15
+
16
+// responseWrapper wraps Response and implements olcdms.Response.
17
+// It embeds a Response so some methods are taken from that.
18
+type responseWrapper struct {
19
+ cmds.Response
20
+
21
+ out interface{}
22
+}
23
+
24
+// Request returns a (faked) oldcmds.Request
25
+func (rw *responseWrapper) Request() oldcmds.Request {
26
+ return &requestWrapper{rw.Response.Request(), nil}
27
+}
28
+
29
+// Output returns either a <-chan interface{} on which you can receive the
30
+// emitted values, or an emitted io.Reader
31
+func (rw *responseWrapper) Output() interface{} {
32
+ //if not called before
33
+ if rw.out == nil {
34
+ // get first emitted value
35
+ x, err := rw.Next()
36
+ if err != nil {
37
+ return nil
38
+ }
39
+ if e, ok := x.(*cmdkit.Error); ok {
40
+ ch := make(chan interface{})
41
+ log.Error(e)
42
+ close(ch)
43
+ return (<-chan interface{})(ch)
44
+ }
45
+
46
+ switch v := x.(type) {
47
+ case io.Reader:
48
+ // if it's a reader, set it
49
+ rw.out = v
50
+ default:
51
+ // if it is something else, create a channel and copy values from next in there
52
+ ch := make(chan interface{})
53
+ rw.out = (<-chan interface{})(ch)
54
+
55
+ go func() {
56
+ defer close(ch)
57
+ ch <- v
58
+
59
+ for {
60
+ v, err := rw.Next()
61
+
62
+ if err == io.EOF || err == context.Canceled {
63
+ return
64
+ }
65
+ if err != nil {
66
+ log.Error(err)
67
+ return
68
+ }
69
+
70
+ ch <- v
71
+ }
72
+ }()
73
+ }
74
+ }
75
+
76
+ // if we have it already, return existing value
77
+ return rw.out
78
+}
79
+
80
+// SetError is an empty stub
81
+func (rw *responseWrapper) SetError(error, cmdkit.ErrorType) {}
82
+
83
+// SetOutput is an empty stub
84
+func (rw *responseWrapper) SetOutput(interface{}) {}
85
+
86
+// SetLength is an empty stub
87
+func (rw *responseWrapper) SetLength(uint64) {}
88
+
89
+// SetCloser is an empty stub
90
+func (rw *responseWrapper) SetCloser(io.Closer) {}
91
+
92
+// Close is an empty stub
93
+func (rw *responseWrapper) Close() error { return nil }
94
+
95
+// Marshal is an empty stub
96
+func (rw *responseWrapper) Marshal() (io.Reader, error) { return nil, nil }
97
+
98
+// Reader is an empty stub
99
+func (rw *responseWrapper) Reader() (io.Reader, error) { return nil, nil }
100
+
101
+// Stdout returns os.Stdout
102
+func (rw *responseWrapper) Stdout() io.Writer { return os.Stdout }
103
+
104
+// Stderr returns os.Stderr
105
+func (rw *responseWrapper) Stderr() io.Writer { return os.Stderr }
106
+
107
+// fakeResponse implements oldcmds.Response and takes a ResponseEmitter
108
+type fakeResponse struct {
109
+ req oldcmds.Request
110
+ re cmds.ResponseEmitter
111
+ out interface{}
112
+ wait chan struct{}
113
+ once sync.Once
114
+}
115
+
116
+// Send emits the value(s) stored in r.out on the ResponseEmitter
117
+func (r *fakeResponse) Send(errCh chan<- error) {
118
+ defer close(errCh)
119
+
120
+ out := r.Output()
121
+ if out == nil {
122
+ return
123
+ }
124
+
125
+ if ch, ok := out.(chan interface{}); ok {
126
+ out = (<-chan interface{})(ch)
127
+ }
128
+
129
+ err := r.re.Emit(out)
130
+ errCh <- err
131
+ return
132
+}
133
+
134
+// Request returns the oldcmds.Request that belongs to this Response
135
+func (r *fakeResponse) Request() oldcmds.Request {
136
+ return r.req
137
+}
138
+
139
+// SetError forwards the call to the underlying ResponseEmitter
140
+func (r *fakeResponse) SetError(err error, code cmdkit.ErrorType) {
141
+ defer r.once.Do(func() { close(r.wait) })
142
+ r.re.SetError(err, code)
143
+}
144
+
145
+// Error is an empty stub
146
+func (r *fakeResponse) Error() *cmdkit.Error {
147
+ return nil
148
+}
149
+
150
+// SetOutput sets the output variable to the passed value
151
+func (r *fakeResponse) SetOutput(v interface{}) {
152
+ t := reflect.TypeOf(v)
153
+ _, isReader := v.(io.Reader)
154
+
155
+ if t != nil && t.Kind() != reflect.Chan && !isReader {
156
+ v = cmds.Single{v}
157
+ }
158
+
159
+ r.out = v
160
+ r.once.Do(func() { close(r.wait) })
161
+}
162
+
163
+// Output returns the output variable
164
+func (r *fakeResponse) Output() interface{} {
165
+ <-r.wait
166
+ return r.out
167
+}
168
+
169
+// SetLength forwards the call to the underlying ResponseEmitter
170
+func (r *fakeResponse) SetLength(l uint64) {
171
+ r.re.SetLength(l)
172
+}
173
+
174
+// Length is an empty stub
175
+func (r *fakeResponse) Length() uint64 {
176
+ return 0
177
+}
178
+
179
+// Close forwards the call to the underlying ResponseEmitter
180
+func (r *fakeResponse) Close() error {
181
+ return r.re.Close()
182
+}
183
+
184
+// SetCloser is an empty stub
185
+func (r *fakeResponse) SetCloser(io.Closer) {}
186
+
187
+// Reader is an empty stub
188
+func (r *fakeResponse) Reader() (io.Reader, error) {
189
+ return nil, nil
190
+}
191
+
192
+// Marshal is an empty stub
193
+func (r *fakeResponse) Marshal() (io.Reader, error) {
194
+ return nil, nil
195
+}
196
+
197
+// Stdout returns os.Stdout
198
+func (r *fakeResponse) Stdout() io.Writer {
199
+ return os.Stdout
200
+}
201
+
202
+// Stderr returns os.Stderr
203
+func (r *fakeResponse) Stderr() io.Writer {
204
+ return os.Stderr
205
+}
commands/legacy/responseemitter.go
new
+55
@@ -0,0 +1,55 @@
1
+package legacy
2
+
3
+import (
4
+ "fmt"
5
+ "io"
6
+
7
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
8
+
9
+ oldcmds "github.com/ipfs/go-ipfs/commands"
10
+)
11
+
12
+// wrappedResponseEmitter implements a ResponseEmitter by forwarding everything to an oldcmds.Response
13
+type wrappedResponseEmitter struct {
14
+ r oldcmds.Response
15
+}
16
+
17
+// SetLength forwards the call to the underlying oldcmds.Response
18
+func (re *wrappedResponseEmitter) SetLength(l uint64) {
19
+ re.r.SetLength(l)
20
+}
21
+
22
+// SetError forwards the call to the underlying oldcmds.Response
23
+func (re *wrappedResponseEmitter) SetError(err interface{}, code cmdkit.ErrorType) {
24
+ re.r.SetError(fmt.Errorf("%v", err), code)
25
+}
26
+
27
+// Close forwards the call to the underlying oldcmds.Response
28
+func (re *wrappedResponseEmitter) Close() error {
29
+ return re.r.Close()
30
+}
31
+
32
+// Emit sends the value to the underlying oldcmds.Response
33
+func (re *wrappedResponseEmitter) Emit(v interface{}) error {
34
+ if re.r.Output() == nil {
35
+ switch c := v.(type) {
36
+ case io.Reader:
37
+ re.r.SetOutput(c)
38
+ return nil
39
+ case chan interface{}:
40
+ re.r.SetOutput(c)
41
+ return nil
42
+ case <-chan interface{}:
43
+ re.r.SetOutput(c)
44
+ return nil
45
+ default:
46
+ re.r.SetOutput(make(chan interface{}))
47
+ }
48
+ }
49
+
50
+ go func() {
51
+ re.r.Output().(chan interface{}) <- v
52
+ }()
53
+
54
+ return nil
55
+}
commands/request.go
+13
-2
@@ -15,8 +15,8 @@ import (
15
"github.com/ipfs/go-ipfs/repo/config"
16
u "gx/ipfs/QmPsAfmDBnZN3kZGSuNwvCNDZiHneERSKmRcFyG3UkvcT3/go-ipfs-util"
17
18
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
19
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit/files"
18
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
19
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit/files"
20
)
21
22
type Context struct {
@@ -63,6 +63,17 @@ func (c *Context) NodeWithoutConstructing() *core.IpfsNode {
63
return c.node
64
}
65
66
+// RootContext returns the node's context.
67
+func (c *Context) RootContext() context.Context {
68
+ n, err := c.GetNode()
69
+ if err != nil {
70
+ log.Debug("error getting node: ", err)
71
+ return nil
72
+ }
73
+
74
+ return n.Context()
75
+}
76
+
77
// Request represents a call to a command from a consumer
78
type Request interface {
79
Path() []string
commands/response.go
+3
-2
@@ -9,7 +9,8 @@ import (
9
"os"
10
"strings"
11
12
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
12
+ cmds "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
13
+ cmdkit "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
14
)
15
16
// ErrorType signfies a category of errors
@@ -148,7 +149,7 @@ func (r *response) Marshal() (io.Reader, error) {
149
return bytes.NewReader([]byte{}), nil
150
}
151
151
- enc, found, err := r.req.Option(cmdkit.EncShort).String()
152
+ enc, found, err := r.req.Option(cmds.EncShort).String()
153
if err != nil {
154
return nil, err
155
}
commands/response_test.go
+3
-2
@@ -6,7 +6,8 @@ import (
6
"strings"
7
"testing"
8
9
- cmdkit "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
9
+ cmds "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
10
+ cmdkit "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
11
)
12
13
type TestOutput struct {
@@ -28,7 +29,7 @@ func TestMarshalling(t *testing.T) {
29
t.Error("Should have failed (no encoding type specified in request)")
30
}
31
31
- req.SetOption(cmdkit.EncShort, JSON)
32
+ req.SetOption(cmds.EncShort, JSON)
33
34
reader, err := res.Marshal()
35
if err != nil {
core/commands/active.go
+1
-1
@@ -11,7 +11,7 @@ import (
11
cmds "github.com/ipfs/go-ipfs/commands"
12
e "github.com/ipfs/go-ipfs/core/commands/e"
13
14
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
14
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
15
)
16
17
var ActiveReqsCmd = &cmds.Command{
core/commands/add.go
+45
-48
@@ -1,6 +1,7 @@
1
package commands
2
3
import (
4
+ "context"
5
"errors"
6
"fmt"
7
"io"
@@ -17,9 +18,10 @@ import (
18
mfs "github.com/ipfs/go-ipfs/mfs"
19
ft "github.com/ipfs/go-ipfs/unixfs"
20
20
- "gx/ipfs/QmP9vZfc5WSjfGTXmwX2EcicMFzmZ6fXn7HTdKYat6ccmH/go-ipfs-cmds"
21
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
21
"gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit/files"
22
+ "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
23
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
24
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit/files"
25
mh "gx/ipfs/QmYeKnKpubCMRiq3PGZcTREErthbb5Q9cXsCoSkD9bjEBd/go-multihash"
26
"gx/ipfs/QmeWjRodbcZFKe5tMN7poEx3izym6osrLSnTLf9UjJZBbs/pb"
27
)
@@ -103,7 +105,7 @@ You can now check what blocks have been created by:
105
cmdkit.FileArg("path", true, true, "The path to a file to be added to ipfs.").EnableRecursive().EnableStdin(),
106
},
107
Options: []cmdkit.Option{
106
- cmdkit.OptionRecursivePath, // a builtin option that allows recursive paths (-r, --recursive)
108
+ cmds.OptionRecursivePath, // a builtin option that allows recursive paths (-r, --recursive)
109
cmdkit.BoolOption(quietOptionName, "q", "Write minimal output."),
110
cmdkit.BoolOption(quieterOptionName, "Q", "Write only final hash."),
111
cmdkit.BoolOption(silentOptionName, "Write no output."),
@@ -120,24 +122,24 @@ You can now check what blocks have been created by:
122
cmdkit.IntOption(cidVersionOptionName, "Cid version. Non-zero value will change default of 'raw-leaves' to true. (experimental)").WithDefault(0),
123
cmdkit.StringOption(hashOptionName, "Hash function to use. Will set Cid version to 1 if used. (experimental)").WithDefault("sha2-256"),
124
},
123
- PreRun: func(req cmds.Request) error {
124
- quiet, _, _ := req.Option(quietOptionName).Bool()
125
- quieter, _, _ := req.Option(quieterOptionName).Bool()
125
+ PreRun: func(req *cmds.Request, env interface{}) error {
126
+ quiet, _ := req.Options[quietOptionName].(bool)
127
+ quieter, _ := req.Options[quieterOptionName].(bool)
128
quiet = quiet || quieter
129
128
- silent, _, _ := req.Option(silentOptionName).Bool()
130
+ silent, _ := req.Options[silentOptionName].(bool)
131
132
if quiet || silent {
133
return nil
134
}
135
136
// ipfs cli progress bar defaults to true unless quiet or silent is used
135
- _, found, _ := req.Option(progressOptionName).Bool()
137
+ _, found := req.Options[progressOptionName].(bool)
138
if !found {
137
- req.SetOption(progressOptionName, true)
139
+ req.Options[progressOptionName] = true
140
}
141
140
- sizeFile, ok := req.Files().(files.SizeFile)
142
+ sizeFile, ok := req.Files.(files.SizeFile)
143
if !ok {
144
// we don't need to error, the progress bar just won't know how big the files are
145
log.Warning("cannot determine size of input file")
@@ -145,7 +147,7 @@ You can now check what blocks have been created by:
147
}
148
149
sizeCh := make(chan int64, 1)
148
- req.Values()["size"] = sizeCh
150
+ req.Context = context.WithValue(req.Context, "size", sizeCh)
151
152
go func() {
153
size, err := sizeFile.Size()
@@ -160,8 +162,9 @@ You can now check what blocks have been created by:
162
163
return nil
164
},
163
- Run: func(req cmds.Request, res cmds.ResponseEmitter) {
164
- n, err := req.InvocContext().GetNode()
165
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env interface{}) {
166
+ fmt.Printf("%#v\n", req)
167
+ n, err := GetNode(env)
168
if err != nil {
169
res.SetError(err, cmdkit.ErrNormal)
170
return
@@ -180,19 +183,19 @@ You can now check what blocks have been created by:
183
// return
184
//}
185
183
- progress, _, _ := req.Option(progressOptionName).Bool()
184
- trickle, _, _ := req.Option(trickleOptionName).Bool()
185
- wrap, _, _ := req.Option(wrapOptionName).Bool()
186
- hash, _, _ := req.Option(onlyHashOptionName).Bool()
187
- hidden, _, _ := req.Option(hiddenOptionName).Bool()
188
- silent, _, _ := req.Option(silentOptionName).Bool()
189
- chunker, _, _ := req.Option(chunkerOptionName).String()
190
- dopin, _, _ := req.Option(pinOptionName).Bool()
191
- rawblks, rbset, _ := req.Option(rawLeavesOptionName).Bool()
192
- nocopy, _, _ := req.Option(noCopyOptionName).Bool()
193
- fscache, _, _ := req.Option(fstoreCacheOptionName).Bool()
194
- cidVer, _, _ := req.Option(cidVersionOptionName).Int()
195
- hashFunStr, hfset, _ := req.Option(hashOptionName).String()
186
+ progress, _ := req.Options[progressOptionName].(bool)
187
+ trickle, _ := req.Options[trickleOptionName].(bool)
188
+ wrap, _ := req.Options[wrapOptionName].(bool)
189
+ hash, _ := req.Options[onlyHashOptionName].(bool)
190
+ hidden, _ := req.Options[hiddenOptionName].(bool)
191
+ silent, _ := req.Options[silentOptionName].(bool)
192
+ chunker, _ := req.Options[chunkerOptionName].(string)
193
+ dopin, _ := req.Options[pinOptionName].(bool)
194
+ rawblks, rbset := req.Options[rawLeavesOptionName].(bool)
195
+ nocopy, _ := req.Options[noCopyOptionName].(bool)
196
+ fscache, _ := req.Options[fstoreCacheOptionName].(bool)
197
+ cidVer, _ := req.Options[cidVersionOptionName].(int)
198
+ hashFunStr, hfset := req.Options[hashOptionName].(string)
199
200
if nocopy && !cfg.Experimental.FilestoreEnabled {
201
res.SetError(errors.New("filestore is not enabled, see https://git.io/vy4XN"),
@@ -209,14 +212,10 @@ You can now check what blocks have been created by:
212
return
213
}
214
212
- if hfset && cidVer == 0 {
215
+ if hfset && hashFunStr != "sha2-256" && cidVer == 0 {
216
cidVer = 1
217
}
218
216
- if cidVer >= 1 && !rbset {
217
- rawblks = true
218
- }
219
-
219
prefix, err := dag.PrefixForCidVersion(cidVer)
220
if err != nil {
221
res.SetError(err, cmdkit.ErrNormal)
@@ -251,7 +250,7 @@ You can now check what blocks have been created by:
250
}
251
252
exch := n.Exchange
254
- local, _, _ := req.Option("local").Bool()
253
+ local, _ := req.Options["local"].(bool)
254
if local {
255
exch = offline.Exchange(addblockstore)
256
}
@@ -261,7 +260,7 @@ You can now check what blocks have been created by:
260
261
outChan := make(chan interface{}, adderOutChanSize)
262
264
- fileAdder, err := coreunix.NewAdder(req.Context(), n.Pinning, n.Blockstore, dserv)
263
+ fileAdder, err := coreunix.NewAdder(req.Context, n.Pinning, n.Blockstore, dserv)
264
if err != nil {
265
res.SetError(err, cmdkit.ErrNormal)
266
return
@@ -281,7 +280,7 @@ You can now check what blocks have been created by:
280
281
if hash {
282
md := dagtest.Mock()
284
- mr, err := mfs.NewRoot(req.Context(), md, ft.EmptyDirNode(), nil)
283
+ mr, err := mfs.NewRoot(req.Context, md, ft.EmptyDirNode(), nil)
284
if err != nil {
285
res.SetError(err, cmdkit.ErrNormal)
286
return
@@ -325,7 +324,7 @@ You can now check what blocks have been created by:
324
var err error
325
defer func() { errCh <- err }()
326
defer close(outChan)
328
- err = addAllAndPin(req.Files())
327
+ err = addAllAndPin(req.Files)
328
}()
329
330
defer res.Close()
@@ -340,21 +339,19 @@ You can now check what blocks have been created by:
339
res.SetError(err, cmdkit.ErrNormal)
340
}
341
},
343
- PostRun: map[cmds.EncodingType]func(cmds.Request, cmds.ResponseEmitter) cmds.ResponseEmitter{
344
- cmds.CLI: func(req cmds.Request, re cmds.ResponseEmitter) cmds.ResponseEmitter {
345
- ctx := req.Context()
346
-
342
+ PostRun: cmds.PostRunMap{
343
+ cmds.CLI: func(req *cmds.Request, re cmds.ResponseEmitter) cmds.ResponseEmitter {
344
reNext, res := cmds.NewChanResponsePair(req)
345
outChan := make(chan interface{})
346
347
progressBar := func(wait chan struct{}) {
348
defer close(wait)
349
353
- quiet, _, _ := req.Option(quietOptionName).Bool()
354
- quieter, _, _ := req.Option(quieterOptionName).Bool()
350
+ quiet, _ := req.Options[quietOptionName].(bool)
351
+ quieter, _ := req.Options[quieterOptionName].(bool)
352
quiet = quiet || quieter
353
357
- progress, _, _ := req.Option(progressOptionName).Bool()
354
+ progress, _ := req.Options[progressOptionName].(bool)
355
356
var bar *pb.ProgressBar
357
if progress {
@@ -367,10 +364,7 @@ You can now check what blocks have been created by:
364
}
365
366
var sizeChan chan int64
370
- s, found := req.Values()["size"]
371
- if found {
372
- sizeChan = s.(chan int64)
373
- }
367
+ sizeChan, _ = req.Context.Value("size").(chan int64)
368
369
lastFile := ""
370
lastHash := ""
@@ -431,6 +425,9 @@ You can now check what blocks have been created by:
425
bar.ShowBar = true
426
bar.ShowTimeLeft = true
427
}
428
+ case <-req.Context.Done():
429
+ re.SetError(req.Context.Err(), cmdkit.ErrNormal)
430
+ return
431
}
432
}
433
}
@@ -459,8 +456,8 @@ You can now check what blocks have been created by:
456
457
select {
458
case outChan <- v:
462
- case <-ctx.Done():
463
- re.SetError(ctx.Err(), cmdkit.ErrNormal)
459
+ case <-req.Context.Done():
460
+ re.SetError(req.Context.Err(), cmdkit.ErrNormal)
461
return
462
}
463
}
core/commands/bitswap.go
+11
-11
@@ -6,13 +6,15 @@ import (
6
"io"
7
8
oldcmds "github.com/ipfs/go-ipfs/commands"
9
+ lgc "github.com/ipfs/go-ipfs/commands/legacy"
10
e "github.com/ipfs/go-ipfs/core/commands/e"
11
bitswap "github.com/ipfs/go-ipfs/exchange/bitswap"
12
decision "github.com/ipfs/go-ipfs/exchange/bitswap/decision"
13
14
cmds "gx/ipfs/QmP9vZfc5WSjfGTXmwX2EcicMFzmZ6fXn7HTdKYat6ccmH/go-ipfs-cmds"
15
"gx/ipfs/QmPSBJL4momYnE7DcUyk2DVhD6rH488ZmHBGLbxNdhU44K/go-humanize"
15
- cmdkit "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
16
+ cmds "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
17
+ cmdkit "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
18
peer "gx/ipfs/QmWNY7dV54ZDYmTA1ykVdwNCqC11mpU4zSUp6XDpLTH9eG/go-libp2p-peer"
19
cid "gx/ipfs/QmeSrf6pzut73u6zLQkRFQ3ygt3k6XFT2kjdYP8Tnkwwyg/go-cid"
20
)
@@ -24,13 +26,11 @@ var BitswapCmd = &cmds.Command{
26
},
27
28
Subcommands: map[string]*cmds.Command{
27
- "stat": bitswapStatCmd,
28
- },
29
- OldSubcommands: map[string]*oldcmds.Command{
30
- "wantlist": showWantlistCmd,
31
- "unwant": unwantCmd,
32
- "ledger": ledgerCmd,
33
- "reprovide": reprovideCmd,
29
+ "stat": bitswapStatCmd,
30
+ "wantlist": lgc.NewCommand(showWantlistCmd),
31
+ "unwant": lgc.NewCommand(unwantCmd),
32
+ "ledger": lgc.NewCommand(ledgerCmd),
33
+ "reprovide": lgc.NewCommand(reprovideCmd),
34
},
35
}
36
@@ -140,8 +140,8 @@ var bitswapStatCmd = &cmds.Command{
140
ShortDescription: ``,
141
},
142
Type: bitswap.Stat{},
143
- Run: func(req cmds.Request, res cmds.ResponseEmitter) {
144
- nd, err := req.InvocContext().GetNode()
143
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env interface{}) {
144
+ nd, err := GetNode(env)
145
if err != nil {
146
res.SetError(err, cmdkit.ErrNormal)
147
return
@@ -167,7 +167,7 @@ var bitswapStatCmd = &cmds.Command{
167
cmds.EmitOnce(res, st)
168
},
169
Encoders: cmds.EncoderMap{
170
- cmds.Text: cmds.MakeEncoder(func(req cmds.Request, w io.Writer, v interface{}) error {
170
+ cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
171
out, ok := v.(*bitswap.Stat)
172
if !ok {
173
return e.TypeErr(out, v)
core/commands/block.go
+27
-26
@@ -2,6 +2,7 @@ package commands
2
3
import (
4
"bytes"
5
+ "context"
6
"fmt"
7
"io"
8
"io/ioutil"
@@ -9,9 +10,9 @@ import (
10
11
util "github.com/ipfs/go-ipfs/blocks/blockstore/util"
12
e "github.com/ipfs/go-ipfs/core/commands/e"
12
- "gx/ipfs/QmP9vZfc5WSjfGTXmwX2EcicMFzmZ6fXn7HTdKYat6ccmH/go-ipfs-cmds"
13
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
13
14
+ "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
15
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
16
mh "gx/ipfs/QmYeKnKpubCMRiq3PGZcTREErthbb5Q9cXsCoSkD9bjEBd/go-multihash"
17
blocks "gx/ipfs/QmYsEQydGrsxNZfAiskvQ76N2xE9hDQtSAkRSynwMiUK3c/go-block-format"
18
cid "gx/ipfs/QmeSrf6pzut73u6zLQkRFQ3ygt3k6XFT2kjdYP8Tnkwwyg/go-cid"
@@ -60,8 +61,8 @@ on raw IPFS blocks. It outputs the following to stdout:
61
Arguments: []cmdkit.Argument{
62
cmdkit.StringArg("key", true, false, "The base58 multihash of an existing block to stat.").EnableStdin(),
63
},
63
- Run: func(req cmds.Request, res cmds.ResponseEmitter) {
64
- b, err := getBlockForKey(req, req.Arguments()[0])
64
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env interface{}) {
65
+ b, err := getBlockForKey(req.Context, env, req.Arguments[0])
66
if err != nil {
67
res.SetError(err, cmdkit.ErrNormal)
68
return
@@ -77,7 +78,7 @@ on raw IPFS blocks. It outputs the following to stdout:
78
},
79
Type: BlockStat{},
80
Encoders: cmds.EncoderMap{
80
- cmds.Text: cmds.MakeEncoder(func(req cmds.Request, w io.Writer, v interface{}) error {
81
+ cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
82
bs, ok := v.(*BlockStat)
83
if !ok {
84
return e.TypeErr(bs, v)
@@ -100,8 +101,8 @@ It outputs to stdout, and <key> is a base58 encoded multihash.
101
Arguments: []cmdkit.Argument{
102
cmdkit.StringArg("key", true, false, "The base58 multihash of an existing block to get.").EnableStdin(),
103
},
103
- Run: func(req cmds.Request, res cmds.ResponseEmitter) {
104
- b, err := getBlockForKey(req, req.Arguments()[0])
104
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env interface{}) {
105
+ b, err := getBlockForKey(req.Context, env, req.Arguments[0])
106
if err != nil {
107
res.SetError(err, cmdkit.ErrNormal)
108
return
@@ -131,14 +132,14 @@ It reads from stdin, and <key> is a base58 encoded multihash.
132
cmdkit.StringOption("mhtype", "multihash hash function").WithDefault("sha2-256"),
133
cmdkit.IntOption("mhlen", "multihash hash length").WithDefault(-1),
134
},
134
- Run: func(req cmds.Request, res cmds.ResponseEmitter) {
135
- n, err := req.InvocContext().GetNode()
135
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env interface{}) {
136
+ n, err := GetNode(env)
137
if err != nil {
138
res.SetError(err, cmdkit.ErrNormal)
139
return
140
}
141
141
- file, err := req.Files().NextFile()
142
+ file, err := req.Files.NextFile()
143
if err != nil {
144
res.SetError(err, cmdkit.ErrNormal)
145
return
@@ -159,7 +160,7 @@ It reads from stdin, and <key> is a base58 encoded multihash.
160
var pref cid.Prefix
161
pref.Version = 1
162
162
- format, _, _ := req.Option("format").String()
163
+ format, _ := req.Options["format"].(string)
164
formatval, ok := cid.Codecs[format]
165
if !ok {
166
res.SetError(fmt.Errorf("unrecognized format: %s", format), cmdkit.ErrNormal)
@@ -170,7 +171,7 @@ It reads from stdin, and <key> is a base58 encoded multihash.
171
}
172
pref.Codec = formatval
173
173
- mhtype, _, _ := req.Option("mhtype").String()
174
+ mhtype, _ := req.Options["mhtype"].(string)
175
mhtval, ok := mh.Names[mhtype]
176
if !ok {
177
err := fmt.Errorf("unrecognized multihash function: %s", mhtype)
@@ -179,9 +180,9 @@ It reads from stdin, and <key> is a base58 encoded multihash.
180
}
181
pref.MhType = mhtval
182
182
- mhlen, _, err := req.Option("mhlen").Int()
183
- if err != nil {
184
- res.SetError(err, cmdkit.ErrNormal)
183
+ mhlen, ok := req.Options["mhlen"].(int)
184
+ if !ok {
185
+ res.SetError("missing option \"mhlen\"", cmdkit.ErrNormal)
186
return
187
}
188
pref.MhLength = mhlen
@@ -213,7 +214,7 @@ It reads from stdin, and <key> is a base58 encoded multihash.
214
}
215
},
216
Encoders: cmds.EncoderMap{
216
- cmds.Text: cmds.MakeEncoder(func(req cmds.Request, w io.Writer, v interface{}) error {
217
+ cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
218
bs, ok := v.(*BlockStat)
219
if !ok {
220
return e.TypeErr(bs, v)
@@ -225,12 +226,12 @@ It reads from stdin, and <key> is a base58 encoded multihash.
226
Type: BlockStat{},
227
}
228
228
-func getBlockForKey(req cmds.Request, skey string) (blocks.Block, error) {
229
+func getBlockForKey(ctx context.Context, env interface{}, skey string) (blocks.Block, error) {
230
if len(skey) == 0 {
231
return nil, fmt.Errorf("zero length cid invalid")
232
}
233
233
- n, err := req.InvocContext().GetNode()
234
+ n, err := GetNode(env)
235
if err != nil {
236
return nil, err
237
}
@@ -240,7 +241,7 @@ func getBlockForKey(req cmds.Request, skey string) (blocks.Block, error) {
241
return nil, err
242
}
243
243
- b, err := n.Blocks.GetBlock(req.Context(), c)
244
+ b, err := n.Blocks.GetBlock(ctx, c)
245
if err != nil {
246
return nil, err
247
}
@@ -263,15 +264,15 @@ It takes a list of base58 encoded multihashs to remove.
264
cmdkit.BoolOption("force", "f", "Ignore nonexistent blocks."),
265
cmdkit.BoolOption("quiet", "q", "Write minimal output."),
266
},
266
- Run: func(req cmds.Request, res cmds.ResponseEmitter) {
267
- n, err := req.InvocContext().GetNode()
267
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env interface{}) {
268
+ n, err := GetNode(env)
269
if err != nil {
270
res.SetError(err, cmdkit.ErrNormal)
271
return
272
}
272
- hashes := req.Arguments()
273
- force, _, _ := req.Option("force").Bool()
274
- quiet, _, _ := req.Option("quiet").Bool()
273
+ hashes := req.Arguments
274
+ force, _ := req.Options["force"].(bool)
275
+ quiet, _ := req.Options["quiet"].(bool)
276
cids := make([]*cid.Cid, 0, len(hashes))
277
for _, hash := range hashes {
278
c, err := cid.Decode(hash)
@@ -298,8 +299,8 @@ It takes a list of base58 encoded multihashs to remove.
299
log.Error(err)
300
}
301
},
301
- PostRun: map[cmds.EncodingType]func(cmds.Request, cmds.ResponseEmitter) cmds.ResponseEmitter{
302
- cmds.CLI: func(req cmds.Request, re cmds.ResponseEmitter) cmds.ResponseEmitter {
302
+ PostRun: map[cmds.EncodingType]func(*cmds.Request, cmds.ResponseEmitter) cmds.ResponseEmitter{
303
+ cmds.CLI: func(req *cmds.Request, re cmds.ResponseEmitter) cmds.ResponseEmitter {
304
reNext, res := cmds.NewChanResponsePair(req)
305
306
go func() {
core/commands/bootstrap.go
+1
-1
@@ -12,7 +12,7 @@ import (
12
config "github.com/ipfs/go-ipfs/repo/config"
13
"github.com/ipfs/go-ipfs/repo/fsrepo"
14
15
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
15
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
16
)
17
18
type BootstrapOutput struct {
core/commands/cat.go
+15
-12
@@ -9,8 +9,8 @@ import (
9
core "github.com/ipfs/go-ipfs/core"
10
coreunix "github.com/ipfs/go-ipfs/core/coreunix"
11
12
- cmds "gx/ipfs/QmP9vZfc5WSjfGTXmwX2EcicMFzmZ6fXn7HTdKYat6ccmH/go-ipfs-cmds"
13
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
12
+ cmds "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
13
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
14
)
15
16
const progressBarMinSize = 1024 * 1024 * 8 // show progress bar for outputs > 8MiB
@@ -28,8 +28,8 @@ var CatCmd = &cmds.Command{
28
cmdkit.IntOption("offset", "o", "Byte offset to begin reading from."),
29
cmdkit.IntOption("length", "l", "Maximum number of bytes to read."),
30
},
31
- Run: func(req cmds.Request, res cmds.ResponseEmitter) {
32
- node, err := req.InvocContext().GetNode()
31
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env interface{}) {
32
+ node, err := GetNode(env)
33
if err != nil {
34
res.SetError(err, cmdkit.ErrNormal)
35
return
@@ -41,11 +41,8 @@ var CatCmd = &cmds.Command{
41
return
42
}
43
}
44
- offset, _, err := req.Option("offset").Int()
45
- if err != nil {
46
- res.SetError(err, cmdkit.ErrNormal)
47
- return
48
- }
44
+
45
+ offset, _ := req.Options["offset"].(int)
46
if offset < 0 {
47
res.SetError(fmt.Errorf("Cannot specify negative offset."), cmdkit.ErrNormal)
48
return
@@ -64,6 +61,12 @@ var CatCmd = &cmds.Command{
61
max = -1
62
}
63
64
+ err = req.ParseBodyArgs()
65
+ if err != nil && err.Error() != "all arguments covered by positional arguments" {
66
+ res.SetError(err, cmdkit.ErrNormal)
67
+ return
68
+ }
69
+
70
readers, length, err := cat(req.Context(), node, req.Arguments(), int64(offset), int64(max))
71
if err != nil {
72
res.SetError(err, cmdkit.ErrNormal)
@@ -71,7 +74,7 @@ var CatCmd = &cmds.Command{
74
}
75
76
/*
74
- if err := corerepo.ConditionalGC(req.Context(), node, length); err != nil {
77
+ if err := corerepo.ConditionalGC(req.Context, node, length); err != nil {
78
re.SetError(err, cmdkit.ErrNormal)
79
return
80
}
@@ -89,8 +92,8 @@ var CatCmd = &cmds.Command{
92
res.SetError(err, cmdkit.ErrNormal)
93
}
94
},
92
- PostRun: map[cmds.EncodingType]func(cmds.Request, cmds.ResponseEmitter) cmds.ResponseEmitter{
93
- cmds.CLI: func(req cmds.Request, re cmds.ResponseEmitter) cmds.ResponseEmitter {
95
+ PostRun: map[cmds.EncodingType]func(*cmds.Request, cmds.ResponseEmitter) cmds.ResponseEmitter{
96
+ cmds.CLI: func(req *cmds.Request, re cmds.ResponseEmitter) cmds.ResponseEmitter {
97
reNext, res := cmds.NewChanResponsePair(req)
98
99
go func() {
core/commands/commands.go
+8
-47
@@ -11,11 +11,11 @@ import (
11
"sort"
12
"strings"
13
14
- oldcmds "github.com/ipfs/go-ipfs/commands"
14
+ // oldcmds "github.com/ipfs/go-ipfs/commands"
15
e "github.com/ipfs/go-ipfs/core/commands/e"
16
17
- cmds "gx/ipfs/QmP9vZfc5WSjfGTXmwX2EcicMFzmZ6fXn7HTdKYat6ccmH/go-ipfs-cmds"
18
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
17
+ cmds "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
18
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
19
)
20
21
type commandEncoder struct {
@@ -69,16 +69,16 @@ func CommandsCmd(root *cmds.Command) *cmds.Command {
69
Options: []cmdkit.Option{
70
cmdkit.BoolOption(flagsOptionName, "f", "Show command flags"),
71
},
72
- Run: func(req cmds.Request, res cmds.ResponseEmitter) {
72
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env interface{}) {
73
rootCmd := cmd2outputCmd("ipfs", root)
74
- rootCmd.showOpts, _, _ = req.Option(flagsOptionName).Bool()
74
+ rootCmd.showOpts, _ = req.Options[flagsOptionName].(bool)
75
err := res.Emit(&rootCmd)
76
if err != nil {
77
log.Error(err)
78
}
79
},
80
Encoders: cmds.EncoderMap{
81
- cmds.Text: func(req cmds.Request) func(io.Writer) cmds.Encoder {
81
+ cmds.Text: func(req *cmds.Request) func(io.Writer) cmds.Encoder {
82
return func(w io.Writer) cmds.Encoder { return &commandEncoder{w} }
83
},
84
},
@@ -94,51 +94,12 @@ func cmd2outputCmd(name string, cmd *cmds.Command) Command {
94
95
output := Command{
96
Name: name,
97
- Subcommands: make([]Command, len(cmd.Subcommands)+len(cmd.OldSubcommands)),
97
+ Subcommands: make([]Command, 0, len(cmd.Subcommands)),
98
Options: opts,
99
}
100
101
- // we need to keep track of names because a name *might* be used by both a Subcommand and an OldSubscommand.
102
- names := make(map[string]struct{})
103
-
104
- i := 0
105
- for name, sub := range cmd.Subcommands {
106
- names[name] = struct{}{}
107
- output.Subcommands[i] = cmd2outputCmd(name, sub)
108
- i++
109
- }
110
-
111
- for name, sub := range cmd.OldSubcommands {
112
- if _, ok := names[name]; ok {
113
- continue
114
- }
115
-
116
- names[name] = struct{}{}
117
- output.Subcommands[i] = oldCmd2outputCmd(name, sub)
118
- i++
119
- }
120
-
121
- // trucate to the amount of names we actually have
122
- output.Subcommands = output.Subcommands[:len(names)]
123
- return output
124
-}
125
-
126
-func oldCmd2outputCmd(name string, cmd *oldcmds.Command) Command {
127
- opts := make([]Option, len(cmd.Options))
128
- for i, opt := range cmd.Options {
129
- opts[i] = Option{opt.Names()}
130
- }
131
-
132
- output := Command{
133
- Name: name,
134
- Subcommands: make([]Command, len(cmd.Subcommands)),
135
- Options: opts,
136
- }
137
-
138
- i := 0
101
for name, sub := range cmd.Subcommands {
140
- output.Subcommands[i] = oldCmd2outputCmd(name, sub)
141
- i++
102
+ output.Subcommands = append(output.Subcommands, cmd2outputCmd(name, sub))
103
}
104
105
return output
core/commands/config.go
+1
-1
@@ -17,7 +17,7 @@ import (
17
config "github.com/ipfs/go-ipfs/repo/config"
18
fsrepo "github.com/ipfs/go-ipfs/repo/fsrepo"
19
20
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
20
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
21
)
22
23
type ConfigField struct {
core/commands/dag/dag.go
+2
-2
@@ -13,8 +13,8 @@ import (
13
path "github.com/ipfs/go-ipfs/path"
14
pin "github.com/ipfs/go-ipfs/pin"
15
16
- cmdkit "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
17
- files "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit/files"
16
+ cmdkit "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
17
+ files "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit/files"
18
mh "gx/ipfs/QmYeKnKpubCMRiq3PGZcTREErthbb5Q9cXsCoSkD9bjEBd/go-multihash"
19
cid "gx/ipfs/QmeSrf6pzut73u6zLQkRFQ3ygt3k6XFT2kjdYP8Tnkwwyg/go-cid"
20
)
core/commands/dht.go
+1
-1
@@ -15,8 +15,8 @@ import (
15
16
routing "gx/ipfs/QmPCGUjMRuBcPybZFpjhzpifwPP9wPRoiy5geTQKU4vqWA/go-libp2p-routing"
17
notif "gx/ipfs/QmPCGUjMRuBcPybZFpjhzpifwPP9wPRoiy5geTQKU4vqWA/go-libp2p-routing/notifications"
18
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
18
b58 "gx/ipfs/QmT8rehPR3F6bmwL6zjUN8XpiDBFFpMP2myPdC6ApsWfJf/go-base58"
19
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
20
peer "gx/ipfs/QmWNY7dV54ZDYmTA1ykVdwNCqC11mpU4zSUp6XDpLTH9eG/go-libp2p-peer"
21
pstore "gx/ipfs/QmYijbtjCxFEjSXaudaQAUz3LN5VKLssm8WCUsRoqzXmQR/go-libp2p-peerstore"
22
cid "gx/ipfs/QmeSrf6pzut73u6zLQkRFQ3ygt3k6XFT2kjdYP8Tnkwwyg/go-cid"
core/commands/diag.go
+1
-1
@@ -3,7 +3,7 @@ package commands
3
import (
4
cmds "github.com/ipfs/go-ipfs/commands"
5
6
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
6
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
7
)
8
9
var DiagCmd = &cmds.Command{
core/commands/dns.go
+1
-1
@@ -8,7 +8,7 @@ import (
8
e "github.com/ipfs/go-ipfs/core/commands/e"
9
namesys "github.com/ipfs/go-ipfs/namesys"
10
11
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
11
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
12
)
13
14
var DNSCmd = &cmds.Command{
core/commands/env.go
new
+27
@@ -0,0 +1,27 @@
1
+package commands
2
+
3
+import (
4
+ "fmt"
5
+
6
+ "github.com/ipfs/go-ipfs/commands"
7
+ "github.com/ipfs/go-ipfs/core"
8
+ "github.com/ipfs/go-ipfs/repo/config"
9
+)
10
+
11
+func GetNode(env interface{}) (*core.IpfsNode, error) {
12
+ ctx, ok := env.(*commands.Context)
13
+ if !ok {
14
+ return nil, fmt.Errorf("expected env to be of type %T, got %T", ctx, env)
15
+ }
16
+
17
+ return ctx.GetNode()
18
+}
19
+
20
+func GetConfig(env interface{}) (*config.Config, error) {
21
+ ctx, ok := env.(*commands.Context)
22
+ if !ok {
23
+ return nil, fmt.Errorf("expected env to be of type %T, got %T", ctx, env)
24
+ }
25
+
26
+ return ctx.GetConfig()
27
+}
core/commands/external.go
+1
-1
@@ -10,7 +10,7 @@ import (
10
11
cmds "github.com/ipfs/go-ipfs/commands"
12
13
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
13
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
14
)
15
16
func ExternalBinary() *cmds.Command {
core/commands/files/files.go
+1
-1
@@ -18,10 +18,10 @@ import (
18
path "github.com/ipfs/go-ipfs/path"
19
ft "github.com/ipfs/go-ipfs/unixfs"
20
uio "github.com/ipfs/go-ipfs/unixfs/io"
21
- cmdkit "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
21
22
node "gx/ipfs/QmNwUEK7QbwSqyKBu3mMtToo8SUc6wQJ7gdZq4gGGJqfnf/go-ipld-format"
23
logging "gx/ipfs/QmSpJByNKFX1sCsHBEp3R73FL4NF6FnQTEGyNAXHm2GS52/go-log"
24
+ cmdkit "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
25
mh "gx/ipfs/QmYeKnKpubCMRiq3PGZcTREErthbb5Q9cXsCoSkD9bjEBd/go-multihash"
26
cid "gx/ipfs/QmeSrf6pzut73u6zLQkRFQ3ygt3k6XFT2kjdYP8Tnkwwyg/go-cid"
27
)
core/commands/filestore.go
+15
-20
@@ -11,8 +11,9 @@ import (
11
e "github.com/ipfs/go-ipfs/core/commands/e"
12
"github.com/ipfs/go-ipfs/filestore"
13
14
- cmds "gx/ipfs/QmP9vZfc5WSjfGTXmwX2EcicMFzmZ6fXn7HTdKYat6ccmH/go-ipfs-cmds"
15
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
14
+ lgc "github.com/ipfs/go-ipfs/commands/legacy"
15
+ cmds "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
16
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
17
cid "gx/ipfs/QmeSrf6pzut73u6zLQkRFQ3ygt3k6XFT2kjdYP8Tnkwwyg/go-cid"
18
)
19
@@ -21,11 +22,9 @@ var FileStoreCmd = &cmds.Command{
22
Tagline: "Interact with filestore objects.",
23
},
24
Subcommands: map[string]*cmds.Command{
24
- "ls": lsFileStore,
25
- },
26
- OldSubcommands: map[string]*oldCmds.Command{
27
- "verify": verifyFileStore,
28
- "dups": dupsFileStore,
25
+ "ls": lsFileStore,
26
+ "verify": lgc.NewCommand(verifyFileStore),
27
+ "dups": lgc.NewCommand(dupsFileStore),
28
},
29
}
30
@@ -54,15 +53,15 @@ The output is:
53
Options: []cmdkit.Option{
54
cmdkit.BoolOption("file-order", "sort the results based on the path of the backing file"),
55
},
57
- Run: func(req cmds.Request, res cmds.ResponseEmitter) {
58
- _, fs, err := getFilestore(req.InvocContext())
56
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env interface{}) {
57
+ _, fs, err := getFilestore(env.(*oldCmds.Context))
58
if err != nil {
59
res.SetError(err, cmdkit.ErrNormal)
60
return
61
}
63
- args := req.Arguments()
62
+ args := req.Arguments
63
if len(args) > 0 {
65
- out := perKeyActionToChan(req.Context(), args, func(c *cid.Cid) *filestore.ListRes {
64
+ out := perKeyActionToChan(req.Context, args, func(c *cid.Cid) *filestore.ListRes {
65
return filestore.List(fs, c)
66
})
67
@@ -71,14 +70,14 @@ The output is:
70
log.Error(err)
71
}
72
} else {
74
- fileOrder, _, _ := req.Option("file-order").Bool()
73
+ fileOrder, _ := req.Options["file-order"].(bool)
74
next, err := filestore.ListAll(fs, fileOrder)
75
if err != nil {
76
res.SetError(err, cmdkit.ErrNormal)
77
return
78
}
79
81
- out := listResToChan(req.Context(), next)
80
+ out := listResToChan(req.Context, next)
81
err = res.Emit(out)
82
if err != nil {
83
log.Error(err)
@@ -86,7 +85,7 @@ The output is:
85
}
86
},
87
PostRun: cmds.PostRunMap{
89
- cmds.CLI: func(req cmds.Request, re cmds.ResponseEmitter) cmds.ResponseEmitter {
88
+ cmds.CLI: func(req *cmds.Request, re cmds.ResponseEmitter) cmds.ResponseEmitter {
89
reNext, res := cmds.NewChanResponsePair(req)
90
91
go func() {
@@ -236,12 +235,8 @@ var dupsFileStore = &oldCmds.Command{
235
Type: RefWrapper{},
236
}
237
239
-type getNoder interface {
240
- GetNode() (*core.IpfsNode, error)
241
-}
242
-
243
-func getFilestore(g getNoder) (*core.IpfsNode, *filestore.Filestore, error) {
244
- n, err := g.GetNode()
238
+func getFilestore(env interface{}) (*core.IpfsNode, *filestore.Filestore, error) {
239
+ n, err := GetNode(env)
240
if err != nil {
241
return nil, nil, err
242
}
core/commands/get.go
+23
-19
@@ -16,8 +16,8 @@ import (
16
tar "github.com/ipfs/go-ipfs/thirdparty/tar"
17
uarchive "github.com/ipfs/go-ipfs/unixfs/archive"
18
19
- "gx/ipfs/QmP9vZfc5WSjfGTXmwX2EcicMFzmZ6fXn7HTdKYat6ccmH/go-ipfs-cmds"
20
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
19
+ "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
20
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
21
"gx/ipfs/QmeWjRodbcZFKe5tMN7poEx3izym6osrLSnTLf9UjJZBbs/pb"
22
)
23
@@ -48,12 +48,12 @@ may also specify the level of compression by specifying '-l=<1-9>'.
48
cmdkit.BoolOption("compress", "C", "Compress the output with GZIP compression."),
49
cmdkit.IntOption("compression-level", "l", "The level of compression (1-9).").WithDefault(-1),
50
},
51
- PreRun: func(req cmds.Request) error {
51
+ PreRun: func(req *cmds.Request, env interface{}) error {
52
_, err := getCompressOptions(req)
53
return err
54
},
55
- Run: func(req cmds.Request, res cmds.ResponseEmitter) {
56
- if len(req.Arguments()) == 0 {
55
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env interface{}) {
56
+ if len(req.Arguments) == 0 {
57
res.SetError(errors.New("not enough arugments provided"), cmdkit.ErrClient)
58
return
59
}
@@ -63,13 +63,13 @@ may also specify the level of compression by specifying '-l=<1-9>'.
63
return
64
}
65
66
- node, err := req.InvocContext().GetNode()
66
+ node, err := GetNode(env)
67
if err != nil {
68
res.SetError(err, cmdkit.ErrNormal)
69
return
70
}
71
- p := path.Path(req.Arguments()[0])
72
- ctx := req.Context()
71
+ p := path.Path(req.Arguments[0])
72
+ ctx := req.Context
73
dn, err := core.Resolve(ctx, node.Namesys, node.Resolver, p)
74
if err != nil {
75
res.SetError(err, cmdkit.ErrNormal)
@@ -92,7 +92,7 @@ may also specify the level of compression by specifying '-l=<1-9>'.
92
return
93
}
94
95
- archive, _, _ := req.Option("archive").Bool()
95
+ archive, _ := req.Options["archive"].(bool)
96
reader, err := uarchive.DagArchive(ctx, dn, p.String(), node.DAG, archive, cmplvl)
97
if err != nil {
98
res.SetError(err, cmdkit.ErrNormal)
@@ -101,8 +101,8 @@ may also specify the level of compression by specifying '-l=<1-9>'.
101
102
res.Emit(reader)
103
},
104
- PostRun: map[cmds.EncodingType]func(cmds.Request, cmds.ResponseEmitter) cmds.ResponseEmitter{
105
- cmds.CLI: func(req cmds.Request, re cmds.ResponseEmitter) cmds.ResponseEmitter {
104
+ PostRun: map[cmds.EncodingType]func(*cmds.Request, cmds.ResponseEmitter) cmds.ResponseEmitter{
105
+ cmds.CLI: func(req *cmds.Request, re cmds.ResponseEmitter) cmds.ResponseEmitter {
106
reNext, res := cmds.NewChanResponsePair(req)
107
108
go func() {
@@ -119,7 +119,11 @@ may also specify the level of compression by specifying '-l=<1-9>'.
119
return
120
}
121
122
- outPath := getOutPath(req)
122
+ outPath, _ := req.Options["output"].(string)
123
+ if len(outPath) == 0 {
124
+ _, outPath = gopath.Split(req.Arguments[0])
125
+ outPath = gopath.Clean(outPath)
126
+ }
127
128
cmplvl, err := getCompressOptions(req)
129
if err != nil {
@@ -127,7 +131,7 @@ may also specify the level of compression by specifying '-l=<1-9>'.
131
return
132
}
133
130
- archive, _, _ := req.Option("archive").Bool()
134
+ archive, _ := req.Options["archive"].(bool)
135
136
gw := getWriter{
137
Out: os.Stdout,
@@ -183,10 +187,10 @@ func makeProgressBar(out io.Writer, l int64) *pb.ProgressBar {
187
return bar
188
}
189
186
-func getOutPath(req cmds.Request) string {
187
- outPath, _, _ := req.Option("output").String()
190
+func getOutPath(req *cmds.Request) string {
191
+ outPath, _ := req.Options["output"].(string)
192
if outPath == "" {
189
- trimmed := strings.TrimRight(req.Arguments()[0], "/")
193
+ trimmed := strings.TrimRight(req.Arguments[0], "/")
194
_, outPath = gopath.Split(trimmed)
195
outPath = gopath.Clean(outPath)
196
}
@@ -251,9 +255,9 @@ func (gw *getWriter) writeExtracted(r io.Reader, fpath string) error {
255
return extractor.Extract(r)
256
}
257
254
-func getCompressOptions(req cmds.Request) (int, error) {
255
- cmprs, _, _ := req.Option("compress").Bool()
256
- cmplvl, cmplvlFound, _ := req.Option("compression-level").Int()
258
+func getCompressOptions(req *cmds.Request) (int, error) {
259
+ cmprs, _ := req.Options["compress"].(bool)
260
+ cmplvl, cmplvlFound := req.Options["compression-level"].(int)
261
switch {
262
case !cmprs:
263
return gzip.NoCompression, nil
core/commands/get_test.go
+10
-7
@@ -1,10 +1,11 @@
1
package commands
2
3
import (
4
+ "context"
5
"testing"
6
6
- "gx/ipfs/QmP9vZfc5WSjfGTXmwX2EcicMFzmZ6fXn7HTdKYat6ccmH/go-ipfs-cmds"
7
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
7
+ cmds "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
8
+ cmdkit "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
9
)
10
11
func TestGetOutputPath(t *testing.T) {
@@ -44,13 +45,15 @@ func TestGetOutputPath(t *testing.T) {
45
},
46
}
47
47
- defOpts, err := GetCmd.GetOptions([]string{})
48
- if err != nil {
49
- t.Fatalf("error getting default command options: %v", err)
50
- }
48
+ /*
49
+ defOpts, err := GetCmd.GetOptions([]string{})
50
+ if err != nil {
51
+ t.Fatalf("error getting default command options: %v", err)
52
+ }
53
+ */
54
55
for _, tc := range cases {
53
- req, err := cmds.NewRequest([]string{}, tc.opts, tc.args, nil, GetCmd, defOpts)
56
+ req, err := cmds.NewRequest(context.TODO(), []string{}, tc.opts, tc.args, nil, GetCmd)
57
if err != nil {
58
t.Fatalf("error creating a command request: %v", err)
59
}
core/commands/helptext_test.go
+1
-1
@@ -4,7 +4,7 @@ import (
4
"strings"
5
"testing"
6
7
- cmds "gx/ipfs/QmP9vZfc5WSjfGTXmwX2EcicMFzmZ6fXn7HTdKYat6ccmH/go-ipfs-cmds"
7
+ cmds "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
8
)
9
10
func checkHelptextRecursive(t *testing.T, name []string, c *cmds.Command) {
core/commands/id.go
+2
-1
@@ -13,9 +13,10 @@ import (
13
e "github.com/ipfs/go-ipfs/core/commands/e"
14
15
kb "gx/ipfs/QmQEo84PQQPJpx9Bf2YxerGVgmgWvQ9iwuZBAJaNJKWREr/go-libp2p-kbucket"
16
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
16
b58 "gx/ipfs/QmT8rehPR3F6bmwL6zjUN8XpiDBFFpMP2myPdC6ApsWfJf/go-base58"
17
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
18
"gx/ipfs/QmWNY7dV54ZDYmTA1ykVdwNCqC11mpU4zSUp6XDpLTH9eG/go-libp2p-peer"
19
+ "gx/ipfs/QmXYjuNuxVzXKJCfWasQk1RqkhVLDM9jtUKhqc2WPQmFSB/go-libp2p-peer"
20
pstore "gx/ipfs/QmYijbtjCxFEjSXaudaQAUz3LN5VKLssm8WCUsRoqzXmQR/go-libp2p-peerstore"
21
identify "gx/ipfs/Qma23bpHwQrQyvKeBemaeJh7sAoRHggPkgnge1B9489ff5/go-libp2p/p2p/protocol/identify"
22
ic "gx/ipfs/QmaPbCnUMBohSGo3KnxEa2bHqyJVVeEEcwtqJAYxerieBo/go-libp2p-crypto"
core/commands/ipns.go
+1
-1
@@ -10,7 +10,7 @@ import (
10
namesys "github.com/ipfs/go-ipfs/namesys"
11
offline "github.com/ipfs/go-ipfs/routing/offline"
12
13
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
13
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
14
)
15
16
var IpnsCmd = &cmds.Command{
core/commands/keystore.go
+1
-1
@@ -12,7 +12,7 @@ import (
12
cmds "github.com/ipfs/go-ipfs/commands"
13
e "github.com/ipfs/go-ipfs/core/commands/e"
14
15
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
15
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
16
peer "gx/ipfs/QmWNY7dV54ZDYmTA1ykVdwNCqC11mpU4zSUp6XDpLTH9eG/go-libp2p-peer"
17
ci "gx/ipfs/QmaPbCnUMBohSGo3KnxEa2bHqyJVVeEEcwtqJAYxerieBo/go-libp2p-crypto"
18
)
core/commands/log.go
+1
-1
@@ -6,8 +6,8 @@ import (
6
7
cmds "github.com/ipfs/go-ipfs/commands"
8
9
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
9
logging "gx/ipfs/QmSpJByNKFX1sCsHBEp3R73FL4NF6FnQTEGyNAXHm2GS52/go-log"
10
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
11
)
12
13
// Golang os.Args overrides * and replaces the character argument with
core/commands/ls.go
+1
-1
@@ -18,7 +18,7 @@ import (
18
unixfspb "github.com/ipfs/go-ipfs/unixfs/pb"
19
20
node "gx/ipfs/QmNwUEK7QbwSqyKBu3mMtToo8SUc6wQJ7gdZq4gGGJqfnf/go-ipld-format"
21
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
21
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
22
)
23
24
type LsLink struct {
core/commands/mount_nofuse.go
+1
-1
@@ -6,7 +6,7 @@ package commands
6
import (
7
cmds "github.com/ipfs/go-ipfs/commands"
8
9
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
9
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
10
)
11
12
var MountCmd = &cmds.Command{
core/commands/mount_unix.go
+1
-1
@@ -13,7 +13,7 @@ import (
13
nodeMount "github.com/ipfs/go-ipfs/fuse/node"
14
config "github.com/ipfs/go-ipfs/repo/config"
15
16
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
16
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
17
)
18
19
var MountCmd = &cmds.Command{
core/commands/mount_windows.go
+1
-1
@@ -5,7 +5,7 @@ import (
5
6
cmds "github.com/ipfs/go-ipfs/commands"
7
8
- cmdkit "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
8
+ cmdkit "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
9
)
10
11
var MountCmd = &cmds.Command{
core/commands/name.go
+1
-1
@@ -3,7 +3,7 @@ package commands
3
import (
4
cmds "github.com/ipfs/go-ipfs/commands"
5
6
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
6
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
7
)
8
9
type IpnsEntry struct {
core/commands/object/diff.go
+1
-1
@@ -10,7 +10,7 @@ import (
10
e "github.com/ipfs/go-ipfs/core/commands/e"
11
dagutils "github.com/ipfs/go-ipfs/merkledag/utils"
12
path "github.com/ipfs/go-ipfs/path"
13
- cmdkit "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
13
+ cmdkit "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
14
)
15
16
type Changes struct {
core/commands/object/object.go
+1
-1
@@ -21,7 +21,7 @@ import (
21
ft "github.com/ipfs/go-ipfs/unixfs"
22
23
node "gx/ipfs/QmNwUEK7QbwSqyKBu3mMtToo8SUc6wQJ7gdZq4gGGJqfnf/go-ipld-format"
24
- cmdkit "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
24
+ cmdkit "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
25
cid "gx/ipfs/QmeSrf6pzut73u6zLQkRFQ3ygt3k6XFT2kjdYP8Tnkwwyg/go-cid"
26
)
27
core/commands/object/patch.go
+1
-1
@@ -13,7 +13,7 @@ import (
13
path "github.com/ipfs/go-ipfs/path"
14
ft "github.com/ipfs/go-ipfs/unixfs"
15
16
- cmdkit "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
16
+ cmdkit "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
17
)
18
19
var ObjectPatchCmd = &cmds.Command{
core/commands/p2p.go
+1
-1
@@ -11,7 +11,7 @@ import (
11
cmds "github.com/ipfs/go-ipfs/commands"
12
core "github.com/ipfs/go-ipfs/core"
13
14
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
14
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
15
ma "gx/ipfs/QmW8s4zTsUoX1Q6CeYxVKPyqSKbF7H1YDUyTostBtZ8DaG/go-multiaddr"
16
)
17
core/commands/pin.go
+2
-1
@@ -16,8 +16,9 @@ import (
16
pin "github.com/ipfs/go-ipfs/pin"
17
uio "github.com/ipfs/go-ipfs/unixfs/io"
18
19
+ cid "gx/ipfs/QmNp85zy9RLrQ5oQD4hPyS39ezrrXpcaa7R4Y9kxdWQLLQ/go-cid"
20
u "gx/ipfs/QmPsAfmDBnZN3kZGSuNwvCNDZiHneERSKmRcFyG3UkvcT3/go-ipfs-util"
20
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
21
+ u "gx/ipfs/QmSU6eubNdhXjFBJBSksTp8kv8YRub8mGAPv8tVJHmL2EU/go-ipfs-util"
22
cid "gx/ipfs/QmeSrf6pzut73u6zLQkRFQ3ygt3k6XFT2kjdYP8Tnkwwyg/go-cid"
23
)
24
core/commands/ping.go
+1
-1
@@ -13,7 +13,7 @@ import (
13
core "github.com/ipfs/go-ipfs/core"
14
15
u "gx/ipfs/QmPsAfmDBnZN3kZGSuNwvCNDZiHneERSKmRcFyG3UkvcT3/go-ipfs-util"
16
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
16
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
17
ma "gx/ipfs/QmW8s4zTsUoX1Q6CeYxVKPyqSKbF7H1YDUyTostBtZ8DaG/go-multiaddr"
18
peer "gx/ipfs/QmWNY7dV54ZDYmTA1ykVdwNCqC11mpU4zSUp6XDpLTH9eG/go-libp2p-peer"
19
pstore "gx/ipfs/QmYijbtjCxFEjSXaudaQAUz3LN5VKLssm8WCUsRoqzXmQR/go-libp2p-peerstore"
core/commands/publish.go
+1
-1
@@ -14,7 +14,7 @@ import (
14
keystore "github.com/ipfs/go-ipfs/keystore"
15
path "github.com/ipfs/go-ipfs/path"
16
17
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
17
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
18
peer "gx/ipfs/QmWNY7dV54ZDYmTA1ykVdwNCqC11mpU4zSUp6XDpLTH9eG/go-libp2p-peer"
19
crypto "gx/ipfs/QmaPbCnUMBohSGo3KnxEa2bHqyJVVeEEcwtqJAYxerieBo/go-libp2p-crypto"
20
)
core/commands/pubsub.go
+21
-21
@@ -12,8 +12,8 @@ import (
12
core "github.com/ipfs/go-ipfs/core"
13
14
floodsub "gx/ipfs/QmP1T1SGU6276R2MHKP2owbck37Fnzd6ZkpyNJvnG2LoTG/go-libp2p-floodsub"
15
- cmds "gx/ipfs/QmP9vZfc5WSjfGTXmwX2EcicMFzmZ6fXn7HTdKYat6ccmH/go-ipfs-cmds"
16
- cmdkit "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
15
+ cmds "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
16
+ cmdkit "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
17
pstore "gx/ipfs/QmYijbtjCxFEjSXaudaQAUz3LN5VKLssm8WCUsRoqzXmQR/go-libp2p-peerstore"
18
blocks "gx/ipfs/QmYsEQydGrsxNZfAiskvQ76N2xE9hDQtSAkRSynwMiUK3c/go-block-format"
19
cid "gx/ipfs/QmeSrf6pzut73u6zLQkRFQ3ygt3k6XFT2kjdYP8Tnkwwyg/go-cid"
@@ -70,8 +70,8 @@ This command outputs data in the following encodings:
70
Options: []cmdkit.Option{
71
cmdkit.BoolOption("discover", "try to discover other peers subscribed to the same topic"),
72
},
73
- Run: func(req cmds.Request, res cmds.ResponseEmitter) {
74
- n, err := req.InvocContext().GetNode()
73
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env interface{}) {
74
+ n, err := GetNode(env)
75
if err != nil {
76
res.SetError(err, cmdkit.ErrNormal)
77
return
@@ -88,7 +88,7 @@ This command outputs data in the following encodings:
88
return
89
}
90
91
- topic := req.Arguments()[0]
91
+ topic := req.Arguments[0]
92
sub, err := n.Floodsub.Subscribe(topic)
93
if err != nil {
94
res.SetError(err, cmdkit.ErrNormal)
@@ -96,7 +96,7 @@ This command outputs data in the following encodings:
96
}
97
defer sub.Cancel()
98
99
- discover, _, _ := req.Option("discover").Bool()
99
+ discover, _ := req.Options["discover"].(bool)
100
if discover {
101
go func() {
102
blk := blocks.NewBlock([]byte("floodsub:" + topic))
@@ -106,7 +106,7 @@ This command outputs data in the following encodings:
106
return
107
}
108
109
- connectToPubSubPeers(req.Context(), n, cid)
109
+ connectToPubSubPeers(req.Context, n, cid)
110
}()
111
}
112
@@ -115,7 +115,7 @@ This command outputs data in the following encodings:
115
}
116
117
for {
118
- msg, err := sub.Next(req.Context())
118
+ msg, err := sub.Next(req.Context)
119
if err == io.EOF || err == context.Canceled {
120
return
121
} else if err != nil {
@@ -127,7 +127,7 @@ This command outputs data in the following encodings:
127
}
128
},
129
Encoders: cmds.EncoderMap{
130
- cmds.Text: cmds.MakeEncoder(func(req cmds.Request, w io.Writer, v interface{}) error {
130
+ cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
131
m, ok := v.(*floodsub.Message)
132
if !ok {
133
return fmt.Errorf("unexpected type: %T", v)
@@ -136,7 +136,7 @@ This command outputs data in the following encodings:
136
_, err := w.Write(m.Data)
137
return err
138
}),
139
- "ndpayload": cmds.MakeEncoder(func(req cmds.Request, w io.Writer, v interface{}) error {
139
+ "ndpayload": cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
140
m, ok := v.(*floodsub.Message)
141
if !ok {
142
return fmt.Errorf("unexpected type: %T", v)
@@ -146,7 +146,7 @@ This command outputs data in the following encodings:
146
_, err := w.Write(m.Data)
147
return err
148
}),
149
- "lenpayload": cmds.MakeEncoder(func(req cmds.Request, w io.Writer, v interface{}) error {
149
+ "lenpayload": cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
150
m, ok := v.(*floodsub.Message)
151
if !ok {
152
return fmt.Errorf("unexpected type: %T", v)
@@ -203,8 +203,8 @@ To use, the daemon must be run with '--enable-pubsub-experiment'.
203
cmdkit.StringArg("topic", true, false, "Topic to publish to."),
204
cmdkit.StringArg("data", true, true, "Payload of message to publish.").EnableStdin(),
205
},
206
- Run: func(req cmds.Request, res cmds.ResponseEmitter) {
207
- n, err := req.InvocContext().GetNode()
206
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env interface{}) {
207
+ n, err := GetNode(env)
208
if err != nil {
209
res.SetError(err, cmdkit.ErrNormal)
210
return
@@ -221,9 +221,9 @@ To use, the daemon must be run with '--enable-pubsub-experiment'.
221
return
222
}
223
224
- topic := req.Arguments()[0]
224
+ topic := req.Arguments[0]
225
226
- for _, data := range req.Arguments()[1:] {
226
+ for _, data := range req.Arguments[1:] {
227
if err := n.Floodsub.Publish(topic, []byte(data)); err != nil {
228
res.SetError(err, cmdkit.ErrNormal)
229
return
@@ -244,8 +244,8 @@ to be used in a production environment.
244
To use, the daemon must be run with '--enable-pubsub-experiment'.
245
`,
246
},
247
- Run: func(req cmds.Request, res cmds.ResponseEmitter) {
248
- n, err := req.InvocContext().GetNode()
247
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env interface{}) {
248
+ n, err := GetNode(env)
249
if err != nil {
250
res.SetError(err, cmdkit.ErrNormal)
251
return
@@ -286,8 +286,8 @@ To use, the daemon must be run with '--enable-pubsub-experiment'.
286
Arguments: []cmdkit.Argument{
287
cmdkit.StringArg("topic", false, false, "topic to list connected peers of"),
288
},
289
- Run: func(req cmds.Request, res cmds.ResponseEmitter) {
290
- n, err := req.InvocContext().GetNode()
289
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env interface{}) {
290
+ n, err := GetNode(env)
291
if err != nil {
292
res.SetError(err, cmdkit.ErrNormal)
293
return
@@ -305,8 +305,8 @@ To use, the daemon must be run with '--enable-pubsub-experiment'.
305
}
306
307
var topic string
308
- if len(req.Arguments()) == 1 {
309
- topic = req.Arguments()[0]
308
+ if len(req.Arguments) == 1 {
309
+ topic = req.Arguments[0]
310
}
311
312
for _, peer := range n.Floodsub.ListPeers(topic) {
core/commands/refs.go
+1
-1
@@ -14,7 +14,7 @@ import (
14
path "github.com/ipfs/go-ipfs/path"
15
16
node "gx/ipfs/QmNwUEK7QbwSqyKBu3mMtToo8SUc6wQJ7gdZq4gGGJqfnf/go-ipld-format"
17
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
17
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
18
cid "gx/ipfs/QmeSrf6pzut73u6zLQkRFQ3ygt3k6XFT2kjdYP8Tnkwwyg/go-cid"
19
)
20
core/commands/repo.go
+13
-17
@@ -17,8 +17,9 @@ import (
17
fsrepo "github.com/ipfs/go-ipfs/repo/fsrepo"
18
lockfile "github.com/ipfs/go-ipfs/repo/fsrepo/lock"
19
20
- cmds "gx/ipfs/QmP9vZfc5WSjfGTXmwX2EcicMFzmZ6fXn7HTdKYat6ccmH/go-ipfs-cmds"
21
- cmdkit "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
20
+ lgc "github.com/ipfs/go-ipfs/commands/legacy"
21
+ cmds "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
22
+ cmdkit "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
23
cid "gx/ipfs/QmeSrf6pzut73u6zLQkRFQ3ygt3k6XFT2kjdYP8Tnkwwyg/go-cid"
24
)
25
@@ -35,13 +36,11 @@ var RepoCmd = &cmds.Command{
36
},
37
38
Subcommands: map[string]*cmds.Command{
38
- "stat": repoStatCmd,
39
- },
40
- OldSubcommands: map[string]*oldcmds.Command{
41
- "gc": repoGcCmd,
42
- "fsck": RepoFsckCmd,
43
- "version": repoVersionCmd,
44
- "verify": repoVerifyCmd,
39
+ "stat": repoStatCmd,
40
+ "gc": lgc.NewCommand(repoGcCmd),
41
+ "fsck": lgc.NewCommand(RepoFsckCmd),
42
+ "version": lgc.NewCommand(repoVersionCmd),
43
+ "verify": lgc.NewCommand(repoVerifyCmd),
44
},
45
}
46
@@ -160,14 +159,14 @@ RepoSize int Size in bytes that the repo is currently taking.
159
Version string The repo version.
160
`,
161
},
163
- Run: func(req cmds.Request, res cmds.ResponseEmitter) {
164
- n, err := req.InvocContext().GetNode()
162
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env interface{}) {
163
+ n, err := GetNode(env)
164
if err != nil {
165
res.SetError(err, cmdkit.ErrNormal)
166
return
167
}
168
170
- stat, err := corerepo.RepoStat(n, req.Context())
169
+ stat, err := corerepo.RepoStat(n, req.Context)
170
if err != nil {
171
res.SetError(err, cmdkit.ErrNormal)
172
return
@@ -180,16 +179,13 @@ Version string The repo version.
179
},
180
Type: corerepo.Stat{},
181
Encoders: cmds.EncoderMap{
183
- cmds.Text: cmds.MakeEncoder(func(req cmds.Request, w io.Writer, v interface{}) error {
182
+ cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
183
stat, ok := v.(*corerepo.Stat)
184
if !ok {
185
return e.TypeErr(stat, v)
186
}
187
189
- human, _, err := req.Option("human").Bool()
190
- if err != nil {
191
- return err
192
- }
188
+ human, _ := req.Options["human"].(bool)
189
190
wtr := tabwriter.NewWriter(w, 0, 0, 1, ' ', 0)
191
core/commands/resolve.go
+1
-1
@@ -10,7 +10,7 @@ import (
10
ns "github.com/ipfs/go-ipfs/namesys"
11
path "github.com/ipfs/go-ipfs/path"
12
13
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
13
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
14
)
15
16
type ResolvedPath struct {
core/commands/root.go
+44
-46
@@ -11,9 +11,10 @@ import (
11
ocmd "github.com/ipfs/go-ipfs/core/commands/object"
12
unixfs "github.com/ipfs/go-ipfs/core/commands/unixfs"
13
14
- "gx/ipfs/QmP9vZfc5WSjfGTXmwX2EcicMFzmZ6fXn7HTdKYat6ccmH/go-ipfs-cmds"
15
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
14
+ lgc "github.com/ipfs/go-ipfs/commands/legacy"
15
logging "gx/ipfs/QmSpJByNKFX1sCsHBEp3R73FL4NF6FnQTEGyNAXHm2GS52/go-log"
16
+ "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
17
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
18
)
19
20
var log = logging.Logger("core/commands")
@@ -91,6 +92,11 @@ The CLI will exit with one of the following values:
92
cmdkit.BoolOption("h", "Show a short version of the command help text."),
93
cmdkit.BoolOption("local", "L", "Run the command locally, instead of using the daemon."),
94
cmdkit.StringOption(ApiOption, "Use a specific API instance (defaults to /ip4/127.0.0.1/tcp/5001)"),
95
+
96
+ // global options, added to every command
97
+ cmds.OptionEncodingType,
98
+ cmds.OptionStreamChannels,
99
+ cmds.OptionTimeout,
100
},
101
}
102
@@ -108,34 +114,31 @@ var rootSubcommands = map[string]*cmds.Command{
114
"pubsub": PubsubCmd,
115
"repo": RepoCmd,
116
"stats": StatsCmd,
111
-}
112
-
113
-var rootOldSubcommands = map[string]*oldcmds.Command{
114
- "bootstrap": BootstrapCmd,
115
- "config": ConfigCmd,
116
- "dag": dag.DagCmd,
117
- "dht": DhtCmd,
118
- "diag": DiagCmd,
119
- "dns": DNSCmd,
120
- "files": files.FilesCmd,
121
- "id": IDCmd,
122
- "key": KeyCmd,
123
- "log": LogCmd,
124
- "ls": LsCmd,
125
- "mount": MountCmd,
126
- "name": NameCmd,
127
- "object": ocmd.ObjectCmd,
128
- "pin": PinCmd,
129
- "ping": PingCmd,
130
- "p2p": P2PCmd,
131
- "refs": RefsCmd,
132
- "resolve": ResolveCmd,
133
- "swarm": SwarmCmd,
134
- "tar": TarCmd,
135
- "file": unixfs.UnixFSCmd,
136
- "update": ExternalBinary(),
137
- "version": VersionCmd,
138
- "shutdown": daemonShutdownCmd,
117
+ "bootstrap": lgc.NewCommand(BootstrapCmd),
118
+ "config": lgc.NewCommand(ConfigCmd),
119
+ "dag": lgc.NewCommand(dag.DagCmd),
120
+ "dht": lgc.NewCommand(DhtCmd),
121
+ "diag": lgc.NewCommand(DiagCmd),
122
+ "dns": lgc.NewCommand(DNSCmd),
123
+ "files": lgc.NewCommand(files.FilesCmd),
124
+ "id": lgc.NewCommand(IDCmd),
125
+ "key": lgc.NewCommand(KeyCmd),
126
+ "log": lgc.NewCommand(LogCmd),
127
+ "ls": lgc.NewCommand(LsCmd),
128
+ "mount": lgc.NewCommand(MountCmd),
129
+ "name": lgc.NewCommand(NameCmd),
130
+ "object": lgc.NewCommand(ocmd.ObjectCmd),
131
+ "pin": lgc.NewCommand(PinCmd),
132
+ "ping": lgc.NewCommand(PingCmd),
133
+ "p2p": lgc.NewCommand(P2PCmd),
134
+ "refs": lgc.NewCommand(RefsCmd),
135
+ "resolve": lgc.NewCommand(ResolveCmd),
136
+ "swarm": lgc.NewCommand(SwarmCmd),
137
+ "tar": lgc.NewCommand(TarCmd),
138
+ "file": lgc.NewCommand(unixfs.UnixFSCmd),
139
+ "update": lgc.NewCommand(ExternalBinary()),
140
+ "version": lgc.NewCommand(VersionCmd),
141
+ "shutdown": lgc.NewCommand(daemonShutdownCmd),
142
}
143
144
// RootRO is the readonly version of Root
@@ -155,33 +158,30 @@ var rootROSubcommands = map[string]*cmds.Command{
158
},
159
},
160
"get": GetCmd,
158
-}
159
-
160
-var rootROOldSubcommands = map[string]*oldcmds.Command{
161
- "dns": DNSCmd,
162
- "ls": LsCmd,
163
- "name": &oldcmds.Command{
161
+ "dns": lgc.NewCommand(DNSCmd),
162
+ "ls": lgc.NewCommand(LsCmd),
163
+ "name": lgc.NewCommand(&oldcmds.Command{
164
Subcommands: map[string]*oldcmds.Command{
165
"resolve": IpnsCmd,
166
},
167
- },
168
- "object": &oldcmds.Command{
167
+ }),
168
+ "object": lgc.NewCommand(&oldcmds.Command{
169
Subcommands: map[string]*oldcmds.Command{
170
"data": ocmd.ObjectDataCmd,
171
"links": ocmd.ObjectLinksCmd,
172
"get": ocmd.ObjectGetCmd,
173
"stat": ocmd.ObjectStatCmd,
174
},
175
- },
176
- "dag": &oldcmds.Command{
175
+ }),
176
+ "dag": lgc.NewCommand(&oldcmds.Command{
177
Subcommands: map[string]*oldcmds.Command{
178
"get": dag.DagGetCmd,
179
"resolve": dag.DagResolveCmd,
180
},
181
- },
182
- "refs": RefsROCmd,
183
- "resolve": ResolveCmd,
184
- "version": VersionCmd,
181
+ }),
182
+ "refs": lgc.NewCommand(RefsROCmd),
183
+ "resolve": lgc.NewCommand(ResolveCmd),
184
+ "version": lgc.NewCommand(VersionCmd),
185
}
186
187
func init() {
@@ -192,10 +192,8 @@ func init() {
192
*RefsROCmd = *RefsCmd
193
RefsROCmd.Subcommands = map[string]*oldcmds.Command{}
194
195
- Root.OldSubcommands = rootOldSubcommands
195
Root.Subcommands = rootSubcommands
196
198
- RootRO.OldSubcommands = rootROOldSubcommands
197
RootRO.Subcommands = rootROSubcommands
198
}
199
core/commands/shutdown.go
+1
-1
@@ -3,7 +3,7 @@ package commands
3
import (
4
"fmt"
5
6
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
6
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
7
8
cmds "github.com/ipfs/go-ipfs/commands"
9
)
core/commands/stat.go
+11
-32
@@ -9,7 +9,8 @@ import (
9
10
cmds "gx/ipfs/QmP9vZfc5WSjfGTXmwX2EcicMFzmZ6fXn7HTdKYat6ccmH/go-ipfs-cmds"
11
humanize "gx/ipfs/QmPSBJL4momYnE7DcUyk2DVhD6rH488ZmHBGLbxNdhU44K/go-humanize"
12
- cmdkit "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
12
+ cmds "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
13
+ cmdkit "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
14
peer "gx/ipfs/QmWNY7dV54ZDYmTA1ykVdwNCqC11mpU4zSUp6XDpLTH9eG/go-libp2p-peer"
15
protocol "gx/ipfs/QmZNkThpqfVXs9GNbexPrfBbXSLNYeKrE7jwFM2oqHbyqN/go-libp2p-protocol"
16
metrics "gx/ipfs/QmaL2WYJGbWKqHoLujoi9GQ5jj4JVFrBqHUBWmEYzJPVWT/go-libp2p-metrics"
@@ -79,8 +80,8 @@ Example:
80
"ns", "us" (or "µs"), "ms", "s", "m", "h".`).WithDefault("1s"),
81
},
82
82
- Run: func(req cmds.Request, res cmds.ResponseEmitter) {
83
- nd, err := req.InvocContext().GetNode()
83
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env interface{}) {
84
+ nd, err := GetNode(env)
85
if err != nil {
86
res.SetError(err, cmdkit.ErrNormal)
87
return
@@ -97,17 +98,8 @@ Example:
98
return
99
}
100
100
- pstr, pfound, err := req.Option("peer").String()
101
- if err != nil {
102
- res.SetError(err, cmdkit.ErrNormal)
103
- return
104
- }
105
-
106
- tstr, tfound, err := req.Option("proto").String()
107
- if err != nil {
108
- res.SetError(err, cmdkit.ErrNormal)
109
- return
110
- }
101
+ pstr, pfound := req.Options["peer"].(string)
102
+ tstr, tfound := req.Options["proto"].(string)
103
if pfound && tfound {
104
res.SetError(errors.New("please only specify peer OR protocol"), cmdkit.ErrClient)
105
return
@@ -123,23 +115,14 @@ Example:
115
pid = checkpid
116
}
117
126
- timeS, _, err := req.Option("interval").String()
127
- if err != nil {
128
- res.SetError(err, cmdkit.ErrNormal)
129
- return
130
- }
118
+ timeS, _ := req.Options["interval"].(string)
119
interval, err := time.ParseDuration(timeS)
120
if err != nil {
121
res.SetError(err, cmdkit.ErrNormal)
122
return
123
}
124
137
- doPoll, _, err := req.Option("poll").Bool()
138
- if err != nil {
139
- res.SetError(err, cmdkit.ErrNormal)
140
- return
141
- }
142
-
125
+ doPoll, _ := req.Options["poll"].(bool)
126
for {
127
if pfound {
128
stats := nd.Reporter.GetBandwidthForPeer(pid)
@@ -157,7 +140,7 @@ Example:
140
}
141
select {
142
case <-time.After(interval):
160
- case <-req.Context().Done():
143
+ case <-req.Context.Done():
144
return
145
}
146
}
@@ -165,17 +148,13 @@ Example:
148
},
149
Type: metrics.Stats{},
150
PostRun: cmds.PostRunMap{
168
- cmds.CLI: func(req cmds.Request, re cmds.ResponseEmitter) cmds.ResponseEmitter {
151
+ cmds.CLI: func(req *cmds.Request, re cmds.ResponseEmitter) cmds.ResponseEmitter {
152
reNext, res := cmds.NewChanResponsePair(req)
153
154
go func() {
155
defer re.Close()
156
174
- polling, _, err := res.Request().Option("poll").Bool()
175
- if err != nil {
176
- return
177
- }
178
-
157
+ polling, _ := res.Request().Options["poll"].(bool)
158
fmt.Fprintln(os.Stdout, "Total Up Total Down Rate Up Rate Down")
159
for {
160
v, err := res.Next()
core/commands/swarm.go
+1
-1
@@ -15,9 +15,9 @@ import (
15
config "github.com/ipfs/go-ipfs/repo/config"
16
"github.com/ipfs/go-ipfs/repo/fsrepo"
17
18
- cmdkit "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
18
mafilter "gx/ipfs/QmSMZwvs3n4GBikZ7hKzT17c3bk65FmyZo2JqtJ16swqCv/multiaddr-filter"
19
swarm "gx/ipfs/QmUhvp4VoQ9cKDVLqAxciEKdm8ymBx2Syx4C1Tv6SmSTPa/go-libp2p-swarm"
20
+ cmdkit "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
21
ma "gx/ipfs/QmW8s4zTsUoX1Q6CeYxVKPyqSKbF7H1YDUyTostBtZ8DaG/go-multiaddr"
22
pstore "gx/ipfs/QmYijbtjCxFEjSXaudaQAUz3LN5VKLssm8WCUsRoqzXmQR/go-libp2p-peerstore"
23
iaddr "gx/ipfs/QmdMeXVB1V1SAZcFzoCuM3zR9K8PeuzCYg4zXNHcHh6dHU/go-ipfs-addr"
core/commands/sysdiag.go
+1
-1
@@ -8,8 +8,8 @@ import (
8
cmds "github.com/ipfs/go-ipfs/commands"
9
config "github.com/ipfs/go-ipfs/repo/config"
10
11
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
11
manet "gx/ipfs/QmSGL5Uoa6gKHgBBwQG8u1CWKUC8ZnwaZiLgFVTFBR2bxr/go-multiaddr-net"
12
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
13
sysi "gx/ipfs/QmZRjKbHa6DenStpQJFiaPcEwkZqrx7TH6xTf342LDU3qM/go-sysinfo"
14
)
15
core/commands/tar.go
+1
-1
@@ -12,7 +12,7 @@ import (
12
path "github.com/ipfs/go-ipfs/path"
13
tar "github.com/ipfs/go-ipfs/tar"
14
15
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
15
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
16
)
17
18
var TarCmd = &cmds.Command{
core/commands/unixfs/ls.go
+1
-1
@@ -15,7 +15,7 @@ import (
15
unixfs "github.com/ipfs/go-ipfs/unixfs"
16
uio "github.com/ipfs/go-ipfs/unixfs/io"
17
unixfspb "github.com/ipfs/go-ipfs/unixfs/pb"
18
- cmdkit "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
18
+ cmdkit "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
19
)
20
21
type LsLink struct {
core/commands/unixfs/unixfs.go
+1
-1
@@ -4,7 +4,7 @@ import (
4
cmds "github.com/ipfs/go-ipfs/commands"
5
e "github.com/ipfs/go-ipfs/core/commands/e"
6
7
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
7
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
8
)
9
10
var UnixFSCmd = &cmds.Command{
core/commands/version.go
+1
-1
@@ -10,7 +10,7 @@ import (
10
e "github.com/ipfs/go-ipfs/core/commands/e"
11
config "github.com/ipfs/go-ipfs/repo/config"
12
fsrepo "github.com/ipfs/go-ipfs/repo/fsrepo"
13
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit"
13
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit"
14
)
15
16
type VersionOutput struct {
core/corehttp/commands.go
+10
-7
@@ -7,12 +7,13 @@ import (
7
"strconv"
8
"strings"
9
10
+ oldcmds "github.com/ipfs/go-ipfs/commands"
11
core "github.com/ipfs/go-ipfs/core"
12
corecommands "github.com/ipfs/go-ipfs/core/commands"
13
config "github.com/ipfs/go-ipfs/repo/config"
14
14
- cmds "gx/ipfs/QmP9vZfc5WSjfGTXmwX2EcicMFzmZ6fXn7HTdKYat6ccmH/go-ipfs-cmds"
15
- cmdsHttp "gx/ipfs/QmP9vZfc5WSjfGTXmwX2EcicMFzmZ6fXn7HTdKYat6ccmH/go-ipfs-cmds/http"
15
+ cmds "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds"
16
+ cmdsHttp "gx/ipfs/QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K/go-ipfs-cmds/http"
17
)
18
19
const originEnvKey = "API_ORIGIN"
@@ -29,6 +30,8 @@ or
30
ipfs daemon --api-http-header 'Access-Control-Allow-Origin: *'
31
`
32
33
+const APIPath = "/api/v0"
34
+
35
var defaultLocalhostOrigins = []string{
36
"http://127.0.0.1:<port>",
37
"https://127.0.0.1:<port>",
@@ -100,7 +103,7 @@ func patchCORSVars(c *cmdsHttp.ServerConfig, addr net.Addr) {
103
c.SetAllowedOrigins(origins...)
104
}
105
103
-func commandsOption(cctx cmds.Context, command *cmds.Command) ServeOption {
106
+func commandsOption(cctx oldcmds.Context, command *cmds.Command) ServeOption {
107
return func(n *core.IpfsNode, l net.Listener, mux *http.ServeMux) (*http.ServeMux, error) {
108
109
cfg := cmdsHttp.NewServerConfig()
@@ -115,16 +118,16 @@ func commandsOption(cctx cmds.Context, command *cmds.Command) ServeOption {
118
addCORSDefaults(cfg)
119
patchCORSVars(cfg, l.Addr())
120
118
- cmdHandler := cmdsHttp.NewHandler(cctx, command, cfg)
119
- mux.Handle(cmdsHttp.ApiPath+"/", cmdHandler)
121
+ cmdHandler := cmdsHttp.NewHandler(&cctx, command, cfg)
122
+ mux.Handle(APIPath, cmdHandler)
123
return mux, nil
124
}
125
}
126
124
-func CommandsOption(cctx cmds.Context) ServeOption {
127
+func CommandsOption(cctx oldcmds.Context) ServeOption {
128
return commandsOption(cctx, corecommands.Root)
129
}
130
128
-func CommandsROOption(cctx cmds.Context) ServeOption {
131
+func CommandsROOption(cctx oldcmds.Context) ServeOption {
132
return commandsOption(cctx, corecommands.RootRO)
133
}
core/coreunix/add.go
+1
-1
@@ -25,8 +25,8 @@ import (
25
unixfs "github.com/ipfs/go-ipfs/unixfs"
26
27
node "gx/ipfs/QmNwUEK7QbwSqyKBu3mMtToo8SUc6wQJ7gdZq4gGGJqfnf/go-ipld-format"
28
- files "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit/files"
28
logging "gx/ipfs/QmSpJByNKFX1sCsHBEp3R73FL4NF6FnQTEGyNAXHm2GS52/go-log"
29
+ files "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit/files"
30
ds "gx/ipfs/QmdHG8MAuARdGHxx4rPQASLcvhz24fzjSQq7AJRAQEorq5/go-datastore"
31
syncds "gx/ipfs/QmdHG8MAuARdGHxx4rPQASLcvhz24fzjSQq7AJRAQEorq5/go-datastore/sync"
32
cid "gx/ipfs/QmeSrf6pzut73u6zLQkRFQ3ygt3k6XFT2kjdYP8Tnkwwyg/go-cid"
core/coreunix/add_test.go
+2
-2
@@ -19,9 +19,9 @@ import (
19
"github.com/ipfs/go-ipfs/repo/config"
20
ds2 "github.com/ipfs/go-ipfs/thirdparty/datastore2"
21
pi "github.com/ipfs/go-ipfs/thirdparty/posinfo"
22
- "gx/ipfs/QmYsEQydGrsxNZfAiskvQ76N2xE9hDQtSAkRSynwMiUK3c/go-block-format"
22
24
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit/files"
23
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit/files"
24
+ "gx/ipfs/QmYsEQydGrsxNZfAiskvQ76N2xE9hDQtSAkRSynwMiUK3c/go-block-format"
25
cid "gx/ipfs/QmeSrf6pzut73u6zLQkRFQ3ygt3k6XFT2kjdYP8Tnkwwyg/go-cid"
26
)
27
importer/helpers/dagbuilder.go
+1
-1
@@ -9,7 +9,7 @@ import (
9
ft "github.com/ipfs/go-ipfs/unixfs"
10
11
node "gx/ipfs/QmNwUEK7QbwSqyKBu3mMtToo8SUc6wQJ7gdZq4gGGJqfnf/go-ipld-format"
12
- files "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit/files"
12
+ files "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit/files"
13
cid "gx/ipfs/QmeSrf6pzut73u6zLQkRFQ3ygt3k6XFT2kjdYP8Tnkwwyg/go-cid"
14
)
15
importer/importer.go
+1
-1
@@ -11,7 +11,7 @@ import (
11
h "github.com/ipfs/go-ipfs/importer/helpers"
12
trickle "github.com/ipfs/go-ipfs/importer/trickle"
13
dag "github.com/ipfs/go-ipfs/merkledag"
14
- "gx/ipfs/QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD/go-ipfs-cmdkit/files"
14
+ "gx/ipfs/QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps/go-ipfs-cmdkit/files"
15
16
node "gx/ipfs/QmNwUEK7QbwSqyKBu3mMtToo8SUc6wQJ7gdZq4gGGJqfnf/go-ipld-format"
17
)
package.json
+4
-4
@@ -414,14 +414,14 @@
414
"version": "2.1.2"
415
},
416
{
417
- "hash": "QmP9vZfc5WSjfGTXmwX2EcicMFzmZ6fXn7HTdKYat6ccmH",
417
+ "hash": "QmTwKPLyeRKuDawuy6CAn1kRj1FVoqBEM8sviAUWN7NW9K",
418
"name": "go-ipfs-cmds",
419
- "version": "0.4.15"
419
+ "version": "0.5.0-dev"
420
},
421
{
422
- "hash": "QmQp2a2Hhb7F6eK2A5hN8f9aJy4mtkEikL9Zj4cgB7d1dD",
422
+ "hash": "QmVD1W3MC8Hk1WZgFQPWWmBECJ3X72BgUYf9eCQ4PGzPps",
423
"name": "go-ipfs-cmdkit",
424
- "version": "0.3.6"
424
+ "version": "1.0.0-dev"
425
},
426
{
427
"author": "whyrusleeping",