floss: Refactor build script and merge bootstrapping

Removed the separate bootstrap.py and merged its functionality into
build.py. With all the changes, this is how you do bootstrapping
+ building now:

./build.py --run-bootstrap
./build.py

This changes defaults to something reasonable in the scripts. A few of
the defaults that were changed:

* Set bootstrap dir default to ~/.floss
* Libdir changed to /usr/lib
* Clang made default and --no-clang added instead
* Vendored rust made default and --no-vendored-rust added instead

Bug: 200620285
Tag: #floss
Test: ./build.py --run-bootstrap && ./build.py
Change-Id: I305c6baa8a47e958dfa8e136eb60b08fc742effc

3 files changed, 324 insertions, 299 deletions

diff --git a/README.md b/README.md
index f4016073fd..fd1b689cde 100644
--- a/README.md
+++ b/README.md
@@ -14,8 +14,9 @@ Instructions for a Debian based distribution:
 
 You'll want to download some pre-requisite packages as well. If you're currently
 configured for AOSP development, you should have most required packages.
-Otherwise, you can use the following apt-get list or use the bootstrap script
-(see below) to get a list of packages missing on your system:
+Otherwise, you can use the following apt-get list or use the `--run-bootstrap`
+option on `build.py` (see below) to get a list of packages missing on your
+system:
 
 ```sh
 sudo apt-get install repo git-core gnupg flex bison gperf build-essential \
@@ -27,7 +28,7 @@ sudo apt-get install repo git-core gnupg flex bison gperf build-essential \
   libflatbuffers-dev libtinyxml2-dev \
   libglib2.0-dev libevent-dev libnss3-dev libdbus-1-dev \
   libprotobuf-dev ninja-build generate-ninja protobuf-compiler \
-  libre2-9
+  libre2-9 debmake
 ```
 
 You will also need a recent-ish version of Rust and Cargo. Please follow the
@@ -41,18 +42,22 @@ cd ~/fluoride
 git clone https://android.googlesource.com/platform/packages/modules/Bluetooth/system
 ```
 
-### Use bootstrap.py
+### Using --run-bootstrap on build.py
 
-`bootstrap.py` is a helper script provided to set up your build environment. It
-will set up your build staging directory and also make sure you have all
-required system packages to build (should work on Debian and Ubuntu). You will
-still need to build some unpackaged dependencies.
+`build.py` is the helper script used to build Fluoride for Linux (i.e. Floss).
+It accepts a `--run-bootstrap` option that will set up your build staging
+directory and also make sure you have all required system packages to build
+(should work on Debian and Ubuntu). You will still need to build some unpackaged
+dependencies (like libchrome, modp_b64, googletest, etc).
 
 To use it:
 ```sh
-./bootstrap.py --base-dir=path/to/staging/dir --bt-dir=path/to/bt/dir
+./build.py --run-bootstrap
 ```
 
+This will install your bootstrapped build environment to `~/.floss`. If you want
+to change this, just pass in `--bootstrap-dir` to the script.
+
 ### Build dependencies
 
 The following third-party dependencies are necessary but currently unavailable
@@ -104,7 +109,7 @@ done
 
 ### Rust dependencies
 
-**Note**: Handled by bootstrap script.
+**Note**: Handled by `--run-bootstrap` option.
 
 Run the following to install Rust dependencies:
 ```
@@ -113,7 +118,7 @@ cargo install cxxbridge-cmd
 
 ### Stage your build environment
 
