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))