yodau::backend::cli_client Class Reference

Simple interactive CLI (REPL) for controlling a stream_manager. More...

#include <backend/include/cli_client.hpp>

Collaboration diagram for yodau::backend::cli_client:

Public Member Functions
	cli_client (backend::stream_manager &mgr)
	Construct a CLI client operating on an existing manager.
int	run () const
	Run the interactive command loop.

Private Member Functions
void	dispatch_command (const std::string &cmd, const std::vector< std::string > &args) const
	Dispatch a command to its handler.
void	cmd_list_streams (const std::vector< std::string > &args) const
	Handler for list-streams.
void	cmd_add_stream (const std::vector< std::string > &args) const
	Handler for add-stream.
void	cmd_start_stream (const std::vector< std::string > &args) const
	Handler for start-stream.
void	cmd_stop_stream (const std::vector< std::string > &args) const
	Handler for stop-stream.
void	cmd_list_lines (const std::vector< std::string > &args) const
	Handler for list-lines.
void	cmd_add_line (const std::vector< std::string > &args) const
	Handler for add-line.
void	cmd_set_line (const std::vector< std::string > &args) const
	Handler for set-line.

Static Private Member Functions
static std::vector< std::string >	tokenize (const std::string &line)
	Split a line into whitespace-separated tokens.
static cxxopts::ParseResult	parse_with_cxxopts (const std::string &cmd, const std::vector< std::string > &args, cxxopts::Options &options)
	Parse command arguments using cxxopts.

Private Attributes
backend::stream_manager &	stream_mgr
	Stream manager controlled by this CLI.

Detailed Description

Simple interactive CLI (REPL) for controlling a stream_manager.

The cli_client provides a text-based command loop that allows the user to:

• list/add/start/stop streams,
• list/add lines,
• connect lines to streams, using cxxopts-style option parsing.

The client does not own the manager; it holds a reference and issues synchronous calls to it.

Note

When compiled with YODAU_OPENCV, the constructor installs OpenCV-based daemon start and motion frame processor hooks (see implementation).

Definition at line 28 of file cli_client.hpp.

Constructor & Destructor Documentation

cli_client()

yodau::backend::cli_client::cli_client ( backend::stream_manager & mgr )

explicit

Construct a CLI client operating on an existing manager.

The manager reference must remain valid for the lifetime of this client.

Parameters

mgr	Stream manager to control.

Definition at line 5 of file cli_client.cpp.

    : stream_mgr(mgr) {
#ifdef YODAU_OPENCV
    stream_mgr.set_daemon_start_hook(opencv_daemon_start);
    stream_mgr.set_frame_processor(opencv_motion_processor);
#endif
}

References stream_mgr.

Referenced by main().

Here is the caller graph for this function:

Member Function Documentation

cmd_add_line()

void yodau::backend::cli_client::cmd_add_line ( const std::vector< std::string > & args ) const

private

Handler for add-line.

Positional arguments:

• path (required; coordinates string like "0,0;100,100")
• name (optional)
• close (optional: true/false)

Options:

• –dir / -d to set tripwire direction.

Parameters

args	Tokenized arguments.

Definition at line 244 of file cli_client.cpp.

        {
    const std::string cmd = "add-line";
    cxxopts::Options options("add-line", "Add a new line to a stream");
    options.allow_unrecognised_options();
    options.positional_help("<path> [<name>] [<close>]");
    options.add_options()
    ("h,help", "Print help")
    ("path", "Line coordinates, e.g. 0,0;100,100", cxxopts::value<std::string>())
    ("name", "Name of the line", cxxopts::value<std::string>()->default_value(""))
    ("close", "Whether the line is closed (true/false)", cxxopts::value<bool>()->default_value("false"))
    ("d,dir", "Tripwire direction (any/neg_to_pos/pos_to_neg)",
        cxxopts::value<std::string>()->default_value("any"));
    options.parse_positional({ "path", "name", "close" });
    try {
        const auto result = parse_with_cxxopts("add-line", args, options);
        if (result.count("help")) {
            std::cout << options.help() << std::endl;
            return;
        }
        if (!result.count("path")) {
            std::cerr << "Error: 'path' argument is required." << std::endl;
            return;
        }
        const std::string path = result["path"].as<std::string>();
        const std::string name = result["name"].as<std::string>();
        const bool close = result["close"].as<bool>();
        const std::string dir_str = result["dir"].as<std::string>();
 
        const auto& line = stream_mgr.add_line(path, close, name);
 
        try {
            const auto dir = parse_tripwire_dir(dir_str);
            stream_mgr.set_line_dir(line->name, dir);
        } catch (const std::exception& e) {
            std::cerr << "bad dir: " << e.what() << std::endl;
        }
 
        line->dump(std::cout);
        std::cout << std::endl;
 
    } catch (const cxxopts::exceptions::exception& e) {
        std::cerr << "Error parsing command '" << cmd << "': " << e.what()
                  << std::endl;
        std::cout << options.help() << std::endl;
    }
}

