def __init__(self):
# Variables
self.level_num = ""
self.curr_player = None
# Debug info
self.DEBUG = 1
self.DEBUG_TAG = "[Main]"
# Reads arguments from command line for which level to load
# If no argument is entered, 00 is rendered
if (len(sys.argv) > 1):
self.level_num = sys.argv[1]
else:
self.level_num = "00"
# Init pygame info
pygame.init()
self.display_surface = pygame.display.set_mode(
(GAME_X_DIM, GAME_Y_DIM))
pygame.display.set_caption(GAME_TITLE)
self.clock = pygame.time.Clock()
# Init EventHandler
self.event_handler = EventHandler()
# Build Level
self.lvl_builder = LevelBuilder(self.level_num)
self.curr_player = self.lvl_builder.getPlayer()
def main():
pygame.init()
# Just a couple of env variables.
size = width, height = 250, 250
black = (0, 0, 0)
screen = pygame.display.set_mode(size)
background = pygame.Surface(screen.get_size())
background = background.convert()
background.fill(black)
pygame.display.set_caption("Controller Logger")
# Initial screen render.
screen.blit(background, (0, 0))
pygame.display.flip()
# A little "progress" spinner. Let's me know things are running.
spinWheel = SpinWheel()
file = open('./Resources/Controller_Logger_Log.txt', 'a')
s = "\n******************************\n\
Launching Controller_Logger...\n\
******************************\n\n"
file.write(s)
# Setting up my spinner and frame clock.
allSprites = pygame.sprite.RenderPlain((spinWheel))
clock = pygame.time.Clock()
# Find and initialize all of the fancy plug-in devices.
s = "Joystick Initiailization: " + str(pygame.joystick.get_count()) + " Joystick(s) Detected\n"
print(s)
file.write(s)
for joys in range(0, pygame.joystick.get_count()):
joy = pygame.joystick.Joystick(joys)
joy.init()
Controller.bio(joy, file)
# Start the main render loop.
progRunMessage(file)
while 1:
# Keeps rendering at 60 frames/second.
clock.tick(60)
# Main event listener.
for event in pygame.event.get():
if event.type == pygame.QUIT:
return progRunDone(file)
else:
EventHandler.handle(event, file)
# Keep the spinner up-to-date.
allSprites.update()
# Keep the screen up-to-date.
screen.blit(background, (0, 0))
allSprites.draw(screen)
pygame.display.flip()
def FireAllKeys(self):
'''
Fire all keys in the keymap
'''
# Run through each action in the key map
for action, key in self.__keyMap.items():
if key.pressed:
Events.FireEvent(action, 0)
# If this is a toggle action, reset once action is fired once
if key.toggle:
key.pressed = False
# Now fire a redraw event
Events.FireEvent("REDRAW", 0)
def run_nth_best():
logger = BaseLogger()
for x in my_range(2, number_of_servers, 1):
entrance_gen = create_generator(enter_lambda, enter_dist)
limit_gen = create_generator(job_limit_lambda, job_limit_dist)
process_gen = create_generator(job_process_time_lambda, job_process_time_dist)
server_chooser = NthBestServerChooser(x)
cv_gen = LinearCVGenerator(number_of_servers, 0, 1)
handler = EventHandler(logger, entrance_gen, limit_gen, process_gen, cv_gen, server_chooser)
handler.handle_events()
logger.calculate_ehtemalat(x, entrance_number)
logger.calculate_cost_waiting(x)
logger.reset()
print x
logger.draw_cost_waiting_time()
def setup_bot(self):
"""
Setup routine for new bot. Does the following things:
1. Select virtual server specified by self.sid
2. Set bot nickname to the Name specified by self.bot_name
3. Move the bot to the channel specified by self.default_channel
4. Register command and event handlers
:return:
"""
try:
self.ts3conn.use(sid=self.sid)
except ts3.TS3Connection.TS3QueryException:
self.logger.exception("Error on use SID")
exit()
try:
self.channel = self.get_channel_id(self.default_channel)
self.ts3conn.clientupdate(["client_nickname=" + self.bot_name])
self.ts3conn.clientmove(self.channel,
int(self.ts3conn.whoami()["client_id"]))
except ts3.TS3Connection.TS3QueryException:
self.logger.exception("Error on setting up client")
self.ts3conn.quit()
return
self.command_handler = textcommands.CommandHandler(self.ts3conn)
self.event_handler = EventHandler.EventHandler(
ts3conn=self.ts3conn, command_handler=self.command_handler)
try:
self.ts3conn.register_for_server_events(
self.event_handler.on_event)
self.ts3conn.register_for_private_messages(
self.event_handler.on_event)
except ts3.TS3Connection.TS3QueryException:
self.logger.exception("Error on registering for events.")
exit()
def start(self):
c = Car.Car() # creating the Car object
e = EventHandler.EventHandler(
c
) # the event handler object is created. The Car object is passed as an argument
c.setEventHandler(e)
c.startCar() # method in car class is invoked to start the car
def __init__(self):
""" Initialisiert die Kamera, die Runtime und den Eventhandler. Ladet die Planeten und startet das Programm
"""
props = WindowProperties()
props.setTitle('Solarsystem')
base.win.requestProperties(props)
base.setBackgroundColor(0, 0, 0)
# The global variables we used to control the speed and size of objects
self.yearscale = 60
self.dayscale = self.yearscale / 365.0 * 5
self.orbitscale = 10
self.sizescale = 0.6
self.skySize = 80
self.runtime = RuntimeHandler()
self.camera = Camera(render, self.skySize)
self.loadLuminaries()
self.runtime.rotateLuminaries()
self.eventHandler = EventHandler(self.runtime, self.camera,
self.runtime.getLuminary('sun'))
def handle_keys():
global GUI_info
global current_menu
global draw_cursor
#Gets current menu to make sure we haven't tryed to change
menu_string = current_menu.title
key = libtcod.console_check_for_keypress() #real-time
if key.vk == libtcod.KEY_ENTER and key.lalt:
#Alt+Enter: toggle fullscreen
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
elif key.vk == libtcod.KEY_ESCAPE:
return True #exit game
#Handle the key press with the Event Handler
key_press = E.return_key()
#Pass that to the menu to figure out what to do with it
menu_string = current_menu.handle_input(key_press, GUI_info)
#Should we render the cursor?
if current_menu.title == "Look" or current_menu.title == "City":
draw_cursor = True
else:
draw_cursor = False
#Do we need to change our menu? Also check to make sure its not a null pointer
if menu_string != current_menu.title and menu_string is not None:
current_menu = menus[menu_string]
def run_nth_best():
logger = BaseLogger()
for x in my_range(2, number_of_servers, 1):
entrance_gen = create_generator(enter_lambda, enter_dist)
limit_gen = create_generator(job_limit_lambda, job_limit_dist)
process_gen = create_generator(job_process_time_lambda,
job_process_time_dist)
server_chooser = NthBestServerChooser(x)
cv_gen = LinearCVGenerator(number_of_servers, 0, 1)
handler = EventHandler(logger, entrance_gen, limit_gen, process_gen,
cv_gen, server_chooser)
handler.handle_events()
logger.calculate_ehtemalat(x, entrance_number)
logger.calculate_cost_waiting(x)
logger.reset()
print x
logger.draw_cost_waiting_time()
def run_simple():
logger = BaseLogger()
for x in my_range(0.2, 20, 0.1):
entrance_gen = create_generator(x, enter_dist)
limit_gen = create_generator(job_limit_lambda, job_limit_dist)
process_gen = create_generator(job_process_time_lambda, job_process_time_dist)
server_chooser = ServerChooser()
cv_gen = LinearCVGenerator(number_of_servers, 0, 1)
handler = EventHandler(logger, entrance_gen, limit_gen, process_gen, cv_gen, server_chooser)
handler.handle_events()
logger.calculate_ehtemalat(x, entrance_number)
logger.reset()
print x
logger.draw_served_probability()
logger.draw_blocked_probability()
logger.draw_leaved_probability()
def getExtraHandler(self):
returnValue = libpanda._inPziw5oC6_(self.this)
import EventHandler
returnObject = EventHandler.EventHandler(None)
returnObject.this = returnValue
if returnObject.this == 0:
return None
return returnObject.setPointer()
def eventFilter(self, obj, event: QEvent):
if obj == self.window and self.is_recording:
if event.type() == QEvent.MouseButtonPress:
self.write_to_table(EventHandler.invert_mouse_event(event))
elif event.type() == QEvent.KeyPress and not event.isAutoRepeat():
key = EventHandler.hook_key_event(event)
if key == True:
return True
self.write_to_table(QKeySequence(key).toString())
elif event.type() == QEvent.KeyRelease and event.key(
) == Qt.Key_Tab:
self.write_to_table(QKeySequence(Qt.Key_Tab))
else:
return False
try:
return QWidget.eventFilter(self, obj, event)
except RuntimeError:
return True
def run_simple():
logger = BaseLogger()
for x in my_range(0.2, 20, 0.1):
entrance_gen = create_generator(x, enter_dist)
limit_gen = create_generator(job_limit_lambda, job_limit_dist)
process_gen = create_generator(job_process_time_lambda,
job_process_time_dist)
server_chooser = ServerChooser()
cv_gen = LinearCVGenerator(number_of_servers, 0, 1)
handler = EventHandler(logger, entrance_gen, limit_gen, process_gen,
cv_gen, server_chooser)
handler.handle_events()
logger.calculate_ehtemalat(x, entrance_number)
logger.reset()
print x
logger.draw_served_probability()
logger.draw_blocked_probability()
logger.draw_leaved_probability()
def start_event_handler(s_util):
event_hand = EventHandler.EventHandler(s_util)
event_hand.add_event(10)
event_hand.get_event(10).add_trigger(1, 666)
event_hand.get_event(10).add_node_cmd_to_run("1234", "LIGHT_ON")
event_hand.add_event(11)
event_hand.get_event(11).add_trigger(1, 69)
event_hand.get_event(11).add_node_cmd_to_run("1234", "ALARM M**********R")
return event_hand
def __init__(self):
self.graph = Graph.graph()
self.listCities = Commands.listCitiesCmd(self.graph)
self.getCityInfo = Commands.getCityInfoCmd(self.graph)
self.getStats = Commands.getStatsCmd(self.graph)
self.getMap = Commands.getMapCmd(self.graph)
self.editDatabase = Commands.editDatabaseCmd(self.graph)
self.writeJSON = Commands.writeJSON(self.graph)
self.shortestRoute = Commands.findShortestRoute(self.graph)
self.addJSON = Commands.addJSON(self.graph)
self.quit = Commands.quitCmd(self.graph)
self.handler = EventHandler.handler(self.listCities, self.getCityInfo, self.getStats, self.getMap,
self.editDatabase, self.writeJSON, self.shortestRoute, self.addJSON, self.quit)
def setup_bot(self):
"""
Setup routine for new bot. Does the following things:
1. Select virtual server specified by self.sid
2. Set bot nickname to the Name specified by self.bot_name
3. Move the bot to the channel specified by self.default_channel
4. Register command and event handlers
:return:
"""
try:
self.ts3conn.use(sid=self.sid)
except ts3.TS3Connection.TS3QueryException:
self.logger.exception("Error on use SID")
exit()
try:
try:
self.ts3conn.clientupdate(["client_nickname=" + self.bot_name])
except TS3QueryException as e:
if e.type == TS3QueryExceptionType.CLIENT_NICKNAME_INUSE:
self.logger.info(
"The choosen bot nickname is already in use, keeping the default nickname"
)
else:
raise e
try:
self.channel = self.get_channel_id(self.default_channel)
self.ts3conn.clientmove(
self.channel, int(self.ts3conn.whoami()["client_id"]))
except TS3QueryException as e:
if e.type == TS3QueryExceptionType.CHANNEL_ALREADY_IN:
self.logger.info(
"The bot is already in the configured default channel")
else:
raise e
except TS3QueryException:
self.logger.exception("Error on setting up client")
self.ts3conn.quit()
return
self.command_handler = CommandHandler.CommandHandler(self.ts3conn)
self.event_handler = EventHandler.EventHandler(
ts3conn=self.ts3conn, command_handler=self.command_handler)
try:
self.ts3conn.register_for_server_events(
self.event_handler.on_event)
self.ts3conn.register_for_channel_events(
0, self.event_handler.on_event)
self.ts3conn.register_for_private_messages(
self.event_handler.on_event)
except ts3.TS3Connection.TS3QueryException:
self.logger.exception("Error on registering for events.")
exit()
def __init__(self):
super(MainWindow, self).__init__()
self.serialPort = SPCore.SerialPort()
self.setWindowIcon(AppIcon().getQIcon())
self.view = ViewController(self)
self.handler = EventHandler.handler(self)
self.view.bindEvents(self.handler)
self.serialPort.sendThread.autoSendError.connect(
self.handler.autoSendError)
self.serialPort.receiveThread.received.connect(
self.handler.receivedData)
self.serialPort.sendThread.error.connect(self.handler.serialIOError)
self.serialPort.receiveThread.error.connect(self.handler.serialIOError)
self.view.initComboBox(self.serialPort)
def __init__(self):
'''
Constructor
'''
# TODO: Replace redraw with an event? Better parallelism?
self.__redraw = True
# TODO: REMOVE HARD-CODED DIMENSIONS?
self.__window = Window(WINX, WINY)
self.__viewport = Viewport(WINX, WINY)
self.__objects = list()
self.__timer = Stopwatch()
self.__lastFrameTime = 0.0
self._modifiers = list()
Events.RegisterEvent("REDRAW", self.Redraw)
def main(watch_dir, logfile):
directory = ""
if len(watch_dir) > 0:
directory = watch_dir
else:
directory = DEFAULT_DIR
wm = pyinotify.WatchManager()
handler = EventHandler.EventHandler()
handler.openlog(logfile)
notifier = pyinotify.Notifier(wm, handler)
wdd = wm.add_watch(directory, EventHandler.mask, rec=True, auto_add=True)
notifier.loop()
def __init__(self, configuration):
global connection
""" initialise connection object. """
self.configuration = configuration
self.__conn_hooks__ = configuration.get_value('main', 'onconnect').split(',')
self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._setupdone, self._connected, self._registered, self._passrequired, self.debug = (False, False, False, False, False)
self.log = logging.getLogger('ashiema')
self.basic = Basic(self)
self._queue = Queue()
self._evh = EventHandler()
self.pluginloader = PluginLoader((self, self._evh))
self.scheduler = Scheduler()
self.tasks = {}
def __init__(self):
self.graph = Graph.graph()
self.listCities = Commands.listCitiesCmd(self.graph)
self.getCityInfo = Commands.getCityInfoCmd(self.graph)
self.getStats = Commands.getStatsCmd(self.graph)
self.getMap = Commands.getMapCmd(self.graph)
self.editDatabase = Commands.editDatabaseCmd(self.graph)
self.writeJSON = Commands.writeJSON(self.graph)
self.shortestRoute = Commands.findShortestRoute(self.graph)
self.addJSON = Commands.addJSON(self.graph)
self.quit = Commands.quitCmd(self.graph)
self.handler = EventHandler.handler(self.listCities, self.getCityInfo,
self.getStats, self.getMap,
self.editDatabase, self.writeJSON,
self.shortestRoute, self.addJSON,
self.quit)
def __init__(self, parent, id, title):
wx.Frame.__init__(self, parent, id, title, size=(600,600))
self.filename = ""
self.evt = EventHandler.EventHandler(self)
self.toolbar = self.ToolBar()
self.MenuBar()
self.SetMenuBar(self.menu)
self.statusbar = self.CreateStatusBar()
self.statusbar.SetStatusText('Ready')
# SideBar
self.sidebar = wx.Panel(self)
vbox = wx.BoxSizer(wx.VERTICAL)
vbox.Add(SideBar(self.sidebar),1,wx.EXPAND,0)
self.sidebar.SetSizer(vbox)
self.draw = DrawWindow.DrawWindow(self)
# Combine windows
hboxm = wx.BoxSizer(wx.HORIZONTAL)
hboxm.Add(self.sidebar,0,wx.EXPAND,0)
hboxm.Add(self.draw,1,wx.EXPAND,0)
vbox = wx.BoxSizer(wx.VERTICAL)
vbox.Add(hboxm,1, wx.EXPAND, 0)
wx.EVT_TOOL(self.toolbar, wx.ID_UNDO, self.evt.OnUndo)
wx.EVT_TOOL(self.toolbar, wx.ID_REDO, self.evt.OnRedo)
wx.EVT_MENU(self, wx.ID_UNDO, self.evt.OnUndo)
wx.EVT_MENU(self, wx.ID_REDO, self.evt.OnRedo)
wx.EVT_MENU(self, wx.ID_NEW, self.evt.OnNew)
wx.EVT_MENU(self, wx.ID_OPEN, self.evt.OnLoad)
wx.EVT_MENU(self, wx.ID_SAVE, self.evt.OnSave)
wx.EVT_MENU(self, wx.ID_SAVEAS, self.evt.OnSaveAs)
wx.EVT_MENU(self, wx.ID_CLOSE, self.evt.OnClose)
wx.EVT_MENU(self, wx.ID_EXIT, self.evt.OnQuit)
self.Bind(wx.EVT_MENU, self.evt.OnExport, self.exp)
# wx.EVT_MENU(self, wx.ID_ABOUT, self.evt.OnAbout)
self.zoom.Bind(wx.EVT_COMBOBOX, self.evt.OnZoom)
self.SetSizer(vbox)
self.Show(True)
def __init__(self, *args, **kwargs):
tk.Tk.__init__(self, *args, **kwargs)
self.wm_title("Chart Creator")
self.minsize(1000, 650)
self.event_handler = EventHandler.EventHandler()
self.protocol("WM_DELETE_WINDOW",
lambda: self.event_handler.event_for_exit(self))
self.data_series_combobox = None
self.chosen_color_label = None
self.chosen_type_label = None
self.chosen_color_preview_label = None
self.name_entry = None
self.canvas = None
self.plot = None
self.new_file = False
ChartCreator.chart_type = tk.StringVar()
ChartCreator.chosen_plot_label = None
def HandleInput(self, lstInput=[]):
if not self.control:
self.SubWindow[1].HandleInput(lstInput)
else:
for input in lstInput:
if input == "K_UP":
self.idxCursor -= 1
if self.idxCursor < 0:
self.idxCursor = len(self.lstMenus) - 1
self.objWindow.UpdateCursor(self.idxCursor)
#print(self.lstMenus[self.idxCursor][0])
if input == "K_DOWN":
self.idxCursor += 1
if self.idxCursor == len(self.lstMenus):
self.idxCursor = 0
self.objWindow.UpdateCursor(self.idxCursor)
#print(self.lstMenus[self.idxCursor][0])
if input == "K_LEFT":
self.DestroyWindow()
if input == "K_RIGHT":
#print("K_RIGHT")
if len(self.lstMenus[self.idxCursor]
[1]) != 0: #if list of submenus is not empty
font = pygame.font.SysFont("none", 32)
offsetX = font.size("-" +
self.lstMenus[self.idxCursor][0])[
0] # determine length idx
offsetY = font.size(
"I")[0] * self.idxCursor # get vertical location
offsetY += (self.intPadding * self.idxCursor
) #+ (self.intPadding * 2)
self.CreateNewSubWindow(
self.lstMenus[self.idxCursor][1],
offset=(offsetX, offsetY))
else:
objFiredEvent = str(self.lstMenus[self.idxCursor][2])
objFiredEventDetails = str(
self.lstMenus[self.idxCursor][3])
# line below is for debugging
print("Event Fired: " +
str(self.lstMenus[self.idxCursor][2]) + " - " +
self.lstMenus[self.idxCursor][0])
self.objEventHandler.RaiseEvent(
EventHandler.Event(objFiredEvent,
objFiredEventDetails))
#! /usr/bin/env python3
import os
os.chdir('/Users/ganglion/Documents/Projects/desktop_cleaner')
from pathlib import Path
from time import sleep
from watchdog.observers import Observer
import EventHandler
if __name__ == '__main__':
watch_path = Path.home() / 'Downloads'
destination_root = Path.home() / 'Downloads/holder of things'
event_handler = EventHandler.EventHandler(
watch_path=watch_path, destination_root=destination_root)
observer = Observer()
observer.schedule(event_handler, f'{watch_path}', recursive=True)
observer.start()
try:
while True:
sleep(60)
except KeyboardInterrupt:
observer.stop()
observer.join()
from AlertManagerLogger import *
from ApiManager import *
if __name__ == "__main__":
start = time.time()
# Setup logger
log = setupLogger('scheduler')
sessionKey = sys.stdin.readline().strip()
splunk.setDefault('sessionKey', sessionKey)
# Setup Helpers
am = ApiManager(sessionKey = sessionKey)
eh = EventHandler(sessionKey=sessionKey)
sh = SuppressionHelper(sessionKey=sessionKey)
#sessionKey = urllib.unquote(sessionKey[11:]).decode('utf8')
log.debug("Scheduler started. sessionKey=%s" % sessionKey)
# Check KV Store availability
while not am.checkKvStore():
log.warn("KV Store is not yet available, sleeping for 1s.")
time.sleep(1)
#
# Get global settings
#
config = {}
config['index'] = 'alerts'
async def startLoop():
e = EventHandler.EventHandler()
await e.init()
e.log("Boot: {} s".format(round(time.process_time(), 1)))
await e.dispatch([[e.startDetectionLoop], [e.server.serveforever],
[e.cook.cookingHandler], [e.energy.logEnergy]])
class Main(object):
'launches the game'
def __init__(self):
# Variables
self.level_num = ""
self.curr_player = None
# Debug info
self.DEBUG = 1
self.DEBUG_TAG = "[Main]"
# Reads arguments from command line for which level to load
# If no argument is entered, 00 is rendered
if (len(sys.argv) > 1):
self.level_num = sys.argv[1]
else:
self.level_num = "00"
# Init pygame info
pygame.init()
self.display_surface = pygame.display.set_mode(
(GAME_X_DIM, GAME_Y_DIM))
pygame.display.set_caption(GAME_TITLE)
self.clock = pygame.time.Clock()
# Init EventHandler
self.event_handler = EventHandler()
# Build Level
self.lvl_builder = LevelBuilder(self.level_num)
self.curr_player = self.lvl_builder.getPlayer()
def start(self):
if (self.DEBUG == 1):
print(self.DEBUG_TAG + ":start")
self.gameLoop(self.lvl_builder.getLevel())
def gameLoop(self, curr_level):
if (self.DEBUG == 1):
print(self.DEBUG_TAG + ":gameLoop")
# Game loop
while True:
if (self.DEBUG == 1):
print(self.DEBUG_TAG + " = = = = = = = = = = = = = = = = = =")
# Fill background
self.display_surface.fill((0, 0, 0))
# Captures events and handles them
for event in pygame.event.get():
self.event_handler.handleEvent(event, self.curr_player)
# Update
self.update(curr_level)
self.display_surface.unlock()
# Draw Entities
self.draw(curr_level)
self.display_surface.lock()
# Display update
pygame.display.update()
pygame.time.Clock().tick(GAME_FPS)
# update(self, curr_level)
# Updates data wrt Entities
def update(self, curr_level):
if (DEBUG == 1):
print(self.DEBUG_TAG + ":update")
entity_list = curr_level.getEntities()
for x in range(len(entity_list)):
y = entity_list[x]
if (y.getMovable() == True):
y.update()
# draw(self, curr_level)
# Prints to the Screen
def draw(self, curr_level):
if (self.DEBUG == 1):
print(self.DEBUG_TAG + ":draw")
# Draw the Walls
if (DEBUG == 1):
print(self.DEBUG_TAG + ":draw:Walls:" +
str(len(curr_level.getWalls())))
wall_list = curr_level.getWalls()
for x in range(len(wall_list)):
y = wall_list[x]
y.printWall()
pygame.draw.rect(self.display_surface, (169, 169, 169),
y.getHitbox(), 0)
# Draw the Entities
entity_list = curr_level.getEntities()
if (DEBUG == 1):
print(self.DEBUG_TAG + ":draw:Entities:" + str(len(entity_list)))
for x in range(len(entity_list)):
y = entity_list[x]
# Scale image to proper size
scaled_image = pygame.transform.scale(
y.getImage(), (y.getWidth(), y.getHeight()))
# Blits (draws) entity to surface
self.display_surface.blit(scaled_image, (y.getX(), y.getY()))
import EventOBJ
import EventHandler
import os
startMessage = "Welcome To Wake Scheduler\n1 -- View Events\n2 -- Add Event\n3 -- Remove Event\n4 -- End\n"
decision = 0
events = EventHandler.getAllEvents()
while decision != int(4):
print(startMessage)
decision = int(input("Please Enter What You Would Like To Do: "))
events = EventHandler.getAllEvents()
if decision == int(1):
if events.__len__() == 0:
print("No Events")
decision = 0
else:
events = EventHandler.getAllEvents()
for e in events:
print("Event: " + str(e.getTag()))
print("Date: " + e.getDate())
print("Time: " + e.getTime())
print("Description: " + e.getDescription())
print("Priority: " + e.getPriority())
print("---------------------------------\n")
decision = 0
elif decision == int(2):
date = input("Please Enter Date(Format M D Y): ")
time = input("Please Enter Time: ")
desc = input("Please Enter Description: ")
priority = input("Please Enter Priority: ")
log.info(
"Found job for alert '%s' with title '%s'. Context is '%s' with %s results."
% (search_name, config['title'], payload.get('app'), result_count))
# Get saved search config
savedSearch = getSavedSearch(payload.get('app'), search_name,
sessionKey)
log.debug("Parsed savedsearch settings: expiry=%s digest_mode=%s" %
(savedSearch['content']['alert.expires'],
savedSearch['content']['alert.digest_mode']))
# Parse ttl
ttl = getTTL(savedSearch['content']['alert.expires'])
# Get helpers
eh = EventHandler(sessionKey=sessionKey)
sh = SuppressionHelper(sessionKey=sessionKey)
# Create unique id
incident_id = str(uuid.uuid4())
# Get results and result id
results = getResults(payload.get('results_file'), incident_id)
result_id = getResultId(savedSearch['content']['alert.digest_mode'],
payload.get('results_file'))
# Prepare metadata
metadata = {}
metadata.update({'alert': search_name})
metadata.update({'alert_time': job['published']})
metadata.update({'app': payload.get('app')})
clock = pygame.time.Clock()
menu = Menu()
END_MUSIC_EVENT = pygame.USEREVENT + 0
pygame.mixer.music.set_endevent(END_MUSIC_EVENT)
sound = pygame.mixer.Sound("background.wav")
sound.play()
logic = Logic(pygame, screen)
ship = Ship(pygame, screen)
particle = Particle(pygame, screen,logic,0,0)
handler = EventHandler()
while clear():
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN or event.type == pygame.KEYUP:
handler.handle(event, pygame, screen, ship)
elif event.type == END_MUSIC_EVENT and event.code == 0:
sound.play()
logic.hit_ship()
if logic.win_game():
clear()
menu.draw_winner(pygame,screen,logic.score)
elif logic.is_game_over():
clear()
def save(self, contents, **kwargs):
logger.info("Saving incident settings contents...")
user = cherrypy.session["user"]["name"]
sessionKey = cherrypy.session.get("sessionKey")
splunk.setDefault("sessionKey", sessionKey)
eh = EventHandler(sessionKey=sessionKey)
config = {}
config["index"] = "alerts"
restconfig = entity.getEntities("configs/alert_manager", count=-1, sessionKey=sessionKey)
if len(restconfig) > 0:
if "index" in restconfig["settings"]:
config["index"] = restconfig["settings"]["index"]
logger.debug("Global settings: %s" % config)
# Parse the JSON
contents = json.loads(contents)
logger.debug("Contents: %s" % json.dumps(contents))
# Get key
query = {}
query["incident_id"] = contents["incident_id"]
logger.debug("Filter: %s" % json.dumps(query))
uri = "/servicesNS/nobody/alert_manager/storage/collections/data/incidents?query=%s" % urllib.quote(
json.dumps(query)
)
serverResponse, incident = rest.simpleRequest(uri, sessionKey=sessionKey)
logger.debug("Settings for incident: %s" % incident)
incident = json.loads(incident)
# Update incident
uri = "/servicesNS/nobody/alert_manager/storage/collections/data/incidents/" + incident[0]["_key"]
logger.debug("URI for incident update: %s" % uri)
# Prepared new entry
now = datetime.datetime.now().isoformat()
changed_keys = []
for key in incident[0].keys():
if (key in contents) and (incident[0][key] != contents[key]):
changed_keys.append(key)
logger.info(
"%s for incident %s changed. Writing change event to index %s."
% (key, incident[0]["incident_id"], config["index"])
)
event_id = hashlib.md5(incident[0]["incident_id"] + now).hexdigest()
event = (
'time=%s severity=INFO origin="incident_posture" event_id="%s" user="******" action="change" incident_id="%s" %s="%s" previous_%s="%s"'
% (now, event_id, user, incident[0]["incident_id"], key, contents[key], key, incident[0][key])
)
logger.debug("Change event will be: %s" % event)
input.submit(
event,
hostname=socket.gethostname(),
sourcetype="incident_change",
source="incident_settings.py",
index=config["index"],
)
incident[0][key] = contents[key]
else:
logger.info("%s for incident %s didn't change." % (key, incident[0]["incident_id"]))
del incident[0]["_key"]
contentsStr = json.dumps(incident[0])
logger.debug("content for update: %s" % contentsStr)
serverResponse, serverContent = rest.simpleRequest(uri, sessionKey=sessionKey, jsonargs=contentsStr)
logger.debug("Response from update incident entry was %s " % serverResponse)
logger.debug("Changed keys: %s" % changed_keys)
if len(changed_keys) > 0:
ic = IncidentContext(sessionKey, contents["incident_id"])
if "owner" in changed_keys:
eh.handleEvent(
alert=incident[0]["alert"], event="incident_assigned", incident=incident[0], context=ic.getContext()
)
elif "status" in changed_keys and contents["status"] == "resolved":
eh.handleEvent(
alert=incident[0]["alert"], event="incident_resolved", incident=incident[0], context=ic.getContext()
)
else:
eh.handleEvent(
alert=incident[0]["alert"], event="incident_changed", incident=incident[0], context=ic.getContext()
)
if contents["comment"] != "":
event_id = hashlib.md5(incident[0]["incident_id"] + now).hexdigest()
event = (
'time=%s severity=INFO origin="incident_posture" event_id="%s" user="******" action="comment" incident_id="%s" comment="%s"'
% (now, event_id, user, incident[0]["incident_id"], contents["comment"])
)
logger.debug("Comment event will be: %s" % event)
event = event.encode("utf8")
input.submit(
event,
hostname=socket.gethostname(),
sourcetype="incident_change",
source="incident_settings.py",
index=config["index"],
)
return "Done"
def save(self, contents, **kwargs):
logger.info("Saving incident settings contents...")
user = cherrypy.session['user']['name']
sessionKey = cherrypy.session.get('sessionKey')
splunk.setDefault('sessionKey', sessionKey)
eh = EventHandler(sessionKey = sessionKey)
config = {}
config['index'] = 'alerts'
restconfig = entity.getEntities('configs/alert_manager', count=-1, sessionKey=sessionKey)
if len(restconfig) > 0:
if 'index' in restconfig['settings']:
config['index'] = restconfig['settings']['index']
logger.debug("Global settings: %s" % config)
# Parse the JSON
contents = json.loads(contents)
logger.debug("Contents: %s" % json.dumps(contents))
# Get key
query = {}
query['incident_id'] = contents['incident_id']
logger.debug("Filter: %s" % json.dumps(query))
uri = '/servicesNS/nobody/alert_manager/storage/collections/data/incidents?query=%s' % urllib.quote(json.dumps(query))
serverResponse, incident = rest.simpleRequest(uri, sessionKey=sessionKey)
logger.debug("Settings for incident: %s" % incident)
incident = json.loads(incident)
# Update incident
uri = '/servicesNS/nobody/alert_manager/storage/collections/data/incidents/' + incident[0]['_key']
logger.debug("URI for incident update: %s" % uri )
# Prepared new entry
now = datetime.datetime.now().isoformat()
changed_keys = []
for key in incident[0].keys():
if (key in contents) and (incident[0][key] != contents[key]):
changed_keys.append(key)
logger.info("%s for incident %s changed. Writing change event to index %s." % (key, incident[0]['incident_id'], config['index']))
event_id = hashlib.md5(incident[0]['incident_id'] + now).hexdigest()
event = 'time=%s severity=INFO origin="incident_posture" event_id="%s" user="******" action="change" incident_id="%s" %s="%s" previous_%s="%s"' % (now, event_id, user, incident[0]['incident_id'], key, contents[key], key, incident[0][key])
logger.debug("Change event will be: %s" % event)
input.submit(event, hostname = socket.gethostname(), sourcetype = 'incident_change', source = 'incident_settings.py', index = config['index'])
incident[0][key] = contents[key]
else:
logger.info("%s for incident %s didn't change." % (key, incident[0]['incident_id']))
del incident[0]['_key']
contentsStr = json.dumps(incident[0])
logger.debug("content for update: %s" % contentsStr)
serverResponse, serverContent = rest.simpleRequest(uri, sessionKey=sessionKey, jsonargs=contentsStr)
logger.debug("Response from update incident entry was %s " % serverResponse)
logger.debug("Changed keys: %s" % changed_keys)
if len(changed_keys) > 0:
ic = IncidentContext(sessionKey, contents['incident_id'])
if "owner" in changed_keys:
eh.handleEvent(alert=incident[0]["alert"], event="incident_assigned", incident=incident[0], context=ic.getContext())
elif "status" in changed_keys and contents["status"] == "resolved":
eh.handleEvent(alert=incident[0]["alert"], event="incident_resolved", incident=incident[0], context=ic.getContext())
else:
eh.handleEvent(alert=incident[0]["alert"], event="incident_changed", incident=incident[0], context=ic.getContext())
if contents['comment'] != "":
event_id = hashlib.md5(incident[0]['incident_id'] + now).hexdigest()
event = 'time=%s severity=INFO origin="incident_posture" event_id="%s" user="******" action="comment" incident_id="%s" comment="%s"' % (now, event_id, user, incident[0]['incident_id'], contents['comment'])
logger.debug("Comment event will be: %s" % event)
event = event.encode('utf8')
input.submit(event, hostname = socket.gethostname(), sourcetype = 'incident_change', source = 'incident_settings.py', index = config['index'])
return 'Done'
#sys.stderr = open('/tmp/stderr', 'w')
start = time.time()
# Setup logger
log = logging.getLogger('alert_manager_scheduler')
fh = logging.handlers.RotatingFileHandler(os.environ.get('SPLUNK_HOME') + "/var/log/splunk/alert_manager_scheduler.log", maxBytes=25000000, backupCount=5)
formatter = logging.Formatter("%(asctime)-15s %(levelname)-5s %(message)s")
fh.setFormatter(formatter)
log.addHandler(fh)
log.setLevel(logging.INFO)
sessionKey = sys.stdin.readline().strip()
splunk.setDefault('sessionKey', sessionKey)
eh = EventHandler(sessionKey=sessionKey)
sh = SuppressionHelper(sessionKey=sessionKey)
#sessionKey = urllib.unquote(sessionKey[11:]).decode('utf8')
log.debug("Scheduler started. sessionKey=%s" % sessionKey)
#
# Get global settings
#
config = {}
config['index'] = 'alerts'
restconfig = entity.getEntities('configs/alert_manager', count=-1, sessionKey=sessionKey)
if len(restconfig) > 0:
if 'index' in restconfig['settings']:
config['index'] = restconfig['settings']['index']
from xml.dom import minidom
import json
import pprint
baseurl = 'https://localhost:8089'
username = '******'
password = '******'
myhttp = httplib2.Http(disable_ssl_certificate_validation=True)
# http://blogs.splunk.com/2011/08/02/splunk-rest-api-is-easy-to-use/
#Step 1: Get a session key
servercontent = myhttp.request(baseurl + '/services/auth/login',
'POST',
headers={},
body=urllib.urlencode({
'username': username,
'password': password
}))[1]
sessionkey = minidom.parseString(servercontent).getElementsByTagName(
'sessionKey')[0].childNodes[0].nodeValue
print "====>sessionkey: %s <====" % sessionkey
from EventHandler import *
incident = {}
incident["owner"] = "demo1"
eh = EventHandler(sessionKey=sessionkey, alert="demo_alert2_splunk_warnings")
eh.handleEvent(event="incident_created", incident=incident, context=incident)
#pp = pprint.PrettyPrinter(depth=6)
#pp.pprint(notif.getNotifications("incident_created"))
def RegisterEvents(self):
Events.RegisterEvent("KEYPRESS", self.ReceiveKeyPress)
def onAction(self, action):
EventHandler.onAction(self, action)
args_stdout = args_stdout + "namespace:%s" % alert_app + "\n"
log.debug("stdout args for %s: %s" %
(incident_config['alert_script'], args_stdout))
log.debug("args for %s: %s" % (incident_config['alert_script'], args))
try:
p = Popen(args, stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=False)
output = p.communicate(input=args_stdout)
log.debug("Alert script run finished. RC=%s. Output: %s" %
(p.returncode, output[0]))
except OSError, e:
log.debug("Alert script failed. Error: %s" % str(e))
log.info("Creating incident for job_id=%s" % job_id)
eh = EventHandler(sessionKey=sessionKey)
sh = SuppressionHelper(sessionKey=sessionKey)
###############################
# Incident creation starts here
# Create unique id
incident_id = str(uuid.uuid4())
# Parse results and result_id
results = getResults(job_path, incident_id)
result_id = getResultId(digest_mode, job_path)
# Get urgency from results and parse priority
job['urgency'] = readUrgencyFromResults(results, incident_config['urgency'],
incident_id)
def _update_incident(self, sessionKey, user, post_data):
logger.debug("START _update_incident()")
required = ['incident_data']
missing = [r for r in required if r not in post_data]
if missing:
return self.response("Missing required arguments: %s" % missing, httplib.BAD_REQUEST)
incident_data = post_data.pop('incident_data')
splunk.setDefault('sessionKey', sessionKey)
eh = EventHandler(sessionKey = sessionKey)
config = {}
config['index'] = 'main'
restconfig = entity.getEntities('configs/alert_manager', count=-1, sessionKey=sessionKey)
if len(restconfig) > 0:
if 'index' in restconfig['settings']:
config['index'] = restconfig['settings']['index']
logger.debug("Global settings: %s" % config)
# Parse the JSON
incident_data = json.loads(incident_data)
# Get key
query = {}
query['incident_id'] = incident_data['incident_id']
logger.debug("Filter: %s" % json.dumps(query))
uri = '/servicesNS/nobody/alert_manager/storage/collections/data/incidents?query=%s' % urllib.quote(json.dumps(query))
serverResponse, incident = rest.simpleRequest(uri, sessionKey=sessionKey)
logger.debug("Settings for incident: %s" % incident)
incident = json.loads(incident)
# Update incident
uri = '/servicesNS/nobody/alert_manager/storage/collections/data/incidents/' + incident[0]['_key']
logger.debug("URI for incident update: %s" % uri )
# Prepared new entry
now = datetime.datetime.now().isoformat()
changed_keys = []
for key in incident[0].keys():
if (key in incident_data) and (incident[0][key] != incident_data[key]):
changed_keys.append(key)
logger.info("%s for incident %s changed. Writing change event to index %s." % (key, incident[0]['incident_id'], config['index']))
event_id = hashlib.md5(incident[0]['incident_id'] + now).hexdigest()
event = 'time=%s severity=INFO origin="incident_posture" event_id="%s" user="******" action="change" incident_id="%s" %s="%s" previous_%s="%s"' % (now, event_id, user, incident[0]['incident_id'], key, incident_data[key], key, incident[0][key])
logger.debug("Change event will be: %s" % event)
input.submit(event, hostname = socket.gethostname(), sourcetype = 'incident_change', source = 'incident_settings.py', index = config['index'])
incident[0][key] = incident_data[key]
else:
logger.info("%s for incident %s didn't change." % (key, incident[0]['incident_id']))
del incident[0]['_key']
contentsStr = json.dumps(incident[0])
logger.debug("content for update: %s" % contentsStr)
serverResponse, serverContent = rest.simpleRequest(uri, sessionKey=sessionKey, jsonargs=contentsStr)
logger.debug("Response from update incident entry was %s " % serverResponse)
logger.debug("Changed keys: %s" % changed_keys)
if len(changed_keys) > 0:
ic = IncidentContext(sessionKey, incident_data['incident_id'])
if "owner" in changed_keys:
eh.handleEvent(alert=incident[0]["alert"], event="incident_assigned", incident=incident[0], context=ic.getContext())
elif "status" in changed_keys and incident_data["status"] == "resolved":
eh.handleEvent(alert=incident[0]["alert"], event="incident_resolved", incident=incident[0], context=ic.getContext())
else:
eh.handleEvent(alert=incident[0]["alert"], event="incident_changed", incident=incident[0], context=ic.getContext())
if incident_data['comment'] != "":
incident_data['comment'] = incident_data['comment'].replace('\n', '<br />').replace('\r', '')
event_id = hashlib.md5(incident[0]['incident_id'] + now).hexdigest()
event = 'time=%s severity=INFO origin="incident_posture" event_id="%s" user="******" action="comment" incident_id="%s" comment="%s"' % (now, event_id, user, incident[0]['incident_id'], incident_data['comment'])
logger.debug("Comment event will be: %s" % event)
event = event.encode('utf8')
input.submit(event, hostname = socket.gethostname(), sourcetype = 'incident_change', source = 'incident_settings.py', index = config['index'])
ic = IncidentContext(sessionKey, incident_data['incident_id'])
eh.handleEvent(alert=incident[0]["alert"], event="incident_commented", incident=incident[0], context=ic.getContext())
return self.response('Successfully updated incident.', httplib.OK)
config = getIncidentSettings(payload, settings, search_name)
# Get job details
job = getJob(job_id, sessionKey)
result_count = job['content']['resultCount']
log.info("Found job for alert '%s' with title '%s'. Context is '%s' with %s results." % (search_name, config['title'], payload.get('app'), result_count))
# Get saved search config
savedSearch = getSavedSearch(payload.get('app'), search_name, sessionKey)
log.debug("Parsed savedsearch settings: expiry=%s digest_mode=%s" % (savedSearch['content']['alert.expires'], savedSearch['content']['alert.digest_mode'] ))
# Parse ttl
ttl = getTTL(savedSearch['content']['alert.expires'])
# Get helpers
eh = EventHandler(sessionKey=sessionKey)
sh = SuppressionHelper(sessionKey=sessionKey)
# Create unique id
incident_id = str(uuid.uuid4())
# Get results and result id
results = getResults(payload.get('results_file'), incident_id)
result_id = getResultId(savedSearch['content']['alert.digest_mode'], payload.get('results_file'))
# Prepare metadata
metadata = {}
metadata.update({ 'alert': search_name })
metadata.update({ 'alert_time': job['updated'] })
metadata.update({ 'app': payload.get('app') })
# metadata.update({ 'entry': [ job ] })
args_stdout = "sessionKey:%s" % sessionKeyOrig + "\n"
args_stdout = args_stdout + "namespace:%s" % alert_app + "\n"
log.debug("stdout args for %s: %s" % (incident_config['alert_script'], args_stdout))
log.debug("args for %s: %s" % (incident_config['alert_script'], args))
try:
p = Popen(args, stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=False)
output = p.communicate(input=args_stdout)
log.debug("Alert script run finished. RC=%s. Output: %s" % (p.returncode, output[0]))
except OSError, e:
log.debug("Alert script failed. Error: %s" % str(e))
log.info("Creating incident for job_id=%s" % job_id)
eh = EventHandler(sessionKey=sessionKey)
sh = SuppressionHelper(sessionKey=sessionKey)
###############################
# Incident creation starts here
# Create unique id
incident_id = str(uuid.uuid4())
# Parse results and result_id
results = getResults(job_path, incident_id)
result_id = getResultId(digest_mode, job_path)
# Get urgency from results and parse priority
job['urgency'] = readUrgencyFromResults(results, incident_config['urgency'], incident_id)
job['priority'] = getPriority(job['impact'], job['urgency'])
from EventHandler import * EventHandle = EventHandler() print(EventHandle.Flag["init"]) EventHandle.keyhandle()
class Connection(object):
""" Connection object to manage the connection
to the uplink """
def __init__(self, configuration):
global connection
""" initialise connection object. """
self.configuration = configuration
self.__conn_hooks__ = configuration.get_value('main', 'onconnect').split(',')
self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._setupdone, self._connected, self._registered, self._passrequired, self.debug = (False, False, False, False, False)
self.log = logging.getLogger('ashiema')
self.basic = Basic(self)
self._queue = Queue()
self._evh = EventHandler()
self.pluginloader = PluginLoader((self, self._evh))
self.scheduler = Scheduler()
self.tasks = {}
""" information setup """
def setup_info(self, nick = '', ident = '', real = ''):
""" set up post connection info. """
self.nick = nick
self.ident = ident
self.real = real
self._setupdone = True
return self
def set_debug(self, debug = True):
""" set connection debug logging. """
self.debug = debug
return self
""" flag management """
def shutdown(self):
""" change the self._connection flag to shut down the bot """
# unload all plugins
self.pluginloader.unload()
# shut down all leftover apscheduler tasks
for task in self.tasks:
self.scheduler.unschedule_job(task)
# shut down the scheduler
self.scheduler.shutdown()
# change the value that controls the connection loop
self._connected = False
""" socket manipulation and management """
def connect(self, address = '', port = '', _ssl = None, password = None):
""" complete the connection process. """
assert self._setupdone is True, 'Information setup has not been completed.'
assert address and port, 'Parameters for connection have not been provided.'
_ssl = True if _ssl == True or _ssl == "True" or _ssl == "true" else False
if _ssl is True:
self.connection = ssl.wrap_socket(self._socket)
self.log.info("connection type: SSL")
elif _ssl is False:
self.connection = self._socket
self.log.info("connection type: plain")
else:
self.connection = self._socket
self.log.warning("connection type not specified, assuming plain.")
if password is not None:
self._passrequired, self._password = (True, password)
self._evh.load_default_events()
self.connection.connect((address, int(port)))
# we're connected!
self._connected = True
return self
def send(self, data):
""" function to add a line to the sendqueue to be sent. """
assert self._setupdone is True, 'Information setup has not been completed.'
assert self._connected is True, 'Connection to the uplink has not yet been established.'
self._queue.append(data.encode("UTF-8") + '\r\n')
def _raw_send(self, data):
""" allows sending of raw data directly to the uplink
assumes +data+ has received all necessary formatting to actually be read and processed by the uplink """
assert self._setupdone is True, 'Information setup has not been completed.'
assert self._connected is True, 'Connection to the uplink has not yet been established.'
data = data.decode('UTF-8', 'ignore')
self.connection.send(data.encode('UTF-8'))
def run(self):
""" runs the polling loop.
this should run off of two assertions:
self._connected is true, and self._setupdone is true."""
assert self._setupdone is True, 'Information setup has not been completed.'
assert self._connected is True, 'Connection to the uplink has not yet been established.'
# start the scheduler
self.scheduler.start()
# cycle counter
_cc = 1
while self._connected is True:
try:
# first, sleep so we don't slurp up CPU time like no tomorrow
time.sleep(0.005)
# send user registration if we're not already registered and about 35 cycles have passed
if not self._registered and _cc is 20:
if self._passrequired:
self.send("PASS :%s" % (self._password))
self._password = None
self.send("NICK %s" % (self.nick))
self.send("USER %s +iw %s :%s" % (self.nick, self.ident, self.real))
self._registered = True
# now, select.
r, w, e = select.select([self.connection], [], [self.connection], .025)
# now GO!
if self.connection in r:
self.parse(self.connection.recv(35000))
# check if im in the errors
if self.connection in e:
self._connected = False
self.log.severe("error during poll; aborting")
break
# process the data thats in the queue
try:
[self._raw_send(data) for data in [self._queue.pop() for count in xrange(0, 1)]]
except (AssertionError, QueueError) as e:
pass
except (KeyboardInterrupt, SystemExit) as e:
self.shutdown()
_cc += 1
except (KeyboardInterrupt, SystemExit) as e:
self.shutdown()
# what are we going to do after the loop closes?
self.log.info("shutting down.")
self.connection.close()
self._socket.close()
exit()
""" data parsing and event dispatch """
def parse(self, data):
assert self._connected is True, 'Connection to the uplink has not yet been established.'
data = data.split('\r\n')
for line in data:
# serialisation.
line = Serialise(line, (self, self._evh))
# fire off all events that match the data.
self._evh.map_events(line)
