mirror of
https://github.com/ipfs/kubo.git
synced 2026-03-13 12:18:00 +08:00
123 lines
2.8 KiB
Go
123 lines
2.8 KiB
Go
package commands
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"time"
|
|
|
|
"github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
|
|
|
|
mh "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multihash"
|
|
"github.com/jbenet/go-ipfs/blocks"
|
|
cmds "github.com/jbenet/go-ipfs/commands"
|
|
u "github.com/jbenet/go-ipfs/util"
|
|
)
|
|
|
|
type Block struct {
|
|
Key string
|
|
Length int
|
|
}
|
|
|
|
var blockCmd = &cmds.Command{
|
|
Help: `ipfs block - manipulate raw ipfs blocks
|
|
|
|
ipfs block get <key> - get and output block named by <key>
|
|
ipfs block put - store stdin as a block, outputs <key>
|
|
|
|
ipfs block is a plumbing command used to manipulate raw ipfs blocks.
|
|
Reads from stdin or writes to stdout, and <key> is a base58 encoded
|
|
multihash.`,
|
|
Subcommands: map[string]*cmds.Command{
|
|
"get": blockGetCmd,
|
|
"put": blockPutCmd,
|
|
},
|
|
}
|
|
|
|
var blockGetCmd = &cmds.Command{
|
|
Arguments: []cmds.Argument{
|
|
cmds.Argument{"key", cmds.ArgString, true, false},
|
|
},
|
|
Help: `ipfs get <key> - gets and outputs block named by <key>
|
|
|
|
'ipfs block get' is a plumbing command for retreiving raw ipfs blocks.
|
|
<key> is a base58 encoded multihash`,
|
|
Run: func(res cmds.Response, req cmds.Request) {
|
|
n := req.Context().Node
|
|
|
|
key, ok := req.Arguments()[0].(string)
|
|
if !ok {
|
|
res.SetError(errors.New("cast error"), cmds.ErrNormal)
|
|
return
|
|
}
|
|
|
|
if !u.IsValidHash(key) {
|
|
res.SetError(errors.New("Not a valid hash"), cmds.ErrClient)
|
|
return
|
|
}
|
|
|
|
h, err := mh.FromB58String(key)
|
|
if err != nil {
|
|
res.SetError(err, cmds.ErrNormal)
|
|
return
|
|
}
|
|
|
|
k := u.Key(h)
|
|
ctx, _ := context.WithTimeout(context.TODO(), time.Second*5)
|
|
b, err := n.Blocks.GetBlock(ctx, k)
|
|
if err != nil {
|
|
res.SetError(err, cmds.ErrNormal)
|
|
return
|
|
}
|
|
|
|
res.SetOutput(bytes.NewReader(b.Data))
|
|
},
|
|
}
|
|
|
|
var blockPutCmd = &cmds.Command{
|
|
Arguments: []cmds.Argument{
|
|
cmds.Argument{"data", cmds.ArgFile, true, false},
|
|
},
|
|
Help: `ipfs put - stores input as a block, outputs its key
|
|
|
|
ipfs block put is a plumbing command for storing raw ipfs blocks.`,
|
|
Run: func(res cmds.Response, req cmds.Request) {
|
|
n := req.Context().Node
|
|
|
|
in, ok := req.Arguments()[0].(io.Reader)
|
|
if !ok {
|
|
res.SetError(errors.New("cast error"), cmds.ErrNormal)
|
|
return
|
|
}
|
|
|
|
data, err := ioutil.ReadAll(in)
|
|
if err != nil {
|
|
res.SetError(err, cmds.ErrNormal)
|
|
return
|
|
}
|
|
|
|
b := blocks.NewBlock(data)
|
|
|
|
k, err := n.Blocks.AddBlock(b)
|
|
if err != nil {
|
|
res.SetError(err, cmds.ErrNormal)
|
|
return
|
|
}
|
|
|
|
res.SetOutput(&Block{
|
|
Key: k.String(),
|
|
Length: len(data),
|
|
})
|
|
},
|
|
Type: &Block{},
|
|
Marshallers: map[cmds.EncodingType]cmds.Marshaller{
|
|
cmds.Text: func(res cmds.Response) ([]byte, error) {
|
|
block := res.Output().(*Block)
|
|
s := fmt.Sprintf("Block added (%v bytes): %s\n", block.Length, block.Key)
|
|
return []byte(s), nil
|
|
},
|
|
},
|
|
}
|