opensource/kubo
1
0
Fork 0
mirror of https://github.com/ipfs/kubo.git synced 2025-06-25 06:58:18 +08:00
Code Issues Projects Releases Wiki Activity

use string datastore keys.

Browse Source
This commit is contained in:
Juan Batiz-Benet
2014-10-03 15:34:08 -07:00
parent 2ce9415c69
commit 612be59643
8 changed files with 39 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
blockservice/blockservice.go
View File

@ -7,7 +7,7 @@ import (
context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
ds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/datastore.go"
mh "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multihash"
"github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/op/go-logging"
logging "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/op/go-logging"
blocks "github.com/jbenet/go-ipfs/blocks"
exchange "github.com/jbenet/go-ipfs/exchange"
@ -37,11 +37,10 @@ func NewBlockService(d ds.Datastore, rem exchange.Interface) (*BlockService, err
// AddBlock adds a particular block to the service, Putting it into the datastore.
func (s *BlockService) AddBlock(b *blocks.Block) (u.Key, error) {
k := b.Key()
dsk := ds.NewKey(string(k))
log.Debug("storing [%s] in datastore", k.Pretty())
// TODO(brian): define a block datastore with a Put method which accepts a
// block parameter
err := s.Datastore.Put(dsk, b.Data)
err := s.Datastore.Put(k.DsKey(), b.Data)
if err != nil {
return k, err
}
@ -56,8 +55,7 @@ func (s *BlockService) AddBlock(b *blocks.Block) (u.Key, error) {
// Getting it from the datastore using the key (hash).
func (s *BlockService) GetBlock(k u.Key) (*blocks.Block, error) {
log.Debug("BlockService GetBlock: '%s'", k.Pretty())
dsk := ds.NewKey(string(k))
datai, err := s.Datastore.Get(dsk)
datai, err := s.Datastore.Get(k.DsKey())
if err == nil {
log.Debug("Blockservice: Got data in datastore.")
bdata, ok := datai.([]byte)

8
blockstore/blockstore.go
View File

@ -27,7 +27,7 @@ type blockstore struct {
}
func (bs *blockstore) Get(k u.Key) (*blocks.Block, error) {
maybeData, err := bs.datastore.Get(toDatastoreKey(k))
maybeData, err := bs.datastore.Get(k.DsKey())
if err != nil {
return nil, err
}
@ -39,9 +39,5 @@ func (bs *blockstore) Get(k u.Key) (*blocks.Block, error) {
}
func (bs *blockstore) Put(block blocks.Block) error {
return bs.datastore.Put(toDatastoreKey(block.Key()), block.Data)
}
func toDatastoreKey(k u.Key) ds.Key {
return ds.NewKey(string(k))
return bs.datastore.Put(block.Key().DsKey(), block.Data)
}

2
blockstore/blockstore_test.go
View File

@ -44,7 +44,7 @@ func TestValueTypeMismatch(t *testing.T) {
block := testutil.NewBlockOrFail(t, "some data")
datastore := ds.NewMapDatastore()
datastore.Put(toDatastoreKey(block.Key()), "data that isn't a block!")
datastore.Put(block.Key().DsKey(), "data that isn't a block!")
blockstore := NewBlockstore(datastore)

8
peer/peerstore.go
View File

@ -37,7 +37,7 @@ func (p *peerstore) Get(i ID) (*Peer, error) {
p.RLock()
defer p.RUnlock()
k := ds.NewKey(string(i))
k := u.Key(i).DsKey()
val, err := p.peers.Get(k)
if err != nil {
return nil, err
@ -54,7 +54,7 @@ func (p *peerstore) Put(peer *Peer) error {
p.Lock()
defer p.Unlock()
k := ds.NewKey(string(peer.ID))
k := u.Key(peer.ID).DsKey()
return p.peers.Put(k, peer)
}
@ -62,7 +62,7 @@ func (p *peerstore) Delete(i ID) error {
p.Lock()
defer p.Unlock()
k := ds.NewKey(string(i))
k := u.Key(i).DsKey()
return p.peers.Delete(k)
}
@ -84,7 +84,7 @@ func (p *peerstore) All() (*Map, error) {
pval, ok := val.(*Peer)
if ok {
(*ps)[u.Key(k.String())] = pval
(*ps)[u.Key(pval.ID)] = pval
}
}
return ps, nil

16
routing/dht/dht.go
View File

@ -13,11 +13,11 @@ import (
peer "github.com/jbenet/go-ipfs/peer"
kb "github.com/jbenet/go-ipfs/routing/kbucket"
u "github.com/jbenet/go-ipfs/util"
"github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/op/go-logging"
context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
ds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/datastore.go"
ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
logging "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/op/go-logging"
"github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/goprotobuf/proto"
)
@ -328,7 +328,7 @@ func (dht *IpfsDHT) getFromPeerList(ctx context.Context, key u.Key,
func (dht *IpfsDHT) getLocal(key u.Key) ([]byte, error) {
dht.dslock.Lock()
defer dht.dslock.Unlock()
v, err := dht.datastore.Get(ds.NewKey(string(key)))
v, err := dht.datastore.Get(key.DsKey())
if err != nil {
return nil, err
}
@ -341,7 +341,7 @@ func (dht *IpfsDHT) getLocal(key u.Key) ([]byte, error) {
}
func (dht *IpfsDHT) putLocal(key u.Key, value []byte) error {
return dht.datastore.Put(ds.NewKey(string(key)), value)
return dht.datastore.Put(key.DsKey(), value)
}
// Update signals to all routingTables to Update their last-seen status
@ -494,13 +494,19 @@ func (dht *IpfsDHT) ensureConnectedToPeer(pbp *Message_Peer) (*peer.Peer, error)
return p, err
}
//TODO: this should be smarter about which keys it selects.
func (dht *IpfsDHT) loadProvidableKeys() error {
kl, err := dht.datastore.KeyList()
if err != nil {
return err
}
for _, k := range kl {
dht.providers.AddProvider(u.Key(k.Bytes()), dht.self)
for _, dsk := range kl {
k := u.KeyFromDsKey(dsk)
if len(k) == 0 {
log.Error("loadProvidableKeys error: %v", dsk)
}
dht.providers.AddProvider(k, dht.self)
}
return nil
}

7
routing/dht/handlers.go
View File

@ -51,7 +51,7 @@ func (dht *IpfsDHT) handleGetValue(p *peer.Peer, pmes *Message) (*Message, error
// let's first check if we have the value locally.
u.DOut("[%s] handleGetValue looking into ds\n", dht.self.ID.Pretty())
dskey := ds.NewKey(pmes.GetKey())
dskey := u.Key(pmes.GetKey()).DsKey()
iVal, err := dht.datastore.Get(dskey)
u.DOut("[%s] handleGetValue looking into ds GOT %v\n", dht.self.ID.Pretty(), iVal)
@ -96,7 +96,7 @@ func (dht *IpfsDHT) handleGetValue(p *peer.Peer, pmes *Message) (*Message, error
func (dht *IpfsDHT) handlePutValue(p *peer.Peer, pmes *Message) (*Message, error) {
dht.dslock.Lock()
defer dht.dslock.Unlock()
dskey := ds.NewKey(pmes.GetKey())
dskey := u.Key(pmes.GetKey()).DsKey()
err := dht.datastore.Put(dskey, pmes.GetValue())
u.DOut("[%s] handlePutValue %v %v\n", dht.self.ID.Pretty(), dskey, pmes.GetValue())
return pmes, err
@ -137,7 +137,8 @@ func (dht *IpfsDHT) handleGetProviders(p *peer.Peer, pmes *Message) (*Message, e
resp := newMessage(pmes.GetType(), pmes.GetKey(), pmes.GetClusterLevel())
// check if we have this value, to add ourselves as provider.
has, err := dht.datastore.Has(ds.NewKey(pmes.GetKey()))
dsk := u.Key(pmes.GetKey()).DsKey()
has, err := dht.datastore.Has(dsk)
if err != nil && err != ds.ErrNotFound {
u.PErr("unexpected datastore error: %v\n", err)
has = false

4
routing/mock/routing.go
View File

@ -33,11 +33,11 @@ func (mr *MockRouter) SetRoutingServer(rs RoutingServer) {
}
func (mr *MockRouter) PutValue(ctx context.Context, key u.Key, val []byte) error {
return mr.datastore.Put(ds.NewKey(string(key)), val)
return mr.datastore.Put(key.DsKey(), val)
}
func (mr *MockRouter) GetValue(ctx context.Context, key u.Key) ([]byte, error) {
v, err := mr.datastore.Get(ds.NewKey(string(key)))
v, err := mr.datastore.Get(key.DsKey())
if err != nil {
return nil, err
}

12
util/util.go
View File

@ -41,6 +41,18 @@ func (k Key) Pretty() string {
return b58.Encode([]byte(k))
}
// DsKey returns a Datastore key
func (k Key) DsKey() ds.Key {
return ds.NewKey(k.Pretty())
}
// KeyFromDsKey returns a Datastore key
func KeyFromDsKey(dsk ds.Key) Key {
l := dsk.List()
enc := l[len(l)-1]
return Key(b58.Decode(enc))
}
// Hash is the global IPFS hash function. uses multihash SHA2_256, 256 bits
func Hash(data []byte) (mh.Multihash, error) {
return mh.Sum(data, mh.SHA2_256, -1)