def _postprocess_config(self):
        """Postprocessing of configuration options"""
        if self.options.prefix is not None:
            # prefix applies to all paths, and repository has to be reinitialised to take new repositorypath in account
            # in the legacy-style configuration, repository is initialised in configuration file itself
            for dest in ["installpath", "buildpath", "sourcepath", "repository", "repositorypath"]:
                if not self.options._action_taken.get(dest, False):
                    if dest == "repository":
                        setattr(self.options, dest, DEFAULT_REPOSITORY)
                    elif dest == "repositorypath":
                        repositorypath = [mk_full_default_path(dest, prefix=self.options.prefix)]
                        setattr(self.options, dest, repositorypath)
                        self.go_cfg_constants[self.DEFAULTSECT]["DEFAULT_REPOSITORYPATH"] = repositorypath
                    else:
                        setattr(self.options, dest, mk_full_default_path(dest, prefix=self.options.prefix))
                    # LEGACY this line is here for oldstyle config reasons
                    self.options._action_taken[dest] = True

        if self.options.pretend:
            self.options.installpath = get_pretend_installpath()

        if self.options.robot is not None:
            # paths specified to --robot have preference over --robot-paths
            # keep both values in sync if robot is enabled, which implies enabling dependency resolver
            self.options.robot_paths = self.options.robot + self.options.robot_paths
            self.options.robot = self.options.robot_paths
    def _postprocess_config(self):
        """Postprocessing of configuration options"""
        if self.options.prefix is not None:
            # prefix applies to all paths, and repository has to be reinitialised to take new repositorypath in account
            # in the legacy-style configuration, repository is initialised in configuration file itself
            for dest in [
                    'installpath', 'buildpath', 'sourcepath', 'repository',
                    'repositorypath'
            ]:
                if not self.options._action_taken.get(dest, False):
                    if dest == 'repository':
                        setattr(self.options, dest, DEFAULT_REPOSITORY)
                    elif dest == 'repositorypath':
                        setattr(self.options, dest, [
                            mk_full_default_path(dest,
                                                 prefix=self.options.prefix)
                        ])
                    else:
                        setattr(
                            self.options, dest,
                            mk_full_default_path(dest,
                                                 prefix=self.options.prefix))
                    # LEGACY this line is here for oldstyle config reasons
                    self.options._action_taken[dest] = True

        if self.options.pretend:
            self.options.installpath = get_pretend_installpath()

        if self.options.robot is not None:
            # paths specified to --robot have preference over --robot-paths
            # keep both values in sync if robot is enabled, which implies enabling dependency resolver
            self.options.robot_paths = self.options.robot + self.options.robot_paths
            self.options.robot = self.options.robot_paths
