amqp_channel_open and amqp_channel_close needs called in every operation, likes in amqp_exchange_declare, amqp_queue_declare and so on

[kongxa]

rabbitmq version:v0.10.0 When i implement rabbitmq client，i see this instance below https://blog.csdn.net/LT_lover/article/details/80915711

Here is my question:

1. Does amqp_channel_open and amqp_channel_close need called in every operation, likes in amqp_exchange_declare, amqp_queue_declare, amqp_queue_bind, amqp_queue_unbind, amqp_queue_delete,amqp_basic_publish,amqp_basic_consume?
2. Does amqp_basic_publish have rpc reply from rabbitmq server? I am not find in example
3. If amqp_queue_bind return NULL，i find two proccess, below . Does amqp_get_rpc_reply realy get something from rabbitmq server when amqp_queue_bind returns NULL? 1) 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"); 2) if (!amqp_queue_bind(conn, 1, queue_bytes, eb, cstring_bytes(routing_key_token), amqp_empty_table)) { die_rpc(amqp_get_rpc_reply(conn), "queue.bind"); }

Code：

#ifndef RABBITMQ_CLIENT_H_
#define RABBITMQ_CLIENT_H_

#include <string>
#include <vector>
#include "amqp_tcp_socket.h"

using std::string;
using std::vector;

class CRabbitmqClient{
public:
    CRabbitmqClient();
    ~CRabbitmqClient();

    int Connect(const string &strHostname, int iPort, const string &strUser, const string &strPasswd);
    int Disconnect();

    /**
    *   @brief     ExchangeDeclare  声明exchange
    *   @param     [in]            strExchange  
    *   @param     [in]            strType
    *   @return 等于0值代表成功创建exchange，小于0代表错误
    */
    int ExchangeDeclare(const string &strExchange, const string &strType);

    /**
    *   @brief     QueueDeclare                  声明消息队列
    *   @param     [in]            strQueueName  消息队列实例
    *   @param     
    *   @return 等于0值代表成功创建queue，小于0代表错误
    */
    int QueueDeclare(const string &strQueueName);

    /**
    *   @brief     QueueBind                        将队列，交换机和绑定规则绑定起来形成一个路由表
    *   @param     [in]            strQueueName  消息队列
    *   @param     [in]            strExchange   交换机名称
    *   @param     [in]            strBindKey   路由名称  “msg.#” “msg.weather.**”
    *   @return 等于0值代表成功绑定，小于0代表错误
    */
    int QueueBind(const string &strQueueName, const string &strExchange, const string &strBindKey);

    /**
    *   @brief     QueueUnbind                    将队列，交换机和绑定规则绑定解除
    *   @param     [in]            strQueueName  消息队列
    *   @param     [in]            strExchange   交换机名称
    *   @param     [in]            strBindKey   路由名称  “msg.#” “msg.weather.**”
    *   @return 等于0值代表成功绑定，小于0代表错误
    */
    int QueueUnbind(const string &strQueueName, const string &strExchange, const string &strBindKey);

    /**
    *   @brief     QueueDelete                    删除消息队列。
    *   @param     [in]            strQueueName  消息队列名称
    *   @param     [in]            iIfUnused     消息队列是否在用，1 则论是否在用都删除
    *   @return 等于0值代表成功删除queue，小于0代表错误
    */
    int QueueDelete(const string &strQueueName, int iIfUnused);

    /**
    * @brief Publish  发布消息
    * @param [in] strMessage        消息实体
    * @param [in] strExchange      交换器
    * @param [in] strRoutekey      路由规则 
    *   1.Direct Exchange – 处理路由键。需要将一个队列绑定到交换机上，要求该消息与一个特定的路由键完全匹配。
    *   2.Fanout Exchange – 不处理路由键。将队列绑定到交换机上。一个发送到交换机的消息都会被转发到与该交换机绑定的所有队列上。
    *   3.Topic Exchange – 将路由键和某模式进行匹配。此时队列需要绑定要一个模式上。符号“#”匹配一个或多个词，符号“*”匹配不多不少一个词。
    *     因此“audit.#”能够匹配到“audit.irs.corporate”，但是“audit.*” 只会匹配到“audit.irs”
    * @return 等于0值代表成功发送消息实体，小于0代表发送错误
    */
    int Publish(const string &strMessage, const string &strExchange, const string &strRoutekey);

