Python BaseScript.__init__方法代码示例

# 需要导入模块: from mozharness.base.script import BaseScript [as 别名]
# 或者: from mozharness.base.script.BaseScript import __init__ [as 别名]
    def __init__(self):
        BaseScript.__init__(
            self,
            config_options=self.config_options,
            # other stuff
            all_actions=[
                "purge",
                "checkout-tools",
                # First, build an optimized JS shell for running the analysis
                "checkout-source",
                "get-blobs",
                "clobber-shell",
                "configure-shell",
                "build-shell",
                # Next, build a tree with the analysis plugin
                # active. Note that we are using the same
                # checkout for the JS shell build and the build
                # of the source to be analyzed, which is a
                # little unnecessary (no need to rebuild the JS
                # shell all the time). (Different objdir,
                # though.)
                "clobber-analysis",
                "setup-analysis",
                "run-analysis",
                "collect-analysis-output",
                "upload-analysis",
                "check-expectations",
            ],
            default_actions=[
                "purge",
                "checkout-tools",
                "checkout-source",
                "get-blobs",
                "clobber-shell",
                "configure-shell",
                "build-shell",
                "clobber-analysis",
                "setup-analysis",
                "run-analysis",
                "collect-analysis-output",
                # Temporary - see bug 1211402
                #'upload-analysis',
                "check-expectations",
            ],
            config={
                "default_vcs": "hgtool",
                "vcs_share_base": os.environ.get("HG_SHARE_BASE_DIR"),
                "ccache": True,
                "buildbot_json_path": os.environ.get("PROPERTIES_FILE"),
                "tools_repo": "https://hg.mozilla.org/build/tools",
                "upload_ssh_server": None,
                "upload_remote_basepath": None,
                "enable_try_uploads": True,
                "source": None,
                "stage_product": "firefox",
            },
        )

        self.buildid = None
        self.analysis = HazardAnalysis()

# 需要导入模块: from mozharness.base.script import BaseScript [as 别名]
# 或者: from mozharness.base.script.BaseScript import __init__ [as 别名]
    def __init__(self):
        BaseScript.__init__(self,
            config_options=self.config_options,
            require_config_file=False,
            config={
                "virtualenv_modules": [
                    "boto",
                ],
                "virtualenv_path": "venv",
                'buildbot_json_path': 'buildprops.json',
            },
            all_actions=[
                "create-virtualenv",
                "collect-individual-checksums",
                "create-big-checksums",
                "sign",
                "upload",
                "copy-info-files",
            ],
            default_actions=[
                "create-virtualenv",
                "collect-individual-checksums",
                "create-big-checksums",
                "sign",
                "upload",
            ],
        )

        self.checksums = {}
        self.bucket = None
        self.bucket_name = self._get_bucket_name()
        self.file_prefix = self._get_file_prefix()
        # set the env var for boto to read our special config file
        # rather than anything else we have at ~/.boto
        os.environ["BOTO_CONFIG"] = os.path.abspath(self.config["credentials"])

# 需要导入模块: from mozharness.base.script import BaseScript [as 别名]
# 或者: from mozharness.base.script.BaseScript import __init__ [as 别名]
    def __init__(self):
        BaseScript.__init__(
            self,
            config_options=self.config_options,
            # other stuff
            all_actions=[
                "setup-mock",
                "reuse-mock",
                "checkout-tools",
                # First, build an optimized JS shell for running the analysis
                "checkout-source",
                "clobber-shell",
                "configure-shell",
                "build-shell",
                # Next, build a tree with the analysis plugin
                # active. Note that we are using the same
                # checkout for the JS shell build and the build
                # of the source to be analyzed, which is a
                # little unnecessary (no need to rebuild the JS
                # shell all the time). (Different objdir,
                # though.)
                "clobber-analysis",
                "setup-analysis",
                "run-analysis",
                "collect-analysis-output",
                "upload-analysis",
                "check-expectations",
            ],
            default_actions=[
                #'reuse-mock',
                "setup-mock",
                "checkout-tools",
                "checkout-source",
                "clobber-shell",
                "configure-shell",
                "build-shell",
                "clobber-analysis",
                "setup-analysis",
                "run-analysis",
                "collect-analysis-output",
                "upload-analysis",
                "check-expectations",
            ],
            config={
                "default_vcs": "hgtool",
                "vcs_share_base": os.environ.get("HG_SHARE_BASE_DIR"),
                "ccache": True,
                "buildbot_json_path": os.environ.get("PROPERTIES_FILE"),
                "tooltool_servers": None,
                "tools_repo": "http://hg.mozilla.org/build/tools",
                "upload_ssh_server": None,
                "upload_remote_basepath": None,
                "enable_try_uploads": True,
            },
        )

        self.nonmock_env = self.query_env(purge_env=nuisance_env_vars)
        self.env = self.nonmock_env

        self.buildtime = None