References parse_tripwire_dir(), and stream_mgr.

Here is the call graph for this function:

cmd_add_stream()

void yodau::backend::cli_client::cmd_add_stream ( const std::vector< std::string > & args ) const

private

Handler for add-stream.

Positional arguments:

• path (required)
• name (optional)
• type (optional: local/file/rtsp/http)
• loop (optional: true/false)

Parameters

args	Tokenized arguments.

Definition at line 113 of file cli_client.cpp.

        {
    const std::string cmd = "add-stream";
    cxxopts::Options options(cmd, "Add a new stream");
    options.allow_unrecognised_options();
    options.positional_help("<path> [<name>] [<type>] [<loop>]");
    options.add_options()
        ("h,help", "Print help")
        ("path", "Path to the device, media file or stream URL", cxxopts::value<std::string>())
        ("name", "Name of the stream", cxxopts::value<std::string>()->default_value(""))
        ("type", "Type of the stream (local/file/rtsp/http)", cxxopts::value<std::string>()->default_value(""))
        ("loop", "Whether to loop the stream (true/false)", cxxopts::value<bool>()->default_value("true"));
    options.parse_positional({ "path", "name", "type", "loop" });
    try {
        const auto result = parse_with_cxxopts(cmd, args, options);
        if (result.count("help")) {
            std::cout << options.help() << std::endl;
            return;
        }
        if (!result.count("path")) {
            std::cerr << "Error: 'path' argument is required." << std::endl;
            return;
        }
        const std::string path = result["path"].as<std::string>();
        const std::string name = result["name"].as<std::string>();
        const std::string type = result["type"].as<std::string>();
        const bool loop = result["loop"].as<bool>();
        const auto& stream = stream_mgr.add_stream(path, name, type, loop);
        stream.dump(std::cout, true);
        std::cout << std::endl;
    } catch (const cxxopts::exceptions::exception& e) {
        std::cerr << "Error parsing command '" << cmd << "': " << e.what()
                  << std::endl;
        std::cout << options.help() << std::endl;
    }
}

References stream_mgr.

cmd_list_lines()

void yodau::backend::cli_client::cmd_list_lines ( const std::vector< std::string > & args ) const

private

Handler for list-lines.

Lists all stored lines in the manager.

Parameters

args	Tokenized arguments.

Definition at line 209 of file cli_client.cpp.

        {
    const std::string cmd = "list-lines";
    cxxopts::Options options("list-lines", "List all lines in a stream");
    options.allow_unrecognised_options();
    options.add_options()("h,help", "Print help");
    try {
        const auto result = parse_with_cxxopts("list-lines", args, options);
        if (result.count("help")) {
            std::cout << options.help() << std::endl;
            return;
        }
        stream_mgr.dump_lines(std::cout);
        std::cout << std::endl;
    } catch (const cxxopts::exceptions::exception& e) {
        std::cerr << "Error parsing command '" << cmd << "': " << e.what()
                  << std::endl;
        std::cout << options.help() << std::endl;
    }
}

References stream_mgr.

cmd_list_streams()

void yodau::backend::cli_client::cmd_list_streams ( const std::vector< std::string > & args ) const

private

Handler for list-streams.

Supports optional --connections to show connected line names.

Parameters

args	Tokenized arguments.

Definition at line 87 of file cli_client.cpp.

        {
    const std::string cmd = "list-streams";
    cxxopts::Options options(cmd, "List all streams");
    options.allow_unrecognised_options();
    options.add_options()("h,help", "Print help")(
        "c,connections", "Show connected lines",
        cxxopts::value<bool>()->default_value("false")
    );
    try {
        const auto result = parse_with_cxxopts(cmd, args, options);
        if (result.count("help")) {
            std::cout << options.help() << std::endl;
            return;
        }
        const bool show_connections = result["connections"].as<bool>();
        stream_mgr.dump_stream(std::cout, show_connections);
        std::cout << std::endl;
    } catch (const cxxopts::exceptions::exception& e) {
        std::cerr << "Error parsing command '" << cmd << "': " << e.what()
                  << std::endl;
        std::cout << options.help() << std::endl;
    }
}

