コード例 #1
0
 def set_software_rendering_env(self, use_release):
     # On Linux and mac, find the OSMesa software rendering library and
     # add it to the dynamic linker search path.
     if sys.platform.startswith('linux'):
         try:
             args = [self.get_binary_path(use_release, not use_release)]
             osmesa_path = path.join(
                 find_dep_path_newest('osmesa-src', args[0]), "out", "lib",
                 "gallium")
             os.environ["LD_LIBRARY_PATH"] = osmesa_path
             os.environ["GALLIUM_DRIVER"] = "softpipe"
         except BuildNotFound:
             # This can occur when cross compiling (e.g. arm64), in which case
             # we won't run the tests anyway so can safely ignore this step.
             pass
     elif sys.platform.startswith('darwin'):
         try:
             args = [self.get_binary_path(use_release, not use_release)]
             osmesa_path = path.join(
                 find_dep_path_newest('osmesa-src', args[0]), "out", "src",
                 "gallium", "targets", "osmesa", ".libs")
             glapi_path = path.join(
                 find_dep_path_newest('osmesa-src', args[0]), "out", "src",
                 "mapi", "shared-glapi", ".libs")
             os.environ[
                 "DYLD_LIBRARY_PATH"] = osmesa_path + ":" + glapi_path
             os.environ["GALLIUM_DRIVER"] = "softpipe"
         except BuildNotFound:
             # This can occur when cross compiling (e.g. arm64), in which case
             # we won't run the tests anyway so can safely ignore this step.
             pass
コード例 #2
0
ファイル: testing_commands.py プロジェクト: glennw/servo
 def set_software_rendering_env(self, use_release):
     # On Linux and mac, find the OSMesa software rendering library and
     # add it to the dynamic linker search path.
     if sys.platform.startswith('linux'):
         try:
             args = [self.get_binary_path(use_release, not use_release)]
             osmesa_path = path.join(find_dep_path_newest('osmesa-src', args[0]), "out", "lib", "gallium")
             os.environ["LD_LIBRARY_PATH"] = osmesa_path
             os.environ["GALLIUM_DRIVER"] = "softpipe"
         except BuildNotFound:
             # This can occur when cross compiling (e.g. arm64), in which case
             # we won't run the tests anyway so can safely ignore this step.
             pass
     elif sys.platform.startswith('darwin'):
         try:
             args = [self.get_binary_path(use_release, not use_release)]
             osmesa_path = path.join(find_dep_path_newest('osmesa-src', args[0]),
                                     "out", "src", "gallium", "targets", "osmesa", ".libs")
             glapi_path = path.join(find_dep_path_newest('osmesa-src', args[0]),
                                    "out", "src", "mapi", "shared-glapi", ".libs")
             os.environ["DYLD_LIBRARY_PATH"] = osmesa_path + ":" + glapi_path
             os.environ["GALLIUM_DRIVER"] = "softpipe"
         except BuildNotFound:
             # This can occur when cross compiling (e.g. arm64), in which case
             # we won't run the tests anyway so can safely ignore this step.
             pass
コード例 #3
0
    def wptrunner(self, run_file, **kwargs):
        # On Linux and mac, find the OSMesa software rendering library and
        # add it to the dynamic linker search path.
        if sys.platform.startswith('linux'):
            try:
                args = [
                    self.get_binary_path(kwargs["release"],
                                         not kwargs["release"])
                ]
                osmesa_path = path.join(
                    find_dep_path_newest('osmesa-src', args[0]), "out", "lib",
                    "gallium")
                os.environ["LD_LIBRARY_PATH"] = osmesa_path
                os.environ["GALLIUM_DRIVER"] = "softpipe"
            except BuildNotFound:
                # This can occur when cross compiling (e.g. arm64), in which case
                # we won't run the tests anyway so can safely ignore this step.
                pass
        if sys.platform.startswith('darwin'):
            try:
                args = [
                    self.get_binary_path(kwargs["release"],
                                         not kwargs["release"])
                ]
                osmesa_path = path.join(
                    find_dep_path_newest('osmesa-src', args[0]), "out", "src",
                    "gallium", "targets", "osmesa", ".libs")
                glapi_path = path.join(
                    find_dep_path_newest('osmesa-src', args[0]), "out", "src",
                    "mapi", "shared-glapi", ".libs")
                os.environ[
                    "DYLD_LIBRARY_PATH"] = osmesa_path + ":" + glapi_path
                os.environ["GALLIUM_DRIVER"] = "softpipe"
            except BuildNotFound:
                # This can occur when cross compiling (e.g. arm64), in which case
                # we won't run the tests anyway so can safely ignore this step.
                pass

        os.environ["RUST_BACKTRACE"] = "1"
        kwargs["debug"] = not kwargs["release"]
        if kwargs.pop("chaos"):
            kwargs["debugger"] = "rr"
            kwargs["debugger_args"] = "record --chaos"
            kwargs["repeat_until_unexpected"] = True
            # TODO: Delete rr traces from green test runs?
        prefs = kwargs.pop("prefs")
        if prefs:
            binary_args = []
            for pref in prefs:
                binary_args.append("--pref=" + pref)
            kwargs["binary_args"] = binary_args

        run_globals = {"__file__": run_file}
        execfile(run_file, run_globals)
        return run_globals["run_tests"](**kwargs)
