Migrate delegated routing

go.mod

@@ -2,10 +2,50 @@ module github.com/ipfs/go-libipfs
 
 go 1.19
 
-require github.com/stretchr/testify v1.8.1
+require (
+	github.com/benbjohnson/clock v1.3.0
+	github.com/gorilla/mux v1.8.0
+	github.com/ipfs/go-cid v0.3.2
+	github.com/ipfs/go-ipns v0.3.0
+	github.com/ipfs/go-log/v2 v2.5.1
+	github.com/libp2p/go-libp2p v0.23.4
+	github.com/libp2p/go-libp2p-record v0.2.0
+	github.com/multiformats/go-multiaddr v0.8.0
+	github.com/multiformats/go-multibase v0.1.1
+	github.com/multiformats/go-multihash v0.2.1
+	github.com/samber/lo v1.36.0
+	github.com/stretchr/testify v1.8.1
+)
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 // indirect
+	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/ipfs/go-ipfs-util v0.0.2 // indirect
+	github.com/ipld/go-ipld-prime v0.9.0 // indirect
+	github.com/klauspost/cpuid/v2 v2.1.1 // indirect
+	github.com/libp2p/go-buffer-pool v0.1.0 // indirect
+	github.com/libp2p/go-openssl v0.1.0 // indirect
+	github.com/mattn/go-isatty v0.0.16 // indirect
+	github.com/mattn/go-pointer v0.0.1 // indirect
+	github.com/minio/sha256-simd v1.0.0 // indirect
+	github.com/mr-tron/base58 v1.2.0 // indirect
+	github.com/multiformats/go-base32 v0.1.0 // indirect
+	github.com/multiformats/go-base36 v0.1.0 // indirect
+	github.com/multiformats/go-multicodec v0.6.0 // indirect
+	github.com/multiformats/go-varint v0.0.6 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/polydawn/refmt v0.0.0-20190807091052-3d65705ee9f1 // indirect
+	github.com/spacemonkeygo/spacelog v0.0.0-20180420211403-2296661a0572 // indirect
+	github.com/spaolacci/murmur3 v1.1.0 // indirect
+	github.com/stretchr/objx v0.5.0 // indirect
+	go.uber.org/atomic v1.10.0 // indirect
+	go.uber.org/multierr v1.8.0 // indirect
+	go.uber.org/zap v1.23.0 // indirect
+	golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e // indirect
+	golang.org/x/exp v0.0.0-20220916125017-b168a2c6b86b // indirect
+	golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
+	lukechampine.com/blake3 v1.1.7 // indirect
 )

routing/http/README.md

