func EchoStreamHandler(stream inet.Stream) { go func() { defer stream.Close() // pull out the ipfs conn c := stream.Conn() log.Infof("%s ponging to %s", c.LocalPeer(), c.RemotePeer()) buf := make([]byte, 4) for { if _, err := stream.Read(buf); err != nil { if err != io.EOF { log.Info("ping receive error:", err) } return } if !bytes.Equal(buf, []byte("ping")) { log.Infof("ping receive error: ping != %s %v", buf, buf) return } if _, err := stream.Write([]byte("pong")); err != nil { log.Info("pond send error:", err) return } } }() }
func (m *Manager) accept(con net.Stream) error { remote, err := peer.New(con.Conn().RemotePeer().Pretty(), m.self) if log.If(err) { return err } if log.If(m.AddPeer(remote)) { return err } rrecent, rpeers, err := peer.ReadRequest(con) if log.If(err) { return err } m.mutex.RLock() prev := m.recent.Key() m.mutex.RUnlock() if log.If(peer.WriteResponse(con, prev)) { return err } m.mutex.Lock() updated, err := m.recent.Merge(rrecent) m.mutex.Unlock() if log.If(err) { return err } if updated { if log.If(m.broadcast(rpeers)) { return err } } return err }
func EchoStreamHandler(stream inet.Stream) { c := stream.Conn() log.Debugf("%s echoing %s", c.LocalPeer(), c.RemotePeer()) go func() { defer stream.Close() io.Copy(stream, stream) }() }
func (d *Diagnostics) HandleMessage(ctx context.Context, s inet.Stream) error { cr := ctxio.NewReader(ctx, s) cw := ctxio.NewWriter(ctx, s) r := ggio.NewDelimitedReader(cr, inet.MessageSizeMax) // maxsize w := ggio.NewDelimitedWriter(cw) // deserialize msg pmes := new(pb.Message) if err := r.ReadMsg(pmes); err != nil { log.Debugf("Failed to decode protobuf message: %v", err) return nil } // Print out diagnostic log.Infof("[peer: %s] Got message from [%s]\n", d.self.Pretty(), s.Conn().RemotePeer()) // Make sure we havent already handled this request to prevent loops if err := d.startDiag(pmes.GetDiagID()); err != nil { return nil } resp := newMessage(pmes.GetDiagID()) resp.Data = d.getDiagInfo().Marshal() if err := w.WriteMsg(resp); err != nil { log.Debugf("Failed to write protobuf message over stream: %s", err) return err } timeout := pmes.GetTimeoutDuration() if timeout < HopTimeoutDecrement { return fmt.Errorf("timeout too short: %s", timeout) } ctx, cancel := context.WithTimeout(ctx, timeout) defer cancel() pmes.SetTimeoutDuration(timeout - HopTimeoutDecrement) dpeers, err := d.getDiagnosticFromPeers(ctx, d.getPeers(), pmes) if err != nil { log.Debugf("diagnostic from peers err: %s", err) return err } for b := range dpeers { resp := newMessage(pmes.GetDiagID()) resp.Data = b.Marshal() if err := w.WriteMsg(resp); err != nil { log.Debugf("Failed to write protobuf message over stream: %s", err) return err } } return nil }
func (ids *IDService) ResponseHandler(s inet.Stream) { defer s.Close() c := s.Conn() r := ggio.NewDelimitedReader(s, 2048) mes := pb.Identify{} if err := r.ReadMsg(&mes); err != nil { return } ids.consumeMessage(&mes, c) log.Debugf("%s received message from %s %s", ID, c.RemotePeer(), c.RemoteMultiaddr()) }
// HandleSync reads the next name off the Stream, and calls a handler function // This is done synchronously. The handler function will return before // HandleSync returns. func (m *Mux) HandleSync(s inet.Stream) { ctx := context.Background() name, handler, err := m.ReadHeader(s) if err != nil { err = fmt.Errorf("protocol mux error: %s", err) log.Event(ctx, "muxError", lgbl.Error(err)) s.Close() return } log.Debugf("muxer handle protocol %s: %s", s.Conn().RemotePeer(), name) handler(s) }
func (ids *IDService) RequestHandler(s inet.Stream) { defer s.Close() c := s.Conn() bwc := ids.Host.GetBandwidthReporter() s = mstream.WrapStream(s, ID, bwc) w := ggio.NewDelimitedWriter(s) mes := pb.Identify{} ids.populateMessage(&mes, s.Conn()) w.WriteMsg(&mes) log.Debugf("%s sent message to %s %s", ID, c.RemotePeer(), c.RemoteMultiaddr()) }
// newStreamHandler is the remote-opened stream handler for inet.Network // TODO: this feels a bit wonky func (h *BasicHost) newStreamHandler(s inet.Stream) { protoID, handle, err := h.Mux().ReadHeader(s) if err != nil { if err == io.EOF { log.Debugf("protocol EOF: %s", s.Conn().RemotePeer()) } else { log.Warning("protocol mux failed: %s", err) } return } logStream := mstream.WrapStream(s, protoID, h.bwc) go handle(logStream) }
func (dht *IpfsDHT) handleNewMessage(s inet.Stream) { defer s.Close() ctx := dht.Context() cr := ctxio.NewReader(ctx, s) // ok to use. we defer close stream in this func cw := ctxio.NewWriter(ctx, s) // ok to use. we defer close stream in this func r := ggio.NewDelimitedReader(cr, inet.MessageSizeMax) w := ggio.NewDelimitedWriter(cw) mPeer := s.Conn().RemotePeer() // receive msg pmes := new(pb.Message) if err := r.ReadMsg(pmes); err != nil { log.Debugf("Error unmarshaling data: %s", err) return } // update the peer (on valid msgs only) dht.updateFromMessage(ctx, mPeer, pmes) // get handler for this msg type. handler := dht.handlerForMsgType(pmes.GetType()) if handler == nil { log.Debug("got back nil handler from handlerForMsgType") return } // dispatch handler. rpmes, err := handler(ctx, mPeer, pmes) if err != nil { log.Debugf("handle message error: %s", err) return } // if nil response, return it before serializing if rpmes == nil { log.Debug("Got back nil response from request.") return } // send out response msg if err := w.WriteMsg(rpmes); err != nil { log.Debugf("send response error: %s", err) return } return }
func (lb *Loopback) HandleStream(s inet.Stream) { defer s.Close() pbr := ggio.NewDelimitedReader(s, inet.MessageSizeMax) var incoming dhtpb.Message if err := pbr.ReadMsg(&incoming); err != nil { log.Debug(err) return } ctx := context.TODO() outgoing := lb.Handler.HandleRequest(ctx, s.Conn().RemotePeer(), &incoming) pbw := ggio.NewDelimitedWriter(s) if err := pbw.WriteMsg(outgoing); err != nil { return // TODO logerr } }
// handleNewStream receives a new stream from the network. func (bsnet *impl) handleNewStream(s inet.Stream) { defer s.Close() if bsnet.receiver == nil { return } received, err := bsmsg.FromNet(s) if err != nil { go bsnet.receiver.ReceiveError(err) log.Debugf("bitswap net handleNewStream from %s error: %s", s.Conn().RemotePeer(), err) return } p := s.Conn().RemotePeer() ctx := context.Background() log.Debugf("bitswap net handleNewStream from %s", s.Conn().RemotePeer()) bsnet.receiver.ReceiveMessage(ctx, p, received) }
func (p *standard) HandleStream(s inet.Stream) { // TODO(brian): Should clients be able to satisfy requests? log.Error("supernode client received (dropped) a routing message from", s.Conn().RemotePeer()) s.Close() }
func TestNotifications(t *testing.T) { ctx := context.Background() swarms := makeSwarms(ctx, t, 5) defer func() { for _, s := range swarms { s.Close() } }() timeout := 5 * time.Second // signup notifs notifiees := make([]*netNotifiee, len(swarms)) for i, swarm := range swarms { n := newNetNotifiee() swarm.Notify(n) notifiees[i] = n } connectSwarms(t, ctx, swarms) <-time.After(time.Millisecond) // should've gotten 5 by now. // test everyone got the correct connection opened calls for i, s := range swarms { n := notifiees[i] for _, s2 := range swarms { if s == s2 { continue } var actual []inet.Conn for len(s.ConnectionsToPeer(s2.LocalPeer())) != len(actual) { select { case c := <-n.connected: actual = append(actual, c) case <-time.After(timeout): t.Fatal("timeout") } } expect := s.ConnectionsToPeer(s2.LocalPeer()) for _, c1 := range actual { found := false for _, c2 := range expect { if c1 == c2 { found = true break } } if !found { t.Error("connection not found") } } } } complement := func(c inet.Conn) (*Swarm, *netNotifiee, *Conn) { for i, s := range swarms { for _, c2 := range s.Connections() { if c.LocalMultiaddr().Equal(c2.RemoteMultiaddr()) && c2.LocalMultiaddr().Equal(c.RemoteMultiaddr()) { return s, notifiees[i], c2 } } } t.Fatal("complementary conn not found", c) return nil, nil, nil } testOCStream := func(n *netNotifiee, s inet.Stream) { var s2 inet.Stream select { case s2 = <-n.openedStream: t.Log("got notif for opened stream") case <-time.After(timeout): t.Fatal("timeout") } if s != s2 { t.Fatal("got incorrect stream", s.Conn(), s2.Conn()) } select { case s2 = <-n.closedStream: t.Log("got notif for closed stream") case <-time.After(timeout): t.Fatal("timeout") } if s != s2 { t.Fatal("got incorrect stream", s.Conn(), s2.Conn()) } } streams := make(chan inet.Stream) for _, s := range swarms { s.SetStreamHandler(func(s inet.Stream) { streams <- s s.Close() }) } // open a streams in each conn for i, s := range swarms { for _, c := range s.Connections() { _, n2, _ := complement(c) st1, err := c.NewStream() if err != nil { t.Error(err) } else { st1.Write([]byte("hello")) st1.Close() testOCStream(notifiees[i], st1) st2 := <-streams testOCStream(n2, st2) } } } // close conns for i, s := range swarms { n := notifiees[i] for _, c := range s.Connections() { _, n2, c2 := complement(c) c.Close() c2.Close() var c3, c4 inet.Conn select { case c3 = <-n.disconnected: case <-time.After(timeout): t.Fatal("timeout") } if c != c3 { t.Fatal("got incorrect conn", c, c3) } select { case c4 = <-n2.disconnected: case <-time.After(timeout): t.Fatal("timeout") } if c2 != c4 { t.Fatal("got incorrect conn", c, c2) } } } }
func WrapStream(base inet.Stream, pid protocol.ID, bwc metrics.Reporter) inet.Stream { return newMeteredStream(base, pid, base.Conn().RemotePeer(), bwc.LogRecvMessageStream, bwc.LogSentMessageStream) }