Service Modules > Scheduling and Optimization > Service Board > Max for Developers > Calling Operations Asynchronously > Deferred Operations
 
Deferred Operations
To asynchronously run operations that require long processing times in the background, you can use deferred operations. When you call this type of operation, a unique identifier is returned, and processing starts to run in the background. You can use the unique identifier later on to check the status of the operation and get the results.
Call Deferred Operation
You call deferred operations in the same manner as regular operations. The only difference is that deferred operations return a UUID that you use to check operation status.
GET https://localhost:8080/asynchronous_operation
Return
ce106553-fe04-405b-b452-096928632c30
Query Deferred Operation Status
After you call a deferred operation, you use the returned UUID to check processing status and get the results. To do so, call the operation with the iop_deferred_operation_id parameter set to the UUID value.
GET https://localhost:8080/asynchronous_operation?iop_deferred_operation_id=ce106553-fe04-405b-b452-096928632c30
Return Values
Return Code
Meaning
202
Operation running.
500
Operation failed.
410
Operation does not exist, or its results have been deleted.
200
Operation successful. Results appear in response body.
Implement Deferred Operations With Results Checking
To implement deferred operations with results checking in Groovy, you can use the com.servicemax.core.asynchronous_operation.AsynchronousOperation class. When you define deferred operations, specify execute as the executing method and make the class that implements the operation a subclass of AsynchronousOperation. Subclasses of AsynchronousOperation must implement the following methods.
Implement Real Behavior
Object realExecute(Map<String, Object> parameters);
Implements the real behavior of the deferred operation. Code with execution times that are too long to run as regular operations is processed with this method. Results are typically stored in a file for retrieval later on.
Get realExecute Results
Object getResult(IImmutableEntityTransaction transaction, Map<String, Object> parameters);
Gets the results produced by realExecute, typically by reading a file. After results are obtained, the method should call DeferredOperationsUtils.cleanupOperation to release resources used by the operation.
Get Operation Full Identifier
String getOperationFullIdentifier();
Returns the full identifier of an operation needed to call the operation asynchronously.
Clean Up Resources
void cleanUp(UUID operationUUID);
Cleans up resources reserved by an operation, and typically deletes the realExecute results file.
Full Example
package com.servicemax.core.asynchronous_operation

import java.util.Map

import com.intalio.core.data.api.IImmutableEntityTransaction;
import com.intalio.core.data.api.DeferredOperationUtils

class AsynchronousOperationExample extends AsynchronousOperation {

    @Override
    public Object realExecute(Map<String, Object> parameters) {

        //emulates processing
        sleep(1000 * 60);

        //writes the result to a file
        def file = new File(getFileName(parameters))
        file.text = ''' This is the result'''

        return null;
    }

    @Override
    public Object getResult(IImmutableEntityTransaction transaction, Map<String, Object> parameters) {

        //reads the result from the file written in realExecute
        def file = new File(getFileName(parameters))
        def lines = file.readLines()

        //cleanup the result
        DeferredOperationUtils.cleanupOperation(transaction, parameters);

        return lines.join("\n")
    }

    @Override
    public String getOperationFullIdentifier() {
        return "io_asynchronous_operation_example";
    }

    private String getFileName(Map<String, Object> parameters) {
        UUID operationUUID = DeferredOperationUtils.getOperationUUID(parameters)
        getFileName(operationUUID)
    }

    private String getFileName(UUID operationUUID) {
        "result_${operationUUID}"
    }
}
Implementing Deferred Operation Without Results Checking
To execute operations asynchronously without results checking:
1. Create a regular operation to launch the deferred operation asynchronously, for example, my_launcher_operation.
◦ To launch another deferred or asynchronous operation, attach an event handler.
2. Create another regular operation to be called asynchronously, for example, my_deferred_operation_a, with a regular, simple execute method.
* 
When this execute method runs, no transaction is attached to it, so be sure to create an execution environment inside which any record can be accessed.
3. In the my_launcher_operation method, call my_deferred_operation_a in the same manner as a deferred operation by using the currentTransaction.deferOperation utility.
Example
package com.servicemax.core.some_package

import com.servicemax.core;

\public class MyLauncherOperation {

    @Override
    public Object execute(Map<String, Object> parameters) {
\
        //do something with the received parameters, add parameters,etc
        def newParameters = processParameters(parameters);
       // call another Operation asynchronously
       Max.currentTransaction.deferOperation("my_deferred_operation_a",
        newParameters, false, 0);
        return "true";
    }

    @Override
    public  Map<String, Object> processParameters( Map<String, Object> parameters) {        
      //do something, add parameters, etc
       return parameters;
    }

}
Deferred Operation Exclusive Execution
To support use cases where deferred operations must execute exclusively within the system, without concurrent execution of the same deferred operation, in the relevant Operation record, select the Deferred Operation Exclusive Execution check box.
After you make this setting, execution attempts that occur while another instance of the same operation is running cause the operation to fail with OperationIsAlreadyRunningException.
For more information:
Was this helpful?