n8nworkflows.xyz/workflows/Prevent Concurrent Workflow Runs Using Redis-3976/readme-3976.md

Prevent Concurrent Workflow Runs Using Redis

https://n8nworkflows.xyz/workflows/prevent-concurrent-workflow-runs-using-redis-3976

Prevent Concurrent Workflow Runs Using Redis

1. Workflow Overview

This workflow is designed to prevent concurrent executions of the same long-running job by using Redis as a locking mechanism. It ensures that only one instance of a workflow runs at a time for a given job key, protecting data integrity and avoiding rate-limit breaches. Additionally, it tracks and exposes live progress states (like "working", "loading", "finishing") which can be polled to monitor job status in real time.

Target Use Cases:

• Avoiding parallel runs triggered by webhooks, cron jobs, or nested workflow calls
• Implementing lightweight locking without full queue systems
• Tracking progress of long jobs with live status updates
• Rate-limit protection for external API calls
• Filtering burst callback spam (e.g., Telegram bots)
• Ensuring maintenance tasks don’t overlap

Logical Blocks:

• 1.1 Input Reception: Receives trigger inputs (action, key, value, timeout) from other workflows.
• 1.2 Action Routing: Uses a Switch node to route the flow based on action type (get, set, unset).
• 1.3 Redis Interaction: Performs Redis operations (get, set with TTL, delete) on keys named process_status_<key>.
• 1.4 Lock Checking and Control Flow: Uses If nodes to decide whether a lock exists and whether to continue, stop, or throw an error.
• 1.5 Long Job Simulation & Progress Updates: Simulates long jobs with Wait nodes, updating Redis keys to reflect progress states.
• 1.6 Workflow Completion: Removes the lock at job completion, allowing future executions.
• 1.7 Status Checking: Provides a path to query current progress and handle output states accordingly.

---

2. Block-by-Block Analysis

---

2.1 Input Reception

Overview:
Receives input parameters from another workflow, including the action to perform, the job key identifier, optional value, and timeout duration.

Nodes Involved:

• When Executed by Another Workflow

Node Details:

• When Executed by Another Workflow

  • Type: Execute Workflow Trigger
  • Role: Entry point listening for external calls with inputs action, value, key, timeout.
  • Configuration: Defines expected inputs, no default values (except TTL default later applied).
  • Inputs: External trigger
  • Outputs: Passes inputs to Set Timeout node
  • Failure Modes: Missing or malformed inputs may cause routing issues downstream.
  • Version: 1.1

• Set Timeout

  • Type: Set
  • Role: Assigns a default timeout of 600 seconds if none provided, preserving other inputs.
  • Configuration: Sets numeric field timeout to 600 if not specified.
  • Inputs: Data from trigger node
  • Outputs: Passes augmented data to Switch node for action routing
  • Failure Modes: Expression failures if inputs malformed.
  • Version: 3.4

---

2.2 Action Routing

Overview:
Decides which Redis operation to execute based on the action input (get, set, unset).

Nodes Involved:

• Switch

Node Details:

• Switch
  • Type: Switch
  • Role: Routes workflow according to the exact string value of $json.action.
  • Configuration: 3 outputs renamed to get, set, and unset based on strict equality checks.
  • Inputs: From Set Timeout
  • Outputs: Directs flow to Redis Get Key, Set Key, or UnSet Key nodes respectively
  • Failure Modes: Unknown or missing action causes no path selected; no fallback configured.
  • Version: 3.2

---

2.3 Redis Interaction

Overview:
Performs the core Redis operations for locking and status tracking: reading, writing (with TTL), and deleting keys.

Nodes Involved:

• Get Key
• Set Key
• UnSet Key

Node Details:

• Get Key

  • Type: Redis
  • Role: Retrieves the value of the key process_status_<key> from Redis.
  • Configuration: Operation is get; key dynamically constructed from key input; output stored in property output.
  • Credentials: Uses stored Redis credentials.
  • Inputs: From Switch node's get output
  • Outputs: Passes data to If nodes for lock checking
  • Failure Modes: Connection errors, key not found (outputs null), credential issues.
  • Version: 1

