DeviceStore.cpp

/*
 * Copyright (C) 2021 CERN
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 *
 * Created on: 2021-10-27
 *     Author: Michal Mysior <mmysior> <michal.mysior@cern.ch>
 *
 */
 
#include "DeviceStore.hpp"
 
#include <memory>
#include <sstream>
#include <unordered_map>
 
#include <ccut/ryml_internals.hpp>
#include <ccut/utils.hpp>
#include <logger/Logger.hpp>
 
#include "Exception.hpp"
 
using namespace smc;
namespace yml = ccut::yml;
 
static const std::string s_loggerCat{"smc:devicestore"};
 
namespace smc {
namespace internal {
 
size_t DeviceStore::probeDevices(const PlatformBase::Shared &platform)
{
    std::size_t newDeviceCount = 0;
 
    const std::lock_guard<std::mutex> lock(m_devicesMutex);
    for (DeviceBase::Shared device :
         platform->generateDevices(platform->getSupportedDevices()))
    {
        logger::notice(s_loggerCat) << "new device: " << device->uid();
        m_devices[device->uid()] = device;
        newDeviceCount++;
    }
 
    return newDeviceCount;
}
 
size_t DeviceStore::getDeviceCount() const
{
    const std::lock_guard<std::mutex> lock(m_devicesMutex);
    return m_devices.size();
}
 
std::shared_ptr<DeviceBase> DeviceStore::getDevice(
    const std::string &address) const
{
    try
    {
        const std::lock_guard<std::mutex> lock{m_devicesMutex};
        decltype(m_alias)::const_iterator it = m_alias.find(address);
        return (it != m_alias.end()) ? m_devices.at(it->second) :
                                       m_devices.at(address);
    }
    catch (const std::out_of_range &e)
    {
        throw Exception(ErrorCode::InvalidArguments,
                        "no such device: " + address);
    }
}
 
std::set<DeviceId> DeviceStore::getDeviceList() const
{
    const std::lock_guard<std::mutex> lock(m_devicesMutex);
    return ccut::keys(m_devices);
}
 
std::set<DeviceId> DeviceStore::getDeviceList(DeviceType type) const
{
    std::set<DeviceId> result;
    const std::lock_guard<std::mutex> lock(m_devicesMutex);
    for (const decltype(m_devices)::value_type &it : m_devices)
    {
        if (type == it.second->type())
            result.insert(it.first);
    }
    return result;
}
 
std::set<std::string> DeviceStore::getAliasList() const
{
    const std::lock_guard<std::mutex> lock(m_devicesMutex);
    return ccut::keys(m_alias);
}
 
DeviceId DeviceStore::getAlias(const std::string &alias) const
{
    const std::lock_guard<std::mutex> lock(m_devicesMutex);
    decltype(m_alias)::const_iterator it = m_alias.find(alias);
    if (it == m_alias.end())
        throw Exception(ErrorCode::InvalidArguments, "no such alias");
    return it->second;
}
 
bool DeviceStore::addAlias(const std::string &alias,
                           const DeviceId &deviceId,
                           bool override)
{
    const std::lock_guard<std::mutex> lock(m_devicesMutex);
    if (override || (m_alias.count(alias) == 0))
    {
        m_alias[alias] = deviceId;
        return true;
    }
    return false;
}
 
void DeviceStore::removeAlias(const std::string &alias)
{
    const std::lock_guard<std::mutex> lock(m_devicesMutex);
    m_alias.erase(alias);
}
 
void DeviceStore::loadAlias(const ccut::yml::NodeRef &aliasNode,
                            const ccut::yml::Parser *)
{
    try
    {
        if (!aliasNode.valid() || !aliasNode.is_map())
            throw Exception(ErrorCode::InvalidArguments,
                            "alias node must be a map");
 
        for (auto it : aliasNode)
        {
            std::string key;
            std::string value;
            it >> yml::default_to(yml::key(key), "") >>
                yml::default_to(value, "");
            if (!addAlias(key, value, false))
                logger::warning(s_loggerCat)
                    << "not loading alias " << key << " alias: already exist";
        }
    }
    catch (std::exception &ex)
    {
        logger::error(s_loggerCat) << "failed to parse alias: " << ex.what();
    }
}
 
} /* namespace internal */
} /* namespace smc */