summaryrefslogtreecommitdiffstats
path: root/toolkit/mozapps/installer/packager.py
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /toolkit/mozapps/installer/packager.py
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'toolkit/mozapps/installer/packager.py')
-rw-r--r--toolkit/mozapps/installer/packager.py295
1 files changed, 295 insertions, 0 deletions
diff --git a/toolkit/mozapps/installer/packager.py b/toolkit/mozapps/installer/packager.py
new file mode 100644
index 0000000000..29364045dd
--- /dev/null
+++ b/toolkit/mozapps/installer/packager.py
@@ -0,0 +1,295 @@
+# 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/.
+
+from mozpack.packager.formats import (
+ FlatFormatter,
+ JarFormatter,
+ OmniJarFormatter,
+)
+from mozpack.packager import (
+ preprocess_manifest,
+ preprocess,
+ Component,
+ SimpleManifestSink,
+)
+from mozpack.files import (
+ GeneratedFile,
+ FileFinder,
+ File,
+)
+from mozpack.copier import (
+ FileCopier,
+ Jarrer,
+)
+from mozpack.errors import errors
+from mozpack.files import ExecutableFile
+import mozpack.path as mozpath
+import buildconfig
+from argparse import ArgumentParser
+from collections import OrderedDict
+from createprecomplete import generate_precomplete
+import os
+import plistlib
+from io import StringIO
+import subprocess
+
+
+class PackagerFileFinder(FileFinder):
+ def get(self, path):
+ f = super(PackagerFileFinder, self).get(path)
+ # Normalize Info.plist files, and remove the MozillaDeveloper*Path
+ # entries which are only needed on unpackaged builds.
+ if mozpath.basename(path) == "Info.plist":
+ info = plistlib.load(f.open(), dict_type=OrderedDict)
+ info.pop("MozillaDeveloperObjPath", None)
+ info.pop("MozillaDeveloperRepoPath", None)
+ return GeneratedFile(plistlib.dumps(info, sort_keys=False))
+ return f
+
+
+class RemovedFiles(GeneratedFile):
+ """
+ File class for removed-files. Is used as a preprocessor parser.
+ """
+
+ def __init__(self, copier):
+ self.copier = copier
+ GeneratedFile.__init__(self, "")
+
+ def handle_line(self, f):
+ f = f.strip()
+ if not f:
+ return
+ if self.copier.contains(f):
+ errors.error("Removal of packaged file(s): %s" % f)
+ self.content = f + "\n"
+
+
+def split_define(define):
+ """
+ Give a VAR[=VAL] string, returns a (VAR, VAL) tuple, where VAL defaults to
+ 1. Numeric VALs are returned as ints.
+ """
+ if "=" in define:
+ name, value = define.split("=", 1)
+ try:
+ value = int(value)
+ except ValueError:
+ pass
+ return (name, value)
+ return (define, 1)
+
+
+class NoPkgFilesRemover(object):
+ """
+ Formatter wrapper to handle NO_PKG_FILES.
+ """
+
+ def __init__(self, formatter, has_manifest):
+ assert "NO_PKG_FILES" in os.environ
+ self._formatter = formatter
+ self._files = os.environ["NO_PKG_FILES"].split()
+ if has_manifest:
+ self._error = errors.error
+ self._msg = "NO_PKG_FILES contains file listed in manifest: %s"
+ else:
+ self._error = errors.warn
+ self._msg = "Skipping %s"
+
+ def add_base(self, base, *args):
+ self._formatter.add_base(base, *args)
+
+ def add(self, path, content):
+ if not any(mozpath.match(path, spec) for spec in self._files):
+ self._formatter.add(path, content)
+ else:
+ self._error(self._msg % path)
+
+ def add_manifest(self, entry):
+ self._formatter.add_manifest(entry)
+
+ def contains(self, path):
+ return self._formatter.contains(path)
+
+
+def main():
+ parser = ArgumentParser()
+ parser.add_argument(
+ "-D",
+ dest="defines",
+ action="append",
+ metavar="VAR[=VAL]",
+ help="Define a variable",
+ )
+ parser.add_argument(
+ "--format",
+ default="omni",
+ help="Choose the chrome format for packaging "
+ + "(omni, jar or flat ; default: %(default)s)",
+ )
+ parser.add_argument("--removals", default=None, help="removed-files source file")
+ parser.add_argument(
+ "--ignore-errors",
+ action="store_true",
+ default=False,
+ help="Transform errors into warnings.",
+ )
+ parser.add_argument(
+ "--ignore-broken-symlinks",
+ action="store_true",
+ default=False,
+ help="Do not fail when processing broken symlinks.",
+ )
+ parser.add_argument(
+ "--minify",
+ action="store_true",
+ default=False,
+ help="Make some files more compact while packaging",
+ )
+ parser.add_argument(
+ "--minify-js",
+ action="store_true",
+ help="Minify JavaScript files while packaging.",
+ )
+ parser.add_argument(
+ "--js-binary",
+ help="Path to js binary. This is used to verify "
+ "minified JavaScript. If this is not defined, "
+ "minification verification will not be performed.",
+ )
+ parser.add_argument(
+ "--jarlog", default="", help="File containing jar " + "access logs"
+ )
+ parser.add_argument(
+ "--compress",
+ choices=("none", "deflate"),
+ default="deflate",
+ help="Use given jar compression (default: deflate)",
+ )
+ parser.add_argument("manifest", default=None, nargs="?", help="Manifest file name")
+ parser.add_argument("source", help="Source directory")
+ parser.add_argument("destination", help="Destination directory")
+ parser.add_argument(
+ "--non-resource",
+ nargs="+",
+ metavar="PATTERN",
+ default=[],
+ help="Extra files not to be considered as resources",
+ )
+ args = parser.parse_args()
+
+ defines = dict(buildconfig.defines["ALLDEFINES"])
+ if args.ignore_errors:
+ errors.ignore_errors()
+
+ if args.defines:
+ for name, value in [split_define(d) for d in args.defines]:
+ defines[name] = value
+
+ compress = {
+ "none": False,
+ "deflate": True,
+ }[args.compress]
+
+ copier = FileCopier()
+ if args.format == "flat":
+ formatter = FlatFormatter(copier)
+ elif args.format == "jar":
+ formatter = JarFormatter(copier, compress=compress)
+ elif args.format == "omni":
+ formatter = OmniJarFormatter(
+ copier,
+ buildconfig.substs["OMNIJAR_NAME"],
+ compress=compress,
+ non_resources=args.non_resource,
+ )
+ else:
+ errors.fatal("Unknown format: %s" % args.format)
+
+ # Adjust defines according to the requested format.
+ if isinstance(formatter, OmniJarFormatter):
+ defines["MOZ_OMNIJAR"] = 1
+ elif "MOZ_OMNIJAR" in defines:
+ del defines["MOZ_OMNIJAR"]
+
+ respath = ""
+ if "RESPATH" in defines:
+ respath = SimpleManifestSink.normalize_path(defines["RESPATH"])
+ while respath.startswith("/"):
+ respath = respath[1:]
+
+ with errors.accumulate():
+ finder_args = dict(
+ minify=args.minify,
+ minify_js=args.minify_js,
+ ignore_broken_symlinks=args.ignore_broken_symlinks,
+ )
+ if args.js_binary:
+ finder_args["minify_js_verify_command"] = [
+ args.js_binary,
+ os.path.join(
+ os.path.abspath(os.path.dirname(__file__)), "js-compare-ast.js"
+ ),
+ ]
+ finder = PackagerFileFinder(args.source, find_executables=True, **finder_args)
+ if "NO_PKG_FILES" in os.environ:
+ sinkformatter = NoPkgFilesRemover(formatter, args.manifest is not None)
+ else:
+ sinkformatter = formatter
+ sink = SimpleManifestSink(finder, sinkformatter)
+ if args.manifest:
+ preprocess_manifest(sink, args.manifest, defines)
+ else:
+ sink.add(Component(""), "bin/*")
+ sink.close(args.manifest is not None)
+
+ if args.removals:
+ removals_in = StringIO(open(args.removals).read())
+ removals_in.name = args.removals
+ removals = RemovedFiles(copier)
+ preprocess(removals_in, removals, defines)
+ copier.add(mozpath.join(respath, "removed-files"), removals)
+
+ # If a pdb file is present and we were instructed to copy it, include it.
+ # Run on all OSes to capture MinGW builds
+ if buildconfig.substs.get("MOZ_COPY_PDBS"):
+ # We want to mutate the copier while we're iterating through it, so copy
+ # the items to a list first.
+ copier_items = [(p, f) for p, f in copier]
+ for p, f in copier_items:
+ if isinstance(f, ExecutableFile):
+ pdbname = os.path.splitext(f.inputs()[0])[0] + ".pdb"
+ if os.path.exists(pdbname):
+ copier.add(os.path.basename(pdbname), File(pdbname))
+
+ # Setup preloading
+ if args.jarlog:
+ if not os.path.exists(args.jarlog):
+ raise Exception("Cannot find jar log: %s" % args.jarlog)
+ omnijars = []
+ if isinstance(formatter, OmniJarFormatter):
+ omnijars = [
+ mozpath.join(base, buildconfig.substs["OMNIJAR_NAME"])
+ for base in sink.packager.get_bases(addons=False)
+ ]
+
+ from mozpack.mozjar import JarLog
+
+ log = JarLog(args.jarlog)
+ for p, f in copier:
+ if not isinstance(f, Jarrer):
+ continue
+ if respath:
+ p = mozpath.relpath(p, respath)
+ if p in log:
+ f.preload(log[p])
+ elif p in omnijars:
+ raise Exception("No jar log data for %s" % p)
+
+ copier.copy(args.destination)
+ generate_precomplete(os.path.normpath(os.path.join(args.destination, respath)))
+
+
+if __name__ == "__main__":
+ main()