def _register_consumer(self, name, facts, owner, env, callback):
"""
method run in the worker thread.
"""
try:
installed_mgr = InstalledProductsManager()
retval = self.backend.admin_uep.registerConsumer(
name=name,
facts=facts.get_facts(),
owner=owner,
environment=env,
installed_products=installed_mgr.format_for_server())
# Facts and installed products went out with the registration
# request, manually write caches to disk:
facts.write_cache()
installed_mgr.write_cache()
ProfileManager().update_check(self.backend.admin_uep,
retval['uuid'])
# We have new credentials, restart virt-who
restart_virt_who()
self.queue.put((callback, retval, None))
except Exception, e:
self.queue.put((callback, None, e))
def setUp(self):
self.prod_dir = StubCertificateDirectory([
StubProductCertificate(StubProduct('a-product', name="Product A")),
StubProductCertificate(StubProduct('b-product', name="Product B")),
StubProductCertificate(StubProduct('c-product', name="Product C")),
])
self.mgr = InstalledProductsManager(self.prod_dir)
def setUp(self):
super(TestInstalledProductsCache, self).setUp()
self.prod_dir = StubCertificateDirectory([
StubProductCertificate(StubProduct('a-product', name="Product A", provided_tags="product,product-a")),
StubProductCertificate(StubProduct('b-product', name="Product B", provided_tags="product,product-b")),
StubProductCertificate(StubProduct('c-product', name="Product C", provided_tags="product-c")),
])
inj.provide(inj.PROD_DIR, self.prod_dir)
self.mgr = InstalledProductsManager()
def unregister(uep, consumer_uuid):
"""
Shared logic for un-registration.
"""
uep.unregisterConsumer(consumer_uuid)
log.info("Successfully un-registered.")
system_log("Unregistered machine with identity: %s" % consumer_uuid)
# Clean up certificates, these are no longer valid:
shutil.rmtree(cfg.get('rhsm', 'consumerCertDir'), ignore_errors=True)
shutil.rmtree(cfg.get('rhsm', 'entitlementCertDir'), ignore_errors=True)
ProfileManager.delete_cache()
Facts.delete_cache()
InstalledProductsManager.delete_cache()
def unregister(uep, consumer_uuid):
"""
Shared logic for un-registration.
"""
uep.unregisterConsumer(consumer_uuid)
log.info("Successfully un-registered.")
system_log("Unregistered machine with identity: %s" % consumer_uuid)
# Clean up certificates, these are no longer valid:
shutil.rmtree(cfg.get('rhsm', 'consumerCertDir'), ignore_errors=True)
shutil.rmtree(cfg.get('rhsm', 'entitlementCertDir'), ignore_errors=True)
ProfileManager.delete_cache()
Facts.delete_cache()
InstalledProductsManager.delete_cache()
def setUp(self):
self.prod_dir = StubCertificateDirectory([
StubProductCertificate(StubProduct('a-product', name="Product A")),
StubProductCertificate(StubProduct('b-product', name="Product B")),
StubProductCertificate(StubProduct('c-product', name="Product C")),
])
self.mgr = InstalledProductsManager(self.prod_dir)
def _register_consumer(self, name, facts, owner, env, callback):
"""
method run in the worker thread.
"""
try:
installed_mgr = InstalledProductsManager()
retval = self.backend.admin_uep.registerConsumer(name=name,
facts=facts.get_facts(), owner=owner, environment=env,
installed_products=installed_mgr.format_for_server())
# Facts and installed products went out with the registration request,
# manually write caches to disk:
facts.write_cache()
installed_mgr.write_cache()
ProfileManager().update_check(self.backend.admin_uep, retval['uuid'])
self.queue.put((callback, retval, None))
except Exception, e:
self.queue.put((callback, None, e))
def clean_all_data(backup=True):
consumer_dir = cfg.get('rhsm', 'consumerCertDir')
if backup:
if consumer_dir[-1] == "/":
consumer_dir_backup = consumer_dir[0:-1] + ".old"
else:
consumer_dir_backup = consumer_dir + ".old"
shutil.rmtree(consumer_dir_backup, ignore_errors=True)
os.rename(consumer_dir, consumer_dir_backup)
else:
shutil.rmtree(consumer_dir, ignore_errors=True)
shutil.rmtree(cfg.get('rhsm', 'entitlementCertDir'), ignore_errors=True)
ProfileManager.delete_cache()
InstalledProductsManager.delete_cache()
Facts.delete_cache()
RepoLib.delete_repo_file()
log.info("Cleaned local data")
def clean_all_data(backup=True):
consumer_dir = cfg.get('rhsm', 'consumerCertDir')
if backup:
if consumer_dir[-1] == "/":
consumer_dir_backup = consumer_dir[0:-1] + ".old"
else:
consumer_dir_backup = consumer_dir + ".old"
shutil.rmtree(consumer_dir_backup, ignore_errors=True)
os.rename(consumer_dir, consumer_dir_backup)
else:
shutil.rmtree(consumer_dir, ignore_errors=True)
shutil.rmtree(cfg.get('rhsm', 'entitlementCertDir'), ignore_errors=True)
ProfileManager.delete_cache()
InstalledProductsManager.delete_cache()
Facts.delete_cache()
RepoLib.delete_repo_file()
log.info("Cleaned local data")
def setUp(self):
super(TestInstalledProductsCache, self).setUp()
self.prod_dir = StubCertificateDirectory(
[
StubProductCertificate(StubProduct("a-product", name="Product A")),
StubProductCertificate(StubProduct("b-product", name="Product B")),
StubProductCertificate(StubProduct("c-product", name="Product C")),
]
)
inj.provide(inj.PROD_DIR, self.prod_dir)
self.mgr = InstalledProductsManager()
def _register_consumer(self, name, facts, owner, env, activation_keys, callback):
"""
method run in the worker thread.
"""
try:
installed_mgr = InstalledProductsManager()
self.plugin_manager.run("pre_register_consumer", name=name,
facts=facts.get_facts())
retval = self.backend.cp_provider.get_basic_auth_cp().registerConsumer(name=name,
facts=facts.get_facts(), owner=owner, environment=env,
keys=activation_keys,
installed_products=installed_mgr.format_for_server())
self.plugin_manager.run("post_register_consumer", consumer=retval,
facts=facts.get_facts())
# Facts and installed products went out with the registration
# request, manually write caches to disk:
facts.write_cache()
installed_mgr.write_cache()
cp = self.backend.cp_provider.get_basic_auth_cp()
# In practice, the only time this condition should be true is
# when we are working with activation keys. See BZ #888790.
if not self.backend.cp_provider.get_basic_auth_cp().username and \
not self.backend.cp_provider.get_basic_auth_cp().password:
# Write the identity cert to disk
managerlib.persist_consumer_cert(retval)
self.backend.update()
cp = self.backend.cp_provider.get_consumer_auth_cp()
ProfileManager().update_check(cp, retval['uuid'])
# We have new credentials, restart virt-who
restart_virt_who()
self.queue.put((callback, retval, None))
except Exception:
self.queue.put((callback, None, sys.exc_info()))
class TestInstalledProductsCache(SubManFixture):
def setUp(self):
super(TestInstalledProductsCache, self).setUp()
self.prod_dir = StubCertificateDirectory([
StubProductCertificate(StubProduct('a-product', name="Product A", provided_tags="product,product-a")),
StubProductCertificate(StubProduct('b-product', name="Product B", provided_tags="product,product-b")),
StubProductCertificate(StubProduct('c-product', name="Product C", provided_tags="product-c")),
])
inj.provide(inj.PROD_DIR, self.prod_dir)
self.mgr = InstalledProductsManager()
def test_cert_parsing(self):
self.assertEqual(3, len(list(self.mgr.installed.keys())))
self.assertTrue('a-product' in self.mgr.installed)
self.assertTrue('b-product' in self.mgr.installed)
self.assertTrue('c-product' in self.mgr.installed)
self.assertEqual("Product A", self.mgr.installed['a-product']['productName'])
self.assertEqual(set(["product", "product-a", "product-b", "product-c"]), set(self.mgr.tags))
def test_load_data(self):
cached = {
'products': {
'prod1': 'Product 1',
'prod2': 'Product 2'
},
'tags': ['p1', 'p2']
}
mock_file = Mock()
mock_file.read = Mock(return_value=json.dumps(cached))
data = self.mgr._load_data(mock_file)
self.assertEqual(data, cached)
def test_has_changed(self):
cached = {
'products': {
'prod1': 'Product 1',
'prod2': 'Product 2'
},
'tags': ['p1', 'p2']
}
self.mgr._read_cache = Mock(return_value=cached)
self.mgr._cache_exists = Mock(return_value=True)
self.assertTrue(self.mgr.has_changed())
def test_has_changed_with_tags_only(self):
cached = {
'products': {
'a-product': {'productName': 'Product A', 'productId': 'a-product', 'version': '1.0', 'arch': 'x86_64'},
'b-product': {'productName': 'Product B', 'productId': 'b-product', 'version': '1.0', 'arch': 'x86_64'},
'c-product': {'productName': 'Product C', 'productId': 'c-product', 'version': '1.0', 'arch': 'x86_64'}
},
'tags': ['different']
}
self.mgr._read_cache = Mock(return_value=cached)
self.mgr._cache_exists = Mock(return_value=True)
self.assertTrue(self.mgr.has_changed())
def test_old_format_seen_as_invalid(self):
cached = {
'a-product': {'productName': 'Product A', 'productId': 'a-product', 'version': '1.0', 'arch': 'x86_64'},
'b-product': {'productName': 'Product B', 'productId': 'b-product', 'version': '1.0', 'arch': 'x86_64'},
'c-product': {'productName': 'Product C', 'productId': 'c-product', 'version': '1.0', 'arch': 'x86_64'}
}
self.mgr._read_cache = Mock(return_value=cached)
self.mgr._cache_exists = Mock(return_value=True)
self.assertTrue(self.mgr.has_changed())
def test_has_not_changed(self):
cached = {
'products': {
'a-product': {'productName': 'Product A', 'productId': 'a-product', 'version': '1.0', 'arch': 'x86_64'},
'b-product': {'productName': 'Product B', 'productId': 'b-product', 'version': '1.0', 'arch': 'x86_64'},
'c-product': {'productName': 'Product C', 'productId': 'c-product', 'version': '1.0', 'arch': 'x86_64'}
},
'tags': ['product-a', 'product-b', 'product-c', 'product']
}
self.mgr._read_cache = Mock(return_value=cached)
self.mgr._cache_exists = Mock(return_value=True)
self.assertFalse(self.mgr.has_changed())
def test_update_check_no_change(self):
uuid = 'FAKEUUID'
uep = Mock()
uep.updateConsumer = Mock()
self.mgr.has_changed = Mock(return_value=False)
self.mgr.write_cache = Mock()
self.mgr.update_check(uep, uuid)
self.assertEqual(0, uep.updateConsumer.call_count)
self.assertEqual(0, self.mgr.write_cache.call_count)
def test_update_check_has_changed(self):
uuid = 'FAKEUUID'
uep = Mock()
uep.updateConsumer = Mock()
self.mgr.has_changed = Mock(return_value=True)
self.mgr.write_cache = Mock()
self.mgr.update_check(uep, uuid)
expected = ["product", "product-a", "product-b", "product-c"]
uep.updateConsumer.assert_called_with(uuid,
content_tags=set(expected),
installed_products=self.mgr.format_for_server())
self.assertEqual(1, self.mgr.write_cache.call_count)
def test_update_check_error_uploading(self):
uuid = 'FAKEUUID'
uep = Mock()
self.mgr.has_changed = Mock(return_value=True)
self.mgr.write_cache = Mock()
# Throw an exception when trying to upload:
uep.updateConsumer = Mock(side_effect=Exception('BOOM!'))
self.assertRaises(Exception, self.mgr.update_check, uep, uuid)
expected = ["product", "product-a", "product-b", "product-c"]
uep.updateConsumer.assert_called_with(uuid,
content_tags=set(expected),
installed_products=self.mgr.format_for_server())
self.assertEqual(0, self.mgr.write_cache.call_count)
class TestInstalledProductsCache(unittest.TestCase):
def setUp(self):
self.prod_dir = StubCertificateDirectory([
StubProductCertificate(StubProduct('a-product', name="Product A")),
StubProductCertificate(StubProduct('b-product', name="Product B")),
StubProductCertificate(StubProduct('c-product', name="Product C")),
])
self.mgr = InstalledProductsManager(self.prod_dir)
def test_cert_parsing(self):
self.assertEqual(3, len(self.mgr.installed.keys()))
self.assertTrue('a-product' in self.mgr.installed)
self.assertTrue('b-product' in self.mgr.installed)
self.assertTrue('c-product' in self.mgr.installed)
self.assertEquals("Product A", self.mgr.installed['a-product']['productName'])
def test_load_data(self):
cached = {
'prod1': 'Product 1',
'prod2': 'Product 2'
}
mock_file = Mock()
mock_file.read = Mock(return_value=json.dumps(cached))
data = self.mgr._load_data(mock_file)
self.assertEquals(data, cached)
def test_has_changed(self):
cached = {
'prod1': 'Product 1',
'prod2': 'Product 2'
}
self.mgr._read_cache = Mock(return_value=cached)
self.mgr._cache_exists = Mock(return_value=True)
self.assertTrue(self.mgr.has_changed())
def test_has_not_changed(self):
cached = {
'a-product': {'productName': 'Product A', 'productId': 'a-product', 'version': '1.0', 'arch': 'x86_64'},
'b-product': {'productName': 'Product B', 'productId': 'b-product', 'version': '1.0', 'arch': 'x86_64'},
'c-product': {'productName': 'Product C', 'productId': 'c-product', 'version': '1.0', 'arch': 'x86_64'}
}
self.mgr._read_cache = Mock(return_value=cached)
self.mgr._cache_exists = Mock(return_value=True)
self.assertFalse(self.mgr.has_changed())
def test_update_check_no_change(self):
uuid = 'FAKEUUID'
uep = Mock()
uep.updateConsumer = Mock()
self.mgr.has_changed = Mock(return_value=False)
self.mgr.write_cache = Mock()
self.mgr.update_check(uep, uuid)
self.assertEquals(0, uep.updateConsumer.call_count)
self.assertEquals(0, self.mgr.write_cache.call_count)
def test_update_check_has_changed(self):
uuid = 'FAKEUUID'
uep = Mock()
uep.updateConsumer = Mock()
self.mgr.has_changed = Mock(return_value=True)
self.mgr.write_cache = Mock()
self.mgr.update_check(uep, uuid)
uep.updateConsumer.assert_called_with(uuid,
installed_products=self.mgr.format_for_server())
self.assertEquals(1, self.mgr.write_cache.call_count)
def test_update_check_error_uploading(self):
uuid = 'FAKEUUID'
uep = Mock()
self.mgr.has_changed = Mock(return_value=True)
self.mgr.write_cache = Mock()
# Throw an exception when trying to upload:
uep.updateConsumer = Mock(side_effect=Exception('BOOM!'))
self.assertRaises(Exception, self.mgr.update_check, uep, uuid)
uep.updateConsumer.assert_called_with(uuid,
installed_products=self.mgr.format_for_server())
self.assertEquals(0, self.mgr.write_cache.call_count)
class TestInstalledProductsCache(unittest.TestCase):
def setUp(self):
self.prod_dir = StubCertificateDirectory([
StubProductCertificate(StubProduct('a-product', name="Product A")),
StubProductCertificate(StubProduct('b-product', name="Product B")),
StubProductCertificate(StubProduct('c-product', name="Product C")),
])
self.mgr = InstalledProductsManager(self.prod_dir)
def test_cert_parsing(self):
self.assertEqual(3, len(self.mgr.installed.keys()))
self.assertTrue('a-product' in self.mgr.installed)
self.assertTrue('b-product' in self.mgr.installed)
self.assertTrue('c-product' in self.mgr.installed)
self.assertEquals("Product A", self.mgr.installed['a-product'])
def test_load_data(self):
cached = {'prod1': 'Product 1', 'prod2': 'Product 2'}
mock_file = Mock()
mock_file.read = Mock(return_value=json.dumps(cached))
data = self.mgr._load_data(mock_file)
self.assertEquals(data, cached)
def test_has_changed(self):
cached = {'prod1': 'Product 1', 'prod2': 'Product 2'}
self.mgr._read_cache = Mock(return_value=cached)
self.mgr._cache_exists = Mock(return_value=True)
self.assertTrue(self.mgr.has_changed())
def test_has_not_changed(self):
cached = {
'a-product': 'Product A',
'b-product': 'Product B',
'c-product': 'Product C',
}
self.mgr._read_cache = Mock(return_value=cached)
self.mgr._cache_exists = Mock(return_value=True)
self.assertFalse(self.mgr.has_changed())
def test_update_check_no_change(self):
uuid = 'FAKEUUID'
uep = Mock()
uep.updateConsumer = Mock()
self.mgr.has_changed = Mock(return_value=False)
self.mgr.write_cache = Mock()
self.mgr.update_check(uep, uuid)
self.assertEquals(0, uep.updateConsumer.call_count)
self.assertEquals(0, self.mgr.write_cache.call_count)
def test_update_check_has_changed(self):
uuid = 'FAKEUUID'
uep = Mock()
uep.updateConsumer = Mock()
self.mgr.has_changed = Mock(return_value=True)
self.mgr.write_cache = Mock()
self.mgr.update_check(uep, uuid)
uep.updateConsumer.assert_called_with(
uuid, installed_products=self.mgr.format_for_server())
self.assertEquals(1, self.mgr.write_cache.call_count)
def test_update_check_error_uploading(self):
uuid = 'FAKEUUID'
uep = Mock()
self.mgr.has_changed = Mock(return_value=True)
self.mgr.write_cache = Mock()
# Throw an exception when trying to upload:
uep.updateConsumer = Mock(side_effect=Exception('BOOM!'))
self.assertRaises(Exception, self.mgr.update_check, uep, uuid)
uep.updateConsumer.assert_called_with(
uuid, installed_products=self.mgr.format_for_server())
self.assertEquals(0, self.mgr.write_cache.call_count)
class TestInstalledProductsCache(SubManFixture):
def setUp(self):
super(TestInstalledProductsCache, self).setUp()
self.prod_dir = StubCertificateDirectory(
[
StubProductCertificate(StubProduct("a-product", name="Product A")),
StubProductCertificate(StubProduct("b-product", name="Product B")),
StubProductCertificate(StubProduct("c-product", name="Product C")),
]
)
inj.provide(inj.PROD_DIR, self.prod_dir)
self.mgr = InstalledProductsManager()
def test_cert_parsing(self):
self.assertEqual(3, len(self.mgr.installed.keys()))
self.assertTrue("a-product" in self.mgr.installed)
self.assertTrue("b-product" in self.mgr.installed)
self.assertTrue("c-product" in self.mgr.installed)
self.assertEquals("Product A", self.mgr.installed["a-product"]["productName"])
def test_load_data(self):
cached = {"prod1": "Product 1", "prod2": "Product 2"}
mock_file = Mock()
mock_file.read = Mock(return_value=json.dumps(cached))
data = self.mgr._load_data(mock_file)
self.assertEquals(data, cached)
def test_has_changed(self):
cached = {"prod1": "Product 1", "prod2": "Product 2"}
self.mgr._read_cache = Mock(return_value=cached)
self.mgr._cache_exists = Mock(return_value=True)
self.assertTrue(self.mgr.has_changed())
def test_has_not_changed(self):
cached = {
"a-product": {"productName": "Product A", "productId": "a-product", "version": "1.0", "arch": "x86_64"},
"b-product": {"productName": "Product B", "productId": "b-product", "version": "1.0", "arch": "x86_64"},
"c-product": {"productName": "Product C", "productId": "c-product", "version": "1.0", "arch": "x86_64"},
}
self.mgr._read_cache = Mock(return_value=cached)
self.mgr._cache_exists = Mock(return_value=True)
self.assertFalse(self.mgr.has_changed())
def test_update_check_no_change(self):
uuid = "FAKEUUID"
uep = Mock()
uep.updateConsumer = Mock()
self.mgr.has_changed = Mock(return_value=False)
self.mgr.write_cache = Mock()
self.mgr.update_check(uep, uuid)
self.assertEquals(0, uep.updateConsumer.call_count)
self.assertEquals(0, self.mgr.write_cache.call_count)
def test_update_check_has_changed(self):
uuid = "FAKEUUID"
uep = Mock()
uep.updateConsumer = Mock()
self.mgr.has_changed = Mock(return_value=True)
self.mgr.write_cache = Mock()
self.mgr.update_check(uep, uuid)
uep.updateConsumer.assert_called_with(uuid, installed_products=self.mgr.format_for_server())
self.assertEquals(1, self.mgr.write_cache.call_count)
def test_update_check_error_uploading(self):
uuid = "FAKEUUID"
uep = Mock()
self.mgr.has_changed = Mock(return_value=True)
self.mgr.write_cache = Mock()
# Throw an exception when trying to upload:
uep.updateConsumer = Mock(side_effect=Exception("BOOM!"))
self.assertRaises(Exception, self.mgr.update_check, uep, uuid)
uep.updateConsumer.assert_called_with(uuid, installed_products=self.mgr.format_for_server())
self.assertEquals(0, self.mgr.write_cache.call_count)
