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...)
}
