Remove DsKeyToCid() and CidToDsKey(). Add DsKeyToCidV1Raw()

We are deprecating these functions as ipfs strives to store
multihashes directly on the datastore, rather than CIDs.

Thus multiple CIDs might map to the same multihash. Making this functions
reflect that behaviour might cause silent breakage in users. We prefer loud
breakage.

Users using CidToDsKey(c) should move to MultihashToDsKey(c.Hash()).

Users using DsKeyToCid() should move to DsKeyToCidV1Raw() or DsKeyToMultihash().

Note that datastore should handle migrations to replace existing CID-encoded
keys with raw multihashes, or preserve DsKeyToCid() and CidToDsKey() in their
own codebases.

key.go

@@ -3,7 +3,7 @@
 package dshelp
 
 import (
-	cid "github.com/ipfs/go-cid"
+	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-datastore"
 	"github.com/multiformats/go-base32"
 	mh "github.com/multiformats/go-multihash"
@@ -23,6 +23,9 @@ func BinaryFromDsKey(k datastore.Key) ([]byte, error) {
 }
 
 // MultihashToDsKey creates a Key from the given Multihash.
+// If working with Cids, you can call cid.Hash() to obtain
+// the multihash. Note that different CIDs might represent
+// the same multihash.
 func MultihashToDsKey(k mh.Multihash) datastore.Key {
 	return NewKeyFromBinary(k)
 }
@@ -36,16 +39,12 @@ func DsKeyToMultihash(dsKey datastore.Key) (mh.Multihash, error) {
 	return mh.Cast(kb)
 }
 
-// CidToDsKey creates a Key from the given Cid.
-func CidToDsKey(k cid.Cid) datastore.Key {
-	return MultihashToDsKey(k.Hash())
-}
-
-// DsKeyToCid converts the given Key to its corresponding Cid.
-func DsKeyToCid(dsKey datastore.Key) (cid.Cid, error) {
+// DsKeyToCidV1Raw converts the given Key (which should be a raw multihash
+// key) to a Cid V1 of raw type.
+func DsKeyToCidV1Raw(dsKey datastore.Key) (cid.Cid, error) {
 	hash, err := DsKeyToMultihash(dsKey)
 	if err != nil {
-		return cid.Cid{}, nil
+		return cid.Cid{}, err
 	}
 	return cid.NewCidV1(cid.Raw, hash), nil
 }

key_test.go

@@ -8,15 +8,17 @@ import (
 
 func TestKey(t *testing.T) {
 	c, _ := cid.Decode("QmP63DkAFEnDYNjDYBpyNDfttu1fvUw99x1brscPzpqmmq")
-	dsKey := CidToDsKey(c)
-	c2, err := DsKeyToCid(dsKey)
+	dsKey := MultihashToDsKey(c.Hash())
+	mh, err := DsKeyToMultihash(dsKey)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if string(c.Hash()) != string(c2.Hash()) {
-		t.Fatal("should have parsed the same key")
+	if string(c.Hash()) != string(mh) {
+		t.Fatal("should have parsed the same multihash")
 	}
-	if c.Equals(c2) || c2.Type() != cid.Raw || c2.Version() != 1 {
+
+	c2, err := DsKeyToCidV1Raw(dsKey)
+	if err != nil || c.Equals(c2) || c2.Type() != cid.Raw || c2.Version() != 1 {
 		t.Fatal("should have been converted to CIDv1-raw")
 	}
 }