namesys

Documentation

Overview

Package namesys implements resolvers and publishers for the IPFS naming system (IPNS).

The core of IPFS is an immutable, content-addressable Merkle graph. That works well for many use cases, but doesn't allow you to answer questions like "what is Alice's current homepage?". The mutable name system allows Alice to publish information like:

The current homepage for alice.example.com is
/ipfs/Qmcqtw8FfrVSBaRmbWwHxt3AuySBhJLcvmFYi3Lbc4xnwj

or:

The current homepage for node
QmatmE9msSfkKxoffpHwNLNKgwZG8eT9Bud6YoPab52vpy
is
/ipfs/Qmcqtw8FfrVSBaRmbWwHxt3AuySBhJLcvmFYi3Lbc4xnwj

The mutable name system also allows users to resolve those references to find the immutable IPFS object currently referenced by a given mutable name.

For command-line bindings to this functionality, see:

ipfs name
ipfs dns
ipfs resolve

Index

• Constants
• Variables
• func CreateRoutingEntryData(pk ci.PrivKey, val path.Path, seq uint64, eol time.Time) (*pb.IpnsEntry, error)
• func InitializeKeyspace(ctx context.Context, ds dag.DAGService, pub Publisher, pins pin.Pinner, ...) error
• func IpnsKeysForID(id peer.ID) (name, ipns key.Key)
• func IpnsSelectorFunc(k key.Key, vals [][]byte) (int, error)
• func NewRoutingPublisher(route routing.IpfsRouting, ds ds.Datastore) *ipnsPublisher
• func NewRoutingResolver(route routing.IpfsRouting, cachesize int) *routingResolver
• func PublishEntry(ctx context.Context, r routing.IpfsRouting, ipnskey key.Key, rec *pb.IpnsEntry) error
• func PublishPublicKey(ctx context.Context, r routing.IpfsRouting, k key.Key, pubk ci.PubKey) error
• func PutRecordToRouting(ctx context.Context, k ci.PrivKey, value path.Path, seqnum uint64, ...) error
• func ValidateIpnsRecord(k key.Key, val []byte) error
• type DNSResolver
  • func (r *DNSResolver) Resolve(ctx context.Context, name string) (path.Path, error)
  • func (r *DNSResolver) ResolveN(ctx context.Context, name string, depth int) (path.Path, error)
• type LookupTXTFunc
• type NameSystem
  • func NewNameSystem(r routing.IpfsRouting, ds ds.Datastore, cachesize int) NameSystem
• type ProquintResolver
  • func (r *ProquintResolver) Resolve(ctx context.Context, name string) (path.Path, error)
  • func (r *ProquintResolver) ResolveN(ctx context.Context, name string, depth int) (path.Path, error)
• type Publisher
• type Resolver
  • func NewDNSResolver() Resolver

Constants

const (
	// DefaultDepthLimit is the default depth limit used by Resolve.
	DefaultDepthLimit = 32

	// UnlimitedDepth allows infinite recursion in ResolveN.  You
	// probably don't want to use this, but it's here if you absolutely
	// trust resolution to eventually complete and can't put an upper
	// limit on how many steps it will take.
	UnlimitedDepth = 0
)

const DefaultResolverCacheTTL = time.Minute

Variables

var ErrExpiredRecord = errors.New("expired record")

ErrExpiredRecord should be returned when an ipns record is invalid due to being too old

var ErrPublishFailed = errors.New("Could not publish name.")

ErrPublishFailed signals an error when attempting to publish.

var ErrResolveFailed = errors.New("Could not resolve name.")

ErrResolveFailed signals an error when attempting to resolve.

var ErrResolveRecursion = errors.New(
	"Could not resolve name (recursion limit exceeded).")

ErrResolveRecursion signals a recursion-depth limit.

var ErrUnrecognizedValidity = errors.New("unrecognized validity type")

ErrUnrecognizedValidity is returned when an IpnsRecord has an unknown validity type.

var IpnsRecordValidator = &record.ValidChecker{
	Func: ValidateIpnsRecord,
	Sign: true,
}

var PublishPutValTimeout = time.Minute

Functions

func CreateRoutingEntryData

func CreateRoutingEntryData(pk ci.PrivKey, val path.Path, seq uint64, eol time.Time) (*pb.IpnsEntry, error)

func InitializeKeyspace

func InitializeKeyspace(ctx context.Context, ds dag.DAGService, pub Publisher, pins pin.Pinner, key ci.PrivKey) error

InitializeKeyspace sets the ipns record for the given key to point to an empty directory. TODO: this doesnt feel like it belongs here

func IpnsKeysForID

func IpnsKeysForID(id peer.ID) (name, ipns key.Key)

func IpnsSelectorFunc

func IpnsSelectorFunc(k key.Key, vals [][]byte) (int, error)

func NewRoutingPublisher

