def start(self):
""" Starts to collect windows data. First invokes next operation:
- loads mask of stored targets.
- loads windows data.
"""
if self.__isStarted:
return
self.__isStarted = True
self.__loader = WindowsStoredDataLoader(STORED_DATA_REV, STORED_DATA_MAX_LENGTH, DEF_TARGET_MASK)
mask, records = self.__loader.load()
mask |= TARGET_ID.CHAT_MANAGEMENT
mask |= TARGET_ID.CHANNEL_CAROUSEL
self.__targetMask = mask & TARGET_ID.ALL
for record in records:
if len(record) < 2:
LOG_ERROR('Invalid record', record)
continue
targetID, dataType = record[:2]
if not targetID & TARGET_ID.ALL:
LOG_ERROR('Invalid target ID', record)
continue
if not self.isTargetEnabled(targetID):
LOG_WARNING('Target is not enabled. Records are ignored to load', self.__targetMask, record)
continue
if dataType not in DATA_TYPE.RANGE:
LOG_ERROR('Invalid data type', record)
continue
if dataType not in self.__supported:
LOG_ERROR('Data type is not supported', dataType)
continue
try:
self.__storedData[targetID].append(self.__supported[dataType](*record[2:]))
except TypeError:
LOG_ERROR('Invalid record', record)
def start(self):
if self.__isStarted:
return
self.__isStarted = True
self.__loader = WindowsStoredDataLoader(STORED_DATA_REV,
STORED_DATA_MAX_LENGTH,
DEF_TARGET_MASK)
mask, records = self.__loader.load()
mask |= TARGET_ID.CHAT_MANAGEMENT
mask |= TARGET_ID.CHANNEL_CAROUSEL
self.__targetMask = mask & TARGET_ID.ALL
for record in records:
if len(record) < 2:
_logger.error('Invalid record: %r', record)
continue
targetID, dataType = record[:2]
if not targetID & TARGET_ID.ALL:
_logger.error('Invalid target ID: %r', record)
continue
if not self.isTargetEnabled(targetID):
_logger.warning(
'Target is not enabled. Records are ignored to load: %r, %r',
self.__targetMask, record)
continue
if dataType not in DATA_TYPE.RANGE:
_logger.error('Invalid data type: %r', record)
continue
if dataType not in self.__supported:
_logger.error('Data type is not supported: %r', dataType)
continue
try:
self.__storedData[targetID].append(
self.__supported[dataType](*record[2:]))
except TypeError:
_logger.error('Invalid record: %r', record)
def start(self):
if self.__isStarted:
return
self.__isStarted = True
self.__loader = WindowsStoredDataLoader(STORED_DATA_REV,
STORED_DATA_MAX_LENGTH,
DEF_TARGET_MASK)
mask, records = self.__loader.load()
self.__targetMask = mask & TARGET_ID.ALL
for record in records:
if len(record) < 2:
LOG_ERROR('Invalid record', record)
continue
targetID, dataType = record[:2]
if not targetID & TARGET_ID.ALL:
LOG_ERROR('Invalid target ID', record)
continue
if not self.isTargetEnabled(targetID):
LOG_WARNING(
'Target is not enabled. Records are ignored to load',
self.__targetMask, record)
continue
if dataType not in DATA_TYPE.RANGE:
LOG_ERROR('Invalid data type', record)
continue
if dataType not in self.__supported:
LOG_ERROR('Data type is not supported', dataType)
continue
try:
self.__storedData[targetID].append(
self.__supported[dataType](*record[2:]))
except TypeError:
LOG_ERROR('Invalid record', record)
def start(self):
if self.__isStarted:
return
self.__isStarted = True
self.__loader = WindowsStoredDataLoader(STORED_DATA_REV, STORED_DATA_MAX_LENGTH, DEF_TARGET_MASK)
mask, records = self.__loader.load()
self.__targetMask = mask & TARGET_ID.ALL
for record in records:
if len(record) < 2:
LOG_ERROR('Invalid record', record)
continue
targetID, dataType = record[:2]
if not targetID & TARGET_ID.ALL:
LOG_ERROR('Invalid target ID', record)
continue
if not self.isTargetEnabled(targetID):
LOG_WARNING('Target is not enabled. Records are ignored to load', self.__targetMask, record)
continue
if dataType not in DATA_TYPE.RANGE:
LOG_ERROR('Invalid data type', record)
continue
if dataType not in self.__supported:
LOG_ERROR('Data type is not supported', dataType)
continue
try:
self.__storedData[targetID].append(self.__supported[dataType](*record[2:]))
except TypeError:
LOG_ERROR('Invalid record', record)
class _WindowsStoredDataManager(object):
def __init__(self, supported):
super(_WindowsStoredDataManager, self).__init__()
self.__storedData = defaultdict(list)
self.__targetMask = DEF_TARGET_MASK
self.__loader = None
self.__supported = dict(((clazz.getDataType(), clazz) for clazz in supported))
self.__isStarted = False
return
def start(self):
if self.__isStarted:
return
self.__isStarted = True
self.__loader = WindowsStoredDataLoader(STORED_DATA_REV, STORED_DATA_MAX_LENGTH, DEF_TARGET_MASK)
mask, records = self.__loader.load()
self.__targetMask = mask & TARGET_ID.ALL
for record in records:
if len(record) < 2:
LOG_ERROR('Invalid record', record)
continue
targetID, dataType = record[:2]
if not targetID & TARGET_ID.ALL:
LOG_ERROR('Invalid target ID', record)
continue
if not self.isTargetEnabled(targetID):
LOG_WARNING('Target is not enabled. Records are ignored to load', self.__targetMask, record)
continue
if dataType not in DATA_TYPE.RANGE:
LOG_ERROR('Invalid data type', record)
continue
if dataType not in self.__supported:
LOG_ERROR('Data type is not supported', dataType)
continue
try:
self.__storedData[targetID].append(self.__supported[dataType](*record[2:]))
except TypeError:
LOG_ERROR('Invalid record', record)
def stop(self):
if not self.__isStarted:
return
else:
self.__isStarted = False
records = []
for targetID, windowsData in self.__storedData.iteritems():
if not self.__targetMask & targetID:
LOG_WARNING('Target is not enabled. Records are ignored to flush', targetID, self.__targetMask)
continue
for data in windowsData:
if not data.isTrusted():
LOG_DEBUG('Data is not trusted. It do not write to file', data)
continue
record = data.pack()
if record is None:
continue
records.append((targetID, data.getDataType()) + record)
self.__loader.flush(self.__targetMask, records)
self.__loader = None
self.__storedData.clear()
return
def isTargetEnabled(self, targetID):
return self.__isStarted and self.__targetMask & targetID > 0
def addTarget(self, targetID):
if self.__targetMask & targetID > 0:
return
if not targetID & TARGET_ID.ALL:
return
self.__targetMask |= targetID
def removeTarget(self, targetID):
if not self.__targetMask & targetID:
return
elif not targetID & TARGET_ID.ALL:
return
else:
self.__targetMask ^= targetID
self.__storedData.pop(targetID, None)
return
def addData(self, targetID, dataType, window):
if not self.isTargetEnabled(targetID):
return
elif dataType not in self.__supported:
LOG_ERROR('Data type is not supported', dataType)
return
else:
clazz = self.__supported[dataType]
data = clazz._make(window)
if data is not None:
self.__storedData[targetID].append(data)
return data
def getData(self, targetID, window):
if not self.isTargetEnabled(targetID):
return
else:
result = None
for data in self.__storedData[targetID]:
if data.isRequiredWindow(window):
result = data
break
return result
def getMap(self, targetID, dataType):
result = {}
for item in self.__storedData[targetID]:
if item.getDataType() == dataType:
result[item.getFindCriteria()] = item
return result
class _WindowsStoredDataManager(object):
def __init__(self, supported):
super(_WindowsStoredDataManager, self).__init__()
self.__storedData = defaultdict(list)
self.__targetMask = DEF_TARGET_MASK
self.__loader = None
self.__supported = dict(((clazz.getDataType(), clazz) for clazz in supported))
self.__trustedCriteria = defaultdict(set)
self.__isStarted = False
return
def start(self):
""" Starts to collect windows data. First invokes next operation:
- loads mask of stored targets.
- loads windows data.
"""
if self.__isStarted:
return
self.__isStarted = True
self.__loader = WindowsStoredDataLoader(STORED_DATA_REV, STORED_DATA_MAX_LENGTH, DEF_TARGET_MASK)
mask, records = self.__loader.load()
mask |= TARGET_ID.CHAT_MANAGEMENT
mask |= TARGET_ID.CHANNEL_CAROUSEL
self.__targetMask = mask & TARGET_ID.ALL
for record in records:
if len(record) < 2:
LOG_ERROR('Invalid record', record)
continue
targetID, dataType = record[:2]
if not targetID & TARGET_ID.ALL:
LOG_ERROR('Invalid target ID', record)
continue
if not self.isTargetEnabled(targetID):
LOG_WARNING('Target is not enabled. Records are ignored to load', self.__targetMask, record)
continue
if dataType not in DATA_TYPE.RANGE:
LOG_ERROR('Invalid data type', record)
continue
if dataType not in self.__supported:
LOG_ERROR('Data type is not supported', dataType)
continue
try:
self.__storedData[targetID].append(self.__supported[dataType](*record[2:]))
except TypeError:
LOG_ERROR('Invalid record', record)
def stop(self):
""" Stops to collects windows data. Invokes next operations:
- store mask of stored targets to file.
- store windows data to file.
"""
if not self.__isStarted:
return
else:
self.__isStarted = False
records = []
for targetID, windowsData in self.__storedData.iteritems():
if not self.__targetMask & targetID and len(windowsData):
LOG_WARNING('Target is not enabled. Records are ignored to flush', targetID, self.__targetMask)
continue
for data in windowsData:
if not data.isTrusted():
LOG_DEBUG('Data is not trusted. It do not write to file', data)
continue
record = data.pack()
if record is None:
continue
records.append((targetID, data.getDataType()) + record)
self.__loader.flush(self.__targetMask, records)
self.__loader = None
self.__storedData.clear()
self.__trustedCriteria.clear()
return
def isTargetEnabled(self, targetID):
""" Is given target enabled to store.
:param targetID: one of TARGET_ID.*.
:return: bool.
"""
return self.__isStarted and self.__targetMask & targetID > 0
def addTarget(self, targetID):
""" Adds target to stored data.
:param targetID: one of TARGET_ID.*.
"""
if self.__targetMask & targetID > 0:
return
if not targetID & TARGET_ID.ALL:
return
self.__targetMask |= targetID
def removeTarget(self, targetID):
""" Removes target from stored data.
:param targetID: one of TARGET_ID.*.
"""
if not self.__targetMask & targetID:
return
elif not targetID & TARGET_ID.ALL:
return
else:
self.__targetMask ^= targetID
self.__storedData.pop(targetID, None)
return
def addData(self, targetID, dataType, window):
""" Adds stored data for given window.
:param targetID: one of TARGET_ID.*.
:param dataType: one of DATA_TYPE.*.
:param window: instance of AbstractWindowView.
:return: instance of WindowStoredData or None.
"""
if not self.isTargetEnabled(targetID):
return
elif dataType not in self.__supported:
LOG_ERROR('Data type is not supported', dataType)
return
else:
clazz = self.__supported[dataType]
data = clazz.make(window)
if data is not None:
if data.getFindCriteria() in self.__trustedCriteria[targetID]:
data.setTrusted(True)
self.__storedData[targetID].append(data)
return data
def getData(self, targetID, window):
""" Gets stored data for given window if it exists.
:param targetID: one of TARGET_ID.*.
:param window: instance of AbstractWindowView.
:return: instance of WindowStoredData or None.
"""
if not self.isTargetEnabled(targetID):
return
else:
result = None
for data in self.__storedData[targetID]:
if data.isRequiredWindow(window):
result = data
break
return result
def getMap(self, targetID, dataType):
""" Gets data mapping for required type.
:param targetID: one of TARGET_ID.*.
:param dataType: one of DATA_TYPE.*.
:return: dict( <criteria> : <instance of data>, ... ).
"""
result = {}
for item in self.__storedData[targetID]:
if item.getDataType() == dataType:
result[item.getFindCriteria()] = item
return result
def setTrustedCriteria(self, targetID, criteria):
""" Sets criteria to set data as trusted if data is defined or
new data that will be created.
:param targetID: one of TARGET_ID.*.
:param criteria: object containing criteria to find.
"""
self.__trustedCriteria[targetID].add(criteria)
for item in self.__storedData[targetID]:
if item.getFindCriteria() == criteria:
item.setTrusted(True)
class _WindowsStoredDataManager(object):
def __init__(self, supported):
super(_WindowsStoredDataManager, self).__init__()
self.__storedData = defaultdict(list)
self.__targetMask = DEF_TARGET_MASK
self.__loader = None
self.__supported = dict(
((clazz.getDataType(), clazz) for clazz in supported))
self.__isStarted = False
return
def start(self):
if self.__isStarted:
return
self.__isStarted = True
self.__loader = WindowsStoredDataLoader(STORED_DATA_REV,
STORED_DATA_MAX_LENGTH,
DEF_TARGET_MASK)
mask, records = self.__loader.load()
mask |= TARGET_ID.CHAT_MANAGEMENT
mask |= TARGET_ID.CHANNEL_CAROUSEL
self.__targetMask = mask & TARGET_ID.ALL
for record in records:
if len(record) < 2:
LOG_ERROR('Invalid record', record)
continue
targetID, dataType = record[:2]
if not targetID & TARGET_ID.ALL:
LOG_ERROR('Invalid target ID', record)
continue
if not self.isTargetEnabled(targetID):
LOG_WARNING(
'Target is not enabled. Records are ignored to load',
self.__targetMask, record)
continue
if dataType not in DATA_TYPE.RANGE:
LOG_ERROR('Invalid data type', record)
continue
if dataType not in self.__supported:
LOG_ERROR('Data type is not supported', dataType)
continue
try:
self.__storedData[targetID].append(
self.__supported[dataType](*record[2:]))
except TypeError:
LOG_ERROR('Invalid record', record)
def stop(self):
if not self.__isStarted:
return
else:
self.__isStarted = False
records = []
for targetID, windowsData in self.__storedData.iteritems():
if not self.__targetMask & targetID and len(windowsData):
LOG_WARNING(
'Target is not enabled. Records are ignored to flush',
targetID, self.__targetMask)
continue
for data in windowsData:
if not data.isTrusted():
LOG_DEBUG(
'Data is not trusted. It do not write to file',
data)
continue
record = data.pack()
if record is None:
continue
records.append((targetID, data.getDataType()) + record)
self.__loader.flush(self.__targetMask, records)
self.__loader = None
self.__storedData.clear()
return
def isTargetEnabled(self, targetID):
return self.__isStarted and self.__targetMask & targetID > 0
def addTarget(self, targetID):
if self.__targetMask & targetID > 0:
return
if not targetID & TARGET_ID.ALL:
return
self.__targetMask |= targetID
def removeTarget(self, targetID):
if not self.__targetMask & targetID:
return
elif not targetID & TARGET_ID.ALL:
return
else:
self.__targetMask ^= targetID
self.__storedData.pop(targetID, None)
return
def addData(self, targetID, dataType, window):
if not self.isTargetEnabled(targetID):
return
elif dataType not in self.__supported:
LOG_ERROR('Data type is not supported', dataType)
return
else:
clazz = self.__supported[dataType]
data = clazz._make(window)
if data is not None:
self.__storedData[targetID].append(data)
return data
def getData(self, targetID, window):
if not self.isTargetEnabled(targetID):
return
else:
result = None
for data in self.__storedData[targetID]:
if data.isRequiredWindow(window):
result = data
break
return result
def getMap(self, targetID, dataType):
result = {}
for item in self.__storedData[targetID]:
if item.getDataType() == dataType:
result[item.getFindCriteria()] = item
return result
