开源服务器设计总计（plain framework2020年总计）

2020年注定会被历史铭记，世界遭受着一场前所未有的灾难，这种灾难到现在还在持续。还记得19年末的时候，那时候听到一点点消息，哪里想得到年关难过，灾难来的让人猝不及防。由于疫情防控，2020年感觉转瞬即逝，仿佛晃眼的功夫。本来做些自身职业上的改变，去年因为自身的原因因此搁浅。想想这几年自己维护的这个框架并未有太大的起色，甚者一度遗忘了它，所规划的很多内容并未得到实现。自己的懒惰搁浅，未免是对生命的严重浪费。今年的虽然暂时没有太多的计划，但是改变已经走在路上，希望这对自己的人生有所帮助。plain framework原本是面向游戏服务器设计的，不过在设计上尽量兼容所有的网络应用，从14年开始到现在已经六七年了，经过多次的修改，也扩充了不少的接口，在使用上更加的便捷。在这篇总结中，我主要讲述的是最近加入的控制台（console）模块，其实这个模块在许多框架中是很常见的。未来的技术日新月异，如果大家对编程上面有所兴趣，不妨可以做一定的参考，如有不足的地方也请指正，我将认真的思考其中遗留的问题。在这里我也祝愿大家在2021年，在风雨之后迎来希望的彩虹！

总结

　　在以前的文章中，我已经总结过plain framework的成长过程，从C++98到C++11经历了不小的变化。如今的目录结构和当初很不同，从参考到自己的一些设计，让整个框架越来越好用越来越高效是最终的目的。但是这种改变是漫长的，而且总觉得力不从心，许多的设计虽然有过临时的想法始终没能得到执行。当前这个框架现阶段如果直接用于项目中问题不大，却不能保证有所隐藏的一些BUG。今年我要做出一些改变，不单单做游戏方面的设计，我对于未来的技术也有过兴趣，如在之前的项目中使用过VUE框架来做后台的相应设计。不过相对于未来，算法始终是大方向以及技术上需要突破的，比如AI人工智能，其中的算法需要许多的数学知识，但这些相应的知识我自己要么遗忘要么还没认真接触，作为自己的兴趣后续会向这些方向研究。

　　人生总要有些改变，支持迟来和早来！因此我需要有段时间来放空脑袋，想一想未来的方向了。随着年龄的增长就产生了一种莫名的危机感，在职业上也有些乏味缺少新鲜，但是生活总是要继续的。一个人如果有了计划而不执行，到了没有精力和时间去做得时候，那时候再后悔未免可笑。因此我觉得一个人就得坚定地向着自己的目标走去，就算目标看来那样遥不可及，但我们可以不断改变策略，毕竟没有人随随便便就成功，但如果不去行动那么连成功的机会都没有。

　　希望大家都能慢慢接近自己的理想，也希望这场人类的灾难早点过去！

控制台（console）

　　控制台是在应用中提供调试的工具，一般情况下可以来分析应用运行过程中一些数据。在经典的操作系统中，控制台实在是太常见了，如windows中的命令行控制器，可以使用相应的命令对系统或者应用进行运行、调试和分析。

　　plain framework加入控制台的目的，也是为了调试以及在应用运行中做一些调试和处理，提供了比较丰富的命令接口使得外部注册命令比较容易。在服务器的设计中，很多时候想要看看应用的线程内存情况，还有网络的链接和数据的收发情况。增加控制台，有助于我们在测试的时候，对不同情况下特别是压力测试时分析出重要的数据，这有助于帮助我们对程序进行优化。目前PF 中的命令不多，主要几个常见的命令，后续会继续完善。

　　下图为PF中控制台的调试（包括在LINUX下的编译部分），目前仅支持网络调试（直接输入的方式很快集成，由于感觉用处不大暂时没实现）：

部分代码

