Implement support for passing a .env file to corerun to easily set environment variables for stress testing. (#58222)

* Implement support for passing a .env file to corerun to easily set environment variables for stress testing.

* Load the parsed dotenv into the process.

* Implement support for # comments

* Clean up code

* Avoid copy

* PR feedback

* Update docs and bash/batch scripts to support the dotenv files.

* Use what clang recommends to not copy

* Apply suggestions from code review

Co-authored-by: Aaron Robinson <arobins@microsoft.com>

Co-authored-by: Aaron Robinson <arobins@microsoft.com>

Author: jkoritzinsky

docs/workflow/testing/using-corerun.md

@@ -75,7 +75,7 @@ variable `CORE_ROOT` to this directory – you don't have to set `CORE_LIBRA
 set PATH=%PATH%;<repo_root>\artifacts\Product\windows.x64.Debug
 set CORE_ROOT=<repo_root>\artifacts\tests\coreclr\windows.x64.Debug\Tests\Core_Root
 ```
-For example, the following runs the finalizerio test on Windows.
+For example, the following runs the finalizeio test on Windows.
 
 ```cmd
 corerun artifacts\tests\coreclr\windows.x64.Debug\GC\Features\Finalizer\finalizeio\finalizeio\finalizeio.dll
@@ -98,3 +98,6 @@ See `corerun --help` for additional details.
 
 `--debug` - Wait for a debugger to attach prior to loading the .NET runtime.
 - For example, `corerun --debug HelloWorld.dll`
+
+`--env` - Pass the path to a file in the [`dotenv`](https://github.com/motdotla/dotenv) format to specify environment variables for the test run.
+- For example, `corerun --env gcstress.env HelloWorld.dll`.

src/coreclr/hosts/corerun/CMakeLists.txt

@@ -11,6 +11,7 @@ endif(CLR_CMAKE_HOST_WIN32)
 
 add_executable_clr(corerun
   corerun.cpp
+  dotenv.cpp
   native.rc
 )
 

src/coreclr/hosts/corerun/corerun.cpp

@@ -5,6 +5,9 @@
 #include <coreclrhost.h>
 
 #include "corerun.hpp"
+#include "dotenv.hpp"
+
+#include <fstream>
 
 using char_t = pal::char_t;
 using string_t = pal::string_t;
@@ -50,6 +53,9 @@ struct configuration
 
     // Perform self test.
     bool self_test;
+
+    // configured .env file to load
+    dotenv dotenv_configuration;
 };
 
 namespace envvar
@@ -262,6 +268,8 @@ static int run(const configuration& config)
         }
     }
 
+    config.dotenv_configuration.load_into_current_process();
+
     actions.before_coreclr_load();
 
     // Attempt to load CoreCLR.
@@ -404,6 +412,7 @@ static void display_usage()
         W("                   If a property value contains spaces, quote the entire argument.\n")
         W("                   May be supplied multiple times. Format: <key>=<value>.\n")
         W("  -d, --debug - causes corerun to wait for a debugger to attach before executing.\n")
+        W("  -e, --env - path to a .env file with environment variables that corerun should set.\n")
         W("  -?, -h, --help - show this help.\n")
         W("\n")
         W("The runtime binary is searched for in --clr-path, CORE_ROOT environment variable, then\n")
@@ -508,6 +517,18 @@ static bool parse_args(
             config.self_test = true;
             return true;
         }
+        else if (pal::strcmp(option, W("e")) == 0 || (pal::strcmp(option, W("env")) == 0))
+        {
+            i++;
+            if (i >= argc)
+            {
+                pal::fprintf(stderr, W("Option %s: missing .env file path\n"), arg);
+                break;
+            }
+
+            std::ifstream dotenvFile{ pal::convert_to_utf8(argv[i]) };
+            config.dotenv_configuration = dotenv{ pal::string_t{ argv[i] }, dotenvFile};
+        }
         else if ((pal::strcmp(option, W("?")) == 0 || (pal::strcmp(option, W("h")) == 0 || (pal::strcmp(option, W("help")) == 0))))
         {
             display_usage();
@@ -640,6 +661,9 @@ static int self_test()
             THROW_IF_FALSE(!pal::string_ends_with(W("ab.cd"), W(".cde")));
             THROW_IF_FALSE(!pal::string_ends_with(W("ab.cd"), W("ab.cde")));
         }
