Function main

extensions/http-curl/tests/HttpGetIntegrationTest.cpp:66–141

};

int main(int argc, char **argv) {
  using org::apache::nifi::minifi::utils::verifyLogLinePresenceInPollTime;
  const cmd_args args = parse_cmdline_args(argc, argv);

  LogTestController::getInstance().setDebug<core::Processor>();
  LogTestController::getInstance().setDebug<core::ProcessSession>();
  LogTestController::getInstance().setDebug<utils::HTTPClient>();
  LogTestController::getInstance().setDebug<minifi::controllers::SSLContextService>();
  LogTestController::getInstance().setDebug<minifi::processors::InvokeHTTP>();
  LogTestController::getInstance().setDebug<minifi::processors::LogAttribute>();

  std::shared_ptr<minifi::Configure> configuration = std::make_shared<minifi::Configure>();
  configuration->set(minifi::Configure::nifi_default_directory, args.key_dir);

  std::shared_ptr<core::Repository> test_repo = std::make_shared<TestRepository>();
  std::shared_ptr<core::Repository> test_flow_repo = std::make_shared<TestFlowRepository>();

  configuration->set(minifi::Configure::nifi_flow_configuration_file, args.test_file);

  std::shared_ptr<minifi::io::StreamFactory> stream_factory = minifi::io::StreamFactory::getInstance(configuration);

  std::shared_ptr<core::ContentRepository> content_repo = std::make_shared<core::repository::VolatileContentRepository>();

  content_repo->initialize(configuration);

  std::unique_ptr<core::FlowConfiguration> yaml_ptr = std::unique_ptr<core::YamlConfiguration>(
      new core::YamlConfiguration(test_repo, test_repo, content_repo, stream_factory, configuration, args.test_file));
  std::shared_ptr<TestRepository> repo = std::static_pointer_cast<TestRepository>(test_repo);

  std::shared_ptr<minifi::FlowController> controller = std::make_shared<minifi::FlowController>(
      test_repo, test_flow_repo, configuration, std::move(yaml_ptr), content_repo, DEFAULT_ROOT_GROUP_NAME, true);

  core::YamlConfiguration yaml_config(test_repo, test_repo, content_repo, stream_factory, configuration, args.test_file);

  std::shared_ptr<core::Processor> proc = yaml_config.getRoot()->findProcessorByName("invoke");
  assert(proc != nullptr);

  const auto inv = std::dynamic_pointer_cast<minifi::processors::InvokeHTTP>(proc);
  assert(inv != nullptr);

  std::string url;
  inv->getProperty(minifi::processors::InvokeHTTP::URL.getName(), url);
  HttpResponder h_ex;
  std::string port, scheme, path;
  std::unique_ptr<TestServer> server;
  parse_http_components(url, port, scheme, path);
  CivetCallbacks callback{};
  if (scheme == "https") {
    std::string cert;
    cert = args.key_dir + "nifi-cert.pem";
    memset(&callback, 0, sizeof(callback));
    callback.init_ssl = ssl_enable;
    std::string https_port = port + "s";
    callback.log_message = log_message;
    server = utils::make_unique<TestServer>(https_port, path, &h_ex, &callback, cert, cert);
  } else {
    server = utils::make_unique<TestServer>(port, path, &h_ex);
  }