TaskOutcomeReader.cpp

Go to the documentation of this file.

#include "TaskOutcomeReader.h"
 
#include <iterator>
 
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/logging/Logging.h>
 
#include <RobotAPI/libraries/armem/util/util.h>
 
#include <RobotAPI/libraries/armem_task_outcome/aron/TaskOutcome.aron.generated.h>
#include <RobotAPI/libraries/armem_task_outcome/aron_conversions.h>
 
namespace armarx::armem::task_outcome::client
{
    TaskOutcomeReader::~TaskOutcomeReader() = default;
 
    armarx::armem::client::query::Builder
    TaskOutcomeReader::buildQuery(const Query& query) const
    {
        armarx::armem::client::query::Builder qb;
 
        armarx::armem::client::query::CoreSegmentSelector& coreSegmentQuery =
            qb.coreSegments().withName(properties().coreSegmentName);
 
        armarx::armem::client::query::ProviderSegmentSelector& providerQuery =
            [&]() -> armem::client::query::ProviderSegmentSelector&
        {
            if (not query.providerName.empty())
            {
                return coreSegmentQuery.providerSegments().withName(query.providerName);
            }
            return coreSegmentQuery.providerSegments().all();
        }();
 
        providerQuery.entities().all().snapshots().beforeOrAtTime(query.timestamp);
 
        return qb;
    }
 
    std::vector<TaskOutcome>
    TaskOutcomeReader::asTaskOutcomes(
        const wm::ProviderSegment& providerSegment,
        const DateTime& timestamp,
        const Duration& maxAge,
        const std::optional<TaskType>& taskTypeFilter,
        const std::optional<TaskOutcomeType>& outcomeFilter) const
    {
        ARMARX_TRACE;
        std::vector<TaskOutcome> outcomes;
 
        providerSegment.forEachEntity(
            [&](const wm::Entity& entity)
            {
                ARMARX_TRACE;
 
                const auto& entitySnapshot = entity.getLatestSnapshot();
 
                entitySnapshot.forEachInstance(
                    [&outcomes, &timestamp, &maxAge, &taskTypeFilter, &outcomeFilter](
                        const auto& entityInstance)
                    {
                        ARMARX_TRACE;
 
                        const core::time::Duration dtToNow =
                            timestamp - entityInstance.metadata().referencedTime;
 
                        if (dtToNow < maxAge and dtToNow.isPositive())
                        {
                            const auto aronDto =
                                tryCast<armarx::task_outcome::arondto::TaskOutcome>(
                                    entityInstance);
                            ARMARX_CHECK(aronDto) << "Failed casting to TaskOutcome";
 
                            TaskOutcome outcome;
                            fromAron(*aronDto, outcome);
 
                            // Client-side filtering
                            if (taskTypeFilter.has_value() &&
                                outcome.taskType != taskTypeFilter.value())
                            {
                                return;
                            }
                            if (outcomeFilter.has_value() &&
                                outcome.outcomeType != outcomeFilter.value())
                            {
                                return;
                            }
 
                            outcomes.push_back(outcome);
                        };
                    });
            });
 
        return outcomes;
    }
 
    std::string
    TaskOutcomeReader::propertyPrefix() const
    {
        return "mem.task_outcome.";
    }
 
    armarx::armem::client::util::SimpleReaderBase::Properties
    TaskOutcomeReader::defaultProperties() const
    {
        return {.memoryName = "TaskOutcome", .coreSegmentName = "TaskOutcome"};
    }
 
    TaskOutcomeReader::Result
    TaskOutcomeReader::query(const Query& query) const
    {
        ARMARX_TRACE;
 
        const auto qb = buildQuery(query);
 
        ARMARX_DEBUG << "[TaskOutcomeReader] query ... ";
 
        const armem::client::QueryResult qResult = memoryReader().query(qb.buildQueryInput());
 
        ARMARX_DEBUG << "[TaskOutcomeReader] result: " << qResult;
 
        if (not qResult.success)
        {
            ARMARX_WARNING << "Failed to query data from memory: " << qResult.errorMessage;
            return {.outcomes = {},
                    .status = Result::Status::Error,
                    .errorMessage = qResult.errorMessage};
        }
 
        ARMARX_TRACE;
        const auto coreSegment = qResult.memory.getCoreSegment(properties().coreSegmentName);
 
        if (query.providerName.empty())
        {
            ARMARX_TRACE;
 
            std::vector<TaskOutcome> allOutcomes;
 
            coreSegment.forEachProviderSegment(
                [this, &allOutcomes, &query](const auto& providerSegment)
                {
                    const std::vector<TaskOutcome> outcomes = asTaskOutcomes(
                        providerSegment,
                        query.timestamp,
                        query.maxAge,
                        query.taskTypeFilter,
                        query.outcomeFilter);
                    std::copy(
                        outcomes.begin(), outcomes.end(), std::back_inserter(allOutcomes));
                });
 
            if (allOutcomes.empty())
            {
                return {.outcomes = {},
                        .status = Result::Status::NoData,
                        .errorMessage = "No entities"};
            }
 
            return Result{.outcomes = allOutcomes, .status = Result::Status::Success};
        }
 
        ARMARX_TRACE;
 
        if (not coreSegment.hasProviderSegment(query.providerName))
        {
            ARMARX_INFO << deactivateSpam(5) << "Provider segment `" << query.providerName
                        << "` does not exist (yet).";
            return {.outcomes = {}, .status = Result::Status::NoData};
        }
 
        ARMARX_TRACE;
 
        const wm::ProviderSegment& providerSegment =
            coreSegment.getProviderSegment(query.providerName);
 
        if (providerSegment.empty())
        {
            ARMARX_WARNING << "No entities.";
            return {.outcomes = {},
                    .status = Result::Status::NoData,
                    .errorMessage = "No entities"};
        }
 
        try
        {
            ARMARX_TRACE;
 
            const auto outcomes = asTaskOutcomes(
                providerSegment,
                query.timestamp,
                query.maxAge,
                query.taskTypeFilter,
                query.outcomeFilter);
            return Result{.outcomes = outcomes, .status = Result::Status::Success};
        }
        catch (...)
        {
            return Result{.status = Result::Status::Error,
                          .errorMessage = GetHandledExceptionString()};
        }
    }
 
    std::vector<TaskOutcome>
    TaskOutcomeReader::queryByTaskType(TaskType taskType,
                                       const Duration& maxAge) const
    {
        Query q{.providerName = "",
                .taskTypeFilter = taskType,
                .outcomeFilter = std::nullopt,
                .timestamp = armem::Time::Now(),
                .maxAge = maxAge};
 
        auto result = query(q);
 
        if (result.status == Result::Status::Success)
        {
            return result.outcomes;
        }
 
        if (result.status == Result::Status::Error)
        {
            ARMARX_WARNING << "Failed to query task outcomes from memory";
        }
 
        return {};
    }
 
    std::vector<TaskOutcome>
    TaskOutcomeReader::queryFailures(const Duration& maxAge) const
    {
        Query q{.providerName = "",
                .taskTypeFilter = std::nullopt,
                .outcomeFilter = TaskOutcomeType::FAILURE,
                .timestamp = armem::Time::Now(),
                .maxAge = maxAge};
 
        auto result = query(q);
 
        if (result.status == Result::Status::Success)
        {
            return result.outcomes;
        }
 
        if (result.status == Result::Status::Error)
        {
            ARMARX_WARNING << "Failed to query task outcome failures from memory";
        }
 
        return {};
    }
 
} // namespace armarx::armem::task_outcome::client