　　由于控制台需要使用网络命令行，因此在框架中增加了standard的网络协议（protocol），这个网络协议是遇到换行便将内容读出并调用注册的执行接口：

#include "pf/basic/string.h"

#include "pf/net/stream/input.h"

#include "pf/net/stream/output.h"

#include "pf/net/connection/basic.h"

#include "pf/net/connection/manager/listener.h"

#include "pf/net/protocol/standard.h"                                              

using namespace pf_basic::string;

using namespace pf_net::protocol;                                                  

bool Standard::command(connection::Basic *connection, uint16_t count) {

  if (connection->is_disconnect()) return false; //Leave this when not connected.

  stream::Input *istream = &connection->istream();

  auto line = istream->readline();

  if (!line.empty()) {

    if (!connection->check_safe_encrypt()) return false;

    auto listener = connection->get_listener();

    if (!is_null(listener)) {

      rtrim(line); // Remove '\n' '\r' or other words on last.

      auto callback = listener->get_standard_callback();

      if (callback) callback(line, connection);

    }

  }

  return true;

}                                                                                  

bool Standard::send(connection::Basic *connection, packet::Interface *packet) {

  return true;

}

　　在处理命令的时候注册的回调函数如下：

void console_net_handle(

    const std::string &cmd, pf_net::connection::Basic *connection) {

  using namespace pf_console;

  using namespace pf_basic::string;

  if (is_null(ENGINE_POINTER)) return;

  auto console = ENGINE_POINTER->get_console();

  if (is_null(console)) return;

  if ("quit" == cmd) {

    connection->exit();

    return;

  }

  StringInput input(cmd);

  NetOutput output(connection);

  console->run(&input, &output);

}

　　整个控制台的实现目录结构如下：

　　控制台应用代码：

#include "pf/basic/string.h"

#include "pf/console/argv_input.h"

#include "pf/console/array_input.h"

#include "pf/console/commands/app.h"

#include "pf/console/commands/help.h"

#include "pf/console/commands/list.h"

#include "pf/basic/logger.h"

#include "pf/console/application.h"

using namespace pf_console;

using namespace pf_interfaces::console;

using namespace pf_basic::string;

uint8_t Application::run(Input *input, Output *output) {

  std::unique_ptr<Input> input_temp;

  std::unique_ptr<Output> output_temp;

  if (is_null(input)) {

    unique_move(Input, new ArgvInput(), input_temp);

    input = input_temp.get();

  }

  if (is_null(output)) {

    unique_move(Output, new Output(), output_temp);

    output = output_temp.get();

  }

  configure_IO(input, output);

  uint8_t exit_code{0};

  try {

    exit_code = do_run(input, output);

  } catch (std::exception &e) {

    std::cout << "Application::run get error!!!: " << e.what() << std::endl;

  }

  return exit_code;

}

uint8_t Application::do_run(Input *input, Output *output) {

  if (input->has_parameter_option({"--version", "-V"})) {

    output->write_ln(get_long_version());

    return 0;

  }

  try {

    input->bind(get_definition());

  } catch(...) {

  }

  auto name = get_command_name(input);

  std::unique_ptr<Input> input_temp;

  if (input->has_parameter_option({"--help", "-h"}, true)) {

    if (name == "") {

      name = "help";

      unique_move(Input,

          new ArrayInput({{"command_name", default_command_name_}}),

          input_temp);

      input = input_temp.get();

    } else {

      want_helps_ = false;

    }

  }

  if (name == "") {

    name = default_command_name_;

    auto definition = get_definition();

    definition->set_argument(InputArgument("command",

        InputArgument::kModeOptional,

        definition->get_argument("command").get_description(), name));

  }

  Command *command{nullptr};

  try {

    running_command_ = nullptr;

    command = find(name);

  } catch (...) {

  }

  if (is_null(command)) {

    FAST_ERRORLOG(CONSOLE_MODULENAME,

                  "[console] (Application::run)"

                  " can't find the command: %s",

                  name.c_str());

    return 1;

  }

  running_command_ = command;

  auto exit_code = do_runcommand(command, input, output);

  return exit_code;

}

