IS-12 support

Development/cmake/NmosCppLibraries.cmake

@@ -757,6 +757,7 @@ set(NMOS_CPP_NMOS_SOURCES
     nmos/connection_api.cpp
     nmos/connection_events_activation.cpp
     nmos/connection_resources.cpp
+    nmos/control_protocol_ws_api.cpp
     nmos/did_sdid.cpp
     nmos/events_api.cpp
     nmos/events_resources.cpp
@@ -828,6 +829,7 @@ set(NMOS_CPP_NMOS_HEADERS
     nmos/connection_api.h
     nmos/connection_events_activation.h
     nmos/connection_resources.h
+    nmos/control_protocol_ws_api.h
     nmos/device_type.h
     nmos/did_sdid.h
     nmos/event_type.h
@@ -846,6 +848,7 @@ set(NMOS_CPP_NMOS_HEADERS
     nmos/is07_versions.h
     nmos/is08_versions.h
     nmos/is09_versions.h
+    nmos/is12_versions.h
     nmos/json_fields.h
     nmos/json_schema.h
     nmos/lldp_handler.h

Development/nmos/control_protocol_ws_api.cpp

@@ -0,0 +1,84 @@
+#include "nmos/control_protocol_ws_api.h"
+
+#include "nmos/slog.h"
+
+namespace nmos
+{
+    // IS-12 Control Protocol WebSocket API
+
+    web::websockets::experimental::listener::validate_handler make_control_protocol_ws_validate_handler(nmos::node_model& model, slog::base_gate& gate_)
+    {
+        return [&model, &gate_](web::http::http_request req)
+        {
+            nmos::ws_api_gate gate(gate_, req.request_uri());
+
+            // RFC 6750 defines two methods of sending bearer access tokens which are applicable to WebSocket
+            // Clients SHOULD use the "Authorization Request Header Field" method.
+            // Clients MAY use a "URI Query Parameter".
+            // See https://tools.ietf.org/html/rfc6750#section-2
+
+            // For now just return true
+            const auto& ws_ncp_path = req.request_uri().path();
+            slog::log<slog::severities::more_info>(gate, SLOG_FLF) << "Validating websocket connection to: " << ws_ncp_path;
+
+            return true;
+        };
+    }
+
+    web::websockets::experimental::listener::open_handler make_control_protocol_ws_open_handler(nmos::node_model& model, nmos::websockets& websockets, slog::base_gate& gate_)
+    {
+        return [&model, &websockets, &gate_](const web::uri& connection_uri, const web::websockets::experimental::listener::connection_id& connection_id)
+        {
+            nmos::ws_api_gate gate(gate_, connection_uri);
+
+            const auto& ws_ncp_path = connection_uri.path();
+            slog::log<slog::severities::info>(gate, SLOG_FLF) << "Opening websocket connection to: " << ws_ncp_path;
+            {
+                // create a websocket connection resource
+
+                nmos::id id = nmos::make_id();
+                websockets.insert({ id, connection_id });
+
+                slog::log<slog::severities::info>(gate, SLOG_FLF) << "Creating websocket connection: " << id;
+            }
+        };
+    }
+
+    web::websockets::experimental::listener::close_handler make_control_protocol_ws_close_handler(nmos::node_model& model, nmos::websockets& websockets, slog::base_gate& gate_)
+    {
+        return [&model, &websockets, &gate_](const web::uri& connection_uri, const web::websockets::experimental::listener::connection_id& connection_id, web::websockets::websocket_close_status close_status, const utility::string_t& close_reason)
+        {
+            nmos::ws_api_gate gate(gate_, connection_uri);
+
+            const auto& ws_ncp_path = connection_uri.path();
+            slog::log<slog::severities::info>(gate, SLOG_FLF) << "Closing websocket connection to: " << ws_ncp_path << " [" << (int)close_status << ": " << close_reason << "]";
+
+            auto websocket = websockets.right.find(connection_id);
+            if (websockets.right.end() != websocket)
+            {
+                slog::log<slog::severities::info>(gate, SLOG_FLF) << "Deleting websocket connection";
+
+                websockets.right.erase(websocket);
+            }
+        };
+    }
+
+    web::websockets::experimental::listener::message_handler make_control_protocol_ws_message_handler(nmos::node_model& model, nmos::websockets& websockets, slog::base_gate& gate_)
+    {
+        return [&model, &websockets, &gate_](const web::uri& connection_uri, const web::websockets::experimental::listener::connection_id& connection_id, const web::websockets::websocket_incoming_message& msg_)
+        {
+            nmos::ws_api_gate gate(gate_, connection_uri);
+           // theoretically blocking, but in fact not
+            auto msg = msg_.extract_string().get();
+
+            const auto& ws_ncp_path = connection_uri.path();
+            slog::log<slog::severities::too_much_info>(gate, SLOG_FLF) << "Received websocket message: " << msg << " on connection to: " << ws_ncp_path;
+
+            auto websocket = websockets.right.find(connection_id);
+            if (websockets.right.end() != websocket)
+            {
+                // hmm, todo message handling....
+            }
+        };
+    }
+}

Development/nmos/control_protocol_ws_api.h

@@ -0,0 +1,33 @@
+#ifndef NMOS_CONTROL_PROTOCOL_WS_API_H
+#define NMOS_CONTROL_PROTOCOL_WS_API_H
+
+#include "nmos/websockets.h"
+
+namespace slog
+{
+    class base_gate;
+}
+
+// Events API websocket implementation
+// See https://specs.amwa.tv/is-07/releases/v1.0.1/docs/5.2._Transport_-_Websocket.html
+namespace nmos
+{
+    struct node_model;
+
+    web::websockets::experimental::listener::validate_handler make_control_protocol_ws_validate_handler(nmos::node_model& model, slog::base_gate& gate);
+    web::websockets::experimental::listener::open_handler make_control_protocol_ws_open_handler(nmos::node_model& model, nmos::websockets& websockets, slog::base_gate& gate);
+    web::websockets::experimental::listener::close_handler make_control_protocol_ws_close_handler(nmos::node_model& model, nmos::websockets& websockets, slog::base_gate& gate);
+    web::websockets::experimental::listener::message_handler make_control_protocol_ws_message_handler(nmos::node_model& model, nmos::websockets& websockets, slog::base_gate& gate);
+
+    inline web::websockets::experimental::listener::websocket_listener_handlers make_control_protocol_ws_api(nmos::node_model& model, nmos::websockets& websockets, slog::base_gate& gate)
+    {
+        return{
+            nmos::make_control_protocol_ws_validate_handler(model, gate),
+            nmos::make_control_protocol_ws_open_handler(model, websockets, gate),
+            nmos::make_control_protocol_ws_close_handler(model, websockets, gate),
+            nmos::make_control_protocol_ws_message_handler(model, websockets, gate)
+        };
+    }
+}
+
+#endif

Development/nmos/is12_versions.h

@@ -0,0 +1,26 @@
+#ifndef NMOS_IS12_VERSIONS_H
+#define NMOS_IS12_VERSIONS_H
+
+#include <set>
+#include <boost/range/adaptor/transformed.hpp>
+#include "nmos/api_version.h"
+#include "nmos/settings.h"
+
+namespace nmos
+{
+    namespace is12_versions
+    {
+        const api_version v1_0{ 1, 0 };
+
+        const std::set<api_version> all{ nmos::is12_versions::v1_0 };
+
+        inline std::set<api_version> from_settings(const nmos::settings& settings)
+        {
+            return settings.has_field(nmos::fields::is12_versions)
+                ? boost::copy_range<std::set<api_version>>(nmos::fields::is12_versions(settings) | boost::adaptors::transformed([](const web::json::value& v) { return nmos::parse_api_version(v.as_string()); }))
+                : nmos::is12_versions::all;
+        }
+    }
+}
+
+#endif

Development/nmos/node_resources.cpp

@@ -16,6 +16,7 @@
 #include "nmos/is05_versions.h"
 #include "nmos/is07_versions.h"
 #include "nmos/is08_versions.h"
+#include "nmos/is12_versions.h"
 #include "nmos/media_type.h"
 #include "nmos/resource.h"
 #include "nmos/sdp_utils.h" // for nmos::make_components
@@ -125,6 +126,26 @@ namespace nmos
             }
         }
 
+        if (0 <= nmos::fields::control_protocol_ws_port(settings))
+        {
+            for (const auto& version : nmos::is12_versions::from_settings(settings))
+            {
+                auto ncp_uri = web::uri_builder()
+                    .set_scheme(nmos::ws_scheme(settings))
+                    .set_port(nmos::fields::control_protocol_ws_port(settings))
+                    .set_path(U("/x-nmos/ncp/") + make_api_version(version));
+                auto type = U("urn:x-nmos:control:ncp/") + make_api_version(version);
+
+                for (const auto& host : hosts)
+                {
+                    web::json::push_back(data[U("controls")], value_of({
+                        { U("href"), ncp_uri.set_host(host).to_uri().to_string() },
+                        { U("type"), type }
+                    }));
+                }
+            }
+        }
+
         return{ is04_versions::v1_3, types::device, std::move(data), false };
     }
 

