Report item as not successfully consumed.

        Removes uid from ackbuffer and re-enqueues it.
961131
def fail(self, uid):
        
        self._redis.pipeline()\
                   .lrem(self.ACKBUF_KEY, 0, uid)\
                   .lrem(self.BACKUP, 0, uid)\
                   .lpush(self.QUEUE_KEY, uid)\
                   .execute()
1350955
private void sendResumeStatus(IPlayItem item) {
        Status resume = new Status(StatusCodes.NS_UNPAUSE_NOTIFY);
        resume.setClientid(streamId);
        resume.setDetails(item.getName());

        doPushMessage(resume);
    }
1365353
def stop(self):
        
        if ( self.dev == None ): return ''
        buf = [REPORT_ID, ord('p'), 0, 0, 0, 0, 0, 0, 0]
        return self.write(buf);
1120717
private void cleanRestoredHandles() throws Exception {
		synchronized (pendingCheckpoints) {

			Iterator<PendingCheckpoint> pendingCheckpointIt = pendingCheckpoints.iterator();
			while (pendingCheckpointIt.hasNext()) {
				PendingCheckpoint pendingCheckpoint = pendingCheckpointIt.next();

				if (committer.isCheckpointCommitted(pendingCheckpoint.subtaskId, pendingCheckpoint.checkpointId)) {
					pendingCheckpoint.stateHandle.discardState();
					pendingCheckpointIt.remove();
				}
			}
		}
	}
1346768
private void doAck(long id) {
    // The other side of the connection has sent a message indicating which
    // messages it has seen. We can clear any messages before the indicated ID.
    if (log.isDebugEnabled()) {
      log.debug(String.format("%s - Received ack for messages up to %d, removing all previous messages from memory", this, id));
    }
    if (messages.containsKey(id+1)) {
      messages.tailMap(id+1);
    } else {
      messages.clear();
    }
    checkDrain();
  }
1222022
function(item, callback) {
                if (hasCache && typeof queueDb == 'object') {
                    queueDb.waitQ.where('uniqueId')
                        .equals(item.uniqueId)
                        .and(function(item) {
                            return item.owner == parseInt(userInfo.id);
                        })
                        .delete()
                        .then(function() {
                            callback && callback();
                        })
                        .catch(function(error) {
                            fireEvent('error', {
                                code: error.code,
                                message: error.message,
                                error: error
                            });
                        });
                }
                else {
                    for (var i = 0; i < chatWaitQueue.length; i++) {
                        if (chatWaitQueue[i].uniqueId == item.uniqueId) {
                            chatWaitQueue.splice(i, 1);
                        }
                    }
                    callback && callback();
                }
            }
1253072
def remove(self, iocb):
        """"""
        if _debug: IOQueue._debug("remove %r", iocb)

        # remove the request from the queue
        for i, item in enumerate(self.queue):
            if iocb is item[1]:
                if _debug: IOQueue._debug("    - found at %d", i)
                del self.queue[i]

                # if the queue is empty, clear the event
                qlen = len(self.queue)
                if not qlen:
                    self.notempty.clear()

                # record the new length
                # self.queuesize.Record( qlen, _time() )
                break
        else:
            if _debug: IOQueue._debug("    - not found")
954848
private void cleanupSubscription(SubscriptionItemStream stream)
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "cleanupSubscription", stream);
      
    try
    {
      // Indicate that we don't want the asynch deletion thread restarted if the 
      // subscription fails to delete, otherwise we might end up in a tight loop trying
      // to delete the subscription
      stream.deleteIfPossible(false);      
    }
    catch (Exception e)
    {
      // FFDC
      FFDCFilter.processException(
        e,
        "com.ibm.ws.sib.processor.impl.AsynchDeletionThread.cleanupSubscription",
        "1:340:1.50",
        stream);
      
      if (tc.isDebugEnabled()) 
      {
        SibTr.debug(tc, "Failed to delete subscription " + stream);       
        SibTr.exception(tc, e);
      }
      
    }
    
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "cleanupSubscription");
  }
783375
def unpersist(self, blocking=False):
        
        self.is_cached = False
        self._jrdd.unpersist(blocking)
        return self
836955
def clean(self):
        
        for _, item in self.queue.items():
            if item['status'] in ['paused', 'running', 'stopping', 'killing']:
                item['status'] = 'queued'
                item['start'] = ''
                item['end'] = ''
243571
def _notify_report(self, device_uuid, event_name, report):
        

        if device_uuid not in self._connections:
            self._logger.debug("Dropping report for device without an active connection, uuid=0x%X", device_uuid)
            return

        slug = self._build_device_slug(device_uuid)
        streaming_topic = self.topics.prefix + 'devices/{}/data/streaming'.format(slug)

        data = {'type': 'notification', 'operation': 'report'}

        ser = report.serialize()
        data['received_time'] = ser['received_time'].strftime("%Y%m%dT%H:%M:%S.%fZ").encode()
        data['report_origin'] = ser['origin']
        data['report_format'] = ser['report_format']
        data['report'] = binascii.hexlify(ser['encoded_report'])
        data['fragment_count'] = 1
        data['fragment_index'] = 0
        self._logger.debug("Publishing report: (topic=%s)", streaming_topic)
        self.client.publish(streaming_topic, data)