-**Note**: Handled by bootstrap script.
+**Note**: Handled by `--run-bootstrap` option.
 
 For host build, we depend on a few other repositories:
 * [Platform2](https://chromium.googlesource.com/chromiumos/platform2/)
@@ -135,17 +140,18 @@ ln -s $(readlink -f ${PROTO_LOG_DIR}) ${STAGING_DIR}/external/proto_logging
 
 We provide a build script to automate building assuming you've staged your build
 environment already as above. At this point, make sure you have all the
-pre-requisites installed (i.e. bootstrap script and other dependencies above) or
+pre-requisites installed (i.e. bootstrap option and other dependencies above) or
 you will see failures. In addition, you may need to set a `--libdir=` if your
-libraries are not stored in `/usr/lib64` by default.
+libraries are not stored in `/usr/lib` by default.
 
 
 ```sh
-./build.py --output ${OUTPUT_DIR} --platform-dir ${STAGING_DIR} --clang
+./build.py
 ```
 
-This will build all targets to the output directory you've given. You can also
-build each stage separately (if you want to iterate on something specific):
+This will build all targets to the output directory at `--bootstrap-dir` (which
+defaults to `~/.floss`). You can also build each stage separately (if you want
+to iterate on something specific):
 
 * prepare - Generate the GN rules
 * tools - Generate host tools
@@ -157,7 +163,10 @@ build each stage separately (if you want to iterate on something specific):
 You can choose to run only a specific stage by passing an arg via `--target`.
 
 Currently, Rust builds are a separate stage that uses Cargo to build. See
-[gd/rust/README.md](gd/rust/README.md) for more information.
+[gd/rust/README.md](gd/rust/README.md) for more information. If you are
+iterating on Rust code and want to add new crates, you may also want to use the
+`--no-vendored-rust` option (which will let you use crates.io instead of using
+a pre-populated vendored crates repo).
 
 ### Run
 
diff --git a/bootstrap.py b/bootstrap.py
deleted file mode 100755
index c7c04bfd75..0000000000
--- a/bootstrap.py
+++ /dev/null
@@ -1,243 +0,0 @@
-#!/usr/bin/env python3
-
-#  Copyright 2021 Google, 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:
-#
-#  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.
-""" Bootstrap script to help set up Linux build. """
-
-import argparse
-import os
-import subprocess
-
-PLATFORM2_GIT = 'https://chromium.googlesource.com/chromiumos/platform2'
-RUST_CRATES_GIT = 'https://chromium.googlesource.com/chromiumos/third_party/rust_crates'
-PROTO_LOGGING_GIT = 'https://android.googlesource.com/platform/frameworks/proto_logging'
-
-# List of packages required for linux build
-REQUIRED_APT_PACKAGES = [
-    'bison',
-    'build-essential',
-    'curl',
-    'flatbuffers-compiler',
-    'flex',
-    'g++-multilib',
-    'gcc-multilib',
-    'generate-ninja',
-    'gnupg',
-    'gperf',
-    'libc++-dev',
-    'libdbus-1-dev',
-    'libevent-dev',
-    'libevent-dev',
-    'libflatbuffers-dev',
-    'libflatbuffers1',
-    'libgl1-mesa-dev',
-    'libglib2.0-dev',
-    'liblz4-tool',
-    'libncurses5',
-    'libnss3-dev',
-    'libprotobuf-dev',
-    'libre2-9',
-    'libssl-dev',
-    'libtinyxml2-dev',
-    'libx11-dev',
-    'libxml2-utils',
-    'ninja-build',
-    'openssl',
-    'protobuf-compiler',
-    'unzip',
-    'x11proto-core-dev',
-    'xsltproc',
-    'zip',
-    'zlib1g-dev',
-]
-
-# List of cargo packages required for linux build
-REQUIRED_CARGO_PACKAGES = ['cxxbridge-cmd']
-
-APT_PKG_LIST = ['apt', '-qq', 'list']
-CARGO_PKG_LIST = ['cargo', 'install', '--list']
-
-
-class Bootstrap():
-
-    def __init__(self, base_dir, bt_dir):
-        """ Construct bootstrapper.
-
-        Args:
-            base_dir: Where to stage everything.
-            bt_dir: Where bluetooth source is kept (will be symlinked)
-        """
-        self.base_dir = os.path.abspath(base_dir)
-        self.bt_dir = os.path.abspath(bt_dir)
-
-        if not os.path.isdir(self.base_dir):
-            raise Exception('{} is not a valid directory'.format(self.base_dir))
-
-        if not os.path.isdir(self.bt_dir):
-            raise Exception('{} is not a valid directory'.format(self.bt_dir))
-
-        self.git_dir = os.path.join(self.base_dir, 'repos')
-        self.staging_dir = os.path.join(self.base_dir, 'staging')
-        self.output_dir = os.path.join(self.base_dir, 'output')
-        self.external_dir = os.path.join(self.base_dir, 'staging', 'external')
-
-        self.dir_setup_complete = os.path.join(self.base_dir, '.setup-complete')
-
-    def _setup_platform2(self):
-        """ Set up platform2.
-
-        This will check out all the git repos and symlink everything correctly.
-        """
-
-        # If already set up, exit early
-        if os.path.isfile(self.dir_setup_complete):
-            print('{} is already set-up'.format(self.base_dir))
-            return
-
-        # Create all directories we will need to use
-        for dirpath in [self.git_dir, self.staging_dir, self.output_dir, self.external_dir]:
-            os.makedirs(dirpath)
-
-        # Check out all repos in git directory
-        for repo in [PLATFORM2_GIT, RUST_CRATES_GIT, PROTO_LOGGING_GIT]:
-            subprocess.check_call(['git', 'clone', repo], cwd=self.git_dir)
-
-        # Symlink things
-        symlinks = [
-            (os.path.join(self.git_dir, 'platform2', 'common-mk'), os.path.join(self.staging_dir, 'common-mk')),
-            (os.path.join(self.git_dir, 'platform2', '.gn'), os.path.join(self.staging_dir, '.gn')),
-            (os.path.join(self.bt_dir), os.path.join(self.staging_dir, 'bt')),
-            (os.path.join(self.git_dir, 'rust_crates'), os.path.join(self.external_dir, 'rust')),
-            (os.path.join(self.git_dir, 'proto_logging'), os.path.join(self.external_dir, 'proto_logging')),
-        ]
-
-        # Create symlinks
-        for pairs in symlinks:
-            (src, dst) = pairs
-            os.symlink(src, dst)
-
-        # Write to setup complete file so we don't repeat this step
-        with open(self.dir_setup_complete, 'w') as f:
-            f.write('Setup complete.')
-
-    def _pretty_print_install(self, install_cmd, packages, line_limit=80):
-        """ Pretty print an install command.
-
-        Args:
-            install_cmd: Prefixed install command.
-            packages: Enumerate packages and append them to install command.
-            line_limit: Number of characters per line.
-
-        Return:
-            Array of lines to join and print.
-        """
-        install = [install_cmd]
-        line = '  '
-        # Remainder needed = space + len(pkg) + space + \
-        # Assuming 80 character lines, that's 80 - 3 = 77
-        line_limit = line_limit - 3
-        for pkg in packages:
-            if len(line) + len(pkg) < line_limit:
-                line = '{}{} '.format(line, pkg)
-            else:
-                install.append(line)
-                line = '  {} '.format(pkg)
-
-        if len(line) > 0:
-            install.append(line)
-
-        return install
-
-    def _check_package_installed(self, package, cmd, predicate):
-        """Check that the given package is installed.
-
-        Args:
-            package: Check that this package is installed.
-            cmd: Command prefix to check if installed (package appended to end)
-            predicate: Function/lambda to check if package is installed based
-                       on output. Takes string output and returns boolean.
-
-        Return:
-            True if package is installed.
-        """
-        try:
-            output = subprocess.check_output(cmd + [package], stderr=subprocess.STDOUT)
-            is_installed = predicate(output.decode('utf-8'))
-            print('  {} is {}'.format(package, 'installed' if is_installed else 'missing'))
-
-            return is_installed
-        except Exception as e:
-            print(e)
-            return False
-
-    def _print_missing_packages(self):
-        """Print any missing packages found via apt.
-
-        This will find any missing packages necessary for build using apt and
-        print it out as an apt-get install printf.
-        """
-        print('Checking for any missing packages...')
-        need_packages = []
-        for pkg in REQUIRED_APT_PACKAGES:
-            if not self._check_package_installed(pkg, APT_PKG_LIST, lambda output: 'installed' in output):
-                need_packages.append(pkg)
-
-        # No packages need to be installed
-        if len(need_packages) == 0:
-            print('All required packages are installed')
-            return
-
-        install = self._pretty_print_install('sudo apt-get install', need_packages)
-
-        # Print all lines so they can be run in cmdline
-        print('Missing system packages. Run the following command: ')
-        print(' \\\n'.join(install))
-
-    def _print_missing_rust_packages(self):
-        """Print any missing packages found via cargo.
-
-        This will find any missing packages necessary for build using cargo and
-        print it out as a cargo-install printf.
-        """
-        print('Checking for any missing cargo packages...')
-        need_packages = []
-
-        for pkg in REQUIRED_CARGO_PACKAGES:
-            if not self._check_package_installed(pkg, CARGO_PKG_LIST, lambda output: pkg in output):
-                need_packages.append(pkg)
-
-        # No packages to be installed
-        if len(need_packages) == 0:
-            print('All required cargo packages are installed')
-            return
-
-        install = self._pretty_print_install('cargo install', need_packages)
-        print('Missing cargo packages. Run the following command: ')
-        print(' \\\n'.join(install))
-
-    def bootstrap(self):
-        """ Bootstrap the Linux build."""
-        self._setup_platform2()
-        self._print_missing_packages()
-        self._print_missing_rust_packages()
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description='Bootstrap Linux build')
-    parser.add_argument('--base-dir', help='Where to create build directories.', required=True)
-    parser.add_argument('--bt-dir', help='Path to packages/modules/Bluetooth/system', required=True)
-
-    args = parser.parse_args()
-    bootstrap = Bootstrap(args.base_dir, args.bt_dir)
-    bootstrap.bootstrap()
diff --git a/build.py b/build.py
index 8613315a08..3a2f72fb80 100755
--- a/build.py
+++ b/build.py
@@ -77,6 +77,58 @@ HOST_TESTS = [
     # 'net_test_btpackets',
 ]
 
