RFC: coreapi.Name,Key

core/coreapi/coreapi.go

@@ -29,6 +29,14 @@ func (api *CoreAPI) Dag() coreiface.DagAPI {
 	return &DagAPI{api, nil}
 }
 
+func (api *CoreAPI) Name() coreiface.NameAPI {
+	return &NameAPI{api, nil}
+}
+
+func (api *CoreAPI) Key() coreiface.KeyAPI {
+	return &KeyAPI{api, nil}
+}
+
 func (api *CoreAPI) ResolveNode(ctx context.Context, p coreiface.Path) (coreiface.Node, error) {
 	p, err := api.ResolvePath(ctx, p)
 	if err != nil {

core/coreapi/interface/interface.go

@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"io"
+	"time"
 
 	options "github.com/ipfs/go-ipfs/core/coreapi/interface/options"
 
@@ -32,11 +33,23 @@ type Reader interface {
 	io.Closer
 }
 
+type IpnsEntry interface {
+	Name() string
+	Value() Path
+}
+
+type Key interface {
+	Name() string
+	Path() Path
+}
+
 // CoreAPI defines an unified interface to IPFS for Go programs.
 type CoreAPI interface {
 	// Unixfs returns an implementation of Unixfs API
 	Unixfs() UnixfsAPI
 	Dag() DagAPI
+	Name() NameAPI
+	Key() KeyAPI
 
 	// ResolvePath resolves the path using Unixfs resolver
 	ResolvePath(context.Context, Path) (Path, error)
@@ -90,6 +103,81 @@ type DagAPI interface {
 	WithDepth(depth int) options.DagTreeOption
 }
 
+// NameAPI specifies the interface to IPNS.
+//
+// IPNS is a PKI namespace, where names are the hashes of public keys, and the
+// private key enables publishing new (signed) values. In both publish and
+// resolve, the default name used is the node's own PeerID, which is the hash of
+// its public key.
+//
+// You can use .Key API to list and generate more names and their respective keys.
+type NameAPI interface {
+	// Publish announces new IPNS name
+	Publish(ctx context.Context, path Path, opts ...options.NamePublishOption) (IpnsEntry, error)
+
+	// WithValidTime is an option for Publish which specifies for how long the
+	// entry will remain valid. Default value is 24h
+	WithValidTime(validTime time.Duration) options.NamePublishOption
+
+	// WithKey is an option for Publish which specifies the key to use for
+	// publishing. Default value is "self" which is the node's own PeerID.
+	// The key parameter must be either PeerID or keystore key alias.
+	//
+	// You can use KeyAPI to list and generate more names and their respective keys.
+	WithKey(key string) options.NamePublishOption
+
+	// Resolve attempts to resolve the newest version of the specified name
+	Resolve(ctx context.Context, name string, opts ...options.NameResolveOption) (Path, error)
+
+	// WithRecursive is an option for Resolve which specifies whether to perform a
+	// recursive lookup. Default value is false
+	WithRecursive(recursive bool) options.NameResolveOption
+
+	// WithLocal is an option for Resolve which specifies if the lookup should be
+	// offline. Default value is false
+	WithLocal(local bool) options.NameResolveOption
+
+	// WithCache is an option for Resolve which specifies if cache should be used.
+	// Default value is true
+	WithCache(cache bool) options.NameResolveOption
+}
+
+// KeyAPI specifies the interface to Keystore
+type KeyAPI interface {
+	// Generate generates new key, stores it in the keystore under the specified
+	// name and returns a base58 encoded multihash of it's public key
+	Generate(ctx context.Context, name string, opts ...options.KeyGenerateOption) (Key, error)
+
+	// WithType is an option for Generate which specifies which algorithm
+	// should be used for the key. Default is options.RSAKey
+	//
+	// Supported key types:
+	// * options.RSAKey
+	// * options.Ed25519Key
+	WithType(algorithm string) options.KeyGenerateOption
+
+	// WithSize is an option for Generate which specifies the size of the key to
+	// generated. Default is -1
+	//
+	// value of -1 means 'use default size for key type':
+	//  * 2048 for RSA
+	WithSize(size int) options.KeyGenerateOption
+
+	// Rename renames oldName key to newName. Returns the key and whether another
+	// key was overwritten, or an error
+	Rename(ctx context.Context, oldName string, newName string, opts ...options.KeyRenameOption) (Key, bool, error)
+
+	// WithForce is an option for Rename which specifies whether to allow to
+	// replace existing keys.
+	WithForce(force bool) options.KeyRenameOption
+
+	// List lists keys stored in keystore
+	List(ctx context.Context) ([]Key, error)
+
+	// Remove removes keys from keystore. Returns ipns path of the removed key
+	Remove(ctx context.Context, name string) (Path, error)
+}
+
 // type ObjectAPI interface {
 // 	New() (cid.Cid, Object)
 // 	Get(string) (Object, error)

core/coreapi/interface/options/key.go

@@ -0,0 +1,72 @@
+package options
+
+const (
+	RSAKey     = "rsa"
+	Ed25519Key = "ed25519"
+
+	DefaultRSALen = 2048
+)
+
+type KeyGenerateSettings struct {
+	Algorithm string
+	Size      int
+}
+
+type KeyRenameSettings struct {
+	Force bool
+}
+
+type KeyGenerateOption func(*KeyGenerateSettings) error
+type KeyRenameOption func(*KeyRenameSettings) error
+
+func KeyGenerateOptions(opts ...KeyGenerateOption) (*KeyGenerateSettings, error) {
+	options := &KeyGenerateSettings{
+		Algorithm: RSAKey,
+		Size:      -1,
+	}
+
+	for _, opt := range opts {
+		err := opt(options)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return options, nil
+}
+
+func KeyRenameOptions(opts ...KeyRenameOption) (*KeyRenameSettings, error) {
+	options := &KeyRenameSettings{
+		Force: false,
+	}
+
+	for _, opt := range opts {
+		err := opt(options)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return options, nil
+}
+
+type KeyOptions struct{}
+
+func (api *KeyOptions) WithType(algorithm string) KeyGenerateOption {
+	return func(settings *KeyGenerateSettings) error {
+		settings.Algorithm = algorithm
+		return nil
+	}
+}
+
+func (api *KeyOptions) WithSize(size int) KeyGenerateOption {
+	return func(settings *KeyGenerateSettings) error {
+		settings.Size = size
+		return nil
+	}
+}
+
+func (api *KeyOptions) WithForce(force bool) KeyRenameOption {
+	return func(settings *KeyRenameSettings) error {
+		settings.Force = force
+		return nil
+	}
+}

core/coreapi/interface/options/name.go

@@ -0,0 +1,93 @@
+package options
+
+import (
+	"time"
+)
+
+const (
+	DefaultNameValidTime = 24 * time.Hour
+)
+
+type NamePublishSettings struct {
+	ValidTime time.Duration
+	Key       string
+}
+
+type NameResolveSettings struct {
+	Recursive bool
+	Local     bool
+	Cache     bool
+}
+
+type NamePublishOption func(*NamePublishSettings) error
+type NameResolveOption func(*NameResolveSettings) error
+
+func NamePublishOptions(opts ...NamePublishOption) (*NamePublishSettings, error) {
+	options := &NamePublishSettings{
+		ValidTime: DefaultNameValidTime,
+		Key:       "self",
+	}
+
+	for _, opt := range opts {
+		err := opt(options)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return options, nil
+}
+
+func NameResolveOptions(opts ...NameResolveOption) (*NameResolveSettings, error) {
+	options := &NameResolveSettings{
+		Recursive: false,
+		Local:     false,
+		Cache:     true,
+	}
+
+	for _, opt := range opts {
+		err := opt(options)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return options, nil
+}
+
+type NameOptions struct{}
+
+func (api *NameOptions) WithValidTime(validTime time.Duration) NamePublishOption {
+	return func(settings *NamePublishSettings) error {
+		settings.ValidTime = validTime
+		return nil
+	}
+}
+
+func (api *NameOptions) WithKey(key string) NamePublishOption {
+	return func(settings *NamePublishSettings) error {
+		settings.Key = key
+		return nil
+	}
+}
+
+func (api *NameOptions) WithRecursive(recursive bool) NameResolveOption {
+	return func(settings *NameResolveSettings) error {
+		settings.Recursive = recursive
+		return nil
+	}
+}
+
+func (api *NameOptions) WithLocal(local bool) NameResolveOption {
+	return func(settings *NameResolveSettings) error {
+		settings.Local = local
+		return nil
+	}
+}
+
+func (api *NameOptions) WithCache(cache bool) NameResolveOption {
+	return func(settings *NameResolveSettings) error {
+		settings.Cache = cache
+		return nil
+	}
+}