Added ordered load balancing

11 files changed, 171 insertions, 116 deletions

diff --git a/cpp/src/IceGrid/AdapterCache.cpp b/cpp/src/IceGrid/AdapterCache.cpp
index 84776e93237..087049e83bc 100644
--- a/cpp/src/IceGrid/AdapterCache.cpp
+++ b/cpp/src/IceGrid/AdapterCache.cpp
@@ -26,25 +26,33 @@ namespace IceGrid
 
 struct ReplicaLoadComp : binary_function<ServerAdapterEntryPtr&, ServerAdapterEntryPtr&, bool>
 {
-    typedef ReplicaGroupEntry::ReplicaSeq::value_type Replica;
-    typedef pair<float, Replica> ReplicaLoad;
-
-    bool operator()(const ReplicaLoad& lhs, const ReplicaLoad& rhs)
+    bool operator()(const pair<float, ServerAdapterEntryPtr>& lhs, const pair<float, ServerAdapterEntryPtr>& rhs)
     {
 	return lhs.first < rhs.first;
     }
 };
 
-struct ToReplicaLoad : public unary_function<const ReplicaLoadComp::Replica&, ReplicaLoadComp::ReplicaLoad>
+struct ReplicaPriorityComp : binary_function<ServerAdapterEntryPtr&, ServerAdapterEntryPtr&, bool>
+{
+    bool operator()(const ServerAdapterEntryPtr& lhs, const ServerAdapterEntryPtr& rhs)
+    {
+	return lhs->getPriority() < rhs->getPriority();
+    }
+};
+
+struct TransformToReplicaLoad : 
+	public unary_function<const ServerAdapterEntryPtr&, pair<float, ServerAdapterEntryPtr> >
 {
-    ToReplicaLoad(LoadSample loadSample) : _loadSample(loadSample) { }
+public:
 
-    ReplicaLoadComp::ReplicaLoad
-    operator()(const ReplicaLoadComp::Replica& value)
+    TransformToReplicaLoad(LoadSample loadSample) : _loadSample(loadSample) { }
+
+    pair<float, ServerAdapterEntryPtr>
+    operator()(const ServerAdapterEntryPtr& value)
     {
 	try
 	{
-	    return make_pair(value.second->getLeastLoadedNodeLoad(_loadSample), value);
+	    return make_pair(value->getLeastLoadedNodeLoad(_loadSample), value);
 	}
 	catch(const Ice::Exception&)
 	{
@@ -55,10 +63,10 @@ struct ToReplicaLoad : public unary_function<const ReplicaLoadComp::Replica&, Re
     LoadSample _loadSample;
 };
 
-struct ToReplica : public unary_function<const ReplicaLoadComp::ReplicaLoad&, ReplicaLoadComp::Replica>
+struct TransformToReplica : public unary_function<const pair<string, ServerAdapterEntryPtr>&, ServerAdapterEntryPtr>
 {
-    ReplicaLoadComp::Replica
-    operator()(const ReplicaLoadComp::ReplicaLoad& value)
+    ServerAdapterEntryPtr
+    operator()(const pair<float, ServerAdapterEntryPtr>& value)
     {
 	return value.second;
     }
@@ -67,30 +75,35 @@ struct ToReplica : public unary_function<const ReplicaLoadComp::ReplicaLoad&, Re
 }
 
 ServerAdapterEntryPtr
-AdapterCache::addServerAdapter(const string& id, const string& rgId, const ServerEntryPtr& server)
+AdapterCache::addServerAdapter(const AdapterDescriptor& desc, const ServerEntryPtr& server)
 {
     Lock sync(*this);
-    assert(!getImpl(id));
-    ServerAdapterEntryPtr entry = new ServerAdapterEntry(*this, id, rgId, server);
-    addImpl(id, entry);
+    assert(!getImpl(desc.id));
+
+    istringstream is(desc.priority);
+    int priority = 0;
+    is >> priority;
+
+    ServerAdapterEntryPtr entry = new ServerAdapterEntry(*this, desc.id, desc.replicaGroupId, priority, server);
+    addImpl(desc.id, entry);
 
-    if(!rgId.empty())
+    if(!desc.replicaGroupId.empty())
     {
-	ReplicaGroupEntryPtr repEntry = ReplicaGroupEntryPtr::dynamicCast(getImpl(rgId));
+	ReplicaGroupEntryPtr repEntry = ReplicaGroupEntryPtr::dynamicCast(getImpl(desc.replicaGroupId));
 	assert(repEntry);
-	repEntry->addReplica(id, entry);
+	repEntry->addReplica(desc.id, entry);
     }
 
     return entry;
 }
 
 ReplicaGroupEntryPtr
-AdapterCache::addReplicaGroup(const string& id, const string& app, const LoadBalancingPolicyPtr& loadBalancing)
+AdapterCache::addReplicaGroup(const ReplicaGroupDescriptor& desc, const string& app)
 {
     Lock sync(*this);
-    assert(!getImpl(id));
-    ReplicaGroupEntryPtr entry = new ReplicaGroupEntry(*this, id, app, loadBalancing);
-    addImpl(id, entry);
+    assert(!getImpl(desc.id));
+    ReplicaGroupEntryPtr entry = new ReplicaGroupEntry(*this, desc.id, app, desc.loadBalancing);
+    addImpl(desc.id, entry);
     return entry;
 }
 
@@ -189,12 +202,20 @@ AdapterEntry::canRemove()
     return true;
 }
 
+string
+AdapterEntry::getId() const
+{
+    return _id;
+}
+
 ServerAdapterEntry::ServerAdapterEntry(AdapterCache& cache,
 				       const string& id,
 				       const string& replicaGroupId, 
+				       int priority,
 				       const ServerEntryPtr& server) : 
     AdapterEntry(cache, id),
     _replicaGroupId(replicaGroupId),
+    _priority(priority),
     _server(server)
 {
 }
@@ -263,6 +284,12 @@ ServerAdapterEntry::getProxy(const string& replicaGroupId, bool upToDate) const
     }
 }
 
