aws_erlang

%% WARNING: DO NOT EDIT, AUTO-GENERATED CODE!
%% See https://github.com/aws-beam/aws-codegen for more details.

%% @doc AWS Step Functions
%%
%% AWS Step Functions is a service that lets you coordinate the components of
%% distributed applications and microservices using visual workflows.
%%
%% You can use Step Functions to build applications from individual
%% components, each of which performs a discrete function, or task, allowing
%% you to scale and change applications quickly. Step Functions provides a
%% console that helps visualize the components of your application as a
%% series of steps. Step Functions automatically triggers and tracks each
%% step, and retries steps when there are errors, so your application
%% executes predictably and in the right order every time. Step Functions
%% logs the state of each step, so you can quickly diagnose and debug any
%% issues.
%%
%% Step Functions manages operations and underlying infrastructure to ensure
%% your application is available at any scale. You can run tasks on AWS, your
%% own servers, or any system that has access to AWS. You can access and use
%% Step Functions using the console, the AWS SDKs, or an HTTP API. For more
%% information about Step Functions, see the AWS Step Functions Developer
%% Guide .
-module(aws_sfn).

-export([create_activity/2,
         create_activity/3,
         create_state_machine/2,
         create_state_machine/3,
         delete_activity/2,
         delete_activity/3,
         delete_state_machine/2,
         delete_state_machine/3,
         describe_activity/2,
         describe_activity/3,
         describe_execution/2,
         describe_execution/3,
         describe_state_machine/2,
         describe_state_machine/3,
         describe_state_machine_for_execution/2,
         describe_state_machine_for_execution/3,
         get_activity_task/2,
         get_activity_task/3,
         get_execution_history/2,
         get_execution_history/3,
         list_activities/2,
         list_activities/3,
         list_executions/2,
         list_executions/3,
         list_state_machines/2,
         list_state_machines/3,
         list_tags_for_resource/2,
         list_tags_for_resource/3,
         send_task_failure/2,
         send_task_failure/3,
         send_task_heartbeat/2,
         send_task_heartbeat/3,
         send_task_success/2,
         send_task_success/3,
         start_execution/2,
         start_execution/3,
         start_sync_execution/2,
         start_sync_execution/3,
         stop_execution/2,
         stop_execution/3,
         tag_resource/2,
         tag_resource/3,
         untag_resource/2,
         untag_resource/3,
         update_state_machine/2,
         update_state_machine/3]).

-include_lib("hackney/include/hackney_lib.hrl").

%%====================================================================
%% API
%%====================================================================

%% @doc Creates an activity.
%%
%% An activity is a task that you write in any programming language and host
%% on any machine that has access to AWS Step Functions. Activities must poll
%% Step Functions using the `GetActivityTask' API action and respond using
%% `SendTask*' API actions. This function lets Step Functions know the
%% existence of your activity and returns an identifier for use in a state
%% machine and when polling from the activity.
%%
%% This operation is eventually consistent. The results are best effort and
%% may not reflect very recent updates and changes.
%%
%% `CreateActivity' is an idempotent API. Subsequent requests won’t create a
%% duplicate resource if it was already created. `CreateActivity''s
%% idempotency check is based on the activity `name'. If a following request
%% has different `tags' values, Step Functions will ignore these differences
%% and treat it as an idempotent request of the previous. In this case,
%% `tags' will not be updated, even if they are different.
create_activity(Client, Input)
  when is_map(Client), is_map(Input) ->
    create_activity(Client, Input, []).
create_activity(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"CreateActivity">>, Input, Options).

%% @doc Creates a state machine.
%%
%% A state machine consists of a collection of states that can do work
%% (`Task' states), determine to which states to transition next (`Choice'
%% states), stop an execution with an error (`Fail' states), and so on. State
%% machines are specified using a JSON-based, structured language. For more
%% information, see Amazon States Language in the AWS Step Functions User
%% Guide.
%%
%% This operation is eventually consistent. The results are best effort and
%% may not reflect very recent updates and changes.
%%
%% `CreateStateMachine' is an idempotent API. Subsequent requests won’t
%% create a duplicate resource if it was already created.
%% `CreateStateMachine''s idempotency check is based on the state machine
%% `name', `definition', `type', `LoggingConfiguration' and
%% `TracingConfiguration'. If a following request has a different `roleArn'
%% or `tags', Step Functions will ignore these differences and treat it as an
%% idempotent request of the previous. In this case, `roleArn' and `tags'
%% will not be updated, even if they are different.
create_state_machine(Client, Input)
  when is_map(Client), is_map(Input) ->
    create_state_machine(Client, Input, []).
create_state_machine(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"CreateStateMachine">>, Input, Options).

%% @doc Deletes an activity.
delete_activity(Client, Input)
  when is_map(Client), is_map(Input) ->
    delete_activity(Client, Input, []).
delete_activity(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"DeleteActivity">>, Input, Options).

%% @doc Deletes a state machine.
%%
%% This is an asynchronous operation: It sets the state machine's status to
%% `DELETING' and begins the deletion process.
%%
%% For `EXPRESS'state machines, the deletion will happen eventually (usually
%% less than a minute). Running executions may emit logs after
%% `DeleteStateMachine' API is called.
delete_state_machine(Client, Input)
  when is_map(Client), is_map(Input) ->
    delete_state_machine(Client, Input, []).
delete_state_machine(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"DeleteStateMachine">>, Input, Options).

%% @doc Describes an activity.
%%
%% This operation is eventually consistent. The results are best effort and
%% may not reflect very recent updates and changes.
describe_activity(Client, Input)
  when is_map(Client), is_map(Input) ->
    describe_activity(Client, Input, []).
describe_activity(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"DescribeActivity">>, Input, Options).

%% @doc Describes an execution.
%%
%% This operation is eventually consistent. The results are best effort and
%% may not reflect very recent updates and changes.
%%
%% This API action is not supported by `EXPRESS' state machines.
describe_execution(Client, Input)
  when is_map(Client), is_map(Input) ->
    describe_execution(Client, Input, []).
