2027 deploy works

- Need to refactor this commit and maybe do some of this in 2025/2026
  first?

Author: virtuald

robotpy_installer/cli_deploy.py

@@ -18,6 +18,7 @@
 from . import pypackages, pyproject, robot_utils, sshcontroller
 from .installer import PipInstallError, PythonMissingError, RobotpyInstaller
 from .installer import _ROBOTPY_PYTHON_VERSION_TUPLE as required_pyversion
+from .installer import _ROBOT_VENV_PYTHON
 from .errors import Error
 from .utils import handle_cli_error, print_err, yesno
 
@@ -241,20 +242,18 @@ def run(
                     )
                     raise Error(msg)
 
-        with sshcontroller.ssh_from_cfg(
-            project_path,
-            main_file,
-            username=robot_utils.ssh_username,
-            password=robot_utils.ssh_password,
+        installer = RobotpyInstaller()
+
+        with installer.connect_to_robot(
+            project_path=project_path,
+            main_file=main_file,
             robot_or_team=robot or team,
-            no_resolve=no_resolve,
+            ignore_image_version=ignore_image_version,
         ) as ssh:
             self._ensure_requirements(
                 project,
-                project_path,
-                main_file,
+                installer,
                 ssh,
-                ignore_image_version,
                 no_install,
                 force_install,
                 no_uninstall,
@@ -353,20 +352,15 @@ def _get_robot_packages(
         return self._robot_packages
 
     def _clear_pip_packages(self, installer: RobotpyInstaller):
-        rio_packages = self._get_robot_packages(installer.ssh)
-        to_uninstall = [p for p in rio_packages.keys() if p != "pip"]
-        if to_uninstall:
-            installer.pip_uninstall(to_uninstall)
-
+        installer.uninstall_venv()
         self._packages_in_cache = None
+        self._robot_packages = None
 
     def _ensure_requirements(
         self,
         project: typing.Optional[pyproject.RobotPyProjectToml],
-        project_path: pathlib.Path,
-        main_file: pathlib.Path,
+        installer: RobotpyInstaller,
         ssh: sshcontroller.SshController,
-        ignore_image_version: bool,
         no_install: bool,
         force_install: bool,
         no_uninstall: bool,
@@ -375,23 +369,20 @@ def _ensure_requirements(
         python_invalid: typing.Union[bool, str] = False
         requirements_installed = False
 
-        installer = RobotpyInstaller()
-
         # does c++/java exist
         with wrap_ssh_error("removing c++/java user programs"):
             cpp_java_exists = not robot_utils.uninstall_cpp_java(ssh)
 
         # does python exist
-        with wrap_ssh_error("checking if python exists"):
-            python_exists = (
-                ssh.exec_cmd("[ -x /usr/local/bin/python3 ]").returncode == 0
-            )
+        with wrap_ssh_error("checking if python was installed"):
+            python_exists = installer.is_python_installed()
             if not python_exists:
                 logger.warning("Python is not installed on SystemCore")
 
         if python_exists:
+
             with wrap_ssh_error("getting python version"):
-                python_version = robot_utils.get_python3_version(ssh)
+                python_version = installer.get_python_version()
 
             if python_version != required_pyversion:
                 python_exists = False
@@ -401,14 +392,14 @@ def _ensure_requirements(
 
                 if no_install:
                     raise Error(
-                        f"Unsupported version of python ({m}.{mn}) was found on the SystemCore\n"
+                        f"Unsupported version of python ({m}.{mn}) was found on the robot\n"
                         "- could not update it because no-install was specified\n"
                     )
 
                 # Warn the user before changing their rio
                 print(
                     "\n"
-                    f"Deployer has detected that the version of Python installed on the SystemCore ({m}.{mn})\n"
+                    f"Deployer has detected that the version of Python installed on the robot ({m}.{mn})\n"
                     "is not supported by this installer. The installer will now uninstall that\n"
                     f"and install Python {rm}.{rmn}.\n"
                 )
@@ -422,7 +413,7 @@ def _ensure_requirements(
             elif not force_install:
                 pkgdata = self._get_robot_packages(ssh)
 
-                logger.debug("SystemCore has these packages installed:")
+                logger.debug("Robot has these packages installed:")
                 for pkg, version in pkgdata.items():
                     logger.debug("- %s (%s)", pkg, version[0])
 
@@ -435,7 +426,7 @@ def _ensure_requirements(
                     ),
                 )
                 if not requirements_installed:
-                    logger.warning("Project requirements not installed on SystemCore")
+                    logger.warning("Project requirements not installed on robot")
                     for msg in desc:
                         logger.warning("- %s", msg)
                 else:
@@ -452,17 +443,17 @@ def _ensure_requirements(
             # before changing their rio
             print(
                 "\n"
-                "Deployer has detected that the packages installed on your SystemCore do not match\n"
+                "Deployer has detected that the packages installed on your robot do not match\n"
                 "the requirements in pyproject.toml. The installer will now:\n"
             )
             if not no_uninstall:
                 prompt = "Continue with uninstall + install?"
-                print("* Uninstall ALL Python packages from the SystemCore")
+                print("* Uninstall ALL Python packages from the robot")
             else:
                 prompt = "Continue with install?"
 
             print(
-                "* Install required packages on the SystemCore\n"
+                "* Install required packages on the robot\n"
                 "\n"
                 "If you do not wish to do this, specify --no-install as a deploy argument, or answer 'n'.\n"
             )
@@ -478,93 +469,73 @@ def _ensure_requirements(
         ):
             if no_install and not python_exists:
                 raise Error(
-                    "python3 was not found on the SystemCore\n"
+                    "python3 was not found on the robot\n"
                     "- could not install it because no-install was specified\n"
                     "- Use 'python -m robotpy installer install-python' to install python separately"
                 )
 
-            # This also will give more memory
-            ssh.exec_bash(
-                ". /etc/profile.d/frc-path.sh",
-                ". /etc/profile.d/natinst-path.sh",
-                robot_utils.kill_robot_cmd,
-            )
+            ssh.exec_bash(robot_utils.kill_robot_cmd)
 
-            with installer.connect_to_robot(
-                project_path=project_path,
-                main_file=main_file,
-                ignore_image_version=ignore_image_version,
-                ssh=ssh,
-            ):
-                if not kill_script_updated:
-                    robot_utils.update_kill_script(installer.ssh)
-
-                if cpp_java_exists:
-                    robot_utils.uninstall_cpp_java_admin(installer.ssh)
-
-                if python_invalid:
-                    with wrap_ssh_error("uninstalling python"):
-                        self._clear_pip_packages(installer)
-                        logger.info("Uninstalling %s from SystemCore", python_invalid)
-                        installer.ssh.exec_cmd(
-                            f"opkg remove {python_invalid}",
-                            check=True,
-                            print_output=True,
-                        )
-
-                if not python_exists:
-                    try:
-                        installer.install_python()
-                    except PythonMissingError as e:
-                        raise PythonMissingError(
-                            f"{e}\n\n"
-                            "Run 'python -m robotpy sync' to download your project requirements from the internet (or --no-install to ignore)"
-                        ) from e
+            if python_invalid:
+                with wrap_ssh_error("uninstalling python"):
+                    self._clear_pip_packages(installer)
+                    logger.info("Uninstalling %s from robot", python_invalid)
+                    installer.uninstall_python()
+                    python_exists = False
 
-                if not requirements_installed:
-                    assert project is not None
-                    packages = project.get_install_list()
-
-                    # Check if everything is in the cache before doing the install
-                    cached = self._get_cached_packages(installer)
-                    ok, missing = project.are_requirements_met(
-                        cached,
-                        pypackages.robot_env(),
-                        pypackages.make_cache_extra_resolver(cached),
+            if not python_exists:
+                try:
+                    installer.install_python()
+                except PythonMissingError as e:
+                    raise PythonMissingError(
+                        f"{e}\n\n"
+                        "Run 'python -m robotpy sync' to download your project requirements from the internet (or --no-install to ignore)"
+                    ) from e
+
+            if not requirements_installed:
+                assert project is not None
+                packages = project.get_install_list()
+
+                # Check if everything is in the cache before doing the install
+                cached = self._get_cached_packages(installer)
+                ok, missing = project.are_requirements_met(
+                    cached,
+                    pypackages.robot_env(),
+                    pypackages.make_cache_extra_resolver(cached),
+                )
+                if not ok:
+                    errmsg = ["Project requirements not found in download cache!"]
+                    errmsg.extend([f"- {msg}" for msg in missing])
+                    errmsg += [
+                        "",
+                        "Run 'python -m robotpy sync' to download your project requirements",
+                        "from the internet (or specify --no-install to not attempt installation).",
+                    ]
+                    raise Error("\n".join(errmsg))
+
+                if not no_uninstall:
+                    logger.info(
+                        "Clearing existing packages on robot before install (specify --no-uninstall to not do this)"
                     )
-                    if not ok:
-                        errmsg = ["Project requirements not found in download cache!"]
-                        errmsg.extend([f"- {msg}" for msg in missing])
-                        errmsg += [
-                            "",
-                            "Run 'python -m robotpy sync' to download your project requirements",
-                            "from the internet (or specify --no-install to not attempt installation).",
-                        ]
-                        raise Error("\n".join(errmsg))
-
-                    if not no_uninstall:
-                        logger.info(
-                            "Clearing existing packages on SystemCore before install (specify --no-uninstall to not do this)"
-                        )
-                        # The user may have deleted something from the project
-                        # requirements so the only way to ensure the exact
-                        # environment is to first clear the environment.
-                        # - can't do a partial uninstall without completely
-                        #   resolving everything
-                        self._clear_pip_packages(installer)
-
-                    logger.info("Installing project requirements on SystemCore:")
-                    for package in packages:
-                        logger.info("- %s", package)
-
-                    try:
-                        installer.pip_install(False, False, False, False, [], packages)
-                    except PipInstallError as e:
-                        raise PipInstallError(
-                            f"{e}\n\n"
-                            "If 'no matching distribution found', run 'python -m robotpy sync' to download your\n"
-                            "project requirements from the internet (or --no-install to ignore)."
-                        ) from e
+                    # The user may have deleted something from the project
+                    # requirements so the only way to ensure the exact
+                    # environment is to first clear the environment.
+                    # - can't do a partial uninstall without completely
+                    #   resolving everything
+                    self._clear_pip_packages(installer)
+
+                logger.info("Installing project requirements on robot:")
+                for package in packages:
+                    logger.info("- %s", package)
+
+                try:
+                    installer.pip_install(False, False, False, False, [], packages)
+                except PipInstallError as e:
+                    raise PipInstallError(
+                        f"{e}\n\n"
+                        "If 'no matching distribution found', run 'python -m robotpy sync' to download your\n"
+                        "project requirements from the internet (or --no-install to ignore)."
+                    ) from e
 
     def _do_deploy(
         self,
@@ -580,12 +551,7 @@ def _do_deploy(
         # GradleRIO kills the robot before deploying it, so we do that too
         logger.info("Killing robot program")
         with wrap_ssh_error("killing robot program"):
-            ssh.exec_bash(
-                ". /etc/profile.d/frc-path.sh",
-                ". /etc/profile.d/natinst-path.sh",
-                "/usr/local/frc/bin/frcKillRobot.sh -t",
-                check=False,
-            )
+            ssh.exec_bash(robot_utils.kill_robot_cmd, check=False)
 
         deploy_dir = pathlib.PurePosixPath("/home/systemcore")
         py_deploy_subdir = "py"
@@ -599,18 +565,12 @@ def _do_deploy(
 
         if debug:
             compileall_flags = ""
-            deployed_cmd = (
-                "env LD_LIBRARY_PATH=/usr/local/frc/lib/ "
-                f"/usr/local/bin/python3 -u -m robotpy --main {py_deploy_dir}/{robot_filename} -v run"
-            )
+            deployed_cmd = f"{_ROBOT_VENV_PYTHON} -u -m robotpy --main {py_deploy_dir}/{robot_filename} -v run"
             deployed_cmd_fname = "robotDebugCommand"
             bash_cmd = "/bin/bash -cex"
         else:
             compileall_flags = "-O"
-            deployed_cmd = (
-                "env LD_LIBRARY_PATH=/usr/local/frc/lib/ "
-                f"/usr/local/bin/python3 -u -O -m robotpy --main {py_deploy_dir}/{robot_filename} run"
-            )
+            deployed_cmd = f"{_ROBOT_VENV_PYTHON} -u -O -m robotpy --main {py_deploy_dir}/{robot_filename} run"
             deployed_cmd_fname = "robotCommand"
             bash_cmd = "/bin/bash -ce"
 
@@ -622,6 +582,8 @@ def _do_deploy(
                 f'echo "{deployed_cmd}" > {deploy_dir}/{deployed_cmd_fname}', check=True
             )
 
+            ssh.exec_cmd(f"chmod +x {robot_utils.robot_command}", check=True)
+
         if debug:
             with wrap_ssh_error("touching frcDebug"):
                 ssh.exec_cmd("touch /tmp/frcdebug", check=True)
@@ -658,12 +620,10 @@ def _do_deploy(
         sshcmd = (
             f"{bash_cmd} '"
             f"{replace_cmd};"
-            f"/usr/local/bin/python3 {compileall_flags} -m compileall -q -r 5 /home/systemcore/py;"
-            ". /etc/profile.d/frc-path.sh; "
-            ". /etc/profile.d/natinst-path.sh; "
-            f"chown -R lvuser:ni {py_deploy_dir}; "
-            "sync; "
-            "/usr/local/frc/bin/frcKillRobot.sh -t -r || true"
+            f"{_ROBOT_VENV_PYTHON} {compileall_flags} -m compileall -q -r 5 /home/systemcore/py;"
+            "sudo sync; "
+            "sudo systemctl enable robot;"
+            "sudo systemctl start robot;"
             "'"
         )
 

robotpy_installer/cli_undeploy.py

@@ -79,7 +79,7 @@ def run(
                 ssh.exec_cmd("rm -rf /home/systemcore/py")
 
                 # for good measure, delete the start command too
-                ssh.exec_cmd("rm -f /home/systemcore/robotCommand")
+                ssh.exec_cmd(f"rm -f {robot_utils.robot_command}")
 
         except sshcontroller.SshExecError as e:
             print_err("ERROR:", str(e))