def construct_match_queue(verbose): """ Returns a Queue of Match objects constructed from piped in sql query. """ rows = [line.decode('utf-8').split(u'|') for line in sys.stdin] fixture_queue = Queue(len(rows) + 1) for row in rows: if verbose: print u'{0} v {1}, {2}'.format(row[2], row[3], row[1]) fixture_queue.enqueue(Match(row)) # Flag match for submission to /r/gunners if row[2] == DUPE_TEAM or row[3] == DUPE_TEAM: print 'duplicating match' fixture_queue.enqueue(Match(row, gunners=True)) # Prompt for fixtures in verbose mode if verbose: sys.stdin = open('/dev/tty') while True: msg = raw_input('[Y/N] >') if 'n' in msg or 'N' in msg: sys.exit() elif 'y' in msg or 'Y' in msg: break return fixture_queue
def test_first(self): self.assertEqual(self.num_queue.first(), 1) self.assertEqual(self.letter_queue.first(), "a") empty_queue = Queue() with self.assertRaises(LookupError): empty_queue.first()
def setUp(self): self.num_queue = Queue() self.num_queue.enqueue(3) self.num_queue.enqueue(2) self.num_queue.enqueue(1) self.letter_queue = Queue() self.letter_queue.enqueue("b") self.letter_queue.enqueue("a")
def __init__(self, *args, **kwargs): super(RefMon, self).__init__(*args, **kwargs) # Used for REST API #wsgi = kwargs['wsgi'] #wsgi.register(FlowModReceiver, self) self.logger = util.log.getLogger('ReferenceMonitor') self.logger.info('refmon: start') # retrieve command line arguments CONF = cfg.CONF log_file_path = CONF['refmon']['log'] if log_file_path is not None: log_file = os.path.abspath(log_file_path) self.log = open(log_file, "w") else: self.log = None # configure flow mod logging log_file_path = CONF['refmon']['flowmodlog'] if log_file_path is not None: log_file = os.path.abspath(log_file_path) self.flow_mod_log = open(log_file, "w") else: self.flow_mod_log = None # load config from file self.logger.info('refmon: load config') try: config_file_path = CONF['refmon']['config'] config_file = os.path.abspath(config_file_path) self.config = Config(config_file) except InvalidConfigError as e: self.logger.info('refmon: invalid config ' + str(e)) self.config.always_ready = CONF['refmon']['always_ready'] # start controller if self.config.isMultiSwitchMode(): self.controller = MultiSwitchController(self.config) elif self.config.isMultiTableMode(): self.controller = MultiTableController(self.config) elif self.config.isOneSwitchMode(): self.controller = OneSwitchController(self.config) # this must be set before Server, which uses it. self.flow_mod_times = Queue() # start server receiving flowmod requests self.server = Server(self, self.config.server["IP"], self.config.server["Port"], self.config.server["key"]) self.server.start()
def test_dequeue(self): first = self.num_queue.dequeue() self.assertEqual(len(self.num_queue), 2) self.assertEqual(first, 1) second = self.num_queue.dequeue() self.assertEqual(second, 2) self.assertEqual(len(self.num_queue), 1) empty_queue = Queue() with self.assertRaises(LookupError): empty_queue.dequeue()
def run(customers): print "Starting to run through the DLD queue: %s" % time.time() queue = Queue('R') reception = Reception(queue, customers) for customer in customers: if (customer.emirates_id is None): print "Unknown customer has failed permanently dueto lack of Emirates ID" reception.fail(customer, False) else: queue.add(customer) return reception.run()
def aClosureV2(self, arcs): global backjumpLevel q = Queue.QQueue() # if arcs is None: # for i in range(0, self.net.nodeCount): # for j in range(i + 1, self.net.nodeCount): # rel = self.net.cs[i][j] # if rel != self.net.algebra.Universal: # q.enqueue(i, j, rel) # else: for arc in arcs: q.enqueue(arc[0], arc[1], self.net.cs[arc[0]][arc[1]]) while q.pq: i, j = q.dequeue() for k in range(self.net.nodeCount): if k == i or k == j: continue Cij = self.net.cs[i][j] Cjk = self.net.cs[j][k] Cik = self.net.cs[i][k] Ckj = self.net.cs[k][j] Cki = self.net.cs[k][i] Cik_star = Cik & self.net.algebra.compose[Cij][Cjk] Ckj_star = Ckj & self.net.algebra.compose[Cki][Cij] if Cik_star == 0 or Ckj_star == 0: backjumpLevel = self.net.triangleChanged(i, j, k) return INCONSISTENT # early exit if Cik_star != Cik: self.net.updateConstraint(i, k, Cik_star) q.enqueue(i, k, Cik_star) if Ckj_star != Ckj: self.net.updateConstraint(k, j, Ckj_star) q.enqueue(k, j, Ckj_star) return CONSISTENT
class TestQueue(unittest.TestCase): def setUp(self): self.num_queue = Queue() self.num_queue.enqueue(3) self.num_queue.enqueue(2) self.num_queue.enqueue(1) self.letter_queue = Queue() self.letter_queue.enqueue("b") self.letter_queue.enqueue("a") def test_enqueue(self): empty_queue = Queue() empty_queue.enqueue(4) self.assertEqual(len(empty_queue), 1) def test_len(self): self.assertEqual(len(self.num_queue), 3) self.assertEqual(len(self.letter_queue), 2) def test_repr(self): self.assertEqual(repr(self.num_queue), "Queue(1, 2, 3)") self.assertEqual(repr(self.letter_queue), "Queue(a, b)") def test_dequeue(self): first = self.num_queue.dequeue() self.assertEqual(len(self.num_queue), 2) self.assertEqual(first, 1) second = self.num_queue.dequeue() self.assertEqual(second, 2) self.assertEqual(len(self.num_queue), 1) empty_queue = Queue() with self.assertRaises(LookupError): empty_queue.dequeue() def test_first(self): self.assertEqual(self.num_queue.first(), 1) self.assertEqual(self.letter_queue.first(), "a") empty_queue = Queue() with self.assertRaises(LookupError): empty_queue.first()
def __init__(self, *args, **kwargs): super(RefMon, self).__init__(*args, **kwargs) # Used for REST API #wsgi = kwargs['wsgi'] #wsgi.register(FlowModReceiver, self) self.logger = util.log.getLogger('ReferenceMonitor') self.logger.info('refmon: start') # retrieve command line arguments CONF = cfg.CONF log_file_path = CONF['refmon']['log'] if log_file_path is not None: log_file = os.path.abspath(log_file_path) self.log = open(log_file, "w") else: self.log = None # configure flow mod logging log_file_path = CONF['refmon']['flowmodlog'] if log_file_path is not None: log_file = os.path.abspath(log_file_path) self.flow_mod_log = open(log_file, "w") else: self.flow_mod_log = None # load config from file self.logger.info('refmon: load config') try: config_file_path = CONF['refmon']['config'] config_file = os.path.abspath(config_file_path) self.config = Config(config_file) except InvalidConfigError as e: self.logger.info('refmon: invalid config '+str(e)) self.config.always_ready = CONF['refmon']['always_ready'] # start controller if self.config.isMultiSwitchMode(): self.controller = MultiSwitchController(self.config) elif self.config.isMultiTableMode(): self.controller = MultiTableController(self.config) elif self.config.isOneSwitchMode(): self.controller = OneSwitchController(self.config) # this must be set before Server, which uses it. self.flow_mod_times = Queue() # start server receiving flowmod requests self.server = Server(self, self.config.server["IP"], self.config.server["Port"], self.config.server["key"]) self.server.start()
async def create_queue(message): queues[message.guild.id] = Queue.Queue( message, await message.author.voice.channel.connect())
def setUp(self): self.q = Queue(1)
class TestQueue(unittest.TestCase): def setUp(self): self.q = Queue(1) def test_print(self): self.assertEquals(self.q.__str__(), "[0]") def test_len(self): self.assertEquals(len(self.q), 0) self.q.enqueue("test") self.assertEquals(len(self.q), 1) def test_dequeue_empty_queue(self): self.assertIsNone(self.q.dequeue()) def test_enqueue_full_queue(self): self.q.enqueue("test") self.assertFalse(self.q.enqueue("test")) def test_latest(self): self.assertEquals(self.q.latest(), 0) self.q.enqueue("test") self.assertEquals(self.q.latest(), "test") def test_empty(self): self.assertTrue(self.q.empty()) def test_enqueue(self): self.assertTrue(self.q.enqueue(0)) def test_full(self): self.q.enqueue(0) self.assertTrue(self.q.full()) def test_dequeue(self): self.q.enqueue("test") self.assertEquals(self.q.dequeue(), "test")
def test_enqueue(self): empty_queue = Queue() empty_queue.enqueue(4) self.assertEqual(len(empty_queue), 1)
print(s, "should be Stack()") print(x, "should be 6") print(y, "should be 5") # *** # uncomment when you've implemented peek and the methods above s.push(1) peeked = s.peek() print(peeked, "should be 1") print(len(s), "should be 1") print(s, "should be Stack(1)") # Queue code q = Queue() print(q._data, "should be []") # uncomment when you've implemented enqueue q.enqueue(5) q.enqueue(4) print(q._data, "should be [4, 5]") # uncomment when you've implemented __repr__ print(q, "should be Queue(4, 5)") # uncomment when you've implemented __len__ print(len(q), "should be 2") # uncomment when you've implemented dequeue x = q.dequeue() print(x, "should be 4")
def main(): logging.basicConfig(filename='errors.log', level=logging.ERROR) log = logging.getLogger('ex') parser = argparse.ArgumentParser() parser.add_argument('-v', '--verbose', help='increase output verbosity', action='store_true') parser.add_argument('-l', '--load', help='load from last canceled run', action='store_true') args = parser.parse_args() if args.load: previous_state = load_from_save() post_queue = previous_state['post_queue'] update_queue = previous_state['update_queue'] else: post_queue = construct_match_queue(args.verbose) update_queue = Queue(len(post_queue)) r = praw.Reddit(user_agent='Match Thread Submiter for /r/soccer, by /u/Match-Thread-Bot') r.login() # Login details in praw.ini file while True: try: if not post_queue.empty(): time_until_kick_off = post_queue.latest().time_until_kick_off() else: time_until_kick_off = 0 print '{0} minutes until next kick off.'.format(int(time_until_kick_off)) print 'Length of post queue:\t{0}'.format(len(post_queue)) print 'Length of update queue:\t{0}'.format(len(update_queue)) if not post_queue.empty(): time_until_kick_off = post_queue.latest().time_until_kick_off() else: time_until_kick_off = 0 if not post_queue.empty() and time_until_kick_off < (PRE_KICK_OFF): post = post_queue.dequeue() title = u'Match Thread: {0} v {1}'.format(post.home_team, post.away_team) if not thread_exists(post, r): content = construct_thread(post) try: if post.gunners: # Submit gunners thread to /r/gunners submission = r.submit(ALT_SUBREDDIT, title, content) else: submission = r.submit(SUBREDDIT, title, content) submission.add_comment(comment) except (APIException, URLError, IOError): log.exception('Could not submit thread.') else: print 'posting thread %s' % submission.title update_queue.enqueue((submission.id, post)) print u'adding thread to update queue {0}'.format(submission.title) else: print u'Thread {0} already exists'.format(title) elif not update_queue.empty(): post = update_queue.dequeue() try: submission = r.get_submission(submission_id=post[0]) submission.edit(construct_thread(post[1], submission_id=post[0])) except (APIException, URLError, IOError): update_queue.enqueue(post) log.exception('Could not update thread') else: print u'updating thread {0}'.format(submission.title) time_left = MATCH_LENGTH - post[1].time_after_kick_off() if time_left > 0: update_queue.enqueue(post) print u'adding thread {0} to update queue {1} minutes left'.format(submission.title, int(time_left)) if post_queue.empty() and update_queue.empty(): print '\nFinished!' break print '\n' sleep(30) except KeyboardInterrupt: save_to_file(post_queue=post_queue, update_queue=update_queue) raise
class RefMon(app_manager.RyuApp): OFP_VERSIONS = [ofproto_v1_0.OFP_VERSION, ofproto_v1_3.OFP_VERSION] # REST API _CONTEXTS = { 'wsgi': WSGIApplication } def __init__(self, *args, **kwargs): super(RefMon, self).__init__(*args, **kwargs) # Used for REST API #wsgi = kwargs['wsgi'] #wsgi.register(FlowModReceiver, self) self.logger = util.log.getLogger('ReferenceMonitor') self.logger.info('refmon: start') # retrieve command line arguments CONF = cfg.CONF log_file_path = CONF['refmon']['log'] if log_file_path is not None: log_file = os.path.abspath(log_file_path) self.log = open(log_file, "w") else: self.log = None # configure flow mod logging log_file_path = CONF['refmon']['flowmodlog'] if log_file_path is not None: log_file = os.path.abspath(log_file_path) self.flow_mod_log = open(log_file, "w") else: self.flow_mod_log = None # load config from file self.logger.info('refmon: load config') try: config_file_path = CONF['refmon']['config'] config_file = os.path.abspath(config_file_path) self.config = Config(config_file) except InvalidConfigError as e: self.logger.info('refmon: invalid config '+str(e)) self.config.always_ready = CONF['refmon']['always_ready'] # start controller if self.config.isMultiSwitchMode(): self.controller = MultiSwitchController(self.config) elif self.config.isMultiTableMode(): self.controller = MultiTableController(self.config) elif self.config.isOneSwitchMode(): self.controller = OneSwitchController(self.config) # this must be set before Server, which uses it. self.flow_mod_times = Queue() # start server receiving flowmod requests self.server = Server(self, self.config.server["IP"], self.config.server["Port"], self.config.server["key"]) self.server.start() def close(self): self.logger.info('refmon: stop') if self.log: self.log.close() if self.flow_mod_log: self.flow_mod_log.close() self.server.stop() @set_ev_cls(ofp_event.EventOFPStateChange, [MAIN_DISPATCHER, DEAD_DISPATCHER]) def dp_state_change_handler(self, ev): datapath = ev.datapath if ev.state == MAIN_DISPATCHER: self.controller.switch_connect(datapath) elif ev.state == DEAD_DISPATCHER: self.controller.switch_disconnect(datapath) @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER) def _packet_in_handler(self, ev): self.controller.packet_in(ev) @set_ev_cls(ofp_event.EventOFPBarrierReply, MAIN_DISPATCHER) def barrier_reply_handler(self, ev): datapath = ev.msg.datapath if self.controller.handle_barrier_reply(datapath): end_time = time() try: start_time = self.flow_mod_times.get_nowait() except Empty: pass if self.log: self.log.write(str(start_time) + " " + str(end_time) + " " + str(end_time - start_time) + "\n") def process_flow_mods(self, msg): self.flow_mod_times.put(time()) self.logger.info('refmon: received flowmod request ' + json.dumps(msg)) # authorization if "auth_info" in msg: auth_info = msg["auth_info"] # TODO: FLANC authorization here origin = auth_info["participant"] if "flow_mods" in msg: # flow mod logging if self.flow_mod_log: self.flow_mod_log.write('BURST: ' + str(time()) + '\n') self.flow_mod_log.write('PARTICIPANT: ' + str(msg['auth_info']['participant']) + '\n') for flow_mod in msg["flow_mods"]: self.flow_mod_log.write(json.dumps(flow_mod) + '\n') self.flow_mod_log.write('\n') self.logger.debug('BURST: ' + str(time())) self.logger.debug('PARTICIPANT: ' + str(msg['auth_info']['participant'])) for flow_mod in msg["flow_mods"]: self.logger.debug('FLOWMOD from ' + str(origin) + ': ' + json.dumps(flow_mod)) # push flow mods to the data plane for flow_mod in msg["flow_mods"]: if self.config.ofv == "1.0": fm = OFP10FlowMod(self.config, origin, flow_mod) elif self.config.ofv == "1.3": fm = OFP13FlowMod(self.config, origin, flow_mod) self.controller.process_flow_mod(fm)
class RefMon(app_manager.RyuApp): OFP_VERSIONS = [ofproto_v1_0.OFP_VERSION, ofproto_v1_3.OFP_VERSION] # REST API _CONTEXTS = { 'wsgi': WSGIApplication } def __init__(self, *args, **kwargs): super(RefMon, self).__init__(*args, **kwargs) # Used for REST API #wsgi = kwargs['wsgi'] #wsgi.register(FlowModReceiver, self) self.logger = util.log.getLogger('ReferenceMonitor') self.logger.info('refmon: start') # retrieve command line arguments CONF = cfg.CONF log_file_path = CONF['refmon']['log'] if log_file_path is not None: log_file = os.path.abspath(log_file_path) self.log = open(log_file, "w") else: self.log = None # configure flow mod logging log_file_path = CONF['refmon']['flowmodlog'] if log_file_path is not None: log_file = os.path.abspath(log_file_path) self.flow_mod_log = open(log_file, "w") else: self.flow_mod_log = None # load config from file self.logger.info('refmon: load config') try: config_file_path = CONF['refmon']['config'] config_file = os.path.abspath(config_file_path) self.config = Config(config_file) except InvalidConfigError as e: self.logger.info('refmon: invalid config ' + str(e)) self.config.always_ready = CONF['refmon']['always_ready'] # start controller if self.config.isMultiSwitchMode(): self.controller = MultiSwitchController(self.config) elif self.config.isMultiTableMode(): self.controller = MultiTableController(self.config) elif self.config.isOneSwitchMode(): self.controller = OneSwitchController(self.config) # this must be set before Server, which uses it. self.flow_mod_times = Queue() # start server receiving flowmod requests self.server = Server(self, self.config.server["IP"], self.config.server["Port"], self.config.server["key"]) self.server.start() def close(self): self.logger.info('refmon: stop') if self.log: self.log.close() if self.flow_mod_log: self.flow_mod_log.close() self.server.stop() @set_ev_cls(ofp_event.EventOFPStateChange, [MAIN_DISPATCHER, DEAD_DISPATCHER]) def dp_state_change_handler(self, ev): datapath = ev.datapath if ev.state == MAIN_DISPATCHER: self.controller.switch_connect(datapath) elif ev.state == DEAD_DISPATCHER: self.controller.switch_disconnect(datapath) @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER) def _packet_in_handler(self, ev): self.controller.packet_in(ev) @set_ev_cls(ofp_event.EventOFPBarrierReply, MAIN_DISPATCHER) def barrier_reply_handler(self, ev): datapath = ev.msg.datapath if self.controller.handle_barrier_reply(datapath): end_time = time() try: start_time = self.flow_mod_times.get_nowait() except Empty: pass if self.log: self.log.write( str(start_time) + " " + str(end_time) + " " + str(end_time - start_time) + "\n") def process_flow_mods(self, msg): self.flow_mod_times.put(time()) self.logger.info('refmon: received flowmod request ' + json.dumps(msg)) # authorization if "auth_info" in msg: auth_info = msg["auth_info"] # TODO: FLANC authorization here origin = auth_info["participant"] if "flow_mods" in msg: # flow mod logging if self.flow_mod_log: self.flow_mod_log.write('BURST: ' + str(time()) + '\n') self.flow_mod_log.write( 'PARTICIPANT: ' + str(msg['auth_info']['participant']) + '\n') for flow_mod in msg["flow_mods"]: self.flow_mod_log.write(json.dumps(flow_mod) + '\n') self.flow_mod_log.write('\n') self.logger.debug('BURST: ' + str(time())) self.logger.debug('PARTICIPANT: ' + str(msg['auth_info']['participant'])) for flow_mod in msg["flow_mods"]: self.logger.debug('FLOWMOD from ' + str(origin) + ': ' + json.dumps(flow_mod)) # push flow mods to the data plane for flow_mod in msg["flow_mods"]: if self.config.ofv == "1.0": fm = OFP10FlowMod(self.config, origin, flow_mod) elif self.config.ofv == "1.3": fm = OFP13FlowMod(self.config, origin, flow_mod) self.controller.process_flow_mod(fm)