コード例 #4
0
    def wptrunner(self, run_file, **kwargs):
        # On Linux and mac, find the OSMesa software rendering library and
        # add it to the dynamic linker search path.
        if sys.platform.startswith('linux'):
            try:
                args = [self.get_binary_path(kwargs["release"], not kwargs["release"])]
                osmesa_path = path.join(find_dep_path_newest('osmesa-src', args[0]), "out", "lib", "gallium")
                os.environ["LD_LIBRARY_PATH"] = osmesa_path
                os.environ["GALLIUM_DRIVER"] = "softpipe"
            except BuildNotFound:
                # This can occur when cross compiling (e.g. arm64), in which case
                # we won't run the tests anyway so can safely ignore this step.
                pass
        if sys.platform.startswith('darwin'):
            try:
                args = [self.get_binary_path(kwargs["release"], not kwargs["release"])]
                osmesa_path = path.join(find_dep_path_newest('osmesa-src', args[0]),
                                        "out", "src", "gallium", "targets", "osmesa", ".libs")
                glapi_path = path.join(find_dep_path_newest('osmesa-src', args[0]),
                                       "out", "src", "mapi", "shared-glapi", ".libs")
                os.environ["DYLD_LIBRARY_PATH"] = osmesa_path + ":" + glapi_path
                os.environ["GALLIUM_DRIVER"] = "softpipe"
            except BuildNotFound:
                # This can occur when cross compiling (e.g. arm64), in which case
                # we won't run the tests anyway so can safely ignore this step.
                pass

        os.environ["RUST_BACKTRACE"] = "1"
        kwargs["debug"] = not kwargs["release"]
        if kwargs.pop("chaos"):
            kwargs["debugger"] = "rr"
            kwargs["debugger_args"] = "record --chaos"
            kwargs["repeat_until_unexpected"] = True
            # TODO: Delete rr traces from green test runs?
        prefs = kwargs.pop("prefs")
        if prefs:
            binary_args = []
            for pref in prefs:
                binary_args.append("--pref=" + pref)
            kwargs["binary_args"] = binary_args

        run_globals = {"__file__": run_file}
        execfile(run_file, run_globals)
        return run_globals["run_tests"](**kwargs)
コード例 #5
0
ファイル: build_commands.py プロジェクト: cheinr/servo
    def build_geckolib(self,
                       with_gecko=None,
                       jobs=None,
                       verbose=False,
                       release=False):
        self.set_use_stable_rust()
        self.ensure_bootstrapped()

        env = self.build_env(is_build=True)
        geckolib_build_path = path.join(self.context.topdir, "target",
                                        "geckolib").encode("UTF-8")
        env["CARGO_TARGET_DIR"] = geckolib_build_path

        ret = None
        opts = []
        if with_gecko is not None:
            opts += ["--features", "bindgen"]
            env["MOZ_DIST"] = path.abspath(with_gecko)
        if jobs is not None:
            opts += ["-j", jobs]
        if verbose:
            opts += ["-v"]
        if release:
            opts += ["--release"]

        if with_gecko is not None:
            print("Generating atoms data...")
            run_file = path.join(self.context.topdir, "components", "style",
                                 "binding_tools", "regen_atoms.py")
            run_globals = {"__file__": run_file}
            execfile(run_file, run_globals)
            run_globals["generate_atoms"](env["MOZ_DIST"])

        build_start = time()
        with cd(path.join("ports", "geckolib")):
            ret = call(["cargo", "build"] + opts, env=env, verbose=verbose)
        elapsed = time() - build_start

        # Generate Desktop Notification if elapsed-time > some threshold value
        notify_build_done(elapsed)

        print("GeckoLib build completed in %s" % format_duration(elapsed))

        if with_gecko is not None and ret == 0:
            print("Copying binding files to style/gecko_bindings...")
            build_path = path.join(geckolib_build_path,
                                   "release" if release else "debug", "")
            target_style_path = find_dep_path_newest("style", build_path)
            out_gecko_path = path.join(target_style_path, "out", "gecko")
            bindings_path = path.join(self.context.topdir, "components",
                                      "style", "gecko_bindings")
            for f in ["bindings.rs", "structs_debug.rs", "structs_release.rs"]:
                shutil.copy(path.join(out_gecko_path, f), bindings_path)

        return ret
