Debian Codegraph @

zaqarclient/queues/v2/core.py

raw
1 # Copyright (c) 2013 Red Hat, Inc.
2 #
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain 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,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
12 # implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
15
16 """
17 This module defines a lower level API for queues' v2. This level of the
18 API is responsible for packing up the final request, sending it to the server
19 and handling asynchronous requests.
20
21 Functions present in this module assume that:
22
23 1. The transport instance is ready to `send` the
24 request to the server.
25
26 2. Transport instance holds the conf instance to use for this
27 request.
28 """
29
30 import datetime
31 import json
32
33 from oslo_utils import timeutils
34
35 import zaqarclient.transport.errors as errors
36
37
38 def _common_queue_ops(operation, transport, request, name, callback=None):
39 """Function for common operation
40
41 This is a lower level call to get a single
42 instance of queue.
43
44 :param transport: Transport instance to use
45 :type transport: `transport.base.Transport`
46 :param request: Request instance ready to be sent.
47 :type request: `transport.request.Request`
48 :param name: Queue reference name.
49 :type name: str
50 :param callback: Optional callable to use as callback.
51 If specified, this request will be sent asynchronously.
52 (IGNORED UNTIL ASYNC SUPPORT IS COMPLETE)
53 :type callback: Callable object.
54 """
55 request.operation = operation
56 request.params['queue_name'] = name
57 resp = transport.send(request)
58 return resp.deserialized_content
59
60
61 def queue_create(transport, request, name,
62 metadata=None, callback=None):
63 """Creates a queue
64
65 :param transport: Transport instance to use
66 :type transport: `transport.base.Transport`
67 :param request: Request instance ready to be sent.
68 :type request: `transport.request.Request`
69 :param name: Queue reference name.
70 :type name: str
71 :param metadata: Queue's metadata object.
72 :type metadata: `dict`
73 :param callback: Optional callable to use as callback.
74 If specified, this request will be sent asynchronously.
75 (IGNORED UNTIL ASYNC SUPPORT IS COMPLETE)
76 :type callback: Callable object.
77 """
78
79 request.operation = 'queue_create'
80 request.params['queue_name'] = name
81 request.content = metadata and json.dumps(metadata)
82
83 resp = transport.send(request)
84 return resp.deserialized_content
85
86
87 def queue_update(transport, request, name, metadata, callback=None):
88 """Updates a queue's metadata using PATCH
89
90 :param transport: Transport instance to use
91 :type transport: `transport.base.Transport`
92 :param request: Request instance ready to be sent.
93 :type request: `transport.request.Request`
94 :param name: Queue reference name.
95 :type name: str
96 :param metadata: Queue's metadata object.
97 :type metadata: `list`
98 :param callback: Optional callable to use as callback.
99 If specified, this request will be sent asynchronously.
100 (IGNORED UNTIL ASYNC SUPPORT IS COMPLETE)
101 :type callback: Callable object.
102 """
103
104 request.operation = 'queue_update'
105 request.params['queue_name'] = name
106 request.content = json.dumps(metadata)
107
108 resp = transport.send(request)
109 return resp.deserialized_content
110
111
112 def queue_exists(transport, request, name, callback=None):
113 """Checks if the queue exists."""
114 try:
115 _common_queue_ops('queue_exists', transport,
116 request, name, callback=callback)
117 return True
118 except errors.ResourceNotFound:
119 return False
120
121
122 def queue_get(transport, request, name, callback=None):
123 """Retrieve a queue."""
124 return _common_queue_ops('queue_get', transport,
125 request, name, callback=callback)
126
127
128 def queue_get_metadata(transport, request, name, callback=None):
129 """Gets queue metadata."""
130 return _common_queue_ops('queue_get_metadata', transport,
131 request, name, callback=callback)
132
133
134 def queue_set_metadata(transport, request, name, metadata, callback=None):
135 """Sets queue metadata."""
136
137 request.operation = 'queue_set_metadata'
138 request.params['queue_name'] = name
139 request.content = json.dumps(metadata)
140
141 transport.send(request)
142
143
144 def queue_get_stats(transport, request, name):
145 return _common_queue_ops('queue_get_stats', transport,
146 request, name)
147
148
149 def queue_delete(transport, request, name, callback=None):
150 """Deletes queue."""
151 return _common_queue_ops('queue_delete', transport,
152 request, name, callback=callback)
153
154
155 def queue_list(transport, request, callback=None, **kwargs):
156 """Gets a list of queues
157
158 :param transport: Transport instance to use
159 :type transport: `transport.base.Transport`
160 :param request: Request instance ready to be sent.
161 :type request: `transport.request.Request`
162 :param callback: Optional callable to use as callback.
163 If specified, this request will be sent asynchronously.
164 (IGNORED UNTIL ASYNC SUPPORT IS COMPLETE)
165 :type callback: Callable object.
166 :param kwargs: Optional arguments for this operation.
167 - marker: Where to start getting queues from.
168 - limit: Maximum number of queues to get.
169 """
170
171 request.operation = 'queue_list'
172
173 request.params.update(kwargs)
174
175 resp = transport.send(request)
176
177 if not resp.content:
178 return {'links': [], 'queues': []}
179
180 return resp.deserialized_content
181
182
183 def queue_purge(transport, request, name, resource_types=None):
184 """Purge resources under a queue
185
186 :param transport: Transport instance to use
187 :type transport: `transport.base.Transport`
188 :param request: Request instance ready to be sent.
189 :type request: `transport.request.Request`
190 :param name: Queue reference name.
191 :type name: str
192 :param resource_types: Resource types will be purged
193 :type resource_types: `list`
194 """
195 request.operation = 'queue_purge'
196 request.params['queue_name'] = name
197 if resource_types:
198 request.content = json.dumps({'resource_types': resource_types})
199
200 resp = transport.send(request)
201 return resp.deserialized_content
202
203
204 def message_list(transport, request, queue_name, callback=None, **kwargs):
205 """Gets a list of messages in queue `queue_name`
206
207 :param transport: Transport instance to use
208 :type transport: `transport.base.Transport`
209 :param request: Request instance ready to be sent.
210 :type request: `transport.request.Request`
211 :param queue_name: Queue reference name.
212 :type queue_name: str
213 :param callback: Optional callable to use as callback.
214 If specified, this request will be sent asynchronously.
215 (IGNORED UNTIL ASYNC SUPPORT IS COMPLETE)
216 :type callback: Callable object.
217 :param kwargs: Optional arguments for this operation.
218 - marker: Where to start getting messages from.
219 - limit: Maximum number of messages to get.
220 - echo: Whether to get our own messages.
221 - include_claimed: Whether to include claimed
222 messages.
223 """
224
225 request.operation = 'message_list'
226 request.params['queue_name'] = queue_name
227
228 # NOTE(flaper87): Assume passed params
229 # are accepted by the API, if not, the
230 # API itself will raise an error.
231 request.params.update(kwargs)
232
233 resp = transport.send(request)
234
235 if not resp.content:
236 # NOTE(flaper87): We could also return None
237 # or an empty dict, however, we're giving
238 # more value to a consistent API here by
239 # returning a compliant dict with empty
240 # `links` and `messages`
241 return {'links': [], 'messages': []}
242
243 return resp.deserialized_content
244
245
246 def message_post(transport, request, queue_name, messages, callback=None):
247 """Post messages to `queue_name`
248
249 :param transport: Transport instance to use
250 :type transport: `transport.base.Transport`
251 :param request: Request instance ready to be sent.
252 :type request: `transport.request.Request`
253 :param queue_name: Queue reference name.
254 :type queue_name: str
255 :param messages: One or more messages to post.
256 :param messages: `list`
257 :param callback: Optional callable to use as callback.
258 If specified, this request will be sent asynchronously.
259 (IGNORED UNTIL ASYNC SUPPORT IS COMPLETE)
260 :type callback: Callable object.
261 """
262
263 request.operation = 'message_post'
264 request.params['queue_name'] = queue_name
265 request.content = json.dumps(messages)
266
267 resp = transport.send(request)
268 return resp.deserialized_content
269
270
271 def message_get(transport, request, queue_name, message_id, callback=None):
272 """Gets one message from the queue by id
273
274 :param transport: Transport instance to use
275 :type transport: `transport.base.Transport`
276 :param request: Request instance ready to be sent.
277 :type request: `transport.request.Request`
278 :param queue_name: Queue reference name.
279 :type queue_name: str
280 :param message_id: Message reference.
281 :param message_id: str
282 :param callback: Optional callable to use as callback.
283 If specified, this request will be sent asynchronously.
284 (IGNORED UNTIL ASYNC SUPPORT IS COMPLETE)
285 :type callback: Callable object.
286 """
287
288 request.operation = 'message_get'
289 request.params['queue_name'] = queue_name
290 request.params['message_id'] = message_id
291
292 resp = transport.send(request)
293 return resp.deserialized_content
294
295
296 def message_get_many(transport, request, queue_name, messages, callback=None):
297 """Gets many messages by id
298
299 :param transport: Transport instance to use
300 :type transport: `transport.base.Transport`
301 :param request: Request instance ready to be sent.
302 :type request: `transport.request.Request`
303 :param queue_name: Queue reference name.
304 :type queue_name: str
305 :param messages: Messages references.
306 :param messages: list of str
307 :param callback: Optional callable to use as callback.
308 If specified, this request will be sent asynchronously.
309 (IGNORED UNTIL ASYNC SUPPORT IS COMPLETE)
310 :type callback: Callable object.
311 """
312
313 request.operation = 'message_get_many'
314 request.params['queue_name'] = queue_name
315 request.params['ids'] = messages
316
317 resp = transport.send(request)
318 return resp.deserialized_content
319
320
321 def message_delete(transport, request, queue_name, message_id,
322 claim_id=None, callback=None):
323 """Deletes messages from `queue_name`
324
325 :param transport: Transport instance to use
326 :type transport: `transport.base.Transport`
327 :param request: Request instance ready to be sent.
328 :type request: `transport.request.Request`
329 :param queue_name: Queue reference name.
330 :type queue_name: str
331 :param message_id: Message reference.
332 :param message_id: str
333 :param callback: Optional callable to use as callback.
334 If specified, this request will be sent asynchronously.
335 (IGNORED UNTIL ASYNC SUPPORT IS COMPLETE)
336 :type callback: Callable object.
337 """
338
339 request.operation = 'message_delete'
340 request.params['queue_name'] = queue_name
341 request.params['message_id'] = message_id
342 if claim_id:
343 request.params['claim_id'] = claim_id
344
345 transport.send(request)
346
347
348 def message_delete_many(transport, request, queue_name,
349 ids, callback=None):
350 """Deletes `ids` messages from `queue_name`
351
352 :param transport: Transport instance to use
353 :type transport: `transport.base.Transport`
354 :param request: Request instance ready to be sent.
355 :type request: `transport.request.Request`
356 :param queue_name: Queue reference name.
357 :type queue_name: str
358 :param ids: Ids of the messages to delete
359 :type ids: List of str
360 :param callback: Optional callable to use as callback.
361 If specified, this request will be sent asynchronously.
362 (IGNORED UNTIL ASYNC SUPPORT IS COMPLETE)
363 :type callback: Callable object.
364 """
365
366 request.operation = 'message_delete_many'
367 request.params['queue_name'] = queue_name
368 request.params['ids'] = ids
369 transport.send(request)
370
371
372 def message_pop(transport, request, queue_name,
373 count, callback=None):
374 """Pops out `count` messages from `queue_name`
375
376 :param transport: Transport instance to use
377 :type transport: `transport.base.Transport`
378 :param request: Request instance ready to be sent.
379 :type request: `transport.request.Request`
380 :param queue_name: Queue reference name.
381 :type queue_name: str
382 :param count: Number of messages to pop.
383 :type count: int
384 :param callback: Optional callable to use as callback.
385 If specified, this request will be sent asynchronously.
386 (IGNORED UNTIL ASYNC SUPPORT IS COMPLETE)
387 :type callback: Callable object.
388 """
389
390 request.operation = 'message_delete_many'
391 request.params['queue_name'] = queue_name
392 request.params['pop'] = count
393
394 resp = transport.send(request)
395 return resp.deserialized_content
396
397
398 def claim_create(transport, request, queue_name, **kwargs):
399 """Creates a Claim `claim_id` on the queue `queue_name`
400
401 :param transport: Transport instance to use
402 :type transport: `transport.base.Transport`
403 :param request: Request instance ready to be sent.
404 :type request: `transport.request.Request`
405 """
406
407 request.operation = 'claim_create'
408 request.params['queue_name'] = queue_name
409
410 if 'limit' in kwargs:
411 request.params['limit'] = kwargs.pop('limit')
412
413 request.content = json.dumps(kwargs)
414
415 resp = transport.send(request)
416 return resp.deserialized_content
417
418
419 def claim_get(transport, request, queue_name, claim_id):
420 """Gets a Claim `claim_id`
421
422 :param transport: Transport instance to use
423 :type transport: `transport.base.Transport`
424 :param request: Request instance ready to be sent.
425 :type request: `transport.request.Request`
426 """
427
428 request.operation = 'claim_get'
429 request.params['queue_name'] = queue_name
430 request.params['claim_id'] = claim_id
431
432 resp = transport.send(request)
433 return resp.deserialized_content
434
435
436 def claim_update(transport, request, queue_name, claim_id, **kwargs):
437 """Updates a Claim `claim_id`
438
439 :param transport: Transport instance to use
440 :type transport: `transport.base.Transport`
441 :param request: Request instance ready to be sent.
442 :type request: `transport.request.Request`
443 """
444
445 request.operation = 'claim_update'
446 request.params['queue_name'] = queue_name
447 request.params['claim_id'] = claim_id
448 request.content = json.dumps(kwargs)
449
450 resp = transport.send(request)
451 return resp.deserialized_content
452
453
454 def claim_delete(transport, request, queue_name, claim_id):
455 """Deletes a Claim `claim_id`
456
457 :param transport: Transport instance to use
458 :type transport: `transport.base.Transport`
459 :param request: Request instance ready to be sent.
460 :type request: `transport.request.Request`
461 """
462 request.operation = 'claim_delete'
463 request.params['queue_name'] = queue_name
464 request.params['claim_id'] = claim_id
465
466 transport.send(request)
467
468
469 def pool_get(transport, request, pool_name, callback=None):
470 """Gets pool data
471
472 :param transport: Transport instance to use
473 :type transport: `transport.base.Transport`
474 :param request: Request instance ready to be sent.
475 :type request: `transport.request.Request`
476 :param pool_name: Pool reference name.
477 :type pool_name: str
478
479 """
480
481 request.operation = 'pool_get'
482 request.params['pool_name'] = pool_name
483
484 resp = transport.send(request)
485 return resp.deserialized_content
486
487
488 def pool_create(transport, request, pool_name, pool_data):
489 """Creates a pool called `pool_name`
490
491
492 :param transport: Transport instance to use
493 :type transport: `transport.base.Transport`
494 :param request: Request instance ready to be sent.
495 :type request: `transport.request.Request`
496 :param pool_name: Pool reference name.
497 :type pool_name: str
498 :param pool_data: Pool's properties, i.e: weight, uri, options.
499 :type pool_data: `dict`
500 """
501
502 request.operation = 'pool_create'
503 request.params['pool_name'] = pool_name
504 request.content = json.dumps(pool_data)
505 transport.send(request)
506
507
508 def pool_update(transport, request, pool_name, pool_data):
509 """Updates the pool `pool_name`
510
511 :param transport: Transport instance to use
512 :type transport: `transport.base.Transport`
513 :param request: Request instance ready to be sent.
514 :type request: `transport.request.Request`
515 :param pool_name: Pool reference name.
516 :type pool_name: str
517 :param pool_data: Pool's properties, i.e: weight, uri, options.
518 :type pool_data: `dict`
519 """
520
521 request.operation = 'pool_update'
522 request.params['pool_name'] = pool_name
523 request.content = json.dumps(pool_data)
524
525 resp = transport.send(request)
526 return resp.deserialized_content
527
528
529 def pool_list(transport, request, **kwargs):
530 """Gets a list of pools
531
532 :param transport: Transport instance to use
533 :type transport: `transport.base.Transport`
534 :param request: Request instance ready to be sent.
535 :type request: `transport.request.Request`
536 :param kwargs: Optional arguments for this operation.
537 - marker: Where to start getting pools from.
538 - limit: Maximum number of pools to get.
539 """
540
541 request.operation = 'pool_list'
542 request.params.update(kwargs)
543
544 resp = transport.send(request)
545
546 if not resp.content:
547 return {'links': [], 'pools': []}
548
549 return resp.deserialized_content
550
551
552 def pool_delete(transport, request, pool_name):
553 """Deletes the pool `pool_name`
554
555 :param transport: Transport instance to use
556 :type transport: `transport.base.Transport`
557 :param request: Request instance ready to be sent.
558 :type request: `transport.request.Request`
559 :param pool_name: Pool reference name.
560 :type pool_name: str
561 """
562
563 request.operation = 'pool_delete'
564 request.params['pool_name'] = pool_name
565 transport.send(request)
566
567
568 def flavor_create(transport, request, name, flavor_data):
569 """Creates a flavor called `name`
570
571 :param transport: Transport instance to use
572 :type transport: `transport.base.Transport`
573 :param request: Request instance ready to be sent.
574 :type request: `transport.request.Request`
575 :param name: Flavor reference name.
576 :type name: str
577 :param flavor_data: Flavor's properties, i.e: pool, capabilities.
578 :type flavor_data: `dict`
579 """
580
581 request.operation = 'flavor_create'
582 request.params['flavor_name'] = name
583 request.content = json.dumps(flavor_data)
584 transport.send(request)
585
586
587 def flavor_get(transport, request, flavor_name, callback=None):
588 """Gets flavor data
589
590 :param transport: Transport instance to use
591 :type transport: `transport.base.Transport`
592 :param request: Request instance ready to be sent.
593 :type request: `transport.request.Request`
594 :param flavor_name: Flavor reference name.
595 :type flavor_name: str
596
597 """
598
599 request.operation = 'flavor_get'
600 request.params['flavor_name'] = flavor_name
601
602 resp = transport.send(request)
603 return resp.deserialized_content
604
605
606 def flavor_update(transport, request, flavor_name, flavor_data):
607 """Updates the flavor `flavor_name`
608
609 :param transport: Transport instance to use
610 :type transport: `transport.base.Transport`
611 :param request: Request instance ready to be sent.
612 :type request: `transport.request.Request`
613 :param flavor_name: Flavor reference name.
614 :type flavor_name: str
615 :param flavor_data: Flavor's properties, i.e: pool, capabilities.
616 :type flavor_data: `dict`
617 """
618
619 request.operation = 'flavor_update'
620 request.params['flavor_name'] = flavor_name
621 request.content = json.dumps(flavor_data)
622
623 resp = transport.send(request)
624 return resp.deserialized_content
625
626
627 def flavor_list(transport, request, **kwargs):
628 """Gets a list of flavors
629
630 :param transport: Transport instance to use
631 :type transport: `transport.base.Transport`
632 :param request: Request instance ready to be sent.
633 :type request: `transport.request.Request`
634 :param kwargs: Optional arguments for this operation.
635 - marker: Where to start getting flavors from.
636 - limit: Maximum number of flavors to get.
637 """
638
639 request.operation = 'flavor_list'
640 request.params.update(kwargs)
641
642 resp = transport.send(request)
643
644 if not resp.content:
645 return {'links': [], 'flavors': []}
646
647 return resp.deserialized_content
648
649
650 def flavor_delete(transport, request, name):
651 """Deletes the flavor `name`
652
653 :param transport: Transport instance to use
654 :type transport: `transport.base.Transport`
655 :param request: Request instance ready to be sent.
656 :type request: `transport.request.Request`
657 :param name: Flavor reference name.
658 :type name: str
659 """
660
661 request.operation = 'flavor_delete'
662 request.params['flavor_name'] = name
663 transport.send(request)
664
665
666 def signed_url_create(transport, request, queue_name, paths=None,
667 ttl_seconds=None, project_id=None, methods=None):
668 """Creates a signed URL given a queue name
669
670 :param transport: Transport instance to use
671 :type transport: `transport.base.Transport`
672 :param request: Request instance ready to be sent.
673 :type request: `transport.request.Request`
674 :param queue_name: name of Queue for the URL to access
675 :type name: str
676 :param paths: Allowed actions. Options: messages, subscriptions, claims
677 :type name: list
678 :param ttl_seconds: Seconds the URL will be valid for, default 86400
679 :type name: int
680 :param project_id: defaults to None
681 :type name: str
682 :param methods: HTTP methods to allow, defaults to ["GET"]
683 :type name: `list`
684 """
685
686 request.operation = 'signed_url_create'
687 request.params['queue_name'] = queue_name
688
689 body = {}
690 if ttl_seconds is not None:
691 expiry = (timeutils.utcnow() + datetime.timedelta(seconds=ttl_seconds))
692 body['expires'] = expiry.isoformat()
693
694 if project_id is not None:
695 body['project_id'] = project_id
696
697 if paths is not None:
698 body['paths'] = paths
699
700 if methods is not None:
701 body['methods'] = methods
702
703 request.content = json.dumps(body)
704
705 resp = transport.send(request)
706 return resp.deserialized_content
707
708
709 def subscription_create(transport, request, queue_name, subscription_data):
710 """Creates a new subscription against the `queue_name`
711
712
713 :param transport: Transport instance to use
714 :type transport: `transport.base.Transport`
715 :param request: Request instance ready to be sent.
716 :type request: `transport.request.Request`
717 :param queue_name: Queue reference name.
718 :type queue_name: str
719 :param subscription_data: Subscription's properties, i.e: subscriber,
720 ttl, options.
721 :type subscription_data: `dict`
722 """
723
724 request.operation = 'subscription_create'
725 request.params['queue_name'] = queue_name
726 request.content = json.dumps(subscription_data)
727 resp = transport.send(request)
728
729 return resp.deserialized_content
730
731
732 def subscription_get(transport, request, queue_name, subscription_id):
733 """Gets a particular subscription data
734
735 :param transport: Transport instance to use
736 :type transport: `transport.base.Transport`
737 :param request: Request instance ready to be sent.
738 :type request: `transport.request.Request`
739 :param queue_name: Queue reference name.
740 :type queue_name: str
741 :param subscription_id: ID of subscription.
742 :type subscription_id: str
743
744 """
745
746 request.operation = 'subscription_get'
747 request.params['queue_name'] = queue_name
748 request.params['subscription_id'] = subscription_id
749
750 resp = transport.send(request)
751 return resp.deserialized_content
752
753
754 def subscription_update(transport, request, queue_name, subscription_id,
755 subscription_data):
756 """Updates the subscription
757
758 :param transport: Transport instance to use
759 :type transport: `transport.base.Transport`
760 :param request: Request instance ready to be sent.
761 :type request: `transport.request.Request`
762 :param queue_name: Queue reference name.
763 :type queue_name: str
764 :param subscription_id: ID of subscription.
765 :type subscription_id: str
766 :param subscription_data: Subscription's properties, i.e: subscriber,
767 ttl, options.
768 :type subscription_data: `dict`
769 """
770
771 request.operation = 'subscription_update'
772 request.params['queue_name'] = queue_name
773 request.params['subscription_id'] = subscription_id
774 request.content = json.dumps(subscription_data)
775
776 resp = transport.send(request)
777 return resp.deserialized_content
778
779
780 def subscription_delete(transport, request, queue_name, subscription_id):
781 """Deletes the subscription
782
783 :param transport: Transport instance to use
784 :type transport: `transport.base.Transport`
785 :param request: Request instance ready to be sent.
786 :type request: `transport.request.Request`
787 :param queue_name: Queue reference name.
788 :type queue_name: str
789 :param subscription_id: ID of subscription.
790 :type subscription_id: str
791 """
792
793 request.operation = 'subscription_delete'
794 request.params['queue_name'] = queue_name
795 request.params['subscription_id'] = subscription_id
796 transport.send(request)
797
798
799 def subscription_list(transport, request, queue_name, **kwargs):
800 """Gets a list of subscriptions
801
802 :param transport: Transport instance to use
803 :type transport: `transport.base.Transport`
804 :param request: Request instance ready to be sent.
805 :type request: `transport.request.Request`
806 :param queue_name: Queue reference name.
807 :type queue_name: str
808 :param kwargs: Optional arguments for this operation.
809 - marker: Where to start getting subscriptions from.
810 - limit: Maximum number of subscriptions to get.
811 """
812
813 request.operation = 'subscription_list'
814 request.params['queue_name'] = queue_name
815 request.params.update(kwargs)
816
817 resp = transport.send(request)
818
819 if not resp.content:
820 return {'links': [], 'subscriptions': []}
821
822 return resp.deserialized_content
823
824
825 def ping(transport, request, callback=None):
826 """Check the health of web head for load balancing
827
828 :param transport: Transport instance to use
829 :type transport: `transport.base.Transport`
830 :param request: Request instance ready to be sent.
831 :type request: `transport.request.Request`
832 :param callback: Optional callable to use as callback.
833 If specified, this request will be sent asynchronously.
834 (IGNORED UNTIL ASYNC SUPPORT IS COMPLETE)
835 :type callback: Callable object.
836 """
837
838 request.operation = 'ping'
839 try:
840 transport.send(request)
841 return True
842 except Exception:
843 return False
844
845
846 def health(transport, request, callback=None):
847 """Get detailed health status of Zaqar server
848
849 :param transport: Transport instance to use
850 :type transport: `transport.base.Transport`
851 :param request: Request instance ready to be sent.
852 :type request: `transport.request.Request`
853 :param callback: Optional callable to use as callback.
854 If specified, this request will be sent asynchronously.
855 (IGNORED UNTIL ASYNC SUPPORT IS COMPLETE)
856 :type callback: Callable object.
857 """
858
859 request.operation = 'health'
860 resp = transport.send(request)
861 return resp.deserialized_content
862
863
864 def homedoc(transport, request, callback=None):
865 """Get the detailed resource doc of Zaqar server
866
867 :param transport: Transport instance to use
868 :type transport: `transport.base.Transport`
869 :param request: Request instance ready to be sent.
870 :type request: `transport.request.Request`
871 :param callback: Optional callable to use as callback.
872 If specified, this request will be sent asynchronously.
873 (IGNORED UNTIL ASYNC SUPPORT IS COMPLETE)
874 :type callback: Callable object.
875 """
876
877 request.operation = 'homedoc'
878 resp = transport.send(request)
879 return resp.deserialized_content