InputDefinition *Application::get_definition() {

  if (is_null(definition_)) {

    std::unique_ptr<InputDefinition> temp(new InputDefinition());

    *temp = get_default_input_definition();

    definition_ = std::move(temp);

    if (single_command_) {

      if (is_null(definition_temp_))    {

        unique_move(InputDefinition, new InputDefinition(), definition_temp_);

        *definition_temp_ = *definition_;

      }

      definition_temp_->set_arguments({});

      return definition_temp_.get();

    }

  }

  return definition_.get();

}

std::string Application::get_long_version() const {

  std::string r{"Console Tool"};

  if (name_ != "") {

    if (version_ != "") {

      r = name_ + " " + version_;

    }

    r = name_;

  }

  return r;

}

Command *Application::add(Command *command) {

  // std::cout << "Add command: " << command->name() << std::endl;

  if (!command->is_enabled()) {

    return nullptr;

  }

  init();

  command->set_application(this);

  // Will throw if the command is not correctly initialized.

  command->get_definition();

  command->configure();

  auto name = command->name();

  if (name == "") {

    throw std::logic_error("command cannot have an empty name.");

  }

  if (commands_.find(name) != commands_.end()) {

    return commands_[name].get();

  }

  std::unique_ptr<Command> temp;

  unique_move(Command, command, temp);

  commands_[name] = std::move(temp);

  for (auto const &alias : command->get_aliases()) {

    command_aliases_[alias] = name;

  }

  return command;

}

Command *Application::get(const std::string &_name) {

  auto name = get_command_real_name(_name);

  if ("" == name) {

    std::string e = "The command \"" + _name + "\" does not exist.";

    throw std::invalid_argument(e);

  }

  if (commands_.find(name) == commands_.end()) return nullptr;

  auto command = commands_[name].get();

  if (want_helps_) {

    want_helps_ = false;

    auto help_command = get("help");

    help_command->set_command(command);

    return help_command;

  }

  return command;

}

std::vector<std::string> Application::get_namespaces() {

  std::vector<std::string> r;

  auto commands = all();

  for (auto it = commands.begin(); it != commands.end(); ++it) {

    if (it->second->is_hidden()) continue;

    auto temp = extract_all_namespace(it->first);

    for (const auto &one : temp) r.emplace_back(one);

    for (const auto &alias : it->second->get_aliases()) {

      auto temp1 = extract_all_namespace(alias);

      for (const auto &one : temp1) r.emplace_back(one);

    }

  }

  // * The result maybe need use array_unique to remove the same values.

  return r;

}

std::string Application::find_namespace(const std::string &_namespace) {

  return "";

}

Command *Application::find(const std::string &name) {

  init();

  for (auto it = commands_.begin(); it != commands_.end(); ++it) {

    if (!is_null(it->second)) {

      for (const auto &alias : it->second->get_aliases()) {

        if ("" == command_aliases_[alias])

          command_aliases_[alias] = it->second->name();

      }

    } else {

      std::cout << "find no command: " << it->first << std::endl;

    }

  }

  return get(name);

}

std::map<std::string, Command *>

Application::all(const std::string &_namespace) {

  std::map<std::string, Command *> r;

  init();

  if ("" == _namespace) {

    for (auto it = commands_.begin(); it != commands_.end(); ++it) {

      r[it->first] = it->second.get();

    }

    return r;

  }

  for (auto it = commands_.begin(); it != commands_.end(); ++it) {

    if (_namespace == extract_namespace(it->first)) {

      r[it->first] = it->second.get();

    }

  }

  return r;

}

Application &Application::set_default_command(

    const std::string &name, bool is_single_command) {

  default_command_name_ = name;

  if (is_single_command) {

    // Ensure the command exist

    find(name);

    single_command_ = true;

  }

  return *this;

}

