Added /rolePaths/{rolePath}/properties endpoint

Author: jonathan-r-thorpe

Development/nmos/configuration_api.cpp

@@ -5,6 +5,7 @@
 //#include "cpprest/json_validator.h"
 #include "nmos/api_utils.h"
 #include "nmos/control_protocol_resource.h"
+#include "nmos/control_protocol_state.h"
 #include "nmos/control_protocol_utils.h"
 #include "nmos/is14_versions.h"
 //#include "nmos/json_schema.h"
@@ -13,9 +14,9 @@
 
 namespace nmos
 {
-    inline web::http::experimental::listener::api_router make_unmounted_configuration_api(nmos::node_model& model, slog::base_gate& gate);
+    inline web::http::experimental::listener::api_router make_unmounted_configuration_api(nmos::node_model& model, get_control_protocol_class_descriptor_handler get_control_protocol_class_descriptor, slog::base_gate& gate);
 
-    web::http::experimental::listener::api_router make_configuration_api(nmos::node_model& model, web::http::experimental::listener::route_handler validate_authorization, slog::base_gate& gate)
+    web::http::experimental::listener::api_router make_configuration_api(nmos::node_model& model, web::http::experimental::listener::route_handler validate_authorization, get_control_protocol_class_descriptor_handler get_control_protocol_class_descriptor, slog::base_gate& gate)
     {
         using namespace web::http::experimental::listener::api_router_using_declarations;
 
@@ -46,7 +47,7 @@ namespace nmos
             return pplx::task_from_result(true);
         });
 
-        configuration_api.mount(U("/x-nmos/") + nmos::patterns::configuration_api.pattern + U("/") + nmos::patterns::version.pattern, make_unmounted_configuration_api(model, gate));
+        configuration_api.mount(U("/x-nmos/") + nmos::patterns::configuration_api.pattern + U("/") + nmos::patterns::version.pattern, make_unmounted_configuration_api(model, get_control_protocol_class_descriptor, gate));
 
         return configuration_api;
     }
@@ -120,7 +121,7 @@ namespace nmos
             }
         }
 
-        bool verify_role_path(const resources& resources, const nmos::resource& resource, std::list<utility::string_t>& role_path_segments)
+        web::json::value get_nc_object(const resources& resources, const nmos::resource& resource, std::list<utility::string_t>& role_path_segments)
         {
             if (resource.data.has_field(nmos::fields::nc::members))
             {
@@ -130,16 +131,16 @@ namespace nmos
                 role_path_segments.pop_front();
                 // find the role_path_segment member
                 auto member_found = std::find_if(members.begin(), members.end(), [&](const web::json::value& member)
-                {
-                    return role_path_segement == nmos::fields::nc::role(member);
-                });
+                    {
+                        return role_path_segement == nmos::fields::nc::role(member);
+                    });
 
                 if (members.end() != member_found)
                 {
                     if (role_path_segments.empty())
                     {
                         // role_path verified
-                        return true;
+                        return *member_found;
                     }
 
                     // get the role_path_segement member resource
@@ -151,16 +152,16 @@ namespace nmos
                         if (resources.end() != found)
                         {
                             // verify the reminding role_path_segments
-                            return verify_role_path(resources, *found, role_path_segments);
+                            return get_nc_object(resources, *found, role_path_segments);
                         }
                     }
                 }
             }
-            return false;
+            return web::json::value().null();
         }
     }
 
-    inline web::http::experimental::listener::api_router make_unmounted_configuration_api(nmos::node_model& model, slog::base_gate& gate_)
+    inline web::http::experimental::listener::api_router make_unmounted_configuration_api(nmos::node_model& model, get_control_protocol_class_descriptor_handler get_control_protocol_class_descriptor, slog::base_gate& gate_)
     {
         using namespace web::http::experimental::listener::api_router_using_declarations;
 
@@ -221,7 +222,7 @@ namespace nmos
                 {
                     role_path_segments.pop_front();
 
-                    result = role_path_segments.size() ? details::verify_role_path(resources, *resource, role_path_segments) : true;
+                    result = role_path_segments.size() ? !details::get_nc_object(resources, *resource, role_path_segments).is_null() : true;
                 }
             }
 
