Decline to acknowldge the given message.

        This will cause the message to be re-delivered to the subscription.
553633
def nack(self):
        
        self._request_queue.put(
            requests.NackRequest(ack_id=self._ack_id, byte_size=self.size)
        )
232843
def ack(self):
        
        if self.acknowledged:
            raise self.MessageStateError(
                "Message already acknowledged with state: %s" % self._state)
        self.backend.ack(self._frame)
        self._state = "ACK"
1081600
def unsubscribe(self, sid):
        
        if sid not in self.observers:
            raise KeyError(
                'Cannot disconnect a observer does not connected to subject'
            )
        del self.observers[sid]
834775
def handle_message(self, response, ignore_subscribe_messages=False):
        
        message_type = nativestr(response[0])
        if message_type == 'pmessage':
            message = {
                'type': message_type,
                'pattern': response[1],
                'channel': response[2],
                'data': response[3]
            }
        else:
            message = {
                'type': message_type,
                'pattern': None,
                'channel': response[1],
                'data': response[2]
            }

        # if this is an unsubscribe message, remove it from memory
        if message_type in self.UNSUBSCRIBE_MESSAGE_TYPES:
            subscribed_dict = None
            if message_type == 'punsubscribe':
                subscribed_dict = self.patterns
            else:
                subscribed_dict = self.channels
            try:
                del subscribed_dict[message['channel']]
            except KeyError:
                pass

        if message_type in self.PUBLISH_MESSAGE_TYPES:
            # if there's a message handler, invoke it
            handler = None
            if message_type == 'pmessage':
                handler = self.patterns.get(message['pattern'], None)
            else:
                handler = self.channels.get(message['channel'], None)
            if handler:
                handler(message)
                return None
        else:
            # this is a subscribe/unsubscribe message. ignore if we don't
            # want them
            if ignore_subscribe_messages or self.ignore_subscribe_messages:
                return None

        return message
1128192
public void unsubscribeDurable(String subscriptionName)
            throws MessagingException {
        try {
            Session session =
                connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            MessageConsumer consumer = durableSubscriptions.get(subscriptionName);
            if(consumer != null) {
                consumer.close();
            }
            session.unsubscribe(subscriptionName);
        } catch (JMSException jmse) {
            String errMsg = "Unable to unsubscribe from subscription with name: "
                          + subscriptionName + " due to exception: "
                          + jmse.getMessage();
            logger.debug(errMsg, jmse);
            throw new MessagingException(errMsg, jmse);
        }
    }
750268
def _recv_ack(self, method_frame):
        ''''''
        if self._ack_listener:
            delivery_tag = method_frame.args.read_longlong()
            multiple = method_frame.args.read_bit()
            if multiple:
                while self._last_ack_id < delivery_tag:
                    self._last_ack_id += 1
                    self._ack_listener(self._last_ack_id)
            else:
                self._last_ack_id = delivery_tag
                self._ack_listener(self._last_ack_id)
1311825
def unsubscribe(self, subscriber: 'Subscriber') -> None:
        
        # here is a special implementation which is replacing the more
        # obvious one: self._subscriptions.remove(subscriber) - this will not
        # work because list.remove(x) is doing comparision for equality.
        # Applied to publishers this will return another publisher instead of
        # a boolean result
        for i, _s in enumerate(self._subscriptions):
            if _s is subscriber:
                self._subscriptions.pop(i)
                return
        raise SubscriptionError('Subscriber is not registered')
40303
def endSubscription(self, subscriber):
        
        self._reqId2Contract.pop(subscriber.reqId, None)
        self.reqId2Subscriber.pop(subscriber.reqId, None)
364732
def unsubscribe(request, message_id, dispatch_id, hashed, redirect_to=None):
    
    return _generic_view(
        'handle_unsubscribe_request', sig_unsubscribe_failed,
        request, message_id, dispatch_id, hashed, redirect_to=redirect_to
    )
1038774
def dismiss(self, message):
        
        assert isinstance(message, (str, unicode)), message
        post_parameters = {'message': message}
        headers, data = self._requester.requestJsonAndCheck(
            "PUT",
            self.pull_request_url + "/reviews/%s/dismissals" % self.id,
            input=post_parameters
        )
806660
@Override
    public void acknowledge(SQSMessage message) throws JMSException {
        session.checkClosed();

        SQSMessageIdentifier ackMessage = SQSMessageIdentifier.fromSQSMessage(message);

        int indexOfMessage = indexOf(ackMessage);

        /**
         * In case the message has already been deleted, warn user about it and
         * return. If not then then it should continue with acknowledging all
         * the messages received before that
         */
        if (indexOfMessage == -1) {
            LOG.warn("SQSMessageID: " + message.getSQSMessageId() + " with SQSMessageReceiptHandle: " +
                     message.getReceiptHandle() + " does not exist.");
        } else {
            bulkAction(getUnAckMessages(), indexOfMessage);
        }
    }
353912
function(message) {
      if (message.namespace === data.namespace &&
          message.data.requestId === data.data.requestId) {
        if (timer) {
          clearTimeout(timer);
        }
        self.removeListener('message', answer);
        self.removeListener('disconnect', cancel);
        cb(null, message);
      }
    }
649732
public void cancelSubscription() throws NotConnectedException, InterruptedException {
        Presence unsubscribed = new Presence(item.getJid(), Type.unsubscribed);
        connection().sendStanza(unsubscribed);
    }
872764
def ack(self, msg):
        
        message_id = msg['headers']['message-id']
        subscription = msg['headers']['subscription']

        transaction_id = None
        if 'transaction-id' in msg['headers']:
            transaction_id = msg['headers']['transaction-id']

#        print "acknowledging message id <%s>." % message_id

        return ack(message_id, subscription, transaction_id)
1173278
def unsubscribe_user_from_discussion(recID, uid):
    
    query = """DELETE FROM "cmtSUBSCRIPTION"
                     WHERE id_bibrec=%s AND id_user=%s"""
    params = (recID, uid)
    try:
        res = run_sql(query, params)
    except:
        return 0
    if res > 0:
        return 1
    return 0
370351
def acknowledge_message(self, delivery_tag):
        
        _logger.debug('Acknowledging message %s', delivery_tag)
        self._channel.basic_ack(delivery_tag)
820502
public UndeliverableReturnCode handleUndeliverableMessage(
                                                              SIBusMessage msg,
                                                              String alternateUser,
                                                              TransactionCommon tran,
                                                              int exceptionReason,
                                                              String[] exceptionStrings,
                                                              String subscriptionID)
    {
        //No need to call getSent() since this will occur as part of the send
        //insde handleUndeliverableMessage
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "handleUndeliverableMessage",
                        new Object[] { msg, alternateUser, tran, Integer.valueOf(exceptionReason), exceptionStrings, subscriptionID });

        UndeliverableReturnCode rc =
                        handleUndeliverableMessage(new MessageItem((JsMessage) msg),
                                                   alternateUser,
                                                   tran,
                                                   exceptionReason,
                                                   exceptionStrings,
                                                   _messageProcessor.getMessagingEngineUuid(),
                                                   subscriptionID);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "handleUndeliverableMessage", rc);
        return rc;
    }