Add --cid-base & --upgrade-cidv0 global opt. and enable them on select cmds

License: MIT
Signed-off-by: Kevin Atkinson <[email protected]>

Author: kevina

core/apicid.go

@@ -0,0 +1,131 @@
+package core
+
+import (
+	"encoding/json"
+
+	cid "gx/ipfs/QmPSQnBKM9g7BaUcZCvswUJVscQ1ipjmwxN5PXCjkp9EQ7/go-cid"
+	mbase "gx/ipfs/QmekxXDhCxCJRNuzmHreuaT3BsuJcsjcXWNrtV9C8DRHtd/go-multibase"
+	//path "gx/ipfs/QmX7uSbkNz76yNwBhuwYwRbhihLnJqM73VTCjS3UMJud9A/go-path"
+)
+
+// CidEncoder is a type used to encode or recode Cid as the user
+// specifies
+type CidEncoder interface {
+	Encode(c cid.Cid) string
+	Recode(v string) (string, error)
+}
+
+// BasicCidEncoder is a basic CidEncoder that will encode Cid's using
+// a specifed base, optionally upgrading a Cid if is Version 0
+type BasicCidEncoder struct {
+	Base    mbase.Encoder
+	Upgrade bool
+}
+
+var DefaultCidEncoder = BasicCidEncoder{
+	Base:    mbase.MustNewEncoder(mbase.Base58BTC),
+	Upgrade: false,
+}
+
+// CidJSONBase is the base to use when Encoding into JSON.
+//var CidJSONBase mbase.Encoder = mbase.MustNewEncoder(mbase.Base58BTC)
+var CidJSONBase mbase.Encoder = mbase.MustNewEncoder(mbase.Base32)
+
+// APICid is a type to respesnt CID in the API
+type APICid struct {
+	str string // always in CidJSONBase
+}
+
+// FromCid created an APICid from a Cid
+func FromCid(c cid.Cid) APICid {
+	return APICid{c.Encode(CidJSONBase)}
+}
+
+// Cid converts an APICid to a CID
+func (c APICid) Cid() (cid.Cid, error) {
+	return cid.Decode(c.str)
+}
+
+func (c APICid) String() string {
+	return c.Encode(DefaultCidEncoder)
+}
+
+func (c APICid) Encode(enc CidEncoder) string {
+	if c.str == "" {
+		return ""
+	}
+	str, err := enc.Recode(c.str)
+	if err != nil {
+		return c.str
+	}
+	return str
+}
+
+func (c *APICid) UnmarshalJSON(b []byte) error {
+	return json.Unmarshal(b, &c.str)
+}
+
+func (c APICid) MarshalJSON() ([]byte, error) {
+	return json.Marshal(c.str)
+}
+
+func (enc BasicCidEncoder) Encode(c cid.Cid) string {
+	if c.Version() == 0 {
+		c = cid.NewCidV1(c.Type(), c.Hash())
+	}
+	return c.Encode(enc.Base)
+}
+
+func (enc BasicCidEncoder) Recode(v string) (string, error) {
+	skip, err := enc.NoopRecode(v)
+	if skip || err != nil {
+		return v, err
+	}
+
+	c, err := cid.Decode(v)
+	if err != nil {
+		return v, err
+	}
+
+	return enc.Encode(c), nil
+}
+
+func (enc BasicCidEncoder) NoopRecode(v string) (bool, error) {
+	if len(v) < 2 {
+		return false, cid.ErrCidTooShort
+	}
+	ver := cidVer(v)
+	skip := ver == 0 && !enc.Upgrade || ver == 1 && v[0] == byte(enc.Base.Encoding())
+	return skip, nil
+}
+
+func cidVer(v string) int {
+	if len(v) == 46 && v[:2] == "Qm" {
+		return 0
+	} else {
+		return 1
+	}
+}
+
+// func (enc *CidEncoder) Scan(cids ...string) {
+// 	if enc.Override == nil {
+// 		enc.Override = map[cid.Cid]string{}
+// 	}
+// 	for _, p := range cids {
+// 		//segs := path.FromString(p).Segments()
+// 		//v := segs[0]
+// 		//if v == "ipfs" && len(segs) > 0 {
+// 		//	v = segs[1]
+// 		//}
+// 		v := p
+// 		skip, err := enc.noopRecode(v)
+// 		if skip || err != nil {
+// 			continue
+// 		}
+// 		c, err := cid.Decode(v)
+// 		if err != nil {
+// 			continue
+// 		}
+// 		enc.Override[c] = v
+// 	}
+// }

core/commands/add.go

@@ -390,6 +390,12 @@ You can now check what blocks have been created by:
 				log.Warning("cannot determine size of input file")
 			}
 
+			err := HandleCidBase(req)
+			if err != nil {
+				re.SetError(err, cmdkit.ErrNormal)
+				return re
+			}
+
 			progressBar := func(wait chan struct{}) {
 				defer close(wait)
 
@@ -425,8 +431,9 @@ You can now check what blocks have been created by:
 							break LOOP
 						}
 						output := out.(*coreunix.AddedObject)
