Changeset 1314:41b85535ff5d

Timestamp:

07/13/09 17:50:37 (3 years ago)

Author:

s0undt3ch

Branch:

default

Message:

Cleaner implementation of database migrations that also supports plugin database migrations. So far only cli upgrades are working. Committing now because we're going to switch to the logging module for the messages.

Files:

• external-plugins/eric_the_fish/__init__.py (modified) (2 diffs)
• external-plugins/eric_the_fish/database.py (added)
• external-plugins/eric_the_fish/versions/001_Move_fortunes_to_the_database.py (added)
• scripts/manage-database (added)
• zine/_core.py (modified) (3 diffs)
• zine/application.py (modified) (2 diffs)
• zine/database.py (modified) (1 diff)
• zine/models.py (modified) (3 diffs)
• zine/templates/admin/perform_upgrade.html (added)
• zine/upgrades/__init__.py (added)
• zine/upgrades/customisation.py (added)
• zine/upgrades/versions/001_split_tables.py (added)
• zine/upgrades/versions/002_notification_subscriptions.py (added)
• zine/upgrades/versions/__init__.py (added)
• zine/upgrades/webapp.py (added)

external-plugins/eric_the_fish/__init__.py

@@ -56 +56 @@
 # here we do the same for the shared files (css, fish images and javascript)
 SHARED_FILES = join(dirname(__file__), 'shared')
+
+# here we do the same for our database upgrade's repository
+UPGRADES_REPO = dirname(__file__)
 
 # and that's just the list of skins we have.
@@ -119 +122 @@
     return {'fortune': choice(FORTUNES)}
 
+def register_repository():
+    print 'registering eric repo'
+    get_application().register_upgrade_repository('eric_the_fish', UPGRADES_REPO)
 
 def setup(app, plugin):
-    """This function is called by Zine in the application initialization
+    """This function is called by Zine in the application initialisation
     phase. Here we connect to the events and register our template paths,
     url rules, views etc.
     """
+
+    # we need to register eric's database upgrades repository
+#    app.connect_event('register-upgrade-repository', register_repository)
+    app.register_upgrade_repository(plugin, UPGRADES_REPO)
 
     # we want our fish to appear in the admin panel, so hook into the

zine/_core.py

@@ -27 +27 @@
     instance folder.
     """
+
+class InstanceUpgradeRequired(RuntimeError):
+    """Zine requires a database upgrade"""
 
 
@@ -60 +63 @@
         try:
             app.__init__(instance_folder)
+            app.upgrade_required
+        except InstanceUpgradeRequired:
+            from zine.upgrades.webapp import WebUpgrades
+            _application = app = WebUpgrades(app)
         except:
             # if an exception happened, tear down the application
@@ -92 +99 @@
                     if key not in preserve and not key.startswith('__'):
                         module.__dict__.pop(key, None)
-            elif name.startswith('zine.') and name != 'zine._core':
+            elif name.startswith('zine.') and name not in (
+                                'zine._core', 'zine.upgrades',
+                                'zine.upgrades.customisation'):
                 # get rid of the module
                 sys.modules.pop(name, None)

zine/application.py

@@ -638 +638 @@
                             self.__class__.__name__)
         self.instance_folder = path.abspath(instance_folder)
+        self.upgrade_lockfile = path.join(instance_folder,
+                                          '.upgrade_in_progress')
 
         # create the event manager, this is the first thing we have to
@@ -834 +836 @@
             self.list_parsers()
 
+        # Register Zine's upgrade repository
+        from zine.upgrades import REPOSITORY_PATH
+        self.register_upgrade_repository('Zine', REPOSITORY_PATH)
+        # Allow plugins to register their upgrade's repositories
+        emit_event('register-upgrade-repository')
+
         self.initialized = True
 
         #! called after the application and all plugins are initialized
         emit_event('application-setup-done')
+
+    def register_upgrade_repository(self, repo_id, repo_path):
+        """This function is responsible for adding upgrade repositories to the
+        database.
+        """
+        from zine.models import SchemaVersion
+        from zine.pluginsystem import Plugin
+        from zine.upgrades.customisation import Repository
+        if isinstance(repo_id, Plugin):
+            repo_id = repo_id.metadata.get('name')
+        Repository(repo_path, repo_id)
+        try:
+            sv = SchemaVersion.query.filter_by(repository_id=repo_id).first()
+            if not sv:
+                db.session.add(SchemaVersion(Repository(repo_path, repo_id)))
+                db.session.commit()
+        except (SQLAlchemyError, AttributeError):
+            # The schema_versions table does not yet exist. Let's create it
+            db.session.rollback()
+            from zine.database import metadata, schema_versions
+            metadata.bind = self.database_engine
+            if not schema_versions.exists():
+                schema_versions.create(self.database_engine)
+            db.session.add(SchemaVersion(Repository(repo_path, repo_id)))
+            db.session.commit()
+
+
+    @property
+    def upgrade_required(self):
+        from zine.models import SchemaVersion
+        from zine.upgrades.customisation import Repository
+
+        for sv in SchemaVersion.query.all():
+            repository = Repository(sv.repository_path, sv.repository_id)
+            try:
+                self.repository_has_upgrade(repository, sv)
+            except _core.InstanceUpgradeRequired:
+                # Set Zine in maintenance mode
+                cfg = self.cfg.edit()
+                cfg['maintenance_mode'] = True
+                cfg.commit()
+                raise _core.InstanceUpgradeRequired()
+
+        # We got here, let's check for a bad upgrade lockfile left behind
+        if path.isfile(self.upgrade_lockfile):
+            remove(self.upgrade_lockfile)
+
+    def repository_has_upgrade(self, repository, schema_version):
+        try:
+            print repository.__dict__, schema_version.version, repository.latest
+            if schema_version.version < repository.latest:
+                raise _core.InstanceUpgradeRequired()
+        except (SQLAlchemyError, AttributeError):
+            print 'WE EVEN GOT HERE???'
+            # The schema_versions table does not yet exist. Let's create it
+            db.session.rollback()
+            from zine.database import metadata, schema_versions
+            metadata.bind = self.database_engine
+            if not schema_versions.exists():
+                schema_versions.create(self.database_engine)
+            db.session.add(SchemaVersion(Repository(repo_path)))
+            db.session.commit()
+            raise _core.InstanceUpgradeRequired()
 
     @property

zine/database.py

@@ -251 +251 @@
 metadata = db.MetaData()
 
+schema_versions = db.Table('schema_versions', metadata,
+    db.Column('repository_id', db.String(255), primary_key=True),
+    db.Column('repository_path', db.Text),
+    db.Column('version', db.Integer)
+)
 
 users = db.Table('users', metadata,

zine/models.py

@@ -18 +18 @@
      post_categories, post_tags, tags, comments, groups, group_users, \
      privileges, user_privileges, group_privileges, texts, \
-     notification_subscriptions, db
+     notification_subscriptions, schema_versions, db
 from zine.utils import zeml
 from zine.utils.text import gen_slug, gen_timestamped_slug, build_tag_uri, \
@@ -177 +177 @@
     def authors(self):
         return self.filter_by(is_author=True)
+
+
+class SchemaVersion(object):
+    """Represents a database schema version."""
+
+    query = db.query_property(db.Query)
+
+    def __init__(self, repos, version=0):
+        self.repository_id = repos.config.get('repository_id')
+        self.repository_path = repos.path
+        self.version = version
 
 
@@ -1256 +1267 @@
 
 # connect the tables.
+db.mapper(SchemaVersion, schema_versions)
 db.mapper(User, users, properties={
     'id':               users.c.user_id,