int main(int argc, char **argv)
{
struct sockaddr_in addr;
struct rdma_cm_event *event = NULL;
struct rdma_cm_id *listener = NULL;
struct rdma_event_channel *ec = NULL;
uint16_t port = 0;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
TEST_Z(ec = rdma_create_event_channel());
TEST_NZ(rdma_create_id(ec, &listener, NULL, RDMA_PS_TCP));
TEST_NZ(rdma_bind_addr(listener, (struct sockaddr *)&addr));
TEST_NZ(rdma_listen(listener, 10)); /* backlog=10 is arbitrary */
port = ntohs(rdma_get_src_port(listener));
printf("listening on port %d.\n", port);
while (rdma_get_cm_event(ec, &event) == 0) {
struct rdma_cm_event event_copy;
memcpy(&event_copy, event, sizeof(*event));
rdma_ack_cm_event(event);
if (on_event(&event_copy))
break;
}
rdma_destroy_id(listener);
rdma_destroy_event_channel(ec);
return 0;
}
void Gamestate_II::fire_event(const Zeni_Input_ID &id, const float &confidence) {
std::map<Zeni_Input_ID, int>::iterator it = m_ii.find(id);
if(it != m_ii.end()) {
float &pc = it->first.previous_confidence;
if(pc != confidence) {
pc = confidence;
on_event(id, confidence, it->second);
}
}
else
on_event(id, confidence, 0);
}
int Application::on_execute()
{
if(this->on_init() == false)
{
return -1;
}
SDL_Event Event;
while(m_running)
{
while(SDL_PollEvent(&Event))
{
on_event(&Event);
}
this->on_loop();
this->on_render();
Uint32 end = SDL_GetTicks();
if(end-m_start >= 1000)
{
std::cout << m_nb_frames << " images par secondes." << std::endl;
m_nb_frames = 0;
m_start = SDL_GetTicks();
}
else
{
++m_nb_frames;
}
}
this->on_cleanup();
return 0;
}
char ask_password(char *pass,char text)
{
char *c;
switch (text)
{
case 0:c ="Provˆ©en¡";break;
case 1:c ="Zmˆna hesla";break;
case 2:c ="Kontrola";break;
}
def_dialoge(320-100,240-50,200,90,c);
define(-1,10,20,1,1,0,label,"Vlo‘ heslo:");
define(10,10,40,180,12,0,input_line,49);
property(def_border(3,WINCOLOR),NULL,flat_color(RGB555(31,31,31)),RGB555(8,8,8));
if (text == 1)set_default(pass);else set_default("");on_event(ask_password_event);
define(20,5,5,50,20,2,button,"OK");
property(def_border(1,0),NULL,NULL,WINCOLOR);on_change(terminate);
define(30,5,5,50,20,3,button,"Zru¨it");
property(def_border(1,0),NULL,NULL,WINCOLOR);on_change(terminate);
redraw_window();
goto_control(10);
escape();
if (o_aktual->id == 30) text = 0;else
{
text = 1;
get_value(0,10,pass);
}
close_current();
return text;
}
bool
TrexDpPortEvent::on_core_reporting_in(int thread_id, bool status) {
/* mark sure no double signal */
if (m_signal.at(thread_id)) {
std::stringstream err;
err << "double signal detected on event id: " << m_event_id;
throw TrexException(err.str());
}
/* mark */
m_signal.at(thread_id) = true;
m_pending_cnt--;
/* if any core reported an error - mark as a failure */
if (!status) {
on_error(thread_id);
}
/* event occured */
if (m_pending_cnt == 0) {
on_event();
return true;
} else {
return false;
}
}
int main(int argc, char **argv)
{
struct addrinfo *addr;
struct rdma_cm_event *event = NULL;
struct rdma_cm_id *conn= NULL;
struct rdma_event_channel *ec = NULL;
if (argc != 3)
die("usage: client <server-address> <server-port>");
TEST_NZ(getaddrinfo(argv[1], argv[2], NULL, &addr));
TEST_Z(ec = rdma_create_event_channel());
TEST_NZ(rdma_create_id(ec, &conn, NULL, RDMA_PS_TCP));
TEST_NZ(rdma_resolve_addr(conn, NULL, addr->ai_addr, TIMEOUT_IN_MS));
freeaddrinfo(addr);
while (rdma_get_cm_event(ec, &event) == 0) {
struct rdma_cm_event event_copy;
memcpy(&event_copy, event, sizeof(*event));
rdma_ack_cm_event(event);
if (on_event(&event_copy))
break;
}
rdma_destroy_event_channel(ec);
return 0;
}
void RedChannel::handle_migrate(RedPeer::InMessage* message)
{
DBG(0, "channel type %u id %u", get_type(), get_id());
_socket_in_loop = false;
_loop.remove_socket(*this);
SpiceMsgMigrate* migrate = (SpiceMsgMigrate*)message->data();
if (migrate->flags & SPICE_MIGRATE_NEED_FLUSH) {
send_migrate_flush_mark();
}
AutoRef<CompoundInMessage> data_message;
if (migrate->flags & SPICE_MIGRATE_NEED_DATA_TRANSFER) {
data_message.reset(recive());
}
_client.migrate_channel(*this);
if (migrate->flags & SPICE_MIGRATE_NEED_DATA_TRANSFER) {
if ((*data_message)->type() != SPICE_MSG_MIGRATE_DATA) {
THROW("expect SPICE_MSG_MIGRATE_DATA");
}
std::auto_ptr<RedPeer::OutMessage> message(new RedPeer::OutMessage(SPICE_MSGC_MIGRATE_DATA));
spice_marshaller_add(message->marshaller(), (*data_message)->data(), (*data_message)->size());
send(*message);
}
_loop.add_socket(*this);
_socket_in_loop = true;
on_migrate();
set_state(CONNECTED_STATE);
on_event();
}
void start(void) {
XEvent ev;
XSync(dpy, 0);
debug("[Start] Started\n");
draw();
while(!stop && !XNextEvent(dpy, &ev))
on_event(&ev);
}
void x3ds_instance::advance(float delta_time)
{
on_event(event_id::ENTER_FRAME);
if (m_play_state == PLAY)
{
m_current_frame = fmod(m_current_frame + 1.0f, (float) m_def->m_file->frames);
lib3ds_file_eval(m_def->m_file, m_current_frame);
}
}
void Gamestate_II::fire_missed_events() {
Game &gr = get_Game();
for(std::map<Zeni_Input_ID, int>::iterator it = m_ii.begin(), iend = m_ii.end(); it != iend; ++it) {
switch(it->first.type) {
case SDL_KEYDOWN:
{
const float confidence = gr.get_key_state(it->first.subid) ? 1.0f : 0.0f;
if(m_firing_missed_events && it->first.previous_confidence != confidence)
on_event(it->first, confidence, it->second);
it->first.previous_confidence = confidence;
}
break;
case SDL_MOUSEBUTTONDOWN:
{
const float confidence = gr.get_mouse_button_state(it->first.subid) ? 1.0f : 0.0f;
if(m_firing_missed_events && it->first.previous_confidence != confidence)
on_event(it->first, confidence, it->second);
it->first.previous_confidence = confidence;
}
break;
case SDL_JOYBUTTONDOWN:
{
const float confidence = gr.get_joy_button_state(it->first.which, it->first.subid) ? 1.0f : 0.0f;
if(m_firing_missed_events && it->first.previous_confidence != confidence)
on_event(it->first, confidence, it->second);
it->first.previous_confidence = confidence;
}
break;
default:
break;
}
}
}
void StateManager::game_loop(SDL_Renderer* ren)
{
SDL_Event event;
while (SDL_PollEvent(&event)) {
on_event(&event);
}
on_loop();
render(ren);
}
void sdl_app::handle_events(){
SDL_Event event;
while(SDL_PollEvent(&event)){
on_event(event);
for(app_ptr_list_iter it = my_apps.begin();
it != my_apps.end(); ++it){
(*it)->process_event(event);
}
}
}
server_t *tcp_server_init(
int port,
const char *host,
int backlog_size,
event_cb on_event
)
{
// allocate server
server_t *server = zalloc(sizeof(*server));
// setup server
server->handle.data = server;
server->on_event = on_event;
server->sizeof_client = sizeof(client_t);
// configure timeouts, let a client be inactive for a whole one day
server->timeouts.first_message = 86400 * 1000;
server->timeouts.stale_client = 86400 * 1000;
server->timeouts.keepalive = 86400 * 1000;
// setup listener
uv_tcp_init(uv_default_loop(), &server->handle);
struct sockaddr_in address = uv_ip4_addr(host, port);
// bind
if (uv_tcp_bind(&server->handle, address)) {
// bind failed? report error
on_event(server, EVT_ERROR, uv_last_error(uv_default_loop()).code, NULL);
} else {
// listen
if (uv_listen((uv_stream_t *)&server->handle,
backlog_size, server_on_connection))
{
// listen failed? report error
on_event(server, EVT_ERROR, uv_last_error(uv_default_loop()).code, NULL);
} else {
// fire 'listen' event
on_event(server, EVT_LISTEN, 0, NULL);
}
}
return server;
}
static int create_rdma(void *ctx)
{
// struct addrinfo *addr;
struct rdma_cm_event *event = NULL;
struct rdma_cm_id *id = NULL;
rdma_cm_event_handler event_handler = NULL;
/*
if (strcmp(argv[1], "write") == 0)
set_mode(M_WRITE);
else if (strcmp(argv[1], "read") == 0)
set_mode(M_READ);
else
usage(argv[0]);
*/
// TEST_NZ(getaddrinfo(s_ip, s_port, NULL, &addr));
struct sockaddr_in addr = { 0 };
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(ip);
addr.sin_port = htons(port);
//TEST_Z(ec = rdma_create_event_channel());
TEST_NZ( id = rdma_create_id( event_handler, NULL, RDMA_PS_TCP, IB_QPT_RC ) ); //WHAT QP?
TEST_NZ( rdma_resolve_addr(id, NULL, (struct sockaddr*) &addr, TIMEOUT_IN_MS) );
// kfree(addr);
time_stamp(0);
while ( event_handler(id, event) == 0) {
struct rdma_cm_event event_copy;
memcpy(&event_copy, event, sizeof(*event));
// rdma_ack_cm_event(event);
if (on_event(id, &event_copy))
break;
}
rdma_destroy_id(id);
time_stamp(9);
time_calculate();
return 0;
}
static void
all_hook(lua_State *state, lua_Debug *ar) {
int index;
ldb_t *ldb;
if(!lua_getstack(state, 0, ar)) {
ldb_output("[LUA_DEBUG]lua_getstack fail\n");
return;
}
lua_pushstring(state, lua_tag);
lua_gettable(state, LUA_REGISTRYINDEX);
ldb = (ldb_t*)lua_touserdata(state, -1);
if (ldb == NULL) {
return;
}
//if(lua_getinfo(state, "lnS", ar)) {
if(lua_getinfo(state, "lnSu", ar)) {
if (ldb->step) {
if (ldb->first) {
ldb->first = 0;
ldb_output("Break at %s:%d\n", ar->source + 1, ar->currentline);
}
on_event(-1, ldb, state, ar);
return;
} else {
index = search_break_point(ldb, ar);
if (index < 0) {
return;
}
on_event(index, ldb, state, ar);
return;
}
} else {
ldb_output("[LUA_DEBUG]lua_getinfo fail\n");
return;
}
}
int CApp::execute() {
if (!init()) {
return Error::INIT_ERROR;
}
while (!terminated) {
CSceneManager::check_scene_queue();
on_event();
loop();
render();
}
cleanup();
return Error::NO_ERRORS;
}
void on_read_callback(uv_stream_t* tcp, ssize_t nread, const uv_buf_t *buf) {
Client* c = static_cast<Client*>(tcp->data);
if(nread == -1) { // disconnected (?)
char plain_buf[1024*10];
int r = SSL_read(c->ssl, plain_buf, sizeof(plain_buf));
if(r < 0) {
handle_error(c, r);
}
else if(r > 0) {
std::copy(plain_buf, plain_buf+r, std::back_inserter(c->buffer_in));
}
std::copy(c->buffer_in.begin(), c->buffer_in.end(), std::ostream_iterator<char>(std::cout));
::exit(0);
}
int written = BIO_write(c->read_bio, buf->base, nread);
on_event(c);
}
void game::activate_state(const state_arg& args) {
m_anims.clear();
m_bonusanims.clear();
if (const auto* g = std::get_if<game_start_transition>(&args)) {
m_twister.seed(std::mt19937::result_type(g->seed));
m_board.setup(m_twister);
m_queue.setup(m_twister);
m_start_time = SDL_GetTicks();
m_bonus = 0;
m_specials[0].m_type = special_move::shuffle;
m_specials[1].m_type = special_move::nuke;
m_specials[2].m_type = special_move::clear_digit;
m_active_special = 0;
on_event(get_mouse_motion_event());
} else {
assert(0 && "game::activate_state called with invalid args");
}
}
int
CApp::on_execute() {
if (!on_init())
return -1;
SDL_Event event;
while (running) {
while (SDL_PollEvent(&event))
on_event(&event);
on_loop();
on_render();
}
on_cleanup();
return 0;
}
int
TopWindow::event_loop(unsigned accelerators_id)
{
#ifdef ENABLE_SDL
SDL_Event event;
update();
while (SDL_WaitEvent(&event)) {
if (event.type == SDL_QUIT)
break;
if (event.type >= SDL_USEREVENT && event.type <= SDL_NUMEVENTS-1 &&
event.user.data1 != NULL) {
Window *window = (Window *)event.user.data1;
window->on_user(event.type - SDL_USEREVENT);
} else
on_event(event);
}
return 0;
#else /* !ENABLE_SDL */
HACCEL hAccelerators = accelerators_id != 0
? ::LoadAccelerators(XCSoarInterface::hInst,
MAKEINTRESOURCE(accelerators_id))
: NULL;
MSG msg;
while (::GetMessage(&msg, NULL, 0, 0)) {
if (hAccelerators == NULL ||
!::TranslateAccelerator(msg.hwnd, hAccelerators, &msg)) {
::TranslateMessage(&msg);
::DispatchMessage(&msg);
}
}
return msg.wParam;
#endif /* !ENABLE_SDL */
}
int main(int argc, char **argv)
{
struct addrinfo *addr;
struct rdma_cm_event *event = NULL;
struct rdma_cm_id *conn= NULL;
struct rdma_event_channel *ec = NULL;
if (argc != 4)
usage(argv[0]);
if (strcmp(argv[1], "write") == 0)
set_mode(M_WRITE);
else if (strcmp(argv[1], "read") == 0)
set_mode(M_READ);
else
usage(argv[0]);
TEST_NZ(getaddrinfo(argv[2], argv[3], NULL, &addr));
TEST_Z(ec = rdma_create_event_channel());
TEST_NZ(rdma_create_id(ec, &conn, NULL, RDMA_PS_TCP));
TEST_NZ(rdma_resolve_addr(conn, NULL, addr->ai_addr, TIMEOUT_IN_MS));
freeaddrinfo(addr);
while (rdma_get_cm_event(ec, &event) == 0) {
struct rdma_cm_event event_copy;
memcpy(&event_copy, event, sizeof(*event));
rdma_ack_cm_event(event);
if (on_event(&event_copy))
break;
}
rdma_destroy_event_channel(ec);
return 0;
}
int Application::on_execute()
{
if(this->on_init() == false)
{
return -1;
}
SDL_Event Event;
while(m_running)
{
while(SDL_PollEvent(&Event))
{
on_event(&Event);
}
this->on_loop();
this->on_render();
}
this->on_cleanup();
return 0;
}
void client_test(char *ip, char *port) {
struct addrinfo *addr;
struct rdma_cm_event *event = NULL;
struct rdma_cm_id *conn= NULL;
struct rdma_event_channel *ec = NULL;
TEST_NZ(getaddrinfo(ip, port, NULL, &addr));
TEST_Z(ec = rdma_create_event_channel());
TEST_NZ(rdma_create_id(ec, &conn, NULL, RDMA_PS_TCP));
TEST_NZ(rdma_resolve_addr(conn, NULL, addr->ai_addr, TIMEOUT_IN_MS));
freeaddrinfo(addr);
while (rdma_get_cm_event(ec, &event) == 0) {
struct rdma_cm_event event_copy;
memcpy(&event_copy, event, sizeof(*event));
rdma_ack_cm_event(event);
if (on_event(&event_copy)) {
s_ctx->ec = ec;
s_ctx->id = conn;
on_connection(event_copy.id);//send our memory information to server using post_send
//printf("wait for msg_send_completion\n");
poll_cq(NULL);//wait for send_completion
//printf("wait for msg_recv_completion\n");
poll_cq(NULL);//wait for recv_completion
break;
}
}
return;
};
int application::run()
{
INFO("Start");
int retval = 0;
// set the current state and focused_widget_
if (states_.size() == 0)
{
// FIXME: throw something
ERROR("application state count is zero!");
return 1;
}
// set the current state if the user hasn't set one
// and find the first focusable widget
if (!current_state_.lock())
current_state_ = *states_.begin();
focused_widget_ = current_state_.lock()->focus_next();
if (focused_widget_.lock())
focused_widget_.lock()->handle_event(event::create(event::focus));
else // FIXME: throw something
ERROR("current state has no focusable widgets");
current_state_.lock()->on_enter();
current_state_.lock()->redraw(surface_->rect());
// enter the main application loop: handle_events, update timers, redraw
event::ptr event_;
while (!done_)
{
boost::mutex::scoped_lock lock(mainloop_mutex);
// handle all available events before redrawing
event_ = event_system_->poll_event();
while (event_->type() != event::none)
{
//INFO("event received of type: 0x" << std::hex << event_->type());
bool handled_by_on_event = on_event(event_);
if (!handled_by_on_event)
{
// if it's a mouse event
if (event_->type() == event::mouse_motion ||
event_->type() == event::mouse_down ||
event_->type() == event::mouse_up)
{
mouse_event::ptr me = boost::shared_static_cast<mouse_event>(event_);
// let current_state_ determine who to send it to
widget::ptr new_hover_ptr = current_state_.lock()->delegate_mouse_event(me);
// temporary shared pointers (avoid so many .lock() calls below)
widget::ptr hover_ptr = hover_widget_.lock();
widget::ptr focused_ptr = focused_widget_.lock();
if (new_hover_ptr != hover_ptr)
{
// NOTE: only leaf widgets can be hover widgets!!!
if (hover_ptr)
hover_ptr->handle_event(event::create(event::mouse_leave));
hover_ptr = new_hover_ptr;
if (hover_ptr)
hover_ptr->handle_event(event::create(event::mouse_enter));
}
// update focused widget as necessary
if (event_->type() == event::mouse_down &&
hover_ptr && focused_ptr != hover_ptr)
{
if (focused_ptr)
focused_ptr->handle_event(event::create(event::un_focus));
focused_ptr = hover_ptr;
if (hover_ptr)
hover_ptr->handle_event(event::create(event::focus));
}
// assign the weak pointers from the temporary shared pointers
hover_widget_ = hover_ptr;
focused_widget_ = focused_ptr;
}
else // it isn't a mouse event
{
INFO("passing event to focused_widget_");
if (focused_widget_.lock())
{
focused_widget_.lock()->handle_event(event_);
}
else
{
WARN("no current widget, pass to state, trying to find one");
focused_widget_ = current_state_.lock()->focus_next();
if (focused_widget_.lock())
{
focused_widget_.lock()->handle_event(event::create(event::focus));
current_state_.lock()->redraw(surface_->rect());
focused_widget_.lock()->handle_event(event_);
}
else // FIXME: throw something
ERROR("current state has no focusable widgets");
}
}
}
event_ = event_system_->poll_event();
}
// update all timers, and remove those that have expired
// FIXME: add protection for multi threading here
if (new_timers_.size() > 0)
{
INFO("adding new timers");
timers_.insert(timers_.end(), new_timers_.begin(), new_timers_.end());
new_timers_.clear();
}
Ttimers::iterator new_end = std::remove_if(timers_.begin(), timers_.end(),
timer_update_predicate);
timers_.erase(new_end, timers_.end());
// redraw the necessary widgets / regions
try
{
stk::state::ptr current_state_ptr = current_state_.lock();
if (current_state_ptr)
{
if (!redraw_rect.empty())
{
//INFO("applicaiton::run() - redrawing state");
on_predraw(redraw_rect);
// prepare the surface to draw a state
surface_->offset(point(0, 0));
surface_->clip_rect(redraw_rect);
// start the draw process
current_state_ptr->draw(surface_, redraw_rect);
on_postdraw(redraw_rect);
surface_->update(redraw_rect);
// reset the redraw rectangle
redraw_rect = rectangle();
}
else
{
//INFO("nothing to redraw");
}
}
else
{
// FIXME: throw something
WARN("Current State is invalid");
}
}
catch(std::exception &excp)
{
ERROR("Exception " << excp.what() << " while redrawing");
}
catch(stk::exception &excp)
{
ERROR("Stk Exception " << excp.what() << " while redrawing");
}
catch(...)
{
ERROR("Unknown exception while redrawing");
}
lock.unlock();
// FIXME: should we try and get 60 fps by using a timer around the above routines
// and sleeping the difference?
// Carter: Nonsense, only REAL vsync would make sense to avoid tearing
usleep(1000); // 1 ms
}
INFO("Done");
return retval;
}
// This code is very tricky and hard to get right. It should
// only be changed when verified by an automated test. Here
// is the procedure:
//
// 1. Identify a bug or desired feature.
//
// 2. Create a .swf file that isolates the bug or new feature.
// The .swf should use trace() statements to log what it is
// doing and define the correct behavior.
//
// 3. Collect the contents of flashlog.txt from the standalone
// Macromedia flash player. Create a new test file under
// tests/ where the first line is the name of the new test
// .swf, and the rest of the file is the correct trace()
// output.
//
// 4. Verify that gameswf fails the new test (by running
// ./gameswf_batch_test.py tests/name_of_new_test.txt)
//
// 5. Fix gameswf behavior. Add the new test to
// passing_tests[] in gameswf_batch_test.py.
//
// 6. Verify that all the other passing tests still pass!
// (Run ./gameswf_batch_test.py and make sure all tests are
// OK! If not, then the new behavior is actually a
// regression.)
void sprite_instance::advance(float delta_time)
{
// child movieclip frame rate is the same the root movieclip frame rate
// that's why it is not needed to analyze 'm_time_remainder'
if (m_on_event_load_called == false)
{
// clip sprite onload
// _root.onLoad() will not be executed since do_actions()
// for frame(0) has not executed yet.
// _root.onLoad() will be executed later in root::advance()
m_def->instanciate_registered_class(this);
on_event(event_id::LOAD);
}
// execute actions from gotoAndPlay(n) or gotoAndStop(n) frame
if (m_goto_frame_action_list.size() > 0)
{
execute_actions(&m_as_environment, m_goto_frame_action_list);
m_goto_frame_action_list.clear();
}
// Update current and next frames.
if (m_play_state == PLAY)
{
int prev_frame = m_current_frame;
if (m_on_event_load_called)
{
m_current_frame++;
if (m_current_frame >= m_def->get_frame_count())
{
m_current_frame = 0;
}
}
// Execute the current frame's tags.
// execute_frame_tags(0) already executed in dlist.cpp
if (m_current_frame != prev_frame)
{
// Macromedia Flash does not call remove display object tag
// for 1-st frame therefore we should do it for it :-)
if (m_current_frame == 0 && m_def->get_frame_count() > 1)
{
// affected depths
const array<execute_tag*>& playlist = m_def->get_playlist(0);
array<int> affected_depths;
for (int i = 0; i < playlist.size(); i++)
{
int depth = (playlist[i]->get_depth_id_of_replace_or_add_tag()) >> 16;
if (depth != -1)
{
affected_depths.push_back(depth);
}
}
if (affected_depths.size() > 0)
{
m_display_list.clear_unaffected(affected_depths);
}
else
{
m_display_list.clear();
}
}
execute_frame_tags(m_current_frame);
}
}
// got a new message from server
void on_message(connection_ptr con, message_ptr msg){
//https://github.com/LearnBoost/socket.io-spec#Encoding
/* 0 Disconnect
1:: Connect
2:: Heartbeat
3:: Message
4:: Json Message
5:: Event
6 Ack
7 Error
8 noop
*/
std::string strm = msg->get_payload();
char f = strm[0];
std::string::size_type p = 1;
for(int i = 0 ; i < 2; i++){
p = strm.find_first_of(':',p+1);
}
std::string data = strm.substr(p+1);
con->alog().at(log::alevel::DEVEL)<<"revc: "<< strm <<log::endl;
con->alog().at(log::alevel::DEVEL)<<"type: "<< f <<" data: "<< data <<log::endl;
Json::Reader r;
Json::Value v;
switch(f){
case '0':
close();
break;
case '1':
on_connect(con);
break;
case '2':
con->send_heartbeat();
break;
case '3':
on_strmessage(data,msg);
break;
case '4':
on_jsonmessage(data,msg);
/*
var fe:FlashSocketEvent = new FlashSocketEvent(FlashSocketEvent.MSG_JSON);
fe.data = JSON.decode(dm.msg);
dispatchEvent(fe);
*/
break;
case '5':
if(r.parse(data,v)){
on_event(v["name"].asString(),v["args"],msg);
}else{
con->alog().at(log::alevel::DEVEL)<<"parse json failed error "<< data <<log::endl;
}
/*
var m:Object = JSON.decode(dm.msg);
var e:FlashSocketEvent = new FlashSocketEvent(FlashSocketEvent.EVENT);
e.data = m;
dispatchEvent(e);
*/
break;
case '7':
//on_fail();
/*
var m:Object = JSON.decode(dm.msg);
var e:FlashSocketEvent = new FlashSocketEvent(FlashSocketEvent.CONNECT_ERROR);
e.data = dm.msg;
dispatchEvent(e);
*/
break;
default:
break;
}
}
void client_test(char *ip, char *port) {
struct addrinfo *addr;
struct rdma_cm_event *event = NULL;
struct rdma_cm_id *conn= NULL;
struct rdma_event_channel *ec = NULL;
struct timeval t1, t2, t3, t11, t12;
struct timeval dt, dt1, dt2, dt11, dt12, dt13;
gettimeofday(&t1, NULL);
TEST_NZ(getaddrinfo(ip, port, NULL, &addr));
TEST_Z(ec = rdma_create_event_channel());
gettimeofday(&t11, NULL);
TEST_NZ(rdma_create_id(ec, &conn, NULL, RDMA_PS_TCP));
gettimeofday(&t12, NULL);
TEST_NZ(rdma_resolve_addr(conn, NULL, addr->ai_addr, TIMEOUT_IN_MS));
freeaddrinfo(addr);
gettimeofday(&t2, NULL);
while (rdma_get_cm_event(ec, &event) == 0) {
struct rdma_cm_event event_copy;
memcpy(&event_copy, event, sizeof(*event));
rdma_ack_cm_event(event);
if (on_event(&event_copy)) {
s_ctx->ec = ec;
s_ctx->id = conn;
on_connection(event_copy.id);//send our memory information to server using post_send
poll_cq(NULL);//wait for send_completion
poll_cq(NULL);//wait for recv_completion
break;
}
}
gettimeofday(&t3, NULL);
timersub(&t3, &t1, &dt);
timersub(&t3, &t2, &dt2);
timersub(&t2, &t1, &dt1);
timersub(&t2, &t12, &dt13);
timersub(&t12, &t11, &dt12);
timersub(&t11, &t1, &dt11);
long usec = dt.tv_usec + 10000 * dt.tv_sec;
printf("[dt]:\t%ld us.\n", usec);
printf("[dt1]:\t%ld us.\n", dt1.tv_usec+1000000 *dt1.tv_sec);
printf("Including the following steps: \n");
printf("[dt11]:\t%ld us.\n", dt11.tv_usec+1000000 *dt11.tv_sec);
printf("[dt12]:\t%ld us.\n", dt12.tv_usec+1000000 *dt12.tv_sec);
printf("[dt13]:\t%ld us.\n", dt13.tv_usec+1000000 *dt13.tv_sec);
printf("[dt2] takes %ld micro_secs.\n", dt2.tv_usec+1000000*dt2.tv_sec);
printf("[dt]:total time\t[dt1]:pre_setup\t[dt2]:send/recv\t.\n");
printf("[dt11]:create_event_channel\t[dt12]:create_id\t[dt13]:resolve_address.\n");
return;
};
static void update_timer(IxxEvent* self, IxxEventLoop* loop)
{
if (self->elapsed >= self->timer.duration) {
on_event(self, loop, 0);
}
}
void udp_data_handler::handle_error(int error_type)
{
on_event(error_type) ;
}
void on_connect_callback(uv_connect_t* con, int status) {
Client* c = static_cast<Client*>(con->data);
if(status == -1) {
printf("ERROR: on_connect_callback \n");//, uv_err_name(uv_last_error(c->loop)));
::exit(0);
}
int r = uv_read_start((uv_stream_t*)&c->socket, on_alloc_callback, on_read_callback);
if(r == -1) {
printf("ERROR: uv_read_start error: \n");//, uv_err_name(uv_last_error(c->loop)));
::exit(0);
}
const char* http_request_tpl = "" \
"GET %s HTTP/1.1\r\n"
"Host: %s\r\n"
"User-Agent: uv_www_client/0.1\r\n"
"Accept: */*\r\n"
"Connection: close\r\n"
"\r\n";
char http_request[1024];
sprintf(http_request, http_request_tpl, c->page, c->host);
c->addAppData(http_request);
printf("APP DATA: %zu\n", c->buffer_out.size());
c->ssl = SSL_new(c->ssl_ctx);
c->read_bio = BIO_new(BIO_s_mem());
c->write_bio = BIO_new(BIO_s_mem());
SSL_set_bio(c->ssl, c->read_bio, c->write_bio);
SSL_set_connect_state(c->ssl);
r = SSL_do_handshake(c->ssl);
on_event(c);
}
