func (bs *blockstore) Get(k *cid.Cid) (blocks.Block, error) {
if k == nil {
log.Error("nil cid in blockstore")
return nil, ErrNotFound
}
maybeData, err := bs.datastore.Get(dshelp.CidToDsKey(k))
if err == ds.ErrNotFound {
return nil, ErrNotFound
}
if err != nil {
return nil, err
}
bdata, ok := maybeData.([]byte)
if !ok {
return nil, ValueTypeMismatch
}
if bs.rehash {
rbcid, err := k.Prefix().Sum(bdata)
if err != nil {
return nil, err
}
if !rbcid.Equals(k) {
return nil, ErrHashMismatch
}
return blocks.NewBlockWithCid(bdata, rbcid)
} else {
return blocks.NewBlockWithCid(bdata, k)
}
}
func TestCidRetention(t *testing.T) {
nd := new(ProtoNode)
nd.SetData([]byte("fooooo"))
pref := nd.Cid().Prefix()
pref.Version = 1
c2, err := pref.Sum(nd.RawData())
if err != nil {
t.Fatal(err)
}
blk, err := blocks.NewBlockWithCid(nd.RawData(), c2)
if err != nil {
t.Fatal(err)
}
bs := dstest.Bserv()
_, err = bs.AddBlock(blk)
if err != nil {
t.Fatal(err)
}
ds := NewDAGService(bs)
out, err := ds.Get(context.Background(), c2)
if err != nil {
t.Fatal(err)
}
if !out.Cid().Equals(c2) {
t.Fatal("output cid didnt match")
}
}
func NewRawNode(data []byte) *RawNode {
h := u.Hash(data)
c := cid.NewCidV1(cid.Raw, h)
blk, _ := blocks.NewBlockWithCid(data, c)
return &RawNode{blk}
}
func (rn *RawNode) Copy() node.Node {
copybuf := make([]byte, len(rn.RawData()))
copy(copybuf, rn.RawData())
nblk, err := blocks.NewBlockWithCid(rn.RawData(), rn.Cid())
if err != nil {
// programmer error
panic("failure attempting to clone raw block: " + err.Error())
}
return &RawNode{nblk}
}
func newMessageFromProto(pbm pb.Message) (BitSwapMessage, error) {
m := newMsg(pbm.GetWantlist().GetFull())
for _, e := range pbm.GetWantlist().GetEntries() {
c, err := cid.Cast([]byte(e.GetBlock()))
if err != nil {
return nil, fmt.Errorf("incorrectly formatted cid in wantlist: %s", err)
}
m.addEntry(c, int(e.GetPriority()), e.GetCancel())
}
// deprecated
for _, d := range pbm.GetBlocks() {
// CIDv0, sha256, protobuf only
b := blocks.NewBlock(d)
m.AddBlock(b)
}
//
for _, b := range pbm.GetPayload() {
pref, err := cid.PrefixFromBytes(b.GetPrefix())
if err != nil {
return nil, err
}
c, err := pref.Sum(b.GetData())
if err != nil {
return nil, err
}
blk, err := blocks.NewBlockWithCid(b.GetData(), c)
if err != nil {
return nil, err
}
m.AddBlock(blk)
}
return m, nil
}
pref.Codec = cid.Raw
case "v0":
pref.Version = 0
pref.Codec = cid.Protobuf
default:
res.SetError(fmt.Errorf("unrecognized format: %s", format), cmds.ErrNormal)
return
}
bcid, err := pref.Sum(data)
if err != nil {
res.SetError(err, cmds.ErrNormal)
return
}
b, err := blocks.NewBlockWithCid(data, bcid)
if err != nil {
res.SetError(err, cmds.ErrNormal)
return
}
log.Debugf("BlockPut key: '%q'", b.Cid())
k, err := n.Blocks.AddBlock(b)
if err != nil {
res.SetError(err, cmds.ErrNormal)
return
}
res.SetOutput(&BlockStat{
Key: k.String(),
Size: len(data),