• Set Key

  • Type: Redis
  • Role: Sets the Redis key with the specified value and TTL (timeout).
  • Configuration: Operation set with TTL enabled; key name built dynamically; TTL defaults to 600 seconds unless overridden.
  • Credentials: Redis credentials required.
  • Inputs: From Switch node's set output
  • Outputs: Passes to set continue node to mark success
  • Failure Modes: Redis write failures, TTL misconfiguration, credential errors.
  • Version: 1

• UnSet Key

  • Type: Redis
  • Role: Deletes the Redis key, releasing the lock.
  • Configuration: Operation delete; key built dynamically; no TTL needed.
  • Credentials: Redis credentials required.
  • Inputs: From Switch node's unset output
  • Outputs: Passes to set continue node
  • Failure Modes: Redis connection or permission errors.
  • Version: 1

• set continue

  • Type: Set
  • Role: Adds a JSON field ok with value "true" to indicate success downstream.
  • Inputs: From Set Key and UnSet Key
  • Outputs: To further logic or termination nodes
  • Failure Modes: Minimal

---

2.4 Lock Checking and Control Flow

Overview:
Determines if a lock exists by checking Redis key outputs and decides whether to proceed or stop execution with a clear error.

Nodes Involved:

• Is Workflow Active (multiple instances)
• If (multiple instances)
• Stop and Error (multiple instances)

Node Details:

• Is Workflow Active, Is Workflow Active1, Is Workflow Active2, Is Workflow Active3

  • Type: Execute Workflow
  • Role: Calls the same workflow recursively with action=get to check the lock status of a given key.
  • Configuration: Fixed workflowId reference to self template; input key is set to a constant "some_workflow_key" in examples (to be replaced by actual key in practice); action is always "get".
  • Inputs: Various points in flow to check lock presence.
  • Outputs: To corresponding If nodes for null or string comparisons.
  • Failure Modes: Recursive calls may fail if credentials or workflows misconfigured.
  • Version: 1.2

• If, If1, If2

  • Type: If
  • Role: Check if Redis output is empty (null), indicating no lock.
  • Configuration: Condition checks if the output field from Redis is empty (null).
  • Inputs: From Redis Get Key or Execute Workflow nodes
  • Outputs: On true (no lock) continues workflow; on false, triggers Stop and Error node.
  • Failure Modes: Expression errors if output missing or malformed.
  • Version: 2.2

• Stop and Error, Stop and Error1

  • Type: Stop and Error
  • Role: Stops workflow execution with error message "Already Executing".
  • Configuration: Custom error message to clearly indicate concurrent execution blocked.
  • Inputs: From If nodes on false branch (lock present).
  • Failure Modes: None beyond normal workflow stop.
  • Version: 1

---

2.5 Long Job Simulation & Progress Updates

Overview:
Simulates a long-running process using Wait nodes and updates Redis key values to represent progress stages (started, loading, finishing, working).

Nodes Involved:

• Wait, Wait1, Wait2, Wait3
• Set Workflow Active1, Set Workflow "started", Set Workflow "loading", Set Workflow "finishing"
• Set Workflow Finished1, Set Workflow Finished2

Node Details:

• Wait, Wait1, Wait2, Wait3

  • Type: Wait
  • Role: Pauses workflow for testing or simulating time-consuming steps.
  • Configuration: No delay specified in JSON, assumed default (can be customized).
  • Inputs: Sequenced from progress update nodes.
  • Outputs: Next progress update or workflow finish nodes.
  • Failure Modes: Timeout or webhook failures in edge cases.
  • Version: 1.1

• Set Workflow Active1, Set Workflow "started", Set Workflow "loading", Set Workflow "finishing"

  • Type: Execute Workflow
  • Role: Calls self workflow to set Redis key values representing current progress stage.
  • Configuration: Each sets value to respective status string (working, started, loading, finishing), action=set, key fixed as "some_workflow_key" in example.
  • Inputs: From If and Wait nodes in sequential order.
  • Outputs: Chain to Wait nodes or final unset nodes.
  • Failure Modes: Recursive call failures or incorrect parameter propagation.
  • Version: 1.2

• Set Workflow Finished1, Set Workflow Finished2

  • Type: Execute Workflow
  • Role: Calls workflow to unset lock key, marking job finished.
  • Configuration: action=unset, key=some_workflow_key.
  • Inputs: From Wait nodes signaling job completion.
  • Outputs: Ends the long job simulation.
  • Failure Modes: Failure to delete lock can cause deadlocks.
  • Version: 1.2

