Asterisk - The Open Source Telephony Project GIT-master-27fb039
Loading...
Searching...
No Matches
Functions | Variables
test_stasis_endpoints.c File Reference

Test endpoints. More...

#include "asterisk.h"
#include "asterisk/astobj2.h"
#include "asterisk/channel.h"
#include "asterisk/endpoints.h"
#include "asterisk/module.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/stasis_endpoints.h"
#include "asterisk/stasis_test.h"
#include "asterisk/test.h"
Include dependency graph for test_stasis_endpoints.c:

Go to the source code of this file.

Functions

static void __reg_module (void)
 
static void __unreg_module (void)
 
struct ast_module * AST_MODULE_SELF_SYM (void)
 
 AST_TEST_DEFINE (cache_clear)
 
 AST_TEST_DEFINE (channel_messages)
 
 AST_TEST_DEFINE (state_changes)
 
static int cache_update (struct stasis_message *msg, const void *data)
 Message matcher looking for cache update messages.
 
static int load_module (void)
 
static int unload_module (void)
 

Variables

static struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Endpoint stasis-related testing" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "res_stasis_test", }
 
static const struct ast_module_info * ast_module_info = &__mod_info
 
static const char * test_category = "/stasis/endpoints/"
 

Detailed Description

Test endpoints.

Author
David M. Lee, II <dlee@digium.com>

Definition in file test_stasis_endpoints.c.

Function Documentation

◆ __reg_module()

static void __reg_module ( void  )
static

Definition at line 307 of file test_stasis_endpoints.c.

◆ __unreg_module()

static void __unreg_module ( void  )
static

Definition at line 307 of file test_stasis_endpoints.c.

◆ AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM ( void  )

Definition at line 307 of file test_stasis_endpoints.c.

◆ AST_TEST_DEFINE() [1/3]

AST_TEST_DEFINE ( cache_clear  )

Definition at line 126 of file test_stasis_endpoints.c.