describe_execution(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"DescribeExecution">>, Input, Options).

%% @doc Describes a state machine.
%%
%% This operation is eventually consistent. The results are best effort and
%% may not reflect very recent updates and changes.
describe_state_machine(Client, Input)
  when is_map(Client), is_map(Input) ->
    describe_state_machine(Client, Input, []).
describe_state_machine(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"DescribeStateMachine">>, Input, Options).

%% @doc Describes the state machine associated with a specific execution.
%%
%% This operation is eventually consistent. The results are best effort and
%% may not reflect very recent updates and changes.
%%
%% This API action is not supported by `EXPRESS' state machines.
describe_state_machine_for_execution(Client, Input)
  when is_map(Client), is_map(Input) ->
    describe_state_machine_for_execution(Client, Input, []).
describe_state_machine_for_execution(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"DescribeStateMachineForExecution">>, Input, Options).

%% @doc Used by workers to retrieve a task (with the specified activity ARN)
%% which has been scheduled for execution by a running state machine.
%%
%% This initiates a long poll, where the service holds the HTTP connection
%% open and responds as soon as a task becomes available (i.e. an execution
%% of a task of this type is needed.) The maximum time the service holds on
%% to the request before responding is 60 seconds. If no task is available
%% within 60 seconds, the poll returns a `taskToken' with a null string.
%%
%% Workers should set their client side socket timeout to at least 65 seconds
%% (5 seconds higher than the maximum time the service may hold the poll
%% request).
%%
%% Polling with `GetActivityTask' can cause latency in some implementations.
%% See Avoid Latency When Polling for Activity Tasks in the Step Functions
%% Developer Guide.
get_activity_task(Client, Input)
  when is_map(Client), is_map(Input) ->
    get_activity_task(Client, Input, []).
get_activity_task(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"GetActivityTask">>, Input, Options).

%% @doc Returns the history of the specified execution as a list of events.
%%
%% By default, the results are returned in ascending order of the `timeStamp'
%% of the events. Use the `reverseOrder' parameter to get the latest events
%% first.
%%
%% If `nextToken' is returned, there are more results available. The value of
%% `nextToken' is a unique pagination token for each page. Make the call
%% again using the returned token to retrieve the next page. Keep all other
%% arguments unchanged. Each pagination token expires after 24 hours. Using
%% an expired pagination token will return an HTTP 400 InvalidToken error.
%%
%% This API action is not supported by `EXPRESS' state machines.
get_execution_history(Client, Input)
  when is_map(Client), is_map(Input) ->
    get_execution_history(Client, Input, []).
get_execution_history(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"GetExecutionHistory">>, Input, Options).

