# 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.encode("utf-8") + b"\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): fpath = f.inputs()[0] pdbname = os.path.splitext(fpath)[0] + ".pdb" if os.path.exists(pdbname): copier.add( mozpath.join(mozpath.dirname(p), mozpath.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()