Exemple #3
0
    def config_options(self):
        # config options
        descr = ("Configuration options", "Configure EasyBuild behavior.")

        opts = OrderedDict({
            'avail-module-naming-schemes': ("Show all supported module naming schemes",
                                            None, 'store_true', False,),
            'avail-modules-tools': ("Show all supported module tools",
                                    None, "store_true", False,),
            'avail-repositories': ("Show all repository types (incl. non-usable)",
                                    None, "store_true", False,),
            'buildpath': ("Temporary build path", None, 'store', mk_full_default_path('buildpath')),
            'ignore-dirs': ("Directory names to ignore when searching for files/dirs",
                            'strlist', 'store', ['.git', '.svn']),
            'installpath': ("Install path for software and modules", None, 'store', mk_full_default_path('installpath')),
            'config': ("Path to EasyBuild config file (DEPRECATED, use --configfiles instead!)",
                       None, 'store', get_default_oldstyle_configfile(), 'C'),
            # purposely take a copy for the default logfile format
            'logfile-format': ("Directory name and format of the log file",
                               'strtuple', 'store', DEFAULT_LOGFILE_FORMAT[:], {'metavar': 'DIR,FORMAT'}),
            'module-naming-scheme': ("Module naming scheme",
                                     'choice', 'store', DEFAULT_MNS, sorted(avail_module_naming_schemes().keys())),
            'moduleclasses': (("Extend supported module classes "
                               "(For more info on the default classes, use --show-default-moduleclasses)"),
                               None, 'extend', [x[0] for x in DEFAULT_MODULECLASSES]),
            'modules-footer': ("Path to file containing footer to be added to all generated module files",
                               None, 'store_or_None', None, {'metavar': "PATH"}),
            'modules-tool': ("Modules tool to use",
                             'choice', 'store', DEFAULT_MODULES_TOOL, sorted(avail_modules_tools().keys())),
            'prefix': (("Change prefix for buildpath, installpath, sourcepath and repositorypath "
                        "(used prefix for defaults %s)" % DEFAULT_PREFIX),
                        None, 'store', None),
            'recursive-module-unload': ("Enable generating of modules that unload recursively.",
                                        None, 'store_true', False),
            'repository': ("Repository type, using repositorypath",
                           'choice', 'store', DEFAULT_REPOSITORY, sorted(avail_repositories().keys())),
            'repositorypath': (("Repository path, used by repository "
                                "(is passed as list of arguments to create the repository instance). "
                                "For more info, use --avail-repositories."),
                                'strlist', 'store',
                                [mk_full_default_path('repositorypath')]),
            'show-default-moduleclasses': ("Show default module classes with description",
                                           None, 'store_true', False),
            'sourcepath': ("Path(s) to where sources should be downloaded (string, colon-separated)",
                           None, 'store', mk_full_default_path('sourcepath')),
            'subdir-modules': ("Installpath subdir for modules", None, 'store', DEFAULT_PATH_SUBDIRS['subdir_modules']),
            'subdir-software': ("Installpath subdir for software", None, 'store', DEFAULT_PATH_SUBDIRS['subdir_software']),
            'suffix-modules-path': ("Suffix for module files install path", None, 'store', GENERAL_CLASS),
            # this one is sort of an exception, it's something jobscripts can set,
            # has no real meaning for regular eb usage
            'testoutput': ("Path to where a job should place the output (to be set within jobscript)",
                            None, 'store', None),
            'tmp-logdir': ("Log directory where temporary log files are stored",
                           None, 'store', DEFAULT_TMP_LOGDIR),
            'tmpdir': ('Directory to use for temporary storage', None, 'store', None),
        })

        self.log.debug("config_options: descr %s opts %s" % (descr, opts))
        self.add_group_parser(opts, descr)
Exemple #4
0
    def __init__(self, *args, **kwargs):
        """Constructor."""

        self.default_repositorypath = [mk_full_default_path('repositorypath')]
        self.default_robot_paths = get_paths_for(subdir=EASYCONFIGS_PKG_SUBDIR,
                                                 robot_path=None) or []

        # set up constants to seed into config files parser, by section
        self.go_cfg_constants = {
            self.DEFAULTSECT: {
                'DEFAULT_REPOSITORYPATH':
                (self.default_repositorypath[0],
                 "Default easyconfigs repository path"),
                'DEFAULT_ROBOT_PATHS':
                (os.pathsep.join(self.default_robot_paths),
                 "List of default robot paths ('%s'-separated)" % os.pathsep),
            }
        }

        # update or define go_configfiles_initenv in named arguments to pass to parent constructor
        go_cfg_initenv = kwargs.setdefault('go_configfiles_initenv', {})
        for section, constants in self.go_cfg_constants.items():
            constants = dict([(name, value)
                              for (name, (value, _)) in constants.items()])
            go_cfg_initenv.setdefault(section, {}).update(constants)

        super(EasyBuildOptions, self).__init__(*args, **kwargs)
    def __init__(self, *args, **kwargs):
        """Constructor."""

        self.default_repositorypath = [mk_full_default_path('repositorypath')]
        self.default_robot_paths = get_paths_for(subdir=EASYCONFIGS_PKG_SUBDIR, robot_path=None) or []

        # set up constants to seed into config files parser, by section
        self.go_cfg_constants = {
            self.DEFAULTSECT: {
                'DEFAULT_REPOSITORYPATH': (self.default_repositorypath[0], "Default easyconfigs repository path"),
                'DEFAULT_ROBOT_PATHS': (os.pathsep.join(self.default_robot_paths),
                                        "List of default robot paths ('%s'-separated)" % os.pathsep),
            }
        }

        # update or define go_configfiles_initenv in named arguments to pass to parent constructor
        go_cfg_initenv = kwargs.setdefault('go_configfiles_initenv', {})
        for section, constants in self.go_cfg_constants.items():
            constants = dict([(name, value) for (name, (value, _)) in constants.items()])
            go_cfg_initenv.setdefault(section, {}).update(constants)

        super(EasyBuildOptions, self).__init__(*args, **kwargs)
