SCRIPT Move subprojects

tools/processstarter/BUILD.bazel

@@ -0,0 +1,54 @@
+load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
+load("//shared/bazel/rules:objectivec_rules.bzl", "wpilib_objc_library")
+load("//shared/bazel/rules:packaging.bzl", "package_binary_cc_project")
+
+WIN_SRCS = glob([
+    "src/main/native/windows/**/*.cpp",
+    "src/main/native/windows/**/*.h",
+])
+
+LINUX_SRCS = glob([
+    "src/main/native/linux/**/*.cpp",
+    "src/main/native/linux/**/*.h",
+])
+
+MAC_SRCS = glob([
+    "src/main/native/osx/**/*.mm",
+    "src/main/native/osx/**/*.h",
+])
+
+filegroup(
+    name = "native-srcs",
+    srcs = select({
+        "@platforms//os:osx": MAC_SRCS,
+        "@platforms//os:windows": WIN_SRCS,
+        "@rules_bzlmodrio_toolchains//constraints/combined:is_linux": LINUX_SRCS,
+    }),
+)
+
+wpilib_objc_library(
+    name = "processstarter-osx",
+    srcs = [":native-srcs"],
+)
+
+cc_binary(
+    name = "processstarter",
+    srcs = select({
+        "@platforms//os:osx": [],
+        "//conditions:default": [":native-srcs"],
+    }),
+    linkopts = select({
+        "@platforms//os:windows": ["-SUBSYSTEM:WINDOWS"],
+        "//conditions:default": [],
+    }),
+    deps = select({
+        "@platforms//os:osx": ["processstarter-osx"],
+        "//conditions:default": [],
+    }),
+)
+
+package_binary_cc_project(
+    name = "processstarter",
+    maven_artifact_name = "processstarter",
+    maven_group_id = "edu.wpi.first.tools",
+)

tools/processstarter/build.gradle

