import time
import errno
+# XXX: read().strip() is an accident waiting to happen if anyone ever
+# makes a directory with a trailing or leading space. Unlikely, but yeah.
+
from wizard import app, command, deploy, merge, shell, user, util
buffer = 1024 * 1024 * 30 # 30 MiB we will always leave available
logging.info("Upgrading %s" % os.getcwd())
self.preflight()
self.merge()
+ # Note invariant: we expect you to be in the production
+ # directory at this point, even if you --continue'd from
+ # the temporary directory!
self.postflight()
# Till now, all of our operations were in a tmp sandbox.
if self.options.dry_run:
self.resumeChdir()
self.resumeState()
self.resumeLogging()
- util.chdir(shell.eval("git", "config", "remote.origin.url"))
self.resumeProd()
def resumeChdir(self):
"""
- If we called ``--continue`` inside a production copy, check if
- :file:`.wizard/pending` exists and change to that directory if so.
+ If we called ``--continue`` inside a working copy (the usual
+ situation), check if :file:`.wizard/pending` exists and change
+ to that directory if so.
"""
- # XXX: Can't use deploy; maybe should stringify constants?
- if os.path.exists(".wizard/pending"):
- newdir = open(".wizard/pending").read().strip()
- logging.warning("Detected production copy; changing directory to %s", newdir)
- os.chdir(newdir)
- def resumeState(self):
self.temp_wc_dir = os.getcwd()
- self.wc = deploy.WorkingCopy(".")
- try:
- self.user_commit, self.next_commit = open(".git/WIZARD_PARENTS", "r").read().split()
- self.version = open(".git/WIZARD_UPGRADE_VERSION", "r").read()
- except IOError as e:
- if e.errno == errno.ENOENT:
- raise CannotResumeError()
- else:
- raise
+ didChdir = command.chdir_to_production()
+ self.prod = deploy.ProductionCopy(".")
+ pending_dir = open(self.prod.pending_file).read().strip()
+ if not didChdir:
+ logging.warning("Continued from a production copy; using working copy at %s", pending_dir)
+ self.temp_wc_dir = pending_dir
+ elif self.temp_wc_dir != pending_dir:
+ # prefer the original working copy, but warn that someone
+ # else someone a started an upgrade in the meantime (XXX:
+ # actually, that someone else should bug out, not clobber)
+ logging.warning("Someone else appears to have started an upgrade at %s", pending_dir)
+ def resumeState(self):
+ with util.ChangeDirectory(self.temp_wc_dir):
+ self.wc = deploy.WorkingCopy(".")
+ try:
+ self.user_commit, self.next_commit = open(".git/WIZARD_PARENTS", "r").read().split()
+ self.version = open(".git/WIZARD_UPGRADE_VERSION", "r").read()
+ except IOError as e:
+ if e.errno == errno.ENOENT:
+ raise CannotResumeError()
+ else:
+ raise
def resumeLogging(self):
- options = self.options
- if not options.log_file and os.path.exists(".git/WIZARD_LOG_FILE"):
- options.log_file = open(".git/WIZARD_LOG_FILE", "r").read()
- command.setup_file_logger(options.log_file, options.debug)
+ with util.ChangeDirectory(self.temp_wc_dir):
+ options = self.options
+ if not options.log_file and os.path.exists(".git/WIZARD_LOG_FILE"):
+ options.log_file = open(".git/WIZARD_LOG_FILE", "r").read()
+ command.setup_file_logger(options.log_file, options.debug)
def resumeProd(self):
"""Restore :attr:`prod` attribute, and check if the production copy has drifted."""
- self.prod = deploy.ProductionCopy(".")
try:
# simulate the action of `git status`, based on cmd_status()'s call to
# refresh_cache() in builtin-commit.c
self.prod.verify()
self.prod.verifyDatabase()
self.prod.verifyTag(options.srv_path)
- self.prod.verifyGit(options.srv_path)
+ try:
+ self.prod.verifyGit(options.srv_path)
+ except deploy.InconsistentWizardTagError:
+ shell.call("git", "fetch")
+ shell.call("git", "fetch", "--tags")
+ shell.call("wizard", "remaster")
+ self.prod.verifyGit(options.srv_path)
+ except deploy.HeadNotDescendantError:
+ shell.call("wizard", "remaster")
+ self.prod.verifyGit(options.srv_path)
if not options.skip_verification:
self.prod.verifyConfigured()
try:
break
else:
raise VersionRematchFailed
- if not options.skip_verification:
- self.prod.verifyWeb()
+ self.verifyWeb()
self.preflightAlreadyUpgraded()
self.preflightQuota()
def preflightBlacklist(self):
self.temp_dir = tempfile.mkdtemp(prefix="wizard", dir=dir)
self.temp_wc_dir = os.path.join(self.temp_dir, "repo")
logging.info("Using temporary directory: " + self.temp_wc_dir)
- shell.call("git", "clone", "-q", "--shared", ".", self.temp_wc_dir)
+ shell.call("git", "clone", "-q", ".", self.temp_wc_dir)
def mergeSaveState(self):
"""Save variables so that ``--continue`` will work."""
# yeah yeah no trailing newline whatever
self.temp_wc_dir = mv_shm_to_tmp(os.getcwd(), self.use_shm)
self.wc.location = self.temp_wc_dir
os.chdir(self.temp_wc_dir)
+ if os.path.exists(self.prod.pending_file):
+ mtime = os.path.getmtime(self.prod.pending_file)
+ pending_location = open(self.prod.pending_file).read().strip()
+ # don't complain if .wizard/pending is a day old
+ if mtime > (time.time() - 60 * 60 * 24):
+ raise UpgradeInProgressError(pending_location, mtime)
+ else:
+ logging.warning("Probably harmless old pending upgrade at %s from %s", pending_location, time.ctime(mtime))
open(self.prod.pending_file, "w").write(self.temp_wc_dir)
if self.options.non_interactive:
print "%d %s" % (conflicts, self.temp_wc_dir)
print "Please resolve these conflicts (edit and then `git add`), and"
print "then type 'exit'. You will now be dropped into a shell whose working"
print "directory is %s" % self.temp_wc_dir
+ print
+ print "NOTE: If you resolve these conflicts, and then the upgrade fails for"
+ print "an unrelated reason, you can run 'wizard upgrade --continue' from this"
+ print "directory to try again."
try:
shell.call(user_shell, "-i", interactive=True)
except shell.CallError as e:
try:
# run update script
self.prod.upgrade(version_obj, self.options)
- self.prod.verifyWeb()
+ self.verifyWeb()
+ try:
+ os.unlink(self.prod.pending_file)
+ except OSError as e:
+ if e.errno != errno.ENOENT:
+ raise
except app.UpgradeFailure:
logging.warning("Upgrade failed: rolling back")
self.upgradeRollback(backup)
if not self.options.disable_rollback:
shell.call("wizard", "restore", backup)
try:
- self.prod.verifyWeb()
+ self.verifyWeb()
except deploy.WebVerificationError:
logging.critical("Web verification failed after rollback")
else:
logging.warning("Rollback was disabled; you can rollback with `wizard restore %s`", backup)
+ def verifyWeb(self):
+ if not self.options.skip_verification:
+ self.prod.verifyWeb()
+
+
# utility functions
def mv_shm_to_tmp(curdir, use_shm):
options, args = parser.parse_all(argv)
if len(args) > 1:
parser.error("too many arguments")
+ if options.skip_verification:
+ logging.warning("Verification is disabled; Wizard may break your application and will not tell you about it")
return options, args
class Error(command.Error):
ERROR: This autoinstall was manually blacklisted against errors;
if the user has not been notified of this, please send them
-mail.
+mail. If you know that this application is blacklisted and
+would like to attempt an upgrade anyway, run:
+
+ wizard blacklist --delete
The reason was: %s""" % self.reason
ERROR: The version you are attempting to upgrade from (%s)
is unknown to the repository Wizard is using.""" % str(self.version)
+
+class UpgradeInProgressError(Error):
+ #: Location of pending upgrade
+ location = None
+ #: Time of pending upgrade
+ time = None
+ def __init__(self, location, time):
+ self.location = location
+ self.time = time
+ def __str__(self):
+ return """
+
+ERROR: There is already an upgrade in progress at
+
+ %s
+
+which was last started at %s.
+
+To ignore and start another upgrade anyway, remove the file
+.wizard/pending and try again.""" % (self.location, time.ctime(self.time))
scripts.mit.edu / wizard.git / blobdiff