def test_contruct_repos(
self, load_mock, rhsm_mock, centos_mock, ceph_mock, dlrn_mock
):
dummy_data = yaml.safe_load(DUMMY_RHEL_DATA)
obj = distribution.DistributionInfo("rhel", "8.2", "Red Hat")
obj._distro_data = dummy_data
obj.construct_repo("rhel8.2", "16.1", "rhel-repo")
rhsm_mock.assert_called_once_with("rhel-repo")
obj.construct_repo("ceph", "16.1", "ceph-repo")
rhsm_mock.assert_called_with("ceph-repo")
dummy_data = yaml.safe_load(DUMMY_CENTOS_DATA)
obj = distribution.DistributionInfo("centos", "8", "CentOS Stream")
obj._distro_data = dummy_data
obj.construct_repo("centos8-stream", "master", "centos-repo")
centos_mock.assert_called_once_with("centos8-stream", "centos-repo")
obj.construct_repo("ceph", "master", "ceph-repo")
ceph_mock.assert_called_once_with("centos8-stream", "ceph-repo")
obj.construct_repo("delorean", "master", "dlrn-repo")
dlrn_mock.assert_called_once_with("centos8", "master", "dlrn-repo")
self.assertRaises(
exceptions.RepositoryNotSupported, obj.construct_repo, "nope", "foo", "bar"
)
def test_data(self, exists_mock):
exists_mock.return_value = True
dummy_data = yaml.safe_load(DUMMY_CENTOS_DATA)
with mock.patch(
"builtins.open", mock.mock_open(read_data=DUMMY_CENTOS_DATA)
) as open_mock:
obj = distribution.DistributionInfo("centos", "8", "CentOS Stream")
open_mock.assert_called_with(
"/usr/share/rhos-bootstrap/centos.yaml", "r", encoding="utf-8"
)
self.assertEqual(obj.distro_data, dummy_data)
self.assertEqual(obj.distro_id, "centos")
self.assertEqual(obj.distro_version_id, "8")
self.assertEqual(obj.distro_major_version_id, "8")
self.assertTrue(obj.is_stream)
self.assertEqual(obj.distro_minor_version_id, "")
self.assertEqual(obj.distro_name, "CentOS Stream")
self.assertEqual(obj.distros, dummy_data["distros"])
self.assertEqual(obj.versions, dummy_data["versions"])
self.assertEqual(obj.distro_normalized_id, "centos8-stream")
self.assertEqual(str(obj), "centos8-stream")
with mock.patch("rhos_bootstrap.distribution.DistributionInfo._load_data"):
obj = distribution.DistributionInfo("rhel", "8.2", "Red Hat")
self.assertEqual(obj.distro_id, "rhel")
self.assertEqual(obj.distro_version_id, "8.2")
self.assertEqual(obj.distro_major_version_id, "8")
self.assertFalse(obj.is_stream)
self.assertEqual(obj.distro_minor_version_id, "2")
self.assertEqual(obj.distro_normalized_id, "rhel8.2")
with mock.patch("subprocess.Popen") as popen_mock:
proc_mock = mock.MagicMock()
comm_mock = mock.MagicMock()
comm_mock.return_value = ["rhel\n8.2\nRed Hat Enterprise Linux"]
proc_mock.__enter__.return_value.communicate = comm_mock
popen_mock.return_value = proc_mock
obj = distribution.DistributionInfo()
self.assertEqual(obj.distro_id, "rhel")
self.assertEqual(obj.distro_version_id, "8.2")
self.assertEqual(obj.distro_major_version_id, "8")
self.assertFalse(obj.is_stream)
self.assertEqual(obj.distro_minor_version_id, "2")
exists_mock.return_value = False
self.assertRaises(
exceptions.DistroNotSupported,
distribution.DistributionInfo,
"foo",
"bar",
"baz",
)
def test_validate_distro(self, load_mock):
obj = distribution.DistributionInfo("centos", "8", "CentOS Stream")
obj._distro_data = yaml.safe_load(DUMMY_CENTOS_DATA)
self.assertFalse(obj.validate_distro("doesnotexist"))
self.assertTrue(obj.validate_distro("master"))
obj._distro_version_id = "9"
self.assertFalse(obj.validate_distro("master"))
def test_modules(self, load_mock, mod_mock):
dummy_data = yaml.safe_load(DUMMY_RHEL_DATA)
obj = distribution.DistributionInfo("rhel", "8.2", "Red Hat")
obj._distro_data = dummy_data
self.assertEqual(
len(obj.get_modules("16.1")), len(dummy_data["versions"]["16.1"]["modules"])
)
mod_calls = [
mock.call(*i) for i in dummy_data["versions"]["16.1"]["modules"].items()
]
self.assertEqual(mod_mock.mock_calls, mod_calls)
def test_repos(self, load_mock, const_repo):
dummy_data = yaml.safe_load(DUMMY_RHEL_DATA)
obj = distribution.DistributionInfo("rhel", "8.2", "Red Hat")
obj._distro_data = dummy_data
res = obj.get_repos("16.1")
self.assertEqual(len(res), 8)
dummy_data = yaml.safe_load(DUMMY_CENTOS_DATA)
obj = distribution.DistributionInfo("centos", "8", "CentOS Stream")
obj._distro_data = dummy_data
res = obj.get_repos("master")
self.assertEqual(len(res), 5)
dummy_data = yaml.safe_load(DUMMY_CENTOS_DATA)
obj = distribution.DistributionInfo("centos", "8.2", "CentOS Stream")
obj._distro_data = dummy_data
res = obj.get_repos("master")
self.assertEqual(len(res), 3)
def test_validate_distro_rhel(self, load_mock, submgr_mock):
inst_mock = mock.MagicMock()
status_mock = mock.MagicMock()
release_mock = mock.MagicMock()
inst_mock.status = status_mock
inst_mock.release = release_mock
submgr_mock.return_value = inst_mock
obj = distribution.DistributionInfo("rhel", "8.2", "Red Hat")
obj._distro_data = yaml.safe_load(DUMMY_RHEL_DATA)
self.assertFalse(obj.validate_distro("doesnotexist"))
release_mock.return_value = (0, "Release: 8.2", "")
self.assertTrue(obj.validate_distro("16.1"))
release_mock.return_value = (0, "Release: 8.3", "")
self.assertRaises(
exceptions.SubscriptionManagerConfigError, obj.validate_distro, "16.1"
)
def main(): # pylint: disable=too-many-branches,too-many-statements
cli = BootstrapCli()
args = cli.parse_args()
log_level = logging.INFO
if args.debug:
log_level = logging.DEBUG
logging.basicConfig(format="[%(asctime)s] [%(levelname)s]: %(message)s",
level=log_level)
if os.getuid() != 0:
LOG.error("You must be root to run this command")
cli.parser.print_help()
sys.exit(2)
LOG.info("=" * 40)
LOG.info("=== OpenStack Version: %s", args.version)
distro = distribution.DistributionInfo()
LOG.info("=== Distribution: %s", distro.distro_normalized_id)
LOG.info("=" * 40)
if not args.skip_validation:
LOG.info("=== Validating version for distro...")
if not distro.validate_distro(args.version):
raise DistroNotSupported(distro.distro_normalized_id)
LOG.info("OK! %s on %s", args.version, distro.distro_normalized_id)
else:
LOG.info("=== Skipping validation of version for distro...")
if not args.skip_repos:
repos = distro.get_repos(args.version,
enable_ceph=not args.skip_ceph_install)
LOG.info("=== Configuring repositories....")
if "rhel" in distro.distro_id:
LOG.info("Disabling all existing configured repositories...")
rhsm = SubscriptionManager.instance()
rhsm.repos(disable=["*"])
for repo in repos:
LOG.info("Configuring %s", repo.name)
repo.save()
else:
LOG.info("=== Skipping repository configuration...")
if not (args.skip_modules and not args.update_packages
and args.skip_client_install):
# we don't need a manager if we're not calling it
manager = DnfManager.instance()
if not args.skip_modules:
modules = distro.get_modules(args.version)
LOG.info("=== Configuring modules...")
for mod in modules:
LOG.info("Enabling %s:%s", mod.name, mod.stream)
manager.enable_module(mod.name, mod.stream, mod.profile)
else:
LOG.info("=== Skipping module configuration...")
if args.update_packages:
LOG.info("=== Performing update...")
manager.update_package("*")
LOG.info("NOTE: A manual reboot may be required")
if not args.skip_client_install:
LOG.info("=== Installing tripleoclient...")
manager.install_update_package("python3-tripleoclient")
else:
LOG.info("=== Skipping tripleoclient installation...")
LOG.info("=== Done!")
def test_version(self, lock_mock):
dummy_data = yaml.safe_load(DUMMY_RHEL_DATA)
obj = distribution.DistributionInfo("rhel", "8.2", "Red Hat")
obj._distro_data = dummy_data
self.assertRaises(exceptions.VersionNotSupported, obj.get_version, "999")
self.assertEqual(obj.get_version("16.1"), dummy_data["versions"]["16.1"])
