Measure manager fixups and improvements

python/SetupPython.cmake

@@ -35,6 +35,20 @@ else()
   endif()
 endif()
 
+execute_process(COMMAND ${Python_EXECUTABLE} -c "import requests; print(requests.__version__)"
+  RESULT_VARIABLE _PyRequests_STATUS
+      OUTPUT_VARIABLE PyRequests_Version
+      ERROR_QUIET
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+if(_PyRequests_STATUS AND NOT _PyRequests_STATUS EQUAL 0)
+  message(AUTHOR_WARNING "requests isn't installed on your system python, so some tests won't be run. Run `pip install requests`")
+  set(PyRequests_AVAILABLE OFF)
+else()
+  message("Found Python requests: ${PyRequests_Version}")
+  set(PyRequests_AVAILABLE ON)
+endif()
+
 get_filename_component(Python_PROGRAM_NAME ${Python_EXECUTABLE} NAME)
 
 get_filename_component(RESOLVED_PYTHON_LIBRARY "${Python_LIBRARIES}" REALPATH)

ruby/engine/measure_manager_server.rb

@@ -119,7 +119,7 @@ def do_POST (request, response)
 
         result = {}
 
-        data = JSON.parse(request.body, {:symbolize_names=>true})
+        data = JSON.parse(request.body || "{}", {:symbolize_names=>true})
         my_measures_dir = data[:my_measures_dir]
 
         if my_measures_dir
@@ -132,7 +132,7 @@ def do_POST (request, response)
 
         result = []
 
-        data = JSON.parse(request.body, {:symbolize_names=>true})
+        data = JSON.parse(request.body || "{}", {:symbolize_names=>true})
         uid = data[:uid]
 
         if uid
@@ -156,8 +156,8 @@ def do_POST (request, response)
 
         result = []
 
-        data = JSON.parse(request.body, {:symbolize_names=>true})
         force_reload = false
+        data = JSON.parse(request.body || "{}", {:symbolize_names=>true})
 
         # loop over all local BCL measures
         OpenStudio::LocalBCL.instance.measures.each do |local_measure|
@@ -181,7 +181,7 @@ def do_POST (request, response)
 
         result = []
 
-        data = JSON.parse(request.body, {:symbolize_names=>true})
+        data = JSON.parse(request.body || "{}", {:symbolize_names=>true})
         measures_dir = data[:measures_dir] ? data[:measures_dir] : @my_measures_dir
         force_reload = data[:force_reload] ? data[:force_reload] : false
 
@@ -205,7 +205,7 @@ def do_POST (request, response)
 
       when "/compute_arguments"
 
-        data = JSON.parse(request.body, {:symbolize_names=>true})
+        data = JSON.parse(request.body || "{}", {:symbolize_names=>true})
         measure_dir  = data[:measure_dir ]
         osm_path = data[:osm_path]
         force_reload = data[:force_reload] ? data[:force_reload] : false
@@ -239,7 +239,7 @@ def do_POST (request, response)
 
       when "/create_measure"
 
-        data = JSON.parse(request.body, {:symbolize_names=>true})
+        data = JSON.parse(request.body || "{}", {:symbolize_names=>true})
         measure_dir = data[:measure_dir]
 
         # name = data[:name] # we do not take name as input
@@ -263,7 +263,7 @@ def do_POST (request, response)
 
       when "/duplicate_measure"
 
-        data = JSON.parse(request.body, {:symbolize_names=>true})
+        data = JSON.parse(request.body || "{}", {:symbolize_names=>true})
         old_measure_dir = data[:old_measure_dir]
         measure_dir = data[:measure_dir]
 

src/cli/CMakeLists.txt

@@ -369,6 +369,16 @@ if(BUILD_TESTING)
       WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/Testing/"
     )
 
+    if (PyRequests_AVAILABLE)
+      add_test(NAME OpenStudioCLI.test_measure_manager
+        COMMAND ${Python_EXECUTABLE} -m pytest --verbose --os-cli-path $<TARGET_FILE:openstudio> "${CMAKE_CURRENT_SOURCE_DIR}/test/test_measure_manager.py"
+        WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/Testing/"
+      )
+      add_test(NAME OpenStudioCLI.Classic.test_measure_manager
+        COMMAND ${Python_EXECUTABLE} -m pytest --verbose --use-classic --os-cli-path $<TARGET_FILE:openstudio> "${CMAKE_CURRENT_SOURCE_DIR}/test/test_measure_manager.py"
+        WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/Testing/"
+      )
+    endif()
 
   else()
     # TODO: Remove. Fallback on these for now, as I don't know if CI has pytest installed

