Switch legacy platform manager to the new

platformio/platform/_packages.py

@@ -13,9 +13,62 @@
 # limitations under the License.
 
 from platformio.package.exception import UnknownPackageError
+from platformio.package.meta import PackageSpec
 
 
 class PlatformPackagesMixin(object):
+    def get_package_spec(self, name):
+        version = self.packages[name].get("version", "")
+        if any(c in version for c in (":", "/", "@")):
+            return PackageSpec("%s=%s" % (name, version))
+        return PackageSpec(
+            owner=self.packages[name].get("owner"), name=name, requirements=version
+        )
+
+    def get_package(self, name):
+        if not name:
+            return None
+        return self.pm.get_package(self.get_package_spec(name))
+
+    def get_package_dir(self, name):
+        pkg = self.get_package(name)
+        return pkg.path if pkg else None
+
+    def get_package_version(self, name):
+        pkg = self.get_package(name)
+        return str(pkg.metadata.version) if pkg else None
+
+    def get_installed_packages(self):
+        result = []
+        for name in self.packages:
+            pkg = self.get_package(name)
+            if pkg:
+                result.append(pkg)
+        return result
+
+    def dump_used_packages(self):
+        result = []
+        for name, options in self.packages.items():
+            if options.get("optional"):
+                continue
+            pkg = self.get_package(name)
+            if not pkg or not pkg.metadata:
+                continue
+            item = {"name": pkg.metadata.name, "version": str(pkg.metadata.version)}
+            if pkg.metadata.spec.external:
+                item["src_url"] = pkg.metadata.spec.url
+            result.append(item)
+        return result
+
+    def autoinstall_runtime_packages(self):
+        for name, options in self.packages.items():
+            if options.get("optional", False):
+                continue
+            if self.get_package(name):
+                continue
+            self.pm.install(self.get_package_spec(name))
+        return True
+
     def install_packages(  # pylint: disable=too-many-arguments
         self,
         with_packages=None,
@@ -24,31 +77,25 @@ class PlatformPackagesMixin(object):
         silent=False,
         force=False,
     ):
-        with_packages = set(self.find_pkg_names(with_packages or []))
-        without_packages = set(self.find_pkg_names(without_packages or []))
+        with_packages = set(self._find_pkg_names(with_packages or []))
+        without_packages = set(self._find_pkg_names(without_packages or []))
 
         upkgs = with_packages | without_packages
         ppkgs = set(self.packages)
         if not upkgs.issubset(ppkgs):
             raise UnknownPackageError(", ".join(upkgs - ppkgs))
 
-        for name, opts in self.packages.items():
-            version = opts.get("version", "")
+        for name, options in self.packages.items():
             if name in without_packages:
                 continue
             if name in with_packages or not (
-                skip_default_package or opts.get("optional", False)
+                skip_default_package or options.get("optional", False)
             ):
-                if ":" in version:
-                    self.pm.install(
-                        "%s=%s" % (name, version), silent=silent, force=force
-                    )
-                else:
-                    self.pm.install(name, version, silent=silent, force=force)
+                self.pm.install(self.get_package_spec(name), silent=silent, force=force)
 
         return True
 
-    def find_pkg_names(self, candidates):
+    def _find_pkg_names(self, candidates):
         result = []
         for candidate in candidates:
             found = False
@@ -73,54 +120,18 @@ class PlatformPackagesMixin(object):
         return result
 
     def update_packages(self, only_check=False):
-        for name, manifest in self.get_installed_packages().items():
-            requirements = self.packages[name].get("version", "")
-            if ":" in requirements:
-                _, requirements, __ = self.pm.parse_pkg_uri(requirements)
-            self.pm.update(manifest["__pkg_dir"], requirements, only_check)
-
-    def get_installed_packages(self):
-        items = {}
-        for name in self.packages:
-            pkg_dir = self.get_package_dir(name)
-            if pkg_dir:
-                items[name] = self.pm.load_manifest(pkg_dir)
-        return items
+        for pkg in self.get_installed_packages():
+            self.pm.update(
+                pkg,
+                to_spec=self.get_package_spec(pkg.metadata.name),
+                only_check=only_check,
+                show_incompatible=False,
+            )
 
     def are_outdated_packages(self):
-        for name, manifest in self.get_installed_packages().items():
-            requirements = self.packages[name].get("version", "")
-            if ":" in requirements:
-                _, requirements, __ = self.pm.parse_pkg_uri(requirements)
-            if self.pm.outdated(manifest["__pkg_dir"], requirements):
+        for pkg in self.get_installed_packages():
+            if self.pm.outdated(
+                pkg, self.get_package_spec(pkg.metadata.name)
+            ).is_outdated(allow_incompatible=False):
                 return True
         return False
-
-    def get_package_dir(self, name):
-        version = self.packages[name].get("version", "")
-        if ":" in version:
-            return self.pm.get_package_dir(
-                *self.pm.parse_pkg_uri("%s=%s" % (name, version))
-            )
-        return self.pm.get_package_dir(name, version)
-
-    def get_package_version(self, name):
-        pkg_dir = self.get_package_dir(name)
-        if not pkg_dir:
-            return None
-        return self.pm.load_manifest(pkg_dir).get("version")
-
-    def dump_used_packages(self):
-        result = []
-        for name, options in self.packages.items():
-            if options.get("optional"):
-                continue
-            pkg_dir = self.get_package_dir(name)
-            if not pkg_dir:
-                continue
-            manifest = self.pm.load_manifest(pkg_dir)
-            item = {"name": manifest["name"], "version": manifest["version"]}
-            if manifest.get("__src_url"):
-                item["src_url"] = manifest.get("__src_url")
-            result.append(item)
-        return result

platformio/platform/_run.py

@@ -50,12 +50,14 @@ class PlatformRunMixin(object):
         assert isinstance(variables, dict)
         assert isinstance(targets, list)
 
+        self.ensure_engine_compatible()
+
         options = self.config.items(env=variables["pioenv"], as_dict=True)
         if "framework" in options:
             # support PIO Core 3.0 dev/platforms
             options["pioframework"] = options["framework"]
         self.configure_default_packages(options, targets)
-        self.install_packages(silent=True)
+        self.autoinstall_runtime_packages()
 
         self._report_non_sensitive_data(options, targets)
 
@@ -84,8 +86,6 @@ class PlatformRunMixin(object):
             for item in self.dump_used_packages()
         ]
         topts["platform"] = {"name": self.name, "version": self.version}
-        if self.src_version:
-            topts["platform"]["src_version"] = self.src_version
         telemetry.send_run_environment(topts, targets)
 
     def _run_scons(self, variables, targets, jobs):

platformio/platform/base.py

@@ -19,11 +19,11 @@ import click
 import semantic_version
 
 from platformio import __version__, fs, proc, util
-from platformio.managers.package import PackageManager
+from platformio.package.manager.tool import ToolPackageManager
 from platformio.platform._packages import PlatformPackagesMixin
 from platformio.platform._run import PlatformRunMixin
 from platformio.platform.board import PlatformBoardConfig
-from platformio.platform.exception import UnknownBoard
+from platformio.platform.exception import IncompatiblePlatform, UnknownBoard
 from platformio.project.config import ProjectConfig
 
 