+BOOTSTRAP_GIT_REPOS = {
+    'platform2': 'https://chromium.googlesource.com/chromiumos/platform2',
+    'rust_crates': 'https://chromium.googlesource.com/chromiumos/third_party/rust_crates',
+    'proto_logging': 'https://android.googlesource.com/platform/frameworks/proto_logging'
+}
+
+# List of packages required for linux build
+REQUIRED_APT_PACKAGES = [
+    'bison',
+    'build-essential',
+    'curl',
+    'debmake',
+    'flatbuffers-compiler',
+    'flex',
+    'g++-multilib',
+    'gcc-multilib',
+    'generate-ninja',
+    'gnupg',
+    'gperf',
+    'libc++-dev',
+    'libdbus-1-dev',
+    'libevent-dev',
+    'libevent-dev',
+    'libflatbuffers-dev',
+    'libflatbuffers1',
+    'libgl1-mesa-dev',
+    'libglib2.0-dev',
+    'liblz4-tool',
+    'libncurses5',
+    'libnss3-dev',
+    'libprotobuf-dev',
+    'libre2-9',
+    'libssl-dev',
+    'libtinyxml2-dev',
+    'libx11-dev',
+    'libxml2-utils',
+    'ninja-build',
+    'openssl',
+    'protobuf-compiler',
+    'unzip',
+    'x11proto-core-dev',
+    'xsltproc',
+    'zip',
+    'zlib1g-dev',
+]
+
+# List of cargo packages required for linux build
+REQUIRED_CARGO_PACKAGES = ['cxxbridge-cmd']
+
+APT_PKG_LIST = ['apt', '-qq', 'list']
+CARGO_PKG_LIST = ['cargo', 'install', '--list']
+
 
 class UseFlags():
 