uint8_t Application::do_runcommand(

    Command *command, Input *input, Output *output) {

  // std::cout << "do_runcommand: " << command->name() << std::endl;

  return command->run(input, output);

}

std::string Application::get_command_name(Input *input) const {

  return single_command_ ? default_command_name_ : input->get_first_argument();

}

InputDefinition Application::get_default_input_definition() const {

  std::vector<InputParameter *> p;

  std::unique_ptr<InputParameter> p1(new InputArgument(

        "command", InputParameter::kModeRequired,

        "The command to execute", ""

        ));

  p.emplace_back(p1.get());

  std::unique_ptr<InputParameter> p2(new InputOption(

        "--help", "-h", InputParameter::kModeNone,

        "Display help for the given command. When no command"

        " is given display help for the" + default_command_name_ + "command", ""

        ));

  p.emplace_back(p2.get());

  std::unique_ptr<InputParameter> p3(new InputOption(

        "--quiet", "-q", InputParameter::kModeNone,

        "Do not output any message", ""

        ));

  p.emplace_back(p3.get());

  std::unique_ptr<InputParameter> p4(new InputOption(

        "--verbose", "-v|vv|vvv", InputParameter::kModeNone,

        "Increase the verbosity of messages: 1 for normal output, "

        "2 for more verbose output and 3 for debug", ""

        ));

  p.emplace_back(p4.get());

  std::unique_ptr<InputParameter> p5(new InputOption(

        "--version", "-V", InputParameter::kModeNone,

        "Display this application version", ""

        ));

  p.emplace_back(p5.get());

  std::unique_ptr<InputParameter> p6(new InputOption(

        "--ansi", "", InputParameter::kModeNone,

        "Force ANSI output", ""

        ));

  p.emplace_back(p6.get());

  std::unique_ptr<InputParameter> p7(new InputOption(

        "--no-ansi", "", InputParameter::kModeNone,

        "Disable ANSI output", ""

        ));

  p.emplace_back(p7.get());

  std::unique_ptr<InputParameter> p8(new InputOption(

        "--no-interaction", "-n", InputParameter::kModeNone,

        "Do not ask any interactive question", ""

        ));

  p.emplace_back(p8.get());

  return InputDefinition(p);

}

std::vector<Command *> Application::get_default_commands() const {

  std::vector<Command *> r;

  return r;

}

std::string Application::get_abbreviation_suggestions(

    const std::vector<std::string> &abbrevs) const {

  return "";

}

std::vector<std::string> Application::find_alternatives(

    const std::string &name, const std::vector<std::string> &collection) const {

  return {};

}

void Application::configure_IO(Input *input, Output *output) {

  if (input->has_parameter_option({"--ansi"}, true)) {

    output->set_decorated(true);

  } else if (input->has_parameter_option({"'--no-ansi'"}, true)) {

    output->set_decorated(false);

  }

}

std::vector<std::string> Application::extract_all_namespace(

    const std::string &name) {

  std::vector<std::string> r;

  std::vector<std::string> parts;

  explode(name.c_str(), parts, ":", true, true);

  for (const auto &part : parts) {

    if (r.size() > 0) {

      std::string temp = r[r.size() - 1] + ":" + part;

      r.emplace_back(temp);

    } else {

      r.emplace_back(part);

    }

  }

  return r;

}

std::string Application::extract_namespace(

    const std::string &name, int32_t limit) const {

  return "";

}

void Application::init() {

  if (initialized_) return;

  initialized_ = true;

  // std::cout << "Application::init" << std::endl;

  add(new commands::Help());

  add(new commands::List());

  add(new commands::App());

}

　　命令实现代码：

#include "pf/basic/string.h"

#include "pf/console/argv_input.h"

#include "pf/console/array_input.h"

#include "pf/console/commands/app.h"

#include "pf/console/commands/help.h"

