messaging.cpp File Reference

#include "messaging.h"
#include <condition_variable>
#include <iostream>
#include <memory>
#include <mutex>
#include <unordered_map>
#include "debug.h"
#include "module.h"
#include "utils/list.h"
#include "utils/lock_guard.h"

Include dependency graph for messaging.cpp:

Go to the source code of this file.

Classes
struct	response

Macros
#define	MAX_MESSAGES   100
#define	MAX_MESSAGES_FOR_NOT_EXISTING_RECV   10
#define	MOD_NAME   "[messaging] "

Functions
struct message *	check_message (struct module *mod)
void	free_message (struct message *msg, struct response *r)
void	free_message_for_child (void *m, struct response *r)
void	free_response (struct response *r)
void	module_check_undelivered_messages (struct module *node)
	Sends message with waiting for response.
void	module_store_message (struct module *node, struct message *m)
struct message *	new_message (size_t len)
struct response *	new_response (int status, const char *text)
int	response_get_status (struct response *r)
const char *	response_get_text (struct response *r)
const char *	response_status_to_text (int status)
struct response *	send_message (struct module *root, const char *const_path, struct message *msg)
	Sends message without waiting for response.
static struct response *	send_message_common (struct module *root, const char *const_path, struct message *msg, bool sync, int timeout_ms, int flags)
struct response *	send_message_sync (struct module *root, const char *const_path, struct message *msg, int timeout_ms, int flags)
	Sends message without waiting for response.
struct response *	send_message_to_receiver (struct module *receiver, struct message *msg)

Detailed Description

Author

Martin Pulec marti.nosp@m.n.pu.nosp@m.lec@c.nosp@m.esne.nosp@m.t.cz

Communication infrastructure for passing messages between individual UltraGrid modules.

Definition in file messaging.cpp.

Macro Definition Documentation

MAX_MESSAGES

#define MAX_MESSAGES   100

Definition at line 59 of file messaging.cpp.

Referenced by send_message_common().

MAX_MESSAGES_FOR_NOT_EXISTING_RECV

#define MAX_MESSAGES_FOR_NOT_EXISTING_RECV   10

Definition at line 60 of file messaging.cpp.

Referenced by send_message_common().

MOD_NAME

#define MOD_NAME   "[messaging] "

Definition at line 61 of file messaging.cpp.

Referenced by send_message_common().

Function Documentation

check_message()

struct message * check_message

(

struct module *

mod

)

Definition at line 394 of file messaging.cpp.

{
        pthread_mutex_guard guard(mod->msg_queue_lock);
 
        if(simple_linked_list_size(mod->msg_queue) > 0) {
                return (struct message *) simple_linked_list_pop(mod->msg_queue);
        } else {
                return NULL;
        }
}

References module::msg_queue, module::msg_queue_lock, simple_linked_list_pop(), and simple_linked_list_size().

Referenced by audio_decoder_process_message(), audio_done(), audio_receiver_thread(), audio_sender_thread(), capture_filter(), video_rxtx::check_sender_messages(), compress_frame(), decoder_process_message(), display_conference_worker(), display_get_frame(), display_sdl2_run(), display_sdl_run(), fec_check_messages(), filter(), filter(), filter(), Filter_chain::filter(), gl_process_frames(), module_done(), keyboard_control::impl::msg_received(), process_messages(), process_messages(), ultragrid_rtp_video_rxtx::receiver_process_messages(), vidcap_file_process_messages(), vidcap_import_new_message(), vidcap_switcher_grab(), and writer().

Here is the call graph for this function:

free_message()

void free_message	(	struct message *	msg,
		struct response *	r )

Frees message

Additionally, it enforces user to pass response to be sent to sender.

Definition at line 318 of file messaging.cpp.

{
        if (!msg) {
                return;
        }
 
        if (r) {
                if (msg->send_response) {
                        msg->send_response(msg->priv_data, r);
                } else {
                        free_response(r);
                }
        }
 
        if (msg->data_deleter) {
                msg->data_deleter(msg);
        }
 
        if (msg->priv_data) {
                delete (shared_ptr<struct responder> *) msg->priv_data;
        }
 
        free(msg);
}

References free_response().