@@ -237,6 +238,66 @@ namespace nmos
             return pplx::task_from_result(true);
         });
 
+        configuration_api.support(U("/rolePaths/") + nmos::patterns::rolePath.pattern + U("/properties/?"), methods::GET, [&model, get_control_protocol_class_descriptor, &gate_](http_request req, http_response res, const string_t& route_path, const route_parameters& parameters)
+        {
+            const string_t role_path = parameters.at(nmos::patterns::rolePath.name);
+
+            // tokenize the role_path with the '.' delimiter
+            std::list<utility::string_t> role_path_segments;
+            boost::algorithm::split(role_path_segments, role_path, [](utility::char_t c) { return '.' == c; });
+
+            bool result{ false };
+            std::set<utility::string_t> properties_routes;
+
+            auto lock = model.read_lock();
+            auto& resources = model.control_protocol_resources;
+            auto resource = nmos::find_resource(resources, utility::s2us(std::to_string(nmos::root_block_oid)));
+            if (resources.end() != resource)
+            {
+                const auto role = nmos::fields::nc::role(resource->data);
+                if (role_path_segments.size() && role == role_path_segments.front())
+                {
+                    role_path_segments.pop_front();
+
+                    auto nc_object = details::get_nc_object(resources, *resource, role_path_segments);
+
+                    result = !nc_object.is_null();
+
+                    if (result)
+                    {
+                        nc_class_id class_id = nmos::details::parse_nc_class_id(nmos::fields::nc::class_id(nc_object));
+
+                        while (!class_id.empty())
+                        {
+                            const auto& control_class = get_control_protocol_class_descriptor(class_id);
+                            auto& property_descriptors = control_class.property_descriptors.as_array();
+
+                            for (auto property_descriptor : property_descriptors)
+                            {
+                                auto property_id = nmos::fields::nc::id(property_descriptor);
+                                std::wostringstream property_id_str;
+                                property_id_str << nmos::fields::nc::level(property_id) << 'p' << nmos::fields::nc::index(property_id) << '/';
+                                properties_routes.insert(property_id_str.str());
+                            }
+
+                            class_id.pop_back();
+                        }
+                    }
+                }
+            }
+    
+            if (result)
+            {
+                set_reply(res, status_codes::OK, nmos::make_sub_routes_body(properties_routes, req, res));
+            }
+            else
+            {
+                set_error_reply(res, status_codes::NotFound, U("Not Found; ") + role_path);
+            }
+
+            return pplx::task_from_result(true);
+        });
+
         return configuration_api;
     }
 }

Development/nmos/configuration_api.h

@@ -2,6 +2,7 @@
 #define NMOS_CONFIGURATION_API_H
 
 #include "cpprest/api_router.h"
+#include "nmos/control_protocol_handlers.h"
 
 namespace slog
 {
@@ -14,7 +15,7 @@ namespace nmos
 {
     struct node_model;
 
-    web::http::experimental::listener::api_router make_configuration_api(nmos::node_model& model, web::http::experimental::listener::route_handler validate_authorization, slog::base_gate& gate);
+    web::http::experimental::listener::api_router make_configuration_api(nmos::node_model& model, web::http::experimental::listener::route_handler validate_authorization, get_control_protocol_class_descriptor_handler get_control_protocol_class_descriptor, slog::base_gate& gate);
 }
 
 #endif

Development/nmos/node_server.cpp

@@ -77,7 +77,7 @@ namespace nmos
 
             // Configure the Configuration API
 
-            node_server.api_routers[{ {}, nmos::fields::configuration_port(node_model.settings) }].mount({}, nmos::make_configuration_api(node_model, validate_authorization ? validate_authorization(nmos::experimental::scopes::configuration) : nullptr, gate));
+            node_server.api_routers[{ {}, nmos::fields::configuration_port(node_model.settings) }].mount({}, nmos::make_configuration_api(node_model, validate_authorization ? validate_authorization(nmos::experimental::scopes::configuration) : nullptr, node_implementation.get_control_protocol_class_descriptor, gate));
 
             const auto& events_ws_port = nmos::fields::events_ws_port(node_model.settings);
             auto& events_ws_api = node_server.ws_handlers[{ {}, nmos::fields::events_ws_port(node_model.settings) }];