def metplus_config(): """! Create a METplus configuration object that can be manipulated/modified to reflect different paths, directories, values, etc. for individual tests. """ # Read in the configuration object CONFIG config = config_metplus.setup(util.baseinputconfs) util.get_logger(config) return config
def __init__(self, p, logger): #pylint:disable=redefined-outer-name super(CyclonePlotterWrapper, self).__init__(p, logger) if logger is None: self.logger = util.get_logger(self.p) else: self.logger = logger self.app_path = os.path.join(p.getdir('MET_INSTALL_DIR'), 'bin/tc_pairs') self.app_name = os.path.basename(self.app_path) self.input_data = p.getdir('CYCLONE_INPUT_DIR') self.output_dir = p.getdir('CYCLONE_OUT_DIR') self.init_date = p.getstr('config', 'CYCLONE_INIT_DATE') self.init_hr = p.getstr('config', 'CYCLONE_INIT_HR') self.projection = p.getstr('config', 'CYCLONE_PROJECTION') self.model = p.getstr('config', 'CYCLONE_MODEL') self.title = p.getstr('config', 'CYCLONE_PLOT_TITLE') self.gen_ascii = p.getbool('config', 'GENERATE_TRACK_ASCII') # Create a set to keep track of unique storm_ids for each track file. self.unique_storm_id = set() # Data structure to separate data based on storm id. self.storm_id_dict = {} # Data/info which we want to retrieve from the track files. self.columns_of_interest = [ 'AMODEL', 'STORM_ID', 'BASIN', 'INIT', 'LEAD', 'VALID', 'ALAT', 'ALON', 'BLAT', 'BLON', 'AMSLP', 'BMSLP' ] self.llcrnrlat = p.getfloat('config', 'CYCLONE_LLCRNRLAT') self.llcrnrlon = p.getfloat('config', 'CYCLONE_LLCRNRLON') self.urcrnrlat = p.getfloat('config', 'CYCLONE_URCRNRLAT') self.urcrnrlon = p.getfloat('config', 'CYCLONE_URCRNRLON') self.resolution = p.getstr('config', 'CYCLONE_RESOLUTION') self.circle_marker = p.getint('config', 'CIRCLE_MARKER_SIZE') self.cross_marker = p.getint('config', 'CROSS_MARKER_SIZE')
def metplus_config(): """! Create a METplus configuration object that can be manipulated/modified to reflect different paths, directories, values, etc. for individual tests. """ try: if 'JLOGFILE' in os.environ: produtil.setup.setup(send_dbn=False, jobname='MTDWrapper', jlogfile=os.environ['JLOGFILE']) else: produtil.setup.setup(send_dbn=False, jobname='MTDWrapper') produtil.log.postmsg('mtd_wrapper is starting') # Read in the configuration object CONFIG config = config_metplus.setup() logger = util.get_logger(config) config = ConfigWrapper(config, logger) return config except Exception as e: produtil.log.jlogger.critical('mtd_wrapper failed: %s' % (str(e), ), exc_info=True) sys.exit(2)
def __init__(self, p): met_build_base = p.getdir('MET_BUILD_BASE') self.tc_exe = os.path.join(met_build_base, 'bin/tc_stat') # self.init_date_beg = p.getstr('config', 'INIT_DATE_BEG') # self.init_date_end = p.getstr('config', 'INIT_DATE_END') # self.init_hour_inc = p.getint('config', 'INIT_HOUR_INC') self.logger = util.get_logger(p) self.config = p
def __init__(self, config, logger=None): """!Class for Creating and Running External Programs. It was intended to handle the MET executables but can be used by other executables.""" self.config = config self.logger = logger if self.logger == None: self.logger = util.get_logger(self.config,sublog='CommandRunner') self.verbose = self.config.getstr('config', 'LOG_MET_VERBOSITY', '2')
def __init__(self, p, logger): super(TcPairsWrapper, self).__init__(p, logger) self.config = self.p self.app_path = os.path.join(p.getdir('MET_INSTALL_DIR'), 'bin/tc_pairs') self.app_name = os.path.basename(self.app_path) if self.logger is None: self.logger = util.get_logger(self.p,sublog='TcPairs') self.cmd = '' self.logger.info("Initialized TcPairsWrapper")
def __init__(self, p, logger): """!Constructor for TCMPRPlotterWrapper Args: @param p: The configuration instance, contains the conf file information. @param logger: A logger, can be None """ # pylint:disable=too-many-instance-attributes # All these instance attributes are needed to support the # plot_tcmpr.R functionality. super(TCMPRPlotterWrapper, self).__init__(p, logger) self.config = p if self.logger is None: self.logger = util.get_logger(self.p) self._init_tcmpr_script() # The only required argument for plot_tcmpr.R, the name of # the tcst file to plot. self.input_data = p.getstr('config', 'TCMPR_DATA') # Optional arguments self.plot_config_file = p.getstr('config', 'CONFIG_FILE') self.output_base_dir = p.getdir('TCMPR_PLOT_OUT_DIR') self.prefix = p.getstr('config', 'PREFIX') self.title = p.getstr('config', 'TITLE') self.subtitle = p.getstr('config', 'SUBTITLE') self.xlab = p.getstr('config', 'XLAB') self.ylab = p.getstr('config', 'YLAB') self.xlim = p.getstr('config', 'XLIM') self.ylim = p.getstr('config', 'YLIM') self.filter = p.getstr('config', 'FILTER') self.filtered_tcst_data = p.getstr('config', 'FILTERED_TCST_DATA_FILE') self.dep_vars = p.getstr('config', 'DEP_VARS') self.scatter_x = p.getstr('config', 'SCATTER_X') self.scatter_y = p.getstr('config', 'SCATTER_Y') self.skill_ref = p.getstr('config', 'SKILL_REF') self.series = p.getstr('config', 'SERIES') self.series_ci = p.getstr('config', 'SERIES_CI') self.legend = p.getstr('config', 'LEGEND') self.lead = p.getstr('config', 'LEAD') self.plot_types = p.getstr('config', 'PLOT_TYPES') self.rp_diff = p.getstr('config', 'RP_DIFF') self.demo_year = p.getstr('config', 'DEMO_YR') self.hfip_baseline = p.getstr('config', 'HFIP_BASELINE') self.footnote_flag = p.getstr('config', 'FOOTNOTE_FLAG') self.plot_config_options = p.getstr('config', 'PLOT_CONFIG_OPTS') self.save_data = p.getstr('config', 'SAVE_DATA') # Optional flags, by default these will be set to False in the # produtil config files. self.no_ee = p.getbool('config', 'NO_EE') self.no_log = p.getbool('config', 'NO_LOG') self.save = p.getbool('config', 'SAVE')
def test_create_tile_grid_string(self): # Test that the tile grid string is what was # expected. p = P.Params() p.init(__doc__) logger = util.get_logger(p) lat = -14.1 lon = 64.2 expected_string = 'latlon 49.0:60:0.5 -29.0:60:0.5' actual_string = str(et.create_tile_grid_string(lat, lon, logger, p)) self.assertEqual(actual_string, expected_string)
def setUp(self): """ Run run_tc_pairs.py based on the metplus.conf file in the $METPLUS_BASE/parm directory, then base all unit tests on the output from that run. """ self.p = self.get_config() self.logger = util.get_logger(self.p) self.init_list = util.gen_init_list( self.p.getstr('config', 'INIT_DATE_BEG'), self.p.getstr('config', 'INIT_DATE_END'), self.p.getint('config', 'INIT_HOUR_INC'), self.p.getstr('config', 'INIT_HOUR_END')) # just run the first time self.request_time = self.init_list[0]
def __init__(self, p, logger): super(PB2NCWrapper, self).__init__(p, logger) self.p = p if logger is None: self.logger = util.get_logger(p) self.pb_dict = self.create_pb_dict() self.app_path = self.pb_dict['APP_PATH'] self.app_name = self.pb_dict['APP_NAME'] self.args = [] # Conversion of hours to seconds # pylint:disable=invalid-name # Need to set constant value, most Pythonic way according to # Stack-Overflow is to set attribute. self.HOURS_TO_SECONDS = 3600
def __init__(self, p, logger): super(ExtractTilesWrapper, self).__init__(p, logger) met_build_base = p.getdir('MET_BUILD_BASE') self.app_path = os.path.join(p.getdir('MET_BUILD_BASE'), 'bin/tc_pairs') self.app_name = os.path.basename(self.app_path) self.tc_pairs_dir = self.p.getdir('TC_PAIRS_DIR') self.overwrite_flag = self.p.getbool('config', 'OVERWRITE_TRACK') self.addl_filter_opts = \ self.p.getstr('config', 'EXTRACT_TILES_FILTER_OPTS') self.filtered_out_dir = self.p.getdir('EXTRACT_OUT_DIR') self.tc_stat_exe = os.path.join(met_build_base, 'bin/tc_stat') self.init_beg = self.p.getstr('config', 'INIT_BEG')[0:8] self.init_end = self.p.getstr('config', 'INIT_END')[0:8] self.init_hour_inc = int(self.p.getint('config', 'INIT_INC') / 3600) self.init_hour_end = self.p.getint('config', 'INIT_HOUR_END') if self.logger is None: self.logger = util.get_logger(self.p) self.config = self.p
def __init__(self, p, logger): super(PointStatWrapper, self).__init__(p, logger) if logger is None: self.logger = util.get_logger(p) self.p = p self.ps_dict = self.create_point_stat_dict() # For building the argument string via # CommandBuilder: self.app_path = self.ps_dict['APP_PATH'] self.app_name = self.ps_dict['APP_NAME'] self.app_name = os.path.basename(self.app_path) self.outdir = "" self.outfile = "" self.args = [] self.input_dir = "" self.param = "" # Conversion factor for hours to seconds self.HOURS_TO_SECONDS = 3600
def metplus_config(): try: if 'JLOGFILE' in os.environ: produtil.setup.setup(send_dbn=False, jobname='TCPairsWrapper ', jlogfile=os.environ['JLOGFILE']) else: produtil.setup.setup(send_dbn=False, jobname='TCPairsWrapper ') produtil.log.postmsg('tc_pairs_wrapper is starting') # Read in the configuration object CONFIG config = config_metplus.setup(util.baseinputconfs) logger = util.get_logger(config) return config except Exception as e: produtil.log.jlogger.critical('tc_pairs_wrapper failed: %s' % (str(e), ), exc_info=True) sys.exit(2)
def __init__(self, p, logger): super(TcStatWrapper, self).__init__(p, logger) self.app_name = 'tc_stat' self.config = self.p self.logger = logger if self.logger is None: self.logger = util.get_logger(self.p, sublog='TcStat') self.app_path = os.path.join(self.p.getdir('MET_INSTALL_DIR'), 'bin/tc_stat') self.app_name = os.path.basename(self.app_path) self.tc_exe = self.app_path # TODO after testing, remove lines below that have ### ###met_install_dir = self.p.getdir('MET_INSTALL_DIR') ###self.tc_exe = os.path.join(met_install_dir, 'bin/tc_stat') # self.init_date_beg = p.getstr('config', 'INIT_DATE_BEG') # self.init_date_end = p.getstr('config', 'INIT_DATE_END') # self.init_hour_inc = p.getint('config', 'INIT_HOUR_INC') ###self.logger = util.get_logger(p) ###self.config = p self.logger.info("Initialized TcStatWrapper")
def main(): """!Main program. Master MET+ script that invokes the necessary Python scripts to perform various activities, such as series analysis.""" # Job Logger produtil.log.jlogger.info('Top of master_metplus') # Used for logging and usage statment cur_filename = sys._getframe().f_code.co_filename cur_function = sys._getframe().f_code.co_name # Setup Task logger, Until Conf object is created, Task logger is # only logging to tty, not a file. logger = logging.getLogger('master_metplus') logger.info('logger Top of master_metplus.') # Parse arguments, options and return a config instance. p = config_metplus.setup(filename=cur_filename) # NOW we have a conf object p, we can now get the logger # and set the handler to write to the LOG_METPLUS # TODO: Frimel setting up logger file handler. # Setting up handler i.e util.get_logger should be moved to # the setup wrapper and encapsulated in the config object. # than you would get it this way logger=p.log(). The config # object has-a logger we want. logger = util.get_logger(p) #logger.info('Top of master_metplus after conf file setup.') # This is available in each subprocess from os.system BUT # we also set it in each process since they may be called stand alone. os.environ['MET_BASE'] = p.getdir('MET_BASE') # Use config object to get the list of processes to call process_list = util.getlist(p.getstr('config', 'PROCESS_LIST')) # Keep this comment. # When running commands in the process_list, reprocess the # original command line using (item))[sys.argv[1:]]. # # You could call each task (ie. run_tc_pairs.py) without any args since # the final METPLUS_CONF file was just created from config_metplus.setup, # and each task, also calls setup, which use an existing final conf # file over command line args. # # both work ... # Note: Using (item))sys.argv[1:], is preferable since # it doesn't depend on the conf file existing. processes = [] for item in process_list: try: logger = p.log(item) command_builder = getattr(sys.modules[__name__], item+"Wrapper")(p, logger) except AttributeError: raise NameError("Process %s doesn't exist" % item) exit() processes.append(command_builder) if p.getstr('config', 'LOOP_METHOD') == "processes": for process in processes: # referencing using repr(process.app_name) in log since it may be None, # if not set in the command builder subclass' contsructor, and no need to # generate an exception because of that. produtil.log.postmsg('master_metplus Calling run_all_times ' 'in: %s wrapper.' % repr(process.app_name)) process.run_all_times() elif p.getstr('config', 'LOOP_METHOD') == "times": use_init = p.getbool('config', 'LOOP_BY_INIT', True) if use_init: time_format = p.getstr('config', 'INIT_TIME_FMT') start_t = p.getstr('config', 'INIT_BEG') end_t = p.getstr('config', 'INIT_END') time_interval = p.getint('config', 'INIT_INC') else: time_format = p.getstr('config', 'VALID_TIME_FMT') start_t = p.getstr('config', 'VALID_BEG') end_t = p.getstr('config', 'VALID_END') time_interval = p.getint('config', 'VALID_INC') if time_interval < 60: print("ERROR: time_interval parameter must be greater than 60 seconds") exit(1) loop_time = calendar.timegm(time.strptime(start_t, time_format)) end_time = calendar.timegm(time.strptime(end_t, time_format)) while loop_time <= end_time: run_time = time.strftime("%Y%m%d%H%M", time.gmtime(loop_time)) logger.info("****************************************") logger.info("* RUNNING MET+") if use_init: logger.info("* at init time: " + run_time) else: logger.info("* at valid time: " + run_time) logger.info("****************************************") for process in processes: # Set valid time to -1 if using init and vice versa if use_init: process.run_at_time(run_time, -1) else: process.run_at_time(-1, run_time) process.clear() loop_time += time_interval else: print("ERROR: Invalid LOOP_METHOD defined. " + \ "Options are processes, times") exit() exit()
# at this point, # explicitly remove them (and any resulting empty directories) # so they don't cause any problems with further processing # steps. util.prune_empty(fcst_anly_ascii_dir, self.logger) if __name__ == "__main__": try: if 'JLOGFILE' in os.environ: produtil.setup.setup(send_dbn=False, jobname='SeriesByInit', jlogfile=os.environ['JLOGFILE']) else: produtil.setup.setup(send_dbn=False, jobname='SeriesByInit') produtil.log.postmsg('series_by_init is starting') # Read in the configuration object CONFIG CONFIG = config_metplus.setup() LOG = util.get_logger(CONFIG) if 'MET_BASE' not in os.environ: os.environ['MET_BASE'] = CONFIG.getdir('MET_BASE') SBI = SeriesByInitWrapper(CONFIG, LOG) SBI.run_all_times() produtil.log.postmsg('series_by_init completed') except Exception as e: produtil.log.jlogger.critical('series_by_init failed: %s' % (str(e), ), exc_info=True) sys.exit(2)
def setUp(self): self.p = self.get_config() self.logger = util.get_logger(self.p) self.sbi = SeriesByInit(self.p, self.logger)
def main(): """!Main program. Master METplus script that invokes the necessary Python scripts to perform various activities, such as series analysis.""" # Setup Task logger, Until Conf object is created, Task logger is # only logging to tty, not a file. logger = logging.getLogger('master_metplus') logger.info('Starting METplus v%s', util.get_version_number()) # Parse arguments, options and return a config instance. conf = config_metplus.setup(filename='master_metplus.py') # NOW we have a conf object p, we can now get the logger # and set the handler to write to the LOG_METPLUS # TODO: Frimel setting up logger file handler. # Setting up handler i.e util.get_logger should be moved to # the setup wrapper and encapsulated in the config object. # than you would get it this way logger=p.log(). The config # object has-a logger we want. logger = util.get_logger(conf) logger.info('Running METplus v%s called with command: %s', util.get_version_number(), ' '.join(sys.argv)) # check for deprecated config items and warn user to remove/replace them util.check_for_deprecated_config(conf, logger) config = ConfigWrapper(conf, logger) # set staging dir to OUTPUT_BASE/stage if not set if not config.has_option('dir', 'STAGING_DIR'): config.set('dir', 'STAGING_DIR', os.path.join(config.getdir('OUTPUT_BASE'), "stage")) # handle dir to write temporary files util.handle_tmp_dir(config) # This is available in each subprocess from os.system BUT # we also set it in each process since they may be called stand alone. os.environ['MET_BASE'] = config.getdir('MET_BASE') config.env = os.environ.copy() # Use config object to get the list of processes to call process_list = util.getlist(config.getstr('config', 'PROCESS_LIST')) # Keep this comment. # When running commands in the process_list, reprocess the # original command line using (item))[sys.argv[1:]]. # # You could call each task (ie. run_tc_pairs.py) without any args since # the final METPLUS_CONF file was just created from config_metplus.setup, # and each task, also calls setup, which use an existing final conf # file over command line args. # # both work ... # Note: Using (item))sys.argv[1:], is preferable since # it doesn't depend on the conf file existing. processes = [] for item in process_list: try: logger = config.log(item) command_builder = \ getattr(sys.modules[__name__], item + "Wrapper")(config, logger) # if Usage specified in PROCESS_LIST, print usage and exit if item == 'Usage': command_builder.run_all_times() exit(1) except AttributeError: raise NameError("Process %s doesn't exist" % item) processes.append(command_builder) loop_order = config.getstr('config', 'LOOP_ORDER', '') if loop_order == '': loop_order = config.getstr('config', 'LOOP_METHOD') if loop_order == "processes": for process in processes: # referencing using repr(process.app_name) in # log since it may be None, # if not set in the command builder subclass' contsructor, # and no need to generate an exception because of that. produtil.log.postmsg('master_metplus Calling run_all_times ' 'in: %s wrapper.' % repr(process.app_name)) process.run_all_times() elif loop_order == "times": util.loop_over_times_and_call(config, processes) else: logger.error("Invalid LOOP_METHOD defined. " + \ "Options are processes, times") exit() # scrub staging directory if requested if config.getbool('config', 'SCRUB_STAGING_DIR', False) and\ os.path.exists(config.getdir('STAGING_DIR')): staging_dir = config.getdir('STAGING_DIR') logger.info("Scrubbing staging dir: %s", staging_dir) shutil.rmtree(staging_dir) # rewrite final conf so it contains all of the default values used util.write_final_conf(conf, logger) logger.info('METplus has successfully finished running.') exit()
def main(): logger = logging.getLogger('run_example') init_time = 0 start_time = 0 end_time = 0 time_interval = 1 short_opts = "c:r:h" long_opts = ["config=", "help", "runtime="] # All command line input, get options and arguments try: opts, args = getopt.gnu_getopt(sys.argv[1:], short_opts, long_opts) except getopt.GetoptError as err: print(str(err)) usage('SCRIPT IS EXITING DUE TO UNRECOGNIZED COMMAND LINE OPTION') for k, v in opts: if k in ('-c', '--config'): # adds the conf file to the list of arguments. args.append(config_launcher.set_conf_file_path(v)) elif k in ('-h', '--help'): usage() exit() elif k in ('-r', '--runtime'): start_time = v end_time = v else: assert False, "UNHANDLED OPTION" if not args: args = None (parm, infiles, moreopt) = config_launcher.parse_launch_args(args, usage, None, logger) p = config_launcher.launch(infiles, moreopt) logger = util.get_logger(p) logger.setLevel(logging.DEBUG) if start_time == 0: start_time = p.getstr('config', 'START_TIME') end_time = p.getstr('config', 'END_TIME') time_interval = p.getstr('config', 'TIME_INTERVAL') # Get the list of processes to call process_list = util.getlist(p.getstr('config', 'PROCESS_LIST')) model_type = p.getstr('config', 'MODEL_TYPE') fcst_vars = util.getlist(p.getstr('config', 'FCST_VARS')) lead_seq = util.getlistint(p.getstr('config', 'LEAD_SEQ')) init_time = start_time while init_time <= end_time: print("") print("****************************************") print("* RUNNING MET+") print("* EVALUATING " + model_type + " at init time: " + init_time) print("****************************************") logger.info("****************************************") logger.info("* RUNNING MET+") logger.info("* EVALUATING " + model_type + " at init time: " + init_time) logger.info("****************************************") for lead in lead_seq: for fcst_var in fcst_vars: # loop over models to compare accums = util.getlist(p.getstr('config', fcst_var + "_ACCUM")) ob_types = util.getlist( p.getstr('config', fcst_var + "_OBTYPE")) for accum in accums: for ob_type in ob_types: if lead < int(accum): continue obs_var = p.getstr('config', ob_type + "_VAR") logger.info("") logger.info("") logger.info("For " + init_time + " F" + str(lead) + ", processing " + model_type + "_" + fcst_var + "_" + accum + " vs " + ob_type + " " + obs_var + "_" + accum) valid_time = util.shift_time(init_time, lead) data_interval = p.getint('config', ob_type + '_DATA_INTERVAL') if int(valid_time[8:10]) % data_interval != 0: logger.warning("No observation for valid time: " + valid_time + ". Skipping...") continue for process in process_list: if process == "pcp_combine": run_pcp = CG_pcp_combine(p, logger) run_pcp.run_at_time(valid_time, accum, ob_type, fcst_var) elif process == "regrid_data_plane": run_regrid = CG_regrid_data_plane(p, logger) run_regrid.run_at_time(valid_time, accum, ob_type) elif process == "grid_stat": run_grid_stat = CG_grid_stat(p, logger) run_grid_stat.run_at_time( init_time, lead, accum, ob_type, fcst_var) else: print("ERROR: Invalid process in process list") exit(1) init_time = util.shift_time(init_time, int(time_interval)) (logger).info("END OF EXECUTION")
def get_test_logger(): # Create a logger object based on the logging_test.conf config_instance = get_test_config() fixture_logger = util.get_logger(config_instance) return fixture_logger
def main(): """!Main program. Master MET+ script that invokes the necessary Python scripts to perform various activities, such as series analysis.""" # Job Logger produtil.log.jlogger.info('Top of master_metplus') # Setup Task logger, Until Conf object is created, Task logger is # only logging to tty, not a file. logger = logging.getLogger('master_metplus') logger.info('logger Top of master_metplus.') # Used for logging and usage statment cur_filename = sys._getframe().f_code.co_filename cur_function = sys._getframe().f_code.co_name short_opts = "c:r:h" long_opts = ["config=", "help", "runtime="] # All command line input, get options and arguments try: opts, args = getopt.gnu_getopt(sys.argv[1:], short_opts, long_opts) except getopt.GetoptError as err: print(str(err)) usage('SCRIPT IS EXITING DUE TO UNRECOGNIZED COMMAND LINE OPTION') for k, v in opts: if k in ('-c', '--config'): # adds the conf file to the list of arguments. print("ADDED CONF FILE: " + v) args.append(config_launcher.set_conf_file_path(v)) elif k in ('-h', '--help'): usage() exit() elif k in ('-r', '--runtime'): start_time = v end_time = v else: assert False, "UNHANDLED OPTION" if not args: args = None (parm, infiles, moreopt) = config_launcher.parse_launch_args(args, usage, None, logger) p = config_launcher.launch(infiles, moreopt) # NOW I have a conf object p, I can now setup the handler # to write to the LOG_FILENAME. logger = util.get_logger(p) # This is available in each subprocess from os.system BUT # we also set it in each process since they may be called stand alone. os.environ['MET_BASE'] = p.getdir('MET_BASE') # Use config object to get the list of processes to call process_list = util.getlist(p.getstr('config', 'PROCESS_LIST')) # Keep this comment. # When running commands in the process_list, reprocess the # original command line using (item))[sys.argv[1:]]. # # You could call each task (ie. run_tc_pairs.py) without any args since # the final METPLUS_CONF file was just created from config_metplus.setup, # and each task, also calls setup, which use an existing final conf # file over command line args. # # both work ... # Note: Using (item))sys.argv[1:], is preferable since # it doesn't depend on the conf file existing. processes = [] for item in process_list: try: command_builder = getattr(sys.modules[__name__], item + "Wrapper")(p, logger) except AttributeError: raise NameError("Process %s doesn't exist" % item) exit() processes.append(command_builder) if p.getstr('config', 'LOOP_METHOD') == "processes": for process in processes: process.run_all_times() elif p.getstr('config', 'LOOP_METHOD') == "times": time_format = p.getstr('config', 'INIT_TIME_FMT') start_t = p.getstr('config', 'INIT_BEG') end_t = p.getstr('config', 'INIT_END') time_interval = p.getint('config', 'INIT_INC') if time_interval < 60: print( "ERROR: time_interval parameter must be greater than 60 seconds" ) exit(1) init_time = calendar.timegm(time.strptime(start_t, time_format)) end_time = calendar.timegm(time.strptime(end_t, time_format)) while init_time <= end_time: run_time = time.strftime("%Y%m%d%H%M", time.gmtime(init_time)) print("") print("****************************************") print("* RUNNING MET+") print("* at init time: " + run_time) print("****************************************") logger.info("****************************************") logger.info("* RUNNING MET+") logger.info("* at init time: " + run_time) logger.info("****************************************") for process in processes: process.run_at_time(run_time) process.clear() init_time += time_interval else: print("ERROR: Invalid LOOP_METHOD defined. " + \ "Options are processes, times") exit() exit() for item in process_list: cmd_shell = cmd.to_shell() logger.info("INFO | [" + cur_filename + ":" + cur_function + "] | " + "Running: " + cmd_shell) ret = run(cmd) if ret != 0: logger.error("ERROR | [" + cur_filename + ":" + cur_function + "] | " + "Problem executing: " + cmd_shell) exit(0)
def __init__(self, p, logger): super(TcPairsWrapper, self).__init__(p, logger) self.config = self.p if self.logger is None: self.logger = util.get_logger(self.p)