Development/nmos/node_server.cpp

@@ -3,6 +3,7 @@
 #include "cpprest/ws_utils.h"
 #include "nmos/api_utils.h"
 #include "nmos/channelmapping_activation.h"
+#include "nmos/control_protocol_ws_api.h"
 #include "nmos/events_api.h"
 #include "nmos/events_ws_api.h"
 #include "nmos/logging_api.h"
@@ -63,9 +64,16 @@ namespace nmos
             // Configure the Channel Mapping API
             node_server.api_routers[{ {}, nmos::fields::channelmapping_port(node_model.settings) }].mount({}, nmos::make_channelmapping_api(node_model, node_implementation.validate_map, gate));
 
-            auto& events_ws_api = node_server.ws_handlers[{ {}, nmos::fields::events_ws_port(node_model.settings) }];
+            const auto& events_ws_port = nmos::fields::events_ws_port(node_model.settings);
+            auto& events_ws_api = node_server.ws_handlers[{ {}, events_ws_port }];
             events_ws_api.first = nmos::make_events_ws_api(node_model, events_ws_api.second, gate);
 
+            // can't share a port between the events ws and the control protocol ws
+            const auto& control_protocol_ws_port = nmos::fields::control_protocol_ws_port(node_model.settings);
+            if (control_protocol_ws_port == events_ws_port) throw std::runtime_error("Same port used for events and control protocol websockets are not supported");
+            auto& control_protocol_ws_api = node_server.ws_handlers[{ {}, control_protocol_ws_port }];
+            control_protocol_ws_api.first = nmos::make_control_protocol_ws_api(node_model, control_protocol_ws_api.second, gate);
+
             // Set up the listeners for each HTTP API port
 
             auto http_config = nmos::make_http_listener_config(node_model.settings, node_implementation.load_server_certificates, node_implementation.load_dh_param, node_implementation.get_ocsp_response, gate);
