1Net::AMQP::Protocol::v0U_s8e(r3)Contributed Perl DocumenNteatt:i:oAnMQP::Protocol::v0_8(3)
2
6 Net::AMQP::Protocol::v0_8 - AMQP v0.8 (de)serialization and
7 representation
8
10 use Net::AMQP::Protocol::v0_8;
11 ...
13 my @frames = Net::AMQP->parse_raw_frames(\$input);
15 ...
17 my $frame = Net::AMQP::Frame::Method->new(
19 channel => 0,
20 method_frame => Net::AMQP::Protocol::Connection::StartOk->new(
21 client_properties => { ... },
22 mechanism => 'AMQPLAIN',
23 locale => 'en_US',
24 response => {
25 LOGIN => 'guest',
26 PASSWORD => 'guest',
27 },
28 ),
29 );
30 print OUT $frame->to_raw_frame();
32
34 This module implements the frame (de)serialization and representation
35 of the Advanced Message Queue Protocol (http://www.amqp.org/) version
36 0.8.
37 It is to be used in conjunction with client or server software that
39 does the actual TCP/IP communication.
40
42 Net::AMQP::Protocol::Connection::Start
43 This class implements the class Connection method Start, which is a
44 synchronous method.
45 This method starts the connection negotiation process by telling the
47 client the protocol version that the server proposes, along with a list
48 of security mechanisms which the client can use for authentication.
49 Each of the following represents a field in the specification. These
51 are the optional arguments to new() and are also read/write accessors:
52 version_major (type: octet)
54 Protocol major version
55 The protocol major version that the server agrees to use, which
57 cannot be higher than the client's major version.
58 version_minor (type: octet)
60 Protocol major version
61 The protocol minor version that the server agrees to use, which
63 cannot be higher than the client's minor version.
64 server_properties (type: table)
66 Server properties
67 mechanisms (type: longstr)
69 Available security mechanisms
70 A list of the security mechanisms that the server supports,
72 delimited by spaces. Currently ASL supports these mechanisms:
73 PLAIN.
74 locales (type: longstr)
76 Available message locales
77 A list of the message locales that the server supports, delimited
79 by spaces. The locale defines the language in which the server will
80 send reply texts.
81 Net::AMQP::Protocol::Connection::StartOk
83 This class implements the class Connection method StartOk, which is a
84 synchronous method.
85 This method selects a SASL security mechanism. ASL uses SASL (RFC2222)
87 to negotiate authentication and encryption.
88 Each of the following represents a field in the specification. These
90 are the optional arguments to new() and are also read/write accessors:
91 client_properties (type: table)
93 Client properties
94 mechanism (type: shortstr)
96 Selected security mechanism
97 A single security mechanisms selected by the client, which must be
99 one of those specified by the server.
100 response (type: longstr)
102 Security response data
103 A block of opaque data passed to the security mechanism. The
105 contents of this data are defined by the SASL security mechanism.
106 For the PLAIN security mechanism this is defined as a field table
107 holding two fields, LOGIN and PASSWORD.
108 locale (type: shortstr)
110 Selected message locale
111 A single message local selected by the client, which must be one of
113 those specified by the server.
114 Net::AMQP::Protocol::Connection::Secure
116 This class implements the class Connection method Secure, which is a
117 synchronous method.
118 The SASL protocol works by exchanging challenges and responses until
120 both peers have received sufficient information to authenticate each
121 other. This method challenges the client to provide more information.
122 Each of the following represents a field in the specification. These
124 are the optional arguments to new() and are also read/write accessors:
125 challenge (type: longstr)
127 Security challenge data
128 Challenge information, a block of opaque binary data passed to the
130 security mechanism.
131 Net::AMQP::Protocol::Connection::SecureOk
133 This class implements the class Connection method SecureOk, which is a
134 synchronous method.
135 This method attempts to authenticate, passing a block of SASL data for
137 the security mechanism at the server side.
138 Each of the following represents a field in the specification. These
140 are the optional arguments to new() and are also read/write accessors:
141 response (type: longstr)
143 Security response data
144 A block of opaque data passed to the security mechanism. The
146 contents of this data are defined by the SASL security mechanism.
147 Net::AMQP::Protocol::Connection::Tune
149 This class implements the class Connection method Tune, which is a
150 synchronous method.
151 This method proposes a set of connection configuration values to the
153 client. The client can accept and/or adjust these.
154 Each of the following represents a field in the specification. These
156 are the optional arguments to new() and are also read/write accessors:
157 channel_max (type: short)
159 Proposed maximum channels
160 The maximum total number of channels that the server allows per
162 connection. Zero means that the server does not impose a fixed
163 limit, but the number of allowed channels may be limited by
164 available server resources.
165 frame_max (type: long)
167 Proposed maximum frame size
168 The largest frame size that the server proposes for the connection.
170 The client can negotiate a lower value. Zero means that the server
171 does not impose any specific limit but may reject very large frames
172 if it cannot allocate resources for them.
173 heartbeat (type: short)
175 Desired heartbeat delay
176 The delay, in seconds, of the connection heartbeat that the server
178 wants. Zero means the server does not want a heartbeat.
179 Net::AMQP::Protocol::Connection::TuneOk
181 This class implements the class Connection method TuneOk, which is a
182 synchronous method.
183 This method sends the client's connection tuning parameters to the
185 server. Certain fields are negotiated, others provide capability
186 information.
187 Each of the following represents a field in the specification. These
189 are the optional arguments to new() and are also read/write accessors:
190 channel_max (type: short)
192 Negotiated maximum channels
193 The maximum total number of channels that the client will use per
195 connection. May not be higher than the value specified by the
196 server.
197 frame_max (type: long)
199 Negotiated maximum frame size
200 The largest frame size that the client and server will use for the
202 connection. Zero means that the client does not impose any specific
203 limit but may reject very large frames if it cannot allocate
204 resources for them. Note that the frame-max limit applies
205 principally to content frames, where large contents can be broken
206 into frames of arbitrary size.
207 heartbeat (type: short)
209 Desired heartbeat delay
210 The delay, in seconds, of the connection heartbeat that the client
212 wants. Zero means the client does not want a heartbeat.
213 Net::AMQP::Protocol::Connection::Open
215 This class implements the class Connection method Open, which is a
216 synchronous method.
217 This method opens a connection to a virtual host, which is a collection
219 of resources, and acts to separate multiple application domains within
220 a server.
221 Each of the following represents a field in the specification. These
223 are the optional arguments to new() and are also read/write accessors:
224 virtual_host (type: shortstr)
226 Virtual host name
227 The name of the virtual host to work with.
229 capabilities (type: shortstr)
231 Required capabilities
232 The client may specify a number of capability names, delimited by
234 spaces. The server can use this string to how to process the
235 client's connection request.
236 insist (type: bit)
238 Insist on connecting to server
239 In a configuration with multiple load-sharing servers, the server
241 may respond to a Connection.Open method with a Connection.Redirect.
242 The insist option tells the server that the client is insisting on
243 a connection to the specified server.
244 Net::AMQP::Protocol::Connection::OpenOk
246 This class implements the class Connection method OpenOk, which is a
247 synchronous method.
248 This method signals to the client that the connection is ready for use.
250 Each of the following represents a field in the specification. These
252 are the optional arguments to new() and are also read/write accessors:
253 known_hosts (type: shortstr)
255 Net::AMQP::Protocol::Connection::Redirect
257 This class implements the class Connection method Redirect, which is a
258 synchronous method.
259 This method redirects the client to another server, based on the
261 requested virtual host and/or capabilities.
262 Each of the following represents a field in the specification. These
264 are the optional arguments to new() and are also read/write accessors:
265 host (type: shortstr)
267 Server to connect to
268 Specifies the server to connect to. This is an IP address or a DNS
270 name, optionally followed by a colon and a port number. If no port
271 number is specified, the client should use the default port number
272 for the protocol.
273 known_hosts (type: shortstr)
275 Net::AMQP::Protocol::Connection::Close
277 This class implements the class Connection method Close, which is a
278 synchronous method.
279 This method indicates that the sender wants to close the connection.
281 This may be due to internal conditions (e.g. a forced shut-down) or due
282 to an error handling a specific method, i.e. an exception. When a close
283 is due to an exception, the sender provides the class and method id of
284 the method which caused the exception.
285 Each of the following represents a field in the specification. These
287 are the optional arguments to new() and are also read/write accessors:
288 reply_code (type: short)
290 reply_text (type: shortstr)
291 class_id (type: short)
292 Failing method class
293 When the close is provoked by a method exception, this is the class
295 of the method.
296 method_id (type: short)
298 Failing method ID
299 When the close is provoked by a method exception, this is the ID of
301 the method.
302 Net::AMQP::Protocol::Connection::CloseOk
304 This class implements the class Connection method CloseOk, which is a
305 synchronous method.
306 This method confirms a Connection.Close method and tells the recipient
308 that it is safe to release resources for the connection and close the
309 socket.
310 This class has no fields nor accessors.
312 Net::AMQP::Protocol::Channel::Open
314 This class implements the class Channel method Open, which is a
315 synchronous method.
316 This method opens a virtual connection (a channel).
318 Each of the following represents a field in the specification. These
320 are the optional arguments to new() and are also read/write accessors:
321 out_of_band (type: shortstr)
323 Out-of-band settings
324 Configures out-of-band transfers on this channel. The syntax and
326 meaning of this field will be formally defined at a later date.
327 Net::AMQP::Protocol::Channel::OpenOk
329 This class implements the class Channel method OpenOk, which is a
330 synchronous method.
331 This method signals to the client that the channel is ready for use.
333 This class has no fields nor accessors.
335 Net::AMQP::Protocol::Channel::Flow
337 This class implements the class Channel method Flow, which is a
338 synchronous method.
339 This method asks the peer to pause or restart the flow of content data.
341 This is a simple flow-control mechanism that a peer can use to avoid
342 oveflowing its queues or otherwise finding itself receiving more
343 messages than it can process. Note that this method is not intended for
344 window control. The peer that receives a request to stop sending
345 content should finish sending the current content, if any, and then
346 wait until it receives a Flow restart method.
347 Each of the following represents a field in the specification. These
349 are the optional arguments to new() and are also read/write accessors:
350 active (type: bit)
352 Start/stop content frames
353 If 1, the peer starts sending content frames. If 0, the peer stops
355 sending content frames.
356 Net::AMQP::Protocol::Channel::FlowOk
358 This class implements the class Channel method FlowOk, which is an
359 asynchronous method.
360 Confirms to the peer that a flow command was received and processed.
362 Each of the following represents a field in the specification. These
364 are the optional arguments to new() and are also read/write accessors:
365 active (type: bit)
367 Current flow setting
368 Confirms the setting of the processed flow method: 1 means the peer
370 will start sending or continue to send content frames; 0 means it
371 will not.
372 Net::AMQP::Protocol::Channel::Alert
374 This class implements the class Channel method Alert, which is an
375 asynchronous method.
376 This method allows the server to send a non-fatal warning to the
378 client. This is used for methods that are normally asynchronous and
379 thus do not have confirmations, and for which the server may detect
380 errors that need to be reported. Fatal errors are handled as channel or
381 connection exceptions; non-fatal errors are sent through this method.
382 Each of the following represents a field in the specification. These
384 are the optional arguments to new() and are also read/write accessors:
385 reply_code (type: short)
387 reply_text (type: shortstr)
388 details (type: table)
389 Detailed information for warning
390 A set of fields that provide more information about the problem.
392 The meaning of these fields are defined on a per-reply-code basis
393 (TO BE DEFINED).
394 Net::AMQP::Protocol::Channel::Close
396 This class implements the class Channel method Close, which is a
397 synchronous method.
398 This method indicates that the sender wants to close the channel. This
400 may be due to internal conditions (e.g. a forced shut-down) or due to
401 an error handling a specific method, i.e. an exception. When a close is
402 due to an exception, the sender provides the class and method id of the
403 method which caused the exception.
404 Each of the following represents a field in the specification. These
406 are the optional arguments to new() and are also read/write accessors:
407 reply_code (type: short)
409 reply_text (type: shortstr)
410 class_id (type: short)
411 Failing method class
412 When the close is provoked by a method exception, this is the class
414 of the method.
415 method_id (type: short)
417 Failing method ID
418 When the close is provoked by a method exception, this is the ID of
420 the method.
421 Net::AMQP::Protocol::Channel::CloseOk
423 This class implements the class Channel method CloseOk, which is a
424 synchronous method.
425 This method confirms a Channel.Close method and tells the recipient
427 that it is safe to release resources for the channel and close the
428 socket.
429 This class has no fields nor accessors.
431 Net::AMQP::Protocol::Access::Request
433 This class implements the class Access method Request, which is a
434 synchronous method.
435 This method requests an access ticket for an access realm. The server
437 responds by granting the access ticket. If the client does not have
438 access rights to the requested realm this causes a connection
439 exception. Access tickets are a per-channel resource.
440 Each of the following represents a field in the specification. These
442 are the optional arguments to new() and are also read/write accessors:
443 realm (type: shortstr)
445 Name of requested realm
446 exclusive (type: bit)
448 Request exclusive access
449 Request exclusive access to the realm. If the server cannot grant
451 this - because there are other active tickets for the realm - it
452 raises a channel exception.
453 passive (type: bit)
455 Request passive access
456 Request message passive access to the specified access realm.
458 Passive access lets a client get information about resources in the
459 realm but not to make any changes to them.
460 active (type: bit)
462 Request active access
463 Request message active access to the specified access realm.
465 Acvtive access lets a client get create and delete resources in the
466 realm.
467 write (type: bit)
469 Request write access
470 Request write access to the specified access realm. Write access
472 lets a client publish messages to all exchanges in the realm.
473 read (type: bit)
475 Request read access
476 Request read access to the specified access realm. Read access lets
478 a client consume messages from queues in the realm.
479 Net::AMQP::Protocol::Access::RequestOk
481 This class implements the class Access method RequestOk, which is a
482 synchronous method.
483 This method provides the client with an access ticket. The access
485 ticket is valid within the current channel and for the lifespan of the
486 channel.
487 Each of the following represents a field in the specification. These
489 are the optional arguments to new() and are also read/write accessors:
490 ticket (type: short)
492 Net::AMQP::Protocol::Exchange::Declare
494 This class implements the class Exchange method Declare, which is a
495 synchronous method.
496 This method creates an exchange if it does not already exist, and if
498 the exchange exists, verifies that it is of the correct and expected
499 class.
500 Each of the following represents a field in the specification. These
502 are the optional arguments to new() and are also read/write accessors:
503 ticket (type: short)
505 When a client defines a new exchange, this belongs to the access
506 realm of the ticket used. All further work done with that exchange
507 must be done with an access ticket for the same realm.
508 exchange (type: shortstr)
510 type (type: shortstr)
511 Exchange type
512 Each exchange belongs to one of a set of exchange types implemented
514 by the server. The exchange types define the functionality of the
515 exchange - i.e. how messages are routed through it. It is not valid
516 or meaningful to attempt to change the type of an existing
517 exchange.
518 passive (type: bit)
520 Do not create exchange
521 If set, the server will not create the exchange. The client can use
523 this to check whether an exchange exists without modifying the
524 server state.
525 durable (type: bit)
527 Request a durable exchange
528 If set when creating a new exchange, the exchange will be marked as
530 durable. Durable exchanges remain active when a server restarts.
531 Non-durable exchanges (transient exchanges) are purged if/when a
532 server restarts.
533 auto_delete (type: bit)
535 Auto-delete when unused
536 If set, the exchange is deleted when all queues have finished using
538 it.
539 internal (type: bit)
541 Create internal exchange
542 If set, the exchange may not be used directly by publishers, but
544 only when bound to other exchanges. Internal exchanges are used to
545 construct wiring that is not visible to applications.
546 nowait (type: bit)
548 Do not send a reply method
549 If set, the server will not respond to the method. The client
551 should not wait for a reply method. If the server could not
552 complete the method it will raise a channel or connection
553 exception.
554 arguments (type: table)
556 Arguments for declaration
557 A set of arguments for the declaration. The syntax and semantics of
559 these arguments depends on the server implementation. This field is
560 ignored if passive is 1.
561 Net::AMQP::Protocol::Exchange::DeclareOk
563 This class implements the class Exchange method DeclareOk, which is a
564 synchronous method.
565 This method confirms a Declare method and confirms the name of the
567 exchange, essential for automatically-named exchanges.
568 This class has no fields nor accessors.
570 Net::AMQP::Protocol::Exchange::Delete
572 This class implements the class Exchange method Delete, which is a
573 synchronous method.
574 This method deletes an exchange. When an exchange is deleted all queue
576 bindings on the exchange are cancelled.
577 Each of the following represents a field in the specification. These
579 are the optional arguments to new() and are also read/write accessors:
580 ticket (type: short)
582 exchange (type: shortstr)
583 if_unused (type: bit)
584 Delete only if unused
585 If set, the server will only delete the exchange if it has no queue
587 bindings. If the exchange has queue bindings the server does not
588 delete it but raises a channel exception instead.
589 nowait (type: bit)
591 Do not send a reply method
592 If set, the server will not respond to the method. The client
594 should not wait for a reply method. If the server could not
595 complete the method it will raise a channel or connection
596 exception.
597 Net::AMQP::Protocol::Exchange::DeleteOk
599 This class implements the class Exchange method DeleteOk, which is a
600 synchronous method.
601 This method confirms the deletion of an exchange.
603 This class has no fields nor accessors.
605 Net::AMQP::Protocol::Queue::Declare
607 This class implements the class Queue method Declare, which is a
608 synchronous method.
609 This method creates or checks a queue. When creating a new queue the
611 client can specify various properties that control the durability of
612 the queue and its contents, and the level of sharing for the queue.
613 Each of the following represents a field in the specification. These
615 are the optional arguments to new() and are also read/write accessors:
616 ticket (type: short)
618 When a client defines a new queue, this belongs to the access realm
619 of the ticket used. All further work done with that queue must be
620 done with an access ticket for the same realm.
621 The client provides a valid access ticket giving "active" access to
623 the realm in which the queue exists or will be created, or
624 "passive" access if the if-exists flag is set.
625 queue (type: shortstr)
627 passive (type: bit)
628 Do not create queue
629 If set, the server will not create the queue. The client can use
631 this to check whether a queue exists without modifying the server
632 state.
633 durable (type: bit)
635 Request a durable queue
636 If set when creating a new queue, the queue will be marked as
638 durable. Durable queues remain active when a server restarts. Non-
639 durable queues (transient queues) are purged if/when a server
640 restarts. Note that durable queues do not necessarily hold
641 persistent messages, although it does not make sense to send
642 persistent messages to a transient queue.
643 exclusive (type: bit)
645 Request an exclusive queue
646 Exclusive queues may only be consumed from by the current
648 connection. Setting the 'exclusive' flag always implies
649 'auto-delete'.
650 auto_delete (type: bit)
652 Auto-delete queue when unused
653 If set, the queue is deleted when all consumers have finished using
655 it. Last consumer can be cancelled either explicitly or because its
656 channel is closed. If there was no consumer ever on the queue, it
657 won't be deleted.
658 nowait (type: bit)
660 Do not send a reply method
661 If set, the server will not respond to the method. The client
663 should not wait for a reply method. If the server could not
664 complete the method it will raise a channel or connection
665 exception.
666 arguments (type: table)
668 Arguments for declaration
669 A set of arguments for the declaration. The syntax and semantics of
671 these arguments depends on the server implementation. This field is
672 ignored if passive is 1.
673 Net::AMQP::Protocol::Queue::DeclareOk
675 This class implements the class Queue method DeclareOk, which is a
676 synchronous method.
677 This method confirms a Declare method and confirms the name of the
679 queue, essential for automatically-named queues.
680 Each of the following represents a field in the specification. These
682 are the optional arguments to new() and are also read/write accessors:
683 queue (type: shortstr)
685 Reports the name of the queue. If the server generated a queue
686 name, this field contains that name.
687 message_count (type: long)
689 Number of messages in queue
690 Reports the number of messages in the queue, which will be zero for
692 newly-created queues.
693 consumer_count (type: long)
695 Number of consumers
696 Reports the number of active consumers for the queue. Note that
698 consumers can suspend activity (Channel.Flow) in which case they do
699 not appear in this count.
700 Net::AMQP::Protocol::Queue::Bind
702 This class implements the class Queue method Bind, which is a
703 synchronous method.
704 This method binds a queue to an exchange. Until a queue is bound it
706 will not receive any messages. In a classic messaging model, store-and-
707 forward queues are bound to a dest exchange and subscription queues are
708 bound to a dest_wild exchange.
709 Each of the following represents a field in the specification. These
711 are the optional arguments to new() and are also read/write accessors:
712 ticket (type: short)
714 The client provides a valid access ticket giving "active" access
715 rights to the queue's access realm.
716 queue (type: shortstr)
718 Specifies the name of the queue to bind. If the queue name is
719 empty, refers to the current queue for the channel, which is the
720 last declared queue.
721 exchange (type: shortstr)
723 The name of the exchange to bind to.
724 routing_key (type: shortstr)
726 Message routing key
727 Specifies the routing key for the binding. The routing key is used
729 for routing messages depending on the exchange configuration. Not
730 all exchanges use a routing key - refer to the specific exchange
731 documentation. If the routing key is empty and the queue name is
732 empty, the routing key will be the current queue for the channel,
733 which is the last declared queue.
734 nowait (type: bit)
736 Do not send a reply method
737 If set, the server will not respond to the method. The client
739 should not wait for a reply method. If the server could not
740 complete the method it will raise a channel or connection
741 exception.
742 arguments (type: table)
744 Arguments for binding
745 A set of arguments for the binding. The syntax and semantics of
747 these arguments depends on the exchange class.
748 Net::AMQP::Protocol::Queue::BindOk
750 This class implements the class Queue method BindOk, which is a
751 synchronous method.
752 This method confirms that the bind was successful.
754 This class has no fields nor accessors.
756 Net::AMQP::Protocol::Queue::Purge
758 This class implements the class Queue method Purge, which is a
759 synchronous method.
760 This method removes all messages from a queue. It does not cancel
762 consumers. Purged messages are deleted without any formal "undo"
763 mechanism.
764 Each of the following represents a field in the specification. These
766 are the optional arguments to new() and are also read/write accessors:
767 ticket (type: short)
769 The access ticket must be for the access realm that holds the
770 queue.
771 queue (type: shortstr)
773 Specifies the name of the queue to purge. If the queue name is
774 empty, refers to the current queue for the channel, which is the
775 last declared queue.
776 nowait (type: bit)
778 Do not send a reply method
779 If set, the server will not respond to the method. The client
781 should not wait for a reply method. If the server could not
782 complete the method it will raise a channel or connection
783 exception.
784 Net::AMQP::Protocol::Queue::PurgeOk
786 This class implements the class Queue method PurgeOk, which is a
787 synchronous method.
788 This method confirms the purge of a queue.
790 Each of the following represents a field in the specification. These
792 are the optional arguments to new() and are also read/write accessors:
793 message_count (type: long)
795 Number of messages purged
796 Reports the number of messages purged.
798 Net::AMQP::Protocol::Queue::Delete
800 This class implements the class Queue method Delete, which is a
801 synchronous method.
802 This method deletes a queue. When a queue is deleted any pending
804 messages are sent to a dead-letter queue if this is defined in the
805 server configuration, and all consumers on the queue are cancelled.
806 Each of the following represents a field in the specification. These
808 are the optional arguments to new() and are also read/write accessors:
809 ticket (type: short)
811 The client provides a valid access ticket giving "active" access
812 rights to the queue's access realm.
813 queue (type: shortstr)
815 Specifies the name of the queue to delete. If the queue name is
816 empty, refers to the current queue for the channel, which is the
817 last declared queue.
818 if_unused (type: bit)
820 Delete only if unused
821 If set, the server will only delete the queue if it has no
823 consumers. If the queue has consumers the server does does not
824 delete it but raises a channel exception instead.
825 if_empty (type: bit)
827 Delete only if empty
828 If set, the server will only delete the queue if it has no
830 messages. If the queue is not empty the server raises a channel
831 exception.
832 nowait (type: bit)
834 Do not send a reply method
835 If set, the server will not respond to the method. The client
837 should not wait for a reply method. If the server could not
838 complete the method it will raise a channel or connection
839 exception.
840 Net::AMQP::Protocol::Queue::DeleteOk
842 This class implements the class Queue method DeleteOk, which is a
843 synchronous method.
844 This method confirms the deletion of a queue.
846 Each of the following represents a field in the specification. These
848 are the optional arguments to new() and are also read/write accessors:
849 message_count (type: long)
851 Number of messages purged
852 Reports the number of messages purged.
854 Net::AMQP::Protocol::Basic::Qos
856 This class implements the class Basic method Qos, which is a
857 synchronous method.
858 This method requests a specific quality of service. The QoS can be
860 specified for the current channel or for all channels on the
861 connection. The particular properties and semantics of a qos method
862 always depend on the content class semantics. Though the qos method
863 could in principle apply to both peers, it is currently meaningful only
864 for the server.
865 Each of the following represents a field in the specification. These
867 are the optional arguments to new() and are also read/write accessors:
868 prefetch_size (type: long)
870 Prefetch window in octets
871 The client can request that messages be sent in advance so that
873 when the client finishes processing a message, the following
874 message is already held locally, rather than needing to be sent
875 down the channel. Prefetching gives a performance improvement. This
876 field specifies the prefetch window size in octets. The server will
877 send a message in advance if it is equal to or smaller in size than
878 the available prefetch size (and also falls into other prefetch
879 limits). May be set to zero, meaning "no specific limit", although
880 other prefetch limits may still apply. The prefetch-size is ignored
881 if the no-ack option is set.
882 prefetch_count (type: short)
884 Prefetch window in messages
885 Specifies a prefetch window in terms of whole messages. This field
887 may be used in combination with the prefetch-size field; a message
888 will only be sent in advance if both prefetch windows (and those at
889 the channel and connection level) allow it. The prefetch-count is
890 ignored if the no-ack option is set.
891 global (type: bit)
893 Apply to entire connection
894 By default the QoS settings apply to the current channel only. If
896 this field is set, they are applied to the entire connection.
897 Net::AMQP::Protocol::Basic::QosOk
899 This class implements the class Basic method QosOk, which is a
900 synchronous method.
901 This method tells the client that the requested QoS levels could be
903 handled by the server. The requested QoS applies to all active
904 consumers until a new QoS is defined.
905 This class has no fields nor accessors.
907 Net::AMQP::Protocol::Basic::Consume
909 This class implements the class Basic method Consume, which is a
910 synchronous method.
911 This method asks the server to start a "consumer", which is a transient
913 request for messages from a specific queue. Consumers last as long as
914 the channel they were created on, or until the client cancels them.
915 Each of the following represents a field in the specification. These
917 are the optional arguments to new() and are also read/write accessors:
918 ticket (type: short)
920 queue (type: shortstr)
921 Specifies the name of the queue to consume from. If the queue name
922 is null, refers to the current queue for the channel, which is the
923 last declared queue.
924 consumer_tag (type: shortstr)
926 Specifies the identifier for the consumer. The consumer tag is
927 local to a connection, so two clients can use the same consumer
928 tags. If this field is empty the server will generate a unique tag.
929 no_local (type: bit)
931 no_ack (type: bit)
932 exclusive (type: bit)
933 Request exclusive access
934 Request exclusive consumer access, meaning only this consumer can
936 access the queue.
937 nowait (type: bit)
939 Do not send a reply method
940 If set, the server will not respond to the method. The client
942 should not wait for a reply method. If the server could not
943 complete the method it will raise a channel or connection
944 exception.
945 Net::AMQP::Protocol::Basic::ConsumeOk
947 This class implements the class Basic method ConsumeOk, which is a
948 synchronous method.
949 The server provides the client with a consumer tag, which is used by
951 the client for methods called on the consumer at a later stage.
952 Each of the following represents a field in the specification. These
954 are the optional arguments to new() and are also read/write accessors:
955 consumer_tag (type: shortstr)
957 Holds the consumer tag specified by the client or provided by the
958 server.
959 Net::AMQP::Protocol::Basic::Cancel
961 This class implements the class Basic method Cancel, which is a
962 synchronous method.
963 This method cancels a consumer. This does not affect already delivered
965 messages, but it does mean the server will not send any more messages
966 for that consumer. The client may receive an abitrary number of
967 messages in between sending the cancel method and receiving the cancel-
968 ok reply.
969 Each of the following represents a field in the specification. These
971 are the optional arguments to new() and are also read/write accessors:
972 consumer_tag (type: shortstr)
974 nowait (type: bit)
975 Do not send a reply method
976 If set, the server will not respond to the method. The client
978 should not wait for a reply method. If the server could not
979 complete the method it will raise a channel or connection
980 exception.
981 Net::AMQP::Protocol::Basic::CancelOk
983 This class implements the class Basic method CancelOk, which is a
984 synchronous method.
985 This method confirms that the cancellation was completed.
987 Each of the following represents a field in the specification. These
989 are the optional arguments to new() and are also read/write accessors:
990 consumer_tag (type: shortstr)
992 Net::AMQP::Protocol::Basic::Publish
994 This class implements the class Basic method Publish, which is an
995 asynchronous method.
996 This method publishes a message to a specific exchange. The message
998 will be routed to queues as defined by the exchange configuration and
999 distributed to any active consumers when the transaction, if any, is
1000 committed.
1001 Each of the following represents a field in the specification. These
1003 are the optional arguments to new() and are also read/write accessors:
1004 ticket (type: short)
1006 exchange (type: shortstr)
1007 Specifies the name of the exchange to publish to. The exchange name
1008 can be empty, meaning the default exchange. If the exchange name is
1009 specified, and that exchange does not exist, the server will raise
1010 a channel exception.
1011 routing_key (type: shortstr)
1013 Message routing key
1014 Specifies the routing key for the message. The routing key is used
1016 for routing messages depending on the exchange configuration.
1017 mandatory (type: bit)
1019 Indicate mandatory routing
1020 This flag tells the server how to react if the message cannot be
1022 routed to a queue. If this flag is set, the server will return an
1023 unroutable message with a Return method. If this flag is zero, the
1024 server silently drops the message.
1025 immediate (type: bit)
1027 Request immediate delivery
1028 This flag tells the server how to react if the message cannot be
1030 routed to a queue consumer immediately. If this flag is set, the
1031 server will return an undeliverable message with a Return method.
1032 If this flag is zero, the server will queue the message, but with
1033 no guarantee that it will ever be consumed.
1034 Net::AMQP::Protocol::Basic::Return
1036 This class implements the class Basic method Return, which is an
1037 asynchronous method.
1038 This method returns an undeliverable message that was published with
1040 the "immediate" flag set, or an unroutable message published with the
1041 "mandatory" flag set. The reply code and text provide information about
1042 the reason that the message was undeliverable.
1043 Each of the following represents a field in the specification. These
1045 are the optional arguments to new() and are also read/write accessors:
1046 reply_code (type: short)
1048 reply_text (type: shortstr)
1049 exchange (type: shortstr)
1050 Specifies the name of the exchange that the message was originally
1051 published to.
1052 routing_key (type: shortstr)
1054 Message routing key
1055 Specifies the routing key name specified when the message was
1057 published.
1058 Net::AMQP::Protocol::Basic::Deliver
1060 This class implements the class Basic method Deliver, which is an
1061 asynchronous method.
1062 This method delivers a message to the client, via a consumer. In the
1064 asynchronous message delivery model, the client starts a consumer using
1065 the Consume method, then the server responds with Deliver methods as
1066 and when messages arrive for that consumer.
1067 Each of the following represents a field in the specification. These
1069 are the optional arguments to new() and are also read/write accessors:
1070 consumer_tag (type: shortstr)
1072 delivery_tag (type: longlong)
1073 redelivered (type: bit)
1074 exchange (type: shortstr)
1075 Specifies the name of the exchange that the message was originally
1076 published to.
1077 routing_key (type: shortstr)
1079 Message routing key
1080 Specifies the routing key name specified when the message was
1082 published.
1083 Net::AMQP::Protocol::Basic::Get
1085 This class implements the class Basic method Get, which is a
1086 synchronous method.
1087 This method provides a direct access to the messages in a queue using a
1089 synchronous dialogue that is designed for specific types of application
1090 where synchronous functionality is more important than performance.
1091 Each of the following represents a field in the specification. These
1093 are the optional arguments to new() and are also read/write accessors:
1094 ticket (type: short)
1096 queue (type: shortstr)
1097 Specifies the name of the queue to consume from. If the queue name
1098 is null, refers to the current queue for the channel, which is the
1099 last declared queue.
1100 no_ack (type: bit)
1102 Net::AMQP::Protocol::Basic::GetOk
1104 This class implements the class Basic method GetOk, which is a
1105 synchronous method.
1106 This method delivers a message to the client following a get method. A
1108 message delivered by 'get-ok' must be acknowledged unless the no-ack
1109 option was set in the get method.
1110 Each of the following represents a field in the specification. These
1112 are the optional arguments to new() and are also read/write accessors:
1113 delivery_tag (type: longlong)
1115 redelivered (type: bit)
1116 exchange (type: shortstr)
1117 Specifies the name of the exchange that the message was originally
1118 published to. If empty, the message was published to the default
1119 exchange.
1120 routing_key (type: shortstr)
1122 Message routing key
1123 Specifies the routing key name specified when the message was
1125 published.
1126 message_count (type: long)
1128 Number of messages pending
1129 This field reports the number of messages pending on the queue,
1131 excluding the message being delivered. Note that this figure is
1132 indicative, not reliable, and can change arbitrarily as messages
1133 are added to the queue and removed by other clients.
1134 Net::AMQP::Protocol::Basic::GetEmpty
1136 This class implements the class Basic method GetEmpty, which is a
1137 synchronous method.
1138 This method tells the client that the queue has no messages available
1140 for the client.
1141 Each of the following represents a field in the specification. These
1143 are the optional arguments to new() and are also read/write accessors:
1144 cluster_id (type: shortstr)
1146 Cluster id
1147 For use by cluster applications, should not be used by client
1149 applications.
1150 Net::AMQP::Protocol::Basic::Ack
1152 This class implements the class Basic method Ack, which is an
1153 asynchronous method.
1154 This method acknowledges one or more messages delivered via the Deliver
1156 or Get-Ok methods. The client can ask to confirm a single message or a
1157 set of messages up to and including a specific message.
1158 Each of the following represents a field in the specification. These
1160 are the optional arguments to new() and are also read/write accessors:
1161 delivery_tag (type: longlong)
1163 multiple (type: bit)
1164 Acknowledge multiple messages
1165 If set to 1, the delivery tag is treated as "up to and including",
1167 so that the client can acknowledge multiple messages with a single
1168 method. If set to zero, the delivery tag refers to a single
1169 message. If the multiple field is 1, and the delivery tag is zero,
1170 tells the server to acknowledge all outstanding mesages.
1171 Net::AMQP::Protocol::Basic::Reject
1173 This class implements the class Basic method Reject, which is an
1174 asynchronous method.
1175 This method allows a client to reject a message. It can be used to
1177 interrupt and cancel large incoming messages, or return untreatable
1178 messages to their original queue.
1179 Each of the following represents a field in the specification. These
1181 are the optional arguments to new() and are also read/write accessors:
1182 delivery_tag (type: longlong)
1184 requeue (type: bit)
1185 Requeue the message
1186 If this field is zero, the message will be discarded. If this bit
1188 is 1, the server will attempt to requeue the message.
1189 Net::AMQP::Protocol::Basic::Recover
1191 This class implements the class Basic method Recover, which is an
1192 asynchronous method.
1193 This method asks the broker to redeliver all unacknowledged messages on
1195 a specifieid channel. Zero or more messages may be redelivered.
1196 Each of the following represents a field in the specification. These
1198 are the optional arguments to new() and are also read/write accessors:
1199 requeue (type: bit)
1201 Requeue the message
1202 If this field is zero, the message will be redelivered to the
1204 original recipient. If this bit is 1, the server will attempt to
1205 requeue the message, potentially then delivering it to an
1206 alternative subscriber.
1207 Net::AMQP::Protocol::Basic::ContentHeader
1209 This class implements the class Basic method ContentHeader, which is an
1210 asynchronous method.
1211 Each of the following represents a field in the specification. These
1213 are the optional arguments to new() and are also read/write accessors:
1214 content_type (type: shortstr)
1216 content_encoding (type: shortstr)
1217 headers (type: table)
1218 delivery_mode (type: octet)
1219 priority (type: octet)
1220 correlation_id (type: shortstr)
1221 reply_to (type: shortstr)
1222 expiration (type: shortstr)
1223 message_id (type: shortstr)
1224 timestamp (type: timestamp)
1225 type (type: shortstr)
1226 user_id (type: shortstr)
1227 app_id (type: shortstr)
1228 cluster_id (type: shortstr)
1229 Net::AMQP::Protocol::File::Qos
1231 This class implements the class File method Qos, which is a synchronous
1232 method.
1233 This method requests a specific quality of service. The QoS can be
1235 specified for the current channel or for all channels on the
1236 connection. The particular properties and semantics of a qos method
1237 always depend on the content class semantics. Though the qos method
1238 could in principle apply to both peers, it is currently meaningful only
1239 for the server.
1240 Each of the following represents a field in the specification. These
1242 are the optional arguments to new() and are also read/write accessors:
1243 prefetch_size (type: long)
1245 Prefetch window in octets
1246 The client can request that messages be sent in advance so that
1248 when the client finishes processing a message, the following
1249 message is already held locally, rather than needing to be sent
1250 down the channel. Prefetching gives a performance improvement. This
1251 field specifies the prefetch window size in octets. May be set to
1252 zero, meaning "no specific limit". Note that other prefetch limits
1253 may still apply. The prefetch-size is ignored if the no-ack option
1254 is set.
1255 prefetch_count (type: short)
1257 Prefetch window in messages
1258 Specifies a prefetch window in terms of whole messages. This is
1260 compatible with some file API implementations. This field may be
1261 used in combination with the prefetch-size field; a message will
1262 only be sent in advance if both prefetch windows (and those at the
1263 channel and connection level) allow it. The prefetch-count is
1264 ignored if the no-ack option is set.
1265 global (type: bit)
1267 Apply to entire connection
1268 By default the QoS settings apply to the current channel only. If
1270 this field is set, they are applied to the entire connection.
1271 Net::AMQP::Protocol::File::QosOk
1273 This class implements the class File method QosOk, which is a
1274 synchronous method.
1275 This method tells the client that the requested QoS levels could be
1277 handled by the server. The requested QoS applies to all active
1278 consumers until a new QoS is defined.
1279 This class has no fields nor accessors.
1281 Net::AMQP::Protocol::File::Consume
1283 This class implements the class File method Consume, which is a
1284 synchronous method.
1285 This method asks the server to start a "consumer", which is a transient
1287 request for messages from a specific queue. Consumers last as long as
1288 the channel they were created on, or until the client cancels them.
1289 Each of the following represents a field in the specification. These
1291 are the optional arguments to new() and are also read/write accessors:
1292 ticket (type: short)
1294 queue (type: shortstr)
1295 Specifies the name of the queue to consume from. If the queue name
1296 is null, refers to the current queue for the channel, which is the
1297 last declared queue.
1298 consumer_tag (type: shortstr)
1300 Specifies the identifier for the consumer. The consumer tag is
1301 local to a connection, so two clients can use the same consumer
1302 tags. If this field is empty the server will generate a unique tag.
1303 no_local (type: bit)
1305 no_ack (type: bit)
1306 exclusive (type: bit)
1307 Request exclusive access
1308 Request exclusive consumer access, meaning only this consumer can
1310 access the queue.
1311 nowait (type: bit)
1313 Do not send a reply method
1314 If set, the server will not respond to the method. The client
1316 should not wait for a reply method. If the server could not
1317 complete the method it will raise a channel or connection
1318 exception.
1319 Net::AMQP::Protocol::File::ConsumeOk
1321 This class implements the class File method ConsumeOk, which is a
1322 synchronous method.
1323 This method provides the client with a consumer tag which it MUST use
1325 in methods that work with the consumer.
1326 Each of the following represents a field in the specification. These
1328 are the optional arguments to new() and are also read/write accessors:
1329 consumer_tag (type: shortstr)
1331 Holds the consumer tag specified by the client or provided by the
1332 server.
1333 Net::AMQP::Protocol::File::Cancel
1335 This class implements the class File method Cancel, which is a
1336 synchronous method.
1337 This method cancels a consumer. This does not affect already delivered
1339 messages, but it does mean the server will not send any more messages
1340 for that consumer.
1341 Each of the following represents a field in the specification. These
1343 are the optional arguments to new() and are also read/write accessors:
1344 consumer_tag (type: shortstr)
1346 nowait (type: bit)
1347 Do not send a reply method
1348 If set, the server will not respond to the method. The client
1350 should not wait for a reply method. If the server could not
1351 complete the method it will raise a channel or connection
1352 exception.
1353 Net::AMQP::Protocol::File::CancelOk
1355 This class implements the class File method CancelOk, which is a
1356 synchronous method.
1357 This method confirms that the cancellation was completed.
1359 Each of the following represents a field in the specification. These
1361 are the optional arguments to new() and are also read/write accessors:
1362 consumer_tag (type: shortstr)
1364 Net::AMQP::Protocol::File::Open
1366 This class implements the class File method Open, which is a
1367 synchronous method.
1368 This method requests permission to start staging a message. Staging
1370 means sending the message into a temporary area at the recipient end
1371 and then delivering the message by referring to this temporary area.
1372 Staging is how the protocol handles partial file transfers - if a
1373 message is partially staged and the connection breaks, the next time
1374 the sender starts to stage it, it can restart from where it left off.
1375 Each of the following represents a field in the specification. These
1377 are the optional arguments to new() and are also read/write accessors:
1378 identifier (type: shortstr)
1380 Staging identifier
1381 This is the staging identifier. This is an arbitrary string chosen
1383 by the sender. For staging to work correctly the sender must use
1384 the same staging identifier when staging the same message a second
1385 time after recovery from a failure. A good choice for the staging
1386 identifier would be the SHA1 hash of the message properties data
1387 (including the original filename, revised time, etc.).
1388 content_size (type: longlong)
1390 Message content size
1391 The size of the content in octets. The recipient may use this
1393 information to allocate or check available space in advance, to
1394 avoid "disk full" errors during staging of very large messages.
1395 Net::AMQP::Protocol::File::OpenOk
1397 This class implements the class File method OpenOk, which is a
1398 synchronous method.
1399 This method confirms that the recipient is ready to accept staged data.
1401 If the message was already partially-staged at a previous time the
1402 recipient will report the number of octets already staged.
1403 Each of the following represents a field in the specification. These
1405 are the optional arguments to new() and are also read/write accessors:
1406 staged_size (type: longlong)
1408 Already staged amount
1409 The amount of previously-staged content in octets. For a new
1411 message this will be zero.
1412 Net::AMQP::Protocol::File::Stage
1414 This class implements the class File method Stage, which is an
1415 asynchronous method.
1416 This method stages the message, sending the message content to the
1418 recipient from the octet offset specified in the Open-Ok method.
1419 This class has no fields nor accessors.
1421 Net::AMQP::Protocol::File::Publish
1423 This class implements the class File method Publish, which is an
1424 asynchronous method.
1425 This method publishes a staged file message to a specific exchange. The
1427 file message will be routed to queues as defined by the exchange
1428 configuration and distributed to any active consumers when the
1429 transaction, if any, is committed.
1430 Each of the following represents a field in the specification. These
1432 are the optional arguments to new() and are also read/write accessors:
1433 ticket (type: short)
1435 exchange (type: shortstr)
1436 Specifies the name of the exchange to publish to. The exchange name
1437 can be empty, meaning the default exchange. If the exchange name is
1438 specified, and that exchange does not exist, the server will raise
1439 a channel exception.
1440 routing_key (type: shortstr)
1442 Message routing key
1443 Specifies the routing key for the message. The routing key is used
1445 for routing messages depending on the exchange configuration.
1446 mandatory (type: bit)
1448 Indicate mandatory routing
1449 This flag tells the server how to react if the message cannot be
1451 routed to a queue. If this flag is set, the server will return an
1452 unroutable message with a Return method. If this flag is zero, the
1453 server silently drops the message.
1454 immediate (type: bit)
1456 Request immediate delivery
1457 This flag tells the server how to react if the message cannot be
1459 routed to a queue consumer immediately. If this flag is set, the
1460 server will return an undeliverable message with a Return method.
1461 If this flag is zero, the server will queue the message, but with
1462 no guarantee that it will ever be consumed.
1463 identifier (type: shortstr)
1465 Staging identifier
1466 This is the staging identifier of the message to publish. The
1468 message must have been staged. Note that a client can send the
1469 Publish method asynchronously without waiting for staging to
1470 finish.
1471 Net::AMQP::Protocol::File::Return
1473 This class implements the class File method Return, which is an
1474 asynchronous method.
1475 This method returns an undeliverable message that was published with
1477 the "immediate" flag set, or an unroutable message published with the
1478 "mandatory" flag set. The reply code and text provide information about
1479 the reason that the message was undeliverable.
1480 Each of the following represents a field in the specification. These
1482 are the optional arguments to new() and are also read/write accessors:
1483 reply_code (type: short)
1485 reply_text (type: shortstr)
1486 exchange (type: shortstr)
1487 Specifies the name of the exchange that the message was originally
1488 published to.
1489 routing_key (type: shortstr)
1491 Message routing key
1492 Specifies the routing key name specified when the message was
1494 published.
1495 Net::AMQP::Protocol::File::Deliver
1497 This class implements the class File method Deliver, which is an
1498 asynchronous method.
1499 This method delivers a staged file message to the client, via a
1501 consumer. In the asynchronous message delivery model, the client starts
1502 a consumer using the Consume method, then the server responds with
1503 Deliver methods as and when messages arrive for that consumer.
1504 Each of the following represents a field in the specification. These
1506 are the optional arguments to new() and are also read/write accessors:
1507 consumer_tag (type: shortstr)
1509 delivery_tag (type: longlong)
1510 redelivered (type: bit)
1511 exchange (type: shortstr)
1512 Specifies the name of the exchange that the message was originally
1513 published to.
1514 routing_key (type: shortstr)
1516 Message routing key
1517 Specifies the routing key name specified when the message was
1519 published.
1520 identifier (type: shortstr)
1522 Staging identifier
1523 This is the staging identifier of the message to deliver. The
1525 message must have been staged. Note that a server can send the
1526 Deliver method asynchronously without waiting for staging to
1527 finish.
1528 Net::AMQP::Protocol::File::Ack
1530 This class implements the class File method Ack, which is an
1531 asynchronous method.
1532 This method acknowledges one or more messages delivered via the Deliver
1534 method. The client can ask to confirm a single message or a set of
1535 messages up to and including a specific message.
1536 Each of the following represents a field in the specification. These
1538 are the optional arguments to new() and are also read/write accessors:
1539 delivery_tag (type: longlong)
1541 multiple (type: bit)
1542 Acknowledge multiple messages
1543 If set to 1, the delivery tag is treated as "up to and including",
1545 so that the client can acknowledge multiple messages with a single
1546 method. If set to zero, the delivery tag refers to a single
1547 message. If the multiple field is 1, and the delivery tag is zero,
1548 tells the server to acknowledge all outstanding mesages.
1549 Net::AMQP::Protocol::File::Reject
1551 This class implements the class File method Reject, which is an
1552 asynchronous method.
1553 This method allows a client to reject a message. It can be used to
1555 return untreatable messages to their original queue. Note that file
1556 content is staged before delivery, so the client will not use this
1557 method to interrupt delivery of a large message.
1558 Each of the following represents a field in the specification. These
1560 are the optional arguments to new() and are also read/write accessors:
1561 delivery_tag (type: longlong)
1563 requeue (type: bit)
1564 Requeue the message
1565 If this field is zero, the message will be discarded. If this bit
1567 is 1, the server will attempt to requeue the message.
1568 Net::AMQP::Protocol::File::ContentHeader
1570 This class implements the class File method ContentHeader, which is an
1571 asynchronous method.
1572 Each of the following represents a field in the specification. These
1574 are the optional arguments to new() and are also read/write accessors:
1575 content_type (type: shortstr)
1577 content_encoding (type: shortstr)
1578 headers (type: table)
1579 priority (type: octet)
1580 reply_to (type: shortstr)
1581 message_id (type: shortstr)
1582 filename (type: shortstr)
1583 timestamp (type: timestamp)
1584 cluster_id (type: shortstr)
1585 Net::AMQP::Protocol::Stream::Qos
1587 This class implements the class Stream method Qos, which is a
1588 synchronous method.
1589 This method requests a specific quality of service. The QoS can be
1591 specified for the current channel or for all channels on the
1592 connection. The particular properties and semantics of a qos method
1593 always depend on the content class semantics. Though the qos method
1594 could in principle apply to both peers, it is currently meaningful only
1595 for the server.
1596 Each of the following represents a field in the specification. These
1598 are the optional arguments to new() and are also read/write accessors:
1599 prefetch_size (type: long)
1601 Prefetch window in octets
1602 The client can request that messages be sent in advance so that
1604 when the client finishes processing a message, the following
1605 message is already held locally, rather than needing to be sent
1606 down the channel. Prefetching gives a performance improvement. This
1607 field specifies the prefetch window size in octets. May be set to
1608 zero, meaning "no specific limit". Note that other prefetch limits
1609 may still apply.
1610 prefetch_count (type: short)
1612 Prefetch window in messages
1613 Specifies a prefetch window in terms of whole messages. This field
1615 may be used in combination with the prefetch-size field; a message
1616 will only be sent in advance if both prefetch windows (and those at
1617 the channel and connection level) allow it.
1618 consume_rate (type: long)
1620 Transfer rate in octets/second
1621 Specifies a desired transfer rate in octets per second. This is
1623 usually determined by the application that uses the streaming data.
1624 A value of zero means "no limit", i.e. as rapidly as possible.
1625 global (type: bit)
1627 Apply to entire connection
1628 By default the QoS settings apply to the current channel only. If
1630 this field is set, they are applied to the entire connection.
1631 Net::AMQP::Protocol::Stream::QosOk
1633 This class implements the class Stream method QosOk, which is a
1634 synchronous method.
1635 This method tells the client that the requested QoS levels could be
1637 handled by the server. The requested QoS applies to all active
1638 consumers until a new QoS is defined.
1639 This class has no fields nor accessors.
1641 Net::AMQP::Protocol::Stream::Consume
1643 This class implements the class Stream method Consume, which is a
1644 synchronous method.
1645 This method asks the server to start a "consumer", which is a transient
1647 request for messages from a specific queue. Consumers last as long as
1648 the channel they were created on, or until the client cancels them.
1649 Each of the following represents a field in the specification. These
1651 are the optional arguments to new() and are also read/write accessors:
1652 ticket (type: short)
1654 queue (type: shortstr)
1655 Specifies the name of the queue to consume from. If the queue name
1656 is null, refers to the current queue for the channel, which is the
1657 last declared queue.
1658 consumer_tag (type: shortstr)
1660 Specifies the identifier for the consumer. The consumer tag is
1661 local to a connection, so two clients can use the same consumer
1662 tags. If this field is empty the server will generate a unique tag.
1663 no_local (type: bit)
1665 exclusive (type: bit)
1666 Request exclusive access
1667 Request exclusive consumer access, meaning only this consumer can
1669 access the queue.
1670 nowait (type: bit)
1672 Do not send a reply method
1673 If set, the server will not respond to the method. The client
1675 should not wait for a reply method. If the server could not
1676 complete the method it will raise a channel or connection
1677 exception.
1678 Net::AMQP::Protocol::Stream::ConsumeOk
1680 This class implements the class Stream method ConsumeOk, which is a
1681 synchronous method.
1682 This method provides the client with a consumer tag which it may use in
1684 methods that work with the consumer.
1685 Each of the following represents a field in the specification. These
1687 are the optional arguments to new() and are also read/write accessors:
1688 consumer_tag (type: shortstr)
1690 Holds the consumer tag specified by the client or provided by the
1691 server.
1692 Net::AMQP::Protocol::Stream::Cancel
1694 This class implements the class Stream method Cancel, which is a
1695 synchronous method.
1696 This method cancels a consumer. Since message delivery is asynchronous
1698 the client may continue to receive messages for a short while after
1699 canceling a consumer. It may process or discard these as appropriate.
1700 Each of the following represents a field in the specification. These
1702 are the optional arguments to new() and are also read/write accessors:
1703 consumer_tag (type: shortstr)
1705 nowait (type: bit)
1706 Do not send a reply method
1707 If set, the server will not respond to the method. The client
1709 should not wait for a reply method. If the server could not
1710 complete the method it will raise a channel or connection
1711 exception.
1712 Net::AMQP::Protocol::Stream::CancelOk
1714 This class implements the class Stream method CancelOk, which is a
1715 synchronous method.
1716 This method confirms that the cancellation was completed.
1718 Each of the following represents a field in the specification. These
1720 are the optional arguments to new() and are also read/write accessors:
1721 consumer_tag (type: shortstr)
1723 Net::AMQP::Protocol::Stream::Publish
1725 This class implements the class Stream method Publish, which is an
1726 asynchronous method.
1727 This method publishes a message to a specific exchange. The message
1729 will be routed to queues as defined by the exchange configuration and
1730 distributed to any active consumers as appropriate.
1731 Each of the following represents a field in the specification. These
1733 are the optional arguments to new() and are also read/write accessors:
1734 ticket (type: short)
1736 exchange (type: shortstr)
1737 Specifies the name of the exchange to publish to. The exchange name
1738 can be empty, meaning the default exchange. If the exchange name is
1739 specified, and that exchange does not exist, the server will raise
1740 a channel exception.
1741 routing_key (type: shortstr)
1743 Message routing key
1744 Specifies the routing key for the message. The routing key is used
1746 for routing messages depending on the exchange configuration.
1747 mandatory (type: bit)
1749 Indicate mandatory routing
1750 This flag tells the server how to react if the message cannot be
1752 routed to a queue. If this flag is set, the server will return an
1753 unroutable message with a Return method. If this flag is zero, the
1754 server silently drops the message.
1755 immediate (type: bit)
1757 Request immediate delivery
1758 This flag tells the server how to react if the message cannot be
1760 routed to a queue consumer immediately. If this flag is set, the
1761 server will return an undeliverable message with a Return method.
1762 If this flag is zero, the server will queue the message, but with
1763 no guarantee that it will ever be consumed.
1764 Net::AMQP::Protocol::Stream::Return
1766 This class implements the class Stream method Return, which is an
1767 asynchronous method.
1768 This method returns an undeliverable message that was published with
1770 the "immediate" flag set, or an unroutable message published with the
1771 "mandatory" flag set. The reply code and text provide information about
1772 the reason that the message was undeliverable.
1773 Each of the following represents a field in the specification. These
1775 are the optional arguments to new() and are also read/write accessors:
1776 reply_code (type: short)
1778 reply_text (type: shortstr)
1779 exchange (type: shortstr)
1780 Specifies the name of the exchange that the message was originally
1781 published to.
1782 routing_key (type: shortstr)
1784 Message routing key
1785 Specifies the routing key name specified when the message was
1787 published.
1788 Net::AMQP::Protocol::Stream::Deliver
1790 This class implements the class Stream method Deliver, which is an
1791 asynchronous method.
1792 This method delivers a message to the client, via a consumer. In the
1794 asynchronous message delivery model, the client starts a consumer using
1795 the Consume method, then the server responds with Deliver methods as
1796 and when messages arrive for that consumer.
1797 Each of the following represents a field in the specification. These
1799 are the optional arguments to new() and are also read/write accessors:
1800 consumer_tag (type: shortstr)
1802 delivery_tag (type: longlong)
1803 exchange (type: shortstr)
1804 Specifies the name of the exchange that the message was originally
1805 published to.
1806 queue (type: shortstr)
1808 Specifies the name of the queue that the message came from. Note
1809 that a single channel can start many consumers on different queues.
1810 Net::AMQP::Protocol::Stream::ContentHeader
1812 This class implements the class Stream method ContentHeader, which is
1813 an asynchronous method.
1814 Each of the following represents a field in the specification. These
1816 are the optional arguments to new() and are also read/write accessors:
1817 content_type (type: shortstr)
1819 content_encoding (type: shortstr)
1820 headers (type: table)
1821 priority (type: octet)
1822 timestamp (type: timestamp)
1823 Net::AMQP::Protocol::Tx::Select
1825 This class implements the class Tx method Select, which is a
1826 synchronous method.
1827 This method sets the channel to use standard transactions. The client
1829 must use this method at least once on a channel before using the Commit
1830 or Rollback methods.
1831 This class has no fields nor accessors.
1833 Net::AMQP::Protocol::Tx::SelectOk
1835 This class implements the class Tx method SelectOk, which is a
1836 synchronous method.
1837 This method confirms to the client that the channel was successfully
1839 set to use standard transactions.
1840 This class has no fields nor accessors.
1842 Net::AMQP::Protocol::Tx::Commit
1844 This class implements the class Tx method Commit, which is a
1845 synchronous method.
1846 This method commits all messages published and acknowledged in the
1848 current transaction. A new transaction starts immediately after a
1849 commit.
1850 This class has no fields nor accessors.
1852 Net::AMQP::Protocol::Tx::CommitOk
1854 This class implements the class Tx method CommitOk, which is a
1855 synchronous method.
1856 This method confirms to the client that the commit succeeded. Note that
1858 if a commit fails, the server raises a channel exception.
1859 This class has no fields nor accessors.
1861 Net::AMQP::Protocol::Tx::Rollback
1863 This class implements the class Tx method Rollback, which is a
1864 synchronous method.
1865 This method abandons all messages published and acknowledged in the
1867 current transaction. A new transaction starts immediately after a
1868 rollback.
1869 This class has no fields nor accessors.
1871 Net::AMQP::Protocol::Tx::RollbackOk
1873 This class implements the class Tx method RollbackOk, which is a
1874 synchronous method.
1875 This method confirms to the client that the rollback succeeded. Note
1877 that if an rollback fails, the server raises a channel exception.
1878 This class has no fields nor accessors.
1880 Net::AMQP::Protocol::Dtx::Select
1882 This class implements the class Dtx method Select, which is a
1883 synchronous method.
1884 This method sets the channel to use distributed transactions. The
1886 client must use this method at least once on a channel before using the
1887 Start method.
1888 This class has no fields nor accessors.
1890 Net::AMQP::Protocol::Dtx::SelectOk
1892 This class implements the class Dtx method SelectOk, which is a
1893 synchronous method.
1894 This method confirms to the client that the channel was successfully
1896 set to use distributed transactions.
1897 This class has no fields nor accessors.
1899 Net::AMQP::Protocol::Dtx::Start
1901 This class implements the class Dtx method Start, which is a
1902 synchronous method.
1903 This method starts a new distributed transaction. This must be the
1905 first method on a new channel that uses the distributed transaction
1906 mode, before any methods that publish or consume messages.
1907 Each of the following represents a field in the specification. These
1909 are the optional arguments to new() and are also read/write accessors:
1910 dtx_identifier (type: shortstr)
1912 Transaction identifier
1913 The distributed transaction key. This identifies the transaction so
1915 that the AMQP server can coordinate with the distributed
1916 transaction coordinator.
1917 Net::AMQP::Protocol::Dtx::StartOk
1919 This class implements the class Dtx method StartOk, which is a
1920 synchronous method.
1921 This method confirms to the client that the transaction started. Note
1923 that if a start fails, the server raises a channel exception.
1924 This class has no fields nor accessors.
1926 Net::AMQP::Protocol::Tunnel::Request
1928 This class implements the class Tunnel method Request, which is an
1929 asynchronous method.
1930 This method tunnels a block of binary data, which can be an encoded
1932 AMQP method or other data. The binary data is sent as the content for
1933 the Tunnel.Request method.
1934 Each of the following represents a field in the specification. These
1936 are the optional arguments to new() and are also read/write accessors:
1937 meta_data (type: table)
1939 Meta data for the tunnelled block
1940 This field table holds arbitrary meta-data that the sender needs to
1942 pass to the recipient.
1943 Net::AMQP::Protocol::Tunnel::ContentHeader
1945 This class implements the class Tunnel method ContentHeader, which is
1946 an asynchronous method.
1947 Each of the following represents a field in the specification. These
1949 are the optional arguments to new() and are also read/write accessors:
1950 headers (type: table)
1952 proxy_name (type: shortstr)
1953 data_name (type: shortstr)
1954 durable (type: octet)
1955 broadcast (type: octet)
1956 Net::AMQP::Protocol::Test::Integer
1958 This class implements the class Test method Integer, which is a
1959 synchronous method.
1960 This method tests the peer's capability to correctly marshal integer
1962 data.
1963 Each of the following represents a field in the specification. These
1965 are the optional arguments to new() and are also read/write accessors:
1966 integer_1 (type: octet)
1968 Octet test value
1969 An octet integer test value.
1971 integer_2 (type: short)
1973 Short test value
1974 A short integer test value.
1976 integer_3 (type: long)
1978 Long test value
1979 A long integer test value.
1981 integer_4 (type: longlong)
1983 Long-long test value
1984 A long long integer test value.
1986 operation (type: octet)
1988 Operation to test
1989 The client must execute this operation on the provided integer test
1991 fields and return the result.
1992 Net::AMQP::Protocol::Test::IntegerOk
1994 This class implements the class Test method IntegerOk, which is a
1995 synchronous method.
1996 This method reports the result of an Integer method.
1998 Each of the following represents a field in the specification. These
2000 are the optional arguments to new() and are also read/write accessors:
2001 result (type: longlong)
2003 Result value
2004 The result of the tested operation.
2006 Net::AMQP::Protocol::Test::String
2008 This class implements the class Test method String, which is a
2009 synchronous method.
2010 This method tests the peer's capability to correctly marshal string
2012 data.
2013 Each of the following represents a field in the specification. These
2015 are the optional arguments to new() and are also read/write accessors:
2016 string_1 (type: shortstr)
2018 Short string test value
2019 An short string test value.
2021 string_2 (type: longstr)
2023 Long string test value
2024 A long string test value.
2026 operation (type: octet)
2028 Operation to test
2029 The client must execute this operation on the provided string test
2031 fields and return the result.
2032 Net::AMQP::Protocol::Test::StringOk
2034 This class implements the class Test method StringOk, which is a
2035 synchronous method.
2036 This method reports the result of a String method.
2038 Each of the following represents a field in the specification. These
2040 are the optional arguments to new() and are also read/write accessors:
2041 result (type: longstr)
2043 Result value
2044 The result of the tested operation.
2046 Net::AMQP::Protocol::Test::Table
2048 This class implements the class Test method Table, which is a
2049 synchronous method.
2050 This method tests the peer's capability to correctly marshal field
2052 table data.
2053 Each of the following represents a field in the specification. These
2055 are the optional arguments to new() and are also read/write accessors:
2056 table (type: table)
2058 Field table of test values
2059 A field table of test values.
2061 integer_op (type: octet)
2063 Operation to test on integers
2064 The client must execute this operation on the provided field table
2066 integer values and return the result.
2067 string_op (type: octet)
2069 Operation to test on strings
2070 The client must execute this operation on the provided field table
2072 string values and return the result.
2073 Net::AMQP::Protocol::Test::TableOk
2075 This class implements the class Test method TableOk, which is a
2076 synchronous method.
2077 This method reports the result of a Table method.
2079 Each of the following represents a field in the specification. These
2081 are the optional arguments to new() and are also read/write accessors:
2082 integer_result (type: longlong)
2084 Integer result value
2085 The result of the tested integer operation.
2087 string_result (type: longstr)
2089 String result value
2090 The result of the tested string operation.
2092 Net::AMQP::Protocol::Test::Content
2094 This class implements the class Test method Content, which is a
2095 synchronous method.
2096 This method tests the peer's capability to correctly marshal content.
2098 This class has no fields nor accessors.
2100 Net::AMQP::Protocol::Test::ContentOk
2102 This class implements the class Test method ContentOk, which is a
2103 synchronous method.
2104 This method reports the result of a Content method. It contains the
2106 content checksum and echoes the original content as provided.
2107 Each of the following represents a field in the specification. These
2109 are the optional arguments to new() and are also read/write accessors:
2110 content_checksum (type: long)
2112 Content hash
2113 The 32-bit checksum of the content, calculated by adding the
2115 content into a 32-bit accumulator.
2116perl v5.30.1 2020-01-30 Net::AMQP::Protocol::v0_8(3)