    /** 
    * @brief consumer  消费消息
    * @param [in]  strQueueName      队列名称
    * @param [out] message_array        获取的消息实体
    * @param [int] GetNum              需要取得的消息个数
    * @param [int] timeout            取得的消息是延迟，若为NULL，表示持续取，无延迟，阻塞状态
    * @return 等于0值代表成功，小于0代表错误，错误信息从ErrorReturn返回
    */
    int Consumer(const string &strQueueName, vector<string> &message_array, int GetNum = 1, struct timeval *timeout = NULL);

private:
    CRabbitmqClient(const CRabbitmqClient & rh);
    void operator=(const CRabbitmqClient & rh);

    int ErrorMsg(amqp_rpc_reply_t x, char const *context);

    string                    m_strHostname;      // amqp主机
    int                      m_iPort;           // amqp端口
    string                      m_strUser;
    string                      m_strPasswd;
    int                      m_iChannel; 

    amqp_socket_t              *m_pSock;        
    amqp_connection_state_t  m_pConn;
};

#endif

#include "RabbitmqClient.h"
#include <unistd.h>

CRabbitmqClient::CRabbitmqClient()
: m_strHostname("") 
, m_iPort(0)
, m_strUser("")
, m_strPasswd("")
, m_iChannel(1) //默认用1号通道，通道无所谓 
, m_pSock(NULL)
, m_pConn(NULL) {

}

CRabbitmqClient::~CRabbitmqClient() {
    if (NULL != m_pConn) {
        Disconnect();  
        m_pConn = NULL;
    }
}

int CRabbitmqClient::Connect(const string &strHostname, int iPort, const string &strUser, const string &strPasswd) {
    m_strHostname = strHostname;
    m_iPort = iPort;
    m_strUser = strUser;
    m_strPasswd = strPasswd;

    m_pConn = amqp_new_connection();
    if (NULL == m_pConn) {
        fprintf(stderr, "amqp new connection failed\n");
        return -1;
    }

    m_pSock =  amqp_tcp_socket_new(m_pConn);
    if (NULL == m_pSock) {
        fprintf(stderr, "amqp tcp new socket failed\n");
        return -2;
    }

    int status = amqp_socket_open(m_pSock, m_strHostname.c_str(), m_iPort);
    if (status<0) {
        fprintf(stderr, "amqp socket open failed\n");
        return -3;
    }

    // amqp_login(amqp_connection_state_t state,char const *vhost, int channel_max, int frame_max, int heartbeat, amqp_sasl_method_enum sasl_method, ..)
    if (0 != ErrorMsg(amqp_login(m_pConn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, m_strUser.c_str(), m_strPasswd.c_str()), "Logging in")) {
        return -4;
    }

    return 0;
}

int CRabbitmqClient::Disconnect() {
    if (NULL != m_pConn) {
        if (0 != ErrorMsg(amqp_connection_close(m_pConn, AMQP_REPLY_SUCCESS), "Closing connection"))
            return -1;

        if (amqp_destroy_connection(m_pConn) < 0)
            return -2;

        m_pConn = NULL;
    }

    return 0;
}

int CRabbitmqClient::ExchangeDeclare(const string &strExchange, const string &strType) {
    amqp_channel_open(m_pConn, m_iChannel);

    amqp_bytes_t _exchange = amqp_cstring_bytes(strExchange.c_str());
    amqp_bytes_t _type = amqp_cstring_bytes(strType.c_str());
    int _passive= 0;
    int _durable= 0;      // 交换机是否持久化
    amqp_exchange_declare(m_pConn, m_iChannel, _exchange, _type, _passive, _durable, 0, 0, amqp_empty_table);
    if (0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "exchange_declare")) {
        amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
        return -1;
    }

    amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
    return 0;
}

int CRabbitmqClient::QueueDeclare(const string &strQueueName) {
    if(NULL == m_pConn) {
        fprintf(stderr, "QueueDeclare m_pConn is null\n");
        return -1;
    }

    amqp_channel_open(m_pConn, m_iChannel);
    amqp_bytes_t _queue = amqp_cstring_bytes(strQueueName.c_str());
    int32_t _passive = 0;
    int32_t _durable = 0; 
    int32_t _exclusive = 0;
    int32_t _auto_delete = 1;
    amqp_queue_declare(m_pConn, m_iChannel, _queue, _passive, _durable, _exclusive, _auto_delete, amqp_empty_table);
    if (0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "queue_declare")) {
        amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
        return -1;
    }

    amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
    return 0;
}

