Debian Codegraph @

src/message.pyx

raw
1 #-------------------------------------------------------------------------
2 # Copyright (c) Microsoft Corporation. All rights reserved.
3 # Licensed under the MIT License. See License.txt in the project root for
4 # license information.
5 #--------------------------------------------------------------------------
6
7 # Python imports
8 from enum import Enum
9 import logging
10
11 # C imports
12 from libc cimport stdint
13
14 cimport c_message
15 cimport c_amqp_definitions
16 cimport c_amqpvalue
17
18
19 _logger = logging.getLogger(__name__)
20
21
22 class MessageBodyType(Enum):
23 NoneType = c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_NONE
24 DataType = c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_DATA
25 SequenceType = c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_SEQUENCE
26 ValueType = c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_VALUE
27
28
29 cdef message_factory(c_message.MESSAGE_HANDLE value):
30 new_message = cMessage()
31 new_message.wrap(value)
32 return new_message
33
34
35 cpdef create_message():
36 new_message = cMessage()
37 new_message.create()
38 return new_message
39
40
41 cdef class cMessage(StructBase):
42
43 cdef c_message.MESSAGE_HANDLE _c_value
44
45 def __cinit__(self):
46 pass
47
48 def __dealloc__(self):
49 _logger.debug("Deallocating cMessage")
50 self.destroy()
51
52 cdef _create(self):
53 if <void*>self._c_value is NULL:
54 self._memory_error()
55
56 cpdef destroy(self):
57 try:
58 if <void*>self._c_value is not NULL:
59 _logger.debug("Destroying cMessage")
60 c_message.message_destroy(self._c_value)
61 except KeyboardInterrupt:
62 pass
63 finally:
64 self._c_value = <c_message.MESSAGE_HANDLE>NULL
65
66 cdef wrap(self, c_message.MESSAGE_HANDLE value):
67 self.destroy()
68 self._c_value = value
69 self._create()
70
71 cdef create(self):
72 self.destroy()
73 self._c_value = c_message.message_create()
74 self._create()
75
76 cpdef clone(self):
77 cdef c_message.MESSAGE_HANDLE value
78 value = c_message.message_clone(self._c_value)
79 if <void*>value == NULL:
80 self._value_error()
81 return message_factory(value)
82
83 @property
84 def header(self):
85 cdef c_amqp_definitions.HEADER_HANDLE value
86 if c_message.message_get_header(self._c_value, &value) == 0:
87 if <void*>value == NULL:
88 return None
89 new_obj = cHeader()
90 new_obj.wrap(value)
91 return new_obj
92 else:
93 self._value_error()
94
95 @header.setter
96 def header(self, cHeader value):
97 if value is None:
98 if c_message.message_set_header(
99 self._c_value, <c_amqp_definitions.HEADER_HANDLE>NULL) != 0:
100 self._value_error()
101 elif c_message.message_set_header(
102 self._c_value, <c_amqp_definitions.HEADER_HANDLE>value._c_value) != 0:
103 self._value_error()
104
105 @property
106 def delivery_annotations(self):
107 cdef c_amqp_definitions.delivery_annotations value
108 if c_message.message_get_delivery_annotations(self._c_value, &value) == 0:
109 if <void*>value == NULL:
110 return None
111 new_obj = cDeliveryAnnotations()
112 new_obj.wrap(value)
113 return new_obj
114 else:
115 self._value_error()
116
117 @delivery_annotations.setter
118 def delivery_annotations(self, cDeliveryAnnotations value):
119 if value is None:
120 if c_message.message_set_delivery_annotations(
121 self._c_value, <c_amqp_definitions.delivery_annotations>NULL) != 0:
122 self._value_error()
123 elif c_message.message_set_delivery_annotations(
124 self._c_value, <c_amqp_definitions.delivery_annotations>value._c_value) != 0:
125 self._value_error()
126
127 @property
128 def message_annotations(self):
129 cdef c_amqp_definitions.message_annotations value
130 if c_message.message_get_message_annotations(self._c_value, &value) == 0:
131 if <void*>value == NULL:
132 return None
133 new_obj = cMessageAnnotations()
134 new_obj.wrap(value)
135 return new_obj
136 else:
137 self._value_error()
138
139 @message_annotations.setter
140 def message_annotations(self, cMessageAnnotations value):
141 if value is None:
142 if c_message.message_set_message_annotations(
143 self._c_value, <c_amqp_definitions.message_annotations>NULL) != 0:
144 self._value_error()
145 elif c_message.message_set_message_annotations(
146 self._c_value, <c_amqp_definitions.message_annotations>value._c_value) != 0:
147 self._value_error()
148
149 @property
150 def properties(self):
151 cdef c_amqp_definitions.PROPERTIES_HANDLE value
152 if c_message.message_get_properties(self._c_value, &value) == 0:
153 if <void*>value == NULL:
154 return None
155 new_obj = cProperties()
156 new_obj.wrap(value)
157 return new_obj
158 else:
159 self._value_error()
160
161 @properties.setter
162 def properties(self, cProperties value):
163 if value is None:
164 if c_message.message_set_properties(
165 self._c_value, <c_amqp_definitions.PROPERTIES_HANDLE>NULL) != 0:
166 self._value_error()
167 elif c_message.message_set_properties(
168 self._c_value, <c_amqp_definitions.PROPERTIES_HANDLE>value._c_value) != 0:
169 self._value_error()
170
171 @property
172 def application_properties(self):
173 cdef c_amqpvalue.AMQP_VALUE value
174 if c_message.message_get_application_properties(self._c_value, &value) == 0:
175 if <void*>value == NULL:
176 return None
177 new_obj = cApplicationProperties()
178 new_obj.wrap(value)
179 return new_obj
180 else:
181 self._value_error()
182
183 @application_properties.setter
184 def application_properties(self, AMQPValue value):
185 if value is None:
186 if c_message.message_set_application_properties(
187 self._c_value, <c_amqpvalue.AMQP_VALUE>NULL) != 0:
188 self._value_error()
189 elif c_message.message_set_application_properties(
190 self._c_value, <c_amqpvalue.AMQP_VALUE>value._c_value) != 0:
191 self._value_error()
192
193 @property
194 def footer(self):
195 cdef c_amqp_definitions.annotations value
196 if c_message.message_get_footer(self._c_value, &value) == 0:
197 if <void*>value == NULL:
198 return None
199 new_obj = cFooter()
200 new_obj.wrap(value)
201 return new_obj
202 else:
203 self._value_error()
204
205 @footer.setter
206 def footer(self, cFooter value):
207 if value is None:
208 if c_message.message_set_footer(
209 self._c_value, <c_amqp_definitions.annotations>NULL) != 0:
210 self._value_error()
211 elif c_message.message_set_footer(
212 self._c_value, <c_amqp_definitions.annotations>value._c_value) != 0:
213 self._value_error()
214
215 @property
216 def body_type(self):
217 cdef c_message.MESSAGE_BODY_TYPE_TAG value
218 if c_message.message_get_body_type(self._c_value, &value) == 0:
219 return MessageBodyType(value)
220 else:
221 self._value_error()
222
223 @property
224 def message_format(self):
225 cdef stdint.uint32_t value
226 if c_message.message_get_message_format(self._c_value, &value) == 0:
227 return value
228 else:
229 self._value_error()
230
231 @message_format.setter
232 def message_format(self, stdint.uint32_t value):
233 if c_message.message_set_message_format(self._c_value, value) != 0:
234 self._value_error()
235
236 @property
237 def delivery_tag(self):
238 cdef c_amqpvalue.AMQP_VALUE value
239 if c_message.message_get_delivery_tag(self._c_value, &value) == 0:
240 if <void*>value == NULL:
241 return None
242 return value_factory(value)
243 else:
244 self._value_error()
245
246 cpdef add_body_data(self, bytes value):
247 cdef c_message.BINARY_DATA _binary
248 length = len(value)
249 bytes = value[:length]
250 _binary.length = length
251 _binary.bytes = bytes
252 if c_message.message_add_body_amqp_data(self._c_value, _binary) != 0:
253 self._value_error()
254
255 cpdef get_body_data(self, size_t index):
256 cdef c_message.BINARY_DATA _value
257 if c_message.message_get_body_amqp_data_in_place(self._c_value, index, &_value) == 0:
258 return _value.bytes[:_value.length]
259 else:
260 self._value_error()
261
262 cpdef count_body_data(self):
263 cdef size_t body_count
264 if c_message.message_get_body_amqp_data_count(self._c_value, &body_count) == 0:
265 return body_count
266 else:
267 self._value_error()
268
269 cpdef set_body_value(self, AMQPValue value):
270 if c_message.message_set_body_amqp_value(self._c_value, <c_amqpvalue.AMQP_VALUE>value._c_value) != 0:
271 self._value_error()
272
273 cpdef get_body_value(self):
274 cdef c_amqpvalue.AMQP_VALUE _value
275 cdef c_amqpvalue.AMQP_VALUE cloned
276 if c_message.message_get_body_amqp_value_in_place(self._c_value, &_value) != 0:
277 self._value_error()
278 cloned = c_amqpvalue.amqpvalue_clone(_value)
279 if <void*>cloned == NULL:
280 self._value_error()
281 return value_factory(cloned)
282
283 cpdef add_body_sequence(self, AMQPValue sequence):
284 if c_message.message_add_body_amqp_sequence(self._c_value, <c_amqpvalue.AMQP_VALUE>sequence._c_value) != 0:
285 self._value_error()
286
287 cpdef get_body_sequence(self, size_t index):
288 cdef c_amqpvalue.AMQP_VALUE _value
289 cdef c_amqpvalue.AMQP_VALUE cloned
290 if c_message.message_get_body_amqp_sequence_in_place(self._c_value, index, &_value) != 0:
291 self._value_error()
292 cloned = c_amqpvalue.amqpvalue_clone(_value)
293 if <void*>cloned == NULL:
294 self._value_error()
295 return value_factory(cloned)
296
297 cpdef count_body_sequence(self):
298 cdef size_t body_count
299 if c_message.message_get_body_amqp_sequence_count(self._c_value, &body_count) == 0:
300 return body_count
301 else:
302 self._value_error()
303
304
305 cdef class Messaging(object):
306
307 @staticmethod
308 def create_source(const char* address):
309 cdef c_amqpvalue.AMQP_VALUE _value
310 _value = c_message.messaging_create_source(address)
311 if <void*>_value == NULL:
312 raise MemoryError("Failed to allocate memory for messaging source.")
313 return value_factory(_value)
314
315 @staticmethod
316 def create_target(const char* address):
317 cdef c_amqpvalue.AMQP_VALUE _value
318 _value = c_message.messaging_create_target(address)
319 if <void*>_value == NULL:
320 raise MemoryError("Failed to allocate memory for messaging target.")
321 return value_factory(_value)
322
323 @staticmethod
324 def delivery_received(stdint.uint32_t section_number, stdint.uint64_t section_offset):
325 cdef c_amqpvalue.AMQP_VALUE _value
326 _value = c_message.messaging_delivery_received(section_number, section_offset)
327 if <void*>_value == NULL:
328 raise MemoryError("Failed to allocate memory for received delivery.")
329 return value_factory(_value)
330
331 @staticmethod
332 def delivery_accepted():
333 cdef c_amqpvalue.AMQP_VALUE _value
334 _value = c_message.messaging_delivery_accepted()
335 if <void*>_value == NULL:
336 raise MemoryError("Failed to allocate memory for accepted delivery.")
337 return value_factory(_value)
338
339 @staticmethod
340 def delivery_rejected(const char* error_condition, const char* error_description, cFields error_info=None):
341 cdef c_amqpvalue.AMQP_VALUE _value
342
343 if error_info is not None:
344 delivery_fields = <c_amqp_definitions.fields>error_info._c_value
345 else:
346 delivery_fields = <c_amqp_definitions.fields>NULL
347
348 _value = c_message.messaging_delivery_rejected(error_condition, error_description, delivery_fields)
349 if <void*>_value == NULL:
350 raise MemoryError("Failed to allocate memory for rejected delivery.")
351 return value_factory(_value)
352
353 @staticmethod
354 def delivery_released():
355 cdef c_amqpvalue.AMQP_VALUE _value
356 _value = c_message.messaging_delivery_released()
357 if <void*>_value == NULL:
358 raise MemoryError("Failed to allocate memory for released delivery.")
359 return value_factory(_value)
360
361 @staticmethod
362 def delivery_modified(bint delivery_failed, bint undeliverable_here, cFields message_annotations):
363 _logger.debug("delivery modified: %r %r", delivery_failed, undeliverable_here)
364 cdef c_amqpvalue.AMQP_VALUE _value
365 _value = c_message.messaging_delivery_modified(delivery_failed, undeliverable_here, <c_amqp_definitions.fields>message_annotations._c_value)
366 if <void*>_value == NULL:
367 raise MemoryError("Failed to allocate memory for modified delivery.")
368 return value_factory(_value)
369
370
371 cdef void destroy_amqp_objects_in_get_encoded_message_size(c_amqp_definitions.HEADER_HANDLE header,
372 c_amqpvalue.AMQP_VALUE header_amqp_value, c_amqpvalue.AMQP_VALUE msg_annotations,
373 c_amqpvalue.AMQP_VALUE footer, c_amqpvalue.AMQP_VALUE delivery_annotations,
374 c_amqp_definitions.PROPERTIES_HANDLE properties, c_amqpvalue.AMQP_VALUE properties_amqp_value,
375 c_amqpvalue.AMQP_VALUE application_properties, c_amqpvalue.AMQP_VALUE application_properties_value,
376 c_amqpvalue.AMQP_VALUE body_amqp_value):
377
378 if <void*>header != NULL:
379 c_amqp_definitions.header_destroy(header)
380
381 if <void*>header_amqp_value != NULL:
382 c_amqpvalue.amqpvalue_destroy(header_amqp_value)
383
384 if <void*>msg_annotations != NULL:
385 c_amqpvalue.amqpvalue_destroy(msg_annotations)
386
387 if <void*>footer != NULL:
388 c_amqpvalue.amqpvalue_destroy(footer)
389
390 if <void*>delivery_annotations != NULL:
391 c_amqpvalue.amqpvalue_destroy(delivery_annotations)
392
393 if <void*>properties != NULL:
394 c_amqp_definitions.properties_destroy(properties)
395
396 if <void*>properties_amqp_value != NULL:
397 c_amqpvalue.amqpvalue_destroy(properties_amqp_value)
398
399 if <void*>application_properties != NULL:
400 c_amqpvalue.amqpvalue_destroy(application_properties)
401
402 if <void*>application_properties_value != NULL:
403 c_amqpvalue.amqpvalue_destroy(application_properties_value)
404
405 if <void*>body_amqp_value != NULL:
406 c_amqpvalue.amqpvalue_destroy(body_amqp_value)
407
408
409 cpdef size_t get_encoded_message_size(cMessage message, encoded_data):
410
411 cdef c_message.MESSAGE_HANDLE c_msg
412 c_msg = <c_message.MESSAGE_HANDLE>message._c_value
413
414 cdef c_message.MESSAGE_BODY_TYPE_TAG message_body_type
415 cdef c_amqp_definitions.message_format message_format
416 cdef c_amqp_definitions.HEADER_HANDLE header = <c_amqp_definitions.HEADER_HANDLE>NULL
417 cdef c_amqpvalue.AMQP_VALUE header_amqp_value = <c_amqpvalue.AMQP_VALUE>NULL
418 cdef c_amqp_definitions.PROPERTIES_HANDLE properties = <c_amqp_definitions.PROPERTIES_HANDLE>NULL
419 cdef c_amqpvalue.AMQP_VALUE properties_amqp_value = <c_amqpvalue.AMQP_VALUE>NULL
420 cdef c_amqpvalue.AMQP_VALUE application_properties = <c_amqpvalue.AMQP_VALUE>NULL
421 cdef c_amqpvalue.AMQP_VALUE application_properties_value = <c_amqpvalue.AMQP_VALUE>NULL
422 cdef c_amqpvalue.AMQP_VALUE body_amqp_value = <c_amqpvalue.AMQP_VALUE>NULL
423 cdef c_amqpvalue.AMQP_VALUE msg_annotations = <c_amqpvalue.AMQP_VALUE>NULL
424 cdef c_amqpvalue.AMQP_VALUE footer = <c_amqpvalue.AMQP_VALUE>NULL
425 cdef c_amqpvalue.AMQP_VALUE delivery_annotations = <c_amqpvalue.AMQP_VALUE>NULL
426 cdef c_amqpvalue.AMQP_VALUE message_body_amqp_value
427 cdef c_amqpvalue.AMQP_VALUE message_body_amqp_sequence
428 cdef c_message.BINARY_DATA binary_data
429 cdef c_amqpvalue.AMQP_VALUE body_amqp_data
430 cdef c_amqpvalue.AMQP_VALUE body_amqp_sequence
431 cdef c_amqpvalue.amqp_binary binary_value
432 cdef size_t encoded_size
433 cdef size_t total_encoded_size = 0
434 cdef size_t body_data_count = 0
435 cdef size_t body_sequence_count = 0
436
437 # message format
438 if (c_message.message_get_body_type(c_msg, &message_body_type) != 0) or (c_message.message_get_message_format(c_msg, &message_format) != 0):
439 raise ValueError("Failure getting message body type and/or message format")
440
441 # message header
442 if c_message.message_get_header(c_msg, &header) == 0 and <void*>header != NULL:
443 header_amqp_value = c_amqp_definitions.amqpvalue_create_header(header)
444 if <void*>header_amqp_value == NULL:
445 _logger.debug("Cannot create header AMQP value")
446 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
447 properties, properties_amqp_value, application_properties, application_properties_value,
448 body_amqp_value)
449 raise MemoryError("Cannot get cMessage header.")
450 else:
451 if c_amqpvalue.amqpvalue_get_encoded_size(header_amqp_value, &encoded_size) != 0:
452 _logger.debug("Cannot obtain header encoded size")
453 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
454 properties, properties_amqp_value, application_properties, application_properties_value,
455 body_amqp_value)
456 raise ValueError("Cannot obtain header encoded size")
457 else:
458 total_encoded_size += encoded_size
459
460 # message annotations
461 if c_message.message_get_message_annotations(c_msg, &msg_annotations) == 0 and <void*>msg_annotations != NULL:
462 if c_amqpvalue.amqpvalue_get_encoded_size(msg_annotations, &encoded_size) != 0:
463 _logger.debug("Cannot obtain message annotations encoded size")
464 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
465 properties, properties_amqp_value, application_properties, application_properties_value,
466 body_amqp_value)
467 raise ValueError("Cannot obtain message annotations encoded size")
468 else:
469 total_encoded_size += encoded_size
470
471 # properties
472 if c_message.message_get_properties(c_msg, &properties) == 0 and <void*>properties != NULL:
473 properties_amqp_value = c_amqp_definitions.amqpvalue_create_properties(properties)
474 if <void*>properties_amqp_value == NULL:
475 _logger.debug("Cannot create properties AMQP value")
476 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
477 properties, properties_amqp_value, application_properties, application_properties_value,
478 body_amqp_value)
479 raise MemoryError("Cannot get cMessage properties.")
480 else:
481 if c_amqpvalue.amqpvalue_get_encoded_size(properties_amqp_value, &encoded_size) != 0:
482 _logger.debug("Cannot obtain message properties encoded size")
483 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
484 properties, properties_amqp_value, application_properties, application_properties_value,
485 body_amqp_value)
486 raise ValueError("Cannot obtain message properties encoded size")
487 else:
488 total_encoded_size += encoded_size
489
490 # application properties
491 if c_message.message_get_application_properties(c_msg, &application_properties) == 0 and <void*>application_properties != NULL:
492 application_properties_value = c_amqp_definitions.amqpvalue_create_application_properties(application_properties)
493 if <void*>application_properties_value == NULL:
494 _logger.debug("Cannot create application properties AMQP value")
495 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
496 properties, properties_amqp_value, application_properties, application_properties_value,
497 body_amqp_value)
498 raise MemoryError("Cannot get cMessage application properties.")
499 else:
500 if c_amqpvalue.amqpvalue_get_encoded_size(application_properties_value, &encoded_size) != 0:
501 _logger.debug("Cannot obtain application properties encoded size")
502 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
503 properties, properties_amqp_value, application_properties, application_properties_value,
504 body_amqp_value)
505 raise ValueError("Cannot obtain application properties encoded size")
506 else:
507 total_encoded_size += encoded_size
508
509 # footer
510 if c_message.message_get_footer(c_msg, &footer) == 0 and <void*>footer != NULL:
511 if c_amqpvalue.amqpvalue_get_encoded_size(footer, &encoded_size) != 0:
512 _logger.debug("Cannot obtain footer encoded size")
513 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
514 properties, properties_amqp_value, application_properties, application_properties_value,
515 body_amqp_value)
516 raise ValueError("Cannot obtain footer encoded size")
517 else:
518 total_encoded_size += encoded_size
519
520 # delivery annotations
521 if c_message.message_get_delivery_annotations(c_msg, &delivery_annotations) == 0 and <void*>delivery_annotations != NULL:
522 if c_amqpvalue.amqpvalue_get_encoded_size(delivery_annotations, &encoded_size) != 0:
523 _logger.debug("Cannot obtain delivery annotations encoded size")
524 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
525 properties, properties_amqp_value, application_properties, application_properties_value,
526 body_amqp_value)
527 raise ValueError("Cannot obtain delivery annotations encoded size")
528 else:
529 total_encoded_size += encoded_size
530
531 # value body
532 if message_body_type == c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_VALUE:
533 if c_message.message_get_body_amqp_value_in_place(c_msg, &message_body_amqp_value) != 0:
534 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
535 properties, properties_amqp_value, application_properties, application_properties_value,
536 body_amqp_value)
537 raise ValueError("Cannot obtain AMQP value from body")
538 body_amqp_value = c_amqp_definitions.amqpvalue_create_amqp_value(message_body_amqp_value)
539 if <void*>body_amqp_value == NULL:
540 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
541 properties, properties_amqp_value, application_properties, application_properties_value,
542 body_amqp_value)
543 raise MemoryError("Cannot create body AMQP value")
544 else:
545 if c_amqpvalue.amqpvalue_get_encoded_size(body_amqp_value, &encoded_size) != 0:
546 _logger.debug("Cannot get body AMQP value encoded size")
547 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
548 properties, properties_amqp_value, application_properties, application_properties_value,
549 body_amqp_value)
550 raise ValueError("Cannot get body AMQP value encoded size")
551 else:
552 total_encoded_size += encoded_size
553
554 # data body
555 if message_body_type == c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_DATA:
556 if c_message.message_get_body_amqp_data_count(c_msg, &body_data_count) != 0:
557 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
558 properties, properties_amqp_value, application_properties, application_properties_value,
559 body_amqp_value)
560 raise ValueError("Cannot get body AMQP data count")
561 if body_data_count == 0:
562 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
563 properties, properties_amqp_value, application_properties, application_properties_value,
564 body_amqp_value)
565 raise ValueError("Body data count is zero")
566 for i in range(body_data_count):
567 if c_message.message_get_body_amqp_data_in_place(c_msg, i, &binary_data) != 0:
568 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
569 properties, properties_amqp_value, application_properties, application_properties_value,
570 body_amqp_value)
571 raise ValueError("Cannot get body AMQP data {}".format(i))
572
573 binary_value.bytes = binary_data.bytes
574 binary_value.length = <stdint.uint32_t>binary_data.length
575 body_amqp_data = c_amqp_definitions.amqpvalue_create_data(binary_value)
576 if <void*>body_amqp_data == NULL:
577 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
578 properties, properties_amqp_value, application_properties, application_properties_value,
579 body_amqp_value)
580 raise MemoryError("Cannot create body AMQP data")
581 else:
582 if c_amqpvalue.amqpvalue_get_encoded_size(body_amqp_data, &encoded_size) != 0:
583 _logger.debug("Cannot get body AMQP data encoded size")
584 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
585 properties, properties_amqp_value, application_properties, application_properties_value,
586 body_amqp_value)
587 c_amqpvalue.amqpvalue_destroy(body_amqp_data)
588 raise ValueError("Cannot get body AMQP data encoded size")
589 else:
590 total_encoded_size += encoded_size
591 c_amqpvalue.amqpvalue_destroy(body_amqp_data)
592
593 # sequence body
594 if message_body_type == c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_SEQUENCE:
595 if c_message.message_get_body_amqp_sequence_count(c_msg, &body_sequence_count) != 0:
596 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
597 properties, properties_amqp_value, application_properties, application_properties_value,
598 body_amqp_value)
599 raise ValueError("Cannot get body AMQP sequence count")
600 if body_sequence_count == 0:
601 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
602 properties, properties_amqp_value, application_properties, application_properties_value,
603 body_amqp_value)
604 raise ValueError("Body sequence count is zero")
605 for i in range(body_sequence_count):
606 if c_message.message_get_body_amqp_sequence_in_place(c_msg, i, &message_body_amqp_sequence) != 0:
607 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
608 properties, properties_amqp_value, application_properties, application_properties_value,
609 body_amqp_value)
610 raise ValueError("Cannot get body AMQP sequence {}".format(i))
611
612 body_amqp_sequence = c_amqp_definitions.amqpvalue_create_amqp_sequence(message_body_amqp_sequence);
613 if <void*> body_amqp_sequence == NULL:
614 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
615 properties, properties_amqp_value, application_properties, application_properties_value,
616 body_amqp_value)
617 raise MemoryError("Cannot create body AMQP sequence")
618 else:
619 if c_amqpvalue.amqpvalue_get_encoded_size(body_amqp_sequence, &encoded_size) != 0:
620 _logger.debug("Cannot get body AMQP sequence encoded size")
621 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
622 properties, properties_amqp_value, application_properties, application_properties_value,
623 body_amqp_value)
624 c_amqpvalue.amqpvalue_destroy(body_amqp_sequence)
625 raise ValueError("Cannot get body AMQP sequence encoded size")
626 else:
627 total_encoded_size += encoded_size
628 c_amqpvalue.amqpvalue_destroy(body_amqp_sequence)
629
630 # encode
631 if <void*>header != NULL:
632 if c_amqpvalue.amqpvalue_encode(
633 header_amqp_value,
634 <c_amqpvalue.AMQPVALUE_ENCODER_OUTPUT>encode_bytes_callback,
635 <void*>encoded_data) != 0:
636 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
637 properties, properties_amqp_value, application_properties, application_properties_value,
638 body_amqp_value)
639 raise ValueError("Cannot encode header value")
640 if <void*>msg_annotations != NULL:
641 if c_amqpvalue.amqpvalue_encode(
642 msg_annotations,
643 <c_amqpvalue.AMQPVALUE_ENCODER_OUTPUT>encode_bytes_callback,
644 <void*>encoded_data) != 0:
645 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
646 properties, properties_amqp_value, application_properties, application_properties_value,
647 body_amqp_value)
648 raise ValueError("Cannot encode message annotations value")
649 if <void*>properties != NULL:
650 if c_amqpvalue.amqpvalue_encode(
651 properties_amqp_value,
652 <c_amqpvalue.AMQPVALUE_ENCODER_OUTPUT>encode_bytes_callback,
653 <void*>encoded_data) != 0:
654 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
655 properties, properties_amqp_value, application_properties, application_properties_value,
656 body_amqp_value)
657 raise ValueError("Cannot encode message properties value")
658 if <void*>application_properties != NULL:
659 if c_amqpvalue.amqpvalue_encode(
660 application_properties_value,
661 <c_amqpvalue.AMQPVALUE_ENCODER_OUTPUT>encode_bytes_callback,
662 <void*>encoded_data) != 0:
663 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
664 properties, properties_amqp_value, application_properties, application_properties_value,
665 body_amqp_value)
666 raise ValueError("Cannot encode application properties value")
667 if <void*>footer != NULL:
668 if c_amqpvalue.amqpvalue_encode(
669 footer,
670 <c_amqpvalue.AMQPVALUE_ENCODER_OUTPUT>encode_bytes_callback,
671 <void*>encoded_data) != 0:
672 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
673 properties, properties_amqp_value, application_properties, application_properties_value,
674 body_amqp_value)
675 raise ValueError("Cannot encode footer value")
676 if <void*>delivery_annotations != NULL:
677 if c_amqpvalue.amqpvalue_encode(
678 delivery_annotations,
679 <c_amqpvalue.AMQPVALUE_ENCODER_OUTPUT>encode_bytes_callback,
680 <void*>encoded_data) != 0:
681 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
682 properties, properties_amqp_value, application_properties, application_properties_value,
683 body_amqp_value)
684 raise ValueError("Cannot encode delivery annotations value")
685 if message_body_type == c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_VALUE:
686 if c_amqpvalue.amqpvalue_encode(
687 body_amqp_value,
688 <c_amqpvalue.AMQPVALUE_ENCODER_OUTPUT>encode_bytes_callback,
689 <void*>encoded_data) != 0:
690 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
691 properties, properties_amqp_value, application_properties, application_properties_value,
692 body_amqp_value)
693 raise ValueError("Cannot encode body AMQP value")
694 if message_body_type == c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_DATA:
695 for i in range(body_data_count):
696 if c_message.message_get_body_amqp_data_in_place(c_msg, i, &binary_data) != 0:
697 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
698 properties, properties_amqp_value, application_properties, application_properties_value,
699 body_amqp_value)
700 raise ValueError("Cannot get body AMQP data {}".format(i))
701
702 binary_value.bytes = binary_data.bytes
703 binary_value.length = <stdint.uint32_t>binary_data.length
704 body_amqp_data = c_amqp_definitions.amqpvalue_create_data(binary_value)
705 if <void*>body_amqp_data == NULL:
706 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
707 properties, properties_amqp_value, application_properties, application_properties_value,
708 body_amqp_value)
709 raise MemoryError("Cannot create body AMQP data")
710 else:
711 if c_amqpvalue.amqpvalue_encode(
712 body_amqp_data,
713 <c_amqpvalue.AMQPVALUE_ENCODER_OUTPUT>encode_bytes_callback,
714 <void*>encoded_data) != 0:
715 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
716 properties, properties_amqp_value, application_properties, application_properties_value,
717 body_amqp_value)
718 c_amqpvalue.amqpvalue_destroy(body_amqp_data)
719 raise ValueError("Cannot encode body AMQP value")
720 c_amqpvalue.amqpvalue_destroy(body_amqp_data)
721 if message_body_type == c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_SEQUENCE:
722 for i in range(body_sequence_count):
723 if c_message.message_get_body_amqp_sequence_in_place(c_msg, i, &message_body_amqp_sequence) != 0:
724 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
725 properties, properties_amqp_value, application_properties, application_properties_value,
726 body_amqp_value)
727 raise ValueError("Cannot get body AMQP sequence {}".format(i))
728
729 body_amqp_sequence = c_amqp_definitions.amqpvalue_create_amqp_sequence(message_body_amqp_sequence);
730 if <void*> body_amqp_sequence == NULL:
731 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
732 properties, properties_amqp_value, application_properties, application_properties_value,
733 body_amqp_value)
734 raise MemoryError("Cannot create body AMQP sequence")
735 else:
736 if c_amqpvalue.amqpvalue_encode(
737 body_amqp_sequence,
738 <c_amqpvalue.AMQPVALUE_ENCODER_OUTPUT>encode_bytes_callback,
739 <void*>encoded_data) != 0:
740 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
741 properties, properties_amqp_value, application_properties, application_properties_value,
742 body_amqp_value)
743 c_amqpvalue.amqpvalue_destroy(body_amqp_sequence)
744 raise ValueError("Cannot get body AMQP sequence encoded size")
745 c_amqpvalue.amqpvalue_destroy(body_amqp_sequence)
746
747 destroy_amqp_objects_in_get_encoded_message_size(header, header_amqp_value, msg_annotations, footer, delivery_annotations,
748 properties, properties_amqp_value, application_properties, application_properties_value,
749 body_amqp_value)
750
751 return total_encoded_size
752
753
754 cdef class cMessageDecoder(object):
755
756 cdef c_message.MESSAGE_HANDLE decoded_message
757 cdef const char* decode_error
758
759 def __cinit__(self):
760 self.decoded_message = c_message.message_create()
761 if <void*>self.decoded_message == NULL:
762 raise MemoryError("Failed to create message decoder.")
763 self.decode_error = <const char*>NULL
764
765 def __dealloc__(self):
766 _logger.debug("Deallocating cMessageDecoder")
767
768
769 cpdef cMessage decode_message(stdint.uint32_t payload_size, const unsigned char* payload_bytes):
770 cdef c_amqpvalue.AMQPVALUE_DECODER_HANDLE amqpvalue_decoder
771 cdef c_message.MESSAGE_HANDLE result
772 message_decoder = cMessageDecoder()
773
774 amqpvalue_decoder = c_amqpvalue.amqpvalue_decoder_create(<c_amqpvalue.ON_VALUE_DECODED>decode_message_data, <void*>message_decoder);
775 if <void*>amqpvalue_decoder == NULL:
776 raise MemoryError("Cannot create AMQP value decoder")
777 else:
778 if c_amqpvalue.amqpvalue_decode_bytes(amqpvalue_decoder, payload_bytes, payload_size) != 0:
779 raise ValueError("Cannot decode bytes")
780 else:
781 if <void*>message_decoder.decode_error != NULL:
782 raise ValueError(message_decoder.decode_error.decode('UTF-8'))
783 else:
784 result = message_decoder.decoded_message
785
786 c_amqpvalue.amqpvalue_decoder_destroy(amqpvalue_decoder)
787 return message_factory(result)
788
789
790 cdef void decode_message_data(void* context, c_amqpvalue.AMQP_VALUE decoded_value):
791 message_decoder = <cMessageDecoder>context
792 cdef c_message.MESSAGE_HANDLE decoded_message
793 cdef c_amqpvalue.AMQP_VALUE descriptor
794 cdef c_amqp_definitions.PROPERTIES_HANDLE properties
795 cdef c_amqp_definitions.annotations delivery_annotations
796 cdef c_amqp_definitions.annotations message_annotations
797 cdef c_amqp_definitions.HEADER_HANDLE header
798 cdef c_amqp_definitions.annotations footer
799 cdef c_message.MESSAGE_BODY_TYPE_TAG body_type
800 cdef c_amqpvalue.AMQP_VALUE body_amqp_value
801 cdef c_amqpvalue.AMQP_VALUE body_data_value
802 cdef c_amqp_definitions.data data_value
803 cdef c_message.BINARY_DATA binary_data
804
805 decoded_message = message_decoder.decoded_message
806 descriptor = c_amqpvalue.amqpvalue_get_inplace_descriptor(decoded_value)
807
808 if c_amqp_definitions.is_application_properties_type_by_descriptor(descriptor):
809 if c_message.message_set_application_properties(decoded_message, decoded_value) != 0:
810 message_decoder.decode_error = b"Error setting application properties on received message"
811
812 elif c_amqp_definitions.is_properties_type_by_descriptor(descriptor):
813 if c_amqp_definitions.amqpvalue_get_properties(decoded_value, &properties) != 0:
814 message_decoder.decode_error = b"Error getting message properties"
815
816 else:
817 if c_message.message_set_properties(decoded_message, properties) != 0:
818 message_decoder.decode_error = b"Error setting message properties on received message"
819 c_amqp_definitions.properties_destroy(properties)
820
821 elif c_amqp_definitions.is_delivery_annotations_type_by_descriptor(descriptor):
822 delivery_annotations = c_amqpvalue.amqpvalue_get_inplace_described_value(decoded_value)
823 if <void*>delivery_annotations == NULL:
824 message_decoder.decode_error = b"Error getting delivery annotations"
825 else:
826 if c_message.message_set_delivery_annotations(decoded_message, delivery_annotations) != 0:
827 message_decoder.decode_error = b"Error setting delivery annotations on received message"
828
829 elif c_amqp_definitions.is_message_annotations_type_by_descriptor(descriptor):
830 message_annotations = c_amqpvalue.amqpvalue_get_inplace_described_value(decoded_value)
831 if <void*>message_annotations == NULL:
832 message_decoder.decode_error = b"Error getting message annotations"
833 else:
834 if c_message.message_set_message_annotations(decoded_message, message_annotations) != 0:
835 message_decoder.decode_error = b"Error setting message annotations on received message"
836
837 elif c_amqp_definitions.is_header_type_by_descriptor(descriptor):
838 if c_amqp_definitions.amqpvalue_get_header(decoded_value, &header) != 0:
839 message_decoder.decode_error = b"Error getting message header"
840 else:
841 if c_message.message_set_header(decoded_message, header) != 0:
842 message_decoder.decode_error = b"Error setting message header on received message"
843 c_amqp_definitions.header_destroy(header)
844
845 elif c_amqp_definitions.is_footer_type_by_descriptor(descriptor):
846 footer = c_amqpvalue.amqpvalue_get_inplace_described_value(decoded_value);
847 if <void*>footer == NULL:
848 message_decoder.decode_error = b"Error getting message footer"
849 else:
850 if c_message.message_set_footer(decoded_message, footer) != 0:
851 message_decoder.decode_error = b"Error setting message footer on received message"
852
853 elif c_amqp_definitions.is_amqp_value_type_by_descriptor(descriptor):
854 if c_message.message_get_body_type(decoded_message, &body_type) != 0:
855 message_decoder.decode_error = b"Error getting message body type"
856
857 else:
858 if body_type != c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_NONE:
859 message_decoder.decode_error = b"Body already set on received message"
860
861 else:
862 body_amqp_value = c_amqpvalue.amqpvalue_get_inplace_described_value(decoded_value)
863 if <void*>body_amqp_value == NULL:
864 message_decoder.decode_error = b"Error getting body AMQP value"
865 else:
866 if c_message.message_set_body_amqp_value(decoded_message, body_amqp_value) != 0:
867 message_decoder.decode_error = b"Error setting body AMQP value on received message"
868
869 elif c_amqp_definitions.is_data_type_by_descriptor(descriptor):
870 if c_message.message_get_body_type(decoded_message, &body_type) != 0:
871 message_decoder.decode_error = b"Error getting message body type"
872
873 else:
874 if (body_type != c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_NONE) and (body_type != c_message.MESSAGE_BODY_TYPE_TAG.MESSAGE_BODY_TYPE_DATA):
875 message_decoder.decode_error = b"Message body type already set to something different than AMQP DATA"
876
877 else:
878 body_data_value = c_amqpvalue.amqpvalue_get_inplace_described_value(decoded_value)
879 if <void*>body_data_value == NULL:
880 message_decoder.decode_error = b"Error getting body DATA value"
881
882 else:
883 if c_amqpvalue.amqpvalue_get_binary(body_data_value, &data_value) != 0:
884 message_decoder.decode_error = b"Error getting body DATA AMQP value"
885
886 else:
887 binary_data.bytes = <const unsigned char*>data_value.bytes
888 binary_data.length = data_value.length
889 if c_message.message_add_body_amqp_data(decoded_message, binary_data) != 0:
890 message_decoder.decode_error = b"Error adding body DATA to received message"