Beispiel #1
0
void
AsyncDBCreateGame::HandleNoResult(mysqlpp::Query &query, DBIdManager& idManager, boost::asio::io_service &service, ServerDBCallback &cb)
{
	query.reset();
	query
			<< "SELECT LAST_INSERT_ID()";
	mysqlpp::StoreQueryResult tmpResult = query.store();
	DB_id insertId = tmpResult[0][0];
	if (!tmpResult || tmpResult.num_rows() != 1 || insertId == 0) {
		service.post(boost::bind(&ServerDBCallback::CreateGameFailed, &cb, GetId()));
	} else {
		service.post(boost::bind(&ServerDBCallback::CreateGameSuccess, &cb, GetId()));
		idManager.AddGameId(GetId(), insertId);
	}
}
Beispiel #2
0
bool
simulator::acquire( boost::asio::io_service& io_service )
{
    hasWaveform_ = false;

    if ( ! acqTriggered_ ) {

        io_service.post( [&]() {
            if ( __waveform_generator_generator ) {

                if ( auto generator = __waveform_generator_generator( sampInterval_, startDelay_, nbrSamples_, nbrWaveforms_ ) ) {

                    generator->addIons( ions_ );
                    generator->onTriggered();

                    std::this_thread::sleep_for( std::chrono::milliseconds( nbrWaveforms_ ) ); // simulate triggers

                    post( generator.get() );

                    hasWaveform_ = true;
                    std::unique_lock< std::mutex > lock( queue_ );
                    cond_.notify_one();
                }
            }
        } );

        acqTriggered_ = true;
        return true;        
    }
    return false;
}
Beispiel #3
0
void push_job(int seconds, boost::asio::io_service& io_service, std::vector<boost::shared_future<int> >& pending_data)
{
    boost::shared_ptr<task_t> task = boost::make_shared<task_t>(boost::bind(&sleep_print, seconds));
    boost::shared_future<int> fut(task->get_future());
    pending_data.push_back(fut);
    io_service.post(boost::bind(&task_t::operator(), task));
}
Beispiel #4
0
static void iopost_msg(boost::asio::io_service & io_service,
	boost::function<void(std::string)> msg_sender,
	std::string msg, std::string groupid)
{
	io_service.post(boost::bind(msg_sender, msg));
	logfile.add_log(groupid, msg);
}
Beispiel #5
0
 Server(boost::asio::io_service& io_service)
   : io_service(io_service), data_strand(io_service), active(0),
     sock(io_service, udp::endpoint(udp::v4(), 12321)),
     recv_timer(io_service), send_timer(io_service), msg_timer(io_service) {
   for(auto& p : players){
     p.present = false;
     p.pos = glm::vec3(1.0, 1.0, 1.0);
   }
   start_receive();
   io_service.post(
     data_strand.wrap(std::bind(&Server::respond, this)));
   io_service.post(
     data_strand.wrap(std::bind(&Server::broadcast, this)));
   io_service.post(
     data_strand.wrap(std::bind(&Server::send_msg, this)));
 }
Beispiel #6
0
 std::pair<size_t, size_t> push(pair_type && pair, boost::asio::io_service & main_service)
 {
     auto empty = _sessions.empty();
     _sessions.push(std::move(pair));
     if (empty)
         main_service.post(std::bind(&auth_queue::next, this));
     return { _sessions.size(), _counter };
 }
