ICE-4774: Merged skype_props enhancement

31 files changed, 1678 insertions, 561 deletions

diff --git a/cpp/src/Ice/CommunicatorI.cpp b/cpp/src/Ice/CommunicatorI.cpp
index 25762041b06..2acb01718bb 100644
--- a/cpp/src/Ice/CommunicatorI.cpp
+++ b/cpp/src/Ice/CommunicatorI.cpp
@@ -384,6 +384,12 @@ Ice::CommunicatorI::removeAdminFacet(const string& facet)
     return _instance->removeAdminFacet(facet);
 }
 
+Ice::ObjectPtr
+Ice::CommunicatorI::findAdminFacet(const string& facet)
+{
+    return _instance->findAdminFacet(facet);
+}
+
 Ice::CommunicatorI::CommunicatorI(const InitializationData& initData)
 {
     __setNoDelete(true);
diff --git a/cpp/src/Ice/CommunicatorI.h b/cpp/src/Ice/CommunicatorI.h
index d9628478707..384a6a7936c 100644
--- a/cpp/src/Ice/CommunicatorI.h
+++ b/cpp/src/Ice/CommunicatorI.h
@@ -79,6 +79,7 @@ public:
     virtual ObjectPrx getAdmin() const;
     virtual void addAdminFacet(const ObjectPtr&, const std::string&);
     virtual ObjectPtr removeAdminFacet(const std::string&);
+    virtual ObjectPtr findAdminFacet(const std::string&);
 
 private:
 
diff --git a/cpp/src/Ice/Instance.cpp b/cpp/src/Ice/Instance.cpp
index 5dda22e333c..c062c5a7671 100644
--- a/cpp/src/Ice/Instance.cpp
+++ b/cpp/src/Ice/Instance.cpp
@@ -25,6 +25,7 @@
 #include <Ice/ObjectAdapterFactory.h>
 #include <Ice/Exception.h>
 #include <Ice/PropertiesI.h>
+#include <Ice/PropertiesAdminI.h>
 #include <Ice/LoggerI.h>
 #include <Ice/Network.h>
 #include <Ice/EndpointFactoryManager.h>
@@ -724,6 +725,35 @@ IceInternal::Instance::removeAdminFacet(const string& facet)
     {
         result = _adminAdapter->removeFacet(_adminIdentity, facet);  
     }
+
+    return result;
+}
+
+Ice::ObjectPtr
+IceInternal::Instance::findAdminFacet(const string& facet)
+{
+    IceUtil::RecMutex::Lock sync(*this);
+
+    if(_state == StateDestroyed)
+    {
+        throw CommunicatorDestroyedException(__FILE__, __LINE__);
+    }
+
+    ObjectPtr result;
+
+    if(_adminAdapter == 0 || (!_adminFacetFilter.empty() && _adminFacetFilter.find(facet) == _adminFacetFilter.end()))
+    {
+        FacetMap::iterator p = _adminFacets.find(facet);
+        if(p != _adminFacets.end())
+        {
+            result = p->second;
+        }
+    }
+    else
+    {
+        result = _adminAdapter->findFacet(_adminIdentity, facet);
+    }
+
     return result;
 } 
 
@@ -1074,7 +1104,9 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi
             _adminFacetFilter.insert(facetSeq.begin(), facetSeq.end());
         }
 
-        _adminFacets.insert(FacetMap::value_type("Properties", new PropertiesAdminI(_initData.properties)));
+        _adminFacets.insert(
+            FacetMap::value_type("Properties",
+                                 new PropertiesAdminI("Properties", _initData.properties, _initData.logger)));
         _adminFacets.insert(FacetMap::value_type("Process", new ProcessI(communicator)));
         IceMX::MetricsAdminIPtr admin = new IceMX::MetricsAdminI(_initData.properties);
         _adminFacets.insert(FacetMap::value_type("MetricsAdmin", admin));
diff --git a/cpp/src/Ice/Instance.h b/cpp/src/Ice/Instance.h
index 1cda82f3608..df97e4390d0 100644
--- a/cpp/src/Ice/Instance.h
+++ b/cpp/src/Ice/Instance.h
@@ -85,6 +85,7 @@ public:
     Ice::ObjectPrx getAdmin();
     void addAdminFacet(const Ice::ObjectPtr&, const std::string&);
     Ice::ObjectPtr removeAdminFacet(const std::string&);
+    Ice::ObjectPtr findAdminFacet(const std::string&);
     
     const Ice::ImplicitContextIPtr& getImplicitContext() const
     {
diff --git a/cpp/src/Ice/Makefile b/cpp/src/Ice/Makefile
index 4aea8c9f907..54110fbf2fe 100644
--- a/cpp/src/Ice/Makefile
+++ b/cpp/src/Ice/Makefile
@@ -85,6 +85,7 @@ OBJS		= Acceptor.o \
 		  PluginManagerI.o \
 		  Plugin.o \
 		  Process.o \
+		  PropertiesAdminI.o \
 		  PropertiesI.o \
 		  Properties.o \
 		  PropertyNames.o \
diff --git a/cpp/src/Ice/Makefile.mak b/cpp/src/Ice/Makefile.mak
index e07cc6833bc..a2b12348f0e 100644
--- a/cpp/src/Ice/Makefile.mak
+++ b/cpp/src/Ice/Makefile.mak
@@ -79,6 +79,7 @@ OBJS		= Acceptor.obj \
 		  PluginManagerI.obj \

 		  Plugin.obj \

 		  Process.obj \

+		  PropertiesAdminI.obj \

 		  PropertiesI.obj \

 		  Properties.obj \

 		  PropertyNames.obj \

diff --git a/cpp/src/Ice/PropertiesAdminI.cpp b/cpp/src/Ice/PropertiesAdminI.cpp
new file mode 100644
index 00000000000..fc929bb959a
--- /dev/null
+++ b/cpp/src/Ice/PropertiesAdminI.cpp
@@ -0,0 +1,187 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2010 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#include <IceUtil/DisableWarnings.h>
+#include <Ice/PropertiesAdminI.h>
+#include <Ice/Logger.h>
+#include <Ice/LoggerUtil.h>
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+Ice::PropertiesAdminI::PropertiesAdminI(const string& name, const PropertiesPtr& properties, const LoggerPtr& logger) :
+    _name(name), _properties(properties), _logger(logger)
+{
+}
+
+string
+Ice::PropertiesAdminI::getProperty(const string& name, const Ice::Current&)
+{
+    IceUtil::Mutex::Lock sync(*this);
+    return _properties->getProperty(name);
+}
+
+Ice::PropertyDict
+Ice::PropertiesAdminI::getPropertiesForPrefix(const string& prefix, const Ice::Current&)
+{
+    IceUtil::Mutex::Lock sync(*this);
+    return _properties->getPropertiesForPrefix(prefix);
+}
+
+void
+Ice::PropertiesAdminI::setProperties_async(const AMD_PropertiesAdmin_setPropertiesPtr& cb, const PropertyDict& props,
+                                           const Ice::Current&)
+{
+    PropertyDict added, changed, removed;
+    PropertiesAdminUpdateCallbackPtr callback;
+    {
+        IceUtil::Mutex::Lock sync(*this);
+
+        PropertyDict old = _properties->getPropertiesForPrefix("");
+        PropertyDict::const_iterator p;
+        const int traceLevel = _properties->getPropertyAsInt("Ice.Trace.Admin.Properties");
+
+        //
+        // Compute the difference between the new property set and the existing property set:
+        //
+        // 1) Any properties in the new set that were not defined in the existing set.
+        //
+        // 2) Any properties that appear in both sets but with different values.
+        //
+        // 3) Any properties not present in the new set but present in the existing set.
+        //    In other words, the property has been removed.
+        //
+        for(p = props.begin(); p != props.end(); ++p)
+        {
+            PropertyDict::iterator q = old.find(p->first);
+            if(q == old.end())
+            {
+                if(!p->second.empty())
+                {
+                    //
+                    // This property is new.
+                    //
+                    added.insert(*p);
+                }
+            }
+            else
+            {
+                if(p->second != q->second)
+                {
+                    if(p->second.empty())
+                    {
+                        //
+                        // This property was removed.
+                        //
+                        removed.insert(*p);
+                    }
+                    else
+                    {
+                        //
+                        // This property has changed.
+                        //
+                        changed.insert(*p);
+                    }
+                }
+            }
+        }
+
+        if(traceLevel > 0 && (!added.empty() || !changed.empty() || !removed.empty()))
+        {
+            Trace out(_logger, _name);
+
+            out << "Summary of property changes";
+
+            if(!added.empty())
+            {
+                out << "\nNew properties:";
+                for(p = added.begin(); p != added.end(); ++p)
+                {
+                    out << "\n  " << p->first;
+                    if(traceLevel > 1)
+                    {
+                        out << " = " << p->second;
+                    }
+                }
+            }
+
+            if(!changed.empty())
+            {
+                out << "\nChanged properties:";
+                for(p = changed.begin(); p != changed.end(); ++p)
+                {
+                    out << "\n  " << p->first;
+                    if(traceLevel > 1)
+                    {
+                        out << " = " << p->second << " (old value = " << _properties->getProperty(p->first) << ")";
+                    }
+                }
+            }
+
+            if(!removed.empty())
+            {
+                out << "\nRemoved properties:";
+                for(p = removed.begin(); p != removed.end(); ++p)
+                {
+                    out << "\n  " << p->first;
+                }
+            }
+        }
+
+        //
+        // Update the property set.
+        //
+
+        for(p = added.begin(); p != added.end(); ++p)
+        {
+            _properties->setProperty(p->first, p->second);
+        }
+
+        for(p = changed.begin(); p != changed.end(); ++p)
+        {
+            _properties->setProperty(p->first, p->second);
+        }
+
+        for(p = removed.begin(); p != removed.end(); ++p)
+        {
+            _properties->setProperty(p->first, "");
+        }
+
+        callback = _updateCallback;
+    }
+
+    //
+    // Send the response now so that we do not block the client during the call to the update callback.
+    //
+    cb->ice_response();
+
+    if(callback)
+    {
+        PropertyDict changes = added;
+        changes.insert(changed.begin(), changed.end());
+        changes.insert(removed.begin(), removed.end());
+
+        try
+        {
+            callback->updated(changes);
+        }
+        catch(...)
+        {
+            // Ignore.
+        }
+    }
+}
+
+void
+Ice::PropertiesAdminI::setUpdateCallback(const PropertiesAdminUpdateCallbackPtr& cb)
+{
+    IceUtil::Mutex::Lock sync(*this);
+    _updateCallback = cb;
+}
diff --git a/cpp/src/Ice/PropertiesAdminI.h b/cpp/src/Ice/PropertiesAdminI.h
new file mode 100644
index 00000000000..2ddf420aa3e
--- /dev/null
+++ b/cpp/src/Ice/PropertiesAdminI.h
@@ -0,0 +1,42 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2009 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_PROPERTIES_ADMIN_I_H
+#define ICE_PROPERTIES_ADMIN_I_H
+
+#include <IceUtil/Mutex.h>
+#include <Ice/PropertiesAdmin.h>
+#include <Ice/LoggerF.h>
+
+namespace Ice
+{
+
+class ICE_API PropertiesAdminI : public PropertiesAdmin, public NativePropertiesAdmin, private IceUtil::Mutex
+{
+public:
+
+    PropertiesAdminI(const std::string&, const PropertiesPtr&, const LoggerPtr&);
+
+    virtual std::string getProperty(const std::string&, const Current&);
+    virtual PropertyDict getPropertiesForPrefix(const std::string&, const Current&);
+    virtual void setProperties_async(const AMD_PropertiesAdmin_setPropertiesPtr&, const PropertyDict&, const Current&);
+
+    virtual void setUpdateCallback(const PropertiesAdminUpdateCallbackPtr&);
+
+private:
+
+    const std::string _name;
+    const PropertiesPtr _properties;
+    const LoggerPtr _logger;
+    PropertiesAdminUpdateCallbackPtr _updateCallback;
+};
+
+}
+
+#endif
diff --git a/cpp/src/Ice/PropertiesI.cpp b/cpp/src/Ice/PropertiesI.cpp
index 9bde5157184..1c4f2670597 100644
--- a/cpp/src/Ice/PropertiesI.cpp
+++ b/cpp/src/Ice/PropertiesI.cpp
@@ -774,26 +774,3 @@ Ice::PropertiesI::loadConfig()
     PropertyValue pv(value, true);
     _properties["Ice.Config"] = pv;
 }
-
-
-//
-// PropertiesAdminI
-//
-
-
-Ice::PropertiesAdminI::PropertiesAdminI(const PropertiesPtr& properties) :
-    _properties(properties)
-{
-}
-
-string 
-Ice::PropertiesAdminI::getProperty(const string& name, const Ice::Current&)
-{
-    return _properties->getProperty(name);
-}
-
-Ice::PropertyDict 
-Ice::PropertiesAdminI::getPropertiesForPrefix(const string& prefix, const Ice::Current&)
-{
-    return _properties->getPropertiesForPrefix(prefix);
-}
diff --git a/cpp/src/Ice/PropertiesI.h b/cpp/src/Ice/PropertiesI.h
index ee6df06c1bb..a54b042cff2 100644
--- a/cpp/src/Ice/PropertiesI.h
+++ b/cpp/src/Ice/PropertiesI.h
@@ -72,19 +72,4 @@ private:
     const StringConverterPtr _converter;
 };
 
-
-class PropertiesAdminI : public PropertiesAdmin
-{
-public:
-    
-    PropertiesAdminI(const PropertiesPtr&);
-    
-    virtual std::string getProperty(const std::string&, const Current&);
-    virtual PropertyDict getPropertiesForPrefix(const std::string&, const Current&);
-    
-private:
-
-    const PropertiesPtr _properties; 
-};
-
 }
diff --git a/cpp/src/Ice/PropertyNames.cpp b/cpp/src/Ice/PropertyNames.cpp
index b1de65c529d..b9e7b8cd97b 100644
--- a/cpp/src/Ice/PropertyNames.cpp
+++ b/cpp/src/Ice/PropertyNames.cpp
@@ -8,7 +8,7 @@
 // **********************************************************************
 
 //
-// Generated by makeprops.py from file ./config/PropertyNames.xml, Fri Aug 10 10:27:32 2012
+// Generated by makeprops.py from file ./config/PropertyNames.xml, Thu Aug 30 14:36:00 2012
 
 // IMPORTANT: Do not edit this file -- any edits made here will be lost!
 
@@ -137,6 +137,7 @@ const IceInternal::Property IcePropsData[] =
     IceInternal::Property("Ice.ThreadPool.Server.ThreadIdleTime", false, 0),
     IceInternal::Property("Ice.ThreadPool.Server.ThreadPriority", false, 0),
     IceInternal::Property("Ice.ThreadPriority", false, 0),
+    IceInternal::Property("Ice.Trace.Admin.Properties", false, 0),
     IceInternal::Property("Ice.Trace.GC", false, 0),
     IceInternal::Property("Ice.Trace.Location", true, "Ice.Trace.Locator"),
     IceInternal::Property("Ice.Trace.Locator", false, 0),
diff --git a/cpp/src/Ice/PropertyNames.h b/cpp/src/Ice/PropertyNames.h
index ce4a7927dcb..ecb560f6943 100644
--- a/cpp/src/Ice/PropertyNames.h
+++ b/cpp/src/Ice/PropertyNames.h
@@ -8,7 +8,7 @@
 // **********************************************************************
 
 //
