ab223a512b
Instead of sometimes re-running minibp/the primary builder during the next phase, run bpglob earlier to check dependencies. We've run into issues where the environment is slightly different between bootstrapping phase and the main build phase. It's also a problem because our primary builder (Soong) exports information used by another tool (Kati) that runs in between the bootstrapping phases and the main phase. When Soong would run in the main phase, it could get out of sync, and would require the build to be run again. To do this, add a "subninja" include a build-globs.ninja file to each build.ninja file. The first time, this will be an empty file, but we'll always run minibp / the primary builder anyway. When the builder runs, in addition to writing a dependency file, write out the build-globs.ninja file with the rules to run bpglob. Since bpglob may need to be run very early, before it would normally be built, build it with microfactory. Change-Id: I89fcd849a8729e892f163d40060ab90b5d4dfa5d
150 lines
6.2 KiB
Go
150 lines
6.2 KiB
Go
// Copyright 2014 Google Inc. All rights reserved.
|
|
//
|
|
// 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.
|
|
|
|
// The Blueprint bootstrapping mechanism is intended to enable building a
|
|
// source tree with minimal prebuilts. The only prerequisites for performing
|
|
// such a build are:
|
|
//
|
|
// 1. A Ninja binary
|
|
// 2. A script interpreter (e.g. Bash or Python)
|
|
// 3. A Go toolchain
|
|
//
|
|
// The Primary Builder
|
|
//
|
|
// As part of the bootstrapping process, a binary called the "primary builder"
|
|
// is created. This primary builder is the binary that includes both the core
|
|
// Blueprint library and the build logic specific to the source tree. It is
|
|
// used to generate the Ninja file that describes how to build the entire source
|
|
// tree.
|
|
//
|
|
// The primary builder must be a pure Go (i.e. no cgo) module built with the
|
|
// module type 'bootstrap_go_binary'. It should have the 'primaryBuilder'
|
|
// module property set to true in its Blueprints file. If more than one module
|
|
// sets primaryBuilder to true the build will fail.
|
|
//
|
|
// The primary builder main function should look something like:
|
|
//
|
|
// package main
|
|
//
|
|
// import (
|
|
// "flag"
|
|
// "github.com/google/blueprint"
|
|
// "github.com/google/blueprint/bootstrap"
|
|
// "path/filepath"
|
|
//
|
|
// "my/custom/build/logic"
|
|
// )
|
|
//
|
|
// func main() {
|
|
// // The primary builder should use the global flag set because the
|
|
// // bootstrap package registers its own flags there.
|
|
// flag.Parse()
|
|
//
|
|
// // The top-level Blueprints file is passed as the first argument.
|
|
// srcDir := filepath.Dir(flag.Arg(0))
|
|
//
|
|
// // Create the build context.
|
|
// ctx := blueprint.NewContext()
|
|
//
|
|
// // Register custom module types
|
|
// ctx.RegisterModuleType("foo", logic.FooModule)
|
|
// ctx.RegisterModuleType("bar", logic.BarModule)
|
|
//
|
|
// // Register custom singletons
|
|
// ctx.RegisterSingleton("baz", logic.NewBazSingleton())
|
|
//
|
|
// // Create and initialize the custom Config object.
|
|
// config := logic.NewConfig(srcDir)
|
|
//
|
|
// // This call never returns
|
|
// bootstrap.Main(ctx, config)
|
|
// }
|
|
//
|
|
// Required Source Files
|
|
//
|
|
// There are three files that must be included in the source tree to facilitate
|
|
// the build bootstrapping:
|
|
//
|
|
// 1. The top-level Blueprints file
|
|
// 2. The bootstrap script
|
|
// 3. The build wrapper script
|
|
//
|
|
// The top-level Blueprints file describes how the entire source tree should be
|
|
// built. It must have a 'subdirs' assignment that includes both the core
|
|
// Blueprint library and the custom build logic for the source tree. It should
|
|
// also include (either directly or through a subdirs entry) describe all the
|
|
// modules to be built in the source tree.
|
|
//
|
|
// The bootstrap script is a small script to setup the build directory, writing
|
|
// a couple configuration files (including the path the source directory,
|
|
// information about the Go build environment, etc), then copying the build
|
|
// wrapper into the build directory.
|
|
//
|
|
// The Bootstrapping Process
|
|
//
|
|
// There are three stages to the bootstrapping process, each with a
|
|
// corresponding Ninja file. The stages are referred to as the "bootstrap",
|
|
// "primary", and "main" stages. Each stage builds the next stage's Ninja file.
|
|
//
|
|
// The bootstrapping process begins with the user running the bootstrap script
|
|
// to initialize a new build directory. The script is run from the build
|
|
// directory, and creates a ".minibootstrap/build.ninja" file that sets a few
|
|
// variables then includes blueprint's "bootstrap/build.ninja". It also writes
|
|
// out a ".blueprint.bootstrap" file that contains a few variables for later use:
|
|
//
|
|
// BLUEPRINT_BOOTSTRAP_VERSION - Used to detect when a user needs to run
|
|
// bootstrap.bash again
|
|
//
|
|
// SRCDIR - The path to the source directory
|
|
// BLUEPRINTDIR - The path to the blueprints directory (includes $SRCDIR)
|
|
// GOROOT - The path to the root directory of the Go toolchain
|
|
// NINJA_BUILDDIR - The path to store .ninja_log, .ninja_deps
|
|
//
|
|
// Once the script completes the build directory is initialized and ready to run
|
|
// a build. A wrapper script (blueprint.bash by default) has been installed in
|
|
// order to run a build. It iterates through the three stages of the build:
|
|
//
|
|
// - Runs microfactory.bash to build minibp
|
|
// - Runs the .minibootstrap/build.ninja to build .bootstrap/build.ninja
|
|
// - Runs .bootstrap/build.ninja to build and run the primary builder
|
|
// - Runs build.ninja to build your code
|
|
//
|
|
// Microfactory takes care of building an up to date version of `minibp` and
|
|
// `bpglob` under the .minibootstrap/ directory.
|
|
//
|
|
// During <builddir>/.minibootstrap/build.ninja, the following actions are
|
|
// taken, if necessary:
|
|
//
|
|
// - Run minibp to generate .bootstrap/build.ninja (Primary stage)
|
|
// - Includes .minibootstrap/build-globs.ninja, which defines rules to
|
|
// run bpglob during incremental builds. These outputs are listed in
|
|
// the dependency file output by minibp.
|
|
//
|
|
// During the <builddir>/.bootstrap/build.ninja, the following actions are
|
|
// taken, if necessary:
|
|
//
|
|
// - Build the primary builder, anything marked `default: true`, and
|
|
// any dependencies.
|
|
// - Run the primary builder to generate build.ninja
|
|
// - Run the primary builder to extract documentation
|
|
// - Includes .bootstrap/build-globs.ninja, which defines rules to run
|
|
// bpglob during incremental builds. These outputs are listed in the
|
|
// dependency file output by the primary builder.
|
|
//
|
|
// Then the main stage is at <builddir>/build.ninja, and will contain all the
|
|
// rules generated by the primary builder. In addition, the bootstrap code
|
|
// adds a phony rule "blueprint_tools" that depends on all blueprint_go_binary
|
|
// rules (bpfmt, bpmodify, etc).
|
|
//
|
|
package bootstrap
|