void
TAO_Log_i::set_forwarding_state (DsLogAdmin::ForwardingState state)
{
ACE_WRITE_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
DsLogAdmin::ForwardingState old_state =
this->recordstore_->get_forwarding_state ();
// @@ The current revision of the specification (formal/03-07-01) is
// unclear whether an AttributeValueChange event should be sent if a
// log attribute was changed (to a new value), or whether the events
// should be sent unconditionally. I have submitted a defect report
// to the OMG for clarification.
//
// In the mean time, we're interepreting it to mean that events are
// only sent when the value has changed.
if (state == old_state)
return;
this->recordstore_->set_forwarding_state (state);
if (notifier_)
{
notifier_->forwarding_state_change (this->log_.in (),
this->logid_,
state);
}
}
CORBA::ULong
TAO_Log_i::delete_records (const char *grammar,
const char *constraint)
{
ACE_WRITE_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
const CORBA::ULong count =
this->recordstore_->delete_records (grammar,
constraint);
if (count > 0)
{
if (avail_status_.log_full)
{
const CORBA::ULongLong current_size =
this->recordstore_->get_current_size ();
const CORBA::ULongLong max_size =
this->recordstore_->get_max_size ();
if (current_size < max_size)
{
avail_status_.log_full = 0;
}
}
this->reset_capacity_alarm_threshold ();
}
return count;
}
CORBA::ULong
TAO_Log_i::delete_records_by_id (const DsLogAdmin::RecordIdList &ids)
{
ACE_WRITE_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
const CORBA::ULong count =
this->recordstore_->delete_records_by_id (ids);
if (count > 0)
{
if (avail_status_.log_full)
{
const CORBA::ULongLong current_size =
this->recordstore_->get_current_size ();
const CORBA::ULongLong max_size =
this->recordstore_->get_max_size ();
if (current_size < max_size)
{
avail_status_.log_full = 0;
}
}
this->reset_capacity_alarm_threshold ();
}
return count;
}
void
TAO_Log_i::remove_old_records (void)
{
ACE_WRITE_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
const CORBA::ULong count =
this->recordstore_->remove_old_records ();
if (count > 0)
{
if (avail_status_.log_full)
{
const CORBA::ULongLong current_size =
this->recordstore_->get_current_size ();
const CORBA::ULongLong max_size =
this->recordstore_->get_max_size ();
if (current_size < max_size)
{
avail_status_.log_full = 0;
}
}
this->reset_capacity_alarm_threshold ();
}
}
void
TAO_Hash_Naming_Context::bind_context (const CosNaming::Name &n,
CosNaming::NamingContext_ptr nc)
{
// Check to make sure this object didn't have <destroy> method
// invoked on it.
if (this->destroyed_)
throw CORBA::OBJECT_NOT_EXIST ();
// Do not allow binding of nil context reference.
if (CORBA::is_nil (nc))
throw CORBA::BAD_PARAM ();
// Get the length of the name.
CORBA::ULong const name_len = n.length ();
// Check for invalid name.
if (name_len == 0)
throw CosNaming::NamingContext::InvalidName();
// If we received compound name, resolve it to get the context in
// which the binding should take place, then perform the binding on
// target context.
if (name_len > 1)
{
CosNaming::NamingContext_var context = this->get_context (n);
CosNaming::Name simple_name;
simple_name.length (1);
simple_name[0] = n[name_len - 1];
try
{
context->bind_context (simple_name, nc);
}
catch (const CORBA::SystemException&)
{
throw CosNaming::NamingContext::CannotProceed(
context.in (), simple_name);
}
}
// If we received a simple name, we need to bind it in this context.
else
{
ACE_WRITE_GUARD_THROW_EX (TAO_SYNCH_RW_MUTEX, ace_mon,
this->lock_,
CORBA::INTERNAL ());
// Try binding the name.
int result = this->context_->bind (n[0].id,
n[0].kind,
nc,
CosNaming::ncontext);
if (result == 1)
throw CosNaming::NamingContext::AlreadyBound();
// Something went wrong with the internal structure
else if (result == -1)
throw CORBA::INTERNAL ();
}
}
void
TAO_Service_Type_Repository::
mask_type (const char *name)
{
if (TAO_Trader_Base::is_valid_identifier_name (name) == 0)
throw CosTrading::IllegalServiceType (name);
ACE_WRITE_GUARD_THROW_EX (ACE_Lock, ace_mon, *this->lock_, CORBA::INTERNAL ());
// Make sure the type exists.
CORBA::String_var type_name (name);
Service_Type_Map::ENTRY *type_entry = 0;
if (this->type_map_.find (type_name,
type_entry) != -1)
throw CosTrading::UnknownServiceType (name);
// Make sure the type is unmasked.
CORBA::Boolean &mask =
type_entry->int_id_->type_struct_.masked;
if (mask == 1)
throw CosTradingRepos::ServiceTypeRepository::AlreadyMasked (name);
else
mask = 1;
}
void
TAO_Hash_LogStore::create_with_id (DsLogAdmin::LogId id,
DsLogAdmin::LogFullActionType full_action,
CORBA::ULongLong max_size,
const DsLogAdmin::CapacityAlarmThresholdList* thresholds)
{
ACE_WRITE_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
lock_,
CORBA::INTERNAL ());
if (this->hash_map_.find (id) == 0)
{
throw DsLogAdmin::LogIdAlreadyExists ();
}
TAO_Hash_LogRecordStore* impl = 0;
ACE_NEW_THROW_EX (impl,
TAO_Hash_LogRecordStore (this->logmgr_i_,
id,
full_action,
max_size,
thresholds
),
CORBA::NO_MEMORY ());
auto_ptr<TAO_Hash_LogRecordStore> recordstore (impl);
if (this->hash_map_.bind (id, recordstore.get ()) != 0)
{
throw CORBA::INTERNAL ();
}
recordstore.release ();
}
void
TAO_Log_i::set_max_size (CORBA::ULongLong size)
{
ACE_WRITE_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
CORBA::ULongLong old_size =
this->recordstore_->get_max_size ();
// @@ The current revision of the specification (formal/03-07-01) is
// unclear whether an AttributeValueChange event should be sent if a
// log attribute was changed (to a new value), or whether the events
// should be sent unconditionally. I have submitted a defect report
// to the OMG for clarification.
//
// In the mean time, we're interepreting it to mean that events are
// only sent when the value has changed.
if (size == old_size)
return;
// size == 0 => infinite size.
if (size != 0)
{
CORBA::ULongLong current_size =
this->recordstore_->get_current_size ();
if (size < current_size)
throw DsLogAdmin::InvalidParam ();
}
this->recordstore_->set_max_size (size);
if (notifier_)
{
notifier_->max_log_size_value_change (this->log_.in (),
this->logid_,
old_size,
size);
}
// @@ The current revision of the specification (formal/03-07-01)
// doesn't specify the interaction between set_max_size() and the
// capacity alarm thresholds list. Publicly available documentation
// I've read for other log service implementations doesn't offer any
// guidance either. I have submitted a defect report to the OMG for
// clarification.
//
// In the mean time, we will call reset_capacity_alarm_threshold()
// to reset the "current_threshold_" index. This will result in
// ThresholdAlarm being sent when the next threshold is crossed. An
// argument could be made that an event should be be sent for each
// threshold that has already been crossed. Hopefully, this will be
// clarified when/if the OMG charters a RTF for the log service.
// --jtc
//
this->reset_capacity_alarm_threshold ();
}
void
TAO_Log_i::set_capacity_alarm_thresholds (const
DsLogAdmin::CapacityAlarmThresholdList
&threshs)
{
ACE_WRITE_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
const CORBA::Boolean validated =
TAO_Log_i::validate_capacity_alarm_thresholds (threshs);
if (!validated)
throw DsLogAdmin::InvalidThreshold ();
DsLogAdmin::CapacityAlarmThresholdList_var old_threshs =
this->recordstore_->get_capacity_alarm_thresholds ();
// @@ The current revision of the specification (formal/03-07-01) is
// unclear whether an AttributeValueChange event should be sent if a
// log attribute was changed (to a new value), or whether the events
// should be sent unconditionally. I have submitted a defect report
// to the OMG for clarification.
//
// In the mean time, we're interepreting it to mean that events are
// only sent when the value has changed.
if (threshs == old_threshs.in ())
return;
this->recordstore_->set_capacity_alarm_thresholds (threshs);
if (notifier_)
{
notifier_->capacity_alarm_threshold_value_change (this->log_.in (),
this->logid_,
old_threshs.in (),
threshs);
}
// @@ The current revision of the specification (formal/03-07-01)
// doesn't completly describe the behavior of changing the capacity
// alarm threshold list. Publicly available documentation I've read
// for other log service implementations doesn't offer much guidance
// either. I have submitted a defect report to the OMG for
// clarification.
//
// In the mean time, we will call reset_capacity_alarm_threshold()
// to reset the "current_threshold_" index. This will result in
// ThresholdAlarm being sent when the next threshold is crossed. An
// argument could be made that an event should be be sent for each
// threshold that has already been crossed. Hopefully, this will be
// clarified when/if the OMG charters a RTF for the log service.
// --jtc
//
this->thresholds_ = threshs;
this->reset_capacity_alarm_threshold ();
}
void
TAO_Hash_Naming_Context::rebind_context (const CosNaming::Name &n,
CosNaming::NamingContext_ptr nc)
{
// Check to make sure this object didn't have <destroy> method
// invoked on it.
if (this->destroyed_)
throw CORBA::OBJECT_NOT_EXIST ();
// Get the length of the name.
CORBA::ULong const name_len = n.length ();
// Check for invalid name.
if (name_len == 0)
throw CosNaming::NamingContext::InvalidName();
// If we received compound name, resolve it to get the context in
// which the rebinding should take place, then perform the rebinding
// on target context.
if (name_len > 1)
{
CosNaming::NamingContext_var context = this->get_context (n);
CosNaming::Name simple_name;
simple_name.length (1);
simple_name[0] = n[name_len - 1];
try
{
context->rebind_context (simple_name, nc);
}
catch (const CORBA::SystemException&)
{
throw CosNaming::NamingContext::CannotProceed(
context.in (), simple_name);
}
}
else
// If we received a simple name, we need to rebind it in this
// context.
{
ACE_WRITE_GUARD_THROW_EX (TAO_SYNCH_RW_MUTEX, ace_mon,
this->lock_,
CORBA::INTERNAL ());
int result = this->context_->rebind (n[0].id,
n[0].kind,
nc,
CosNaming::ncontext);
// Check for error conditions.
if (result == -1)
throw CORBA::INTERNAL ();
else if (result == -2)
throw CosNaming::NamingContext::NotFound(
CosNaming::NamingContext::not_context,
n);
}
}
void
TAO_Log_i::set_record_attribute (DsLogAdmin::RecordId id,
const DsLogAdmin::NVList &attr_list)
{
ACE_WRITE_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
this->recordstore_->set_record_attribute (id, attr_list);
}
void
TAO_Log_i::set_interval (const DsLogAdmin::TimeInterval &interval)
{
ACE_WRITE_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
// validate interval
if (interval.start != 0)
{
if (interval.start >= interval.stop)
throw DsLogAdmin::InvalidTimeInterval ();
}
DsLogAdmin::TimeInterval old_interval =
this->recordstore_->get_interval ();
// @@ The current revision of the specification (formal/03-07-01) is
// unclear whether an AttributeValueChange event should be sent if a
// log attribute was changed (to a new value), or whether the events
// should be sent unconditionally. I have submitted a defect report
// to the OMG for clarification.
//
// In the mean time, we're interepreting it to mean that events are
// only sent when the value has changed.
if (interval == old_interval)
return;
this->recordstore_->set_interval (interval);
if (notifier_)
{
if (interval.start != old_interval.start)
{
notifier_->start_time_value_change (this->log_.in (),
this->logid_,
old_interval.start,
interval.start);
}
if (interval.stop != old_interval.stop)
{
notifier_->stop_time_value_change (this->log_.in (),
this->logid_,
old_interval.stop,
interval.stop);
}
}
}
CORBA::ULong
TAO_Log_i::set_records_attribute (const char *grammar,
const char *constraint,
const DsLogAdmin::NVList
&attr_list)
{
ACE_WRITE_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
return this->recordstore_->set_records_attribute (grammar,
constraint,
attr_list);
}
void
TAO_Log_i::set_log_qos (const DsLogAdmin::QoSList &qos)
{
ACE_WRITE_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
// @@ The current revision of the specification (formal/03-07-01)
// does not clearly define the semantics to follow when the QoSList
// contains mutually exclusive, unsupported, or unknown properties.
// I have submitted a defect report to the OMG for clarification.
//
// In the mean time, the last known/supported property found in the
// QoSList takes presidence. If any unknown/unsupported properties
// were found, an UnsupportedQoS exception is thrown.
// --jtc
validate_log_qos (qos);
DsLogAdmin::QoSList_var old_qos =
this->recordstore_->get_log_qos ();
// @@ The current revision of the specification (formal/03-07-01) is
// unclear whether an AttributeValueChange event should be sent if a
// log attribute was changed (to a new value), or whether the events
// should be sent unconditionally. I have submitted a defect report
// to the OMG for clarification.
//
// In the mean time, we're interepreting it to mean that events are
// only sent when the value has changed.
if (qos == old_qos.in ())
return;
this->recordstore_->set_log_qos (qos);
reset_log_qos (qos);
if (notifier_)
{
notifier_->quality_of_service_value_change (this->log_.in (),
this->logid_,
old_qos.in (),
qos);
}
}
int
TAO_Hash_LogStore::remove (DsLogAdmin::LogId id)
{
ACE_WRITE_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
lock_,
CORBA::INTERNAL ());
TAO_Hash_LogRecordStore* recordstore = 0;
int retval = this->hash_map_.unbind (id, recordstore);
if (retval == 0)
{
delete recordstore;
}
return retval;
}
void
TAO_Service_Type_Repository::remove_type (const char *name)
{
if (TAO_Trader_Base::is_valid_identifier_name (name) == 0)
throw CosTrading::IllegalServiceType (name);
ACE_WRITE_GUARD_THROW_EX (ACE_Lock, ace_mon, *this->lock_, CORBA::INTERNAL ());
// Check if the type exists.
Service_Type_Map::ENTRY* type_entry = 0; ;
if (this->type_map_.find (name,
type_entry) == -1)
throw CosTrading::UnknownServiceType (name);
// Check if it has any subtypes.
Type_Info *type_info = type_entry->int_id_;
if (type_info->has_subtypes_)
throw CosTradingRepos::ServiceTypeRepository::HasSubTypes (name, "");
// Remove the type from the map.
this->type_map_.unbind (type_entry);
delete type_info;
}
void
TAO_Log_i::set_max_record_life (CORBA::ULong life)
{
ACE_WRITE_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
CORBA::ULong old_life =
this->recordstore_->get_max_record_life ();
// @@ The current revision of the specification (formal/03-07-01) is
// unclear whether an AttributeValueChange event should be sent if a
// log attribute was changed (to a new value), or whether the events
// should be sent unconditionally. I have submitted a defect report
// to the OMG for clarification.
//
// In the mean time, we're interepreting it to mean that events are
// only sent when the value has changed.
if (life == old_life)
return;
this->recordstore_->set_max_record_life (life);
if (life != 0)
this->log_compaction_handler_.schedule();
else
this->log_compaction_handler_.cancel();
if (notifier_)
{
notifier_->max_record_life_value_change (this->log_.in (),
this->logid_,
old_life,
life);
}
}
CosTradingRepos::ServiceTypeRepository::IncarnationNumber
TAO_Service_Type_Repository::
add_type (const char *name,
const char *if_name,
const CosTradingRepos::ServiceTypeRepository::PropStructSeq &props,
const CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq &super_types)
{
Prop_Map prop_map;
Service_Type_Map super_map;
ACE_WRITE_GUARD_THROW_EX (ACE_Lock, ace_mon, *this->lock_, CORBA::INTERNAL ());
// Make sure Type name is valid.
if (TAO_Trader_Base::is_valid_identifier_name (name) == 0)
throw CosTrading::IllegalServiceType (name);
// Check if the service type already exists.
CORBA::String_var type_name (name);
if (this->type_map_.find (type_name) == 0)
throw CosTradingRepos::ServiceTypeRepository::ServiceTypeExists ();
// Make sure all property names are valid and appear only once.
this->validate_properties (prop_map,
props);
// Check that all super_types exist, and none are duplicated.
this->validate_supertypes (super_map,
super_types);
// NOTE: I don't really know a way to do this without an Interface
// Repository, since the Interface Repository IDs don't contain
// information about supertypes.
//
// make sure interface name is legal.
// this->validate_interface (if_name, super_types);
//
// Instead, we do this:
//
if (if_name == 0)
throw CosTradingRepos::ServiceTypeRepository::InterfaceTypeMismatch ();
// Collect and make sure that properties of all supertypes and this
// type are compatible. We can use prop_map and super_types_map for
// the job.
this->validate_inheritance (prop_map,
super_types);
// We can now use prop_map to construct a sequence of all properties
// the this type.
this->update_type_map (name,
if_name,
props,
super_types,
prop_map,
super_map);
CosTradingRepos::ServiceTypeRepository::IncarnationNumber return_value =
this->incarnation_;
// Increment incarnation number.
this->incarnation_.low++;
// If we wrapped around in lows...
if (this->incarnation_.low == 0)
this->incarnation_.high++;
return return_value;
}
void
TAO_Log_i::write_recordlist (const DsLogAdmin::RecordList &reclist)
{
ACE_WRITE_GUARD_THROW_EX (ACE_SYNCH_RW_MUTEX,
guard,
this->recordstore_->lock (),
CORBA::INTERNAL ());
DsLogAdmin::LogFullActionType log_full_action =
this->recordstore_->get_log_full_action ();
DsLogAdmin::AdministrativeState admin_state =
this->recordstore_->get_administrative_state ();
// @@ The current revision of the specification (formal/03-07-01)
// does not explicitly specify the preference of exceptions to be
// thrown when multiple error conditions are present.
//
// However, the because log is considered off duty if the log's
// operational state is disabled or its administrative state is
// locked, we handle the LogOffDuty exception last so the more
// specific LogLocked and LogDisabled exceptions will be thrown.
DsLogAdmin::AvailabilityStatus avail_stat =
this->get_availability_status_i ();
if (admin_state == DsLogAdmin::locked)
{
throw DsLogAdmin::LogLocked ();
}
else if (this->op_state_ == DsLogAdmin::disabled)
{
throw DsLogAdmin::LogDisabled ();
}
else if (avail_stat.off_duty == 1)
{
throw DsLogAdmin::LogOffDuty ();
}
CORBA::Short num_written (0);
for (CORBA::ULong i = 0; i < reclist.length (); i++)
{
// retval == 1 => log store reached max size.
int retval = this->recordstore_->log (reclist[i]);
if (retval == 1)
{
// The Log is full . check what the policy is and take
// appropriate action.
if (log_full_action == DsLogAdmin::halt)
{
avail_status_.log_full = 1;
throw DsLogAdmin::LogFull (num_written);
}
// the policy is to wrap. for this we need to delete a few
// records. let the record store decide how many.
if (this->recordstore_->purge_old_records () == -1)
throw CORBA::PERSIST_STORE ();
// Now, we want to attempt to write the same record again
// so decrement the index to balance the inc. in the for loop.
--i;
}
else if (retval == 0)
{
num_written++;
this->check_capacity_alarm_threshold ();
}
else
{
throw CORBA::PERSIST_STORE ();
}
} // for
}
