blob: 2af0be243c508a34422482e026dbd932796ec743 [file] [log] [blame]
// Copyright 2017 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "src/tools/launcher/java_launcher.h"
#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/path_platform.h"
#include "src/main/cpp/util/strings.h"
#include "src/main/native/windows/file.h"
#include "src/main/native/windows/process.h"
#include "src/tools/launcher/util/launcher_util.h"
namespace bazel {
namespace launcher {
using std::getline;
using std::string;
using std::vector;
using std::wofstream;
using std::wostringstream;
using std::wstring;
using std::wstringstream;
// The runfile path of java binary, eg. local_jdk/bin/java.exe
static constexpr const char* JAVA_BIN_PATH = "java_bin_path";
static constexpr const char* JAR_BIN_PATH = "jar_bin_path";
static constexpr const char* CLASSPATH = "classpath";
static constexpr const char* JAVA_START_CLASS = "java_start_class";
static constexpr const char* JVM_FLAGS = "jvm_flags";
// Check if a string start with a certain prefix.
// If it's true, store the substring without the prefix in value.
// If value is quoted, then remove the quotes.
static bool GetFlagValue(const wstring& str, const wstring& prefix,
wstring* value_ptr) {
if (str.compare(0, prefix.length(), prefix)) {
return false;
}
wstring& value = *value_ptr;
value = str.substr(prefix.length());
int len = value.length();
if (len >= 2 && value[0] == L'"' && value[len - 1] == L'"') {
value = value.substr(1, len - 2);
}
return true;
}
// Parses one launcher flag and updates this object's state accordingly.
//
// Returns true if the flag is a valid launcher flag; false otherwise.
bool JavaBinaryLauncher::ProcessWrapperArgument(const wstring& argument) {
wstring flag_value;
if (argument.compare(L"--debug") == 0) {
wstring default_jvm_debug_port;
if (GetEnv(L"DEFAULT_JVM_DEBUG_PORT", &default_jvm_debug_port)) {
this->jvm_debug_port = default_jvm_debug_port;
} else {
this->jvm_debug_port = L"5005";
}
} else if (GetFlagValue(argument, L"--debug=", &flag_value)) {
this->jvm_debug_port = flag_value;
} else if (GetFlagValue(argument, L"--main_advice=", &flag_value)) {
this->main_advice = flag_value;
} else if (GetFlagValue(argument, L"--main_advice_classpath=", &flag_value)) {
this->main_advice_classpath = flag_value;
} else if (GetFlagValue(argument, L"--jvm_flag=", &flag_value)) {
this->jvm_flags_cmdline.push_back(flag_value);
} else if (GetFlagValue(argument, L"--jvm_flags=", &flag_value)) {
wstringstream flag_value_ss(flag_value);
wstring item;
while (getline(flag_value_ss, item, L' ')) {
this->jvm_flags_cmdline.push_back(item);
}
} else if (argument.compare(L"--singlejar") == 0) {
this->singlejar = true;
} else if (argument.compare(L"--print_javabin") == 0) {
this->print_javabin = true;
} else if (GetFlagValue(argument, L"--classpath_limit=", &flag_value)) {
this->classpath_limit = std::stoi(flag_value);
} else {
return false;
}
return true;
}
vector<wstring> JavaBinaryLauncher::ProcessesCommandLine() {
vector<wstring> args;
bool first = 1;
for (const auto& arg : this->GetCommandlineArguments()) {
// Skip the first argument.
if (first) {
first = 0;
continue;
}
wstring flag_value;
// TODO(pcloudy): Should rename this flag to --native_launcher_flag.
// But keep it as it is for now to be consistent with the shell script
// launcher.
if (GetFlagValue(arg, L"--wrapper_script_flag=", &flag_value)) {
if (!ProcessWrapperArgument(flag_value)) {
die(L"invalid wrapper argument '%s'", arg.c_str());
}
} else if (!args.empty() || !ProcessWrapperArgument(arg)) {
args.push_back(arg);
}
}
return args;
}
// Return an absolute normalized path for the directory of manifest jar
static wstring GetManifestJarDir(const wstring& binary_base_path) {
wstring abs_manifest_jar_dir;
std::size_t slash = binary_base_path.find_last_of(L"/\\");
if (slash == wstring::npos) {
abs_manifest_jar_dir = L"";
} else {
abs_manifest_jar_dir = binary_base_path.substr(0, slash);
}
if (!blaze_util::IsAbsolute(binary_base_path)) {
abs_manifest_jar_dir = blaze_util::GetCwdW() + L"\\" + abs_manifest_jar_dir;
}
wstring result;
if (!NormalizePath(abs_manifest_jar_dir, &result)) {
die(L"GetManifestJarDir Failed");
}
return result;
}
static void WriteJarClasspath(const wstring& jar_path,
wostringstream* manifest_classpath) {
*manifest_classpath << L' ';
if (jar_path.find_first_of(L" \\") != wstring::npos) {
for (const auto& x : jar_path) {
if (x == L' ') {
*manifest_classpath << L"%20";
}
if (x == L'\\') {
*manifest_classpath << L"/";
} else {
*manifest_classpath << x;
}
}
} else {
*manifest_classpath << jar_path;
}
}
wstring JavaBinaryLauncher::GetJunctionBaseDir() {
wstring binary_base_path =
GetBinaryPathWithExtension(this->GetCommandlineArguments()[0]);
wstring result;
if (!NormalizePath(binary_base_path + L".j", &result)) {
die(L"Failed to get normalized junction base directory.");
}
return result;
}
void JavaBinaryLauncher::DeleteJunctionBaseDir() {
wstring junction_base_dir_norm = GetJunctionBaseDir();
if (!DoesDirectoryPathExist(junction_base_dir_norm.c_str())) {
return;
}
vector<wstring> junctions;
blaze_util::GetAllFilesUnderW(junction_base_dir_norm, &junctions);
for (const auto& junction : junctions) {
if (!DeleteDirectoryByPath(junction.c_str())) {
PrintError(L"Failed to delete junction directory: %hs",
GetLastErrorString().c_str());
}
}
if (!DeleteDirectoryByPath(junction_base_dir_norm.c_str())) {
PrintError(L"Failed to delete junction directory: %hs",
GetLastErrorString().c_str());
}
}
wstring JavaBinaryLauncher::CreateClasspathJar(const wstring& classpath) {
wstring binary_base_path =
GetBinaryPathWithoutExtension(this->GetCommandlineArguments()[0]);
wstring abs_manifest_jar_dir_norm = GetManifestJarDir(binary_base_path);
wostringstream manifest_classpath;
manifest_classpath << L"Class-Path:";
wstringstream classpath_ss(classpath);
wstring 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<wstring, wstring> jar_dirs;
wstring junction_base_dir_norm = GetJunctionBaseDir();
int junction_count = 0;
// Make sure the junction base directory doesn't exist already.
DeleteJunctionBaseDir();
blaze_util::MakeDirectoriesW(junction_base_dir_norm, 0755);
while (getline(classpath_ss, path, L';')) {
if (blaze_util::IsAbsolute(path)) {
if (!NormalizePath(path, &path_norm)) {
die(L"CreateClasspathJar failed");
}
// 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]) {
wstring jar_dir = GetParentDirFromPath(path_norm);
wstring jar_base_name = GetBaseNameFromPath(path_norm);
wstring junction;
auto search = jar_dirs.find(jar_dir);
if (search == jar_dirs.end()) {
junction = junction_base_dir_norm + L"\\" +
std::to_wstring(junction_count++);
wstring error;
if (bazel::windows::CreateJunction(junction, jar_dir, &error) !=
bazel::windows::CreateJunctionResult::kSuccess) {
die(L"CreateClasspathJar failed: %s", error.c_str());
}
jar_dirs.insert(std::make_pair(jar_dir, junction));
} else {
junction = search->second;
}
path_norm = junction + L"\\" + jar_base_name;
}
if (!RelativeTo(path_norm, abs_manifest_jar_dir_norm, &path)) {
die(L"CreateClasspathJar failed");
}
}
WriteJarClasspath(path, &manifest_classpath);
}
wstring rand_id = L"-" + GetRandomStr(10);
// Enable long path support for jar_manifest_file_path.
wstring jar_manifest_file_path =
binary_base_path + rand_id + L".jar_manifest";
blaze_util::AddUncPrefixMaybe(&jar_manifest_file_path);
wofstream jar_manifest_file(jar_manifest_file_path);
jar_manifest_file << L"Manifest-Version: 1.0\n";
// No line in the MANIFEST.MF file may be longer than 72 bytes.
// A space prefix indicates the line is still the content of the last
// attribute.
wstring manifest_classpath_str = manifest_classpath.str();
for (size_t i = 0; i < manifest_classpath_str.length(); i += 71) {
if (i > 0) {
jar_manifest_file << L" ";
}
jar_manifest_file << manifest_classpath_str.substr(i, 71) << "\n";
}
jar_manifest_file.close();
if (jar_manifest_file.fail()) {
die(L"Couldn't write jar manifest file: %s",
jar_manifest_file_path.c_str());
}
// Create the command for generating classpath jar.
wstring manifest_jar_path = binary_base_path + rand_id + L"-classpath.jar";
wstring jar_bin = this->Rlocation(this->GetLaunchInfoByKey(JAR_BIN_PATH));
vector<wstring> arguments;
arguments.push_back(L"cvfm");
arguments.push_back(manifest_jar_path);
arguments.push_back(jar_manifest_file_path);
if (this->LaunchProcess(jar_bin, arguments, /* suppressOutput */ true) != 0) {
die(L"Couldn't create classpath jar: %s", manifest_jar_path.c_str());
}
// Delete jar_manifest_file after classpath jar is created.
DeleteFileByPath(jar_manifest_file_path.c_str());
return manifest_jar_path;
}
ExitCode JavaBinaryLauncher::Launch() {
// Parse the original command line.
vector<wstring> remaining_args = this->ProcessesCommandLine();
// Set JAVA_RUNFILES
wstring java_runfiles;
if (!GetEnv(L"JAVA_RUNFILES", &java_runfiles)) {
java_runfiles = this->GetRunfilesPath();
}
SetEnv(L"JAVA_RUNFILES", java_runfiles);
// Print Java binary path if needed
wstring java_bin = this->Rlocation(this->GetLaunchInfoByKey(JAVA_BIN_PATH),
/*has_workspace_name =*/true);
if (this->print_javabin ||
this->GetLaunchInfoByKey(JAVA_START_CLASS) == L"--print_javabin") {
wprintf(L"%s\n", java_bin.c_str());
return 0;
}
wostringstream classpath;
// Run deploy jar if needed, otherwise generate the CLASSPATH by rlocation.
if (this->singlejar) {
wstring deploy_jar =
GetBinaryPathWithoutExtension(this->GetCommandlineArguments()[0]) +
L"_deploy.jar";
if (!DoesFilePathExist(deploy_jar.c_str())) {
die(L"Option --singlejar was passed, but %s does not exist.\n (You may "
"need to build it explicitly.)",
deploy_jar.c_str());
}
classpath << deploy_jar << L';';
} else {
// Add main advice classpath if exists
if (!this->main_advice_classpath.empty()) {
classpath << this->main_advice_classpath << L';';
}
wstring path;
wstringstream classpath_ss(this->GetLaunchInfoByKey(CLASSPATH));
while (getline(classpath_ss, path, L';')) {
classpath << this->Rlocation(path) << L';';
}
}
// Set jvm debug options
wostringstream jvm_debug_flags;
if (!this->jvm_debug_port.empty()) {
wstring jvm_debug_suspend;
if (!GetEnv(L"DEFAULT_JVM_DEBUG_SUSPEND", &jvm_debug_suspend)) {
jvm_debug_suspend = L"y";
}
jvm_debug_flags << L"-agentlib:jdwp=transport=dt_socket,server=y";
jvm_debug_flags << L",suspend=" << jvm_debug_suspend;
jvm_debug_flags << L",address=" << jvm_debug_port;
wstring value;
if (GetEnv(L"PERSISTENT_TEST_RUNNER", &value) && value == L"true") {
jvm_debug_flags << L",quiet=y";
}
}
// Get jvm flags from JVM_FLAGS environment variable and JVM_FLAGS launch info
vector<wstring> jvm_flags;
wstring jvm_flags_env;
GetEnv(L"JVM_FLAGS", &jvm_flags_env);
wstring flag;
wstringstream jvm_flags_env_ss(jvm_flags_env);
while (getline(jvm_flags_env_ss, flag, L' ')) {
jvm_flags.push_back(flag);
}
wstringstream jvm_flags_launch_info_ss(this->GetLaunchInfoByKey(JVM_FLAGS));
while (getline(jvm_flags_launch_info_ss, flag, L'\t')) {
jvm_flags.push_back(flag);
}
// Check if TEST_TMPDIR is available to use for scratch.
wstring test_tmpdir;
if (GetEnv(L"TEST_TMPDIR", &test_tmpdir) &&
DoesDirectoryPathExist(test_tmpdir.c_str())) {
jvm_flags.push_back(L"-Djava.io.tmpdir=" + test_tmpdir);
}
// Construct the final command line arguments
vector<wstring> arguments;
// Add classpath flags
arguments.push_back(L"-classpath");
// Check if CLASSPATH is over classpath length limit.
// If it does, then we create a classpath jar to pass CLASSPATH value.
wstring classpath_str = classpath.str();
wstring classpath_jar = L"";
if (classpath_str.length() > this->classpath_limit) {
classpath_jar = CreateClasspathJar(classpath_str);
arguments.push_back(classpath_jar);
} else {
arguments.push_back(classpath_str);
}
// Add JVM debug flags
wstring jvm_debug_flags_str = jvm_debug_flags.str();
if (!jvm_debug_flags_str.empty()) {
arguments.push_back(jvm_debug_flags_str);
}
// Add JVM flags parsed from env and launch info.
for (const auto& arg : jvm_flags) {
arguments.push_back(arg);
}
// Add JVM flags parsed from command line.
for (const auto& arg : this->jvm_flags_cmdline) {
arguments.push_back(arg);
}
// Add main advice class
if (!this->main_advice.empty()) {
arguments.push_back(this->main_advice);
}
// Add java start class
arguments.push_back(this->GetLaunchInfoByKey(JAVA_START_CLASS));
// Add the remaininng arguments, they will be passed to the program.
for (const auto& arg : remaining_args) {
arguments.push_back(arg);
}
vector<wstring> escaped_arguments;
// Quote the arguments if having spaces
for (const auto& arg : arguments) {
escaped_arguments.push_back(bazel::windows::WindowsEscapeArg(arg));
}
ExitCode exit_code = this->LaunchProcess(java_bin, escaped_arguments);
// Delete classpath jar file after execution.
if (!classpath_jar.empty()) {
DeleteFileByPath(classpath_jar.c_str());
DeleteJunctionBaseDir();
}
return exit_code;
}
} // namespace launcher
} // namespace bazel