Merge pull request #2530 from Azure/release-2.7.0.0

Merge release 2.7  to master

Author: narrieta

README.md

@@ -195,7 +195,7 @@ ResourceDisk.EnableSwap=n
 ResourceDisk.EnableSwapEncryption=n
 ResourceDisk.SwapSizeMB=0
 Logs.Verbose=n
-Logs.Collect=n
+Logs.Collect=y
 Logs.CollectPeriod=3600
 OS.AllowHTTP=n
 OS.RootDeviceScsiTimeout=300
@@ -461,10 +461,12 @@ leverages the system logrotate functionality to rotate logs.
 #### __Logs.Collect__
 
 _Type: Boolean_  
-_Default: n_
+_Default: y_
 
 If set, agent logs will be periodically collected and uploaded to a secure location for improved supportability.
 
+NOTE: This feature is only supported ubuntu 16.04+; this flag will not take effect on any other distro.
+
 #### __Logs.CollectPeriod__
 
 _Type: Integer_  

azurelinuxagent/common/AgentGlobals.py

@@ -22,11 +22,13 @@ class AgentGlobals(object):
     This class is used for setting AgentGlobals which can be used all throughout the Agent.
     """
 
+    GUID_ZERO = "00000000-0000-0000-0000-000000000000"
+
     #
     # Some modules (e.g. telemetry) require an up-to-date container ID. We update this variable each time we
     # fetch the goal state.
     #
-    _container_id = "00000000-0000-0000-0000-000000000000"
+    _container_id = GUID_ZERO
 
     @staticmethod
     def get_container_id():

azurelinuxagent/common/cgroupapi.py

@@ -26,7 +26,8 @@
 from azurelinuxagent.common.cgroup import CpuCgroup
 from azurelinuxagent.common.cgroupstelemetry import CGroupsTelemetry
 from azurelinuxagent.common.conf import get_agent_pid_file_path
-from azurelinuxagent.common.exception import CGroupsException, ExtensionErrorCodes, ExtensionError, ExtensionOperationError
+from azurelinuxagent.common.exception import CGroupsException, ExtensionErrorCodes, ExtensionError, \
+    ExtensionOperationError
 from azurelinuxagent.common.future import ustr
 from azurelinuxagent.common.osutil import systemd
 from azurelinuxagent.common.utils import fileutil, shellutil
@@ -39,10 +40,12 @@
 CGROUP_CONTROLLERS = ["cpu", "memory"]
 EXTENSION_SLICE_PREFIX = "azure-vmextensions"
 
+
 class SystemdRunError(CGroupsException):
     """
     Raised when systemd-run fails
     """
+
     def __init__(self, msg=None):
         super(SystemdRunError, self).__init__(msg)
 
@@ -56,7 +59,9 @@ def cgroups_supported():
             distro_version = FlexibleVersion(distro_info[1])
         except ValueError:
             return False
-        return distro_name.lower() == 'ubuntu' and distro_version.major >= 16
+        return ((distro_name.lower() == 'ubuntu' and distro_version.major >= 16) or
+                (distro_name.lower() in ("centos", "redhat") and
+                 ((distro_version.major == 7 and distro_version.minor >= 8) or distro_version.major >= 8)))
 
     @staticmethod
     def track_cgroups(extension_cgroups):
@@ -118,6 +123,7 @@ class SystemdCgroupsApi(CGroupsApi):
     """
     Cgroups interface via systemd
     """
+
     def __init__(self):
         self._cgroup_mountpoints = None
         self._agent_unit_name = None
@@ -156,7 +162,7 @@ def get_cgroup_mount_points(self):
                         memory = path
             self._cgroup_mountpoints = {'cpu': cpu, 'memory': memory}
 
-        return self._cgroup_mountpoints['cpu'],  self._cgroup_mountpoints['memory']
+        return self._cgroup_mountpoints['cpu'], self._cgroup_mountpoints['memory']
 
     @staticmethod
     def get_process_cgroup_relative_paths(process_id):
@@ -253,7 +259,8 @@ def get_extension_slice_name(extension_name):
         # Since '-' is used as a separator in systemd unit names, we replace it with '_' to prevent side-effects.
         return EXTENSION_SLICE_PREFIX + "-" + extension_name.replace('-', '_') + ".slice"
 
-    def start_extension_command(self, extension_name, command, cmd_name, timeout, shell, cwd, env, stdout, stderr, error_code=ExtensionErrorCodes.PluginUnknownFailure):
+    def start_extension_command(self, extension_name, command, cmd_name, timeout, shell, cwd, env, stdout, stderr,
+                                error_code=ExtensionErrorCodes.PluginUnknownFailure):
         scope = "{0}_{1}".format(cmd_name, uuid.uuid4())
         extension_slice_name = self.get_extension_slice_name(extension_name)
         with self._systemd_run_commands_lock:
@@ -293,7 +300,8 @@ def start_extension_command(self, extension_name, command, cmd_name, timeout, sh
 
         # Wait for process completion or timeout
         try:
-            return handle_process_completion(process=process, command=command, timeout=timeout, stdout=stdout, stderr=stderr, error_code=error_code)
+            return handle_process_completion(process=process, command=command, timeout=timeout, stdout=stdout,
+                                             stderr=stderr, error_code=error_code)
         except ExtensionError as e:
             # The extension didn't terminate successfully. Determine whether it was due to systemd errors or
             # extension errors.
@@ -309,7 +317,8 @@ def start_extension_command(self, extension_name, command, cmd_name, timeout, sh
 
             if isinstance(e, ExtensionOperationError):
                 # no-member: Instance of 'ExtensionError' has no 'exit_code' member (no-member) - Disabled: e is actually an ExtensionOperationError
-                err_msg = 'Systemd process exited with code %s and output %s' % (e.exit_code, process_output)  # pylint: disable=no-member
+                err_msg = 'Systemd process exited with code %s and output %s' % (
+                    e.exit_code, process_output)  # pylint: disable=no-member
             else:
                 err_msg = "Systemd timed-out, output: %s" % process_output
             raise SystemdRunError(err_msg)

azurelinuxagent/common/cgroupconfigurator.py

@@ -96,11 +96,13 @@
 """
 _AGENT_THROTTLED_TIME_THRESHOLD = 120  # 2 minutes
 
