Refactor user defined handlers

Author: jonathan-r-thorpe

Development/nmos-cpp-node/main.cpp

@@ -138,7 +138,7 @@ int main(int argc, char* argv[])
                 .on_request_authorization_code(nmos::experimental::make_request_authorization_code_handler(gate)); // may be omitted, only required for OAuth client which is using the Authorization Code Flow to obtain the access token
         }
 
-        nmos::experimental::control_protocol_state control_protocol_state(node_implementation.get_lost_packet_method_handler, node_implementation.get_late_packet_method_handler, node_implementation.reset_packet_counters_method_handler, node_implementation.control_protocol_property_changed);
+        nmos::experimental::control_protocol_state control_protocol_state(node_implementation.get_lost_packet_counters, node_implementation.get_late_packet_counters, node_implementation.reset_packet_counters, node_implementation.control_protocol_property_changed);
         if (0 <= nmos::fields::control_protocol_ws_port(node_model.settings))
         {
             node_implementation

Development/nmos-cpp-node/node_implementation.cpp

@@ -1715,9 +1715,9 @@ nmos::control_protocol_property_changed_handler make_node_implementation_control
 }
 
 // Example Receiver Status Monitor callback for get_lost_packets method
-nmos::experimental::control_protocol_method_handler make_node_implementation_get_lost_packet_method_handler()
+nmos::get_lost_packet_counters_handler make_node_implementation_get_lost_packet_counters_handler()
 {
-    return [&](nmos::resources& resources, const nmos::resource& resource, const web::json::value& arguments, bool is_deprecated, slog::base_gate& gate)
+    return [&]()
     {
         // Implement polling of lost packet count here
         uint16_t lost_packet_count(0);
@@ -1726,9 +1726,9 @@ nmos::experimental::control_protocol_method_handler make_node_implementation_get
 }
 
 // Example Receiver Status Monitor callback for get_late_packets method
-nmos::experimental::control_protocol_method_handler make_node_implementation_get_late_packet_method_handler()
+nmos::get_late_packet_counters_handler make_node_implementation_get_late_packet_counters_handler()
 {
-    return [&](nmos::resources& resources, const nmos::resource& resource, const web::json::value& arguments, bool is_deprecated, slog::base_gate& gate)
+    return [&]()
     {
         // Implement polling of late packet count here
         uint16_t late_packet_count(0);
@@ -1737,9 +1737,9 @@ nmos::experimental::control_protocol_method_handler make_node_implementation_get
 }
 
 // Example Receiver Status Monitor callback for reset_packet_counters method
-nmos::experimental::control_protocol_method_handler make_node_implementation_reset_packet_counters_method_handler()
+nmos::reset_packet_counters_handler make_node_implementation_reset_packet_counters_handler()
 {
-    return [&](nmos::resources& resources, const nmos::resource& resource, const web::json::value& arguments, bool is_deprecated, slog::base_gate& gate)
+    return [&]()
     {
         // Implement reset of lost and late packet counters
         return nmos::details::make_nc_method_result({ nmos::nc_method_status::ok });
@@ -1904,7 +1904,7 @@ nmos::experimental::node_implementation make_node_implementation(nmos::node_mode
         .on_validate_channelmapping_output_map(make_node_implementation_map_validator()) // may be omitted if not required
         .on_channelmapping_activated(make_node_implementation_channelmapping_activation_handler(gate))
         .on_control_protocol_property_changed(make_node_implementation_control_protocol_property_changed_handler(gate)) // may be omitted if IS-12 not required
-        .on_get_lost_packet(make_node_implementation_get_lost_packet_method_handler())
-        .on_get_late_packet(make_node_implementation_get_late_packet_method_handler())
-        .on_reset_packet_counters(make_node_implementation_reset_packet_counters_method_handler());
+        .on_get_lost_packet_counters(make_node_implementation_get_lost_packet_counters_handler())
+        .on_get_late_packet_counters(make_node_implementation_get_late_packet_counters_handler())
+        .on_reset_packet_counters(make_node_implementation_reset_packet_counters_handler());
 }

Development/nmos/control_protocol_handlers.h

@@ -36,6 +36,12 @@ namespace nmos
     // this callback should not throw exceptions, as the relevant property will already has been changed and those changes will not be rolled back
     typedef std::function<void(const nmos::resource& resource, const utility::string_t& property_name, int index)> control_protocol_property_changed_handler;
 
+    // Receiver status callbacks
+    // these callbacks should not throw exceptions
+    typedef std::function<web::json::value(void)> get_lost_packet_counters_handler;
+    typedef std::function<web::json::value(void)> get_late_packet_counters_handler;
+    typedef std::function<web::json::value(void)> reset_packet_counters_handler;
+
     namespace experimental
     {
         // control method handler definition

Development/nmos/control_protocol_state.cpp

@@ -1,5 +1,6 @@
 #include "nmos/control_protocol_state.h"
 
+#include "cpprest/http_utils.h"
 #include "nmos/control_protocol_methods.h"
 #include "nmos/control_protocol_resource.h"
 
@@ -178,30 +179,69 @@ namespace nmos
                     return get_datatype(resources, resource, arguments, is_deprecated, get_control_protocol_datatype_descriptor, gate);
                 };
             }
-            nmos::experimental::control_protocol_method_handler make_nc_get_lost_packets(experimental::control_protocol_method_handler get_lost_packet_method_handler)
+            nmos::experimental::control_protocol_method_handler make_nc_get_lost_packet_counters_handler(get_lost_packet_counters_handler get_lost_packet_counters)
             {
-                return [get_lost_packet_method_handler](nmos::resources& resources, const nmos::resource& resource, const web::json::value& arguments, bool is_deprecated, slog::base_gate& gate)
+                return [get_lost_packet_counters](nmos::resources& resources, const nmos::resource& resource, const web::json::value& arguments, bool is_deprecated, slog::base_gate& gate)
                 {
-                    return get_lost_packet_method_handler(resources, resource, arguments, is_deprecated, gate);
+                    // Delegate to user defined handler
+                    auto result = nmos::details::make_nc_method_result_error({ nmos::nc_method_status::method_not_implemented }, U("not implemented"));
+                    
+                    if (get_lost_packet_counters)
+                    {
+                        result = get_lost_packet_counters();
+
+                        const auto& status = nmos::fields::nc::status(result);
+                        if (!web::http::is_error_status_code((web::http::status_code)status) && is_deprecated)
+                        {
+                            return nmos::details::make_nc_method_result({ nmos::nc_method_status::method_deprecated }, nmos::fields::nc::value(result));
+                        }
+                    }
+                    return result;
                 };
             }
-            nmos::experimental::control_protocol_method_handler make_nc_get_late_packets(experimental::control_protocol_method_handler get_late_packet_method_handler)
+            nmos::experimental::control_protocol_method_handler make_nc_get_late_packet_counters_handler(get_late_packet_counters_handler get_late_packet_counters)
             {
-                return [get_late_packet_method_handler](nmos::resources& resources, const nmos::resource& resource, const web::json::value& arguments, bool is_deprecated, slog::base_gate& gate)
+                return [get_late_packet_counters](nmos::resources& resources, const nmos::resource& resource, const web::json::value& arguments, bool is_deprecated, slog::base_gate& gate)
                 {
-                    return get_late_packet_method_handler(resources, resource, arguments, is_deprecated, gate);
+                    // Delegate to user defined handler
+                    auto result = nmos::details::make_nc_method_result_error({ nmos::nc_method_status::method_not_implemented }, U("not implemented"));
+
+                    if (get_late_packet_counters)
+                    {
+                        result = get_late_packet_counters();
+
+                        const auto& status = nmos::fields::nc::status(result);
+                        if (!web::http::is_error_status_code((web::http::status_code)status) && is_deprecated)
+                        {
+                            return nmos::details::make_nc_method_result({ nmos::nc_method_status::method_deprecated }, nmos::fields::nc::value(result));
+                        }
+                    }
+                    return result;
                 };
             }
-            nmos::experimental::control_protocol_method_handler make_nc_reset_packet_counters(experimental::control_protocol_method_handler reset_packet_counters_method_handler)
+            nmos::experimental::control_protocol_method_handler make_nc_reset_packet_counters_handler(reset_packet_counters_handler reset_packet_counters)
             {
-                return [reset_packet_counters_method_handler](nmos::resources& resources, const nmos::resource& resource, const web::json::value& arguments, bool is_deprecated, slog::base_gate& gate)
+                return [reset_packet_counters](nmos::resources& resources, const nmos::resource& resource, const web::json::value& arguments, bool is_deprecated, slog::base_gate& gate)
                 {
-                    return reset_packet_counters_method_handler(resources, resource, arguments, is_deprecated, gate);
+                    // Delegate to user defined handler
+                    auto result = nmos::details::make_nc_method_result_error({ nmos::nc_method_status::method_not_implemented }, U("not implemented"));
+
+                    if (reset_packet_counters)
+                    {
+                        result = reset_packet_counters();
+
+                        const auto& status = nmos::fields::nc::status(result);
+                        if (!web::http::is_error_status_code((web::http::status_code)status) && is_deprecated)
+                        {
+                            return nmos::details::make_nc_method_result({ nmos::nc_method_status::method_deprecated }, nmos::fields::nc::value(result));
+                        }
+                    }
+                    return result;
                 };
             }
         }
 
-        control_protocol_state::control_protocol_state(experimental::control_protocol_method_handler get_lost_packet_method_handler, experimental::control_protocol_method_handler get_late_packet_method_handler, experimental::control_protocol_method_handler reset_packet_couter_method_handler, control_protocol_property_changed_handler property_changed)
+        control_protocol_state::control_protocol_state(get_lost_packet_counters_handler get_lost_packet_counters, get_late_packet_counters_handler get_late_packet_counters, reset_packet_counters_handler reset_packet_counters, control_protocol_property_changed_handler property_changed)
         {
             using web::json::value;
 
@@ -336,9 +376,9 @@ namespace nmos
                     to_methods_vector(make_nc_receiver_monitor_methods(),
                     { 
                         // link NcReceiverMonitor method_ids with method functions
-                        { nc_receiver_monitor_get_lost_packets_method_id, details::make_nc_get_lost_packets(get_lost_packet_method_handler)},
-                        { nc_receiver_monitor_get_late_packets_method_id, details::make_nc_get_late_packets(get_late_packet_method_handler)},
-                        { nc_receiver_monitor_reset_packet_counters_method_id, details::make_nc_reset_packet_counters(reset_packet_couter_method_handler)}
+                        { nc_receiver_monitor_get_lost_packet_counters_method_id, details::make_nc_get_lost_packet_counters_handler(get_lost_packet_counters)},
+                        { nc_receiver_monitor_get_late_packet_counters_method_id, details::make_nc_get_late_packet_counters_handler(get_late_packet_counters)},
+                        { nc_receiver_monitor_reset_packet_counters_method_id, details::make_nc_reset_packet_counters_handler(reset_packet_counters)}
                     }),
                     // NcReceiverMonitor events
                     to_vector(make_nc_receiver_monitor_events())) }
@@ -424,7 +464,8 @@ namespace nmos
                 { U("NcLinkStatus"), {make_nc_link_status_datatype() } },
                 { U("NcSynchronizationStatus"), {make_nc_synchronization_status_datatype() } },
                 { U("NcStreamStatus"), {make_nc_stream_status_datatype() } },
-                { U("NcMethodResultCounter"), {make_nc_method_result_counter_datatype() } }
+                { U("NcPacketCounter"), {make_nc_packet_counter_datatype() } },
+                { U("NcMethodResultCounters"), {make_nc_method_result_counters_datatype() } }
             };
         }
 

