github.com/zignig/go-ipfs@v0.0.0-20141111235910-c9e5fdf55a52/core/commands2/pin.go (about)

     1  package commands
     2  
     3  import (
     4  	"fmt"
     5  
     6  	cmds "github.com/jbenet/go-ipfs/commands"
     7  	"github.com/jbenet/go-ipfs/core"
     8  	"github.com/jbenet/go-ipfs/core/commands2/internal"
     9  	"github.com/jbenet/go-ipfs/merkledag"
    10  )
    11  
    12  var pinCmd = &cmds.Command{
    13  	Description: "Keeps objects stored locally",
    14  
    15  	Subcommands: map[string]*cmds.Command{
    16  		"add": addPinCmd,
    17  		"rm":  rmPinCmd,
    18  	},
    19  }
    20  
    21  var addPinCmd = &cmds.Command{
    22  	Description: "Pins objects to local storage",
    23  	Help: `Retrieves the object named by <ipfs-path> and stores it locally
    24  on disk.
    25  `,
    26  
    27  	Arguments: []cmds.Argument{
    28  		cmds.StringArg("ipfs-path", true, true, "Path to object(s) to be pinned"),
    29  	},
    30  	Options: []cmds.Option{
    31  		cmds.BoolOption("recursive", "r", "Recursively pin the object linked to by the specified object(s)"),
    32  	},
    33  	Run: func(req cmds.Request) (interface{}, error) {
    34  		n := req.Context().Node
    35  
    36  		// set recursive flag
    37  		recursive, _ := req.Option("recursive").Bool() // false if cast fails.
    38  
    39  		paths, err := internal.CastToStrings(req.Arguments())
    40  		if err != nil {
    41  			return nil, err
    42  		}
    43  
    44  		_, err = pin(n, paths, recursive)
    45  		if err != nil {
    46  			return nil, err
    47  		}
    48  
    49  		// TODO: create some output to show what got pinned
    50  		return nil, nil
    51  	},
    52  }
    53  
    54  var rmPinCmd = &cmds.Command{
    55  	Description: "Unpin an object from local storage",
    56  	Help: `Removes the pin from the given object allowing it to be garbage
    57  collected if needed.
    58  `,
    59  
    60  	Arguments: []cmds.Argument{
    61  		cmds.StringArg("ipfs-path", true, true, "Path to object(s) to be unpinned"),
    62  	},
    63  	Options: []cmds.Option{
    64  		cmds.BoolOption("recursive", "r", "Recursively unpin the object linked to by the specified object(s)"),
    65  	},
    66  	Run: func(req cmds.Request) (interface{}, error) {
    67  		n := req.Context().Node
    68  
    69  		// set recursive flag
    70  		recursive, _ := req.Option("recursive").Bool() // false if cast fails.
    71  
    72  		paths, err := internal.CastToStrings(req.Arguments())
    73  		if err != nil {
    74  			return nil, err
    75  		}
    76  
    77  		_, err = unpin(n, paths, recursive)
    78  		if err != nil {
    79  			return nil, err
    80  		}
    81  
    82  		// TODO: create some output to show what got unpinned
    83  		return nil, nil
    84  	},
    85  }
    86  
    87  func pin(n *core.IpfsNode, paths []string, recursive bool) ([]*merkledag.Node, error) {
    88  
    89  	dagnodes := make([]*merkledag.Node, 0)
    90  	for _, path := range paths {
    91  		dagnode, err := n.Resolver.ResolvePath(path)
    92  		if err != nil {
    93  			return nil, fmt.Errorf("pin error: %v", err)
    94  		}
    95  		dagnodes = append(dagnodes, dagnode)
    96  	}
    97  
    98  	for _, dagnode := range dagnodes {
    99  		err := n.Pinning.Pin(dagnode, recursive)
   100  		if err != nil {
   101  			return nil, fmt.Errorf("pin: %v", err)
   102  		}
   103  	}
   104  
   105  	err := n.Pinning.Flush()
   106  	if err != nil {
   107  		return nil, err
   108  	}
   109  
   110  	return dagnodes, nil
   111  }
   112  
   113  func unpin(n *core.IpfsNode, paths []string, recursive bool) ([]*merkledag.Node, error) {
   114  
   115  	dagnodes := make([]*merkledag.Node, 0)
   116  	for _, path := range paths {
   117  		dagnode, err := n.Resolver.ResolvePath(path)
   118  		if err != nil {
   119  			return nil, err
   120  		}
   121  		dagnodes = append(dagnodes, dagnode)
   122  	}
   123  
   124  	for _, dagnode := range dagnodes {
   125  		k, _ := dagnode.Key()
   126  		err := n.Pinning.Unpin(k, recursive)
   127  		if err != nil {
   128  			return nil, err
   129  		}
   130  	}
   131  
   132  	err := n.Pinning.Flush()
   133  	if err != nil {
   134  		return nil, err
   135  	}
   136  	return dagnodes, nil
   137  }