Transport has active streams. Start sending keepalives if necessary.
762906
public synchronized void onTransportActive() {
    if (state == State.IDLE) {
      // When the transport goes active, we do not reset the nextKeepaliveTime. This allows us to
      // quickly check whether the connection is still working.
      state = State.PING_SCHEDULED;
      if (pingFuture == null) {
        pingFuture = scheduler.schedule(
            sendPing,
            keepAliveTimeInNanos - stopwatch.elapsed(TimeUnit.NANOSECONDS),
            TimeUnit.NANOSECONDS);
      }
    } else if (state == State.IDLE_AND_PING_SENT) {
      state = State.PING_SENT;
    } // Other states are possible when keepAliveDuringTransportIdle == true
  }
1248671
def persist(self):
        """"""

        self.persisted_nodes = self.graph.dump_nodes()
        self.persisted_streamers = self.graph.dump_streamers()
        self.persisted_exists = True
        self.persisted_constants = self._sensor_log.dump_constants()
1348478
public synchronized void newGuessInStream(long tick) throws SIResourceException
  {

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(this, tc, "newGuessInStream", new Object[] { Long.valueOf(tick),
          Boolean.valueOf(containsGuesses),
          Long.valueOf(sendWindow),
          Long.valueOf(totalMessages),
          Long.valueOf(firstMsgOutsideWindow)});
    
    // If this is the first guess in the stream 
    if( !containsGuesses)
    { 
      containsGuesses=true;  
      if( sendWindow > totalMessages )
      {
        sendWindow = totalMessages;
        persistSendWindow(sendWindow, null);  
        firstMsgOutsideWindow = tick; 
      }  
    }
         
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "newGuessInStream", new Object[] {Boolean.valueOf(containsGuesses),
          Long.valueOf(sendWindow),
          Long.valueOf(firstMsgOutsideWindow)});
  }
336184
@Override
    public ReactiveSeq<T> stream() {
        listeningStreams.incrementAndGet(); //assumes all Streams that ever connected, remain connected
        return ReactiveSeq.fromStream(closingStream(this::get, new AlwaysContinue()));
    }
291945
def notice_stream(self, stream):
        
        self._routes_by_stream[stream] = set([stream.remote_id])
        self._propagate_up(mitogen.core.ADD_ROUTE, stream.remote_id,
                        stream.name)
        mitogen.core.listen(
            obj=stream,
            name='disconnect',
            func=lambda: self._on_stream_disconnect(stream),
        )
67500
function broadcast(connections, packet) {
    var i = connections.length;
    while (i--) {
        connections[i].write(packet);
        flush(connections[i]);
    }
}
157709
private void onDataRead(int streamId, ByteBuf data, int padding, boolean endOfStream) {
    flowControlPing().onDataRead(data.readableBytes(), padding);
    NettyClientStream.TransportState stream = clientStream(requireHttp2Stream(streamId));
    stream.transportDataReceived(data, endOfStream);
    if (keepAliveManager != null) {
      keepAliveManager.onDataReceived();
    }
  }
273628
private NettyServerStream.TransportState serverStream(Http2Stream stream) {
    return stream == null ? null : (NettyServerStream.TransportState) stream.getProperty(streamKey);
  }
725937
def activate_stream(id: nil, **args)
      connection_error(msg: 'Stream ID already exists') if @streams.key?(id)

      stream = Stream.new({ connection: self, id: id }.merge(args))

      # Streams that are in the "open" state, or either of the "half closed"
      # states count toward the maximum number of streams that an endpoint is
      # permitted to open.
      stream.once(:active) { @active_stream_count += 1 }
      stream.once(:close) do
        @active_stream_count -= 1

        # Store a reference to the closed stream, such that we can respond
        # to any in-flight frames while close is registered on both sides.
        # References to such streams will be purged whenever another stream
        # is closed, with a minimum of 15s RTT time window.
        @streams_recently_closed[id] = Time.now
        to_delete = @streams_recently_closed.select { |_, v| (Time.now - v) > 15 }
        to_delete.each do |stream_id|
          @streams.delete stream_id
          @streams_recently_closed.delete stream_id
        end
      end

      stream.on(:promise, &method(:promise)) if self.is_a? Server
      stream.on(:frame,   &method(:send))

      @streams[id] = stream
    end
