Java Cloud Function Guide

Cloud function is a sub-module of LeanEngine that allows you to run functions on the cloud in response to the requests made by clients. Before you continue, make sure you have read LeanEngine Overview.

When developing your application, you may need to write logic that:

• Are shared by multiple platforms (like iOS, Android, and web) and you wish to write them only once.
• Need to be modified frequently (like the sorting rules of a list) but you don't want to release a new version of client each time you make a change.
• Demand high network traffic or computing power (like producing statistics on a huge table) which you don't want to run on clients.
• Need to be triggered when certain events happen (hooking). For example, when a user deletes an account, you may wish to delete the entries in other tables that are related to this account as well.
• Need to bypass certain restrictions set by ACL.
• Need to be performed routinely. For example, you may wish to clean up inactive accounts every month.

With cloud function, you can deploy these logic written in any language (JavaScript, Python, PHP, or Java) on the cloud and have LeanEngine run them for you.

If you have no idea how to deploy you project to LeanEngine, take a look at LeanEngine Quick Start.

Other Languages

This guide uses Java as an example, but LeanEngine supports many other languages as well. You can choose the one you are familiar with for development:

• Node.js
• Python
• PHP
• Java (current)

Switching Environments

LeanEngine offers two environments for each app: production environment and staging environment. When calling cloud functions within LeanEngine instances using SDK, no matter explicitly or implicitly (by triggering hooks), the SDK uses the function defined in the same environment as the instance. For example, if beforeDelete hook is defined and an object is deleted with SDK in the staging environment, the beforeDelete hook in the staging environment will be triggered.

When calling cloud functions outside of LeanEngine instances using SDK, no matter explicitly or implicitly, X-LC-Prod is set to be 1 by default, which means that the production environment will be used. For historical reasons, there are some differences between each SDK:

• For Node.js, PHP, and Java SDKs, the production environment will always be used by default.
• For Python SDK, when debugging locally with lean-cli, the staging environment will be used if it exists, otherwise the production environment will be used.
• For Java example projects java-war-getting-started and spring-boot-getting-started, when debugging locally with lean-cli, the staging environment will be used if it exists, otherwise the production environment will be used (same as Python SDK).

You can specify the environment being used with SDK:

[AVCloud setProductionMode:NO]; // Staging environment

AV.setProduction(false); // Staging environment

leancloud.use_production(False) # Staging environment
# Call it before `leancloud.init`

LeanClient::useProduction(false); // Staging environment

AVCloud.setProductionMode(false); // Staging environment

Apps with only trial instances would only have production environments. Please do not attempt to switch to staging environments.

Cloud Functions

In this example, a simple cloud function named hello is defined in src/main/java/cn/leancloud/demo/todo/Cloud.java. By doing so, clients running on all platforms will be able to call it and get the return value of it. The computing process of the function is done on the cloud side rather than on the client side, so there will be less burden on the clients.

Now let's look into a more complex example.

Imagine that you have an app that lets users review the movies they have watched. An object containing a single review of a movie may look like this:

{
  "movie": "Despicable Me",
  "stars": 5,
  "comment": "These minions are so cute. I wish they are real and I can have them in my home!"
}

stars is the score given by the user, ranging from 1 to 5. If you want to obtain the average score of Despicable Me, one thing you can do is to have the client search for all the reviews of this movie and calculate the average score on the device. However, this requires all the reviews of this movie to be fetched to the client, which leads to unnecessary network traffic. With cloud function, you can simply have the client pass the name of the movie to the cloud and receive the calculated score only.

Cloud functions accept parameters in JSON objects which we can include the name of the movie in. All the methods defined in LeanStorage Java SDK can be used on LeanEngine, so we can write the cloud function averageStars like this:

@EngineFunction("averageStars")
public static float getAverageStars(@EngineFunctionParam("movie") String movie)
    throws AVException {
  AVQuery<AVObject> query = new AVQuery("Review");
  query.whereEqualTo("movie", movie);
  List<AVObject> reviews = query.find();
  int sum = 0;
  if (reviews == null && reviews.isEmpty()) {
    return 0;
  }
  for (AVObject review : reviews) {
    sum += review.getInt("star");
  }
  return sum / reviews.size();
}

Parameters and Return Values

The following parameters can be accessed within a cloud function:

• @EngineFunctionParam: The parameters sent from the client.
• AVUser.getCurrentUser(): The user logged in at the client side (according to the header LC-Session).
• EngineRequestContext: Other information about the client.

Calling Cloud Functions with SDK

You can call cloud functions with any LeanCloud SDK:

