void
Sender_exec_i::start (void)
{
ACE_Reactor* reactor = 0;
::CORBA::Object_var ccm_object = this->ciao_context_->get_CCM_object();
if (!::CORBA::is_nil (ccm_object.in ()))
{
::CORBA::ORB_var orb = ccm_object->_get_orb ();
if (!::CORBA::is_nil (orb.in ()))
{
reactor = orb->orb_core ()->reactor ();
}
}
if (reactor)
{
// calculate the interval time
long const usec = 1000000 / this->rate_;
if (reactor->schedule_timer (
this->ticker_,
0,
ACE_Time_Value (3, usec),
ACE_Time_Value (0, usec)) == -1)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Sender_exec_i::start : ")
ACE_TEXT ("Error scheduling timer")));
}
}
else
{
throw ::CORBA::INTERNAL ();
}
}
int
ImR_Activator_i::handle_exit (ACE_Process * process)
{
if (debug_ > 0)
{
ORBSVCS_DEBUG
((LM_DEBUG,
ACE_TEXT ("Process %d exited with exit code %d, delay = %d\n"),
process->getpid (), process->return_value (), this->induce_delay_));
}
if (this->induce_delay_ > 0 && this->active_check_pid_ == ACE_INVALID_PID)
{
ACE_Reactor *r = this->orb_->orb_core()->reactor();
ACE_Time_Value dtv (0, this->induce_delay_ * 1000);
pid_t pid = process->getpid();
Act_token_type token = static_cast<Act_token_type>(pid);
r->schedule_timer (this, reinterpret_cast<void *>(token), dtv );
}
else
{
this->handle_exit_i (process->getpid());
}
return 0;
}
void
device_averager::activate()
{
doit( device_state::command_initialize );
ACE_Reactor * reactor = acewrapper::singleton::ReactorThread::instance()->get_reactor();
reactor->schedule_timer( this, 0, ACE_Time_Value(1), ACE_Time_Value(1) );
}
int
ImR_Activator_i::handle_exit (ACE_Process * process)
{
if (debug_ > 0)
{
ORBSVCS_DEBUG
((LM_DEBUG,
ACE_TEXT ("Process %d exited with exit code %d\n"),
process->getpid (), process->return_value ()));
}
if (this->induce_delay_ > 0)
{
ACE_Reactor *r = this->orb_->orb_core()->reactor();
ACE_Time_Value dtv (0, this->induce_delay_ * 1000);
pid_t pid = process->getpid();
#if (ACE_SIZEOF_VOID_P == 8)
ACE_INT64 token = static_cast<ACE_INT64>(pid);
#else
ACE_INT32 token = static_cast<ACE_INT32>(pid);
#endif
r->schedule_timer (this, reinterpret_cast<void *>(token), dtv );
}
else
{
this->handle_exit_i (process->getpid());
}
return 0;
}
void
Time_Handler::setup (void)
{
ACE_Reactor *r = ACE_Reactor::instance ();
this->timer_id_[2] = r->schedule_timer (this,
(const void *) 2,
ACE_Time_Value (3));
this->timer_id_[3] = r->schedule_timer (this,
(const void *) 3,
ACE_Time_Value (4));
this->timer_id_[4] = r->schedule_timer (this,
(const void *) 4,
ACE_Time_Value (5));
return;
}
int
run_main (int, ACE_TCHAR *[])
{
ACE_START_TEST (ACE_TEXT ("Timer_Cancellation_Test"));
ACE_Reactor reactor (new ACE_TP_Reactor,
1);
Deadlock deadlock;
deadlock.reactor (&reactor);
Event_Handler handler (deadlock);
// Scheduler a timer to kick things off.
reactor.schedule_timer (&handler,
0,
ACE_Time_Value (1));
// Run the event loop for a while.
ACE_Time_Value timeout (4);
reactor.run_reactor_event_loop (timeout);
ACE_END_TEST;
return 0;
}
void
Client_Peer::crash(void)
{
Crasher * crasher = new Crasher;
ACE_Time_Value clk_tck (0, Clock_Ticks::get_usecs_per_tick ());
ACE_Reactor * reactor = this->orb_->orb_core()->reactor();
reactor->schedule_timer(crasher, 0, clk_tck);
}
CORBA::Boolean
ImR_Activator_i::kill_server (const char* name, CORBA::Long lastpid, CORBA::Short signum)
{
if (debug_ > 1)
ORBSVCS_DEBUG((LM_DEBUG,
"ImR Activator: Killing server <%C>, lastpid = %d\n",
name, lastpid));
pid_t lpid = static_cast<pid_t>(lastpid);
pid_t pid = 0;
bool found = false;
int result = -1;
for (ProcessMap::iterator iter = process_map_.begin();
!found && iter != process_map_.end (); iter++)
{
if (iter->item () == name)
{
pid = iter->key ();
found = pid == lpid;
}
}
if (!found && pid == 0)
{
pid = lpid;
}
#if defined (ACE_WIN32)
found = false; // sigchild apparently doesn't work on windows
#endif
if (pid != 0)
{
result =
#if !defined (ACE_WIN32)
(signum != 9) ? ACE_OS::kill (pid, signum) :
#endif
ACE::terminate_process (pid);
if (this->running_server_list_.remove (name) == 0)
{
this->dying_server_list_.insert (name);
}
if (debug_ > 1)
ORBSVCS_DEBUG((LM_DEBUG,
"ImR Activator: Killing server <%C> "
"signal %d to pid %d, found %d, this->notify_imr_ %d, result = %d\n",
name, signum, static_cast<int> (pid), found, this->notify_imr_, result));
if (!found && result == 0 && this->notify_imr_)
{
this->process_map_.bind (pid, name);
ACE_Reactor *r = this->orb_->orb_core()->reactor();
Act_token_type token = static_cast<Act_token_type>(pid);
r->schedule_timer (this, reinterpret_cast<void *>(token), ACE_Time_Value ());
}
}
return result == 0;
}
int
main (int argc, char**argv)
{
// The worlds most useless user interface
Widget top_level = XtVaAppInitialize (NULL,
"buttontest",
NULL,
0,
&argc,
argv,
NULL,
NULL);
Widget button = XmCreatePushButton (top_level,
"change",
0,
0);
XtManageChild (button);
XtAddCallback (button,
XmNactivateCallback,
ActivateCB,
NULL);
// A reactor beastie.
ACE_XtReactor xreactor (XtWidgetToApplicationContext (top_level));
ACE_Reactor reactor (&xreactor);
// Print a message when data is recv'd on stdin...
ACE_Event_Handler *stdin_;
ACE_NEW_RETURN (stdin_,
Stdin (new Stdout (&reactor)),
-1);
reactor.register_handler (stdin_,
ACE_Event_Handler::READ_MASK);
// Print a message every 10 seconds.
if (reactor.schedule_timer (stdin_, 0,
ACE_Time_Value (10),
ACE_Time_Value (10)) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"schedule_timer"),
-1);
// Show the top_level widget.
XtRealizeWidget (top_level);
// Demonstrate Reactor/Xt event loop unification.
XtAppMainLoop (XtWidgetToApplicationContext (top_level));
return 0;
}
int
Time_Handler::svc (void)
{
ACE_Reactor *r = ACE_Reactor::instance ();
ACE_TEST_ASSERT (r->cancel_timer (this->timer_id_[2]) == 1);
this->timer_id_[2] = Time_Handler::TIMER_CANCELLED;
this->timer_id_[1] = r->schedule_timer(this,
(const void *) 1,
ACE_Time_Value (2));
// This one may get the callback before we return, so serialize.
this->lock_.acquire ();
this->timer_id_[0] = r->schedule_timer(this,
(const void *) 0,
ACE_Time_Value (0, -5));
this->lock_.release ();
ACE_OS::sleep(3);
this->timer_id_[5] = r->schedule_timer(this,
(const void *)5,
ACE_Time_Value (10));
this->timer_id_[6] = r->schedule_timer(this,
(const void *)6,
ACE_Time_Value (12));
ACE_TEST_ASSERT (r->cancel_timer (this->timer_id_[4]) == 1);
this->timer_id_[4] = Time_Handler::TIMER_CANCELLED;
// Test that cancelling a timers through a nill ACE_Event_Handler
// pointer just does nothing instead of crash
ACE_Event_Handler_var timer_var;
ACE_TEST_ASSERT (r->cancel_timer (timer_var.handler()) == 0);
return 0;
}
void pause()
{
// get the reactor and set the timer.
CORBA::ORB_var orb = TheServiceParticipant->get_ORB ();
ACE_Reactor* reactor ;
reactor = orb->orb_core()->reactor();
if (reactor->schedule_timer(this,
0,
ACE_Time_Value(0,1)) == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: PauseReactor, ")
ACE_TEXT(" %p. \n"), "schedule_timer"));
}
}
bool
iTaskManager::manager_initialize()
{
if ( timerHandler_ == 0 ) {
acewrapper::scoped_mutex_t<> lock( mutex_ );
if ( timerHandler_ == 0 ) {
// initialize timer
timerHandler_ = new acewrapper::EventHandler< acewrapper::TimerReceiver<internal::TimeReceiver> >();
ACE_Reactor * reactor = iTaskManager::instance()->reactor();
reactor->schedule_timer( timerHandler_, 0, ACE_Time_Value(3), ACE_Time_Value(3) );
}
// activate task
pTask_->open();
return true;
}
return false;
}
CORBA::Boolean
ImR_Activator_i::kill_server (const char* name, CORBA::Long lastpid, CORBA::Short signum)
{
if (debug_ > 1)
ORBSVCS_DEBUG((LM_DEBUG,
"ImR Activator: Killing server <%s>...\n",
name));
pid_t pid = static_cast<pid_t>(lastpid);
bool found = false;
int result = -1;
for (ProcessMap::iterator iter = process_map_.begin();
!found && iter != process_map_.end (); iter++)
{
if (iter->item () == name)
{
pid = iter->key ();
found = true;
}
}
#if defined (ACE_WIN32)
found = false; // sigchild apparently doesn't work on windows
#endif
if (pid != 0)
{
result = (signum != 9) ? ACE_OS::kill (pid, signum)
: ACE::terminate_process (pid);
if (debug_ > 1)
ORBSVCS_DEBUG((LM_DEBUG,
"ImR Activator: Killing server <%s> "
"signal %d to pid %d, result = %d\n",
name, signum, pid, result));
if (!found && result == 0 && this->notify_imr_)
{
this->process_map_.bind (pid, name);
#if (ACE_SIZEOF_VOID_P == 8)
ACE_INT64 token = static_cast<ACE_INT64>(pid);
#else
ACE_INT32 token = static_cast<ACE_INT32>(pid);
#endif
ACE_Reactor *r = this->orb_->orb_core()->reactor();
r->schedule_timer (this, reinterpret_cast<void *>(token), ACE_Time_Value ());
}
}
return result == 0;
}
int
Heartbeat_Application::register_for_timeouts (void)
{
// Schedule timeout every 0.5 seconds, for sending heartbeat events.
ACE_Time_Value timeout_interval (0, 500000);
ACE_Reactor *reactor = this->orb_->orb_core ()->reactor ();
if (!reactor
|| reactor->schedule_timer (&this->timeout_handler_, 0,
timeout_interval,
timeout_interval) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Heartbeat_Application::register_for_timeouts - "
"cannot schedule timer\n"),
-1);
}
return 0;
}
int
TAO_Acceptor::handle_accept_error (ACE_Event_Handler* base_acceptor)
{
if (errno == EMFILE || errno == ENFILE)
{
if (TAO_debug_level > 0)
TAOLIB_DEBUG ((LM_DEBUG, "TAO (%P|%t) - "
"TAO_Acceptor::handle_accept_error - "
"Too many files open\n"));
// If the user has decided to stop accepting when the file handles
// run out, just return -1;
if (this->error_retry_delay_ == 0)
return -1;
// Get the reactor. If there isn't one, which isn't very likely,
// then just return -1.
ACE_Reactor* reactor = base_acceptor->reactor ();
if (reactor == 0)
return -1;
// So that the reactor doesn't completely remove this handler from
// the reactor, register it with the except mask. It should be
// removed in the timer handler.
reactor->register_handler (base_acceptor,
ACE_Event_Handler::EXCEPT_MASK);
// Remove the handler so that the reactor doesn't attempt to
// process this handle again (and tightly spin).
reactor->remove_handler (base_acceptor,
ACE_Event_Handler::ACCEPT_MASK |
ACE_Event_Handler::DONT_CALL);
// Schedule a timer so that we can resume the handler in hopes
// that some file handles have freed up.
ACE_Time_Value timeout (this->error_retry_delay_);
reactor->schedule_timer (base_acceptor, 0, timeout);
}
// We want to keep accepting in all other situations.
return 0;
}
static void
run_svc (ACE_HANDLE handle)
{
// The <callback> object is an <ACE_Event_Handler> created on the
// stack. This is normally not a good idea, but in this case it
// works because the ACE_Reactor is destroyed before leaving this
// scope as well, so it'll remove the <callback> object from its
// internal tables BEFORE it is destroyed.
Ping_Pong callback (string_name, handle);
// Note that we put the <reactor> AFTER the <callback> so that the
// <reactor> will get shutdown first.
ACE_Reactor reactor;
// Register the callback object for the various I/O, signal, and
// timer-based events.
if (reactor.register_handler (&callback,
ACE_Event_Handler::READ_MASK
| ACE_Event_Handler::WRITE_MASK) == -1
#if !defined (CHORUS)
|| reactor.register_handler (SIGINT,
&callback) == -1
#endif /* CHORUS */
|| reactor.schedule_timer (&callback,
0,
SHUTDOWN_TIME) == -1)
{
ACE_ERROR ((LM_ERROR,
"%p\n",
"reactor"));
ACE_OS::exit (1);
}
// Main event loop (one per process).
while (callback.is_set () == 0)
if (reactor.handle_events () == -1)
ACE_ERROR ((LM_ERROR,
"%p\n",
"handle_events"));
}
int main (int, char* [])
{
ACE_Reactor reactor;
Time_Handler* th = new Time_Handler;
int timer_id[NUMBER_TIMERS];
for (int i = 0; i < NUMBER_TIMERS; i++)
{
timer_id[i] = reactor.schedule_timer(th,
(const void *)i, // argument sent to handle_timeout()
ACE_Time_Value(2 * i + 1)); //set timer to go off with delay
}
//Cancel the fifth timer before it goes off
reactor.cancel_timer(timer_id[5]);//Timer ID of timer to be removed
while (!done)
{
reactor.handle_events();
}
return 0;
}
int HandlersRegister::scheduleTimers (const ACE_Time_Value &p_TestTime)
{
int i;
for (i = 0; i < HandlersNo; ++i)
{
if (-1 == reactor_->schedule_timer (DgramHandlers_[ i ],
(const void *) 0,
ACE_Time_Value::zero,
p_TestTime * (0.5 / DgramsToSend)))
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT (" (%P) %p\n"),
ACE_TEXT ("Cannot schedule ACE timer")),
-1);
DgramHandlers_[ i ] ->expectedTriggers (DgramsToSend);
}
return 0;
}
static void
run_svc (ACE_HANDLE handle)
{
Ping_Pong *callback = 0;
ACE_NEW (callback,
Ping_Pong (ACE_TEXT_ALWAYS_CHAR (string_name),
handle));
ACE_Reactor reactor;
// Register the callback object for the various I/O, signal, and
// timer-based events.
if (reactor.register_handler (callback,
ACE_Event_Handler::READ_MASK
| ACE_Event_Handler::WRITE_MASK) == -1
#if !defined (CHORUS)
|| reactor.register_handler (SIGINT,
callback) == -1
#endif /* CHORUS */
|| reactor.schedule_timer (callback,
0,
SHUTDOWN_TIME) == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("reactor")));
ACE_OS::exit (1);
}
// Main event loop (one per process).
while (callback->is_set () == 0)
if (reactor.handle_events () == -1)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("handle_events")));
}
// implement state machine, send, wait (timeout/results) return
int transaction::run(transaction_result * r)
{
result_ = r;
int rc;
// 1. register io port for read access
ACE_Reactor * reactor = ACE_Reactor::instance();
if (reactor->register_handler(session_.get_handle(),
this,
READ_MASK) == -1)
return SNMP_CLASS_INTERNAL_ERROR;
retry_counter_ = 0;
// register a time handler and a socket with this
ACE_Time_Value to = params_.get_timeout();
if (reactor->schedule_timer(this, 0, to, to) < 0)
return SNMP_CLASS_INTERNAL_ERROR;
if ((rc = send()) < 0) // send pkt to agent
return rc;
return 0;
}
char *
Simple_Server_i::test_method (Simple_Server_ptr objref)
{
ACE_DEBUG ((LM_DEBUG, "(%P|%t) test_method called\n"));
if (CORBA::is_nil (objref))
{
ACE_ERROR ((LM_ERROR, "Nil object reference!\n"));
}
else
{
try
{
{
ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, 0);
if (!this->timer_registed_)
{
ACE_DEBUG ((LM_DEBUG, "(%P|%t) Scheduling timeout...\n"));
ACE_Time_Value timeout (2, 0);
ACE_Reactor * reactor = this->orb_->orb_core ()->reactor ();
reactor->schedule_timer (this, (void*)0, timeout);
this->timer_registed_ = true;
}
}
ACE_DEBUG ((LM_DEBUG, "(%P|%t) Calling test_method() on client, "
"which will sleep for 3 seconds\n"));
CORBA::String_var str = objref->test_method (_this());
ACE_DEBUG ((LM_DEBUG, "(%P|%t) Received \"%C\"\n", str.in ()));
}
catch (...)
{
ACE_ERROR ((LM_ERROR, "(%P|%t) Caught exception\n"));
}
}
ACE_DEBUG ((LM_DEBUG, "(%P|%t) leaving test_method\n"));
return CORBA::string_dup("Hello world");
}
int
run_main (int, ACE_TCHAR *[])
{
ACE_START_TEST (ACE_TEXT ("MT_Reactor_Timer_Test"));
int status = 0;
int test_result = 0;
ACE_Reactor *r = ACE_Reactor::instance ();
Dispatch_Count_Handler callback;
for (int i = ACE_MAX_TIMERS; i > 0; i--)
// Schedule a timeout to expire immediately.
if (r->schedule_timer (&callback,
reinterpret_cast <const void *> (static_cast <size_t> (i)),
ACE_Time_Value (0)) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("schedule_timer")),
1);
ACE_Time_Value no_waiting (0);
size_t events = 0;
while (1)
{
int result = r->handle_events (no_waiting);
// Timeout.
if (result == 0)
break;
// Make sure there were no errors.
ACE_TEST_ASSERT (result != -1);
events += result;
}
// All <ACE_MAX_TIMERS> + 2 I/O dispatches (one for <handle_input>
// and the other for <handle_exception>) should be counted in
// events.
if (events < ACE_MAX_TIMERS + 2)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("expected %d events, got %d instead\n"),
ACE_MAX_TIMERS + 2,
events));
}
status = callback.verify_results ();
if (status != 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Dispatch counting test failed.\n")));
test_result = 1;
}
#if defined (ACE_HAS_THREADS)
Time_Handler other_thread;
ACE_Time_Value time_limit (30);
// Set up initial set of timers.
other_thread.setup ();
other_thread.activate (THR_NEW_LWP | THR_JOINABLE);
status = ACE_Reactor::instance()->run_reactor_event_loop (time_limit);
// Should have returned only because the time limit is up...
ACE_TEST_ASSERT (status != -1);
ACE_TEST_ASSERT (time_limit.sec () == 0);
status = other_thread.wait ();
if (status == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p, errno is %d\n"),
"wait ()",
ACE_ERRNO_GET));
ACE_TEST_ASSERT (status != -1);
}
status = other_thread.verify_results ();
if (status != 0)
test_result = 1;
#else
ACE_ERROR ((LM_INFO,
ACE_TEXT ("threads not supported on this platform\n")));
#endif /* ACE_HAS_THREADS */
ACE_END_TEST;
return test_result;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
CORBA::Object_var object =
orb->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
if (CORBA::is_nil (policy_current.in ()))
{
ACE_ERROR ((LM_ERROR, "ERROR: Nil policy current\n"));
return 1;
}
CORBA::Any scope_as_any;
scope_as_any <<= Messaging::SYNC_WITH_SERVER;
CORBA::PolicyList policies(1); policies.length (1);
policies[0] =
orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
scope_as_any);
policy_current->set_policy_overrides (policies,
CORBA::ADD_OVERRIDE);
policies[0]->destroy ();
seed = (unsigned int) ACE_OS::gethrtime ();
if (parse_args (argc, argv) != 0)
return 1;
ACE_DEBUG ((LM_DEBUG, "SEED = %u\n", seed));
Server_Peer *impl;
ACE_NEW_RETURN (impl,
Server_Peer (seed, orb.in (), payload_size),
1);
PortableServer::ServantBase_var owner_transfer(impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (impl);
CORBA::Object_var object_act = root_poa->id_to_reference (id.in ());
Test::Peer_var peer =
Test::Peer::_narrow (object_act.in ());
CORBA::String_var ior =
orb->object_to_string (peer.in ());
// If the ior_output_file exists, output the ior to it
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
poa_manager->activate ();
Sleeper sleeper (orb.in ());
ACE_Time_Value interval(0, 500000);
ACE_Reactor * reactor = orb->orb_core()->reactor();
reactor->schedule_timer(&sleeper, 0, interval, interval);
// ACE_Time_Value run_time(600, 0);
// orb->run (run_time);
orb->run ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
bool TestHandler::trigger_in(const ACE_Time_Value &delay)
{
ACE_DEBUG ((LM_DEBUG, "(%P|%t) TestHandler::trigger_in - scheduling timer\n"));
return -1 != reactor_->schedule_timer (this, 0, delay, ACE_Time_Value (0));
}
static bool
test_reactor_dispatch_order (ACE_Reactor &reactor)
{
Handler handler (reactor);
if (!handler.ok_)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Error initializing test; abort.\n")));
return false;
}
bool ok_to_go = true;
// This should trigger a call to <handle_input>.
ssize_t result =
ACE::send_n (handler.pipe_.write_handle (),
message,
ACE_OS::strlen (message));
if (result != ssize_t (ACE_OS::strlen (message)))
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Handler sent %b bytes; should be %B\n"),
result, ACE_OS::strlen (message)));
ok_to_go = false;
}
// This should trigger a call to <handle_timeout>.
if (-1 == reactor.schedule_timer (&handler,
0,
ACE_Time_Value (0)))
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("schedule_timer")));
ok_to_go = false;
}
// Suspend the handlers - only the timer should be dispatched
ACE_Time_Value tv (1);
reactor.suspend_handlers ();
reactor.run_reactor_event_loop (tv);
// only the timer should have fired
if (handler.dispatch_order_ != 2)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Incorrect number fired %d\n"),
handler.dispatch_order_));
ok_to_go = false;
}
// Reset the dispatch_order_ count and schedule another timer
handler.dispatch_order_ = 1;
if (-1 == reactor.schedule_timer (&handler,
0,
ACE_Time_Value (0)))
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("schedule_timer")));
ok_to_go = false;
}
// Resume the handlers - things should work now
reactor.resume_handlers ();
if (ok_to_go)
{
reactor.run_reactor_event_loop (tv);
}
if (0 != reactor.remove_handler (handler.pipe_.read_handle (),
ACE_Event_Handler::ALL_EVENTS_MASK |
ACE_Event_Handler::DONT_CALL))
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("remover_handler pipe")));
if (handler.dispatch_order_ != 4)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Incorrect number fired %d\n"),
handler.dispatch_order_));
ok_to_go = false;
}
return ok_to_go;
}
int ManageClientValidation::svc(void)
{
FUNCTIONTRACE(ManageClientValidation::svc);
REPORT_THREAD_INFO("ManageClientValidation::svc", ACE_OS::thr_self());
ACE_Reactor * reactor = NULL;
while (!m_stop)
{
#ifdef WIN32
reactor = new ACE_Reactor(new ACE_Select_Reactor(), true);
#else
reactor = new ACE_Reactor(new ACE_Dev_Poll_Reactor(), true);
#endif
LoginAcceptor login_acceptor;
ACE_INET_Addr port_to_listen(sMsgCfg->getLSCfg().listen_port, sMsgCfg->getLSCfg().host.c_str());
if (login_acceptor.open(port_to_listen, reactor) == -1)
{
GATE_LOG_ERROR(ACE_TEXT("Failed to call login_acceptor.open, host is <%s>, the port is <%d>, last error is <%d>\n"), sMsgCfg->getClientCfg().host.c_str(), sMsgCfg->getClientCfg().listen_port, ACE_OS::last_error());
return 1;
}
ReportTrafficToLoginServer report_traffic;
m_timer_id = reactor->schedule_timer(this, NULL, ACE_Time_Value(3, 0), ACE_Time_Value(3, 0));
if (m_timer_id == -1)
{
GATE_LOG_ERROR(ACE_TEXT("Failed to schedule timer in ManageClientValidation::svc, last error is <%d>\n"), ACE_OS::last_error());
return 1;
}
//m_report_traffic_timer_id = reactor->schedule_timer(&report_traffic, NULL, ACE_Time_Value(sMsgCfg->getLSCfg().report_interval), ACE_Time_Value(sMsgCfg->getLSCfg().report_interval));
//if (m_report_traffic_timer_id == -1)
//{
// GATELogp(LM_ERROR, ACE_TEXT("Failed to schedule timer in ManageClientValidation::svc for report traffic, last error is <%d>\n"), ACE_OS::last_error());
// return 1;
//}
//reactor->run_reactor_event_loop();
while (true)
{
reactor->run_reactor_event_loop();
#ifdef WIN32
break;
#else
if (ACE_OS::last_error() == EINTR)
{
continue;
}
else
{
break;
}
#endif
}
GATE_LOG_INFO(ACE_TEXT("Exit thread ManageClientValidation::svc, last error is <%d>\n"), ACE_OS::last_error());
}
delete reactor;
m_wait = false;
return 0;
}
int
Time_Handler::svc (void)
{
ACE_Reactor *r = ACE_Reactor::instance ();
ACE_ASSERT (r->cancel_timer (this->timer_id_[2]) == 1);
this->timer_id_[2] = Time_Handler::TIMER_CANCELLED;
this->timer_id_[1] = r->schedule_timer(this,
(const void *) 1,
ACE_Time_Value (2));
// This one may get the callback before we return, so serialize.
this->lock_.acquire ();
this->timer_id_[0] = r->schedule_timer(this,
(const void *) 0,
ACE_Time_Value (0, -5));
this->lock_.release ();
ACE_OS::sleep(3);
this->timer_id_[5] = r->schedule_timer(this,
(const void *)5,
ACE_Time_Value (10));
this->timer_id_[6] = r->schedule_timer(this,
(const void *)6,
ACE_Time_Value (12));
ACE_ASSERT (r->cancel_timer (this->timer_id_[4]) == 1);
this->timer_id_[4] = Time_Handler::TIMER_CANCELLED;
return 0;
}
