void ctx_impl::start(size_t worker_pool_size) {
if (running) return;
running = true;
LOG(INFO) << "Starting distributed policy engine";
work.reset(new io_service::work(io));
for (size_t i = 0; i < worker_pool_size; i++) {
workers.emplace_back([this]() {
while (this->running) {
try {
io.run();
} catch (const std::exception& e) {
LOG(ERROR) << "Exception while processing I/O: "
<< e.what();
} catch (...) {
LOG(ERROR) << "Unknown error while processing I/O";
}
}
});
}
rpc.set_seeds(seeds);
rpc.start();
// leveldb::Options options;
// options.create_if_missing = true;
// leveldb::DB* dbPtr = nullptr;
// path systemDbPath = dbPath;
// systemDbPath /= "__system__";
// leveldb::Status status = leveldb::DB::Open(options,
// systemDbPath.string(),
// &dbPtr);
// if (!status.ok()) {
// throw std::runtime_error(string("Could not create/open database: ") +
// status.ToString());
// } else {
// systemDb.reset(dbPtr);
// dbPtr = nullptr;
// }
}
int main(int argc, char const *argv[])
{
parse_args(argc, argv);
if (num < 1 || num > 10000000)
{
std::cerr << "Bad value for 'num': " << num << std::endl;
usage();
}
if (interval < 1 || interval > 100000)
{
std::cerr << "Bad value for 'interval': " << interval << std::endl;
}
if (counters < 1 || counters > 10000)
{
std::cerr << "Bad value for 'counters': " << counters << std::endl;
}
totalCount_ = 0;
calculate_counters();
connect_socket();
// run, waiting for clean shutdown signals, single-threaded
struct sigaction sact;
memset(&sact, 0, sizeof(sact));
sact.sa_handler = stop_running;
sigaction(SIGINT, &sact, 0);
sigaction(SIGHUP, &sact, 0);
start_timer(0);
struct timeval tv1, tv2;
gettimeofday(&tv1, NULL);
svc_.run();
gettimeofday(&tv2, NULL);
if (!running_)
{
std::cerr << "Interrupted." << std::endl;
}
double seconds = (tv2.tv_sec - tv1.tv_sec) + (tv2.tv_usec - tv1.tv_usec) * 0.000001;
std::cout << "Sent " << totalCount_ << " metrics in " << seconds << " seconds." << std::endl;
return running_ ? 0 : 1;
}
int main(int argc, char* argv[]) {
if(argc != 2) {
cerr << "Usage: " << argv[0] << " <com port name>" << endl;
return EXIT_FAILURE;
}
EnvSignals reader(argv[1], // port name
115200, // baud rate
serial_port::parity::none, //
8, // data bits
serial_port::stop_bits::one, //
1 // modbus address
);
reader.start();
io.run();
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
if (argc > 1)
if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) {
printf("\n Usage: %s [ThreadCount] [Connection_Count] [QueryDataLength]\n", argv[0]);
printf("\n Default: %s %d 1024 4\n", argv[0], thread_count);
printf("\n For example:\n %s 2 1000 32\n", argv[0]);
printf("\n That's means: start client with 2 threads, create 1000 tcp connection to server, and per data-package is 32 bytes.\n\n");
exit(1);
}
if (argc > 1)
thread_count = atoi(argv[1]);
if (argc > 2)
conn_count = atoi(argv[2]);
if (argc > 3)
qdata = atoi(argv[3]);
rlimit of = {65536, 65536};
if (-1 == setrlimit(RLIMIT_NOFILE, &of)) {
perror("setrlimit");
exit(1);
}
for (int i = 0; i < conn_count; ++i)
echo_client();
boost::thread_group tg;
for (int i = 0; i < thread_count; ++i)
tg.create_thread([]{ ios.run(); });
for (;;) {
#ifdef _WIN32
Sleep(1000);
#else
sleep(1);
#endif
show_status();
}
return 0;
}
int main(int argc, char* argv[]) {
if(argc != 2) {
cerr << "Usage: " << argv[0] << " <com port name>" << endl;
return EXIT_FAILURE;
}
boost::asio::signal_set signals(io, SIGINT, SIGTERM);
signals.async_wait(handler);
EnvSignals reader(argv[1], // port name
9600, // baud rate
serial_port::parity::none, //
8, // data bits
serial_port::stop_bits::one, //
1 // modbus address
);
reader.start();
io.run();
return EXIT_SUCCESS;
}
void run_test(std::string const& url, int size, int status, int connected
, boost::optional<error_code> ec, proxy_settings const& ps)
{
reset_globals();
std::cerr << " ===== TESTING: " << url << " =====" << std::endl;
boost::shared_ptr<http_connection> h(new http_connection(ios, cq
, &::http_handler, true, &::http_connect_handler));
h->get(url, seconds(1), 0, &ps);
ios.reset();
ios.run();
std::cerr << "connect_handler_called: " << connect_handler_called << std::endl;
std::cerr << "handler_called: " << handler_called << std::endl;
std::cerr << "status: " << http_status << std::endl;
std::cerr << "size: " << data_size << std::endl;
std::cerr << "error_code: " << g_error_code.message() << std::endl;
TEST_CHECK(connect_handler_called == connected);
TEST_CHECK(handler_called == 1);
TEST_CHECK(data_size == size || size == -1);
TEST_CHECK(!ec || g_error_code == *ec);
TEST_CHECK(http_status == status || status == -1);
}
void worker_thread() {
service.run();
}
int main()
{
tcp::resolver::query q{"theboostcpplibraries.com", "80"};
resolv.async_resolve(q, resolve_handler);
ioservice.run();
}
int main(int argc, char* argv[]) {
ip::tcp::endpoint ep_c( ip::address::from_string("127.0.0.1"), 8001);
ip::tcp::endpoint ep_s( ip::address::from_string("127.0.0.1"), 8002);
proxy::start(ep_c, ep_s);
service.run();
}
int main(int argc, char **argv)
{
using namespace boost::program_options;
unsigned int reload_period;
options_description desc("General");
bool download_only;
desc.add_options()
("verbose", "Increase console log verbosity")
("quiet", "Only report warnings to console")
("manifest_reload_period", value(&reload_period)->default_value(3), "How ofter to recheck manifest file")
("keep_segments", value(&keep_segments)->default_value(50), "Maximum number of segments in the manifest")
("required_manifest_size", value(&required_manifest_size)->default_value(6), "Number of segments to download before starting ffmpeg")
("ffmpeg_command", value<std::string>(), "Command line to start when enough segments are available")
("log_file", value<std::string>()->default_value("hls_proxy.log"), "Log file name")
("download_only", value(&download_only)->default_value(false), "Just download all the segments mentioned in the manifest")
;
try {
options_description hidden;
hidden.add_options()
("source", value<std::string>()->required(), "HLS source URL")
;
options_description all;
all.add(desc).add(hidden);
variables_map vm;
parsed_options parsed = command_line_parser(argc, argv).
options(all).
positional(positional_options_description().add("source", 1)).
run();
store(parsed, vm);
notify(vm);
if (!download_only) {
if (vm.count("ffmpeg_command") == 0) {
FATAL "ffmpeg_command option required when operating in HLS mode";
return 1;
}
ffmpeg_command = vm["ffmpeg_command"].as<std::string>();
}
manifest_reload_period = boost::posix_time::seconds(reload_period);
using namespace boost::log;
auto file_log = add_file_log (
keywords::file_name = vm["log_file"].as<std::string>(),
keywords::format = "[%TimeStamp%]: %Message%",
keywords::auto_flush = true
);
auto console = add_console_log();
if (vm.count("verbose"))
console->set_filter ( trivial::severity >= trivial::debug );
else if (vm.count("quiet"))
console->set_filter ( trivial::severity >= trivial::warning);
else
console->set_filter ( trivial::severity >= trivial::info);
core::get()->add_global_attribute("TimeStamp", attributes::local_clock());
std::string url = vm["source"].as<std::string>();
INFO "Starting " << url;
if (download_only) {
DownloaderManifestReader manifest_reader;
manifest_reader.load_manifest(url);
ios.run();
} else {
HLSManifestReader manifest_reader;
manifest_reader.load_manifest(url);
ios.run();
}
} catch(boost::program_options::error& e) {
std::cout << e.what() << std::endl;
std::cout << "Usage: " << argv[0] << "[options] <hls-url>" << std::endl;
std::cout << desc << std::endl;
} catch (std::exception& e)
{
FATAL "Exception: " << e.what();
}
}
int main(int argc, char ** argv)
{
if(argc == 1)
{
std::cerr<<"Usage: "<<argv[0]<<" filename"<<std::endl;
return 1;
}
const char * script = argv[1];
init_lua();
lua_State * L = get_lua_state();
switch(luaL_loadfile(L, script))
{
case 0: //success
break;
case LUA_ERRFILE:
case LUA_ERRSYNTAX:
case LUA_ERRMEM:
std::cerr<<lua_tostring(L, -1)<<std::endl;
return 1;
default:;
}
// Create and fill arg table
lua_newtable(L);
for(int i = 2; i < argc; i++)
{
lua_pushinteger(L, i - 1);
lua_pushstring(L, argv[i]);
lua_settable(L, -3);
}
lua_setfield(L, LUA_GLOBALSINDEX, "arg");
#ifdef LUAPP_TABLE
lua_newtable(L);
int T = lua_gettop(L);
bind_function(L, T, "test_func", test);
bind_function(L, T, "file_exists", file_exists);
bind_function(L, T, "dir_exists", dir_exists);
/* lua_pushliteral(L, "vars");
lua_newtable(L);
int vars_table = lua_gettop(L);
luapp::init_constants(L, vars_table);
luapp::init_variables(L, vars_table);
lua_settable(L, -3); // Add vars table to core table*/
lua_setglobal(L, "core"); // Add core table to global table
#endif
if(luaL_dofile(L, script) == 1)
{
std::cerr<<lua_tostring(L, -1)<<std::endl;
return 1;
}
try
{
main_io_service.run();
}
catch(const boost::system::system_error & se)
{
std::cerr<<se.what()<<std::endl;
throw;
}
return 0;
}