127{
128 RAII_VAR(struct ast_endpoint *, uut, NULL, ast_endpoint_shutdown);
129 RAII_VAR(struct ast_channel *, chan, NULL, ast_hangup);
130 RAII_VAR(struct stasis_message_sink *, sink, NULL, ao2_cleanup);
131 RAII_VAR(struct stasis_subscription *, sub, NULL, stasis_unsubscribe);
132 struct stasis_message *msg;
133 struct stasis_message_type *type;
134 struct ast_endpoint_snapshot *actual_snapshot;
135 struct stasis_cache_update *update;
136 int message_index;
137
138 switch (cmd) {
139 case TEST_INIT:
140 info->name = __func__;
141 info->category = test_category;
142 info->summary = "Test endpoint state change messages";
143 info->description = "Test endpoint state change messages";
144 return AST_TEST_NOT_RUN;
145 case TEST_EXECUTE:
146 break;
147 }
148
149 /* Subscribe to the cache topic */
150 sink = stasis_message_sink_create();
151 ast_test_validate(test, NULL != sink);
152
153 sub = stasis_subscribe(
154 ast_endpoint_topic_all_cached(),
155 stasis_message_sink_cb(), sink);
156 ast_test_validate(test, NULL != sub);
157
158 uut = ast_endpoint_create("TEST", __func__);
159 ast_test_validate(test, NULL != uut);
160
161 /* Since the cache topic is a singleton (ew), it may have messages from
162 * elsewheres that it's processing, or maybe even some final messages
163 * from the prior test. We've got to wait_for our specific message,
164 * instead of wait_for_count.
165 */
166 message_index = stasis_message_sink_wait_for(sink, 0,
167 cache_update, __func__, STASIS_SINK_DEFAULT_WAIT);
168 ast_test_validate(test, 0 <= message_index);
169
170 /* First message should be a cache creation entry for our endpoint */
171 msg = sink->messages[message_index];
172 type = stasis_message_type(msg);
173 ast_test_validate(test, stasis_cache_update_type() == type);
174 update = stasis_message_data(msg);
175 ast_test_validate(test, ast_endpoint_snapshot_type() == update->type);
176 ast_test_validate(test, NULL == update->old_snapshot);
177 actual_snapshot = stasis_message_data(update->new_snapshot);
178 ast_test_validate(test, 0 == strcmp("TEST", actual_snapshot->tech));
179 ast_test_validate(test,
180 0 == strcmp(__func__, actual_snapshot->resource));
181
182 ast_endpoint_shutdown(uut);
183 uut = NULL;
184
185 /* Note: there's a few messages between the creation and the clear.
186 * Wait for all of them... */
187 message_index = stasis_message_sink_wait_for(sink, message_index + 2,
188 cache_update, __func__, STASIS_SINK_DEFAULT_WAIT);
189 ast_test_validate(test, 0 <= message_index);
190
191 /* Now we should have a cache removal entry */
192 msg = sink->messages[message_index];
193 type = stasis_message_type(msg);
194 ast_test_validate(test, stasis_cache_update_type() == type);
195 update = stasis_message_data(msg);
196 ast_test_validate(test, ast_endpoint_snapshot_type() == update->type);
197 actual_snapshot = stasis_message_data(update->old_snapshot);
198 ast_test_validate(test, 0 == strcmp("TEST", actual_snapshot->tech));
199 ast_test_validate(test,
200 0 == strcmp(__func__, actual_snapshot->resource));
201 ast_test_validate(test, NULL == update->new_snapshot);
202
203 return AST_TEST_PASS;
204}
ao2_cleanup
#define ao2_cleanup(obj)
Definition astobj2.h:1934
type
static const char type[]
Definition chan_ooh323.c:109
ast_hangup
void ast_hangup(struct ast_channel *chan)
Hang up a channel.
Definition channel.c:2538
update
static void update(int code_size, int y, int wi, int fi, int dq, int sr, int dqsez, struct g726_state *state_ptr)
Definition codec_g726.c:367
ast_endpoint_shutdown
void ast_endpoint_shutdown(struct ast_endpoint *endpoint)
Shutsdown an ast_endpoint.
Definition main/endpoints.c:311
ast_endpoint_create
struct ast_endpoint * ast_endpoint_create(const char *tech, const char *resource)
Create an endpoint struct.
Definition main/endpoints.c:280
ast_endpoint_snapshot_type
struct stasis_message_type * ast_endpoint_snapshot_type(void)
Message type for ast_endpoint_snapshot.
ast_endpoint_topic_all_cached
struct stasis_topic * ast_endpoint_topic_all_cached(void)
Cached topic for all endpoint related messages.
Definition stasis_endpoints.c:127
stasis_cache_update_type
struct stasis_message_type * stasis_cache_update_type(void)
Message type for cache update messages.
sip_to_pjsip.info
info(msg)
Definition sip_to_pjsip.py:1313
sub
static struct stasis_subscription * sub
Statsd channel stats. Exmaple of how to subscribe to Stasis events.
Definition res_chan_stats.c:44
NULL
#define NULL
Definition resample.c:96
stasis_message_data
void * stasis_message_data(const struct stasis_message *msg)
Get the data contained in a message.
Definition stasis_message.c:195
stasis_unsubscribe
struct stasis_subscription * stasis_unsubscribe(struct stasis_subscription *subscription)
Cancel a subscription.
Definition stasis.c:1038
stasis_subscribe
#define stasis_subscribe(topic, callback, data)
Definition stasis.h:649
STASIS_SINK_DEFAULT_WAIT
#define STASIS_SINK_DEFAULT_WAIT
Definition stasis_test.h:41
stasis_message_sink_wait_for
int stasis_message_sink_wait_for(struct stasis_message_sink *sink, int start, stasis_wait_cb cmp_cb, const void *data, int timeout_millis)
Wait for a message that matches the given criteria.
Definition res_stasis_test.c:191
stasis_message_sink_create
struct stasis_message_sink * stasis_message_sink_create(void)
Create a message sink.
Definition res_stasis_test.c:79
stasis_message_sink_cb
stasis_subscription_cb stasis_message_sink_cb(void)
Topic callback to receive messages.
Definition res_stasis_test.c:143
ast_channel
Main Channel structure associated with a channel.
Definition channel_private.h:48
ast_endpoint_snapshot
A snapshot of an endpoint's state.
Definition stasis_endpoints.h:48
ast_endpoint_snapshot::tech
const ast_string_field tech
Definition stasis_endpoints.h:53
ast_endpoint_snapshot::resource
const ast_string_field resource
Definition stasis_endpoints.h:53
ast_endpoint
Definition main/endpoints.c:53
stasis_cache_update
Cache update message.
Definition stasis.h:965
stasis_message_sink
Structure that collects messages from a topic.
Definition stasis_test.h:44
stasis_message_type
Definition stasis_message.c:38
stasis_message
Definition stasis_message.c:121
stasis_subscription
Definition stasis.c:747
TEST_INIT
@ TEST_INIT
Definition test.h:200
TEST_EXECUTE
@ TEST_EXECUTE
Definition test.h:201
AST_TEST_PASS
@ AST_TEST_PASS
Definition test.h:195
AST_TEST_NOT_RUN
@ AST_TEST_NOT_RUN
Definition test.h:194
cache_update
static int cache_update(struct stasis_message *msg, const void *data)
Message matcher looking for cache update messages.
Definition test_stasis_endpoints.c:48
test_category
static const char * test_category
Definition test_stasis_endpoints.c:45
RAII_VAR
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition utils.h:981