-						if len(output.Hash) > 0 {
-							lastHash = output.Hash
+						hash := output.Hash.String()
+						if len(hash) > 0 {
+							lastHash = hash
 							if quieter {
 								continue
 							}
@@ -436,9 +443,9 @@ You can now check what blocks have been created by:
 								fmt.Fprintf(os.Stderr, "\033[2K\r")
 							}
 							if quiet {
-								fmt.Fprintf(os.Stdout, "%s\n", output.Hash)
+								fmt.Fprintf(os.Stdout, "%s\n", hash)
 							} else {
-								fmt.Fprintf(os.Stdout, "added %s %s\n", output.Hash, output.Name)
+								fmt.Fprintf(os.Stdout, "added %s %s\n", hash, output.Name)
 							}
 
 						} else {

core/commands/ls.go

@@ -24,9 +24,10 @@ import (
 )
 
 type LsLink struct {
-	Name, Hash string
-	Size       uint64
-	Type       unixfspb.Data_DataType
+	Name string
+	Hash core.APICid
+	Size uint64
+	Type unixfspb.Data_DataType
 }
 
 type LsObject struct {
@@ -160,7 +161,7 @@ The JSON output contains type information.
 				}
 				output[i].Links[j] = LsLink{
 					Name: link.Name,
-					Hash: link.Cid.String(),
+					Hash: core.FromCid(link.Cid),
 					Size: link.Size,
 					Type: t,
 				}
@@ -171,6 +172,10 @@ The JSON output contains type information.
 	},
 	Marshalers: cmds.MarshalerMap{
 		cmds.Text: func(res cmds.Response) (io.Reader, error) {
+			err := HandleCidBaseLegacy(res.Request())
+			if err != nil {
+				return nil, err
+			}
 
 			v, err := unwrapOutput(res.Output())
 			if err != nil {

core/commands/pin.go

@@ -39,11 +39,11 @@ var PinCmd = &cmds.Command{
 }
 
 type PinOutput struct {
-	Pins []string
+	Pins []core.APICid
 }
 
 type AddPinOutput struct {
-	Pins     []string
+	Pins     []core.APICid
 	Progress int `json:",omitempty"`
 }
 
@@ -84,7 +84,7 @@ var addPinCmd = &cmds.Command{
 				res.SetError(err, cmdkit.ErrNormal)
 				return
 			}
-			res.SetOutput(&AddPinOutput{Pins: cidsToStrings(added)})
+			res.SetOutput(&AddPinOutput{Pins: toAPICids(added)})
 			return
 		}
 
@@ -117,7 +117,7 @@ var addPinCmd = &cmds.Command{
 				if pv := v.Value(); pv != 0 {
 					out <- &AddPinOutput{Progress: v.Value()}
 				}
-				out <- &AddPinOutput{Pins: cidsToStrings(val.pins)}
+				out <- &AddPinOutput{Pins: toAPICids(val.pins)}
 				return
 			case <-ticker.C:
 				out <- &AddPinOutput{Progress: v.Value()}
@@ -130,12 +130,16 @@ var addPinCmd = &cmds.Command{
 	},
 	Marshalers: cmds.MarshalerMap{
 		cmds.Text: func(res cmds.Response) (io.Reader, error) {
+			err := HandleCidBaseLegacy(res.Request())
+			if err != nil {
+				return nil, err
+			}
 			v, err := unwrapOutput(res.Output())
 			if err != nil {
 				return nil, err
 			}
 
-			var added []string
+			var added []core.APICid
 
 			switch out := v.(type) {
 			case *AddPinOutput:
@@ -206,10 +210,14 @@ collected if needed. (By default, recursively. Use -r=false for direct pins.)
 			return
 		}
 
-		res.SetOutput(&PinOutput{cidsToStrings(removed)})
+		res.SetOutput(&PinOutput{toAPICids(removed)})
 	},
 	Marshalers: cmds.MarshalerMap{
 		cmds.Text: func(res cmds.Response) (io.Reader, error) {
+			err := HandleCidBaseLegacy(res.Request())
+			if err != nil {
+				return nil, err
+			}
 			v, err := unwrapOutput(res.Output())
 			if err != nil {
 				return nil, err
@@ -318,6 +326,10 @@ Example:
 	Type: RefKeyList{},
 	Marshalers: cmds.MarshalerMap{
 		cmds.Text: func(res cmds.Response) (io.Reader, error) {
+			err := HandleCidBaseLegacy(res.Request())
+			if err != nil {
+				return nil, err
+			}
 			v, err := unwrapOutput(res.Output())
 			if err != nil {
 				return nil, err
@@ -345,6 +357,10 @@ Example:
 	},
 }
 
+type UpdatePinOutput struct {
+	Pins []string // really paths
+}
+
 var updatePinCmd = &cmds.Command{
 	Helptext: cmdkit.HelpText{
 		Tagline: "Update a recursive pin",
@@ -362,7 +378,7 @@ new pin and removing the old one.
 	Options: []cmdkit.Option{
 		cmdkit.BoolOption("unpin", "Remove the old pin.").WithDefault(true),
 	},
-	Type: PinOutput{},
+	Type: UpdatePinOutput{},
 	Run: func(req cmds.Request, res cmds.Response) {
 		n, err := req.InvocContext().GetNode()
 		if err != nil {
@@ -417,7 +433,7 @@ new pin and removing the old one.
 			return
 		}
 
-		res.SetOutput(&PinOutput{Pins: []string{from.String(), to.String()}})
+		res.SetOutput(&UpdatePinOutput{Pins: []string{from.String(), to.String()}})
 	},
 	Marshalers: cmds.MarshalerMap{
 		cmds.Text: func(res cmds.Response) (io.Reader, error) {
@@ -680,10 +696,10 @@ func (r PinVerifyRes) Format(out io.Writer) {
 	}
 }
 
-func cidsToStrings(cs []cid.Cid) []string {
-	out := make([]string, 0, len(cs))
+func toAPICids(cs []cid.Cid) []core.APICid {
+	out := make([]core.APICid, 0, len(cs))
 	for _, c := range cs {
-		out = append(out, c.String())
+		out = append(out, core.FromCid(c))
 	}
 	return out
 }

core/commands/root.go

@@ -7,6 +7,7 @@ import (
 
 	oldcmds "github.com/ipfs/go-ipfs/commands"
 	lgc "github.com/ipfs/go-ipfs/commands/legacy"
+	core "github.com/ipfs/go-ipfs/core"
 	dag "github.com/ipfs/go-ipfs/core/commands/dag"
 	e "github.com/ipfs/go-ipfs/core/commands/e"
 	name "github.com/ipfs/go-ipfs/core/commands/name"
@@ -16,14 +17,17 @@ import (
 	"gx/ipfs/QmPTfgFTo9PFr1PvPKyKoeMgBvYPh6cX3aDP7DHKVbnCbi/go-ipfs-cmds"
 	logging "gx/ipfs/QmRREK2CAZ5Re2Bd9zZFG6FeYDppUWt5cMgsoUEp3ktgSr/go-log"
 	"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
+	mbase "gx/ipfs/QmekxXDhCxCJRNuzmHreuaT3BsuJcsjcXWNrtV9C8DRHtd/go-multibase"
 )
 
 var log = logging.Logger("core/commands")
 
 var ErrNotOnline = errors.New("this command must be run in online mode. Try running 'ipfs daemon' first")
 
 const (
-	ApiOption = "api"
+	ApiOption          = "api"
+	CidBaseOption      = "cid-base"
+	UpgradeCidV0Option = "upgrade-cidv0"
 )
 
 var Root = &cmds.Command{
@@ -95,6 +99,8 @@ The CLI will exit with one of the following values:
 		cmdkit.BoolOption("h", "Show a short version of the command help text."),
 		cmdkit.BoolOption("local", "L", "Run the command locally, instead of using the daemon."),
 		cmdkit.StringOption(ApiOption, "Use a specific API instance (defaults to /ip4/127.0.0.1/tcp/5001)"),
+		cmdkit.StringOption(CidBaseOption, "mbase", "Multi-base to use to encode version 1 CIDs in output."),
+		cmdkit.BoolOption(UpgradeCidV0Option, "Upgrade CID version 0 to version 1 in output."),
 
 		// global options, added to every command
 		cmds.OptionEncodingType,
@@ -222,3 +228,35 @@ func MessageTextMarshaler(res oldcmds.Response) (io.Reader, error) {
 
 	return strings.NewReader(out.Message), nil
 }
+
+func handleCidBase(base string, upgrade bool, upgradeDefined bool) error {
+	enc := core.DefaultCidEncoder
+
+	if base != "" {
+		var err error
+		enc.Base, err = mbase.EncoderByName(base)
+		if err != nil {
+			return err
+		}
+	}
+
+	enc.Upgrade = upgrade
+	if base != "" && !upgradeDefined {
+		enc.Upgrade = true
+	}
+
+	core.DefaultCidEncoder = enc
+	return nil
+}
+
+func HandleCidBase(req *cmds.Request) error {
+	base, _ := req.Options[CidBaseOption].(string)
+	upgrade, defined := req.Options[UpgradeCidV0Option].(bool)
+	return handleCidBase(base, upgrade, defined)
+}
+
+func HandleCidBaseLegacy(req oldcmds.Request) error {
+	base, _, _ := req.Option(CidBaseOption).String()
+	upgrade, defined, _ := req.Option(UpgradeCidV0Option).Bool()
+	return handleCidBase(base, upgrade, defined)
+}