File Coverage

blib/lib/Paws/SQS.pm
Criterion Covered Total %
statement 42 61 68.8
branch n/a
condition n/a
subroutine 16 23 69.5
pod 17 21 80.9
total 75 105 71.4


line stmt bran cond sub pod time code
1             package Paws::SQS;
2 1     1   2494 use Moose;
  1     7   3  
  1         7  
  7         6340  
  7         15  
  7         44  
3 41     41 0 152 sub service { 'sqs' }
4 3     3 0 18 sub version { '2012-11-05' }
5 8     8 0 46 sub flattened_arrays { 1 }
6             has max_attempts => (is => 'ro', isa => 'Int', default => 5);
7             has retry => (is => 'ro', isa => 'HashRef', default => sub {
8             { base => 'rand', type => 'exponential', growth_factor => 2 }
9             });
10             has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
11             sub { defined $_[0]->http_status and $_[0]->http_status == 403 and $_[0]->code eq 'RequestThrottled' },
12             ] });
13              
14             with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::QueryCaller', 'Paws::Net::XMLResponse';
15              
16             has '+region_rules' => (default => sub {
17             my $regioninfo;
18             $regioninfo = [
19             {
20             constraints => [
21             [
22             'region',
23             'equals',
24             'us-east-1'
25             ]
26             ],
27             uri => 'https://queue.amazonaws.com'
28             },
29             {
30             constraints => [
31             [
32             'region',
33             'startsWith',
34             'cn-'
35             ]
36             ],
37             uri => 'https://{region}.queue.amazonaws.com.cn'
38             },
39             {
40             constraints => [
41             [
42             'region',
43             'notEquals',
44             undef
45             ]
46             ],
47             uri => 'https://{region}.queue.amazonaws.com'
48             }
49             ];
50              
51             return $regioninfo;
52             });
53              
54            
55             sub AddPermission {
56 1     1 1 520 my $self = shift;
57 1         5 my $call_object = $self->new_with_coercions('Paws::SQS::AddPermission', @_);
58 1         1240 return $self->caller->do_call($self, $call_object);
59             }
60             sub ChangeMessageVisibility {
61 0     0 1 0 my $self = shift;
62 0         0 my $call_object = $self->new_with_coercions('Paws::SQS::ChangeMessageVisibility', @_);
63 0         0 return $self->caller->do_call($self, $call_object);
64             }
65             sub ChangeMessageVisibilityBatch {
66 1     1 1 344 my $self = shift;
67 1         4 my $call_object = $self->new_with_coercions('Paws::SQS::ChangeMessageVisibilityBatch', @_);
68 1         711 return $self->caller->do_call($self, $call_object);
69             }
70             sub CreateQueue {
71 2     2 1 286 my $self = shift;
72 2         10 my $call_object = $self->new_with_coercions('Paws::SQS::CreateQueue', @_);
73 2         1241 return $self->caller->do_call($self, $call_object);
74             }
75             sub DeleteMessage {
76 0     0 1 0 my $self = shift;
77 0         0 my $call_object = $self->new_with_coercions('Paws::SQS::DeleteMessage', @_);
78 0         0 return $self->caller->do_call($self, $call_object);
79             }
80             sub DeleteMessageBatch {
81 1     1 1 318 my $self = shift;
82 1         5 my $call_object = $self->new_with_coercions('Paws::SQS::DeleteMessageBatch', @_);
83 1         717 return $self->caller->do_call($self, $call_object);
84             }
85             sub DeleteQueue {
86 1     1 1 2 my $self = shift;
87 1         5 my $call_object = $self->new_with_coercions('Paws::SQS::DeleteQueue', @_);
88 1         496 return $self->caller->do_call($self, $call_object);
89             }
90             sub GetQueueAttributes {
91 2     2 1 526 my $self = shift;
92 2         9 my $call_object = $self->new_with_coercions('Paws::SQS::GetQueueAttributes', @_);
93 2         1054 return $self->caller->do_call($self, $call_object);
94             }
95             sub GetQueueUrl {
96 1     1 1 280 my $self = shift;
97 1         5 my $call_object = $self->new_with_coercions('Paws::SQS::GetQueueUrl', @_);
98 1         522 return $self->caller->do_call($self, $call_object);
99             }
100             sub ListDeadLetterSourceQueues {
101 0     0 1 0 my $self = shift;
102 0         0 my $call_object = $self->new_with_coercions('Paws::SQS::ListDeadLetterSourceQueues', @_);
103 0         0 return $self->caller->do_call($self, $call_object);
104             }
105             sub ListQueues {
106 3     3 1 167 my $self = shift;
107 3         14 my $call_object = $self->new_with_coercions('Paws::SQS::ListQueues', @_);
108 3         823 return $self->caller->do_call($self, $call_object);
109             }
110             sub PurgeQueue {
111 0     0 1 0 my $self = shift;
112 0         0 my $call_object = $self->new_with_coercions('Paws::SQS::PurgeQueue', @_);
113 0         0 return $self->caller->do_call($self, $call_object);
114             }
115             sub ReceiveMessage {
116 1     1 1 429 my $self = shift;
117 1         5 my $call_object = $self->new_with_coercions('Paws::SQS::ReceiveMessage', @_);
118 1         1051 return $self->caller->do_call($self, $call_object);
119             }
120             sub RemovePermission {
121 0     0 1 0 my $self = shift;
122 0         0 my $call_object = $self->new_with_coercions('Paws::SQS::RemovePermission', @_);
123 0         0 return $self->caller->do_call($self, $call_object);
124             }
125             sub SendMessage {
126 2     2 1 926 my $self = shift;
127 2         11 my $call_object = $self->new_with_coercions('Paws::SQS::SendMessage', @_);
128 2         2307 return $self->caller->do_call($self, $call_object);
129             }
130             sub SendMessageBatch {
131 2     2 1 838 my $self = shift;
132 2         10 my $call_object = $self->new_with_coercions('Paws::SQS::SendMessageBatch', @_);
133 2         1508 return $self->caller->do_call($self, $call_object);
134             }
135             sub SetQueueAttributes {
136 0     0 1   my $self = shift;
137 0           my $call_object = $self->new_with_coercions('Paws::SQS::SetQueueAttributes', @_);
138 0           return $self->caller->do_call($self, $call_object);
139             }
140            
141              
142              
143 0     0 0   sub operations { qw/AddPermission ChangeMessageVisibility ChangeMessageVisibilityBatch CreateQueue DeleteMessage DeleteMessageBatch DeleteQueue GetQueueAttributes GetQueueUrl ListDeadLetterSourceQueues ListQueues PurgeQueue ReceiveMessage RemovePermission SendMessage SendMessageBatch SetQueueAttributes / }
144              
145             1;
146              
147             ### main pod documentation begin ###
148              
149             =head1 NAME
150              
151             Paws::SQS - Perl Interface to AWS Amazon Simple Queue Service
152              
153             =head1 SYNOPSIS
154              
155             use Paws;
156              
157             my $obj = Paws->service('SQS');
158             my $res = $obj->Method(
159             Arg1 => $val1,
160             Arg2 => [ 'V1', 'V2' ],
161             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
162             # of the arguments type
163             Arg3 => { Att1 => 'Val1' },
164             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
165             # the constructor of the arguments type
166             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
167             );
168              
169             =head1 DESCRIPTION
170              
171             Welcome to the I<Amazon Simple Queue Service API Reference>.
172              
173             Amazon Simple Queue Service (Amazon SQS) is a reliable, highly-scalable
174             hosted queue for storing messages as they travel between applications
175             or microservices. Amazon SQS moves data between distributed application
176             components and helps you decouple these components.
177              
178             Standard queues are available in all regions. FIFO queues are available
179             in the US East (N. Virginia), US East (Ohio), US West (Oregon), and EU
180             (Ireland) regions.
181              
182             You can use AWS SDKs to access Amazon SQS using your favorite
183             programming language. The SDKs perform tasks such as the following
184             automatically:
185              
186             =over
187              
188             =item *
189              
190             Cryptographically sign your service requests
191              
192             =item *
193              
194             Retry requests
195              
196             =item *
197              
198             Handle error responses
199              
200             =back
201              
202             B<Additional Information>
203              
204             =over
205              
206             =item *
207              
208             Amazon SQS Product Page
209              
210             =item *
211              
212             I<Amazon SQS Developer Guide>
213              
214             =over
215              
216             =item *
217              
218             Making API Requests
219              
220             =item *
221              
222             Using Amazon SQS Message Attributes
223              
224             =item *
225              
226             Using Amazon SQS Dead-Letter Queues
227              
228             =back
229              
230             =item *
231              
232             I<Amazon Web Services General Reference>
233              
234             =over
235              
236             =item *
237              
238             Regions and Endpoints
239              
240             =back
241              
242             =back
243              
244              
245             =head1 METHODS
246              
247             =head2 AddPermission(Actions => ArrayRef[Str|Undef], AWSAccountIds => ArrayRef[Str|Undef], Label => Str, QueueUrl => Str)
248              
249             Each argument is described in detail in: L<Paws::SQS::AddPermission>
250              
251             Returns: nothing
252              
253             Adds a permission to a queue for a specific principal. This allows
254             sharing access to the queue.
255              
256             When you create a queue, you have full control access rights for the
257             queue. Only you, the owner of the queue, can grant or deny permissions
258             to the queue. For more information about these permissions, see Shared
259             Queues in the I<Amazon SQS Developer Guide>.
260              
261             C<AddPermission> writes an Amazon-SQS-generated policy. If you want to
262             write your own policy, use C< SetQueueAttributes > to upload your
263             policy. For more information about writing your own policy, see Using
264             The Access Policy Language in the I<Amazon SQS Developer Guide>.
265              
266             Some actions take lists of parameters. These lists are specified using
267             the C<param.n> notation. Values of C<n> are integers starting from 1.
268             For example, a parameter list with two elements looks like this:
269              
270             C<&Attribute.1=this>
271              
272             C<&Attribute.2=that>
273              
274              
275             =head2 ChangeMessageVisibility(QueueUrl => Str, ReceiptHandle => Str, VisibilityTimeout => Int)
276              
277             Each argument is described in detail in: L<Paws::SQS::ChangeMessageVisibility>
278              
279             Returns: nothing
280              
281             Changes the visibility timeout of a specified message in a queue to a
282             new value. The maximum allowed timeout value is 12 hours. Thus, you
283             can't extend the timeout of a message in an existing queue to more than
284             a total visibility timeout of 12 hours. For more information, see
285             Visibility Timeout in the I<Amazon SQS Developer Guide>.
286              
287             For example, you have a message with a visibility timeout of 5 minutes.
288             After 3 minutes, you call C<ChangeMessageVisiblity> with a timeout of
289             10 minutes. At that time, the timeout for the message is extended by 10
290             minutes beyond the time of the C<ChangeMessageVisibility> action. This
291             results in a total visibility timeout of 13 minutes. You can continue
292             to call the C<ChangeMessageVisibility> to extend the visibility timeout
293             to a maximum of 12 hours. If you try to extend the visibility timeout
294             beyond 12 hours, your request is rejected.
295              
296             A message is considered to be I<in flight> after it's received from a
297             queue by a consumer, but not yet deleted from the queue.
298              
299             For standard queues, there can be a maximum of 120,000 inflight
300             messages per queue. If you reach this limit, Amazon SQS returns the
301             C<OverLimit> error message. To avoid reaching the limit, you should
302             delete messages from the queue after they're processed. You can also
303             increase the number of queues you use to process your messages.
304              
305             For FIFO queues, there can be a maximum of 20,000 inflight messages per
306             queue. If you reach this limit, Amazon SQS returns no error messages.
307              
308             If you attempt to set the C<VisibilityTimeout> to a value greater than
309             the maximum time left, Amazon SQS returns an error. Amazon SQS doesn't
310             automatically recalculate and increase the timeout to the maximum
311             remaining time.
312              
313             Unlike with a queue, when you change the visibility timeout for a
314             specific message the timeout value is applied immediately but isn't
315             saved in memory for that message. If you don't delete a message after
316             it is received, the visibility timeout for the message reverts to the
317             original timeout value (not to the value you set using the
318             C<ChangeMessageVisibility> action) the next time the message is
319             received.
320              
321              
322             =head2 ChangeMessageVisibilityBatch(Entries => ArrayRef[L<Paws::SQS::ChangeMessageVisibilityBatchRequestEntry>], QueueUrl => Str)
323              
324             Each argument is described in detail in: L<Paws::SQS::ChangeMessageVisibilityBatch>
325              
326             Returns: a L<Paws::SQS::ChangeMessageVisibilityBatchResult> instance
327              
328             Changes the visibility timeout of multiple messages. This is a batch
329             version of C< ChangeMessageVisibility.> The result of the action on
330             each message is reported individually in the response. You can send up
331             to 10 C< ChangeMessageVisibility > requests with each
332             C<ChangeMessageVisibilityBatch> action.
333              
334             Because the batch request can result in a combination of successful and
335             unsuccessful actions, you should check for batch errors even when the
336             call returns an HTTP status code of C<200>.
337              
338             Some actions take lists of parameters. These lists are specified using
339             the C<param.n> notation. Values of C<n> are integers starting from 1.
340             For example, a parameter list with two elements looks like this:
341              
342             C<&Attribute.1=this>
343              
344             C<&Attribute.2=that>
345              
346              
347             =head2 CreateQueue(QueueName => Str, [Attributes => L<Paws::SQS::QueueAttributeMap>])
348              
349             Each argument is described in detail in: L<Paws::SQS::CreateQueue>
350              
351             Returns: a L<Paws::SQS::CreateQueueResult> instance
352              
353             Creates a new standard or FIFO queue. You can pass one or more
354             attributes in the request. Keep the following caveats in mind:
355              
356             =over
357              
358             =item *
359              
360             If you don't specify the C<FifoQueue> attribute, Amazon SQS creates a
361             standard queue.
362              
363             You can't change the queue type after you create it and you can't
364             convert an existing standard queue into a FIFO queue. You must either
365             create a new FIFO queue for your application or delete your existing
366             standard queue and recreate it as a FIFO queue. For more information,
367             see Moving From a Standard Queue to a FIFO Queue in the I<Amazon SQS
368             Developer Guide>.
369              
370             =item *
371              
372             If you don't provide a value for an attribute, the queue is created
373             with the default value for the attribute.
374              
375             =item *
376              
377             If you delete a queue, you must wait at least 60 seconds before
378             creating a queue with the same name.
379              
380             =back
381              
382             To successfully create a new queue, you must provide a queue name that
383             adheres to the limits related to queues and is unique within the scope
384             of your queues.
385              
386             To get the queue URL, use the C< GetQueueUrl > action. C< GetQueueUrl >
387             requires only the C<QueueName> parameter. be aware of existing queue
388             names:
389              
390             =over
391              
392             =item *
393              
394             If you provide the name of an existing queue along with the exact names
395             and values of all the queue's attributes, C<CreateQueue> returns the
396             queue URL for the existing queue.
397              
398             =item *
399              
400             If the queue name, attribute names, or attribute values don't match an
401             existing queue, C<CreateQueue> returns an error.
402              
403             =back
404              
405             Some actions take lists of parameters. These lists are specified using
406             the C<param.n> notation. Values of C<n> are integers starting from 1.
407             For example, a parameter list with two elements looks like this:
408              
409             C<&Attribute.1=this>
410              
411             C<&Attribute.2=that>
412              
413              
414             =head2 DeleteMessage(QueueUrl => Str, ReceiptHandle => Str)
415              
416             Each argument is described in detail in: L<Paws::SQS::DeleteMessage>
417              
418             Returns: nothing
419              
420             Deletes the specified message from the specified queue. You specify the
421             message by using the message's I<receipt handle> and not the
422             I<MessageId> you receive when you send the message. Even if the message
423             is locked by another reader due to the visibility timeout setting, it
424             is still deleted from the queue. If you leave a message in the queue
425             for longer than the queue's configured retention period, Amazon SQS
426             automatically deletes the message.
427              
428             The receipt handle is associated with a specific instance of receiving
429             the message. If you receive a message more than once, the receipt
430             handle you get each time you receive the message is different. If you
431             don't provide the most recently received receipt handle for the message
432             when you use the C<DeleteMessage> action, the request succeeds, but the
433             message might not be deleted.
434              
435             For standard queues, it is possible to receive a message even after you
436             delete it. This might happen on rare occasions if one of the servers
437             storing a copy of the message is unavailable when you send the request
438             to delete the message. The copy remains on the server and might be
439             returned to you on a subsequent receive request. You should ensure that
440             your application is idempotent, so that receiving a message more than
441             once does not cause issues.
442              
443              
444             =head2 DeleteMessageBatch(Entries => ArrayRef[L<Paws::SQS::DeleteMessageBatchRequestEntry>], QueueUrl => Str)
445              
446             Each argument is described in detail in: L<Paws::SQS::DeleteMessageBatch>
447              
448             Returns: a L<Paws::SQS::DeleteMessageBatchResult> instance
449              
450             Deletes up to ten messages from the specified queue. This is a batch
451             version of C< DeleteMessage.> The result of the action on each message
452             is reported individually in the response.
453              
454             Because the batch request can result in a combination of successful and
455             unsuccessful actions, you should check for batch errors even when the
456             call returns an HTTP status code of C<200>.
457              
458             Some actions take lists of parameters. These lists are specified using
459             the C<param.n> notation. Values of C<n> are integers starting from 1.
460             For example, a parameter list with two elements looks like this:
461              
462             C<&Attribute.1=this>
463              
464             C<&Attribute.2=that>
465              
466              
467             =head2 DeleteQueue(QueueUrl => Str)
468              
469             Each argument is described in detail in: L<Paws::SQS::DeleteQueue>
470              
471             Returns: nothing
472              
473             Deletes the queue specified by the C<QueueUrl>, regardless of the
474             queue's contents. If the specified queue doesn't exist, Amazon SQS
475             returns a successful response.
476              
477             Be careful with the C<DeleteQueue> action: When you delete a queue, any
478             messages in the queue are no longer available.
479              
480             When you delete a queue, the deletion process takes up to 60 seconds.
481             Requests you send involving that queue during the 60 seconds might
482             succeed. For example, a C< SendMessage > request might succeed, but
483             after 60 seconds the queue and the message you sent no longer exist.
484              
485             When you delete a queue, you must wait at least 60 seconds before
486             creating a queue with the same name.
487              
488              
489             =head2 GetQueueAttributes(QueueUrl => Str, [AttributeNames => ArrayRef[Str|Undef]])
490              
491             Each argument is described in detail in: L<Paws::SQS::GetQueueAttributes>
492              
493             Returns: a L<Paws::SQS::GetQueueAttributesResult> instance
494              
495             Gets attributes for the specified queue.
496              
497             To determine whether a queue is FIFO, you can check whether
498             C<QueueName> ends with the C<.fifo> suffix.
499              
500             Some actions take lists of parameters. These lists are specified using
501             the C<param.n> notation. Values of C<n> are integers starting from 1.
502             For example, a parameter list with two elements looks like this:
503              
504             C<&Attribute.1=this>
505              
506             C<&Attribute.2=that>
507              
508              
509             =head2 GetQueueUrl(QueueName => Str, [QueueOwnerAWSAccountId => Str])
510              
511             Each argument is described in detail in: L<Paws::SQS::GetQueueUrl>
512              
513             Returns: a L<Paws::SQS::GetQueueUrlResult> instance
514              
515             Returns the URL of an existing queue. This action provides a simple way
516             to retrieve the URL of an Amazon SQS queue.
517              
518             To access a queue that belongs to another AWS account, use the
519             C<QueueOwnerAWSAccountId> parameter to specify the account ID of the
520             queue's owner. The queue's owner must grant you permission to access
521             the queue. For more information about shared queue access, see C<
522             AddPermission > or see Shared Queues in the I<Amazon SQS Developer
523             Guide>.
524              
525              
526             =head2 ListDeadLetterSourceQueues(QueueUrl => Str)
527              
528             Each argument is described in detail in: L<Paws::SQS::ListDeadLetterSourceQueues>
529              
530             Returns: a L<Paws::SQS::ListDeadLetterSourceQueuesResult> instance
531              
532             Returns a list of your queues that have the C<RedrivePolicy> queue
533             attribute configured with a dead-letter queue.
534              
535             For more information about using dead-letter queues, see Using Amazon
536             SQS Dead-Letter Queues in the I<Amazon SQS Developer Guide>.
537              
538              
539             =head2 ListQueues([QueueNamePrefix => Str])
540              
541             Each argument is described in detail in: L<Paws::SQS::ListQueues>
542              
543             Returns: a L<Paws::SQS::ListQueuesResult> instance
544              
545             Returns a list of your queues. The maximum number of queues that can be
546             returned is 1,000. If you specify a value for the optional
547             C<QueueNamePrefix> parameter, only queues with a name that begins with
548             the specified value are returned.
549              
550              
551             =head2 PurgeQueue(QueueUrl => Str)
552              
553             Each argument is described in detail in: L<Paws::SQS::PurgeQueue>
554              
555             Returns: nothing
556              
557             Deletes the messages in a queue specified by the C<QueueURL> parameter.
558              
559             When you use the C<PurgeQueue> action, you can't retrieve a message
560             deleted from a queue.
561              
562             When you purge a queue, the message deletion process takes up to 60
563             seconds. All messages sent to the queue before calling the
564             C<PurgeQueue> action are deleted. Messages sent to the queue while it
565             is being purged might be deleted. While the queue is being purged,
566             messages sent to the queue before C<PurgeQueue> is called might be
567             received, but are deleted within the next minute.
568              
569              
570             =head2 ReceiveMessage(QueueUrl => Str, [AttributeNames => ArrayRef[Str|Undef], MaxNumberOfMessages => Int, MessageAttributeNames => ArrayRef[Str|Undef], ReceiveRequestAttemptId => Str, VisibilityTimeout => Int, WaitTimeSeconds => Int])
571              
572             Each argument is described in detail in: L<Paws::SQS::ReceiveMessage>
573              
574             Returns: a L<Paws::SQS::ReceiveMessageResult> instance
575              
576             Retrieves one or more messages (up to 10), from the specified queue.
577             Using the C<WaitTimeSeconds> parameter enables long-poll support. For
578             more information, see Amazon SQS Long Polling in the I<Amazon SQS
579             Developer Guide>.
580              
581             Short poll is the default behavior where a weighted random set of
582             machines is sampled on a C<ReceiveMessage> call. Thus, only the
583             messages on the sampled machines are returned. If the number of
584             messages in the queue is small (fewer than 1,000), you most likely get
585             fewer messages than you requested per C<ReceiveMessage> call. If the
586             number of messages in the queue is extremely small, you might not
587             receive any messages in a particular C<ReceiveMessage> response. If
588             this happens, repeat the request.
589              
590             For each message returned, the response includes the following:
591              
592             =over
593              
594             =item *
595              
596             The message body.
597              
598             =item *
599              
600             An MD5 digest of the message body. For information about MD5, see
601             RFC1321.
602              
603             =item *
604              
605             The C<MessageId> you received when you sent the message to the queue.
606              
607             =item *
608              
609             The receipt handle.
610              
611             =item *
612              
613             The message attributes.
614              
615             =item *
616              
617             An MD5 digest of the message attributes.
618              
619             =back
620              
621             The receipt handle is the identifier you must provide when deleting the
622             message. For more information, see Queue and Message Identifiers in the
623             I<Amazon SQS Developer Guide>.
624              
625             You can provide the C<VisibilityTimeout> parameter in your request. The
626             parameter is applied to the messages that Amazon SQS returns in the
627             response. If you don't include the parameter, the overall visibility
628             timeout for the queue is used for the returned messages. For more
629             information, see Visibility Timeout in the I<Amazon SQS Developer
630             Guide>.
631              
632             A message that isn't deleted or a message whose visibility isn't
633             extended before the visibility timeout expires counts as a failed
634             receive. Depending on the configuration of the queue, the message might
635             be sent to the dead-letter queue.
636              
637             In the future, new attributes might be added. If you write code that
638             calls this action, we recommend that you structure your code so that it
639             can handle new attributes gracefully.
640              
641              
642             =head2 RemovePermission(Label => Str, QueueUrl => Str)
643              
644             Each argument is described in detail in: L<Paws::SQS::RemovePermission>
645              
646             Returns: nothing
647              
648             Revokes any permissions in the queue policy that matches the specified
649             C<Label> parameter. Only the owner of the queue can remove permissions.
650              
651              
652             =head2 SendMessage(MessageBody => Str, QueueUrl => Str, [DelaySeconds => Int, MessageAttributes => L<Paws::SQS::MessageBodyAttributeMap>, MessageDeduplicationId => Str, MessageGroupId => Str])
653              
654             Each argument is described in detail in: L<Paws::SQS::SendMessage>
655              
656             Returns: a L<Paws::SQS::SendMessageResult> instance
657              
658             Delivers a message to the specified queue.
659              
660             A message can include only XML, JSON, and unformatted text. The
661             following Unicode characters are allowed:
662              
663             C<#x9> | C<#xA> | C<#xD> | C<#x20> to C<#xD7FF> | C<#xE000> to
664             C<#xFFFD> | C<#x10000> to C<#x10FFFF>
665              
666             Any characters not included in this list will be rejected. For more
667             information, see the W3C specification for characters.
668              
669              
670             =head2 SendMessageBatch(Entries => ArrayRef[L<Paws::SQS::SendMessageBatchRequestEntry>], QueueUrl => Str)
671              
672             Each argument is described in detail in: L<Paws::SQS::SendMessageBatch>
673              
674             Returns: a L<Paws::SQS::SendMessageBatchResult> instance
675              
676             Delivers up to ten messages to the specified queue. This is a batch
677             version of C< SendMessage.> For a FIFO queue, multiple messages within
678             a single batch are enqueued in the order they are sent.
679              
680             The result of sending each message is reported individually in the
681             response. Because the batch request can result in a combination of
682             successful and unsuccessful actions, you should check for batch errors
683             even when the call returns an HTTP status code of C<200>.
684              
685             The maximum allowed individual message size and the maximum total
686             payload size (the sum of the individual lengths of all of the batched
687             messages) are both 256 KB (262,144 bytes).
688              
689             A message can include only XML, JSON, and unformatted text. The
690             following Unicode characters are allowed:
691              
692             C<#x9> | C<#xA> | C<#xD> | C<#x20> to C<#xD7FF> | C<#xE000> to
693             C<#xFFFD> | C<#x10000> to C<#x10FFFF>
694              
695             Any characters not included in this list will be rejected. For more
696             information, see the W3C specification for characters.
697              
698             If you don't specify the C<DelaySeconds> parameter for an entry, Amazon
699             SQS uses the default value for the queue.
700              
701             Some actions take lists of parameters. These lists are specified using
702             the C<param.n> notation. Values of C<n> are integers starting from 1.
703             For example, a parameter list with two elements looks like this:
704              
705             C<&Attribute.1=this>
706              
707             C<&Attribute.2=that>
708              
709              
710             =head2 SetQueueAttributes(Attributes => L<Paws::SQS::QueueAttributeMap>, QueueUrl => Str)
711              
712             Each argument is described in detail in: L<Paws::SQS::SetQueueAttributes>
713              
714             Returns: nothing
715              
716             Sets the value of one or more queue attributes. When you change a
717             queue's attributes, the change can take up to 60 seconds for most of
718             the attributes to propagate throughout the Amazon SQS system. Changes
719             made to the C<MessageRetentionPeriod> attribute can take up to 15
720             minutes.
721              
722             In the future, new attributes might be added. If you write code that
723             calls this action, we recommend that you structure your code so that it
724             can handle new attributes gracefully.
725              
726              
727              
728              
729             =head1 PAGINATORS
730              
731             Paginator methods are helpers that repetively call methods that return partial results
732              
733              
734              
735              
736             =head1 SEE ALSO
737              
738             This service class forms part of L<Paws>
739              
740             =head1 BUGS and CONTRIBUTIONS
741              
742             The source code is located here: https://github.com/pplu/aws-sdk-perl
743              
744             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
745              
746             =cut
747