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, 0), "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
amqp_connection_state_t setup_amqp_connection()
{
amqp_connection_state_t connection = amqp_new_connection();
amqp_socket_t *socket = amqp_tcp_socket_new(connection);
#ifdef FIX_SIG_PIPE
// why doesn't librabbitmq do this, eh?
int sockfd = amqp_get_sockfd(connection);
int one = 1; //
setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, &one, sizeof(one));
#endif
int status = amqp_socket_open(socket, rabbit_host, rabbit_port);
assert_x(!status, "Opening RabbitMQ socket", __FILE__, __LINE__);
die_on_amqp_error(amqp_login(connection, "/", 0, OUR_FRAME_MAX, 0, AMQP_SASL_METHOD_PLAIN, "guest", "guest"),
"Logging in to RabbitMQ");
amqp_channel_open(connection, 1);
die_on_amqp_error(amqp_get_rpc_reply(connection), "Opening AMQP channel");
return connection;
}
int main(int argc, char const * const *argv) {
char const *hostname;
int port;
char const *exchange;
char const *exchangetype;
int sockfd;
amqp_connection_state_t conn;
if (argc < 5) {
fprintf(stderr, "Usage: amqp_exchange_declare host port exchange exchangetype\n");
return 1;
}
hostname = argv[1];
port = atoi(argv[2]);
exchange = argv[3];
exchangetype = 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_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;
}
void RabbitMQConnection::_rabbitMQConnection(const std::string& hostname, int port, const std::string& vhost,
const std::string& user, const std::string& password) {
this->channel_n=0;
this->conn = amqp_new_connection();
amqp_socket_t * socket = amqp_tcp_socket_new(conn);
if (!socket) {
die("creating TCP socket");
}
int status = amqp_socket_open(socket, hostname.c_str(), port);
if (status) {
die("opening TCP socket");
}
die_on_amqp_error(amqp_login(this->conn, vhost.c_str(), 0, 131072, 60, AMQP_SASL_METHOD_PLAIN, user.c_str(), password.c_str()),
"Logging in");
}
void Channel::binding(const std::string& routing_key){
if(this->queue_name.empty()){
amqp_queue_declare_ok_t *r = amqp_queue_declare(this->conn_ptr->_getconn_n(),
this->channel_n, amqp_empty_bytes, 0, 0, 1, 1,amqp_empty_table);
die_on_amqp_error(amqp_get_rpc_reply(this->conn_ptr->_getconn_n()), "Declaring queue");
amqp_bytes_t listen_quque = amqp_bytes_malloc_dup(r->queue);
if (listen_quque.bytes == NULL) {
Log::log.error("Out of memory while copying queue name");
}
char str[listen_quque.len+1];
for(unsigned int i=0;i<listen_quque.len;i++){
str[i]=((char*)listen_quque.bytes)[i];
}
str[listen_quque.len]='\0';
this->queue_name=std::string(str);
}
//binding
amqp_queue_bind(this->conn_ptr->_getconn_n(), this->channel_n,
amqp_cstring_bytes(this->queue_name.c_str()),
amqp_cstring_bytes(this->conn_ptr->getDefaultExchange().c_str()),
amqp_cstring_bytes(routing_key.c_str()),
amqp_empty_table);
die_on_amqp_error(amqp_get_rpc_reply(this->conn_ptr->_getconn_n()), "Binding");
}
bool initAmqp(amqp_connection_state_t &conn, amqp_socket_t *socket, int &status, amqp_bytes_t &queuename) {
conn = amqp_new_connection();
socket = amqp_tcp_socket_new(conn);
if (!socket) {
die("creating TCP socket");
return false;
}
status = amqp_socket_open(socket, hostname, port);
if (status) {
die("opening TCP socket");
return false;
}
if (!die_on_amqp_error(amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, amqp_user, amqp_pass), "Logging in")) {
return false;
};
amqp_channel_open(conn, 1);
if (!die_on_amqp_error(amqp_get_rpc_reply(conn), "Opening channel")) {
return false;
}
// passive 0 durable 1 auto-delete 0 internal 0 exchange
amqp_exchange_declare_ok_t_ *er = amqp_exchange_declare(conn, 1, amqp_cstring_bytes(exchange), amqp_cstring_bytes(exchange_type), 0, 1, 0, 0, amqp_empty_table);
if (!die_on_amqp_error(amqp_get_rpc_reply(conn), "Declaring exchange")) {
return false;
}
// passive 0 durable 1 exclusive 0 auto-delete 0 queue
amqp_queue_declare_ok_t *r = amqp_queue_declare(conn, 1, amqp_cstring_bytes(bindingkey), 0, 1, 0, 0, amqp_empty_table);
if (!die_on_amqp_error(amqp_get_rpc_reply(conn), "Declaring queue")) {
return false;
}
queuename = amqp_bytes_malloc_dup(r->queue);
if (queuename.bytes == NULL) {
fprintf(stderr, "Out of memory while copying queue name");
return false;
}
amqp_queue_bind(conn, 1, queuename, amqp_cstring_bytes(exchange), amqp_cstring_bytes(bindingkey), amqp_empty_table);
if (!die_on_amqp_error(amqp_get_rpc_reply(conn), "Binding queue")) {
return false;
}
// no-local 0 no-ack 0 exclusive 0 consumer
amqp_basic_consume(conn, 1, queuename, amqp_cstring_bytes(consumer_name), 1, 0, 0, amqp_empty_table);
if (!die_on_amqp_error(amqp_get_rpc_reply(conn), "Consuming")) {
return false;
}
return true;
}
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 const *const *argv)
{
char const *hostname;
int port, status;
char const *exchange;
char const *bindingkey;
char const *queue;
amqp_socket_t *socket;
amqp_connection_state_t conn;
if (argc < 6) {
fprintf(stderr, "Usage: amqps_unbind host port exchange bindingkey queue "
"[cacert.pem [key.pem cert.pem]]\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_ssl_socket_new();
if (!socket) {
die("creating SSL/TLS socket");
}
if (argc > 6) {
status = amqp_ssl_socket_set_cacert(socket, argv[6]);
if (status) {
die("setting CA certificate");
}
}
if (argc > 8) {
status = amqp_ssl_socket_set_key(socket, argv[8], argv[7]);
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_queue_unbind(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;
}
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) {
die("creating TCP socket");
}
status = amqp_socket_open(socket, hostname, port);
if (status) {
die("opening TCP 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");
/*
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);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Declaring queue");
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
*/
die_on_error(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
*/
{
amqp_basic_consume(conn, 1, reply_to_queue, amqp_empty_bytes, 0, 1, 0, amqp_empty_table);
die_on_amqp_error(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;
for (;;) {
amqp_maybe_release_buffers(conn);
result = amqp_simple_wait_frame(conn, &frame);
printf("Result: %d\n", result);
if (result < 0) {
break;
}
printf("Frame type: %u channel: %u\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 = (size_t)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;
}
/* everything was fine, we can quit now because we received the reply */
break;
}
}
}
/*
closing
*/
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, status;
char const *exchange;
char const *bindingkey;
amqp_socket_t *socket;
amqp_connection_state_t conn;
amqp_bytes_t queuename;
if (argc < 3) {
fprintf(stderr, "Usage: amqps_consumer host port "
"[cacert.pem [key.pem cert.pem]]\n");
return 1;
}
hostname = argv[1];
port = atoi(argv[2]);
exchange = "amq.direct"; /* argv[3]; */
bindingkey = "test queue"; /* argv[4]; */
conn = amqp_new_connection();
socket = amqp_ssl_socket_new(conn);
if (!socket) {
die("creating SSL/TLS socket");
}
if (argc > 3) {
status = amqp_ssl_socket_set_cacert(socket, argv[3]);
if (status) {
die("setting CA certificate");
}
}
if (argc > 5) {
status = amqp_ssl_socket_set_key(socket, argv[5], argv[4]);
if (status) {
die("setting client key");
}
}
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_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;
}
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;
}
int main(int argc,const char *argv[]) {
const char *hostName;
int port;
const char *queueName;
int prefetchCount;
int noAck = 1;
if (argc < 6) {
fprintf(stderr,"Usage: consumer host port queuename prefetch_count no_ack\n");
exit(1);
}
hostName = argv[1];
port = atoi(argv[2]);
queueName = argv[3];
prefetchCount = atoi(argv[4]);
if(strcmp(argv[5],"false")==0) noAck = 0;
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_basic_qos(conn,channelId,0,prefetchCount,0);
amqp_basic_consume(conn,channelId,amqp_cstring_bytes(queueName),amqp_empty_bytes,0,noAck,0,amqp_empty_table);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Consuming");
int count = 0;
amqp_frame_t frame;
int result;
amqp_basic_deliver_t *d;
amqp_basic_properties_t *p;
size_t body_target;
size_t body_received;
long long start = timeInMilliseconds();
while(1){
{
amqp_maybe_release_buffers(conn);
result = amqp_simple_wait_frame(conn, &frame);
if (result < 0)
break;
if (frame.frame_type != AMQP_FRAME_METHOD)
continue;
if (frame.payload.method.id != AMQP_BASIC_DELIVER_METHOD)
continue;
d = (amqp_basic_deliver_t *) frame.payload.method.decoded;
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;
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);
}
if (body_received != body_target) {
break;
}
if(!noAck)
amqp_basic_ack(conn,channelId,d->delivery_tag,0);
}
count++;
if(count%10000 == 0) {
long long end = timeInMilliseconds();
fprintf(stderr,"round %d takes %lld millseconds(10000 messages consumed every round)\n",count/10000-1,end-start);
start = timeInMilliseconds();
}
}
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 = "amqpbroker"; // amqp hostname
int port = 5672; // amqp port
static int verbose_flag = 0; // be verbose?
static int foreground_flag = 0;
static int passive = 0; // declare queue passively?
static int exclusive = 0; // declare queue as exclusive?
static int durable = 0; // decalre queue as durable?
static int no_ack = 0;
static int msg_limit = 0; // maxiumum number of messages to retrieve
int const no_local = 1; // we never want to see messages we publish
int c; // for option parsing
char const *exchange = "";
char const *bindingkey = "";
char const *vhost = "/";
char const *username = "******";
char const *password = "******";
char const *program = NULL;
char const *program_args = NULL;
amqp_bytes_t queue = AMQP_EMPTY_BYTES;
int sockfd;
amqp_connection_state_t conn;
amqp_bytes_t queuename;
if (NULL != getenv("AMQP_HOST"))
hostname = getenv("AMQP_HOST");
if (NULL != getenv("AMQP_PORT"))
port = atoi(getenv("AMQP_PORT"));
port = port > 0 ? port : 5672; // 5672 is the default amqp port
if (NULL != getenv("AMQP_VHOST"))
vhost = getenv("AMQP_VHOST");
if (NULL != getenv("AMQP_USER"))
username = getenv("AMQP_USER");
if (NULL != getenv("AMQP_PASSWORD"))
password = getenv("AMQP_PASSWORD");
if (NULL != getenv("AMQP_QUEUE"))
queue = amqp_cstring_bytes(getenv("AMQP_QUEUE"));
if (NULL != getenv("AMQP_QUEUE_PASSIVE"))
passive = atoi(getenv("AMQP_QUEUE_PASSIVE"));
if (NULL != getenv("AMQP_QUEUE_EXCLUSIVE"))
exclusive = atoi(getenv("AMQP_QUEUE_EXCLUSIVE"));
if (NULL != getenv("AMQP_QUEUE_DURABLE"))
durable = atoi(getenv("AMQP_QUEUE_DURABLE"));
if (NULL != getenv("AMQP_MSG_LIMIT"))
msg_limit = atoi(getenv("AMQP_MSG_LIMIT"));
msg_limit = msg_limit > 0 ? msg_limit : 0; // default to unlimited
while(1) {
static struct option long_options[] =
{
{"verbose", no_argument, &verbose_flag, 1},
{"user", required_argument, 0, 'u'},
{"password", required_argument, 0, 'p'},
{"vhost", required_argument, 0, 'v'},
{"host", required_argument, 0, 'h'},
{"port", required_argument, 0, 'P'},
{"number", required_argument, 0, 'n'},
{"foreground", no_argument, 0, 'f'},
{"passive", no_argument, &passive, 1},
{"exclusive", no_argument, &exclusive, 1},
{"durable", no_argument, &durable, 1},
{"no-ack", no_argument, &no_ack, 1},
{"execute", required_argument, 0, 'e'},
{"queue", required_argument, 0, 'q'},
{"help", no_argument, 0, '?'},
{0, 0, 0, 0}
};
int option_index = 0;
c = getopt_long(argc, argv, "v:h:P:u:p:n:fe:q:?",
long_options, &option_index);
if(c == -1)
break;
switch(c) {
case 0: // no_argument
break;
case 'v':
vhost = optarg;
break;
case 'h':
hostname = optarg;
break;
case 'P':
port = atoi(optarg);
port = port > 0 ? port : 5672; // 5672 is the default amqp port
break;
case 'f':
foreground_flag = 1;
case 'n':
msg_limit = atoi(optarg);
msg_limit = msg_limit > 0 ? msg_limit : 0; // deafult to unlimited
break;
case 'e':
program = optarg;
break;
case 'u':
username = optarg;
break;
case 'p':
password = optarg;
break;
case 'q':
queue = amqp_cstring_bytes(optarg);
break;
case '?':
default:
print_help(argv[0]);
exit(1);
}
}
if ((argc-optind) < 2) {
print_help(argv[0]);
return 1;
}
exchange = argv[optind];
bindingkey = argv[optind+1];
if (NULL != program) {
// check that the program is executable
char *wend;
wend = strchr(program, ' ');
if(wend){
*wend = '\0';
program_args = wend+1;
}
if (0 != access(program, X_OK)) {
fprintf(stderr, "Program doesn't have execute permission, aborting: %s\n", program);
exit(-1);
}
if(wend){
*wend = ' ';
}
}
if ((passive != 0) && (passive != 1)) {
fprintf(stderr, "Queue option 'passive' must be 0 or 1: %u\n", passive);
exit(-1);
}
if ((exclusive != 0) && (exclusive != 1)) {
fprintf(stderr, "Queue option 'exclusive' must be 0 or 1: %u\n", exclusive);
exit(-1);
}
if ((durable != 0) && (durable != 1)) {
fprintf(stderr, "Queue option 'durable' must be 0 or 1: %u\n", durable);
exit(-1);
}
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, vhost,
0, /* channel_max */
10485760, /* max frame size, 10MB */
30, /* heartbeat, 30 secs */
AMQP_SASL_METHOD_PLAIN,
username, password),
"Logging in");
amqp_channel_open(conn, AMQP_CHANNEL);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Opening channel");
{
int optval = 1;
socklen_t optlen = sizeof(optlen);
setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &optval, optlen);
}
{
amqp_queue_declare_ok_t *r = amqp_queue_declare(conn, AMQP_CHANNEL, queue, passive,
durable, exclusive, 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\n");
return 1;
}
}
amqp_queue_bind(conn, AMQP_CHANNEL, queuename, amqp_cstring_bytes(exchange),
amqp_cstring_bytes(bindingkey), AMQP_EMPTY_TABLE);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Binding queue");
/* Set our prefetch to the maximum number of messages we want to ensure we
* don't take more than we want according to --number option from user */
int prefetch_limit = DEFAULT_PREFETCH;
if (msg_limit > 0 && msg_limit <= 65535)
prefetch_limit = msg_limit;
amqp_basic_qos(conn, AMQP_CHANNEL, 0, prefetch_limit, 0);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Setting Basic QOS (prefetch limit)");
amqp_basic_consume(conn, AMQP_CHANNEL, queuename, AMQP_EMPTY_BYTES, no_local, no_ack, exclusive,
AMQP_EMPTY_TABLE);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Consuming");
// If executing a program, daemonise
if(NULL != program && 0 == foreground_flag)
{
pid_t pid, sid;
pid = fork();
if (pid < 0) {
exit(EXIT_FAILURE);
} else if(pid > 0) {
exit(EXIT_SUCCESS);
}
umask(0);
sid = setsid();
if (sid < 0)
exit(EXIT_FAILURE);
}
{
amqp_frame_t frame;
int result;
int status = 0; /* wait() status, used whether to send ACK */
amqp_basic_deliver_t *d;
amqp_basic_properties_t *p;
size_t body_target;
size_t body_received;
install_term_handler(SIGINT);
install_term_handler(SIGTERM);
install_term_handler(SIGHUP);
int msg_count = 0;
while (1) {
char tempfile[] = "/tmp/amqp.XXXXXX";
int tempfd;
// exit if we've reached our maximum message count
if((0 != msg_limit) && (msg_limit == msg_count))
break;
// we haven't reached our limit; move on to the next
msg_count++;
if(g_shutdown == 1)
break;
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_HEARTBEAT) {
// send the same heartbeat frame back
amqp_send_frame(conn, &frame);
continue;
} else 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;
tempfd = mkstemp(tempfile);
//tempfd = open(tempfile, O_WRONLY | O_CREAT | O_EXCL, 660);
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);
if (write(tempfd, frame.payload.body_fragment.bytes,
frame.payload.body_fragment.len) < 0) {
perror("Error while writing received message to temp file");
}
}
close(tempfd);
{
char *routekey = (char *)calloc(1, d->routing_key.len + 1);
strncpy(routekey, (char *)d->routing_key.bytes, d->routing_key.len);
if(NULL != program) {
// fork and run the program in the background
pid_t pid = fork();
if (pid == 0) {
if(execl(program, program, program_args, routekey, tempfile, NULL) == -1) {
perror("Could not execute program");
exit(EXIT_FAILURE);
}
} else {
status = 0;
wait(&status);
}
} else {
// print to stdout & flush.
printf("%s %s\n", routekey, tempfile);
fflush(stdout);
}
free(routekey);
}
// send ack on successful processing of the frame
if((0 == status) && (0 == no_ack))
amqp_basic_ack(conn, frame.channel, d->delivery_tag, 0);
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, AMQP_CHANNEL, 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 amqpsend(const char *msg) {
int amqp_channel = 1; // TODO: handle dynamic channel number
int status;
amqp_socket_t *socket = NULL;
amqp_connection_state_t conn;
amqp_bytes_t messagebody;
// build the message body
messagebody = amqp_cstring_bytes(msg);
// open a connection to the server
debug_print(2, "Connecting to AMQP Broker");
conn = amqp_new_connection();
socket = amqp_tcp_socket_new(conn);
if (!socket) {
debug_print(2, "ERROR creating TCP socket");
return 1;
}
status = amqp_socket_open(socket, amqp_hostname, amqp_port);
if (status) {
debug_print(2, "ERROR opening TCP socket");
return 1;
}
// authenticate
debug_print(2, "Authenticating");
die_on_amqp_error(
amqp_login(
conn, amqp_vhost, 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, amqp_username, amqp_password
),
"Authenticating");
// open a channel
debug_print(3, "Opening a channel");
amqp_channel_open(conn, amqp_channel);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Opening channel");
// build the message frame
debug_print(3, "Building AMQP Message Frame");
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 = AMQP_PERSISTENT;
// send the message frame
debug_print(2, "Publishing message to exchange/routing key");
debug_print(2, amqp_exchange);
debug_print(2, amqp_routingkey);
die_on_error(amqp_basic_publish(conn,
amqp_channel,
amqp_cstring_bytes(amqp_exchange),
amqp_cstring_bytes(amqp_routingkey),
0,
0,
&props,
messagebody),
"Sending message");
// cleanup by closing all our connections
debug_print(4, "Cleaning up AMQP Connection");
//debug_print(5, "Closing connection");
//die_on_amqp_error(
// amqp_connection_close(conn, AMQP_REPLY_SUCCESS),
// "Closing connection");
debug_print(5, "Ending connection");
die_on_error(
amqp_destroy_connection(conn),
"Ending connection");
return 0;
}
void closeAmqp(amqp_connection_state_t &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");
}
int main(int argc, char const *const *argv)
{
char const nofile[2] = "-";
char const *hostname;
int port, status;
amqp_socket_t *socket;
amqp_connection_state_t conn;
struct timeval *tv;
if (argc < 3) {
fprintf(stderr, "Usage: amqps_connect_timeout host port "
"[cacert.pem [key.pem cert.pem [timeout_sec [timeout_usec=0]]]]\n");
return 1;
}
hostname = argv[1];
port = atoi(argv[2]);
if (argc > 6) {
tv = malloc(sizeof(struct timeval));
tv->tv_sec = atoi(argv[6]);
if (argc > 7 ) {
tv->tv_usec = atoi(argv[7]);
} else {
tv->tv_usec = 0;
}
} else {
tv = NULL;
}
conn = amqp_new_connection();
socket = amqp_ssl_socket_new(conn);
if (!socket) {
die("creating SSL/TLS socket");
}
if (argc > 3 && strcmp(nofile, argv[3])) {
die_on_error(amqp_ssl_socket_set_cacert(socket, argv[3]), "setting CA certificate");
}
if (argc > 5) {
if (!strcmp(nofile, argv[5]) && !strcmp(nofile, argv[4])) {
status = 0;
} else if (!strcmp(nofile, argv[5]) || !strcmp(nofile, argv[4])) {
status = -1;
} else {
status = amqp_ssl_socket_set_key(socket, argv[5], argv[4]);
}
if (status) {
die("setting client key");
}
}
die_on_error(amqp_socket_open_noblock(socket, hostname, port, tv), "opening SSL/TLS connection");
die_on_amqp_error(amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, "guest", "guest"),
"Logging in");
die_on_amqp_error(amqp_connection_close(conn, AMQP_REPLY_SUCCESS), "Closing connection");
die_on_error(amqp_destroy_connection(conn), "Ending connection");
printf ("Done\n");
return 0;
}
static
void rabbitmq_add_queue(amqp_connection_state_t conn, amqp_channel_t* channel_ref, const char *stream)
{
size_t n = strlen(stream) + 1;
char app[n], env[n];
memset(app, 0, n);
memset(env, 0, n);
sscanf(stream, "%[^-]-%[^-]", app, env);
if (strcmp(env, rabbit_env)) {
printf("[I] skipping: %s-%s\n", app, env);
return;
}
// printf("[D] processing stream %s-%s\n", app, env);
char exchange[n+16];
memset(exchange, 0, n+16);
sprintf(exchange, "request-stream-%s-%s", app, env);
// printf("[D] exchange: %s\n", exchange);
char queue[n+15];
memset(queue, 0, n+15);
sprintf(queue, "logjam-device-%s-%s", app, env);
// printf("[D] queue: %s\n", queue);
printf("[I] binding: %s ==> %s\n", exchange, queue);
amqp_channel_t channel = ++(*channel_ref);
if (channel > 1) {
// printf("[D] opening channel %d\n", channel);
amqp_channel_open(conn, channel);
die_on_amqp_error(amqp_get_rpc_reply(conn), "Opening AMQP channel");
}
// amqp_exchange_declare(amqp_connection_state_t state, amqp_channel_t channel, amqp_bytes_t exchange,
// amqp_bytes_t type, amqp_boolean_t passive, amqp_boolean_t durable,
// amqp_boolean_t auto_delete, amqp_boolean_t internal, amqp_table_t arguments);
amqp_exchange_declare(conn, channel, amqp_cstring_bytes(exchange), amqp_cstring_bytes("topic"),
0, 1, 0, 0, amqp_empty_table);
die_on_amqp_error(amqp_get_rpc_reply(conn), "declaring exchange");
amqp_bytes_t queuename = amqp_cstring_bytes(queue);
struct amqp_table_entry_t_ queue_arg_table_entries[1] = {
{ amqp_cstring_bytes("x-message-ttl"), { AMQP_FIELD_KIND_I32, { 60 * 1000 } } }
};
amqp_table_t queue_argument_table = {1, queue_arg_table_entries};
// amqp_queue_declare(amqp_connection_state_t state, amqp_channel_t channel, amqp_bytes_t queue,
// amqp_boolean_t passive, amqp_boolean_t durable, amqp_boolean_t exclusive, amqp_boolean_t auto_delete,
// amqp_table_t arguments);
amqp_queue_declare(conn, channel, queuename, 0, 0, 0, 1, queue_argument_table);
die_on_amqp_error(amqp_get_rpc_reply(conn), "declaring queue");
// amqp_queue_bind(amqp_connection_state_t state, amqp_channel_t channel, amqp_bytes_t queue,
// amqp_bytes_t exchange, amqp_bytes_t routing_key, amqp_table_t arguments)
const char *routing_key = "#";
amqp_queue_bind(conn, channel, queuename, amqp_cstring_bytes(exchange), amqp_cstring_bytes(routing_key), amqp_empty_table);
die_on_amqp_error(amqp_get_rpc_reply(conn), "binding queue");
// amqp_basic_consume(amqp_connection_state_t state, amqp_channel_t channel, amqp_bytes_t queue, amqp_bytes_t consumer_tag,
// amqp_boolean_t no_local, amqp_boolean_t no_ack, amqp_boolean_t exclusive, amqp_table_t arguments)
amqp_basic_consume(conn, channel, queuename, amqp_empty_bytes, 0, 1, 0, amqp_empty_table);
die_on_amqp_error(amqp_get_rpc_reply(conn), "consuming");
}
int main(int argc, char const *const *argv) {
struct sockaddr_in si_me, si_other;
int s, i, slen = sizeof(si_other) , recv_len;
char buf[BUFLEN];
if ((s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
died("socket");
}
memset((char *) &si_me, 0, sizeof(si_me));
si_me.sin_family = AF_INET;
si_me.sin_port = htons(PORT);
si_me.sin_addr.s_addr = htonl(INADDR_ANY);
//bind socket to port
if( bind(s , (struct sockaddr*)&si_me, sizeof(si_me) ) == -1) {
died("bind");
}
if (argc < 2) {
fprintf(stderr, "Usage: udp_producer host port\n");
return 1;
}
char const *hostname;
int port;
hostname = argv[1];
port = atoi(argv[2]);
// amqp
// char const *hostname = "localhost"; int port = 5674;
int status;
amqp_socket_t *socket = NULL;
amqp_connection_state_t conn;
conn = amqp_new_connection();
socket = amqp_tcp_socket_new(conn);
if (!socket) {
died("creating TCP socket");
}
status = amqp_socket_open(socket, hostname, port);
if (status) {
died("opening TCP 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");
while(1) {
if ((recv_len = recvfrom(s, buf, BUFLEN, 0, (struct sockaddr *) &si_other, &slen)) == -1) {
died("recvfrom()");
}
amqp_bytes_t message_bytes;
message_bytes.len = sizeof(buf);
message_bytes.bytes = buf;
die_on_error(amqp_basic_publish(conn, 1,
amqp_cstring_bytes("udp"),
amqp_cstring_bytes("udp"),
0, 0,NULL, message_bytes),"Publishing");
}
close(s);
return 0;
}
int main(int argc, char const *const *argv)
{
char const *hostname;
int port;
int timeout;
amqp_socket_t *socket;
amqp_connection_state_t conn;
struct timeval tval;
struct timeval *tv;
if (argc < 3) {
fprintf(
stderr,
"Usage: amqps_connect_timeout host port timeout_sec "
"[cacert.pem [verifypeer] [verifyhostname] [key.pem cert.pem]]\n");
return 1;
}
hostname = argv[1];
port = atoi(argv[2]);
timeout = atoi(argv[3]);
if (timeout > 0) {
tv = &tval;
tv->tv_sec = timeout;
tv->tv_usec = 0;
} else {
tv = NULL;
}
conn = amqp_new_connection();
socket = amqp_ssl_socket_new(conn);
if (!socket) {
die("creating SSL/TLS socket");
}
amqp_ssl_socket_set_verify_peer(socket, 0);
amqp_ssl_socket_set_verify_hostname(socket, 0);
if (argc > 5) {
int nextarg = 6;
die_on_error(amqp_ssl_socket_set_cacert(socket, argv[5]),
"setting CA certificate");
if (argc > nextarg && !strcmp("verifypeer", argv[nextarg])) {
amqp_ssl_socket_set_verify_peer(socket, 1);
nextarg++;
}
if (argc > nextarg && !strcmp("verifyhostname", argv[nextarg])) {
amqp_ssl_socket_set_verify_hostname(socket, 1);
nextarg++;
}
if (argc > nextarg + 1) {
die_on_error(
amqp_ssl_socket_set_key(socket, argv[nextarg + 1], argv[nextarg]),
"setting client key");
}
}
die_on_error(amqp_socket_open_noblock(socket, hostname, port, tv), "opening SSL/TLS connection");
die_on_amqp_error(amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, "guest", "guest"),
"Logging in");
die_on_amqp_error(amqp_connection_close(conn, AMQP_REPLY_SUCCESS), "Closing connection");
die_on_error(amqp_destroy_connection(conn), "Ending connection");
printf ("Done\n");
return 0;
}
int main(int argc, char const *const *argv)
{
char const *hostname;
int port, status;
char const *exchange;
char const *bindingkey;
amqp_socket_t *socket = NULL;
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();
socket = amqp_tcp_socket_new(conn);
if (!socket) {
die("creating TCP socket");
}
status = amqp_socket_open(socket, hostname, port);
if (status) {
die("opening TCP 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_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");
{
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) {
break;
}
printf("Delivery %u, exchange %.*s routingkey %.*s\n",
(unsigned) envelope.delivery_tag,
(int) envelope.exchange.len, (char *) envelope.exchange.bytes,
(int) envelope.routing_key.len, (char *) envelope.routing_key.bytes);
if (envelope.message.properties._flags & AMQP_BASIC_CONTENT_TYPE_FLAG) {
printf("Content-type: %.*s\n",
(int) envelope.message.properties.content_type.len,
(char *) envelope.message.properties.content_type.bytes);
}
amqp_destroy_envelope(&envelope);
}
}
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;
}
Channel::~Channel(){
die_on_amqp_error(amqp_channel_close(this->conn_ptr->_getconn_n(),
channel_n, AMQP_REPLY_SUCCESS), "Closing channel");
}
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 const *const *argv )
{
if ( argc != 3 )
{
printf ( "usage: %s CFG_FILE LOG_FILE\n", argv[0] );
return -1;
}
const char *log_filename = argv[2];
int flags = O_CREAT | O_APPEND | O_RDWR;
mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
int log_fd = open ( log_filename, flags, mode );
if ( log_fd < 0 )
{
fprintf ( stderr, "ERROR: Falied to open the log file '%s'\n", log_filename );
exit ( 1 );
}
/* Read the configuration file. */
struct lcfg *cfg = lcfg_new ( argv[1] );
if ( lcfg_parse ( cfg ) != lcfg_status_ok )
{
printf ( "lcfg error: %s\n", lcfg_error_get ( cfg ) );
return -1;
}
/* Read all the configuration parameters. */
fprintf ( stdout, "Starting Murano agent with the following configuration:\n\n" );
const char *host = get_config_value ( cfg, "RABBITMQ_HOST" , 1 );
int port = atoi ( get_config_value ( cfg, "RABBITMQ_PORT" , 1 ) );
const char *vhost = get_config_value ( cfg, "RABBITMQ_VHOST" , 1 );
const char *username = get_config_value ( cfg, "RABBITMQ_USERNAME" , 1 );
const char *password = get_config_value ( cfg, "RABBITMQ_PASSWORD" , 1 );
const char *queuename = get_config_value ( cfg, "RABBITMQ_INPUT_QUEUE" , 1 );
const char *result_routing_key = get_config_value ( cfg, "RABBITMQ_RESULT_ROUTING_KEY", 1 );
amqp_connection_state_t conn = amqp_new_connection();
amqp_socket_t *socket = NULL;
amqp_bytes_t queuename_bytes = amqp_cstring_bytes ( queuename );
socket = amqp_tcp_socket_new ( conn );
if ( !socket )
{
die ( "creating TCP socket" );
}
if ( amqp_socket_open ( socket, host, port ) )
{
die ( "opening TCP socket" );
}
die_on_amqp_error ( amqp_login ( conn, vhost, 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, username, password ),
"Logging in" );
amqp_channel_open ( conn, 1 );
die_on_amqp_error ( amqp_get_rpc_reply ( conn ), "Opening channel" );
amqp_basic_consume ( conn, 1, queuename_bytes, amqp_empty_bytes, 0, 1, 0, amqp_empty_table );
die_on_amqp_error ( amqp_get_rpc_reply ( conn ), "Consuming" );
puts ( "\nSuccessfully connected to Rabbit MQ server! Ready for messages..." );
run ( conn, log_fd , result_routing_key );
close ( log_fd );
lcfg_delete ( cfg );
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;
}