* Close initiate a clean channel closure by sending a close message with the error code set to '200'. It is safe to call this method multiple times.

* Channel opens a unique, concurrent server channel to process the bulk of AMQP messages. Any error from methods on this receiver will render the rec

Returns a connection to the AMQP if the AMQP_URL environment variable is set and a connection can be established.

* Publish sends a Publishing from the client to an exchange on the server. When you want a single message to be delivered to a single queue, you can

* QueueDeclare declares a queue to hold messages and deliver to consumers. Declaring creates a queue if it doesn't already exist, or ensures that an e

Checks if this bit mask matches the flags bitset

drops all but method frames expected on the given channel

Performs a request/response call for when the message is not NoWait and is specified as Synchronous.

* Consume immediately starts delivering queued messages. Begin receiving on the returned chan Delivery before any other operation on the Connection o

* ExchangeDeclare declares an exchange on the server. If the exchange does not already exist, the server will create it. If the exchange exists, the

* Open accepts an already established connection, or other io.ReadWriteCloser as a transport. Use this method if you have established a TLS connectio

ParseURI attempts to parse the given AMQP URI according to the spec. See http://www.rabbitmq.com/uri-spec.html. Default values for the fields are: S

send calls Channel.sendOpen() during normal operation. After the channel has been closed, send calls Channel.sendClosed(), ensuring only 'channel.clo

Dial accepts a string in the AMQP URI format and returns a new Connection over TCP using PlainAuth. Defaults to a server heartbeat interval of 10 sec

* Field tables are long strings that contain packed name-value pairs. The name-value pairs are encoded as short string defining the name, and octet

* Get synchronously receives a single Delivery from the head of a queue from the server to the client. In almost all cases, using Channel.Consume wil

Validate returns and error if any Go types in the table are incompatible with AMQP types.

Next reserves and returns the next available number out of the range between low and high. If no number is available, false is returned. O(N) worst

DialConfig accepts a string in the AMQP URI format and a configuration for the transport and connection setup, returning a new Connection. Defaults t

* NotifyPublish registers a listener for reliable publishing. Receives from this chan for every publish after Channel.Confirm will be in order startin

one confirms one publishing and all following in the publishing sequence

* QueueDelete removes the queue from the server including all bindings then purges the messages based on server configuration, returning the number of

reserve claims the bit if it is not already claimed, returning true if successfully claimed.

* Confirm puts this channel into confirm mode so that the client can ensure all publishings have successfully been received by the server. After ente

* NotifyClose registers a listener for when the server sends a channel or connection exception in the form of a Connection.Close or Channel.Close meth

* * Support for integration tests */

* QueueBind binds an exchange to a queue so that publishings to the exchange will be routed to the queue when the publishing routing key matches the b

NewAllocator reserves and frees integers out of a range between low and high. O(N) worst case space used, where N is maximum allocated, divided by si

IsClosed returns true if the connection is marked as closed, otherwise false is returned.

newConfirms allocates a confirms

* ExchangeDelete removes the named exchange from the server. When an exchange is deleted all queue bindings on the exchange are also deleted. If this

multiple confirms all publishings up until the delivery tag

* Qos controls how many messages or how many bytes the server will try to keep on the network for consumers before receiving delivery acks. The inten

* Reads a frame from an input stream and returns an interface that can be cast into one of the following: methodFrame PropertiesFrame bodyFr

Eventually called via the state machine from the connection's reader goroutine, so assumes serialized access.

Returns a connection, channel and declares a queue when the AMQP_URL is in the environment

* Cancel stops deliveries to the consumer chan established in Channel.Consume and identified by consumer. Only use this method to cleanly stop receiv

Close tears the connection down, taking the channel with it.

DialTLS accepts a string in the AMQP URI format and returns a new Connection over TCP using PlainAuth. Defaults to a server heartbeat interval of 10

* NotifyCancel registers a listener for basic.cancel methods. These can be sent from the server when a queue is deleted or when consuming from a mirr

* NotifyReturn registers a listener for basic.return methods. These can be sent from the server when a publish is undeliverable either from the manda

* QueueDeclarePassive is functionally and parametrically equivalent to QueueDeclare, except that it sets the "passive" attribute to true. A passive q

confirm confirms one publishing, increments the expecting delivery tag, and removes bookkeeping for that delivery tag.

release frees the use of the number for another allocation

* Close requests and waits for the response to close the AMQP connection. It's advisable to use this message when publishing to ensure all kernel buf

* ExchangeDeclarePassive is functionally and parametrically equivalent to ExchangeDeclare, except that it sets the "passive" attribute to true. A pas

* Flow pauses the delivery of messages to consumers on this channel. Channels are opened with flow control active, to open a channel with paused deli

* Tx puts the channel into transaction mode on the server. All publishings and acknowledgments following this method will be atomically committed or

closeChannel releases and initiates a shutdown of the channel. All channel closures should be initiated here for proper channel lifecycle management

Delegates to integrationConnection and only returns a connection if the product is RabbitMQ

Constructs a new channel with the given framing rules

Connection = open-Connection *use-Connection close-Connection open-Connection = C:protocol-header S:START C:START-OK *challenge S:TUNE C:

* 'A': []interface{} 'D': Decimal 'F': Table 'I': int32 'S': string 'T': time.Time 'V': nil 'b': byte 'd': float64 'f': float32 'l': int64 's': int16