References ao2_cleanup, ast_endpoint_create(), ast_endpoint_shutdown(), ast_endpoint_snapshot_type(), ast_endpoint_topic_all_cached(), ast_hangup(), AST_TEST_NOT_RUN, AST_TEST_PASS, cache_update(), NULL, RAII_VAR, ast_endpoint_snapshot::resource, stasis_cache_update_type(), stasis_message_data(), stasis_message_sink_cb(), stasis_message_sink_create(), stasis_message_sink_wait_for(), STASIS_SINK_DEFAULT_WAIT, stasis_subscribe, stasis_unsubscribe(), sub, ast_endpoint_snapshot::tech, test_category, TEST_EXECUTE, TEST_INIT, type, and update().

◆ AST_TEST_DEFINE() [2/3]

AST_TEST_DEFINE ( channel_messages  )

Definition at line 206 of file test_stasis_endpoints.c.

207{
208 RAII_VAR(struct ast_endpoint *, uut, NULL, ast_endpoint_shutdown);
209 RAII_VAR(struct ast_channel *, chan, NULL, ast_hangup);
210 RAII_VAR(struct stasis_message_sink *, sink, NULL, ao2_cleanup);
211 RAII_VAR(struct stasis_subscription *, sub, NULL, stasis_unsubscribe);
212 struct stasis_message *msg;
213 struct stasis_message_type *type;
214 struct ast_endpoint_snapshot *actual_snapshot;
215 int expected_count;
216 int actual_count;
217 int i;
218 int channel_index = -1;
219 int endpoint_index = -1;
220
221 switch (cmd) {
222 case TEST_INIT:
223 info->name = __func__;
224 info->category = test_category;
225 info->summary = "Test channel messages on an endpoint topic";
226 info->description =
227 "Test channel messages on an endpoint topic";
228 return AST_TEST_NOT_RUN;
229 case TEST_EXECUTE:
230 break;
231 }
232
233 uut = ast_endpoint_create("TEST", __func__);
234 ast_test_validate(test, NULL != uut);
235
236 sink = stasis_message_sink_create();
237 ast_test_validate(test, NULL != sink);
238
239 sub = stasis_subscribe(ast_endpoint_topic(uut),
240 stasis_message_sink_cb(), sink);
241 ast_test_validate(test, NULL != sub);
242
243 chan = ast_channel_alloc(0, AST_STATE_DOWN, "100", __func__, "100",
244 "100", "default", NULL, NULL, 0, "TEST/test_res");
245 ast_test_validate(test, NULL != chan);
246
247 ast_endpoint_add_channel(uut, chan);
248
249 actual_count = stasis_message_sink_wait_for_count(sink, 1,
250 STASIS_SINK_DEFAULT_WAIT);
251 ast_test_validate(test, 1 == actual_count);
252
253 msg = sink->messages[0];
254 type = stasis_message_type(msg);
255 ast_test_validate(test, ast_endpoint_snapshot_type() == type);
256 actual_snapshot = stasis_message_data(msg);
257 ast_test_validate(test, 1 == actual_snapshot->num_channels);
258
259 ast_endpoint_remove_channel(uut, chan);
260
261 ast_hangup(chan);
262 chan = NULL;
263
264 expected_count = 3;
265 actual_count = stasis_message_sink_wait_for_count(sink, expected_count,
266 STASIS_SINK_DEFAULT_WAIT);
267 ast_test_validate(test, expected_count == actual_count);
268
269 for (i = 0; i < expected_count; i++) {
270 msg = sink->messages[i];
271 type = stasis_message_type(msg);
272 if (type == ast_channel_snapshot_type()) {
273 channel_index = i;
274 }
275 if (type == ast_endpoint_snapshot_type()) {
276 endpoint_index = i;
277 }
278 }
279 ast_test_validate(test, channel_index >= 0 && endpoint_index >= 0);
280 actual_snapshot = stasis_message_data(sink->messages[endpoint_index]);
281 ast_test_validate(test, 0 == actual_snapshot->num_channels);
282
283 return AST_TEST_PASS;
284}
ast_channel_alloc
#define ast_channel_alloc(needqueue, state, cid_num, cid_name, acctcode, exten, context, assignedids, requestor, amaflag,...)
Create a channel structure.
Definition channel.h:1299
AST_STATE_DOWN
@ AST_STATE_DOWN
Definition channelstate.h:36
ast_endpoint_add_channel
int ast_endpoint_add_channel(struct ast_endpoint *endpoint, struct ast_channel *chan)
Adds a channel to the given endpoint.
Definition main/endpoints.c:156
ast_endpoint_remove_channel
int ast_endpoint_remove_channel(struct ast_endpoint *endpoint, struct ast_channel *chan)
Removes a channel from the given endpoint.
Definition main/endpoints.c:174
ast_endpoint_topic
struct stasis_topic * ast_endpoint_topic(struct ast_endpoint *endpoint)
Returns the topic for a specific endpoint.
Definition main/endpoints.c:90
ast_channel_snapshot_type
struct stasis_message_type * ast_channel_snapshot_type(void)
Message type for ast_channel_snapshot_update.
stasis_message_sink_wait_for_count
int stasis_message_sink_wait_for_count(struct stasis_message_sink *sink, int num_messages, int timeout_millis)
Wait for a sink's num_messages field to reach a certain level.
Definition res_stasis_test.c:149
ast_endpoint_snapshot::num_channels
int num_channels
Definition stasis_endpoints.h:63