func NewRoutingPublisher(route routing.IpfsRouting, ds ds.Datastore) *ipnsPublisher

NewRoutingPublisher constructs a publisher for the IPFS Routing name system.

func NewRoutingResolver

func NewRoutingResolver(route routing.IpfsRouting, cachesize int) *routingResolver

NewRoutingResolver constructs a name resolver using the IPFS Routing system to implement SFS-like naming on top. cachesize is the limit of the number of entries in the lru cache. Setting it to '0' will disable caching.

func PublishEntry

func PublishEntry(ctx context.Context, r routing.IpfsRouting, ipnskey key.Key, rec *pb.IpnsEntry) error

func PublishPublicKey

func PublishPublicKey(ctx context.Context, r routing.IpfsRouting, k key.Key, pubk ci.PubKey) error

func PutRecordToRouting

func PutRecordToRouting(ctx context.Context, k ci.PrivKey, value path.Path, seqnum uint64, eol time.Time, r routing.IpfsRouting, id peer.ID) error

func ValidateIpnsRecord

func ValidateIpnsRecord(k key.Key, val []byte) error

ValidateIpnsRecord implements ValidatorFunc and verifies that the given 'val' is an IpnsEntry and that that entry is valid.

Types

type DNSResolver

type DNSResolver struct {
	// contains filtered or unexported fields
}

DNSResolver implements a Resolver on DNS domains

func (*DNSResolver) Resolve

func (r *DNSResolver) Resolve(ctx context.Context, name string) (path.Path, error)

Resolve implements Resolver.

func (*DNSResolver) ResolveN

func (r *DNSResolver) ResolveN(ctx context.Context, name string, depth int) (path.Path, error)

ResolveN implements Resolver.

type LookupTXTFunc

type LookupTXTFunc func(name string) (txt []string, err error)

type NameSystem

type NameSystem interface {
	Resolver
	Publisher
}

Namesys represents a cohesive name publishing and resolving system.

Publishing a name is the process of establishing a mapping, a key-value pair, according to naming rules and databases.

Resolving a name is the process of looking up the value associated with the key (name).

func NewNameSystem

func NewNameSystem(r routing.IpfsRouting, ds ds.Datastore, cachesize int) NameSystem

NewNameSystem will construct the IPFS naming system based on Routing

type ProquintResolver

type ProquintResolver struct{}

func (*ProquintResolver) Resolve

func (r *ProquintResolver) Resolve(ctx context.Context, name string) (path.Path, error)

Resolve implements Resolver.

func (*ProquintResolver) ResolveN

func (r *ProquintResolver) ResolveN(ctx context.Context, name string, depth int) (path.Path, error)

ResolveN implements Resolver.

type Publisher

type Publisher interface {

	// Publish establishes a name-value mapping.
	// TODO make this not PrivKey specific.
	Publish(ctx context.Context, name ci.PrivKey, value path.Path) error

	// TODO: to be replaced by a more generic 'PublishWithValidity' type
	// call once the records spec is implemented
	PublishWithEOL(ctx context.Context, name ci.PrivKey, value path.Path, eol time.Time) error
}

Publisher is an object capable of publishing particular names.

type Resolver

type Resolver interface {

	// Resolve performs a recursive lookup, returning the dereferenced
	// path.  For example, if ipfs.io has a DNS TXT record pointing to
	//   /ipns/QmatmE9msSfkKxoffpHwNLNKgwZG8eT9Bud6YoPab52vpy
	// and there is a DHT IPNS entry for
	//   QmatmE9msSfkKxoffpHwNLNKgwZG8eT9Bud6YoPab52vpy
	//   -> /ipfs/Qmcqtw8FfrVSBaRmbWwHxt3AuySBhJLcvmFYi3Lbc4xnwj
	// then
	//   Resolve(ctx, "/ipns/ipfs.io")
	// will resolve both names, returning
	//   /ipfs/Qmcqtw8FfrVSBaRmbWwHxt3AuySBhJLcvmFYi3Lbc4xnwj
	//
	// There is a default depth-limit to avoid infinite recursion.  Most
	// users will be fine with this default limit, but if you need to
	// adjust the limit you can use ResolveN.
	Resolve(ctx context.Context, name string) (value path.Path, err error)

	// ResolveN performs a recursive lookup, returning the dereferenced
	// path.  The only difference from Resolve is that the depth limit
	// is configurable.  You can use DefaultDepthLimit, UnlimitedDepth,
	// or a depth limit of your own choosing.
	//
	// Most users should use Resolve, since the default limit works well
	// in most real-world situations.
	ResolveN(ctx context.Context, name string, depth int) (value path.Path, err error)
}

Resolver is an object capable of resolving names.

func NewDNSResolver

func NewDNSResolver() Resolver

NewDNSResolver constructs a name resolver using DNS TXT records.