Change load API.

Use {caller|callee}_{usr|peer}_load().
peer_load just copies peer prefs to real prefs.

ngcp/ngcp.lua

@@ -57,34 +57,44 @@ NGCP_MT = { __index = NGCP }
         return t
     end
 
-    function NGCP:caller_load(uuid, domain, peer)
+    function NGCP:caller_peer_load(peer)
+        local keys = self.prefs.peer:caller_load(peer)
+        self.prefs.real:caller_usr_load(keys)
+        return keys
+    end
+
+    function NGCP:callee_peer_load(peer)
+        local keys = self.prefs.peer:callee_load(peer)
+        self.prefs.real:callee_peer_load(keys)
+        return keys
+    end
+
+    function NGCP:caller_usr_load(uuid, domain)
         local keys = {
             domain = self.prefs.dom:caller_load(domain),
-            user   = self.prefs.usr:caller_load(uuid),
-            peer   = self.prefs.peer:caller_load(peer)
+            user   = self.prefs.usr:caller_load(uuid)
         }
         local unique_keys = table.deepcopy(keys.domain)
         local _,v
         for _,v in pairs(keys.user) do
             table.add(unique_keys, v)
         end
-        self.prefs.real:caller_load(unique_keys)
-        return {real = unique_keys, peer = keys.peer}
+        self.prefs.real:caller_usr_load(unique_keys)
+        return unique_keys
     end
 
-    function NGCP:callee_load(uuid, domain, peer)
+    function NGCP:callee_usr_load(uuid, domain)
         local keys = {
             domain = self.prefs.dom:callee_load(domain),
-            user   = self.prefs.usr:callee_load(uuid),
-            peer   = self.prefs.peer:caller_load(peer)
+            user   = self.prefs.usr:callee_load(uuid)
         }
         local unique_keys = table.deepcopy(keys.domain)
         local _,v
         for _,v in pairs(keys.user) do
             table.add(unique_keys, v)
         end
-        self.prefs.real:callee_load(unique_keys)
-        return {real = unique_keys, peer = keys.peer}
+        self.prefs.real:callee_usr_load(unique_keys)
+        return unique_keys
     end
 
     function NGCP:clean(vtype, group)

ngcp/rp.lua

@@ -13,15 +13,44 @@ NGCPRealPrefs_MT = { __index = NGCPRealPrefs }
         return setmetatable( t, NGCPRealPrefs_MT )
     end
 
-    function NGCPRealPrefs:caller_load(keys)
-        return NGCPRealPrefs:_load("caller", keys)
+    function NGCPRealPrefs:caller_peer_load(keys)
+        return NGCPRealPrefs:_peer_load("caller", keys)
     end
 
-    function NGCPRealPrefs:callee_load(keys)
-        return NGCPRealPrefs:_load("callee", keys)
+    function NGCPRealPrefs:callee_peer_load(keys)
+        return NGCPRealPrefs:_peer_load("callee", keys)
     end
 
