func ParseBootstrapPeer(addr string) (BootstrapPeer, error) { ia, err := iaddr.ParseString(addr) if err != nil { return nil, err } return BootstrapPeer(ia), err }
func main() { conn.EncryptConnections = false listenF := flag.Int("l", 0, "wait for incoming connections") target := flag.String("d", "", "target peer to dial") flag.Parse() listenaddr := fmt.Sprintf("/ip4/0.0.0.0/tcp/%d", *listenF) ha, err := makeDummyHost(listenaddr) if err != nil { log.Fatal(err) } message := []byte("hello libp2p!") // Set a stream handler on host A ha.SetStreamHandler("/echo/1.0.0", func(s net.Stream) { defer s.Close() log.Println("writing message") s.Write(message) }) if *target == "" { log.Println("listening on for connections...") for { time.Sleep(time.Hour) } } a, err := ipfsaddr.ParseString(*target) if err != nil { log.Fatalln(err) } pi := pstore.PeerInfo{ ID: a.ID(), Addrs: []ma.Multiaddr{a.Transport()}, } log.Println("connecting to target") err = ha.Connect(context.Background(), pi) if err != nil { log.Fatalln(err) } log.Println("opening stream...") // make a new stream from host B to host A // it should be handled on host A by the handler we set s, err := ha.NewStream(context.Background(), "/echo/1.0.0", a.ID()) if err != nil { log.Fatalln(err) } log.Println("reading message") out, err := ioutil.ReadAll(s) if err != nil { log.Fatalln(err) } log.Println("GOT: ", string(out)) }
// parseAddresses is a function that takes in a slice of string peer addresses // (multiaddr + peerid) and returns slices of multiaddrs and peerids. func parseAddresses(addrs []string) (iaddrs []iaddr.IPFSAddr, err error) { iaddrs = make([]iaddr.IPFSAddr, len(addrs)) for i, saddr := range addrs { iaddrs[i], err = iaddr.ParseString(saddr) if err != nil { return nil, cmds.ClientError("invalid peer address: " + err.Error()) } } return }
func (gcr *SupernodeClientConfig) ServerIPFSAddrs() ([]ipfsaddr.IPFSAddr, error) { var addrs []ipfsaddr.IPFSAddr for _, server := range gcr.Servers { addr, err := ipfsaddr.ParseString(server) if err != nil { return nil, err } addrs = append(addrs, addr) } return addrs, nil }
func run() error { servers := config.DefaultSNRServers fmt.Println("using gcr remotes:") for _, p := range servers { fmt.Println("\t", p) } ctx, cancel := context.WithCancel(context.Background()) defer cancel() cwd, err := os.Getwd() if err != nil { return err } repoPath := gopath.Join(cwd, config.DefaultPathName) if err := ensureRepoInitialized(repoPath); err != nil { } repo, err := fsrepo.Open(repoPath) if err != nil { // owned by node return err } cfg, err := repo.Config() if err != nil { return err } cfg.Bootstrap = servers if err := repo.SetConfig(cfg); err != nil { return err } var addrs []ipfsaddr.IPFSAddr for _, info := range servers { addr, err := ipfsaddr.ParseString(info) if err != nil { return err } addrs = append(addrs, addr) } var infos []peer.PeerInfo for _, addr := range addrs { infos = append(infos, peer.PeerInfo{ ID: addr.ID(), Addrs: []ma.Multiaddr{addr.Transport()}, }) } node, err := core.NewNode(ctx, &core.BuildCfg{ Online: true, Repo: repo, Routing: corerouting.SupernodeClient(infos...), }) if err != nil { return err } defer node.Close() opts := []corehttp.ServeOption{ corehttp.CommandsOption(cmdCtx(node, repoPath)), corehttp.GatewayOption(false, nil), } if *cat { if err := runFileCattingWorker(ctx, node); err != nil { return err } } else { if err := runFileAddingWorker(node); err != nil { return err } } return corehttp.ListenAndServe(node, cfg.Addresses.API, opts...) }