def __init__( self, userID, interceptionFilePath = "./", interceptionFileName = "interception.pcap" , senderTool : SenderTool = SenderTool.logstash, kafkaServerAddress = "localhost", kafkaServerPort = 9092, kafkaTopic = "interception_data", logstashAddress = "localhost", logstashPort = 5960, logstashMessageVersion = 1, sizeByteToRead = 100, tcpServerAddress = "", tcpServerPort = 0 ) : threading.Thread.__init__( self ) self.userID = userID self.interceptionFilePath = interceptionFilePath self.interceptionFileName = interceptionFileName self.senderTool = senderTool self.kafkaServerAddress = kafkaServerAddress self.kafkaServerPort = kafkaServerPort self.kafkaTopic = kafkaTopic self.logstashAddress = logstashAddress self.logstashPort = logstashPort self.logstashMessageVersion = logstashMessageVersion self.sizeByteToRead = sizeByteToRead self.tcpServerAddress = tcpServerAddress self.tcpServerPort = tcpServerPort self.tcpFirstMessage = None self.tcpSocket = None localLogger = MyLogger() self.logger = localLogger.getLogger( __name__ ) self.logger.debug( "tcpServerAddress: %s / tcpServerPort: %s", str( self.tcpServerAddress ), str( self.tcpServerPort ) ) self.is_active = True if self.senderTool == SenderTool.kafka : bootstrap_servers = [ str( self.kafkaServerAddress ) + ":" + str( self.kafkaServerPort ) ] self.logger.debug( "kafka bootstrap server: %s", str( bootstrap_servers ) ) value_serializer = lambda x: dumps(x).encode( 'utf-8' ) self.producer = KafkaProducer( bootstrap_servers = bootstrap_servers, value_serializer = value_serializer ) self.__sender = self.__kafkaSender elif self.senderTool == SenderTool.logstash : self.logger.debug( "Logstash server : %s : %s", str( self.logstashAddress ), str( self.logstashPort ) ) self.sendToLogstash = logging.getLogger( "interception" ) if len( self.sendToLogstash.handlers ) == 0 : self.sendToLogstash.setLevel( logging.INFO ) self.sendToLogstash.addHandler( logstash.TCPLogstashHandler( host = self.logstashAddress, port = self.logstashPort, version = self.logstashMessageVersion ) ) self.__sender = self.__logstashSender elif self.senderTool == SenderTool.tcpstream : self.logger.debug( "Tcp stream sender : tcp server : %s:%s", \ str( self.tcpServerAddress ), str( self.tcpServerPort ) ) self.tcpFirstMessage = True self.__sender = self.__tcpSender for res in socket.getaddrinfo( self.tcpServerAddress, self.tcpServerPort, socket.AF_UNSPEC, socket.SOCK_STREAM ) : af, socktype, proto, canonname, sa = res try : self.tcpSocket = socket.socket( af, socktype, proto ) except socket.error as exception : self.logger.debug( "Error: create socket, retry : %s", str( exception ) ) self.tcpSocket = None continue try : self.tcpSocket.connect( sa ) except socket.error as exception : self.logger.debug( "Error: connect, retry : %s", str( exception ) ) self.tcpSocket.close() self.tcpSocket = None continue break if self.tcpSocket is None : self.logger.error( "ERROR: impossible to connect to %s:%s", \ str( self.tcpServerAddress ), str( self.tcpServerPort ) ) else : self.__sender = self.__undefinedSender
confBox.getKafkaServerPort != 0 : kafkaClient = KafkaClient(confBox.getKafkaServerAddress(), confBox.getKafkaServerPort(), confBox.getKafkaServerTopic(), confBox.getPolycubeServerAddress(), confBox.getPolycubeServerPort(), confBox.getInterceptionInterfaceName(), confBox.getLogVoIPServerPath(), confBox.getLogVoIPServerFilename(), confBox.getVoIPLogReadingTimeOut(), confBox.getInterceptionTool(), confBox.getSavedInterceptionPath(), confBox.getLogstashServerAddress(), confBox.getLogstashServerMsgPort(), confBox.getLogstashServerVersion(), "interception_data", confBox.getLogstashServerDataPort(), confBox.getTcpServerAddress(), confBox.getTcpServerPort()) kafkaClient.run() if __name__ == "__main__": confBox = ConfigurationManager() myLogger = MyLogger() logger = myLogger.getLogger(logName=__name__) logger.debug("starting ... ") main() logger.debug("... end ")
class RadioProcess(object): def __init__(self): self.myLogger = MyLogger(self.__class__.__name__) self.myLogger.info('Init RadioProcess') self.radioSwitch = RadioSwitch() self.redisServer = redis.Redis(host='localhost', port=6379, db=0) # nur zum initialisieren. Todo: huebsch machen. self.current_radiostation = self.radioSwitch.get_radiostation( RadioSwitch.radioBob) def process(self, stop_event): current_radiostation_name = RadioSwitch.radio_off current_volume = 0 while not stop_event.is_set(): time.sleep(1) try: selected_radiostation_name = self.redisServer.get( RadioSwitch.selected_radiostation).decode('utf-8') self.myLogger.debug('Selected Radiostation: %s.' % selected_radiostation_name) self.myLogger.debug('Current Radiostation: %s.' % current_radiostation_name) selected_volume = int( self.redisServer.get( RadioSwitch.selected_volume).decode('utf-8')) if current_volume != selected_volume: self.myLogger.info('Change Volume: %s.' % selected_volume) self.current_radiostation.set_volume(selected_volume) current_volume = selected_volume if current_radiostation_name != selected_radiostation_name: if selected_radiostation_name == RadioSwitch.radio_off or selected_radiostation_name == RadioSwitch.airplay: self.myLogger.info("Stop Radio. Selected station %s." % selected_radiostation_name) self.current_radiostation.stop() self.myLogger.debug("Stop current radiostation %s ." % self.current_radiostation.name) else: self.myLogger.info("Change Radiostation to %s." % selected_radiostation_name) self.myLogger.debug("Stop current radiostation %s ." % self.current_radiostation.name) self.current_radiostation.stop() self.current_radiostation = self.radioSwitch.get_radiostation( selected_radiostation_name) self.myLogger.debug("Play selected radiostation %s ." % self.current_radiostation.name) self.current_radiostation.play() current_radiostation_name = selected_radiostation_name except: # catch *all* exceptions self.redisServer.set(RadioSwitch.selected_radiostation, RadioSwitch.radio_off) self.myLogger.debug( "Set selected radiostation on default %s." % RadioSwitch.radio_off) e = sys.exc_info()[0] self.myLogger.error("Error: %s" % e) self.myLogger.info("Stop event is set. Stop %s" % self.__class__.__name__) self.current_radiostation.stop()
def __init__( self, configFileName = "configurationFile.conf", configFilePath = "./config/" ): self.logger = "" self.configFileName = configFileName self.configFilePath = configFilePath self.jsonDictionary = {} # buffer to save configuration parameters self.loggerLevel = logging.DEBUG self.restServerParams = {} # "address" and "port" self.kafkaServerParams = {} # "address", "port" and "topic" self.contextBrokerParams = {} # "address", "port", "user", "password" try: path = self.configFilePath + self.configFileName with open( path ) as jsonFile : self.jsonDictionary = json.load( jsonFile ) except FileNotFoundError as exception: if self.logger : self.logger.error( exception ) else : print( exception ) parameters = self.jsonDictionary.get( "parameters", "" ) if parameters != "" : loggerLevel = parameters.get( "loggerLevel", "" ) if loggerLevel != "" : if loggerLevel == "INFO" : self.loggerLevel = logging.INFO if loggerLevel == "WARN" : self.loggerLevel = logging.WARN if loggerLevel == "DEBUG" : self.loggerLevel = logging.DEBUG if loggerLevel == "ERROR" : self.loggerLevel = logging.ERROR myLogger = MyLogger() myLogger.setLogLevel( self.loggerLevel) self.logger = myLogger.getLogger( __name__ ) self.logger.debug( "logLevel: %s", str( self.loggerLevel ) ) restServer = parameters.get( "restServer", "" ) if restServer != "" : self.restServerParams[ "address" ] = restServer.get( "address", "" ) self.restServerParams[ "port" ] = restServer.get( "port", "" ) self.logger.debug( "REST server address: %s, port: %s", str( self.restServerParams[ "address" ] ), str( self.restServerParams[ "port" ] ) ) kafkaServer = parameters.get( "kafkaServer", "" ) if kafkaServer != "" : self.kafkaServerParams[ "address" ] = kafkaServer.get( "address", "" ) self.kafkaServerParams[ "port" ] = kafkaServer.get( "port", "" ) self.kafkaServerParams[ "topic" ] = kafkaServer.get( "topic", "" ) self.logger.debug( "Kafka server address: %s, port: %s, topic: %s", str( self.kafkaServerParams[ "address" ] ), str( self.kafkaServerParams[ "port" ] ), str( self.kafkaServerParams[ "topic" ] ) ) contextBroker = parameters.get( "contextBroker", "" ) if contextBroker != "" : self.contextBrokerParams[ "address" ] = contextBroker.get( "address", "" ) self.contextBrokerParams[ "port" ] = contextBroker.get( "port", "" ) self.contextBrokerParams[ "user" ] = contextBroker.get( "user", "" ) self.contextBrokerParams[ "password" ] = contextBroker.get( "password", "" ) self.logger.debug( "ContextBroker server address: %s, port: %s, user: %s, \ password: *** ", str( self.contextBrokerParams[ "address" ] ), str( self.contextBrokerParams[ "port" ] ) , str( self.contextBrokerParams[ "user" ] ) ) return None
def __init__(self, configFileName="configurationFile.conf", configFilePath="./config/"): self.logger = "" self.configFileName = configFileName self.configFilePath = configFilePath self.jsonDictionary = {} # buffer to save configuration parameters self.loggerLevel = logging.DEBUG self.interceptionInterfaceName = "" self.savedInterceptionPath = "" self.restServerParams = {} # "address" and "port" self.polycubeServerParams = {} # "address" and "port" self.kafkaServerParams = {} # "address" and "port" self.logstashServerParams = { } # "address", "msgPort", "dataPort" and "version" self.logVoIPServerParams = {} # "path" and "timeout" self.interceptionTool = "" self.tcpServerParams = {} # "address" and "port" try: path = self.configFilePath + self.configFileName with open(path) as jsonFile: self.jsonDictionary = json.load(jsonFile) except FileNotFoundError as exception: if self.logger: self.logger.error(exception) else: print(exception) parameters = self.jsonDictionary.get("parameters", "") if parameters != "": loggerLevel = parameters.get("loggerLevel", "") if loggerLevel != "": if loggerLevel == "INFO": self.loggerLevel = logging.INFO if loggerLevel == "WARN": self.loggerLevel = logging.WARN if loggerLevel == "DEBUG": self.loggerLevel = logging.DEBUG if loggerLevel == "ERROR": self.loggerLevel = logging.ERROR myLogger = MyLogger() myLogger.setLogLevel(self.loggerLevel) self.logger = myLogger.getLogger(__name__) self.logger.debug("logLevel: %s", str(self.loggerLevel)) self.interceptionInterfaceName = parameters.get( "interceptionInterfaceName", "") self.logger.debug("interception interface name: %s", str(self.interceptionInterfaceName)) self.savedInterceptionPath = parameters.get( "savedInterceptionPath", "") self.logger.debug("saved interceptions path : %s", str(self.savedInterceptionPath)) restServer = parameters.get("restServer", "") if restServer != "": self.restServerParams["address"] = restServer.get( "address", "") self.restServerParams["port"] = restServer.get("port", "") self.logger.debug("REST server address: %s, port: %s", str(self.restServerParams["address"]), str(self.restServerParams["port"])) polycubeServer = parameters.get("polycubeServer", "") if polycubeServer != "": self.polycubeServerParams["address"] = polycubeServer.get( "address", "") self.polycubeServerParams["port"] = polycubeServer.get( "port", "") self.logger.debug("Polycube address: %s, port: %s", str(self.polycubeServerParams["address"]), str(self.polycubeServerParams["port"])) kafkaServer = parameters.get("kafkaServer", "") if kafkaServer != "": self.kafkaServerParams["address"] = kafkaServer.get( "address", "") self.kafkaServerParams["port"] = kafkaServer.get("port", "") self.kafkaServerParams["topic"] = kafkaServer.get("topic", "") self.logger.debug( "Kafka server address: %s, port: %s, topic: %s", str(self.kafkaServerParams["address"]), str(self.kafkaServerParams["port"]), str(self.kafkaServerParams["topic"])) logstashServer = parameters.get("logstashServer", "") if logstashServer != "": self.logstashServerParams["address"] = logstashServer.get( "address", "") self.logstashServerParams["msgPort"] = logstashServer.get( "msgPort", "") self.logstashServerParams["dataPort"] = logstashServer.get( "dataPort", "") self.logstashServerParams["version"] = logstashServer.get( "version", "") self.logger.debug( "Logstash server address: %s, msgPort: %s, dataPort: %s, version: %s", str(self.logstashServerParams["address"]), str(self.logstashServerParams["msgPort"]), str(self.logstashServerParams["dataPort"]), str(self.logstashServerParams["version"])) logVoIPServer = parameters.get("logVoIPServer", "") if logVoIPServer != "": self.logVoIPServerParams["path"] = logVoIPServer.get( "path", "") self.logVoIPServerParams["name"] = logVoIPServer.get( "name", "") self.logVoIPServerParams["readingTimeOut"] = logVoIPServer.get( "readingTimeOut", 0.5) self.logger.debug( "log VoIP server path: \"%s\", file name: \"%s\", reading timeout: %s sec", str(self.logVoIPServerParams["path"]), str(self.logVoIPServerParams["name"]), str(self.logVoIPServerParams["readingTimeOut"])) tcpServer = parameters.get("tcpServer", "") if tcpServer != "": self.tcpServerParams["address"] = tcpServer.get("address", "") self.tcpServerParams["port"] = tcpServer.get("port", "") self.logger.debug( "tcp server address: %s, port: %s", \ str( self.tcpServerParams[ "address" ] ), str( self.tcpServerParams[ "port" ] ) ) interceptionTool = parameters.get("interceptionTool", "") if interceptionTool != "": isPolycubePacketCaptureEnabled = interceptionTool.get( "polycubePacketCapture", False) isTcpdumpEnabled = interceptionTool.get("libpcap", False) if isPolycubePacketCaptureEnabled: self.logger.debug( "interception tool is set to be Polycube Packetcapture" ) self.interceptionTool = InterceptionTool.PolycubePacketCapture if isTcpdumpEnabled: self.logger.debug( "interception tools is set to be Tcpdump") self.interceptionTool = InterceptionTool.Tcpdump if isPolycubePacketCaptureEnabled and isTcpdumpEnabled: self.logger.error( "yet Polycube Packetcapture and Tcpdump are set to be enabled" ) raise Exception( "yet Polycube Packetcapture and Tcpdump are set to be enabled" ) if isPolycubePacketCaptureEnabled == False and isTcpdumpEnabled == False: self.logger.error( "yet Polycube Packetcapture and Tcpdump are set do be DISABLED" ) raise Exception( "yet Polycube Packetcapture and Tcpdump are set do be DISABLED" ) return None
def __init__(self): self.myLogger = MyLogger(self.__class__.__name__) self.myLogger.info('Init VolumeWatcherProcess') self.redisServer = redis.Redis(host='localhost', port=6379, db=0) self.mcp3008Controller = MCP3008Controller()
def __init__(self, userID, providerID, serviceID, polycubeServerAddress, polycubeServerPort, interceptionInterfaceName, logVoIPFilePath="./", logVoIPFileName="file.log", readVoIPLogTimeout=0.5, interceptionTool=InterceptionTool.PolycubePacketCapture, savedInterceptionPath="./", logstashAddress="127.0.0.1", logstashMsgPort=5959, logstashVersion=1, kafkaAddress="127.0.0.1", kafkaPort=5002, kafkaTopic="interception_data", logstashDataPort=5960, tcpServerAddress="", tcpServerPort=0): threading.Thread.__init__(self) myLogger = MyLogger() self.logger = myLogger.getLogger(__name__) #threading.Thread.__init__( self ) self.is_active = True self.interceptionInterfaceName = interceptionInterfaceName self.logVoIPFilePath = logVoIPFilePath self.logVoIPFileName = logVoIPFileName self.userID = userID self.providerID = providerID self.serviceID = serviceID self.readVoIPLogTimeout = readVoIPLogTimeout self.parsingHandler = ParsingHandler(userID=self.userID, providerID=self.providerID, serviceID=self.serviceID, filePath=self.logVoIPFilePath, fileName=self.logVoIPFileName) self.savedInterceptionPah = savedInterceptionPath if interceptionTool == InterceptionTool.PolycubePacketCapture: self.logger.debug("Polycube PacketCapture activation") self.interceptionHandler = PolycubeHandler(polycubeServerAddress, polycubeServerPort, savedInterceptionPath) elif interceptionTool == InterceptionTool.Tcpdump: self.logger.debug("Tcpdump activation") self.interceptionHandler = TcpdumpHandler(savedInterceptionPath, "capture.pcap") else: self.logger.error("no interception tool chosen !!!") self.interceptionHandler = None self.interceptedUserIP = "" self.logstashAddress = logstashAddress self.logstashMsgPort = logstashMsgPort self.logstashVersion = logstashVersion self.kafkaAddress = kafkaAddress self.kafkaPort = kafkaPort self.kafkaTopic = kafkaTopic self.logstashDataPort = logstashDataPort self.tcpServerAddress = tcpServerAddress self.tcpServerPort = tcpServerPort self.logger.debug("tcpServerAddress: %s / tcpServerPort: %s", str(self.tcpServerAddress), str(self.tcpServerPort)) self.logstashClient = LogstashClient(self.logstashAddress, self.logstashMsgPort, self.logstashVersion) # list of sender : read pcap file and send it to LEA self.interceptionSenders = dict()
# process cmd line args parser = argparse.ArgumentParser( description='Start script for the radio application') parser.add_argument("--logLevel", type=str, default='INFO') parser.add_argument("--dryMode", type=bool, default=False) args = parser.parse_args() logLevel = args.logLevel dryMode = args.dryMode print('Arg[logLevel]=%s' % logLevel) print('Arg[dryMode]=%s' % dryMode) print("************************************") # init and create the first logger MyLogger.level = logLevel myLogger = MyLogger('main') # set start values redisServer = redis.Redis(host='localhost', port=6379, db=0) redisServer.set(RadioSwitch.selected_radiostation, RadioSwitch.radio_off) # start working with the threads stop_event = threading.Event() radioProcess = RadioProcess() radio_thread = threading.Thread(target=radioProcess.process, name="RadioThread", args=(stop_event, )) radio_thread.start() if dryMode:
class VolumeWatcherProcess(object): def __init__(self): self.myLogger = MyLogger(self.__class__.__name__) self.myLogger.info('Init VolumeWatcherProcess') self.redisServer = redis.Redis(host='localhost', port=6379, db=0) self.mcp3008Controller = MCP3008Controller() def process(self, stop_event): while not stop_event.is_set(): time.sleep(1) try: value = self.mcp3008Controller.read(channel=7) self.myLogger.debug("voltage current: %.2f" % (value)) if value > 4000: self.redisServer.set(RadioSwitch.selected_volume, 100) continue if value > 3000: self.redisServer.set(RadioSwitch.selected_volume, 90) continue if value > 2000: self.redisServer.set(RadioSwitch.selected_volume, 80) continue if value > 1500: self.redisServer.set(RadioSwitch.selected_volume, 70) continue if value > 800: self.redisServer.set(RadioSwitch.selected_volume, 60) continue if value > 500: self.redisServer.set(RadioSwitch.selected_volume, 50) continue if value > 300: self.redisServer.set(RadioSwitch.selected_volume, 40) continue if value > 100: self.redisServer.set(RadioSwitch.selected_volume, 30) continue if value > 50: self.redisServer.set(RadioSwitch.selected_volume, 20) continue if value > 10: self.redisServer.set(RadioSwitch.selected_volume, 10) continue if value < 10: self.redisServer.set(RadioSwitch.selected_volume, 0) continue except: # catch *all* exceptions e = sys.exc_info()[0] self.myLogger.error("Error: %s" % e) self.myLogger.info("Stop event is set. Stop %s" % self.__class__.__name__)
class LightProcess(object): def __init__(self): self.myLogger = MyLogger(self.__class__.__name__) self.myLogger.info('Init LightProcess') self.redisServer = redis.Redis(host='localhost', port=6379, db=0) self.gpioController = GPIOController() def process(self, stop_event): # init with start value current_radiostation_name = RadioSwitch.radio_off current_light_state = False self.gpioController.call(GPIOController.gpio_led_3_3_v, GPIOController.gpio_off) while not stop_event.is_set(): time.sleep(1) try: self.myLogger.debug("Check selected radiostation") selected_radiostation_name = self.redisServer.get( RadioSwitch.selected_radiostation) radiostation_name_decoded = selected_radiostation_name.decode( 'utf-8') turn_light_on = False if radiostation_name_decoded != RadioSwitch.radio_off: turn_light_on = True if current_light_state == turn_light_on: continue if turn_light_on: self.myLogger.info("Switch on light and turn amp on") self.gpioController.call(GPIOController.gpio_led_3_3_v, GPIOController.gpio_on) else: self.myLogger.info("Switch off light and turn amp off") self.gpioController.call(GPIOController.gpio_led_3_3_v, GPIOController.gpio_off) current_light_state = turn_light_on current_radiostation_name = radiostation_name_decoded except: # catch *all* exceptions e = sys.exc_info()[0] self.myLogger.error("Error: %s" % e) self.myLogger.info("Stop event is set. Stop %s" % self.__class__.__name__) self.gpioController.call(GPIOController.gpio_led_3_3_v, GPIOController.gpio_off)
def __init__(self): self.myLogger = MyLogger(self.__class__.__name__) self.myLogger.info('Init LightProcess') self.redisServer = redis.Redis(host='localhost', port=6379, db=0) self.gpioController = GPIOController()
def __init__(self): self.myLogger = MyLogger(self.__class__.__name__) self.myLogger.info('Init DryModeProcess') self.redisServer = redis.Redis(host='localhost', port=6379, db=0)
class DryModeProcess(object): def __init__(self): self.myLogger = MyLogger(self.__class__.__name__) self.myLogger.info('Init DryModeProcess') self.redisServer = redis.Redis(host='localhost', port=6379, db=0) def process(self, stop_event): count = 0 # loop a couple of times for simulation while count < 5 and not stop_event.is_set(): count += 1 time.sleep(5) try: self.myLogger.info('Starte RadioBob') self.redisServer.set(RadioSwitch.selected_radiostation, RadioSwitch.radioBob) time.sleep(10) self.myLogger.info('Starte hr3') self.redisServer.set(RadioSwitch.selected_radiostation, RadioSwitch.hr3) time.sleep(10) except: # catch *all* exceptions self.redisServer.set(RadioSwitch.selected_radiostation, RadioSwitch.radio_off) self.myLogger.debug( "Set selected radiostation on default %s." % RadioSwitch.radio_off) e = sys.exc_info()[0] self.myLogger.error("Error: %s" % e) self.myLogger.info("Stop event is set. Stop dry mode process.")
class SwitchWatcherProcess(object): def __init__(self): self.myLogger = MyLogger(self.__class__.__name__) self.myLogger.info('Init SwitchWatcherProcess') self.redisServer = redis.Redis(host='localhost', port=6379, db=0) self.gpioController = GPIOController() def process(self, stop_event): while not stop_event.is_set(): time.sleep(1) try: gpio_radio_bob = self.gpioController.request( GPIOController.gpio_radio_bob_switch) self.myLogger.debug("State of RadioBob switch: %s" % gpio_radio_bob) gpio_radio_hr3 = self.gpioController.request( GPIOController.gpio_hr3_switch) self.myLogger.debug("State of HR3 switch: %s" % gpio_radio_hr3) gpio_free_station = self.gpioController.request( GPIOController.gpio_free_station_switch) self.myLogger.debug("State of free station switch: %s" % gpio_free_station) if gpio_radio_bob == 1: self.myLogger.debug("Switch to %s" % RadioSwitch.radioBob) self.redisServer.set(RadioSwitch.selected_radiostation, RadioSwitch.radioBob) continue if gpio_radio_hr3 == 1: self.myLogger.debug("Switch to %s" % RadioSwitch.hr3) self.redisServer.set(RadioSwitch.selected_radiostation, RadioSwitch.hr3) continue if gpio_free_station == 1: self.myLogger.debug("Switch to %s" % RadioSwitch.airplay) self.redisServer.set(RadioSwitch.selected_radiostation, RadioSwitch.airplay) continue self.myLogger.debug("No switch is pressed.") self.redisServer.set(RadioSwitch.selected_radiostation, RadioSwitch.radio_off) except: # catch *all* exceptions e = sys.exc_info()[0] self.myLogger.error("Error: %s" % e) self.myLogger.info("Stop event is set. Stop %s" % self.__class__.__name__)