References ao2_cleanup, ast_channel_alloc, ast_channel_snapshot_type(), ast_endpoint_add_channel(), ast_endpoint_create(), ast_endpoint_remove_channel(), ast_endpoint_shutdown(), ast_endpoint_snapshot_type(), ast_endpoint_topic(), ast_hangup(), AST_STATE_DOWN, AST_TEST_NOT_RUN, AST_TEST_PASS, NULL, ast_endpoint_snapshot::num_channels, RAII_VAR, stasis_message_data(), stasis_message_sink_cb(), stasis_message_sink_create(), stasis_message_sink_wait_for_count(), STASIS_SINK_DEFAULT_WAIT, stasis_subscribe, stasis_unsubscribe(), sub, test_category, TEST_EXECUTE, TEST_INIT, and type.

◆ AST_TEST_DEFINE() [3/3]

AST_TEST_DEFINE ( state_changes  )

Definition at line 70 of file test_stasis_endpoints.c.

71{
72 RAII_VAR(struct ast_endpoint *, uut, NULL, ast_endpoint_shutdown);
73 RAII_VAR(struct ast_channel *, chan, NULL, ast_hangup);
74 RAII_VAR(struct stasis_message_sink *, sink, NULL, ao2_cleanup);
75 RAII_VAR(struct stasis_subscription *, sub, NULL, stasis_unsubscribe);
76 struct stasis_message *msg;
77 struct stasis_message_type *type;
78 struct ast_endpoint_snapshot *actual_snapshot;
79 int actual_count;
80
81 switch (cmd) {
82 case TEST_INIT:
83 info->name = __func__;
84 info->category = test_category;
85 info->summary = "Test endpoint updates as its state changes";
86 info->description =
87 "Test endpoint updates as its state changes";
88 return AST_TEST_NOT_RUN;
89 case TEST_EXECUTE:
90 break;
91 }
92
93 uut = ast_endpoint_create("TEST", __func__);
94 ast_test_validate(test, NULL != uut);
95
96 sink = stasis_message_sink_create();
97 ast_test_validate(test, NULL != sink);
98
99 sub = stasis_subscribe(ast_endpoint_topic(uut),
100 stasis_message_sink_cb(), sink);
101 ast_test_validate(test, NULL != sub);
102
103 ast_endpoint_set_state(uut, AST_ENDPOINT_OFFLINE);
104 actual_count = stasis_message_sink_wait_for_count(sink, 1,
105 STASIS_SINK_DEFAULT_WAIT);
106 ast_test_validate(test, 1 == actual_count);
107 msg = sink->messages[0];
108 type = stasis_message_type(msg);
109 ast_test_validate(test, ast_endpoint_snapshot_type() == type);
110 actual_snapshot = stasis_message_data(msg);
111 ast_test_validate(test, AST_ENDPOINT_OFFLINE == actual_snapshot->state);
112
113 ast_endpoint_set_max_channels(uut, 8675309);
114 actual_count = stasis_message_sink_wait_for_count(sink, 2,
115 STASIS_SINK_DEFAULT_WAIT);
116 ast_test_validate(test, 2 == actual_count);
117 msg = sink->messages[1];
118 type = stasis_message_type(msg);
119 ast_test_validate(test, ast_endpoint_snapshot_type() == type);
120 actual_snapshot = stasis_message_data(msg);
121 ast_test_validate(test, 8675309 == actual_snapshot->max_channels);
122
123 return AST_TEST_PASS;
124}
AST_ENDPOINT_OFFLINE
@ AST_ENDPOINT_OFFLINE
Definition endpoints.h:55
ast_endpoint_set_state
void ast_endpoint_set_state(struct ast_endpoint *endpoint, enum ast_endpoint_state state)
Updates the state of the given endpoint.
Definition main/endpoints.c:364
ast_endpoint_set_max_channels
void ast_endpoint_set_max_channels(struct ast_endpoint *endpoint, int max_channels)
Updates the maximum number of channels an endpoint supports.
Definition main/endpoints.c:376
ast_endpoint_snapshot::state
enum ast_endpoint_state state
Definition stasis_endpoints.h:56
ast_endpoint_snapshot::max_channels
int max_channels
Definition stasis_endpoints.h:61

