Red Hat Summit Red Hat SummitSuporteConsoleDesenvolvedoresComeçar um testeContato

Este conteúdo não está disponível no idioma selecionado.

Chapter 8. Remotely Executing Server-Side Tasks

Define and add tasks to Data Grid servers that you can invoke from the Data Grid command line interface, REST API, or from Hot Rod clients.

You can implement tasks as custom Java classes or define scripts in languages such as JavaScript.

8.1. Creating Server Tasks
Copiar o link

Create custom task implementations and add them to Data Grid servers.

8.1.1. Server Tasks
Copiar o link

Data Grid server tasks are classes that extend the org.infinispan.tasks.ServerTask interface and generally include the following method calls:

setTaskContext()
Allows access to execution context information including task parameters, cache references on which tasks are executed, and so on. In most cases, implementations store this information locally and use it when tasks are actually executed.
getName()
Returns unique names for tasks. Clients invoke tasks with these names.
getExecutionMode()

Returns the execution mode for tasks.

  • TaskExecutionMode.ONE_NODE only the node that handles the request executes the script. Although scripts can still invoke clustered operations.
  • TaskExecutionMode.ALL_NODES Data Grid uses clustered executors to run scripts across nodes. For example, server tasks that invoke stream processing need to be executed on a single node because stream processing is distributed to all nodes.
call()
Computes a result. This method is defined in the java.util.concurrent.Callable interface and is invoked with server tasks.
Important

Server task implementations must adhere to service loader pattern requirements. For example, implementations must have a zero-argument constructors.

The following HelloTask class implementation provides an example task that has one parameter: 

package example;

import org.infinispan.tasks.ServerTask;
import org.infinispan.tasks.TaskContext;

public class HelloTask implements ServerTask<String> {

   private TaskContext ctx;

   @Override
   public void setTaskContext(TaskContext ctx) {
      this.ctx = ctx;
   }

   @Override
   public String call() throws Exception {
      String name = (String) ctx.getParameters().get().get("name");
      return "Hello " + name;
   }

   @Override
   public String getName() {
      return "hello-task";
   }

}
Copy to Clipboard Toggle word wrap

Reference

8.1.2. Deploying Server Tasks to Data Grid Servers
Copiar o link

Add your custom server task classes to Data Grid servers.

Prerequisites

Stop any running Data Grid servers. Data Grid does not support runtime deployment of custom classes.

Procedure

  1. Package your server task implementation in a JAR file.

  2. Add a META-INF/services/org.infinispan.tasks.ServerTask file that contains the fully qualified names of server tasks, for example: 

    example.HelloTask
    Copy to Clipboard Toggle word wrap
  3. Copy the JAR file to the $RHDG_HOME/server/lib directory of your Data Grid server.
  4. Add your classes to the deserialization whitelist in your Data Grid configuration. Alternatively set the whitelist using system properties.

Reference

8.2. Creating Server Scripts
Copiar o link

Create custom scripts and add them to Data Grid servers.

8.2.1. Server Scripts
Copiar o link

Data Grid server scripting is based on the javax.script API and is compatible with any JVM-based ScriptEngine implementation.

Hello World Script Example

The following is a simple example that runs on a single Data Grid server, has one parameter, and uses JavaScript: 

// mode=local,language=javascript,parameters=[greetee]
"Hello " + greetee
Copy to Clipboard Toggle word wrap

When you run the preceding script, you pass a value for the greetee parameter and Data Grid returns "Hello ${value}".

8.2.1.1. Script Metadata
Copiar o link

Metadata provides additional information about scripts that Data Grid servers use when running scripts.

Script metadata are property=value pairs that you add to comments in the first lines of scripts, such as the following example: 