211926
function XdrStreamingTransport(transUrl) {
  if (!XDRObject.enabled) {
    throw new Error('Transport created when disabled');
  }
  AjaxBasedTransport.call(this, transUrl, '/xhr_streaming', XhrReceiver, XDRObject);
}
215001
void rstStream() {
        if (reset) {
            return;
        }
        reset = true;
        if(!isReadyForFlush()) {
            IoUtils.safeClose(this);
        }
        getChannel().removeStreamSink(getStreamId());
    }
1237429
private boolean doReachedUseDataFlow()
    {
        itsLiveOnExitSet.clear();
        if (itsSuccessors != null) {
            for (int i = 0; i < itsSuccessors.length; i++) {
                itsLiveOnExitSet.or(itsSuccessors[i].itsLiveOnEntrySet);
            }
        }
        return updateEntrySet(itsLiveOnEntrySet, itsLiveOnExitSet,
                              itsUseBeforeDefSet, itsNotDefSet);
    }
1187392
public boolean track(GlobalStreamId stream, long ts) {
        Long currentVal = streamToTs.get(stream);
        if (currentVal == null || ts > currentVal) {
            streamToTs.put(stream, ts);
        }
        checkFailures();
        return ts >= lastWaterMarkTs;
    }
1095776
def connection_made(self, transport):
        

        # Save the underlying transport
        self._transport = transport

        # Call connection_made() on the client protocol, passing
        # ourself as the transport
        self._client.connection_made(self)
114282
def push(self, stream, reading):
        

        # Make sure the stream is correct
        reading = copy.copy(reading)
        reading.stream = stream.encode()

        if stream.buffered:
            output_buffer = stream.output

            if self.id_assigner is not None:
                reading.reading_id = self.id_assigner(stream, reading)

            try:
                self._engine.push(reading)
            except StorageFullError:
                # If we are in fill-stop mode, don't auto erase old data.
                if (stream.output and not self._rollover_streaming) or (not stream.output and not self._rollover_storage):
                    raise

                self._erase_buffer(stream.output)
                self._engine.push(reading)

            for walker in self._queue_walkers:
                # Only notify the walkers that are on this queue
                if walker.selector.output == output_buffer:
                    walker.notify_added(stream)

        # Activate any monitors we have for this stream
        for selector in self._monitors:
            if selector is None or selector.matches(stream):
                for callback in self._monitors[selector]:
                    callback(stream, reading)

        # Virtual streams live only in their walkers, so update each walker
        # that contains this stream.
        for walker in self._virtual_walkers:
            if walker.matches(stream):
                walker.push(stream, reading)

        self._last_values[stream] = reading
1045210
public void introduceServiceToTransports(Iterator<? extends BindingDescriptorRegistrationListener> transports) {
        while (transports.hasNext()) {
            BindingDescriptorRegistrationListener t = transports.next();
            boolean eventTransport = t instanceof EventTransport;
            boolean includedEventTransport = false;
            if (eventTransport) {
                // if it's an event transport then we only want to notify if we've been told that the developer wanted to
                // bind to this particular transport (since you can have >1 instance of the event transport currently)
                if (eventTransports != null && eventTransports.contains(t)) {
                    includedEventTransport = true;
                }
            }
            if (!eventTransport || includedEventTransport) {
                for (BindingDescriptor bindingDescriptor : getBindingDescriptors()) {
                    t.notify(bindingDescriptor);
                }
            }
        }
    }
445825
public void setTrasmit(boolean active) {
        for (SendStream sendStream : sendStreams) {
            try {
                if (active) {
                    sendStream.start();
                    LOGGER.fine("START");
                }
                else {
                    sendStream.stop();
                    LOGGER.fine("STOP");
                }
            }
            catch (IOException e) {
                LOGGER.log(Level.WARNING, "exception", e);
            }

        }
    }