//StartListen starts listening and calls accept fucn if accepted. func (m *Self) StartListen(accept func(net.Stream) error) error { list, err := corenet.Listen(m.ipfsNode, "/app/"+m.RootPath) if log.If(err) { return err } log.Printf("starting to listen at peer: %s\n", m.ipfsNode.Identity.Pretty()) go func() { for { con, err := list.Accept() defer func() { log.If(con.Close()) }() if log.If(err) { continue } peer := con.Conn().RemotePeer() log.Printf("Connection from: %s\n", peer) p, err := FromBytes([]byte(peer), m) if log.If(err) { continue } if !p.IsAllowed() { log.Println(p, "denifed") continue } log.If(accept(con)) } }() return nil }
func handleAdd(n *core.IpfsNode, ctx context.Context, index *Index, mtx *sync.Mutex, wg *sync.WaitGroup, dspath string, reloadindex chan *Entry, getCurIndex func() *Index) { list, err := corenet.Listen(n, "/pack/add") if err != nil { panic(err) } //fmt.Printf("I am ready to add: %s\n", n.Identity) for { fmt.Println("Waiting for add...\n") con, err := list.Accept() if err != nil { fmt.Println(err) return } go func() { defer con.Close() index = getCurIndex() fmt.Printf("Connection from: %s\n", con.Conn().RemotePeer()) if len(index.WriteList) != 0 { present := false for i := range index.WriteList { if con.Conn().RemotePeer().Pretty() == index.WriteList[i] { present = true break } } if !present { fmt.Println("Not on write list", con.Conn().RemotePeer().Pretty()) } else { fmt.Println("On write list", con.Conn().RemotePeer().Pretty()) } } serverReader := &serverContentReader{r: con} fmt.Println("Add request:", serverReader.Name()) key, err := coreunix.Add(n, serverReader) if err != nil { panic(err) } fmt.Println("Added:", key) entry := Entry{Timestamp: time.Now(), Size: serverReader.n - HEADER_SIZE, Name: serverReader.Name(), Hash: key} reloadindex <- &entry }() } wg.Done() }
func handleIndex(n *core.IpfsNode, ctx context.Context, index *Index, wg *sync.WaitGroup, getCurIndex func() *Index) { list, err := corenet.Listen(n, "/pack/index") if err != nil { panic(err) } for { fmt.Printf("Waiting for index (ls) requests: %s\n", n.Identity) con, err := list.Accept() if err != nil { fmt.Println(err) return } go func() { defer con.Close() index = getCurIndex() fmt.Printf("Connection from: %s\n", con.Conn().RemotePeer()) if len(index.ReadList) != 0 { present := false for i := range index.ReadList { fmt.Println(index.ReadList[i]) if con.Conn().RemotePeer().Pretty() == index.ReadList[i] { present = true break } } if !present { fmt.Println("Not on read list", con.Conn().RemotePeer().Pretty()) } else { fmt.Println("On read list", con.Conn().RemotePeer().Pretty()) } } indexbytes, err := json.Marshal(index) if err != nil { panic(err) } count, err := con.Write(indexbytes) if err != nil { fmt.Println(err) } fmt.Println("Wrote bytes:", count) //con.Close() }() } wg.Done() }
func main() { // Basic ipfsnode setup r, err := fsrepo.Open("~/.ipfs") if err != nil { panic(err) } ctx, cancel := context.WithCancel(context.Background()) defer cancel() cfg := &core.BuildCfg{ Repo: r, Online: true, } nd, err := core.NewNode(ctx, cfg) if err != nil { panic(err) } list, err := corenet.Listen(nd, "/app/whyrusleeping") if err != nil { panic(err) } fmt.Printf("I am peer: %s\n", nd.Identity.Pretty()) for { con, err := list.Accept() if err != nil { fmt.Println(err) return } defer con.Close() fmt.Fprintln(con, "Hello! This is whyrusleepings awesome ipfs service") fmt.Printf("Connection from: %s\n", con.Conn().RemotePeer()) } }
//Listen for connections from other peers func (s *Service) Listen() error { list, err := corenet.Listen(s.node, s.name) if err != nil { return err } fmt.Printf("I am peer: %s\n", s.node.Identity.Pretty()) defer s.cancel() //node.Routing.PutValue() // Loop of +1 listening s.isListening = true for { select { case <-s.stop: s.isListening = false return nil default: con, err := list.Accept() if err != nil { return err } if s.connections == nil { s.connections = make(map[string]connection) } key := con.Conn().RemotePeer().Pretty() s.connections[key] = connection{con, &sync.RWMutex{}, make(chan []byte), make(chan []byte), make(chan bool)} go s.handleCon(s.connections[key]) defer func() { delete(s.connections, key) con.Close() }() fmt.Printf("Connection from: %s\n", key) } } }
func (cs *cliqueService) listen(portName string) (<-chan *incomingMessage, error) { portString := cs.servicePortString(portName) listener, err := corenet.Listen(cs.ipfsNode, portString) if err != nil { return nil, err } messageOut := make(chan *incomingMessage) go func() { for { stream, err := listener.Accept() if err != nil { // ipfsNode's context was canceled close(messageOut) return } reader := msgio.NewVarintReader(stream) message, err := reader.ReadMsg() if err != nil { log.Printf("Cliqueservice failed to read message: %s\n", err) continue } reader.Close() if err != nil { log.Printf("Cliqueservice failed to close stream: %s\n", err) continue } messageOut <- &incomingMessage{id: stream.Conn().RemotePeer(), data: message} } }() return messageOut, nil }
return } proto := "/app/" + req.Arguments()[0] if checkProtoExists(n.PeerHost.Mux().Protocols(), proto) { res.SetError(errors.New("Protocol handler already registered."), cmds.ErrNormal) return } addr, err := ma.NewMultiaddr(req.Arguments()[1]) if err != nil { res.SetError(err, cmds.ErrNormal) return } listener, err := corenet.Listen(n, proto) if err != nil { res.SetError(err, cmds.ErrNormal) return } app := cnAppInfo{ identity: n.Identity, protocol: proto, address: addr, closer: listener, running: true, } go acceptStreams(&app, listener)