Add options support for cors

src/mtconnect/configuration/agent_config.cpp

@@ -1248,7 +1248,8 @@ namespace mtconnect::configuration {
       }
       catch (exception &e)
       {
-        LOG(info) << "Cannot load plugin " << name << " from " << path << " Reason: " << e.what();
+        LOG(debug) << "Plugin " << name << " from " << path << " not found, Reason: " << e.what()
+                   << ", trying next path if available.";
       }
     }
 

src/mtconnect/configuration/agent_config.hpp

@@ -295,7 +295,7 @@ namespace mtconnect {
           else
           {
             LOG(debug) << "Cannot find file '" << file << "' "
-                       << " in path " << path;
+                       << " in path " << path << ", continuing...";
           }
         }
 
@@ -312,7 +312,7 @@ namespace mtconnect {
         if (!ec)
           paths.emplace_back(con);
         else
-          LOG(debug) << "Cannot file path: " << path << ", " << ec.message();
+          LOG(debug) << "Cannot find path: " << path << ", " << ec.message() << ", skipping...";
       }
 
       void addPathFront(std::list<std::filesystem::path> &paths, std::filesystem::path path)

src/mtconnect/device_model/configuration/coordinate_systems.cpp

@@ -33,7 +33,8 @@ namespace mtconnect {
                             Requirement("Rotation", ValueType::VECTOR, 3, false),
                             Requirement("TranslationDataSet", ValueType::DATA_SET, false),
                             Requirement("RotationDataSet", ValueType::DATA_SET, false)});