-    function NGCPRealPrefs:_load(level, keys)
+    function NGCPRealPrefs:caller_usr_load(keys)
+        return NGCPRealPrefs:_usr_load("caller", keys)
+    end
+
+    function NGCPRealPrefs:callee_usr_load(keys)
+        return NGCPRealPrefs:_usr_load("callee", keys)
+    end
+
+    function NGCPRealPrefs:_peer_load(level, keys)
+        local _,v
+        local xavp = {
+            real = NGCPRealPrefs:xavp(level),
+            peer  = NGCPPeerPrefs:xavp(level),
+        }
+        local real_keys = {}
+        local value
+        for _,v in pairs(keys) do
+            value = xavp.peer(v)
+            if value then
+                table.add(real_keys, v)
+                --sr.log("info", string.format("key:%s value:%s", v, value))
+                xavp.real(v, value)
+            else
+                sr.log("err", string.format("key:%s not in user or domain", v))
+            end
+        end
+        return real_keys
+    end
+
+    function NGCPRealPrefs:_usr_load(level, keys)
         local _,v
         local xavp = {
             real = NGCPRealPrefs:xavp(level),

tests/ngcp.lua

@@ -64,12 +64,20 @@ TestNGCP = {} --class
         assertTrue(self.ngcp.prefs.real)
     end
 
-    function TestNGCP:test_load_caller()
-        assertEquals(self.ngcp:caller_load(), {real={}, peer={}})
+    function TestNGCP:test_caller_usr_load_empty()
+        assertEquals(self.ngcp:caller_usr_load(), {})
     end
 
-    function TestNGCP:test_load_callee()
-        assertEquals(self.ngcp:callee_load(), {real={}, peer={}})
+    function TestNGCP:test_callee_usr_load_empty()
+        assertEquals(self.ngcp:callee_usr_load(), {})
+    end
+
+    function TestNGCP:test_caller_peer_load_empty()
+        assertEquals(self.ngcp:caller_peer_load(), {})
+    end
+
+    function TestNGCP:test_callee_peer_load_empty()
+        assertEquals(self.ngcp:callee_peer_load(), {})
     end
 
     function TestNGCP:test_clean()

tests/ngcp_rp.lua

@@ -65,23 +65,41 @@ TestNGCPRealPrefs = {} --class
         assertError(self.real.callee_load, nil)
     end
 
-    function TestNGCPRealPrefs:test_caller_load()
+    function TestNGCPRealPrefs:test_caller_peer_load()
         local keys = {"uno"}
         local xavp = {
             domain  = NGCPDomainPrefs:xavp("caller"),
             user    = NGCPUserPrefs:xavp("caller"),
+            peer    = NGCPPeerPrefs:xavp("caller"),
             real    = NGCPRealPrefs:xavp("caller")
         }
         xavp.domain("uno",1)
         assertEquals(sr.pv.get("$xavp(caller_dom_prefs=>uno)"),1)
         xavp.user("uno",2)
         assertEquals(sr.pv.get("$xavp(caller_usr_prefs=>uno)"),2)
-        local real_keys = self.real:caller_load(keys)
+        xavp.peer("uno",3)
+        local real_keys = self.real:caller_peer_load(keys)
+        assertEquals(real_keys, keys)
+        assertEquals(xavp.real("uno"),3)
+    end
+
+    function TestNGCPRealPrefs:test_caller_usr_load()
+        local keys = {"uno"}
+        local xavp = {
+            domain  = NGCPDomainPrefs:xavp("caller"),
+            user    = NGCPUserPrefs:xavp("caller"),
+            real    = NGCPRealPrefs:xavp("caller")
+        }
+        xavp.domain("uno",1)
+        assertEquals(sr.pv.get("$xavp(caller_dom_prefs=>uno)"),1)
+        xavp.user("uno",2)
+        assertEquals(sr.pv.get("$xavp(caller_usr_prefs=>uno)"),2)
+        local real_keys = self.real:caller_usr_load(keys)
         assertEquals(real_keys, keys)
         assertEquals(xavp.real("uno"),2)
     end
 
-    function TestNGCPRealPrefs:test_caller_load1()
+    function TestNGCPRealPrefs:test_caller_usr_load1()
         local keys = {"uno", "dos"}
         local xavp = {
             domain  = NGCPDomainPrefs:xavp("caller"),
@@ -92,13 +110,13 @@ TestNGCPRealPrefs = {} --class
         assertEquals(sr.pv.get("$xavp(caller_dom_prefs=>uno)"),1)
         xavp.user("dos",2)
         assertEquals(sr.pv.get("$xavp(caller_usr_prefs=>dos)"),2)
-        local real_keys = self.real:caller_load(keys)
+        local real_keys = self.real:caller_usr_load(keys)
         assertEquals(real_keys, keys)
         assertEquals(xavp.real("uno"),1)
         assertEquals(xavp.real("dos"),2)
     end
 
-    function TestNGCPRealPrefs:test_callee_load()
+    function TestNGCPRealPrefs:test_callee_usr_load()
         local keys = {"uno"}
         local xavp = {
             domain  = NGCPDomainPrefs:xavp("callee"),
@@ -109,12 +127,12 @@ TestNGCPRealPrefs = {} --class
         assertEquals(sr.pv.get("$xavp(callee_dom_prefs=>uno)"),1)
         xavp.user("uno",2)
         assertEquals(sr.pv.get("$xavp(callee_usr_prefs=>uno)"),2)
-        local real_keys = self.real:callee_load(keys)
+        local real_keys = self.real:callee_usr_load(keys)
         assertEquals(real_keys, keys)
         assertEquals(xavp.real("uno"),2)
     end
 
-    function TestNGCPRealPrefs:test_callee_load1()
+    function TestNGCPRealPrefs:test_callee_usr_load1()
         local keys = {"uno", "dos"}
         local xavp = {
             domain  = NGCPDomainPrefs:xavp("callee"),
@@ -125,7 +143,7 @@ TestNGCPRealPrefs = {} --class
         assertEquals(sr.pv.get("$xavp(callee_dom_prefs=>uno)"),1)
         xavp.user("dos",2)
         assertEquals(sr.pv.get("$xavp(callee_usr_prefs=>dos)"),2)
-        local real_keys = self.real:callee_load(keys)
+        local real_keys = self.real:callee_usr_load(keys)
         assertEquals(real_keys, keys)
         assertEquals(xavp.real("uno"),1)
         assertEquals(xavp.real("dos"),2)