# 需要导入模块: from mozharness.base.script import BaseScript [as 别名]
# 或者: from mozharness.base.script.BaseScript import __init__ [as 别名]
    def __init__(self, **kwargs):
        kwargs.setdefault('config_options', self.config_options)
        kwargs.setdefault('all_actions', ['clobber',
                                          'read-buildbot-config',
                                          'download-and-extract',
                                          'create-virtualenv',
                                          'install',
                                          'generate-config',
                                          'run-tests',
                                         ])
        kwargs.setdefault('default_actions', ['clobber',
                                              'download-and-extract',
                                              'create-virtualenv',
                                              'install',
                                              'generate-config',
                                              'run-tests',
                                             ])
        kwargs.setdefault('config', {})
        kwargs['config'].setdefault('virtualenv_modules', ["talos", "mozinstall"])
        BaseScript.__init__(self, **kwargs)

        self.workdir = self.query_abs_dirs()['abs_work_dir'] # convenience

        # results output
        self.results_url = self.config.get('results_url')
        if self.results_url is None:
            # use a results_url by default based on the class name in the working directory
            self.results_url = 'file://%s' % os.path.join(self.workdir, self.__class__.__name__.lower() + '.txt')
        self.installer_url = self.config.get("installer_url")

# 需要导入模块: from mozharness.base.script import BaseScript [as 别名]
# 或者: from mozharness.base.script.BaseScript import __init__ [as 别名]
    def __init__(self):
        BaseScript.__init__(self,
                            config_options=self.config_options,
                            # other stuff
                            all_actions=[
                                'purge',
                                'checkout-tools',

                                # First, build an optimized JS shell for running the analysis
                                'checkout-source',
                                'get-blobs',
                                'clobber-shell',
                                'configure-shell',
                                'build-shell',

                                # Next, build a tree with the analysis plugin
                                # active. Note that we are using the same
                                # checkout for the JS shell build and the build
                                # of the source to be analyzed, which is a
                                # little unnecessary (no need to rebuild the JS
                                # shell all the time). (Different objdir,
                                # though.)
                                'clobber-analysis',
                                'setup-analysis',
                                'run-analysis',
                                'collect-analysis-output',
                                'upload-analysis',
                                'check-expectations',
                            ],
                            default_actions=[
                                'purge',
                                'checkout-tools',
                                'checkout-source',
                                'get-blobs',
                                'clobber-shell',
                                'configure-shell',
                                'build-shell',
                                'clobber-analysis',
                                'setup-analysis',
                                'run-analysis',
                                'collect-analysis-output',
                                'upload-analysis',
                                'check-expectations',
                            ],
                            config={
                                'default_vcs': 'hgtool',
                                'vcs_share_base': os.environ.get('HG_SHARE_BASE_DIR'),
                                'ccache': True,
                                'buildbot_json_path': os.environ.get('PROPERTIES_FILE'),
                                'tools_repo': 'https://hg.mozilla.org/build/tools',

                                'upload_ssh_server': None,
                                'upload_remote_basepath': None,
                                'enable_try_uploads': True,
                                'source': None,
                            },
        )

        self.buildid = None
        self.analysis = HazardAnalysis()

# 需要导入模块: from mozharness.base.script import BaseScript [as 别名]
# 或者: from mozharness.base.script.BaseScript import __init__ [as 别名]
    def __init__(self, require_config_file=True):
        # fxbuild style:
        buildscript_kwargs = {
            'all_actions': [
                "clobber",
                "pull",
                "list-locales",
                "setup",
                "repack",
                "taskcluster-upload",
                "funsize-props",
                "submit-to-balrog",
                "summary",
            ],
            'config': {
                "buildbot_json_path": "buildprops.json",
                "ignore_locales": ["en-US"],
                "locales_dir": "browser/locales",
                "update_mar_dir": "dist/update",
                "buildid_section": "App",
                "buildid_option": "BuildID",
                "application_ini": "application.ini",
                "log_name": "single_locale",
                "clobber_file": 'CLOBBER',
                "appName": "Firefox",
                "hashType": "sha512",
                "taskcluster_credentials_file": "oauth.txt",
                'virtualenv_modules': [
                    'requests==2.2.1',
                    'PyHawk-with-a-single-extra-commit==0.1.5',
                    'taskcluster==0.0.15',
                ],
                'virtualenv_path': 'venv',
            },
        }
        #

        LocalesMixin.__init__(self)
        BaseScript.__init__(
            self,
            config_options=self.config_options,
            require_config_file=require_config_file,
            **buildscript_kwargs
        )

        self.buildid = None
        self.make_ident_output = None
        self.bootstrap_env = None
        self.upload_env = None
        self.revision = None
        self.version = None
        self.upload_urls = {}
        self.locales_property = {}
        self.package_urls = {}
        self.pushdate = None
        # upload_files is a dictionary of files to upload, keyed by locale.
        self.upload_files = {}

        if 'mock_target' in self.config:
            self.enable_mock()