-// Generated by makeprops.py from file ./config/PropertyNames.xml, Fri Aug 10 10:27:32 2012
+// Generated by makeprops.py from file ./config/PropertyNames.xml, Thu Aug 30 14:36:00 2012
 
 // IMPORTANT: Do not edit this file -- any edits made here will be lost!
 
diff --git a/cpp/src/IceBox/ServiceManagerI.cpp b/cpp/src/IceBox/ServiceManagerI.cpp
index f91e9cd8da2..ce763ba0844 100644
--- a/cpp/src/IceBox/ServiceManagerI.cpp
+++ b/cpp/src/IceBox/ServiceManagerI.cpp
@@ -14,6 +14,7 @@
 #include <Ice/SliceChecksums.h>
 #include <Ice/Initialize.h>
 #include <Ice/Instance.h>
+#include <Ice/PropertiesAdminI.h>
 #include <IceBox/ServiceManagerI.h>
 
 using namespace Ice;
@@ -25,30 +26,6 @@ typedef IceBox::Service* (*SERVICE_FACTORY)(CommunicatorPtr);
 namespace
 {
 
-class PropertiesAdminI : public PropertiesAdmin
-{
-public:
-
-    PropertiesAdminI(const PropertiesPtr& properties) :
-        _properties(properties)
-    {
-    }
-
-    virtual string getProperty(const string& name, const Current&)
-    {
-        return _properties->getProperty(name);
-    }
-
-    virtual PropertyDict getPropertiesForPrefix(const string& prefix, const Current&)
-    {
-        return _properties->getPropertiesForPrefix(prefix);
-    }
-
-private:
-
-    const PropertiesPtr _properties;
-};
-
 struct StartServiceInfo
 {
     StartServiceInfo(const std::string& service, const std::string& value, const Ice::StringSeq& serverArgs)
@@ -65,8 +42,8 @@ struct StartServiceInfo
         }
         catch(const IceUtilInternal::BadOptException& ex)
         {
-            PluginInitializationException e(__FILE__, __LINE__);
-            e.reason = "invalid arguments for service `" + name + "':\n" + ex.reason;
+            FailureException e(__FILE__, __LINE__);
+            e.reason = "ServiceManager: invalid arguments for service `" + name + "':\n" + ex.reason;
             throw e;
         }
 
@@ -157,7 +134,7 @@ IceBox::ServiceManagerI::startService(const string& name, const Current&)
         info.service->start(name, info.communicator == 0 ? _sharedCommunicator : info.communicator, info.args);
         started = true;
     }
-    catch(const Ice::Exception& ex)
+    catch(const Exception& ex)
     {
         Warning out(_logger);
         out << "ServiceManager: exception in start for service " << info.name << ":\n";
@@ -235,7 +212,7 @@ IceBox::ServiceManagerI::stopService(const string& name, const Current&)
         info.service->stop();
         stopped = true;
     }
-    catch(const Ice::Exception& ex)
+    catch(const Exception& ex)
     {
         Warning out(_logger);
         out << "ServiceManager: exception while stopping service " << info.name << ":\n";
@@ -276,7 +253,7 @@ IceBox::ServiceManagerI::stopService(const string& name, const Current&)
 }
 
 void
-IceBox::ServiceManagerI::addObserver(const ServiceObserverPrx& observer, const Ice::Current&)
+IceBox::ServiceManagerI::addObserver(const ServiceObserverPrx& observer, const Current&)
 {
     //
     // Null observers and duplicate registrations are ignored
@@ -458,18 +435,6 @@ IceBox::ServiceManagerI::start()
         try
         {
             _communicator->addAdminFacet(this, "IceBox.ServiceManager");
-
-            //
-            // Add a Properties facet for each service
-            //
-            for(vector<ServiceInfo>::iterator r = _services.begin(); r != _services.end(); ++r)
-            {
-                const ServiceInfo& info = *r;
-                CommunicatorPtr communicator = info.communicator != 0 ? info.communicator : _sharedCommunicator;
-                _communicator->addAdminFacet(new PropertiesAdminI(communicator->getProperties()),
-                                             "IceBox.Service." + info.name + ".Properties");
-            }
-
             _communicator->getAdmin();
         }
         catch(const ObjectAdapterDeactivatedException&)
@@ -536,11 +501,6 @@ IceBox::ServiceManagerI::start(const string& service, const string& entryPoint,
 {
     IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this);
 
-    ServiceInfo info;
-    info.name = service;
-    info.status = Stopped;
-    info.args = args;
-
     //
     // Load the entry point.
     //
@@ -559,57 +519,27 @@ IceBox::ServiceManagerI::start(const string& service, const string& entryPoint,
         throw ex;
     }
 
+    ServiceInfo info;
+    info.name = service;
+    info.status = Stopped;
+    info.args = args;
+
     //
-    // Invoke the factory function.
+    // If Ice.UseSharedCommunicator.<name> is not defined, create
+    // a communicator for the service. The communicator inherits
+    // from the shared communicator properties. If it's defined
+    // add the service properties to the shared commnunicator
+    // property set.
     //
-    SERVICE_FACTORY factory = (SERVICE_FACTORY)sym;
-    try
-    {
-        info.service = factory(_communicator);
-    }
-    catch(const FailureException&)
-    {
-        throw;
-    }
-    catch(const Exception& ex)
+    Ice::CommunicatorPtr communicator;
+    if(_communicator->getProperties()->getPropertyAsInt("IceBox.UseSharedCommunicator." + service) > 0)
     {
-        ostringstream s;
-        s << "ServiceManager: exception in entry point `" + entryPoint + "' for service " << service << ":\n";
-        s << ex;
-
-        FailureException e(__FILE__, __LINE__);
-        e.reason = s.str();
-        throw e;
-    }
-    catch(...)
-    {
-        ostringstream s;
-        s << "ServiceManager: unknown exception in entry point `" + entryPoint + "' for service " << service;
-
-        FailureException e(__FILE__, __LINE__);
-        e.reason = s.str();
-        throw e;
+        assert(_sharedCommunicator);
+        communicator = _sharedCommunicator;
     }
-
-    //
-    // Invoke Service::start().
-    //
-    try
+    else
     {
-        //
-        // If Ice.UseSharedCommunicator.<name> is not defined, create
-        // a communicator for the service. The communicator inherits
-        // from the shared communicator properties. If it's defined
-        // add the service properties to the shared commnunicator
-        // property set.
-        //
-        Ice::CommunicatorPtr communicator;
-        if(_communicator->getProperties()->getPropertyAsInt("IceBox.UseSharedCommunicator." + service) > 0)
-        {
-            assert(_sharedCommunicator);
-            communicator = _sharedCommunicator;
-        }
-        else
+        try
         {
             //
             // Create the service properties. We use the communicator properties as the default
@@ -624,19 +554,19 @@ IceBox::ServiceManagerI::start(const string& service, const string& entryPoint,
                 // read the service config file if it's specified with --Ice.Config.
                 //
                 initData.properties = createProperties(info.args, initData.properties);
-
+                
                 //
                 // Next, parse the service "<service>.*" command line options (the Ice command
                 // line options were parsed by the createProperties above)
                 //
                 info.args = initData.properties->parseCommandLineOptions(service, info.args);
             }
-
+            
             //
             // Clone the logger to assign a new prefix.
             //
             initData.logger = _logger->cloneWithPrefix(initData.properties->getProperty("Ice.ProgramName"));
-
+            
             //
             // Remaining command line options are passed to the communicator. This is
             // necessary for Ice plug-in properties (e.g.: IceSSL).
@@ -644,15 +574,69 @@ IceBox::ServiceManagerI::start(const string& service, const string& entryPoint,
             info.communicator = initialize(info.args, initData);
             communicator = info.communicator;
         }
+        catch(const Exception& ex)
+        {
+            ostringstream s;
+            s << "ServiceManager: exception while starting service " << service << ":\n";
+            s << ex;
 
+            FailureException e(__FILE__, __LINE__);
+            e.reason = s.str();
+            throw e;
+        }
+    }
+
+    try
+    {
+        //
+        // Add a PropertiesAdmin facet to the service manager's communicator that provides
+        // access to this service's property set. We do this prior to instantiating the
+        // service so that the service's constructor is able to access the facet (e.g.,
+        // in case it wants to set a callback).
+        //
+        string facetName = "IceBox.Service." + info.name + ".Properties";
+        _communicator->addAdminFacet(
+            new PropertiesAdminI(facetName, communicator->getProperties(), communicator->getLogger()), facetName);
+
+        //
+        // Invoke the factory function.
+        //
+        SERVICE_FACTORY factory = (SERVICE_FACTORY)sym;
+        try
+        {
+            info.service = factory(_communicator);
+        }
+        catch(const FailureException&)
+        {
+            throw;
+        }
+        catch(const Exception& ex)
+        {
+            ostringstream s;
+            s << "ServiceManager: exception in entry point `" + entryPoint + "' for service " << info.name << ":\n";
+            s << ex;
+            
+            FailureException e(__FILE__, __LINE__);
+            e.reason = s.str();
+            throw e;
+        }
+        catch(...)
+        {
+            ostringstream s;
+            s << "ServiceManager: unknown exception in entry point `" + entryPoint + "' for service " << info.name;
+            
+            FailureException e(__FILE__, __LINE__);
+            e.reason = s.str();
+            throw e;
+        }
+            
         //
         // Start the service.
         //
         try
         {
-            info.service->start(service, communicator, info.args);
-            info.status = Started;
-
+            info.service->start(info.name, communicator, info.args);
+            
             //
             // There is no need to notify the observers since the 'start all'
             // (that indirectly calls this function) occurs before the creation of
@@ -660,71 +644,61 @@ IceBox::ServiceManagerI::start(const string& service, const string& entryPoint,
             // object adapter (so before any observer can be registered)
             //
         }
+        catch(const FailureException&)
+        {
+            throw;
+        }
+        catch(const Exception& ex)
+        {
+            ostringstream s;
+            s << "ServiceManager: exception while starting service " << info.name << ":\n";
+            s << ex;
+
+            FailureException e(__FILE__, __LINE__);
+            e.reason = s.str();
+            throw e;
+        }
         catch(...)
         {
-            if(info.communicator)
-            {
-                try
-                {
-                    info.communicator->shutdown();
-                    info.communicator->waitForShutdown();
-                }
-                catch(const Ice::CommunicatorDestroyedException&)
-                {
-                    //
-                    // Ignore, the service might have already destroyed
-                    // the communicator for its own reasons.
-                    //
-                }
-                catch(const Ice::Exception& ex)
-                {
-                    Warning out(_logger);
-                    out << "ServiceManager: exception while shutting down communicator for service " << service
-                        << ":\n";
-                    out << ex;
-                }
+            ostringstream s;
+            s << "ServiceManager: unknown exception while starting service " << info.name;
 
-                try
-                {
-                    info.communicator->destroy();
-                    info.communicator = 0;
-                }
-                catch(const Exception& ex)
-                {
-                    Warning out(_logger);
-                    out << "ServiceManager: exception while destroying communicator for service " << service
-                        << ":\n";
-                    out << ex;
-                }
-            }
-            throw;
+            FailureException e(__FILE__, __LINE__);
+            e.reason = s.str();
+            throw e;
         }
 
         info.library = library;
+        info.status = Started;
         _services.push_back(info);
     }
-    catch(const FailureException&)
+    catch(const ObjectAdapterDeactivatedException&)
     {
-        throw;
+        //
+        // Can be raised by addAdminFacet if the service manager communicator has been shut down.
+        //
+        if(info.communicator)
+        {
+            destroyServiceCommunicator(info.name, info.communicator);
+        }
     }
-    catch(const Exception& ex)
+    catch(const Exception&)
     {
-        ostringstream s;
-        s << "ServiceManager: exception while starting service " << service << ":\n";
-        s << ex;
+        try
+        {
+            _communicator->removeAdminFacet("IceBox.Service." + info.name + ".Properties");
+        }
+        catch(const LocalException&)
+        {
+            // Ignored
+        }
 
-        FailureException e(__FILE__, __LINE__);
-        e.reason = s.str();
-        throw e;
-    }
-    catch(...)
-    {
-        ostringstream s;
-        s << "ServiceManager: unknown exception while starting service " << service;
+        if(info.communicator)
+        {
+            destroyServiceCommunicator(info.name, info.communicator);
+        }
 
-        FailureException e(__FILE__, __LINE__);
-        e.reason = s.str();
-        throw e;
+        throw;
     }
 }
 
@@ -764,7 +738,7 @@ IceBox::ServiceManagerI::stopAll()
                 info.status = Stopped;
                 stoppedServices.push_back(info.name);
             }
-            catch(const Ice::Exception& ex)
+            catch(const Exception& ex)
             {
                 Warning out(_logger);
                 out << "ServiceManager: exception while stopping service " << info.name << ":\n";
@@ -798,14 +772,14 @@ IceBox::ServiceManagerI::stopAll()
                 info.communicator->shutdown();
                 info.communicator->waitForShutdown();
             }
-            catch(const Ice::CommunicatorDestroyedException&)
+            catch(const CommunicatorDestroyedException&)
             {
                 //
                 // Ignore, the service might have already destroyed
                 // the communicator for its own reasons.
                 //
             }
-            catch(const Ice::Exception& ex)
+            catch(const Exception& ex)
             {
                 Warning out(_logger);
                 out << "ServiceManager: exception while stopping service " << info.name << ":\n";
@@ -983,3 +957,37 @@ ServiceManagerI::observerCompleted(const Ice::AsyncResultPtr& result)
         }
      }
 }
+
+void
+IceBox::ServiceManagerI::destroyServiceCommunicator(const string& service, const CommunicatorPtr& communicator)
+{
+    try
+    {
+        communicator->shutdown();
+        communicator->waitForShutdown();
+    }
+    catch(const CommunicatorDestroyedException&)
+    {
+        //
+        // Ignore, the service might have already destroyed
+        // the communicator for its own reasons.
+        //
+    }
+    catch(const Exception& ex)
+    {
+        Warning out(_logger);
+        out << "ServiceManager: exception in shutting down communicator for service " << service << ":\n";
+        out << ex;
+    }
+
+    try
+    {
+        communicator->destroy();
+    }
+    catch(const Exception& ex)
+    {
+        Warning out(_logger);
+        out << "ServiceManager: exception in shutting down communicator for service " << service << ":\n";
+        out << ex;
+    }
+}
diff --git a/cpp/src/IceBox/ServiceManagerI.h b/cpp/src/IceBox/ServiceManagerI.h
index 9c381941b49..a2b5388f4a8 100644
--- a/cpp/src/IceBox/ServiceManagerI.h
+++ b/cpp/src/IceBox/ServiceManagerI.h
@@ -70,6 +70,7 @@ private:
     void observerRemoved(const ServiceObserverPrx&, const std::exception&);
 
     Ice::PropertiesPtr createServiceProperties(const std::string&);
+    void destroyServiceCommunicator(const std::string&, const Ice::CommunicatorPtr&);
     
     ::Ice::CommunicatorPtr _communicator;
     ::Ice::CommunicatorPtr _sharedCommunicator;
diff --git a/cpp/src/IceGrid/AdminI.cpp b/cpp/src/IceGrid/AdminI.cpp
index 7453a93902b..624f143c1ba 100644
--- a/cpp/src/IceGrid/AdminI.cpp
+++ b/cpp/src/IceGrid/AdminI.cpp
@@ -187,7 +187,7 @@ void
 AdminI::syncApplication(const ApplicationDescriptor& descriptor, const Current&)
 {
     checkIsReadOnly();
-    _database->syncApplicationDescriptor(descriptor, _session.get());
+    _database->syncApplicationDescriptor(descriptor, false, _session.get());
 }
 
 void
