1 files changed, 65 insertions, 1 deletions

diff --git a/cpp/src/Ice/ConnectionFactory.cpp b/cpp/src/Ice/ConnectionFactory.cpp
index c6efdac809b..e51fc9ff4a2 100755
--- a/cpp/src/Ice/ConnectionFactory.cpp
+++ b/cpp/src/Ice/ConnectionFactory.cpp
@@ -29,6 +29,7 @@
 
 using namespace std;
 using namespace Ice;
+using namespace Ice::Instrumentation;
 using namespace IceInternal;
 
 IceUtil::Shared* IceInternal::upCast(OutgoingConnectionFactory* p) { return p; }
@@ -106,6 +107,14 @@ IceInternal::OutgoingConnectionFactory::destroy()
 }
 
 void
+IceInternal::OutgoingConnectionFactory::updateConnectionObservers()
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+    for_each(_connections.begin(), _connections.end(),
+             Ice::secondVoidMemFun<const ConnectorPtr, ConnectionI>(&ConnectionI::updateObserver));
+}
+
+void
 IceInternal::OutgoingConnectionFactory::waitUntilFinished()
 {
     multimap<ConnectorPtr, ConnectionIPtr> connections;
@@ -223,14 +232,30 @@ IceInternal::OutgoingConnectionFactory::create(const vector<EndpointIPtr>& endpt
     // Try to establish the connection to the connectors.
     //
     DefaultsAndOverridesPtr defaultsAndOverrides = _instance->defaultsAndOverrides();
+    const CommunicatorObserverPtr& obsv = _instance->initializationData().observer;
     vector<ConnectorInfo>::const_iterator q;
     for(q = connectors.begin(); q != connectors.end(); ++q)
     {
+        ObserverPtr observer;
+        if(obsv)
+        {
+            observer = obsv->getConnectionEstablishmentObserver(q->endpoint, q->connector->toString());
+            if(observer)
+            {
+                observer->attach();
+            }
+        }
+
         try
         {
             connection = createConnection(q->connector->connect(), *q);
             connection->start(0);
 
+            if(observer)
+            {
+                observer->detach();
+            }
+
             if(defaultsAndOverrides->overrideCompress)
             {
                 compress = defaultsAndOverrides->overrideCompressValue;
@@ -245,6 +270,11 @@ IceInternal::OutgoingConnectionFactory::create(const vector<EndpointIPtr>& endpt
         }
         catch(const Ice::CommunicatorDestroyedException& ex)
         {
+            if(observer)
+            {
+                observer->failed(ex.ice_name());
+                observer->detach();
+            }
             exception.reset(ex.ice_clone());
             handleConnectionException(*exception.get(), hasMore || q != connectors.end() - 1);
             connection = 0;
@@ -252,6 +282,11 @@ IceInternal::OutgoingConnectionFactory::create(const vector<EndpointIPtr>& endpt
         }
         catch(const Ice::LocalException& ex)
         {
+            if(observer)
+            {
+                observer->failed(ex.ice_name());
+                observer->detach();
+            }
             exception.reset(ex.ice_clone());
             handleConnectionException(*exception.get(), hasMore || q != connectors.end() - 1);
             connection = 0;
@@ -932,6 +967,11 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::ConnectCallback(const O
 void
 IceInternal::OutgoingConnectionFactory::ConnectCallback::connectionStartCompleted(const ConnectionIPtr& connection)
 {
+    if(_observer)
+    {
+        _observer->detach();
+    }
+    
     connection->activate();
     _factory->finishGetConnection(_connectors, *_iter, connection, this);
 }
@@ -941,6 +981,12 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::connectionStartFailed(c
                                                                                const LocalException& ex)
 {
     assert(_iter != _connectors.end());
+
+    if(_observer)
+    {
+        _observer->failed(ex.ice_name());
+        _observer->detach();
+    }
     
     _factory->handleConnectionException(ex, _hasMore || _iter != _connectors.end() - 1);
     if(dynamic_cast<const Ice::CommunicatorDestroyedException*>(&ex)) // No need to continue.
@@ -1089,6 +1135,17 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::nextConnector()
     Ice::ConnectionIPtr connection;
     try
     {
+
+        const CommunicatorObserverPtr& obsv = _factory->_instance->initializationData().observer;
+        if(obsv)
+        {
+            _observer = obsv->getConnectionEstablishmentObserver(_iter->endpoint, _iter->connector->toString());
+            if(_observer)
+            {
+                _observer->attach();
+            }
+        }
+
         assert(_iter != _connectors.end());
         connection = _factory->createConnection(_iter->connector->connect(), *_iter);
         connection->start(this);
@@ -1176,6 +1233,13 @@ IceInternal::IncomingConnectionFactory::destroy()
 }
 
 void
+IceInternal::IncomingConnectionFactory::updateConnectionObservers()
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+    for_each(_connections.begin(), _connections.end(), Ice::voidMemFun(&ConnectionI::updateObserver));
+}
+
+void
 IceInternal::IncomingConnectionFactory::waitUntilHolding() const
 {
     set<ConnectionIPtr> connections;
@@ -1488,7 +1552,7 @@ IceInternal::IncomingConnectionFactory::connectionStartFailed(const Ice::Connect
     {
         return;
     }
-    
+
     if(_warn)
     {
         Warning out(_instance->initializationData().logger);