# 需要导入模块: from mozharness.base.script import BaseScript [as 别名]
# 或者: from mozharness.base.script.BaseScript import __init__ [as 别名]
    def __init__(self, require_config_file=False, config={},
                 all_actions=all_actions,
                 default_actions=default_actions):

        # Default configuration
        default_config = {
            'debug_build': False,
            'pip_index': True,
            # this will pip install it automajically when we call the create-virtualenv action
            'virtualenv_modules': ['google-api-python-client'],
            "find_links": [   # so mozharness knows where to look for the package
                "http://pypi.pvt.build.mozilla.org/pub",
                "http://pypi.pub.build.mozilla.org/pub",
            ],
            # the path inside the work_dir ('build') of where we will install the env.
            # pretty sure it's the default and not needed.
            'virtualenv_path': 'venv',
        }
        default_config.update(config)

        BaseScript.__init__(
            self,
            config_options=self.config_options,
            require_config_file=require_config_file,
            config=default_config,
            all_actions=all_actions,
            default_actions=default_actions,
        )

# 需要导入模块: from mozharness.base.script import BaseScript [as 别名]
# 或者: from mozharness.base.script.BaseScript import __init__ [as 别名]
    def __init__(self, require_config_file=True):
        LocalesMixin.__init__(self)
        BaseScript.__init__(
            self,
            config_options=self.config_options,
            all_actions=[
                "clobber",
                "pull",
                "list-locales",
                "setup",
                "repack",
                #"generate-complete-mar",
                #"generate-partials",
                "create-nightly-snippets",
                "upload-nightly-repacks",
                "upload-snippets",
                "summary",
            ],
            require_config_file=require_config_file
        )
        self.buildid = None
        self.make_ident_output = None
        self.repack_env = None
        self.revision = None
        self.version = None
        self.upload_urls = {}
        self.locales_property = {}
        self.l10n_dir = None

        if 'mock_target' in self.config:
            self.enable_mock()

# 需要导入模块: from mozharness.base.script import BaseScript [as 别名]
# 或者: from mozharness.base.script.BaseScript import __init__ [as 别名]
    def __init__(self, require_config_file=False):
        LocalesMixin.__init__(self)
        BaseScript.__init__(self,
                            config_options=self.config_options,
                            all_actions=[
                                'pull',
                                'build',
                                'summary',
                            ],
                            require_config_file=require_config_file,

                            # Default configuration
                            config={
                                'gaia_l10n_vcs': 'hg',
                                'vcs_share_base': os.environ.get('HG_SHARE_BASE_DIR'),
                                'locales_dir': 'b2g/locales',
                                'l10n_dir': 'gecko-l10n',
                                # I forget what this was for.  Copied from the Android multilocale stuff
                                'ignore_locales': ["en-US", "multi"],
                                # This only has 2 locales in it.  We probably need files that mirror gaia's locale lists
                                # We need 2 sets of locales files because the locale names in gaia are different than gecko, e.g. 'es' vs 'es-ES'
                                # We'll need to override this for localizer buidls
                                'locales_file': 'build/b2g/locales/all-locales',
                                'mozilla_dir': 'build',
                                'objdir': 'obj-firefox',
                                'merge_locales': True,
                                'work_dir': '.',
                                'vcs_output_timeout': 600,  # 10 minutes should be enough for anyone!
                            },
                            )

# 需要导入模块: from mozharness.base.script import BaseScript [as 别名]
# 或者: from mozharness.base.script.BaseScript import __init__ [as 别名]
    def __init__(self):
        # fxbuild style:
        buildscript_kwargs = {
            'all_actions': DesktopPartnerRepacks.actions,
            'default_actions': DesktopPartnerRepacks.actions,
            'config': {
                'buildbot_json_path': os.environ.get('PROPERTIES_FILE'),
                "log_name": "partner-repacks",
                "hashType": "sha512",
                'virtualenv_modules': [
                    'requests==2.2.1',
                    'PyHawk-with-a-single-extra-commit==0.1.5',
                    'taskcluster==0.0.15',
                    's3cmd==1.6.0',
                ],
                'virtualenv_path': 'venv',
                'workdir': 'partner-repacks',
            },
        }
        #

        BaseScript.__init__(
            self,
            config_options=self.config_options,
            **buildscript_kwargs
        )

        if 'version' not in self.config:
            self.fatal("Version (-v) not supplied.")
        if 'buildnumber' not in self.config:
            self.fatal("Build number (-n) not supplied.")
        if 'repo_file' not in self.config:
            self.fatal("repo_file not supplied.")
        if 'repack_manifests_url' not in self.config:
            self.fatal("repack_manifests_url not supplied.")

