Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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()