Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A system comprising: a non-transitory data store configured to store an execution record of a task, wherein the task is associated with code executable to implement functionality corresponding to the task, and wherein executing the task comprises executing the code; and one or more processors configured with computer-executable instructions to: obtain, from one or more devices external to the system, first instructions instructing the system to execute the task, wherein the task is associated with a request to implement an execution guarantee for the task, wherein the execution guarantee specifies that the task is to be successfully executed on an on-demand code execution system no more than a desired number of times for instructions including a first execution identifier, wherein the execution guarantee is not implemented for instructions not including the first execution identifier, and wherein the first instructions include the first execution identifier; obtain an execution record corresponding to the first execution identifier, wherein the execution record indicates whether other executions of the task, associated with the first execution identifier, have successfully occurred or are occurring; verify, from at least the execution record, that a number of the other executions of the task that are associated with the first execution identifier and that have successfully occurred or are occurring is less than the desired number of times associated with the first execution identifier; and in response to verifying that the number of the other executions of the task that are associated with the first execution identifier and that have successfully occurred or are occurring is less than the desired number of times associated with the first execution identifier, respond to the first instructions at least by: generating an execution environment on the on-demand code execution system in which to execute the task; initiating an execution of the task on the on-demand code execution system within the execution environment; and recording a state of execution of the task within the execution record; obtain, from the one or more devices external to the system, second instructions instructing the system to execute the task, the second instructions including the first execution identifier associated with the request to verify that, for instructions including the first execution identifier, the task is successfully executed on the on-demand code execution system no more than the desired number of times; and respond to the second instructions to execute the task at least by: verifying, from at least the execution record, that the number of the other executions of the task that are associated with the first execution identifier and that have successfully occurred or are occurring, including the execution initiated in response to the first instructions, is not less than the desired number of times associated with the first execution identifier; and declining to execute the task on the on-demand code execution system; and obtain, from the one or more devices external to the system, third instructions instructing the system to execute the task, the third instructions not including the first execution identifier associated with the request, and in response to the third instructions not including the first execution identifier, initiate an additional execution of the task on the on-demand code execution system without implementing the execution guarantee.
This system operates in the domain of on-demand code execution, addressing the problem of ensuring controlled and guaranteed execution of tasks while preventing excessive or unauthorized runs. The system includes a data store for tracking execution records of tasks, where each task is associated with executable code. The system receives instructions from external devices to execute tasks, with some instructions including an execution identifier tied to an execution guarantee. This guarantee specifies that the task must be executed no more than a predefined number of times for instructions containing the identifier. The system verifies the execution record to confirm that prior executions (successful or ongoing) associated with the identifier do not exceed the allowed limit. If the limit is not exceeded, the system generates an execution environment, runs the task, and updates the execution record. If subsequent instructions with the same identifier are received and the limit is reached, the system declines further execution. Instructions without the identifier bypass this guarantee, allowing unrestricted execution. The system ensures tasks are executed only as permitted, preventing overuse while allowing flexible execution for non-guaranteed tasks.
2. The system of claim 1 , wherein the execution environment is at least one of a virtual machine instance or a container.
A system for managing execution environments in cloud computing addresses the challenge of efficiently deploying and isolating applications. The system provides a platform for running applications in isolated execution environments, such as virtual machine instances or containers, to ensure security, scalability, and resource efficiency. Virtual machine instances offer full operating system-level isolation, while containers provide lightweight, process-level isolation, allowing multiple applications to run on the same host without interference. The system dynamically allocates and manages these environments based on workload requirements, optimizing resource utilization and reducing operational overhead. By supporting both virtual machines and containers, the system offers flexibility in deployment strategies, accommodating different application needs and performance constraints. This approach enhances security by isolating applications from the underlying infrastructure and from each other, minimizing the risk of unauthorized access or resource conflicts. Additionally, the system simplifies application deployment and scaling by abstracting infrastructure complexities, enabling faster provisioning and easier management of execution environments. The solution is particularly useful in cloud-based environments where dynamic workloads and multi-tenancy require efficient resource management and isolation mechanisms.
3. The system of claim 1 , wherein the one or more processors are further configured with the computer-executable instructions to: determine that the state of execution of the task within the execution record indicates an error; rollback the execution of the task; and initiate a second execution of the task.
This invention relates to a system for managing task execution in a computing environment, particularly focusing on error handling and recovery. The system monitors the execution state of tasks within an execution record to detect errors. When an error is identified, the system automatically rolls back the execution of the affected task to a previous stable state, ensuring data consistency and system integrity. Following the rollback, the system initiates a second execution attempt of the task, allowing the system to retry the operation without manual intervention. This approach improves reliability by automatically recovering from errors, reducing downtime and minimizing the need for manual troubleshooting. The system is designed to handle tasks in a structured manner, ensuring that errors do not propagate and that affected operations are retried in a controlled environment. This method is particularly useful in distributed systems, transactional processing, and other scenarios where task execution reliability is critical. The system's ability to detect errors, roll back execution, and retry tasks enhances overall system robustness and efficiency.
4. The system of claim 1 , wherein the one or more processors are further configured with the computer-executable instructions to: determine that the state of execution of the task does not indicate either success or failure after at least a threshold period of time; and record that the state of execution of the task is erroneous.
This invention relates to a system for monitoring and managing task execution in computing environments, particularly addressing the problem of tasks that neither complete successfully nor fail explicitly, leading to indeterminate states that can cause system instability or resource leaks. The system includes one or more processors configured to execute tasks and monitor their execution states. When a task is initiated, the system tracks its progress and determines whether it reaches a successful or failed state within a predefined threshold period. If the task's execution state remains unresolved after this period, the system automatically classifies the task as erroneous, preventing indefinite hanging or resource consumption. This ensures system reliability by enforcing time-bound resolution of task execution, distinguishing it from traditional systems that may indefinitely wait for task completion or lack mechanisms to handle ambiguous execution states. The system may also include additional components for task scheduling, resource allocation, or error recovery, which work in conjunction with the state monitoring functionality to maintain system stability. The invention is particularly useful in distributed computing, cloud environments, or any scenario where task execution must be reliably managed to avoid system degradation.
5. A method implemented by a computing system to manage code execution in an on-demand code execution system, the computer-implemented method comprising: obtaining, from one or more devices external to the computing system, first instructions instructing the computing system to execute a task, wherein the task is associated with a request to implement an execution guarantee for the task, wherein the execution guarantee specifies that the task is to be successfully executed on the on-demand code execution system no more than a desired number of times for instructions including a first execution identifier, wherein the execution guarantee is not implemented for instructions not including the first execution identifier, wherein the task is associated with code executable to implement functionality corresponding to the task, and wherein the first instructions include the first execution identifier; obtaining an execution record corresponding to the first execution identifier and indicating a history of executions of the task; verifying, from at least the execution record, that a number of other executions of the task that are associated with the first execution identifier and that have successfully occurred or are occurring is less than the desired number of times associated with the first execution identifier; and in response to verifying that the number of the other executions of the task that are associated with the first execution identifier and that have successfully occurred or are occurring is less than the desired number of times associated with the first execution identifier, responding to the first instructions at least by: generating an execution environment on the on-demand code execution system in which to execute the task; initiating an execution of the task on the on-demand code execution system within the execution environment; and recording a state of execution of the task within the execution record; obtaining, from the one or more devices external to the computing system, second instructions instructing the computing system to execute the task, the second instructions including the first execution identifier associated with the request to verify that, for instructions including the first execution identifier, the task is successfully executed on the on-demand code execution system no more than the desired number of times; and responding to the second instructions at least by: verifying, from at least the execution record, that the number of the other executions of the task that are associated with the first execution identifier and that have successfully occurred or are occurring is not less than the desired number of times associated with the first execution identifier; and declining to execute the task on the on-demand code execution system; and obtaining, from the one or more devices external to the computing system, third instructions instructing the system to execute the task, the third instructions not including the first execution identifier associated with the request, and in response to the third instructions not including the first execution identifier, initiating an additional execution of the task on the on-demand code execution system without implementing the execution guarantee.
This invention relates to managing code execution in an on-demand code execution system, such as serverless computing environments, where tasks are executed dynamically in response to external requests. The problem addressed is ensuring that certain tasks are executed no more than a specified number of times while allowing unrestricted execution for other tasks. The system obtains instructions from external devices to execute a task, where the task may include an execution identifier tied to an execution guarantee. The guarantee specifies that the task should be executed no more than a desired number of times for instructions containing the identifier. The system checks an execution record to verify whether prior executions of the task with the same identifier have met the guarantee. If the count of successful or ongoing executions is below the limit, the system generates an execution environment, runs the task, and updates the execution record. If subsequent instructions with the same identifier exceed the limit, the system declines execution. Tasks without the identifier are executed without enforcement of the guarantee. This ensures controlled execution for tasks requiring limits while allowing unrestricted execution for others.
6. The computer-implemented method of claim 5 further comprising: determining that the state of execution of the task indicates an error; rolling back the execution of the task; and initiating a second execution of the task.
This invention relates to error handling in computer-implemented task execution systems. The problem addressed is the need to detect and recover from errors during task execution in a way that ensures system reliability and data integrity. The invention provides a method for monitoring task execution, identifying errors, and automatically recovering from those errors by rolling back and re-executing the task. The method involves continuously tracking the state of a task as it executes. If an error is detected, the system rolls back the task to a previous stable state, effectively undoing any changes made during the erroneous execution. After rolling back, the system initiates a second execution of the task, allowing it to proceed from the stable state. This approach ensures that errors do not propagate, and the task can be retried without manual intervention. The method may also include additional steps such as logging the error, notifying system administrators, or adjusting system parameters to prevent recurrence. The rollback mechanism ensures that any partial or corrupted data from the failed execution is discarded, maintaining system consistency. This technique is particularly useful in distributed systems, transactional databases, or any environment where task reliability is critical. The invention improves fault tolerance and reduces downtime by automating error recovery.
7. The computer-implemented method of claim 6 , wherein rolling back the execution of the task comprises executing an undo function associated with the task.
This invention relates to computer-implemented methods for managing task execution in a computing system, particularly focusing on error recovery and state management. The problem addressed is the need to efficiently revert or undo the execution of a task when errors or inconsistencies occur, ensuring system stability and data integrity. The method involves monitoring the execution of a task within a computing environment. If an error or failure is detected during task execution, the system initiates a rollback process to revert the system state to a previous valid state. This rollback is achieved by executing an undo function specifically associated with the task. The undo function is designed to reverse the effects of the task's operations, effectively undoing any changes made during its execution. This ensures that the system returns to a consistent and error-free state. The method may also include additional steps such as identifying the task to be rolled back, determining the appropriate undo function based on the task's characteristics, and applying the undo function to reverse the task's effects. The system may further log the rollback process for debugging or auditing purposes. This approach enhances system reliability by providing a structured mechanism for error recovery, minimizing the impact of failed tasks on overall system performance.
8. The computer-implemented method of claim 7 , wherein the undo function is included within at least one of the code of the task or code of a second task.
A computer-implemented method for managing undo functionality in task-based systems addresses the challenge of efficiently reversing actions within automated workflows. The method integrates an undo function directly into the code of a task or a separate task, enabling selective reversal of operations without disrupting the overall workflow. This approach improves flexibility and error recovery by allowing users or systems to revert specific actions while maintaining the integrity of the process. The undo function can be triggered by user input or automated triggers, ensuring seamless integration into existing task execution frameworks. By embedding the undo capability within task code, the method reduces the need for external intervention and enhances the robustness of task automation systems. This solution is particularly useful in environments where precise control over task execution and reversal is critical, such as software development, automated testing, or workflow management systems. The method ensures that undo operations are context-aware, minimizing unintended side effects and improving system reliability.
9. The computer-implemented method of claim 5 further comprising: during execution of the task, detecting a call to at least one of a second task on the on-demand code execution system or an external service; and appending, within the call, a second execution identifier.
The invention relates to a computer-implemented method for managing task execution in an on-demand code execution system, addressing the challenge of tracking and correlating task interactions within distributed computing environments. The method involves executing a task in response to an event, where the task is associated with a first execution identifier. During execution, if the task calls another task within the same system or an external service, a second execution identifier is appended to the call. This ensures traceability and correlation of related executions, enabling better monitoring, debugging, and performance analysis in distributed systems. The method may also include generating a task execution record that includes the first execution identifier, the second execution identifier, and metadata such as execution time, duration, and status. The task execution record can be stored in a data store for later retrieval and analysis. The invention improves visibility into task dependencies and execution flows, particularly in serverless or event-driven architectures where tasks are dynamically invoked and may interact with multiple services.
10. The computer-implemented method of claim 9 , wherein the second execution identifier matches the first execution identifier.
A computer-implemented method for managing software execution involves tracking and verifying the integrity of software processes. The method addresses the problem of ensuring that software runs as intended, without unauthorized modifications or deviations from expected behavior. It does this by generating and comparing execution identifiers for software processes to detect inconsistencies. The method begins by executing a first software process and generating a first execution identifier based on the process's execution state. This identifier uniquely represents the process's expected behavior. A second software process is then executed, and a second execution identifier is generated in the same way. If the second execution identifier matches the first, it confirms that the second process is executing as intended, with no unauthorized changes. If they do not match, it indicates a deviation, such as tampering or an unexpected execution path. The method can be applied to any software process where integrity verification is critical, such as security-sensitive applications, financial systems, or mission-critical software. By comparing execution identifiers, the method provides a way to detect and respond to unauthorized modifications or execution errors in real time. This ensures that software behaves predictably and securely.
11. The computer-implemented method of claim 9 further comprising: determining that the state of execution of the task indicates an error; and generating a second call, including the second execution identifier, to at least one of the second task or the external service indicating that execution of the task has resulted in an error.
This invention relates to error handling in distributed computing systems, specifically for managing task execution and error reporting in environments where tasks may be distributed across multiple services or systems. The problem addressed is the need for reliable error detection and communication in distributed workflows, where tasks may fail or encounter errors, and these failures must be properly reported to ensure system integrity and enable recovery mechanisms. The method involves monitoring the execution state of a task, which may be part of a larger workflow or process. If the task's execution state indicates an error, the system generates a call to either a second task or an external service, including a unique execution identifier. This call signals that the task has encountered an error, allowing the system to take corrective action, such as retrying the task, rolling back dependent operations, or alerting system administrators. The execution identifier ensures that the error report is associated with the correct instance of the task, preventing misattribution or loss of error information in distributed environments. The method may also involve generating a first call to initiate the task, including a first execution identifier, and tracking the task's progress until an error is detected. The system may further determine whether the task has completed successfully or failed, and generate appropriate notifications based on the outcome. This ensures that errors are promptly identified and addressed, improving system reliability and fault tolerance in distributed computing environments.
12. The computer-implemented method of claim 11 , wherein determining that the state of execution of the task indicates an error includes at least one of determining that the execution of the task outputted an error, or determining that an execution environment executing the task has become unhealthy.
This invention relates to error detection in task execution within a computing environment. The method monitors the state of a task during execution to identify errors, which can occur when the task outputs an error or when the execution environment becomes unhealthy. The execution environment may be deemed unhealthy if it fails to meet predefined operational criteria, such as resource availability, stability, or performance thresholds. The method may involve analyzing task outputs, system logs, or environment metrics to detect anomalies or deviations from expected behavior. Once an error is detected, the system can trigger corrective actions, such as task termination, retry mechanisms, or notifications to administrators. This approach improves system reliability by proactively identifying and addressing execution failures before they escalate. The method is particularly useful in automated workflows, cloud computing, and distributed systems where tasks must execute reliably without manual intervention. By monitoring both task outputs and the health of the execution environment, the system ensures robust error detection and response.
13. Non-transitory computer-readable media including computer-executable instructions that, when executed by a computing system, cause the computing system to: obtain, from one or more devices external to the computing system, first instructions instructing the computing system to execute a task, wherein the task is associated with code executable to implement functionality corresponding to the task, wherein the task is associated with a request to implement an execution guarantee for the task, wherein the execution guarantee specifies that the task is to be successfully executed on an on-demand code execution system no more than a desired number of times for instructions including a first execution identifier, wherein the execution guarantee is not implemented for instructions not including the first execution identifier, and wherein the instructions include the first execution identifier; verify, from an execution record corresponding to the first execution identifier and indicating a history of executions of the task, that a number of other executions of the task that are associated with the first execution identifier and that have successfully occurred or are occurring is less than the desired number of times associated with the first execution identifier; and in response to verifying that the number of the other executions of the task that are associated with the first execution identifier and that have successfully occurred or are occurring is less than the desired number of times associated with the first execution identifier, responding to the first instructions at least by: generating an execution environment on the on-demand code execution system in which to execute the task; initiating an execution of the task on the on-demand code execution system within the execution environment; and recording a state of execution of the task within the execution record; obtain, from the one or more devices external to the computing system, second instructions instructing the computing system to execute the task, the second instructions including the first execution identifier associated with the request to verify that, for instructions including the first execution identifier, the task is successfully executed on the on-demand code execution system no more than the desired number of times; and respond to the second instructions at least by: verifying, from at least the execution record, that the number of the other executions of the task that are associated with the first execution identifier and that have successfully occurred or are occurring is not less than the desired number of times associated with the first execution identifier; and declining to execute the task on the on-demand code execution system; and obtain, from the one or more devices external to the computing system, third instructions instructing the system to execute the task, the third instructions not including the first execution identifier associated with the request, and in response to the third instructions not including the first execution identifier, initiate an additional execution of the task on the on-demand code execution system without implementing the execution guarantee.
This invention relates to a system for managing task execution in an on-demand code execution environment, addressing the problem of ensuring controlled and limited execution of tasks while allowing unrestricted execution when no such control is requested. The system obtains instructions from external devices to execute a task, where the task may be associated with an execution guarantee that limits the number of successful executions for instructions containing a specific execution identifier. The system verifies an execution record to confirm that the number of prior successful executions of the task with the identifier is below the specified limit before proceeding with execution. If the limit is reached, the system declines further execution requests containing the identifier. For requests lacking the identifier, the system executes the task without enforcing the execution guarantee. The execution record tracks the state of each task execution, ensuring compliance with the specified limits. This approach enables selective enforcement of execution constraints, preventing overuse of resources while allowing unrestricted execution when no such constraints are applied.
14. The non-transitory computer-readable media of claim 13 , wherein the computer-executable instructions further cause the computing system to: determine that the execution record corresponding to the first execution identifier does not exist; and generate the execution record corresponding to the first execution identifier.
This invention relates to a system for managing execution records in a computing environment. The problem addressed is the need to efficiently track and manage execution records, particularly when a requested record does not exist. The system involves a computing system that processes execution identifiers to retrieve or generate execution records. When the system receives a request associated with a first execution identifier, it checks whether a corresponding execution record exists. If the record does not exist, the system generates a new execution record for that identifier. This ensures that execution records are dynamically created when needed, maintaining an up-to-date and comprehensive record of executions. The system may also include additional features, such as storing execution records in a database or processing multiple execution identifiers in a batch. The invention improves efficiency by automating the creation of missing records, reducing manual intervention and ensuring data consistency. The solution is particularly useful in environments where execution tracking is critical, such as software deployment, task scheduling, or system monitoring.
15. The non-transitory computer-readable media of claim 13 , wherein the computer-executable instructions further cause the computing system to: determine that the state of execution of the task indicates an error; rollback the execution of the task; and initiate a second execution of the task.
This invention relates to error handling in computing systems, specifically for tasks that may fail during execution. The problem addressed is the need to automatically detect and recover from execution errors in tasks, ensuring system reliability and data integrity. The invention provides a method for monitoring task execution, detecting errors, and automatically recovering by rolling back and re-executing the task. The system includes a computing device with a processor and memory storing computer-executable instructions. These instructions enable the device to monitor the state of a task during execution. If an error is detected, the system rolls back the task to a previous stable state, undoing any partial or corrupted changes. After rollback, the system initiates a second execution of the task, allowing it to complete successfully. This process ensures that tasks are either fully completed or reverted to a known good state, preventing system instability or data corruption. The invention may also include additional features such as logging error details, notifying administrators, or adjusting task parameters before re-execution to improve success rates. The rollback mechanism may involve reverting database transactions, undoing file modifications, or resetting system states, depending on the task's nature. This approach enhances system resilience by automating error recovery, reducing manual intervention, and maintaining operational continuity.
16. The non-transitory computer-readable media of claim 13 , wherein the computer-executable instructions further cause the computing system to: during execution of the task, detect a call to at least one of a second task on the on-demand code execution system or an external service; and determine that the state of execution of the task indicates an error; and generate a second call, including the first execution identifier, to at least one of the second task or the external service indicating that execution of the task has resulted in an error.
This invention relates to error handling in on-demand code execution systems, such as serverless computing environments. The problem addressed is the lack of robust error detection and propagation mechanisms when tasks fail during execution, particularly when those tasks interact with other tasks or external services. The solution involves a system that monitors task execution, detects errors, and automatically propagates error information to dependent tasks or services to ensure proper error handling and recovery. The system executes a task in an on-demand code execution environment, where the task may call other tasks or external services. During execution, the system detects calls to these dependencies and tracks the task's execution state. If an error occurs, the system identifies the error and generates a new call to the dependent task or service, including an execution identifier and an indication that the original task failed. This allows the dependent task or service to handle the error appropriately, such as retrying the operation, rolling back changes, or notifying administrators. The system ensures that errors are propagated efficiently without manual intervention, improving reliability in distributed computing environments.
17. The non-transitory computer-readable media of claim 13 , wherein the computer-executable instructions further cause the computing system to: obtain additional instructions to execute the task, wherein the additional instructions include a second execution identifier; generate a new execution record for the task, wherein the new execution record corresponds to the second execution identifier; and allocate additional computing resources on the on-demand code execution system in which to execute the task; initiate a second execution of the task on the on-demand code execution system utilizing the additional allocated computing resources; and record a state of the second execution of the task within the new execution record corresponding to the second execution identifier.
This invention relates to on-demand code execution systems, specifically improving task execution tracking and resource allocation. The system addresses challenges in managing multiple executions of the same task, ensuring proper resource allocation, and maintaining execution state records. The invention involves a computing system that executes tasks on an on-demand code execution platform. When a task requires additional instructions, the system obtains these instructions, which include a second execution identifier. The system then generates a new execution record for the task, linked to this identifier, and allocates additional computing resources to handle the task. The task is executed again using these resources, and the state of this second execution is recorded in the new execution record. This approach ensures that each execution of a task is tracked independently, allowing for better resource management and state tracking across multiple runs. The system dynamically adjusts resource allocation based on task requirements, improving efficiency and scalability in on-demand code execution environments.
18. The non-transitory computer-readable media of claim 13 , wherein the task is associated with a plurality of stages, wherein instructions include a stage indicator identifying one of the plurality of stages, and wherein the computer-executable instructions further cause the computing system to verify, from the execution record, that the stage indicator identifies a stage later than a latest stage indicated in the execution record as having executed successfully.
This invention relates to task management systems in computing environments, specifically addressing the challenge of ensuring tasks are executed in the correct sequence and that each stage of a multi-stage task is completed successfully before proceeding. The system involves a non-transitory computer-readable medium storing instructions that, when executed, manage task execution by tracking progress through multiple stages. Each task is divided into distinct stages, and each stage is associated with an indicator that specifies its position in the sequence. The system verifies that a stage being executed is later than the most recently completed stage recorded in an execution history. This ensures that tasks progress in the correct order and that no stage is skipped or repeated improperly. The execution record maintains a log of successfully completed stages, allowing the system to validate the current stage against this history before proceeding. This approach prevents errors caused by out-of-order execution and ensures task integrity by enforcing sequential progression. The system is particularly useful in environments where tasks must follow a predefined workflow, such as software deployment, data processing pipelines, or automated workflows.
Unknown
January 5, 2021
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.