X-Git-Url: https://scripts.mit.edu/gitweb/wizard.git/blobdiff_plain/48af129368493c5458c942aef025ed746b97b856..8939cb421d77e7469160f38381cf2106974e5ba8:/wizard/command/upgrade.py diff --git a/wizard/command/upgrade.py b/wizard/command/upgrade.py index f56d00b..8f25920 100644 --- a/wizard/command/upgrade.py +++ b/wizard/command/upgrade.py @@ -21,136 +21,137 @@ def main(argv, baton): shell.drop_priviledges(dir, options.log_file) util.chdir(dir) if os.path.exists(".scripts/blacklisted"): - raise BlacklistedError() + reason = open(".scripts/blacklisted").read() + print "-1 " + reason + raise BlacklistedError(reason) sh = shell.Shell() util.set_git_env() use_shm = False # if you are running --continue, this is guaranteed to be False - if options.continue_: - temp_wc_dir = os.getcwd() - user_commit, next_commit = open(".git/WIZARD_PARENTS", "r").read().split() - repo = open(".git/WIZARD_REPO", "r").read() - version = open(".git/WIZARD_UPGRADE_VERSION", "r").read() - if not options.log_file and os.path.exists(".git/WIZARD_LOG_FILE"): - options.log_file = open(".git/WIZARD_LOG_FILE", "r").read() - # reload logging - command.addFileLogger(options.log_file, options.debug) - logging.info("Continuing upgrade...") - util.chdir(sh.eval("git", "config", "remote.origin.url")) - d = deploy.Deployment(".") - try: - sh.call("git", "status") - raise LocalChangesError() - except shell.CallError: - pass - else: - d = deploy.Deployment(".") - d.verify() - d.verifyTag(options.srv_path) - d.verifyGit(options.srv_path) - d.verifyConfigured() - d.verifyVersion() - if not options.dry_run: - d.verifyWeb() - repo = d.application.repository(options.srv_path) - version = calculate_newest_version(sh, repo) - if version == d.app_version.scripts_tag and not options.force: - # don't log this error - # XXX: maybe we should build this in as a flag to add - # to exceptions w/ our exception handler - sys.stderr.write("Traceback:\n (n/a)\nAlreadyUpgraded\n") - sys.exit(1) - logging.info("Upgrading %s" % os.getcwd()) - kib_usage, kib_limit = scripts.get_quota_usage_and_limit() - if kib_limit is not None and (kib_limit - kib_usage) < kib_buffer: # 10 mebibytes - raise QuotaTooLow - if not options.dry_run: - perform_pre_commit(sh) - # If /dev/shm exists, it's a tmpfs and we can use it - # to do a fast git merge. Don't forget to move it to - # /tmp if it fails. - # XXX: git merge-tree is another possibility for - # reducing filesystem interactions, and also probably - # works better with extra merging functionality. However, - # I don't know how I would put the results back in the - # working tree. - use_shm = os.path.exists("/dev/shm") - temp_dir, temp_wc_dir = perform_tmp_clone(sh, use_shm) - with util.ChangeDirectory(temp_wc_dir): - sh.call("git", "remote", "add", "scripts", repo) - sh.call("git", "fetch", "-q", "scripts") - user_commit, next_commit = calculate_parents(sh, version) - # save variables so that --continue will work - # yeah yeah no trailing newline whatever - open(".git/WIZARD_REPO", "w").write(repo) - open(".git/WIZARD_UPGRADE_VERSION", "w").write(version) - open(".git/WIZARD_PARENTS", "w").write("%s\n%s" % (user_commit, next_commit)) - open(".git/WIZARD_SIZE", "w").write(str(scripts.get_disk_usage())) - if options.log_file: - open(".git/WIZARD_LOG_FILE", "w").write(options.log_file) - perform_merge(sh, repo, d, version, use_shm, kib_limit and kib_limit - kib_usage or None) - # variables: version, user_commit, next_commit, temp_wc_dir - with util.ChangeDirectory(temp_wc_dir): - try: - sh.call("git", "status") - sh.call("git", "commit", "-m", "throw-away commit") - except shell.CallError: - pass - message = make_commit_message(version) - new_tree = sh.eval("git", "rev-parse", "HEAD^{tree}") - final_commit = sh.eval("git", "commit-tree", new_tree, - "-p", user_commit, "-p", next_commit, input=message, log=True) - # a master branch may not necessarily exist if the user - # was manually installed to an earlier version - try: - sh.call("git", "checkout", "-q", "-b", "master", "--") - except shell.CallError: - sh.call("git", "checkout", "-q", "master", "--") - sh.call("git", "reset", "-q", "--hard", final_commit) - # This is a quick sanity check to make sure we didn't completely - # mess up the merge - d.verifyVersion() - # Till now, all of our operations were in a tmp sandbox. - if options.dry_run: - logging.info("Dry run, bailing. See results at %s" % temp_wc_dir) - return - # Ok, now we have to do a crazy complicated dance to see if we're - # going to have enough quota to finish what we need - pre_size = int(open(os.path.join(temp_wc_dir, ".git/WIZARD_SIZE"), "r").read()) - post_size = scripts.get_disk_usage(temp_wc_dir) - kib_usage, kib_limit = scripts.get_quota_usage_and_limit() - backup = d.backup(options) - if kib_limit is not None and (kib_limit - kib_usage) - (post_size - pre_size) / 1024 < kib_buffer: - shutil.rmtree(os.path.join(".scripts/backups", sh.eval("wizard", "restore").splitlines()[0])) - raise QuotaTooLow - # XXX: frob .htaccess to make site inaccessible - with util.IgnoreKeyboardInterrupts(): - with util.LockDirectory(".scripts-upgrade-lock"): - # git merge (which performs a fast forward) - sh.call("git", "pull", "-q", temp_wc_dir, "master") - # after the pull is successful, the directory now - # has the objects for this commit, so we can safely - # nuke the shm directory. We refrain from nuking the - # tmp directory in case we messed up the merge resolution - # and want to be able to use it again. - if use_shm: - shutil.rmtree(temp_dir) - version_obj = distutils.version.LooseVersion(version.partition('-')[2]) + temp_dir = None + try: + if options.continue_: + temp_wc_dir = os.getcwd() + user_commit, next_commit = open(".git/WIZARD_PARENTS", "r").read().split() + repo = open(".git/WIZARD_REPO", "r").read() + version = open(".git/WIZARD_UPGRADE_VERSION", "r").read() + if not options.log_file and os.path.exists(".git/WIZARD_LOG_FILE"): + options.log_file = open(".git/WIZARD_LOG_FILE", "r").read() + # reload logging + command.addFileLogger(options.log_file, options.debug) + logging.info("Continuing upgrade...") + util.chdir(sh.eval("git", "config", "remote.origin.url")) + d = deploy.Deployment(".") try: - # run update script - d.upgrade(version_obj, options) + sh.call("git", "status") + raise LocalChangesError() + except shell.CallError: + pass + else: + d = deploy.Deployment(".") + d.verify() + d.verifyTag(options.srv_path) + d.verifyGit(options.srv_path) + d.verifyConfigured() + d.verifyVersion() + if not options.dry_run: d.verifyWeb() - except app.UpgradeFailure: - logging.warning("Upgrade failed: rolling back") - perform_restore(d, backup) - raise - except deploy.WebVerificationError as e: - logging.warning("Web verification failed: rolling back") - perform_restore(d, backup) - raise app.UpgradeVerificationFailure(e.contents) - # XXX: frob .htaccess to make site accessible - # to do this, check if .htaccess changed, first. Upgrade - # process might have frobbed it. Don't be - # particularly worried if the segment disappeared + repo = d.application.repository(options.srv_path) + version = calculate_newest_version(sh, repo) + if version == d.app_version.scripts_tag and not options.force: + # don't log this error + # XXX: maybe we should build this in as a flag to add + # to exceptions w/ our exception handler + sys.stderr.write("Traceback:\n (n/a)\nAlreadyUpgraded\n") + sys.exit(1) + logging.info("Upgrading %s" % os.getcwd()) + kib_usage, kib_limit = scripts.get_quota_usage_and_limit() + if kib_limit is not None and (kib_limit - kib_usage) < kib_buffer: # 10 mebibytes + raise QuotaTooLow + if not options.dry_run: + perform_pre_commit(sh) + # If /dev/shm exists, it's a tmpfs and we can use it + # to do a fast git merge. Don't forget to move it to + # /tmp if it fails. + # XXX: git merge-tree is another possibility for + # reducing filesystem interactions, and also probably + # works better with extra merging functionality. However, + # I don't know how I would put the results back in the + # working tree. + if not options.dry_run: + use_shm = os.path.exists("/dev/shm") + temp_dir, temp_wc_dir = perform_tmp_clone(sh, use_shm) + with util.ChangeDirectory(temp_wc_dir): + sh.call("git", "remote", "add", "scripts", repo) + sh.call("git", "fetch", "-q", "scripts") + user_commit, next_commit = calculate_parents(sh, version) + # save variables so that --continue will work + # yeah yeah no trailing newline whatever + open(".git/WIZARD_REPO", "w").write(repo) + open(".git/WIZARD_UPGRADE_VERSION", "w").write(version) + open(".git/WIZARD_PARENTS", "w").write("%s\n%s" % (user_commit, next_commit)) + open(".git/WIZARD_SIZE", "w").write(str(scripts.get_disk_usage())) + if options.log_file: + open(".git/WIZARD_LOG_FILE", "w").write(options.log_file) + perform_merge(sh, repo, d, version, use_shm, kib_limit and kib_limit - kib_usage or None) + # variables: version, user_commit, next_commit, temp_wc_dir + with util.ChangeDirectory(temp_wc_dir): + try: + sh.call("git", "status") + sh.call("git", "commit", "-m", "throw-away commit") + except shell.CallError: + pass + message = make_commit_message(version) + new_tree = sh.eval("git", "rev-parse", "HEAD^{tree}") + final_commit = sh.eval("git", "commit-tree", new_tree, + "-p", user_commit, "-p", next_commit, input=message, log=True) + # a master branch may not necessarily exist if the user + # was manually installed to an earlier version + try: + sh.call("git", "checkout", "-q", "-b", "master", "--") + except shell.CallError: + sh.call("git", "checkout", "-q", "master", "--") + sh.call("git", "reset", "-q", "--hard", final_commit) + # This is a quick sanity check to make sure we didn't completely + # mess up the merge + d.verifyVersion() + # Till now, all of our operations were in a tmp sandbox. + if options.dry_run: + logging.info("Dry run, bailing. See results at %s" % temp_wc_dir) + return + # Ok, now we have to do a crazy complicated dance to see if we're + # going to have enough quota to finish what we need + pre_size = int(open(os.path.join(temp_wc_dir, ".git/WIZARD_SIZE"), "r").read()) + post_size = scripts.get_disk_usage(temp_wc_dir) + kib_usage, kib_limit = scripts.get_quota_usage_and_limit() + backup = d.backup(options) + if kib_limit is not None and (kib_limit - kib_usage) - (post_size - pre_size) / 1024 < kib_buffer: + shutil.rmtree(os.path.join(".scripts/backups", sh.eval("wizard", "restore").splitlines()[0])) + raise QuotaTooLow + # XXX: frob .htaccess to make site inaccessible + with util.IgnoreKeyboardInterrupts(): + with util.LockDirectory(".scripts-upgrade-lock"): + # git merge (which performs a fast forward) + sh.call("git", "pull", "-q", temp_wc_dir, "master") + version_obj = distutils.version.LooseVersion(version.partition('-')[2]) + try: + # run update script + d.upgrade(version_obj, options) + d.verifyWeb() + except app.UpgradeFailure: + logging.warning("Upgrade failed: rolling back") + perform_restore(d, backup) + raise + except deploy.WebVerificationError as e: + logging.warning("Web verification failed: rolling back") + perform_restore(d, backup) + raise app.UpgradeVerificationFailure(e.contents) + # XXX: frob .htaccess to make site accessible + # to do this, check if .htaccess changed, first. Upgrade + # process might have frobbed it. Don't be + # particularly worried if the segment disappeared + finally: + if use_shm and temp_dir and os.path.exists(temp_dir): + shutil.rmtree(temp_dir) def perform_restore(d, backup): # You don't want d.restore() because it doesn't perform @@ -245,21 +246,24 @@ def perform_merge(sh, repo, d, version, use_shm, kib_avail): return # XXX: Maybe should recalculate conflicts logging.info("Conflict info:\n" + sh.eval("git", "diff")) - if use_shm: - # Keeping all of our autoinstalls in shared memory is - # a recipe for disaster, so let's move them to slightly - # less volatile storage (a temporary directory) - os.chdir(tempfile.gettempdir()) - newdir = tempfile.mkdtemp(prefix="wizard") - # shutil, not os; at least on Ubuntu os.move fails - # with "[Errno 18] Invalid cross-device link" - shutil.move(curdir, newdir) - shutil.rmtree(os.path.dirname(curdir)) - curdir = os.path.join(newdir, "repo") - os.chdir(curdir) + curdir = mv_shm_to_tmp(curdir, use_shm) print "%d %s" % (conflicts, curdir) raise MergeFailed +def mv_shm_to_tmp(curdir, use_shm): + if not use_shm: return curdir + # Keeping all of our autoinstalls in shared memory is + # a recipe for disaster, so let's move them to slightly + # less volatile storage (a temporary directory) + os.chdir(tempfile.gettempdir()) + newdir = tempfile.mkdtemp(prefix="wizard") + # shutil, not os; at least on Ubuntu os.move fails + # with "[Errno 18] Invalid cross-device link" + shutil.move(curdir, newdir) + shutil.rmtree(os.path.dirname(curdir)) + curdir = os.path.join(newdir, "repo") + return curdir + def parse_args(argv, baton): usage = """usage: %prog upgrade [ARGS] [DIR] @@ -320,9 +324,15 @@ with git rerere to remember merge resolutions (XXX: not sure if this actually works).""" class BlacklistedError(Error): + #: Reason why the autoinstall was blacklisted + reason = None + def __init__(self, reason): + self.reason = reason def __str__(self): return """ ERROR: This autoinstall was manually blacklisted against errors; if the user has not been notified of this, please send them -mail.""" +mail. + +The reason was: %s""" % self.reason