github.com/keltia/go-ipfs@v0.3.8-0.20150909044612-210793031c63/core/corerepo/pinning.go (about)

     1  /*
     2  Package corerepo provides pinning and garbage collection for local
     3  IPFS block services.
     4  
     5  IPFS nodes will keep local copies of any object that have either been
     6  added or requested locally.  Not all of these objects are worth
     7  preserving forever though, so the node adminstrator can pin objects
     8  they want to keep and unpin objects that they don't care about.
     9  
    10  Garbage collection sweeps iterate through the local block store
    11  removing objects that aren't pinned, which frees storage space for new
    12  objects.
    13  */
    14  package corerepo
    15  
    16  import (
    17  	"fmt"
    18  
    19  	context "github.com/ipfs/go-ipfs/Godeps/_workspace/src/golang.org/x/net/context"
    20  
    21  	key "github.com/ipfs/go-ipfs/blocks/key"
    22  	"github.com/ipfs/go-ipfs/core"
    23  	"github.com/ipfs/go-ipfs/merkledag"
    24  	path "github.com/ipfs/go-ipfs/path"
    25  )
    26  
    27  func Pin(n *core.IpfsNode, ctx context.Context, paths []string, recursive bool) ([]key.Key, error) {
    28  	dagnodes := make([]*merkledag.Node, 0)
    29  	for _, fpath := range paths {
    30  		dagnode, err := core.Resolve(ctx, n, path.Path(fpath))
    31  		if err != nil {
    32  			return nil, fmt.Errorf("pin: %s", err)
    33  		}
    34  		dagnodes = append(dagnodes, dagnode)
    35  	}
    36  
    37  	var out []key.Key
    38  	for _, dagnode := range dagnodes {
    39  		k, err := dagnode.Key()
    40  		if err != nil {
    41  			return nil, err
    42  		}
    43  
    44  		ctx, cancel := context.WithCancel(ctx)
    45  		defer cancel()
    46  		err = n.Pinning.Pin(ctx, dagnode, recursive)
    47  		if err != nil {
    48  			return nil, fmt.Errorf("pin: %s", err)
    49  		}
    50  		out = append(out, k)
    51  	}
    52  
    53  	err := n.Pinning.Flush()
    54  	if err != nil {
    55  		return nil, err
    56  	}
    57  
    58  	return out, nil
    59  }
    60  
    61  func Unpin(n *core.IpfsNode, ctx context.Context, paths []string, recursive bool) ([]key.Key, error) {
    62  
    63  	dagnodes := make([]*merkledag.Node, 0)
    64  	for _, fpath := range paths {
    65  		dagnode, err := core.Resolve(ctx, n, path.Path(fpath))
    66  		if err != nil {
    67  			return nil, err
    68  		}
    69  		dagnodes = append(dagnodes, dagnode)
    70  	}
    71  
    72  	var unpinned []key.Key
    73  	for _, dagnode := range dagnodes {
    74  		k, _ := dagnode.Key()
    75  
    76  		ctx, cancel := context.WithCancel(ctx)
    77  		defer cancel()
    78  		err := n.Pinning.Unpin(ctx, k, recursive)
    79  		if err != nil {
    80  			return nil, err
    81  		}
    82  		unpinned = append(unpinned, k)
    83  	}
    84  
    85  	err := n.Pinning.Flush()
    86  	if err != nil {
    87  		return nil, err
    88  	}
    89  	return unpinned, nil
    90  }