def upgrade(v1_database, v2_database):
report = UpgradeStepReport()
# Applies to both yum and iso importers
repo_importers = v2_database.repo_importers.find()
for repo_importer in repo_importers:
repo_working_dir = repos.importer_working_dir(
repo_importer['importer_type_id'], repo_importer['repo_id'])
# CA certificate
if repo_importer['config'].get('ssl_ca_cert', None):
filename = os.path.join(repo_working_dir, 'ssl_ca_cert')
f = open(filename, 'w')
f.write(repo_importer['config']['ssl_ca_cert'])
f.close()
# Client Certificate
if repo_importer['config'].get('ssl_client_cert', None):
filename = os.path.join(repo_working_dir, 'ssl_client_cert')
f = open(filename, 'w')
f.write(repo_importer['config']['ssl_client_cert'])
f.close()
report.succeeded()
return report
def setUp(self):
super(MainTests, self).setUp()
# Mock out the DB upgrade calls
self.mock_db_upgrade_call_1 = mock.MagicMock().upgrade
self.mock_db_upgrade_call_1.return_value = UpgradeStepReport()
self.mock_db_upgrade_call_1.return_value.succeeded()
self.mock_db_upgrade_call_1.return_value.message(
'Upgrading collection 1')
self.mock_db_upgrade_call_1.return_value.warning(
'Small problem with collection 3')
self.mock_db_upgrade_calls = [(self.mock_db_upgrade_call_1, 'Mock 1')]
# Mock out the filesystem upgrade calls
self.mock_fs_upgrade_call_1 = mock.MagicMock().upgrade
self.mock_fs_upgrade_call_1.return_value = UpgradeStepReport()
self.mock_fs_upgrade_call_1.return_value.succeeded()
self.mock_fs_upgrade_call_1.return_value.message(
'Upgrading filesystem')
self.mock_fs_upgrade_call_1.return_value.warning('File not found')
self.mock_fs_upgrade_calls = [(self.mock_fs_upgrade_call_1, 'Mock 1')]
# Assemble the upgrader with the mock calls
self.upgrader = main.Upgrader(
stream_file=STREAM_FILENAME,
prod_db_name=V1_DB_NAME,
tmp_db_name=TMP_DB_NAME,
db_upgrade_calls=self.mock_db_upgrade_calls,
files_upgrade_calls=self.mock_fs_upgrade_calls)
def upgrade(v1_database, v2_database):
report = UpgradeStepReport()
# I expected the return value from these calls to be more meaningful.
# As it turned out, nearly all of them simply return True. I didn't rip
# out the result flags yet in case testing shows that they'll be useful,
# but don't be surprised when this looks kinda pointless after looking at
# the individual upgrade methods.
# jdob, Nov 8, 2012
init_types_success = _initialize_content_types(v2_database)
init_associations_success = _initialize_association_collection(v2_database)
rpms_success = _rpms(v1_database, v2_database, report)
srpms_success = _srpms(v1_database, v2_database, report)
drpms_success = _drpms(v1_database, v2_database, report)
errata_success = _errata(v1_database, v2_database, report)
groups_success = _package_groups(v1_database, v2_database, report)
categories_success = _package_group_categories(v1_database, v2_database, report)
distributions_success = _distributions(v1_database, v2_database, report)
iso_success = _isos(v1_database, v2_database, report)
report.success = (init_types_success and init_associations_success and
rpms_success and srpms_success and drpms_success and
groups_success and categories_success and
errata_success and distributions_success and iso_success)
return report
def upgrade(v1_database, v2_database):
report = UpgradeStepReport()
# I expected the return value from these calls to be more meaningful.
# As it turned out, nearly all of them simply return True. I didn't rip
# out the result flags yet in case testing shows that they'll be useful,
# but don't be surprised when this looks kinda pointless after looking at
# the individual upgrade methods.
# jdob, Nov 8, 2012
init_types_success = _initialize_content_types(v2_database)
init_associations_success = _initialize_association_collection(v2_database)
rpms_success = _rpms(v1_database, v2_database, report)
srpms_success = _srpms(v1_database, v2_database, report)
drpms_success = _drpms(v1_database, v2_database, report)
errata_success = _errata(v1_database, v2_database, report)
groups_success = _package_groups(v1_database, v2_database, report)
categories_success = _package_group_categories(v1_database, v2_database,
report)
distributions_success = _distributions(v1_database, v2_database, report)
iso_success = _isos(v1_database, v2_database, report)
report.success = (init_types_success and init_associations_success
and rpms_success and srpms_success and drpms_success
and groups_success and categories_success
and errata_success and distributions_success
and iso_success)
return report
def upgrade(v1_database, v2_database):
report = UpgradeStepReport()
rpms_success = _rpms(v1_database, v2_database, report)
drpms_success = _drpms(v1_database, v2_database, report)
report.success = (rpms_success and drpms_success)
return report
def upgrade(v1_database, v2_database):
# Given the changes in v2, the task history and snapshots are simply not
# going to be copied into the v2 database.
report = UpgradeStepReport()
report.succeeded()
return report
def upgrade(v1_database, v2_database):
report = UpgradeStepReport()
rpms_success = _rpms(v1_database, v2_database, report)
drpms_success = _drpms(v1_database, v2_database, report)
report.success = (rpms_success and drpms_success)
return report
def upgrade(v1_database, v2_database):
# The events collection is used for the auditing capabilities which were
# disabled in v1, so there's nothing to bother copying here.
report = UpgradeStepReport()
report.succeeded()
return report
def upgrade(v1_database, v2_database):
_roles(v1_database, v2_database)
v1_consumer_users = _users(v1_database, v2_database)
_permissions(v1_database, v2_database, v1_consumer_users)
report = UpgradeStepReport()
report.succeeded()
return report
def upgrade(v1_database, v2_database):
report = UpgradeStepReport()
group_success = _repo_groups(v1_database, v2_database, report)
sync_schedule_success = _sync_schedules(v1_database, v2_database, report)
report.success = (group_success and sync_schedule_success)
return report
def upgrade(v1_database, v2_database):
_roles(v1_database, v2_database)
v1_consumer_users = _users(v1_database, v2_database)
_permissions(v1_database, v2_database, v1_consumer_users)
report = UpgradeStepReport()
report.succeeded()
return report
def upgrade(v1_database, v2_database):
report = UpgradeStepReport()
clone_success = _handle_clones(v1_database, v2_database, report)
group_success = _repo_groups(v1_database, v2_database, report)
sync_schedule_success = _sync_schedules(v1_database, v2_database, report)
report.success = (clone_success and group_success
and sync_schedule_success)
return report
def upgrade(v1_database, v2_database):
# At the time of this upgrade, we don't know what CDS implementation will
# look like in v2. There's a really good chance that it'll look so
# drastically different on the CDS side that it won't be migratable anyway,
# so we're not copying anything CDS-related from the v1 database into
# the v2.
#
# tl;dr - Intentionally a no-op
report = UpgradeStepReport()
report.succeeded()
return report
def upgrade(v1_database, v2_database):
"""
Corrects the permissions of the v2 content filesystem.
Databases are unused but necessary for the upgrade API.
"""
report = UpgradeStepReport()
for dir in DIRS:
success = False
try:
exit_code = os.system('chown -R apache:apache %s' % dir)
success = (exit_code == 0)
except:
pass
if not success:
report.error(_('Could not correct permissions for directory: %(d)s') % {'d' : dir})
report.failed()
if len(report.errors) == 0:
report.succeeded()
return report
def upgrade(v1_database, v2_database):
# Instead of having to worry about having the consumers and bindings added
# atomically, they will be added as separate steps. There's a slight
# duplication in queries with this approach, but it's very minimal and
# beats having to account for the case where a consumer was ported but
# something stopped its bindings.
_consumer_history(v1_database, v2_database)
_consumers(v1_database, v2_database)
report = UpgradeStepReport()
report.succeeded()
return report
def upgrade(v1_database, v2_database):
# This is written after the yum repository upgrade and will use similar
# patterns. Rather than rewrite all of the comments here, please check
# that file for more information if anything looks confusing.
report = UpgradeStepReport()
repo_success = _repos(v1_database, v2_database)
importer_success = _repo_importers(v1_database, v2_database, report)
distributor_success = _repo_distributors(v1_database, v2_database, report)
report.success = (repo_success and importer_success and distributor_success)
return report
def upgrade(v1_database, v2_database):
# Instead of having to worry about having the consumers and bindings added
# atomically, they will be added as separate steps. There's a slight
# duplication in queries with this approach, but it's very minimal and
# beats having to account for the case where a consumer was ported but
# something stopped its bindings.
_consumer_history(v1_database, v2_database)
_consumers(v1_database, v2_database)
_consumer_groups(v1_database, v2_database)
report = UpgradeStepReport()
report.succeeded()
return report
def upgrade(v1_database, v2_database):
# This is written after the yum repository upgrade and will use similar
# patterns. Rather than rewrite all of the comments here, please check
# that file for more information if anything looks confusing.
report = UpgradeStepReport()
repo_success = _repos(v1_database, v2_database)
importer_success = _repo_importers(v1_database, v2_database, report)
distributor_success = _repo_distributors(v1_database, v2_database, report)
report.success = (repo_success and importer_success
and distributor_success)
return report
def upgrade(v1_database, v2_database):
report = UpgradeStepReport()
# Idempotency: Don't bother; worst case we recalculate.
repo_coll = v2_database.repos
ass_coll = v2_database.repo_content_units
v2_repos = repo_coll.find()
for v2_repo in v2_repos:
spec = {'repo_id' : v2_repo['id']}
unit_count = ass_coll.find(spec).count()
v2_repo['content_unit_count'] = unit_count
repo_coll.save(v2_repo, safe=True)
report.succeeded()
return report
def upgrade(v1_database, v2_database):
report = UpgradeStepReport()
tracker_coll = v2_database.migration_trackers
# Idempotency: By name, make sure it's not present
existing_name_list = tracker_coll.find({}, {'name' : 1})
existing_names = [n['name'] for n in existing_name_list]
migrate_names = [n for n in MIGRATION_PACKAGES if n not in existing_names]
for pkg in migrate_names:
tracker = {
'name' : pkg,
'version' : 0,
}
tracker_coll.insert(tracker, safe=True)
report.succeeded()
return report
def upgrade(v1_database, v2_database):
# It's very important that each repository have its associated importer
# and distributor created. Each will be done in its own pass, allowing us
# to use idempotency checks instead of attempting to ensure a transaction
# across the three creates. The idea is that if one of these fails to
# get created on a run of the upgrade, the next time it is run it will
# be created, assuming the second run will have fixed any errors that
# arose due to data in the db already (which shouldn't happen assuming we
# QE this properly) or because the user aborted the upgrade.
report = UpgradeStepReport()
repo_success = _repos(v1_database, v2_database)
importer_success = _repo_importers(v1_database, v2_database, report)
distributor_success = _repo_distributors(v1_database, v2_database, report)
report.success = (repo_success and importer_success and
distributor_success)
return report
def test_rpms(self):
# Test
report = UpgradeStepReport()
result = units._rpms(self.v1_test_db.database, self.tmp_test_db.database, report)
# Verify
self.assertTrue(result)
v1_rpms = self.v1_test_db.database.packages.find({'arch' : {'$ne' : 'src'}}).sort('filename')
self._assert_upgrade(v1_rpms)
self._assert_associations(self.tmp_test_db.database.units_rpm, 'rpm', {'arch' : {'$ne' : 'src'}})
def upgrade(v1_database, v2_database):
"""
Deletes the v1 directories that are no longer used. Needless to say, this
upgrade should be done last in the series of filesystem upgrades.
Databases are unused but necessary for the API into these upgrade scripts.
"""
report = UpgradeStepReport()
for dir in CLEAN_UP_DIRS:
# Some of the content dirs aren't created until used, so make sure not
# to tank if they aren't.
if not os.path.exists(dir):
continue
try:
shutil.rmtree(dir)
except Exception, e:
report.warning(_('Unable to delete directory: %(d)s') % dir)
def upgrade(v1_database, v2_database):
"""
Deletes the v1 directories that are no longer used. Needless to say, this
upgrade should be done last in the series of filesystem upgrades.
Databases are unused but necessary for the API into these upgrade scripts.
"""
report = UpgradeStepReport()
for dir in CLEAN_UP_DIRS:
# Some of the content dirs aren't created until used, so make sure not
# to tank if they aren't.
if not os.path.exists(dir):
continue
try:
shutil.rmtree(dir)
except Exception, e:
report.warning(_('Unable to delete directory: %(d)s') % dir)
def test_main_with_partial_error(self):
# Setup
m = mock.MagicMock()
m.call_1.return_value = UpgradeStepReport()
m.call_1.return_value.succeeded()
m.call_2.return_value = UpgradeStepReport()
m.call_2.return_value.failed()
m.call_3.return_value = UpgradeStepReport()
m.call_3.return_value.succeeded()
self.upgrader.db_upgrade_calls = (
(m.call_1, 'Mock 1'),
(m.call_2, 'Mock 2'),
(m.call_3, 'Mock 3'),
)
# Test
try:
self.upgrader.upgrade()
self.fail()
except main.StepException, e:
self.assertEqual('Mock 2', e[0])
def upgrade(v1_database, v2_database):
report = UpgradeStepReport()
# Idempotency: Each of the *_working_dir calls below will check for the
# directory's existence first, so there's nothing special to do here.
# Importers
all_importers = v2_database.repo_importers.find({})
for i in all_importers:
repo_id = i['repo_id']
importer_type_id = i['importer_type_id']
importer_working_dir(importer_type_id, repo_id)
# Distributors
all_distributors = v2_database.repo_distributors.find({})
for d in all_distributors:
repo_id = d['repo_id']
distributor_type_id = d['distributor_type_id']
distributor_working_dir(distributor_type_id, repo_id)
report.succeeded()
return report
def upgrade(v1_database, v2_database):
report = UpgradeStepReport()
# Idempotency: Each of the *_working_dir calls below will check for the
# directory's existence first, so there's nothing special to do here.
# Importers
all_importers = v2_database.repo_importers.find({})
for i in all_importers:
repo_id = i["repo_id"]
importer_type_id = i["importer_type_id"]
importer_working_dir(importer_type_id, repo_id)
# Distributors
all_distributors = v2_database.repo_distributors.find({})
for d in all_distributors:
repo_id = d["repo_id"]
distributor_type_id = d["distributor_type_id"]
distributor_working_dir(distributor_type_id, repo_id)
report.succeeded()
return report
def test_isos(self):
report = UpgradeStepReport()
isos.V1_DIR_ISO = "%s/%s" % (V1_TEST_FILESYSTEM, isos.V1_DIR_ISO)
isos.DIR_ISOS = "%s/%s" % (V2_TEST_FILESYSTEM, isos.DIR_ISOS)
v1_isos_list_pre_upgrade = get_files_in_dir('*.iso', isos.V1_DIR_ISO)
status = isos._isos(self.v1_test_db.database, self.v2_test_db.database,
report)
self.assertTrue(status)
for v1_path in v1_isos_list_pre_upgrade:
v2_path = "%s/%s" % (isos.DIR_ISOS, v1_path.split(
isos.V1_DIR_ISO)[-1])
self.assertTrue(os.path.exists(v2_path))
self.assertEquals(len(report.errors), 0)
self.assertTrue(report.succeeded)
def test_drpms(self):
report = UpgradeStepReport()
if not rpms.V1_DIR_RPMS.startswith(V1_TEST_FILESYSTEM):
rpms.V1_DIR_RPMS = "%s/%s" % (V1_TEST_FILESYSTEM, rpms.V1_DIR_RPMS)
rpms.DIR_DRPM = "%s/%s" % (V2_TEST_FILESYSTEM, rpms.DIR_DRPM)
status = rpms._drpms(self.v1_test_db.database,
self.v2_test_db.database, report)
self.assertTrue(status)
v2_rpms_list = get_files_in_dir('*.drpm',
os.path.join(rpms.DIR_DRPM, "drpms"))
self.assertEquals(18, len(v2_rpms_list))
self.assertEquals(len(report.errors), 0)
self.assertTrue(report.succeeded)
def test_srpms_idempotency(self):
# Test
report = UpgradeStepReport()
units._srpms(self.v1_test_db.database, self.tmp_test_db.database, report)
result = units._srpms(self.v1_test_db.database, self.tmp_test_db.database, report)
# Verify
self.assertTrue(result)
v1_rpms = self.v1_test_db.database.packages.find({'arch' : 'src'})
v2_rpms = self.tmp_test_db.database.units_rpm.find()
self.assertEqual(v1_rpms.count(), v2_rpms.count())
self._assert_associations(self.tmp_test_db.database.units_srpm, 'srpm', {'arch' : 'src'})
def test_drpms(self):
# Test
report = UpgradeStepReport()
result = units._drpms(self.v1_test_db.database, self.tmp_test_db.database, report)
# Verify
self.assertTrue(result)
v1_drpms = []
deltarpms = presto_parser.get_deltas(self.v1_test_db.database.repos.find_one({'id' : 'test_drpm_repo'}))
for nevra, dpkg in deltarpms.items():
for drpm in dpkg.deltas.values():
v1_drpms.append(drpm)
self._assert_upgrade(v1_drpms)
self._assert_associations()
def upgrade(v1_database, v2_database):
report = UpgradeStepReport()
# Applies to both yum and iso importers
repo_importers = v2_database.repo_importers.find()
for repo_importer in repo_importers:
repo_working_dir = repos.importer_working_dir(repo_importer['importer_type_id'], repo_importer['repo_id'])
# CA certificate
if repo_importer['config'].get('ssl_ca_cert', None):
filename = os.path.join(repo_working_dir, 'ssl_ca_cert')
f = open(filename, 'w')
f.write(repo_importer['config']['ssl_ca_cert'])
f.close()
# Client Certificate
if repo_importer['config'].get('ssl_client_cert', None):
filename = os.path.join(repo_working_dir, 'ssl_client_cert')
f = open(filename, 'w')
f.write(repo_importer['config']['ssl_client_cert'])
f.close()
report.succeeded()
return report
def test_iso_idempotency(self):
# Setup
report = UpgradeStepReport()
units._initialize_content_types(self.tmp_test_db.database)
units._isos(self.v1_test_db.database, self.tmp_test_db.database, report)
# Test
success = units._isos(self.v1_test_db.database, self.tmp_test_db.database, report)
# Verify
self.assertTrue(success)
v1_count = self.v1_test_db.database.file.find().count()
v2_count = self.tmp_test_db.database.units_iso.find().count()
self.assertEqual(v1_count, v2_count)
def test_groups(self):
# Test
report = UpgradeStepReport()
result = units._package_groups(self.v1_test_db.database, self.tmp_test_db.database, report)
# Verify
self.assertTrue(result)
v1_repo_group_tuples = []
for v1_repo in self.v1_test_db.database.repos.find({}, {'id' : 1, 'packagegroups' : 1}):
for group_id in v1_repo['packagegroups'].keys():
v1_repo_group_tuples.append( (v1_repo['id'], group_id) )
v2_repo_group_tuples = [ (x['repo_id'], x['id']) for x in
self.tmp_test_db.database.units_package_group.find({}, {'repo_id': 1, 'id' : 1}) ]
v1_repo_group_tuples.sort()
v2_repo_group_tuples.sort()
self.assertEqual(v1_repo_group_tuples, v2_repo_group_tuples)
for v1_repo in self.v1_test_db.database.repos.find({}, {'id' : 1, 'packagegroups' : 1}):
for group_id in v1_repo.get('packagegroups', {}).keys():
# Verify the group itself
v1_group = v1_repo['packagegroups'][group_id]
v2_group = self.tmp_test_db.database.units_package_group.find_one({'repo_id' : v1_repo['id'], 'id' : group_id})
self.assertTrue(v2_group is not None)
self.assertTrue(isinstance(v2_group['_id'], basestring))
self.assertEqual(v2_group['_storage_path'], None)
self.assertEqual(v2_group['_content_type_id'], 'package_group')
for k in ('conditional_package_names', 'default', 'default_package_names',
'description', 'display_order', 'id', 'langonly', 'mandatory_package_names',
'name', 'optional_package_names', 'translated_description',
'translated_name', 'user_visible'):
self.assertEqual(v1_group[k], v2_group[k], msg='Incorrect key: %s' % k)
# Make sure an association exists
ass_query = {'repo_id' : v1_repo['id'],
'unit_id' : v2_group['_id'],
'unit_type_id' : 'package_group'}
association = self.tmp_test_db.database.repo_content_units.find_one(ass_query)
self.assertTrue(association is not None)
self.assertEqual(association['owner_type'], units.DEFAULT_OWNER_TYPE)
self.assertEqual(association['owner_id'], units.DEFAULT_OWNER_ID)
self.assertEqual(association['created'], units.DEFAULT_CREATED)
self.assertEqual(association['updated'], units.DEFAULT_UPDATED)
def test_distributions(self):
report = UpgradeStepReport()
distribution.V1_DIR_DISTROS = "%s/%s" % (V1_TEST_FILESYSTEM,
distribution.V1_DIR_DISTROS)
distribution.DIR_DISTROS = "%s/%s" % (V2_TEST_FILESYSTEM,
distribution.DIR_DISTROS)
status = distribution._distribution(self.v1_test_db.database,
self.v2_test_db.database, report)
self.assertTrue(status)
v1_distro_list = get_files_in_dir('*', distribution.V1_DIR_DISTROS)
v2_distro_list = get_files_in_dir('*', distribution.DIR_DISTROS)
self.assertEquals(len(v1_distro_list), 0)
self.assertEquals(len(v2_distro_list), 4)
self.assertEquals(len(report.errors), 0)
self.assertTrue(report.succeeded)
def test_categories(self):
# Test
report = UpgradeStepReport()
result = units._package_group_categories(self.v1_test_db.database, self.tmp_test_db.database, report)
# Verify
self.assertTrue(result)
v1_repo_category_tuples = []
for v1_repo in self.v1_test_db.database.repos.find({}, {'id' : 1, 'packagegroupcategories' : 1}):
for categoryid in v1_repo['packagegroupcategories'].keys():
v1_repo_category_tuples.append( (v1_repo['id'], categoryid) )
v2_repo_category_tuples = [ (x['repo_id'], x['id']) for x in
self.tmp_test_db.database.units_package_category.find({}, {'repo_id': 1, 'id' : 1}) ]
v1_repo_category_tuples.sort()
v2_repo_category_tuples.sort()
self.assertEqual(v1_repo_category_tuples, v2_repo_category_tuples)
for v1_repo in self.v1_test_db.database.repos.find({}, {'id' : 1, 'packagegroupcategories' : 1}):
for category_id in v1_repo.get('packagegroupcategories', {}).keys():
# Verify the categories themselves
v1_category = v1_repo['packagegroupcategories'][category_id]
v2_category = self.tmp_test_db.database.units_package_category.find_one({'repo_id' : v1_repo['id'], 'id' : category_id})
self.assertTrue(v2_category is not None)
self.assertTrue(isinstance(v2_category['_id'], basestring))
self.assertEqual(v2_category['_storage_path'], None)
self.assertEqual(v2_category['_content_type_id'], 'package_category')
for k in ('description', 'display_order', 'id', 'name',
'packagegroupids', 'translated_description',
'translated_name'):
self.assertEqual(v2_category[k], v1_category[k])
# Make sure an association exists
ass_query = {'repo_id' : v1_repo['id'],
'unit_id' : v2_category['_id'],
'unit_type_id' : 'package_category'}
association = self.tmp_test_db.database.repo_content_units.find_one(ass_query)
self.assertTrue(association is not None)
self.assertEqual(association['owner_type'], units.DEFAULT_OWNER_TYPE)
self.assertEqual(association['owner_id'], units.DEFAULT_OWNER_ID)
self.assertEqual(association['created'], units.DEFAULT_CREATED)
self.assertEqual(association['updated'], units.DEFAULT_UPDATED)
def test_upgrade(self):
# Test
report = UpgradeStepReport()
result = units._distributions(self.v1_test_db.database, self.tmp_test_db.database, report)
# Verify
self.assertTrue(result)
# Units
v1_distros = self.v1_test_db.database.distribution.find().sort('id')
v2_distros = self.tmp_test_db.database.units_distribution.find().sort('id')
self.assertEqual(v1_distros.count(), v2_distros.count())
for v1_distro, v2_distro in zip(v1_distros, v2_distros):
self.assertTrue(isinstance(v2_distro['_id'], basestring))
self.assertEqual(v2_distro['_content_type_id'], 'distribution')
expected_path = '/var/lib/pulp/content/distribution/%s' % v2_distro['id']
self.assertEqual(v2_distro['_storage_path'], expected_path)
self.assertEqual(v1_distro['id'], v2_distro['id'])
self.assertEqual(v1_distro['arch'], v2_distro['arch'])
self.assertEqual(v1_distro['version'], v2_distro['version'])
self.assertEqual(v1_distro['variant'], v2_distro['variant'])
self.assertEqual(v1_distro['family'], v2_distro['family'])
non_treeinfo_v1_files = [f for f in v1_distro['files'] if '.treeinfo' not in f]
self.assertEqual(len(non_treeinfo_v1_files), len(v2_distro['files']))
# Associations
v1_distros = self.v1_test_db.database.distribution.find()
for v1_distro in v1_distros:
expected_repo_ids = v1_distro['repoids']
v2_distro = self.tmp_test_db.database.units_distribution.find_one({'id' : v1_distro['id']}, {'_id' : 1})
ass_query = {'unit_id' : v2_distro['_id'], 'repo_id' : {'$in' : expected_repo_ids}}
associations = self.tmp_test_db.database.repo_content_units.find(ass_query)
self.assertEqual(len(expected_repo_ids), associations.count())
for association in associations:
self.assertTrue(isinstance(association['_id'], ObjectId))
self.assertTrue(association['repo_id'] in expected_repo_ids)
self.assertEqual(association['unit_id'], v2_distro['_id'])
self.assertEqual(association['unit_type_id'], 'distribution')
self.assertEqual(association['owner_type'], units.DEFAULT_OWNER_TYPE)
self.assertEqual(association['owner_id'], units.DEFAULT_OWNER_ID)
self.assertEqual(association['created'], units.DEFAULT_CREATED)
self.assertEqual(association['updated'], units.DEFAULT_UPDATED)
def test_errata(self):
# Test
report = UpgradeStepReport()
result = units._errata(self.v1_test_db.database, self.tmp_test_db.database, report)
# Verify
self.assertTrue(result)
# Units
v1_errata = self.v1_test_db.database.errata.find().sort('id')
v2_errata = self.tmp_test_db.database.units_erratum.find().sort('id')
self.assertEqual(v1_errata.count(), v2_errata.count())
for v1_erratum, v2_erratum in zip(v1_errata, v2_errata):
self.assertTrue(isinstance(v2_erratum['_id'], basestring))
self.assertEqual(v2_erratum['_storage_path'], None)
self.assertEqual(v2_erratum['_content_type_id'], 'erratum')
for k in ('description', 'from_str', 'id', 'issued', 'pkglist',
'pushcount', 'reboot_suggested', 'references', 'release',
'rights', 'severity', 'solution', 'status', 'summary',
'title', 'type', 'updated', 'version'):
self.assertEqual(v2_erratum[k], v1_erratum[k], msg='Unequal key: %s' % k)
# Associations
v1_errata = self.v1_test_db.database.errata.find().sort('id')
for v1_erratum in v1_errata:
expected_repo_ids = v1_erratum['repoids']
v2_erratum = self.tmp_test_db.database.units_erratum.find_one({'id' : v1_erratum['id']}, {'_id' : 1})
ass_query = {'unit_id' : v2_erratum['_id'], 'repo_id' : {'$in' : expected_repo_ids}}
associations = self.tmp_test_db.database.repo_content_units.find(ass_query)
self.assertEqual(len(expected_repo_ids), associations.count())
for association in associations:
self.assertTrue(isinstance(association['_id'], ObjectId))
self.assertTrue(association['repo_id'] in expected_repo_ids)
self.assertEqual(association['unit_id'], v2_erratum['_id'])
self.assertEqual(association['unit_type_id'], 'erratum')
self.assertEqual(association['owner_type'], units.DEFAULT_OWNER_TYPE)
self.assertEqual(association['owner_id'], units.DEFAULT_OWNER_ID)
self.assertEqual(association['created'], units.DEFAULT_CREATED)
self.assertEqual(association['updated'], units.DEFAULT_UPDATED)
def test_rpms(self):
report = UpgradeStepReport()
if not rpms.V1_DIR_RPMS.startswith(V1_TEST_FILESYSTEM):
rpms.V1_DIR_RPMS = "%s/%s" % (V1_TEST_FILESYSTEM, rpms.V1_DIR_RPMS)
rpms.DIR_RPMS = "%s/%s" % (V2_TEST_FILESYSTEM, rpms.DIR_RPMS)
v1_rpms_list_pre_upgrade = get_files_in_dir('*.rpm', rpms.V1_DIR_RPMS)
status = rpms._rpms(self.v1_test_db.database, self.v2_test_db.database,
report)
self.assertTrue(status)
v1_rpms_list = get_files_in_dir('*.rpm', rpms.V1_DIR_RPMS)
v2_rpms_list = get_files_in_dir('*.rpm', rpms.DIR_RPMS)
self.assertEquals(len(v1_rpms_list), 0)
self.assertEquals(len(v2_rpms_list), 3)
for v1_path in v1_rpms_list_pre_upgrade:
v2_path = "%s/%s" % (rpms.DIR_RPMS, v1_path.split(
rpms.V1_DIR_RPMS)[-1])
self.assertTrue(os.path.exists(v2_path))
self.assertEquals(len(report.errors), 0)
self.assertTrue(report.succeeded)
def upgrade(v1_database, v2_database):
report = UpgradeStepReport()
distro_success = _distribution(v1_database, v2_database, report)
report.success = distro_success
return report
def upgrade(v1_database, v2_database):
report = UpgradeStepReport()
isos_success = _isos(v1_database, v2_database, report)
report.success = isos_success
return report
