def main():
e_to_s_recv, e_to_s_send = mp.Pipe(False)
s_to_e_recv, s_to_e_send = mp.Pipe(False)
g_to_e_recv, g_to_e_send = mp.Pipe(False)
graph = Graph()
graph.init_file("./pickles/graph.pypkle")
# pickup_dist, dropoff_dist = generateDistributions()
# start the engine
engine = Engine(pipe_recv_from_scheduler=s_to_e_recv,
pipe_recv_from_gen=g_to_e_recv,
pipe_send_to_scheduler=e_to_s_send)
engine.start()
scheduler = Scheduler(pipe_send_to_engine=s_to_e_send,
pipe_recv_from_engine=e_to_s_recv,
graph=graph)
scheduler.start()
processes = [EventProcess(g_to_e_send, i, graph) for i in range(1)]
for p in processes:
p.start()
for p in processes:
p.join()
engine.join()
scheduler.join()
def __init__(self, test_case_conf, clients: List[Client]):
self.test_case_conf = test_case_conf
self.logger = log.get_logger()
self.clients = {}
for client in clients:
self.clients[client.index] = client
self.scheduler = Scheduler(test_case_conf, clients)
# TC statistics
self.start_chain_height = 0
self.end_chain_height_before_recover = 0
self.end_chain_height_after_recover = 0
self.start_time = time.time()
self.start_recover_time = None
self.end_recover_time = None
self.tx_history_file = TX_HISTORY_FILE.format(self.start_time)
# TX issuing statistics
self.tx_start_chain_height = 0
self.tx_end_chain_height = 0
self.tx_start_time = None
self.tx_end_time = None
self.tx_sent = 0
self.tx_mined = 0
self.balance_mined_by_the_test = 0
self.sender_before_balance = 0
self.receiver_before_balance = 0
def __init__(self,local_mapping_file):
logger.init('./globalhapi.log',logging.INFO)
self.logger=logger.getLogger('global',logging.INFO)
# self.topo = topo
# self.locals = [0,1] #{0:"bala"}
# self.dp_to_local = {1:0,2:1}
self.locals = read_mapping_from_file(local_mapping_file).keys()
self.dp_to_local = get_reverse_mapping_from_file(local_mapping_file)
self.logger.info(self.locals)
self.logger.info(self.dp_to_local)
self.sockets = {}
self.link_bw = {}#outer layer
self.link_ltcy = {}
self.local_to_buf_size = {}
self.dp_to_tcam_size = {}
# self.dp_to_local = {1:0,2:0,3:1,4:1}#for lineartopo2
self.flows = {}# all flows now
self.flows_new = {} #flows updating
self.flows_to_schedule = {} #flow to update
self.status_num = 0 #for start update
# self.flows_new = {"10.0.0.110.0.0.25001":flowdes0}
self.scheduler = Scheduler()
self.tag_flows_temp = {}
self.schedule_result = {}
eventlet.spawn(self.run_fd_server)
def get_messages(self, **kwargs):
person_name = kwargs.get('PersonName', '')
self.sqs_msgs = []
"""get all available messages off the queue"""
print "Checking message queue"
messages = self.queue.receive_messages(MessageAttributeNames=[
'NoMoreOccurrences', 'ExpirationDateTimeInUtc', 'PersonName',
'Voice', 'UUID'
],
WaitTimeSeconds=20,
MaxNumberOfMessages=10)
if len(messages) > 0:
for m in messages:
qm = QueuedMessage(QueuedMessage=m)
if not qm.person_name == person_name:
continue
if qm.person_name not in self.messages:
logging.info("First message for " + qm.person_name)
self.messages[qm.person_name] = []
logging.info('Adding message:\n')
logging.info(qm.body)
self.messages[qm.person_name].append(qm)
logging.info('Total messages so far: ' +
str(len(self.messages[qm.person_name])))
self.sqs_msgs.append(m)
scheduler = Scheduler()
scheduler.update_queue_status(qm.uuid_key, person_name, False)
def message_schedule(person_name, message, expiration_datetime, ical,
start_datetime):
try:
click.echo("Scheduling message for person {}".format(person_name))
scheduler = Scheduler()
start_datetime = arrow.utcnow()
if start_datetime is None:
click.echo("Setting start time to now")
else:
start_datetime = arrow.get(start_datetime)
click.echo("Setting custom start time to %s" % start_datetime)
if ical is None:
ical = 'FREQ=DAILY;COUNT=1'
if expiration_datetime is None:
expiration_datetime = start_datetime.replace(hours=1)
message = ScheduledMessage(StartDateTimeInUtc=start_datetime,
ical=ical,
Body=message,
PersonName=person_name,
EndDateTimeInUtc=expiration_datetime)
scheduler.schedule_message(message)
except Exception:
click.echo(traceback.print_exc())
exit(2)
def test_inserting_schedule_sets_start_datetime(good_scheduled_message):
start_datetime_in_utc = good_scheduled_message.start_datetime_in_utc
scheduler_under_test = Scheduler()
scheduler_under_test.schedule_message(good_scheduled_message)
message = scheduler_under_test.get_messages()[0]
start_date = message.start_datetime_in_utc
assert start_date.isoformat() == start_datetime_in_utc.isoformat()
def schedulerLargeValuesPerf(plant, orderList, testNum):
machines = plant.machines[:]
orders = orderList.orders[:]
pprint(
"PERF Starting benchmark test " + str(testNum) + " with large values",
BLUE)
orderList.orders = orders[:6]
plant.machines = machines[:]
largeValuesTimes = [0]
for i in range(1, 10):
pprint("PERF Large Value = " + str(i * 4), BLUE)
for o in orderList.orders:
o.deadline *= 4
for r in o.recipe.recipe:
r[1] *= 4
scheduler = Scheduler(plant, orderList)
t = time()
scheduler.start()
t = time() - t
largeValuesTimes.append(t)
pprint("PERF Time = " + str(t), GREEN)
try:
from thirdparty.CairoPlot import dot_line_plot
except:
pprint("PERF Will not output to graph.", RED)
return
dot_line_plot(
path.join("benchmarks", "largevalues-" + str(testNum)) + ".ps",
largeValuesTimes, 800, 800, (255, 255, 255), 5, True, True, True, None,
None, None, None)
def queue(simulate, simulated_date):
try:
if simulated_date:
dt = arrow.get(simulated_date)
else:
dt = arrow.utcnow()
scheduler = Scheduler()
print 'getting messages'
msgs = scheduler.get_messages()
logging.info("Starting MessageManager")
logging.info("messages = %s" % len(msgs))
if len(msgs) == 0:
click.echo("No messages are ready to be queued")
else:
click.echo("Number of messages to be scheduled: %s" % len(msgs))
for m in msgs:
if not simulate:
logging.info("Getting person %s " % m.person_name)
pm = PersonManager()
p = pm.get_person(m.person_name)
if not p:
logging.warn(m.person_name +
"does not have an entry in the " +
"Person table")
continue
if p.all_available_count(dt) == 0:
logging.warn('No locations available for %s' %
m.person_name)
click.echo('No locations available for %s' % m.person_name)
continue
avail_windows = p.all_available(dt)
click.echo('# of locations avail: {}, last_loc={}'.format(
p.all_available_count(dt), m.last_loc))
if m.last_loc == p.all_available_count(dt) - 1:
click.echo('Resetting to first location')
idx = 0
else:
click.echo('Moving to next location')
idx = m.last_loc + 1
active_window = avail_windows[int(idx)]
next_exp = m.next_expiration_utc.isoformat()
mm = MessageManager(LocationName=active_window.location_name)
click.echo("Publishing message for person %s to location %s" %
(m.person_name, active_window.location_name))
mm.publish_message(Body=m.body,
UUID=m.uuid_key,
PersonName=m.person_name,
NoMoreOccurrences=m.no_more_occurrences,
ExpirationDateTimeInUtc=next_exp)
scheduler.update_queue_status(m.uuid_key, m.person_name, True)
scheduler.update_last_location(m.uuid_key, m.person_name, idx)
else:
click.echo("Publishing message(simulated):")
click.echo(str(m))
except Exception:
print 'here'
click.echo(traceback.print_exc())
raise
def test_inserting_schedule_sets_end_datetime(good_scheduled_message):
end_datetime_in_utc = good_scheduled_message.end_datetime_in_utc
scheduler_under_test = Scheduler()
scheduler_under_test.schedule_message(good_scheduled_message)
message = scheduler_under_test.get_messages()[0]
end_datetime = message.end_datetime_in_utc
assert end_datetime.isoformat() == end_datetime_in_utc.isoformat()
def schedulerOrdersPerf(plant, orderList, testNum):
machines = plant.machines[:]
orders = orderList.orders[:]
pprint("PERF Starting benchmark test " + str(testNum) + " on orders", BLUE)
orderList.orders = []
plant.machines = machines[:]
ordertimes = [0]
for i in range(1, len(orders) + 1):
pprint("PERF Number of orders = " + str(i), BLUE)
orderList.orders = orders[:i]
scheduler = Scheduler(plant, orderList)
t = time()
scheduler.start()
t = time() - t
ordertimes.append(t)
pprint("PERF Time = " + str(t), GREEN)
try:
from thirdparty.CairoPlot import dot_line_plot
except:
pprint("PERF Will not output to graph.", RED)
return
dot_line_plot(
path.join("benchmarks", "orders-" + str(testNum)) + ".ps", ordertimes,
800, 800, (255, 255, 255), 5, True, True, True, None, None, None, None)
def __init__(self, parent=None):
super(MainApp, self).__init__(parent)
# set up GUI
self.setupUi(self)
self.taskListElems.setAlignment(QtCore.Qt.AlignTop)
self.currentTaskElem.setAlignment(QtCore.Qt.AlignTop)
self.currentTask.setStyleSheet("QScrollArea {background-color:transparent;}");
self.currentTaskContents.setStyleSheet("background-color:transparent;");
self.taskList.setStyleSheet("QScrollArea {background-color:transparent;}");
self.taskListContents.setStyleSheet("background-color:transparent;");
self.setStyleSheet("#mainWindow{background-color:white;}")
# connect signals
self.add_task_signal.connect(self.add_task)
self.pop_task_signal.connect(self.pop_task)
self.clear_tasks_signal.connect(self.clear_tasks)
self.update_time_signal.connect(self.update_time)
self.update_position_signal.connect(self.update_position)
# initialize cloud components
self.stt = stt.SpeechToTextManager("google_key.json")
self.nlp = nlp.NaturalProcessingLanguageGoogleCloud()
self.tts = tts.TextToSpeechManager()
th = threading.Thread(target=self.get_task_thread_body, daemon=True)
th.start()
# initialize scheduler
self.time_daemon = TimeDaemon(min_every_sec=1, update_time_signal=self.update_time_signal)
threading.Thread(target=self.time_daemon.run, args=()).start()
# need to set current GPS position here
self.scheduler = Scheduler(current_position="Cecina", time_daemon=self.time_daemon, polling_sec=5,
task_finished_signal=self.pop_task_signal,
update_position_signal=self.update_position_signal)
def test_inserting_recurring_schedule_sets_ical(good_scheduled_message):
test_ical = good_scheduled_message.ical
scheduler_under_test = Scheduler()
scheduler_under_test.schedule_message(good_scheduled_message)
message = scheduler_under_test.get_messages()[0]
ical = message.ical
assert ical == test_ical
def test_inserting_recurring_schedule_sets_message(good_scheduled_message):
body = good_scheduled_message.body
scheduler_under_test = Scheduler()
scheduler_under_test.schedule_message(good_scheduled_message)
message = scheduler_under_test.get_messages()[0]
actual_body = message.body
assert actual_body == body
def __init__(self, config: Config):
self._scheduler = Scheduler()
self._email_notification = EmailNotification(config.get('smtp'), config.get('recipients'))
for site in config.get('sites'):
self._scheduler.every_minutes(Site(site), self.parse)
logger.info(f"Will be parsing {len(config.get('sites'))} site(s)")
def message_schedule(person_name, message, ical, count, frequency, lexbot,
interval, timezone, start_date, start_time, end_date,
bot_names, ice_breaker, required_bots, introduction,
end_time):
try:
print ice_breaker
print required_bots
click.echo("Scheduling message for person {}".format(person_name))
scheduler = Scheduler()
if not timezone:
timezone = tzlocal.get_localzone().zone
click.echo('Timezone: {}'.format(timezone))
if start_time is None:
start_time = arrow.now(timezone).format('HH:mm')
if start_date is None:
start_date = arrow.now(timezone).format('YYYY-MM-DD')
start_datetime = arrow.get(
'{} {}'.format(start_date, start_time)) \
.replace(tzinfo=tz.gettz(timezone)).to('UTC')
if end_time is None:
end_time = start_time.format('HH:mm')
if end_date is None:
end_date = start_datetime.replace(years=10).format('YYYY-MM-DD')
end_datetime = arrow.get(
'{} {}'.format(end_date, end_time)) \
.replace(tzinfo=tz.gettz(timezone)).to('UTC')
message = ScheduledMessage(StartDateTimeInUtc=start_datetime,
ical=ical,
Body=message,
PersonName=person_name,
Frequency=frequency,
Count=count,
Lexbot=lexbot,
TimeZone=timezone,
Interval=interval,
BotNames=bot_names,
IceBreaker=ice_breaker,
Introduction=introduction,
RequiredBots=required_bots,
EndDateTimeInUtc=end_datetime)
scheduler.schedule_message(message)
click.echo('Start Time: {}'.format(start_datetime))
click.echo('End Time: {}'.format(end_datetime))
if ical:
click.echo('ical:\n{}'.format(ical))
print "Next: {}".format(message.next_occurrence_local)
print message.to_ical()
except Exception:
click.echo(traceback.print_exc())
exit(2)
def message_delete(person_name, message_id, verbose):
log = logging.getLogger('PollexyCli')
if verbose:
os.environ['LOG_LEVEL'] = 'DEBUG'
log.setLevel(logging.DEBUG)
s = Scheduler()
click.echo('Deleting message')
s.delete_message(Key=message_id,
PersonName=person_name)
def main():
""" Scheduler scripts, reads from the database all
schedules and determines if any spider should
be executed at this time.
"""
#path = dirname(realpath(__file__))
project_conf = get_project_conf()
scheduler = Scheduler(project_conf)
scheduler.run_scheduler()
def test_new_message_is_ready(good_scheduled_message):
msg = ScheduledMessage(
StartDateTimeInUtc=arrow.get('2012-01-01 01:01 UTC'),
ical="FREQ=DAILY",
Body="Test Message Body",
PersonName="Testperson",
EndDateTimeInUtc=arrow.get('2027-01-01 01:01 UTC'))
scheduler_under_test = Scheduler()
scheduler_under_test.schedule_message(msg)
m = scheduler_under_test.get_messages()[0]
assert m.is_message_ready
def test_sanity(self):
test_scheduler = TestingScheduler(max_jobs=SchedulerTests.MAX_JOBS)
self.assertEqual(test_scheduler.time_unit, TimeUnitEnum.SECONDS)
self.assertEqual(len(test_scheduler), SchedulerTests.MAX_JOBS)
scheduler = Scheduler(max_jobs=SchedulerTests.MAX_JOBS)
self.assertEqual(scheduler.time_unit, TimeUnitEnum.HOURS)
self.assertEqual(len(scheduler), SchedulerTests.MAX_JOBS)
self.assertFalse(scheduler.is_alive())
self.assertFalse(scheduler.daemon)
def __init__(
self, settings, new_scheduler=Scheduler(), new_player=Player(),
):
"""Accpets new scheduler and player but this is largely for testing"""
self._alarms = {}
self._snooze_time = 10
self._snoozed = self._default_snoozed = 5
self._settings = settings
AlarmSettings.connect(self._update_alarm_setting)
self._scheduler = new_scheduler
self._player = new_player
AlarmJob.subscribe(self._trigger_alarm)
def test_ignore_expired_messages(good_scheduled_message):
msg = ScheduledMessage(
StartDateTimeInUtc=arrow.get('2012-01-01 01:01 UTC'),
ical="FREQ=DAILY",
Body="Test Message Body",
PersonName="Testperson",
EndDateTimeInUtc=arrow.get('2014-01-01 01:01 UTC'))
compare_date = arrow.utcnow()
scheduler_under_test = Scheduler()
scheduler_under_test.schedule_message(msg)
m = scheduler_under_test.get_messages(compare_date, True)
assert len(m) == 0
def handler(event, context):
scheduler = Scheduler()
dt = arrow.utcnow()
logging.info("Getting messages")
msgs = scheduler.get_messages()
logging.info("messages = %s" % len(msgs))
if len(msgs) == 0:
logging.info("No messages are ready to be queued")
else:
logging.info("Number of messages to be scheduled: %s" % len(msgs))
for m in msgs:
logging.info("Getting person %s " % m.person_name)
pm = PersonManager()
p = pm.get_person(m.person_name)
if not p:
logging.warn(m.person_name + "does not have an entry in the " +
"Person table . . . skipping")
continue
if p.all_available_count(dt) == 0:
logging.warn('No locations available for %s . . . skipping' %
m.person_name)
continue
avail_windows = p.all_available(dt)
logging.info('# of locations avail: {}, last_loc={}'.format(
p.all_available_count(dt), m.last_loc))
if p.all_available_count(dt) > 1 and \
m.last_loc == p.all_available_count(dt)-1:
logging.info('Resetting to first location')
idx = 0
else:
if p.all_available_count(dt) > 1:
logging.info('Moving to next location')
idx = m.last_loc + 1
else:
idx = 0
active_window = avail_windows[int(idx)]
next_exp = m.next_expiration_utc.isoformat()
mm = MessageManager(LocationName=active_window.location_name)
logging.info("Publishing message for person %s to location %s" %
(m.person_name, active_window.location_name))
mm.publish_message(Body=m.body,
UUID=m.uuid_key,
PersonName=m.person_name,
NoMoreOccurrences=m.no_more_occurrences,
BotNames=m.bot_names,
IceBreaker=m.ice_breaker,
RequiredBots=m.required_bots,
ExpirationDateTimeInUtc=next_exp)
scheduler.update_queue_status(m.uuid_key, m.person_name, True)
scheduler.update_last_location(m.uuid_key, m.person_name, idx)
def __init__(self):
self._env_init()
self._log_init()
self._conf_init()
self._db_init()
self.se_mgr = SearchEngineMgr(self.conf, self.db)
self._rabbitmq_init()
self.scheduler = Scheduler(self.conf, self.se_mgr, self.db)
self.se_mgr.set_scheduler(self.scheduler)
self.se_mgr.set_mq(self.analyze_mq)
self.rest_server = RestServer(self.conf, self.db, self.analyze_mq,
self.se_mgr, self.scheduler)
self.analyze_mq.set_rest_server(self.rest_server)
def bench(self):
orders = self.orderList.orders[:]
i = self.startValue
while i <= len(orders):
pprint("PERF Number of orders = " + str(i), BLUE)
self.orderList.orders = orders[:i]
scheduler = Scheduler(self.plant, self.orderList)
t = time()
scheduler.start()
t = time() - t
self.addCairoPlotTime(t)
self.addGnuPlotTime(i, t)
i += 1
def __call__(self, app, port):
if port:
app.config['SCHEDULER_PORT'] = value
# Show server info on initial run (not on reload)
if not os.environ.get('WERKZEUG_RUN_MAIN'):
print self.log_info(app.config['SCHEDULER_HOST'],
app.config['SCHEDULER_PORT'])
app.scheduler = Scheduler()
werkzeug.serving.run_with_reloader(lambda: gevent.pywsgi.WSGIServer(
(app.config['SCHEDULER_HOST'], app.config['SCHEDULER_PORT']), app).
serve_forever())
def fail_speech(self, **kwargs):
logging.info('Speech failed: ' +
kwargs.get('Reason', 'Unknown Reason'))
dont_delete = kwargs.get('DontDelete', False)
if (dont_delete):
logging.info('We are NOT deleting the original SQS messages')
return
for m in self.sqs_msgs:
scheduler = Scheduler()
qm = QueuedMessage(QueuedMessage=m)
logging.info("Setting messages InQueue to False")
scheduler.update_queue_status(qm.uuid_key, qm.person_name, False)
self.delete_sqs_msgs()
def run_scheduler():
scheduler = Scheduler(taskdb=get_taskdb(),
projectdb=get_projectdb(),
newtask_queue=self.newtask_queue,
status_queue=self.status_queue,
out_queue=self.scheduler2fetcher,
data_path="./test/data/")
scheduler.UPDATE_PROJECT_INTERVAL = 0.1
scheduler.LOOP_INTERVAL = 0.1
scheduler._last_tick = time.time() # not dispatch cronjob
run_in_thread(scheduler.xmlrpc_run,
port=self.scheduler_xmlrpc_port)
scheduler.run()
def trigger():
if not request.content_type == 'application/json':
return Response('Error: Invalid Content-Type header',
status=400,
mimetype='text/plain')
try:
scheduler = Scheduler(request.json, 420)
scheduler.start()
except SchedulerError as e:
return Response('Error: ' + str(e), status=400, mimetype='text/plain')
return Response(f"Launched scheduler", status=200, mimetype='text/plain')
def schedule(self):
"""
Runs the Scheduler with the OrderList from orderListName on the Plant
with plantName.
"""
scheduler = Scheduler(self.plant, self.orderList)
evaluator = Evaluator.fromXmlFile(self.configFilename, self.plant)
result = scheduler.start()
if result != None:
solutions = parseSolutions(result, self.plant, self.orderList)
evaluator.evaluate(solutions)
best = bestSolution(solutions)
best.unNormalize(self.normValue)
print best
def list(person_name, include_expired, verbose):
log = logging.getLogger('PollexyCli')
if verbose:
os.environ['LOG_LEVEL'] = 'DEBUG'
log.setLevel(logging.DEBUG)
s = Scheduler()
msgs = s.get_messages(IncludeExpired=True, ready_only=False)
for m in msgs:
if not m.person_name == person_name:
log.debug('Skipping message for {}'.format(m.person_name))
continue
print '\n* {}\n "{}"\n Next: {}\n Expired: {}\n Queued: {}'.format(
m.uuid_key, m.body, m.next_occurrence_local,
bool(m.no_more_occurrences), bool(m.is_queued))
