def test_rr_input_estimated_scheduler_end(self):
input_provider = SchedulingInputProvider(self.sched_params,
self.network_interface,
self.network_model,
is_rr_input=True)
test_now = datetime.utcnow()
input_provider.refresh()
assert_almost_equal(0, (input_provider.scheduler_now -
test_now).total_seconds(),
delta=5)
assert_equal(
self.sched_params.rr_run_time,
input_provider.estimated_scheduler_runtime().total_seconds())
assert_equal(1,
self.network_interface.get_all_request_groups.call_count)
assert_equal(1,
self.network_interface.resource_usage_snapshot.call_count)
assert_almost_equal(
0,
(self.network_interface.resource_usage_snapshot.call_args[0][1] -
test_now).total_seconds(),
delta=5,
msg='Snapshot start should be refresh time')
assert_almost_equal(
self.sched_params.rr_run_time,
(self.network_interface.resource_usage_snapshot.call_args[0][2] -
test_now).total_seconds(),
delta=5,
msg='Snapshot end should be refresh time + RR scheduling run time')
def test_set_rr_run_time(self):
input_provider = SchedulingInputProvider(self.sched_params,
self.network_interface,
self.network_model,
is_rr_input=False)
current_estimate = input_provider.estimated_rr_run_time
new_estimate_timedelta = current_estimate + timedelta(seconds=100)
input_provider.set_rr_run_time(new_estimate_timedelta.total_seconds())
def test_input_scheduler_now_when_provided_by_parameter(self):
simulated_now_str = '1980-06-10T08:00:00Z'
simulated_now = datetime.strptime(simulated_now_str, '%Y-%m-%dT%H:%M:%SZ')
self.sched_params.simulate_now = simulated_now_str
input_provider = SchedulingInputProvider(self.sched_params, self.network_interface, self.network_model,
is_rr_input=True)
input_provider.refresh()
assert_equal(simulated_now, input_provider.scheduler_now)
def test_input_scheduler_now_when_not_provided_by_parameter(self):
input_provider = SchedulingInputProvider(self.sched_params,
self.network_interface,
self.network_model,
is_rr_input=True)
test_now = datetime.utcnow()
input_provider.refresh()
assert_almost_equal(0, (input_provider.scheduler_now -
test_now).total_seconds(),
delta=5)
def test_constructor(self):
input_provider = SchedulingInputProvider(self.sched_params, self.network_interface, self.network_model,
is_rr_input=True)
assert_equal(self.sched_params.rr_runtime_seconds, input_provider.estimated_rr_run_time.total_seconds())
assert_equal(self.sched_params.normal_runtime_seconds, input_provider.estimated_normal_run_time.total_seconds())
assert_equal(None, input_provider.scheduler_now)
assert_equal(input_provider.estimated_rr_run_time, input_provider.estimated_scheduler_runtime())
assert_equal(None, input_provider.json_request_group_list)
assert_equal(None, input_provider.available_resources)
assert_equal(None, input_provider.resource_usage_snapshot)
def test_input_does_not_exclude_resources_with_events(self):
self.network_model['1m0a.doma.elp'] = {'name': '1m0a.doma.elp',
'events': [],
'status': 'online'}
self.network_model['1m0a.doma.lsc'] = {'name': '1m0a.doma.lsc',
'events': [],
'status': 'online'}
self.network_model['1m0a.doma.lsc']['events'].append('event')
input_provider = SchedulingInputProvider(self.sched_params, self.network_interface, self.network_model,
is_rr_input=True)
input_provider.refresh()
assert_equal(['1m0a.doma.elp'], input_provider.available_resources)
assert_equal(set(['1m0a.doma.elp', '1m0a.doma.lsc']),
set(self.network_interface.resource_usage_snapshot.call_args[0][0]))
def main(argv):
sched_params = parse_args(argv)
log.info("Starting Adaptive Scheduler, version {v}".format(v=VERSION))
event_bus = get_eventbus()
user_feedback_logger = UserFeedbackLogger()
timing_logger = TimingLogger()
event_bus.add_listener(user_feedback_logger, persist=True)
event_bus.add_listener(timing_logger, persist=True,
event_type=TimingLogger._StartEvent)
event_bus.add_listener(timing_logger, persist=True,
event_type=TimingLogger._EndEvent)
schedule_interface = ObservationScheduleInterface(host=sched_params.observation_portal_url)
observation_portal_interface = ObservationPortalInterface(sched_params.observation_portal_url)
configdb_interface = ConfigDBInterface(configdb_url=sched_params.configdb_url, telescope_classes=sched_params.telescope_classes)
network_state_interface = Network(configdb_interface, sched_params)
network_interface = NetworkInterface(schedule_interface, observation_portal_interface, network_state_interface,
configdb_interface)
kernel_class = get_kernel_class(sched_params)
network_model = configdb_interface.get_telescope_info()
scheduler = LCOGTNetworkScheduler(kernel_class, sched_params, event_bus, network_model)
if sched_params.input_file_name:
input_provider = FileBasedSchedulingInputProvider(sched_params.input_file_name, network_interface,
is_rr_mode=True)
else:
input_provider = SchedulingInputProvider(sched_params, network_interface, network_model, is_rr_input=True)
input_factory = SchedulingInputFactory(input_provider)
scheduler_runner = SchedulerRunner(sched_params, scheduler, network_interface, network_model, input_factory)
scheduler_runner.run()
def test_normal_input_resource_usage_snapshot_start(self):
input_provider = SchedulingInputProvider(self.sched_params, self.network_interface, self.network_model,
is_rr_input=False)
last_known_state = datetime(2014, 10, 29, 5, 47, 0)
input_provider.set_last_known_state(last_known_state)
input_provider.refresh()
assert_almost_equal(last_known_state, self.network_interface.resource_usage_snapshot.call_args[0][1],
msg='Snapshot start should be last known state')