refac(exchange) move bitswap -> exchange/bitswap

blockservice/blockservice.go

@@ -5,8 +5,8 @@ import (
 	"time"
 
 	ds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/datastore.go"
-	bitswap "github.com/jbenet/go-ipfs/bitswap"
 	blocks "github.com/jbenet/go-ipfs/blocks"
+	exchange "github.com/jbenet/go-ipfs/exchange"
 	u "github.com/jbenet/go-ipfs/util"
 
 	mh "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multihash"
@@ -16,11 +16,11 @@ import (
 // It uses an internal `datastore.Datastore` instance to store values.
 type BlockService struct {
 	Datastore ds.Datastore
-	Remote    bitswap.Exchange
+	Remote    exchange.Interface
 }
 
 // NewBlockService creates a BlockService with given datastore instance.
-func NewBlockService(d ds.Datastore, rem bitswap.Exchange) (*BlockService, error) {
+func NewBlockService(d ds.Datastore, rem exchange.Interface) (*BlockService, error) {
 	if d == nil {
 		return nil, fmt.Errorf("BlockService requires valid datastore")
 	}

core/core.go

@@ -10,10 +10,11 @@ import (
 	b58 "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-base58"
 	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
 
-	bitswap "github.com/jbenet/go-ipfs/bitswap"
 	bserv "github.com/jbenet/go-ipfs/blockservice"
 	config "github.com/jbenet/go-ipfs/config"
 	ci "github.com/jbenet/go-ipfs/crypto"
+	exchange "github.com/jbenet/go-ipfs/exchange"
+	bitswap "github.com/jbenet/go-ipfs/exchange/bitswap"
 	merkledag "github.com/jbenet/go-ipfs/merkledag"
 	inet "github.com/jbenet/go-ipfs/net"
 	mux "github.com/jbenet/go-ipfs/net/mux"
@@ -47,7 +48,7 @@ type IpfsNode struct {
 	Routing routing.IpfsRouting
 
 	// the block exchange + strategy (bitswap)
-	BitSwap bitswap.Exchange
+	Exchange exchange.Interface
 
 	// the block service, get/add blocks.
 	Blocks *bserv.BlockService
@@ -88,7 +89,7 @@ func NewIpfsNode(cfg *config.Config, online bool) (*IpfsNode, error) {
 		net inet.Network
 		// TODO: refactor so we can use IpfsRouting interface instead of being DHT-specific
 		route           *dht.IpfsDHT
-		exchangeSession bitswap.Exchange
+		exchangeSession exchange.Interface
 	)
 
 	if online {
@@ -140,7 +141,7 @@ func NewIpfsNode(cfg *config.Config, online bool) (*IpfsNode, error) {
 		Blocks:    bs,
 		DAG:       dag,
 		Resolver:  &path.Resolver{DAG: dag},
-		BitSwap:   exchangeSession,
+		Exchange:  exchangeSession,
 		Identity:  local,
 		Routing:   route,
 	}, nil

bitswap/bitswap.go → exchange/bitswap/bitswap.go

@@ -7,16 +7,27 @@ 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"
 
-	bsmsg "github.com/jbenet/go-ipfs/bitswap/message"
-	bsnet "github.com/jbenet/go-ipfs/bitswap/network"
-	notifications "github.com/jbenet/go-ipfs/bitswap/notifications"
-	strategy "github.com/jbenet/go-ipfs/bitswap/strategy"
 	blocks "github.com/jbenet/go-ipfs/blocks"
 	blockstore "github.com/jbenet/go-ipfs/blockstore"
+	exchange "github.com/jbenet/go-ipfs/exchange"
+	bsmsg "github.com/jbenet/go-ipfs/exchange/bitswap/message"
+	bsnet "github.com/jbenet/go-ipfs/exchange/bitswap/network"
+	notifications "github.com/jbenet/go-ipfs/exchange/bitswap/notifications"
+	strategy "github.com/jbenet/go-ipfs/exchange/bitswap/strategy"
 	peer "github.com/jbenet/go-ipfs/peer"
 	u "github.com/jbenet/go-ipfs/util"
 )
 
+// TODO rename -> Router?
+type Routing interface {
+	// FindProvidersAsync returns a channel of providers for the given key
+	// TODO replace with timeout with context
+	FindProvidersAsync(u.Key, int, time.Duration) <-chan *peer.Peer
+
+	// Provide provides the key to the network
+	Provide(key u.Key) error
+}
+
 // TODO(brian): ensure messages are being received
 
 // PartnerWantListMax is the bound for the number of keys we'll store per
@@ -37,25 +48,25 @@ type bitswap struct {
 	blockstore blockstore.Blockstore
 
 	// routing interface for communication
-	routing Directory
+	routing Routing
 
 	notifications notifications.PubSub
 
-	// strategist listens to network traffic and makes decisions about how to
+	// strategy listens to network traffic and makes decisions about how to
 	// interact with partners.
-	// TODO(brian): save the strategist's state to the datastore
-	strategist strategy.Strategist
+	// TODO(brian): save the strategy's state to the datastore
+	strategy strategy.Strategy
 }
 
 // NewSession initializes a bitswap session.
-func NewSession(parent context.Context, s bsnet.NetworkService, p *peer.Peer, d ds.Datastore, directory Directory) Exchange {
+func NewSession(parent context.Context, s bsnet.NetworkService, p *peer.Peer, d ds.Datastore, directory Routing) exchange.Interface {
 
 	// FIXME(brian): instantiate a concrete Strategist
 	receiver := bsnet.Forwarder{}
 	bs := &bitswap{
 		blockstore:    blockstore.NewBlockstore(d),
 		notifications: notifications.New(),
-		strategist:    strategy.New(d),
+		strategy:      strategy.New(),
 		peer:          p,
 		routing:       directory,
 		sender:        bsnet.NewNetworkAdapter(s, &receiver),
@@ -112,7 +123,7 @@ func (bs *bitswap) getBlock(k u.Key, p *peer.Peer, timeout time.Duration) (*bloc
 	// that accounting is _always_ performed when SendMessage and
 	// ReceiveMessage are called
 	bs.sender.SendMessage(ctx, p, message)
-	bs.strategist.MessageSent(p, message)
+	bs.strategy.MessageSent(p, message)
 
 	block, ok := <-blockChannel
 	if !ok {
@@ -122,9 +133,9 @@ func (bs *bitswap) getBlock(k u.Key, p *peer.Peer, timeout time.Duration) (*bloc
 }
 
 func (bs *bitswap) sendToPeersThatWant(block blocks.Block) {
-	for _, p := range bs.strategist.Peers() {
-		if bs.strategist.IsWantedByPeer(block.Key(), p) {
-			if bs.strategist.ShouldSendToPeer(block.Key(), p) {
+	for _, p := range bs.strategy.Peers() {
+		if bs.strategy.BlockIsWantedByPeer(block.Key(), p) {
+			if bs.strategy.ShouldSendBlockToPeer(block.Key(), p) {
 				go bs.send(p, block)
 			}
 		}
@@ -144,15 +155,15 @@ func (bs *bitswap) send(p *peer.Peer, b blocks.Block) {
 	message.AppendBlock(b)
 	// FIXME(brian): pass ctx
 	bs.sender.SendMessage(context.Background(), p, message)
-	bs.strategist.MessageSent(p, message)
+	bs.strategy.MessageSent(p, message)
 }
 
 // TODO(brian): handle errors
 func (bs *bitswap) ReceiveMessage(
 	ctx context.Context, sender *peer.Peer, incoming bsmsg.BitSwapMessage) (
 	*peer.Peer, bsmsg.BitSwapMessage, error) {
 
-	bs.strategist.MessageReceived(sender, incoming)
+	bs.strategy.MessageReceived(sender, incoming)
 
 	if incoming.Blocks() != nil {
 		for _, block := range incoming.Blocks() {
@@ -163,7 +174,7 @@ func (bs *bitswap) ReceiveMessage(
 
 	if incoming.Wantlist() != nil {
 		for _, key := range incoming.Wantlist() {
-			if bs.strategist.ShouldSendToPeer(key, sender) {
+			if bs.strategy.ShouldSendBlockToPeer(key, sender) {
 				block, errBlockNotFound := bs.blockstore.Get(key)
 				if errBlockNotFound != nil {
 					// TODO(brian): log/return the error

bitswap/network/forwarder.go → exchange/bitswap/network/forwarder.go

@@ -2,7 +2,7 @@ package network
 
 import (
 	context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
-	bsmsg "github.com/jbenet/go-ipfs/bitswap/message"
+	bsmsg "github.com/jbenet/go-ipfs/exchange/bitswap/message"
 	peer "github.com/jbenet/go-ipfs/peer"
 )
 

bitswap/network/forwarder_test.go → exchange/bitswap/network/forwarder_test.go

@@ -4,7 +4,7 @@ import (
 	"testing"
 
 	context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
-	bsmsg "github.com/jbenet/go-ipfs/bitswap/message"
+	bsmsg "github.com/jbenet/go-ipfs/exchange/bitswap/message"
 	peer "github.com/jbenet/go-ipfs/peer"
 )
 

bitswap/network/interface.go → exchange/bitswap/network/interface.go

@@ -4,7 +4,7 @@ import (
 	context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
 	netservice "github.com/jbenet/go-ipfs/net/service"
 
-	bsmsg "github.com/jbenet/go-ipfs/bitswap/message"
+	bsmsg "github.com/jbenet/go-ipfs/exchange/bitswap/message"
 	netmsg "github.com/jbenet/go-ipfs/net/message"
 	peer "github.com/jbenet/go-ipfs/peer"
 )

bitswap/network/network_adapter.go → exchange/bitswap/network/network_adapter.go

@@ -5,7 +5,7 @@ import (
 
 	context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
 
-	bsmsg "github.com/jbenet/go-ipfs/bitswap/message"
+	bsmsg "github.com/jbenet/go-ipfs/exchange/bitswap/message"
 	netmsg "github.com/jbenet/go-ipfs/net/message"
 	peer "github.com/jbenet/go-ipfs/peer"
 )

bitswap/offline.go → exchange/bitswap/offline.go

@@ -5,10 +5,11 @@ import (
 	"time"
 
 	blocks "github.com/jbenet/go-ipfs/blocks"
+	exchange "github.com/jbenet/go-ipfs/exchange"
 	u "github.com/jbenet/go-ipfs/util"
 )
 
-func NewOfflineExchange() Exchange {
+func NewOfflineExchange() exchange.Interface {
 	return &offlineExchange{}
 }
 

bitswap/strategy/interface.go → exchange/bitswap/strategy/interface.go

@@ -1,28 +1,24 @@
 package strategy
 
 import (
-	bsmsg "github.com/jbenet/go-ipfs/bitswap/message"
+	bsmsg "github.com/jbenet/go-ipfs/exchange/bitswap/message"
 	peer "github.com/jbenet/go-ipfs/peer"
 	u "github.com/jbenet/go-ipfs/util"
 )
 
-type Strategist interface {
-	Accountant
-
+type Strategy interface {
 	// Returns a slice of Peers that
 	Peers() []*peer.Peer
 
 	// WantList returns the WantList for the given Peer
-	IsWantedByPeer(u.Key, *peer.Peer) bool
+	BlockIsWantedByPeer(u.Key, *peer.Peer) bool
 
 	// ShouldSendTo(Peer) decides whether to send data to this Peer
-	ShouldSendToPeer(u.Key, *peer.Peer) bool
+	ShouldSendBlockToPeer(u.Key, *peer.Peer) bool
 
 	// Seed initializes the decider to a deterministic state
 	Seed(int64)
-}
 
-type Accountant interface {
 	// MessageReceived records receipt of message for accounting purposes
 	MessageReceived(*peer.Peer, bsmsg.BitSwapMessage) error
 

bitswap/strategy/ledger.go → exchange/bitswap/strategy/ledger.go

@@ -12,6 +12,14 @@ import (
 // access/lookups.
 type keySet map[u.Key]struct{}
 
+func newLedger(p *peer.Peer, strategy strategyFunc) *ledger {
+	return &ledger{
+		wantList: keySet{},
+		Strategy: strategy,
+		Partner:  p,
+	}
+}
+
 // ledger stores the data exchange relationship between two peers.
 type ledger struct {
 	lock sync.RWMutex
@@ -37,9 +45,6 @@ type ledger struct {
 	Strategy strategyFunc
 }
 
-// LedgerMap lists Ledgers by their Partner key.
-type ledgerMap map[u.Key]*ledger
-
 func (l *ledger) ShouldSend() bool {
 	l.lock.Lock()
 	defer l.lock.Unlock()