Referenced by audio_decoder_process_message(), audio_done(), audio_receiver_thread(), audio_sender_thread(), capture_filter(), video_rxtx::check_sender_messages(), compress_process_message(), decoder_process_message(), display_conference_worker(), display_get_frame(), display_sdl2_run(), display_sdl_run(), fec_check_messages(), filter(), filter(), filter(), Filter_chain::filter(), free_message_for_child(), gl_process_frames(), module_done(), keyboard_control::impl::msg_received(), process_audio_message(), process_messages(), process_messages(), ultragrid_rtp_video_rxtx::receiver_process_messages(), send_message_common(), set_fec(), vidcap_file_process_messages(), vidcap_import_new_message(), vidcap_switcher_grab(), and writer().

Here is the call graph for this function:

free_message_for_child()

void free_message_for_child	(	void *	m,
		struct response *	r )

Definition at line 99 of file messaging.cpp.

                                                         {
        struct pair_msg_path *mp = (struct pair_msg_path *) m;
        free_message(mp->msg, r);
        free(mp);
 
}

References free_message().

Referenced by module_done(), and send_message_common().

Here is the call graph for this function:

free_response()

void free_response

(

struct response *

r

)

Definition at line 361 of file messaging.cpp.

                                       {
        free(r);
}

Referenced by compress_process_message(), BasicRTSPOnlySubsession::deleteStream(), keyboard_control::impl::exec_external_commands(), free_message(), keyboard_control::impl::info(), keycontrol_register_key(), keycontrol_send_key(), module_check_undelivered_messages(), process_msg(), reconfigure_decoder(), keyboard_control::impl::run(), sdp_send_change_address_message(), h264_sdp_video_rxtx::send_frame(), send_response(), set_fec(), BasicRTSPOnlySubsession::startStream(), Participant_manager::tick(), tx_update(), AudioDriftFixer::update(), and vidcap_switcher_register_keyboard_ctl().

module_check_undelivered_messages()

void module_check_undelivered_messages

(

struct module *

node

)

Sends message with waiting for response.

Stores message to module message box. If new_message callback is present it is called. Otherwise it may take a long time until module reads the message therefore setting timeout_ms is strongly recommended to prevent freeze (unless knowing that module implements synchronnous message processing via module::new_message callback).

If not set otherwise, when receiver doesn't exist, message is stored by nearest existing parent until it starts (this may be disabled with flag SEND_MESSAGE_FLAG_NO_STORE).

Parameters