---

2.6 Workflow Completion

Overview:
Removes the Redis lock key to allow subsequent workflow executions.

Nodes Involved:

• UnSet Key
• Set Workflow Finished, Set Workflow Finished1, Set Workflow Finished2 (all Execute Workflow nodes invoking unset action)

Node Details:

• Already covered in Redis Interaction and Long Job Simulation blocks.
• Key action is unset, which deletes the Redis key and clears the lock.

---

2.7 Status Checking

Overview:
Allows polling the current workflow execution status by reading the Redis key and routing based on the stored progress value.

Nodes Involved:

• Is Workflow Active3
• Switch1

Node Details:

• Is Workflow Active3

  • Type: Execute Workflow
  • Role: Calls self workflow to get the current Redis key value for status.
  • Inputs: Triggered externally or from internal logic to fetch status.
  • Outputs: Passes output to Switch1 node.

• Switch1

  • Type: Switch
  • Role: Routes based on the Redis status value (started, loading, finished, or others).
  • Configuration: Renamed outputs for each known status; fallback output for unknown states.
  • Inputs: From Is Workflow Active3
  • Outputs: Can be linked to UI or other logic to display or act based on status.

---

3. Summary Table

Node Name	Node Type	Functional Role	Input Node(s)	Output Node(s)	Sticky Note
When Executed by Another Workflow	Execute Workflow Trigger	Entry point receiving external workflow inputs	Manual Trigger (optional)	Set Timeout
Set Timeout	Set	Assigns default TTL and prepares inputs	When Executed by Another Workflow	Switch
Switch	Switch	Routes flow based on action input	Set Timeout	Get Key, Set Key, UnSet Key
Get Key	Redis	Reads Redis key status	Switch (get)	Is Workflow Active, If2
Set Key	Redis	Sets Redis key with value and TTL	Switch (set)	set continue
UnSet Key	Redis	Deletes Redis key (removes lock)	Switch (unset)	set continue
set continue	Set	Marks successful Redis operation	Set Key, UnSet Key	Various downstream
Is Workflow Active	Execute Workflow	Calls workflow recursively to check lock status	Get Key	If2
If2	If	Checks if Redis output is empty (lock absent)	Is Workflow Active	Set Workflow Active, Stop and Error
Set Workflow Active	Execute Workflow	Sets lock key to "working" status	If2 (true)	No Operation, do nothing
Stop and Error	Stop and Error	Stops workflow if lock exists (error)	If2 (false)	None
No Operation, do nothing	NoOp	Placeholder to chain workflow	Set Workflow Active	Wait
Wait	Wait	Simulates long running process	No Operation, do nothing	Set Workflow Finished1
Set Workflow Finished1	Execute Workflow	Unsets lock key signaling job completion	Wait	None
Is Workflow Active1	Execute Workflow	Checks if lock key exists	Various	If
If	If	Checks if Redis output is empty (lock absent)	Is Workflow Active1	Set Workflow Active1, Stop and Error
Set Workflow Active1	Execute Workflow	Sets lock key to "working"	If (true)	No Operation, do nothing
Stop and Error1	Stop and Error	Stops workflow if lock exists	If (false)	None
Set Workflow "started"	Execute Workflow	Sets Redis status to "started"	If1 (true)	Wait1
Wait1	Wait	Simulates step delay	Set Workflow "started"	Set Workflow "loading"
Set Workflow "loading"	Execute Workflow	Updates Redis status to "loading"	Wait1	Wait2
Wait2	Wait	Simulates step delay	Set Workflow "loading"	Set Workflow "finishing"
Set Workflow "finishing"	Execute Workflow	Updates Redis status to "finishing"	Wait2	Wait3
Wait3	Wait	Simulates step delay	Set Workflow "finishing"	Set Workflow Finished2
Set Workflow Finished2	Execute Workflow	Removes Redis lock key signaling final completion	Wait3	None
Is Workflow Active2	Execute Workflow	Checks lock status	Various	If1
If1	If	Checks if Redis output is empty (lock absent)	Is Workflow Active2	Set Workflow "started", Stop and Error1
Is Workflow Active3	Execute Workflow	Fetches current status for polling	External or internal trigger	Switch1
Switch1	Switch	Routes based on current Redis status value	Is Workflow Active3	(started, loading, finished, extra)
Set Workflow Finished	Execute Workflow	Unsets lock key to mark workflow end	Wait	None
Sticky Notes (multiple)	Sticky Note	Provides descriptive comments and guidance	N/A	N/A	Multiple notes provide explanations on blocks, Redis logic, usage examples, and testing

