7c636061bd
* Improve pin/unpin method signatures: These changes the following Cluster Go API methods: * -> Cluster.Pin(ctx, cid, options) (pin, error) * -> Cluster.Unpin(ctx, cid) (pin, error) * -> Cluster.PinPath(ctx, path, opts) (pin,error) Pin and Unpin now return the pinned object. The signature of the methods now matches that of the API Client, is clearer as to what options the user can set and is aligned with PinPath, UnpinPath, which returned pin methods. The REST API now returns the Pinned/Unpinned object rather than 204-Accepted. This was necessary for a cleaner pin/update approach, which I'm working on in another branch. Most of the changes here are updating tests to the new signatures * Adapt load-balancing client to new Pin/Unpin signatures * cluster.go: Fix typo Co-Authored-By: Kishan Sagathiya <kishansagathiya@gmail.com> * cluster.go: Fix typo Co-Authored-By: Kishan Sagathiya <kishansagathiya@gmail.com>
107 lines
2.7 KiB
Go
107 lines
2.7 KiB
Go
package adder
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
|
|
"github.com/ipfs/ipfs-cluster/api"
|
|
"github.com/ipfs/ipfs-cluster/rpcutil"
|
|
|
|
cid "github.com/ipfs/go-cid"
|
|
ipld "github.com/ipfs/go-ipld-format"
|
|
peer "github.com/libp2p/go-libp2p-core/peer"
|
|
rpc "github.com/libp2p/go-libp2p-gorpc"
|
|
)
|
|
|
|
// PutBlock sends a NodeWithMeta to the given destinations.
|
|
func PutBlock(ctx context.Context, rpc *rpc.Client, n *api.NodeWithMeta, dests []peer.ID) error {
|
|
format, ok := cid.CodecToStr[n.Cid.Type()]
|
|
if !ok {
|
|
format = ""
|
|
logger.Warning("unsupported cid type, treating as v0")
|
|
}
|
|
if n.Cid.Prefix().Version == 0 {
|
|
format = "v0"
|
|
}
|
|
n.Format = format
|
|
|
|
ctxs, cancels := rpcutil.CtxsWithCancel(ctx, len(dests))
|
|
defer rpcutil.MultiCancel(cancels)
|
|
|
|
logger.Debugf("block put %s to %s", n.Cid, dests)
|
|
errs := rpc.MultiCall(
|
|
ctxs,
|
|
dests,
|
|
"IPFSConnector",
|
|
"BlockPut",
|
|
n,
|
|
rpcutil.RPCDiscardReplies(len(dests)),
|
|
)
|
|
return rpcutil.CheckErrs(errs)
|
|
}
|
|
|
|
// BlockAllocate helps allocating blocks to peers.
|
|
func BlockAllocate(ctx context.Context, rpc *rpc.Client, pinOpts api.PinOptions) ([]peer.ID, error) {
|
|
// Find where to allocate this file
|
|
var allocsStr []peer.ID
|
|
err := rpc.CallContext(
|
|
ctx,
|
|
"",
|
|
"Cluster",
|
|
"BlockAllocate",
|
|
api.PinWithOpts(cid.Undef, pinOpts),
|
|
&allocsStr,
|
|
)
|
|
return allocsStr, err
|
|
}
|
|
|
|
// Pin helps sending local RPC pin requests.
|
|
func Pin(ctx context.Context, rpc *rpc.Client, pin *api.Pin) error {
|
|
if pin.ReplicationFactorMin < 0 {
|
|
pin.Allocations = []peer.ID{}
|
|
}
|
|
logger.Debugf("adder pinning %+v", pin)
|
|
var pinResp api.Pin
|
|
return rpc.CallContext(
|
|
ctx,
|
|
"", // use ourself to pin
|
|
"Cluster",
|
|
"Pin",
|
|
pin,
|
|
&pinResp,
|
|
)
|
|
}
|
|
|
|
// ErrDAGNotFound is returned whenever we try to get a block from the DAGService.
|
|
var ErrDAGNotFound = errors.New("dagservice: block not found")
|
|
|
|
// BaseDAGService partially implements an ipld.DAGService.
|
|
// It provides the methods which are not needed by ClusterDAGServices
|
|
// (Get*, Remove*) so that they can save adding this code.
|
|
type BaseDAGService struct {
|
|
}
|
|
|
|
// Get always returns errNotFound
|
|
func (dag BaseDAGService) Get(ctx context.Context, key cid.Cid) (ipld.Node, error) {
|
|
return nil, ErrDAGNotFound
|
|
}
|
|
|
|
// GetMany returns an output channel that always emits an error
|
|
func (dag BaseDAGService) GetMany(ctx context.Context, keys []cid.Cid) <-chan *ipld.NodeOption {
|
|
out := make(chan *ipld.NodeOption, 1)
|
|
out <- &ipld.NodeOption{Err: fmt.Errorf("failed to fetch all nodes")}
|
|
close(out)
|
|
return out
|
|
}
|
|
|
|
// Remove is a nop
|
|
func (dag BaseDAGService) Remove(ctx context.Context, key cid.Cid) error {
|
|
return nil
|
|
}
|
|
|
|
// RemoveMany is a nop
|
|
func (dag BaseDAGService) RemoveMany(ctx context.Context, keys []cid.Cid) error {
|
|
return nil
|
|
}
|