# Nack All (/sdks/elixir/how-to/queues/nack-all)



## Overview [#overview]

**Bulk nack** rejects an entire polled batch of queue messages in a single call instead of settling each one individually. It's the operation you reach for when a failure affects the whole batch at once — a downstream dependency is down, a shared resource lock couldn't be acquired, or a transient error means none of the messages can be processed right now — and retrying them one-by-one would just be extra round-trips for the same outcome.

It works with manual-ack polling: `KubeMQ.Client.poll_queue` returns a poll result holding the messages without settling them, and `KubeMQ.PollResponse.nack_all/1` sends one negative-acknowledge that settles every message in that result, returning them all to the queue for redelivery.

**Gotchas:** the receive count increments on every message in the batch, so an unbounded retry loop is one bad `nack_all/1` call away — pair it with a max-receive-count and a dead-letter policy. `nack_all/1` is all-or-nothing: you can't use it to keep a few messages and reject the rest — that needs per-message settlement. And calling it on an empty poll result is a wasted round-trip.

## Prerequisites [#prerequisites]

* KubeMQ server running on `localhost:50000`
* Elixir SDK installed (`{:kubemq, "~> 1.0"}` in mix.exs)

## Code [#code]

```elixir title="main.exs"
channel = "elixir-queues.nack-all"
{:ok, client} = KubeMQ.Client.start_link(address: "localhost:50000", client_id: "elixir-qs-nackall")

for i <- 1..3 do
  {:ok, _} = KubeMQ.Client.send_queue_message(client,
    KubeMQ.QueueMessage.new(channel: channel, body: "Retriable msg #{i}"))
end

IO.puts("Sent 3 messages")

case KubeMQ.Client.poll_queue(client,
       channel: channel,
       max_items: 10,
       wait_timeout: 5_000
     ) do
  {:ok, poll} ->
    IO.puts("Polled #{length(poll.messages)} messages")
    IO.puts("Simulating processing failure — nacking all...")

    case KubeMQ.PollResponse.nack_all(poll) do
      {:ok, _} -> IO.puts("All messages nacked (returned to queue for retry)")
      {:error, err} -> IO.puts("Nack failed: #{err.message}")
    end

  {:error, err} ->
    IO.puts("Poll failed: #{err.message}")
end

Process.sleep(500)

case KubeMQ.Client.receive_queue_messages(client, channel,
       max_messages: 10,
       wait_timeout: 3_000
     ) do
  {:ok, result} ->
    IO.puts("After nack, #{result.messages_received} messages available again")

  {:error, _} ->
    IO.puts("No messages available")
end

KubeMQ.Client.close(client)
```

## How It Works [#how-it-works]

* `PollResponse.nack_all/1` rejects all messages, returning them to the queue
* Messages become available again for other consumers or retry attempts
* Useful when a processing failure affects an entire batch

## Related [#related]

* [Ack/Reject](/sdks/elixir/how-to/queues/ack-reject)
* [Requeue All](/sdks/elixir/how-to/queues/requeue-all)