On all paths, send an ACKACK back
541273
static AutoBuffer ackack( AutoBuffer ab, int tnum ) {
    return ab.clearForWriting(H2O.ACK_ACK_PRIORITY).putTask(UDP.udp.ackack.ordinal(),tnum);
  }
83909
def send_acks(self, message):
        
        if isinstance(message, EventHub_pb2.Message):
            ack = EventHub_pb2.Ack(partition=message.partition, offset=message.offset)
            self.grpc_manager.send_message(EventHub_pb2.SubscriptionResponse(ack=ack))

        elif isinstance(message, EventHub_pb2.SubscriptionMessage):
            acks = []
            for m in message.messages:
                acks.append(EventHub_pb2.Ack(parition=m.partition, offset=m.offset))
            self.grpc_manager.send_message(EventHub_pb2.SubscriptionAcks(ack=acks))
948464
function onSuccess(path, callback, type) {
  if(type !== 'resume') {
      fire('open.success', path);
      if (typeof callback === 'function') {
        callback(path);
      }
  } else {
      fire('resume', path);
  }
  return path;
}
790133
function notifyWatchersOnPaths(paths) {
    var expandedPaths = _expandNestedPaths(paths);

    watchers.map(function _notifyWatcher(watcher) {
      var hasPath = intersect(expandedPaths, watcher.paths).length > 0;

      if (hasPath) {
        var watchedKeyValues = {};
        try {
          watchedKeyValues = getAll(paths);
        } catch (e) {}

        if (watcher.options.async !== false) {
          setTimeout(function () {
            watcher.callback(watchedKeyValues);
          }, watcher.options.async || 0);
        } else {
          watcher.callback(watchedKeyValues);
        }
      }
    });

    if (paths !== '*') {
      notifyGlobalWatchers();
    }
  }
1308117
@Override
    public void ack() {
        waitClientRunning();
        if (!running) {
            return;
        }

        if (kafkaConsumer != null) {
            kafkaConsumer.commitSync();
        }
        if (kafkaConsumer2 != null) {
            kafkaConsumer2.commitSync();
        }
    }
567068
def sendall(self, data, **kws):
        """"""
        return SendAll(self, data, timeout=self._timeout, **kws)
735620
def _control_resp(self, data, state):
        
        if _is_control_response(data):
            ack_state = bytes([data[22]])
            if state == ack_state:
                _LOGGER.debug("Received state ack from %s, state: %s",
                              self.host, ord(ack_state))
                return ack_state
1120621
def path_manager_callback(self):
        """"""
        from spyder.widgets.pathmanager import PathManager
        self.remove_path_from_sys_path()
        project_path = self.projects.get_pythonpath()
        dialog = PathManager(self, self.path, project_path,
                             self.not_active_path, sync=True)
        dialog.redirect_stdio.connect(self.redirect_internalshell_stdio)
        dialog.exec_()
        self.add_path_to_sys_path()
        try:
            encoding.writelines(self.path, self.SPYDER_PATH) # Saving path
            encoding.writelines(self.not_active_path,
                                self.SPYDER_NOT_ACTIVE_PATH)
        except EnvironmentError:
            pass
        self.sig_pythonpath_changed.emit()
982282
@Service
    public boolean ackTaskReceived(String taskId) {
        LOGGER.debug("Ack received for task: {}", taskId);
        boolean ackResult;
        try {
            ackResult = executionService.ackTaskReceived(taskId);
        } catch (Exception e) {
            // safe to ignore exception here, since the task will not be processed by the worker due to ack failure
            // The task will eventually be available to be polled again after the unack timeout
            LOGGER.error("Exception when trying to ack task {}", taskId, e);
            ackResult = false;
        }
        return ackResult;
    }
411395
def touch(path, fatal=True, logger=None):
    
    return write(path, "", fatal=fatal, logger=logger)
1166429
def _recv_nack(self, method_frame):
        ''''''
        if self._nack_listener:
            delivery_tag = method_frame.args.read_longlong()
            multiple, requeue = method_frame.args.read_bits(2)
            if multiple:
                while self._last_ack_id < delivery_tag:
                    self._last_ack_id += 1
                    self._nack_listener(self._last_ack_id, requeue)
            else:
                self._last_ack_id = delivery_tag
                self._nack_listener(self._last_ack_id, requeue)
989744
def send(self, msg):
        """"""
        self._router.broker.defer(self._send, msg)
1157176
def talk_back(self, message):
        """"""
        quote = self.get_quote()
        if quote:
            self.reply("Actually, she said things like this: \n%s" % quote)
191009
def ack(self, frame):
        
        if not frame.message_id:
            raise ProtocolError("No message-id specified for ACK command.")
        self.engine.queue_manager.ack(self.engine.connection, frame)
59292
def kick(self, channel, target, reason=None):
        """"""
        if reason:
            target += ' :' + reason
        self.send_line('KICK %s %s' % (channel, target), nowait=True)
1104690
def write_and_return(
        command, ack, serial_connection, timeout=DEFAULT_WRITE_TIMEOUT):
    ''''''
    clear_buffer(serial_connection)
    with serial_with_temp_timeout(
            serial_connection, timeout) as device_connection:
        response = _write_to_device_and_return(command, ack, device_connection)
    return response
782408
async def ack(self):
        

        state = self._state
        if state.is_bot:
            raise ClientException('Must not be a bot account to ack messages.')
        return await state.http.ack_message(self.channel.id, self.id)