http://bugzilla.zeroc.com/bugzilla/show_bug.cgi?id=2269 - do not exit if permissions verifier or session manager are not running at startup

4 files changed, 128 insertions, 37 deletions

diff --git a/cpp/CHANGES b/cpp/CHANGES
index 4f5dd9c1482..174de79b38e 100644
--- a/cpp/CHANGES
+++ b/cpp/CHANGES
@@ -65,6 +65,11 @@ Changes since version 3.2.X (binary incompatible)
 Changes since version 3.2.0
 ---------------------------
 
+- If the glacier2router can not contact the permissions verifier or
+  session manager on startup it now prints a warning and continues
+  rather than exiting. These warnings are disabled if the router is
+  started with the --nowarn command line option.
+
 - Added support for protected class data members using the new
   metadata tag ["protected"]. The tag can be applied to a Slice class
   or to individual data members.
diff --git a/cpp/src/Glacier2/Glacier2Router.cpp b/cpp/src/Glacier2/Glacier2Router.cpp
index 9855723bd18..21b0fe278b0 100644
--- a/cpp/src/Glacier2/Glacier2Router.cpp
+++ b/cpp/src/Glacier2/Glacier2Router.cpp
@@ -93,9 +93,12 @@ Glacier2::RouterService::RouterService()
 bool
 Glacier2::RouterService::start(int argc, char* argv[])
 {
+    bool nowarn;
+
     IceUtil::Options opts;
     opts.addOpt("h", "help");
     opts.addOpt("v", "version");
+    opts.addOpt("", "nowarn");
 
     vector<string> args;
     try
@@ -119,6 +122,7 @@ Glacier2::RouterService::start(int argc, char* argv[])
         print(ICE_STRING_VERSION);
         return false;
     }
