2892064154

Build # 2892064154

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/kobotoolbox/kpi/commit/<a class=hub.com/kobotoolbox/kpi/commit/<a class="double-link" href="https://git"><a class=hub.com/kobotoolbox/kpi/commit/<a class="double-link" href="https://git"><a class=hub.com/kobotoolbox/kpi/commit/<a class="double-link" href="https://git"><a class=hub.com/kobotoolbox/kpi/commit/98718c5fe9626b21810b5e1edae0f001a8aa2fa5">98718c5fe">&lt;a href=&quot;https://github.com/kobotoolbox/kpi/commit/</a><a class="double-link" href="https://github.com/kobotoolbox/kpi/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/kobotoolbox/kpi/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/kobotoolbox/kpi/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/kobotoolbox/kpi/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/kobotoolbox/kpi/commit/98718c5fe9626b21810b5e1edae0f001a8aa2fa5">98718c5fe</a><a href="https://github.com/kobotoolbox/kpi/commit/98718c5fe9626b21810b5e1edae0f001a8aa2fa5">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/kobotoolbox/kpi/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/kobotoolbox/kpi/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/kobotoolbox/kpi/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/kobotoolbox/kpi/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/kobotoolbox/kpi/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/kobotoolbox/kpi/commit/98718c5fe9626b21810b5e1edae0f001a8aa2fa5&quot;&gt;98718c5fe&lt;/a&gt;&lt;a href=&quot;https://github.com/kobotoolbox/kpi/commit/98718c5fe9626b21810b5e1edae0f001a8aa2fa5&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/kobotoolbox/kpi/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/kobotoolbox/kpi/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&am... (continued)

Pull Request Pull Request #3978: Avoid crash when kobocat database does not exist

Run Details

2161 of 3556 branches covered (60.77%)

7 of 7 new or added lines in 1 file covered. (100.0%)

9264 of 12180 relevant lines covered (76.06%)

1.52 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

22.33

/kpi/utils/two_database_configuration_checker.py

# coding: utf-8
from django.conf import settings
from django.core.checks import Error
from django.db import connections
from django.db.utils import OperationalError
from django.utils.translation import gettext as t

from kpi.management.commands.is_database_empty import (
    test_table_exists_and_has_any_row,
)