コード例 #6
0
ファイル: build_commands.py プロジェクト: broesamle/servo
    def build_geckolib(self, with_gecko=None, jobs=None, verbose=False, release=False):
        self.set_use_stable_rust()
        self.ensure_bootstrapped()

        env = self.build_env(is_build=True, geckolib=True)
        geckolib_build_path = path.join(self.context.topdir, "target", "geckolib").encode("UTF-8")

        ret = None
        opts = []
        features = []
        if with_gecko is not None:
            features += ["bindgen"]
            env["MOZ_DIST"] = path.abspath(path.expanduser(with_gecko))
        if jobs is not None:
            opts += ["-j", jobs]
        if verbose:
            opts += ["-v"]
        if release:
            opts += ["--release"]
        else:
            features += ["gecko_debug"]

        if features:
            opts += ["--features", ' '.join(features)]

        if with_gecko is not None:
            print("Generating atoms data...")
            run_file = path.join(self.context.topdir, "components",
                                 "style", "binding_tools", "regen_atoms.py")
            run_globals = {"__file__": run_file}
            execfile(run_file, run_globals)
            run_globals["generate_atoms"](env["MOZ_DIST"])

        build_start = time()
        with cd(path.join("ports", "geckolib")):
            ret = call(["cargo", "build"] + opts, env=env, verbose=verbose)
        elapsed = time() - build_start

        # Generate Desktop Notification if elapsed-time > some threshold value
        notify_build_done(self.config, elapsed)

        print("GeckoLib build completed in %s" % format_duration(elapsed))

        if with_gecko is not None:
            print("Copying binding files to style/gecko_bindings...")
            build_path = path.join(geckolib_build_path, "release" if release else "debug", "")
            target_style_path = find_dep_path_newest("style", build_path)
            out_gecko_path = path.join(target_style_path, "out", "gecko")
            bindings_path = path.join(self.context.topdir, "components", "style", "gecko_bindings")
            for f in ["bindings.rs", "structs_debug.rs", "structs_release.rs"]:
                shutil.copy(path.join(out_gecko_path, f), bindings_path)

        return ret
コード例 #7
0
    def run(self, params, release=False, dev=False, android=None, debug=False, debugger=None, browserhtml=False,
            headless=False):
        env = self.build_env()
        env["RUST_BACKTRACE"] = "1"

        # Make --debugger imply --debug
        if debugger:
            debug = True

        if android is None:
            android = self.config["build"]["android"]

        if android:
            if debug:
                print("Android on-device debugging is not supported by mach yet. See")
                print("https://github.com/servo/servo/wiki/Building-for-Android#debugging-on-device")
                return
            script = [
                "am force-stop com.mozilla.servo",
                "echo servo >/sdcard/servo/android_params"
            ]
            for param in params:
                script += [
                    "echo '%s' >>/sdcard/servo/android_params" % param.replace("'", "\\'")
                ]
            script += [
                "am start com.mozilla.servo/com.mozilla.servo.MainActivity",
                "exit"
            ]
            shell = subprocess.Popen(["adb", "shell"], stdin=subprocess.PIPE)
            shell.communicate("\n".join(script) + "\n")
            return shell.wait()

        args = [self.get_binary_path(release, dev)]

        if browserhtml:
            browserhtml_path = find_dep_path_newest('browserhtml', args[0])
            if browserhtml_path is None:
                print("Could not find browserhtml package; perhaps you haven't built Servo.")
                return 1

            if is_macosx():
                # Enable borderless on OSX
                args = args + ['-b']
            elif is_windows():
                # Convert to a relative path to avoid mingw -> Windows path conversions
                browserhtml_path = path.relpath(browserhtml_path, os.getcwd())

            args = args + ['--pref', 'dom.mozbrowser.enabled',
                           '--pref', 'dom.forcetouch.enabled',
                           '--pref', 'shell.builtin-key-shortcuts.enabled=false',
                           path.join(browserhtml_path, 'out', 'index.html')]

        if headless:
            set_osmesa_env(args[0], env)
            args.append('-z')

        # Borrowed and modified from:
        # http://hg.mozilla.org/mozilla-central/file/c9cfa9b91dea/python/mozbuild/mozbuild/mach_commands.py#l883
        if debug:
            import mozdebug
            if not debugger:
                # No debugger name was provided. Look for the default ones on
                # current OS.
                debugger = mozdebug.get_default_debugger_name(
                    mozdebug.DebuggerSearch.KeepLooking)

            self.debuggerInfo = mozdebug.get_debugger_info(debugger)
            if not self.debuggerInfo:
                print("Could not find a suitable debugger in your PATH.")
                return 1

            command = self.debuggerInfo.path
            if debugger == 'gdb' or debugger == 'lldb':
                rustCommand = 'rust-' + debugger
                try:
                    subprocess.check_call([rustCommand, '--version'], env=env, stdout=open(os.devnull, 'w'))
                except (OSError, subprocess.CalledProcessError):
                    pass
                else:
                    command = rustCommand

            # Prepend the debugger args.
            args = ([command] + self.debuggerInfo.args +
                    args + params)
        else:
            args = args + params

        try:
            check_call(args, env=env)
        except subprocess.CalledProcessError as e:
            print("Servo exited with return value %d" % e.returncode)
            return e.returncode
        except OSError as e:
            if e.errno == 2:
                print("Servo Binary can't be found! Run './mach build'"
                      " and try again!")
            else:
                raise e