+int
+ServerAdapterEntry::getPriority() const
+{
+    return _priority;
+}
+
 ServerEntryPtr
 ServerAdapterEntry::getServer() const
 {
@@ -286,16 +313,16 @@ void
 ReplicaGroupEntry::addReplica(const string& replicaId, const ServerAdapterEntryPtr& adapter)
 {
     Lock sync(*this);
-    _replicas.push_back(make_pair(replicaId, adapter));
+    _replicas.push_back(adapter);
 }
 
 void
 ReplicaGroupEntry::removeReplica(const string& replicaId)
 {
     Lock sync(*this);
-    for(ReplicaGroupEntry::ReplicaSeq::iterator p = _replicas.begin(); p != _replicas.end(); ++p)
+    for(vector<ServerAdapterEntryPtr>::iterator p = _replicas.begin(); p != _replicas.end(); ++p)
     {
-	if(replicaId == p->first)
+	if(replicaId == (*p)->getId())
 	{
 	    _replicas.erase(p);		
 	    // Make sure _lastReplica is still within the bounds.
@@ -309,36 +336,32 @@ void
 ReplicaGroupEntry::update(const LoadBalancingPolicyPtr& policy)
 {
     Lock sync(*this);
+    assert(policy);
+
     _loadBalancing = policy;
-    if(!_loadBalancing)
-    {
-	_loadBalancingNReplicas = 0;
-    }
-    else
+
+    istringstream is(_loadBalancing->nReplicas);
+    int nReplicas = 0;
+    is >> nReplicas;
+    _loadBalancingNReplicas = nReplicas < 0 ? 1 : nReplicas;
+    AdaptiveLoadBalancingPolicyPtr alb = AdaptiveLoadBalancingPolicyPtr::dynamicCast(_loadBalancing);
+    if(alb)
     {
-	istringstream is(_loadBalancing->nReplicas);
-	int nReplicas = 0;
-	is >> nReplicas;
-	_loadBalancingNReplicas = nReplicas < 1 ? 1 : nReplicas;
-	AdaptiveLoadBalancingPolicyPtr alb = AdaptiveLoadBalancingPolicyPtr::dynamicCast(_loadBalancing);
-	if(alb)
+	if(alb->loadSample == "1")
 	{
-	    if(alb->loadSample == "1")
-	    {
-		_loadSample = LoadSample1;
-	    }
-	    else if(alb->loadSample == "5")
-	    {
-		_loadSample = LoadSample5;
-	    }
-	    else if(alb->loadSample == "15")
-	    {
-		_loadSample = LoadSample15;
-	    }
-	    else
-	    {
-		_loadSample = LoadSample1;
-	    }
+	    _loadSample = LoadSample1;
+	}
+	else if(alb->loadSample == "5")
+	{
+	    _loadSample = LoadSample5;
+	}
+	else if(alb->loadSample == "15")
+	{
+	    _loadSample = LoadSample15;
+	}
+	else
+	{
+	    _loadSample = LoadSample1;
 	}
     }
 }
@@ -346,7 +369,7 @@ ReplicaGroupEntry::update(const LoadBalancingPolicyPtr& policy)
 vector<pair<string, AdapterPrx> >
 ReplicaGroupEntry::getProxies(int& nReplicas, bool& replicaGroup)
 {
-    ReplicaSeq replicas;
+    vector<ServerAdapterEntryPtr> replicas;
     bool adaptive = false;
     LoadSample loadSample = LoadSample1;
     {
@@ -360,10 +383,6 @@ ReplicaGroupEntry::getProxies(int& nReplicas, bool& replicaGroup)
 
 	nReplicas = _loadBalancingNReplicas > 0 ? _loadBalancingNReplicas : static_cast<int>(_replicas.size());
 	replicas.reserve(_replicas.size());
-	if(!_loadBalancing)
-	{
-	    replicas = _replicas;
-	}
 	if(RoundRobinLoadBalancingPolicyPtr::dynamicCast(_loadBalancing))
 	{
 	    for(unsigned int i = 0; i < _replicas.size(); ++i)
@@ -377,10 +396,15 @@ ReplicaGroupEntry::getProxies(int& nReplicas, bool& replicaGroup)
 	    replicas = _replicas;
 	    RandomNumberGenerator rng;
 	    random_shuffle(replicas.begin(), replicas.end(), rng);
-	    adaptive = true;
 	    loadSample = _loadSample;
+	    adaptive = true;
 	}
-	else// if(RandomLoadBalancingPolicyPtr::dynamicCast(_loadBalancing))
+	else if(OrderedLoadBalancingPolicyPtr::dynamicCast(_loadBalancing))
+	{
+	    replicas = _replicas;
+	    sort(replicas.begin(), replicas.end(), ReplicaPriorityComp());
+	}
+	else if(RandomLoadBalancingPolicyPtr::dynamicCast(_loadBalancing))
 	{
 	    replicas = _replicas;
 	    RandomNumberGenerator rng;
@@ -392,14 +416,16 @@ ReplicaGroupEntry::getProxies(int& nReplicas, bool& replicaGroup)
     {
 	//
 	// This must be done outside the synchronization block since
-	// the sort() will call and lock each server entry.
+	// the trasnform() might call and lock each server adapter
+	// entry. We also can't sort directly as the load of each
+	// server adapter is not stable so we first take a snapshot of
+	// each adapter and sort the snapshot.
 	//
-
-	vector<ReplicaLoadComp::ReplicaLoad> rl;
-	transform(replicas.begin(), replicas.end(), back_inserter(rl), ToReplicaLoad(loadSample));
+	vector<pair<float, ServerAdapterEntryPtr> > rl;
+	transform(replicas.begin(), replicas.end(), back_inserter(rl), TransformToReplicaLoad(loadSample));
 	sort(rl.begin(), rl.end(), ReplicaLoadComp());
 	replicas.clear();
-	transform(rl.begin(), rl.end(), back_inserter(replicas), ToReplica());
+	transform(rl.begin(), rl.end(), back_inserter(replicas), TransformToReplica());
     }
 
     //
@@ -408,7 +434,7 @@ ReplicaGroupEntry::getProxies(int& nReplicas, bool& replicaGroup)
     // reachable.
     //
     vector<pair<string, AdapterPrx> > adapters;
-    for(ReplicaSeq::const_iterator p = replicas.begin(); p != replicas.end(); ++p)
+    for(vector<ServerAdapterEntryPtr>::const_iterator p = replicas.begin(); p != replicas.end(); ++p)
     {
 	try
 	{
@@ -417,8 +443,8 @@ ReplicaGroupEntry::getProxies(int& nReplicas, bool& replicaGroup)
 	    // compiler bug with xlC on AIX which causes a segfault if
 	    // getProxy raises an exception.
 	    //
-	    AdapterPrx adpt = p->second->getProxy(_id, true);
-	    adapters.push_back(make_pair(p->first, adpt));
+	    AdapterPrx adpt = (*p)->getProxy(_id, true);
+	    adapters.push_back(make_pair((*p)->getId(), adpt));
 	}
 	catch(const AdapterNotExistException&)
 	{
@@ -437,7 +463,7 @@ ReplicaGroupEntry::getProxies(int& nReplicas, bool& replicaGroup)
 float
 ReplicaGroupEntry::getLeastLoadedNodeLoad(LoadSample loadSample) const
 {
-    ReplicaSeq replicas;
+    vector<ServerAdapterEntryPtr> replicas;
     {
 	Lock sync(*this);
 	replicas = _replicas;
@@ -449,9 +475,9 @@ ReplicaGroupEntry::getLeastLoadedNodeLoad(LoadSample loadSample) const
     //
     RandomNumberGenerator rng;
     random_shuffle(replicas.begin(), replicas.end(), rng);
-    vector<ReplicaLoadComp::ReplicaLoad> rl;
-    transform(replicas.begin(), replicas.end(), back_inserter(rl), ToReplicaLoad(loadSample));
-    AdapterEntryPtr adpt = min_element(rl.begin(), rl.end(), ReplicaLoadComp())->second.second;
+    vector<pair<float, ServerAdapterEntryPtr> > rl;
+    transform(replicas.begin(), replicas.end(), back_inserter(rl), TransformToReplicaLoad(loadSample));
+    AdapterEntryPtr adpt = min_element(rl.begin(), rl.end(), ReplicaLoadComp())->second;
     return adpt->getLeastLoadedNodeLoad(loadSample);
 }
 
@@ -465,16 +491,16 @@ ReplicaGroupEntry::getApplication() const
 AdapterInfoSeq
 ReplicaGroupEntry::getAdapterInfo() const
 {
-    ReplicaSeq replicas;
+    vector<ServerAdapterEntryPtr> replicas;
     {
 	Lock sync(*this);
 	replicas = _replicas;
     }
 
     AdapterInfoSeq infos;
-    for(ReplicaSeq::const_iterator p = replicas.begin(); p != replicas.end(); ++p)
+    for(vector<ServerAdapterEntryPtr>::const_iterator p = replicas.begin(); p != replicas.end(); ++p)
     {
-	AdapterInfoSeq infs = p->second->getAdapterInfo();
+	AdapterInfoSeq infs = (*p)->getAdapterInfo();
 	assert(infs.size() == 1);
 	infos.push_back(infs[0]);
     }
diff --git a/cpp/src/IceGrid/AdapterCache.h b/cpp/src/IceGrid/AdapterCache.h
index 94a19e1fe40..cec41f9214f 100644
--- a/cpp/src/IceGrid/AdapterCache.h
+++ b/cpp/src/IceGrid/AdapterCache.h
@@ -40,6 +40,8 @@ public:
     virtual AdapterInfoSeq getAdapterInfo() const = 0;
 
     virtual bool canRemove();
+
+    std::string getId() const;
     
 protected:
 
@@ -52,7 +54,7 @@ class ServerAdapterEntry : public AdapterEntry
 {
 public:
 
-    ServerAdapterEntry(AdapterCache&, const std::string&, const std::string&, const ServerEntryPtr&);
+    ServerAdapterEntry(AdapterCache&, const std::string&, const std::string&, int, const ServerEntryPtr&);
 
     virtual std::vector<std::pair<std::string, AdapterPrx> > getProxies(int&, bool&);
     virtual float getLeastLoadedNodeLoad(LoadSample) const;
@@ -61,12 +63,14 @@ public:
     virtual const std::string& getReplicaGroupId() const { return _replicaGroupId; }
 
     AdapterPrx getProxy(const std::string&, bool) const;
-
+    int getPriority() const;
+    
 private:
     
     ServerEntryPtr getServer() const;
 
     const std::string _replicaGroupId;
+    const int _priority;
     const ServerEntryPtr _server;
 };
 typedef IceUtil::Handle<ServerAdapterEntry> ServerAdapterEntryPtr;
@@ -87,8 +91,6 @@ public:
 
     void update(const LoadBalancingPolicyPtr&);
 
-    typedef std::vector<std::pair<std::string, ServerAdapterEntryPtr> > ReplicaSeq;
-
 private:
 
     const std::string _application;
@@ -96,7 +98,7 @@ private:
     LoadBalancingPolicyPtr _loadBalancing;
     int _loadBalancingNReplicas;
     LoadSample _loadSample;
-    ReplicaSeq _replicas;
+    std::vector<ServerAdapterEntryPtr> _replicas;
     int _lastReplica;
 };
 typedef IceUtil::Handle<ReplicaGroupEntry> ReplicaGroupEntryPtr;
@@ -105,8 +107,8 @@ class AdapterCache : public CacheByString<AdapterEntry>
 {
 public:
 
-    ServerAdapterEntryPtr addServerAdapter(const std::string&, const std::string&, const ServerEntryPtr&);
-    ReplicaGroupEntryPtr addReplicaGroup(const std::string&, const std::string&, const LoadBalancingPolicyPtr&);
+    ServerAdapterEntryPtr addServerAdapter(const AdapterDescriptor&, const ServerEntryPtr&);
+    ReplicaGroupEntryPtr addReplicaGroup(const ReplicaGroupDescriptor&, const std::string&);
 
     AdapterEntryPtr get(const std::string&) const;
     ServerAdapterEntryPtr getServerAdapter(const std::string&) const;
diff --git a/cpp/src/IceGrid/Database.cpp b/cpp/src/IceGrid/Database.cpp
index ff7858f900b..9e7debbaaac 100644
--- a/cpp/src/IceGrid/Database.cpp
+++ b/cpp/src/IceGrid/Database.cpp
@@ -1554,7 +1554,7 @@ Database::load(const ApplicationHelper& app, ServerEntrySeq& entries, const stri
     for(ReplicaGroupDescriptorSeq::const_iterator r = adpts.begin(); r != adpts.end(); ++r)
     {
 	assert(!r->id.empty());
-	_adapterCache.addReplicaGroup(r->id, application, r->loadBalancing);
+	_adapterCache.addReplicaGroup(*r, application);
 	for(ObjectDescriptorSeq::const_iterator o = r->objects.begin(); o != r->objects.end(); ++o)
 	{
 	    ObjectInfo info;
@@ -1693,7 +1693,7 @@ Database::reload(const ApplicationHelper& oldApp,
 	}
 	catch(const AdapterNotExistException&)
 	{
-	    _adapterCache.addReplicaGroup(r->id, application, r->loadBalancing);
+	    _adapterCache.addReplicaGroup(*r, application);
 	}
 
 	for(ObjectDescriptorSeq::const_iterator o = r->objects.begin(); o != r->objects.end(); ++o)
diff --git a/cpp/src/IceGrid/DescriptorBuilder.cpp b/cpp/src/IceGrid/DescriptorBuilder.cpp
index c10abbe9acb..7071c4a359a 100644
--- a/cpp/src/IceGrid/DescriptorBuilder.cpp
+++ b/cpp/src/IceGrid/DescriptorBuilder.cpp
@@ -253,6 +253,16 @@ ApplicationDescriptorBuilder::addReplicaGroup(const XmlAttributesHelper& attrs)
 }
 
 void
+ApplicationDescriptorBuilder::finishReplicaGroup()
+{
+    if(!_descriptor.replicaGroups.back().loadBalancing)
+    {
+	_descriptor.replicaGroups.back().loadBalancing = new RandomLoadBalancingPolicy();
+	_descriptor.replicaGroups.back().loadBalancing->nReplicas = "0";
+    }
+}
+
+void
 ApplicationDescriptorBuilder::setLoadBalancing(const XmlAttributesHelper& attrs)
 {
     LoadBalancingPolicyPtr policy;
@@ -261,6 +271,10 @@ ApplicationDescriptorBuilder::setLoadBalancing(const XmlAttributesHelper& attrs)
     {
 	policy = new RandomLoadBalancingPolicy();
     }
+    else if(type == "ordered")
+    {
+	policy = new OrderedLoadBalancingPolicy();
+    }
     else if(type == "round-robin")
     {
 	policy = new RoundRobinLoadBalancingPolicy();
@@ -275,7 +289,7 @@ ApplicationDescriptorBuilder::setLoadBalancing(const XmlAttributesHelper& attrs)
     {
 	throw "invalid load balancing policy `" + type + "'";
     }
-    policy->nReplicas = attrs("n-replicas", "0");
+    policy->nReplicas = attrs("n-replicas", "1");
     _descriptor.replicaGroups.back().loadBalancing = policy;
 }
 
@@ -611,6 +625,7 @@ CommunicatorDescriptorBuilder::addAdapter(const XmlAttributesHelper& attrs)
 	desc.id = fqn + "." + desc.name;
     }
     desc.replicaGroupId = attrs("replica-group", "");
+    desc.priority = attrs("priority", "");
     desc.registerProcess = attrs.asBool("register-process", false);
     if(desc.id == "")
     {
@@ -817,7 +832,7 @@ IceBoxDescriptorBuilder::init(const IceBoxDescriptorPtr& desc, const XmlAttribut
     ServerDescriptorBuilder::init(desc, attrs);
     _descriptor = desc;
 
-    addProperty(_hiddenProperties, "IceBox.InstanceName", _descriptor->id);    
+    addProperty(_hiddenProperties, "IceBox.InstanceName", "${server}");
     addProperty(_hiddenProperties, "IceBox.ServiceManager.Endpoints", "tcp -h 127.0.0.1");
     addProperty(_hiddenProperties, "IceBox.ServiceManager.RegisterProcess", "1");
 }
diff --git a/cpp/src/IceGrid/DescriptorBuilder.h b/cpp/src/IceGrid/DescriptorBuilder.h
index a44e70bda46..a0f5bfea50c 100644
--- a/cpp/src/IceGrid/DescriptorBuilder.h
+++ b/cpp/src/IceGrid/DescriptorBuilder.h
@@ -92,6 +92,7 @@ public:
     void setVariableOverrides(const std::map<std::string, std::string>&);
     void setDescription(const std::string&);
     void addReplicaGroup(const XmlAttributesHelper&);
+    void finishReplicaGroup();
     void setLoadBalancing(const XmlAttributesHelper&);
     void setReplicaGroupDescription(const std::string&);
     void addObject(const XmlAttributesHelper&);
diff --git a/cpp/src/IceGrid/DescriptorHelper.cpp b/cpp/src/IceGrid/DescriptorHelper.cpp
index e897cd56d74..44ed4a8f2d4 100644
--- a/cpp/src/IceGrid/DescriptorHelper.cpp
+++ b/cpp/src/IceGrid/DescriptorHelper.cpp
@@ -536,6 +536,10 @@ Resolver::asInt(const string& value, const string& name) const
 	    ex.reason = "invalid value `" + value + "' for `" + name + "' in " + _context + ": not an integer";
 	    throw ex;
 	}
+
+	ostringstream os;
+	os << val;
+	v = os.str();
     }
     return v;
 }
@@ -940,6 +944,7 @@ CommunicatorHelper::instantiateImpl(const CommunicatorDescriptorPtr& instance, c
 	{
 	    resolve.exception("unknown replica group `" + adapter.replicaGroupId + "'");
 	}
+	adapter.priority = resolve.asInt(p->priority, "object adapter priority");
 	adapter.objects = resolve(p->objects, "well-known");
 	adapter.allocatables = resolve(p->allocatables, "allocatable");
 	instance->adapters.push_back(adapter);
@@ -1033,6 +1038,10 @@ CommunicatorHelper::printObjectAdapter(Output& out, const AdapterDescriptor& ada
     {
 	out << nl << "replica group id = `" << adapter.replicaGroupId << "'";
     }
+    if(!adapter.priority.empty())
+    {
+	out << nl << "priority = `" << adapter.priority << "'";
+    }
     string endpoints = getProperty(adapter.name + ".Endpoints");
     if(!endpoints.empty())
     {
@@ -2288,22 +2297,26 @@ ApplicationHelper::ApplicationHelper(const Ice::CommunicatorPtr& communicator, c
 	ReplicaGroupDescriptor desc;
 	desc.id = r->id;
 	desc.description = resolve(r->description, "replica group description");
-	desc.objects = resolve(r->objects, "well-known");
-
-	if(r->loadBalancing)
+	desc.objects = resolve(r->objects, "replica group well-known");
+	if(!r->loadBalancing)
+	{
+	    resolve.exception("replica group load balancing is not set");
+	}
+	desc.loadBalancing = LoadBalancingPolicyPtr::dynamicCast(r->loadBalancing->ice_clone());
+	desc.loadBalancing->nReplicas = resolve.asInt(r->loadBalancing->nReplicas, "replica group number of replicas");
+	if(desc.loadBalancing->nReplicas[0] == '-')
 	{
-	    desc.loadBalancing = LoadBalancingPolicyPtr::dynamicCast(r->loadBalancing->ice_clone());
-	    desc.loadBalancing->nReplicas = resolve(r->loadBalancing->nReplicas, "replica group number of replicas");
-	    AdaptiveLoadBalancingPolicyPtr al = AdaptiveLoadBalancingPolicyPtr::dynamicCast(desc.loadBalancing);
-	    if(al)
+	    resolve.exception("invalid replica group load balancing number of replicas value: inferior to 0");
+	}
+	AdaptiveLoadBalancingPolicyPtr al = AdaptiveLoadBalancingPolicyPtr::dynamicCast(desc.loadBalancing);
+	if(al)
+	{
+	    al->loadSample = resolve(al->loadSample, "replica group load sample");
+	    if(al->loadSample != "" && al->loadSample != "1" && al->loadSample != "5" && al->loadSample != "15")
 	    {
-		al->loadSample = resolve(al->loadSample, "replica group load sample");
-		if(al->loadSample != "" && al->loadSample != "1" && al->loadSample != "5" && al->loadSample != "15")
-		{
-		    resolve.exception("invalid load sample value (allowed values are 1, 5 or 15)");
-		}
+		resolve.exception("invalid load sample value (allowed values are 1, 5 or 15)");
 	    }
-	}	
+	}
 	_instance.replicaGroups.push_back(desc);
     }
     
diff --git a/cpp/src/IceGrid/DescriptorParser.cpp b/cpp/src/IceGrid/DescriptorParser.cpp
index ea7d672fe32..06b8919f721 100644
--- a/cpp/src/IceGrid/DescriptorParser.cpp
+++ b/cpp/src/IceGrid/DescriptorParser.cpp
@@ -668,6 +668,7 @@ DescriptorHandler::endElement(const string& name, int line, int column)
 	} 
 	else if(name == "replica-group")
 	{
+	    _currentApplication->finishReplicaGroup();
 	    _inReplicaGroup = false;
 	} 
 	else if(name == "dbenv")
diff --git a/cpp/src/IceGrid/ServerAdapterI.cpp b/cpp/src/IceGrid/ServerAdapterI.cpp
index eef9228ec94..4a35b9551b5 100644
--- a/cpp/src/IceGrid/ServerAdapterI.cpp
+++ b/cpp/src/IceGrid/ServerAdapterI.cpp
@@ -149,10 +149,6 @@ ServerAdapterI::setDirectProxy(const Ice::ObjectPrx& prx, const Ice::Current&)
     {
 	_server->adapterActivated(_id);
     }
-    else
-    {
-	_server->adapterDeactivated(_id);
-    }
 
     if(_node->getTraceLevels()->adapter > 1)
     {
diff --git a/cpp/src/IceGrid/ServerCache.cpp b/cpp/src/IceGrid/ServerCache.cpp
index b53ba74b4ac..88c0cbac8ad 100644
--- a/cpp/src/IceGrid/ServerCache.cpp
+++ b/cpp/src/IceGrid/ServerCache.cpp
@@ -159,7 +159,7 @@ ServerCache::addCommunicator(const CommunicatorDescriptorPtr& comm, const Server
     for(AdapterDescriptorSeq::const_iterator q = comm->adapters.begin() ; q != comm->adapters.end(); ++q)
     {
 	assert(!q->id.empty());
-	_adapterCache.addServerAdapter(q->id, q->replicaGroupId, server);
+	_adapterCache.addServerAdapter(*q, server);
 
 	ObjectDescriptorSeq::const_iterator r;
 	for(r = q->objects.begin(); r != q->objects.end(); ++r)
diff --git a/cpp/src/IceGrid/ServerI.cpp b/cpp/src/IceGrid/ServerI.cpp
index 2cf219ca006..2f35755110e 100644
--- a/cpp/src/IceGrid/ServerI.cpp
+++ b/cpp/src/IceGrid/ServerI.cpp
@@ -1108,7 +1108,13 @@ ServerI::adapterActivated(const string& id)
     ServerCommandPtr command;
     {
 	Lock sync(*this);
-	_activeAdapters.insert(id);
+	if(_state != ServerI::Activating && 
+	   _state != ServerI::WaitForActivation &&
+	   _state != ServerI::ActivationTimeout)
+	{
+	    return;
+	}
+	_activatedAdapters.insert(id);
 	checkActivation();
 	command = nextCommand();
     }
@@ -1176,13 +1182,6 @@ ServerI::enableAfterFailure(bool force)
 }
 
 void
-ServerI::adapterDeactivated(const string& id)
-{
-    Lock sync(*this);
-    _activeAdapters.erase(id);
-}
-
-void
 ServerI::activationFailed(bool destroyed)
 {
     ServerCommandPtr command;
@@ -1501,6 +1500,7 @@ ServerI::terminated(const string& msg, int status)
 	//
 	_process = 0;
 	_pid = 0;
+	_activatedAdapters.clear();
 
 	bool failed = false;
 #ifndef _WIN32
@@ -2035,7 +2035,7 @@ ServerI::checkActivation()
 	for(AdapterDescriptorSeq::const_iterator p = _info.descriptor->adapters.begin(); 
 	    p != _info.descriptor->adapters.end(); ++p)
 	{
-	    if(!p->id.empty() && p->waitForActivation && _activeAdapters.find(p->id) == _activeAdapters.end())
+	    if(!p->id.empty() && p->waitForActivation && _activatedAdapters.find(p->id) == _activatedAdapters.end())
 	    {
 		return;
 	    }
@@ -2049,7 +2049,9 @@ ServerI::checkActivation()
 		ServiceDescriptorPtr desc = ServiceDescriptorPtr::dynamicCast(s->descriptor);
 		for(AdapterDescriptorSeq::const_iterator p = desc->adapters.begin(); p != desc->adapters.end(); ++p)
 		{
-		    if(!p->id.empty() && p->waitForActivation && _activeAdapters.find(p->id) == _activeAdapters.end())
+		    if(!p->id.empty() && 
+		       p->waitForActivation && 
+		       _activatedAdapters.find(p->id) == _activatedAdapters.end())
 		    {
 			return;
 		    }
diff --git a/cpp/src/IceGrid/ServerI.h b/cpp/src/IceGrid/ServerI.h
index 6dd59dcb2b3..6e787642da4 100644
--- a/cpp/src/IceGrid/ServerI.h
+++ b/cpp/src/IceGrid/ServerI.h
@@ -95,7 +95,6 @@ public:
     void finishPatch();
 
     void adapterActivated(const std::string&);
-    void adapterDeactivated(const std::string&);
     void activationFailed(bool);
     void deactivationFailed();
 
@@ -148,7 +147,7 @@ private:
     ServerAdapterDict _adapters;
     bool _processRegistered;
     Ice::ProcessPrx _process;
-    std::set<std::string> _activeAdapters;
+    std::set<std::string> _activatedAdapters;
     IceUtil::Time _failureTime;
     ServerActivation _previousActivation;
     WaitItemPtr _timer;