In this section, we will discuss backing areas from a functionality standpoint. This section presents a somewhat simplified view of how backing areas actually work, but it is good enough to cover the normal cases. To understand the exact mechanism that abuild uses to handle backing areas with enough detail to fully understand the subtleties of how they work, please see Section 33.3, “Traversal Details”.
The purpose of a backing area is to enable a developer to create a partially populated build tree and to fall back to a more complete area for build items that are omitted in the local build tree. A build forest may have any number of backing areas, and backing areas may in turn have additional backing areas. There are a few restrictions, however. As with item and tree dependencies, there may be no cycles among backing area relationships. Additionally, if two unrelated backing areas supply items or trees with the same name, this creates an ambiguity, which abuild will consider an error. [25]
When you have one or more backing areas, any reference to a build item or build tree that is not found locally can be resolved in the backing area. What abuild essentially does is to maintain a list of available item and tree names, which it internally maps to locations in the file system. When you using a backing area, abuild uses the backing areas' lookup tables in addition to that from your own forest to resolve items and trees. [26] When a build item or tree is defined in a backing area and is also defined in your local forest, your local forest is said to shadow the item or tree. This is not an error. It is a normal case that happens when you are using backing areas. In most cases, your build forest will contain items that either exist now in the backing area or will exist there at some future point. This is because the backing area generally represents a more stable version of whatever project you are working on.
Note that since abuild refers to build items and trees by name
and not by path, there are no restrictions about the location of
build items in the local forest relative to where they appear in
the backing area. This makes it possible for you to reorganize
the build items or even the build trees in your local area
without having to simultaneously change the backing area. There
is only way in which use of backing areas affects how abuild
resolves paths: if a directory named in a
child-dirs key in some
Abuild.conf
does not exist and the forest
has a backing area, abuild will ignore the non-existence of the
child directory. (If you run with --verbose
, it
will mention that it is ignoring the directory, but otherwise,
you won't be bothered with this detail.) This enables you to
create sparsely populated build items without having to edit
Abuild.conf
files of the parents of the
directories you have chosen to omit.
If this seems confusing, the best way to think about it is in terms of how this all interacts with a version control system. Typically, there is some master copy of the source code of a project in a version control system. There may be some stable trunk or branch in the version control system that is expected to be self-contained and operational. This is what would typically be checked out into a forest that would be fully built and used by others as a backing area. Then, individual developers would just check out the pieces of the system that they are working on, and set their backing area to point to the stable area. Since their checkouts would be sparse, there may be child directories that don't exist, but it wouldn't matter; once they check in their changes and the stable area from which the backing area is created gets updated, everything should be normal.
One side effect of this is that if you remove the directory
containing a build item or tree from your local forest while
using a backing area that still contains that item or tree, the
thing you removed doesn't really go away from abuild's
perspective. Instead, it just “moves” from the local
build tree to the backing area. If it is actually your intention
to remove the build item so that its name is
not known to other build items in your build tree, you can do
this by adding the name of the build item to the
deleted-items key or the build tree to the
deleted-trees key of your
Abuild.backing
file. This effectively
blocks abuild from resolving items or trees with those names
from the backing area. Most users will probably never use this
feature and don't even need to know it exists, but it can be very
useful under certain circumstances. When you tell abuild to
ignore a tree in this way, it actually blocks abuild from
seeing any items defined in the deleted tree. If you wanted to,
you could create a new tree locally with the same name as the
deleted tree, and the new tree and the old tree would be
completely separate from each other. We present an example that
illustrates the use of the deleted-item key
in Section 11.5, “Deleted Build Item”.
[25]
What do we mean by “unrelated” backing areas? If
your build forest declares A
and
B
to be backing areas and
A
backs to B
,
abuild will notice this relationship and will ignore your
mention of B
as a backing area. You will
still inherit items from B
, but you will
do so through A
instead of getting them
directly. Abuild doesn't consider this to be an error or
even a warning since, for all you know, A
and B
may be independent, and
A
may be using B
on a
temporary or experimental basis. However, if you really want
to know, abuild will tell you that it is ignoring
B
when you run it with the
--verbose
flag.
[26] The actual implementation differs from this description, but the effect is the same. For the real story, see Section 33.3, “Traversal Details”.