Records that a request has been dropped as instructed by the remote balancer.
965847
void recordDroppedRequest(String token) {
    callsStartedUpdater.getAndIncrement(this);
    callsFinishedUpdater.getAndIncrement(this);

    synchronized (this) {
      LongHolder holder;
      if ((holder = callsDroppedPerToken.get(token)) == null) {
        callsDroppedPerToken.put(token, (holder = new LongHolder()));
      }
      holder.num++;
    }
  }
922546
void recordDroppedRequest(String category) {
    AtomicLong counter = dropCounters.get(category);
    if (counter == null) {
      counter = dropCounters.putIfAbsent(category, new AtomicLong());
      if (counter == null) {
        counter = dropCounters.get(category);
      }
    }
    counter.getAndIncrement();
  }
880495
def flush_down_connections(self):
        
        self._get_db_attempts = 0
        for db_num in self._down_connections.keys():
            self.mark_connection_up(db_num)
1329442
@Override
  public boolean failedSendRecord(ClientRfSession appSession, Request rfRequest) throws InternalException {
    logger.info("failedSendRecord :: appSession[" + appSession + "], Request[" + rfRequest + "]");
    return false;
  }
1220380
public void requestDone() {
        currentRequest = null;

        if (anyAreSet(state, CLOSE_REQ)) {
            safeClose(connection);
        } else if (anyAreSet(state, UPGRADE_REQUESTED)) {
            safeClose(connection); //we don't support upgrade, just close the connection to be safe
            return;
        }

        AjpClientExchange next = pendingQueue.poll();

        if (next != null) {
            initiateRequest(next);
        }
    }
160172
function removePendingReq() {
          var idx = indexOf($http.pendingRequests, config);
          if (idx !== -1) {
            $http.pendingRequests.splice(idx, 1);
            config.$iframeTransportForm.remove();
            delete config.$iframeTransportForm;
          }
        }
417255
private void sendRecordFailedNotify(String reason) {
        Status failedStatus = new Status(StatusCodes.NS_RECORD_FAILED);
        failedStatus.setLevel(Status.ERROR);
        failedStatus.setClientid(getStreamId());
        failedStatus.setDetails(getPublishedName());
        failedStatus.setDesciption(reason);

        StatusMessage failedMsg = new StatusMessage();
        failedMsg.setBody(failedStatus);
        pushMessage(failedMsg);
    }
996377
def on_service_departure(self, svc_ref):
        
        with self._lock:
            if svc_ref is self.reference:
                # Forget about the service
                self._value.unset_service()

                # Clear the reference
                self.reference = None

                # Look for a replacement
                self._pending_ref = self._context.get_service_reference(
                    self.requirement.specification, self.requirement.filter
                )

                if self._pending_ref is None:
                    # No replacement found yet, wait a little
                    self.__still_valid = True
                    self.__timer_args = (self._value, svc_ref)
                    self.__timer = threading.Timer(
                        self.__timeout, self.__unbind_call, (False,)
                    )
                    self.__timer.start()

                else:
                    # Notify iPOPO immediately
                    self._ipopo_instance.unbind(self, self._value, svc_ref)
                return True

            return None
1259851
protected void statsRequestEnd()
    {
        if (_statsOn && _reqTime>0)
        {
            _httpServer.statsEndRequest(System.currentTimeMillis()-_reqTime,
                                        (_response!=null));
            _reqTime=0;
        }
    }
55318
function() {
            var waitingOrConnected = connectionManager.getWaitingOrConnected(),
                i;

            // ensure files are cancelled in reverse order which they were added
            // to avoid a flash of time where a queued file begins to upload before it is canceled
            if (waitingOrConnected.length) {
                for (i = waitingOrConnected.length - 1; i >= 0; i--) {
                    controller.cancel(waitingOrConnected[i]);
                }
            }

            connectionManager.reset();
        }
1077041
def drop_connection(self, name, database=None):
        
        request_executor = self._store.get_request_executor(database)
        command = DropSubscriptionConnectionCommand(name)
        request_executor.execute(command)
566133
def _maybe_drop_message(self):
        
        if self.headers[_PROCESSING_EXCEPTIONS] >= self._error_max_retry:
            self.logger.warning('Dropping message with %i deaths due to '
                                'ERROR_MAX_RETRY',
                                self.headers[_PROCESSING_EXCEPTIONS])
            if self._drop_exchange:
                self._republish_dropped_message('max retries ({})'.format(
                    self.headers[_PROCESSING_EXCEPTIONS]))
            raise DropMessage
658975
public boolean stopReporting() {

        // quit the bounce proxy heartbeat but let a possibly running request
        // finish
        if (scheduledFuture != null) {
            return scheduledFuture.cancel(false);
        }

        executorService.shutdown();
        executorService = null;
        return false;
    }
234687
def connectionLost(self, reason):
        
        self.factory.protocols.remove(self)
        super(AMP, self).connectionLost(reason)
1092863
private void cancelPendingSlotRequest(PendingSlotRequest pendingSlotRequest) {
		CompletableFuture<Acknowledge> request = pendingSlotRequest.getRequestFuture();

		returnPendingTaskManagerSlotIfAssigned(pendingSlotRequest);

		if (null != request) {
			request.cancel(false);
		}
	}
624733
protected void removePendingRequestForType(ResourceRequestInfo req) {
    Context c = getContext(req.getType());
    Object removed = Utilities.removeReference(c.pendingRequests, req);
    if (removed != null) {
      c.pendingRequestCount--;
    }
  }
679889
def on_consumer_cancelled(self, method_frame):
        
        _logger.info('Consumer was cancelled remotely, shutting down: %r', method_frame)
        if self._channel:
            self._channel.close()