@@ -200,7 +200,27 @@ AdminI::updateApplication(const ApplicationUpdateDescriptor& descriptor, const C
     update.updateUser = _session->getId();
     update.descriptor = descriptor;
     update.revision = -1; // The database will set it.
-    _database->updateApplication(update, _session.get());
+    _database->updateApplication(update, false, _session.get());
+}
+
+void
+AdminI::syncApplicationWithoutRestart(const ApplicationDescriptor& descriptor, const Current&)
+{
+    checkIsReadOnly();
+    _database->syncApplicationDescriptor(descriptor, true, _session.get());
+}
+
+void
+AdminI::updateApplicationWithoutRestart(const ApplicationUpdateDescriptor& descriptor, const Current&)
+{
+    checkIsReadOnly();
+
+    ApplicationUpdateInfo update;
+    update.updateTime = IceUtil::Time::now().toMilliSeconds();
+    update.updateUser = _session->getId();
+    update.descriptor = descriptor;
+    update.revision = -1; // The database will set it.
+    _database->updateApplication(update, true, _session.get());
 }
 
 void
diff --git a/cpp/src/IceGrid/AdminI.h b/cpp/src/IceGrid/AdminI.h
index 5ed1c5ee11c..864170dec19 100644
--- a/cpp/src/IceGrid/AdminI.h
+++ b/cpp/src/IceGrid/AdminI.h
@@ -36,6 +36,8 @@ public:
     virtual void addApplication(const ApplicationDescriptor&, const Ice::Current&);
     virtual void syncApplication(const ApplicationDescriptor&, const Ice::Current&);
     virtual void updateApplication(const ApplicationUpdateDescriptor&, const Ice::Current&);
+    virtual void syncApplicationWithoutRestart(const ApplicationDescriptor&, const Ice::Current&);
+    virtual void updateApplicationWithoutRestart(const ApplicationUpdateDescriptor&, const Ice::Current&);
     virtual void removeApplication(const std::string&, const Ice::Current&);
     virtual void instantiateServer(const std::string&, const std::string&, const ServerInstanceDescriptor&, 
                                    const Ice::Current&);
diff --git a/cpp/src/IceGrid/Database.cpp b/cpp/src/IceGrid/Database.cpp
index 9326ea2e62f..0d8fb7888dd 100644
--- a/cpp/src/IceGrid/Database.cpp
+++ b/cpp/src/IceGrid/Database.cpp
@@ -43,30 +43,6 @@ struct ObjectLoadCI : binary_function<pair<Ice::ObjectPrx, float>&, pair<Ice::Ob
     }
 };
 
-bool 
-isServerUpdated(const ServerInfo& lhs, const ServerInfo& rhs)
-{
-    if(lhs.node != rhs.node)
-    {
-        return true;
-    }
-
-    IceBoxDescriptorPtr lhsIceBox = IceBoxDescriptorPtr::dynamicCast(lhs.descriptor);
-    IceBoxDescriptorPtr rhsIceBox = IceBoxDescriptorPtr::dynamicCast(rhs.descriptor);
-    if(lhsIceBox && rhsIceBox)
-    {
-        return IceBoxHelper(lhsIceBox) != IceBoxHelper(rhsIceBox);
-    }
-    else if(!lhsIceBox && !rhsIceBox)
-    {
-        return ServerHelper(lhs.descriptor) != ServerHelper(rhs.descriptor);
-    }
-    else
-    {
-        return true;
-    }
-}
-
 void
 halt(const Ice::CommunicatorPtr& com, const DatabaseException& ex)
 {
@@ -275,7 +251,7 @@ Database::syncApplications(const ApplicationInfoSeq& newApplications)
                 {
                     ApplicationHelper previous(_communicator, q->second.descriptor);
                     ApplicationHelper helper(_communicator, p->descriptor);
-                    reload(previous, helper, entries, p->uuid, p->revision);
+                    reload(previous, helper, entries, p->uuid, p->revision, false);
                 }
                 else
                 {
@@ -466,12 +442,12 @@ Database::addApplication(const ApplicationInfo& info, AdminSessionI* session)
 }
 
 void
-Database::updateApplication(const ApplicationUpdateInfo& updt, AdminSessionI* session)
+Database::updateApplication(const ApplicationUpdateInfo& updt, bool noRestart, AdminSessionI* session)
 {
-    ServerEntrySeq entries;
     ApplicationInfo oldApp;
-    ApplicationDescriptor newDesc;
     ApplicationUpdateInfo update = updt;
+    auto_ptr<ApplicationHelper> previous;
+    auto_ptr<ApplicationHelper> helper;
     try
     {
         Lock sync(*this);       
@@ -495,20 +471,8 @@ Database::updateApplication(const ApplicationUpdateInfo& updt, AdminSessionI* se
             update.revision = oldApp.revision + 1;
         }
 
-        ApplicationHelper previous(_communicator, oldApp.descriptor);
-        ApplicationHelper helper(_communicator, previous.update(update.descriptor), true);
-        newDesc = helper.getDefinition();
-
-        checkForUpdate(previous, helper, connection);
-
-        ApplicationInfo info = oldApp;
-        info.updateTime = update.updateTime;
-        info.updateUser = update.updateUser;
-        info.revision = update.revision;
-        info.descriptor = newDesc;
-        saveApplication(info, connection);
-
-        reload(previous, helper, entries, oldApp.uuid, oldApp.revision + 1);
+        previous.reset(new ApplicationHelper(_communicator, oldApp.descriptor));
+        helper.reset(new ApplicationHelper(_communicator, previous->update(update.descriptor), true));
 
         startUpdating(update.descriptor.name, oldApp.uuid, oldApp.revision + 1);
     }
@@ -517,15 +481,16 @@ Database::updateApplication(const ApplicationUpdateInfo& updt, AdminSessionI* se
         halt(_communicator, ex);
     }
 
-    finishApplicationUpdate(entries, update, oldApp, newDesc, session);
+    finishApplicationUpdate(update, oldApp, *previous, *helper, session, noRestart);
 }
 
 void
-Database::syncApplicationDescriptor(const ApplicationDescriptor& newDesc, AdminSessionI* session)
+Database::syncApplicationDescriptor(const ApplicationDescriptor& newDesc, bool noRestart, AdminSessionI* session)
 {
-    ServerEntrySeq entries;
     ApplicationUpdateInfo update;
     ApplicationInfo oldApp;
+    auto_ptr<ApplicationHelper> previous;
+    auto_ptr<ApplicationHelper> helper;
     try
     {
         Lock sync(*this);
@@ -544,25 +509,14 @@ Database::syncApplicationDescriptor(const ApplicationDescriptor& newDesc, AdminS
             throw ApplicationNotExistException(newDesc.name);
         }
 
-        ApplicationHelper previous(_communicator, oldApp.descriptor);
-        ApplicationHelper helper(_communicator, newDesc, true);
+        previous.reset(new ApplicationHelper(_communicator, oldApp.descriptor));
+        helper.reset(new ApplicationHelper(_communicator, newDesc, true));
 
         update.updateTime = IceUtil::Time::now().toMilliSeconds();
         update.updateUser = _lockUserId;
         update.revision = oldApp.revision + 1;
-        update.descriptor = helper.diff(previous);
+        update.descriptor = helper->diff(*previous);
         
-        checkForUpdate(previous, helper, connection);
-
-        ApplicationInfo info = oldApp;
-        info.updateTime = update.updateTime;
-        info.updateUser = update.updateUser;
-        info.revision = update.revision;
-        info.descriptor = newDesc;
-        saveApplication(info, connection);
-
-        reload(previous, helper, entries, oldApp.uuid, oldApp.revision + 1);
-
         startUpdating(update.descriptor.name, oldApp.uuid, oldApp.revision + 1);
     }
     catch(const DatabaseException& ex)
@@ -570,7 +524,7 @@ Database::syncApplicationDescriptor(const ApplicationDescriptor& newDesc, AdminS
         halt(_communicator, ex);
     }
 
-    finishApplicationUpdate(entries, update, oldApp, newDesc, session);
+    finishApplicationUpdate(update, oldApp, *previous, *helper, session, noRestart);
 }
 
 void
@@ -579,10 +533,10 @@ Database::instantiateServer(const string& application,
                             const ServerInstanceDescriptor& instance,
                             AdminSessionI* session)
 {
-    ServerEntrySeq entries;
     ApplicationUpdateInfo update;
     ApplicationInfo oldApp;
-    ApplicationDescriptor newDesc;
+    auto_ptr<ApplicationHelper> previous;
+    auto_ptr<ApplicationHelper> helper;
 
     try
     {
@@ -602,25 +556,13 @@ Database::instantiateServer(const string& application,
             throw ApplicationNotExistException(application);
         }
 
-        ApplicationHelper previous(_communicator, oldApp.descriptor);
-        ApplicationHelper helper(_communicator, previous.instantiateServer(node, instance), true);
-        newDesc = helper.getDefinition();
+        previous.reset(new ApplicationHelper(_communicator, oldApp.descriptor));
+        helper.reset(new ApplicationHelper(_communicator, previous->instantiateServer(node, instance), true));
 
         update.updateTime = IceUtil::Time::now().toMilliSeconds();
         update.updateUser = _lockUserId;
         update.revision = oldApp.revision + 1;
-        update.descriptor = helper.diff(previous);
-
-        checkForUpdate(previous, helper, connection);
-
-        ApplicationInfo info = oldApp;
-        info.updateTime = update.updateTime;
-        info.updateUser = update.updateUser;
-        info.revision = update.revision;
-        info.descriptor = newDesc;
-        saveApplication(info, connection);
-
-        reload(previous, helper, entries, oldApp.uuid, oldApp.revision + 1);
+        update.descriptor = helper->diff(*previous);
 
         startUpdating(update.descriptor.name, oldApp.uuid, oldApp.revision + 1);
     }
@@ -629,7 +571,7 @@ Database::instantiateServer(const string& application,
         halt(_communicator, ex);
     }
 
-    finishApplicationUpdate(entries, update, oldApp, newDesc, session);
+    finishApplicationUpdate(update, oldApp, *previous, *helper, session, true);
 }
 
 void
@@ -1034,7 +976,7 @@ Database::getAdapterInfo(const string& id)
     // Otherwise, we check the adapter endpoint table -- if there's an
     // entry the adapter is managed by the registry itself.
     //
-    DatabaseConnectionPtr connection = _databaseCache->getConnection();
+    DatabaseConnectionPtr connection = _databaseCache->newConnection();
     AdaptersWrapperPtr adaptersWrapper = _databaseCache->getAdapters(connection);
     AdapterInfoSeq infos;
     try
@@ -1878,7 +1820,7 @@ Database::load(const ApplicationHelper& app, ServerEntrySeq& entries, const stri
     map<string, ServerInfo> servers = app.getServerInfos(uuid, revision);
     for(map<string, ServerInfo>::const_iterator p = servers.begin(); p != servers.end(); ++p)
     {
-        entries.push_back(_serverCache.add(p->second));
+        entries.push_back(_serverCache.add(p->second, false));
     }
 }
 
@@ -1914,7 +1856,8 @@ Database::reload(const ApplicationHelper& oldApp,
                  const ApplicationHelper& newApp, 
                  ServerEntrySeq& entries, 
                  const string& uuid, 
-                 int revision)
+                 int revision, 
+                 bool noRestart)
 {
     const string application = oldApp.getInstance().name;
 
@@ -1940,7 +1883,7 @@ Database::reload(const ApplicationHelper& oldApp,
         else
         {
             ServerEntryPtr server = _serverCache.get(p->first);
-            server->update(q->second); // Just update the server revision on the node.
+            server->update(q->second, noRestart); // Just update the server revision on the node.
             entries.push_back(server);
         }
     }
@@ -2028,7 +1971,7 @@ Database::reload(const ApplicationHelper& oldApp,
     //
     for(vector<ServerInfo>::const_iterator q = load.begin(); q != load.end(); ++q)
     {
-        entries.push_back(_serverCache.add(*q));
+        entries.push_back(_serverCache.add(*q, noRestart));
     }
 }
 
@@ -2081,17 +2024,205 @@ Database::removeApplication(const string& name, const DatabaseConnectionPtr& con
 }
 
 void
-Database::finishApplicationUpdate(ServerEntrySeq& entries, 
-                                  const ApplicationUpdateInfo& update,
-                                  const ApplicationInfo& oldApp, 
-                                  const ApplicationDescriptor& newDesc,
-                                  AdminSessionI* session)
+Database::checkUpdate(const ApplicationHelper& oldApp,
+                      const ApplicationHelper& newApp,
+                      const string& uuid,
+                      int revision,
+                      bool noRestart)
 {
+    const string application = oldApp.getInstance().name;
+
+    map<string, ServerInfo> oldServers = oldApp.getServerInfos(uuid, revision);
+    map<string, ServerInfo> newServers = newApp.getServerInfos(uuid, revision + 1);
+
+    map<string, ServerInfo>::const_iterator p;
+    vector<string> servers;
+    vector<string> reasons;
+    if(noRestart)
+    {
+        for(p = oldServers.begin(); p != oldServers.end(); ++p)
+        {
+            map<string, ServerInfo>::const_iterator q = newServers.find(p->first);
+            if(q == newServers.end())
+            {
+                servers.push_back(p->first);
+                reasons.push_back("server `" + p->first + "' needs to be removed");
+            }
+        }
+    }
+
+    vector<CheckUpdateResultPtr> results;
+    set<string> unreachableNodes;
+    for(p = newServers.begin(); p != newServers.end(); ++p)
+    {
+        map<string, ServerInfo>::const_iterator q = oldServers.find(p->first);
+        if(q != oldServers.end() && isServerUpdated(p->second, q->second))
+        {
+            if(noRestart && isServerUpdated(p->second, q->second, true)) // Ignore properties
+            {
+                //
+                // The updates are not only property updates and noRestart is required, no
+                // need to check the server update on the node, we know already it requires
+                // a restart.
+                //
+                servers.push_back(p->first);
+                reasons.push_back("update requires the server `" + p->first + "' to be stopped");
+            }
+            else
+            {
+                //
+                // Ask the node to check the server update.
+                //
+                try
+                {
+                    CheckUpdateResultPtr result = _serverCache.get(p->first)->checkUpdate(p->second, noRestart);
+                    if(result)
+                    {
+                        results.push_back(result);
+                    }
+                }
+                catch(const NodeUnreachableException& ex)
+                {
+                    unreachableNodes.insert(ex.name);
+                }
+                catch(const DeploymentException& ex)
+                {
+                    servers.push_back(p->first);
+                    reasons.push_back(ex.reason);
+                }
+
+            }
+        }
+    }
+
+    for(vector<CheckUpdateResultPtr>::const_iterator q = results.begin(); q != results.end(); ++q)
+    {
+        try
+        {
+            (*q)->getResult();
+        }
+        catch(const NodeUnreachableException& ex)
+        {
+            unreachableNodes.insert(ex.name);
+        }
+        catch(const DeploymentException& ex)
+        {
+            servers.push_back((*q)->getServer());
+            reasons.push_back(ex.reason);
+        }
+    }
+
+    if(noRestart)
+    {
+        if(!servers.empty() || !unreachableNodes.empty())
+        {
+            if(_traceLevels->application > 0)
+            {
+                Ice::Trace out(_traceLevels->logger, _traceLevels->applicationCat);
+                out << "check for application `" << application << "' update failed:";
+                if(!unreachableNodes.empty())
+                {
+                    Ice::StringSeq nodes(unreachableNodes.begin(), unreachableNodes.end());
+                    if(nodes.size() == 1)
+                    {
+                        out << "\nthe node `" << nodes[0] << "' is down";
+                    }
+                    else
+                    {
+                        out << "\nthe nodes `" << toString(nodes, ", ") << "' are down";
+                    }
+                }
+                if(!reasons.empty())
+                {
+                    for(vector<string>::const_iterator p = reasons.begin(); p != reasons.end(); ++p)
+                    {
+                        out << "\n" << *p;
+                    }
+                }
+            }
+
+            ostringstream os;
+            os << "check for application `" << application << "' update failed:";
+            if(!servers.empty())
+            {
+                if(servers.size() == 1)
+                {
+                    os << "\nthe server `" << servers[0] << "' would need to be stopped";
+                }
+                else
+                {
+                    os << "\nthe servers `" << toString(servers, ", ") << "' would need to be stopped";
+                }
+            }
+            if(!unreachableNodes.empty())
+            {
+                Ice::StringSeq nodes(unreachableNodes.begin(), unreachableNodes.end());
+                if(nodes.size() == 1)
+                {
+                    os << "\nthe node `" << nodes[0] << "' is down";
+                }
+                else
+                {
+                    os << "\nthe nodes `" << toString(nodes, ", ") << "' are down";
+                }
+            }
+            throw DeploymentException(os.str());
+        }
+    }
+    else if(!reasons.empty())
+    {
+        ostringstream os;
+        os << "check for application `" << application << "' update failed:";
+        for(vector<string>::const_iterator p = reasons.begin(); p != reasons.end(); ++p)
+        {
+            os << "\n" << *p;
+        }
+        throw DeploymentException(os.str());
+    }
+}
+
+void
+Database::finishApplicationUpdate(const ApplicationUpdateInfo& update,
+                                  const ApplicationInfo& oldApp,
+                                  const ApplicationHelper& previous, 
+                                  const ApplicationHelper& helper,
+                                  AdminSessionI* session,
+                                  bool noRestart)
+{
+    const ApplicationDescriptor& newDesc = helper.getDefinition();
+    DatabaseConnectionPtr connection = _databaseCache->newConnection();
+
+    ServerEntrySeq entries;
+    try
+    {
+        if(_master)
+        {
+            checkUpdate(previous, helper, oldApp.uuid, oldApp.revision, noRestart);
+        }
+
+        Lock sync(*this);
+        checkForUpdate(previous, helper, connection);
+        reload(previous, helper, entries, oldApp.uuid, oldApp.revision + 1, noRestart);
+    }
+    catch(const DeploymentException&)
+    {
+        finishUpdating(update.descriptor.name);
+        throw;
+    }
+
     for_each(entries.begin(), entries.end(), IceUtil::voidMemFun(&ServerEntry::sync));
 
     int serial;
     {
         Lock sync(*this);
+
+        ApplicationInfo info = oldApp;
+        info.updateTime = update.updateTime;
+        info.updateUser = update.updateUser;
+        info.revision = update.revision;
+        info.descriptor = newDesc;
+        saveApplication(info, connection);
+
         ++_applicationSerial;
         serial = _applicationObserverTopic->applicationUpdated(_applicationSerial, update);
     }
@@ -2135,8 +2266,8 @@ Database::finishApplicationUpdate(ServerEntrySeq& entries,
 
                 ApplicationInfo info = oldApp;
                 info.revision = update.revision + 1;
-                saveApplication(info, _databaseCache->getConnection());
-                reload(previous, helper, entries, info.uuid, info.revision);
+                saveApplication(info, connection);
+                reload(previous, helper, entries, info.uuid, info.revision, noRestart);
 
                 newUpdate.updateTime = IceUtil::Time::now().toMilliSeconds();
                 newUpdate.updateUser = _lockUserId;
diff --git a/cpp/src/IceGrid/Database.h b/cpp/src/IceGrid/Database.h
index bd437619dcf..e3bae73ab67 100644
--- a/cpp/src/IceGrid/Database.h
+++ b/cpp/src/IceGrid/Database.h
@@ -73,8 +73,8 @@ public:
     void syncObjects(const ObjectInfoSeq&);
 
     void addApplication(const ApplicationInfo&, AdminSessionI* = 0);
-    void updateApplication(const ApplicationUpdateInfo&, AdminSessionI* = 0);
-    void syncApplicationDescriptor(const ApplicationDescriptor&, AdminSessionI* = 0);
+    void updateApplication(const ApplicationUpdateInfo&, bool, AdminSessionI* = 0);
+    void syncApplicationDescriptor(const ApplicationDescriptor&, bool, AdminSessionI* = 0);
     void instantiateServer(const std::string&, const std::string&, const ServerInstanceDescriptor&, AdminSessionI* =0);
     void removeApplication(const std::string&, AdminSessionI* = 0);
     ApplicationInfo getApplicationInfo(const std::string&);
@@ -140,13 +140,15 @@ private:
 
     void load(const ApplicationHelper&, ServerEntrySeq&, const std::string&, int);
     void unload(const ApplicationHelper&, ServerEntrySeq&);
-    void reload(const ApplicationHelper&, const ApplicationHelper&, ServerEntrySeq&, const std::string&, int);
+    void reload(const ApplicationHelper&, const ApplicationHelper&, ServerEntrySeq&, const std::string&, int, bool);
+
+    void checkUpdate(const ApplicationHelper&, const ApplicationHelper&, const std::string&, int, bool);
 
     void saveApplication(const ApplicationInfo&, const IceDB::DatabaseConnectionPtr&);
     void removeApplication(const std::string&, const IceDB::DatabaseConnectionPtr&);
 
-    void finishApplicationUpdate(ServerEntrySeq&, const ApplicationUpdateInfo&, const ApplicationInfo&, 
-                                 const ApplicationDescriptor&, AdminSessionI*);
+    void finishApplicationUpdate(const ApplicationUpdateInfo&, const ApplicationInfo&, const ApplicationHelper&,
+                                 const ApplicationHelper&, AdminSessionI*, bool);
 
     void checkSessionLock(AdminSessionI*);
 
diff --git a/cpp/src/IceGrid/DescriptorHelper.cpp b/cpp/src/IceGrid/DescriptorHelper.cpp
index 67467f280f9..ce9a74810e6 100644
--- a/cpp/src/IceGrid/DescriptorHelper.cpp
+++ b/cpp/src/IceGrid/DescriptorHelper.cpp
@@ -915,8 +915,8 @@ Resolver::checkReserved(const string& type, const map<string, string>& values) c
     }
 }
 
-CommunicatorHelper::CommunicatorHelper(const CommunicatorDescriptorPtr& desc) : 
-    _desc(desc)
+CommunicatorHelper::CommunicatorHelper(const CommunicatorDescriptorPtr& desc, bool ignoreProps) : 
+    _desc(desc), _ignoreProps(ignoreProps)
 {
 }
 
@@ -939,9 +939,12 @@ CommunicatorHelper::operator==(const CommunicatorHelper& helper) const
         return false;
     }
 
