void Channel::listen(Callable_envelope& callback){
amqp_connection_state_t conn = this->conn_ptr->_getconn_n();
//open channel
//amqp_channel_open(conn, channel);
//die_on_amqp_error(amqp_get_rpc_reply(conn), "Opening channel");
//set consumer
amqp_basic_consume(conn,
this->channel_n,
amqp_cstring_bytes(this->queue_name.c_str()),
amqp_empty_bytes, 0, 1, 0, amqp_empty_table);//auto ack consumer
die_on_amqp_error(amqp_get_rpc_reply(this->conn_ptr->_getconn_n()), "rabbitmq_listen Consuming");
{
while (1) {
amqp_rpc_reply_t res;
amqp_envelope_t envelope;
amqp_maybe_release_buffers(conn);
res = amqp_consume_message(conn, &envelope, NULL, 0);
if (AMQP_RESPONSE_NORMAL != res.reply_type) {
//this solution is not really work when network changed.
label_listen_reconnet:
Log::log.warning("Channel::listen, AMQP response abnormal\n");
Log::log.warning("Channel::listen, reconnecting...\n");
//first close previous
amqp_channel_close(this->conn_ptr->_getconn_n(), this->channel_n, AMQP_REPLY_SUCCESS);
amqp_connection_close(this->conn_ptr->_getconn_n(), AMQP_REPLY_SUCCESS);
amqp_destroy_connection(this->conn_ptr->_getconn_n());
//reconnect to rabbitMQ server!
this->conn_ptr->reconnnect();
amqp_channel_open(this->conn_ptr->_getconn_n(), channel_n);
if(amqp_get_rpc_reply(this->conn_ptr->_getconn_n()).reply_type !=AMQP_RESPONSE_NORMAL){
Log::log.warning("Channel::publish:Opening channel_n error\n");
sleep(2);
goto label_listen_reconnet;
}else{
continue;
}
}
callback.callback(envelope);
amqp_destroy_envelope(&envelope);
}
}
die_on_amqp_error(amqp_channel_close(conn, this->channel_n, AMQP_REPLY_SUCCESS), "Closing channel");
}
int main(int argc, char const * const *argv) {
char const *hostname;
int port;
int rate_limit;
int message_count;
int sockfd;
amqp_connection_state_t conn;
if (argc < 5) {
fprintf(stderr, "Usage: amqp_producer host port rate_limit message_count\n");
return 1;
}
hostname = argv[1];
port = atoi(argv[2]);
rate_limit = atoi(argv[3]);
message_count = atoi(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");
send_batch(conn, "test queue", rate_limit, message_count);
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;
}
RabbitMQConnection::~RabbitMQConnection()
{
int fd;
if (conn == NULL) {
GST_DEBUG ("service already stopped");
return;
}
fd = amqp_socket_get_sockfd (socket);
/* Errors are ignored during close */
if (!closeOnRelease) {
/* close socket */
close (fd);
}
amqp_channel_close (conn, 1, AMQP_REPLY_SUCCESS);
amqp_connection_close (conn, AMQP_REPLY_SUCCESS);
amqp_destroy_connection (conn);
if (closeOnRelease) {
/* inform remote side that we are done */
shutdown (fd, SHUT_WR);
}
conn = NULL;
}
void rpc_close(struct status *status)
{
int ret = 0;
DEBUG(2, ("[*] Closing RPC\n"));
/* Adquire lock */
ret = pthread_spin_lock(&status->lock);
if (ret) {
fprintf(stderr, "[!] pthread_spin_lock: %s\n", strerror(ret));
return;
}
if (status->conn) {
if (amqp_channel_close(status->conn, 1, AMQP_REPLY_SUCCESS).reply_type != AMQP_RESPONSE_NORMAL) {
fprintf(stderr, "[!] Error closing AMQP channel\n");
}
if (amqp_connection_close(status->conn, AMQP_REPLY_SUCCESS).reply_type != AMQP_RESPONSE_NORMAL) {
fprintf(stderr, "[!] Error closing AMQP connection\n");
}
if (amqp_destroy_connection(status->conn) < 0) {
fprintf(stderr, "[!] Error destroying AMQP connection\n");
}
}
status->conn = NULL;
/* Release lock */
pthread_spin_unlock(&status->lock);
}
static int exit_amqp_connection_atomic()
{
int res = LC_BUS_OK;
amqp_rpc_reply_t ret;
int i;
for (i = 0; i < LC_BUS_MAX_CONNECTION; ++i) {
if (connection_tid[i]) {
ret = amqp_channel_close(lc_conn[i],
LC_BUS_CHANNEL, AMQP_REPLY_SUCCESS);
if (ret.reply_type != AMQP_RESPONSE_NORMAL) {
LB_SYSLOG(LOG_ERR, "error in closing channel: %s\n",
amqp_rpc_reply_string(&ret));
}
ret = amqp_connection_close(lc_conn[i], AMQP_REPLY_SUCCESS);
if (ret.reply_type != AMQP_RESPONSE_NORMAL) {
LB_SYSLOG(LOG_ERR, "error in closing connection, %s\n",
amqp_rpc_reply_string(&ret));
}
res = amqp_destroy_connection(lc_conn[i]);
if (res) {
LB_SYSLOG(LOG_ERR, "error in destroy connection ret=%d\n", res);
}
connection_tid[i] = 0;
}
}
return LC_BUS_OK;
}
void destroy()
{
amqp_channel_close(conn, channel_id, AMQP_REPLY_SUCCESS);
amqp_connection_close(conn, AMQP_REPLY_SUCCESS);
amqp_destroy_connection(conn);
printf("amqp close and destroy connection.\n");
}
/* php_amqp_disconnect
handles disconnecting from amqp
called by disconnect(), reconnect(), and d_tor
*/
void php_amqp_disconnect(amqp_connection_object *amqp_connection)
{
void * old_handler;
/*
If we are trying to close the connection and the connection already closed, it will throw
SIGPIPE, which is fine, so ignore all SIGPIPES
*/
/* Start ignoring SIGPIPE */
old_handler = signal(SIGPIPE, SIG_IGN);
if (amqp_connection->is_channel_connected == '\1') {
amqp_channel_close(amqp_connection->conn, AMQP_CHANNEL, AMQP_REPLY_SUCCESS);
}
amqp_connection->is_channel_connected = '\0';
if (amqp_connection->conn && amqp_connection->is_connected == '\1') {
amqp_connection_close(amqp_connection->conn, AMQP_REPLY_SUCCESS);
amqp_destroy_connection(amqp_connection->conn);
}
amqp_connection->is_connected = '\0';
if (amqp_connection->fd) {
close(amqp_connection->fd);
}
/* End ignoring of SIGPIPEs */
signal(SIGPIPE, old_handler);
return;
}
int main(int argc, char const *const *argv)
{
char const *hostname;
int port, status;
char const *exchange;
char const *exchangetype;
amqp_socket_t *socket;
amqp_connection_state_t conn;
if (argc < 5) {
fprintf(stderr, "Usage: amqps_exchange_declare host port exchange "
"exchangetype [cacert.pem [key.pem cert.pem]]\n");
return 1;
}
hostname = argv[1];
port = atoi(argv[2]);
exchange = argv[3];
exchangetype = argv[4];
conn = amqp_new_connection();
socket = amqp_ssl_socket_new(conn);
if (!socket) {
die("creating SSL/TLS socket");
}
if (argc > 5) {
status = amqp_ssl_socket_set_cacert(socket, argv[5]);
if (status) {
die("setting CA certificate");
}
}
if (argc > 7) {
status = amqp_ssl_socket_set_key(socket, argv[7], argv[6]);
if (status) {
die("setting client key/cert");
}
}
status = amqp_socket_open(socket, hostname, port);
if (status) {
die("opening SSL/TLS connection");
}
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_exchange_declare(conn, 1, amqp_cstring_bytes(exchange), amqp_cstring_bytes(exchangetype),
0, 0, amqp_empty_table);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Declaring exchange");
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;
}
static void
_amqp_connection_disconnect(AMQPDestDriver* self)
{
amqp_channel_close(self->conn, 1, AMQP_REPLY_SUCCESS);
amqp_connection_close(self->conn, AMQP_REPLY_SUCCESS);
_amqp_connection_deinit(self);
}
/**
* Close a session with the filter, this is the mechanism
* by which a filter may cleanup data structure etc.
* In the case of the MQ filter we simply close the connection to the server.
*
* @param instance The filter instance data
* @param session The session being closed
*/
static void
closeSession(FILTER *instance, void *session)
{
MQ_SESSION *my_session = (MQ_SESSION *)session;
amqp_channel_close(my_session->conn,my_session->channel,AMQP_REPLY_SUCCESS);
amqp_connection_close(my_session->conn,AMQP_REPLY_SUCCESS);
amqp_destroy_connection(my_session->conn);
}
static void
afamqp_dd_disconnect(AMQPDestDriver *self)
{
amqp_channel_close(self->conn, 1, AMQP_REPLY_SUCCESS);
amqp_connection_close(self->conn, AMQP_REPLY_SUCCESS);
amqp_destroy_connection(self->conn);
self->conn = NULL;
}
int main(int argc, char const *const *argv)
{
char const *hostname;
int port, status;
int rate_limit;
int message_count;
amqp_socket_t *socket;
amqp_connection_state_t conn;
if (argc < 5) {
fprintf(stderr, "Usage: amqps_producer host port rate_limit message_count "
"[cacert.pem [key.pem cert.pem]]\n");
return 1;
}
hostname = argv[1];
port = atoi(argv[2]);
rate_limit = atoi(argv[3]);
message_count = atoi(argv[4]);
conn = amqp_new_connection();
socket = amqp_ssl_socket_new(conn);
if (!socket) {
die("creating SSL/TLS socket");
}
if (argc > 5) {
status = amqp_ssl_socket_set_cacert(socket, argv[5]);
if (status) {
die("setting CA certificate");
}
}
if (argc > 7) {
status = amqp_ssl_socket_set_key(socket, argv[7], argv[6]);
if (status) {
die("setting client cert");
}
}
status = amqp_socket_open(socket, hostname, port);
if (status) {
die("opening SSL/TLS connection");
}
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");
send_batch(conn, "test queue", rate_limit, message_count);
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;
}
void AMQPBase::closeChannel()
{
if (opened) {
amqp_channel_close(*cnn, channelNum, AMQP_REPLY_SUCCESS);
amqp_rpc_reply_t res = amqp_get_rpc_reply(*cnn);
THROW_AMQP_EXC_IF_FAILED(res, "close channel");
opened = 0;
}
}
int main(int argc, const char **argv) {
const char *hostname;
int port;
const char *exchange;
const char *routingkey;
const char *messagebody;
const char *exchangetype = "direct";
if (argc < 6) {
fprintf(stderr, "Usage: emit_log_direct host port exchange routingkey messagebody\n");
return 1;
}
hostname = argv[1];
port = atoi(argv[2]);
exchange = argv[3];
routingkey = argv[4];
messagebody = argv[5];
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_basic_properties_t props;
props._flags = AMQP_BASIC_DELIVERY_MODE_FLAG;
/*props.content_type = amqp_cstring_bytes("text/plain");*/
props.delivery_mode = 2; /* persistent delivery mode */
die_on_error(amqp_basic_publish(conn,
channelid,
amqp_cstring_bytes(exchange),
amqp_cstring_bytes(routingkey),
0,
0,
&props,
amqp_cstring_bytes(messagebody)),
"Publishing");
}
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 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 < 3) {
fprintf(stderr, "Usage: amqp_consumer host port\n");
return 1;
}
hostname = argv[1];
port = atoi(argv[2]);
exchange = "amq.direct"; /* argv[3]; */
bindingkey = "test queue"; /* 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) {
fprintf(stderr, "Out of memory while copying queue name");
return 1;
}
}
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, amqp_empty_table);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Consuming");
run(conn);
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;
}
static
void shutdown_amqp_connection(amqp_connection_state_t connection, int amqp_rc, uint num_channels)
{
// close amqp connection, including all open channels
if (amqp_rc >= 0) {
for (int i=1; i <= num_channels; i++)
log_amqp_error(amqp_channel_close(connection, i, AMQP_REPLY_SUCCESS), "closing AMQP channel");
log_amqp_error(amqp_connection_close(connection, AMQP_REPLY_SUCCESS), "closing AMQP connection");
}
log_error(amqp_destroy_connection(connection), "closing AMQP connection");
}
static void
closeAMQPConnection(instanceData *pData)
{
if (pData->conn != NULL) {
die_on_amqp_error(amqp_channel_close(pData->conn, 1, AMQP_REPLY_SUCCESS), "amqp_channel_close");
die_on_amqp_error(amqp_connection_close(pData->conn, AMQP_REPLY_SUCCESS), "amqp_connection_close");
die_on_error(amqp_destroy_connection(pData->conn), "amqp_destroy_connection");
pData->conn = NULL;
}
}
void close_connection(amqp_connection_state_t conn)
{
int res;
die_rpc(amqp_channel_close(conn, 1, AMQP_REPLY_SUCCESS),
"closing channel");
die_rpc(amqp_connection_close(conn, AMQP_REPLY_SUCCESS),
"closing connection");
res = amqp_destroy_connection(conn);
die_amqp_error(res, "closing connection");
}
/*
* Close a channel and wait for 5 seconds to receive a channel close OK event
*/
static wiced_result_t amqp_ch_close( wiced_amqp_connection_t *conn, uint16_t channel )
{
if ( amqp_channel_close( channel, conn ) != WICED_SUCCESS )
{
return WICED_ERROR;
}
if ( amqp_wait_for( AMQP_EVENT_CHANNEL_RECV_CLOSE_OK, 5000 ) != WICED_SUCCESS )
{
return WICED_ERROR;
}
return WICED_SUCCESS;
}
int create_queue_item(void *buf, size_t len) {
printf("length: %zu\n", len);
amqp_connection_state_t conn = amqp_new_connection();
amqp_socket_t *socket = amqp_tcp_socket_new(conn);
if (!socket) {
printf("Error creating TCP socket.\n");
return -1;
}
int status = amqp_socket_open(socket, "localhost", 5672);
if (status) {
printf("Error opening TCP socket.\n");
return -1;
}
// Open channel
if (handle_amqp_error(amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, "guest", "guest"), "Login")) {
return -1;
}
amqp_channel_open(conn, 1);
if (handle_amqp_error(amqp_get_rpc_reply(conn), "Get Reply")) {
return -1;
}
// Send message
{
amqp_basic_properties_t props;
props._flags = AMQP_BASIC_CONTENT_TYPE_FLAG | AMQP_BASIC_DELIVERY_MODE_FLAG;
props.content_type = amqp_cstring_bytes("text/plain");
props.delivery_mode = 2; /* persistent delivery mode */
status = amqp_basic_publish(conn,
1,
amqp_cstring_bytes(""),
amqp_cstring_bytes("test-route"),
0,
0,
&props,
amqp_cstring_bytes(buf));
if (status < 0) {
printf("Error publishing\n");
return -1;
}
printf("Published the thingy\n");
}
// Close channel
amqp_channel_close(conn, 1, AMQP_REPLY_SUCCESS);
amqp_connection_close(conn, AMQP_REPLY_SUCCESS);
amqp_destroy_connection(conn);
return 0;
}
AMQP::~AMQP() {
if (channels.size()) {
vector<AMQPBase*>::iterator i;
for (i=channels.begin(); i!=channels.end(); i++) {
delete *i;
}
}
amqp_channel_close(cnn, 1, AMQP_REPLY_SUCCESS);
amqp_connection_close(cnn, AMQP_REPLY_SUCCESS);
amqp_destroy_connection(cnn);
};
int main(int argc, char const *const *argv)
{
char const *hostname;
int port, status;
char const *exchange;
char const *bindingkey;
char const *queue;
amqp_socket_t *socket = NULL;
amqp_connection_state_t conn;
if (argc < 6) {
fprintf(stderr, "Usage: amqp_bind host port exchange bindingkey queue\n");
return 1;
}
hostname = argv[1];
port = atoi(argv[2]);
exchange = argv[3];
bindingkey = argv[4];
queue = argv[5];
conn = amqp_new_connection();
socket = amqp_tcp_socket_new();
if (!socket) {
die("creating TCP socket");
}
status = amqp_socket_open(socket, hostname, port);
if (status) {
die("opening TCP socket");
}
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_queue_bind(conn, 1,
amqp_cstring_bytes(queue),
amqp_cstring_bytes(exchange),
amqp_cstring_bytes(bindingkey),
amqp_empty_table);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Unbinding");
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;
}
/*
* Functions
*/
static void camqp_close_connection (camqp_config_t *conf) /* {{{ */
{
int sockfd;
if ((conf == NULL) || (conf->connection == NULL))
return;
sockfd = amqp_get_sockfd (conf->connection);
amqp_channel_close (conf->connection, CAMQP_CHANNEL, AMQP_REPLY_SUCCESS);
amqp_connection_close (conf->connection, AMQP_REPLY_SUCCESS);
amqp_destroy_connection (conf->connection);
close (sockfd);
conf->connection = NULL;
} /* }}} void camqp_close_connection */
void Channel::publish(const std::string& exchange,const std::string& routing_key,
const std::string& mesg ){
amqp_basic_properties_t props;
props._flags = AMQP_BASIC_CONTENT_TYPE_FLAG | AMQP_BASIC_DELIVERY_MODE_FLAG;
props.content_type = amqp_cstring_bytes("text/plain");
props.delivery_mode = 1; /* transient delivery mode */
int x = amqp_basic_publish(this->conn_ptr->_getconn_n(),
this->channel_n,
amqp_cstring_bytes(exchange.c_str()),
amqp_cstring_bytes(routing_key.c_str()),
0,
0,
&props,
amqp_cstring_bytes(mesg.c_str()));
if(x<0){
label_reconnet:
//meaning error occur
Log::log.warning("%s: %s\n", "publishing", amqp_error_string2(x));
Log::log.warning("Channel::publish: Reconnecting to RabbitMQ\n");
//first close all the things
amqp_channel_close(this->conn_ptr->_getconn_n(), this->channel_n, AMQP_REPLY_SUCCESS);
amqp_connection_close(this->conn_ptr->_getconn_n(), AMQP_REPLY_SUCCESS);
amqp_destroy_connection(this->conn_ptr->_getconn_n());
//reconnect to rabbitMQ server!
this->conn_ptr->reconnnect();
amqp_channel_open(this->conn_ptr->_getconn_n(), channel_n);
if(amqp_get_rpc_reply(this->conn_ptr->_getconn_n()).reply_type !=AMQP_RESPONSE_NORMAL){
Log::log.warning("Channel::publish:Opening channel_n error\n");
}else{
x = amqp_basic_publish(this->conn_ptr->_getconn_n(),
this->channel_n,
amqp_cstring_bytes(exchange.c_str()),
amqp_cstring_bytes(routing_key.c_str()),
0,
0,
&props,
amqp_cstring_bytes(mesg.c_str()));
}
if(x<0){
sleep(2);
goto label_reconnet;
}
}
//die_on_error(x, "Publishing");
}
void rmq_close(int destroy)
{
if (ctx->channel) {
amqp_channel_close(ctx->conn, ctx->channel, AMQP_REPLY_SUCCESS);
ctx->channel = 0;
}
if (ctx->socket) {
amqp_connection_close(ctx->conn, AMQP_REPLY_SUCCESS);
ctx->socket = 0;
}
if (destroy) {
amqp_destroy_connection(ctx->conn);
ctx->conn = 0;
}
}
static amqp_connection_state_t get_amqp_connection(void)
{
int status;
amqp_connection_state_t conn;
amqp_rpc_reply_t reply;
amqp_socket_t *socket = NULL;
conn = amqp_new_connection();
if (!conn) {
fprintf(stderr, "[!] Error getting ampq connection\n");
return NULL;
}
socket = amqp_tcp_socket_new(conn);
if (!socket) {
amqp_destroy_connection(conn);
fprintf(stderr, "[!] Error creating the TCP socket!\n");
return NULL;
}
status = amqp_socket_open(socket, "localhost", 5672);
if (status) {
amqp_connection_close(conn, AMQP_REPLY_SUCCESS);
amqp_destroy_connection(conn);
fprintf(stderr, "[!] Error opening the TCP socket!\n");
return NULL;
}
reply = amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN,
"guest", "guest");
if (reply.reply_type != AMQP_RESPONSE_NORMAL) {
amqp_connection_close(conn, AMQP_REPLY_SUCCESS);
amqp_destroy_connection(conn);
fprintf(stderr, "[!] Error loggging into server\n");
return NULL;
}
if (!amqp_channel_open(conn, 1)) {
amqp_channel_close(conn, 1, AMQP_REPLY_SUCCESS);
amqp_connection_close(conn, AMQP_REPLY_SUCCESS);
fprintf(stderr, "[!] Error opening channel 1\n");
return NULL;
}
return conn;
}
void rmq_destroy_param(rmq_params_t *rmqp)
{
if (!rmqp)
return;
if (rmqp->conn && rmqp->flags & RMQ_PARAM_CONN) {
if (rmqp->flags & RMQ_PARAM_CHAN) {
rmq_error("closing channel",
amqp_channel_close(rmqp->conn, rmqp->channel,
AMQP_REPLY_SUCCESS));
}
rmq_error("closing connection",
amqp_connection_close(rmqp->conn, AMQP_REPLY_SUCCESS));
if (amqp_destroy_connection(rmqp->conn) < 0)
LM_ERR("cannot destroy connection\n");
}
rmqp->flags &= ~(RMQ_PARAM_CONN|RMQ_PARAM_CHAN);
}
void janus_rabbitmq_destroy(void) {
if(!g_atomic_int_get(&initialized))
return;
g_atomic_int_set(&stopping, 1);
if(rmq_client) {
rmq_client->destroy = 1;
g_async_queue_push(rmq_client->messages, &exit_message);
if(rmq_client->in_thread)
g_thread_join(rmq_client->in_thread);
if(rmq_client->out_thread)
g_thread_join(rmq_client->out_thread);
if(rmq_client->rmq_conn && rmq_client->rmq_channel) {
amqp_channel_close(rmq_client->rmq_conn, rmq_client->rmq_channel, AMQP_REPLY_SUCCESS);
amqp_connection_close(rmq_client->rmq_conn, AMQP_REPLY_SUCCESS);
amqp_destroy_connection(rmq_client->rmq_conn);
}
}
g_free(rmq_client);
janus_transport_session_destroy(rmq_session);
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);
g_atomic_int_set(&initialized, 0);
g_atomic_int_set(&stopping, 0);
JANUS_LOG(LOG_INFO, "%s destroyed!\n", JANUS_RABBITMQ_NAME);
}
int releaseMsgClient(MsgReceiver_t *receiver) {
if(receiver == NULL) {
LOG4CXX_ERROR(logger, "releaseMsgClient: receiver is null");
return EINVAL;
}
if(receiver->thread_run) {
// stop thread
LOG4CXX_DEBUG(logger, "releaseMsgClient: canceling an event receiver thread");
receiver->thread_run = false;
pthread_cancel(receiver->thread);
pthread_join(receiver->thread, NULL);
}
amqp_channel_close(receiver->conn_state, receiver->channel, AMQP_REPLY_SUCCESS);
amqp_connection_close(receiver->conn_state, AMQP_REPLY_SUCCESS);
amqp_destroy_connection(receiver->conn_state);
free(receiver);
LOG4CXX_DEBUG(logger, "releaseMsgClient: closed connection");
return 0;
}
static int send(struct stats_buffer *sf)
{
int status;
char const *exchange;
char const *routingkey;
amqp_socket_t *socket = NULL;
amqp_connection_state_t conn;
exchange = "amq.direct";
routingkey = "tacc_stats";
conn = amqp_new_connection();
socket = amqp_tcp_socket_new(conn);
status = amqp_socket_open(socket, sf->sf_host, atoi(sf->sf_port));
amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN,
"guest", "guest");
amqp_channel_open(conn, 1);
amqp_get_rpc_reply(conn);
{
amqp_basic_properties_t props;
props._flags = AMQP_BASIC_CONTENT_TYPE_FLAG | AMQP_BASIC_DELIVERY_MODE_FLAG;
props.content_type = amqp_cstring_bytes("text/plain");
props.delivery_mode = 2; /* persistent delivery mode */
amqp_basic_publish(conn,
1,
amqp_cstring_bytes(exchange),
amqp_cstring_bytes(routingkey),
0,
0,
&props,
amqp_cstring_bytes(sf->sf_data));
}
amqp_channel_close(conn, 1, AMQP_REPLY_SUCCESS);
amqp_connection_close(conn, AMQP_REPLY_SUCCESS);
amqp_destroy_connection(conn);
return 0;
}