%% @doc Lists the existing activities.
%%
%% If `nextToken' is returned, there are more results available. The value of
%% `nextToken' is a unique pagination token for each page. Make the call
%% again using the returned token to retrieve the next page. Keep all other
%% arguments unchanged. Each pagination token expires after 24 hours. Using
%% an expired pagination token will return an HTTP 400 InvalidToken error.
%%
%% This operation is eventually consistent. The results are best effort and
%% may not reflect very recent updates and changes.
list_activities(Client, Input)
  when is_map(Client), is_map(Input) ->
    list_activities(Client, Input, []).
list_activities(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"ListActivities">>, Input, Options).

%% @doc Lists the executions of a state machine that meet the filtering
%% criteria.
%%
%% Results are sorted by time, with the most recent execution first.
%%
%% If `nextToken' is returned, there are more results available. The value of
%% `nextToken' is a unique pagination token for each page. Make the call
%% again using the returned token to retrieve the next page. Keep all other
%% arguments unchanged. Each pagination token expires after 24 hours. Using
%% an expired pagination token will return an HTTP 400 InvalidToken error.
%%
%% This operation is eventually consistent. The results are best effort and
%% may not reflect very recent updates and changes.
%%
%% This API action is not supported by `EXPRESS' state machines.
list_executions(Client, Input)
  when is_map(Client), is_map(Input) ->
    list_executions(Client, Input, []).
list_executions(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"ListExecutions">>, Input, Options).

%% @doc Lists the existing state machines.
%%
%% If `nextToken' is returned, there are more results available. The value of
%% `nextToken' is a unique pagination token for each page. Make the call
%% again using the returned token to retrieve the next page. Keep all other
%% arguments unchanged. Each pagination token expires after 24 hours. Using
%% an expired pagination token will return an HTTP 400 InvalidToken error.
%%
%% This operation is eventually consistent. The results are best effort and
%% may not reflect very recent updates and changes.
list_state_machines(Client, Input)
  when is_map(Client), is_map(Input) ->
    list_state_machines(Client, Input, []).
list_state_machines(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"ListStateMachines">>, Input, Options).

%% @doc List tags for a given resource.
%%
%% Tags may only contain Unicode letters, digits, white space, or these
%% symbols: `_ . : / = + - @'.
list_tags_for_resource(Client, Input)
  when is_map(Client), is_map(Input) ->
    list_tags_for_resource(Client, Input, []).
list_tags_for_resource(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"ListTagsForResource">>, Input, Options).