@@ -84,16 +92,19 @@ namespace nmos
             auto websocket_config = nmos::make_websocket_listener_config(node_model.settings, node_implementation.load_server_certificates, node_implementation.load_dh_param, node_implementation.get_ocsp_response, gate);
             websocket_config.set_log_callback(nmos::make_slog_logging_callback(gate));
 
+            size_t event_ws_pos{ 0 };
             for (auto& ws_handler : node_server.ws_handlers)
             {
                 // if IP address isn't specified for this router, use default server address or wildcard address
                 const auto& host = !ws_handler.first.first.empty() ? ws_handler.first.first : !server_address.empty() ? server_address : web::websockets::experimental::listener::host_wildcard;
                 // map the configured client port to the server port on which to listen
                 // hmm, this should probably also take account of the address
                 node_server.ws_listeners.push_back(nmos::make_ws_api_listener(server_secure, host, nmos::experimental::server_port(ws_handler.first.second, node_model.settings), ws_handler.second.first, websocket_config, gate));
+
+                event_ws_pos = (ws_handler.first.second == events_ws_port) ? event_ws_pos : ++event_ws_pos;
             }
 
-            auto& events_ws_listener = node_server.ws_listeners.back();
+            auto& events_ws_listener = node_server.ws_listeners.at(event_ws_pos);
 
             // Set up node operation (including the DNS-SD advertisements)
 

Development/nmos/settings.cpp

@@ -66,6 +66,8 @@ namespace nmos
                 const auto http_port = nmos::fields::http_port(settings);
                 // can't share a port between an http_listener and a websocket_listener, so use next higher port
                 const auto ws_port = http_port + 1;
+                // can't share a port between the events ws and the control protocol ws
+                const auto ncp_ws_port = ws_port + 1;
                 if (registry) web::json::insert(settings, std::make_pair(nmos::fields::query_port, http_port));
                 if (registry) web::json::insert(settings, std::make_pair(nmos::fields::query_ws_port, ws_port));
                 if (registry) web::json::insert(settings, std::make_pair(nmos::fields::registration_port, http_port));
@@ -81,6 +83,7 @@ namespace nmos
                 if (registry) web::json::insert(settings, std::make_pair(nmos::experimental::fields::admin_port, http_port));
                 if (registry) web::json::insert(settings, std::make_pair(nmos::experimental::fields::mdns_port, http_port));
                 if (registry) web::json::insert(settings, std::make_pair(nmos::experimental::fields::schemas_port, http_port));
+                if (!registry) web::json::insert(settings, std::make_pair(nmos::fields::control_protocol_ws_port, ncp_ws_port));
             }
         }
     }

Development/nmos/settings.h

@@ -101,6 +101,9 @@ namespace nmos
         // is09_versions [registry, node]: used to specify the enabled API versions for a version-locked configuration
         const web::json::field_as_array is09_versions{ U("is09_versions") }; // when omitted, nmos::is09_versions::all is used
 
+        // is12_versions [node]: used to specify the enabled API versions for a version-locked configuration
+        const web::json::field_as_array is12_versions{ U("is12_versions") }; // when omitted, nmos::is12_versions::all is used
+
         // pri [registry, node]: used for the 'pri' TXT record; specifying nmos::service_priorities::no_priority (maximum value) disables advertisement completely
         const web::json::field_as_integer_or pri{ U("pri"), 100 }; // default to highest_development_priority
 
@@ -136,6 +139,7 @@ namespace nmos
         const web::json::field_as_integer_or channelmapping_port{ U("channelmapping_port"), 3215 };
         // system_port [node]: used to construct request URLs for the System API (if not discovered via DNS-SD)
         const web::json::field_as_integer_or system_port{ U("system_port"), 10641 };
+        const web::json::field_as_integer_or control_protocol_ws_port{ U("control_protocol_ws_port"), 3218 };
 
         // listen_backlog [registry, node]: the maximum length of the queue of pending connections, or zero for the implementation default (the implementation may not honour this value)
         const web::json::field_as_integer_or listen_backlog{ U("listen_backlog"), 0 };