Add missing parameters for Provide Reframe methods

Co-authored-by: Ivan Schasny <[email protected]>

cmd/ipfs/daemon.go

@@ -416,7 +416,13 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment
  case routingOptionNoneKwd:
  ncfg.Routing = libp2p.NilRouterOption
  case routingOptionCustomKwd:
- ncfg.Routing = libp2p.ConstructDelegatedRouting(cfg.Routing.Routers, cfg.Routing.Methods)
+ ncfg.Routing = libp2p.ConstructDelegatedRouting(
+ cfg.Routing.Routers,
+ cfg.Routing.Methods,
+ cfg.Identity.PeerID,
+ cfg.Addresses.Swarm,
+ cfg.Identity.PrivKey,
+ )
  default:
  return fmt.Errorf("unrecognized routing option: %s", routingOption)
  }

core/node/libp2p/routingopt.go

@@ -49,7 +49,7 @@ func constructDHTRouting(mode dht.ModeOpt) func(
  }
 }
 
-func ConstructDelegatedRouting(routers config.Routers, methods config.Methods) func(
+func ConstructDelegatedRouting(routers config.Routers, methods config.Methods, peerID string, addrs []string, privKey string) func(
  ctx context.Context,
  host host.Host,
  dstore datastore.Batching,
@@ -63,13 +63,19 @@ func ConstructDelegatedRouting(routers config.Routers, methods config.Methods) f
  validator record.Validator,
  bootstrapPeers ...peer.AddrInfo,
  ) (routing.Routing, error) {
- return irouting.Parse(routers, methods, &irouting.ExtraDHTParams{
- BootstrapPeers: bootstrapPeers,
- Host: host,
- Validator: validator,
- Datastore: dstore,
- Context: ctx,
- })
+ return irouting.Parse(routers, methods,
+ &irouting.ExtraDHTParams{
+ BootstrapPeers: bootstrapPeers,
+ Host: host,
+ Validator: validator,
+ Datastore: dstore,
+ Context: ctx,
+ },
+ &irouting.ExtraReframeParams{
+ PeerID: peerID,
+ Addrs: addrs,
+ PrivKeyB64: privKey,
+ })
  }
 }
 

routing/delegated.go