Development/nmos/control_protocol_state.h

@@ -58,7 +58,7 @@ namespace nmos
             nmos::read_lock read_lock() const { return nmos::read_lock{ mutex }; }
             nmos::write_lock write_lock() const { return nmos::write_lock{ mutex }; }
 
-            control_protocol_state(experimental::control_protocol_method_handler get_lost_packet_method_handler = nullptr, experimental::control_protocol_method_handler get_late_packet_method_handler = nullptr, experimental::control_protocol_method_handler reset_packet_couter_method_handler = nullptr, control_protocol_property_changed_handler property_changed = nullptr);
+            control_protocol_state(get_lost_packet_counters_handler get_lost_packet_counters = nullptr, get_late_packet_counters_handler get_late_packet_counters = nullptr, reset_packet_counters_handler reset_packet_counters = nullptr, control_protocol_property_changed_handler property_changed = nullptr);
 
             // insert control class descriptor, false if class descriptor already inserted
             bool insert(const experimental::control_class_descriptor& control_class_descriptor);

Development/nmos/node_server.h

@@ -82,9 +82,9 @@ namespace nmos
             node_implementation& on_get_control_datatype_descriptor(nmos::get_control_protocol_datatype_descriptor_handler get_control_protocol_datatype_descriptor) { this->get_control_protocol_datatype_descriptor = std::move(get_control_protocol_datatype_descriptor); return *this; }
             node_implementation& on_get_control_protocol_method_descriptor(nmos::get_control_protocol_method_descriptor_handler get_control_protocol_method_descriptor) { this->get_control_protocol_method_descriptor = std::move(get_control_protocol_method_descriptor); return *this; }
             node_implementation& on_control_protocol_property_changed(nmos::control_protocol_property_changed_handler control_protocol_property_changed) { this->control_protocol_property_changed = std::move(control_protocol_property_changed); return *this; }
