ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::~ACE_Cached_Connect_Strategy (void)
{
if (this->delete_lock_)
delete this->lock_;
delete this->reverse_lock_;
if (this->delete_creation_strategy_)
delete this->creation_strategy_;
this->delete_creation_strategy_ = false;
this->creation_strategy_ = 0;
if (this->delete_concurrency_strategy_)
delete this->concurrency_strategy_;
this->delete_concurrency_strategy_ = false;
this->concurrency_strategy_ = 0;
if (this->delete_recycling_strategy_)
delete this->recycling_strategy_;
this->delete_recycling_strategy_ = false;
this->recycling_strategy_ = 0;
// Close down all cached service handlers.
CONNECTION_MAP_ENTRY *entry = 0;
for (CONNECTION_MAP_ITERATOR iterator (connection_map_);
iterator.next (entry);
iterator.advance ())
{
entry->int_id_->recycler (0, 0);
entry->int_id_->close ();
}
}
void
Event_Channel::initiate_connector (void)
{
if (Options::instance ()->enabled
(Options::CONSUMER_CONNECTOR | Options::SUPPLIER_CONNECTOR))
{
CONNECTION_MAP_ITERATOR cmi (this->connection_map_);
// Iterate through the Consumer Map connecting all the
// Connection_Handlers.
for (CONNECTION_MAP_ENTRY *me = 0;
cmi.next (me) != 0;
cmi.advance ())
{
Connection_Handler *connection_handler = me->int_id_;
if (this->initiate_connection_connection (connection_handler) == -1)
continue; // Failures are handled elsewhere...
}
}
}
int
Event_Channel::close (u_long)
{
if (Options::instance ()->threading_strategy () != Options::REACTIVE)
{
if (ACE_Thread_Manager::instance ()->suspend_all () == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"(%t) %p\n",
"suspend_all"),
-1);
ACE_DEBUG ((LM_DEBUG,
"(%t) suspending all threads\n"));
}
// First tell everyone that the spaceship is here...
{
CONNECTION_MAP_ITERATOR cmi (this->connection_map_);
// Iterate over all the handlers and shut them down.
for (CONNECTION_MAP_ENTRY *me = 0; // It's safe to reset me to 0.
cmi.next (me) != 0;
cmi.advance ())
{
Connection_Handler *connection_handler = me->int_id_;
ACE_DEBUG ((LM_DEBUG,
"(%t) closing down connection %d\n",
connection_handler->connection_id ()));
// If have no this statement, the gatewayd will abort when exiting
// with some Consumer/Supplier not connected.
if (connection_handler->state()==Connection_Handler::CONNECTING)
this->cancel_connection_connection(connection_handler);
// Mark Connection_Handler as DISCONNECTING so we don't try to
// reconnect...
connection_handler->state (Connection_Handler::DISCONNECTING);
}
}
// Close down the connector
this->connector_.close ();
// Close down the supplier acceptor.
this->supplier_acceptor_.close ();
// Close down the consumer acceptor.
this->consumer_acceptor_.close ();
// Now tell everyone that it is now time to commit suicide.
{
CONNECTION_MAP_ITERATOR cmi (this->connection_map_);
for (CONNECTION_MAP_ENTRY *me = 0; // It's safe to reset me to 0.
cmi.next (me) != 0;
cmi.advance ())
{
Connection_Handler *connection_handler = me->int_id_;
// Deallocate Connection_Handler resources.
connection_handler->destroy (); // Will trigger a delete.
}
}
return 0;
}
int
Event_Channel::compute_performance_statistics (void)
{
ACE_DEBUG ((LM_DEBUG, "(%t) doing the performance timeout here...\n"));
CONNECTION_MAP_ITERATOR cmi (this->connection_map_);
// If we've got a <ACE_Thread_Manager> then use it to suspend all
// the threads. This will enable us to get an accurate count.
if (Options::instance ()->threading_strategy ()
!= Options::REACTIVE)
{
if (ACE_Thread_Manager::instance ()->suspend_all () == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"(%t) %p\n",
"suspend_all"),
-1);
ACE_DEBUG ((LM_DEBUG,
"(%t) suspending all threads..."));
}
size_t total_bytes_in = 0;
size_t total_bytes_out = 0;
// Iterate through the connection map summing up the number of bytes
// sent/received.
for (CONNECTION_MAP_ENTRY *me = 0;
cmi.next (me) != 0;
cmi.advance ())
{
Connection_Handler *connection_handler = me->int_id_;
if (connection_handler->connection_role () == 'C')
total_bytes_out += connection_handler->total_bytes ();
else // connection_handler->connection_role () == 'S'
total_bytes_in += connection_handler->total_bytes ();
}
ACE_DEBUG ((LM_DEBUG,
"(%t) after %d seconds, \ntotal_bytes_in = %d\ntotal_bytes_out = %d\n",
Options::instance ()->performance_window (),
total_bytes_in,
total_bytes_out));
ACE_DEBUG ((LM_DEBUG,
"(%t) %f Mbits/sec received.\n",
(float) (total_bytes_in * 8 /
(float) (1024 * 1024 * Options::instance ()->performance_window ()))));
ACE_DEBUG ((LM_DEBUG,
"(%t) %f Mbits/sec sent.\n",
(float) (total_bytes_out * 8 /
(float) (1024 * 1024 * Options::instance ()->performance_window ()))));
// Resume all the threads again.
if (Options::instance ()->threading_strategy ()
!= Options::REACTIVE)
{
if (ACE_Thread_Manager::instance ()->resume_all () == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"(%t) %p\n",
"resume_all"),
-1);
ACE_DEBUG ((LM_DEBUG,
"(%t) resuming all threads..."));
}
return 0;
}