sync	wait for response timeout_ms milliseconds, if false, 202 is immediately returned (or 404 if NO_STORE flag is set and receiver doesn't exist)
timeout_ms	if sync==true number of ms to wait for response (-1 means infinitely), ignored if sync is false, @params flags bit mask of SEND_MESSAGE_FLAG_NO_STORE and SEND_MESSAGE_FLAG_QUIET

Definition at line 265 of file messaging.cpp.

{
        pthread_mutex_guard guard(node->lock);
 
        for(void *it = simple_linked_list_it_init(node->msg_queue_children); it != NULL; ) {
                struct pair_msg_path *msg = (struct pair_msg_path *) simple_linked_list_it_next(&it);
                struct module *receiver = get_matching_child(node, msg->path);
                if (receiver) {
                        struct response *resp = send_message_to_receiver(receiver, msg->msg);
                        free_response(resp);
                        simple_linked_list_remove(node->msg_queue_children, msg);
                        free(msg);
                        // reinit iterator
                        it = simple_linked_list_it_init(node->msg_queue_children);
                }
        }
}

References free_response(), get_matching_child(), module::lock, module::msg_queue_children, send_message_to_receiver(), simple_linked_list_it_init(), simple_linked_list_it_next(), and simple_linked_list_remove().

Referenced by module_register().

Here is the call graph for this function:

module_store_message()

void module_store_message	(	struct module *	node,
		struct message *	m )

Definition at line 283 of file messaging.cpp.

{
        pthread_mutex_guard guard(node->msg_queue_lock);
        simple_linked_list_append(node->msg_queue, m);
}

References module::msg_queue, module::msg_queue_lock, and simple_linked_list_append().

Here is the call graph for this function:

new_message()

struct message * new_message

(

size_t

len

)

Definition at line 303 of file messaging.cpp.

{
        assert(len >= sizeof(struct message));
 
        struct message *ret = (struct message *)
                calloc(1, len);
 
        return ret;
}

References len.

new_response()

struct response * new_response	(	int	status,
		const char *	text )

Creates new response

Parameters

status	status
text	optional text contained in message

Definition at line 349 of file messaging.cpp.

{
        struct response *resp = (struct response *) malloc(sizeof(struct response) + (text ? strlen(text) : 0) + 1);
        resp->status = status;
        if (text) {
                strcpy(resp->text, text);
        } else {
                resp->text[0] = '\0';
        }
        return resp;
}

References response::status, and response::text.

Referenced by audio_decoder_process_message(), audio_receiver_process_message(), audio_sender_process_message(), change_replica_type(), compress_process_message(), decoder_process_message(), display_conference_worker(), display_sdl2_run(), display_sdl_run(), fec_check_messages(), filter(), filter(), Filter_chain::filter(), gl_process_frames(), keyboard_control::impl::msg_received(), process_audio_message(), process_message(), process_message(), process_message(), process_messages(), process_messages(), process_msg(), rtp_video_rxtx::process_sender_message(), ultragrid_rtp_video_rxtx::receiver_process_messages(), send_message_common(), send_message_to_receiver(), vidcap_file_process_messages(), vidcap_import_new_message(), vidcap_switcher_grab(), and writer().

response_get_status()

int response_get_status

(

struct response *

r

)

Definition at line 365 of file messaging.cpp.

                                            {
        return r->status;
}

References response::status.

Referenced by keyboard_control::impl::exec_external_commands(), keyboard_control::impl::info(), keycontrol_register_key(), keycontrol_send_key(), sdp_send_change_address_message(), send_response(), Participant_manager::tick(), AudioDriftFixer::update(), and vidcap_switcher_register_keyboard_ctl().

response_get_text()

const char * response_get_text

(

struct response *

r

)

Definition at line 369 of file messaging.cpp.

                                                  {
        return r->text;
}

References response::text.

Referenced by keyboard_control::impl::info(), send_response(), and AudioDriftFixer::update().

response_status_to_text()

const char * response_status_to_text

(

int

status

)

Definition at line 373 of file messaging.cpp.

{
        const static unordered_map<int, const char *> mapping = {
                { RESPONSE_OK, "OK" },
                { RESPONSE_ACCEPTED, "Accepted" },
                { RESPONSE_NO_CONTENT, "No Content" },
                { RESPONSE_BAD_REQUEST, "Bad Request" },
                { RESPONSE_NOT_FOUND, "Not Found" },
                { RESPONSE_REQ_TIMEOUT, "Request Timeout" },
                { RESPONSE_INT_SERV_ERR, "Internal Server Error" },
                { RESPONSE_NOT_IMPL, "Not Implemented" },
        };
 
        auto it = mapping.find(status);
        if (it != mapping.end()) {
                return it->second;
        }
 
        return NULL;
}

References mapping, RESPONSE_ACCEPTED, RESPONSE_BAD_REQUEST, RESPONSE_INT_SERV_ERR, RESPONSE_NO_CONTENT, RESPONSE_NOT_FOUND, RESPONSE_NOT_IMPL, RESPONSE_OK, and RESPONSE_REQ_TIMEOUT.

Referenced by send_response().

send_message()

struct response * send_message	(	struct module *	root,
		const char *	const_path,
		struct message *	msg )

Sends message without waiting for response.

Stores message to module message box. If new_message callback is present it is called. Otherwise it may take a long time until module reads the message therefore setting timeout_ms is strongly recommended to prevent freeze (unless knowing that module implements synchronnous message processing via module::new_message callback).

If not set otherwise, when receiver doesn't exist, message is stored by nearest existing parent until it starts (this may be disabled with flag SEND_MESSAGE_FLAG_NO_STORE).

Parameters

sync	wait for response timeout_ms milliseconds, if false, 202 is immediately returned (or 404 if NO_STORE flag is set and receiver doesn't exist)
timeout_ms	if sync==true number of ms to wait for response (-1 means infinitely), ignored if sync is false, @params flags bit mask of SEND_MESSAGE_FLAG_NO_STORE and SEND_MESSAGE_FLAG_QUIET

Definition at line 249 of file messaging.cpp.

{
        return send_message_common(root, const_path, msg, false, 0, 0);
}

References send_message_common().

Referenced by BasicRTSPOnlySubsession::deleteStream(), process_audio_message(), process_msg(), keyboard_control::impl::run(), sdp_send_change_address_message(), h264_sdp_video_rxtx::send_frame(), and BasicRTSPOnlySubsession::startStream().

Here is the call graph for this function:

send_message_common()

static struct response * send_message_common ( struct module * root, const char * const_path, struct message * msg, bool sync, int timeout_ms, int flags )

static

Stores message to module message box. If new_message callback is present it is called. Otherwise it may take a long time until module reads the message therefore setting timeout_ms is strongly recommended to prevent freeze (unless knowing that module implements synchronnous message processing via module::new_message callback).

If not set otherwise, when receiver doesn't exist, message is stored by nearest existing parent until it starts (this may be disabled with flag SEND_MESSAGE_FLAG_NO_STORE).

Parameters

sync	wait for response timeout_ms milliseconds, if false, 202 is immediately returned (or 404 if NO_STORE flag is set and receiver doesn't exist)
timeout_ms	if sync==true number of ms to wait for response (-1 means infinitely), ignored if sync is false, @params flags bit mask of SEND_MESSAGE_FLAG_NO_STORE and SEND_MESSAGE_FLAG_QUIET

Invariant

either receiver is NULL or receiver->lock is locked (exactly once)

Definition at line 121 of file messaging.cpp.

{
        char *path, *tmp;
        char *item, *save_ptr;
        tmp = path = strdup(const_path);
        struct module *receiver = root;
        shared_ptr<struct responder> responder;
 
        if (sync) {
                msg->send_response = responder::receive_response;
                responder = shared_ptr<struct responder>(new struct responder());
                msg->priv_data = new shared_ptr<struct responder>(responder);
        }
 
        pthread_mutex_lock(&receiver->lock);
 
        while ((item = strtok_r(path, ".", &save_ptr))) {
                path = NULL;
                struct module *old_receiver = receiver;
 
                if (strcmp(item, "root") == 0)
                        continue;
 
                receiver = get_matching_child(receiver, item);
 
                if (!receiver) {
                        if (!(flags & SEND_MESSAGE_FLAG_NO_STORE)) {
                                if (!(flags & SEND_MESSAGE_FLAG_QUIET))
                                        printf("Receiver %s does not exist.\n", const_path);
                                //dump_tree(root, 0);
                                if (simple_linked_list_size(old_receiver->msg_queue_children) > MAX_MESSAGES_FOR_NOT_EXISTING_RECV) {
                                        if (!(flags & SEND_MESSAGE_FLAG_QUIET))
                                                printf("Dropping some old messages for %s (queue full).\n", const_path);
                                        free_message_for_child(simple_linked_list_pop(old_receiver->msg_queue_children),
                                                        new_response(RESPONSE_NOT_FOUND, "Receiver not found"));
                                }
 
                                struct pair_msg_path *saved_message = (struct pair_msg_path *)
                                        malloc(sizeof(struct pair_msg_path) + strlen(const_path + (item - tmp)) + 1);
                                saved_message->msg = msg;
                                strcpy(saved_message->path, const_path + (item - tmp));
 
                                simple_linked_list_append(old_receiver->msg_queue_children, saved_message);
                                pthread_mutex_unlock(&old_receiver->lock);
 
                                free(tmp);
                                if (!sync) {
                                        return new_response(RESPONSE_ACCEPTED, "(receiver not yet exists)");
                                } else {
                                        unique_lock<mutex> lk(responder->lock);
                                        if (timeout_ms == -1) {
                                                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Warning: infinite wait for "
                                                                "non-existent recv. Please report!\n");
                                                responder->cv.wait(lk, [responder]{return responder->received_response != NULL;});
                                        } else {
                                                responder->cv.wait_for(lk, std::chrono::milliseconds(timeout_ms), [responder]{return responder->received_response != NULL;});
                                        }
                                        if (responder->received_response) {
                                                struct response *resp = responder->received_response;
                                                responder->received_response = NULL;
                                                return resp;
                                        } else {
                                                return new_response(RESPONSE_ACCEPTED, NULL);
                                        }
                                }
                        } else {
                                pthread_mutex_unlock(&old_receiver->lock);
                                free_message(msg, NULL);
                                free(tmp);
                                return new_response(RESPONSE_NOT_FOUND, NULL);
                        }
                }
                pthread_mutex_lock(&receiver->lock);
                pthread_mutex_unlock(&old_receiver->lock);
        }
 
        free(tmp);
 
        //pthread_mutex_guard guard(receiver->lock, lock_guard_retain_ownership_t());
 
        pthread_mutex_lock(&receiver->msg_queue_lock);
        int size = simple_linked_list_size(receiver->msg_queue);
        pthread_mutex_unlock(&receiver->msg_queue_lock);
        if (size >= MAX_MESSAGES) {
                struct message *m = (struct message *) simple_linked_list_pop(receiver->msg_queue);
                free_message(m, new_response(RESPONSE_INT_SERV_ERR, "Too many unprocessed messages"));
                printf("Dropping some messages for %s - queue full.\n", const_path);
        }
        pthread_mutex_lock(&receiver->msg_queue_lock);
        simple_linked_list_append(receiver->msg_queue, msg);
        pthread_mutex_unlock(&receiver->msg_queue_lock);
 
        if (receiver->new_message) {
                receiver->new_message(receiver);
        }
 
        pthread_mutex_unlock(&receiver->lock);
 
        if (!sync) {
                return new_response(RESPONSE_ACCEPTED, NULL);
        } else {
                unique_lock<mutex> lk(responder->lock);
                if (timeout_ms == -1) {
                        if (receiver->new_message == NULL) {
                                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Warning: infinite wait for "
                                                "module without msg notifier. Please report!\n");
                        }
                        responder->cv.wait(lk, [responder]{return responder->received_response != NULL;});
                } else {
                        responder->cv.wait_for(lk, std::chrono::milliseconds(timeout_ms), [responder]{return responder->received_response != NULL;});
                }
                if (responder->received_response) {
                        struct response *resp = responder->received_response;
                        responder->received_response = NULL;
                        return resp;
                } else {
                        return new_response(RESPONSE_ACCEPTED, NULL);
                }
        }
}

References flags, free_message(), free_message_for_child(), get_matching_child(), module::lock, LOG_LEVEL_WARNING, log_msg(), MAX_MESSAGES, MAX_MESSAGES_FOR_NOT_EXISTING_RECV, MOD_NAME, msg, module::msg_queue, module::msg_queue_children, module::msg_queue_lock, module::new_message, new_response(), RESPONSE_ACCEPTED, RESPONSE_INT_SERV_ERR, RESPONSE_NOT_FOUND, SEND_MESSAGE_FLAG_NO_STORE, SEND_MESSAGE_FLAG_QUIET, simple_linked_list_append(), simple_linked_list_pop(), and simple_linked_list_size().

Referenced by send_message(), and send_message_sync().

Here is the call graph for this function:

send_message_sync()

struct response * send_message_sync	(	struct module *	root,
		const char *	const_path,
		struct message *	msg,
		int	timeout_ms,
		int	flags )

Sends message without waiting for response.

Stores message to module message box. If new_message callback is present it is called. Otherwise it may take a long time until module reads the message therefore setting timeout_ms is strongly recommended to prevent freeze (unless knowing that module implements synchronnous message processing via module::new_message callback).

If not set otherwise, when receiver doesn't exist, message is stored by nearest existing parent until it starts (this may be disabled with flag SEND_MESSAGE_FLAG_NO_STORE).

Parameters

sync	wait for response timeout_ms milliseconds, if false, 202 is immediately returned (or 404 if NO_STORE flag is set and receiver doesn't exist)
timeout_ms	if sync==true number of ms to wait for response (-1 means infinitely), ignored if sync is false, @params flags bit mask of SEND_MESSAGE_FLAG_NO_STORE and SEND_MESSAGE_FLAG_QUIET

Definition at line 257 of file messaging.cpp.

{
        return send_message_common(root, const_path, msg, true, timeout_ms, flags);
}

References flags, and send_message_common().

Referenced by keyboard_control::impl::exec_external_commands(), keyboard_control::impl::info(), keycontrol_register_key(), keycontrol_send_key(), AudioDriftFixer::update(), and vidcap_switcher_register_keyboard_ctl().

Here is the call graph for this function:

send_message_to_receiver()

struct response * send_message_to_receiver	(	struct module *	receiver,
		struct message *	msg )

Definition at line 289 of file messaging.cpp.

{
        pthread_mutex_lock(&receiver->msg_queue_lock);
        simple_linked_list_append(receiver->msg_queue, msg);
        pthread_mutex_unlock(&receiver->msg_queue_lock);
 
        pthread_mutex_guard guard(receiver->lock);
        if (receiver->new_message) {
                receiver->new_message(receiver);
        }
 
        return new_response(RESPONSE_ACCEPTED, NULL);
}

References module::lock, module::msg_queue, module::msg_queue_lock, module::new_message, new_response(), RESPONSE_ACCEPTED, and simple_linked_list_append().

Referenced by compress_process_message(), module_check_undelivered_messages(), reconfigure_decoder(), set_fec(), Participant_manager::tick(), and tx_update().

Here is the call graph for this function: