Merge branch 'resolve'

Author: rizsotto

CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.12 FATAL_ERROR)
 cmake_policy(VERSION 3.12)
 
 project(Bear
-        VERSION 3.0.0
+        VERSION 3.0.2
         DESCRIPTION "Bear is a tool to generate compilation database for clang tooling."
         LANGUAGES C CXX
         )

source/intercept/CMakeLists.txt

@@ -16,11 +16,12 @@ if (SUPPORT_PRELOAD)
 endif()
 
 target_include_directories(intercept_a PUBLIC source/)
-target_link_libraries(intercept_a PUBLIC result_a)
+target_link_libraries(intercept_a PUBLIC exec_a)
 target_link_libraries(intercept_a PUBLIC flags_a)
 target_link_libraries(intercept_a PUBLIC supervise_a)
 target_link_libraries(intercept_a PUBLIC sys_a)
 target_link_libraries(intercept_a PUBLIC report_a)
+target_link_libraries(intercept_a PUBLIC result_a)
 target_link_libraries(intercept_a PUBLIC spdlog::spdlog)
 
 # Create an executable from the sub projects.
@@ -33,6 +34,7 @@ target_link_libraries(intercept report_a)
 target_link_libraries(intercept supervise_a)
 target_link_libraries(intercept sys_a)
 target_link_libraries(intercept flags_a)
+target_link_libraries(intercept exec_a)
 
 install(TARGETS intercept
         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
@@ -56,6 +58,7 @@ if (ENABLE_UNIT_TESTS)
             test/SessionTest.cc
             )
 
+    target_link_libraries(intercept_unit_test exec_a)
     target_link_libraries(intercept_unit_test intercept_a)
     target_link_libraries(intercept_unit_test report_a)
     target_link_libraries(intercept_unit_test supervise_a)

source/intercept/source/collect/Application.cc

@@ -75,10 +75,10 @@ namespace ic {
         Session::SharedPtr session_;
     };
 
-    rust::Result<Application> Application::from(const flags::Arguments& args, sys::env::Vars&& environment)
+    rust::Result<Application> Application::from(const flags::Arguments& args, const char **envp)
     {
         auto command = Command::from(args);
-        auto session = Session::from(args, std::move(environment));
+        auto session = Session::from(args, envp);
         auto reporter = session
                             .and_then<Reporter::SharedPtr>([&args](const auto& session) {
                                 return Reporter::from(args, *session);

source/intercept/source/collect/Application.h

@@ -38,7 +38,7 @@ namespace ic {
         static constexpr char FORCE_WRAPPER[] = "--force-wrapper";
         static constexpr char FORCE_PRELOAD[] = "--force-preload";
 
-        static ::rust::Result<Application> from(const flags::Arguments& args, sys::env::Vars &&environment);
+        static ::rust::Result<Application> from(const flags::Arguments& args, const char **envp);
 
         ::rust::Result<int> operator()() const;
 

source/intercept/source/collect/Session.cc

@@ -29,15 +29,15 @@
 
 namespace ic {
 
-    rust::Result<Session::SharedPtr> Session::from(const flags::Arguments& args, sys::env::Vars&& environment)
+    rust::Result<Session::SharedPtr> Session::from(const flags::Arguments& args, const char **envp)
 #ifdef SUPPORT_PRELOAD
     {
         if (args.as_bool(ic::Application::FORCE_WRAPPER).unwrap_or(false))
-            return WrapperSession::from(args, std::move(environment));
+            return WrapperSession::from(args, envp);
         if (args.as_bool(ic::Application::FORCE_PRELOAD).unwrap_or(false))
-            return LibraryPreloadSession::from(args, std::move(environment));
+            return LibraryPreloadSession::from(args, envp);
 
-        return LibraryPreloadSession::from(args, std::move(environment));
+        return LibraryPreloadSession::from(args, envp);
     }
 #else
     {

source/intercept/source/collect/Session.h

@@ -34,7 +34,7 @@ namespace ic {
     class Session {
     public:
         using SharedPtr = std::shared_ptr<Session>;
-        static rust::Result<Session::SharedPtr> from(const flags::Arguments&, sys::env::Vars&&);
+        static rust::Result<Session::SharedPtr> from(const flags::Arguments&, const char **envp);
 
     public:
         virtual ~Session() = default;

source/intercept/source/collect/SessionLibrary.cc

@@ -20,9 +20,11 @@
 #include "collect/SessionLibrary.h"
 
 #include "collect/Application.h"
+#include "libsys/Errors.h"
 #include "libsys/Path.h"
 #include "libsys/Process.h"
 #include "report/libexec/Environments.h"
+#include "report/libexec/Resolver.h"
 #include "report/supervisor/Flags.h"
 
 #include <spdlog/spdlog.h>
@@ -53,30 +55,33 @@ namespace {
 
 namespace ic {
 
-    rust::Result<Session::SharedPtr> LibraryPreloadSession::from(const flags::Arguments& args, sys::env::Vars&& environment)
+    rust::Result<Session::SharedPtr> LibraryPreloadSession::from(const flags::Arguments& args, const char **envp)
     {
+        auto verbose = args.as_bool(ic::Application::VERBOSE).unwrap_or(false);
         auto library = args.as_string(ic::Application::LIBRARY);
         auto executor = args.as_string(ic::Application::EXECUTOR);
-        auto verbose = args.as_bool(ic::Application::VERBOSE);
+        auto environment = sys::env::from(envp);
+        auto path = sys::os::get_path(environment);
 
-        return merge(library, executor, verbose)
-            .map<Session::SharedPtr>([&environment](auto tuple) {
-                const auto& [library, executor, verbose] = tuple;
-                auto result = new LibraryPreloadSession(library, executor, verbose, std::move(environment));
-                return std::shared_ptr<Session>(result);
+        return merge(library, executor, path)
+            .map<Session::SharedPtr>([&verbose, &environment](auto tuple) {
+                const auto& [library, executor, path] = tuple;
+                return std::make_shared<LibraryPreloadSession>(library, executor, verbose, path, std::move(environment));
             });
     }
 
     LibraryPreloadSession::LibraryPreloadSession(
-        const std::string_view& library,
-        const std::string_view& executor,
+        const std::string_view &library,
+        const std::string_view &executor,
         bool verbose,
-        sys::env::Vars&& environment)
+        const std::string &path,
+        sys::env::Vars &&environment)
             : Session()
             , library_(library)
             , executor_(executor)
+            , path_(path)
             , verbose_(verbose)
-            , environment_(std::move(environment))
+            , environment_(environment)
     {
         spdlog::debug("Created library preload session. [library={0}, executor={1}]", library_, executor_);
     }
@@ -101,18 +106,29 @@ namespace ic {
 
     rust::Result<sys::Process::Builder> LibraryPreloadSession::supervise(const std::vector<std::string_view>& command) const
     {
+        auto resolver = el::Resolver();
+        auto program = resolver.from_search_path(command.front(), path_.c_str())
+                .map<std::string>([](auto ptr) {
+                    return std::string(ptr);
+                })
+                .map_err<std::runtime_error>([&command](auto error) {
+                    return std::runtime_error(
+                            fmt::format("Could not found: {}: {}", command.front(), sys::error_string(error)));
+                });
         auto environment = update(environment_);
-        auto program = sys::Process::Builder(command.front())
-                .set_environment(environment_)
-                .resolve_executable();
 
         return rust::merge(program, environment)
             .map<sys::Process::Builder>([&command, this](auto pair) {
                 const auto& [program, environment] = pair;
-                return sys::Process::Builder(executor_)
+                auto result = sys::Process::Builder(executor_)
                     .add_argument(executor_)
                     .add_argument(er::flags::DESTINATION)
-                    .add_argument(server_address_)
+                    .add_argument(server_address_);
+                if (verbose_) {
+                    result.add_argument(er::flags::VERBOSE);
+                }
+
+                return result
                     .add_argument(er::flags::EXECUTE)
                     .add_argument(program)
                     .add_argument(er::flags::COMMAND)

source/intercept/source/collect/SessionLibrary.h

@@ -26,12 +26,14 @@ namespace ic {
     class LibraryPreloadSession : public ic::Session {
     public:
         LibraryPreloadSession(
-            const std::string_view& library,
-            const std::string_view& executor,
-            bool verbose,
-            sys::env::Vars&& environment);
+                const std::string_view &library,
+                const std::string_view &executor,
+                bool verbose,
+                const std::string &path,
+                sys::env::Vars &&environment
+        );
 
-        static rust::Result<Session::SharedPtr> from(const flags::Arguments&, sys::env::Vars&&);
+        static rust::Result<Session::SharedPtr> from(const flags::Arguments&, const char **envp);
 
     public:
         [[nodiscard]] rust::Result<std::string> resolve(const std::string& name) const override;
@@ -43,6 +45,7 @@ namespace ic {
     private:
         std::string library_;
         std::string executor_;
+        std::string path_;
         bool verbose_;
         sys::env::Vars environment_;
     };

source/intercept/source/collect/SessionWrapper.cc

@@ -18,9 +18,11 @@
  */
 
 #include "collect/SessionWrapper.h"
-
 #include "collect/Application.h"
+#include "report/libexec/Resolver.h"
+#include "report/libexec/Environment.h"
 #include "report/wrapper/Environment.h"
+#include "libsys/Errors.h"
 #include "libsys/Os.h"
 #include "libsys/Path.h"
 
@@ -85,31 +87,6 @@ namespace {
         return os;
     }
 
-    rust::Result<fs::path> is_executable(const fs::path& path)
-    {
-        // Check if we can get the relpath of this file
-        std::error_code error_code;
-        auto result = fs::canonical(path, error_code);
-        if (error_code) {
-            return rust::Err(std::runtime_error(error_code.message()));
-        }
-        // Check if the file is executable.
-        return (0 == access(result.c_str(), X_OK))
-               ? rust::Result<fs::path>(rust::Ok(result))
-               : rust::Result<fs::path>(rust::Err(std::runtime_error("Not executable")));
-    }
-
-    rust::Result<fs::path> find_from_path(const std::list<fs::path>& paths, const fs::path& file)
-    {
-        for (const auto& path : paths) {
-            auto executable = is_executable(path / file);
-            if (executable.is_ok()) {
-                return executable;
-            }
-        }
-        return rust::Err(std::runtime_error("Not found"));
-    }
-
     rust::Result<std::list<fs::path>> list_dir(const fs::path& path)
     {
         std::list<fs::path> result;
@@ -129,42 +106,40 @@ namespace {
 
 namespace ic {
 
-    rust::Result<Session::SharedPtr> WrapperSession::from(const flags::Arguments& args, sys::env::Vars&& environment)
+    rust::Result<Session::SharedPtr> WrapperSession::from(const flags::Arguments& args, const char **envp)
     {
         const bool verbose = args.as_bool(ic::Application::VERBOSE).unwrap_or(false);
-        auto path = sys::os::get_path(environment);
         auto wrapper_dir = args.as_string(ic::Application::WRAPPER);
         auto wrappers = wrapper_dir
                             .and_then<std::list<fs::path>>([](auto wrapper_dir) {
                                 return list_dir(wrapper_dir);
                             });
 
-        auto mapping_and_override = rust::merge(path, wrappers)
-            .map<std::map<std::string, std::string>>([](auto tuple) {
-                const auto& [paths, wrappers] = tuple;
+        auto mapping_and_override = wrappers
+            .map<std::map<std::string, std::string>>([&envp](auto wrappers) {
                 // Find the executables with the same name from the path.
-                std::map<std::string, std::string> result = {};
+                std::map<std::string, std::string> result;
+                el::Resolver resolver;
                 for (const auto& wrapper : wrappers) {
                     auto basename = wrapper.filename();
-                    auto candidate = find_from_path(paths, basename);
+                    auto candidate = resolver.from_path(basename.c_str(), const_cast<char* const*>(envp));
                     candidate.on_success([&result, &basename](auto candidate) {
-                        result[basename] = candidate.string();
+                        result[basename] = candidate;
                     });
                 }
                 return result;
             })
-            .map<std::tuple<std::map<std::string, std::string>, std::map<std::string, std::string>>>([&environment](auto mapping) {
+            .map<std::tuple<std::map<std::string, std::string>, std::map<std::string, std::string>>>([&envp](auto mapping) {
                 std::map<std::string, std::string> override;
+                el::Resolver resolver;
                 // check if any environment variable is naming the real compiler
                 for (auto implicit : IMPLICITS) {
                     // find any of the implicit defined in environment.
-                    if (auto env_it = environment.find(implicit.env); env_it != environment.end()) {
+                    if (auto env_it = el::env::get_env_value(envp, implicit.env); env_it != nullptr) {
                         // FIXME: it would be more correct if we shell-split the `env_it->second`
                         //        and use only the program name, but not the argument. But then how
                         //        to deal with the errors?
-                        auto program = sys::Process::Builder(env_it->second)
-                                .set_environment(environment)
-                                .resolve_executable();
+                        auto program = resolver.from_path(std::string_view(env_it), const_cast<char* const*>(envp));
 
                         // find the current mapping for the program the user wants to run.
                         // and replace the program what the wrapper will call.
@@ -185,13 +160,13 @@ namespace ic {
             });
 
         return rust::merge(wrapper_dir, mapping_and_override)
-            .map<Session::SharedPtr>([&verbose, &environment](const auto& tuple) {
+            .map<Session::SharedPtr>([&verbose, &envp](const auto& tuple) {
                 const auto& [const_wrapper_dir, const_mapping_and_override] = tuple;
                 const auto& [const_mapping, const_override] = const_mapping_and_override;
                 std::string wrapper_dir(const_wrapper_dir);
                 std::map<std::string, std::string> mapping(const_mapping);
                 std::map<std::string, std::string> override(const_override);
-                return std::make_shared<WrapperSession>(verbose, std::move(wrapper_dir), std::move(mapping), std::move(override), environment);
+                return std::make_shared<WrapperSession>(verbose, std::move(wrapper_dir), std::move(mapping), std::move(override), sys::env::from(envp));
             });
     }
 
@@ -200,7 +175,7 @@ namespace ic {
         std::string&& wrapper_dir,
         std::map<std::string, std::string>&& mapping,
         std::map<std::string, std::string>&& override,
-        const sys::env::Vars& environment)
+        sys::env::Vars&& environment)
             : Session()
             , verbose_(verbose)
             , wrapper_dir_(wrapper_dir)
@@ -250,10 +225,11 @@ namespace ic {
 
     rust::Result<sys::Process::Builder> WrapperSession::supervise(const std::vector<std::string_view>& command) const
     {
-        return rust::Ok(
-            sys::Process::Builder(command.front())
+        auto result = sys::Process::Builder(command.front())
                 .add_arguments(command.begin(), command.end())
-                .set_environment(set_up_environment()));
+                .set_environment(set_up_environment());
+
+        return rust::Ok(result);
     }
 
     std::string WrapperSession::get_session_type() const

source/intercept/source/collect/SessionWrapper.h

@@ -30,9 +30,9 @@ namespace ic {
             std::string&& wrapper_dir,
             std::map<std::string, std::string>&& mapping,
             std::map<std::string, std::string>&& override,
-            const sys::env::Vars& environment);
+            sys::env::Vars&& environment);
 
-        static rust::Result<Session::SharedPtr> from(const flags::Arguments&, sys::env::Vars &&);
+        static rust::Result<Session::SharedPtr> from(const flags::Arguments&, const char **envp);
 
     public:
         [[nodiscard]] rust::Result<std::string> resolve(const std::string& name) const override;