Add options support for cors

src/mtconnect/configuration/agent_config.cpp

@@ -176,8 +176,9 @@ namespace mtconnect::configuration {
         cerr << "Loading configuration from:" << *path << endl;
 
         m_configFile = fs::canonical(*path);
-        addPathFront(m_configPaths, m_configFile.parent_path());
-        addPathBack(m_dataPaths, m_configFile.parent_path());
+        m_configPath = m_configFile.parent_path();
+        addPathFront(m_configPaths, m_configPath);
+        addPathBack(m_dataPaths, m_configPath);
 
         ifstream file(m_configFile.c_str());
         std::stringstream buffer;
@@ -617,30 +618,51 @@ namespace mtconnect::configuration {
     // Get file names and patterns from the options.
     auto file_name = *GetOption<string>(options, "file_name");
     auto archive_pattern = *GetOption<string>(options, "archive_pattern");
-
+
+    // Default the log directory to the configuration file path.
+    logDirectory = m_configPath;
+    logFileName = fs::path(file_name);
     logArchivePattern = fs::path(archive_pattern);
-    if (!logArchivePattern.has_filename())
+
+    // Determine the log directory based on the provided file name and archive pattern
+    if (logFileName.is_absolute())
+      logDirectory = logFileName.parent_path();
+    else if (logArchivePattern.is_absolute())
+      logDirectory = logArchivePattern.parent_path();
+
+    // If the log file name is relative and has a parent path, use it to determine the log directory
+    if (logFileName.is_relative() && logFileName.has_parent_path())
     {
-      logArchivePattern = logArchivePattern / archiveFileName(get<string>(options["file_name"]));
+      logDirectory = logDirectory / logFileName.parent_path();
+      logFileName = logFileName.filename();
+    }
+    else if (logArchivePattern.is_relative() && logArchivePattern.has_parent_path())
+    {
+      logDirectory = logDirectory / logArchivePattern.parent_path();
+      logArchivePattern = logArchivePattern.filename();
     }
 
-    if (logArchivePattern.is_relative())
-      logArchivePattern = fs::current_path() / logArchivePattern;
+    // Make sure the log archive pattern includes a file name, use the default file name as the base.
+    if (!logArchivePattern.has_filename())
+      logArchivePattern = logArchivePattern / archiveFileName(get<string>(options["file_name"]));
 
-    // Get the log directory from the archive path.
-    logDirectory = logArchivePattern.parent_path();
+    // Make the logArchivePattern and logFileName absolute paths
+    logDirectory = logDirectory.lexically_normal();
 
-    // If the file name does not specify a log directory, use the
-    // archive directory
-    logFileName = fs::path(file_name);
-    if (!logFileName.has_parent_path())
+    if (logArchivePattern.is_relative())
+      logArchivePattern = logDirectory / logArchivePattern;
+    logArchivePattern = logArchivePattern.lexically_normal();
+    auto archiveDir = logArchivePattern.parent_path();
+    fs::create_directories(logArchivePattern.parent_path());
+
+    if (logFileName.is_relative())
       logFileName = logDirectory / logFileName;
-    else if (logFileName.is_relative())
-      logFileName = fs::current_path() / logFileName;
+    logFileName = logFileName.lexically_normal();
+    fs::create_directories(logFileName.parent_path());
 
     // Create a text file sink
     auto sink = boost::make_shared<text_sink>(
-        kw::file_name = logFileName, kw::target_file_name = logArchivePattern.filename(),
+        kw::file_name = logFileName.string(), kw::target_file_name = logArchivePattern.string(),
         kw::auto_flush = true, kw::rotation_size = logRotationSize,
         kw::open_mode = ios_base::out | ios_base::app, kw::format = formatter);
 
@@ -649,7 +671,8 @@ namespace mtconnect::configuration {
 
     // Set up where the rotated files will be stored
     sink->locked_backend()->set_file_collector(logr::sinks::file::make_collector(
-        kw::target = logDirectory, kw::max_size = maxLogFileSize, kw::max_files = max_index));
+        kw::target = archiveDir.string(), kw::max_size = maxLogFileSize,
+        kw::max_files = max_index));
 
     if (rotationLogInterval > 0)
     {
@@ -1248,7 +1271,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)
@@ -374,6 +374,7 @@ namespace mtconnect {
       std::string m_devicesFile;
       std::filesystem::path m_exePath;
       std::filesystem::path m_working;
+      std::filesystem::path m_configPath;
 
       std::list<std::filesystem::path> m_configPaths;
       std::list<std::filesystem::path> m_dataPaths;

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