Scripts

"type": string, required

The Internet media type (formerly MIME type) of the script, "application/x-groovy" for Groovy

"file": expression

Path to the file containing the script; mutually exclusive with "source".

Relative paths are with respect to to the base location for scripts. The base location depends on the configuration.

The base location for Groovy scripts is on the classpath when the scripts are executed. If some Groovy scripts are not in the default package, but instead have their own package names, they belong in the directory corresponding to their package name. For example, a script in package com.example.groovy belongs under openig-base/scripts/groovy/com/example/groovy/.

"source": string or array of strings, required if "file" is not used

The script as a string or array of strings; mutually exclusive with "file".

The following example shows the source of a script as an array of strings:

"source": [
  "Response response = new Response(Status.OK)",
  "response.entity = 'foo'",
  "return response"
]

"args": map, optional

Parameters passed from the configuration to the script.

• The following example configures arguments as a map whose values can are scalars, arrays, and objects:

  {
    "args": {
      "title": "Coffee time",
      "status": 418,
      "reason": [
        "Not Acceptable",
        "I'm a teapot",
        "Acceptable"
      ],
      "names": {
        "1": "koffie",
        "2": "kafe",
        "3": "cafe",
        "4": "kafo"
      }
    }
  }

  A script can access the args parameters in the same way as other global objects. The following example sets the response status to I'm a teapot:

  response.status = Status.valueOf(418, reason[1])

  For information about the 418 status code see RFC 7168, Section 2.3.3 418 I'm a Teapot .

• The following example configures arguments as strings and numbers for a ScriptableThrottlingPolicy:

  "args": {
    "status": "gold",
    "rate": 6,
    "duration": "10 seconds"
  }

  The following lines set the throttling rate to 6 requests each 10 seconds when the response status is gold:

  if (attributes.rate.status == status) {
    return new ThrottlingRate(rate, duration)
  }

• The following example configures arguments that reference a SampleFilter defined in the heap:

  {
    "heap": [
      {
        "name": "SampleFilter",
        "type": "SampleFilter",
        "config": {
          "name": "X-Greeting",
          "value": "Hello world"
        }
      }
    ]
  }

  The following line uses an expression in the args parameter to pass SampleFilter to the script:

  {
    "args": {
      "filter": "${heap['SampleFilter']}"
    }
  }

  The script can then reference SampleFilter as filter.

"clientHandler", ClientHandler reference, optional

A Handler for making outbound HTTP requests to third-party services. In a script, clientHandler is wrapped within the global object http.

Default: The default ClientHandler.

For details, see Handlers.

For more information, see org.forgerock.http.Client.

The following global objects are available to scripts:

Any parameters passed as args

You can use the configuration to pass parameters to the script by specifying an args object.

The args object is a map whose values can be scalars, arrays, and objects. The args object can reference objects defined in the heap by using expressions, for example, "${heap['ObjectName']}".

The values for script arguments can be defined as configuration expressions, and evaluated at configuration time.

Script arguments cannot refer to context and request, but context and request variables can be accessed directly within scripts.

Take care when naming keys in the args object. If you reuse the name of another global object, cause the script to fail and IG to return a response with HTTP status code 500 Internal Server Error.

All heap objects

The heap object configuration, described in "Heap Objects".

openig

An implicit object that provides access to the environment when expressions are evaluated.

attributes

The attributes object provides access to a context map of arbitrary attributes, which is a mechanism for transferring transient state between components when processing a single request.

Use session for maintaining state between successive requests from the same logical client.

builder

For ScriptableJwtValidatorCustomizer only.

Used by the ScriptableJwtValidatorCustomizer and "JwtValidationFilter" to create constraints to test JWT claims and sub-claims. The purpose of the ScriptableJwtValidatorCustomizer is to enrich the builder object.

For information about methods to enrich the builder instance, see JwtValidator.Builder.

context

The processing context.

This context is the leaf of a chain of contexts. It provides access to other Context types, such as SessionContext, AttributesContext, and ClientContext, through the context.asContext(ContextClass.class) method.

contexts

a map<string, context> object. For information, see "Contexts".

request

The HTTP request.

globals

This object is a Map that holds variables that persist across successive invocations.

http

An embedded client for making outbound HTTP requests, which is an org.forgerock.http.Client.

If a "clientHandler" is set in the configuration, then that Handler is used. Otherwise, the default ClientHandler configuration is used.

For details, see Handlers.

ldap

The ldap object provides an embedded LDAP client.

Use this client to perform outbound LDAP requests, such as LDAP authentication.

logger

The logger object provides access to a unique SLF4J logger instance for scripts, where the logger instance is named with the script name.

For information about logging for scripts, see "Logging In Scripts".

next

The object named next refers to the next element in the chain, which can be the following filter or the terminal handler. If the next object in the chain is a filter, IG wraps it in a handler.

session

The session object provides access to the session context, which is a mechanism for maintaining state when processing a successive requests from the same logical client or end user.

Use attributes for transferring transient state between components when processing a single request.