cmds/dag: use new cmds lib
License: MIT Signed-off-by: Overbool <overbool.xu@gmail.com>
Overbool committed
Oct 27, 2018 at 00:45 UTC
d31e92b446ec250250cb03df72673c51c23e2f1a
2 files changed
+67
-96
core/commands/dag/dag.go
+62
-91
@@ -1,23 +1,21 @@
1
package dagcmd
2
3
import (
4
- "bytes"
4
"fmt"
5
"io"
6
"math"
8
- "strings"
7
10
- path "gx/ipfs/QmRKuTyCzg7HFBcV1YUhzStroGtJSb8iWgyxfsDCwFhWTS/go-path"
11
-
12
- cmds "github.com/ipfs/go-ipfs/commands"
13
- e "github.com/ipfs/go-ipfs/core/commands/e"
14
- coredag "github.com/ipfs/go-ipfs/core/coredag"
15
- pin "github.com/ipfs/go-ipfs/pin"
8
+ "github.com/ipfs/go-ipfs/core/commands/cmdenv"
9
+ "github.com/ipfs/go-ipfs/core/commands/e"
10
+ "github.com/ipfs/go-ipfs/core/coredag"
11
+ "github.com/ipfs/go-ipfs/pin"
12
13
cid "gx/ipfs/QmPSQnBKM9g7BaUcZCvswUJVscQ1ipjmwxN5PXCjkp9EQ7/go-cid"
14
mh "gx/ipfs/QmPnFwZ2JXKnXgMw8CdBPxn7FWh6LLdjUjxV1fKHuJnkr8/go-multihash"
15
+ path "gx/ipfs/QmRKuTyCzg7HFBcV1YUhzStroGtJSb8iWgyxfsDCwFhWTS/go-path"
16
files "gx/ipfs/QmZMWMvWMVKCbHetJ4RgndbuEF1io2UpUxwQwtNjtYPzSC/go-ipfs-files"
17
ipld "gx/ipfs/QmdDXJs4axxefSPgK6Y1QhpJWKuDPnGJiqgq4uncb4rFHL/go-ipld-format"
18
+ cmds "gx/ipfs/QmdTmGruUz23vgzym3uWpnAEQdGdGifQqBvP8UXSRjG8gZ/go-ipfs-cmds"
19
cmdkit "gx/ipfs/Qmde5VP1qUkyQXKCfmEUA7bP64V2HAptbJ7phuPp7jXWwg/go-ipfs-cmdkit"
20
)
21
@@ -66,21 +64,16 @@ into an object of the specified format.
64
cmdkit.BoolOption("pin", "Pin this object when adding."),
65
cmdkit.StringOption("hash", "Hash function to use").WithDefault(""),
66
},
69
- Run: func(req cmds.Request, res cmds.Response) {
70
- n, err := req.InvocContext().GetNode()
67
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
68
+ nd, err := cmdenv.GetNode(env)
69
if err != nil {
72
- res.SetError(err, cmdkit.ErrNormal)
73
- return
70
+ return err
71
}
72
76
- ienc, _, _ := req.Option("input-enc").String()
77
- format, _, _ := req.Option("format").String()
78
- hash, _, err := req.Option("hash").String()
79
- dopin, _, err := req.Option("pin").Bool()
80
- if err != nil {
81
- res.SetError(err, cmdkit.ErrNormal)
82
- return
83
- }
73
+ ienc, _ := req.Options["input-enc"].(string)
74
+ format, _ := req.Options["format"].(string)
75
+ hash, _ := req.Options["hash"].(string)
76
+ dopin, _ := req.Options["pin"].(bool)
77
78
// mhType tells inputParser which hash should be used. MaxUint64 means 'use
79
// default hash' (sha256 for cbor, sha1 for git..)
@@ -90,18 +83,15 @@ into an object of the specified format.
83
var ok bool
84
mhType, ok = mh.Names[hash]
85
if !ok {
93
- res.SetError(fmt.Errorf("%s in not a valid multihash name", hash), cmdkit.ErrNormal)
94
-
95
- return
86
+ return fmt.Errorf("%s in not a valid multihash name", hash)
87
}
88
}
89
90
outChan := make(chan interface{}, 8)
100
- res.SetOutput((<-chan interface{})(outChan))
91
92
addAllAndPin := func(f files.File) error {
93
cids := cid.NewSet()
104
- b := ipld.NewBatch(req.Context(), n.DAG)
94
+ b := ipld.NewBatch(req.Context, nd.DAG)
95
96
for {
97
file, err := f.NextFile()
@@ -132,7 +122,7 @@ into an object of the specified format.
122
123
select {
124
case outChan <- &OutputObject{Cid: cid}:
135
- case <-req.Context().Done():
125
+ case <-req.Context.Done():
126
return nil
127
}
128
}
@@ -142,14 +132,14 @@ into an object of the specified format.
132
}
133
134
if dopin {
145
- defer n.Blockstore.PinLock().Unlock()
135
+ defer nd.Blockstore.PinLock().Unlock()
136
137
cids.ForEach(func(c cid.Cid) error {
148
- n.Pinning.PinWithMode(c, pin.Recursive)
138
+ nd.Pinning.PinWithMode(c, pin.Recursive)
139
return nil
140
})
141
152
- err := n.Pinning.Flush()
142
+ err := nd.Pinning.Flush()
143
if err != nil {
144
return err
145
}
@@ -158,29 +148,27 @@ into an object of the specified format.
148
return nil
149
}
150
151
+ errC := make(chan error)
152
go func() {
153
+ var err error
154
+ defer func() { errC <- err }()
155
defer close(outChan)
163
- if err := addAllAndPin(req.Files()); err != nil {
164
- res.SetError(err, cmdkit.ErrNormal)
165
- return
166
- }
156
+ err = addAllAndPin(req.Files)
157
}()
168
- },
169
- Type: OutputObject{},
170
- Marshalers: cmds.MarshalerMap{
171
- cmds.Text: func(res cmds.Response) (io.Reader, error) {
172
- v, err := unwrapOutput(res.Output())
173
- if err != nil {
174
- return nil, err
175
- }
158
177
- oobj, ok := v.(*OutputObject)
178
- if !ok {
179
- return nil, e.TypeErr(oobj, v)
180
- }
159
+ err = res.Emit(outChan)
160
+ if err != nil {
161
+ return err
162
+ }
163
182
- return strings.NewReader(oobj.Cid.String() + "\n"), nil
183
- },
164
+ return <-errC
165
+ },
166
+ Type: OutputObject{},
167
+ Encoders: cmds.EncoderMap{
168
+ cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *OutputObject) error {
169
+ fmt.Fprintln(w, out.Cid.String())
170
+ return nil
171
+ }),
172
},
173
}
174
@@ -195,41 +183,35 @@ format.
183
Arguments: []cmdkit.Argument{
184
cmdkit.StringArg("ref", true, false, "The object to get").EnableStdin(),
185
},
198
- Run: func(req cmds.Request, res cmds.Response) {
199
- n, err := req.InvocContext().GetNode()
186
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
187
+ nd, err := cmdenv.GetNode(env)
188
if err != nil {
201
- res.SetError(err, cmdkit.ErrNormal)
202
- return
189
+ return err
190
}
191
205
- p, err := path.ParsePath(req.Arguments()[0])
192
+ p, err := path.ParsePath(req.Arguments[0])
193
if err != nil {
207
- res.SetError(err, cmdkit.ErrNormal)
208
- return
194
+ return err
195
}
196
211
- lastCid, rem, err := n.Resolver.ResolveToLastNode(req.Context(), p)
197
+ lastCid, rem, err := nd.Resolver.ResolveToLastNode(req.Context, p)
198
if err != nil {
213
- res.SetError(err, cmdkit.ErrNormal)
214
- return
199
+ return err
200
}
216
- obj, err := n.DAG.Get(req.Context(), lastCid)
201
+ obj, err := nd.DAG.Get(req.Context, lastCid)
202
if err != nil {
218
- res.SetError(err, cmdkit.ErrNormal)
219
- return
203
+ return err
204
}
205
206
var out interface{} = obj
207
if len(rem) > 0 {
208
final, _, err := obj.Resolve(rem)
209
if err != nil {
226
- res.SetError(err, cmdkit.ErrNormal)
227
- return
210
+ return err
211
}
212
out = final
213
}
231
-
232
- res.SetOutput(out)
214
+ return res.Emit(&out)
215
},
216
}
217
@@ -244,48 +226,37 @@ var DagResolveCmd = &cmds.Command{
226
Arguments: []cmdkit.Argument{
227
cmdkit.StringArg("ref", true, false, "The path to resolve").EnableStdin(),
228
},
247
- Run: func(req cmds.Request, res cmds.Response) {
248
- n, err := req.InvocContext().GetNode()
229
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
230
+ nd, err := cmdenv.GetNode(env)
231
if err != nil {
250
- res.SetError(err, cmdkit.ErrNormal)
251
- return
232
+ return err
233
}
234
254
- p, err := path.ParsePath(req.Arguments()[0])
235
+ p, err := path.ParsePath(req.Arguments[0])
236
if err != nil {
256
- res.SetError(err, cmdkit.ErrNormal)
257
- return
237
+ return err
238
}
239
260
- lastCid, rem, err := n.Resolver.ResolveToLastNode(req.Context(), p)
240
+ lastCid, rem, err := nd.Resolver.ResolveToLastNode(req.Context, p)
241
if err != nil {
262
- res.SetError(err, cmdkit.ErrNormal)
263
- return
242
+ return err
243
}
244
266
- res.SetOutput(&ResolveOutput{
245
+ return res.Emit(&ResolveOutput{
246
Cid: lastCid,
247
RemPath: path.Join(rem),
248
})
249
},
271
- Marshalers: cmds.MarshalerMap{
272
- cmds.Text: func(res cmds.Response) (io.Reader, error) {
273
- v, err := unwrapOutput(res.Output())
274
- if err != nil {
275
- return nil, err
276
- }
277
-
278
- output := v.(*ResolveOutput)
279
- buf := new(bytes.Buffer)
280
- p := output.Cid.String()
281
- if output.RemPath != "" {
282
- p = path.Join([]string{p, output.RemPath})
250
+ Encoders: cmds.EncoderMap{
251
+ cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *ResolveOutput) error {
252
+ p := out.Cid.String()
253
+ if out.RemPath != "" {
254
+ p = path.Join([]string{p, out.RemPath})
255
}
256
285
- buf.WriteString(p)
286
-
287
- return buf, nil
288
- },
257
+ fmt.Fprint(w, p)
258
+ return nil
259
+ }),
260
},
261
Type: ResolveOutput{},
262
}
core/commands/root.go
+5
-5
@@ -124,7 +124,7 @@ var rootSubcommands = map[string]*cmds.Command{
124
"stats": StatsCmd,
125
"bootstrap": lgc.NewCommand(BootstrapCmd),
126
"config": lgc.NewCommand(ConfigCmd),
127
- "dag": lgc.NewCommand(dag.DagCmd),
127
+ "dag": dag.DagCmd,
128
"dht": lgc.NewCommand(DhtCmd),
129
"diag": lgc.NewCommand(DiagCmd),
130
"dns": lgc.NewCommand(DNSCmd),
@@ -169,7 +169,7 @@ var rootROSubcommands = map[string]*cmds.Command{
169
"get": GetCmd,
170
"dns": lgc.NewCommand(DNSCmd),
171
"ls": lgc.NewCommand(LsCmd),
172
- "name": &cmds.Command{
172
+ "name": {
173
Subcommands: map[string]*cmds.Command{
174
"resolve": name.IpnsCmd,
175
},
@@ -182,12 +182,12 @@ var rootROSubcommands = map[string]*cmds.Command{
182
"stat": ocmd.ObjectStatCmd,
183
},
184
}),
185
- "dag": lgc.NewCommand(&oldcmds.Command{
186
- Subcommands: map[string]*oldcmds.Command{
185
+ "dag": {
186
+ Subcommands: map[string]*cmds.Command{
187
"get": dag.DagGetCmd,
188
"resolve": dag.DagResolveCmd,
189
},
190
- }),
190
+ },
191
"resolve": ResolveCmd,
192
"version": lgc.NewCommand(VersionCmd),
193
}