class TwoDatabaseConfigurationChecker:
    """
    This class detects certain problems that might arise when upgrading an
    installation that used a single, shared database for both KPI and KoBoCAT
    to a new configuration with separate databases for each Django project.

    If any issue is found, the application should be stopped to avoid a messy
    situation where KPI data from two databases would have to be merged
    together, as opposed to simply copied from the old database to the new one.
    """

    HELP_PAGE = 'https://community.kobotoolbox.org/t/upgrading-to-separate-databases-for-kpi-and-kobocat/7202'
    GUIDANCE_TEMPLATE = 'For assistance, please visit {HELP_PAGE}.'

    def __init__(self):
        self.errors = []

    @classmethod
    def __str__(cls):
        return cls.__name__

    @property
    def guidance_message(self):
        return ' ' + t(self.GUIDANCE_TEMPLATE).format(HELP_PAGE=self.HELP_PAGE)

    def check_for_two_databases(self):
        if sorted(list(settings.DATABASES.keys())) != ['default', 'kobocat']:
            self.errors.append(Error(
                t('Exactly two databases must be configured'),
                hint=t('KPI and KoBoCAT must each have their own databases. '
                       "Configure the KPI database as 'default' and the "
                       "KoBoCAT database as 'kobocat'.")
                      + self.guidance_message,
                obj=self,
                id='KPI.E021',
            ))
            return False
        return True

    def check_for_distinct_databases(self):
        DATABASE_IDENTIFYING_KEYS = ['HOST', 'PORT', 'NAME']
        kpi_db = settings.DATABASES['default']
        kc_db = settings.DATABASES['kobocat']
        databases_distinct = False
        for key_to_check in DATABASE_IDENTIFYING_KEYS:
            if kpi_db[key_to_check] != kc_db[key_to_check]:
                databases_distinct = True
                break
        if not databases_distinct:
            self.errors.append(Error(
                t('KPI may not share a database with KoBoCAT'),
                hint=t('KPI and KoBoCAT must each have their own databases.')
                       + self.guidance_message,
                obj=self,
                id='KPI.E022',
            ))
            return False
        return True

    def check_for_kpi_data_in_kobocat_database(self):
        """
        If there's no KPI data in the KoBoCAT database, there's no need to run
        `check_for_migration_from_shared_database()`
        """
        connection = connections['kobocat']
        try:
            with connection.cursor() as cursor:
                return test_table_exists_and_has_any_row(cursor, 'kpi_asset')
        except OperationalError as e:
            # It's possible (and okay) that this runs before the kobocat
            # database even exists
            if str(e).strip().endswith('does not exist'):
                return False

    def check_for_migration_from_shared_database(self):
        def db_contains_app_migrations(db_connection, app):
            # Does the migrations table exist?
            with db_connection.cursor() as cursor:
                cursor.execute(
                    '''SELECT (1) AS "exists" FROM "pg_tables" '''
                    '''WHERE "tablename" = 'django_migrations' '''
                    '''LIMIT 1;'''
                )
                if not cursor.fetchone():
                    return False
            # Does the migrations table contain any KPI migration?
            with db_connection.cursor() as cursor:
                cursor.execute(
                    '''SELECT (1) AS "exists" FROM "django_migrations" '''
                    '''WHERE "app" = %s '''
                    '''LIMIT 1;''', [app]
                )
                if not cursor.fetchone():
                    return False
            return True

        kpi_connection = connections['default']
        kc_connection = connections['kobocat']
        kpi_app = 'kpi'
        kc_app = 'logger'

        if db_contains_app_migrations(kc_connection, kpi_app):
            # This was formerly a single-database setup, since the KC database
            # contains KPI migrations
            if not db_contains_app_migrations(kpi_connection, kc_app):
                # When migrating from the single, shared database setup:
                #   1. A new database for KPI should have been created;
                #   2. Certain tables, including `django_migrations`, should
                #      have been copied from the original, shared database to
                #      the new one;
                #   3. KoBoCAT should have been configured to continue using
                #      the original database;
                #   4. KPI should have been configured to use the newly-created
                #      database;
                #   5. Because `django_migrations` should have been copied from
                #      the original database to the new one, we should see
                #      KoBoCAT migrations in the KPI database.
                # Since we _do not_ see any KoBoCAT migrations, stop now and
                # get the human to fix their installation.
                self.errors.append(Error(
                    t('Incomplete migration from shared-database installation'),
                    hint=t('The KoBoCAT database was originally shared by '
                           'KPI, but the KPI tables were not copied from that '
                           'shared database to the new, KPI-only database.')
                         + self.guidance_message,
                    obj=self,
                    id='KPI.E023',
                ))
                return False
        return True

    def do_checks(self, app_configs, **kwargs):
        checks = [
            self.check_for_two_databases,
            self.check_for_distinct_databases,
            self.check_for_kpi_data_in_kobocat_database,
            self.check_for_migration_from_shared_database,
        ]
        for check in checks:
            if not check():
                # Each check depends on the one before; it makes no sense to
                # continue any further
                break
        return self.errors

    def as_check(self):
        """ For use with django.core.checks.register() """

        def wrapper(*args, **kwargs):
            return self.do_checks(*args, **kwargs)
        return wrapper