+    nowarn = opts.isSet("nowarn");
 
     if(!args.empty())
     {
@@ -183,7 +187,23 @@ Glacier2::RouterService::start(int argc, char* argv[])
         nullPermVerifId.category = instanceName;
         nullPermVerifId.name = "NullPermissionsVerifier";
 
-        ObjectPrx obj = communicator()->propertyToProxy(verifierProperty);
+        ObjectPrx obj;
+        try
+        {
+            obj = communicator()->propertyToProxy(verifierProperty);
+            if(!obj)
+            {
+                error("permissions verifier `" + verifierPropertyValue + "' is invalid");
+                return false;
+            }
+        }
+        catch(const Ice::Exception& ex)
+        {
+            ostringstream ostr;
+            ostr << ex;
+            error("permissions verifier `" + verifierPropertyValue + "' is invalid:\n" + ostr.str());
+            return false;
+        }
         if(obj->ice_getIdentity() == nullPermVerifId)
         {
             verifier = PermissionsVerifierPrx::uncheckedCast(
@@ -194,18 +214,21 @@ Glacier2::RouterService::start(int argc, char* argv[])
             try
             {
                 verifier = PermissionsVerifierPrx::checkedCast(obj);
+                if(!verifier)
+                {
+                    error("permissions verifier `" + verifierPropertyValue + "' is invalid");
+                    return false;
+                }
             }
             catch(const Ice::Exception& ex)
             {
-                ostringstream ostr;
-                ostr << ex;
-                error("unable to contact permissions verifier `" + verifierPropertyValue + "'\n" + ostr.str());
-                return false;
-            }
-            if(!verifier)
-            {
-                error("permissions verifier `" + verifierPropertyValue + "' is invalid");
-                return false;
+                if(!nowarn)
+                {
+                    ostringstream ostr;
+                    ostr << ex;
+                    warning("unable to contact permissions verifier `" + verifierPropertyValue + "'\n" + ostr.str());
+                }
+                verifier = PermissionsVerifierPrx::uncheckedCast(obj);
             }
         }
     }
@@ -255,21 +278,36 @@ Glacier2::RouterService::start(int argc, char* argv[])
     SessionManagerPrx sessionManager;
     if(!sessionManagerPropertyValue.empty())
     {
+        ObjectPrx obj;
         try
         {
-            sessionManager = SessionManagerPrx::checkedCast(communicator()->propertyToProxy(sessionManagerProperty));
+            obj = communicator()->propertyToProxy(sessionManagerProperty);
         }
         catch(const Ice::Exception& ex)
         {
             ostringstream ostr;
             ostr << ex;
-            error("unable to contact session manager `" + sessionManagerPropertyValue + "'\n" + ostr.str());
+            error("session manager `" + sessionManagerPropertyValue + "' is invalid\n:" + ostr.str());
             return false;
         }
-        if(!sessionManager)
+        try
         {
-            error("session manager `" + sessionManagerPropertyValue + "' is invalid");
-            return false;
+            sessionManager = SessionManagerPrx::checkedCast(obj);
+            if(!sessionManager)
+            {
+                error("session manager `" + sessionManagerPropertyValue + "' is invalid");
+                return false;
+            }
+        }
+        catch(const Ice::Exception& ex)
+        {
+            if(!nowarn)
+            {
+                ostringstream ostr;
+                ostr << ex;
+                warning("unable to contact session manager `" + sessionManagerPropertyValue + "'\n" + ostr.str());
+            }
+            sessionManager = SessionManagerPrx::uncheckedCast(obj);
         }
         sessionManager = 
             SessionManagerPrx::uncheckedCast(sessionManager->ice_connectionCached(false)->ice_locatorCacheTimeout(
@@ -288,7 +326,23 @@ Glacier2::RouterService::start(int argc, char* argv[])
         nullSSLPermVerifId.category = instanceName;
         nullSSLPermVerifId.name = "NullSSLPermissionsVerifier";
 
-        ObjectPrx obj = communicator()->propertyToProxy(sslVerifierProperty);
+        ObjectPrx obj;
+        try
+        {
+            obj = communicator()->propertyToProxy(sslVerifierProperty);
+            if(!obj)
+            {
+                error("ssl permissions verifier `" + verifierPropertyValue + "' is invalid");
+                return false;
+            }
+        }
+        catch(const Ice::Exception& ex)
+        {
+            ostringstream ostr;
+            ostr << ex;
+            error("ssl permissions verifier `" + sslVerifierPropertyValue + "' is invalid:\n" + ostr.str());
+            return false;
+        }
         if(obj->ice_getIdentity() == nullSSLPermVerifId)
         {
 
@@ -301,18 +355,22 @@ Glacier2::RouterService::start(int argc, char* argv[])
             try
             {
                 sslVerifier = SSLPermissionsVerifierPrx::checkedCast(obj);
+                if(!sslVerifier)
+                {
+                    error("ssl permissions verifier `" + sslVerifierPropertyValue + "' is invalid");
+                    return false;
+                }
             }
             catch(const Ice::Exception& ex)
             {
-                ostringstream ostr;
-                ostr << ex;
-                error("unable to contact ssl permissions verifier `" + sslVerifierPropertyValue + "'\n" + ostr.str());
-                return false;
-            }
-            if(!sslVerifier)
-            {
-                error("ssl permissions verifier `" + sslVerifierPropertyValue + "' is invalid");
-                return false;
+                if(!nowarn)
+                {
+                    ostringstream ostr;
+                    ostr << ex;
+                    warning("unable to contact ssl permissions verifier `" + sslVerifierPropertyValue + "'\n" + 
+                            ostr.str());
+                }
+                sslVerifier = SSLPermissionsVerifierPrx::uncheckedCast(obj);
             }
         }
     }
@@ -325,22 +383,37 @@ Glacier2::RouterService::start(int argc, char* argv[])
     SSLSessionManagerPrx sslSessionManager;
     if(!sslSessionManagerPropertyValue.empty())
     {
+        ObjectPrx obj;
         try
         {
-            sslSessionManager = 
-                SSLSessionManagerPrx::checkedCast(communicator()->propertyToProxy(sslSessionManagerProperty));
+            obj = communicator()->propertyToProxy(sslSessionManagerProperty);
         }
         catch(const Ice::Exception& ex)
         {
             ostringstream ostr;
             ostr << ex;
-            error("unable to ssl session manager `" + sslSessionManagerPropertyValue + "'\n" + ostr.str());
-            return false;
+            error("ssl session manager `" + sslSessionManagerPropertyValue + "' is invalid:\n" + ostr.str());
+            return false
         }
-        if(!sslSessionManager)
+        try
         {
-            error("ssl session manager `" + sslSessionManagerPropertyValue + "' is invalid");
-            return false;
+            sslSessionManager = SSLSessionManagerPrx::checkedCast(obj);
+            if(!sslSessionManager)
+            {
+                error("ssl session manager `" + sslSessionManagerPropertyValue + "' is invalid");
+                return false;
+            }
+        }
+        catch(const Ice::Exception& ex)
+        {
+            if(!nowarn)
+            {
+                ostringstream ostr;
+                ostr << ex;
+                warning("unable to contact ssl session manager `" + sslSessionManagerPropertyValue + "'\n" +
+                        ostr.str());
+            }
+            sslSessionManager = SSLSessionManagerPrx::uncheckedCast(obj);
         }
         sslSessionManager = 
             SSLSessionManagerPrx::uncheckedCast(sslSessionManager->ice_connectionCached(false)->ice_locatorCacheTimeout(
@@ -463,7 +536,8 @@ Glacier2::RouterService::usage(const string& appName)
     string options =
         "Options:\n"
         "-h, --help           Show this message.\n"
-        "-v, --version        Display the Ice version.";
+        "-v, --version        Display the Ice version.\n"
+        "--nowarn             Suppress warnings.";
 #ifdef _WIN32
     if(checkSystem())
     {
diff --git a/cpp/src/Glacier2/SessionRouterI.cpp b/cpp/src/Glacier2/SessionRouterI.cpp
index a095748b52d..642f4f527f7 100644
--- a/cpp/src/Glacier2/SessionRouterI.cpp
+++ b/cpp/src/Glacier2/SessionRouterI.cpp
@@ -804,7 +804,7 @@ Glacier2::SessionRouterI::createSessionInternal(const string& userId, bool allow
         {
             if(_sessionTraceLevel >= 1)
             {
-                Trace out(_logger, "Glacier2");
+                Warning out(_logger);
                 out << "exception while verifying password:\n" << ex;
             }
             
diff --git a/cpp/src/IceGrid/RegistryI.cpp b/cpp/src/IceGrid/RegistryI.cpp
index 901e351e8d7..84f242ab6f7 100644
--- a/cpp/src/IceGrid/RegistryI.cpp
+++ b/cpp/src/IceGrid/RegistryI.cpp
@@ -958,6 +958,12 @@ RegistryI::getPermissionsVerifier(const ObjectAdapterPtr& adapter,
         try
         {
             verifier = _communicator->propertyToProxy(verifierProperty);
+            if(!verifier)
+            {
+                Error out(_communicator->getLogger());
+                out << "permissions verifier `" + verifierPropertyValue + "' is invalid";
+                return 0;
+            }
             assert(_nullPermissionsVerifier);
             if(verifier->ice_getIdentity() == _nullPermissionsVerifier->ice_getIdentity())
             {
@@ -1057,6 +1063,12 @@ RegistryI::getSSLPermissionsVerifier(const IceGrid::LocatorPrx& locator, const s
         try
         {
             verifier = _communicator->propertyToProxy(verifierProperty);
+            if(!verifier)
+            {
+                Error out(_communicator->getLogger());
+                out << "ssl permissions verifier `" + verifierPropertyValue + "' is invalid";
+                return 0;
+            }
             assert(_nullSSLPermissionsVerifier);
             if(verifier->ice_getIdentity() == _nullSSLPermissionsVerifier->ice_getIdentity())
             {
@@ -1066,7 +1078,7 @@ RegistryI::getSSLPermissionsVerifier(const IceGrid::LocatorPrx& locator, const s
         catch(const LocalException& ex)
         {
             Error out(_communicator->getLogger());
-            out << "permissions verifier `" + verifierPropertyValue + "' is invalid:\n" << ex;
+            out << "ssl permissions verifier `" + verifierPropertyValue + "' is invalid:\n" << ex;
             return 0;
         }
     }
@@ -1088,7 +1100,7 @@ RegistryI::getSSLPermissionsVerifier(const IceGrid::LocatorPrx& locator, const s
         if(!verifierPrx)
         {
             Error out(_communicator->getLogger());
-            out << "permissions verifier `" + verifierProperty + "' is invalid";
+            out << "ssl permissions verifier `" + verifierProperty + "' is invalid";
             return 0;
         }    
     }
@@ -1097,7 +1109,7 @@ RegistryI::getSSLPermissionsVerifier(const IceGrid::LocatorPrx& locator, const s
         if(!nowarn)
         {
             Warning out(_communicator->getLogger());
-            out << "couldn't contact permissions verifier `" + verifierProperty + "':\n" << ex; 
+            out << "couldn't contact ssl permissions verifier `" + verifierProperty + "':\n" << ex; 
         }
         verifierPrx = Glacier2::SSLPermissionsVerifierPrx::uncheckedCast(verifier->ice_locator(locator));
     }