shared-state: multiwriter use counter based merge strategy

Replace the timestamp merge strategy that has many issues on the field
with a counter + a random number merge strategy.

Author: spiccinini

packages/shared-state/files/usr/lib/lua/shared-state.lua

@@ -301,14 +301,16 @@ function SharedStateMultiWriter:new(dataType, logger)
 	return newInstance
 end
 
+
 function SharedStateMultiWriter:_merge(stateSlice)
-	-- Make merge based on timestamp
+	--! Make merge based on an incremental counter (changes) and a random number (fortune)
 	local stateSlice = stateSlice or {}
 	for key,rv in pairs(stateSlice) do
 		local lv = self.storage[key]
-		if ( lv == nil or lv.lastModified < rv.lastModified ) then
+		if ( lv == nil or lv.changes < rv.changes or
+			 ( lv.changes == rv.changes and lv.fortune < rv.fortune )) then
 			self.log( "debug", "Updating entry for: "..key.." older: "..
-					  (lv and lv.lastModified or 'no entry') .." newer: "..rv.lastModified )
+					  (lv and lv.changes or 'no entry') .." newer: "..rv.changes )
 			self.storage[key] = rv
 			self.changed = true
 		end
@@ -324,11 +326,18 @@ function SharedStateMultiWriter:insert(data)
 	self:notifyHooks()
 end
 
+function shared_state._getFortune()
+	return math.random(1, 100000)
+end
+
 function SharedStateMultiWriter:_insert(key, data)
 	local lv = self.storage[key]
 	if (lv == nil or not utils.deepcompare(lv.data, data)) then
+		local changes = lv and lv.changes + 1 or 0
 		self.storage[key] = {
 			lastModified=os.time(),
+			changes=changes,
+			fortune=shared_state._getFortune(),
 			author=io.input("/proc/sys/kernel/hostname"):read("*line"),
 			data=data
 		}

packages/shared-state/tests/test_shared_state.lua

@@ -126,13 +126,50 @@ describe('Shared State MultiWriter tests #sharedstatemultiwriter', function()
     after_each('', function()
         test_utils.teardown_test_dir()
     end)
-    
-    it('test merge data from remote db with newer timestamp', function()
+
+    it('test insert new data', function()
+        local ss = shared_state.SharedStateMultiWriter:new('foo')
+        local sharedStateB = shared_state.SharedStateMultiWriter:new('B')
+        stub(shared_state, "_getFortune", function () return 100 end)
+        ss:insert({ bar = '123'})
+        local db = ss:get()
+        assert.is.equal('123', db.bar.data)
+        assert.is.equal(0, db.bar.changes)
+        assert.is.equal(100, db.bar.fortune)
+    end)
+
+    it('test merge data from remote db with more changes (newer)', function()
+        local sharedStateA = shared_state.SharedStateMultiWriter:new('A')
+        local sharedStateB = shared_state.SharedStateMultiWriter:new('B')
+        sharedStateA:insert({ bar = 'foo', baz = 'qux', zig = 'old_zag'})
+        sharedStateB:insert({ zig = 'new_zag'})
+        sharedStateB:insert({ zig = 'newer_zag'})
+        sharedStateA:merge(sharedStateB:get())
+        local dbA = sharedStateA:get()
+        assert.is.equal('foo', dbA.bar.data)
+        assert.is.equal('qux', dbA.baz.data)
+        assert.is.equal('newer_zag', dbA.zig.data)
+    end)
+
+    it('test merge data from remote db with less changes (older)', function()
+        local sharedStateA = shared_state.SharedStateMultiWriter:new('A')
+        local sharedStateB = shared_state.SharedStateMultiWriter:new('B')
+        sharedStateA:insert({ bar = 'foo', baz = 'qux', zig = 'zag'})
+        sharedStateA:insert({ zig = 'new_zag'})
+        sharedStateB:insert({ zig = 'old_zag'})
+        sharedStateA:merge(sharedStateB:get())
+        local dbA = sharedStateA:get()
+        assert.is.equal('foo', dbA.bar.data)
+        assert.is.equal('qux', dbA.baz.data)
+        assert.is.equal('new_zag', dbA.zig.data)
+    end)
+
+    it('test merge data from remote db with same changes but more luck', function()
         local sharedStateA = shared_state.SharedStateMultiWriter:new('A')
         local sharedStateB = shared_state.SharedStateMultiWriter:new('B')
-        stub(os, "time", function () return 1616095000 end)
+        stub(shared_state, "_getFortune", function () return 100 end)
         sharedStateA:insert({ bar = 'foo', baz = 'qux', zig = 'old_zag'})
-        stub(os, "time", function () return 1616096000 end)
+        stub(shared_state, "_getFortune", function () return 1000 end)
         sharedStateB:insert({ zig = 'new_zag'})
         sharedStateA:merge(sharedStateB:get())
         local dbA = sharedStateA:get()
@@ -141,12 +178,12 @@ describe('Shared State MultiWriter tests #sharedstatemultiwriter', function()
         assert.is.equal('new_zag', dbA.zig.data)
     end)
 
-    it('test merge data from remote db with older timestamp', function()
+    it('test merge data from remote db with same changes but less luck', function()
         local sharedStateA = shared_state.SharedStateMultiWriter:new('A')
         local sharedStateB = shared_state.SharedStateMultiWriter:new('B')
-        stub(os, "time", function () return 1616096000 end)
+        stub(shared_state, "_getFortune", function () return 1000 end)
         sharedStateA:insert({ bar = 'foo', baz = 'qux', zig = 'new_zag'})
-        stub(os, "time", function () return 1616095000 end)
+        stub(shared_state, "_getFortune", function () return 100 end)
         sharedStateB:insert({ zig = 'old_zag'})
         sharedStateA:merge(sharedStateB:get())
         local dbA = sharedStateA:get()