References stream_mgr.

cmd_set_line()

void yodau::backend::cli_client::cmd_set_line ( const std::vector< std::string > & args ) const

private

Handler for set-line.

Positional arguments:

• stream (required; stream name)
• line (required; line name)

Connects an existing line to an existing stream.

Parameters

args	Tokenized arguments.

Definition at line 293 of file cli_client.cpp.

        {
    const std::string cmd = "set-line";
    cxxopts::Options options("set-line", "Set a new line to a stream");
    options.allow_unrecognised_options();
    options
        .add_options()("h,help", "Print help")("stream", "Stream name", cxxopts::value<std::string>())(
            "line", "Line name", cxxopts::value<std::string>()
        );
    options.parse_positional({ "stream", "line" });
    try {
        const auto result = parse_with_cxxopts("set-line", args, options);
        if (result.count("help")) {
            std::cout << options.help() << std::endl;
            return;
        }
        if (!result.count("stream") || !result.count("line")) {
            std::cerr << "Error: 'stream' and 'line' arguments are required."
                      << std::endl;
            return;
        }
        const std::string stream_name = result["stream"].as<std::string>();
        const std::string line_name = result["line"].as<std::string>();
        const auto& stream = stream_mgr.set_line(stream_name, line_name);
        stream.dump(std::cout, true);
        std::cout << std::endl;
    } catch (const cxxopts::exceptions::exception& e) {
        std::cerr << "Error parsing command '" << cmd << "': " << e.what()
                  << std::endl;
        std::cout << options.help() << std::endl;
    }
}

References stream_mgr.

cmd_start_stream()

void yodau::backend::cli_client::cmd_start_stream ( const std::vector< std::string > & args ) const

private

Handler for start-stream.

Positional argument:

• name (required)

Parameters

args	Tokenized arguments.

Definition at line 151 of file cli_client.cpp.

        {
    const std::string cmd = "start-stream";
    cxxopts::Options options("start-stream", "Start a stream");
    options.allow_unrecognised_options();
    options.add_options()("h,help", "Print help")(
        "name", "Name of the stream to start", cxxopts::value<std::string>()
    );
    options.parse_positional({ "name" });
    try {
        const auto result = parse_with_cxxopts("start-stream", args, options);
        if (result.count("help")) {
            std::cout << options.help() << std::endl;
            return;
        }
        if (!result.count("name")) {
            std::cerr << "Error: 'name' argument is required." << std::endl;
            return;
        }
        const std::string name = result["name"].as<std::string>();
        stream_mgr.start_stream(name);
    } catch (const cxxopts::exceptions::exception& e) {
        std::cerr << "Error parsing command '" << cmd << "': " << e.what()
                  << std::endl;
        std::cout << options.help() << std::endl;
    }
}

References stream_mgr.

cmd_stop_stream()

void yodau::backend::cli_client::cmd_stop_stream ( const std::vector< std::string > & args ) const

private

Handler for stop-stream.

Positional argument:

• name (required)

Parameters

args	Tokenized arguments.

Definition at line 180 of file cli_client.cpp.

        {
    const std::string cmd = "stop-stream";
    cxxopts::Options options("stop-stream", "Stop a stream");
    options.allow_unrecognised_options();
    options.add_options()("h,help", "Print help")(
        "name", "Name of the stream to stop", cxxopts::value<std::string>()
    );
    options.parse_positional({ "name" });
    try {
        const auto result = parse_with_cxxopts("stop-stream", args, options);
        if (result.count("help")) {
            std::cout << options.help() << std::endl;
            return;
        }
        if (!result.count("name")) {
            std::cerr << "Error: 'name' argument is required." << std::endl;
            return;
        }
        const std::string name = result["name"].as<std::string>();
        stream_mgr.stop_stream(name);
    } catch (const cxxopts::exceptions::exception& e) {
        std::cerr << "Error parsing command '" << cmd << "': " << e.what()
                  << std::endl;
        std::cout << options.help() << std::endl;
    }
}

