add truncindex

fix #222

Signed-off-by: yanxuean <yan.xuean@zte.com.cn>

pkg/store/sandbox/sandbox.go

@@ -20,6 +20,7 @@ import (
 	"sync"
 
 	"github.com/containerd/containerd"
+	"github.com/docker/docker/pkg/truncindex"
 
 	"github.com/kubernetes-incubator/cri-containerd/pkg/store"
 )
@@ -39,7 +40,7 @@ type Sandbox struct {
 type Store struct {
 	lock      sync.RWMutex
 	sandboxes map[string]Sandbox
-	// TODO(random-liu): Add trunc index.
+	idIndex   *truncindex.TruncIndex
 }
 
 // LoadStore loads sandboxes from runtime.
@@ -48,7 +49,10 @@ func LoadStore() *Store { return nil }
 
 // NewStore creates a sandbox store.
 func NewStore() *Store {
-	return &Store{sandboxes: make(map[string]Sandbox)}
+	return &Store{
+		sandboxes: make(map[string]Sandbox),
+		idIndex:   truncindex.NewTruncIndex([]string{}),
+	}
 }
 
 // Add a sandbox into the store.
@@ -58,6 +62,9 @@ func (s *Store) Add(sb Sandbox) error {
 	if _, ok := s.sandboxes[sb.ID]; ok {
 		return store.ErrAlreadyExist
 	}
+	if err := s.idIndex.Add(sb.ID); err != nil {
+		return err
+	}
 	s.sandboxes[sb.ID] = sb
 	return nil
 }
@@ -67,6 +74,13 @@ func (s *Store) Add(sb Sandbox) error {
 func (s *Store) Get(id string) (Sandbox, error) {
 	s.lock.RLock()
 	defer s.lock.RUnlock()
+	id, err := s.idIndex.Get(id)
+	if err != nil {
+		if err == truncindex.ErrNotExist {
+			err = store.ErrNotExist
+		}
+		return Sandbox{}, err
+	}
 	if sb, ok := s.sandboxes[id]; ok {
 		return sb, nil
 	}
@@ -88,5 +102,12 @@ func (s *Store) List() []Sandbox {
 func (s *Store) Delete(id string) {
 	s.lock.Lock()
 	defer s.lock.Unlock()
+	id, err := s.idIndex.Get(id)
+	if err != nil {
+		// Note: The idIndex.Delete and delete doesn't handle truncated index.
+		// So we need to return if there are error.
+		return
+	}
+	s.idIndex.Delete(id) // nolint: errcheck
 	delete(s.sandboxes, id)
 }

pkg/store/sandbox/sandbox_test.go

@@ -26,7 +26,6 @@ import (
 )
 
 func TestSandboxStore(t *testing.T) {
-	ids := []string{"1", "2", "3"}
 	metadatas := map[string]Metadata{
 		"1": {
 			ID:   "1",
@@ -41,36 +40,49 @@ func TestSandboxStore(t *testing.T) {
 			},
 			NetNSPath: "TestNetNS-1",
 		},
-		"2": {
-			ID:   "2",
-			Name: "Sandbox-2",
+		"2abcd": {
+			ID:   "2abcd",
+			Name: "Sandbox-2abcd",
 			Config: &runtime.PodSandboxConfig{
 				Metadata: &runtime.PodSandboxMetadata{
-					Name:      "TestPod-2",
-					Uid:       "TestUid-2",
-					Namespace: "TestNamespace-2",
+					Name:      "TestPod-2abcd",
+					Uid:       "TestUid-2abcd",
+					Namespace: "TestNamespace-2abcd",
 					Attempt:   2,
 				},
 			},
 			NetNSPath: "TestNetNS-2",
 		},
-		"3": {
-			ID:   "3",
-			Name: "Sandbox-3",
+		"4a333": {
+			ID:   "4a333",
+			Name: "Sandbox-4a333",
 			Config: &runtime.PodSandboxConfig{
 				Metadata: &runtime.PodSandboxMetadata{
-					Name:      "TestPod-3",
-					Uid:       "TestUid-3",
-					Namespace: "TestNamespace-3",
+					Name:      "TestPod-4a333",
+					Uid:       "TestUid-4a333",
+					Namespace: "TestNamespace-4a333",
 					Attempt:   3,
 				},
 			},
 			NetNSPath: "TestNetNS-3",
 		},
+		"4abcd": {
+			ID:   "4abcd",
+			Name: "Sandbox-4abcd",
+			Config: &runtime.PodSandboxConfig{
+				Metadata: &runtime.PodSandboxMetadata{
+					Name:      "TestPod-4abcd",
+					Uid:       "TestUid-4abcd",
+					Namespace: "TestNamespace-4abcd",
+					Attempt:   1,
+				},
+			},
+			NetNSPath: "TestNetNS-4abcd",
+		},
 	}
 	assert := assertlib.New(t)
 	sandboxes := map[string]Sandbox{}
-	for _, id := range ids {
+	for id := range metadatas {
 		sandboxes[id] = Sandbox{Metadata: metadatas[id]}
 	}
 
@@ -82,27 +94,33 @@ func TestSandboxStore(t *testing.T) {
 	}
 
 	t.Logf("should be able to get sandbox")
+	genTruncIndex := func(normalName string) string { return normalName[:(len(normalName)+1)/2] }
 	for id, sb := range sandboxes {
-		got, err := s.Get(id)
+		got, err := s.Get(genTruncIndex(id))
 		assert.NoError(err)
 		assert.Equal(sb, got)
 	}
 
 	t.Logf("should be able to list sandboxes")
 	sbs := s.List()
-	assert.Len(sbs, 3)
+	assert.Len(sbs, len(sandboxes))
 
-	testID := "2"
-	t.Logf("add should return already exists error for duplicated sandbox")
-	assert.Equal(store.ErrAlreadyExist, s.Add(sandboxes[testID]))
+	sbNum := len(sandboxes)
+	for testID, v := range sandboxes {
+		truncID := genTruncIndex(testID)
 
-	t.Logf("should be able to delete sandbox")
-	s.Delete(testID)
-	sbs = s.List()
-	assert.Len(sbs, 2)
+		t.Logf("add should return already exists error for duplicated sandbox")
+		assert.Equal(store.ErrAlreadyExist, s.Add(v))
 
-	t.Logf("get should return not exist error after deletion")
-	sb, err := s.Get(testID)
-	assert.Equal(Sandbox{}, sb)
-	assert.Equal(store.ErrNotExist, err)
+		t.Logf("should be able to delete sandbox")
+		s.Delete(truncID)
+		sbNum--
+		sbs = s.List()
+		assert.Len(sbs, sbNum)
+
+		t.Logf("get should return not exist error after deletion")
+		sb, err := s.Get(truncID)
+		assert.Equal(Sandbox{}, sb)
+		assert.Equal(store.ErrNotExist, err)
+	}
 }