1Net::AMQP::Protocol::v0U_s8e(r3)Contributed Perl DocumenNteatt:i:oAnMQP::Protocol::v0_8(3)
2
3
4

NAME

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

SYNOPSIS

10         use Net::AMQP::Protocol::v0_8;
11
12         ...
13
14         my @frames = Net::AMQP->parse_raw_frames(\$input);
15
16         ...
17
18         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
31         print OUT $frame->to_raw_frame();
32

DESCRIPTION

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
38       It is to be used in conjunction with client or server software that
39       does the actual TCP/IP communication.
40

PROTOCOL CLASSES

42   Net::AMQP::Protocol::Connection::Start
43       This class implements the class Connection method Start, which is a
44       synchronous method.
45
46       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
50       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
53       version_major (type: octet)
54           Protocol major version
55
56           The protocol major version that the server agrees to use, which
57           cannot be higher than the client's major version.
58
59       version_minor (type: octet)
60           Protocol major version
61
62           The protocol minor version that the server agrees to use, which
63           cannot be higher than the client's minor version.
64
65       server_properties (type: table)
66           Server properties
67
68       mechanisms (type: longstr)
69           Available security mechanisms
70
71           A list of the security mechanisms that the server supports,
72           delimited by spaces. Currently ASL supports these mechanisms:
73           PLAIN.
74
75       locales (type: longstr)
76           Available message locales
77
78           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
82   Net::AMQP::Protocol::Connection::StartOk
83       This class implements the class Connection method StartOk, which is a
84       synchronous method.
85
86       This method selects a SASL security mechanism. ASL uses SASL (RFC2222)
87       to negotiate authentication and encryption.
88
89       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
92       client_properties (type: table)
93           Client properties
94
95       mechanism (type: shortstr)
96           Selected security mechanism
97
98           A single security mechanisms selected by the client, which must be
99           one of those specified by the server.
100
101       response (type: longstr)
102           Security response data
103
104           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
109       locale (type: shortstr)
110           Selected message locale
111
112           A single message local selected by the client, which must be one of
113           those specified by the server.
114
115   Net::AMQP::Protocol::Connection::Secure
116       This class implements the class Connection method Secure, which is a
117       synchronous method.
118
119       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
123       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
126       challenge (type: longstr)
127           Security challenge data
128
129           Challenge information, a block of opaque binary data passed to the
130           security mechanism.
131
132   Net::AMQP::Protocol::Connection::SecureOk
133       This class implements the class Connection method SecureOk, which is a
134       synchronous method.
135
136       This method attempts to authenticate, passing a block of SASL data for
137       the security mechanism at the server side.
138
139       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
142       response (type: longstr)
143           Security response data
144
145           A block of opaque data passed to the security mechanism. The
146           contents of this data are defined by the SASL security mechanism.
147
148   Net::AMQP::Protocol::Connection::Tune
149       This class implements the class Connection method Tune, which is a
150       synchronous method.
151
152       This method proposes a set of connection configuration values to the
153       client. The client can accept and/or adjust these.
154
155       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
158       channel_max (type: short)
159           Proposed maximum channels
160
161           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
166       frame_max (type: long)
167           Proposed maximum frame size
168
169           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
174       heartbeat (type: short)
175           Desired heartbeat delay
176
177           The delay, in seconds, of the connection heartbeat that the server
178           wants. Zero means the server does not want a heartbeat.
179
180   Net::AMQP::Protocol::Connection::TuneOk
181       This class implements the class Connection method TuneOk, which is a
182       synchronous method.
183
184       This method sends the client's connection tuning parameters to the
185       server. Certain fields are negotiated, others provide capability
186       information.
187
188       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
191       channel_max (type: short)
192           Negotiated maximum channels
193
194           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
198       frame_max (type: long)
199           Negotiated maximum frame size
200
201           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
208       heartbeat (type: short)
209           Desired heartbeat delay
210
211           The delay, in seconds, of the connection heartbeat that the client
212           wants. Zero means the client does not want a heartbeat.
213
214   Net::AMQP::Protocol::Connection::Open
215       This class implements the class Connection method Open, which is a
216       synchronous method.
217
218       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
222       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
225       virtual_host (type: shortstr)
226           Virtual host name
227
228           The name of the virtual host to work with.
229
230       capabilities (type: shortstr)
231           Required capabilities
232
233           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
237       insist (type: bit)
238           Insist on connecting to server
239
240           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
245   Net::AMQP::Protocol::Connection::OpenOk
246       This class implements the class Connection method OpenOk, which is a
247       synchronous method.
248
249       This method signals to the client that the connection is ready for use.
250
251       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
254       known_hosts (type: shortstr)
255
256   Net::AMQP::Protocol::Connection::Redirect
257       This class implements the class Connection method Redirect, which is a
258       synchronous method.
259
260       This method redirects the client to another server, based on the
261       requested virtual host and/or capabilities.
262
263       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
266       host (type: shortstr)
267           Server to connect to
268
269           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
274       known_hosts (type: shortstr)
275
276   Net::AMQP::Protocol::Connection::Close
277       This class implements the class Connection method Close, which is a
278       synchronous method.
279
280       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
286       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
289       reply_code (type: short)
290       reply_text (type: shortstr)
291       class_id (type: short)
292           Failing method class
293
294           When the close is provoked by a method exception, this is the class
295           of the method.
296
297       method_id (type: short)
298           Failing method ID
299
300           When the close is provoked by a method exception, this is the ID of
301           the method.
302
303   Net::AMQP::Protocol::Connection::CloseOk
304       This class implements the class Connection method CloseOk, which is a
305       synchronous method.
306
307       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
311       This class has no fields nor accessors.
312
313   Net::AMQP::Protocol::Channel::Open
314       This class implements the class Channel method Open, which is a
315       synchronous method.
316
317       This method opens a virtual connection (a channel).
318
319       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
322       out_of_band (type: shortstr)
323           Out-of-band settings
324
325           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
328   Net::AMQP::Protocol::Channel::OpenOk
329       This class implements the class Channel method OpenOk, which is a
330       synchronous method.
331
332       This method signals to the client that the channel is ready for use.
333
334       This class has no fields nor accessors.
335
336   Net::AMQP::Protocol::Channel::Flow
337       This class implements the class Channel method Flow, which is a
338       synchronous method.
339
340       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
348       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
351       active (type: bit)
352           Start/stop content frames
353
354           If 1, the peer starts sending content frames. If 0, the peer stops
355           sending content frames.
356
357   Net::AMQP::Protocol::Channel::FlowOk
358       This class implements the class Channel method FlowOk, which is an
359       asynchronous method.
360
361       Confirms to the peer that a flow command was received and processed.
362
363       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
366       active (type: bit)
367           Current flow setting
368
369           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
373   Net::AMQP::Protocol::Channel::Alert
374       This class implements the class Channel method Alert, which is an
375       asynchronous method.
376
377       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
383       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
386       reply_code (type: short)
387       reply_text (type: shortstr)
388       details (type: table)
389           Detailed information for warning
390
391           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
395   Net::AMQP::Protocol::Channel::Close
396       This class implements the class Channel method Close, which is a
397       synchronous method.
398
399       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
405       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
408       reply_code (type: short)
409       reply_text (type: shortstr)
410       class_id (type: short)
411           Failing method class
412
413           When the close is provoked by a method exception, this is the class
414           of the method.
415
416       method_id (type: short)
417           Failing method ID
418
419           When the close is provoked by a method exception, this is the ID of
420           the method.
421
422   Net::AMQP::Protocol::Channel::CloseOk
423       This class implements the class Channel method CloseOk, which is a
424       synchronous method.
425
426       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
430       This class has no fields nor accessors.
431
432   Net::AMQP::Protocol::Access::Request
433       This class implements the class Access method Request, which is a
434       synchronous method.
435
436       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
441       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
444       realm (type: shortstr)
445           Name of requested realm
446
447       exclusive (type: bit)
448           Request exclusive access
449
450           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
454       passive (type: bit)
455           Request passive access
456
457           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
461       active (type: bit)
462           Request active access
463
464           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
468       write (type: bit)
469           Request write access
470
471           Request write access to the specified access realm. Write access
472           lets a client publish messages to all exchanges in the realm.
473
474       read (type: bit)
475           Request read access
476
477           Request read access to the specified access realm. Read access lets
478           a client consume messages from queues in the realm.
479
480   Net::AMQP::Protocol::Access::RequestOk
481       This class implements the class Access method RequestOk, which is a
482       synchronous method.
483
484       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
488       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
491       ticket (type: short)
492
493   Net::AMQP::Protocol::Exchange::Declare
494       This class implements the class Exchange method Declare, which is a
495       synchronous method.
496
497       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
501       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
504       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
509       exchange (type: shortstr)
510       type (type: shortstr)
511           Exchange type
512
513           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
519       passive (type: bit)
520           Do not create exchange
521
522           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
526       durable (type: bit)
527           Request a durable exchange
528
529           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
534       auto_delete (type: bit)
535           Auto-delete when unused
536
537           If set, the exchange is deleted when all queues have finished using
538           it.
539
540       internal (type: bit)
541           Create internal exchange
542
543           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
547       nowait (type: bit)
548           Do not send a reply method
549
550           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
555       arguments (type: table)
556           Arguments for declaration
557
558           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
562   Net::AMQP::Protocol::Exchange::DeclareOk
563       This class implements the class Exchange method DeclareOk, which is a
564       synchronous method.
565
566       This method confirms a Declare method and confirms the name of the
567       exchange, essential for automatically-named exchanges.
568
569       This class has no fields nor accessors.
570
571   Net::AMQP::Protocol::Exchange::Delete
572       This class implements the class Exchange method Delete, which is a
573       synchronous method.
574
575       This method deletes an exchange. When an exchange is deleted all queue
576       bindings on the exchange are cancelled.
577
578       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
581       ticket (type: short)
582       exchange (type: shortstr)
583       if_unused (type: bit)
584           Delete only if unused
585
586           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
590       nowait (type: bit)
591           Do not send a reply method
592
593           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
598   Net::AMQP::Protocol::Exchange::DeleteOk
599       This class implements the class Exchange method DeleteOk, which is a
600       synchronous method.
601
602       This method confirms the deletion of an exchange.
603
604       This class has no fields nor accessors.
605
606   Net::AMQP::Protocol::Queue::Declare
607       This class implements the class Queue method Declare, which is a
608       synchronous method.
609
610       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
614       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
617       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
622           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
626       queue (type: shortstr)
627       passive (type: bit)
628           Do not create queue
629
630           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
634       durable (type: bit)
635           Request a durable queue
636
637           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
644       exclusive (type: bit)
645           Request an exclusive queue
646
647           Exclusive queues may only be consumed from by the current
648           connection. Setting the 'exclusive' flag always implies
649           'auto-delete'.
650
651       auto_delete (type: bit)
652           Auto-delete queue when unused
653
654           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
659       nowait (type: bit)
660           Do not send a reply method
661
662           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
667       arguments (type: table)
668           Arguments for declaration
669
670           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
674   Net::AMQP::Protocol::Queue::DeclareOk
675       This class implements the class Queue method DeclareOk, which is a
676       synchronous method.
677
678       This method confirms a Declare method and confirms the name of the
679       queue, essential for automatically-named queues.
680
681       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
684       queue (type: shortstr)
685           Reports the name of the queue. If the server generated a queue
686           name, this field contains that name.
687
688       message_count (type: long)
689           Number of messages in queue
690
691           Reports the number of messages in the queue, which will be zero for
692           newly-created queues.
693
694       consumer_count (type: long)
695           Number of consumers
696
697           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
701   Net::AMQP::Protocol::Queue::Bind
702       This class implements the class Queue method Bind, which is a
703       synchronous method.
704
705       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
710       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
713       ticket (type: short)
714           The client provides a valid access ticket giving "active" access
715           rights to the queue's access realm.
716
717       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
722       exchange (type: shortstr)
723           The name of the exchange to bind to.
724
725       routing_key (type: shortstr)
726           Message routing key
727
728           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
735       nowait (type: bit)
736           Do not send a reply method
737
738           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
743       arguments (type: table)
744           Arguments for binding
745
746           A set of arguments for the binding. The syntax and semantics of
747           these arguments depends on the exchange class.
748
749   Net::AMQP::Protocol::Queue::BindOk
750       This class implements the class Queue method BindOk, which is a
751       synchronous method.
752
753       This method confirms that the bind was successful.
754
755       This class has no fields nor accessors.
756
757   Net::AMQP::Protocol::Queue::Purge
758       This class implements the class Queue method Purge, which is a
759       synchronous method.
760
761       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
765       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
768       ticket (type: short)
769           The access ticket must be for the access realm that holds the
770           queue.
771
772       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
777       nowait (type: bit)
778           Do not send a reply method
779
780           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
785   Net::AMQP::Protocol::Queue::PurgeOk
786       This class implements the class Queue method PurgeOk, which is a
787       synchronous method.
788
789       This method confirms the purge of a queue.
790
791       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
794       message_count (type: long)
795           Number of messages purged
796
797           Reports the number of messages purged.
798
799   Net::AMQP::Protocol::Queue::Delete
800       This class implements the class Queue method Delete, which is a
801       synchronous method.
802
803       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
807       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
810       ticket (type: short)
811           The client provides a valid access ticket giving "active" access
812           rights to the queue's access realm.
813
814       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
819       if_unused (type: bit)
820           Delete only if unused
821
822           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
826       if_empty (type: bit)
827           Delete only if empty
828
829           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
833       nowait (type: bit)
834           Do not send a reply method
835
836           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
841   Net::AMQP::Protocol::Queue::DeleteOk
842       This class implements the class Queue method DeleteOk, which is a
843       synchronous method.
844
845       This method confirms the deletion of a queue.
846
847       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
850       message_count (type: long)
851           Number of messages purged
852
853           Reports the number of messages purged.
854
855   Net::AMQP::Protocol::Basic::Qos
856       This class implements the class Basic method Qos, which is a
857       synchronous method.
858
859       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
866       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
869       prefetch_size (type: long)
870           Prefetch window in octets
871
872           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
883       prefetch_count (type: short)
884           Prefetch window in messages
885
886           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
892       global (type: bit)
893           Apply to entire connection
894
895           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
898   Net::AMQP::Protocol::Basic::QosOk
899       This class implements the class Basic method QosOk, which is a
900       synchronous method.
901
902       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
906       This class has no fields nor accessors.
907
908   Net::AMQP::Protocol::Basic::Consume
909       This class implements the class Basic method Consume, which is a
910       synchronous method.
911
912       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
916       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
919       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
925       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
930       no_local (type: bit)
931       no_ack (type: bit)
932       exclusive (type: bit)
933           Request exclusive access
934
935           Request exclusive consumer access, meaning only this consumer can
936           access the queue.
937
938       nowait (type: bit)
939           Do not send a reply method
940
941           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
946   Net::AMQP::Protocol::Basic::ConsumeOk
947       This class implements the class Basic method ConsumeOk, which is a
948       synchronous method.
949
950       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
953       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
956       consumer_tag (type: shortstr)
957           Holds the consumer tag specified by the client or provided by the
958           server.
959
960   Net::AMQP::Protocol::Basic::Cancel
961       This class implements the class Basic method Cancel, which is a
962       synchronous method.
963
964       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
970       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
973       consumer_tag (type: shortstr)
974       nowait (type: bit)
975           Do not send a reply method
976
977           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
982   Net::AMQP::Protocol::Basic::CancelOk
983       This class implements the class Basic method CancelOk, which is a
984       synchronous method.
985
986       This method confirms that the cancellation was completed.
987
988       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
991       consumer_tag (type: shortstr)
992
993   Net::AMQP::Protocol::Basic::Publish
994       This class implements the class Basic method Publish, which is an
995       asynchronous method.
996
997       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
1002       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
1005       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
1012       routing_key (type: shortstr)
1013           Message routing key
1014
1015           Specifies the routing key for the message. The routing key is used
1016           for routing messages depending on the exchange configuration.
1017
1018       mandatory (type: bit)
1019           Indicate mandatory routing
1020
1021           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
1026       immediate (type: bit)
1027           Request immediate delivery
1028
1029           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
1035   Net::AMQP::Protocol::Basic::Return
1036       This class implements the class Basic method Return, which is an
1037       asynchronous method.
1038
1039       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
1044       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
1047       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
1053       routing_key (type: shortstr)
1054           Message routing key
1055
1056           Specifies the routing key name specified when the message was
1057           published.
1058
1059   Net::AMQP::Protocol::Basic::Deliver
1060       This class implements the class Basic method Deliver, which is an
1061       asynchronous method.
1062
1063       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
1068       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
1071       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
1078       routing_key (type: shortstr)
1079           Message routing key
1080
1081           Specifies the routing key name specified when the message was
1082           published.
1083
1084   Net::AMQP::Protocol::Basic::Get
1085       This class implements the class Basic method Get, which is a
1086       synchronous method.
1087
1088       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
1092       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
1095       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
1101       no_ack (type: bit)
1102
1103   Net::AMQP::Protocol::Basic::GetOk
1104       This class implements the class Basic method GetOk, which is a
1105       synchronous method.
1106
1107       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
1111       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
1114       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
1121       routing_key (type: shortstr)
1122           Message routing key
1123
1124           Specifies the routing key name specified when the message was
1125           published.
1126
1127       message_count (type: long)
1128           Number of messages pending
1129
1130           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
1135   Net::AMQP::Protocol::Basic::GetEmpty
1136       This class implements the class Basic method GetEmpty, which is a
1137       synchronous method.
1138
1139       This method tells the client that the queue has no messages available
1140       for the client.
1141
1142       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
1145       cluster_id (type: shortstr)
1146           Cluster id
1147
1148           For use by cluster applications, should not be used by client
1149           applications.
1150
1151   Net::AMQP::Protocol::Basic::Ack
1152       This class implements the class Basic method Ack, which is an
1153       asynchronous method.
1154
1155       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
1159       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
1162       delivery_tag (type: longlong)
1163       multiple (type: bit)
1164           Acknowledge multiple messages
1165
1166           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
1172   Net::AMQP::Protocol::Basic::Reject
1173       This class implements the class Basic method Reject, which is an
1174       asynchronous method.
1175
1176       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
1180       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
1183       delivery_tag (type: longlong)
1184       requeue (type: bit)
1185           Requeue the message
1186
1187           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
1190   Net::AMQP::Protocol::Basic::Recover
1191       This class implements the class Basic method Recover, which is an
1192       asynchronous method.
1193
1194       This method asks the broker to redeliver all unacknowledged messages on
1195       a specifieid channel. Zero or more messages may be redelivered.
1196
1197       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
1200       requeue (type: bit)
1201           Requeue the message
1202
1203           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
1208   Net::AMQP::Protocol::Basic::ContentHeader
1209       This class implements the class Basic method ContentHeader, which is an
1210       asynchronous method.
1211
1212       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
1215       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
1230   Net::AMQP::Protocol::File::Qos
1231       This class implements the class File method Qos, which is a synchronous
1232       method.
1233
1234       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
1241       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
1244       prefetch_size (type: long)
1245           Prefetch window in octets
1246
1247           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
1256       prefetch_count (type: short)
1257           Prefetch window in messages
1258
1259           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
1266       global (type: bit)
1267           Apply to entire connection
1268
1269           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
1272   Net::AMQP::Protocol::File::QosOk
1273       This class implements the class File method QosOk, which is a
1274       synchronous method.
1275
1276       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
1280       This class has no fields nor accessors.
1281
1282   Net::AMQP::Protocol::File::Consume
1283       This class implements the class File method Consume, which is a
1284       synchronous method.
1285
1286       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
1290       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
1293       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
1299       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
1304       no_local (type: bit)
1305       no_ack (type: bit)
1306       exclusive (type: bit)
1307           Request exclusive access
1308
1309           Request exclusive consumer access, meaning only this consumer can
1310           access the queue.
1311
1312       nowait (type: bit)
1313           Do not send a reply method
1314
1315           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
1320   Net::AMQP::Protocol::File::ConsumeOk
1321       This class implements the class File method ConsumeOk, which is a
1322       synchronous method.
1323
1324       This method provides the client with a consumer tag which it MUST use
1325       in methods that work with the consumer.
1326
1327       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
1330       consumer_tag (type: shortstr)
1331           Holds the consumer tag specified by the client or provided by the
1332           server.
1333
1334   Net::AMQP::Protocol::File::Cancel
1335       This class implements the class File method Cancel, which is a
1336       synchronous method.
1337
1338       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
1342       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
1345       consumer_tag (type: shortstr)
1346       nowait (type: bit)
1347           Do not send a reply method
1348
1349           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
1354   Net::AMQP::Protocol::File::CancelOk
1355       This class implements the class File method CancelOk, which is a
1356       synchronous method.
1357
1358       This method confirms that the cancellation was completed.
1359
1360       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
1363       consumer_tag (type: shortstr)
1364
1365   Net::AMQP::Protocol::File::Open
1366       This class implements the class File method Open, which is a
1367       synchronous method.
1368
1369       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
1376       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
1379       identifier (type: shortstr)
1380           Staging identifier
1381
1382           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
1389       content_size (type: longlong)
1390           Message content size
1391
1392           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
1396   Net::AMQP::Protocol::File::OpenOk
1397       This class implements the class File method OpenOk, which is a
1398       synchronous method.
1399
1400       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
1404       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
1407       staged_size (type: longlong)
1408           Already staged amount
1409
1410           The amount of previously-staged content in octets. For a new
1411           message this will be zero.
1412
1413   Net::AMQP::Protocol::File::Stage
1414       This class implements the class File method Stage, which is an
1415       asynchronous method.
1416
1417       This method stages the message, sending the message content to the
1418       recipient from the octet offset specified in the Open-Ok method.
1419
1420       This class has no fields nor accessors.
1421
1422   Net::AMQP::Protocol::File::Publish
1423       This class implements the class File method Publish, which is an
1424       asynchronous method.
1425
1426       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
1431       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
1434       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
1441       routing_key (type: shortstr)
1442           Message routing key
1443
1444           Specifies the routing key for the message. The routing key is used
1445           for routing messages depending on the exchange configuration.
1446
1447       mandatory (type: bit)
1448           Indicate mandatory routing
1449
1450           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
1455       immediate (type: bit)
1456           Request immediate delivery
1457
1458           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
1464       identifier (type: shortstr)
1465           Staging identifier
1466
1467           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
1472   Net::AMQP::Protocol::File::Return
1473       This class implements the class File method Return, which is an
1474       asynchronous method.
1475
1476       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
1481       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
1484       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
1490       routing_key (type: shortstr)
1491           Message routing key
1492
1493           Specifies the routing key name specified when the message was
1494           published.
1495
1496   Net::AMQP::Protocol::File::Deliver
1497       This class implements the class File method Deliver, which is an
1498       asynchronous method.
1499
1500       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
1505       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
1508       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
1515       routing_key (type: shortstr)
1516           Message routing key
1517
1518           Specifies the routing key name specified when the message was
1519           published.
1520
1521       identifier (type: shortstr)
1522           Staging identifier
1523
1524           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
1529   Net::AMQP::Protocol::File::Ack
1530       This class implements the class File method Ack, which is an
1531       asynchronous method.
1532
1533       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
1537       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
1540       delivery_tag (type: longlong)
1541       multiple (type: bit)
1542           Acknowledge multiple messages
1543
1544           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
1550   Net::AMQP::Protocol::File::Reject
1551       This class implements the class File method Reject, which is an
1552       asynchronous method.
1553
1554       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
1559       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
1562       delivery_tag (type: longlong)
1563       requeue (type: bit)
1564           Requeue the message
1565
1566           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
1569   Net::AMQP::Protocol::File::ContentHeader
1570       This class implements the class File method ContentHeader, which is an
1571       asynchronous method.
1572
1573       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
1576       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
1586   Net::AMQP::Protocol::Stream::Qos
1587       This class implements the class Stream method Qos, which is a
1588       synchronous method.
1589
1590       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
1597       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
1600       prefetch_size (type: long)
1601           Prefetch window in octets
1602
1603           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
1611       prefetch_count (type: short)
1612           Prefetch window in messages
1613
1614           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
1619       consume_rate (type: long)
1620           Transfer rate in octets/second
1621
1622           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
1626       global (type: bit)
1627           Apply to entire connection
1628
1629           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
1632   Net::AMQP::Protocol::Stream::QosOk
1633       This class implements the class Stream method QosOk, which is a
1634       synchronous method.
1635
1636       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
1640       This class has no fields nor accessors.
1641
1642   Net::AMQP::Protocol::Stream::Consume
1643       This class implements the class Stream method Consume, which is a
1644       synchronous method.
1645
1646       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
1650       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
1653       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
1659       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
1664       no_local (type: bit)
1665       exclusive (type: bit)
1666           Request exclusive access
1667
1668           Request exclusive consumer access, meaning only this consumer can
1669           access the queue.
1670
1671       nowait (type: bit)
1672           Do not send a reply method
1673
1674           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
1679   Net::AMQP::Protocol::Stream::ConsumeOk
1680       This class implements the class Stream method ConsumeOk, which is a
1681       synchronous method.
1682
1683       This method provides the client with a consumer tag which it may use in
1684       methods that work with the consumer.
1685
1686       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
1689       consumer_tag (type: shortstr)
1690           Holds the consumer tag specified by the client or provided by the
1691           server.
1692
1693   Net::AMQP::Protocol::Stream::Cancel
1694       This class implements the class Stream method Cancel, which is a
1695       synchronous method.
1696
1697       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
1701       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
1704       consumer_tag (type: shortstr)
1705       nowait (type: bit)
1706           Do not send a reply method
1707
1708           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
1713   Net::AMQP::Protocol::Stream::CancelOk
1714       This class implements the class Stream method CancelOk, which is a
1715       synchronous method.
1716
1717       This method confirms that the cancellation was completed.
1718
1719       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
1722       consumer_tag (type: shortstr)
1723
1724   Net::AMQP::Protocol::Stream::Publish
1725       This class implements the class Stream method Publish, which is an
1726       asynchronous method.
1727
1728       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
1732       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
1735       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
1742       routing_key (type: shortstr)
1743           Message routing key
1744
1745           Specifies the routing key for the message. The routing key is used
1746           for routing messages depending on the exchange configuration.
1747
1748       mandatory (type: bit)
1749           Indicate mandatory routing
1750
1751           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
1756       immediate (type: bit)
1757           Request immediate delivery
1758
1759           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
1765   Net::AMQP::Protocol::Stream::Return
1766       This class implements the class Stream method Return, which is an
1767       asynchronous method.
1768
1769       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
1774       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
1777       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
1783       routing_key (type: shortstr)
1784           Message routing key
1785
1786           Specifies the routing key name specified when the message was
1787           published.
1788
1789   Net::AMQP::Protocol::Stream::Deliver
1790       This class implements the class Stream method Deliver, which is an
1791       asynchronous method.
1792
1793       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
1798       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
1801       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
1807       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
1811   Net::AMQP::Protocol::Stream::ContentHeader
1812       This class implements the class Stream method ContentHeader, which is
1813       an asynchronous method.
1814
1815       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
1818       content_type (type: shortstr)
1819       content_encoding (type: shortstr)
1820       headers (type: table)
1821       priority (type: octet)
1822       timestamp (type: timestamp)
1823
1824   Net::AMQP::Protocol::Tx::Select
1825       This class implements the class Tx method Select, which is a
1826       synchronous method.
1827
1828       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
1832       This class has no fields nor accessors.
1833
1834   Net::AMQP::Protocol::Tx::SelectOk
1835       This class implements the class Tx method SelectOk, which is a
1836       synchronous method.
1837
1838       This method confirms to the client that the channel was successfully
1839       set to use standard transactions.
1840
1841       This class has no fields nor accessors.
1842
1843   Net::AMQP::Protocol::Tx::Commit
1844       This class implements the class Tx method Commit, which is a
1845       synchronous method.
1846
1847       This method commits all messages published and acknowledged in the
1848       current transaction. A new transaction starts immediately after a
1849       commit.
1850
1851       This class has no fields nor accessors.
1852
1853   Net::AMQP::Protocol::Tx::CommitOk
1854       This class implements the class Tx method CommitOk, which is a
1855       synchronous method.
1856
1857       This method confirms to the client that the commit succeeded. Note that
1858       if a commit fails, the server raises a channel exception.
1859
1860       This class has no fields nor accessors.
1861
1862   Net::AMQP::Protocol::Tx::Rollback
1863       This class implements the class Tx method Rollback, which is a
1864       synchronous method.
1865
1866       This method abandons all messages published and acknowledged in the
1867       current transaction. A new transaction starts immediately after a
1868       rollback.
1869
1870       This class has no fields nor accessors.
1871
1872   Net::AMQP::Protocol::Tx::RollbackOk
1873       This class implements the class Tx method RollbackOk, which is a
1874       synchronous method.
1875
1876       This method confirms to the client that the rollback succeeded. Note
1877       that if an rollback fails, the server raises a channel exception.
1878
1879       This class has no fields nor accessors.
1880
1881   Net::AMQP::Protocol::Dtx::Select
1882       This class implements the class Dtx method Select, which is a
1883       synchronous method.
1884
1885       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
1889       This class has no fields nor accessors.
1890
1891   Net::AMQP::Protocol::Dtx::SelectOk
1892       This class implements the class Dtx method SelectOk, which is a
1893       synchronous method.
1894
1895       This method confirms to the client that the channel was successfully
1896       set to use distributed transactions.
1897
1898       This class has no fields nor accessors.
1899
1900   Net::AMQP::Protocol::Dtx::Start
1901       This class implements the class Dtx method Start, which is a
1902       synchronous method.
1903
1904       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
1908       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
1911       dtx_identifier (type: shortstr)
1912           Transaction identifier
1913
1914           The distributed transaction key. This identifies the transaction so
1915           that the AMQP server can coordinate with the distributed
1916           transaction coordinator.
1917
1918   Net::AMQP::Protocol::Dtx::StartOk
1919       This class implements the class Dtx method StartOk, which is a
1920       synchronous method.
1921
1922       This method confirms to the client that the transaction started. Note
1923       that if a start fails, the server raises a channel exception.
1924
1925       This class has no fields nor accessors.
1926
1927   Net::AMQP::Protocol::Tunnel::Request
1928       This class implements the class Tunnel method Request, which is an
1929       asynchronous method.
1930
1931       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
1935       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
1938       meta_data (type: table)
1939           Meta data for the tunnelled block
1940
1941           This field table holds arbitrary meta-data that the sender needs to
1942           pass to the recipient.
1943
1944   Net::AMQP::Protocol::Tunnel::ContentHeader
1945       This class implements the class Tunnel method ContentHeader, which is
1946       an asynchronous method.
1947
1948       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
1951       headers (type: table)
1952       proxy_name (type: shortstr)
1953       data_name (type: shortstr)
1954       durable (type: octet)
1955       broadcast (type: octet)
1956
1957   Net::AMQP::Protocol::Test::Integer
1958       This class implements the class Test method Integer, which is a
1959       synchronous method.
1960
1961       This method tests the peer's capability to correctly marshal integer
1962       data.
1963
1964       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
1967       integer_1 (type: octet)
1968           Octet test value
1969
1970           An octet integer test value.
1971
1972       integer_2 (type: short)
1973           Short test value
1974
1975           A short integer test value.
1976
1977       integer_3 (type: long)
1978           Long test value
1979
1980           A long integer test value.
1981
1982       integer_4 (type: longlong)
1983           Long-long test value
1984
1985           A long long integer test value.
1986
1987       operation (type: octet)
1988           Operation to test
1989
1990           The client must execute this operation on the provided integer test
1991           fields and return the result.
1992
1993   Net::AMQP::Protocol::Test::IntegerOk
1994       This class implements the class Test method IntegerOk, which is a
1995       synchronous method.
1996
1997       This method reports the result of an Integer method.
1998
1999       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
2002       result (type: longlong)
2003           Result value
2004
2005           The result of the tested operation.
2006
2007   Net::AMQP::Protocol::Test::String
2008       This class implements the class Test method String, which is a
2009       synchronous method.
2010
2011       This method tests the peer's capability to correctly marshal string
2012       data.
2013
2014       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
2017       string_1 (type: shortstr)
2018           Short string test value
2019
2020           An short string test value.
2021
2022       string_2 (type: longstr)
2023           Long string test value
2024
2025           A long string test value.
2026
2027       operation (type: octet)
2028           Operation to test
2029
2030           The client must execute this operation on the provided string test
2031           fields and return the result.
2032
2033   Net::AMQP::Protocol::Test::StringOk
2034       This class implements the class Test method StringOk, which is a
2035       synchronous method.
2036
2037       This method reports the result of a String method.
2038
2039       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
2042       result (type: longstr)
2043           Result value
2044
2045           The result of the tested operation.
2046
2047   Net::AMQP::Protocol::Test::Table
2048       This class implements the class Test method Table, which is a
2049       synchronous method.
2050
2051       This method tests the peer's capability to correctly marshal field
2052       table data.
2053
2054       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
2057       table (type: table)
2058           Field table of test values
2059
2060           A field table of test values.
2061
2062       integer_op (type: octet)
2063           Operation to test on integers
2064
2065           The client must execute this operation on the provided field table
2066           integer values and return the result.
2067
2068       string_op (type: octet)
2069           Operation to test on strings
2070
2071           The client must execute this operation on the provided field table
2072           string values and return the result.
2073
2074   Net::AMQP::Protocol::Test::TableOk
2075       This class implements the class Test method TableOk, which is a
2076       synchronous method.
2077
2078       This method reports the result of a Table method.
2079
2080       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
2083       integer_result (type: longlong)
2084           Integer result value
2085
2086           The result of the tested integer operation.
2087
2088       string_result (type: longstr)
2089           String result value
2090
2091           The result of the tested string operation.
2092
2093   Net::AMQP::Protocol::Test::Content
2094       This class implements the class Test method Content, which is a
2095       synchronous method.
2096
2097       This method tests the peer's capability to correctly marshal content.
2098
2099       This class has no fields nor accessors.
2100
2101   Net::AMQP::Protocol::Test::ContentOk
2102       This class implements the class Test method ContentOk, which is a
2103       synchronous method.
2104
2105       This method reports the result of a Content method. It contains the
2106       content checksum and echoes the original content as provided.
2107
2108       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
2111       content_checksum (type: long)
2112           Content hash
2113
2114           The 32-bit checksum of the content, calculated by adding the
2115           content into a 32-bit accumulator.
2116
2117
2118
2119perl v5.32.1                      2021-01-27      Net::AMQP::Protocol::v0_8(3)
Impressum