def test_exponential_backoff_success_after_failure(self, mock_sleep):
fake_fun = Mock()
fake_fun.side_effect = [1, 1, 0]
exit_code = exponential_backoff(fake_fun, check_fun_test)
self.assertEqual(mock_sleep.call_count, 2)
self.assertEqual(exit_code, 0)
def accept_ert_eula(my_settings: settings.Settings):
response, result = util.exponential_backoff(
functools.partial(post_eula, my_settings, "elastic-runtime",
my_settings.ert_release_id), check_eula_succeeded)
if result == EULAResult.SUCCESS:
return "Success", "", 0
else:
return "Failed to accept ERT EULA; status code from Pivotal Network {}".format(
response.status_code), "", 1
def accept_stemcell_eula(my_settings: settings.Settings):
response, result = util.exponential_backoff(
functools.partial(post_eula, my_settings, "stemcells-ubuntu-xenial",
my_settings.stemcell_release_id),
check_eula_succeeded)
if result == EULAResult.SUCCESS:
return "Success", "", 0
else:
return "Failed to accept stemcell EULA; status code from Pivotal Network {}".format(
response.status_code), "", 1
def test_exponential_backoff_failing(self, mock_sleep):
test = Mock()
test.return_value = 1
exit_code = exponential_backoff(test, check_fun_test)
self.assertEqual(mock_sleep.call_count, 5)
self.assertEqual(mock_sleep.call_args_list[0][0][0], 0)
self.assertEqual(mock_sleep.call_args_list[1][0][0], 1)
self.assertEqual(mock_sleep.call_args_list[2][0][0], 8)
self.assertEqual(mock_sleep.call_args_list[3][0][0], 27)
self.assertEqual(mock_sleep.call_args_list[4][0][0], 64)
self.assertEqual(exit_code, 1)
def header_value(auth_token: str):
success = False
if re.search("-r$", auth_token):
print("Refresh Token")
# then it's a refresh token
access_token, success = util.exponential_backoff(
functools.partial(refresh_token_grant, auth_token),
check_refresh_succeeded)
if success:
authHeaderValue = "Bearer {}".format(access_token)
else:
# it isn't a refresh token. It could be a legacy token... or just plain
# wrong. Either way, hand back a legacy auth
authHeaderValue = "Token {}".format(auth_token)
print("Legacy Token")
success = True
print("Auth token success is {}".format(success))
return authHeaderValue, success
name = ('%s [%s]' % (data['farmfieldname'][:(61-len(data['leadpi']))],
data['leadpi'])).replace("\n", " ")
if data['latitudedd.d'] == 'TBD':
print 'Skipping %s due to TBD location' % (name,)
continue
cursor.execute("""SELECT climate_site from stations where id = %s
and network = 'TD'
""", (siteid,))
if cursor.rowcount == 0:
cursor.execute("""INSERT into stations (id, name, state, country,
network, online, geom, metasite) VALUES (%s, %s, %s, 'US',
'TD', 'f', %s, 't')""", (siteid, name, data['state'],
'SRID=4326;POINT(%s %s)' % (
data['longitudeddd.d'],
data['latitudedd.d'])))
else:
cursor.execute("""UPDATE stations SET name = %s
WHERE id = %s and network = 'TD' RETURNING climate_site
""", (name, siteid))
climatesite = cursor.fetchone()[0]
if (climatesite is not None and climatesite != '' and
climatesite != data['iemclimatesite']):
entry.set_value('iemclimatesite', climatesite)
print 'Setting climate site: %s for site: %s' % (climatesite,
siteid)
util.exponential_backoff(spr_client.update, entry)
cursor.close()
pgconn.commit()
pgconn.close()
def test_multiple_returns(self, mock_sleep):
fun = Mock()
fun.return_value = "Some random output", "Success"
exit_code = exponential_backoff(fun, check_multiple_returns)
mock_sleep.assert_not_called()
self.assertEqual(exit_code, ("Some random output", "Success"))
def test_exponential_backoff_success(self, mock_sleep):
test = Mock()
test.return_value = 0
exit_code = exponential_backoff(test, check_fun_test)
mock_sleep.assert_not_called()
self.assertEqual(exit_code, 0)
def report_status_backoff(my_settings: settings.Settings, req_type: str, reason: str, logical_res_id: str, status: str):
return util.exponential_backoff(
functools.partial(report_status, my_settings, req_type, reason, logical_res_id, status),
check_report_status
)
