Debian Codegraph @

zaqarclient/queues/v2/cli.py

raw
1 # Copyright 2015 NEC Corporation. All rights reserved.
2 #
3 # Licensed under the Apache License, Version 2.0 (the "License"); you may
4 # not use this file except in compliance with the License. You may obtain
5 # a copy of the License at
6 #
7 # http://www.apache.org/licenses/LICENSE-2.0
8 #
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 # License for the specific language governing permissions and limitations
13 # under the License.
14
15 import json
16 import os
17
18 from osc_lib.command import command
19 from osc_lib import utils
20 from oslo_log import log as logging
21
22 from zaqarclient._i18n import _
23 from zaqarclient.transport import errors
24
25
26 def _get_client(obj, parsed_args):
27 obj.log.debug("take_action(%s)" % parsed_args)
28 return obj.app.client_manager.messaging
29
30
31 class CreateQueue(command.ShowOne):
32 """Create a queue"""
33
34 _description = _("Create a queue")
35 log = logging.getLogger(__name__ + ".CreateQueue")
36
37 def get_parser(self, prog_name):
38 parser = super().get_parser(prog_name)
39 parser.add_argument(
40 "queue_name",
41 metavar="<queue_name>",
42 help="Name of the queue")
43 return parser
44
45 def take_action(self, parsed_args):
46 client = _get_client(self, parsed_args)
47 queue_name = parsed_args.queue_name
48 data = client.queue(queue_name, force_create=True)
49 columns = ('Name',)
50 return columns, utils.get_item_properties(data, columns)
51
52
53 class DeleteQueue(command.Command):
54 """Delete a queue"""
55
56 _description = _("Delete a queue")
57 log = logging.getLogger(__name__ + ".DeleteQueue")
58
59 def get_parser(self, prog_name):
60 parser = super().get_parser(prog_name)
61 parser.add_argument(
62 "queue_name",
63 metavar="<queue_name>",
64 help="Name of the queue")
65 return parser
66
67 def take_action(self, parsed_args):
68 client = _get_client(self, parsed_args)
69 queue_name = parsed_args.queue_name
70 client.queue(queue_name).delete()
71
72
73 class ListQueues(command.Lister):
74 """List available queues"""
75
76 _description = _("List available queues")
77 log = logging.getLogger(__name__ + ".ListQueues")
78
79 def get_parser(self, prog_name):
80 parser = super().get_parser(prog_name)
81 parser.add_argument(
82 "--marker",
83 metavar="<queue_id>",
84 help="Queue's paging marker")
85 parser.add_argument(
86 "--limit",
87 metavar="<limit>",
88 help="Page size limit")
89 parser.add_argument(
90 "--detailed",
91 action="store_true",
92 help="If show detailed information of queue")
93 parser.add_argument(
94 "--with_count",
95 action="store_true",
96 help="If show amount information of queue")
97
98 return parser
99
100 def take_action(self, parsed_args):
101 client = _get_client(self, parsed_args)
102 kwargs = {}
103 columns = ["Name"]
104 if parsed_args.marker is not None:
105 kwargs["marker"] = parsed_args.marker
106 if parsed_args.limit is not None:
107 kwargs["limit"] = parsed_args.limit
108 if parsed_args.detailed is not None and parsed_args.detailed:
109 kwargs["detailed"] = parsed_args.detailed
110 columns.extend(["Metadata_Dict", "Href"])
111 if parsed_args.with_count is not None and parsed_args.with_count:
112 kwargs["with_count"] = parsed_args.with_count
113
114 data, count = client.queues(**kwargs)
115 if count:
116 print("Queues in total: %s" % count)
117 columns = tuple(columns)
118 return (columns, (utils.get_item_properties(s, columns) for s in data))
119
120
121 class GetQueueStats(command.ShowOne):
122 """Get queue stats"""
123
124 _description = _("Get queue stats")
125 log = logging.getLogger(__name__ + ".GetQueueStats")
126
127 def get_parser(self, prog_name):
128 parser = super().get_parser(prog_name)
129 parser.add_argument(
130 "queue_name",
131 metavar="<queue_name>",
132 help="Name of the queue")
133 return parser
134
135 def take_action(self, parsed_args):
136 client = _get_client(self, parsed_args)
137 queue_name = parsed_args.queue_name
138 queue = client.queue(queue_name, auto_create=False)
139
140 try:
141 stats = queue.stats
142 except errors.ResourceNotFound:
143 raise RuntimeError('Queue(%s) does not exist.' % queue_name)
144
145 columns = ("Stats",)
146 data = dict(stats=stats)
147 return columns, utils.get_dict_properties(data, columns)
148
149
150 class SetQueueMetadata(command.Command):
151 """Set queue metadata"""
152
153 _description = _("Set queue metadata")
154 log = logging.getLogger(__name__ + ".SetQueueMetadata")
155
156 def get_parser(self, prog_name):
157 parser = super().get_parser(prog_name)
158 parser.add_argument(
159 "queue_name",
160 metavar="<queue_name>",
161 help="Name of the queue")
162 parser.add_argument(
163 "queue_metadata",
164 metavar="<queue_metadata>",
165 help="Queue metadata, All the metadata of "
166 "the queue will be replaced by queue_metadata")
167 return parser
168
169 def take_action(self, parsed_args):
170 client = _get_client(self, parsed_args)
171 queue_name = parsed_args.queue_name
172 queue_metadata = parsed_args.queue_metadata
173
174 try:
175 valid_metadata = json.loads(queue_metadata)
176 except ValueError:
177 raise RuntimeError("Queue metadata(%s) is not a valid json." %
178 queue_metadata)
179
180 client.queue(queue_name, auto_create=False).\
181 metadata(new_meta=valid_metadata)
182
183
184 class GetQueueMetadata(command.ShowOne):
185 """Get queue metadata"""
186
187 _description = _("Get queue metadata")
188 log = logging.getLogger(__name__ + ".GetQueueMetadata")
189
190 def get_parser(self, prog_name):
191 parser = super().get_parser(prog_name)
192 parser.add_argument(
193 "queue_name",
194 metavar="<queue_name>",
195 help="Name of the queue")
196 return parser
197
198 def take_action(self, parsed_args):
199 client = _get_client(self, parsed_args)
200 queue_name = parsed_args.queue_name
201 queue = client.queue(queue_name, auto_create=False)
202
203 columns = ("Metadata",)
204 data = dict(metadata=queue.metadata())
205 return columns, utils.get_dict_properties(data, columns)
206
207
208 class PostMessages(command.Command):
209 """Post messages for a given queue"""
210
211 _description = _("Post messages for a given queue")
212 log = logging.getLogger(__name__ + ".PostMessages")
213
214 def get_parser(self, prog_name):
215 parser = super().get_parser(prog_name)
216 parser.add_argument(
217 "queue_name",
218 metavar="<queue_name>",
219 help="Name of the queue")
220 parser.add_argument(
221 "messages",
222 type=json.loads,
223 metavar="<messages>",
224 help="Messages to be posted.")
225 parser.add_argument(
226 "--client-id",
227 metavar="<client_id>",
228 default=os.environ.get("OS_MESSAGE_CLIENT_ID"),
229 help="A UUID for each client instance.")
230 return parser
231
232 def take_action(self, parsed_args):
233 client = _get_client(self, parsed_args)
234
235 if not parsed_args.client_id:
236 raise AttributeError("<--client-id> option is missing and "
237 "environment variable OS_MESSAGE_CLIENT_ID "
238 "is not set. Please at least either pass in "
239 "the client id or set the environment "
240 "variable")
241 else:
242 client.client_uuid = parsed_args.client_id
243
244 queue = client.queue(parsed_args.queue_name)
245 queue.post(parsed_args.messages)
246
247
248 class ListMessages(command.Lister):
249 """List all messages for a given queue"""
250
251 _description = _("List all messages for a given queue")
252 log = logging.getLogger(__name__ + ".ListMessages")
253
254 def get_parser(self, prog_name):
255 parser = super().get_parser(prog_name)
256 parser.add_argument(
257 "queue_name",
258 metavar="<queue_name>",
259 help="Name of the queue")
260 parser.add_argument(
261 "--message-ids",
262 metavar="<message_ids>",
263 help="List of messages' ids to retrieve")
264 parser.add_argument(
265 "--limit",
266 metavar="<limit>",
267 type=int,
268 help="Maximum number of messages to get")
269 parser.add_argument(
270 "--echo",
271 action="store_true",
272 help="Whether to get this client's own messages")
273 parser.add_argument(
274 "--include-claimed",
275 action="store_true",
276 help="Whether to include claimed messages")
277 parser.add_argument(
278 "--include-delayed",
279 action="store_true",
280 help="Whether to include delayed messages")
281 parser.add_argument(
282 "--client-id",
283 metavar="<client_id>",
284 default=os.environ.get("OS_MESSAGE_CLIENT_ID"),
285 help="A UUID for each client instance.")
286 return parser
287
288 def take_action(self, parsed_args):
289 client = _get_client(self, parsed_args)
290
291 if not parsed_args.client_id:
292 raise AttributeError("<--client-id> option is missing and "
293 "environment variable OS_MESSAGE_CLIENT_ID "
294 "is not set. Please at least either pass in "
295 "the client id or set the environment "
296 "variable")
297 else:
298 client.client_uuid = parsed_args.client_id
299
300 kwargs = {}
301 if parsed_args.limit is not None:
302 kwargs["limit"] = parsed_args.limit
303 if parsed_args.echo is not None:
304 kwargs["echo"] = parsed_args.echo
305 if parsed_args.include_claimed is not None:
306 kwargs["include_claimed"] = parsed_args.include_claimed
307 if parsed_args.include_delayed is not None:
308 kwargs["include_delayed"] = parsed_args.include_delayed
309
310 queue = client.queue(parsed_args.queue_name)
311
312 if parsed_args.message_ids:
313 messages = queue.messages(parsed_args.message_ids.split(','),
314 **kwargs)
315 else:
316 messages = queue.messages(**kwargs)
317
318 columns = ("ID", "Body", "TTL", "Age", "Claim ID", "Checksum")
319 return (columns,
320 (utils.get_item_properties(s, columns) for s in messages))
321
322
323 class PurgeQueue(command.Command):
324 """Purge a queue"""
325
326 _description = _("Purge a queue")
327 log = logging.getLogger(__name__ + ".PurgeQueue")
328
329 def get_parser(self, prog_name):
330 parser = super().get_parser(prog_name)
331 parser.add_argument(
332 "queue_name",
333 metavar="<queue_name>",
334 help="Name of the queue")
335 parser.add_argument(
336 "--resource_types",
337 metavar="<resource_types>",
338 action='append',
339 choices=['messages', 'subscriptions'],
340 help="Resource types want to be purged.")
341 return parser
342
343 def take_action(self, parsed_args):
344 client = _get_client(self, parsed_args)
345 queue_name = parsed_args.queue_name
346 client.queue(queue_name).purge(
347 resource_types=parsed_args.resource_types)
348
349
350 class CreatePool(command.ShowOne):
351 """Create a pool"""
352
353 _description = _("Create a pool")
354 log = logging.getLogger(__name__ + ".CreatePool")
355
356 def get_parser(self, prog_name):
357 parser = super().get_parser(prog_name)
358 parser.add_argument(
359 "pool_name",
360 metavar="<pool_name>",
361 help="Name of the pool")
362 parser.add_argument(
363 "pool_uri",
364 metavar="<pool_uri>",
365 help="Storage engine URI")
366 parser.add_argument(
367 "pool_weight",
368 type=int,
369 metavar="<pool_weight>",
370 help="weight of the pool")
371 parser.add_argument(
372 "--flavor",
373 metavar="<flavor>",
374 help="Flavor of the pool")
375 parser.add_argument(
376 "--pool_options",
377 type=json.loads,
378 default={},
379 metavar="<pool_options>",
380 help="An optional request component "
381 "related to storage-specific options")
382
383 return parser
384
385 def take_action(self, parsed_args):
386 client = _get_client(self, parsed_args)
387 kw_arg = {
388 'uri': parsed_args.pool_uri,
389 'weight': parsed_args.pool_weight,
390 'options': parsed_args.pool_options
391 }
392
393 if parsed_args.flavor:
394 kw_arg.update({'flavor': parsed_args.flavor})
395
396 data = client.pool(parsed_args.pool_name, **kw_arg)
397
398 if not data:
399 raise RuntimeError('Failed to create pool(%s).' %
400 parsed_args.pool_name)
401
402 columns = ('Name', 'Weight', 'URI', 'Flavor', 'Options')
403 return columns, utils.get_item_properties(data, columns)
404
405
406 class ShowPool(command.ShowOne):
407 """Display pool details"""
408
409 _description = _("Display pool details")
410 log = logging.getLogger(__name__ + ".ShowPool")
411
412 def get_parser(self, prog_name):
413 parser = super().get_parser(prog_name)
414 parser.add_argument(
415 "pool_name",
416 metavar="<pool_name>",
417 help="Pool to display (name)",
418 )
419 return parser
420
421 def take_action(self, parsed_args):
422 client = _get_client(self, parsed_args)
423
424 pool_data = client.pool(parsed_args.pool_name,
425 auto_create=False).get()
426 columns = ('Name', 'Weight', 'URI', 'Flavor', 'Options')
427 return columns, utils.get_dict_properties(pool_data, columns)
428
429
430 class UpdatePool(command.ShowOne):
431 """Update a pool attribute"""
432
433 _description = _("Update a pool attribute")
434 log = logging.getLogger(__name__ + ".UpdatePool")
435
436 def get_parser(self, prog_name):
437 parser = super().get_parser(prog_name)
438 parser.add_argument(
439 "pool_name",
440 metavar="<pool_name>",
441 help="Name of the pool")
442 parser.add_argument(
443 "--pool_uri",
444 metavar="<pool_uri>",
445 help="Storage engine URI")
446 parser.add_argument(
447 "--pool_weight",
448 type=int,
449 metavar="<pool_weight>",
450 help="Weight of the pool")
451 parser.add_argument(
452 "--flavor",
453 metavar="<flavor>",
454 help="Flavor of the pool")
455 parser.add_argument(
456 "--pool_options",
457 type=json.loads,
458 metavar="<pool_options>",
459 help="An optional request component "
460 "related to storage-specific options")
461 return parser
462
463 def take_action(self, parsed_args):
464 client = _get_client(self, parsed_args)
465 kw_arg = {}
466
467 if parsed_args.pool_uri:
468 kw_arg["uri"] = parsed_args.pool_uri
469 if parsed_args.pool_weight:
470 kw_arg["weight"] = parsed_args.pool_weight
471 if parsed_args.flavor:
472 kw_arg["flavor"] = parsed_args.flavor
473 if parsed_args.pool_options:
474 kw_arg["options"] = parsed_args.pool_options
475
476 pool_obj = client.pool(parsed_args.pool_name, auto_create=False)
477 pool_obj.update(kw_arg)
478 pool_data = pool_obj.get()
479 columns = ('Name', 'Weight', 'URI', 'Flavor', 'Options')
480 return columns, utils.get_dict_properties(pool_data, columns)
481
482
483 class DeletePool(command.Command):
484 """Delete a pool"""
485
486 _description = _("Delete a pool")
487 log = logging.getLogger(__name__ + ".DeletePool")
488
489 def get_parser(self, prog_name):
490 parser = super().get_parser(prog_name)
491 parser.add_argument(
492 "pool_name",
493 metavar="<pool_name>",
494 help="Name of the pool")
495 return parser
496
497 def take_action(self, parsed_args):
498 client = _get_client(self, parsed_args)
499 pool_name = parsed_args.pool_name
500 client.pool(pool_name, auto_create=False).delete()
501
502
503 class ListPools(command.Lister):
504 """List available Pools"""
505
506 _description = _("List available Pools")
507 log = logging.getLogger(__name__ + ".ListPools")
508
509 def get_parser(self, prog_name):
510 parser = super().get_parser(prog_name)
511 parser.add_argument(
512 "--marker",
513 metavar="<pool_name>",
514 help="Pool's paging marker")
515 parser.add_argument(
516 "--limit",
517 metavar="<limit>",
518 help="Page size limit")
519 parser.add_argument(
520 "--detailed",
521 action="store_true",
522 help="Detailed output")
523
524 return parser
525
526 def take_action(self, parsed_args):
527 client = _get_client(self, parsed_args)
528
529 kwargs = {}
530 columns = ["Name", "Weight", "URI", "Flavor"]
531 if parsed_args.marker is not None:
532 kwargs["marker"] = parsed_args.marker
533 if parsed_args.limit is not None:
534 kwargs["limit"] = parsed_args.limit
535 if parsed_args.detailed is not None and parsed_args.detailed:
536 kwargs["detailed"] = parsed_args.detailed
537 columns.append("Options")
538
539 data = client.pools(**kwargs)
540 columns = tuple(columns)
541 return (columns,
542 (utils.get_item_properties(s, columns) for s in data))
543
544
545 class DeleteFlavor(command.Command):
546 """Delete a pool flavor"""
547
548 _description = _("Delete a pool flavor")
549 log = logging.getLogger(__name__ + ".DeleteFlavor")
550
551 def get_parser(self, prog_name):
552 parser = super().get_parser(prog_name)
553 parser.add_argument(
554 "flavor_name",
555 metavar="<flavor_name>",
556 help="Name of the flavor")
557 return parser
558
559 def take_action(self, parsed_args):
560 client = _get_client(self, parsed_args)
561 flavor_name = parsed_args.flavor_name
562 client.flavor(flavor_name, auto_create=False).delete()
563
564
565 class ShowFlavor(command.ShowOne):
566 """Display pool flavor details"""
567
568 _description = _("Display pool flavor details")
569 log = logging.getLogger(__name__ + ".ShowFlavor")
570
571 def get_parser(self, prog_name):
572 parser = super().get_parser(prog_name)
573 parser.add_argument(
574 "flavor_name",
575 metavar="<flavor_name>",
576 help="Flavor to display (name)",
577 )
578 return parser
579
580 def take_action(self, parsed_args):
581 self.log.debug("take_action(%s)", parsed_args)
582 client = self.app.client_manager.messaging
583 flavor_data = client.flavor(parsed_args.flavor_name,
584 auto_create=False).get()
585 columns = ('Name', 'Pool list', 'Capabilities')
586 return columns, utils.get_dict_properties(flavor_data, columns)
587
588
589 class ListFlavors(command.Lister):
590 """List available pool flavors"""
591
592 _description = _("List available pool flavors")
593 log = logging.getLogger(__name__ + ".ListFlavors")
594
595 def get_parser(self, prog_name):
596 parser = super().get_parser(prog_name)
597 parser.add_argument(
598 "--marker",
599 metavar="<flavor_name>",
600 help="Flavor's paging marker")
601 parser.add_argument(
602 "--limit",
603 metavar="<limit>",
604 help="Page size limit")
605 parser.add_argument(
606 "--detailed",
607 action="store_true",
608 help="If show detailed capabilities of flavor")
609 return parser
610
611 def take_action(self, parsed_args):
612 self.log.debug("take_action(%s)" % parsed_args)
613
614 client = self.app.client_manager.messaging
615
616 kwargs = {'detailed': parsed_args.detailed}
617 if parsed_args.marker is not None:
618 kwargs["marker"] = parsed_args.marker
619 if parsed_args.limit is not None:
620 kwargs["limit"] = parsed_args.limit
621 data = client.flavors(**kwargs)
622 columns = ("Name", 'Pool list')
623 if parsed_args.detailed:
624 columns = ("Name", 'Pool list', 'Capabilities')
625 return (columns,
626 (utils.get_item_properties(s, columns) for s in data))
627
628
629 class UpdateFlavor(command.ShowOne):
630 """Update a flavor's attributes"""
631
632 _description = _("Update a flavor's attributes")
633 log = logging.getLogger(__name__ + ".UpdateFlavor")
634
635 def get_parser(self, prog_name):
636 parser = super().get_parser(prog_name)
637 parser.add_argument(
638 "flavor_name",
639 metavar="<flavor_name>",
640 help="Name of the flavor")
641 parser.add_argument(
642 "--pool_list",
643 metavar="<pool_list>",
644 help="Pool list the flavor sits on")
645 parser.add_argument(
646 "--capabilities",
647 metavar="<capabilities>",
648 type=json.loads,
649 help="Describes flavor-specific capabilities.")
650 return parser
651
652 def take_action(self, parsed_args):
653 self.log.debug("take_action(%s)" % parsed_args)
654 client = self.app.client_manager.messaging
655 kwargs = {}
656 if parsed_args.pool_list:
657 pool_list = parsed_args.pool_list.split(',')
658 kwargs['pool_list'] = pool_list
659 if parsed_args.capabilities:
660 kwargs['capabilities'] = json.loads(parsed_args.capabilities)
661
662 flavor = client.flavor(parsed_args.flavor_name, auto_create=False)
663 columns = ('Name', 'Pool_list', 'Capabilities')
664 flavor.update(kwargs)
665 flavor_data = flavor.get()
666 return columns, utils.get_dict_properties(flavor_data, columns)
667
668
669 class CreateFlavor(command.ShowOne):
670 """Create a pool flavor"""
671
672 _description = _("Create a pool flavor")
673 log = logging.getLogger(__name__ + ".CreateFlavor")
674
675 def get_parser(self, prog_name):
676 parser = super().get_parser(prog_name)
677 parser.add_argument(
678 "flavor_name",
679 metavar="<flavor_name>",
680 help="Name of the flavor")
681 parser.add_argument(
682 "--pool_list",
683 metavar="<pool_list>",
684 help="Pool list for flavor")
685 return parser
686
687 def take_action(self, parsed_args):
688 self.log.debug("take_action(%s)" % parsed_args)
689
690 client = self.app.client_manager.messaging
691
692 pool_list = None
693 if parsed_args.pool_list:
694 pool_list = parsed_args.pool_list.split(',')
695 data = client.flavor(parsed_args.flavor_name,
696 pool_list=pool_list)
697
698 columns = ('Name', 'Pool list', 'Capabilities')
699 return columns, utils.get_item_properties(data, columns)
700
701
702 class CreateSubscription(command.ShowOne):
703 """Create a subscription for queue"""
704
705 _description = _("Create a subscription for queue")
706 log = logging.getLogger(__name__ + ".CreateSubscription")
707
708 def get_parser(self, prog_name):
709 parser = super().get_parser(prog_name)
710 parser.add_argument(
711 "queue_name",
712 metavar="<queue_name>",
713 help="Name of the queue to subscribe to")
714 parser.add_argument(
715 "subscriber",
716 metavar="<subscriber>",
717 help="Subscriber which will be notified")
718 parser.add_argument(
719 "ttl",
720 metavar="<ttl>",
721 type=int,
722 help="Time to live of the subscription in seconds")
723 parser.add_argument(
724 "--options",
725 type=json.loads,
726 default={},
727 metavar="<options>",
728 help="Metadata of the subscription in JSON format")
729
730 return parser
731
732 def take_action(self, parsed_args):
733 client = _get_client(self, parsed_args)
734 kwargs = {'options': parsed_args.options}
735 if parsed_args.subscriber:
736 kwargs['subscriber'] = parsed_args.subscriber
737 if parsed_args.subscriber:
738 kwargs['ttl'] = parsed_args.ttl
739
740 data = client.subscription(parsed_args.queue_name, **kwargs)
741
742 if not data:
743 raise RuntimeError('Failed to create subscription for (%s).' %
744 parsed_args.subscriber)
745
746 columns = ('ID', 'Subscriber', 'TTL', 'Options')
747 return columns, utils.get_item_properties(data, columns)
748
749
750 class UpdateSubscription(command.ShowOne):
751 """Update a subscription"""
752
753 _description = _("Update a subscription")
754 log = logging.getLogger(__name__ + ".UpdateSubscription")
755
756 def get_parser(self, prog_name):
757 parser = super().get_parser(prog_name)
758 parser.add_argument(
759 "queue_name",
760 metavar="<queue_name>",
761 help="Name of the queue to subscribe to")
762 parser.add_argument(
763 "subscription_id",
764 metavar="<subscription_id>",
765 help="ID of the subscription"
766 )
767 parser.add_argument(
768 "--subscriber",
769 metavar="<subscriber>",
770 help="Subscriber which will be notified")
771 parser.add_argument(
772 "--ttl",
773 metavar="<ttl>",
774 type=int,
775 help="Time to live of the subscription in seconds")
776 parser.add_argument(
777 "--options",
778 type=json.loads,
779 default={},
780 metavar="<options>",
781 help="Metadata of the subscription in JSON format")
782
783 return parser
784
785 def take_action(self, parsed_args):
786 client = _get_client(self, parsed_args)
787 data = {'subscriber': parsed_args.subscriber,
788 'ttl': parsed_args.ttl,
789 'options': parsed_args.options}
790
791 kwargs = {'id': parsed_args.subscription_id}
792 subscription = client.subscription(parsed_args.queue_name,
793 auto_create=False, **kwargs)
794
795 subscription.update(data)
796
797 columns = ('ID', 'Subscriber', 'TTL', 'Options')
798 return columns, utils.get_item_properties(data, columns)
799
800
801 class DeleteSubscription(command.Command):
802 """Delete a subscription"""
803
804 _description = _("Delete a subscription")
805 log = logging.getLogger(__name__ + ".DeleteSubscription")
806
807 def get_parser(self, prog_name):
808 parser = super().get_parser(prog_name)
809 parser.add_argument(
810 "queue_name",
811 metavar="<queue_name>",
812 help="Name of the queue for the subscription")
813 parser.add_argument(
814 "subscription_id",
815 metavar="<subscription_id>",
816 help="ID of the subscription"
817 )
818 return parser
819
820 def take_action(self, parsed_args):
821 client = _get_client(self, parsed_args)
822 client.subscription(parsed_args.queue_name,
823 id=parsed_args.subscription_id,
824 auto_create=False).delete()
825
826
827 class ShowSubscription(command.ShowOne):
828 """Display subscription details"""
829
830 _description = _("Display subscription details")
831 log = logging.getLogger(__name__ + ".ShowSubscription")
832
833 def get_parser(self, prog_name):
834 parser = super().get_parser(prog_name)
835 parser.add_argument(
836 "queue_name",
837 metavar="<queue_name>",
838 help="Name of the queue to subscribe to"
839 )
840 parser.add_argument(
841 "subscription_id",
842 metavar="<subscription_id>",
843 help="ID of the subscription"
844 )
845 return parser
846
847 def take_action(self, parsed_args):
848 client = _get_client(self, parsed_args)
849 kwargs = {'id': parsed_args.subscription_id}
850 pool_data = client.subscription(parsed_args.queue_name,
851 **kwargs)
852 columns = ('ID', 'Subscriber', 'TTL', 'Age', 'Confirmed', 'Options')
853 return columns, utils.get_dict_properties(pool_data.__dict__, columns)
854
855
856 class ListSubscriptions(command.Lister):
857 """List available subscriptions"""
858
859 _description = _("List available subscriptions")
860 log = logging.getLogger(__name__ + ".ListSubscriptions")
861
862 def get_parser(self, prog_name):
863 parser = super().get_parser(prog_name)
864 parser.add_argument(
865 "queue_name",
866 metavar="<queue_name>",
867 help="Name of the queue to subscribe to")
868 parser.add_argument(
869 "--marker",
870 metavar="<subscription_id>",
871 help="Subscription's paging marker, "
872 "the ID of the last subscription of the previous page")
873 parser.add_argument(
874 "--limit",
875 metavar="<limit>",
876 help="Page size limit, default value is 20")
877 return parser
878
879 def take_action(self, parsed_args):
880 self.log.debug("take_action(%s)" % parsed_args)
881
882 client = self.app.client_manager.messaging
883
884 kwargs = {'queue_name': parsed_args.queue_name}
885 if parsed_args.marker is not None:
886 kwargs["marker"] = parsed_args.marker
887 if parsed_args.limit is not None:
888 kwargs["limit"] = parsed_args.limit
889
890 data = client.subscriptions(**kwargs)
891 columns = ('ID', 'Subscriber', 'TTL', 'Age', 'Confirmed', 'Options')
892 return (columns,
893 (utils.get_item_properties(s, columns) for s in data))
894
895
896 class CreateClaim(command.Lister):
897 """Create claim and return a list of claimed messages"""
898
899 _description = _("Create claim and return a list of claimed messages")
900 log = logging.getLogger(__name__ + ".CreateClaim")
901
902 def get_parser(self, prog_name):
903 parser = super().get_parser(prog_name)
904 parser.add_argument(
905 "queue_name",
906 metavar="<queue_name>",
907 help="Name of the queue to be claim")
908 parser.add_argument(
909 "--ttl",
910 metavar="<ttl>",
911 type=int,
912 default=300,
913 help="Time to live in seconds for claim")
914 parser.add_argument(
915 "--grace",
916 metavar="<grace>",
917 type=int,
918 default=60,
919 help="The message grace period in seconds")
920 parser.add_argument(
921 "--limit",
922 metavar="<limit>",
923 type=int,
924 default=10,
925 help="Claims a set of messages, up to limit")
926
927 return parser
928
929 def take_action(self, parsed_args):
930 client = _get_client(self, parsed_args)
931
932 kwargs = {}
933 if parsed_args.ttl is not None:
934 kwargs["ttl"] = parsed_args.ttl
935 if parsed_args.grace is not None:
936 kwargs["grace"] = parsed_args.grace
937 if parsed_args.limit is not None:
938 kwargs["limit"] = parsed_args.limit
939
940 queue = client.queue(parsed_args.queue_name, auto_create=False)
941 keys = ("claim_id", "id", "ttl", "age", 'body', "checksum")
942 columns = ("Claim_ID", "Message_ID", "TTL", "Age", "Messages",
943 "Checksum")
944 data = queue.claim(**kwargs)
945 return (columns,
946 (utils.get_item_properties(s, keys) for s in data))
947
948
949 class QueryClaim(command.Lister):
950 """Display claim details"""
951
952 _description = _("Display claim details")
953 log = logging.getLogger(__name__ + ".QueryClaim")
954
955 def get_parser(self, prog_name):
956 parser = super().get_parser(prog_name)
957 parser.add_argument(
958 "queue_name",
959 metavar="<queue_name>",
960 help="Name of the claimed queue")
961 parser.add_argument(
962 "claim_id",
963 metavar="<claim_id>",
964 help="ID of the claim")
965
966 return parser
967
968 def take_action(self, parsed_args):
969 client = _get_client(self, parsed_args)
970
971 queue = client.queue(parsed_args.queue_name, auto_create=False)
972 keys = ("_id", "age", "ttl", "body")
973 columns = ("Message_ID", "Age", "TTL", "Message")
974 data = queue.claim(id=parsed_args.claim_id)
975
976 return (columns,
977 (utils.get_item_properties(s, keys) for s in data))
978
979
980 class RenewClaim(command.Lister):
981 """Renew a claim"""
982
983 _description = _("Renew a claim")
984 log = logging.getLogger(__name__ + ".RenewClaim")
985
986 def get_parser(self, prog_name):
987 parser = super().get_parser(prog_name)
988 parser.add_argument(
989 "queue_name",
990 metavar="<queue_name>",
991 help="Name of the claimed queue")
992 parser.add_argument(
993 "claim_id",
994 metavar="<claim_id>",
995 help="Claim ID")
996 parser.add_argument(
997 "--ttl",
998 metavar="<ttl>",
999 type=int,
1000 help="Time to live in seconds for claim")
1001 parser.add_argument(
1002 "--grace",
1003 metavar="<grace>",
1004 type=int,
1005 help="The message grace period in seconds")
1006
1007 return parser
1008
1009 def take_action(self, parsed_args):
1010 client = _get_client(self, parsed_args)
1011
1012 queue = client.queue(parsed_args.queue_name, auto_create=False)
1013 kwargs = {}
1014 if parsed_args.ttl is not None:
1015 kwargs["ttl"] = parsed_args.ttl
1016 if parsed_args.grace is not None:
1017 kwargs["grace"] = parsed_args.grace
1018
1019 claim_obj = queue.claim(id=parsed_args.claim_id)
1020 claim_obj.update(**kwargs)
1021 data = claim_obj
1022 keys = ("_id", "age", "ttl", "body")
1023 columns = ("Message_ID", "Age", "TTL", "Message")
1024
1025 return (columns,
1026 (utils.get_item_properties(s, keys) for s in data))
1027
1028
1029 class ReleaseClaim(command.Command):
1030 """Delete a claim"""
1031
1032 _description = _("Delete a claim")
1033 log = logging.getLogger(__name__ + ".ReleaseClaim")
1034
1035 def get_parser(self, prog_name):
1036 parser = super().get_parser(prog_name)
1037 parser.add_argument(
1038 "queue_name",
1039 metavar="<queue_name>",
1040 help="Name of the claimed queue")
1041 parser.add_argument(
1042 "claim_id",
1043 metavar="<claim_id>",
1044 help="Claim ID to delete")
1045
1046 return parser
1047
1048 def take_action(self, parsed_args):
1049 client = _get_client(self, parsed_args)
1050
1051 queue = client.queue(parsed_args.queue_name, auto_create=False)
1052 queue.claim(id=parsed_args.claim_id).delete()
1053
1054
1055 class CreateSignedUrl(command.ShowOne):
1056 """Create a pre-signed url"""
1057
1058 _description = _("Create a pre-signed url")
1059 log = logging.getLogger(__name__ + ".CreateSignedUrl")
1060
1061 def get_parser(self, prog_name):
1062 parser = super().get_parser(prog_name)
1063 parser.add_argument(
1064 "queue_name",
1065 metavar="<queue_name>",
1066 help="Name of the queue")
1067 parser.add_argument(
1068 "--paths",
1069 metavar="<paths>",
1070 default="messages",
1071 help="Allowed paths in a comma-separated list. "
1072 "Options: messages, subscriptions, claims")
1073 parser.add_argument(
1074 "--ttl-seconds",
1075 metavar="<ttl_seconds>",
1076 type=int,
1077 help="Length of time (in seconds) until the signature expires")
1078 parser.add_argument(
1079 "--methods",
1080 metavar="<methods>",
1081 default="GET",
1082 help="HTTP methods to allow as a comma-separated list. "
1083 "Options: GET, HEAD, OPTIONS, POST, PUT, DELETE")
1084 return parser
1085
1086 allowed_paths = ("messages", "subscriptions", "claims")
1087
1088 def take_action(self, parsed_args):
1089 client = self.app.client_manager.messaging
1090 queue = client.queue(parsed_args.queue_name, auto_create=False)
1091
1092 paths = parsed_args.paths.split(',')
1093 if not all([p in self.allowed_paths for p in paths]):
1094 print("Invalid path supplied! Received {}. "
1095 "Valid paths are: messages, subscriptions, "
1096 "claims".format(','.join(paths)))
1097
1098 kwargs = {
1099 'methods': parsed_args.methods.split(','),
1100 'paths': paths,
1101 }
1102
1103 if parsed_args.ttl_seconds:
1104 kwargs['ttl_seconds'] = parsed_args.ttl_seconds
1105
1106 data = queue.signed_url(**kwargs)
1107
1108 fields = ('Paths', 'Methods', 'Expires', 'Signature', 'Project ID')
1109 return fields, (
1110 ','.join(data['paths']),
1111 ','.join(data['methods']),
1112 data['expires'],
1113 data['signature'],
1114 data['project']
1115 )
1116
1117
1118 class Ping(command.ShowOne):
1119 """Check if Zaqar server is alive or not"""
1120
1121 _description = _("Check if Zaqar server is alive or not")
1122 log = logging.getLogger(__name__ + ".Ping")
1123
1124 def take_action(self, parsed_args):
1125 client = _get_client(self, parsed_args)
1126 columns = ('Pingable', )
1127 return columns, utils.get_dict_properties({'pingable': client.ping()},
1128 columns)
1129
1130
1131 class Health(command.Command):
1132 """Display detailed health status of Zaqar server"""
1133
1134 _description = _("Display detailed health status of Zaqar server")
1135 log = logging.getLogger(__name__ + ".Health")
1136
1137 def take_action(self, parsed_args):
1138 client = _get_client(self, parsed_args)
1139 health = client.health()
1140 print(json.dumps(health, indent=4, sort_keys=True))
1141
1142
1143 class HomeDoc(command.Command):
1144 """Display the resource doc of Zaqar server"""
1145
1146 _description = _("Display detailed resource doc of Zaqar server")
1147 log = logging.getLogger(__name__ + ".HomeDoc")
1148
1149 def take_action(self, parsed_args):
1150 client = _get_client(self, parsed_args)
1151 homedoc = client.homedoc()
1152 print(json.dumps(homedoc, indent=4, sort_keys=True))