@@ -0,0 +1,85 @@
+import org.gradle.internal.os.OperatingSystem
+
+if (project.hasProperty('onlylinuxathena') || project.hasProperty('onlylinuxsystemcore')) {
+    return;
+}
+
+description = "Process Starter"
+
+apply plugin: 'cpp'
+apply plugin: 'objective-cpp'
+apply plugin: 'visual-studio'
+apply plugin: 'edu.wpi.first.NativeUtils'
+
+ext {
+    nativeName = 'processstarter'
+}
+
+apply from: "${rootDir}/shared/config.gradle"
+
+// Replace shared crt with static crt.
+// Note this means no wpilib binaries can be dependencies
+nativeUtils.platformConfigs.named(nativeUtils.wpi.platforms.windowsx64).configure {
+    cppCompiler.debugArgs.remove('/MDd')
+    cppCompiler.debugArgs.add('/MTd')
+    cppCompiler.releaseArgs.remove('/MD')
+    cppCompiler.releaseArgs.add('/MT')
+}
+
+project(':').libraryBuild.dependsOn build
+
+model {
+    components {
+        "${nativeName}"(NativeExecutableSpec) {
+            baseName = 'processstarter'
+            binaries.all {
+                if (it.targetPlatform.name == nativeUtils.wpi.platforms.systemcore) {
+                    it.buildable = false
+                    return
+                }
+                if (it.targetPlatform.operatingSystem.isMacOsX()) {
+                    it.sources {
+                        macObjCpp(ObjectiveCppSourceSet) {
+                            source {
+                                srcDirs 'src/main/native/osx'
+                                include '**/*.mm'
+                            }
+                            exportedHeaders {
+                                srcDirs 'src/main/native/include'
+                                include '**/*.h'
+                            }
+                        }
+                    }
+                } else if (it.targetPlatform.operatingSystem.isLinux()) {
+                    it.sources {
+                        linuxCpp(CppSourceSet) {
+                            source {
+                                srcDirs 'src/main/native/linux'
+                                include '**/*.cpp'
+                            }
+                            exportedHeaders {
+                                srcDirs 'src/main/native/include'
+                                include '**/*.h'
+                            }
+                        }
+                    }
+                } else if (it.targetPlatform.operatingSystem.isWindows()) {
+                    it.sources {
+                        windowsCpp(CppSourceSet) {
+                            source {
+                                srcDirs 'src/main/native/windows'
+                                include '**/*.cpp'
+                            }
+                            exportedHeaders {
+                                srcDirs 'src/main/native/include'
+                                include '**/*.h'
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+apply from: 'publish.gradle'

tools/processstarter/publish.gradle

@@ -0,0 +1,68 @@
+apply plugin: 'maven-publish'
+
+def baseArtifactId = 'processstarter'
+def artifactGroupId = 'edu.wpi.first.tools'
+def zipBaseName = '_GROUP_edu_wpi_first_tools_ID_processstarter_CLS'
+
+def outputsFolder = file("$project.buildDir/outputs")
+
+model {
+    tasks {
+        // Create the run task.
+        $.components.processstarter.binaries.each { bin ->
+            if (bin.buildable && bin.name.toLowerCase().contains("debug") && nativeUtils.isNativeDesktopPlatform(bin.targetPlatform)) {
+                Task run = project.tasks.create("run", Exec) {
+                    commandLine bin.tasks.install.runScriptFile.get().asFile.toString()
+                }
+                run.dependsOn bin.tasks.install
+            }
+        }
+    }
+    publishing {
+        def processstarterTaskList = []
+        $.components.each { component ->
+            component.binaries.each { binary ->
+                if (binary in NativeExecutableBinarySpec && binary.component.name.contains("processstarter")) {
+                    if (binary.buildable && (binary.name.contains('Release') || binary.name.contains('release'))) {
+                        // We are now in the binary that we want.
+                        // This is the default application path for the ZIP task.
+                        def applicationPath = binary.executable.file
+
+                        // Create the ZIP.
+                        def task = project.tasks.create("copyprocessstarterExecutable" + binary.targetPlatform.architecture.name, Zip) {
+                            description = "Copies the processstarter executable to the outputs directory."
+                            destinationDirectory = outputsFolder
+
+                            archiveBaseName = zipBaseName
+                            duplicatesStrategy = 'exclude'
+                            archiveClassifier = nativeUtils.getPublishClassifier(binary)
+
+                            from(licenseFile) {
+                                into '/'
+                            }
+
+                            from(applicationPath)
+                            into(nativeUtils.getPlatformPath(binary))
+                        }
+
+                        task.dependsOn binary.tasks.link
+                        processstarterTaskList.add(task)
+                        project.build.dependsOn task
+                        project.artifacts { task }
+                        addTaskToCopyAllOutputs(task)
+                    }
+                }
+            }
+        }
+
+        publications {
+            processstarter(MavenPublication) {
+                processstarterTaskList.each { artifact it }
+
+                artifactId = baseArtifactId
+                groupId = artifactGroupId
+                version = wpilibVersioning.version.get()
+            }
+        }
+    }
+}

tools/processstarter/src/main/native/linux/main.cpp

@@ -0,0 +1,124 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "main.h"
+
+#include <poll.h>
+#include <spawn.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <climits>
+#include <cstdio>
+#include <cstring>
+#include <string>
+
+int main(int argc, char* argv[]) {
+  char path[PATH_MAX];
+  char dest[PATH_MAX];
+  std::memset(dest, 0, sizeof(dest));  // readlink does not null terminate!
+  pid_t pid = getpid();
+  std::snprintf(path, PATH_MAX, "/proc/%d/exe", pid);
+  int readlink_len = readlink(path, dest, PATH_MAX);
+  if (readlink_len < 0) {
+    std::perror("readlink");
+    return 1;
+  } else if (readlink_len == PATH_MAX) {
+    std::printf("Truncation occurred\n");
+    return 1;
+  }
+
+  std::filesystem::path exePath{dest};
+  if (exePath.empty()) {
+    return 1;
+  }
+
+  if (!exePath.has_stem()) {
+    return 1;
+  }
+
+  if (!exePath.has_parent_path()) {
+    return 1;
+  }
+
+  if (exePath.stem() == (L"AdvantageScope")) {
+    std::filesystem::path AdvantageScopePath{
+        exePath.parent_path().parent_path() / L"advantagescope" /
+        L"advantagescope-wpilib"};
+    return StartExeTool(AdvantageScopePath);
+  } else if (exePath.stem() == (L"Elastic")) {
+    std::filesystem::path ElasticPath{exePath.parent_path().parent_path() /
+                                      L"elastic" / L"elastic_dashboard"};
+    return StartExeTool(ElasticPath);
+  } else {
+    return StartJavaTool(exePath);
+  }
+}
+
+int StartJavaTool(std::filesystem::path& exePath) {
+  pid_t pid = 0;
+  std::filesystem::path jarPath{exePath};
+  jarPath.replace_extension("jar");
+  std::filesystem::path parentPath{exePath.parent_path()};
+
+  if (!parentPath.has_parent_path()) {
+    return 1;
+  }
+  std::filesystem::path toolsFolder{parentPath.parent_path()};
+
+  std::filesystem::path Java = toolsFolder / "jdk" / "bin" / "java";
+
+  std::string data = jarPath;
+  std::string jarArg = "-jar";
+  auto javaGenericStr = Java.generic_string();
+  char* const arguments[] = {javaGenericStr.data(), jarArg.data(), data.data(),
+                             nullptr};
+
+  int status =
+      posix_spawn(&pid, Java.c_str(), nullptr, nullptr, arguments, environ);
+  if (status != 0) {
+    char* home = std::getenv("JAVA_HOME");
+    std::string javaLocal = "java";
+    if (home != nullptr) {
+      std::filesystem::path javaHomePath{home};
+      javaHomePath /= "bin";
+      javaHomePath /= "java";
+      javaLocal = javaHomePath;
+    }
+
+    status = posix_spawn(&pid, javaLocal.c_str(), nullptr, nullptr, arguments,
+                         environ);
+    if (status != 0) {
+      return 1;
+    }
+  }
+
+  int childPid = syscall(SYS_pidfd_open, pid, 0);
+  if (childPid <= 0) {
+    return 1;
+  }
+
+  struct pollfd pfd = {childPid, POLLIN, 0};
+  return poll(&pfd, 1, 3000);
+}
+
+int StartExeTool(std::filesystem::path& exePath) {
+  char* const arguments[] = {nullptr};
+  pid_t pid = 0;
+
+  int status =
+      posix_spawn(&pid, exePath.c_str(), nullptr, nullptr, arguments, environ);
+
+  if (status != 0) {
+    return 1;
+  }
+  int childPid = syscall(SYS_pidfd_open, pid, 0);
+  if (childPid <= 0) {
+    return 1;
+  }
+
+  struct pollfd pfd = {childPid, POLLIN, 0};
+  return poll(&pfd, 1, 5000);
+}

tools/processstarter/src/main/native/linux/main.h

@@ -0,0 +1,11 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <filesystem>
+
+int StartExeTool(std::filesystem::path& exePath);
+int StartJavaTool(std::filesystem::path& exePath);
+int main(int argc, char* argv[]);

tools/processstarter/src/main/native/osx/main.h

@@ -0,0 +1,11 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <filesystem>
+
+int StartExeTool(std::filesystem::path& exePath);
+int StartJavaTool(std::filesystem::path& exePath);
+int main(int argc, char* argv[]);

tools/processstarter/src/main/native/osx/main.mm

@@ -0,0 +1,119 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#import <Foundation/Foundation.h>
+#include "main.h"
+
+#include <iostream>
+#include <string>
+
+int main(int argc, char* argv[]) {
+  (void)argc;
+  (void)argv;
+  NSString* exePathPlat = [[NSBundle mainBundle] bundlePath];
+  NSString* identifier = [[NSBundle mainBundle] bundleIdentifier];
+  if (identifier == nil) {
+    exePathPlat = [[NSBundle mainBundle] executablePath];
+  }
+
+  std::filesystem::path exePath{[exePathPlat UTF8String]};
+  if (exePath.empty()) {
+    return 1;
+  }
+
+  if (!exePath.has_stem()) {
+    return 1;
+  }
+
+  if (!exePath.has_parent_path()) {
+    return 1;
+  }
+
+  if (exePath.stem() == (L"AdvantageScope")) {
+    std::filesystem::path AdvantageScopePath{
+        exePath.parent_path().parent_path() / L"advantagescope" /
+        L"Advantagescope (WPILib).app" / L"Contents" / L"MacOS" /
+        L"advantagescope"};
+    return StartExeTool(AdvantageScopePath);
+  } else if (exePath.stem() == (L"Elastic")) {
+    std::filesystem::path ElasticPath{exePath.parent_path().parent_path() /
+                                      L"elastic" / L"elastic_dashboard.app" /
+                                      L"Contents" / L"MacOS" /
+                                      L"elastic_dashboard"};
+    return StartExeTool(ElasticPath);
+  } else {
+    return StartJavaTool(exePath);
+  }
+}
+
+int StartJavaTool(std::filesystem::path& exePath) {
+  std::filesystem::path jarPath{exePath};
+  jarPath.replace_extension("jar");
+  std::filesystem::path parentPath{exePath.parent_path()};
+
+  if (!parentPath.has_parent_path()) {
+    return 1;
+  }
+  std::filesystem::path toolsFolder{parentPath.parent_path()};
+
+  std::filesystem::path java = toolsFolder / "jdk" / "bin" / "java";
+
+  NSArray<NSString*>* Arguments =
+      @[ @"-jar", [NSString stringWithFormat:@"%s", jarPath.c_str()] ];
+
+  NSTask* task = [[NSTask alloc] init];
+  task.launchPath = [NSString stringWithFormat:@"%s", java.c_str()];
+  task.arguments = Arguments;
+  task.terminationHandler = ^(NSTask* t) {
+    (void)t;
+    CFRunLoopStop(CFRunLoopGetMain());
+  };
+
+  if (![task launchAndReturnError:nil]) {
+    task.terminationHandler = nil;
+
+    NSString* javaHome =
+        [[[NSProcessInfo processInfo] environment] objectForKey:@"JAVA_HOME"];
+    task = [[NSTask alloc] init];
+    task.launchPath = @"java";
+    if (javaHome != nil) {
+      std::filesystem::path javaHomePath{[javaHome UTF8String]};
+      javaHomePath /= "bin";
+      javaHomePath /= "java";
+      task.launchPath = [NSString stringWithFormat:@"%s", javaHomePath.c_str()];
+    }
+    task.arguments = Arguments;
+    task.terminationHandler = ^(NSTask* t) {
+      (void)t;
+      CFRunLoopStop(CFRunLoopGetMain());
+    };
+
+    if (![task launchAndReturnError:nil]) {
+      return 1;
+    }
+  }
+
+  CFRunLoopRunInMode(kCFRunLoopDefaultMode, 3, false);
+
+  return task.running ? 0 : 1;
+}
+
+int StartExeTool(std::filesystem::path& exePath) {
+  std::cout << "exePath: " << exePath.c_str() << std::endl;
+  NSTask* task = [[NSTask alloc] init];
+  task.launchPath = [NSString stringWithFormat:@"%s", exePath.c_str()];
+  // task.arguments = Arguments;
+  task.terminationHandler = ^(NSTask* t) {
+    (void)t;
+    CFRunLoopStop(CFRunLoopGetMain());
+  };
+
+  if (![task launchAndReturnError:nil]) {
+    return 1;
+  }
+
+  CFRunLoopRunInMode(kCFRunLoopDefaultMode, 3, false);
+
+  return task.running ? 0 : 1;
+}

tools/processstarter/src/main/native/windows/main.cpp

@@ -0,0 +1,123 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "main.h"
+
+int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
+                   LPTSTR pCmdLine, int nCmdShow) {
+  DWORD Status;
+  WCHAR ExePathRaw[1024];
+  Status = GetModuleFileNameW(NULL, ExePathRaw, 1024);
+  if (Status == 0) {
+    DWORD LastError = GetLastError();
+    return LastError;
+  }
+
+  std::filesystem::path ExePath{ExePathRaw};
+  if (ExePath.empty()) {
+    return 1;
+  }
+
+  if (!ExePath.has_stem()) {
+    return 1;
+  }
+
+  if (!ExePath.has_parent_path()) {
+    return 1;
+  }
+
+  if (ExePath.stem() == (L"AdvantageScope")) {
+    std::filesystem::path AdvantageScopePath{
+        ExePath.parent_path().parent_path() / L"advantagescope" /
+        L"AdvantageScope (WPILib).exe"};
+    return StartExeTool(AdvantageScopePath);
+  } else if (ExePath.stem() == (L"Elastic")) {
+    std::filesystem::path ElasticPath{ExePath.parent_path().parent_path() /
+                                      L"elastic" / L"elastic_dashboard.exe"};
+    return StartExeTool(ElasticPath);
+  } else {
+    return StartJavaTool(ExePath);
+  }
+}
+
+int StartJavaTool(std::filesystem::path& ExePath) {
+  WCHAR ExePathRaw[1024];
+  DWORD Status;
+
+  std::filesystem::path JarPath{ExePath};
+  JarPath.replace_extension(L"jar");
+  std::filesystem::path ParentPath{ExePath.parent_path()};
+
+  if (!ParentPath.has_parent_path()) {
+    return 1;
+  }
+  std::filesystem::path ToolsFolder{ParentPath.parent_path()};
+
+  std::filesystem::path Javaw = ToolsFolder / L"jdk" / L"bin" / L"javaw.exe";
+
+  std::wstring ToRun = L" -jar \"";
+  ToRun += JarPath;
+  ToRun += L"\"";
+
+  STARTUPINFOW StartupInfo;
+  PROCESS_INFORMATION ProcessInfo;
+
+  ZeroMemory(&StartupInfo, sizeof(StartupInfo));
+  StartupInfo.cb = sizeof(StartupInfo);
+  ZeroMemory(&ProcessInfo, sizeof(ProcessInfo));
+
+  if (!CreateProcessW(Javaw.c_str(), ToRun.data(), NULL, NULL, FALSE, 0, NULL,
+                      NULL, &StartupInfo, &ProcessInfo)) {
+    ZeroMemory(&StartupInfo, sizeof(StartupInfo));
+    StartupInfo.cb = sizeof(StartupInfo);
+    ZeroMemory(&ProcessInfo, sizeof(ProcessInfo));
+
+    ToRun = L" -jar \"";
+    ToRun += JarPath;
+    ToRun += L"\"";
+
+    Status = GetEnvironmentVariableW(L"JAVA_HOME", ExePathRaw, 1024);
+    std::wstring JavawLocal = L"javaw";
+    if (Status != 0 && Status < 1024) {
+      std::filesystem::path JavaHomePath{ExePathRaw};
+      JavaHomePath /= "bin";
+      JavaHomePath /= "javaw.exe";
+      JavawLocal = JavaHomePath;
+    }
+
+    if (!CreateProcessW(JavawLocal.c_str(), ToRun.data(), NULL, NULL, FALSE, 0,
+                        NULL, NULL, &StartupInfo, &ProcessInfo)) {
+      return 1;
+    }
+  }
+
+  Status =
+      WaitForSingleObject(ProcessInfo.hProcess, 3000);  // Wait for 3 seconds
+  CloseHandle(ProcessInfo.hProcess);
+  CloseHandle(ProcessInfo.hThread);
+
+  return Status == WAIT_TIMEOUT ? 0 : 1;
+}
+
+int StartExeTool(std::filesystem::path& ExePath) {
+  STARTUPINFOW StartupInfo;
+  PROCESS_INFORMATION ProcessInfo;
+  DWORD Status;
+
+  ZeroMemory(&StartupInfo, sizeof(StartupInfo));
+  StartupInfo.cb = sizeof(StartupInfo);
+  ZeroMemory(&ProcessInfo, sizeof(ProcessInfo));
+
+  if (!CreateProcessW(ExePath.c_str(), NULL, NULL, NULL, FALSE, 0, NULL, NULL,
+                      &StartupInfo, &ProcessInfo)) {
+    return 1;
+  }
+
+  Status =
+      WaitForSingleObject(ProcessInfo.hProcess, 5000);  // Wait for 5 seconds
+  CloseHandle(ProcessInfo.hProcess);
+  CloseHandle(ProcessInfo.hThread);
+
+  return Status == WAIT_TIMEOUT ? 0 : 1;
+}

tools/processstarter/src/main/native/windows/main.h

@@ -0,0 +1,15 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <windows.h>
+
+#include <filesystem>
+#include <string>
+
+int StartExeTool(std::filesystem::path& ExePath);
+int StartJavaTool(std::filesystem::path& ExePath);
+int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
+                   LPTSTR pCmdLine, int nCmdShow);