def create_configuration(extra_toplevel_config=None):
"""Creates a blank configuration file with default values. Optionally overwrites top-level key/values.
Sets api_key to 'fake' unless defined in extra_toplevel_config
@param extra_toplevel_config: Dict of top-level key/value objects to overwrite.
@return: The configuration object
@rtype: Configuration
"""
config_dir = tempfile.mkdtemp()
config_file = os.path.join(config_dir, 'agentConfig.json')
config_fragments_dir = os.path.join(config_dir, 'configs.d')
os.makedirs(config_fragments_dir)
toplevel_config = {'api_key': 'fake'}
if extra_toplevel_config:
toplevel_config.update(extra_toplevel_config)
fp = open(config_file, 'w')
fp.write(json_lib.serialize(JsonObject(**toplevel_config)))
fp.close()
default_paths = DefaultPaths('/var/log/scalyr-agent-2',
'/etc/scalyr-agent-2/agent.json',
'/var/lib/scalyr-agent-2')
config = Configuration(config_file, default_paths, None)
config.parse()
# we need to delete the config dir when done
atexit.register(shutil.rmtree, config_dir)
return config
def create_configuration(extra_toplevel_config=None):
"""Creates a blank configuration file with default values. Optionally overwrites top-level key/values.
Sets api_key to 'fake' unless defined in extra_toplevel_config
@param extra_toplevel_config: Dict of top-level key/value objects to overwrite.
@return: The configuration object
@rtype: Configuration
"""
config_dir = tempfile.mkdtemp()
config_file = os.path.join(config_dir, "agentConfig.json")
config_fragments_dir = os.path.join(config_dir, "configs.d")
os.makedirs(config_fragments_dir)
toplevel_config = {"api_key": "fake"}
if extra_toplevel_config:
toplevel_config.update(extra_toplevel_config)
fp = open(config_file, "w")
fp.write(scalyr_util.json_encode(toplevel_config))
fp.close()
default_paths = DefaultPaths(
"/var/log/scalyr-agent-2",
"/etc/scalyr-agent-2/agent.json",
"/var/lib/scalyr-agent-2",
)
config = Configuration(config_file, default_paths, None)
config.parse()
# we need to delete the config dir when done
atexit.register(shutil.rmtree, config_dir)
return config
def create_configuration(extra_toplevel_config=None):
"""Creates a blank configuration file with default values. Optionally overwrites top-level key/values.
Sets api_key to 'fake' unless defined in extra_toplevel_config
@param extra_toplevel_config: Dict of top-level key/value objects to overwrite.
@return: The configuration object
@rtype: Configuration
"""
config_dir = tempfile.mkdtemp()
config_file = os.path.join(config_dir, 'agentConfig.json')
config_fragments_dir = os.path.join(config_dir, 'configs.d')
os.makedirs(config_fragments_dir)
toplevel_config = {'api_key': 'fake'}
if extra_toplevel_config:
toplevel_config.update(extra_toplevel_config)
fp = open(config_file, 'w')
fp.write(json_lib.serialize(JsonObject(**toplevel_config)))
fp.close()
default_paths = DefaultPaths('/var/log/scalyr-agent-2', '/etc/scalyr-agent-2/agent.json',
'/var/lib/scalyr-agent-2')
config = Configuration(config_file, default_paths, None)
config.parse()
# we need to delete the config dir when done
atexit.register(shutil.rmtree, config_dir)
return config
def __create_test_instance(self, configuration_logs_entry, monitors_log_configs):
config_dir = tempfile.mkdtemp()
config_file = os.path.join(config_dir, "agentConfig.json")
config_fragments_dir = os.path.join(config_dir, "configs.d")
os.makedirs(config_fragments_dir)
logs_json_array = JsonArray()
for entry in configuration_logs_entry:
logs_json_array.add(JsonObject(content=entry))
fp = open(config_file, "w")
fp.write(json_lib.serialize(JsonObject(api_key="fake", logs=logs_json_array)))
fp.close()
default_paths = DefaultPaths(
"/var/log/scalyr-agent-2", "/etc/scalyr-agent-2/agent.json", "/var/lib/scalyr-agent-2"
)
config = Configuration(config_file, default_paths)
config.parse()
self.__monitor_fake_instances = []
for monitor_log_config in monitors_log_configs:
self.__monitor_fake_instances.append(FakeMonitor(monitor_log_config))
# noinspection PyTypeChecker
return CopyingManager(config, self.__monitor_fake_instances)
def __create_test_instance(self, config_monitors, platform_monitors):
config_dir = tempfile.mkdtemp()
config_file = os.path.join(config_dir, 'agentConfig.json')
config_fragments_dir = os.path.join(config_dir, 'configs.d')
os.makedirs(config_fragments_dir)
monitors_json_array = JsonArray()
for entry in config_monitors:
monitors_json_array.add(JsonObject(content=entry))
fp = open(config_file, 'w')
fp.write(
json_lib.serialize(
JsonObject(api_key='fake', monitors=monitors_json_array)))
fp.close()
default_paths = DefaultPaths('/var/log/scalyr-agent-2',
'/etc/scalyr-agent-2/agent.json',
'/var/lib/scalyr-agent-2')
config = Configuration(config_file, default_paths)
config.parse()
# noinspection PyTypeChecker
return MonitorsManager(config, FakePlatform(platform_monitors))
def __create_test_instance(self, configuration_logs_entry,
monitors_log_configs):
config_dir = tempfile.mkdtemp()
config_file = os.path.join(config_dir, 'agentConfig.json')
config_fragments_dir = os.path.join(config_dir, 'configs.d')
os.makedirs(config_fragments_dir)
logs_json_array = JsonArray()
for entry in configuration_logs_entry:
logs_json_array.add(JsonObject(content=entry))
fp = open(config_file, 'w')
fp.write(
json_lib.serialize(JsonObject(api_key='fake',
logs=logs_json_array)))
fp.close()
default_paths = DefaultPaths('/var/log/scalyr-agent-2',
'/etc/scalyr-agent-2/agent.json',
'/var/lib/scalyr-agent-2')
config = Configuration(config_file, default_paths)
config.parse()
self.__monitor_fake_instances = []
for monitor_log_config in monitors_log_configs:
self.__monitor_fake_instances.append(
FakeMonitor(monitor_log_config))
# noinspection PyTypeChecker
return CopyingManager(config, self.__monitor_fake_instances)
def config_object(self): # type: () -> Configuration
"""
Get config object from the config file.
"""
platform = PlatformController.new_platform()
platform._install_type = self._installation_type
default_types = platform.default_paths
config = Configuration(six.text_type(self._agent_config_path),
default_types, None)
config.parse()
return config
def setUp(self):
super(AgentMainStatusHandlerTestCase, self).setUp()
self.data_path = tempfile.mkdtemp(suffix="agent-data-path")
self.status_format_file = os.path.join(self.data_path, STATUS_FORMAT_FILE)
default_paths = mock.Mock()
default_paths.agent_data_path = self.data_path
default_paths.agent_log_path = "agent.log"
config_file = os.path.join(BASE_DIR, "fixtures/configs/agent1.json")
config = Configuration(config_file, default_paths, None)
config.parse()
self.agent = ScalyrAgent(PlatformController())
self.agent._ScalyrAgent__config = config
def __create_test_configuration_instance(self):
default_paths = DefaultPaths(
"/var/log/scalyr-agent-2",
"/etc/scalyr-agent-2/agent.json",
"/var/lib/scalyr-agent-2",
)
return Configuration(self.__config_file, default_paths, None)
def create_copying_manager(self, config):
if 'api_key' not in config:
config['api_key'] = 'fake'
f = open(self._config_file, "w")
if f:
f.write(scalyr_util.json_encode(config))
f.close()
default_paths = DefaultPaths(self._log_dir, self._config_file,
self._data_dir)
configuration = Configuration(self._config_file, default_paths, None)
configuration.parse()
self._manager = TestableCopyingManager(configuration, [])
self._controller = self._manager.controller
def __create_test_instance(self, use_pipelining=False):
tmp_dir = tempfile.mkdtemp()
config_dir = os.path.join(tmp_dir, "config")
data_dir = os.path.join(tmp_dir, "data")
log_dir = os.path.join(tmp_dir, "log")
os.mkdir(data_dir)
os.mkdir(config_dir)
os.mkdir(log_dir)
self.__test_log_file = os.path.join(tmp_dir, "test.log")
fp = open(self.__test_log_file, "w")
fp.close()
config_file = os.path.join(config_dir, "agentConfig.json")
config_fragments_dir = os.path.join(config_dir, "configs.d")
os.makedirs(config_fragments_dir)
logs_json_array = JsonArray()
logs_json_array.add(JsonObject(path=self.__test_log_file))
pipeline_threshold = 1.1
if use_pipelining:
pipeline_threshold = 0.0
fp = open(config_file, "w")
fp.write(
json_lib.serialize(
JsonObject(
api_key="fake",
logs=logs_json_array,
pipeline_threshold=pipeline_threshold,
)))
fp.close()
default_paths = DefaultPaths(log_dir, config_file, data_dir)
config = Configuration(config_file, default_paths, None)
config.parse()
# noinspection PyTypeChecker
self._controller = TestableCopyingManager(config, []).controller
return self._controller
def __create_test_configuration_instance(self):
"""Creates an instance of a Configuration file for testing.
@return: The test instance
@rtype: Configuration
"""
default_paths = DefaultPaths(self.convert_path('/var/log/scalyr-agent-2'),
self.convert_path('/etc/scalyr-agent-2/agent.json'),
self.convert_path('/var/lib/scalyr-agent-2'))
return Configuration(self.__config_file, default_paths)
def create_copying_manager(self, config, monitor_agent_log=False):
if "api_key" not in config:
config["api_key"] = "fake"
if not monitor_agent_log:
config["implicit_agent_log_collection"] = False
f = open(self._config_file, "w")
if f:
f.write(scalyr_util.json_encode(config))
f.close()
default_paths = DefaultPaths(self._log_dir, self._config_file,
self._data_dir)
configuration = Configuration(self._config_file, default_paths, None)
configuration.parse()
self._manager = TestableCopyingManager(configuration, [])
self._controller = self._manager.controller
def __create_test_instance(self, config_monitors, platform_monitors):
config_dir = tempfile.mkdtemp()
config_file = os.path.join(config_dir, 'agentConfig.json')
config_fragments_dir = os.path.join(config_dir, 'configs.d')
os.makedirs(config_fragments_dir)
monitors_json_array = JsonArray()
for entry in config_monitors:
monitors_json_array.add(JsonObject(content=entry))
fp = open(config_file, 'w')
fp.write(json_lib.serialize(JsonObject(api_key='fake', monitors=monitors_json_array)))
fp.close()
default_paths = DefaultPaths('/var/log/scalyr-agent-2', '/etc/scalyr-agent-2/agent.json',
'/var/lib/scalyr-agent-2')
config = Configuration(config_file, default_paths)
config.parse()
# noinspection PyTypeChecker
return MonitorsManager(config, FakePlatform(platform_monitors))
def __create_test_instance(self, use_pipelining=False):
tmp_dir = tempfile.mkdtemp()
config_dir = os.path.join(tmp_dir, 'config')
data_dir = os.path.join(tmp_dir, 'data')
log_dir = os.path.join(tmp_dir, 'log')
os.mkdir(data_dir)
os.mkdir(config_dir)
os.mkdir(log_dir)
self.__test_log_file = os.path.join(tmp_dir, 'test.log')
fp = open(self.__test_log_file, 'w')
fp.close()
config_file = os.path.join(config_dir, 'agentConfig.json')
config_fragments_dir = os.path.join(config_dir, 'configs.d')
os.makedirs(config_fragments_dir)
logs_json_array = JsonArray()
logs_json_array.add(JsonObject(path=self.__test_log_file))
pipeline_threshold = 1.1
if use_pipelining:
pipeline_threshold = 0.0
fp = open(config_file, 'w')
fp.write(json_lib.serialize(JsonObject(api_key='fake', logs=logs_json_array,
pipeline_threshold=pipeline_threshold)))
fp.close()
default_paths = DefaultPaths(log_dir, config_file, data_dir)
config = Configuration(config_file, default_paths)
config.parse()
# noinspection PyTypeChecker
self._controller = TestableCopyingManager(config, []).controller
return self._controller
def __create_test_configuration_instance(self):
default_paths = DefaultPaths('/var/log/scalyr-agent-2',
'/etc/scalyr-agent-2/agent.json',
'/var/lib/scalyr-agent-2')
def log_factory(config):
return CopyingParamsTest.LogObject(config)
def monitor_factory(config, _):
return CopyingParamsTest.MonitorObject(config)
monitors = [
JsonObject(
module='scalyr_agent.builtin_monitors.linux_system_metrics'),
JsonObject(
module='scalyr_agent.builtin_monitors.linux_process_metrics',
pid='$$',
id='agent')
]
return Configuration(self.__config_file, default_paths, monitors,
log_factory, monitor_factory)
def test_config_parse_memory_leak(self):
# There was a memory leak with config.parse() and underlying __perform_substitutions method
config_path = os.path.join(BASE_DIR, "fixtures/configs/agent2.json")
default_paths = DefaultPaths(
"/var/log/scalyr-agent-2",
"/etc/scalyr-agent-2/agent.json",
"/var/lib/scalyr-agent-2",
)
# New config object is created
for index in range(0, 50):
config = Configuration(file_path=config_path,
default_paths=default_paths,
logger=None)
config.parse()
self.assertNoNewGarbage()
# Existing config object is reused
config = Configuration(file_path=config_path,
default_paths=default_paths,
logger=None)
for index in range(0, 50):
config.parse()
self.assertNoNewGarbage()
if 'id' not in parsed_config:
parsed_config['id'] = ''
# noinspection PyUnusedLocal
def handle_shutdown_signal(signum, frame):
print >>sys.stdout, 'Signal received, stopping monitor...'
monitor.stop()
for sig in (signal.SIGTERM, signal.SIGINT):
signal.signal(sig, handle_shutdown_signal)
try:
if global_config_path is not None:
controller = PlatformController.new_platform()
paths = controller.default_paths
global_config = Configuration( global_config_path, paths )
global_config.parse(logger=log)
else:
global_config = None
monitor = MonitorsManager.build_monitor(parsed_config, monitor_python_path, float(monitor_sample_interval),
global_config )
log.log(scalyr_logging.DEBUG_LEVEL_1, 'Constructed monitor')
monitor.open_metric_log()
log.log(scalyr_logging.DEBUG_LEVEL_1, 'Starting monitor')
monitor.start()
while monitor.isAlive():
time.sleep(0.1)
except BadMonitorConfiguration, e:
print >>sys.stderr, 'Invalid monitor configuration: %s' % str(e)
def __create_test_configuration_instance(self):
default_paths = DefaultPaths('/var/log/scalyr-agent-2',
'/etc/scalyr-agent-2/agent.json',
'/var/lib/scalyr-agent-2')
return Configuration(self.__config_file, default_paths)
parsed_config['module'] = monitor_module
if 'id' not in parsed_config:
parsed_config['id'] = ''
# noinspection PyUnusedLocal
def handle_shutdown_signal(signum, frame):
print >>sys.stdout, 'Signal received, stopping monitor...'
monitor.stop()
for sig in (signal.SIGTERM, signal.SIGINT):
signal.signal(sig, handle_shutdown_signal)
try:
controller = PlatformController.new_platform()
paths = controller.default_paths
global_config = Configuration( paths.config_file_path, paths )
global_config.parse()
monitor = MonitorsManager.build_monitor(parsed_config, monitor_python_path, float(monitor_sample_interval), global_config )
log.log(scalyr_logging.DEBUG_LEVEL_1, 'Constructed monitor')
monitor.open_metric_log()
log.log(scalyr_logging.DEBUG_LEVEL_1, 'Starting monitor')
monitor.start()
while monitor.isAlive():
time.sleep(0.1)
except BadMonitorConfiguration, e:
print >>sys.stderr, 'Invalid monitor configuration: %s' % str(e)
return 0
if __name__ == '__main__':
def run_standalone_monitor(
monitor_module,
monitor_python_path,
monitor_config,
monitor_sample_interval,
monitor_debug_level,
global_config_path,
):
"""Runs a single plugin monitor instance.
@param monitor_module: The name of the python module implementing the monitor.
@param monitor_python_path: The python path to search to find the module.
@param monitor_config: The monitor configuration object.
@param monitor_sample_interval: The default to use for the sample interval.
@param monitor_debug_level: The debug level to use for logging.
@param global_config_path: The path to the agent.json global configuration file to use, or None if none was
supplied.
"""
scalyr_logging.set_log_destination(use_stdout=True)
scalyr_logging.set_log_level(monitor_debug_level)
log.log(scalyr_logging.DEBUG_LEVEL_1, "Attempting to run module %s",
monitor_module)
try:
# Needs to be json_lib.parse because it is parsing configuration
parsed_config = scalyr_util.json_scalyr_config_decode(monitor_config)
log.log(scalyr_logging.DEBUG_LEVEL_1,
"Parsed configuration successfully")
except JsonParseException as e:
print(
"Failed to parse the monitor configuration as valid JSON: %s",
six.text_type(e),
file=sys.stderr,
)
return 1
parsed_config["module"] = monitor_module
if "id" not in parsed_config:
parsed_config["id"] = ""
# noinspection PyUnusedLocal
def handle_shutdown_signal(signum, frame):
print("Signal received, stopping monitor...", file=sys.stdout)
monitor.stop()
for sig in (signal.SIGTERM, signal.SIGINT):
signal.signal(sig, handle_shutdown_signal)
try:
if global_config_path is not None:
controller = PlatformController.new_platform()
paths = controller.default_paths
global_config = Configuration(global_config_path, paths, log)
global_config.parse()
else:
global_config = None
monitor = MonitorsManager.build_monitor(
parsed_config,
monitor_python_path,
float(monitor_sample_interval),
global_config,
)
log.log(scalyr_logging.DEBUG_LEVEL_1, "Constructed monitor")
monitor.open_metric_log()
log.log(scalyr_logging.DEBUG_LEVEL_1, "Starting monitor")
monitor.start()
while monitor.isAlive():
time.sleep(0.1)
except BadMonitorConfiguration as e:
print("Invalid monitor configuration: %s" % six.text_type(e),
file=sys.stderr)
return 0
if not os.path.isfile(template):
print >> sys.stderr, ('Cannot initialize configuration file because template file does not exist at'
'%s' % template)
sys.exit(1)
# Copy the file.
shutil.copy(template, config_path)
controller.set_file_owner(config_path, controller.get_current_user())
print 'Successfully initialized the configuration file.'
if options.executing_user and controller.get_current_user() != 'root':
print >> sys.stderr, 'You must be root to update the user account that is used to run the agent.'
sys.exit(1)
try:
config_file = Configuration(options.config_filename, default_paths, controller.default_monitors, None, None)
config_file.parse()
except Exception, e:
print >> sys.stderr, 'Error reading configuration file: %s' % str(e)
print >> sys.stderr, traceback.format_exc()
print >> sys.stderr, 'Terminating, please fix the configuration file and restart agent.'
sys.exit(1)
controller.consume_config(config_file, options.config_filename)
# See if we have to start the agent. This is only used by Windows right now as part of its install process.
if 'win32' == sys.platform and options.mark_conditional_restart:
mark_conditional_restart(controller, config_file)
if 'win32' == sys.platform and options.conditional_restart:
restart_if_conditional_marker_exists(controller, config_file)
def upgrade_tarball_install(config, new_tarball, preserve_old_install):
"""Performs an upgrade for an existing Scalyr Agent 2 that was previously installed using the tarball method.
@param config: The configuration for this agent.
@param new_tarball: The path to file containing the new tarball to install.
@param preserve_old_install: If True, will move the old install directory to a new location rather than deleting
it.
@return: The exit status code.
"""
# Create a temporary directory hold the new install as we untar it and copy files into it.
tmp_install_dir = tempfile.mkdtemp()
# Some variables that capture some important state that we may need to unwind if we execute
# out the installation along the way.
#
# If not None, then the directory we are currently holding the old installation directory in.
preserve_dir = None
# True if the agent was running when the install started.
was_running = False
# True if the agent was successfully restarted.
was_restarted = False
try:
try:
# Ensure that this is a tarball install
if not config.is_tarball_install():
raise UpgradeFailure('The current agent was not installed using a tarball, so you may not use the '
'upgrade tarball command.')
# Ensure that the user has not changed the defaults for the config, data, and log directory.
if Configuration.default_config_file_path() != config.file_path:
raise UpgradeFailure('The agent is not using the default configuration file so you may not use the '
'upgrade tarball command.')
if Configuration.default_agent_data_path() != config.agent_data_path:
raise UpgradeFailure('The agent is not using the default data directory so you may not use the upgrade '
'tarball command.')
if Configuration.default_agent_log_path() != config.agent_log_path:
raise UpgradeFailure('The agent is not using the default log directory so you may not use the upgrade '
'tarball command.')
# We rely on the current installation being included in the PATH variable.
if spawn.find_executable('scalyr-agent-2-config') is None:
raise UpgradeFailure('Could not locate the scalyr-agent-2-config command from the current '
'installation. Please ensure that the agent\'s bin directory is in the system\'s '
'PATH variable.')
if not os.path.isfile(new_tarball):
raise UpgradeFailure('The tarball file %s does not exist.' % new_tarball)
file_name = os.path.basename(new_tarball)
if re.match('^scalyr-agent-2\..*\.tar\.gz$', file_name) is None:
raise UpgradeFailure('The supplied tarball file name does not match the expected format.')
tarball_directory = file_name[0:-7]
# We will be installing in the same directory where scalyr-agent-2 is currently installed. That directory
# should be 4 levels back from this file.
# The path to this file looks like: scalyr-agent-2/py/scalyr_agent/config_main.py
install_directory = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file_path__))))
if not os.path.isdir(os.path.join(install_directory, 'scalyr-agent-2')):
raise UpgradeFailure('Could not determine the install directory. Either the main directory is no '
'longer called scalyr-agent-2, or the directory structure has changed.')
# Compute the full paths to the scalyr-agent-2 directories for both the new install and old install.
tmp_new_install_location = os.path.join(tmp_install_dir, tarball_directory)
old_install_location = os.path.join(install_directory, 'scalyr-agent-2')
# Untar the new package into the temp location.
tar = tarfile.open(new_tarball, 'r:gz')
for member in tar.getmembers():
tar.extract(member, path=tmp_install_dir)
# Check to see if the agent is running. If so, stop it.
was_running = run_command('scalyr-agent-2 stop', grep_for='Agent has stopped',
command_name='scalyr-agent-2 stop')[0] == 0
# Copy the config, data, and log directories.
for dir_name in ['config', 'log', 'data']:
copy_dir_to_new_agent(old_install_location, tmp_new_install_location, dir_name)
# Allow the new agent code to perform any actions it deems necessary. We do the special commandline
# here where to pass in both directories to the --upgrade-tarball-command
result = subprocess.call([os.path.join(tmp_new_install_location, 'bin', 'scalyr-agent-2-config'),
'--upgrade-tarball', '%s%s%s' % (old_install_location, os.pathsep,
tmp_new_install_location)])
if result != 0:
raise UpgradeFailure('New package failed to finish the upgrade process.')
# Move the old install directory to a temporary location, so we can undo the next move if we need to.
preserve_dir = tempfile.mkdtemp()
shutil.move(old_install_location, preserve_dir)
# Move the new install into place.
success = False
try:
shutil.move(tmp_new_install_location, old_install_location)
success = True
finally:
if not success:
# Move the old install back in place just to be safe.
shutil.move(os.path.join(preserve_dir, 'scalyr-agent-2'), old_install_location)
if success and not preserve_old_install:
shutil.rmtree(preserve_dir)
preserve_dir = None
print 'New agent installed.'
# Start the agent if it was previously running.
if was_running:
if run_command('scalyr-agent-2 start', exit_on_fail=False, command_name='scalyr-agent-2 start')[0] == 0:
print 'Agent has successfully restarted.'
print ' You may execute the following command for status details: scalyr-agent-2 status -v'
was_restarted = True
else:
raise UpgradeFailure('Could not start the agent. Execute the following command for more details: '
'scalyr-agent-2 start')
else:
print 'Execute the following command to start the agent: scalyr-agent-2 start'
return 0
except UpgradeFailure, error:
print >>sys.stderr
print >>sys.stderr, 'The upgrade failed due to the following reason: %s' % error.message
return 1
finally:
# Delete the temporary directory.
shutil.rmtree(tmp_install_dir)
# Warn if we should have restarted the agent but did not.
if was_running and not was_restarted:
print ''
print ('WARNING, due to failure, the agent may no longer be running. Restart it with: scalyr-agent-2 '
'start')
# If there is still a preserve_directory, there must be a reason for it, so tell the user where it is.
if preserve_dir is not None:
print ''
print 'The previous agent installation was left in \'%s\'' % preserve_dir
print 'You should be sure to delete this directory once you no longer need it.'
parser.add_option("", "--preserve-old-install", action="store_true", dest="preserve_old_install", default=False,
help="When performing a tarball upgrade, move the old install to a temporary directory "
"instead of deleting it.")
(options, args) = parser.parse_args()
if len(args) > 1:
print >> sys.stderr, 'Could not parse commandline arguments.'
parser.print_help(sys.stderr)
sys.exit(1)
if options.executing_user and getpass.getuser() != 'root':
print >> sys.stderr, 'You must be root to update the user account that is used to run the agent.'
sys.exit(1)
if options.config_filename is None:
options.config_filename = Configuration.default_config_file_path()
if not os.path.isabs(options.config_filename):
options.config_filename = os.path.abspath(options.config_filename)
try:
config_file = Configuration(options.config_filename, None, None)
config_file.parse()
except Exception, e:
print >> sys.stderr, 'Error reading configuration file: %s' % str(e)
print >> sys.stderr, traceback.format_exc()
print >> sys.stderr, 'Terminating, please fix the configuration file and restart agent.'
sys.exit(1)
if options.set_key_from_stdin:
api_key = raw_input('Please enter key: ')
if not os.path.isfile(template):
print >> sys.stderr, ('Cannot initialize configuration file because template file does not exist at'
'%s' % template)
sys.exit(1)
# Copy the file.
shutil.copy(template, config_path)
controller.set_file_owner(config_path, controller.get_current_user())
print 'Successfully initialized the configuration file.'
if options.executing_user and controller.get_current_user() != 'root':
print >> sys.stderr, 'You must be root to update the user account that is used to run the agent.'
sys.exit(1)
try:
config_file = Configuration(options.config_filename, default_paths)
config_file.parse()
except Exception, e:
print >> sys.stderr, 'Error reading configuration file: %s' % str(e)
print >> sys.stderr, traceback.format_exc()
print >> sys.stderr, 'Terminating, please fix the configuration file and restart agent.'
sys.exit(1)
controller.consume_config(config_file, options.config_filename)
# See if we have to start the agent. This is only used by Windows right now as part of its install process.
if 'win32' == sys.platform and options.mark_conditional_restart:
mark_conditional_restart(controller, config_file)
if 'win32' == sys.platform and options.conditional_restart:
restart_if_conditional_marker_exists(controller, config_file)
'Cannot initialize configuration file because template file does not exist at'
'%s' % template)
sys.exit(1)
# Copy the file.
shutil.copy(template, config_path)
controller.set_file_owner(config_path,
controller.get_current_user())
print 'Successfully initialized the configuration file.'
if options.executing_user and controller.get_current_user() != 'root':
print >> sys.stderr, 'You must be root to update the user account that is used to run the agent.'
sys.exit(1)
try:
config_file = Configuration(options.config_filename, default_paths)
config_file.parse()
except Exception, e:
print >> sys.stderr, 'Error reading configuration file: %s' % str(e)
print >> sys.stderr, traceback.format_exc()
print >> sys.stderr, 'Terminating, please fix the configuration file and restart agent.'
sys.exit(1)
controller.consume_config(config_file, options.config_filename)
# See if we have to start the agent. This is only used by Windows right now as part of its install process.
if 'win32' == sys.platform and options.mark_conditional_restart:
mark_conditional_restart(controller, config_file)
if 'win32' == sys.platform and options.conditional_restart:
restart_if_conditional_marker_exists(controller, config_file)
if 'id' not in parsed_config:
parsed_config['id'] = ''
# noinspection PyUnusedLocal
def handle_shutdown_signal(signum, frame):
print >> sys.stdout, 'Signal received, stopping monitor...'
monitor.stop()
for sig in (signal.SIGTERM, signal.SIGINT):
signal.signal(sig, handle_shutdown_signal)
try:
if global_config_path is not None:
controller = PlatformController.new_platform()
paths = controller.default_paths
global_config = Configuration(global_config_path, paths, log)
global_config.parse()
else:
global_config = None
monitor = MonitorsManager.build_monitor(parsed_config,
monitor_python_path,
float(monitor_sample_interval),
global_config)
log.log(scalyr_logging.DEBUG_LEVEL_1, 'Constructed monitor')
monitor.open_metric_log()
log.log(scalyr_logging.DEBUG_LEVEL_1, 'Starting monitor')
monitor.start()
while monitor.isAlive():
time.sleep(0.1)
except BadMonitorConfiguration, e:
