fix: lazy load version in client/rpc

client/rpc/api.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/blang/semver/v4"
@@ -42,12 +43,13 @@ var ErrApiNotFound = errors.New("ipfs api address could not be found")
 // For interface docs see
 // https://godoc.org/github.com/ipfs/interface-go-ipfs-core#CoreAPI
 type HttpApi struct {
-	url           string
-	httpcli       http.Client
-	Headers       http.Header
-	applyGlobal   func(*requestBuilder)
-	ipldDecoder   *legacy.Decoder
-	remoteVersion *semver.Version
+	url         string
+	httpcli     http.Client
+	Headers     http.Header
+	applyGlobal func(*requestBuilder)
+	ipldDecoder *legacy.Decoder
+	versionOnce sync.Once
+	version     *semver.Version
 }
 
 // NewLocalApi tries to construct new HttpApi instance communicating with local
@@ -158,9 +160,7 @@ func NewURLApiWithClient(url string, c *http.Client) (*HttpApi, error) {
 		return fmt.Errorf("unexpected redirect")
 	}
 
-	var err error
-	api.remoteVersion, err = api.getRemoteVersion()
-	return api, err
+	return api, nil
 }
 
 func (api *HttpApi) WithOptions(opts ...caopts.ApiOption) (iface.CoreAPI, error) {
@@ -169,14 +169,19 @@ func (api *HttpApi) WithOptions(opts ...caopts.ApiOption) (iface.CoreAPI, error)
 		return nil, err
 	}
 
-	subApi := *api
-	subApi.applyGlobal = func(req *requestBuilder) {
-		if options.Offline {
-			req.Option("offline", options.Offline)
-		}
+	subApi := &HttpApi{
+		url:     api.url,
+		httpcli: api.httpcli,
+		Headers: api.Headers,
+		applyGlobal: func(req *requestBuilder) {
+			if options.Offline {
+				req.Option("offline", options.Offline)
+			}
+		},
+		ipldDecoder: api.ipldDecoder,
 	}
 
-	return &subApi, nil
+	return subApi, nil
 }
 
 func (api *HttpApi) Request(command string, args ...string) RequestBuilder {
@@ -238,25 +243,34 @@ func (api *HttpApi) Routing() iface.RoutingAPI {
 	return (*RoutingAPI)(api)
 }
 
-func (api *HttpApi) getRemoteVersion() (*semver.Version, error) {
-	ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(time.Second*30))
-	defer cancel()
+func (api *HttpApi) loadRemoteVersion() error {
+	if api.version == nil {
+		ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(time.Second*30))
+		defer cancel()
 
-	resp, err := api.Request("version").Send(ctx)
-	if err != nil {
-		return nil, err
-	}
-	if resp.Error != nil {
-		return nil, resp.Error
-	}
-	defer resp.Close()
+		resp, err := api.Request("version").Send(ctx)
+		if err != nil {
+			return err
+		}
+		if resp.Error != nil {
+			return resp.Error
+		}
+		defer resp.Close()
+		var out ipfs.VersionInfo
+		dec := json.NewDecoder(resp.Output)
+		if err := dec.Decode(&out); err != nil {
+			return err
+		}
 
-	var out ipfs.VersionInfo
+		remoteVersion, err := semver.New(out.Version)
+		if err != nil {
+			return err
+		}
 
-	dec := json.NewDecoder(resp.Output)
-	if err := dec.Decode(&out); err != nil {
-		return nil, err
+		api.versionOnce.Do(func() {
+			api.version = remoteVersion
+		})
 	}
 
-	return semver.New(out.Version)
+	return nil
 }

client/rpc/requestbuilder.go

@@ -26,11 +26,12 @@ type RequestBuilder interface {
 
 // requestBuilder is an IPFS commands request builder.
 type requestBuilder struct {
-	command string
-	args    []string
-	opts    map[string]string
-	headers map[string]string
-	body    io.Reader
+	command    string
+	args       []string
+	opts       map[string]string
+	headers    map[string]string
+	body       io.Reader
+	buildError error
 
 	shell *HttpApi
 }
@@ -61,7 +62,17 @@ func (r *requestBuilder) Body(body io.Reader) RequestBuilder {
 func (r *requestBuilder) FileBody(body io.Reader) RequestBuilder {
 	pr, _ := files.NewReaderPathFile("/dev/stdin", io.NopCloser(body), nil)
 	d := files.NewMapDirectory(map[string]files.Node{"": pr})
-	r.body = files.NewMultiFileReader(d, false, r.shell.remoteVersion.LT(ipfs.EncodedAbsolutePathVersion))
+
+	err := r.shell.loadRemoteVersion()
+	if err != nil {
+		// Unfortunately, we cannot return an error here. Changing this API is also
+		// not the best since we would otherwise have an inconsistent RequestBuilder.
+		// We save the error and return it when calling [requestBuilder.Send].
+		r.buildError = err
+		return r
+	}
+
+	r.body = files.NewMultiFileReader(d, false, r.shell.version.LT(ipfs.EncodedAbsolutePathVersion))
 
 	return r
 }
@@ -98,6 +109,10 @@ func (r *requestBuilder) Header(name, value string) RequestBuilder {
 
 // Send sends the request and return the response.
 func (r *requestBuilder) Send(ctx context.Context) (*Response, error) {
+	if r.buildError != nil {
+		return nil, r.buildError
+	}
+
 	r.shell.applyGlobal(r)
 
 	req := NewRequest(ctx, r.shell.url, r.command, r.args...)

client/rpc/unixfs.go

@@ -63,7 +63,7 @@ func (api *UnixfsAPI) Add(ctx context.Context, f files.Node, opts ...caopts.Unix
 	}
 
 	d := files.NewMapDirectory(map[string]files.Node{"": f}) // unwrapped on the other side
-	req.Body(files.NewMultiFileReader(d, false, api.remoteVersion.LT(ipfs.EncodedAbsolutePathVersion)))
+	req.Body(files.NewMultiFileReader(d, false, api.version.LT(ipfs.EncodedAbsolutePathVersion)))
 
 	var out addEvent
 	resp, err := req.Send(ctx)