#!/usr/bin/env python ############################################################################# ## ## Copyright (C) 2015 The Qt Company Ltd. ## Contact: https://www.qt.io/licensing/ ## ## This file is part of the QtWebEngine module of the Qt Toolkit. ## ## $QT_BEGIN_LICENSE:GPL-EXCEPT$ ## Commercial License Usage ## Licensees holding valid commercial Qt licenses may use this file in ## accordance with the commercial license agreement provided with the ## Software or, alternatively, in accordance with the terms contained in ## a written agreement between you and The Qt Company. For licensing terms ## and conditions see https://www.qt.io/terms-conditions. For further ## information use the contact form at https://www.qt.io/contact-us. ## ## GNU General Public License Usage ## Alternatively, this file may be used under the terms of the GNU ## General Public License version 3 as published by the Free Software ## Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT ## included in the packaging of this file. Please review the following ## information to ensure the GNU General Public License requirements will ## be met: https://www.gnu.org/licenses/gpl-3.0.html. ## ## $QT_END_LICENSE$ ## ############################################################################# import argparse import os import re import subprocess import shutil import sys class Api: QUICK = "webengine" WIDGET = "webenginewidgets" class Mode: RELEASE = "release" DEBUG = "debug" def is_windows(): return os.name == "nt" class ArgManager(object): def __init__(self): try: self.__args = self.__parse() except: raise self.build_dir = self.__args.build_dir self.src_dir = self.__args.src_dir self.example_filter = re.compile("%s-%s-%s" % (self.__api_filter(), self.__name_filter(), self.__mode_filter())) self.list_examples = self.__args.list_examples self.force = self.__args.force self.verbose = self.__args.verbose self.out_dir = self.__args.out_dir def __parse(self): ap = argparse.ArgumentParser(description="Deploy QtWebEngine example binaries on Windows.") ap.add_argument("--release", dest="release", action="store_true", default=False, help="Deploy release binaries only") ap.add_argument("--debug", dest="debug", action="store_true", default=False, help="Deploy debug binaries only") ap.add_argument("--quick", dest="quick", action="store_true", default=False, help="Deploy quick examples only") ap.add_argument("--widget", dest="widget", action="store_true", default=False, help="Deploy widget examples only") ap.add_argument("-e", "--examples", dest="examples", nargs="+", action="store", default=".*", help="Select example to deploy") ap.add_argument("-l", "--list-examples", dest="list_examples", action="store_true", default=False, help="List available examples") ap.add_argument("-f", "--force", dest="force", action="store_true", default=False, help="Force to overwrite existing files") ap.add_argument("-v", "--verbose", dest="verbose", action="store_true", default=False, help="Print windeployqt output") ap.add_argument("--src-dir", dest="src_dir", action="store", type=self.__validate_src_dir, default=None, help="Specify path of Qt sources. It is used for finding QML files of the example" "and scanning for QML imports") ap.add_argument("--build-dir", dest="build_dir", action="store", type=self.__validate_build_dir, default=None, help="Specify path of the Qt binaries. It is used for finding qmake.exe, windeployqt.exe and" "binaries of the examples. It is not necessary to set if qmake.exe is set in the path") ap.add_argument("-o", "--out-dir", dest="out_dir", action="store", default=os.getcwd(), help="Specify path for the deployed examples. If it is not set" "current working directory is used") return ap.parse_args() def __validate_src_dir(self, src_dir): if not os.path.exists(src_dir): raise OSError("The specified Qt source directory does not exist: %s" % src_dir) qtwebengine_dir = src_dir # Accept Qt top level source directory too if os.path.exists(os.path.join(src_dir, "qtwebengine")): qtwebengine_dir = os.path.join(src_dir, "qtwebengine") examples_dir = os.path.join(qtwebengine_dir, "examples") must_have_paths = [ os.path.join(examples_dir, "examples.pro"), os.path.join(examples_dir, Api.QUICK), os.path.join(examples_dir, Api.WIDGET), ] # Check whether src_dir is the proper QtWebEngine source directory for p in must_have_paths: if not os.path.exists(p): raise OSError("The specified Qt source directory is invalid: %s" % src_dir) return src_dir def __validate_build_dir(self, build_dir): if not os.path.exists(build_dir): raise OSError("The specified Qt build directory does not exist: %s" % build_dir) # Accept QtWebEngine build directory too if os.path.basename(build_dir) == "qtwebengine": build_dir = os.path.abspath(os.path.join(build_dir, "..")) # Attempt to support custom build directories if os.path.exists(os.path.join(build_dir, "bin", "qmake.exe")): return build_dir # Check existence of qtbase/bin/qmake.exe qtbase_dir = os.path.join(build_dir, "qtbase") if not os.path.exists(os.path.join(qtbase_dir, "bin", "qmake.exe")): raise OSError("Program 'qmake.exe' cannot be found in the specified Qt build directory: %s" % build_dir) return qtbase_dir def __mode_filter(self): if self.__args.release and not self.__args.debug: return Mode.RELEASE if not self.__args.release and self.__args.debug: return Mode.DEBUG return ".*" def __api_filter(self): if self.__args.quick and not self.__args.widget: return Api.QUICK if not self.__args.quick and self.__args.widget: return Api.WIDGET return ".*" def __name_filter(self): alt_list = [] examples = self.__args.examples if not isinstance(examples, list): examples = [examples] for e in examples: if "," in e: alt_list.extend(e.split(",")) else: alt_list.append(e) return "|".join(alt_list) class QtHelper(object): def __init__(self, build_path=None, src_path=None): self.__build_path = build_path if build_path is not None else "" self.__src_path = src_path if src_path is not None else "" self.__query = {} self.__angle = None self.__qmake = "qmake.exe" self.__windeployqt = "windeployqt.exe" if build_path: self.__qmake = os.path.join(self.__build_path, "bin", self.__qmake) self.__windeployqt = os.path.join(self.__build_path, "bin", self.__windeployqt) try: program = self.__qmake subprocess.check_output([program, "-v"]) program = self.__windeployqt subprocess.check_output([program, "-h"]) except OSError as e: raise OSError("Program '%s' cannot be executed\n%s" % (program, e)) except: raise self.__query = self.get_query() self.__build_path = self.get_build_path() self.__src_path = self.get_src_path() self.__angle = self.has_angle() def get_query(self): if self.__query: return self.__query qmake_output = subprocess.check_output([self.__qmake, "-query"]).split("\r\n") query = {} for line in qmake_output: entry = line.split(":", 1) if len(entry) != 2: continue query[entry[0]] = entry[1] return query def get_build_path(self): return os.path.abspath(os.path.join(self.__query["QT_INSTALL_PREFIX"], "..")) def get_src_path(self): if self.__src_path: return self.__src_path if "QT_INSTALL_PREFIX/src" in self.__query: return os.path.abspath(os.path.join(self.__query["QT_INSTALL_PREFIX/src"], "..")) return self.__build_path def get_windeployqt(self): return self.__windeployqt def has_angle(self): if self.__angle: return self.__angle qconfig_pri_path = os.path.abspath(os.path.join(self.__query["QT_HOST_PREFIX"], "mkspecs", "qconfig.pri")) print(qconfig_pri_path) if not os.path.exists(qconfig_pri_path): sys.stderr.write("Configuration file qconfig.pri cannot be found. Fallback to desktop GL mode.\n") return False qt_config = [] qconfig_pri = open(qconfig_pri_path, "r") for line in qconfig_pri: if line.startswith("QT_CONFIG +="): qt_config = re.match("^QT_CONFIG \+= (.+)$", line).group(1).split(" ") qconfig_pri.close() return "angle" in qt_config def collect_examples(self): examples = [] for api in [Api.QUICK, Api.WIDGET]: examples_root_dir_path = os.path.join(self.__build_path, "qtwebengine", "examples", api) if not os.path.exists(examples_root_dir_path): continue for example in os.listdir(examples_root_dir_path): example_dir_path = os.path.join(examples_root_dir_path, example) if not os.path.exists(example_dir_path): continue example_src_path = os.path.join(self.__src_path, "qtwebengine", "examples", api, example) for mode in [Mode.RELEASE, Mode.DEBUG]: example_exe_path = os.path.join(example_dir_path, mode, example + ".exe") if not os.path.exists(example_exe_path): continue examples.append(Example(example, api, mode, self.__angle, example_exe_path, example_src_path)) return examples class Example(str): def __new__(cls, example, api, mode, angle, exe_path, src_path): obj = str.__new__(cls, "%s-%s-%s" % (api, example, mode)) return obj def __init__(self, example, api, mode, angle, exe_path, src_path): super(Example, self).__init__("%s-%s-%s" % (api, example, mode)) self.__name = example self.__api = api self.__mode = mode self.__angle = angle self.__exe_path = exe_path self.__src_path = src_path def get_deploy_params(self, mode, force): deploy_params = [] deploy_params.append("--%s" % mode) deploy_params.append("--compiler-runtime") if self.__angle: deploy_params.append("--angle") if force: deploy_params.append("--force") if self.__api is Api.QUICK: deploy_params.append("--qmldir") deploy_params.append(self.__src_path) if self.__mode is Mode.DEBUG: deploy_params.append("--pdb") return deploy_params def name(self): return self.__name def deploy(self, qt, dest_path, force=False, verbose=False): src_path = os.path.dirname(self.__exe_path) for f in os.listdir(src_path): shutil.copy(os.path.join(src_path, f), dest_path) deploy_command = [] deploy_command.append(qt.get_windeployqt()) # Debug executables also need the release libraries deploy_command.extend(self.get_deploy_params(Mode.RELEASE, force)) deploy_command.append(dest_path) if verbose: print("%s" % " ".join(deploy_command)) out = None if verbose else open(os.devnull, "w") exit_code = subprocess.call(deploy_command, stdout=out) if self.__mode is Mode.DEBUG and not exit_code: param_release = "--%s" % Mode.RELEASE param_debug = "--%s" % Mode.DEBUG deploy_command = map(lambda item: param_debug if item == param_release else item, deploy_command) if verbose: print("%s" % " ".join(deploy_command)) exit_code = subprocess.call(deploy_command, stdout=out) if out is not None: out.close() return exit_code def main(): try: args = ArgManager() if not is_windows(): raise OSError("This script works on Windows only\n") qt = QtHelper(args.build_dir, args.src_dir) except Exception as e: sys.stderr.write(str(e)) exit(1) example_list = filter((lambda e: args.example_filter.match(e)), qt.collect_examples()) if not example_list: print("There is no example that fulfills the requirements") return for example in example_list: if args.list_examples: print(example.name()) continue print("Deploying %s ..." % example.name()) dest_path = os.path.abspath(os.path.join(args.out_dir, example.name())) if not os.path.exists(dest_path): os.makedirs(dest_path) elif os.listdir(dest_path) and not args.force: sys.stderr.write("Destination directory is not empty: %s\n" % dest_path) sys.stderr.write("Skip deploying %s\n" % example.name()) continue exit_code = example.deploy(qt, dest_path, args.force, args.verbose) if exit_code: sys.stderr.write("Deploy of example '%s' has failed: %s\n" % (example.name(), exit_code)) exit(exit_code) print("Example '%s' has been successfully deployed at %s" % (example.name(), dest_path)) return if __name__ == "__main__": main()