eee53bfa4f
This commit makes all the changes to make Peers() a streaming call. While Peers is usually a non problematic call, for consistency, all calls returning collections assembled through broadcast to cluster peers are now streaming calls.
907 lines
18 KiB
Go
907 lines
18 KiB
Go
package client
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
types "github.com/ipfs/ipfs-cluster/api"
|
|
rest "github.com/ipfs/ipfs-cluster/api/rest"
|
|
test "github.com/ipfs/ipfs-cluster/test"
|
|
|
|
cid "github.com/ipfs/go-cid"
|
|
peer "github.com/libp2p/go-libp2p-core/peer"
|
|
rpc "github.com/libp2p/go-libp2p-gorpc"
|
|
ma "github.com/multiformats/go-multiaddr"
|
|
)
|
|
|
|
func testClients(t *testing.T, api *rest.API, f func(*testing.T, Client)) {
|
|
t.Run("in-parallel", func(t *testing.T) {
|
|
t.Run("libp2p", func(t *testing.T) {
|
|
t.Parallel()
|
|
f(t, testClientLibp2p(t, api))
|
|
})
|
|
t.Run("http", func(t *testing.T) {
|
|
t.Parallel()
|
|
f(t, testClientHTTP(t, api))
|
|
})
|
|
})
|
|
}
|
|
|
|
func TestVersion(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
v, err := c.Version(ctx)
|
|
if err != nil || v.Version == "" {
|
|
t.Logf("%+v", v)
|
|
t.Log(err)
|
|
t.Error("expected something in version")
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestID(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
id, err := c.ID(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if id.ID == "" {
|
|
t.Error("bad id")
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestPeers(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
out := make(chan types.ID, 10)
|
|
err := c.Peers(ctx, out)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(out) == 0 {
|
|
t.Error("expected some peers")
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestPeersWithError(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
addr, _ := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/44444")
|
|
var _ = c
|
|
c, _ = NewDefaultClient(&Config{APIAddr: addr, DisableKeepAlives: true})
|
|
out := make(chan types.ID, 10)
|
|
err := c.Peers(ctx, out)
|
|
if err == nil {
|
|
t.Fatal("expected error")
|
|
}
|
|
if len(out) > 0 {
|
|
t.Fatal("expected no ids")
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestPeerAdd(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
id, err := c.PeerAdd(ctx, test.PeerID1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if id.ID != test.PeerID1 {
|
|
t.Error("bad peer")
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestPeerRm(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
err := c.PeerRm(ctx, test.PeerID1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestPin(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
opts := types.PinOptions{
|
|
ReplicationFactorMin: 6,
|
|
ReplicationFactorMax: 7,
|
|
Name: "hello there",
|
|
}
|
|
_, err := c.Pin(ctx, test.Cid1, opts)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestUnpin(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
_, err := c.Unpin(ctx, test.Cid1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
type pathCase struct {
|
|
path string
|
|
wantErr bool
|
|
expectedCid string
|
|
}
|
|
|
|
var pathTestCases = []pathCase{
|
|
{
|
|
test.CidResolved.String(),
|
|
false,
|
|
test.CidResolved.String(),
|
|
},
|
|
{
|
|
test.PathIPFS1,
|
|
false,
|
|
"QmaNJ5acV31sx8jq626qTpAWW4DXKw34aGhx53dECLvXbY",
|
|
},
|
|
{
|
|
test.PathIPFS2,
|
|
false,
|
|
test.CidResolved.String(),
|
|
},
|
|
{
|
|
test.PathIPNS1,
|
|
false,
|
|
test.CidResolved.String(),
|
|
},
|
|
{
|
|
test.PathIPLD1,
|
|
false,
|
|
"QmaNJ5acV31sx8jq626qTpAWW4DXKw34aGhx53dECLvXbY",
|
|
},
|
|
{
|
|
test.InvalidPath1,
|
|
true,
|
|
"",
|
|
},
|
|
}
|
|
|
|
func TestPinPath(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
opts := types.PinOptions{
|
|
ReplicationFactorMin: 6,
|
|
ReplicationFactorMax: 7,
|
|
Name: "hello there",
|
|
UserAllocations: []peer.ID{test.PeerID1, test.PeerID2},
|
|
}
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
for _, testCase := range pathTestCases {
|
|
ec, _ := cid.Decode(testCase.expectedCid)
|
|
resultantPin := types.PinWithOpts(ec, opts)
|
|
p := testCase.path
|
|
pin, err := c.PinPath(ctx, p, opts)
|
|
if err != nil {
|
|
if testCase.wantErr {
|
|
continue
|
|
}
|
|
t.Fatalf("unexpected error %s: %s", p, err)
|
|
}
|
|
|
|
if !pin.Equals(resultantPin) {
|
|
t.Errorf("expected different pin: %s", p)
|
|
t.Errorf("expected: %+v", resultantPin)
|
|
t.Errorf("actual: %+v", pin)
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestUnpinPath(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
for _, testCase := range pathTestCases {
|
|
p := testCase.path
|
|
pin, err := c.UnpinPath(ctx, p)
|
|
if err != nil {
|
|
if testCase.wantErr {
|
|
continue
|
|
}
|
|
t.Fatalf("unepected error %s: %s", p, err)
|
|
}
|
|
|
|
if pin.Cid.String() != testCase.expectedCid {
|
|
t.Errorf("bad resolved Cid: %s, %s", p, pin.Cid)
|
|
}
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestAllocations(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
pins := make(chan types.Pin)
|
|
n := 0
|
|
var wg sync.WaitGroup
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
for range pins {
|
|
n++
|
|
}
|
|
}()
|
|
|
|
err := c.Allocations(ctx, types.DataType|types.MetaType, pins)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
wg.Wait()
|
|
if n == 0 {
|
|
t.Error("should be some pins")
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestAllocation(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
pin, err := c.Allocation(ctx, test.Cid1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !pin.Cid.Equals(test.Cid1) {
|
|
t.Error("should be same pin")
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestStatus(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
pin, err := c.Status(ctx, test.Cid1, false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !pin.Cid.Equals(test.Cid1) {
|
|
t.Error("should be same pin")
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestStatusCids(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
out := make(chan types.GlobalPinInfo)
|
|
|
|
go func() {
|
|
err := c.StatusCids(ctx, []cid.Cid{test.Cid1}, false, out)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
}()
|
|
|
|
pins := collectGlobalPinInfos(t, out)
|
|
if len(pins) != 1 {
|
|
t.Fatal("wrong number of pins returned")
|
|
}
|
|
if !pins[0].Cid.Equals(test.Cid1) {
|
|
t.Error("should be same pin")
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func collectGlobalPinInfos(t *testing.T, out <-chan types.GlobalPinInfo) []types.GlobalPinInfo {
|
|
t.Helper()
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
|
|
var gpis []types.GlobalPinInfo
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
t.Error(ctx.Err())
|
|
return gpis
|
|
case gpi, ok := <-out:
|
|
if !ok {
|
|
return gpis
|
|
}
|
|
gpis = append(gpis, gpi)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestStatusAll(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
out := make(chan types.GlobalPinInfo)
|
|
go func() {
|
|
err := c.StatusAll(ctx, 0, false, out)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
}()
|
|
pins := collectGlobalPinInfos(t, out)
|
|
|
|
if len(pins) == 0 {
|
|
t.Error("there should be some pins")
|
|
}
|
|
|
|
out2 := make(chan types.GlobalPinInfo)
|
|
go func() {
|
|
err := c.StatusAll(ctx, 0, true, out2)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
}()
|
|
pins = collectGlobalPinInfos(t, out2)
|
|
|
|
if len(pins) != 2 {
|
|
t.Error("there should be two pins")
|
|
}
|
|
|
|
out3 := make(chan types.GlobalPinInfo)
|
|
go func() {
|
|
err := c.StatusAll(ctx, types.TrackerStatusPinning, false, out3)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
}()
|
|
pins = collectGlobalPinInfos(t, out3)
|
|
|
|
if len(pins) != 1 {
|
|
t.Error("there should be one pin")
|
|
}
|
|
|
|
out4 := make(chan types.GlobalPinInfo)
|
|
go func() {
|
|
err := c.StatusAll(ctx, types.TrackerStatusPinned|types.TrackerStatusError, false, out4)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
}()
|
|
pins = collectGlobalPinInfos(t, out4)
|
|
|
|
if len(pins) != 2 {
|
|
t.Error("there should be two pins")
|
|
}
|
|
|
|
out5 := make(chan types.GlobalPinInfo, 1)
|
|
err := c.StatusAll(ctx, 1<<25, false, out5)
|
|
if err == nil {
|
|
t.Error("expected an error")
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestRecover(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
pin, err := c.Recover(ctx, test.Cid1, false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !pin.Cid.Equals(test.Cid1) {
|
|
t.Error("should be same pin")
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestRecoverAll(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
out := make(chan types.GlobalPinInfo, 10)
|
|
err := c.RecoverAll(ctx, true, out)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
out2 := make(chan types.GlobalPinInfo, 10)
|
|
err = c.RecoverAll(ctx, false, out2)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestAlerts(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
alerts, err := c.Alerts(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(alerts) != 1 {
|
|
t.Fatal("expected 1 alert")
|
|
}
|
|
pID2 := peer.Encode(test.PeerID2)
|
|
if alerts[0].Peer != test.PeerID2 {
|
|
t.Errorf("expected an alert from %s", pID2)
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestGetConnectGraph(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
cg, err := c.GetConnectGraph(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(cg.IPFSLinks) != 3 || len(cg.ClusterLinks) != 3 ||
|
|
len(cg.ClustertoIPFS) != 3 {
|
|
t.Fatal("Bad graph")
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestMetrics(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
m, err := c.Metrics(ctx, "somemetricstype")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if len(m) == 0 {
|
|
t.Fatal("No metrics found")
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestMetricNames(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
m, err := c.MetricNames(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if len(m) == 0 {
|
|
t.Fatal("No metric names found")
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
type waitService struct {
|
|
l sync.Mutex
|
|
pinStart time.Time
|
|
}
|
|
|
|
func (wait *waitService) Pin(ctx context.Context, in types.Pin, out *types.Pin) error {
|
|
wait.l.Lock()
|
|
defer wait.l.Unlock()
|
|
wait.pinStart = time.Now()
|
|
*out = in
|
|
return nil
|
|
}
|
|
|
|
func (wait *waitService) Status(ctx context.Context, in cid.Cid, out *types.GlobalPinInfo) error {
|
|
wait.l.Lock()
|
|
defer wait.l.Unlock()
|
|
if time.Now().After(wait.pinStart.Add(5 * time.Second)) { //pinned
|
|
*out = types.GlobalPinInfo{
|
|
Cid: in,
|
|
PeerMap: map[string]types.PinInfoShort{
|
|
peer.Encode(test.PeerID1): {
|
|
Status: types.TrackerStatusPinned,
|
|
TS: wait.pinStart,
|
|
},
|
|
peer.Encode(test.PeerID2): {
|
|
Status: types.TrackerStatusPinned,
|
|
TS: wait.pinStart,
|
|
},
|
|
peer.Encode(test.PeerID3): {
|
|
Status: types.TrackerStatusPinning,
|
|
TS: wait.pinStart,
|
|
},
|
|
peer.Encode(test.PeerID3): {
|
|
Status: types.TrackerStatusRemote,
|
|
TS: wait.pinStart,
|
|
},
|
|
},
|
|
}
|
|
} else { // pinning
|
|
*out = types.GlobalPinInfo{
|
|
Cid: in,
|
|
PeerMap: map[string]types.PinInfoShort{
|
|
peer.Encode(test.PeerID1): {
|
|
Status: types.TrackerStatusPinning,
|
|
TS: wait.pinStart,
|
|
},
|
|
peer.Encode(test.PeerID2): {
|
|
Status: types.TrackerStatusPinned,
|
|
TS: wait.pinStart,
|
|
},
|
|
peer.Encode(test.PeerID3): {
|
|
Status: types.TrackerStatusPinning,
|
|
TS: wait.pinStart,
|
|
},
|
|
peer.Encode(test.PeerID3): {
|
|
Status: types.TrackerStatusRemote,
|
|
TS: wait.pinStart,
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (wait *waitService) PinGet(ctx context.Context, in cid.Cid, out *types.Pin) error {
|
|
p := types.PinCid(in)
|
|
p.ReplicationFactorMin = 2
|
|
p.ReplicationFactorMax = 3
|
|
*out = p
|
|
return nil
|
|
}
|
|
|
|
type waitServiceUnpin struct {
|
|
l sync.Mutex
|
|
unpinStart time.Time
|
|
}
|
|
|
|
func (wait *waitServiceUnpin) Unpin(ctx context.Context, in types.Pin, out *types.Pin) error {
|
|
wait.l.Lock()
|
|
defer wait.l.Unlock()
|
|
wait.unpinStart = time.Now()
|
|
return nil
|
|
}
|
|
|
|
func (wait *waitServiceUnpin) Status(ctx context.Context, in cid.Cid, out *types.GlobalPinInfo) error {
|
|
wait.l.Lock()
|
|
defer wait.l.Unlock()
|
|
if time.Now().After(wait.unpinStart.Add(5 * time.Second)) { //unpinned
|
|
*out = types.GlobalPinInfo{
|
|
Cid: in,
|
|
PeerMap: map[string]types.PinInfoShort{
|
|
peer.Encode(test.PeerID1): {
|
|
Status: types.TrackerStatusUnpinned,
|
|
TS: wait.unpinStart,
|
|
},
|
|
peer.Encode(test.PeerID2): {
|
|
Status: types.TrackerStatusUnpinned,
|
|
TS: wait.unpinStart,
|
|
},
|
|
},
|
|
}
|
|
} else { // pinning
|
|
*out = types.GlobalPinInfo{
|
|
Cid: in,
|
|
PeerMap: map[string]types.PinInfoShort{
|
|
peer.Encode(test.PeerID1): {
|
|
Status: types.TrackerStatusUnpinning,
|
|
TS: wait.unpinStart,
|
|
},
|
|
peer.Encode(test.PeerID2): {
|
|
Status: types.TrackerStatusUnpinning,
|
|
TS: wait.unpinStart,
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (wait *waitServiceUnpin) PinGet(ctx context.Context, in cid.Cid, out *types.Pin) error {
|
|
return errors.New("not found")
|
|
}
|
|
|
|
func TestWaitForPin(t *testing.T) {
|
|
ctx := context.Background()
|
|
tapi := testAPI(t)
|
|
defer shutdown(tapi)
|
|
|
|
rpcS := rpc.NewServer(nil, "wait")
|
|
rpcC := rpc.NewClientWithServer(nil, "wait", rpcS)
|
|
err := rpcS.RegisterName("Cluster", &waitService{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
tapi.SetClient(rpcC)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
|
|
var wg sync.WaitGroup
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
|
|
fp := StatusFilterParams{
|
|
Cid: test.Cid1,
|
|
Local: false,
|
|
Target: types.TrackerStatusPinned,
|
|
CheckFreq: time.Second,
|
|
}
|
|
start := time.Now()
|
|
|
|
st, err := WaitFor(ctx, c, fp)
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
if time.Since(start) <= 5*time.Second {
|
|
t.Error("slow pin should have taken at least 5 seconds")
|
|
return
|
|
}
|
|
|
|
totalPinned := 0
|
|
for _, pi := range st.PeerMap {
|
|
if pi.Status == types.TrackerStatusPinned {
|
|
totalPinned++
|
|
}
|
|
}
|
|
if totalPinned < 2 { // repl factor min
|
|
t.Error("pin info should show the item is pinnedin two places at least")
|
|
}
|
|
}()
|
|
_, err := c.Pin(ctx, test.Cid1, types.PinOptions{ReplicationFactorMin: 0, ReplicationFactorMax: 0, Name: "test", ShardSize: 0})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
wg.Wait()
|
|
}
|
|
|
|
testClients(t, tapi, testF)
|
|
}
|
|
|
|
func TestWaitForUnpin(t *testing.T) {
|
|
ctx := context.Background()
|
|
tapi := testAPI(t)
|
|
defer shutdown(tapi)
|
|
|
|
rpcS := rpc.NewServer(nil, "wait")
|
|
rpcC := rpc.NewClientWithServer(nil, "wait", rpcS)
|
|
err := rpcS.RegisterName("Cluster", &waitServiceUnpin{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
tapi.SetClient(rpcC)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
|
|
var wg sync.WaitGroup
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
|
|
fp := StatusFilterParams{
|
|
Cid: test.Cid1,
|
|
Local: false,
|
|
Target: types.TrackerStatusUnpinned,
|
|
CheckFreq: time.Second,
|
|
}
|
|
start := time.Now()
|
|
|
|
st, err := WaitFor(ctx, c, fp)
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
if time.Since(start) <= 5*time.Second {
|
|
t.Error("slow unpin should have taken at least 5 seconds")
|
|
return
|
|
}
|
|
|
|
for _, pi := range st.PeerMap {
|
|
if pi.Status != types.TrackerStatusUnpinned {
|
|
t.Error("the item should have been unpinned everywhere")
|
|
}
|
|
}
|
|
}()
|
|
_, err := c.Unpin(ctx, test.Cid1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
wg.Wait()
|
|
}
|
|
|
|
testClients(t, tapi, testF)
|
|
}
|
|
|
|
func TestAddMultiFile(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer api.Shutdown(ctx)
|
|
|
|
sth := test.NewShardingTestHelper()
|
|
defer sth.Clean(t)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
mfr, closer := sth.GetTreeMultiReader(t)
|
|
defer closer.Close()
|
|
|
|
p := types.AddParams{
|
|
PinOptions: types.PinOptions{
|
|
ReplicationFactorMin: -1,
|
|
ReplicationFactorMax: -1,
|
|
Name: "test something",
|
|
ShardSize: 1024,
|
|
},
|
|
Shard: false,
|
|
Format: "",
|
|
IPFSAddParams: types.IPFSAddParams{
|
|
Chunker: "",
|
|
RawLeaves: false,
|
|
},
|
|
Hidden: false,
|
|
StreamChannels: true,
|
|
}
|
|
|
|
out := make(chan types.AddedOutput, 1)
|
|
var wg sync.WaitGroup
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
for v := range out {
|
|
t.Logf("output: Name: %s. Hash: %s", v.Name, v.Cid)
|
|
}
|
|
}()
|
|
|
|
err := c.AddMultiFile(ctx, mfr, p, out)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
wg.Wait()
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|
|
|
|
func TestRepoGC(t *testing.T) {
|
|
ctx := context.Background()
|
|
api := testAPI(t)
|
|
defer shutdown(api)
|
|
|
|
testF := func(t *testing.T, c Client) {
|
|
globalGC, err := c.RepoGC(ctx, false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if globalGC.PeerMap == nil {
|
|
t.Fatal("expected a non-nil peer map")
|
|
}
|
|
|
|
for _, gc := range globalGC.PeerMap {
|
|
if gc.Peer == "" {
|
|
t.Error("bad id")
|
|
}
|
|
if gc.Error != "" {
|
|
t.Error("did not expect any error")
|
|
}
|
|
if gc.Keys == nil {
|
|
t.Error("expected a non-nil array of IPFSRepoGC")
|
|
} else {
|
|
if !gc.Keys[0].Key.Equals(test.Cid1) {
|
|
t.Errorf("expected a different cid, expected: %s, found: %s", test.Cid1, gc.Keys[0].Key)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
testClients(t, api, testF)
|
|
}
|