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; }