go-ipfs: github.com/ipfs/go-ipfs/namesys Index | Files | Directories

package namesys

import "github.com/ipfs/go-ipfs/namesys"

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

Package Files

base.go cache.go dns.go interface.go namesys.go proquint.go publisher.go routing.go

Constants

const DefaultRecordEOL = 24 * time.Hour
const DefaultResolverCacheTTL = time.Minute
const PublishPutValTimeout = time.Minute

Variables

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.

func InitializeKeyspace Uses

func InitializeKeyspace(ctx context.Context, 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 IpnsDsKey Uses

func IpnsDsKey(id peer.ID) ds.Key

func PkKeyForID Uses

func PkKeyForID(id peer.ID) string

PkKeyForID returns the public key routing key for the given peer ID.

func PublishEntry Uses

func PublishEntry(ctx context.Context, r routing.ValueStore, ipnskey string, rec *pb.IpnsEntry) error

func PublishPublicKey Uses

func PublishPublicKey(ctx context.Context, r routing.ValueStore, k string, pubk ci.PubKey) error

func PutRecordToRouting Uses

func PutRecordToRouting(ctx context.Context, r routing.ValueStore, k ci.PubKey, entry *pb.IpnsEntry) error

type DNSResolver Uses

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

DNSResolver implements a Resolver on DNS domains

func NewDNSResolver Uses

func NewDNSResolver() *DNSResolver

NewDNSResolver constructs a name resolver using DNS TXT records.

func (*DNSResolver) Resolve Uses

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

Resolve implements Resolver.

func (*DNSResolver) ResolveAsync Uses

func (r *DNSResolver) ResolveAsync(ctx context.Context, name string, options ...opts.ResolveOpt) <-chan Result

ResolveAsync implements Resolver.

type IpnsPublisher Uses

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

IpnsPublisher is capable of publishing and resolving names to the IPFS routing system.

func NewIpnsPublisher Uses

func NewIpnsPublisher(route routing.ValueStore, ds ds.Datastore) *IpnsPublisher

NewIpnsPublisher constructs a publisher for the IPFS Routing name system.

func (*IpnsPublisher) GetPublished Uses

func (p *IpnsPublisher) GetPublished(ctx context.Context, id peer.ID, checkRouting bool) (*pb.IpnsEntry, error)

GetPublished returns the record this node has published corresponding to the given peer ID.

If `checkRouting` is true and we have no existing record, this method will check the routing system for any existing records.

func (*IpnsPublisher) ListPublished Uses

func (p *IpnsPublisher) ListPublished(ctx context.Context) (map[peer.ID]*pb.IpnsEntry, error)

PublishedNames returns the latest IPNS records published by this node and their expiration times.

This method will not search the routing system for records published by other nodes.

func (*IpnsPublisher) Publish Uses

func (p *IpnsPublisher) Publish(ctx context.Context, k ci.PrivKey, value path.Path) error

Publish implements Publisher. Accepts a keypair and a value, and publishes it out to the routing system

func (*IpnsPublisher) PublishWithEOL Uses

func (p *IpnsPublisher) PublishWithEOL(ctx context.Context, k ci.PrivKey, value path.Path, eol time.Time) error

PublishWithEOL is a temporary stand in for the ipns records implementation see here for more details: https://github.com/ipfs/specs/tree/master/records

type IpnsResolver Uses

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

IpnsResolver implements NSResolver for the main IPFS SFS-like naming

func NewIpnsResolver Uses

func NewIpnsResolver(route routing.ValueStore) *IpnsResolver

NewIpnsResolver constructs a name resolver using the IPFS Routing system to implement SFS-like naming on top.

func (*IpnsResolver) Resolve Uses

func (r *IpnsResolver) Resolve(ctx context.Context, name string, options ...opts.ResolveOpt) (path.Path, error)

Resolve implements Resolver.

func (*IpnsResolver) ResolveAsync Uses

func (r *IpnsResolver) ResolveAsync(ctx context.Context, name string, options ...opts.ResolveOpt) <-chan Result

ResolveAsync implements Resolver.

type LookupTXTFunc Uses

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

type NameSystem Uses

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 Uses

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

NewNameSystem will construct the IPFS naming system based on Routing

type ProquintResolver Uses

type ProquintResolver struct{}

func (*ProquintResolver) Resolve Uses

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

Resolve implements Resolver.

type Publisher Uses

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 Uses

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 specify it as an option.
    Resolve(ctx context.Context, name string, options ...opts.ResolveOpt) (value path.Path, err error)

    // ResolveAsync performs recursive name lookup, like Resolve, but it returns
    // entries as they are discovered in the DHT. Each returned result is guaranteed
    // to be "better" (which usually means newer) than the previous one.
    ResolveAsync(ctx context.Context, name string, options ...opts.ResolveOpt) <-chan Result
}

Resolver is an object capable of resolving names.

type Result Uses

type Result struct {
    Path path.Path
    Err  error
}

Result is the return type for Resolver.ResolveAsync.

Directories

PathSynopsis
republisher
resolve

Package namesys imports 26 packages (graph) and is imported by 260 packages. Updated 2019-10-09. Refresh now. Tools for package owners.