def name_parsed_correctly(pkg, name):
"""Determine if the name of a package was correctly parsed.
Args:
pkg (spack.package.PackageBase): The Spack package
name (str): The name that was extracted from the URL
Returns:
bool: True if the name was correctly parsed, else False
"""
pkg_name = pkg.name
name = simplify_name(name)
# After determining a name, `spack create` determines a build system.
# Some build systems prepend a special string to the front of the name.
# Since this can't be guessed from the URL, it would be unfair to say
# that these names are incorrectly parsed, so we remove them.
if pkg_name.startswith('r-'):
pkg_name = pkg_name[2:]
elif pkg_name.startswith('py-'):
pkg_name = pkg_name[3:]
elif pkg_name.startswith('perl-'):
pkg_name = pkg_name[5:]
elif pkg_name.startswith('octave-'):
pkg_name = pkg_name[7:]
return name == pkg_name
def name_parsed_correctly(pkg, name):
"""Determine if the name of a package was correctly parsed.
Args:
pkg (spack.package.PackageBase): The Spack package
name (str): The name that was extracted from the URL
Returns:
bool: True if the name was correctly parsed, else False
"""
pkg_name = pkg.name
name = simplify_name(name)
# After determining a name, `spack create` determines a build system.
# Some build systems prepend a special string to the front of the name.
# Since this can't be guessed from the URL, it would be unfair to say
# that these names are incorrectly parsed, so we remove them.
if pkg_name.startswith('r-'):
pkg_name = pkg_name[2:]
elif pkg_name.startswith('py-'):
pkg_name = pkg_name[3:]
elif pkg_name.startswith('octave-'):
pkg_name = pkg_name[7:]
return name == pkg_name
def name_parsed_correctly(pkg, name):
"""Determine if the name of a package was correctly parsed.
Args:
pkg (spack.package.PackageBase): The Spack package
name (str): The name that was extracted from the URL
Returns:
bool: True if the name was correctly parsed, else False
"""
pkg_name = remove_prefix(pkg.name)
name = simplify_name(name)
return name == pkg_name
def get_name(args):
"""Get the name of the package based on the supplied arguments.
If a name was provided, always use that. Otherwise, if a URL was
provided, extract the name from that. Otherwise, use a default.
Args:
args (param argparse.Namespace): The arguments given to
``spack create``
Returns:
str: The name of the package
"""
# Default package name
name = 'example'
if args.name is not None:
# Use a user-supplied name if one is present
name = args.name
if len(args.name.strip()) > 0:
tty.msg("Using specified package name: '{0}'".format(name))
else:
tty.die("A package name must be provided when using the option.")
elif args.url is not None:
# Try to guess the package name based on the URL
try:
name = parse_name(args.url)
if name != args.url:
desc = 'URL'
else:
desc = 'package name'
tty.msg("This looks like a {0} for {1}".format(desc, name))
except UndetectableNameError:
tty.die("Couldn't guess a name for this package.",
" Please report this bug. In the meantime, try running:",
" `spack create --name <name> <url>`")
name = simplify_name(name)
if not valid_fully_qualified_module_name(name):
tty.die("Package name can only contain a-z, 0-9, and '-'")
return name
def get_name(args):
"""Get the name of the package based on the supplied arguments.
If a name was provided, always use that. Otherwise, if a URL was
provided, extract the name from that. Otherwise, use a default.
Args:
args (param argparse.Namespace): The arguments given to
``spack create``
Returns:
str: The name of the package
"""
# Default package name
name = 'example'
if args.name:
# Use a user-supplied name if one is present
name = args.name
tty.msg("Using specified package name: '{0}'".format(name))
elif args.url:
# Try to guess the package name based on the URL
try:
name = parse_name(args.url)
tty.msg("This looks like a URL for {0}".format(name))
except UndetectableNameError:
tty.die("Couldn't guess a name for this package.",
" Please report this bug. In the meantime, try running:",
" `spack create --name <name> <url>`")
name = simplify_name(name)
if not valid_fully_qualified_module_name(name):
tty.die("Package name can only contain a-z, 0-9, and '-'")
return name
def configure_pipeline(parser, args):
# Parse all of our inputs before trying to modify any recipes.
modifications = {}
packages_to_ignore = set(args.ignore_packages)
mod_pattern = re.compile("^([^=]+)_(BRANCH|COMMIT|TAG)=(.*)$",
re.IGNORECASE)
for mod_str in args.modifications:
match = mod_pattern.match(mod_str)
if not match:
raise Exception("Could not parse: {}".format(mod_str))
package_name = match.group(1)
ref_type = match.group(2).lower()
val = match.group(3)
# Handle --ignore-packges arguments
if package_name in packages_to_ignore:
tty.info("{}: ignoring {}".format(package_name, mod_str))
continue
# Try and transform the input name, which is probably all upper case
# and may contain underscores, into a Spack-style name that is all
# lower case and contains hyphens.
spack_package_name = simplify_name(package_name)
# Check if this package exists
try:
spack.repo.get(spack_package_name)
except spack.repo.UnknownPackageError:
raise Exception(
"Could not find a Spack package corresponding to {}, tried {}".
format(package_name, spack_package_name))
if spack_package_name in modifications:
raise Exception(
"Parsed multiple modifications for Spack package {} from: {}".
format(spack_package_name, " ".join(args.modifications)))
modifications[spack_package_name] = {
"bash_name": package_name,
"ref_type": ref_type,
"ref": val,
}
# Translate any branches or tags into commit hashes and then use those
# consistently. This guarantees different jobs in a pipeline all get the
# same commit, and means we can handle provenance information (what did
# @develop mean) in one place.
git = which("git")
if not git:
raise Exception("Git is required")
for spack_package_name, info in modifications.items():
if info["ref_type"] == "commit":
info["commit"] = info["ref"]
else:
if info["ref_type"] == "branch":
remote_ref = "refs/heads/" + info["ref"]
else:
assert info["ref_type"] == "tag"
remote_ref = "refs/tags/" + info["ref"]
spack_package = spack.repo.get(spack_package_name)
remote_refs = git("ls-remote",
spack_package.git,
remote_ref,
output=str).splitlines()
assert len(remote_refs) < 2
if len(remote_refs) == 0:
raise Exception(
"Could not find {} {} on remote {} (tried {})".format(
info["ref_type"], info["ref"], spack_package.git,
remote_ref))
commit, ref_check = remote_refs[0].split()
assert remote_ref == ref_check
tty.info("{}: resolved {} {} to {}".format(spack_package_name,
info["ref_type"],
info["ref"], commit))
info["commit"] = commit
if args.write_commit_file is not None:
with open(args.write_commit_file, "w") as ofile:
for spack_package_name, info in modifications.items():
ofile.write("{}_COMMIT={}\n".format(info["bash_name"],
info["commit"]))
# Now modify the Spack recipes of the given packages
for spack_package_name, info in modifications.items():
spack_package = spack.repo.get(spack_package_name)
spack_recipe = os.path.join(spack_package.package_dir,
spack.repo.package_file_name)
# Using filter_file seems neater than calling sed, but it is a little
# more limited. First, remove any existing branch/commit/tag from the
# develop version.
tty.info(
"{}@develop: remove branch/commit/tag".format(spack_package_name))
filter_file(
"version\\s*\\(\\s*(['\"]{1})develop\\1(.*?)" +
",\\s*(branch|commit|tag)=(['\"]{1})(.*?)\\4(.*?)\\)",
"version('develop'\\2\\6) # old: \\3=\\4\\5\\4",
spack_recipe,
)
# Second, insert the new commit="sha" part
tty.info('{}@develop: use commit="{}"'.format(spack_package_name,
info["commit"]))
filter_file(
"version\\('develop'",
"version('develop', commit='{}'".format(info["commit"]),
spack_recipe,
)
# Third, make sure that the develop version, and only the develop
# version, is flagged as the preferred version. Start by getting a list
# of versions that are already explicitly flagged as preferred.
already_preferred = {
str(v)
for v, v_info in spack_package.versions.items()
if v_info.get("preferred", False)
}
# Make sure the develop version has an explicit preferred=True.
if "develop" not in already_preferred:
tty.info(
"{}@develop: add preferred=True".format(spack_package_name))
filter_file("version\\('develop'",
"version('develop', preferred=True", spack_recipe)
# Make sure no other versions have an explicit preferred=True.
for other_version in already_preferred - {"develop"}:
tty.info("{}@{}: remove preferred=True".format(
spack_package_name, other_version))
escaped_version = re.escape(other_version)
filter_file(
"version\\s*\\(\\s*(['\"]{1})" + escaped_version +
"\\1(.*?),\\s*preferred=True(.*?)\\)",
"version('{version}'\\2\\3)".format(version=other_version),
spack_recipe,
)
