feat(pinning): add support for names

CHANGELOG.md

@@ -16,6 +16,8 @@ The following emojis are used to highlight certain changes:
 
 ### Added
 
+* 🛠 `pinning/pinner`: you can now give a custom name when pinning a CID. To reflect this, the `Pinner` has been adjusted.
+
 ### Changed
 
 ### Removed

pinning/pinner/dspinner/pin.go

@@ -174,20 +174,20 @@
 }
 
 // Pin the given node, optionally recursive
-func (p *pinner) Pin(ctx context.Context, node ipld.Node, recurse bool) error {
+func (p *pinner) Pin(ctx context.Context, node ipld.Node, recurse bool, name string) error {
 	err := p.dserv.Add(ctx, node)
 	if err != nil {
 		return err
 	}
 
 	if recurse {
-		return p.doPinRecursive(ctx, node.Cid(), true)
+		return p.doPinRecursive(ctx, node.Cid(), true, name)
 	} else {
-		return p.doPinDirect(ctx, node.Cid())
+		return p.doPinDirect(ctx, node.Cid(), name)
 	}
 }
 
-func (p *pinner) doPinRecursive(ctx context.Context, c cid.Cid, fetch bool) error {
+func (p *pinner) doPinRecursive(ctx context.Context, c cid.Cid, fetch bool, name string) error {
 	cidKey := c.KeyString()
 
 	p.lock.Lock()
@@ -243,14 +243,14 @@
 		}
 	}
 
-	_, err = p.addPin(ctx, c, ipfspinner.Recursive, "")
+	_, err = p.addPin(ctx, c, ipfspinner.Recursive, name)
 	if err != nil {
 		return err
 	}
 	return p.flushPins(ctx, false)
 }
 
-func (p *pinner) doPinDirect(ctx context.Context, c cid.Cid) error {
+func (p *pinner) doPinDirect(ctx context.Context, c cid.Cid, name string) error {
 	cidKey := c.KeyString()
 
 	p.lock.Lock()
@@ -264,7 +264,7 @@
 		return fmt.Errorf("%s already pinned recursively", c.String())
 	}
 
-	_, err = p.addPin(ctx, c, ipfspinner.Direct, "")
+	_, err = p.addPin(ctx, c, ipfspinner.Direct, name)
 	if err != nil {
 		return err
 	}
@@ -665,17 +665,17 @@
 }
 
 // DirectKeys returns a slice containing the directly pinned keys
-func (p *pinner) DirectKeys(ctx context.Context) <-chan ipfspinner.StreamedCid {
-	return p.streamIndex(ctx, p.cidDIndex)
+func (p *pinner) DirectKeys(ctx context.Context, detailed bool) <-chan ipfspinner.StreamedPin {
+	return p.streamIndex(ctx, p.cidDIndex, detailed)
 }
 
 // RecursiveKeys returns a slice containing the recursively pinned keys
-func (p *pinner) RecursiveKeys(ctx context.Context) <-chan ipfspinner.StreamedCid {
-	return p.streamIndex(ctx, p.cidRIndex)
+func (p *pinner) RecursiveKeys(ctx context.Context, detailed bool) <-chan ipfspinner.StreamedPin {
+	return p.streamIndex(ctx, p.cidRIndex, detailed)
 }
 
-func (p *pinner) streamIndex(ctx context.Context, index dsindex.Indexer) <-chan ipfspinner.StreamedCid {
-	out := make(chan ipfspinner.StreamedCid)
+func (p *pinner) streamIndex(ctx context.Context, index dsindex.Indexer, detailed bool) <-chan ipfspinner.StreamedPin {
+	out := make(chan ipfspinner.StreamedPin)
 
 	go func() {
 		defer close(out)
@@ -688,21 +688,37 @@
 		err := index.ForEach(ctx, "", func(key, value string) bool {
 			c, err := cid.Cast([]byte(key))
 			if err != nil {
-				out <- ipfspinner.StreamedCid{Err: err}
+				out <- ipfspinner.StreamedPin{Err: err}
 				return false
 			}
+
+			var pin ipfspinner.Pinned
+			if detailed {
+				pp, err := p.loadPin(ctx, value)
+				if err != nil {
+					out <- ipfspinner.StreamedPin{Err: err}
+					return false
+				}
+
+				pin.Key = pp.Cid
+				pin.Mode = pp.Mode
+				pin.Name = pp.Name
+			} else {
+				pin.Key = c
+			}
+
 			if !cidSet.Has(c) {
 				select {
 				case <-ctx.Done():
 					return false
-				case out <- ipfspinner.StreamedCid{C: c}:
+				case out <- ipfspinner.StreamedPin{Pin: pin}:
 				}
 				cidSet.Add(c)
 			}
 			return true
 		})
 		if err != nil {
-			out <- ipfspinner.StreamedCid{Err: err}
+			out <- ipfspinner.StreamedPin{Err: err}
 		}
 	}()
 
@@ -711,8 +727,8 @@
 
 // InternalPins returns all cids kept pinned for the internal state of the
 // pinner
-func (p *pinner) InternalPins(ctx context.Context) <-chan ipfspinner.StreamedCid {
-	c := make(chan ipfspinner.StreamedCid)
+func (p *pinner) InternalPins(ctx context.Context, detailed bool) <-chan ipfspinner.StreamedPin {
+	c := make(chan ipfspinner.StreamedPin)
 	close(c)
 	return c
 }
@@ -725,11 +741,11 @@
 	p.lock.Lock()
 	defer p.lock.Unlock()
 
-	found, err := p.cidRIndex.HasAny(ctx, from.KeyString())
+	fromValues, err := p.cidRIndex.Search(ctx, from.KeyString())
 	if err != nil {
 		return err
 	}
-	if !found {
+	if len(fromValues) != 1 {
 		return errors.New("'from' cid was not recursively pinned already")
 	}
 
@@ -739,11 +755,11 @@
 	}
 
 	// Check if the `to` cid is already recursively pinned
-	found, err = p.cidRIndex.HasAny(ctx, to.KeyString())
+	toFound, err := p.cidRIndex.HasAny(ctx, to.KeyString())
 	if err != nil {
 		return err
 	}
-	if found {
+	if toFound {
 		return errors.New("'to' cid was already recursively pinned")
 	}
 
@@ -756,7 +772,13 @@
 		return err
 	}
 
-	_, err = p.addPin(ctx, to, ipfspinner.Recursive, "")
+	// Get pin information so that we can keep the name.
+	pin, err := p.loadPin(ctx, fromValues[0])
+	if err != nil {
+		return err
+	}
+
+	_, err = p.addPin(ctx, to, ipfspinner.Recursive, pin.Name)
 	if err != nil {
 		return err
 	}
@@ -809,13 +831,13 @@
 
 // PinWithMode allows the user to have fine grained control over pin
 // counts
-func (p *pinner) PinWithMode(ctx context.Context, c cid.Cid, mode ipfspinner.Mode) error {
+func (p *pinner) PinWithMode(ctx context.Context, c cid.Cid, mode ipfspinner.Mode, name string) error {
 	// TODO: remove his to support multiple pins per CID
 	switch mode {
 	case ipfspinner.Recursive:
-		return p.doPinRecursive(ctx, c, false)
+		return p.doPinRecursive(ctx, c, false, name)
 	case ipfspinner.Direct:
-		return p.doPinDirect(ctx, c)
+		return p.doPinDirect(ctx, c, name)
 	default:
 		return errors.New("unrecognized pin mode")
 	}