cascade/ipfs-cluster
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Feat: Split components into RPC Services

Browse Source 
I had thought of this for a very long time but there were no compelling
reasons to do it. Specifying RPC endpoint permissions becomes however
significantly nicer if each Component is a different RPC Service. This also
fixes some naming issues like having to prefix methods with the component name
to separate them from methods named in the same way in some other component
(Pin and IPFSPin).
This commit is contained in:
Hector Sanjuan 2019-05-04 21:36:10 +01:00
parent 7e700e2338
commit 3d49ac26a5
25 changed files with 451 additions and 328 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
adder/local/dag_service.go
View File

@ -33,7 +33,7 @@ type DAGService struct {
} }
// New returns a new Adder with the given rpc Client. The client is used // New returns a new Adder with the given rpc Client. The client is used
// to perform calls to IPFSBlockPut and Pin content on Cluster. // to perform calls to IPFS.BlockPut and Pin content on Cluster.
func New(rpc *rpc.Client, opts api.PinOptions) *DAGService { func New(rpc *rpc.Client, opts api.PinOptions) *DAGService {
return &DAGService{ return &DAGService{
rpcClient: rpc, rpcClient: rpc,

39
adder/local/dag_service_test.go
View File

@ -16,22 +16,25 @@ import (
rpc "github.com/libp2p/go-libp2p-gorpc" rpc "github.com/libp2p/go-libp2p-gorpc"
) )
type testRPC struct { type testIPFSRPC struct {
blocks sync.Map blocks sync.Map
pins sync.Map
} }
func (rpcs *testRPC) IPFSBlockPut(ctx context.Context, in *api.NodeWithMeta, out *struct{}) error { type testClusterRPC struct {
pins sync.Map
}
func (rpcs *testIPFSRPC) BlockPut(ctx context.Context, in *api.NodeWithMeta, out *struct{}) error {
rpcs.blocks.Store(in.Cid.String(), in) rpcs.blocks.Store(in.Cid.String(), in)
return nil return nil
} }
func (rpcs *testRPC) Pin(ctx context.Context, in *api.Pin, out *struct{}) error { func (rpcs *testClusterRPC) Pin(ctx context.Context, in *api.Pin, out *struct{}) error {
rpcs.pins.Store(in.Cid.String(), in) rpcs.pins.Store(in.Cid.String(), in)
return nil return nil
} }
func (rpcs *testRPC) BlockAllocate(ctx context.Context, in *api.Pin, out *[]peer.ID) error { func (rpcs *testClusterRPC) BlockAllocate(ctx context.Context, in *api.Pin, out *[]peer.ID) error {
if in.ReplicationFactorMin > 1 { if in.ReplicationFactorMin > 1 {
return errors.New("we can only replicate to 1 peer") return errors.New("we can only replicate to 1 peer")
} }
@ -43,9 +46,14 @@ func (rpcs *testRPC) BlockAllocate(ctx context.Context, in *api.Pin, out *[]peer
func TestAdd(t *testing.T) { func TestAdd(t *testing.T) {
t.Run("balanced", func(t *testing.T) { t.Run("balanced", func(t *testing.T) {
rpcObj := &testRPC{} clusterRPC := &testClusterRPC{}
ipfsRPC := &testIPFSRPC{}
server := rpc.NewServer(nil, "mock") server := rpc.NewServer(nil, "mock")
err := server.RegisterName("Cluster", rpcObj) err := server.RegisterName("Cluster", clusterRPC)
if err != nil {
t.Fatal(err)
}
err = server.RegisterName("IPFSConnector", ipfsRPC)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -73,22 +81,27 @@ func TestAdd(t *testing.T) {
expected := test.ShardingDirCids[:] expected := test.ShardingDirCids[:]
for _, c := range expected { for _, c := range expected {
_, ok := rpcObj.blocks.Load(c) _, ok := ipfsRPC.blocks.Load(c)
if !ok { if !ok {
t.Error("no IPFSBlockPut for block", c) t.Error("no IPFS.BlockPut for block", c)
} }
} }
_, ok := rpcObj.pins.Load(test.ShardingDirBalancedRootCIDWrapped) _, ok := clusterRPC.pins.Load(test.ShardingDirBalancedRootCIDWrapped)
if !ok { if !ok {
t.Error("the tree wasn't pinned") t.Error("the tree wasn't pinned")
} }
}) })
t.Run("trickle", func(t *testing.T) { t.Run("trickle", func(t *testing.T) {
rpcObj := &testRPC{} clusterRPC := &testClusterRPC{}
ipfsRPC := &testIPFSRPC{}
server := rpc.NewServer(nil, "mock") server := rpc.NewServer(nil, "mock")
err := server.RegisterName("Cluster", rpcObj) err := server.RegisterName("Cluster", clusterRPC)
if err != nil {
t.Fatal(err)
}
err = server.RegisterName("IPFSConnector", ipfsRPC)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -114,7 +127,7 @@ func TestAdd(t *testing.T) {
t.Fatal("bad root cid") t.Fatal("bad root cid")
} }
_, ok := rpcObj.pins.Load(test.ShardingDirTrickleRootCID) _, ok := clusterRPC.pins.Load(test.ShardingDirTrickleRootCID)
if !ok { if !ok {
t.Error("the tree wasn't pinned") t.Error("the tree wasn't pinned")
} }

4
adder/sharding/dag.go
View File

@ -140,8 +140,8 @@ func putDAG(ctx context.Context, rpcC *rpc.Client, nodes []ipld.Node, dests []pe
errs := rpcC.MultiCall( errs := rpcC.MultiCall(
ctxs, ctxs,
dests, dests,
"Cluster", "IPFSConnector",
"IPFSBlockPut", "BlockPut",
b, b,
rpcutil.RPCDiscardReplies(len(dests)), rpcutil.RPCDiscardReplies(len(dests)),
) )

6
adder/sharding/dag_service_test.go
View File

@ -27,7 +27,7 @@ type testRPC struct {
pins sync.Map pins sync.Map
} }
func (rpcs *testRPC) IPFSBlockPut(ctx context.Context, in *api.NodeWithMeta, out *struct{}) error { func (rpcs *testRPC) BlockPut(ctx context.Context, in *api.NodeWithMeta, out *struct{}) error {
rpcs.blocks.Store(in.Cid.String(), in.Data) rpcs.blocks.Store(in.Cid.String(), in.Data)
return nil return nil
} }
@ -70,6 +70,10 @@ func makeAdder(t *testing.T, params *api.AddParams) (*adder.Adder, *testRPC) {
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
err = server.RegisterName("IPFSConnector", rpcObj)
if err != nil {
t.Fatal(err)
}
client := rpc.NewClientWithServer(nil, "mock", server) client := rpc.NewClientWithServer(nil, "mock", server)
out := make(chan *api.AddedOutput, 1) out := make(chan *api.AddedOutput, 1)

4
adder/util.go
View File

@ -33,8 +33,8 @@ func PutBlock(ctx context.Context, rpc *rpc.Client, n *api.NodeWithMeta, dests [
errs := rpc.MultiCall( errs := rpc.MultiCall(
ctxs, ctxs,
dests, dests,
"Cluster", "IPFSConnector",
"IPFSBlockPut", "BlockPut",
n, n,
rpcutil.RPCDiscardReplies(len(dests)), rpcutil.RPCDiscardReplies(len(dests)),
) )

12
api/ipfsproxy/ipfsproxy.go
View File

@ -435,8 +435,8 @@ func (proxy *Server) pinUpdateHandler(w http.ResponseWriter, r *http.Request) {
err = proxy.rpcClient.CallContext( err = proxy.rpcClient.CallContext(
ctx, ctx,
"", "",
"Cluster", "IPFSConnector",
"IPFSResolve", "Resolve",
pFrom.String(), pFrom.String(),
&fromCid, &fromCid,
) )
@ -591,8 +591,8 @@ func (proxy *Server) repoStatHandler(w http.ResponseWriter, r *http.Request) {
peers := make([]peer.ID, 0) peers := make([]peer.ID, 0)
err := proxy.rpcClient.Call( err := proxy.rpcClient.Call(
"", "",
"Cluster", "Consensus",
"ConsensusPeers", "Peers",
struct{}{}, struct{}{},
&peers, &peers,
) )
@ -614,8 +614,8 @@ func (proxy *Server) repoStatHandler(w http.ResponseWriter, r *http.Request) {
errs := proxy.rpcClient.MultiCall( errs := proxy.rpcClient.MultiCall(
ctxs, ctxs,
peers, peers,
"Cluster", "IPFSConnector",
"IPFSRepoStat", "RepoStat",
struct{}{}, struct{}{},
repoStatsIfaces, repoStatsIfaces,
) )

4
api/rest/restapi.go
View File

@ -574,8 +574,8 @@ func (api *API) metricsHandler(w http.ResponseWriter, r *http.Request) {
err := api.rpcClient.CallContext( err := api.rpcClient.CallContext(
r.Context(), r.Context(),
"", "",
"Cluster", "PeerMonitor",
"PeerMonitorLatestMetrics", "LatestMetrics",
name, name,
&metrics, &metrics,
) )

42
cluster.go
View File

@ -157,14 +157,7 @@ func NewCluster(
} }
func (c *Cluster) setupRPC() error { func (c *Cluster) setupRPC() error {
var rpcServer *rpc.Server rpcServer, err := newRPCServer(c)
if c.config.Tracing {
sh := &ocgorpc.ServerHandler{}
rpcServer = rpc.NewServer(c.host, version.RPCProtocol, rpc.WithServerStatsHandler(sh))
} else {
rpcServer = rpc.NewServer(c.host, version.RPCProtocol)
}
err := rpcServer.RegisterName("Cluster", &RPCAPI{c})
if err != nil { if err != nil {
return err return err
} }
@ -173,7 +166,12 @@ func (c *Cluster) setupRPC() error {
var rpcClient *rpc.Client var rpcClient *rpc.Client
if c.config.Tracing { if c.config.Tracing {
csh := &ocgorpc.ClientHandler{} csh := &ocgorpc.ClientHandler{}
rpcClient = rpc.NewClientWithServer(c.host, version.RPCProtocol, rpcServer, rpc.WithClientStatsHandler(csh)) rpcClient = rpc.NewClientWithServer(
c.host,
version.RPCProtocol,
rpcServer,
rpc.WithClientStatsHandler(csh),
)
} else { } else {
rpcClient = rpc.NewClientWithServer(c.host, version.RPCProtocol, rpcServer) rpcClient = rpc.NewClientWithServer(c.host, version.RPCProtocol, rpcServer)
} }
@ -648,8 +646,8 @@ func (c *Cluster) PeerAdd(ctx context.Context, pid peer.ID) (*api.ID, error) {
err = c.rpcClient.CallContext( err = c.rpcClient.CallContext(
ctx, ctx,
pid, pid,
"Cluster", "PeerMonitor",
"PeerMonitorLogMetric", "LogMetric",
m, m,
&struct{}{}, &struct{}{},
) )
@ -661,8 +659,8 @@ func (c *Cluster) PeerAdd(ctx context.Context, pid peer.ID) (*api.ID, error) {
err = c.rpcClient.CallContext( err = c.rpcClient.CallContext(
ctx, ctx,
pid, pid,
"Cluster", "IPFSConnector",
"IPFSConnectSwarms", "ConnectSwarms",
struct{}{}, struct{}{},
&struct{}{}, &struct{}{},
) )
@ -856,7 +854,7 @@ func (c *Cluster) StatusAll(ctx context.Context) ([]*api.GlobalPinInfo, error) {
defer span.End() defer span.End()
ctx = trace.NewContext(c.ctx, span) ctx = trace.NewContext(c.ctx, span)
return c.globalPinInfoSlice(ctx, "TrackerStatusAll") return c.globalPinInfoSlice(ctx, "PinTracker", "StatusAll")
} }
// StatusAllLocal returns the PinInfo for all the tracked Cids in this peer. // StatusAllLocal returns the PinInfo for all the tracked Cids in this peer.
@ -876,7 +874,7 @@ func (c *Cluster) Status(ctx context.Context, h cid.Cid) (*api.GlobalPinInfo, er
defer span.End() defer span.End()
ctx = trace.NewContext(c.ctx, span) ctx = trace.NewContext(c.ctx, span)
return c.globalPinInfoCid(ctx, "TrackerStatus", h) return c.globalPinInfoCid(ctx, "PinTracker", "Status", h)
} }
// StatusLocal returns this peer's PinInfo for a given Cid. // StatusLocal returns this peer's PinInfo for a given Cid.
@ -897,7 +895,7 @@ func (c *Cluster) SyncAll(ctx context.Context) ([]*api.GlobalPinInfo, error) {
defer span.End() defer span.End()
ctx = trace.NewContext(c.ctx, span) ctx = trace.NewContext(c.ctx, span)
return c.globalPinInfoSlice(ctx, "SyncAllLocal") return c.globalPinInfoSlice(ctx, "Cluster", "SyncAllLocal")
} }
// SyncAllLocal makes sure that the current state for all tracked items // SyncAllLocal makes sure that the current state for all tracked items
@ -927,7 +925,7 @@ func (c *Cluster) Sync(ctx context.Context, h cid.Cid) (*api.GlobalPinInfo, erro
defer span.End() defer span.End()
ctx = trace.NewContext(c.ctx, span) ctx = trace.NewContext(c.ctx, span)
return c.globalPinInfoCid(ctx, "SyncLocal", h) return c.globalPinInfoCid(ctx, "Cluster", "SyncLocal", h)
} }
// used for RecoverLocal and SyncLocal. // used for RecoverLocal and SyncLocal.
@ -985,7 +983,7 @@ func (c *Cluster) Recover(ctx context.Context, h cid.Cid) (*api.GlobalPinInfo, e
defer span.End() defer span.End()
ctx = trace.NewContext(c.ctx, span) ctx = trace.NewContext(c.ctx, span)
return c.globalPinInfoCid(ctx, "TrackerRecover", h) return c.globalPinInfoCid(ctx, "PinTracker", "Recover", h)
} }
// RecoverLocal triggers a recover operation for a given Cid in this peer only. // RecoverLocal triggers a recover operation for a given Cid in this peer only.
@ -1356,7 +1354,7 @@ func (c *Cluster) Peers(ctx context.Context) []*api.ID {
return peers return peers
} }
func (c *Cluster) globalPinInfoCid(ctx context.Context, method string, h cid.Cid) (*api.GlobalPinInfo, error) { func (c *Cluster) globalPinInfoCid(ctx context.Context, comp, method string, h cid.Cid) (*api.GlobalPinInfo, error) {
ctx, span := trace.StartSpan(ctx, "cluster/globalPinInfoCid") ctx, span := trace.StartSpan(ctx, "cluster/globalPinInfoCid")
defer span.End() defer span.End()
@ -1379,7 +1377,7 @@ func (c *Cluster) globalPinInfoCid(ctx context.Context, method string, h cid.Cid
errs := c.rpcClient.MultiCall( errs := c.rpcClient.MultiCall(
ctxs, ctxs,
members, members,
"Cluster", comp,
method, method,
h, h,
rpcutil.CopyPinInfoToIfaces(replies), rpcutil.CopyPinInfoToIfaces(replies),
@ -1409,7 +1407,7 @@ func (c *Cluster) globalPinInfoCid(ctx context.Context, method string, h cid.Cid
return pin, nil return pin, nil
} }
func (c *Cluster) globalPinInfoSlice(ctx context.Context, method string) ([]*api.GlobalPinInfo, error) { func (c *Cluster) globalPinInfoSlice(ctx context.Context, comp, method string) ([]*api.GlobalPinInfo, error) {
ctx, span := trace.StartSpan(ctx, "cluster/globalPinInfoSlice") ctx, span := trace.StartSpan(ctx, "cluster/globalPinInfoSlice")
defer span.End() defer span.End()
@ -1431,7 +1429,7 @@ func (c *Cluster) globalPinInfoSlice(ctx context.Context, method string) ([]*api
errs := c.rpcClient.MultiCall( errs := c.rpcClient.MultiCall(
ctxs, ctxs,
members, members,
"Cluster", comp,
method, method,
struct{}{}, struct{}{},
rpcutil.CopyPinInfoSliceToIfaces(replies), rpcutil.CopyPinInfoSliceToIfaces(replies),

4
connect_graph.go
View File

@ -97,8 +97,8 @@ func (c *Cluster) recordIPFSLinks(cg *api.ConnectGraph, pID *api.ID) {
var swarmPeers []peer.ID var swarmPeers []peer.ID
err := c.rpcClient.Call( err := c.rpcClient.Call(
pID.ID, pID.ID,
"Cluster", "IPFSConnector",
"IPFSSwarmPeers", "SwarmPeers",
struct{}{}, struct{}{},
&swarmPeers, &swarmPeers,
) )

8
consensus/crdt/consensus.go
View File

@ -174,7 +174,7 @@ func (css *Consensus) setup() {
err = css.rpcClient.CallContext( err = css.rpcClient.CallContext(
css.ctx, css.ctx,
"", "",
"Cluster", "PinTracker",
"Track", "Track",
pin, pin,
&struct{}{}, &struct{}{},
@ -194,7 +194,7 @@ func (css *Consensus) setup() {
err = css.rpcClient.CallContext( err = css.rpcClient.CallContext(
css.ctx, css.ctx,
"", "",
"Cluster", "PinTracker",
"Untrack", "Untrack",
pin, pin,
&struct{}{}, &struct{}{},
@ -295,8 +295,8 @@ func (css *Consensus) Peers(ctx context.Context) ([]peer.ID, error) {
err := css.rpcClient.CallContext( err := css.rpcClient.CallContext(
ctx, ctx,
"", "",
"Cluster", "PeerMonitor",
"PeerMonitorLatestMetrics", "LatestMetrics",
css.config.PeersetMetric, css.config.PeersetMetric,
&metrics, &metrics,
) )

10
consensus/raft/consensus.go
View File

@ -280,7 +280,7 @@ func (cc *Consensus) redirectToLeader(method string, arg interface{}) (bool, err
finalErr = cc.rpcClient.CallContext( finalErr = cc.rpcClient.CallContext(
ctx, ctx,
leader, leader,
"Cluster", "Consensus",
method, method,
arg, arg,
&struct{}{}, &struct{}{},
@ -360,7 +360,7 @@ func (cc *Consensus) LogPin(ctx context.Context, pin *api.Pin) error {
defer span.End() defer span.End()
op := cc.op(ctx, pin, LogOpPin) op := cc.op(ctx, pin, LogOpPin)
err := cc.commit(ctx, op, "ConsensusLogPin", pin) err := cc.commit(ctx, op, "LogPin", pin)
if err != nil { if err != nil {
return err return err
} }
@ -373,7 +373,7 @@ func (cc *Consensus) LogUnpin(ctx context.Context, pin *api.Pin) error {
defer span.End() defer span.End()
op := cc.op(ctx, pin, LogOpUnpin) op := cc.op(ctx, pin, LogOpUnpin)
err := cc.commit(ctx, op, "ConsensusLogUnpin", pin) err := cc.commit(ctx, op, "LogUnpin", pin)
if err != nil { if err != nil {
return err return err
} }
@ -392,7 +392,7 @@ func (cc *Consensus) AddPeer(ctx context.Context, pid peer.ID) error {
if finalErr != nil { if finalErr != nil {
logger.Errorf("retrying to add peer. Attempt #%d failed: %s", i, finalErr) logger.Errorf("retrying to add peer. Attempt #%d failed: %s", i, finalErr)
} }
ok, err := cc.redirectToLeader("ConsensusAddPeer", pid) ok, err := cc.redirectToLeader("AddPeer", pid)
if err != nil || ok { if err != nil || ok {
return err return err
} }
@ -423,7 +423,7 @@ func (cc *Consensus) RmPeer(ctx context.Context, pid peer.ID) error {
if finalErr != nil { if finalErr != nil {
logger.Errorf("retrying to remove peer. Attempt #%d failed: %s", i, finalErr) logger.Errorf("retrying to remove peer. Attempt #%d failed: %s", i, finalErr)
} }
ok, err := cc.redirectToLeader("ConsensusRmPeer", pid) ok, err := cc.redirectToLeader("RmPeer", pid)
if err != nil || ok { if err != nil || ok {
return err return err
} }

4
consensus/raft/log_op.go
View File

@ -73,7 +73,7 @@ func (op *LogOp) ApplyTo(cstate consensus.State) (consensus.State, error) {
op.consensus.rpcClient.GoContext( op.consensus.rpcClient.GoContext(
ctx, ctx,
"", "",
"Cluster", "PinTracker",
"Track", "Track",
pin, pin,
&struct{}{}, &struct{}{},
@ -89,7 +89,7 @@ func (op *LogOp) ApplyTo(cstate consensus.State) (consensus.State, error) {
op.consensus.rpcClient.GoContext( op.consensus.rpcClient.GoContext(
ctx, ctx,
"", "",
"Cluster", "PinTracker",
"Untrack", "Untrack",
pin, pin,
&struct{}{}, &struct{}{},

4
informer/disk/disk.go
View File

@ -86,8 +86,8 @@ func (disk *Informer) GetMetric(ctx context.Context) *api.Metric {
err := disk.rpcClient.CallContext( err := disk.rpcClient.CallContext(
ctx, ctx,
"", "",
"Cluster", "IPFSConnector",
"IPFSRepoStat", "RepoStat",
struct{}{}, struct{}{},
&repoStat, &repoStat,
) )

4
informer/disk/disk_test.go
View File

@ -17,14 +17,14 @@ type badRPCService struct {
func badRPCClient(t *testing.T) *rpc.Client { func badRPCClient(t *testing.T) *rpc.Client {
s := rpc.NewServer(nil, "mock") s := rpc.NewServer(nil, "mock")
c := rpc.NewClientWithServer(nil, "mock", s) c := rpc.NewClientWithServer(nil, "mock", s)
err := s.RegisterName("Cluster", &badRPCService{}) err := s.RegisterName("IPFSConnector", &badRPCService{})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
return c return c
} }
func (mock *badRPCService) IPFSRepoStat(ctx context.Context, in struct{}, out *api.IPFSRepoStat) error { func (mock *badRPCService) RepoStat(ctx context.Context, in struct{}, out *api.IPFSRepoStat) error {
return errors.New("fake error") return errors.New("fake error")
} }

10
informer/numpin/numpin.go
View File

@ -74,11 +74,11 @@ func (npi *Informer) GetMetric(ctx context.Context) *api.Metric {
// about the number of pins in IPFS. See RPCAPI docs. // about the number of pins in IPFS. See RPCAPI docs.
err := npi.rpcClient.CallContext( err := npi.rpcClient.CallContext(
ctx, ctx,
"", // Local call "", // Local call
"Cluster", // Service name "IPFSConnector", // Service name
"IPFSPinLs", // Method name "PinLs", // Method name
"recursive", // in arg "recursive", // in arg
&pinMap, // out arg &pinMap, // out arg
) )
valid := err == nil valid := err == nil

4
informer/numpin/numpin_test.go
View File

@ -14,14 +14,14 @@ type mockService struct{}
func mockRPCClient(t *testing.T) *rpc.Client { func mockRPCClient(t *testing.T) *rpc.Client {
s := rpc.NewServer(nil, "mock") s := rpc.NewServer(nil, "mock")
c := rpc.NewClientWithServer(nil, "mock", s) c := rpc.NewClientWithServer(nil, "mock", s)
err := s.RegisterName("Cluster", &mockService{}) err := s.RegisterName("IPFSConnector", &mockService{})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
return c return c
} }
func (mock *mockService) IPFSPinLs(ctx context.Context, in string, out *map[string]api.IPFSPinStatus) error { func (mock *mockService) PinLs(ctx context.Context, in string, out *map[string]api.IPFSPinStatus) error {
*out = map[string]api.IPFSPinStatus{ *out = map[string]api.IPFSPinStatus{
"QmPGDFvBkgWhvzEK9qaTWrWurSwqXNmhnK3hgELPdZZNPa": api.IPFSPinStatusRecursive, "QmPGDFvBkgWhvzEK9qaTWrWurSwqXNmhnK3hgELPdZZNPa": api.IPFSPinStatusRecursive,
"QmUZ13osndQ5uL4tPWHXe3iBgBgq9gfewcBMSCAuMBsDJ6": api.IPFSPinStatusRecursive, "QmUZ13osndQ5uL4tPWHXe3iBgBgq9gfewcBMSCAuMBsDJ6": api.IPFSPinStatusRecursive,

8
ipfscluster.go
View File

@ -1,11 +1,9 @@
// Package ipfscluster implements a wrapper for the IPFS deamon which // Package ipfscluster implements a wrapper for the IPFS deamon which
// allows to orchestrate pinning operations among several IPFS nodes. // allows to orchestrate pinning operations among several IPFS nodes.
// //
// IPFS Cluster uses a go-libp2p-raft to keep a shared state between // IPFS Cluster peers form a separate libp2p swarm. A Cluster peer uses
// the different cluster peers. It also uses LibP2P to enable // multiple Cluster Componenets which perform different tasks like managing
// communication between its different components, which perform different // the underlying IPFS daemons, or providing APIs for external control.
// tasks like managing the underlying IPFS daemons, or providing APIs for
// external control.
package ipfscluster package ipfscluster
import ( import (

16
pintracker/maptracker/maptracker.go
View File

@ -137,8 +137,8 @@ func (mpt *MapPinTracker) pin(op *optracker.Operation) error {
err := mpt.rpcClient.CallContext( err := mpt.rpcClient.CallContext(
ctx, ctx,
"", "",
"Cluster", "IPFSConnector",
"IPFSPin", "Pin",
op.Pin(), op.Pin(),
&struct{}{}, &struct{}{},
) )
@ -156,8 +156,8 @@ func (mpt *MapPinTracker) unpin(op *optracker.Operation) error {
err := mpt.rpcClient.CallContext( err := mpt.rpcClient.CallContext(
ctx, ctx,
"", "",
"Cluster", "IPFSConnector",
"IPFSUnpin", "Unpin",
op.Pin(), op.Pin(),
&struct{}{}, &struct{}{},
) )
@ -270,8 +270,8 @@ func (mpt *MapPinTracker) Sync(ctx context.Context, c cid.Cid) (*api.PinInfo, er
var ips api.IPFSPinStatus var ips api.IPFSPinStatus
err := mpt.rpcClient.Call( err := mpt.rpcClient.Call(
"", "",
"Cluster", "IPFSConnector",
"IPFSPinLsCid", "PinLsCid",
c, c,
&ips, &ips,
) )
@ -300,8 +300,8 @@ func (mpt *MapPinTracker) SyncAll(ctx context.Context) ([]*api.PinInfo, error) {
var results []*api.PinInfo var results []*api.PinInfo
err := mpt.rpcClient.Call( err := mpt.rpcClient.Call(
"", "",
"Cluster", "IPFSConnector",
"IPFSPinLs", "PinLs",
"recursive", "recursive",
&ipsMap, &ipsMap,
) )

10
pintracker/maptracker/maptracker_test.go
View File

@ -23,21 +23,19 @@ var (
ErrUnpinCancelCid = errors.New("should not have received rpc.IPFSUnpin operation") ErrUnpinCancelCid = errors.New("should not have received rpc.IPFSUnpin operation")
) )
type mockService struct { type mockIPFS struct{}
rpcClient *rpc.Client
}
func mockRPCClient(t *testing.T) *rpc.Client { func mockRPCClient(t *testing.T) *rpc.Client {
s := rpc.NewServer(nil, "mock") s := rpc.NewServer(nil, "mock")
c := rpc.NewClientWithServer(nil, "mock", s) c := rpc.NewClientWithServer(nil, "mock", s)
err := s.RegisterName("Cluster", &mockService{}) err := s.RegisterName("IPFSConnector", &mockIPFS{})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
return c return c
} }
func (mock *mockService) IPFSPin(ctx context.Context, in *api.Pin, out *struct{}) error { func (mock *mockIPFS) Pin(ctx context.Context, in *api.Pin, out *struct{}) error {
switch in.Cid.String() { switch in.Cid.String() {
case test.SlowCid1.String(): case test.SlowCid1.String():
time.Sleep(2 * time.Second) time.Sleep(2 * time.Second)
@ -47,7 +45,7 @@ func (mock *mockService) IPFSPin(ctx context.Context, in *api.Pin, out *struct{}
return nil return nil
} }
func (mock *mockService) IPFSUnpin(ctx context.Context, in *api.Pin, out *struct{}) error { func (mock *mockIPFS) Unpin(ctx context.Context, in *api.Pin, out *struct{}) error {
switch in.Cid.String() { switch in.Cid.String() {
case test.SlowCid1.String(): case test.SlowCid1.String():
time.Sleep(2 * time.Second) time.Sleep(2 * time.Second)

23
pintracker/pintracker_test.go
View File

@ -32,21 +32,24 @@ var (
} }
) )
type mockService struct { type mockCluster struct{}
rpcClient *rpc.Client type mockIPFS struct{}
}
func mockRPCClient(t testing.TB) *rpc.Client { func mockRPCClient(t testing.TB) *rpc.Client {
s := rpc.NewServer(nil, "mock") s := rpc.NewServer(nil, "mock")
c := rpc.NewClientWithServer(nil, "mock", s) c := rpc.NewClientWithServer(nil, "mock", s)
err := s.RegisterName("Cluster", &mockService{}) err := s.RegisterName("Cluster", &mockCluster{})
if err != nil {
t.Fatal(err)
}
err = s.RegisterName("IPFSConnector", &mockIPFS{})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
return c return c
} }
func (mock *mockService) IPFSPin(ctx context.Context, in *api.Pin, out *struct{}) error { func (mock *mockIPFS) Pin(ctx context.Context, in *api.Pin, out *struct{}) error {
c := in.Cid c := in.Cid
switch c.String() { switch c.String() {
case test.SlowCid1.String(): case test.SlowCid1.String():
@ -57,7 +60,7 @@ func (mock *mockService) IPFSPin(ctx context.Context, in *api.Pin, out *struct{}
return nil return nil
} }
func (mock *mockService) IPFSPinLsCid(ctx context.Context, in cid.Cid, out *api.IPFSPinStatus) error { func (mock *mockIPFS) PinLsCid(ctx context.Context, in cid.Cid, out *api.IPFSPinStatus) error {
switch in.String() { switch in.String() {
case test.Cid1.String(), test.Cid2.String(): case test.Cid1.String(), test.Cid2.String():
*out = api.IPFSPinStatusRecursive *out = api.IPFSPinStatusRecursive
@ -70,7 +73,7 @@ func (mock *mockService) IPFSPinLsCid(ctx context.Context, in cid.Cid, out *api.
return nil return nil
} }
func (mock *mockService) IPFSUnpin(ctx context.Context, in *api.Pin, out *struct{}) error { func (mock *mockIPFS) Unpin(ctx context.Context, in *api.Pin, out *struct{}) error {
switch in.Cid.String() { switch in.Cid.String() {
case test.SlowCid1.String(): case test.SlowCid1.String():
time.Sleep(3 * time.Second) time.Sleep(3 * time.Second)
@ -80,7 +83,7 @@ func (mock *mockService) IPFSUnpin(ctx context.Context, in *api.Pin, out *struct
return nil return nil
} }
func (mock *mockService) IPFSPinLs(ctx context.Context, in string, out *map[string]api.IPFSPinStatus) error { func (mock *mockIPFS) PinLs(ctx context.Context, in string, out *map[string]api.IPFSPinStatus) error {
m := map[string]api.IPFSPinStatus{ m := map[string]api.IPFSPinStatus{
test.Cid1.String(): api.IPFSPinStatusRecursive, test.Cid1.String(): api.IPFSPinStatusRecursive,
} }
@ -88,7 +91,7 @@ func (mock *mockService) IPFSPinLs(ctx context.Context, in string, out *map[stri
return nil return nil
} }
func (mock *mockService) Pins(ctx context.Context, in struct{}, out *[]*api.Pin) error { func (mock *mockCluster) Pins(ctx context.Context, in struct{}, out *[]*api.Pin) error {
*out = []*api.Pin{ *out = []*api.Pin{
api.PinWithOpts(test.Cid1, pinOpts), api.PinWithOpts(test.Cid1, pinOpts),
api.PinWithOpts(test.Cid3, pinOpts), api.PinWithOpts(test.Cid3, pinOpts),
@ -96,7 +99,7 @@ func (mock *mockService) Pins(ctx context.Context, in struct{}, out *[]*api.Pin)
return nil return nil
} }
func (mock *mockService) PinGet(ctx context.Context, in cid.Cid, out *api.Pin) error { func (mock *mockCluster) PinGet(ctx context.Context, in cid.Cid, out *api.Pin) error {
switch in.String() { switch in.String() {
case test.ErrorCid.String(): case test.ErrorCid.String():
return errors.New("expected error when using ErrorCid") return errors.New("expected error when using ErrorCid")

20
pintracker/stateless/stateless.go
View File

@ -121,8 +121,8 @@ func (spt *Tracker) pin(op *optracker.Operation) error {
err := spt.rpcClient.CallContext( err := spt.rpcClient.CallContext(
ctx, ctx,
"", "",
"Cluster", "IPFSConnector",
"IPFSPin", "Pin",
op.Pin(), op.Pin(),
&struct{}{}, &struct{}{},
) )
@ -140,8 +140,8 @@ func (spt *Tracker) unpin(op *optracker.Operation) error {
err := spt.rpcClient.CallContext( err := spt.rpcClient.CallContext(
ctx, ctx,
"", "",
"Cluster", "IPFSConnector",
"IPFSUnpin", "Unpin",
op.Pin(), op.Pin(),
&struct{}{}, &struct{}{},
) )
@ -352,8 +352,8 @@ func (spt *Tracker) Status(ctx context.Context, c cid.Cid) *api.PinInfo {
var ips api.IPFSPinStatus var ips api.IPFSPinStatus
err = spt.rpcClient.Call( err = spt.rpcClient.Call(
"", "",
"Cluster", "IPFSConnector",
"IPFSPinLsCid", "PinLsCid",
c, c,
&ips, &ips,
) )
@ -462,8 +462,8 @@ func (spt *Tracker) Sync(ctx context.Context, c cid.Cid) (*api.PinInfo, error) {
var ips api.IPFSPinStatus var ips api.IPFSPinStatus
err := spt.rpcClient.Call( err := spt.rpcClient.Call(
"", "",
"Cluster", "IPFSConnector",
"IPFSPinLsCid", "PinLsCid",
c, c,
&ips, &ips,
) )
@ -544,8 +544,8 @@ func (spt *Tracker) ipfsStatusAll(ctx context.Context) (map[string]*api.PinInfo,
err := spt.rpcClient.CallContext( err := spt.rpcClient.CallContext(
ctx, ctx,
"", "",
"Cluster", "IPFSConnector",
"IPFSPinLs", "PinLs",
"recursive", "recursive",
&ipsMap, &ipsMap,
) )

24
pintracker/stateless/stateless_test.go
View File

@ -25,21 +25,25 @@ var (
} }
) )
type mockService struct { type mockCluster struct{}
rpcClient *rpc.Client
} type mockIPFS struct{}
func mockRPCClient(t *testing.T) *rpc.Client { func mockRPCClient(t *testing.T) *rpc.Client {
s := rpc.NewServer(nil, "mock") s := rpc.NewServer(nil, "mock")
c := rpc.NewClientWithServer(nil, "mock", s) c := rpc.NewClientWithServer(nil, "mock", s)
err := s.RegisterName("Cluster", &mockService{}) err := s.RegisterName("Cluster", &mockCluster{})
if err != nil {
t.Fatal(err)
}
err = s.RegisterName("IPFSConnector", &mockIPFS{})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
return c return c
} }
func (mock *mockService) IPFSPin(ctx context.Context, in *api.Pin, out *struct{}) error { func (mock *mockIPFS) Pin(ctx context.Context, in *api.Pin, out *struct{}) error {
switch in.Cid.String() { switch in.Cid.String() {
case test.SlowCid1.String(): case test.SlowCid1.String():
time.Sleep(2 * time.Second) time.Sleep(2 * time.Second)
@ -49,7 +53,7 @@ func (mock *mockService) IPFSPin(ctx context.Context, in *api.Pin, out *struct{}
return nil return nil
} }
func (mock *mockService) IPFSUnpin(ctx context.Context, in *api.Pin, out *struct{}) error { func (mock *mockIPFS) Unpin(ctx context.Context, in *api.Pin, out *struct{}) error {
switch in.Cid.String() { switch in.Cid.String() {
case test.SlowCid1.String(): case test.SlowCid1.String():
time.Sleep(2 * time.Second) time.Sleep(2 * time.Second)
@ -59,7 +63,7 @@ func (mock *mockService) IPFSUnpin(ctx context.Context, in *api.Pin, out *struct
return nil return nil
} }
func (mock *mockService) IPFSPinLs(ctx context.Context, in string, out *map[string]api.IPFSPinStatus) error { func (mock *mockIPFS) PinLs(ctx context.Context, in string, out *map[string]api.IPFSPinStatus) error {
m := map[string]api.IPFSPinStatus{ m := map[string]api.IPFSPinStatus{
test.Cid1.String(): api.IPFSPinStatusRecursive, test.Cid1.String(): api.IPFSPinStatusRecursive,
} }
@ -67,7 +71,7 @@ func (mock *mockService) IPFSPinLs(ctx context.Context, in string, out *map[stri
return nil return nil
} }
func (mock *mockService) IPFSPinLsCid(ctx context.Context, in cid.Cid, out *api.IPFSPinStatus) error { func (mock *mockIPFS) PinLsCid(ctx context.Context, in cid.Cid, out *api.IPFSPinStatus) error {
switch in.String() { switch in.String() {
case test.Cid1.String(), test.Cid2.String(): case test.Cid1.String(), test.Cid2.String():
*out = api.IPFSPinStatusRecursive *out = api.IPFSPinStatusRecursive
@ -77,7 +81,7 @@ func (mock *mockService) IPFSPinLsCid(ctx context.Context, in cid.Cid, out *api.
return nil return nil
} }
func (mock *mockService) Pins(ctx context.Context, in struct{}, out *[]*api.Pin) error { func (mock *mockCluster) Pins(ctx context.Context, in struct{}, out *[]*api.Pin) error {
*out = []*api.Pin{ *out = []*api.Pin{
api.PinWithOpts(test.Cid1, pinOpts), api.PinWithOpts(test.Cid1, pinOpts),
api.PinWithOpts(test.Cid3, pinOpts), api.PinWithOpts(test.Cid3, pinOpts),
@ -85,7 +89,7 @@ func (mock *mockService) Pins(ctx context.Context, in struct{}, out *[]*api.Pin)
return nil return nil
} }
func (mock *mockService) PinGet(ctx context.Context, in cid.Cid, out *api.Pin) error { func (mock *mockCluster) PinGet(ctx context.Context, in cid.Cid, out *api.Pin) error {
switch in.String() { switch in.String() {
case test.ErrorCid.String(): case test.ErrorCid.String():
return errors.New("expected error when using ErrorCid") return errors.New("expected error when using ErrorCid")

276
rpc_api.go
View File

@ -3,49 +3,105 @@ package ipfscluster
import ( import (
"context" "context"
peer "github.com/libp2p/go-libp2p-peer" "github.com/ipfs/ipfs-cluster/api"
"github.com/ipfs/ipfs-cluster/version"
"go.opencensus.io/trace" ocgorpc "github.com/lanzafame/go-libp2p-ocgorpc"
cid "github.com/ipfs/go-cid" cid "github.com/ipfs/go-cid"
rpc "github.com/libp2p/go-libp2p-gorpc"
"github.com/ipfs/ipfs-cluster/api" peer "github.com/libp2p/go-libp2p-peer"
"go.opencensus.io/trace"
) )
// RPCAPI is a go-libp2p-gorpc service which provides the internal ipfs-cluster // newRPCServer returns a new RPC Server for Cluster.
// API, which enables components and cluster peers to communicate and func newRPCServer(c *Cluster) (*rpc.Server, error) {
// request actions from each other. var s *rpc.Server
// if c.config.Tracing {
// The RPC API methods are usually redirects to the actual methods in s = rpc.NewServer(
// the different components of ipfs-cluster, with very little added logic. c.host,
// Refer to documentation on those methods for details on their behaviour. version.RPCProtocol,
type RPCAPI struct { rpc.WithServerStatsHandler(&ocgorpc.ServerHandler{}),
)
} else {
s = rpc.NewServer(c.host, version.RPCProtocol)
}
err := s.RegisterName("Cluster", &ClusterRPCAPI{c})
if err != nil {
return nil, err
}
err = s.RegisterName("PinTracker", &PinTrackerRPCAPI{c.tracker})
if err != nil {
return nil, err
}
err = s.RegisterName("IPFSConnector", &IPFSConnectorRPCAPI{c.ipfs})
if err != nil {
return nil, err
}
err = s.RegisterName("Consensus", &ConsensusRPCAPI{c.consensus})
if err != nil {
return nil, err
}
err = s.RegisterName("PeerMonitor", &PeerMonitorRPCAPI{c.monitor})
if err != nil {
return nil, err
}
return s, nil
}
// ClusterRPCAPI is a go-libp2p-gorpc service which provides the internal peer
// API for the main cluster component.
type ClusterRPCAPI struct {
c *Cluster c *Cluster
} }
// PinTrackerRPCAPI is a go-libp2p-gorpc service which provides the internal
// peer API for the PinTracker component.
type PinTrackerRPCAPI struct {
tracker PinTracker
}
// IPFSConnectorRPCAPI is a go-libp2p-gorpc service which provides the
// internal peer API for the IPFSConnector component.
type IPFSConnectorRPCAPI struct {
ipfs IPFSConnector
}
// ConsensusRPCAPI is a go-libp2p-gorpc service which provides the
// internal peer API for the Consensus component.
type ConsensusRPCAPI struct {
cons Consensus
}
// PeerMonitorRPCAPI is a go-libp2p-gorpc service which provides the
// internal peer API for the PeerMonitor component.
type PeerMonitorRPCAPI struct {
mon PeerMonitor
}
/* /*
Cluster components methods Cluster component methods
*/ */
// ID runs Cluster.ID() // ID runs Cluster.ID()
func (rpcapi *RPCAPI) ID(ctx context.Context, in struct{}, out *api.ID) error { func (rpcapi *ClusterRPCAPI) ID(ctx context.Context, in struct{}, out *api.ID) error {
id := rpcapi.c.ID(ctx) id := rpcapi.c.ID(ctx)
*out = *id *out = *id
return nil return nil
} }
// Pin runs Cluster.Pin(). // Pin runs Cluster.Pin().
func (rpcapi *RPCAPI) Pin(ctx context.Context, in *api.Pin, out *struct{}) error { func (rpcapi *ClusterRPCAPI) Pin(ctx context.Context, in *api.Pin, out *struct{}) error {
return rpcapi.c.Pin(ctx, in) return rpcapi.c.Pin(ctx, in)
} }
// Unpin runs Cluster.Unpin(). // Unpin runs Cluster.Unpin().
func (rpcapi *RPCAPI) Unpin(ctx context.Context, in *api.Pin, out *struct{}) error { func (rpcapi *ClusterRPCAPI) Unpin(ctx context.Context, in *api.Pin, out *struct{}) error {
return rpcapi.c.Unpin(ctx, in.Cid) return rpcapi.c.Unpin(ctx, in.Cid)
} }
// PinPath resolves path into a cid and runs Cluster.Pin(). // PinPath resolves path into a cid and runs Cluster.Pin().
func (rpcapi *RPCAPI) PinPath(ctx context.Context, in *api.PinPath, out *api.Pin) error { func (rpcapi *ClusterRPCAPI) PinPath(ctx context.Context, in *api.PinPath, out *api.Pin) error {
pin, err := rpcapi.c.PinPath(ctx, in) pin, err := rpcapi.c.PinPath(ctx, in)
if err != nil { if err != nil {
return err return err
@ -55,7 +111,7 @@ func (rpcapi *RPCAPI) PinPath(ctx context.Context, in *api.PinPath, out *api.Pin
} }
// UnpinPath resolves path into a cid and runs Cluster.Unpin(). // UnpinPath resolves path into a cid and runs Cluster.Unpin().
func (rpcapi *RPCAPI) UnpinPath(ctx context.Context, in *api.PinPath, out *api.Pin) error { func (rpcapi *ClusterRPCAPI) UnpinPath(ctx context.Context, in *api.PinPath, out *api.Pin) error {
pin, err := rpcapi.c.UnpinPath(ctx, in.Path) pin, err := rpcapi.c.UnpinPath(ctx, in.Path)
if err != nil { if err != nil {
return err return err
@ -65,7 +121,7 @@ func (rpcapi *RPCAPI) UnpinPath(ctx context.Context, in *api.PinPath, out *api.P
} }
// Pins runs Cluster.Pins(). // Pins runs Cluster.Pins().
func (rpcapi *RPCAPI) Pins(ctx context.Context, in struct{}, out *[]*api.Pin) error { func (rpcapi *ClusterRPCAPI) Pins(ctx context.Context, in struct{}, out *[]*api.Pin) error {
cidList, err := rpcapi.c.Pins(ctx) cidList, err := rpcapi.c.Pins(ctx)
if err != nil { if err != nil {
return err return err
@ -75,7 +131,7 @@ func (rpcapi *RPCAPI) Pins(ctx context.Context, in struct{}, out *[]*api.Pin) er
} }
// PinGet runs Cluster.PinGet(). // PinGet runs Cluster.PinGet().
func (rpcapi *RPCAPI) PinGet(ctx context.Context, in cid.Cid, out *api.Pin) error { func (rpcapi *ClusterRPCAPI) PinGet(ctx context.Context, in cid.Cid, out *api.Pin) error {
pin, err := rpcapi.c.PinGet(ctx, in) pin, err := rpcapi.c.PinGet(ctx, in)
if err != nil { if err != nil {
return err return err
@ -85,7 +141,7 @@ func (rpcapi *RPCAPI) PinGet(ctx context.Context, in cid.Cid, out *api.Pin) erro
} }
// Version runs Cluster.Version(). // Version runs Cluster.Version().
func (rpcapi *RPCAPI) Version(ctx context.Context, in struct{}, out *api.Version) error { func (rpcapi *ClusterRPCAPI) Version(ctx context.Context, in struct{}, out *api.Version) error {
*out = api.Version{ *out = api.Version{
Version: rpcapi.c.Version(), Version: rpcapi.c.Version(),
} }
@ -93,13 +149,13 @@ func (rpcapi *RPCAPI) Version(ctx context.Context, in struct{}, out *api.Version
} }
// Peers runs Cluster.Peers(). // Peers runs Cluster.Peers().
func (rpcapi *RPCAPI) Peers(ctx context.Context, in struct{}, out *[]*api.ID) error { func (rpcapi *ClusterRPCAPI) Peers(ctx context.Context, in struct{}, out *[]*api.ID) error {
*out = rpcapi.c.Peers(ctx) *out = rpcapi.c.Peers(ctx)
return nil return nil
} }
// PeerAdd runs Cluster.PeerAdd(). // PeerAdd runs Cluster.PeerAdd().
func (rpcapi *RPCAPI) PeerAdd(ctx context.Context, in peer.ID, out *api.ID) error { func (rpcapi *ClusterRPCAPI) PeerAdd(ctx context.Context, in peer.ID, out *api.ID) error {
id, err := rpcapi.c.PeerAdd(ctx, in) id, err := rpcapi.c.PeerAdd(ctx, in)
if err != nil { if err != nil {
return err return err
@ -109,7 +165,7 @@ func (rpcapi *RPCAPI) PeerAdd(ctx context.Context, in peer.ID, out *api.ID) erro
} }
// ConnectGraph runs Cluster.GetConnectGraph(). // ConnectGraph runs Cluster.GetConnectGraph().
func (rpcapi *RPCAPI) ConnectGraph(ctx context.Context, in struct{}, out *api.ConnectGraph) error { func (rpcapi *ClusterRPCAPI) ConnectGraph(ctx context.Context, in struct{}, out *api.ConnectGraph) error {
graph, err := rpcapi.c.ConnectGraph() graph, err := rpcapi.c.ConnectGraph()
if err != nil { if err != nil {
return err return err
@ -119,17 +175,17 @@ func (rpcapi *RPCAPI) ConnectGraph(ctx context.Context, in struct{}, out *api.Co
} }
// PeerRemove runs Cluster.PeerRm(). // PeerRemove runs Cluster.PeerRm().
func (rpcapi *RPCAPI) PeerRemove(ctx context.Context, in peer.ID, out *struct{}) error { func (rpcapi *ClusterRPCAPI) PeerRemove(ctx context.Context, in peer.ID, out *struct{}) error {
return rpcapi.c.PeerRemove(ctx, in) return rpcapi.c.PeerRemove(ctx, in)
} }
// Join runs Cluster.Join(). // Join runs Cluster.Join().
func (rpcapi *RPCAPI) Join(ctx context.Context, in api.Multiaddr, out *struct{}) error { func (rpcapi *ClusterRPCAPI) Join(ctx context.Context, in api.Multiaddr, out *struct{}) error {
return rpcapi.c.Join(ctx, in.Value()) return rpcapi.c.Join(ctx, in.Value())
} }
// StatusAll runs Cluster.StatusAll(). // StatusAll runs Cluster.StatusAll().
func (rpcapi *RPCAPI) StatusAll(ctx context.Context, in struct{}, out *[]*api.GlobalPinInfo) error { func (rpcapi *ClusterRPCAPI) StatusAll(ctx context.Context, in struct{}, out *[]*api.GlobalPinInfo) error {
pinfos, err := rpcapi.c.StatusAll(ctx) pinfos, err := rpcapi.c.StatusAll(ctx)
if err != nil { if err != nil {
return err return err
@ -139,14 +195,14 @@ func (rpcapi *RPCAPI) StatusAll(ctx context.Context, in struct{}, out *[]*api.Gl
} }
// StatusAllLocal runs Cluster.StatusAllLocal(). // StatusAllLocal runs Cluster.StatusAllLocal().
func (rpcapi *RPCAPI) StatusAllLocal(ctx context.Context, in struct{}, out *[]*api.PinInfo) error { func (rpcapi *ClusterRPCAPI) StatusAllLocal(ctx context.Context, in struct{}, out *[]*api.PinInfo) error {
pinfos := rpcapi.c.StatusAllLocal(ctx) pinfos := rpcapi.c.StatusAllLocal(ctx)
*out = pinfos *out = pinfos
return nil return nil
} }
// Status runs Cluster.Status(). // Status runs Cluster.Status().
func (rpcapi *RPCAPI) Status(ctx context.Context, in cid.Cid, out *api.GlobalPinInfo) error { func (rpcapi *ClusterRPCAPI) Status(ctx context.Context, in cid.Cid, out *api.GlobalPinInfo) error {
pinfo, err := rpcapi.c.Status(ctx, in) pinfo, err := rpcapi.c.Status(ctx, in)
if err != nil { if err != nil {
return err return err
@ -156,14 +212,14 @@ func (rpcapi *RPCAPI) Status(ctx context.Context, in cid.Cid, out *api.GlobalPin
} }
// StatusLocal runs Cluster.StatusLocal(). // StatusLocal runs Cluster.StatusLocal().
func (rpcapi *RPCAPI) StatusLocal(ctx context.Context, in cid.Cid, out *api.PinInfo) error { func (rpcapi *ClusterRPCAPI) StatusLocal(ctx context.Context, in cid.Cid, out *api.PinInfo) error {
pinfo := rpcapi.c.StatusLocal(ctx, in) pinfo := rpcapi.c.StatusLocal(ctx, in)
*out = *pinfo *out = *pinfo
return nil return nil
} }
// SyncAll runs Cluster.SyncAll(). // SyncAll runs Cluster.SyncAll().
func (rpcapi *RPCAPI) SyncAll(ctx context.Context, in struct{}, out *[]*api.GlobalPinInfo) error { func (rpcapi *ClusterRPCAPI) SyncAll(ctx context.Context, in struct{}, out *[]*api.GlobalPinInfo) error {
pinfos, err := rpcapi.c.SyncAll(ctx) pinfos, err := rpcapi.c.SyncAll(ctx)
if err != nil { if err != nil {
return err return err
@ -173,7 +229,7 @@ func (rpcapi *RPCAPI) SyncAll(ctx context.Context, in struct{}, out *[]*api.Glob
} }
// SyncAllLocal runs Cluster.SyncAllLocal(). // SyncAllLocal runs Cluster.SyncAllLocal().
func (rpcapi *RPCAPI) SyncAllLocal(ctx context.Context, in struct{}, out *[]*api.PinInfo) error { func (rpcapi *ClusterRPCAPI) SyncAllLocal(ctx context.Context, in struct{}, out *[]*api.PinInfo) error {
pinfos, err := rpcapi.c.SyncAllLocal(ctx) pinfos, err := rpcapi.c.SyncAllLocal(ctx)
if err != nil { if err != nil {
return err return err
@ -183,7 +239,7 @@ func (rpcapi *RPCAPI) SyncAllLocal(ctx context.Context, in struct{}, out *[]*api
} }
// Sync runs Cluster.Sync(). // Sync runs Cluster.Sync().
func (rpcapi *RPCAPI) Sync(ctx context.Context, in cid.Cid, out *api.GlobalPinInfo) error { func (rpcapi *ClusterRPCAPI) Sync(ctx context.Context, in cid.Cid, out *api.GlobalPinInfo) error {
pinfo, err := rpcapi.c.Sync(ctx, in) pinfo, err := rpcapi.c.Sync(ctx, in)
if err != nil { if err != nil {
return err return err
@ -193,7 +249,7 @@ func (rpcapi *RPCAPI) Sync(ctx context.Context, in cid.Cid, out *api.GlobalPinIn
} }
// SyncLocal runs Cluster.SyncLocal(). // SyncLocal runs Cluster.SyncLocal().
func (rpcapi *RPCAPI) SyncLocal(ctx context.Context, in cid.Cid, out *api.PinInfo) error { func (rpcapi *ClusterRPCAPI) SyncLocal(ctx context.Context, in cid.Cid, out *api.PinInfo) error {
pinfo, err := rpcapi.c.SyncLocal(ctx, in) pinfo, err := rpcapi.c.SyncLocal(ctx, in)
if err != nil { if err != nil {
return err return err
@ -203,7 +259,7 @@ func (rpcapi *RPCAPI) SyncLocal(ctx context.Context, in cid.Cid, out *api.PinInf
} }
// RecoverAllLocal runs Cluster.RecoverAllLocal(). // RecoverAllLocal runs Cluster.RecoverAllLocal().
func (rpcapi *RPCAPI) RecoverAllLocal(ctx context.Context, in struct{}, out *[]*api.PinInfo) error { func (rpcapi *ClusterRPCAPI) RecoverAllLocal(ctx context.Context, in struct{}, out *[]*api.PinInfo) error {
pinfos, err := rpcapi.c.RecoverAllLocal(ctx) pinfos, err := rpcapi.c.RecoverAllLocal(ctx)
if err != nil { if err != nil {
return err return err
@ -213,7 +269,7 @@ func (rpcapi *RPCAPI) RecoverAllLocal(ctx context.Context, in struct{}, out *[]*
} }
// Recover runs Cluster.Recover(). // Recover runs Cluster.Recover().
func (rpcapi *RPCAPI) Recover(ctx context.Context, in cid.Cid, out *api.GlobalPinInfo) error { func (rpcapi *ClusterRPCAPI) Recover(ctx context.Context, in cid.Cid, out *api.GlobalPinInfo) error {
pinfo, err := rpcapi.c.Recover(ctx, in) pinfo, err := rpcapi.c.Recover(ctx, in)
if err != nil { if err != nil {
return err return err
@ -223,7 +279,7 @@ func (rpcapi *RPCAPI) Recover(ctx context.Context, in cid.Cid, out *api.GlobalPi
} }
// RecoverLocal runs Cluster.RecoverLocal(). // RecoverLocal runs Cluster.RecoverLocal().
func (rpcapi *RPCAPI) RecoverLocal(ctx context.Context, in cid.Cid, out *api.PinInfo) error { func (rpcapi *ClusterRPCAPI) RecoverLocal(ctx context.Context, in cid.Cid, out *api.PinInfo) error {
pinfo, err := rpcapi.c.RecoverLocal(ctx, in) pinfo, err := rpcapi.c.RecoverLocal(ctx, in)
if err != nil { if err != nil {
return err return err
@ -234,7 +290,7 @@ func (rpcapi *RPCAPI) RecoverLocal(ctx context.Context, in cid.Cid, out *api.Pin
// BlockAllocate returns allocations for blocks. This is used in the adders. // BlockAllocate returns allocations for blocks. This is used in the adders.
// It's different from pin allocations when ReplicationFactor < 0. // It's different from pin allocations when ReplicationFactor < 0.
func (rpcapi *RPCAPI) BlockAllocate(ctx context.Context, in *api.Pin, out *[]peer.ID) error { func (rpcapi *ClusterRPCAPI) BlockAllocate(ctx context.Context, in *api.Pin, out *[]peer.ID) error {
err := rpcapi.c.setupPin(ctx, in) err := rpcapi.c.setupPin(ctx, in)
if err != nil { if err != nil {
return err return err
@ -272,7 +328,7 @@ func (rpcapi *RPCAPI) BlockAllocate(ctx context.Context, in *api.Pin, out *[]pee
} }
// SendInformerMetric runs Cluster.sendInformerMetric(). // SendInformerMetric runs Cluster.sendInformerMetric().
func (rpcapi *RPCAPI) SendInformerMetric(ctx context.Context, in struct{}, out *api.Metric) error { func (rpcapi *ClusterRPCAPI) SendInformerMetric(ctx context.Context, in struct{}, out *api.Metric) error {
m, err := rpcapi.c.sendInformerMetric(ctx) m, err := rpcapi.c.sendInformerMetric(ctx)
if err != nil { if err != nil {
return err return err
@ -286,41 +342,41 @@ func (rpcapi *RPCAPI) SendInformerMetric(ctx context.Context, in struct{}, out *
*/ */
// Track runs PinTracker.Track(). // Track runs PinTracker.Track().
func (rpcapi *RPCAPI) Track(ctx context.Context, in *api.Pin, out *struct{}) error { func (rpcapi *PinTrackerRPCAPI) Track(ctx context.Context, in *api.Pin, out *struct{}) error {
ctx, span := trace.StartSpan(ctx, "rpc/tracker/Track") ctx, span := trace.StartSpan(ctx, "rpc/tracker/Track")
defer span.End() defer span.End()
return rpcapi.c.tracker.Track(ctx, in) return rpcapi.tracker.Track(ctx, in)
} }
// Untrack runs PinTracker.Untrack(). // Untrack runs PinTracker.Untrack().
func (rpcapi *RPCAPI) Untrack(ctx context.Context, in *api.Pin, out *struct{}) error { func (rpcapi *PinTrackerRPCAPI) Untrack(ctx context.Context, in *api.Pin, out *struct{}) error {
ctx, span := trace.StartSpan(ctx, "rpc/tracker/Untrack") ctx, span := trace.StartSpan(ctx, "rpc/tracker/Untrack")
defer span.End() defer span.End()
return rpcapi.c.tracker.Untrack(ctx, in.Cid) return rpcapi.tracker.Untrack(ctx, in.Cid)
} }
// TrackerStatusAll runs PinTracker.StatusAll(). // StatusAll runs PinTracker.StatusAll().
func (rpcapi *RPCAPI) TrackerStatusAll(ctx context.Context, in struct{}, out *[]*api.PinInfo) error { func (rpcapi *PinTrackerRPCAPI) StatusAll(ctx context.Context, in struct{}, out *[]*api.PinInfo) error {
ctx, span := trace.StartSpan(ctx, "rpc/tracker/StatusAll") ctx, span := trace.StartSpan(ctx, "rpc/tracker/StatusAll")
defer span.End() defer span.End()
*out = rpcapi.c.tracker.StatusAll(ctx) *out = rpcapi.tracker.StatusAll(ctx)
return nil return nil
} }
// TrackerStatus runs PinTracker.Status(). // Status runs PinTracker.Status().
func (rpcapi *RPCAPI) TrackerStatus(ctx context.Context, in cid.Cid, out *api.PinInfo) error { func (rpcapi *PinTrackerRPCAPI) Status(ctx context.Context, in cid.Cid, out *api.PinInfo) error {
ctx, span := trace.StartSpan(ctx, "rpc/tracker/Status") ctx, span := trace.StartSpan(ctx, "rpc/tracker/Status")
defer span.End() defer span.End()
pinfo := rpcapi.c.tracker.Status(ctx, in) pinfo := rpcapi.tracker.Status(ctx, in)
*out = *pinfo *out = *pinfo
return nil return nil
} }
// TrackerRecoverAll runs PinTracker.RecoverAll().f // RecoverAll runs PinTracker.RecoverAll().f
func (rpcapi *RPCAPI) TrackerRecoverAll(ctx context.Context, in struct{}, out *[]*api.PinInfo) error { func (rpcapi *PinTrackerRPCAPI) RecoverAll(ctx context.Context, in struct{}, out *[]*api.PinInfo) error {
ctx, span := trace.StartSpan(ctx, "rpc/tracker/RecoverAll") ctx, span := trace.StartSpan(ctx, "rpc/tracker/RecoverAll")
defer span.End() defer span.End()
pinfos, err := rpcapi.c.tracker.RecoverAll(ctx) pinfos, err := rpcapi.tracker.RecoverAll(ctx)
if err != nil { if err != nil {
return err return err
} }
@ -328,11 +384,11 @@ func (rpcapi *RPCAPI) TrackerRecoverAll(ctx context.Context, in struct{}, out *[
return nil return nil
} }
// TrackerRecover runs PinTracker.Recover(). // Recover runs PinTracker.Recover().
func (rpcapi *RPCAPI) TrackerRecover(ctx context.Context, in cid.Cid, out *api.PinInfo) error { func (rpcapi *PinTrackerRPCAPI) Recover(ctx context.Context, in cid.Cid, out *api.PinInfo) error {
ctx, span := trace.StartSpan(ctx, "rpc/tracker/Recover") ctx, span := trace.StartSpan(ctx, "rpc/tracker/Recover")
defer span.End() defer span.End()
pinfo, err := rpcapi.c.tracker.Recover(ctx, in) pinfo, err := rpcapi.tracker.Recover(ctx, in)
*out = *pinfo *out = *pinfo
return err return err
} }
@ -341,21 +397,21 @@ func (rpcapi *RPCAPI) TrackerRecover(ctx context.Context, in cid.Cid, out *api.P
IPFS Connector component methods IPFS Connector component methods
*/ */
// IPFSPin runs IPFSConnector.Pin(). // Pin runs IPFSConnector.Pin().
func (rpcapi *RPCAPI) IPFSPin(ctx context.Context, in *api.Pin, out *struct{}) error { func (rpcapi *IPFSConnectorRPCAPI) Pin(ctx context.Context, in *api.Pin, out *struct{}) error {
ctx, span := trace.StartSpan(ctx, "rpc/ipfsconn/IPFSPin") ctx, span := trace.StartSpan(ctx, "rpc/ipfsconn/IPFSPin")
defer span.End() defer span.End()
return rpcapi.c.ipfs.Pin(ctx, in.Cid, in.MaxDepth) return rpcapi.ipfs.Pin(ctx, in.Cid, in.MaxDepth)
} }
// IPFSUnpin runs IPFSConnector.Unpin(). // Unpin runs IPFSConnector.Unpin().
func (rpcapi *RPCAPI) IPFSUnpin(ctx context.Context, in *api.Pin, out *struct{}) error { func (rpcapi *IPFSConnectorRPCAPI) Unpin(ctx context.Context, in *api.Pin, out *struct{}) error {
return rpcapi.c.ipfs.Unpin(ctx, in.Cid) return rpcapi.ipfs.Unpin(ctx, in.Cid)
} }
// IPFSPinLsCid runs IPFSConnector.PinLsCid(). // PinLsCid runs IPFSConnector.PinLsCid().
func (rpcapi *RPCAPI) IPFSPinLsCid(ctx context.Context, in cid.Cid, out *api.IPFSPinStatus) error { func (rpcapi *IPFSConnectorRPCAPI) PinLsCid(ctx context.Context, in cid.Cid, out *api.IPFSPinStatus) error {
b, err := rpcapi.c.ipfs.PinLsCid(ctx, in) b, err := rpcapi.ipfs.PinLsCid(ctx, in)
if err != nil { if err != nil {
return err return err
} }
@ -363,9 +419,9 @@ func (rpcapi *RPCAPI) IPFSPinLsCid(ctx context.Context, in cid.Cid, out *api.IPF
return nil return nil
} }
// IPFSPinLs runs IPFSConnector.PinLs(). // PinLs runs IPFSConnector.PinLs().
func (rpcapi *RPCAPI) IPFSPinLs(ctx context.Context, in string, out *map[string]api.IPFSPinStatus) error { func (rpcapi *IPFSConnectorRPCAPI) PinLs(ctx context.Context, in string, out *map[string]api.IPFSPinStatus) error {
m, err := rpcapi.c.ipfs.PinLs(ctx, in) m, err := rpcapi.ipfs.PinLs(ctx, in)
if err != nil { if err != nil {
return err return err
} }
@ -373,15 +429,15 @@ func (rpcapi *RPCAPI) IPFSPinLs(ctx context.Context, in string, out *map[string]
return nil return nil
} }
// IPFSConnectSwarms runs IPFSConnector.ConnectSwarms(). // ConnectSwarms runs IPFSConnector.ConnectSwarms().
func (rpcapi *RPCAPI) IPFSConnectSwarms(ctx context.Context, in struct{}, out *struct{}) error { func (rpcapi *IPFSConnectorRPCAPI) ConnectSwarms(ctx context.Context, in struct{}, out *struct{}) error {
err := rpcapi.c.ipfs.ConnectSwarms(ctx) err := rpcapi.ipfs.ConnectSwarms(ctx)
return err return err
} }
// IPFSConfigKey runs IPFSConnector.ConfigKey(). // ConfigKey runs IPFSConnector.ConfigKey().
func (rpcapi *RPCAPI) IPFSConfigKey(ctx context.Context, in string, out *interface{}) error { func (rpcapi *IPFSConnectorRPCAPI) ConfigKey(ctx context.Context, in string, out *interface{}) error {
res, err := rpcapi.c.ipfs.ConfigKey(in) res, err := rpcapi.ipfs.ConfigKey(in)
if err != nil { if err != nil {
return err return err
} }
@ -389,9 +445,9 @@ func (rpcapi *RPCAPI) IPFSConfigKey(ctx context.Context, in string, out *interfa
return nil return nil
} }
// IPFSRepoStat runs IPFSConnector.RepoStat(). // RepoStat runs IPFSConnector.RepoStat().
func (rpcapi *RPCAPI) IPFSRepoStat(ctx context.Context, in struct{}, out *api.IPFSRepoStat) error { func (rpcapi *IPFSConnectorRPCAPI) RepoStat(ctx context.Context, in struct{}, out *api.IPFSRepoStat) error {
res, err := rpcapi.c.ipfs.RepoStat(ctx) res, err := rpcapi.ipfs.RepoStat(ctx)
if err != nil { if err != nil {
return err return err
} }
@ -399,9 +455,9 @@ func (rpcapi *RPCAPI) IPFSRepoStat(ctx context.Context, in struct{}, out *api.IP
return err return err
} }
// IPFSSwarmPeers runs IPFSConnector.SwarmPeers(). // SwarmPeers runs IPFSConnector.SwarmPeers().
func (rpcapi *RPCAPI) IPFSSwarmPeers(ctx context.Context, in struct{}, out *[]peer.ID) error { func (rpcapi *IPFSConnectorRPCAPI) SwarmPeers(ctx context.Context, in struct{}, out *[]peer.ID) error {
res, err := rpcapi.c.ipfs.SwarmPeers(ctx) res, err := rpcapi.ipfs.SwarmPeers(ctx)
if err != nil { if err != nil {
return err return err
} }
@ -409,14 +465,14 @@ func (rpcapi *RPCAPI) IPFSSwarmPeers(ctx context.Context, in struct{}, out *[]pe
return nil return nil
} }
// IPFSBlockPut runs IPFSConnector.BlockPut(). // BlockPut runs IPFSConnector.BlockPut().
func (rpcapi *RPCAPI) IPFSBlockPut(ctx context.Context, in *api.NodeWithMeta, out *struct{}) error { func (rpcapi *IPFSConnectorRPCAPI) BlockPut(ctx context.Context, in *api.NodeWithMeta, out *struct{}) error {
return rpcapi.c.ipfs.BlockPut(ctx, in) return rpcapi.ipfs.BlockPut(ctx, in)
} }
// IPFSBlockGet runs IPFSConnector.BlockGet(). // BlockGet runs IPFSConnector.BlockGet().
func (rpcapi *RPCAPI) IPFSBlockGet(ctx context.Context, in cid.Cid, out *[]byte) error { func (rpcapi *IPFSConnectorRPCAPI) BlockGet(ctx context.Context, in cid.Cid, out *[]byte) error {
res, err := rpcapi.c.ipfs.BlockGet(ctx, in) res, err := rpcapi.ipfs.BlockGet(ctx, in)
if err != nil { if err != nil {
return err return err
} }
@ -424,9 +480,9 @@ func (rpcapi *RPCAPI) IPFSBlockGet(ctx context.Context, in cid.Cid, out *[]byte)
return nil return nil
} }
// IPFSResolve runs IPFSConnector.Resolve(). // Resolve runs IPFSConnector.Resolve().
func (rpcapi *RPCAPI) IPFSResolve(ctx context.Context, in string, out *cid.Cid) error { func (rpcapi *IPFSConnectorRPCAPI) Resolve(ctx context.Context, in string, out *cid.Cid) error {
c, err := rpcapi.c.ipfs.Resolve(ctx, in) c, err := rpcapi.ipfs.Resolve(ctx, in)
if err != nil { if err != nil {
return err return err
} }
@ -438,37 +494,37 @@ func (rpcapi *RPCAPI) IPFSResolve(ctx context.Context, in string, out *cid.Cid)
Consensus component methods Consensus component methods
*/ */
// ConsensusLogPin runs Consensus.LogPin(). // LogPin runs Consensus.LogPin().
func (rpcapi *RPCAPI) ConsensusLogPin(ctx context.Context, in *api.Pin, out *struct{}) error { func (rpcapi *ConsensusRPCAPI) LogPin(ctx context.Context, in *api.Pin, out *struct{}) error {
ctx, span := trace.StartSpan(ctx, "rpc/consensus/LogPin") ctx, span := trace.StartSpan(ctx, "rpc/consensus/LogPin")
defer span.End() defer span.End()
return rpcapi.c.consensus.LogPin(ctx, in) return rpcapi.cons.LogPin(ctx, in)
} }
// ConsensusLogUnpin runs Consensus.LogUnpin(). // LogUnpin runs Consensus.LogUnpin().
func (rpcapi *RPCAPI) ConsensusLogUnpin(ctx context.Context, in *api.Pin, out *struct{}) error { func (rpcapi *ConsensusRPCAPI) LogUnpin(ctx context.Context, in *api.Pin, out *struct{}) error {
ctx, span := trace.StartSpan(ctx, "rpc/consensus/LogUnpin") ctx, span := trace.StartSpan(ctx, "rpc/consensus/LogUnpin")
defer span.End() defer span.End()
return rpcapi.c.consensus.LogUnpin(ctx, in) return rpcapi.cons.LogUnpin(ctx, in)
} }
// ConsensusAddPeer runs Consensus.AddPeer(). // AddPeer runs Consensus.AddPeer().
func (rpcapi *RPCAPI) ConsensusAddPeer(ctx context.Context, in peer.ID, out *struct{}) error { func (rpcapi *ConsensusRPCAPI) AddPeer(ctx context.Context, in peer.ID, out *struct{}) error {
ctx, span := trace.StartSpan(ctx, "rpc/consensus/AddPeer") ctx, span := trace.StartSpan(ctx, "rpc/consensus/AddPeer")
defer span.End() defer span.End()
return rpcapi.c.consensus.AddPeer(ctx, in) return rpcapi.cons.AddPeer(ctx, in)
} }
// ConsensusRmPeer runs Consensus.RmPeer(). // RmPeer runs Consensus.RmPeer().
func (rpcapi *RPCAPI) ConsensusRmPeer(ctx context.Context, in peer.ID, out *struct{}) error { func (rpcapi *ConsensusRPCAPI) RmPeer(ctx context.Context, in peer.ID, out *struct{}) error {
ctx, span := trace.StartSpan(ctx, "rpc/consensus/RmPeer") ctx, span := trace.StartSpan(ctx, "rpc/consensus/RmPeer")
defer span.End() defer span.End()
return rpcapi.c.consensus.RmPeer(ctx, in) return rpcapi.cons.RmPeer(ctx, in)
} }
// ConsensusPeers runs Consensus.Peers(). // Peers runs Consensus.Peers().
func (rpcapi *RPCAPI) ConsensusPeers(ctx context.Context, in struct{}, out *[]peer.ID) error { func (rpcapi *ConsensusRPCAPI) Peers(ctx context.Context, in struct{}, out *[]peer.ID) error {
peers, err := rpcapi.c.consensus.Peers(ctx) peers, err := rpcapi.cons.Peers(ctx)
if err != nil { if err != nil {
return err return err
} }
@ -480,13 +536,13 @@ func (rpcapi *RPCAPI) ConsensusPeers(ctx context.Context, in struct{}, out *[]pe
PeerMonitor PeerMonitor
*/ */
// PeerMonitorLogMetric runs PeerMonitor.LogMetric(). // LogMetric runs PeerMonitor.LogMetric().
func (rpcapi *RPCAPI) PeerMonitorLogMetric(ctx context.Context, in *api.Metric, out *struct{}) error { func (rpcapi *PeerMonitorRPCAPI) LogMetric(ctx context.Context, in *api.Metric, out *struct{}) error {
return rpcapi.c.monitor.LogMetric(ctx, in) return rpcapi.mon.LogMetric(ctx, in)
} }
// PeerMonitorLatestMetrics runs PeerMonitor.LatestMetrics(). // LatestMetrics runs PeerMonitor.LatestMetrics().
func (rpcapi *RPCAPI) PeerMonitorLatestMetrics(ctx context.Context, in string, out *[]*api.Metric) error { func (rpcapi *PeerMonitorRPCAPI) LatestMetrics(ctx context.Context, in string, out *[]*api.Metric) error {
*out = rpcapi.c.monitor.LatestMetrics(ctx, in) *out = rpcapi.mon.LatestMetrics(ctx, in)
return nil return nil
} }

131
test/rpc_api_mock.go
View File

@ -20,8 +20,6 @@ import (
// fail. // fail.
var ErrBadCid = errors.New("this is an expected error when using ErrorCid") var ErrBadCid = errors.New("this is an expected error when using ErrorCid")
type mockService struct{}
// NewMockRPCClient creates a mock ipfs-cluster RPC server and returns // NewMockRPCClient creates a mock ipfs-cluster RPC server and returns
// a client to it. // a client to it.
func NewMockRPCClient(t testing.TB) *rpc.Client { func NewMockRPCClient(t testing.TB) *rpc.Client {
@ -33,28 +31,51 @@ func NewMockRPCClient(t testing.TB) *rpc.Client {
func NewMockRPCClientWithHost(t testing.TB, h host.Host) *rpc.Client { func NewMockRPCClientWithHost(t testing.TB, h host.Host) *rpc.Client {
s := rpc.NewServer(h, "mock") s := rpc.NewServer(h, "mock")
c := rpc.NewClientWithServer(h, "mock", s) c := rpc.NewClientWithServer(h, "mock", s)
err := s.RegisterName("Cluster", &mockService{}) err := s.RegisterName("Cluster", &mockCluster{})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
err = s.RegisterName("PinTracker", &mockPinTracker{})
if err != nil {
t.Fatal(err)
}
err = s.RegisterName("IPFSConnector", &mockIPFSConnector{})
if err != nil {
t.Fatal(err)
}
err = s.RegisterName("Consensus", &mockConsensus{})
if err != nil {
t.Fatal(err)
}
err = s.RegisterName("PeerMonitor", &mockPeerMonitor{})
if err != nil {
t.Fatal(err)
}
return c return c
} }
func (mock *mockService) Pin(ctx context.Context, in *api.Pin, out *struct{}) error { type mockCluster struct{}
type mockPinTracker struct{}
type mockIPFSConnector struct{}
type mockConsensus struct{}
type mockPeerMonitor struct{}
func (mock *mockCluster) Pin(ctx context.Context, in *api.Pin, out *struct{}) error {
if in.Cid.Equals(ErrorCid) { if in.Cid.Equals(ErrorCid) {
return ErrBadCid return ErrBadCid
} }
return nil return nil
} }
func (mock *mockService) Unpin(ctx context.Context, in *api.Pin, out *struct{}) error { func (mock *mockCluster) Unpin(ctx context.Context, in *api.Pin, out *struct{}) error {
if in.Cid.Equals(ErrorCid) { if in.Cid.Equals(ErrorCid) {
return ErrBadCid return ErrBadCid
} }
return nil return nil
} }
func (mock *mockService) PinPath(ctx context.Context, in *api.PinPath, out *api.Pin) error { func (mock *mockCluster) PinPath(ctx context.Context, in *api.PinPath, out *api.Pin) error {
p, err := gopath.ParsePath(in.Path) p, err := gopath.ParsePath(in.Path)
if err != nil { if err != nil {
return err return err
@ -78,12 +99,12 @@ func (mock *mockService) PinPath(ctx context.Context, in *api.PinPath, out *api.
return nil return nil
} }
func (mock *mockService) UnpinPath(ctx context.Context, in *api.PinPath, out *api.Pin) error { func (mock *mockCluster) UnpinPath(ctx context.Context, in *api.PinPath, out *api.Pin) error {
// Mock-Unpin behaves exactly pin (doing nothing). // Mock-Unpin behaves exactly pin (doing nothing).
return mock.PinPath(ctx, in, out) return mock.PinPath(ctx, in, out)
} }
func (mock *mockService) Pins(ctx context.Context, in struct{}, out *[]*api.Pin) error { func (mock *mockCluster) Pins(ctx context.Context, in struct{}, out *[]*api.Pin) error {
opts := api.PinOptions{ opts := api.PinOptions{
ReplicationFactorMin: -1, ReplicationFactorMin: -1,
ReplicationFactorMax: -1, ReplicationFactorMax: -1,
@ -97,7 +118,7 @@ func (mock *mockService) Pins(ctx context.Context, in struct{}, out *[]*api.Pin)
return nil return nil
} }
func (mock *mockService) PinGet(ctx context.Context, in cid.Cid, out *api.Pin) error { func (mock *mockCluster) PinGet(ctx context.Context, in cid.Cid, out *api.Pin) error {
switch in.String() { switch in.String() {
case ErrorCid.String(): case ErrorCid.String():
return errors.New("this is an expected error when using ErrorCid") return errors.New("this is an expected error when using ErrorCid")
@ -118,7 +139,7 @@ func (mock *mockService) PinGet(ctx context.Context, in cid.Cid, out *api.Pin) e
return nil return nil
} }
func (mock *mockService) ID(ctx context.Context, in struct{}, out *api.ID) error { func (mock *mockCluster) ID(ctx context.Context, in struct{}, out *api.ID) error {
//_, pubkey, _ := crypto.GenerateKeyPair( //_, pubkey, _ := crypto.GenerateKeyPair(
// DefaultConfigCrypto, // DefaultConfigCrypto,
// DefaultConfigKeyLength) // DefaultConfigKeyLength)
@ -136,14 +157,14 @@ func (mock *mockService) ID(ctx context.Context, in struct{}, out *api.ID) error
return nil return nil
} }
func (mock *mockService) Version(ctx context.Context, in struct{}, out *api.Version) error { func (mock *mockCluster) Version(ctx context.Context, in struct{}, out *api.Version) error {
*out = api.Version{ *out = api.Version{
Version: "0.0.mock", Version: "0.0.mock",
} }
return nil return nil
} }
func (mock *mockService) Peers(ctx context.Context, in struct{}, out *[]*api.ID) error { func (mock *mockCluster) Peers(ctx context.Context, in struct{}, out *[]*api.ID) error {
id := &api.ID{} id := &api.ID{}
mock.ID(ctx, in, id) mock.ID(ctx, in, id)
@ -151,18 +172,18 @@ func (mock *mockService) Peers(ctx context.Context, in struct{}, out *[]*api.ID)
return nil return nil
} }
func (mock *mockService) PeerAdd(ctx context.Context, in peer.ID, out *api.ID) error { func (mock *mockCluster) PeerAdd(ctx context.Context, in peer.ID, out *api.ID) error {
id := api.ID{} id := api.ID{}
mock.ID(ctx, struct{}{}, &id) mock.ID(ctx, struct{}{}, &id)
*out = id *out = id
return nil return nil
} }
func (mock *mockService) PeerRemove(ctx context.Context, in peer.ID, out *struct{}) error { func (mock *mockCluster) PeerRemove(ctx context.Context, in peer.ID, out *struct{}) error {
return nil return nil
} }
func (mock *mockService) ConnectGraph(ctx context.Context, in struct{}, out *api.ConnectGraph) error { func (mock *mockCluster) ConnectGraph(ctx context.Context, in struct{}, out *api.ConnectGraph) error {
*out = api.ConnectGraph{ *out = api.ConnectGraph{
ClusterID: PeerID1, ClusterID: PeerID1,
IPFSLinks: map[string][]peer.ID{ IPFSLinks: map[string][]peer.ID{
@ -184,7 +205,7 @@ func (mock *mockService) ConnectGraph(ctx context.Context, in struct{}, out *api
return nil return nil
} }
func (mock *mockService) StatusAll(ctx context.Context, in struct{}, out *[]*api.GlobalPinInfo) error { func (mock *mockCluster) StatusAll(ctx context.Context, in struct{}, out *[]*api.GlobalPinInfo) error {
pid := peer.IDB58Encode(PeerID1) pid := peer.IDB58Encode(PeerID1)
*out = []*api.GlobalPinInfo{ *out = []*api.GlobalPinInfo{
{ {
@ -224,11 +245,11 @@ func (mock *mockService) StatusAll(ctx context.Context, in struct{}, out *[]*api
return nil return nil
} }
func (mock *mockService) StatusAllLocal(ctx context.Context, in struct{}, out *[]*api.PinInfo) error { func (mock *mockCluster) StatusAllLocal(ctx context.Context, in struct{}, out *[]*api.PinInfo) error {
return mock.TrackerStatusAll(ctx, in, out) return (&mockPinTracker{}).StatusAll(ctx, in, out)
} }
func (mock *mockService) Status(ctx context.Context, in cid.Cid, out *api.GlobalPinInfo) error { func (mock *mockCluster) Status(ctx context.Context, in cid.Cid, out *api.GlobalPinInfo) error {
if in.Equals(ErrorCid) { if in.Equals(ErrorCid) {
return ErrBadCid return ErrBadCid
} }
@ -246,39 +267,39 @@ func (mock *mockService) Status(ctx context.Context, in cid.Cid, out *api.Global
return nil return nil
} }
func (mock *mockService) StatusLocal(ctx context.Context, in cid.Cid, out *api.PinInfo) error { func (mock *mockCluster) StatusLocal(ctx context.Context, in cid.Cid, out *api.PinInfo) error {
return mock.TrackerStatus(ctx, in, out) return (&mockPinTracker{}).Status(ctx, in, out)
} }
func (mock *mockService) SyncAll(ctx context.Context, in struct{}, out *[]*api.GlobalPinInfo) error { func (mock *mockCluster) SyncAll(ctx context.Context, in struct{}, out *[]*api.GlobalPinInfo) error {
return mock.StatusAll(ctx, in, out) return mock.StatusAll(ctx, in, out)
} }
func (mock *mockService) SyncAllLocal(ctx context.Context, in struct{}, out *[]*api.PinInfo) error { func (mock *mockCluster) SyncAllLocal(ctx context.Context, in struct{}, out *[]*api.PinInfo) error {
return mock.StatusAllLocal(ctx, in, out) return mock.StatusAllLocal(ctx, in, out)
} }
func (mock *mockService) Sync(ctx context.Context, in cid.Cid, out *api.GlobalPinInfo) error { func (mock *mockCluster) Sync(ctx context.Context, in cid.Cid, out *api.GlobalPinInfo) error {
return mock.Status(ctx, in, out) return mock.Status(ctx, in, out)
} }
func (mock *mockService) SyncLocal(ctx context.Context, in cid.Cid, out *api.PinInfo) error { func (mock *mockCluster) SyncLocal(ctx context.Context, in cid.Cid, out *api.PinInfo) error {
return mock.StatusLocal(ctx, in, out) return mock.StatusLocal(ctx, in, out)
} }
func (mock *mockService) RecoverAllLocal(ctx context.Context, in struct{}, out *[]*api.PinInfo) error { func (mock *mockCluster) RecoverAllLocal(ctx context.Context, in struct{}, out *[]*api.PinInfo) error {
return mock.TrackerRecoverAll(ctx, in, out) return (&mockPinTracker{}).RecoverAll(ctx, in, out)
} }
func (mock *mockService) Recover(ctx context.Context, in cid.Cid, out *api.GlobalPinInfo) error { func (mock *mockCluster) Recover(ctx context.Context, in cid.Cid, out *api.GlobalPinInfo) error {
return mock.Status(ctx, in, out) return mock.Status(ctx, in, out)
} }
func (mock *mockService) RecoverLocal(ctx context.Context, in cid.Cid, out *api.PinInfo) error { func (mock *mockCluster) RecoverLocal(ctx context.Context, in cid.Cid, out *api.PinInfo) error {
return mock.TrackerRecover(ctx, in, out) return (&mockPinTracker{}).Recover(ctx, in, out)
} }
func (mock *mockService) BlockAllocate(ctx context.Context, in *api.Pin, out *[]peer.ID) error { func (mock *mockCluster) BlockAllocate(ctx context.Context, in *api.Pin, out *[]peer.ID) error {
if in.ReplicationFactorMin > 1 { if in.ReplicationFactorMin > 1 {
return errors.New("replMin too high: can only mock-allocate to 1") return errors.New("replMin too high: can only mock-allocate to 1")
} }
@ -286,21 +307,21 @@ func (mock *mockService) BlockAllocate(ctx context.Context, in *api.Pin, out *[]
return nil return nil
} }
func (mock *mockService) SendInformerMetric(ctx context.Context, in struct{}, out *api.Metric) error { func (mock *mockCluster) SendInformerMetric(ctx context.Context, in struct{}, out *api.Metric) error {
return nil return nil
} }
/* Tracker methods */ /* Tracker methods */
func (mock *mockService) Track(ctx context.Context, in *api.Pin, out *struct{}) error { func (mock *mockPinTracker) Track(ctx context.Context, in *api.Pin, out *struct{}) error {
return nil return nil
} }
func (mock *mockService) Untrack(ctx context.Context, in *api.Pin, out *struct{}) error { func (mock *mockPinTracker) Untrack(ctx context.Context, in *api.Pin, out *struct{}) error {
return nil return nil
} }
func (mock *mockService) TrackerStatusAll(ctx context.Context, in struct{}, out *[]*api.PinInfo) error { func (mock *mockPinTracker) StatusAll(ctx context.Context, in struct{}, out *[]*api.PinInfo) error {
*out = []*api.PinInfo{ *out = []*api.PinInfo{
{ {
Cid: Cid1, Cid: Cid1,
@ -318,7 +339,7 @@ func (mock *mockService) TrackerStatusAll(ctx context.Context, in struct{}, out
return nil return nil
} }
func (mock *mockService) TrackerStatus(ctx context.Context, in cid.Cid, out *api.PinInfo) error { func (mock *mockPinTracker) Status(ctx context.Context, in cid.Cid, out *api.PinInfo) error {
if in.Equals(ErrorCid) { if in.Equals(ErrorCid) {
return ErrBadCid return ErrBadCid
} }
@ -332,12 +353,12 @@ func (mock *mockService) TrackerStatus(ctx context.Context, in cid.Cid, out *api
return nil return nil
} }
func (mock *mockService) TrackerRecoverAll(ctx context.Context, in struct{}, out *[]*api.PinInfo) error { func (mock *mockPinTracker) RecoverAll(ctx context.Context, in struct{}, out *[]*api.PinInfo) error {
*out = make([]*api.PinInfo, 0, 0) *out = make([]*api.PinInfo, 0, 0)
return nil return nil
} }
func (mock *mockService) TrackerRecover(ctx context.Context, in cid.Cid, out *api.PinInfo) error { func (mock *mockPinTracker) Recover(ctx context.Context, in cid.Cid, out *api.PinInfo) error {
*out = api.PinInfo{ *out = api.PinInfo{
Cid: in, Cid: in,
Peer: PeerID1, Peer: PeerID1,
@ -349,13 +370,13 @@ func (mock *mockService) TrackerRecover(ctx context.Context, in cid.Cid, out *ap
/* PeerMonitor methods */ /* PeerMonitor methods */
// PeerMonitorLogMetric runs PeerMonitor.LogMetric(). // LogMetric runs PeerMonitor.LogMetric().
func (mock *mockService) PeerMonitorLogMetric(ctx context.Context, in *api.Metric, out *struct{}) error { func (mock *mockPeerMonitor) LogMetric(ctx context.Context, in *api.Metric, out *struct{}) error {
return nil return nil
} }
// PeerMonitorLatestMetrics runs PeerMonitor.LatestMetrics(). // LatestMetrics runs PeerMonitor.LatestMetrics().
func (mock *mockService) PeerMonitorLatestMetrics(ctx context.Context, in string, out *[]*api.Metric) error { func (mock *mockPeerMonitor) LatestMetrics(ctx context.Context, in string, out *[]*api.Metric) error {
m := &api.Metric{ m := &api.Metric{
Name: "test", Name: "test",
Peer: PeerID1, Peer: PeerID1,
@ -370,15 +391,15 @@ func (mock *mockService) PeerMonitorLatestMetrics(ctx context.Context, in string
/* IPFSConnector methods */ /* IPFSConnector methods */
func (mock *mockService) IPFSPin(ctx context.Context, in *api.Pin, out *struct{}) error { func (mock *mockIPFSConnector) Pin(ctx context.Context, in *api.Pin, out *struct{}) error {
return nil return nil
} }
func (mock *mockService) IPFSUnpin(ctx context.Context, in *api.Pin, out *struct{}) error { func (mock *mockIPFSConnector) Unpin(ctx context.Context, in *api.Pin, out *struct{}) error {
return nil return nil
} }
func (mock *mockService) IPFSPinLsCid(ctx context.Context, in cid.Cid, out *api.IPFSPinStatus) error { func (mock *mockIPFSConnector) PinLsCid(ctx context.Context, in cid.Cid, out *api.IPFSPinStatus) error {
if in.Equals(Cid1) || in.Equals(Cid3) { if in.Equals(Cid1) || in.Equals(Cid3) {
*out = api.IPFSPinStatusRecursive *out = api.IPFSPinStatusRecursive
} else { } else {
@ -387,7 +408,7 @@ func (mock *mockService) IPFSPinLsCid(ctx context.Context, in cid.Cid, out *api.
return nil return nil
} }
func (mock *mockService) IPFSPinLs(ctx context.Context, in string, out *map[string]api.IPFSPinStatus) error { func (mock *mockIPFSConnector) PinLs(ctx context.Context, in string, out *map[string]api.IPFSPinStatus) error {
m := map[string]api.IPFSPinStatus{ m := map[string]api.IPFSPinStatus{
Cid1.String(): api.IPFSPinStatusRecursive, Cid1.String(): api.IPFSPinStatusRecursive,
Cid3.String(): api.IPFSPinStatusRecursive, Cid3.String(): api.IPFSPinStatusRecursive,
@ -396,16 +417,16 @@ func (mock *mockService) IPFSPinLs(ctx context.Context, in string, out *map[stri
return nil return nil
} }
func (mock *mockService) IPFSConnectSwarms(ctx context.Context, in struct{}, out *struct{}) error { func (mock *mockIPFSConnector) ConnectSwarms(ctx context.Context, in struct{}, out *struct{}) error {
return nil return nil
} }
func (mock *mockService) IPFSSwarmPeers(ctx context.Context, in struct{}, out *[]peer.ID) error { func (mock *mockIPFSConnector) SwarmPeers(ctx context.Context, in struct{}, out *[]peer.ID) error {
*out = []peer.ID{PeerID2, PeerID3} *out = []peer.ID{PeerID2, PeerID3}
return nil return nil
} }
func (mock *mockService) IPFSConfigKey(ctx context.Context, in string, out *interface{}) error { func (mock *mockIPFSConnector) ConfigKey(ctx context.Context, in string, out *interface{}) error {
switch in { switch in {
case "Datastore/StorageMax": case "Datastore/StorageMax":
*out = "100KB" *out = "100KB"
@ -415,7 +436,7 @@ func (mock *mockService) IPFSConfigKey(ctx context.Context, in string, out *inte
return nil return nil
} }
func (mock *mockService) IPFSRepoStat(ctx context.Context, in struct{}, out *api.IPFSRepoStat) error { func (mock *mockIPFSConnector) RepoStat(ctx context.Context, in struct{}, out *api.IPFSRepoStat) error {
// since we have two pins. Assume each is 1000B. // since we have two pins. Assume each is 1000B.
stat := api.IPFSRepoStat{ stat := api.IPFSRepoStat{
StorageMax: 100000, StorageMax: 100000,
@ -425,11 +446,11 @@ func (mock *mockService) IPFSRepoStat(ctx context.Context, in struct{}, out *api
return nil return nil
} }
func (mock *mockService) IPFSBlockPut(ctx context.Context, in *api.NodeWithMeta, out *struct{}) error { func (mock *mockIPFSConnector) BlockPut(ctx context.Context, in *api.NodeWithMeta, out *struct{}) error {
return nil return nil
} }
func (mock *mockService) IPFSResolve(ctx context.Context, in string, out *cid.Cid) error { func (mock *mockIPFSConnector) Resolve(ctx context.Context, in string, out *cid.Cid) error {
switch in { switch in {
case ErrorCid.String(), "/ipfs/" + ErrorCid.String(): case ErrorCid.String(), "/ipfs/" + ErrorCid.String():
*out = ErrorCid *out = ErrorCid
@ -439,15 +460,15 @@ func (mock *mockService) IPFSResolve(ctx context.Context, in string, out *cid.Ci
return nil return nil
} }
func (mock *mockService) ConsensusAddPeer(ctx context.Context, in peer.ID, out *struct{}) error { func (mock *mockConsensus) AddPeer(ctx context.Context, in peer.ID, out *struct{}) error {
return errors.New("mock rpc cannot redirect") return errors.New("mock rpc cannot redirect")
} }
func (mock *mockService) ConsensusRmPeer(ctx context.Context, in peer.ID, out *struct{}) error { func (mock *mockConsensus) RmPeer(ctx context.Context, in peer.ID, out *struct{}) error {
return errors.New("mock rpc cannot redirect") return errors.New("mock rpc cannot redirect")
} }
func (mock *mockService) ConsensusPeers(ctx context.Context, in struct{}, out *[]peer.ID) error { func (mock *mockConsensus) Peers(ctx context.Context, in struct{}, out *[]peer.ID) error {
*out = []peer.ID{PeerID1, PeerID2, PeerID3} *out = []peer.ID{PeerID1, PeerID2, PeerID3}
return nil return nil
} }

110
test/test_test.go
View File

@ -14,49 +14,77 @@ func TestIpfsMock(t *testing.T) {
// Test that our RPC mock resembles the original // Test that our RPC mock resembles the original
func TestRPCMockValid(t *testing.T) { func TestRPCMockValid(t *testing.T) {
mock := &mockService{} type tc struct {
real := &ipfscluster.RPCAPI{} mock reflect.Type
mockT := reflect.TypeOf(mock) real reflect.Type
realT := reflect.TypeOf(real)
// Make sure all the methods we have match the original
for i := 0; i < mockT.NumMethod(); i++ {
method := mockT.Method(i)
name := method.Name
origMethod, ok := realT.MethodByName(name)
if !ok {
t.Fatalf("%s method not found in real RPC", name)
}
mType := method.Type
oType := origMethod.Type
if nout := mType.NumOut(); nout != 1 || nout != oType.NumOut() {
t.Errorf("%s: more than 1 out parameter", name)
}
if mType.Out(0).Name() != "error" {
t.Errorf("%s out param should be an error", name)
}
if nin := mType.NumIn(); nin != oType.NumIn() || nin != 4 {
t.Fatalf("%s: num in parameter mismatch: %d vs. %d", name, nin, oType.NumIn())
}
for j := 1; j < 4; j++ {
mn := mType.In(j).String()
on := oType.In(j).String()
if mn != on {
t.Errorf("%s: name mismatch: %s vs %s", name, mn, on)
}
}
} }
for i := 0; i < realT.NumMethod(); i++ { tcs := []tc{
name := realT.Method(i).Name {
_, ok := mockT.MethodByName(name) real: reflect.TypeOf(&ipfscluster.ClusterRPCAPI{}),
if !ok { mock: reflect.TypeOf(&mockCluster{}),
t.Logf("Warning: %s: unimplemented in mock rpc", name) },
{
real: reflect.TypeOf(&ipfscluster.PinTrackerRPCAPI{}),
mock: reflect.TypeOf(&mockPinTracker{}),
},
{
real: reflect.TypeOf(&ipfscluster.IPFSConnectorRPCAPI{}),
mock: reflect.TypeOf(&mockIPFSConnector{}),
},
{
real: reflect.TypeOf(&ipfscluster.ConsensusRPCAPI{}),
mock: reflect.TypeOf(&mockConsensus{}),
},
{
real: reflect.TypeOf(&ipfscluster.PeerMonitorRPCAPI{}),
mock: reflect.TypeOf(&mockPeerMonitor{}),
},
}
for _, tc := range tcs {
realT := tc.real
mockT := tc.mock
// Make sure all the methods we have match the original
for i := 0; i < mockT.NumMethod(); i++ {
method := mockT.Method(i)
name := method.Name
origMethod, ok := realT.MethodByName(name)
if !ok {
t.Fatalf("%s method not found in real RPC", name)
}
mType := method.Type
oType := origMethod.Type
if nout := mType.NumOut(); nout != 1 || nout != oType.NumOut() {
t.Errorf("%s: more than 1 out parameter", name)
}
if mType.Out(0).Name() != "error" {
t.Errorf("%s out param should be an error", name)
}
if nin := mType.NumIn(); nin != oType.NumIn() || nin != 4 {
t.Fatalf("%s: num in parameter mismatch: %d vs. %d", name, nin, oType.NumIn())
}
for j := 1; j < 4; j++ {
mn := mType.In(j).String()
on := oType.In(j).String()
if mn != on {
t.Errorf("%s: name mismatch: %s vs %s", name, mn, on)
}
}
}
for i := 0; i < realT.NumMethod(); i++ {
name := realT.Method(i).Name
_, ok := mockT.MethodByName(name)
if !ok {
t.Logf("Warning: %s: unimplemented in mock rpc", name)
}
} }
} }
} }