+"""
+Object model for querying information and manipulating deployments
+of autoinstalls. Every :class:`Deployment` has an :class:`app.ApplicationVersion`
+which in turn has an :class:`app.Application`.
+"""
+
import os.path
-import math
import fileinput
-import dateutil.parser
-import distutils.version
+import logging
+import decorator
+import datetime
+import tempfile
+import time
+import traceback
+import shutil
+import errno
+import pkg_resources
+import urlparse
import wizard
+from wizard import app, git, old_log, shell, sql, util
+
+## -- Global Functions --
+
+def get_install_lines(versions_store, user=None):
+ """
+ Low level function that retrieves a list of lines from the
+ :term:`versions store` that can be passed to :meth:`Deployment.parse`.
+ """
+ if os.path.isfile(versions_store):
+ return fileinput.input([versions_store])
+ if user:
+ return fileinput.input([versions_store + "/" + user])
+ return fileinput.input([versions_store + "/" + f for f in sorted(os.listdir(versions_store))])
+
+def parse_install_lines(show, versions_store, yield_errors = False, user = None):
+ """
+ Generator function for iterating through all autoinstalls.
+ Each item is an instance of :class:`Deployment`, or possibly
+ a :class:`wizard.deploy.Error` if ``yield_errors`` is ``True``. You can
+ filter out applications and versions by specifying ``app``
+ or ``app-1.2.3`` in ``show``. This function may generate
+ log output.
+ """
+ if not show:
+ show = app.applications()
+ elif isinstance(show, str):
+ # otherwise, frozenset will treat string as an iterable
+ show = frozenset([show])
+ else:
+ show = frozenset(show)
+ for line in get_install_lines(versions_store, user):
+ # construction
+ try:
+ d = Deployment.parse(line)
+ name = d.application.name
+ except app.NoSuchApplication as e:
+ if not e.location:
+ try:
+ e.location = line.split(':')[0]
+ except IndexError:
+ e.location = line
+ if yield_errors:
+ yield e
+ continue
+ except Error:
+ # we consider this a worse error
+ logging.warning("Error with '%s'" % line.rstrip())
+ continue
+ # filter
+ if name + "-" + util.truncate(str(d.version)) in show or name in show:
+ pass
+ else:
+ continue
+ # yield
+ yield d
+
+def web(dir, url=None):
+ """
+ Attempts to determine the URL a directory would be web-accessible at.
+ If ``url`` is specified, automatically use it. Returns a generator which
+ produces a list of candidate urls.
-def getInstallLines(global_options):
- """Retrieves a list of lines from the version directory that
- can be passed to Deployment.parse()"""
- vs = global_options.versions
- if os.path.isfile(vs):
- return fileinput.input([vs])
- return fileinput.input([vs + "/" + f for f in os.listdir(vs)])
+ This function implements a plugin interface named :ref:`wizard.deploy.web`.
+ """
+ if url:
+ if isinstance(url, str):
+ url = urlparse.urlparse(url)
+ logging.info("wizard.deploy.web: Using default URL %s", url)
+ yield url
+ return
+
+ for entry in pkg_resources.iter_entry_points("wizard.deploy.web"):
+ logging.debug("wizard.deploy.web: Processing %s", entry)
+ f = entry.load()
+ for r in f(dir):
+ if isinstance(r, str):
+ r = urlparse.urlparse(r)
+ logging.info("wizard.deploy.web: Using plugin-supplied URL %s", r)
+ yield r
+
+ # try the environment
+ host = os.getenv("WIZARD_WEB_HOST")
+ path = os.getenv("WIZARD_WEB_PATH")
+ if host is not None and path is not None:
+ r = urlparse.ParseResult(
+ "http",
+ host,
+ path.rstrip('/'),
+ "", "", "")
+ logging.info("wizard.deploy.web: Using environment URL %s", r)
+ yield r
+
+ logging.info("wizard.deploy.web: Exhausted URLs")
+
+## -- Model Objects --
+
+@decorator.decorator
+def chdir_to_location(f, self, *args, **kwargs):
+ """
+ Decorator for making a function have working directory
+ :attr:`Deployment.location`.
+ """
+ with util.ChangeDirectory(self.location):
+ return f(self, *args, **kwargs)
class Deployment(object):
- """Represents a deployment of an autoinstall; i.e. a concrete
- directory in web_scripts that has .scripts-version in it."""
- def __init__(self, location, log=None, version=None):
- """ `location` Location of the deployment
- `version` ApplicationVersion of the app (this is cached info)
- `log` DeployLog of the app"""
- self.location = location
- self._version = version
- self._log = log
+ """
+ Represents a deployment of an autoinstall, e.g. directory that has a
+ ``.wizard`` directory in it. Supply ``version`` with an
+ :class:`ApplicationVersion` only if you were reading from the
+ :term:`versions store` and care about speed (data from there can be
+ stale).
+
+ The Deployment interface is somewhat neutered, so you may
+ want to use :class:`WorkingCopy` or :class:`ProductionCopy` for
+ more powerful operations.
+
+ .. note::
+
+ For legacy purposes, deployments can also be marked by a
+ ``.scripts`` directory or a ``.scripts-version`` file.
+ """
+ #: Absolute path to the deployment
+ location = None
+ def __init__(self, location, version=None):
+ self.location = os.path.abspath(location)
+ self._app_version = version
+ # some cache variables
+ self._read_cache = {}
+ self._old_log = None
+ self._dsn = None
+ self._url = None
+ self._urlGen = None
+ self._wizard_dir = None
+ def invalidateCache(self):
+ """
+ Invalidates all cached variables. This currently applies to
+ :attr:`app_version`, :attr:`old_log` and :meth:`read`.
+ """
+ self._app_version = None
+ self._read_cache = {}
+ self._old_log = None
+ def setAppVersion(self, app_version):
+ """
+ Manually resets the application version; useful if the working
+ copy is off in space (i.e. not anchored to something we can
+ git describe off of) or there is no metadata to be heard of.
+ """
+ self._app_version = app_version
+ def read(self, file, force = False):
+ """
+ Reads a file's contents, possibly from cache unless ``force``
+ is ``True``.
+ """
+ if force or file not in self._read_cache:
+ f = open(os.path.join(self.location, file))
+ self._read_cache[file] = f.read()
+ f.close()
+ return self._read_cache[file]
+ def extract(self):
+ """
+ Extracts all the values of all variables from deployment.
+ These variables may be used for parametrizing generic parent
+ commits and include things such as database access credentials
+ and local configuration.
+ """
+ return self.application.extract(self)
+
+ def verify(self, no_touch=False):
+ """
+ Checks if this is an autoinstall, throws an exception if there
+ are problems. If ``no_touch`` is ``True``, it will not attempt
+ edit the installation.
+ """
+ with util.ChangeDirectory(self.location):
+ has_git = os.path.isdir(".git")
+ has_wizard = os.path.isdir(".wizard")
+ if not has_wizard and os.path.isdir(".scripts"):
+ # LEGACY
+ os.symlink(".scripts", ".wizard")
+ has_wizard = True
+ if not has_git and has_wizard:
+ raise CorruptedAutoinstallError(self.location)
+ elif has_git and not has_wizard:
+ raise AlreadyVersionedError(self.location)
+ # LEGACY
+ elif not has_git and not has_wizard:
+ if os.path.isfile(".scripts-version"):
+ raise NotMigratedError(self.location)
+ else:
+ raise NotAutoinstallError(self.location)
+
+ def verifyTag(self, srv_path):
+ """
+ Checks if the purported version has a corresponding tag
+ in the upstream repository.
+ """
+ repo = self.application.repository(srv_path)
+ try:
+ shell.eval("git", "--git-dir", repo, "rev-parse", self.app_version.wizard_tag, '--')
+ except shell.CallError:
+ raise NoTagError(self.app_version.wizard_tag)
+
+ def verifyGit(self, srv_path):
+ """
+ Checks if the autoinstall's Git repository makes sense,
+ checking if the tag is parseable and corresponds to
+ a real application, and if the tag in this repository
+ corresponds to the one in the remote repository.
+ """
+ with util.ChangeDirectory(self.location):
+ repo = self.application.repository(srv_path)
+ def repo_rev_parse(tag):
+ return shell.eval("git", "--git-dir", repo, "rev-parse", tag)
+ def self_rev_parse(tag):
+ try:
+ return shell.safeCall("git", "rev-parse", tag, strip=True)
+ except shell.CallError:
+ raise NoLocalTagError(tag)
+ def compare_tags(tag):
+ return repo_rev_parse(tag) == self_rev_parse(tag)
+ if not compare_tags(self.app_version.pristine_tag):
+ raise InconsistentPristineTagError(self.app_version.pristine_tag)
+ if not compare_tags(self.app_version.wizard_tag):
+ # Causes remastering
+ raise InconsistentWizardTagError(self.app_version.wizard_tag)
+ parent = repo_rev_parse(self.app_version.wizard_tag)
+ merge_base = shell.safeCall("git", "merge-base", parent, "HEAD", strip=True)
+ if merge_base != parent:
+ # Causes remastering
+ raise HeadNotDescendantError(self.app_version.wizard_tag)
+
+ def verifyConfigured(self):
+ """
+ Checks if the autoinstall is configured running.
+ """
+ if not self.configured:
+ raise NotConfiguredError(self.location)
+
+ @chdir_to_location
+ def verifyVersion(self):
+ """
+ Checks if our version and the version number recorded in a file
+ are consistent.
+ """
+ real = self.detectVersion()
+ if not str(real) == self.app_version.pristine_tag.partition('-')[2]:
+ raise VersionMismatchError(real, self.version)
+
+ @chdir_to_location
+ def detectVersion(self):
+ """
+ Returns the real version, based on filesystem, of install.
+
+ Throws a :class:`VersionDetectionError` if we couldn't figure out
+ what the real version was.
+ """
+ real = self.application.detectVersion(self)
+ if not real:
+ raise VersionDetectionError
+ return real
+
+ @property
+ @chdir_to_location
+ def configured(self):
+ """Whether or not an autoinstall has been configured/installed for use."""
+ return self.application.checkConfig(self)
+ @property
+ def migrated(self):
+ """Whether or not the autoinstalls has been migrated."""
+ return os.path.isdir(self.wizard_dir)
+ @property
+ def wizard_dir(self):
+ """The absolute path of the Wizard directory."""
+ return os.path.join(self.location, ".wizard")
+ @property
+ def backup_dir(self):
+ """The absolute path to ``.wizard/backups``."""
+ return os.path.join(self.wizard_dir, "backups")
+ # LEGACY
+ @property
+ def old_version_file(self):
+ """
+ The absolute path of either ``.scripts-version``.
+ """
+ return os.path.join(self.location, '.scripts-version')
+ @property
+ def blacklisted_file(self):
+ """The absolute path of the ``.wizard/blacklisted`` file."""
+ return os.path.join(self.wizard_dir, 'blacklisted')
+ @property
+ def pending_file(self):
+ """The absolute path of the ``.wizard/pending`` file."""
+ return os.path.join(self.wizard_dir, 'pending')
+ @property
+ def version_file(self):
+ """The absolute path of the ``.wizard/version`` file."""
+ return os.path.join(self.wizard_dir, 'version')
+ @property
+ def dsn_file(self):
+ """The absolute path of the :file:`.wizard/dsn` override file."""
+ return os.path.join(self.wizard_dir, 'dsn')
+ @property
+ def url_file(self):
+ """The absolute path of the :file:`.wizard/url` override file."""
+ return os.path.join(self.wizard_dir, 'url')
+ @property
+ def application(self):
+ """The :class:`app.Application` of this deployment."""
+ return self.app_version.application
+ @property
+ def old_log(self):
+ """
+ The :class:`wizard.old_log.Log` of this deployment. This
+ is only applicable to un-migrated autoinstalls.
+ """
+ if not self._old_log:
+ self._old_log = old_log.DeployLog.load(self)
+ return self._old_log
+ @property
+ def version(self):
+ """
+ The :class:`distutils.version.LooseVersion` of this
+ deployment.
+ """
+ return self.app_version.version
+ @property
+ def app_version(self):
+ """The :class:`app.ApplicationVersion` of this deployment."""
+ if not self._app_version:
+ if os.path.isdir(os.path.join(self.location, ".git")):
+ try:
+ with util.ChangeDirectory(self.location):
+ appname, _, version = git.describe().partition('-')
+ self._app_version = app.ApplicationVersion.make(appname, version)
+ except shell.CallError:
+ pass
+ if not self._app_version:
+ # LEGACY
+ try:
+ self._app_version = self.old_log[-1].version
+ except old_log.ScriptsVersionNoSuchFile:
+ pass
+ if not self._app_version:
+ 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.auth(self.application.dsn(self))
+ return self._dsn
+ @property
+ def url(self):
+ """The :class:`urlparse.ParseResult` for this deployment."""
+ if not self._url:
+ self.nextUrl()
+ return self._url
+ def nextUrl(self):
+ """
+ Initializes :attr:`url` with a possible URL the web application may
+ be located at. It may be called again to switch to another possible
+ URL, usually in the event of a web access failure.
+ """
+ if not self._urlGen:
+ self._urlGen = web(self.location, self.application.url(self))
+ try:
+ self._url = self._urlGen.next() # pylint: disable-msg=E1101
+ return self._url
+ except StopIteration:
+ raise UnknownWebPath
@staticmethod
def parse(line):
- """Parses a line from the results of parallel-find.pl.
- This will work out of the box with fileinput, see
- getInstallLines()"""
+ """
+ Parses a line from the :term:`versions store`.
+
+ .. note::
+
+ Use this method only when speed is of the utmost
+ importance. You should prefer to directly create a deployment
+ with only a ``location`` when possible.
+ """
line = line.rstrip()
try:
location, deploydir = line.split(":")
except ValueError:
- return Deployment(line) # lazy loaded version
- return Deployment(location, version=ApplicationVersion.parse(deploydir))
- @staticmethod
- def fromDir(dir):
- """Lazily creates a deployment from a directory"""
- return Deployment(dir)
- def getVersionFile(self):
- return os.path.join(self.location, '.scripts-version')
- def getApplication(self):
- return self.getAppVersion().application
- def getLog(self):
- if not self._log:
- self._log = DeployLog.load(self.getVersionFile())
- return self._log
- def getVersion(self):
- """Returns the distutils Version of the deployment"""
- return self.getAppVersion().version
- def getAppVersion(self, force = False):
- """Returns the ApplicationVersion of the deployment"""
- if self._version and not force: return self._version
- else: return self.getLog()[-1].version
- def count(self):
- """Simple method which registers the deployment as a +1 on the
- appropriate version. No further inspection is done."""
- self.getAppVersion().count(self)
- return True
- def count_exists(self, file):
- """Checks if the codebase has a certain file/directory in it."""
- if os.path.exists(self.location + "/" + file):
- self.getAppVersion().count_exists(self, file)
- return True
- return False
-
-class Application(object):
- """Represents the generic notion of an application, i.e.
- mediawiki or phpbb."""
- def __init__(self, name):
- self.name = name
- self.versions = {}
- # This is 'wizard summary' specific code
- self._total = 0
- self._max = 0
- self._c_exists = {}
- def getRepository(self):
- """Returns the Git repository that would contain this application."""
- repo = os.path.join("/afs/athena.mit.edu/contrib/scripts/git/autoinstalls", self.name + ".git")
- if not os.path.isdir(repo):
- raise NoRepositoryError(app)
- return repo
- def getVersion(self, version):
- if version not in self.versions:
- self.versions[version] = ApplicationVersion(distutils.version.LooseVersion(version), self)
- return self.versions[version]
- # XXX: This code should go in summary.py; maybe as a mixin, maybe as
- # a visitor acceptor
- HISTOGRAM_WIDTH = 30
- def _graph(self, v):
- return '+' * int(math.ceil(float(v)/self._max * self.HISTOGRAM_WIDTH))
- def report(self):
- if not self.versions: return "%-11s no installs" % self.name
- ret = \
- ["%-16s %3d installs" % (self.name, self._total)] + \
- [v.report() for v in sorted(self.versions.values())]
- for f,c in self._c_exists.items():
- ret.append("%d users have %s" % (c,f))
- return "\n".join(ret)
-
-class DeployLog(list):
- # As per #python; if you decide to start overloading magic methods,
- # we should remove this subclass
- """Equivalent to .scripts-version: a series of DeployRevisions."""
- def __init__(self, revs = []):
- """`revs` List of DeployRevision objects"""
- list.__init__(self, revs) # pass to list
- @staticmethod
- def load(file):
- """Loads a scripts version file and parses it into
- DeployLog and DeployRevision objects"""
- # XXX: DIRTY DIRTY HACK
- # What we should actually do is parse the git logs
- scriptsdir = os.path.join(os.path.dirname(file), ".scripts")
- if os.path.isdir(scriptsdir):
- file = os.path.join(scriptsdir, "old-version")
- i = 0
- rev = DeployRevision()
- revs = []
- def append(rev):
- if i:
- if i != 4:
- raise ScriptsVersionNotEnoughFieldsError()
- revs.append(rev)
+ return ProductionCopy(line) # lazy loaded version
try:
- fh = open(file)
- except IOError:
- raise ScriptsVersionNoSuchFile(file)
- # XXX: possibly rewrite this parsing code. This might
- # be legacy soon
- for line in fh:
- line = line.rstrip()
- if not line:
- append(rev)
- i = 0
- rev = DeployRevision()
- continue
- if i == 0:
- # we need the dateutil parser in order to
- # be able to parse time offsets
- rev.datetime = dateutil.parser.parse(line)
- elif i == 1:
- rev.user = line
- elif i == 2:
- rev.source = DeploySource.parse(line)
- elif i == 3:
- rev.version = ApplicationVersion.parse(line)
- else:
- # ruh oh
- raise ScriptsVersionTooManyFieldsError()
- i += 1
- append(rev)
- return DeployLog(revs)
- def __repr__(self):
- return '<DeployLog %s>' % list.__repr__(self)
-
-class DeployRevision(object):
- """A single entry in the .scripts-version file. Contains who deployed
- this revision, what application version this is, etc."""
- def __init__(self, datetime=None, user=None, source=None, version=None):
- """ `datetime` Time this revision was deployed
- `user` Person who deployed this revision, in user@host format.
- `source` Instance of DeploySource
- `version` Instance of ApplicationVersion
- Note: This object is typically built incrementally."""
- self.datetime = datetime
- self.user = user
- self.source = source
- self.version = version
-
-class DeploySource(object):
- """Source of the deployment; see subclasses for examples"""
- def __init__(self):
- raise NotImplementedError # abstract class
- @staticmethod
- def parse(line):
- # munge out common prefix
- rel = os.path.relpath(line, "/afs/athena.mit.edu/contrib/scripts/")
- parts = rel.split("/")
- if parts[0] == "wizard":
- return WizardUpdate()
- elif parts[0] == "deploy" or parts[0] == "deploydev":
- isDev = ( parts[0] == "deploydev" )
+ return ProductionCopy(location, version=app.ApplicationVersion.parse(deploydir))
+ except Error as e:
+ e.location = location
+ raise e
+
+class ProductionCopy(Deployment):
+ """
+ Represents the production copy of a deployment. This copy
+ is canonical, and is the only one guaranteed to be accessible
+ via web, have a database, etc.
+ """
+ @chdir_to_location
+ def upgrade(self, version, options):
+ """
+ Performs an upgrade of database schemas and other non-versioned data.
+ """
+ return self.application.upgrade(self, version, options)
+ @chdir_to_location
+ def backup(self, options):
+ """
+ Performs a backup of database schemas and other non-versioned data.
+ """
+ # 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.
+ if not os.path.exists(self.backup_dir):
try:
- if parts[1] == "updates":
- return OldUpdate(isDev)
+ os.mkdir(self.backup_dir)
+ except OSError as e:
+ if e.errno == errno.EEXIST:
+ pass
else:
- return TarballInstall(line, isDev)
- except IndexError:
- pass
- return UnknownDeploySource(line)
+ 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(self.backup_dir, "lock")):
+ while 1:
+ backup = str(self.version) + "-" + datetime.datetime.today().strftime("%Y-%m-%dT%H%M%S")
+ outdir = os.path.join(self.backup_dir, 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):
+ """
+ Restores a backup. Destroys state, so be careful! Also, this does
+ NOT restore the file-level backup, which is what 'wizard restore'
+ does, so you probably do NOT want to call this elsewhere unless
+ you know what you're doing (call 'wizard restore' instead).
+ """
+ return self.application.restore(self, os.path.join(self.backup_dir, backup), options)
+ @chdir_to_location
+ def remove(self, options):
+ """
+ Deletes all non-local or non-filesystem data (such as databases) that
+ this application uses.
+ """
+ self.application.remove(self, options)
+ def verifyDatabase(self):
+ """
+ Checks if the autoinstall has a properly configured database.
+ """
+ if not self.application.checkDatabase(self):
+ raise DatabaseVerificationError
+ def verifyWeb(self):
+ """
+ Checks if the autoinstall is viewable from the web. If you do not run
+ this, there is no guarantee that the url returned by this application
+ is the correct one.
+ """
+ while True:
+ if not self.application.checkWeb(self):
+ try:
+ self.nextUrl()
+ except UnknownWebPath:
+ raise WebVerificationError
+ else:
+ break
+ def fetch(self, path, post=None):
+ """
+ Performs a HTTP request on the website.
+ """
+ return util.fetch(self.url.netloc, self.url.path, path, post) # pylint: disable-msg=E1103
-class TarballInstall(DeploySource):
- """Original installation from tarball, characterized by
- /afs/athena.mit.edu/contrib/scripts/deploy/APP-x.y.z.tar.gz
+class WorkingCopy(Deployment):
"""
- def __init__(self, location, isDev):
- self.location = location
- self.isDev = isDev
-
-class OldUpdate(DeploySource):
- """Upgrade using old upgrade infrastructure, characterized by
- /afs/athena.mit.edu/contrib/scripts/deploydev/updates/update-scripts-version.pl
+ Represents a temporary clone of a deployment that we can make
+ modifications to without fear of interfering with a production
+ deployment. More operations are permitted on these copies.
"""
- def __init__(self, isDev):
- self.isDev = isDev
+ @chdir_to_location
+ def parametrize(self, deployment):
+ """
+ Edits files in ``dir`` to replace WIZARD_* variables with literal
+ instances based on ``deployment``. This is used for constructing
+ virtual merge bases, and as such ``deployment`` will generally not
+ equal ``self``.
+ """
+ return self.application.parametrize(self, deployment)
+ @chdir_to_location
+ def prepareConfig(self):
+ """
+ Edits files in the deployment such that any user-specific configuration
+ is replaced with generic WIZARD_* variables.
+ """
+ return self.application.prepareConfig(self)
+ @chdir_to_location
+ def resolveConflicts(self):
+ """
+ Resolves conflicted files in this working copy. Returns whether or
+ not all conflicted files were resolved or not. Fully resolved
+ files are added to the index, but no commit is made.
+ """
+ return self.application.resolveConflicts(self)
+ @chdir_to_location
+ def prepareMerge(self):
+ """
+ Performs various edits to files in the current working directory in
+ order to make a merge go more smoothly. This is usually
+ used to fix botched line-endings.
+ """
+ return self.application.prepareMerge(self)
-class WizardUpdate(DeploySource):
- """Upgrade using wizard infrastructure, characterized by
- /afs/athena.mit.edu/contrib/scripts/wizard/bin/wizard HASHGOBBLEDYGOOK
- """
- def __init__(self):
- pass
-
-class UnknownDeploySource(DeploySource):
- """Deployment that we don't know the meaning of. Wot!"""
- def __init__(self, line):
- self.line = line
-
-class ApplicationVersion(object):
- """Represents an abstract notion of a version for an application"""
- def __init__(self, version, application):
- """ `version` Instance of distutils.LooseVersion
- `application` Instance of Application
- WARNING: Please don't call this directly; instead, use getVersion()
- on the application you want, so that this version gets registered."""
- self.version = version
- self.application = application
- self.c = 0
- self.c_exists = {}
- def getScriptsTag(self):
- """Returns the name of the Git tag for this version"""
- # XXX: This assumes that there's only a -scripts version
- # which will not be true in the future.
- return "v%s-scripts" % self.version
- def __cmp__(x, y):
- return cmp(x.version, y.version)
- @staticmethod
- def parse(deploydir,applookup=None):
- # The version of the deployment, will be:
- # /afs/athena.mit.edu/contrib/scripts/deploy/APP-x.y.z for old style installs
- # /afs/athena.mit.edu/contrib/scripts/wizard/srv/APP.git vx.y.z-scripts for new style installs
- # XXX: ^- the above is wrong; there will be no more .scripts-version
- name = deploydir.split("/")[-1]
- try:
- if name.find(" ") != -1:
- raw_app, raw_version = name.split(" ")
- version = raw_version[1:] # remove leading v
- app, _ = raw_app.split(".") # remove trailing .git
- elif name.find("-") != -1:
- app, version = name.split("-")
- # XXX: this should be removed after the next parallel-find run
- elif name == "deploy":
- # Assume that it's django, since those were botched
- app = "django"
- version = "0.1-scripts"
- else:
- raise DeploymentParseError(deploydir)
- except ValueError: # mostly from the a, b = foo.split(' ')
- raise DeploymentParseError(deploydir)
- if not applookup: applookup = applications
- try:
- # defer to the application for version creation
- return applookup[app].getVersion(version)
- except KeyError:
- raise NoSuchApplication
- # This is summary specific code
- def count(self, deployment):
- self.c += 1
- self.application._total += 1
- if self.c > self.application._max:
- self.application._max = self.c
- def count_exists(self, deployment, n):
- if n in self.c_exists: self.c_exists[n] += 1
- else: self.c_exists[n] = 1
- if n in self.application._c_exists: self.application._c_exists[n] += 1
- else: self.application._c_exists[n] = 1
- def report(self):
- return " %-12s %3d %s" \
- % (self.version, self.c, self.application._graph(self.c))
+## -- Exceptions --
class Error(wizard.Error):
- """Base error class for deploy errors"""
+ """Base error class for this module"""
pass
-class NoSuchApplication(Error):
- pass
+# LEGACY
+class NotMigratedError(Error):
+ """
+ The deployment contains a .scripts-version file, but no .git
+ or .wizard directory.
+ """
+ #: Directory of deployment
+ dir = None
+ def __init__(self, dir):
+ self.dir = dir
+ def __str__(self):
+ return """This installation was not migrated"""
-class DeploymentParseError(Error):
- def __init__(self, malformed):
- self.malformed = malformed
+class AlreadyVersionedError(Error):
+ """The deployment contained a .git directory but no .wizard directory."""
+ #: Directory of deployment
+ dir = None
+ def __init__(self, dir):
+ self.dir = dir
def __str__(self):
return """
-ERROR: Could not parse deployment string:
-%s
-""" % self.malformed
+ERROR: Directory contains a .git directory, but not
+a .wizard directory. If this is not a corrupt
+migration, this means that the user was versioning their
+install using Git."""
-class ScriptsVersionTooManyFieldsError(Error):
+class NotConfiguredError(Error):
+ """The install was missing essential configuration."""
+ #: Directory of unconfigured install
+ dir = None
+ def __init__(self, dir):
+ self.dir = dir
def __str__(self):
return """
-ERROR: Could not parse .scripts-version file. It
-contained too many fields.
-"""
+ERROR: The install was well-formed, but not configured
+(essential configuration files were not found.)"""
-class ScriptsVersionNotEnoughFieldsError(Error):
+class CorruptedAutoinstallError(Error):
+ """The install was missing a .git directory, but had a .wizard directory."""
+ #: Directory of the corrupted install
+ dir = None
+ def __init__(self, dir):
+ self.dir = dir
def __str__(self):
return """
-ERROR: Could not parse .scripts-version file. It
-didn't contain enough fields.
-"""
+ERROR: Directory contains a .wizard directory,
+but not a .git directory."""
+
+class NotAutoinstallError(Error):
+ """Application is not an autoinstall."""
+ #: Directory of the not autoinstall
+ dir = None
+ def __init__(self, dir):
+ self.dir = dir
+ def __str__(self):
+ return """
+
+ERROR: The directory
+
+ %s
+
+does not appear to be an autoinstall. If you are in a
+subdirectory of an autoinstall, you need to use the root
+directory for the autoinstall.""" % self.dir
+
+class NoTagError(Error):
+ """Deployment has a tag that does not have an equivalent in upstream repository."""
+ #: Missing tag
+ tag = None
+ def __init__(self, tag):
+ self.tag = tag
+ def __str__(self):
+ return """
+
+ERROR: Could not find tag %s in repository.""" % self.tag
+
+class NoLocalTagError(Error):
+ """Could not find tag in local repository."""
+ #: Missing tag
+ tag = None
+ def __init__(self, tag):
+ self.tag = tag
+ def __str__(self):
+ return """
+
+ERROR: Could not find tag %s in local repository.""" % self.tag
+
+class InconsistentPristineTagError(Error):
+ """Pristine tag commit ID does not match upstream pristine tag commit ID."""
+ #: Inconsistent tag
+ tag = None
+ def __init__(self, tag):
+ self.tag = tag
+ def __str__(self):
+ return """
+
+ERROR: Local pristine tag %s did not match repository's. This
+probably means an upstream rebase occured.""" % self.tag
+
+class InconsistentWizardTagError(Error):
+ """Wizard tag commit ID does not match upstream wizard tag commit ID."""
+ #: Inconsistent tag
+ tag = None
+ def __init__(self, tag):
+ self.tag = tag
+ def __str__(self):
+ return """
+
+ERROR: Local wizard tag %s did not match repository's. This
+probably means an upstream rebase occurred. Try
+'git fetch --tags && wizard remaster'.""" % self.tag
+
+class HeadNotDescendantError(Error):
+ """HEAD is not connected to tag."""
+ #: Tag that HEAD should have been descendant of.
+ tag = None
+ def __init__(self, tag):
+ self.tag = tag
+ def __str__(self):
+ return """
-class ScriptsVersionNoSuchFile(Error):
- def __init__(self, file):
- self.file = file
+ERROR: HEAD is not a descendant of %s. This probably
+means that an upstream rebase occurred, and new tags were
+pulled, but local user commits were never rebased. Try
+running 'wizard remaster'.""" % self.tag
+
+class VersionDetectionError(Error):
+ """Could not detect real version of application."""
def __str__(self):
return """
-ERROR: File %s didn't exist.
-""" % self.file
+ERROR: Could not detect the real version of the application."""
+
+class VersionMismatchError(Error):
+ """Git version of application does not match detected version."""
+ #: Detected version
+ real_version = None
+ #: Version from Git
+ git_version = None
+ def __init__(self, real_version, git_version):
+ self.real_version = real_version
+ self.git_version = git_version
+ def __str__(self):
+ return """
-# If you want, you can wrap this up into a registry and access things
-# through that, but it's not really necessary
+ERROR: The detected version %s did not match the Git
+version %s.""" % (self.real_version, self.git_version)
+
+class WebVerificationError(Error):
+ """Could not access the application on the web"""
+ def __str__(self):
+ return """
-application_list = [
- "mediawiki", "wordpress", "joomla", "e107", "gallery2",
- "phpBB", "advancedbook", "phpical", "trac", "turbogears", "django",
- # these are technically deprecated
- "advancedpoll", "gallery",
-]
+ERROR: We were not able to access the application on the
+web. This may indicate that the website is behind
+authentication on the htaccess level. You can find
+the contents of the page from the debug backtraces."""
-"""Hash table for looking up string application name to instance"""
-applications = dict([(n,Application(n)) for n in application_list ])
+class DatabaseVerificationError(Error):
+ """Could not access the database"""
+ def __str__(self):
+ return """
+
+ERROR: We were not able to access the database for
+this application; this probably means that your database
+configuration is misconfigured."""
+
+class UnknownWebPath(Error):
+ """Could not determine application's web path."""
+ def __str__(self):
+ return """
+ERROR: We were not able to determine what the application's
+host and path were in order to perform a web request
+on the application. You can specify this manually using
+the WIZARD_WEB_HOST and WIZARD_WEB_PATH environment
+variables."""
scripts.mit.edu / wizard.git / blobdiff