sai_status_t RedisRemoteSaiInterface::setRedisExtensionAttribute()

in lib/RedisRemoteSaiInterface.cpp [279:496]

• 131 lines of code
• 27 McCabe index (conditional complexity)

sai_status_t RedisRemoteSaiInterface::setRedisExtensionAttribute(
        _In_ sai_object_type_t objectType,
        _In_ sai_object_id_t objectId,
        _In_ const sai_attribute_t *attr)
{
    SWSS_LOG_ENTER();

    if (attr == nullptr)
    {
        SWSS_LOG_ERROR("attr pointer is null");

        return SAI_STATUS_FAILURE;
    }

    /*
     * NOTE: that this will work without
     * switch being created.
     */

    switch (attr->id)
    {
        case SAI_REDIS_SWITCH_ATTR_PERFORM_LOG_ROTATE:

            if (m_recorder)
            {
                m_recorder->requestLogRotate();
            }

            return SAI_STATUS_SUCCESS;

        case SAI_REDIS_SWITCH_ATTR_RECORD:

            if (m_recorder)
            {
                m_recorder->enableRecording(attr->value.booldata);
            }

            return SAI_STATUS_SUCCESS;

        case SAI_REDIS_SWITCH_ATTR_NOTIFY_SYNCD:

            return sai_redis_notify_syncd(objectId, attr);

        case SAI_REDIS_SWITCH_ATTR_USE_TEMP_VIEW:

            m_useTempView = attr->value.booldata;

            return SAI_STATUS_SUCCESS;

        case SAI_REDIS_SWITCH_ATTR_RECORD_STATS:

            m_recorder->recordStats(attr->value.booldata);

            return SAI_STATUS_SUCCESS;

        case SAI_REDIS_SWITCH_ATTR_SYNC_OPERATION_RESPONSE_TIMEOUT:

            m_responseTimeoutMs = attr->value.u64;

            m_communicationChannel->setResponseTimeout(m_responseTimeoutMs);

            SWSS_LOG_NOTICE("set response timeout to %lu ms", m_responseTimeoutMs);

            return SAI_STATUS_SUCCESS;

        case SAI_REDIS_SWITCH_ATTR_SYNC_MODE:

            SWSS_LOG_WARN("sync mode is depreacated, use communication mode");

            m_syncMode = attr->value.booldata;

            if (m_contextConfig->m_zmqEnable)
            {
                SWSS_LOG_NOTICE("zmq enabled, forcing sync mode");

                m_syncMode = true;
            }

            if (m_syncMode)
            {
                SWSS_LOG_NOTICE("disabling buffered pipeline in sync mode");

                m_communicationChannel->setBuffered(false);
            }

            return SAI_STATUS_SUCCESS;

        case SAI_REDIS_SWITCH_ATTR_REDIS_COMMUNICATION_MODE:

            m_redisCommunicationMode = (sai_redis_communication_mode_t)attr->value.s32;

            if (m_contextConfig->m_zmqEnable)
            {
                SWSS_LOG_NOTICE("zmq enabled via context config");

                m_redisCommunicationMode = SAI_REDIS_COMMUNICATION_MODE_ZMQ_SYNC;
            }

            m_communicationChannel = nullptr;

            switch (m_redisCommunicationMode)
            {
                case SAI_REDIS_COMMUNICATION_MODE_REDIS_ASYNC:

                    SWSS_LOG_NOTICE("enabling redis async mode");

                    m_syncMode = false;

                    m_communicationChannel = std::make_shared<RedisChannel>(
                            m_contextConfig->m_dbAsic,
                            std::bind(&RedisRemoteSaiInterface::handleNotification, this, _1, _2, _3));

                    m_communicationChannel->setResponseTimeout(m_responseTimeoutMs);

                    m_communicationChannel->setBuffered(true);

                    return SAI_STATUS_SUCCESS;

                case SAI_REDIS_COMMUNICATION_MODE_REDIS_SYNC:

                    SWSS_LOG_NOTICE("enabling redis sync mode");

                    m_syncMode = true;

                    m_communicationChannel = std::make_shared<RedisChannel>(
                            m_contextConfig->m_dbAsic,
                            std::bind(&RedisRemoteSaiInterface::handleNotification, this, _1, _2, _3));

                    m_communicationChannel->setResponseTimeout(m_responseTimeoutMs);

                    m_communicationChannel->setBuffered(false);

                    return SAI_STATUS_SUCCESS;

                case SAI_REDIS_COMMUNICATION_MODE_ZMQ_SYNC:

                    m_contextConfig->m_zmqEnable = true;

                    // main communication channel was created at initialize method
                    // so this command will replace it with zmq channel

                    m_communicationChannel = std::make_shared<ZeroMQChannel>(
                            m_contextConfig->m_zmqEndpoint,
                            m_contextConfig->m_zmqNtfEndpoint,
                            std::bind(&RedisRemoteSaiInterface::handleNotification, this, _1, _2, _3));

                    m_communicationChannel->setResponseTimeout(m_responseTimeoutMs);

                    SWSS_LOG_NOTICE("zmq enabled, forcing sync mode");

                    m_syncMode = true;

                    SWSS_LOG_NOTICE("disabling buffered pipeline in sync mode");

                    m_communicationChannel->setBuffered(false);

                    return SAI_STATUS_SUCCESS;

                default:

                    SWSS_LOG_ERROR("invalid communication mode value: %d", m_redisCommunicationMode);

                    return SAI_STATUS_NOT_SUPPORTED;
            }

        case SAI_REDIS_SWITCH_ATTR_USE_PIPELINE:

            if (m_syncMode)
            {
                SWSS_LOG_WARN("use pipeline is not supported in sync mode");

                return SAI_STATUS_NOT_SUPPORTED;
            }

            m_communicationChannel->setBuffered(attr->value.booldata);

            return SAI_STATUS_SUCCESS;

        case SAI_REDIS_SWITCH_ATTR_FLUSH:

            m_communicationChannel->flush();

            return SAI_STATUS_SUCCESS;

        case SAI_REDIS_SWITCH_ATTR_RECORDING_OUTPUT_DIR:

            if (m_recorder)
            {
                m_recorder->setRecordingOutputDirectory(*attr);
            }

            return SAI_STATUS_SUCCESS;

        case SAI_REDIS_SWITCH_ATTR_RECORDING_FILENAME:

            if (m_recorder)
            {
                m_recorder->setRecordingFilename(*attr);
            }

            return SAI_STATUS_SUCCESS;

        case SAI_REDIS_SWITCH_ATTR_FLEX_COUNTER_GROUP:
            return notifyCounterGroupOperations(objectId,
                                                reinterpret_cast<sai_redis_flex_counter_group_parameter_t*>(attr->value.ptr));

        case SAI_REDIS_SWITCH_ATTR_FLEX_COUNTER:
            return notifyCounterOperations(objectId,
                                           reinterpret_cast<sai_redis_flex_counter_parameter_t*>(attr->value.ptr));

        default:
            break;
    }

    SWSS_LOG_ERROR("unknown redis extension attribute: %d", attr->id);

    return SAI_STATUS_FAILURE;
}