@@ -123,11 +175,14 @@ class HostBuild():
             self.jobs = multiprocessing.cpu_count()
             print("Number of jobs = {}".format(self.jobs))
 
-        # Normalize all directories
-        self.output_dir = os.path.abspath(self.args.output)
-        self.platform_dir = os.path.abspath(self.args.platform_dir)
+        # Normalize bootstrap dir and make sure it exists
+        self.bootstrap_dir = os.path.abspath(self.args.bootstrap_dir)
+        os.makedirs(self.bootstrap_dir, exist_ok=True)
+
+        # Output and platform directories are based on bootstrap
+        self.output_dir = os.path.join(self.bootstrap_dir, 'output')
+        self.platform_dir = os.path.join(self.bootstrap_dir, 'staging')
         self.sysroot = self.args.sysroot
-        self.use_board = os.path.abspath(self.args.use_board) if self.args.use_board else None
         self.libdir = self.args.libdir
 
         # If default target isn't set, build everything
@@ -183,16 +238,6 @@ class HostBuild():
         self.env['RUSTFLAGS'] = self._generate_rustflags()
         self.env['CXX_ROOT_PATH'] = os.path.join(self.platform_dir, 'bt')
 
-        # Configure some GN variables
-        if self.use_board:
-            self.env['PKG_CONFIG_PATH'] = os.path.join(self.use_board, self.libdir, 'pkgconfig')
-            libdir = os.path.join(self.use_board, self.libdir)
-            if self.env.get('LIBRARY_PATH'):
-                libpath = self.env['LIBRARY_PATH']
-                self.env['LIBRARY_PATH'] = '{}:{}'.format(libdir, libpath)
-            else:
-                self.env['LIBRARY_PATH'] = libdir
-
     def run_command(self, target, args, cwd=None, env=None):
         """ Run command and stream the output.
         """
