Skip to main content
100%

get step function status

✓ Published0🌍 Public
Aandresmijares
Last edited Apr 3, 2018
Created on Apr 3, 2018

This example shows the status of a Step Functions execution by extracting the departure forecast from its event history. It queries the execution history using the AWS SDK’s `StepFunctions.getExecutionHistory` method, then filters for `PassStateEntered` events to parse the flight and forecast data embedded in the state input. The handler, written with `co.wrap` and Bluebird promises, returns the execution ARN and the parsed departure object as a JSON response via an API Gateway Lambda trigger.

AI-generated description

Similar vizzes

Loading thumbnail…

get-departure-step-fn

This example shows an AWS Lambda function that triggers a Step Functions state machine to fetch departure data for a given ID and date. It lists all state machines, filters for one named `GetDepartureMachine`, and starts an execution with the query parameters as JSON input. The code uses the AWS SDK for JavaScript (`aws-sdk`) with `AWS.StepFunctions`, `co` for generator-based control flow, and `Promise` from Bluebird. It returns the execution ARN in an HTTP response, logging “finish” before invoking the callback.

Aandresmijares
75% match
Loading thumbnail…

Gist ef99831492181718c41fd4331d226a74

This example shows the control flow of an AWS Step Functions state machine that checks a date before deciding whether to update a Fantasy Premier League team. A chain of AWS Lambda functions retrieves player odds and details, calculates transfers, and posts updates to the team. The visualization uses the state machine’s declarative JSON definition to map states and transitions, including a choice point that branches to a success state or continues to further tasks. It relies on the Step Functions API for orchestration, not on a separate plotting library.

CConorAspell
58% match
Loading thumbnail…

Step Machine definition

This example visualizes the structure of an AWS Step Functions state machine definition, showing how parallel branches and sequential states compose a workflow. The rendered diagram maps the YAML configuration from a serverless.yml file, displaying the “Parallel” state that splits into two concurrent tasks—GetFlight and GetForecast—before converging at the FinalState. The visualization uses the Step Functions definition’s explicit StartAt, Type, Next, and End fields to determine node placement and edge routing. It relies on the serverless framework’s stepFunctions configuration to parse the state machine’s branching logic, with resource ARNs referencing Lambda functions for each task.

Aandresmijares
58% match
Loading thumbnail…

Lambda triggers other lambdas

This example shows how one AWS Lambda function orchestrates two other Lambda functions to compose a departure response. The `get-departure.js` handler receives query parameters for an `id` and `date`, then invokes `get-flight` and `get-forecast` functions concurrently using the AWS SDK’s `Lambda.invoke` API with `InvocationType: "RequestResponse"`. It uses Bluebird’s `Promise.all` to await both payloads, parses each JSON response, and returns a combined `departure` object containing the forecast and flight data. The code demonstrates a saga-style pattern for coordinating dependent serverless calls.

Aandresmijares
56% match
Loading thumbnail…

Gist ed5c09d69d4e5d65c6ec5faafaea7e08

This example shows an AWS Step Functions state machine that automates a two-step data pipeline for controlling Fantasy Premier League updates. The workflow first invokes an `oddsGetter` Lambda function to fetch betting odds, then passes the result to a `storeFPLData` Lambda function, which persists the data and ends the process. The visualization uses the Step Functions JSON state machine definition to render the sequential task flow, with explicit `Resource` ARNs linking to the Lambda functions. The graph displays the `StartAt` and `End` states, making the linear execution path and the service integrations clear without showing runtime behavior or intermediate data handling.

CConorAspell
56% match
Loading thumbnail…

Gist 4523b841021e154daebbf9c9bccaae7b

This visualization is a linear flow diagram of an AWS Step Functions state machine that orchestrates a Fantasy Premier League update. It shows three sequential tasks—DateChecker, OddsGetter, and UpdateFPLTeam—each represented as a labeled node with a resource ARN. The diagram uses rectangular and rounded-rectangle shapes connected by arrows to indicate execution order, with the final node marked as terminal. The underlying JSON definition (visible in the accompanying file) defines the state transitions, while the rendered view likely employs a graph layout library such as D3.js or a similar tool to position nodes and edges. The data source is the embedded stateMachine.txt file, which exposes the exact Lambda function names and control flow.

CConorAspell
50% match
Loading thumbnail…

App Flow Proto 2

This example shows a JavaScript application module that coordinates step updates through database transactions and post-commit effects. The code demonstrates dependency injection with factory functions like `createStep` and `stepFactory`, alongside utility containers for managing operations. It uses Sequelize’s `startTransaction` for database writes, while an `effectsContainer` pattern collects and executes deferred operations. The `applyUpdates` helper and `createHistoryRecord` suggest data transformation and logging, though no specific visualization library or rendering API appears in the provided source.

RRestuta
46% match
Loading thumbnail…

Gist c52a8d028d9be31e5ee21b9c3d409d54

This visualization demonstrates a geofencing SDK that predicts a user’s likely destination upon departure from a known location. The code listens for a departure event via `SetSDK.instance.onDeparture(.home)`, then calls `getDestination(fromLocation:fromTimestamp:)` to return ranked destination predictions. It shows how the SDK filters the top candidate from the returned array, highlighting the core API flow for location-based prediction. The example uses Swift and the SetSDK instance, with no rendering or charting libraries involved, focusing purely on the data-handling logic.

Aandrewxhill
45% match