@@ -0,0 +1,24 @@
+go-delegated-routing
+=======================
+
+> Delegated routing Client and Server over Reframe RPC
+
+This package provides delegated routing implementation in Go:
+- Client (for IPFS nodes like [Kubo](https://github.com/ipfs/kubo/blob/master/docs/config.md#routingrouters-parameters)),
+- Server (for public indexers such as https://cid.contact)
+
+## Documentation
+
+- Go docs: https://pkg.go.dev/github.com/ipfs/go-libipfs/routing/http/
+
+## Lead Maintainer
+
+🦗🎶
+
+## Contributing
+
+Contributions are welcome! This repository is part of the IPFS project and therefore governed by our [contributing guidelines](https://github.com/ipfs/community/blob/master/CONTRIBUTING.md).
+
+## License
+
+[SPDX-License-Identifier: Apache-2.0 OR MIT](LICENSE.md)

routing/http/client/client.go

@@ -0,0 +1,187 @@
+package client
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/benbjohnson/clock"
+	"github.com/ipfs/go-cid"
+	ipns "github.com/ipfs/go-ipns"
+	delegatedrouting "github.com/ipfs/go-libipfs/routing/http"
+	logging "github.com/ipfs/go-log/v2"
+	record "github.com/libp2p/go-libp2p-record"
+	"github.com/libp2p/go-libp2p/core/crypto"
+	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/multiformats/go-multiaddr"
+)
+
+var logger = logging.Logger("service/delegatedrouting")
+
+type client struct {
+	baseURL    string
+	httpClient httpClient
+	validator  record.Validator
+	clock      clock.Clock
+
+	peerID   peer.ID
+	addrs    []delegatedrouting.Multiaddr
+	identity crypto.PrivKey
+
+	// called immeidately after signing a provide req
+	// used for testing, e.g. testing the server with a mangled signature
+	afterSignCallback func(req *delegatedrouting.BitswapWriteProviderRequest)
+}
+
+type httpClient interface {
+	Do(req *http.Request) (*http.Response, error)
+}
+
+type option func(*client)
+
+func WithIdentity(identity crypto.PrivKey) option {
+	return func(c *client) {
+		c.identity = identity
+	}
+}
+
+func WithHTTPClient(h httpClient) option {
+	return func(c *client) {
+		c.httpClient = h
+	}
+}
+
+func WithProviderInfo(peerID peer.ID, addrs []multiaddr.Multiaddr) option {
+	return func(c *client) {
+		c.peerID = peerID
+		for _, a := range addrs {
+			c.addrs = append(c.addrs, delegatedrouting.Multiaddr{Multiaddr: a})
+		}
+	}
+}
+
+// New creates a content routing API client.
+// The Provider and identity parameters are option. If they are nil, the `Provide` method will not function.
+func New(baseURL string, opts ...option) (*client, error) {
+	client := &client{
+		baseURL:    baseURL,
+		httpClient: http.DefaultClient,
+		validator:  ipns.Validator{},
+		clock:      clock.New(),
+	}
+
+	for _, opt := range opts {
+		opt(client)
+	}
+
+	if client.identity != nil && client.peerID.Size() != 0 && !client.peerID.MatchesPublicKey(client.identity.GetPublic()) {
+		return nil, errors.New("identity does not match provider")
+	}
+
+	return client, nil
+}
+
+func (c *client) FindProviders(ctx context.Context, key cid.Cid) ([]delegatedrouting.Provider, error) {
+	url := c.baseURL + "/v1/providers/" + key.String()
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, httpError(resp.StatusCode, resp.Body)
+	}
+
+	parsedResp := &delegatedrouting.FindProvidersResponse{}
+	err = json.NewDecoder(resp.Body).Decode(parsedResp)
+	return parsedResp.Providers, err
+}
+
+func (c *client) ProvideBitswap(ctx context.Context, keys []cid.Cid, ttl time.Duration) (time.Duration, error) {
+	if c.identity == nil {
+		return 0, errors.New("cannot provide Bitswap records without an identity")
+	}
+	if c.peerID.Size() == 0 {
+		return 0, errors.New("cannot provide Bitswap records without a peer ID")
+	}
+
+	ks := make([]delegatedrouting.CID, len(keys))
+	for i, c := range keys {
+		ks[i] = delegatedrouting.CID{Cid: c}
+	}
+
+	now := c.clock.Now()
+
+	req := delegatedrouting.BitswapWriteProviderRequest{
+		Protocol: "bitswap",
+		Payload: delegatedrouting.BitswapWriteProviderRequestPayload{
+			Keys:        ks,
+			AdvisoryTTL: &delegatedrouting.Duration{Duration: ttl},
+			Timestamp:   &delegatedrouting.Time{Time: now},
+			ID:          &c.peerID,
+			Addrs:       c.addrs,
+		},
+	}
+	err := req.Sign(c.peerID, c.identity)
+	if err != nil {
+		return 0, err
+	}
+
+	if c.afterSignCallback != nil {
+		c.afterSignCallback(&req)
+	}
+
+	advisoryTTL, err := c.provideSignedBitswapRecord(ctx, &req)
+	if err != nil {
+		return 0, err
+	}
+
+	return advisoryTTL, err
+}
+
+// ProvideAsync makes a provide request to a delegated router
+func (c *client) provideSignedBitswapRecord(ctx context.Context, bswp *delegatedrouting.BitswapWriteProviderRequest) (time.Duration, error) {
+	req := delegatedrouting.WriteProvidersRequest{Providers: []delegatedrouting.Provider{bswp}}
+
+	url := c.baseURL + "/v1/providers"
+
+	b, err := json.Marshal(req)
+	if err != nil {
+		return 0, err
+	}
+
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewBuffer(b))
+	if err != nil {
+		return 0, err
+	}
+
+	resp, err := c.httpClient.Do(httpReq)
+	if err != nil {
+		return 0, fmt.Errorf("making HTTP req to provide a signed record: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return 0, httpError(resp.StatusCode, resp.Body)
+	}
+	provideResult := delegatedrouting.WriteProvidersResponse{Protocols: []string{"bitswap"}}
+	err = json.NewDecoder(resp.Body).Decode(&provideResult)
+	if err != nil {
+		return 0, err
+	}
+	if len(provideResult.ProvideResults) != 1 {
+		return 0, fmt.Errorf("expected 1 result but got %d", len(provideResult.ProvideResults))
+	}
+
+	return provideResult.ProvideResults[0].(*delegatedrouting.BitswapWriteProviderResponse).AdvisoryTTL, nil
+}