Asterisk - The Open Source Telephony Project  GIT-master-a24979a
mwi.c
Go to the documentation of this file.
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2019, Sangoma Technologies Corporation
5  *
6  * Kevin Harwell <kharwell@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18 
19 /*** MODULEINFO
20  <support_level>core</support_level>
21  ***/
22 
23 #include "asterisk.h"
24 
25 #include "asterisk/app.h"
26 #include "asterisk/mwi.h"
28 
29 /*!
30  * \brief Define \ref stasis topic objects
31  * @{
32  */
36 
37 /*! @} */
38 
39 /*! \brief Convert a MWI \ref stasis_message to a \ref ast_event */
41 {
42  struct ast_event *event;
43  struct ast_mwi_state *mwi_state;
44  char *mailbox;
45  char *context;
46 
47  if (!message) {
48  return NULL;
49  }
50 
51  mwi_state = stasis_message_data(message);
52 
53  /* Strip off @context */
54  context = mailbox = ast_strdupa(mwi_state->uniqueid);
55  strsep(&context, "@");
56  if (ast_strlen_zero(context)) {
57  context = "default";
58  }
59 
65  AST_EVENT_IE_EID, AST_EVENT_IE_PLTYPE_RAW, &mwi_state->eid, sizeof(mwi_state->eid),
67 
68  return event;
69 }
70 
71 /*!
72  * \brief Define \ref stasis message types for MWI
73  * @{
74  */
76  .to_event = mwi_to_event, );
78 
79 /*! @} */
80 
81 static void mwi_state_dtor(void *obj)
82 {
83  struct ast_mwi_state *mwi_state = obj;
85  ao2_cleanup(mwi_state->snapshot);
86  mwi_state->snapshot = NULL;
87 }
88 
90 {
92 }
93 
95 {
96  return mwi_state_cache;
97 }
98 
100 {
102 }
103 
104 struct stasis_topic *ast_mwi_topic(const char *uniqueid)
105 {
106  return stasis_state_topic(mwi_state_manager, uniqueid);
107 }
108 
109 static struct ast_mwi_state *mwi_create_state(const char *mailbox, const char *context,
110  int urgent_msgs, int new_msgs, int old_msgs)
111 {
112  struct ast_mwi_state *mwi_state;
113 
115 
116  mwi_state = ao2_alloc(sizeof(*mwi_state), mwi_state_dtor);
117  if (!mwi_state) {
118  ast_log(LOG_ERROR, "Unable to create MWI state for mailbox '%s@%s'\n",
120  return NULL;
121  }
122 
123  if (ast_string_field_init(mwi_state, 256)) {
124  ast_log(LOG_ERROR, "Unable to initialize MWI state for mailbox '%s@%s'\n",
126  ao2_ref(mwi_state, -1);
127  return NULL;
128  }
129  if (!ast_strlen_zero(context)) {
130  ast_string_field_build(mwi_state, uniqueid, "%s@%s", mailbox, context);
131  } else {
133  }
134 
135  mwi_state->urgent_msgs = urgent_msgs;
136  mwi_state->new_msgs = new_msgs;
137  mwi_state->old_msgs = old_msgs;
138 
139  return mwi_state;
140 }
141 
143 {
144  int urgent_msgs;
145  int new_msgs;
146  int old_msgs;
147 
150 }
151 
152 struct ast_mwi_state *ast_mwi_create(const char *mailbox, const char *context)
153 {
154  return mwi_create_state(mailbox, context, 0, 0, 0);
155 }
156 
157 /*!
158  * \internal
159  * \brief Create a MWI state snapshot message.
160  * \since 12.2.0
161  *
162  * \param[in] mailbox The mailbox identifier string.
163  * \param[in] context The context this mailbox resides in (NULL or "" if only using mailbox)
164  * \param urgent_msgs
165  * \param[in] new_msgs The number of new messages in this mailbox
166  * \param[in] old_msgs The number of old messages in this mailbox
167  * \param[in] channel_id A unique identifier for a channel associated with this
168  * change in mailbox state
169  * \param[in] eid The EID of the server that originally published the message
170  *
171  * \return message on success. Use ao2_cleanup() when done with it.
172  * \retval NULL on error.
173  */
175  const char *mailbox,
176  const char *context,
177  int urgent_msgs,
178  int new_msgs,
179  int old_msgs,
180  const char *channel_id,
181  struct ast_eid *eid)
182 {
183  struct ast_mwi_state *mwi_state;
184  struct stasis_message *message;
185 
186  if (!ast_mwi_state_type()) {
187  return NULL;
188  }
189 
190  mwi_state = mwi_create_state(mailbox, context, urgent_msgs, new_msgs, old_msgs);
191  if (!mwi_state) {
192  return NULL;
193  }
194 
195  if (!ast_strlen_zero(channel_id)) {
196  mwi_state->snapshot = ast_channel_snapshot_get_latest(channel_id);
197  }
198 
199  if (eid) {
200  mwi_state->eid = *eid;
201  } else {
202  mwi_state->eid = ast_eid_default;
203  }
204 
205  /*
206  * XXX As far as stasis is concerned, all MWI events are local.
207  *
208  * We may in the future want to make MWI aggregate local/remote
209  * message counts similar to how device state aggregates state.
210  */
212  ao2_cleanup(mwi_state);
213  return message;
214 }
215 
216 /*!
217  * \internal
218  *
219  * This object currently acts as a typedef, but can also be thought of as a "child" object
220  * of the stasis_state_subscriber type. As such the "base" pointer should always be the
221  * first object attribute. Doing so allows this object to be easily type cast and used by
222  * the stasis_state code.
223  */
225  /*! The "base" state subscriber. (Must be first object attribute) */
227 };
228 
230 {
233 }
234 
236  stasis_subscription_cb callback, void *data)
237 {
238  struct stasis_subscription *stasis_sub;
240  mwi_state_manager, mailbox, callback, data);
241 
242  if (!sub) {
243  return NULL;
244  }
245 
246  stasis_sub = ast_mwi_subscriber_subscription(sub);
247 
250 
251  return sub;
252 }
253 
255 {
257 }
258 
260 {
262 }
263 
265 {
267 }
268 
270 {
272  struct ast_mwi_state *mwi_state = stasis_state_subscriber_data(s);
273 
275 }
276 
278 {
280 }
281 
282 /*!
283  * \internal
284  *
285  * This object currently acts as a typedef, but can also be thought of as a "child" object
286  * of the stasis_state_publisher type. As such the "base" pointer should always be the
287  * first object attribute. Doing so allows this object to be easily type cast and used by
288  * the stasis_state code.
289  */
291  /*! The "base" state publisher. (Must be first object attribute) */
293 };
294 
296 {
299 }
300 
302 {
304  (struct stasis_state_observer *)observer);
305 }
306 
308 {
310  (struct stasis_state_observer *)observer);
311 }
312 
315  void *data;
316 };
317 
318 static int handle_mwi_state(const char *id, struct stasis_message *msg, void *user_data)
319 {
320  struct mwi_handler_data *d = user_data;
321  struct ast_mwi_state *mwi_state = stasis_message_data(msg);
322  int res;
323 
324  if (mwi_state) {
325  return d->handler(mwi_state, d->data);
326  }
327 
328  mwi_state = mwi_create_state(id, NULL, 0, 0, 0);
329  if (!mwi_state) {
330  return 0;
331  }
332 
333  res = d->handler(mwi_state, d->data);
334  ao2_ref(mwi_state, -1);
335  return res;
336 }
337 
339 {
340  struct mwi_handler_data d = {
341  .handler = handler,
342  .data = data
343  };
344 
346 }
347 
349 {
350  struct mwi_handler_data d = {
351  .handler = handler,
352  .data = data
353  };
354 
356 }
357 
358 int ast_mwi_publish(struct ast_mwi_publisher *pub, int urgent_msgs,
359  int new_msgs, int old_msgs, const char *channel_id, struct ast_eid *eid)
360 {
361  struct stasis_state_publisher *p = (struct stasis_state_publisher *)pub;
363  NULL, urgent_msgs, new_msgs, old_msgs, channel_id, eid);
364 
365  if (!msg) {
366  return -1;
367  }
368 
369  stasis_state_publish(p, msg);
370  ao2_ref(msg, -1);
371 
372  return 0;
373 }
374 
375 int ast_mwi_publish_by_mailbox(const char *mailbox, const char *context, int urgent_msgs,
376  int new_msgs, int old_msgs, const char *channel_id, struct ast_eid *eid)
377 {
378  struct ast_mwi_state *mwi_state;
380  mailbox, context, urgent_msgs, new_msgs, old_msgs, channel_id, eid);
381 
382  if (!msg) {
383  return -1;
384  }
385 
386  mwi_state = stasis_message_data(msg);
388  ao2_ref(msg, -1);
389 
390  return 0;
391 }
392 
394  const char *mailbox,
395  const char *context,
396  int new_msgs,
397  int old_msgs,
398  const char *channel_id,
399  struct ast_eid *eid)
400 {
401  return ast_mwi_publish_by_mailbox(mailbox, context, 0, new_msgs, old_msgs, channel_id, eid);
402 }
403 
404 int ast_delete_mwi_state_full(const char *mailbox, const char *context, struct ast_eid *eid)
405 {
406  RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
407  struct stasis_message *cached_msg;
408  struct stasis_message *clear_msg;
409  struct ast_mwi_state *mwi_state;
410 
411  msg = mwi_state_create_message(mailbox, context, 0, 0, 0, NULL, eid);
412  if (!msg) {
413  return -1;
414  }
415 
416  mwi_state = stasis_message_data(msg);
417 
418  /*
419  * XXX As far as stasis is concerned, all MWI events are local.
420  *
421  * For now, it is assumed that there is only one entity
422  * maintaining the state of a particular mailbox.
423  *
424  * If we ever have multiple MWI event entities maintaining
425  * the same mailbox that wish to delete their cached entry
426  * we will need to do something about the race condition
427  * potential between checking the cache and removing the
428  * cache entry.
429  */
432  if (!cached_msg) {
433  /* Nothing to clear from the cache, but still need to remove state */
435  return -1;
436  }
437  ao2_cleanup(cached_msg);
438 
439  clear_msg = stasis_cache_clear_create(msg);
441  ao2_cleanup(clear_msg);
442 
443  return 0;
444 }
445 
446 static const char *mwi_state_get_id(struct stasis_message *message)
447 {
449  struct ast_mwi_state *mwi_state = stasis_message_data(message);
450  return mwi_state->uniqueid;
453  return change->uniqueid;
454  }
455 
456  return NULL;
457 }
458 
459 static void mwi_blob_dtor(void *obj)
460 {
461  struct ast_mwi_blob *mwi_blob = obj;
462 
463  ao2_cleanup(mwi_blob->mwi_state);
464  ast_json_unref(mwi_blob->blob);
465 }
466 
468  struct stasis_message_type *message_type,
469  struct ast_json *blob)
470 {
471  struct ast_mwi_blob *obj;
472  struct stasis_message *msg;
473 
474  ast_assert(blob != NULL);
475 
476  if (!message_type) {
477  return NULL;
478  }
479 
480  obj = ao2_alloc(sizeof(*obj), mwi_blob_dtor);
481  if (!obj) {
482  return NULL;
483  }
484 
485  obj->mwi_state = mwi_state;
486  ao2_ref(obj->mwi_state, +1);
487  obj->blob = ast_json_ref(blob);
488 
489  /* This is not a normal MWI event. Only used by the MinivmNotify app. */
490  msg = stasis_message_create(message_type, obj);
491  ao2_ref(obj, -1);
492 
493  return msg;
494 }
495 
496 static void mwi_cleanup(void)
497 {
505 }
506 
507 int mwi_init(void)
508 {
510 
512  return -1;
513  }
514 
516  return -1;
517  }
518 
520  if (!mwi_state_manager) {
521  return -1;
522  }
523 
525  if (!mwi_state_cache) {
526  return -1;
527  }
528 
530  if (!mwi_topic_cached) {
531  return -1;
532  }
533 
534  return 0;
535 }
Asterisk main include file. File version handling, generic pbx functions.
int ast_register_cleanup(void(*func)(void))
Register a function to be executed before Asterisk gracefully exits.
Definition: clicompat.c:19
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:298
#define ast_log
Definition: astobj2.c:42
#define ao2_cleanup(obj)
Definition: astobj2.h:1934
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition: astobj2.h:459
#define ao2_alloc(data_size, destructor_fn)
Definition: astobj2.h:409
static char context[AST_MAX_CONTEXT]
Definition: chan_alsa.c:120
static char mailbox[AST_MAX_MAILBOX_UNIQUEID]
Definition: chan_mgcp.c:207
struct ast_event * ast_event_new(enum ast_event_type event_type,...)
Create a new event.
Definition: event.c:402
@ AST_EVENT_IE_END
Definition: event_defs.h:70
@ AST_EVENT_IE_CONTEXT
Context IE Used by AST_EVENT_MWI Payload type: str.
Definition: event_defs.h:127
@ AST_EVENT_IE_EID
Entity ID Used by All events Payload type: RAW This IE indicates which server the event originated fr...
Definition: event_defs.h:272
@ AST_EVENT_IE_MAILBOX
Mailbox name.
Definition: event_defs.h:89
@ AST_EVENT_IE_OLDMSGS
Number of Used by: AST_EVENT_MWI Payload type: UINT.
Definition: event_defs.h:83
@ AST_EVENT_IE_NEWMSGS
Number of new messages Used by: AST_EVENT_MWI Payload type: UINT.
Definition: event_defs.h:77
@ AST_EVENT_MWI
Definition: event_defs.h:38
@ AST_EVENT_IE_PLTYPE_RAW
Definition: event_defs.h:330
@ AST_EVENT_IE_PLTYPE_UINT
Definition: event_defs.h:326
@ AST_EVENT_IE_PLTYPE_STR
Definition: event_defs.h:328
struct ast_channel_snapshot * ast_channel_snapshot_get_latest(const char *uniqueid)
Obtain the latest ast_channel_snapshot from the Stasis Message Bus API cache. This is an ao2 object,...
struct stasis_message_type * stasis_subscription_change_type(void)
Gets the message type for subscription change notices.
Application convenience functions, designed to give consistent look and feel to Asterisk apps.
int ast_app_inboxcount2(const char *mailboxes, int *urgentmsgs, int *newmsgs, int *oldmsgs)
Determine number of urgent/new/old messages in a mailbox.
Definition: main/app.c:689
char * strsep(char **str, const char *delims)
#define LOG_ERROR
struct ast_json * ast_json_ref(struct ast_json *value)
Increase refcount on value.
Definition: json.c:67
void ast_json_unref(struct ast_json *value)
Decrease refcount on value. If refcount reaches zero, value is freed.
Definition: json.c:73
static struct ast_mwi_state * mwi_create_state(const char *mailbox, const char *context, int urgent_msgs, int new_msgs, int old_msgs)
Definition: mwi.c:109
static void mwi_state_dtor(void *obj)
Definition: mwi.c:81
struct ast_mwi_state * ast_mwi_create(const char *mailbox, const char *context)
Create a ast_mwi_state object.
Definition: mwi.c:152
static struct ast_event * mwi_to_event(struct stasis_message *message)
Convert a MWI stasis_message to a ast_event.
Definition: mwi.c:40
static struct stasis_caching_topic * mwi_topic_cached
Definition: mwi.c:35
struct stasis_subscription * ast_mwi_subscriber_subscription(struct ast_mwi_subscriber *sub)
Retrieve the stasis MWI topic subscription if available.
Definition: mwi.c:277
static const char * mwi_state_get_id(struct stasis_message *message)
Definition: mwi.c:446
static struct stasis_state_manager * mwi_state_manager
Define Stasis Message Bus API topic objects.
Definition: mwi.c:33
struct stasis_topic * ast_mwi_topic_all(void)
Get the Stasis Message Bus API topic for MWI messages.
Definition: mwi.c:89
int mwi_init(void)
Initialize the mwi core.
Definition: mwi.c:507
static struct stasis_cache * mwi_state_cache
Definition: mwi.c:34
struct stasis_topic * ast_mwi_subscriber_topic(struct ast_mwi_subscriber *sub)
Retrieves the MWI subscriber's topic.
Definition: mwi.c:264
static struct ast_mwi_state * mwi_retrieve_then_create_state(const char *mailbox)
Definition: mwi.c:142
struct stasis_message * ast_mwi_blob_create(struct ast_mwi_state *mwi_state, struct stasis_message_type *message_type, struct ast_json *blob)
Creates a ast_mwi_blob message.
Definition: mwi.c:467
struct ast_mwi_publisher * ast_mwi_add_publisher(const char *mailbox)
Add an MWI state publisher to the mailbox.
Definition: mwi.c:295
struct stasis_cache * ast_mwi_state_cache(void)
Backend cache for ast_mwi_topic_cached().
Definition: mwi.c:94
void * ast_mwi_unsubscribe(struct ast_mwi_subscriber *sub)
Unsubscribe from the stasis topic and MWI.
Definition: mwi.c:254
int ast_publish_mwi_state_full(const char *mailbox, const char *context, int new_msgs, int old_msgs, const char *channel_id, struct ast_eid *eid)
Publish a MWI state update via stasis with all parameters.
Definition: mwi.c:393
static void mwi_cleanup(void)
Definition: mwi.c:496
int ast_mwi_publish(struct ast_mwi_publisher *pub, int urgent_msgs, int new_msgs, int old_msgs, const char *channel_id, struct ast_eid *eid)
Publish MWI for the given mailbox.
Definition: mwi.c:358
struct stasis_topic * ast_mwi_topic_cached(void)
Get the Stasis Message Bus API caching topic for MWI messages.
Definition: mwi.c:99
void ast_mwi_state_callback_all(on_mwi_state handler, void *data)
For each managed mailbox call the given handler.
Definition: mwi.c:338
void ast_mwi_state_callback_subscribed(on_mwi_state handler, void *data)
For each managed mailbox that has a subscriber call the given handler.
Definition: mwi.c:348
int ast_mwi_add_observer(struct ast_mwi_observer *observer)
Add an observer to receive MWI state related events.
Definition: mwi.c:301
int ast_delete_mwi_state_full(const char *mailbox, const char *context, struct ast_eid *eid)
Delete MWI state cached by stasis with all parameters.
Definition: mwi.c:404
struct ast_mwi_subscriber * ast_mwi_add_subscriber(const char *mailbox)
Add an MWI state subscriber to the mailbox.
Definition: mwi.c:229
static void mwi_blob_dtor(void *obj)
Definition: mwi.c:459
static int handle_mwi_state(const char *id, struct stasis_message *msg, void *user_data)
Definition: mwi.c:318
void * ast_mwi_unsubscribe_and_join(struct ast_mwi_subscriber *sub)
Unsubscribe from the stasis topic, block until the final message is received, and then unsubscribe fr...
Definition: mwi.c:259
void ast_mwi_remove_observer(struct ast_mwi_observer *observer)
Remove an MWI state observer.
Definition: mwi.c:307
struct ast_mwi_subscriber * ast_mwi_subscribe_pool(const char *mailbox, stasis_subscription_cb callback, void *data)
Add an MWI state subscriber, and stasis subscription to the mailbox.
Definition: mwi.c:235
struct stasis_topic * ast_mwi_topic(const char *uniqueid)
Get the Stasis Message Bus API topic for MWI messages on a unique ID.
Definition: mwi.c:104
struct ast_mwi_state * ast_mwi_subscriber_data(struct ast_mwi_subscriber *sub)
Retrieves the state data object associated with the MWI subscriber.
Definition: mwi.c:269
STASIS_MESSAGE_TYPE_DEFN(ast_mwi_state_type,.to_event=mwi_to_event,)
Define Stasis Message Bus API message types for MWI.
static struct stasis_message * mwi_state_create_message(const char *mailbox, const char *context, int urgent_msgs, int new_msgs, int old_msgs, const char *channel_id, struct ast_eid *eid)
Definition: mwi.c:174
int ast_mwi_publish_by_mailbox(const char *mailbox, const char *context, int urgent_msgs, int new_msgs, int old_msgs, const char *channel_id, struct ast_eid *eid)
Publish MWI for the given mailbox.
Definition: mwi.c:375
Asterisk MWI API.
struct stasis_message_type * ast_mwi_vm_app_type(void)
Get the Stasis Message Bus API message type for voicemail application specific messages.
int(* on_mwi_state)(struct ast_mwi_state *mwi_state, void *data)
The delegate called for each managed mailbox state.
Definition: mwi.h:301
struct stasis_message_type * ast_mwi_state_type(void)
Get the Stasis Message Bus API message type for MWI messages.
struct stasis_forward * sub
Definition: res_corosync.c:240
struct ast_sorcery_instance_observer observer
#define NULL
Definition: resample.c:96
struct stasis_message * stasis_message_create_full(struct stasis_message_type *type, void *data, const struct ast_eid *eid)
Create a new message for an entity.
struct stasis_message * stasis_cache_clear_create(struct stasis_message *message)
A message which instructs the caching topic to remove an entry from its cache.
Definition: stasis_cache.c:778
struct stasis_message * stasis_cache_get_by_eid(struct stasis_cache *cache, struct stasis_message_type *type, const char *id, const struct ast_eid *eid)
Retrieve an item from the cache for a specific entity.
Definition: stasis_cache.c:659
void(* stasis_subscription_cb)(void *data, struct stasis_subscription *sub, struct stasis_message *message)
Callback function type for Stasis subscriptions.
Definition: stasis.h:611
#define STASIS_MESSAGE_TYPE_CLEANUP(name)
Boiler-plate messaging macro for cleaning up message types.
Definition: stasis.h:1515
@ STASIS_SUBSCRIPTION_FILTER_SELECTIVE
Definition: stasis.h:297
struct stasis_caching_topic * stasis_caching_topic_create(struct stasis_topic *original_topic, struct stasis_cache *cache)
Create a topic which monitors and caches messages from another topic.
Definition: stasis_cache.c:948
int stasis_subscription_accept_message_type(struct stasis_subscription *subscription, const struct stasis_message_type *type)
Indicate to a subscription that we are interested in a message type.
Definition: stasis.c:1025
int stasis_subscription_set_filter(struct stasis_subscription *subscription, enum stasis_subscription_message_filter filter)
Set the message type filtering level on a subscription.
Definition: stasis.c:1079
struct stasis_topic * stasis_caching_get_topic(struct stasis_caching_topic *caching_topic)
Returns the topic of cached events from a caching topics.
Definition: stasis_cache.c:85
struct stasis_cache * stasis_cache_create(snapshot_get_id id_fn)
Create a cache.
Definition: stasis_cache.c:360
#define STASIS_MESSAGE_TYPE_INIT(name)
Boiler-plate messaging macro for initializing message types.
Definition: stasis.h:1493
struct stasis_message * stasis_message_create(struct stasis_message_type *type, void *data)
Create a new message.
struct stasis_message_type * stasis_message_type(const struct stasis_message *msg)
Get the message type for a stasis_message.
struct stasis_caching_topic * stasis_caching_unsubscribe_and_join(struct stasis_caching_topic *caching_topic)
Unsubscribes a caching topic from its upstream topic, blocking until all messages have been forwarded...
Definition: stasis_cache.c:146
void * stasis_message_data(const struct stasis_message *msg)
Get the data contained in a message.
struct stasis_state_subscriber * stasis_state_add_subscriber(struct stasis_state_manager *manager, const char *id)
Add a subscriber to the managed stasis state for the given id.
Definition: stasis_state.c:413
struct stasis_state_manager * stasis_state_manager_create(const char *topic_name)
Create a stasis state manager.
Definition: stasis_state.c:325
void stasis_state_callback_all(struct stasis_state_manager *manager, on_stasis_state handler, void *data)
For each managed state call the given handler.
Definition: stasis_state.c:741
void stasis_state_publish_by_id(struct stasis_state_manager *manager, const char *id, const struct ast_eid *eid, struct stasis_message *msg)
Publish to a managed named by id topic, and add an implicit subscriber.
Definition: stasis_state.c:639
void * stasis_state_subscriber_data(struct stasis_state_subscriber *sub)
Retrieve the last known state stasis message payload for the subscriber.
Definition: stasis_state.c:498
struct stasis_topic * stasis_state_topic(struct stasis_state_manager *manager, const char *id)
Retrieve a managed topic creating one if not currently managed.
Definition: stasis_state.c:370
void * stasis_state_unsubscribe(struct stasis_state_subscriber *sub)
Unsubscribe from the stasis topic and stasis state.
Definition: stasis_state.c:471
void stasis_state_remove_observer(struct stasis_state_manager *manager, struct stasis_state_observer *observer)
Remove an observer (will no longer receive managed state related events).
Definition: stasis_state.c:701
const char * stasis_state_subscriber_id(const struct stasis_state_subscriber *sub)
Retrieve the underlying subscribed to state's unique id.
Definition: stasis_state.c:488
int stasis_state_add_observer(struct stasis_state_manager *manager, struct stasis_state_observer *observer)
Add an observer to receive managed state related events.
Definition: stasis_state.c:689
void * stasis_state_unsubscribe_and_join(struct stasis_state_subscriber *sub)
Unsubscribe from the stasis topic, block until the final message is received, and then unsubscribe fr...
Definition: stasis_state.c:478
struct stasis_topic * stasis_state_subscriber_topic(struct stasis_state_subscriber *sub)
Retrieve the subscriber's topic.
Definition: stasis_state.c:493
struct stasis_subscription * stasis_state_subscriber_subscription(struct stasis_state_subscriber *sub)
Retrieve the stasis topic subscription if available.
Definition: stasis_state.c:514
void stasis_state_callback_subscribed(struct stasis_state_manager *manager, on_stasis_state handler, void *data)
For each managed, and explicitly subscribed state call the given handler.
Definition: stasis_state.c:764
const char * stasis_state_publisher_id(const struct stasis_state_publisher *pub)
Retrieve the publisher's underlying state's unique id.
Definition: stasis_state.c:553
void stasis_state_remove_publish_by_id(struct stasis_state_manager *manager, const char *id, const struct ast_eid *eid, struct stasis_message *msg)
Publish to a managed named by id topic, and remove an implicit publisher.
Definition: stasis_state.c:659
void stasis_state_publish(struct stasis_state_publisher *pub, struct stasis_message *msg)
Publish to a managed state (topic) using a publisher.
Definition: stasis_state.c:563
struct stasis_state_publisher * stasis_state_add_publisher(struct stasis_state_manager *manager, const char *id)
Add a publisher to the managed state for the given id.
Definition: stasis_state.c:532
struct stasis_topic * stasis_state_all_topic(struct stasis_state_manager *manager)
Retrieve the manager's topic (the topic that all state topics get forwarded to)
Definition: stasis_state.c:365
struct stasis_state_subscriber * stasis_state_subscribe_pool(struct stasis_state_manager *manager, const char *id, stasis_subscription_cb callback, void *data)
Add a subscriber, and subscribe to its underlying stasis topic.
Definition: stasis_state.c:447
#define ast_string_field_set(x, field, data)
Set a field to a simple string value.
Definition: stringfields.h:521
#define ast_string_field_init(x, size)
Initialize a field pool and fields.
Definition: stringfields.h:359
#define ast_string_field_build(x, field, fmt, args...)
Set a field to a complex (built) value.
Definition: stringfields.h:555
#define ast_string_field_free_memory(x)
free all memory - to be called before destroying the object
Definition: stringfields.h:374
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition: strings.h:65
An Entity ID is essentially a MAC address, brief and unique.
Definition: utils.h:808
An event.
Definition: event.c:81
Abstract JSON element (object, array, string, int, ...).
Object that represents an MWI update with some additional application defined data.
Definition: mwi.h:471
struct ast_mwi_state * mwi_state
Definition: mwi.h:472
struct ast_json * blob
Definition: mwi.h:473
MWI state event interface.
Definition: mwi.h:248
struct stasis_state_publisher * base
Definition: mwi.c:292
The structure that contains MWI state.
Definition: mwi.h:455
int urgent_msgs
Definition: mwi.h:464
struct ast_channel_snapshot * snapshot
Definition: mwi.h:462
int old_msgs
Definition: mwi.h:460
int new_msgs
Definition: mwi.h:459
const ast_string_field uniqueid
Definition: mwi.h:458
struct ast_eid eid
Definition: mwi.h:463
struct stasis_state_subscriber * base
Definition: mwi.c:226
Definition: astman.c:222
void * data
Definition: mwi.c:315
on_mwi_state handler
Definition: mwi.c:314
struct ast_eid eid
Managed stasis state event interface.
Definition: stasis_state.h:463
Holds details about changes to subscriptions for the specified topic.
Definition: stasis.h:890
static void handler(const char *name, int response_code, struct ast_variable *get_params, struct ast_variable *path_vars, struct ast_variable *headers, struct ast_json *body, struct ast_ari_response *response)
Definition: test_ari.c:59
static struct test_val d
#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:936
#define ast_assert(a)
Definition: utils.h:734
struct ast_eid ast_eid_default
Global EID.
Definition: options.c:93