def load_config(): """Parses the command line arguments and loads config files. """ base_config_file = utils.determine_config_file(fname_base="base_sender") arguments = argument_parsing() if arguments.config_file is None: arguments.config_file = utils.determine_config_file( fname_base="datamanager").as_posix() else: arguments.config_file = Path(arguments.config_file).as_posix() # check if config_file exist utils.check_existence(base_config_file) utils.check_existence(arguments.config_file) # ------------------------------------------------------------------------ # Get arguments from config file and command line # ------------------------------------------------------------------------ config = utils.load_config(base_config_file) config_detailed = utils.load_config(arguments.config_file) # if config and yaml is mixed mapping has to take place before merging them config_type = "sender" config = utils.map_conf_format(config, config_type) config_detailed = utils.map_conf_format(config_detailed, config_type) arguments_dict = utils.map_conf_format(arguments, config_type, is_namespace=True) utils.update_dict(config_detailed, config) utils.update_dict(arguments_dict, config) return config
def main(): """Parses the settings from the configure file and displays them. """ args = get_arguments() config_file = args.config_file params = utils.load_config(config_file) # in case the config file was in the old config format # (for backwards compatibility to 4.0.x) config = utils.map_conf_format(params, "sender") config_ed = config["eventdetector"][config["eventdetector"]["type"]] print("Configured settings:") print("Monitored directory: {}".format(config_ed["monitored_dir"])) print("Watched subdirectories are: {}".format(config_ed["fix_subdirs"])) msg = "Data is written to: {}" if config["datafetcher"]["store_data"]: print(msg.format(config["datafetcher"]["local_target"])) else: print(msg.format("Data is not stored locally")) msg = "Data is sent to: {}" if config["datafetcher"]["use_data_stream"]: print(msg.format(config["datafetcher"]["data_stream_targets"])) else: print(msg.format("Data is not sent as priority stream anywhere")) print("Remove data from the detector: {}".format( config["datafetcher"]["remove_data"])) print("Whitelist: {}".format(config["general"]["whitelist"]))
def _create_asapo_config(self): config = self.config.copy() try: user_config = utils.load_config(self.user_config_path) config.update(user_config) except OSError as err: logger.warning("Could not get user config: {}".format(err)) logger.warning("Default config is used") return config
def argument_parsing(): """Parsing of command line arguments. """ parser = argparse.ArgumentParser() parser.add_argument("--config_file", type=str, help="Location of the configuration file") parser.add_argument("--beamline", type=str, help="Beamline for which the HiDRA Server " "(detector mode) should be started", default="p00") parser.add_argument("--verbose", help="More verbose output", action="store_true") parser.add_argument("--onscreen", type=str, help="Display logging on screen " "(options are CRITICAL, ERROR, WARNING, " "INFO, DEBUG)", default=False) arguments = parser.parse_args() config_file = arguments.config_file if config_file is None: config_file = utils.determine_config_file( fname_base="control_server.yaml") # convert to dict and map to config section arguments = {"controlserver": vars(arguments)} # ------------------------------------------------------------------------ # Get arguments from config file and command line # ------------------------------------------------------------------------ utils.check_existence(config_file) config = utils.load_config(config_file) utils.update_dict(arguments, config) # the configuration is now of the form: # { # "controlserver": {...} # "hidraconfig_static" : {...} # "hidraconfig_variable" : {...} # } # TODO check config for required params return config
def main(): """Connect to the receiver and show status. """ parser = get_arguments() args = parser.parse_args() host = args.host default_config_file = "/opt/hidra/conf/datamanager.yaml" config_file = args.config_file or default_config_file if host is not None and config_file is not None: parser.error("Either use --host or --config_file but not both.") if host is None: params = utils.load_config(config_file) # in case the config file was in the old config format # (for backwards compatibility to 4.0.x) config = utils.map_conf_format(params, "sender") data_stream_targets = params["datafetcher"]["data_stream_targets"] hosts = [target[0] for target in data_stream_targets] # TODO make generic host = hosts[0] control = ReceiverControl(host) print("Checking for service hidra receiver on", host, ": ", end="") try: status = control.get_status() if status == ["OK"]: print(CGREEN + "running." + CEND) else: print(CYELLOW + "running but in error state:" + CEND) print(status) except CommunicationFailed as excp: print(CRED + "not reachable." + CEND) print(traceback.format_exception_only(type(excp), excp)[0], end="") except Exception: print(CRED + "not reachable. Unknown Error.\n" + CEND) print(traceback.format_exc()) sys.exit(1)
def _read_config(self): config_file = self.get_config_file_name() self.log.info("Reading config files: %s", config_file) try: self.active_config = utils.load_config(config_file, log=self.log) except IOError: self.log.debug("Configuration file not readable: %s", config_file) except Exception: self.log.debug("cfile=%s", config_file) self.log.error("Error when trying to load config file", exc_info=True) raise self.print_config(self.active_config, description="active_config=")
def _merge_with_config(args, parser): """ Takes the command line arguments and overwrites the parameter of the config file with it. """ # convert to dict and map to config section args_dict = vars(args) # hidra config eventdetector = { "http_events": { "det_ip": args_dict["det"], } } if args_dict["detapi"] is not None: eventdetector["http_events"]["det_api_version"] = args_dict["detapi"] arguments = {"hidra": {"eventdetector": eventdetector}} del args_dict["det"] del args_dict["detapi"] if args_dict["beamline"] is None: del args_dict["beamline"] # general config arguments["general"] = args_dict # ------------------------------------------------------------------------ # Get arguments from config file and command line # ------------------------------------------------------------------------ config_file = _identify_config_file(arguments) config = utils.load_config(config_file) utils.update_dict(arguments, config) # check for beamline try: if config["general"]["beamline"] not in ALLOWED_BEAMLINES: raise parser.error( "argument --beamline: invalid choice: '{}' (choose from {})" .format(config["general"]["beamline"], str(ALLOWED_BEAMLINES)[1:-1]) ) except KeyError: raise parser.error("the following arguments are required: --beamline") return config
def argument_parsing(): """Parses and checks the command line arguments used. """ base_config_file = utils.determine_config_file(fname_base="base_receiver") # ------------------------------------------------------------------------ # Get command line arguments # ------------------------------------------------------------------------ parser = argparse.ArgumentParser() parser.add_argument("--config_file", type=str, help="Location of the configuration file") parser.add_argument("--log_path", type=str, help="Path where logfile will be created") parser.add_argument("--log_name", type=str, help="Filename used for logging") parser.add_argument("--log_size", type=int, help="File size before rollover in B (linux only)") parser.add_argument("--verbose", help="More verbose output", action="store_true") parser.add_argument("--onscreen", type=str, help="Display logging on screen " "(options are CRITICAL, ERROR, WARNING, " "INFO, DEBUG)", default=False) parser.add_argument("--procname", type=str, help="Name with which the service should be running") parser.add_argument("--whitelist", type=str, help="List of hosts allowed to connect") parser.add_argument("--target_dir", type=str, help="Where incoming data will be stored to") parser.add_argument("--dirs_not_to_create", type=str, help="Subdirectories which should not be created when " "data is stored") parser.add_argument("--data_stream_ip", type=str, help="Ip of dataStream-socket to pull new files from") parser.add_argument("--data_stream_port", type=str, help="Port number of dataStream-socket to pull new " "files from") arguments = parser.parse_args() arguments.config_file = ( arguments.config_file or utils.determine_config_file(fname_base="datareceiver")) # check if config_file exist utils.check_existence(arguments.config_file) # ------------------------------------------------------------------------ # Get arguments from config file # ------------------------------------------------------------------------ config = utils.load_config(base_config_file) config_detailed = utils.load_config(arguments.config_file) # if config and yaml is mixed mapping has to take place before merging them config_type = "receiver" config = utils.map_conf_format(config, config_type) config_detailed = utils.map_conf_format(config_detailed, config_type) arguments_dict = utils.map_conf_format(arguments, config_type, is_namespace=True) utils.update_dict(config_detailed, config) utils.update_dict(arguments_dict, config) # ------------------------------------------------------------------------ # Check given arguments # ------------------------------------------------------------------------ required_params = { "general": [ "log_path", "log_name", "procname", "procname", "ldapuri", "dirs_not_to_create", "whitelist" ], "datareceiver": [ "target_dir", "data_stream_ip", "data_stream_port", ] } # Check format of config check_passed, _ = utils.check_config(required_params, config, logging) if not check_passed: logging.error("Configuration check failed") raise utils.WrongConfiguration # check target directory for existence utils.check_existence(config["datareceiver"]["target_dir"]) # check if logfile is writable config["general"]["log_file"] = os.path.join(config["general"]["log_path"], config["general"]["log_name"]) return config