1	# coding: utf-8
2	from django.conf import settings	2✔
3	from django.core.checks import Error	2✔
4	from django.db import connections	2✔
5	from django.db.utils import OperationalError	2✔
6	from django.utils.translation import gettext as t	2✔
7
8	from kpi.management.commands.is_database_empty import (	2✔
9	test_table_exists_and_has_any_row,
10	)
11
12
13	class TwoDatabaseConfigurationChecker:	2✔
14	"""
15	This class detects certain problems that might arise when upgrading an
16	installation that used a single, shared database for both KPI and KoBoCAT
17	to a new configuration with separate databases for each Django project.
18
19	If any issue is found, the application should be stopped to avoid a messy
20	situation where KPI data from two databases would have to be merged
21	together, as opposed to simply copied from the old database to the new one.
22	"""
23
24	HELP_PAGE = 'https://community.kobotoolbox.org/t/upgrading-to-separate-databases-for-kpi-and-kobocat/7202'	2✔
25	GUIDANCE_TEMPLATE = 'For assistance, please visit {HELP_PAGE}.'	2✔
26
27	def __init__(self):	2✔
28	self.errors = []	2✔
29
30	@classmethod	2✔
31	def __str__(cls):	2✔
32	return cls.__name__	×
33
34	@property	2✔
35	def guidance_message(self):	2✔
36	return ' ' + t(self.GUIDANCE_TEMPLATE).format(HELP_PAGE=self.HELP_PAGE)	×
37
38	def check_for_two_databases(self):	2✔
39	if sorted(list(settings.DATABASES.keys())) != ['default', 'kobocat']:	×
40	self.errors.append(Error(	×
41	t('Exactly two databases must be configured'),
42	hint=t('KPI and KoBoCAT must each have their own databases. '
43	"Configure the KPI database as 'default' and the "
44	"KoBoCAT database as 'kobocat'.")
45	+ self.guidance_message,
46	obj=self,
47	id='KPI.E021',
48	))
49	return False	×
50	return True	×
51
52	def check_for_distinct_databases(self):	2✔
53	DATABASE_IDENTIFYING_KEYS = ['HOST', 'PORT', 'NAME']	×
54	kpi_db = settings.DATABASES['default']	×
55	kc_db = settings.DATABASES['kobocat']	×
56	databases_distinct = False	×
57	for key_to_check in DATABASE_IDENTIFYING_KEYS:	×
58	if kpi_db[key_to_check] != kc_db[key_to_check]:	×
59	databases_distinct = True	×
60	break	×
61	if not databases_distinct:	×
62	self.errors.append(Error(	×
63	t('KPI may not share a database with KoBoCAT'),
64	hint=t('KPI and KoBoCAT must each have their own databases.')
65	+ self.guidance_message,
66	obj=self,
67	id='KPI.E022',
68	))
69	return False	×
70	return True	×
71
72	def check_for_kpi_data_in_kobocat_database(self):	2✔
73	"""
74	If there's no KPI data in the KoBoCAT database, there's no need to run
75	`check_for_migration_from_shared_database()`
76	"""
77	connection = connections['kobocat']	×
78	try:	×
79	with connection.cursor() as cursor:	×
80	return test_table_exists_and_has_any_row(cursor, 'kpi_asset')	×
81	except OperationalError as e:	×
82	# It's possible (and okay) that this runs before the kobocat
83	# database even exists
84	if str(e).strip().endswith('does not exist'):	×
85	return False	×
86
87	def check_for_migration_from_shared_database(self):	2✔
88	def db_contains_app_migrations(db_connection, app):	×
89	# Does the migrations table exist?
90	with db_connection.cursor() as cursor:	×
91	cursor.execute(	×
92	'''SELECT (1) AS "exists" FROM "pg_tables" '''
93	'''WHERE "tablename" = 'django_migrations' '''
94	'''LIMIT 1;'''
95	)
96	if not cursor.fetchone():	×
97	return False	×
98	# Does the migrations table contain any KPI migration?
99	with db_connection.cursor() as cursor:	×
100	cursor.execute(	×
101	'''SELECT (1) AS "exists" FROM "django_migrations" '''
102	'''WHERE "app" = %s '''
103	'''LIMIT 1;''', [app]
104	)
105	if not cursor.fetchone():	×
106	return False	×
107	return True	×
108
109	kpi_connection = connections['default']	×
110	kc_connection = connections['kobocat']	×
111	kpi_app = 'kpi'	×
112	kc_app = 'logger'	×
113
114	if db_contains_app_migrations(kc_connection, kpi_app):	×
115	# This was formerly a single-database setup, since the KC database
116	# contains KPI migrations
117	if not db_contains_app_migrations(kpi_connection, kc_app):	×
118	# When migrating from the single, shared database setup:
119	# 1. A new database for KPI should have been created;
120	# 2. Certain tables, including `django_migrations`, should
121	# have been copied from the original, shared database to
122	# the new one;
123	# 3. KoBoCAT should have been configured to continue using
124	# the original database;
125	# 4. KPI should have been configured to use the newly-created
126	# database;
127	# 5. Because `django_migrations` should have been copied from
128	# the original database to the new one, we should see
129	# KoBoCAT migrations in the KPI database.
130	# Since we _do not_ see any KoBoCAT migrations, stop now and
131	# get the human to fix their installation.
132	self.errors.append(Error(	×
133	t('Incomplete migration from shared-database installation'),
134	hint=t('The KoBoCAT database was originally shared by '
135	'KPI, but the KPI tables were not copied from that '
136	'shared database to the new, KPI-only database.')
137	+ self.guidance_message,
138	obj=self,
139	id='KPI.E023',
140	))
141	return False	×
142	return True	×
143
144	def do_checks(self, app_configs, **kwargs):	2✔
145	checks = [	×
146	self.check_for_two_databases,
147	self.check_for_distinct_databases,
148	self.check_for_kpi_data_in_kobocat_database,
149	self.check_for_migration_from_shared_database,
150	]
151	for check in checks:	×
152	if not check():	×
153	# Each check depends on the one before; it makes no sense to
154	# continue any further
155	break	×
156	return self.errors	×
157
158	def as_check(self):	2✔
159	""" For use with django.core.checks.register() """
160
161	def wrapper(args, *kwargs):	2✔
162	return self.do_checks(args, *kwargs)	×
163	return wrapper	2✔

kobotoolbox / kpi / 2892064154

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous