def _smoke_test():
"""
Simple smoke tests of GCP detector and collector
"""
# Gather only information about hardware and virtualization
from rhsmlib.facts.host_collector import HostCollector
from rhsmlib.facts.hwprobe import HardwareCollector
import sys
root = logging.getLogger()
root.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
handler.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
root.addHandler(handler)
facts = {}
facts.update(HostCollector().get_all())
facts.update(HardwareCollector().get_all())
gcp_cloud_detector = GCPCloudDetector(facts)
result = gcp_cloud_detector.is_running_on_cloud()
probability = gcp_cloud_detector.is_likely_running_on_cloud()
print('>>> debug <<< result: %s, %6.3f' % (result, probability))
if result is True:
# 1. using default audience
gcp_cloud_collector = GCPCloudCollector()
token = gcp_cloud_collector.get_metadata()
print(f'>>> debug <<< 1. token: {token}')
# 2. using some custom audience
gcp_cloud_collector = GCPCloudCollector(audience_url="https://localhost:8443/candlepin")
token = gcp_cloud_collector.get_metadata()
print(f'>>> debug <<< 2. token: {token}')
def _smoke_tests():
"""
Simple smoke test of azure detector and collector
:return: None
"""
# Gather only information about hardware and virtualization
from rhsmlib.facts.host_collector import HostCollector
from rhsmlib.facts.hwprobe import HardwareCollector
import sys
root = logging.getLogger()
root.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
handler.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
root.addHandler(handler)
facts = {}
facts.update(HostCollector().get_all())
facts.update(HardwareCollector().get_all())
azure_cloud_detector = AzureCloudDetector(facts)
result = azure_cloud_detector.is_running_on_cloud()
probability = azure_cloud_detector.is_likely_running_on_cloud()
print('>>> debug <<< result: %s, %6.3f' % (result, probability))
if result is True:
azure_cloud_collector = AzureCloudCollector()
metadata = azure_cloud_collector.get_metadata()
signature = azure_cloud_collector.get_signature()
print(f'>>> debug <<< metadata: {metadata}')
print(f'>>> debug <<< signature: {signature}')
def enable_pkg_plugins(cls):
"""
This function tries to enable dnf/yum plugins: subscription-manager and product-id.
It takes no action, when automatic enabling of yum plugins is disabled in rhsm.conf.
:return: It returns list of enabled plugins
"""
# When user doesn't want to automatically enable yum plugins, then return empty list
if cls.is_auto_enable_enabled() is False:
log.debug(
"The rhsm.auto_enable_yum_plugins is disabled. Skipping the enablement of yum plugins."
)
return []
dist_info = HardwareCollector().get_distribution()
if dist_info[4] == "debian" or "debian" in dist_info[5]:
return []
log.debug("The rhsm.auto_enable_yum_plugins is enabled")
enabled_plugins = []
enabled_plugins.extend(cls._enable_plugins("dnf", cls.DNF_PLUGIN_DIR))
return enabled_plugins
def __init__(self):
"""
Create a new firstboot Module for the 'register' screen.
"""
super(moduleClass, self).__init__()
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
GLib.threads_init()
dbus.mainloop.glib.threads_init()
self.mode = constants.MODE_REGULAR
self.title = _("Subscription Management Registration")
self.sidebarTitle = _("Subscription Registration")
self.priority = 200.1
# NOTE: all of this is copied form former firstboot_base module
# and may no longer be needed
# set this so subclasses can override behaviour if needed
self._is_compat = False
reg_info = registergui.RegisterInfo()
self.backend = managergui.Backend()
self.plugin_manager = inj.require(inj.PLUGIN_MANAGER)
self.register_widget = registergui.FirstbootWidget(
self.backend, reg_info)
self.register_widget.connect("notify::screen-ready",
self._on_screen_ready_change)
# Will be False if we are on an older RHEL version where
# rhn-client-tools already does some things so we don't have to.
self.standalone = True
distribution = HardwareCollector().get_distribution()
log.debug("Distribution: %s" % str(distribution))
try:
dist_version = float(distribution[1])
# We run this for Fedora as well, but all we really care about here
# is if this is prior to RHEL 7, so this comparison should be safe.
if dist_version < 7:
self.standalone = False
except Exception as e:
log.error("Unable to parse a distribution version.")
log.exception(e)
log.debug("Running standalone firstboot: %s" % self.standalone)
self.manual_message = None
self._skip_apply_for_page_jump = False
self._cached_credentials = None
self._registration_finished = False
self.interface = None
self.finished = False
self.proxies_were_enabled_from_gui = None
self._apply_result = constants.RESULT_FAILURE
self.page_status = constants.RESULT_FAILURE
def detect_cloud_provider():
"""
This method tries to detect cloud provider using hardware information provided by dmidecode.
When there is strong sign that the VM is running on one of the cloud provider, then return
list containing only one provider. When there is no strong sign of one cloud provider, then
try to detect cloud provider using heuristics methods. In this case this method will return
list of all cloud providers sorted according detected probability
:return: List of string representing detected cloud providers. E.g. ['aws'] or ['aws', 'gcp']
"""
# Gather only information about hardware and virtualization
facts = {}
facts.update(HostCollector().get_all())
facts.update(HardwareCollector().get_all())
cloud_detectors = [cls(facts) for cls in CLOUD_DETECTORS]
log.debug('Trying to detect cloud provider')
# First try to detect cloud providers using strong signs
cloud_list = []
for cloud_detector in cloud_detectors:
cloud_detected = cloud_detector.is_running_on_cloud()
if cloud_detected is True:
cloud_list.append(cloud_detector.ID)
# When only one cloud provider was detected, then return the list with
# one cloud provider. Print error in other cases and try to detect cloud providers
# using heuristics methods
if len(cloud_list) == 1:
return cloud_list
elif len(cloud_list) == 0:
log.error('No cloud provider detected using strong signs')
elif len(cloud_list) > 1:
log.error(
'More than one cloud provider detected using strong signs ({providers})'
.format(providers=", ".join(cloud_list)))
# When no cloud provider detected using strong signs, because behavior of cloud providers
# has changed, then try to detect cloud provider using some heuristics
cloud_list = []
for cloud_detector in cloud_detectors:
probability = cloud_detector.is_likely_running_on_cloud()
if probability > 0.0:
cloud_list.append((probability, cloud_detector.ID))
# Sort list according probability (provider with highest probability first)
cloud_list.sort(reverse=True)
# We care only about order, not probability in the result (filter probability out)
cloud_list = [item[1] for item in cloud_list]
if len(cloud_list) == 0:
log.error('No cloud provider detected using heuristics')
return cloud_list
def _smoke_tests():
"""
Simple smoke tests of AWS detector and collector
:return: None
"""
# Gather only information about hardware and virtualization
from rhsmlib.facts.host_collector import HostCollector
from rhsmlib.facts.hwprobe import HardwareCollector
import sys
root = logging.getLogger()
root.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
handler.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
root.addHandler(handler)
facts = {}
facts.update(HostCollector().get_all())
facts.update(HardwareCollector().get_all())
aws_cloud_detector = AWSCloudDetector(facts)
result = aws_cloud_detector.is_running_on_cloud()
probability = aws_cloud_detector.is_likely_running_on_cloud()
print(
f'>>> debug <<< cloud provider: {result}, probability: {probability}')
if result is True:
metadata_collector = AWSCloudCollector()
metadata = metadata_collector.get_metadata()
print(f'>>> debug <<< cloud metadata: {metadata}')
signature = metadata_collector.get_signature()
print(f'>>> debug <<< metadata signature: {signature}')
metadata_v2 = metadata_collector._get_metadata_from_server_imds_v2()
print(f'>>> debug <<< cloud metadata: {metadata_v2}')
signature_v2 = metadata_collector._get_signature_from_server_imds_v2()
print(f'>>> debug <<< cloud signature: {signature_v2}')
found_google = False
found_gcp = False
for hw_item in self.hw_info.values():
if type(hw_item) != str:
continue
if 'google' in hw_item.lower():
found_google = True
elif 'gcp' in hw_item.lower():
found_gcp = True
if found_google is True:
probability += 0.3
if found_gcp is True:
probability += 0.1
return probability
# Some temporary smoke testing code. You can test this module using:
# sudo PYTHONPATH=./src:./syspurse/src python3 -m rhsmlib.cloud.providers.gcp
if __name__ == '__main__':
# Gather only information about hardware and virtualization
from rhsmlib.facts.host_collector import HostCollector
from rhsmlib.facts.hwprobe import HardwareCollector
_facts = {}
_facts.update(HostCollector().get_all())
_facts.update(HardwareCollector().get_all())
_gcp_cloud_detector = GCPCloudDetector(_facts)
_result = _gcp_cloud_detector.is_running_on_cloud()
_probability = _gcp_cloud_detector.is_likely_running_on_cloud()
print('>>> debug <<< result: %s, %6.3f' % (_result, _probability))