// Construct the dictionary to be passed to the cloud
NSDictionary *dicParameters = [NSDictionary dictionaryWithObject:@"Despicable Me"
                                                          forKey:@"movie"];

// Call averageStars with parameters
[AVCloud callFunctionInBackground:@"averageStars"
                   withParameters:dicParameters
                   block:^(id object, NSError *error) {
                   if(error == nil){
                     // Success; object is the returned value from the cloud function
                   } else {
                     // Error handling
                   }
}];

var paramsJson = {
  movie: "Despicable Me"
};
AV.Cloud.run('averageStars', paramsJson).then(function (data) {
  // Success; data is the returned value from the cloud function
}, function (err) {
  // Error handling
});

from leancloud import cloudfunc

cloudfunc.run('averageStars', movie='Despicable Me')

use \LeanCloud\Engine\Cloud;
$params = array(
    "movie" => "Despicable Me"
);
Cloud::run("averageStars", $params);

// Construct the parameters to be passed to the cloud
Map<String, String> dicParameters = new HashMap<String, String>();
dicParameters.put("movie", "Despicable Me");

// Call averageStars with parameters
AVCloud.callFunctionInBackground("averageStars", dicParameters, new FunctionCallback() {
    public void done(Object object, AVException e) {
        if (e == null) {
            // Success; object is the returned value from the cloud function
        } else {
            // Error handling
        }
    }
});

Calling Cloud Functions with REST API

See LeanEngine REST API Guide.

Calling Cloud Functions on LeanEngine

You can call the cloud functions defined by @EngineFunction with AVCloud.callFunction:

Map<String, Object> params = new HashMap<String, Object>();
params.put("movie", "Despicable Me");
try {
  float result = AVCloud.callFunction("averageStars", params);
} catch (AVException e) {
  e.printStackTrace();
}

Calling Cloud Functions with RPC

By calling cloud functions with RPC, LeanEngine will automatically serialize the HTTP response body and the SDK will get the response in the format of AVObject:

NSDictionary *dicParameters = [NSDictionary dictionaryWithObject:@"Despicable Me"
                                                          forKey:@"movie"];

[AVCloud rpcFunctionInBackground:@"averageStars"
                  withParameters:parameters
                  block:^(id object, NSError *error) {
                  if(error == nil){
                    // Success
                  }
                  else {
                    // Error handling
                  }
}];

var paramsJson = {
  movie: "Despicable Me"
};

AV.Cloud.rpc('averageStars', paramsJson).then(function (object) {
  // Success
}, function (error) {
  // Error handling
});

from leancloud import cloudfunc

cloudfunc.rpc('averageStars', movie='Despicable Me')

// Construct parameters
Map<String, String> dicParameters = new HashMap<String, String>();
dicParameters.put("movie", "Despicable Me");

AVCloud.rpcFunctionInBackground("averageStars", dicParameters,
  new FunctionCallback<AVObject>() {
    @Override
    public void done(AVObject object, AVException e) {
      Assert.assertNull(e);
    }
  }
);

Error Codes

You can customize error codes for cloud functions in accordance with HTTP status codes.

@EngineFunction("errorCode")
public static AVUser getCurrentUser() throws Exception {
  AVUser u = AVUser.getCurrentUser();
  if (u == null) {
    throw new AVException(211, "Could not find the user.");
  } else {
    return u;
  }
}

The client will receive { "code": 211, "error": "Could not find the user." } from the function above.

@EngineFunction()
public static void customErrorCode() throws Exception {
  throw new AVException(123, "Custom error message.");
}

The client will receive { "code": 123, "error": "Custom error message." } from the function above.

Timeouts

The time limit for a cloud function to be processed is 15 seconds. If the cloud function does not make a response after this, HTTP error 503 will be triggered with error message The request timed out on the server.

Hooking

A hook can be automatically triggered when certain events happen (like before or after saving or updating an object). Keep in mind that:

• Importing data on the dashboard will not trigger any hooks.
• Dead loops may be caused if hooks are not defined properly.
• Hooks cannot be applied to _Installation table.

For hooks starting with before (including onLogin), if an exception occurs inside the function, the data operation will be terminated. Therefore, you can reject certain data operations by having functions throw an error. For hooks starting with after (including onVerified), such exception will not terminate the data operation because the operation is already completed before the function is executed.

graph LR
A((save)) -->D{object}
D-->E(new)
E-->|beforeSave|H{error?}
H-->N(No)
N-->B[create new object on the cloud]
B -->|afterSave|C((done))
H-->Y(Yes)
Y-->Z((interrupted))
D-->F(existing)
F-->|beforeUpdate|I{error?}
I-->Y
I-->V(No)
V-->G[update existing object on the cloud]
G-->|afterUpdate|C

