WireCell::Main Class Reference

#include <Main.h>

Public Member Functions
	Main ()
	~Main ()
int	cmdline (int argc, char *argv[])
void	add_app (const std::string &tn)
void	add_config (const std::string &filename)
void	add_var (const std::string &name, const std::string &value)
void	add_code (const std::string &name, const std::string &value)
void	add_path (const std::string &dirname)
void	add_plugin (const std::string &libname)
void	add_logsink (const std::string &log, const std::string &level="")
	Add a log sink, reserved names 'stdout' and 'stderr' or a filename. More...
void	set_loglevel (const std::string &log, const std::string &level="")
void	initialize ()
void	operator() ()
	Run any and all application components once. More...

Private Attributes
ConfigManager	m_cfgmgr
std::vector< std::string >	m_plugins
std::vector< std::string >	m_apps
std::vector< std::string >	m_cfgfiles
std::vector< std::string >	m_load_path
Persist::externalvars_t	m_extvars
Persist::externalvars_t	m_extcode
Log::logptr_t	l

Detailed Description

Definition at line 23 of file Main.h.

Constructor & Destructor Documentation

Main::Main

(

)

Definition at line 27 of file Main.cxx.

    : l(Log::logger("main"))
{
}

Main::~Main

(

)

Definition at line 32 of file Main.cxx.

{
}

Member Function Documentation

void Main::add_app

(

const std::string &

tn

)

Individual setup methods called by cmdline() or called explicitly by external application/frameork: Add an IApplication component to execute as a type:name string.

Definition at line 142 of file Main.cxx.

{
    m_apps.push_back(tn);
}

void Main::add_code	(	const std::string &	name,
		const std::string &	value
	)

Bind external configuration code (in Jsonnet language) to a variable so that its may be referenced the configuration files (via std.extVar())

Definition at line 173 of file Main.cxx.

{
    m_extcode[name] = value;
}

void Main::add_config

(

const std::string &

filename

)

Append a top-level JSON/Jsonnet configuration file to the configuration sequence.

Definition at line 163 of file Main.cxx.

{
    m_cfgfiles.push_back(filename);
}

void Main::add_logsink	(	const std::string &	log,
		const std::string &	level = ""
	)

Add a log sink, reserved names 'stdout' and 'stderr' or a filename.

Definition at line 147 of file Main.cxx.

{
    if (log == "stdout") {
        Log::add_stdout(true, level);
        return;
    }
    if (log == "stderr") {
        Log::add_stderr(true, level);
        return;
    }
    Log::add_file(log, level);
}

void Main::add_path

(

const std::string &

dirname

)

Add an element to the configuration path in which configuration files may be found.

Definition at line 178 of file Main.cxx.

{
    m_load_path.push_back(dirname);
}

void Main::add_plugin

(

const std::string &

libname

)

Add a plugin library in which components may be found. The libname may lack the initial "lib" prefix and file extension.

Definition at line 137 of file Main.cxx.

{
    m_plugins.push_back(libname);
}

void Main::add_var	(	const std::string &	name,
		const std::string &	value
	)

Bind an external scalar value to a variable so that it may be referenced in the configuration files (via std.extVar()).

Definition at line 168 of file Main.cxx.

{
    m_extvars[name] = value;
}

int Main::cmdline	(	int	argc,
		char *	argv[]
	)

Single-point entry to Wire Cell.

Pass in literal command line arguments and return a return code. See wire-cell --help for args.

Or, one can use subsequent methods for more fine-grained setup and execution.

Definition at line 38 of file Main.cxx.