Exemple #6
0
    def avail_repositories(self):
        """Show list of known repository types."""
        repopath_defaults = mk_full_default_path('repositorypath')
        all_repos = avail_repositories(check_useable=False)
        usable_repos = avail_repositories(check_useable=True).keys()

        indent = ' ' * 2
        txt = ['All avaliable repository types']
        repos = sorted(all_repos.keys())
        for repo in repos:
            if repo in usable_repos:
                missing = ''
            else:
                missing = ' (*not usable*, something is missing (e.g. a required Python module))'
            if repo in repopath_defaults:
                default = ' (default arguments: %s)' % ', '.join(repopath_defaults[repo])
            else:
                default = ' (no default arguments)'

            txt.append("%s* %s%s%s" % (indent, repo, default, missing))
            txt.append("%s%s" % (indent * 3, all_repos[repo].DESCRIPTION))

        return "\n".join(txt)
    def avail_repositories(self):
        """Show list of known repository types."""
        repopath_defaults = mk_full_default_path('repositorypath')
        all_repos = avail_repositories(check_useable=False)
        usable_repos = avail_repositories(check_useable=True).keys()

        indent = ' ' * 2
        txt = ['All avaliable repository types']
        repos = sorted(all_repos.keys())
        for repo in repos:
            if repo in usable_repos:
                missing = ''
            else:
                missing = ' (*not usable*, something is missing (e.g. a required Python module))'
            if repo in repopath_defaults:
                default = ' (default arguments: %s)' % ', '.join(
                    repopath_defaults[repo])
            else:
                default = ' (no default arguments)'

            txt.append("%s* %s%s%s" % (indent, repo, default, missing))
            txt.append("%s%s" % (indent * 3, all_repos[repo].DESCRIPTION))

        return "\n".join(txt)
    def config_options(self):
        # config options
        descr = ("Configuration options", "Configure EasyBuild behavior.")

        opts = OrderedDict(
            {
                "avail-module-naming-schemes": ("Show all supported module naming schemes", None, "store_true", False),
                "avail-modules-tools": ("Show all supported module tools", None, "store_true", False),
                "avail-repositories": ("Show all repository types (incl. non-usable)", None, "store_true", False),
                "buildpath": ("Temporary build path", None, "store", mk_full_default_path("buildpath")),
                "external-modules-metadata": (
                    "List of files specifying metadata for external modules (INI format)",
                    "strlist",
                    "store",
                    [],
                ),
                "ignore-dirs": (
                    "Directory names to ignore when searching for files/dirs",
                    "strlist",
                    "store",
                    [".git", ".svn"],
                ),
                "installpath": (
                    "Install path for software and modules",
                    None,
                    "store",
                    mk_full_default_path("installpath"),
                ),
                "installpath-modules": (
                    "Install path for modules (if None, combine --installpath and --subdir-modules)",
                    None,
                    "store",
                    None,
                ),
                "installpath-software": (
                    "Install path for software (if None, combine --installpath and --subdir-software)",
                    None,
                    "store",
                    None,
                ),
                # purposely take a copy for the default logfile format
                "logfile-format": (
                    "Directory name and format of the log file",
                    "strtuple",
                    "store",
                    DEFAULT_LOGFILE_FORMAT[:],
                    {"metavar": "DIR,FORMAT"},
                ),
                "module-naming-scheme": (
                    "Module naming scheme",
                    "choice",
                    "store",
                    DEFAULT_MNS,
                    sorted(avail_module_naming_schemes().keys()),
                ),
                "module-syntax": (
                    "Syntax to be used for module files",
                    "choice",
                    "store",
                    DEFAULT_MODULE_SYNTAX,
                    sorted(avail_module_generators().keys()),
                ),
                "moduleclasses": (
                    (
                        "Extend supported module classes "
                        "(For more info on the default classes, use --show-default-moduleclasses)"
                    ),
                    None,
                    "extend",
                    [x[0] for x in DEFAULT_MODULECLASSES],
                ),
                "modules-footer": (
                    "Path to file containing footer to be added to all generated module files",
                    None,
                    "store_or_None",
                    None,
                    {"metavar": "PATH"},
                ),
                "modules-tool": (
                    "Modules tool to use",
                    "choice",
                    "store",
                    DEFAULT_MODULES_TOOL,
                    sorted(avail_modules_tools().keys()),
                ),
                "prefix": (
                    (
                        "Change prefix for buildpath, installpath, sourcepath and repositorypath "
                        "(used prefix for defaults %s)" % DEFAULT_PREFIX
                    ),
                    None,
                    "store",
                    None,
                ),
                "recursive-module-unload": (
                    "Enable generating of modules that unload recursively.",
                    None,
                    "store_true",
                    False,
                ),
                "repository": (
                    "Repository type, using repositorypath",
                    "choice",
                    "store",
                    DEFAULT_REPOSITORY,
                    sorted(avail_repositories().keys()),
                ),
                "repositorypath": (
                    (
                        "Repository path, used by repository "
                        "(is passed as list of arguments to create the repository instance). "
                        "For more info, use --avail-repositories."
                    ),
                    "strlist",
                    "store",
                    self.default_repositorypath,
                ),
                "sourcepath": (
                    "Path(s) to where sources should be downloaded (string, colon-separated)",
                    None,
                    "store",
                    mk_full_default_path("sourcepath"),
                ),
                "subdir-modules": (
                    "Installpath subdir for modules",
                    None,
                    "store",
                    DEFAULT_PATH_SUBDIRS["subdir_modules"],
                ),
                "subdir-software": (
                    "Installpath subdir for software",
                    None,
                    "store",
                    DEFAULT_PATH_SUBDIRS["subdir_software"],
                ),
                "suffix-modules-path": ("Suffix for module files install path", None, "store", GENERAL_CLASS),
                # this one is sort of an exception, it's something jobscripts can set,
                # has no real meaning for regular eb usage
                "testoutput": (
                    "Path to where a job should place the output (to be set within jobscript)",
                    None,
                    "store",
                    None,
                ),
                "tmp-logdir": ("Log directory where temporary log files are stored", None, "store", None),
                "tmpdir": ("Directory to use for temporary storage", None, "store", None),
            }
        )

        self.log.debug("config_options: descr %s opts %s" % (descr, opts))
        self.add_group_parser(opts, descr)
    def config_options(self):
        # config options
        descr = ("Configuration options", "Configure EasyBuild behavior.")

        opts = OrderedDict({
            'avail-module-naming-schemes': (
                "Show all supported module naming schemes",
                None,
                'store_true',
                False,
            ),
            'avail-modules-tools': (
                "Show all supported module tools",
                None,
                "store_true",
                False,
            ),
            'avail-repositories': (
                "Show all repository types (incl. non-usable)",
                None,
                "store_true",
                False,
            ),
            'buildpath': ("Temporary build path", None, 'store',
                          mk_full_default_path('buildpath')),
            'ignore-dirs':
            ("Directory names to ignore when searching for files/dirs",
             'strlist', 'store', ['.git', '.svn']),
            'installpath': ("Install path for software and modules", None,
                            'store', mk_full_default_path('installpath')),
            # purposely take a copy for the default logfile format
            'logfile-format':
            ("Directory name and format of the log file", 'strtuple', 'store',
             DEFAULT_LOGFILE_FORMAT[:], {
                 'metavar': 'DIR,FORMAT'
             }),
            'module-naming-scheme':
            ("Module naming scheme", 'choice', 'store', DEFAULT_MNS,
             sorted(avail_module_naming_schemes().keys())),
            'moduleclasses':
            (("Extend supported module classes "
              "(For more info on the default classes, use --show-default-moduleclasses)"
              ), None, 'extend', [x[0] for x in DEFAULT_MODULECLASSES]),
            'modules-footer':
            ("Path to file containing footer to be added to all generated module files",
             None, 'store_or_None', None, {
                 'metavar': "PATH"
             }),
            'modules-tool': ("Modules tool to use", 'choice', 'store',
                             DEFAULT_MODULES_TOOL,
                             sorted(avail_modules_tools().keys())),
            'prefix':
            (("Change prefix for buildpath, installpath, sourcepath and repositorypath "
              "(used prefix for defaults %s)" % DEFAULT_PREFIX), None, 'store',
             None),
            'recursive-module-unload':
            ("Enable generating of modules that unload recursively.", None,
             'store_true', False),
            'repository': ("Repository type, using repositorypath", 'choice',
                           'store', DEFAULT_REPOSITORY,
                           sorted(avail_repositories().keys())),
            'repositorypath':
            (("Repository path, used by repository "
              "(is passed as list of arguments to create the repository instance). "
              "For more info, use --avail-repositories."), 'strlist', 'store',
             [mk_full_default_path('repositorypath')]),
            'show-default-moduleclasses':
            ("Show default module classes with description", None,
             'store_true', False),
            'sourcepath':
            ("Path(s) to where sources should be downloaded (string, colon-separated)",
             None, 'store', mk_full_default_path('sourcepath')),
            'subdir-modules': ("Installpath subdir for modules", None, 'store',
                               DEFAULT_PATH_SUBDIRS['subdir_modules']),
            'subdir-software': ("Installpath subdir for software", None,
                                'store',
                                DEFAULT_PATH_SUBDIRS['subdir_software']),
            'suffix-modules-path': ("Suffix for module files install path",
                                    None, 'store', GENERAL_CLASS),
            # this one is sort of an exception, it's something jobscripts can set,
            # has no real meaning for regular eb usage
            'testoutput':
            ("Path to where a job should place the output (to be set within jobscript)",
             None, 'store', None),
            'tmp-logdir':
            ("Log directory where temporary log files are stored", None,
             'store', None),
            'tmpdir': ('Directory to use for temporary storage', None, 'store',
                       None),
        })

        self.log.debug("config_options: descr %s opts %s" % (descr, opts))
        self.add_group_parser(opts, descr)
    def config_options(self):
        # config options
        descr = ("Configuration options", "Configure EasyBuild behavior.")

        opts = OrderedDict({
            'avail-module-naming-schemes': ("Show all supported module naming schemes",
                                            None, 'store_true', False,),
            'avail-modules-tools': ("Show all supported module tools",
                                    None, "store_true", False,),
            'avail-repositories': ("Show all repository types (incl. non-usable)",
                                   None, "store_true", False,),
            'buildpath': ("Temporary build path", None, 'store', mk_full_default_path('buildpath')),
            'external-modules-metadata': ("List of files specifying metadata for external modules (INI format)",
                                          'strlist', 'store', []),
            'ignore-dirs': ("Directory names to ignore when searching for files/dirs",
                            'strlist', 'store', ['.git', '.svn']),
            'include-easyblocks': ("Location(s) of extra or customized easyblocks", 'strlist', 'store', []),
            'include-module-naming-schemes': ("Location(s) of extra or customized module naming schemes",
                                              'strlist', 'store', []),
            'include-toolchains': ("Location(s) of extra or customized toolchains or toolchain components",
                                   'strlist', 'store', []),
            'installpath': ("Install path for software and modules",
                            None, 'store', mk_full_default_path('installpath')),
            'installpath-modules': ("Install path for modules (if None, combine --installpath and --subdir-modules)",
                                    None, 'store', None),
            'installpath-software': ("Install path for software (if None, combine --installpath and --subdir-software)",
                                     None, 'store', None),
            'job-backend': ("Backend to use for submitting jobs", 'choice', 'store',
                            DEFAULT_JOB_BACKEND, sorted(avail_job_backends().keys())),
            # purposely take a copy for the default logfile format
            'logfile-format': ("Directory name and format of the log file",
                               'strtuple', 'store', DEFAULT_LOGFILE_FORMAT[:], {'metavar': 'DIR,FORMAT'}),
            'module-naming-scheme': ("Module naming scheme",
                                     'choice', 'store', DEFAULT_MNS, sorted(avail_module_naming_schemes().keys())),
            'module-syntax': ("Syntax to be used for module files", 'choice', 'store', DEFAULT_MODULE_SYNTAX,
                              sorted(avail_module_generators().keys())),
            'moduleclasses': (("Extend supported module classes "
                               "(For more info on the default classes, use --show-default-moduleclasses)"),
                              None, 'extend', [x[0] for x in DEFAULT_MODULECLASSES]),
            'modules-footer': ("Path to file containing footer to be added to all generated module files",
                               None, 'store_or_None', None, {'metavar': "PATH"}),
            'modules-tool': ("Modules tool to use",
                             'choice', 'store', DEFAULT_MODULES_TOOL, sorted(avail_modules_tools().keys())),
            'packagepath': ("The destination path for the packages built by package-tool",
                             None, 'store', mk_full_default_path('packagepath')),
            'package-naming-scheme': ("Packaging naming scheme choice", 
                                      'choice', 'store', DEFAULT_PNS, sorted(avail_package_naming_schemes().keys())),
            'prefix': (("Change prefix for buildpath, installpath, sourcepath and repositorypath "
                        "(used prefix for defaults %s)" % DEFAULT_PREFIX),
                       None, 'store', None),
            'recursive-module-unload': ("Enable generating of modules that unload recursively.",
                                        None, 'store_true', False),
            'repository': ("Repository type, using repositorypath",
                           'choice', 'store', DEFAULT_REPOSITORY, sorted(avail_repositories().keys())),
            'repositorypath': (("Repository path, used by repository "
                                "(is passed as list of arguments to create the repository instance). "
                                "For more info, use --avail-repositories."),
                               'strlist', 'store', self.default_repositorypath),
            'sourcepath': ("Path(s) to where sources should be downloaded (string, colon-separated)",
                           None, 'store', mk_full_default_path('sourcepath')),
            'subdir-modules': ("Installpath subdir for modules", None, 'store', DEFAULT_PATH_SUBDIRS['subdir_modules']),
            'subdir-software': ("Installpath subdir for software",
                                None, 'store', DEFAULT_PATH_SUBDIRS['subdir_software']),
            'suffix-modules-path': ("Suffix for module files install path", None, 'store', GENERAL_CLASS),
            # this one is sort of an exception, it's something jobscripts can set,
            # has no real meaning for regular eb usage
            'testoutput': ("Path to where a job should place the output (to be set within jobscript)",
                           None, 'store', None),
            'tmp-logdir': ("Log directory where temporary log files are stored", None, 'store', None),
            'tmpdir': ('Directory to use for temporary storage', None, 'store', None),
        })

        self.log.debug("config_options: descr %s opts %s" % (descr, opts))
        self.add_group_parser(opts, descr)