int main()

in mcrouter/lib/carbon/example/ThreadAffinityMC.cpp [105:201]
88 lines of code
12 McCabe index (conditional complexity)

int main(int argc, char** argv) {
  folly::init(&argc, &argv);

  // Create CarbonRouterInstance
  XLOG(INFO, "Creating CarbonRouterInstance");
  std::unordered_map<std::string, std::string> flavorOverrides;
  flavorOverrides.emplace("num_proxies", std::to_string(FLAGS_num_proxies));
  flavorOverrides.emplace("asynclog_disable", "true");
  if (FLAGS_thread_affinity) {
    flavorOverrides.emplace("thread_affinity", "true");
  } else {
    flavorOverrides.emplace("thread_affinity", "false");
  }
  // Service identity
  flavorOverrides.emplace("ssl_service_identity", FLAGS_ssl_service_identity);
  if (FLAGS_ssl_service_identity_authorization_log) {
    flavorOverrides.emplace("ssl_service_identity_authorization_log", "true");
  } else {
    flavorOverrides.emplace("ssl_service_identity_authorization_log", "false");
  }
  if (FLAGS_ssl_service_identity_authorization_enforce) {
    flavorOverrides.emplace(
        "ssl_service_identity_authorization_enforce", "true");
  } else {
    flavorOverrides.emplace(
        "ssl_service_identity_authorization_enforce", "false");
  }
  if (!FLAGS_routing_config_override.empty()) {
    flavorOverrides.emplace("config", "file:" + FLAGS_routing_config_override);
  }

  std::shared_ptr<CarbonRouterInstance<MemcacheRouterInfo>> router;
  try {
    router = createRouterFromFlavor<MemcacheRouterInfo>(
        FLAGS_flavor, flavorOverrides);
  } catch (std::exception& ex) {
    XLOGF(
        ERR,
        "Error creating router for threadAffinity for flavor {}. Exception: {}",
        FLAGS_flavor,
        ex.what());
    return 1;
  }

  SCOPE_EXIT {
    // Release all router resources on exit
    router->shutdown();
    freeAllRouters();
  };

  XLOGF(INFO, "Creating {} CarbonRouterClient", FLAGS_num_clients);
  std::vector<std::thread> threads;
  for (int t = 0; t < FLAGS_num_client_threads; ++t) {
    threads.push_back(std::thread([&]() {
      std::vector<Pointer> clients;
      for (int i = 0; i < FLAGS_num_clients; ++i) {
        clients.push_back(
            router->createClient(0 /* max_outstanding_requests */, false));
      }
      for (int i = 0; i < FLAGS_num_clients; ++i) {
        XLOGF(
            INFO,
            "Sending {} requests to CarbonRouterClient {}",
            FLAGS_num_req_per_client,
            i);
        for (int j = 0; j < FLAGS_num_req_per_client; ++j) {
          sendGetRequest(clients[i].get(), folly::sformat("key:{}{}", i, j));
        }
      }
    }));
  }

  for (auto& thread : threads) {
    thread.join();
  }

  for (int i = 0; i < FLAGS_num_proxies; ++i) {
    XLOGF(
        INFO,
        "Total Connections proxy_{}: {}",
        i,
        router->getProxyBase(i)->stats().getValue(num_servers_up_stat));
    XLOGF(
        INFO,
        "Authorization Successes proxy_{}: {}",
        i,
        router->getProxyBase(i)->stats().getValue(
            num_authorization_successes_stat));
    XLOGF(
        INFO,
        "Authorization Failures proxy_{}: {}",
        i,
        router->getProxyBase(i)->stats().getValue(
            num_authorization_failures_stat));
  }
  return 0;
}