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; }
static int noit_rabbimq_submit(iep_thread_driver_t *dr, const char *payload, size_t payloadlen) { int rv; amqp_bytes_t body; struct amqp_driver *driver = (struct amqp_driver *)dr; const char *routingkey = driver->routingkey; body.len = payloadlen; body.bytes = (char *)payload; if(*payload == 'M' || *payload == 'S' || *payload == 'C' || (*payload == 'H' && payload[1] == '1') || (*payload == 'F' && payload[1] == '1') || (*payload == 'B' && (payload[1] == '1' || payload[1] == '2'))) { char uuid_str[32 * 2 + 1]; int account_id, check_id; if(extract_uuid_from_jlog(payload, payloadlen, &account_id, &check_id, uuid_str)) { if(*routingkey) { char *replace; int newlen = strlen(driver->routingkey) + 1 + sizeof(uuid_str) + 2 * 32; replace = alloca(newlen); snprintf(replace, newlen, "%s.%x.%x.%d.%d%s", driver->routingkey, account_id%16, (account_id/16)%16, account_id, check_id, uuid_str); routingkey = replace; } } } rv = amqp_basic_publish(driver->connection, 1, amqp_cstring_bytes(driver->exchange), amqp_cstring_bytes(routingkey), 1, 0, NULL, body); if(rv < 0) { mtevL(mtev_error, "AMQP publish failed, disconnecting\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; } BUMPSTAT(publications); noit_rabbitmq_heartbeat(driver); noit_rabbitmq_read_frame(driver); amqp_maybe_release_buffers(driver->connection); if(driver->has_error) { 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; } return 0; }
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; }
int main(int argc, char const *const *argv) { char const *hostname; int port, status; char const *exchange; char const *exchangetype; amqp_socket_t *socket; amqp_connection_state_t conn; if (argc < 5) { fprintf(stderr, "Usage: amqps_exchange_declare host port exchange " "exchangetype [cacert.pem [key.pem cert.pem]]\n"); return 1; } hostname = argv[1]; port = atoi(argv[2]); exchange = argv[3]; exchangetype = argv[4]; conn = amqp_new_connection(); socket = amqp_ssl_socket_new(conn); if (!socket) { die("creating SSL/TLS socket"); } if (argc > 5) { status = amqp_ssl_socket_set_cacert(socket, argv[5]); if (status) { die("setting CA certificate"); } } if (argc > 7) { status = amqp_ssl_socket_set_key(socket, argv[7], argv[6]); if (status) { die("setting client key/cert"); } } status = amqp_socket_open(socket, hostname, port); if (status) { die("opening SSL/TLS connection"); } die_on_amqp_error(amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, "guest", "guest"), "Logging in"); amqp_channel_open(conn, 1); die_on_amqp_error(amqp_get_rpc_reply(conn), "Opening channel"); amqp_exchange_declare(conn, 1, amqp_cstring_bytes(exchange), amqp_cstring_bytes(exchangetype), 0, 0, amqp_empty_table); die_on_amqp_error(amqp_get_rpc_reply(conn), "Declaring exchange"); die_on_amqp_error(amqp_channel_close(conn, 1, AMQP_REPLY_SUCCESS), "Closing channel"); die_on_amqp_error(amqp_connection_close(conn, AMQP_REPLY_SUCCESS), "Closing connection"); die_on_error(amqp_destroy_connection(conn), "Ending connection"); return 0; }
void destroy() { amqp_channel_close(conn, channel_id, AMQP_REPLY_SUCCESS); amqp_connection_close(conn, AMQP_REPLY_SUCCESS); amqp_destroy_connection(conn); printf("amqp close and destroy connection.\n"); }
/* php_amqp_disconnect handles disconnecting from amqp called by disconnect(), reconnect(), and d_tor */ void php_amqp_disconnect(amqp_connection_object *amqp_connection) { void * old_handler; /* If we are trying to close the connection and the connection already closed, it will throw SIGPIPE, which is fine, so ignore all SIGPIPES */ /* Start ignoring SIGPIPE */ old_handler = signal(SIGPIPE, SIG_IGN); if (amqp_connection->is_channel_connected == '\1') { amqp_channel_close(amqp_connection->conn, AMQP_CHANNEL, AMQP_REPLY_SUCCESS); } amqp_connection->is_channel_connected = '\0'; if (amqp_connection->conn && amqp_connection->is_connected == '\1') { amqp_connection_close(amqp_connection->conn, AMQP_REPLY_SUCCESS); amqp_destroy_connection(amqp_connection->conn); } amqp_connection->is_connected = '\0'; if (amqp_connection->fd) { close(amqp_connection->fd); } /* End ignoring of SIGPIPEs */ signal(SIGPIPE, old_handler); return; }
void close_and_destroy_connection(amqp_connection_state_t connection_state_) { amqp_rpc_reply_t rpc_reply = amqp_connection_close(connection_state_, AMQP_REPLY_SUCCESS); assert(rpc_reply.reply_type == AMQP_RESPONSE_NORMAL); int rc = amqp_destroy_connection(connection_state_); assert(rc == AMQP_STATUS_OK); }
RabbitMQConnection::~RabbitMQConnection() { int fd; if (conn == NULL) { GST_DEBUG ("service already stopped"); return; } fd = amqp_socket_get_sockfd (socket); /* Errors are ignored during close */ if (!closeOnRelease) { /* close socket */ close (fd); } amqp_channel_close (conn, 1, AMQP_REPLY_SUCCESS); amqp_connection_close (conn, AMQP_REPLY_SUCCESS); amqp_destroy_connection (conn); if (closeOnRelease) { /* inform remote side that we are done */ shutdown (fd, SHUT_WR); } conn = NULL; }
void AMQP::login() { amqp_rpc_reply_t res = amqp_login(cnn, vhost.c_str(), 0, FRAME_MAX, 0, AMQP_SASL_METHOD_PLAIN, user.c_str(), password.c_str()); if ( res.reply_type != AMQP_RESPONSE_NORMAL) { amqp_destroy_connection(cnn); throw AMQPException(&res); } }
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); }
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 { amqp_socket_t *socket = amqp_tcp_socket_new(m_impl->m_connection); int sock = amqp_socket_open(socket, host.c_str(), port); m_impl->CheckForError(sock); m_impl->DoLogin(username, password, vhost, frame_max); } catch (...) { amqp_destroy_connection(m_impl->m_connection); throw; } m_impl->SetIsConnected(true); }
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; }
void rpc_close(struct status *status) { int ret = 0; DEBUG(2, ("[*] Closing RPC\n")); /* Adquire lock */ ret = pthread_spin_lock(&status->lock); if (ret) { fprintf(stderr, "[!] pthread_spin_lock: %s\n", strerror(ret)); return; } if (status->conn) { if (amqp_channel_close(status->conn, 1, AMQP_REPLY_SUCCESS).reply_type != AMQP_RESPONSE_NORMAL) { fprintf(stderr, "[!] Error closing AMQP channel\n"); } if (amqp_connection_close(status->conn, AMQP_REPLY_SUCCESS).reply_type != AMQP_RESPONSE_NORMAL) { fprintf(stderr, "[!] Error closing AMQP connection\n"); } if (amqp_destroy_connection(status->conn) < 0) { fprintf(stderr, "[!] Error destroying AMQP connection\n"); } } status->conn = NULL; /* Release lock */ pthread_spin_unlock(&status->lock); }
static int exit_amqp_connection_atomic() { int res = LC_BUS_OK; amqp_rpc_reply_t ret; int i; for (i = 0; i < LC_BUS_MAX_CONNECTION; ++i) { if (connection_tid[i]) { ret = amqp_channel_close(lc_conn[i], LC_BUS_CHANNEL, AMQP_REPLY_SUCCESS); if (ret.reply_type != AMQP_RESPONSE_NORMAL) { LB_SYSLOG(LOG_ERR, "error in closing channel: %s\n", amqp_rpc_reply_string(&ret)); } ret = amqp_connection_close(lc_conn[i], AMQP_REPLY_SUCCESS); if (ret.reply_type != AMQP_RESPONSE_NORMAL) { LB_SYSLOG(LOG_ERR, "error in closing connection, %s\n", amqp_rpc_reply_string(&ret)); } res = amqp_destroy_connection(lc_conn[i]); if (res) { LB_SYSLOG(LOG_ERR, "error in destroy connection ret=%d\n", res); } connection_tid[i] = 0; } } return LC_BUS_OK; }
int amqp_tune_connection(amqp_connection_state_t state, int channel_max, int frame_max, int heartbeat) { void *newbuf; ENFORCE_STATE(state, CONNECTION_STATE_IDLE); state->channel_max = channel_max; state->frame_max = frame_max; state->heartbeat = heartbeat; empty_amqp_pool(&state->frame_pool); init_amqp_pool(&state->frame_pool, frame_max); state->inbound_buffer.len = frame_max; state->outbound_buffer.len = frame_max; newbuf = realloc(state->outbound_buffer.bytes, frame_max); if (newbuf == NULL) { amqp_destroy_connection(state); return -ENOMEM; } state->outbound_buffer.bytes = newbuf; 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, const std::string &path_to_ca_cert, const std::string &path_to_client_key, const std::string &path_to_client_cert) : m_impl(new Detail::ChannelImpl) { m_impl->m_connection = amqp_new_connection(); if (NULL == m_impl->m_connection) { throw std::bad_alloc(); } amqp_socket_t *socket = amqp_ssl_socket_new(m_impl->m_connection); if (NULL == socket) { throw std::bad_alloc(); } try { int status = amqp_ssl_socket_set_cacert(socket, path_to_ca_cert.c_str()); if (status) { throw std::runtime_error("Error in setting CA certificate for socket"); } if (path_to_client_key != "" && path_to_client_cert != "") { status = amqp_ssl_socket_set_key(socket, path_to_client_cert.c_str(), path_to_client_key.c_str()); if (status) { throw std::runtime_error("Error in setting client certificate for socket"); } } status = amqp_socket_open(socket, host.c_str(), port); if (status) { throw std::runtime_error("Error in opening SSL/TLS connection for socket"); } m_impl->DoLogin(username, password, vhost, frame_max); } catch (...) { amqp_destroy_connection(m_impl->m_connection); throw; } m_impl->SetIsConnected(true); }
static void afamqp_dd_disconnect(AMQPDestDriver *self) { amqp_channel_close(self->conn, 1, AMQP_REPLY_SUCCESS); amqp_connection_close(self->conn, AMQP_REPLY_SUCCESS); amqp_destroy_connection(self->conn); self->conn = NULL; }
static amqp_connection_state_t get_amqp_connection(void) { int status; amqp_connection_state_t conn; amqp_rpc_reply_t reply; amqp_socket_t *socket = NULL; conn = amqp_new_connection(); if (!conn) { fprintf(stderr, "[!] Error getting ampq connection\n"); return NULL; } socket = amqp_tcp_socket_new(conn); if (!socket) { amqp_destroy_connection(conn); fprintf(stderr, "[!] Error creating the TCP socket!\n"); return NULL; } status = amqp_socket_open(socket, "localhost", 5672); if (status) { amqp_connection_close(conn, AMQP_REPLY_SUCCESS); amqp_destroy_connection(conn); fprintf(stderr, "[!] Error opening the TCP socket!\n"); return NULL; } reply = amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, "guest", "guest"); if (reply.reply_type != AMQP_RESPONSE_NORMAL) { amqp_connection_close(conn, AMQP_REPLY_SUCCESS); amqp_destroy_connection(conn); fprintf(stderr, "[!] Error loggging into server\n"); return NULL; } if (!amqp_channel_open(conn, 1)) { amqp_channel_close(conn, 1, AMQP_REPLY_SUCCESS); amqp_connection_close(conn, AMQP_REPLY_SUCCESS); fprintf(stderr, "[!] Error opening channel 1\n"); return NULL; } return conn; }
eSquere * eSquere::DestroyConnection(){ int x=amqp_destroy_connection(this->connect); if(x<0){ this->ErrorStatus=true; this->ErrorMessage=amqp_error_string2(x); } return this; }
/** * Close a session with the filter, this is the mechanism * by which a filter may cleanup data structure etc. * In the case of the MQ filter we simply close the connection to the server. * * @param instance The filter instance data * @param session The session being closed */ static void closeSession(FILTER *instance, void *session) { MQ_SESSION *my_session = (MQ_SESSION *)session; amqp_channel_close(my_session->conn,my_session->channel,AMQP_REPLY_SUCCESS); amqp_connection_close(my_session->conn,AMQP_REPLY_SUCCESS); amqp_destroy_connection(my_session->conn); }
int main(int argc, char const *const *argv) { char const *hostname; int port, status; int rate_limit; int message_count; amqp_socket_t *socket; amqp_connection_state_t conn; if (argc < 5) { fprintf(stderr, "Usage: amqps_producer host port rate_limit message_count " "[cacert.pem [key.pem cert.pem]]\n"); return 1; } hostname = argv[1]; port = atoi(argv[2]); rate_limit = atoi(argv[3]); message_count = atoi(argv[4]); conn = amqp_new_connection(); socket = amqp_ssl_socket_new(conn); if (!socket) { die("creating SSL/TLS socket"); } if (argc > 5) { status = amqp_ssl_socket_set_cacert(socket, argv[5]); if (status) { die("setting CA certificate"); } } if (argc > 7) { status = amqp_ssl_socket_set_key(socket, argv[7], argv[6]); if (status) { die("setting client cert"); } } status = amqp_socket_open(socket, hostname, port); if (status) { die("opening SSL/TLS connection"); } die_on_amqp_error(amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, "guest", "guest"), "Logging in"); amqp_channel_open(conn, 1); die_on_amqp_error(amqp_get_rpc_reply(conn), "Opening channel"); send_batch(conn, "test queue", rate_limit, message_count); die_on_amqp_error(amqp_channel_close(conn, 1, AMQP_REPLY_SUCCESS), "Closing channel"); die_on_amqp_error(amqp_connection_close(conn, AMQP_REPLY_SUCCESS), "Closing connection"); die_on_error(amqp_destroy_connection(conn), "Ending connection"); return 0; }
void AMQP::sockConnect() { cnn = amqp_new_connection(); sockfd = amqp_tcp_socket_new(cnn); if (!sockfd) { amqp_destroy_connection(cnn); throw AMQPException("AMQP cannot create socket descriptor"); } //cout << "sockfd="<< sockfd << " pid=" << getpid() <<endl; int status = amqp_socket_open(sockfd, host.c_str(), port); if (status != AMQP_STATUS_OK) { amqp_connection_close(cnn, AMQP_REPLY_SUCCESS); amqp_destroy_connection(cnn); throw AMQPException("AMQP cannot open socket"); } }
int main(int argc, const char **argv) { const char *hostname; int port; const char *exchange; const char *routingkey; const char *messagebody; const char *exchangetype = "direct"; if (argc < 6) { fprintf(stderr, "Usage: emit_log_direct host port exchange routingkey messagebody\n"); return 1; } hostname = argv[1]; port = atoi(argv[2]); exchange = argv[3]; routingkey = argv[4]; messagebody = argv[5]; int sockfd; int channelid = 1; amqp_connection_state_t conn; conn = amqp_new_connection(); die_on_error(sockfd = amqp_open_socket(hostname, port), "Opening socket"); amqp_set_sockfd(conn, sockfd); die_on_amqp_error(amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, "guest", "guest"),"Logging in"); amqp_channel_open(conn, channelid); die_on_amqp_error(amqp_get_rpc_reply(conn), "Opening channel"); amqp_exchange_declare(conn,channelid,amqp_cstring_bytes(exchange),amqp_cstring_bytes(exchangetype),0,1, amqp_empty_table); die_on_amqp_error(amqp_get_rpc_reply(conn),"Declaring exchange"); { amqp_basic_properties_t props; props._flags = AMQP_BASIC_DELIVERY_MODE_FLAG; /*props.content_type = amqp_cstring_bytes("text/plain");*/ props.delivery_mode = 2; /* persistent delivery mode */ die_on_error(amqp_basic_publish(conn, channelid, amqp_cstring_bytes(exchange), amqp_cstring_bytes(routingkey), 0, 0, &props, amqp_cstring_bytes(messagebody)), "Publishing"); } die_on_amqp_error(amqp_channel_close(conn, 1, AMQP_REPLY_SUCCESS), "Closing channel"); die_on_amqp_error(amqp_connection_close(conn, AMQP_REPLY_SUCCESS), "Closing connection"); die_on_error(amqp_destroy_connection(conn), "Ending connection"); return 0; }
int main(int argc, char const * const *argv) { char const *hostname; int port; char const *exchange; char const *bindingkey; int sockfd; amqp_connection_state_t conn; amqp_bytes_t queuename; if (argc < 3) { fprintf(stderr, "Usage: amqp_consumer host port\n"); return 1; } hostname = argv[1]; port = atoi(argv[2]); exchange = "amq.direct"; /* argv[3]; */ bindingkey = "test queue"; /* argv[4]; */ conn = amqp_new_connection(); die_on_error(sockfd = amqp_open_socket(hostname, port), "Opening socket"); amqp_set_sockfd(conn, sockfd); die_on_amqp_error(amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, "guest", "guest"), "Logging in"); amqp_channel_open(conn, 1); die_on_amqp_error(amqp_get_rpc_reply(conn), "Opening channel"); { amqp_queue_declare_ok_t *r = amqp_queue_declare(conn, 1, amqp_empty_bytes, 0, 0, 0, 1, amqp_empty_table); die_on_amqp_error(amqp_get_rpc_reply(conn), "Declaring queue"); queuename = amqp_bytes_malloc_dup(r->queue); if (queuename.bytes == NULL) { fprintf(stderr, "Out of memory while copying queue name"); return 1; } } amqp_queue_bind(conn, 1, queuename, amqp_cstring_bytes(exchange), amqp_cstring_bytes(bindingkey), amqp_empty_table); die_on_amqp_error(amqp_get_rpc_reply(conn), "Binding queue"); amqp_basic_consume(conn, 1, queuename, amqp_empty_bytes, 0, 1, 0, amqp_empty_table); die_on_amqp_error(amqp_get_rpc_reply(conn), "Consuming"); run(conn); die_on_amqp_error(amqp_channel_close(conn, 1, AMQP_REPLY_SUCCESS), "Closing channel"); die_on_amqp_error(amqp_connection_close(conn, AMQP_REPLY_SUCCESS), "Closing connection"); die_on_error(amqp_destroy_connection(conn), "Ending connection"); return 0; }
static int noit_rabbimq_disconnect(iep_thread_driver_t *d) { struct amqp_driver *dr = (struct amqp_driver *)d; if(dr->connection) { amqp_destroy_connection(dr->connection); dr->sockfd = -1; dr->connection = NULL; return 0; } return -1; }
static void closeAMQPConnection(instanceData *pData) { if (pData->conn != NULL) { die_on_amqp_error(amqp_channel_close(pData->conn, 1, AMQP_REPLY_SUCCESS), "amqp_channel_close"); die_on_amqp_error(amqp_connection_close(pData->conn, AMQP_REPLY_SUCCESS), "amqp_connection_close"); die_on_error(amqp_destroy_connection(pData->conn), "amqp_destroy_connection"); pData->conn = NULL; } }
static void shutdown_amqp_connection(amqp_connection_state_t connection, int amqp_rc, uint num_channels) { // close amqp connection, including all open channels if (amqp_rc >= 0) { for (int i=1; i <= num_channels; i++) log_amqp_error(amqp_channel_close(connection, i, AMQP_REPLY_SUCCESS), "closing AMQP channel"); log_amqp_error(amqp_connection_close(connection, AMQP_REPLY_SUCCESS), "closing AMQP connection"); } log_error(amqp_destroy_connection(connection), "closing AMQP connection"); }
void close_connection(amqp_connection_state_t conn) { int res; die_rpc(amqp_channel_close(conn, 1, AMQP_REPLY_SUCCESS), "closing channel"); die_rpc(amqp_connection_close(conn, AMQP_REPLY_SUCCESS), "closing connection"); res = amqp_destroy_connection(conn); die_amqp_error(res, "closing connection"); }
AMQP::~AMQP() { if (channels.size()) { vector<AMQPBase*>::iterator i; for (i=channels.begin(); i!=channels.end(); i++) { delete *i; } } amqp_destroy_connection(cnn); close(sockfd); };
static void local_amqp_disconnect_bs(struct brokerstate *bs) { if(bs && bs->conn) { int errorstate = bs->inerror; amqp_connection_close(bs->conn, AMQP_REPLY_SUCCESS); if(bs->sockfd >= 0) close(bs->sockfd); amqp_destroy_connection(bs->conn); memset(bs, 0, sizeof(*bs)); bs->inerror = errorstate; } }