void system_timer_custom_allocation_test() { static asio::io_service io_service; struct timer { asio::system_timer t; timer() : t(io_service) {} } timers[100]; int allocation_count = 0; for (int i = 0; i < 50; ++i) { timers[i].t.expires_at((asio::system_timer::time_point::max)()); timers[i].t.async_wait(custom_allocation_timer_handler(&allocation_count)); } for (int i = 50; i < 100; ++i) { timers[i].t.expires_at((asio::system_timer::time_point::min)()); timers[i].t.async_wait(custom_allocation_timer_handler(&allocation_count)); } for (int i = 0; i < 50; ++i) timers[i].t.cancel(); io_service.run(); ASIO_CHECK(allocation_count == 0); }
void ex_flickr() { printf ("Tags (default 'kitten'): "); std::string tags = util::readLine(); std::vector<std::string> splitTags; boost::split(splitTags, tags, boost::is_space()); splitTags.resize( std::remove(splitTags.begin(), splitTags.end(), "") - splitTags.begin()); if (splitTags.empty()) splitTags.push_back("kitten"); ut::Task<void> task = asyncFlickrDownload(splitTags, 25, 10); sIo.run(); assert(task.isReady()); try { task.get(); } catch (std::exception& e) { printf ("Flickr download failed: %s - %s\n", typeid(e).name(), e.what()); } catch (...) { printf ("Flickr download failed: unknown exception\n"); } }
Wondruss::auth_slave::auth_slave(asio::io_service& io_service, Lobby* lobby) : service_slave(io_service, lobby) { asio::local::stream_protocol::socket child_fdsock(io_service); asio::local::stream_protocol::socket child_rdsock(io_service); asio::local::stream_protocol::socket child_wrsock(io_service); asio::local::connect_pair(fdsock, child_fdsock); asio::local::connect_pair(rdsock, child_wrsock); asio::local::connect_pair(wrsock, child_rdsock); fcntl(fdsock.native(), F_SETFD, FD_CLOEXEC); fcntl(rdsock.native(), F_SETFD, FD_CLOEXEC); fcntl(wrsock.native(), F_SETFD, FD_CLOEXEC); io_service.notify_fork(asio::io_service::fork_prepare); pid_t newpid = fork(); if (newpid == 0) { io_service.notify_fork(asio::io_service::fork_child); if(FD_SOCKETS != dup2(child_fdsock.native(), FD_SOCKETS)) { child_fdsock.send(asio::buffer("KO", 0)); exit(0); } if(FD_LBY_TO_SLV != dup2(child_rdsock.native(), FD_LBY_TO_SLV)) { child_fdsock.send(asio::buffer("KO", 0)); exit(0); } if(FD_SLV_TO_LBY != dup2(child_wrsock.native(), FD_SLV_TO_LBY)) { child_fdsock.send(asio::buffer("KO", 0)); exit(0); } // TODO: find wondruss_auth a bit more sanely execl("./wondruss_auth", "wondruss_auth", nullptr); // if we get here, execl failed for some reason. Let's tell the lobby we failed. child_fdsock.send(asio::buffer("KO", 0)); exit(0); } io_service.notify_fork(asio::io_service::fork_parent); char buf[3] = {0}; fdsock.receive(asio::buffer(buf, 2)); //TODO: timeout if(strcmp(buf, "OK") != 0) { LOG_FATAL("Auth process gave us a bad startup msg. WTF?"); // TODO: fail spectacularly } else { LOG_INFO("Auth startup OK! continuing..."); } rdsock.async_receive(asio::null_buffers(), std::bind(std::mem_fn(&auth_slave::handle_slave_msg), this, std::placeholders::_1)); }
static void process_start( const std::error_code& ec, asio::io_service& io_service) { assert(!ec); std::shared_ptr<myapp> app(new myapp(io_service)); io_service.post(std::bind(&myapp::start, app)); }
void scheduler::process_service_work(asio::io_service& service) { while (running) { try { service.run(); } catch (std::exception& e) { (void) e; STATICLIB_PION_LOG_ERROR(log, e.what()); } catch (...) { STATICLIB_PION_LOG_ERROR(log, "caught unrecognized exception"); } } }
void Plugin_Quit() { forwarder->Quit(); streamManager->quit(); streamer.release(); forwarder.release(); mpdClient.release(); streamManager.release(); io_service.stop(); //::WaitForSingleObject(io_sync_mutex, INFINITE); }
void StorageEngineImpl::getLongestPrefixes(asio::io_service &io, function<void(const std::vector<Name> &)> onCompletion) { // if (!keysTrieBuilt_) // onCompletion(keysTrie_.getLongestPrefixes()); // else // { shared_ptr<StorageEngineImpl> me = shared_from_this(); io.dispatch([me, this, onCompletion]() { buildKeyTrie(); keysTrieBuilt_ = true; onCompletion(keysTrie_.getLongestPrefixes()); }); // } }
void handleConnected(asio::io_service &ioService, RedisAsyncClient &redis, bool ok, const std::string &errmsg) { if( ok ) { redis.command("SET", redisKey, redisValue, [&](const RedisValue &v) { std::cerr << "SET: " << v.toString() << std::endl; redis.command("GET", redisKey, [&](const RedisValue &v) { std::cerr << "GET: " << v.toString() << std::endl; redis.command("DEL", redisKey, [&](const RedisValue &) { ioService.stop(); }); }); }); } else { std::cerr << "Can't connect to redis: " << errmsg << std::endl; } }
void reset() { io_service.reset(); }
DWORD CALLBACK IOServiceRunThread(void *state) { io_service.run(); ::SetEvent(io_sync_mutex); return 0; }
void run_ios( ba::io_service &ios ) { while( 1 ) { ios.run( ); } }
void Connection::poll() { // reset must always be called prior to poll g_ioService.reset(); g_ioService.poll(); }
void Connection::terminate() { g_ioService.stop(); m_outputStreams.clear(); }
void io_service_thread() { io_svc.run(); if(log_level) std::cerr << "io_svc stopped" << std::endl; serial.close(); //serial port should be closed from the same thread as io service }
virtual ~AsioMTImpl() { io_svc.stop(); io_thread.join(); }
void Connection::poll() { g_ioService.poll(); g_ioService.reset(); }
void Connection::terminate() { g_ioService.stop(); }
void term() { io_service.stop(); }
void insert(std::function<void(void)> f) { io_service.post(f); }
void run(size_t n, ThreadGroup& tg) { tg.run([this]{ asio::io_service::work work(io_service); io_service.run(); }, n); }