%% @doc Used by activity workers and task states using the callback pattern
%% to report that the task identified by the `taskToken' failed.
send_task_failure(Client, Input)
  when is_map(Client), is_map(Input) ->
    send_task_failure(Client, Input, []).
send_task_failure(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"SendTaskFailure">>, Input, Options).

%% @doc Used by activity workers and task states using the callback pattern
%% to report to Step Functions that the task represented by the specified
%% `taskToken' is still making progress.
%%
%% This action resets the `Heartbeat' clock. The `Heartbeat' threshold is
%% specified in the state machine's Amazon States Language definition
%% (`HeartbeatSeconds'). This action does not in itself create an event in
%% the execution history. However, if the task times out, the execution
%% history contains an `ActivityTimedOut' entry for activities, or a
%% `TaskTimedOut' entry for for tasks using the job run or callback pattern.
%%
%% The `Timeout' of a task, defined in the state machine's Amazon States
%% Language definition, is its maximum allowed duration, regardless of the
%% number of `SendTaskHeartbeat' requests received. Use `HeartbeatSeconds' to
%% configure the timeout interval for heartbeats.
send_task_heartbeat(Client, Input)
  when is_map(Client), is_map(Input) ->
    send_task_heartbeat(Client, Input, []).
send_task_heartbeat(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"SendTaskHeartbeat">>, Input, Options).

%% @doc Used by activity workers and task states using the callback pattern
%% to report that the task identified by the `taskToken' completed
%% successfully.
send_task_success(Client, Input)
  when is_map(Client), is_map(Input) ->
    send_task_success(Client, Input, []).
send_task_success(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"SendTaskSuccess">>, Input, Options).

%% @doc Starts a state machine execution.
%%
%% `StartExecution' is idempotent. If `StartExecution' is called with the
%% same name and input as a running execution, the call will succeed and
%% return the same response as the original request. If the execution is
%% closed or if the input is different, it will return a 400
%% `ExecutionAlreadyExists' error. Names can be reused after 90 days.
start_execution(Client, Input)
  when is_map(Client), is_map(Input) ->
    start_execution(Client, Input, []).
start_execution(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"StartExecution">>, Input, Options).

%% @doc Starts a Synchronous Express state machine execution.
start_sync_execution(Client, Input)
  when is_map(Client), is_map(Input) ->
    start_sync_execution(Client, Input, []).
start_sync_execution(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"StartSyncExecution">>, Input, Options).

%% @doc Stops an execution.
%%
%% This API action is not supported by `EXPRESS' state machines.
stop_execution(Client, Input)
  when is_map(Client), is_map(Input) ->
    stop_execution(Client, Input, []).
stop_execution(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"StopExecution">>, Input, Options).

%% @doc Add a tag to a Step Functions resource.
%%
%% An array of key-value pairs. For more information, see Using Cost
%% Allocation Tags in the AWS Billing and Cost Management User Guide, and
%% Controlling Access Using IAM Tags.
%%
%% Tags may only contain Unicode letters, digits, white space, or these
%% symbols: `_ . : / = + - @'.
tag_resource(Client, Input)
  when is_map(Client), is_map(Input) ->
    tag_resource(Client, Input, []).
tag_resource(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"TagResource">>, Input, Options).

%% @doc Remove a tag from a Step Functions resource
untag_resource(Client, Input)
  when is_map(Client), is_map(Input) ->
    untag_resource(Client, Input, []).
untag_resource(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"UntagResource">>, Input, Options).

%% @doc Updates an existing state machine by modifying its `definition',
%% `roleArn', or `loggingConfiguration'.
%%
%% Running executions will continue to use the previous `definition' and
%% `roleArn'. You must include at least one of `definition' or `roleArn' or
%% you will receive a `MissingRequiredParameter' error.
%%
%% All `StartExecution' calls within a few seconds will use the updated
%% `definition' and `roleArn'. Executions started immediately after calling
%% `UpdateStateMachine' may use the previous state machine `definition' and
%% `roleArn'.
update_state_machine(Client, Input)
  when is_map(Client), is_map(Input) ->
    update_state_machine(Client, Input, []).
update_state_machine(Client, Input, Options)
  when is_map(Client), is_map(Input), is_list(Options) ->
    request(Client, <<"UpdateStateMachine">>, Input, Options).

%%====================================================================
%% Internal functions
%%====================================================================

-spec request(aws_client:aws_client(), binary(), map(), list()) ->
    {ok, Result, {integer(), list(), hackney:client()}} |
    {error, Error, {integer(), list(), hackney:client()}} |
    {error, term()} when
    Result :: map() | undefined,
    Error :: map().
request(Client, Action, Input0, Options) ->
    Client1 = Client#{service => <<"states">>},
    Host = build_host(<<"states">>, Client1),
    URL = build_url(Host, Client1),
    Headers = [
        {<<"Host">>, Host},
        {<<"Content-Type">>, <<"application/x-amz-json-1.0">>},
        {<<"X-Amz-Target">>, <<"AWSStepFunctions.", Action/binary>>}
    ],

    Input = Input0,

    Payload = jsx:encode(Input),
    SignedHeaders = aws_request:sign_request(Client1, <<"POST">>, URL, Headers, Payload),
    Response = hackney:request(post, URL, SignedHeaders, Payload, Options),
    handle_response(Response).

handle_response({ok, 200, ResponseHeaders, Client}) ->
    case hackney:body(Client) of
        {ok, <<>>} ->
            {ok, undefined, {200, ResponseHeaders, Client}};
        {ok, Body} ->
            Result = jsx:decode(Body),
            {ok, Result, {200, ResponseHeaders, Client}}
    end;
handle_response({ok, StatusCode, ResponseHeaders, Client}) ->
    {ok, Body} = hackney:body(Client),
    Error = jsx:decode(Body),
    {error, Error, {StatusCode, ResponseHeaders, Client}};
handle_response({error, Reason}) ->
    {error, Reason}.

build_host(_EndpointPrefix, #{region := <<"local">>, endpoint := Endpoint}) ->
    Endpoint;
build_host(_EndpointPrefix, #{region := <<"local">>}) ->
    <<"localhost">>;
build_host(EndpointPrefix, #{region := Region, endpoint := Endpoint}) ->
    aws_util:binary_join([EndpointPrefix, Region, Endpoint], <<".">>).

build_url(Host, Client) ->
    Proto = maps:get(proto, Client),
    Port = maps:get(port, Client),
    aws_util:binary_join([Proto, <<"://">>, Host, <<":">>, Port, <<"/">>], <<"">>).