-    if(_desc->propertySet != helper._desc->propertySet)
+    if(!_ignoreProps)
     {
-        return false;
+        if(_desc->propertySet != helper._desc->propertySet)
+        {
+            return false;
+        }
     }
 
     if(set<DbEnvDescriptor>(_desc->dbEnvs.begin(), _desc->dbEnvs.end()) != 
@@ -1206,8 +1209,8 @@ CommunicatorHelper::getProperty(const string& name) const
     return IceGrid::getProperty(_desc->propertySet.properties, name);
 }
 
-ServiceHelper::ServiceHelper(const ServiceDescriptorPtr& descriptor) :
-    CommunicatorHelper(descriptor),
+ServiceHelper::ServiceHelper(const ServiceDescriptorPtr& descriptor, bool ignoreProps) :
+    CommunicatorHelper(descriptor, ignoreProps),
     _desc(descriptor)
 {
 }
@@ -1284,8 +1287,8 @@ ServiceHelper::print(const Ice::CommunicatorPtr& communicator, Output& out) cons
     out << eb;
 }
 
-ServerHelper::ServerHelper(const ServerDescriptorPtr& descriptor) :
-    CommunicatorHelper(descriptor),
+ServerHelper::ServerHelper(const ServerDescriptorPtr& descriptor, bool ignoreProps) :
+    CommunicatorHelper(descriptor, ignoreProps),
     _desc(descriptor)
 {
 }
@@ -1504,13 +1507,13 @@ ServerHelper::instantiateImpl(const ServerDescriptorPtr& instance,
     instance->propertySet.properties.insert(instance->propertySet.properties.end(), props.begin(), props.end());
 }
 
-IceBoxHelper::IceBoxHelper(const IceBoxDescriptorPtr& descriptor) :
-    ServerHelper(descriptor),
+IceBoxHelper::IceBoxHelper(const IceBoxDescriptorPtr& descriptor, bool ignoreProps) :
+    ServerHelper(descriptor, ignoreProps),
     _desc(descriptor)
 {
     for(ServiceInstanceDescriptorSeq::const_iterator p = _desc->services.begin(); p != _desc->services.end(); ++p)
     {
-        _services.push_back(ServiceInstanceHelper(*p));
+        _services.push_back(ServiceInstanceHelper(*p, ignoreProps));
     }
 }
 
@@ -1671,7 +1674,7 @@ InstanceHelper::instantiateParams(const Resolver& resolve,
     return params;
 }
 
-ServiceInstanceHelper::ServiceInstanceHelper(const ServiceInstanceDescriptor& desc) :
+ServiceInstanceHelper::ServiceInstanceHelper(const ServiceInstanceDescriptor& desc, bool ignoreProps) :
     _def(desc)
 {
     //
@@ -1686,7 +1689,7 @@ ServiceInstanceHelper::ServiceInstanceHelper(const ServiceInstanceDescriptor& de
 
     if(_def.descriptor)
     {
-        _service = ServiceHelper(_def.descriptor);
+        _service = ServiceHelper(_def.descriptor, ignoreProps);
     }
 }
 
@@ -3153,17 +3156,17 @@ ApplicationHelper::printDiff(Output& out, const ApplicationHelper& helper) const
 }
 
 bool
-IceGrid::descriptorEqual(const ServerDescriptorPtr& lhs, const ServerDescriptorPtr& rhs)
+IceGrid::descriptorEqual(const ServerDescriptorPtr& lhs, const ServerDescriptorPtr& rhs, bool ignoreProps)
 {
     IceBoxDescriptorPtr lhsIceBox = IceBoxDescriptorPtr::dynamicCast(lhs);
     IceBoxDescriptorPtr rhsIceBox = IceBoxDescriptorPtr::dynamicCast(rhs);
     if(lhsIceBox && rhsIceBox)
     {
-        return IceBoxHelper(lhsIceBox) == IceBoxHelper(rhsIceBox);
+        return IceBoxHelper(lhsIceBox, ignoreProps) == IceBoxHelper(rhsIceBox, ignoreProps);
     }
     else if(!lhsIceBox && !rhsIceBox)
     {
-        return ServerHelper(lhs) == ServerHelper(rhs);
+        return ServerHelper(lhs, ignoreProps) == ServerHelper(rhs, ignoreProps);
     }
     else
     {
@@ -3184,3 +3187,13 @@ IceGrid::createHelper(const ServerDescriptorPtr& desc)
         return new ServerHelper(desc);
     }
 }