334801
@Override
    public boolean onFailedToRecycleView(RecyclerView.ViewHolder holder) {
        if (mVerbose) Log.v(TAG, "onFailedToRecycleView: " + holder.getItemViewType());
        return mOnBindViewHolderListener.onFailedToRecycleView(holder, holder.getAdapterPosition()) || super.onFailedToRecycleView(holder);
    }
1095609
def _view_clear_queue(self, queue_type, queue_id):
        """"""
        response = {
            'status': 'failure'
        }
        try:
            request_data = json.loads(request.data)
        except Exception, e:
            response['message'] = e.message
            return jsonify(**response), 400
        
        request_data.update({
            'queue_type': queue_type,
            'queue_id': queue_id
        })
        try:
            response = self.sq.clear_queue(**request_data)
        except Exception, e:
            response['message'] = e.message
            return jsonify(**response), 400

        return jsonify(**response)
1162781
def elem_remove(self, idx=None):
        
        if idx is not None:
            if idx in self.uid:
                key = idx
                item = self.uid[idx]
            else:
                self.log('The item <{:s}> does not exist.'.format(idx), ERROR)
                return None
        else:
            return None

        convert = False
        if isinstance(self.__dict__[self._params[0]], matrix):
            self._param_to_list()
            convert = True

        # self.n -= 1
        self.uid.pop(key, '')
        self.idx.pop(item)
        self.mdl_from.pop(item)
        self.mdl_to.pop(item)

        for x, y in self.uid.items():
            if y > item:
                self.uid[x] = y - 1

        for param in self._data:
            self.__dict__[param].pop(item)

        for param in self._service:
            if len(self.__dict__[param]) == (self.n + 1):
                if isinstance(self.__dict__[param], list):
                    self.__dict__[param].pop(item)
                elif isinstance(self.__dict__[param], matrix):
                    service = list(self.__dict__[param])
                    service.pop(item)
                    self.__dict__[param] = matrix(service)

        for x in self._states:
            if len(self.__dict__[x]):
                self.__dict__[x].pop(item)

        for y in self._algebs:
            if self.__dict__[y]:
                self.__dict__[y].pop(item)

        for key, param in self._ac.items():
            if isinstance(param, list):
                for subparam in param:
                    if len(self.__dict__[subparam]):
                        self.__dict__[subparam].pop(item)
            else:
                self.__dict__[param].pop(item)

        for key, param in self._dc.items():
            self.__dict__[param].pop(item)

        self.name.pop(item)
        if convert and self.n:
            self._param_to_matrix()
668976
def execute_remove(self, remove):
		''' 
		'''

		safe = self.safe
		if remove.safe is not None:
			safe = remove.safe

		self.queue.append(RemoveOp(self.transaction_id, self, remove.type, safe, remove))
		if self.autoflush:
			return self.flush()
1293861
private void processFailedReceivedDeleted(long[] failedMap, Block[] sent) {
    synchronized (receivedAndDeletedBlockList) {
      // Blocks that do not belong to an Inode are saved for
      // retransmisions
      for (int i = sent.length - 1 ; i >= 0; i--) {
        if(!LightWeightBitSet.get(failedMap, i)){
          continue;
        }
        // Insert into retry list.
        LOG.info("Block " + sent[i] + " does not belong to any file "
            + "on namenode " + avatarnodeAddress + " Retry later.");
        receivedAndDeletedBlockList.add(0, sent[i]);
        if (!DFSUtil.isDeleted(sent[i])) {
          pendingReceivedRequests++;
        }
      }
      lastBlockReceivedFailed = AvatarDataNode.now();
    }
  }
291064
public void deleteDevice() throws DevFailed {
        MDC.setContextMap(contextMap);
        xlogger.entry();
        PropertiesUtils.clearCache();
        PropertiesUtils.clearDeviceCache(name);
        PropertiesUtils.clearClassCache(className);
        stopPolling();
        pollingManager.removeAll();
        if (deviceScheduler != null) {
            deviceScheduler.stop();
        }
        if (interfaceChangeSender != null) {
            interfaceChangeSender.stop();
        }
        if (deleteMethod != null) {
            try {
                deleteMethod.invoke(businessObject);
            } catch (final IllegalArgumentException e) {
                throw DevFailedUtils.newDevFailed(e);
            } catch (final IllegalAccessException e) {
                throw DevFailedUtils.newDevFailed(e);
            } catch (final InvocationTargetException e) {
                if (e.getCause() instanceof DevFailed) {
                    throw (DevFailed) e.getCause();
                } else {
                    throw DevFailedUtils.newDevFailed(e.getCause());
                }
            }
        }
        xlogger.exit();
    }