def run(self, args):
platform = common.get_current_platform()
common.establish_build_id(
args.build_id) # sets id (even if not specified),
# and stores in the AUTOBUILD_BUILD_ID environment variable
config = configfile.ConfigurationDescription(args.config_file)
package_errors = configfile.check_package_attributes(config)
if package_errors:
raise ConfigurationError("%s\n in configuration %s" \
% (package_errors, args.config_file))
current_directory = os.getcwd()
try:
build_configurations = common.select_configurations(
args, config, "configuring for")
if not build_configurations:
logger.error(
"no applicable configurations found.\n"
"did you remember to mark a configuration as default?\n"
"autobuild cowardly refuses to do nothing!")
for build_configuration in build_configurations:
# Get enriched environment based on the current configuration
environment = get_enriched_environment(
build_configuration.name)
# then get a copy of the config specific to this build
# configuration
bconfig = config.copy()
# and expand its $variables according to the environment.
bconfig.expand_platform_vars(environment)
# Re-fetch the build configuration so we have its expansions.
build_configuration = bconfig.get_build_configuration(
build_configuration.name, platform_name=platform)
build_directory = bconfig.make_build_directory(
build_configuration,
platform=platform,
dry_run=args.dry_run)
if not args.dry_run:
logger.debug("configuring in %s" % build_directory)
os.chdir(build_directory)
else:
logger.info("configuring in %s" % build_directory)
result = _configure_a_configuration(bconfig,
build_configuration,
args.additional_options,
args.dry_run,
environment=environment)
if result != 0:
raise ConfigurationError(
"default configuration returned %d" % result)
finally:
os.chdir(current_directory)
def run(self, args):
platform = common.get_current_platform()
logger.debug("uninstalling for platform " + platform)
installed_filename = args.installed_filename
if os.path.isabs(installed_filename):
installed_filenames = [installed_filename]
else:
# This logic handles the (usual) case when installed_filename is
# relative to install_dir. Therefore we must figure out install_dir.
# write packages into 'packages' subdir of build directory by default
config = configfile.ConfigurationDescription(args.install_filename)
# establish a build directory so that the install directory is relative to it
build_configurations = common.select_configurations(
args, config, "uninstalling for")
if not build_configurations:
logger.error(
"no applicable configurations found.\n"
"did you remember to mark a configuration as default?\n"
"autobuild cowardly refuses to do nothing!")
for build_configuration in build_configurations:
# Get enriched environment based on the current configuration
environment = get_enriched_environment(
build_configuration.name)
# then get a copy of the config specific to this build
# configuration
bconfig = config.copy()
# and expand its $variables according to the environment.
bconfig.expand_platform_vars(environment)
# Re-fetch the build configuration so we have its expansions.
build_configuration = bconfig.get_build_configuration(
build_configuration.name, platform_name=platform)
build_directory = bconfig.get_build_directory(
build_configuration, platform_name=platform)
logger.debug("build directory: %s" % build_directory)
installed_filenames = \
[os.path.realpath(os.path.join(install_dir, installed_filename))
for install_dir in
common.select_directories(args, config,
"install", "uninstalling",
lambda cnf:
os.path.join(build_directory,
"packages"))]
logger.debug("installed filenames: %s" % installed_filenames)
for installed_filename in installed_filenames:
uninstall_packages(args, installed_filename, args.package,
args.dry_run)
def run(self, args):
UTF8Writer = codecs.getwriter('utf8')
sys.stdout = UTF8Writer(sys.stdout)
platform = common.get_current_platform()
logger.debug("installing platform " + platform)
# load the list of packages to install
logger.debug("loading " + args.install_filename)
config = configfile.ConfigurationDescription(args.install_filename)
# establish a build directory so that the install directory is relative to it
build_configurations = common.select_configurations(
args, config, "installing for")
if not build_configurations:
logger.error(
"no applicable configurations found.\n"
"did you remember to mark a configuration as default?\n"
"autobuild cowardly refuses to do nothing!")
for build_configuration in build_configurations:
# Get enriched environment based on the current configuration
environment = get_enriched_environment(build_configuration.name)
# then get a copy of the config specific to this build
# configuration
bconfig = config.copy()
# and expand its $variables according to the environment.
bconfig.expand_platform_vars(environment)
# Re-fetch the build configuration so we have its expansions.
build_configuration = bconfig.get_build_configuration(
build_configuration.name, platform_name=platform)
build_directory = bconfig.get_build_directory(
build_configuration, platform_name=platform)
# write packages into 'packages' subdir of build directory
install_dirs = \
common.select_directories(args, bconfig,
"install", "installing packages for",
lambda cnf:
os.path.join(bconfig.make_build_directory(cnf, platform=platform, dry_run=args.dry_run),
"packages"))
# get the absolute paths to the install dir and installed-packages.xml file
for install_dir in install_dirs:
install_dir = os.path.realpath(install_dir)
install_packages(args, bconfig, install_dir, platform,
args.package)
def run(self, args):
platform = common.get_current_platform()
build_id = common.establish_build_id(
args.build_id) # sets id (even if not specified),
# and stores in the AUTOBUILD_BUILD_ID environment variable
config = configfile.ConfigurationDescription(args.config_file)
package_errors = \
configfile.check_package_attributes(config,
additional_requirements=['version_file'])
if package_errors:
# Now that we've deprecated hard-coded version and started
# requiring version_file instead, provide an explanation when it's
# missing, instead of confounding a longtime autobuild user with
# failure to meet a brand-new requirement.
# Recall that package_errors isa str that also has an attrs
# attribute. Only emit the verbose message if version_file is
# actually one of the problematic attributes, and the config file
# had to be converted from an earlier file format, and the
# original file format version predates version_file.
# (missing orig_ver attribute means a current autobuild.xml, which
# is why we pass get() a default value that bypasses verbose)
# (version_file was introduced at AUTOBUILD_CONFIG_VERSION 1.3)
if "version_file" in package_errors.attrs \
and common.get_version_tuple(config.get("orig_ver", "1.3")) < (1, 3):
verbose = """
New requirement: instead of stating a particular version number in the %(xml)s
file, we now require you to configure a version_file attribute. This should be
the path (relative to the build_directory) of a small text file containing
only the package version string. Freezing the version number into %(xml)s
means we often forget to update it there. Reading the version number from a
separate text file allows your build script to create that file from data
available in the package. version_file need not be in the manifest; it's used
only by 'autobuild build' to create package metadata.
""" % dict(xml=configfile.AUTOBUILD_CONFIG_FILE)
else:
verbose = ""
# Now, regardless of the value of 'verbose', show the message.
raise BuildError(''.join(
(package_errors, "\n in configuration ", args.config_file,
verbose)))
current_directory = os.getcwd()
if args.clean_only:
logger.info("building with --clean-only required")
try:
configure_first = not args.do_not_configure
build_configurations = common.select_configurations(
args, config, "building for")
if not build_configurations:
logger.error(
"no applicable configurations found.\n"
"did you remember to mark a configuration as default?\n"
"autobuild cowardly refuses to do nothing!")
for build_configuration in build_configurations:
# Get enriched environment based on the current configuration
environment = get_enriched_environment(
build_configuration.name)
# then get a copy of the config specific to this build
# configuration
bconfig = config.copy()
# and expand its $variables according to the environment.
bconfig.expand_platform_vars(environment)
# Re-fetch the build configuration so we have its expansions.
build_configuration = bconfig.get_build_configuration(
build_configuration.name, platform_name=platform)
build_directory = bconfig.make_build_directory(
build_configuration,
platform=platform,
dry_run=args.dry_run)
if not args.dry_run:
logger.debug("building in %s" % build_directory)
os.chdir(build_directory)
else:
logger.info("building in %s" % build_directory)
if configure_first:
result = _configure_a_configuration(
bconfig,
build_configuration,
args.build_extra_arguments,
args.dry_run,
environment=environment)
if result != 0:
raise BuildError(
"configuring default configuration returned %d" %
result)
result = _build_a_configuration(
bconfig,
build_configuration,
platform_name=platform,
extra_arguments=args.build_extra_arguments,
dry_run=args.dry_run,
environment=environment)
# always make clean copy of the build metadata regardless of result
metadata_file_name = configfile.PACKAGE_METADATA_FILE
logger.debug("metadata file name: %s" % metadata_file_name)
if os.path.exists(metadata_file_name):
if not args.dry_run:
os.unlink(metadata_file_name)
else:
logger.info("would have replaced %s" %
metadata_file_name)
if result != 0:
raise BuildError("building configuration %s returned %d" %
(build_configuration, result))
# Create the metadata record for inclusion in the package
metadata_file = configfile.MetadataDescription(
path=metadata_file_name, create_quietly=True)
# COPY the package description from the configuration: we're
# going to convert it to metadata format.
metadata_file.package_description = \
configfile.PackageDescription(bconfig.package_description)
# A metadata package_description has a version attribute
# instead of a version_file attribute.
metadata_file.package_description.version = \
metadata_file.package_description.read_version_file(build_directory)
del metadata_file.package_description["version_file"]
logger.info("built %s version %s" %
(metadata_file.package_description.name,
metadata_file.package_description.version))
metadata_file.package_description.platforms = None # omit data on platform configurations
metadata_file.platform = platform
metadata_file.configuration = build_configuration.name
metadata_file.build_id = build_id
# get the record of any installed packages
logger.debug("installed files in " + args.installed_filename)
# SL-773: This if/else partly replicates
# common.select_directories() because our build_directory
# comes from bconfig, which has been $-expanded.
# The former select_directories() call produced (e.g.)
# build-vc120-$AUTOBUILD_ADDRSIZE, which didn't exist.
if args.select_dir:
install_dir = args.select_dir
logger.debug(
"specified metadata directory: {}".format(install_dir))
else:
# packages were written into 'packages' subdir of build directory by default
install_dir = os.path.join(build_directory, "packages")
logger.debug("metadata in build subdirectory: {}".format(
install_dir))
# load the list of already installed packages
installed_pathname = os.path.realpath(
os.path.join(install_dir, args.installed_filename))
if os.path.exists(installed_pathname):
metadata_file.add_dependencies(installed_pathname)
else:
logger.debug("no installed files found (%s)" %
installed_pathname)
if args.clean_only and metadata_file.dirty:
raise BuildError(
"Build depends on local or legacy installables\n" +
" use 'autobuild install --list-dirty' to see problem packages\n"
+
" rerun without --clean-only to allow building anyway"
)
if not args.dry_run:
metadata_file.save()
finally:
os.chdir(current_directory)