func publish(ctx context.Context, n *core.IpfsNode, k crypto.PrivKey, ref path.Path, opts *publishOpts) (*IpnsEntry, error) { if opts.verifyExists { // verify the path exists _, err := core.Resolve(ctx, n.Namesys, n.Resolver, ref) if err != nil { return nil, err } } eol := time.Now().Add(opts.pubValidTime) err := n.Namesys.PublishWithEOL(ctx, k, ref, eol) if err != nil { return nil, err } pid, err := peer.IDFromPrivateKey(k) if err != nil { return nil, err } return &IpnsEntry{ Name: pid.Pretty(), Value: ref.String(), }, nil }
func (ns *mpns) addToDHTCache(key ci.PrivKey, value path.Path, eol time.Time) { rr, ok := ns.resolvers["dht"].(*routingResolver) if !ok { // should never happen, purely for sanity log.Panicf("unexpected type %T as DHT resolver.", ns.resolvers["dht"]) } if rr.cache == nil { // resolver has no caching return } var err error value, err = path.ParsePath(value.String()) if err != nil { log.Error("could not parse path") return } name, err := peer.IDFromPrivateKey(key) if err != nil { log.Error("while adding to cache, could not get peerid from private key") return } if time.Now().Add(DefaultResolverCacheTTL).Before(eol) { eol = time.Now().Add(DefaultResolverCacheTTL) } rr.cache.Add(name.Pretty(), cacheEntry{ val: value, eol: eol, }) }
func loadPrivateKey(cfg *config.Identity, id peer.ID) (ic.PrivKey, error) { sk, err := cfg.DecodePrivateKey("passphrase todo!") if err != nil { return nil, err } id2, err := peer.IDFromPrivateKey(sk) if err != nil { return nil, err } if id2 != id { return nil, fmt.Errorf("private key in config does not match id: %s != %s", id, id2) } return sk, nil }
// PublishWithEOL is a temporary stand in for the ipns records implementation // see here for more details: https://github.com/ipfs/specs/tree/master/records func (p *ipnsPublisher) PublishWithEOL(ctx context.Context, k ci.PrivKey, value path.Path, eol time.Time) error { id, err := peer.IDFromPrivateKey(k) if err != nil { return err } _, ipnskey := IpnsKeysForID(id) // get previous records sequence number seqnum, err := p.getPreviousSeqNo(ctx, ipnskey) if err != nil { return err } // increment it seqnum++ return PutRecordToRouting(ctx, k, value, seqnum, eol, p.routing, id) }
// ReadDirAll reads a particular directory. Will show locally available keys // as well as a symlink to the peerID key func (r *Root) ReadDirAll(ctx context.Context) ([]fuse.Dirent, error) { log.Debug("Root ReadDirAll") var listing []fuse.Dirent for alias, k := range r.Keys { pid, err := peer.IDFromPrivateKey(k) if err != nil { continue } ent := fuse.Dirent{ Name: pid.Pretty(), Type: fuse.DT_Dir, } link := fuse.Dirent{ Name: alias, Type: fuse.DT_Link, } listing = append(listing, ent, link) } return listing, nil }
func CreateRoot(ipfs *core.IpfsNode, keys map[string]ci.PrivKey, ipfspath, ipnspath string) (*Root, error) { ldirs := make(map[string]fs.Node) roots := make(map[string]*keyRoot) links := make(map[string]*Link) for alias, k := range keys { pid, err := peer.IDFromPrivateKey(k) if err != nil { return nil, err } name := pid.Pretty() kr := &keyRoot{k: k, alias: alias} fsn, err := loadRoot(ipfs.Context(), kr, ipfs, name) if err != nil { return nil, err } roots[name] = kr ldirs[name] = fsn // set up alias symlink links[alias] = &Link{ Target: name, } } return &Root{ Ipfs: ipfs, IpfsRoot: ipfspath, IpnsRoot: ipnspath, Keys: keys, LocalDirs: ldirs, LocalLinks: links, Roots: roots, }, nil }