The constructors of individual Blaze modules should be empty. All work should be done in the * methods (e.g. {@link #blazeStartup}). */ public abstract class BlazeModule { /** * Returns the extra startup options this module contributes. * *
This method will be called at the beginning of Blaze startup (before #blazeStartup).
*/
public Iterable This method will be called at the beginning of Blaze startup.
*/
@SuppressWarnings("unused")
public void globalInit(OptionsProvider startupOptions) throws AbruptExitException {
}
/**
* Returns the file system implementation used by Blaze. It is an error if more than one module
* returns a file system. If all return null, the default unix file system is used.
*
* This method will be called at the beginning of Blaze startup (in-between #globalInit and
* #blazeStartup).
*/
@SuppressWarnings("unused")
public FileSystem getFileSystem(OptionsProvider startupOptions, PathFragment outputPath) {
return null;
}
/**
* Called when Blaze starts up.
*/
@SuppressWarnings("unused")
public void blazeStartup(OptionsProvider startupOptions,
BlazeVersionInfo versionInfo, UUID instanceId, BlazeDirectories directories,
Clock clock) throws AbruptExitException {
}
/**
* May yield a supplier that provides factories for the Preprocessor to apply. Only one of the
* configured modules may return non-null.
*
* The factory yielded by the supplier will be checked with
* {@link Preprocessor.Factory#isStillValid} at the beginning of each incremental build. This
* allows modules to have preprocessors customizable by flags.
*
* This method will be called during Blaze startup (after #blazeStartup).
*/
public Preprocessor.Factory.Supplier getPreprocessorFactorySupplier() {
return null;
}
/**
* Adds the rule classes supported by this module.
*
* This method will be called during Blaze startup (after #blazeStartup).
*/
@SuppressWarnings("unused")
public void initializeRuleClasses(ConfiguredRuleClassProvider.Builder builder) {
}
/**
* Returns the list of commands this module contributes to Blaze.
*
* This method will be called during Blaze startup (after #blazeStartup).
*/
public Iterable getCommands() {
return ImmutableList.of();
}
/**
* Returns the list of query output formatters this module provides.
*
* This method will be called during Blaze startup (after #blazeStartup).
*/
public Iterable This method will be called during Blaze startup (after #blazeStartup).
*/
@SuppressWarnings("unused")
public Iterable getDiffAwarenessFactories(boolean watchFS) {
return ImmutableList.of();
}
/**
* Returns the workspace status action factory contributed by this module.
*
* There should always be exactly one of these in a Blaze instance.
*/
public WorkspaceStatusAction.Factory getWorkspaceStatusActionFactory() {
return null;
}
/**
* PlatformSet is a group of platforms characterized by a regular expression. For example, the
* entry "oldlinux": "i[34]86-libc[345]-linux" might define a set of platforms representing
* certain older linux releases.
*
* Platform-set names are used in BUILD files in the third argument to vardef, to
* define per-platform tweaks to variables such as CFLAGS.
*
* vardef is a legacy mechanism: it needs explicit support in the rule implementations,
* and cannot express conditional dependencies, only conditional attribute values. This
* mechanism will be supplanted by configuration dependent attributes, and its effect can
* usually also be achieved with select().
*
* This method will be called during Blaze startup (after #blazeStartup).
*/
public Map This method will be called at the beginning of each command (after #beforeCommand).
*/
@SuppressWarnings("unused")
public OutputService getOutputService() throws AbruptExitException {
return null;
}
/**
* Does any handling of options needed by the command.
*
* This method will be called at the beginning of each command (after #beforeCommand).
*/
@SuppressWarnings("unused")
public void handleOptions(OptionsProvider optionsProvider) {
}
/**
* Returns extra options this module contributes to a specific command. Note that option
* inheritance applies: if this method returns a non-empty list, then the returned options are
* added to every command that depends on this command.
*
* This method may be called at any time, and the returned value may be cached. Implementations
* must be thread-safe and never return different lists for the same command object. Typical
* implementations look like this:
* This method is also used to generate command-line documentation; in order to avoid
* duplicated options descriptions, this method should never return the same options class for two
* different commands if one of them inherits the other.
*
* If you want to add options to all commands, override {@link #getCommonCommandOptions}
* instead.
*
* @param command the command
*/
public Iterable This method will be called at the beginning of each "blaze info" command (after
* #beforeCommand).
*/
public Iterable This method will be called at the beginning of each "blaze query" command (after
* #beforeCommand).
*/
public Iterable This method will be called at the beginning of the execution phase, e.g. of the
* "blaze build" command.
*/
public Iterable This method will be called at the beginning of the execution phase, e.g. of the
* "blaze build" command.
*/
public Iterable This method is called once per Blaze instance at the very beginning of its life.
* If it creates the injected values by using a {@code com.google.common.base.Supplier},
* that supplier is asked for the value it contains just before the loading phase begins. This
* functionality can be used to implement precomputed values that are not constant during the
* lifetime of a Blaze instance (naturally, they must be constant over the course of a build)
*
* The following things must be done in order to define a new precomputed values:
*
* return "build".equals(command.name())
* ? ImmutableList.
* Note that this example adds options to all commands that inherit from the build command.
*
*
*
*/
public Iterable