@@ -243,7 +288,7 @@ class HostBuild():
 
         Mostly copied from //common-mk/platform2.py
         """
-        clang = self.args.clang
+        clang = not self.args.no_clang
 
         def to_gn_string(s):
             return '"%s"' % s.replace('"', '\\"')
@@ -288,20 +333,6 @@ class HostBuild():
             self.use.set_flag('clang', True)
             gn_args['external_cxxflags'] += ['-I/usr/include/']
 
-        # EXTREME HACK ALERT
-        #
-        # In my laziness, I am supporting building against an already built
-        # sysroot path (i.e. chromeos board) so that I don't have to build
-        # libchrome or modp_b64 locally.
-        if self.use_board:
-            includedir = os.path.join(self.use_board, 'usr/include')
-            gn_args['external_cxxflags'] += [
-                '-I{}'.format(includedir),
-                '-I{}/libchrome'.format(includedir),
-                '-I{}/gtest'.format(includedir),
-                '-I{}/gmock'.format(includedir),
-                '-I{}/modp_b64'.format(includedir),
-            ]
         gn_args_args = list(to_gn_args_args(gn_args))
         use_args = ['%s=%s' % (k, str(v).lower()) for k, v in self.use.flags.items()]
         gn_args_args += ['use={%s}' % (' '.join(use_args))]
@@ -351,7 +382,7 @@ class HostBuild():
         local-registry = "/nonexistent"
         """
 
-        if self.args.vendored_rust:
+        if not self.args.no_vendored_rust:
             contents = template.format(self.platform_dir)
             with open(os.path.join(self.env['CARGO_HOME'], 'config'), 'w') as f:
                 f.write(contents)
@@ -410,6 +441,8 @@ class HostBuild():
         """ Delete the output directory entirely.
         """
         shutil.rmtree(self.output_dir)