#include "pf/console/commands/list.h"

#include "pf/basic/logger.h"

#include "pf/console/application.h"

using namespace pf_console;

using namespace pf_interfaces::console;

using namespace pf_basic::string;

uint8_t Application::run(Input *input, Output *output) {

  std::unique_ptr<Input> input_temp;

  std::unique_ptr<Output> output_temp;

  if (is_null(input)) {

    unique_move(Input, new ArgvInput(), input_temp);

    input = input_temp.get();

  }

  if (is_null(output)) {

    unique_move(Output, new Output(), output_temp);

    output = output_temp.get();

  }

  configure_IO(input, output);

  uint8_t exit_code{0};

  try {

    exit_code = do_run(input, output);

  } catch (std::exception &e) {

    std::cout << "Application::run get error!!!: " << e.what() << std::endl;

  }

  return exit_code;

}

uint8_t Application::do_run(Input *input, Output *output) {

  if (input->has_parameter_option({"--version", "-V"})) {

    output->write_ln(get_long_version());

    return 0;

  }

  try {

    input->bind(get_definition());

  } catch(...) {

  }

  auto name = get_command_name(input);

  std::unique_ptr<Input> input_temp;

  if (input->has_parameter_option({"--help", "-h"}, true)) {

    if (name == "") {

      name = "help";

      unique_move(Input,

          new ArrayInput({{"command_name", default_command_name_}}),

          input_temp);

      input = input_temp.get();

    } else {

      want_helps_ = false;

    }

  }

  if (name == "") {

    name = default_command_name_;

    auto definition = get_definition();

    definition->set_argument(InputArgument("command",

        InputArgument::kModeOptional,

        definition->get_argument("command").get_description(), name));

  }

  Command *command{nullptr};

  try {

    running_command_ = nullptr;

    command = find(name);

  } catch (...) {

  }

  if (is_null(command)) {

    FAST_ERRORLOG(CONSOLE_MODULENAME,

                  "[console] (Application::run)"

                  " can't find the command: %s",

                  name.c_str());

    return 1;

  }

  running_command_ = command;

  auto exit_code = do_runcommand(command, input, output);

  return exit_code;

}

InputDefinition *Application::get_definition() {

  if (is_null(definition_)) {

    std::unique_ptr<InputDefinition> temp(new InputDefinition());

    *temp = get_default_input_definition();

    definition_ = std::move(temp);

    if (single_command_) {

      if (is_null(definition_temp_))    {

        unique_move(InputDefinition, new InputDefinition(), definition_temp_);

        *definition_temp_ = *definition_;

      }

      definition_temp_->set_arguments({});

      return definition_temp_.get();

    }

  }

  return definition_.get();

}

std::string Application::get_long_version() const {

  std::string r{"Console Tool"};

  if (name_ != "") {

    if (version_ != "") {

      r = name_ + " " + version_;

    }

    r = name_;

  }

  return r;

}

Command *Application::add(Command *command) {

  // std::cout << "Add command: " << command->name() << std::endl;

  if (!command->is_enabled()) {

    return nullptr;

  }

  init();

  command->set_application(this);

  // Will throw if the command is not correctly initialized.

  command->get_definition();

  command->configure();

  auto name = command->name();

  if (name == "") {

    throw std::logic_error("command cannot have an empty name.");

  }

  if (commands_.find(name) != commands_.end()) {

    return commands_[name].get();

  }

  std::unique_ptr<Command> temp;

  unique_move(Command, command, temp);

  commands_[name] = std::move(temp);

  for (auto const &alias : command->get_aliases()) {

    command_aliases_[alias] = name;

  }

  return command;

}

Command *Application::get(const std::string &_name) {

  auto name = get_command_real_name(_name);

  if ("" == name) {

    std::string e = "The command \"" + _name + "\" does not exist.";

    throw std::invalid_argument(e);

  }

  if (commands_.find(name) == commands_.end()) return nullptr;

  auto command = commands_[name].get();

  if (want_helps_) {

    want_helps_ = false;

    auto help_command = get("help");

    help_command->set_command(command);

    return help_command;

  }

  return command;

}

