Bump JDK 8u242-b08 to 17.0.7+7

changes/1065.feature.rst

@@ -0,0 +1 @@
+The version of OpenJDK for Java was updated from 8 to 17.

src/briefcase/commands/base.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import argparse
 import importlib
 import inspect
@@ -9,7 +11,6 @@
 from abc import ABC, abstractmethod
 from argparse import RawDescriptionHelpFormatter
 from pathlib import Path
-from typing import Optional
 
 from cookiecutter import exceptions as cookiecutter_exceptions
 from cookiecutter.repository import is_repo_url
@@ -26,7 +27,7 @@
     import tomli as tomllib
 
 from briefcase import __version__
-from briefcase.config import AppConfig, BaseConfig, GlobalConfig, parse_config
+from briefcase.config import AppConfig, GlobalConfig, parse_config
 from briefcase.console import Console, Log
 from briefcase.exceptions import (
     BriefcaseCommandError,
@@ -108,6 +109,9 @@ class BaseCommand(ABC):
     GLOBAL_CONFIG_CLASS = GlobalConfig
     APP_CONFIG_CLASS = AppConfig
     allows_passthrough = False
+    # if specified for a platform, then any template for that
+    # platform must declare compatibility with that version or later.
+    oldest_compatible_briefcase: str | None = None
 
     def __init__(
         self,
@@ -149,7 +153,7 @@ def __init__(
         Download.verify(tools=self.tools)
 
         self.global_config = None
-        self._path_index = {}
+        self._briefcase_toml: dict[AppConfig, dict[str, ...]] = {}
 
     @property
     def logger(self):
@@ -324,104 +328,95 @@ def binary_path(self, app):
 
         :param app: The app config
         """
-        ...
 
-    def _load_path_index(self, app: BaseConfig):
-        """Load the path index from the index file provided by the app template.
+    def briefcase_toml(self, app: AppConfig) -> dict[str, ...]:
+        """Load the ``briefcase.toml`` file provided by the app template.
 
         :param app: The config object for the app
-        :return: The contents of the application path index.
+        :return: The contents of ``briefcase.toml``
         """
         try:
-            with (self.bundle_path(app) / "briefcase.toml").open("rb") as f:
-                self._path_index[app] = tomllib.load(f)["paths"]
-        except OSError as e:
-            raise BriefcaseCommandError(
-                f"Unable to find '{self.bundle_path(app) / 'briefcase.toml'}'"
-            ) from e
-        return self._path_index[app]
+            return self._briefcase_toml[app]
+        except KeyError:
+            try:
+                with (self.bundle_path(app) / "briefcase.toml").open("rb") as f:
+                    self._briefcase_toml[app] = tomllib.load(f)
+            except OSError as e:
+                raise BriefcaseCommandError(
+                    f"Unable to find '{self.bundle_path(app) / 'briefcase.toml'}'"
+                ) from e
+            else:
+                return self._briefcase_toml[app]
 
-    def support_path(self, app: BaseConfig):
-        """Obtain the path into which the support package should be unpacked.
+    def path_index(self, app: AppConfig, path_name: str) -> str | dict | list:
+        """Return a path from the path index provided by the app template.
+
+        Raises KeyError if ``path_name`` is not defined in the index.
 
         :param app: The config object for the app
-        :return: The full path where the support package should be unpacked.
+        :param path_name: Name of the filepath to retrieve
+        :return: filepath for requested path
         """
-        # If the index file hasn't been loaded for this app, load it.
+        return self.briefcase_toml(app=app)["paths"][path_name]
+
+    def briefcase_target_version(self, app: AppConfig) -> str | None:
+        """The list of requirements to build an app from ``briefcase.toml``."""
         try:
-            path_index = self._path_index[app]
+            return self.briefcase_toml(app)["briefcase"]["target_version"]
         except KeyError:
-            path_index = self._load_path_index(app)
-        return self.bundle_path(app) / path_index["support_path"]
+            return None
+
+    def support_path(self, app: AppConfig) -> Path:
+        """Obtain the path into which the support package should be unpacked.
 
-    def support_revision(self, app: BaseConfig):
+        :param app: The config object for the app
+        :return: The full path where the support package should be unpacked.
+        """
+        return self.bundle_path(app) / self.path_index(app, "support_path")
+
+    def support_revision(self, app: AppConfig) -> str:
         """Obtain the support package revision that the template requires.
 
         :param app: The config object for the app
         :return: The support revision required by the template.
         """
-        # If the index file hasn't been loaded for this app, load it.
-        try:
-            path_index = self._path_index[app]
-        except KeyError:
-            path_index = self._load_path_index(app)
-        return path_index["support_revision"]
+        return self.path_index(app, "support_revision")
 
-    def cleanup_paths(self, app: BaseConfig):
+    def cleanup_paths(self, app: AppConfig) -> list[str]:
         """Obtain the paths generated by the app template that should be cleaned up
         prior to release.
 
         :param app: The config object for the app
         :return: The list of path globs inside the app template that should
             be cleaned up.
         """
-        # If the index file hasn't been loaded for this app, load it.
-        try:
-            path_index = self._path_index[app]
-        except KeyError:
-            path_index = self._load_path_index(app)
-        return path_index["cleanup_paths"]
+        return self.path_index(app, "cleanup_paths")
 
-    def app_requirements_path(self, app: BaseConfig):
+    def app_requirements_path(self, app: AppConfig) -> Path:
         """Obtain the path into which a requirements.txt file should be written.
 
         :param app: The config object for the app
         :return: The full path where the requirements.txt file should be written
         """
-        # If the index file hasn't been loaded for this app, load it.
-        try:
-            path_index = self._path_index[app]
-        except KeyError:
-            path_index = self._load_path_index(app)
-        return self.bundle_path(app) / path_index["app_requirements_path"]
+        return self.bundle_path(app) / self.path_index(app, "app_requirements_path")
 
-    def app_packages_path(self, app: BaseConfig):
+    def app_packages_path(self, app: AppConfig) -> Path:
         """Obtain the path into which requirements should be installed.
 
         :param app: The config object for the app
         :return: The full path where application requirements should be installed.
         """
-        # If the index file hasn't been loaded for this app, load it.
-        try:
-            path_index = self._path_index[app]
-        except KeyError:
-            path_index = self._load_path_index(app)
-        return self.bundle_path(app) / path_index["app_packages_path"]
+        return self.bundle_path(app) / self.path_index(app, "app_packages_path")
 
-    def app_path(self, app: BaseConfig):
+    def app_path(self, app: AppConfig) -> Path:
         """Obtain the path into which the application should be installed.
 
         :param app: The config object for the app
         :return: The full path where application code should be installed.
         """
-        # If the index file hasn't been loaded for this app, load it.
-        try:
-            path_index = self._path_index[app]
-        except KeyError:
-            path_index = self._load_path_index(app)
-        return self.bundle_path(app) / path_index["app_path"]
+        return self.bundle_path(app) / self.path_index(app, "app_path")
 
-    def app_module_path(self, app):
+    def app_module_path(self, app: AppConfig) -> Path:
         """Find the path for the application module for an app.
 
         :param app: The config object for the app
@@ -484,7 +479,7 @@ def verify_tools(self):
         """
         pass
 
-    def finalize_app_config(self, app: BaseConfig):
+    def finalize_app_config(self, app: AppConfig):
         """Finalize the application config.
 
         Some app configurations (notably, Linux system packages like .deb) have
@@ -502,7 +497,7 @@ def finalize_app_config(self, app: BaseConfig):
         """
         pass
 
-    def finalize(self, app: Optional[BaseConfig] = None):
+    def finalize(self, app: AppConfig | None = None):
         """Finalize Briefcase configuration.
 
         This will:
@@ -529,7 +524,7 @@ def finalize(self, app: Optional[BaseConfig] = None):
                 self.finalize_app_config(app)
                 delattr(app, "__draft__")
 
-    def verify_app_tools(self, app: BaseConfig):
+    def verify_app_tools(self, app: AppConfig):
         """Verify that tools needed to run the command for this app exist."""
         pass
 

src/briefcase/commands/build.py

@@ -1,6 +1,9 @@
 from typing import Optional
 
-from briefcase.config import BaseConfig
+from packaging.version import Version
+
+import briefcase
+from briefcase.config import AppConfig, BaseConfig
 from briefcase.exceptions import BriefcaseCommandError
 
 from .base import BaseCommand, full_options
@@ -14,16 +17,66 @@ def add_options(self, parser):
         self._add_update_options(parser, context_label=" before building")
         self._add_test_options(parser, context_label="Build")
 
-    def build_app(self, app: BaseConfig, **options):
+    def build_app(self, app: AppConfig, **options):
         """Build an application.
 
         :param app: The application to build
         """
         # Default implementation; nothing to build.
 
+    def verify_template(self, app: AppConfig):
+        """Verify the template satisfies the Command's requirements."""
+        self.logger.info("Checking template compatability...", prefix=app.app_name)
+
+        with self.input.wait_bar("Verifying Briefcase support..."):
+            # check against the "release" for each Version since versions
+            # such as "0.3.15.dev123" are considered older than "0.3.15"
+
+            if template_target := self.briefcase_target_version(app=app):
+                template_target = Version(template_target).release
+
+            if platform_target := self.oldest_compatible_briefcase:
+                platform_target = Version(platform_target).release
+
+            if platform_target and not template_target:
+                raise BriefcaseCommandError(
+                    f"""\
+The app template must declare a target version of Briefcase to confirm it is
+compatible with this version of Briefcase.
+
+The template's target Briefcase version must be {'.'.join(map(str, platform_target))} or later.
+
+Once the template is updated, run the create command:
+
+    $ briefcase create {self.platform} {self.output_format}
+"""
+                )
+
+            current_version = Version(briefcase.__version__).release
+            if (platform_target and platform_target > template_target) or (
+                template_target and template_target > current_version
+            ):
+                minimum_version = ".".join(map(str, platform_target or current_version))
+                raise BriefcaseCommandError(
+                    f"""\
+The app template is not compatible with this version of Briefcase since it is
+targeting version {'.'.join(map(str, template_target))}.
+
+If you are using BeeWare's default template, then running the create command
+to update the app using a compatible version of the app template.
+
+If a custom template is being used, it must be updated to be compatible with
+Briefcase version {minimum_version} before re-running the create command.
+
+To run the create command:
+
+    $ briefcase create {self.platform} {self.output_format}
+"""
+                )
+
     def _build_app(
         self,
-        app: BaseConfig,
+        app: AppConfig,
         update: bool,
         update_requirements: bool,
         update_resources: bool,
@@ -68,6 +121,7 @@ def _build_app(
         else:
             state = None
 
+        self.verify_template(app)
         self.verify_app_tools(app)
 
         state = self.build_app(app, test_mode=test_mode, **full_options(state, options))