Beispiel #7
0
void avlog_do_search(boost::asio::io_service & io_service,
	std::string c, std::string q, std::string date,
	boost::function<void (boost::system::error_code, pt::ptree)> handler,
	soci::session & db)
{
	pt::ptree outjson;
	std::string q_escaped;
	// 根据 channel_name , query string , date 像数据库查找
	AVLOG_DBG << " c = " << c << " q =  " << q << " date= " << date ;

	std::vector<std::string>	r_date(1000);
	std::vector<std::string>	r_channel(1000);
	std::vector<std::string>	r_nick(1000);
	std::vector<std::string>	r_message(1000);
	std::vector<std::string>	r_rowid(1000);

	avhttp::detail::unescape_path(q, q_escaped);

	boost::timer::cpu_timer cputimer;

	cputimer.start();

	db << "select date,channel,nick,message,rowid from avlog where channel=:c "
		"and message like \"%" << q_escaped << "%\" order  by strftime(`date`) DESC"
		, soci::into(r_date)
		, soci::into(r_channel)
		, soci::into(r_nick)
		, soci::into(r_message)
		, soci::into(r_rowid)
		, soci::use(c);

	pt::ptree results;
	// print out the result
	for (int i = 0; i < r_date.size() ; i ++)
	{
		pt::ptree onemsg;
		onemsg.put("date", r_date[i]);
		onemsg.put("channel", r_channel[i]);
		onemsg.put("nick", r_nick[i]);
		onemsg.put("channel", r_channel[i]);
		onemsg.put("message", r_message[i]);
		onemsg.put("id", r_rowid[i]);

		results.push_back(std::make_pair("", onemsg));
	}

	outjson.put("params.num_results", r_date.size());
	outjson.put_child("data", results);

	outjson.put("params.time_used", boost::timer::format(cputimer.elapsed(), 6, "%w"));

	io_service.post(
		boost::asio::detail::bind_handler(handler,
			boost::system::error_code(),
			outjson
		)
	);
};
Beispiel #8
0
void
Logger::finalizeLogRecord()
{
    if (!recordsQueue_.push(currentLogRecord_.str()))
        sink_->finalizeRecord("[CRITICAL]\tlog queue is full");
        // getOutFileStream() << "[CRITICAL]\tlog queue is full" << std::endl;
    else
        LogIoService.post(boost::bind(&Logger::processLogRecords, shared_from_this()));
}
Beispiel #9
0
void worker(int id) {
    while (true) {
        this_thread::sleep_for(chrono::milliseconds(rand() % 3000));

        shared_queue.post([id] {
                std::cout << "event from thread #" << id << " handled on " << this_thread::get_id << "\n";
            });
    }
}
/*
 * NOTE!!! post dispatch 区别仅仅在io_service调用的工作函数里使用才看得出区别。
 * dispatch 只有start没有finish
 */
static
void job_func(int i)
{
    LOG(INFO) << "Job " << i << " started in thread " << THIS_THREAD_ID;
    SLEEP_SECONDS(2);
    // g_io_service.dispatch(std::bind(job_func, i+1));
    g_io_service.post(std::bind(job_func, i+1));
    LOG(INFO) << "Job " << i << " finished in thread " << THIS_THREAD_ID;
}
Beispiel #11
0
int main(int argc, char** argv) {
    init();
    if (handle_args(argc, argv) == 1)
        return 0;

    int processors = boost::thread::hardware_concurrency();

    ioService.post(boost::bind(read_images));
    ioService.post(boost::bind(assign_workers));
    ioService.post(boost::bind(output));

    boost::asio::io_service::work work(ioService);
    for (int i = 0; i < processors; i++) {
        threadpool.create_thread(boost::bind(&boost::asio::io_service::run, &ioService));
    }
    threadpool.join_all();
    return 0;
}
		void syncLoad(AssetPath path, AssetPromisePtr pr, AssetContentPtr c) {
			Progress::Work w = (Progress::Work)boost::filesystem::file_size(path);
			mngr.prog_.addWork( w );
			// add the loading function to the io_service
			io.post( boost::bind(
				&AssetManager::Loader::asyncLoad,
				this, path, pr, c, w
				)
			);
		}
Beispiel #13
0
// workarround windows that can use posix stream for stdin
static void input_thread(boost::asio::io_service & io_service)
{
	while (!boost::this_thread::interruption_requested() && !std::cin.eof())
	{
		std::string line;
		std::getline(std::cin, line);
		io_service.post([line]{
			input_got_one_line(ansi_utf8(line));
		});
	}
}
Beispiel #14
0
static void 
worker()
{
    sleep(2);
    svc.post([](){
            std::cout<<"\nRaising signal.";
            std::string hello("hello world");
            textEntered(hello);
       });
    return;
}
int main(int argc, char **argv) {

  if (argc != 3) {
    std::cerr << "usage stackless_coroutine_perf <port> <read buffer size>\n";
    return 1;
  }

  boost::asio::io_service io;
  auto work = std::make_unique<boost::asio::io_service::work>(io);

  std::promise<void> done_promise;

  auto done_future = done_promise.get_future();

  auto func = [&]() {
    do_coroutine(io, "127.0.0.1", argv[1], std::stoi(argv[2]),
                 [&](auto &value, std::exception_ptr e, auto op) {
                   if (e) {
                     done_promise.set_exception(e);
                   } else {
                     auto end_time = std::chrono::steady_clock::now();

                     auto duration =
                         std::chrono::duration_cast<std::chrono::milliseconds>(
                             end_time - value.start_time);
                     std::cout << "Received " << value.bytes << " in "
                               << duration.count() << " milliseconds\n";
                     std::cout << "Transmit speed "
                               << (value.bytes / duration.count()) * 1000
                               << " Bytes/Seconds \n";
                     done_promise.set_value();
                   }
                 });
  };

  io.post(func);

  auto frun = std::async(std::launch::async, [&]() { io.run(); });

  done_future.wait();

  work.reset();

  frun.get();

  try {

    done_future.get();
  } catch (std::exception &e) {
    std::cerr << e.what() << "\n";
  }
};
	void async_rename(const boost::filesystem::path & source,
		const boost::filesystem::path & destination,
		Callback callback)
	{
		worker_service_.post(boost::bind(
			&filesystem_service::rename<boost::_bi::protected_bind_t<Callback> >,
			this,
			boost::make_shared<boost::asio::io_service::work>(boost::ref(io_service_)),
			source,
			destination,
			boost::protect(callback)
		));
	}