---

4. Reproducing the Workflow from Scratch

1. Create an Execute Workflow Trigger node

   • Name: When Executed by Another Workflow
   • Parameters: Define inputs action, value, key, timeout.
   • Purpose: Entry point for external workflow calls.

2. Add a Set node

   • Name: Set Timeout
   • Assign numeric field timeout with default 600 if not provided.
   • Pass through all other input fields unchanged.

3. Add a Switch node

   • Name: Switch
   • Configure three outputs:
     • get: if $json.action === "get"
     • set: if $json.action === "set"
     • unset: if $json.action === "unset"

4. Add Redis node for GET operation

   • Name: Get Key
   • Operation: get
   • Key: process_status_{{$json.key}} (dynamic key)
   • Credentials: Select your Redis credentials.

5. Add Redis node for SET operation

   • Name: Set Key
   • Operation: set
   • Key: process_status_{{$json.key}}
   • Value: {{$json.value}}
   • TTL: {{$json.timeout}} seconds
   • Enable expiration.

6. Add Redis node for DELETE operation

   • Name: UnSet Key
   • Operation: delete
   • Key: process_status_{{$json.key}}

7. Connect Switch outputs:

   • get → Get Key
   • set → Set Key
   • unset → UnSet Key

8. Add a Set node

   • Name: set continue
   • Add field ok with value "true"
   • Connect outputs of Set Key and UnSet Key to this node.

9. Add Execute Workflow nodes to call self recursively for lock checks

   • Create a workflow call node named Is Workflow Active (and variants) calling this same workflow with inputs:
     • action: "get"
     • key: Use the job key dynamically
   • These nodes are used to check lock state at various points.

10. Add If nodes to check if Redis output is empty

    • Condition: $json.output is empty (null)
    • True branch: No lock present, proceed
    • False branch: Lock present, stop with error

11. Add Stop and Error nodes

    • Name: Stop and Error
    • Error message: "Already Executing"
    • Connected to false branches of If nodes to fail workflow when concurrent execution detected.

12. Add No Operation (NoOp) node

    • Used as a pass-through placeholder for chaining.

13. Add Wait nodes

    • Add several Wait nodes (Wait, Wait1, Wait2, Wait3) to simulate job progress delays.

14. Add Execute Workflow nodes to update Redis status during job

    • Set status to "working", "started", "loading", "finishing" at different job steps.
    • Call self workflow with action="set", key, and corresponding value to update Redis.

15. Add Execute Workflow nodes to unset key for job completion

    • Call self with action="unset" and key to remove lock.

16. Add final status polling nodes

    • Execute Workflow node Is Workflow Active3 to fetch current Redis key value.
    • Switch node Switch1 to route based on status (started, loading, finished, or fallback).

17. Wire all nodes according to the logical flow described in section 1 and 2.

18. Configure Redis credentials in all Redis nodes.

19. Test workflow with manual trigger or external calls providing action, key, and optional value and timeout.

---

5. General Notes & Resources

Note Content	Context or Link
This workflow template helps prevent concurrent runs by setting a Redis lock and tracking progress status with TTL keys.	Workflow description and use cases
Customize the TTL in the Set Timeout node to match typical job execution duration.	Customization tips
Replace the Stop and Error nodes with Slack or email notifications, or push triggers into a queue to avoid failing parallel calls.	Customization tips
Build a status endpoint by calling this workflow with action=get to display real-time job progress to users.	Customization tips
Use this workflow to protect against Telegram callback spam bursts, API rate-limit violations, and overlapping maintenance windows.	Additional use cases
Redis credentials must be configured in n8n beforehand and reachable from the workflow runtime environment.	Prerequisites
The workflow uses recursive calls to itself for status checking and updating, so ensure correct input parameter passing and looping control to avoid infinite recursion.	Execution considerations
Sticky notes in the workflow visually explain the Redis logic, usage examples, and testing instructions for easier understanding and modification.	Sticky notes content
Redis key names are prefixed with process_status_ followed by the user-provided key, enabling multiple independent locks.	Redis key naming convention