package client import ( "context" "errors" "sync" "testing" "time" types "github.com/ipfs-cluster/ipfs-cluster/api" rest "github.com/ipfs-cluster/ipfs-cluster/api/rest" test "github.com/ipfs-cluster/ipfs-cluster/test" 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, _ := types.DecodeCid(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, []types.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 types.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 types.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 types.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 types.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) }