nmos_node.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
/*
 * Project: RAVENNAKIT (RAVENNA / AES67 / ST2110-30 SDK)
 * Copyright (c) 2024-2025 Sound on Digital
 *
 * This file is part of RAVENNAKIT.
 *
 * RAVENNAKIT is dual-licensed:
 *   1) Under the terms of the GNU Affero General Public License as published by
 *      the Free Software Foundation, either version 3 of the License, or
 *      (at your option) any later version (the "AGPL License"); and
 *   2) Under a commercial license from Sound on Digital, for customers who
 *      cannot (or do not wish to) comply with the AGPL License terms.
 *
 * If you obtained this file under the AGPL License, you may redistribute it
 * and/or modify it under the terms of the AGPL License. See the LICENSE
 * file in the project root for details.
 *
 * For commercial licensing, support, and other inquiries, please visit:
 *
 *     https://ravennakit.com
 *
 */
 
#pragma once
 
#include "detail/nmos_api_version.hpp"
#include "detail/nmos_error.hpp"
#include "detail/nmos_operating_mode.hpp"
#include "detail/nmos_registry_browser.hpp"
#include "models/nmos_device.hpp"
#include "models/nmos_flow_audio_raw.hpp"
#include "models/nmos_receiver_audio.hpp"
#include "models/nmos_self.hpp"
#include "models/nmos_sender.hpp"
#include "models/nmos_source.hpp"
#include "ravennakit/core/json.hpp"
#include "ravennakit/core/net/http/http_client.hpp"
#include "ravennakit/core/net/http/http_server.hpp"
#include "ravennakit/core/net/interfaces/network_interface_config.hpp"
#include "ravennakit/ptp/ptp_instance.hpp"
 
#include <boost/uuid.hpp>
#include <boost/system/result.hpp>
#include <fmt/ostream.h>
 
#include <unordered_map>
 
namespace rav::nmos {

class Node: public ptp::Instance::Subscriber {
  public:
    static std::array<ApiVersion, 2> k_node_api_versions;
    static std::array<ApiVersion, 2> k_connection_api_versions;
    static constexpr auto k_default_timeout = std::chrono::milliseconds(2000);
    static constexpr auto k_internal_clock_name = "clk0";
    static constexpr auto k_ptp_clock_name = "clk1";

    struct Configuration {
        boost::uuids::uuid id;  // The UUID of the NMOS node.
        OperationMode operation_mode {OperationMode::mdns_p2p};
        ApiVersion api_version {1, 3};
        std::string registry_address;  // For when operation_mode is registered and discover_mode is manual.
        bool enabled {false};          // Whether the node is enabled or not.
        uint16_t api_port {0};         // The port of the local APIs (the node and connection apis).
        std::string label;             // Freeform string label for the resource.
        std::string description;       // Detailed description of the resource.

        [[nodiscard]] boost::system::result<void, Error> validate() const;

        [[nodiscard]] boost::json::object to_json() const;

        static boost::system::result<Configuration, std::string> from_json(const boost::json::value& json);
 
        [[nodiscard]] auto constexpr tie() const {
            return std::tie(id, operation_mode, api_version, registry_address, enabled, label, description, api_port);
        }
 
        friend bool operator==(const Configuration& lhs, const Configuration& rhs) {
            return lhs.tie() == rhs.tie();
        }
 
        friend bool operator!=(const Configuration& lhs, const Configuration& rhs) {
            return lhs.tie() != rhs.tie();
        }
    };
 
    struct StatusInfo {
        std::string name;
        std::string address;
        uint16_t api_port {};
    };
 
    enum class Status { disabled, discovering, connecting, connected, registered, p2p, error };
 
    SafeFunction<void(const Status& status, const StatusInfo& status_info)> on_status_changed;
    SafeFunction<void(const Configuration& config)> on_configuration_changed;
 
    explicit Node(
        boost::asio::io_context& io_context, ptp::Instance& ptp_instance, std::unique_ptr<RegistryBrowserBase> registry_browser = nullptr,
        std::unique_ptr<HttpClientBase> http_client = nullptr
    );
 
    ~Node() override;

    [[nodiscard]] boost::system::result<void, Error> start();

    void stop();

    [[nodiscard]] tl::expected<void, Error> set_configuration(Configuration new_configuration, bool force_update = false);

    [[nodiscard]] const Configuration& get_configuration() const;

    [[nodiscard]] boost::asio::ip::tcp::endpoint get_local_endpoint() const;

