int read_message_size_worker(worker_t *worker, GError **error) {
ssize_t rl = 0;
worker_data_t *data = NULL;
TRACE_POSITION();
data = &(worker->data);
g_assert(data->session == NULL);
if (data->buffer == NULL) {
message_t dummy;
g_assert(data->buffer_size == 0);
data->done = 0;
data->buffer_size = sizeof(dummy.length);
data->buffer = g_malloc0(data->buffer_size);
}
rl = read(data->fd, data->buffer + data->done, data->buffer_size - data->done);
TRACE2("fd=%d buffer=%p size=%u done=%u + %"G_GSSIZE_FORMAT, data->fd, data->buffer, data->buffer_size, data->done, rl);
if (rl < 0) {
if (errno == EAGAIN || errno == EINTR)
return 1;
GSETERROR(error, "Read of message size failed with error : %s", strerror(errno));
return 0;
}
if (rl == 0 && data->done < data->buffer_size) {
GSETERROR(error, "Connection closed while reading message size");
return 0;
}
data->done += rl;
if (data->done >= data->buffer_size) { /* The size of message has been read */
/* Set message length */
message_t *message = g_malloc0(sizeof(message_t));
memcpy(&(message->length), data->buffer, data->buffer_size);
if (message->length <= 0) {
GSETERROR(error, "Invalid message size");
message_clean(message);
return 0;
}
/* reset data */
g_free(data->buffer);
data->buffer = NULL;
data->buffer_size = 0;
data->done = 0;
/* branch to next worker */
worker->data.session = message;
worker->func = read_message_data_worker;
worker->clean = message_cleanup;
return read_message_data_worker(worker, error);
}
return(1);
}
/**
@brief 处理消息
如果消息是同步的，则要调用内核去响应，因为发送者在等待我们的回应。
如果消息是异步的，则直接清掉占用位即可。
@return
The next postion to fetch the message.The message length is dynmaic!
*/
static struct y_message *handle_message(struct y_message_instance *instance, struct y_message *what)
{
int count;
int r = true;
struct y_message * next;
if (instance->filter) r = instance->filter(what);
count = what->count; //record the src count before handling message, sync msg will overwrite it.
if (r == true)
{
/*
1，地址调用型的？
2，那么就是查询的
*/
if (what->flags & MSG_FLAGS_ADDRESS)
{
y_message_func fn;
fn = (y_message_func)what->what;
fn(what);
}
else
{
y_message_func fn;
if (instance->find_handler)
{
fn = instance->find_handler(instance, what->what);
if (fn)
fn(what);
}
}
}
/*
ACK the sender if it's a synchronouse message
*/
if (what->flags & MSG_FLAGS_SYNC)
{
/*
The sender is waiting in kernel,
so let kernel know the message has bean handled and
let the sender copy back the result.
When these are all done, we can safely clean the message.
*/
instance->response_sync(what);
}
/*
Clear the message.
The head is cleaned when the data part has been cleaned.
*/
next = what;
MSG_GET_NEXT_SLOT(instance, next);
next = message_clean(instance, next, count);
what->flags = 0;
return next;
}
int main(int argc, char **argv)
{
int input=-1;
printf("\n===============WELCOME TO THE TEST INTERFACE TO VERIFY THE IPC================\n");
//list_receiver(1);
while(1)
{
printf("\n -----Available Operations--- \n");
printf("\n 1. MESSAGE QUEUE Creation \n"); //this calls to the mq_open
printf(" 2. Register Sender in the queue \n"); //this calls the msender system call
printf(" 3. Register Receiver in the queue \n"); //this call the mreceiver system call
printf(" 4. Send a message using the system call mq_send \n"); // This calls the mq_send system call
printf(" 5. Clear and Close Message Queue\n"); //This calls the mq_close system call
printf(" 6. Get Attributes of the message queue \n");
printf(" 7. Set Attributes of the message queue \n");//this calls to the mq_getattr system call
printf(" 8. Notify system call \n");
printf(" 0. Exit the Program \n");
printf("Choose the operation you want to perform \t ");
scanf(" %d",&input);
switch(input)
{
case 1:
list_queue();
break;
case 2:
list_sender();
break;
case 3:
list_receiver(0);
break;
case 4:
mess_send(); //sender can be created dynamically also.
break;
case 5:
message_clean();
break;
case 6:
get_attr();
break;
case 7:
set_attr();
break;
case 8 :
reqnotify();
break;
case 0:
exit(0);
break;
default :
printf("\nIncorrect input. Try again. \n");
break;
}
}
}
void worker_mgr_t::worker_process(int32_t index)
{
worker_t *worker = m_worker[index];
message_t message;
context_t *running, *head, *tail;
while (!m_exiting) {
int32_t stolen = 0;
running = worker->try_pop_one_context();
if (!running) {
stolen = steal_context(index, head, tail);
if (!stolen) {
worker->wait();
continue;
}
running = head;
if (stolen - 1 > 0) {
worker->push_many_context(head->next(), tail, stolen - 1);
}
}
bool processing = true;
running->attach_worker(worker);
for (int32_t i = 0; i < MAX_MESSAGE_PROC_NUM || worker->get_context_length() <= 0 || !running->is_valid(); ++i) {
if (running->pop_message(message)) {
if (running->is_valid()) {
running->on_received(message);
} else {
running->on_dropped(message);
}
message_clean(message);
} else {
processing = false;
break;
}
}
if (!processing) {
running->release();
} else {
#ifndef RELEASE
running->detach_worker();
#endif
repush_context(index, running);
}
}
}
void worker_mgr_t::wait()
{
for (int32_t i = 0; i < m_worker_num; ++i) {
uv_thread_join(&m_thread[i]);
worker_t *worker = m_worker[i];
message_t message;
context_t *running, *release;
running = worker->pop_all_context();
while (running) {
running->attach_worker(worker);
while (running->pop_message(message)) {
running->on_dropped(message);
message_clean(message);
}
release = running;
running = release->next();
release->release();
}
delete m_worker[i];
m_worker[i] = NULL;
}
}
int send_request(request_t *req, response_t *resp, GError **error) {
int fd;
size_t size_to_send, u_size_sent, u_size_read;
gint size_sent, size_read;
message_t message;
void *buff = NULL;
memset(&message, 0, sizeof(message_t));
if (!build_message_from_request(&message, req, error)) {
GSETERROR(error, "Failed to build message");
return(0);
}
if (!connect_socket(&fd, error)) {
GSETERROR(error, "Connection to agent failed");
goto error_connect;
}
size_to_send = message.length + sizeof(message.length);
buff = g_try_malloc0(size_to_send);
if (buff == NULL) {
GSETERROR(error, "Memory allocation failure");
goto error_alloc_buff;
}
memcpy(buff, &(message.length), sizeof(message.length));
memcpy(buff + sizeof(message.length), message.data, message.length);
size_sent = sock_to_write(fd, CONNECT_TIMEOUT, buff, size_to_send, error);
if (size_sent<0) {
GSETERROR(error, "Failed to send all data to agent");
goto error_write;
}
if ((u_size_sent=size_sent) < size_to_send) {
GSETERROR(error, "Failed to send all data to agent");
goto error_write;
}
/* Clean message to reuse it */
message_clean( &message);
size_read = sock_to_read_size(fd, SOCKET_TIMEOUT, &(message.length), sizeof(message.length), error);
if ((u_size_read=size_read) < sizeof(message.length)) {
GSETERROR(error, "Failed to read message size");
goto error_read_size;
}
message.data = g_try_malloc0(message.length);
if (message.data == NULL) {
GSETERROR(error, "Memory allocation failure");
goto error_alloc_data;
}
size_read = sock_to_read_size(fd, SOCKET_TIMEOUT, message.data, message.length, error);
if ((u_size_read=size_read) < message.length) {
GSETERROR(error, "Failed to read all data from agent");
goto error_read;
}
if (!read_response_from_message(resp, &message, error)) {
GSETERROR(error, "Failed to extract response from message");
goto error_read_resp;
}
metautils_pclose(&fd);
g_free(buff);
message_clean( &message);
return(1);
error_read_resp:
error_read:
error_alloc_data:
error_read_size:
error_write:
if (buff)
g_free(buff);
error_alloc_buff:
metautils_pclose(&fd);
error_connect:
message_clean( &message);
return(0);
}