コード例 #8
0
    def package(self,
                release=False,
                dev=False,
                android=None,
                debug=False,
                debugger=None):
        env = self.build_env()
        if android is None:
            android = self.config["build"]["android"]
        binary_path = self.get_binary_path(release, dev, android=android)
        dir_to_root = self.get_top_dir()
        target_dir = path.dirname(binary_path)
        if android:
            if dev:
                env["NDK_DEBUG"] = "1"
                env["ANT_FLAVOR"] = "debug"
                dev_flag = "-d"
            else:
                env["ANT_FLAVOR"] = "release"
                dev_flag = ""

            output_apk = "{}.apk".format(binary_path)

            dir_to_apk = path.join(target_dir, "apk")
            if path.exists(dir_to_apk):
                print("Cleaning up from previous packaging")
                delete(dir_to_apk)
            shutil.copytree(
                path.join(dir_to_root, "support", "android", "apk"),
                dir_to_apk)

            blurdroid_path = find_dep_path_newest('blurdroid', binary_path)
            if blurdroid_path is None:
                print(
                    "Could not find blurdroid package; perhaps you haven't built Servo."
                )
                return 1
            else:
                dir_to_libs = path.join(dir_to_apk, "libs")
                if not path.exists(dir_to_libs):
                    os.makedirs(dir_to_libs)
                shutil.copy2(blurdroid_path + '/out/blurdroid.jar',
                             dir_to_libs)
            try:
                with cd(path.join("support", "android", "build-apk")):
                    subprocess.check_call([
                        "cargo", "run", "--", dev_flag, "-o", output_apk, "-t",
                        target_dir, "-r", dir_to_root
                    ],
                                          env=env)
            except subprocess.CalledProcessError as e:
                print("Packaging Android exited with return value %d" %
                      e.returncode)
                return e.returncode
        elif is_macosx():
            print("Creating Servo.app")
            dir_to_dmg = path.join(target_dir, 'dmg')
            dir_to_app = path.join(dir_to_dmg, 'Servo.app')
            dir_to_resources = path.join(dir_to_app, 'Contents', 'Resources')
            if path.exists(dir_to_dmg):
                print("Cleaning up from previous packaging")
                delete(dir_to_dmg)
            browserhtml_path = get_browserhtml_path(binary_path)

            print("Copying files")
            shutil.copytree(path.join(dir_to_root, 'resources'),
                            dir_to_resources)
            shutil.copytree(browserhtml_path,
                            path.join(dir_to_resources, 'browserhtml'))
            shutil.copy2(path.join(dir_to_root, 'Info.plist'),
                         path.join(dir_to_app, 'Contents', 'Info.plist'))

            content_dir = path.join(dir_to_app, 'Contents', 'MacOS')
            os.makedirs(content_dir)
            shutil.copy2(binary_path, content_dir)

            change_prefs(dir_to_resources, "macosx")

            print("Finding dylibs and relinking")
            copy_dependencies(path.join(content_dir, 'servo'), content_dir)

            print("Adding version to Credits.rtf")
            version_command = [binary_path, '--version']
            p = subprocess.Popen(version_command,
                                 stdout=subprocess.PIPE,
                                 stderr=subprocess.PIPE,
                                 universal_newlines=True)
            version, stderr = p.communicate()
            if p.returncode != 0:
                raise Exception("Error occurred when getting Servo version: " +
                                stderr)
            version = "Nightly version: " + version

            template_path = path.join(dir_to_resources, 'Credits.rtf.mako')
            credits_path = path.join(dir_to_resources, 'Credits.rtf')
            with open(template_path) as template_file:
                template = mako.template.Template(template_file.read())
                with open(credits_path, "w") as credits_file:
                    credits_file.write(template.render(version=version))
            delete(template_path)

            print("Writing run-servo")
            bhtml_path = path.join('${0%/*}', '..', 'Resources', 'browserhtml',
                                   'index.html')
            runservo = os.open(path.join(content_dir, 'run-servo'),
                               os.O_WRONLY | os.O_CREAT, int("0755", 8))
            os.write(runservo, '#!/bin/bash\nexec ${0%/*}/servo ' + bhtml_path)
            os.close(runservo)

            print("Creating dmg")
            os.symlink('/Applications', path.join(dir_to_dmg, 'Applications'))
            dmg_path = path.join(target_dir, "servo-tech-demo.dmg")

            if path.exists(dmg_path):
                print("Deleting existing dmg")
                os.remove(dmg_path)

            try:
                subprocess.check_call([
                    'hdiutil', 'create', '-volname', 'Servo', dmg_path,
                    '-srcfolder', dir_to_dmg
                ])
            except subprocess.CalledProcessError as e:
                print("Packaging MacOS dmg exited with return value %d" %
                      e.returncode)
                return e.returncode
            print("Cleaning up")
            delete(dir_to_dmg)
            print("Packaged Servo into " + dmg_path)

            print("Creating brew package")
            dir_to_brew = path.join(target_dir, 'brew_tmp')
            dir_to_tar = path.join(target_dir, 'brew')
            if not path.exists(dir_to_tar):
                os.makedirs(dir_to_tar)
            tar_path = path.join(dir_to_tar, "servo.tar.gz")
            if path.exists(dir_to_brew):
                print("Cleaning up from previous packaging")
                delete(dir_to_brew)
            if path.exists(tar_path):
                print("Deleting existing package")
                os.remove(tar_path)
            shutil.copytree(path.join(dir_to_root, 'resources'),
                            path.join(dir_to_brew, 'resources'))
            os.makedirs(path.join(dir_to_brew, 'bin'))
            shutil.copy2(binary_path, path.join(dir_to_brew, 'bin', 'servo'))
            # Note that in the context of Homebrew, libexec is reserved for private use by the formula
            # and therefore is not symlinked into HOMEBREW_PREFIX.
            os.makedirs(path.join(dir_to_brew, 'libexec'))
            copy_dependencies(path.join(dir_to_brew, 'bin', 'servo'),
                              path.join(dir_to_brew, 'libexec'))
            archive_deterministically(dir_to_brew,
                                      tar_path,
                                      prepend_path='servo/')
            delete(dir_to_brew)
            print("Packaged Servo into " + tar_path)
        elif is_windows():
            dir_to_msi = path.join(target_dir, 'msi')
            if path.exists(dir_to_msi):
                print("Cleaning up from previous packaging")
                delete(dir_to_msi)
            os.makedirs(dir_to_msi)
            browserhtml_path = get_browserhtml_path(binary_path)

            print("Copying files")
            dir_to_temp = path.join(dir_to_msi, 'temp')
            dir_to_temp_servo = path.join(dir_to_temp, 'servo')
            dir_to_resources = path.join(dir_to_temp_servo, 'resources')
            shutil.copytree(path.join(dir_to_root, 'resources'),
                            dir_to_resources)
            shutil.copytree(browserhtml_path,
                            path.join(dir_to_temp_servo, 'browserhtml'))
            shutil.copy(binary_path, dir_to_temp_servo)
            shutil.copy("{}.manifest".format(binary_path), dir_to_temp_servo)
            copy_windows_dependencies(target_dir, dir_to_temp_servo)

            change_prefs(dir_to_resources, "windows")

            # generate Servo.wxs
            template_path = path.join(dir_to_root, "support", "windows",
                                      "Servo.wxs.mako")
            template = Template(open(template_path).read())
            wxs_path = path.join(dir_to_msi, "Servo.wxs")
            open(wxs_path, "w").write(
                template.render(exe_path=target_dir,
                                dir_to_temp=dir_to_temp_servo,
                                resources_path=dir_to_resources))

            # run candle and light
            print("Creating MSI")
            try:
                with cd(dir_to_msi):
                    subprocess.check_call(['candle', wxs_path])
            except subprocess.CalledProcessError as e:
                print("WiX candle exited with return value %d" % e.returncode)
                return e.returncode
            try:
                wxsobj_path = "{}.wixobj".format(path.splitext(wxs_path)[0])
                with cd(dir_to_msi):
                    subprocess.check_call(['light', wxsobj_path])
            except subprocess.CalledProcessError as e:
                print("WiX light exited with return value %d" % e.returncode)
                return e.returncode
            print("Packaged Servo into " + path.join(dir_to_msi, "Servo.msi"))

            print("Creating ZIP")
            shutil.make_archive(path.join(dir_to_msi, "Servo"), "zip",
                                dir_to_temp)
            print("Packaged Servo into " + path.join(dir_to_msi, "Servo.zip"))

            print("Cleaning up")
            delete(dir_to_temp)
        else:
            dir_to_temp = path.join(target_dir, 'packaging-temp')
            browserhtml_path = get_browserhtml_path(binary_path)
            if path.exists(dir_to_temp):
                # TODO(aneeshusa): lock dir_to_temp to prevent simultaneous builds
                print("Cleaning up from previous packaging")
                delete(dir_to_temp)

            print("Copying files")
            dir_to_resources = path.join(dir_to_temp, 'resources')
            shutil.copytree(path.join(dir_to_root, 'resources'),
                            dir_to_resources)
            shutil.copytree(browserhtml_path,
                            path.join(dir_to_temp, 'browserhtml'))
            shutil.copy(binary_path, dir_to_temp)

            change_prefs(dir_to_resources, "linux")

            print("Creating tarball")
            tar_path = path.join(target_dir, 'servo-tech-demo.tar.gz')

            archive_deterministically(dir_to_temp,
                                      tar_path,
                                      prepend_path='servo/')

            print("Cleaning up")
            delete(dir_to_temp)
            print("Packaged Servo into " + tar_path)
