needs to be forwarded downstream.
434106
void processAckExpected(
    long ackExpStamp,
    int priority,
    Reliability reliability,
    SIBUuid12 stream)
   throws SIResourceException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "processAckExpected", new Long(ackExpStamp));

    _internalOutputStreamManager.processAckExpected(ackExpStamp, priority, reliability, stream);
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "processAckExpected");
  }
243173
protected void finishCompoundMessage ()
    {
        if (--_compoundDepth == 0) {
            CompoundDownstreamMessage downstream = _compound;
            _compound = null;
            if (!downstream.msgs.isEmpty()) {
                postMessage(downstream, null);
            }
        }
    }
55142
function safeForwarded(req) {
	try {
		return forwarded(req, req.headers);
	} catch (error) {
		logger.error(error);
		return null;
	}
}
989744
def send(self, msg):
        """"""
        self._router.broker.defer(self._send, msg)
1086041
def connect(self, recver):
        
        r1 = recver
        m1 = r1.middle
        s2 = self
        m2 = self.middle
        r2 = self.other

        r2.middle = m1
        del m2.sender
        del m2.recver

        del m1.recver
        m1.recver = weakref.ref(r2, m1.on_abandoned)
        m1.recver_current = m2.recver_current

        del r1.middle
        del s2.middle

        # if we are currently a chain, return the last recver of our chain
        while True:
            if getattr(r2, 'downstream', None) is None:
                break
            r2 = r2.downstream.other
        return r2
1211398
private void sendNextPayload() {
		singleThreadExecutor.execute(new Runnable() {
			@Override
			public void run() {
				try {
					sendNextPayloadSync();
				} catch (Exception e) {
					ApptentiveLog.e(e, "Exception while trying to send next payload");
					logException(e);
				}
			}
		});
	}
42848
def forward(self, to):
        

        method, url = get_URL('forward')

        payload = {
            'apikey': self.session.cookies.get('apikey'),
            'transferid': self.transfer_id,
            'transferkey': self.transfer_info.get('transferkey'),
            'to': self._parse_recipients(to)
            }

        res = getattr(self.session, method)(url, params=payload)

        if res.status_code == 200:
            return True

        hellraiser(res)
1252494
function PushRoute (router, request, scheme, handler, limits, validate, upload) {
		let args = [scheme, limits], filt = v=>!!v;
		args = (!!validate ? args.concat([validate]).filter(filt) : args);
		args = (!!upload   ? args.concat([upload  ]).filter(filt) : args);
		args = args.concat([handler]); router[request](...args);
	}
168830
def send_unavailable(from, to)
      available = router.available_resources(from, to)
      stanzas = available.map {|stream| unavailable(stream.user.jid) }
      broadcast_to_available_resources(stanzas, to)
    end
326998
async def forward(self, n, *, timeout=None) -> int:
        
        """
        self._check_ready()
        if n <= 0:
            raise exceptions.InterfaceError('n must be greater than zero')

        protocol = self._connection._protocol
        status = await protocol.query('MOVE FORWARD {:d} {}'.format(
            n, self._portal_name), timeout)

        advanced = int(status.split()[1])
        if advanced < n:
            self._exhausted = True

        return advanced
246256
def forward(self, is_train=False):
        """"""
        for texec in self.train_execs:
            texec.forward(is_train=is_train)
133229
def forward_message(self, *args, **kwargs):
        """"""
        return forward_message(*args, **self._merge_overrides(**kwargs)).run()
1037521
def put(self, source, rel_path, metadata=None):
        """"""
        return self.upstreams[0].put(source, rel_path, metadata)
63027
private void forward() {

        try {
            CmsDbSettingsPanel panel = m_panel[0];
            panel.saveToSetupBean();

            boolean createDb = panel.getCreateDb();
            boolean dropDb = panel.getDropDb();
            boolean createTables = panel.getCreateTables();
            setupDb(createDb, createTables, dropDb);
        } catch (DBException e) {
            CmsSetupErrorDialog.showErrorDialog(e.getMessage(), e.getDetails());
        } catch (Exception e) {
            CmsSetupErrorDialog.showErrorDialog(e);
        }

    }
902885
def pre_request(self, response, exc=None):
        
        if response.request.method == 'CONNECT':
            self.start_response(
                '200 Connection established',
                [('content-length', '0')]
            )
            # send empty byte so that headers are sent
            self.future.set_result([b''])
            # proxy - server connection
            upstream = response.connection
            # client - proxy connection
            dostream = self.connection
            # Upgrade downstream connection
            dostream.upgrade(partial(StreamTunnel.create, upstream))
            #
            # upstream upgrade
            upstream.upgrade(partial(StreamTunnel.create, dostream))
            response.fire_event('post_request')
            # abort the event
            raise AbortEvent
        else:
            response.event('data_processed').bind(self.data_processed)
            response.event('post_request').bind(self.post_request)
676010
def forward(self, **kwargs):
        
        # rewrite url path  
        prefix = self.url_prefix
        path= "" if request.path == "/" else request.path
        path = path[len(prefix):]
        url = '%s%s'% ( self.url_root[:-1], path )

        if request.method == 'GET':
            resp = requests.get(url, params=request.args)
            data = json.loads(resp.content)
        elif request.method == 'POST':
            if request.headers['Content-Type'].startswith('application/json'):
                # data in JSON
                resp = requests.post(url, json=request.json)
                data = request.json
            else :
                resp = requests.post(url, json=request.form)
                data = request.form
            data = json.loads(resp.content)
        else:
            # method not allowed aborting
            abort(405) # XXX

        return jsonify(data)
1113123
def _AddForwardedIps(self, forwarded_ips, interface):
    
    for address in forwarded_ips:
      self.ip_forwarding_utils.AddForwardedIp(address, interface)