// name=test, language=javascript
// mode=local, parameters=[a,b,c]
Copy to Clipboard Toggle word wrap
  • Use comment styles that match the scripting language (//, ;;, #).
  • Separate property=value pairs with commas.
  • Separate values with single (') or double (") quote characters.
Expand
Table 8.1. Metadata Properties
PropertyDescription

mode

Defines the exection mode and has the following values:

local only the node that handles the request executes the script. Although scripts can still invoke clustered operations.

distributed Data Grid uses clustered executors to run scripts across nodes.

language

Specifies the ScriptEngine that executes the script.

extension

Specifies filename extensions as an alternative method to set the ScriptEngine.

role

Specifies roles that users must have to execute scripts.

parameters

Specifies an array of valid parameter names for this script. Invocations which specify parameters not included in this list cause exceptions.

datatype

Optionally sets the MediaType (MIME type) for storing data as well as parameter and return values. This property is useful for remote clients that support particular data formats only.

Currently you can set only text/plain; charset=utf-8 to use the String UTF-8 format for data.

8.2.1.2. Script Bindings
Copiar o link

Data Grid exposes internal objects as bindings for script execution.

Expand
BindingDescription

cache

Specifies the cache against which the script is run.

marshaller

Specifies the marshaller to use for serializing data to the cache.

cacheManager

Specifies the cacheManager for the cache.

scriptingManager

Specifies the instance of the script manager that runs the script. You can use this binding to run other scripts from a script.

8.2.1.3. Script Parameters
Copiar o link

Data Grid lets you pass named parameters as bindings for running scripts.

Parameters are name,value pairs, where name is a string and value is any value that the marshaller can interpret.

The following example script has two parameters, multiplicand and multiplier. The script takes the value of multiplicand and multiplies it with the value of multiplier. 

// mode=local,language=javascript
multiplicand * multiplier
Copy to Clipboard Toggle word wrap

When you run the preceding script, Data Grid responds with the result of the expression evaluation.

8.2.2. Adding Scripts to Data Grid Servers
Copiar o link

Use the command line interface to add scripts to Data Grid servers.

Prerequisites

Data Grid Server stores scripts in the ___script_cache cache. If you enable cache authorization, users require the ___script_manager role to access ___script_cache.

Procedure

  1. Define scripts as required.

    For example, create a file named multiplication.js that runs on a single Data Grid server, has two parameters, and uses JavaScript to multiply a given value: 

    // mode=local,language=javascript
multiplicand * multiplier
    Copy to Clipboard Toggle word wrap
  2. Create a CLI connection to Data Grid.

  3. Use the task command to upload scripts, as in the following example: 

    [//containers/default]> task upload --file=multiplication.js multiplication
    Copy to Clipboard Toggle word wrap

  4. Verify that your scripts are available. 

    [//containers/default]> ls tasks
multiplication
    Copy to Clipboard Toggle word wrap

8.2.3. Programmatically Creating Scripts
Copiar o link

Add scripts with the Hot Rod RemoteCache interface as in the following example: 

RemoteCache<String, String> scriptCache = cacheManager.getCache("___script_cache");
scriptCache.put("multiplication.js",
  "// mode=local,language=javascript\n" +
  "multiplicand * multiplier\n");
Copy to Clipboard Toggle word wrap

Reference

org.infinispan.client.hotrod.RemoteCache

8.3. Running Server-Side Tasks and Scripts
Copiar o link

Execute tasks and custom scripts on Data Grid servers.

8.3.1. Running Tasks and Scripts
Copiar o link

Use the command line interface to run tasks and scripts on Data Grid clusters.

Procedure

  1. Create a CLI connection to Data Grid.

  2. Use the task command to run tasks and scripts, as in the following examples:

    • Execute a script named multipler.js and specify two parameters: 

      [//containers/default]> task exec multipler.js -Pmultiplicand=10 -Pmultiplier=20
200.0
      Copy to Clipboard Toggle word wrap

    • Execute a task named @@cache@names to retrieve a list of all available caches: 

      //containers/default]> task exec @@cache@names
["___protobuf_metadata","mycache","___script_cache"]
      Copy to Clipboard Toggle word wrap

8.3.2. Programmatically Running Scripts
Copiar o link

Call the execute() method to run scripts with the Hot Rod RemoteCache interface, as in the following example: 

RemoteCache<String, Integer> cache = cacheManager.getCache();
// Create parameters for script execution.
Map<String, Object> params = new HashMap<>();
params.put("multiplicand", 10);
params.put("multiplier", 20);
// Run the script with the parameters.
Object result = cache.execute("multiplication.js", params);
Copy to Clipboard Toggle word wrap

Reference

org.infinispan.client.hotrod.RemoteCache

8.3.3. Programmatically Running Tasks
Copiar o link

Call the execute() method to run tasks with the Hot Rod RemoteCache interface, as in the following example: 

// Add configuration for a locally running server.
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.addServer().host("127.0.0.1").port(11222);

// Connect to the server.
RemoteCacheManager cacheManager = new RemoteCacheManager(builder.build());

// Retrieve the remote cache.
RemoteCache<String, String> cache = cacheManager.getCache();

// Create task parameters.
Map<String, String> parameters = new HashMap<>();
parameters.put("name", "developer");

// Run the server task.
String greet = cache.execute("hello-task", parameters);
System.out.println(greet);
Copy to Clipboard Toggle word wrap

Reference

org.infinispan.client.hotrod.RemoteCache

Voltar ao topo
Red Hat logoGithubredditYoutubeTwitter

Aprender

Experimente, compre e venda

Comunidades

Sobre a documentação da Red Hat

Ajudamos os usuários da Red Hat a inovar e atingir seus objetivos com nossos produtos e serviços com conteúdo em que podem confiar. Explore nossas atualizações recentes.

Tornando o open source mais inclusivo

A Red Hat está comprometida em substituir a linguagem problemática em nosso código, documentação e propriedades da web. Para mais detalhes veja o Blog da Red Hat.

Sobre a Red Hat

Fornecemos soluções robustas que facilitam o trabalho das empresas em plataformas e ambientes, desde o data center principal até a borda da rede.

Theme

© 2025 Red Hat