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__)