void
TestIntfI::opOutArrayByteSeqAsync(Test::ByteSeq in,
std::function<void (const std::pair<const Ice::Byte*, const Ice::Byte*>&)> response,
std::function<void (std::exception_ptr)>, const Ice::Current&)
{
response(std::make_pair(in.data(), in.data() + in.size()));
}
void
TestIntfI::opOutRangeByteSeq_async(const Test::AMD_TestIntf_opOutRangeByteSeqPtr& cb,
const Test::ByteSeq& inS,
const Ice::Current&)
{
cb->ice_response(std::pair<Test::ByteSeq::const_iterator,
Test::ByteSeq::const_iterator>(inS.begin(), inS.end()));
}
void
TestIntfI::opOutRangeByteSeqAsync(Test::ByteSeq in,
std::function<void (const std::pair<Test::ByteSeq::const_iterator,
Test::ByteSeq::const_iterator>&)> response,
std::function<void (std::exception_ptr)>, const Ice::Current&)
{
response(std::make_pair(in.begin(), in.end()));
}
void
TestIntfI::opOutArrayByteSeq_async(const Test::AMD_TestIntf_opOutArrayByteSeqPtr& cb,
const Test::ByteSeq& inS,
const Ice::Current&)
{
cb->ice_response(std::pair<const Ice::Byte*,
const Ice::Byte*>(&inS[0], &inS[0] + inS.size()));
}
MetricsPrx
allTests(const Ice::CommunicatorPtr& communicator, const CommunicatorObserverIPtr& obsv)
{
MetricsPrx metrics = MetricsPrx::checkedCast(communicator->stringToProxy("metrics:default -p 12010"));
cout << "testing metrics admin facet checkedCast... " << flush;
Ice::ObjectPrx admin = communicator->getAdmin()->ice_collocationOptimized(false);
Ice::PropertiesAdminPrx clientProps = Ice::PropertiesAdminPrx::checkedCast(admin, "Properties");
IceMX::MetricsAdminPrx clientMetrics = IceMX::MetricsAdminPrx::checkedCast(admin, "Metrics");
test(clientProps && clientMetrics);
admin = metrics->getAdmin();
Ice::PropertiesAdminPrx serverProps = Ice::PropertiesAdminPrx::checkedCast(admin, "Properties");
IceMX::MetricsAdminPrx serverMetrics = IceMX::MetricsAdminPrx::checkedCast(admin, "Metrics");
test(serverProps && serverMetrics);
UpdateCallbackI* update = new UpdateCallbackI(serverProps);
Ice::NativePropertiesAdminPtr::dynamicCast(communicator->findAdminFacet("Properties"))->addUpdateCallback(update);
cout << "ok" << endl;
Ice::PropertyDict props;
cout << "testing group by none..." << flush;
props["IceMX.Metrics.View.GroupBy"] = "none";
updateProps(clientProps, serverProps, update, props);
#ifndef ICE_OS_WINRT
int threadCount = 4;
#else
int threadCount = 3; // No endpoint host resolver thread with WinRT.
#endif
Ice::Long timestamp;
IceMX::MetricsView view = clientMetrics->getMetricsView("View", timestamp);
test(view["Connection"].size() == 1 && view["Connection"][0]->current == 1 && view["Connection"][0]->total == 1);
test(view["Thread"].size() == 1 && view["Thread"][0]->current == threadCount &&
view["Thread"][0]->total == threadCount);
cout << "ok" << endl;
cout << "testing group by id..." << flush;
props["IceMX.Metrics.View.GroupBy"] = "id";
updateProps(clientProps, serverProps, update, props);
metrics->ice_ping();
metrics->ice_ping();
metrics->ice_connectionId("Con1")->ice_ping();
metrics->ice_connectionId("Con1")->ice_ping();
metrics->ice_connectionId("Con1")->ice_ping();
view = clientMetrics->getMetricsView("View", timestamp);
test(static_cast<int>(view["Thread"].size()) == threadCount);
test(view["Connection"].size() == 2);
test(view["Invocation"].size() == 1);
IceMX::InvocationMetricsPtr invoke = IceMX::InvocationMetricsPtr::dynamicCast(view["Invocation"][0]);
test(invoke->id.find("[ice_ping]") > 0 && invoke->current == 0 && invoke->total == 5);
test(invoke->remotes.size() == 2);
test(invoke->remotes[0]->total = 2);
test(invoke->remotes[1]->total = 3);
view = serverMetrics->getMetricsView("View", timestamp);
test(view["Thread"].size() > 4);
test(view["Connection"].size() == 2);
test(view["Dispatch"].size() == 1);
test(view["Dispatch"][0]->current <= 1 && view["Dispatch"][0]->total == 5);
test(view["Dispatch"][0]->id.find("[ice_ping]") > 0);
metrics->ice_getConnection()->close(false);
metrics->ice_connectionId("Con1")->ice_getConnection()->close(false);
waitForCurrent(clientMetrics, "View", "Connection", 0);
waitForCurrent(serverMetrics, "View", "Connection", 0);
clearView(clientProps, serverProps, update);
cout << "ok" << endl;
cout << "testing connection metrics... " << flush;
props["IceMX.Metrics.View.Map.Connection.GroupBy"] = "none";
updateProps(clientProps, serverProps, update, props, "Connection");
test(clientMetrics->getMetricsView("View", timestamp)["Connection"].empty());
test(serverMetrics->getMetricsView("View", timestamp)["Connection"].empty());
metrics->ice_ping();
IceMX::ConnectionMetricsPtr cm1, sm1, cm2, sm2;
cm1 = IceMX::ConnectionMetricsPtr::dynamicCast(clientMetrics->getMetricsView("View", timestamp)["Connection"][0]);
sm1 = IceMX::ConnectionMetricsPtr::dynamicCast(serverMetrics->getMetricsView("View", timestamp)["Connection"][0]);
sm1 = getServerConnectionMetrics(serverMetrics, 25);
test(cm1->total == 1 && sm1->total == 1);
metrics->ice_ping();
cm2 = IceMX::ConnectionMetricsPtr::dynamicCast(clientMetrics->getMetricsView("View", timestamp)["Connection"][0]);
sm2 = getServerConnectionMetrics(serverMetrics, 50);
test(cm2->sentBytes - cm1->sentBytes == 45); // 45 for ice_ping request
test(cm2->receivedBytes - cm1->receivedBytes == 25); // 25 bytes for ice_ping response
test(sm2->receivedBytes - sm1->receivedBytes == 45);
test(sm2->sentBytes - sm1->sentBytes == 25);
cm1 = cm2;
sm1 = sm2;
Test::ByteSeq bs;
metrics->opByteS(bs);
cm2 = IceMX::ConnectionMetricsPtr::dynamicCast(clientMetrics->getMetricsView("View", timestamp)["Connection"][0]);
sm2 = getServerConnectionMetrics(serverMetrics, sm1->sentBytes + cm2->receivedBytes - cm1->receivedBytes);
Ice::Long requestSz = cm2->sentBytes - cm1->sentBytes;
Ice::Long replySz = cm2->receivedBytes - cm1->receivedBytes;
cm1 = cm2;
sm1 = sm2;
bs.resize(456);
metrics->opByteS(bs);
cm2 = IceMX::ConnectionMetricsPtr::dynamicCast(clientMetrics->getMetricsView("View", timestamp)["Connection"][0]);
sm2 = getServerConnectionMetrics(serverMetrics, sm1->sentBytes + replySz);
// 4 is for the seq variable size
test(cm2->sentBytes - cm1->sentBytes == requestSz + static_cast<int>(bs.size()) + 4);
test(cm2->receivedBytes - cm1->receivedBytes == replySz);
test(sm2->receivedBytes - sm1->receivedBytes == requestSz + static_cast<int>(bs.size()) + 4);
test(sm2->sentBytes - sm1->sentBytes == replySz);
cm1 = cm2;
sm1 = sm2;
bs.resize(1024 * 1024 * 10); // Try with large amount of data which should be sent in several chunks
metrics->opByteS(bs);
cm2 = IceMX::ConnectionMetricsPtr::dynamicCast(clientMetrics->getMetricsView("View", timestamp)["Connection"][0]);
sm2 = getServerConnectionMetrics(serverMetrics, sm1->sentBytes + replySz);
// 4 is for the seq variable size
test(cm2->sentBytes - cm1->sentBytes == requestSz + static_cast<int>(bs.size()) + 4);
test(cm2->receivedBytes - cm1->receivedBytes == replySz);
test(sm2->receivedBytes - sm1->receivedBytes == requestSz + static_cast<int>(bs.size()) + 4);
test(sm2->sentBytes - sm1->sentBytes == replySz);
props["IceMX.Metrics.View.Map.Connection.GroupBy"] = "state";
updateProps(clientProps, serverProps, update, props, "Connection");
map<string, IceMX::MetricsPtr> map;
map = toMap(serverMetrics->getMetricsView("View", timestamp)["Connection"]);
test(map["active"]->current == 1);
ControllerPrx controller = ControllerPrx::checkedCast(communicator->stringToProxy("controller:default -p 12011"));
controller->hold();
map = toMap(clientMetrics->getMetricsView("View", timestamp)["Connection"]);
test(map["active"]->current == 1);
map = toMap(serverMetrics->getMetricsView("View", timestamp)["Connection"]);
test(map["holding"]->current == 1);
metrics->ice_getConnection()->close(false);
map = toMap(clientMetrics->getMetricsView("View", timestamp)["Connection"]);
test(map["closing"]->current == 1);
map = toMap(serverMetrics->getMetricsView("View", timestamp)["Connection"]);
test(map["holding"]->current == 1);
controller->resume();
map = toMap(serverMetrics->getMetricsView("View", timestamp)["Connection"]);
test(map["holding"]->current == 0);
props["IceMX.Metrics.View.Map.Connection.GroupBy"] = "none";
updateProps(clientProps, serverProps, update, props, "Connection");
metrics->ice_getConnection()->close(false);
metrics->ice_timeout(500)->ice_ping();
controller->hold();
try
{
metrics->ice_timeout(500)->ice_ping();
test(false);
}
catch(const Ice::TimeoutException&)
{
}
controller->resume();
cm1 = IceMX::ConnectionMetricsPtr::dynamicCast(clientMetrics->getMetricsView("View", timestamp)["Connection"][0]);
while(true)
{
sm1 = IceMX::ConnectionMetricsPtr::dynamicCast(
serverMetrics->getMetricsView("View", timestamp)["Connection"][0]);
if(sm1-> failures >= 2)
{
break;
}
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10));
}
test(cm1->failures == 2 && sm1->failures >= 1);
checkFailure(clientMetrics, "Connection", cm1->id, "Ice::TimeoutException", 1);
checkFailure(clientMetrics, "Connection", cm1->id, "Ice::ConnectTimeoutException", 1);
checkFailure(serverMetrics, "Connection", sm1->id, "Ice::ConnectionLostException");
MetricsPrx m = metrics->ice_timeout(500)->ice_connectionId("Con1");
m->ice_ping();
testAttribute(clientMetrics, clientProps, update, "Connection", "parent", "Communicator");
//testAttribute(clientMetrics, clientProps, update, "Connection", "id", "");
testAttribute(clientMetrics, clientProps, update, "Connection", "endpoint", "tcp -h 127.0.0.1 -p 12010 -t 500");
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointType", "1");
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointIsDatagram", "false");
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointIsSecure", "false");
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointTimeout", "500");
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointCompress", "false");
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointHost", "127.0.0.1");
testAttribute(clientMetrics, clientProps, update, "Connection", "endpointPort", "12010");
testAttribute(clientMetrics, clientProps, update, "Connection", "incoming", "false");
testAttribute(clientMetrics, clientProps, update, "Connection", "adapterName", "");
testAttribute(clientMetrics, clientProps, update, "Connection", "connectionId", "Con1");
testAttribute(clientMetrics, clientProps, update, "Connection", "localHost", "127.0.0.1");
//testAttribute(clientMetrics, clientProps, update, "Connection", "localPort", "");
testAttribute(clientMetrics, clientProps, update, "Connection", "remoteHost", "127.0.0.1");
testAttribute(clientMetrics, clientProps, update, "Connection", "remotePort", "12010");
testAttribute(clientMetrics, clientProps, update, "Connection", "mcastHost", "");
testAttribute(clientMetrics, clientProps, update, "Connection", "mcastPort", "");
m->ice_getConnection()->close(false);
waitForCurrent(clientMetrics, "View", "Connection", 0);
waitForCurrent(serverMetrics, "View", "Connection", 0);
cout << "ok" << endl;
cout << "testing connection establishment metrics... " << flush;
props["IceMX.Metrics.View.Map.ConnectionEstablishment.GroupBy"] = "id";
updateProps(clientProps, serverProps, update, props, "ConnectionEstablishment");
test(clientMetrics->getMetricsView("View", timestamp)["ConnectionEstablishment"].empty());
metrics->ice_ping();
test(clientMetrics->getMetricsView("View", timestamp)["ConnectionEstablishment"].size() == 1);
IceMX::MetricsPtr m1 = clientMetrics->getMetricsView("View", timestamp)["ConnectionEstablishment"][0];
test(m1->current == 0 && m1->total == 1 && m1->id == "127.0.0.1:12010");
metrics->ice_getConnection()->close(false);
controller->hold();
try
{
communicator->stringToProxy("test:tcp -p 12010 -h 127.0.0.1")->ice_timeout(10)->ice_ping();
test(false);
}
catch(const Ice::ConnectTimeoutException&)
{
}
catch(const Ice::LocalException&)
{
test(false);
}
controller->resume();
test(clientMetrics->getMetricsView("View", timestamp)["ConnectionEstablishment"].size() == 1);
m1 = clientMetrics->getMetricsView("View", timestamp)["ConnectionEstablishment"][0];
test(m1->id == "127.0.0.1:12010" && m1->total == 3 && m1->failures == 2);
checkFailure(clientMetrics, "ConnectionEstablishment", m1->id, "Ice::ConnectTimeoutException", 2);
Connect c(metrics);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "parent", "Communicator", c);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "id", "127.0.0.1:12010", c);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpoint",
"tcp -h 127.0.0.1 -p 12010", c);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointType", "1", c);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointIsDatagram", "false", c);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointIsSecure", "false", c);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointTimeout", "-1", c);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointCompress", "false", c);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointHost", "127.0.0.1", c);
testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointPort", "12010", c);
cout << "ok" << endl;
//
// Ice doesn't do any endpoint lookup with WinRT, the WinRT
// runtime takes care of if.
//
#ifndef ICE_OS_WINRT
cout << "testing endpoint lookup metrics... " << flush;
props["IceMX.Metrics.View.Map.ConnectionEstablishment.GroupBy"] = "id";
updateProps(clientProps, serverProps, update, props, "EndpointLookup");
test(clientMetrics->getMetricsView("View", timestamp)["EndpointLookup"].empty());
Ice::ObjectPrx prx = communicator->stringToProxy("metrics:default -p 12010 -h localhost");
prx->ice_ping();
test(clientMetrics->getMetricsView("View", timestamp)["EndpointLookup"].size() == 1);
m1 = clientMetrics->getMetricsView("View", timestamp)["EndpointLookup"][0];
test(m1->current <= 1 && m1->total == 1 && m1->id == "tcp -h localhost -p 12010");
prx->ice_getConnection()->close(false);
bool dnsException = false;
try
{
communicator->stringToProxy("test:tcp -t 500 -p 12010 -h unknownfoo.zeroc.com")->ice_ping();
test(false);
}
catch(const Ice::DNSException&)
{
dnsException = true;
}
catch(const Ice::LocalException&)
{
// Some DNS servers don't fail on unknown DNS names.
}
test(clientMetrics->getMetricsView("View", timestamp)["EndpointLookup"].size() == 2);
m1 = clientMetrics->getMetricsView("View", timestamp)["EndpointLookup"][1];
test(m1->id == "tcp -h unknownfoo.zeroc.com -p 12010 -t 500" && m1->total == 2 &&
(!dnsException || m1->failures == 2));
if(dnsException)
{
checkFailure(clientMetrics, "EndpointLookup", m1->id, "Ice::DNSException", 2);
}
c = Connect(prx);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "parent", "Communicator", c);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "id", "tcp -h localhost -p 12010", c);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpoint",
"tcp -h localhost -p 12010", c);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointType", "1", c);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointIsDatagram", "false", c);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointIsSecure", "false", c);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointTimeout", "-1", c);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointCompress", "false", c);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointHost", "localhost", c);
testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointPort", "12010", c);
cout << "ok" << endl;
#endif
cout << "testing dispatch metrics... " << flush;
props["IceMX.Metrics.View.Map.Dispatch.GroupBy"] = "operation";
updateProps(clientProps, serverProps, update, props, "Dispatch");
test(serverMetrics->getMetricsView("View", timestamp)["Dispatch"].empty());
metrics->op();
try
{
metrics->opWithUserException();
test(false);
}
catch(const Test::UserEx&)
{
}
try
{
metrics->opWithRequestFailedException();
test(false);
}
catch(const Ice::RequestFailedException&)
{
}
try
{
metrics->opWithLocalException();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
metrics->opWithUnknownException();
test(false);
}
catch(const Ice::UnknownException&)
{
}
try
{
metrics->fail();
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
map = toMap(serverMetrics->getMetricsView("View", timestamp)["Dispatch"]);
test(map.size() == 6);
IceMX::DispatchMetricsPtr dm1 = IceMX::DispatchMetricsPtr::dynamicCast(map["op"]);
test(dm1->current <= 1 && dm1->total == 1 && dm1->failures == 0 && dm1->userException == 0);
test(dm1->size == 21 && dm1->replySize == 7);
dm1 = IceMX::DispatchMetricsPtr::dynamicCast(map["opWithUserException"]);
test(dm1->current <= 1 && dm1->total == 1 && dm1->failures == 0 && dm1->userException == 1);
test(dm1->size == 38 && dm1->replySize == 23);
dm1 = IceMX::DispatchMetricsPtr::dynamicCast(map["opWithLocalException"]);
test(dm1->current <= 1 && dm1->total == 1 && dm1->failures == 1 && dm1->userException == 0);
checkFailure(serverMetrics, "Dispatch", dm1->id, "Ice::SyscallException", 1);
test(dm1->size == 39 && dm1->replySize > 7); // Reply contains the exception stack depending on the OS.
dm1 = IceMX::DispatchMetricsPtr::dynamicCast(map["opWithRequestFailedException"]);
test(dm1->current <= 1 && dm1->total == 1 && dm1->failures == 1 && dm1->userException == 0);
checkFailure(serverMetrics, "Dispatch", dm1->id, "Ice::ObjectNotExistException", 1);
test(dm1->size == 47 && dm1->replySize == 40);
dm1 = IceMX::DispatchMetricsPtr::dynamicCast(map["opWithUnknownException"]);
test(dm1->current <= 1 && dm1->total == 1 && dm1->failures == 1 && dm1->userException == 0);
checkFailure(serverMetrics, "Dispatch", dm1->id, "unknown", 1);
test(dm1->size == 41 && dm1->replySize == 23);
InvokeOp op(metrics);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "parent", "TestAdapter", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "id", "metrics [op]", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpoint", "tcp -h 127.0.0.1 -p 12010", op);
//testAttribute(serverMetrics, serverProps, update, "Dispatch", "connection", "", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointType", "1", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointIsDatagram", "false", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointIsSecure", "false", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointTimeout", "-1", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointCompress", "false", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointHost", "127.0.0.1", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointPort", "12010", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "incoming", "true", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "adapterName", "TestAdapter", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "connectionId", "", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "localHost", "127.0.0.1", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "localPort", "12010", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "remoteHost", "127.0.0.1", op);
//testAttribute(serverMetrics, serverProps, update, "Dispatch", "remotePort", "12010", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "mcastHost", "", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "mcastPort", "", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "operation", "op", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "identity", "metrics", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "facet", "", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "mode", "twoway", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "context.entry1", "test", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "context.entry2", "", op);
testAttribute(serverMetrics, serverProps, update, "Dispatch", "context.entry3", "", op);
cout << "ok" << endl;
cout << "testing invocation metrics... " << flush;
props["IceMX.Metrics.View.Map.Invocation.GroupBy"] = "operation";
props["IceMX.Metrics.View.Map.Invocation.Map.Remote.GroupBy"] = "localPort";
updateProps(clientProps, serverProps, update, props, "Invocation");
test(serverMetrics->getMetricsView("View", timestamp)["Invocation"].empty());
CallbackPtr cb = new Callback();
metrics->op();
metrics->end_op(metrics->begin_op());
metrics->begin_op(newCallback_Metrics_op(cb, &Callback::response, &Callback::exception));
cb->waitForResponse();
// User exception
try
{
metrics->opWithUserException();
test(false);
}
catch(const Test::UserEx&)
{
}
try
{
metrics->end_opWithUserException(metrics->begin_opWithUserException());
test(false);
}
catch(const Test::UserEx&)
{
}
metrics->begin_opWithUserException(newCallback_Metrics_opWithUserException(
cb, &Callback::response, &Callback::exception));
cb->waitForResponse();
// Request failed exception
try
{
metrics->opWithRequestFailedException();
test(false);
}
catch(const Ice::RequestFailedException&)
{
}
try
{
metrics->end_opWithRequestFailedException(metrics->begin_opWithRequestFailedException());
test(false);
}
catch(const Ice::RequestFailedException&)
{
}
metrics->begin_opWithRequestFailedException(newCallback_Metrics_opWithRequestFailedException(
cb, &Callback::response, &Callback::exception));
cb->waitForResponse();
// Local exception
try
{
metrics->opWithLocalException();
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
metrics->end_opWithLocalException(metrics->begin_opWithLocalException());
test(false);
}
catch(const Ice::LocalException&)
{
}
metrics->begin_opWithLocalException(newCallback_Metrics_opWithLocalException(
cb, &Callback::response, &Callback::exception));
cb->waitForResponse();
// Unknown exception
try
{
metrics->opWithUnknownException();
test(false);
}
catch(const Ice::UnknownException&)
{
}
try
{
metrics->end_opWithUnknownException(metrics->begin_opWithUnknownException());
test(false);
}
catch(const Ice::UnknownException&)
{
}
metrics->begin_opWithUnknownException(newCallback_Metrics_opWithUnknownException(
cb, &Callback::response, &Callback::exception));
cb->waitForResponse();
// Fail
try
{
metrics->fail();
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
try
{
metrics->end_fail(metrics->begin_fail());
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
metrics->begin_fail(newCallback_Metrics_fail(cb, &Callback::response, &Callback::exception));
cb->waitForResponse();
map = toMap(clientMetrics->getMetricsView("View", timestamp)["Invocation"]);
test(map.size() == 6);
IceMX::InvocationMetricsPtr im1;
IceMX::RemoteMetricsPtr rim1;
im1 = IceMX::InvocationMetricsPtr::dynamicCast(map["op"]);
test(im1->current <= 1 && im1->total == 3 && im1->failures == 0 && im1->retry == 0 && im1->remotes.size() == 1);
rim1 = IceMX::RemoteMetricsPtr::dynamicCast(im1->remotes[0]);
test(rim1->current == 0 && rim1->total == 3 && rim1->failures == 0);
test(rim1->size == 63 && rim1->replySize == 21);
im1 = IceMX::InvocationMetricsPtr::dynamicCast(map["opWithUserException"]);
test(im1->current <= 1 && im1->total == 3 && im1->failures == 0 && im1->retry == 0 && im1->remotes.size() == 1);
rim1 = IceMX::RemoteMetricsPtr::dynamicCast(im1->remotes[0]);
test(rim1->current == 0 && rim1->total == 3 && rim1->failures == 0);
test(rim1->size == 114 && rim1->replySize == 69);
test(im1->userException == 3);
im1 = IceMX::InvocationMetricsPtr::dynamicCast(map["opWithLocalException"]);
test(im1->current <= 1 && im1->total == 3 && im1->failures == 3 && im1->retry == 0 && im1->remotes.size() == 1);
rim1 = IceMX::RemoteMetricsPtr::dynamicCast(im1->remotes[0]);
test(rim1->current == 0 && rim1->total == 3 && rim1->failures == 0);
test(rim1->size == 117 && rim1->replySize > 7);
checkFailure(clientMetrics, "Invocation", im1->id, "Ice::UnknownLocalException", 3);
im1 = IceMX::InvocationMetricsPtr::dynamicCast(map["opWithRequestFailedException"]);
test(im1->current <= 1 && im1->total == 3 && im1->failures == 3 && im1->retry == 0 && im1->remotes.size() == 1);
rim1 = IceMX::RemoteMetricsPtr::dynamicCast(im1->remotes[0]);
test(rim1->current == 0 && rim1->total == 3 && rim1->failures == 0);
test(rim1->size == 141 && rim1->replySize == 120);
checkFailure(clientMetrics, "Invocation", im1->id, "Ice::ObjectNotExistException", 3);
im1 = IceMX::InvocationMetricsPtr::dynamicCast(map["opWithUnknownException"]);
test(im1->current <= 1 && im1->total == 3 && im1->failures == 3 && im1->retry == 0 && im1->remotes.size() == 1);
rim1 = IceMX::RemoteMetricsPtr::dynamicCast(im1->remotes[0]);
test(rim1->current == 0 && rim1->total == 3 && rim1->failures == 0);
test(rim1->size == 123 && rim1->replySize == 69);
checkFailure(clientMetrics, "Invocation", im1->id, "Ice::UnknownException", 3);
im1 = IceMX::InvocationMetricsPtr::dynamicCast(map["fail"]);
test(im1->current <= 1 && im1->total == 3 && im1->failures == 3 && im1->retry == 3 && im1->remotes.size() == 6);
test(im1->remotes[0]->current == 0 && im1->remotes[0]->total == 1 && im1->remotes[0]->failures == 1);
test(im1->remotes[1]->current == 0 && im1->remotes[1]->total == 1 && im1->remotes[1]->failures == 1);
test(im1->remotes[2]->current == 0 && im1->remotes[2]->total == 1 && im1->remotes[2]->failures == 1);
test(im1->remotes[3]->current == 0 && im1->remotes[3]->total == 1 && im1->remotes[3]->failures == 1);
test(im1->remotes[4]->current == 0 && im1->remotes[4]->total == 1 && im1->remotes[4]->failures == 1);
test(im1->remotes[5]->current == 0 && im1->remotes[5]->total == 1 && im1->remotes[5]->failures == 1);
checkFailure(clientMetrics, "Invocation", im1->id, "Ice::ConnectionLostException", 3);
testAttribute(clientMetrics, clientProps, update, "Invocation", "parent", "Communicator", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "id", "metrics -t -e 1.1 [op]", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "operation", "op", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "identity", "metrics", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "facet", "", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "encoding", "1.1", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "mode", "twoway", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "proxy",
"metrics -t -e 1.1:tcp -h 127.0.0.1 -p 12010", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "context.entry1", "test", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "context.entry2", "", op);
testAttribute(clientMetrics, clientProps, update, "Invocation", "context.entry3", "", op);
cout << "ok" << endl;
cout << "testing metrics view enable/disable..." << flush;
Ice::StringSeq disabledViews;
props["IceMX.Metrics.View.GroupBy"] = "none";
props["IceMX.Metrics.View.Disabled"] = "0";
updateProps(clientProps, serverProps, update, props, "Thread");
test(!clientMetrics->getMetricsView("View", timestamp)["Thread"].empty());
test(clientMetrics->getMetricsViewNames(disabledViews).size() == 1 && disabledViews.empty());
props["IceMX.Metrics.View.Disabled"] = "1";
updateProps(clientProps, serverProps, update, props, "Thread");
test(clientMetrics->getMetricsView("View", timestamp)["Thread"].empty());
test(clientMetrics->getMetricsViewNames(disabledViews).empty() && disabledViews.size() == 1);
clientMetrics->enableMetricsView("View");
test(!clientMetrics->getMetricsView("View", timestamp)["Thread"].empty());
test(clientMetrics->getMetricsViewNames(disabledViews).size() == 1 && disabledViews.empty());
clientMetrics->disableMetricsView("View");
test(clientMetrics->getMetricsView("View", timestamp)["Thread"].empty());
test(clientMetrics->getMetricsViewNames(disabledViews).empty() && disabledViews.size() == 1);
try
{
clientMetrics->enableMetricsView("UnknownView");
}
catch(const IceMX::UnknownMetricsView&)
{
}
cout << "ok" << endl;
cout << "testing instrumentation observer delegate... " << flush;
test(obsv->threadObserver->getTotal() > 0);
test(obsv->connectionObserver->getTotal() > 0);
test(obsv->connectionEstablishmentObserver->getTotal() > 0);
#ifndef ICE_OS_WINRT
test(obsv->endpointLookupObserver->getTotal() > 0);
#endif
test(obsv->dispatchObserver->getTotal() > 0);
test(obsv->invocationObserver->getTotal() > 0);
test(obsv->invocationObserver->remoteObserver->getTotal() > 0);
test(obsv->threadObserver->getCurrent() > 0);
test(obsv->connectionObserver->getCurrent() > 0);
test(obsv->connectionEstablishmentObserver->getCurrent() == 0);
#ifndef ICE_OS_WINRT
test(obsv->endpointLookupObserver->getCurrent() == 0);
#endif
test(obsv->dispatchObserver->getCurrent() == 0);
test(obsv->invocationObserver->getCurrent() == 0);
test(obsv->invocationObserver->remoteObserver->getCurrent() == 0);
test(obsv->threadObserver->getFailedCount() == 0);
test(obsv->connectionObserver->getFailedCount() > 0);
test(obsv->connectionEstablishmentObserver->getFailedCount() > 0);
#ifndef ICE_OS_WINRT
test(obsv->endpointLookupObserver->getFailedCount() > 0);
#endif
//test(obsv->dispatchObserver->getFailedCount() > 0);
test(obsv->invocationObserver->getFailedCount() > 0);
test(obsv->invocationObserver->remoteObserver->getFailedCount() > 0);
test(obsv->threadObserver->states > 0);
test(obsv->connectionObserver->received > 0 && obsv->connectionObserver->sent > 0);
//test(obsv->dispatchObserver->userExceptionCount > 0);
test(obsv->invocationObserver->userExceptionCount > 0 && obsv->invocationObserver->retriedCount > 0);
test(obsv->invocationObserver->remoteObserver->replySize > 0);
cout << "ok" << endl;
return metrics;
}
void
allTests(const CommunicatorPtr& communicator)
{
communicator->getProperties()->setProperty("ReplyAdapter.Endpoints", "udp -p 12030");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("ReplyAdapter");
PingReplyIPtr replyI = new PingReplyI;
PingReplyPrx reply = PingReplyPrx::uncheckedCast(adapter->addWithUUID(replyI))->ice_datagram();
adapter->activate();
cout << "testing udp... " << flush;
ObjectPrx base = communicator->stringToProxy("test -d:udp -p 12010");
TestIntfPrx obj = TestIntfPrx::uncheckedCast(base);
int nRetry = 5;
bool ret;
while(nRetry-- > 0)
{
replyI->reset();
obj->ping(reply);
obj->ping(reply);
obj->ping(reply);
ret = replyI->waitReply(3, IceUtil::Time::seconds(2));
if(ret)
{
break; // Success
}
// If the 3 datagrams were not received within the 2 seconds, we try again to
// receive 3 new datagrams using a new object. We give up after 5 retries.
replyI = new PingReplyI;
reply = PingReplyPrx::uncheckedCast(adapter->addWithUUID(replyI))->ice_datagram();
}
test(ret);
if(communicator->getProperties()->getPropertyAsInt("Ice.Override.Compress") == 0)
{
//
// Only run this test if compression is disabled, the test expect fixed message size
// to be sent over the wire.
//
Test::ByteSeq seq;
try
{
seq.resize(1024);
while(true)
{
seq.resize(seq.size() * 2 + 10);
replyI->reset();
obj->sendByteSeq(seq, reply);
replyI->waitReply(1, IceUtil::Time::seconds(10));
}
}
catch(const DatagramLimitException&)
{
test(seq.size() > 16384);
}
obj->ice_getConnection()->close(false);
communicator->getProperties()->setProperty("Ice.UDP.SndSize", "64000");
seq.resize(50000);
try
{
replyI->reset();
obj->sendByteSeq(seq, reply);
test(!replyI->waitReply(1, IceUtil::Time::milliSeconds(500)));
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
}
cout << "ok" << endl;
string endpoint;
if(communicator->getProperties()->getProperty("Ice.IPv6") == "1")
{
#ifdef __APPLE__
endpoint = "udp -h \"ff15::1:1\" -p 12020 --interface \"::1\"";
#else
endpoint = "udp -h \"ff15::1:1\" -p 12020";
#endif
}
else
{
endpoint = "udp -h 239.255.1.1 -p 12020";
}
base = communicator->stringToProxy("test -d:" + endpoint);
TestIntfPrx objMcast = TestIntfPrx::uncheckedCast(base);
#if !defined(ICE_OS_WINRT) && (!defined(__APPLE__) || (defined(__APPLE__) && !TARGET_OS_IPHONE))
cout << "testing udp multicast... " << flush;
nRetry = 5;
while(nRetry-- > 0)
{
replyI->reset();
objMcast->ping(reply);
ret = replyI->waitReply(5, IceUtil::Time::seconds(2));
if(ret)
{
break; // Success
}
replyI = new PingReplyI;
reply = PingReplyPrx::uncheckedCast(adapter->addWithUUID(replyI))->ice_datagram();
}
if(!ret)
{
cout << "failed (is a firewall enabled?)" << endl;
}
else
{
cout << "ok" << endl;
}
#endif
cout << "testing udp bi-dir connection... " << flush;
obj->ice_getConnection()->setAdapter(adapter);
objMcast->ice_getConnection()->setAdapter(adapter);
nRetry = 5;
while(nRetry-- > 0)
{
replyI->reset();
obj->pingBiDir(reply->ice_getIdentity());
obj->pingBiDir(reply->ice_getIdentity());
obj->pingBiDir(reply->ice_getIdentity());
ret = replyI->waitReply(3, IceUtil::Time::seconds(2));
if(ret)
{
break; // Success
}
// If the 3 datagrams were not received within the 2 seconds, we try again to
// receive 3 new datagrams using a new object. We give up after 5 retries.
replyI = new PingReplyI;
reply = PingReplyPrx::uncheckedCast(adapter->addWithUUID(replyI))->ice_datagram();
}
test(ret);
cout << "ok" << endl;
//
// Sending the replies back on the multicast UDP connection doesn't work for most
// platform (it works for OS X Leopard but not Snow Leopard, doesn't work on SLES,
// Windows...). For Windows, see UdpTransceiver constructor for the details. So
// we don't run this test.
//
// cout << "testing udp bi-dir connection... " << flush;
// nRetry = 5;
// while(nRetry-- > 0)
// {
// replyI->reset();
// objMcast->pingBiDir(reply->ice_getIdentity());
// ret = replyI->waitReply(5, IceUtil::Time::seconds(2));
// if(ret)
// {
// break; // Success
// }
// replyI = new PingReplyI;
// reply = PingReplyPrx::uncheckedCast(adapter->addWithUUID(replyI))->ice_datagram();
// }
// if(!ret)
// {
// cout << "failed (is a firewall enabled?)" << endl;
// }
// else
// {
// cout << "ok" << endl;
// }
}