std::vector<std::string> Application::get_namespaces() {

  std::vector<std::string> r;

  auto commands = all();

  for (auto it = commands.begin(); it != commands.end(); ++it) {

    if (it->second->is_hidden()) continue;

    auto temp = extract_all_namespace(it->first);

    for (const auto &one : temp) r.emplace_back(one);

    for (const auto &alias : it->second->get_aliases()) {

      auto temp1 = extract_all_namespace(alias);

      for (const auto &one : temp1) r.emplace_back(one);

    }

  }

  // * The result maybe need use array_unique to remove the same values.

  return r;

}

std::string Application::find_namespace(const std::string &_namespace) {

  return "";

}

Command *Application::find(const std::string &name) {

  init();

  for (auto it = commands_.begin(); it != commands_.end(); ++it) {

    if (!is_null(it->second)) {

      for (const auto &alias : it->second->get_aliases()) {

        if ("" == command_aliases_[alias])

          command_aliases_[alias] = it->second->name();

      }

    } else {

      std::cout << "find no command: " << it->first << std::endl;

    }

  }

  return get(name);

}

std::map<std::string, Command *>

Application::all(const std::string &_namespace) {

  std::map<std::string, Command *> r;

  init();

  if ("" == _namespace) {

    for (auto it = commands_.begin(); it != commands_.end(); ++it) {

      r[it->first] = it->second.get();

    }

    return r;

  }

  for (auto it = commands_.begin(); it != commands_.end(); ++it) {

    if (_namespace == extract_namespace(it->first)) {

      r[it->first] = it->second.get();

    }

  }

  return r;

}

Application &Application::set_default_command(

    const std::string &name, bool is_single_command) {

  default_command_name_ = name;

  if (is_single_command) {

    // Ensure the command exist

    find(name);

    single_command_ = true;

  }

  return *this;

}

uint8_t Application::do_runcommand(

    Command *command, Input *input, Output *output) {

  // std::cout << "do_runcommand: " << command->name() << std::endl;

  return command->run(input, output);

}

std::string Application::get_command_name(Input *input) const {

  return single_command_ ? default_command_name_ : input->get_first_argument();

}

InputDefinition Application::get_default_input_definition() const {

  std::vector<InputParameter *> p;

  std::unique_ptr<InputParameter> p1(new InputArgument(

        "command", InputParameter::kModeRequired,

        "The command to execute", ""

        ));

  p.emplace_back(p1.get());

  std::unique_ptr<InputParameter> p2(new InputOption(

        "--help", "-h", InputParameter::kModeNone,

        "Display help for the given command. When no command"

        " is given display help for the" + default_command_name_ + "command", ""

        ));

  p.emplace_back(p2.get());

  std::unique_ptr<InputParameter> p3(new InputOption(

        "--quiet", "-q", InputParameter::kModeNone,

        "Do not output any message", ""

        ));

  p.emplace_back(p3.get());

  std::unique_ptr<InputParameter> p4(new InputOption(

        "--verbose", "-v|vv|vvv", InputParameter::kModeNone,

        "Increase the verbosity of messages: 1 for normal output, "

        "2 for more verbose output and 3 for debug", ""

        ));

  p.emplace_back(p4.get());

  std::unique_ptr<InputParameter> p5(new InputOption(

        "--version", "-V", InputParameter::kModeNone,

        "Display this application version", ""

        ));

  p.emplace_back(p5.get());

  std::unique_ptr<InputParameter> p6(new InputOption(

        "--ansi", "", InputParameter::kModeNone,

        "Force ANSI output", ""

        ));

  p.emplace_back(p6.get());

  std::unique_ptr<InputParameter> p7(new InputOption(

        "--no-ansi", "", InputParameter::kModeNone,

        "Disable ANSI output", ""

        ));

  p.emplace_back(p7.get());

  std::unique_ptr<InputParameter> p8(new InputOption(

        "--no-interaction", "-n", InputParameter::kModeNone,

        "Do not ask any interactive question", ""

        ));

  p.emplace_back(p8.get());

  return InputDefinition(p);

}

