static amqp_boolean_t check_channel_status(connstate_t *conn,
amqp_frame_t *frame,
chanstate_t *chan) {
if (chan->status) {
if (amqp_constant_is_hard_error(chan->status)) {
close_connection(conn, chan->status, "Connection error %s (%d) in response to %s",
amqp_constant_name(chan->status),
chan->status,
amqp_method_name(frame->payload.method.id));
} else {
close_channel(conn, chan->channel, chan->status, "Channel error %s (%d) in response to %s",
amqp_constant_name(chan->status),
chan->status,
amqp_method_name(frame->payload.method.id));
}
return 1;
} else {
return 0;
}
}
void AmqpException::Throw(const amqp_connection_close_t& reply)
{
std::ostringstream what;
const char* method_name = amqp_method_name(((reply.class_id << 16) | reply.method_id));
std::string reply_text;
if (reply.reply_text.bytes != NULL)
{
reply_text = std::string((char*)reply.reply_text.bytes, reply.reply_text.len);
}
if (method_name != NULL)
{
what << "connection error: " << reply.reply_code << ": " << method_name << " caused: " << reply_text;
}
else
{
what << "connection error: " << reply.reply_code << ": " << reply_text;
}
switch (reply.reply_code)
{
case ConnectionForcedException::REPLY_CODE:
throw ConnectionForcedException(what.str(), reply_text, reply.class_id, reply.method_id);
case InvalidPathException::REPLY_CODE:
throw InvalidPathException(what.str(), reply_text, reply.class_id, reply.method_id);
case FrameErrorException::REPLY_CODE:
throw FrameErrorException(what.str(), reply_text, reply.class_id, reply.method_id);
case SyntaxErrorException::REPLY_CODE:
throw SyntaxErrorException(what.str(), reply_text, reply.class_id, reply.method_id);
case CommandInvalidException::REPLY_CODE:
throw CommandInvalidException(what.str(), reply_text, reply.class_id, reply.method_id);
case ChannelErrorException::REPLY_CODE:
throw ChannelErrorException(what.str(), reply_text, reply.class_id, reply.method_id);
case UnexpectedFrameException::REPLY_CODE:
throw UnexpectedFrameException(what.str(), reply_text, reply.class_id, reply.method_id);
case ResourceErrorException::REPLY_CODE:
throw ResourceErrorException(what.str(), reply_text, reply.class_id, reply.method_id);
case NotAllowedException::REPLY_CODE:
throw NotAllowedException(what.str(), reply_text, reply.class_id, reply.method_id);
case NotImplementedException::REPLY_CODE:
throw NotImplementedException(what.str(), reply_text, reply.class_id, reply.method_id);
case InternalErrorException::REPLY_CODE:
throw InternalErrorException(what.str(), reply_text, reply.class_id, reply.method_id);
default:
throw std::logic_error(std::string("Programming error: unknown connection reply code: ").append(boost::lexical_cast<std::string>(reply.reply_code)));
}
}
void AmqpException::Throw(const amqp_channel_close_t &reply) {
std::ostringstream what;
std::string reply_text;
if (reply.reply_text.bytes != NULL) {
reply_text =
std::string((char *)reply.reply_text.bytes, reply.reply_text.len);
}
const char *method_name =
amqp_method_name(((reply.class_id << 16) | reply.method_id));
if (method_name != NULL) {
what << "channel error: " << reply.reply_code << ": " << method_name
<< " caused: " << reply_text;
} else {
what << "channel error: " << reply.reply_code << ": " << reply_text;
}
switch (reply.reply_code) {
case ContentTooLargeException::REPLY_CODE:
throw ContentTooLargeException(what.str(), reply_text, reply.class_id,
reply.method_id);
case NoRouteException::REPLY_CODE:
throw NoRouteException(what.str(), reply_text, reply.class_id,
reply.method_id);
case NoConsumersException::REPLY_CODE:
throw NoConsumersException(what.str(), reply_text, reply.class_id,
reply.method_id);
case AccessRefusedException::REPLY_CODE:
throw AccessRefusedException(what.str(), reply_text, reply.class_id,
reply.method_id);
case NotFoundException::REPLY_CODE:
throw NotFoundException(what.str(), reply_text, reply.class_id,
reply.method_id);
case ResourceLockedException::REPLY_CODE:
throw ResourceLockedException(what.str(), reply_text, reply.class_id,
reply.method_id);
case PreconditionFailedException::REPLY_CODE:
throw PreconditionFailedException(what.str(), reply_text, reply.class_id,
reply.method_id);
default:
throw std::logic_error(
std::string("Programming error: unknown channel reply code: ")
.append(boost::lexical_cast<std::string>(reply.reply_code)));
}
}
static void noit_rabbitmq_read_frame(struct amqp_driver *dr) {
struct pollfd p;
if(!dr->connection) return;
while(1) {
memset(&p, 0, sizeof(p));
p.fd = dr->sockfd;
p.events = POLLIN;
if(poll(&p, 1, 0)) {
int rv;
amqp_frame_t f;
rv = amqp_simple_wait_frame(dr->connection, &f);
if(rv > 0) {
if(f.frame_type == AMQP_FRAME_HEARTBEAT) {
BUMPSTAT(inbound_heartbeats);
mtevL(mtev_debug, "amqp <- hearbeat\n");
}
else if(f.frame_type == AMQP_FRAME_METHOD) {
BUMPSTAT(inbound_methods);
mtevL(mtev_error, "amqp <- method [%s]\n", amqp_method_name(f.payload.method.id));
dr->has_error = 1;
switch(f.payload.method.id) {
case AMQP_CHANNEL_CLOSE_METHOD: {
amqp_channel_close_t *m = (amqp_channel_close_t *) f.payload.method.decoded;
mtevL(mtev_error, "AMQP channel close error %d: %s\n",
m->reply_code, (char *)m->reply_text.bytes);
}
break;
case AMQP_CONNECTION_CLOSE_METHOD: {
amqp_connection_close_t *m = (amqp_connection_close_t *) f.payload.method.decoded;
mtevL(mtev_error, "AMQP connection close error %d: %s\n",
m->reply_code, (char *)m->reply_text.bytes);
}
break;
}
}
else {
mtevL(mtev_error, "amqp <- frame [%d]\n", f.frame_type);
}
}
else break;
}
else break;
}
}
int main(int argc, char const *const *argv)
{
char const *hostname;
int port, status;
char const *queuename;
amqp_socket_t *socket;
amqp_connection_state_t conn;
if (argc < 4) {
fprintf(stderr, "Usage: amqps_listenq host port queuename "
"[cacert.pem [key.pem cert.pem]]\n");
return 1;
}
hostname = argv[1];
port = atoi(argv[2]);
queuename = argv[3];
conn = amqp_new_connection();
socket = amqp_ssl_socket_new();
if (!socket) {
die("creating SSL/TLS socket");
}
if (argc > 4) {
status = amqp_ssl_socket_set_cacert(socket, argv[4]);
if (status) {
die("setting CA certificate");
}
}
if (argc > 6) {
status = amqp_ssl_socket_set_key(socket, argv[6], argv[5]);
if (status) {
die("setting client cert");
}
}
status = amqp_socket_open(socket, hostname, port);
if (status) {
die("opening SSL/TLS connection");
}
amqp_set_socket(conn, socket);
die_on_amqp_error(amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, "guest", "guest"),
"Logging in");
amqp_channel_open(conn, 1);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Opening channel");
amqp_basic_consume(conn, 1, amqp_cstring_bytes(queuename), amqp_empty_bytes, 0, 0, 0, amqp_empty_table);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Consuming");
{
amqp_frame_t frame;
int result;
amqp_basic_deliver_t *d;
amqp_basic_properties_t *p;
size_t body_target;
size_t body_received;
while (1) {
amqp_maybe_release_buffers(conn);
result = amqp_simple_wait_frame(conn, &frame);
printf("Result %d\n", result);
if (result < 0) {
break;
}
printf("Frame type %d, channel %d\n", frame.frame_type, frame.channel);
if (frame.frame_type != AMQP_FRAME_METHOD) {
continue;
}
printf("Method %s\n", amqp_method_name(frame.payload.method.id));
if (frame.payload.method.id != AMQP_BASIC_DELIVER_METHOD) {
continue;
}
d = (amqp_basic_deliver_t *) frame.payload.method.decoded;
printf("Delivery %u, exchange %.*s routingkey %.*s\n",
(unsigned) d->delivery_tag,
(int) d->exchange.len, (char *) d->exchange.bytes,
(int) d->routing_key.len, (char *) d->routing_key.bytes);
result = amqp_simple_wait_frame(conn, &frame);
if (result < 0) {
break;
}
if (frame.frame_type != AMQP_FRAME_HEADER) {
fprintf(stderr, "Expected header!");
abort();
}
p = (amqp_basic_properties_t *) frame.payload.properties.decoded;
if (p->_flags & AMQP_BASIC_CONTENT_TYPE_FLAG) {
printf("Content-type: %.*s\n",
(int) p->content_type.len, (char *) p->content_type.bytes);
}
printf("----\n");
body_target = frame.payload.properties.body_size;
body_received = 0;
while (body_received < body_target) {
result = amqp_simple_wait_frame(conn, &frame);
if (result < 0) {
break;
}
if (frame.frame_type != AMQP_FRAME_BODY) {
fprintf(stderr, "Expected body!");
abort();
}
body_received += frame.payload.body_fragment.len;
assert(body_received <= body_target);
amqp_dump(frame.payload.body_fragment.bytes,
frame.payload.body_fragment.len);
}
if (body_received != body_target) {
/* Can only happen when amqp_simple_wait_frame returns <= 0 */
/* We break here to close the connection */
break;
}
amqp_basic_ack(conn, 1, d->delivery_tag, 0);
}
}
die_on_amqp_error(amqp_channel_close(conn, 1, AMQP_REPLY_SUCCESS), "Closing channel");
die_on_amqp_error(amqp_connection_close(conn, AMQP_REPLY_SUCCESS), "Closing connection");
die_on_error(amqp_destroy_connection(conn), "Ending connection");
return 0;
}
int main(int argc, char *argv[])
{
char const *hostname;
int port, status;
char const *exchange;
char const *routingkey;
char const *messagebody;
amqp_socket_t *socket = NULL;
amqp_connection_state_t conn;
amqp_bytes_t reply_to_queue;
if (argc < 6) { /* minimum number of mandatory arguments */
fprintf(stderr, "usage:\namqp_rpc_sendstring_client host port exchange routingkey messagebody\n");
return 1;
}
hostname = argv[1];
port = atoi(argv[2]);
exchange = argv[3];
routingkey = argv[4];
messagebody = argv[5];
/*
establish a channel that is used to connect RabbitMQ server
*/
conn = amqp_new_connection();
socket = amqp_tcp_socket_new(conn);
if (!socket) {
printf("creating TCP socket");
}
status = amqp_socket_open(socket, hostname, port);
if (status) {
printf("opening TCP socket");
}
printf("established connection!\n");
amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, "guest", "guest");// "Logging in");
amqp_channel_open(conn, 1);
amqp_get_rpc_reply(conn);//, "Opening channel");
printf("open channel!\n");
/*
create private reply_to queue
*/
{
amqp_queue_declare_ok_t *r = amqp_queue_declare(conn, 1, amqp_empty_bytes, 0, 0, 0, 1, amqp_empty_table);
amqp_get_rpc_reply(conn);//, "Declaring queue");
printf("declare queue!\n");
reply_to_queue = amqp_bytes_malloc_dup(r->queue);
if (reply_to_queue.bytes == NULL) {
fprintf(stderr, "Out of memory while copying queue name");
return 1;
}
}
/*
send the message
*/
{
/*
set properties
*/
amqp_basic_properties_t props;
props._flags = AMQP_BASIC_CONTENT_TYPE_FLAG |
AMQP_BASIC_DELIVERY_MODE_FLAG |
AMQP_BASIC_REPLY_TO_FLAG |
AMQP_BASIC_CORRELATION_ID_FLAG;
props.content_type = amqp_cstring_bytes("text/plain");
props.delivery_mode = 2; /* persistent delivery mode */
props.reply_to = amqp_bytes_malloc_dup(reply_to_queue);
if (props.reply_to.bytes == NULL) {
fprintf(stderr, "Out of memory while copying queue name");
return 1;
}
props.correlation_id = amqp_cstring_bytes("1");
/*
publish
*/
amqp_basic_publish(conn,
1,
amqp_cstring_bytes(exchange),
amqp_cstring_bytes(routingkey),
0,
0,
&props,
amqp_cstring_bytes(messagebody));
// "Publishing");
amqp_bytes_free(props.reply_to);
}
/*
wait an answer
*/
printf("waiting answer!\n");
{
amqp_basic_consume(conn, 1, reply_to_queue, amqp_empty_bytes, 0, 1, 0, amqp_empty_table);
amqp_get_rpc_reply(conn);//, "Consuming");
amqp_bytes_free(reply_to_queue);
{
amqp_frame_t frame;
int result;
amqp_basic_deliver_t *d;
amqp_basic_properties_t *p;
size_t body_target;
size_t body_received;
while (1) {
amqp_maybe_release_buffers(conn);
result = amqp_simple_wait_frame(conn, &frame);
printf("Result: %d\n", result);
if (result < 0) {
break;
}
printf("Frame type: %d channel: %d\n", frame.frame_type, frame.channel);
if (frame.frame_type != AMQP_FRAME_METHOD) {
continue;
}
printf("Method: %s\n", amqp_method_name(frame.payload.method.id));
if (frame.payload.method.id != AMQP_BASIC_DELIVER_METHOD) {
continue;
}
d = (amqp_basic_deliver_t *) frame.payload.method.decoded;
printf("Delivery: %u exchange: %.*s routingkey: %.*s\n",
(unsigned) d->delivery_tag,
(int) d->exchange.len, (char *) d->exchange.bytes,
(int) d->routing_key.len, (char *) d->routing_key.bytes);
result = amqp_simple_wait_frame(conn, &frame);
if (result < 0) {
break;
}
if (frame.frame_type != AMQP_FRAME_HEADER) {
fprintf(stderr, "Expected header!");
abort();
}
p = (amqp_basic_properties_t *) frame.payload.properties.decoded;
if (p->_flags & AMQP_BASIC_CONTENT_TYPE_FLAG) {
printf("Content-type: %.*s\n",
(int) p->content_type.len, (char *) p->content_type.bytes);
}
printf("----\n");
body_target = frame.payload.properties.body_size;
body_received = 0;
while (body_received < body_target) {
result = amqp_simple_wait_frame(conn, &frame);
if (result < 0) {
break;
}
if (frame.frame_type != AMQP_FRAME_BODY) {
fprintf(stderr, "Expected body!");
abort();
}
body_received += frame.payload.body_fragment.len;
printf("len -> %d \n",frame.payload.body_fragment.len);
assert(body_received <= body_target);
amqp_dump(frame.payload.body_fragment.bytes,
frame.payload.body_fragment.len);
}
if (body_received != body_target) {
/* Can only happen when amqp_simple_wait_frame returns <= 0 */
/* We break here to close the connection */
break;
}
/* everything was fine, we can quit now because we received the reply */
break;
}
}
}
/*
closing
*/
amqp_channel_close(conn, 1, AMQP_REPLY_SUCCESS);//, "Closing channel");
amqp_connection_close(conn, AMQP_REPLY_SUCCESS);//, "Closing connection");
amqp_destroy_connection(conn);//, "Ending connection");
return 0;
}
int main(int argc, char const * const *argv) {
char const *hostname;
int port;
char const *exchange;
char const *bindingkey;
int sockfd;
amqp_connection_state_t conn;
amqp_bytes_t queuename;
if (argc < 5) {
fprintf(stderr, "Usage: amqp_listen host port exchange bindingkey\n");
return 1;
}
hostname = argv[1];
port = atoi(argv[2]);
exchange = argv[3];
bindingkey = argv[4];
conn = amqp_new_connection();
die_on_error(sockfd = amqp_open_socket(hostname, port), "Opening socket");
amqp_set_sockfd(conn, sockfd);
die_on_amqp_error(amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, "guest", "guest"),
"Logging in");
amqp_channel_open(conn, 1);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Opening channel");
{
amqp_queue_declare_ok_t *r = amqp_queue_declare(conn, 1, AMQP_EMPTY_BYTES, 0, 0, 0, 1,
AMQP_EMPTY_TABLE);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Declaring queue");
queuename = amqp_bytes_malloc_dup(r->queue);
if (queuename.bytes == NULL) {
die_on_error(-ENOMEM, "Copying queue name");
}
}
amqp_queue_bind(conn, 1, queuename, amqp_cstring_bytes(exchange), amqp_cstring_bytes(bindingkey),
AMQP_EMPTY_TABLE);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Binding queue");
amqp_basic_consume(conn, 1, queuename, AMQP_EMPTY_BYTES, 0, 1, 0);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Consuming");
{
amqp_frame_t frame;
int result;
amqp_basic_deliver_t *d;
amqp_basic_properties_t *p;
size_t body_target;
size_t body_received;
while (1) {
amqp_maybe_release_buffers(conn);
result = amqp_simple_wait_frame(conn, &frame);
printf("Result %d\n", result);
if (result <= 0)
break;
printf("Frame type %d, channel %d\n", frame.frame_type, frame.channel);
if (frame.frame_type != AMQP_FRAME_METHOD)
continue;
printf("Method %s\n", amqp_method_name(frame.payload.method.id));
if (frame.payload.method.id != AMQP_BASIC_DELIVER_METHOD)
continue;
d = (amqp_basic_deliver_t *) frame.payload.method.decoded;
printf("Delivery %u, exchange %.*s routingkey %.*s\n",
(unsigned) d->delivery_tag,
(int) d->exchange.len, (char *) d->exchange.bytes,
(int) d->routing_key.len, (char *) d->routing_key.bytes);
result = amqp_simple_wait_frame(conn, &frame);
if (result <= 0)
break;
if (frame.frame_type != AMQP_FRAME_HEADER) {
fprintf(stderr, "Expected header!");
abort();
}
p = (amqp_basic_properties_t *) frame.payload.properties.decoded;
if (p->_flags & AMQP_BASIC_CONTENT_TYPE_FLAG) {
printf("Content-type: %.*s\n",
(int) p->content_type.len, (char *) p->content_type.bytes);
}
printf("----\n");
body_target = frame.payload.properties.body_size;
body_received = 0;
while (body_received < body_target) {
result = amqp_simple_wait_frame(conn, &frame);
if (result <= 0)
break;
if (frame.frame_type != AMQP_FRAME_BODY) {
fprintf(stderr, "Expected body!");
abort();
}
body_received += frame.payload.body_fragment.len;
assert(body_received <= body_target);
amqp_dump(frame.payload.body_fragment.bytes,
frame.payload.body_fragment.len);
}
if (body_received != body_target) {
/* Can only happen when amqp_simple_wait_frame returns <= 0 */
/* We break here to close the connection */
break;
}
}
}
die_on_amqp_error(amqp_channel_close(conn, 1, AMQP_REPLY_SUCCESS), "Closing channel");
die_on_amqp_error(amqp_connection_close(conn, AMQP_REPLY_SUCCESS), "Closing connection");
amqp_destroy_connection(conn);
die_on_error(close(sockfd), "Closing socket");
return 0;
}
int main(int argc, char** argv)
{
int channel = 1, status = AMQP_STATUS_OK, cnfnlen;
amqp_socket_t *socket = NULL;
amqp_connection_state_t conn;
amqp_rpc_reply_t ret;
amqp_message_t *reply = NULL;
amqp_frame_t frame;
struct timeval timeout;
MYSQL db_inst;
char ch, *cnfname = NULL, *cnfpath = NULL;
static const char* fname = "consumer.cnf";
if((c_inst = calloc(1,sizeof(CONSUMER))) == NULL){
fprintf(stderr, "Fatal Error: Cannot allocate enough memory.\n");
return 1;
}
if(signal(SIGINT,sighndl) == SIG_IGN){
signal(SIGINT,SIG_IGN);
}
while((ch = getopt(argc,argv,"c:"))!= -1){
switch(ch){
case 'c':
cnfnlen = strlen(optarg);
cnfpath = strdup(optarg);
break;
default:
break;
}
}
cnfname = calloc(cnfnlen + strlen(fname) + 1,sizeof(char));
if(cnfpath){
/**Config file path as argument*/
strcpy(cnfname,cnfpath);
if(cnfpath[cnfnlen-1] != '/'){
strcat(cnfname,"/");
}
}
strcat(cnfname,fname);
timeout.tv_sec = 1;
timeout.tv_usec = 0;
all_ok = 1;
out_fd = NULL;
/**Parse the INI file*/
if(ini_parse(cnfname,handler,NULL) < 0){
/**Try to parse a config in the same directory*/
if(ini_parse(fname,handler,NULL) < 0){
fprintf(stderr, "Fatal Error: Error parsing configuration file!\n");
goto fatal_error;
}
}
if(out_fd == NULL){
out_fd = stdout;
}
fprintf(out_fd,"\n--------------------------------------------------------------\n");
/**Confirm that all parameters were in the configuration file*/
if(!c_inst->hostname||!c_inst->vhost||!c_inst->user||
!c_inst->passwd||!c_inst->dbpasswd||!c_inst->queue||
!c_inst->dbserver||!c_inst->dbname||!c_inst->dbuser){
fprintf(stderr, "Fatal Error: Inadequate configuration file!\n");
goto fatal_error;
}
connectToServer(&db_inst);
if((conn = amqp_new_connection()) == NULL ||
(socket = amqp_tcp_socket_new(conn)) == NULL){
fprintf(stderr, "Fatal Error: Cannot create connection object or socket.\n");
goto fatal_error;
}
if(amqp_socket_open(socket, c_inst->hostname, c_inst->port)){
fprintf(stderr, "RabbitMQ Error: Cannot open socket.\n");
goto error;
}
ret = amqp_login(conn, c_inst->vhost, 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, c_inst->user, c_inst->passwd);
if(ret.reply_type != AMQP_RESPONSE_NORMAL){
fprintf(stderr, "RabbitMQ Error: Cannot login to server.\n");
goto error;
}
amqp_channel_open(conn, channel);
ret = amqp_get_rpc_reply(conn);
if(ret.reply_type != AMQP_RESPONSE_NORMAL){
fprintf(stderr, "RabbitMQ Error: Cannot open channel.\n");
goto error;
}
reply = malloc(sizeof(amqp_message_t));
if(!reply){
fprintf(stderr, "Error: Cannot allocate enough memory.\n");
goto error;
}
amqp_basic_consume(conn,channel,amqp_cstring_bytes(c_inst->queue),amqp_empty_bytes,0,0,0,amqp_empty_table);
while(all_ok){
status = amqp_simple_wait_frame_noblock(conn,&frame,&timeout);
/**No frames to read from server, possibly out of messages*/
if(status == AMQP_STATUS_TIMEOUT){
sleep(timeout.tv_sec);
continue;
}
if(frame.payload.method.id == AMQP_BASIC_DELIVER_METHOD){
amqp_basic_deliver_t* decoded = (amqp_basic_deliver_t*)frame.payload.method.decoded;
amqp_read_message(conn,channel,reply,0);
if(sendMessage(&db_inst,reply)){
fprintf(stderr,"RabbitMQ Error: Received malformed message.\n");
amqp_basic_reject(conn,channel,decoded->delivery_tag,0);
amqp_destroy_message(reply);
}else{
amqp_basic_ack(conn,channel,decoded->delivery_tag,0);
amqp_destroy_message(reply);
}
}else{
fprintf(stderr,"RabbitMQ Error: Received method from server: %s\n",amqp_method_name(frame.payload.method.id));
all_ok = 0;
goto error;
}
}
fprintf(out_fd,"Shutting down...\n");
error:
mysql_close(&db_inst);
mysql_library_end();
if(c_inst && c_inst->query_stack){
while(c_inst->query_stack){
DELIVERY* d = c_inst->query_stack->next;
amqp_destroy_message(c_inst->query_stack->message);
free(c_inst->query_stack);
c_inst->query_stack = d;
}
}
amqp_channel_close(conn, channel, AMQP_REPLY_SUCCESS);
amqp_connection_close(conn, AMQP_REPLY_SUCCESS);
amqp_destroy_connection(conn);
fatal_error:
if(out_fd){
fclose(out_fd);
}
if(c_inst){
free(c_inst->hostname);
free(c_inst->vhost);
free(c_inst->user);
free(c_inst->passwd);
free(c_inst->queue);
free(c_inst->dbserver);
free(c_inst->dbname);
free(c_inst->dbuser);
free(c_inst->dbpasswd);
free(c_inst);
}
return all_ok;
}
int main(int argc, const char **argv) {
const char *hostname;
int port;
const char *exchange;
const char *routingkey;
const char *exchangetype = "direct";
if (argc < 5) {
fprintf(stderr, "Usage: receive_logs_direct host port exchange routingkeys...\n");
return 1;
}
hostname = argv[1];
port = atoi(argv[2]);
exchange = argv[3];
int sockfd;
int channelid = 1;
amqp_connection_state_t conn;
conn = amqp_new_connection();
die_on_error(sockfd = amqp_open_socket(hostname, port), "Opening socket");
amqp_set_sockfd(conn, sockfd);
die_on_amqp_error(amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, "guest", "guest"),"Logging in");
amqp_channel_open(conn, channelid);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Opening channel");
amqp_exchange_declare(conn,channelid,amqp_cstring_bytes(exchange),amqp_cstring_bytes(exchangetype),0,1,
amqp_empty_table);
die_on_amqp_error(amqp_get_rpc_reply(conn),"Declaring exchange");
amqp_queue_declare_ok_t *r = amqp_queue_declare(conn,channelid,amqp_empty_bytes,0,0,1,0,amqp_empty_table);
int i;
for(i = 4;i < argc;i++)
{
routingkey = argv[i];
amqp_queue_bind(conn,channelid,amqp_bytes_malloc_dup(r->queue),amqp_cstring_bytes(exchange),
amqp_cstring_bytes(routingkey),amqp_empty_table);
}
amqp_basic_qos(conn,channelid,0,1,0);
amqp_basic_consume(conn,channelid,amqp_bytes_malloc_dup(r->queue),amqp_empty_bytes,0,0,0,amqp_empty_table);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Consuming");
{
amqp_frame_t frame;
int result;
amqp_basic_deliver_t *d;
amqp_basic_properties_t *p;
size_t body_target;
size_t body_received;
while (1) {
amqp_maybe_release_buffers(conn);
result = amqp_simple_wait_frame(conn, &frame);
printf("Result %d\n", result);
if (result < 0)
break;
printf("Frame type %d, channel %d\n", frame.frame_type, frame.channel);
if (frame.frame_type != AMQP_FRAME_METHOD)
continue;
printf("Method %s\n", amqp_method_name(frame.payload.method.id));
if (frame.payload.method.id != AMQP_BASIC_DELIVER_METHOD)
continue;
d = (amqp_basic_deliver_t *) frame.payload.method.decoded;
printf("Delivery %u, exchange %.*s routingkey %.*s\n",(unsigned) d->delivery_tag,
(int) d->exchange.len, (char *) d->exchange.bytes,
(int) d->routing_key.len, (char *) d->routing_key.bytes);
result = amqp_simple_wait_frame(conn, &frame);
if (result < 0)
break;
if (frame.frame_type != AMQP_FRAME_HEADER) {
fprintf(stderr, "Expected header!");
abort();
}
p = (amqp_basic_properties_t *) frame.payload.properties.decoded;
if (p->_flags & AMQP_BASIC_CONTENT_TYPE_FLAG) {
printf("Content-type: %.*s\n",
(int) p->content_type.len, (char *) p->content_type.bytes);
}
body_target = frame.payload.properties.body_size;
body_received = 0;
int sleep_seconds = 0;
while (body_received < body_target) {
result = amqp_simple_wait_frame(conn, &frame);
if (result < 0)
break;
if (frame.frame_type != AMQP_FRAME_BODY) {
fprintf(stderr, "Expected body!");
abort();
}
body_received += frame.payload.body_fragment.len;
assert(body_received <= body_target);
int i;
for(i = 0; i<frame.payload.body_fragment.len; i++)
{
printf("%c",*((char*)frame.payload.body_fragment.bytes+i));
if(*((char*)frame.payload.body_fragment.bytes+i) == '.')
sleep_seconds++;
}
printf("\n");
}
if (body_received != body_target) {
/* Can only happen when amqp_simple_wait_frame returns <= 0 */
/* We break here to close the connection */
break;
}
/* do something */
sleep(sleep_seconds);
amqp_basic_ack(conn,channelid,d->delivery_tag,0);
}
}
die_on_amqp_error(amqp_channel_close(conn, 1, AMQP_REPLY_SUCCESS), "Closing channel");
die_on_amqp_error(amqp_connection_close(conn, AMQP_REPLY_SUCCESS), "Closing connection");
die_on_error(amqp_destroy_connection(conn), "Ending connection");
return 0;
}
/* Threads */
void *janus_rmq_in_thread(void *data) {
if(rmq_client == NULL) {
JANUS_LOG(LOG_ERR, "No RabbitMQ connection??\n");
return NULL;
}
JANUS_LOG(LOG_VERB, "Joining RabbitMQ in thread\n");
struct timeval timeout;
timeout.tv_sec = 0;
timeout.tv_usec = 20000;
amqp_frame_t frame;
while(!rmq_client->destroy && !g_atomic_int_get(&stopping)) {
amqp_maybe_release_buffers(rmq_client->rmq_conn);
/* Wait for a frame */
int res = amqp_simple_wait_frame_noblock(rmq_client->rmq_conn, &frame, &timeout);
if(res != AMQP_STATUS_OK) {
/* No data */
if(res == AMQP_STATUS_TIMEOUT)
continue;
JANUS_LOG(LOG_VERB, "Error on amqp_simple_wait_frame_noblock: %d (%s)\n", res, amqp_error_string2(res));
break;
}
/* We expect method first */
JANUS_LOG(LOG_VERB, "Frame type %d, channel %d\n", frame.frame_type, frame.channel);
if(frame.frame_type != AMQP_FRAME_METHOD)
continue;
JANUS_LOG(LOG_VERB, "Method %s\n", amqp_method_name(frame.payload.method.id));
gboolean admin = FALSE;
if(frame.payload.method.id == AMQP_BASIC_DELIVER_METHOD) {
amqp_basic_deliver_t *d = (amqp_basic_deliver_t *)frame.payload.method.decoded;
JANUS_LOG(LOG_VERB, "Delivery #%u, %.*s\n", (unsigned) d->delivery_tag, (int) d->routing_key.len, (char *) d->routing_key.bytes);
/* Check if this is a Janus or Admin API request */
if(rmq_client->admin_api_enabled) {
if(d->routing_key.len == rmq_client->to_janus_admin_queue.len) {
size_t i=0;
admin = TRUE;
char *inq = (char *)d->routing_key.bytes;
char *expq = (char *)rmq_client->to_janus_admin_queue.bytes;
for(i=0; i< d->routing_key.len; i++) {
if(inq[i] != expq[i]) {
admin = FALSE;
break;
}
}
}
}
JANUS_LOG(LOG_VERB, " -- This is %s API request\n", admin ? "an admin" : "a Janus");
}
/* Then the header */
amqp_simple_wait_frame(rmq_client->rmq_conn, &frame);
JANUS_LOG(LOG_VERB, "Frame type %d, channel %d\n", frame.frame_type, frame.channel);
if(frame.frame_type != AMQP_FRAME_HEADER)
continue;
amqp_basic_properties_t *p = (amqp_basic_properties_t *)frame.payload.properties.decoded;
if(p->_flags & AMQP_BASIC_REPLY_TO_FLAG) {
JANUS_LOG(LOG_VERB, " -- Reply-to: %.*s\n", (int) p->reply_to.len, (char *) p->reply_to.bytes);
}
char *correlation = NULL;
if(p->_flags & AMQP_BASIC_CORRELATION_ID_FLAG) {
correlation = g_malloc0(p->correlation_id.len+1);
sprintf(correlation, "%.*s", (int) p->correlation_id.len, (char *) p->correlation_id.bytes);
JANUS_LOG(LOG_VERB, " -- Correlation-id: %s\n", correlation);
}
if(p->_flags & AMQP_BASIC_CONTENT_TYPE_FLAG) {
JANUS_LOG(LOG_VERB, " -- Content-type: %.*s\n", (int) p->content_type.len, (char *) p->content_type.bytes);
}
/* And the body */
uint64_t total = frame.payload.properties.body_size, received = 0;
char *payload = g_malloc0(total+1), *index = payload;
while(received < total) {
amqp_simple_wait_frame(rmq_client->rmq_conn, &frame);
JANUS_LOG(LOG_VERB, "Frame type %d, channel %d\n", frame.frame_type, frame.channel);
if(frame.frame_type != AMQP_FRAME_BODY)
break;
sprintf(index, "%.*s", (int) frame.payload.body_fragment.len, (char *) frame.payload.body_fragment.bytes);
received += frame.payload.body_fragment.len;
index = payload+received;
}
JANUS_LOG(LOG_VERB, "Got %"SCNu64"/%"SCNu64" bytes from the %s queue (%"SCNu64")\n",
received, total, admin ? "admin API" : "Janus API", frame.payload.body_fragment.len);
JANUS_LOG(LOG_VERB, "%s\n", payload);
/* Parse the JSON payload */
json_error_t error;
json_t *root = json_loads(payload, 0, &error);
g_free(payload);
/* Notify the core, passing both the object and, since it may be needed, the error
* We also specify the correlation ID as an opaque request identifier: we'll need it later */
gateway->incoming_request(&janus_rabbitmq_transport, rmq_session, correlation, admin, root, &error);
}
JANUS_LOG(LOG_INFO, "Leaving RabbitMQ in thread\n");
return NULL;
}
/* Transport implementation */
int janus_rabbitmq_init(janus_transport_callbacks *callback, const char *config_path) {
if(g_atomic_int_get(&stopping)) {
/* Still stopping from before */
return -1;
}
if(callback == NULL || config_path == NULL) {
/* Invalid arguments */
return -1;
}
/* This is the callback we'll need to invoke to contact the Janus core */
gateway = callback;
/* Read configuration */
char filename[255];
g_snprintf(filename, 255, "%s/%s.jcfg", config_path, JANUS_RABBITMQ_PACKAGE);
JANUS_LOG(LOG_VERB, "Configuration file: %s\n", filename);
janus_config *config = janus_config_parse(filename);
if(config == NULL) {
JANUS_LOG(LOG_WARN, "Couldn't find .jcfg configuration file (%s), trying .cfg\n", JANUS_RABBITMQ_PACKAGE);
g_snprintf(filename, 255, "%s/%s.cfg", config_path, JANUS_RABBITMQ_PACKAGE);
JANUS_LOG(LOG_VERB, "Configuration file: %s\n", filename);
config = janus_config_parse(filename);
}
if(config != NULL)
janus_config_print(config);
janus_config_category *config_general = janus_config_get_create(config, NULL, janus_config_type_category, "general");
janus_config_category *config_admin = janus_config_get_create(config, NULL, janus_config_type_category, "admin");
janus_config_item *item = janus_config_get(config, config_general, janus_config_type_item, "json");
if(item && item->value) {
/* Check how we need to format/serialize the JSON output */
if(!strcasecmp(item->value, "indented")) {
/* Default: indented, we use three spaces for that */
json_format = JSON_INDENT(3) | JSON_PRESERVE_ORDER;
} else if(!strcasecmp(item->value, "plain")) {
/* Not indented and no new lines, but still readable */
json_format = JSON_INDENT(0) | JSON_PRESERVE_ORDER;
} else if(!strcasecmp(item->value, "compact")) {
/* Compact, so no spaces between separators */
json_format = JSON_COMPACT | JSON_PRESERVE_ORDER;
} else {
JANUS_LOG(LOG_WARN, "Unsupported JSON format option '%s', using default (indented)\n", item->value);
json_format = JSON_INDENT(3) | JSON_PRESERVE_ORDER;
}
}
/* Check if we need to send events to handlers */
janus_config_item *events = janus_config_get(config, config_general, janus_config_type_item, "events");
if(events != NULL && events->value != NULL)
notify_events = janus_is_true(events->value);
if(!notify_events && callback->events_is_enabled()) {
JANUS_LOG(LOG_WARN, "Notification of events to handlers disabled for %s\n", JANUS_RABBITMQ_NAME);
}
/* Handle configuration, starting from the server details */
item = janus_config_get(config, config_general, janus_config_type_item, "host");
if(item && item->value)
rmqhost = g_strdup(item->value);
else
rmqhost = g_strdup("localhost");
int rmqport = AMQP_PROTOCOL_PORT;
item = janus_config_get(config, config_general, janus_config_type_item, "port");
if(item && item->value)
rmqport = atoi(item->value);
/* Credentials and Virtual Host */
item = janus_config_get(config, config_general, janus_config_type_item, "vhost");
if(item && item->value)
vhost = g_strdup(item->value);
else
vhost = g_strdup("/");
item = janus_config_get(config, config_general, janus_config_type_item, "username");
if(item && item->value)
username = g_strdup(item->value);
else
username = g_strdup("guest");
item = janus_config_get(config, config_general, janus_config_type_item, "password");
if(item && item->value)
password = g_strdup(item->value);
else
password = g_strdup("guest");
/* SSL config*/
gboolean ssl_enabled = FALSE;
gboolean ssl_verify_peer = FALSE;
gboolean ssl_verify_hostname = FALSE;
item = janus_config_get(config, config_general, janus_config_type_item, "ssl_enabled");
if(item == NULL) {
/* Try legacy property */
item = janus_config_get(config, config_general, janus_config_type_item, "ssl_enable");
if (item && item->value) {
JANUS_LOG(LOG_WARN, "Found deprecated 'ssl_enable' property, please update it to 'ssl_enabled' instead\n");
}
}
if(!item || !item->value || !janus_is_true(item->value)) {
JANUS_LOG(LOG_INFO, "RabbitMQ SSL support disabled\n");
} else {
ssl_enabled = TRUE;
item = janus_config_get(config, config_general, janus_config_type_item, "ssl_cacert");
if(item && item->value)
ssl_cacert_file = g_strdup(item->value);
item = janus_config_get(config, config_general, janus_config_type_item, "ssl_cert");
if(item && item->value)
ssl_cert_file = g_strdup(item->value);
item = janus_config_get(config, config_general, janus_config_type_item, "ssl_key");
if(item && item->value)
ssl_key_file = g_strdup(item->value);
item = janus_config_get(config, config_general, janus_config_type_item, "ssl_verify_peer");
if(item && item->value && janus_is_true(item->value))
ssl_verify_peer = TRUE;
item = janus_config_get(config, config_general, janus_config_type_item, "ssl_verify_hostname");
if(item && item->value && janus_is_true(item->value))
ssl_verify_hostname = TRUE;
}
/* Now check if the Janus API must be supported */
item = janus_config_get(config, config_general, janus_config_type_item, "enabled");
if(item == NULL) {
/* Try legacy property */
item = janus_config_get(config, config_general, janus_config_type_item, "enable");
if (item && item->value) {
JANUS_LOG(LOG_WARN, "Found deprecated 'enable' property, please update it to 'enabled' instead\n");
}
}
if(!item || !item->value || !janus_is_true(item->value)) {
JANUS_LOG(LOG_WARN, "RabbitMQ support disabled (Janus API)\n");
} else {
/* Parse configuration */
item = janus_config_get(config, config_general, janus_config_type_item, "to_janus");
if(!item || !item->value) {
JANUS_LOG(LOG_FATAL, "Missing name of incoming queue for RabbitMQ integration...\n");
goto error;
}
to_janus = g_strdup(item->value);
item = janus_config_get(config, config_general, janus_config_type_item, "from_janus");
if(!item || !item->value) {
JANUS_LOG(LOG_FATAL, "Missing name of outgoing queue for RabbitMQ integration...\n");
goto error;
}
from_janus = g_strdup(item->value);
item = janus_config_get(config, config_general, janus_config_type_item, "janus_exchange");
if(!item || !item->value) {
JANUS_LOG(LOG_INFO, "Missing name of outgoing exchange for RabbitMQ integration, using default\n");
} else {
janus_exchange = g_strdup(item->value);
}
if (janus_exchange == NULL) {
JANUS_LOG(LOG_INFO, "RabbitMQ support for Janus API enabled, %s:%d (%s/%s)\n", rmqhost, rmqport, to_janus, from_janus);
} else {
JANUS_LOG(LOG_INFO, "RabbitMQ support for Janus API enabled, %s:%d (%s/%s) exch: (%s)\n", rmqhost, rmqport, to_janus, from_janus, janus_exchange);
}
rmq_janus_api_enabled = TRUE;
}
/* Do the same for the admin API */
item = janus_config_get(config, config_admin, janus_config_type_item, "admin_enabled");
if(item == NULL) {
/* Try legacy property */
item = janus_config_get(config, config_general, janus_config_type_item, "admin_enable");
if (item && item->value) {
JANUS_LOG(LOG_WARN, "Found deprecated 'admin_enable' property, please update it to 'admin_enabled' instead\n");
}
}
if(!item || !item->value || !janus_is_true(item->value)) {
JANUS_LOG(LOG_WARN, "RabbitMQ support disabled (Admin API)\n");
} else {
/* Parse configuration */
item = janus_config_get(config, config_admin, janus_config_type_item, "to_janus_admin");
if(!item || !item->value) {
JANUS_LOG(LOG_FATAL, "Missing name of incoming queue for RabbitMQ integration...\n");
goto error;
}
to_janus_admin = g_strdup(item->value);
item = janus_config_get(config, config_admin, janus_config_type_item, "from_janus_admin");
if(!item || !item->value) {
JANUS_LOG(LOG_FATAL, "Missing name of outgoing queue for RabbitMQ integration...\n");
goto error;
}
from_janus_admin = g_strdup(item->value);
JANUS_LOG(LOG_INFO, "RabbitMQ support for Admin API enabled, %s:%d (%s/%s)\n", rmqhost, rmqport, to_janus_admin, from_janus_admin);
rmq_admin_api_enabled = TRUE;
}
if(!rmq_janus_api_enabled && !rmq_admin_api_enabled) {
JANUS_LOG(LOG_WARN, "RabbitMQ support disabled for both Janus and Admin API, giving up\n");
goto error;
} else {
/* FIXME We currently support a single application, create a new janus_rabbitmq_client instance */
rmq_client = g_malloc0(sizeof(janus_rabbitmq_client));
/* Connect */
rmq_client->rmq_conn = amqp_new_connection();
amqp_socket_t *socket = NULL;
int status;
JANUS_LOG(LOG_VERB, "Creating RabbitMQ socket...\n");
if (ssl_enabled) {
socket = amqp_ssl_socket_new(rmq_client->rmq_conn);
if(socket == NULL) {
JANUS_LOG(LOG_FATAL, "Can't connect to RabbitMQ server: error creating socket...\n");
goto error;
}
if(ssl_verify_peer) {
amqp_ssl_socket_set_verify_peer(socket, 1);
} else {
amqp_ssl_socket_set_verify_peer(socket, 0);
}
if(ssl_verify_hostname) {
amqp_ssl_socket_set_verify_hostname(socket, 1);
} else {
amqp_ssl_socket_set_verify_hostname(socket, 0);
}
if(ssl_cacert_file) {
status = amqp_ssl_socket_set_cacert(socket, ssl_cacert_file);
if(status != AMQP_STATUS_OK) {
JANUS_LOG(LOG_FATAL, "Can't connect to RabbitMQ server: error setting CA certificate... (%s)\n", amqp_error_string2(status));
goto error;
}
}
if(ssl_cert_file && ssl_key_file) {
status = amqp_ssl_socket_set_key(socket, ssl_cert_file, ssl_key_file);
if(status != AMQP_STATUS_OK) {
JANUS_LOG(LOG_FATAL, "Can't connect to RabbitMQ server: error setting key... (%s)\n", amqp_error_string2(status));
goto error;
}
}
} else {
socket = amqp_tcp_socket_new(rmq_client->rmq_conn);
if(socket == NULL) {
JANUS_LOG(LOG_FATAL, "Can't connect to RabbitMQ server: error creating socket...\n");
goto error;
}
}
JANUS_LOG(LOG_VERB, "Connecting to RabbitMQ server...\n");
status = amqp_socket_open(socket, rmqhost, rmqport);
if(status != AMQP_STATUS_OK) {
JANUS_LOG(LOG_FATAL, "Can't connect to RabbitMQ server: error opening socket... (%s)\n", amqp_error_string2(status));
goto error;
}
JANUS_LOG(LOG_VERB, "Logging in...\n");
amqp_rpc_reply_t result = amqp_login(rmq_client->rmq_conn, vhost, 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, username, password);
if(result.reply_type != AMQP_RESPONSE_NORMAL) {
JANUS_LOG(LOG_FATAL, "Can't connect to RabbitMQ server: error logging in... %s, %s\n", amqp_error_string2(result.library_error), amqp_method_name(result.reply.id));
goto error;
}
rmq_client->rmq_channel = 1;
JANUS_LOG(LOG_VERB, "Opening channel...\n");
amqp_channel_open(rmq_client->rmq_conn, rmq_client->rmq_channel);
result = amqp_get_rpc_reply(rmq_client->rmq_conn);
if(result.reply_type != AMQP_RESPONSE_NORMAL) {
JANUS_LOG(LOG_FATAL, "Can't connect to RabbitMQ server: error opening channel... %s, %s\n", amqp_error_string2(result.library_error), amqp_method_name(result.reply.id));
goto error;
}
rmq_client->janus_exchange = amqp_empty_bytes;
if(janus_exchange != NULL) {
JANUS_LOG(LOG_VERB, "Declaring exchange...\n");
rmq_client->janus_exchange = amqp_cstring_bytes(janus_exchange);
amqp_exchange_declare(rmq_client->rmq_conn, rmq_client->rmq_channel, rmq_client->janus_exchange, amqp_cstring_bytes(JANUS_RABBITMQ_EXCHANGE_TYPE), 0, 0, 0, 0, amqp_empty_table);
result = amqp_get_rpc_reply(rmq_client->rmq_conn);
if(result.reply_type != AMQP_RESPONSE_NORMAL) {
JANUS_LOG(LOG_FATAL, "Can't connect to RabbitMQ server: error diclaring exchange... %s, %s\n", amqp_error_string2(result.library_error), amqp_method_name(result.reply.id));
goto error;
}
}
rmq_client->janus_api_enabled = FALSE;
if(rmq_janus_api_enabled) {
rmq_client->janus_api_enabled = TRUE;
JANUS_LOG(LOG_VERB, "Declaring incoming queue... (%s)\n", to_janus);
rmq_client->to_janus_queue = amqp_cstring_bytes(to_janus);
amqp_queue_declare(rmq_client->rmq_conn, rmq_client->rmq_channel, rmq_client->to_janus_queue, 0, 0, 0, 0, amqp_empty_table);
result = amqp_get_rpc_reply(rmq_client->rmq_conn);
if(result.reply_type != AMQP_RESPONSE_NORMAL) {
JANUS_LOG(LOG_FATAL, "Can't connect to RabbitMQ server: error declaring queue... %s, %s\n", amqp_error_string2(result.library_error), amqp_method_name(result.reply.id));
goto error;
}
JANUS_LOG(LOG_VERB, "Declaring outgoing queue... (%s)\n", from_janus);
rmq_client->from_janus_queue = amqp_cstring_bytes(from_janus);
amqp_queue_declare(rmq_client->rmq_conn, rmq_client->rmq_channel, rmq_client->from_janus_queue, 0, 0, 0, 0, amqp_empty_table);
result = amqp_get_rpc_reply(rmq_client->rmq_conn);
if(result.reply_type != AMQP_RESPONSE_NORMAL) {
JANUS_LOG(LOG_FATAL, "Can't connect to RabbitMQ server: error declaring queue... %s, %s\n", amqp_error_string2(result.library_error), amqp_method_name(result.reply.id));
goto error;
}
amqp_basic_consume(rmq_client->rmq_conn, rmq_client->rmq_channel, rmq_client->to_janus_queue, amqp_empty_bytes, 0, 1, 0, amqp_empty_table);
result = amqp_get_rpc_reply(rmq_client->rmq_conn);
if(result.reply_type != AMQP_RESPONSE_NORMAL) {
JANUS_LOG(LOG_FATAL, "Can't connect to RabbitMQ server: error consuming... %s, %s\n", amqp_error_string2(result.library_error), amqp_method_name(result.reply.id));
goto error;
}
}
rmq_client->admin_api_enabled = FALSE;
if(rmq_admin_api_enabled) {
rmq_client->admin_api_enabled = TRUE;
JANUS_LOG(LOG_VERB, "Declaring incoming queue... (%s)\n", to_janus_admin);
rmq_client->to_janus_admin_queue = amqp_cstring_bytes(to_janus_admin);
amqp_queue_declare(rmq_client->rmq_conn, rmq_client->rmq_channel, rmq_client->to_janus_admin_queue, 0, 0, 0, 0, amqp_empty_table);
result = amqp_get_rpc_reply(rmq_client->rmq_conn);
if(result.reply_type != AMQP_RESPONSE_NORMAL) {
JANUS_LOG(LOG_FATAL, "Can't connect to RabbitMQ server: error declaring queue... %s, %s\n", amqp_error_string2(result.library_error), amqp_method_name(result.reply.id));
goto error;
}
JANUS_LOG(LOG_VERB, "Declaring outgoing queue... (%s)\n", from_janus_admin);
rmq_client->from_janus_admin_queue = amqp_cstring_bytes(from_janus_admin);
amqp_queue_declare(rmq_client->rmq_conn, rmq_client->rmq_channel, rmq_client->from_janus_admin_queue, 0, 0, 0, 0, amqp_empty_table);
result = amqp_get_rpc_reply(rmq_client->rmq_conn);
if(result.reply_type != AMQP_RESPONSE_NORMAL) {
JANUS_LOG(LOG_FATAL, "Can't connect to RabbitMQ server: error declaring queue... %s, %s\n", amqp_error_string2(result.library_error), amqp_method_name(result.reply.id));
goto error;
}
amqp_basic_consume(rmq_client->rmq_conn, rmq_client->rmq_channel, rmq_client->to_janus_admin_queue, amqp_empty_bytes, 0, 1, 0, amqp_empty_table);
result = amqp_get_rpc_reply(rmq_client->rmq_conn);
if(result.reply_type != AMQP_RESPONSE_NORMAL) {
JANUS_LOG(LOG_FATAL, "Can't connect to RabbitMQ server: error consuming... %s, %s\n", amqp_error_string2(result.library_error), amqp_method_name(result.reply.id));
goto error;
}
}
rmq_client->messages = g_async_queue_new();
rmq_client->destroy = 0;
/* Prepare the transport session (again, just one) */
rmq_session = janus_transport_session_create(rmq_client, NULL);
/* Start the threads */
GError *error = NULL;
rmq_client->in_thread = g_thread_try_new("rmq_in_thread", &janus_rmq_in_thread, rmq_client, &error);
if(error != NULL) {
/* Something went wrong... */
JANUS_LOG(LOG_FATAL, "Got error %d (%s) trying to launch the RabbitMQ incoming thread...\n", error->code, error->message ? error->message : "??");
janus_transport_session_destroy(rmq_session);
g_free(rmq_client);
janus_config_destroy(config);
return -1;
}
rmq_client->out_thread = g_thread_try_new("rmq_out_thread", &janus_rmq_out_thread, rmq_client, &error);
if(error != NULL) {
/* Something went wrong... */
JANUS_LOG(LOG_FATAL, "Got error %d (%s) trying to launch the RabbitMQ outgoing thread...\n", error->code, error->message ? error->message : "??");
janus_transport_session_destroy(rmq_session);
g_free(rmq_client);
janus_config_destroy(config);
return -1;
}
janus_mutex_init(&rmq_client->mutex);
/* Done */
JANUS_LOG(LOG_INFO, "Setup of RabbitMQ integration completed\n");
/* Notify handlers about this new transport */
if(notify_events && gateway->events_is_enabled()) {
json_t *info = json_object();
json_object_set_new(info, "event", json_string("connected"));
gateway->notify_event(&janus_rabbitmq_transport, rmq_session, info);
}
}
janus_config_destroy(config);
config = NULL;
/* Done */
g_atomic_int_set(&initialized, 1);
JANUS_LOG(LOG_INFO, "%s initialized!\n", JANUS_RABBITMQ_NAME);
return 0;
error:
/* If we got here, something went wrong */
g_free(rmq_client);
g_free(rmqhost);
g_free(vhost);
g_free(username);
g_free(password);
g_free(janus_exchange);
g_free(to_janus);
g_free(from_janus);
g_free(to_janus_admin);
g_free(from_janus_admin);
g_free(ssl_cacert_file);
g_free(ssl_cert_file);
g_free(ssl_key_file);
if(config)
janus_config_destroy(config);
return -1;
}
