def __init__(self): self._config: dict self.clients: list self._server_socket: socket.socket self.db_connector: Connector self.is_running: bool self._sel: selectors.DefaultSelector self.lock_clients: threading.RLock self._config = None self.clients = None self._server_socket = None self.db_connector = None self.is_running = False self._sel = None self.lock_clients = threading.RLock() EventManager.register_handler(CONNECT_CLIENT_EVENT, self._handle_connect_client) EventManager.register_handler(DISCONNECTED_CLIENT_EVENT, self._handle_disconnect_client) signal.signal(signal.SIGINT, self.stop)
def _accept_client(self): channel: socket.socket address: tuple channel, address = self._server_socket.accept() if len(self.clients) != self.max_client: client = Client(address, channel) # 소켓을 유용하고 편하게 사용하기 위해 Client 래퍼 객체로 생성 try: self._sel.register(client.channel, selectors.EVENT_READ, client) # selectors 이벤트 등록 self.clients[client] = client # 클라이언트 리스트 등록 EventManager.call_handler(CONNECT_CLIENT_EVENT, client=client) except socket.error as e: # todo: (try-except) 이제 이벤트 헨들러는 개별 스레드에서 처리하므로 try-except 필요가 없음 with client: if client != 2: client.close() else: # 최대 클라이언트 연결 수를 넘어갔을 경우 꽉 찼다는 메시지르 보내고 연결 종료 channel.sendall(make_message(FULL_CONN, self.host, address[0])) channel.close()
def _monitor_clients(self): while self.is_running: time.sleep(self.wait_term) now = time.time() with self.lock_clients: for client in list(self.clients): try: with client: if client.state == 2: return if client.last_receive_time is None or int( abs(now - client.last_receive_time) ) > self.wait_term: # 클라이언트의 마지막 수신 시각과 현재 시각을 비교해 heartbeat 전송 주기가 돌아오기 전까지 데이터가 수신한 적이 있는지 확인 if client.wait_count == self.max_wait_count: """ 클라이언트가 최대 heartbeat 허용 횟수를 넘긴 상태라면 연결이 끊긴 상태라고 판단하고 예외를 발생시켜 except 부분에서 클라이언트 종료 처리 """ raise Exception else: # 허용 횟수를 넘기지 않은 상태라면 heartbeat 메시지 전송 후 heartbeat 전송 횟수를 1 증가 시킴 send_message(HEARTBEAT, self.host, client) client.wait_count += 1 except Exception as e: with client: if client.state != 2: client.close() EventManager.call_handler( DISCONNECTED_CLIENT_EVENT, client=client)
def __del__(self): dead = [] for m in ResourceManager.mgrs: if not m(): dead.append(m) for m in dead: ResourceManager.mgrs.remove(m) EventManager.__del__(self)
class ClipboardPipeline(object): def __init__(self): super().__init__() self.event_manager = EventManager() def process_item(self, item, spider): self.event_manager.update(item['url'], item) return item def close_spider(self, spider): ScraperData.add_data(self.event_manager.events.values())
def __init__(self): """ :rtype: """ Timer.init() Renderer.init() self.__event = EventManager() self.__game_objects = {} self.__field = LogicField() self.__current_pu_yo: PuYo = None
class Game(EventListener): keyboard: Keyboard = None event_manager: EventManager = None controller: Controller = None state: GameState = None def __init__(self) -> None: self.event_manager = EventManager() super(Game, self).__init__(self.event_manager) self.inialize_pygame() self.clock: pygame.Clock = Clock() self.screen: pygame.Surface = pygame.display.set_mode( constants.SCREEN_SIZE) self.keyboard = Keyboard(self.event_manager) self.state = GameState.LOAD_SCREEN self.controller = LaunchController(self.event_manager, self.screen) def notify(self, event: Event) -> None: if event == Event.QUIT: pygame.quit() sys.exit() elif event == Event.TICK: # limit the redraw speed to 30 frames per second self.clock.tick(30) elif event == Event.OPEN_SETTINGS: self.open_settings() elif event == Event.CLOSE_SETTINGS: self.close_settings() def run(self) -> None: while True: self.event_manager.post(Event.TICK) def inialize_pygame(self) -> None: pygame.mixer.pre_init(44100, -16, 4, 2048) pygame.init() pygame.font.init() def open_settings(self) -> None: if self.state == GameState.SETTINGS: return self.state = GameState.SETTINGS self.controller = SettingsController(self.event_manager, self.screen) def close_settings(self) -> None: if self.state == GameState.LOAD_SCREEN: return self.state = GameState.LOAD_SCREEN self.controller = LaunchController(self.event_manager, self.screen)
def __init__(self) -> None: self.event_manager = EventManager() super(Game, self).__init__(self.event_manager) self.inialize_pygame() self.clock: pygame.Clock = Clock() self.screen: pygame.Surface = pygame.display.set_mode( constants.SCREEN_SIZE) self.keyboard = Keyboard(self.event_manager) self.state = GameState.LOAD_SCREEN self.controller = LaunchController(self.event_manager, self.screen)
def insert_arrived_action(cmdline, action, devices, actionexec, pos=-1, **kwargs): if action is None: spl = shlex.split(cmdline) if len(spl) > 1: action = ActionAction.create_action(spl[1:], devices) randid = -1 if action is not None: randid = int(spl[0]) action.set_randomid(randid) EventManager.fire( eventname='ActionParsed', randid=randid, action=action) actionexec.insert_action(action, pos) else: actionexec.insert_action(action, pos)
def __init__( self ): # Set the app to running self.running = True # Create the event manager self.events = EventManager( ) self.events.registerListener( AppListener() ) # Set the default app mode self.mode = 'menu' self.updateableObjects = { 'game': [], 'menu': [] }
def __init__(self, organization, base_url, start_date, end_date, date_format, request_date_format=None): self.organization = organization # date_format is the string that specifies the date style of the target website if request_date_format == None: request_date_format = date_format self.date_format = date_format self.time_utils = TimeUtils(date_format) self.base_url = base_url self.identifier = re.sub(r'\W', '', base_url) self.event_manager = EventManager() request_format_utils = TimeUtils('%m-%d-%Y') # When this is running for multiple days, validating if the date is in the past causes issues self.start_date = request_format_utils.convert_date_format( start_date, request_date_format, validate_past=False) self.end_date = request_format_utils.convert_date_format( end_date, request_date_format, validate_past=False) self.start_timestamp = request_format_utils.min_timestamp_for_day( start_date) self.end_timestamp = request_format_utils.max_timestamp_for_day( end_date)
class ClipboardPipeline(object): def __init__(self): super().__init__() self.event_manager = EventManager() def process_item(self, item, spider): self.event_manager.update(item['url'], item) return item def close_spider(self, spider): if len(self.event_manager.events) == 0: print('No data returned for ' + spider.base_url) spider.save_events([ event.to_dict() for event in list(self.event_manager.events.values()) ])
def __init__(self, name, label, width, height, show_fps, logging, alignment, default_node_width, default_node_height, bg_color, start_timers, structure_document, structure, hotkeys, initializer, events): super(Window, self).__init__(name, label, width, height, show_fps, logging, alignment, default_node_width, default_node_height, bg_color, start_timers, structure_document, structure, hotkeys, initializer, events) glutInitWindowSize(self.width, self.height) # the window starts at the upper left corner of the screen # TODO: hook up alignment with this! glutInitWindowPosition(0, 0) self.window = glutCreateWindow( self.label) # check if window ID is actually needed for something # glutFullScreen() # TODO: hook up this with conf! glutReshapeFunc(self.resize) glutVisibilityFunc(self.visibility) self.event_manager = EventManager(self.root_layout, self.hotkeys, self.events) setup_2D_projection(self.width, self.height)
class Context(object): __metaclass__ = abc.ABCMeta state = 1 #class attribute to be used as the singleton's attribute eventManager=EventManager() camera=None state=None idle=stat.Idle() active=stat.Active() processor=process.InputProcessor() usersConteiner=cont.UsersConteiner() @abc.abstractmethod def __init__(self): pass #this prevents instantiation! @classmethod def printSelf(cls): print(cls.state) #prints out the value of the singleton's state @classmethod def otro(cls): cls.state+=1 @classmethod def set_camera(cls, camera:camUtil.CameraInterface): cls.camera=camera cls.state=cls.idle cls.state.freeControl() @classmethod def stop(cls): cls.idle.suspend() cls.active.suspend()
def __init__(self, journalfile=None): self.eventManager = EventManager() self.journaller = Journaler(journalfile) self.sessions = {} # We load all sessions from the journal and add to our list for session in self.journaller.sessions(): self.sessions[session.key] = session
def run_server(): bot = None cam = None try: try: app.bot_config = Config.read() bot = CoderBot.get_instance( servo=(app.bot_config.get("move_motor_mode") == "servo"), motor_trim_factor=float( app.bot_config.get('move_motor_trim', 1.0))) audio = Audio.get_instance() audio.say(app.bot_config.get("sound_start")) try: cam = Camera.get_instance() Motion.get_instance() except picamera.exc.PiCameraError: logging.error("Camera not present") CNNManager.get_instance() EventManager.get_instance("coderbot") if app.bot_config.get('load_at_start') and app.bot_config.get( 'load_at_start'): app.prog = app.prog_engine.load( app.bot_config.get('load_at_start')) app.prog.execute() except ValueError as e: app.bot_config = {} logging.error(e) bot.set_callback(PIN_PUSHBUTTON, button_pushed, 100) remove_doreset_file() app.run(host="0.0.0.0", port=5000, debug=True, use_reloader=False, threaded=True) finally: if cam: cam.exit() if bot: bot.exit() app.shutdown_requested = True
def close(self): """ uninitial the koan lib. @rtype: None """ koan.animManager.pooling() print '[Kernel.py] Before Fire Close' self.fire('Close') koan.animManager.pooling() if self._window: self._window.SetCore(None) self._window.Close() self._window = None EventManager.clear(self)
def _receive_client_message(self, client: Client): try: with client: client.last_receive_time = time.time() client.wait_count = 0 # 수신 한 경우 heartbeat 누적 수를 초기화 # todo: Cleint receive 함수 내부에 처리할것 header_bytes = client.receive(13) # 헤더 사이즈 만큼 버퍼에서 가져옴 # todo: 사이즈가 작긴 하지만 이 부분도 아래 BODY 데이터를 가지고 오는 것처럼 처리를 해줘야함 (Client receive 함수 내에 처리) if not header_bytes: if client.state != 2: client.close() EventManager.call_handler(DISCONNECTED_CLIENT_EVENT, client=client) # todo: 이벤트 호출자가 제어하지 않고, 함수 안에서 실행을 제어하도록 변경 # 예) 클라이언트 연결 이벤트에서 헨들러 A가 실행할때 어떠한 이유로 클라이언트를 종료시킨 경우 다음 번에 실행될 # (이벤트에 대한 헨들러들이 순차적으로 실행됨) 클라이언트 연결 이벤트 헨들러 B가 실행 되면 안되므로 return header = Header.decode(header_bytes) if not header: return body_bytes = client.receive(header.SIZE) # body 크기는 가변 적이므로 header에서 body 사이즈를 알아낸 후 버퍼에서 가져옴 while len(body_bytes) < header.SIZE: body_bytes += client.receive(header.SIZE - len(body_bytes)) # 서버 상황상 명시한 사이즈 만큼 데이터를 가지고 온다는 보장이 없으므로, 완전할때까지 버퍼에서 가져옴 receive_message(client, Message(header, body_bytes)) except Exception as e: # 연결 혹은 받아온 데이터에 문제가 있으면 연결을 끊는거로 처리하고 있음 with client: if client.state != 2: client.close() EventManager.call_handler(DISCONNECTED_CLIENT_EVENT, client=client)
def main(): ev_manager = EventManager() main_frame = MainFrame(ev_manager) spinner = CPUSpinnerController(ev_manager) keybd = KeyboardController(ev_manager) ai = Agent(ev_manager) app = App(ev_manager) spinner.run()
def __init__(self, parent): QtCore.QObject.__init__(self, parent) # Fix later self.__active = None self.__settings = None self.__panel_types = {} self.__panels = [] self.__workspaces = list(self.Defaults) # TODO: a more official way to register panels. self.registerPanelType("JobWrangler", JobWranglerPanel) self.registerPanelType("Render Watch", RenderJobWatchPanel) self.registerPanelType("Tasks", TaskPanel) self.registerPanelType("Clusters", ClusterPanel) self.registerPanelType("Nodes", NodePanel) self.registerPanelType("Logs", LogsPanel) self.registerPanelType("Properties", PropertiesPanel) EventManager.bind("GLOBAL_REFRESH", self.refresh)
class Game: def __init__(self): """ :rtype: """ Timer.init() Renderer.init() self.__event = EventManager() self.__game_objects = {} self.__field = LogicField() self.__current_pu_yo: PuYo = None def run(self): is_continue = True while is_continue: is_continue = self.__update() self.__render() def __update(self) -> bool: Timer.capture_time() current_event = self.__event.get_event() if isinstance(current_event, event.GameExitEvent): return False self.__field.update(current_event) self.__field.set_game_objects(tuple(self.__game_objects.values())) for game_object in self.__game_objects.values(): assert isinstance(game_object, GameObject) game_object.update(current_event) current_pu_yo = self.__current_pu_yo if not current_pu_yo or not current_pu_yo.valid: new_pu_yo = PuYo(self.__field) self.__current_pu_yo = new_pu_yo self.__game_objects[new_pu_yo.id] = new_pu_yo return True def __render(self): if not Renderer.render_begin(self.__field.renderer): return for game_object in self.__game_objects.values(): assert isinstance(game_object, GameObject) game_object.render() Renderer.render_end()
def run_server(): bot = None cam = None try: try: app.bot_config = Config.read() bot = CoderBot.get_instance(servo=(app.bot_config.get("move_motor_mode") == "servo"), motor_trim_factor=float(app.bot_config.get('move_motor_trim', 1.0))) audio = Audio.get_instance() audio.say(app.bot_config.get("sound_start")) try: cam = Camera.get_instance() Motion.get_instance() except picamera.exc.PiCameraError: logging.error("Camera not present") CNNManager.get_instance() EventManager.get_instance("coderbot") if app.bot_config.get('load_at_start') and app.bot_config.get('load_at_start'): app.prog = app.prog_engine.load(app.bot_config.get('load_at_start')) app.prog.execute() except ValueError as e: app.bot_config = {} logging.error(e) bot.set_callback(PIN_PUSHBUTTON, button_pushed, 100) remove_doreset_file() app.run(host="0.0.0.0", port=5000, debug=True, use_reloader=False, threaded=True) finally: if cam: cam.exit() if bot: bot.exit() app.shutdown_requested = True
def __init__(self, id, domain): """ Init method """ self.id = id self.instancied = False self.event_name = "%s_on_set_value" % id self.e_mgr = EventManager() self.e_mgr.register_event(self.event_name) if len(domain) == 0: raise BTException() self.domain = domain if len(domain) == 1: self.set(domain[0]) else: self.value = None
def main(): # Initialize pygame pygame.init() # Initialize event manager event_manager = EventManager() # Initialize display, input, and game data display_manager = Display(event_manager) input_manager = InputController(event_manager) game_model = GameModel(event_manager) clock = ClockController(event_manager) # Run game clock.run()
def __init__(self): """ Init method """ self.constraints = [] self.variables = {} self.public_solutions = [] self.qstate = LifoQueue() self.phase = 'INIT' self.e_mgr = EventManager() self.e_mgr.register_event('solver_on_init') self.e_mgr.register_event('solver_on_end') self.e_mgr.register_event('solver_on_solution') self.e_mgr.register_event('solver_on_backtrack') self.e_mgr.register_event('solver_before_set_value') self.e_mgr.register_event('solver_after_set_value') self.e_mgr.raise_event('solver_on_init')
def __init__(self, structure, keys, events=None, constraints=None, ui_initializer=None, element_height=20): super(Application, self).__init__(structure, keys, events, constraints, ui_initializer, element_height) self.event_manager = EventManager(self.root_layout, keys, events) for event in ('mouse_x', 'mouse_y'): self.event_manager.key_events[BLENDER_KEYS[event]] = Event() self.event_manager.key_events[ BLENDER_KEYS[event]].press = check_state_events self.window_manager = WindowManager() self.root_layout.common.window_manager = self.window_manager self.root_layout.common.invert_y = True global app app = self
class TestEventManager(unittest.TestCase): """ Class for testing event.EventManager from cspy """ def setUp(self): """ Prepare the test """ self.e_mgr = EventManager() def test_singleton(self): """ Design pattern implemented correctly? """ self.assertEqual(self.e_mgr._Singleton__instance, EventManager()._Singleton__instance) def test_subscription(self): """ Events are created correctly a recieved? """ def function(**kwargs): """ Test function """ self.assertEqual(1, kwargs['test']) self.e_mgr.register_event('test_event') self.e_mgr.subscribe('test_event', function) self.e_mgr.raise_event('test_event', test=1)
sys.path.insert(0, '../google-calendar-api') from main import getService, createEvent, deleteEvent, editEvent # instantiate Slack client slack_client = SlackClient(os.environ.get('SLACK_BOT_TOKEN')) # starterbot's user ID in Slack: value is assigned after the bot starts up starterbot_id = None #AUTH_TOKEN = "xoxp-405504331811-405638712146-405402172724-6911eeb1abd04a212f2e0ab6661889f5" AUTH_TOKEN = "xoxb-405504331811-404929513808-vyzBLNNvgwh0TOqVyYggUxZl" # constants RTM_READ_DELAY = 1 # 1 second delay between reading from RTM EXAMPLE_COMMAND = "do" MENTION_REGEX = "^<@(|[WU].+?)>(.*)" em = EventManager(slack_client, AUTH_TOKEN) # google calendar google_service = getService('token.json', 'credentials.json') def parse_bot_commands(slack_events): """ Parses a list of events coming from the Slack RTM API to find bot commands. If a bot command is found, this function returns a tuple of command and channel. If its not found, then this function returns None, None. """ for event in slack_events: if event["type"] == "message" and not "subtype" in event: user_id, message = parse_direct_mention(event["text"]) sender = event["user"]
class SolverVariable(): """ Varible class for cspy Solver. Each Variable has a domain. When a variable is set an unique event is raised. """ def __init__(self, id, domain): """ Init method """ self.id = id self.instancied = False self.event_name = "%s_on_set_value" % id self.e_mgr = EventManager() self.e_mgr.register_event(self.event_name) if len(domain) == 0: raise BTException() self.domain = domain if len(domain) == 1: self.set(domain[0]) else: self.value = None def _restore(self, domain): """ Restore domain to a previous domain """ self.domain = domain if len(domain) > 1: self.instancied = False self.value = None def set(self, val): """ Set the value to val and raise a event """ self.domain = [val] self.value = val self.instancied = True self.e_mgr.raise_event(self.event_name, id=self.id, value=val) def remove_from_domain(self, values): """ Remove values from domain. If domain had more than one value and after remove only have one the variable become set. """ # len before removing domain_len = len(self.domain) for value in values: if self.in_domain(value): self.domain.remove(value) # No values is an invalid states if len(self.domain) == 0: raise BTException() # Now the variable is set elif len(self.domain) == 1 and domain_len > 1: self.set(self.domain[0]) def subscribe(self, function): """ Subscribe to variable event """ self.e_mgr.subscribe(self.event_name, function) def in_domain(self, value): """ Is the value in the domain? """ return value in self.domain def min(self): """ Min posible value of the variable""" return min(self.domain) def max(self): """ Max posible value of the variable""" return max(self.domain) def __str__(self): """ String representation of the variable """ return str(self.domain)
class App( ): # -------- Init -------- # Constructor, creates the app and sets it to running. # # @return App def __init__( self ): # Set the app to running self.running = True # Create the event manager self.events = EventManager( ) self.events.registerListener( AppListener() ) # Set the default app mode self.mode = 'menu' self.updateableObjects = { 'game': [], 'menu': [] } self.colliders = [] # -------- Tick -------- # Process a single tick of the game loop. # # @param int frameTime Number of milliseconds passed since the previous tick. # @param int lifeTime Number of milliseconds since pygame initialised. # @return None def tick( self, frameTime, lifeTime ): if 'game' == self.mode: self.tickGame( frameTime, lifeTime ) else: self.tickMenu( frameTime, lifeTime ) # -------- Tick Game -------- # Process a single tick within the game mode. # # @param int frameTime Number of milliseconds passed since the previous tick. # @param int lifeTime Number of milliseconds since pygame initialised. # @return None def tickGame( self, frameTime, lifeTime ): # Fill with black config.screen.fill( config.settings['screen_fill'] ) # Update sprites print len(self.updateableObjects['game']) for obj in self.updateableObjects['game']: obj.update( int(frameTime), int(lifeTime) ) # Run checks on colliders for collider in self.colliders: collider.check( ) # Draw sprites rects = config.sprites.draw( config.screen ) #pygame.display.update( rects ) pygame.display.flip( ) # -------- Tick Menu -------- # Process a single tick within the menu mode. # # @param int frameTime Number of milliseconds passed since the previous tick. # @param int lifeTime Number of milliseconds since pygame initialised. # @return None def tickMenu( self, frameTime, lifeTime ): for obj in self.updateableObjects['menu']: pass def addUpdateableObject( self, mode, obj ): if obj not in self.updateableObjects[mode]: self.updateableObjects[mode].append( obj ) def removeUpdateableObject( self, mode, obj ): if obj in self.updateableObjects[mode]: self.updateableObjects[mode].remove( obj ) def addCollider( self, collider ): self.colliders.append( collider ) def setMode( self, mode ): self.mode = mode def setWorld( self, world ): self.world = world
def main(): board = Board(6, 5) board.init() board.fill_random() evtmgr = EventManager() cpu = CPUTickController(evtmgr) evtmgr.add(cpu) evtmgr.add(KeyboardController(evtmgr)) evtmgr.add(PygameController(evtmgr)) evtmgr.add(ModelController(evtmgr, board)) evtmgr.add(AnimationController(evtmgr, board)) evtmgr.trigger(InitEvent()) cpu.run()
def __init__(self): EventManager.__init__(self) self._window = None self.ending = False self.preIdleTime = time.time()
class Solver(object): """ Solve CSP problems getting all solutions """ PHASES = ['INIT', 'SOLVING', 'FINISHED'] def __init__(self): """ Init method """ self.constraints = [] self.variables = {} self.public_solutions = [] self.qstate = LifoQueue() self.phase = 'INIT' self.e_mgr = EventManager() self.e_mgr.register_event('solver_on_init') self.e_mgr.register_event('solver_on_end') self.e_mgr.register_event('solver_on_solution') self.e_mgr.register_event('solver_on_backtrack') self.e_mgr.register_event('solver_before_set_value') self.e_mgr.register_event('solver_after_set_value') self.e_mgr.raise_event('solver_on_init') def _push_state(self, variable, value): """ Store in qstate the value of the variable it going to be set next and the state of the all domains """ domain_dump = {} for var in self.variables.itervalues(): # store a copy of the domain domain_dump[var.id] = var.domain[:] self.qstate.put((variable.id, value, domain_dump)) def _pop_state(self): """ Restore previous state """ return self.qstate.get(False) def _back_to_previous_state(self): """ Go back to a previous valid state removing invalid values. If qstate become empty (there is no valid state) return false else true. """ while not self.qstate.empty(): state = self._pop_state() id_var = state[0] value = state[1] domain_dump = state[2] # Restore domains for id, domain in domain_dump.iteritems(): self.variables[id]._restore(domain) # Delete invalid value try: self.variables[id_var].remove_from_domain([value]) return True except: pass return False def reg_variable(self, variable): """ Register a variable to the problem. """ self.variables[variable.id] = variable def _public_solution(self): """ Store in public_solutions a id_variable -> value hash """ solution = {} for id_var, variable in self.variables.iteritems(): solution[id_var] = variable.value self.public_solutions.append(solution) return solution def next_variable(self): """ Choose what variable is the best to be instancied. """ for variable in self.variables.values(): if not variable.instancied: return variable def value(self, variable): """ Choose the better value to the variable. """ return variable.min() def solve(self): """ Get all solutions to the problem. """ while self.iter_solve(): pass return self.public_solutions def iter_solve(self): """ Get all the solutions one by one using a backtracking strategy.""" if self.phase == 'INIT': self.phase = 'SOLVING' elif not self._back_to_previous_state(): # No more solutions self.e_mgr.raise_event('solver_on_end') self.phase = 'FINISHED' return None while not self.all_instancied(): try: # Heuristic var = self.next_variable() value = self.value(var) self.e_mgr.raise_event('solver_before_set_value') self._push_state(var, value) var.set(value) self.e_mgr.raise_event('solver_after_set_value') except BTException, bte: if not self._back_to_previous_state(): # No more solutions self.phase = 'FINISHED' self.e_mgr.raise_event('solver_on_end') return None else: self.e_mgr.raise_event('solver_on_backtrack') # Solution solution = self._public_solution() self.e_mgr.raise_event('solver_on_solution') return solution
class Simulator(object): def __init__(self, network_file_path, configs): self.configs = configs self.file_path = network_file_path # Initialize the event manager self.mgr = EventManager() self.collector = DataCollector() # Read network in from file. with open(file_path, 'r') as yaml_file: network = yaml.load(yaml_file) # Initialize the network components self.hosts = {} for host_name in network['hosts']: self.hosts[host_name] = Host(host_name, self, self.collector) self.routers = {} if 'routers' in network: for router_name in network['routers']: self.routers[router_name] = Router(router_name, self) self.flows = {} for flow_dict in network['flows']: flow_name = flow_dict.keys()[0] flow_desc = flow_dict[flow_name] self.flows[flow_name] = Flow( flow_name, self, self.collector, self.hosts[flow_desc['source']] , self.hosts[flow_desc['destination']], flow_desc['amount'], flow_desc['start'] ) self.links = {} host_prefixes = ['H', 'S', 'T'] for link_dict in network['links']: link_name = link_dict.keys()[0] link_desc = link_dict[link_name] aname = link_desc['anode'] bname = link_desc['bnode'] ahost = self.hosts[aname] \ if aname[0] in host_prefixes else self.routers[aname] bhost = self.hosts[bname] \ if bname[0] in host_prefixes else self.routers[bname] link = Link( link_name, self, self.collector, link_desc['rate'] / 8.0, link_desc['delay'], link_desc['buffer'], link_desc['buffer'], ahost, bhost ) self.links[link_name] = link ahost.set_link(link) bhost.set_link(link) self.mgr.add_event(0.0, link.calculate_throughput, []) # Add initial events for each of the flows for flow in self.flows.values(): self.mgr.add_event(flow.start_t, flow.send_packet, []) if not configs['tcpreno']: self.mgr.add_event(flow.start_t, flow.tcp_fast_update, []) # Initialize the routing tables for router in self.routers.values(): router.init_routing_table() if len(self.routers) > 0: self.mgr.add_event(0.0, self.routers['R1'].send_rout_packet, []) self.mgr.add_event(self.mgr.t + configs['dynamic_routing_step'], self.start_dynamic_routing, []) def get_data(self): """Telling all of the objects to report their data.""" for flow in self.flows.values(): self.mgr.add_event(0.0, flow.report_rates, [0.1, 0, 0]) self.mgr.add_event(0.0, flow.report_link_rates, [0.2, {}]) for link in self.links.values(): self.mgr.add_event(0.0, link.report_occupancy, [0.1]) self.mgr.add_event(0.0, link.report_dropped, [0.1]) self.mgr.add_event(0.0, link.report_throughput, [0.5]) for host in self.hosts.values(): self.mgr.add_event(0.0, host.report_rates, [0.1, 0, 0]) def start_dynamic_routing(self): # Initialize the routing tables and send out routing packets for router in self.routers.values(): router.init_routing_table(temp_table=True) router.start_dynamic_routing() router.send_rout_packet(True) self.mgr.add_event(self.mgr.t + self.configs['dynamic_routing_step'], self.start_dynamic_routing, []) def check_done_dynamic_routing(self): time_step = 0.01 num_not_done = 0 for router in self.routers.values(): if not router.done_d_routing: num_not_done += 1 if num_not_done == 0: for router in self.routers.values(): router.finish_dynamic_routing() for link in self.links.values(): link.time_through_link_update() def run(self): # Starting data collection self.get_data() while self.mgr.has_events(): (t, event, args) = self.mgr.pop_event() self.mgr.t = t event(*args) # Check if all our flows have terminated flows_not_done = len(self.flows) for flow in self.flows.values(): if flow.last_acknowledged == flow.max_seq: flows_not_done -= 1 if flows_not_done == 0: break print 'Done with all events at time: {}'.format(self.mgr.t) def plot(self): # Get only the file_name file_name = self.file_path.split("/")[-1].rstrip(".yml") # Print the plots to pdf plot_dir = "plots/" # Whether or not its reno or fast if self.configs['tcpreno']: mode = '_reno' else: mode = '_fast' # Pdf page pp = PdfPages(plot_dir + file_name + mode + '.pdf') print 'Plotting to {}'.format(plot_dir + file_name + mode + '.pdf') collecs = self.collector.collection.keys() collecs.sort() for g in collecs: self.collector.graph_data(pp, g, g) if file_name =='testcase0': # The congestion window for the flow self.collector.graph_data(pp, 'F1 Congestion Window', 'F1_cwnd') elif file_name == 'testcase1': # The congestion window for the flow self.collector.graph_data(pp, 'F1 Congestion Window', 'F1_cwnd') # The link rates of L1 and L2 self.collector.combine_graphs( pp, 'Test Case 1 Link Rates', ['F1_L1_rate', 'F1_L2_rate'], labels=['L1', 'L2'] ) # The link rates of L3 and L4 self.collector.combine_graphs( pp, 'Test Case 1 Link Rates', ['F1_L3_rate', 'F1_L4_rate'], labels=['L3', 'L4'] ) elif file_name == 'testcase2': self.collector.combine_graphs( pp, 'Test Case 2 Flow Congestion Windows', ['F1_cwnd', 'F2_cwnd', 'F3_cwnd'], labels=['F1', 'F2', 'F3'] ) self.collector.combine_graphs( pp, 'Test Case 2 Buffer Occupancy', ['L1_a_occupancy', 'L2_a_occupancy', 'L3_a_occupancy'], labels=['L1a', 'L2a', 'L3a'] ) pp.close()
def close(self): self.clearAll() EventManager.close(self) self.window = koan.Null
def __init__(self): super().__init__() self.event_manager = EventManager()
def __init__(self, *argv, **argd): list.__init__(self, *argv, **argd) EventManager.__init__(self)
def __init__(self): super().__init__() self.file_fetch_dict = FileFetchDict() EventManager.register_handler(DISCONNECTED_CLIENT_EVENT, self._check_disconnect_client)
class App( ): # -------- Init -------- # Constructor, creates the app and sets it to running. # # @return App def __init__( self ): # Set the app to running self.running = True # Create the event manager self.events = EventManager( ) self.events.registerListener( AppListener() ) # Set the default app mode self.mode = 'menu' self.updateableObjects = { 'game': [], 'menu': [] } # -------- Tick -------- # Process a single tick of the game loop. # # @param int frameTime Number of milliseconds passed since the previous tick. # @param int lifeTime Number of milliseconds since pygame initialised. # @return None def tick( self, frameTime, lifeTime ): if 'game' == self.mode: self.tickGame( frameTime, lifeTime ) else: self.tickMenu( frameTime, lifeTime ) # -------- Tick Game -------- # Process a single tick within the game mode. # # @param int frameTime Number of milliseconds passed since the previous tick. # @param int lifeTime Number of milliseconds since pygame initialised. # @return None def tickGame( self, frameTime, lifeTime ): # Fill with black config.screen.fill( config.settings['screen_fill'] ) # Update sprites for obj in self.updateableObjects['game']: obj.update( int(frameTime), int(lifeTime) ) # Draw sprites rects = config.sprites.draw( config.screen ) #pygame.display.update( rects ) pygame.display.flip( ) # -------- Tick Menu -------- # Process a single tick within the menu mode. # # @param int frameTime Number of milliseconds passed since the previous tick. # @param int lifeTime Number of milliseconds since pygame initialised. # @return None def tickMenu( self, frameTime, lifeTime ): for obj in self.updateableObjects['menu']: pass def addUpdateableObject( self, mode, obj ): self.updateableObjects[mode].append( obj ) def setMode( self, mode ): self.mode = mode def setWorld( self, world ): self.world = world
def main(argv=None): # IGNORE:C0111 '''Command line options.''' if argv is None: argv = sys.argv else: sys.argv.extend(argv) program_name = os.path.basename(sys.argv[0]) program_version = "v%s" % __version__ program_build_date = str(__updated__) program_version_message = '%%(prog)s %s (%s)' % ( program_version, program_build_date) program_shortdesc = __import__('__main__').__doc__.split("\n")[1] program_license = '''%s Created by user_name on %s. Copyright 2016 organization_name. All rights reserved. Licensed under the Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 Distributed on an "AS IS" basis without warranties or conditions of any kind, either express or implied. USAGE ''' % (program_shortdesc, str(__date__)) try: # Setup argument parser parser = ap.ArgumentParser( description=program_license, formatter_class=ap.RawDescriptionHelpFormatter) parser.add_argument("-c", "--conf", dest="conf", action=ActionConf) parser.add_argument("-b", "--broadcast", dest="broadcast") parser.add_argument("-m", "--mqtt-host", dest="mqtt_host", type=valid_host) parser.add_argument("-k", "--mqtt-port", dest="mqtt_port", type=valid_port) parser.add_argument("-f", "--prime-host", dest="prime_host", type=valid_host) parser.add_argument("-y", "--prime-port", dest="prime_port", type=valid_port) parser.add_argument("-w", "--prime-port2", dest="prime_port2", type=valid_port) parser.add_argument("-q", "--prime-code", dest="prime_code", type=valid_code) parser.add_argument("-z", "--prime-pass", dest="prime_pass") parser.add_argument("-p", "--port", dest="port", type=valid_port) parser.add_argument("-s", "--tcpport", dest="tcpport", type=valid_port) parser.add_argument("-g", "--httpport", dest="httpport", type=valid_port) parser.add_argument("-t", "--timeout", dest="timeout", type=valid_timeout) parser.add_argument("-j", "--emitdelay", dest="emit_delay", type=valid_delay) parser.add_argument("-r", "--retry", dest="retry", type=valid_retry) parser.add_argument("-a", "--action", dest="actions", nargs='+', action=ActionAction) parser.add_argument('-x', '--active_on_finish', action='store_true', dest="active_on_finish") parser.add_argument('-V', '--version', action='version', version=program_version_message) parser.add_argument('-d', '--debug', action='store_true', dest="debug") parser.add_argument( '-e', '--remote', action='store_true', dest="remote") parser.set_defaults(conf=os.path.join(os.getcwd(), 'devices.xml'), devices={}, mqtt_host='', mqtt_port=1883, emit_delay=0, port=10000, tcpport=2802, httpport=2803, actions=[], broadcast='255.255.255.255', active_on_finish=False, timeout=1, retry=3, debug=False, remote=False, prime_host='', prime_port=80, prime_port2=6004, prime_code='', prime_pass='' ) def connect_devices(devices): for _, dv in devices.copy().items(): dv.connect_devices(devices) def add_discovered_devices(action, devices, mqtt_client, mqtt_userdata, emit_delay, **kwargs): for _, v in action.hosts.copy().items(): # _LOGGER.info("current "+k+" nm "+v.name+" lndv "+str(len(devices))) already_saved_device = None # _LOGGER.info("Confronto "+v.name) for _, dv in devices.copy().items(): # _LOGGER.info("VS "+v.name+'/'+dv.name) if v.mac == dv.mac: already_saved_device = dv break # elif v.name==dv.name: # _LOGGER.info("Are you sure? "+v.name+"->"+v.mac.encode('hex')+"/"+dv.mac.encode('hex')) if already_saved_device is None: # _LOGGER.info("changed "+str(v)) devices.update({v.name: v}) action.m_device = True else: already_saved_device.on_stop() v.copy_extra_from(already_saved_device) v.name = already_saved_device.name if isinstance(v, IrManager): v.set_emit_delay(emit_delay) devices.update({already_saved_device.name: v}) if mqtt_client and mqtt_client.is_connected(): v.mqtt_start(mqtt_client, mqtt_userdata) connect_devices(devices) def save_modified_devices(save_filename, save_devices, debug, device, action, **kwargs): # _LOGGER.info("lensv "+str(len(save_devices))) save = True if isinstance(action, ActionDiscovery): save = debug or action.modifies_device() elif isinstance(action, ActionViewtable): save = False if isinstance(action, ActionViewtable1): save = debug elif isinstance(action, ActionViewtable4): dn = device.default_name() if dn in save_devices and dn != device.name: del save_devices[dn] save_devices[device.name] = device save = True else: save = debug elif isinstance(device, DeviceS20): save = debug elif isinstance(device, IrManager): save = debug or action.modifies_device() elif isinstance(action, ActionStatechange) or isinstance(action, ActionSubscribe): save = debug if save: Device.save(save_devices, save_filename, (DEVICE_SAVE_FLAG_MAIN | DEVICE_SAVE_FLAG_TABLE) if debug else DEVICE_SAVE_FLAG_MAIN) def terminate_on_finish(actionexec, force=False, **kwargs): if force or actionexec.action_list_len() <= 1: _LOGGER.info("Terminating...") global term_called term_called = True def do_timer_action(device, timerobj, actionexec, **kwargs): act = ActionEmitir(device, *tuple(timerobj['action'].split(' '))) actionexec.insert_action(act) def insert_arrived_action(cmdline, action, devices, actionexec, pos=-1, **kwargs): if action is None: spl = shlex.split(cmdline) if len(spl) > 1: action = ActionAction.create_action(spl[1:], devices) randid = -1 if action is not None: randid = int(spl[0]) action.set_randomid(randid) EventManager.fire( eventname='ActionParsed', randid=randid, action=action) actionexec.insert_action(action, pos) else: actionexec.insert_action(action, pos) def handle_device_dl(action, devices, **kwargs): if action is not None: action.set_devices(devices) def process_state_change(hp, newstate, devices, mac, actionexec, **kwargs): _LOGGER.info(f'ExtStateChange {mac}') for _, dv in devices.items(): if mac == dv.mac: act = ActionNotifystate(dv, newstate) actionexec.insert_action(act, 1) def mqtt_subscribe(client, userdata, who, lsttopics): if userdata and userdata.mqtt_mid is not None: if isinstance(who, str): log = key = who else: key = str(id(who)) log = who.name _, mid = client.subscribe(lsttopics) userdata.mqtt_mid[key] = mid _LOGGER.info(f"Asked for subscription for {log} with mid {mid}") def mqtt_on_connect(client, userdata, flags, rc): if userdata.mqtt_mid is None and not rc: _LOGGER.info("__main__ connect") userdata.mqtt_mid = dict() mqtt_subscribe(client, userdata, "__main__", [("cmnd/#", 0,)]) for _, d in userdata.devices.items(): d.mqtt_start(client, userdata) else: _LOGGER.info(f"Ignoring connack rc {rc}") def mqtt_on_subscribe(client, userdata, mid, granted_qos): if userdata and userdata.mqtt_mid is not None: log = 'N/A' if "__main__" in userdata.mqtt_mid and userdata.mqtt_mid["__main__"] == mid: userdata.mqtt_mid["__main__"] = -1 log = "__main__" else: for _, d in userdata.devices.items(): key = str(id(d)) if key in userdata.mqtt_mid and userdata.mqtt_mid[key] == mid: userdata.mqtt_mid[key] = -1 log = d.name d.mqtt_on_subscribe(client, userdata, mid, granted_qos) break _LOGGER.info(f"{log} subscribed: mid={mid} qos={granted_qos}") def mqtt_on_message(client, userdata, msg): topic = msg.topic _LOGGER.info(f"Received {b2s(msg.topic)}, pay {b2s(msg.payload)}") i = topic.rfind("/") if i >= 0 and i < len(topic) - 1: sub = topic[i + 1:] if sub == "devicedl": resp = json.dumps(userdata.devices) client.publish("stat/devicedl", resp) else: for _, d in userdata.devices.items(): d.mqtt_on_message(client, userdata, msg) def mqtt_on_publish(client, userdata, mid): _LOGGER.info("Someone pub mid: " + str(mid)) def mqtt_on_disconnect(client, userdata, rc): _LOGGER.info("disconnect with rc: " + str(rc)) userdata.mqtt_mid = None def mqtt_init(hp, ud): ud.mqtt_mid = None ud.mqtt_subscribe = mqtt_subscribe client = paho.Client(userdata=ud, protocol=paho.MQTTv31) client.on_connect = mqtt_on_connect client.on_message = mqtt_on_message client.on_subscribe = mqtt_on_subscribe client.on_disconnect = mqtt_on_disconnect client.on_publish = mqtt_on_publish _LOGGER.info("mqtt_start (%s:%d)" % hp) client.connect_async(hp[0], port=hp[1]) client.loop_start() return client def mqtt_stop(client): client.on_disconnect = None client.loop_stop() client.disconnect() # Process arguments signal(SIGTERM, sigterm_handler) _LOGGER.info("Parsing args") args = parser.parse_args() mqtt_client = None if len(args.mqtt_host): mqtt_client = mqtt_init((args.mqtt_host, args.mqtt_port), args) _LOGGER.info(str(args)) _LOGGER.info(args.devices) connect_devices(args.devices) actionexec = ActionExecutor() if not args.active_on_finish: EventManager.on('ActionDone', terminate_on_finish, actionexec=actionexec) pars = {'save_filename': args.conf, 'save_devices': args.devices, 'debug': args.debug} EventManager.on('TimerAction', do_timer_action, actionexec=actionexec, **pars) EventManager.on('ActionDiscovery', add_discovered_devices, devices=args.devices, mqtt_client=mqtt_client, mqtt_userdata=args, emit_delay=args.emit_delay) EventManager.on('ExtInsertAction', insert_arrived_action, devices=args.devices, actionexec=actionexec) EventManager.on('ExtChangeState', process_state_change, actionexec=actionexec, devices=args.devices) EventManager.on('ActionDiscovery', save_modified_devices, **pars) EventManager.on('ActionLearnir', save_modified_devices, **pars) EventManager.on('ActionEditraw', save_modified_devices, **pars) EventManager.on('ActionSubscribe', save_modified_devices, **pars) EventManager.on('ActionViewtable1', save_modified_devices, **pars) EventManager.on('ActionInsertKey', save_modified_devices, **pars) EventManager.on('ActionViewtable3', save_modified_devices, **pars) EventManager.on('ActionViewtable4', save_modified_devices, **pars) EventManager.on('ActionStatechange', save_modified_devices, **pars) EventManager.on('ActionStateon', save_modified_devices, **pars) EventManager.on('ActionStateoff', save_modified_devices, **pars) EventManager.on('ActionCreatesh', save_modified_devices, **pars) EventManager.on('ActionDevicedl', handle_device_dl, devices=args.devices, **pars) EventManager.on('ActionExit', terminate_on_finish, actionexec=actionexec, force=True) actionexec.configure(args) if len(args.mqtt_host): actionexec.insert_action(ActionPause("5")) actionexec.insert_action(ActionDiscovery()) actionexec.insert_action(args.actions) stopped = False numv = 2 while threading.active_count() > 1 and numv > 1: try: time.sleep(1) if stopped: thl = threading.enumerate() rv = "" numv = 0 for th in thl: if not th.daemon: numv += 1 rv += th.name + " " _LOGGER.info("TH=%s" % rv) elif term_called: raise KeyboardInterrupt except KeyboardInterrupt: if not stopped: _LOGGER.info("Stopping") stopped = True actionexec.stop() if mqtt_client: mqtt_stop(mqtt_client) for _, k in args.devices.copy().items(): k.on_stop() return 0 except KeyboardInterrupt: # handle keyboard interrupt ### return 0 except Exception as e: if DEBUG or TESTRUN: raise(e) _LOGGER.warning(f"{traceback.format_exc()}") indent = len(program_name) * " " sys.stderr.write(program_name + ": " + repr(e) + "\n") sys.stderr.write(indent + " for help use --help") return 2
def __init__(self, network_file_path, configs): self.configs = configs self.file_path = network_file_path # Initialize the event manager self.mgr = EventManager() self.collector = DataCollector() # Read network in from file. with open(file_path, 'r') as yaml_file: network = yaml.load(yaml_file) # Initialize the network components self.hosts = {} for host_name in network['hosts']: self.hosts[host_name] = Host(host_name, self, self.collector) self.routers = {} if 'routers' in network: for router_name in network['routers']: self.routers[router_name] = Router(router_name, self) self.flows = {} for flow_dict in network['flows']: flow_name = flow_dict.keys()[0] flow_desc = flow_dict[flow_name] self.flows[flow_name] = Flow( flow_name, self, self.collector, self.hosts[flow_desc['source']] , self.hosts[flow_desc['destination']], flow_desc['amount'], flow_desc['start'] ) self.links = {} host_prefixes = ['H', 'S', 'T'] for link_dict in network['links']: link_name = link_dict.keys()[0] link_desc = link_dict[link_name] aname = link_desc['anode'] bname = link_desc['bnode'] ahost = self.hosts[aname] \ if aname[0] in host_prefixes else self.routers[aname] bhost = self.hosts[bname] \ if bname[0] in host_prefixes else self.routers[bname] link = Link( link_name, self, self.collector, link_desc['rate'] / 8.0, link_desc['delay'], link_desc['buffer'], link_desc['buffer'], ahost, bhost ) self.links[link_name] = link ahost.set_link(link) bhost.set_link(link) self.mgr.add_event(0.0, link.calculate_throughput, []) # Add initial events for each of the flows for flow in self.flows.values(): self.mgr.add_event(flow.start_t, flow.send_packet, []) if not configs['tcpreno']: self.mgr.add_event(flow.start_t, flow.tcp_fast_update, []) # Initialize the routing tables for router in self.routers.values(): router.init_routing_table() if len(self.routers) > 0: self.mgr.add_event(0.0, self.routers['R1'].send_rout_packet, []) self.mgr.add_event(self.mgr.t + configs['dynamic_routing_step'], self.start_dynamic_routing, [])
def setUp(self): """ Prepare the test """ self.e_mgr = EventManager()