def _notifyOfTupleUpdateInMainOne(self, tupleSelector: TupleSelector):
tsStr = tupleSelector.toJsonStr()
if tsStr not in self._observerDataByTupleSelector:
return
# Filter out the offline observables
onlineUuids = set(VortexFactory.getRemoteVortexUuids())
observers = self._observerDataByTupleSelector[tsStr].observers
for od in list(observers):
if od.vortexUuid not in onlineUuids:
observers.remove(od)
# Get / update the list of observing UUIDs
if not observers:
del self._observerDataByTupleSelector[tsStr]
return
# Create the vortexMsg
filt = dict(tupleSelector=tupleSelector)
filt.update(self._filt)
vortexMsg = yield self._createVortexMsg(filt, tupleSelector)
# We can have multiple Observable clients on the one vortex, so make sure
# we only send one message for these.
destVortexUuids = set([od.vortexUuid for od in observers])
# Send the vortex messages
for destVortexUuid in destVortexUuids:
d = VortexFactory.sendVortexMsg(vortexMsgs=vortexMsg,
destVortexUuid=destVortexUuid)
d.addErrback(vortexLogFailure, logger)
def makeVortexMsg(self, filt: dict, tupleSelector: TupleSelector) -> Deferred:
# Uncomment this to print the SQL being created
#
# criterias = tupleSelector..get('criteria', [])
# newestDateTime = tupleSelector..get('newestDateTime')
# oldestDateTime = tupleSelector..get('oldestDateTime')
#
# sql = self._makeSql(criterias, 0, newestDateTime, oldestDateTime)
# logger.info(sql)
logger.debug(tupleSelector.toJsonStr())
return (yield runPyInPg(logger,
self._dbSessionCreator,
self._loadInPg,
self._importTuples,
filt=filt,
tupleSelectorStr=tupleSelector.toJsonStr())).encode()
def _makeCache(self,
tupleSelector: TupleSelector) -> _CachedSubscribedData:
tsStr = tupleSelector.toJsonStr()
if tsStr in self.__cache:
return self.__cache[tsStr]
cache = _CachedSubscribedData(tupleSelector)
self.__cache[tsStr] = cache
return cache
def _getMappedTupleSelectors(
self, tupleSelector: TupleSelector) -> List[TupleSelector]:
# Get all tuple selectors
allTupleSelectors = [
data.tupleSelector
for data in self._observerDataByTupleSelector.values()
]
# Create a dict so we end up with only unique ones
tupleSelectorByStr = {tupleSelector.toJsonStr(): tupleSelector}
# Run through the mappers
for mapper in self._tupleSelectorUpdateMappers:
mappedSelectors = mapper.mapTupleSelector(tupleSelector,
allTupleSelectors)
if mappedSelectors:
tupleSelectorByStr.update(
{ts.toJsonStr(): ts
for ts in mappedSelectors})
# Return a list of tuple selectors
return list(tupleSelectorByStr.values())
def hasTupleSubscribers(self, tupleSelector: TupleSelector):
return tupleSelector.toJsonStr() in self._observerDataByTupleSelector
def _hasTupleSelector(self, tupleSelectorAny: TupleSelector) -> bool:
return tupleSelectorAny.toJsonStr() in self.__cache
def _getCache(
self,
tupleSelector: TupleSelector) -> Optional[_CachedSubscribedData]:
return self.__cache.get(tupleSelector.toJsonStr())