+        {
+            dotenv::self_test();
+        }
     }
     catch (const char_t msg[])
     {

src/coreclr/hosts/corerun/corerun.hpp

@@ -63,19 +63,19 @@ namespace pal
     const char_t nativelib_ext[] = W(".dll");
     const char_t coreclr_lib[] = W("coreclr");
 
-    int strcmp(const char_t* str1, const char_t* str2) { return wcscmp(str1, str2); }
-    size_t strlen(const char_t* str) { return wcslen(str); }
-    char_t* strdup(const char_t* str) { return ::_wcsdup(str); }
-    int fprintf(FILE* fd, const char_t* const fmt, ...)
+    inline int strcmp(const char_t* str1, const char_t* str2) { return wcscmp(str1, str2); }
+    inline size_t strlen(const char_t* str) { return wcslen(str); }
+    inline char_t* strdup(const char_t* str) { return ::_wcsdup(str); }
+    inline int fprintf(FILE* fd, const char_t* const fmt, ...)
     {
         va_list args;
         va_start(args, fmt);
         int ret = ::vfwprintf(fd, fmt, args);
         va_end(args);
         return ret;
     }
-    bool is_cli_option(const char_t option_maybe) { return option_maybe == W('-') || option_maybe == W('/'); }
-    string_t getenv(const char_t* var)
+    inline bool is_cli_option(const char_t option_maybe) { return option_maybe == W('-') || option_maybe == W('/'); }
+    inline string_t getenv(const char_t* var)
     {
         DWORD needed = ::GetEnvironmentVariableW(var, nullptr, 0);
         if (needed == 0)
@@ -87,15 +87,20 @@ namespace pal
         assert(wrote < needed);
         return { buffer.get() };
     }
-    string_t get_exe_path()
+    inline void setenv(const char_t* var, string_t value)
+    {
+        BOOL success = ::SetEnvironmentVariableW(var, value.c_str());
+        assert(success);
+    }
+    inline string_t get_exe_path()
     {
         char_t file_name[1024];
         DWORD count = ::GetModuleFileNameW(nullptr, file_name, ARRAYSIZE(file_name));
         assert(::GetLastError() != ERROR_INSUFFICIENT_BUFFER);
 
         return { file_name };
     }
-    string_t get_absolute_path(const char_t* path)
+    inline string_t get_absolute_path(const char_t* path)
     {
         DWORD needed = ::GetFullPathNameW(path, 0, nullptr, nullptr);
         malloc_ptr<char_t> buffer{ (char_t*)::malloc(needed * sizeof(char_t)) };
@@ -106,25 +111,25 @@ namespace pal
         return { buffer.get() };
     }
 
-    uint32_t get_process_id()
+    inline uint32_t get_process_id()
     {
         return (uint32_t)::GetCurrentProcessId();
     }
 
-    debugger_state_t is_debugger_attached()
+    inline debugger_state_t is_debugger_attached()
     {
         return (::IsDebuggerPresent() == TRUE) ? debugger_state_t::attached : debugger_state_t::not_attached;
     }
 
-    bool does_file_exist(const string_t& file_path)
+    inline bool does_file_exist(const string_t& file_path)
     {
         return INVALID_FILE_ATTRIBUTES != ::GetFileAttributesW(file_path.c_str());
     }
 
     // Forward declaration
     void ensure_trailing_delimiter(pal::string_t& dir);
 
-    string_t build_file_list(
+    inline string_t build_file_list(
         const string_t& dir,
         const char_t* ext,
         std::function<bool(const char_t*)> should_add)
@@ -163,13 +168,13 @@ namespace pal
         return file_list.str();
     }
 
-    void* get_module_symbol(mod_t m, const char* sym)
+    inline void* get_module_symbol(mod_t m, const char* sym)
     {
         assert(m != nullptr && sym != nullptr);
         return ::GetProcAddress((HMODULE)m, sym);
     }
 
-    string_utf8_t convert_to_utf8(const char_t* str)
+    inline string_utf8_t convert_to_utf8(const char_t* str)
     {
         // Compute the needed buffer
         int bytes_req = ::WideCharToMultiByte(
@@ -191,12 +196,12 @@ namespace pal
         return { buffer.get() };
     }
 
-    string_utf8_t convert_to_utf8(string_t&& str)
+    inline string_utf8_t convert_to_utf8(string_t&& str)
     {
         return convert_to_utf8(str.c_str());
     }
 
-    bool try_load_hostpolicy(pal::string_t mock_hostpolicy_value)
+    inline bool try_load_hostpolicy(pal::string_t mock_hostpolicy_value)
     {
         const char_t* hostpolicyName = W("hostpolicy.dll");
         pal::mod_t hMod = (pal::mod_t)::GetModuleHandleW(hostpolicyName);
@@ -213,7 +218,7 @@ namespace pal
         return hMod != nullptr;
     }
 
-    bool try_load_coreclr(const pal::string_t& core_root, pal::mod_t& hMod)
+    inline bool try_load_coreclr(const pal::string_t& core_root, pal::mod_t& hMod)
     {
         pal::string_t coreclr_path = core_root;
         pal::ensure_trailing_delimiter(coreclr_path);
@@ -335,29 +340,34 @@ namespace pal
 #endif
     const char_t coreclr_lib[] = W("libcoreclr");
 
-    int strcmp(const char_t* str1, const char_t* str2) { return ::strcmp(str1, str2); }
-    size_t strlen(const char_t* str) { return ::strlen(str); }
-    char_t* strdup(const char_t* str) { return ::strdup(str); }
-    int fprintf(FILE* fd, const char_t* const fmt, ...)
+    inline int strcmp(const char_t* str1, const char_t* str2) { return ::strcmp(str1, str2); }
+    inline size_t strlen(const char_t* str) { return ::strlen(str); }
+    inline char_t* strdup(const char_t* str) { return ::strdup(str); }
+    inline int fprintf(FILE* fd, const char_t* const fmt, ...)
     {
         va_list args;
         va_start(args, fmt);
         int ret = ::vfprintf(fd, fmt, args);
         va_end(args);
         return ret;
     }
-    bool is_cli_option(const char_t option_maybe) { return option_maybe == W('-'); }
-    string_t getenv(const char_t* var)
+    inline bool is_cli_option(const char_t option_maybe) { return option_maybe == W('-'); }
+    inline string_t getenv(const char_t* var)
     {
         const char_t* val = ::getenv(var);
         if (val == nullptr)
             return {};
         return { val };
     }
+    inline void setenv(const char_t* var, string_t value)
+    {
+        int error = ::setenv(var, value.c_str(), /* overwrite */ 1);
+        assert(error == 0);
+    }
 
-    string_t get_exe_path() { return { getexepath() }; }
+    inline string_t get_exe_path() { return { getexepath() }; }
 
-    string_t get_absolute_path(const string_t& path)
+    inline string_t get_absolute_path(const string_t& path)
     {
         string_t abs_path = path;
 
@@ -372,12 +382,12 @@ namespace pal
         return abs_path;
     }
 
-    uint32_t get_process_id()
+    inline uint32_t get_process_id()
     {
         return (uint32_t)getpid();
     }
 
-    debugger_state_t is_debugger_attached()
+    inline debugger_state_t is_debugger_attached()
     {
 #if defined(__APPLE__)
         // Taken from https://developer.apple.com/library/archive/qa/qa1361/_index.html
@@ -452,7 +462,7 @@ namespace pal
 #endif // !__APPLE__
     }
 
-    bool does_file_exist(const char_t* file_path)
+    inline bool does_file_exist(const char_t* file_path)
     {
         // Check if the specified path exists
         struct stat sb;
@@ -478,7 +488,7 @@ namespace pal
     bool string_ends_with(const string_t& str, size_t suffix_len, const char_t* suffix);
     void ensure_trailing_delimiter(pal::string_t& dir);
 
-    string_t build_file_list(
+    inline string_t build_file_list(
         const string_t& directory,
         const char_t* ext,
         std::function<bool(const char_t*)> should_add)
@@ -539,23 +549,23 @@ namespace pal
         return file_list.str();
     }
 
-    void* get_module_symbol(mod_t m, const char* sym)
+    inline void* get_module_symbol(mod_t m, const char* sym)
     {
         assert(m != nullptr && sym != nullptr);
         return dlsym(m, sym);
     }
 
-    string_utf8_t convert_to_utf8(const char_t* str)
+    inline string_utf8_t convert_to_utf8(const char_t* str)
     {
         return { str };
     }
 
-    string_utf8_t convert_to_utf8(string_t&& str)
+    inline string_utf8_t convert_to_utf8(string_t&& str)
     {
         return std::move(str);
     }
 
-    bool try_load_hostpolicy(pal::string_t mock_hostpolicy_value)
+    inline bool try_load_hostpolicy(pal::string_t mock_hostpolicy_value)
     {
         if (!string_ends_with(mock_hostpolicy_value, pal::nativelib_ext))
             mock_hostpolicy_value.append(pal::nativelib_ext);
@@ -567,13 +577,13 @@ namespace pal
         return hMod != nullptr;
     }
 
-    bool try_load_coreclr(const pal::string_t& core_root, pal::mod_t& hMod)
+    inline bool try_load_coreclr(const pal::string_t& core_root, pal::mod_t& hMod)
     {
         pal::string_t coreclr_path = core_root;
         pal::ensure_trailing_delimiter(coreclr_path);
         coreclr_path.append(pal::coreclr_lib);
         coreclr_path.append(pal::nativelib_ext);
-        
+
         hMod = (pal::mod_t)dlopen(coreclr_path.c_str(), RTLD_NOW | RTLD_LOCAL);
         if (hMod == nullptr)
         {
@@ -616,7 +626,7 @@ class platform_specific_actions final
 
 namespace pal
 {
-    void split_path_to_dir_filename(const pal::string_t& path, pal::string_t& dir, pal::string_t& filename)
+    inline void split_path_to_dir_filename(const pal::string_t& path, pal::string_t& dir, pal::string_t& filename)
     {
         size_t pos = path.find_last_of(dir_delim);
         if (pos == pal::string_t::npos)
@@ -630,7 +640,7 @@ namespace pal
         filename = path.substr(pos + 1);
     }
 
-    bool string_ends_with(const string_t& str, size_t suffix_len, const char_t* suffix)
+    inline bool string_ends_with(const string_t& str, size_t suffix_len, const char_t* suffix)
     {
         assert(suffix != nullptr);
 
@@ -648,7 +658,7 @@ namespace pal
         return string_ends_with(str, LEN - 1, suffix);
     }
 
-    void ensure_trailing_delimiter(pal::string_t& dir)
+    inline void ensure_trailing_delimiter(pal::string_t& dir)
     {
         if (dir.empty())
         {
@@ -660,7 +670,7 @@ namespace pal
         }
     }
 
-    const char** convert_argv_to_utf8(int argc, const char_t** argv, std::vector<string_utf8_t>& lifetime)
+    inline const char** convert_argv_to_utf8(int argc, const char_t** argv, std::vector<string_utf8_t>& lifetime)
     {
         malloc_ptr<const char*> ret{ (const char**)::malloc(sizeof(char*) * argc) };
         assert(ret != nullptr);