int CRabbitmqClient::QueueBind(const string &strQueueName, const string &strExchange, const string &strBindKey) {
    if(NULL == m_pConn) {
        fprintf(stderr, "QueueBind m_pConn is null\n");
        return -1;
    }

    amqp_channel_open(m_pConn, m_iChannel);
    amqp_bytes_t _queue = amqp_cstring_bytes(strQueueName.c_str());
    amqp_bytes_t _exchange = amqp_cstring_bytes(strExchange.c_str());
    amqp_bytes_t _routkey  = amqp_cstring_bytes(strBindKey.c_str());
    amqp_queue_bind(m_pConn, m_iChannel, _queue, _exchange, _routkey, amqp_empty_table);
    if(0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "queue_bind")) {
        amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
        return -1;
    }

    amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
    return 0;
}

int CRabbitmqClient::QueueUnbind(const string &strQueueName, const string &strExchange, const string &strBindKey) {
    if(NULL == m_pConn) {
        fprintf(stderr, "QueueUnbind m_pConn is null\n");
        return -1;
    }

    amqp_channel_open(m_pConn, m_iChannel);
    amqp_bytes_t _queue = amqp_cstring_bytes(strQueueName.c_str());
    amqp_bytes_t _exchange = amqp_cstring_bytes(strExchange.c_str());
    amqp_bytes_t _routkey  = amqp_cstring_bytes(strBindKey.c_str());
    amqp_queue_unbind(m_pConn, m_iChannel, _queue, _exchange, _routkey, amqp_empty_table);
    if(0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "queue_unbind")) {
        amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
        return -1;
    }

    amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
    return 0;
}

int CRabbitmqClient::QueueDelete(const string &strQueueName, int iIfUnused) {
    if(NULL == m_pConn) {
        fprintf(stderr, "QueueDelete m_pConn is null\n");
        return -1;
    }

    amqp_channel_open(m_pConn, m_iChannel);
    if(0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "open channel")) {
        amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
        return -2;
    }

    amqp_queue_delete(m_pConn, m_iChannel, amqp_cstring_bytes(strQueueName.c_str()), iIfUnused, 0);
    if(0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "delete queue")) {
        amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
        return -3;
    }

    amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
    return 0;
}

int CRabbitmqClient::Publish(const string &strMessage, const string &strExchange, const string &strRoutekey) {
    if (NULL == m_pConn) {
        fprintf(stderr, "publish m_pConn is null, publish failed\n");
        return -1;
    }

    amqp_channel_open(m_pConn, m_iChannel);
    if(0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "open channel")) {
        amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
        return -2;
    }

    amqp_bytes_t message_bytes;
    message_bytes.len = strMessage.length();
    message_bytes.bytes = (void *)(strMessage.c_str());
    //fprintf(stderr, "publish message(%d): %.*s\n", (int)message_bytes.len, (int)message_bytes.len, (char *)message_bytes.bytes);

    /*
    amqp_basic_properties_t props;
    props._flags = AMQP_BASIC_CONTENT_TYPE_FLAG | AMQP_BASIC_DELIVERY_MODE_FLAG;
    props.content_type = amqp_cstring_bytes(m_type.c_str());
    props.delivery_mode = m_durable;    // persistent delivery mode
    */

    amqp_bytes_t exchange = amqp_cstring_bytes(strExchange.c_str());
    amqp_bytes_t routekey = amqp_cstring_bytes(strRoutekey.c_str());

    //if (0 != amqp_basic_publish(m_pConn, m_iChannel, exchange, routekey, 0, 0, &props, message_bytes)) {
    if (0 != amqp_basic_publish(m_pConn, m_iChannel, exchange, routekey, 0, 0, NULL, message_bytes)) {
        fprintf(stderr, "publish amqp_basic_publish failed\n");
        if (0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "amqp_basic_publish")) {
            amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
            return -3;
        }
    }

    amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
    return 0;
}

int CRabbitmqClient::Consumer(const string &strQueueName, vector<string> &message_array, int GetNum, struct timeval *timeout) {
    if (NULL == m_pConn) {
        fprintf(stderr, "Consumer m_pConn is null, Consumer failed\n");
        return -1;
    }

    amqp_channel_open(m_pConn, m_iChannel);
    if (0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "open channel")) {
        amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
        return -2;
    }

    amqp_basic_qos(m_pConn, m_iChannel, 0, GetNum, 0);
    int ack = 1; // no_ack  是否需要确认消息后再从队列中删除消息
    amqp_bytes_t queuename= amqp_cstring_bytes(strQueueName.c_str());
    amqp_basic_consume(m_pConn, m_iChannel, queuename, amqp_empty_bytes, 0, ack, 0, amqp_empty_table);

    if (0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "Consuming")) {
        amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
        return -3;
    }

    int hasget = 0;
    amqp_rpc_reply_t res;
    amqp_envelope_t envelope;
    while (GetNum > 0) {
        amqp_maybe_release_buffers(m_pConn);
        res = amqp_consume_message(m_pConn, &envelope, timeout, 0);
        if (AMQP_RESPONSE_NORMAL != res.reply_type) {
            fprintf(stderr, "Consumer amqp_channel_close failed\n");
            amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);

            if (0 == hasget)
                return -res.reply_type;
            else
                return 0;
        }

        string str((char *)envelope.message.body.bytes, (char *)envelope.message.body.bytes + envelope.message.body.len);
        message_array.push_back(str);
        int rtn = amqp_basic_ack(m_pConn, m_iChannel, envelope.delivery_tag, 1);
        amqp_destroy_envelope(&envelope);
        if (rtn != 0) {
            amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
            return -4;
        }

        GetNum--;
        hasget++;
        usleep(1);
    }

    return 0;
}