std::vector<Command *> Application::get_default_commands() const {

  std::vector<Command *> r;

  return r;

}

std::string Application::get_abbreviation_suggestions(

    const std::vector<std::string> &abbrevs) const {

  return "";

}

std::vector<std::string> Application::find_alternatives(

    const std::string &name, const std::vector<std::string> &collection) const {

  return {};

}

void Application::configure_IO(Input *input, Output *output) {

  if (input->has_parameter_option({"--ansi"}, true)) {

    output->set_decorated(true);

  } else if (input->has_parameter_option({"'--no-ansi'"}, true)) {

    output->set_decorated(false);

  }

}

std::vector<std::string> Application::extract_all_namespace(

    const std::string &name) {

  std::vector<std::string> r;

  std::vector<std::string> parts;

  explode(name.c_str(), parts, ":", true, true);

  for (const auto &part : parts) {

    if (r.size() > 0) {

      std::string temp = r[r.size() - 1] + ":" + part;

      r.emplace_back(temp);

    } else {

      r.emplace_back(part);

    }

  }

  return r;

}

std::string Application::extract_namespace(

    const std::string &name, int32_t limit) const {

  return "";

}

void Application::init() {

  if (initialized_) return;

  initialized_ = true;

  // std::cout << "Application::init" << std::endl;

  add(new commands::Help());

  add(new commands::List());

  add(new commands::App());

}

[viticm@izuf633l0ge76tbdctmljaz core]$ cat /home/viticm/develop/github/plain/framework/core/src/console/command.cc

#include "pf/support/helpers.h"

#include "pf/console/application.h"

#include "pf/console/command.h"

using namespace pf_support;

using namespace pf_console;

// Static member must be initialized.

std::string Command::default_name_{"unknown"};

void Command::merge_application_definition(bool merge_args) {

  if (is_null(app_) or !is_null(full_definition_)) return;

  unique_move(InputDefinition, new InputDefinition(), full_definition_);

  full_definition_->set_options(array_values(definition_->get_options()));

  full_definition_->add_options(

    array_values(app_->get_definition()->get_options()));

  if (merge_args) {

    full_definition_->set_arguments(

        array_values(app_->get_definition()->get_arguments()));

    full_definition_->add_arguments(array_values(definition_->get_arguments()));

  } else {

    full_definition_->set_arguments(array_values(definition_->get_arguments()));

  }

}

uint8_t Command::run(Input *input, Output *output) {

  uint8_t r{0};

  merge_application_definition();

  // bind the input against the command specific arguments/options

  try {

    input->bind(get_definition(), is_parse_input());

  } catch (std::exception &e) {

    if (!ignore_validation_errors_)

      throw std::runtime_error(e.what());

  }

  initialize(input, output);

  // Set process title.

  if (!process_title_.empty()) {

  }

  if (input->is_interactive()) {

    interact(input, output);

  }

  // The command name argument is often omitted when a command is executed

  // directly with its run() method.

  // It would fail the validation if we didn't make sure the command argument

  // is present, since it's required by the application.

  if (input->has_argument("command") && input->get_argument("command") == "") {

    input->set_argument("command", name_);

  }

  input->validate();

  if (code_) {

    r = code_(input, output);

  } else {

    r = execute(input, output);

  }

  return r;

}

　　可以在github上找到完整的项目：https://github.com/viticm/plain

巴特西

开源服务器设计总计（plain framework2020年总计）

总结

控制台（console）

部分代码

更多

最新文章

热门文章