Convert ad hoc shell calls to singleton instance; fix upgrade bug.

[wizard.git] / wizard / deploy.py

diff --git a/wizard/deploy.py b/wizard/deploy.py
index cadf63341990604a1524dca4dd190db74d543e4f..67c4118e0b7c37741a97e5ad7658bdde62b6014a 100644 (file)
--- a/wizard/deploy.py
+++ b/wizard/deploy.py
@@ -9,6 +9,11 @@ import fileinput
 import logging
 import decorator
 import datetime
+import tempfile
+import time
+import traceback
+import shutil
+import errno
 
 import wizard
 from wizard import app, git, old_log, scripts, shell, sql, util
@@ -95,6 +100,7 @@ class Deployment(object):
         self._read_cache = {}
         self._old_log = None
         self._dsn = None
+        self._url = None
     def invalidateCache(self):
         """
         Invalidates all cached variables.  This currently applies to
@@ -145,7 +151,7 @@ class Deployment(object):
         """
         repo = self.application.repository(srv_path)
         try:
-            shell.Shell().eval("git", "--git-dir", repo, "rev-parse", self.app_version.scripts_tag, '--')
+            shell.eval("git", "--git-dir", repo, "rev-parse", self.app_version.scripts_tag, '--')
         except shell.CallError:
             raise NoTagError(self.app_version.scripts_tag)
 
@@ -157,13 +163,12 @@ class Deployment(object):
         corresponds to the one in the remote repository.
         """
         with util.ChangeDirectory(self.location):
-            sh = shell.Shell()
             repo = self.application.repository(srv_path)
             def repo_rev_parse(tag):
-                return sh.eval("git", "--git-dir", repo, "rev-parse", tag)
+                return shell.eval("git", "--git-dir", repo, "rev-parse", tag)
             def self_rev_parse(tag):
                 try:
-                    return sh.safeCall("git", "rev-parse", tag, strip=True)
+                    return shell.safeCall("git", "rev-parse", tag, strip=True)
                 except shell.CallError:
                     raise NoLocalTagError(tag)
             def compare_tags(tag):
@@ -173,7 +178,7 @@ class Deployment(object):
             if not compare_tags(self.app_version.scripts_tag):
                 raise InconsistentScriptsTagError(self.app_version.scripts_tag)
             parent = repo_rev_parse(self.app_version.scripts_tag)
-            merge_base = sh.safeCall("git", "merge-base", parent, "HEAD", strip=True)
+            merge_base = shell.safeCall("git", "merge-base", parent, "HEAD", strip=True)
             if merge_base != parent:
                 raise HeadNotDescendantError(self.app_version.scripts_tag)
 
@@ -229,6 +234,10 @@ class Deployment(object):
         """The absolute path of the :file:`.scripts/dsn` override file."""
         return os.path.join(self.scripts_dir, 'dsn')
     @property
+    def url_file(self):
+        """The absolute path of the :file:`.scripts/url` override file."""
+        return os.path.join(self.scripts_dir, 'url')
+    @property
     def application(self):
         """The :class:`app.Application` of this deployment."""
         return self.app_version.application
@@ -265,14 +274,23 @@ class Deployment(object):
             except old_log.ScriptsVersionNoSuchFile:
                 pass
         if not self._app_version:
-            appname = shell.Shell().eval("git", "config", "remote.origin.url").rpartition("/")[2].partition(".")[0]
+            appname = shell.eval("git", "config", "remote.origin.url").rpartition("/")[2].partition(".")[0]
             self._app_version = app.ApplicationVersion.make(appname, "unknown")
         return self._app_version
     @property
     def dsn(self):
+        """The :class:`sqlalchemy.engine.url.URL` for this deployment."""
         if not self._dsn:
             self._dsn = sql.fill_url(self.application.dsn(self))
         return self._dsn
+    @property
+    def url(self):
+        """The :class:`urlparse.ParseResult` for this deployment."""
+        if not self._url:
+            self._url = scripts.fill_url(self.location, self.application.url(self))
+        if not self._url:
+            raise UnknownWebPath
+        return self._url
     @staticmethod
     def parse(line):
         """
@@ -312,15 +330,44 @@ class ProductionCopy(Deployment):
         """
         Performs a backup of database schemas and other non-versioned data.
         """
-        backupdir = os.path.join(self.location, ".scripts", "backups")
-        backup = str(self.version) + "-" + datetime.date.today().isoformat()
-        outdir = os.path.join(backupdir, backup)
+        # There are retarded amounts of race-safety in this function,
+        # because we do NOT want to claim to have made a backup, when
+        # actually something weird happened to it.
+        backupdir = os.path.join(self.scripts_dir, "backups")
         if not os.path.exists(backupdir):
-            os.mkdir(backupdir)
-        if os.path.exists(outdir):
-            util.safe_unlink(outdir)
-        os.mkdir(outdir)
-        self.application.backup(self, outdir, options)
+            try:
+                os.mkdir(backupdir)
+            except OSError as e:
+                if e.errno == errno.EEXIST:
+                    pass
+                else:
+                    raise
+        tmpdir = tempfile.mkdtemp() # actually will be kept around
+        try:
+            self.application.backup(self, tmpdir, options)
+        except app.BackupFailure:
+            # the backup is bogus, don't let it show up
+            shutil.rmtree(tmpdir)
+            raise
+        backup = None
+        with util.LockDirectory(os.path.join(backupdir, "lock")):
+            while 1:
+                backup = str(self.version) + "-" + datetime.datetime.today().strftime("%Y-%m-%dT%H%M%S")
+                outdir = os.path.join(backupdir, backup)
+                if os.path.exists(outdir):
+                    logging.warning("Backup: A backup occurred in the last second. Trying again in a second...")
+                    time.sleep(1)
+                    continue
+                try:
+                    shutil.move(tmpdir, outdir)
+                except:
+                    # don't leave half-baked stuff lying around
+                    try:
+                        shutil.rmtree(outdir)
+                    except OSError:
+                        pass
+                    raise
+                break
         return backup
     @chdir_to_location
     def restore(self, backup, options):
@@ -349,11 +396,7 @@ class ProductionCopy(Deployment):
         """
         Performs a HTTP request on the website.
         """
-        try:
-            host, basepath = scripts.get_web_host_and_path(self.location)
-        except (ValueError, TypeError):
-            raise UnknownWebPath
-        return util.fetch(host, basepath, path, post)
+        return util.fetch(self.url.netloc, self.url.path, path, post) # pylint: disable-msg=E1103
 
 class WorkingCopy(Deployment):
     """