DeviceDefender.h

Go to the documentation of this file.

#pragma once
 
#include <aws/iotdevicedefender/Exports.h>
 
#include <aws/crt/io/EventLoopGroup.h>
#include <aws/crt/mqtt/Mqtt5Client.h>
#include <aws/crt/mqtt/MqttClient.h>
 
#include <aws/iotdevice/device_defender.h>
 
namespace Aws
{
    namespace Crt
    {
 
    }
 
    namespace Iotdevicedefenderv1
    {
 
        class ReportTask;
        class ReportTaskBuilder;
 
        using OnTaskCancelledHandler = std::function<void(void *)>;
 
        using ReportFormat = aws_iotdevice_defender_report_format;
 
        using CustomMetricNumberFunction = std::function<int(double *)>;
        using CustomMetricNumberListFunction = std::function<int(Crt::Vector<double> *)>;
        using CustomMetricStringListFunction = std::function<int(Crt::Vector<Crt::String> *)>;
        using CustomMetricIpListFunction = std::function<int(Crt::Vector<Crt::String> *)>;
 
        class AWS_IOTDEVICEDEFENDER_API CustomMetricBase;
 
        enum class ReportTaskStatus
        {
            Ready = 0,
            Running = 1,
            Stopped = 2,
        };
 
        class AWS_IOTDEVICEDEFENDER_API ReportTask final
        {
            friend ReportTaskBuilder;
 
          public:
            ~ReportTask();
            ReportTask(const ReportTask &) = delete;
            ReportTask &operator=(const ReportTask &) = delete;
 
            void StopTask() noexcept;
 
            int StartTask() noexcept;
 
            ReportTaskStatus GetStatus() noexcept;
 
            OnTaskCancelledHandler OnTaskCancelled;
 
            void *cancellationUserdata;
 
            int LastError() const noexcept { return m_lastError; }
 
            void RegisterCustomMetricNumber(
                const Crt::String metricName,
                CustomMetricNumberFunction metricFunc) noexcept;
 
            void RegisterCustomMetricNumberList(
                const Crt::String metricName,
                CustomMetricNumberListFunction metricFunc) noexcept;
 
            void RegisterCustomMetricStringList(
                const Crt::String metricName,
                CustomMetricStringListFunction metricFunc) noexcept;
 
            void RegisterCustomMetricIpAddressList(
                const Crt::String metricName,
                CustomMetricIpListFunction metricFunc) noexcept;
 
          private:
            Crt::Allocator *m_allocator;
            ReportTaskStatus m_status;
            aws_iotdevice_defender_task_config *m_taskConfig;
            aws_iotdevice_defender_task *m_owningTask;
            int m_lastError;
            std::shared_ptr<Crt::Mqtt::MqttConnection> m_mqttConnection;
            Crt::Io::EventLoopGroup &m_eventLoopGroup;
 
            ReportTask(
                Crt::Allocator *allocator,
                std::shared_ptr<Crt::Mqtt::MqttConnection> mqttConnection,
                const Crt::String &thingName,
                Crt::Io::EventLoopGroup &eventLoopGroup,
                ReportFormat reportFormat,
                uint32_t taskPeriodSeconds,
                uint32_t networkConnectionSamplePeriodSeconds,
                OnTaskCancelledHandler &&onCancelled = NULL,
                void *cancellationUserdata = nullptr) noexcept;
 
            static void s_onDefenderV1TaskCancelled(void *userData);
 
            // Holds all of the custom metrics created for this task. These are pointers that will be
            // automatically created and cleaned by ReportTask when it is destroyed.
            Crt::Vector<std::shared_ptr<CustomMetricBase>> storedCustomMetrics;
        };
 
        class AWS_IOTDEVICEDEFENDER_API ReportTaskBuilder final
        {
          public:
            ReportTaskBuilder(
                Crt::Allocator *allocator,
                std::shared_ptr<Crt::Mqtt::MqttConnection> mqttConnection,
                Crt::Io::EventLoopGroup &eventLoopGroup,
                const Crt::String &thingName);
 
            ReportTaskBuilder(
                Crt::Allocator *allocator,
                std::shared_ptr<Crt::Mqtt5::Mqtt5Client> mqtt5Client,
                Crt::Io::EventLoopGroup &eventLoopGroup,
                const Crt::String &thingName);
 
            ReportTaskBuilder &WithReportFormat(ReportFormat reportFormat) noexcept;
 
            ReportTaskBuilder &WithTaskPeriodSeconds(uint32_t taskPeriodSeconds) noexcept;
 
            ReportTaskBuilder &WithNetworkConnectionSamplePeriodSeconds(
                uint32_t networkConnectionSamplePeriodSeconds) noexcept;
 
            ReportTaskBuilder &WithTaskCancelledHandler(OnTaskCancelledHandler &&onCancelled) noexcept;
 
            ReportTaskBuilder &WithTaskCancellationUserData(void *cancellationUserdata) noexcept;
 
            std::shared_ptr<ReportTask> Build() noexcept;
 
          private:
            Crt::Allocator *m_allocator;
            std::shared_ptr<Crt::Mqtt::MqttConnection> m_mqttConnection;
            Crt::String m_thingName;
            Crt::Io::EventLoopGroup &m_eventLoopGroup;
            ReportFormat m_reportFormat;
            uint32_t m_taskPeriodSeconds;
            uint32_t m_networkConnectionSamplePeriodSeconds;
            OnTaskCancelledHandler m_onCancelled;
            void *m_cancellationUserdata;
        };
 
    } // namespace Iotdevicedefenderv1
} // namespace Aws