ptp_instance.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 "ptp_error.hpp"
#include "ptp_local_clock.hpp"
#include "ptp_port.hpp"
#include "detail/ptp_stats.hpp"
#include "datasets/ptp_current_ds.hpp"
#include "datasets/ptp_default_ds.hpp"
#include "datasets/ptp_parent_ds.hpp"
#include "datasets/ptp_time_properties_ds.hpp"
#include "ravennakit/core/util/subscriber_list.hpp"
#include "ravennakit/core/expected.hpp"
#include "ravennakit/core/net/interfaces/network_interface_config.hpp"
#include "ravennakit/core/util/throttle.hpp"
 
#include <boost/lockfree/spsc_value.hpp>
 
namespace rav::ptp {

class Instance {
  public:
    struct Configuration {
        uint8_t domain_number {};
    };
 
    class Subscriber {
      public:
        virtual ~Subscriber() = default;

        virtual void ptp_parent_changed(const ParentDs& parent) {
            std::ignore = parent;
        }

        virtual void ptp_port_changed_state(const Port& port) {
            std::ignore = port;
        }

        virtual void ptp_port_removed(const uint16_t port_number) {
            std::ignore = port_number;
        }

        virtual void ptp_configuration_updated(const Configuration& config) {
            std::ignore = config;
        }

        virtual void ptp_stats_updated(const Stats& ptp_stats) {
            std::ignore = ptp_stats;
        }

        const LocalClock& get_local_clock();
 
      private:
        friend class Instance;
        boost::lockfree::spsc_value<LocalClock> local_clock_buffer_;
        LocalClock local_clock_;
    };

    explicit Instance(boost::asio::io_context& io_context);
 
    ~Instance();

    [[nodiscard]] bool subscribe(Subscriber* subscriber);

    [[nodiscard]] bool unsubscribe(const Subscriber* subscriber);

    [[nodiscard]] tl::expected<void, std::string> set_configuration(Configuration config);

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

    [[nodiscard]] tl::expected<void, Error> add_port(uint16_t port_number, const boost::asio::ip::address_v4& interface_address);

    [[nodiscard]] tl::expected<void, Error> add_or_update_port(uint16_t port_number, const boost::asio::ip::address_v4& interface_address);

    [[nodiscard]] tl::expected<void, Error> update_ports(const std::vector<ip_address_v4>& ports);

    [[nodiscard]] bool has_port(uint16_t port_number) const;

    [[nodiscard]] bool remove_port(uint16_t port_number);

    [[nodiscard]] size_t get_port_count() const;

    [[nodiscard]] bool set_port_interface(uint16_t port_number, const boost::asio::ip::address_v4& interface_address) const;

    [[nodiscard]] const DefaultDs& get_default_ds() const;

    [[nodiscard]] const ParentDs& get_parent_ds() const;

    [[nodiscard]] const TimePropertiesDs& get_time_properties_ds() const;

    bool set_recommended_state(StateDecisionCode state_decision_code, const std::optional<AnnounceMessage>& announce_message);

    void execute_state_decision_event();

    [[nodiscard]] bool should_process_ptp_messages(const MessageHeader& header) const;

    [[nodiscard]] State get_state_for_decision_code(StateDecisionCode code) const;

    [[nodiscard]] Timestamp get_local_ptp_time() const;

    void update_local_ptp_clock(const Measurement<double>& measurement);
 
  private:
    boost::asio::io_context& io_context_;
    Configuration config_;
    boost::asio::steady_timer state_decision_timer_;
    DefaultDs default_ds_;
    CurrentDs current_ds_;
    ParentDs parent_ds_;
    TimePropertiesDs time_properties_ds_;
    std::vector<std::unique_ptr<Port>> ports_;
    LocalClock local_clock_;
    Stats ptp_stats_;
    Throttle<void> stats_callback_throttle_ {std::chrono::seconds(5)};
    SubscriberList<Subscriber> subscribers_;
 
    [[nodiscard]] uint16_t get_next_available_port_number() const;
    void schedule_state_decision_timer();
};
 
void tag_invoke(const boost::json::value_from_tag&, boost::json::value& jv, const Instance::Configuration& config);
 
Instance::Configuration tag_invoke(const boost::json::value_to_tag<Instance::Configuration>&, const boost::json::value& jv);
 
}  // namespace rav::ptp