{
    po::options_description desc("Options");
    desc.add_options()
        ("help,h", "wire-cell [options] [arguments]")
        ("logsink,l", po::value< vector<string> >(),"log sink, filename or 'stdout' or 'stderr', if added ':level' then set a log level for the sink")
        ("loglevel,L", po::value< vector<string> >(),"set lowest log level for a log in form 'name:level' or just 'level' for all (level one of critical,error,warn,info,debug,trace)")
        ("app,a", po::value< vector<string> >(),"application component to invoke")
        ("config,c", po::value< vector<string> >(),"provide a configuration file")
        ("plugin,p", po::value< vector<string> >(),"specify a plugin as name[:lib]")
//      ("jsonpath,j", po::value< vector<string> >(),"specify a JSON path=value")
        ("ext-str,V", po::value< vector<string> >(),"specify a Jsonnet external variable=value")
        ("ext-code,C", po::value< vector<string> >(),"specify a Jsonnet external variable=code")
        ("path,P", po::value< vector<string> >(),"add to JSON/Jsonnet search path")
    ;    

    po::variables_map opts;
    po::store(po::parse_command_line(argc, argv, desc), opts);
    po::notify(opts);    

    if (opts.count("help")) {
        std::cout << desc << "\n";
        return 1;
    }

    if (opts.count("config")) {
        for (auto fname : opts["config"].as< vector<string> >()) {
            add_config(fname);
        }
    }

    if (opts.count("path")) {
        for (auto path : opts["path"].as< vector<string> >()) {
            add_path(path);
        }
    }

    // Get any external variables
    if (opts.count("ext-str")) {
        for (auto vev : opts["ext-str"].as< vector<string> >()) {
            auto vv = String::split(vev, "=");
            add_var(vv[0], vv[1]);
        }
    }
    // And any external code
    if (opts.count("ext-code")) {
        for (auto vev : opts["ext-code"].as< vector<string> >()) {
            auto vv = String::split(vev, "=");
            add_code(vv[0], vv[1]);
        }
    }
    // fixme: these aren't yet supported.
    // if (opts.count("jsonpath")) { 
    //     jsonpath_vars = opts["jsonpath"].as< vector<string> >();
    // }


    if (opts.count("plugin")) {
        for (auto plugin : opts["plugin"].as< vector<string> >()) {
            add_plugin(plugin);
        }
    }
    if (opts.count("app")) {
        for (auto app : opts["app"].as< vector<string> >()) {
            add_app(app);
        }
    }
    if (opts.count("logsink")) {
        for (auto ls : opts["logsink"].as< vector<string> >()) {
            auto ll = String::split(ls, ":");
            if (ll.size() == 1) {
                add_logsink(ll[0]);
            }
            if (ll.size() == 2) {
                add_logsink(ll[0], ll[1]);
            }
        }
    }

    if (opts.count("loglevel")) {
        for (auto ll : opts["loglevel"].as< vector<string> >()) {
            auto lal = String::split(ll, ":");
            if (lal.size() == 2) {
                set_loglevel(lal[0], lal[1]);
            }
            else{
                set_loglevel("", lal[0]);
            }
        }
    }

    // Maybe make this cmdline configurable.  For now, set all
    // backends the same.
    Log::set_pattern("[%H:%M:%S.%03e] %L [%^%=8n%$] %v");

    return 0;
}

void Main::initialize

(

)

Call once after all setup has been done and before running.

Definition at line 184 of file Main.cxx.