int CRabbitmqClient::ErrorMsg(amqp_rpc_reply_t x, char const *context) {
    switch (x.reply_type) {
        case AMQP_RESPONSE_NORMAL:
            return 0;

        case AMQP_RESPONSE_NONE:
            fprintf(stderr, "%s: missing RPC reply type!\n", context);
            break;

        case AMQP_RESPONSE_LIBRARY_EXCEPTION:
            fprintf(stderr, "%s: %s\n", context, amqp_error_string2(x.library_error));
            break;

        case AMQP_RESPONSE_SERVER_EXCEPTION:
            switch (x.reply.id) {
                case AMQP_CONNECTION_CLOSE_METHOD: {
                    amqp_connection_close_t *m = (amqp_connection_close_t *)x.reply.decoded;
                    fprintf(stderr, "%s: server connection error %uh, message: %.*s\n",
                        context, m->reply_code, (int)m->reply_text.len,
                        (char *)m->reply_text.bytes);
                    break;
                                                    }
                case AMQP_CHANNEL_CLOSE_METHOD: {
                    amqp_channel_close_t *m = (amqp_channel_close_t *)x.reply.decoded;
                    fprintf(stderr, "%s: server channel error %uh, message: %.*s\n",
                        context, m->reply_code, (int)m->reply_text.len,
                        (char *)m->reply_text.bytes);
                    break;
                                                }
                default:
                    fprintf(stderr, "%s: unknown server error, method id 0x%08X\n",
                        context, x.reply.id);
                    break;
            }
            break;
    }

    return -1;
}

[alanxz]

Does amqp_channel_open and amqp_channel_close need called in every operation, likes in amqp_exchange_declare, amqp_queue_declare, amqp_queue_bind, amqp_queue_unbind, amqp_queue_delete,amqp_basic_publish,amqp_basic_consume?

amqp_exchange_declare (and friends) need an open channel, that channel may be reused between different calls, so there is no reason to close the channel after each call. A channel may be closed by the server if one of those calls fails. If the server indicates that the channel is closed, you'll need to open a new channel before calling any new functions that require a channel.

Does amqp_basic_publish have rpc reply from rabbitmq server? I am not find in example

By default amqp_basic_publish does not get an rpc-reply from the server. You can enable publisher confirms, in which the server will send a basic.ack method when back to the client after it has successfully processed a message. https://github.com/alanxz/rabbitmq-c/blob/master/examples/amqp_producer.c has a small example where publisher confirms are not enabled

If amqp_queue_bind return NULL，i find two proccess, below . Does amqp_get_rpc_reply realy get something from rabbitmq server when amqp_queue_bind returns NULL?

If amqp_queue_bind returns NULL, you will need to use amqp_get_rpc_reply to understand why it failed, this may be due to the server returning an error.

[kongxa]

Thank you very much.

By default amqp_basic_publish does not get an rpc-reply from the server. You can enable publisher confirms, in which the server will send a basic.ack method when back to the client after it has successfully processed a message. https://github.com/alanxz/rabbitmq-c/blob/master/examples/amqp_producer.c has a small example where publisher confirms are not enabled

If publisher confirms are not enabled, amqp_basic_publish does not get an rpc-reply from the server, amqp_get_rpc_reply was called anyway. Will the process be blocked by this call？

If amqp_queue_bind returns NULL, you will need to use amqp_get_rpc_reply to understand why it failed, this may be due to the server returning an error.

If amqp_queue_bind return success, do i need to call amqp_get_rpc_reply? I have known the result, but if i no need to call amqp_get_rpc_reply，will some rpc reply be left in rabbitmq client or connection？

[alanxz]

If amqp_queue_bind return success, do i need to call amqp_get_rpc_reply?

No, you only need to call it when amqp_queue_bind returns NULL.