def configure_log(logdir=logdir, level=logging.WARNING, name=None):
logger = logging.getLogger(name)
for hdlr in logger.handlers[:]:
logger.removeHandler(hdlr)
logger.setLevel(level)
logger.propagate = False
logging.getLogger("requests").setLevel(logging.CRITICAL)
filename = "oftmatrix.log"
if name is not None:
filename = "oftmatrix.{}.log".format(name)
fileHandler = logging.FileHandler(filename=os.path.join(logdir, filename))
fileHandler.setFormatter(mainLogFormatter)
logger.addHandler(fileHandler)
logger.addHandler(mainConsoleHandler)
config = ConfigReader()
alertemails = config.get('logging', 'error_alertemails')
if len(alertemails) > 0:
smtpHandler = BufferingMailgunHandler(
toaddrs=alertemails,
fromaddr=config.get('logging', 'error_fromaddr'),
mailgunconfig=config.get('logging', 'mailgunconfig'),
subject="Error in OFTMatrix",
capacity=10)
smtpHandler.setFormatter(mainLogFormatter)
smtpHandler.setLevel(logging.ERROR)
logger.addHandler(smtpHandler)
def main():
config = ConfigReader()
loglevel = logging.INFO
if config.get("logging", "loglevel"):
numeric_level = getattr(logging,
config.get("logging", "loglevel").upper(),
None)
if not isinstance(numeric_level, int):
raise ValueError('Invalid log level: %s' % loglevel)
loglevel = numeric_level
configure_log(level=loglevel)
configure_log(name="werkzeug", level=logging.INFO)
installThreadExcepthook()
def uncaught_exception_handler(exc_type, exc_value, exc_traceback):
logging.info('haha wtf {}'.format(exc_traceback))
logging.error("Uncaught exception",
exc_info=(exc_type, exc_value, exc_traceback))
sys.excepthook = uncaught_exception_handler
wsthread = WebServerThread(app)
wsthread.start()
global CONFIG
CONFIG = load_config()
logging.info('config loaded {}'.format(CONFIG))
oftmatrix.run()
try:
wd.run()
except:
pass
initialize_matrix()
try:
while 1:
time.sleep(1)
except KeyboardInterrupt:
logging.info("shutdown has been initiated from the console...")
oftmatrix.stop()
try:
wd.stop()
except:
pass
wsthread.stop_server()
def __init__(self, config_file):
if path.exists(config_file) and path.isfile(config_file):
conf = ConfigReader(config_file)
self.output = conf.get("output")
self.output_file = conf.get("output_file")
self.level = conf.get("level")
self.__log_levels = {
"debug": 10,
"info": 20,
"warning": 30,
"error": 40,
"critical": 50,
}
self.message_format = conf.get("message_format")
self.date_format = conf.get("date_format")
self.formatter = Formatter(self.level, self.message_format,
self.date_format)
else:
raise IOError("Can't find configuration file.")
def __init__(self, config_file):
if path.exists(config_file) and path.isfile(config_file):
conf = ConfigReader(config_file)
self.output = conf.get("output")
self.output_file = conf.get("output_file")
self.level = conf.get("level")
self.__log_levels = {
"debug": 10,
"info": 20,
"warning": 30,
"error": 40,
"critical": 50,
}
self.message_format = conf.get("message_format")
self.date_format = conf.get("date_format")
self.formatter = Formatter(
self.level, self.message_format, self.date_format)
else:
raise IOError("Can't find configuration file.")
class InputReceiver():
def __init__(self):
self.oP = OutPipe("InputReceiver", 0)
self.cR = ConfigReader(GAME_PATH + "controls")
self.sE = ScriptExecuter()
self.eI = EngineInterface(objectMode=False)
self.keyboard = self.eI.getKeyboard()
self.mouse = self.eI.getMouse()
self.tH = TypingHandler(self.keyboard)
self.pairs = {}
self.responses = {}
self.oldKeyboard = self.keyboard.events
self.oldMouse = self.mouse.events
self.sE.addContext("Input", self)
self.sE.execute(INPUT_PATH + "csp")
self.sE.execute(INPUT_PATH + "input")
self.keyEvents = []
self.readControls()
self.locked = False
self.xsens = 50
self.ysens = 50
self.inverted = 0
self.predict = False
self.recent = {}
self.oP("Initialized.")
def addEvent(self, event):
if not event in self.recent.keys():
self.keyEvents.append(["INPUT", "COMMAND", event])
if not type(event) == type(tuple()):
self.recent[event] = time.time()
if self.predict:
self.callClientSidePrediction(event)
def callClientSidePrediction(self, event):
if not type(event) == type(tuple()):
if hasattr(self, "csp_" + event):
getattr(self, "csp_" + event)()
else:
if hasattr(self, "csp_look"):
getattr(self, "csp_look")(event)
def readControls(self):
keys = self.cR.getAllOptions("CONTROLS")
for key in keys:
keyString = self.cR.get("CONTROLS", key)
keyCode = self.eI.getKeyCode(keyString)
try:
self.pairs[keyCode] = getattr(self, key)
self.oP("Read in key response %s successfully." % key)
except:
self.oP("Failed to read in key response %s successfully." %
key)
def checkControls(self):
for keyCode in self.pairs.keys():
if keyCode in self.keyboard.events and not self.locked:
if self.keyboard.events[keyCode] == self.eI.l.KX_INPUT_ACTIVE:
self.callCommand("KEYBOARD", keyCode)
elif self.keyboard.events[
keyCode] == self.eI.l.KX_INPUT_JUST_ACTIVATED:
self.callCommand("KEYBOARD", keyCode)
elif self.keyboard.events[
keyCode] == self.eI.l.KX_INPUT_JUST_RELEASED:
self.callCommand("KEYBOARD", keyCode)
elif keyCode in self.mouse.events:
if self.mouse.events[keyCode] == self.eI.l.KX_INPUT_ACTIVE:
self.callCommand("MOUSE", keyCode)
elif self.mouse.events[
keyCode] == self.eI.l.KX_INPUT_JUST_ACTIVATED:
self.callCommand("MOUSE", keyCode)
elif self.mouse.events[
keyCode] == self.eI.l.KX_INPUT_JUST_RELEASED:
self.callCommand("MOUSE", keyCode)
self.oldKeyboard = self.keyboard.events
self.oldMouse = self.mouse.events
#Handle the "recent" spam blocker
keys = self.recent.keys()
for key in keys:
if abs(self.recent[key] - time.time()) > 0.1:
del self.recent[key]
break
if self.locked:
self.tH.process()
def callCommand(self, mode, keyCode):
if mode == "KEYBOARD":
state = self.getState(self.keyboard.events[keyCode],
self.oldKeyboard[keyCode])
elif mode == "MOUSE":
state = self.getState(self.mouse.events[keyCode],
self.oldMouse[keyCode])
consumed = False
if state == "DEACTIVATE" and keyCode in [
self.eI.e.LEFTMOUSE, self.eI.e.RIGHTMOUSE
]:
consumed = self.checkInterfaceClick(keyCode, self.mouse.position)
if not consumed and not keyCode in [
self.eI.e.MOUSEX, self.eI.e.MOUSEY
]:
self.pairs[keyCode](state)
elif keyCode in [self.eI.e.MOUSEX, self.eI.e.MOUSEY]:
pos = self.mouse.position
self.pairs[keyCode](pos)
def checkInterfaceClick(self, keyCode, pos):
return self.eI.getGlobal("client").inputClick(keyCode, pos)
def getState(self, newstate, oldstate):
if newstate == self.eI.l.KX_INPUT_ACTIVE:
if oldstate == self.eI.l.KX_INPUT_ACTIVE:
return "ACTIVE"
elif oldstate == self.eI.l.KX_INPUT_NONE:
return "ACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_ACTIVATED:
return "ACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_RELEASED:
return "ACTIVATE"
if newstate == self.eI.l.KX_INPUT_NONE:
if oldstate == self.eI.l.KX_INPUT_ACTIVE:
return "DEACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_NONE:
return "INACTIVE"
elif oldstate == self.eI.l.KX_INPUT_JUST_ACTIVATED:
return "DEACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_RELEASED:
return "DEACTIVATE"
if newstate == self.eI.l.KX_INPUT_JUST_ACTIVATED:
if oldstate == self.eI.l.KX_INPUT_ACTIVE:
return "ACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_NONE:
return "ACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_ACTIVATED:
return "ACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_RELEASED:
return "ACTIVATE"
if newstate == self.eI.l.KX_INPUT_JUST_RELEASED:
if oldstate == self.eI.l.KX_INPUT_ACTIVE:
return "DEACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_NONE:
return "DEACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_ACTIVATED:
return "DEACTIVATE"
elif oldstate == self.eI.l.KX_INPUT_JUST_RELEASED:
return "DEACTIVATE"
from selenium import webdriver
from selenium.common.exceptions import NoSuchElementException, TimeoutException
from selenium.webdriver.chrome.options import Options as ChromeOptions
from selenium.webdriver.firefox.options import Options as FirefoxOptions
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as conditions
from selenium.webdriver.support import ui
from configreader import ConfigReader
os.environ['DISPLAY'] = ':0' # Set the display if set to run as cronjob
HOMEPAGE = 'http://myaccount.telkom.co.ke'
TODAY = datetime.now()
config = ConfigReader('defaults.ini')
TITLE = config.get('notificationtitle', default='Telkom Balance')
NUMBER = config.get('number', section='credentials', default='')
PASSWD = config.get('pass', section='credentials', default='')
s = os.path.join(os.path.expanduser('~'), 'bin')
driver_path = config.get('driverspath', default=s)
chrome_driver_name = config.get('chromedrivername',
section='Chrome',
default='chromedriver')
firefox_driver_name = config.get('firefoxdrivername',
section='Firefox',
default='geckodriver')
headless = config.get('headless', default=True)
chrome_options = ChromeOptions()
firefox_options = FirefoxOptions()
if headless:
from configreader import ConfigReader
config = ConfigReader("../../res/test.cfg")
print config.get("name")
print config.get_string("name")
print config.get_int("some_int")
print config.get_float("some_float")
print config.get_long("some_long")
print config.get_boolean("some_bool")
print config.get_boolean("some_int")
print config.get_boolean("some_nonexistent_property")
from configreader import ConfigReader
config = ConfigReader("../../res/test.cfg")
print config.get("name")
print config.get_string("name")
print config.get_int("some_int")
print config.get_float("some_float")
print config.get_long("some_long")
print config.get_boolean("some_bool")
print config.get_boolean("some_int")
print config.get_boolean("some_nonexistent_property")
class Launcher():
def __init__(self):
#Remove engine log
try:
os.remove(ENGINE_PATH + "engine_log" + TEXT_EXT)
except:
pass
#Remove net logs
try:
for i in os.listdir(NET_PATH):
os.remove(NET_PATH + i)
except:
pass
#Create net path
try:
os.mkdir(NET_PATH)
except:
pass
self.oP = OutPipe("Launcher", 0)
for line in self.getSystemInfo():
self.oP(line)
self.cR = ConfigReader(ENGINE_PATH + "engine")
self.sE = ScriptExecuter()
self.eI = EngineInterface()
self.eI.preLoad()
self.eI.preLoadEpi()
#Sloppy, removes the blacker that covers up starting glitches
self.eI.getOverlayScene().objects["BlackScreen"].endObject()
self.sound = SoundEngine()
self.sound.preLoadAudio()
self.s = None
self.c = None
self.output = True
self.oP("Initialized.")
def enableShader(self, index, text):
self.oP("Activating shader pass #%i" % index)
controller = bge.logic.getCurrentController()
filterActuator = controller.actuators["filter"]
filterActuator.mode = bge.logic.RAS_2DFILTER_CUSTOMFILTER
filterActuator.passNumber = index
filterActuator.shaderText = text
controller.activate(filterActuator)
controller.deactivate(filterActuator)
def disableShader(self, index):
self.oP("Deactivating shader pass #%i" % index)
controller = bge.logic.getCurrentController()
filterActuator = controller.actuators["filter"]
filterActuator.mode = bge.logic.RAS_2DFILTER_DISABLED
filterActuator.passNumber = index
controller.activate(filterActuator)
controller.deactivate(filterActuator)
def bootSystem(self):
self.output = int(self.cR.get("LAUNCHER", "la_output"))
dedicated = int(self.cR.get("LAUNCHER", "la_dedicated"))
if dedicated:
lobby = int(self.cR.get("LAUNCHER", "la_dedicated_fast"))
self.bootServer()
self.s.configure("sv_game", lobby)
self.s.configure("sv_dedicated", 1)
else:
self.bootClient()
def getSystemInfo(self):
f = open(ENGINE_PATH + "system" + TEXT_EXT, "r")
try:
data = eval(f.read())
return [
"EpiEngine v%.2f" % data["version"],
"Built for BGE %.2f" % data["targetVersion"],
"Running %s %.2f" % (data["game"], data["gameVersion"]),
"Built %s" % data["date"],
]
except:
return "EpiEngine launching."
f.close()
def bootClient(self):
self.c = Client()
#self.sE.addContext("Client", self.c)
#self.sE.execute(bootScript)
for option in self.cR.getAllOptions("CLIENT"):
self.c.configure(option, self.cR.get("CLIENT", option))
def bootServer(self):
#bootScript = self.cR.get("SERVER", "sv_startscript")
#addr = self.cR.get("SERVER", "sv_addr")
#port = self.cR.get("SERVER", "sv_port")
self.s = Server()
#self.sE.addContext("Server", self.s)
#self.sE.execute(bootScript)
#
#self.s.configure("sv_addr", addr)
#self.s.configure("sv_port", int(port))
for option in self.cR.getAllOptions("SERVER"):
self.s.configure(option, self.cR.get("SERVER", option))
def configureServer(self, level, gamemode):
if self.s:
self.s.configure("level", level)
self.s.configure("gamemode", gamemode)
def loop(self):
self.sound.loop()
try:
if hasattr(self.c, "loop"):
self.c.loop()
except:
self.oP("Failure in client loop: %s" %
str(traceback.format_exc()))
try:
if hasattr(self.s, "loop"):
self.s.loop()
except:
self.oP("Failure in server loop: %s" %
str(traceback.format_exc()))
def pushConsoleCommand(self, command):
if hasattr(self, "s") and self.s:
self.s.pushConsoleCommand(command)
if hasattr(self, "c") and self.c:
self.c.pushConsoleCommand(command)