-            node_implementation& on_get_lost_packet(experimental::control_protocol_method_handler get_lost_packet_method_handler) { this->get_lost_packet_method_handler = std::move(get_lost_packet_method_handler); return *this; }
-            node_implementation& on_get_late_packet(experimental::control_protocol_method_handler get_late_packet_method_handler) { this->get_late_packet_method_handler = std::move(get_late_packet_method_handler); return *this; }
-            node_implementation& on_reset_packet_counters(experimental::control_protocol_method_handler reset_packet_counters_method_handler) { this->reset_packet_counters_method_handler = std::move(reset_packet_counters_method_handler); return *this; }
+            node_implementation& on_get_lost_packet_counters(nmos::get_lost_packet_counters_handler get_lost_packet_counters) { this->get_lost_packet_counters = std::move(get_lost_packet_counters); return *this; }
+            node_implementation& on_get_late_packet_counters(nmos::get_late_packet_counters_handler get_late_packet_counters) { this->get_late_packet_counters = std::move(get_late_packet_counters); return *this; }
+            node_implementation& on_reset_packet_counters(nmos::reset_packet_counters_handler reset_packet_counters) { this->reset_packet_counters = std::move(reset_packet_counters); return *this; }
 
             // deprecated, use on_validate_connection_resource_patch
             node_implementation& on_validate_merged(nmos::details::connection_resource_patch_validator validate_merged) { return on_validate_connection_resource_patch(std::move(validate_merged)); }
@@ -127,9 +127,9 @@ namespace nmos
             nmos::get_control_protocol_datatype_descriptor_handler get_control_protocol_datatype_descriptor;
             nmos::get_control_protocol_method_descriptor_handler get_control_protocol_method_descriptor;
             nmos::control_protocol_property_changed_handler control_protocol_property_changed;
-            experimental::control_protocol_method_handler get_lost_packet_method_handler;
-            experimental::control_protocol_method_handler get_late_packet_method_handler;
-            experimental::control_protocol_method_handler reset_packet_counters_method_handler;
+            nmos::get_lost_packet_counters_handler get_lost_packet_counters;
+            nmos::get_late_packet_counters_handler get_late_packet_counters;
+            nmos::reset_packet_counters_handler reset_packet_counters;
         };
 
         // Construct a server instance for an NMOS Node, implementing the IS-04 Node API, IS-05 Connection API, IS-07 Events API