src/cli/MeasureManager.cpp

@@ -10,6 +10,7 @@
 #include "../utilities/core/Filesystem.hpp"
 #include "../utilities/core/FilesystemHelpers.hpp"
 #include "../utilities/core/StringHelpers.hpp"
+#include "../utilities/time/DateTime.hpp"
 #include "../osversion/VersionTranslator.hpp"
 #include "../energyplus/ForwardTranslator.hpp"
 #include "../utilities/bcl/LocalBCL.hpp"
@@ -145,7 +146,7 @@ Json::Value MeasureManager::internalState() const {
     osmInfo["checksum"] = v.checksum;
     osms.append(std::move(osmInfo));
   }
-  result["osm"] = std::move(osms);
+  result["osms"] = std::move(osms);
 
   Json::Value idfs(Json::arrayValue);
   for (const auto& [k, v] : m_idfs) {
@@ -154,15 +155,18 @@ Json::Value MeasureManager::internalState() const {
     idfInfo["checksum"] = v.checksum;
     idfs.append(std::move(idfInfo));
   }
-  result["idf"] = std::move(idfs);
+  result["idfs"] = std::move(idfs);
 
+  // Json::Value measures(Json::arrayValue);
   auto& measures = result["measures"];
+  measures = Json::arrayValue;
   for (const auto& [measureDirPath, bclMeasureInfo] : m_measures) {
     Json::Value mInfo(Json::objectValue);
     measures.append(bclMeasureInfo.measure.toJSON());
   }
 
   auto& measureInfos = result["measure_info"];
+  measureInfos = Json::arrayValue;
   // Json::Value measureInfos(Json::arrayValue);
   for (const auto& [measureDirPath, bclMeasureInfo] : m_measures) {
     for (const auto& [osmOrIdfPath, measureInfo] : bclMeasureInfo.measureInfos) {
@@ -597,14 +601,17 @@ bool MeasureManagerServer::close() {
   return status == pplx::task_group_status::completed;
 }
 
+void MeasureManagerServer::unknown_endpoint(web::http::http_request& message) {
+  const std::string uri = toString(web::http::uri::decode(message.relative_uri().path()));
+  message.reply(web::http::status_codes::BadRequest, toWebJSON(fmt::format("Error, unknown path '{}'", uri)));
+  print_feedback(message, web::http::status_codes::NotFound);
+}
+
 void MeasureManagerServer::handle_get(web::http::http_request message) {
   const std::string uri = toString(web::http::uri::decode(message.relative_uri().path()));
 
   if (uri == "/") {
-    Json::Value result;
-    result["status"] = "running";
-    result["my_measures_dir"] = my_measures_dir.generic_string();
-    message.reply(web::http::status_codes::OK, toWebJSON(result));
+    handle_request(message, web::json::value(), &MeasureManagerServer::status);
     return;
   }
 
@@ -614,7 +621,7 @@ void MeasureManagerServer::handle_get(web::http::http_request message) {
     return;
   }
 
-  message.reply(web::http::status_codes::BadRequest, toWebJSON(fmt::format("Error, unknown path '{}'", uri)));
+  unknown_endpoint(message);
 }
 
 void MeasureManagerServer::handle_post(web::http::http_request message) {
@@ -672,8 +679,16 @@ void MeasureManagerServer::handle_post(web::http::http_request message) {
     return;
   }
 
-  message.reply(web::http::status_codes::NotFound, toWebJSON("404: Unknown Endpoint"));
+  unknown_endpoint(message);
 }
+
+MeasureManagerServer::ResponseType MeasureManagerServer::status([[maybe_unused]] const web::json::value& body) {
+  Json::Value result;
+  result["status"] = "running";
+  result["my_measures_dir"] = my_measures_dir.generic_string();
+  return {web::http::status_codes::OK, toWebJSON(result)};
+}
+
 MeasureManagerServer::ResponseType MeasureManagerServer::internal_state([[maybe_unused]] const web::json::value& body) {
   Json::Value result;
   result["status"] = "running";
@@ -989,30 +1004,44 @@ MeasureManagerServer::ResponseType MeasureManagerServer::duplicate_measure(const
   }
 }
 
+void MeasureManagerServer::print_feedback(const web::http::http_request& message, web::http::status_code status_code) {
+  const std::string uri = toString(web::http::uri::decode(message.relative_uri().path()));
+  const std::string method = toString(message.method());
+  const std::string http_version = message.http_version().to_utf8string();
+  const std::string timestamp = openstudio::DateTime::now().toXsdDateTime();
+  fmt::print(status_code == web::http::status_codes::OK ? stdout : stderr, "[{}] \"{} {} {}\" {}\n", openstudio::DateTime::now().toXsdDateTime(),
+             method, uri, http_version, status_code);
+}
+
 void MeasureManagerServer::handle_request(const web::http::http_request& message, const web::json::value& body,
                                           memRequestHandlerFunPtr request_handler) {
 
   std::packaged_task<ResponseType()> task([this, &body, &request_handler]() { return (this->*request_handler)(body); });
 
   auto future_result = task.get_future();  // The task hasn't been started yet
   tasks.push_back(std::move(task));        // It gets queued, the **main** thread will process it
+  web::http::status_code status_code = web::http::status_codes::Created;
   try {
     auto result = future_result.get();  // This block until it's been processed
-    message.reply(result.status_code, result.body);
+    status_code = result.status_code;
+    message.reply(status_code, result.body);
   } catch (const std::exception& e) {
     constexpr auto msg = "MeasureManager Server encountered an error:\n\"{}\"\n";
     fmt::print(msg, e.what());
+    status_code = web::http::status_codes::InternalError;
     message.reply(web::http::status_codes::InternalError, fmt::format(msg, e.what()));
   }
+  print_feedback(message, status_code);
 }
 
 void MeasureManagerServer::do_tasks_forever() {
-  fmt::print("MeasureManager Ready");
+  fmt::print("MeasureManager Ready\n");
   fmt::print("Accepting requests on: {}\n", m_url);
   std::fflush(stdout);
   while (true) {
     auto task = tasks.wait_for_one();
     task();
+    std::fflush(stdout);
   }
 }
 

src/cli/MeasureManager.hpp

@@ -118,6 +118,7 @@ class MeasureManagerServer
   };
 
   // Request handlers
+  ResponseType status(const web::json::value& body);
   ResponseType internal_state(const web::json::value& body);
   ResponseType reset(const web::json::value& body);
   ResponseType set(const web::json::value& body);
@@ -137,6 +138,15 @@ class MeasureManagerServer
   void handle_get(web::http::http_request message);
   void handle_post(web::http::http_request message);
   static void handle_error(pplx::task<void>& t);
+
+  // Helper to return a 404 error
+  static void unknown_endpoint(web::http::http_request& message);
+
+  // Print the request to the console (stdout if Ok, stderr otherwise)
+  // [2024-11-14T10:21:46+01:00] "POST /reset HTTP/1.1" 200
+  // [2024-11-14T10:22:09+01:00] "GET /dsd HTTP/1.1" 400
+  static void print_feedback(const web::http::http_request& message, web::http::status_code status_code);
+
   MeasureManager m_measureManager;
   web::http::experimental::listener::http_listener m_listener;
   ThreadSafeDeque<std::packaged_task<ResponseType()>> tasks;

src/cli/test/conftest.py

@@ -12,11 +12,16 @@ def validate_file(arg):
 
 def pytest_addoption(parser):
     parser.addoption("--os-cli-path", type=validate_file, help="Path to the OS CLI")  # , required=True
-
+    parser.addoption("--use-classic", action="store_true", help="Force use the Classic CLI")
 
 @pytest.fixture(scope="module")
 def osclipath(request):
     cli_path = request.config.getoption("--os-cli-path")
     if cli_path is None:
         raise ValueError("You must supply --os-cli-path [Path]")
     return cli_path
+
+@pytest.fixture(scope="module")
+def use_classic_cli(request):
+    use_classic = request.config.getoption("--use-classic")
+    return use_classic