+        # Remove Cargo.lock that may have become generated
+        os.remove(os.path.join(self.platform_dir, 'bt', 'Cargo.lock'))
 
     def _target_all(self):
         """ Build all common targets (skipping test and clean).
@@ -440,21 +473,247 @@ class HostBuild():
             self._target_all()
 
 
+class Bootstrap():
+
+    def __init__(self, base_dir, bt_dir):
+        """ Construct bootstrapper.
+
+        Args:
+            base_dir: Where to stage everything.
+            bt_dir: Where bluetooth source is kept (will be symlinked)
+        """
+        self.base_dir = os.path.abspath(base_dir)
+        self.bt_dir = os.path.abspath(bt_dir)
+
+        # Create base directory if it doesn't already exist
+        os.makedirs(self.base_dir, exist_ok=True)
+
+        if not os.path.isdir(self.bt_dir):
+            raise Exception('{} is not a valid directory'.format(self.bt_dir))
+
+        self.git_dir = os.path.join(self.base_dir, 'repos')
+        self.staging_dir = os.path.join(self.base_dir, 'staging')
+        self.output_dir = os.path.join(self.base_dir, 'output')
+        self.external_dir = os.path.join(self.base_dir, 'staging', 'external')
+
+        self.dir_setup_complete = os.path.join(self.base_dir, '.setup-complete')
+
+    def _update_platform2(self):
+        """Updates repositories used for build."""
+        for repo in BOOTSTRAP_GIT_REPOS.keys():
+            cwd = os.path.join(self.git_dir, repo)
+            subprocess.check_call(['git', 'pull'], cwd=cwd)
+
+    def _setup_platform2(self):
+        """ Set up platform2.
+
+        This will check out all the git repos and symlink everything correctly.
+        """
+
+        # If already set up, exit early
+        if os.path.isfile(self.dir_setup_complete):
+            print('{} already set-up. Updating instead.'.format(self.base_dir))
+            self._update_platform2()
+            return
+
+        # Create all directories we will need to use
+        for dirpath in [self.git_dir, self.staging_dir, self.output_dir, self.external_dir]:
+            os.makedirs(dirpath)
+
+        # Check out all repos in git directory
+        for repo in BOOTSTRAP_GIT_REPOS.values():
+            subprocess.check_call(['git', 'clone', repo], cwd=self.git_dir)
+
+        # Symlink things
+        symlinks = [
+            (os.path.join(self.git_dir, 'platform2', 'common-mk'), os.path.join(self.staging_dir, 'common-mk')),
+            (os.path.join(self.git_dir, 'platform2', '.gn'), os.path.join(self.staging_dir, '.gn')),
+            (os.path.join(self.bt_dir), os.path.join(self.staging_dir, 'bt')),
+            (os.path.join(self.git_dir, 'rust_crates'), os.path.join(self.external_dir, 'rust')),
+            (os.path.join(self.git_dir, 'proto_logging'), os.path.join(self.external_dir, 'proto_logging')),
+        ]
+
+        # Create symlinks
+        for pairs in symlinks:
+            (src, dst) = pairs
+            os.symlink(src, dst)
+
+        # Write to setup complete file so we don't repeat this step
+        with open(self.dir_setup_complete, 'w') as f:
+            f.write('Setup complete.')
+
+    def _pretty_print_install(self, install_cmd, packages, line_limit=80):
+        """ Pretty print an install command.
+
+        Args:
+            install_cmd: Prefixed install command.
+            packages: Enumerate packages and append them to install command.
+            line_limit: Number of characters per line.
+
+        Return:
+            Array of lines to join and print.
+        """
+        install = [install_cmd]
+        line = '  '
+        # Remainder needed = space + len(pkg) + space + \
+        # Assuming 80 character lines, that's 80 - 3 = 77
+        line_limit = line_limit - 3
+        for pkg in packages:
+            if len(line) + len(pkg) < line_limit:
+                line = '{}{} '.format(line, pkg)
+            else:
+                install.append(line)
+                line = '  {} '.format(pkg)
+
+        if len(line) > 0:
+            install.append(line)
+
+        return install
+
+    def _check_package_installed(self, package, cmd, predicate):
+        """Check that the given package is installed.
+
+        Args:
+            package: Check that this package is installed.
+            cmd: Command prefix to check if installed (package appended to end)
+            predicate: Function/lambda to check if package is installed based
+                       on output. Takes string output and returns boolean.
+
+        Return:
+            True if package is installed.
+        """
+        try:
+            output = subprocess.check_output(cmd + [package], stderr=subprocess.STDOUT)
+            is_installed = predicate(output.decode('utf-8'))
+            print('  {} is {}'.format(package, 'installed' if is_installed else 'missing'))
+
+            return is_installed
+        except Exception as e:
+            print(e)
+            return False
+
+    def _get_command_output(self, cmd):
+        """Runs the command and gets the output.
+
+        Args:
+            cmd: Command to run.
+
+        Return:
+            Tuple (Success, Output). Success represents if the command ran ok.
+        """
+        try:
+            output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+            return (True, output.decode('utf-8').split('\n'))
+        except Exception as e:
+            print(e)
+            return (False, "")
+
+    def _print_missing_packages(self):
+        """Print any missing packages found via apt.
+
+        This will find any missing packages necessary for build using apt and
+        print it out as an apt-get install printf.
+        """
+        print('Checking for any missing packages...')
+
+        (success, output) = self._get_command_output(APT_PKG_LIST)
+        if not success:
+            raise Exception("Could not query apt for packages.")
+
+        packages_installed = {}
+        for line in output:
+            if 'installed' in line:
+                split = line.split('/', 2)
+                packages_installed[split[0]] = True
+
+        need_packages = []
+        for pkg in REQUIRED_APT_PACKAGES:
+            if pkg not in packages_installed:
+                need_packages.append(pkg)
+
+        # No packages need to be installed
+        if len(need_packages) == 0:
+            print('+ All required packages are installed')
+            return
+
+        install = self._pretty_print_install('sudo apt-get install', need_packages)
+
+        # Print all lines so they can be run in cmdline
+        print('Missing system packages. Run the following command: ')
+        print(' \\\n'.join(install))
+
+    def _print_missing_rust_packages(self):
+        """Print any missing packages found via cargo.
+
+        This will find any missing packages necessary for build using cargo and
+        print it out as a cargo-install printf.
+        """
+        print('Checking for any missing cargo packages...')
+
+        (success, output) = self._get_command_output(CARGO_PKG_LIST)
+        if not success:
+            raise Exception("Could not query cargo for packages.")
+
+        packages_installed = {}
+        for line in output:
+            # Cargo installed packages have this format
+            # <crate name> <version>:
+            #   <binary name>
+            # We only care about the crates themselves
+            if ':' not in line:
+                continue
+
+            split = line.split(' ', 2)
+            packages_installed[split[0]] = True
+
+        need_packages = []
+        for pkg in REQUIRED_CARGO_PACKAGES:
+            if pkg not in packages_installed:
+                need_packages.append(pkg)
+
+        # No packages to be installed
+        if len(need_packages) == 0:
+            print('+ All required cargo packages are installed')
+            return
+
+        install = self._pretty_print_install('cargo install', need_packages)
+        print('Missing cargo packages. Run the following command: ')
+        print(' \\\n'.join(install))
+
+    def bootstrap(self):
+        """ Bootstrap the Linux build."""
+        self._setup_platform2()
+        self._print_missing_packages()
+        self._print_missing_rust_packages()
+
+
 if __name__ == '__main__':
     parser = argparse.ArgumentParser(description='Simple build for host.')
-    parser.add_argument('--output', help='Output directory for the build.', required=True)
-    parser.add_argument('--platform-dir', help='Directory where platform2 is staged.', required=True)
-    parser.add_argument('--clang', help='Use clang compiler.', default=False, action='store_true')
+    parser.add_argument(
+        '--bootstrap-dir', help='Directory to run bootstrap on (or was previously run on).', default="~/.floss")
+    parser.add_argument(
+        '--run-bootstrap',
+        help='Run bootstrap code to verify build env is ok to build.',
+        default=False,
+        action='store_true')
+    parser.add_argument('--no-clang', help='Use clang compiler.', default=False, action='store_true')
     parser.add_argument('--use', help='Set a specific use flag.')
     parser.add_argument('--notest', help="Don't compile test code.", default=False, action='store_true')
     parser.add_argument('--target', help='Run specific build target')
     parser.add_argument('--sysroot', help='Set a specific sysroot path', default='/')
-    parser.add_argument('--libdir', help='Libdir - default = usr/lib64', default='usr/lib64')
-    parser.add_argument('--use-board', help='Use a built x86 board for dependencies. Provide path.')
+    parser.add_argument('--libdir', help='Libdir - default = usr/lib', default='usr/lib')
     parser.add_argument('--jobs', help='Number of jobs to run', default=0, type=int)
-    parser.add_argument('--vendored-rust', help='Use vendored rust crates', default=False, action='store_true')
+    parser.add_argument(
+        '--no-vendored-rust', help='Do not use vendored rust crates', default=False, action='store_true')
     parser.add_argument('--verbose', help='Verbose logs for build.')
-
     args = parser.parse_args()
-    build = HostBuild(args)
-    build.build()
+
+    # Make sure we get absolute path + expanded path for bootstrap directory
+    args.bootstrap_dir = os.path.abspath(os.path.expanduser(args.bootstrap_dir))
+
+    if args.run_bootstrap:
+        bootstrap = Bootstrap(args.bootstrap_dir, os.path.dirname(__file__))
+        bootstrap.bootstrap()
+    else:
+        build = HostBuild(args)
+        build.build()