def test_handle_stuck_jobs(self):
order_id = self.mock_order.generate_testing_order(self.user_id)
# Make some really old jobs
self.mock_order.update_scenes(order_id, ('landsat', 'modis', 'plot'),
'status', ['processing'])
self.mock_order.update_scenes(order_id, ('landsat', 'modis', 'plot'),
'status_modified',
[datetime.datetime(1900, 1, 1)])
scenes = Scene.where({'status': 'processing', 'order_id': order_id})
n_scenes = len(scenes)
response = production_provider.handle_stuck_jobs(scenes)
self.assertTrue(response)
scenes = Scene.where({
'status': 'processing',
'order_id': order_id,
'reported_orphan is not': None
})
self.assertEqual(n_scenes, len(scenes))
self.mock_order.update_scenes(order_id, ('landsat', 'modis', 'plot'),
'reported_orphan',
[datetime.datetime(1900, 1, 1)])
response = production_provider.handle_stuck_jobs(scenes)
self.assertTrue(response)
scenes = Scene.where({'status': 'processing', 'order_id': order_id})
self.assertEqual(0, len(scenes))
def test_handle_stuck_jobs(self):
time_jobs_stuck = datetime.datetime.now() - datetime.timedelta(hours=6)
order_id = self.mock_order.generate_testing_order(self.user_id)
# Make some really old jobs
self.mock_order.update_scenes(
order_id, ('landsat', 'modis', 'viirs', 'sentinel', 'plot'),
'status', ['scheduled'])
self.mock_order.update_scenes(
order_id, ('landsat', 'modis', 'viirs', 'sentinel', 'plot'),
'status_modified', [datetime.datetime(1900, 1, 1)])
scenes = Scene.where({
'status': ('tasked', 'scheduled', 'processing'),
'order_id': order_id
})
n_scenes = len(scenes)
response = production_provider.handle_stuck_jobs(scenes)
self.assertTrue(response)
scenes = Scene.where({
'status': ('tasked', 'scheduled', 'processing'),
'order_id': order_id
})
self.assertEqual(0, len(scenes))
scenes = Scene.where({'status': 'oncache', 'order_id': order_id})
self.assertEqual(n_scenes, len(scenes))
def test_hadoop_reset_status(self):
order_id = self.mock_order.generate_testing_order(self.user_id)
scenes = Scene.where({'order_id': order_id})
Scene.bulk_update([s.id for s in scenes], {'status': 'processing'})
self.assertTrue(production_provider.reset_processing_status())
scenes = Scene.where({'order_id': order_id})
self.assertEqual({'submitted'}, set([s.status for s in scenes]))
def test_production_calc_scene_download_sizes(self):
order = Order.find(self.mock_order.generate_testing_order(self.user_id))
scenes = order.scenes()
Scene.bulk_update([s.id for s in scenes], {'status': 'complete', 'download_size': 0})
self.assertTrue(production_provider.calc_scene_download_sizes())
upscenes = Scene.where({'status': 'complete', 'download_size': 999})
self.assertEqual(len(upscenes), len(scenes))
def update_scenes(self, order_id, attribute, values):
scenes = Scene.where({'order_id': order_id})
xscenes = chunkify(scenes, len(values))
for idx, value in enumerate(values):
for scene in xscenes[idx]:
scene.update(attribute, value)
return True
def test_production_handle_retry_products(self):
prev = datetime.datetime.now() - datetime.timedelta(hours=1)
order_id = self.mock_order.generate_testing_order(self.user_id)
self.mock_order.update_scenes(order_id, 'status', ['retry'])
self.mock_order.update_scenes(order_id, 'retry_after', [prev])
production_provider.handle_retry_products()
for s in Scene.where({'order_id': order_id}):
self.assertTrue(s.status == 'submitted')
def test_production_handle_retry_products(self):
prev = datetime.datetime.now() - datetime.timedelta(hours=1)
order_id = self.mock_order.generate_testing_order(self.user_id)
self.mock_order.update_scenes(order_id, 'status', ['retry'])
self.mock_order.update_scenes(order_id, 'retry_after', [prev])
production_provider.handle_retry_products()
for s in Scene.where({'order_id': order_id}):
self.assertTrue(s.status == 'submitted')
def update_scenes(self, order_id, stype, attribute, values):
scenes = Scene.where({'order_id': order_id, 'sensor_type': stype})
xscenes = chunkify(scenes, len(values))
for idx, value in enumerate(values):
for scene in xscenes[idx]:
scene.update(attribute, value)
return True
def test_production_calc_scene_download_sizes(self):
order = Order.find(self.mock_order.generate_testing_order(self.user_id))
scenes = order.scenes()
Scene.bulk_update([s.id for s in scenes], {'status': 'complete', 'download_size': 0})
scenes = Order.find(order.id).scenes({'status': 'complete', 'download_size': 0})
self.assertTrue(production_provider.calc_scene_download_sizes(scenes))
upscenes = Scene.where({'status': 'complete', 'download_size': 999})
self.assertEqual(len(upscenes), len(scenes))
def test_catch_orphaned_scenes(self):
order_id = self.mock_order.generate_testing_order(self.user_id)
# need scenes with statuses of 'queued'
self.mock_order.update_scenes(order_id, 'status', ['queued'])
response = production_provider.catch_orphaned_scenes()
self.assertTrue(response)
old_time = datetime.datetime.now() - datetime.timedelta(minutes=15)
for s in Scene.where({'order_id': order_id}):
self.assertTrue(s.reported_orphan is not None)
s.reported_orphan = old_time
s.save()
response = production_provider.catch_orphaned_scenes()
self.assertTrue(response)
for s in Scene.where({'order_id': order_id}):
self.assertTrue(s.orphaned)
def test_production_handle_failed_ee_updates(self):
order = Order.find(self.mock_order.generate_testing_order(self.user_id))
for scene in order.scenes():
scene.update('failed_lta_status_update', 'C')
production_provider.handle_failed_ee_updates()
scenes = Scene.where({'failed_lta_status_update IS NOT': None})
self.assertTrue(len(scenes) == 0)
def test_production_handle_failed_ee_updates(self):
order = Order.find(self.mock_order.generate_testing_order(self.user_id))
for scene in order.scenes():
scene.update('failed_lta_status_update', 'C')
production_provider.handle_failed_ee_updates()
scenes = Scene.where({'failed_lta_status_update IS NOT': None})
self.assertTrue(len(scenes) == 0)
def test_catch_orphaned_scenes(self):
order_id = self.mock_order.generate_testing_order(self.user_id)
# need scenes with statuses of 'queued'
self.mock_order.update_scenes(order_id, 'status', ['queued'])
response = production_provider.catch_orphaned_scenes()
self.assertTrue(response)
old_time = datetime.datetime.now() - datetime.timedelta(minutes=15)
for s in Scene.where({'order_id': order_id}):
self.assertTrue(s.reported_orphan is not None)
s.reported_orphan = old_time
s.save()
response = production_provider.catch_orphaned_scenes()
self.assertTrue(response)
for s in Scene.where({'order_id': order_id}):
self.assertTrue(s.orphaned)
def test_fetch_production_products_sentinel(self):
order_id = self.mock_order.generate_testing_order(self.user_id)
# need scenes with statuses of 'processing'
scenes = Scene.where({'order_id': order_id, 'sensor_type': 'sentinel'})
self.mock_order.update_scenes(order_id, 'sentinel', 'status',
['processing', 'oncache'])
user = User.find(self.user_id)
params = {'for_user': user.username, 'product_types': ['sentinel']}
response = api.fetch_production_products(params)
self.assertTrue('bilbo' in response[0]['orderid'])
def test_status_modified(self):
order_id = self.mock_order.generate_testing_order(self.user_id)
scene = Scene.where({'order_id': order_id}).pop()
scene.status = 'oncache'
scene.save()
old_time = scene.status_modified
scene.status = 'queued'
scene.save()
new_time = scene.status_modified
self.assertGreater(new_time, old_time)
def active_hadoop_job_names(self):
order_ids = tuple([
o.id for o in Order.where({
'status': 'ordered',
'user_id': self.id
})
])
return [
s.job_name for s in Scene.where({
'status': ('processing', 'queued'),
'order_id': order_ids
})
]
def test_update_product_details_fail_lta_mark_product_complete(self):
order = Order.find(self.mock_order.generate_testing_order(self.user_id))
scene = order.scenes()[1]
order.update('order_source', 'ee')
production_provider.update_product('mark_product_complete',
name=scene.name,
orderid=order.orderid,
processing_loc='L8SRLEXAMPLE',
completed_file_location='/some/loc',
cksum_file_location='some checksum',
log_file_contents='some log')
s = Scene.where({'name': scene.name, 'order_id': scene.order_id})[0]
self.assertTrue('C' == s.failed_lta_status_update)
def test_update_product_details_fail_lta_mark_product_complete(self):
order = Order.find(self.mock_order.generate_testing_order(self.user_id))
scene = order.scenes()[1]
order.update('order_source', 'ee')
production_provider.update_product('mark_product_complete',
name=scene.name,
orderid=order.orderid,
processing_loc='L8SRLEXAMPLE',
completed_file_location='/some/loc',
cksum_file_location='some checksum',
log_file_contents='some log')
s = Scene.where({'name': scene.name, 'order_id': scene.order_id})[0]
self.assertTrue('C' == s.failed_lta_status_update)
def scenes(self, sql_dict=None):
"""
Retrieve a list of Scene objects related to this
initialized Order object
:param sql_dict: dictionary object for sql parameters
:return: list of Scene objects
"""
if sql_dict:
sql_dict['order_id'] = self.id
else:
sql_dict = {'order_id': self.id}
return Scene.where(sql_dict)
def scenes(self, sql_dict=None):
"""
Retrieve a list of Scene objects related to this
initialized Order object
:param sql_dict: dictionary object for sql parameters
:return: list of Scene objects
"""
if sql_dict:
sql_dict['order_id'] = self.id
else:
sql_dict = {'order_id': self.id}
return Scene.where(sql_dict)
def get_user_scenes(cls, user_id, params=None):
"""
Retrieve a list of scenes associated with a user
:param user_id: user info
:param params: additional SQL query parameters
:return: list of scene objects
"""
user_orders = Order.where({'user_id': user_id})
if params is None:
params = dict()
params.update({'order_id': [o.id for o in user_orders]})
scene_list = Scene.where(params)
return scene_list
def scene_names_list(self, order_id):
scenes = Scene.where({'order_id': order_id})
names_list = [s.name for s in scenes]
return names_list
def scene_names_list(self, order_id):
scenes = Scene.where({'order_id': order_id})
names_list = [s.name for s in scenes]
return names_list
def check_dependencies_for_products(self, scene_list):
return Scene.where({'status': 'submitted', 'sensor_type': 'landsat'})
def check_valid_sentinel_false(token, prod_name_list):
_scenes = Scene.where({"status": "submitted", "sensor_type": "sentinel"})
_names = [s.name for s in _scenes]
return {_names[0]: False}
def check_valid_viirs(token, prod_name_list):
_scenes = Scene.where({"status": "submitted", "sensor_type": "viirs"})
_names = [s.name for s in _scenes]
return {_names[0]: True}
def check_valid_modis_unavailable(token, prod_name_list):
_scenes = Scene.where({"status": "submitted", "sensor_type": "modis"})
_names = [s.name for s in _scenes]
return {_names[0]: False}
