Struct Channel

pub struct Channel<T> {
    pub transport: Arc<Mutex<RawMutex, AMQPTransport<T>>>,
    pub id: u16,
}

Channel provides methods to act on a channel, such as managing queues

Fields

transport: Arc<Mutex<RawMutex, AMQPTransport<T>>>

id: u16

Implementations

impl<T> Channel<T>

where T: AsyncRead + AsyncWrite + Send + Sync + 'static,

pub fn create( transport: Arc<Mutex<RawMutex, AMQPTransport<T>>>, ) -> impl Future<Item = Channel<T>, Error = Error> + Send + 'static

create a channel

pub fn access_request( &self, realm: &str, options: AccessRequestOptions, ) -> impl Future<Item = (), Error = Error> + Send + 'static

request access

returns a future that resolves once the access is granted

pub fn exchange_declare( &self, name: &str, exchange_type: &str, options: ExchangeDeclareOptions, arguments: BTreeMap<String, AMQPValue>, ) -> impl Future<Item = (), Error = Error> + Send + 'static

declares an exchange

returns a future that resolves once the exchange is available

pub fn exchange_delete( &self, name: &str, options: ExchangeDeleteOptions, ) -> impl Future<Item = (), Error = Error> + Send + 'static

deletes an exchange

returns a future that resolves once the exchange is deleted

pub fn exchange_bind( &self, destination: &str, source: &str, routing_key: &str, options: ExchangeBindOptions, arguments: BTreeMap<String, AMQPValue>, ) -> impl Future<Item = (), Error = Error> + Send + 'static

binds an exchange to another exchange

returns a future that resolves once the exchanges are bound

pub fn exchange_unbind( &self, destination: &str, source: &str, routing_key: &str, options: ExchangeUnbindOptions, arguments: BTreeMap<String, AMQPValue>, ) -> impl Future<Item = (), Error = Error> + Send + 'static

unbinds an exchange from another one

returns a future that resolves once the exchanges are unbound

pub fn queue_declare( &self, name: &str, options: QueueDeclareOptions, arguments: BTreeMap<String, AMQPValue>, ) -> impl Future<Item = Queue, Error = Error> + Send + 'static

declares a queue

returns a future that resolves once the queue is available

the mandatory and ìmmediate options can be set to true, but the return message will not be handled

pub fn queue_bind( &self, name: &str, exchange: &str, routing_key: &str, options: QueueBindOptions, arguments: BTreeMap<String, AMQPValue>, ) -> impl Future<Item = (), Error = Error> + Send + 'static

binds a queue to an exchange

returns a future that resolves once the queue is bound to the exchange

pub fn queue_unbind( &self, name: &str, exchange: &str, routing_key: &str, options: QueueUnbindOptions, arguments: BTreeMap<String, AMQPValue>, ) -> impl Future<Item = (), Error = Error> + Send + 'static

unbinds a queue from the exchange

returns a future that resolves once the queue is unbound from the exchange

pub fn confirm_select( &self, options: ConfirmSelectOptions, ) -> impl Future<Item = (), Error = Error> + Send + 'static

sets up confirm extension for this channel

pub fn basic_qos( &self, options: BasicQosOptions, ) -> impl Future<Item = (), Error = Error> + Send + 'static

specifies quality of service for a channel

pub fn basic_publish( &self, exchange: &str, routing_key: &str, payload: Vec<u8>, options: BasicPublishOptions, properties: AMQPProperties, ) -> impl Future<Item = Option<u64>, Error = Error> + Send + 'static

publishes a message on a queue

the future’s result is:

• Some(request_id) if we’re on a confirm channel and the message was ack’d
• None if we’re not on a confirm channel or the message was nack’d

pub fn basic_consume( &self, queue: &Queue, consumer_tag: &str, options: BasicConsumeOptions, arguments: BTreeMap<String, AMQPValue>, ) -> impl Future<Item = Consumer<T>, Error = Error> + Send + 'static

creates a consumer stream

returns a future of a Consumer that resolves once the method succeeds

Consumer implements futures::Stream, so it can be used with any of the usual combinators

pub fn basic_ack( &self, delivery_tag: u64, multiple: bool, ) -> impl Future<Item = (), Error = Error> + Send + 'static

acks a message

pub fn basic_nack( &self, delivery_tag: u64, multiple: bool, requeue: bool, ) -> impl Future<Item = (), Error = Error> + Send + 'static

nacks a message

pub fn basic_reject( &self, delivery_tag: u64, requeue: bool, ) -> impl Future<Item = (), Error = Error> + Send + 'static

rejects a message

pub fn basic_get( &self, queue: &str, options: BasicGetOptions, ) -> impl Future<Item = BasicGetMessage, Error = Error> + Send + 'static

gets a message

pub fn queue_purge( &self, queue_name: &str, options: QueuePurgeOptions, ) -> impl Future<Item = (), Error = Error> + Send + 'static

Purge a queue.

This method removes all messages from a queue which are not awaiting acknowledgment.

pub fn queue_delete( &self, queue_name: &str, options: QueueDeleteOptions, ) -> impl Future<Item = (), Error = Error> + Send + 'static

Delete a queue.

This method deletes a queue. When a queue is deleted any pending messages are sent to a dead-letter queue if this is defined in the server configuration, and all consumers on the queue are cancelled.

If if_unused is set, the server will only delete the queue if it has no consumers. If the queue has consumers the server does not delete it but raises a channel exception instead.

If if_empty is set, the server will only delete the queue if it has no messages.

pub fn close( &self, code: u16, message: &str, ) -> impl Future<Item = (), Error = Error> + Send + 'static

closes the channel

pub fn close_ok(&self) -> impl Future<Item = (), Error = Error> + Send + 'static

ack a channel close

pub fn channel_flow( &self, options: ChannelFlowOptions, ) -> impl Future<Item = (), Error = Error> + Send + 'static

update a channel flow

pub fn channel_flow_ok( &self, options: ChannelFlowOptions, ) -> impl Future<Item = (), Error = Error> + Send + 'static

ack an update to a channel flow

pub fn wait_for_answer<Finished>( tr: &mut AMQPTransport<T>, request_id: u64, finished: &Finished, ) -> Result<Async<Option<u64>>, Error>

where Finished: 'static + Send + Fn(&mut Connection, u64) -> Result<Async<Option<u64>>, Error>,

internal method to wait until a request succeeds

Trait Implementations

impl<T> Clone for Channel<T>

where T: Send,

fn clone(&self) -> Channel<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.