+
 class DisableCgroups(object):
     ALL = "all"
     AGENT = "agent"
     EXTENSIONS = "extensions"
 
+
 def _log_cgroup_info(format_string, *args):
     message = format_string.format(*args)
     logger.info("[CGI] " + message)
@@ -120,6 +122,7 @@ class CGroupConfigurator(object):
     NOTE: with the exception of start_extension_command, none of the methods in this class
     raise exceptions (cgroup operations should not block extensions)
     """
+
     class _Impl(object):
         def __init__(self):
             self._initialized = False
@@ -165,7 +168,9 @@ def initialize(self):
                 self.__setup_azure_slice()
 
                 cpu_controller_root, memory_controller_root = self.__get_cgroup_controllers()
-                self._agent_cpu_cgroup_path, self._agent_memory_cgroup_path = self.__get_agent_cgroups(agent_slice, cpu_controller_root, memory_controller_root)
+                self._agent_cpu_cgroup_path, self._agent_memory_cgroup_path = self.__get_agent_cgroups(agent_slice,
+                                                                                                       cpu_controller_root,
+                                                                                                       memory_controller_root)
 
                 if self._agent_cpu_cgroup_path is not None:
                     _log_cgroup_info("Agent CPU cgroup: {0}", self._agent_cpu_cgroup_path)
@@ -218,7 +223,7 @@ def __collect_agent_unit_files_telemetry():
             agent_service_name = get_osutil().get_service_name()
             try:
                 fragment_path = systemd.get_unit_property(agent_service_name, "FragmentPath")
-                if fragment_path != "/lib/systemd/system/{0}.service".format(agent_service_name):
+                if fragment_path != systemd.get_agent_unit_file():
                     agent_unit_files.append(fragment_path)
             except Exception as exception:
                 _log_cgroup_warning("Failed to query the agent's FragmentPath: {0}", ustr(exception))
@@ -233,7 +238,8 @@ def __collect_agent_unit_files_telemetry():
             for unit_file in agent_unit_files:
                 try:
                     with open(unit_file, "r") as file_object:
-                        _log_cgroup_info("Found a custom unit file for the agent: {0}\n{1}", unit_file, file_object.read())
+                        _log_cgroup_info("Found a custom unit file for the agent: {0}\n{1}", unit_file,
+                                         file_object.read())
                 except Exception as exception:
                     _log_cgroup_warning("Can't read {0}: {1}", unit_file, ustr(exception))
 
@@ -269,7 +275,8 @@ def __get_cgroup_controllers(self):
             #
             cgroup2_mount_point, cgroup2_controllers = self._cgroups_api.get_cgroup2_controllers()
             if cgroup2_mount_point is not None:
-                _log_cgroup_info("cgroups v2 mounted at {0}.  Controllers: [{1}]", cgroup2_mount_point, cgroup2_controllers)
+                _log_cgroup_info("cgroups v2 mounted at {0}.  Controllers: [{1}]", cgroup2_mount_point,
+                                 cgroup2_controllers)
 
             return cpu_controller_root, memory_controller_root
 
@@ -322,7 +329,7 @@ def __setup_azure_slice():
 
             if not os.path.exists(logcollector_slice):
                 slice_contents = _LOGCOLLECTOR_SLICE_CONTENTS_FMT.format(cpu_quota=_LOGCOLLECTOR_CPU_QUOTA,
-                    memory_limit=_LOGCOLLECTOR_MEMORY_LIMIT)
+                                                                         memory_limit=_LOGCOLLECTOR_MEMORY_LIMIT)
 
                 files_to_create.append((logcollector_slice, slice_contents))
 
@@ -408,7 +415,8 @@ def __get_agent_cgroups(self, agent_slice, cpu_controller_root, memory_controlle
             agent_unit_name = systemd.get_agent_unit_name()
 
             expected_relative_path = os.path.join(agent_slice, agent_unit_name)
-            cpu_cgroup_relative_path, memory_cgroup_relative_path = self._cgroups_api.get_process_cgroup_relative_paths("self")
+            cpu_cgroup_relative_path, memory_cgroup_relative_path = self._cgroups_api.get_process_cgroup_relative_paths(
+                "self")
 
             if cpu_cgroup_relative_path is None:
                 _log_cgroup_warning("The agent's process is not within a CPU cgroup")
@@ -417,11 +425,11 @@ def __get_agent_cgroups(self, agent_slice, cpu_controller_root, memory_controlle
                     _log_cgroup_info('CPUAccounting: {0}', systemd.get_unit_property(agent_unit_name, "CPUAccounting"))
                     _log_cgroup_info('CPUQuota: {0}', systemd.get_unit_property(agent_unit_name, "CPUQuotaPerSecUSec"))
                 else:
-                    cpu_cgroup_relative_path = None  # Set the path to None to prevent monitoring
                     _log_cgroup_warning(
                         "The Agent is not in the expected CPU cgroup; will not enable monitoring. Cgroup:[{0}] Expected:[{1}]",
                         cpu_cgroup_relative_path,
                         expected_relative_path)
+                    cpu_cgroup_relative_path = None  # Set the path to None to prevent monitoring
 
             if memory_cgroup_relative_path is None:
                 _log_cgroup_warning("The agent's process is not within a memory cgroup")
@@ -430,11 +438,11 @@ def __get_agent_cgroups(self, agent_slice, cpu_controller_root, memory_controlle
                     memory_accounting = systemd.get_unit_property(agent_unit_name, "MemoryAccounting")
                     _log_cgroup_info('MemoryAccounting: {0}', memory_accounting)
                 else:
-                    memory_cgroup_relative_path = None  # Set the path to None to prevent monitoring
                     _log_cgroup_info(
                         "The Agent is not in the expected memory cgroup; will not enable monitoring. CGroup:[{0}] Expected:[{1}]",
                         memory_cgroup_relative_path,
                         expected_relative_path)
+                    memory_cgroup_relative_path = None  # Set the path to None to prevent monitoring
 
             if cpu_controller_root is not None and cpu_cgroup_relative_path is not None:
                 agent_cpu_cgroup_path = os.path.join(cpu_controller_root, cpu_cgroup_relative_path)
@@ -462,30 +470,30 @@ def extensions_enabled(self):
 
         def enable(self):
             if not self.supported():
-                raise CGroupsException("Attempted to enable cgroups, but they are not supported on the current platform")
+                raise CGroupsException(
+                    "Attempted to enable cgroups, but they are not supported on the current platform")
             self._agent_cgroups_enabled = True
             self._extensions_cgroups_enabled = True
             self.__set_cpu_quota(conf.get_agent_cpu_quota())
 
-        def disable(self, reason, disableCgroups):
+        def disable(self, reason, disable_cgroups):
             # Todo: disable/reset extension when ext quotas introduced
-            if disableCgroups == DisableCgroups.ALL:                 # disable all
+            if disable_cgroups == DisableCgroups.ALL:  # disable all
                 self._agent_cgroups_enabled = False
                 self._extensions_cgroups_enabled = False
                 self.__reset_agent_cpu_quota()
                 CGroupsTelemetry.reset()
-            elif disableCgroups == DisableCgroups.AGENT: # disable agent
+            elif disable_cgroups == DisableCgroups.AGENT:  # disable agent
                 self._agent_cgroups_enabled = False
                 self.__reset_agent_cpu_quota()
                 CGroupsTelemetry.stop_tracking(CpuCgroup(AGENT_NAME_TELEMETRY, self._agent_cpu_cgroup_path))
-            elif disableCgroups == DisableCgroups.EXTENSIONS: # disable extensions
+            elif disable_cgroups == DisableCgroups.EXTENSIONS:  # disable extensions
                 self._extensions_cgroups_enabled = False
 
             message = "[CGW] Disabling resource usage monitoring. Reason: {0}".format(reason)
             logger.info(message)  # log as INFO for now, in the future it should be logged as WARNING
             add_event(op=WALAEventOperation.CGroupsDisabled, message=message, is_success=False, log_event=False)
 
-
         @staticmethod
         def __set_cpu_quota(quota):
             """
