NAME

Net::AMQP::Protocol::v0_8 - AMQP v0.8 (de)serialization and representation

SYNOPSIS

  use Net::AMQP::Protocol::v0_8;
  
  ...

  my @frames = Net::AMQP->parse_raw_frames(\$input);
  
  ...

  my $frame = Net::AMQP::Frame::Method->new(
      channel => 0,
      method_frame => Net::AMQP::Protocol::Connection::StartOk->new(
          client_properties => { ... },
          mechanism         => 'AMQPLAIN',
          locale            => 'en_US',
          response          => {
              LOGIN    => 'guest',
              PASSWORD => 'guest',
          },
      ),
  );

  print OUT $frame->to_raw_frame();

DESCRIPTION

This module implements the frame (de)serialization and representation of the Advanced Message Queue Protocol (http://www.amqp.org/) version 0.8.

It is to be used in conjunction with client or server software that does the actual TCP/IP communication.

PROTOCOL CLASSES

Net::AMQP::Protocol::Connection::Start

This class implements the class Connection method Start, which is a synchronous method.

This method starts the connection negotiation process by telling the client the protocol version that the server proposes, along with a list of security mechanisms which the client can use for authentication.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

version_major (type: octet): Protocol major version
The protocol major version that the server agrees to use, which cannot be higher than the client's major version.
version_minor (type: octet): Protocol major version
The protocol minor version that the server agrees to use, which cannot be higher than the client's minor version.
server_properties (type: table): Server properties
mechanisms (type: longstr): Available security mechanisms
A list of the security mechanisms that the server supports, delimited by spaces. Currently ASL supports these mechanisms: PLAIN.
locales (type: longstr): Available message locales
A list of the message locales that the server supports, delimited by spaces. The locale defines the language in which the server will send reply texts.

Net::AMQP::Protocol::Connection::StartOk

This class implements the class Connection method StartOk, which is a synchronous method.

This method selects a SASL security mechanism. ASL uses SASL (RFC2222) to negotiate authentication and encryption.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

client_properties (type: table): Client properties
mechanism (type: shortstr): Selected security mechanism
A single security mechanisms selected by the client, which must be one of those specified by the server.
response (type: longstr): Security response data
A block of opaque data passed to the security mechanism. The contents of this data are defined by the SASL security mechanism. For the PLAIN security mechanism this is defined as a field table holding two fields, LOGIN and PASSWORD.
locale (type: shortstr): Selected message locale
A single message local selected by the client, which must be one of those specified by the server.

Net::AMQP::Protocol::Connection::Secure

This class implements the class Connection method Secure, which is a synchronous method.

The SASL protocol works by exchanging challenges and responses until both peers have received sufficient information to authenticate each other. This method challenges the client to provide more information.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

challenge (type: longstr): Security challenge data
Challenge information, a block of opaque binary data passed to the security mechanism.

Net::AMQP::Protocol::Connection::SecureOk

This class implements the class Connection method SecureOk, which is a synchronous method.

This method attempts to authenticate, passing a block of SASL data for the security mechanism at the server side.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

response (type: longstr): Security response data
A block of opaque data passed to the security mechanism. The contents of this data are defined by the SASL security mechanism.

Net::AMQP::Protocol::Connection::Tune

This class implements the class Connection method Tune, which is a synchronous method.

This method proposes a set of connection configuration values to the client. The client can accept and/or adjust these.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

channel_max (type: short): Proposed maximum channels
The maximum total number of channels that the server allows per connection. Zero means that the server does not impose a fixed limit, but the number of allowed channels may be limited by available server resources.
frame_max (type: long): Proposed maximum frame size
The largest frame size that the server proposes for the connection. The client can negotiate a lower value. Zero means that the server does not impose any specific limit but may reject very large frames if it cannot allocate resources for them.
heartbeat (type: short): Desired heartbeat delay
The delay, in seconds, of the connection heartbeat that the server wants. Zero means the server does not want a heartbeat.

Net::AMQP::Protocol::Connection::TuneOk

This class implements the class Connection method TuneOk, which is a synchronous method.

This method sends the client's connection tuning parameters to the server. Certain fields are negotiated, others provide capability information.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

channel_max (type: short): Negotiated maximum channels
The maximum total number of channels that the client will use per connection. May not be higher than the value specified by the server.
frame_max (type: long): Negotiated maximum frame size
The largest frame size that the client and server will use for the connection. Zero means that the client does not impose any specific limit but may reject very large frames if it cannot allocate resources for them. Note that the frame-max limit applies principally to content frames, where large contents can be broken into frames of arbitrary size.
heartbeat (type: short): Desired heartbeat delay
The delay, in seconds, of the connection heartbeat that the client wants. Zero means the client does not want a heartbeat.

Net::AMQP::Protocol::Connection::Open

This class implements the class Connection method Open, which is a synchronous method.

This method opens a connection to a virtual host, which is a collection of resources, and acts to separate multiple application domains within a server.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

virtual_host (type: shortstr): Virtual host name
The name of the virtual host to work with.
capabilities (type: shortstr): Required capabilities
The client may specify a number of capability names, delimited by spaces. The server can use this string to how to process the client's connection request.
insist (type: bit): Insist on connecting to server
In a configuration with multiple load-sharing servers, the server may respond to a Connection.Open method with a Connection.Redirect. The insist option tells the server that the client is insisting on a connection to the specified server.

Net::AMQP::Protocol::Connection::OpenOk

This class implements the class Connection method OpenOk, which is a synchronous method.

This method signals to the client that the connection is ready for use.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

known_hosts (type: shortstr)

Net::AMQP::Protocol::Connection::Redirect

This class implements the class Connection method Redirect, which is a synchronous method.

This method redirects the client to another server, based on the requested virtual host and/or capabilities.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

host (type: shortstr): Server to connect to
Specifies the server to connect to. This is an IP address or a DNS name, optionally followed by a colon and a port number. If no port number is specified, the client should use the default port number for the protocol.
known_hosts (type: shortstr)

Net::AMQP::Protocol::Connection::Close

This class implements the class Connection method Close, which is a synchronous method.

This method indicates that the sender wants to close the connection. This may be due to internal conditions (e.g. a forced shut-down) or due to an error handling a specific method, i.e. an exception. When a close is due to an exception, the sender provides the class and method id of the method which caused the exception.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

reply_code (type: short)
reply_text (type: shortstr)
class_id (type: short): Failing method class
When the close is provoked by a method exception, this is the class of the method.
method_id (type: short): Failing method ID
When the close is provoked by a method exception, this is the ID of the method.

Net::AMQP::Protocol::Connection::CloseOk

This class implements the class Connection method CloseOk, which is a synchronous method.

This method confirms a Connection.Close method and tells the recipient that it is safe to release resources for the connection and close the socket.

This class has no fields nor accessors.

Net::AMQP::Protocol::Channel::Open

This class implements the class Channel method Open, which is a synchronous method.

This method opens a virtual connection (a channel).

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

out_of_band (type: shortstr): Out-of-band settings
Configures out-of-band transfers on this channel. The syntax and meaning of this field will be formally defined at a later date.

Net::AMQP::Protocol::Channel::OpenOk

This class implements the class Channel method OpenOk, which is a synchronous method.

This method signals to the client that the channel is ready for use.

This class has no fields nor accessors.

Net::AMQP::Protocol::Channel::Flow

This class implements the class Channel method Flow, which is a synchronous method.

This method asks the peer to pause or restart the flow of content data. This is a simple flow-control mechanism that a peer can use to avoid oveflowing its queues or otherwise finding itself receiving more messages than it can process. Note that this method is not intended for window control. The peer that receives a request to stop sending content should finish sending the current content, if any, and then wait until it receives a Flow restart method.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

active (type: bit): Start/stop content frames
If 1, the peer starts sending content frames. If 0, the peer stops sending content frames.

Net::AMQP::Protocol::Channel::FlowOk

This class implements the class Channel method FlowOk, which is an asynchronous method.

Confirms to the peer that a flow command was received and processed.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

active (type: bit): Current flow setting
Confirms the setting of the processed flow method: 1 means the peer will start sending or continue to send content frames; 0 means it will not.

Net::AMQP::Protocol::Channel::Alert

This class implements the class Channel method Alert, which is an asynchronous method.

This method allows the server to send a non-fatal warning to the client. This is used for methods that are normally asynchronous and thus do not have confirmations, and for which the server may detect errors that need to be reported. Fatal errors are handled as channel or connection exceptions; non-fatal errors are sent through this method.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

reply_code (type: short)
reply_text (type: shortstr)
details (type: table): Detailed information for warning
A set of fields that provide more information about the problem. The meaning of these fields are defined on a per-reply-code basis (TO BE DEFINED).

Net::AMQP::Protocol::Channel::Close

This class implements the class Channel method Close, which is a synchronous method.

This method indicates that the sender wants to close the channel. This may be due to internal conditions (e.g. a forced shut-down) or due to an error handling a specific method, i.e. an exception. When a close is due to an exception, the sender provides the class and method id of the method which caused the exception.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

reply_code (type: short)
reply_text (type: shortstr)
class_id (type: short): Failing method class
When the close is provoked by a method exception, this is the class of the method.
method_id (type: short): Failing method ID
When the close is provoked by a method exception, this is the ID of the method.

Net::AMQP::Protocol::Channel::CloseOk

This class implements the class Channel method CloseOk, which is a synchronous method.

This method confirms a Channel.Close method and tells the recipient that it is safe to release resources for the channel and close the socket.

This class has no fields nor accessors.

Net::AMQP::Protocol::Access::Request

This class implements the class Access method Request, which is a synchronous method.

This method requests an access ticket for an access realm. The server responds by granting the access ticket. If the client does not have access rights to the requested realm this causes a connection exception. Access tickets are a per-channel resource.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

realm (type: shortstr): Name of requested realm
exclusive (type: bit): Request exclusive access
Request exclusive access to the realm. If the server cannot grant this - because there are other active tickets for the realm - it raises a channel exception.
passive (type: bit): Request passive access
Request message passive access to the specified access realm. Passive access lets a client get information about resources in the realm but not to make any changes to them.
active (type: bit): Request active access
Request message active access to the specified access realm. Acvtive access lets a client get create and delete resources in the realm.
write (type: bit): Request write access
Request write access to the specified access realm. Write access lets a client publish messages to all exchanges in the realm.
read (type: bit): Request read access
Request read access to the specified access realm. Read access lets a client consume messages from queues in the realm.

Net::AMQP::Protocol::Access::RequestOk

This class implements the class Access method RequestOk, which is a synchronous method.

This method provides the client with an access ticket. The access ticket is valid within the current channel and for the lifespan of the channel.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

ticket (type: short)

Net::AMQP::Protocol::Exchange::Declare

This class implements the class Exchange method Declare, which is a synchronous method.

This method creates an exchange if it does not already exist, and if the exchange exists, verifies that it is of the correct and expected class.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

ticket (type: short): When a client defines a new exchange, this belongs to the access realm of the ticket used. All further work done with that exchange must be done with an access ticket for the same realm.
exchange (type: shortstr)
type (type: shortstr): Exchange type
Each exchange belongs to one of a set of exchange types implemented by the server. The exchange types define the functionality of the exchange - i.e. how messages are routed through it. It is not valid or meaningful to attempt to change the type of an existing exchange.
passive (type: bit): Do not create exchange
If set, the server will not create the exchange. The client can use this to check whether an exchange exists without modifying the server state.
durable (type: bit): Request a durable exchange
If set when creating a new exchange, the exchange will be marked as durable. Durable exchanges remain active when a server restarts. Non-durable exchanges (transient exchanges) are purged if/when a server restarts.
auto_delete (type: bit): Auto-delete when unused
If set, the exchange is deleted when all queues have finished using it.
internal (type: bit): Create internal exchange
If set, the exchange may not be used directly by publishers, but only when bound to other exchanges. Internal exchanges are used to construct wiring that is not visible to applications.
nowait (type: bit): Do not send a reply method
If set, the server will not respond to the method. The client should not wait for a reply method. If the server could not complete the method it will raise a channel or connection exception.
arguments (type: table): Arguments for declaration
A set of arguments for the declaration. The syntax and semantics of these arguments depends on the server implementation. This field is ignored if passive is 1.

Net::AMQP::Protocol::Exchange::DeclareOk

This class implements the class Exchange method DeclareOk, which is a synchronous method.

This method confirms a Declare method and confirms the name of the exchange, essential for automatically-named exchanges.

This class has no fields nor accessors.

Net::AMQP::Protocol::Exchange::Delete

This class implements the class Exchange method Delete, which is a synchronous method.

This method deletes an exchange. When an exchange is deleted all queue bindings on the exchange are cancelled.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

ticket (type: short)
exchange (type: shortstr)
if_unused (type: bit): Delete only if unused
If set, the server will only delete the exchange if it has no queue bindings. If the exchange has queue bindings the server does not delete it but raises a channel exception instead.
nowait (type: bit): Do not send a reply method
If set, the server will not respond to the method. The client should not wait for a reply method. If the server could not complete the method it will raise a channel or connection exception.

Net::AMQP::Protocol::Exchange::DeleteOk

This class implements the class Exchange method DeleteOk, which is a synchronous method.

This method confirms the deletion of an exchange.

This class has no fields nor accessors.

Net::AMQP::Protocol::Queue::Declare

This class implements the class Queue method Declare, which is a synchronous method.

This method creates or checks a queue. When creating a new queue the client can specify various properties that control the durability of the queue and its contents, and the level of sharing for the queue.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

ticket (type: short): When a client defines a new queue, this belongs to the access realm of the ticket used. All further work done with that queue must be done with an access ticket for the same realm.
The client provides a valid access ticket giving "active" access to the realm in which the queue exists or will be created, or "passive" access if the if-exists flag is set.
queue (type: shortstr)
passive (type: bit): Do not create queue
If set, the server will not create the queue. The client can use this to check whether a queue exists without modifying the server state.
durable (type: bit): Request a durable queue
If set when creating a new queue, the queue will be marked as durable. Durable queues remain active when a server restarts. Non-durable queues (transient queues) are purged if/when a server restarts. Note that durable queues do not necessarily hold persistent messages, although it does not make sense to send persistent messages to a transient queue.
exclusive (type: bit): Request an exclusive queue
Exclusive queues may only be consumed from by the current connection. Setting the 'exclusive' flag always implies 'auto-delete'.
auto_delete (type: bit): Auto-delete queue when unused
If set, the queue is deleted when all consumers have finished using it. Last consumer can be cancelled either explicitly or because its channel is closed. If there was no consumer ever on the queue, it won't be deleted.
nowait (type: bit): Do not send a reply method
If set, the server will not respond to the method. The client should not wait for a reply method. If the server could not complete the method it will raise a channel or connection exception.
arguments (type: table): Arguments for declaration
A set of arguments for the declaration. The syntax and semantics of these arguments depends on the server implementation. This field is ignored if passive is 1.

Net::AMQP::Protocol::Queue::DeclareOk

This class implements the class Queue method DeclareOk, which is a synchronous method.

This method confirms a Declare method and confirms the name of the queue, essential for automatically-named queues.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

queue (type: shortstr): Reports the name of the queue. If the server generated a queue name, this field contains that name.
message_count (type: long): Number of messages in queue
Reports the number of messages in the queue, which will be zero for newly-created queues.
consumer_count (type: long): Number of consumers
Reports the number of active consumers for the queue. Note that consumers can suspend activity (Channel.Flow) in which case they do not appear in this count.

Net::AMQP::Protocol::Queue::Bind

This class implements the class Queue method Bind, which is a synchronous method.

This method binds a queue to an exchange. Until a queue is bound it will not receive any messages. In a classic messaging model, store-and-forward queues are bound to a dest exchange and subscription queues are bound to a dest_wild exchange.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

ticket (type: short): The client provides a valid access ticket giving "active" access rights to the queue's access realm.
queue (type: shortstr): Specifies the name of the queue to bind. If the queue name is empty, refers to the current queue for the channel, which is the last declared queue.
exchange (type: shortstr): The name of the exchange to bind to.
routing_key (type: shortstr): Message routing key
Specifies the routing key for the binding. The routing key is used for routing messages depending on the exchange configuration. Not all exchanges use a routing key - refer to the specific exchange documentation. If the routing key is empty and the queue name is empty, the routing key will be the current queue for the channel, which is the last declared queue.
nowait (type: bit): Do not send a reply method
If set, the server will not respond to the method. The client should not wait for a reply method. If the server could not complete the method it will raise a channel or connection exception.
arguments (type: table): Arguments for binding
A set of arguments for the binding. The syntax and semantics of these arguments depends on the exchange class.

Net::AMQP::Protocol::Queue::BindOk

This class implements the class Queue method BindOk, which is a synchronous method.

This method confirms that the bind was successful.

This class has no fields nor accessors.

Net::AMQP::Protocol::Queue::Purge

This class implements the class Queue method Purge, which is a synchronous method.

This method removes all messages from a queue. It does not cancel consumers. Purged messages are deleted without any formal "undo" mechanism.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

ticket (type: short): The access ticket must be for the access realm that holds the queue.
queue (type: shortstr): Specifies the name of the queue to purge. If the queue name is empty, refers to the current queue for the channel, which is the last declared queue.
nowait (type: bit): Do not send a reply method
If set, the server will not respond to the method. The client should not wait for a reply method. If the server could not complete the method it will raise a channel or connection exception.

Net::AMQP::Protocol::Queue::PurgeOk

This class implements the class Queue method PurgeOk, which is a synchronous method.

This method confirms the purge of a queue.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

message_count (type: long): Number of messages purged
Reports the number of messages purged.

Net::AMQP::Protocol::Queue::Delete

This class implements the class Queue method Delete, which is a synchronous method.

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.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

ticket (type: short): The client provides a valid access ticket giving "active" access rights to the queue's access realm.
queue (type: shortstr): Specifies the name of the queue to delete. If the queue name is empty, refers to the current queue for the channel, which is the last declared queue.
if_unused (type: bit): Delete only if unused
If set, the server will only delete the queue if it has no consumers. If the queue has consumers the server does does not delete it but raises a channel exception instead.
if_empty (type: bit): Delete only if empty
If set, the server will only delete the queue if it has no messages. If the queue is not empty the server raises a channel exception.
nowait (type: bit): Do not send a reply method
If set, the server will not respond to the method. The client should not wait for a reply method. If the server could not complete the method it will raise a channel or connection exception.

Net::AMQP::Protocol::Queue::DeleteOk

This class implements the class Queue method DeleteOk, which is a synchronous method.

This method confirms the deletion of a queue.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

message_count (type: long): Number of messages purged
Reports the number of messages purged.

Net::AMQP::Protocol::Basic::Qos

This class implements the class Basic method Qos, which is a synchronous method.

This method requests a specific quality of service. The QoS can be specified for the current channel or for all channels on the connection. The particular properties and semantics of a qos method always depend on the content class semantics. Though the qos method could in principle apply to both peers, it is currently meaningful only for the server.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

prefetch_size (type: long): Prefetch window in octets
The client can request that messages be sent in advance so that when the client finishes processing a message, the following message is already held locally, rather than needing to be sent down the channel. Prefetching gives a performance improvement. This field specifies the prefetch window size in octets. The server will send a message in advance if it is equal to or smaller in size than the available prefetch size (and also falls into other prefetch limits). May be set to zero, meaning "no specific limit", although other prefetch limits may still apply. The prefetch-size is ignored if the no-ack option is set.
prefetch_count (type: short): Prefetch window in messages
Specifies a prefetch window in terms of whole messages. This field may be used in combination with the prefetch-size field; a message will only be sent in advance if both prefetch windows (and those at the channel and connection level) allow it. The prefetch-count is ignored if the no-ack option is set.
global (type: bit): Apply to entire connection
By default the QoS settings apply to the current channel only. If this field is set, they are applied to the entire connection.

Net::AMQP::Protocol::Basic::QosOk

This class implements the class Basic method QosOk, which is a synchronous method.

This method tells the client that the requested QoS levels could be handled by the server. The requested QoS applies to all active consumers until a new QoS is defined.

This class has no fields nor accessors.

Net::AMQP::Protocol::Basic::Consume

This class implements the class Basic method Consume, which is a synchronous method.

This method asks the server to start a "consumer", which is a transient request for messages from a specific queue. Consumers last as long as the channel they were created on, or until the client cancels them.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

ticket (type: short)
queue (type: shortstr): Specifies the name of the queue to consume from. If the queue name is null, refers to the current queue for the channel, which is the last declared queue.
consumer_tag (type: shortstr): Specifies the identifier for the consumer. The consumer tag is local to a connection, so two clients can use the same consumer tags. If this field is empty the server will generate a unique tag.
no_local (type: bit)
no_ack (type: bit)
exclusive (type: bit): Request exclusive access
Request exclusive consumer access, meaning only this consumer can access the queue.
nowait (type: bit): Do not send a reply method
If set, the server will not respond to the method. The client should not wait for a reply method. If the server could not complete the method it will raise a channel or connection exception.

Net::AMQP::Protocol::Basic::ConsumeOk

This class implements the class Basic method ConsumeOk, which is a synchronous method.

The server provides the client with a consumer tag, which is used by the client for methods called on the consumer at a later stage.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

consumer_tag (type: shortstr): Holds the consumer tag specified by the client or provided by the server.

Net::AMQP::Protocol::Basic::Cancel

This class implements the class Basic method Cancel, which is a synchronous method.

This method cancels a consumer. This does not affect already delivered messages, but it does mean the server will not send any more messages for that consumer. The client may receive an abitrary number of messages in between sending the cancel method and receiving the cancel-ok reply.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

consumer_tag (type: shortstr)
nowait (type: bit): Do not send a reply method
If set, the server will not respond to the method. The client should not wait for a reply method. If the server could not complete the method it will raise a channel or connection exception.

Net::AMQP::Protocol::Basic::CancelOk

This class implements the class Basic method CancelOk, which is a synchronous method.

This method confirms that the cancellation was completed.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

consumer_tag (type: shortstr)

Net::AMQP::Protocol::Basic::Publish

This class implements the class Basic method Publish, which is an asynchronous method.

This method publishes a message to a specific exchange. The message will be routed to queues as defined by the exchange configuration and distributed to any active consumers when the transaction, if any, is committed.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

ticket (type: short)
exchange (type: shortstr): Specifies the name of the exchange to publish to. The exchange name can be empty, meaning the default exchange. If the exchange name is specified, and that exchange does not exist, the server will raise a channel exception.
routing_key (type: shortstr): Message routing key
Specifies the routing key for the message. The routing key is used for routing messages depending on the exchange configuration.
mandatory (type: bit): Indicate mandatory routing
This flag tells the server how to react if the message cannot be routed to a queue. If this flag is set, the server will return an unroutable message with a Return method. If this flag is zero, the server silently drops the message.
immediate (type: bit): Request immediate delivery
This flag tells the server how to react if the message cannot be routed to a queue consumer immediately. If this flag is set, the server will return an undeliverable message with a Return method. If this flag is zero, the server will queue the message, but with no guarantee that it will ever be consumed.

Net::AMQP::Protocol::Basic::Return

This class implements the class Basic method Return, which is an asynchronous method.

This method returns an undeliverable message that was published with the "immediate" flag set, or an unroutable message published with the "mandatory" flag set. The reply code and text provide information about the reason that the message was undeliverable.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

reply_code (type: short)
reply_text (type: shortstr)
exchange (type: shortstr): Specifies the name of the exchange that the message was originally published to.
routing_key (type: shortstr): Message routing key
Specifies the routing key name specified when the message was published.

Net::AMQP::Protocol::Basic::Deliver

This class implements the class Basic method Deliver, which is an asynchronous method.

This method delivers a message to the client, via a consumer. In the asynchronous message delivery model, the client starts a consumer using the Consume method, then the server responds with Deliver methods as and when messages arrive for that consumer.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

consumer_tag (type: shortstr)
delivery_tag (type: longlong)
redelivered (type: bit)
exchange (type: shortstr): Specifies the name of the exchange that the message was originally published to.
routing_key (type: shortstr): Message routing key
Specifies the routing key name specified when the message was published.

Net::AMQP::Protocol::Basic::Get

This class implements the class Basic method Get, which is a synchronous method.

This method provides a direct access to the messages in a queue using a synchronous dialogue that is designed for specific types of application where synchronous functionality is more important than performance.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

ticket (type: short)
queue (type: shortstr): Specifies the name of the queue to consume from. If the queue name is null, refers to the current queue for the channel, which is the last declared queue.
no_ack (type: bit)

Net::AMQP::Protocol::Basic::GetOk

This class implements the class Basic method GetOk, which is a synchronous method.

This method delivers a message to the client following a get method. A message delivered by 'get-ok' must be acknowledged unless the no-ack option was set in the get method.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

delivery_tag (type: longlong)
redelivered (type: bit)
exchange (type: shortstr): Specifies the name of the exchange that the message was originally published to. If empty, the message was published to the default exchange.
routing_key (type: shortstr): Message routing key
Specifies the routing key name specified when the message was published.
message_count (type: long): Number of messages pending
This field reports the number of messages pending on the queue, excluding the message being delivered. Note that this figure is indicative, not reliable, and can change arbitrarily as messages are added to the queue and removed by other clients.

Net::AMQP::Protocol::Basic::GetEmpty

This class implements the class Basic method GetEmpty, which is a synchronous method.

This method tells the client that the queue has no messages available for the client.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

cluster_id (type: shortstr): Cluster id
For use by cluster applications, should not be used by client applications.

Net::AMQP::Protocol::Basic::Ack

This class implements the class Basic method Ack, which is an asynchronous method.

This method acknowledges one or more messages delivered via the Deliver or Get-Ok methods. The client can ask to confirm a single message or a set of messages up to and including a specific message.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

delivery_tag (type: longlong)
multiple (type: bit): Acknowledge multiple messages
If set to 1, the delivery tag is treated as "up to and including", so that the client can acknowledge multiple messages with a single method. If set to zero, the delivery tag refers to a single message. If the multiple field is 1, and the delivery tag is zero, tells the server to acknowledge all outstanding mesages.

Net::AMQP::Protocol::Basic::Reject

This class implements the class Basic method Reject, which is an asynchronous method.

This method allows a client to reject a message. It can be used to interrupt and cancel large incoming messages, or return untreatable messages to their original queue.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

delivery_tag (type: longlong)
requeue (type: bit): Requeue the message
If this field is zero, the message will be discarded. If this bit is 1, the server will attempt to requeue the message.

Net::AMQP::Protocol::Basic::Recover

This class implements the class Basic method Recover, which is an asynchronous method.

This method asks the broker to redeliver all unacknowledged messages on a specifieid channel. Zero or more messages may be redelivered.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

requeue (type: bit): Requeue the message
If this field is zero, the message will be redelivered to the original recipient. If this bit is 1, the server will attempt to requeue the message, potentially then delivering it to an alternative subscriber.

Net::AMQP::Protocol::Basic::ContentHeader

This class implements the class Basic method ContentHeader, which is an asynchronous method.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

content_type (type: shortstr)
content_encoding (type: shortstr)
headers (type: table)
delivery_mode (type: octet)
priority (type: octet)
correlation_id (type: shortstr)
reply_to (type: shortstr)
expiration (type: shortstr)
message_id (type: shortstr)
timestamp (type: timestamp)
type (type: shortstr)
user_id (type: shortstr)
app_id (type: shortstr)
cluster_id (type: shortstr)

Net::AMQP::Protocol::File::Qos

This class implements the class File method Qos, which is a synchronous method.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

prefetch_size (type: long): Prefetch window in octets
The client can request that messages be sent in advance so that when the client finishes processing a message, the following message is already held locally, rather than needing to be sent down the channel. Prefetching gives a performance improvement. This field specifies the prefetch window size in octets. May be set to zero, meaning "no specific limit". Note that other prefetch limits may still apply. The prefetch-size is ignored if the no-ack option is set.
prefetch_count (type: short): Prefetch window in messages
Specifies a prefetch window in terms of whole messages. This is compatible with some file API implementations. This field may be used in combination with the prefetch-size field; a message will only be sent in advance if both prefetch windows (and those at the channel and connection level) allow it. The prefetch-count is ignored if the no-ack option is set.
global (type: bit): Apply to entire connection
By default the QoS settings apply to the current channel only. If this field is set, they are applied to the entire connection.

Net::AMQP::Protocol::File::QosOk

This class implements the class File method QosOk, which is a synchronous method.

This method tells the client that the requested QoS levels could be handled by the server. The requested QoS applies to all active consumers until a new QoS is defined.

This class has no fields nor accessors.

Net::AMQP::Protocol::File::Consume

This class implements the class File method Consume, which is a synchronous method.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

ticket (type: short)
queue (type: shortstr): Specifies the name of the queue to consume from. If the queue name is null, refers to the current queue for the channel, which is the last declared queue.
consumer_tag (type: shortstr): Specifies the identifier for the consumer. The consumer tag is local to a connection, so two clients can use the same consumer tags. If this field is empty the server will generate a unique tag.
no_local (type: bit)
no_ack (type: bit)
exclusive (type: bit): Request exclusive access
Request exclusive consumer access, meaning only this consumer can access the queue.
nowait (type: bit): Do not send a reply method
If set, the server will not respond to the method. The client should not wait for a reply method. If the server could not complete the method it will raise a channel or connection exception.

Net::AMQP::Protocol::File::ConsumeOk

This class implements the class File method ConsumeOk, which is a synchronous method.

This method provides the client with a consumer tag which it MUST use in methods that work with the consumer.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

consumer_tag (type: shortstr): Holds the consumer tag specified by the client or provided by the server.

Net::AMQP::Protocol::File::Cancel

This class implements the class File method Cancel, which is a synchronous method.

This method cancels a consumer. This does not affect already delivered messages, but it does mean the server will not send any more messages for that consumer.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

consumer_tag (type: shortstr)
nowait (type: bit): Do not send a reply method
If set, the server will not respond to the method. The client should not wait for a reply method. If the server could not complete the method it will raise a channel or connection exception.

Net::AMQP::Protocol::File::CancelOk

This class implements the class File method CancelOk, which is a synchronous method.

This method confirms that the cancellation was completed.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

consumer_tag (type: shortstr)

Net::AMQP::Protocol::File::Open

This class implements the class File method Open, which is a synchronous method.

This method requests permission to start staging a message. Staging means sending the message into a temporary area at the recipient end and then delivering the message by referring to this temporary area. Staging is how the protocol handles partial file transfers - if a message is partially staged and the connection breaks, the next time the sender starts to stage it, it can restart from where it left off.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

identifier (type: shortstr): Staging identifier
This is the staging identifier. This is an arbitrary string chosen by the sender. For staging to work correctly the sender must use the same staging identifier when staging the same message a second time after recovery from a failure. A good choice for the staging identifier would be the SHA1 hash of the message properties data (including the original filename, revised time, etc.).
content_size (type: longlong): Message content size
The size of the content in octets. The recipient may use this information to allocate or check available space in advance, to avoid "disk full" errors during staging of very large messages.

Net::AMQP::Protocol::File::OpenOk

This class implements the class File method OpenOk, which is a synchronous method.

This method confirms that the recipient is ready to accept staged data. If the message was already partially-staged at a previous time the recipient will report the number of octets already staged.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

staged_size (type: longlong): Already staged amount
The amount of previously-staged content in octets. For a new message this will be zero.

Net::AMQP::Protocol::File::Stage

This class implements the class File method Stage, which is an asynchronous method.

This method stages the message, sending the message content to the recipient from the octet offset specified in the Open-Ok method.

This class has no fields nor accessors.

Net::AMQP::Protocol::File::Publish

This class implements the class File method Publish, which is an asynchronous method.

This method publishes a staged file message to a specific exchange. The file message will be routed to queues as defined by the exchange configuration and distributed to any active consumers when the transaction, if any, is committed.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

ticket (type: short)
exchange (type: shortstr): Specifies the name of the exchange to publish to. The exchange name can be empty, meaning the default exchange. If the exchange name is specified, and that exchange does not exist, the server will raise a channel exception.
routing_key (type: shortstr): Message routing key
Specifies the routing key for the message. The routing key is used for routing messages depending on the exchange configuration.
mandatory (type: bit): Indicate mandatory routing
This flag tells the server how to react if the message cannot be routed to a queue. If this flag is set, the server will return an unroutable message with a Return method. If this flag is zero, the server silently drops the message.
immediate (type: bit): Request immediate delivery
This flag tells the server how to react if the message cannot be routed to a queue consumer immediately. If this flag is set, the server will return an undeliverable message with a Return method. If this flag is zero, the server will queue the message, but with no guarantee that it will ever be consumed.
identifier (type: shortstr): Staging identifier
This is the staging identifier of the message to publish. The message must have been staged. Note that a client can send the Publish method asynchronously without waiting for staging to finish.

Net::AMQP::Protocol::File::Return

This class implements the class File method Return, which is an asynchronous method.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

reply_code (type: short)
reply_text (type: shortstr)
exchange (type: shortstr): Specifies the name of the exchange that the message was originally published to.
routing_key (type: shortstr): Message routing key
Specifies the routing key name specified when the message was published.

Net::AMQP::Protocol::File::Deliver

This class implements the class File method Deliver, which is an asynchronous method.

This method delivers a staged file message to the client, via a consumer. In the asynchronous message delivery model, the client starts a consumer using the Consume method, then the server responds with Deliver methods as and when messages arrive for that consumer.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

consumer_tag (type: shortstr)
delivery_tag (type: longlong)
redelivered (type: bit)
exchange (type: shortstr): Specifies the name of the exchange that the message was originally published to.
routing_key (type: shortstr): Message routing key
Specifies the routing key name specified when the message was published.
identifier (type: shortstr): Staging identifier
This is the staging identifier of the message to deliver. The message must have been staged. Note that a server can send the Deliver method asynchronously without waiting for staging to finish.

Net::AMQP::Protocol::File::Ack

This class implements the class File method Ack, which is an asynchronous method.

This method acknowledges one or more messages delivered via the Deliver method. The client can ask to confirm a single message or a set of messages up to and including a specific message.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

delivery_tag (type: longlong)
multiple (type: bit): Acknowledge multiple messages
If set to 1, the delivery tag is treated as "up to and including", so that the client can acknowledge multiple messages with a single method. If set to zero, the delivery tag refers to a single message. If the multiple field is 1, and the delivery tag is zero, tells the server to acknowledge all outstanding mesages.

Net::AMQP::Protocol::File::Reject

This class implements the class File method Reject, which is an asynchronous method.

This method allows a client to reject a message. It can be used to return untreatable messages to their original queue. Note that file content is staged before delivery, so the client will not use this method to interrupt delivery of a large message.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

delivery_tag (type: longlong)
requeue (type: bit): Requeue the message
If this field is zero, the message will be discarded. If this bit is 1, the server will attempt to requeue the message.

Net::AMQP::Protocol::File::ContentHeader

This class implements the class File method ContentHeader, which is an asynchronous method.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

content_type (type: shortstr)
content_encoding (type: shortstr)
headers (type: table)
priority (type: octet)
reply_to (type: shortstr)
message_id (type: shortstr)
filename (type: shortstr)
timestamp (type: timestamp)
cluster_id (type: shortstr)

Net::AMQP::Protocol::Stream::Qos

This class implements the class Stream method Qos, which is a synchronous method.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

prefetch_size (type: long): Prefetch window in octets
The client can request that messages be sent in advance so that when the client finishes processing a message, the following message is already held locally, rather than needing to be sent down the channel. Prefetching gives a performance improvement. This field specifies the prefetch window size in octets. May be set to zero, meaning "no specific limit". Note that other prefetch limits may still apply.
prefetch_count (type: short): Prefetch window in messages
Specifies a prefetch window in terms of whole messages. This field may be used in combination with the prefetch-size field; a message will only be sent in advance if both prefetch windows (and those at the channel and connection level) allow it.
consume_rate (type: long): Transfer rate in octets/second
Specifies a desired transfer rate in octets per second. This is usually determined by the application that uses the streaming data. A value of zero means "no limit", i.e. as rapidly as possible.
global (type: bit): Apply to entire connection
By default the QoS settings apply to the current channel only. If this field is set, they are applied to the entire connection.

Net::AMQP::Protocol::Stream::QosOk

This class implements the class Stream method QosOk, which is a synchronous method.

This method tells the client that the requested QoS levels could be handled by the server. The requested QoS applies to all active consumers until a new QoS is defined.

This class has no fields nor accessors.

Net::AMQP::Protocol::Stream::Consume

This class implements the class Stream method Consume, which is a synchronous method.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

ticket (type: short)
queue (type: shortstr): Specifies the name of the queue to consume from. If the queue name is null, refers to the current queue for the channel, which is the last declared queue.
consumer_tag (type: shortstr): Specifies the identifier for the consumer. The consumer tag is local to a connection, so two clients can use the same consumer tags. If this field is empty the server will generate a unique tag.
no_local (type: bit)
exclusive (type: bit): Request exclusive access
Request exclusive consumer access, meaning only this consumer can access the queue.
nowait (type: bit): Do not send a reply method
If set, the server will not respond to the method. The client should not wait for a reply method. If the server could not complete the method it will raise a channel or connection exception.

Net::AMQP::Protocol::Stream::ConsumeOk

This class implements the class Stream method ConsumeOk, which is a synchronous method.

This method provides the client with a consumer tag which it may use in methods that work with the consumer.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

consumer_tag (type: shortstr): Holds the consumer tag specified by the client or provided by the server.

Net::AMQP::Protocol::Stream::Cancel

This class implements the class Stream method Cancel, which is a synchronous method.

This method cancels a consumer. Since message delivery is asynchronous the client may continue to receive messages for a short while after canceling a consumer. It may process or discard these as appropriate.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

consumer_tag (type: shortstr)
nowait (type: bit): Do not send a reply method
If set, the server will not respond to the method. The client should not wait for a reply method. If the server could not complete the method it will raise a channel or connection exception.

Net::AMQP::Protocol::Stream::CancelOk

This class implements the class Stream method CancelOk, which is a synchronous method.

This method confirms that the cancellation was completed.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

consumer_tag (type: shortstr)

Net::AMQP::Protocol::Stream::Publish

This class implements the class Stream method Publish, which is an asynchronous method.

This method publishes a message to a specific exchange. The message will be routed to queues as defined by the exchange configuration and distributed to any active consumers as appropriate.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

ticket (type: short)
exchange (type: shortstr): Specifies the name of the exchange to publish to. The exchange name can be empty, meaning the default exchange. If the exchange name is specified, and that exchange does not exist, the server will raise a channel exception.
routing_key (type: shortstr): Message routing key
Specifies the routing key for the message. The routing key is used for routing messages depending on the exchange configuration.
mandatory (type: bit): Indicate mandatory routing
This flag tells the server how to react if the message cannot be routed to a queue. If this flag is set, the server will return an unroutable message with a Return method. If this flag is zero, the server silently drops the message.
immediate (type: bit): Request immediate delivery
This flag tells the server how to react if the message cannot be routed to a queue consumer immediately. If this flag is set, the server will return an undeliverable message with a Return method. If this flag is zero, the server will queue the message, but with no guarantee that it will ever be consumed.

Net::AMQP::Protocol::Stream::Return

This class implements the class Stream method Return, which is an asynchronous method.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

reply_code (type: short)
reply_text (type: shortstr)
exchange (type: shortstr): Specifies the name of the exchange that the message was originally published to.
routing_key (type: shortstr): Message routing key
Specifies the routing key name specified when the message was published.

Net::AMQP::Protocol::Stream::Deliver

This class implements the class Stream method Deliver, which is an asynchronous method.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

consumer_tag (type: shortstr)
delivery_tag (type: longlong)
exchange (type: shortstr): Specifies the name of the exchange that the message was originally published to.
queue (type: shortstr): Specifies the name of the queue that the message came from. Note that a single channel can start many consumers on different queues.

Net::AMQP::Protocol::Stream::ContentHeader

This class implements the class Stream method ContentHeader, which is an asynchronous method.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

content_type (type: shortstr)
content_encoding (type: shortstr)
headers (type: table)
priority (type: octet)
timestamp (type: timestamp)

Net::AMQP::Protocol::Tx::Select

This class implements the class Tx method Select, which is a synchronous method.

This method sets the channel to use standard transactions. The client must use this method at least once on a channel before using the Commit or Rollback methods.

This class has no fields nor accessors.

Net::AMQP::Protocol::Tx::SelectOk

This class implements the class Tx method SelectOk, which is a synchronous method.

This method confirms to the client that the channel was successfully set to use standard transactions.

This class has no fields nor accessors.

Net::AMQP::Protocol::Tx::Commit

This class implements the class Tx method Commit, which is a synchronous method.

This method commits all messages published and acknowledged in the current transaction. A new transaction starts immediately after a commit.

This class has no fields nor accessors.

Net::AMQP::Protocol::Tx::CommitOk

This class implements the class Tx method CommitOk, which is a synchronous method.

This method confirms to the client that the commit succeeded. Note that if a commit fails, the server raises a channel exception.

This class has no fields nor accessors.

Net::AMQP::Protocol::Tx::Rollback

This class implements the class Tx method Rollback, which is a synchronous method.

This method abandons all messages published and acknowledged in the current transaction. A new transaction starts immediately after a rollback.

This class has no fields nor accessors.

Net::AMQP::Protocol::Tx::RollbackOk

This class implements the class Tx method RollbackOk, which is a synchronous method.

This method confirms to the client that the rollback succeeded. Note that if an rollback fails, the server raises a channel exception.

This class has no fields nor accessors.

Net::AMQP::Protocol::Dtx::Select

This class implements the class Dtx method Select, which is a synchronous method.

This method sets the channel to use distributed transactions. The client must use this method at least once on a channel before using the Start method.

This class has no fields nor accessors.

Net::AMQP::Protocol::Dtx::SelectOk

This class implements the class Dtx method SelectOk, which is a synchronous method.

This method confirms to the client that the channel was successfully set to use distributed transactions.

This class has no fields nor accessors.

Net::AMQP::Protocol::Dtx::Start

This class implements the class Dtx method Start, which is a synchronous method.

This method starts a new distributed transaction. This must be the first method on a new channel that uses the distributed transaction mode, before any methods that publish or consume messages.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

dtx_identifier (type: shortstr): Transaction identifier
The distributed transaction key. This identifies the transaction so that the AMQP server can coordinate with the distributed transaction coordinator.

Net::AMQP::Protocol::Dtx::StartOk

This class implements the class Dtx method StartOk, which is a synchronous method.

This method confirms to the client that the transaction started. Note that if a start fails, the server raises a channel exception.

This class has no fields nor accessors.

Net::AMQP::Protocol::Tunnel::Request

This class implements the class Tunnel method Request, which is an asynchronous method.

This method tunnels a block of binary data, which can be an encoded AMQP method or other data. The binary data is sent as the content for the Tunnel.Request method.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

meta_data (type: table): Meta data for the tunnelled block
This field table holds arbitrary meta-data that the sender needs to pass to the recipient.

Net::AMQP::Protocol::Tunnel::ContentHeader

This class implements the class Tunnel method ContentHeader, which is an asynchronous method.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

headers (type: table)
proxy_name (type: shortstr)
data_name (type: shortstr)
durable (type: octet)
broadcast (type: octet)

Net::AMQP::Protocol::Test::Integer

This class implements the class Test method Integer, which is a synchronous method.

This method tests the peer's capability to correctly marshal integer data.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

integer_1 (type: octet): Octet test value
An octet integer test value.
integer_2 (type: short): Short test value
A short integer test value.
integer_3 (type: long): Long test value
A long integer test value.
integer_4 (type: longlong): Long-long test value
A long long integer test value.
operation (type: octet): Operation to test
The client must execute this operation on the provided integer test fields and return the result.

Net::AMQP::Protocol::Test::IntegerOk

This class implements the class Test method IntegerOk, which is a synchronous method.

This method reports the result of an Integer method.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

result (type: longlong): Result value
The result of the tested operation.

Net::AMQP::Protocol::Test::String

This class implements the class Test method String, which is a synchronous method.

This method tests the peer's capability to correctly marshal string data.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

string_1 (type: shortstr): Short string test value
An short string test value.
string_2 (type: longstr): Long string test value
A long string test value.
operation (type: octet): Operation to test
The client must execute this operation on the provided string test fields and return the result.

Net::AMQP::Protocol::Test::StringOk

This class implements the class Test method StringOk, which is a synchronous method.

This method reports the result of a String method.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

result (type: longstr): Result value
The result of the tested operation.

Net::AMQP::Protocol::Test::Table

This class implements the class Test method Table, which is a synchronous method.

This method tests the peer's capability to correctly marshal field table data.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

table (type: table): Field table of test values
A field table of test values.
integer_op (type: octet): Operation to test on integers
The client must execute this operation on the provided field table integer values and return the result.
string_op (type: octet): Operation to test on strings
The client must execute this operation on the provided field table string values and return the result.

Net::AMQP::Protocol::Test::TableOk

This class implements the class Test method TableOk, which is a synchronous method.

This method reports the result of a Table method.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

integer_result (type: longlong): Integer result value
The result of the tested integer operation.
string_result (type: longstr): String result value
The result of the tested string operation.

Net::AMQP::Protocol::Test::Content

This class implements the class Test method Content, which is a synchronous method.

This method tests the peer's capability to correctly marshal content.

This class has no fields nor accessors.

Net::AMQP::Protocol::Test::ContentOk

This class implements the class Test method ContentOk, which is a synchronous method.

This method reports the result of a Content method. It contains the content checksum and echoes the original content as provided.

Each of the following represents a field in the specification. These are the optional arguments to new() and are also read/write accessors:

content_checksum (type: long): Content hash
The 32-bit checksum of the content, calculated by adding the content into a 32-bit accumulator.