Debian Codegraph @

src/link.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 import logging
9
10 # C imports
11 from libc cimport stdint
12
13 cimport c_link
14 cimport c_session
15 cimport c_amqp_definitions
16 cimport c_amqpvalue
17
18
19 _logger = logging.getLogger(__name__)
20
21
22 cpdef create_link(cSession session, const char* name, bint role, AMQPValue source, AMQPValue target):
23 new_link = cLink()
24 new_link.create(session, name, <c_amqp_definitions.role>role, <c_amqpvalue.AMQP_VALUE>source._c_value, <c_amqpvalue.AMQP_VALUE>target._c_value)
25 return new_link
26
27
28 cdef class cLink(StructBase):
29
30 cdef c_link.LINK_HANDLE _c_value
31 cdef c_link.ON_LINK_DETACH_EVENT_SUBSCRIPTION_HANDLE _detach_event
32 cdef cSession _session
33
34 def __cinit__(self):
35 pass
36
37 def __dealloc__(self):
38 _logger.debug("Deallocating cLink")
39 self.destroy()
40
41 def __enter__(self):
42 return self
43
44 def __exit__(self, *args):
45 self.destroy()
46
47 cdef _create(self):
48 if <void*>self._c_value is NULL:
49 self._memory_error()
50
51 cpdef destroy(self):
52 if <void*>self._c_value is not NULL:
53 _logger.debug("Destroying cLink")
54 c_link.link_destroy(self._c_value)
55 self._c_value = <c_link.LINK_HANDLE>NULL
56 self._session = None
57
58 cdef wrap(self, cLink value):
59 self.destroy()
60 self._session = value._session
61 self._c_value = value._c_value
62 self._create()
63
64 cdef create(self, cSession session, const char* name, c_amqp_definitions.role role, c_amqpvalue.AMQP_VALUE source, c_amqpvalue.AMQP_VALUE target):
65 self.destroy()
66 self._session = session
67 self._c_value = c_link.link_create(<c_session.SESSION_HANDLE>session._c_value, name, role, source, target)
68 self._create()
69
70 cpdef subscribe_to_detach_event(self, on_detch_received):
71 self._detach_event = c_link.link_subscribe_on_link_detach_received(
72 self._c_value,
73 <c_link.ON_LINK_DETACH_RECEIVED>on_link_detach_received,
74 <void*>on_detch_received)
75 if <void*>self._detach_event == NULL:
76 self._value_error("Unable to register DETACH event handler.")
77
78 cpdef unsubscribe_to_detach_event(self):
79 c_link.link_unsubscribe_on_link_detach_received(self._detach_event)
80
81 cpdef reset_link_credit(self, stdint.uint32_t link_credit, bint drain):
82 _logger.debug("send flow, reset link credit to %r and drain to %r", link_credit, drain)
83 if c_link.link_reset_link_credit(self._c_value, link_credit, drain) != 0:
84 self._value_error("Unable to reset link credit and send flow.")
85
86 @property
87 def send_settle_mode(self):
88 cdef c_amqp_definitions.sender_settle_mode snd_settle_mode
89 if c_link.link_get_snd_settle_mode(self._c_value, &snd_settle_mode) != 0:
90 self._value_error()
91 return <stdint.uint8_t>snd_settle_mode
92
93 @send_settle_mode.setter
94 def send_settle_mode(self, stdint.uint8_t value):
95 if c_link.link_set_snd_settle_mode(self._c_value, <c_amqp_definitions.sender_settle_mode>value) != 0:
96 self._value_error()
97
98 @property
99 def receive_settle_mode(self):
100 cdef c_amqp_definitions.receiver_settle_mode rcv_settle_mode
101 if c_link.link_get_rcv_settle_mode(self._c_value, &rcv_settle_mode) != 0:
102 self._value_error()
103 return <stdint.uint8_t>rcv_settle_mode
104
105 @receive_settle_mode.setter
106 def receive_settle_mode(self, stdint.uint8_t value):
107 if c_link.link_set_rcv_settle_mode(self._c_value, <c_amqp_definitions.receiver_settle_mode>value) != 0:
108 self._value_error()
109
110 @property
111 def max_message_size(self):
112 cdef stdint.uint64_t value
113 if c_link.link_get_max_message_size(self._c_value, &value) != 0:
114 self._value_error()
115 return value
116
117 @max_message_size.setter
118 def max_message_size(self, stdint.uint64_t value):
119 if c_link.link_set_max_message_size(self._c_value, value) != 0:
120 self._value_error()
121
122 @property
123 def initial_delivery_count(self):
124 cdef c_amqp_definitions.sequence_no value
125 if c_link.link_get_initial_delivery_count(self._c_value, &value) != 0:
126 self._value_error()
127 return value
128
129 @initial_delivery_count.setter
130 def initial_delivery_count(self, c_amqp_definitions.sequence_no value):
131 if c_link.link_set_initial_delivery_count(self._c_value, value) != 0:
132 self._value_error()
133
134 @property
135 def peer_max_message_size(self):
136 cdef stdint.uint64_t value
137 if c_link.link_get_peer_max_message_size(self._c_value, &value) != 0:
138 self._value_error()
139 return value
140
141 @property
142 def name(self):
143 cdef const char* value
144 if c_link.link_get_name(self._c_value, &value) != 0:
145 self._value_error()
146 return value
147
148 @property
149 def desired_capabilities(self):
150 cdef c_amqpvalue.AMQP_VALUE value
151 if c_link.link_get_desired_capabilities(self._c_value, &value) != 0:
152 self._value_error()
153 return value_factory(value)
154
155 cpdef do_work(self):
156 c_link.link_dowork(self._c_value)
157
158 cpdef set_prefetch_count(self, stdint.uint32_t prefetch):
159 if c_link.link_set_max_link_credit(self._c_value, prefetch) != 0:
160 self._value_error("Unable to set link credit.")
161
162 cpdef set_attach_properties(self, AMQPValue properties):
163 if c_link.link_set_attach_properties(self._c_value, <c_amqp_definitions.fields>properties._c_value) != 0:
164 self._value_error("Unable to set link attach properties.")
165
166 cpdef set_desired_capabilities(self, AMQPValue desired_capabilities):
167 if c_link.link_set_desired_capabilities(self._c_value, <c_amqpvalue.AMQP_VALUE>desired_capabilities._c_value) != 0:
168 self._value_error("Unable to set link desired capabilities.")
169
170
171 #### Callback
172
173 cdef void on_link_detach_received(void* context, c_amqp_definitions.ERROR_HANDLE error):
174 cdef c_amqp_definitions.ERROR_HANDLE cloned
175 context_obj = <object>context
176 if <void*> error != NULL:
177 cloned = c_amqp_definitions.error_clone(error)
178 wrapped_error = error_factory(cloned)
179 else:
180 wrapped_error = None
181 if hasattr(context_obj, '_detach_received'):
182 context_obj._detach_received(wrapped_error)