graph LR
A((delete))-->|beforeDelete|H{error?}
H-->Y(Yes)
Y-->Z((interrupted))
H-->N(No)
N-->B[delete object on the cloud]
B -->|afterDelete|C((done))

To ensure that hooks are triggered internally by LeanStorage services, our SDK will verify the source of each request. If the verification fails, the error message Hook key check failed will be returned. If you see such error message when debugging locally, make sure you are using our command-line interface for debugging.

beforeSave

You can perform an operation before an object is saved, like data verification and pre-processing. For example, a comment on a movie may be too long to be displayed on the client and needs to be cut off to 140 characters:

@EngineHook(className = "Review", type = EngineHookType.beforeSave)
public static AVObject reviewBeforeSaveHook(AVObject review) throws Exception {
  if (AVUtils.isBlankString(review.getString("comment"))) {
    throw new Exception("No comment provided!");
  } else if (review.getString("comment").length() > 140) {
    review.put("comment", review.getString("comment").substring(0, 140) + "…");
  }
  return review;
}

afterSave

You can perform an operation after an object is saved. For example, to update the total number of comments after a comment is created:

@EngineHook(className = "Review", type = EngineHookType.afterSave)
public static void reviewAfterSaveHook(AVObject review) throws Exception {
  AVObject post = review.getAVObject("post");
  post.fetch();
  post.increment("comments");
  post.save();
}

Or, to add a new field from for each new user:

@EngineHook(className = "_User", type = EngineHookType.afterSave)
public static void userAfterSaveHook(AVUser user) throws Exception {
  user.put("from", "LeanCloud");
  user.save();
}

beforeUpdate

You can perform an operation before an object is updated. You will be able to know which fields are updated, or reject the data operation:

@EngineHook(className = "Review", type = EngineHookType.beforeUpdate)
public static AVObject reviewBeforeUpdateHook(AVObject review) throws Exception {
  List<String> updateKeys = EngineRequestContext.getUpdateKeys();
  for (String key : updateKeys) {
    // If comment is changed, check its length
    if ("comment".equals(key) && review.getString("comment").length()>140) {
      throw new Exception("Your comment cannot be longer than 140 characters.");
    }
  }
  return review;
}

afterUpdate

You can perform an operation after an object is updated. You will be able to know which fields are updated (same as beforeUpdate).

@EngineHook(className = "Review", type = EngineHookType.afterUpdate)
public static void reviewAfterUpdateHook(AVObject review) throws Exception {
  List<String> updateKeys = EngineRequestContext.getUpdateKeys();
  for (String key : updateKeys) {
    if ("comment".equals(key) && review.getString("comment").length()<5) {
      LogUtil.avlog.d(review.ObjectId + " seems like a spam: " + comment);
    }
  }
}

Preventing Dead Loops

You might be wondering why we can modify and save the post object in the afterUpdate hook without triggering this hook again. This is because LeanEngine automatically identifies and pre-processes all the post objects passed in by a hook to prevent the hook to be triggered again.

However, if the following situations happen, you still need to handle them by yourself:

• You called fetch on the post objects passed in.
• You constructed the post objects passed in by yourself with methods like AVObject.createWithoutData(String, String).

To prevent such objects from triggering certain hooks, you can call post.disableBeforeHook() or post.disableAfterHook() on them:

@EngineHook(className="Post", type = EngineHookType.afterUpdate)
public static void afterUpdatePost(AVObject post) throws AVException {
  // Directly modifying and saving the object will not trigger afterUpdate
  post.put("foo", "bar");
  post.save();

  // Use disableAfterHook if you called fetch on the object
  post.fetch();
  post.disableAfterHook();
  post.put("foo", "bar");

  // Use disableAfterHook if you constructed the object by yourself
  post = AVObject.createWithoutData("Post", post.getObjectId());
  post.disableAfterHook();
  post.save();
}

beforeDelete

You can perform an operation before an object is deleted. For example, before an album is deleted, check if there are any photos in it:

@EngineHook(className = "Album", type = EngineHookType.beforeDelete)
public static AVObject albumBeforeDeleteHook(AVObject album) throws Exception {
  AVQuery query = new AVQuery("Photo");
  query.whereEqualTo("album", album);
  int count = query.count();
  if (count > 0) {
    // The delete operation will be aborted
    throw new Exception("Cannot delete an album if it still has photos in it.");
  } else {
    return album;
  }
}

afterDelete

You can perform an operation after an object is deleted. For example, when an album is being deleted, instead of checking if there are any photos left, we directly delete all the photos in it:

@EngineHook(className = "Album", type = EngineHookType.afterDelete)
public static void albumAfterDeleteHook(AVObject album) throws Exception {
  AVQuery query = new AVQuery("Photo");
  query.whereEqualTo("album", album);
  List<AVObject> result = query.find();
  if (result != null && !result.isEmpty()) {
    AVObject.deleteAll(result);
  }
}

onVerified

You can perform an operation after a user's email or phone number is verified:

@EngineHook(className = "_User", type = EngineHookType.onVerified)
public static void userOnVerifiedHook(AVUser user) throws Exception {
  LogUtil.avlog.d("User " + user.getObjectId() + " is verified by SMS.");
}

The first parameter is the type of verification (sms for phone number and email for email). Keep in mind that you don't have to update fields like emailVerified with this hook since the system automatically updates them.

onLogin

You can perform an operation before a user tries to log in. For example, to prevent blocked users from logging in:

@EngineHook(className = "_User", type = EngineHookType.onLogin)
public static AVUser userOnLoginHook(AVUser user) throws Exception {
  if ("noLogin".equals(user.getUsername())) {
    throw new Exception("Forbidden");
  } else {
    return user;
  }
}

Hooks for LeanMessage

See LeanMessage Overview > LeanEngine Hooks for more instructions on the methods introduced below.

messageReceived

You can perform an operation after a message is delivered to the cloud but before it is delivered to the receiver. For example, to filter out certain keywords from the message:

@IMHook(type = IMHookType.messageReceived)
public static Map<String, Object> onMessageReceived(Map<String, Object> params) {
  System.out.println(params);
  Map<String, Object> result = new HashMap<String, Object>();
  String content = (String)params.get("content");
  Map<String,Object> contentMap = (Map<String,Object>)JSON.parse(content);
  String text = (String)(contentMap.get("_lctext").toString());
  String processedContent = text.replace("selling drugs", "**");
  result.put("content", processedContent);
  return result;
}

receiversOffline

You can perform an operation if a message is delivered to the receiver but the receiver is offline. For example, to slice the first 32 characters of the message as the title for the push notification:

@IMHook(type = IMHookType.receiversOffline)
public static Map<String, Object> onReceiversOffline(Map<String, Object> params) {
  // content is the content of the message
  String alert = (String)params.get("content");
  if(alert.length() > 32){
    alert = alert.substring(0, 32);
  }
  System.out.println(alert);
  Map<String, Object> result = new HashMap<String, Object>();
  JSONObject object = new JSONObject();
  // Self-increase the number of unread messages
  // Can be set to a fixed number
  object.put("badge", "Increment");
  object.put("sound", "default");
  // Using development certificate
  object.put("_profile", "dev");
  object.put("alert", alert);
  result.put("pushMessage", object.toString());
  return result;
}

messageSent

You can perform an operation after a message is delivered to the receiver. For example, to print out a log in LeanEngine:

@IMHook(type = IMHookType.messageSent)
public static Map<String, Object> onMessageSent(Map<String, Object> params) {
  System.out.println(params);
  Map<String, Object> result = new HashMap<String, Object>();
  // …
  return result;
}

conversationStart

You can perform an operation after the signature verification (if enabled) of creating a conversation is completed but before the conversation is created. For example, to print out a log in LeanEngine:

@IMHook(type = IMHookType.conversationStart)
public static Map<String, Object> onConversationStart(Map<String, Object> params) {
  System.out.println(params);
  Map<String, Object> result = new HashMap<String, Object>();
  // Refuse to create the conversation if it is initiated by Tom
  if ("Tom".equals(params.get("initBy"))) {
    result.put("reject", true);
    // Custom error code
    result.put("code", 9890);
  }
  return result;
}

conversationStarted

You can perform an operation after a conversation is created. For example, to print out a log in LeanEngine:

@IMHook(type = IMHookType.conversationStarted)
public static Map<String, Object> onConversationStarted(Map<String, Object> params) throws Exception {
  System.out.println(params);
  Map<String, Object> result = new HashMap<String, Object>();
  String convId = (String)params.get("convId");
  System.out.println(convId);
  return result;
}

conversationAdd

You can perform an operation after the signature verification (if enabled) of adding a member into a conversation is completed but before the member is added. This will be triggered both when the member proactively joins the conversation or is added by another member. Keep in mind that this hook will not be triggered when creating a conversation with clientIds. For example, to print out a log in LeanEngine:

@IMHook(type = IMHookType.conversationAdd)
public static Map<String, Object> onConversationAdd(Map<String, Object> params) {
  System.out.println(params);
  String[] members = (String[])params.get("members");
  Map<String, Object> result = new HashMap<String, Object>();
  System.out.println("members");
  System.out.println(members);
  // Refuse to add the member if it is initiated by Tom
  if ("Tom".equals(params.get("initBy"))) {
    result.put("reject", true);
    // Custom error code
    result.put("code", 9890);
  }
  return result;
}

conversationRemove

You can perform an operation after the signature verification (if enabled) of removing a member from a conversation is completed but before the member is removed. This will not be triggered when the member proactively quits the conversation. For example, to print out a log in LeanEngine:

@IMHook(type = IMHookType.conversationRemove)
public static Map<String, Object> onConversationRemove(Map<String, Object> params) {
  System.out.println(params);
  String[] members = (String[])params.get("members");
  Map<String, Object> result = new HashMap<String, Object>();
  System.out.println("members");
  // Refuse to remove the member if it is initiated by Tom
  if ("Tom".equals(params.get("initBy"))) {
    result.put("reject", true);
    // Custom error code
    result.put("code", 9892);
  }
  return result;
}

conversationUpdate

You can perform an operation before the properties of a conversation (including notifications) are updated. For example, to print out a log in LeanEngine:

@IMHook(type = IMHookType.conversationUpdate)
public static Map<String, Object> onConversationUpdate(Map<String, Object> params) {
  System.out.println(params);
  Map<String, Object> result = new HashMap<String, Object>();
  Map<String,Object> attr = (Map<String,Object>)params.get("attr");
  System.out.println(attr);
  // Map<String,Object> attrMap = (Map<String,Object>)JSON.parse(attr);
  String name = (String)attr.get("name");
  // System.out.println(attrMap);
  System.out.println(name);
  // Refuse to change the property if it is initiated by Tom
  if ("Tom".equals(params.get("initBy"))) {
    result.put("reject", true);
    // Custom error code
    result.put("code", 9893);
  }
  return result;
}

Error Codes for Hooks

You can define error codes for hooks like beforeSave:

@EngineHook(className = "Review", type = EngineHookType.beforeSave)
public static AVObject reviewBeforeSaveHook(AVObject review) throws Exception {
  throw new AVException(123, "An error occurred.");
}

The client will receive Cloud Code validation failed. Error detail: { "code": 123, "message": "An error occurred." } as the response. You can retrieve the error message by slicing the string.

Timeouts for Hooks

The time limit for a hook to be processed is 3 seconds. If a hook is triggered by another cloud function (like a beforeSave or afterSave triggered by saving an object), the time limit of this hook will be further limited by the time remaining.

For example, if a beforeSave is triggered by a cloud function that has already taken 13 seconds, there will be only 2 seconds left for this hook. See Timeouts.

Scheduled Tasks

You can set up timers to schedule your cloud functions. For example, to clean up temporary data every night, to send push notifications to users every Monday, etc. The timer can be accurate to a second.

The time restrictions applied to ordinary cloud functions also apply to scheduled functions. See Timeouts.

After deploying your program to LeanEngine, go to your app's Dashboard > LeanEngine > Scheduled tasks and click on Create a timer to create a timer for a cloud function. For example, if we have a function named logTimer:

@EngineFunction("logTimer")
public static float logTimer throws Exception {
  LogUtil.avlog.d("This log is printed by logTimer.");
}

After a timer is created, the default status of it will be Disabled. You need to click on Enable to activate the timer. You can see the logs of the timer in Dashboard > LeanEngine > App logs.

You can set up timers with either cron expressions or intervals with seconds as the unit. For example, to run a function on 8:00 every Monday, use 0 0 8 ? * MON as the cron expression.

You can create up to 6 timers for each of the staging environment and the production environment, which means that you can create 12 timers in total.

Error Messages for Scheduled Tasks

The error messages of timers will be output to Dashboard > LeanEngine > App logs. Below are some common errors and the reasons causing them:

• timerAction timed-out and no fallback available
  A function triggered by a timer reached its 15-second time limit for processing. See Handling Timeouts.
• timerAction short-circuited and no fallback available
  A timer is disabled due to frequent timeouts happening to the function it is triggering.

Using Master Key

Since cloud functions are running on the server side, we can assume that requests made by these functions are trustable. Therefore, you can enable global Master Key for all these requests, which will have your program ignore permission settings of classes and those done by ACL so it can access data in the cloud without any restrictions. The code below enables Master Key for your program:

// Often in src/…/AppInitListener.java
JavaRequestSignImplementation.instance().setUseMasterKey(true);

See ACL Guide and Using ACL in LeanEngine for more information regarding permission settings with LeanEngine.