mirror of
https://github.com/ipfs/kubo.git
synced 2025-09-09 23:42:20 +08:00
93 lines
2.4 KiB
Go
93 lines
2.4 KiB
Go
package mockrouting
|
|
|
|
import (
|
|
"errors"
|
|
"time"
|
|
|
|
ds "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore"
|
|
ma "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
|
|
context "github.com/ipfs/go-ipfs/Godeps/_workspace/src/golang.org/x/net/context"
|
|
key "github.com/ipfs/go-ipfs/blocks/key"
|
|
peer "github.com/ipfs/go-ipfs/p2p/peer"
|
|
routing "github.com/ipfs/go-ipfs/routing"
|
|
"github.com/ipfs/go-ipfs/util/testutil"
|
|
logging "github.com/ipfs/go-ipfs/vendor/go-log-v1.0.0"
|
|
)
|
|
|
|
var log = logging.Logger("mockrouter")
|
|
|
|
type client struct {
|
|
datastore ds.Datastore
|
|
server server
|
|
peer testutil.Identity
|
|
}
|
|
|
|
// FIXME(brian): is this method meant to simulate putting a value into the network?
|
|
func (c *client) PutValue(ctx context.Context, key key.Key, val []byte) error {
|
|
log.Debugf("PutValue: %s", key)
|
|
return c.datastore.Put(key.DsKey(), val)
|
|
}
|
|
|
|
// FIXME(brian): is this method meant to simulate getting a value from the network?
|
|
func (c *client) GetValue(ctx context.Context, key key.Key) ([]byte, error) {
|
|
log.Debugf("GetValue: %s", key)
|
|
v, err := c.datastore.Get(key.DsKey())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
data, ok := v.([]byte)
|
|
if !ok {
|
|
return nil, errors.New("could not cast value from datastore")
|
|
}
|
|
|
|
return data, nil
|
|
}
|
|
|
|
func (c *client) FindProviders(ctx context.Context, key key.Key) ([]peer.PeerInfo, error) {
|
|
return c.server.Providers(key), nil
|
|
}
|
|
|
|
func (c *client) FindPeer(ctx context.Context, pid peer.ID) (peer.PeerInfo, error) {
|
|
log.Debugf("FindPeer: %s", pid)
|
|
return peer.PeerInfo{}, nil
|
|
}
|
|
|
|
func (c *client) FindProvidersAsync(ctx context.Context, k key.Key, max int) <-chan peer.PeerInfo {
|
|
out := make(chan peer.PeerInfo)
|
|
go func() {
|
|
defer close(out)
|
|
for i, p := range c.server.Providers(k) {
|
|
if max <= i {
|
|
return
|
|
}
|
|
select {
|
|
case out <- p:
|
|
case <-ctx.Done():
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
return out
|
|
}
|
|
|
|
// Provide returns once the message is on the network. Value is not necessarily
|
|
// visible yet.
|
|
func (c *client) Provide(_ context.Context, key key.Key) error {
|
|
info := peer.PeerInfo{
|
|
ID: c.peer.ID(),
|
|
Addrs: []ma.Multiaddr{c.peer.Address()},
|
|
}
|
|
return c.server.Announce(info, key)
|
|
}
|
|
|
|
func (c *client) Ping(ctx context.Context, p peer.ID) (time.Duration, error) {
|
|
return 0, nil
|
|
}
|
|
|
|
func (c *client) Bootstrap(context.Context) error {
|
|
return nil
|
|
}
|
|
|
|
var _ routing.IpfsRouting = &client{}
|