{
    for (auto filename : m_cfgfiles) {
        l->info("loading config file {} ...", filename);
        Persist::Parser p(m_load_path, m_extvars, m_extcode);
        Json::Value one = p.load(filename); // throws
        m_cfgmgr.extend(one);
        l->info("...done");
    }


    // Find if we have our special configuration entry
    int ind = m_cfgmgr.index("wire-cell");
    Configuration main_cfg = m_cfgmgr.pop(ind);
    if (! main_cfg.isNull()) {
        for (auto plugin : get< vector<string> >(main_cfg, "data.plugins")) {
            l->info("config requests plugin: \"{}\"", plugin);
            m_plugins.push_back(plugin);
        }
        for (auto app : get< vector<string> >(main_cfg, "data.apps")) {
            l->info("config requests app: \"{}\"", app);
            m_apps.push_back(app);
        }
    }


    // Load any plugin shared libraries requested by user.
    PluginManager& pm = PluginManager::instance();
    for (auto plugin : m_plugins) {
        string pname, lname;
        std::tie(pname, lname) = String::parse_pair(plugin);
        l->info("adding plugin: \"{}\"", plugin);
        if (lname.size()) {
            l->info("\t from library \"{}\"", lname);
        }
        pm.add(pname, lname);
    }


    // Apply any user configuration.  This is a two step.  First, just
    // assure all the components referenced in the configuration
    // sequence can be instantiated.  Then, find them again and
    // actually configure them.  This way, any problems fails fast.

    for (auto c : m_cfgmgr.all()) {
        if (c.isNull()) {
            continue;           // allow and ignore any totally empty configurations
        }
        if (c["type"].isNull()) {
            l->critical("all configuration must have a type attribute, got: {}", c);
            THROW(ValueError() << errmsg{"got configuration sequence element lacking a type"});
        }
        string type = get<string>(c, "type");
        string name = get<string>(c, "name");
        l->info("constructing component: \"{}\":\"{}\"", type, name);
        auto iface = Factory::lookup<Interface>(type, name); // throws 
    }
    for (auto c : m_apps) {
        l->info("constructing app: \"{}\"",c);
        Factory::lookup_tn<IApplication>(c);
    }
    for (auto c : m_cfgmgr.all()) {
        if (c.isNull()) {
            continue;           // allow and ignore any totally empty configurations
        }
        string type = get<string>(c, "type");
        string name = get<string>(c, "name");
        l->info("configuring component: \"{}\":\"{}\"", type, name);
        auto cfgobj = Factory::find_maybe<IConfigurable>(type, name); // doesn't throw. 
        if (!cfgobj) {
            continue;
        }

        // Get component's hard-coded default config, update it with
        // anything the user may have provided and apply it.
        Configuration cfg = cfgobj->default_configuration();
        cfg = update(cfg, c["data"]);
        cfgobj->configure(cfg); // throws
    }
}

void Main::operator()

(

void

)

Run any and all application components once.

Definition at line 265 of file Main.cxx.

{
    // Find all IApplications to execute
    vector<IApplication::pointer> app_objs;
    for (auto component : m_apps) {
        string type, name;
        std::tie(type,name) = String::parse_pair(component);
        auto a = Factory::find<IApplication>(type,name); // throws
        app_objs.push_back(a);
    }
    l->debug("executing {} apps:", m_apps.size());
    for (size_t ind=0; ind < m_apps.size(); ++ind) {
        auto aobj = app_objs[ind];
        l->debug("executing app: \"{}\"", m_apps[ind]);
        aobj->execute();        // throws
    }
}

void Main::set_loglevel	(	const std::string &	log,
		const std::string &	level = ""
	)

Set a minimum level to emit a message for a given log. (levels: critical, error, warn, info, debug, trace).

Definition at line 159 of file Main.cxx.

{
    Log::set_level(level, log);
}

Member Data Documentation

Log::logptr_t WireCell::Main::l

private

Definition at line 90 of file Main.h.

std::vector<std::string> WireCell::Main::m_apps

private

Definition at line 88 of file Main.h.

std::vector<std::string> WireCell::Main::m_cfgfiles

private

Definition at line 88 of file Main.h.

ConfigManager WireCell::Main::m_cfgmgr

private

Definition at line 87 of file Main.h.

Persist::externalvars_t WireCell::Main::m_extcode

private

Definition at line 89 of file Main.h.

Persist::externalvars_t WireCell::Main::m_extvars

private

Definition at line 89 of file Main.h.

std::vector<std::string> WireCell::Main::m_load_path

private

Definition at line 88 of file Main.h.

std::vector<std::string> WireCell::Main::m_plugins

private

Definition at line 88 of file Main.h.

---

The documentation for this class was generated from the following files:

• wire-cell-build/apps/inc/WireCellApps/Main.h
• wire-cell-build/apps/src/Main.cxx