# 需要导入模块: from mozharness.base.script import BaseScript [as 别名]
# 或者: from mozharness.base.script.BaseScript import __init__ [as 别名]
    def __init__(self):
        BaseScript.__init__(self,
            config_options=self.config_options,
            require_config_file=False,
            config={
                "virtualenv_modules": [
                    "boto",
                    "redo",
                ],
                "virtualenv_path": "venv",
            },
            all_actions=[
                "create-virtualenv",
                "activate-virtualenv",
                "collect-individual-checksums",
                "create-big-checksums",
                "sign",
                "get-upload-script",
                "upload",
            ],
            default_actions=[
                "create-virtualenv",
                "activate-virtualenv",
                "collect-individual-checksums",
                "create-big-checksums",
                "sign",
                "get-upload-script",
                "upload",
            ],
        )

        self.checksums = {}

# 需要导入模块: from mozharness.base.script import BaseScript [as 别名]
# 或者: from mozharness.base.script.BaseScript import __init__ [as 别名]
 def __init__(self):
     BaseScript.__init__(self,
                         config_options=self.config_options,
                         # other stuff
                         all_actions=[
                             'setup-mock',
                             'checkout-servo',
                             'clobber-obj',
                             'configure',
                             'build',
                             'check',
                         ],
                         default_actions=[
                             'checkout-servo',
                             'clobber-obj',
                             'configure',
                             'build',
                             'check',
                         ],
                         config={
                             'default_vcs': 'gittool',
                             'backup_rust': True,
                             'concurrency': 1,
                         },
                         )

# 需要导入模块: from mozharness.base.script import BaseScript [as 别名]
# 或者: from mozharness.base.script.BaseScript import __init__ [as 别名]
    def __init__(self):
        BaseScript.__init__(self,
            config_options=self.config_options,
            require_config_file=False,
            config={
                "virtualenv_modules": [
                    "boto",
                    "redo",
                ],
                "virtualenv_path": "venv",
            },
            all_actions=[
                "create-virtualenv",
                "activate-virtualenv",
                "push-to-releases",
            ],
            default_actions=[
                "create-virtualenv",
                "activate-virtualenv",
                "push-to-releases",
            ],
        )

        # set the env var for boto to read our special config file
        # rather than anything else we have at ~/.boto
        os.environ["BOTO_CONFIG"] = os.path.abspath(self.config["credentials"])

# 需要导入模块: from mozharness.base.script import BaseScript [as 别名]
# 或者: from mozharness.base.script.BaseScript import __init__ [as 别名]
    def __init__(self, require_config_file=False, config={},
                 all_actions=all_actions,
                 default_actions=default_actions):

        # Default configuration
        default_config = {
            'debug_build': False,
            'pip_index': True,
            # this will pip install it automajically when we call the
            # create-virtualenv action
            'virtualenv_modules': ['google-api-python-client'],
            "find_links": [
                "http://pypi.pvt.build.mozilla.org/pub",
                "http://pypi.pub.build.mozilla.org/pub",
            ],
            'virtualenv_path': 'venv',
        }
        default_config.update(config)

        BaseScript.__init__(
            self,
            config_options=self.config_options,
            require_config_file=require_config_file,
            config=default_config,
            all_actions=all_actions,
            default_actions=default_actions,
        )

        self.all_locales_url = self.config['l10n_api_url'] + "api/?done&channel={channel}"
        self.locale_url = self.config['l10n_api_url'] + "api/?locale={locale}&channel={channel}"
        self.mapping_url = self.config['l10n_api_url'] + "api/?locale_mapping&reverse"

# 需要导入模块: from mozharness.base.script import BaseScript [as 别名]
# 或者: from mozharness.base.script.BaseScript import __init__ [as 别名]
    def __init__(self):
        # fxbuild style:
        buildscript_kwargs = {
            'all_actions': DesktopPartnerRepacks.actions,
            'default_actions': DesktopPartnerRepacks.actions,
            'config': {
                'buildbot_json_path': 'buildprops.json',
                "log_name": "partner-repacks",
                "hashType": "sha512",
                'virtualenv_modules': [
                    'requests==2.2.1',
                    'PyHawk-with-a-single-extra-commit==0.1.5',
                    'taskcluster==0.0.15',
                    's3cmd==1.6.0',
                ],
                'virtualenv_path': 'venv',
                'workdir': 'partner-repacks',
            },
        }
        #

        BaseScript.__init__(
            self,
            config_options=self.config_options,
            **buildscript_kwargs
        )