@@ -510,6 +518,7 @@ def __reset_agent_cpu_quota():
             logger.info("Resetting agent's CPUQuota")
             if CGroupConfigurator._Impl.__try_set_cpu_quota(''):  # setting an empty value resets to the default (infinity)
                 CGroupsTelemetry.set_track_throttled_time(False)
+                _log_cgroup_info('CPUQuota: {0}', systemd.get_unit_property(systemd.get_agent_unit_name(), "CPUQuotaPerSecUSec"))
 
         @staticmethod
         def __try_set_cpu_quota(quota):
@@ -589,7 +598,8 @@ def _check_processes_in_agent_cgroup(self):
                     if process in (daemon, extension_handler) or process in systemd_run_commands:
                         continue
                     # systemd_run_commands contains the shell that started systemd-run, so we also need to check for the parent
-                    if self._get_parent(process) in systemd_run_commands and self._get_command(process) == 'systemd-run':
+                    if self._get_parent(process) in systemd_run_commands and self._get_command(
+                            process) == 'systemd-run':
                         continue
                     # check if the process is a command started by the agent or a descendant of one of those commands
                     current = process
@@ -697,7 +707,8 @@ def stop_tracking_extension_cgroups(self, extension_name):
             except Exception as exception:
                 logger.info("Failed to stop tracking resource usage for the extension service: {0}", ustr(exception))
 
