From bfa931889269fc3868bd88a970b2ea1c0feb13da Mon Sep 17 00:00:00 2001 From: CentOS Sources Date: Oct 19 2017 13:26:06 +0000 Subject: import cloud-init-0.7.9-9.el7_4.1 --- diff --git a/SOURCES/0023-DatasourceEc2-add-warning-message-when-not-on-AWS.patch b/SOURCES/0023-DatasourceEc2-add-warning-message-when-not-on-AWS.patch new file mode 100644 index 0000000..89ae3c3 --- /dev/null +++ b/SOURCES/0023-DatasourceEc2-add-warning-message-when-not-on-AWS.patch @@ -0,0 +1,261 @@ +From 75ee377f902082f23de0feea190444e19a942420 Mon Sep 17 00:00:00 2001 +From: Scott Moser +Date: Thu, 23 Feb 2017 17:15:27 -0500 +Subject: [PATCH 2/5] DatasourceEc2: add warning message when not on AWS. + +Based on the setting Datasource/Ec2/strict_id, the datasource +will now warn once per instance. + +(cherry picked from commit 9bb55c6c45bcc5e310cf7e4d42cad53759dcca15) + +Resolves: rhbz#1496113 + +Signed-off-by: Ryan McCabe +--- + cloudinit/sources/DataSourceAliYun.py | 4 + + cloudinit/sources/DataSourceEc2.py | 178 +++++++++++++++++++++++++++++++++- + 2 files changed, 180 insertions(+), 2 deletions(-) + +diff --git a/cloudinit/sources/DataSourceAliYun.py b/cloudinit/sources/DataSourceAliYun.py +index 2d00255c..9debe947 100644 +--- a/cloudinit/sources/DataSourceAliYun.py ++++ b/cloudinit/sources/DataSourceAliYun.py +@@ -22,6 +22,10 @@ class DataSourceAliYun(EC2.DataSourceEc2): + def get_public_ssh_keys(self): + return parse_public_keys(self.metadata.get('public-keys', {})) + ++ @property ++ def cloud_platform(self): ++ return EC2.Platforms.ALIYUN ++ + + def parse_public_keys(public_keys): + keys = [] +diff --git a/cloudinit/sources/DataSourceEc2.py b/cloudinit/sources/DataSourceEc2.py +index c657fd09..26da263a 100644 +--- a/cloudinit/sources/DataSourceEc2.py ++++ b/cloudinit/sources/DataSourceEc2.py +@@ -9,6 +9,7 @@ + # This file is part of cloud-init. See LICENSE file for license information. + + import os ++import textwrap + import time + + from cloudinit import ec2_utils as ec2 +@@ -22,12 +23,23 @@ LOG = logging.getLogger(__name__) + # Which version we are requesting of the ec2 metadata apis + DEF_MD_VERSION = '2009-04-04' + ++STRICT_ID_PATH = ("datasource", "Ec2", "strict_id") ++STRICT_ID_DEFAULT = "warn" ++ ++ ++class Platforms(object): ++ ALIYUN = "AliYun" ++ AWS = "AWS" ++ SEEDED = "Seeded" ++ UNKNOWN = "Unknown" ++ + + class DataSourceEc2(sources.DataSource): + # Default metadata urls that will be used if none are provided + # They will be checked for 'resolveability' and some of the + # following may be discarded if they do not resolve + metadata_urls = ["http://169.254.169.254", "http://instance-data.:8773"] ++ _cloud_platform = None + + def __init__(self, sys_cfg, distro, paths): + sources.DataSource.__init__(self, sys_cfg, distro, paths) +@@ -41,8 +53,18 @@ class DataSourceEc2(sources.DataSource): + self.userdata_raw = seed_ret['user-data'] + self.metadata = seed_ret['meta-data'] + LOG.debug("Using seeded ec2 data from %s", self.seed_dir) ++ self._cloud_platform = Platforms.SEEDED + return True + ++ strict_mode, _sleep = read_strict_mode( ++ util.get_cfg_by_path(self.sys_cfg, STRICT_ID_PATH, ++ STRICT_ID_DEFAULT), ("warn", None)) ++ ++ LOG.debug("strict_mode: %s, cloud_platform=%s", ++ strict_mode, self.cloud_platform) ++ if strict_mode == "true" and self.cloud_platform == Platforms.UNKNOWN: ++ return False ++ + try: + if not self.wait_for_metadata_service(): + return False +@@ -51,8 +73,8 @@ class DataSourceEc2(sources.DataSource): + ec2.get_instance_userdata(self.api_ver, self.metadata_address) + self.metadata = ec2.get_instance_metadata(self.api_ver, + self.metadata_address) +- LOG.debug("Crawl of metadata service took %s seconds", +- int(time.time() - start_time)) ++ LOG.debug("Crawl of metadata service took %.3f seconds", ++ time.time() - start_time) + return True + except Exception: + util.logexc(LOG, "Failed reading from metadata address %s", +@@ -190,6 +212,158 @@ class DataSourceEc2(sources.DataSource): + return az[:-1] + return None + ++ @property ++ def cloud_platform(self): ++ if self._cloud_platform is None: ++ self._cloud_platform = identify_platform() ++ return self._cloud_platform ++ ++ def activate(self, cfg, is_new_instance): ++ if not is_new_instance: ++ return ++ if self.cloud_platform == Platforms.UNKNOWN: ++ warn_if_necessary( ++ util.get_cfg_by_path(cfg, STRICT_ID_PATH, STRICT_ID_DEFAULT)) ++ ++ ++def read_strict_mode(cfgval, default): ++ try: ++ return parse_strict_mode(cfgval) ++ except ValueError as e: ++ LOG.warn(e) ++ return default ++ ++ ++def parse_strict_mode(cfgval): ++ # given a mode like: ++ # true, false, warn,[sleep] ++ # return tuple with string mode (true|false|warn) and sleep. ++ if cfgval is True: ++ return 'true', None ++ if cfgval is False: ++ return 'false', None ++ ++ if not cfgval: ++ return 'warn', 0 ++ ++ mode, _, sleep = cfgval.partition(",") ++ if mode not in ('true', 'false', 'warn'): ++ raise ValueError( ++ "Invalid mode '%s' in strict_id setting '%s': " ++ "Expected one of 'true', 'false', 'warn'." % (mode, cfgval)) ++ ++ if sleep: ++ try: ++ sleep = int(sleep) ++ except ValueError: ++ raise ValueError("Invalid sleep '%s' in strict_id setting '%s': " ++ "not an integer" % (sleep, cfgval)) ++ else: ++ sleep = None ++ ++ return mode, sleep ++ ++ ++def warn_if_necessary(cfgval): ++ try: ++ mode, sleep = parse_strict_mode(cfgval) ++ except ValueError as e: ++ LOG.warn(e) ++ return ++ ++ if mode == "false": ++ return ++ ++ show_warning(sleep) ++ ++ ++def show_warning(sleep): ++ message = textwrap.dedent(""" ++ **************************************************************** ++ # This system is using the EC2 Metadata Service, but does not # ++ # appear to be running on Amazon EC2 or one of cloud-init's # ++ # known platforms that provide a EC2 Metadata service. In the # ++ # future, cloud-init may stop reading metadata from the EC2 # ++ # Metadata Service unless the platform can be identified # ++ # # ++ # If you are seeing this message, please file a bug against # ++ # cloud-init at https://bugs.launchpad.net/cloud-init/+filebug # ++ # Make sure to include the cloud provider your instance is # ++ # running on. # ++ # # ++ # For more information see # ++ # https://bugs.launchpad.net/cloud-init/+bug/1660385 # ++ # # ++ # After you have filed a bug, you can disable this warning by # ++ # launching your instance with the cloud-config below, or # ++ # putting that content into # ++ # /etc/cloud/cloud.cfg.d/99-ec2-datasource.cfg # ++ # # ++ # #cloud-config # ++ # datasource: # ++ # Ec2: # ++ # strict_id: false # ++ # # ++ """) ++ closemsg = "" ++ if sleep: ++ closemsg = " [sleeping for %d seconds] " % sleep ++ message += closemsg.center(64, "*") ++ print(message) ++ LOG.warn(message) ++ if sleep: ++ time.sleep(sleep) ++ ++ ++def identify_aws(data): ++ # data is a dictionary returned by _collect_platform_data. ++ if (data['uuid'].startswith('ec2') and ++ (data['uuid_source'] == 'hypervisor' or ++ data['uuid'] == data['serial'])): ++ return Platforms.AWS ++ ++ return None ++ ++ ++def identify_platform(): ++ # identify the platform and return an entry in Platforms. ++ data = _collect_platform_data() ++ checks = (identify_aws, lambda x: Platforms.UNKNOWN) ++ for checker in checks: ++ try: ++ result = checker(data) ++ if result: ++ return result ++ except Exception as e: ++ LOG.warn("calling %s with %s raised exception: %s", ++ checker, data, e) ++ ++ ++def _collect_platform_data(): ++ # returns a dictionary with all lower case values: ++ # uuid: system-uuid from dmi or /sys/hypervisor ++ # uuid_source: 'hypervisor' (/sys/hypervisor/uuid) or 'dmi' ++ # serial: dmi 'system-serial-number' (/sys/.../product_serial) ++ data = {} ++ try: ++ uuid = util.load_file("/sys/hypervisor/uuid").strip() ++ data['uuid_source'] = 'hypervisor' ++ except Exception: ++ uuid = util.read_dmi_data('system-uuid') ++ data['uuid_source'] = 'dmi' ++ ++ if uuid is None: ++ uuid = '' ++ data['uuid'] = uuid.lower() ++ ++ serial = util.read_dmi_data('system-serial-number') ++ if serial is None: ++ serial = '' ++ ++ data['serial'] = serial.lower() ++ ++ return data ++ + + # Used to match classes to dependencies + datasources = [ +-- +2.13.5 + diff --git a/SOURCES/0024-Identify-Brightbox-as-an-Ec2-datasource-user.patch b/SOURCES/0024-Identify-Brightbox-as-an-Ec2-datasource-user.patch new file mode 100644 index 0000000..148e7a1 --- /dev/null +++ b/SOURCES/0024-Identify-Brightbox-as-an-Ec2-datasource-user.patch @@ -0,0 +1,50 @@ +From 9044e39b1db9da242c244202ad649c5f8b05bc12 Mon Sep 17 00:00:00 2001 +From: Scott Moser +Date: Fri, 24 Feb 2017 14:19:20 -0500 +Subject: [PATCH 3/5] Identify Brightbox as an Ec2 datasource user. + +Brightbox will identify their platform to the guest by setting the +product serial to a string that ends with 'brightbox.com'. + +LP: #1661693 +(cherry picked from commit 5dd5b2cb539a84ed59f2b3181020d2bd18989718) + +Resolves: rhbz#1496113 + +Signed-off-by: Ryan McCabe +--- + cloudinit/sources/DataSourceEc2.py | 8 +++++++- + 1 file changed, 7 insertions(+), 1 deletion(-) + +diff --git a/cloudinit/sources/DataSourceEc2.py b/cloudinit/sources/DataSourceEc2.py +index 26da263a..c7df8060 100644 +--- a/cloudinit/sources/DataSourceEc2.py ++++ b/cloudinit/sources/DataSourceEc2.py +@@ -30,6 +30,7 @@ STRICT_ID_DEFAULT = "warn" + class Platforms(object): + ALIYUN = "AliYun" + AWS = "AWS" ++ BRIGHTBOX = "Brightbox" + SEEDED = "Seeded" + UNKNOWN = "Unknown" + +@@ -325,10 +326,15 @@ def identify_aws(data): + return None + + ++def identify_brightbox(data): ++ if data['serial'].endswith('brightbox.com'): ++ return Platforms.BRIGHTBOX ++ ++ + def identify_platform(): + # identify the platform and return an entry in Platforms. + data = _collect_platform_data() +- checks = (identify_aws, lambda x: Platforms.UNKNOWN) ++ checks = (identify_aws, identify_brightbox, lambda x: Platforms.UNKNOWN) + for checker in checks: + try: + result = checker(data) +-- +2.13.5 + diff --git a/SOURCES/0025-AliYun-Enable-platform-identification-and-enable-by-.patch b/SOURCES/0025-AliYun-Enable-platform-identification-and-enable-by-.patch new file mode 100644 index 0000000..ac01a97 --- /dev/null +++ b/SOURCES/0025-AliYun-Enable-platform-identification-and-enable-by-.patch @@ -0,0 +1,195 @@ +From a7727ecf117a2bc02f68405823796afe1d76d3e3 Mon Sep 17 00:00:00 2001 +From: Junjie Wang +Date: Fri, 21 Apr 2017 20:06:09 +0800 +Subject: [PATCH 4/5] AliYun: Enable platform identification and enable by + default. + +AliYun cloud platform is now identifying themselves by setting the dmi +product id to the well known value "Alibaba Cloud ECS". The changes here +identify that properly in tools/ds-identify and in the DataSourceAliYun. + +Since the 'get_data' for AliYun now identifies itself correctly, we can +enable AliYun by default. + +LP: #1638931 +(cherry picked from commit 4a60af54957634920e84a928aa22b4fc9a6dfd11) + +Resolves: rhbz#1496113 + +Signed-off-by: Ryan McCabe +--- + cloudinit/settings.py | 1 + + cloudinit/sources/DataSourceAliYun.py | 14 ++++++- + cloudinit/sources/DataSourceEc2.py | 7 ++++ + tests/unittests/test_datasource/test_aliyun.py | 51 +++++++++++++++++++++++++- + tests/unittests/test_datasource/test_common.py | 1 + + 5 files changed, 71 insertions(+), 3 deletions(-) + +diff --git a/cloudinit/settings.py b/cloudinit/settings.py +index 0d39aab7..d6046dc6 100644 +--- a/cloudinit/settings.py ++++ b/cloudinit/settings.py +@@ -27,6 +27,7 @@ CFG_BUILTIN = { + 'MAAS', + 'GCE', + 'OpenStack', ++ 'AliYun', + 'Ec2', + 'CloudSigma', + 'CloudStack', +diff --git a/cloudinit/sources/DataSourceAliYun.py b/cloudinit/sources/DataSourceAliYun.py +index 9debe947..380e27cb 100644 +--- a/cloudinit/sources/DataSourceAliYun.py ++++ b/cloudinit/sources/DataSourceAliYun.py +@@ -4,8 +4,10 @@ import os + + from cloudinit import sources + from cloudinit.sources import DataSourceEc2 as EC2 ++from cloudinit import util + + DEF_MD_VERSION = "2016-01-01" ++ALIYUN_PRODUCT = "Alibaba Cloud ECS" + + + class DataSourceAliYun(EC2.DataSourceEc2): +@@ -24,7 +26,17 @@ class DataSourceAliYun(EC2.DataSourceEc2): + + @property + def cloud_platform(self): +- return EC2.Platforms.ALIYUN ++ if self._cloud_platform is None: ++ if _is_aliyun(): ++ self._cloud_platform = EC2.Platforms.ALIYUN ++ else: ++ self._cloud_platform = EC2.Platforms.NO_EC2_METADATA ++ ++ return self._cloud_platform ++ ++ ++def _is_aliyun(): ++ return util.read_dmi_data('system-product-name') == ALIYUN_PRODUCT + + + def parse_public_keys(public_keys): +diff --git a/cloudinit/sources/DataSourceEc2.py b/cloudinit/sources/DataSourceEc2.py +index c7df8060..31825665 100644 +--- a/cloudinit/sources/DataSourceEc2.py ++++ b/cloudinit/sources/DataSourceEc2.py +@@ -32,7 +32,12 @@ class Platforms(object): + AWS = "AWS" + BRIGHTBOX = "Brightbox" + SEEDED = "Seeded" ++ # UNKNOWN indicates no positive id. If strict_id is 'warn' or 'false', ++ # then an attempt at the Ec2 Metadata service will be made. + UNKNOWN = "Unknown" ++ # NO_EC2_METADATA indicates this platform does not have a Ec2 metadata ++ # service available. No attempt at the Ec2 Metadata service will be made. ++ NO_EC2_METADATA = "No-EC2-Metadata" + + + class DataSourceEc2(sources.DataSource): +@@ -65,6 +70,8 @@ class DataSourceEc2(sources.DataSource): + strict_mode, self.cloud_platform) + if strict_mode == "true" and self.cloud_platform == Platforms.UNKNOWN: + return False ++ elif self.cloud_platform == Platforms.NO_EC2_METADATA: ++ return False + + try: + if not self.wait_for_metadata_service(): +diff --git a/tests/unittests/test_datasource/test_aliyun.py b/tests/unittests/test_datasource/test_aliyun.py +index c16d1a6e..990bff2c 100644 +--- a/tests/unittests/test_datasource/test_aliyun.py ++++ b/tests/unittests/test_datasource/test_aliyun.py +@@ -2,6 +2,7 @@ + + import functools + import httpretty ++import mock + import os + + from .. import helpers as test_helpers +@@ -111,15 +112,29 @@ class TestAliYunDatasource(test_helpers.HttprettyTestCase): + self.assertEqual(self.default_metadata['hostname'], + self.ds.get_hostname()) + ++ @mock.patch("cloudinit.sources.DataSourceAliYun._is_aliyun") + @httpretty.activate +- def test_with_mock_server(self): ++ def test_with_mock_server(self, m_is_aliyun): ++ m_is_aliyun.return_value = True + self.regist_default_server() +- self.ds.get_data() ++ ret = self.ds.get_data() ++ self.assertEqual(True, ret) ++ self.assertEqual(1, m_is_aliyun.call_count) + self._test_get_data() + self._test_get_sshkey() + self._test_get_iid() + self._test_host_name() + ++ @mock.patch("cloudinit.sources.DataSourceAliYun._is_aliyun") ++ @httpretty.activate ++ def test_returns_false_when_not_on_aliyun(self, m_is_aliyun): ++ """If is_aliyun returns false, then get_data should return False.""" ++ m_is_aliyun.return_value = False ++ self.regist_default_server() ++ ret = self.ds.get_data() ++ self.assertEqual(1, m_is_aliyun.call_count) ++ self.assertEqual(False, ret) ++ + def test_parse_public_keys(self): + public_keys = {} + self.assertEqual(ay.parse_public_keys(public_keys), []) +@@ -149,4 +164,36 @@ class TestAliYunDatasource(test_helpers.HttprettyTestCase): + self.assertEqual(ay.parse_public_keys(public_keys), + public_keys['key-pair-0']['openssh-key']) + ++ ++class TestIsAliYun(test_helpers.CiTestCase): ++ ALIYUN_PRODUCT = 'Alibaba Cloud ECS' ++ read_dmi_data_expected = [mock.call('system-product-name')] ++ ++ @mock.patch("cloudinit.sources.DataSourceAliYun.util.read_dmi_data") ++ def test_true_on_aliyun_product(self, m_read_dmi_data): ++ """Should return true if the dmi product data has expected value.""" ++ m_read_dmi_data.return_value = self.ALIYUN_PRODUCT ++ ret = ay._is_aliyun() ++ self.assertEqual(self.read_dmi_data_expected, ++ m_read_dmi_data.call_args_list) ++ self.assertEqual(True, ret) ++ ++ @mock.patch("cloudinit.sources.DataSourceAliYun.util.read_dmi_data") ++ def test_false_on_empty_string(self, m_read_dmi_data): ++ """Should return false on empty value returned.""" ++ m_read_dmi_data.return_value = "" ++ ret = ay._is_aliyun() ++ self.assertEqual(self.read_dmi_data_expected, ++ m_read_dmi_data.call_args_list) ++ self.assertEqual(False, ret) ++ ++ @mock.patch("cloudinit.sources.DataSourceAliYun.util.read_dmi_data") ++ def test_false_on_unknown_string(self, m_read_dmi_data): ++ """Should return false on an unrelated string.""" ++ m_read_dmi_data.return_value = "cubs win" ++ ret = ay._is_aliyun() ++ self.assertEqual(self.read_dmi_data_expected, ++ m_read_dmi_data.call_args_list) ++ self.assertEqual(False, ret) ++ + # vi: ts=4 expandtab +diff --git a/tests/unittests/test_datasource/test_common.py b/tests/unittests/test_datasource/test_common.py +index c08717f3..7649b9ae 100644 +--- a/tests/unittests/test_datasource/test_common.py ++++ b/tests/unittests/test_datasource/test_common.py +@@ -36,6 +36,7 @@ DEFAULT_LOCAL = [ + ] + + DEFAULT_NETWORK = [ ++ AliYun.DataSourceAliYun, + AltCloud.DataSourceAltCloud, + Azure.DataSourceAzureNet, + Bigstep.DataSourceBigstep, +-- +2.13.5 + diff --git a/SOURCES/0026-Fix-alibaba-cloud-unit-tests-to-work-with-0.7.9.patch b/SOURCES/0026-Fix-alibaba-cloud-unit-tests-to-work-with-0.7.9.patch new file mode 100644 index 0000000..1755547 --- /dev/null +++ b/SOURCES/0026-Fix-alibaba-cloud-unit-tests-to-work-with-0.7.9.patch @@ -0,0 +1,29 @@ +From b87c46fe008dc4df50b0103d598d218f8dd26735 Mon Sep 17 00:00:00 2001 +From: Ryan McCabe +Date: Tue, 5 Sep 2017 13:02:00 -0400 +Subject: [PATCH 5/5] Fix alibaba cloud unit tests to work with 0.7.9 + +Resolves: rhbz#1496113 +X-downstream-only: Yes + +Signed-off-by: Ryan McCabe +--- + tests/unittests/test_datasource/test_aliyun.py | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/tests/unittests/test_datasource/test_aliyun.py b/tests/unittests/test_datasource/test_aliyun.py +index 990bff2c..90454c8d 100644 +--- a/tests/unittests/test_datasource/test_aliyun.py ++++ b/tests/unittests/test_datasource/test_aliyun.py +@@ -165,7 +165,7 @@ class TestAliYunDatasource(test_helpers.HttprettyTestCase): + public_keys['key-pair-0']['openssh-key']) + + +-class TestIsAliYun(test_helpers.CiTestCase): ++class TestIsAliYun(test_helpers.HttprettyTestCase): + ALIYUN_PRODUCT = 'Alibaba Cloud ECS' + read_dmi_data_expected = [mock.call('system-product-name')] + +-- +2.13.5 + diff --git a/SOURCES/cloud-init-add-centos-os.patch b/SOURCES/cloud-init-add-centos-os.patch deleted file mode 100644 index 977c156..0000000 --- a/SOURCES/cloud-init-add-centos-os.patch +++ /dev/null @@ -1,43 +0,0 @@ -diff --git a/cloudinit/distros/__init__.py b/cloudinit/distros/__init__.py -index f56c0cf..1fd48a7 100755 ---- a/cloudinit/distros/__init__.py -+++ b/cloudinit/distros/__init__.py -@@ -32,7 +32,7 @@ from cloudinit.distros.parsers import hosts - - OSFAMILIES = { - 'debian': ['debian', 'ubuntu'], -- 'redhat': ['fedora', 'rhel'], -+ 'redhat': ['centos', 'fedora', 'rhel'], - 'gentoo': ['gentoo'], - 'freebsd': ['freebsd'], - 'suse': ['sles'], -diff --git a/cloudinit/distros/centos.py b/cloudinit/distros/centos.py -new file mode 100644 -index 0000000..4b803d2 ---- /dev/null -+++ b/cloudinit/distros/centos.py -@@ -0,0 +1,12 @@ -+# This file is part of cloud-init. See LICENSE file for license information. -+ -+from cloudinit.distros import rhel -+from cloudinit import log as logging -+ -+LOG = logging.getLogger(__name__) -+ -+ -+class Distro(rhel.Distro): -+ pass -+ -+# vi: ts=4 expandtab -diff -uNr cloud-init-0.7.9__orig/rhel/cloud.cfg cloud-init-0.7.9/rhel/cloud.cfg ---- cloud-init-0.7.9__orig/rhel/cloud.cfg 2017-09-05 22:20:14.302075947 +0100 -+++ cloud-init-0.7.9/rhel/cloud.cfg 2017-09-05 22:20:37.912076373 +0100 -@@ -52,7 +52,7 @@ - - system_info: - default_user: -- name: cloud-user -+ name: centos - lock_passwd: true - gecos: Cloud User - groups: [wheel, adm, systemd-journal] diff --git a/SOURCES/cloud-init-rhel.cfg b/SOURCES/cloud-init-rhel.cfg index d097c1d..986f241 100644 --- a/SOURCES/cloud-init-rhel.cfg +++ b/SOURCES/cloud-init-rhel.cfg @@ -51,7 +51,7 @@ cloud_final_modules: system_info: default_user: - name: centos + name: cloud-user lock_passwd: true gecos: Cloud User groups: [wheel, adm, systemd-journal] diff --git a/SPECS/cloud-init.spec b/SPECS/cloud-init.spec index 89691ae..5d1f07c 100644 --- a/SPECS/cloud-init.spec +++ b/SPECS/cloud-init.spec @@ -7,7 +7,7 @@ Name: cloud-init Version: 0.7.9 -Release: 9%{?dist}.2 +Release: 9%{?dist}.1 Summary: Cloud instance init scripts Group: System Environment/Base @@ -44,7 +44,10 @@ Patch0019: 0019-Add-missing-sysconfig-unit-test-data.patch Patch0020: 0020-Fix-ipv6-subnet-detection.patch Patch0021: 0021-azure-ensure-that-networkmanager-hook-script-runs.patch Patch0022: 0022-RHEL-CentOS-Fix-default-routes-for-IPv4-IPv6-configu.patch -Patch9999: cloud-init-add-centos-os.patch +Patch0023: 0023-DatasourceEc2-add-warning-message-when-not-on-AWS.patch +Patch0024: 0024-Identify-Brightbox-as-an-Ec2-datasource-user.patch +Patch0025: 0025-AliYun-Enable-platform-identification-and-enable-by-.patch +Patch0026: 0026-Fix-alibaba-cloud-unit-tests-to-work-with-0.7.9.patch # Deal with noarch -> arch # https://bugzilla.redhat.com/show_bug.cgi?id=1067089 @@ -180,10 +183,8 @@ fi %config(noreplace) %{_sysconfdir}/rsyslog.d/21-cloudinit.conf %changelog -* Tue Sep 5 2017 Karanbir Singh 0.7.9-9.el7.centos.1 -- Roll in CentOS Branding -- set default user to centos -- assume Red Hat compatibility +* Tue Sep 26 2017 Ryan McCabe 0.7.9-9.1 +- Support AliCloud datasource (rhbz#1496113) * Thu Jun 22 2017 Lars Kellogg-Stedman 0.7.9-9 - RHEL/CentOS: Fix default routes for IPv4/IPv6 configuration. (rhbz#1438082)