class HyperVKvpReportingHandler(ReportingHandler): """ Reports events to a Hyper-V host using Key-Value-Pair exchange protocol and can be used to obtain high level diagnostic information from the host. To use this facility, the KVP user-space daemon (hv_kvp_daemon) has to be running. It reads the kvp_file when the host requests the guest to enumerate the KVP's. This reporter collates all events for a module (origin|name) in a single json string in the dictionary. For more information, see https://technet.microsoft.com/en-us/library/dn798287.aspx#Linux%20guests """ HV_KVP_EXCHANGE_MAX_VALUE_SIZE = 2048 HV_KVP_EXCHANGE_MAX_KEY_SIZE = 512 HV_KVP_RECORD_SIZE = (HV_KVP_EXCHANGE_MAX_KEY_SIZE + HV_KVP_EXCHANGE_MAX_VALUE_SIZE) EVENT_PREFIX = 'CLOUD_INIT' MSG_KEY = 'msg' RESULT_KEY = 'result' DESC_IDX_KEY = 'msg_i' JSON_SEPARATORS = (',', ':') KVP_POOL_FILE_GUEST = '/var/lib/hyperv/.kvp_pool_1' _already_truncated_pool_file = False def __init__(self, kvp_file_path=KVP_POOL_FILE_GUEST, event_types=None): super(HyperVKvpReportingHandler, self).__init__() self._kvp_file_path = kvp_file_path HyperVKvpReportingHandler._truncate_guest_pool_file( self._kvp_file_path) self._event_types = event_types self.q = JQueue() self.incarnation_no = self._get_incarnation_no() self.event_key_prefix = u"{0}|{1}".format(self.EVENT_PREFIX, self.incarnation_no) self.publish_thread = threading.Thread( target=self._publish_event_routine) self.publish_thread.daemon = True self.publish_thread.start() @classmethod def _truncate_guest_pool_file(cls, kvp_file): """ Truncate the pool file if it has not been truncated since boot. This should be done exactly once for the file indicated by KVP_POOL_FILE_GUEST constant above. This method takes a filename so that we can use an arbitrary file during unit testing. Since KVP is a best-effort telemetry channel we only attempt to truncate the file once and only if the file has not been modified since boot. Additional truncation can lead to loss of existing KVPs. """ if cls._already_truncated_pool_file: return boot_time = time.time() - float(util.uptime()) try: if os.path.getmtime(kvp_file) < boot_time: with open(kvp_file, "w"): pass except (OSError, IOError) as e: LOG.warning("failed to truncate kvp pool file, %s", e) finally: cls._already_truncated_pool_file = True def _get_incarnation_no(self): """ use the time passed as the incarnation number. the incarnation number is the number which are used to distinguish the old data stored in kvp and the new data. """ uptime_str = util.uptime() try: return int(time.time() - float(uptime_str)) except ValueError: LOG.warning("uptime '%s' not in correct format.", uptime_str) return 0 def _iterate_kvps(self, offset): """iterate the kvp file from the current offset.""" with open(self._kvp_file_path, 'rb') as f: fcntl.flock(f, fcntl.LOCK_EX) f.seek(offset) record_data = f.read(self.HV_KVP_RECORD_SIZE) while len(record_data) == self.HV_KVP_RECORD_SIZE: kvp_item = self._decode_kvp_item(record_data) yield kvp_item record_data = f.read(self.HV_KVP_RECORD_SIZE) fcntl.flock(f, fcntl.LOCK_UN) def _event_key(self, event): """ the event key format is: CLOUD_INIT|<incarnation number>|<event_type>|<event_name>|<time> """ return u"{0}|{1}|{2}|{3}".format(self.event_key_prefix, event.event_type, event.name, uuid.uuid4()) def _encode_kvp_item(self, key, value): data = (struct.pack("%ds%ds" % ( self.HV_KVP_EXCHANGE_MAX_KEY_SIZE, self.HV_KVP_EXCHANGE_MAX_VALUE_SIZE), key.encode('utf-8'), value.encode('utf-8'))) return data def _decode_kvp_item(self, record_data): record_data_len = len(record_data) if record_data_len != self.HV_KVP_RECORD_SIZE: raise ReportException( "record_data len not correct {0} {1}." .format(record_data_len, self.HV_KVP_RECORD_SIZE)) k = (record_data[0:self.HV_KVP_EXCHANGE_MAX_KEY_SIZE].decode('utf-8') .strip('\x00')) v = ( record_data[ self.HV_KVP_EXCHANGE_MAX_KEY_SIZE:self.HV_KVP_RECORD_SIZE ].decode('utf-8').strip('\x00')) return {'key': k, 'value': v} def _append_kvp_item(self, record_data): with open(self._kvp_file_path, 'ab') as f: fcntl.flock(f, fcntl.LOCK_EX) for data in record_data: f.write(data) f.flush() fcntl.flock(f, fcntl.LOCK_UN) def _break_down(self, key, meta_data, description): del meta_data[self.MSG_KEY] des_in_json = json.dumps(description) des_in_json = des_in_json[1:(len(des_in_json) - 1)] i = 0 result_array = [] message_place_holder = "\"" + self.MSG_KEY + "\":\"\"" while True: meta_data[self.DESC_IDX_KEY] = i meta_data[self.MSG_KEY] = '' data_without_desc = json.dumps(meta_data, separators=self.JSON_SEPARATORS) room_for_desc = ( self.HV_KVP_EXCHANGE_MAX_VALUE_SIZE - len(data_without_desc) - 8) value = data_without_desc.replace( message_place_holder, '"{key}":"{desc}"'.format( key=self.MSG_KEY, desc=des_in_json[:room_for_desc])) result_array.append(self._encode_kvp_item(key, value)) i += 1 des_in_json = des_in_json[room_for_desc:] if len(des_in_json) == 0: break return result_array def _encode_event(self, event): """ encode the event into kvp data bytes. if the event content reaches the maximum length of kvp value. then it would be cut to multiple slices. """ key = self._event_key(event) meta_data = { "name": event.name, "type": event.event_type, "ts": (datetime.utcfromtimestamp(event.timestamp) .isoformat() + 'Z'), } if hasattr(event, self.RESULT_KEY): meta_data[self.RESULT_KEY] = event.result meta_data[self.MSG_KEY] = event.description value = json.dumps(meta_data, separators=self.JSON_SEPARATORS) # if it reaches the maximum length of kvp value, # break it down to slices. # this should be very corner case. if len(value) > self.HV_KVP_EXCHANGE_MAX_VALUE_SIZE: return self._break_down(key, meta_data, event.description) else: data = self._encode_kvp_item(key, value) return [data] def _publish_event_routine(self): while True: items_from_queue = 0 try: event = self.q.get(block=True) items_from_queue += 1 encoded_data = [] while event is not None: encoded_data += self._encode_event(event) try: # get all the rest of the events in the queue event = self.q.get(block=False) items_from_queue += 1 except QueueEmptyError: event = None try: self._append_kvp_item(encoded_data) except (OSError, IOError) as e: LOG.warning("failed posting events to kvp, %s", e) finally: for _ in range(items_from_queue): self.q.task_done() # when main process exits, q.get() will through EOFError # indicating we should exit this thread. except EOFError: return # since the saving to the kvp pool can be a time costing task # if the kvp pool already contains a chunk of data, # so defer it to another thread. def publish_event(self, event): if not self._event_types or event.event_type in self._event_types: self.q.put(event) def flush(self): LOG.debug('HyperVReportingHandler flushing remaining events') self.q.join()
def run(self): transportDispatcher = None try: # Initialize the engine self.tokens_start.get() if self.active is not None and self.active.lower() == "false": # Changes the process name shown by ps for instance setProcTitle("agentcluster agent [active: False] [name: %s]" % self.name) logger.info('Agent "%s": inactive', self.name) # Generates a deadlock to enter in sleep mode # Only an external signal can break this deadlock self.tokens_start.task_done() queue = JoinableQueue() queue.put(object()) queue.join() # Changes the process name shown by ps for instance setProcTitle("agentcluster agent [active: True ] [name: %s]" % self.name) logger.info('Agent "%s": run', self.name) logger.debug('EngineID="%s"', self.engineID) engineID_bin = None if self.engineID != None: try: engineID_bin = self.engineID.decode("hex") except Exception: logger.warn( "Cannot convert configured engine ID to byte array, engine ID ignored: %s", self.engineID ) logger.debug("", exc_info=True) else: logger.debug("No context engineID specified, let pysnmp generate one") snmpEngine = engine.SnmpEngine(snmpEngineID=engineID_bin) logger.debug('Agent "%s": Configure transport layer', self.name) for protocol, params in self.listen.__dict__.items(): if type(params) is list: for param in params: (domain, socket) = self.socketHelper.openSocket(protocol, param.encode("ascii")) config.addSocketTransport(snmpEngine, domain, socket) else: (domain, socket) = self.socketHelper.openSocket(protocol, params.encode("ascii")) config.addSocketTransport(snmpEngine, domain, socket) logger.debug('Agent "%s": Configure application layer', self.name) snmpContext = context.SnmpContext(snmpEngine) if self.snmpv1 is not None: SnmpConfHelperV1().configure(snmpEngine, snmpContext, self.snmpv1) if self.snmpv2c is not None: SnmpConfHelperV2().configure(snmpEngine, snmpContext, self.snmpv2c) if self.snmpv3 is not None: SnmpConfHelperV3().configure(snmpEngine, snmpContext, self.snmpv3) cmdrsp.GetCommandResponder(snmpEngine, snmpContext) cmdrsp.SetCommandResponder(snmpEngine, snmpContext) cmdrsp.NextCommandResponder(snmpEngine, snmpContext) cmdrsp.BulkCommandResponder(snmpEngine, snmpContext) logger.debug('Agent "%s": Configured', self.name) self.tokens_start.task_done() logger.debug("Starting parent and database watchdog") self.monitor = Watchdog(self.parent_pid, self.monitoring_period) self.monitor.start() # Job will never end unless killed logger.debug('Agent "%s": Running dispatcher', self.name) transportDispatcher = snmpEngine.transportDispatcher transportDispatcher.jobStarted(1) transportDispatcher.runDispatcher() except KeyboardInterrupt: logger.debug('Agent "%s": interrupted', self.name) except Exception: logger.error("Unexpected exception catched in agent: %s", sys.exc_info()[1]) logger.error("", exc_info=True) finally: if transportDispatcher != None: transportDispatcher.closeDispatcher() logger.info('Agent "%s": end', self.name) logging.shutdown() try: # Issue #3: Python 2.7.6 releases the parent process if children is killed # not Python 2.6.6 so we must still release the token. self.tokens_start.task_done() except: pass # Issue #3: This agent is no longer usable so commit suicide to be sure # This process won't become a zombie and that parent will start a new agent os.kill(os.getpid(), signal.SIGKILL)
class HyperVKvpReportingHandler(ReportingHandler): """ Reports events to a Hyper-V host using Key-Value-Pair exchange protocol and can be used to obtain high level diagnostic information from the host. To use this facility, the KVP user-space daemon (hv_kvp_daemon) has to be running. It reads the kvp_file when the host requests the guest to enumerate the KVP's. This reporter collates all events for a module (origin|name) in a single json string in the dictionary. For more information, see https://technet.microsoft.com/en-us/library/dn798287.aspx#Linux%20guests """ HV_KVP_EXCHANGE_MAX_VALUE_SIZE = 2048 HV_KVP_EXCHANGE_MAX_KEY_SIZE = 512 HV_KVP_RECORD_SIZE = (HV_KVP_EXCHANGE_MAX_KEY_SIZE + HV_KVP_EXCHANGE_MAX_VALUE_SIZE) EVENT_PREFIX = 'CLOUD_INIT' MSG_KEY = 'msg' RESULT_KEY = 'result' DESC_IDX_KEY = 'msg_i' JSON_SEPARATORS = (',', ':') KVP_POOL_FILE_GUEST = '/var/lib/hyperv/.kvp_pool_1' _already_truncated_pool_file = False def __init__(self, kvp_file_path=KVP_POOL_FILE_GUEST, event_types=None): super(HyperVKvpReportingHandler, self).__init__() self._kvp_file_path = kvp_file_path HyperVKvpReportingHandler._truncate_guest_pool_file( self._kvp_file_path) self._event_types = event_types self.q = JQueue() self.incarnation_no = self._get_incarnation_no() self.event_key_prefix = u"{0}|{1}".format(self.EVENT_PREFIX, self.incarnation_no) self.publish_thread = threading.Thread( target=self._publish_event_routine) self.publish_thread.daemon = True self.publish_thread.start() @classmethod def _truncate_guest_pool_file(cls, kvp_file): """ Truncate the pool file if it has not been truncated since boot. This should be done exactly once for the file indicated by KVP_POOL_FILE_GUEST constant above. This method takes a filename so that we can use an arbitrary file during unit testing. Since KVP is a best-effort telemetry channel we only attempt to truncate the file once and only if the file has not been modified since boot. Additional truncation can lead to loss of existing KVPs. """ if cls._already_truncated_pool_file: return boot_time = time.time() - float(util.uptime()) try: if os.path.getmtime(kvp_file) < boot_time: with open(kvp_file, "w"): pass except (OSError, IOError) as e: LOG.warning("failed to truncate kvp pool file, %s", e) finally: cls._already_truncated_pool_file = True def _get_incarnation_no(self): """ use the time passed as the incarnation number. the incarnation number is the number which are used to distinguish the old data stored in kvp and the new data. """ uptime_str = util.uptime() try: return int(time.time() - float(uptime_str)) except ValueError: LOG.warning("uptime '%s' not in correct format.", uptime_str) return 0 def _iterate_kvps(self, offset): """iterate the kvp file from the current offset.""" with open(self._kvp_file_path, 'rb') as f: fcntl.flock(f, fcntl.LOCK_EX) f.seek(offset) record_data = f.read(self.HV_KVP_RECORD_SIZE) while len(record_data) == self.HV_KVP_RECORD_SIZE: kvp_item = self._decode_kvp_item(record_data) yield kvp_item record_data = f.read(self.HV_KVP_RECORD_SIZE) fcntl.flock(f, fcntl.LOCK_UN) def _event_key(self, event): """ the event key format is: CLOUD_INIT|<incarnation number>|<event_type>|<event_name> """ return u"{0}|{1}|{2}".format(self.event_key_prefix, event.event_type, event.name) def _encode_kvp_item(self, key, value): data = (struct.pack("%ds%ds" % ( self.HV_KVP_EXCHANGE_MAX_KEY_SIZE, self.HV_KVP_EXCHANGE_MAX_VALUE_SIZE), key.encode('utf-8'), value.encode('utf-8'))) return data def _decode_kvp_item(self, record_data): record_data_len = len(record_data) if record_data_len != self.HV_KVP_RECORD_SIZE: raise ReportException( "record_data len not correct {0} {1}." .format(record_data_len, self.HV_KVP_RECORD_SIZE)) k = (record_data[0:self.HV_KVP_EXCHANGE_MAX_KEY_SIZE].decode('utf-8') .strip('\x00')) v = ( record_data[ self.HV_KVP_EXCHANGE_MAX_KEY_SIZE:self.HV_KVP_RECORD_SIZE ].decode('utf-8').strip('\x00')) return {'key': k, 'value': v} def _append_kvp_item(self, record_data): with open(self._kvp_file_path, 'ab') as f: fcntl.flock(f, fcntl.LOCK_EX) for data in record_data: f.write(data) f.flush() fcntl.flock(f, fcntl.LOCK_UN) def _break_down(self, key, meta_data, description): del meta_data[self.MSG_KEY] des_in_json = json.dumps(description) des_in_json = des_in_json[1:(len(des_in_json) - 1)] i = 0 result_array = [] message_place_holder = "\"" + self.MSG_KEY + "\":\"\"" while True: meta_data[self.DESC_IDX_KEY] = i meta_data[self.MSG_KEY] = '' data_without_desc = json.dumps(meta_data, separators=self.JSON_SEPARATORS) room_for_desc = ( self.HV_KVP_EXCHANGE_MAX_VALUE_SIZE - len(data_without_desc) - 8) value = data_without_desc.replace( message_place_holder, '"{key}":"{desc}"'.format( key=self.MSG_KEY, desc=des_in_json[:room_for_desc])) result_array.append(self._encode_kvp_item(key, value)) i += 1 des_in_json = des_in_json[room_for_desc:] if len(des_in_json) == 0: break return result_array def _encode_event(self, event): """ encode the event into kvp data bytes. if the event content reaches the maximum length of kvp value. then it would be cut to multiple slices. """ key = self._event_key(event) meta_data = { "name": event.name, "type": event.event_type, "ts": (datetime.utcfromtimestamp(event.timestamp) .isoformat() + 'Z'), } if hasattr(event, self.RESULT_KEY): meta_data[self.RESULT_KEY] = event.result meta_data[self.MSG_KEY] = event.description value = json.dumps(meta_data, separators=self.JSON_SEPARATORS) # if it reaches the maximum length of kvp value, # break it down to slices. # this should be very corner case. if len(value) > self.HV_KVP_EXCHANGE_MAX_VALUE_SIZE: return self._break_down(key, meta_data, event.description) else: data = self._encode_kvp_item(key, value) return [data] def _publish_event_routine(self): while True: items_from_queue = 0 try: event = self.q.get(block=True) items_from_queue += 1 encoded_data = [] while event is not None: encoded_data += self._encode_event(event) try: # get all the rest of the events in the queue event = self.q.get(block=False) items_from_queue += 1 except QueueEmptyError: event = None try: self._append_kvp_item(encoded_data) except (OSError, IOError) as e: LOG.warning("failed posting events to kvp, %s", e) finally: for _ in range(items_from_queue): self.q.task_done() # when main process exits, q.get() will through EOFError # indicating we should exit this thread. except EOFError: return # since the saving to the kvp pool can be a time costing task # if the kvp pool already contains a chunk of data, # so defer it to another thread. def publish_event(self, event): if not self._event_types or event.event_type in self._event_types: self.q.put(event) def flush(self): LOG.debug('HyperVReportingHandler flushing remaining events') self.q.join()
class HyperVKvpReportingHandler(ReportingHandler): """ Reports events to a Hyper-V host using Key-Value-Pair exchange protocol and can be used to obtain high level diagnostic information from the host. To use this facility, the KVP user-space daemon (hv_kvp_daemon) has to be running. It reads the kvp_file when the host requests the guest to enumerate the KVP's. This reporter collates all events for a module (origin|name) in a single json string in the dictionary. For more information, see https://technet.microsoft.com/en-us/library/dn798287.aspx#Linux%20guests """ HV_KVP_EXCHANGE_MAX_VALUE_SIZE = 2048 HV_KVP_EXCHANGE_MAX_KEY_SIZE = 512 HV_KVP_RECORD_SIZE = (HV_KVP_EXCHANGE_MAX_KEY_SIZE + HV_KVP_EXCHANGE_MAX_VALUE_SIZE) EVENT_PREFIX = 'CLOUD_INIT' MSG_KEY = 'msg' RESULT_KEY = 'result' DESC_IDX_KEY = 'msg_i' JSON_SEPARATORS = (',', ':') KVP_POOL_FILE_GUEST = '/var/lib/hyperv/.kvp_pool_1' def __init__(self, kvp_file_path=KVP_POOL_FILE_GUEST, event_types=None): super(HyperVKvpReportingHandler, self).__init__() self._kvp_file_path = kvp_file_path self._event_types = event_types self.q = JQueue() self.kvp_file = None self.incarnation_no = self._get_incarnation_no() self.event_key_prefix = u"{0}|{1}".format(self.EVENT_PREFIX, self.incarnation_no) self._current_offset = 0 self.publish_thread = threading.Thread( target=self._publish_event_routine) self.publish_thread.daemon = True self.publish_thread.start() def _get_incarnation_no(self): """ use the time passed as the incarnation number. the incarnation number is the number which are used to distinguish the old data stored in kvp and the new data. """ uptime_str = util.uptime() try: return int(time.time() - float(uptime_str)) except ValueError: LOG.warning("uptime '%s' not in correct format.", uptime_str) return 0 def _iterate_kvps(self, offset): """iterate the kvp file from the current offset.""" try: with open(self._kvp_file_path, 'rb+') as f: self.kvp_file = f fcntl.flock(f, fcntl.LOCK_EX) f.seek(offset) record_data = f.read(self.HV_KVP_RECORD_SIZE) while len(record_data) == self.HV_KVP_RECORD_SIZE: self._current_offset += self.HV_KVP_RECORD_SIZE kvp_item = self._decode_kvp_item(record_data) yield kvp_item record_data = f.read(self.HV_KVP_RECORD_SIZE) fcntl.flock(f, fcntl.LOCK_UN) finally: self.kvp_file = None def _event_key(self, event): """ the event key format is: CLOUD_INIT|<incarnation number>|<event_type>|<event_name> """ return u"{0}|{1}|{2}".format(self.event_key_prefix, event.event_type, event.name) def _encode_kvp_item(self, key, value): data = (struct.pack( "%ds%ds" % (self.HV_KVP_EXCHANGE_MAX_KEY_SIZE, self.HV_KVP_EXCHANGE_MAX_VALUE_SIZE), key.encode('utf-8'), value.encode('utf-8'))) return data def _decode_kvp_item(self, record_data): record_data_len = len(record_data) if record_data_len != self.HV_KVP_RECORD_SIZE: raise ReportException( "record_data len not correct {0} {1}.".format( record_data_len, self.HV_KVP_RECORD_SIZE)) k = (record_data[0:self.HV_KVP_EXCHANGE_MAX_KEY_SIZE].decode( 'utf-8').strip('\x00')) v = (record_data[self.HV_KVP_EXCHANGE_MAX_KEY_SIZE:self. HV_KVP_RECORD_SIZE].decode('utf-8').strip('\x00')) return {'key': k, 'value': v} def _update_kvp_item(self, record_data): if self.kvp_file is None: raise ReportException("kvp file '{0}' not opened.".format( self._kvp_file_path)) self.kvp_file.seek(-self.HV_KVP_RECORD_SIZE, 1) self.kvp_file.write(record_data) def _append_kvp_item(self, record_data): with open(self._kvp_file_path, 'rb+') as f: fcntl.flock(f, fcntl.LOCK_EX) # seek to end of the file f.seek(0, 2) f.write(record_data) f.flush() fcntl.flock(f, fcntl.LOCK_UN) self._current_offset = f.tell() def _break_down(self, key, meta_data, description): del meta_data[self.MSG_KEY] des_in_json = json.dumps(description) des_in_json = des_in_json[1:(len(des_in_json) - 1)] i = 0 result_array = [] message_place_holder = "\"" + self.MSG_KEY + "\":\"\"" while True: meta_data[self.DESC_IDX_KEY] = i meta_data[self.MSG_KEY] = '' data_without_desc = json.dumps(meta_data, separators=self.JSON_SEPARATORS) room_for_desc = (self.HV_KVP_EXCHANGE_MAX_VALUE_SIZE - len(data_without_desc) - 8) value = data_without_desc.replace( message_place_holder, '"{key}":"{desc}"'.format(key=self.MSG_KEY, desc=des_in_json[:room_for_desc])) result_array.append(self._encode_kvp_item(key, value)) i += 1 des_in_json = des_in_json[room_for_desc:] if len(des_in_json) == 0: break return result_array def _encode_event(self, event): """ encode the event into kvp data bytes. if the event content reaches the maximum length of kvp value. then it would be cut to multiple slices. """ key = self._event_key(event) meta_data = { "name": event.name, "type": event.event_type, "ts": (datetime.utcfromtimestamp(event.timestamp).isoformat() + 'Z'), } if hasattr(event, self.RESULT_KEY): meta_data[self.RESULT_KEY] = event.result meta_data[self.MSG_KEY] = event.description value = json.dumps(meta_data, separators=self.JSON_SEPARATORS) # if it reaches the maximum length of kvp value, # break it down to slices. # this should be very corner case. if len(value) > self.HV_KVP_EXCHANGE_MAX_VALUE_SIZE: return self._break_down(key, meta_data, event.description) else: data = self._encode_kvp_item(key, value) return [data] def _publish_event_routine(self): while True: try: event = self.q.get(block=True) need_append = True try: if not os.path.exists(self._kvp_file_path): LOG.warning( "skip writing events %s to %s. file not present.", event.as_string(), self._kvp_file_path) encoded_event = self._encode_event(event) # for each encoded_event for encoded_data in (encoded_event): for kvp in self._iterate_kvps(self._current_offset): match = (re.match( r"^{0}\|(\d+)\|.+".format(self.EVENT_PREFIX), kvp['key'])) if match: match_groups = match.groups(0) if int(match_groups[0]) < self.incarnation_no: need_append = False self._update_kvp_item(encoded_data) continue if need_append: self._append_kvp_item(encoded_data) except IOError as e: LOG.warning("failed posting event to kvp: %s e:%s", event.as_string(), e) finally: self.q.task_done() # when main process exits, q.get() will through EOFError # indicating we should exit this thread. except EOFError: return # since the saving to the kvp pool can be a time costing task # if the kvp pool already contains a chunk of data, # so defer it to another thread. def publish_event(self, event): if (not self._event_types or event.event_type in self._event_types): self.q.put(event) def flush(self): LOG.debug('HyperVReportingHandler flushing remaining events') self.q.join()