def fail_first_and_wait(context):
file = os.path.join(context.solid_config, "i_threw_up")
if os.path.exists(file):
return "okay perfect"
else:
open(file, "a").close()
raise RetryRequested(seconds_to_wait=DELAY)
def dbt_rpc_snapshot_and_wait(context: SolidExecutionContext) -> DbtRpcOutput:
"""This solid sends the ``dbt snapshot`` command to a dbt RPC server and returns the result of
the executed dbt process.
This dbt RPC solid is synchronous, and will periodically poll the dbt RPC server until the dbt
process is completed.
"""
if context.solid_config["task_tags"]:
results = context.resources.dbt_rpc.ps().json()
for task in results["result"]["rows"]:
if task["tags"] == context.solid_config["task_tags"]:
context.log.warning(
f"RPC task with tags {json.dumps(task['tags'])} currently running."
)
raise RetryRequested(
max_retries=context.solid_config["max_retries"],
seconds_to_wait=context.solid_config["retry_interval"],
)
resp = context.resources.dbt_rpc.snapshot(
select=context.solid_config["select"],
exclude=context.solid_config["exclude"])
context.log.debug(resp.text)
raise_for_rpc_error(context, resp)
request_token = resp.json().get("result").get("request_token")
return _poll_rpc(
context,
request_token,
should_yield_materializations=context.
solid_config["yield_materializations"],
)
def fail_first_time(context):
event_records = context.instance.all_logs(context.run_id)
for event_record in event_records:
context.log.info(event_record.message)
if 'Started re-execution' in event_record.message:
return 'okay perfect'
raise RetryRequested()
def manual():
try:
fails_sometimes()
except Exception as e:
if should_retry(e):
raise RetryRequested(max_retries=1, seconds_to_wait=1) from e
else:
raise
def retry_solid(context):
time.sleep(0.1)
if (context.retry_number + 1) >= context.solid_config["work_on_attempt"]:
return "success"
else:
raise RetryRequested(
max_retries=context.solid_config["max_retries"],
seconds_to_wait=context.solid_config["delay"],
)
def raise_for_rpc_error(context: SolidExecutionContext,
resp: Response) -> None:
error = resp.json().get("error")
if error is not None:
if error["code"] in [
DBTErrors.project_currently_compiling_error,
DBTErrors.runtime_error,
DBTErrors.server_error,
]:
context.log.warning(error["message"])
raise RetryRequested(max_retries=5,
seconds_to_wait=30) # TODO backoff logic
elif error["code"] == DBTErrors.project_compile_failure_error:
raise Failure(
description=error["message"],
metadata_entries=[
EventMetadataEntry.text(text=str(error["code"]),
label="RPC Error Code"),
EventMetadataEntry.text(
text=error["data"]["cause"]["message"],
label="RPC Error Cause"),
],
)
elif error["code"] == DBTErrors.rpc_process_killed_error:
raise Failure(
description=error["message"],
metadata_entries=[
EventMetadataEntry.text(text=str(error["code"]),
label="RPC Error Code"),
EventMetadataEntry.text(text=str(error["data"]["signum"]),
label="RPC Signum"),
EventMetadataEntry.text(text=error["data"]["message"],
label="RPC Error Message"),
],
)
elif error["code"] == DBTErrors.rpc_timeout_error:
raise Failure(
description=error["message"],
metadata_entries=[
EventMetadataEntry.text(text=str(error["code"]),
label="RPC Error Code"),
EventMetadataEntry.text(text=str(error["data"]["timeout"]),
label="RPC Timeout"),
EventMetadataEntry.text(text=error["data"]["message"],
label="RPC Error Message"),
],
)
else:
raise Failure(
description=error["message"],
metadata_entries=[
EventMetadataEntry.text(text=str(error["code"]),
label="RPC Error Code"),
],
)
def retry_solid(context):
time.sleep(1)
global _ATTEMPTS # pylint: disable=global-statement
_ATTEMPTS += 1
if _ATTEMPTS >= context.solid_config["work_on_attempt"]:
return "success"
else:
raise RetryRequested(
max_retries=context.solid_config["max_retries"],
seconds_to_wait=context.solid_config["delay"],
)
def dbt_rpc_run_and_wait(context: SolidExecutionContext) -> DbtRpcOutput:
"""This solid sends the ``dbt run`` command to a dbt RPC server and returns the result of the
executed dbt process.
This dbt RPC solid is synchronous, and will periodically poll the dbt RPC server until the dbt
process is completed.
"""
if context.solid_config["task_tags"]:
results = context.resources.dbt_rpc.ps().json()
for task in results["result"]["rows"]:
if task["tags"] == context.solid_config["task_tags"]:
context.log.warning(
f"RPC task with tags {json.dumps(task['tags'])} currently running."
)
raise RetryRequested(
max_retries=context.solid_config["max_retries"],
seconds_to_wait=context.solid_config["retry_interval"],
)
command = ""
if context.solid_config["warn_error"]:
command += " --warn-error"
command += " run"
if context.solid_config["models"]:
models = " ".join(set(context.solid_config["models"]))
command += f" --models {models}"
if context.solid_config["exclude"]:
exclude = " ".join(set(context.solid_config["exclude"]))
command += f" --exclude {exclude}"
if context.solid_config["full_refresh"]:
command += " --full-refresh"
if context.solid_config["fail_fast"]:
command += " --fail-fast"
context.log.debug(f"Running dbt command: dbt {command}")
out = context.resources.dbt_rpc.cli(
command=command, task_tags=context.solid_config["task_tags"]
)
context.log.debug(out.response.text)
raise_for_rpc_error(context, out.response)
request_token = out.result.get("request_token")
return _poll_rpc(
context,
request_token,
should_yield_materializations=context.solid_config["yield_materializations"],
)
def _post(self, data: str = None) -> requests.Response:
"""Constructs a standard way of making a POST request to the dbt RPC server."""
headers = self._construct_headers()
try:
response = requests.post(self.url, headers=headers, data=data)
response.raise_for_status()
except requests.exceptions.HTTPError as e:
if is_fatal_code(e):
raise e
else:
raise RetryRequested(max_retries=5,
seconds_to_wait=30) # TODO backoff logic
return response
def dynamic_download_items(context, id_range: Tuple[int, int]) -> List[dict]:
start_id, end_id = id_range
context.log.info(
f"Downloading range {start_id} up to {end_id}: {end_id - start_id} items."
)
try:
return [
context.resources.hn_client.fetch_item_by_id(item_id)
for item_id in range(start_id, end_id)
]
except Exception as e:
raise RetryRequested(max_retries=3) from e
def _act_on_config(solid_config):
if solid_config["throw_in_solid"]:
raise Failure(
description="I'm a Failure",
metadata_entries=[
EventMetadataEntry.text(
label="metadata_label",
text="I am metadata text",
description="metadata_description",
)
],
)
elif solid_config["request_retry"]:
raise RetryRequested()
def _act_on_config(solid_config):
if solid_config['throw_in_solid']:
raise Failure(
description="I'm a Failure",
metadata_entries=[
EventMetadataEntry.text(
label='metadata_label',
text='I am metadata text',
description='metadata_description',
)
],
)
elif solid_config['request_retry']:
raise RetryRequested()
def _post(self, data: str = None) -> requests.Response:
"""Constructs and sends a POST request to the dbt RPC server.
Returns:
Response: the HTTP response from the dbt RPC server.
"""
headers = self._construct_headers()
try:
response = requests.post(self.url, headers=headers, data=data)
response.raise_for_status()
except requests.exceptions.HTTPError as e:
if is_fatal_code(e):
raise e
else:
raise RetryRequested(max_retries=5, seconds_to_wait=30)
return response
def _act_on_config(solid_config):
if solid_config["crash_in_solid"]:
segfault()
if solid_config["failure_in_solid"]:
try:
raise ExampleException("sample cause exception")
except ExampleException as e:
raise Failure(
description="I'm a Failure",
metadata={
"metadata_label": "I am metadata text",
},
) from e
elif solid_config["throw_in_solid"]:
raise ExampleException("I threw up")
elif solid_config["request_retry"]:
raise RetryRequested()
def _act_on_config(solid_config):
if solid_config["crash_in_solid"]:
segfault()
if solid_config["throw_in_solid"]:
try:
raise ExampleException("sample cause exception")
except ExampleException as e:
raise Failure(
description="I'm a Failure",
metadata_entries=[
EventMetadataEntry.text(
label="metadata_label",
text="I am metadata text",
description="metadata_description",
)
],
) from e
elif solid_config["request_retry"]:
raise RetryRequested()
def dbt_rpc_run_and_wait(context) -> DbtRpcPollResult:
if context.solid_config["task_tags"]:
results = context.resources.dbt_rpc.ps().json()
for task in results["result"]["rows"]:
if task["tags"] == context.solid_config["task_tags"]:
context.log.warning(
f"RPC task with tags {json.dumps(task['tags'])} currently running."
)
raise RetryRequested(
max_retries=context.solid_config["max_retries"],
seconds_to_wait=context.solid_config["retry_interval"],
)
command = ""
if context.solid_config["warn_error"]:
command += " --warn-error"
command += " run"
if context.solid_config["models"]:
models = " ".join(set(context.solid_config["models"]))
command += f" --models {models}"
if context.solid_config["exclude"]:
exclude = " ".join(set(context.solid_config["exclude"]))
command += f" --exclude {exclude}"
if context.solid_config["full_refresh"]:
command += " --full-refresh"
if context.solid_config["fail_fast"]:
command += " --fail-fast"
context.log.debug(f"Running dbt command: dbt {command}")
resp = context.resources.dbt_rpc.cli(cli=command,
**context.solid_config["task_tags"])
context.log.debug(resp.text)
raise_for_rpc_error(context, resp)
request_token = resp.json().get("result").get("request_token")
return dbt_rpc_poll(context, request_token)
def raise_for_rpc_error(context: SolidExecutionContext,
resp: Response) -> None:
error = resp.json().get("error")
if error is not None:
if error["code"] in [
DBTErrors.project_currently_compiling_error.value,
DBTErrors.runtime_error.value,
DBTErrors.server_error.value,
]:
context.log.warning(error["message"])
raise RetryRequested(max_retries=5, seconds_to_wait=30)
elif error["code"] == DBTErrors.project_compile_failure_error.value:
raise Failure(
description=error["message"],
metadata={
"RPC Error Code": str(error["code"]),
"RPC Error Cause": error["data"]["cause"]["message"],
},
)
elif error["code"] == DBTErrors.rpc_process_killed_error.value:
raise Failure(
description=error["message"],
metadata={
"RPC Error Code": str(error["code"]),
"RPC Signum": str(error["data"]["signum"]),
"RPC Error Message": error["data"]["message"],
},
)
elif error["code"] == DBTErrors.rpc_timeout_error.value:
raise Failure(
description=error["message"],
metadata={
"RPC Error Code": str(error["code"]),
"RPC Timeout": str(error["data"]["timeout"]),
"RPC Error Message": error["data"]["message"],
},
)
else:
raise Failure(
description=error["message"],
metadata={"RPC Error Code": str(error["code"])},
)
def dbt_rpc_snapshot_and_wait(context) -> DbtRpcPollResult:
if context.solid_config["task_tags"]:
results = context.resources.dbt_rpc.ps().json()
for task in results["result"]["rows"]:
if task["tags"] == context.solid_config["task_tags"]:
context.log.warning(
f"RPC task with tags {json.dumps(task['tags'])} currently running."
)
raise RetryRequested(
max_retries=context.solid_config["max_retries"],
seconds_to_wait=context.solid_config["retry_interval"],
)
resp = context.resources.dbt_rpc.snapshot(
select=context.solid_config["select"],
exclude=context.solid_config["exclude"])
context.log.debug(resp.text)
raise_for_rpc_error(context, resp)
request_token = resp.json().get("result").get("request_token")
return dbt_rpc_poll(context, request_token)
def launch_step(self, step_context, prior_attempts_count):
if prior_attempts_count == 0:
raise RetryRequested()
else:
return super(RequestRetryLocalExternalStepLauncher,
self).launch_step(step_context, prior_attempts_count)
def should_retry(context, _input):
raise RetryRequested(max_retries=3)
def my_retry_solid():
try:
result = flaky_operation()
except:
raise RetryRequested(max_retries=3)
return result
def retries():
raise RetryRequested()
def retry_request():
raise RetryRequested()
def solid_retries():
raise RetryRequested()
def three_max():
raise RetryRequested(max_retries=3)
def default_max():
raise RetryRequested()
def my_retry_op():
try:
result = flaky_operation()
except Exception as e:
raise RetryRequested(max_retries=3) from e
return result
def handle_output(self, _context, _obj):
raise RetryRequested(max_retries=3)
def handle_output(self, _context, _obj):
if _count["total"] < 2:
_count["total"] += 1
raise RetryRequested(max_retries=3)