diff options
Diffstat (limited to 'src/lib/Bcfg2/Server/SchemaUpdater/__init__.py')
| -rw-r--r-- | src/lib/Bcfg2/Server/SchemaUpdater/__init__.py | 257 |
1 files changed, 257 insertions, 0 deletions
diff --git a/src/lib/Bcfg2/Server/SchemaUpdater/__init__.py b/src/lib/Bcfg2/Server/SchemaUpdater/__init__.py new file mode 100644 index 000000000..304b36636 --- /dev/null +++ b/src/lib/Bcfg2/Server/SchemaUpdater/__init__.py @@ -0,0 +1,257 @@ +from django.db import connection, DatabaseError +from django.core.exceptions import ImproperlyConfigured +import django.core.management +import logging +import pkgutil +import re +import sys +import traceback + +from Bcfg2.Bcfg2Py3k import CmpMixin +from Bcfg2.Server.models import InternalDatabaseVersion +from Bcfg2.Server.SchemaUpdater.Routines import UpdaterRoutineException, \ + UpdaterRoutine +from Bcfg2.Server.SchemaUpdater import Changes + +logger = logging.getLogger(__name__) + +class UpdaterError(Exception): + pass + + +class SchemaTooOldError(UpdaterError): + pass + + +def _walk_packages(paths): + """Python 2.4 lacks this routine""" + import glob + submodules = [] + for path in paths: + for submodule in glob.glob("%s/*.py" % path): + mod = '.'.join(submodule.split("/")[-1].split('.')[:-1]) + if mod != '__init__': + submodules.append((None, mod, False)) + return submodules + + +def _release_to_version(release): + """ + Build a release base for a version + + Expects a string of the form 00.00 + + returns an integer of the form MMmm00 + """ + regex = re.compile("^(\d+)\.(\d+)$") + m = regex.match(release) + if not m: + logger.error("Invalid release string: %s" % release) + raise TypeError + return int("%02d%02d00" % (int(m.group(1)), int(m.group(2)))) + + +class Updater(CmpMixin): + """Database updater to standardize updates""" + + def __init__(self, release): + CmpMixin.__init__(self) + + self._cursor = None + self._release = release + try: + self._base_version = _release_to_version(release) + except: + err = "Invalid release string: %s" % release + logger.error(err) + raise UpdaterError(err) + + self._fixes = [] + self._version = -1 + + def __cmp__(self, other): + return self._base_version - other._base_version + + @property + def release(self): + return self._release + + @property + def version(self): + if self._version < 0: + try: + iv = InternalDatabaseVersion.objects.latest() + self._version = iv.version + except InternalDatabaseVersion.DoesNotExist: + raise UpdaterError("No database version stored internally") + return self._version + + @property + def cursor(self): + if not self._cursor: + self._cursor = connection.cursor() + return self._cursor + + @property + def target_version(self): + if(len(self._fixes) == 0): + return self._base_version + else: + return self._base_version + len(self._fixes) - 1 + + + def add(self, update): + if type(update) == str or isinstance(update, UpdaterRoutine): + self._fixes.append(update) + else: + raise TypeError + + + def override_base_version(self, version): + """Override our starting point for old releases. New code should + not use this method""" + self._base_version = int(version) + + + @staticmethod + def get_current_version(): + """Queries the db for the latest version. Returns 0 for a + fresh install""" + + if "call_command" in dir(django.core.management): + django.core.management.call_command("syncdb", interactive=False, + verbosity=0) + else: + msg = "Unable to call syndb routine" + logger.warning(msg) + raise UpdaterError(msg) + + try: + iv = InternalDatabaseVersion.objects.latest() + version = iv.version + except InternalDatabaseVersion.DoesNotExist: + version = 0 + + return version + + + def syncdb(self): + """Function to do the syncronisation for the models""" + + self._version = Updater.get_current_version() + self._cursor = None + + + def increment(self): + """Increment schema version in the database""" + if self._version < self._base_version: + self._version = self._base_version + else: + self._version += 1 + InternalDatabaseVersion.objects.create(version=self._version) + + def apply(self): + """Apply pending schema changes""" + + if self.version >= self.target_version: + logger.debug("No updates for release %s" % self._release) + return + + logger.debug("Applying updates for release %s" % self._release) + + if self.version < self._base_version: + start = 0 + else: + start = self.version - self._base_version + 1 + + try: + for fix in self._fixes[start:]: + if type(fix) == str: + self.cursor.execute(fix) + elif isinstance(fix, UpdaterRoutine): + fix.run() + else: + logger.error("Invalid schema change at %s" % \ + self._version + 1) + self.increment() + logger.debug("Applied schema change number %s: %s" % \ + (self.version, fix)) + logger.info("Applied schema changes for release %s" % self._release) + except: + msg = "Failed to perform db update %s (%s): %s" % \ + (self._version + 1, fix, + traceback.format_exc().splitlines()[-1]) + logger.error(msg) + raise UpdaterError(msg) + + +class UnsupportedUpdate(Updater): + """Handle an unsupported update""" + + def __init__(self, release, version): + super(UnsupportedUpdate, self).__init__(release) + self._base_version = version + + def apply(self): + """Raise an exception if we're too old""" + + if self.version < self.target_version: + logger.error("Upgrade from release %s unsupported" % self._release) + raise SchemaTooOldError + + +def update_database(): + """method to search where we are in the revision + of the database models and update them""" + try: + logger.debug("Verifying database schema") + + updaters = [] + if hasattr(pkgutil, 'walk_packages'): + submodules = pkgutil.walk_packages(path=Changes.__path__) + else: + #python 2.4 + submodules = _walk_packages(Changes.__path__) + for loader, submodule, ispkg in submodules: + if ispkg: + continue + try: + updates = getattr( + __import__("%s.%s" % (Changes.__name__, submodule), + globals(), locals(), ['*']), + "updates") + updaters.append(updates()) + except ImportError: + logger.error("Failed to import %s" % submodule) + except AttributeError: + logger.warning("Module %s does not have an updates function" % + submodule) + except: + msg = "Failed to build updater for %s" % submodule + logger.error(msg, exc_info=1) + raise UpdaterError(msg) + + current_version = Updater.get_current_version() + logger.debug("Database version at %s" % current_version) + + updaters.sort() + if current_version > 0: + [u.apply() for u in updaters] + logger.debug("Database version at %s" % + Updater.get_current_version()) + else: + target = updaters[-1].target_version + InternalDatabaseVersion.objects.create(version=target) + logger.info("A new database was created") + + except UpdaterError: + raise + except ImproperlyConfigured: + logger.error("Django is not properly configured: %s" % + traceback.format_exc().splitlines()[-1]) + raise UpdaterError + except: + logger.error("Error while updating the database") + for x in traceback.format_exc().splitlines(): + logger.error(x) + raise UpdaterError |