def test_basic_listener(self):
v1 = self.harness.newView()
v2 = self.harness.newView()
while not v1.waitConnectTimeout(.1):
pass
while not v2.waitConnectTimeout(.1):
pass
l = SharedState.Listener(v1)
v1.subscribe(
SharedState.KeyRange(_testKeyspace, 0, None, None, True, True),
True)
v2.subscribe(
SharedState.KeyRange(_testKeyspace, 0, None, None, True, True),
True)
self.assertIsInstance(l.get()[0][1],
SharedState.SharedStateNative.KeyRange)
self.assertTrue(len(l.get(.1)) == 0)
self.assertTrue(len(l.getNonblock()) == 0)
testKey = SharedState.Key(_testKeyspace, (NativeJson.Json('test'), ))
with SharedState.Transaction(v2):
v2[testKey] = NativeJson.Json('test2')
v2.flush()
v1.flush()
updates = l.get(1)
self.assertTrue(len(updates) == 1)
self.assertEqual(updates[0][0], "KeyUpdates")
self.assertIsInstance(updates[0][1], list)
self.assertTrue(updates[0][1][0] == testKey)
with SharedState.Transaction(v2):
v2[testKey] = NativeJson.Json('newer test')
v2.flush()
v1.flush()
updates = l.get(1)
self.assertTrue(len(updates) == 1)
self.assertEqual(updates[0][0], "KeyUpdates")
self.assertIsInstance(updates[0][1], list)
self.assertTrue(updates[0][1][0] == testKey)
def test_listener(self):
harness = self.getHarness(inMemory=True)
try:
v1 = harness.newView()
v2 = harness.newView()
l = SharedState.Listener(v2)
space = SharedState.Keyspace("ComparisonKeyType",
NativeJson.Json("TestSpace"), 1)
rng = SharedState.KeyRange(space, 0, None, None, True, False)
v1.subscribe(rng)
v2.subscribe(rng)
keysToWrite = [JsonNative.Json(str(x)) for x in range(40)]
def writer():
with SharedState.Transaction(v1):
for keyName in keysToWrite:
key = SharedState.Key(space, (keyName, ))
v1[key] = JsonNative.Json("value")
changedKeys = []
def reader():
while len(changedKeys) < len(keysToWrite):
updates = l.get()
for updateType, update in updates:
if updateType == "KeyUpdates":
for key in update:
changedKeys.append(key[0])
writerThread = threading.Thread(target=writer)
readerThread = threading.Thread(target=reader)
writerThread.start()
readerThread.start()
writerThread.join()
readerThread.join()
self.assertEqual(set(keysToWrite), set(changedKeys))
finally:
time.sleep(0.01)
harness.teardown()
def test_shared_state_disconnect_idle_client(self):
try:
def createFilteredChannelFactory(callbackScheduler, manager):
return FilteredChannelFactory.FilteredChannelFactory(
callbackScheduler, manager, self.filterMinId)
harness = SharedStateTestHarness.SharedStateTestHarness(
True, inMemChannelFactoryFactory=createFilteredChannelFactory)
view = harness.viewFactory.createView()
view.waitConnect()
listener = SharedState.Listener(view)
time.sleep(SharedStateTestHarness.IN_MEMORY_HARNESS_PING_INTERVAL +
1.0)
listener.get()
self.assertFalse(listener.isConnected)
finally:
view.teardown()
harness.teardown()
def test_add_transaction(self):
try:
toWrite = {
NativeJson.Json(str(x)): NativeJson.Json('value-%s' % x)
for x in range(50)
}
simpleView = None
def onConnect(_):
def callback(value):
for key, value in toWrite.iteritems():
key = SharedState.Key(self.testKeyspace, (key,))
simpleView.pushTransaction(key, value)
deferred = simpleView.subscribeToKeyspace(self.testKeyspace, 0, callback)
deferred.addCallbacks(callback, lambda value: None)
simpleView = AsyncView.AsyncView(self.harness.viewFactory,
onConnectCallback=onConnect)
simpleView.startService()
v1 = self.harness.newView()
listener = SharedState.Listener(v1)
self.subscribeToTestKeyspace(v1)
toCheck = dict(toWrite)
while len(toCheck):
updates = listener.get()
for updateType, update in updates:
if updateType == "KeyUpdates":
for key in update:
if key[0] in toCheck:
with SharedState.Transaction(v1):
self.assertEqual(toCheck[key[0]], v1[key].value())
del toCheck[key[0]]
finally:
if simpleView:
simpleView.stopService()
self.harness.teardown()
def __init__(self,
viewFactory,
onConnectCallback=lambda result: None,
onErrorCallback=lambda error: None):
self._stopFlag = threading.Event()
self._onConnectCallback = onConnectCallback
self._onErrorCallback = onErrorCallback
self._view = viewFactory.createView(retrySeconds=10.0, numRetries=10)
self._listener = SharedState.Listener(self._view)
self._subscribedKeyspaces = set()
self._keyspaceCallbackFunctions = {}
self._subscriptionDeferreds = {}
self._reactorThreadCalls = Queue.Queue()
self._viewReactorThread = ManagedThread.ManagedThread(
target=self._viewReactorLoop)
def attachView(self, view):
self.view_ = view
self.listener_ = SharedState.Listener(view)