コード例 #9
0
ファイル: package_commands.py プロジェクト: Ms2ger/servo
    def package(self, release=False, dev=False, android=None, debug=False, debugger=None):
        env = self.build_env()
        if android is None:
            android = self.config["build"]["android"]
        binary_path = self.get_binary_path(release, dev, android=android)
        dir_to_root = self.get_top_dir()
        target_dir = path.dirname(binary_path)
        if android:
            if dev:
                env["NDK_DEBUG"] = "1"
                env["ANT_FLAVOR"] = "debug"
                dev_flag = "-d"
            else:
                env["ANT_FLAVOR"] = "release"
                dev_flag = ""

            output_apk = "{}.apk".format(binary_path)

            dir_to_apk = path.join(target_dir, "apk")
            if path.exists(dir_to_apk):
                print("Cleaning up from previous packaging")
                delete(dir_to_apk)
            shutil.copytree(path.join(dir_to_root, "support", "android", "apk"), dir_to_apk)

            blurdroid_path = find_dep_path_newest('blurdroid', binary_path)
            if blurdroid_path is None:
                print("Could not find blurdroid package; perhaps you haven't built Servo.")
                return 1
            else:
                dir_to_libs = path.join(dir_to_apk, "libs")
                if not path.exists(dir_to_libs):
                    os.makedirs(dir_to_libs)
                shutil.copy2(blurdroid_path + '/out/blurdroid.jar', dir_to_libs)
            try:
                with cd(path.join("support", "android", "build-apk")):
                    subprocess.check_call(["cargo", "run", "--", dev_flag, "-o", output_apk, "-t", target_dir,
                                           "-r", dir_to_root], env=env)
            except subprocess.CalledProcessError as e:
                print("Packaging Android exited with return value %d" % e.returncode)
                return e.returncode
        elif is_macosx():
            print("Creating Servo.app")
            dir_to_dmg = path.join(target_dir, 'dmg')
            dir_to_app = path.join(dir_to_dmg, 'Servo.app')
            dir_to_resources = path.join(dir_to_app, 'Contents', 'Resources')
            if path.exists(dir_to_dmg):
                print("Cleaning up from previous packaging")
                delete(dir_to_dmg)
            browserhtml_path = get_browserhtml_path(binary_path)

            print("Copying files")
            shutil.copytree(path.join(dir_to_root, 'resources'), dir_to_resources)
            shutil.copytree(browserhtml_path, path.join(dir_to_resources, 'browserhtml'))
            shutil.copy2(path.join(dir_to_root, 'Info.plist'), path.join(dir_to_app, 'Contents', 'Info.plist'))

            content_dir = path.join(dir_to_app, 'Contents', 'MacOS')
            os.makedirs(content_dir)
            shutil.copy2(binary_path, content_dir)

            change_prefs(dir_to_resources, "macosx")

            print("Finding dylibs and relinking")
            copy_dependencies(path.join(content_dir, 'servo'), content_dir)

            print("Adding version to Credits.rtf")
            version_command = [binary_path, '--version']
            p = subprocess.Popen(version_command,
                                 stdout=subprocess.PIPE,
                                 stderr=subprocess.PIPE,
                                 universal_newlines=True)
            version, stderr = p.communicate()
            if p.returncode != 0:
                raise Exception("Error occurred when getting Servo version: " + stderr)
            version = "Nightly version: " + version

            template_path = path.join(dir_to_resources, 'Credits.rtf.mako')
            credits_path = path.join(dir_to_resources, 'Credits.rtf')
            with open(template_path) as template_file:
                template = mako.template.Template(template_file.read())
                with open(credits_path, "w") as credits_file:
                    credits_file.write(template.render(version=version))
            delete(template_path)

            print("Writing run-servo")
            bhtml_path = path.join('${0%/*}', '..', 'Resources', 'browserhtml', 'index.html')
            runservo = os.open(
                path.join(content_dir, 'run-servo'),
                os.O_WRONLY | os.O_CREAT,
                int("0755", 8)
            )
            os.write(runservo, '#!/bin/bash\nexec ${0%/*}/servo ' + bhtml_path)
            os.close(runservo)

            print("Creating dmg")
            os.symlink('/Applications', path.join(dir_to_dmg, 'Applications'))
            dmg_path = path.join(target_dir, "servo-tech-demo.dmg")

            try:
                subprocess.check_call(['hdiutil', 'create', '-volname', 'Servo', dmg_path, '-srcfolder', dir_to_dmg])
            except subprocess.CalledProcessError as e:
                print("Packaging MacOS dmg exited with return value %d" % e.returncode)
                return e.returncode
            print("Cleaning up")
            delete(dir_to_dmg)
            print("Packaged Servo into " + dmg_path)

            print("Creating brew package")
            dir_to_brew = path.join(target_dir, 'brew_tmp')
            dir_to_tar = path.join(target_dir, 'brew')
            if not path.exists(dir_to_tar):
                os.makedirs(dir_to_tar)
            tar_path = path.join(dir_to_tar, "servo.tar.gz")
            if path.exists(dir_to_brew):
                print("Cleaning up from previous packaging")
                delete(dir_to_brew)
            if path.exists(tar_path):
                print("Deleting existing package")
                os.remove(tar_path)
            shutil.copytree(path.join(dir_to_root, 'resources'), path.join(dir_to_brew, 'resources'))
            os.makedirs(path.join(dir_to_brew, 'bin'))
            shutil.copy2(binary_path, path.join(dir_to_brew, 'bin', 'servo'))
            # Note that in the context of Homebrew, libexec is reserved for private use by the formula
            # and therefore is not symlinked into HOMEBREW_PREFIX.
            os.makedirs(path.join(dir_to_brew, 'libexec'))
            copy_dependencies(path.join(dir_to_brew, 'bin', 'servo'), path.join(dir_to_brew, 'libexec'))
            archive_deterministically(dir_to_brew, tar_path, prepend_path='servo/')
            delete(dir_to_brew)
            print("Packaged Servo into " + tar_path)
        elif is_windows():
            dir_to_msi = path.join(target_dir, 'msi')
            if path.exists(dir_to_msi):
                print("Cleaning up from previous packaging")
                delete(dir_to_msi)
            os.makedirs(dir_to_msi)
            browserhtml_path = get_browserhtml_path(binary_path)

            print("Copying files")
            dir_to_temp = path.join(dir_to_msi, 'temp')
            dir_to_temp_servo = path.join(dir_to_temp, 'servo')
            dir_to_resources = path.join(dir_to_temp_servo, 'resources')
            shutil.copytree(path.join(dir_to_root, 'resources'), dir_to_resources)
            shutil.copytree(browserhtml_path, path.join(dir_to_temp_servo, 'browserhtml'))
            shutil.copy(binary_path, dir_to_temp_servo)
            shutil.copy("{}.manifest".format(binary_path), dir_to_temp_servo)
            copy_windows_dependencies(target_dir, dir_to_temp_servo)

            change_prefs(dir_to_resources, "windows")

            # generate Servo.wxs
            template_path = path.join(dir_to_root, "support", "windows", "Servo.wxs.mako")
            template = Template(open(template_path).read())
            wxs_path = path.join(dir_to_msi, "Servo.wxs")
            open(wxs_path, "w").write(template.render(
                exe_path=target_dir,
                dir_to_temp=dir_to_temp_servo,
                resources_path=dir_to_resources))

            # run candle and light
            print("Creating MSI")
            try:
                with cd(dir_to_msi):
                    subprocess.check_call(['candle', wxs_path])
            except subprocess.CalledProcessError as e:
                print("WiX candle exited with return value %d" % e.returncode)
                return e.returncode
            try:
                wxsobj_path = "{}.wixobj".format(path.splitext(wxs_path)[0])
                with cd(dir_to_msi):
                    subprocess.check_call(['light', wxsobj_path])
            except subprocess.CalledProcessError as e:
                print("WiX light exited with return value %d" % e.returncode)
                return e.returncode
            print("Packaged Servo into " + path.join(dir_to_msi, "Servo.msi"))

            print("Creating ZIP")
            shutil.make_archive(path.join(dir_to_msi, "Servo"), "zip", dir_to_temp)
            print("Packaged Servo into " + path.join(dir_to_msi, "Servo.zip"))

            print("Cleaning up")
            delete(dir_to_temp)
        else:
            dir_to_temp = path.join(target_dir, 'packaging-temp')
            browserhtml_path = get_browserhtml_path(binary_path)
            if path.exists(dir_to_temp):
                # TODO(aneeshusa): lock dir_to_temp to prevent simultaneous builds
                print("Cleaning up from previous packaging")
                delete(dir_to_temp)

            print("Copying files")
            dir_to_resources = path.join(dir_to_temp, 'resources')
            shutil.copytree(path.join(dir_to_root, 'resources'), dir_to_resources)
            shutil.copytree(browserhtml_path, path.join(dir_to_temp, 'browserhtml'))
            shutil.copy(binary_path, dir_to_temp)

            change_prefs(dir_to_resources, "linux")

            print("Creating tarball")
            tar_path = path.join(target_dir, 'servo-tech-demo.tar.gz')

            archive_deterministically(dir_to_temp, tar_path, prepend_path='servo/')

            print("Cleaning up")
            delete(dir_to_temp)
            print("Packaged Servo into " + tar_path)