+
+bool 
+IceGrid::isServerUpdated(const ServerInfo& lhs, const ServerInfo& rhs, bool ignoreProps)
+{
+    if(lhs.node != rhs.node)
+    {
+        return true;
+    }
+    return !descriptorEqual(lhs.descriptor, rhs.descriptor, ignoreProps);
+}
diff --git a/cpp/src/IceGrid/DescriptorHelper.h b/cpp/src/IceGrid/DescriptorHelper.h
index b2b012c5e49..eeda3eee3a1 100644
--- a/cpp/src/IceGrid/DescriptorHelper.h
+++ b/cpp/src/IceGrid/DescriptorHelper.h
@@ -85,8 +85,8 @@ class CommunicatorHelper
 {
 public:
 
-    CommunicatorHelper(const CommunicatorDescriptorPtr&);
-    CommunicatorHelper() { }
+    CommunicatorHelper(const CommunicatorDescriptorPtr&, bool = false);
+    CommunicatorHelper() : _ignoreProps(false) { }
     virtual ~CommunicatorHelper() { }
 
     virtual bool operator==(const CommunicatorHelper&) const;
@@ -109,13 +109,14 @@ protected:
 private:
 
     CommunicatorDescriptorPtr _desc;
+    bool _ignoreProps;
 };
 
 class ServiceHelper : public CommunicatorHelper
 {
 public:
 
-    ServiceHelper(const ServiceDescriptorPtr&);
+    ServiceHelper(const ServiceDescriptorPtr&, bool = false);
     ServiceHelper() { }
 
     virtual bool operator==(const CommunicatorHelper&) const;
@@ -143,7 +144,7 @@ class ServerHelper : public CommunicatorHelper, public IceUtil::SimpleShared
 {
 public:
 
-    ServerHelper(const ServerDescriptorPtr&);
+    ServerHelper(const ServerDescriptorPtr&, bool = false);
     ServerHelper() { }
 
     virtual bool operator==(const CommunicatorHelper&) const;
@@ -185,7 +186,7 @@ class ServiceInstanceHelper : public InstanceHelper
 {
 public:
 
-    ServiceInstanceHelper(const ServiceInstanceDescriptor&);
+    ServiceInstanceHelper(const ServiceInstanceDescriptor&, bool);
 
     bool operator==(const ServiceInstanceHelper&) const;
     bool operator!=(const ServiceInstanceHelper&) const;
@@ -207,7 +208,7 @@ class IceBoxHelper : public ServerHelper
 {
 public:
 
-    IceBoxHelper(const IceBoxDescriptorPtr&);
+    IceBoxHelper(const IceBoxDescriptorPtr&, bool = false);
     IceBoxHelper() { }
 
     virtual bool operator==(const CommunicatorHelper&) const;
@@ -339,7 +340,8 @@ private:
     NodeHelperDict _nodes;
 };
 
-bool descriptorEqual(const ServerDescriptorPtr&, const ServerDescriptorPtr&);
+bool descriptorEqual(const ServerDescriptorPtr&, const ServerDescriptorPtr&, bool = false);
 ServerHelperPtr createHelper(const ServerDescriptorPtr&);
+bool isServerUpdated(const ServerInfo&, const ServerInfo&, bool = false);
 
 }
diff --git a/cpp/src/IceGrid/Internal.ice b/cpp/src/IceGrid/Internal.ice
index 1362ff7bbe7..bb5ae9b9907 100644
--- a/cpp/src/IceGrid/Internal.ice
+++ b/cpp/src/IceGrid/Internal.ice
@@ -239,6 +239,18 @@ interface Server extends FileReader
     
     /**
      *
+     * Check if the given server can be loaded on this node.
+     *
+     * @return True if the server is inactive.
+     *
+     * @throws DeploymentException Raised if the server can't be updated.
+     *
+     **/
+    ["ami"] bool checkUpdate(InternalServerDescriptor svr, bool noRestart)
+        throws DeploymentException;
+
+    /**
+     *
      * Enable or disable the server.
      *
      **/ 
@@ -359,6 +371,22 @@ interface Node extends FileReader, ReplicaObserver
 
     /**
      *
+     * Load the given server and ensure the server won't be
+     * restarted. If the server resources weren't already created
+     * (database environment directories, property files, etc), they
+     * will be created. If the server can't be updated without a
+     * restart, a DeploymentException is raised.
+     *
+     **/
+    ["amd"] idempotent Server* loadServerWithoutRestart(InternalServerDescriptor svr,
+                                                        string replicaName,
+                                                        out AdapterPrxDict adapters, 
+                                                        out int actTimeout, 
+                                                        out int deactTimeout)
+        throws DeploymentException;
+
+    /**
+     *
      * Destroy the given server.
      *
      **/
diff --git a/cpp/src/IceGrid/NodeCache.cpp b/cpp/src/IceGrid/NodeCache.cpp
index e03a74e51d9..c2d69d64e05 100644
--- a/cpp/src/IceGrid/NodeCache.cpp
+++ b/cpp/src/IceGrid/NodeCache.cpp
@@ -182,10 +182,7 @@ class LoadCB : virtual public IceUtil::Shared
 {
 public:
 
-    LoadCB(const TraceLevelsPtr& traceLevels, 
-           const ServerEntryPtr& server, 
-           const string& node,
-           int timeout) : 
+    LoadCB(const TraceLevelsPtr& traceLevels, const ServerEntryPtr& server, const string& node, int timeout) : 
         _traceLevels(traceLevels), _server(server), _id(server->getId()), _node(node), _timeout(timeout)
     {
     }
@@ -549,7 +546,8 @@ NodeEntry::canRemove()
 }
 
 void
-NodeEntry::loadServer(const ServerEntryPtr& entry, const ServerInfo& server, const SessionIPtr& session, int timeout)
+NodeEntry::loadServer(const ServerEntryPtr& entry, const ServerInfo& server, const SessionIPtr& session, int timeout,
+                      bool noRestart)
 {
     try
     {
@@ -600,12 +598,23 @@ NodeEntry::loadServer(const ServerEntryPtr& entry, const ServerInfo& server, con
                 out << " for session `" << session->getId() << "'";
             }
         }
-        
-        node->begin_loadServer(desc, _cache.getReplicaName(),
-                               newCallback_Node_loadServer(
-                                   new LoadCB(_cache.getTraceLevels(), entry, _name, sessionTimeout),
-                                   &LoadCB::response, 
-                                   &LoadCB::exception));
+
+        if(noRestart)
+        {
+            node->begin_loadServerWithoutRestart(desc, _cache.getReplicaName(),
+                                                 newCallback_Node_loadServerWithoutRestart(
+                                                     new LoadCB(_cache.getTraceLevels(), entry, _name, sessionTimeout),
+                                                     &LoadCB::response, 
+                                                     &LoadCB::exception));
+        }
+        else
+        {
+            node->begin_loadServer(desc, _cache.getReplicaName(),
+                                   newCallback_Node_loadServer(
+                                       new LoadCB(_cache.getTraceLevels(), entry, _name, sessionTimeout),
+                                       &LoadCB::response, 
+                                       &LoadCB::exception));
+        }
     }
     catch(const NodeUnreachableException& ex)
     {
@@ -665,31 +674,27 @@ NodeEntry::getServerInfo(const ServerInfo& server, const SessionIPtr& session)
     return info;
 }
 
-ServerDescriptorPtr
-NodeEntry::getServerDescriptor(const ServerInfo& server, const SessionIPtr& session)
+InternalServerDescriptorPtr
+NodeEntry::getInternalServerDescriptor(const ServerInfo& server, const SessionIPtr& session)
 {
-    assert(_session);
-
-    Resolver resolve(_session->getInfo(), _cache.getCommunicator());
-    resolve.setReserved("application", server.application);
-    resolve.setReserved("server", server.descriptor->id);
-    resolve.setContext("server `${server}'");
-
-    if(session)
-    {
-        resolve.setReserved("session.id", session->getId());
-    }
-
-    IceBoxDescriptorPtr iceBox = IceBoxDescriptorPtr::dynamicCast(server.descriptor);
-    if(iceBox)
+    Lock sync(*this);
+    checkSession();
+    
+    ServerInfo info = server;
+    try
     {
-        return IceBoxHelper(iceBox).instantiate(resolve, PropertyDescriptorSeq(), PropertySetDescriptorDict());
+        info.descriptor = getServerDescriptor(server, session);
     }
-    else
+    catch(const DeploymentException&)
     {
-        return ServerHelper(server.descriptor).instantiate(resolve, PropertyDescriptorSeq(), 
-                                                           PropertySetDescriptorDict());
+        //
+        // We ignore the deployment error for now (which can
+        // only be caused in theory by session variables not
+        // being defined because the server isn't
+        // allocated...)
+        //
     }
+    return getInternalServerDescriptor(info);
 }
 
 void
@@ -854,6 +859,33 @@ NodeEntry::finishedRegistration(const Ice::Exception& ex)
     }
 }
 
