QPID-529: Added aliases for arguments that are more uniform with others in c++ broker

git-svn-id: https://svn.apache.org/repos/asf/qpid/trunk@1076207 13f79535-47bb-0310-9956-ffa450edef68

3 files changed, 69 insertions, 33 deletions

diff --git a/qpid/cpp/src/qpid/broker/Fairshare.cpp b/qpid/cpp/src/qpid/broker/Fairshare.cpp
index e6bbf86691..17270ffd8d 100644
--- a/qpid/cpp/src/qpid/broker/Fairshare.cpp
+++ b/qpid/cpp/src/qpid/broker/Fairshare.cpp
@@ -24,6 +24,7 @@
 #include "qpid/log/Statement.h"
 #include <boost/format.hpp>
 #include <boost/lexical_cast.hpp>
+#include <boost/assign/list_of.hpp>
 
 namespace qpid {
 namespace broker {
@@ -104,51 +105,80 @@ bool Fairshare::setState(Messages& m, uint priority, uint count)
     return fairshare && fairshare->setState(priority, count);
 }
 
-int getIntegerSetting(const qpid::framing::FieldTable& settings, const std::string& key)
+int getIntegerSetting(const qpid::framing::FieldTable& settings, const std::vector<std::string>& keys)
 {
-    qpid::framing::FieldTable::ValuePtr v = settings.get(key);
+    qpid::framing::FieldTable::ValuePtr v;
+    std::vector<std::string>::const_iterator i = keys.begin(); 
+    while (!v && i != keys.end()) {
+        v = settings.get(*i++);
+    }
+
     if (!v) {
         return 0;
     } else if (v->convertsTo<int>()) {
         return v->get<int>();
     } else if (v->convertsTo<std::string>()){
         std::string s = v->get<std::string>();
-        try { 
-            return boost::lexical_cast<int>(s); 
+        try {
+            return boost::lexical_cast<int>(s);
         } catch(const boost::bad_lexical_cast&) {
-            QPID_LOG(warning, "Ignoring invalid integer value for " << key << ": " << s);
+            QPID_LOG(warning, "Ignoring invalid integer value for " << *i << ": " << s);
             return 0;
         }
     } else {
-        QPID_LOG(warning, "Ignoring invalid integer value for " << key << ": " << *v);
+        QPID_LOG(warning, "Ignoring invalid integer value for " << *i << ": " << *v);
         return 0;
     }
 }
 
-int getSetting(const qpid::framing::FieldTable& settings, const std::string& key, int minvalue, int maxvalue)
+int getIntegerSettingForKey(const qpid::framing::FieldTable& settings, const std::string& key)
+{
+    return getIntegerSetting(settings, boost::assign::list_of<std::string>(key));
+}
+
+int getSetting(const qpid::framing::FieldTable& settings, const std::vector<std::string>& keys, int minvalue, int maxvalue)
+{
+    return std::max(minvalue,std::min(getIntegerSetting(settings, keys), maxvalue));
+}
+
+std::auto_ptr<Fairshare> getFairshareForKey(const qpid::framing::FieldTable& settings, uint levels, const std::string& key)
+{
+    uint defaultLimit = getIntegerSettingForKey(settings, key);
+    std::auto_ptr<Fairshare> fairshare(new Fairshare(levels, defaultLimit));
+    for (uint i = 0; i < levels; i++) {
+        std::string levelKey = (boost::format("%1%-%2%") % key % i).str();
+        if(settings.isSet(levelKey)) {
+            fairshare->setLimit(i, getIntegerSettingForKey(settings, levelKey));
+        }
+    }
+    if (!fairshare->isNull()) {
+        return fairshare;
+    } else {
+        return std::auto_ptr<Fairshare>();
+    }
+}
+
+std::auto_ptr<Fairshare> getFairshare(const qpid::framing::FieldTable& settings,
+                                      uint levels,
+                                      const std::vector<std::string>& keys)
 {
-    return std::max(minvalue,std::min(getIntegerSetting(settings, key), maxvalue));
+    std::auto_ptr<Fairshare> fairshare;
+    for (std::vector<std::string>::const_iterator i = keys.begin(); i != keys.end() && !fairshare.get(); ++i) {
+        fairshare = getFairshareForKey(settings, levels, *i);
+    }
+    return fairshare;
 }
 
 std::auto_ptr<Messages> Fairshare::create(const qpid::framing::FieldTable& settings)
 {
+    using boost::assign::list_of;
     std::auto_ptr<Messages> result;
-    size_t levels = getSetting(settings, "x-qpid-priorities", 1, 100);
+    size_t levels = getSetting(settings, list_of<std::string>("qpid.priorities")("x-qpid-priorities"), 1, 100);
     if (levels) {
-        uint defaultLimit = getIntegerSetting(settings, "x-qpid-fairshare");
-        std::auto_ptr<Fairshare> fairshare(new Fairshare(levels, defaultLimit));
-        for (uint i = 0; i < levels; i++) {
-            std::string key = (boost::format("x-qpid-fairshare-%1%") % i).str();
-            if(settings.isSet(key)) {
-                fairshare->setLimit(i, getIntegerSetting(settings, key));
-            }
-        }
-        
-        if (fairshare->isNull()) {
-            result = std::auto_ptr<Messages>(new PriorityQueue(levels));
-        } else {
-            result = fairshare;
-        }
+        std::auto_ptr<Fairshare> fairshare =
+            getFairshare(settings, levels, list_of<std::string>("qpid.fairshare")("x-qpid-fairshare"));
+        if (fairshare.get()) result = fairshare;
+        else result = std::auto_ptr<Messages>(new PriorityQueue(levels));
     }
     return result;
 }
diff --git a/qpid/cpp/src/qpid/broker/Fairshare.h b/qpid/cpp/src/qpid/broker/Fairshare.h
index 6c4b87f857..1b25721e0c 100644
--- a/qpid/cpp/src/qpid/broker/Fairshare.h
+++ b/qpid/cpp/src/qpid/broker/Fairshare.h
@@ -41,18 +41,18 @@ class Fairshare : public PriorityQueue
     bool getState(uint& priority, uint& count) const;
     bool setState(uint priority, uint count);
     void setLimit(size_t level, uint limit);
+    bool isNull();
     static std::auto_ptr<Messages> create(const qpid::framing::FieldTable& settings);
     static bool getState(const Messages&, uint& priority, uint& count);
     static bool setState(Messages&, uint priority, uint count);
   private:
     std::vector<uint> limits;
-    
+
     uint priority;
     uint count;
-    
+
     uint currentLevel();
     uint nextLevel();
-    bool isNull();
     bool limitReached();
     bool findFrontLevel(uint& p, PriorityLevels&);
 };
diff --git a/qpid/tests/src/py/qpid_tests/broker_0_10/priority.py b/qpid/tests/src/py/qpid_tests/broker_0_10/priority.py
index 3651a1218b..6a60add97e 100644
--- a/qpid/tests/src/py/qpid_tests/broker_0_10/priority.py
+++ b/qpid/tests/src/py/qpid_tests/broker_0_10/priority.py
@@ -33,13 +33,13 @@ class PriorityTests (Base):
     def setup_session(self):
         return self.conn.session()
 
-    def prioritised_delivery(self, priorities, levels=10):
+    def prioritised_delivery(self, priorities, levels=10, key="x-qpid-priorities"):
         """
         Test that message on a queue are delivered in priority order.
         """
         msgs = [Message(content=str(uuid4()), priority = p) for p in priorities]
 
-        snd = self.ssn.sender("priority-queue; {create: sender, delete: receiver, node: {x-declare:{arguments:{x-qpid-priorities:%s}}}}" % levels,
+        snd = self.ssn.sender("priority-queue; {create: sender, delete: receiver, node: {x-declare:{arguments:{'%s':%s}}}}" % (key, levels),
                               durable=self.durable())
         for m in msgs: snd.send(m)
 
@@ -50,16 +50,16 @@ class PriorityTests (Base):
             assert msg.content == expected.content
             self.ssn.acknowledge(msg)
 
-    def fairshare_delivery(self, priorities, default_limit=5, limits=None, levels=10):
+    def fairshare_delivery(self, priorities, default_limit=5, limits=None, levels=10, level_key="x-qpid-priorities", fairshare_key="x-qpid-fairshare"):
         msgs = [Message(content=str(uuid4()), priority = p) for p in priorities]
 
-        limit_policy = "x-qpid-fairshare:%s" % default_limit
+        limit_policy = "'%s':%s" % (fairshare_key, default_limit)
         if limits:
             for k, v in limits.items():
-                limit_policy += ", x-qpid-fairshare-%s:%s" % (k, v)
+                limit_policy += ", '%s-%s':%s" % (fairshare_key, k, v)
 
-        snd = self.ssn.sender("priority-queue; {create: sender, delete: receiver, node: {x-declare:{arguments:{x-qpid-priorities:%s, %s}}}}"
-                              % (levels, limit_policy),
+        snd = self.ssn.sender("priority-queue; {create: sender, delete: receiver, node: {x-declare:{arguments:{'%s':%s, %s}}}}"
+                              % (level_key, levels, limit_policy),
                               durable=self.durable())
         for m in msgs: snd.send(m)
 
@@ -79,12 +79,18 @@ class PriorityTests (Base):
     def test_prioritised_delivery_1(self):
         self.prioritised_delivery(priorities = [8,9,5,1,2,2,3,4,15,7,8,10,10,2], levels = 10)
 
+    def test_prioritised_delivery_with_alias(self):
+        self.prioritised_delivery(priorities = [8,9,5,1,2,2,3,4,15,7,8,10,10,2], levels = 10, key="qpid.priorities")
+
     def test_prioritised_delivery_2(self):
         self.prioritised_delivery(priorities = [8,9,5,1,2,2,3,4,15,7,8,10,10,2], levels = 5)
 
     def test_fairshare_1(self):
         self.fairshare_delivery(priorities = [4,5,3,6,10,10,2,10,2,10,10,1,10,10,10,3,3,3,10,10,3,10,3,10,10,10,10,10,10,2,3])
 
+    def test_fairshare_with_alias(self):
+        self.fairshare_delivery(priorities = [4,5,3,6,10,10,2,10,2,10,10,1,10,10,10,3,3,3,10,10,2,3], level_key="qpid.priorities", fairshare_key="qpid.fairshare")
+
     def test_fairshare_2(self):
         self.fairshare_delivery(priorities = [10 for i in range(30)])