feat(retrievalmarket): extract skeleton interfaces

Define all types to spec, modify interfaces, wrap old code

fix(builder): use client blockstore for retrieval

feat(retrieval): add node implementations

add node adapters for client & provider so that retrieval can be extracted

node/impl/client/client.go

@@ -1,6 +1,7 @@
 package client
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"io"
@@ -17,6 +18,7 @@ import (
 	files "github.com/ipfs/go-ipfs-files"
 	ipld "github.com/ipfs/go-ipld-format"
 	"github.com/ipfs/go-merkledag"
+	unixfile "github.com/ipfs/go-unixfs/file"
 	"github.com/ipfs/go-unixfs/importer/balanced"
 	ihelper "github.com/ipfs/go-unixfs/importer/helpers"
 	"github.com/libp2p/go-libp2p-core/peer"
@@ -31,8 +33,7 @@ import (
 	"github.com/filecoin-project/lotus/node/impl/full"
 	"github.com/filecoin-project/lotus/node/impl/paych"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
-	"github.com/filecoin-project/lotus/retrieval"
-	"github.com/filecoin-project/lotus/retrieval/discovery"
+	retrievalmarket "github.com/filecoin-project/lotus/retrieval"
 )
 
 type API struct {
@@ -44,8 +45,8 @@ type API struct {
 	paych.PaychAPI
 
 	DealClient   *deals.Client
-	RetDiscovery discovery.PeerResolver
-	Retrieval    *retrieval.Client
+	RetDiscovery retrievalmarket.PeerResolver
+	Retrieval    retrievalmarket.RetrievalClient
 	Chain        *store.ChainStore
 
 	LocalDAG   dtypes.ClientDAG
@@ -153,7 +154,18 @@ func (a *API) ClientFindData(ctx context.Context, root cid.Cid) ([]api.QueryOffe
 
 	out := make([]api.QueryOffer, len(peers))
 	for k, p := range peers {
-		out[k] = a.Retrieval.Query(ctx, p, root)
+		queryResponse, err := a.Retrieval.Query(ctx, p, root.Bytes(), retrievalmarket.QueryParams{})
+		if err != nil {
+			out[k] = api.QueryOffer{Err: err.Error(), Miner: p.Address, MinerPeerID: p.ID}
+		} else {
+			out[k] = api.QueryOffer{
+				Root:        root,
+				Size:        queryResponse.Size,
+				MinPrice:    queryResponse.PieceRetrievalPrice(),
+				Miner:       p.Address, // TODO: check
+				MinerPeerID: p.ID,
+			}
+		}
 	}
 
 	return out, nil
@@ -263,18 +275,43 @@ func (a *API) ClientRetrieve(ctx context.Context, order api.RetrievalOrder, path
 		order.MinerPeerID = pid
 	}
 
-	outFile, err := os.OpenFile(path, os.O_TRUNC|os.O_CREATE|os.O_WRONLY, 0777)
-	if err != nil {
-		return err
+	retrievalResult := make(chan error, 1)
+
+	unsubscribe := a.Retrieval.SubscribeToEvents(func(event retrievalmarket.ClientEvent, state retrievalmarket.ClientDealState) {
+		if bytes.Equal(state.PieceCID, order.Root.Bytes()) {
+			switch event {
+			case retrievalmarket.ClientEventError:
+				retrievalResult <- xerrors.New("Retrieval Error")
+			case retrievalmarket.ClientEventComplete:
+				retrievalResult <- nil
+			}
+		}
+	})
+
+	a.Retrieval.Retrieve(
+		ctx, order.Root.Bytes(), retrievalmarket.Params{
+			PricePerByte: types.BigDiv(order.Total, types.NewInt(order.Size)),
+		}, order.Total, order.MinerPeerID, order.Client, order.Miner)
+	select {
+	case <-ctx.Done():
+		return xerrors.New("Retrieval Timed Out")
+	case err := <-retrievalResult:
+		if err != nil {
+			return xerrors.Errorf("RetrieveUnixfs: %w", err)
+		}
 	}
 
-	err = a.Retrieval.RetrieveUnixfs(ctx, order.Root, order.Size, order.Total, order.MinerPeerID, order.Client, order.Miner, outFile)
-	if err != nil {
-		_ = outFile.Close()
-		return xerrors.Errorf("RetrieveUnixfs: %w", err)
-	}
+	unsubscribe()
 
-	return outFile.Close()
+	nd, err := a.LocalDAG.Get(ctx, order.Root)
+	if err != nil {
+		return xerrors.Errorf("ClientRetrieve: %w", err)
+	}
+	file, err := unixfile.NewUnixfsFile(ctx, a.LocalDAG, nd)
+	if err != nil {
+		return xerrors.Errorf("ClientRetrieve: %w", err)
+	}
+	return files.WriteTo(file, path)
 }
 
 func (a *API) ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*types.SignedStorageAsk, error) {