2016-12-23 18:35:37 +00:00
|
|
|
package ipfscluster
|
|
|
|
|
2017-01-30 12:12:25 +00:00
|
|
|
import (
|
2017-02-02 22:52:06 +00:00
|
|
|
"errors"
|
2017-01-30 12:12:25 +00:00
|
|
|
|
|
|
|
peer "github.com/libp2p/go-libp2p-peer"
|
2017-02-08 17:04:08 +00:00
|
|
|
|
|
|
|
"github.com/ipfs/ipfs-cluster/api"
|
2017-01-30 12:12:25 +00:00
|
|
|
)
|
2016-12-23 18:35:37 +00:00
|
|
|
|
2017-01-25 11:14:39 +00:00
|
|
|
// RPCAPI is a go-libp2p-gorpc service which provides the internal ipfs-cluster
|
2017-01-26 18:59:31 +00:00
|
|
|
// API, which enables components and cluster peers to communicate and
|
2016-12-28 15:25:24 +00:00
|
|
|
// request actions from each other.
|
|
|
|
//
|
|
|
|
// The RPC API methods are usually redirects to the actual methods in
|
|
|
|
// the different components of ipfs-cluster, with very little added logic.
|
|
|
|
// Refer to documentation on those methods for details on their behaviour.
|
2016-12-23 18:35:37 +00:00
|
|
|
type RPCAPI struct {
|
2017-02-08 17:04:08 +00:00
|
|
|
c *Cluster
|
2016-12-23 18:35:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Cluster components methods
|
|
|
|
*/
|
|
|
|
|
2017-01-25 17:07:19 +00:00
|
|
|
// ID runs Cluster.ID()
|
2017-02-08 17:04:08 +00:00
|
|
|
func (rpcapi *RPCAPI) ID(in struct{}, out *api.IDSerial) error {
|
|
|
|
id := rpcapi.c.ID().ToSerial()
|
2017-01-26 18:59:31 +00:00
|
|
|
*out = id
|
2017-01-24 15:19:23 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-12-28 15:25:24 +00:00
|
|
|
// Pin runs Cluster.Pin().
|
2017-03-08 15:57:27 +00:00
|
|
|
func (rpcapi *RPCAPI) Pin(in api.PinSerial, out *struct{}) error {
|
2017-03-08 17:28:43 +00:00
|
|
|
return rpcapi.c.Pin(in.ToPin())
|
2016-12-23 18:35:37 +00:00
|
|
|
}
|
|
|
|
|
2016-12-28 15:25:24 +00:00
|
|
|
// Unpin runs Cluster.Unpin().
|
2017-03-08 15:57:27 +00:00
|
|
|
func (rpcapi *RPCAPI) Unpin(in api.PinSerial, out *struct{}) error {
|
|
|
|
c := in.ToPin().Cid
|
2017-02-08 17:04:08 +00:00
|
|
|
return rpcapi.c.Unpin(c)
|
2016-12-23 18:35:37 +00:00
|
|
|
}
|
|
|
|
|
2017-04-06 02:27:02 +00:00
|
|
|
// Pins runs Cluster.Pins().
|
|
|
|
func (rpcapi *RPCAPI) Pins(in struct{}, out *[]api.PinSerial) error {
|
2017-02-08 17:04:08 +00:00
|
|
|
cidList := rpcapi.c.Pins()
|
2017-03-08 15:57:27 +00:00
|
|
|
cidSerialList := make([]api.PinSerial, 0, len(cidList))
|
2016-12-23 18:35:37 +00:00
|
|
|
for _, c := range cidList {
|
2017-02-13 15:46:53 +00:00
|
|
|
cidSerialList = append(cidSerialList, c.ToSerial())
|
2016-12-23 18:35:37 +00:00
|
|
|
}
|
2017-02-13 15:46:53 +00:00
|
|
|
*out = cidSerialList
|
2016-12-23 18:35:37 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-04-06 02:27:02 +00:00
|
|
|
// PinGet runs Cluster.PinGet().
|
|
|
|
func (rpcapi *RPCAPI) PinGet(in api.PinSerial, out *api.PinSerial) error {
|
|
|
|
cidarg := in.ToPin()
|
|
|
|
pin, err := rpcapi.c.PinGet(cidarg.Cid)
|
|
|
|
if err == nil {
|
|
|
|
*out = pin.ToSerial()
|
|
|
|
}
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2016-12-28 15:25:24 +00:00
|
|
|
// Version runs Cluster.Version().
|
2017-02-08 17:04:08 +00:00
|
|
|
func (rpcapi *RPCAPI) Version(in struct{}, out *api.Version) error {
|
2017-02-15 14:16:34 +00:00
|
|
|
*out = api.Version{
|
|
|
|
Version: rpcapi.c.Version(),
|
|
|
|
}
|
2016-12-23 18:35:37 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-26 18:59:31 +00:00
|
|
|
// Peers runs Cluster.Peers().
|
2017-02-08 17:04:08 +00:00
|
|
|
func (rpcapi *RPCAPI) Peers(in struct{}, out *[]api.IDSerial) error {
|
|
|
|
peers := rpcapi.c.Peers()
|
|
|
|
var sPeers []api.IDSerial
|
2017-01-26 18:59:31 +00:00
|
|
|
for _, p := range peers {
|
|
|
|
sPeers = append(sPeers, p.ToSerial())
|
|
|
|
}
|
|
|
|
*out = sPeers
|
2016-12-23 18:35:37 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-30 12:12:25 +00:00
|
|
|
// PeerAdd runs Cluster.PeerAdd().
|
2017-02-08 17:04:08 +00:00
|
|
|
func (rpcapi *RPCAPI) PeerAdd(in api.MultiaddrSerial, out *api.IDSerial) error {
|
2017-01-30 12:12:25 +00:00
|
|
|
addr := in.ToMultiaddr()
|
2017-02-08 17:04:08 +00:00
|
|
|
id, err := rpcapi.c.PeerAdd(addr)
|
2017-01-30 12:12:25 +00:00
|
|
|
*out = id.ToSerial()
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// PeerRemove runs Cluster.PeerRm().
|
2017-02-08 17:04:08 +00:00
|
|
|
func (rpcapi *RPCAPI) PeerRemove(in peer.ID, out *struct{}) error {
|
|
|
|
return rpcapi.c.PeerRemove(in)
|
2017-01-30 12:12:25 +00:00
|
|
|
}
|
|
|
|
|
2017-02-02 22:52:06 +00:00
|
|
|
// Join runs Cluster.Join().
|
2017-02-08 17:04:08 +00:00
|
|
|
func (rpcapi *RPCAPI) Join(in api.MultiaddrSerial, out *struct{}) error {
|
2017-02-02 22:52:06 +00:00
|
|
|
addr := in.ToMultiaddr()
|
2017-02-08 17:04:08 +00:00
|
|
|
err := rpcapi.c.Join(addr)
|
2017-02-02 22:52:06 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-01-25 18:38:23 +00:00
|
|
|
// StatusAll runs Cluster.StatusAll().
|
2017-02-08 17:04:08 +00:00
|
|
|
func (rpcapi *RPCAPI) StatusAll(in struct{}, out *[]api.GlobalPinInfoSerial) error {
|
|
|
|
pinfos, err := rpcapi.c.StatusAll()
|
|
|
|
*out = globalPinInfoSliceToSerial(pinfos)
|
2016-12-23 18:35:37 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-01-25 18:38:23 +00:00
|
|
|
// Status runs Cluster.Status().
|
2017-03-08 15:57:27 +00:00
|
|
|
func (rpcapi *RPCAPI) Status(in api.PinSerial, out *api.GlobalPinInfoSerial) error {
|
|
|
|
c := in.ToPin().Cid
|
2017-02-08 17:04:08 +00:00
|
|
|
pinfo, err := rpcapi.c.Status(c)
|
|
|
|
*out = pinfo.ToSerial()
|
2016-12-23 18:35:37 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-01-25 18:38:23 +00:00
|
|
|
// SyncAllLocal runs Cluster.SyncAllLocal().
|
2017-02-08 17:04:08 +00:00
|
|
|
func (rpcapi *RPCAPI) SyncAllLocal(in struct{}, out *[]api.PinInfoSerial) error {
|
|
|
|
pinfos, err := rpcapi.c.SyncAllLocal()
|
|
|
|
*out = pinInfoSliceToSerial(pinfos)
|
2016-12-23 18:35:37 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-01-25 18:38:23 +00:00
|
|
|
// SyncLocal runs Cluster.SyncLocal().
|
2017-03-08 15:57:27 +00:00
|
|
|
func (rpcapi *RPCAPI) SyncLocal(in api.PinSerial, out *api.PinInfoSerial) error {
|
|
|
|
c := in.ToPin().Cid
|
2017-02-08 17:04:08 +00:00
|
|
|
pinfo, err := rpcapi.c.SyncLocal(c)
|
|
|
|
*out = pinfo.ToSerial()
|
2016-12-23 18:35:37 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-01-25 18:38:23 +00:00
|
|
|
// SyncAll runs Cluster.SyncAll().
|
2017-02-08 17:04:08 +00:00
|
|
|
func (rpcapi *RPCAPI) SyncAll(in struct{}, out *[]api.GlobalPinInfoSerial) error {
|
|
|
|
pinfos, err := rpcapi.c.SyncAll()
|
|
|
|
*out = globalPinInfoSliceToSerial(pinfos)
|
2016-12-23 18:35:37 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-01-25 18:38:23 +00:00
|
|
|
// Sync runs Cluster.Sync().
|
2017-03-08 15:57:27 +00:00
|
|
|
func (rpcapi *RPCAPI) Sync(in api.PinSerial, out *api.GlobalPinInfoSerial) error {
|
|
|
|
c := in.ToPin().Cid
|
2017-02-08 17:04:08 +00:00
|
|
|
pinfo, err := rpcapi.c.Sync(c)
|
|
|
|
*out = pinfo.ToSerial()
|
2016-12-23 18:35:37 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2016-12-28 15:25:24 +00:00
|
|
|
// StateSync runs Cluster.StateSync().
|
2017-02-08 17:04:08 +00:00
|
|
|
func (rpcapi *RPCAPI) StateSync(in struct{}, out *[]api.PinInfoSerial) error {
|
|
|
|
pinfos, err := rpcapi.c.StateSync()
|
|
|
|
*out = pinInfoSliceToSerial(pinfos)
|
2016-12-23 18:35:37 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-01-25 18:38:23 +00:00
|
|
|
// Recover runs Cluster.Recover().
|
2017-03-08 15:57:27 +00:00
|
|
|
func (rpcapi *RPCAPI) Recover(in api.PinSerial, out *api.GlobalPinInfoSerial) error {
|
|
|
|
c := in.ToPin().Cid
|
2017-02-08 17:04:08 +00:00
|
|
|
pinfo, err := rpcapi.c.Recover(c)
|
|
|
|
*out = pinfo.ToSerial()
|
2017-01-25 18:38:23 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2016-12-23 18:35:37 +00:00
|
|
|
/*
|
|
|
|
Tracker component methods
|
|
|
|
*/
|
|
|
|
|
2016-12-28 15:25:24 +00:00
|
|
|
// Track runs PinTracker.Track().
|
2017-03-08 15:57:27 +00:00
|
|
|
func (rpcapi *RPCAPI) Track(in api.PinSerial, out *struct{}) error {
|
|
|
|
return rpcapi.c.tracker.Track(in.ToPin())
|
2016-12-23 18:35:37 +00:00
|
|
|
}
|
|
|
|
|
2016-12-28 15:25:24 +00:00
|
|
|
// Untrack runs PinTracker.Untrack().
|
2017-03-08 15:57:27 +00:00
|
|
|
func (rpcapi *RPCAPI) Untrack(in api.PinSerial, out *struct{}) error {
|
|
|
|
c := in.ToPin().Cid
|
2017-02-08 17:04:08 +00:00
|
|
|
return rpcapi.c.tracker.Untrack(c)
|
2016-12-23 18:35:37 +00:00
|
|
|
}
|
|
|
|
|
2017-01-25 18:38:23 +00:00
|
|
|
// TrackerStatusAll runs PinTracker.StatusAll().
|
2017-02-08 17:04:08 +00:00
|
|
|
func (rpcapi *RPCAPI) TrackerStatusAll(in struct{}, out *[]api.PinInfoSerial) error {
|
|
|
|
*out = pinInfoSliceToSerial(rpcapi.c.tracker.StatusAll())
|
2016-12-23 18:35:37 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-25 18:38:23 +00:00
|
|
|
// TrackerStatus runs PinTracker.Status().
|
2017-03-08 15:57:27 +00:00
|
|
|
func (rpcapi *RPCAPI) TrackerStatus(in api.PinSerial, out *api.PinInfoSerial) error {
|
|
|
|
c := in.ToPin().Cid
|
2017-02-08 17:04:08 +00:00
|
|
|
pinfo := rpcapi.c.tracker.Status(c)
|
|
|
|
*out = pinfo.ToSerial()
|
2016-12-23 18:35:37 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-25 18:38:23 +00:00
|
|
|
// TrackerRecover runs PinTracker.Recover().
|
2017-03-08 15:57:27 +00:00
|
|
|
func (rpcapi *RPCAPI) TrackerRecover(in api.PinSerial, out *api.PinInfoSerial) error {
|
|
|
|
c := in.ToPin().Cid
|
2017-02-08 17:04:08 +00:00
|
|
|
pinfo, err := rpcapi.c.tracker.Recover(c)
|
|
|
|
*out = pinfo.ToSerial()
|
2017-01-25 18:38:23 +00:00
|
|
|
return err
|
|
|
|
}
|
2016-12-23 18:35:37 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
IPFS Connector component methods
|
|
|
|
*/
|
|
|
|
|
2016-12-28 15:25:24 +00:00
|
|
|
// IPFSPin runs IPFSConnector.Pin().
|
2017-03-08 15:57:27 +00:00
|
|
|
func (rpcapi *RPCAPI) IPFSPin(in api.PinSerial, out *struct{}) error {
|
|
|
|
c := in.ToPin().Cid
|
2017-02-08 17:04:08 +00:00
|
|
|
return rpcapi.c.ipfs.Pin(c)
|
2016-12-23 18:35:37 +00:00
|
|
|
}
|
|
|
|
|
2016-12-28 15:25:24 +00:00
|
|
|
// IPFSUnpin runs IPFSConnector.Unpin().
|
2017-03-08 15:57:27 +00:00
|
|
|
func (rpcapi *RPCAPI) IPFSUnpin(in api.PinSerial, out *struct{}) error {
|
|
|
|
c := in.ToPin().Cid
|
2017-02-08 17:04:08 +00:00
|
|
|
return rpcapi.c.ipfs.Unpin(c)
|
2016-12-23 18:35:37 +00:00
|
|
|
}
|
|
|
|
|
2017-01-25 17:07:19 +00:00
|
|
|
// IPFSPinLsCid runs IPFSConnector.PinLsCid().
|
2017-03-08 15:57:27 +00:00
|
|
|
func (rpcapi *RPCAPI) IPFSPinLsCid(in api.PinSerial, out *api.IPFSPinStatus) error {
|
|
|
|
c := in.ToPin().Cid
|
2017-02-08 17:04:08 +00:00
|
|
|
b, err := rpcapi.c.ipfs.PinLsCid(c)
|
2016-12-23 18:35:37 +00:00
|
|
|
*out = b
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-01-25 17:07:19 +00:00
|
|
|
// IPFSPinLs runs IPFSConnector.PinLs().
|
2017-02-09 15:29:17 +00:00
|
|
|
func (rpcapi *RPCAPI) IPFSPinLs(in string, out *map[string]api.IPFSPinStatus) error {
|
|
|
|
m, err := rpcapi.c.ipfs.PinLs(in)
|
2017-01-25 17:07:19 +00:00
|
|
|
*out = m
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-03-27 13:07:12 +00:00
|
|
|
// IPFSConnectSwarms runs IPFSConnector.ConnectSwarms().
|
|
|
|
func (rpcapi *RPCAPI) IPFSConnectSwarms(in struct{}, out *struct{}) error {
|
|
|
|
err := rpcapi.c.ipfs.ConnectSwarms()
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// IPFSConfigKey runs IPFSConnector.ConfigKey().
|
|
|
|
func (rpcapi *RPCAPI) IPFSConfigKey(in string, out *interface{}) error {
|
|
|
|
res, err := rpcapi.c.ipfs.ConfigKey(in)
|
|
|
|
*out = res
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-08-02 22:49:25 +00:00
|
|
|
// IPFSFreeSpace runs IPFSConnector.FreeSpace().
|
2017-10-26 11:45:33 +00:00
|
|
|
func (rpcapi *RPCAPI) IPFSFreeSpace(in struct{}, out *uint64) error {
|
2017-08-02 22:49:25 +00:00
|
|
|
res, err := rpcapi.c.ipfs.FreeSpace()
|
|
|
|
*out = res
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-03-27 13:07:12 +00:00
|
|
|
// IPFSRepoSize runs IPFSConnector.RepoSize().
|
2017-10-26 11:45:33 +00:00
|
|
|
func (rpcapi *RPCAPI) IPFSRepoSize(in struct{}, out *uint64) error {
|
2017-03-27 13:07:12 +00:00
|
|
|
res, err := rpcapi.c.ipfs.RepoSize()
|
|
|
|
*out = res
|
|
|
|
return err
|
2017-03-23 18:34:33 +00:00
|
|
|
}
|
|
|
|
|
2016-12-23 18:35:37 +00:00
|
|
|
/*
|
|
|
|
Consensus component methods
|
|
|
|
*/
|
|
|
|
|
2016-12-28 15:25:24 +00:00
|
|
|
// ConsensusLogPin runs Consensus.LogPin().
|
2017-03-08 15:57:27 +00:00
|
|
|
func (rpcapi *RPCAPI) ConsensusLogPin(in api.PinSerial, out *struct{}) error {
|
|
|
|
c := in.ToPin()
|
2017-02-08 17:04:08 +00:00
|
|
|
return rpcapi.c.consensus.LogPin(c)
|
2016-12-23 18:35:37 +00:00
|
|
|
}
|
|
|
|
|
2016-12-28 15:25:24 +00:00
|
|
|
// ConsensusLogUnpin runs Consensus.LogUnpin().
|
2017-03-08 15:57:27 +00:00
|
|
|
func (rpcapi *RPCAPI) ConsensusLogUnpin(in api.PinSerial, out *struct{}) error {
|
|
|
|
c := in.ToPin()
|
2017-02-08 17:04:08 +00:00
|
|
|
return rpcapi.c.consensus.LogUnpin(c)
|
2016-12-23 18:35:37 +00:00
|
|
|
}
|
2017-01-30 12:12:25 +00:00
|
|
|
|
2017-11-08 19:04:04 +00:00
|
|
|
// ConsensusAddPeer runs Consensus.AddPeer().
|
|
|
|
func (rpcapi *RPCAPI) ConsensusAddPeer(in peer.ID, out *struct{}) error {
|
|
|
|
return rpcapi.c.consensus.AddPeer(in)
|
2017-02-02 22:52:06 +00:00
|
|
|
}
|
|
|
|
|
2017-11-08 19:04:04 +00:00
|
|
|
// ConsensusRmPeer runs Consensus.RmPeer().
|
|
|
|
func (rpcapi *RPCAPI) ConsensusRmPeer(in peer.ID, out *struct{}) error {
|
|
|
|
return rpcapi.c.consensus.RmPeer(in)
|
2017-02-02 22:52:06 +00:00
|
|
|
}
|
|
|
|
|
2017-01-30 12:12:25 +00:00
|
|
|
/*
|
|
|
|
Peer Manager methods
|
|
|
|
*/
|
|
|
|
|
|
|
|
// PeerManagerAddPeer runs peerManager.addPeer().
|
2017-02-08 17:04:08 +00:00
|
|
|
func (rpcapi *RPCAPI) PeerManagerAddPeer(in api.MultiaddrSerial, out *struct{}) error {
|
2017-02-02 22:52:06 +00:00
|
|
|
addr := in.ToMultiaddr()
|
2017-11-08 19:04:04 +00:00
|
|
|
err := rpcapi.c.peerManager.addPeer(addr)
|
2017-02-02 22:52:06 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-11-08 19:04:04 +00:00
|
|
|
// PeerManagerImportAddresses runs peerManager.importAddresses().
|
|
|
|
func (rpcapi *RPCAPI) PeerManagerImportAddresses(in api.MultiaddrsSerial, out *struct{}) error {
|
2017-02-02 22:52:06 +00:00
|
|
|
addrs := in.ToMultiaddrs()
|
2017-11-08 19:04:04 +00:00
|
|
|
err := rpcapi.c.peerManager.importAddresses(addrs)
|
2017-01-30 12:12:25 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// PeerManagerRmPeer runs peerManager.rmPeer().
|
2017-02-08 17:04:08 +00:00
|
|
|
func (rpcapi *RPCAPI) PeerManagerRmPeer(in peer.ID, out *struct{}) error {
|
2017-11-08 19:04:04 +00:00
|
|
|
return rpcapi.c.peerManager.rmPeer(in)
|
2017-01-30 12:12:25 +00:00
|
|
|
}
|
|
|
|
|
2017-11-08 19:04:04 +00:00
|
|
|
// PeerManagerPeers runs cluster.consensus.Peers().
|
2017-02-13 15:46:53 +00:00
|
|
|
func (rpcapi *RPCAPI) PeerManagerPeers(in struct{}, out *[]peer.ID) error {
|
2017-11-08 19:04:04 +00:00
|
|
|
peers, err := rpcapi.c.consensus.Peers()
|
|
|
|
*out = peers
|
|
|
|
return err
|
2017-02-13 15:46:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
PeerMonitor
|
|
|
|
*/
|
|
|
|
|
|
|
|
// PeerMonitorLogMetric runs PeerMonitor.LogMetric().
|
|
|
|
func (rpcapi *RPCAPI) PeerMonitorLogMetric(in api.Metric, out *struct{}) error {
|
|
|
|
rpcapi.c.monitor.LogMetric(in)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// PeerMonitorLastMetrics runs PeerMonitor.LastMetrics().
|
|
|
|
func (rpcapi *RPCAPI) PeerMonitorLastMetrics(in string, out *[]api.Metric) error {
|
|
|
|
*out = rpcapi.c.monitor.LastMetrics(in)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-02 22:52:06 +00:00
|
|
|
/*
|
|
|
|
Other
|
|
|
|
*/
|
2017-01-30 12:12:25 +00:00
|
|
|
|
2017-02-02 22:52:06 +00:00
|
|
|
// RemoteMultiaddrForPeer returns the multiaddr of a peer as seen by this peer.
|
|
|
|
// This is necessary for a peer to figure out which of its multiaddresses the
|
|
|
|
// peers are seeing (also when crossing NATs). It should be called from
|
|
|
|
// the peer the IN parameter indicates.
|
2017-02-08 17:04:08 +00:00
|
|
|
func (rpcapi *RPCAPI) RemoteMultiaddrForPeer(in peer.ID, out *api.MultiaddrSerial) error {
|
|
|
|
conns := rpcapi.c.host.Network().ConnsToPeer(in)
|
2017-02-02 22:52:06 +00:00
|
|
|
if len(conns) == 0 {
|
|
|
|
return errors.New("no connections to: " + in.Pretty())
|
|
|
|
}
|
2017-02-08 17:04:08 +00:00
|
|
|
*out = api.MultiaddrToSerial(multiaddrJoin(conns[0].RemoteMultiaddr(), in))
|
2017-01-30 12:12:25 +00:00
|
|
|
return nil
|
|
|
|
}
|