+ServerDescriptorPtr
+NodeEntry::getServerDescriptor(const ServerInfo& server, const SessionIPtr& session)
+{
+    assert(_session);
+
+    Resolver resolve(_session->getInfo(), _cache.getCommunicator());
+    resolve.setReserved("application", server.application);
+    resolve.setReserved("server", server.descriptor->id);
+    resolve.setContext("server `${server}'");
+
+    if(session)
+    {
+        resolve.setReserved("session.id", session->getId());
+    }
+
+    IceBoxDescriptorPtr iceBox = IceBoxDescriptorPtr::dynamicCast(server.descriptor);
+    if(iceBox)
+    {
+        return IceBoxHelper(iceBox).instantiate(resolve, PropertyDescriptorSeq(), PropertySetDescriptorDict());
+    }
+    else
+    {
+        return ServerHelper(server.descriptor).instantiate(resolve, PropertyDescriptorSeq(), 
+                                                           PropertySetDescriptorDict());
+    }
+}
+
 InternalServerDescriptorPtr
 NodeEntry::getInternalServerDescriptor(const ServerInfo& info) const
 {
diff --git a/cpp/src/IceGrid/NodeCache.h b/cpp/src/IceGrid/NodeCache.h
index 03b3a1a914d..af87fe2730b 100644
--- a/cpp/src/IceGrid/NodeCache.h
+++ b/cpp/src/IceGrid/NodeCache.h
@@ -53,9 +53,11 @@ public:
 
     bool canRemove();
     
-    void loadServer(const ServerEntryPtr&, const ServerInfo&, const SessionIPtr&, int);
+    void loadServer(const ServerEntryPtr&, const ServerInfo&, const SessionIPtr&, int, bool);
     void destroyServer(const ServerEntryPtr&, const ServerInfo&, int);
+
     ServerInfo getServerInfo(const ServerInfo&, const SessionIPtr&);
+    InternalServerDescriptorPtr getInternalServerDescriptor(const ServerInfo&, const SessionIPtr&);
     
     void __incRef();
     void __decRef();
diff --git a/cpp/src/IceGrid/NodeI.cpp b/cpp/src/IceGrid/NodeI.cpp
index 1c03de9c4fa..de95ba412d2 100644
--- a/cpp/src/IceGrid/NodeI.cpp
+++ b/cpp/src/IceGrid/NodeI.cpp
@@ -374,6 +374,7 @@ void
 NodeI::loadServer_async(const AMD_Node_loadServerPtr& amdCB,
                         const InternalServerDescriptorPtr& descriptor,
                         const string& replicaName,
+                        bool noRestart,
                         const Ice::Current& current)
 {
     ServerCommandPtr command;
@@ -418,7 +419,7 @@ NodeI::loadServer_async(const AMD_Node_loadServerPtr& amdCB,
             
             try
             {
-                command = server->load(amdCB, descriptor, replicaName);
+                command = server->load(amdCB, descriptor, replicaName, noRestart);
             }
             catch(const Ice::ObjectNotExistException&)
             {
@@ -450,9 +451,57 @@ NodeI::loadServer_async(const AMD_Node_loadServerPtr& amdCB,
 }
 
 void
-NodeI::destroyServer_async(const AMD_Node_destroyServerPtr& amdCB, 
-                           const string& serverId, 
-                           const string& uuid, 
+NodeI::loadServer_async(const AMD_Node_loadServerPtr& amdCB,
+                        const InternalServerDescriptorPtr& descriptor,
+                        const string& replicaName,
+                        const Ice::Current& current)
+{
+    loadServer_async(amdCB, descriptor, replicaName, false, current);
+}
+
+void
+NodeI::loadServerWithoutRestart_async(const AMD_Node_loadServerWithoutRestartPtr& amdCB,
+                                      const InternalServerDescriptorPtr& descriptor,
+                                      const string& replicaName,
+                                      const Ice::Current& current)
+{
+    class LoadServerCB : public AMD_Node_loadServer
+    {
+    public:
+
+        LoadServerCB(const AMD_Node_loadServerWithoutRestartPtr& cb) : _cb(cb)
+        {
+        }
+
+        virtual void 
+        ice_response(const ServerPrx& server, const AdapterPrxDict& adapters, Ice::Int actTimeout, Ice::Int deacTimeout)
+        {
+            _cb->ice_response(server, adapters, actTimeout, deacTimeout);
+        };
+
+        virtual void 
+        ice_exception(const ::std::exception& ex)
+        {
+            _cb->ice_exception(ex);
+        }
+
+        virtual void 
+        ice_exception()
+        {
+            _cb->ice_exception();
+        }
+
+    private:
+
+        const AMD_Node_loadServerWithoutRestartPtr _cb;
+    };
+    loadServer_async(new LoadServerCB(amdCB), descriptor, replicaName, true, current);
+}
+
+void
+NodeI::destroyServer_async(const AMD_Node_destroyServerPtr& amdCB,
+                           const string& serverId,
+                           const string& uuid,
                            int revision,
                            const string& replicaName,
                            const Ice::Current& current)
diff --git a/cpp/src/IceGrid/NodeI.h b/cpp/src/IceGrid/NodeI.h
index 508de0f2a48..39d39a976b8 100644
--- a/cpp/src/IceGrid/NodeI.h
+++ b/cpp/src/IceGrid/NodeI.h
@@ -68,8 +68,19 @@ public:
     virtual void loadServer_async(const AMD_Node_loadServerPtr&, 
                                   const InternalServerDescriptorPtr&, 
                                   const std::string&,
+                                  bool,
                                   const Ice::Current&);
 
+    virtual void loadServer_async(const AMD_Node_loadServerPtr&, 
+                                  const InternalServerDescriptorPtr&, 
+                                  const std::string&,
+                                  const Ice::Current&);
+
+    virtual void loadServerWithoutRestart_async(const AMD_Node_loadServerWithoutRestartPtr&, 
+                                                const InternalServerDescriptorPtr&, 
+                                                const std::string&,
+                                                const Ice::Current&);
+
     virtual void destroyServer_async(const AMD_Node_destroyServerPtr&, 
                                      const std::string&, 
                                      const std::string&,
diff --git a/cpp/src/IceGrid/Parser.cpp b/cpp/src/IceGrid/Parser.cpp
index e80d54408b1..4c068664e0a 100644
--- a/cpp/src/IceGrid/Parser.cpp
+++ b/cpp/src/IceGrid/Parser.cpp
@@ -51,13 +51,17 @@ const char* _commandsHelp[][3] = {
 "application describe NAME Describe application NAME.\n" 
 },
 { "application", "diff",
-"application diff DESC [TARGET ... ] [NAME=VALUE ... ]\n"
+"application diff [-s | --servers] DESC [TARGET ... ] [NAME=VALUE ... ]\n"
 "                          Print the differences betwen the application\n"
 "                          described in DESC and the current deployment.\n" 
+"                          If -s or --servers is specified, print the\n"
+"                          the list of servers affected by the differences.\n" 
 },
 { "application", "update",
-"application update DESC [TARGET ... ] [NAME=VALUE ... ]\n"
-"                          Update the application described in DESC.\n"
+"application update [-n | --no-restart] DESC [TARGET ... ] [NAME=VALUE ... ]\n"
+"                          Update the application described in DESC. If -n or\n"
+"                          --no-restart is specified, the update will fail if\n"
+"                          it requires to stop some servers.\n"
 },
 { "application", "patch",
 "application patch [-f | --force] NAME\n"
@@ -475,8 +479,28 @@ Parser::describeApplication(const list<string>& args)
 }
 
 void
-Parser::diffApplication(const list<string>& args)
+Parser::diffApplication(const list<string>& origArgs)
 {
+    list<string> copyArgs = origArgs;
+    copyArgs.push_front("icegridadmin");
+
+    IceUtilInternal::Options opts;
+    opts.addOpt("s", "servers");
+    vector<string> args;
+    try
+    {
+        for(list<string>::const_iterator p = copyArgs.begin(); p != copyArgs.end(); ++p)
+        {
+            args.push_back(*p);
+        }
+        args = opts.parse(args);
+    }
+    catch(const IceUtilInternal::BadOptException& e)
+    {
+        error(e.reason);
+        return;
+    }
+
     if(args.size() < 1)
     {
         invalidCommand("application diff" , "requires at least one argument");
@@ -488,7 +512,7 @@ Parser::diffApplication(const list<string>& args)
         StringSeq targets;
         map<string, string> vars;
 
-        list<string>::const_iterator p = args.begin();
+        vector<string>::const_iterator p = args.begin();
         string desc = *p++;
 
         for(; p != args.end(); ++p)
@@ -511,7 +535,55 @@ Parser::diffApplication(const list<string>& args)
         ApplicationHelper oldAppHelper(_communicator, origApp.descriptor);
         
         Output out(cout);
-        newAppHelper.printDiff(out, oldAppHelper);
+        if(opts.isSet("servers"))
+        {
+            map<string, ServerInfo> oldServers = oldAppHelper.getServerInfos(origApp.uuid, origApp.revision);
+            map<string, ServerInfo> newServers = newAppHelper.getServerInfos(origApp.uuid, origApp.revision);
+
+            vector<string> messages;
+            map<string, ServerInfo>::const_iterator p;
+            for(p = oldServers.begin(); p != oldServers.end(); ++p)
+            {
+                map<string, ServerInfo>::const_iterator q = newServers.find(p->first);
+                if(q == newServers.end())
+                {
+                    messages.push_back("server `" + p->first + "': removed");
+                }
+            }
+
+            for(p = newServers.begin(); p != newServers.end(); ++p)
+            {
+                map<string, ServerInfo>::const_iterator q = oldServers.find(p->first);
+                if(q == oldServers.end())
+                {
+                    messages.push_back("server `" + p->first + "': added");
+                }
+                else if(isServerUpdated(p->second, q->second))
+                {
+                    if(isServerUpdated(p->second, q->second, true)) // Ignore properties
+                    {
+                        messages.push_back("server `" + p->first + "': updated (restart required)");
+                    }
+                    else
+                    {
+                        messages.push_back("server `" + p->first + "': properties updated (no restart required)");
+                    }
+                }
+            }
+
+            out << "application `" << origApp.descriptor.name << "'";
+            out << sb;
+            sort(messages.begin(), messages.end());
+            for(vector<string>::const_iterator r = messages.begin(); r != messages.end(); ++r)
+            {
+                out << nl << *r;
+            }
+            out << eb;
+        }
+        else
+        {
+            newAppHelper.printDiff(out, oldAppHelper);
+        }
         out << nl;  
     }
     catch(const Ice::Exception& ex)
@@ -521,8 +593,28 @@ Parser::diffApplication(const list<string>& args)
 }
 
 void
-Parser::updateApplication(const list<string>& args)
+Parser::updateApplication(const list<string>& origArgs)
 {
+    list<string> copyArgs = origArgs;
+    copyArgs.push_front("icegridadmin");
+
+    IceUtilInternal::Options opts;
+    opts.addOpt("n", "no-restart");
+    vector<string> args;
+    try
+    {
+        for(list<string>::const_iterator p = copyArgs.begin(); p != copyArgs.end(); ++p)
+        {
+            args.push_back(*p);
+        }
+        args = opts.parse(args);
+    }
+    catch(const IceUtilInternal::BadOptException& e)
+    {
+        error(e.reason);
+        return;
+    }
+
     if(args.size() < 1)
     {
         invalidCommand("application update", "requires at least one argument");
@@ -534,8 +626,8 @@ Parser::updateApplication(const list<string>& args)
         StringSeq targets;
         map<string, string> vars;
 
-        list<string>::const_iterator p = args.begin();
-        string desc = *p++;
+        vector<string>::const_iterator p = args.begin();
+        string xml = *p++;
 
         for(; p != args.end(); ++p)
         {
@@ -550,7 +642,19 @@ Parser::updateApplication(const list<string>& args)
             }
         }
 
-        _admin->syncApplication(DescriptorParser::parseDescriptor(desc, targets, vars, _communicator, _admin));
+        ApplicationDescriptor desc = DescriptorParser::parseDescriptor(xml, targets, vars, _communicator, _admin);
+        if(opts.isSet("no-restart"))
+        {
+            _admin->syncApplicationWithoutRestart(desc);
+        }
+        else
+        {
+            _admin->syncApplication(desc);
+        }
+    }
+    catch(const Ice::OperationNotExistException&)
+    {
+        error("registry doesn't support updates without restart");
     }
     catch(const Ice::Exception& ex)
     {
diff --git a/cpp/src/IceGrid/ReplicaSessionManager.cpp b/cpp/src/IceGrid/ReplicaSessionManager.cpp
index 8d478fddc8c..404571b7217 100644
--- a/cpp/src/IceGrid/ReplicaSessionManager.cpp
+++ b/cpp/src/IceGrid/ReplicaSessionManager.cpp
@@ -79,7 +79,7 @@ public:
         string failure;
         try
         {
-            _database->updateApplication(update);
+            _database->updateApplication(update, false);
         }
         catch(const DeploymentException& ex)
         {
diff --git a/cpp/src/IceGrid/ServerCache.cpp b/cpp/src/IceGrid/ServerCache.cpp
index d9be593a4af..5d8d8942b29 100644
--- a/cpp/src/IceGrid/ServerCache.cpp
+++ b/cpp/src/IceGrid/ServerCache.cpp
@@ -59,6 +59,45 @@ namespace IceGrid
         ServerCache& _serverCache;
         const ServerEntryPtr _entry;
     };
+
+
+}
+
+CheckUpdateResult::CheckUpdateResult(const string& server, 
+                                     const string& node, 
+                                     bool noRestart, 
+                                     const Ice::AsyncResultPtr& result) : 
+    _server(server), _node(node), _noRestart(noRestart), _result(result)
+{
+}
+
+bool
+CheckUpdateResult::getResult()
+{
+    try
+    {
+        return ServerPrx::uncheckedCast(_result->getProxy())->end_checkUpdate(_result);
+    }
+    catch(const DeploymentException& ex)
+    {
+        ostringstream os;
+        os << "check for server `" << _server << "' update failed: " << ex.reason;
+        throw DeploymentException(os.str());
+    }
+    catch(const Ice::OperationNotExistException&)
+    {
+        if(_noRestart)
+        {
+            throw DeploymentException("server `" + _server + "' doesn't support check for updates");
+        }
+        return false;
+    }
+    catch(const Ice::Exception& ex)
+    {
+        ostringstream os;
+        os << ex;
+        throw NodeUnreachableException(_node, os.str());
+    }
 }
 
 ServerCache::ServerCache(const Ice::CommunicatorPtr& communicator,
@@ -77,7 +116,7 @@ ServerCache::ServerCache(const Ice::CommunicatorPtr& communicator,
 }
 
 ServerEntryPtr
-ServerCache::add(const ServerInfo& info)
+ServerCache::add(const ServerInfo& info, bool noRestart)
 {
     Lock sync(*this);
 
@@ -87,7 +126,7 @@ ServerCache::add(const ServerInfo& info)
         entry = new ServerEntry(*this, info.descriptor->id);
         addImpl(info.descriptor->id, entry);
     }
-    entry->update(info);
+    entry->update(info, noRestart);
     _nodeCache.get(info.node, true)->addServer(entry);
 
     forEachCommunicator(AddCommunicator(*this, entry, info.application))(info.descriptor);
@@ -211,7 +250,8 @@ ServerEntry::ServerEntry(ServerCache& cache, const string& id) :
     _activationTimeout(-1),
     _deactivationTimeout(-1),
     _synchronizing(false),
-    _updated(false)
+    _updated(false),
+    _noRestart(false)
 {
 }
 
@@ -273,7 +313,7 @@ ServerEntry::addSyncCallback(const SynchronizationCallbackPtr& callback)
 }
 
 void
-ServerEntry::update(const ServerInfo& info)
+ServerEntry::update(const ServerInfo& info, bool noRestart)
 {
     Lock sync(*this);
 
@@ -295,6 +335,7 @@ ServerEntry::update(const ServerInfo& info)
     }
 
     _load = descriptor;
+    _noRestart = noRestart;
     _loaded.reset(0);
     _allocatable = info.descriptor->allocatable;
     if(info.descriptor->activation == "session")
@@ -528,6 +569,7 @@ ServerEntry::syncImpl()
     SessionIPtr session;
     ServerInfo destroy;
     int timeout = -1;
+    bool noRestart;
 
     {
         Lock sync(*this);
@@ -554,6 +596,7 @@ ServerEntry::syncImpl()
             load = *_load;
             session = _session;
             timeout = _deactivationTimeout; // loadServer might block to deactivate the previous server.
+            noRestart = _noRestart;
         }
         else
         {
@@ -578,7 +621,7 @@ ServerEntry::syncImpl()
     {
         try
         {
-            _cache.getNodeCache().get(load.node)->loadServer(this, load, session, timeout);
+            _cache.getNodeCache().get(load.node)->loadServer(this, load, session, timeout, noRestart);
         }
         catch(NodeNotExistException&)
         {
@@ -692,6 +735,7 @@ ServerEntry::loadCallback(const ServerPrx& proxy, const AdapterPrxDict& adpts, i
     ServerInfo destroy;
     int timeout = -1;
     bool synced = false;
+    bool noRestart;
 
     {
         Lock sync(*this);
@@ -726,6 +770,7 @@ ServerEntry::loadCallback(const ServerPrx& proxy, const AdapterPrxDict& adpts, i
             else if(_load.get())
             {
                 load = *_load;
+                noRestart = _noRestart;
                 session = _session;
                 timeout = _deactivationTimeout; // loadServer might block to deactivate the previous server.
             }
@@ -754,7 +799,7 @@ ServerEntry::loadCallback(const ServerPrx& proxy, const AdapterPrxDict& adpts, i
     {
         try
         {
-            _cache.getNodeCache().get(load.node)->loadServer(this, load, session, timeout);
+            _cache.getNodeCache().get(load.node)->loadServer(this, load, session, timeout, noRestart);
         }
         catch(NodeNotExistException&)
         {
@@ -767,6 +812,7 @@ void
 ServerEntry::destroyCallback()
 {
     ServerInfo load;
+    bool noRestart;
     SessionIPtr session;
 
     {
@@ -787,6 +833,7 @@ ServerEntry::destroyCallback()
         {
             _updated = false;
             load = *_load;
+            noRestart = _noRestart;
             session = _session;
         }
     }
@@ -795,7 +842,7 @@ ServerEntry::destroyCallback()
     {
         try
         {
-            _cache.getNodeCache().get(load.node)->loadServer(this, load, session, -1);
+            _cache.getNodeCache().get(load.node)->loadServer(this, load, session, -1, noRestart);
         }
         catch(NodeNotExistException&)
         {
@@ -814,6 +861,7 @@ ServerEntry::exception(const Ice::Exception& ex)
 {
     ServerInfo load;
     SessionIPtr session;
+    bool noRestart;
     bool remove = false;
     int timeout = -1;
 
@@ -836,6 +884,7 @@ ServerEntry::exception(const Ice::Exception& ex)
             _destroy.reset(0);
             _updated = false;
             load = *_load.get();
+            noRestart = _noRestart;
             session = _session;
             timeout = _deactivationTimeout; // loadServer might block to deactivate the previous server.
         }
@@ -845,7 +894,7 @@ ServerEntry::exception(const Ice::Exception& ex)
     {
         try
         {
-            _cache.getNodeCache().get(load.node)->loadServer(this, load, session, timeout);
+            _cache.getNodeCache().get(load.node)->loadServer(this, load, session, timeout, noRestart);
         }
         catch(NodeNotExistException&)
         {
@@ -876,6 +925,60 @@ ServerEntry::canRemove()
      return !_loaded.get() && !_load.get() && !_destroy.get();
 }
 
+CheckUpdateResultPtr
+ServerEntry::checkUpdate(const ServerInfo& info, bool noRestart)
+{
+    SessionIPtr session;
+    {
+        Lock sync(*this);
+        if(!_loaded.get() && !_load.get())
+        {
+            throw ServerNotExistException();
+        }
+        
+        ServerInfo oldInfo = _loaded.get() ? *_loaded : *_load;
+        if(noRestart && info.node != oldInfo.node)
+        {
+            throw DeploymentException("server `" + _id + "' is moved to another node");
+        }
+
+        session = _session;
+    }
+
+    NodeEntryPtr node;
+    try
+    {
+        node = _cache.getNodeCache().get(info.node);
+    }
+    catch(NodeNotExistException&)
+    {
+        throw NodeUnreachableException(info.node, "node is not active");
+    }
+
+    ServerPrx server;
+    try
+    {
+        server = getProxy(true);
+    }
+    catch(const DeploymentException&)
+    {
+        if(noRestart)
+        {
+            // If the server can't be loaded and no restart is required, we throw
+            // to indicate that the server update can't be checked.
+            throw;
+        }
+        else
+        {
+            // Otherwise, we do as if the update is valid.
+            return 0;
+        }
+    }
+
+    InternalServerDescriptorPtr desc = node->getInternalServerDescriptor(info, session);
+    return new CheckUpdateResult(_id, info.node, noRestart, server->begin_checkUpdate(desc, noRestart));
+
+}
 
 void
 ServerEntry::allocated(const SessionIPtr& session)
diff --git a/cpp/src/IceGrid/ServerCache.h b/cpp/src/IceGrid/ServerCache.h
index f1db17fa9b6..866ba3652aa 100644
--- a/cpp/src/IceGrid/ServerCache.h
+++ b/cpp/src/IceGrid/ServerCache.h
@@ -29,6 +29,28 @@ class NodeCache;
 class NodeEntry;
 typedef IceUtil::Handle<NodeEntry> NodeEntryPtr;
 
+class CheckServerResult;
+typedef IceUtil::Handle<CheckServerResult> CheckServerResultPtr;
+
+class CheckUpdateResult : public IceUtil::Shared
+{
+public:
+
+    CheckUpdateResult(const std::string&, const std::string&, bool, const Ice::AsyncResultPtr&);
+
+    bool getResult();
+
+    const std::string& getServer() { return _server; }
+
+private:
+
+    const std::string _server;
+    const std::string _node;
+    const bool _noRestart;
+    const Ice::AsyncResultPtr _result;
+};
+typedef IceUtil::Handle<CheckUpdateResult> CheckUpdateResultPtr;
+
 class ServerEntry : public Allocatable
 {
 public:
@@ -50,7 +72,8 @@ public:
 
     bool addSyncCallback(const SynchronizationCallbackPtr&);
 
-    void update(const ServerInfo&);
+    void update(const ServerInfo&, bool);
+
     void destroy();
 
     ServerInfo getInfo(bool = false) const;
@@ -65,6 +88,7 @@ public:
     float getLoad(LoadSample) const;
 
     bool canRemove();
+    CheckUpdateResultPtr checkUpdate(const ServerInfo&, bool);
     bool isDestroyed();
     
     void loadCallback(const ServerPrx&, const AdapterPrxDict&, int, int);
@@ -96,6 +120,7 @@ private:
 
     bool _synchronizing;
     bool _updated;
+    bool _noRestart;
     std::auto_ptr<Ice::Exception> _exception;
     std::vector<SynchronizationCallbackPtr> _callbacks;
 
@@ -114,7 +139,7 @@ public:
 
     ServerCache(const Ice::CommunicatorPtr&, const std::string&, NodeCache&, AdapterCache&, ObjectCache&, AllocatableObjectCache&);
 
-    ServerEntryPtr add(const ServerInfo&);
+    ServerEntryPtr add(const ServerInfo&, bool);
     ServerEntryPtr get(const std::string&) const;
     bool has(const std::string&) const;
     ServerEntryPtr remove(const std::string&, bool = true);
diff --git a/cpp/src/IceGrid/ServerI.cpp b/cpp/src/IceGrid/ServerI.cpp
index 4db7ef92f78..ae530bc5cdb 100755
--- a/cpp/src/IceGrid/ServerI.cpp
+++ b/cpp/src/IceGrid/ServerI.cpp
@@ -121,12 +121,16 @@ chownRecursive(const string& path, uid_t uid, gid_t gid)
 #endif
 
 static bool
-descriptorWithoutRevisionEqual(const InternalServerDescriptorPtr& lhs, const InternalServerDescriptorPtr& rhs)
+descriptorUpdated(const InternalServerDescriptorPtr& lhs, const InternalServerDescriptorPtr& rhs, bool noProps = false)
 {
+    if(lhs->uuid == rhs->uuid && lhs->revision == rhs->revision)
+    {
+        return false;
+    }
+
     if(lhs->id != rhs->id ||
        lhs->application != rhs->application ||
        lhs->uuid != rhs->uuid ||
-//       lhs->revision != rhs->revision ||
        lhs->sessionId != rhs->sessionId ||
        lhs->exe != rhs->exe || 
        lhs->pwd != rhs->pwd ||
@@ -140,25 +144,25 @@ descriptorWithoutRevisionEqual(const InternalServerDescriptorPtr& lhs, const Int
        lhs->envs != rhs->envs ||
        lhs->logs != rhs->logs)
     {
-        return false;
+        return true;
     }
 
     if((!lhs->distrib && rhs->distrib) || (lhs->distrib && !rhs->distrib))
     {
-        return false;
+        return true;
     }
     else if(lhs->distrib && rhs->distrib)
     {
         if(lhs->distrib->icepatch != rhs->distrib->icepatch ||
            lhs->distrib->directories != rhs->distrib->directories)
         {
-            return false;
+            return true;
         }
     }
 
     if(lhs->adapters.size() != rhs->adapters.size())
     {
-        return false;
+        return true;
     }
     else
     {
@@ -167,14 +171,14 @@ descriptorWithoutRevisionEqual(const InternalServerDescriptorPtr& lhs, const Int
         {
             if((*p)->id != (*q)->id || (*p)->serverLifetime != (*q)->serverLifetime)
             {
-                return false;
+                return true;
             }
         }
     }
     
     if(lhs->dbEnvs.size() != rhs->dbEnvs.size())
     {
-        return false;
+        return true;
     }
     else
     {
@@ -183,17 +187,40 @@ descriptorWithoutRevisionEqual(const InternalServerDescriptorPtr& lhs, const Int
         {
             if((*p)->name != (*q)->name || (*p)->properties != (*q)->properties)
             {
-                return false;
+                return true;
             }
         }
     }
 
-    if(lhs->properties != rhs->properties)
+    if(!noProps && lhs->properties != rhs->properties)
     {
-        return false;
+        return true;
     }
 
-    return true;
+    return false;
+}
+
+Ice::PropertyDict
+toPropertyDict(const PropertyDescriptorSeq& seq)
+{
+    Ice::PropertyDict props;
+    for(PropertyDescriptorSeq::const_iterator q = seq.begin(); q != seq.end(); ++q)
+    {
+        if(q->value.empty() && q->name.find('#') == 0)
+        {
+            continue; // Ignore comments.
+        }
+        
+        if(q->value.empty())
+        {
+            props.erase(q->name);
+        }
+        else
+        {
+            props[q->name] = q->value;
+        }
+    }
+    return props;
 }
 
 class CommandTimeoutTimerTask : public IceUtil::TimerTask
@@ -248,6 +275,109 @@ private:
     const TraceLevelsPtr _traceLevels;
 };
 
+class ResetPropertiesCB : public IceUtil::Shared
+{
+public:
+
+    ResetPropertiesCB(const ServerIPtr& server, 
+                      const Ice::ObjectPrx admin, 
+                      const InternalServerDescriptorPtr& desc,
+                      const InternalServerDescriptorPtr& old,
+                      const TraceLevelsPtr& traceLevels) :
+        _server(server), 
+        _admin(admin), 
+        _desc(desc),
+        _traceLevels(traceLevels),
+        _properties(server->getProperties(desc)),
+        _oldProperties(server->getProperties(old)), 
+        _p(_properties.begin())
+    {
+    }
+
+    void
+    execute()
+    {
+        assert(_p != _properties.end());
+        next();
+    }
+
+private:
+
+    void
+    next()
+    {
+        while(_p != _properties.end() && _p->second == _oldProperties[_p->first])
+        {
+            ++_p;
+        }
+        if(_p == _properties.end())
+        {
+            _server->updateRuntimePropertiesCallback(_desc);
+            return;
+        }
+
+        Ice::PropertyDict oldProps = toPropertyDict(_oldProperties[_p->first]);
+        Ice::PropertyDict props = toPropertyDict(_p->second);
+        for(Ice::PropertyDict::const_iterator q = oldProps.begin(); q != oldProps.end(); ++q)
+        {
+            if(props.find(q->first) == props.end())
+            {
+                props[q->first] = "";
+            }
+        }
+
+        string facet;
+        if(_p->first == "config")
+        {
+            facet = "Properties";
+            if(_traceLevels->server > 1)
+            {
+                const string id = _server->getId();
+                Ice::Trace out(_traceLevels->logger, _traceLevels->serverCat);
+                out << "updating runtime properties for server `" << id << "'";
+            }
+        }
+        else
+        {
+            assert(_p->first.find("config_") == 0);
+            const string service = _p->first.substr(7);
+            facet = "IceBox.Service." + service + ".Properties";
+            if(_traceLevels->server > 1)
+            {
+                const string id = _server->getId();
+                Ice::Trace out(_traceLevels->logger, _traceLevels->serverCat);
+                out << "updating runtime properties for service `" << service << "' from server `" + id + "'";
+            }
+        }
+
+        //
+        // Increment the iterator *before* invoking setProperties_async to avoid a
+        // race condition.
+        //
+        ++_p;
+
+        Ice::PropertiesAdminPrx p = Ice::PropertiesAdminPrx::uncheckedCast(_admin, facet);
+        p->begin_setProperties(props, Ice::newCallback_PropertiesAdmin_setProperties(this, 
+                                                                                     &ResetPropertiesCB::next, 
+                                                                                     &ResetPropertiesCB::exception));
+    }
+    
+    void
+    exception(const Ice::Exception& ex)
+    {
+        _server->updateRuntimePropertiesCallback(ex, _desc);
+    }
+    
+    const ServerIPtr _server;
+    const Ice::ObjectPrx _admin;
+    const InternalServerDescriptorPtr _desc;
+    const TraceLevelsPtr _traceLevels;
+    const PropertyDescriptorSeqDict _properties;
+    PropertyDescriptorSeqDict _oldProperties;
+    PropertyDescriptorSeqDict::const_iterator _p;
+};
+typedef IceUtil::Handle<ResetPropertiesCB> ResetPropertiesCBPtr;
+
 struct EnvironmentEval : std::unary_function<string, string>
 {
     
@@ -275,7 +405,8 @@ struct EnvironmentEval : std::unary_function<string, string>
                 break;
             }
             string variable = v.substr(beg + 1, end - beg - 1);
-            DWORD ret = GetEnvironmentVariableW(IceUtil::stringToWstring(variable).c_str(), &buf[0], static_cast<DWORD>(buf.size()));
+            DWORD ret = GetEnvironmentVariableW(IceUtil::stringToWstring(variable).c_str(), &buf[0], 
+                                                static_cast<DWORD>(buf.size()));
             string valstr = (ret > 0 && ret < buf.size()) ? IceUtil::wstringToString(&buf[0]) : string("");
             v.replace(beg, end - beg + 1, valstr);
             beg += valstr.size();
@@ -354,8 +485,10 @@ TimedServerCommand::stopTimer()
     }
 }
 
-LoadCommand::LoadCommand(const ServerIPtr& server) : 
-    ServerCommand(server)
+LoadCommand::LoadCommand(const ServerIPtr& server, 
+                         const InternalServerDescriptorPtr& runtime, 
+                         const TraceLevelsPtr& traceLevels) : 
+    ServerCommand(server), _runtime(runtime), _updating(false), _traceLevels(traceLevels)
 {
 }
 
@@ -403,12 +536,50 @@ LoadCommand::addCallback(const AMD_Node_loadServerPtr& amdCB)
 }
 
 void
+LoadCommand::startRuntimePropertiesUpdate(const Ice::ObjectPrx& process)
+{
+    if(_updating)
+    {
+        return;
+    }
+    assert(_desc != _runtime);
+    _updating = true;
+    
+    ResetPropertiesCBPtr cb = new ResetPropertiesCB(_server, process, _desc, _runtime, _traceLevels);
+    cb->execute();
+}
+
+bool
+LoadCommand::finishRuntimePropertiesUpdate(const InternalServerDescriptorPtr& runtime, const Ice::ObjectPrx& process)
+{
+    _updating = false;
+    _runtime = runtime; // The new runtime server descriptor.
+
+    if(_traceLevels->server > 0)
+    {
+        Ice::Trace out(_traceLevels->logger, _traceLevels->serverCat);
+        out << "updated runtime properties for server `" << _server->getId() << "'";
+    }
+
+    if(_desc != _runtime)
+    {
+        startRuntimePropertiesUpdate(process);
+        return false;
+    }
+    else
+    {
+        return true;
+    }
+}
+
+void
 LoadCommand::failed(const Ice::Exception& ex)
 {
     for(vector<AMD_Node_loadServerPtr>::const_iterator p = _loadCB.begin(); p != _loadCB.end(); ++p)
     {
         (*p)->ice_exception(ex);
     }   
+    _loadCB.clear();
 }
 
 void
@@ -418,6 +589,7 @@ LoadCommand::finished(const ServerPrx& proxy, const AdapterPrxDict& adapters, in
     {
         (*p)->ice_response(proxy, adapters, at, dt);
     }
+    _loadCB.clear();
 }
 
 DestroyCommand::DestroyCommand(const ServerIPtr& server, bool loadFailure, bool clearDir) : 
@@ -659,7 +831,7 @@ ServerI::ServerI(const NodeIPtr& node, const ServerPrx& proxy, const string& ser
     _disableOnFailure(0),
     _state(ServerI::Inactive),
     _activation(ServerI::Disabled),
-    _failureTime(IceUtil::Time::now(IceUtil::Time::Monotonic)), // Ensure that _activation gets initialized in updateImpl().
+    _failureTime(IceUtil::Time::now(IceUtil::Time::Monotonic)), // Ensure that _activation is init. in updateImpl().
     _pid(0)
 {
     assert(_node->getActivator());
@@ -1040,7 +1212,8 @@ ServerI::start(ServerActivation activation, const AMD_Server_startPtr& amdCB)
 }
 
 ServerCommandPtr
-ServerI::load(const AMD_Node_loadServerPtr& amdCB, const InternalServerDescriptorPtr& desc, const string& replicaName)
+ServerI::load(const AMD_Node_loadServerPtr& amdCB, const InternalServerDescriptorPtr& desc, const string& replicaName, 
+              bool noRestart)
 {
     Lock sync(*this);
     checkDestroyed();
@@ -1056,12 +1229,10 @@ ServerI::load(const AMD_Node_loadServerPtr& amdCB, const InternalServerDescripto
     // we don't re-load the server. We just return the server
     // proxy and the proxies of its adapters.
     // 
-    if(_desc &&
-       (replicaName != "Master" || _desc->sessionId == desc->sessionId) &&
-       ((_desc->uuid == desc->uuid && _desc->revision == desc->revision) ||
-		descriptorWithoutRevisionEqual(_desc, desc)))
+    InternalServerDescriptorPtr d = _load ? _load->getInternalServerDescriptor() : _desc;
+    if(d && (replicaName != "Master" || d->sessionId == desc->sessionId) && !descriptorUpdated(d, desc))
     {
-        if(_desc->revision != desc->revision)
+        if(d->revision != desc->revision)
         {
             updateRevision(desc->uuid, desc->revision);
         }
@@ -1078,13 +1249,27 @@ ServerI::load(const AMD_Node_loadServerPtr& amdCB, const InternalServerDescripto
         return 0;
     }
 
-    if(!StopCommand::isStopped(_state) && !_stop)
+    if(!StopCommand::isStopped(_state) && !_stop) // Server is running and no stop is scheduled
     {
-        _stop = new StopCommand(this, _node->getTimer(), _deactivationTimeout);
+        assert(_desc);
+        if(noRestart)
+        {
+            //
+            // If the server is not inactive, we have to make sure the update doesn't require
+            // a restart. If it requires a restart, we throw. Otherwise we update its properties
+            // now.
+            //
+            checkNoRestart(desc);
+        }
+        else
+        {
+            _stop = new StopCommand(this, _node->getTimer(), _deactivationTimeout);
+        }
     }
+    
     if(!_load)
     {
-        _load = new LoadCommand(this);
+        _load = new LoadCommand(this, _desc, _node->getTraceLevels());
     }
     _load->setUpdate(desc, _destroy);
     if(_destroy && _state != Destroying)
@@ -1092,13 +1277,64 @@ ServerI::load(const AMD_Node_loadServerPtr& amdCB, const InternalServerDescripto
         _destroy->finished();
         _destroy = 0;
     }
+
     if(amdCB)
     {
         _load->addCallback(amdCB);
     }
+
+    if(!_stop && _state == Active) // Must be done after adding the AMD callback.
+    {
+        updateRevision(desc->uuid, desc->revision);
+        _load->startRuntimePropertiesUpdate(_process);
+    }
     return nextCommand();
 }
 
+bool
+ServerI::checkUpdate(const InternalServerDescriptorPtr& desc, bool noRestart, const Ice::Current&)
+{
+    Lock sync(*this);
+    checkDestroyed();
+
+    if(!_desc)
+    {
+        throw DeploymentException("server not loaded");
+    }
+
+    InternalServerDescriptorPtr d = _load ? _load->getInternalServerDescriptor() : _desc;
+    if(!descriptorUpdated(d, desc))
+    {
+        return StopCommand::isStopped(_state);
+    }
+
+    if(noRestart)
+    {
+        checkNoRestart(desc);
+    }
+
+    try
+    {
+        checkAndUpdateUser(desc, false); // false = don't update the user, just check.
+    }
+    catch(const Ice::Exception& ex)
+    {
+        ostringstream os;
+        os << ex;
+        throw DeploymentException(os.str());
+    }
+    catch(const string& msg)
+    {
+        throw DeploymentException(msg);
+    }
+    catch(const char* msg)
+    {
+        throw DeploymentException(msg);
+    }
+
+    return StopCommand::isStopped(_state);
+}
+
 ServerCommandPtr
 ServerI::destroy(const AMD_Node_destroyServerPtr& amdCB, const string& uuid, int revision, const string& replicaName)
 {
@@ -1785,6 +2021,12 @@ ServerI::update()
                     _node->removeServer(this, oldDescriptor->application);
                     _node->addServer(this, _desc->application);
                 }
+
+                if(_node->getTraceLevels()->server > 0)
+                {
+                    Ice::Trace out(_node->getTraceLevels()->logger, _node->getTraceLevels()->serverCat);
+                    out << "updated configuration for server `" << _id << "'";
+                }
             }
             else
             {
@@ -1948,116 +2190,7 @@ ServerI::updateImpl(const InternalServerDescriptorPtr& descriptor)
         _timerTask = 0;
     }   
 
-#ifndef _WIN32
-    _uid = getuid();
-    _gid = getgid();
-#endif
-
-    //
-    // Don't change the user if the server has the session activation
-    // mode and if it's not currently owned by a session.
-    //
-    string user;
-    if(_desc->activation != "session" || !_desc->sessionId.empty())
-    {
-        user = _desc->user;
-#ifndef _WIN32
-        //
-        // Check if the node is running as root, if that's the case we
-        // make sure that a user is set for the process.
-        //
-        if(_uid == 0 && user.empty())
-        {
-            //
-            // If no user is configured and if this server is owned by
-            // a session we set the user to the session id, otherwise
-            // we set it to "nobody".
-            //
-            user = !_desc->sessionId.empty() ? _desc->sessionId : "nobody";
-        }
-#endif
-    }
-
-    if(!user.empty())
-    {
-        UserAccountMapperPrx mapper = _node->getUserAccountMapper();
-        if(mapper)
-        {
-            try
-            {
-                user = mapper->getUserAccount(user);
-            }
-            catch(const UserAccountNotFoundException&)
-            {
-                throw "couldn't find user account for user `" + user + "'";
-            }
-            catch(const Ice::LocalException& ex)
-            {
-                ostringstream os;
-                os << "unexpected exception while trying to find user account for user `" << user << "':\n" << ex;
-                throw os.str();
-            }
-        }
-
-#ifdef _WIN32
-        //
-        // Windows doesn't support running processes under another
-        // account (at least not easily, see the CreateProcessAsUser
-        // documentation). So if a user is specified, we just check
-        // that the node is running under the same user account as the
-        // one which is specified.
-        //      
-        vector<char> buf(256);
-        buf.resize(256);
-        DWORD size = static_cast<DWORD>(buf.size());
-        bool success = GetUserName(&buf[0], &size);
-        if(!success && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
-        {
-            buf.resize(size);
-            success = GetUserName(&buf[0], &size);
-        }
-        if(!success)
-        {
-            Ice::SyscallException ex(__FILE__, __LINE__);
-            ex.error = IceInternal::getSystemErrno();
-            throw ex;
-        }
-        if(user != string(&buf[0]))
-        {
-            throw "couldn't load server under user account `" + user + "': feature not supported on Windows";
-        }
-#else
-        //
-        // Get the uid/gid associated with the given user.
-        //
-        struct passwd* pw = getpwnam(user.c_str());
-        if(!pw)
-        {
-            throw "unknown user account `" + user + "'";
-        }
-
-        //
-        // If the node isn't running as root and if the uid of the
-        // configured user is different from the uid of the userr
-        // running the node we throw, a regular user can't run a
-        // process as another user.
-        //
-        if(_uid != 0 && pw->pw_uid != _uid)
-        {
-            throw "node has insufficient privileges to load server under user account `" + user + "'";
-        }
-
-
-	if(pw->pw_uid == 0 &&
-	   _node->getCommunicator()->getProperties()->getPropertyAsInt("IceGrid.Node.AllowRunningServersAsRoot") == 0)
-	{
-	    throw "running server as `root' is not allowed";
-	}
-
-        _uid = pw->pw_uid;
-        _gid = pw->pw_gid;
-#endif
-    }
+    checkAndUpdateUser(_desc, true); // we pass true to update _uid/_gid.
 
     istringstream at(_desc->activationTimeout);
     if(!(at >> _activationTimeout) || !at.eof() || _activationTimeout == 0)
@@ -2088,58 +2221,10 @@ ServerI::updateImpl(const InternalServerDescriptorPtr& descriptor)
     }
     sort(_logs.begin(), _logs.begin());
     
-    //
-    // Copy the descriptor properties. We shouldn't modify the
-    // descriptor since it's used for the comparison when the server
-    // needs to be updated.
-    //
-    PropertyDescriptorSeqDict properties = _desc->properties;
+    PropertyDescriptorSeqDict properties = getProperties(_desc);
     PropertyDescriptorSeq& props = properties["config"];
-    
-    //
-    // Cache the path of the stderr/stdout file, first check if the
-    // node OutputDir property is set and then we check the server
-    // configuration file for the Ice.StdErr and Ice.StdOut
-    // properties.
-    //
     _stdErrFile = getProperty(props, "Ice.StdErr");
     _stdOutFile = getProperty(props, "Ice.StdOut");
-    string outputDir = _node->getOutputDir();
-    if(!outputDir.empty())
-    {
-        if(_stdErrFile.empty())
-        {
-            _stdErrFile = outputDir + "/" + _id + (_node->getRedirectErrToOut() ? ".out" : ".err");
-            props.push_back(createProperty("Ice.StdErr", _stdErrFile));
-        }
-        if(_stdOutFile.empty())
-        {
-            _stdOutFile = outputDir + "/" + _id + ".out";
-            props.push_back(createProperty("Ice.StdOut", _stdOutFile));
-        }
-    }
-
-    //
-    // Add the locator proxy property and the node properties override
-    //
-    {
-        const PropertyDescriptorSeq& overrides = _node->getPropertiesOverride();
-        for(PropertyDescriptorSeqDict::iterator p = properties.begin(); p != properties.end(); ++p)
-        {
-            if(getProperty(p->second, "Ice.Default.Locator").empty())
-            {
-                p->second.push_back(
-                    createProperty("Ice.Default.Locator",
-                                   _node->getCommunicator()->getProperties()->getProperty("Ice.Default.Locator")));
-            }
-            
-            if(!overrides.empty())
-            {
-                p->second.push_back(createProperty("# Node properties override"));
-                p->second.insert(p->second.end(), overrides.begin(), overrides.end());
-            }
-        }
-    }
 
     //
     // If the server is a session server and it wasn't udpated but
@@ -2298,7 +2383,12 @@ ServerI::checkRevision(const string& replicaName, const string& uuid, int revisi
 
     string descUUID;
     int descRevision;
-    if(_desc)
+    if(_load)
+    {
+        descUUID = _load->getInternalServerDescriptor()->uuid;
+        descRevision = _load->getInternalServerDescriptor()->revision;
+    }
+    else if(_desc)
     {
         descUUID = _desc->uuid;
         descRevision = _desc->revision;
@@ -2338,11 +2428,157 @@ ServerI::checkRevision(const string& replicaName, const string& uuid, int revisi
 }
 
 void
+ServerI::checkNoRestart(const InternalServerDescriptorPtr& desc)
+{
+    assert(_desc);
+
+    if(_desc->sessionId != desc->sessionId)
+    {
+        throw DeploymentException("server allocated by another session");
+    }
+
+    if(descriptorUpdated(_desc, desc, true)) // true = ignore properties
+    {
+        throw DeploymentException("update requires server to be stopped");
+    }
+}
+
+void
+ServerI::checkAndUpdateUser(const InternalServerDescriptorPtr& desc, bool update)
+{
+#ifndef _WIN32
+    uid_t uid = getuid();
+    uid_t gid = getgid();
+#endif
+
+    //
+    // Don't change the user if the server has the session activation
+    // mode and if it's not currently owned by a session.
+    //
+    string user;
+    if(desc->activation != "session" || !desc->sessionId.empty())
+    {
+        user = desc->user;
+#ifndef _WIN32
+        //
+        // Check if the node is running as root, if that's the case we
+        // make sure that a user is set for the process.
+        //
+        if(uid == 0 && user.empty())
+        {
+            //
+            // If no user is configured and if this server is owned by
+            // a session we set the user to the session id, otherwise
+            // we set it to "nobody".
+            //
+            user = !desc->sessionId.empty() ? desc->sessionId : "nobody";
+        }
+#endif
+    }
+
+    if(!user.empty())
+    {
+        UserAccountMapperPrx mapper = _node->getUserAccountMapper();
+        if(mapper)
+        {
+            try
+            {
+                user = mapper->getUserAccount(user);
+            }
+            catch(const UserAccountNotFoundException&)
+            {
+                throw "couldn't find user account for user `" + user + "'";
+            }
+            catch(const Ice::LocalException& ex)
+            {
+                ostringstream os;
+                os << "unexpected exception while trying to find user account for user `" << user << "':\n" << ex;
+                throw os.str();
+            }
+        }
+
+#ifdef _WIN32
+        //
+        // Windows doesn't support running processes under another
+        // account (at least not easily, see the CreateProcessAsUser
+        // documentation). So if a user is specified, we just check
+        // that the node is running under the same user account as the
+        // one which is specified.
+        //      
+        vector<char> buf(256);
+        buf.resize(256);
+        DWORD size = static_cast<DWORD>(buf.size());
+        bool success = GetUserName(&buf[0], &size);
+        if(!success && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
+        {
+            buf.resize(size);
+            success = GetUserName(&buf[0], &size);
+        }
+        if(!success)
+        {
+            Ice::SyscallException ex(__FILE__, __LINE__);
+            ex.error = IceInternal::getSystemErrno();
+            throw ex;
+        }
+        if(user != string(&buf[0]))
+        {
+            throw "couldn't load server under user account `" + user + "': feature not supported on Windows";
+        }
+    }
+#else
+        //
+        // Get the uid/gid associated with the given user.
+        //
+        struct passwd* pw = getpwnam(user.c_str());
+        if(!pw)
+        {
+            throw "unknown user account `" + user + "'";
+        }
+
+        //
+        // If the node isn't running as root and if the uid of the
+        // configured user is different from the uid of the userr
+        // running the node we throw, a regular user can't run a
+        // process as another user.
+        //
+        if(uid != 0 && pw->pw_uid != uid)
+        {
+            throw "node has insufficient privileges to load server under user account `" + user + "'";
+        }
+
+
+	if(pw->pw_uid == 0 &&
+	   _node->getCommunicator()->getProperties()->getPropertyAsInt("IceGrid.Node.AllowRunningServersAsRoot") == 0)
+	{
+	    throw "running server as `root' is not allowed";
+	}
+
+        if(update)
+        {
+            _uid = pw->pw_uid;
+            _gid = pw->pw_gid;
+        }
+    }
+    else if(update)
+    {
+        _uid = uid;
+        _gid = gid;
+    }
+#endif
+}
+
+void
 ServerI::updateRevision(const string& uuid, int revision)
 {
     _desc->uuid = uuid;
     _desc->revision = revision;
 
+    if(_load)
+    {
+        _load->getInternalServerDescriptor()->uuid = uuid;
+        _load->getInternalServerDescriptor()->revision = revision;
+    }
+
     string idFilePath = _serverDir + "/revision";
     IceUtilInternal::ofstream os(idFilePath); // idFilePath is a UTF-8 string
     if(os.good())
@@ -2355,6 +2591,41 @@ ServerI::updateRevision(const string& uuid, int revision)
     }
 }
 
+void
+ServerI::updateRuntimePropertiesCallback(const InternalServerDescriptorPtr& desc)
+{
+    Lock sync(*this);
+    if(_state != Active || !_load)
+    {
+        return;
+    }
+
+    if(_load->finishRuntimePropertiesUpdate(desc, _process))
+    {
+        AdapterPrxDict adapters;
+        for(ServerAdapterDict::const_iterator p = _adapters.begin(); p != _adapters.end(); ++p)
+        {
+            adapters.insert(make_pair(p->first, p->second->getProxy()));
+        }
+        _load->finished(_this, adapters, _activationTimeout, _deactivationTimeout);
+    }
+}
+
+void
+ServerI::updateRuntimePropertiesCallback(const Ice::Exception& ex, const InternalServerDescriptorPtr& desc)
+{
+    Lock sync(*this);
+    if(_state != Active || !_load)
+    {
+        return;
+    }
+
+    if(_load->finishRuntimePropertiesUpdate(desc, _process))
+    {
+        _load->failed(ex);
+    }
+}
+
 bool
 ServerI::checkActivation()
 {
@@ -2469,7 +2740,6 @@ ServerI::setStateNoSync(InternalServerState st, const std::string& reason)
     //
     InternalServerState previous = _state;
     _state = st;
-
    
     //
     // Check if some commands are done.
@@ -2617,6 +2887,14 @@ ServerI::setStateNoSync(InternalServerState st, const std::string& reason)
             }
         }
     }
+    else if(_state == Active && _load)
+    {
+        //
+        // If there's a pending load command, it's time to update the
+        // runtime properties of the server now that it's active.
+        //
+        _load->startRuntimePropertiesUpdate(_process);
+    }
 
     //
     // Don't send the server update if the state didn't change or if
@@ -2641,8 +2919,11 @@ ServerI::setStateNoSync(InternalServerState st, const std::string& reason)
         }
         else if(_state == ServerI::Inactive)
         {
-            Ice::Trace out(_node->getTraceLevels()->logger, _node->getTraceLevels()->serverCat);
-            out << "changed server `" << _id << "' state to `Inactive'";
+            if(_node->getTraceLevels()->server != 2 && !(previous == ServerI::Loading || previous == ServerI::Patching))
+            {
+                Ice::Trace out(_node->getTraceLevels()->logger, _node->getTraceLevels()->serverCat);
+                out << "changed server `" << _id << "' state to `Inactive'";
+            }
         }
         else if(_state == ServerI::Destroyed)
         {
@@ -2819,3 +3100,59 @@ ServerI::getFilePath(const string& filename) const
     }
 }
 
+PropertyDescriptorSeqDict
+ServerI::getProperties(const InternalServerDescriptorPtr& desc)
+{
+    //
+    // Copy the descriptor properties.
+    //
+    PropertyDescriptorSeqDict properties = desc->properties;
+    PropertyDescriptorSeq& props = properties["config"];
+    
+    //
+    // Cache the path of the stderr/stdout file, first check if the
+    // node OutputDir property is set and then we check the server
+    // configuration file for the Ice.StdErr and Ice.StdOut
+    // properties.
+    //
+    string stdErrFile = getProperty(props, "Ice.StdErr");
+    string stdOutFile = getProperty(props, "Ice.StdOut");
+    string outputDir = _node->getOutputDir();
+    if(!outputDir.empty())
+    {
+        if(stdErrFile.empty())
+        {
+            stdErrFile = outputDir + "/" + _id + (_node->getRedirectErrToOut() ? ".out" : ".err");
+            props.push_back(createProperty("Ice.StdErr", stdErrFile));
+        }
+        if(stdOutFile.empty())
+        {
+            stdOutFile = outputDir + "/" + _id + ".out";
+            props.push_back(createProperty("Ice.StdOut", stdOutFile));
+        }
+    }
+
+    //
+    // Add the locator proxy property and the node properties override
+    //
+    {
+        const PropertyDescriptorSeq& overrides = _node->getPropertiesOverride();
+        for(PropertyDescriptorSeqDict::iterator p = properties.begin(); p != properties.end(); ++p)
+        {
+            if(getProperty(p->second, "Ice.Default.Locator").empty())
+            {
+                p->second.push_back(
+                    createProperty("Ice.Default.Locator",
+                                   _node->getCommunicator()->getProperties()->getProperty("Ice.Default.Locator")));
+            }
+            
+            if(!overrides.empty())
+            {
+                p->second.push_back(createProperty("# Node properties override"));
+                p->second.insert(p->second.end(), overrides.begin(), overrides.end());
+            }
+        }
+    }
+
+    return properties;
+}
diff --git a/cpp/src/IceGrid/ServerI.h b/cpp/src/IceGrid/ServerI.h
index e40cd51c877..b86d611bf7a 100644
--- a/cpp/src/IceGrid/ServerI.h
+++ b/cpp/src/IceGrid/ServerI.h
@@ -94,7 +94,8 @@ public:
     bool dependsOnApplicationDistrib() const;
 
     void start(ServerActivation, const AMD_Server_startPtr& = AMD_Server_startPtr());
-    ServerCommandPtr load(const AMD_Node_loadServerPtr&, const InternalServerDescriptorPtr&, const std::string&);
+    ServerCommandPtr load(const AMD_Node_loadServerPtr&, const InternalServerDescriptorPtr&, const std::string&, bool);
+    bool checkUpdate(const InternalServerDescriptorPtr&, bool, const Ice::Current&);
     ServerCommandPtr destroy(const AMD_Node_destroyServerPtr&, const std::string&, int, const std::string&);
     bool startPatch(bool);
     bool waitForPatch();
@@ -117,10 +118,17 @@ public:
     //
     Ice::ObjectPrx getProcess() const;
 
+    PropertyDescriptorSeqDict getProperties(const InternalServerDescriptorPtr&);
+
+    void updateRuntimePropertiesCallback(const InternalServerDescriptorPtr&);
+    void updateRuntimePropertiesCallback(const Ice::Exception&, const InternalServerDescriptorPtr&);
+
 private:
     
     void updateImpl(const InternalServerDescriptorPtr&);
     void checkRevision(const std::string&, const std::string&, int) const;
+    void checkNoRestart(const InternalServerDescriptorPtr&);
+    void checkAndUpdateUser(const InternalServerDescriptorPtr&, bool);
     void updateRevision(const std::string&, int);
     bool checkActivation();
     void checkDestroyed() const;
@@ -299,7 +307,7 @@ class LoadCommand : public ServerCommand
 {
 public:
 
-    LoadCommand(const ServerIPtr&);
+    LoadCommand(const ServerIPtr&, const InternalServerDescriptorPtr&, const TraceLevelsPtr&);
 
     bool canExecute(ServerI::InternalServerState);
     ServerI::InternalServerState nextState();
@@ -309,6 +317,8 @@ public:
     bool clearDir() const;
     InternalServerDescriptorPtr getInternalServerDescriptor() const;
     void addCallback(const AMD_Node_loadServerPtr&);
+    void startRuntimePropertiesUpdate(const Ice::ObjectPrx&);
+    bool finishRuntimePropertiesUpdate(const InternalServerDescriptorPtr&, const Ice::ObjectPrx&);
     void failed(const Ice::Exception&);
     void finished(const ServerPrx&, const AdapterPrxDict&, int, int);
 
@@ -317,6 +327,9 @@ private:
     std::vector<AMD_Node_loadServerPtr> _loadCB;
     bool _clearDir;
     InternalServerDescriptorPtr _desc;
+    InternalServerDescriptorPtr _runtime;
+    bool _updating;
+    TraceLevelsPtr _traceLevels;
     std::auto_ptr<DeploymentException> _exception;
 };