DLRunConfig.cpp

Go to the documentation of this file.

#include <DatabaseUtils/DAQConfig/DLRunConfig.h>
#include <DatabaseUtils/DAQConfig/ConfigDataTree.h>
#include <DatabaseUtils/DAQConfig/DBColumnParams.h>
#include <DatabaseUtils/DAQConfig/DBColumnUtils.h>
#include <DatabaseUtils/DAQConfig/NamedConfigUtils.h>
#include <NovaDatabase/Table.h>
#include <NovaDAQUtilities/EnvVarCache.h>
#include <boost/algorithm/string.hpp>

namespace NOVADB = nova::database;

namespace dbutils {
namespace daqconfig {

/**
 * Creates a DataLogger run configuration object from the specified
 * list of subsystem configuration IDs.
 *
 * @param subsystemConfigIdList The list of subsystem
 *        configuration IDs.
 * @param dcmName The name of the DCM of interest.
 */
DLRunConfig::
DLRunConfig(const std::vector<int64_t>& subsystemConfigIdList)
{
    _primarySubsystemConfigId = -1;
    if (subsystemConfigIdList.size() > 0) {
        _primarySubsystemConfigId = subsystemConfigIdList[0];
        _hasValidData = _fetchAllData(subsystemConfigIdList);
    }
    else {
        _hasValidData = false;
    }
}

/**
 * Creates a DataLogger run configuration object from the specified
 * subsystem configuration specification.
 *
 * @param nameSpec The named configuration of interest.
 */
DLRunConfig::DLRunConfig(const SubsystemNameSpec& nameSpec)
{
    _primarySubsystemConfigId = -1;
    std::vector<int64_t> subsystemConfigIdList;
    if (NamedConfigUtils::
        getSubsystemConfigIdAncestry(nameSpec, subsystemConfigIdList)) {
        _primarySubsystemConfigId = subsystemConfigIdList[0];
        _hasValidData = _fetchAllData(subsystemConfigIdList);
    }
    else {
        _hasValidData = false;
    }
}

/**
 * Creates a DataLogger run configuration object from the specified
 * global configuration specification.
 *
 * @param nameSpec The named configuration of interest.
 */
DLRunConfig::DLRunConfig(const GlobalNameSpec& nameSpec)
{
    _primarySubsystemConfigId = -1;
    int64_t subsystemConfigId;
    bool status = NamedConfigUtils::
        getSubsystemConfigIdFromGlobalName(nameSpec,
                                           SubsystemNameSpec::
                                           DL_SUBSYSTEM_NAME,
                                           SubsystemNameSpec::
                                           RUN_CONFIG_TYPE,
                                           subsystemConfigId);

    std::vector<int64_t> subsystemConfigIdList;
    if (status) {
        IDSpec idSpec(subsystemConfigId, IDSpec::SUBSYSTEM, IDSpec::DAQ);
        status = NamedConfigUtils::
            getConfigIdAncestry(idSpec, subsystemConfigIdList);
    }

    if (status) {
        _primarySubsystemConfigId = subsystemConfigIdList[0];
        _hasValidData = _fetchAllData(subsystemConfigIdList);
    }
    else {
        _hasValidData = false;
    }
}

/**
 * Creates a DataLogger run configuration object from the specified
 * global configuration ID.
 *
 * @param globalConfigId The ID of the global configuration of interest.
 */
DLRunConfig::DLRunConfig(const int64_t& globalConfigId)
{
    IDSpec idSpec(globalConfigId, IDSpec::GLOBAL, IDSpec::DAQ);
    _primarySubsystemConfigId = -1;
    std::vector<int64_t> subsystemConfigIdList;
    if (NamedConfigUtils::
        getSubsystemConfigIdAncestryFromGlobalId(idSpec,
                                                 SubsystemNameSpec::
                                                 DL_SUBSYSTEM_NAME,
                                                 SubsystemNameSpec::
                                                 RUN_CONFIG_TYPE,
                                                 subsystemConfigIdList)) {
        _primarySubsystemConfigId = subsystemConfigIdList[0];
        _hasValidData = _fetchAllData(subsystemConfigIdList);
    }
    else {
        _hasValidData = false;
    }
}

bool DLRunConfig::
_fetchAllData(const std::vector<int64_t>& subsystemConfigIdList)
{
    bool status = true;
    std::string fname;

    // for the DL configuration, inheritance is not used,
    // so only the first subsystem ID is relevant
    int64_t subsystemConfigId = subsystemConfigIdList[0];

    if (status) {
        fname = "NovaDatabase/tables/DAQConfig/DataLoggerStreams.xml";
        status = _fetchStreamData(fname, subsystemConfigId);
    }
    if (status) {
        fname = "NovaDatabase/tables/DAQConfig/DataLoggerSystemParameters.xml";
        status = _fetchSystemData(fname, subsystemConfigId);
    }

    return status;
}

bool DLRunConfig::
_fetchStreamData(const std::string& tableDefinitionFileName,
                 const int64_t& subsystemConfigId)
{
    boost::shared_ptr<NOVADB::Table> dbt;
    dbt.reset(new NOVADB::Table(tableDefinitionFileName));
    std::string detName = 
      novadaq::EnvVarCache::getInstance().getEnvVar("NOVADAQ_ENVIRONMENT");
    dbt->SetDetector(detName);
    std::string dbUser =
      novadaq::EnvVarCache::getInstance().getEnvVar("CFGMGR_DB_USER");
    if (dbUser.length() > 0) {dbt->SetUser(dbUser);}
    if (! dbt->GetConnection()) {return false;}
    if (! dbt->ExistsInDB()) {return false;}

    dbt->Clear();
    dbt->SetValidityRange(NamedConfigUtils::SUBSYSCFGID_COLUMN_NAME,
                          subsystemConfigId);
    if (! dbt->LoadFromDB()) {return false;}

    std::vector<std::string> colNames = dbt->GetColNames();
    NOVADB::Row* rowPtr;
    NOVADB::Column* colPtr;
    for (int rowIdx = 0; rowIdx < dbt->NRow(); ++rowIdx) {
        boost::shared_ptr<SimpleParameterSet>
            streamParamSet(new SimpleParameterSet());
        rowPtr = dbt->GetRow(rowIdx);

        for (uint32_t colIdx = 0; colIdx < colNames.size(); ++colIdx) {
            std::string colName = boost::to_lower_copy(colNames[colIdx]);
            if (DBColumnUtils::isInfrastructureColumn(colName)) {continue;}
            if (DBColumnUtils::isSubsystemConfigReferenceColumn(colName)) {
                continue;
            }

            std::string valueString;
            colPtr = rowPtr->Col(colName);
            if (! colPtr->Get(valueString)) {
                return false;
            }
            streamParamSet->put(colName, valueString);
        }

        _streamList.push_back(streamParamSet);
    }

    return true;
}

bool DLRunConfig::
_fetchSystemData(const std::string& tableDefinitionFileName,
                 const int64_t& subsystemConfigId)
{
    boost::shared_ptr<NOVADB::Table> dbt;
    dbt.reset(new NOVADB::Table(tableDefinitionFileName));
    std::string detName = 
      novadaq::EnvVarCache::getInstance().getEnvVar("NOVADAQ_ENVIRONMENT");
    dbt->SetDetector(detName);
    std::string dbUser =
        novadaq::EnvVarCache::getInstance().getEnvVar("CFGMGR_DB_USER");
    if (dbUser.length() > 0) {dbt->SetUser(dbUser);}
    if (! dbt->GetConnection()) {return false;}
    if (! dbt->ExistsInDB()) {return false;}

    dbt->Clear();
    dbt->SetValidityRange(NamedConfigUtils::SUBSYSCFGID_COLUMN_NAME,
                          subsystemConfigId);
    if (! dbt->LoadFromDB()) {return false;}

    if (dbt->NRow() != 1) {return false;}

    NOVADB::Row* rowPtr = dbt->GetRow(0);
    NOVADB::Column* colPtr = rowPtr->Col("outputPath");
    if (! colPtr->Get(_outputPath)) {
        return false;
    }

    return true;
}

} // end of namespace daqconfig
} // end of namespace dbutils