void
MonitorTestInterface_i::consumer_stats_check()
{
bool foundConsumerStats = false;
Monitor::NameList_var names = nsm_->get_statistic_names ();
CORBA::ULong length = names->length ();
for(CORBA::ULong i = 0; i < length; i++)
{
const char * name = names[i].in ();
size_t slashcount = 0;
bool isConsumerQueueSize = false;
for (size_t nCh = 0; name[nCh] != 0 && slashcount < 3; ++nCh)
{
if (name[nCh] == '/')
{
slashcount += 1;
if(slashcount == 3)
{
isConsumerQueueSize = 0 == ACE_OS::strcmp(
&name[nCh + 1],
NotifyMonitoringExt::EventChannelQueueSize);
}
}
}
if (isConsumerQueueSize)
{
foundConsumerStats = true;
// We have a consumer queue
try
{
Monitor::Data_var queueSizeData =
nsm_->get_statistic(name);
Monitor::Numeric queueSizeNum = queueSizeData->data_union.num ();
ACE_DEBUG ((LM_DEBUG, "Monitor: %s: Average: %f, Maximum: %f, Most recent: %f\n",
name,
queueSizeNum.average, queueSizeNum.maximum, queueSizeNum.last));
if (queueSizeNum.average <= 0.0 || queueSizeNum.average > 2000.0)
ACE_ERROR ((LM_ERROR, "Monitor: ERROR: %s average queue size [%f] should be greater than zero and less than 2000.\n",
name,
queueSizeNum.average));
if (queueSizeNum.last > 2000.0)
ACE_ERROR ((LM_ERROR, "Monitor: ERROR: %s most recent queue size [%f] should not be greater than 2000.\n",
name,
queueSizeNum.last));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (name);
}
}
}
if(! foundConsumerStats)
{
ACE_ERROR ((LM_ERROR, "Monitor: ERROR: No consumer queue size statistics found.\n"
));
}
}
void
MonitorTestInterface_i::stat_dump (const char * statName)
{
try
{
Monitor::Data_var data = nsm_->get_statistic(statName);
switch (data->data_union._d())
{
case Monitor::DATA_NUMERIC:
{
ACE_DEBUG ((LM_DEBUG, "Numeric: %s\n", statName));
Monitor::Numeric num = data->data_union.num();
ACE_DEBUG ((LM_DEBUG, " count: %d, average: %f; sumsq: %f, min: %f, max: %f: last %f\n",
(unsigned int)num.count, num.average, num.sum_of_squares, num.minimum, num.maximum, num.last));
break;
}
default:
{
Monitor::NameList list = data->data_union.list ();
size_t len = list.length ();
ACE_DEBUG ((LM_DEBUG, "Text[%d]: %s\n", (int)len, statName));
for (size_t i = 0; i < len; i++)
{
ACE_CString str = list[i].in ();
ACE_DEBUG ((LM_DEBUG, " %d: %s\n", (int)i, str.c_str()));
}
break;
}
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (statName);
}
}
void
MonitorTestInterface_i::running (MonitorTestInterface::Which proc)
{
ACE_CString str;
Monitor::Data_var data;
Monitor::NameList list;
Monitor::Numeric num;
switch (proc)
{
case MonitorTestInterface::NotifyService:
{
data =
nsm_->get_statistic (NotifyMonitoringExt::EventChannelFactoryNames);
list = data->data_union.list ();
if (list.length () != 1)
{
ACE_ERROR ((LM_ERROR,
"ERROR: There should be only one Event "
"Channel Factory\n"));
}
this->base_ = list[0];
this->base_ += "/";
str = this->base_ + NotifyMonitoringExt::ActiveEventChannelCount;
data = this->nsm_->get_statistic (str.c_str ());
num = data->data_union.num ();
if (!ACE::is_equal (num.dlist[0].value, 0.0))
{
ACE_ERROR ((LM_ERROR,
"ERROR: There should be no active Event "
"Channels\n"));
}
str = this->base_ + NotifyMonitoringExt::InactiveEventChannelCount;
data = this->nsm_->get_statistic (str.c_str ());
num = data->data_union.num ();
if (!ACE::is_equal (num.dlist[0].value, 0.0))
{
ACE_ERROR ((LM_ERROR,
"ERROR: There should be no inactive Event "
"Channels\n"));
}
break;
}
case MonitorTestInterface::Consumer:
{
str = this->base_ + NotifyMonitoringExt::ActiveEventChannelNames;
data = nsm_->get_statistic (str.c_str ());
list = data->data_union.list ();
if (list.length () != 1)
{
ACE_ERROR ((LM_ERROR,
"ERROR: There should be only one active "
"Event Channel\n"));
}
// Base will now be the factory plus the event channel.
this->base_ = list[0];
this->base_ += "/";
str = this->base_ + NotifyMonitoringExt::EventChannelConsumerCount;
data = this->nsm_->get_statistic (str.c_str ());
num = data->data_union.num ();
if (!ACE::is_equal (num.dlist[0].value, 1.0))
ACE_ERROR ((LM_ERROR, "Monitor: ERROR: There should be only one Consumer\n"));
str = this->base_ + NotifyMonitoringExt::EventChannelConsumerAdminCount;
data = nsm_->get_statistic(str.c_str ());
num = data->data_union.num ();
if (!ACE::is_equal (num.dlist[0].value, 1.0))
ACE_ERROR ((LM_ERROR,
"Monitor: ERROR: There should be only one ConsumerAdmin\n"));
str = this->base_ + NotifyMonitoringExt::EventChannelQueueElementCount;
data = nsm_->get_statistic(str.c_str ());
num = data->data_union.num ();
if (!ACE::is_equal (num.dlist[0].value, 0.0))
ACE_ERROR ((LM_ERROR, "Monitor: ERROR: There should be no events queued\n"));
brain_dump ("Running Consumer");
break;
}
case MonitorTestInterface::Supplier:
{
str = this->base_ + NotifyMonitoringExt::EventChannelSupplierCount;
data = nsm_->get_statistic(str.c_str ());
num = data->data_union.num ();
if (!ACE::is_equal (num.dlist[0].value, 1.0))
ACE_ERROR ((LM_ERROR, "Monitor: ERROR: There should be only one Supplier\n"));
str = this->base_ + NotifyMonitoringExt::EventChannelSupplierAdminCount;
data = nsm_->get_statistic(str.c_str ());
num = data->data_union.num ();
if (!ACE::is_equal (num.dlist[0].value, 1.0))
ACE_ERROR ((LM_ERROR,
"Monitor: ERROR: There should be only one SupplierAdmin\n"));
brain_dump ("Running Supplier");
break;
}
default:
ACE_ERROR ((LM_ERROR, "Monitor: ERROR: Impossible enum value %d\n", proc));
break;
}
}
void
MonitorTestInterface_i::finished (MonitorTestInterface::Which proc)
{
// ACE_CString str;
// Monitor::Data_var data;
// Monitor::NameList list;
// Monitor::Numeric num;
switch (proc)
{
case MonitorTestInterface::NotifyService:
ACE_ERROR ((LM_ERROR, "This should not be called\n"));
break;
case MonitorTestInterface::Consumer:
// By the time the consumer finishes, it should have destroyed
// the event channel.
this->running (MonitorTestInterface::NotifyService);
break;
case MonitorTestInterface::Supplier:
{
ACE_CString consumerCountName = this->base_ + NotifyMonitoringExt::EventChannelConsumerCount;
Monitor::Data_var consumerCountData =
nsm_->get_statistic(consumerCountName.c_str ());
Monitor::Numeric consumerCountNum =
consumerCountData->data_union.num ();
if (!ACE::is_equal (consumerCountNum.last, 1.0))
ACE_ERROR ((LM_ERROR, "Monitor: ERROR: There should still be one Consumer\n"));
ACE_CString queueElementName = this->base_ + NotifyMonitoringExt::EventChannelQueueElementCount;
Monitor::Data_var queueElementData =
nsm_->get_statistic(queueElementName.c_str ());
Monitor::Numeric queueElementNum =
queueElementData->data_union.num ();
if (ACE::is_equal (queueElementNum.last, 0.0))
ACE_ERROR ((LM_ERROR, "Monitor: ERROR: There should be at least one "
"event queued\n"));
ACE_CString adminNamesName = this->base_ + NotifyMonitoringExt::EventChannelConsumerAdminNames;
Monitor::Data_var adminNamesData =
nsm_->get_statistic(adminNamesName.c_str ());
Monitor::NameList nameList =
adminNamesData->data_union.list ();
for (CORBA::ULong i = 0; i < nameList.length (); i++)
{
ACE_CString queueSizeName = nameList[i].in ();
queueSizeName += "/";
queueSizeName += NotifyMonitoringExt::EventChannelQueueSize;
Monitor::Data_var queueSizeData =
nsm_->get_statistic(queueSizeName.c_str ());
Monitor::Numeric queueSizeNum =
queueSizeData->data_union.num ();
ACE_DEBUG ((LM_DEBUG, "Monitor: Queue Size: Average: %f, Maximum: %f, Most recent: %f\n",
queueSizeNum.average, queueSizeNum.maximum, queueSizeNum.last));
if (queueSizeNum.average <= 0.0 || queueSizeNum.average > 2000.0)
ACE_ERROR ((LM_ERROR, "Monitor: ERROR: The average queue size [%f] should be greater than zero and less than 2000.\n",
queueSizeNum.average));
if (queueSizeNum.last > 2000.0)
ACE_ERROR ((LM_ERROR, "Monitor: ERROR: The most recent queue size [%f] should not be greater than 2000.\n",
queueSizeNum.last));
}
consumer_stats_check();
brain_dump ("Finished Supplier");
break;
}
default:
ACE_ERROR ((LM_ERROR, "Impossible enum value %d\n", proc));
break;
}
}