def is_log_collection_allowed():
# There are three conditions that need to be met in order to allow periodic log collection:
# 1) It should be enabled in the configuration.
# 2) The system must be using systemd to manage services. Needed for resource limiting of the log collection.
# 3) The python version must be greater than 2.6 in order to support the ZipFile library used when collecting.
conf_enabled = conf.get_collect_logs()
systemd_present = CGroupsApi.is_systemd()
supported_python = PY_VERSION_MINOR >= 7 if PY_VERSION_MAJOR == 2 else PY_VERSION_MAJOR == 3
is_allowed = conf_enabled and systemd_present and supported_python
msg = "Checking if log collection is allowed at this time [{0}]. All three conditions must be met: " \
"configuration enabled [{1}], systemd present [{2}], python supported: [{3}]".format(is_allowed,
conf_enabled,
systemd_present,
supported_python)
logger.info(msg)
add_event(name=AGENT_NAME,
version=CURRENT_VERSION,
op=WALAEventOperation.LogCollection,
is_success=is_allowed,
message=msg,
log_event=False)
return is_allowed
def run(self, debug=False): # pylint: disable=R0912
"""
This is the main loop which watches for agent and extension updates.
"""
try:
logger.info(u"Agent {0} is running as the goal state agent",
CURRENT_AGENT)
#
# Fetch the goal state one time; some components depend on information provided by the goal state and this
# call ensures the required info is initialized (e.g telemetry depends on the container ID.)
#
protocol = self.protocol_util.get_protocol()
protocol.update_goal_state()
# Initialize the common parameters for telemetry events
initialize_event_logger_vminfo_common_parameters(protocol)
# Log OS-specific info.
os_info_msg = u"Distro: {dist_name}-{dist_ver}; "\
u"OSUtil: {util_name}; AgentService: {service_name}; "\
u"Python: {py_major}.{py_minor}.{py_micro}; "\
u"systemd: {systemd}; "\
u"LISDrivers: {lis_ver}; "\
u"logrotate: {has_logrotate};".format(
dist_name=DISTRO_NAME, dist_ver=DISTRO_VERSION,
util_name=type(self.osutil).__name__,
service_name=self.osutil.service_name,
py_major=PY_VERSION_MAJOR, py_minor=PY_VERSION_MINOR,
py_micro=PY_VERSION_MICRO, systemd=CGroupsApi.is_systemd(),
lis_ver=get_lis_version(), has_logrotate=has_logrotate()
)
logger.info(os_info_msg)
add_event(AGENT_NAME,
op=WALAEventOperation.OSInfo,
message=os_info_msg)
#
# Perform initialization tasks
#
from azurelinuxagent.ga.exthandlers import get_exthandlers_handler, migrate_handler_state
exthandlers_handler = get_exthandlers_handler(protocol)
migrate_handler_state()
from azurelinuxagent.ga.remoteaccess import get_remote_access_handler
remote_access_handler = get_remote_access_handler(protocol)
self._ensure_no_orphans()
self._emit_restart_event()
self._emit_changes_in_default_configuration()
self._ensure_partition_assigned()
self._ensure_readonly_files()
self._ensure_cgroups_initialized()
self._ensure_extension_telemetry_state_configured_properly(
protocol)
# Get all thread handlers
telemetry_handler = get_send_telemetry_events_handler(
self.protocol_util)
all_thread_handlers = [
get_monitor_handler(),
get_env_handler(), telemetry_handler,
get_collect_telemetry_events_handler(telemetry_handler)
]
if is_log_collection_allowed():
all_thread_handlers.append(get_collect_logs_handler())
# Launch all monitoring threads
for thread_handler in all_thread_handlers:
thread_handler.run()
goal_state_interval = conf.get_goal_state_period(
) if conf.get_extensions_enabled(
) else GOAL_STATE_INTERVAL_DISABLED
while self.running:
#
# Check that the parent process (the agent's daemon) is still running
#
if not debug and self._is_orphaned:
logger.info("Agent {0} is an orphan -- exiting",
CURRENT_AGENT)
break
#
# Check that all the threads are still running
#
for thread_handler in all_thread_handlers:
if not thread_handler.is_alive():
logger.warn("{0} thread died, restarting".format(
thread_handler.get_thread_name()))
thread_handler.start()
#
# Process the goal state
#
if not protocol.try_update_goal_state():
self._heartbeat_update_goal_state_error_count += 1
else:
if self._upgrade_available(protocol):
available_agent = self.get_latest_agent()
if available_agent is None:
logger.info(
"Agent {0} is reverting to the installed agent -- exiting",
CURRENT_AGENT)
else:
logger.info(
u"Agent {0} discovered update {1} -- exiting",
CURRENT_AGENT, available_agent.name)
break
utc_start = datetime.utcnow()
last_etag = exthandlers_handler.last_etag
exthandlers_handler.run()
remote_access_handler.run()
if last_etag != exthandlers_handler.last_etag:
self._ensure_readonly_files()
duration = elapsed_milliseconds(utc_start)
logger.info(
'ProcessGoalState completed [incarnation {0}; {1} ms]',
exthandlers_handler.last_etag, duration)
add_event(AGENT_NAME,
op=WALAEventOperation.ProcessGoalState,
duration=duration,
message="Incarnation {0}".format(
exthandlers_handler.last_etag))
self._send_heartbeat_telemetry(protocol)
time.sleep(goal_state_interval)
except Exception as e: # pylint: disable=C0103
msg = u"Agent {0} failed with exception: {1}".format(
CURRENT_AGENT, ustr(e))
self._set_sentinel(msg=msg)
logger.warn(msg)
logger.warn(traceback.format_exc())
sys.exit(1)
# additional return here because sys.exit is mocked in unit tests
return
self._shutdown()
sys.exit(0)