Beispiel #17
0
void assign_workers() {
    Frame* current;
    while (hasMoreFrames || in_buffer.size() > 0) {
        if (in_buffer.size() > 0) {
            current = in_buffer.front();
            // spawn worker to process image;
            BOOST_LOG_TRIVIAL(info) << "Working...";
            ioService.post(boost::bind(worker, current));
            in_buffer.pop();
        }

        boost::this_thread::sleep(boost::posix_time::milliseconds(30));
    }
}
Beispiel #18
0
	// ------------------------------------------------------------------
	//
	// @details This is a template method pattern.  The completion calls
	// into the derived class to allow it to implement its custom code
	// following the completion of the computation.  Once that is done,
	// this method sends the result and sends a new task request back to 
	// the task generation source.
	//
	// ------------------------------------------------------------------
	void Task::complete(boost::asio::io_service& ioService)
	{
		//
		// Call into the derived class and let it do whatever it wants first
		auto message = this->completeCustom(ioService);

		//
		// Post the message to the io_service to be returned back to the client.
		std::shared_ptr<ip::tcp::socket> socket = m_socket;
		ioService.post(
			[message, socket]()
		{
			message->send(socket);
		});

		//
		// We send a request for more work
		ioService.post(
			[socket]()
		{
			Messages::TaskRequest command;
			command.send(socket);
		});
	}
Beispiel #19
0
    void generate_jobs() // we're on the data thread
    {
        try { 
            for(;;) {
                boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
                boost::this_thread::interruption_point();

                std::cout << '.' << std::flush;

                static uint64_t id = 0;
                Command cmd(++id);
                iosvc.post(boost::bind(&Server::dispatch, this, cmd)); // to the IO thread!
            }
        }
        catch(boost::thread_interrupted const&) {
            std::cout << "generate_jobs has been stopped" << std::endl;
        }
    }
Beispiel #20
0
        service( boost::asio::io_service & io_svc) :
            boost::asio::io_service::service( io_svc),
            work_{ new boost::asio::io_service::work( io_svc) } {
            io_svc.post([&io_svc](){
//]
//[asio_rr_service_lambda
                while ( ! io_svc.stopped() ) {
                    if ( boost::fibers::has_ready_fibers() ) {
                        // run all pending handlers in round_robin
                        while ( io_svc.poll() );
                        // run pending (ready) fibers
                        this_fiber::yield();
                    } else {
                        // run one handler inside io_service
                        // if no handler available, block this thread
                        if ( ! io_svc.run_one() ) {
                            break;
                        }
                    }
                }
//]
//[asio_rr_service_bottom
            });
        }
Beispiel #21
0
static void post_to_io_queue( boost::asio::io_service& queue, const boost::function< void() >& f )
{
    queue.post( f );
}
//---------------------------------------------------------
void thread_00()
{
	global_io_service.post(boost::bind(check_thread_id_00, boost::this_thread::get_id()));
}
Beispiel #23
0
void
AsyncDBLogin::HandleError(boost::asio::io_service &service, ServerDBCallback &cb)
{
	service.post(boost::bind(&ServerDBCallback::QueryError, &cb, "AsyncDBLogin: Failure."));
}
static void defered_update_node( pubsub::root& root, const pubsub::node_name& node,
    const json::value& val, boost::asio::io_service& queue )
{
    queue.post( boost::bind( update_node, boost::ref( root ), node, val ) );
}
	inline void push_task(const T& task_unwrapped)
	{
		ios_.post(detail::make_task_wrapped(task_unwrapped));
	}
Beispiel #26
0
 void post(Task task)
 {
    io_service_.post( boost::bind(task));
 }
//---------------------------------------------------------
void thread_01()
{
	global_io_service.post(run_00);
}
void service_print4()
{
	// PRINT_DEBUG("Enter print4");    
	m_service.post(boost::bind(print, 4));
	// PRINT_DEBUG("Exit print4");    
}
Beispiel #29
0
 void await_suspend(co2::coroutine<> const& cb)
 {
     io.post(cb);
 }
Beispiel #30
0
void add_busy_work(boost::asio::io_service& io_service, unsigned int count)
{
    io_service.post(boost::bind(busy_work, boost::ref(io_service), count));
}