@@ -44,20 +44,7 @@ class PlatformBase(  # pylint: disable=too-many-instance-attributes,too-many-pub
         self._custom_packages = None
 
         self.config = ProjectConfig.get_instance()
-        self.pm = PackageManager(
-            self.config.get_optional_dir("packages"), self.package_repositories
-        )
-
-        self._src_manifest = None
-        src_manifest_path = self.pm.get_src_manifest_path(self.get_dir())
-        if src_manifest_path:
-            self._src_manifest = fs.load_json(src_manifest_path)
-
-        # if self.engines and "platformio" in self.engines:
-        #     if self.PIO_VERSION not in semantic_version.SimpleSpec(
-        #             self.engines['platformio']):
-        #         raise exception.IncompatiblePlatform(self.name,
-        #                                              str(self.PIO_VERSION))
+        self.pm = ToolPackageManager(self.config.get_optional_dir("packages"))
 
     @property
     def name(self):
@@ -75,14 +62,6 @@ class PlatformBase(  # pylint: disable=too-many-instance-attributes,too-many-pub
     def version(self):
         return self._manifest["version"]
 
-    @property
-    def src_version(self):
-        return self._src_manifest.get("version") if self._src_manifest else None
-
-    @property
-    def src_url(self):
-        return self._src_manifest.get("url") if self._src_manifest else None
-
     @property
     def homepage(self):
         return self._manifest.get("homepage")
@@ -103,10 +82,6 @@ class PlatformBase(  # pylint: disable=too-many-instance-attributes,too-many-pub
     def engines(self):
         return self._manifest.get("engines")
 
-    @property
-    def package_repositories(self):
-        return self._manifest.get("packageRepositories")
-
     @property
     def manifest(self):
         return self._manifest
@@ -114,21 +89,32 @@ class PlatformBase(  # pylint: disable=too-many-instance-attributes,too-many-pub
     @property
     def packages(self):
         packages = self._manifest.get("packages", {})
-        for item in self._custom_packages or []:
-            name = item
-            version = "*"
-            if "@" in item:
-                name, version = item.split("@", 2)
-            name = name.strip()
-            if name not in packages:
-                packages[name] = {}
-            packages[name].update({"version": version.strip(), "optional": False})
+        for spec in self._custom_packages or []:
+            spec = self.pm.ensure_spec(spec)
+            if spec.external:
+                version = spec.url
+            else:
+                version = str(spec.requirements) or "*"
+            if spec.name not in packages:
+                packages[spec.name] = {}
+            packages[spec.name].update(
+                {"owner": spec.owner, "version": version, "optional": False}
+            )
         return packages
 
     @property
     def python_packages(self):
         return self._manifest.get("pythonPackages")
 
+    def ensure_engine_compatible(self):
+        if not self.engines or "platformio" not in self.engines:
+            return True
+        if self.PIO_VERSION in semantic_version.SimpleSpec(self.engines["platformio"]):
+            return True
+        raise IncompatiblePlatform(
+            self.name, str(self.PIO_VERSION), self.engines["platformio"]
+        )
+
     def get_dir(self):
         return os.path.dirname(self.manifest_path)
 
@@ -218,10 +204,10 @@ class PlatformBase(  # pylint: disable=too-many-instance-attributes,too-many-pub
         for opts in (self.frameworks or {}).values():
             if "package" not in opts:
                 continue
-            pkg_dir = self.get_package_dir(opts["package"])
-            if not pkg_dir or not os.path.isdir(os.path.join(pkg_dir, "libraries")):
+            pkg = self.get_package(opts["package"])
+            if not pkg or not os.path.isdir(os.path.join(pkg.path, "libraries")):
                 continue
-            libs_dir = os.path.join(pkg_dir, "libraries")
+            libs_dir = os.path.join(pkg.path, "libraries")
             storages[libs_dir] = opts["package"]
             libcores_dir = os.path.join(libs_dir, "__cores__")
             if not os.path.isdir(libcores_dir):

platformio/platform/exception.py

@@ -26,7 +26,10 @@ class UnknownPlatform(PlatformException):
 
 class IncompatiblePlatform(PlatformException):
 
-    MESSAGE = "Development platform '{0}' is not compatible with PIO Core v{1}"
+    MESSAGE = (
+        "Development platform '{0}' is not compatible with PlatformIO Core v{1} and "
+        "depends on PlatformIO Core {2}.\n"
+    )
 
 
 class UnknownBoard(PlatformException):

platformio/platform/factory.py

@@ -16,7 +16,7 @@ import os
 import re
 
 from platformio.compat import load_python_module
-from platformio.package.manager.platform import PlatformPackageManager
+from platformio.package.meta import PackageItem
 from platformio.platform.base import PlatformBase
 from platformio.platform.exception import UnknownPlatform
 
@@ -36,9 +36,16 @@ class PlatformFactory(object):
 
     @classmethod
     def new(cls, pkg_or_spec):
-        pkg = PlatformPackageManager().get_package(
-            "file://%s" % pkg_or_spec if os.path.isdir(pkg_or_spec) else pkg_or_spec
-        )
+        if isinstance(pkg_or_spec, PackageItem):
+            pkg = pkg_or_spec
+        else:
+            from platformio.package.manager.platform import (  # pylint: disable=import-outside-toplevel
+                PlatformPackageManager,
+            )
+
+            pkg = PlatformPackageManager().get_package(
+                "file://%s" % pkg_or_spec if os.path.isdir(pkg_or_spec) else pkg_or_spec
+            )
         if not pkg:
             raise UnknownPlatform(pkg_or_spec)