-          transformation->setOrder({"Translation", "TranslationDataSet", "Rotation", "RotationDataSet"});
+          transformation->setOrder(
+              {"Translation", "TranslationDataSet", "Rotation", "RotationDataSet"});
 
           auto coordinateSystem = make_shared<Factory>(Requirements {
               Requirement("id", true), Requirement("name", false), Requirement("nativeName", false),

src/mtconnect/device_model/configuration/motion.cpp

@@ -30,7 +30,8 @@ namespace mtconnect {
                           Requirement("Rotation", ValueType::VECTOR, 3, false),
                           Requirement("TranslationDataSet", ValueType::DATA_SET, false),
                           Requirement("RotationDataSet", ValueType::DATA_SET, false)});
-        transformation->setOrder({"Translation", "TranslationDataSet", "Rotation", "RotationDataSet"});
+        transformation->setOrder(
+            {"Translation", "TranslationDataSet", "Rotation", "RotationDataSet"});
 
         static auto motion = make_shared<Factory>(Requirements {
             Requirement("id", true), Requirement("parentIdRef", false),

src/mtconnect/device_model/configuration/solid_model.cpp

@@ -29,11 +29,12 @@ namespace mtconnect {
         if (!solidModel)
         {
           static auto transformation = make_shared<Factory>(
-                                                            Requirements {Requirement("Translation", ValueType::VECTOR, 3, false),
-                                                              Requirement("Rotation", ValueType::VECTOR, 3, false),
-                                                              Requirement("TranslationDataSet", ValueType::DATA_SET, false),
-                                                              Requirement("RotationDataSet", ValueType::DATA_SET, false)});
-          transformation->setOrder({"Translation", "TranslationDataSet", "Rotation", "RotationDataSet"});
+              Requirements {Requirement("Translation", ValueType::VECTOR, 3, false),
+                            Requirement("Rotation", ValueType::VECTOR, 3, false),
+                            Requirement("TranslationDataSet", ValueType::DATA_SET, false),
+                            Requirement("RotationDataSet", ValueType::DATA_SET, false)});
+          transformation->setOrder(
+              {"Translation", "TranslationDataSet", "Rotation", "RotationDataSet"});
 
           solidModel = make_shared<Factory>(
               Requirements {{"id", true},

src/mtconnect/entity/xml_parser.cpp

@@ -287,7 +287,7 @@ namespace mtconnect::entity {
               }
               else
               {
-                LOG(warning) << "Unexpected element: " << nodeQName(child);
+                // LOG(warning) << "Unexpected element: " << nodeQName(child);
                 errors.emplace_back(
                     new EntityError("Invalid element '" + nodeQName(child) + "'", qname));
               }

src/mtconnect/parser/xml_parser.cpp

@@ -202,13 +202,27 @@ namespace mtconnect::parser {
         {
           auto device =
               entity::XmlParser::parseXmlNode(Device::getRoot(), nodeset->nodeTab[i], errors);
+
           if (device)
+          {
             deviceList.emplace_back(dynamic_pointer_cast<Device>(device));
+          }
+          else
+          {
+            LOG(error) << "Failed to parse device, skipping";
+          }
 
           if (!errors.empty())
           {
             for (auto &e : errors)
-              LOG(warning) << "Error parsing device: " << e->what();
+            {
+              if (device)
+                LOG(warning) << "When loading device " << device->get<string>("name")
+                             << ", A problem was skipped: "
+                             << e->what();
+              else
+                LOG(error) << "Failed to load device: " << e->what();
+            }
           }
         }
       }

src/mtconnect/pipeline/shdr_token_mapper.cpp

@@ -166,8 +166,8 @@ namespace mtconnect {
         }
         catch (entity::PropertyError &e)
         {
-          LOG(warning) << "Cannot convert value for data item id '" << dataItem->getId()
-                       << "': " << *token << " - " << e.what();
+          LOG(debug) << "Cannot convert value for data item id '" << dataItem->getId()
+                     << "': " << *token << " - " << e.what();
           if (schemaVersion >= SCHEMA_VERSION(2, 5) && validation)
           {
             props.insert_or_assign("quality", "INVALID"s);

src/mtconnect/sink/rest_sink/parameter.hpp

@@ -64,6 +64,9 @@ namespace mtconnect::sink::rest_sink {
     Parameter(const std::string &n, ParameterType t = STRING, UrlPart p = PATH)
       : m_name(n), m_type(t), m_part(p)
     {}
+    Parameter(const std::string_view &n, ParameterType t = STRING, UrlPart p = PATH)
+      : m_name(n), m_type(t), m_part(p)
+    {}
     Parameter(const Parameter &o) = default;
 
     /// @brief to support std::set interface

src/mtconnect/sink/rest_sink/response.hpp

@@ -21,6 +21,7 @@
 #include <boost/beast/http/status.hpp>
 
 #include <filesystem>
+#include <list>
 #include <unordered_map>
 
 #include "cached_file.hpp"
@@ -64,6 +65,9 @@ namespace mtconnect {
       std::optional<std::string> m_requestId;  ///< Request id from websocket sub
 
       CachedFilePtr m_file;  ///< Cached file if a file is being returned
+
+      /// @brief Additional per-response header fields (e.g. for CORS preflight)
+      std::list<std::pair<std::string, std::string>> m_fields;
     };
 
     using ResponsePtr = std::unique_ptr<Response>;

src/mtconnect/sink/rest_sink/routing.hpp

@@ -17,8 +17,10 @@
 
 #pragma once
 
+#include <boost/algorithm/string.hpp>
 #include <boost/beast/http/verb.hpp>
 
+#include <iostream>
 #include <list>
 #include <optional>
 #include <regex>
@@ -84,7 +86,8 @@ namespace mtconnect::sink::rest_sink {
         m_pattern(pattern),
         m_command(request),
         m_function(function),
-        m_swagger(swagger)
+        m_swagger(swagger),
+        m_catchAll(true)
     {}
 
     /// @brief Added summary and description to the routing
@@ -295,6 +298,15 @@ namespace mtconnect::sink::rest_sink {
       return true;
     }
 
+    /// @brief check if the routing's path pattern matches a given path (ignoring verb)
+    /// @param[in] path the request path to test
+    /// @return `true` if the path matches this routing's pattern
+    bool matchesPath(const std::string &path) const
+    {
+      std::smatch m;
+      return std::regex_match(path, m, m_pattern);
+    }
+
     /// @brief check if this is related to a swagger API
     /// @returns `true` if related to swagger
     auto isSwagger() const { return m_swagger; }
@@ -304,6 +316,10 @@ namespace mtconnect::sink::rest_sink {
     /// @brief Get the routing `verb`
     const auto &getVerb() const { return m_verb; }
 
+    /// @brief Check if the route is a catch-all (every path segment is a parameter)
+    /// @returns `true` if all path segments are parameters (e.g. `/{device}`)
+    auto isCatchAll() const { return m_catchAll; }
+
     /// @brief Get the optional command associated with the routing
     /// @returns optional routing
     const auto &getCommand() const { return m_command; }
@@ -319,21 +335,60 @@ namespace mtconnect::sink::rest_sink {
   protected:
     void pathParameters(std::string s)
     {
-      std::regex reg("\\{([^}]+)\\}");
-      std::smatch match;
       std::stringstream pat;
 
-      while (regex_search(s, match, reg))
+      using namespace boost::algorithm;
+      using SplitList = std::list<boost::iterator_range<std::string::iterator>>;
+
+      SplitList parts;
+      auto pos = s.find_first_not_of('/');
+      if (pos != std::string::npos)
       {
-        pat << match.prefix() << "([^/]+)";
-        m_pathParameters.emplace_back(match[1]);
-        s = match.suffix().str();
+        auto range = boost::make_iterator_range(s.begin() + pos, s.end());
+        split(parts, range, [](char c) { return c == '/'; });
+      }
+
+      bool hasLiteral = false;
+      for (auto &p : parts)
+      {
+        auto start = p.begin();
+        auto end = p.end();
+
+        auto openBrace = std::find(start, end, '{');
+        decltype(openBrace) closeBrace {end};
+        if (openBrace != end && std::distance(openBrace, end) > 2)
+          closeBrace = std::find(openBrace + 1, end, '}');
+
+        pat << "/";
+        if (openBrace != end && closeBrace != end)
+        {
+          if (openBrace > start)
+          {
+            pat << std::string_view(start, openBrace);
+            hasLiteral = true;
+          }
+          std::string_view param(openBrace + 1, closeBrace);
+          pat << "([^/]+)";
+          if (closeBrace + 1 < end)
+          {
+            pat << std::string_view(closeBrace + 1, end);
+            hasLiteral = true;
+          }
+          m_pathParameters.emplace_back(param);
+        }
+        else
+        {
+          pat << std::string_view(start, end);
+          hasLiteral = true;
+        }
       }
-      pat << s;
       pat << "/?";
 
       m_patternText = pat.str();
       m_pattern = std::regex(m_patternText);
+
+      // A route is catch-all if it has parameters but no literal path segments
+      m_catchAll = !m_pathParameters.empty() && !hasLiteral;
     }
 
     void queryParameters(std::string s)
@@ -513,5 +568,6 @@ namespace mtconnect::sink::rest_sink {
     std::optional<std::string> m_description;
 
     bool m_swagger = false;
+    bool m_catchAll = false;
   };
 }  // namespace mtconnect::sink::rest_sink

src/mtconnect/sink/rest_sink/server.cpp

@@ -19,13 +19,15 @@
 
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/case_conv.hpp>
+#include <boost/algorithm/string/join.hpp>
 #include <boost/asio.hpp>
 #include <boost/asio/coroutine.hpp>
 #include <boost/beast.hpp>
 #include <boost/beast/core.hpp>
 #include <boost/beast/http.hpp>
 #include <boost/beast/ssl.hpp>
 #include <boost/beast/version.hpp>
+#include <boost/range/adaptor/transformed.hpp>
 #include <boost/tokenizer.hpp>
 
 #include <thread>
@@ -413,4 +415,44 @@ namespace mtconnect::sink::rest_sink {
     // addRouting({boost::beast::http::verb::get, "/swagger.yaml", handler, true});
   }
 
+  bool Server::handleOptionsRequest(SessionPtr session, const RequestPtr request)
+  {
+    using namespace boost;
+    using namespace adaptors;
+    set<http::verb> specificVerbs;
+    set<http::verb> catchAllVerbs;
+    for (const auto &r : m_routings)
+    {
+      if (!r.isSwagger() && r.matchesPath(request->m_path))
+      {
+        if (r.isCatchAll())
+          catchAllVerbs.insert(r.getVerb());
+        else
+          specificVerbs.insert(r.getVerb());
+      }
+    }
+
+    // If any specific route matched, use only those; otherwise fall back to catch-alls
+    auto &verbs = specificVerbs.empty() ? catchAllVerbs : specificVerbs;
+
+    // OPTIONS is always allowed
+    verbs.insert(http::verb::options);
+
+    // Build the Allow / Access-Control-Allow-Methods header value
+    string methods = algorithm::join(
+        verbs | transformed([](http::verb v) { return string(http::to_string(v)); }), ", ");
+
+    auto response = std::make_unique<Response>(status::no_content, "", "text/plain");
+    response->m_close = false;
+    response->m_fields.emplace_back("Allow", methods);
+    response->m_fields.emplace_back("Access-Control-Allow-Methods", methods);
+    response->m_fields.emplace_back("Access-Control-Allow-Headers",
+                                    "Content-Type, Accept, Accept-Encoding");
+    response->m_fields.emplace_back("Access-Control-Max-Age", "86400");
+
+    session->writeResponse(std::move(response));
+
+    return true;
+  }
+
 }  // namespace mtconnect::sink::rest_sink

src/mtconnect/sink/rest_sink/server.hpp

@@ -173,6 +173,10 @@ namespace mtconnect::sink::rest_sink {
           else
             message = "Command failed: " + *request->m_command;
         }
+        else if (request->m_verb == boost::beast::http::verb::options)
+        {
+          success = handleOptionsRequest(session, request);
+        }
         else
         {
           for (auto &r : m_routings)
@@ -298,6 +302,16 @@ namespace mtconnect::sink::rest_sink {
     const void renderSwaggerResponse(T &format);
     /// @}
 
+    /// @name CORS Support
+    /// @{
+    ///
+    /// @brief Handle OPTIONS request for CORS preflight requests
+    /// @param[in] session the client session
+    /// @param[in] request the incoming request
+    /// @return `true` if the request was handled, otherwise `false` and a 404 will be returned
+    bool handleOptionsRequest(SessionPtr session, const RequestPtr request);
+    /// @}
+
   protected:
     boost::asio::io_context &m_context;
 

src/mtconnect/sink/rest_sink/session_impl.cpp

@@ -199,8 +199,9 @@ namespace mtconnect::sink::rest_sink {
     auto &msg = m_parser->get();
     const auto &remote = m_remote;
 
-    // Check for put, post, or delete
-    if (msg.method() != http::verb::get)
+    // Check for put, post, or delete (allow OPTIONS for CORS preflight)
+    if (msg.method() == http::verb::put || msg.method() == http::verb::post ||
+        msg.method() == http::verb::delete_)
     {
       if (!m_allowPuts)
       {
@@ -376,6 +377,10 @@ namespace mtconnect::sink::rest_sink {
     {
       res->set(http::field::location, *response.m_location);
     }
+    for (const auto &f : response.m_fields)
+    {
+      res->set(f.first, f.second);
+    }
   }
 
   template <class Derived>