Merge branch 'release/v5.2.1'

Signed-off-by: Christophe PAVOT <christophe.pavot@wiifor.com>

.github/workflows/core.yml

@@ -1,6 +1,6 @@
 name: Core
 
-on: [push]
+on: [push, pull_request]
 
 jobs:
   build:
@@ -8,17 +8,18 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        python-version: [2.7, 3.7]
+        python-version: [3.6, 3.7, 3.8, 3.9]
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v2
+        with:
+          submodules: "recursive"
       - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v1
         with:
           python-version: ${{ matrix.python-version }}
       - name: Install dependencies
         run: |
-          git submodule update --init --recursive
           python -m pip install --upgrade pip
           pip install tox
 
@@ -27,8 +28,9 @@ jobs:
           tox -e lint
       - name: Integration Tests
         env:
-          PLATFORMIO_TEST_ACCOUNT_LOGIN: ${{ secrets.PLATFORMIO_TEST_ACCOUNT_LOGIN }}
-          PLATFORMIO_TEST_ACCOUNT_PASSWORD: ${{ secrets.PLATFORMIO_TEST_ACCOUNT_PASSWORD }}
+          TEST_EMAIL_LOGIN: ${{ secrets.TEST_EMAIL_LOGIN }}
+          TEST_EMAIL_PASSWORD: ${{ secrets.TEST_EMAIL_PASSWORD }}
+          TEST_EMAIL_IMAP_SERVER: ${{ secrets.TEST_EMAIL_IMAP_SERVER }}
         run: |
           tox -e testcore
 
@@ -40,3 +42,4 @@ jobs:
           job_name: '*Core*'
           commit: true
           url: ${{ secrets.SLACK_BUILD_WEBHOOK }}
+          token: ${{ secrets.SLACK_GITHUB_TOKEN }}

.github/workflows/docs.yml

@@ -1,19 +1,21 @@
 name: Docs
 
-on: [push]
+on: [push, pull_request]
 
 jobs:
   build:
+    name: Build Docs
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+        with:
+          submodules: "recursive"
       - name: Set up Python
-        uses: actions/setup-python@v1
+        uses: actions/setup-python@v2
         with:
           python-version: 3.7
       - name: Install dependencies
         run: |
-          git submodule update --init --recursive
           python -m pip install --upgrade pip
           pip install tox
 
@@ -28,4 +30,80 @@ jobs:
           type: ${{ job.status }}
           job_name: '*Docs*'
           commit: true
-          url: ${{ secrets.SLACK_BUILD_WEBHOOK }}
+          url: ${{ secrets.SLACK_BUILD_WEBHOOK }}
+          token: ${{ secrets.SLACK_GITHUB_TOKEN }}
+
+      - name: Preserve Docs
+        if: ${{ github.event_name == 'push' }}
+        run: |
+          tar -czvf docs.tar.gz -C docs/_build html rtdpage
+
+      - name: Save artifact
+        if: ${{ github.event_name == 'push' }}
+        uses: actions/upload-artifact@v2
+        with:
+          name: docs
+          path: ./docs.tar.gz
+
+  deploy:
+    name: Deploy Docs
+    needs: build
+    runs-on: ubuntu-latest
+    env:
+      DOCS_REPO: platformio/platformio-docs
+      DOCS_DIR: platformio-docs
+      LATEST_DOCS_DIR: latest-docs
+      RELEASE_BUILD: ${{ startsWith(github.ref, 'refs/tags/v') }}
+    if: ${{ github.event_name == 'push' }}
+    steps:
+      - name: Download artifact
+        uses: actions/download-artifact@v2
+        with:
+          name: docs
+      - name: Unpack artifact
+        run: |
+          mkdir ./${{ env.LATEST_DOCS_DIR }}
+          tar -xzf ./docs.tar.gz -C ./${{ env.LATEST_DOCS_DIR }}
+      - name: Delete Artifact
+        uses: geekyeggo/delete-artifact@v1
+        with:
+          name: docs
+      - name: Select Docs type
+        id: get-destination-dir
+        run: |
+          if [[ ${{ env.RELEASE_BUILD }} == true ]]; then
+            echo "::set-output name=dst_dir::stable"
+          else
+            echo "::set-output name=dst_dir::latest"
+          fi
+      - name: Checkout latest Docs
+        continue-on-error: true
+        uses: actions/checkout@v2
+        with:
+          repository: ${{ env.DOCS_REPO }}
+          path: ${{ env.DOCS_DIR }}
+          ref: gh-pages
+      - name: Synchronize Docs
+        run: |
+          rm -rf ${{ env.DOCS_DIR }}/.git
+          rm -rf ${{ env.DOCS_DIR }}/en/${{ steps.get-destination-dir.outputs.dst_dir }}
+          mkdir -p ${{ env.DOCS_DIR }}/en/${{ steps.get-destination-dir.outputs.dst_dir }}
+          cp -rf ${{ env.LATEST_DOCS_DIR }}/html/* ${{ env.DOCS_DIR }}/en/${{ steps.get-destination-dir.outputs.dst_dir }}
+          if [[ ${{ env.RELEASE_BUILD }} == false ]]; then
+            rm -rf ${{ env.DOCS_DIR }}/page
+            mkdir -p ${{ env.DOCS_DIR }}/page
+            cp -rf ${{ env.LATEST_DOCS_DIR }}/rtdpage/* ${{ env.DOCS_DIR }}/page
+          fi
+      - name: Validate Docs
+        run: |
+          if [ -z "$(ls -A ${{ env.DOCS_DIR }})" ]; then
+             echo "Docs folder is empty. Aborting!"
+             exit 1
+          fi
+      - name: Deploy to Github Pages
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          personal_token: ${{ secrets.PERSONAL_TOKEN }}
+          external_repository: ${{ env.DOCS_REPO }}
+          publish_dir: ./${{ env.DOCS_DIR }}
+          commit_message: Sync Docs

.github/workflows/examples.yml

@@ -1,31 +1,33 @@
 name: Examples
 
-on: [push]
+on: [push, pull_request]
 
 jobs:
   build:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-16.04, windows-latest, macos-latest]
-        python-version: [2.7, 3.7]
+        os: [ubuntu-18.04, windows-latest, macos-latest]
+        python-version: [3.7]
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v2
+        with:
+          submodules: "recursive"
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v1
+        uses: actions/setup-python@v2
         with:
           python-version: ${{ matrix.python-version }}
       - name: Install dependencies
         run: |
-          git submodule update --init --recursive
           python -m pip install --upgrade pip
           pip install tox
 
       - name: Run on Linux
         if: startsWith(matrix.os, 'ubuntu')
         env:
-          PIO_INSTALL_DEVPLATFORMS_IGNORE: "ststm8,infineonxmc,intel_mcs51,aceinna_imu"
+          PIO_INSTALL_DEVPLATFORMS_OWNERNAMES: "platformio"
+          PIO_INSTALL_DEVPLATFORMS_IGNORE: "ststm8,infineonxmc,intel_mcs51"
         run: |
           # ChipKIT issue: install 32-bit support for GCC PIC32
           sudo apt-get install libc6-i386
@@ -39,7 +41,8 @@ jobs:
       - name: Run on macOS
         if: startsWith(matrix.os, 'macos')
         env:
-          PIO_INSTALL_DEVPLATFORMS_IGNORE: "ststm8,infineonxmc,microchippic32,gd32v,nuclei"
+          PIO_INSTALL_DEVPLATFORMS_OWNERNAMES: "platformio"
+          PIO_INSTALL_DEVPLATFORMS_IGNORE: "ststm8,infineonxmc,microchippic32,lattice_ice40,gd32v"
         run: |
           df -h
           tox -e testexamples
@@ -48,6 +51,8 @@ jobs:
         if: startsWith(matrix.os, 'windows')
         env:
           PLATFORMIO_CORE_DIR: C:/pio
+          PLATFORMIO_WORKSPACE_DIR: C:/pio-workspace/$PROJECT_HASH
+          PIO_INSTALL_DEVPLATFORMS_OWNERNAMES: "platformio"
           PIO_INSTALL_DEVPLATFORMS_IGNORE: "ststm8,infineonxmc,riscv_gap"
         run: |
           tox -e testexamples
@@ -60,3 +65,4 @@ jobs:
           job_name: '*Examples*'
           commit: true
           url: ${{ secrets.SLACK_BUILD_WEBHOOK }}
+          token: ${{ secrets.SLACK_GITHUB_TOKEN }}

.isort.cfg

@@ -1,3 +0,0 @@
-[settings]
-line_length=88
-known_third_party=OpenSSL, SCons, autobahn, jsonrpc, twisted, zope

.pylintrc

@@ -1,3 +1,6 @@
+[REPORTS]
+output-format=colorized
+
 [MESSAGES CONTROL]
 disable=
     bad-continuation,
@@ -11,5 +14,10 @@ disable=
     too-few-public-methods,
     useless-object-inheritance,
     useless-import-alias,
-    fixme,
-    bad-option-value
+    bad-option-value,
+    consider-using-dict-items,
+    consider-using-f-string,
+
+    ; PY2 Compat
+    super-with-arguments,
+    raise-missing-from

CONTRIBUTING.md

@@ -1,20 +1,20 @@
 Contributing
 ------------
 
-To get started, <a href="https://www.clahub.com/agreements/platformio/platformio-core">sign the Contributor License Agreement</a>.
+To get started, <a href="https://cla-assistant.io/platformio/platformio-core">sign the Contributor License Agreement</a>.
 
 1. Fork the repository on GitHub.
 2. Clone repository `git clone --recursive https://github.com/YourGithubUsername/platformio-core.git`
 3. Run `pip install tox`
-4. Go to the root of project where is located `tox.ini` and run `tox -e py27`
+4. Go to the root of project where is located `tox.ini` and run `tox -e py37`
 5. Activate current development environment:
 
-   * Windows: `.tox\py27\Scripts\activate`
-   * Bash/ZSH: `source .tox/py27/bin/activate`
-   * Fish: `source .tox/py27/bin/activate.fish`
+   * Windows: `.tox\py37\Scripts\activate`
+   * Bash/ZSH: `source .tox/py37/bin/activate`
+   * Fish: `source .tox/py37/bin/activate.fish`
 
 6. Make changes to code, documentation, etc.
-7. Lint source code `make lint`
+7. Lint source code `make before-commit`
 8. Run the tests `make test`
 9. Build documentation `tox -e docs` (creates a directory _build under docs where you can find the html)
 10. Commit changes to your forked repository

Makefile

@@ -1,13 +1,14 @@
 lint:
-	pylint --rcfile=./.pylintrc ./platformio
+	pylint -j 6 --rcfile=./.pylintrc ./tests
+	pylint -j 6 --rcfile=./.pylintrc ./platformio
 
 isort:
-	isort -rc ./platformio
-	isort -rc ./tests
+	isort ./platformio
+	isort ./tests
 
 format:
-	black --target-version py27 ./platformio
-	black --target-version py27 ./tests
+	black ./platformio
+	black ./tests
 
 test:
 	py.test --verbose --capture=no --exitfirst -n 6 --dist=loadscope tests --ignore tests/test_examples.py
@@ -27,8 +28,11 @@ clean: clean-docs
 
 profile:
 	# Usage $ > make PIOARGS="boards" profile
-	python -m cProfile -o .tox/.tmp/cprofile.prof $(shell which platformio) ${PIOARGS}
+	python -m cProfile -o .tox/.tmp/cprofile.prof -m platformio ${PIOARGS}
 	snakeviz .tox/.tmp/cprofile.prof
 
+pack:
+	python setup.py sdist
+
 publish:
 	python setup.py sdist upload

README.rst

@@ -16,28 +16,28 @@ PlatformIO
 .. image:: https://img.shields.io/badge/license-Apache%202.0-blue.svg
     :target: https://pypi.python.org/pypi/platformio/
     :alt:  License
-.. image:: https://img.shields.io/badge/PlatformIO-Community-orange.svg
-   :alt: Community Forums
-   :target: https://community.platformio.org?utm_source=github&utm_medium=core
+.. image:: https://img.shields.io/badge/PlatformIO-Labs-orange.svg
+   :alt: Community Labs
+   :target: https://piolabs.com/?utm_source=github&utm_medium=core
 
 **Quick Links:** `Web <https://platformio.org?utm_source=github&utm_medium=core>`_ |
 `PlatformIO IDE <https://platformio.org/platformio-ide?utm_source=github&utm_medium=core>`_ |
 `Project Examples <https://github.com/platformio/platformio-examples/>`__ |
 `Docs <https://docs.platformio.org?utm_source=github&utm_medium=core>`_ |
 `Donate <https://platformio.org/donate?utm_source=github&utm_medium=core>`_ |
-`Contact Us <https://platformio.org/contact?utm_source=github&utm_medium=core>`_
+`Contact Us <https://piolabs.com/?utm_source=github&utm_medium=core>`_
 
-**Social:** `Twitter <https://twitter.com/PlatformIO_Org>`_ |
-`LinkedIn <https://www.linkedin.com/company/platformio/>`_ |
+**Social:** `LinkedIn <https://www.linkedin.com/company/platformio/>`_ |
+`Twitter <https://twitter.com/PlatformIO_Org>`_ |
 `Facebook <https://www.facebook.com/platformio>`_ |
-`Hackaday <https://hackaday.io/project/7980-platformio>`_ |
-`Bintray <https://bintray.com/platformio>`_ |
-`Community <https://community.platformio.org?utm_source=github&utm_medium=core>`_
+`Community Forums <https://community.platformio.org?utm_source=github&utm_medium=core>`_
 
 .. image:: https://raw.githubusercontent.com/platformio/platformio-web/develop/app/images/platformio-ide-laptop.png
     :target: https://platformio.org?utm_source=github&utm_medium=core
 
-`PlatformIO <https://platformio.org?utm_source=github&utm_medium=core>`_ a new generation ecosystem for embedded development
+`PlatformIO <https://platformio.org?utm_source=github&utm_medium=core>`_ is a professional collaborative platform for embedded development
+
+**A place where Developers and Teams have true Freedom! No more vendor lock-in!**
 
 * Open source, maximum permissive Apache 2.0 license
 * Cross-platform IDE and Unified Debugger
@@ -49,25 +49,23 @@ Get Started
 -----------
 
 * `What is PlatformIO? <https://docs.platformio.org/page/what-is-platformio.html?utm_source=github&utm_medium=core>`_
-
-Instruments
------------
-
 * `PlatformIO IDE <https://platformio.org/platformio-ide?utm_source=github&utm_medium=core>`_
 * `PlatformIO Core (CLI) <https://docs.platformio.org/page/core.html?utm_source=github&utm_medium=core>`_
-* `Library Management <https://docs.platformio.org/page/librarymanager/index.html?utm_source=github&utm_medium=core>`_
 * `Project Examples <https://github.com/platformio/platformio-examples?utm_source=github&utm_medium=core>`__
+
+Solutions
+---------
+
+* `Library Management <https://docs.platformio.org/page/librarymanager/index.html?utm_source=github&utm_medium=core>`_
 * `Desktop IDEs Integration <https://docs.platformio.org/page/ide.html?utm_source=github&utm_medium=core>`_
 * `Continuous Integration <https://docs.platformio.org/page/ci/index.html?utm_source=github&utm_medium=core>`_
-* `Advanced Scripting API <https://docs.platformio.org/page/projectconf/advanced_scripting.html?utm_source=github&utm_medium=core>`_
 
-Professional
-------------
+**Advanced**
 
-* `PIO Check <https://docs.platformio.org/page/plus/pio-check.html?utm_source=github&utm_medium=core>`_
-* `PIO Remote <https://docs.platformio.org/page/plus/pio-remote.html?utm_source=github&utm_medium=core>`_
-* `PIO Unified Debugger <https://docs.platformio.org/page/plus/debugging.html?utm_source=github&utm_medium=core>`_
-* `PIO Unit Testing <https://docs.platformio.org/page/plus/unit-testing.html?utm_source=github&utm_medium=core>`_
+* `Debugging <https://docs.platformio.org/page/plus/debugging.html?utm_source=github&utm_medium=core>`_
+* `Unit Testing <https://docs.platformio.org/page/plus/unit-testing.html?utm_source=github&utm_medium=core>`_
+* `Static Code Analysis <https://docs.platformio.org/page/plus/pio-check.html?utm_source=github&utm_medium=core>`_
+* `Remote Development <https://docs.platformio.org/page/plus/pio-remote.html?utm_source=github&utm_medium=core>`_
 
 Registry
 --------
@@ -81,6 +79,7 @@ Development Platforms
 ---------------------
 
 * `Aceinna IMU <https://platformio.org/platforms/aceinna_imu?utm_source=github&utm_medium=core>`_
+* `ASR Microelectronics ASR605x <https://platformio.org/platforms/asrmicro650x?utm_source=github&utm_medium=core>`_
 * `Atmel AVR <https://platformio.org/platforms/atmelavr?utm_source=github&utm_medium=core>`_
 * `Atmel SAM <https://platformio.org/platforms/atmelsam?utm_source=github&utm_medium=core>`_
 * `Espressif 32 <https://platformio.org/platforms/espressif32?utm_source=github&utm_medium=core>`_
@@ -144,7 +143,6 @@ Share minimal diagnostics and usage information to help us make PlatformIO bette
 It is enabled by default. For more information see:
 
 * `Telemetry Setting <https://docs.platformio.org/page/userguide/cmd_settings.html?utm_source=github&utm_medium=core#enable-telemetry>`_
-* `SSL Setting <https://docs.platformio.org/page/userguide/cmd_settings.html?utm_source=github&utm_medium=core#strict-ssl>`_
 
 License
 -------

platformio/__init__.py

@@ -12,27 +12,53 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-VERSION = (4, 3, 3)
+import sys
+
+VERSION = (5, 2, 1)
 __version__ = ".".join([str(s) for s in VERSION])
 
 __title__ = "platformio"
 __description__ = (
-    "A new generation ecosystem for embedded development. "
+    "A professional collaborative platform for embedded development. "
     "Cross-platform IDE and Unified Debugger. "
     "Static Code Analyzer and Remote Unit Testing. "
     "Multi-platform and Multi-architecture Build System. "
     "Firmware File Explorer and Memory Inspection. "
-    "Arduino, ARM mbed, Espressif (ESP8266/ESP32), STM32, PIC32, nRF51/nRF52, "
-    "RISC-V, FPGA, CMSIS, SPL, AVR, Samsung ARTIK, libOpenCM3"
+    "IoT, Arduino, CMSIS, ESP-IDF, FreeRTOS, libOpenCM3, mbedOS, Pulp OS, SPL, "
+    "STM32Cube, Zephyr RTOS, ARM, AVR, Espressif (ESP8266/ESP32), FPGA, "
+    "MCS-51 (8051), MSP430, Nordic (nRF51/nRF52), NXP i.MX RT, PIC32, RISC-V, "
+    "STMicroelectronics (STM8/STM32), Teensy"
 )
 __url__ = "https://platformio.org"
 
-__author__ = "PlatformIO"
-__email__ = "contact@platformio.org"
+__author__ = "PlatformIO Labs"
+__email__ = "contact@piolabs.com"
 
 __license__ = "Apache Software License"
-__copyright__ = "Copyright 2014-present PlatformIO"
+__copyright__ = "Copyright 2014-present PlatformIO Labs"
 
-__apiurl__ = "https://api.platformio.org"
-__pioaccount_api__ = "https://api.accounts.platformio.org"
+__accounts_api__ = "https://api.accounts.platformio.org"
+__registry_api__ = [
+    "https://api.registry.platformio.org",
+    "https://api.registry.ns1.platformio.org",
+]
 __pioremote_endpoint__ = "ssl:host=remote.platformio.org:port=4413"
+
+__default_requests_timeout__ = (10, None)  # (connect, read)
+
+__core_packages__ = {
+    "contrib-piohome": "~3.3.4",
+    "contrib-pysite": "~2.%d%d.0" % (sys.version_info.major, sys.version_info.minor),
+    "tool-unity": "~1.20500.0",
+    "tool-scons": "~4.40200.0",
+    "tool-cppcheck": "~1.260.0",
+    "tool-clangtidy": "~1.120001.0",
+    "tool-pvs-studio": "~7.14.0",
+}
+
+__check_internet_hosts__ = [
+    "185.199.110.153",  # Github.com
+    "88.198.170.159",  # platformio.org
+    "github.com",
+    "platformio.org",
+]

platformio/__main__.py

@@ -12,21 +12,30 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# pylint: disable=import-outside-toplevel
+
 import os
 import sys
 from traceback import format_exc
 
 import click
 
-from platformio import __version__, exception, maintenance, util
+from platformio import __version__, exception
 from platformio.commands import PlatformioCLI
-from platformio.compat import CYGWIN
+from platformio.compat import IS_CYGWIN, ensure_python3
+
+try:
+    import click_completion  # pylint: disable=import-error
+
+    click_completion.init()
+except:  # pylint: disable=bare-except
+    pass
 
 
 @click.command(
     cls=PlatformioCLI, context_settings=dict(help_option_names=["-h", "--help"])
 )
-@click.version_option(__version__, prog_name="PlatformIO")
+@click.version_option(__version__, prog_name="PlatformIO Core")
 @click.option("--force", "-f", is_flag=True, help="DEPRECATE")
 @click.option("--caller", "-c", help="Caller ID (service)")
 @click.option("--no-ansi", is_flag=True, help="Do not print ANSI control characters")
@@ -53,18 +62,36 @@ def cli(ctx, force, caller, no_ansi):
     except:  # pylint: disable=bare-except
         pass
 
+    from platformio import maintenance
+
     maintenance.on_platformio_start(ctx, force, caller)
 
 
-@cli.resultcallback()
-@click.pass_context
-def process_result(ctx, result, *_, **__):
+try:
+
+    @cli.result_callback()
+    @click.pass_context
+    def process_result(ctx, result, *_, **__):
+        _process_result(ctx, result)
+
+
+except (AttributeError, TypeError):  # legacy support for CLick > 8.0.1
+    print("legacy Click")
+
+    @cli.resultcallback()
+    @click.pass_context
+    def process_result(ctx, result, *_, **__):
+        _process_result(ctx, result)
+
+
+def _process_result(ctx, result):
+    from platformio import maintenance
+
     maintenance.on_platformio_end(ctx, result)
 
 
-@util.memoized()
 def configure():
-    if CYGWIN:
+    if IS_CYGWIN:
         raise exception.CygwinEnvDetected()
 
     # https://urllib3.readthedocs.org
@@ -98,6 +125,7 @@ def main(argv=None):
         assert isinstance(argv, list)
         sys.argv = argv
     try:
+        ensure_python3(raise_exception=True)
         configure()
         cli()  # pylint: disable=no-value-for-parameter
     except SystemExit as e:
@@ -105,7 +133,10 @@ def main(argv=None):
             exit_code = int(e.code)
     except Exception as e:  # pylint: disable=broad-except
         if not isinstance(e, exception.ReturnErrorCode):
-            maintenance.on_platformio_exception(e)
+            if sys.version_info.major != 2:
+                from platformio import maintenance
+
+                maintenance.on_platformio_exception(e)
             error_str = "Error: "
             if isinstance(e, exception.PlatformioException):
                 error_str += str(e)

platformio/app.py

@@ -12,27 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import codecs
+from __future__ import absolute_import
+
 import getpass
 import hashlib
+import json
 import os
 import platform
 import socket
 import uuid
-from os import environ, getenv, listdir, remove
 from os.path import dirname, isdir, isfile, join, realpath
-from time import time
 
-import requests
-
-from platformio import __version__, exception, fs, lockfile
-from platformio.compat import WINDOWS, dump_json_to_unicode, hashlib_encode_data
-from platformio.proc import is_ci
-from platformio.project.helpers import (
-    get_default_projects_dir,
-    get_project_cache_dir,
-    get_project_core_dir,
-)
+from platformio import __version__, exception, fs, proc
+from platformio.compat import IS_WINDOWS, hashlib_encode_data
+from platformio.package.lockfile import LockFile
+from platformio.project.helpers import get_default_projects_dir, get_project_core_dir
 
 
 def projects_dir_validate(projects_dir):
@@ -61,11 +55,14 @@ DEFAULT_SETTINGS = {
         "description": "Check for the platform updates interval (days)",
         "value": 7,
     },
+    "check_prune_system_threshold": {
+        "description": "Check for pruning unnecessary data threshold (megabytes)",
+        "value": 1024,
+    },
     "enable_cache": {
-        "description": "Enable caching for API requests and Library Manager",
+        "description": "Enable caching for HTTP API requests",
         "value": True,
     },
-    "strict_ssl": {"description": "Strict SSL for PlatformIO Services", "value": False},
     "enable_telemetry": {
         "description": ("Telemetry service <http://bit.ly/pio-telemetry> (Yes/No)"),
         "value": True,
@@ -75,7 +72,7 @@ DEFAULT_SETTINGS = {
         "value": False,
     },
     "projects_dir": {
-        "description": "Default location for PlatformIO projects (PIO Home)",
+        "description": "Default location for PlatformIO projects (PlatformIO Home)",
         "value": get_default_projects_dir(),
         "validator": projects_dir_validate,
     },
@@ -117,8 +114,8 @@ class State(object):
     def __exit__(self, type_, value, traceback):
         if self.modified:
             try:
-                with open(self.path, "w") as fp:
-                    fp.write(dump_json_to_unicode(self._storage))
+                with open(self.path, mode="w", encoding="utf8") as fp:
+                    fp.write(json.dumps(self._storage))
             except IOError:
                 raise exception.HomeDirPermissionsError(get_project_core_dir())
         self._unlock_state_file()
@@ -126,7 +123,7 @@ class State(object):
     def _lock_state_file(self):
         if not self.lock:
             return
-        self._lockfile = lockfile.LockFile(self.path)
+        self._lockfile = LockFile(self.path)
         try:
             self._lockfile.acquire()
         except IOError:
@@ -144,6 +141,9 @@ class State(object):
     def as_dict(self):
         return self._storage
 
+    def keys(self):
+        return self._storage.keys()
+
     def get(self, key, default=True):
         return self._storage.get(key, default)
 
@@ -169,146 +169,6 @@ class State(object):
         return item in self._storage
 
 
-class ContentCache(object):
-    def __init__(self, cache_dir=None):
-        self.cache_dir = None
-        self._db_path = None
-        self._lockfile = None
-
-        self.cache_dir = cache_dir or get_project_cache_dir()
-        self._db_path = join(self.cache_dir, "db.data")
-
-    def __enter__(self):
-        self.delete()
-        return self
-
-    def __exit__(self, type_, value, traceback):
-        pass
-
-    def _lock_dbindex(self):
-        if not self.cache_dir:
-            os.makedirs(self.cache_dir)
-        self._lockfile = lockfile.LockFile(self.cache_dir)
-        try:
-            self._lockfile.acquire()
-        except:  # pylint: disable=bare-except
-            return False
-
-        return True
-
-    def _unlock_dbindex(self):
-        if self._lockfile:
-            self._lockfile.release()
-        return True
-
-    def get_cache_path(self, key):
-        assert "/" not in key and "\\" not in key
-        key = str(key)
-        assert len(key) > 3
-        return join(self.cache_dir, key[-2:], key)
-
-    @staticmethod
-    def key_from_args(*args):
-        h = hashlib.md5()
-        for arg in args:
-            if arg:
-                h.update(hashlib_encode_data(arg))
-        return h.hexdigest()
-
-    def get(self, key):
-        cache_path = self.get_cache_path(key)
-        if not isfile(cache_path):
-            return None
-        with codecs.open(cache_path, "rb", encoding="utf8") as fp:
-            return fp.read()
-
-    def set(self, key, data, valid):
-        if not get_setting("enable_cache"):
-            return False
-        cache_path = self.get_cache_path(key)
-        if isfile(cache_path):
-            self.delete(key)
-        if not data:
-            return False
-        if not isdir(self.cache_dir):
-            os.makedirs(self.cache_dir)
-        tdmap = {"s": 1, "m": 60, "h": 3600, "d": 86400}
-        assert valid.endswith(tuple(tdmap))
-        expire_time = int(time() + tdmap[valid[-1]] * int(valid[:-1]))
-
-        if not self._lock_dbindex():
-            return False
-
-        if not isdir(dirname(cache_path)):
-            os.makedirs(dirname(cache_path))
-        try:
-            with codecs.open(cache_path, "wb", encoding="utf8") as fp:
-                fp.write(data)
-            with open(self._db_path, "a") as fp:
-                fp.write("%s=%s\n" % (str(expire_time), cache_path))
-        except UnicodeError:
-            if isfile(cache_path):
-                try:
-                    remove(cache_path)
-                except OSError:
-                    pass
-
-        return self._unlock_dbindex()
-
-    def delete(self, keys=None):
-        """ Keys=None, delete expired items """
-        if not isfile(self._db_path):
-            return None
-        if not keys:
-            keys = []
-        if not isinstance(keys, list):
-            keys = [keys]
-        paths_for_delete = [self.get_cache_path(k) for k in keys]
-        found = False
-        newlines = []
-        with open(self._db_path) as fp:
-            for line in fp.readlines():
-                line = line.strip()
-                if "=" not in line:
-                    continue
-                expire, path = line.split("=")
-                try:
-                    if (
-                        time() < int(expire)
-                        and isfile(path)
-                        and path not in paths_for_delete
-                    ):
-                        newlines.append(line)
-                        continue
-                except ValueError:
-                    pass
-                found = True
-                if isfile(path):
-                    try:
-                        remove(path)
-                        if not listdir(dirname(path)):
-                            fs.rmtree(dirname(path))
-                    except OSError:
-                        pass
-
-        if found and self._lock_dbindex():
-            with open(self._db_path, "w") as fp:
-                fp.write("\n".join(newlines) + "\n")
-            self._unlock_dbindex()
-
-        return True
-
-    def clean(self):
-        if not self.cache_dir or not isdir(self.cache_dir):
-            return
-        fs.rmtree(self.cache_dir)
-
-
-def clean_cache():
-    with ContentCache() as cc:
-        cc.clean()
-
-
 def sanitize_setting(name, value):
     if name not in DEFAULT_SETTINGS:
         raise exception.InvalidSettingName(name)
@@ -346,8 +206,8 @@ def delete_state_item(name):
 
 def get_setting(name):
     _env_name = "PLATFORMIO_SETTING_%s" % name.upper()
-    if _env_name in environ:
-        return sanitize_setting(name, getenv(_env_name))
+    if _env_name in os.environ:
+        return sanitize_setting(name, os.getenv(_env_name))
 
     with State() as state:
         if "settings" in state and name in state["settings"]:
@@ -383,44 +243,51 @@ def is_disabled_progressbar():
     return any(
         [
             get_session_var("force_option"),
-            is_ci(),
-            getenv("PLATFORMIO_DISABLE_PROGRESSBAR") == "true",
+            proc.is_ci(),
+            os.getenv("PLATFORMIO_DISABLE_PROGRESSBAR") == "true",
         ]
     )
 
 
 def get_cid():
+    # pylint: disable=import-outside-toplevel
+    from platformio.clients.http import fetch_remote_content
+
     cid = get_state_item("cid")
     if cid:
         return cid
     uid = None
-    if getenv("C9_UID"):
-        uid = getenv("C9_UID")
-    elif getenv("CHE_API", getenv("CHE_API_ENDPOINT")):
+    if os.getenv("C9_UID"):
+        uid = os.getenv("C9_UID")
+    elif os.getenv("GITPOD_GIT_USER_NAME"):
+        uid = os.getenv("GITPOD_GIT_USER_NAME")
+    elif os.getenv("CHE_API", os.getenv("CHE_API_ENDPOINT")):
         try:
-            uid = (
-                requests.get(
+            uid = json.loads(
+                fetch_remote_content(
                     "{api}/user?token={token}".format(
-                        api=getenv("CHE_API", getenv("CHE_API_ENDPOINT")),
-                        token=getenv("USER_TOKEN"),
+                        api=os.getenv("CHE_API", os.getenv("CHE_API_ENDPOINT")),
+                        token=os.getenv("USER_TOKEN"),
                     )
                 )
-                .json()
-                .get("id")
-            )
+            ).get("id")
         except:  # pylint: disable=bare-except
             pass
     if not uid:
         uid = uuid.getnode()
     cid = uuid.UUID(bytes=hashlib.md5(hashlib_encode_data(uid)).digest())
     cid = str(cid)
-    if WINDOWS or os.getuid() > 0:  # pylint: disable=no-member
+    if IS_WINDOWS or os.getuid() > 0:  # pylint: disable=no-member
         set_state_item("cid", cid)
     return cid
 
 
 def get_user_agent():
-    data = ["PlatformIO/%s" % __version__, "CI/%d" % int(is_ci())]
+    data = [
+        "PlatformIO/%s" % __version__,
+        "CI/%d" % int(proc.is_ci()),
+        "Container/%d" % int(proc.is_container()),
+    ]
     if get_session_var("caller_id"):
         data.append("Caller/%s" % get_session_var("caller_id"))
     if os.getenv("PLATFORMIO_IDE"):

platformio/builder/main.py

@@ -12,9 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import json
+import os
 import sys
-from os import environ, makedirs
-from os.path import isdir, join
 from time import time
 
 import click
@@ -28,9 +28,8 @@ from SCons.Script import DefaultEnvironment  # pylint: disable=import-error
 from SCons.Script import Import  # pylint: disable=import-error
 from SCons.Script import Variables  # pylint: disable=import-error
 
-from platformio import fs
-from platformio.compat import dump_json_to_unicode
-from platformio.managers.platform import PlatformBase
+from platformio import compat, fs
+from platformio.platform.base import PlatformBase
 from platformio.proc import get_pythonexe_path
 from platformio.project.helpers import get_project_dir
 
@@ -55,6 +54,7 @@ DEFAULT_ENV_OPTIONS = dict(
         "c++",
         "link",
         "platformio",
+        "piotarget",
         "pioplatform",
         "pioproject",
         "piomaxlen",
@@ -64,27 +64,35 @@ DEFAULT_ENV_OPTIONS = dict(
         "pioide",
         "piosize",
     ],
-    toolpath=[join(fs.get_source_dir(), "builder", "tools")],
+    toolpath=[os.path.join(fs.get_source_dir(), "builder", "tools")],
     variables=clivars,
     # Propagating External Environment
-    ENV=environ,
+    ENV=os.environ,
     UNIX_TIME=int(time()),
-    BUILD_DIR=join("$PROJECT_BUILD_DIR", "$PIOENV"),
-    BUILD_SRC_DIR=join("$BUILD_DIR", "src"),
-    BUILD_TEST_DIR=join("$BUILD_DIR", "test"),
-    COMPILATIONDB_PATH=join("$BUILD_DIR", "compile_commands.json"),
+    BUILD_DIR=os.path.join("$PROJECT_BUILD_DIR", "$PIOENV"),
+    BUILD_SRC_DIR=os.path.join("$BUILD_DIR", "src"),
+    BUILD_TEST_DIR=os.path.join("$BUILD_DIR", "test"),
+    COMPILATIONDB_PATH=os.path.join("$BUILD_DIR", "compile_commands.json"),
     LIBPATH=["$BUILD_DIR"],
     PROGNAME="program",
-    PROG_PATH=join("$BUILD_DIR", "$PROGNAME$PROGSUFFIX"),
+    PROG_PATH=os.path.join("$BUILD_DIR", "$PROGNAME$PROGSUFFIX"),
     PYTHONEXE=get_pythonexe_path(),
+    IDE_EXTRA_DATA={},
 )
 
+# Declare command verbose messages
+command_strings = dict(
+    ARCOM="Archiving",
+    LINKCOM="Linking",
+    RANLIBCOM="Indexing",
+    ASCOM="Compiling",
+    ASPPCOM="Compiling",
+    CCCOM="Compiling",
+    CXXCOM="Compiling",
+)
 if not int(ARGUMENTS.get("PIOVERBOSE", 0)):
-    DEFAULT_ENV_OPTIONS["ARCOMSTR"] = "Archiving $TARGET"
-    DEFAULT_ENV_OPTIONS["LINKCOMSTR"] = "Linking $TARGET"
-    DEFAULT_ENV_OPTIONS["RANLIBCOMSTR"] = "Indexing $TARGET"
-    for k in ("ASCOMSTR", "ASPPCOMSTR", "CCCOMSTR", "CXXCOMSTR"):
-        DEFAULT_ENV_OPTIONS[k] = "Compiling $TARGET"
+    for name, value in command_strings.items():
+        DEFAULT_ENV_OPTIONS["%sSTR" % name] = "%s $TARGET" % (value)
 
 env = DefaultEnvironment(**DEFAULT_ENV_OPTIONS)
 
@@ -115,39 +123,55 @@ env.Replace(
     BUILD_CACHE_DIR=config.get_optional_dir("build_cache"),
     LIBSOURCE_DIRS=[
         config.get_optional_dir("lib"),
-        join("$PROJECT_LIBDEPS_DIR", "$PIOENV"),
+        os.path.join("$PROJECT_LIBDEPS_DIR", "$PIOENV"),
         config.get_optional_dir("globallib"),
     ],
 )
 
+if (
+    compat.IS_WINDOWS
+    and sys.version_info >= (3, 8)
+    and env["PROJECT_DIR"].startswith("\\\\")
+):
+    click.secho(
+        "There is a known issue with Python 3.8+ and mapped network drives on "
+        "Windows.\nSee a solution at:\n"
+        "https://github.com/platformio/platformio-core/issues/3417",
+        fg="yellow",
+    )
+
 if env.subst("$BUILD_CACHE_DIR"):
-    if not isdir(env.subst("$BUILD_CACHE_DIR")):
-        makedirs(env.subst("$BUILD_CACHE_DIR"))
+    if not os.path.isdir(env.subst("$BUILD_CACHE_DIR")):
+        os.makedirs(env.subst("$BUILD_CACHE_DIR"))
     env.CacheDir("$BUILD_CACHE_DIR")
 
 if int(ARGUMENTS.get("ISATTY", 0)):
     # pylint: disable=protected-access
     click._compat.isatty = lambda stream: True
 
-if env.GetOption("clean"):
-    env.PioClean(env.subst("$BUILD_DIR"))
+is_clean_all = "cleanall" in COMMAND_LINE_TARGETS
+if env.GetOption("clean") or is_clean_all:
+    env.PioClean(is_clean_all)
     env.Exit(0)
-elif not int(ARGUMENTS.get("PIOVERBOSE", 0)):
+
+if not int(ARGUMENTS.get("PIOVERBOSE", 0)):
     click.echo("Verbose mode can be enabled via `-v, --verbose` option")
 
 # Dynamically load dependent tools
 if "compiledb" in COMMAND_LINE_TARGETS:
     env.Tool("compilation_db")
 
-if not isdir(env.subst("$BUILD_DIR")):
-    makedirs(env.subst("$BUILD_DIR"))
+if not os.path.isdir(env.subst("$BUILD_DIR")):
+    os.makedirs(env.subst("$BUILD_DIR"))
 
 env.LoadProjectOptions()
 env.LoadPioPlatform()
 
 env.SConscriptChdir(0)
 env.SConsignFile(
-    join("$BUILD_DIR", ".sconsign%d%d.db" % (sys.version_info[0], sys.version_info[1]))
+    os.path.join(
+        "$BUILD_DIR", ".sconsign%d%d" % (sys.version_info[0], sys.version_info[1])
+    )
 )
 
 for item in env.GetExtraScripts("pre"):
@@ -188,7 +212,7 @@ env.AddPreAction(
     ),
 )
 
-AlwaysBuild(env.Alias("debug", DEFAULT_TARGETS))
+AlwaysBuild(env.Alias("__debug", DEFAULT_TARGETS))
 AlwaysBuild(env.Alias("__test", DEFAULT_TARGETS))
 
 ##############################################################################
@@ -197,17 +221,20 @@ if "envdump" in COMMAND_LINE_TARGETS:
     click.echo(env.Dump())
     env.Exit(0)
 
-if "idedata" in COMMAND_LINE_TARGETS:
+if set(["_idedata", "idedata"]) & set(COMMAND_LINE_TARGETS):
     try:
         Import("projenv")
     except:  # pylint: disable=bare-except
         projenv = env
-    click.echo(
-        "\n%s\n"
-        % dump_json_to_unicode(
-            projenv.DumpIDEData()  # pylint: disable=undefined-variable
-        )
-    )
+    data = projenv.DumpIDEData(env)
+    # dump to file for the further reading by project.helpers.load_project_ide_data
+    with open(
+        projenv.subst(os.path.join("$BUILD_DIR", "idedata.json")),
+        mode="w",
+        encoding="utf8",
+    ) as fp:
+        json.dump(data, fp)
+    click.echo("\n%s\n" % json.dumps(data))  # pylint: disable=undefined-variable
     env.Exit(0)
 
 if "sizedata" in COMMAND_LINE_TARGETS:

platformio/builder/tools/compilation_db.py

@@ -1,17 +1,24 @@
 # Copyright (c) 2014-present PlatformIO <contact@platformio.org>
-# Copyright 2015 MongoDB Inc.
+# Copyright 2020 MongoDB Inc.
 #
-# 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
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
 #
-# 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.
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 # pylint: disable=unused-argument, protected-access, unused-variable, import-error
 # Original: https://github.com/mongodb/mongo/blob/master/site_scons/site_tools/compilation_db.py
@@ -34,7 +41,7 @@ from platformio.proc import where_is_program
 # should hold the compilation database, otherwise, the file defaults to compile_commands.json,
 # which is the name that most clang tools search for by default.
 
-# TODO: Is there a better way to do this than this global? Right now this exists so that the
+# Is there a better way to do this than this global? Right now this exists so that the
 # emitter we add can record all of the things it emits, so that the scanner for the top level
 # compilation database can access the complete list, and also so that the writer has easy
 # access to write all of the files. But it seems clunky. How can the emitter and the scanner
@@ -51,7 +58,7 @@ class __CompilationDbNode(SCons.Node.Python.Value):
 
 
 def changed_since_last_build_node(*args, **kwargs):
-    """ Dummy decider to force always building"""
+    """Dummy decider to force always building"""
     return True
 
 
@@ -97,7 +104,7 @@ def makeEmitCompilationDbEntry(comstr):
             __COMPILATIONDB_ENV=env,
         )
 
-        # TODO: Technically, these next two lines should not be required: it should be fine to
+        # Technically, these next two lines should not be required: it should be fine to
         # cache the entries. However, they don't seem to update properly. Since they are quick
         # to re-generate disable caching and sidestep this problem.
         env.AlwaysBuild(entry)
@@ -145,7 +152,7 @@ def WriteCompilationDb(target, source, env):
         item["file"] = os.path.abspath(item["file"])
         entries.append(item)
 
-    with open(str(target[0]), "w") as target_file:
+    with open(str(target[0]), mode="w", encoding="utf8") as target_file:
         json.dump(
             entries, target_file, sort_keys=True, indent=4, separators=(",", ": ")
         )

platformio/builder/tools/pioide.py

@@ -14,13 +14,13 @@
 
 from __future__ import absolute_import
 
+import glob
 import os
-from glob import glob
 
-from SCons.Defaults import processDefines  # pylint: disable=import-error
+import SCons.Defaults  # pylint: disable=import-error
+import SCons.Subst  # pylint: disable=import-error
 
-from platformio.compat import glob_escape
-from platformio.managers.core import get_core_package_dir
+from platformio.package.manager.core import get_core_package_dir
 from platformio.proc import exec_command, where_is_program
 
 
@@ -45,10 +45,10 @@ def _dump_includes(env):
     # includes from toolchains
     p = env.PioPlatform()
     includes["toolchain"] = []
-    for name in p.get_installed_packages():
-        if p.get_package_type(name) != "toolchain":
+    for pkg in p.get_installed_packages():
+        if p.get_package_type(pkg.metadata.name) != "toolchain":
             continue
-        toolchain_dir = glob_escape(p.get_package_dir(name))
+        toolchain_dir = glob.escape(pkg.path)
         toolchain_incglobs = [
             os.path.join(toolchain_dir, "*", "include", "c++", "*"),
             os.path.join(toolchain_dir, "*", "include", "c++", "*", "*-*-*"),
@@ -56,10 +56,20 @@ def _dump_includes(env):
             os.path.join(toolchain_dir, "*", "include*"),
         ]
         for g in toolchain_incglobs:
-            includes["toolchain"].extend([os.path.realpath(inc) for inc in glob(g)])
+            includes["toolchain"].extend(
+                [os.path.realpath(inc) for inc in glob.glob(g)]
+            )
 
+    # include Unity framework if there are tests in project
     includes["unity"] = []
-    unity_dir = get_core_package_dir("tool-unity")
+    auto_install_unity = False
+    test_dir = env.GetProjectConfig().get_optional_dir("test")
+    if os.path.isdir(test_dir) and os.listdir(test_dir) != ["README"]:
+        auto_install_unity = True
+    unity_dir = get_core_package_dir(
+        "tool-unity",
+        auto_install=auto_install_unity,
+    )
     if unity_dir:
         includes["unity"].append(unity_dir)
 
@@ -92,8 +102,10 @@ def _get_gcc_defines(env):
 def _dump_defines(env):
     defines = []
     # global symbols
-    for item in processDefines(env.get("CPPDEFINES", [])):
-        defines.append(env.subst(item).replace("\\", ""))
+    for item in SCons.Defaults.processDefines(env.get("CPPDEFINES", [])):
+        item = item.strip()
+        if item:
+            defines.append(env.subst(item).replace("\\", ""))
 
     # special symbol for Atmel AVR MCU
     if env["PIOPLATFORM"] == "atmelavr":
@@ -139,42 +151,39 @@ def _get_svd_path(env):
     return None
 
 
-def _escape_build_flag(flags):
-    return [flag if " " not in flag else '"%s"' % flag for flag in flags]
+def _subst_cmd(env, cmd):
+    args = env.subst_list(cmd, SCons.Subst.SUBST_CMD)[0]
+    return " ".join([SCons.Subst.quote_spaces(arg) for arg in args])
 
 
-def DumpIDEData(env):
-
-    env["__escape_build_flag"] = _escape_build_flag
-
-    LINTCCOM = (
-        "${__escape_build_flag(CFLAGS)} ${__escape_build_flag(CCFLAGS)} $CPPFLAGS"
-    )
-    LINTCXXCOM = (
-        "${__escape_build_flag(CXXFLAGS)} ${__escape_build_flag(CCFLAGS)} $CPPFLAGS"
-    )
+def DumpIDEData(env, globalenv):
+    """env here is `projenv`"""
 
     data = {
         "env_name": env["PIOENV"],
-        "libsource_dirs": [env.subst(l) for l in env.GetLibSourceDirs()],
+        "libsource_dirs": [env.subst(item) for item in env.GetLibSourceDirs()],
         "defines": _dump_defines(env),
         "includes": _dump_includes(env),
         "cc_path": where_is_program(env.subst("$CC"), env.subst("${ENV['PATH']}")),
         "cxx_path": where_is_program(env.subst("$CXX"), env.subst("${ENV['PATH']}")),
         "gdb_path": where_is_program(env.subst("$GDB"), env.subst("${ENV['PATH']}")),
         "prog_path": env.subst("$PROG_PATH"),
-        "flash_extra_images": [
-            {"offset": item[0], "path": env.subst(item[1])}
-            for item in env.get("FLASH_EXTRA_IMAGES", [])
-        ],
         "svd_path": _get_svd_path(env),
         "compiler_type": env.GetCompilerType(),
+        "targets": globalenv.DumpTargets(),
+        "extra": dict(
+            flash_images=[
+                {"offset": item[0], "path": env.subst(item[1])}
+                for item in env.get("FLASH_EXTRA_IMAGES", [])
+            ]
+        ),
     }
+    data["extra"].update(env.get("IDE_EXTRA_DATA", {}))
 
     env_ = env.Clone()
     # https://github.com/platformio/platformio-atom-ide/issues/34
     _new_defines = []
-    for item in processDefines(env_.get("CPPDEFINES", [])):
+    for item in SCons.Defaults.processDefines(env_.get("CPPDEFINES", [])):
         item = item.replace('\\"', '"')
         if " " in item:
             _new_defines.append(item.replace(" ", "\\\\ "))
@@ -182,7 +191,13 @@ def DumpIDEData(env):
             _new_defines.append(item)
     env_.Replace(CPPDEFINES=_new_defines)
 
-    data.update({"cc_flags": env_.subst(LINTCCOM), "cxx_flags": env_.subst(LINTCXXCOM)})
+    # export C/C++ build flags
+    data.update(
+        {
+            "cc_flags": _subst_cmd(env_, "$CFLAGS $CCFLAGS $CPPFLAGS"),
+            "cxx_flags": _subst_cmd(env_, "$CXXFLAGS $CCFLAGS $CPPFLAGS"),
+        }
+    )
 
     return data
 

platformio/builder/tools/piolib.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pylint: disable=no-member, no-self-use, unused-argument, too-many-lines
+# pylint: disable=no-self-use, unused-argument, too-many-lines
 # pylint: disable=too-many-instance-attributes, too-many-public-methods
 # pylint: disable=assignment-from-no-return
 
@@ -23,7 +23,6 @@ import io
 import os
 import re
 import sys
-from os.path import basename, commonprefix, isdir, isfile, join, realpath, sep
 
 import click
 import SCons.Scanner  # pylint: disable=import-error
@@ -33,12 +32,15 @@ from SCons.Script import DefaultEnvironment  # pylint: disable=import-error
 
 from platformio import exception, fs, util
 from platformio.builder.tools import platformio as piotool
-from platformio.compat import WINDOWS, hashlib_encode_data, string_types
-from platformio.managers.lib import LibraryManager
+from platformio.clients.http import InternetIsOffline
+from platformio.compat import IS_WINDOWS, hashlib_encode_data, string_types
+from platformio.package.exception import UnknownPackageError
+from platformio.package.manager.library import LibraryPackageManager
 from platformio.package.manifest.parser import (
     ManifestParserError,
     ManifestParserFactory,
 )
+from platformio.package.meta import PackageItem
 from platformio.project.options import ProjectOptions
 
 
@@ -46,7 +48,7 @@ class LibBuilderFactory(object):
     @staticmethod
     def new(env, path, verbose=int(ARGUMENTS.get("PIOVERBOSE", 0))):
         clsname = "UnknownLibBuilder"
-        if isfile(join(path, "library.json")):
+        if os.path.isfile(os.path.join(path, "library.json")):
             clsname = "PlatformIOLibBuilder"
         else:
             used_frameworks = LibBuilderFactory.get_used_frameworks(env, path)
@@ -57,18 +59,28 @@ class LibBuilderFactory(object):
                 clsname = "%sLibBuilder" % used_frameworks[0].title()
 
         obj = getattr(sys.modules[__name__], clsname)(env, path, verbose=verbose)
+
+        # Handle PlatformIOLibBuilder.manifest.build.builder
+        # pylint: disable=protected-access
+        if isinstance(obj, PlatformIOLibBuilder) and obj._manifest.get("build", {}).get(
+            "builder"
+        ):
+            obj = getattr(
+                sys.modules[__name__], obj._manifest.get("build", {}).get("builder")
+            )(env, path, verbose=verbose)
+
         assert isinstance(obj, LibBuilderBase)
         return obj
 
     @staticmethod
     def get_used_frameworks(env, path):
         if any(
-            isfile(join(path, fname))
+            os.path.isfile(os.path.join(path, fname))
             for fname in ("library.properties", "keywords.txt")
         ):
             return ["arduino"]
 
-        if isfile(join(path, "module.json")):
+        if os.path.isfile(os.path.join(path, "module.json")):
             return ["mbed"]
 
         include_re = re.compile(
@@ -84,7 +96,9 @@ class LibBuilderFactory(object):
                     fname, piotool.SRC_BUILD_EXT + piotool.SRC_HEADER_EXT
                 ):
                     continue
-                with io.open(join(root, fname), errors="ignore") as fp:
+                with io.open(
+                    os.path.join(root, fname), encoding="utf8", errors="ignore"
+                ) as fp:
                     content = fp.read()
                 if not content:
                     continue
@@ -111,7 +125,7 @@ class LibBuilderBase(object):
     def __init__(self, env, path, manifest=None, verbose=False):
         self.env = env.Clone()
         self.envorigin = env.Clone()
-        self.path = realpath(env.subst(path))
+        self.path = os.path.realpath(env.subst(path))
         self.verbose = verbose
 
         try:
@@ -124,9 +138,9 @@ class LibBuilderBase(object):
 
         self._is_dependent = False
         self._is_built = False
-        self._depbuilders = list()
-        self._circular_deps = list()
-        self._processed_files = list()
+        self._depbuilders = []
+        self._circular_deps = []
+        self._processed_files = []
 
         # reset source filter, could be overridden with extra script
         self.env["SRC_FILTER"] = ""
@@ -140,16 +154,16 @@ class LibBuilderBase(object):
     def __contains__(self, path):
         p1 = self.path
         p2 = path
-        if WINDOWS:
+        if IS_WINDOWS:
             p1 = p1.lower()
             p2 = p2.lower()
         if p1 == p2:
             return True
-        return commonprefix((p1 + sep, p2)) == p1 + sep
+        return os.path.commonprefix((p1 + os.path.sep, p2)) == p1 + os.path.sep
 
     @property
     def name(self):
-        return self._manifest.get("name", basename(self.path))
+        return self._manifest.get("name", os.path.basename(self.path))
 
     @property
     def version(self):
@@ -170,13 +184,19 @@ class LibBuilderBase(object):
 
     @property
     def include_dir(self):
-        if not all(isdir(join(self.path, d)) for d in ("include", "src")):
-            return None
-        return join(self.path, "include")
+        for name in ("include", "Include"):
+            d = os.path.join(self.path, name)
+            if os.path.isdir(d):
+                return d
+        return None
 
     @property
     def src_dir(self):
-        return join(self.path, "src") if isdir(join(self.path, "src")) else self.path
+        for name in ("src", "Src"):
+            d = os.path.join(self.path, name)
+            if os.path.isdir(d):
+                return d
+        return self.path
 
     def get_include_dirs(self):
         items = []
@@ -189,7 +209,9 @@ class LibBuilderBase(object):
     @property
     def build_dir(self):
         lib_hash = hashlib.sha1(hashlib_encode_data(self.path)).hexdigest()[:3]
-        return join("$BUILD_DIR", "lib%s" % lib_hash, basename(self.path))
+        return os.path.join(
+            "$BUILD_DIR", "lib%s" % lib_hash, os.path.basename(self.path)
+        )
 
     @property
     def build_flags(self):
@@ -268,7 +290,7 @@ class LibBuilderBase(object):
             if self.extra_script:
                 self.env.SConscriptChdir(1)
                 self.env.SConscript(
-                    realpath(self.extra_script),
+                    os.path.realpath(self.extra_script),
                     exports={"env": self.env, "pio_lib_builder": self},
                 )
             self.env.ProcessUnFlags(self.build_unflags)
@@ -294,14 +316,14 @@ class LibBuilderBase(object):
 
     def get_search_files(self):
         items = [
-            join(self.src_dir, item)
+            os.path.join(self.src_dir, item)
             for item in self.env.MatchSourceFiles(self.src_dir, self.src_filter)
         ]
         include_dir = self.include_dir
         if include_dir:
             items.extend(
                 [
-                    join(include_dir, item)
+                    os.path.join(include_dir, item)
                     for item in self.env.MatchSourceFiles(include_dir)
                 ]
             )
@@ -370,7 +392,7 @@ class LibBuilderBase(object):
                     continue
                 _f_part = _h_path[: _h_path.rindex(".")]
                 for ext in piotool.SRC_C_EXT + piotool.SRC_CXX_EXT:
-                    if not isfile("%s.%s" % (_f_part, ext)):
+                    if not os.path.isfile("%s.%s" % (_f_part, ext)):
                         continue
                     _c_path = self.env.File("%s.%s" % (_f_part, ext))
                     if _c_path not in result:
@@ -449,12 +471,22 @@ class LibBuilderBase(object):
                 for key in ("CPPPATH", "LIBPATH", "LIBS", "LINKFLAGS"):
                     self.env.PrependUnique(**{key: lb.env.get(key)})
 
-        if self.lib_archive:
-            libs.append(
-                self.env.BuildLibrary(self.build_dir, self.src_dir, self.src_filter)
+        do_not_archive = not self.lib_archive
+        if not do_not_archive:
+            nodes = self.env.CollectBuildFiles(
+                self.build_dir, self.src_dir, self.src_filter
             )
-        else:
+            if nodes:
+                libs.append(
+                    self.env.BuildLibrary(
+                        self.build_dir, self.src_dir, self.src_filter, nodes
+                    )
+                )
+            else:
+                do_not_archive = True
+        if do_not_archive:
             self.env.BuildSources(self.build_dir, self.src_dir, self.src_filter)
+
         return libs
 
 
@@ -464,23 +496,32 @@ class UnknownLibBuilder(LibBuilderBase):
 
 class ArduinoLibBuilder(LibBuilderBase):
     def load_manifest(self):
-        manifest_path = join(self.path, "library.properties")
-        if not isfile(manifest_path):
+        manifest_path = os.path.join(self.path, "library.properties")
+        if not os.path.isfile(manifest_path):
             return {}
         return ManifestParserFactory.new_from_file(manifest_path).as_dict()
 
+    @property
+    def include_dir(self):
+        if not all(
+            os.path.isdir(os.path.join(self.path, d)) for d in ("include", "src")
+        ):
+            return None
+        return os.path.join(self.path, "include")
+
     def get_include_dirs(self):
         include_dirs = LibBuilderBase.get_include_dirs(self)
-        if isdir(join(self.path, "src")):
+        if os.path.isdir(os.path.join(self.path, "src")):
             return include_dirs
-        if isdir(join(self.path, "utility")):
-            include_dirs.append(join(self.path, "utility"))
+        if os.path.isdir(os.path.join(self.path, "utility")):
+            include_dirs.append(os.path.join(self.path, "utility"))
         return include_dirs
 
     @property
     def src_filter(self):
-        src_dir = join(self.path, "src")
-        if isdir(src_dir):
+        src_dir = os.path.join(self.path, "src")
+        if os.path.isdir(src_dir):
+            # pylint: disable=no-member
             src_filter = LibBuilderBase.src_filter.fget(self)
             for root, _, files in os.walk(src_dir, followlinks=True):
                 found = False
@@ -491,50 +532,80 @@ class ArduinoLibBuilder(LibBuilderBase):
                 if not found:
                     continue
                 rel_path = root.replace(src_dir, "")
-                if rel_path.startswith(sep):
-                    rel_path = rel_path[1:] + sep
+                if rel_path.startswith(os.path.sep):
+                    rel_path = rel_path[1:] + os.path.sep
                 src_filter.append("-<%s*.[aA][sS][mM]>" % rel_path)
             return src_filter
 
         src_filter = []
-        is_utility = isdir(join(self.path, "utility"))
+        is_utility = os.path.isdir(os.path.join(self.path, "utility"))
         for ext in piotool.SRC_BUILD_EXT + piotool.SRC_HEADER_EXT:
             # arduino ide ignores files with .asm or .ASM extensions
             if ext.lower() == "asm":
                 continue
             src_filter.append("+<*.%s>" % ext)
             if is_utility:
-                src_filter.append("+<utility%s*.%s>" % (sep, ext))
+                src_filter.append("+<utility%s*.%s>" % (os.path.sep, ext))
         return src_filter
 
+    @property
+    def dependencies(self):
+        # do not include automatically all libraries for build
+        # chain+ will decide later
+        return None
+
+    @property
+    def lib_ldf_mode(self):
+        # pylint: disable=no-member
+        if not self._manifest.get("dependencies"):
+            return LibBuilderBase.lib_ldf_mode.fget(self)
+        missing = object()
+        global_value = self.env.GetProjectConfig().getraw(
+            "env:" + self.env["PIOENV"], "lib_ldf_mode", missing
+        )
+        if global_value != missing:
+            return LibBuilderBase.lib_ldf_mode.fget(self)
+        # automatically enable C++ Preprocessing in runtime
+        # (Arduino IDE has this behavior)
+        return "chain+"
+
     def is_frameworks_compatible(self, frameworks):
         return util.items_in_list(frameworks, ["arduino", "energia"])
 
     def is_platforms_compatible(self, platforms):
-        items = self._manifest.get("platforms", [])
-        if not items:
-            return LibBuilderBase.is_platforms_compatible(self, platforms)
-        return util.items_in_list(platforms, items)
+        return util.items_in_list(platforms, self._manifest.get("platforms") or ["*"])
+
+    @property
+    def build_flags(self):
+        ldflags = [
+            LibBuilderBase.build_flags.fget(self),  # pylint: disable=no-member
+            self._manifest.get("ldflags"),
+        ]
+        if self._manifest.get("precompiled") in ("true", "full"):
+            # add to LDPATH {build.mcu} folder
+            board_config = self.env.BoardConfig()
+            for key in ("build.mcu", "build.cpu"):
+                libpath = os.path.join(self.src_dir, board_config.get(key, ""))
+                if not os.path.isdir(libpath):
+                    continue
+                self.env.PrependUnique(LIBPATH=libpath)
+                break
+        ldflags = [flag for flag in ldflags if flag]  # remove empty
+        return " ".join(ldflags) if ldflags else None
 
 
 class MbedLibBuilder(LibBuilderBase):
     def load_manifest(self):
-        manifest_path = join(self.path, "module.json")
-        if not isfile(manifest_path):
+        manifest_path = os.path.join(self.path, "module.json")
+        if not os.path.isfile(manifest_path):
             return {}
         return ManifestParserFactory.new_from_file(manifest_path).as_dict()
 
-    @property
-    def include_dir(self):
-        if isdir(join(self.path, "include")):
-            return join(self.path, "include")
-        return None
-
     @property
     def src_dir(self):
-        if isdir(join(self.path, "source")):
-            return join(self.path, "source")
-        return LibBuilderBase.src_dir.fget(self)
+        if os.path.isdir(os.path.join(self.path, "source")):
+            return os.path.join(self.path, "source")
+        return LibBuilderBase.src_dir.fget(self)  # pylint: disable=no-member
 
     def get_include_dirs(self):
         include_dirs = LibBuilderBase.get_include_dirs(self)
@@ -543,13 +614,13 @@ class MbedLibBuilder(LibBuilderBase):
 
         # library with module.json
         for p in self._manifest.get("extraIncludes", []):
-            include_dirs.append(join(self.path, p))
+            include_dirs.append(os.path.join(self.path, p))
 
         # old mbed library without manifest, add to CPPPATH all folders
         if not self._manifest:
             for root, _, __ in os.walk(self.path):
                 part = root.replace(self.path, "").lower()
-                if any(s in part for s in ("%s." % sep, "test", "example")):
+                if any(s in part for s in ("%s." % os.path.sep, "test", "example")):
                     continue
                 if root not in include_dirs:
                     include_dirs.append(root)
@@ -565,7 +636,7 @@ class MbedLibBuilder(LibBuilderBase):
 
     def _process_mbed_lib_confs(self):
         mbed_lib_paths = [
-            join(root, "mbed_lib.json")
+            os.path.join(root, "mbed_lib.json")
             for root, _, files in os.walk(self.path)
             if "mbed_lib.json" in files
         ]
@@ -574,8 +645,8 @@ class MbedLibBuilder(LibBuilderBase):
 
         mbed_config_path = None
         for p in self.env.get("CPPPATH"):
-            mbed_config_path = join(self.env.subst(p), "mbed_config.h")
-            if isfile(mbed_config_path):
+            mbed_config_path = os.path.join(self.env.subst(p), "mbed_config.h")
+            if os.path.isfile(mbed_config_path):
                 break
             mbed_config_path = None
         if not mbed_config_path:
@@ -642,7 +713,7 @@ class MbedLibBuilder(LibBuilderBase):
 
     def _mbed_conf_append_macros(self, mbed_config_path, macros):
         lines = []
-        with open(mbed_config_path) as fp:
+        with open(mbed_config_path, encoding="utf8") as fp:
             for line in fp.readlines():
                 line = line.strip()
                 if line == "#endif":
@@ -661,36 +732,37 @@ class MbedLibBuilder(LibBuilderBase):
                 if len(tokens) < 2 or tokens[1] not in macros:
                     lines.append(line)
         lines.append("")
-        with open(mbed_config_path, "w") as fp:
+        with open(mbed_config_path, mode="w", encoding="utf8") as fp:
             fp.write("\n".join(lines))
 
 
 class PlatformIOLibBuilder(LibBuilderBase):
     def load_manifest(self):
-        manifest_path = join(self.path, "library.json")
-        if not isfile(manifest_path):
+        manifest_path = os.path.join(self.path, "library.json")
+        if not os.path.isfile(manifest_path):
             return {}
         return ManifestParserFactory.new_from_file(manifest_path).as_dict()
 
     def _has_arduino_manifest(self):
-        return isfile(join(self.path, "library.properties"))
+        return os.path.isfile(os.path.join(self.path, "library.properties"))
 
     @property
     def include_dir(self):
         if "includeDir" in self._manifest.get("build", {}):
             with fs.cd(self.path):
-                return realpath(self._manifest.get("build").get("includeDir"))
-        return LibBuilderBase.include_dir.fget(self)
+                return os.path.realpath(self._manifest.get("build").get("includeDir"))
+        return LibBuilderBase.include_dir.fget(self)  # pylint: disable=no-member
 
     @property
     def src_dir(self):
         if "srcDir" in self._manifest.get("build", {}):
             with fs.cd(self.path):
-                return realpath(self._manifest.get("build").get("srcDir"))
-        return LibBuilderBase.src_dir.fget(self)
+                return os.path.realpath(self._manifest.get("build").get("srcDir"))
+        return LibBuilderBase.src_dir.fget(self)  # pylint: disable=no-member
 
     @property
     def src_filter(self):
+        # pylint: disable=no-member
         if "srcFilter" in self._manifest.get("build", {}):
             return self._manifest.get("build").get("srcFilter")
         if self.env["SRC_FILTER"]:
@@ -703,19 +775,19 @@ class PlatformIOLibBuilder(LibBuilderBase):
     def build_flags(self):
         if "flags" in self._manifest.get("build", {}):
             return self._manifest.get("build").get("flags")
-        return LibBuilderBase.build_flags.fget(self)
+        return LibBuilderBase.build_flags.fget(self)  # pylint: disable=no-member
 
     @property
     def build_unflags(self):
         if "unflags" in self._manifest.get("build", {}):
             return self._manifest.get("build").get("unflags")
-        return LibBuilderBase.build_unflags.fget(self)
+        return LibBuilderBase.build_unflags.fget(self)  # pylint: disable=no-member
 
     @property
     def extra_script(self):
         if "extraScript" in self._manifest.get("build", {}):
             return self._manifest.get("build").get("extraScript")
-        return LibBuilderBase.extra_script.fget(self)
+        return LibBuilderBase.extra_script.fget(self)  # pylint: disable=no-member
 
     @property
     def lib_archive(self):
@@ -727,12 +799,14 @@ class PlatformIOLibBuilder(LibBuilderBase):
             return self.env.GetProjectConfig().get(
                 "env:" + self.env["PIOENV"], "lib_archive"
             )
+        # pylint: disable=no-member
         return self._manifest.get("build", {}).get(
             "libArchive", LibBuilderBase.lib_archive.fget(self)
         )
 
     @property
     def lib_ldf_mode(self):
+        # pylint: disable=no-member
         return self.validate_ldf_mode(
             self._manifest.get("build", {}).get(
                 "libLDFMode", LibBuilderBase.lib_ldf_mode.fget(self)
@@ -741,6 +815,7 @@ class PlatformIOLibBuilder(LibBuilderBase):
 
     @property
     def lib_compat_mode(self):
+        # pylint: disable=no-member
         return self.validate_compat_mode(
             self._manifest.get("build", {}).get(
                 "libCompatMode", LibBuilderBase.lib_compat_mode.fget(self)
@@ -748,16 +823,10 @@ class PlatformIOLibBuilder(LibBuilderBase):
         )
 
     def is_platforms_compatible(self, platforms):
-        items = self._manifest.get("platforms")
-        if not items:
-            return LibBuilderBase.is_platforms_compatible(self, platforms)
-        return util.items_in_list(platforms, items)
+        return util.items_in_list(platforms, self._manifest.get("platforms") or ["*"])
 
     def is_frameworks_compatible(self, frameworks):
-        items = self._manifest.get("frameworks")
-        if not items:
-            return LibBuilderBase.is_frameworks_compatible(self, frameworks)
-        return util.items_in_list(frameworks, items)
+        return util.items_in_list(frameworks, self._manifest.get("frameworks") or ["*"])
 
     def get_include_dirs(self):
         include_dirs = LibBuilderBase.get_include_dirs(self)
@@ -766,10 +835,10 @@ class PlatformIOLibBuilder(LibBuilderBase):
         if (
             "build" not in self._manifest
             and self._has_arduino_manifest()
-            and not isdir(join(self.path, "src"))
-            and isdir(join(self.path, "utility"))
+            and not os.path.isdir(os.path.join(self.path, "src"))
+            and os.path.isdir(os.path.join(self.path, "utility"))
         ):
-            include_dirs.append(join(self.path, "utility"))
+            include_dirs.append(os.path.join(self.path, "utility"))
 
         for path in self.env.get("CPPPATH", []):
             if path not in self.envorigin.get("CPPPATH", []):
@@ -788,7 +857,7 @@ class ProjectAsLibBuilder(LibBuilderBase):
     @property
     def include_dir(self):
         include_dir = self.env.subst("$PROJECT_INCLUDE_DIR")
-        return include_dir if isdir(include_dir) else None
+        return include_dir if os.path.isdir(include_dir) else None
 
     @property
     def src_dir(self):
@@ -797,7 +866,7 @@ class ProjectAsLibBuilder(LibBuilderBase):
     def get_include_dirs(self):
         include_dirs = []
         project_include_dir = self.env.subst("$PROJECT_INCLUDE_DIR")
-        if isdir(project_include_dir):
+        if os.path.isdir(project_include_dir):
             include_dirs.append(project_include_dir)
         for include_dir in LibBuilderBase.get_include_dirs(self):
             if include_dir not in include_dirs:
@@ -811,7 +880,7 @@ class ProjectAsLibBuilder(LibBuilderBase):
         if "__test" in COMMAND_LINE_TARGETS:
             items.extend(
                 [
-                    join("$PROJECT_TEST_DIR", item)
+                    os.path.join("$PROJECT_TEST_DIR", item)
                     for item in self.env.MatchSourceFiles(
                         "$PROJECT_TEST_DIR", "$PIOTEST_SRC_FILTER"
                     )
@@ -821,7 +890,7 @@ class ProjectAsLibBuilder(LibBuilderBase):
 
     @property
     def lib_ldf_mode(self):
-        mode = LibBuilderBase.lib_ldf_mode.fget(self)
+        mode = LibBuilderBase.lib_ldf_mode.fget(self)  # pylint: disable=no-member
         if not mode.startswith("chain"):
             return mode
         # parse all project files
@@ -829,6 +898,7 @@ class ProjectAsLibBuilder(LibBuilderBase):
 
     @property
     def src_filter(self):
+        # pylint: disable=no-member
         return self.env.get("SRC_FILTER") or LibBuilderBase.src_filter.fget(self)
 
     @property
@@ -840,34 +910,36 @@ class ProjectAsLibBuilder(LibBuilderBase):
         pass
 
     def install_dependencies(self):
-        def _is_builtin(uri):
+        def _is_builtin(spec):
             for lb in self.env.GetLibBuilders():
-                if lb.name == uri:
+                if lb.name == spec:
                     return True
             return False
 
-        not_found_uri = []
-        for uri in self.dependencies:
+        not_found_specs = []
+        for spec in self.dependencies:
             # check if built-in library
-            if _is_builtin(uri):
+            if _is_builtin(spec):
                 continue
 
             found = False
             for storage_dir in self.env.GetLibSourceDirs():
-                lm = LibraryManager(storage_dir)
-                if lm.get_package_dir(*lm.parse_pkg_uri(uri)):
+                lm = LibraryPackageManager(storage_dir)
+                if lm.get_package(spec):
                     found = True
                     break
             if not found:
-                not_found_uri.append(uri)
+                not_found_specs.append(spec)
 
         did_install = False
-        lm = LibraryManager(self.env.subst(join("$PROJECT_LIBDEPS_DIR", "$PIOENV")))
-        for uri in not_found_uri:
+        lm = LibraryPackageManager(
+            self.env.subst(os.path.join("$PROJECT_LIBDEPS_DIR", "$PIOENV"))
+        )
+        for spec in not_found_specs:
             try:
-                lm.install(uri)
+                lm.install(spec)
                 did_install = True
-            except (exception.LibNotFound, exception.InternetIsOffline) as e:
+            except (UnknownPackageError, InternetIsOffline) as e:
                 click.secho("Warning! %s" % e, fg="yellow")
 
         # reset cache
@@ -875,17 +947,17 @@ class ProjectAsLibBuilder(LibBuilderBase):
             DefaultEnvironment().Replace(__PIO_LIB_BUILDERS=None)
 
     def process_dependencies(self):  # pylint: disable=too-many-branches
-        for uri in self.dependencies:
+        for spec in self.dependencies:
             found = False
             for storage_dir in self.env.GetLibSourceDirs():
                 if found:
                     break
-                lm = LibraryManager(storage_dir)
-                lib_dir = lm.get_package_dir(*lm.parse_pkg_uri(uri))
-                if not lib_dir:
+                lm = LibraryPackageManager(storage_dir)
+                pkg = lm.get_package(spec)
+                if not pkg:
                     continue
                 for lb in self.env.GetLibBuilders():
-                    if lib_dir != lb.path:
+                    if pkg.path != lb.path:
                         continue
                     if lb not in self.depbuilders:
                         self.depend_recursive(lb)
@@ -897,7 +969,7 @@ class ProjectAsLibBuilder(LibBuilderBase):
             # look for built-in libraries by a name
             # which don't have package manifest
             for lb in self.env.GetLibBuilders():
-                if lb.name != uri:
+                if lb.name != spec:
                     continue
                 if lb not in self.depbuilders:
                     self.depend_recursive(lb)
@@ -952,12 +1024,12 @@ def GetLibBuilders(env):  # pylint: disable=too-many-branches
     found_incompat = False
 
     for storage_dir in env.GetLibSourceDirs():
-        storage_dir = realpath(storage_dir)
-        if not isdir(storage_dir):
+        storage_dir = os.path.realpath(storage_dir)
+        if not os.path.isdir(storage_dir):
             continue
         for item in sorted(os.listdir(storage_dir)):
-            lib_dir = join(storage_dir, item)
-            if item == "__cores__" or not isdir(lib_dir):
+            lib_dir = os.path.join(storage_dir, item)
+            if item == "__cores__" or not os.path.isdir(lib_dir):
                 continue
             try:
                 lb = LibBuilderFactory.new(env, lib_dir)
@@ -989,10 +1061,6 @@ def GetLibBuilders(env):  # pylint: disable=too-many-branches
 
 
 def ConfigureProjectLibBuilder(env):
-    def _get_vcs_info(lb):
-        path = LibraryManager.get_src_manifest_path(lb.path)
-        return fs.load_json(path) if path else None
-
     def _correct_found_libs(lib_builders):
         # build full dependency graph
         found_lbs = [lb for lb in lib_builders if lb.dependent]
@@ -1008,15 +1076,15 @@ def ConfigureProjectLibBuilder(env):
         margin = "|   " * (level)
         for lb in root.depbuilders:
             title = "<%s>" % lb.name
-            vcs_info = _get_vcs_info(lb)
-            if lb.version:
+            pkg = PackageItem(lb.path)
+            if pkg.metadata:
+                title += " %s" % pkg.metadata.version
+            elif lb.version:
                 title += " %s" % lb.version
-            if vcs_info and vcs_info.get("version"):
-                title += " #%s" % vcs_info.get("version")
             click.echo("%s|-- %s" % (margin, title), nl=False)
             if int(ARGUMENTS.get("PIOVERBOSE", 0)):
-                if vcs_info:
-                    click.echo(" [%s]" % vcs_info.get("url"), nl=False)
+                if pkg.metadata and pkg.metadata.spec.external:
+                    click.echo(" [%s]" % pkg.metadata.spec.url, nl=False)
                 click.echo(" (", nl=False)
                 click.echo(lb.path, nl=False)
                 click.echo(")", nl=False)
@@ -1025,7 +1093,7 @@ def ConfigureProjectLibBuilder(env):
                 _print_deps_tree(lb, level + 1)
 
     project = ProjectAsLibBuilder(env, "$PROJECT_DIR")
-    ldf_mode = LibBuilderBase.lib_ldf_mode.fget(project)
+    ldf_mode = LibBuilderBase.lib_ldf_mode.fget(project)  # pylint: disable=no-member
 
     click.echo("LDF: Library Dependency Finder -> http://bit.ly/configure-pio-ldf")
     click.echo(

platformio/builder/tools/piomaxlen.py

@@ -14,15 +14,30 @@
 
 from __future__ import absolute_import
 
-from hashlib import md5
-from os import makedirs
-from os.path import isdir, isfile, join
+import hashlib
+import os
+import re
 
-from platformio.compat import WINDOWS, hashlib_encode_data
+from SCons.Platform import TempFileMunge  # pylint: disable=import-error
+from SCons.Subst import quote_spaces  # pylint: disable=import-error
 
-# Windows CLI has limit with command length to 8192
-# Leave 2000 chars for flags and other options
-MAX_LINE_LENGTH = 6000 if WINDOWS else 128072
+from platformio.compat import IS_WINDOWS, hashlib_encode_data
+
+# There are the next limits depending on a platform:
+# - Windows = 8192
+# - Unix    = 131072
+# We need ~512 characters for compiler and temporary file paths
+MAX_LINE_LENGTH = (8192 if IS_WINDOWS else 131072) - 512
+
+WINPATHSEP_RE = re.compile(r"\\([^\"'\\]|$)")
+
+
+def tempfile_arg_esc_func(arg):
+    arg = quote_spaces(arg)
+    if not IS_WINDOWS:
+        return arg
+    # GCC requires double Windows slashes, let's use UNIX separator
+    return WINPATHSEP_RE.sub(r"/\1", arg)
 
 
 def long_sources_hook(env, sources):
@@ -41,32 +56,16 @@ def long_sources_hook(env, sources):
     return '@"%s"' % _file_long_data(env, " ".join(data))
 
 
-def long_incflags_hook(env, incflags):
-    _incflags = env.subst(incflags).replace("\\", "/")
-    if len(_incflags) < MAX_LINE_LENGTH:
-        return incflags
-
-    # fix space in paths
-    data = []
-    for line in _incflags.split(" -I"):
-        line = line.strip()
-        if not line.startswith("-I"):
-            line = "-I" + line
-        data.append('-I"%s"' % line[2:])
-
-    return '@"%s"' % _file_long_data(env, " ".join(data))
-
-
 def _file_long_data(env, data):
     build_dir = env.subst("$BUILD_DIR")
-    if not isdir(build_dir):
-        makedirs(build_dir)
-    tmp_file = join(
-        build_dir, "longcmd-%s" % md5(hashlib_encode_data(data)).hexdigest()
+    if not os.path.isdir(build_dir):
+        os.makedirs(build_dir)
+    tmp_file = os.path.join(
+        build_dir, "longcmd-%s" % hashlib.md5(hashlib_encode_data(data)).hexdigest()
     )
-    if isfile(tmp_file):
+    if os.path.isfile(tmp_file):
         return tmp_file
-    with open(tmp_file, "w") as fp:
+    with open(tmp_file, mode="w", encoding="utf8") as fp:
         fp.write(data)
     return tmp_file
 
@@ -76,17 +75,21 @@ def exists(_):
 
 
 def generate(env):
-    env.Replace(_long_sources_hook=long_sources_hook)
-    env.Replace(_long_incflags_hook=long_incflags_hook)
-    coms = {}
-    for key in ("ARCOM", "LINKCOM"):
-        coms[key] = env.get(key, "").replace(
-            "$SOURCES", "${_long_sources_hook(__env__, SOURCES)}"
-        )
-    for key in ("_CCCOMCOM", "ASPPCOM"):
-        coms[key] = env.get(key, "").replace(
-            "$_CPPINCFLAGS", "${_long_incflags_hook(__env__, _CPPINCFLAGS)}"
-        )
-    env.Replace(**coms)
+    kwargs = dict(
+        _long_sources_hook=long_sources_hook,
+        TEMPFILE=TempFileMunge,
+        MAXLINELENGTH=MAX_LINE_LENGTH,
+        TEMPFILEARGESCFUNC=tempfile_arg_esc_func,
+        TEMPFILESUFFIX=".tmp",
+        TEMPFILEDIR="$BUILD_DIR",
+    )
+
+    for name in ("LINKCOM", "ASCOM", "ASPPCOM", "CCCOM", "CXXCOM"):
+        kwargs[name] = "${TEMPFILE('%s','$%sSTR')}" % (env.get(name), name)
+
+    kwargs["ARCOM"] = env.get("ARCOM", "").replace(
+        "$SOURCES", "${_long_sources_hook(__env__, SOURCES)}"
+    )
+    env.Replace(**kwargs)
 
     return env

platformio/builder/tools/piomisc.py

@@ -15,20 +15,18 @@
 from __future__ import absolute_import
 
 import atexit
+import glob
 import io
+import os
 import re
 import sys
-from os import environ, remove, walk
-from os.path import basename, isdir, isfile, join, realpath, relpath, sep
-from tempfile import mkstemp
+import tempfile
 
 import click
-from SCons.Action import Action  # pylint: disable=import-error
-from SCons.Script import ARGUMENTS  # pylint: disable=import-error
 
 from platformio import fs, util
-from platformio.compat import get_filesystem_encoding, get_locale_encoding, glob_escape
-from platformio.managers.core import get_core_package_dir
+from platformio.compat import get_filesystem_encoding, get_locale_encoding
+from platformio.package.manager.core import get_core_package_dir
 from platformio.proc import exec_command
 
 
@@ -119,18 +117,18 @@ class InoToCPPConverter(object):
         return out_file
 
     def _gcc_preprocess(self, contents, out_file):
-        tmp_path = mkstemp()[1]
+        tmp_path = tempfile.mkstemp()[1]
         self.write_safe_contents(tmp_path, contents)
         self.env.Execute(
             self.env.VerboseAction(
                 '$CXX -o "{0}" -x c++ -fpreprocessed -dD -E "{1}"'.format(
                     out_file, tmp_path
                 ),
-                "Converting " + basename(out_file[:-4]),
+                "Converting " + os.path.basename(out_file[:-4]),
             )
         )
         atexit.register(_delete_file, tmp_path)
-        return isfile(out_file)
+        return os.path.isfile(out_file)
 
     def _join_multiline_strings(self, contents):
         if "\\\n" not in contents:
@@ -232,8 +230,10 @@ class InoToCPPConverter(object):
 
 
 def ConvertInoToCpp(env):
-    src_dir = glob_escape(env.subst("$PROJECT_SRC_DIR"))
-    ino_nodes = env.Glob(join(src_dir, "*.ino")) + env.Glob(join(src_dir, "*.pde"))
+    src_dir = glob.escape(env.subst("$PROJECT_SRC_DIR"))
+    ino_nodes = env.Glob(os.path.join(src_dir, "*.ino")) + env.Glob(
+        os.path.join(src_dir, "*.pde")
+    )
     if not ino_nodes:
         return
     c = InoToCPPConverter(env)
@@ -244,8 +244,8 @@ def ConvertInoToCpp(env):
 
 def _delete_file(path):
     try:
-        if isfile(path):
-            remove(path)
+        if os.path.isfile(path):
+            os.remove(path)
     except:  # pylint: disable=bare-except
         pass
 
@@ -255,7 +255,7 @@ def _get_compiler_type(env):
     if env.subst("$CC").endswith("-gcc"):
         return "gcc"
     try:
-        sysenv = environ.copy()
+        sysenv = os.environ.copy()
         sysenv["PATH"] = str(env["ENV"]["PATH"])
         result = exec_command([env.subst("$CC"), "-v"], env=sysenv)
     except OSError:
@@ -277,8 +277,8 @@ def GetCompilerType(env):
 def GetActualLDScript(env):
     def _lookup_in_ldpath(script):
         for d in env.get("LIBPATH", []):
-            path = join(env.subst(d), script)
-            if isfile(path):
+            path = os.path.join(env.subst(d), script)
+            if os.path.isfile(path):
                 return path
         return None
 
@@ -297,7 +297,7 @@ def GetActualLDScript(env):
         else:
             continue
         script = env.subst(raw_script.replace('"', "").strip())
-        if isfile(script):
+        if os.path.isfile(script):
             return script
         path = _lookup_in_ldpath(script)
         if path:
@@ -319,29 +319,6 @@ def GetActualLDScript(env):
     env.Exit(1)
 
 
-def VerboseAction(_, act, actstr):
-    if int(ARGUMENTS.get("PIOVERBOSE", 0)):
-        return act
-    return Action(act, actstr)
-
-
-def PioClean(env, clean_dir):
-    if not isdir(clean_dir):
-        print("Build environment is clean")
-        env.Exit(0)
-    clean_rel_path = relpath(clean_dir)
-    for root, _, files in walk(clean_dir):
-        for f in files:
-            dst = join(root, f)
-            remove(dst)
-            print(
-                "Removed %s" % (dst if clean_rel_path.startswith(".") else relpath(dst))
-            )
-    print("Done cleaning")
-    fs.rmtree(clean_dir)
-    env.Exit(0)
-
-
 def ConfigureDebugFlags(env):
     def _cleanup_debug_flags(scope):
         if scope not in env:
@@ -357,7 +334,13 @@ def ConfigureDebugFlags(env):
     for scope in ("ASFLAGS", "CCFLAGS", "LINKFLAGS"):
         _cleanup_debug_flags(scope)
 
-    debug_flags = env.ParseFlags(env.GetProjectOption("debug_build_flags"))
+    debug_flags = env.ParseFlags(
+        env.get("PIODEBUGFLAGS")
+        if env.get("PIODEBUGFLAGS")
+        and not env.GetProjectOptions(as_dict=True).get("debug_build_flags")
+        else env.GetProjectOption("debug_build_flags")
+    )
+
     env.MergeFlags(debug_flags)
     optimization_flags = [
         f for f in debug_flags.get("CCFLAGS", []) if f.startswith(("-O", "-g"))
@@ -370,16 +353,16 @@ def ConfigureDebugFlags(env):
 def ConfigureTestTarget(env):
     env.Append(
         CPPDEFINES=["UNIT_TEST", "UNITY_INCLUDE_CONFIG_H"],
-        CPPPATH=[join("$BUILD_DIR", "UnityTestLib")],
+        CPPPATH=[os.path.join("$BUILD_DIR", "UnityTestLib")],
     )
     unitylib = env.BuildLibrary(
-        join("$BUILD_DIR", "UnityTestLib"), get_core_package_dir("tool-unity")
+        os.path.join("$BUILD_DIR", "UnityTestLib"), get_core_package_dir("tool-unity")
     )
     env.Prepend(LIBS=[unitylib])
 
     src_filter = ["+<*.cpp>", "+<*.c>"]
     if "PIOTEST_RUNNING_NAME" in env:
-        src_filter.append("+<%s%s>" % (env["PIOTEST_RUNNING_NAME"], sep))
+        src_filter.append("+<%s%s>" % (env["PIOTEST_RUNNING_NAME"], os.path.sep))
     env.Replace(PIOTEST_SRC_FILTER=src_filter)
 
 
@@ -393,7 +376,7 @@ def GetExtraScripts(env, scope):
     if not items:
         return items
     with fs.cd(env.subst("$PROJECT_DIR")):
-        return [realpath(item) for item in items]
+        return [os.path.realpath(item) for item in items]
 
 
 def exists(_):
@@ -404,8 +387,6 @@ def generate(env):
     env.AddMethod(ConvertInoToCpp)
     env.AddMethod(GetCompilerType)
     env.AddMethod(GetActualLDScript)
-    env.AddMethod(VerboseAction)
-    env.AddMethod(PioClean)
     env.AddMethod(ConfigureDebugFlags)
     env.AddMethod(ConfigureTestTarget)
     env.AddMethod(GetExtraScripts)

platformio/builder/tools/pioplatform.py

@@ -14,15 +14,18 @@
 
 from __future__ import absolute_import
 
+import os
 import sys
-from os.path import isdir, isfile, join
 
 from SCons.Script import ARGUMENTS  # pylint: disable=import-error
 from SCons.Script import COMMAND_LINE_TARGETS  # pylint: disable=import-error
 
-from platformio import exception, fs, util
-from platformio.compat import WINDOWS
-from platformio.managers.platform import PlatformFactory
+from platformio import fs, util
+from platformio.compat import IS_MACOS, IS_WINDOWS
+from platformio.package.meta import PackageItem
+from platformio.package.version import get_original_version
+from platformio.platform.exception import UnknownBoard
+from platformio.platform.factory import PlatformFactory
 from platformio.project.config import ProjectOptions
 
 # pylint: disable=too-many-branches, too-many-locals
@@ -34,7 +37,7 @@ def PioPlatform(env):
     if "framework" in variables:
         # support PIO Core 3.0 dev/platforms
         variables["pioframework"] = variables["framework"]
-    p = PlatformFactory.newPlatform(env["PLATFORM_MANIFEST"])
+    p = PlatformFactory.new(os.path.dirname(env["PLATFORM_MANIFEST"]))
     p.configure_default_packages(variables, COMMAND_LINE_TARGETS)
     return p
 
@@ -46,46 +49,51 @@ def BoardConfig(env, board=None):
             board = board or env.get("BOARD")
             assert board, "BoardConfig: Board is not defined"
             return p.board_config(board)
-        except (AssertionError, exception.UnknownBoard) as e:
+        except (AssertionError, UnknownBoard) as e:
             sys.stderr.write("Error: %s\n" % str(e))
             env.Exit(1)
+    return None
 
 
 def GetFrameworkScript(env, framework):
     p = env.PioPlatform()
     assert p.frameworks and framework in p.frameworks
     script_path = env.subst(p.frameworks[framework]["script"])
-    if not isfile(script_path):
-        script_path = join(p.get_dir(), script_path)
+    if not os.path.isfile(script_path):
+        script_path = os.path.join(p.get_dir(), script_path)
     return script_path
 
 
 def LoadPioPlatform(env):
     p = env.PioPlatform()
-    installed_packages = p.get_installed_packages()
 
     # Ensure real platform name
     env["PIOPLATFORM"] = p.name
 
     # Add toolchains and uploaders to $PATH and $*_LIBRARY_PATH
-    systype = util.get_systype()
-    for name in installed_packages:
-        type_ = p.get_package_type(name)
+    for pkg in p.get_installed_packages():
+        type_ = p.get_package_type(pkg.metadata.name)
         if type_ not in ("toolchain", "uploader", "debugger"):
             continue
-        pkg_dir = p.get_package_dir(name)
         env.PrependENVPath(
-            "PATH", join(pkg_dir, "bin") if isdir(join(pkg_dir, "bin")) else pkg_dir
+            "PATH",
+            os.path.join(pkg.path, "bin")
+            if os.path.isdir(os.path.join(pkg.path, "bin"))
+            else pkg.path,
         )
-        if not WINDOWS and isdir(join(pkg_dir, "lib")) and type_ != "toolchain":
+        if (
+            not IS_WINDOWS
+            and os.path.isdir(os.path.join(pkg.path, "lib"))
+            and type_ != "toolchain"
+        ):
             env.PrependENVPath(
-                "DYLD_LIBRARY_PATH" if "darwin" in systype else "LD_LIBRARY_PATH",
-                join(pkg_dir, "lib"),
+                "DYLD_LIBRARY_PATH" if IS_MACOS else "LD_LIBRARY_PATH",
+                os.path.join(pkg.path, "lib"),
             )
 
     # Platform specific LD Scripts
-    if isdir(join(p.get_dir(), "ldscripts")):
-        env.Prepend(LIBPATH=[join(p.get_dir(), "ldscripts")])
+    if os.path.isdir(os.path.join(p.get_dir(), "ldscripts")):
+        env.Prepend(LIBPATH=[os.path.join(p.get_dir(), "ldscripts")])
 
     if "BOARD" not in env:
         return
@@ -125,6 +133,7 @@ def LoadPioPlatform(env):
 
 def PrintConfiguration(env):  # pylint: disable=too-many-statements
     platform = env.PioPlatform()
+    pkg_metadata = PackageItem(platform.get_dir()).metadata
     board_config = env.BoardConfig() if "BOARD" in env else None
 
     def _get_configuration_data():
@@ -139,11 +148,19 @@ def PrintConfiguration(env):  # pylint: disable=too-many-statements
         )
 
     def _get_plaform_data():
-        data = ["PLATFORM: %s %s" % (platform.title, platform.version)]
-        if platform.src_version:
-            data.append("#" + platform.src_version)
-        if int(ARGUMENTS.get("PIOVERBOSE", 0)) and platform.src_url:
-            data.append("(%s)" % platform.src_url)
+        data = [
+            "PLATFORM: %s (%s)"
+            % (
+                platform.title,
+                pkg_metadata.version if pkg_metadata else platform.version,
+            )
+        ]
+        if (
+            int(ARGUMENTS.get("PIOVERBOSE", 0))
+            and pkg_metadata
+            and pkg_metadata.spec.external
+        ):
+            data.append("(%s)" % pkg_metadata.spec.url)
         if board_config:
             data.extend([">", board_config.get("name")])
         return data
@@ -162,7 +179,8 @@ def PrintConfiguration(env):  # pylint: disable=too-many-statements
         ram = board_config.get("upload", {}).get("maximum_ram_size")
         flash = board_config.get("upload", {}).get("maximum_size")
         data.append(
-            "%s RAM, %s Flash" % (fs.format_filesize(ram), fs.format_filesize(flash))
+            "%s RAM, %s Flash"
+            % (fs.humanize_file_size(ram), fs.humanize_file_size(flash))
         )
         return data
 
@@ -194,7 +212,7 @@ def PrintConfiguration(env):  # pylint: disable=too-many-statements
     def _get_packages_data():
         data = []
         for item in platform.dump_used_packages():
-            original_version = util.get_original_version(item["version"])
+            original_version = get_original_version(item["version"])
             info = "%s %s" % (item["name"], item["version"])
             extra = []
             if original_version:

platformio/builder/tools/piosize.py

@@ -16,6 +16,7 @@
 
 from __future__ import absolute_import
 
+import json
 import sys
 from os import environ, makedirs, remove
 from os.path import isdir, join, splitdrive
@@ -23,9 +24,8 @@ from os.path import isdir, join, splitdrive
 from elftools.elf.descriptions import describe_sh_flags
 from elftools.elf.elffile import ELFFile
 
-from platformio.compat import dump_json_to_unicode
+from platformio.compat import IS_WINDOWS
 from platformio.proc import exec_command
-from platformio.util import get_systype
 
 
 def _run_tool(cmd, env, tool_args):
@@ -37,7 +37,7 @@ def _run_tool(cmd, env, tool_args):
         makedirs(build_dir)
     tmp_file = join(build_dir, "size-data-longcmd.txt")
 
-    with open(tmp_file, "w") as fp:
+    with open(tmp_file, mode="w", encoding="utf8") as fp:
         fp.write("\n".join(tool_args))
 
     cmd.append("@" + tmp_file)
@@ -164,7 +164,7 @@ def _collect_symbols_info(env, elffile, elf_path, sections):
         location = symbol_locations.get(hex(symbol["addr"]))
         if not location or "?" in location:
             continue
-        if "windows" in get_systype():
+        if IS_WINDOWS:
             drive, tail = splitdrive(location)
             location = join(drive.upper(), tail)
         symbol["file"] = location
@@ -220,7 +220,7 @@ def DumpSizeData(_, target, source, env):  # pylint: disable=unused-argument
             "sections": sections,
         }
 
-        files = dict()
+        files = {}
         for symbol in _collect_symbols_info(env, elffile, elf_path, sections):
             file_path = symbol.get("file") or "unknown"
             if not files.get(file_path, {}):
@@ -235,14 +235,16 @@ def DumpSizeData(_, target, source, env):  # pylint: disable=unused-argument
 
             files[file_path]["symbols"].append(symbol)
 
-        data["memory"]["files"] = list()
+        data["memory"]["files"] = []
         for k, v in files.items():
             file_data = {"path": k}
             file_data.update(v)
             data["memory"]["files"].append(file_data)
 
-    with open(join(env.subst("$BUILD_DIR"), "sizedata.json"), "w") as fp:
-        fp.write(dump_json_to_unicode(data))
+    with open(
+        join(env.subst("$BUILD_DIR"), "sizedata.json"), mode="w", encoding="utf8"
+    ) as fp:
+        fp.write(json.dumps(data))
 
 
 def exists(_):

platformio/builder/tools/piotarget.py

@@ -0,0 +1,134 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+from __future__ import absolute_import
+
+import os
+
+from SCons.Action import Action  # pylint: disable=import-error
+from SCons.Script import ARGUMENTS  # pylint: disable=import-error
+from SCons.Script import AlwaysBuild  # pylint: disable=import-error
+
+from platformio import compat, fs
+
+
+def VerboseAction(_, act, actstr):
+    if int(ARGUMENTS.get("PIOVERBOSE", 0)):
+        return act
+    return Action(act, actstr)
+
+
+def PioClean(env, clean_all=False):
+    def _relpath(path):
+        if compat.IS_WINDOWS:
+            prefix = os.getcwd()[:2].lower()
+            if (
+                ":" not in prefix
+                or not path.lower().startswith(prefix)
+                or os.path.relpath(path).startswith("..")
+            ):
+                return path
+        return os.path.relpath(path)
+
+    def _clean_dir(path):
+        clean_rel_path = _relpath(path)
+        for root, _, files in os.walk(path):
+            for f in files:
+                dst = os.path.join(root, f)
+                os.remove(dst)
+                print(
+                    "Removed %s"
+                    % (dst if not clean_rel_path.startswith(".") else _relpath(dst))
+                )
+
+    build_dir = env.subst("$BUILD_DIR")
+    libdeps_dir = env.subst("$PROJECT_LIBDEPS_DIR")
+    if os.path.isdir(build_dir):
+        _clean_dir(build_dir)
+        fs.rmtree(build_dir)
+    else:
+        print("Build environment is clean")
+
+    if clean_all and os.path.isdir(libdeps_dir):
+        _clean_dir(libdeps_dir)
+        fs.rmtree(libdeps_dir)
+
+    print("Done cleaning")
+
+
+def AddTarget(  # pylint: disable=too-many-arguments
+    env,
+    name,
+    dependencies,
+    actions,
+    title=None,
+    description=None,
+    group="General",
+    always_build=True,
+):
+    if "__PIO_TARGETS" not in env:
+        env["__PIO_TARGETS"] = {}
+    assert name not in env["__PIO_TARGETS"]
+    env["__PIO_TARGETS"][name] = dict(
+        name=name, title=title, description=description, group=group
+    )
+    target = env.Alias(name, dependencies, actions)
+    if always_build:
+        AlwaysBuild(target)
+    return target
+
+
+def AddPlatformTarget(env, *args, **kwargs):
+    return env.AddTarget(group="Platform", *args, **kwargs)
+
+
+def AddCustomTarget(env, *args, **kwargs):
+    return env.AddTarget(group="Custom", *args, **kwargs)
+
+
+def DumpTargets(env):
+    targets = env.get("__PIO_TARGETS") or {}
+    # pre-fill default targets if embedded dev-platform
+    if env.PioPlatform().is_embedded() and not any(
+        t["group"] == "Platform" for t in targets.values()
+    ):
+        targets["upload"] = dict(name="upload", group="Platform", title="Upload")
+    targets["compiledb"] = dict(
+        name="compiledb",
+        title="Compilation Database",
+        description="Generate compilation database `compile_commands.json`",
+        group="Advanced",
+    )
+    targets["clean"] = dict(name="clean", title="Clean", group="General")
+    targets["cleanall"] = dict(
+        name="cleanall",
+        title="Clean All",
+        group="General",
+        description="Clean a build environment and installed library dependencies",
+    )
+    return list(targets.values())
+
+
+def exists(_):
+    return True
+
+
+def generate(env):
+    env.AddMethod(VerboseAction)
+    env.AddMethod(PioClean)
+    env.AddMethod(AddTarget)
+    env.AddMethod(AddPlatformTarget)
+    env.AddMethod(AddCustomTarget)
+    env.AddMethod(DumpTargets)
+    return env

platformio/builder/tools/pioupload.py

@@ -26,7 +26,7 @@ from SCons.Script import ARGUMENTS  # pylint: disable=import-error
 from serial import Serial, SerialException
 
 from platformio import exception, fs, util
-from platformio.compat import WINDOWS
+from platformio.compat import IS_WINDOWS
 from platformio.proc import exec_command
 
 # pylint: disable=unused-argument
@@ -134,7 +134,7 @@ def AutodetectUploadPort(*args, **kwargs):
                 continue
             port = item["port"]
             if upload_protocol.startswith("blackmagic"):
-                if WINDOWS and port.startswith("COM") and len(port) > 4:
+                if IS_WINDOWS and port.startswith("COM") and len(port) > 4:
                     port = "\\\\.\\%s" % port
                 if "GDB" in item["description"]:
                     return port
@@ -236,9 +236,9 @@ def CheckUploadSize(_, target, source, env):
     def _format_availale_bytes(value, total):
         percent_raw = float(value) / float(total)
         blocks_per_progress = 10
-        used_blocks = int(round(blocks_per_progress * percent_raw))
-        if used_blocks > blocks_per_progress:
-            used_blocks = blocks_per_progress
+        used_blocks = min(
+            int(round(blocks_per_progress * percent_raw)), blocks_per_progress
+        )
         return "[{:{}}] {: 6.1%} (used {:d} bytes from {:d} bytes)".format(
             "=" * used_blocks, blocks_per_progress, percent_raw, value, total
         )

platformio/builder/tools/platformio.py

@@ -26,9 +26,9 @@ from SCons.Script import DefaultEnvironment  # pylint: disable=import-error
 from SCons.Script import Export  # pylint: disable=import-error
 from SCons.Script import SConscript  # pylint: disable=import-error
 
-from platformio import fs
-from platformio.compat import string_types
-from platformio.util import pioversion_to_intstr
+from platformio import __version__, fs
+from platformio.compat import IS_MACOS, string_types
+from platformio.package.version import pepver_to_semver
 
 SRC_HEADER_EXT = ["h", "hpp"]
 SRC_ASM_EXT = ["S", "spp", "SPP", "sx", "s", "asm", "ASM"]
@@ -50,7 +50,7 @@ def GetBuildType(env):
     return (
         "debug"
         if (
-            set(["debug", "sizedata"]) & set(COMMAND_LINE_TARGETS)
+            set(["__debug", "sizedata"]) & set(COMMAND_LINE_TARGETS)
             or env.GetProjectOption("build_type") == "debug"
         )
         else "release"
@@ -66,12 +66,17 @@ def BuildProgram(env):
         env.Prepend(LINKFLAGS=["-T", env.subst("$LDSCRIPT_PATH")])
 
     # enable "cyclic reference" for linker
-    if env.get("LIBS") and env.GetCompilerType() == "gcc":
+    if (
+        env.get("LIBS")
+        and env.GetCompilerType() == "gcc"
+        and (env.PioPlatform().is_embedded() or not IS_MACOS)
+    ):
         env.Prepend(_LIBFLAGS="-Wl,--start-group ")
         env.Append(_LIBFLAGS=" -Wl,--end-group")
 
     program = env.Program(
-        os.path.join("$BUILD_DIR", env.subst("$PROGNAME")), env["PIOBUILDFILES"]
+        os.path.join("$BUILD_DIR", env.subst("$PROGNAME$PROGSUFFIX")),
+        env["PIOBUILDFILES"],
     )
     env.Replace(PIOMAINPROG=program)
 
@@ -90,11 +95,16 @@ def BuildProgram(env):
 
 def ProcessProgramDeps(env):
     def _append_pio_macros():
+        core_version = pepver_to_semver(__version__)
         env.AppendUnique(
             CPPDEFINES=[
                 (
                     "PLATFORMIO",
-                    int("{0:02d}{1:02d}{2:02d}".format(*pioversion_to_intstr())),
+                    int(
+                        "{0:02d}{1:02d}{2:02d}".format(
+                            core_version.major, core_version.minor, core_version.patch
+                        )
+                    ),
                 )
             ]
         )
@@ -282,18 +292,21 @@ def CollectBuildFiles(
         if fs.path_endswith_ext(item, SRC_BUILD_EXT):
             sources.append(env.File(os.path.join(_var_dir, os.path.basename(item))))
 
-    for callback, pattern in env.get("__PIO_BUILD_MIDDLEWARES", []):
-        tmp = []
-        for node in sources:
-            if pattern and not fnmatch.fnmatch(node.srcnode().get_path(), pattern):
-                tmp.append(node)
-                continue
-            n = callback(node)
-            if n:
-                tmp.append(n)
-        sources = tmp
+    middlewares = env.get("__PIO_BUILD_MIDDLEWARES")
+    if not middlewares:
+        return sources
 
-    return sources
+    new_sources = []
+    for node in sources:
+        new_node = node
+        for callback, pattern in middlewares:
+            if pattern and not fnmatch.fnmatch(node.srcnode().get_path(), pattern):
+                continue
+            new_node = callback(new_node)
+        if new_node:
+            new_sources.append(new_node)
+
+    return new_sources
 
 
 def AddBuildMiddleware(env, callback, pattern=None):
@@ -333,11 +346,10 @@ def BuildFrameworks(env, frameworks):
             env.Exit(1)
 
 
-def BuildLibrary(env, variant_dir, src_dir, src_filter=None):
+def BuildLibrary(env, variant_dir, src_dir, src_filter=None, nodes=None):
     env.ProcessUnFlags(env.get("BUILD_UNFLAGS"))
-    return env.StaticLibrary(
-        env.subst(variant_dir), env.CollectBuildFiles(variant_dir, src_dir, src_filter)
-    )
+    nodes = nodes or env.CollectBuildFiles(variant_dir, src_dir, src_filter)
+    return env.StaticLibrary(env.subst(variant_dir), nodes)
 
 
 def BuildSources(env, variant_dir, src_dir, src_filter=None):

platformio/cache.py

@@ -0,0 +1,165 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+import codecs
+import hashlib
+import os
+from time import time
+
+from platformio import app, fs
+from platformio.compat import hashlib_encode_data
+from platformio.package.lockfile import LockFile
+from platformio.project.helpers import get_project_cache_dir
+
+
+class ContentCache(object):
+    def __init__(self, namespace=None):
+        self.cache_dir = os.path.join(get_project_cache_dir(), namespace or "content")
+        self._db_path = os.path.join(self.cache_dir, "db.data")
+        self._lockfile = None
+        if not os.path.isdir(self.cache_dir):
+            os.makedirs(self.cache_dir)
+
+    def __enter__(self):
+        # cleanup obsolete items
+        self.delete()
+        return self
+
+    def __exit__(self, type_, value, traceback):
+        pass
+
+    @staticmethod
+    def key_from_args(*args):
+        h = hashlib.sha1()
+        for arg in args:
+            if arg:
+                h.update(hashlib_encode_data(arg))
+        return h.hexdigest()
+
+    def get_cache_path(self, key):
+        assert "/" not in key and "\\" not in key
+        key = str(key)
+        assert len(key) > 3
+        return os.path.join(self.cache_dir, key)
+
+    def get(self, key):
+        cache_path = self.get_cache_path(key)
+        if not os.path.isfile(cache_path):
+            return None
+        with codecs.open(cache_path, "rb", encoding="utf8") as fp:
+            return fp.read()
+
+    def set(self, key, data, valid):
+        if not app.get_setting("enable_cache"):
+            return False
+        cache_path = self.get_cache_path(key)
+        if os.path.isfile(cache_path):
+            self.delete(key)
+        if not data:
+            return False
+        tdmap = {"s": 1, "m": 60, "h": 3600, "d": 86400}
+        assert valid.endswith(tuple(tdmap))
+        expire_time = int(time() + tdmap[valid[-1]] * int(valid[:-1]))
+
+        if not self._lock_dbindex():
+            return False
+
+        if not os.path.isdir(os.path.dirname(cache_path)):
+            os.makedirs(os.path.dirname(cache_path))
+        try:
+            with codecs.open(cache_path, mode="wb", encoding="utf8") as fp:
+                fp.write(data)
+            with open(self._db_path, mode="a", encoding="utf8") as fp:
+                fp.write("%s=%s\n" % (str(expire_time), os.path.basename(cache_path)))
+        except UnicodeError:
+            if os.path.isfile(cache_path):
+                try:
+                    os.remove(cache_path)
+                except OSError:
+                    pass
+
+        return self._unlock_dbindex()
+
+    def delete(self, keys=None):
+        """Keys=None, delete expired items"""
+        if not os.path.isfile(self._db_path):
+            return None
+        if not keys:
+            keys = []
+        if not isinstance(keys, list):
+            keys = [keys]
+        paths_for_delete = [self.get_cache_path(k) for k in keys]
+        found = False
+        newlines = []
+        with open(self._db_path, encoding="utf8") as fp:
+            for line in fp.readlines():
+                line = line.strip()
+                if "=" not in line:
+                    continue
+                expire, fname = line.split("=")
+                path = os.path.join(self.cache_dir, fname)
+                try:
+                    if (
+                        time() < int(expire)
+                        and os.path.isfile(path)
+                        and path not in paths_for_delete
+                    ):
+                        newlines.append(line)
+                        continue
+                except ValueError:
+                    pass
+                found = True
+                if os.path.isfile(path):
+                    try:
+                        os.remove(path)
+                        if not os.listdir(os.path.dirname(path)):
+                            fs.rmtree(os.path.dirname(path))
+                    except OSError:
+                        pass
+
+        if found and self._lock_dbindex():
+            with open(self._db_path, mode="w", encoding="utf8") as fp:
+                fp.write("\n".join(newlines) + "\n")
+            self._unlock_dbindex()
+
+        return True
+
+    def clean(self):
+        if not os.path.isdir(self.cache_dir):
+            return
+        fs.rmtree(self.cache_dir)
+
+    def _lock_dbindex(self):
+        self._lockfile = LockFile(self.cache_dir)
+        try:
+            self._lockfile.acquire()
+        except:  # pylint: disable=bare-except
+            return False
+
+        return True
+
+    def _unlock_dbindex(self):
+        if self._lockfile:
+            self._lockfile.release()
+        return True
+
+
+#
+# Helpers
+#
+
+
+def cleanup_content_cache(namespace=None):
+    with ContentCache(namespace) as cc:
+        cc.clean()

platformio/clients/account.py

@@ -0,0 +1,329 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+import os
+import time
+
+from platformio import __accounts_api__, app
+from platformio.clients.http import HTTPClient
+from platformio.exception import PlatformioException
+
+
+class AccountError(PlatformioException):
+
+    MESSAGE = "{0}"
+
+
+class AccountNotAuthorized(AccountError):
+
+    MESSAGE = "You are not authorized! Please log in to PlatformIO Account."
+
+
+class AccountAlreadyAuthorized(AccountError):
+
+    MESSAGE = "You are already authorized with {0} account."
+
+
+class AccountClient(HTTPClient):  # pylint:disable=too-many-public-methods
+
+    SUMMARY_CACHE_TTL = 60 * 60 * 24 * 7
+
+    def __init__(self):
+        super(AccountClient, self).__init__(__accounts_api__)
+
+    @staticmethod
+    def get_refresh_token():
+        try:
+            return app.get_state_item("account").get("auth").get("refresh_token")
+        except:  # pylint:disable=bare-except
+            raise AccountNotAuthorized()
+
+    @staticmethod
+    def delete_local_session():
+        app.delete_state_item("account")
+
+    @staticmethod
+    def delete_local_state(key):
+        account = app.get_state_item("account")
+        if not account or key not in account:
+            return
+        del account[key]
+        app.set_state_item("account", account)
+
+    def send_auth_request(self, *args, **kwargs):
+        headers = kwargs.get("headers", {})
+        if "Authorization" not in headers:
+            token = self.fetch_authentication_token()
+            headers["Authorization"] = "Bearer %s" % token
+        kwargs["headers"] = headers
+        return self.fetch_json_data(*args, **kwargs)
+
+    def login(self, username, password):
+        try:
+            self.fetch_authentication_token()
+        except:  # pylint:disable=bare-except
+            pass
+        else:
+            raise AccountAlreadyAuthorized(
+                app.get_state_item("account", {}).get("email", "")
+            )
+
+        data = self.fetch_json_data(
+            "post",
+            "/v1/login",
+            data={"username": username, "password": password},
+        )
+        app.set_state_item("account", data)
+        return data
+
+    def login_with_code(self, client_id, code, redirect_uri):
+        try:
+            self.fetch_authentication_token()
+        except:  # pylint:disable=bare-except
+            pass
+        else:
+            raise AccountAlreadyAuthorized(
+                app.get_state_item("account", {}).get("email", "")
+            )
+
+        result = self.fetch_json_data(
+            "post",
+            "/v1/login/code",
+            data={"client_id": client_id, "code": code, "redirect_uri": redirect_uri},
+        )
+        app.set_state_item("account", result)
+        return result
+
+    def logout(self):
+        refresh_token = self.get_refresh_token()
+        self.delete_local_session()
+        try:
+            self.fetch_json_data(
+                "post",
+                "/v1/logout",
+                data={"refresh_token": refresh_token},
+            )
+        except AccountError:
+            pass
+        return True
+
+    def change_password(self, old_password, new_password):
+        return self.send_auth_request(
+            "post",
+            "/v1/password",
+            data={"old_password": old_password, "new_password": new_password},
+        )
+
+    def registration(
+        self, username, email, password, firstname, lastname
+    ):  # pylint:disable=too-many-arguments
+        try:
+            self.fetch_authentication_token()
+        except:  # pylint:disable=bare-except
+            pass
+        else:
+            raise AccountAlreadyAuthorized(
+                app.get_state_item("account", {}).get("email", "")
+            )
+
+        return self.fetch_json_data(
+            "post",
+            "/v1/registration",
+            data={
+                "username": username,
+                "email": email,
+                "password": password,
+                "firstname": firstname,
+                "lastname": lastname,
+            },
+        )
+
+    def auth_token(self, password, regenerate):
+        return self.send_auth_request(
+            "post",
+            "/v1/token",
+            data={"password": password, "regenerate": 1 if regenerate else 0},
+        ).get("auth_token")
+
+    def forgot_password(self, username):
+        return self.fetch_json_data(
+            "post",
+            "/v1/forgot",
+            data={"username": username},
+        )
+
+    def get_profile(self):
+        return self.send_auth_request(
+            "get",
+            "/v1/profile",
+        )
+
+    def update_profile(self, profile, current_password):
+        profile["current_password"] = current_password
+        self.delete_local_state("summary")
+        response = self.send_auth_request(
+            "put",
+            "/v1/profile",
+            data=profile,
+        )
+        return response
+
+    def get_account_info(self, offline=False):
+        account = app.get_state_item("account") or {}
+        if (
+            account.get("summary")
+            and account["summary"].get("expire_at", 0) > time.time()
+        ):
+            return account["summary"]
+        if offline and account.get("email"):
+            return {
+                "profile": {
+                    "email": account.get("email"),
+                    "username": account.get("username"),
+                }
+            }
+        result = self.send_auth_request(
+            "get",
+            "/v1/summary",
+        )
+        account["summary"] = dict(
+            profile=result.get("profile"),
+            packages=result.get("packages"),
+            subscriptions=result.get("subscriptions"),
+            user_id=result.get("user_id"),
+            expire_at=int(time.time()) + self.SUMMARY_CACHE_TTL,
+        )
+        app.set_state_item("account", account)
+        return result
+
+    def get_logged_username(self):
+        return self.get_account_info(offline=True).get("profile").get("username")
+
+    def destroy_account(self):
+        return self.send_auth_request("delete", "/v1/account")
+
+    def create_org(self, orgname, email, displayname):
+        return self.send_auth_request(
+            "post",
+            "/v1/orgs",
+            data={"orgname": orgname, "email": email, "displayname": displayname},
+        )
+
+    def get_org(self, orgname):
+        return self.send_auth_request("get", "/v1/orgs/%s" % orgname)
+
+    def list_orgs(self):
+        return self.send_auth_request(
+            "get",
+            "/v1/orgs",
+        )
+
+    def update_org(self, orgname, data):
+        return self.send_auth_request(
+            "put", "/v1/orgs/%s" % orgname, data={k: v for k, v in data.items() if v}
+        )
+
+    def destroy_org(self, orgname):
+        return self.send_auth_request(
+            "delete",
+            "/v1/orgs/%s" % orgname,
+        )
+
+    def add_org_owner(self, orgname, username):
+        return self.send_auth_request(
+            "post",
+            "/v1/orgs/%s/owners" % orgname,
+            data={"username": username},
+        )
+
+    def list_org_owners(self, orgname):
+        return self.send_auth_request(
+            "get",
+            "/v1/orgs/%s/owners" % orgname,
+        )
+
+    def remove_org_owner(self, orgname, username):
+        return self.send_auth_request(
+            "delete",
+            "/v1/orgs/%s/owners" % orgname,
+            data={"username": username},
+        )
+
+    def create_team(self, orgname, teamname, description):
+        return self.send_auth_request(
+            "post",
+            "/v1/orgs/%s/teams" % orgname,
+            data={"name": teamname, "description": description},
+        )
+
+    def destroy_team(self, orgname, teamname):
+        return self.send_auth_request(
+            "delete",
+            "/v1/orgs/%s/teams/%s" % (orgname, teamname),
+        )
+
+    def get_team(self, orgname, teamname):
+        return self.send_auth_request(
+            "get",
+            "/v1/orgs/%s/teams/%s" % (orgname, teamname),
+        )
+
+    def list_teams(self, orgname):
+        return self.send_auth_request(
+            "get",
+            "/v1/orgs/%s/teams" % orgname,
+        )
+
+    def update_team(self, orgname, teamname, data):
+        return self.send_auth_request(
+            "put",
+            "/v1/orgs/%s/teams/%s" % (orgname, teamname),
+            data={k: v for k, v in data.items() if v},
+        )
+
+    def add_team_member(self, orgname, teamname, username):
+        return self.send_auth_request(
+            "post",
+            "/v1/orgs/%s/teams/%s/members" % (orgname, teamname),
+            data={"username": username},
+        )
+
+    def remove_team_member(self, orgname, teamname, username):
+        return self.send_auth_request(
+            "delete",
+            "/v1/orgs/%s/teams/%s/members" % (orgname, teamname),
+            data={"username": username},
+        )
+
+    def fetch_authentication_token(self):
+        if os.environ.get("PLATFORMIO_AUTH_TOKEN"):
+            return os.environ.get("PLATFORMIO_AUTH_TOKEN")
+        auth = app.get_state_item("account", {}).get("auth", {})
+        if auth.get("access_token") and auth.get("access_token_expire"):
+            if auth.get("access_token_expire") > time.time():
+                return auth.get("access_token")
+            if auth.get("refresh_token"):
+                try:
+                    data = self.fetch_json_data(
+                        "post",
+                        "/v1/login",
+                        headers={
+                            "Authorization": "Bearer %s" % auth.get("refresh_token")
+                        },
+                    )
+                    app.set_state_item("account", data)
+                    return data.get("auth").get("access_token")
+                except AccountError:
+                    self.delete_local_session()
+        raise AccountNotAuthorized()

platformio/clients/http.py

@@ -0,0 +1,208 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+import json
+import math
+import os
+import socket
+
+import requests.adapters
+from requests.packages.urllib3.util.retry import Retry  # pylint:disable=import-error
+
+from platformio import __check_internet_hosts__, __default_requests_timeout__, app, util
+from platformio.cache import ContentCache
+from platformio.exception import PlatformioException, UserSideException
+
+try:
+    from urllib.parse import urljoin
+except ImportError:
+    from urlparse import urljoin
+
+
+class HTTPClientError(PlatformioException):
+    def __init__(self, message, response=None):
+        super(HTTPClientError, self).__init__()
+        self.message = message
+        self.response = response
+
+    def __str__(self):  # pragma: no cover
+        return self.message
+
+
+class InternetIsOffline(UserSideException):
+
+    MESSAGE = (
+        "You are not connected to the Internet.\n"
+        "PlatformIO needs the Internet connection to"
+        " download dependent packages or to work with PlatformIO Account."
+    )
+
+
+class EndpointSession(requests.Session):
+    def __init__(self, base_url, *args, **kwargs):
+        super(EndpointSession, self).__init__(*args, **kwargs)
+        self.base_url = base_url
+
+    def request(  # pylint: disable=signature-differs,arguments-differ
+        self, method, url, *args, **kwargs
+    ):
+        # print(self.base_url, method, url, args, kwargs)
+        return super(EndpointSession, self).request(
+            method, urljoin(self.base_url, url), *args, **kwargs
+        )
+
+
+class EndpointSessionIterator(object):
+    def __init__(self, endpoints):
+        if not isinstance(endpoints, list):
+            endpoints = [endpoints]
+        self.endpoints = endpoints
+        self.endpoints_iter = iter(endpoints)
+        self.retry = Retry(
+            total=math.ceil(6 / len(self.endpoints)),
+            backoff_factor=1,
+            # method_whitelist=list(Retry.DEFAULT_METHOD_WHITELIST) + ["POST"],
+            status_forcelist=[413, 429, 500, 502, 503, 504],
+        )
+
+    def __iter__(self):  # pylint: disable=non-iterator-returned
+        return self
+
+    def next(self):
+        """For Python 2 compatibility"""
+        return self.__next__()
+
+    def __next__(self):
+        base_url = next(self.endpoints_iter)
+        session = EndpointSession(base_url)
+        session.headers.update({"User-Agent": app.get_user_agent()})
+        adapter = requests.adapters.HTTPAdapter(max_retries=self.retry)
+        session.mount(base_url, adapter)
+        return session
+
+
+class HTTPClient(object):
+    def __init__(self, endpoints):
+        self._session_iter = EndpointSessionIterator(endpoints)
+        self._session = None
+        self._next_session()
+
+    def __del__(self):
+        if not self._session:
+            return
+        try:
+            self._session.close()
+        except:  # pylint: disable=bare-except
+            pass
+        self._session = None
+
+    def _next_session(self):
+        if self._session:
+            self._session.close()
+        self._session = next(self._session_iter)
+
+    @util.throttle(500)
+    def send_request(self, method, path, **kwargs):
+        # check Internet before and resolve issue with 60 seconds timeout
+        ensure_internet_on(raise_exception=True)
+
+        # set default timeout
+        if "timeout" not in kwargs:
+            kwargs["timeout"] = __default_requests_timeout__
+
+        while True:
+            try:
+                return getattr(self._session, method)(path, **kwargs)
+            except (
+                requests.exceptions.ConnectionError,
+                requests.exceptions.Timeout,
+            ) as e:
+                try:
+                    self._next_session()
+                except:  # pylint: disable=bare-except
+                    raise HTTPClientError(str(e))
+
+    def fetch_json_data(self, method, path, **kwargs):
+        cache_valid = kwargs.pop("cache_valid") if "cache_valid" in kwargs else None
+        if not cache_valid:
+            return self._parse_json_response(self.send_request(method, path, **kwargs))
+        cache_key = ContentCache.key_from_args(
+            method, path, kwargs.get("params"), kwargs.get("data")
+        )
+        with ContentCache("http") as cc:
+            result = cc.get(cache_key)
+            if result is not None:
+                return json.loads(result)
+            response = self.send_request(method, path, **kwargs)
+            data = self._parse_json_response(response)
+            cc.set(cache_key, response.text, cache_valid)
+            return data
+
+    @staticmethod
+    def _parse_json_response(response, expected_codes=(200, 201, 202)):
+        if response.status_code in expected_codes:
+            try:
+                return response.json()
+            except ValueError:
+                pass
+        try:
+            message = response.json()["message"]
+        except (KeyError, ValueError):
+            message = response.text
+        raise HTTPClientError(message, response)
+
+
+#
+# Helpers
+#
+
+
+@util.memoized(expire="10s")
+def _internet_on():
+    timeout = 2
+    socket.setdefaulttimeout(timeout)
+    for host in __check_internet_hosts__:
+        try:
+            for var in ("HTTP_PROXY", "HTTPS_PROXY"):
+                if not os.getenv(var) and not os.getenv(var.lower()):
+                    continue
+                requests.get("http://%s" % host, allow_redirects=False, timeout=timeout)
+                return True
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            s.connect((host, 80))
+            s.close()
+            return True
+        except:  # pylint: disable=bare-except
+            pass
+    return False
+
+
+def ensure_internet_on(raise_exception=False):
+    result = _internet_on()
+    if raise_exception and not result:
+        raise InternetIsOffline()
+    return result
+
+
+def fetch_remote_content(*args, **kwargs):
+    kwargs["headers"] = kwargs.get("headers", {})
+    if "User-Agent" not in kwargs["headers"]:
+        kwargs["headers"]["User-Agent"] = app.get_user_agent()
+
+    if "timeout" not in kwargs:
+        kwargs["timeout"] = __default_requests_timeout__
+
+    r = requests.get(*args, **kwargs)
+    r.raise_for_status()
+    return r.text

platformio/clients/registry.py

@@ -0,0 +1,136 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+from platformio import __registry_api__, fs
+from platformio.clients.account import AccountClient
+from platformio.clients.http import HTTPClient, HTTPClientError
+
+# pylint: disable=too-many-arguments
+
+
+class RegistryClient(HTTPClient):
+    def __init__(self):
+        super(RegistryClient, self).__init__(__registry_api__)
+
+    def send_auth_request(self, *args, **kwargs):
+        headers = kwargs.get("headers", {})
+        if "Authorization" not in headers:
+            token = AccountClient().fetch_authentication_token()
+            headers["Authorization"] = "Bearer %s" % token
+        kwargs["headers"] = headers
+        return self.fetch_json_data(*args, **kwargs)
+
+    def publish_package(  # pylint: disable=redefined-builtin
+        self, owner, type, archive_path, released_at=None, private=False, notify=True
+    ):
+        with open(archive_path, "rb") as fp:
+            return self.send_auth_request(
+                "post",
+                "/v3/packages/%s/%s" % (owner, type),
+                params={
+                    "private": 1 if private else 0,
+                    "notify": 1 if notify else 0,
+                    "released_at": released_at,
+                },
+                headers={
+                    "Content-Type": "application/octet-stream",
+                    "X-PIO-Content-SHA256": fs.calculate_file_hashsum(
+                        "sha256", archive_path
+                    ),
+                },
+                data=fp,
+            )
+
+    def unpublish_package(  # pylint: disable=redefined-builtin
+        self, owner, type, name, version=None, undo=False
+    ):
+        path = "/v3/packages/%s/%s/%s" % (owner, type, name)
+        if version:
+            path += "/" + version
+        return self.send_auth_request(
+            "delete",
+            path,
+            params={"undo": 1 if undo else 0},
+        )
+
+    def update_resource(self, urn, private):
+        return self.send_auth_request(
+            "put",
+            "/v3/resources/%s" % urn,
+            data={"private": int(private)},
+        )
+
+    def grant_access_for_resource(self, urn, client, level):
+        return self.send_auth_request(
+            "put",
+            "/v3/resources/%s/access" % urn,
+            data={"client": client, "level": level},
+        )
+
+    def revoke_access_from_resource(self, urn, client):
+        return self.send_auth_request(
+            "delete",
+            "/v3/resources/%s/access" % urn,
+            data={"client": client},
+        )
+
+    def list_resources(self, owner):
+        return self.send_auth_request(
+            "get", "/v3/resources", params={"owner": owner} if owner else None
+        )
+
+    def list_packages(self, query=None, filters=None, page=None):
+        assert query or filters
+        search_query = []
+        if filters:
+            valid_filters = (
+                "authors",
+                "keywords",
+                "frameworks",
+                "platforms",
+                "headers",
+                "ids",
+                "names",
+                "owners",
+                "types",
+            )
+            assert set(filters.keys()) <= set(valid_filters)
+            for name, values in filters.items():
+                for value in set(
+                    values if isinstance(values, (list, tuple)) else [values]
+                ):
+                    search_query.append('%s:"%s"' % (name[:-1], value))
+        if query:
+            search_query.append(query)
+        params = dict(query=" ".join(search_query))
+        if page:
+            params["page"] = int(page)
+        return self.fetch_json_data(
+            "get", "/v3/packages", params=params, cache_valid="1h"
+        )
+
+    def get_package(self, type_, owner, name, version=None):
+        try:
+            return self.fetch_json_data(
+                "get",
+                "/v3/packages/{owner}/{type}/{name}".format(
+                    type=type_, owner=owner.lower(), name=name.lower()
+                ),
+                params=dict(version=version) if version else None,
+                cache_valid="1h",
+            )
+        except HTTPClientError as e:
+            if e.response is not None and e.response.status_code == 404:
+                return None
+            raise e

platformio/commands/access.py

@@ -0,0 +1,146 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+# pylint: disable=unused-argument
+
+import json
+import re
+
+import click
+from tabulate import tabulate
+
+from platformio.clients.registry import RegistryClient
+from platformio.commands.account import validate_username
+from platformio.commands.team import validate_orgname_teamname
+
+
+def validate_client(value):
+    if ":" in value:
+        validate_orgname_teamname(value)
+    else:
+        validate_username(value)
+    return value
+
+
+@click.group("access", short_help="Manage resource access")
+def cli():
+    pass
+
+
+def validate_urn(value):
+    value = str(value).strip()
+    if not re.match(r"^prn:reg:pkg:(\d+):(\w+)$", value, flags=re.I):
+        raise click.BadParameter("Invalid URN format.")
+    return value
+
+
+@cli.command("public", short_help="Make resource public")
+@click.argument(
+    "urn",
+    callback=lambda _, __, value: validate_urn(value),
+)
+@click.option("--urn-type", type=click.Choice(["prn:reg:pkg"]), default="prn:reg:pkg")
+def access_public(urn, urn_type):
+    client = RegistryClient()
+    client.update_resource(urn=urn, private=0)
+    return click.secho(
+        "The resource %s has been successfully updated." % urn,
+        fg="green",
+    )
+
+
+@cli.command("private", short_help="Make resource private")
+@click.argument(
+    "urn",
+    callback=lambda _, __, value: validate_urn(value),
+)
+@click.option("--urn-type", type=click.Choice(["prn:reg:pkg"]), default="prn:reg:pkg")
+def access_private(urn, urn_type):
+    client = RegistryClient()
+    client.update_resource(urn=urn, private=1)
+    return click.secho(
+        "The resource %s has been successfully updated." % urn,
+        fg="green",
+    )
+
+
+@cli.command("grant", short_help="Grant access")
+@click.argument("level", type=click.Choice(["admin", "maintainer", "guest"]))
+@click.argument(
+    "client",
+    metavar="[<ORGNAME:TEAMNAME>|<USERNAME>]",
+    callback=lambda _, __, value: validate_client(value),
+)
+@click.argument(
+    "urn",
+    callback=lambda _, __, value: validate_urn(value),
+)
+@click.option("--urn-type", type=click.Choice(["prn:reg:pkg"]), default="prn:reg:pkg")
+def access_grant(level, client, urn, urn_type):
+    reg_client = RegistryClient()
+    reg_client.grant_access_for_resource(urn=urn, client=client, level=level)
+    return click.secho(
+        "Access for resource %s has been granted for %s" % (urn, client),
+        fg="green",
+    )
+
+
+@cli.command("revoke", short_help="Revoke access")
+@click.argument(
+    "client",
+    metavar="[ORGNAME:TEAMNAME|USERNAME]",
+    callback=lambda _, __, value: validate_client(value),
+)
+@click.argument(
+    "urn",
+    callback=lambda _, __, value: validate_urn(value),
+)
+@click.option("--urn-type", type=click.Choice(["prn:reg:pkg"]), default="prn:reg:pkg")
+def access_revoke(client, urn, urn_type):
+    reg_client = RegistryClient()
+    reg_client.revoke_access_from_resource(urn=urn, client=client)
+    return click.secho(
+        "Access for resource %s has been revoked for %s" % (urn, client),
+        fg="green",
+    )
+
+
+@cli.command("list", short_help="List published resources")
+@click.argument("owner", required=False)
+@click.option("--urn-type", type=click.Choice(["prn:reg:pkg"]), default="prn:reg:pkg")
+@click.option("--json-output", is_flag=True)
+def access_list(owner, urn_type, json_output):
+    reg_client = RegistryClient()
+    resources = reg_client.list_resources(owner=owner)
+    if json_output:
+        return click.echo(json.dumps(resources))
+    if not resources:
+        return click.secho("You do not have any resources.", fg="yellow")
+    for resource in resources:
+        click.echo()
+        click.secho(resource.get("name"), fg="cyan")
+        click.echo("-" * len(resource.get("name")))
+        table_data = []
+        table_data.append(("URN:", resource.get("urn")))
+        table_data.append(("Owner:", resource.get("owner")))
+        table_data.append(
+            (
+                "Access level(s):",
+                ", ".join(
+                    (level.capitalize() for level in resource.get("access_levels"))
+                ),
+            )
+        )
+        click.echo(tabulate(table_data, tablefmt="plain"))
+    return click.echo()

platformio/commands/account.py

@@ -21,22 +21,23 @@ import re
 import click
 from tabulate import tabulate
 
-from platformio.commands.account import exception
-from platformio.commands.account.client import AccountClient
+from platformio.clients.account import AccountClient, AccountNotAuthorized
 
 
-@click.group("account", short_help="Manage PIO Account")
+@click.group("account", short_help="Manage PlatformIO account")
 def cli():
     pass
 
 
-def validate_username(value):
+def validate_username(value, field="username"):
     value = str(value).strip()
-    if not re.match(r"^[a-z\d](?:[a-z\d]|-(?=[a-z\d])){3,38}$", value, flags=re.I):
+    if not re.match(r"^[a-z\d](?:[a-z\d]|-(?=[a-z\d])){0,37}$", value, flags=re.I):
         raise click.BadParameter(
-            "Invalid username format. "
-            "Username must contain at least 4 characters including single hyphens,"
-            " and cannot begin or end with a hyphen"
+            "Invalid %s format. "
+            "%s must contain only alphanumeric characters "
+            "or single hyphens, cannot begin or end with a hyphen, "
+            "and must not be longer than 38 characters."
+            % (field.lower(), field.capitalize())
         )
     return value
 
@@ -59,7 +60,7 @@ def validate_password(value):
     return value
 
 
-@cli.command("register", short_help="Create new PIO Account")
+@cli.command("register", short_help="Create new PlatformIO Account")
 @click.option(
     "-u",
     "--username",
@@ -89,7 +90,7 @@ def account_register(username, email, password, firstname, lastname):
     )
 
 
-@cli.command("login", short_help="Log in to PIO Account")
+@cli.command("login", short_help="Log in to PlatformIO Account")
 @click.option("-u", "--username", prompt="Username or email")
 @click.option("-p", "--password", prompt=True, hide_input=True)
 def account_login(username, password):
@@ -98,7 +99,7 @@ def account_login(username, password):
     return click.secho("Successfully logged in!", fg="green")
 
 
-@cli.command("logout", short_help="Log out of PIO Account")
+@cli.command("logout", short_help="Log out of PlatformIO Account")
 def account_logout():
     client = AccountClient()
     client.logout()
@@ -167,7 +168,7 @@ def account_update(current_password, **kwargs):
         return None
     try:
         client.logout()
-    except exception.AccountNotAuthenticated:
+    except AccountNotAuthorized:
         pass
     if email_changed:
         return click.secho(
@@ -177,7 +178,27 @@ def account_update(current_password, **kwargs):
     return click.secho("Please re-login.", fg="yellow")
 
 
-@cli.command("show", short_help="PIO Account information")
+@cli.command("destroy", short_help="Destroy account")
+def account_destroy():
+    client = AccountClient()
+    click.confirm(
+        "Are you sure you want to delete the %s user account?\n"
+        "Warning! All linked data will be permanently removed and can not be restored."
+        % client.get_logged_username(),
+        abort=True,
+    )
+    client.destroy_account()
+    try:
+        client.logout()
+    except AccountNotAuthorized:
+        pass
+    return click.secho(
+        "User account has been destroyed.",
+        fg="green",
+    )
+
+
+@cli.command("show", short_help="PlatformIO Account information")
 @click.option("--offline", is_flag=True)
 @click.option("--json-output", is_flag=True)
 def account_show(offline, json_output):

platformio/commands/account/client.py

@@ -1,235 +0,0 @@
-# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
-#
-# 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.
-
-# pylint: disable=unused-argument
-
-import os
-import time
-
-import requests.adapters
-from requests.packages.urllib3.util.retry import Retry  # pylint:disable=import-error
-
-from platformio import __pioaccount_api__, app
-from platformio.commands.account import exception
-
-
-class AccountClient(object):
-    def __init__(
-        self, api_base_url=__pioaccount_api__, retries=3,
-    ):
-        if api_base_url.endswith("/"):
-            api_base_url = api_base_url[:-1]
-        self.api_base_url = api_base_url
-        self._session = requests.Session()
-        self._session.headers.update({"User-Agent": app.get_user_agent()})
-        retry = Retry(
-            total=retries,
-            read=retries,
-            connect=retries,
-            backoff_factor=2,
-            method_whitelist=list(Retry.DEFAULT_METHOD_WHITELIST) + ["POST"],
-        )
-        adapter = requests.adapters.HTTPAdapter(max_retries=retry)
-        self._session.mount(api_base_url, adapter)
-
-    def login(self, username, password):
-        try:
-            self.fetch_authentication_token()
-        except:  # pylint:disable=bare-except
-            pass
-        else:
-            raise exception.AccountAlreadyAuthenticated(
-                app.get_state_item("account", {}).get("email", "")
-            )
-
-        response = self._session.post(
-            self.api_base_url + "/v1/login",
-            data={"username": username, "password": password},
-        )
-        result = self.raise_error_from_response(response)
-        app.set_state_item("account", result)
-        return result
-
-    def login_with_code(self, client_id, code, redirect_uri):
-        try:
-            self.fetch_authentication_token()
-        except:  # pylint:disable=bare-except
-            pass
-        else:
-            raise exception.AccountAlreadyAuthenticated(
-                app.get_state_item("account", {}).get("email", "")
-            )
-
-        response = self._session.post(
-            self.api_base_url + "/v1/login/code",
-            data={"client_id": client_id, "code": code, "redirect_uri": redirect_uri},
-        )
-        result = self.raise_error_from_response(response)
-        app.set_state_item("account", result)
-        return result
-
-    def logout(self):
-        try:
-            refresh_token = self.get_refresh_token()
-        except:  # pylint:disable=bare-except
-            raise exception.AccountNotAuthenticated()
-        response = requests.post(
-            self.api_base_url + "/v1/logout", data={"refresh_token": refresh_token},
-        )
-        try:
-            self.raise_error_from_response(response)
-        except exception.AccountError:
-            pass
-        app.delete_state_item("account")
-        return True
-
-    def change_password(self, old_password, new_password):
-        try:
-            token = self.fetch_authentication_token()
-        except:  # pylint:disable=bare-except
-            raise exception.AccountNotAuthenticated()
-        response = self._session.post(
-            self.api_base_url + "/v1/password",
-            headers={"Authorization": "Bearer %s" % token},
-            data={"old_password": old_password, "new_password": new_password},
-        )
-        self.raise_error_from_response(response)
-        return True
-
-    def registration(
-        self, username, email, password, firstname, lastname
-    ):  # pylint:disable=too-many-arguments
-        try:
-            self.fetch_authentication_token()
-        except:  # pylint:disable=bare-except
-            pass
-        else:
-            raise exception.AccountAlreadyAuthenticated(
-                app.get_state_item("account", {}).get("email", "")
-            )
-
-        response = self._session.post(
-            self.api_base_url + "/v1/registration",
-            data={
-                "username": username,
-                "email": email,
-                "password": password,
-                "firstname": firstname,
-                "lastname": lastname,
-            },
-        )
-        return self.raise_error_from_response(response)
-
-    def auth_token(self, password, regenerate):
-        try:
-            token = self.fetch_authentication_token()
-        except:  # pylint:disable=bare-except
-            raise exception.AccountNotAuthenticated()
-        response = self._session.post(
-            self.api_base_url + "/v1/token",
-            headers={"Authorization": "Bearer %s" % token},
-            data={"password": password, "regenerate": 1 if regenerate else 0},
-        )
-        return self.raise_error_from_response(response).get("auth_token")
-
-    def forgot_password(self, username):
-        response = self._session.post(
-            self.api_base_url + "/v1/forgot", data={"username": username},
-        )
-        return self.raise_error_from_response(response).get("auth_token")
-
-    def get_profile(self):
-        try:
-            token = self.fetch_authentication_token()
-        except:  # pylint:disable=bare-except
-            raise exception.AccountNotAuthenticated()
-        response = self._session.get(
-            self.api_base_url + "/v1/profile",
-            headers={"Authorization": "Bearer %s" % token},
-        )
-        return self.raise_error_from_response(response)
-
-    def update_profile(self, profile, current_password):
-        try:
-            token = self.fetch_authentication_token()
-        except:  # pylint:disable=bare-except
-            raise exception.AccountNotAuthenticated()
-        profile["current_password"] = current_password
-        response = self._session.put(
-            self.api_base_url + "/v1/profile",
-            headers={"Authorization": "Bearer %s" % token},
-            data=profile,
-        )
-        return self.raise_error_from_response(response)
-
-    def get_account_info(self, offline):
-        if offline:
-            account = app.get_state_item("account")
-            if not account:
-                raise exception.AccountNotAuthenticated()
-            return {
-                "profile": {
-                    "email": account.get("email"),
-                    "username": account.get("username"),
-                }
-            }
-        try:
-            token = self.fetch_authentication_token()
-        except:  # pylint:disable=bare-except
-            raise exception.AccountNotAuthenticated()
-        response = self._session.get(
-            self.api_base_url + "/v1/summary",
-            headers={"Authorization": "Bearer %s" % token},
-        )
-        return self.raise_error_from_response(response)
-
-    def fetch_authentication_token(self):
-        if "PLATFORMIO_AUTH_TOKEN" in os.environ:
-            return os.environ["PLATFORMIO_AUTH_TOKEN"]
-        auth = app.get_state_item("account", {}).get("auth", {})
-        if auth.get("access_token") and auth.get("access_token_expire"):
-            if auth.get("access_token_expire") > time.time():
-                return auth.get("access_token")
-            if auth.get("refresh_token"):
-                response = self._session.post(
-                    self.api_base_url + "/v1/login",
-                    headers={"Authorization": "Bearer %s" % auth.get("refresh_token")},
-                )
-                result = self.raise_error_from_response(response)
-                app.set_state_item("account", result)
-                return result.get("auth").get("access_token")
-        raise exception.AccountNotAuthenticated()
-
-    @staticmethod
-    def get_refresh_token():
-        try:
-            auth = app.get_state_item("account").get("auth").get("refresh_token")
-            return auth
-        except:  # pylint:disable=bare-except
-            raise exception.AccountNotAuthenticated()
-
-    @staticmethod
-    def raise_error_from_response(response, expected_codes=(200, 201, 202)):
-        if response.status_code in expected_codes:
-            try:
-                return response.json()
-            except ValueError:
-                pass
-        try:
-            message = response.json()["message"]
-        except (KeyError, ValueError):
-            message = response.text
-        if "Authorization session has been expired" in message:
-            app.delete_state_item("account")
-        raise exception.AccountError(message)

platformio/commands/boards.py

@@ -13,16 +13,16 @@
 # limitations under the License.
 
 import json
+import shutil
 
 import click
 from tabulate import tabulate
 
 from platformio import fs
-from platformio.compat import dump_json_to_unicode
-from platformio.managers.platform import PlatformManager
+from platformio.package.manager.platform import PlatformPackageManager
 
 
-@click.command("boards", short_help="Embedded Board Explorer")
+@click.command("boards", short_help="Embedded board explorer")
 @click.argument("query", required=False)
 @click.option("--installed", is_flag=True)
 @click.option("--json-output", is_flag=True)
@@ -41,7 +41,7 @@ def cli(query, installed, json_output):  # pylint: disable=R0912
             grpboards[board["platform"]] = []
         grpboards[board["platform"]].append(board)
 
-    terminal_width, _ = click.get_terminal_size()
+    terminal_width, _ = shutil.get_terminal_size()
     for (platform, boards) in sorted(grpboards.items()):
         click.echo("")
         click.echo("Platform: ", nl=False)
@@ -59,8 +59,8 @@ def print_boards(boards):
                     click.style(b["id"], fg="cyan"),
                     b["mcu"],
                     "%dMHz" % (b["fcpu"] / 1000000),
-                    fs.format_filesize(b["rom"]),
-                    fs.format_filesize(b["ram"]),
+                    fs.humanize_file_size(b["rom"]),
+                    fs.humanize_file_size(b["ram"]),
                     b["name"],
                 )
                 for b in boards
@@ -71,7 +71,7 @@ def print_boards(boards):
 
 
 def _get_boards(installed=False):
-    pm = PlatformManager()
+    pm = PlatformPackageManager()
     return pm.get_installed_boards() if installed else pm.get_all_boards()
 
 
@@ -83,4 +83,4 @@ def _print_boards_json(query, installed=False):
             if query.lower() not in search_data.lower():
                 continue
         result.append(board)
-    click.echo(dump_json_to_unicode(result))
+    click.echo(json.dumps(result))

platformio/commands/check/command.py

@@ -15,7 +15,9 @@
 # pylint: disable=too-many-arguments,too-many-locals,too-many-branches
 # pylint: disable=redefined-builtin,too-many-statements
 
+import json
 import os
+import shutil
 from collections import Counter
 from os.path import dirname, isfile
 from time import time
@@ -26,12 +28,11 @@ from tabulate import tabulate
 from platformio import app, exception, fs, util
 from platformio.commands.check.defect import DefectItem
 from platformio.commands.check.tools import CheckToolFactory
-from platformio.compat import dump_json_to_unicode
 from platformio.project.config import ProjectConfig
 from platformio.project.helpers import find_project_dir_above, get_project_dir
 
 
-@click.command("check", short_help="Run a static analysis tool on code")
+@click.command("check", short_help="Static code analysis")
 @click.option("-e", "--environment", multiple=True)
 @click.option(
     "-d",
@@ -163,7 +164,7 @@ def cli(
                     print_processing_footer(result)
 
         if json_output:
-            click.echo(dump_json_to_unicode(results_to_json(results)))
+            click.echo(json.dumps(results_to_json(results)))
         elif not silent:
             print_check_summary(results)
 
@@ -193,7 +194,7 @@ def print_processing_header(tool, envname, envdump):
         "Checking %s > %s (%s)"
         % (click.style(envname, fg="cyan", bold=True), tool, "; ".join(envdump))
     )
-    terminal_width, _ = click.get_terminal_size()
+    terminal_width, _ = shutil.get_terminal_size()
     click.secho("-" * terminal_width, bold=True)
 
 
@@ -214,7 +215,7 @@ def print_processing_footer(result):
 
 
 def collect_component_stats(result):
-    components = dict()
+    components = {}
 
     def _append_defect(component, defect):
         if not components.get(component):
@@ -249,7 +250,7 @@ def print_defects_stats(results):
 
     severity_labels = list(DefectItem.SEVERITY_LABELS.values())
     severity_labels.reverse()
-    tabular_data = list()
+    tabular_data = []
     for k, v in component_stats.items():
         tool_defect = [v.get(s, 0) for s in severity_labels]
         tabular_data.append([k] + tool_defect)

platformio/commands/check/tools/base.py

@@ -14,7 +14,7 @@
 
 import glob
 import os
-from tempfile import NamedTemporaryFile
+import tempfile
 
 import click
 
@@ -84,7 +84,9 @@ class CheckToolBase(object):  # pylint: disable=too-many-instance-attributes
             cmd = "echo | %s -x %s %s %s -dM -E -" % (
                 self.cc_path,
                 language,
-                " ".join([f for f in build_flags if f.startswith(("-m", "-f"))]),
+                " ".join(
+                    [f for f in build_flags if f.startswith(("-m", "-f", "-std"))]
+                ),
                 includes_file,
             )
             result = proc.exec_command(cmd, shell=True)
@@ -103,7 +105,7 @@ class CheckToolBase(object):  # pylint: disable=too-many-instance-attributes
         return {lang: _extract_defines(lang, incflags_file) for lang in ("c", "c++")}
 
     def _create_tmp_file(self, data):
-        with NamedTemporaryFile("w", delete=False) as fp:
+        with tempfile.NamedTemporaryFile("w", delete=False) as fp:
             fp.write(data)
             self._tmp_files.append(fp.name)
             return fp.name
@@ -166,6 +168,29 @@ class CheckToolBase(object):  # pylint: disable=too-many-instance-attributes
             if os.path.isfile(f):
                 os.remove(f)
 
+    @staticmethod
+    def is_check_successful(cmd_result):
+        return cmd_result["returncode"] == 0
+
+    def execute_check_cmd(self, cmd):
+        result = proc.exec_command(
+            cmd,
+            stdout=proc.LineBufferedAsyncPipe(self.on_tool_output),
+            stderr=proc.LineBufferedAsyncPipe(self.on_tool_output),
+        )
+
+        if not self.is_check_successful(result):
+            click.echo(
+                "\nError: Failed to execute check command! Exited with code %d."
+                % result["returncode"]
+            )
+            if self.options.get("verbose"):
+                click.echo(result["out"])
+                click.echo(result["err"])
+            self._bad_input = True
+
+        return result
+
     @staticmethod
     def get_project_target_files(patterns):
         c_extension = (".c",)
@@ -183,7 +208,7 @@ class CheckToolBase(object):  # pylint: disable=too-many-instance-attributes
                 result["c++"].append(os.path.realpath(path))
 
         for pattern in patterns:
-            for item in glob.glob(pattern):
+            for item in glob.glob(pattern, recursive=True):
                 if not os.path.isdir(item):
                     _add_file(item)
                 for root, _, files in os.walk(item, followlinks=True):
@@ -199,11 +224,7 @@ class CheckToolBase(object):  # pylint: disable=too-many-instance-attributes
             if self.options.get("verbose"):
                 click.echo(" ".join(cmd))
 
-            proc.exec_command(
-                cmd,
-                stdout=proc.LineBufferedAsyncPipe(self.on_tool_output),
-                stderr=proc.LineBufferedAsyncPipe(self.on_tool_output),
-            )
+            self.execute_check_cmd(cmd)
 
         else:
             if self.options.get("verbose"):

platformio/commands/check/tools/clangtidy.py

@@ -17,7 +17,7 @@ from os.path import join
 
 from platformio.commands.check.defect import DefectItem
 from platformio.commands.check.tools.base import CheckToolBase
-from platformio.managers.core import get_core_package_dir
+from platformio.package.manager.core import get_core_package_dir
 
 
 class ClangtidyCheckTool(CheckToolBase):
@@ -49,6 +49,12 @@ class ClangtidyCheckTool(CheckToolBase):
 
         return DefectItem(severity, category, message, file_, line, column, defect_id)
 
+    @staticmethod
+    def is_check_successful(cmd_result):
+        # Note: Clang-Tidy returns 1 for not critical compilation errors,
+        # so 0 and 1 are only acceptable values
+        return cmd_result["returncode"] < 2
+
     def configure_command(self):
         tool_path = join(get_core_package_dir("tool-clangtidy"), "clang-tidy")
 
@@ -63,10 +69,7 @@ class ClangtidyCheckTool(CheckToolBase):
         for scope in project_files:
             src_files.extend(project_files[scope])
 
-        cmd.extend(flags)
-        cmd.extend(src_files)
-        cmd.append("--")
-
+        cmd.extend(flags + src_files + ["--"])
         cmd.extend(
             ["-D%s" % d for d in self.cpp_defines + self.toolchain_defines["c++"]]
         )
@@ -79,6 +82,6 @@ class ClangtidyCheckTool(CheckToolBase):
                 continue
             includes.append(inc)
 
-        cmd.append("--extra-arg=" + self._long_includes_hook(includes))
+        cmd.extend(["-I%s" % inc for inc in includes])
 
         return cmd

platformio/commands/check/tools/cppcheck.py

@@ -19,11 +19,13 @@ import click
 from platformio import proc
 from platformio.commands.check.defect import DefectItem
 from platformio.commands.check.tools.base import CheckToolBase
-from platformio.managers.core import get_core_package_dir
+from platformio.package.manager.core import get_core_package_dir
 
 
 class CppcheckCheckTool(CheckToolBase):
     def __init__(self, *args, **kwargs):
+        self._field_delimiter = "<&PIO&>"
+        self._buffer = ""
         self.defect_fields = [
             "severity",
             "message",
@@ -55,13 +57,15 @@ class CppcheckCheckTool(CheckToolBase):
         return line
 
     def parse_defect(self, raw_line):
-        if "<&PIO&>" not in raw_line or any(
-            f not in raw_line for f in self.defect_fields
-        ):
+        if self._field_delimiter not in raw_line:
             return None
 
-        args = dict()
-        for field in raw_line.split("<&PIO&>"):
+        self._buffer += raw_line
+        if any(f not in self._buffer for f in self.defect_fields):
+            return None
+
+        args = {}
+        for field in self._buffer.split(self._field_delimiter):
             field = field.strip().replace('"', "")
             name, value = field.split("=", 1)
             args[name] = value
@@ -92,24 +96,27 @@ class CppcheckCheckTool(CheckToolBase):
                     )
                     click.echo()
                 self._bad_input = True
+                self._buffer = ""
             return None
 
+        self._buffer = ""
         return DefectItem(**args)
 
-    def configure_command(
-        self, language, src_files
-    ):  # pylint: disable=arguments-differ
+    def configure_command(self, language, src_file):  # pylint: disable=arguments-differ
         tool_path = os.path.join(get_core_package_dir("tool-cppcheck"), "cppcheck")
 
         cmd = [
             tool_path,
-            "--error-exitcode=1",
+            "--addon-python=%s" % proc.get_pythonexe_path(),
+            "--error-exitcode=3",
             "--verbose" if self.options.get("verbose") else "--quiet",
         ]
 
         cmd.append(
             '--template="%s"'
-            % "<&PIO&>".join(["{0}={{{0}}}".format(f) for f in self.defect_fields])
+            % self._field_delimiter.join(
+                ["{0}={{{0}}}".format(f) for f in self.defect_fields]
+            )
         )
 
         flags = self.get_flags("cppcheck")
@@ -134,10 +141,11 @@ class CppcheckCheckTool(CheckToolBase):
 
         build_flags = self.cxx_flags if language == "c++" else self.cc_flags
 
-        for flag in build_flags:
-            if "-std" in flag:
-                # Standards with GNU extensions are not allowed
-                cmd.append("-" + flag.replace("gnu", "c"))
+        if not self.is_flag_set("--std", flags):
+            # Try to guess the standard version from the build flags
+            for flag in build_flags:
+                if "-std" in flag:
+                    cmd.append("-" + self.convert_language_standard(flag))
 
         cmd.extend(
             ["-D%s" % d for d in self.cpp_defines + self.toolchain_defines[language]]
@@ -149,8 +157,8 @@ class CppcheckCheckTool(CheckToolBase):
             "--include=" + inc
             for inc in self.get_forced_includes(build_flags, self.cpp_includes)
         )
-        cmd.append("--file-list=%s" % self._generate_src_file(src_files))
         cmd.append("--includes-file=%s" % self._generate_inc_file())
+        cmd.append('"%s"' % src_file)
 
         return cmd
 
@@ -212,29 +220,47 @@ class CppcheckCheckTool(CheckToolBase):
                 if os.path.isfile(dump_file):
                     os.remove(dump_file)
 
+    @staticmethod
+    def is_check_successful(cmd_result):
+        # Cppcheck is configured to return '3' if a defect is found
+        return cmd_result["returncode"] in (0, 3)
+
+    @staticmethod
+    def convert_language_standard(flag):
+        cpp_standards_map = {
+            "0x": "11",
+            "1y": "14",
+            "1z": "17",
+            "2a": "20",
+        }
+
+        standard = flag[-2:]
+        # Note: GNU extensions are not supported and converted to regular standards
+        return flag.replace("gnu", "c").replace(
+            standard, cpp_standards_map.get(standard, standard)
+        )
+
     def check(self, on_defect_callback=None):
         self._on_defect_callback = on_defect_callback
-        project_files = self.get_project_target_files(self.options["patterns"])
 
-        languages = ("c", "c++")
-        if not any([project_files[t] for t in languages]):
+        project_files = self.get_project_target_files(self.options["patterns"])
+        src_files_scope = ("c", "c++")
+        if not any(project_files[t] for t in src_files_scope):
             click.echo("Error: Nothing to check.")
             return True
-        for language in languages:
-            if not project_files[language]:
-                continue
-            cmd = self.configure_command(language, project_files[language])
-            if not cmd:
-                self._bad_input = True
-                continue
-            if self.options.get("verbose"):
-                click.echo(" ".join(cmd))
 
-            proc.exec_command(
-                cmd,
-                stdout=proc.LineBufferedAsyncPipe(self.on_tool_output),
-                stderr=proc.LineBufferedAsyncPipe(self.on_tool_output),
-            )
+        for scope, files in project_files.items():
+            if scope not in src_files_scope:
+                continue
+            for src_file in files:
+                cmd = self.configure_command(scope, src_file)
+                if not cmd:
+                    self._bad_input = True
+                    continue
+                if self.options.get("verbose"):
+                    click.echo(" ".join(cmd))
+
+                self.execute_check_cmd(cmd)
 
         self.clean_up()
 

platformio/commands/check/tools/pvsstudio.py

@@ -19,10 +19,11 @@ from xml.etree.ElementTree import fromstring
 
 import click
 
-from platformio import proc, util
+from platformio import proc
 from platformio.commands.check.defect import DefectItem
 from platformio.commands.check.tools.base import CheckToolBase
-from platformio.managers.core import get_core_package_dir
+from platformio.compat import IS_WINDOWS
+from platformio.package.manager.core import get_core_package_dir
 
 
 class PvsStudioCheckTool(CheckToolBase):  # pylint: disable=too-many-instance-attributes
@@ -34,24 +35,29 @@ class PvsStudioCheckTool(CheckToolBase):  # pylint: disable=too-many-instance-at
         self._tmp_cmd_file = self._generate_tmp_file_path() + ".cmd"
         self.tool_path = os.path.join(
             get_core_package_dir("tool-pvs-studio"),
-            "x64" if "windows" in util.get_systype() else "bin",
+            "x64" if IS_WINDOWS else "bin",
             "pvs-studio",
         )
         super(PvsStudioCheckTool, self).__init__(*args, **kwargs)
 
-        with open(self._tmp_cfg_file, "w") as fp:
+        with open(self._tmp_cfg_file, mode="w", encoding="utf8") as fp:
             fp.write(
                 "exclude-path = "
                 + self.config.get_optional_dir("packages").replace("\\", "/")
             )
 
-        with open(self._tmp_cmd_file, "w") as fp:
+        with open(self._tmp_cmd_file, mode="w", encoding="utf8") as fp:
             fp.write(
                 " ".join(
                     ['-I"%s"' % inc.replace("\\", "/") for inc in self.cpp_includes]
                 )
             )
 
+    def tool_output_filter(self, line):
+        if "license was not entered" in line.lower():
+            self._bad_input = True
+        return line
+
     def _process_defects(self, defects):
         for defect in defects:
             if not isinstance(defect, DefectItem):
@@ -65,9 +71,7 @@ class PvsStudioCheckTool(CheckToolBase):  # pylint: disable=too-many-instance-at
     def _demangle_report(self, output_file):
         converter_tool = os.path.join(
             get_core_package_dir("tool-pvs-studio"),
-            "HtmlGenerator"
-            if "windows" in util.get_systype()
-            else os.path.join("bin", "plog-converter"),
+            "HtmlGenerator" if IS_WINDOWS else os.path.join("bin", "plog-converter"),
         )
 
         cmd = (
@@ -182,7 +186,13 @@ class PvsStudioCheckTool(CheckToolBase):  # pylint: disable=too-many-instance-at
             flags = self.cc_flags
             compiler = self.cc_path
 
-        cmd = [compiler, src_file, "-E", "-o", self._tmp_preprocessed_file]
+        cmd = [
+            compiler,
+            '"%s"' % src_file,
+            "-E",
+            "-o",
+            '"%s"' % self._tmp_preprocessed_file,
+        ]
         cmd.extend([f for f in flags if f])
         cmd.extend(["-D%s" % d for d in self.cpp_defines])
         cmd.append('@"%s"' % self._tmp_cmd_file)
@@ -203,6 +213,12 @@ class PvsStudioCheckTool(CheckToolBase):  # pylint: disable=too-many-instance-at
         if os.path.isdir(self._tmp_dir):
             shutil.rmtree(self._tmp_dir)
 
+    @staticmethod
+    def is_check_successful(cmd_result):
+        return (
+            "license" not in cmd_result["err"].lower() and cmd_result["returncode"] == 0
+        )
+
     def check(self, on_defect_callback=None):
         self._on_defect_callback = on_defect_callback
         for scope, files in self.get_project_target_files(
@@ -219,11 +235,8 @@ class PvsStudioCheckTool(CheckToolBase):  # pylint: disable=too-many-instance-at
                     self._bad_input = True
                     continue
 
-                result = proc.exec_command(cmd)
-                # pylint: disable=unsupported-membership-test
-                if result["returncode"] != 0 or "license" in result["err"].lower():
-                    self._bad_input = True
-                    click.echo(result["err"])
+                result = self.execute_check_cmd(cmd)
+                if result["returncode"] != 0:
                     continue
 
                 self._process_defects(self.parse_defects(self._tmp_output_file))

platformio/commands/ci.py

@@ -12,11 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from glob import glob
-from os import getenv, makedirs, remove
-from os.path import basename, isdir, isfile, join, realpath
-from shutil import copyfile, copytree
-from tempfile import mkdtemp
+import glob
+import os
+import shutil
+import tempfile
 
 import click
 
@@ -24,7 +23,6 @@ from platformio import app, fs
 from platformio.commands.project import project_init as cmd_project_init
 from platformio.commands.project import validate_boards
 from platformio.commands.run.command import cli as cmd_run
-from platformio.compat import glob_escape
 from platformio.exception import CIBuildEnvsEmpty
 from platformio.project.config import ProjectConfig
 
@@ -35,8 +33,8 @@ def validate_path(ctx, param, value):  # pylint: disable=unused-argument
     for i, p in enumerate(value):
         if p.startswith("~"):
             value[i] = fs.expanduser(p)
-        value[i] = realpath(value[i])
-        if not glob(value[i]):
+        value[i] = os.path.realpath(value[i])
+        if not glob.glob(value[i], recursive=True):
             invalid_path = p
             break
     try:
@@ -46,14 +44,14 @@ def validate_path(ctx, param, value):  # pylint: disable=unused-argument
         raise click.BadParameter("Found invalid path: %s" % invalid_path)
 
 
-@click.command("ci", short_help="Continuous Integration")
+@click.command("ci", short_help="Continuous integration")
 @click.argument("src", nargs=-1, callback=validate_path)
 @click.option("-l", "--lib", multiple=True, callback=validate_path, metavar="DIRECTORY")
 @click.option("--exclude", multiple=True)
 @click.option("-b", "--board", multiple=True, metavar="ID", callback=validate_boards)
 @click.option(
     "--build-dir",
-    default=mkdtemp,
+    default=tempfile.mkdtemp,
     type=click.Path(file_okay=False, dir_okay=True, writable=True, resolve_path=True),
 )
 @click.option("--keep-build-dir", is_flag=True)
@@ -80,28 +78,28 @@ def cli(  # pylint: disable=too-many-arguments, too-many-branches
     verbose,
 ):
 
-    if not src and getenv("PLATFORMIO_CI_SRC"):
-        src = validate_path(ctx, None, getenv("PLATFORMIO_CI_SRC").split(":"))
+    if not src and os.getenv("PLATFORMIO_CI_SRC"):
+        src = validate_path(ctx, None, os.getenv("PLATFORMIO_CI_SRC").split(":"))
     if not src:
         raise click.BadParameter("Missing argument 'src'")
 
     try:
         app.set_session_var("force_option", True)
 
-        if not keep_build_dir and isdir(build_dir):
+        if not keep_build_dir and os.path.isdir(build_dir):
             fs.rmtree(build_dir)
-        if not isdir(build_dir):
-            makedirs(build_dir)
+        if not os.path.isdir(build_dir):
+            os.makedirs(build_dir)
 
         for dir_name, patterns in dict(lib=lib, src=src).items():
             if not patterns:
                 continue
             contents = []
             for p in patterns:
-                contents += glob(p)
-            _copy_contents(join(build_dir, dir_name), contents)
+                contents += glob.glob(p, recursive=True)
+            _copy_contents(os.path.join(build_dir, dir_name), contents)
 
-        if project_conf and isfile(project_conf):
+        if project_conf and os.path.isfile(project_conf):
             _copy_project_conf(build_dir, project_conf)
         elif not board:
             raise CIBuildEnvsEmpty()
@@ -124,52 +122,55 @@ def cli(  # pylint: disable=too-many-arguments, too-many-branches
             fs.rmtree(build_dir)
 
 
-def _copy_contents(dst_dir, contents):
+def _copy_contents(dst_dir, contents):  # pylint: disable=too-many-branches
     items = {"dirs": set(), "files": set()}
 
     for path in contents:
-        if isdir(path):
+        if os.path.isdir(path):
             items["dirs"].add(path)
-        elif isfile(path):
+        elif os.path.isfile(path):
             items["files"].add(path)
 
-    dst_dir_name = basename(dst_dir)
+    dst_dir_name = os.path.basename(dst_dir)
 
     if dst_dir_name == "src" and len(items["dirs"]) == 1:
-        copytree(list(items["dirs"]).pop(), dst_dir, symlinks=True)
+        if not os.path.isdir(dst_dir):
+            shutil.copytree(list(items["dirs"]).pop(), dst_dir, symlinks=True)
     else:
-        if not isdir(dst_dir):
-            makedirs(dst_dir)
+        if not os.path.isdir(dst_dir):
+            os.makedirs(dst_dir)
         for d in items["dirs"]:
-            copytree(d, join(dst_dir, basename(d)), symlinks=True)
+            src_dst_dir = os.path.join(dst_dir, os.path.basename(d))
+            if not os.path.isdir(src_dst_dir):
+                shutil.copytree(d, src_dst_dir, symlinks=True)
 
     if not items["files"]:
         return
 
     if dst_dir_name == "lib":
-        dst_dir = join(dst_dir, mkdtemp(dir=dst_dir))
+        dst_dir = os.path.join(dst_dir, tempfile.mkdtemp(dir=dst_dir))
 
     for f in items["files"]:
-        dst_file = join(dst_dir, basename(f))
+        dst_file = os.path.join(dst_dir, os.path.basename(f))
         if f == dst_file:
             continue
-        copyfile(f, dst_file)
+        shutil.copyfile(f, dst_file)
 
 
 def _exclude_contents(dst_dir, patterns):
     contents = []
     for p in patterns:
-        contents += glob(join(glob_escape(dst_dir), p))
+        contents += glob.glob(os.path.join(glob.escape(dst_dir), p), recursive=True)
     for path in contents:
-        path = realpath(path)
-        if isdir(path):
+        path = os.path.realpath(path)
+        if os.path.isdir(path):
             fs.rmtree(path)
-        elif isfile(path):
-            remove(path)
+        elif os.path.isfile(path):
+            os.remove(path)
 
 
 def _copy_project_conf(build_dir, project_conf):
     config = ProjectConfig(project_conf, parse_extra=False)
     if config.has_section("platformio"):
         config.remove_section("platformio")
-    config.save(join(build_dir, "platformio.ini"))
+    config.save(os.path.join(build_dir, "platformio.ini"))

platformio/commands/debug.py

@@ -12,28 +12,31 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pylint: disable=too-many-arguments, too-many-statements
-# pylint: disable=too-many-locals, too-many-branches
+# pylint: disable=too-many-arguments, too-many-locals
+# pylint: disable=too-many-branches, too-many-statements
 
+import asyncio
 import os
-import signal
-from os.path import isfile
+import subprocess
 
 import click
 
-from platformio import app, exception, fs, proc, util
-from platformio.commands.debug import helpers
-from platformio.commands.debug.exception import DebugInvalidOptionsError
-from platformio.managers.core import inject_contrib_pysite
+from platformio import app, exception, fs, proc
+from platformio.commands.platform import init_platform
+from platformio.compat import IS_WINDOWS
+from platformio.debug import helpers
+from platformio.debug.config.factory import DebugConfigFactory
+from platformio.debug.exception import DebugInvalidOptionsError
+from platformio.debug.process.gdb import GDBClientProcess
 from platformio.project.config import ProjectConfig
 from platformio.project.exception import ProjectEnvsNotAvailableError
-from platformio.project.helpers import is_platformio_project, load_project_ide_data
+from platformio.project.helpers import is_platformio_project
 
 
 @click.command(
     "debug",
     context_settings=dict(ignore_unknown_options=True),
-    short_help="PIO Unified Debugger",
+    short_help="Unified debugger",
 )
 @click.option(
     "-d",
@@ -59,35 +62,35 @@ def cli(ctx, project_dir, project_conf, environment, verbose, interface, __unpro
     app.set_session_var("custom_project_conf", project_conf)
 
     # use env variables from Eclipse or CLion
-    for sysenv in ("CWD", "PWD", "PLATFORMIO_PROJECT_DIR"):
+    for name in ("CWD", "PWD", "PLATFORMIO_PROJECT_DIR"):
         if is_platformio_project(project_dir):
             break
-        if os.getenv(sysenv):
-            project_dir = os.getenv(sysenv)
+        if os.getenv(name):
+            project_dir = os.getenv(name)
 
     with fs.cd(project_dir):
-        config = ProjectConfig.get_instance(project_conf)
-        config.validate(envs=[environment] if environment else None)
-
-        env_name = environment or helpers.get_default_debug_env(config)
-        env_options = config.items(env=env_name, as_dict=True)
-        if not set(env_options.keys()) >= set(["platform", "board"]):
-            raise ProjectEnvsNotAvailableError()
-        debug_options = helpers.validate_debug_options(ctx, env_options)
-        assert debug_options
+        project_config = ProjectConfig.get_instance(project_conf)
+    project_config.validate(envs=[environment] if environment else None)
+    env_name = environment or helpers.get_default_debug_env(project_config)
 
     if not interface:
-        return helpers.predebug_project(ctx, project_dir, env_name, False, verbose)
+        return helpers.predebug_project(
+            ctx, project_dir, project_config, env_name, False, verbose
+        )
 
-    configuration = load_project_ide_data(project_dir, env_name)
-    if not configuration:
-        raise DebugInvalidOptionsError("Could not load debug configuration")
+    env_options = project_config.items(env=env_name, as_dict=True)
+    if "platform" not in env_options:
+        raise ProjectEnvsNotAvailableError()
+
+    with fs.cd(project_dir):
+        debug_config = DebugConfigFactory.new(
+            init_platform(env_options["platform"]), project_config, env_name
+        )
 
     if "--version" in __unprocessed:
-        result = proc.exec_command([configuration["gdb_path"], "--version"])
-        if result["returncode"] == 0:
-            return click.echo(result["out"])
-        raise exception.PlatformioException("\n".join([result["out"], result["err"]]))
+        return subprocess.run(
+            [debug_config.client_executable_path, "--version"], check=True
+        )
 
     try:
         fs.ensure_udev_rules()
@@ -99,27 +102,24 @@ def cli(ctx, project_dir, project_conf, environment, verbose, interface, __unpro
             nl=False,
         )
 
-    debug_options["load_cmds"] = helpers.configure_esp32_load_cmds(
-        debug_options, configuration
-    )
-
     rebuild_prog = False
-    preload = debug_options["load_cmds"] == ["preload"]
-    load_mode = debug_options["load_mode"]
+    preload = debug_config.load_cmds == ["preload"]
+    load_mode = debug_config.load_mode
     if load_mode == "always":
         rebuild_prog = preload or not helpers.has_debug_symbols(
-            configuration["prog_path"]
+            debug_config.program_path
         )
     elif load_mode == "modified":
         rebuild_prog = helpers.is_prog_obsolete(
-            configuration["prog_path"]
-        ) or not helpers.has_debug_symbols(configuration["prog_path"])
-    else:
-        rebuild_prog = not isfile(configuration["prog_path"])
+            debug_config.program_path
+        ) or not helpers.has_debug_symbols(debug_config.program_path)
+
+    if not (debug_config.program_path and os.path.isfile(debug_config.program_path)):
+        rebuild_prog = True
 
     if preload or (not rebuild_prog and load_mode != "always"):
         # don't load firmware through debug server
-        debug_options["load_cmds"] = []
+        debug_config.load_cmds = []
 
     if rebuild_prog:
         if helpers.is_gdbmi_mode():
@@ -130,30 +130,38 @@ def cli(ctx, project_dir, project_conf, environment, verbose, interface, __unpro
                 nl=False,
             )
             stream = helpers.GDBMIConsoleStream()
-            with util.capture_std_streams(stream):
-                helpers.predebug_project(ctx, project_dir, env_name, preload, verbose)
+            with proc.capture_std_streams(stream):
+                helpers.predebug_project(
+                    ctx, project_dir, project_config, env_name, preload, verbose
+                )
             stream.close()
         else:
             click.echo("Preparing firmware for debugging...")
-            helpers.predebug_project(ctx, project_dir, env_name, preload, verbose)
+            helpers.predebug_project(
+                ctx, project_dir, project_config, env_name, preload, verbose
+            )
 
         # save SHA sum of newly created prog
         if load_mode == "modified":
-            helpers.is_prog_obsolete(configuration["prog_path"])
+            helpers.is_prog_obsolete(debug_config.program_path)
 
-    if not isfile(configuration["prog_path"]):
+    if not os.path.isfile(debug_config.program_path):
         raise DebugInvalidOptionsError("Program/firmware is missed")
 
-    # run debugging client
-    inject_contrib_pysite()
+    loop = asyncio.ProactorEventLoop() if IS_WINDOWS else asyncio.get_event_loop()
+    asyncio.set_event_loop(loop)
 
-    # pylint: disable=import-outside-toplevel
-    from platformio.commands.debug.process.client import GDBClient, reactor
-
-    client = GDBClient(project_dir, __unprocessed, debug_options, env_options)
-    client.spawn(configuration["gdb_path"], configuration["prog_path"])
-
-    signal.signal(signal.SIGINT, lambda *args, **kwargs: None)
-    reactor.run()
+    with fs.cd(project_dir):
+        client = GDBClientProcess(project_dir, debug_config)
+        coro = client.run(__unprocessed)
+        try:
+            loop.run_until_complete(coro)
+            if IS_WINDOWS:
+                # an issue with `asyncio` executor and STIDIN,
+                # it cannot be closed gracefully
+                proc.force_exit()
+        finally:
+            del client
+            loop.close()
 
     return True

platformio/commands/debug/helpers.py

@@ -1,311 +0,0 @@
-# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
-#
-# 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.
-
-import re
-import sys
-import time
-from fnmatch import fnmatch
-from hashlib import sha1
-from io import BytesIO
-from os.path import isfile
-
-from platformio import exception, fs, util
-from platformio.commands import PlatformioCLI
-from platformio.commands.debug.exception import DebugInvalidOptionsError
-from platformio.commands.platform import platform_install as cmd_platform_install
-from platformio.commands.run.command import cli as cmd_run
-from platformio.compat import is_bytes
-from platformio.managers.platform import PlatformFactory
-from platformio.project.config import ProjectConfig
-from platformio.project.options import ProjectOptions
-
-
-class GDBMIConsoleStream(BytesIO):  # pylint: disable=too-few-public-methods
-
-    STDOUT = sys.stdout
-
-    def write(self, text):
-        self.STDOUT.write(escape_gdbmi_stream("~", text))
-        self.STDOUT.flush()
-
-
-def is_gdbmi_mode():
-    return "--interpreter" in " ".join(PlatformioCLI.leftover_args)
-
-
-def escape_gdbmi_stream(prefix, stream):
-    bytes_stream = False
-    if is_bytes(stream):
-        bytes_stream = True
-        stream = stream.decode()
-
-    if not stream:
-        return b"" if bytes_stream else ""
-
-    ends_nl = stream.endswith("\n")
-    stream = re.sub(r"\\+", "\\\\\\\\", stream)
-    stream = stream.replace('"', '\\"')
-    stream = stream.replace("\n", "\\n")
-    stream = '%s"%s"' % (prefix, stream)
-    if ends_nl:
-        stream += "\n"
-
-    return stream.encode() if bytes_stream else stream
-
-
-def get_default_debug_env(config):
-    default_envs = config.default_envs()
-    all_envs = config.envs()
-    for env in default_envs:
-        if config.get("env:" + env, "build_type") == "debug":
-            return env
-    for env in all_envs:
-        if config.get("env:" + env, "build_type") == "debug":
-            return env
-    return default_envs[0] if default_envs else all_envs[0]
-
-
-def predebug_project(ctx, project_dir, env_name, preload, verbose):
-    ctx.invoke(
-        cmd_run,
-        project_dir=project_dir,
-        environment=[env_name],
-        target=["debug"] + (["upload"] if preload else []),
-        verbose=verbose,
-    )
-    if preload:
-        time.sleep(5)
-
-
-def validate_debug_options(cmd_ctx, env_options):
-    def _cleanup_cmds(items):
-        items = ProjectConfig.parse_multi_values(items)
-        return ["$LOAD_CMDS" if item == "$LOAD_CMD" else item for item in items]
-
-    try:
-        platform = PlatformFactory.newPlatform(env_options["platform"])
-    except exception.UnknownPlatform:
-        cmd_ctx.invoke(
-            cmd_platform_install,
-            platforms=[env_options["platform"]],
-            skip_default_package=True,
-        )
-        platform = PlatformFactory.newPlatform(env_options["platform"])
-
-    board_config = platform.board_config(env_options["board"])
-    tool_name = board_config.get_debug_tool_name(env_options.get("debug_tool"))
-    tool_settings = board_config.get("debug", {}).get("tools", {}).get(tool_name, {})
-    server_options = None
-
-    # specific server per a system
-    if isinstance(tool_settings.get("server", {}), list):
-        for item in tool_settings["server"][:]:
-            tool_settings["server"] = item
-            if util.get_systype() in item.get("system", []):
-                break
-
-    # user overwrites debug server
-    if env_options.get("debug_server"):
-        server_options = {
-            "cwd": None,
-            "executable": None,
-            "arguments": env_options.get("debug_server"),
-        }
-        server_options["executable"] = server_options["arguments"][0]
-        server_options["arguments"] = server_options["arguments"][1:]
-    elif "server" in tool_settings:
-        server_options = tool_settings["server"]
-        server_package = server_options.get("package")
-        server_package_dir = (
-            platform.get_package_dir(server_package) if server_package else None
-        )
-        if server_package and not server_package_dir:
-            platform.install_packages(
-                with_packages=[server_package], skip_default_package=True, silent=True
-            )
-            server_package_dir = platform.get_package_dir(server_package)
-        server_options.update(
-            dict(
-                cwd=server_package_dir if server_package else None,
-                executable=server_options.get("executable"),
-                arguments=[
-                    a.replace("$PACKAGE_DIR", server_package_dir)
-                    if server_package_dir
-                    else a
-                    for a in server_options.get("arguments", [])
-                ],
-            )
-        )
-
-    extra_cmds = _cleanup_cmds(env_options.get("debug_extra_cmds"))
-    extra_cmds.extend(_cleanup_cmds(tool_settings.get("extra_cmds")))
-    result = dict(
-        tool=tool_name,
-        upload_protocol=env_options.get(
-            "upload_protocol", board_config.get("upload", {}).get("protocol")
-        ),
-        load_cmds=_cleanup_cmds(
-            env_options.get(
-                "debug_load_cmds",
-                tool_settings.get(
-                    "load_cmds",
-                    tool_settings.get(
-                        "load_cmd", ProjectOptions["env.debug_load_cmds"].default
-                    ),
-                ),
-            )
-        ),
-        load_mode=env_options.get(
-            "debug_load_mode",
-            tool_settings.get(
-                "load_mode", ProjectOptions["env.debug_load_mode"].default
-            ),
-        ),
-        init_break=env_options.get(
-            "debug_init_break",
-            tool_settings.get(
-                "init_break", ProjectOptions["env.debug_init_break"].default
-            ),
-        ),
-        init_cmds=_cleanup_cmds(
-            env_options.get("debug_init_cmds", tool_settings.get("init_cmds"))
-        ),
-        extra_cmds=extra_cmds,
-        require_debug_port=tool_settings.get("require_debug_port", False),
-        port=reveal_debug_port(
-            env_options.get("debug_port", tool_settings.get("port")),
-            tool_name,
-            tool_settings,
-        ),
-        server=server_options,
-    )
-    return result
-
-
-def configure_esp32_load_cmds(debug_options, configuration):
-    ignore_conds = [
-        debug_options["load_cmds"] != ["load"],
-        "xtensa-esp32" not in configuration.get("cc_path", ""),
-        not configuration.get("flash_extra_images"),
-        not all(
-            [isfile(item["path"]) for item in configuration.get("flash_extra_images")]
-        ),
-    ]
-    if any(ignore_conds):
-        return debug_options["load_cmds"]
-
-    mon_cmds = [
-        'monitor program_esp32 "{{{path}}}" {offset} verify'.format(
-            path=fs.to_unix_path(item["path"]), offset=item["offset"]
-        )
-        for item in configuration.get("flash_extra_images")
-    ]
-    mon_cmds.append(
-        'monitor program_esp32 "{%s.bin}" 0x10000 verify'
-        % fs.to_unix_path(configuration["prog_path"][:-4])
-    )
-    return mon_cmds
-
-
-def has_debug_symbols(prog_path):
-    if not isfile(prog_path):
-        return False
-    matched = {
-        b".debug_info": False,
-        b".debug_abbrev": False,
-        b" -Og": False,
-        b" -g": False,
-        b"__PLATFORMIO_BUILD_DEBUG__": False,
-    }
-    with open(prog_path, "rb") as fp:
-        last_data = b""
-        while True:
-            data = fp.read(1024)
-            if not data:
-                break
-            for pattern, found in matched.items():
-                if found:
-                    continue
-                if pattern in last_data + data:
-                    matched[pattern] = True
-            last_data = data
-    return all(matched.values())
-
-
-def is_prog_obsolete(prog_path):
-    prog_hash_path = prog_path + ".sha1"
-    if not isfile(prog_path):
-        return True
-    shasum = sha1()
-    with open(prog_path, "rb") as fp:
-        while True:
-            data = fp.read(1024)
-            if not data:
-                break
-            shasum.update(data)
-    new_digest = shasum.hexdigest()
-    old_digest = None
-    if isfile(prog_hash_path):
-        with open(prog_hash_path) as fp:
-            old_digest = fp.read()
-    if new_digest == old_digest:
-        return False
-    with open(prog_hash_path, "w") as fp:
-        fp.write(new_digest)
-    return True
-
-
-def reveal_debug_port(env_debug_port, tool_name, tool_settings):
-    def _get_pattern():
-        if not env_debug_port:
-            return None
-        if set(["*", "?", "[", "]"]) & set(env_debug_port):
-            return env_debug_port
-        return None
-
-    def _is_match_pattern(port):
-        pattern = _get_pattern()
-        if not pattern:
-            return True
-        return fnmatch(port, pattern)
-
-    def _look_for_serial_port(hwids):
-        for item in util.get_serialports(filter_hwid=True):
-            if not _is_match_pattern(item["port"]):
-                continue
-            port = item["port"]
-            if tool_name.startswith("blackmagic"):
-                if (
-                    "windows" in util.get_systype()
-                    and port.startswith("COM")
-                    and len(port) > 4
-                ):
-                    port = "\\\\.\\%s" % port
-                if "GDB" in item["description"]:
-                    return port
-            for hwid in hwids:
-                hwid_str = ("%s:%s" % (hwid[0], hwid[1])).replace("0x", "")
-                if hwid_str in item["hwid"]:
-                    return port
-        return None
-
-    if env_debug_port and not _get_pattern():
-        return env_debug_port
-    if not tool_settings.get("require_debug_port"):
-        return None
-
-    debug_port = _look_for_serial_port(tool_settings.get("hwids", []))
-    if not debug_port:
-        raise DebugInvalidOptionsError("Please specify `debug_port` for environment")
-    return debug_port

platformio/commands/debug/initcfgs.py

@@ -1,161 +0,0 @@
-# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
-#
-# 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.
-
-GDB_DEFAULT_INIT_CONFIG = """
-define pio_reset_halt_target
-    monitor reset halt
-end
-
-define pio_reset_run_target
-    monitor reset
-end
-
-target extended-remote $DEBUG_PORT
-monitor init
-$LOAD_CMDS
-pio_reset_halt_target
-$INIT_BREAK
-"""
-
-GDB_STUTIL_INIT_CONFIG = """
-define pio_reset_halt_target
-    monitor reset
-    monitor halt
-end
-
-define pio_reset_run_target
-    monitor reset
-end
-
-target extended-remote $DEBUG_PORT
-$LOAD_CMDS
-pio_reset_halt_target
-$INIT_BREAK
-"""
-
-GDB_JLINK_INIT_CONFIG = """
-define pio_reset_halt_target
-    monitor reset
-    monitor halt
-end
-
-define pio_reset_run_target
-    monitor clrbp
-    monitor reset
-    monitor go
-end
-
-target extended-remote $DEBUG_PORT
-monitor clrbp
-monitor speed auto
-pio_reset_halt_target
-$LOAD_CMDS
-$INIT_BREAK
-"""
-
-GDB_BLACKMAGIC_INIT_CONFIG = """
-define pio_reset_halt_target
-    set language c
-    set *0xE000ED0C = 0x05FA0004
-    set $busy = (*0xE000ED0C & 0x4)
-    while ($busy)
-        set $busy = (*0xE000ED0C & 0x4)
-    end
-    set language auto
-end
-
-define pio_reset_run_target
-    pio_reset_halt_target
-end
-
-target extended-remote $DEBUG_PORT
-monitor swdp_scan
-attach 1
-set mem inaccessible-by-default off
-$LOAD_CMDS
-$INIT_BREAK
-
-set language c
-set *0xE000ED0C = 0x05FA0004
-set $busy = (*0xE000ED0C & 0x4)
-while ($busy)
-    set $busy = (*0xE000ED0C & 0x4)
-end
-set language auto
-"""
-
-GDB_MSPDEBUG_INIT_CONFIG = """
-define pio_reset_halt_target
-end
-
-define pio_reset_run_target
-end
-
-target extended-remote $DEBUG_PORT
-monitor erase
-$LOAD_CMDS
-pio_reset_halt_target
-$INIT_BREAK
-"""
-
-GDB_QEMU_INIT_CONFIG = """
-define pio_reset_halt_target
-    monitor system_reset
-end
-
-define pio_reset_run_target
-    monitor system_reset
-end
-
-target extended-remote $DEBUG_PORT
-$LOAD_CMDS
-pio_reset_halt_target
-$INIT_BREAK
-"""
-
-GDB_RENODE_INIT_CONFIG = """
-define pio_reset_halt_target
-    monitor machine Reset
-    $LOAD_CMDS
-    monitor start
-end
-
-define pio_reset_run_target
-    pio_reset_halt_target
-end
-
-target extended-remote $DEBUG_PORT
-$LOAD_CMDS
-$INIT_BREAK
-monitor start
-"""
-
-
-TOOL_TO_CONFIG = {
-    "jlink": GDB_JLINK_INIT_CONFIG,
-    "mspdebug": GDB_MSPDEBUG_INIT_CONFIG,
-    "qemu": GDB_QEMU_INIT_CONFIG,
-    "blackmagic": GDB_BLACKMAGIC_INIT_CONFIG,
-    "renode": GDB_RENODE_INIT_CONFIG,
-}
-
-
-def get_gdb_init_config(debug_options):
-    tool = debug_options.get("tool")
-    if tool and tool in TOOL_TO_CONFIG:
-        return TOOL_TO_CONFIG[tool]
-    server_exe = (debug_options.get("server") or {}).get("executable", "").lower()
-    if "st-util" in server_exe:
-        return GDB_STUTIL_INIT_CONFIG
-    return GDB_DEFAULT_INIT_CONFIG

platformio/commands/debug/process/base.py

@@ -1,93 +0,0 @@
-# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
-#
-# 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.
-
-import signal
-import time
-
-import click
-from twisted.internet import protocol  # pylint: disable=import-error
-
-from platformio import fs
-from platformio.compat import string_types
-from platformio.proc import get_pythonexe_path
-from platformio.project.helpers import get_project_core_dir
-
-
-class BaseProcess(protocol.ProcessProtocol, object):
-
-    STDOUT_CHUNK_SIZE = 2048
-    LOG_FILE = None
-
-    COMMON_PATTERNS = {
-        "PLATFORMIO_HOME_DIR": get_project_core_dir(),
-        "PLATFORMIO_CORE_DIR": get_project_core_dir(),
-        "PYTHONEXE": get_pythonexe_path(),
-    }
-
-    def __init__(self):
-        self._last_activity = 0
-
-    def apply_patterns(self, source, patterns=None):
-        _patterns = self.COMMON_PATTERNS.copy()
-        _patterns.update(patterns or {})
-
-        for key, value in _patterns.items():
-            if key.endswith(("_DIR", "_PATH")):
-                _patterns[key] = fs.to_unix_path(value)
-
-        def _replace(text):
-            for key, value in _patterns.items():
-                pattern = "$%s" % key
-                text = text.replace(pattern, value or "")
-            return text
-
-        if isinstance(source, string_types):
-            source = _replace(source)
-        elif isinstance(source, (list, dict)):
-            items = enumerate(source) if isinstance(source, list) else source.items()
-            for key, value in items:
-                if isinstance(value, string_types):
-                    source[key] = _replace(value)
-                elif isinstance(value, (list, dict)):
-                    source[key] = self.apply_patterns(value, patterns)
-
-        return source
-
-    def onStdInData(self, data):
-        self._last_activity = time.time()
-        if self.LOG_FILE:
-            with open(self.LOG_FILE, "ab") as fp:
-                fp.write(data)
-
-    def outReceived(self, data):
-        self._last_activity = time.time()
-        if self.LOG_FILE:
-            with open(self.LOG_FILE, "ab") as fp:
-                fp.write(data)
-        while data:
-            chunk = data[: self.STDOUT_CHUNK_SIZE]
-            click.echo(chunk, nl=False)
-            data = data[self.STDOUT_CHUNK_SIZE :]
-
-    def errReceived(self, data):
-        self._last_activity = time.time()
-        if self.LOG_FILE:
-            with open(self.LOG_FILE, "ab") as fp:
-                fp.write(data)
-        click.echo(data, nl=False, err=True)
-
-    def processEnded(self, _):
-        self._last_activity = time.time()
-        # Allow terminating via SIGINT/CTRL+C
-        signal.signal(signal.SIGINT, signal.default_int_handler)

platformio/commands/debug/process/client.py

@@ -1,279 +0,0 @@
-# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
-#
-# 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.
-
-import os
-import re
-import signal
-import time
-from hashlib import sha1
-from os.path import basename, dirname, isdir, join, realpath, splitext
-from tempfile import mkdtemp
-
-from twisted.internet import defer  # pylint: disable=import-error
-from twisted.internet import protocol  # pylint: disable=import-error
-from twisted.internet import reactor  # pylint: disable=import-error
-from twisted.internet import stdio  # pylint: disable=import-error
-from twisted.internet import task  # pylint: disable=import-error
-
-from platformio import app, fs, proc, telemetry, util
-from platformio.commands.debug import helpers
-from platformio.commands.debug.exception import DebugInvalidOptionsError
-from platformio.commands.debug.initcfgs import get_gdb_init_config
-from platformio.commands.debug.process.base import BaseProcess
-from platformio.commands.debug.process.server import DebugServer
-from platformio.compat import hashlib_encode_data, is_bytes
-from platformio.project.helpers import get_project_cache_dir
-
-
-class GDBClient(BaseProcess):  # pylint: disable=too-many-instance-attributes
-
-    PIO_SRC_NAME = ".pioinit"
-    INIT_COMPLETED_BANNER = "PlatformIO: Initialization completed"
-
-    def __init__(self, project_dir, args, debug_options, env_options):
-        super(GDBClient, self).__init__()
-        self.project_dir = project_dir
-        self.args = list(args)
-        self.debug_options = debug_options
-        self.env_options = env_options
-
-        self._debug_server = DebugServer(debug_options, env_options)
-        self._session_id = None
-
-        if not isdir(get_project_cache_dir()):
-            os.makedirs(get_project_cache_dir())
-        self._gdbsrc_dir = mkdtemp(dir=get_project_cache_dir(), prefix=".piodebug-")
-
-        self._target_is_run = False
-        self._auto_continue_timer = None
-        self._errors_buffer = b""
-
-    @defer.inlineCallbacks
-    def spawn(self, gdb_path, prog_path):
-        session_hash = gdb_path + prog_path
-        self._session_id = sha1(hashlib_encode_data(session_hash)).hexdigest()
-        self._kill_previous_session()
-
-        patterns = {
-            "PROJECT_DIR": self.project_dir,
-            "PROG_PATH": prog_path,
-            "PROG_DIR": dirname(prog_path),
-            "PROG_NAME": basename(splitext(prog_path)[0]),
-            "DEBUG_PORT": self.debug_options["port"],
-            "UPLOAD_PROTOCOL": self.debug_options["upload_protocol"],
-            "INIT_BREAK": self.debug_options["init_break"] or "",
-            "LOAD_CMDS": "\n".join(self.debug_options["load_cmds"] or []),
-        }
-
-        yield self._debug_server.spawn(patterns)
-        if not patterns["DEBUG_PORT"]:
-            patterns["DEBUG_PORT"] = self._debug_server.get_debug_port()
-
-        self.generate_pioinit(self._gdbsrc_dir, patterns)
-
-        # start GDB client
-        args = [
-            "piogdb",
-            "-q",
-            "--directory",
-            self._gdbsrc_dir,
-            "--directory",
-            self.project_dir,
-            "-l",
-            "10",
-        ]
-        args.extend(self.args)
-        if not gdb_path:
-            raise DebugInvalidOptionsError("GDB client is not configured")
-        gdb_data_dir = self._get_data_dir(gdb_path)
-        if gdb_data_dir:
-            args.extend(["--data-directory", gdb_data_dir])
-        args.append(patterns["PROG_PATH"])
-
-        transport = reactor.spawnProcess(
-            self, gdb_path, args, path=self.project_dir, env=os.environ
-        )
-        defer.returnValue(transport)
-
-    @staticmethod
-    def _get_data_dir(gdb_path):
-        if "msp430" in gdb_path:
-            return None
-        gdb_data_dir = realpath(join(dirname(gdb_path), "..", "share", "gdb"))
-        return gdb_data_dir if isdir(gdb_data_dir) else None
-
-    def generate_pioinit(self, dst_dir, patterns):
-        # default GDB init commands depending on debug tool
-        commands = get_gdb_init_config(self.debug_options).split("\n")
-
-        if self.debug_options["init_cmds"]:
-            commands = self.debug_options["init_cmds"]
-        commands.extend(self.debug_options["extra_cmds"])
-
-        if not any("define pio_reset_run_target" in cmd for cmd in commands):
-            commands = [
-                "define pio_reset_run_target",
-                "   echo Warning! Undefined pio_reset_run_target command\\n",
-                "   monitor reset",
-                "end",
-            ] + commands
-        if not any("define pio_reset_halt_target" in cmd for cmd in commands):
-            commands = [
-                "define pio_reset_halt_target",
-                "   echo Warning! Undefined pio_reset_halt_target command\\n",
-                "   monitor reset halt",
-                "end",
-            ] + commands
-        if not any("define pio_restart_target" in cmd for cmd in commands):
-            commands += [
-                "define pio_restart_target",
-                "   pio_reset_halt_target",
-                "   $INIT_BREAK",
-                "   %s" % ("continue" if patterns["INIT_BREAK"] else "next"),
-                "end",
-            ]
-
-        banner = [
-            "echo PlatformIO Unified Debugger -> http://bit.ly/pio-debug\\n",
-            "echo PlatformIO: debug_tool = %s\\n" % self.debug_options["tool"],
-            "echo PlatformIO: Initializing remote target...\\n",
-        ]
-        footer = ["echo %s\\n" % self.INIT_COMPLETED_BANNER]
-        commands = banner + commands + footer
-
-        with open(join(dst_dir, self.PIO_SRC_NAME), "w") as fp:
-            fp.write("\n".join(self.apply_patterns(commands, patterns)))
-
-    def connectionMade(self):
-        self._lock_session(self.transport.pid)
-
-        p = protocol.Protocol()
-        p.dataReceived = self.onStdInData
-        stdio.StandardIO(p)
-
-    def onStdInData(self, data):
-        super(GDBClient, self).onStdInData(data)
-        if b"-exec-run" in data:
-            if self._target_is_run:
-                token, _ = data.split(b"-", 1)
-                self.outReceived(token + b"^running\n")
-                return
-            data = data.replace(b"-exec-run", b"-exec-continue")
-
-        if b"-exec-continue" in data:
-            self._target_is_run = True
-        if b"-gdb-exit" in data or data.strip() in (b"q", b"quit"):
-            # Allow terminating via SIGINT/CTRL+C
-            signal.signal(signal.SIGINT, signal.default_int_handler)
-            self.transport.write(b"pio_reset_run_target\n")
-        self.transport.write(data)
-
-    def processEnded(self, reason):  # pylint: disable=unused-argument
-        self._unlock_session()
-        if self._gdbsrc_dir and isdir(self._gdbsrc_dir):
-            fs.rmtree(self._gdbsrc_dir)
-        if self._debug_server:
-            self._debug_server.terminate()
-
-        reactor.stop()
-
-    def outReceived(self, data):
-        super(GDBClient, self).outReceived(data)
-        self._handle_error(data)
-        # go to init break automatically
-        if self.INIT_COMPLETED_BANNER.encode() in data:
-            telemetry.send_event(
-                "Debug", "Started", telemetry.dump_run_environment(self.env_options)
-            )
-            self._auto_continue_timer = task.LoopingCall(self._auto_exec_continue)
-            self._auto_continue_timer.start(0.1)
-
-    def errReceived(self, data):
-        super(GDBClient, self).errReceived(data)
-        self._handle_error(data)
-
-    def console_log(self, msg):
-        if helpers.is_gdbmi_mode():
-            msg = helpers.escape_gdbmi_stream("~", msg)
-        self.outReceived(msg if is_bytes(msg) else msg.encode())
-
-    def _auto_exec_continue(self):
-        auto_exec_delay = 0.5  # in seconds
-        if self._last_activity > (time.time() - auto_exec_delay):
-            return
-        if self._auto_continue_timer:
-            self._auto_continue_timer.stop()
-        self._auto_continue_timer = None
-
-        if not self.debug_options["init_break"] or self._target_is_run:
-            return
-        self.console_log(
-            "PlatformIO: Resume the execution to `debug_init_break = %s`\n"
-            % self.debug_options["init_break"]
-        )
-        self.console_log(
-            "PlatformIO: More configuration options -> http://bit.ly/pio-debug\n"
-        )
-        self.transport.write(
-            b"0-exec-continue\n" if helpers.is_gdbmi_mode() else b"continue\n"
-        )
-        self._target_is_run = True
-
-    def _handle_error(self, data):
-        self._errors_buffer = (self._errors_buffer + data)[-8192:]  # keep last 8 KBytes
-        if not (
-            self.PIO_SRC_NAME.encode() in self._errors_buffer
-            and b"Error in sourced" in self._errors_buffer
-        ):
-            return
-
-        last_erros = self._errors_buffer.decode()
-        last_erros = " ".join(reversed(last_erros.split("\n")))
-        last_erros = re.sub(r'((~|&)"|\\n\"|\\t)', " ", last_erros, flags=re.M)
-
-        err = "%s -> %s" % (
-            telemetry.dump_run_environment(self.env_options),
-            last_erros,
-        )
-        telemetry.send_exception("DebugInitError: %s" % err)
-        self.transport.loseConnection()
-
-    def _kill_previous_session(self):
-        assert self._session_id
-        pid = None
-        with app.ContentCache() as cc:
-            pid = cc.get(self._session_id)
-            cc.delete(self._session_id)
-        if not pid:
-            return
-        if "windows" in util.get_systype():
-            kill = ["Taskkill", "/PID", pid, "/F"]
-        else:
-            kill = ["kill", pid]
-        try:
-            proc.exec_command(kill)
-        except:  # pylint: disable=bare-except
-            pass
-
-    def _lock_session(self, pid):
-        if not self._session_id:
-            return
-        with app.ContentCache() as cc:
-            cc.set(self._session_id, str(pid), "1h")
-
-    def _unlock_session(self):
-        if not self._session_id:
-            return
-        with app.ContentCache() as cc:
-            cc.delete(self._session_id)

platformio/commands/debug/process/server.py

@@ -1,166 +0,0 @@
-# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
-#
-# 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.
-
-import os
-import time
-from os.path import isdir, isfile, join
-
-from twisted.internet import defer  # pylint: disable=import-error
-from twisted.internet import reactor  # pylint: disable=import-error
-
-from platformio import fs, util
-from platformio.commands.debug.exception import DebugInvalidOptionsError
-from platformio.commands.debug.helpers import escape_gdbmi_stream, is_gdbmi_mode
-from platformio.commands.debug.process.base import BaseProcess
-from platformio.proc import where_is_program
-
-
-class DebugServer(BaseProcess):
-    def __init__(self, debug_options, env_options):
-        super(DebugServer, self).__init__()
-        self.debug_options = debug_options
-        self.env_options = env_options
-
-        self._debug_port = ":3333"
-        self._transport = None
-        self._process_ended = False
-        self._ready = False
-
-    @defer.inlineCallbacks
-    def spawn(self, patterns):  # pylint: disable=too-many-branches
-        systype = util.get_systype()
-        server = self.debug_options.get("server")
-        if not server:
-            defer.returnValue(None)
-        server = self.apply_patterns(server, patterns)
-        server_executable = server["executable"]
-        if not server_executable:
-            defer.returnValue(None)
-        if server["cwd"]:
-            server_executable = join(server["cwd"], server_executable)
-        if (
-            "windows" in systype
-            and not server_executable.endswith(".exe")
-            and isfile(server_executable + ".exe")
-        ):
-            server_executable = server_executable + ".exe"
-
-        if not isfile(server_executable):
-            server_executable = where_is_program(server_executable)
-        if not isfile(server_executable):
-            raise DebugInvalidOptionsError(
-                "\nCould not launch Debug Server '%s'. Please check that it "
-                "is installed and is included in a system PATH\n\n"
-                "See documentation or contact contact@platformio.org:\n"
-                "https://docs.platformio.org/page/plus/debugging.html\n"
-                % server_executable
-            )
-
-        openocd_pipe_allowed = all(
-            [not self.debug_options["port"], "openocd" in server_executable]
-        )
-        if openocd_pipe_allowed:
-            args = []
-            if server["cwd"]:
-                args.extend(["-s", server["cwd"]])
-            args.extend(
-                ["-c", "gdb_port pipe; tcl_port disabled; telnet_port disabled"]
-            )
-            args.extend(server["arguments"])
-            str_args = " ".join(
-                [arg if arg.startswith("-") else '"%s"' % arg for arg in args]
-            )
-            self._debug_port = '| "%s" %s' % (server_executable, str_args)
-            self._debug_port = fs.to_unix_path(self._debug_port)
-            defer.returnValue(self._debug_port)
-
-        env = os.environ.copy()
-        # prepend server "lib" folder to LD path
-        if (
-            "windows" not in systype
-            and server["cwd"]
-            and isdir(join(server["cwd"], "lib"))
-        ):
-            ld_key = "DYLD_LIBRARY_PATH" if "darwin" in systype else "LD_LIBRARY_PATH"
-            env[ld_key] = join(server["cwd"], "lib")
-            if os.environ.get(ld_key):
-                env[ld_key] = "%s:%s" % (env[ld_key], os.environ.get(ld_key))
-        # prepend BIN to PATH
-        if server["cwd"] and isdir(join(server["cwd"], "bin")):
-            env["PATH"] = "%s%s%s" % (
-                join(server["cwd"], "bin"),
-                os.pathsep,
-                os.environ.get("PATH", os.environ.get("Path", "")),
-            )
-
-        self._transport = reactor.spawnProcess(
-            self,
-            server_executable,
-            [server_executable] + server["arguments"],
-            path=server["cwd"],
-            env=env,
-        )
-        if "mspdebug" in server_executable.lower():
-            self._debug_port = ":2000"
-        elif "jlink" in server_executable.lower():
-            self._debug_port = ":2331"
-        elif "qemu" in server_executable.lower():
-            self._debug_port = ":1234"
-
-        yield self._wait_until_ready()
-
-        defer.returnValue(self._debug_port)
-
-    @defer.inlineCallbacks
-    def _wait_until_ready(self):
-        timeout = 10
-        elapsed = 0
-        delay = 0.5
-        auto_ready_delay = 0.5
-        while not self._ready and not self._process_ended and elapsed < timeout:
-            yield self.async_sleep(delay)
-            if not self.debug_options.get("server", {}).get("ready_pattern"):
-                self._ready = self._last_activity < (time.time() - auto_ready_delay)
-            elapsed += delay
-
-    @staticmethod
-    def async_sleep(secs):
-        d = defer.Deferred()
-        reactor.callLater(secs, d.callback, None)
-        return d
-
-    def get_debug_port(self):
-        return self._debug_port
-
-    def outReceived(self, data):
-        super(DebugServer, self).outReceived(
-            escape_gdbmi_stream("@", data) if is_gdbmi_mode() else data
-        )
-        if self._ready:
-            return
-        ready_pattern = self.debug_options.get("server", {}).get("ready_pattern")
-        if ready_pattern:
-            self._ready = ready_pattern.encode() in data
-
-    def processEnded(self, reason):
-        self._process_ended = True
-        super(DebugServer, self).processEnded(reason)
-
-    def terminate(self):
-        if self._process_ended or not self._transport:
-            return
-        try:
-            self._transport.signalProcess("KILL")
-        except:  # pylint: disable=bare-except
-            pass

platformio/commands/device/command.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import json
 import os
 import sys
 from fnmatch import fnmatch
@@ -21,12 +22,11 @@ from serial.tools import miniterm
 
 from platformio import exception, fs, util
 from platformio.commands.device import helpers as device_helpers
-from platformio.compat import dump_json_to_unicode
-from platformio.managers.platform import PlatformFactory
+from platformio.platform.factory import PlatformFactory
 from platformio.project.exception import NotPlatformIOProjectError
 
 
-@click.group(short_help="Monitor device or list existing")
+@click.group(short_help="Device manager & serial/socket monitor")
 def cli():
     pass
 
@@ -52,9 +52,7 @@ def device_list(  # pylint: disable=too-many-branches
     single_key = list(data)[0] if len(list(data)) == 1 else None
 
     if json_output:
-        return click.echo(
-            dump_json_to_unicode(data[single_key] if single_key else data)
-        )
+        return click.echo(json.dumps(data[single_key] if single_key else data))
 
     titles = {
         "serial": "Serial Ports",
@@ -179,7 +177,9 @@ def device_monitor(**kwargs):  # pylint: disable=too-many-branches
     for name in os.listdir(filters_dir):
         if not name.endswith(".py"):
             continue
-        device_helpers.load_monitor_filter(os.path.join(filters_dir, name))
+        device_helpers.load_monitor_filter(
+            os.path.join(filters_dir, name), options=kwargs
+        )
 
     project_options = {}
     try:
@@ -192,10 +192,8 @@ def device_monitor(**kwargs):  # pylint: disable=too-many-branches
     platform = None
     if "platform" in project_options:
         with fs.cd(kwargs["project_dir"]):
-            platform = PlatformFactory.newPlatform(project_options["platform"])
-            device_helpers.register_platform_filters(
-                platform, kwargs["project_dir"], kwargs["environment"]
-            )
+            platform = PlatformFactory.new(project_options["platform"])
+            device_helpers.register_platform_filters(platform, options=kwargs)
 
     if not kwargs["port"]:
         ports = util.get_serial_ports(filter_hwid=True)
@@ -203,7 +201,9 @@ def device_monitor(**kwargs):  # pylint: disable=too-many-branches
             kwargs["port"] = ports[0]["port"]
         elif "platform" in project_options and "board" in project_options:
             board_hwids = device_helpers.get_board_hwids(
-                kwargs["project_dir"], platform, project_options["board"],
+                kwargs["project_dir"],
+                platform,
+                project_options["board"],
             )
             for item in ports:
                 for hwid in board_hwids:

platformio/commands/device/filters/base.py

@@ -18,12 +18,13 @@ from platformio.project.config import ProjectConfig
 
 
 class DeviceMonitorFilter(miniterm.Transform):
-    def __init__(self, project_dir=None, environment=None):
-        """ Called by PlatformIO to pass context """
+    def __init__(self, options=None):
+        """Called by PlatformIO to pass context"""
         miniterm.Transform.__init__(self)
 
-        self.project_dir = project_dir
-        self.environment = environment
+        self.options = options or {}
+        self.project_dir = self.options.get("project_dir")
+        self.environment = self.options.get("environment")
 
         self.config = ProjectConfig.get_instance()
         if not self.environment:
@@ -34,7 +35,7 @@ class DeviceMonitorFilter(miniterm.Transform):
                 self.environment = self.config.envs()[0]
 
     def __call__(self):
-        """ Called by the miniterm library when the filter is actually used """
+        """Called by the miniterm library when the filter is actually used"""
         return self
 
     @property

platformio/commands/device/filters/log2file.py

@@ -31,6 +31,7 @@ class LogToFile(DeviceMonitorFilter):
             "%y%m%d-%H%M%S"
         )
         print("--- Logging an output to %s" % os.path.abspath(log_file_name))
+        # pylint: disable=consider-using-with
         self._log_fp = io.open(log_file_name, "w", encoding="utf-8")
         return self
 

platformio/commands/device/filters/send_on_enter.py

@@ -22,10 +22,17 @@ class SendOnEnter(DeviceMonitorFilter):
         super(SendOnEnter, self).__init__(*args, **kwargs)
         self._buffer = ""
 
+        if self.options.get("eol") == "CR":
+            self._eol = "\r"
+        elif self.options.get("eol") == "LF":
+            self._eol = "\n"
+        else:
+            self._eol = "\r\n"
+
     def tx(self, text):
         self._buffer += text
-        if self._buffer.endswith("\r\n"):
-            text = self._buffer[:-2]
+        if self._buffer.endswith(self._eol):
+            text = self._buffer
             self._buffer = ""
             return text
         return ""

platformio/commands/device/filters/time.py

@@ -22,13 +22,16 @@ class Timestamp(DeviceMonitorFilter):
 
     def __init__(self, *args, **kwargs):
         super(Timestamp, self).__init__(*args, **kwargs)
-        self._first_text_received = False
+        self._line_started = False
 
     def rx(self, text):
-        if self._first_text_received and "\n" not in text:
+        if self._line_started and "\n" not in text:
             return text
         timestamp = datetime.now().strftime("%H:%M:%S.%f")[:-3]
-        if not self._first_text_received:
-            self._first_text_received = True
-            return "%s > %s" % (timestamp, text)
+        if not self._line_started:
+            self._line_started = True
+            text = "%s > %s" % (timestamp, text)
+        if text.endswith("\n"):
+            self._line_started = False
+            return text[:-1].replace("\n", "\n%s > " % timestamp) + "\n"
         return text.replace("\n", "\n%s > " % timestamp)

platformio/commands/device/helpers.py

@@ -76,7 +76,7 @@ def get_board_hwids(project_dir, platform, board):
         return platform.board_config(board).get("build.hwids", [])
 
 
-def load_monitor_filter(path, project_dir=None, environment=None):
+def load_monitor_filter(path, options=None):
     name = os.path.basename(path)
     name = name[: name.find(".")]
     module = load_python_module("platformio.commands.device.filters.%s" % name, path)
@@ -87,12 +87,12 @@ def load_monitor_filter(path, project_dir=None, environment=None):
             or cls == DeviceMonitorFilter
         ):
             continue
-        obj = cls(project_dir, environment)
+        obj = cls(options)
         miniterm.TRANSFORMATIONS[obj.NAME] = obj
     return True
 
 
-def register_platform_filters(platform, project_dir, environment):
+def register_platform_filters(platform, options=None):
     monitor_dir = os.path.join(platform.get_dir(), "monitor")
     if not os.path.isdir(monitor_dir):
         return
@@ -103,4 +103,4 @@ def register_platform_filters(platform, project_dir, environment):
         path = os.path.join(monitor_dir, name)
         if not os.path.isfile(path):
             continue
-        load_monitor_filter(path, project_dir, environment)
+        load_monitor_filter(path, options)

platformio/commands/home/command.py

@@ -12,24 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pylint: disable=too-many-locals,too-many-statements
-
 import mimetypes
-import socket
-from os.path import isdir
 
 import click
 
-from platformio import exception
-from platformio.compat import WINDOWS
-from platformio.managers.core import (
-    build_contrib_pysite_deps,
-    get_core_package_dir,
-    inject_contrib_pysite,
-)
+from platformio.commands.home.helpers import is_port_used
+from platformio.commands.home.run import run_server
 
 
-@click.command("home", short_help="PIO Home")
+@click.command("home", short_help="GUI to manage PlatformIO")
 @click.option("--port", type=int, default=8008, help="HTTP port, default=8008")
 @click.option(
     "--host",
@@ -49,66 +40,28 @@ from platformio.managers.core import (
         "are connected. Default is 0 which means never auto shutdown"
     ),
 )
-def cli(port, host, no_open, shutdown_timeout):
-    # pylint: disable=import-error, import-outside-toplevel
-
-    # import contrib modules
-    inject_contrib_pysite()
-
-    try:
-        from autobahn.twisted.resource import WebSocketResource
-    except:  # pylint: disable=bare-except
-        build_contrib_pysite_deps(get_core_package_dir("contrib-pysite"))
-        from autobahn.twisted.resource import WebSocketResource
-
-    from twisted.internet import reactor
-    from twisted.web import server
-    from twisted.internet.error import CannotListenError
-
-    from platformio.commands.home.rpc.handlers.app import AppRPC
-    from platformio.commands.home.rpc.handlers.ide import IDERPC
-    from platformio.commands.home.rpc.handlers.misc import MiscRPC
-    from platformio.commands.home.rpc.handlers.os import OSRPC
-    from platformio.commands.home.rpc.handlers.piocore import PIOCoreRPC
-    from platformio.commands.home.rpc.handlers.project import ProjectRPC
-    from platformio.commands.home.rpc.handlers.account import AccountRPC
-    from platformio.commands.home.rpc.server import JSONRPCServerFactory
-    from platformio.commands.home.web import WebRoot
-
-    factory = JSONRPCServerFactory(shutdown_timeout)
-    factory.addHandler(AppRPC(), namespace="app")
-    factory.addHandler(IDERPC(), namespace="ide")
-    factory.addHandler(MiscRPC(), namespace="misc")
-    factory.addHandler(OSRPC(), namespace="os")
-    factory.addHandler(PIOCoreRPC(), namespace="core")
-    factory.addHandler(ProjectRPC(), namespace="project")
-    factory.addHandler(AccountRPC(), namespace="account")
-
-    contrib_dir = get_core_package_dir("contrib-piohome")
-    if not isdir(contrib_dir):
-        raise exception.PlatformioException("Invalid path to PIO Home Contrib")
-
+@click.option(
+    "--session-id",
+    help=(
+        "A unique session identifier to keep PIO Home isolated from other instances "
+        "and protect from 3rd party access"
+    ),
+)
+def cli(port, host, no_open, shutdown_timeout, session_id):
     # Ensure PIO Home mimetypes are known
     mimetypes.add_type("text/html", ".html")
     mimetypes.add_type("text/css", ".css")
     mimetypes.add_type("application/javascript", ".js")
 
-    root = WebRoot(contrib_dir)
-    root.putChild(b"wsrpc", WebSocketResource(factory))
-    site = server.Site(root)
-
     # hook for `platformio-node-helpers`
     if host == "__do_not_start__":
         return
 
-    already_started = is_port_used(host, port)
-    home_url = "http://%s:%d" % (host, port)
-    if not no_open:
-        if already_started:
-            click.launch(home_url)
-        else:
-            reactor.callLater(1, lambda: click.launch(home_url))
-
+    home_url = "http://%s:%d%s" % (
+        host,
+        port,
+        ("/session/%s/" % session_id) if session_id else "/",
+    )
     click.echo(
         "\n".join(
             [
@@ -117,45 +70,25 @@ def cli(port, host, no_open, shutdown_timeout):
                 " /\\-_--\\   PlatformIO Home",
                 "/  \\_-__\\",
                 "|[]| [] |  %s" % home_url,
-                "|__|____|______________%s" % ("_" * len(host)),
+                "|__|____|__%s" % ("_" * len(home_url)),
             ]
         )
     )
     click.echo("")
     click.echo("Open PlatformIO Home in your browser by this URL => %s" % home_url)
 
-    try:
-        reactor.listenTCP(port, site, interface=host)
-    except CannotListenError as e:
-        click.secho(str(e), fg="red", err=True)
-        already_started = True
-
-    if already_started:
+    if is_port_used(host, port):
         click.secho(
             "PlatformIO Home server is already started in another process.", fg="yellow"
         )
+        if not no_open:
+            click.launch(home_url)
         return
 
-    click.echo("PIO Home has been started. Press Ctrl+C to shutdown.")
-
-    reactor.run()
-
-
-def is_port_used(host, port):
-    socket.setdefaulttimeout(1)
-    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    if WINDOWS:
-        try:
-            s.bind((host, port))
-            s.close()
-            return False
-        except (OSError, socket.error):
-            pass
-    else:
-        try:
-            s.connect((host, port))
-            s.close()
-        except socket.error:
-            return False
-
-    return True
+    run_server(
+        host=host,
+        port=port,
+        no_open=no_open,
+        shutdown_timeout=shutdown_timeout,
+        home_url=home_url,
+    )

platformio/commands/home/helpers.py

@@ -12,58 +12,49 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pylint: disable=keyword-arg-before-vararg,arguments-differ,signature-differs
-
-import os
 import socket
 
 import requests
-from twisted.internet import defer  # pylint: disable=import-error
-from twisted.internet import reactor  # pylint: disable=import-error
-from twisted.internet import threads  # pylint: disable=import-error
+from starlette.concurrency import run_in_threadpool
 
 from platformio import util
+from platformio.compat import IS_WINDOWS
 from platformio.proc import where_is_program
 
 
 class AsyncSession(requests.Session):
-    def __init__(self, n=None, *args, **kwargs):
-        if n:
-            pool = reactor.getThreadPool()
-            pool.adjustPoolsize(0, n)
-
-        super(AsyncSession, self).__init__(*args, **kwargs)
-
-    def request(self, *args, **kwargs):
+    async def request(  # pylint: disable=signature-differs,invalid-overridden-method
+        self, *args, **kwargs
+    ):
         func = super(AsyncSession, self).request
-        return threads.deferToThread(func, *args, **kwargs)
-
-    def wrap(self, *args, **kwargs):  # pylint: disable=no-self-use
-        return defer.ensureDeferred(*args, **kwargs)
+        return await run_in_threadpool(func, *args, **kwargs)
 
 
 @util.memoized(expire="60s")
 def requests_session():
-    return AsyncSession(n=5)
+    return AsyncSession()
 
 
 @util.memoized(expire="60s")
 def get_core_fullpath():
-    return where_is_program(
-        "platformio" + (".exe" if "windows" in util.get_systype() else "")
-    )
+    return where_is_program("platformio" + (".exe" if IS_WINDOWS else ""))
 
 
-@util.memoized(expire="10s")
-def is_twitter_blocked():
-    ip = "104.244.42.1"
-    timeout = 2
-    try:
-        if os.getenv("HTTP_PROXY", os.getenv("HTTPS_PROXY")):
-            requests.get("http://%s" % ip, allow_redirects=False, timeout=timeout)
-        else:
-            socket.socket(socket.AF_INET, socket.SOCK_STREAM).connect((ip, 80))
-        return False
-    except:  # pylint: disable=bare-except
-        pass
+def is_port_used(host, port):
+    socket.setdefaulttimeout(1)
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    if IS_WINDOWS:
+        try:
+            s.bind((host, port))
+            s.close()
+            return False
+        except (OSError, socket.error):
+            pass
+    else:
+        try:
+            s.connect((host, port))
+            s.close()
+        except socket.error:
+            return False
+
     return True

platformio/commands/home/rpc/handlers/account.py

@@ -12,18 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import jsonrpc  # pylint: disable=import-error
+from ajsonrpc.core import JSONRPC20DispatchException
 
-from platformio.commands.account.client import AccountClient
+from platformio.clients.account import AccountClient
 
 
-class AccountRPC(object):
+class AccountRPC:
     @staticmethod
     def call_client(method, *args, **kwargs):
         try:
             client = AccountClient()
             return getattr(client, method)(*args, **kwargs)
         except Exception as e:  # pylint: disable=bare-except
-            raise jsonrpc.exceptions.JSONRPCDispatchException(
+            raise JSONRPC20DispatchException(
                 code=4003, message="PIO Account Call Error", data=str(e)
             )

platformio/commands/home/rpc/handlers/app.py

@@ -20,7 +20,7 @@ from platformio import __version__, app, fs, util
 from platformio.project.helpers import get_project_core_dir, is_platformio_project
 
 
-class AppRPC(object):
+class AppRPC:
 
     APPSTATE_PATH = join(get_project_core_dir(), "homestate.json")
 

platformio/commands/home/rpc/handlers/ide.py

@@ -14,29 +14,30 @@
 
 import time
 
-import jsonrpc  # pylint: disable=import-error
-from twisted.internet import defer  # pylint: disable=import-error
+from ajsonrpc.core import JSONRPC20DispatchException
+
+from platformio.compat import aio_get_running_loop
 
 
-class IDERPC(object):
+class IDERPC:
     def __init__(self):
         self._queue = {}
 
     def send_command(self, sid, command, params):
         if not self._queue.get(sid):
-            raise jsonrpc.exceptions.JSONRPCDispatchException(
+            raise JSONRPC20DispatchException(
                 code=4005, message="PIO Home IDE agent is not started"
             )
         while self._queue[sid]:
-            self._queue[sid].pop().callback(
+            self._queue[sid].pop().set_result(
                 {"id": time.time(), "method": command, "params": params}
             )
 
-    def listen_commands(self, sid=0):
+    async def listen_commands(self, sid=0):
         if sid not in self._queue:
             self._queue[sid] = []
-        self._queue[sid].append(defer.Deferred())
-        return self._queue[sid][-1]
+        self._queue[sid].append(aio_get_running_loop().create_future())
+        return await self._queue[sid][-1]
 
     def open_project(self, sid, project_dir):
         return self.send_command(sid, "open_project", project_dir)

platformio/commands/home/rpc/handlers/misc.py

@@ -15,38 +15,35 @@
 import json
 import time
 
-from twisted.internet import defer, reactor  # pylint: disable=import-error
-
-from platformio import app
+from platformio.cache import ContentCache
 from platformio.commands.home.rpc.handlers.os import OSRPC
+from platformio.compat import aio_create_task
 
 
-class MiscRPC(object):
-    def load_latest_tweets(self, data_url):
-        cache_key = app.ContentCache.key_from_args(data_url, "tweets")
-        cache_valid = "7d"
-        with app.ContentCache() as cc:
+class MiscRPC:
+    async def load_latest_tweets(self, data_url):
+        cache_key = ContentCache.key_from_args(data_url, "tweets")
+        cache_valid = "180d"
+        with ContentCache() as cc:
             cache_data = cc.get(cache_key)
             if cache_data:
                 cache_data = json.loads(cache_data)
                 # automatically update cache in background every 12 hours
                 if cache_data["time"] < (time.time() - (3600 * 12)):
-                    reactor.callLater(
-                        5, self._preload_latest_tweets, data_url, cache_key, cache_valid
+                    aio_create_task(
+                        self._preload_latest_tweets(data_url, cache_key, cache_valid)
                     )
                 return cache_data["result"]
 
-        result = self._preload_latest_tweets(data_url, cache_key, cache_valid)
-        return result
+        return await self._preload_latest_tweets(data_url, cache_key, cache_valid)
 
     @staticmethod
-    @defer.inlineCallbacks
-    def _preload_latest_tweets(data_url, cache_key, cache_valid):
-        result = json.loads((yield OSRPC.fetch_content(data_url)))
-        with app.ContentCache() as cc:
+    async def _preload_latest_tweets(data_url, cache_key, cache_valid):
+        result = json.loads((await OSRPC.fetch_content(data_url)))
+        with ContentCache() as cc:
             cc.set(
                 cache_key,
                 json.dumps({"time": int(time.time()), "result": result}),
                 cache_valid,
             )
-        defer.returnValue(result)
+        return result

platformio/commands/home/rpc/handlers/os.py

@@ -21,17 +21,16 @@ import shutil
 from functools import cmp_to_key
 
 import click
-from twisted.internet import defer  # pylint: disable=import-error
 
-from platformio import app, fs, util
+from platformio import __default_requests_timeout__, fs, util
+from platformio.cache import ContentCache
+from platformio.clients.http import ensure_internet_on
 from platformio.commands.home import helpers
-from platformio.compat import PY2, get_filesystem_encoding
 
 
-class OSRPC(object):
+class OSRPC:
     @staticmethod
-    @defer.inlineCallbacks
-    def fetch_content(uri, data=None, headers=None, cache_valid=None):
+    async def fetch_content(uri, data=None, headers=None, cache_valid=None):
         if not headers:
             headers = {
                 "User-Agent": (
@@ -40,32 +39,36 @@ class OSRPC(object):
                     "Safari/603.3.8"
                 )
             }
-        cache_key = app.ContentCache.key_from_args(uri, data) if cache_valid else None
-        with app.ContentCache() as cc:
+        cache_key = ContentCache.key_from_args(uri, data) if cache_valid else None
+        with ContentCache() as cc:
             if cache_key:
                 result = cc.get(cache_key)
                 if result is not None:
-                    defer.returnValue(result)
+                    return result
 
         # check internet before and resolve issue with 60 seconds timeout
-        util.internet_on(raise_exception=True)
+        ensure_internet_on(raise_exception=True)
 
         session = helpers.requests_session()
         if data:
-            r = yield session.post(uri, data=data, headers=headers)
+            r = await session.post(
+                uri, data=data, headers=headers, timeout=__default_requests_timeout__
+            )
         else:
-            r = yield session.get(uri, headers=headers)
+            r = await session.get(
+                uri, headers=headers, timeout=__default_requests_timeout__
+            )
 
         r.raise_for_status()
         result = r.text
         if cache_valid:
-            with app.ContentCache() as cc:
+            with ContentCache() as cc:
                 cc.set(cache_key, result, cache_valid)
-        defer.returnValue(result)
+        return result
 
-    def request_content(self, uri, data=None, headers=None, cache_valid=None):
+    async def request_content(self, uri, data=None, headers=None, cache_valid=None):
         if uri.startswith("http"):
-            return self.fetch_content(uri, data, headers, cache_valid)
+            return await self.fetch_content(uri, data, headers, cache_valid)
         if os.path.isfile(uri):
             with io.open(uri, encoding="utf-8") as fp:
                 return fp.read()
@@ -77,13 +80,11 @@ class OSRPC(object):
 
     @staticmethod
     def reveal_file(path):
-        return click.launch(
-            path.encode(get_filesystem_encoding()) if PY2 else path, locate=True
-        )
+        return click.launch(path, locate=True)
 
     @staticmethod
     def open_file(path):
-        return click.launch(path.encode(get_filesystem_encoding()) if PY2 else path)
+        return click.launch(path)
 
     @staticmethod
     def is_file(path):
@@ -107,7 +108,7 @@ class OSRPC(object):
 
     @staticmethod
     def copy(src, dst):
-        return shutil.copytree(src, dst)
+        return shutil.copytree(src, dst, symlinks=True)
 
     @staticmethod
     def glob(pathnames, root=None):
@@ -115,7 +116,11 @@ class OSRPC(object):
             pathnames = [pathnames]
         result = set()
         for pathname in pathnames:
-            result |= set(glob.glob(os.path.join(root, pathname) if root else pathname))
+            result |= set(
+                glob.glob(
+                    os.path.join(root, pathname) if root else pathname, recursive=True
+                )
+            )
         return list(result)
 
     @staticmethod

platformio/commands/home/rpc/handlers/piocore.py

@@ -17,17 +17,15 @@ from __future__ import absolute_import
 import json
 import os
 import sys
-from io import BytesIO, StringIO
+from io import StringIO
 
 import click
-import jsonrpc  # pylint: disable=import-error
-from twisted.internet import defer  # pylint: disable=import-error
-from twisted.internet import threads  # pylint: disable=import-error
-from twisted.internet import utils  # pylint: disable=import-error
+from ajsonrpc.core import JSONRPC20DispatchException
+from starlette.concurrency import run_in_threadpool
 
-from platformio import __main__, __version__, fs
+from platformio import __main__, __version__, fs, proc
 from platformio.commands.home import helpers
-from platformio.compat import PY2, get_filesystem_encoding, is_bytes, string_types
+from platformio.compat import get_locale_encoding, is_bytes
 
 try:
     from thread import get_ident as thread_get_ident
@@ -46,7 +44,7 @@ class MultiThreadingStdStream(object):
 
     def _ensure_thread_buffer(self, thread_id):
         if thread_id not in self._buffers:
-            self._buffers[thread_id] = BytesIO() if PY2 else StringIO()
+            self._buffers[thread_id] = StringIO()
 
     def write(self, value):
         thread_id = thread_get_ident()
@@ -59,14 +57,14 @@ class MultiThreadingStdStream(object):
         result = ""
         try:
             result = self.getvalue()
-            self.truncate(0)
             self.seek(0)
+            self.truncate(0)
         except AttributeError:
             pass
         return result
 
 
-class PIOCoreRPC(object):
+class PIOCoreRPC:
     @staticmethod
     def version():
         return __version__
@@ -81,43 +79,44 @@ class PIOCoreRPC(object):
         sys.stderr = PIOCoreRPC.thread_stderr
 
     @staticmethod
-    def call(args, options=None):
-        return defer.maybeDeferred(PIOCoreRPC._call_generator, args, options)
-
-    @staticmethod
-    @defer.inlineCallbacks
-    def _call_generator(args, options=None):
+    async def call(args, options=None):
         for i, arg in enumerate(args):
-            if isinstance(arg, string_types):
-                args[i] = arg.encode(get_filesystem_encoding()) if PY2 else arg
-            else:
+            if not isinstance(arg, str):
                 args[i] = str(arg)
 
+        options = options or {}
         to_json = "--json-output" in args
 
         try:
-            if args and args[0] == "remote":
-                result = yield PIOCoreRPC._call_subprocess(args, options)
-                defer.returnValue(PIOCoreRPC._process_result(result, to_json))
-            else:
-                result = yield PIOCoreRPC._call_inline(args, options)
-                try:
-                    defer.returnValue(PIOCoreRPC._process_result(result, to_json))
-                except ValueError:
-                    # fall-back to subprocess method
-                    result = yield PIOCoreRPC._call_subprocess(args, options)
-                    defer.returnValue(PIOCoreRPC._process_result(result, to_json))
+            if options.get("force_subprocess"):
+                result = await PIOCoreRPC._call_subprocess(args, options)
+                return PIOCoreRPC._process_result(result, to_json)
+            result = await PIOCoreRPC._call_inline(args, options)
+            try:
+                return PIOCoreRPC._process_result(result, to_json)
+            except ValueError:
+                # fall-back to subprocess method
+                result = await PIOCoreRPC._call_subprocess(args, options)
+                return PIOCoreRPC._process_result(result, to_json)
         except Exception as e:  # pylint: disable=bare-except
-            raise jsonrpc.exceptions.JSONRPCDispatchException(
+            raise JSONRPC20DispatchException(
                 code=4003, message="PIO Core Call Error", data=str(e)
             )
 
     @staticmethod
-    def _call_inline(args, options):
-        PIOCoreRPC.setup_multithreading_std_streams()
-        cwd = (options or {}).get("cwd") or os.getcwd()
+    async def _call_subprocess(args, options):
+        result = await run_in_threadpool(
+            proc.exec_command,
+            [helpers.get_core_fullpath()] + args,
+            cwd=options.get("cwd") or os.getcwd(),
+        )
+        return (result["out"], result["err"], result["returncode"])
 
-        def _thread_task():
+    @staticmethod
+    async def _call_inline(args, options):
+        PIOCoreRPC.setup_multithreading_std_streams()
+
+        def _thread_safe_call(args, cwd):
             with fs.cd(cwd):
                 exit_code = __main__.main(["-c"] + args)
             return (
@@ -126,28 +125,22 @@ class PIOCoreRPC(object):
                 exit_code,
             )
 
-        return threads.deferToThread(_thread_task)
-
-    @staticmethod
-    def _call_subprocess(args, options):
-        cwd = (options or {}).get("cwd") or os.getcwd()
-        return utils.getProcessOutputAndValue(
-            helpers.get_core_fullpath(),
-            args,
-            path=cwd,
-            env={k: v for k, v in os.environ.items() if "%" not in k},
+        return await run_in_threadpool(
+            _thread_safe_call, args=args, cwd=options.get("cwd") or os.getcwd()
         )
 
     @staticmethod
     def _process_result(result, to_json=False):
         out, err, code = result
+        if out and is_bytes(out):
+            out = out.decode(get_locale_encoding())
+        if err and is_bytes(err):
+            err = err.decode(get_locale_encoding())
         text = ("%s\n\n%s" % (out, err)).strip()
         if code != 0:
             raise Exception(text)
         if not to_json:
             return text
-        if is_bytes(out):
-            out = out.decode()
         try:
             return json.loads(out)
         except ValueError as e:

platformio/commands/home/rpc/handlers/project.py

@@ -18,21 +18,20 @@ import os
 import shutil
 import time
 
-import jsonrpc  # pylint: disable=import-error
+from ajsonrpc.core import JSONRPC20DispatchException
 
 from platformio import exception, fs
 from platformio.commands.home.rpc.handlers.app import AppRPC
 from platformio.commands.home.rpc.handlers.piocore import PIOCoreRPC
-from platformio.compat import PY2, get_filesystem_encoding
 from platformio.ide.projectgenerator import ProjectGenerator
-from platformio.managers.platform import PlatformManager
+from platformio.package.manager.platform import PlatformPackageManager
 from platformio.project.config import ProjectConfig
 from platformio.project.exception import ProjectError
 from platformio.project.helpers import get_project_dir, is_platformio_project
 from platformio.project.options import get_config_options_schema
 
 
-class ProjectRPC(object):
+class ProjectRPC:
     @staticmethod
     def config_call(init_kwargs, method, *args):
         assert isinstance(init_kwargs, dict)
@@ -105,7 +104,7 @@ class ProjectRPC(object):
             return (os.path.sep).join(path.split(os.path.sep)[-2:])
 
         result = []
-        pm = PlatformManager()
+        pm = PlatformPackageManager()
         for project_dir in AppRPC.load_state()["storage"]["recentProjects"]:
             if not os.path.isdir(project_dir):
                 continue
@@ -148,8 +147,9 @@ class ProjectRPC(object):
     @staticmethod
     def get_project_examples():
         result = []
-        for manifest in PlatformManager().get_installed():
-            examples_dir = os.path.join(manifest["__pkg_dir"], "examples")
+        pm = PlatformPackageManager()
+        for pkg in pm.get_installed():
+            examples_dir = os.path.join(pkg.path, "examples")
             if not os.path.isdir(examples_dir):
                 continue
             items = []
@@ -172,6 +172,7 @@ class ProjectRPC(object):
                         "description": project_description,
                     }
                 )
+            manifest = pm.load_manifest(pkg)
             result.append(
                 {
                     "platform": {
@@ -183,7 +184,7 @@ class ProjectRPC(object):
             )
         return sorted(result, key=lambda data: data["platform"]["title"])
 
-    def init(self, board, framework, project_dir):
+    async def init(self, board, framework, project_dir):
         assert project_dir
         state = AppRPC.load_state()
         if not os.path.isdir(project_dir):
@@ -196,12 +197,13 @@ class ProjectRPC(object):
             and state["storage"]["coreCaller"] in ProjectGenerator.get_supported_ides()
         ):
             args.extend(["--ide", state["storage"]["coreCaller"]])
-        d = PIOCoreRPC.call(args, options={"cwd": project_dir})
-        d.addCallback(self._generate_project_main, project_dir, framework)
-        return d
+        await PIOCoreRPC.call(
+            args, options={"cwd": project_dir, "force_subprocess": True}
+        )
+        return self._generate_project_main(project_dir, board, framework)
 
     @staticmethod
-    def _generate_project_main(_, project_dir, framework):
+    def _generate_project_main(project_dir, board, framework):
         main_content = None
         if framework == "arduino":
             main_content = "\n".join(
@@ -236,39 +238,51 @@ class ProjectRPC(object):
             )
         if not main_content:
             return project_dir
+
+        is_cpp_project = True
+        pm = PlatformPackageManager()
+        try:
+            board = pm.board_config(board)
+            platforms = board.get("platforms", board.get("platform"))
+            if not isinstance(platforms, list):
+                platforms = [platforms]
+            c_based_platforms = ["intel_mcs51", "ststm8"]
+            is_cpp_project = not (set(platforms) & set(c_based_platforms))
+        except exception.PlatformioException:
+            pass
+
         with fs.cd(project_dir):
             config = ProjectConfig()
             src_dir = config.get_optional_dir("src")
-            main_path = os.path.join(src_dir, "main.cpp")
+            main_path = os.path.join(
+                src_dir, "main.%s" % ("cpp" if is_cpp_project else "c")
+            )
             if os.path.isfile(main_path):
                 return project_dir
             if not os.path.isdir(src_dir):
                 os.makedirs(src_dir)
-            with open(main_path, "w") as fp:
+            with open(main_path, mode="w", encoding="utf8") as fp:
                 fp.write(main_content.strip())
         return project_dir
 
-    def import_arduino(self, board, use_arduino_libs, arduino_project_dir):
+    @staticmethod
+    async def import_arduino(board, use_arduino_libs, arduino_project_dir):
         board = str(board)
-        if arduino_project_dir and PY2:
-            arduino_project_dir = arduino_project_dir.encode(get_filesystem_encoding())
         # don't import PIO Project
         if is_platformio_project(arduino_project_dir):
             return arduino_project_dir
 
         is_arduino_project = any(
-            [
-                os.path.isfile(
-                    os.path.join(
-                        arduino_project_dir,
-                        "%s.%s" % (os.path.basename(arduino_project_dir), ext),
-                    )
+            os.path.isfile(
+                os.path.join(
+                    arduino_project_dir,
+                    "%s.%s" % (os.path.basename(arduino_project_dir), ext),
                 )
-                for ext in ("ino", "pde")
-            ]
+            )
+            for ext in ("ino", "pde")
         )
         if not is_arduino_project:
-            raise jsonrpc.exceptions.JSONRPCDispatchException(
+            raise JSONRPC20DispatchException(
                 code=4000, message="Not an Arduino project: %s" % arduino_project_dir
             )
 
@@ -289,31 +303,28 @@ class ProjectRPC(object):
             and state["storage"]["coreCaller"] in ProjectGenerator.get_supported_ides()
         ):
             args.extend(["--ide", state["storage"]["coreCaller"]])
-        d = PIOCoreRPC.call(args, options={"cwd": project_dir})
-        d.addCallback(self._finalize_arduino_import, project_dir, arduino_project_dir)
-        return d
-
-    @staticmethod
-    def _finalize_arduino_import(_, project_dir, arduino_project_dir):
+        await PIOCoreRPC.call(
+            args, options={"cwd": project_dir, "force_subprocess": True}
+        )
         with fs.cd(project_dir):
             config = ProjectConfig()
             src_dir = config.get_optional_dir("src")
             if os.path.isdir(src_dir):
                 fs.rmtree(src_dir)
-            shutil.copytree(arduino_project_dir, src_dir)
+            shutil.copytree(arduino_project_dir, src_dir, symlinks=True)
         return project_dir
 
     @staticmethod
-    def import_pio(project_dir):
+    async def import_pio(project_dir):
         if not project_dir or not is_platformio_project(project_dir):
-            raise jsonrpc.exceptions.JSONRPCDispatchException(
+            raise JSONRPC20DispatchException(
                 code=4001, message="Not an PlatformIO project: %s" % project_dir
             )
         new_project_dir = os.path.join(
             AppRPC.load_state()["storage"]["projectsDir"],
             time.strftime("%y%m%d-%H%M%S-") + os.path.basename(project_dir),
         )
-        shutil.copytree(project_dir, new_project_dir)
+        shutil.copytree(project_dir, new_project_dir, symlinks=True)
 
         state = AppRPC.load_state()
         args = ["init"]
@@ -322,6 +333,7 @@ class ProjectRPC(object):
             and state["storage"]["coreCaller"] in ProjectGenerator.get_supported_ides()
         ):
             args.extend(["--ide", state["storage"]["coreCaller"]])
-        d = PIOCoreRPC.call(args, options={"cwd": new_project_dir})
-        d.addCallback(lambda _: new_project_dir)
-        return d
+        await PIOCoreRPC.call(
+            args, options={"cwd": new_project_dir, "force_subprocess": True}
+        )
+        return new_project_dir

platformio/commands/home/rpc/server.py

@@ -12,90 +12,86 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pylint: disable=import-error
-
 import click
-import jsonrpc
-from autobahn.twisted.websocket import WebSocketServerFactory, WebSocketServerProtocol
-from jsonrpc.exceptions import JSONRPCDispatchException
-from twisted.internet import defer, reactor
+from ajsonrpc.dispatcher import Dispatcher
+from ajsonrpc.manager import AsyncJSONRPCResponseManager
+from starlette.endpoints import WebSocketEndpoint
 
-from platformio.compat import PY2, dump_json_to_unicode, is_bytes
+from platformio.compat import aio_create_task, aio_get_running_loop
+from platformio.proc import force_exit
 
 
-class JSONRPCServerProtocol(WebSocketServerProtocol):
-    def onOpen(self):
-        self.factory.connection_nums += 1
-        if self.factory.shutdown_timer:
-            self.factory.shutdown_timer.cancel()
-            self.factory.shutdown_timer = None
+class JSONRPCServerFactoryBase:
 
-    def onClose(self, wasClean, code, reason):  # pylint: disable=unused-argument
-        self.factory.connection_nums -= 1
-        if self.factory.connection_nums == 0:
-            self.factory.shutdownByTimeout()
-
-    def onMessage(self, payload, isBinary):  # pylint: disable=unused-argument
-        # click.echo("> %s" % payload)
-        response = jsonrpc.JSONRPCResponseManager.handle(
-            payload, self.factory.dispatcher
-        ).data
-        # if error
-        if "result" not in response:
-            self.sendJSONResponse(response)
-            return None
-
-        d = defer.maybeDeferred(lambda: response["result"])
-        d.addCallback(self._callback, response)
-        d.addErrback(self._errback, response)
-
-        return None
-
-    def _callback(self, result, response):
-        response["result"] = result
-        self.sendJSONResponse(response)
-
-    def _errback(self, failure, response):
-        if isinstance(failure.value, JSONRPCDispatchException):
-            e = failure.value
-        else:
-            e = JSONRPCDispatchException(code=4999, message=failure.getErrorMessage())
-        del response["result"]
-        response["error"] = e.error._data  # pylint: disable=protected-access
-        self.sendJSONResponse(response)
-
-    def sendJSONResponse(self, response):
-        # click.echo("< %s" % response)
-        if "error" in response:
-            click.secho("Error: %s" % response["error"], fg="red", err=True)
-        response = dump_json_to_unicode(response)
-        if not PY2 and not is_bytes(response):
-            response = response.encode("utf-8")
-        self.sendMessage(response)
-
-
-class JSONRPCServerFactory(WebSocketServerFactory):
-
-    protocol = JSONRPCServerProtocol
     connection_nums = 0
-    shutdown_timer = 0
+    shutdown_timer = None
 
     def __init__(self, shutdown_timeout=0):
-        super(JSONRPCServerFactory, self).__init__()
         self.shutdown_timeout = shutdown_timeout
-        self.dispatcher = jsonrpc.Dispatcher()
+        self.manager = AsyncJSONRPCResponseManager(
+            Dispatcher(), is_server_error_verbose=True
+        )
 
-    def shutdownByTimeout(self):
+    def __call__(self, *args, **kwargs):
+        raise NotImplementedError
+
+    def addObjectHandler(self, handler, namespace):
+        self.manager.dispatcher.add_object(handler, prefix="%s." % namespace)
+
+    def on_client_connect(self):
+        self.connection_nums += 1
+        if self.shutdown_timer:
+            self.shutdown_timer.cancel()
+            self.shutdown_timer = None
+
+    def on_client_disconnect(self):
+        self.connection_nums -= 1
+        if self.connection_nums < 1:
+            self.connection_nums = 0
+
+        if self.connection_nums == 0:
+            self.shutdown_by_timeout()
+
+    async def on_shutdown(self):
+        pass
+
+    def shutdown_by_timeout(self):
         if self.shutdown_timeout < 1:
             return
 
         def _auto_shutdown_server():
             click.echo("Automatically shutdown server on timeout")
-            reactor.stop()
+            force_exit()
 
-        self.shutdown_timer = reactor.callLater(
+        self.shutdown_timer = aio_get_running_loop().call_later(
             self.shutdown_timeout, _auto_shutdown_server
         )
 
-    def addHandler(self, handler, namespace):
-        self.dispatcher.build_method_map(handler, prefix="%s." % namespace)
+
+class WebSocketJSONRPCServerFactory(JSONRPCServerFactoryBase):
+    def __call__(self, *args, **kwargs):
+        ws = WebSocketJSONRPCServer(*args, **kwargs)
+        ws.factory = self
+        return ws
+
+
+class WebSocketJSONRPCServer(WebSocketEndpoint):
+    encoding = "text"
+    factory: WebSocketJSONRPCServerFactory = None
+
+    async def on_connect(self, websocket):
+        await websocket.accept()
+        self.factory.on_client_connect()  # pylint: disable=no-member
+
+    async def on_receive(self, websocket, data):
+        aio_create_task(self._handle_rpc(websocket, data))
+
+    async def on_disconnect(self, websocket, close_code):
+        self.factory.on_client_disconnect()  # pylint: disable=no-member
+
+    async def _handle_rpc(self, websocket, data):
+        # pylint: disable=no-member
+        response = await self.factory.manager.get_response_for_payload(data)
+        if response.error:
+            click.secho("Error: %s" % response.error.data, fg="red", err=True)
+        await websocket.send_text(self.factory.manager.serialize(response.body))

platformio/commands/home/run.py

@@ -0,0 +1,99 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+import os
+from urllib.parse import urlparse
+
+import click
+import uvicorn
+from starlette.applications import Starlette
+from starlette.middleware import Middleware
+from starlette.responses import PlainTextResponse
+from starlette.routing import Mount, Route, WebSocketRoute
+from starlette.staticfiles import StaticFiles
+from starlette.status import HTTP_403_FORBIDDEN
+
+from platformio.commands.home.rpc.handlers.account import AccountRPC
+from platformio.commands.home.rpc.handlers.app import AppRPC
+from platformio.commands.home.rpc.handlers.ide import IDERPC
+from platformio.commands.home.rpc.handlers.misc import MiscRPC
+from platformio.commands.home.rpc.handlers.os import OSRPC
+from platformio.commands.home.rpc.handlers.piocore import PIOCoreRPC
+from platformio.commands.home.rpc.handlers.project import ProjectRPC
+from platformio.commands.home.rpc.server import WebSocketJSONRPCServerFactory
+from platformio.compat import aio_get_running_loop
+from platformio.exception import PlatformioException
+from platformio.package.manager.core import get_core_package_dir
+from platformio.proc import force_exit
+
+
+class ShutdownMiddleware:
+    def __init__(self, app):
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] == "http" and b"__shutdown__" in scope.get("query_string", {}):
+            await shutdown_server()
+        await self.app(scope, receive, send)
+
+
+async def shutdown_server(_=None):
+    aio_get_running_loop().call_later(0.5, force_exit)
+    return PlainTextResponse("Server has been shutdown!")
+
+
+async def protected_page(_):
+    return PlainTextResponse(
+        "Protected PlatformIO Home session", status_code=HTTP_403_FORBIDDEN
+    )
+
+
+def run_server(host, port, no_open, shutdown_timeout, home_url):
+    contrib_dir = get_core_package_dir("contrib-piohome")
+    if not os.path.isdir(contrib_dir):
+        raise PlatformioException("Invalid path to PIO Home Contrib")
+
+    ws_rpc_factory = WebSocketJSONRPCServerFactory(shutdown_timeout)
+    ws_rpc_factory.addObjectHandler(AccountRPC(), namespace="account")
+    ws_rpc_factory.addObjectHandler(AppRPC(), namespace="app")
+    ws_rpc_factory.addObjectHandler(IDERPC(), namespace="ide")
+    ws_rpc_factory.addObjectHandler(MiscRPC(), namespace="misc")
+    ws_rpc_factory.addObjectHandler(OSRPC(), namespace="os")
+    ws_rpc_factory.addObjectHandler(PIOCoreRPC(), namespace="core")
+    ws_rpc_factory.addObjectHandler(ProjectRPC(), namespace="project")
+
+    path = urlparse(home_url).path
+    routes = [
+        WebSocketRoute(path + "wsrpc", ws_rpc_factory, name="wsrpc"),
+        Route(path + "__shutdown__", shutdown_server, methods=["POST"]),
+        Mount(path, StaticFiles(directory=contrib_dir, html=True), name="static"),
+    ]
+    if path != "/":
+        routes.append(Route("/", protected_page))
+
+    uvicorn.run(
+        Starlette(
+            middleware=[Middleware(ShutdownMiddleware)],
+            routes=routes,
+            on_startup=[
+                lambda: click.echo(
+                    "PIO Home has been started. Press Ctrl+C to shutdown."
+                ),
+                lambda: None if no_open else click.launch(home_url),
+            ],
+        ),
+        host=host,
+        port=port,
+        log_level="warning",
+    )

platformio/commands/lib/command.py

@@ -14,22 +14,21 @@
 
 # pylint: disable=too-many-branches, too-many-locals
 
+import json
 import os
 import time
 
 import click
-import semantic_version
 from tabulate import tabulate
 
 from platformio import exception, fs, util
 from platformio.commands import PlatformioCLI
-from platformio.compat import dump_json_to_unicode
-from platformio.managers.lib import LibraryManager, get_builtin_libs, is_builtin_lib
-from platformio.package.manifest.parser import ManifestParserFactory
-from platformio.package.manifest.schema import ManifestSchema
+from platformio.commands.lib.helpers import get_builtin_libs, save_project_libdeps
+from platformio.package.exception import NotGlobalLibDir, UnknownPackageError
+from platformio.package.manager.library import LibraryPackageManager
+from platformio.package.meta import PackageItem, PackageSpec
 from platformio.proc import is_ci
 from platformio.project.config import ProjectConfig
-from platformio.project.exception import InvalidProjectConfError
 from platformio.project.helpers import get_project_dir, is_platformio_project
 
 try:
@@ -47,7 +46,7 @@ def get_project_global_lib_dir():
     return ProjectConfig.get_instance().get_optional_dir("globallib")
 
 
-@click.group(short_help="Library Manager")
+@click.group(short_help="Library manager")
 @click.option(
     "-d",
     "--storage-dir",
@@ -94,7 +93,7 @@ def cli(ctx, **options):
             )
 
     if not storage_dirs:
-        raise exception.NotGlobalLibDir(
+        raise NotGlobalLibDir(
             get_project_dir(), get_project_global_lib_dir(), ctx.invoked_subcommand
         )
 
@@ -126,89 +125,99 @@ def cli(ctx, **options):
 @cli.command("install", short_help="Install library")
 @click.argument("libraries", required=False, nargs=-1, metavar="[LIBRARY...]")
 @click.option(
-    "--save",
+    "--save/--no-save",
     is_flag=True,
-    help="Save installed libraries into the `platformio.ini` dependency list",
+    default=True,
+    help="Save installed libraries into the `platformio.ini` dependency list"
+    " (enabled by default)",
 )
 @click.option("-s", "--silent", is_flag=True, help="Suppress progress reporting")
 @click.option(
-    "--interactive", is_flag=True, help="Allow to make a choice for all prompts"
+    "--interactive",
+    is_flag=True,
+    help="Deprecated! Please use a strict dependency specification (owner/libname)",
 )
 @click.option(
     "-f", "--force", is_flag=True, help="Reinstall/redownload library if exists"
 )
 @click.pass_context
-def lib_install(  # pylint: disable=too-many-arguments
+def lib_install(  # pylint: disable=too-many-arguments,unused-argument
     ctx, libraries, save, silent, interactive, force
 ):
     storage_dirs = ctx.meta[CTX_META_STORAGE_DIRS_KEY]
     storage_libdeps = ctx.meta.get(CTX_META_STORAGE_LIBDEPS_KEY, [])
 
-    installed_manifests = {}
+    installed_pkgs = {}
     for storage_dir in storage_dirs:
         if not silent and (libraries or storage_dir in storage_libdeps):
             print_storage_header(storage_dirs, storage_dir)
-        lm = LibraryManager(storage_dir)
-        if libraries:
-            for library in libraries:
-                pkg_dir = lm.install(
-                    library, silent=silent, interactive=interactive, force=force
-                )
-                installed_manifests[library] = lm.load_manifest(pkg_dir)
-        elif storage_dir in storage_libdeps:
-            builtin_lib_storages = None
-            for library in storage_libdeps[storage_dir]:
-                try:
-                    pkg_dir = lm.install(
-                        library, silent=silent, interactive=interactive, force=force
-                    )
-                    installed_manifests[library] = lm.load_manifest(pkg_dir)
-                except exception.LibNotFound as e:
-                    if builtin_lib_storages is None:
-                        builtin_lib_storages = get_builtin_libs()
-                    if not silent or not is_builtin_lib(builtin_lib_storages, library):
-                        click.secho("Warning! %s" % e, fg="yellow")
+        lm = LibraryPackageManager(storage_dir)
 
-    if not save or not libraries:
-        return
+        if libraries:
+            installed_pkgs = {
+                library: lm.install(library, silent=silent, force=force)
+                for library in libraries
+            }
+
+        elif storage_dir in storage_libdeps:
+            for library in storage_libdeps[storage_dir]:
+                lm.install(library, silent=silent, force=force)
+
+    if save and installed_pkgs:
+        _save_deps(ctx, installed_pkgs)
+
+
+def _save_deps(ctx, pkgs, action="add"):
+    specs = []
+    for library, pkg in pkgs.items():
+        spec = PackageSpec(library)
+        if spec.external:
+            specs.append(spec)
+        else:
+            specs.append(
+                PackageSpec(
+                    owner=pkg.metadata.spec.owner,
+                    name=pkg.metadata.spec.name,
+                    requirements=spec.requirements
+                    or (
+                        ("^%s" % pkg.metadata.version)
+                        if not pkg.metadata.version.build
+                        else pkg.metadata.version
+                    ),
+                )
+            )
 
     input_dirs = ctx.meta.get(CTX_META_INPUT_DIRS_KEY, [])
     project_environments = ctx.meta[CTX_META_PROJECT_ENVIRONMENTS_KEY]
     for input_dir in input_dirs:
-        config = ProjectConfig.get_instance(os.path.join(input_dir, "platformio.ini"))
-        config.validate(project_environments)
-        for env in config.envs():
-            if project_environments and env not in project_environments:
-                continue
-            config.expand_interpolations = False
-            try:
-                lib_deps = config.get("env:" + env, "lib_deps")
-            except InvalidProjectConfError:
-                lib_deps = []
-            for library in libraries:
-                if library in lib_deps:
-                    continue
-                manifest = installed_manifests[library]
-                try:
-                    assert library.lower() == manifest["name"].lower()
-                    assert semantic_version.Version(manifest["version"])
-                    lib_deps.append("{name}@^{version}".format(**manifest))
-                except (AssertionError, ValueError):
-                    lib_deps.append(library)
-            config.set("env:" + env, "lib_deps", lib_deps)
-            config.save()
+        if not is_platformio_project(input_dir):
+            continue
+        save_project_libdeps(input_dir, specs, project_environments, action=action)
 
 
-@cli.command("uninstall", short_help="Uninstall libraries")
+@cli.command("uninstall", short_help="Remove libraries")
 @click.argument("libraries", nargs=-1, metavar="[LIBRARY...]")
+@click.option(
+    "--save/--no-save",
+    is_flag=True,
+    default=True,
+    help="Remove libraries from the `platformio.ini` dependency list and save changes"
+    " (enabled by default)",
+)
+@click.option("-s", "--silent", is_flag=True, help="Suppress progress reporting")
 @click.pass_context
-def lib_uninstall(ctx, libraries):
+def lib_uninstall(ctx, libraries, save, silent):
     storage_dirs = ctx.meta[CTX_META_STORAGE_DIRS_KEY]
+    uninstalled_pkgs = {}
     for storage_dir in storage_dirs:
         print_storage_header(storage_dirs, storage_dir)
-        lm = LibraryManager(storage_dir)
-        for library in libraries:
-            lm.uninstall(library)
+        lm = LibraryPackageManager(storage_dir)
+        uninstalled_pkgs = {
+            library: lm.uninstall(library, silent=silent) for library in libraries
+        }
+
+    if save and uninstalled_pkgs:
+        _save_deps(ctx, uninstalled_pkgs, action="remove")
 
 
 @cli.command("update", short_help="Update installed libraries")
@@ -222,46 +231,62 @@ def lib_uninstall(ctx, libraries):
 @click.option(
     "--dry-run", is_flag=True, help="Do not update, only check for the new versions"
 )
+@click.option("-s", "--silent", is_flag=True, help="Suppress progress reporting")
 @click.option("--json-output", is_flag=True)
 @click.pass_context
-def lib_update(ctx, libraries, only_check, dry_run, json_output):
+def lib_update(  # pylint: disable=too-many-arguments
+    ctx, libraries, only_check, dry_run, silent, json_output
+):
     storage_dirs = ctx.meta[CTX_META_STORAGE_DIRS_KEY]
     only_check = dry_run or only_check
     json_result = {}
     for storage_dir in storage_dirs:
         if not json_output:
             print_storage_header(storage_dirs, storage_dir)
-        lm = LibraryManager(storage_dir)
-
-        _libraries = libraries
-        if not _libraries:
-            _libraries = [manifest["__pkg_dir"] for manifest in lm.get_installed()]
+        lib_deps = ctx.meta.get(CTX_META_STORAGE_LIBDEPS_KEY, {}).get(storage_dir, [])
+        lm = LibraryPackageManager(storage_dir)
+        _libraries = libraries or lib_deps or lm.get_installed()
 
         if only_check and json_output:
             result = []
             for library in _libraries:
-                pkg_dir = library if os.path.isdir(library) else None
-                requirements = None
-                url = None
-                if not pkg_dir:
-                    name, requirements, url = lm.parse_pkg_uri(library)
-                    pkg_dir = lm.get_package_dir(name, requirements, url)
-                if not pkg_dir:
+                spec = None
+                pkg = None
+                if isinstance(library, PackageItem):
+                    pkg = library
+                else:
+                    spec = PackageSpec(library)
+                    pkg = lm.get_package(spec)
+                if not pkg:
                     continue
-                latest = lm.outdated(pkg_dir, requirements)
-                if not latest:
+                outdated = lm.outdated(pkg, spec)
+                if not outdated.is_outdated(allow_incompatible=True):
                     continue
-                manifest = lm.load_manifest(pkg_dir)
-                manifest["versionLatest"] = latest
+                manifest = lm.legacy_load_manifest(pkg)
+                manifest["versionWanted"] = (
+                    str(outdated.wanted) if outdated.wanted else None
+                )
+                manifest["versionLatest"] = (
+                    str(outdated.latest) if outdated.latest else None
+                )
                 result.append(manifest)
             json_result[storage_dir] = result
         else:
             for library in _libraries:
-                lm.update(library, only_check=only_check)
+                to_spec = (
+                    None if isinstance(library, PackageItem) else PackageSpec(library)
+                )
+                try:
+                    lm.update(
+                        library, to_spec=to_spec, only_check=only_check, silent=silent
+                    )
+                except UnknownPackageError as e:
+                    if library not in lib_deps:
+                        raise e
 
     if json_output:
         return click.echo(
-            dump_json_to_unicode(
+            json.dumps(
                 json_result[storage_dirs[0]] if len(storage_dirs) == 1 else json_result
             )
         )
@@ -278,8 +303,8 @@ def lib_list(ctx, json_output):
     for storage_dir in storage_dirs:
         if not json_output:
             print_storage_header(storage_dirs, storage_dir)
-        lm = LibraryManager(storage_dir)
-        items = lm.get_installed()
+        lm = LibraryPackageManager(storage_dir)
+        items = lm.legacy_get_installed()
         if json_output:
             json_result[storage_dir] = items
         elif items:
@@ -290,7 +315,7 @@ def lib_list(ctx, json_output):
 
     if json_output:
         return click.echo(
-            dump_json_to_unicode(
+            json.dumps(
                 json_result[storage_dirs[0]] if len(storage_dirs) == 1 else json_result
             )
         )
@@ -303,6 +328,7 @@ def lib_list(ctx, json_output):
 @click.option("--json-output", is_flag=True)
 @click.option("--page", type=click.INT, default=1)
 @click.option("--id", multiple=True)
+@click.option("-o", "--owner", multiple=True)
 @click.option("-n", "--name", multiple=True)
 @click.option("-a", "--author", multiple=True)
 @click.option("-k", "--keyword", multiple=True)
@@ -315,6 +341,7 @@ def lib_list(ctx, json_output):
     help="Do not prompt, automatically paginate with delay",
 )
 def lib_search(query, json_output, page, noninteractive, **filters):
+    regclient = LibraryPackageManager().get_registry_client_instance()
     if not query:
         query = []
     if not isinstance(query, list):
@@ -324,12 +351,15 @@ def lib_search(query, json_output, page, noninteractive, **filters):
         for value in values:
             query.append('%s:"%s"' % (key, value))
 
-    result = util.get_api_result(
-        "/v2/lib/search", dict(query=" ".join(query), page=page), cache_valid="1d"
+    result = regclient.fetch_json_data(
+        "get",
+        "/v2/lib/search",
+        params=dict(query=" ".join(query), page=page),
+        cache_valid="1d",
     )
 
     if json_output:
-        click.echo(dump_json_to_unicode(result))
+        click.echo(json.dumps(result))
         return
 
     if result["total"] == 0:
@@ -374,9 +404,10 @@ def lib_search(query, json_output, page, noninteractive, **filters):
             time.sleep(5)
         elif not click.confirm("Show next libraries?"):
             break
-        result = util.get_api_result(
+        result = regclient.fetch_json_data(
+            "get",
             "/v2/lib/search",
-            {"query": " ".join(query), "page": int(result["page"]) + 1},
+            params=dict(query=" ".join(query), page=int(result["page"]) + 1),
             cache_valid="1d",
         )
 
@@ -387,7 +418,7 @@ def lib_search(query, json_output, page, noninteractive, **filters):
 def lib_builtin(storage, json_output):
     items = get_builtin_libs(storage)
     if json_output:
-        return click.echo(dump_json_to_unicode(items))
+        return click.echo(json.dumps(items))
 
     for storage_ in items:
         if not storage_["items"]:
@@ -406,23 +437,20 @@ def lib_builtin(storage, json_output):
 @click.argument("library", metavar="[LIBRARY]")
 @click.option("--json-output", is_flag=True)
 def lib_show(library, json_output):
-    lm = LibraryManager()
-    name, requirements, _ = lm.parse_pkg_uri(library)
-    lib_id = lm.search_lib_id(
-        {"name": name, "requirements": requirements},
-        silent=json_output,
-        interactive=not json_output,
-    )
-    lib = util.get_api_result("/lib/info/%d" % lib_id, cache_valid="1d")
+    lm = LibraryPackageManager()
+    lib_id = lm.reveal_registry_package_id(library, silent=json_output)
+    regclient = lm.get_registry_client_instance()
+    lib = regclient.fetch_json_data("get", "/v2/lib/info/%d" % lib_id, cache_valid="1h")
     if json_output:
-        return click.echo(dump_json_to_unicode(lib))
+        return click.echo(json.dumps(lib))
 
-    click.secho(lib["name"], fg="cyan")
-    click.echo("=" * len(lib["name"]))
-    click.secho("#ID: %d" % lib["id"], bold=True)
+    title = "{ownername}/{name}".format(**lib)
+    click.secho(title, fg="cyan")
+    click.echo("=" * len(title))
     click.echo(lib["description"])
     click.echo()
 
+    click.secho("ID: %d" % lib["id"])
     click.echo(
         "Version: %s, released %s"
         % (
@@ -445,7 +473,7 @@ def lib_show(library, json_output):
     for author in lib.get("authors", []):
         _data = []
         for key in ("name", "email", "url", "maintainer"):
-            if not author[key]:
+            if not author.get(key):
                 continue
             if key == "email":
                 _data.append("<%s>" % author[key])
@@ -495,32 +523,22 @@ def lib_show(library, json_output):
     return True
 
 
-@cli.command("register", short_help="Register a new library")
+@cli.command("register", short_help="Deprecated")
 @click.argument("config_url")
-def lib_register(config_url):
-    if not config_url.startswith("http://") and not config_url.startswith("https://"):
-        raise exception.InvalidLibConfURL(config_url)
-
-    # Validate manifest
-    ManifestSchema().load_manifest(
-        ManifestParserFactory.new_from_url(config_url).as_dict()
+def lib_register(config_url):  # pylint: disable=unused-argument
+    raise exception.UserSideException(
+        "This command is deprecated. Please use `pio package publish` command."
     )
 
-    result = util.get_api_result("/lib/register", data=dict(config_url=config_url))
-    if "message" in result and result["message"]:
-        click.secho(
-            result["message"],
-            fg="green" if "successed" in result and result["successed"] else "red",
-        )
-
 
 @cli.command("stats", short_help="Library Registry Statistics")
 @click.option("--json-output", is_flag=True)
 def lib_stats(json_output):
-    result = util.get_api_result("/lib/stats", cache_valid="1h")
+    regclient = LibraryPackageManager().get_registry_client_instance()
+    result = regclient.fetch_json_data("get", "/v2/lib/stats", cache_valid="1h")
 
     if json_output:
-        return click.echo(dump_json_to_unicode(result))
+        return click.echo(json.dumps(result))
 
     for key in ("updated", "added"):
         tabular_data = [

platformio/commands/lib/helpers.py

@@ -0,0 +1,102 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+import os
+
+from platformio.compat import ci_strings_are_equal
+from platformio.package.manager.platform import PlatformPackageManager
+from platformio.package.meta import PackageSpec
+from platformio.platform.factory import PlatformFactory
+from platformio.project.config import ProjectConfig
+from platformio.project.exception import InvalidProjectConfError
+
+
+def get_builtin_libs(storage_names=None):
+    # pylint: disable=import-outside-toplevel
+    from platformio.package.manager.library import LibraryPackageManager
+
+    items = []
+    storage_names = storage_names or []
+    pm = PlatformPackageManager()
+    for pkg in pm.get_installed():
+        p = PlatformFactory.new(pkg)
+        for storage in p.get_lib_storages():
+            if storage_names and storage["name"] not in storage_names:
+                continue
+            lm = LibraryPackageManager(storage["path"])
+            items.append(
+                {
+                    "name": storage["name"],
+                    "path": storage["path"],
+                    "items": lm.legacy_get_installed(),
+                }
+            )
+    return items
+
+
+def is_builtin_lib(name, storages=None):
+    for storage in storages or get_builtin_libs():
+        for lib in storage["items"]:
+            if lib.get("name") == name:
+                return True
+    return False
+
+
+def ignore_deps_by_specs(deps, specs):
+    result = []
+    for dep in deps:
+        depspec = PackageSpec(dep)
+        if depspec.external:
+            result.append(dep)
+            continue
+        ignore_conditions = []
+        for spec in specs:
+            if depspec.owner:
+                ignore_conditions.append(
+                    ci_strings_are_equal(depspec.owner, spec.owner)
+                    and ci_strings_are_equal(depspec.name, spec.name)
+                )
+            else:
+                ignore_conditions.append(ci_strings_are_equal(depspec.name, spec.name))
+        if not any(ignore_conditions):
+            result.append(dep)
+    return result
+
+
+def save_project_libdeps(project_dir, specs, environments=None, action="add"):
+    config = ProjectConfig.get_instance(os.path.join(project_dir, "platformio.ini"))
+    config.validate(environments)
+    for env in config.envs():
+        if environments and env not in environments:
+            continue
+        config.expand_interpolations = False
+        candidates = []
+        try:
+            candidates = ignore_deps_by_specs(
+                config.get("env:" + env, "lib_deps"), specs
+            )
+        except InvalidProjectConfError:
+            pass
+        if action == "add":
+            candidates.extend(spec.as_dependency() for spec in specs)
+        if candidates:
+            result = []
+            for item in candidates:
+                item = item.strip()
+                if item and item not in result:
+                    result.append(item)
+            config.set("env:" + env, "lib_deps", result)
+        elif config.has_option("env:" + env, "lib_deps"):
+            config.remove_option("env:" + env, "lib_deps")
+    config.save()

platformio/commands/org.py

@@ -0,0 +1,165 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+# pylint: disable=unused-argument
+
+import json
+
+import click
+from tabulate import tabulate
+
+from platformio.clients.account import AccountClient
+from platformio.commands.account import validate_email, validate_username
+
+
+@click.group("org", short_help="Manage organizations")
+def cli():
+    pass
+
+
+def validate_orgname(value):
+    return validate_username(value, "Organization name")
+
+
+@cli.command("create", short_help="Create a new organization")
+@click.argument(
+    "orgname",
+    callback=lambda _, __, value: validate_orgname(value),
+)
+@click.option(
+    "--email", callback=lambda _, __, value: validate_email(value) if value else value
+)
+@click.option(
+    "--displayname",
+)
+def org_create(orgname, email, displayname):
+    client = AccountClient()
+    client.create_org(orgname, email, displayname)
+    return click.secho(
+        "The organization `%s` has been successfully created." % orgname,
+        fg="green",
+    )
+
+
+@cli.command("list", short_help="List organizations and their members")
+@click.option("--json-output", is_flag=True)
+def org_list(json_output):
+    client = AccountClient()
+    orgs = client.list_orgs()
+    if json_output:
+        return click.echo(json.dumps(orgs))
+    if not orgs:
+        return click.echo("You do not have any organization")
+    for org in orgs:
+        click.echo()
+        click.secho(org.get("orgname"), fg="cyan")
+        click.echo("-" * len(org.get("orgname")))
+        data = []
+        if org.get("displayname"):
+            data.append(("Display Name:", org.get("displayname")))
+        if org.get("email"):
+            data.append(("Email:", org.get("email")))
+        data.append(
+            (
+                "Owners:",
+                ", ".join((owner.get("username") for owner in org.get("owners"))),
+            )
+        )
+        click.echo(tabulate(data, tablefmt="plain"))
+    return click.echo()
+
+
+@cli.command("update", short_help="Update organization")
+@click.argument("cur_orgname")
+@click.option(
+    "--orgname",
+    callback=lambda _, __, value: validate_orgname(value),
+    help="A new orgname",
+)
+@click.option("--email")
+@click.option("--displayname")
+def org_update(cur_orgname, **kwargs):
+    client = AccountClient()
+    org = client.get_org(cur_orgname)
+    del org["owners"]
+    new_org = org.copy()
+    if not any(kwargs.values()):
+        for field in org:
+            new_org[field] = click.prompt(
+                field.replace("_", " ").capitalize(), default=org[field]
+            )
+            if field == "email":
+                validate_email(new_org[field])
+            if field == "orgname":
+                validate_orgname(new_org[field])
+    else:
+        new_org.update(
+            {key.replace("new_", ""): value for key, value in kwargs.items() if value}
+        )
+    client.update_org(cur_orgname, new_org)
+    return click.secho(
+        "The organization `%s` has been successfully updated." % cur_orgname,
+        fg="green",
+    )
+
+
+@cli.command("destroy", short_help="Destroy organization")
+@click.argument("orgname")
+def account_destroy(orgname):
+    client = AccountClient()
+    click.confirm(
+        "Are you sure you want to delete the `%s` organization account?\n"
+        "Warning! All linked data will be permanently removed and can not be restored."
+        % orgname,
+        abort=True,
+    )
+    client.destroy_org(orgname)
+    return click.secho(
+        "Organization `%s` has been destroyed." % orgname,
+        fg="green",
+    )
+
+
+@cli.command("add", short_help="Add a new owner to organization")
+@click.argument(
+    "orgname",
+)
+@click.argument(
+    "username",
+)
+def org_add_owner(orgname, username):
+    client = AccountClient()
+    client.add_org_owner(orgname, username)
+    return click.secho(
+        "The new owner `%s` has been successfully added to the `%s` organization."
+        % (username, orgname),
+        fg="green",
+    )
+
+
+@cli.command("remove", short_help="Remove an owner from organization")
+@click.argument(
+    "orgname",
+)
+@click.argument(
+    "username",
+)
+def org_remove_owner(orgname, username):
+    client = AccountClient()
+    client.remove_org_owner(orgname, username)
+    return click.secho(
+        "The `%s` owner has been successfully removed from the `%s` organization."
+        % (username, orgname),
+        fg="green",
+    )

platformio/commands/package.py

@@ -0,0 +1,226 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+import os
+import tempfile
+from datetime import datetime
+
+import click
+from tabulate import tabulate
+
+from platformio import fs
+from platformio.clients.account import AccountClient
+from platformio.clients.registry import RegistryClient
+from platformio.exception import UserSideException
+from platformio.package.manifest.parser import ManifestParserFactory
+from platformio.package.manifest.schema import ManifestSchema, ManifestValidationError
+from platformio.package.meta import PackageSpec, PackageType
+from platformio.package.pack import PackagePacker
+from platformio.package.unpack import FileUnpacker, TARArchiver
+
+
+def validate_datetime(ctx, param, value):  # pylint: disable=unused-argument
+    if not value:
+        return value
+    try:
+        datetime.strptime(value, "%Y-%m-%d %H:%M:%S")
+    except ValueError as e:
+        raise click.BadParameter(e)
+    return value
+
+
+def load_manifest_from_archive(path):
+    return ManifestSchema().load_manifest(
+        ManifestParserFactory.new_from_archive(path).as_dict()
+    )
+
+
+def check_package_duplicates(
+    owner, type, name, version, system
+):  # pylint: disable=redefined-builtin
+    found = False
+    items = (
+        RegistryClient()
+        .list_packages(filters=dict(types=[type], names=[name]))
+        .get("items")
+    )
+    if not items:
+        return True
+    # duplicated version by owner / system
+    found = False
+    for item in items:
+        if item["owner"]["username"] != owner or item["version"]["name"] != version:
+            continue
+        if not system:
+            found = True
+            break
+        published_systems = []
+        for f in item["version"]["files"]:
+            published_systems.extend(f.get("system", []))
+        found = set(system).issubset(set(published_systems))
+    if found:
+        raise UserSideException(
+            "The package `%s/%s@%s` is already published in the registry"
+            % (owner, name, version)
+        )
+    other_owners = [
+        item["owner"]["username"]
+        for item in items
+        if item["owner"]["username"] != owner
+    ]
+    if other_owners:
+        click.secho(
+            "\nWarning! A package with the name `%s` is already published by the next "
+            "owners: %s\n" % (name, ", ".join(other_owners)),
+            fg="yellow",
+        )
+    return True
+
+
+@click.group("package", short_help="Package manager")
+def cli():
+    pass
+
+
+@cli.command("pack", short_help="Create a tarball from a package")
+@click.argument(
+    "package",
+    required=True,
+    default=os.getcwd,
+    metavar="<source directory, tar.gz or zip>",
+)
+@click.option(
+    "-o", "--output", help="A destination path (folder or a full path to file)"
+)
+def package_pack(package, output):
+    p = PackagePacker(package)
+    archive_path = p.pack(output)
+    # validate manifest
+    try:
+        load_manifest_from_archive(archive_path)
+    except ManifestValidationError as e:
+        os.remove(archive_path)
+        raise e
+    click.secho('Wrote a tarball to "%s"' % archive_path, fg="green")
+
+
+@cli.command("publish", short_help="Publish a package to the registry")
+@click.argument(
+    "package",
+    required=True,
+    default=os.getcwd,
+    metavar="<source directory, tar.gz or zip>",
+)
+@click.option(
+    "--owner",
+    help="PIO Account username (can be organization username). "
+    "Default is set to a username of the authorized PIO Account",
+)
+@click.option(
+    "--released-at",
+    callback=validate_datetime,
+    help="Custom release date and time in the next format (UTC): 2014-06-13 17:08:52",
+)
+@click.option("--private", is_flag=True, help="Restricted access (not a public)")
+@click.option(
+    "--notify/--no-notify",
+    default=True,
+    help="Notify by email when package is processed",
+)
+@click.option(
+    "--non-interactive",
+    is_flag=True,
+    help="Do not show interactive prompt",
+)
+def package_publish(  # pylint: disable=too-many-arguments, too-many-locals
+    package, owner, released_at, private, notify, non_interactive
+):
+    click.secho("Preparing a package...", fg="cyan")
+    owner = owner or AccountClient().get_logged_username()
+    do_not_pack = not os.path.isdir(package) and isinstance(
+        FileUnpacker.new_archiver(package), TARArchiver
+    )
+    archive_path = None
+    with tempfile.TemporaryDirectory() as tmp_dir:  # pylint: disable=no-member
+        # publish .tar.gz instantly without repacking
+        if do_not_pack:
+            archive_path = package
+        else:
+            with fs.cd(tmp_dir):
+                p = PackagePacker(package)
+                archive_path = p.pack()
+
+        type_ = PackageType.from_archive(archive_path)
+        manifest = load_manifest_from_archive(archive_path)
+        name = manifest.get("name")
+        version = manifest.get("version")
+        data = [
+            ("Type:", type_),
+            ("Owner:", owner),
+            ("Name:", name),
+            ("Version:", version),
+        ]
+        if manifest.get("system"):
+            data.insert(len(data) - 1, ("System:", ", ".join(manifest.get("system"))))
+        click.echo(tabulate(data, tablefmt="plain"))
+
+        # look for duplicates
+        check_package_duplicates(owner, type_, name, version, manifest.get("system"))
+
+        if not non_interactive:
+            click.confirm(
+                "Are you sure you want to publish the %s %s to the registry?\n"
+                % (
+                    type_,
+                    click.style(
+                        "%s/%s@%s" % (owner, name, version),
+                        fg="cyan",
+                    ),
+                ),
+                abort=True,
+            )
+
+        response = RegistryClient().publish_package(
+            owner, type_, archive_path, released_at, private, notify
+        )
+        if not do_not_pack:
+            os.remove(archive_path)
+        click.secho(response.get("message"), fg="green")
+
+
+@cli.command("unpublish", short_help="Remove a pushed package from the registry")
+@click.argument(
+    "package", required=True, metavar="[<organization>/]<pkgname>[@<version>]"
+)
+@click.option(
+    "--type",
+    type=click.Choice(list(PackageType.items().values())),
+    default="library",
+    help="Package type, default is set to `library`",
+)
+@click.option(
+    "--undo",
+    is_flag=True,
+    help="Undo a remove, putting a version back into the registry",
+)
+def package_unpublish(package, type, undo):  # pylint: disable=redefined-builtin
+    spec = PackageSpec(package)
+    response = RegistryClient().unpublish_package(
+        owner=spec.owner or AccountClient().get_logged_username(),
+        type=type,
+        name=spec.name,
+        version=str(spec.requirements),
+        undo=undo,
+    )
+    click.secho(response.get("message"), fg="green")

platformio/commands/platform.py

@@ -12,154 +12,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from os.path import dirname, isdir
+import json
+import os
 
 import click
 
-from platformio import app, exception, util
+from platformio.cache import cleanup_content_cache
 from platformio.commands.boards import print_boards
-from platformio.compat import dump_json_to_unicode
-from platformio.managers.platform import PlatformFactory, PlatformManager
-from platformio.package.pack import PackagePacker
+from platformio.package.manager.platform import PlatformPackageManager
+from platformio.package.meta import PackageItem, PackageSpec
+from platformio.package.version import get_original_version
+from platformio.platform.exception import UnknownPlatform
+from platformio.platform.factory import PlatformFactory
 
 
-@click.group(short_help="Platform Manager")
+@click.group(short_help="Platform manager")
 def cli():
     pass
 
 
-def _print_platforms(platforms):
-    for platform in platforms:
-        click.echo(
-            "{name} ~ {title}".format(
-                name=click.style(platform["name"], fg="cyan"), title=platform["title"]
-            )
-        )
-        click.echo("=" * (3 + len(platform["name"] + platform["title"])))
-        click.echo(platform["description"])
-        click.echo()
-        if "homepage" in platform:
-            click.echo("Home: %s" % platform["homepage"])
-        if "frameworks" in platform and platform["frameworks"]:
-            click.echo("Frameworks: %s" % ", ".join(platform["frameworks"]))
-        if "packages" in platform:
-            click.echo("Packages: %s" % ", ".join(platform["packages"]))
-        if "version" in platform:
-            if "__src_url" in platform:
-                click.echo(
-                    "Version: #%s (%s)" % (platform["version"], platform["__src_url"])
-                )
-            else:
-                click.echo("Version: " + platform["version"])
-        click.echo()
-
-
-def _get_registry_platforms():
-    platforms = util.get_api_result("/platforms", cache_valid="7d")
-    pm = PlatformManager()
-    for platform in platforms or []:
-        platform["versions"] = pm.get_all_repo_versions(platform["name"])
-    return platforms
-
-
-def _get_platform_data(*args, **kwargs):
-    try:
-        return _get_installed_platform_data(*args, **kwargs)
-    except exception.UnknownPlatform:
-        return _get_registry_platform_data(*args, **kwargs)
-
-
-def _get_installed_platform_data(platform, with_boards=True, expose_packages=True):
-    p = PlatformFactory.newPlatform(platform)
-    data = dict(
-        name=p.name,
-        title=p.title,
-        description=p.description,
-        version=p.version,
-        homepage=p.homepage,
-        repository=p.repository_url,
-        url=p.vendor_url,
-        docs=p.docs_url,
-        license=p.license,
-        forDesktop=not p.is_embedded(),
-        frameworks=sorted(list(p.frameworks) if p.frameworks else []),
-        packages=list(p.packages) if p.packages else [],
-    )
-
-    # if dump to API
-    # del data['version']
-    # return data
-
-    # overwrite VCS version and add extra fields
-    manifest = PlatformManager().load_manifest(dirname(p.manifest_path))
-    assert manifest
-    for key in manifest:
-        if key == "version" or key.startswith("__"):
-            data[key] = manifest[key]
-
-    if with_boards:
-        data["boards"] = [c.get_brief_data() for c in p.get_boards().values()]
-
-    if not data["packages"] or not expose_packages:
-        return data
-
-    data["packages"] = []
-    installed_pkgs = p.get_installed_packages()
-    for name, opts in p.packages.items():
-        item = dict(
-            name=name,
-            type=p.get_package_type(name),
-            requirements=opts.get("version"),
-            optional=opts.get("optional") is True,
-        )
-        if name in installed_pkgs:
-            for key, value in installed_pkgs[name].items():
-                if key not in ("url", "version", "description"):
-                    continue
-                item[key] = value
-                if key == "version":
-                    item["originalVersion"] = util.get_original_version(value)
-        data["packages"].append(item)
-
-    return data
-
-
-def _get_registry_platform_data(  # pylint: disable=unused-argument
-    platform, with_boards=True, expose_packages=True
-):
-    _data = None
-    for p in _get_registry_platforms():
-        if p["name"] == platform:
-            _data = p
-            break
-
-    if not _data:
-        return None
-
-    data = dict(
-        name=_data["name"],
-        title=_data["title"],
-        description=_data["description"],
-        homepage=_data["homepage"],
-        repository=_data["repository"],
-        url=_data["url"],
-        license=_data["license"],
-        forDesktop=_data["forDesktop"],
-        frameworks=_data["frameworks"],
-        packages=_data["packages"],
-        versions=_data["versions"],
-    )
-
-    if with_boards:
-        data["boards"] = [
-            board
-            for board in PlatformManager().get_registered_boards()
-            if board["platform"] == _data["name"]
-        ]
-
-    return data
-
-
 @cli.command("search", short_help="Search for development platform")
 @click.argument("query", required=False)
 @click.option("--json-output", is_flag=True)
@@ -168,7 +39,7 @@ def platform_search(query, json_output):
     for platform in _get_registry_platforms():
         if query == "all":
             query = ""
-        search_data = dump_json_to_unicode(platform)
+        search_data = json.dumps(platform)
         if query and query.lower() not in search_data.lower():
             continue
         platforms.append(
@@ -178,7 +49,7 @@ def platform_search(query, json_output):
         )
 
     if json_output:
-        click.echo(dump_json_to_unicode(platforms))
+        click.echo(json.dumps(platforms))
     else:
         _print_platforms(platforms)
 
@@ -187,11 +58,14 @@ def platform_search(query, json_output):
 @click.argument("query", required=False)
 @click.option("--json-output", is_flag=True)
 def platform_frameworks(query, json_output):
+    regclient = PlatformPackageManager().get_registry_client_instance()
     frameworks = []
-    for framework in util.get_api_result("/frameworks", cache_valid="7d"):
+    for framework in regclient.fetch_json_data(
+        "get", "/v2/frameworks", cache_valid="1d"
+    ):
         if query == "all":
             query = ""
-        search_data = dump_json_to_unicode(framework)
+        search_data = json.dumps(framework)
         if query and query.lower() not in search_data.lower():
             continue
         framework["homepage"] = "https://platformio.org/frameworks/" + framework["name"]
@@ -204,7 +78,7 @@ def platform_frameworks(query, json_output):
 
     frameworks = sorted(frameworks, key=lambda manifest: manifest["name"])
     if json_output:
-        click.echo(dump_json_to_unicode(frameworks))
+        click.echo(json.dumps(frameworks))
     else:
         _print_platforms(frameworks)
 
@@ -213,17 +87,15 @@ def platform_frameworks(query, json_output):
 @click.option("--json-output", is_flag=True)
 def platform_list(json_output):
     platforms = []
-    pm = PlatformManager()
-    for manifest in pm.get_installed():
+    pm = PlatformPackageManager()
+    for pkg in pm.get_installed():
         platforms.append(
-            _get_installed_platform_data(
-                manifest["__pkg_dir"], with_boards=False, expose_packages=False
-            )
+            _get_installed_platform_data(pkg, with_boards=False, expose_packages=False)
         )
 
     platforms = sorted(platforms, key=lambda manifest: manifest["name"])
     if json_output:
-        click.echo(dump_json_to_unicode(platforms))
+        click.echo(json.dumps(platforms))
     else:
         _print_platforms(platforms)
 
@@ -234,16 +106,15 @@ def platform_list(json_output):
 def platform_show(platform, json_output):  # pylint: disable=too-many-branches
     data = _get_platform_data(platform)
     if not data:
-        raise exception.UnknownPlatform(platform)
+        raise UnknownPlatform(platform)
     if json_output:
-        return click.echo(dump_json_to_unicode(data))
+        return click.echo(json.dumps(data))
 
+    dep = "{ownername}/{name}".format(**data) if "ownername" in data else data["name"]
     click.echo(
-        "{name} ~ {title}".format(
-            name=click.style(data["name"], fg="cyan"), title=data["title"]
-        )
+        "{dep} ~ {title}".format(dep=click.style(dep, fg="cyan"), title=data["title"])
     )
-    click.echo("=" * (3 + len(data["name"] + data["title"])))
+    click.echo("=" * (3 + len(dep + data["title"])))
     click.echo(data["description"])
     click.echo()
     if "version" in data:
@@ -300,6 +171,7 @@ def platform_show(platform, json_output):  # pylint: disable=too-many-branches
 @click.option("--without-package", multiple=True)
 @click.option("--skip-default-package", is_flag=True)
 @click.option("--with-all-packages", is_flag=True)
+@click.option("-s", "--silent", is_flag=True, help="Suppress progress reporting")
 @click.option(
     "-f",
     "--force",
@@ -312,21 +184,44 @@ def platform_install(  # pylint: disable=too-many-arguments
     without_package,
     skip_default_package,
     with_all_packages,
+    silent,
     force,
 ):
-    pm = PlatformManager()
+    return _platform_install(
+        platforms,
+        with_package,
+        without_package,
+        skip_default_package,
+        with_all_packages,
+        silent,
+        force,
+    )
+
+
+def _platform_install(  # pylint: disable=too-many-arguments
+    platforms,
+    with_package=None,
+    without_package=None,
+    skip_default_package=False,
+    with_all_packages=False,
+    silent=False,
+    force=False,
+):
+    pm = PlatformPackageManager()
     for platform in platforms:
-        if pm.install(
-            name=platform,
-            with_packages=with_package,
-            without_packages=without_package,
+        pkg = pm.install(
+            spec=platform,
+            with_packages=with_package or [],
+            without_packages=without_package or [],
             skip_default_package=skip_default_package,
             with_all_packages=with_all_packages,
+            silent=silent,
             force=force,
-        ):
+        )
+        if pkg and not silent:
             click.secho(
                 "The platform '%s' has been successfully installed!\n"
-                "The rest of packages will be installed automatically "
+                "The rest of the packages will be installed later "
                 "depending on your build environment." % platform,
                 fg="green",
             )
@@ -335,11 +230,11 @@ def platform_install(  # pylint: disable=too-many-arguments
 @cli.command("uninstall", short_help="Uninstall development platform")
 @click.argument("platforms", nargs=-1, required=True, metavar="[PLATFORM...]")
 def platform_uninstall(platforms):
-    pm = PlatformManager()
+    pm = PlatformPackageManager()
     for platform in platforms:
         if pm.uninstall(platform):
             click.secho(
-                "The platform '%s' has been successfully uninstalled!" % platform,
+                "The platform '%s' has been successfully removed!" % platform,
                 fg="green",
             )
 
@@ -358,66 +253,207 @@ def platform_uninstall(platforms):
 @click.option(
     "--dry-run", is_flag=True, help="Do not update, only check for the new versions"
 )
+@click.option("-s", "--silent", is_flag=True, help="Suppress progress reporting")
 @click.option("--json-output", is_flag=True)
-def platform_update(  # pylint: disable=too-many-locals
-    platforms, only_packages, only_check, dry_run, json_output
+def platform_update(  # pylint: disable=too-many-locals, too-many-arguments
+    platforms, only_packages, only_check, dry_run, silent, json_output
 ):
-    pm = PlatformManager()
-    pkg_dir_to_name = {}
-    if not platforms:
-        platforms = []
-        for manifest in pm.get_installed():
-            platforms.append(manifest["__pkg_dir"])
-            pkg_dir_to_name[manifest["__pkg_dir"]] = manifest.get(
-                "title", manifest["name"]
-            )
-
+    pm = PlatformPackageManager()
+    platforms = platforms or pm.get_installed()
     only_check = dry_run or only_check
 
     if only_check and json_output:
         result = []
         for platform in platforms:
-            pkg_dir = platform if isdir(platform) else None
-            requirements = None
-            url = None
-            if not pkg_dir:
-                name, requirements, url = pm.parse_pkg_uri(platform)
-                pkg_dir = pm.get_package_dir(name, requirements, url)
-            if not pkg_dir:
+            spec = None
+            pkg = None
+            if isinstance(platform, PackageItem):
+                pkg = platform
+            else:
+                spec = PackageSpec(platform)
+                pkg = pm.get_package(spec)
+            if not pkg:
                 continue
-            latest = pm.outdated(pkg_dir, requirements)
+            outdated = pm.outdated(pkg, spec)
             if (
-                not latest
-                and not PlatformFactory.newPlatform(pkg_dir).are_outdated_packages()
+                not outdated.is_outdated(allow_incompatible=True)
+                and not PlatformFactory.new(pkg).are_outdated_packages()
             ):
                 continue
             data = _get_installed_platform_data(
-                pkg_dir, with_boards=False, expose_packages=False
+                pkg, with_boards=False, expose_packages=False
             )
-            if latest:
-                data["versionLatest"] = latest
+            if outdated.is_outdated(allow_incompatible=True):
+                data["versionLatest"] = (
+                    str(outdated.latest) if outdated.latest else None
+                )
             result.append(data)
-        return click.echo(dump_json_to_unicode(result))
+        return click.echo(json.dumps(result))
 
     # cleanup cached board and platform lists
-    app.clean_cache()
+    cleanup_content_cache("http")
+
     for platform in platforms:
         click.echo(
             "Platform %s"
-            % click.style(pkg_dir_to_name.get(platform, platform), fg="cyan")
+            % click.style(
+                platform.metadata.name
+                if isinstance(platform, PackageItem)
+                else platform,
+                fg="cyan",
+            )
         )
         click.echo("--------")
-        pm.update(platform, only_packages=only_packages, only_check=only_check)
+        pm.update(
+            platform, only_packages=only_packages, only_check=only_check, silent=silent
+        )
         click.echo()
 
     return True
 
 
-@cli.command(
-    "pack", short_help="Create a tarball from development platform/tool package"
-)
-@click.argument("package", required=True, metavar="[source directory, tar.gz or zip]")
-def platform_pack(package):
-    p = PackagePacker(package)
-    tarball_path = p.pack()
-    click.secho('Wrote a tarball to "%s"' % tarball_path, fg="green")
+#
+# Helpers
+#
+
+
+def init_platform(name, skip_default_package=True, auto_install=True):
+    try:
+        return PlatformFactory.new(name)
+    except UnknownPlatform:
+        if auto_install:
+            _platform_install([name], skip_default_package=skip_default_package)
+        return PlatformFactory.new(name)
+
+
+def _print_platforms(platforms):
+    for platform in platforms:
+        click.echo(
+            "{name} ~ {title}".format(
+                name=click.style(platform["name"], fg="cyan"), title=platform["title"]
+            )
+        )
+        click.echo("=" * (3 + len(platform["name"] + platform["title"])))
+        click.echo(platform["description"])
+        click.echo()
+        if "homepage" in platform:
+            click.echo("Home: %s" % platform["homepage"])
+        if "frameworks" in platform and platform["frameworks"]:
+            click.echo("Frameworks: %s" % ", ".join(platform["frameworks"]))
+        if "packages" in platform:
+            click.echo("Packages: %s" % ", ".join(platform["packages"]))
+        if "version" in platform:
+            if "__src_url" in platform:
+                click.echo(
+                    "Version: %s (%s)" % (platform["version"], platform["__src_url"])
+                )
+            else:
+                click.echo("Version: " + platform["version"])
+        click.echo()
+
+
+def _get_registry_platforms():
+    regclient = PlatformPackageManager().get_registry_client_instance()
+    return regclient.fetch_json_data("get", "/v2/platforms", cache_valid="1d")
+
+
+def _get_platform_data(*args, **kwargs):
+    try:
+        return _get_installed_platform_data(*args, **kwargs)
+    except UnknownPlatform:
+        return _get_registry_platform_data(*args, **kwargs)
+
+
+def _get_installed_platform_data(platform, with_boards=True, expose_packages=True):
+    p = PlatformFactory.new(platform)
+    data = dict(
+        name=p.name,
+        title=p.title,
+        description=p.description,
+        version=p.version,
+        homepage=p.homepage,
+        url=p.homepage,
+        repository=p.repository_url,
+        license=p.license,
+        forDesktop=not p.is_embedded(),
+        frameworks=sorted(list(p.frameworks) if p.frameworks else []),
+        packages=list(p.packages) if p.packages else [],
+    )
+
+    # if dump to API
+    # del data['version']
+    # return data
+
+    # overwrite VCS version and add extra fields
+    manifest = PlatformPackageManager().legacy_load_manifest(
+        os.path.dirname(p.manifest_path)
+    )
+    assert manifest
+    for key in manifest:
+        if key == "version" or key.startswith("__"):
+            data[key] = manifest[key]
+
+    if with_boards:
+        data["boards"] = [c.get_brief_data() for c in p.get_boards().values()]
+
+    if not data["packages"] or not expose_packages:
+        return data
+
+    data["packages"] = []
+    installed_pkgs = {
+        pkg.metadata.name: p.pm.load_manifest(pkg) for pkg in p.get_installed_packages()
+    }
+    for name, options in p.packages.items():
+        item = dict(
+            name=name,
+            type=p.get_package_type(name),
+            requirements=options.get("version"),
+            optional=options.get("optional") is True,
+        )
+        if name in installed_pkgs:
+            for key, value in installed_pkgs[name].items():
+                if key not in ("url", "version", "description"):
+                    continue
+                item[key] = value
+                if key == "version":
+                    item["originalVersion"] = get_original_version(value)
+        data["packages"].append(item)
+
+    return data
+
+
+def _get_registry_platform_data(  # pylint: disable=unused-argument
+    platform, with_boards=True, expose_packages=True
+):
+    _data = None
+    for p in _get_registry_platforms():
+        if p["name"] == platform:
+            _data = p
+            break
+
+    if not _data:
+        return None
+
+    data = dict(
+        ownername=_data.get("ownername"),
+        name=_data["name"],
+        title=_data["title"],
+        description=_data["description"],
+        homepage=_data["homepage"],
+        repository=_data["repository"],
+        url=_data["url"],
+        license=_data["license"],
+        forDesktop=_data["forDesktop"],
+        frameworks=_data["frameworks"],
+        packages=_data["packages"],
+        versions=_data.get("versions"),
+    )
+
+    if with_boards:
+        data["boards"] = [
+            board
+            for board in PlatformPackageManager().get_registered_boards()
+            if board["platform"] == _data["name"]
+        ]
+
+    return data

platformio/commands/project.py

@@ -12,23 +12,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pylint: disable=too-many-arguments,too-many-locals, too-many-branches
+# pylint: disable=too-many-arguments,too-many-locals,too-many-branches,line-too-long
 
+import json
 import os
 
 import click
 from tabulate import tabulate
 
-from platformio import exception, fs
+from platformio import fs
 from platformio.commands.platform import platform_install as cli_platform_install
 from platformio.ide.projectgenerator import ProjectGenerator
-from platformio.managers.platform import PlatformManager
+from platformio.package.manager.platform import PlatformPackageManager
+from platformio.platform.exception import UnknownBoard
 from platformio.project.config import ProjectConfig
 from platformio.project.exception import NotPlatformIOProjectError
-from platformio.project.helpers import is_platformio_project
+from platformio.project.helpers import is_platformio_project, load_project_ide_data
 
 
-@click.group(short_help="Project Manager")
+@click.group(short_help="Project manager")
 def cli():
     pass
 
@@ -38,9 +40,7 @@ def cli():
     "-d",
     "--project-dir",
     default=os.getcwd,
-    type=click.Path(
-        exists=True, file_okay=True, dir_okay=True, writable=True, resolve_path=True
-    ),
+    type=click.Path(exists=True, file_okay=False, dir_okay=True, resolve_path=True),
 )
 @click.option("--json-output", is_flag=True)
 def project_config(project_dir, json_output):
@@ -54,7 +54,6 @@ def project_config(project_dir, json_output):
         "Computed project configuration for %s" % click.style(project_dir, fg="cyan")
     )
     for section, options in config.as_tuple():
-        click.echo()
         click.secho(section, fg="cyan")
         click.echo("-" * len(section))
         click.echo(
@@ -66,15 +65,55 @@ def project_config(project_dir, json_output):
                 tablefmt="plain",
             )
         )
+        click.echo()
+    return None
+
+
+@cli.command("data", short_help="Dump data intended for IDE extensions/plugins")
+@click.option(
+    "-d",
+    "--project-dir",
+    default=os.getcwd,
+    type=click.Path(exists=True, file_okay=False, dir_okay=True, resolve_path=True),
+)
+@click.option("-e", "--environment", multiple=True)
+@click.option("--json-output", is_flag=True)
+def project_data(project_dir, environment, json_output):
+    if not is_platformio_project(project_dir):
+        raise NotPlatformIOProjectError(project_dir)
+    with fs.cd(project_dir):
+        config = ProjectConfig.get_instance()
+        config.validate(environment)
+        environment = list(environment or config.envs())
+
+    if json_output:
+        return click.echo(json.dumps(load_project_ide_data(project_dir, environment)))
+
+    for envname in environment:
+        click.echo("Environment: " + click.style(envname, fg="cyan", bold=True))
+        click.echo("=" * (13 + len(envname)))
+        click.echo(
+            tabulate(
+                [
+                    (click.style(name, bold=True), "=", json.dumps(value, indent=2))
+                    for name, value in load_project_ide_data(
+                        project_dir, envname
+                    ).items()
+                ],
+                tablefmt="plain",
+            )
+        )
+        click.echo()
+
     return None
 
 
 def validate_boards(ctx, param, value):  # pylint: disable=W0613
-    pm = PlatformManager()
+    pm = PlatformPackageManager()
     for id_ in value:
         try:
             pm.board_config(id_)
-        except exception.UnknownBoard:
+        except UnknownBoard:
             raise click.BadParameter(
                 "`%s`. Please search for board ID using `platformio boards` "
                 "command" % id_
@@ -93,6 +132,7 @@ def validate_boards(ctx, param, value):  # pylint: disable=W0613
 )
 @click.option("-b", "--board", multiple=True, metavar="ID", callback=validate_boards)
 @click.option("--ide", type=click.Choice(ProjectGenerator.get_supported_ides()))
+@click.option("-e", "--environment", help="Update using existing environment")
 @click.option("-O", "--project-option", multiple=True)
 @click.option("--env-prefix", default="")
 @click.option("-s", "--silent", is_flag=True)
@@ -102,21 +142,26 @@ def project_init(
     project_dir,
     board,
     ide,
+    environment,
     project_option,
     env_prefix,
     silent,
 ):
     if not silent:
         if project_dir == os.getcwd():
-            click.secho("\nThe current working directory", fg="yellow", nl=False)
-            click.secho(" %s " % project_dir, fg="cyan", nl=False)
-            click.secho("will be used for the project.", fg="yellow")
+            click.secho("\nThe current working directory ", fg="yellow", nl=False)
+            try:
+                click.secho(project_dir, fg="cyan", nl=False)
+            except UnicodeEncodeError:
+                click.secho(json.dumps(project_dir), fg="cyan", nl=False)
+            click.secho(" will be used for the project.", fg="yellow")
             click.echo("")
 
-        click.echo(
-            "The next files/directories have been created in %s"
-            % click.style(project_dir, fg="cyan")
-        )
+        click.echo("The next files/directories have been created in ", nl=False)
+        try:
+            click.secho(project_dir, fg="cyan")
+        except UnicodeEncodeError:
+            click.secho(json.dumps(project_dir), fg="cyan")
         click.echo(
             "%s - Put project header files here" % click.style("include", fg="cyan")
         )
@@ -133,17 +178,25 @@ def project_init(
     if is_new_project:
         init_base_project(project_dir)
 
-    if board:
-        fill_project_envs(
+    if environment:
+        update_project_env(project_dir, environment, project_option)
+    elif board:
+        update_board_envs(
             ctx, project_dir, board, project_option, env_prefix, ide is not None
         )
 
     if ide:
-        pg = ProjectGenerator(project_dir, ide, board)
+        with fs.cd(project_dir):
+            config = ProjectConfig.get_instance(
+                os.path.join(project_dir, "platformio.ini")
+            )
+        config.validate()
+        pg = ProjectGenerator(
+            config, environment or get_best_envname(config, board), ide
+        )
         pg.generate()
 
     if is_new_project:
-        init_ci_conf(project_dir)
         init_cvs_ignore(project_dir)
 
     if silent:
@@ -187,7 +240,7 @@ def init_base_project(project_dir):
 
 
 def init_include_readme(include_dir):
-    with open(os.path.join(include_dir, "README"), "w") as fp:
+    with open(os.path.join(include_dir, "README"), mode="w", encoding="utf8") as fp:
         fp.write(
             """
 This directory is intended for project header files.
@@ -233,8 +286,7 @@ https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html
 
 
 def init_lib_readme(lib_dir):
-    # pylint: disable=line-too-long
-    with open(os.path.join(lib_dir, "README"), "w") as fp:
+    with open(os.path.join(lib_dir, "README"), mode="w", encoding="utf8") as fp:
         fp.write(
             """
 This directory is intended for project specific (private) libraries.
@@ -287,10 +339,10 @@ More information about PlatformIO Library Dependency Finder
 
 
 def init_test_readme(test_dir):
-    with open(os.path.join(test_dir, "README"), "w") as fp:
+    with open(os.path.join(test_dir, "README"), mode="w", encoding="utf8") as fp:
         fp.write(
             """
-This directory is intended for PIO Unit Testing and project tests.
+This directory is intended for PlatformIO Unit Testing and project tests.
 
 Unit Testing is a software testing method by which individual units of
 source code, sets of one or more MCU program modules together with associated
@@ -298,98 +350,21 @@ control data, usage procedures, and operating procedures, are tested to
 determine whether they are fit for use. Unit testing finds problems early
 in the development cycle.
 
-More information about PIO Unit Testing:
+More information about PlatformIO Unit Testing:
 - https://docs.platformio.org/page/plus/unit-testing.html
 """,
         )
 
 
-def init_ci_conf(project_dir):
-    conf_path = os.path.join(project_dir, ".travis.yml")
-    if os.path.isfile(conf_path):
-        return
-    with open(conf_path, "w") as fp:
-        fp.write(
-            """# Continuous Integration (CI) is the practice, in software
-# engineering, of merging all developer working copies with a shared mainline
-# several times a day < https://docs.platformio.org/page/ci/index.html >
-#
-# Documentation:
-#
-# * Travis CI Embedded Builds with PlatformIO
-#   < https://docs.travis-ci.com/user/integration/platformio/ >
-#
-# * PlatformIO integration with Travis CI
-#   < https://docs.platformio.org/page/ci/travis.html >
-#
-# * User Guide for `platformio ci` command
-#   < https://docs.platformio.org/page/userguide/cmd_ci.html >
-#
-#
-# Please choose one of the following templates (proposed below) and uncomment
-# it (remove "# " before each line) or use own configuration according to the
-# Travis CI documentation (see above).
-#
-
-
-#
-# Template #1: General project. Test it using existing `platformio.ini`.
-#
-
-# language: python
-# python:
-#     - "2.7"
-#
-# sudo: false
-# cache:
-#     directories:
-#         - "~/.platformio"
-#
-# install:
-#     - pip install -U platformio
-#     - platformio update
-#
-# script:
-#     - platformio run
-
-
-#
-# Template #2: The project is intended to be used as a library with examples.
-#
-
-# language: python
-# python:
-#     - "2.7"
-#
-# sudo: false
-# cache:
-#     directories:
-#         - "~/.platformio"
-#
-# env:
-#     - PLATFORMIO_CI_SRC=path/to/test/file.c
-#     - PLATFORMIO_CI_SRC=examples/file.ino
-#     - PLATFORMIO_CI_SRC=path/to/test/directory
-#
-# install:
-#     - pip install -U platformio
-#     - platformio update
-#
-# script:
-#     - platformio ci --lib="." --board=ID_1 --board=ID_2 --board=ID_N
-""",
-        )
-
-
 def init_cvs_ignore(project_dir):
     conf_path = os.path.join(project_dir, ".gitignore")
     if os.path.isfile(conf_path):
         return
-    with open(conf_path, "w") as fp:
+    with open(conf_path, mode="w", encoding="utf8") as fp:
         fp.write(".pio\n")
 
 
-def fill_project_envs(
+def update_board_envs(
     ctx, project_dir, board_ids, project_option, env_prefix, force_download
 ):
     config = ProjectConfig(
@@ -401,7 +376,7 @@ def fill_project_envs(
         if all(cond):
             used_boards.append(config.get(section, "board"))
 
-    pm = PlatformManager()
+    pm = PlatformPackageManager()
     used_platforms = []
     modified = False
     for id_ in board_ids:
@@ -438,9 +413,51 @@ def fill_project_envs(
 
 
 def _install_dependent_platforms(ctx, platforms):
-    installed_platforms = [p["name"] for p in PlatformManager().get_installed()]
+    installed_platforms = [
+        pkg.metadata.name for pkg in PlatformPackageManager().get_installed()
+    ]
     if set(platforms) <= set(installed_platforms):
         return
     ctx.invoke(
         cli_platform_install, platforms=list(set(platforms) - set(installed_platforms))
     )
+
+
+def update_project_env(project_dir, environment, project_option):
+    if not project_option:
+        return
+    config = ProjectConfig(
+        os.path.join(project_dir, "platformio.ini"), parse_extra=False
+    )
+
+    section = "env:%s" % environment
+    if not config.has_section(section):
+        config.add_section(section)
+
+    for item in project_option:
+        if "=" not in item:
+            continue
+        _name, _value = item.split("=", 1)
+        config.set(section, _name.strip(), _value.strip())
+
+    config.save()
+
+
+def get_best_envname(config, board_ids=None):
+    envname = None
+    default_envs = config.default_envs()
+    if default_envs:
+        envname = default_envs[0]
+        if not board_ids:
+            return envname
+
+    for env in config.envs():
+        if not board_ids:
+            return env
+        if not envname:
+            envname = env
+        items = config.items(env=env, as_dict=True)
+        if "board" in items and items.get("board") in board_ids:
+            return env
+
+    return envname

platformio/commands/remote/client/base.py

@@ -72,7 +72,7 @@ class RemoteClientBase(  # pylint: disable=too-many-instance-attributes
 
     def connect(self):
         self.log.info("Name: {name}", name=self.name)
-        self.log.info("Connecting to PIO Remote Cloud")
+        self.log.info("Connecting to PlatformIO Remote Development Cloud")
 
         # pylint: disable=protected-access
         proto, options = endpoints._parse(__pioremote_endpoint__)

platformio/commands/remote/client/device_monitor.py

@@ -173,7 +173,11 @@ class DeviceMonitorClient(  # pylint: disable=too-many-instance-attributes
         address = port.getHost()
         self.log.debug("Serial Bridge is started on {address!r}", address=address)
         if "sock" in self.cmd_options:
-            with open(os.path.join(self.cmd_options["sock"], "sock"), "w") as fp:
+            with open(
+                os.path.join(self.cmd_options["sock"], "sock"),
+                mode="w",
+                encoding="utf8",
+            ) as fp:
                 fp.write("socket://localhost:%d" % address.port)
 
     def client_terminal_stopped(self):

platformio/commands/remote/client/run_or_test.py

@@ -20,7 +20,7 @@ from io import BytesIO
 
 from twisted.spread import pb  # pylint: disable=import-error
 
-from platformio import util
+from platformio import fs
 from platformio.commands.remote.client.async_base import AsyncClientBase
 from platformio.commands.remote.projectsync import PROJECT_SYNC_STAGE, ProjectSync
 from platformio.compat import hashlib_encode_data
@@ -64,7 +64,7 @@ class RunOrTestClient(AsyncClientBase):
         return "%s-%s" % (os.path.basename(path), h.hexdigest())
 
     def add_project_items(self, psync):
-        with util.cd(self.options["project_dir"]):
+        with fs.cd(self.options["project_dir"]):
             cfg = ProjectConfig.get_instance(
                 os.path.join(self.options["project_dir"], "platformio.ini")
             )

platformio/commands/remote/command.py

@@ -23,28 +23,21 @@ from time import sleep
 
 import click
 
-from platformio import exception, fs, proc
+from platformio import fs, proc
 from platformio.commands.device import helpers as device_helpers
 from platformio.commands.device.command import device_monitor as cmd_device_monitor
 from platformio.commands.run.command import cli as cmd_run
 from platformio.commands.test.command import cli as cmd_test
-from platformio.compat import PY2
-from platformio.managers.core import inject_contrib_pysite
+from platformio.package.manager.core import inject_contrib_pysite
 from platformio.project.exception import NotPlatformIOProjectError
 
 
-@click.group("remote", short_help="PIO Remote")
+@click.group("remote", short_help="Remote development")
 @click.option("-a", "--agent", multiple=True)
 @click.pass_context
 def cli(ctx, agent):
-    if PY2:
-        raise exception.UserSideException(
-            "PIO Remote requires Python 3.5 or above. \nPlease install the latest "
-            "Python 3 and reinstall PlatformIO Core using installation script:\n"
-            "https://docs.platformio.org/page/core/installation.html"
-        )
     ctx.obj = agent
-    inject_contrib_pysite()
+    inject_contrib_pysite(verify_openssl=True)
 
 
 @cli.group("agent", short_help="Start a new agent or list active")
@@ -343,7 +336,10 @@ def device_monitor(ctx, agents, **kwargs):
     kwargs["baud"] = kwargs["baud"] or 9600
 
     def _tx_target(sock_dir):
-        subcmd_argv = ["remote", "device", "monitor"]
+        subcmd_argv = ["remote"]
+        for agent in agents:
+            subcmd_argv.extend(["--agent", agent])
+        subcmd_argv.extend(["device", "monitor"])
         subcmd_argv.extend(device_helpers.options_to_argv(kwargs, project_options))
         subcmd_argv.extend(["--sock", sock_dir])
         subprocess.call([proc.where_is_program("platformio")] + subcmd_argv)
@@ -357,7 +353,7 @@ def device_monitor(ctx, agents, **kwargs):
             sleep(0.1)
         if not t.is_alive():
             return
-        with open(sock_file) as fp:
+        with open(sock_file, encoding="utf8") as fp:
             kwargs["port"] = fp.read()
         ctx.invoke(cmd_device_monitor, **kwargs)
         t.join(2)

platformio/commands/remote/factory/client.py

@@ -13,11 +13,11 @@
 # limitations under the License.
 
 from twisted.cred import credentials  # pylint: disable=import-error
-from twisted.internet import protocol, reactor  # pylint: disable=import-error
+from twisted.internet import defer, protocol, reactor  # pylint: disable=import-error
 from twisted.spread import pb  # pylint: disable=import-error
 
 from platformio.app import get_host_id
-from platformio.commands.account.client import AccountClient
+from platformio.clients.account import AccountClient
 
 
 class RemoteClientFactory(pb.PBClientFactory, protocol.ReconnectingClientFactory):
@@ -35,17 +35,30 @@ class RemoteClientFactory(pb.PBClientFactory, protocol.ReconnectingClientFactory
         self.remote_client.log.info("Successfully connected")
         self.remote_client.log.info("Authenticating")
 
+        auth_token = None
+        try:
+            auth_token = AccountClient().fetch_authentication_token()
+        except Exception as e:  # pylint:disable=broad-except
+            d = defer.Deferred()
+            d.addErrback(self.clientAuthorizationFailed)
+            d.errback(pb.Error(e))
+            return d
+
         d = self.login(
             credentials.UsernamePassword(
-                AccountClient().fetch_authentication_token().encode(),
+                auth_token.encode(),
                 get_host_id().encode(),
             ),
             client=self.remote_client,
         )
         d.addCallback(self.remote_client.cb_client_authorization_made)
-        d.addErrback(self.remote_client.cb_client_authorization_failed)
+        d.addErrback(self.clientAuthorizationFailed)
         return d
 
+    def clientAuthorizationFailed(self, err):
+        AccountClient.delete_local_session()
+        self.remote_client.cb_client_authorization_failed(err)
+
     def clientConnectionFailed(self, connector, reason):
         self.remote_client.log.warn(
             "Could not connect to PIO Remote Cloud. Reconnecting..."

platformio/commands/run/command.py

@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import operator
+import os
+import shutil
 from multiprocessing import cpu_count
-from os import getcwd
-from os.path import isfile
 from time import time
 
 import click
@@ -26,7 +27,7 @@ from platformio.commands.run.helpers import clean_build_dir, handle_legacy_libde
 from platformio.commands.run.processor import EnvironmentProcessor
 from platformio.commands.test.processor import CTX_META_TEST_IS_RUNNING
 from platformio.project.config import ProjectConfig
-from platformio.project.helpers import find_project_dir_above
+from platformio.project.helpers import find_project_dir_above, load_project_ide_data
 
 # pylint: disable=too-many-arguments,too-many-locals,too-many-branches
 
@@ -36,14 +37,14 @@ except NotImplementedError:
     DEFAULT_JOB_NUMS = 1
 
 
-@click.command("run", short_help="Process project environments")
+@click.command("run", short_help="Run project targets (build, upload, clean, etc.)")
 @click.option("-e", "--environment", multiple=True)
 @click.option("-t", "--target", multiple=True)
 @click.option("--upload-port")
 @click.option(
     "-d",
     "--project-dir",
-    default=getcwd,
+    default=os.getcwd,
     type=click.Path(
         exists=True, file_okay=True, dir_okay=True, writable=True, resolve_path=True
     ),
@@ -68,6 +69,7 @@ except NotImplementedError:
 @click.option("-s", "--silent", is_flag=True)
 @click.option("-v", "--verbose", is_flag=True)
 @click.option("--disable-auto-clean", is_flag=True)
+@click.option("--list-targets", is_flag=True)
 @click.pass_context
 def cli(
     ctx,
@@ -80,11 +82,12 @@ def cli(
     silent,
     verbose,
     disable_auto_clean,
+    list_targets,
 ):
     app.set_session_var("custom_project_conf", project_conf)
 
     # find project directory on upper level
-    if isfile(project_dir):
+    if os.path.isfile(project_dir):
         project_dir = find_project_dir_above(project_dir)
 
     is_test_running = CTX_META_TEST_IS_RUNNING in ctx.meta
@@ -93,6 +96,9 @@ def cli(
         config = ProjectConfig.get_instance(project_conf)
         config.validate(environment)
 
+        if list_targets:
+            return print_target_list(list(environment) or config.envs())
+
         # clean obsolete build dir
         if not disable_auto_clean:
             build_dir = config.get_optional_dir("build")
@@ -142,7 +148,7 @@ def cli(
         command_failed = any(r.get("succeeded") is False for r in results)
 
         if not is_test_running and (command_failed or not silent) and len(results) > 1:
-            print_processing_summary(results)
+            print_processing_summary(results, verbose)
 
         if command_failed:
             raise exception.ReturnErrorCode(1)
@@ -195,7 +201,7 @@ def print_processing_header(env, config, verbose=False):
         "Processing %s (%s)"
         % (click.style(env, fg="cyan", bold=True), "; ".join(env_dump))
     )
-    terminal_width, _ = click.get_terminal_size()
+    terminal_width, _ = shutil.get_terminal_size()
     click.secho("-" * terminal_width, bold=True)
 
 
@@ -215,7 +221,7 @@ def print_processing_footer(result):
     )
 
 
-def print_processing_summary(results):
+def print_processing_summary(results, verbose=False):
     tabular_data = []
     succeeded_nums = 0
     failed_nums = 0
@@ -227,6 +233,8 @@ def print_processing_summary(results):
             failed_nums += 1
             status_str = click.style("FAILED", fg="red")
         elif result.get("succeeded") is None:
+            if not verbose:
+                continue
             status_str = "IGNORED"
         else:
             succeeded_nums += 1
@@ -261,3 +269,33 @@ def print_processing_summary(results):
         is_error=failed_nums,
         fg="red" if failed_nums else "green",
     )
+
+
+def print_target_list(envs):
+    tabular_data = []
+    for env, data in load_project_ide_data(os.getcwd(), envs).items():
+        tabular_data.extend(
+            sorted(
+                [
+                    (
+                        click.style(env, fg="cyan"),
+                        t["group"],
+                        click.style(t.get("name"), fg="yellow"),
+                        t["title"],
+                        t.get("description"),
+                    )
+                    for t in data.get("targets", [])
+                ],
+                key=operator.itemgetter(1, 2),
+            )
+        )
+        tabular_data.append((None, None, None, None, None))
+    click.echo(
+        tabulate(
+            tabular_data,
+            headers=[
+                click.style(s, bold=True)
+                for s in ("Environment", "Group", "Name", "Title", "Description")
+            ],
+        ),
+    )

platformio/commands/run/helpers.py

@@ -54,11 +54,11 @@ def clean_build_dir(build_dir, config):
     if isdir(build_dir):
         # check project structure
         if isfile(checksum_file):
-            with open(checksum_file) as fp:
+            with open(checksum_file, encoding="utf8") as fp:
                 if fp.read() == checksum:
                     return
         fs.rmtree(build_dir)
 
     makedirs(build_dir)
-    with open(checksum_file, "w") as fp:
+    with open(checksum_file, mode="w", encoding="utf8") as fp:
         fp.write(checksum)

platformio/commands/run/processor.py

@@ -12,10 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from platformio import exception
-from platformio.commands.platform import platform_install as cmd_platform_install
+from platformio.commands.platform import init_platform
 from platformio.commands.test.processor import CTX_META_TEST_RUNNING_NAME
-from platformio.managers.platform import PlatformFactory
 from platformio.project.exception import UndefinedEnvPlatformError
 
 # pylint: disable=too-many-instance-attributes
@@ -66,15 +64,7 @@ class EnvironmentProcessor(object):
         if "monitor" in build_targets:
             build_targets.remove("monitor")
 
-        try:
-            p = PlatformFactory.newPlatform(self.options["platform"])
-        except exception.UnknownPlatform:
-            self.cmd_ctx.invoke(
-                cmd_platform_install,
-                platforms=[self.options["platform"]],
-                skip_default_package=True,
-            )
-            p = PlatformFactory.newPlatform(self.options["platform"])
-
-        result = p.run(build_vars, build_targets, self.silent, self.verbose, self.jobs)
+        result = init_platform(self.options["platform"]).run(
+            build_vars, build_targets, self.silent, self.verbose, self.jobs
+        )
         return result["returncode"] == 0

platformio/commands/settings.py

@@ -27,7 +27,7 @@ def format_value(raw):
     return str(raw)
 
 
-@click.group(short_help="Manage PlatformIO settings")
+@click.group(short_help="Manage system settings")
 def cli():
     pass
 

platformio/commands/system/command.py

@@ -0,0 +1,214 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+import json
+import platform
+import subprocess
+import sys
+
+import click
+from tabulate import tabulate
+
+from platformio import __version__, compat, fs, proc, util
+from platformio.commands.system.completion import (
+    get_completion_install_path,
+    install_completion_code,
+    uninstall_completion_code,
+)
+from platformio.commands.system.prune import (
+    prune_cached_data,
+    prune_core_packages,
+    prune_platform_packages,
+)
+from platformio.package.manager.library import LibraryPackageManager
+from platformio.package.manager.platform import PlatformPackageManager
+from platformio.package.manager.tool import ToolPackageManager
+from platformio.project.config import ProjectConfig
+
+
+@click.group("system", short_help="Miscellaneous system commands")
+def cli():
+    pass
+
+
+@cli.command("info", short_help="Display system-wide information")
+@click.option("--json-output", is_flag=True)
+def system_info(json_output):
+    project_config = ProjectConfig()
+    data = {}
+    data["core_version"] = {"title": "PlatformIO Core", "value": __version__}
+    data["python_version"] = {
+        "title": "Python",
+        "value": "{0}.{1}.{2}-{3}.{4}".format(*list(sys.version_info)),
+    }
+    data["system"] = {"title": "System Type", "value": util.get_systype()}
+    data["platform"] = {"title": "Platform", "value": platform.platform(terse=True)}
+    data["filesystem_encoding"] = {
+        "title": "File System Encoding",
+        "value": compat.get_filesystem_encoding(),
+    }
+    data["locale_encoding"] = {
+        "title": "Locale Encoding",
+        "value": compat.get_locale_encoding(),
+    }
+    data["core_dir"] = {
+        "title": "PlatformIO Core Directory",
+        "value": project_config.get_optional_dir("core"),
+    }
+    data["platformio_exe"] = {
+        "title": "PlatformIO Core Executable",
+        "value": proc.where_is_program(
+            "platformio.exe" if compat.IS_WINDOWS else "platformio"
+        ),
+    }
+    data["python_exe"] = {
+        "title": "Python Executable",
+        "value": proc.get_pythonexe_path(),
+    }
+    data["global_lib_nums"] = {
+        "title": "Global Libraries",
+        "value": len(LibraryPackageManager().get_installed()),
+    }
+    data["dev_platform_nums"] = {
+        "title": "Development Platforms",
+        "value": len(PlatformPackageManager().get_installed()),
+    }
+    data["package_tool_nums"] = {
+        "title": "Tools & Toolchains",
+        "value": len(
+            ToolPackageManager(
+                project_config.get_optional_dir("packages")
+            ).get_installed()
+        ),
+    }
+
+    click.echo(
+        json.dumps(data)
+        if json_output
+        else tabulate([(item["title"], item["value"]) for item in data.values()])
+    )
+
+
+@cli.command("prune", short_help="Remove unused data")
+@click.option("--force", "-f", is_flag=True, help="Do not prompt for confirmation")
+@click.option(
+    "--dry-run", is_flag=True, help="Do not prune, only show data that will be removed"
+)
+@click.option("--cache", is_flag=True, help="Prune only cached data")
+@click.option(
+    "--core-packages", is_flag=True, help="Prune only unnecessary core packages"
+)
+@click.option(
+    "--platform-packages",
+    is_flag=True,
+    help="Prune only unnecessary development platform packages",
+)
+def system_prune(force, dry_run, cache, core_packages, platform_packages):
+    if dry_run:
+        click.secho(
+            "Dry run mode (do not prune, only show data that will be removed)",
+            fg="yellow",
+        )
+        click.echo()
+
+    reclaimed_cache = 0
+    reclaimed_core_packages = 0
+    reclaimed_platform_packages = 0
+    prune_all = not any([cache, core_packages, platform_packages])
+
+    if cache or prune_all:
+        reclaimed_cache = prune_cached_data(force, dry_run)
+        click.echo()
+
+    if core_packages or prune_all:
+        reclaimed_core_packages = prune_core_packages(force, dry_run)
+        click.echo()
+
+    if platform_packages or prune_all:
+        reclaimed_platform_packages = prune_platform_packages(force, dry_run)
+        click.echo()
+
+    click.secho(
+        "Total reclaimed space: %s"
+        % fs.humanize_file_size(
+            reclaimed_cache + reclaimed_core_packages + reclaimed_platform_packages
+        ),
+        fg="green",
+    )
+
+
+@cli.group("completion", short_help="Shell completion support")
+def completion():
+    # pylint: disable=import-error,import-outside-toplevel
+    try:
+        import click_completion  # pylint: disable=unused-import,unused-variable
+    except ImportError:
+        click.echo("Installing dependent packages...")
+        subprocess.check_call(
+            [proc.get_pythonexe_path(), "-m", "pip", "install", "click-completion"],
+        )
+
+
+@completion.command("install", short_help="Install shell completion files/code")
+@click.option(
+    "--shell",
+    default=None,
+    type=click.Choice(["fish", "bash", "zsh", "powershell", "auto"]),
+    help="The shell type, default=auto",
+)
+@click.option(
+    "--path",
+    type=click.Path(file_okay=True, dir_okay=False, readable=True, resolve_path=True),
+    help="Custom installation path of the code to be evaluated by the shell. "
+    "The standard installation path is used by default.",
+)
+def completion_install(shell, path):
+
+    import click_completion  # pylint: disable=import-outside-toplevel,import-error
+
+    shell = shell or click_completion.get_auto_shell()
+    path = path or get_completion_install_path(shell)
+    install_completion_code(shell, path)
+    click.echo(
+        "PlatformIO CLI completion has been installed for %s shell to %s \n"
+        "Please restart a current shell session."
+        % (click.style(shell, fg="cyan"), click.style(path, fg="blue"))
+    )
+
+
+@completion.command("uninstall", short_help="Uninstall shell completion files/code")
+@click.option(
+    "--shell",
+    default=None,
+    type=click.Choice(["fish", "bash", "zsh", "powershell", "auto"]),
+    help="The shell type, default=auto",
+)
+@click.option(
+    "--path",
+    type=click.Path(file_okay=True, dir_okay=False, readable=True, resolve_path=True),
+    help="Custom installation path of the code to be evaluated by the shell. "
+    "The standard installation path is used by default.",
+)
+def completion_uninstall(shell, path):
+
+    import click_completion  # pylint: disable=import-outside-toplevel,import-error
+
+    shell = shell or click_completion.get_auto_shell()
+    path = path or get_completion_install_path(shell)
+    uninstall_completion_code(shell, path)
+    click.echo(
+        "PlatformIO CLI completion has been uninstalled for %s shell from %s \n"
+        "Please restart a current shell session."
+        % (click.style(shell, fg="cyan"), click.style(path, fg="blue"))
+    )

platformio/commands/system/completion.py

@@ -0,0 +1,73 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+import os
+import subprocess
+
+import click
+
+
+def get_completion_install_path(shell):
+    home_dir = os.path.expanduser("~")
+    prog_name = click.get_current_context().find_root().info_name
+    if shell == "fish":
+        return os.path.join(
+            home_dir, ".config", "fish", "completions", "%s.fish" % prog_name
+        )
+    if shell == "bash":
+        return os.path.join(home_dir, ".bash_completion")
+    if shell == "zsh":
+        return os.path.join(home_dir, ".zshrc")
+    if shell == "powershell":
+        return subprocess.check_output(
+            ["powershell", "-NoProfile", "echo $profile"]
+        ).strip()
+    raise click.ClickException("%s is not supported." % shell)
+
+
+def is_completion_code_installed(shell, path):
+    if shell == "fish" or not os.path.exists(path):
+        return False
+
+    import click_completion  # pylint: disable=import-error,import-outside-toplevel
+
+    with open(path, encoding="utf8") as fp:
+        return click_completion.get_code(shell=shell) in fp.read()
+
+
+def install_completion_code(shell, path):
+    import click_completion  # pylint: disable=import-error,import-outside-toplevel
+
+    if is_completion_code_installed(shell, path):
+        return None
+
+    return click_completion.install(shell=shell, path=path, append=shell != "fish")
+
+
+def uninstall_completion_code(shell, path):
+    if not os.path.exists(path):
+        return True
+    if shell == "fish":
+        os.remove(path)
+        return True
+
+    import click_completion  # pylint: disable=import-error,import-outside-toplevel
+
+    with open(path, "r+", encoding="utf8") as fp:
+        contents = fp.read()
+        fp.seek(0)
+        fp.truncate()
+        fp.write(contents.replace(click_completion.get_code(shell=shell), ""))
+
+    return True

platformio/commands/system/prune.py

@@ -0,0 +1,98 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+import os
+from operator import itemgetter
+
+import click
+from tabulate import tabulate
+
+from platformio import fs
+from platformio.package.manager.core import remove_unnecessary_core_packages
+from platformio.package.manager.platform import remove_unnecessary_platform_packages
+from platformio.project.helpers import get_project_cache_dir
+
+
+def prune_cached_data(force=False, dry_run=False, silent=False):
+    reclaimed_space = 0
+    if not silent:
+        click.secho("Prune cached data:", bold=True)
+        click.echo(" - cached API requests")
+        click.echo(" - cached package downloads")
+        click.echo(" - temporary data")
+    cache_dir = get_project_cache_dir()
+    if os.path.isdir(cache_dir):
+        reclaimed_space += fs.calculate_folder_size(cache_dir)
+        if not dry_run:
+            if not force:
+                click.confirm("Do you want to continue?", abort=True)
+            fs.rmtree(cache_dir)
+    if not silent:
+        click.secho("Space on disk: %s" % fs.humanize_file_size(reclaimed_space))
+    return reclaimed_space
+
+
+def prune_core_packages(force=False, dry_run=False, silent=False):
+    if not silent:
+        click.secho("Prune unnecessary core packages:", bold=True)
+    return _prune_packages(force, dry_run, silent, remove_unnecessary_core_packages)
+
+
+def prune_platform_packages(force=False, dry_run=False, silent=False):
+    if not silent:
+        click.secho("Prune unnecessary development platform packages:", bold=True)
+    return _prune_packages(force, dry_run, silent, remove_unnecessary_platform_packages)
+
+
+def _prune_packages(force, dry_run, silent, handler):
+    if not silent:
+        click.echo("Calculating...")
+    items = [
+        (
+            pkg,
+            fs.calculate_folder_size(pkg.path),
+        )
+        for pkg in handler(dry_run=True)
+    ]
+    items = sorted(items, key=itemgetter(1), reverse=True)
+    reclaimed_space = sum([item[1] for item in items])
+    if items and not silent:
+        click.echo(
+            tabulate(
+                [
+                    (
+                        pkg.metadata.spec.humanize(),
+                        str(pkg.metadata.version),
+                        fs.humanize_file_size(size),
+                    )
+                    for (pkg, size) in items
+                ],
+                headers=["Package", "Version", "Size"],
+            )
+        )
+    if not dry_run:
+        if not force:
+            click.confirm("Do you want to continue?", abort=True)
+        handler(dry_run=False)
+    if not silent:
+        click.secho("Space on disk: %s" % fs.humanize_file_size(reclaimed_space))
+    return reclaimed_space
+
+
+def calculate_unnecessary_system_data():
+    return (
+        prune_cached_data(force=True, dry_run=True, silent=True)
+        + prune_core_packages(force=True, dry_run=True, silent=True)
+        + prune_platform_packages(force=True, dry_run=True, silent=True)
+    )

platformio/commands/team.py

@@ -0,0 +1,212 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+# pylint: disable=unused-argument
+
+import json
+import re
+
+import click
+from tabulate import tabulate
+
+from platformio.clients.account import AccountClient
+
+
+def validate_orgname_teamname(value, teamname_validate=False):
+    if ":" not in value:
+        raise click.BadParameter(
+            "Please specify organization and team name in the next"
+            " format - orgname:teamname. For example, mycompany:DreamTeam"
+        )
+    teamname = str(value.strip().split(":", 1)[1])
+    if teamname_validate:
+        validate_teamname(teamname)
+    return value
+
+
+def validate_teamname(value):
+    if not value:
+        return value
+    value = str(value).strip()
+    if not re.match(r"^[a-z\d](?:[a-z\d]|[\-_ ](?=[a-z\d])){0,19}$", value, flags=re.I):
+        raise click.BadParameter(
+            "Invalid team name format. "
+            "Team name must only contain alphanumeric characters, "
+            "single hyphens, underscores, spaces. It can not "
+            "begin or end with a hyphen or a underscore and must"
+            " not be longer than 20 characters."
+        )
+    return value
+
+
+@click.group("team", short_help="Manage organization teams")
+def cli():
+    pass
+
+
+@cli.command("create", short_help="Create a new team")
+@click.argument(
+    "orgname_teamname",
+    metavar="ORGNAME:TEAMNAME",
+    callback=lambda _, __, value: validate_orgname_teamname(
+        value, teamname_validate=True
+    ),
+)
+@click.option(
+    "--description",
+)
+def team_create(orgname_teamname, description):
+    orgname, teamname = orgname_teamname.split(":", 1)
+    client = AccountClient()
+    client.create_team(orgname, teamname, description)
+    return click.secho(
+        "The team %s has been successfully created." % teamname,
+        fg="green",
+    )
+
+
+@cli.command("list", short_help="List teams")
+@click.argument("orgname", required=False)
+@click.option("--json-output", is_flag=True)
+def team_list(orgname, json_output):
+    client = AccountClient()
+    data = {}
+    if not orgname:
+        for item in client.list_orgs():
+            teams = client.list_teams(item.get("orgname"))
+            data[item.get("orgname")] = teams
+    else:
+        teams = client.list_teams(orgname)
+        data[orgname] = teams
+    if json_output:
+        return click.echo(json.dumps(data[orgname] if orgname else data))
+    if not any(data.values()):
+        return click.secho("You do not have any teams.", fg="yellow")
+    for org_name in data:
+        for team in data[org_name]:
+            click.echo()
+            click.secho("%s:%s" % (org_name, team.get("name")), fg="cyan")
+            click.echo("-" * len("%s:%s" % (org_name, team.get("name"))))
+            table_data = []
+            if team.get("description"):
+                table_data.append(("Description:", team.get("description")))
+            table_data.append(
+                (
+                    "Members:",
+                    ", ".join(
+                        (member.get("username") for member in team.get("members"))
+                    )
+                    if team.get("members")
+                    else "-",
+                )
+            )
+            click.echo(tabulate(table_data, tablefmt="plain"))
+    return click.echo()
+
+
+@cli.command("update", short_help="Update team")
+@click.argument(
+    "orgname_teamname",
+    metavar="ORGNAME:TEAMNAME",
+    callback=lambda _, __, value: validate_orgname_teamname(value),
+)
+@click.option(
+    "--name",
+    callback=lambda _, __, value: validate_teamname(value),
+    help="A new team name",
+)
+@click.option(
+    "--description",
+)
+def team_update(orgname_teamname, **kwargs):
+    orgname, teamname = orgname_teamname.split(":", 1)
+    client = AccountClient()
+    team = client.get_team(orgname, teamname)
+    del team["id"]
+    del team["members"]
+    new_team = team.copy()
+    if not any(kwargs.values()):
+        for field in team:
+            new_team[field] = click.prompt(
+                field.replace("_", " ").capitalize(), default=team[field]
+            )
+            if field == "name":
+                validate_teamname(new_team[field])
+    else:
+        new_team.update({key: value for key, value in kwargs.items() if value})
+    client.update_team(orgname, teamname, new_team)
+    return click.secho(
+        "The team %s has been successfully updated." % teamname,
+        fg="green",
+    )
+
+
+@cli.command("destroy", short_help="Destroy a team")
+@click.argument(
+    "orgname_teamname",
+    metavar="ORGNAME:TEAMNAME",
+    callback=lambda _, __, value: validate_orgname_teamname(value),
+)
+def team_destroy(orgname_teamname):
+    orgname, teamname = orgname_teamname.split(":", 1)
+    click.confirm(
+        click.style(
+            "Are you sure you want to destroy the %s team?" % teamname, fg="yellow"
+        ),
+        abort=True,
+    )
+    client = AccountClient()
+    client.destroy_team(orgname, teamname)
+    return click.secho(
+        "The team %s has been successfully destroyed." % teamname,
+        fg="green",
+    )
+
+
+@cli.command("add", short_help="Add a new member to team")
+@click.argument(
+    "orgname_teamname",
+    metavar="ORGNAME:TEAMNAME",
+    callback=lambda _, __, value: validate_orgname_teamname(value),
+)
+@click.argument(
+    "username",
+)
+def team_add_member(orgname_teamname, username):
+    orgname, teamname = orgname_teamname.split(":", 1)
+    client = AccountClient()
+    client.add_team_member(orgname, teamname, username)
+    return click.secho(
+        "The new member %s has been successfully added to the %s team."
+        % (username, teamname),
+        fg="green",
+    )
+
+
+@cli.command("remove", short_help="Remove a member from team")
+@click.argument(
+    "orgname_teamname",
+    metavar="ORGNAME:TEAMNAME",
+    callback=lambda _, __, value: validate_orgname_teamname(value),
+)
+@click.argument("username")
+def team_remove_owner(orgname_teamname, username):
+    orgname, teamname = orgname_teamname.split(":", 1)
+    client = AccountClient()
+    client.remove_team_member(orgname, teamname, username)
+    return click.secho(
+        "The %s member has been successfully removed from the %s team."
+        % (username, teamname),
+        fg="green",
+    )

platformio/commands/test/command.py

@@ -14,21 +14,23 @@
 
 # pylint: disable=too-many-arguments, too-many-locals, too-many-branches
 
-from fnmatch import fnmatch
-from os import getcwd, listdir
-from os.path import isdir, join
+import fnmatch
+import os
+import shutil
 from time import time
 
 import click
 from tabulate import tabulate
 
 from platformio import app, exception, fs, util
+from platformio.commands.platform import init_platform
 from platformio.commands.test.embedded import EmbeddedTestProcessor
+from platformio.commands.test.helpers import get_test_names
 from platformio.commands.test.native import NativeTestProcessor
 from platformio.project.config import ProjectConfig
 
 
-@click.command("test", short_help="Unit Testing")
+@click.command("test", short_help="Unit testing")
 @click.option("--environment", "-e", multiple=True, metavar="<environment>")
 @click.option(
     "--filter",
@@ -49,7 +51,7 @@ from platformio.project.config import ProjectConfig
 @click.option(
     "-d",
     "--project-dir",
-    default=getcwd,
+    default=os.getcwd,
     type=click.Path(
         exists=True, file_okay=False, dir_okay=True, writable=True, resolve_path=True
     ),
@@ -101,11 +103,7 @@ def cli(  # pylint: disable=redefined-builtin
     with fs.cd(project_dir):
         config = ProjectConfig.get_instance(project_conf)
         config.validate(envs=environment)
-
-        test_dir = config.get_optional_dir("test")
-        if not isdir(test_dir):
-            raise exception.TestDirNotExists(test_dir)
-        test_names = get_test_names(test_dir)
+        test_names = get_test_names(config)
 
         if not verbose:
             click.echo("Verbose mode can be enabled via `-v, --verbose` option")
@@ -128,9 +126,11 @@ def cli(  # pylint: disable=redefined-builtin
                     not environment and default_envs and envname not in default_envs,
                     testname != "*"
                     and patterns["filter"]
-                    and not any([fnmatch(testname, p) for p in patterns["filter"]]),
+                    and not any(
+                        fnmatch.fnmatch(testname, p) for p in patterns["filter"]
+                    ),
                     testname != "*"
-                    and any([fnmatch(testname, p) for p in patterns["ignore"]]),
+                    and any(fnmatch.fnmatch(testname, p) for p in patterns["ignore"]),
                 ]
                 if any(skip_conditions):
                     results.append({"env": envname, "test": testname})
@@ -140,9 +140,10 @@ def cli(  # pylint: disable=redefined-builtin
                 print_processing_header(testname, envname)
 
                 cls = (
-                    NativeTestProcessor
-                    if config.get(section, "platform") == "native"
-                    else EmbeddedTestProcessor
+                    EmbeddedTestProcessor
+                    if config.get(section, "platform")
+                    and init_platform(config.get(section, "platform")).is_embedded()
+                    else NativeTestProcessor
                 )
                 tp = cls(
                     ctx,
@@ -177,23 +178,13 @@ def cli(  # pylint: disable=redefined-builtin
     if without_testing:
         return
 
-    print_testing_summary(results)
+    print_testing_summary(results, verbose)
 
     command_failed = any(r.get("succeeded") is False for r in results)
     if command_failed:
         raise exception.ReturnErrorCode(1)
 
 
-def get_test_names(test_dir):
-    names = []
-    for item in sorted(listdir(test_dir)):
-        if isdir(join(test_dir, item)):
-            names.append(item)
-    if not names:
-        names = ["*"]
-    return names
-
-
 def print_processing_header(test, env):
     click.echo(
         "Processing %s in %s environment"
@@ -202,7 +193,7 @@ def print_processing_header(test, env):
             click.style(env, fg="cyan", bold=True),
         )
     )
-    terminal_width, _ = click.get_terminal_size()
+    terminal_width, _ = shutil.get_terminal_size()
     click.secho("-" * terminal_width, bold=True)
 
 
@@ -222,7 +213,7 @@ def print_processing_footer(result):
     )
 
 
-def print_testing_summary(results):
+def print_testing_summary(results, verbose=False):
     click.echo()
 
     tabular_data = []
@@ -236,6 +227,8 @@ def print_testing_summary(results):
             failed_nums += 1
             status_str = click.style("FAILED", fg="red")
         elif result.get("succeeded") is None:
+            if not verbose:
+                continue
             status_str = "IGNORED"
         else:
             succeeded_nums += 1

platformio/commands/test/embedded.py

@@ -19,7 +19,7 @@ import serial
 
 from platformio import exception, util
 from platformio.commands.test.processor import TestProcessorBase
-from platformio.managers.platform import PlatformFactory
+from platformio.platform.factory import PlatformFactory
 
 
 class EmbeddedTestProcessor(TestProcessorBase):
@@ -95,7 +95,7 @@ class EmbeddedTestProcessor(TestProcessorBase):
             if isinstance(line, bytes):
                 line = line.decode("utf8", "ignore")
             self.on_run_out(line)
-            if all([l in line for l in ("Tests", "Failures", "Ignored")]):
+            if all(l in line for l in ("Tests", "Failures", "Ignored")):
                 break
         ser.close()
         return not self._run_failed
@@ -108,7 +108,7 @@ class EmbeddedTestProcessor(TestProcessorBase):
             return self.env_options.get("test_port")
 
         assert set(["platform", "board"]) & set(self.env_options.keys())
-        p = PlatformFactory.newPlatform(self.env_options["platform"])
+        p = PlatformFactory.new(self.env_options["platform"])
         board_hwids = p.board_config(self.env_options["board"]).get("build.hwids", [])
         port = None
         elapsed = 0
@@ -117,13 +117,10 @@ class EmbeddedTestProcessor(TestProcessorBase):
                 port = item["port"]
                 for hwid in board_hwids:
                     hwid_str = ("%s:%s" % (hwid[0], hwid[1])).replace("0x", "")
-                    if hwid_str in item["hwid"]:
+                    if hwid_str in item["hwid"] and self.is_serial_port_ready(port):
                         return port
 
-            # check if port is already configured
-            try:
-                serial.Serial(port, timeout=self.SERIAL_TIMEOUT).close()
-            except serial.SerialException:
+            if port and not self.is_serial_port_ready(port):
                 port = None
 
             if not port:
@@ -136,3 +133,18 @@ class EmbeddedTestProcessor(TestProcessorBase):
                 "global `--test-port` option."
             )
         return port
+
+    @staticmethod
+    def is_serial_port_ready(port, timeout=3):
+        if not port:
+            return False
+        elapsed = 0
+        while elapsed < timeout:
+            try:
+                serial.Serial(port, timeout=1).close()
+                return True
+            except:  # pylint: disable=bare-except
+                pass
+            sleep(1)
+            elapsed += 1
+        return False

platformio/commands/test/helpers.py

@@ -12,17 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from twisted.internet import reactor  # pylint: disable=import-error
-from twisted.web import static  # pylint: disable=import-error
+import os
+
+from platformio import exception
 
 
-class WebRoot(static.File):
-    def render_GET(self, request):
-        if request.args.get(b"__shutdown__", False):
-            reactor.stop()
-            return "Server has been stopped"
-
-        request.setHeader("cache-control", "no-cache, no-store, must-revalidate")
-        request.setHeader("pragma", "no-cache")
-        request.setHeader("expires", "0")
-        return static.File.render_GET(self, request)
+def get_test_names(config):
+    test_dir = config.get_optional_dir("test")
+    if not os.path.isdir(test_dir):
+        raise exception.TestDirNotExists(test_dir)
+    names = []
+    for item in sorted(os.listdir(test_dir)):
+        if os.path.isdir(os.path.join(test_dir, item)):
+            names.append(item)
+    if not names:
+        names = ["*"]
+    return names

platformio/commands/test/processor.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import atexit
-from os import remove
+from os import listdir, remove
 from os.path import isdir, isfile, join
 from string import Template
 
@@ -25,33 +25,39 @@ TRANSPORT_OPTIONS = {
     "arduino": {
         "include": "#include <Arduino.h>",
         "object": "",
-        "putchar": "Serial.write(c)",
-        "flush": "Serial.flush()",
-        "begin": "Serial.begin($baudrate)",
-        "end": "Serial.end()",
+        "putchar": "Serial.write(c);",
+        "flush": "Serial.flush();",
+        "begin": "Serial.begin($baudrate);",
+        "end": "Serial.end();",
         "language": "cpp",
     },
     "mbed": {
         "include": "#include <mbed.h>",
-        "object": "Serial pc(USBTX, USBRX);",
-        "putchar": "pc.putc(c)",
+        "object": (
+            "#if MBED_MAJOR_VERSION == 6\nUnbufferedSerial pc(USBTX, USBRX);\n"
+            "#else\nRawSerial pc(USBTX, USBRX);\n#endif"
+        ),
+        "putchar": (
+            "#if MBED_MAJOR_VERSION == 6\npc.write(&c, 1);\n"
+            "#else\npc.putc(c);\n#endif"
+        ),
         "flush": "",
-        "begin": "pc.baud($baudrate)",
+        "begin": "pc.baud($baudrate);",
         "end": "",
         "language": "cpp",
     },
     "espidf": {
         "include": "#include <stdio.h>",
         "object": "",
-        "putchar": "putchar(c)",
-        "flush": "fflush(stdout)",
+        "putchar": "putchar(c);",
+        "flush": "fflush(stdout);",
         "begin": "",
         "end": "",
     },
     "zephyr": {
         "include": "#include <sys/printk.h>",
         "object": "",
-        "putchar": 'printk("%c", c)',
+        "putchar": 'printk("%c", c);',
         "flush": "",
         "begin": "",
         "end": "",
@@ -59,18 +65,18 @@ TRANSPORT_OPTIONS = {
     "native": {
         "include": "#include <stdio.h>",
         "object": "",
-        "putchar": "putchar(c)",
-        "flush": "fflush(stdout)",
+        "putchar": "putchar(c);",
+        "flush": "fflush(stdout);",
         "begin": "",
         "end": "",
     },
     "custom": {
         "include": '#include "unittest_transport.h"',
         "object": "",
-        "putchar": "unittest_uart_putchar(c)",
-        "flush": "unittest_uart_flush()",
-        "begin": "unittest_uart_begin()",
-        "end": "unittest_uart_end()",
+        "putchar": "unittest_uart_putchar(c);",
+        "flush": "unittest_uart_flush();",
+        "begin": "unittest_uart_begin();",
+        "end": "unittest_uart_end();",
         "language": "cpp",
     },
 }
@@ -132,9 +138,10 @@ class TestProcessorBase(object):
             return self.cmd_ctx.invoke(
                 cmd_run,
                 project_dir=self.options["project_dir"],
-                upload_port=self.options["upload_port"],
+                project_conf=self.options["project_config"].path,
+                upload_port=self.options.get("upload_port"),
                 verbose=self.options["verbose"],
-                silent=self.options["silent"],
+                silent=self.options.get("silent"),
                 environment=[self.env_name],
                 disable_auto_clean="nobuild" in target,
                 target=target,
@@ -174,44 +181,50 @@ class TestProcessorBase(object):
                 "void output_start(unsigned int baudrate)",
                 "#endif",
                 "{",
-                "    $begin;",
+                "    $begin",
                 "}",
                 "",
                 "void output_char(int c)",
                 "{",
-                "    $putchar;",
+                "    $putchar",
                 "}",
                 "",
                 "void output_flush(void)",
                 "{",
-                "    $flush;",
+                "    $flush",
                 "}",
                 "",
                 "void output_complete(void)",
                 "{",
-                "   $end;",
+                "   $end",
                 "}",
             ]
         )
 
-        def delete_tmptest_file(file_):
-            try:
-                remove(file_)
-            except:  # pylint: disable=bare-except
-                if isfile(file_):
-                    click.secho(
-                        "Warning: Could not remove temporary file '%s'. "
-                        "Please remove it manually." % file_,
-                        fg="yellow",
-                    )
+        tmp_file_prefix = "tmp_pio_test_transport"
+
+        def delete_tmptest_files(test_dir):
+            for item in listdir(test_dir):
+                if item.startswith(tmp_file_prefix) and isfile(join(test_dir, item)):
+                    try:
+                        remove(join(test_dir, item))
+                    except:  # pylint: disable=bare-except
+                        click.secho(
+                            "Warning: Could not remove temporary file '%s'. "
+                            "Please remove it manually." % join(test_dir, item),
+                            fg="yellow",
+                        )
 
         transport_options = TRANSPORT_OPTIONS[self.get_transport()]
         tpl = Template(file_tpl).substitute(transport_options)
         data = Template(tpl).substitute(baudrate=self.get_baudrate())
+
+        delete_tmptest_files(test_dir)
         tmp_file = join(
-            test_dir, "output_export." + transport_options.get("language", "c")
+            test_dir,
+            "%s.%s" % (tmp_file_prefix, transport_options.get("language", "c")),
         )
-        with open(tmp_file, "w") as fp:
+        with open(tmp_file, mode="w", encoding="utf8") as fp:
             fp.write(data)
 
-        atexit.register(delete_tmptest_file, tmp_file)
+        atexit.register(delete_tmptest_files, test_dir)

platformio/commands/update.py

@@ -14,12 +14,12 @@
 
 import click
 
-from platformio import app
-from platformio.commands.lib import CTX_META_STORAGE_DIRS_KEY
-from platformio.commands.lib import lib_update as cmd_lib_update
+from platformio.cache import cleanup_content_cache
+from platformio.commands.lib.command import CTX_META_STORAGE_DIRS_KEY
+from platformio.commands.lib.command import lib_update as cmd_lib_update
 from platformio.commands.platform import platform_update as cmd_platform_update
-from platformio.managers.core import update_core_packages
-from platformio.managers.lib import LibraryManager
+from platformio.package.manager.core import update_core_packages
+from platformio.package.manager.library import LibraryPackageManager
 
 
 @click.command(
@@ -38,7 +38,7 @@ from platformio.managers.lib import LibraryManager
 @click.pass_context
 def cli(ctx, core_packages, only_check, dry_run):
     # cleanup lib search results, cached board and platform lists
-    app.clean_cache()
+    cleanup_content_cache("http")
 
     only_check = dry_run or only_check
 
@@ -55,5 +55,5 @@ def cli(ctx, core_packages, only_check, dry_run):
     click.echo()
     click.echo("Library Manager")
     click.echo("===============")
-    ctx.meta[CTX_META_STORAGE_DIRS_KEY] = [LibraryManager().package_dir]
+    ctx.meta[CTX_META_STORAGE_DIRS_KEY] = [LibraryPackageManager().package_dir]
     ctx.invoke(cmd_lib_update, only_check=only_check)

platformio/commands/upgrade.py

@@ -12,15 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import json
 import os
 import re
 from zipfile import ZipFile
 
 import click
-import requests
 
 from platformio import VERSION, __version__, app, exception
-from platformio.compat import WINDOWS
+from platformio.clients.http import fetch_remote_content
+from platformio.compat import IS_WINDOWS
 from platformio.proc import exec_command, get_pythonexe_path
 from platformio.project.helpers import get_project_cache_dir
 
@@ -39,7 +40,7 @@ def cli(dev):
 
     to_develop = dev or not all(c.isdigit() for c in __version__ if c != ".")
     cmds = (
-        ["pip", "install", "--upgrade", get_pip_package(to_develop)],
+        ["pip", "install", "--upgrade", download_dist_package(to_develop)],
         ["platformio", "--version"],
     )
 
@@ -72,7 +73,7 @@ def cli(dev):
         if not r:
             raise exception.UpgradeError("\n".join([str(cmd), str(e)]))
         permission_errors = ("permission denied", "not permitted")
-        if any(m in r["err"].lower() for m in permission_errors) and not WINDOWS:
+        if any(m in r["err"].lower() for m in permission_errors) and not IS_WINDOWS:
             click.secho(
                 """
 -----------------
@@ -93,7 +94,7 @@ WARNING! Don't use `sudo` for the rest PlatformIO commands.
     return True
 
 
-def get_pip_package(to_develop):
+def download_dist_package(to_develop):
     if not to_develop:
         return "platformio"
     dl_url = "https://github.com/platformio/platformio-core/archive/develop.zip"
@@ -102,7 +103,7 @@ def get_pip_package(to_develop):
         os.makedirs(cache_dir)
     pkg_name = os.path.join(cache_dir, "piocoredevelop.zip")
     try:
-        with open(pkg_name, "w") as fp:
+        with open(pkg_name, "wb") as fp:
             r = exec_command(
                 ["curl", "-fsSL", dl_url], stdout=fp, universal_newlines=True
             )
@@ -130,13 +131,11 @@ def get_latest_version():
 
 def get_develop_latest_version():
     version = None
-    r = requests.get(
+    content = fetch_remote_content(
         "https://raw.githubusercontent.com/platformio/platformio"
-        "/develop/platformio/__init__.py",
-        headers={"User-Agent": app.get_user_agent()},
+        "/develop/platformio/__init__.py"
     )
-    r.raise_for_status()
-    for line in r.text.split("\n"):
+    for line in content.split("\n"):
         line = line.strip()
         if not line.startswith("VERSION"):
             continue
@@ -152,9 +151,5 @@ def get_develop_latest_version():
 
 
 def get_pypi_latest_version():
-    r = requests.get(
-        "https://pypi.org/pypi/platformio/json",
-        headers={"User-Agent": app.get_user_agent()},
-    )
-    r.raise_for_status()
-    return r.json()["info"]["version"]
+    content = fetch_remote_content("https://pypi.org/pypi/platformio/json")
+    return json.loads(content)["info"]["version"]

platformio/compat.py

@@ -12,19 +12,57 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pylint: disable=unused-import, no-name-in-module, import-error,
-# pylint: disable=no-member, undefined-variable
+# pylint: disable=unused-import,no-name-in-module
 
 import inspect
-import json
 import locale
-import os
-import re
 import sys
 
+from platformio.exception import UserSideException
+
+if sys.version_info >= (3,):
+    if sys.version_info >= (3, 7):
+        from asyncio import create_task as aio_create_task
+        from asyncio import get_running_loop as aio_get_running_loop
+    else:
+        from asyncio import ensure_future as aio_create_task
+        from asyncio import get_event_loop as aio_get_running_loop
+
+
 PY2 = sys.version_info[0] == 2
-CYGWIN = sys.platform.startswith("cygwin")
-WINDOWS = sys.platform.startswith("win")
+IS_CYGWIN = sys.platform.startswith("cygwin")
+IS_WINDOWS = WINDOWS = sys.platform.startswith("win")
+IS_MACOS = sys.platform.startswith("darwin")
+string_types = (str,)
+
+
+def is_bytes(x):
+    return isinstance(x, (bytes, memoryview, bytearray))
+
+
+def ci_strings_are_equal(a, b):
+    if a == b:
+        return True
+    if not a or not b:
+        return False
+    return a.strip().lower() == b.strip().lower()
+
+
+def hashlib_encode_data(data):
+    if is_bytes(data):
+        return data
+    if not isinstance(data, string_types):
+        data = str(data)
+    return data.encode()
+
+
+def load_python_module(name, pathname):
+    import importlib.util  # pylint: disable=import-outside-toplevel
+
+    spec = importlib.util.spec_from_file_location(name, pathname)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
 
 
 def get_filesystem_encoding():
@@ -49,81 +87,21 @@ def get_object_members(obj, ignore_private=True):
     }
 
 
-if PY2:
-    import imp
-
-    string_types = (str, unicode)
-
-    def is_bytes(x):
-        return isinstance(x, (buffer, bytearray))
-
-    def path_to_unicode(path):
-        if isinstance(path, unicode):
-            return path
-        return path.decode(get_filesystem_encoding())
-
-    def hashlib_encode_data(data):
-        if is_bytes(data):
-            return data
-        if isinstance(data, unicode):
-            data = data.encode(get_filesystem_encoding())
-        elif not isinstance(data, string_types):
-            data = str(data)
-        return data
-
-    def dump_json_to_unicode(obj):
-        if isinstance(obj, unicode):
-            return obj
-        return json.dumps(
-            obj, encoding=get_filesystem_encoding(), ensure_ascii=False, sort_keys=True
-        ).encode("utf8")
-
-    _magic_check = re.compile("([*?[])")
-    _magic_check_bytes = re.compile(b"([*?[])")
-
-    def glob_escape(pathname):
-        """Escape all special characters."""
-        # https://github.com/python/cpython/blob/master/Lib/glob.py#L161
-        # Escaping is done by wrapping any of "*?[" between square brackets.
-        # Metacharacters do not work in the drive part and shouldn't be
-        # escaped.
-        drive, pathname = os.path.splitdrive(pathname)
-        if isinstance(pathname, bytes):
-            pathname = _magic_check_bytes.sub(br"[\1]", pathname)
-        else:
-            pathname = _magic_check.sub(r"[\1]", pathname)
-        return drive + pathname
-
-    def load_python_module(name, pathname):
-        return imp.load_source(name, pathname)
+def ensure_python3(raise_exception=True):
+    compatible = sys.version_info >= (3, 6)
+    if not raise_exception or compatible:
+        return compatible
+    raise UserSideException(
+        "Python 3.6 or later is required for this operation. \n"
+        "Please check a migration guide:\n"
+        "https://docs.platformio.org/en/latest/core/migration.html"
+        "#drop-support-for-python-2-and-3-5"
+    )
 
 
-else:
-    import importlib.util
-    from glob import escape as glob_escape
-
-    string_types = (str,)
-
-    def is_bytes(x):
-        return isinstance(x, (bytes, memoryview, bytearray))
-
-    def path_to_unicode(path):
-        return path
-
-    def hashlib_encode_data(data):
-        if is_bytes(data):
-            return data
-        if not isinstance(data, string_types):
-            data = str(data)
-        return data.encode()
-
-    def dump_json_to_unicode(obj):
-        if isinstance(obj, string_types):
-            return obj
-        return json.dumps(obj, ensure_ascii=False, sort_keys=True)
-
-    def load_python_module(name, pathname):
-        spec = importlib.util.spec_from_file_location(name, pathname)
-        module = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(module)
-        return module
+def path_to_unicode(path):
+    """
+    Deprecated: Compatibility with dev-platforms,
+    and custom device monitor filters
+    """
+    return path

platformio/debug/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.

platformio/debug/config/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.

platformio/debug/config/base.py

@@ -0,0 +1,246 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+import json
+import os
+
+from platformio import fs, proc, util
+from platformio.compat import string_types
+from platformio.debug.exception import DebugInvalidOptionsError
+from platformio.debug.helpers import reveal_debug_port
+from platformio.project.config import ProjectConfig
+from platformio.project.helpers import get_project_core_dir, load_project_ide_data
+from platformio.project.options import ProjectOptions
+
+
+class DebugConfigBase:  # pylint: disable=too-many-instance-attributes
+    def __init__(self, platform, project_config, env_name):
+        self.platform = platform
+        self.project_config = project_config
+        self.env_name = env_name
+        self.env_options = project_config.items(env=env_name, as_dict=True)
+        self.build_data = self._load_build_data()
+
+        self.tool_name = None
+        self.board_config = {}
+        self.tool_settings = {}
+        if "board" in self.env_options:
+            self.board_config = platform.board_config(self.env_options["board"])
+            self.tool_name = self.board_config.get_debug_tool_name(
+                self.env_options.get("debug_tool")
+            )
+            self.tool_settings = (
+                self.board_config.get("debug", {})
+                .get("tools", {})
+                .get(self.tool_name, {})
+            )
+
+        self._load_cmds = None
+        self._port = None
+
+        self.server = self._configure_server()
+
+        try:
+            platform.configure_debug_session(self)
+        except NotImplementedError:
+            pass
+
+    @staticmethod
+    def cleanup_cmds(items):
+        items = ProjectConfig.parse_multi_values(items)
+        return ["$LOAD_CMDS" if item == "$LOAD_CMD" else item for item in items]
+
+    @property
+    def program_path(self):
+        return self.build_data["prog_path"]
+
+    @property
+    def client_executable_path(self):
+        return self.build_data["gdb_path"]
+
+    @property
+    def load_cmds(self):
+        if self._load_cmds is not None:
+            return self._load_cmds
+        result = self.env_options.get("debug_load_cmds")
+        if not result:
+            result = self.tool_settings.get("load_cmds")
+        if not result:
+            # legacy
+            result = self.tool_settings.get("load_cmd")
+        if not result:
+            result = ProjectOptions["env.debug_load_cmds"].default
+        return self.cleanup_cmds(result)
+
+    @load_cmds.setter
+    def load_cmds(self, cmds):
+        self._load_cmds = cmds
+
+    @property
+    def load_mode(self):
+        result = self.env_options.get("debug_load_mode")
+        if not result:
+            result = self.tool_settings.get("load_mode")
+        return result or ProjectOptions["env.debug_load_mode"].default
+
+    @property
+    def init_break(self):
+        missed = object()
+        result = self.env_options.get("debug_init_break", missed)
+        if result != missed:
+            return result
+        result = None
+        if not result:
+            result = self.tool_settings.get("init_break")
+        return result or ProjectOptions["env.debug_init_break"].default
+
+    @property
+    def init_cmds(self):
+        return self.cleanup_cmds(
+            self.env_options.get("debug_init_cmds", self.tool_settings.get("init_cmds"))
+        )
+
+    @property
+    def extra_cmds(self):
+        return self.cleanup_cmds(
+            self.env_options.get("debug_extra_cmds")
+        ) + self.cleanup_cmds(self.tool_settings.get("extra_cmds"))
+
+    @property
+    def port(self):
+        return reveal_debug_port(
+            self.env_options.get("debug_port", self.tool_settings.get("port"))
+            or self._port,
+            self.tool_name,
+            self.tool_settings,
+        )
+
+    @port.setter
+    def port(self, value):
+        self._port = value
+
+    @property
+    def upload_protocol(self):
+        return self.env_options.get(
+            "upload_protocol", self.board_config.get("upload", {}).get("protocol")
+        )
+
+    @property
+    def speed(self):
+        return self.env_options.get("debug_speed", self.tool_settings.get("speed"))
+
+    @property
+    def server_ready_pattern(self):
+        return self.env_options.get(
+            "debug_server_ready_pattern", (self.server or {}).get("ready_pattern")
+        )
+
+    def _load_build_data(self):
+        data = load_project_ide_data(os.getcwd(), self.env_name, cache=True)
+        if data:
+            return data
+        raise DebugInvalidOptionsError("Could not load a build configuration")
+
+    def _configure_server(self):
+        result = None
+        # specific server per a system
+        if isinstance(self.tool_settings.get("server", {}), list):
+            for item in self.tool_settings["server"][:]:
+                self.tool_settings["server"] = item
+                if util.get_systype() in item.get("system", []):
+                    break
+
+        # user overwrites debug server
+        if self.env_options.get("debug_server"):
+            result = {
+                "cwd": None,
+                "executable": None,
+                "arguments": self.env_options.get("debug_server"),
+            }
+            result["executable"] = result["arguments"][0]
+            result["arguments"] = result["arguments"][1:]
+        elif "server" in self.tool_settings:
+            result = self.tool_settings["server"]
+            server_package = result.get("package")
+            server_package_dir = (
+                self.platform.get_package_dir(server_package)
+                if server_package
+                else None
+            )
+            if server_package and not server_package_dir:
+                self.platform.install_packages(
+                    with_packages=[server_package],
+                    skip_default_package=True,
+                    silent=True,
+                )
+                server_package_dir = self.platform.get_package_dir(server_package)
+            result.update(
+                dict(
+                    cwd=server_package_dir if server_package else None,
+                    executable=result.get("executable"),
+                    arguments=[
+                        a.replace("$PACKAGE_DIR", server_package_dir)
+                        if server_package_dir
+                        else a
+                        for a in result.get("arguments", [])
+                    ],
+                )
+            )
+        return self.reveal_patterns(result) if result else None
+
+    def get_init_script(self, debugger):
+        try:
+            return getattr(self, "%s_INIT_SCRIPT" % debugger.upper())
+        except AttributeError:
+            raise NotImplementedError
+
+    def reveal_patterns(self, source, recursive=True):
+        program_path = self.program_path or ""
+        patterns = {
+            "PLATFORMIO_CORE_DIR": get_project_core_dir(),
+            "PYTHONEXE": proc.get_pythonexe_path(),
+            "PROJECT_DIR": self.project_config.path,
+            "PROG_PATH": program_path,
+            "PROG_DIR": os.path.dirname(program_path),
+            "PROG_NAME": os.path.basename(os.path.splitext(program_path)[0]),
+            "DEBUG_PORT": self.port,
+            "UPLOAD_PROTOCOL": self.upload_protocol,
+            "INIT_BREAK": self.init_break or "",
+            "LOAD_CMDS": "\n".join(self.load_cmds or []),
+        }
+        for key, value in patterns.items():
+            if key.endswith(("_DIR", "_PATH")):
+                patterns[key] = fs.to_unix_path(value)
+
+        def _replace(text):
+            for key, value in patterns.items():
+                pattern = "$%s" % key
+                text = text.replace(pattern, value or "")
+            return text
+
+        if isinstance(source, string_types):
+            source = _replace(source)
+        elif isinstance(source, (list, dict)):
+            items = enumerate(source) if isinstance(source, list) else source.items()
+            for key, value in items:
+                if isinstance(value, string_types):
+                    source[key] = _replace(value)
+                elif isinstance(value, (list, dict)) and recursive:
+                    source[key] = self.reveal_patterns(value, patterns)
+
+        data = json.dumps(source)
+        if any(("$" + key) in data for key in patterns):
+            source = self.reveal_patterns(source, patterns)
+
+        return source

platformio/debug/config/blackmagic.py

@@ -0,0 +1,49 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+from platformio.debug.config.base import DebugConfigBase
+
+
+class BlackmagicDebugConfig(DebugConfigBase):
+
+    GDB_INIT_SCRIPT = """
+define pio_reset_halt_target
+    set language c
+    set *0xE000ED0C = 0x05FA0004
+    set $busy = (*0xE000ED0C & 0x4)
+    while ($busy)
+        set $busy = (*0xE000ED0C & 0x4)
+    end
+    set language auto
+end
+
+define pio_reset_run_target
+    pio_reset_halt_target
+end
+
+target extended-remote $DEBUG_PORT
+monitor swdp_scan
+attach 1
+set mem inaccessible-by-default off
+$LOAD_CMDS
+$INIT_BREAK
+
+set language c
+set *0xE000ED0C = 0x05FA0004
+set $busy = (*0xE000ED0C & 0x4)
+while ($busy)
+    set $busy = (*0xE000ED0C & 0x4)
+end
+set language auto
+"""

platformio/debug/config/factory.py

@@ -0,0 +1,48 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+import importlib
+import re
+
+from platformio.debug.config.generic import GenericDebugConfig
+from platformio.debug.config.native import NativeDebugConfig
+
+
+class DebugConfigFactory(object):
+    @staticmethod
+    def get_clsname(name):
+        name = re.sub(r"[^\da-z\_\-]+", "", name, flags=re.I)
+        return "%s%sDebugConfig" % (name.upper()[0], name.lower()[1:])
+
+    @classmethod
+    def new(cls, platform, project_config, env_name):
+        board_config = platform.board_config(
+            project_config.get("env:" + env_name, "board")
+        )
+        tool_name = (
+            board_config.get_debug_tool_name(
+                project_config.get("env:" + env_name, "debug_tool")
+            )
+            if board_config
+            else None
+        )
+        config_cls = None
+        try:
+            mod = importlib.import_module("platformio.debug.config.%s" % tool_name)
+            config_cls = getattr(mod, cls.get_clsname(tool_name))
+        except ModuleNotFoundError:
+            config_cls = (
+                GenericDebugConfig if platform.is_embedded() else NativeDebugConfig
+            )
+        return config_cls(platform, project_config, env_name)

platformio/debug/config/generic.py

@@ -0,0 +1,38 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+from platformio.debug.config.base import DebugConfigBase
+
+
+class GenericDebugConfig(DebugConfigBase):
+
+    GDB_INIT_SCRIPT = """
+define pio_reset_halt_target
+    monitor reset halt
+end
+
+define pio_reset_run_target
+    monitor reset
+end
+
+target extended-remote $DEBUG_PORT
+monitor init
+$LOAD_CMDS
+pio_reset_halt_target
+$INIT_BREAK
+"""
+
+    def __init__(self, *args, **kwargs):
+        super(GenericDebugConfig, self).__init__(*args, **kwargs)
+        self.port = ":3333"

platformio/debug/config/jlink.py

@@ -0,0 +1,48 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+from platformio.debug.config.base import DebugConfigBase
+
+
+class JlinkDebugConfig(DebugConfigBase):
+
+    GDB_INIT_SCRIPT = """
+define pio_reset_halt_target
+    monitor reset
+    monitor halt
+end
+
+define pio_reset_run_target
+    monitor clrbp
+    monitor reset
+    monitor go
+end
+
+target extended-remote $DEBUG_PORT
+monitor clrbp
+monitor speed auto
+pio_reset_halt_target
+$LOAD_CMDS
+$INIT_BREAK
+"""
+
+    def __init__(self, *args, **kwargs):
+        super(JlinkDebugConfig, self).__init__(*args, **kwargs)
+        self.port = ":2331"
+
+    @property
+    def server_ready_pattern(self):
+        return super(JlinkDebugConfig, self).server_ready_pattern or (
+            "Waiting for GDB connection"
+        )

platformio/debug/config/mspdebug.py

@@ -0,0 +1,36 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+from platformio.debug.config.base import DebugConfigBase
+
+
+class MspdebugDebugConfig(DebugConfigBase):
+
+    GDB_INIT_SCRIPT = """
+define pio_reset_halt_target
+end
+
+define pio_reset_run_target
+end
+
+target remote $DEBUG_PORT
+monitor erase
+$LOAD_CMDS
+pio_reset_halt_target
+$INIT_BREAK
+"""
+
+    def __init__(self, *args, **kwargs):
+        super(MspdebugDebugConfig, self).__init__(*args, **kwargs)
+        self.port = ":2000"

platformio/debug/config/native.py

@@ -12,19 +12,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from platformio.exception import PlatformioException
+from platformio.compat import IS_WINDOWS
+from platformio.debug.config.base import DebugConfigBase
 
 
-class AccountError(PlatformioException):
+class NativeDebugConfig(DebugConfigBase):
 
-    MESSAGE = "{0}"
+    GDB_INIT_SCRIPT = """
+define pio_reset_halt_target
+end
 
+define pio_reset_run_target
+end
 
-class AccountNotAuthenticated(AccountError):
+define pio_restart_target
+end
 
-    MESSAGE = "You are not authenticated! Please login to PIO Account."
-
-
-class AccountAlreadyAuthenticated(AccountError):
-
-    MESSAGE = "You are already authenticated with {0} account."
+$INIT_BREAK
+""" + (
+        "set startup-with-shell off" if not IS_WINDOWS else ""
+    )