References stream_mgr.

dispatch_command()

void yodau::backend::cli_client::dispatch_command ( const std::string & cmd, const std::vector< std::string > & args ) const

private

Dispatch a command to its handler.

Looks up cmd in the internal command map and invokes the corresponding cmd_* method. Unknown commands print an error to stderr.

Parameters

cmd	Command name (e.g., "add-stream").
args	Tokenized arguments excluding the command name.

Definition at line 45 of file cli_client.cpp.

        {
    static const std::unordered_map<
        std::string,
        void (cli_client::*)(const std::vector<std::string>& args) const>
        command_map = { { "list-streams", &cli_client::cmd_list_streams },
                        { "add-stream", &cli_client::cmd_add_stream },
                        { "start-stream", &cli_client::cmd_start_stream },
                        { "stop-stream", &cli_client::cmd_stop_stream },
                        { "list-lines", &cli_client::cmd_list_lines },
                        { "add-line", &cli_client::cmd_add_line },
                        { "set-line", &cli_client::cmd_set_line } };
    const auto it = command_map.find(cmd);
    if (it == command_map.end()) {
        std::cerr << "unknown command: " << cmd << std::endl;
        return;
    }
    try {
        const auto method = it->second;
        (this->*method)(args);
    } catch (const std::exception& e) {
        std::cerr << "error executing command '" << cmd << "': " << e.what()
                  << std::endl;
    }
}

parse_with_cxxopts()

cxxopts::ParseResult yodau::backend::cli_client::parse_with_cxxopts ( const std::string & cmd, const std::vector< std::string > & args, cxxopts::Options & options )

staticprivate

Parse command arguments using cxxopts.

Builds a temporary argv-like array from cmd and args and calls cxxopts::Options::parse.

Parameters

cmd	Command name (used as argv[0]).
args	Command arguments.
options	Configured cxxopts options for this command.

Returns

cxxopts parse result.

Definition at line 72 of file cli_client.cpp.

  {
    std::vector<char*> argv;
    argv.reserve(args.size() + 1);
    argv.push_back(const_cast<char*>(cmd.data()));
    for (const auto& arg : args) {
        argv.push_back(const_cast<char*>(arg.data()));
    }
    const int argc = static_cast<int>(argv.size());
    char** argv_ptr = argv.data();
    return options.parse(argc, argv_ptr);
}

run()

int yodau::backend::cli_client::run

(

)

const

Run the interactive command loop.

This function reads commands from stdin and prints results/errors to stdout/stderr until the user enters one of the quit commands: "quit", "q", or "exit".

Returns

0 on normal termination, non-zero if stdin closes / EOF occurs.

Definition at line 13 of file cli_client.cpp.

                                      {
    std::string line;
    while (true) {
        std::cout << "yodau> " << std::flush;
        if (!std::getline(std::cin, line)) {
            return 1;
        }
        auto tokens = tokenize(line);
        if (tokens.empty()) {
            continue;
        }
        const auto& cmd = tokens[0];
        std::vector args(tokens.begin() + 1, tokens.end());
        if (cmd == "quit" || cmd == "q" || cmd == "exit") {
            break;
        }
        dispatch_command(cmd, args);
    }
    return 0;
}

Referenced by main().

Here is the caller graph for this function:

tokenize()

std::vector< std::string > yodau::backend::cli_client::tokenize ( const std::string & line )

staticprivate

Split a line into whitespace-separated tokens.

Used to parse the REPL input into:

• command name (first token),
• positional/flag arguments (remaining tokens).

Parameters

line	Raw input line.

Returns

Vector of tokens; empty if line contains no tokens.

Definition at line 35 of file cli_client.cpp.

                                                      {
    std::vector<std::string> tokens;
    std::istringstream stream(line);
    std::string token;
    while (stream >> token) {
        tokens.push_back(token);
    }
    return tokens;
}

Member Data Documentation

stream_mgr

backend::stream_manager& yodau::backend::cli_client::stream_mgr

private

Stream manager controlled by this CLI.

Non-owning reference.

Definition at line 176 of file cli_client.hpp.

Referenced by cli_client(), cmd_add_line(), cmd_add_stream(), cmd_list_lines(), cmd_list_streams(), cmd_set_line(), cmd_start_stream(), and cmd_stop_stream().

---

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

• cli_client.hpp
• cli_client.cpp