def live_build_finished(arch, full_name, machine, status, text_status,
lp_build=None):
timestamp = time.strftime("%F %T")
logger.info("%s on %s finished at %s (%s)" % (
full_name, machine, timestamp, text_status))
tracker_set_rebuild_status(config, [0, 1, 2], 3, arch)
if status == 0:
successful.add(arch)
if arch == "amd64" and "amd64+mac" in config.arches:
successful.add("amd64+mac")
else:
live_build_notify_failure(config, arch, lp_build=lp_build)
def build_image_set_locked(config, options, multipidfile_state):
image_type = config.image_type
config["CDIMAGE_DATE"] = date = next_build_id(config, image_type)
log_path = None
try:
configure_for_project(config)
log_path = open_log(config)
if want_live_builds(options):
log_marker("Building live filesystems")
live_successful = run_live_builds(config)
config.limit_arches(live_successful)
else:
tracker_set_rebuild_status(config, [0, 1], 2)
if not is_live_fs_only(config):
sync_local_mirror(config, multipidfile_state)
if config["LOCAL"]:
log_marker("Updating archive of local packages")
update_local_indices(config)
build_britney(config)
log_marker("Extracting debootstrap scripts")
extract_debootstrap(config)
if config["UBUNTU_DEFAULTS_LOCALE"]:
build_ubuntu_defaults_locale(config)
elif is_live_fs_only(config):
build_livecd_base(config)
else:
if not config["CDIMAGE_PREINSTALLED"]:
log_marker("Germinating")
germination = Germination(config)
germination.run()
log_marker("Generating new task lists")
germinate_output = germination.output(config.project)
germinate_output.write_tasks()
log_marker("Checking for other task changes")
germinate_output.update_tasks(date)
if (config["CDIMAGE_LIVE"] or config["CDIMAGE_SQUASHFS_BASE"] or
config["CDIMAGE_PREINSTALLED"]):
log_marker("Downloading live filesystem images")
download_live_filesystems(config)
configure_splash(config)
run_debian_cd(config)
fix_permissions(config)
# Temporarily turned off for live builds.
if (config["CDIMAGE_INSTALL_BASE"] and
not config["CDIMAGE_ADDON"] and
not config["CDIMAGE_PREINSTALLED"]):
log_marker("Producing installability report")
check_installable(config)
if not config["DEBUG"] and not config["CDIMAGE_NOPUBLISH"]:
log_marker("Publishing")
tree = Tree.get_daily(config)
publisher = Publisher.get_daily(tree, image_type)
publisher.publish(date)
log_marker("Purging old images")
publisher.purge()
log_marker("Triggering mirrors")
trigger_mirrors(config)
log_marker("Finished")
return True
except Exception as e:
for line in traceback.format_exc().splitlines():
logger.error(line)
sys.stdout.flush()
sys.stderr.flush()
if not isinstance(e, LiveBuildsFailed):
notify_failure(config, log_path)
return False
def run_live_builds(config):
builds = {}
lp_builds = []
for arch in config.arches:
if arch == "amd64+mac":
# Use normal amd64 live image on amd64+mac.
continue
full_name = live_build_full_name(config, arch)
timestamp = time.strftime("%F %T")
lp, lp_livefs = get_lp_livefs(config, arch)
if lp_livefs is None:
machine = live_builder(config, arch)
else:
machine = "Launchpad"
logger.info(
"%s on %s starting at %s" % (full_name, machine, timestamp))
tracker_set_rebuild_status(config, [0, 1], 2, arch)
if lp_livefs is not None:
lp_kwargs = live_build_lp_kwargs(config, lp, lp_livefs, arch)
lp_build = lp_livefs.requestBuild(**lp_kwargs)
logger.info("%s: %s" % (full_name, lp_build.web_link))
lp_builds.append((lp_build, arch, full_name, machine, None))
else:
proc = subprocess.Popen(live_build_command(config, arch))
builds[proc.pid] = (proc, arch, full_name, machine)
successful = set()
def live_build_finished(arch, full_name, machine, status, text_status,
lp_build=None):
timestamp = time.strftime("%F %T")
logger.info("%s on %s finished at %s (%s)" % (
full_name, machine, timestamp, text_status))
tracker_set_rebuild_status(config, [0, 1, 2], 3, arch)
if status == 0:
successful.add(arch)
if arch == "amd64" and "amd64+mac" in config.arches:
successful.add("amd64+mac")
else:
live_build_notify_failure(config, arch, lp_build=lp_build)
while builds or lp_builds:
# Check for non-Launchpad build results.
if builds:
pid, status = os.waitpid(0, os.WNOHANG)
if pid and pid in builds:
_, arch, full_name, machine = builds.pop(pid)
live_build_finished(
arch, full_name, machine, status,
"success" if status == 0 else "failed")
# Check for Launchpad build results.
pending_lp_builds = []
for lp_item in lp_builds:
lp_build, arch, full_name, machine, log_timeout = lp_item
lp_build.lp_refresh()
if lp_build.buildstate in (
"Needs building", "Currently building", "Uploading build"):
pending_lp_builds.append(lp_item)
elif lp_build.buildstate == "Successfully built":
live_build_finished(
arch, full_name, machine, 0, lp_build.buildstate,
lp_build=lp_build)
elif (lp_build.build_log_url is None and
(log_timeout is None or time.time() < log_timeout)):
# Wait up to five minutes for Launchpad to fetch the build
# log from the slave. We need a timeout since in rare cases
# this might fail.
if log_timeout is None:
log_timeout = time.time() + 300
pending_lp_builds.append(
(lp_build, arch, full_name, machine, log_timeout))
else:
live_build_finished(
arch, full_name, machine, 1, lp_build.buildstate,
lp_build=lp_build)
lp_builds = pending_lp_builds
if lp_builds:
# Wait a while before polling Launchpad again. If a
# non-Launchpad build completes in the meantime, it will
# interrupt this sleep with SIGCHLD.
time.sleep(15)
if not successful:
raise LiveBuildsFailed("No live filesystem builds succeeded.")
return successful