Extract: routing package to github.com/ipfs/go-ipfs-routing

This extracts the routing package to its own repository
(https://github.com/ipfs/go-ipfs-routing). History has
been preserved. The new module has been gx'ed and published.

Imports have been rewritten and re-ordered accordingly.

An internal dependency to go-ipfs/repo has been removed
by substituting it with the go-datastore.Batching interface.

License: MIT
Signed-off-by: Hector Sanjuan <hector@protocol.ai>

blockservice/test/mock.go

@@ -4,9 +4,9 @@ import (
 	. "github.com/ipfs/go-ipfs/blockservice"
 	bitswap "github.com/ipfs/go-ipfs/exchange/bitswap"
 	tn "github.com/ipfs/go-ipfs/exchange/bitswap/testnet"
-	mockrouting "github.com/ipfs/go-ipfs/routing/mock"
 
 	delay "gx/ipfs/QmRJVNatYJwTAHgdSM1Xef9QVQ1Ch3XHdmcrykjP5Y4soL/go-ipfs-delay"
+	mockrouting "gx/ipfs/QmZRcGYvxdauCd7hHnMYLYqcZRaDjv24c7eUNyJojAcdBb/go-ipfs-routing/mock"
 )
 
 // Mocks returns |n| connected mock Blockservices

core/commands/ipns.go

@@ -8,8 +8,8 @@ import (
 	cmds "github.com/ipfs/go-ipfs/commands"
 	e "github.com/ipfs/go-ipfs/core/commands/e"
 	namesys "github.com/ipfs/go-ipfs/namesys"
-	offline "github.com/ipfs/go-ipfs/routing/offline"
 
+	offline "gx/ipfs/QmZRcGYvxdauCd7hHnMYLYqcZRaDjv24c7eUNyJojAcdBb/go-ipfs-routing/offline"
 	"gx/ipfs/QmceUdzxkimdYsgtX733uNgzf1DLHyBKN6ehGSp85ayppM/go-ipfs-cmdkit"
 )
 

core/core.go

@@ -38,8 +38,6 @@ import (
 	pin "github.com/ipfs/go-ipfs/pin"
 	repo "github.com/ipfs/go-ipfs/repo"
 	config "github.com/ipfs/go-ipfs/repo/config"
-	nilrouting "github.com/ipfs/go-ipfs/routing/none"
-	offroute "github.com/ipfs/go-ipfs/routing/offline"
 	ft "github.com/ipfs/go-ipfs/unixfs"
 
 	addrutil "gx/ipfs/QmNSWW3Sb4eju4o2djPQ1L1c2Zj9XN9sMYJL8r1cbxdc6b/go-addr-util"
@@ -66,6 +64,8 @@ import (
 	smux "gx/ipfs/QmY9JXR3FupnYAYJWK9aMr9bCpqWKcToQ1tz8DVGTrHpHw/go-stream-muxer"
 	connmgr "gx/ipfs/QmZ1R2LxRZTUaeuMFEtQigzHfFCv3hLYBi5316aZ7YUeyf/go-libp2p-connmgr"
 	ipnet "gx/ipfs/QmZPrWxuM8GHr4cGKbyF5CCT11sFUP9hgqpeUHALvx2nUr/go-libp2p-interface-pnet"
+	nilrouting "gx/ipfs/QmZRcGYvxdauCd7hHnMYLYqcZRaDjv24c7eUNyJojAcdBb/go-ipfs-routing/none"
+	offroute "gx/ipfs/QmZRcGYvxdauCd7hHnMYLYqcZRaDjv24c7eUNyJojAcdBb/go-ipfs-routing/offline"
 	peer "gx/ipfs/QmZoWKhxUmZ2seW4BzX6fJkNR8hh9PsGModr7q171yq2SS/go-libp2p-peer"
 	ic "gx/ipfs/QmaPbCnUMBohSGo3KnxEa2bHqyJVVeEEcwtqJAYxerieBo/go-libp2p-crypto"
 	ifconnmgr "gx/ipfs/Qmax8X1Kfahf5WfSB68EWDG3d3qyS3Sqs1v412fjPTfRwx/go-libp2p-interface-connmgr"
@@ -947,21 +947,21 @@ func startListening(ctx context.Context, host p2phost.Host, cfg *config.Config)
 	return nil
 }
 
-func constructDHTRouting(ctx context.Context, host p2phost.Host, dstore repo.Datastore) (routing.IpfsRouting, error) {
+func constructDHTRouting(ctx context.Context, host p2phost.Host, dstore ds.Batching) (routing.IpfsRouting, error) {
 	dhtRouting := dht.NewDHT(ctx, host, dstore)
 	dhtRouting.Validator[IpnsValidatorTag] = namesys.NewIpnsRecordValidator(host.Peerstore())
 	dhtRouting.Selector[IpnsValidatorTag] = namesys.IpnsSelectorFunc
 	return dhtRouting, nil
 }
 
-func constructClientDHTRouting(ctx context.Context, host p2phost.Host, dstore repo.Datastore) (routing.IpfsRouting, error) {
+func constructClientDHTRouting(ctx context.Context, host p2phost.Host, dstore ds.Batching) (routing.IpfsRouting, error) {
 	dhtRouting := dht.NewDHTClient(ctx, host, dstore)
 	dhtRouting.Validator[IpnsValidatorTag] = namesys.NewIpnsRecordValidator(host.Peerstore())
 	dhtRouting.Selector[IpnsValidatorTag] = namesys.IpnsSelectorFunc
 	return dhtRouting, nil
 }
 
-type RoutingOption func(context.Context, p2phost.Host, repo.Datastore) (routing.IpfsRouting, error)
+type RoutingOption func(context.Context, p2phost.Host, ds.Batching) (routing.IpfsRouting, error)
 
 type DiscoveryOption func(context.Context, p2phost.Host) (discovery.Service, error)
 

core/coreapi/name.go

@@ -13,8 +13,8 @@ import (
 	keystore "github.com/ipfs/go-ipfs/keystore"
 	namesys "github.com/ipfs/go-ipfs/namesys"
 	ipath "github.com/ipfs/go-ipfs/path"
-	offline "github.com/ipfs/go-ipfs/routing/offline"
 
+	offline "gx/ipfs/QmZRcGYvxdauCd7hHnMYLYqcZRaDjv24c7eUNyJojAcdBb/go-ipfs-routing/offline"
 	peer "gx/ipfs/QmZoWKhxUmZ2seW4BzX6fJkNR8hh9PsGModr7q171yq2SS/go-libp2p-peer"
 	crypto "gx/ipfs/QmaPbCnUMBohSGo3KnxEa2bHqyJVVeEEcwtqJAYxerieBo/go-libp2p-crypto"
 )

exchange/bitswap/bitswap_test.go

@@ -12,12 +12,12 @@ import (
 	blocksutil "github.com/ipfs/go-ipfs/blocks/blocksutil"
 	decision "github.com/ipfs/go-ipfs/exchange/bitswap/decision"
 	tn "github.com/ipfs/go-ipfs/exchange/bitswap/testnet"
-	mockrouting "github.com/ipfs/go-ipfs/routing/mock"
 
 	delay "gx/ipfs/QmRJVNatYJwTAHgdSM1Xef9QVQ1Ch3XHdmcrykjP5Y4soL/go-ipfs-delay"
 	tu "gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil"
 	travis "gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil/ci/travis"
 	p2ptestutil "gx/ipfs/QmYVR3C8DWPHdHxvLtNFYfjsXgaRAdh6hPMNH3KiwCgu4o/go-libp2p-netutil"
+	mockrouting "gx/ipfs/QmZRcGYvxdauCd7hHnMYLYqcZRaDjv24c7eUNyJojAcdBb/go-ipfs-routing/mock"
 	cid "gx/ipfs/QmcZfnkapfECQGcLZaf9B79NRg7cRa9EnZh4LSbkCzwNvY/go-cid"
 	blocks "gx/ipfs/Qmej7nf81hi2x2tvjRBF3mcp74sQyuDH4VMYDGd1YtXjb2/go-block-format"
 	detectrace "gx/ipfs/Qmf7HqcW7LtCi1W8y2bdx2eJpze74jkbKqpByxgXikdbLF/go-detect-race"

exchange/bitswap/testnet/network_test.go

@@ -7,10 +7,10 @@ import (
 
 	bsmsg "github.com/ipfs/go-ipfs/exchange/bitswap/message"
 	bsnet "github.com/ipfs/go-ipfs/exchange/bitswap/network"
-	mockrouting "github.com/ipfs/go-ipfs/routing/mock"
 
 	delay "gx/ipfs/QmRJVNatYJwTAHgdSM1Xef9QVQ1Ch3XHdmcrykjP5Y4soL/go-ipfs-delay"
 	testutil "gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil"
+	mockrouting "gx/ipfs/QmZRcGYvxdauCd7hHnMYLYqcZRaDjv24c7eUNyJojAcdBb/go-ipfs-routing/mock"
 	peer "gx/ipfs/QmZoWKhxUmZ2seW4BzX6fJkNR8hh9PsGModr7q171yq2SS/go-libp2p-peer"
 	blocks "gx/ipfs/Qmej7nf81hi2x2tvjRBF3mcp74sQyuDH4VMYDGd1YtXjb2/go-block-format"
 )

exchange/bitswap/testnet/peernet.go

@@ -4,10 +4,11 @@ import (
 	"context"
 
 	bsnet "github.com/ipfs/go-ipfs/exchange/bitswap/network"
-	mockrouting "github.com/ipfs/go-ipfs/routing/mock"
+
 	mockpeernet "gx/ipfs/QmNh1kGFFdsPu79KNSaL4NUKUPb4Eiz4KHdMtFY6664RDp/go-libp2p/p2p/net/mock"
 	ds "gx/ipfs/QmPpegoMqhAEqjncrzArm7KVWAkCm78rqL2DPuNjhPrshg/go-datastore"
 	testutil "gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil"
+	mockrouting "gx/ipfs/QmZRcGYvxdauCd7hHnMYLYqcZRaDjv24c7eUNyJojAcdBb/go-ipfs-routing/mock"
 	peer "gx/ipfs/QmZoWKhxUmZ2seW4BzX6fJkNR8hh9PsGModr7q171yq2SS/go-libp2p-peer"
 )
 

exchange/bitswap/testnet/virtual.go

@@ -8,12 +8,12 @@ import (
 
 	bsmsg "github.com/ipfs/go-ipfs/exchange/bitswap/message"
 	bsnet "github.com/ipfs/go-ipfs/exchange/bitswap/network"
-	mockrouting "github.com/ipfs/go-ipfs/routing/mock"
 
 	delay "gx/ipfs/QmRJVNatYJwTAHgdSM1Xef9QVQ1Ch3XHdmcrykjP5Y4soL/go-ipfs-delay"
 	logging "gx/ipfs/QmRb5jh8z2E8hMGN2tkvs1yHynUanqnZ3UeKwgN1i9P1F8/go-log"
 	routing "gx/ipfs/QmTiWLZ6Fo5j4KcTVutZJ5KWRRJrbxzmxA4td8NfEdrPh7/go-libp2p-routing"
 	testutil "gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil"
+	mockrouting "gx/ipfs/QmZRcGYvxdauCd7hHnMYLYqcZRaDjv24c7eUNyJojAcdBb/go-ipfs-routing/mock"
 	peer "gx/ipfs/QmZoWKhxUmZ2seW4BzX6fJkNR8hh9PsGModr7q171yq2SS/go-libp2p-peer"
 	ifconnmgr "gx/ipfs/Qmax8X1Kfahf5WfSB68EWDG3d3qyS3Sqs1v412fjPTfRwx/go-libp2p-interface-connmgr"
 	cid "gx/ipfs/QmcZfnkapfECQGcLZaf9B79NRg7cRa9EnZh4LSbkCzwNvY/go-cid"

exchange/reprovide/reprovide_test.go

@@ -5,11 +5,12 @@ import (
 	"testing"
 
 	blockstore "github.com/ipfs/go-ipfs/blocks/blockstore"
-	mock "github.com/ipfs/go-ipfs/routing/mock"
+
 	ds "gx/ipfs/QmPpegoMqhAEqjncrzArm7KVWAkCm78rqL2DPuNjhPrshg/go-datastore"
 	dssync "gx/ipfs/QmPpegoMqhAEqjncrzArm7KVWAkCm78rqL2DPuNjhPrshg/go-datastore/sync"
 	testutil "gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil"
 	pstore "gx/ipfs/QmXauCuJzmzapetmC6W4TuDJLL1yFFrVzSHoWv8YdbmnxH/go-libp2p-peerstore"
+	mock "gx/ipfs/QmZRcGYvxdauCd7hHnMYLYqcZRaDjv24c7eUNyJojAcdBb/go-ipfs-routing/mock"
 	blocks "gx/ipfs/Qmej7nf81hi2x2tvjRBF3mcp74sQyuDH4VMYDGd1YtXjb2/go-block-format"
 
 	. "github.com/ipfs/go-ipfs/exchange/reprovide"

fuse/ipns/ipns_test.go

@@ -14,12 +14,12 @@ import (
 
 	core "github.com/ipfs/go-ipfs/core"
 	namesys "github.com/ipfs/go-ipfs/namesys"
-	offroute "github.com/ipfs/go-ipfs/routing/offline"
 
-	ci "gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil/ci"
-	racedet "gx/ipfs/Qmf7HqcW7LtCi1W8y2bdx2eJpze74jkbKqpByxgXikdbLF/go-detect-race"
 	u "gx/ipfs/QmNiJuT8Ja3hMVpBHXv3Q6dwmperaQ6JjLtpMQgMCD7xvx/go-ipfs-util"
+	ci "gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil/ci"
+	offroute "gx/ipfs/QmZRcGYvxdauCd7hHnMYLYqcZRaDjv24c7eUNyJojAcdBb/go-ipfs-routing/offline"
 	fstest "gx/ipfs/QmaFNtBAXX4nVMQWbUqNysXyhevUj1k4B1y5uS45LC7Vw9/fuse/fs/fstestutil"
+	racedet "gx/ipfs/Qmf7HqcW7LtCi1W8y2bdx2eJpze74jkbKqpByxgXikdbLF/go-detect-race"
 )
 
 func maybeSkipFuseTests(t *testing.T) {

fuse/node/mount_test.go

@@ -15,8 +15,9 @@ import (
 	ipns "github.com/ipfs/go-ipfs/fuse/ipns"
 	mount "github.com/ipfs/go-ipfs/fuse/mount"
 	namesys "github.com/ipfs/go-ipfs/namesys"
-	offroute "github.com/ipfs/go-ipfs/routing/offline"
+
 	ci "gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil/ci"
+	offroute "gx/ipfs/QmZRcGYvxdauCd7hHnMYLYqcZRaDjv24c7eUNyJojAcdBb/go-ipfs-routing/offline"
 )
 
 func maybeSkipFuseTests(t *testing.T) {

namesys/ipns_validate_test.go

@@ -7,7 +7,6 @@ import (
 	"time"
 
 	path "github.com/ipfs/go-ipfs/path"
-	mockrouting "github.com/ipfs/go-ipfs/routing/mock"
 
 	u "gx/ipfs/QmNiJuT8Ja3hMVpBHXv3Q6dwmperaQ6JjLtpMQgMCD7xvx/go-ipfs-util"
 	ds "gx/ipfs/QmPpegoMqhAEqjncrzArm7KVWAkCm78rqL2DPuNjhPrshg/go-datastore"
@@ -18,6 +17,7 @@ import (
 	testutil "gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil"
 	pstore "gx/ipfs/QmXauCuJzmzapetmC6W4TuDJLL1yFFrVzSHoWv8YdbmnxH/go-libp2p-peerstore"
 	proto "gx/ipfs/QmZ4Qi3GaRbjcx28Sme5eMH7RQjGkt8wHxt2a65oLaeFEV/gogo-protobuf/proto"
+	mockrouting "gx/ipfs/QmZRcGYvxdauCd7hHnMYLYqcZRaDjv24c7eUNyJojAcdBb/go-ipfs-routing/mock"
 	peer "gx/ipfs/QmZoWKhxUmZ2seW4BzX6fJkNR8hh9PsGModr7q171yq2SS/go-libp2p-peer"
 	ci "gx/ipfs/QmaPbCnUMBohSGo3KnxEa2bHqyJVVeEEcwtqJAYxerieBo/go-libp2p-crypto"
 )

namesys/namesys_test.go

@@ -7,11 +7,11 @@ import (
 	context "context"
 
 	path "github.com/ipfs/go-ipfs/path"
-	offroute "github.com/ipfs/go-ipfs/routing/offline"
 	"github.com/ipfs/go-ipfs/unixfs"
 
 	ds "gx/ipfs/QmPpegoMqhAEqjncrzArm7KVWAkCm78rqL2DPuNjhPrshg/go-datastore"
 	dssync "gx/ipfs/QmPpegoMqhAEqjncrzArm7KVWAkCm78rqL2DPuNjhPrshg/go-datastore/sync"
+	offroute "gx/ipfs/QmZRcGYvxdauCd7hHnMYLYqcZRaDjv24c7eUNyJojAcdBb/go-ipfs-routing/offline"
 	ci "gx/ipfs/QmaPbCnUMBohSGo3KnxEa2bHqyJVVeEEcwtqJAYxerieBo/go-libp2p-crypto"
 )
 

namesys/publisher_test.go

@@ -7,12 +7,12 @@ import (
 	"time"
 
 	path "github.com/ipfs/go-ipfs/path"
-	mockrouting "github.com/ipfs/go-ipfs/routing/mock"
 
 	ds "gx/ipfs/QmPpegoMqhAEqjncrzArm7KVWAkCm78rqL2DPuNjhPrshg/go-datastore"
 	dssync "gx/ipfs/QmPpegoMqhAEqjncrzArm7KVWAkCm78rqL2DPuNjhPrshg/go-datastore/sync"
 	testutil "gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil"
 	ma "gx/ipfs/QmWWQ2Txc2c6tqjsBpzg5Ar652cHPGNsQQp2SejkNmkUMb/go-multiaddr"
+	mockrouting "gx/ipfs/QmZRcGYvxdauCd7hHnMYLYqcZRaDjv24c7eUNyJojAcdBb/go-ipfs-routing/mock"
 	peer "gx/ipfs/QmZoWKhxUmZ2seW4BzX6fJkNR8hh9PsGModr7q171yq2SS/go-libp2p-peer"
 	ci "gx/ipfs/QmaPbCnUMBohSGo3KnxEa2bHqyJVVeEEcwtqJAYxerieBo/go-libp2p-crypto"
 	dshelp "gx/ipfs/QmdQTPWduSeyveSxeCAte33M592isSW5Z979g81aJphrgn/go-ipfs-ds-help"

namesys/pubsub_test.go

@@ -7,7 +7,6 @@ import (
 	"time"
 
 	path "github.com/ipfs/go-ipfs/path"
-	mockrouting "github.com/ipfs/go-ipfs/routing/mock"
 
 	p2phost "gx/ipfs/QmNmJZL7FQySMtE2BQuLMuZg2EB2CLEunJJUSVSc9YnnbV/go-libp2p-host"
 	ds "gx/ipfs/QmPpegoMqhAEqjncrzArm7KVWAkCm78rqL2DPuNjhPrshg/go-datastore"
@@ -17,6 +16,7 @@ import (
 	testutil "gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil"
 	pstore "gx/ipfs/QmXauCuJzmzapetmC6W4TuDJLL1yFFrVzSHoWv8YdbmnxH/go-libp2p-peerstore"
 	netutil "gx/ipfs/QmYVR3C8DWPHdHxvLtNFYfjsXgaRAdh6hPMNH3KiwCgu4o/go-libp2p-netutil"
+	mockrouting "gx/ipfs/QmZRcGYvxdauCd7hHnMYLYqcZRaDjv24c7eUNyJojAcdBb/go-ipfs-routing/mock"
 	peer "gx/ipfs/QmZoWKhxUmZ2seW4BzX6fJkNR8hh9PsGModr7q171yq2SS/go-libp2p-peer"
 	ci "gx/ipfs/QmaPbCnUMBohSGo3KnxEa2bHqyJVVeEEcwtqJAYxerieBo/go-libp2p-crypto"
 )

namesys/resolve_test.go

@@ -7,11 +7,11 @@ import (
 	"time"
 
 	path "github.com/ipfs/go-ipfs/path"
-	mockrouting "github.com/ipfs/go-ipfs/routing/mock"
-	testutil "gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil"
 
 	ds "gx/ipfs/QmPpegoMqhAEqjncrzArm7KVWAkCm78rqL2DPuNjhPrshg/go-datastore"
 	dssync "gx/ipfs/QmPpegoMqhAEqjncrzArm7KVWAkCm78rqL2DPuNjhPrshg/go-datastore/sync"
+	testutil "gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil"
+	mockrouting "gx/ipfs/QmZRcGYvxdauCd7hHnMYLYqcZRaDjv24c7eUNyJojAcdBb/go-ipfs-routing/mock"
 	peer "gx/ipfs/QmZoWKhxUmZ2seW4BzX6fJkNR8hh9PsGModr7q171yq2SS/go-libp2p-peer"
 )
 

package.json

@@ -551,6 +551,12 @@
       "hash": "QmdQTPWduSeyveSxeCAte33M592isSW5Z979g81aJphrgn",
       "name": "go-ipfs-ds-help",
       "version": "0.0.1"
+    },
+    {
+      "author": "hsanjuan",
+      "hash": "QmZRcGYvxdauCd7hHnMYLYqcZRaDjv24c7eUNyJojAcdBb",
+      "name": "go-ipfs-routing",
+      "version": "0.0.1"
     }
   ],
   "gxVersion": "0.10.0",

routing/mock/centralized_client.go

@@ -1,125 +0,0 @@
-package mockrouting
-
-import (
-	"context"
-	"errors"
-	"time"
-
-	u "gx/ipfs/QmNiJuT8Ja3hMVpBHXv3Q6dwmperaQ6JjLtpMQgMCD7xvx/go-ipfs-util"
-	ds "gx/ipfs/QmPpegoMqhAEqjncrzArm7KVWAkCm78rqL2DPuNjhPrshg/go-datastore"
-	logging "gx/ipfs/QmRb5jh8z2E8hMGN2tkvs1yHynUanqnZ3UeKwgN1i9P1F8/go-log"
-	routing "gx/ipfs/QmTiWLZ6Fo5j4KcTVutZJ5KWRRJrbxzmxA4td8NfEdrPh7/go-libp2p-routing"
-	dhtpb "gx/ipfs/QmUpttFinNDmNPgFwKN8sZK6BUtBmA68Y4KdSBDXa8t9sJ/go-libp2p-record/pb"
-	"gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil"
-	ma "gx/ipfs/QmWWQ2Txc2c6tqjsBpzg5Ar652cHPGNsQQp2SejkNmkUMb/go-multiaddr"
-	pstore "gx/ipfs/QmXauCuJzmzapetmC6W4TuDJLL1yFFrVzSHoWv8YdbmnxH/go-libp2p-peerstore"
-	proto "gx/ipfs/QmZ4Qi3GaRbjcx28Sme5eMH7RQjGkt8wHxt2a65oLaeFEV/gogo-protobuf/proto"
-	peer "gx/ipfs/QmZoWKhxUmZ2seW4BzX6fJkNR8hh9PsGModr7q171yq2SS/go-libp2p-peer"
-	cid "gx/ipfs/QmcZfnkapfECQGcLZaf9B79NRg7cRa9EnZh4LSbkCzwNvY/go-cid"
-	dshelp "gx/ipfs/QmdQTPWduSeyveSxeCAte33M592isSW5Z979g81aJphrgn/go-ipfs-ds-help"
-)
-
-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 string, val []byte) error {
-	log.Debugf("PutValue: %s", key)
-	rec := new(dhtpb.Record)
-	rec.Value = val
-	rec.Key = proto.String(string(key))
-	rec.TimeReceived = proto.String(u.FormatRFC3339(time.Now()))
-	data, err := proto.Marshal(rec)
-	if err != nil {
-		return err
-	}
-
-	return c.datastore.Put(dshelp.NewKeyFromBinary([]byte(key)), data)
-}
-
-// FIXME(brian): is this method meant to simulate getting a value from the network?
-func (c *client) GetValue(ctx context.Context, key string) ([]byte, error) {
-	log.Debugf("GetValue: %s", key)
-	v, err := c.datastore.Get(dshelp.NewKeyFromBinary([]byte(key)))
-	if err != nil {
-		return nil, err
-	}
-
-	data, ok := v.([]byte)
-	if !ok {
-		return nil, errors.New("could not cast value from datastore")
-	}
-
-	rec := new(dhtpb.Record)
-	err = proto.Unmarshal(data, rec)
-	if err != nil {
-		return nil, err
-	}
-
-	return rec.GetValue(), nil
-}
-
-func (c *client) GetValues(ctx context.Context, key string, count int) ([]routing.RecvdVal, error) {
-	log.Debugf("GetValues: %s", key)
-	data, err := c.GetValue(ctx, key)
-	if err != nil {
-		return nil, err
-	}
-
-	return []routing.RecvdVal{{Val: data, From: c.peer.ID()}}, nil
-}
-
-func (c *client) FindProviders(ctx context.Context, key *cid.Cid) ([]pstore.PeerInfo, error) {
-	return c.server.Providers(key), nil
-}
-
-func (c *client) FindPeer(ctx context.Context, pid peer.ID) (pstore.PeerInfo, error) {
-	log.Debugf("FindPeer: %s", pid)
-	return pstore.PeerInfo{}, nil
-}
-
-func (c *client) FindProvidersAsync(ctx context.Context, k *cid.Cid, max int) <-chan pstore.PeerInfo {
-	out := make(chan pstore.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 *cid.Cid, brd bool) error {
-	if !brd {
-		return nil
-	}
-	info := pstore.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{}

routing/mock/centralized_server.go

@@ -1,92 +0,0 @@
-package mockrouting
-
-import (
-	"context"
-	"math/rand"
-	"sync"
-	"time"
-
-	"gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil"
-
-	ds "gx/ipfs/QmPpegoMqhAEqjncrzArm7KVWAkCm78rqL2DPuNjhPrshg/go-datastore"
-	dssync "gx/ipfs/QmPpegoMqhAEqjncrzArm7KVWAkCm78rqL2DPuNjhPrshg/go-datastore/sync"
-	pstore "gx/ipfs/QmXauCuJzmzapetmC6W4TuDJLL1yFFrVzSHoWv8YdbmnxH/go-libp2p-peerstore"
-	peer "gx/ipfs/QmZoWKhxUmZ2seW4BzX6fJkNR8hh9PsGModr7q171yq2SS/go-libp2p-peer"
-	cid "gx/ipfs/QmcZfnkapfECQGcLZaf9B79NRg7cRa9EnZh4LSbkCzwNvY/go-cid"
-)
-
-// server is the mockrouting.Client's private interface to the routing server
-type server interface {
-	Announce(pstore.PeerInfo, *cid.Cid) error
-	Providers(*cid.Cid) []pstore.PeerInfo
-
-	Server
-}
-
-// s is an implementation of the private server interface
-type s struct {
-	delayConf DelayConfig
-
-	lock      sync.RWMutex
-	providers map[string]map[peer.ID]providerRecord
-}
-
-type providerRecord struct {
-	Peer    pstore.PeerInfo
-	Created time.Time
-}
-
-func (rs *s) Announce(p pstore.PeerInfo, c *cid.Cid) error {
-	rs.lock.Lock()
-	defer rs.lock.Unlock()
-
-	k := c.KeyString()
-
-	_, ok := rs.providers[k]
-	if !ok {
-		rs.providers[k] = make(map[peer.ID]providerRecord)
-	}
-	rs.providers[k][p.ID] = providerRecord{
-		Created: time.Now(),
-		Peer:    p,
-	}
-	return nil
-}
-
-func (rs *s) Providers(c *cid.Cid) []pstore.PeerInfo {
-	rs.delayConf.Query.Wait() // before locking
-
-	rs.lock.RLock()
-	defer rs.lock.RUnlock()
-	k := c.KeyString()
-
-	var ret []pstore.PeerInfo
-	records, ok := rs.providers[k]
-	if !ok {
-		return ret
-	}
-	for _, r := range records {
-		if time.Since(r.Created) > rs.delayConf.ValueVisibility.Get() {
-			ret = append(ret, r.Peer)
-		}
-	}
-
-	for i := range ret {
-		j := rand.Intn(i + 1)
-		ret[i], ret[j] = ret[j], ret[i]
-	}
-
-	return ret
-}
-
-func (rs *s) Client(p testutil.Identity) Client {
-	return rs.ClientWithDatastore(context.Background(), p, dssync.MutexWrap(ds.NewMapDatastore()))
-}
-
-func (rs *s) ClientWithDatastore(_ context.Context, p testutil.Identity, datastore ds.Datastore) Client {
-	return &client{
-		peer:      p,
-		datastore: datastore,
-		server:    rs,
-	}
-}

routing/mock/centralized_test.go

@@ -1,176 +0,0 @@
-package mockrouting
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	u "gx/ipfs/QmNiJuT8Ja3hMVpBHXv3Q6dwmperaQ6JjLtpMQgMCD7xvx/go-ipfs-util"
-	delay "gx/ipfs/QmRJVNatYJwTAHgdSM1Xef9QVQ1Ch3XHdmcrykjP5Y4soL/go-ipfs-delay"
-	testutil "gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil"
-	pstore "gx/ipfs/QmXauCuJzmzapetmC6W4TuDJLL1yFFrVzSHoWv8YdbmnxH/go-libp2p-peerstore"
-	cid "gx/ipfs/QmcZfnkapfECQGcLZaf9B79NRg7cRa9EnZh4LSbkCzwNvY/go-cid"
-)
-
-func TestKeyNotFound(t *testing.T) {
-
-	var pi = testutil.RandIdentityOrFatal(t)
-	var key = cid.NewCidV0(u.Hash([]byte("mock key")))
-	var ctx = context.Background()
-
-	rs := NewServer()
-	providers := rs.Client(pi).FindProvidersAsync(ctx, key, 10)
-	_, ok := <-providers
-	if ok {
-		t.Fatal("should be closed")
-	}
-}
-
-func TestClientFindProviders(t *testing.T) {
-	pi := testutil.RandIdentityOrFatal(t)
-	rs := NewServer()
-	client := rs.Client(pi)
-
-	k := cid.NewCidV0(u.Hash([]byte("hello")))
-	err := client.Provide(context.Background(), k, true)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// This is bad... but simulating networks is hard
-	time.Sleep(time.Millisecond * 300)
-	max := 100
-
-	providersFromClient := client.FindProvidersAsync(context.Background(), k, max)
-	isInClient := false
-	for pi := range providersFromClient {
-		if pi.ID == pi.ID { // <-- typo?
-			isInClient = true
-		}
-	}
-	if !isInClient {
-		t.Fatal("Despite client providing key, client didn't receive peer when finding providers")
-	}
-}
-
-func TestClientOverMax(t *testing.T) {
-	rs := NewServer()
-	k := cid.NewCidV0(u.Hash([]byte("hello")))
-	numProvidersForHelloKey := 100
-	for i := 0; i < numProvidersForHelloKey; i++ {
-		pi := testutil.RandIdentityOrFatal(t)
-		err := rs.Client(pi).Provide(context.Background(), k, true)
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	max := 10
-	pi := testutil.RandIdentityOrFatal(t)
-	client := rs.Client(pi)
-
-	providersFromClient := client.FindProvidersAsync(context.Background(), k, max)
-	i := 0
-	for range providersFromClient {
-		i++
-	}
-	if i != max {
-		t.Fatal("Too many providers returned")
-	}
-}
-
-// TODO does dht ensure won't receive self as a provider? probably not.
-func TestCanceledContext(t *testing.T) {
-	rs := NewServer()
-	k := cid.NewCidV0(u.Hash([]byte("hello")))
-
-	// avoid leaking goroutine, without using the context to signal
-	// (we want the goroutine to keep trying to publish on a
-	// cancelled context until we've tested it doesnt do anything.)
-	done := make(chan struct{})
-	defer func() { done <- struct{}{} }()
-
-	t.Log("async'ly announce infinite stream of providers for key")
-	i := 0
-	go func() { // infinite stream
-		for {
-			select {
-			case <-done:
-				t.Log("exiting async worker")
-				return
-			default:
-			}
-
-			pi, err := testutil.RandIdentity()
-			if err != nil {
-				t.Error(err)
-			}
-			err = rs.Client(pi).Provide(context.Background(), k, true)
-			if err != nil {
-				t.Error(err)
-			}
-			i++
-		}
-	}()
-
-	local := testutil.RandIdentityOrFatal(t)
-	client := rs.Client(local)
-
-	t.Log("warning: max is finite so this test is non-deterministic")
-	t.Log("context cancellation could simply take lower priority")
-	t.Log("and result in receiving the max number of results")
-	max := 1000
-
-	t.Log("cancel the context before consuming")
-	ctx, cancelFunc := context.WithCancel(context.Background())
-	cancelFunc()
-	providers := client.FindProvidersAsync(ctx, k, max)
-
-	numProvidersReturned := 0
-	for range providers {
-		numProvidersReturned++
-	}
-	t.Log(numProvidersReturned)
-
-	if numProvidersReturned == max {
-		t.Fatal("Context cancel had no effect")
-	}
-}
-
-func TestValidAfter(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	pi := testutil.RandIdentityOrFatal(t)
-	key := cid.NewCidV0(u.Hash([]byte("mock key")))
-	conf := DelayConfig{
-		ValueVisibility: delay.Fixed(1 * time.Hour),
-		Query:           delay.Fixed(0),
-	}
-
-	rs := NewServerWithDelay(conf)
-
-	rs.Client(pi).Provide(ctx, key, true)
-
-	var providers []pstore.PeerInfo
-	max := 100
-	providersChan := rs.Client(pi).FindProvidersAsync(ctx, key, max)
-	for p := range providersChan {
-		providers = append(providers, p)
-	}
-	if len(providers) > 0 {
-		t.Fail()
-	}
-
-	conf.ValueVisibility.Set(0)
-	time.Sleep(100 * time.Millisecond)
-
-	providersChan = rs.Client(pi).FindProvidersAsync(ctx, key, max)
-	t.Log("providers", providers)
-	for p := range providersChan {
-		providers = append(providers, p)
-	}
-	if len(providers) != 1 {
-		t.Fail()
-	}
-}

routing/mock/interface.go

@@ -1,53 +0,0 @@
-// Package mockrouting provides a virtual routing server. To use it,
-// create a virtual routing server and use the Client() method to get a
-// routing client (IpfsRouting). The server quacks like a DHT but is
-// really a local in-memory hash table.
-package mockrouting
-
-import (
-	"context"
-
-	ds "gx/ipfs/QmPpegoMqhAEqjncrzArm7KVWAkCm78rqL2DPuNjhPrshg/go-datastore"
-	delay "gx/ipfs/QmRJVNatYJwTAHgdSM1Xef9QVQ1Ch3XHdmcrykjP5Y4soL/go-ipfs-delay"
-	routing "gx/ipfs/QmTiWLZ6Fo5j4KcTVutZJ5KWRRJrbxzmxA4td8NfEdrPh7/go-libp2p-routing"
-	"gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil"
-	peer "gx/ipfs/QmZoWKhxUmZ2seW4BzX6fJkNR8hh9PsGModr7q171yq2SS/go-libp2p-peer"
-)
-
-// Server provides mockrouting Clients
-type Server interface {
-	Client(p testutil.Identity) Client
-	ClientWithDatastore(context.Context, testutil.Identity, ds.Datastore) Client
-}
-
-// Client implements IpfsRouting
-type Client interface {
-	routing.IpfsRouting
-}
-
-// NewServer returns a mockrouting Server
-func NewServer() Server {
-	return NewServerWithDelay(DelayConfig{
-		ValueVisibility: delay.Fixed(0),
-		Query:           delay.Fixed(0),
-	})
-}
-
-// NewServerWithDelay returns a mockrouting Server with a delay!
-func NewServerWithDelay(conf DelayConfig) Server {
-	return &s{
-		providers: make(map[string]map[peer.ID]providerRecord),
-		delayConf: conf,
-	}
-}
-
-// DelayConfig can be used to configured the fake delays of a mock server.
-// Use with NewServerWithDelay().
-type DelayConfig struct {
-	// ValueVisibility is the time it takes for a value to be visible in the network
-	// FIXME there _must_ be a better term for this
-	ValueVisibility delay.D
-
-	// Query is the time it takes to receive a response from a routing query
-	Query delay.D
-}

routing/none/none_client.go

@@ -1,56 +0,0 @@
-// Package nilrouting implements a routing client that does nothing.
-package nilrouting
-
-import (
-	"context"
-	"errors"
-
-	repo "github.com/ipfs/go-ipfs/repo"
-
-	p2phost "gx/ipfs/QmNmJZL7FQySMtE2BQuLMuZg2EB2CLEunJJUSVSc9YnnbV/go-libp2p-host"
-	routing "gx/ipfs/QmTiWLZ6Fo5j4KcTVutZJ5KWRRJrbxzmxA4td8NfEdrPh7/go-libp2p-routing"
-	pstore "gx/ipfs/QmXauCuJzmzapetmC6W4TuDJLL1yFFrVzSHoWv8YdbmnxH/go-libp2p-peerstore"
-	peer "gx/ipfs/QmZoWKhxUmZ2seW4BzX6fJkNR8hh9PsGModr7q171yq2SS/go-libp2p-peer"
-	cid "gx/ipfs/QmcZfnkapfECQGcLZaf9B79NRg7cRa9EnZh4LSbkCzwNvY/go-cid"
-)
-
-type nilclient struct {
-}
-
-func (c *nilclient) PutValue(_ context.Context, _ string, _ []byte) error {
-	return nil
-}
-
-func (c *nilclient) GetValue(_ context.Context, _ string) ([]byte, error) {
-	return nil, errors.New("tried GetValue from nil routing")
-}
-
-func (c *nilclient) GetValues(_ context.Context, _ string, _ int) ([]routing.RecvdVal, error) {
-	return nil, errors.New("tried GetValues from nil routing")
-}
-
-func (c *nilclient) FindPeer(_ context.Context, _ peer.ID) (pstore.PeerInfo, error) {
-	return pstore.PeerInfo{}, nil
-}
-
-func (c *nilclient) FindProvidersAsync(_ context.Context, _ *cid.Cid, _ int) <-chan pstore.PeerInfo {
-	out := make(chan pstore.PeerInfo)
-	defer close(out)
-	return out
-}
-
-func (c *nilclient) Provide(_ context.Context, _ *cid.Cid, _ bool) error {
-	return nil
-}
-
-func (c *nilclient) Bootstrap(_ context.Context) error {
-	return nil
-}
-
-// ConstructNilRouting creates an IpfsRouting client which does nothing.
-func ConstructNilRouting(_ context.Context, _ p2phost.Host, _ repo.Datastore) (routing.IpfsRouting, error) {
-	return &nilclient{}, nil
-}
-
-//  ensure nilclient satisfies interface
-var _ routing.IpfsRouting = &nilclient{}

routing/offline/offline.go

@@ -1,120 +0,0 @@
-// Package offline implements IpfsRouting with a client which
-// is only able to perform offline operations.
-package offline
-
-import (
-	"context"
-	"errors"
-	"time"
-
-	ds "gx/ipfs/QmPpegoMqhAEqjncrzArm7KVWAkCm78rqL2DPuNjhPrshg/go-datastore"
-	routing "gx/ipfs/QmTiWLZ6Fo5j4KcTVutZJ5KWRRJrbxzmxA4td8NfEdrPh7/go-libp2p-routing"
-	record "gx/ipfs/QmUpttFinNDmNPgFwKN8sZK6BUtBmA68Y4KdSBDXa8t9sJ/go-libp2p-record"
-	pb "gx/ipfs/QmUpttFinNDmNPgFwKN8sZK6BUtBmA68Y4KdSBDXa8t9sJ/go-libp2p-record/pb"
-	pstore "gx/ipfs/QmXauCuJzmzapetmC6W4TuDJLL1yFFrVzSHoWv8YdbmnxH/go-libp2p-peerstore"
-	proto "gx/ipfs/QmZ4Qi3GaRbjcx28Sme5eMH7RQjGkt8wHxt2a65oLaeFEV/gogo-protobuf/proto"
-	"gx/ipfs/QmZoWKhxUmZ2seW4BzX6fJkNR8hh9PsGModr7q171yq2SS/go-libp2p-peer"
-	ci "gx/ipfs/QmaPbCnUMBohSGo3KnxEa2bHqyJVVeEEcwtqJAYxerieBo/go-libp2p-crypto"
-	cid "gx/ipfs/QmcZfnkapfECQGcLZaf9B79NRg7cRa9EnZh4LSbkCzwNvY/go-cid"
-	dshelp "gx/ipfs/QmdQTPWduSeyveSxeCAte33M592isSW5Z979g81aJphrgn/go-ipfs-ds-help"
-)
-
-// ErrOffline is returned when trying to perform operations that
-// require connectivity.
-var ErrOffline = errors.New("routing system in offline mode")
-
-// NewOfflineRouter returns an IpfsRouting implementation which only performs
-// offline operations. It allows to Put and Get signed dht
-// records to and from the local datastore.
-func NewOfflineRouter(dstore ds.Datastore, privkey ci.PrivKey) routing.IpfsRouting {
-	return &offlineRouting{
-		datastore: dstore,
-		sk:        privkey,
-	}
-}
-
-// offlineRouting implements the IpfsRouting interface,
-// but only provides the capability to Put and Get signed dht
-// records to and from the local datastore.
-type offlineRouting struct {
-	datastore ds.Datastore
-	sk        ci.PrivKey
-}
-
-func (c *offlineRouting) PutValue(ctx context.Context, key string, val []byte) error {
-	rec, err := record.MakePutRecord(c.sk, key, val, false)
-	if err != nil {
-		return err
-	}
-	data, err := proto.Marshal(rec)
-	if err != nil {
-		return err
-	}
-
-	return c.datastore.Put(dshelp.NewKeyFromBinary([]byte(key)), data)
-}
-
-func (c *offlineRouting) GetValue(ctx context.Context, key string) ([]byte, error) {
-	v, err := c.datastore.Get(dshelp.NewKeyFromBinary([]byte(key)))
-	if err != nil {
-		return nil, err
-	}
-
-	byt, ok := v.([]byte)
-	if !ok {
-		return nil, errors.New("value stored in datastore not []byte")
-	}
-	rec := new(pb.Record)
-	err = proto.Unmarshal(byt, rec)
-	if err != nil {
-		return nil, err
-	}
-
-	return rec.GetValue(), nil
-}
-
-func (c *offlineRouting) GetValues(ctx context.Context, key string, _ int) ([]routing.RecvdVal, error) {
-	v, err := c.datastore.Get(dshelp.NewKeyFromBinary([]byte(key)))
-	if err != nil {
-		return nil, err
-	}
-
-	byt, ok := v.([]byte)
-	if !ok {
-		return nil, errors.New("value stored in datastore not []byte")
-	}
-	rec := new(pb.Record)
-	err = proto.Unmarshal(byt, rec)
-	if err != nil {
-		return nil, err
-	}
-
-	return []routing.RecvdVal{
-		{Val: rec.GetValue()},
-	}, nil
-}
-
-func (c *offlineRouting) FindPeer(ctx context.Context, pid peer.ID) (pstore.PeerInfo, error) {
-	return pstore.PeerInfo{}, ErrOffline
-}
-
-func (c *offlineRouting) FindProvidersAsync(ctx context.Context, k *cid.Cid, max int) <-chan pstore.PeerInfo {
-	out := make(chan pstore.PeerInfo)
-	close(out)
-	return out
-}
-
-func (c *offlineRouting) Provide(_ context.Context, k *cid.Cid, _ bool) error {
-	return ErrOffline
-}
-
-func (c *offlineRouting) Ping(ctx context.Context, p peer.ID) (time.Duration, error) {
-	return 0, ErrOffline
-}
-
-func (c *offlineRouting) Bootstrap(context.Context) error {
-	return nil
-}
-
-// ensure offlineRouting matches the IpfsRouting interface
-var _ routing.IpfsRouting = &offlineRouting{}

routing/offline/offline_test.go

@@ -1,82 +0,0 @@
-package offline
-
-import (
-	"bytes"
-	"context"
-	"testing"
-
-	ds "gx/ipfs/QmPpegoMqhAEqjncrzArm7KVWAkCm78rqL2DPuNjhPrshg/go-datastore"
-	"gx/ipfs/QmVvkK7s5imCiq3JVbL3pGfnhcCnf3LrFJPF4GE2sAoGZf/go-testutil"
-)
-
-func TestOfflineRouterStorage(t *testing.T) {
-	ctx := context.Background()
-
-	nds := ds.NewMapDatastore()
-	privkey, _, _ := testutil.RandTestKeyPair(128)
-	offline := NewOfflineRouter(nds, privkey)
-
-	if err := offline.PutValue(ctx, "key", []byte("testing 1 2 3")); err != nil {
-		t.Fatal(err)
-	}
-
-	val, err := offline.GetValue(ctx, "key")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !bytes.Equal([]byte("testing 1 2 3"), val) {
-		t.Fatal("OfflineRouter does not properly store")
-	}
-
-	_, err = offline.GetValue(ctx, "notHere")
-	if err == nil {
-		t.Fatal("Router should throw errors for unfound records")
-	}
-
-	recVal, err := offline.GetValues(ctx, "key", 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = offline.GetValues(ctx, "notHere", 0)
-	if err == nil {
-		t.Fatal("Router should throw errors for unfound records")
-	}
-
-	local := recVal[0].Val
-	if !bytes.Equal([]byte("testing 1 2 3"), local) {
-		t.Fatal("OfflineRouter does not properly store")
-	}
-}
-
-func TestOfflineRouterLocal(t *testing.T) {
-	ctx := context.Background()
-
-	nds := ds.NewMapDatastore()
-	privkey, _, _ := testutil.RandTestKeyPair(128)
-	offline := NewOfflineRouter(nds, privkey)
-
-	id, _ := testutil.RandPeerID()
-	_, err := offline.FindPeer(ctx, id)
-	if err != ErrOffline {
-		t.Fatal("OfflineRouting should alert that its offline")
-	}
-
-	cid, _ := testutil.RandCidV0()
-	pChan := offline.FindProvidersAsync(ctx, cid, 1)
-	p, ok := <-pChan
-	if ok {
-		t.Fatalf("FindProvidersAsync did not return a closed channel. Instead we got %+v !", p)
-	}
-
-	cid, _ = testutil.RandCidV0()
-	err = offline.Provide(ctx, cid, true)
-	if err != ErrOffline {
-		t.Fatal("OfflineRouting should alert that its offline")
-	}
-
-	err = offline.Bootstrap(ctx)
-	if err != nil {
-		t.Fatal("You shouldn't be able to bootstrap offline routing.")
-	}
-}