0001-multitenant-remove-django-1.8-compatibility-code-fro.patch

Frédéric Péters, 09 août 2018 22:58

Voir les différences: en ligne côte à côte

Subject: [PATCH] multitenant: remove django < 1.8 compatibility code from
 commands (#25538)

 .../management/commands/__init__.py           |  33 ------
 .../management/commands/legacy/__init__.py    |   0
 .../commands/legacy/migrate_schemas.py        |  91 ---------------
 .../management/commands/list_tenants.py       |   1 -
 .../management/commands/migrate_schemas.py    |  22 +---
 .../commands/safemigrate_schemas.py           | 105 ------------------
 .../management/commands/sync_schemas.py       |  87 ---------------
 7 files changed, 3 insertions(+), 336 deletions(-)
 delete mode 100644 hobo/multitenant/management/commands/legacy/__init__.py
 delete mode 100644 hobo/multitenant/management/commands/legacy/migrate_schemas.py
 delete mode 100644 hobo/multitenant/management/commands/safemigrate_schemas.py
 delete mode 100644 hobo/multitenant/management/commands/sync_schemas.py

             else:
                 cmdclass = load_command_class(app_name, obj.COMMAND_NAME)
             if django.VERSION < (1, 8, 0):
                 # inherit the options from the original command
                 obj.option_list = cmdclass.option_list
                 obj.option_list += (
                     make_option("-d", "--domain", dest="domain"),
+                )
                 obj.option_list += (
                     make_option("-p", "--skip-public", dest="skip_public", action="store_true", default=False),
+                )
             # prepend the command's original help with the info about schemata iteration
             obj.help = "Calls %s for all registered schemata. You can use regular %s options. "\
                        "Original help for %s: %s" % (obj.COMMAND_NAME, obj.COMMAND_NAME, obj.COMMAND_NAME,
-...
     class InteractiveTenantOption(object):
         def __init__(self, *args, **kwargs):
             super(InteractiveTenantOption, self).__init__(*args, **kwargs)
             if django.VERSION < (1, 8, 0):
                 self.option_list += (
                     make_option("-d", "--domain", dest="domain", help="specify tenant domain"),
+                )
         def add_arguments(self, parser):
             parser.add_argument("-d", "--domain", dest="domain", help='specify tenant domain')
-...
         def __new__(cls, *args, **kwargs):
             obj = super(TenantWrappedCommand, cls).__new__(cls, *args, **kwargs)
             obj.command_instance = obj.COMMAND()
             obj.option_list = obj.command_instance.option_list
             return obj
         def add_arguments(self, parser):
-...
     class SyncCommon(BaseCommand):
         if django.VERSION < (1, 8, 0):
             option_list = (
                 make_option('--tenant', action='store_true', dest='tenant', default=False,
                             help='Tells Django to populate only tenant applications.'),
                 make_option('--shared', action='store_true', dest='shared', default=False,
                             help='Tells Django to populate only shared applications.'),
                 make_option('--app_label', action='store', dest='app_label', nargs='?',
                             help='App label of an application to synchronize the state.'),
                 make_option('--migration_name', action='store', dest='migration_name', nargs='?',
                             help=('Database state will be brought to the state after that '
                                   'migration. Use the name "zero" to unapply all migrations.')),
                 make_option("-d", "--domain", dest="domain"),
+            )
         def __init__(self, stdout=None, stderr=None, no_color=False):
             if django.VERSION >= (1, 8, 0):
                 super(SyncCommon, self).__init__(stdout, stderr, no_color)
-...
                 super(SyncCommon, self).__init__()
         def add_arguments(self, parser):
             # for django 1.8 and above
             parser.add_argument('--tenant', action='store_true', dest='tenant', default=False,
                         help='Tells Django to populate only tenant applications.')
             parser.add_argument('--shared', action='store_true', dest='shared', default=False,

     # this file derive from django-tenant-schemas
     #   Author: Bernardo Pires Carneiro
     #   Email: carneiro.be@gmail.com
     #   License: MIT license
     #   Home-page: http://github.com/bcarneiro/django-tenant-schemas
     from django.conf import settings
     from django.db import connection
     from south import migration
     from south.migration.base import Migrations
     from south.management.commands.migrate import Command as MigrateCommand
     from hobo.multitenant.middleware import TenantMiddleware
     from hobo.multitenant.management.commands import SyncCommon
     class Command(SyncCommon):
         help = "Migrate schemas with South"
         option_list = MigrateCommand.option_list + SyncCommon.option_list
         def handle(self, *args, **options):
             super(Command, self).handle(*args, **options)
             if self.sync_public:
                 self.migrate_public_apps()
             if self.sync_tenant:
                 self.migrate_tenant_apps(self.domain)
         def _set_managed_apps(self, included_apps, excluded_apps):
             """ while sync_schemas works by setting which apps are managed, on south we set which apps should be ignored """
             ignored_apps = []
             if excluded_apps:
                 for item in excluded_apps:
                     if item not in included_apps:
                         ignored_apps.append(item)
             for app in ignored_apps:
                 app_label = app.split('.')[-1]
                 settings.SOUTH_MIGRATION_MODULES[app_label] = 'ignore'
         def _save_south_settings(self):
             self._old_south_modules = None
             if hasattr(settings, "SOUTH_MIGRATION_MODULES") and settings.SOUTH_MIGRATION_MODULES is not None:
                 self._old_south_modules = settings.SOUTH_MIGRATION_MODULES.copy()
             else:
                 settings.SOUTH_MIGRATION_MODULES = dict()
         def _restore_south_settings(self):
             settings.SOUTH_MIGRATION_MODULES = self._old_south_modules
         def _clear_south_cache(self):
             for mig in list(migration.all_migrations()):
                 delattr(mig._application, "migrations")
             Migrations._clear_cache()
         def _migrate_schema(self, tenant):
             connection.set_tenant(tenant, include_public=False)
             MigrateCommand().execute(*self.args, **self.options)
         def migrate_tenant_apps(self, schema_name=None):
             self._save_south_settings()
             apps = self.tenant_apps or self.installed_apps
             self._set_managed_apps(included_apps=apps, excluded_apps=self.shared_apps)
             if schema_name:
                 self._notice("=== Running migrate for schema: %s" % schema_name)
                 connection.set_schema_to_public()
                 tenant = TenantMiddleware.get_tenant_by_hostname(schema_name)
                 self._migrate_schema(tenant)
             else:
                 all_tenants = TenantMiddleware.get_tenants()
                 if not all_tenants:
                     self._notice("No tenants found")
                 for tenant in all_tenants:
                     Migrations._dependencies_done = False  # very important, the dependencies need to be purged from cache
                     self._notice("=== Running migrate for schema %s" % tenant.schema_name)
                     self._migrate_schema(tenant)
             self._restore_south_settings()
         def migrate_public_apps(self):
             self._save_south_settings()
             apps = self.shared_apps or self.installed_apps
             self._set_managed_apps(included_apps=apps, excluded_apps=self.tenant_apps)
             self._notice("=== Running migrate for schema public")
             MigrateCommand().execute(*self.args, **self.options)
             self._clear_south_cache()
             self._restore_south_settings()

hobo/multitenant/management/commands/list_tenants.py
4	4	class Command(BaseCommand):
5	5	requires_model_validation = True
6	6	can_import_settings = True
7		option_list = BaseCommand.option_list
8	7
9	8	def handle(self, **options):
10	9	all_tenants = TenantMiddleware.get_tenants()

     import django
     from optparse import NO_DEFAULT
     if django.VERSION >= (1, 7, 0):
         from django.core.management.commands.migrate import Command as MigrateCommand
         from django.db.migrations.recorder import MigrationRecorder
     from django.core.management.commands.migrate import Command as MigrateCommand
     from django.db.migrations.recorder import MigrationRecorder
     from django.db import connection
     from django.conf import settings
-...
     class MigrateSchemasCommand(SyncCommon):
         help = "Updates database schema. Manages both apps with migrations and those without."
         def __init__(self, stdout=None, stderr=None, no_color=False):
             """
             Changes the option_list to use the options from the wrapped migrate command.
             """
             if django.VERSION <= (1, 10, 0):
                 self.option_list += MigrateCommand.option_list
             if django.VERSION >= (1, 8, 0):
                 super(MigrateSchemasCommand, self).__init__(stdout, stderr, no_color)
             else:
                 super(MigrateSchemasCommand, self).__init__()
         def add_arguments(self, parser):
             super(MigrateSchemasCommand, self).add_arguments(parser)
             command = MigrateCommand()
-...
         def _notice(self, output):
             self.stdout.write(self.style.NOTICE(output))
     if django.VERSION >= (1, 7, 0):
         Command = MigrateSchemasCommand
     else:
         from .legacy.migrate_schemas import Command
     Command = MigrateSchemasCommand

     # this file derive from django-tenant-schemas
     #   Author: Bernardo Pires Carneiro
     #   Email: carneiro.be@gmail.com
     #   License: MIT license
     #   Home-page: http://github.com/bcarneiro/django-tenant-schemas
     import django
     if django.VERSION < (1, 7, 0):
         from django.conf import settings
         from django.db import connection
         from south import migration
         from south.migration.base import Migrations
         from hobo.multitenant.middleware import TenantMiddleware
         from entrouvert.djommon.management.commands.safemigrate import Command as SafeMigrateCommand
         from hobo.multitenant.management.commands.sync_schemas import Command as MTSyncCommand
         from hobo.multitenant.management.commands.migrate_schemas import Command as MTMigrateCommand
     from hobo.multitenant.management.commands import SyncCommon
     class SafeMigrateCommand(SyncCommon):
         help = "Safely migrate schemas with South"
         option_list = MTMigrateCommand.option_list
         def handle(self, *args, **options):
             super(Command, self).handle(*args, **options)
             MTSyncCommand().execute(*args, **options)
             connection.set_schema_to_public()
             if self.sync_public:
                 self.fake_public_apps()
             if self.sync_tenant:
                 self.fake_tenant_apps(self.domain)
             connection.set_schema_to_public()
             MTMigrateCommand().execute(*args, **options)
         def _set_managed_apps(self, included_apps, excluded_apps):
             """ while sync_schemas works by setting which apps are managed, on south we set which apps should be ignored """
             ignored_apps = []
             if excluded_apps:
                 for item in excluded_apps:
                     if item not in included_apps:
                         ignored_apps.append(item)
             for app in ignored_apps:
                 app_label = app.split('.')[-1]
                 settings.SOUTH_MIGRATION_MODULES[app_label] = 'ignore'
         def _save_south_settings(self):
             self._old_south_modules = None
             if hasattr(settings, "SOUTH_MIGRATION_MODULES") and settings.SOUTH_MIGRATION_MODULES is not None:
                 self._old_south_modules = settings.SOUTH_MIGRATION_MODULES.copy()
             else:
                 settings.SOUTH_MIGRATION_MODULES = dict()
         def _restore_south_settings(self):
             settings.SOUTH_MIGRATION_MODULES = self._old_south_modules
         def _clear_south_cache(self):
             for mig in list(migration.all_migrations()):
                 delattr(mig._application, "migrations")
             Migrations._clear_cache()
         def _fake_schema(self, tenant):
             connection.set_tenant(tenant, include_public=False)
             SafeMigrateCommand().fake_if_needed()
         def fake_tenant_apps(self, schema_name=None):
             self._save_south_settings()
             apps = self.tenant_apps or self.installed_apps
             self._set_managed_apps(included_apps=apps, excluded_apps=self.shared_apps)
             if schema_name:
                 self._notice("=== Running fake_if_needed for schema: %s" % schema_name)
                 connection.set_schema_to_public()
                 tenant = TenantMiddleware.get_tenant_by_hostname(schema_name)
                 self._fake_schema(tenant)
             else:
                 all_tenants = TenantMiddleware.get_tenants()
                 if not all_tenants:
                     self._notice("No tenants found")
                 for tenant in all_tenants:
                     Migrations._dependencies_done = False  # very important, the dependencies need to be purged from cache
                     self._notice("=== Running fake_if_needed for schema %s" % tenant.schema_name)
                     self._fake_schema(tenant)
             self._restore_south_settings()
         def fake_public_apps(self):
             self._save_south_settings()
             apps = self.shared_apps or self.installed_apps
             self._set_managed_apps(included_apps=apps, excluded_apps=self.tenant_apps)
             self._notice("=== Running fake_if_needed for schema public")
             SafeMigrateCommand().fake_if_needed()
             self._clear_south_cache()
             self._restore_south_settings()
     if django.VERSION < (1, 7, 0):
         Command = SafeMigrateCommand
     else:
         raise RuntimeError('Django 1.7: please use migrate_schemas')

     # this file derive from django-tenant-schemas
     #   Author: Bernardo Pires Carneiro
     #   Email: carneiro.be@gmail.com
     #   License: MIT license
     #   Home-page: http://github.com/bcarneiro/django-tenant-schemas
     import django
     from django.core.management.base import CommandError
     from django.conf import settings
     from django.contrib.contenttypes.models import ContentType
     from django.db.models import get_apps, get_models
     if 'south' in settings.INSTALLED_APPS:
         from south.management.commands.syncdb import Command as SyncdbCommand
     else:
         from django.core.management.commands.syncdb import Command as SyncdbCommand
     from django.db import connection
     from hobo.multitenant.middleware import TenantMiddleware
     from hobo.multitenant.management.commands import SyncCommon
     class Command(SyncCommon):
         help = "Sync schemas based on TENANT_APPS and SHARED_APPS settings"
         option_list = SyncdbCommand.option_list + SyncCommon.option_list
         def handle(self, *args, **options):
             if django.VERSION >= (1, 7, 0):
                 raise CommandError('This command is only meant to be used for 1.6'
                                    ' and older version of django. For 1.7, use'
                                    ' `migrate_schemas` instead.')
             super(Command, self).handle(*args, **options)
             if "south" in settings.INSTALLED_APPS:
                 self.options["migrate"] = False
             # save original settings
             for model in get_models(include_auto_created=True):
                 setattr(model._meta, 'was_managed', model._meta.managed)
             ContentType.objects.clear_cache()
             if self.sync_public:
                 self.sync_public_apps()
             if self.sync_tenant:
                 self.sync_tenant_apps(self.domain)
             # restore settings
             for model in get_models(include_auto_created=True):
                 model._meta.managed = model._meta.was_managed
         def _set_managed_apps(self, included_apps):
             """ sets which apps are managed by syncdb """
             for model in get_models(include_auto_created=True):
                 model._meta.managed = False
             verbosity = int(self.options.get('verbosity'))
             for app_model in get_apps():
                 app_name = app_model.__name__.replace('.models', '')
                 if app_name in included_apps:
                     for model in get_models(app_model, include_auto_created=True):
                         model._meta.managed = model._meta.was_managed
                         if model._meta.managed and verbosity >= 3:
                             self._notice("=== Include Model: %s: %s" % (app_name, model.__name__))
         def _sync_tenant(self, tenant):
             self._notice("=== Running syncdb for schema: %s" % tenant.schema_name)
             connection.set_tenant(tenant, include_public=False)
             SyncdbCommand().execute(**self.options)
         def sync_tenant_apps(self, schema_name=None):
             apps = self.tenant_apps or self.installed_apps
             self._set_managed_apps(apps)
             if schema_name:
                 tenant = TenantMiddleware.get_tenant_by_hostname(schema_name)
                 self._sync_tenant(tenant)
             else:
                 all_tenants = TenantMiddleware.get_tenants()
                 if not all_tenants:
                     self._notice("No tenants found!")
                 for tenant in all_tenants:
                     self._sync_tenant(tenant)
         def sync_public_apps(self):
             self._notice("=== Running syncdb for schema public")
             apps = self.shared_apps or self.installed_apps
             self._set_managed_apps(apps)
             SyncdbCommand().execute(**self.options)
+    -

Projet

Général

Profil

Produits Entr'ouvert » Hobo

0001-multitenant-remove-django-1.8-compatibility-code-fro.patch