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_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: