Windows, Java launcher: Support jar files under different drives

Create junctions to jar's directory when java launcher and its jar are under different drives

Fixed bazelbuild#5135

Change-Id: I21c5b28f5f36c1fe234f8b781fe40d526db846cc
PiperOrigin-RevId: 196477704

src/main/cpp/util/file.cc

@@ -124,8 +124,8 @@ class DirectoryTreeWalker : public DirectoryEntryConsumer {
  _ForEachDirectoryEntry walk_entries)
  : _files(files), _walk_entries(walk_entries) {}
 
- void Consume(const string &path, bool is_directory) override {
- if (is_directory) {
+ void Consume(const string &path, bool follow_directory) override {
+ if (follow_directory) {
  Walk(path);
  } else {
  _files->push_back(path);

src/main/cpp/util/file_windows.cc

@@ -1219,7 +1219,9 @@ void ForEachDirectoryEntry(const string &path,
  wstring wname = wpath + metadata.cFileName;
  string name(WstringToCstring(/* omit prefix */ 4 + wname.c_str()).get());
  bool is_dir = (metadata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
- consume->Consume(name, is_dir);
+ bool is_junc =
+ (metadata.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0;
+ consume->Consume(name, is_dir && !is_junc);
  }
  } while (::FindNextFileW(handle, &metadata));
  ::FindClose(handle);

src/test/shell/bazel/bazel_windows_example_test.sh

@@ -39,7 +39,6 @@ function set_up() {
 startup --host_jvm_args=-Dbazel.windows_unix_root=C:/fake/msys
 
 startup --batch
-build --cpu=x64_windows_msvc
 EOF
  export MSYS_NO_PATHCONV=1
  export MSYS2_ARG_CONV_EXCL="*"
@@ -129,6 +128,43 @@ function test_java() {
  assert_binary_run_from_subdir "bazel-bin/${java_pkg}/hello-world foo" "Hello foo"
 }
 
+function create_tmp_drive() {
+ mkdir "$TEST_TMPDIR/tmp_drive"
+
+ TMP_DRIVE_PATH=$(cygpath -w "$TEST_TMPDIR\\tmp_drive")
+ for X in {A..Z}
+ do
+ TMP_DRIVE=${X}
+ subst ${TMP_DRIVE}: ${TMP_DRIVE_PATH} >NUL || TMP_DRIVE=""
+ if [ -n "${TMP_DRIVE}" ]; then
+ break
+ fi
+ done
+
+ if [ -z "${TMP_DRIVE}" ]; then
+ fail "Cannot create temporary drive."
+ fi
+
+ export TMP_DRIVE
+}
+
+function delete_tmp_drive() {
+ if [ -n "${TMP_DRIVE}" ]; then
+ subst ${TMP_DRIVE}: /D
+ fi
+}
+
+function test_java_with_jar_under_different_drive() {
+ create_tmp_drive
+
+ trap delete_tmp_drive EXIT
+
+ local java_pkg=examples/java-native/src/main/java/com/example/myproject
+ bazel --output_user_root=${TMP_DRIVE}:/tmp build ${java_pkg}:hello-world
+
+ assert_binary_run_from_subdir "bazel-bin/${java_pkg}/hello-world --classpath_limit=0" "Hello world"
+}
+
 function test_java_test() {
  setup_javatest_support
  local java_native_tests=//examples/java-native/src/test/java/com/example/myproject

src/tools/launcher/java_launcher.cc

@@ -12,11 +12,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <memory>
 #include <sstream>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
+#include "src/main/cpp/util/file.h"
 #include "src/main/cpp/util/file_platform.h"
+#include "src/main/cpp/util/strings.h"
+#include "src/main/native/windows/file.h"
 #include "src/tools/launcher/java_launcher.h"
 #include "src/tools/launcher/util/launcher_util.h"
 
@@ -29,6 +34,7 @@ using std::ostringstream;
 using std::string;
 using std::stringstream;
 using std::vector;
+using std::wstring;
 
 // The runfile path of java binary, eg. local_jdk/bin/java.exe
 static constexpr const char* JAVA_BIN_PATH = "java_bin_path";
@@ -135,6 +141,52 @@ static string GetManifestJarDir(const string& binary_base_path) {
  return result;
 }
 
+static void WriteJarClasspath(const string& jar_path,
+ ostringstream* manifest_classpath) {
+ *manifest_classpath << ' ';
+ if (jar_path.find_first_of(" \\") != string::npos) {
+ for (const auto& x : jar_path) {
+ if (x == ' ') {
+ *manifest_classpath << "%20";
+ }
+ if (x == '\\') {
+ *manifest_classpath << "/";
+ } else {
+ *manifest_classpath << x;
+ }
+ }
+ } else {
+ *manifest_classpath << jar_path;
+ }
+}
+
+string JavaBinaryLauncher::GetJunctionBaseDir() {
+ string binary_base_path =
+ GetBinaryPathWithExtension(this->GetCommandlineArguments()[0]);
+ string result;
+ if (!NormalizePath(binary_base_path + ".j", &result)) {
+ die("Failed to get normalized junction base directory.");
+ }
+ return result;
+}
+
+void JavaBinaryLauncher::DeleteJunctionBaseDir() {
+ string junction_base_dir_norm = GetJunctionBaseDir();
+ if (!DoesDirectoryPathExist(junction_base_dir_norm.c_str())) {
+ return;
+ }
+ vector<string> junctions;
+ blaze_util::GetAllFilesUnder(junction_base_dir_norm, &junctions);
+ for (const auto& junction : junctions) {
+ if (!DeleteDirectoryByPath(junction.c_str())) {
+ PrintError(GetLastErrorString().c_str());
+ }
+ }
+ if (!DeleteDirectoryByPath(junction_base_dir_norm.c_str())) {
+ PrintError(GetLastErrorString().c_str());
+ }
+}
+
 string JavaBinaryLauncher::CreateClasspathJar(const string& classpath) {
  string binary_base_path =
  GetBinaryPathWithoutExtension(this->GetCommandlineArguments()[0]);
@@ -144,28 +196,55 @@ string JavaBinaryLauncher::CreateClasspathJar(const string& classpath) {
  manifest_classpath << "Class-Path:";
  stringstream classpath_ss(classpath);
  string path, path_norm;
+
+ // A set to store all junctions created.
+ // The key is the target path, the value is the junction path.
+ std::unordered_map<string, string> jar_dirs;
+ string junction_base_dir_norm = GetJunctionBaseDir();
+ int junction_count = 0;
+ // Make sure the junction base directory doesn't exist already.
+ DeleteJunctionBaseDir();
+ blaze_util::MakeDirectories(junction_base_dir_norm, 0755);
+
  while (getline(classpath_ss, path, ';')) {
- manifest_classpath << ' ';
  if (blaze_util::IsAbsolute(path)) {
- if (!NormalizePath(path, &path_norm) ||
- !RelativeTo(path_norm, abs_manifest_jar_dir_norm, &path)) {
+ if (!NormalizePath(path, &path_norm)) {
  die("CreateClasspathJar failed");
  }
- }
- if (path.find_first_of(" \\") != string::npos) {
- for (const auto& x : path) {
- if (x == ' ') {
- manifest_classpath << "%20";
- }
- if (x == '\\') {
- manifest_classpath << "/";
+
+ // If two paths are under different drives, we should create a junction to
+ // the jar's directory
+ if (path_norm[0] != abs_manifest_jar_dir_norm[0]) {
+ string jar_dir = GetParentDirFromPath(path_norm);
+ string jar_base_name = GetBaseNameFromPath(path_norm);
+ string junction;
+ auto search = jar_dirs.find(jar_dir);
+ if (search == jar_dirs.end()) {
+ junction =
+ junction_base_dir_norm + "\\" + std::to_string(junction_count++);
+
+ wstring wjar_dir(
+ blaze_util::CstringToWstring(junction.c_str()).get());
+ wstring wjunction(
+ blaze_util::CstringToWstring(jar_dir.c_str()).get());
+ wstring werror(bazel::windows::CreateJunction(wjar_dir, wjunction));
+ if (!werror.empty()) {
+ string error(werror.begin(), werror.end());
+ die("CreateClasspathJar failed: %s", error.c_str());
+ }
+
+ jar_dirs.insert(std::make_pair(jar_dir, junction));
  } else {
- manifest_classpath << x;
+ junction = search->second;
  }
+ path_norm = junction + "\\" + jar_base_name;
+ }
+
+ if (!RelativeTo(path_norm, abs_manifest_jar_dir_norm, &path)) {
+ die("CreateClasspathJar failed");
  }
- } else {
- manifest_classpath << path;
  }
+ WriteJarClasspath(path, &manifest_classpath);
  }
 
  string rand_id = "-" + GetRandomStr(10);
@@ -335,6 +414,7 @@ ExitCode JavaBinaryLauncher::Launch() {
  // Delete classpath jar file after execution.
  if (!classpath_jar.empty()) {
  DeleteFileByPath(classpath_jar.c_str());
+ DeleteJunctionBaseDir();
  }
 
  return exit_code;

src/tools/launcher/java_launcher.h

@@ -90,6 +90,13 @@ class JavaBinaryLauncher : public BinaryLauncherBase {
  //
  // Return the path of the classpath jar created.
  std::string CreateClasspathJar(const std::string& classpath);
+
+ // Creat a directory based on the binary path, all the junctions will be
+ // generated under this directory.
+ std::string GetJunctionBaseDir();
+
+ // Delete all the junction directory and all the junctions under it.
+ void DeleteJunctionBaseDir();
 };
 
 } // namespace launcher

src/tools/launcher/util/launcher_util.cc

@@ -100,6 +100,10 @@ bool DeleteFileByPath(const char* path) {
  return DeleteFileW(AsAbsoluteWindowsPath(path).c_str());
 }
 
+bool DeleteDirectoryByPath(const char* path) {
+ return RemoveDirectoryW(AsAbsoluteWindowsPath(path).c_str());
+}
+
 string GetBinaryPathWithoutExtension(const string& binary) {
  if (binary.find(".exe", binary.size() - 4) != string::npos) {
  return binary.substr(0, binary.length() - 4);
@@ -184,6 +188,14 @@ bool NormalizePath(const string& path, string* result) {
  return true;
 }
 
+string GetBaseNameFromPath(const string& path) {
+ return path.substr(path.find_last_of("\\/") + 1);
+}
+
+string GetParentDirFromPath(const string& path) {
+ return path.substr(0, path.find_last_of("\\/"));
+}
+
 bool RelativeTo(const string& path, const string& base, string* result) {
  if (blaze_util::IsAbsolute(path) != blaze_util::IsAbsolute(base)) {
  PrintError(

src/tools/launcher/util/launcher_util.h

@@ -61,6 +61,12 @@ bool DoesDirectoryPathExist(const char* path);
 // Delete a file at a given path.
 bool DeleteFileByPath(const char* path);
 
+// Delete a directory at a given path,.
+// If it's a real directory, it must be empty
+// If it's a junction, the target directory it points to doesn't have to be
+// empty, the junction will be deleted regardless of the state of the target.
+bool DeleteDirectoryByPath(const char* path);
+
 // Get the value of a specific environment variable
 //
 // Return true if succeeded and the result is stored in buffer.
@@ -79,6 +85,12 @@ std::string GetRandomStr(size_t len);
 // Normalize a path to a Windows path in lower case
 bool NormalizePath(const std::string& path, std::string* result);
 
+// Get the base name from a normalized absoulute path
+std::string GetBaseNameFromPath(const std::string& path);
+
+// Get parent directory from a normalized absoulute path
+std::string GetParentDirFromPath(const std::string& path);
+
 // Calculate a relative path from `path` to `base`.
 // This function expects normalized Windows path in lower case.
 // `path` and `base` should be both absolute or both relative.