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)
