int
main (int, char *[])
{
// Instantiate a server which will receive messages for DURATION
// seconds.
Server_Events server_events (UDP_PORT,
MCAST_ADDR,
DURATION);
// Instance of the ACE_Reactor.
ACE_Reactor reactor;
if (reactor.register_handler (&server_events,
ACE_Event_Handler::READ_MASK) == -1)
ACE_ERROR ((LM_ERROR,
"%p\n%a",
"register_handler",
1));
ACE_DEBUG ((LM_DEBUG,
"starting up server\n"));
for (;;)
reactor.handle_events (server_events.wait_time ());
ACE_NOTREACHED (return 0;)
}
int
ACE_Process_Manager::append_proc (ACE_Process *proc)
{
ACE_TRACE ("ACE_Process_Manager::append_proc");
// Try to resize the array to twice its existing size if we run out
// of space...
if (this->current_count_ >= this->max_process_table_size_
&& this->resize (this->max_process_table_size_ * 2) == -1)
return -1;
else
{
ACE_Process_Descriptor &proc_desc =
this->process_table_[this->current_count_];
proc_desc.process_ = proc;
proc_desc.exit_notify_ = 0;
#if defined (ACE_WIN32)
// If we have a Reactor, then we're supposed to reap Processes
// automagically. Get a handle to this new Process and tell the
// Reactor we're interested in <handling_input> on it.
ACE_Reactor *r = this->reactor ();
if (r != 0)
r->register_handler (this,
proc->gethandle ());
#endif /* ACE_WIN32 */
this->current_count_++;
return 0;
}
}
Handle_Events::Handle_Events (u_short udp_port,
const char *ip_addr,
const char *interface,
ACE_Reactor &reactor)
{
// Create multicast address to listen on.
ACE_INET_Addr sockmc_addr (udp_port, ip_addr);
// subscribe to multicast group.
if (this->mcast_.subscribe (sockmc_addr, 1, interface) == -1)
ACE_OS::perror ("can't subscribe to multicast group"), ACE_OS::exit (1);
// Disable loopbacks.
// if (this->mcast_.set_option (IP_MULTICAST_LOOP, 0) == -1 )
// ACE_OS::perror (" can't disable loopbacks " ), ACE_OS::exit (1);
if (!QUIET) {
this->handle_set_.set_bit (0);
}
this->handle_set_.set_bit (this->mcast_.get_handle ());
// Register callbacks with the ACE_Reactor.
if (reactor.register_handler (this->handle_set_,
this,
ACE_Event_Handler::READ_MASK) == -1)
ACE_OS::perror ("can't register events"), ACE_OS::exit (1);
}
Dispatch_Count_Handler::Dispatch_Count_Handler (void)
{
ACE_Reactor *r = ACE_Reactor::instance ();
this->input_seen_ = this->notify_seen_ = 0;
this->timers_fired_ = 0;
// Initialize the pipe.
if (this->pipe_.open () == -1)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("ACE_Pipe::open")));
// Register the "read" end of the pipe.
else if (r->register_handler (this->pipe_.read_handle (),
this,
ACE_Event_Handler::READ_MASK) == -1)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("register_handler")));
// Put something in our pipe and smoke it... ;-)
else if (ACE::send (this->pipe_.write_handle (),
"z",
1) == -1)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("send")));
// Call notify to prime the pump for this, as well.
else if (r->notify (this) == -1)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("notify")));
}
int
Server_i::enable_multicast (const char *ior)
{
if (this->parse_args (this->argc_, this->argv_) != 0)
return -1;
// Get reactor instance from TAO.
ACE_Reactor *reactor =
this->orb_->orb_core ()->reactor ();
// Instantiate a handler which will handle client requests for the
// bootstrappable service, received on the multicast port.
ACE_NEW_RETURN (this->ior_multicast_,
TAO_IOR_Multicast (),
-1);
if (this->ior_multicast_->init (ior,
this->mcast_address_.in (),
TAO_SERVICEID_MCASTSERVER) == -1)
return -1;
// Register event handler for the ior multicast.
if (reactor->register_handler (this->ior_multicast_,
ACE_Event_Handler::READ_MASK) == -1)
{
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
"MCast_Server: cannot register Event handler\n"));
return -1;
}
return 0;
}
Sig_Handler_1 (ACE_Reactor &reactor, const char *msg)
: msg_ (msg),
count_ (0),
reactor_ (reactor)
{
// Register the signal handlers.
this->quit_sigkey_ =
reactor.register_handler (SIGQUIT, this);
this->int_sigkey_ =
reactor.register_handler (SIGINT, this);
if (this->quit_sigkey_ == -1 || this->int_sigkey_ == -1)
ACE_ERROR ((LM_ERROR,
"%p\n",
"register_handler"));
}
int HandlersRegister::registerDgramHandlers ()
{
int i;
// open dgram handlers for all ports
for (i = 0; i < HandlersNo; ++i)
if (-1 == DgramHandlers_[ i ]->open (
ACE_INET_Addr (i + BaseDgramPort,
ACE_TEXT ("127.0.0.1"),
ACE_PROTOCOL_FAMILY_INET)))
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT (" (%P) %p\n"),
ACE_TEXT ("Cannot open dgram handler")),
-1);
// register dgram handlers
for (i = 0; i < HandlersNo; ++i)
if (-1 == reactor_->register_handler (DgramHandlers_[ i ],
ACE_Event_Handler::READ_MASK))
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT (" (%P) %p\n"),
ACE_TEXT ("Cannot register dgram handler")),
-1);
return 0;
}
int MyTask::svc()
{
ACE_DEBUG ((LM_INFO, ACE_TEXT ("(%t) enter MyTask::svc()\n\n")));
//initialization
selector = new ACE_Select_Reactor;
ACE_Reactor* reactor = new ACE_Reactor(selector);
ACE_Reactor::instance(reactor); //then, ACE_Reactor::instance() is reactor
this->reactor(reactor); //this reactor_ of ACE_Event_Handler can not be set
//register socket handler
Handler handler(UDP_PORT);
if (reactor->register_handler(&handler, ACE_Event_Handler::READ_MASK) == -1)
{
ACE_ERROR((LM_ERROR, "%p\n", "cant't register with Reactor in MyTask::svc()\n"));
return -1;
}
//spawn mytask2
mytask2::instance()->open(&handler);
//handle_events in forever-loop until receive two data packets from socket, then, it will notify the MY_EXIT_HANDLER
while (exit_flag == 0)
{
int result = reactor->handle_events(); //timeout will not occur at all
if (result)
{
ACE_DEBUG ((LM_INFO, ACE_TEXT ("(%t) handle_events() succeed, result = %d\n\n"), result));
if (RECV_COUNT == handler.get_count())
{
ACE_DEBUG ((LM_INFO, ACE_TEXT ("(%t) MyTask::svc() notify the exit handler\n")));
ACE_Reactor::instance()->notify(&handler, ACE_Event_Handler::EXCEPT_MASK);
}
if (handler.get_flag())
exit_flag = 1;
}
else
{
ACE_ERROR((LM_ERROR, "%p\n", "handle_events() failed\n"));
return -1;
}
}
if (reactor->remove_handler(&handler, ACE_Event_Handler::READ_MASK |
ACE_Event_Handler::DONT_CALL) == -1)
{
ACE_ERROR((LM_ERROR, "%p\n", "cant't remove handler from Reactor\n"));
return -1;
}
delete reactor;
reactor = NULL;
ACE_DEBUG ((LM_INFO, ACE_TEXT ("(%t) exit MyTask::svc()\n\n")));
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
ACE_TMAIN (int, ACE_TCHAR *[])
{
int result = reactor.register_handler (&simple_handler,
simple_handler.event1_.handle ());
ACE_ASSERT (result == 0);
result = reactor.register_handler (&simple_handler,
simple_handler.event2_.handle ());
ACE_ASSERT (result == 0);
result = ACE_OS::thr_create ((ACE_THR_FUNC) worker, 0, 0, 0);
ACE_ASSERT (result == 0);
result = 0;
while (!stop_test && result != -1)
{
result = reactor.handle_events ();
}
return 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;
}
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")));
}
int
RtpsUdpReceiveStrategy::start_i()
{
ACE_Reactor* reactor = link_->get_reactor();
if (reactor == 0) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: ")
ACE_TEXT("RtpsUdpReceiveStrategy::start_i: ")
ACE_TEXT("NULL reactor reference!\n")),
-1);
}
if (reactor->register_handler(link_->unicast_socket().get_handle(), this,
ACE_Event_Handler::READ_MASK) != 0) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: ")
ACE_TEXT("RtpsUdpReceiveStrategy::start_i: ")
ACE_TEXT("failed to register handler for unicast ")
ACE_TEXT("socket %d\n"),
link_->unicast_socket().get_handle()),
-1);
}
if (link_->config()->use_multicast_) {
if (reactor->register_handler(link_->multicast_socket().get_handle(), this,
ACE_Event_Handler::READ_MASK) != 0) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: ")
ACE_TEXT("RtpsUdpReceiveStrategy::start_i: ")
ACE_TEXT("failed to register handler for multicast\n")),
-1);
}
}
return 0;
}
int
Receiver::open (void *)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
ACE_Reactor *TPReactor = ACE_Reactor::instance ();
this->reactor (TPReactor);
flg_mask_ = ACE_Event_Handler::NULL_MASK ;
if (TPReactor->register_handler (this, flg_mask_) == -1)
return -1;
initiate_io (ACE_Event_Handler::READ_MASK);
return check_destroy ();
}
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;
}
int Sender::open (void *)
{
ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, locker, this->mutex_, -1);
ACE_Reactor * TPReactor = ACE_Reactor::instance ();
this->reactor (TPReactor);
flg_mask_ = ACE_Event_Handler::NULL_MASK ;
if (TPReactor->register_handler (this,flg_mask_) == -1)
return -1;
if (this->initiate_write () == -1)
return -1;
if (duplex != 0)
initiate_io (ACE_Event_Handler::READ_MASK);
return check_destroy ();
}
int
UdpReceiveStrategy::start_i()
{
ACE_Reactor* reactor = this->link_->get_reactor();
if (reactor == 0) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: ")
ACE_TEXT("UdpReceiveStrategy::start_i: ")
ACE_TEXT("NULL reactor reference!\n")),
-1);
}
if (reactor->register_handler(this, ACE_Event_Handler::READ_MASK) != 0) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: ")
ACE_TEXT("UdpReceiveStrategy::start_i: ")
ACE_TEXT("failed to register handler for DataLink!\n")),
-1);
}
return 0;
}
// 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;
}
int agent_impl::process_requests()
{
ACE_TRACE("agent_impl::process_requests");
ACE_Reactor reactor;
ACE_Sig_Action sa ((ACE_SignalHandler) sig_handler, SIGINT);
ACE_UNUSED_ARG (sa);
// Read data from other side.
if (reactor.register_handler (this, ACE_Event_Handler::READ_MASK) == -1)
ACE_ERROR_RETURN ((LM_ERROR, "ACE_Reactor::register_handler"), -1);
// TODO: register signal handler to shut down gracefully here
while (!finished)
{
reactor.handle_events ();
ACE_DEBUG ((LM_DEBUG, "return from handle events\n"));
}
ACE_DEBUG ((LM_DEBUG, "return from handle events - normal shut down\n"));
return 0;
}
int
TAO_Acceptor::handle_expiration (ACE_Event_Handler* base_acceptor)
{
// 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;
if (TAO_debug_level > 0)
TAOLIB_DEBUG ((LM_DEBUG, "TAO (%P|%t) - "
"TAO_Acceptor::handle_expiration - "
"Re-registering the acceptor\n"));
// Try again to allow incoming connections
reactor->register_handler (base_acceptor, ACE_Event_Handler::ACCEPT_MASK);
// Remove the except mask that was added during the handling of the
// accept() error. That is the only reason that we're in this method
// in the first place.
reactor->remove_handler (base_acceptor, ACE_Event_Handler::EXCEPT_MASK |
ACE_Event_Handler::DONT_CALL);
return 0;
}
// implement state machine, send, wait (timeout/results) return
int transaction::run()
{
int rc, done = 0;
int retry_counter = 0;
ACE_Time_Value to(params_.get_timeout(), 0); // seconds
ACE_Reactor *reactor = ACE_Reactor::instance ();
// 1. register io port for read access
if (reactor->register_handler(session_.get_handle(), this,
ACE_Event_Handler::READ_MASK) == -1)
return SNMP_CLASS_INTERNAL_ERROR;
// register a time handler and a socket with this
while (!done) {
if ((rc = send()) < 0) // send pkt to agent
return rc;
else {
if (retry_counter++ > params_.get_retry())
return SNMP_CLASS_TIMEOUT;
}
// 2. wait for events (timeout, returned msg)
if (( rc = reactor->handle_events (to)) == 1) // one handler registered
return 0;
else {
if (rc == 0) {
to.set(params_.get_timeout(), 0);
}
else
return SNMP_CLASS_INTERNAL_ERROR;
}
}
return SNMP_CLASS_INTERNAL_ERROR;
}
int main(int argc, char *argv[])
{
int rc = 0;
bool first = true;
ImageVector v;
Client client(argc, argv);
if ((rc = parseArgs(argc, argv)))
return rc;
try {
// event handler
Event * event = new Event();
// Signal set to be handled by the event handler.
ACE_Sig_Set sig;
// register Signal handler for Ctr+C
sig.sig_add(SIGINT);
sig.sig_add(SIGTERM);
// Reactor, misused as signal handler
ACE_Reactor reactor;
if (reactor.register_handler(sig, event) == -1) {
throw Miro::ACE_Exception(errno, "failed to register signal handler");
}
// get reference to video service
Video_var video = client.resolveName<Video>(interfaceName.c_str());
Miro::VideoConnection connection(video.in());
ACE_Time_Value start;
while(!canceled) {
// wait for key
if (first || !streaming) {
first = false;
cout << "Press key to grab next image: " << flush;
getchar();
start = ACE_OS::gettimeofday();
}
// init streaming timer
if (!first && streaming) {
ACE_Time_Value elapsed = ACE_OS::gettimeofday();
elapsed -= start;
if (elapsed.msec() > stop)
break;
}
{
// get image
Miro::VideoAcquireImage
frame(connection,
(interval)?
Miro::VideoAcquireImage::Current :
Miro::VideoAcquireImage::Next);
// fill image structure
Image image;
image.fileName = path() + client.namingContextName + "_" + Miro::timeString() + ".ppm";
image.width = connection.handle->format.width;
image.height = connection.handle->format.height;
// fill image buffer
if (!bgr && !streaming)
image.buffer = (char*) frame.buffer;
else {
image.buffer = new char[3 * image.width * image.height];
// byte swapping
if (bgr) {
int offset = 0;
for (int i = 0; i < image.width; ++i) {
for (int j = 0; j < image.height; ++j, offset += 3) {
image.buffer[offset + 0] = frame.buffer[offset + 2]; // r
image.buffer[offset + 1] = frame.buffer[offset + 1]; // g
image.buffer[offset + 2] = frame.buffer[offset + 0]; // b
}
}
}
else
memcpy(image.buffer, frame.buffer, 3 * image.width * image.height);
}
// save image
if (!streaming) {
image.writePpm();
if (bgr)
delete[] image.buffer;
}
else
v.push_back(image);
}
// sleep
if (interval) {
ACE_Time_Value delta;
delta.msec(interval);
ACE_OS::sleep(delta);
}
}
cout << "exiting on signal" << endl;
for (ImageVector::const_iterator i = v.begin(); i != v.end(); ++i) {
i->writePpm();
delete i->buffer;
}
}
catch (const Miro::ETimeOut& e) {
cerr << "Miro Timeout Exception: " << e << endl;
rc = 1;
}
catch (const Miro::EDevIO & e) {
cerr << "Miro Device I/O exception: " << e << endl;
rc = 1;
}
catch (const Miro::EOutOfBounds & e) {
cerr << "Miro out of bounds exception: " << e << endl;
rc = 1;
}
catch (const CORBA::Exception & e) {
cerr << "Uncaught CORBA exception: " << e << endl;
rc = 1;
}
return rc;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
if (parse_args (argc, argv) == -1)
return -1;
ACE_Select_Reactor sr;
ACE_Reactor reac (&sr);
ACE_Reactor::instance (&reac);
ACE_SOCK_Stream stream[iter];
ACE_SOCK_Connector connector[iter];
Purging_Handler ph[iter];
ACE_INET_Addr addr (port,
host);
ACE_Reactor *singleton =
ACE_Reactor::instance ();
for (int i = 0; i != iter; ++i)
{
if (connector[i].connect (stream[i],
addr) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"Error while connecting: %p\n",
"client"),
-1);
if (stream[i].get_handle () == ACE_INVALID_HANDLE)
ACE_ERROR_RETURN ((LM_ERROR,
"Got invalid handles after connecting the [%d] time\n",i),
-1);
if (singleton->register_handler (stream[i].get_handle (),
&ph[i],
ACE_Event_Handler::READ_MASK) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"Registration failed\n"),
-1);
// ACE_Time_Value tv (1);
// while (singleton->handle_events (&tv) >= 1);
}
// Handle events moved to here to prevent this test taking best part
// of a minute
ACE_Time_Value tv (3);
while (singleton->handle_events (&tv) >= 1)
{
// No action.
}
// Remove the handlers to avoid the possibility of the reactor
// using any of them after they leave the scope (those that haven't
// been closed and removed already, that is).
for (int j = 0; j != iter; ++j)
{
singleton->remove_handler (stream[j].get_handle (),
ACE_Event_Handler::READ_MASK);
}
if ((iter - purged_handles) > 20)
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Purging hasnt worked at all\n"),
-1);
return 0;
}
int
TAO_Naming_Server::init_new_naming (CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
const ACE_TCHAR *persistence_location,
void *base_addr,
size_t context_size,
int enable_multicast,
int use_storable_context,
int round_trip_timeout,
int use_round_trip_timeout)
{
try
{
#if defined (CORBA_E_MICRO)
ACE_UNUSED_ARG (persistence_location);
ACE_UNUSED_ARG (base_addr);
ACE_UNUSED_ARG (use_storable_context);
#else
if (use_storable_context)
{
// In lieu of a fully implemented service configurator version
// of this Reader and Writer, let's just take something off the
// command line for now.
TAO::Storable_Factory* pf = 0;
ACE_CString directory (ACE_TEXT_ALWAYS_CHAR (persistence_location));
ACE_NEW_RETURN (pf, TAO::Storable_FlatFileFactory (directory), -1);
auto_ptr<TAO::Storable_Factory> persFactory(pf);
// Use an auto_ptr to ensure that we clean up the factory in the case
// of a failure in creating and registering the Activator.
TAO_Storable_Naming_Context_Factory* cf =
this->storable_naming_context_factory (context_size);
// Make sure we got a factory
if (cf == 0) return -1;
auto_ptr<TAO_Storable_Naming_Context_Factory> contextFactory (cf);
// This instance will either get deleted after recreate all or,
// in the case of a servant activator's use, on destruction of the
// activator.
// Was a location specified?
if (persistence_location == 0)
{
// No, assign the default location "NameService"
persistence_location = ACE_TEXT ("NameService");
}
// Now make sure this directory exists
if (ACE_OS::access (persistence_location, W_OK|X_OK))
{
ORBSVCS_ERROR_RETURN ((LM_ERROR, "Invalid persistence directory\n"), -1);
}
#if (TAO_HAS_MINIMUM_POA == 0) && !defined (CORBA_E_COMPACT)
if (this->use_servant_activator_)
{
ACE_NEW_THROW_EX (this->servant_activator_,
TAO_Storable_Naming_Context_Activator (orb,
persFactory.get(),
contextFactory.get (),
persistence_location),
CORBA::NO_MEMORY ());
this->ns_poa_->set_servant_manager(this->servant_activator_);
}
#endif /* TAO_HAS_MINIMUM_POA */
try { // The following might throw an exception.
this->naming_context_ =
TAO_Storable_Naming_Context::recreate_all (orb,
poa,
TAO_ROOT_NAMING_CONTEXT,
context_size,
0,
contextFactory.get (),
persFactory.get (),
use_redundancy_);
}
catch (const CORBA::Exception& ex)
{
// The activator already took over the factories so we need to release the auto_ptr
if (this->use_servant_activator_)
{
// The context factory is now owned by the activator
// so we should release it
contextFactory.release ();
// If using a servant activator, the activator now owns the
// factory, so we should release it
persFactory.release ();
}
// Print out the exception and return failure
ex._tao_print_exception (
"TAO_Naming_Server::init_new_naming");
return -1;
}
// Kind of a duplicate of the above here, but we must also release the
// factory autoptrs in the good case as well.
if (this->use_servant_activator_)
{
// The context factory is now owned by the activator
// so we should release it
contextFactory.release ();
// If using a servant activator, the activator now owns the
// factory, so we should release it
persFactory.release ();
}
}
else if (persistence_location != 0)
//
// Initialize Persistent Naming Service.
//
{
// Create Naming Context Implementation Factory to be used for the creation of
// naming contexts by the TAO_Persistent_Context_Index
TAO_Persistent_Naming_Context_Factory *naming_context_factory =
this->persistent_naming_context_factory ();
// Make sure we got a factory.
if (naming_context_factory == 0) return -1;
// Allocate and initialize Persistent Context Index.
ACE_NEW_RETURN (this->context_index_,
TAO_Persistent_Context_Index (orb, poa, naming_context_factory),
-1);
if (this->context_index_->open (persistence_location,
base_addr) == -1
|| this->context_index_->init (context_size) == -1)
{
if (TAO_debug_level >0)
ORBSVCS_DEBUG ((LM_DEBUG,
"TAO_Naming_Server: context_index initialization failed\n"));
return -1;
}
// Set the root Naming Context reference.
this->naming_context_ =
this->context_index_->root_context ();
}
else
#endif /* CORBA_E_MICRO */
{
//
// Initialize Transient Naming Service.
//
this->naming_context_ =
TAO_Transient_Naming_Context::make_new_context (poa,
TAO_ROOT_NAMING_CONTEXT,
context_size);
}
#if !defined (CORBA_E_MICRO)
// Register with the ORB's resolve_initial_references()
// mechanism. Primarily useful for dynamically loaded Name
// Services.
orb->register_initial_reference ("NameService",
this->naming_context_.in ());
#endif /* CORBA_E_MICRO */
// Set the ior of the root Naming Context.
this->naming_service_ior_=
orb->object_to_string (this->naming_context_.in ());
CORBA::Object_var table_object =
orb->resolve_initial_references ("IORTable");
IORTable::Table_var adapter =
IORTable::Table::_narrow (table_object.in ());
if (CORBA::is_nil (adapter.in ()))
{
ORBSVCS_ERROR ((LM_ERROR, "Nil IORTable\n"));
}
else
{
CORBA::String_var ior =
orb->object_to_string (this->naming_context_.in ());
adapter->bind ("NameService", ior.in ());
}
#if defined (ACE_HAS_IP_MULTICAST)
if (enable_multicast)
{
// @@ Marina: is there anyway to implement this stuff
// without using ORB_Core_instance()? For example can you
// pass the ORB as an argument?
//
// Install ior multicast handler.
//
// Get reactor instance from TAO.
ACE_Reactor *reactor = orb->orb_core()->reactor ();
// See if the -ORBMulticastDiscoveryEndpoint option was specified.
ACE_CString mde (orb->orb_core ()->orb_params ()->mcast_discovery_endpoint ());
// First, see if the user has given us a multicast port number
// on the command-line;
u_short port =
orb->orb_core ()->orb_params ()->service_port (TAO::MCAST_NAMESERVICE);
if (port == 0)
{
// Check environment var. for multicast port.
const char *port_number =
ACE_OS::getenv ("NameServicePort");
if (port_number != 0)
port = static_cast<u_short> (ACE_OS::atoi (port_number));
}
// Port wasn't specified on the command-line or in environment -
// use the default.
if (port == 0)
port = TAO_DEFAULT_NAME_SERVER_REQUEST_PORT;
// Instantiate a handler which will handle client requests for
// the root Naming Context ior, received on the multicast port.
ACE_NEW_RETURN (this->ior_multicast_,
TAO_IOR_Multicast (),
-1);
if (mde.length () != 0)
{
if (this->ior_multicast_->init (this->naming_service_ior_.in (),
mde.c_str (),
TAO_SERVICEID_NAMESERVICE) == -1)
return -1;
}
else
{
if (this->ior_multicast_->init (this->naming_service_ior_.in (),
port,
#if defined (ACE_HAS_IPV6)
ACE_DEFAULT_MULTICASTV6_ADDR,
#else
ACE_DEFAULT_MULTICAST_ADDR,
#endif /* ACE_HAS_IPV6 */
TAO_SERVICEID_NAMESERVICE) == -1)
return -1;
}
// Register event handler for the ior multicast.
if (reactor->register_handler (this->ior_multicast_,
ACE_Event_Handler::READ_MASK) == -1)
{
if (TAO_debug_level > 0)
ORBSVCS_DEBUG ((LM_DEBUG,
"TAO_Naming_Server: cannot register Event handler\n"));
return -1;
}
if (TAO_debug_level > 0)
ORBSVCS_DEBUG ((LM_DEBUG,
"TAO_Naming_Server: The multicast server setup is done.\n"));
}
#else
ACE_UNUSED_ARG (enable_multicast);
#endif /* ACE_HAS_IP_MULTICAST */
#if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
if (use_round_trip_timeout == 1)
{
TimeBase::TimeT roundTripTimeoutVal = round_trip_timeout;
CORBA::Any anyObjectVal;
anyObjectVal <<= roundTripTimeoutVal;
CORBA::PolicyList polList (1);
polList.length (1);
polList[0] = orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
anyObjectVal);
// set a timeout on the orb
//
CORBA::Object_var orbPolicyManagerObj =
orb->resolve_initial_references ("ORBPolicyManager");
CORBA::PolicyManager_var orbPolicyManager =
CORBA::PolicyManager::_narrow (orbPolicyManagerObj.in ());
orbPolicyManager->set_policy_overrides (polList, CORBA::SET_OVERRIDE);
polList[0]->destroy ();
polList[0] = CORBA::Policy::_nil ();
}
#else
ACE_UNUSED_ARG (use_round_trip_timeout);
ACE_UNUSED_ARG (round_trip_timeout);
#endif /* TAO_HAS_CORBA_MESSAGING */
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (
"TAO_Naming_Server::init_new_naming");
return -1;
}
return 0;
}
int
TAO_Trading_Loader::init_multicast_server (void)
{
#if defined (ACE_HAS_IP_MULTICAST)
// Get reactor instance from TAO.
ACE_Reactor *reactor = TAO_ORB_Core_instance ()->reactor ();
// See if the -ORBMulticastDiscoveryEndpoint option was specified.
ACE_CString mde (TAO_ORB_Core_instance ()->orb_params ()
->mcast_discovery_endpoint ());
// First, see if the user has given us a multicast port number for
// the name service on the command-line;
u_short port =
TAO_ORB_Core_instance ()->orb_params ()->service_port (TAO::MCAST_TRADINGSERVICE);
if (port == 0)
{
const char *port_number =
ACE_OS::getenv ("TradingServicePort");
if (port_number != 0)
port = static_cast<u_short> (ACE_OS::atoi (port_number));
else
port = TAO_DEFAULT_TRADING_SERVER_REQUEST_PORT;
}
// Instantiate a server that will receive requests for an ior
if (mde.length () != 0)
{
if (this->ior_multicast_.init ((char *) this->ior_.in (),
mde.c_str (),
TAO_SERVICEID_TRADINGSERVICE) == -1)
return -1;
}
else
{
if (this->ior_multicast_.init ((char *) this->ior_.in (),
port,
ACE_DEFAULT_MULTICAST_ADDR,
TAO_SERVICEID_TRADINGSERVICE) == -1)
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"Failed to init IOR multicast.\n"),
-1);
}
// Register event handler for the ior multicast.
if (reactor->register_handler (&this->ior_multicast_,
ACE_Event_Handler::READ_MASK) == -1)
ORBSVCS_DEBUG ((LM_DEBUG,
"cannot register Event handler\n"));
else
ORBSVCS_DEBUG ((LM_DEBUG,
"The multicast server setup is done.\n"));
// Other trader instances will bootstrap to us.
this->bootstrapper_ = 1;
#endif /* ACE_HAS_IP_MULTICAST */
return 0;
}
// Install ior multicast handler.
int
TAO_IFR_Server::init_multicast_server (void)
{
#if defined (ACE_HAS_IP_MULTICAST)
// Get reactor instance from TAO.
ACE_Reactor *reactor = this->orb_->orb_core ()->reactor ();
// See if the -ORBMulticastDiscoveryEndpoint option was specified.
ACE_CString mde (
TAO_ORB_Core_instance ()->orb_params ()->mcast_discovery_endpoint ()
);
// First, see if the user has given us a multicast port number
// on the command-line;
u_short port =
TAO_ORB_Core_instance ()->orb_params ()->service_port (
TAO::MCAST_INTERFACEREPOSERVICE
);
if (port == 0)
{
// Check environment var. for multicast port.
const char *port_number =
ACE_OS::getenv ("InterfaceRepoServicePort");
if (port_number != 0)
port = static_cast<u_short> (ACE_OS::atoi (port_number));
}
// Port wasn't specified on the command-line or in environment -
// use the default.
if (port == 0)
port = TAO_DEFAULT_INTERFACEREPO_SERVER_REQUEST_PORT;
// Instantiate a handler which will handle client requests for
// the IFR ior, received on the multicast port.
ACE_NEW_THROW_EX (this->ior_multicast_,
TAO_IOR_Multicast (),
CORBA::NO_MEMORY ());
if (mde.length () != 0)
{
if (this->ior_multicast_->init (this->ifr_ior_.in (),
mde.c_str (),
TAO_SERVICEID_INTERFACEREPOSERVICE)
== -1)
{
ORBSVCS_ERROR_RETURN ((
LM_ERROR,
ACE_TEXT ("Interface Repository: cannot initialize ")
ACE_TEXT ("multicast event handler\n")
),
-1
);
}
}
else
{
if (this->ior_multicast_->init (this->ifr_ior_.in (),
port,
ACE_DEFAULT_MULTICAST_ADDR,
TAO_SERVICEID_INTERFACEREPOSERVICE)
== -1)
{
ORBSVCS_ERROR_RETURN ((
LM_ERROR,
ACE_TEXT ("Interface Repository: cannot initialize ")
ACE_TEXT ("multicast event handler\n")
),
-1
);
}
}
// Register event handler for the ior multicast.
if (reactor->register_handler (this->ior_multicast_,
ACE_Event_Handler::READ_MASK)
== -1)
{
ORBSVCS_ERROR_RETURN ((
LM_ERROR,
ACE_TEXT ("Interface Repository: cannot register ")
ACE_TEXT ("multicast event handler\n")
),
-1
);
}
#endif /* ACE_HAS_IP_MULTICAST */
return 0;
}
//---------------------------------------------------------------------------
int ACE_MAIN(int argc, ACE_TCHAR *argv[])
{
// 환경설정 (제일 먼저 초기화 해야함)
procArguments(argc, argv);
// 로그
if(initLog() < 0)
{
printf("로그 초기화를 실패했으므로 프로그램을 종료합니다.\n");
return -1;
}
//-----------------------------------------------------------------------
// 데몬 만들기
//-----------------------------------------------------------------------
// acceptor 가 초기화 된 후 데몬을 만들게 되면, 부모프로세스가 제거되면서
// listen 소켓도 같이 제거된다. 그러므로 acceptor 를 초기화 하기 전에
// 데몬을 먼저 만들어야 한다.
if(Config::instance()->process.daemon == true)
{
if(makeDaemon() < 0)
{
printf("데몬으로 만들기를 실패했으므로 프로그램을 종료합니다.\n");
return -1;
}
}
PAS_NOTICE1("%s", compile_date);
// 시그널 핸들러
PasSignalHandler* pSignalHandler = new PasSignalHandler;
initSignal(pSignalHandler);
//------------------
// 각 모듈의 초기화
//------------------
HTTP::Request::HeaderBuffBytes = HTTP::Response::HeaderBuffBytes = Config::instance()->process.HttpHeaderBufferBytes;
increseFdLimit();
// PAS 공식 로그
char hostName[32];
gethostname(hostName, sizeof(hostName)-1);
PasDataLog::setPasAddr(hostName);
// 메모리 매니저 초기화
//initMessageBlockManager();
if (readMBconfig() < 0)
{
printf("메모리 풀 컨피그 설정값을 확인하세요.\n");
PAS_ERROR("메모리 풀 컨피그 설정값을 확인하세요.\n");
return -1;
}
const int numWorkerThread = Config::instance()->thread.numWorker;
// 리액터
ACE_Reactor* pReactor = ReactorPool::instance()->createMaster();
ReactorPool::instance()->createWorkers(numWorkerThread);
ACE_Reactor* pGlobalReactor = ACE_Reactor::instance();
PAS_NOTICE3("REACTOR: Master=%X, Global=%X, Master=%x",
pReactor, pGlobalReactor, ReactorPool::instance()->masterReactor());
// Listen 포트 설정
PAS_NOTICE("Listen Socket Activate");
PasAcceptor* pAcceptor = new PasAcceptor(pReactor);
const int listenPort = Config::instance()->network.listenPort;
// mIDC 내의 서버를 감시하는 쪽에 mwatch 전달하기 위해 메시지 작성한다.
Util2::setMwatchMsg(listenPort);
// acceptor 기동
if(pAcceptor->open(listenPort) < 0)
{
PAS_ERROR1("Listen 소켓 생성 실패, Port[%d]\n", listenPort);
PAS_ERROR("프로그램 종료\n");
printf("Listen 소켓 생성 실패, Port[%d]\n", listenPort);
printf("프로그램 종료\n");
return -1;
}
// 쓰레드 매니저
ACE_Thread_Manager* pTManager = ACE_Thread_Manager::instance();
// monitor 보고리를 위한 thread 를 생성한다.
MonitorReporter *monitor = MonitorReporter::instance(pTManager);
monitor->activate(THR_NEW_LWP | THR_JOINABLE);
WatchReporter *watch = WatchReporter::instance(pTManager);
watch->activate(THR_NEW_LWP | THR_JOINABLE);
// UserInfo 관리를 위한 thread 를 생성한다.
UserInfoMng *userInfoMng = UserInfoMng::instance(pTManager);
userInfoMng->activate(THR_NEW_LWP | THR_JOINABLE);
// phone trace 를 위한 thread 를 생성한다.
PhoneTraceMng *phoneTraceMng = PhoneTraceMng::instance(pTManager);
phoneTraceMng->setDataFile((char*)"trace.acl");
phoneTraceMng->activate(THR_NEW_LWP | THR_JOINABLE);
// 공지 처리 (Stat Filter) 를 위한 thread 를 생성한다.
StatFilterMng *statFilterMng = StatFilterMng::instance(pTManager);
statFilterMng->setDataFile((char*)"k_stat.cfg");
statFilterMng->activate(THR_NEW_LWP | THR_JOINABLE);
// ACL 초기화
if(Config::instance()->acl.enable)
initACL();
CGI::cgiSetupConstants();
// Create AuthAgent Thread
AuthAgent *authAgent = AuthAgent::instance(pTManager);
authAgent->activate(THR_NEW_LWP | THR_JOINABLE);
//usleep(1000);
// 내부 정보 (sysinfo) 출력를 위한 Thread
SysInfo *sysInfo = SysInfo::instance(pTManager);
sysInfo->activate(THR_NEW_LWP | THR_JOINABLE);
// hash key 로그 작성을 위한 초기화.
HashKey::prepare();
// 로그 화일을 먼저 만들어 놓는다. 테스트시에 편하다. (tail -f )
PasDataLog::instance();
// accept event 핸들러 등록
pReactor->register_handler(pAcceptor, ACE_Event_Handler::ACCEPT_MASK);
// 이벤트 디멀티플렉싱
PAS_NOTICE("Master Reactor Start");
pReactor->run_event_loop();
PAS_NOTICE("Master Reactor Stop");
ReactorPool::instance()->stopWorkers();
/*--- Reactor 가 종료된 경우 아래 라인으로 진행된다. ---*/
stopACL(); // ACL 종료
userInfoMng->stop();
monitor->stop();
watch->stop();
phoneTraceMng->putq(new ACE_Message_Block());
statFilterMng->putq(new ACE_Message_Block());
sysInfo->putq(new ACE_Message_Block());
authAgent->putq(new ACE_Message_Block());
DNS::Manager::instance()->removeAllQuerier();
// 모든 쓰레드 종료 대기
PAS_NOTICE("Waiting for all threads to stop");
pTManager->wait();
delete phoneTraceMng;
delete statFilterMng;
delete sysInfo;
// 생성한 동적 객체 삭제
delete pSignalHandler;
PAS_NOTICE("======= PAS GW Stop =======");
return 0;
}
