coosld/kubo
1
0
Fork 0
mirror of https://github.com/ipfs/kubo.git synced 2026-03-01 06:17:56 +08:00
Code Issues Actions 13 Packages Projects Releases Wiki Activity

namecache: update name follow to new cmd lib

Browse Source 
License: MIT
Signed-off-by: Łukasz Magiera <magik6k@gmail.com>
This commit is contained in:
Łukasz Magiera 2018-11-28 00:09:13 +01:00
parent 96648f2713
commit 7d6de7ec96
2 changed files with 42 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
core/commands/follow.go → core/commands/name/follow.go
View File

@ -1,15 +1,14 @@
package commands
package name
import (
"errors"
"fmt"
"io"
"strings"
"time"
cmds "github.com/ipfs/go-ipfs/commands"
e "github.com/ipfs/go-ipfs/core/commands/e"
"github.com/ipfs/go-ipfs/core/commands/cmdenv"
nc "github.com/ipfs/go-ipfs/namecache"
"gx/ipfs/QmR77mMvvh8mJBBWQmBfQBu8oD38NUN4KE9SL2gDgAQNc6/go-ipfs-cmds"
"gx/ipfs/Qmde5VP1qUkyQXKCfmEUA7bP64V2HAptbJ7phuPp7jXWwg/go-ipfs-cmdkit"
)
@ -46,48 +45,39 @@ Follows an IPNS name by periodically resolving in the backround.
cmdkit.StringOption("refresh-interval", "Follow refresh interval; defaults to 1hr."),
},
Run: func(req cmds.Request, res cmds.Response) {
n, err := req.InvocContext().GetNode()
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
n, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
if n.Namecache == nil {
res.SetError(errors.New("IPNS Namecache is not available"), cmdkit.ErrClient)
return
}
pin, _, _ := req.Option("pin").Bool()
refrS, _, err := req.Option("refresh-interval").String()
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return cmdkit.Errorf(cmdkit.ErrClient, "IPNS Namecache is not available")
}
pin, _ := req.Options["pin"].(bool)
refrS, _ := req.Options["refresh-interval"].(string)
refr := nc.DefaultFollowInterval
if refrS != "" {
refr, err = time.ParseDuration(refrS)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
}
for _, name := range req.Arguments() {
for _, name := range req.Arguments {
err = n.Namecache.Follow(name, pin, refr)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
}
res.SetOutput(&ipnsFollowResult{"ok"})
return cmds.EmitOnce(res, &ipnsFollowResult{"ok"})
},
Type: ipnsFollowResult{},
Marshalers: cmds.MarshalerMap{
cmds.Text: marshalFollowResult,
Encoders: cmds.EncoderMap{
cmds.Text: encodeFollowResult(),
},
}
@ -95,23 +85,21 @@ var ipnsFollowListCmd = &cmds.Command{
Helptext: cmdkit.HelpText{
Tagline: "List names followed by the daemon",
},
Run: func(req cmds.Request, res cmds.Response) {
n, err := req.InvocContext().GetNode()
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
n, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
if n.Namecache == nil {
res.SetError(errors.New("IPNS Namecache is not available"), cmdkit.ErrClient)
return
return cmdkit.Errorf(cmdkit.ErrClient, "IPNS Namecache is not available")
}
res.SetOutput(&stringList{n.Namecache.ListFollows()})
return cmds.EmitOnce(res, &stringList{n.Namecache.ListFollows()})
},
Type: stringList{},
Marshalers: cmds.MarshalerMap{
cmds.Text: stringListMarshaler,
Encoders: cmds.EncoderMap{
cmds.Text: stringListEncoder(),
},
}
@ -122,44 +110,34 @@ var ipnsFollowCancelCmd = &cmds.Command{
Arguments: []cmdkit.Argument{
cmdkit.StringArg("name", true, true, "Name follow to cancel."),
},
Run: func(req cmds.Request, res cmds.Response) {
n, err := req.InvocContext().GetNode()
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
n, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
if n.Namecache == nil {
res.SetError(errors.New("IPNS Namecache is not available"), cmdkit.ErrClient)
return
return cmdkit.Errorf(cmdkit.ErrClient, "IPNS Namecache is not available")
}
for _, name := range req.Arguments() {
for _, name := range req.Arguments {
err = n.Namecache.Unfollow(name)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
}
res.SetOutput(&ipnsFollowResult{"ok"})
return cmds.EmitOnce(res, &ipnsFollowResult{"ok"})
},
Type: ipnsFollowResult{},
Marshalers: cmds.MarshalerMap{
cmds.Text: marshalFollowResult,
Encoders: cmds.EncoderMap{
cmds.Text: encodeFollowResult(),
},
}
func marshalFollowResult(res cmds.Response) (io.Reader, error) {
v, err := unwrapOutput(res.Output())
if err != nil {
return nil, err
}
output, ok := v.(*ipnsFollowResult)
if !ok {
return nil, e.TypeErr(output, v)
}
return strings.NewReader(output.Result + "\n"), nil
func encodeFollowResult() cmds.EncoderFunc {
return cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, list *ipnsFollowResult) error {
_, err := fmt.Fprintf(w, "%s\n", list.Result)
return err
})
}

8
namecache/namecache.go
View File

@ -11,12 +11,12 @@ import (
namesys "github.com/ipfs/go-ipfs/namesys"
pin "github.com/ipfs/go-ipfs/pin"
uio "gx/ipfs/QmQ1JnYpnzkaurjW1yxkQxC2w3K1PorNE1nv1vaP5Le7sq/go-unixfs/io"
cid "gx/ipfs/QmR8BauakNcBa3RbE4nbQu76PDiJgoQgz8AJdhJuiU4TAw/go-cid"
ipld "gx/ipfs/QmRL22E4paat7ky7vx9MLpR97JHHbFPrg3ytFQw6qp1y1s/go-ipld-format"
bstore "gx/ipfs/QmS2aqUZLJp8kF1ihE5rvDGE5LvmKDPnx32w9Z1BW9xLV5/go-ipfs-blockstore"
uio "gx/ipfs/QmUnHNqhSB1JgzVCxL1Kz3yb4bdyB4q1Z9AD5AUBVmt3fZ/go-unixfs/io"
path "gx/ipfs/QmVi2uUygezqaMTqs3Yzt5FcZFHJoYD4B7jQ2BELjj7ZuY/go-path"
resolver "gx/ipfs/QmVi2uUygezqaMTqs3Yzt5FcZFHJoYD4B7jQ2BELjj7ZuY/go-path/resolver"
ipld "gx/ipfs/QmcKKBwfz6FyQdHR2jsXrrF6XeSBXYL86anmWNewpFpoF5/go-ipld-format"
path "gx/ipfs/QmWqh9oob7ZHQRwU5CdTqpnC8ip8BEkFNrwXRxeNo5Y7vA/go-path"
resolver "gx/ipfs/QmWqh9oob7ZHQRwU5CdTqpnC8ip8BEkFNrwXRxeNo5Y7vA/go-path/resolver"
logging "gx/ipfs/QmcuXC5cxs79ro2cUuHs4HQ2bkDLJUYokwL8aivcX6HW3C/go-log"
)