static void qdr_connection_insert_column_CT()

in src/router_core/agent_connection.c [124:312]

• 152 lines of code
• 48 McCabe index (conditional complexity)

static void qdr_connection_insert_column_CT(qdr_core_t *core, qdr_connection_t *conn, int col, qd_composed_field_t *body, bool as_map)
{
    char id_str[100];
    const char *text = 0;

    if (!conn)
        return;

    if (as_map)
        qd_compose_insert_string(body, qdr_connection_columns[col]);

    switch(col) {
    case QDR_CONNECTION_NAME:
        qd_compose_insert_string2(body, "connection/", conn->connection_info->host);
        break;

    case QDR_CONNECTION_IDENTITY: {
        snprintf(id_str, 100, "%"PRId64, conn->identity);
        qd_compose_insert_string(body, id_str);
        break;
    }

    case QDR_CONNECTION_HOST:
        qd_compose_insert_string(body, conn->connection_info->host);
        break;

    case QDR_CONNECTION_ROLE:
        qd_compose_insert_string(body, qdr_connection_roles[conn->connection_info->role]);
        break;

    case QDR_CONNECTION_PROTOCOL:
        qd_compose_insert_string(body, conn->protocol_adaptor->name);
        break;

    case QDR_CONNECTION_DIR:
        if (conn->connection_info->dir == QD_INCOMING)
            qd_compose_insert_string(body, QDR_CONNECTION_DIR_IN);
        else
            qd_compose_insert_string(body, QDR_CONNECTION_DIR_OUT);
        break;

    case QDR_CONNECTION_CONTAINER_ID:
        if (conn->connection_info->container)
            qd_compose_insert_string(body, conn->connection_info->container);
        else
            qd_compose_insert_null(body);
        break;

    case QDR_CONNECTION_SASL_MECHANISMS:
        if (conn->connection_info->sasl_mechanisms) 
            qd_compose_insert_string(body, conn->connection_info->sasl_mechanisms);
	else
	    qd_compose_insert_null(body);
        break;

    case QDR_CONNECTION_IS_AUTHENTICATED:
        qd_compose_insert_bool(body, conn->connection_info->is_authenticated);
        break;

    case QDR_CONNECTION_USER:
        if (conn->connection_info->user)
            qd_compose_insert_string(body, conn->connection_info->user);
        else
            qd_compose_insert_null(body);
        break;

    case QDR_CONNECTION_IS_ENCRYPTED:
        qd_compose_insert_bool(body, conn->connection_info->is_encrypted);
        break;

    case QDR_CONNECTION_SSLPROTO:
        if (conn->connection_info->ssl_proto[0] != '\0')
            qd_compose_insert_string(body, conn->connection_info->ssl_proto);
        else
            qd_compose_insert_null(body);
        break;

    case QDR_CONNECTION_SSLCIPHER:
        if (conn->connection_info->ssl_cipher[0] != '\0')
            qd_compose_insert_string(body, conn->connection_info->ssl_cipher);
        else
            qd_compose_insert_null(body);
        break;

    case QDR_CONNECTION_SSLSSF:
        qd_compose_insert_long(body, conn->connection_info->ssl_ssf);
        break;

    case QDR_CONNECTION_TENANT:
        if (conn->tenant_space)
            qd_compose_insert_string(body, conn->tenant_space);
        else
            qd_compose_insert_null(body);
        break;

    case QDR_CONNECTION_TYPE:
        qd_compose_insert_string(body, CONNECTION_TYPE);
        break;

    case QDR_CONNECTION_SSL:
        qd_compose_insert_bool(body, conn->connection_info->ssl);
        break;

    case QDR_CONNECTION_OPENED:
        qd_compose_insert_bool(body, conn->connection_info->opened);
        break;

    case QDR_CONNECTION_ENABLE_PROTOCOL_TRACE:
        qd_compose_insert_bool(body, conn->enable_protocol_trace);
        break;

    case QDR_CONNECTION_ACTIVE:
        if (conn->role == QDR_ROLE_EDGE_CONNECTION) {
            if (core->router_mode == QD_ROUTER_MODE_INTERIOR) {
                qd_compose_insert_bool(body, true);
            }
            else if (core->router_mode  == QD_ROUTER_MODE_EDGE){
                if (core->active_edge_connection == conn)
                    qd_compose_insert_bool(body, true);
                else
                    qd_compose_insert_bool(body, false);
            }
        }
        else {
            qd_compose_insert_bool(body, true);
        }
        break;

    case QDR_CONNECTION_ADMIN_STATUS:
        text = conn->closed ? QDR_CONNECTION_ADMIN_STATUS_DELETED : QDR_CONNECTION_ADMIN_STATUS_ENABLED;
        qd_compose_insert_string(body, text);
        break;

    case QDR_CONNECTION_OPER_STATUS:
        text = conn->closed ? QDR_CONNECTION_OPER_STATUS_CLOSING : QDR_CONNECTION_OPER_STATUS_UP;
        qd_compose_insert_string(body, text);
        break;

    case QDR_CONNECTION_UPTIME_SECONDS:
        qd_compose_insert_uint(body, qdr_core_uptime_ticks(core) - conn->conn_uptime);
        break;

    case QDR_CONNECTION_LAST_DLV_SECONDS:
        if (conn->last_delivery_time==0)
            qd_compose_insert_null(body);
        else
            qd_compose_insert_uint(body, qdr_core_uptime_ticks(core) - conn->last_delivery_time);
        break;

    case QDR_CONNECTION_PROPERTIES: {
        pn_data_t *data = conn->connection_info->connection_properties;
        qd_compose_start_map(body);
        if (data) {
            pn_data_next(data);
            size_t count = pn_data_get_map(data);
            pn_data_enter(data);

            if (count > 0) {

                for (size_t i = 0; i < count/2; i++) {
                    const char *key   = 0;
                    // We are assuming for now that all keys are strings
                    qd_get_next_pn_data(&data, &key, 0);

                    const char *value_string = 0;
                    int value_int = 0;
                    // We are assuming for now that all values are either strings or integers
                    qd_get_next_pn_data(&data, &value_string, &value_int);

                    // We now have the key and the value. Do not insert the key or the value if key is empty
                    if (key) {
                        qd_compose_insert_string(body, key);
                        if (value_string)
                            qd_compose_insert_string(body, value_string);
                        else if (value_int)
                            qd_compose_insert_int(body, value_int);
                    }

                }
            }

            pn_data_exit(data);

        }
        qd_compose_end_map(body);
    }
    break;
    }
}