References ao2_cleanup, ast_endpoint_create(), AST_ENDPOINT_OFFLINE, ast_endpoint_set_max_channels(), ast_endpoint_set_state(), ast_endpoint_shutdown(), ast_endpoint_snapshot_type(), ast_endpoint_topic(), ast_hangup(), AST_TEST_NOT_RUN, AST_TEST_PASS, ast_endpoint_snapshot::max_channels, NULL, RAII_VAR, stasis_message_data(), stasis_message_sink_cb(), stasis_message_sink_create(), stasis_message_sink_wait_for_count(), STASIS_SINK_DEFAULT_WAIT, stasis_subscribe, stasis_unsubscribe(), ast_endpoint_snapshot::state, sub, test_category, TEST_EXECUTE, TEST_INIT, and type.

◆ cache_update()

static int cache_update ( struct stasis_message *  msg,
const void *  data 
)
static

Message matcher looking for cache update messages.

Definition at line 48 of file test_stasis_endpoints.c.

48 {
49 struct stasis_cache_update *update;
50 struct ast_endpoint_snapshot *snapshot;
51 const char *name = data;
52
53 if (stasis_cache_update_type() != stasis_message_type(msg)) {
54 return 0;
55 }
56
57 update = stasis_message_data(msg);
58 if (ast_endpoint_snapshot_type() != update->type) {
59 return 0;
60 }
61
62 snapshot = stasis_message_data(update->old_snapshot);
63 if (!snapshot) {
64 snapshot = stasis_message_data(update->new_snapshot);
65 }
66
67 return 0 == strcmp(name, snapshot->resource);
68}
name
static const char name[]
Definition format_mp3.c:68

References ast_endpoint_snapshot_type(), name, ast_endpoint_snapshot::resource, stasis_cache_update_type(), stasis_message_data(), and update().

Referenced by AST_TEST_DEFINE().

◆ load_module()

static int load_module ( void  )
static

Definition at line 294 of file test_stasis_endpoints.c.

295{
296 AST_TEST_REGISTER(state_changes);
297 AST_TEST_REGISTER(cache_clear);
298 AST_TEST_REGISTER(channel_messages);
299 return AST_MODULE_LOAD_SUCCESS;
300}
AST_MODULE_LOAD_SUCCESS
@ AST_MODULE_LOAD_SUCCESS
Definition module.h:70
state_changes
The state change queue. State changes are queued for processing by a separate thread.
Definition devicestate.c:211
AST_TEST_REGISTER
#define AST_TEST_REGISTER(cb)
Definition test.h:127

References AST_MODULE_LOAD_SUCCESS, and AST_TEST_REGISTER.

◆ unload_module()

static int unload_module ( void  )
static

Definition at line 286 of file test_stasis_endpoints.c.

287{
288 AST_TEST_UNREGISTER(state_changes);
289 AST_TEST_UNREGISTER(cache_clear);
290 AST_TEST_UNREGISTER(channel_messages);
291 return 0;
292}
AST_TEST_UNREGISTER
#define AST_TEST_UNREGISTER(cb)
Definition test.h:128

References AST_TEST_UNREGISTER.

Variable Documentation

◆ __mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Endpoint stasis-related testing" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "res_stasis_test", }
static

Definition at line 307 of file test_stasis_endpoints.c.

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info
static

Definition at line 307 of file test_stasis_endpoints.c.

◆ test_category

const char* test_category = "/stasis/endpoints/"
static

Definition at line 45 of file test_stasis_endpoints.c.

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), and AST_TEST_DEFINE().

Generated on Wed Oct 29 2025 20:04:42 for Asterisk - The Open Source Telephony Project by doxygen 1.9.8