class

LavinMQ::AMQP::Channel

Inherits LavinMQ::Persister::ConfirmTarget < LavinMQ::SortableJSON < LavinMQ::Stats < LavinMQ::Client::Channel < LavinMQ::SortableJSON < Reference < Object

Constants

Log = LavinMQ::Log.for("amqp.channel")

Constructors

new(client : Client, id : UInt16)

Instance methods

ack_count

add_content(frame)

basic_ack(frame)

basic_get(frame)

basic_nack(frame)

basic_qos(frame) : Nil

basic_recover(frame) : Nil

basic_reject(frame)

cancel_consumer(consumer : AMQP::Consumer) : Nil

cancel_consumer(frame)

check_consumer_timeout

Iterate over all unacked messages and see if any has been unacked longer than the queue's consumer timeout

client

close(reason : String) : Nil

Closes the channel from the server side, e.g. from the management API. The client is told why with a Channel::Close frame. Consumers, unacked messages and buffers are released right away, so a client that never replies with Channel::CloseOk can't keep any of them alive.

close

confirm_count

confirm_select(frame)

consume(frame)

consumers

consumers_size

current_stats_details

Like stats_details but without log

deliver(frame, msg, redelivered = false, flush = true) : Nil

deliver_count

deliver_get_count

deliver_no_ack_count

details_tuple

do_confirm_ack(msgid, multiple = false)

enqueue_confirm_ack(msgid : UInt64) : Nil

Non-blocking; if the 1-slot mailbox is full, the stale msgid is dropped (acks are cumulative).

find_consumer

flow(active : Bool)

flow?

flush

get_count

get_no_ack_count

global_prefetch_count

has_capacity

has_capacity?

id

increment_deliver_count(redelivered : Bool, no_ack : Bool = false)

name

next_msg_headers(frame)

prefetch_count

prefetch_count=(value : UInt16)

publish_count

redeliver_count

reject_count

return_unroutable_count

running=(running : Bool)

running?

send(frame)

start_publish(frame)

state

stats_details

to_json(json : JSON::Builder)

tx_commit(frame)

tx_rollback(frame)

tx_select(frame)

unacked

update_rates

Nested types