    [[nodiscard]] bool add_or_update_device(Device* device);

    [[nodiscard]] const Device* find_device(const boost::uuids::uuid& uuid) const;

    [[nodiscard]] bool remove_device(Device* device);

    [[nodiscard]] bool add_or_update_flow(FlowAudioRaw* flow);

    [[nodiscard]] const FlowAudioRaw* find_flow(const boost::uuids::uuid& uuid) const;

    [[nodiscard]] bool remove_flow(FlowAudioRaw* flow);

    [[nodiscard]] bool add_or_update_receiver(ReceiverAudio* receiver);

    [[nodiscard]] const ReceiverAudio* find_receiver(const boost::uuids::uuid& uuid) const;

    [[nodiscard]] bool remove_receiver(ReceiverAudio* receiver);

    [[nodiscard]] bool add_or_update_sender(Sender* sender);

    [[nodiscard]] Sender* find_sender(const boost::uuids::uuid& uuid) const;

    [[nodiscard]] bool remove_sender(Sender* sender);

    [[nodiscard]] bool add_or_update_source(SourceAudio* source);

    [[nodiscard]] const SourceAudio* find_source(const boost::uuids::uuid& uuid) const;

    [[nodiscard]] bool remove_source(SourceAudio* source);

    [[nodiscard]] const boost::uuids::uuid& get_uuid() const;

    [[nodiscard]] const std::vector<Device*>& get_devices() const;

    [[nodiscard]] const std::vector<FlowAudioRaw*>& get_flows() const;

    [[nodiscard]] const std::vector<ReceiverAudio*>& get_receivers() const;

    [[nodiscard]] const std::vector<Sender*>& get_senders() const;

    [[nodiscard]] const std::vector<SourceAudio*>& get_sources() const;

    [[nodiscard]] const Status& get_status() const;

    [[nodiscard]] const StatusInfo& get_registry_info() const;

    void set_network_interface_config(NetworkInterfaceConfig config);

    [[nodiscard]] static std::optional<size_t> index_of_supported_api_version(const ApiVersion& version);
 
    void ptp_parent_changed(const ptp::ParentDs& parent) override;
    void ptp_port_changed_state(const ptp::Port& port) override;
 
  private:
    static constexpr uint8_t k_max_failed_heartbeats = 5;
    static constexpr auto k_heartbeat_interval = std::chrono::seconds(5);
    static constexpr size_t k_clock_ptp_index = 1;
 
    ptp::Instance& ptp_instance_;
    Self self_;
    std::vector<Device*> devices_;
    std::vector<FlowAudioRaw*> flows_;
    std::vector<ReceiverAudio*> receivers_;
    std::vector<Sender*> senders_;
    std::vector<SourceAudio*> sources_;
 
    Configuration configuration_;
    Status status_ {Status::disabled};
    int post_resource_error_count_ = 0;
    NetworkInterfaceConfig network_interface_config_;
 
    std::optional<dnssd::ServiceDescription> selected_registry_;
    StatusInfo status_info_;
 
    HttpServer http_server_;
    std::unique_ptr<HttpClientBase> http_client_;
    std::unique_ptr<RegistryBrowserBase> registry_browser_;
    AsioTimer timer_;
 
    uint8_t failed_heartbeat_count_ = 0;
    AsioTimer heartbeat_timer_;  // Keep below connector_ to avoid dangling reference
    Version current_version_;
 
    [[nodiscard]] boost::system::result<void, Error> start_internal();
    void stop_internal();
 
    void register_async();
    void unregister_async();
    void post_resource_async(std::string type, boost::json::value resource);
    void delete_resource_async(std::string resource_type, const boost::uuids::uuid& id);
    void update_self();
    void send_heartbeat_async();
    void connect_to_registry_async();
    void connect_to_registry_async(std::string_view host, std::string_view service);
 
    [[nodiscard]] bool add_receiver_to_device(const ReceiverAudio& receiver) const;
    [[nodiscard]] bool add_sender_to_device(const Sender& sender) const;
 
    bool select_registry(const dnssd::ServiceDescription& desc);
    void handle_registry_discovered(const dnssd::ServiceDescription& desc);
 
    void set_status(Status new_status);
    void update_all_resources_to_now();
    void send_updated_resources_async();
    void update_device(Device& device);
};
 
const char* to_string(const Node::Status& status);
 
void tag_invoke(const boost::json::value_from_tag&, boost::json::value& jv, const Node::Configuration& config);
 
}  // namespace rav::nmos