| __init__.py |
|
0 |
| action |
|
|
| analyze |
|
|
| android_version_code.py |
Generate a v1 android:versionCode.
The important consideration is that version codes be monotonically
increasing (per Android package name) for all published builds. The input
build IDs are based on timestamps and hence are always monotonically
increasing.
The generated v1 version codes look like (in binary):
0111 1000 0010 tttt tttt tttt tttt txpg
The 17 bits labelled 't' represent the number of hours since midnight on
September 1, 2015. (2015090100 in YYYYMMMDDHH format.) This yields a
little under 15 years worth of hourly build identifiers, since 2**17 / (366
* 24) =~ 14.92.
The bits labelled 'x', 'p', and 'g' are feature flags.
The bit labelled 'x' is 1 if the build is for an x86 or x86-64 architecture,
and 0 otherwise, which means the build is for an ARM or ARM64 architecture.
(Fennec no longer supports ARMv6, so ARM is equivalent to ARMv7.
ARM64 is also known as AArch64; it is logically ARMv8.)
For the same release, x86 and x86_64 builds have higher version codes and
take precedence over ARM builds, so that they are preferred over ARM on
devices that have ARM emulation.
The bit labelled 'p' is 1 if the build is for a 64-bit architecture (x86-64
or ARM64), and 0 otherwise, which means the build is for a 32-bit
architecture (x86 or ARM). 64-bit builds have higher version codes so
they take precedence over 32-bit builds on devices that support 64-bit.
The bit labelled 'g' is 1 if the build targets a recent API level, which
is currently always the case, because Firefox no longer ships releases that
are split by API levels. However, we may reintroduce a split in the future,
in which case the release that targets an older API level will
We throw an explanatory exception when we are within one calendar year of
running out of build events. This gives lots of time to update the version
scheme. The responsible individual should then bump the range (to allow
builds to continue) and use the time remaining to update the version scheme
via the reserved high order bits.
N.B.: the reserved 0 bit to the left of the highest order 't' bit can,
sometimes, be used to bump the version scheme. In addition, by reducing the
granularity of the build identifiers (for example, moving to identifying
builds every 2 or 4 hours), the version scheme may be adjusted further still
without losing a (valuable) high order bit.
|
7570 |
| artifact_builds.py |
|
792 |
| artifact_cache.py |
Fetch and cache artifacts from URLs.
This module manages fetching artifacts from URLS and purging old
artifacts using a simple Least Recently Used cache.
This module requires certain modules be importable from the ambient Python
environment. Consumers will need to arrange this themselves.
The bulk of the complexity is in managing and persisting several caches. If
we found a Python LRU cache that pickled cleanly, we could remove a lot of
this code! Sadly, I found no such candidate implementations, so we pickle
pylru caches manually.
None of the instances (or the underlying caches) are safe for concurrent use.
A future need, perhaps.
|
9341 |
| artifact_commands.py |
Download, cache, and install pre-built binary artifacts to build Firefox.
Use ``mach build`` as normal to freshen your installed binary libraries:
artifact builds automatically download, cache, and install binary
artifacts from Mozilla automation, replacing whatever may be in your
object directory. Use ``mach artifact last`` to see what binary artifacts
were last used.
Never build libxul again!
|
21134 |
| artifacts.py |
Fetch build artifacts from a Firefox tree.
This provides an (at-the-moment special purpose) interface to download Android
artifacts from Mozilla's Task Cluster.
This module performs the following steps:
* find a candidate hg parent revision. At one time we used the local pushlog,
which required the mozext hg extension. This isn't feasible with git, and it
is only mildly less efficient to not use the pushlog, so we don't use it even
when querying hg.
* map the candidate parent to candidate Task Cluster tasks and artifact
locations. Pushlog entries might not correspond to tasks (yet), and those
tasks might not produce the desired class of artifacts.
* fetch fresh Task Cluster artifacts and purge old artifacts, using a simple
Least Recently Used cache.
* post-process fresh artifacts, to speed future installation. In particular,
extract relevant files from Mac OS X DMG files into a friendly archive format
so we don't have to mount DMG files frequently.
This module requires certain modules be importable from the ambient Python
environment. ``mach artifact`` ensures these modules are available, but other
consumers will need to arrange this themselves.
|
64142 |
| backend |
|
|
| base.py |
Base class for errors raised when the build environment is not sane. |
39093 |
| bootstrap.py |
|
1988 |
| build_commands.py |
What to build. Can be a top-level make target or a relative directory. If
multiple options are provided, they will be built serially. BUILDING ONLY PARTS
OF THE TREE CAN RESULT IN BAD TREE STATE. USE AT YOUR OWN RISK.
|
11353 |
| chunkify.py |
Split an integer into evenly distributed list
>>> split_evenly(7, 3)
[3, 2, 2]
>>> split_evenly(12, 3)
[4, 4, 4]
>>> split_evenly(35, 10)
[4, 4, 4, 4, 4, 3, 3, 3, 3, 3]
>>> split_evenly(1, 2)
Traceback (most recent call last):
...
ChunkingError: Number of chunks is greater than number
|
1622 |
| code_analysis |
|
|
| codecoverage |
|
|
| compilation |
|
|
| config_status.py |
=============
ADVERTISEMENT
You are building GeckoView. After your build completes, you can open
the top source directory in Android Studio directly and build using Gradle.
See the documentation at
https://firefox-source-docs.mozilla.org/mobile/android/geckoview/contributor/geckoview-quick-start.html#build-using-android-studio
=============
|
6088 |
| configure |
|
|
| controller |
|
|
| doctor.py |
Disable the last access time feature?
This improves the speed of file and
directory access by deferring Last Access Time modification on disk by up to an
hour. Backup programs that rely on this feature may be affected.
https://technet.microsoft.com/en-us/library/cc785435.aspx
|
19560 |
| dotproperties.py |
A thin representation of a key=value .properties file. |
2603 |
| faster_daemon.py |
Use pywatchman to watch source directories and perform partial
``mach build faster`` builds.
|
11423 |
| frontend |
|
|
| gen_test_backend.py |
|
1912 |
| generated_sources.py |
Generate the SHA-512 digest of `data` and return it as a hex string.
|
3198 |
| gn_processor.py |
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
29232 |
| html_build_viewer.py |
Register a resource JSON file with the server.
The file will be made available under the name/key specified. |
3799 |
| jar.py |
jarmaker.py provides a python class to package up chrome content by
processing jar.mn files.
See the documentation for jar.mn on MDC for further details on the format.
|
22780 |
| mach_commands.py |
===================
PERFORMANCE WARNING
Your machine experienced a lot of swap activity during the build. This is
possibly a sign that your machine doesn't have enough physical memory or
not enough available memory to perform the build. It's also possible some
other system activity during the build is to blame.
If you feel this message is not appropriate for your machine configuration,
please file a Firefox Build System :: General bug at
https://bugzilla.mozilla.org/enter_bug.cgi?product=Firefox%20Build%20System&component=General
and tell us about your machine and build configuration so we can adjust the
warning heuristic.
===================
|
93124 |
| makeutil.py |
Provides an interface for writing simple makefiles
Instances of this class are created, populated with rules, then
written.
|
6356 |
| mozconfig.py |
Evaluation of your mozconfig exited with an error. This could be triggered
by a command inside your mozconfig failing. Please change your mozconfig
to not error and/or to catch errors in executed commands.
|
13896 |
| mozconfig_loader |
|
1053 |
| mozinfo.py |
Build a dict containing data about the build configuration from
the environment.
|
5699 |
| nodeutil.py |
Determines the possible paths for node executables.
Returns a list of paths, which includes the build state directory.
|
4116 |
| preprocessor.py |
This is a very primitive line based preprocessor, for times when using
a C preprocessor isn't an option.
It currently supports the following grammar for expressions, whitespace is
ignored:
expression :
and_cond ( '||' expression ) ? ;
and_cond:
test ( '&&' and_cond ) ? ;
test:
unary ( ( '==' | '!=' ) unary ) ? ;
unary :
'!'? value ;
value :
[0-9]+ # integer
| 'defined(' \w+ ')'
| \w+ # string identifier or value;
|
30408 |
| pythonutil.py |
|
734 |
| repackaging |
|
|
| resources |
|
|
| schedules.py |
Constants for SCHEDULES configuration in moz.build files and for
skip-unless-schedules optimizations in task-graph generation.
|
2458 |
| shellutil.py |
Parses a given command line string and creates a list of command
and arguments, with wildcard expansion.
|
7207 |
| sphinx.py |
Find and return mots config path if it exists. |
7140 |
| telemetry.py |
This file contains functions used for telemetry.
|
5443 |
| test |
|
|
| testing.py |
Processes a "support-files" entry from a test object, either from
a parsed object from a test manifests or its representation in
moz.build and returns the installs to perform for this test object.
Processing the same support files multiple times will not have any further
effect, and the structure of the parsed objects from manifests will have a
lot of repeated entries, so this class takes care of memoizing.
|
11058 |
| toolchains.py |
|
1151 |
| util.py |
Hashes a file specified by the path given and returns the hex digest. |
45625 |
| vendor |
|
|