-        def start_extension_command(self, extension_name, command, cmd_name, timeout, shell, cwd, env, stdout, stderr, error_code=ExtensionErrorCodes.PluginUnknownFailure):
+        def start_extension_command(self, extension_name, command, cmd_name, timeout, shell, cwd, env, stdout, stderr,
+                                    error_code=ExtensionErrorCodes.PluginUnknownFailure):
             """
             Starts a command (install/enable/etc) for an extension and adds the command's PID to the extension's cgroup
             :param extension_name: The extension executing the command
@@ -713,9 +724,12 @@ def start_extension_command(self, extension_name, command, cmd_name, timeout, sh
             """
             if self.enabled():
                 try:
-                    return self._cgroups_api.start_extension_command(extension_name, command, cmd_name, timeout, shell=shell, cwd=cwd, env=env, stdout=stdout, stderr=stderr, error_code=error_code)
+                    return self._cgroups_api.start_extension_command(extension_name, command, cmd_name, timeout,
+                                                                     shell=shell, cwd=cwd, env=env, stdout=stdout,
+                                                                     stderr=stderr, error_code=error_code)
                 except SystemdRunError as exception:
-                    reason = 'Failed to start {0} using systemd-run, will try invoking the extension directly. Error: {1}'.format(extension_name, ustr(exception))
+                    reason = 'Failed to start {0} using systemd-run, will try invoking the extension directly. Error: {1}'.format(
+                        extension_name, ustr(exception))
                     self.disable(reason, DisableCgroups.ALL)
                     # fall-through and re-invoke the extension
 
@@ -735,7 +749,7 @@ def setup_extension_slice(self, extension_name):
             if self.enabled():
                 unit_file_install_path = systemd.get_unit_file_install_path()
                 extension_slice_path = os.path.join(unit_file_install_path,
-                                                     SystemdCgroupsApi.get_extension_slice_name(extension_name))
+                                                    SystemdCgroupsApi.get_extension_slice_name(extension_name))
                 try:
                     slice_contents = _EXTENSION_SLICE_CONTENTS.format(extension_name=extension_name)
                     CGroupConfigurator._Impl.__create_unit_file(extension_slice_path, slice_contents)
@@ -755,12 +769,6 @@ def remove_extension_slice(self, extension_name):
                 if os.path.exists(extension_slice_path):
                     self.stop_tracking_extension_cgroups(extension_name)
                     CGroupConfigurator._Impl.__cleanup_unit_file(extension_slice_path)
-                # stop the unit gracefully; the extensions slices will be removed from /sys/fs/cgroup path
-                try:
-                    logger.info("Executing systemctl stop {0}".format(extension_slice_name))
-                    shellutil.run_command(["systemctl", "stop", extension_slice_name])
-                except Exception as exception:
-                    _log_cgroup_warning("systemctl stop failed (remove slice): {0}", ustr(exception))
 
         def set_extension_services_cpu_memory_quota(self, services_list):
             """