コード例 #10
0
    def run(self,
            params,
            release=False,
            dev=False,
            android=None,
            debug=False,
            debugger=None,
            browserhtml=False):
        env = self.build_env()
        env["RUST_BACKTRACE"] = "1"

        # Make --debugger imply --debug
        if debugger:
            debug = True

        if android is None:
            android = self.config["build"]["android"]

        if android:
            if debug:
                print(
                    "Android on-device debugging is not supported by mach yet. See"
                )
                print(
                    "https://github.com/servo/servo/wiki/Building-for-Android#debugging-on-device"
                )
                return
            script = [
                "am force-stop com.mozilla.servo",
                "echo servo >/sdcard/servo/android_params"
            ]
            for param in params:
                script += [
                    "echo '%s' >>/sdcard/servo/android_params" %
                    param.replace("'", "\\'")
                ]
            script += [
                "am start com.mozilla.servo/com.mozilla.servo.MainActivity",
                "exit"
            ]
            shell = subprocess.Popen(["adb", "shell"], stdin=subprocess.PIPE)
            shell.communicate("\n".join(script) + "\n")
            return shell.wait()

        args = [self.get_binary_path(release, dev)]

        if browserhtml:
            browserhtml_path = find_dep_path_newest('browserhtml', args[0])
            if browserhtml_path is None:
                print(
                    "Could not find browserhtml package; perhaps you haven't built Servo."
                )
                return 1

            if is_macosx():
                # Enable borderless on OSX
                args = args + ['-b']
            elif is_windows():
                # Convert to a relative path to avoid mingw -> Windows path conversions
                browserhtml_path = path.relpath(browserhtml_path, os.getcwd())

            args = args + [
                '--pref', 'dom.mozbrowser.enabled', '--pref',
                'dom.forcetouch.enabled', '--pref',
                'shell.builtin-key-shortcuts.enabled=false',
                path.join(browserhtml_path, 'out', 'index.html')
            ]

        # Borrowed and modified from:
        # http://hg.mozilla.org/mozilla-central/file/c9cfa9b91dea/python/mozbuild/mozbuild/mach_commands.py#l883
        if debug:
            import mozdebug
            if not debugger:
                # No debugger name was provided. Look for the default ones on
                # current OS.
                debugger = mozdebug.get_default_debugger_name(
                    mozdebug.DebuggerSearch.KeepLooking)

            self.debuggerInfo = mozdebug.get_debugger_info(debugger)
            if not self.debuggerInfo:
                print("Could not find a suitable debugger in your PATH.")
                return 1

            command = self.debuggerInfo.path
            if debugger == 'gdb' or debugger == 'lldb':
                rustCommand = 'rust-' + debugger
                try:
                    subprocess.check_call([rustCommand, '--version'],
                                          env=env,
                                          stdout=open(os.devnull, 'w'))
                except (OSError, subprocess.CalledProcessError):
                    pass
                else:
                    command = rustCommand

            # Prepend the debugger args.
            args = ([command] + self.debuggerInfo.args + args + params)
        else:
            args = args + params

        try:
            check_call(args, env=env)
        except subprocess.CalledProcessError as e:
            print("Servo exited with return value %d" % e.returncode)
            return e.returncode
        except OSError as e:
            if e.errno == 2:
                print("Servo Binary can't be found! Run './mach build'"
                      " and try again!")
            else:
                raise e