/*
* Initialize RabbitMQ connection
*/
static rsRetVal
initRabbitMQ(instanceData *pData)
{
int sockfd;
DEFiRet;
DBGPRINTF("omrabbitmq: trying connect to '%s' at port %d\n", pData->host, pData->port);
pData->conn = amqp_new_connection();
if (die_on_error(sockfd = amqp_open_socket((char*) pData->host, pData->port), "Opening socket")) {
pData->conn = NULL;
ABORT_FINALIZE(RS_RET_SUSPENDED);
}
amqp_set_sockfd(pData->conn, sockfd);
if (die_on_amqp_error(amqp_login(pData->conn, (char*) pData->vhost, 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, pData->user, pData->password),
"Logging in")) {
pData->conn = NULL;
ABORT_FINALIZE(RS_RET_SUSPENDED);
}
amqp_channel_open(pData->conn, 1);
if (die_on_amqp_error(amqp_get_rpc_reply(pData->conn), "Opening channel")) {
pData->conn = NULL;
ABORT_FINALIZE(RS_RET_SUSPENDED);
}
finalize_it:
RETiRet;
}
int
amqp_link(struct amqp_state_t *amqp)
{
amqp_rpc_reply_t r;
amqp->props._flags =
AMQP_BASIC_CONTENT_TYPE_FLAG | AMQP_BASIC_DELIVERY_MODE_FLAG;
amqp->props.delivery_mode = 2;
amqp->props.content_type =
amqp_cstring_bytes("application/octet-stream");
amqp->conn = amqp_new_connection();
cfg.amqp.fd = amqp_open_socket(cfg.amqp.host, cfg.amqp.port);
if (cfg.amqp.fd < 0) {
LOG("unable to open amqp socket!\n");
return(-1);
}
amqp_set_sockfd(amqp->conn, cfg.amqp.fd);
r = amqp_login(amqp->conn, cfg.amqp.vhost, 0, 131072, 0,
AMQP_SASL_METHOD_PLAIN, cfg.amqp.user, cfg.amqp.pass);
if (r.reply_type != AMQP_RESPONSE_NORMAL) {
LOG("problem logging in amqp broker\n");
return(-1);
}
amqp_channel_open(amqp->conn, 1);
r = amqp_get_rpc_reply(amqp->conn);
if (r.reply_type != AMQP_RESPONSE_NORMAL) {
LOG("problem opening amqp channel\n");
return(-1);
}
return(0);
}
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;
}
Channel::Channel(const std::string& host,
int port,
const std::string& username,
const std::string& password,
const std::string& vhost,
int frame_max) :
m_impl(new Detail::ChannelImpl)
{
m_impl->m_connection = amqp_new_connection();
if (NULL == m_impl->m_connection)
{
throw std::bad_alloc();
}
try
{
int sock = amqp_open_socket(host.c_str(), port);
m_impl->CheckForError(sock);
amqp_set_sockfd(m_impl->m_connection, sock);
m_impl->CheckRpcReply(0, amqp_login(m_impl->m_connection, vhost.c_str(), 0,
frame_max, BROKER_HEARTBEAT, AMQP_SASL_METHOD_PLAIN,
username.c_str(), password.c_str()));
}
catch (...)
{
amqp_destroy_connection(m_impl->m_connection);
throw;
}
m_impl->SetIsConnected(true);
}
amqp_connection_state_t make_connection(void)
{
int s;
struct amqp_connection_info ci;
amqp_connection_state_t conn;
init_connection_info(&ci);
s = amqp_open_socket(ci.host, ci.port);
die_amqp_error(s, "opening socket to %s:%d", ci.host, ci.port);
conn = amqp_new_connection();
amqp_set_sockfd(conn, s);
die_rpc(amqp_login(conn, ci.vhost, 0, 131072, 0,
AMQP_SASL_METHOD_PLAIN,
ci.user, ci.password),
"logging in to AMQP server");
if (!amqp_channel_open(conn, 1)) {
die_rpc(amqp_get_rpc_reply(conn), "opening channel");
}
return conn;
}
static int noit_rabbimq_connect(iep_thread_driver_t *dr) {
struct amqp_driver *driver = (struct amqp_driver *)dr;
if(!driver->connection) {
int sidx = driver->nconnects++ % driver->nhosts;
struct timeval timeout;
amqp_rpc_reply_t r, *rptr;
mtevL(mtev_error, "AMQP connect: %s:%d\n",
driver->hostname[sidx], driver->port);
BUMPSTAT(connects);
driver->hostidx = sidx;
timeout.tv_sec = driver->heartbeat;
timeout.tv_usec = 0;
driver->sockfd = amqp_open_socket(driver->hostname[sidx], driver->port, &timeout);
if(driver->sockfd < 0) {
mtevL(mtev_error, "AMQP connect failed: %s:%d\n",
driver->hostname[sidx], driver->port);
return -1;
}
if(setsockopt(driver->sockfd, SOL_SOCKET, SO_SNDBUF, &desired_sndbuf, sizeof(desired_sndbuf)) < 0)
mtevL(mtev_debug, "rabbitmq: setsockopt(SO_SNDBUF, %ld) -> %s\n", (long int)desired_sndbuf, strerror(errno));
if(setsockopt(driver->sockfd, SOL_SOCKET, SO_RCVBUF, &desired_rcvbuf, sizeof(desired_rcvbuf)) < 0)
mtevL(mtev_debug, "rabbitmq: setsockopt(SO_RCVBUF, %ld) -> %s\n", (long int)desired_rcvbuf, strerror(errno));
driver->has_error = 0;
driver->connection = amqp_new_connection();
amqp_set_basic_return_cb(driver->connection, noit_rabbitmq_brcb, driver);
amqp_set_sockfd(driver->connection, driver->sockfd);
r = amqp_login(driver->connection,
driver->vhost, 0, 131072, driver->heartbeat,
AMQP_SASL_METHOD_PLAIN,
driver->username, driver->password);
if(r.reply_type != AMQP_RESPONSE_NORMAL) {
mtevL(mtev_error, "AMQP login failed\n");
amqp_connection_close(driver->connection, AMQP_REPLY_SUCCESS);
amqp_destroy_connection(driver->connection);
if(driver->sockfd >= 0) close(driver->sockfd);
driver->sockfd = -1;
driver->connection = NULL;
return -1;
}
amqp_channel_open(driver->connection, 1);
rptr = amqp_get_rpc_reply();
if(rptr->reply_type != AMQP_RESPONSE_NORMAL) {
mtevL(mtev_error, "AMQP channe_open failed\n");
amqp_connection_close(driver->connection, AMQP_REPLY_SUCCESS);
amqp_destroy_connection(driver->connection);
if(driver->sockfd >= 0) close(driver->sockfd);
driver->sockfd = -1;
driver->connection = NULL;
return -1;
}
mtev_gettimeofday(&driver->last_hb, NULL);
return 0;
}
/* 1 means already connected */
return 1;
}
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;
}
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;
}
void AMQP::sockConnect() {
cnn = amqp_new_connection();
sockfd = amqp_open_socket(host.c_str(), port);
if (sockfd<0)
throw AMQPException::AMQPException("AMQP cannot create socket descriptor");
//cout << "sockfd="<< sockfd << " pid=" << getpid() <<endl;
amqp_set_sockfd(cnn, sockfd);
}
static gboolean
afamqp_dd_connect(AMQPDestDriver *self, gboolean reconnect)
{
int sockfd;
amqp_rpc_reply_t ret;
if (reconnect && self->conn)
{
ret = amqp_get_rpc_reply(self->conn);
if (ret.reply_type == AMQP_RESPONSE_NORMAL)
return TRUE;
}
self->conn = amqp_new_connection();
sockfd = amqp_open_socket(self->host, self->port);
if (sockfd < 0)
{
gchar *errstr = amqp_error_string(-sockfd);
msg_error("Error connecting to AMQP server",
evt_tag_str("driver", self->super.super.super.id),
evt_tag_str("error", errstr),
evt_tag_int("time_reopen", self->super.time_reopen),
NULL);
g_free(errstr);
return FALSE;
}
amqp_set_sockfd(self->conn, sockfd);
ret = amqp_login(self->conn, self->vhost, 0, 131072, 0,
AMQP_SASL_METHOD_PLAIN, self->user, self->password);
if (!afamqp_is_ok(self, "Error during AMQP login", ret))
return FALSE;
amqp_channel_open(self->conn, 1);
ret = amqp_get_rpc_reply(self->conn);
if (!afamqp_is_ok(self, "Error during AMQP channel open", ret))
return FALSE;
if (self->declare)
{
amqp_exchange_declare(self->conn, 1, amqp_cstring_bytes(self->exchange),
amqp_cstring_bytes(self->exchange_type), 0, 0,
amqp_empty_table);
ret = amqp_get_rpc_reply(self->conn);
if (!afamqp_is_ok(self, "Error during AMQP exchange declaration", ret))
return FALSE;
}
msg_debug ("Connecting to AMQP succeeded",
evt_tag_str("driver", self->super.super.super.id),
NULL);
return TRUE;
}
static int noit_rabbimq_connect(iep_thread_driver_t *dr) {
struct amqp_driver *driver = (struct amqp_driver *)dr;
if(!driver->connection) {
int sidx = driver->nconnects++ % driver->nhosts;
struct timeval timeout;
amqp_rpc_reply_t r, *rptr;
noitL(noit_error, "AMQP connect: %s:%d\n",
driver->hostname[sidx], driver->port);
BUMPSTAT(connects);
driver->hostidx = sidx;
timeout.tv_sec = driver->heartbeat;
timeout.tv_usec = 0;
driver->sockfd = amqp_open_socket(driver->hostname[sidx], driver->port, &timeout);
if(driver->sockfd < 0) {
noitL(noit_error, "AMQP connect failed: %s:%d\n",
driver->hostname[sidx], driver->port);
return -1;
}
driver->has_error = 0;
driver->connection = amqp_new_connection();
amqp_set_basic_return_cb(driver->connection, noit_rabbitmq_brcb, driver);
amqp_set_sockfd(driver->connection, driver->sockfd);
r = amqp_login(driver->connection,
driver->vhost, 0, 131072, driver->heartbeat,
AMQP_SASL_METHOD_PLAIN,
driver->username, driver->password);
if(r.reply_type != AMQP_RESPONSE_NORMAL) {
noitL(noit_error, "AMQP login failed\n");
amqp_connection_close(driver->connection, AMQP_REPLY_SUCCESS);
amqp_destroy_connection(driver->connection);
driver->connection = NULL;
return -1;
}
amqp_channel_open(driver->connection, 1);
rptr = amqp_get_rpc_reply();
if(rptr->reply_type != AMQP_RESPONSE_NORMAL) {
noitL(noit_error, "AMQP channe_open failed\n");
amqp_connection_close(driver->connection, AMQP_REPLY_SUCCESS);
amqp_destroy_connection(driver->connection);
driver->connection = NULL;
return -1;
}
gettimeofday(&driver->last_hb, NULL);
return 0;
}
/* 1 means already connected */
return 1;
}
/**
* php_amqp_connect
* handles connecting to amqp
* called by connect() and reconnect()
*/
void php_amqp_connect(amqp_connection_object *amqp_connection)
{
char str[256];
char ** pstr = (char **) &str;
void * old_handler;
/* create the connection */
amqp_connection->conn = amqp_new_connection();
amqp_connection->fd = amqp_open_socket(amqp_connection->host, amqp_connection->port);
if (amqp_connection->fd < 1) {
/* Start ignoring SIGPIPE */
old_handler = signal(SIGPIPE, SIG_IGN);
amqp_destroy_connection(amqp_connection->conn);
/* End ignoring of SIGPIPEs */
signal(SIGPIPE, old_handler);
zend_throw_exception(amqp_connection_exception_class_entry, "Socket error: could not connect to host.", 0 TSRMLS_CC);
return;
}
amqp_connection->is_connected = '\1';
amqp_set_sockfd(amqp_connection->conn, amqp_connection->fd);
amqp_rpc_reply_t x = amqp_login(amqp_connection->conn, amqp_connection->vhost, 0, FRAME_MAX, AMQP_HEARTBEAT, AMQP_SASL_METHOD_PLAIN, amqp_connection->login, amqp_connection->password);
if (x.reply_type != AMQP_RESPONSE_NORMAL) {
amqp_error(x, pstr);
zend_throw_exception(amqp_connection_exception_class_entry, *pstr, 0 TSRMLS_CC);
return;
}
amqp_channel_open(amqp_connection->conn, AMQP_CHANNEL);
x = amqp_get_rpc_reply(amqp_connection->conn);
if (x.reply_type != AMQP_RESPONSE_NORMAL) {
amqp_error(x, pstr);
zend_throw_exception(amqp_connection_exception_class_entry, *pstr, 0 TSRMLS_CC);
return;
}
amqp_connection->is_channel_connected = '\1';
}
static int rmq_reconnect(evi_reply_sock *sock)
{
rmq_params_t * rmqp = (rmq_params_t *)sock->params;
if (!rmqp || !(rmqp->flags & RMQ_PARAM_EXCH)) {
LM_ERR("not enough socket info\n");
return -1;
}
// rmq_print(sock);
if (!(rmqp->flags & RMQ_PARAM_CONN) || !rmqp->conn) {
/* init new connection */
if (!(rmqp->conn = amqp_new_connection())) {
LM_ERR("cannot create new connection\n");
return -1;
}
rmqp->flags |= RMQ_PARAM_CONN;
rmqp->sock = amqp_open_socket(sock->address.s, sock->port);
if (rmqp->sock < 0) {
LM_ERR("cannot opens socket\n");
goto destroy_rmqp;
}
amqp_set_sockfd(rmqp->conn, rmqp->sock);
if (rmq_error("Logging in", amqp_login(rmqp->conn,
RMQ_DEFAULT_VHOST,
0,
RMQ_DEFAULT_MAX,
0,
AMQP_SASL_METHOD_PLAIN,
rmqp->flags & RMQ_PARAM_USER ? rmqp->user.s : RMQ_DEFAULT_UP,
rmqp->flags & RMQ_PARAM_PASS ? rmqp->pass.s : RMQ_DEFAULT_UP)))
goto destroy_rmqp;
}
if (!(rmqp->flags & RMQ_PARAM_CHAN)) {
rmqp->channel = 1;
amqp_channel_open(rmqp->conn, rmqp->channel);
rmqp->flags |= RMQ_PARAM_CHAN;
if (rmq_error("Opening channel", amqp_get_rpc_reply(rmqp->conn)))
goto destroy_rmqp;
}
return 0;
destroy_rmqp:
rmq_destroy_param(rmqp);
return -1;
}
int main(int argc, char const * const *argv) {
char const *hostname;
int port;
char const *exchange;
char const *bindingkey;
char const *queue;
int sockfd;
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();
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_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;
}
static int camqp_connect (camqp_config_t *conf) /* {{{ */
{
amqp_rpc_reply_t reply;
int sockfd;
int status;
if (conf->connection != NULL)
return (0);
conf->connection = amqp_new_connection ();
if (conf->connection == NULL)
{
ERROR ("amqp plugin: amqp_new_connection failed.");
return (ENOMEM);
}
sockfd = amqp_open_socket (CONF(conf, host), conf->port);
if (sockfd < 0)
{
char errbuf[1024];
status = (-1) * sockfd;
ERROR ("amqp plugin: amqp_open_socket failed: %s",
sstrerror (status, errbuf, sizeof (errbuf)));
amqp_destroy_connection (conf->connection);
conf->connection = NULL;
return (status);
}
amqp_set_sockfd (conf->connection, sockfd);
reply = amqp_login (conf->connection, CONF(conf, vhost),
/* channel max = */ 0,
/* frame max = */ 131072,
/* heartbeat = */ 0,
/* authentication = */ AMQP_SASL_METHOD_PLAIN,
CONF(conf, user), CONF(conf, password));
if (reply.reply_type != AMQP_RESPONSE_NORMAL)
{
ERROR ("amqp plugin: amqp_login (vhost = %s, user = %s) failed.",
CONF(conf, vhost), CONF(conf, user));
amqp_destroy_connection (conf->connection);
close (sockfd);
conf->connection = NULL;
return (1);
}
amqp_channel_open (conf->connection, /* channel = */ 1);
/* FIXME: Is checking "reply.reply_type" really correct here? How does
* it get set? --octo */
if (reply.reply_type != AMQP_RESPONSE_NORMAL)
{
ERROR ("amqp plugin: amqp_channel_open failed.");
amqp_connection_close (conf->connection, AMQP_REPLY_SUCCESS);
amqp_destroy_connection (conf->connection);
close(sockfd);
conf->connection = NULL;
return (1);
}
INFO ("amqp plugin: Successfully opened connection to vhost \"%s\" "
"on %s:%i.", CONF(conf, vhost), CONF(conf, host), conf->port);
status = camqp_create_exchange (conf);
if (status != 0)
return (status);
if (!conf->publish)
return (camqp_setup_queue (conf));
return (0);
} /* }}} int camqp_connect */
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, 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;
}
static int camqp_connect (camqp_config_t *conf) /* {{{ */
{
static time_t last_connect_time = 0;
amqp_rpc_reply_t reply;
int status;
#ifdef HAVE_AMQP_TCP_SOCKET
amqp_socket_t *socket;
#else
int sockfd;
#endif
if (conf->connection != NULL)
return (0);
time_t now = time(NULL);
if (now < (last_connect_time + conf->connection_retry_delay))
{
DEBUG("amqp plugin: skipping connection retry, "
"ConnectionRetryDelay: %d", conf->connection_retry_delay);
return(1);
}
else
{
DEBUG ("amqp plugin: retrying connection");
last_connect_time = now;
}
conf->connection = amqp_new_connection ();
if (conf->connection == NULL)
{
ERROR ("amqp plugin: amqp_new_connection failed.");
return (ENOMEM);
}
#ifdef HAVE_AMQP_TCP_SOCKET
# define CLOSE_SOCKET() /* amqp_destroy_connection() closes the socket for us */
/* TODO: add support for SSL using amqp_ssl_socket_new
* and related functions */
socket = amqp_tcp_socket_new (conf->connection);
if (! socket)
{
ERROR ("amqp plugin: amqp_tcp_socket_new failed.");
amqp_destroy_connection (conf->connection);
conf->connection = NULL;
return (ENOMEM);
}
status = amqp_socket_open (socket, CONF(conf, host), conf->port);
if (status < 0)
{
char errbuf[1024];
status *= -1;
ERROR ("amqp plugin: amqp_socket_open failed: %s",
sstrerror (status, errbuf, sizeof (errbuf)));
amqp_destroy_connection (conf->connection);
conf->connection = NULL;
return (status);
}
#else /* HAVE_AMQP_TCP_SOCKET */
# define CLOSE_SOCKET() close(sockfd)
/* this interface is deprecated as of rabbitmq-c 0.4 */
sockfd = amqp_open_socket (CONF(conf, host), conf->port);
if (sockfd < 0)
{
char errbuf[1024];
status = (-1) * sockfd;
ERROR ("amqp plugin: amqp_open_socket failed: %s",
sstrerror (status, errbuf, sizeof (errbuf)));
amqp_destroy_connection (conf->connection);
conf->connection = NULL;
return (status);
}
amqp_set_sockfd (conf->connection, sockfd);
#endif
reply = amqp_login (conf->connection, CONF(conf, vhost),
/* channel max = */ 0,
/* frame max = */ 131072,
/* heartbeat = */ 0,
/* authentication = */ AMQP_SASL_METHOD_PLAIN,
CONF(conf, user), CONF(conf, password));
if (reply.reply_type != AMQP_RESPONSE_NORMAL)
{
ERROR ("amqp plugin: amqp_login (vhost = %s, user = %s) failed.",
CONF(conf, vhost), CONF(conf, user));
amqp_destroy_connection (conf->connection);
CLOSE_SOCKET ();
conf->connection = NULL;
return (1);
}
amqp_channel_open (conf->connection, /* channel = */ 1);
/* FIXME: Is checking "reply.reply_type" really correct here? How does
* it get set? --octo */
if (reply.reply_type != AMQP_RESPONSE_NORMAL)
{
ERROR ("amqp plugin: amqp_channel_open failed.");
amqp_connection_close (conf->connection, AMQP_REPLY_SUCCESS);
amqp_destroy_connection (conf->connection);
CLOSE_SOCKET ();
conf->connection = NULL;
return (1);
}
INFO ("amqp plugin: Successfully opened connection to vhost \"%s\" "
"on %s:%i.", CONF(conf, vhost), CONF(conf, host), conf->port);
status = camqp_create_exchange (conf);
if (status != 0)
return (status);
if (!conf->publish)
return (camqp_setup_queue (conf));
return (0);
} /* }}} int camqp_connect */
static int rmq_reconnect(evi_reply_sock *sock)
{
rmq_params_t * rmqp = (rmq_params_t *)sock->params;
#if defined AMQP_VERSION_v04
amqp_socket_t *amqp_sock;
#endif
int socket;
if (!rmqp || !(rmqp->flags & RMQ_PARAM_RKEY)) {
LM_ERR("not enough socket info\n");
return -1;
}
if (!(rmqp->flags & RMQ_PARAM_CONN) || !rmqp->conn) {
/* init new connection */
if (!(rmqp->conn = amqp_new_connection())) {
LM_ERR("cannot create new connection\n");
return -1;
}
rmqp->flags |= RMQ_PARAM_CONN;
#if defined AMQP_VERSION_v04
amqp_sock = amqp_tcp_socket_new(rmqp->conn);
if (!amqp_sock) {
LM_ERR("cannot create AMQP socket\n");
goto destroy_rmqp;
}
socket = amqp_socket_open(amqp_sock, sock->address.s, sock->port);
if (socket < 0) {
LM_ERR("cannot open AMQP socket\n");
goto destroy_rmqp;
}
#else
socket = amqp_open_socket(sock->address.s, sock->port);
if (socket < 0) {
LM_ERR("cannot open AMQP socket\n");
goto destroy_rmqp;
}
amqp_set_sockfd(rmqp->conn, socket);
#endif
if (rmq_error("Logging in", amqp_login(
rmqp->conn,
RMQ_DEFAULT_VHOST,
0,
RMQ_DEFAULT_MAX,
rmqp->heartbeat,
AMQP_SASL_METHOD_PLAIN,
rmqp->flags & RMQ_PARAM_USER ? rmqp->user.s : RMQ_DEFAULT_UP,
rmqp->flags & RMQ_PARAM_PASS ? rmqp->pass.s : RMQ_DEFAULT_UP)))
goto destroy_rmqp;
}
if (!(rmqp->flags & RMQ_PARAM_CHAN)) {
rmqp->channel = 1;
amqp_channel_open(rmqp->conn, rmqp->channel);
rmqp->flags |= RMQ_PARAM_CHAN;
if (rmq_error("Opening channel", amqp_get_rpc_reply(rmqp->conn)))
goto destroy_rmqp;
}
return 0;
destroy_rmqp:
rmq_destroy_param(rmqp);
return -1;
}
static struct brokerstate *
local_amqp_get_bs(broker_id) {
char sql[1024];
char host_copy[300] = "";
int tries = 0;
struct brokerstate *bs = local_amqp_get_a_bs(broker_id);
if(bs->conn) return bs;
if(SPI_connect() == SPI_ERROR_CONNECT) return NULL;
snprintf(sql, sizeof(sql), "SELECT host, port, vhost, username, password "
" FROM amqp.broker "
" WHERE broker_id = %d "
" ORDER BY host DESC, port", broker_id);
if(SPI_OK_SELECT == SPI_execute(sql, true, 100)) {
tries = SPI_processed;
retry:
tries--;
if(SPI_processed > 0) {
struct timeval hb = { .tv_sec = 2UL, .tv_usec = 0UL };
amqp_rpc_reply_t *reply, s_reply;
char *host, *vhost, *user, *pass;
Datum port_datum;
bool is_null;
int port = 5672;
bs->idx = (bs->idx + 1) % SPI_processed;
host = SPI_getvalue(SPI_tuptable->vals[bs->idx], SPI_tuptable->tupdesc, 1);
if(!host) host = "localhost";
port_datum = SPI_getbinval(SPI_tuptable->vals[bs->idx], SPI_tuptable->tupdesc, 2, &is_null);
if(!is_null) port = DatumGetInt32(port_datum);
vhost = SPI_getvalue(SPI_tuptable->vals[bs->idx], SPI_tuptable->tupdesc, 3);
if(!vhost) vhost = "/";
user = SPI_getvalue(SPI_tuptable->vals[bs->idx], SPI_tuptable->tupdesc, 4);
if(!user) user = "******";
pass = SPI_getvalue(SPI_tuptable->vals[bs->idx], SPI_tuptable->tupdesc, 5);
if(!pass) pass = "******";
snprintf(host_copy, sizeof(host_copy), "%s:%d", host, port);
bs->conn = amqp_new_connection();
if(!bs->conn) { SPI_finish(); return NULL; }
bs->sockfd = amqp_open_socket(host, port, &hb);
if(bs->sockfd < 0) {
elog(WARNING, "amqp[%s] login socket/connect failed: %s",
host_copy, strerror(-bs->sockfd));
goto busted;
}
amqp_set_sockfd(bs->conn, bs->sockfd);
s_reply = amqp_login(bs->conn, vhost, 0, 131072,
0, AMQP_SASL_METHOD_PLAIN,
user, pass);
if(s_reply.reply_type != AMQP_RESPONSE_NORMAL) {
elog(WARNING, "amqp[%s] login failed on broker %d", host_copy, broker_id);
goto busted;
}
amqp_channel_open(bs->conn, 1);
reply = amqp_get_rpc_reply();
if(reply->reply_type != AMQP_RESPONSE_NORMAL) {
elog(WARNING, "amqp[%s] channel open failed on broker %d", host_copy, broker_id);
goto busted;
}
amqp_channel_open(bs->conn, 2);
reply = amqp_get_rpc_reply();
if(reply->reply_type != AMQP_RESPONSE_NORMAL) {
elog(WARNING, "amqp[%s] channel open failed on broker %d", host_copy, broker_id);
goto busted;
}
amqp_tx_select(bs->conn, 2, AMQP_EMPTY_TABLE);
reply = amqp_get_rpc_reply();
if(reply->reply_type != AMQP_RESPONSE_NORMAL) {
elog(WARNING, "amqp[%s] could not start tx mode on broker %d", host_copy, broker_id);
goto busted;
}
} else {
elog(WARNING, "amqp can't find broker %d", broker_id);
}
} else {
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;
char const *queuename;
char const *amqp_user;
char const *amqp_passwd;
amqp_frame_t frame;
int result;
char *ret = NULL;
amqp_basic_deliver_t *d;
amqp_basic_properties_t *p;
size_t body_target;
size_t body_received;
int sockfd;
amqp_connection_state_t conn;
if (argc < 6) {
fprintf(stderr, "Usage: amqp_listenq host port queuename user password\n");
return 1;
}
hostname = argv[1];
port = atoi(argv[2]);
queuename = argv[3];
amqp_user = argv[4];
amqp_passwd = argv[5];
conn = amqp_new_connection();
ads_utils_error(sockfd = amqp_open_socket(hostname, port), "Opening socket");
amqp_set_sockfd(conn, sockfd);
ads_utils_amqp_error(amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, amqp_user,
amqp_passwd), "Logging in");
amqp_channel_open(conn, 1);
ads_utils_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);
ads_utils_amqp_error(amqp_get_rpc_reply(conn), "Consuming");
amqp_maybe_release_buffers(conn);
result = amqp_simple_wait_frame(conn, &frame);
if (result < 0)
exit(0);
if (frame.frame_type != AMQP_FRAME_METHOD)
exit(0);
if (frame.payload.method.id != AMQP_BASIC_DELIVER_METHOD)
exit(0);
d = (amqp_basic_deliver_t *) frame.payload.method.decoded;
result = amqp_simple_wait_frame(conn, &frame);
if (result < 0)
exit(0);
if (frame.frame_type != AMQP_FRAME_HEADER) {
fprintf(stderr, "Expected header!");
return 1;
}
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!");
return 1;
}
body_received += frame.payload.body_fragment.len;
assert(body_received <= body_target);
ret = ads_utils_amqp_dump(frame.payload.body_fragment.bytes,
frame.payload.body_fragment.len);
printf("%s\n", ret);
free(ret);
}
if (body_received != body_target) {
/* Can only happen when amqp_simple_wait_frame returns <= 0 */
/* We break here to close the connection */
exit(0);
}
amqp_basic_ack(conn, 1, d->delivery_tag, 0);
ads_utils_amqp_error(amqp_channel_close(conn, 1, AMQP_REPLY_SUCCESS), "Closing channel");
ads_utils_amqp_error(amqp_connection_close(conn, AMQP_REPLY_SUCCESS), "Closing connection");
ads_utils_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;
}