@@ -2,6 +2,7 @@ package routing
 
 import (
  "context"
+ "encoding/base64"
  "errors"
  "fmt"
 
@@ -15,14 +16,17 @@ import (
  "github.com/libp2p/go-libp2p-kad-dht/fullrt"
  record "github.com/libp2p/go-libp2p-record"
  routinghelpers "github.com/libp2p/go-libp2p-routing-helpers"
+ ic "github.com/libp2p/go-libp2p/core/crypto"
  host "github.com/libp2p/go-libp2p/core/host"
  "github.com/libp2p/go-libp2p/core/peer"
  "github.com/libp2p/go-libp2p/core/routing"
+ ma "github.com/multiformats/go-multiaddr"
+ "github.com/multiformats/go-multicodec"
 )
 
 var log = logging.Logger("routing/delegated")
 
-func Parse(routers config.Routers, methods config.Methods, extra *ExtraDHTParams) (routing.Routing, error) {
+func Parse(routers config.Routers, methods config.Methods, extraDHT *ExtraDHTParams, extraReframe *ExtraReframeParams) (routing.Routing, error) {
  stack := make(map[string]routing.Routing)
  processLater := make(config.Routers)
  log.Info("starting to parse ", len(routers), " routers")
@@ -37,7 +41,7 @@ func Parse(routers config.Routers, methods config.Methods, extra *ExtraDHTParams
  continue
  }
  log.Info("creating router ", k)
- router, err := routingFromConfig(r.Router, extra)
+ router, err := routingFromConfig(r.Router, extraDHT, extraReframe)
  if err != nil {
  return nil, err
  }
@@ -123,22 +127,28 @@ func Parse(routers config.Routers, methods config.Methods, extra *ExtraDHTParams
  return finalRouter, nil
 }
 
-func routingFromConfig(conf config.Router, extra *ExtraDHTParams) (routing.Routing, error) {
+func routingFromConfig(conf config.Router, extraDHT *ExtraDHTParams, extraReframe *ExtraReframeParams) (routing.Routing, error) {
  var router routing.Routing
  var err error
  switch conf.Type {
  case config.RouterTypeReframe:
- router, err = reframeRoutingFromConfig(conf)
+ router, err = reframeRoutingFromConfig(conf, extraReframe)
  case config.RouterTypeDHT:
- router, err = dhtRoutingFromConfig(conf, extra)
+ router, err = dhtRoutingFromConfig(conf, extraDHT)
  default:
  return nil, fmt.Errorf("unknown router type %s", conf.Type)
  }
 
  return router, err
 }
 
-func reframeRoutingFromConfig(conf config.Router) (routing.Routing, error) {
+type ExtraReframeParams struct {
+ PeerID string
+ Addrs []string
+ PrivKeyB64 string
+}
+
+func reframeRoutingFromConfig(conf config.Router, extraReframe *ExtraReframeParams) (routing.Routing, error) {
  var dr drp.DelegatedRouting_Client
 
  params, ok := conf.Parameters.(*config.ReframeRouterParams)
@@ -155,18 +165,72 @@ func reframeRoutingFromConfig(conf config.Router) (routing.Routing, error) {
  return nil, err
  }
 
- // TODO support Provide adding missing params.
- c, err := drc.NewClient(dr, nil, nil)
- if err != nil {
- return nil, err
+ var c *drc.Client
+ if extraReframe == nil {
+ c, err = drc.NewClient(dr, nil, nil)
+ if err != nil {
+ return nil, err
+ }
+ } else {
+ prov, err := createProvider(extraReframe.PeerID, extraReframe.Addrs)
+ if err != nil {
+ return nil, err
+ }
+
+ key, err := decodePrivKey(extraReframe.PrivKeyB64)
+ if err != nil {
+ return nil, err
+ }
+
+ c, err = drc.NewClient(dr, prov, key)
+ if err != nil {
+ return nil, err
+ }
  }
+
  crc := drc.NewContentRoutingClient(c)
  return &reframeRoutingWrapper{
  Client: c,
  ContentRoutingClient: crc,
  }, nil
 }
 
+func decodePrivKey(keyB64 string) (ic.PrivKey, error) {
+ pk, err := base64.StdEncoding.DecodeString(keyB64)
+ if err != nil {
+ return nil, err
+ }
+
+ return ic.UnmarshalPrivateKey(pk)
+}
+
+func createProvider(peerID string, addrs []string) (*drc.Provider, error) {
+ pID, err := peer.Decode(peerID)
+ if err != nil {
+ return nil, err
+ }
+
+ var mas []ma.Multiaddr
+ for _, a := range addrs {
+ m, err := ma.NewMultiaddr(a)
+ if err != nil {
+ return nil, err
+ }
+
+ mas = append(mas, m)
+ }
+
+ return &drc.Provider{
+ Peer: peer.AddrInfo{
+ ID: pID,
+ Addrs: mas,
+ },
+ ProviderProto: []drc.TransferProtocol{
+ {Codec: multicodec.TransportBitswap},
+ },
+ }, nil
+}
+
 type ExtraDHTParams struct {
  BootstrapPeers []peer.AddrInfo
  Host host.Host

routing/delegated_test.go

@@ -1,9 +1,12 @@
 package routing
 
 import (
+ "encoding/base64"
  "testing"
 
  "github.com/ipfs/kubo/config"
+ crypto "github.com/libp2p/go-libp2p/core/crypto"
+ peer "github.com/libp2p/go-libp2p/core/peer"
  "github.com/stretchr/testify/require"
 )
 
@@ -12,15 +15,15 @@ func TestRoutingFromConfig(t *testing.T) {
 
  r, err := routingFromConfig(config.Router{
  Type: "unknown",
- }, nil)
+ }, nil, nil)
 
  require.Nil(r)
  require.EqualError(err, "unknown router type unknown")
 
  r, err = routingFromConfig(config.Router{
  Type: config.RouterTypeReframe,
  Parameters: &config.ReframeRouterParams{},
- }, nil)
+ }, nil, nil)
 
  require.Nil(r)
  require.EqualError(err, "configuration param 'Endpoint' is needed for reframe delegated routing types")
@@ -30,10 +33,33 @@ func TestRoutingFromConfig(t *testing.T) {
  Parameters: &config.ReframeRouterParams{
  Endpoint: "test",
  },
- }, nil)
+ }, nil, nil)
 
  require.NoError(err)
  require.NotNil(r)
+
+ priv, pub, err := crypto.GenerateKeyPair(crypto.RSA, 2048)
+ require.NoError(err)
+
+ id, err := peer.IDFromPublicKey(pub)
+ require.NoError(err)
+
+ privM, err := crypto.MarshalPrivateKey(priv)
+ require.NoError(err)
+
+ r, err = routingFromConfig(config.Router{
+ Type: config.RouterTypeReframe,
+ Parameters: &config.ReframeRouterParams{
+ Endpoint: "test",
+ },
+ }, nil, &ExtraReframeParams{
+ PeerID: id.String(),
+ Addrs: []string{"/ip4/0.0.0.0/tcp/4001"},
+ PrivKeyB64: base64.StdEncoding.EncodeToString(privM),
+ })
+
+ require.NotNil(r)
+ require.NoError(err)
 }
 
 func TestParser(t *testing.T) {
@@ -78,7 +104,7 @@ func TestParser(t *testing.T) {
  config.MethodNameProvide: config.Method{
  RouterName: "r2",
  },
- }, &ExtraDHTParams{})
+ }, &ExtraDHTParams{}, nil)
 
  require.NoError(err)