void
TAO_Support_Attributes_i::
supports_proxy_offers (CORBA::Boolean new_value)
{
ACE_WRITE_GUARD (ACE_Lock, ace_mon, this->locker_.lock ());
this->supports_proxy_offers_ = new_value;
}
void
TAO_Support_Attributes_i::
supports_modifiable_properties (CORBA::Boolean new_value)
{
ACE_WRITE_GUARD (ACE_Lock, ace_mon, this->locker_.lock ());
this->supports_modifiable_properties_ = new_value;
}
void TAO_FTEC_Group_Manager::replica_crashed (
const FTRT::Location & location)
{
TAO_FTRTEC::Log(1, ACE_TEXT("TAO_FTEC_Group_Manager::replica_crashed\n"));
FTRTEC::Replication_Service* svc = FTRTEC::Replication_Service::instance();
ACE_WRITE_GUARD (FTRTEC::Replication_Service, lock, *svc);
remove_member(location, IOGR_Maker::instance()->get_ref_version()+1);
}
void
TAO_Import_Attributes_i::max_follow_policy (CosTrading::FollowOption new_value)
{
ACE_WRITE_GUARD (ACE_Lock, ace_mon, this->locker_.lock ());
this->max_follow_policy_ = new_value;
if (this->def_follow_policy_ > this->max_follow_policy_)
this->def_follow_policy_ = this->max_follow_policy_;
}
void
TAO_Import_Attributes_i::max_hop_count (CORBA::ULong new_value)
{
ACE_WRITE_GUARD (ACE_Lock, ace_mon, this->locker_.lock ());
this->max_hop_count_ = new_value;
if (this->def_hop_count_ > this->max_hop_count_)
this->def_hop_count_ = this->max_hop_count_;
}
void
TAO_Import_Attributes_i::max_return_card (CORBA::ULong new_value)
{
ACE_WRITE_GUARD (ACE_Lock, ace_mon, this->locker_.lock ());
this->max_return_card_ = new_value;
if (this->def_return_card_ > this->max_return_card_)
this->def_return_card_ = this->max_return_card_;
}
void
TAO_Import_Attributes_i::def_match_card (CORBA::ULong new_value)
{
ACE_WRITE_GUARD (ACE_Lock, ace_mon, this->locker_.lock ());
if (new_value > this->max_match_card_)
this->def_match_card_ = this->max_match_card_;
else
this->def_match_card_ = new_value;
}
void TAO_FTEC_Group_Manager::join_group (
const FTRT::ManagerInfo & info)
{
TAO_FTRTEC::Log(1, ACE_TEXT("join group\n"));
if (impl_->my_position == 0) {
FTRTEC::Replication_Service* svc = FTRTEC::Replication_Service::instance();
ACE_WRITE_GUARD (FTRTEC::Replication_Service, lock, *svc);
add_member(info, IOGR_Maker::instance()->get_ref_version()+1);
}
}
void
TAO_Support_Attributes_i::
type_repos (CosTrading::TypeRepository_ptr new_value)
{
// @@ Seth, There is no way to propagate the exception out.
ACE_WRITE_GUARD (ACE_Lock, ace_mon, this->locker_.lock ());
this->type_repos_ = new_value;
// @@ What can we do even if we catch this?
this->service_type_repos_ =
CosTradingRepos::ServiceTypeRepository::_narrow (new_value);
}
void
TAO_Portable_Group_Map::add_groupid_objectkey_pair (
PortableGroup::TagGroupTaggedComponent *group_id,
const TAO::ObjectKey &key
)
{
ACE_WRITE_GUARD (TAO_SYNCH_RW_MUTEX,
guard,
this->lock_);
Map_Entry *new_entry;
// We take ownership of the group_id memory. Be sure we don't
// forget about it.
PortableGroup::TagGroupTaggedComponent_var safe_group = group_id;
ACE_NEW_THROW_EX (new_entry,
Map_Entry (),
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
// Fill out the entry.
new_entry->key = key;
// First, check if the GroupId is already in the map.
Map_Entry *entry = 0;
if (this->map_.find (group_id, entry) == 0)
{
// Add the object key to the list of object keys serviced by this GroupId.
new_entry->next = entry->next;
entry->next = new_entry;
}
else
{
new_entry->next = 0;
// Add the
int result =
this->map_.bind (group_id, new_entry);
if (result != 0)
{
delete new_entry;
throw CORBA::INTERNAL ();
}
// Transfer ownership of group_id to the map.
(void) safe_group._retn ();
}
}
TAO_Control_Registry::~TAO_Control_Registry (void)
{
ACE_WRITE_GUARD (TAO_SYNCH_RW_MUTEX, guard, this->mutex_);
Map::iterator itr (this->map_);
Map::value_type* entry = 0;
while (itr.next (entry))
{
delete entry->item ();
itr.advance ();
}
}
//
// handle_messages
//
void CUTS_Testing_LoggingServerListener_i::
handle_messages (const char * hostname,
const ::CUTS::UUID & test,
const ::CUTS::LogMessages & msgs)
{
try
{
ACE_WRITE_GUARD (ACE_RW_Thread_Mutex, guard, this->mutex_);
if (0 == this->database_)
return;
// Create a new query object.
ADBC::Query * query = this->database_->create_query ();
CUTS_Auto_Functor_T <ADBC::Query> auto_clean (query, &ADBC::Query::destroy);
// Start a new transaction.
query->execute_no_record ("BEGIN TRANSACTION");
// Prepare the statement for inserting messages.
CUTS_Log_Message_Table msg_table (*this->database_);
CUTS_Log_Message_Table::INSERT_STMT insert_stmt (*query);
insert_stmt.prepare ();
insert_stmt.bind_hostname (hostname);
// Insert each message into the database.
std::for_each (msgs.get_buffer (),
msgs.get_buffer () + msgs.length (),
insert_message (insert_stmt));
// End the current transaction.
query->execute_no_record ("COMMIT");
}
catch (const ADBC::Exception & ex)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%T (%t) - %M - %s (%N:%l)\n"),
ex.message ().c_str ()));
}
catch (...)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%T (%t) - %M - caught unknown exception (%N:%l)\n")));
}
++this->messages_received_;
}
void WardenCheckMgr::LoadWardenOverrides()
{
// Check if Warden is enabled by config before loading anything
if (!sWorld->getBoolConfig(CONFIG_WARDEN_ENABLED))
{
sLog->outInfo(LOG_FILTER_WARDEN, ">> Warden disabled, loading check overrides skipped.");
return;
}
// 0 1
QueryResult result = CharacterDatabase.Query("SELECT wardenId, action FROM warden_action");
if (!result)
{
sLog->outInfo(LOG_FILTER_SERVER_LOADING, ">> Loaded 0 Warden action overrides. DB table `warden_action` is empty!");
return;
}
uint32 count = 0;
ACE_WRITE_GUARD(ACE_RW_Mutex, g, _checkStoreLock);
do
{
Field* fields = result->Fetch();
uint16 checkId = fields[0].GetUInt16();
uint8 action = fields[1].GetUInt8();
// Check if action value is in range (0-2, see WardenActions enum)
if (action > WARDEN_ACTION_BAN)
sLog->outError(LOG_FILTER_WARDEN, "Warden check override action out of range (ID: %u, action: %u)", checkId, action);
// Check if check actually exists before accessing the CheckStore vector
else if (checkId > CheckStore.size())
sLog->outError(LOG_FILTER_WARDEN, "Warden check action override for non-existing check (ID: %u, action: %u), skipped", checkId, action);
else
{
CheckStore[checkId]->Action = WardenActions(action);
++count;
}
}
while (result->NextRow());
sLog->outInfo(LOG_FILTER_WARDEN, ">> Loaded %u warden action overrides.", count);
}
void
RecorderImpl::remove_associations(const WriterIdSeq& writers,
bool notify_lost)
{
DBG_ENTRY_LVL("RecorderImpl", "remove_associations", 6);
if (writers.length() == 0) {
return;
}
if (DCPS_debug_level >= 1) {
GuidConverter reader_converter(subscription_id_);
GuidConverter writer_converter(writers[0]);
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) RecorderImpl::remove_associations: ")
ACE_TEXT("bit %d local %C remote %C num remotes %d \n"),
is_bit_,
OPENDDS_STRING(reader_converter).c_str(),
OPENDDS_STRING(writer_converter).c_str(),
writers.length()));
}
if (!this->entity_deleted_.value()) {
// stop pending associations for these writer ids
this->stop_associating(writers.get_buffer(), writers.length());
// writers which are considered non-active and can
// be removed immediately
WriterIdSeq non_active_writers;
{
CORBA::ULong wr_len = writers.length();
ACE_WRITE_GUARD(ACE_RW_Thread_Mutex, write_guard, this->writers_lock_);
for (CORBA::ULong i = 0; i < wr_len; i++) {
PublicationId writer_id = writers[i];
WriterMapType::iterator it = this->writers_.find(writer_id);
if (it != this->writers_.end() &&
it->second->active(TheServiceParticipant->pending_timeout())) {
remove_association_sweeper_->schedule_timer(it->second, notify_lost);
} else {
push_back(non_active_writers, writer_id);
}
}
}
remove_associations_i(non_active_writers, notify_lost);
} else {
remove_associations_i(writers, notify_lost);
}
}
TAO_Service_Type_Repository::~TAO_Service_Type_Repository (void)
{
{
// Make sure not to throw exceptions in destructors...
ACE_WRITE_GUARD (ACE_Lock, ace_mon, *this->lock_);
for (Service_Type_Map_Iterator service_map_iterator (this->type_map_);
service_map_iterator.done () == 0;
service_map_iterator++)
{
Type_Info *type_info = (*service_map_iterator).int_id_;
delete type_info;
}
}
delete this->lock_;
}
ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::ACE_RB_Tree (const ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> &rbt)
: root_ (0),
current_size_ (0)
{
ACE_TRACE ("ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::ACE_RB_Tree (const ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> &rbt)");
ACE_WRITE_GUARD (ACE_LOCK, ace_mon, this->lock_);
allocator_ = rbt.allocator_;
// Make a deep copy of the passed tree.
ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> iter(rbt);
for (iter.first ();
iter.is_done () == 0; iter.next ())
insert_i (*(iter.key ()),
*(iter.item ()));
}
void
RecorderImpl::remove_or_reschedule(const PublicationId& pub_id)
{
ACE_WRITE_GUARD(ACE_RW_Thread_Mutex, write_guard, this->writers_lock_);
WriterMapType::iterator where = writers_.find(pub_id);
if (writers_.end() != where) {
WriterInfo& info = *where->second;
WriterIdSeq writers;
push_back(writers, pub_id);
bool notify = info.notify_lost_;
if (info.removal_deadline_ < ACE_OS::gettimeofday()) {
write_guard.release();
remove_associations_i(writers, notify);
} else {
write_guard.release();
remove_associations(writers, notify);
}
}
}
void WardenCheckMgr::LoadWardenOverrides()
{
// 0 1
QueryResult result = CharacterDatabase.Query("SELECT wardenId, action FROM warden_action");
if (!result)
{
sLog->outString(">> Loaded 0 Warden action overrides. DB table `warden_action` is empty!");
sLog->outString();
return;
}
uint32 count = 0;
ACE_WRITE_GUARD(ACE_RW_Mutex, g, _checkStoreLock);
do
{
Field* fields = result->Fetch();
uint16 checkId = fields[0].GetUInt16();
uint8 action = fields[1].GetUInt8();
// Check if action value is in range (0-2, see WardenActions enum)
if (action > WARDEN_ACTION_BAN)
sLog->outError("Warden check override action out of range (ID: %u, action: %u)", checkId, action);
// Check if check actually exists before accessing the CheckStore vector
else if (checkId > CheckStore.size())
sLog->outError("Warden check action override for non-existing check (ID: %u, action: %u), skipped", checkId, action);
else
{
CheckStore[checkId]->Action = WardenActions(action);
++count;
}
}
while (result->NextRow());
sLog->outString(">> Loaded %u warden action overrides.", count);
sLog->outString();
}
int
Writer_Task::svc (void)
{
ACE_Profile_Timer timer;
ACE_Profile_Timer::ACE_Elapsed_Time elapsed_time;
barrier_.wait ();
// Wait at the barrier
// We start an ACE_Profile_Timer here...
timer.start ();
for (int iterations = 1;
iterations <= n_iterations;
iterations++)
{
ACE_Thread::yield ();
#if defined (RW_MUTEX)
ACE_WRITE_GUARD (ACE_RW_Thread_Mutex, g, rw_mutex, 0);
#else
ACE_GUARD_RETURN (ACE_Thread_Mutex, g, mutex, 0);
#endif /* RW_MUTEX */
find_last ();
current_writers--;
}
// Stop the timer.
timer.stop ();
timer.elapsed_time (elapsed_time);
this->time_Calculation_.report_time (elapsed_time);
return 0;
}
template <class EXT_ID, class INT_ID, class COMPARE_KEYS, class ACE_LOCK> void
ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator = (const ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> &rbt)
{
ACE_TRACE ("ACE_RB_Tree<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK>::operator =");
ACE_WRITE_GUARD (ACE_LOCK, ace_mon, this->lock_);
if (this != &rbt)
{
// Clear out the existing tree.
close_i ();
// Make a deep copy of the passed tree.
ACE_RB_Tree_Iterator<EXT_ID, INT_ID, COMPARE_KEYS, ACE_LOCK> iter(rbt);
for (iter.first ();
iter.is_done () == 0;
iter.next ())
insert_i (*(iter.key ()),
*(iter.item ()));
// Use the same allocator as the rhs.
allocator_ = rbt.allocator_;
}
}
void
TAO_Trading_Components_i::lookup_if (CosTrading::Lookup_ptr new_value)
{
ACE_WRITE_GUARD (ACE_Lock, ace_mon, this->locker_.lock ());
this->lookup_ = new_value;
}
void
RecorderImpl::remove_associations_i(const WriterIdSeq& writers,
bool notify_lost)
{
DBG_ENTRY_LVL("RecorderImpl", "remove_associations_i", 6);
if (writers.length() == 0) {
return;
}
if (DCPS_debug_level >= 1) {
GuidConverter reader_converter(subscription_id_);
GuidConverter writer_converter(writers[0]);
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) RecorderImpl::remove_associations_i: ")
ACE_TEXT("bit %d local %C remote %C num remotes %d \n"),
is_bit_,
OPENDDS_STRING(reader_converter).c_str(),
OPENDDS_STRING(writer_converter).c_str(),
writers.length()));
}
DDS::InstanceHandleSeq handles;
ACE_GUARD(ACE_Recursive_Thread_Mutex, guard, this->publication_handle_lock_);
// This is used to hold the list of writers which were actually
// removed, which is a proper subset of the writers which were
// requested to be removed.
WriterIdSeq updated_writers;
CORBA::ULong wr_len;
//Remove the writers from writer list. If the supplied writer
//is not in the cached writers list then it is already removed.
//We just need remove the writers in the list that have not been
//removed.
{
ACE_WRITE_GUARD(ACE_RW_Thread_Mutex, write_guard, this->writers_lock_);
wr_len = writers.length();
for (CORBA::ULong i = 0; i < wr_len; i++) {
PublicationId writer_id = writers[i];
WriterMapType::iterator it = this->writers_.find(writer_id);
if (it != this->writers_.end()) {
it->second->removed();
remove_association_sweeper_->cancel_timer(it->second);
}
if (this->writers_.erase(writer_id) == 0) {
if (DCPS_debug_level >= 1) {
GuidConverter converter(writer_id);
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) RecorderImpl::remove_associations_i: ")
ACE_TEXT("the writer local %C was already removed.\n"),
OPENDDS_STRING(converter).c_str()));
}
} else {
push_back(updated_writers, writer_id);
}
}
}
wr_len = updated_writers.length();
// Return now if the supplied writers have been removed already.
if (wr_len == 0) {
return;
}
if (!is_bit_) {
// The writer should be in the id_to_handle map at this time. Note
// it if it not there.
if (this->lookup_instance_handles(updated_writers, handles) == false) {
if (DCPS_debug_level > 4) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) RecorderImpl::remove_associations_i: ")
ACE_TEXT("lookup_instance_handles failed.\n")));
}
}
for (CORBA::ULong i = 0; i < wr_len; ++i) {
id_to_handle_map_.erase(updated_writers[i]);
}
}
for (CORBA::ULong i = 0; i < updated_writers.length(); ++i) {
this->disassociate(updated_writers[i]);
}
// Mirror the add_associations SUBSCRIPTION_MATCHED_STATUS processing.
if (!this->is_bit_) {
// Derive the change in the number of publications writing to this reader.
int matchedPublications = static_cast<int>(this->id_to_handle_map_.size());
this->subscription_match_status_.current_count_change
= matchedPublications - this->subscription_match_status_.current_count;
// Only process status if the number of publications has changed.
if (this->subscription_match_status_.current_count_change != 0) {
this->subscription_match_status_.current_count = matchedPublications;
/// Section 7.1.4.1: total_count will not decrement.
/// @TODO: Reconcile this with the verbiage in section 7.1.4.1
this->subscription_match_status_.last_publication_handle
= handles[ wr_len - 1];
// set_status_changed_flag(DDS::SUBSCRIPTION_MATCHED_STATUS, true);
// DDS::DataReaderListener_var listener
// = listener_for(DDS::SUBSCRIPTION_MATCHED_STATUS);
if (listener_.in()) {
listener_->on_recorder_matched(
this,
this->subscription_match_status_);
// Client will look at it so next time it looks the change should be 0
this->subscription_match_status_.total_count_change = 0;
this->subscription_match_status_.current_count_change = 0;
}
// notify_status_condition();
}
}
// If this remove_association is invoked when the InfoRepo
// detects a lost writer then make a callback to notify
// subscription lost.
if (notify_lost) {
this->notify_subscription_lost(handles);
}
// if (this->monitor_) {
// this->monitor_->report();
// }
}
int
Reader_Task::svc (void)
{
ACE_Profile_Timer timer;
ACE_Profile_Timer::ACE_Elapsed_Time elapsed_time;
barrier_.wait ();
// Wait at the barrier.
// We start an ACE_Profile_Timer here...
timer.start ();
for (int iterations = 1;
iterations <= n_iterations;
iterations++)
{
ACE_Thread::yield ();
int result = 0;
{
#if defined (RW_MUTEX)
ACE_READ_GUARD_RETURN (ACE_RW_Thread_Mutex, g, rw_mutex, 1);
#else
ACE_GUARD_RETURN (ACE_Thread_Mutex, g, mutex, 1);
#endif /* RW_MUTEX */
find_last ();
#if defined (RW_MUTEX)
if (use_try_upgrade)
result =
rw_mutex.tryacquire_write_upgrade ();
#endif /* RW_MUTEX */
// True, when we were able to upgrade.
if (result == 0 && use_try_upgrade)
{
//find_last (); try to find something which is not in
//there
upgraded++;
continue;
}
}
if ((result == -1 && errno == EBUSY) // we tried and failed
|| !use_try_upgrade) // we did not try at all
{
#if defined (RW_MUTEX)
ACE_WRITE_GUARD (ACE_RW_Thread_Mutex, g, rw_mutex, 1);
#else
ACE_GUARD_RETURN (ACE_Thread_Mutex, g, mutex, 1);
#endif /* RW_MUTEX */
not_upgraded++;
find_last ();
}
else if (result == -1 && errno != EBUSY)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT (" (%t) failure in upgrading to write lock!\n"),
1));
}
}
// Stop the timer.
timer.stop ();
timer.elapsed_time (elapsed_time);
this->time_Calculation_.report_time (elapsed_time);
return 0;
}
void
TAO_Import_Attributes_i::max_list (CORBA::ULong new_value)
{
ACE_WRITE_GUARD (ACE_Lock, ace_mon, this->locker_.lock ());
this->max_list_ = new_value;
}
void
TAO_Trading_Components_i::register_if (CosTrading::Register_ptr new_value)
{
ACE_WRITE_GUARD (ACE_Lock, ace_mon, this->locker_.lock ());
this->register_ = new_value;
}
void
TAO_Link_Attributes_i::max_link_follow_policy (CosTrading::FollowOption new_value)
{
ACE_WRITE_GUARD (ACE_Lock, ace_mon, this->locker_.lock ());
this->max_link_follow_policy_ = new_value;
}
void
TAO_Trading_Components_i::admin_if (CosTrading::Admin_ptr new_value)
{
ACE_WRITE_GUARD (ACE_Lock, ace_mon, this->locker_.lock ());
this->admin_ = new_value;
}
void
TAO_Trading_Components_i::proxy_if (CosTrading::Proxy_ptr new_value)
{
ACE_WRITE_GUARD (ACE_Lock, ace_mon, this->locker_.lock ());
this->proxy_ = new_value;
}
