APEX Policy Guide

APEX Policy Matrix

APEX Policy Matrix

APEX offers a lot of flexibility for defining, deploying, and executing policies. Based on a theoretic model, it supports virtually any policy model and allows to translate legacy policies into the APEX execution format. However, the most important aspect for using APEX is to decide what policy is needed, what underlying policy concepts should be used, and how the decision logic should be realized. Once these aspects are decided, APEX can be used to execute the policies. If the policy evolves, say from a simple decision table to a fully adaptable policy, only the policy definition requires change. APEX supports all of that.
The figure below shows a (non-exhaustive) matrix, which will help to decide what policy is required to solve your problem. Read the matrix from left to right choosing one cell in each column.
APEX Policy Matrix
Figure 1. APEX Policy Matrix
The policy can support one of a number of stimuli with an associated purpose/model of the policy, for instance:
  • Configuration, i.e. what should happen. An example is an event that states an intended network configuration and the policy should provide the detailed actions for it. The policy can be realized for instance as an obligation policy, a promise or an intent.
  • Report, i.e. something did happen. An example is an event about an error or fault and the policy needs to repair that problem. The policy would usually be an obligation, utility function, or goal policy.
  • Monitoring, i.e. something does happen. An example is a notification about certain network conditions, to which the policy might (or might not) react. The policy will mitigate the monitored events or permit (deny) related actions as an obligation or authorization.
  • Analysis, i.e. why did something happen. An example is an analytic component sends insights of a situation requiring a policy to act on it. The policy can solve the problem, escalate it, or delegate it as a refrain or delegation policy.
  • Prediction, i.e. what will happen next. An example are events that a policy uses to predict a future network condition. The policy can prevent or enforce the prediction as an adaptive policy, a utility function, or a goal.
  • Feedback, i.e. why did something happen or not happen. Similar to analysis, but here the feedback will be in the input event and the policy needs to something with that information. Feedback can be related to history or experience, for instance a previous policy execution. The policy needs to be context-aware or be a meta-policy.
Once the purpose of the policy is decided, the next step is to look into what context information the policy will require to do its job. This can range from very simple to a lot of different information, for instance:
  • No context, nothing but a trigger event, e.g. a string or a number, is required
  • Event context, the incoming event provides all information (more than a string or number) for the policy
  • Policy context (read only), the policy has access to additional information related to its class but cannot change/alter them
  • Policy context (read and write), the policy has access to additional information related to its class and can alter this information (for instance to record historic information)
  • Global context (read only), the policy has access to additional information of any kind but cannot change/alter them
  • Global context (read and write), the policy the policy has access to additional information of any kind and can alter this information (for instance to record historic information)
The next step is to decide how the policy should do its job, i.e. what flavor it has, how many states are needed, and how many tasks. There are many possible combinations, for instance:
  • Simple / God: a simple policy with 1 state and 1 task, which is doing everything for the decision-making. This is the ideal policy for simple situation, e.g. deciding on configuration parameters or simple access control.
  • Simple sequence: a simple policy with a number of states each having a single task. This is a very good policy for simple decision-making with different steps. For instance, a classic action policy (ECA) would have 3 states (E, C, and A) with some logic (1 task) in each state.
  • Simple selective: a policy with 1 state but more than one task. Here, the appropriate task (and it’s logic) will be selected at execution time. This policy is very good for dealing with similar (or the same) situation in different contexts. For instance, the tasks can be related to available external software, or to current work load on the compute node, or to time of day.
  • Selective: any number of states having any number of tasks (usually more than 1 task). This is a combination of the two policies above, for instance an ECA policy with more than one task in E, C, and A.
  • Classic directed: a policy with more than one state, each having one task, but a non-sequential execution. This means that the sequence of the states is not pre-defined in the policy (as would be for all cases above) but calculated at runtime. This can be good to realize decision trees based on contextual information.
  • Super Adaptive: using the full potential of the APEX policy model, states and tasks and state execution are fully flexible and calculated at runtime (per policy execution). This policy is very close to a general programming system (with only a few limitations), but can solve very hard problems.
The final step is to select a response that the policy creates. Possible responses have been discussed in the literature for a very long time. A few examples are:
  • Obligation (deontic for what should happen)
  • Authorization (e.g. for rule-based or other access control or security systems)
  • Intent (instead of providing detailed actions the response is an intent statement and a further system processes that)
  • Delegation (hand the problem over to someone else, possibly with some information or instructions)
  • Fail / Error (the policy has encountered a problem, and reports it)
  • Feedback (why did the policy make a certain decision)

APEX Policy Model

Introduction

The APEX policy model is shown in UML notation in the figure below. A policy model can be stored in JSON or XML format in a file or can be held in a database. The APEX editor creates and modifies APEX policy models. APEX deployment deploys policy models, and a policy model is loaded into APEX engines so that the engines can run the policies in the policy model.
The figure shows four different views of the policy model:
  • The general model view shows the main parts of a policy: state, state output, event, and task. A task can also have parameters. Data types can be defined on a per-model basis using either standard atomic types (such as character, string, numbers) or complex types from a policy domain.
  • The logic model view emphasizes how decision-making logic is injected into a policy. There are essentially three different types of logic: task logic (for decision making in a task), task selection logic (to select a task if more than one is defined in a state), and state finalizer logic (to compute the final output event of a state and select an appropriate next state from the policy model).
  • The context model view shows how context is injected into a policy. States collect all context from their tasks. A task can define what context it requires for the decision making, i.e. what context the task logic will process. Context itself is a collection of items (individual context information) with data types. Context can be templated.
  • The event and field model view shows the events in the policy model. Tasks define what information they consume (input) and produce (output). This information is modeled as fields, essentially a key/type tuple in the model and a key/type/value triple at execution. Events then are collection of fields.
APEX Policy Model for Execution
Figure 2. APEX Policy Model for Execution

Concepts and Keys

Each element of the policy model is called a concept. Each concept is a subclass of the abstract Concept class, as shown in the next figure. Every concept implements the following abstract methods:
Concepts and Keys
Figure 3. Concepts and Keys
  • getKey() - gets the unique key for this concept instance in the system
  • validate() - validates the structure of this concept, its sub-concepts and its relationships
  • clean() - carries out housekeeping on the concept such as trimming strings, remove any hanging references
  • clone() - creates a deep copy of an instance of this concept
  • equals() - checks if two instances of this concept are equal
  • toString() - returns a string representation of the concept
  • hashCode() - returns a hash code for the concept
  • copyTo() - carries out a deep copy of one instance of the concept to another instance, overwriting the target fields.
All concepts must have a key, which uniquely identifies a concept instance. The key of a subclass of an Concept must either be an ArtifactKey or an ReferenceKey. Concepts that have a stand-alone independent existence such as Policy, Task, and Event must have an ArtifctKey key. Concepts that are contained in other concepts, that do not exist as stand-alone concepts must have an ReferenceKey key. Examples of such concepts are State and EventParameter.
An ArticactKey has two fields; the Name of the concept it is the key for and the concept’s Version. A concept’s name must be unique in a given PolicyModel. A concept version is represented using the well known major.minor.path scheme as used in semantic versioning.
A ReferenceKey has three fields. The UserKeyName and UserKeyVersion fields identify the ArtifactKey of the concept in which the concept keyed by the ReferenceKey is contained. The LocalName field identifies the contained concept instance. The LocalName must be unique in the concepts of a given type contained by a parent.
For example, a policy called SalesPolicy with a Version of 1.12.4 has a state called Decide. The Decide state is linked to the SalesPolicy with a ReferenceKey with fields UserKeyName of SalesPolicy, UserKeyVersion of 1.12.4, and LocalName of Decide. There must not be another state called Decide in the policy SalesPolicy. However, there may well be a state called Decide in some other policy called PurchasingPolicy.
Each concept in the model is also a JPA (Java Persistence API) Entity. This means that every concept can be individually persisted or the entire model can be persisted en-bloc to any persistence mechanism using an JPA framework such as Hibernate or EclipseLink.

Concept: PolicyModel

The PolicyModel concept is a container that holds the definition of a set of policies and their associated events, context maps, and tasks. A PolicyModel is implemented as four maps for policies, events, context maps, and tasks. Each map is indexed by the key of the policy, event, context map, or task. Any non-empty policy model must have at least one entry in its policy, event, and task map because all policies must have at least one input and output event and must execute at least one task.
A PolicyModel concept is keyed with an ArtifactKey key. Because a PolicyModel is an AxConcept, calling the validate() method on a policy model validates the concepts, structure, and relationships of the entire policy model.

Concept: DataType

Data types are tightly controlled in APEX in order to provide a very high degree of consistency in policies and to facilitate tracking of changes to context as policies execute. All context is modeled as a DataType concept. Each DataType concept instance is keyed with an ArtifactKey key. The DataType field identifies the Java class of objects that is used to represent concept instances that use this data type. All context has a DataType; incoming and outgoing context is represented by EventField concepts and all other context is represented by ContextItem concepts.

Concept: Event

An Event defines the structure of a message that passes into or out of an APEX engine or that passes between two states in an APEX engine. APEX supports message reception and sending in many formats and all messages are translated into an Event prior to processing by an APEX engine. Event concepts are keyed with an ArtifactKey key. The parameters of an event are held as a map of EventField concept instances with each parameter indexed by the LocalName of its ReferenceKey. An Event has three fields:
  • The NameSpace identifies the domain of application of the event
  • The Source of the event identifies the system that emitted the event
  • The Target of the event identifies the system that the event was sent to
A PolicyModel contains a map of all the events known to a given policy model. Although an empty model may have no events in its event map, any sane policy model must have at least one Event defined.

Concept: EventField

The incoming context and outgoing context of an event are the fields of the event. Each field representing a single piece of incoming or outgoing context. Each field of an Event is represented by an instance of the EventField concept. Each EventField concept instance in an event is keyed with a ReferenceKey key, which references the event. The LocalName field of the ReferenceKey holds the name of the field A reference to a DataType concept defines the data type that values of this parameter have at run time.

Concept: ContextMap

The set of context that is available for use by the policies of a PolicyModel is defined as ContextMap concept instances. The PolicyModel holds a map of all the ContextMap definitions. A ContextMap is itself a container for a group of related context items, each of which is represented by a ContextItem concept instance. ContextMap concepts are keyed with an ArtifactKey key. A developer can use the APEX Policy Editor to create context maps for their application domain.
A ContextMap uses a map to hold the context items. The ContextItem concept instances in the map are indexed by the LocalName of their ReferenceKey.
The ContextMapType field of a ContextMap defines the type of a context map. The type can have either of two values:
  • A BAG context map is a context map with fixed content. Each possible context item in the context map is defined at design time and is held in the ContextMap context instance as ContextItem concept definitions and only the values of the context items in the context map can be changed at run time. The context items in a BAG context map have mixed types and distinct ContextItem concept instances of the same type can be defined. A BAG context map is convenient for defining a group of context items that are diverse but are related by domain, such as the characteristics of a device. A fully defined BAG context map has a fully populated ContextItem map but its ContextItemTemplate reference is not defined.
  • A SAMETYPE context map is used to represent a group of ContextItem instances of the same type. Unlike a BAG context map, the ContextItem concept instances of a SAMETYPE context map can be added, modified, and deleted at runtime. All ContextItem concept instances in a SAMETYPE context map must be of the same type, and that context item is defined as a single ContextItemTemplate concept instances at design time. At run time, the ContextItemTemplate definition is used to create new ContextItem concept instances for the context map on demand. A fully defined SAMETYPE context map has an empty ContextItem map and its ContextItemTemplate_ reference is defined.
The Scope of a ContextMap defines the range of applicability of a context map in APEX. The following scopes of applicability are defined:
  • EPHEMERAL scope means that the context map is owned, used, and modified by a single application, but the context map only exists while that application is running
  • APPLICATION scope specifies that the context map is owned, used, and modified by a single application, the context map is persistent
  • GLOBAL scope specifies that the context map is globally owned and is used and modified by any application, the context map is persistent
  • EXTERNAL scope specifies that the context map is owned by an external system and may be used in a read-only manner by any application, the context map is persistent
A much more sophisticated scoping mechanism for context maps is envisaged for Apex in future work. In such a mechanism, the scope of a context map would work somewhat like the way roles work in security authentication systems.

Concept: ContextItem

Each piece of context in a ContextMap is represented by an instance of the ContextItem concept. Each ContextItem concept instance in a context map keyed with a ReferenceKey key, which references the context map of the context item. The LocalName field of the ReferenceKey holds the name of the context item in the context map A reference to a DataType concept defines the data type that values of this context item have at run time. The WritableFlag indicates if the context item is read only or read-write at run time.

Concept: ContextItemTemplate

In a SAMETYPE ContextMap, the ContextItemTemplate definition provides a template for the ContextItem instances that will be created on the context map at run time. Each ContextItem concept instance in the context map is created using the ContextItemTemplate template. It is keyed with a ReferenceKey key, which references the context map of the context item. The LocalName field of the ReferenceKey, supplied by the creator of the context item at run time, holds the name of the context item in the context map. A reference to a DataType concept defines the data type that values of this context item have at run time. The WritableFlag indicates if the context item is read only or read-write at run time.

Concept: Task

The smallest unit of logic in a policy is a Task. A task encapsulates a single atomic unit of logic, and is designed to be a single indivisible unit of execution. A task may be invoked by a single policy or by many policies. A task has a single trigger event, which is sent to the task when it is invoked. Tasks emit one or more outgoing events, which carry the result of the task execution. Tasks may use or modify context as they execute.
The Task concept definition captures the definition of an APEX task. Task concepts are keyed with an ArtifactKey key. The Trigger of the task is a reference to the Event concept that triggers the task. The OutgoingEvents of a task are a set of references to Event concepts that may be emitted by the task.
All tasks have logic, some code that is programmed to execute the work of the task. The Logic concept of the task holds the definition of that logic.
The Task definition holds a set of ContextItem and ContextItemTemplate context items that the task is allow to access, as defined by the task developer at design time. The type of access (read-only or read write) that a task has is determined by the WritableFlag flag on the individual context item definitions. At run time, a task may only access the context items specified in its context item set, the APEX engine makes only the context items in the task context item set is available to the task.
A task can be configured with startup parameters. The set of parameters that can be configured on a task are defined as a set of TaskParameter concept definitions.

Concept: TaskParameter

Each configuration parameter of a task are represented as a Taskparameter concept keyed with a ReferenceKey key, which references the task. The LocalName field of the ReferenceKey holds the name of the parameter. The DefaultValue field defines the default value that the task parameter is set to. The value of TaskParameter instances can be overridden at deployment time by specifying their values in the configuration information passed to APEX engines.

Concept: Logic

The Logic concept instance holds the actual programmed task logic for a task defined in a Task concept or the programmed task selection logic for a state defined in a State concept. It is keyed with a ReferenceKey key, which references the task or state that owns the logic. The LocalName field of the Logic concept is the name of the logic.
The LogicCode field of a Logic concept definition is a string that holds the program code that is to be executed at run time. The LogicType field defines the language of the code. The standard values are the logic languages supported by APEX: JAVASCRIPT, JAVA, JYTHON, JRUBY, or MVEL.
The APEX engine uses the LogicType field value to decide which language interpreter to use for a task and then sends the logic defined in the LogicCode field to that interpreter.

Concept: Policy

The Policy concept defines a policy in APEX. The definition is rather straightforward. A policy is made up of a set of states with the flavor of the policy determining the structure of the policy states and the first state defining what state in the policy executes first. Policy concepts are keyed with an ArtifactKey key.
The PolicyFlavour of a Policy concept specifies the structure that will be used for the states in the policy. A number of commonly used policy patterns are supported as APEX policy flavors. The standard policy flavors are:
  • The MEDA flavor supports policies written to the MEDA policy pattern and require a sequence of four states: namely Match, Establish, Decide and Act.
  • The OODA flavor supports policies written to the OODA loop pattern and require a sequence of four states: namely Observe, Orient, Decide and Act.
  • The ECA flavor supports policies written to the ECA active rule pattern and require a sequence of three states: namely Event, Condition and Action
  • The XACML flavor supports policies written in XACML and require a single state: namely XACML
  • The FREEFORM flavor supports policies written in an arbitrary style. A user can define a FREEFORM policy as an arbitrarily long chain of states.
The FirstState field of a Policy definition is the starting point for execution of a policy. Therefore, the trigger event of the state referenced in the FirstState field is also the trigger event for the entire policy.

Concept: State

The State concept represents a phase or a stage in a policy, with a policy being composed of a series of states. Each state has at least one but may have many tasks and, on each run of execution, a state executes one and only one of its tasks. If a state has more than one task, then its task selection logic is used to select which task to execute. Task selection logic is programmable logic provided by the state designer. That logic can use incoming, policy, global, and external context to select which task best accomplishes the purpose of the state in a give situation if more than one task has been specified on a state. A state calls one and only one task when it is executed.
Each state is triggered by an event, which means that all tasks of a state must also be triggered by that same event. The set of output events for a state is the union of all output events from all tasks for that task. In practice at the moment, because a state can only have a single input event, a state that is not the final state of a policy may only output a single event and all tasks of that state may also only output that single event. In future work, the concept of having a less restrictive trigger pattern will be examined.
A State concept is keyed with a ReferenceKey key, which references the Policy concept that owns the state. The LocalName field of the ReferenceKey holds the name of the state. As a state is part of a chain of states, the NextState field of a state holds the ReferenceKey key of the state in the policy to execute after this state.
The Trigger field of a state holds the ArtifactKey of the event that triggers this state. The OutgoingEvents field holds the ArtifactKey references of all possible events that may be output from the state. This is a set that is the union of all output events of all tasks of the state.
The Task concepts that hold the definitions of the task for the state are held as a set of ArtifactKey references in the state. The DefaultTask field holds a reference to the default task for the state, a task that is executed if no task selection logic is specified. If the state has only one task, that task is the default task.
The Logic concept referenced by a state holds the task selection logic for a state. The task selection logic uses the incoming context (parameters of the incoming event) and other context to determine the best task to use to execute its goals. The state holds a set of references to ContextItem and ContextItemTemplate definitions for the context used by its task selection logic.

Writing Logic

Writing APEX Task Logic

Task logic specifies the behavior of an Apex Task. This logic can be specified in a number of ways, exploiting Apex’s plug-in architecture to support a range of logic executors. In Apex scripted Task Logic can be written in any of these languages:
These languages were chosen because the scripts can be compiled into Java bytecode at runtime and then efficiently executed natively in the JVM. Task Logic an also be written directly in Java but needs to be compiled, with the resulting classes added to the classpath. There are also a number of other Task Logic types (e.g. Fuzzy Logic), but these are not supported as yet. This guide will focus on the scripted Task Logic approaches, with MVEL and JavaScript being our favorite languages. In particular this guide will focus on the Apex aspects of the scripts. However, this guide does not attempt to teach you about the scripting languages themselves …​ that is up to you!

Tip

JVM-based scripting languages For more more information on scripting for the Java platform see: https://docs.oracle.com/javase/8/docs/technotes/guides/scripting/prog_guide/index.html

Note

What do Tasks do? The function of an Apex Task is to provide the logic that can be executed for an Apex State as one of the steps in an Apex Policy. Each task receives some incoming fields, executes some logic (e.g: make a decision based on shared state or context, incoming fields, external context, etc.), perhaps set some shared state or context and then emits outgoing fields. The state that uses the task is responsible for extracting the incoming fields from the state input event. The state also has an output mapper associated with the task, and this output mapper is responsible for mapping the outgoing fields from the task into an appropriate output event for the state.

First lets start with a sample task, drawn from the “My First Apex Policy” example: The task “MorningBoozeCheck” from the “My First Apex Policy” example is available in both MVEL and JavaScript:
Javascript code for the MorningBoozeCheck task
 1 /*
 2  * ============LICENSE_START=======================================================
 3  *  Copyright (C) 2016-2018 Ericsson. All rights reserved.
 4  * ================================================================================
 5  * Licensed under the Apache License, Version 2.0 (the "License");
 6  * you may not use this file except in compliance with the License.
 7  * You may obtain a copy of the License at
 8  *
 9  *      http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17  * SPDX-License-Identifier: Apache-2.0
18  * ============LICENSE_END=========================================================
19  */
20 
21 var returnValueType = Java.type("java.lang.Boolean");
22 var returnValue = new returnValueType(true);
23 
24 // Load compatibility script for imports etc
25 load("nashorn:mozilla_compat.js");
26 importPackage(java.text);
27 importClass(java.text.SimpleDateFormat);
28 
29 executor.logger.info("Task Execution: '"+executor.subject.id+"'. Input Fields: '"+executor.inFields+"'");
30 
31 executor.outFields.put("amount"      , executor.inFields.get("amount"));
32 executor.outFields.put("assistant_ID", executor.inFields.get("assistant_ID"));
33 executor.outFields.put("notes"       , executor.inFields.get("notes"));
34 executor.outFields.put("quantity"    , executor.inFields.get("quantity"));
35 executor.outFields.put("branch_ID"   , executor.inFields.get("branch_ID"));
36 executor.outFields.put("item_ID"     , executor.inFields.get("item_ID"));
37 executor.outFields.put("time"        , executor.inFields.get("time"));
38 executor.outFields.put("sale_ID"     , executor.inFields.get("sale_ID"));
39 
40 item_id = executor.inFields.get("item_ID");
41 
42 //All times in this script are in GMT/UTC since the policy and events assume time is in GMT.
43 var timenow_gmt =  new Date(Number(executor.inFields.get("time")));
44 
45 var midnight_gmt = new Date(Number(executor.inFields.get("time")));
46 midnight_gmt.setUTCHours(0,0,0,0);
47 
48 var eleven30_gmt = new Date(Number(executor.inFields.get("time")));
49 eleven30_gmt.setUTCHours(11,30,0,0);
50 
51 var timeformatter = new java.text.SimpleDateFormat("HH:mm:ss z");
52 
53 var itemisalcohol = false;
54 if(item_id != null && item_id >=1000 && item_id < 2000)
55     itemisalcohol = true;
56 
57 if( itemisalcohol
58     && timenow_gmt.getTime() >= midnight_gmt.getTime()
59     && timenow_gmt.getTime() <  eleven30_gmt.getTime()) {
60 
61   executor.outFields.put("authorised", false);
62   executor.outFields.put("message", "Sale not authorised by policy task " +
63     executor.subject.taskName+ " for time " + timeformatter.format(timenow_gmt.getTime()) +
64     ". Alcohol can not be sold between " + timeformatter.format(midnight_gmt.getTime()) +
65     " and " + timeformatter.format(eleven30_gmt.getTime()));
66 }
67 else{
68   executor.outFields.put("authorised", true);
69   executor.outFields.put("message", "Sale authorised by policy task " +
70     executor.subject.taskName + " for time "+timeformatter.format(timenow_gmt.getTime()));
71 }
72 
73 /*
74 This task checks if a sale request is for an item that is an alcoholic drink.
75 If the local time is between 00:00:00 GMT and 11:30:00 GMT then the sale is not
76 authorised. Otherwise the sale is authorised.
77 In this implementation we assume that items with item_ID value between 1000 and
78 2000 are all alcoholic drinks :-)
79 */
MVEL code for the MorningBoozeCheck task
 1 /*
 2  * ============LICENSE_START=======================================================
 3  *  Copyright (C) 2016-2018 Ericsson. All rights reserved.
 4  * ================================================================================
 5  * Licensed under the Apache License, Version 2.0 (the "License");
 6  * you may not use this file except in compliance with the License.
 7  * You may obtain a copy of the License at
 8  *
 9  *      http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17  * SPDX-License-Identifier: Apache-2.0
18  * ============LICENSE_END=========================================================
19  */
20 import java.util.Date;
21 import java.util.Calendar;
22 import java.util.TimeZone;
23 import java.text.SimpleDateFormat;
24 
25 logger.info("Task Execution: '"+subject.id+"'. Input Fields: '"+inFields+"'");
26 
27 outFields.put("amount"      , inFields.get("amount"));
28 outFields.put("assistant_ID", inFields.get("assistant_ID"));
29 outFields.put("notes"       , inFields.get("notes"));
30 outFields.put("quantity"    , inFields.get("quantity"));
31 outFields.put("branch_ID"   , inFields.get("branch_ID"));
32 outFields.put("item_ID"     , inFields.get("item_ID"));
33 outFields.put("time"        , inFields.get("time"));
34 outFields.put("sale_ID"     , inFields.get("sale_ID"));
35 
36 item_id = inFields.get("item_ID");
37 
38 //The events used later to test this task use GMT timezone!
39 gmt = TimeZone.getTimeZone("GMT");
40 timenow = Calendar.getInstance(gmt);
41 df = new SimpleDateFormat("HH:mm:ss z");
42 df.setTimeZone(gmt);
43 timenow.setTimeInMillis(inFields.get("time"));
44 
45 midnight = timenow.clone();
46 midnight.set(
47     timenow.get(Calendar.YEAR),timenow.get(Calendar.MONTH),
48     timenow.get(Calendar.DATE),0,0,0);
49 eleven30 = timenow.clone();
50 eleven30.set(
51     timenow.get(Calendar.YEAR),timenow.get(Calendar.MONTH),
52     timenow.get(Calendar.DATE),11,30,0);
53 
54 itemisalcohol = false;
55 if(item_id != null && item_id >=1000 && item_id < 2000)
56     itemisalcohol = true;
57 
58 if( itemisalcohol
59     && timenow.after(midnight) && timenow.before(eleven30)){
60   outFields.put("authorised", false);
61   outFields.put("message", "Sale not authorised by policy task "+subject.taskName+
62     " for time "+df.format(timenow.getTime())+
63     ". Alcohol can not be sold between "+df.format(midnight.getTime())+
64     " and "+df.format(eleven30.getTime()));
65   return true;
66 }
67 else{
68   outFields.put("authorised", true);
69   outFields.put("message", "Sale authorised by policy task "+subject.taskName+
70     " for time "+df.format(timenow.getTime()));
71   return true;
72 }
73 
74 /*
75 This task checks if a sale request is for an item that is an alcoholic drink.
76 If the local time is between 00:00:00 GMT and 11:30:00 GMT then the sale is not
77 authorised. Otherwise the sale is authorised.
78 In this implementation we assume that items with item_ID value between 1000 and
79 2000 are all alcoholic drinks :-)
80 */
The role of the task in this simple example is to copy the values in the incoming fields into the outgoing fields, then examine the values in some incoming fields (item_id and time), then set the values in some other outgoing fields (authorised and message).
Both MVEL and JavaScript like most JVM-based scripting languages can use standard Java libraries to perform complex tasks. Towards the top of the scripts you will see how to import Java classes and packages to be used directly in the logic. Another thing to notice is that Task Logic should return a java.lang.Boolean value true if the logic executed correctly. If the logic fails for some reason then false can be returned, but this will cause the policy invoking this task will fail and exit.

Note

How to return a value from task logic Some languages explicitly support returning values from the script (e.g. MVEL and JRuby) using an explicit return statement (e.g. return true), other languages do not (e.g. JavaScript and Jython). For languages that do not support the return statement, a special field called returnValue must be created to hold the result of the task logic operation (i.e. assign a java.lang.Boolean value to the returnValue field before completing the task). Also, in MVEL if there is no explicit return statement then the return value of the last executed statement will return (e.g. the statement a=(1+2) will return the value 3).

Besides these imported classes and normal language features Apex provides some natively available parameters and functions that can be used directly. At run-time these parameters are populated by the Apex execution environment and made natively available to logic scripts each time the logic script is invoked. (These can be accessed using the executor keyword for most languages, or can be accessed directly without the executor keyword in MVEL):

Table 1. The executor Fields / Methods

Name Type Java type Description
inFields Fields java.util.Map <String,Object>
The incoming task fields. This is implemented as a standard Java Java (unmodifiable) Map
Example:
executor.logger.debug("Incoming fields: "
   +executor.inFields.entrySet());
var item_id = executor.incomingFields["item_ID"];
if (item_id >=1000) { ... }
outFields Fields java.util.Map <String,Object>
The outgoing task fields. This is implemented as a standard initially empty Java (modifiable) Map. To create a new schema-compliant instance of a field object see the utility method subject.getOutFieldSchemaHelper() below
Example:
executor.outFields["authorised"] = false;
logger Logger org.slf4j.ext.XLogger
A helpful logger
Example:
executor.logger.info("Executing task: "
   +executor.subject.id);
TRUE/FALSE boolean java.lang.Boolean
2 helpful constants. These are useful to retrieve correct return values for the task logic
Example:
var returnValue = executor.isTrue;
var returnValueType = Java.type("java.lang.Boolean");
var returnValue = new returnValueType(true);
subject Task TaskFacade
This provides some useful information about the task that contains this task logic. This object has some useful fields and methods :
  • AxTask task to get access to the full task definition of the host task
  • String getTaskName() to get the name of the host task
  • String getId() to get the ID of the host task
  • SchemaHelper getInFieldSchemaHelper( String fieldName ) to get a SchemaHelper helper object to manipulate incoming task fields in a schema-aware manner
  • SchemaHelper getOutFieldSchemaHelper( String fieldName ) to get a SchemaHelper helper object to manipulate outgoing task fields in a schema-aware manner, e.g. to instantiate new schema-compliant field objects to populate the executor.outFields outgoing fields map
Example:
executor.logger.info("Task name: "
   +executor.subject.getTaskName());
executor.logger.info("Task id: "
   +executor.subject.getId());
executor.logger.info("Task inputs definitions: "
   +"executor.subject.task.getInputFieldSet());
executor.logger.info("Task outputs definitions: "
   +"executor.subject.task.getOutputFieldSet());
executor.outFields["authorised"] = executor.subject
      .getOutFieldSchemaHelper("authorised")
     .createNewInstance("false");
ContextAlbum getContextAlbum(String ctxtAlbumName )
A utility method to retrieve a ContextAlbum for use in the task. This is how you access the context used by the task. The returned ContextAlbum implements the java.util.Map <String,Object> interface to get and set context as appropriate. The returned ContextAlbum also has methods to lock context albums, get information about the schema of the items to be stored in a context album, and get a SchemaHelper to manipulate context album items. How to define and use context in a task is described in the Apex Programmer’s Guide and in the My First Apex Policy guide.
Example:
var bkey = executor.inFields.get("branch_ID");
var cnts = executor.getContextMap("BranchCounts");
cnts.lockForWriting(bkey);
cnts.put(bkey, cnts.get(bkey) + 1);
cnts.unlockForWriting(bkey);

Writing APEX Task Selection Logic

The function of Task Selection Logic is to choose which task should be executed for an Apex State as one of the steps in an Apex Policy. Since each state must define a default task there is no need for Task Selection Logic unless the state uses more than one task. This logic can be specified in a number of ways, exploiting Apex’s plug-in architecture to support a range of logic executors. In Apex scripted Task Selection Logic can be written in any of these languages:
These languages were chosen because the scripts can be compiled into Java bytecode at runtime and then efficiently executed natively in the JVM. Task Selection Logic an also be written directly in Java but needs to be compiled, with the resulting classes added to the classpath. There are also a number of other Task Selection Logic types but these are not supported as yet. This guide will focus on the scripted Task Selection Logic approaches, with MVEL and JavaScript being our favorite languages. In particular this guide will focus on the Apex aspects of the scripts. However, this guide does not attempt to teach you about the scripting languages themselves …​ that is up to you!

Tip

JVM-based scripting languages
For more more information on Scripting for the Java platform see: https://docs.oracle.com/javase/8/docs/technotes/guides/scripting/prog_guide/index.html

Note

What does Task Selection Logic do?
When an Apex state references multiple tasks, there must be a way to dynamically decide which task should be chosen and executed. This can depend on the many factors, e.g. the incoming event for the state, shared state or context, external context, etc.. This is the function of a state’s Task Selection Logic. Obviously, if there is only one task then Task only one task then Task Selection Logic is not needed. Each state must also select one of the tasks a the default state. If the Task Selection Logic is unable to select an appropriate task, then it should select the default task. Once the task has been selected the Apex Engine will then execute that task.
First lets start with some simple Task Selection Logic, drawn from the “My First Apex Policy” example: The Task Selection Logic from the “My First Apex Policy” example is specified in JavaScript here:
Javascript code for the “My First Policy” Task Selection Logic
/*
 * ============LICENSE_START=======================================================
 *  Copyright (C) 2016-2018 Ericsson. All rights reserved.
 * ================================================================================
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 * ============LICENSE_END=========================================================
 */


var returnValueType = Java.type("java.lang.Boolean");
var returnValue = new returnValueType(true);

executor.logger.info("Task Selection Execution: '"+executor.subject.id+
    "'. Input Event: '"+executor.inFields+"'");

branchid = executor.inFields.get("branch_ID");
taskorig = executor.subject.getTaskKey("MorningBoozeCheck");
taskalt = executor.subject.getTaskKey("MorningBoozeCheckAlt1");
taskdef = executor.subject.getDefaultTaskKey();

if(branchid >=0 && branchid <1000){
  taskorig.copyTo(executor.selectedTask);
}
else if (branchid >=1000 && branchid <2000){
  taskalt.copyTo(executor.selectedTask);
}
else{
  taskdef.copyTo(executor.selectedTask);
}

/*
This task selection logic selects task "MorningBoozeCheck" for branches with
0<=branch_ID<1000 and selects task "MorningBoozeCheckAlt1" for branches with
1000<=branch_ID<2000. Otherwise the default task is selected.
In this case the default task is also "MorningBoozeCheck"
*/
The role of the Task Selection Logic in this simple example is to examine the value in one incoming field (branchid), then depending on that field’s value set the value for the selected task to the appropriate task (MorningBoozeCheck, MorningBoozeCheckAlt1, or the default task).
Another thing to notice is that Task Selection Logic should return a java.lang.Boolean value true if the logic executed correctly. If the logic fails for some reason then false can be returned, but this will cause the policy invoking this task will fail and exit.

Note

How to return a value from Task Selection Logic
Some languages explicitly support returning values from the script (e.g. MVEL and JRuby) using an explicit return statement (e.g. return true), other languages do not (e.g. JavaScript and Jython). For languages that do not support the return statement, a special field called returnValue must be created to hold the result of the task logic operation (i.e. assign a java.lang.Boolean value to the returnValue field before completing the task). Also, in MVEL if there is not explicit return statement then the return value of the last executed statement will return (e.g. the statement a=(1+2) will return the value 3).
Each of the scripting languages used in Apex can import and use standard Java libraries to perform complex tasks. Besides imported classes and normal language features Apex provides some natively available parameters and functions that can be used directly. At run-time these parameters are populated by the Apex execution environment and made natively available to logic scripts each time the logic script is invoked. (These can be accessed using the executor keyword for most languages, or can be accessed directly without the executor keyword in MVEL):
Table 2. The executor Fields / Methods
Unix, Cygwin Windows
1 >c:
2 >cd \dev\apex
3 >mvn clean install -DskipTests
1 # cd /usr/local/src/apex-pdp
2 # mvn clean install -DskipTest
Name Type Java type Description
inFields Fields java.util.Map <String,Object>
All fields in the state’s incoming event. This is implemented as a standard Java Java (unmodifiable) Map
Example:
executor.logger.debug("Incoming fields: "
   +executor.inFields.entrySet());
var item_id = executor.incomingFields["item_ID"];
if (item_id >=1000) { ... }
outFields Fields java.util.Map <String,Object>
The outgoing task fields. This is implemented as a standard initially empty Java (modifiable) Map. To create a new schema-compliant instance of a field object see the utility method subject.getOutFieldSchemaHelper() below
Example:
executor.outFields["authorised"] = false;
logger Logger org.slf4j.ext.XLogger
A helpful logger
Example:
executor.logger.info("Executing task: "
   +executor.subject.id);
TRUE/FALSE boolean java.lang.Boolean
2 helpful constants. These are useful to retrieve correct return values for the task logic
Example:
var returnValue = executor.isTrue;
var returnValueType = Java.type("java.lang.Boolean");
var returnValue = new returnValueType(true);
subject Task TaskFacade
This provides some useful information about the task that contains this task logic. This object has some useful fields and methods :
  • AxTask task to get access to the full task definition of the host task
  • String getTaskName() to get the name of the host task
  • String getId() to get the ID of the host task
  • SchemaHelper getInFieldSchemaHelper( String fieldName ) to get a SchemaHelper helper object to manipulate incoming task fields in a schema-aware manner
  • SchemaHelper getOutFieldSchemaHelper( String fieldName ) to get a SchemaHelper helper object to manipulate outgoing task fields in a schema-aware manner, e.g. to instantiate new schema-compliant field objects to populate the executor.outFields outgoing fields map
Example:
executor.logger.info("Task name: "
   +executor.subject.getTaskName());
executor.logger.info("Task id: "
   +executor.subject.getId());
executor.logger.info("Task inputs definitions: "
   +"executor.subject.task.getInputFieldSet());
executor.logger.info("Task outputs definitions: "
   +"executor.subject.task.getOutputFieldSet());
executor.outFields["authorised"] = executor.subject
      .getOutFieldSchemaHelper("authorised")
     .createNewInstance("false");
ContextAlbum getContextAlbum(String ctxtAlbumName )
A utility method to retrieve a ContextAlbum for use in the task. This is how you access the context used by the task. The returned ContextAlbum implements the java.util.Map <String,Object> interface to get and set context as appropriate. The returned ContextAlbum also has methods to lock context albums, get information about the schema of the items to be stored in a context album, and get a SchemaHelper to manipulate context album items. How to define and use context in a task is described in the Apex Programmer’s Guide and in the My First Apex Policy guide.
Example:
var bkey = executor.inFields.get("branch_ID");
var cnts = executor.getContextMap("BranchCounts");
cnts.lockForWriting(bkey);
cnts.put(bkey, cnts.get(bkey) + 1);
cnts.unlockForWriting(bkey);

Logic Cheatsheet

Examples given here use Javascript (if not stated otherwise), other execution environments will be similar.

Add Nashorn

First line in the logic use this import.
JS Nashorn
load("nashorn:mozilla_compat.js");

Finish Logic with Success or Error

To finish logic, i.e. return to APEX, with success use the following lines close to the end of the logic.
JS Success
var returnValueType = Java.type("java.lang.Boolean");
var returnValue = new returnValueType(true);
To notify a problem, finish with an error.
JS Fail
var returnValueType = Java.type("java.lang.Boolean");
var returnValue = new returnValueType(false);

Logic Logging

Logging can be made easy using a local variable for the logger. Line 1 below does that. Then we start with a trace log with the task (or task logic) identifier followed by the infields.
JS Logging
var logger = executor.logger;
logger.trace("start: " + executor.subject.id);
logger.trace("-- infields: " + executor.inFields);
For larger logging blocks you can use the standard logging API to detect log levels, for instance:
JS Logging Blocks
if(logger.isTraceEnabled()){
    // trace logging block here
}
Note: the shown logger here logs to org.onap.policy.apex.executionlogging. The behavior of the actual logging can be specified in the $APEX_HOME/etc/logback.xml.
If you want to log into the APEX root logger (which is sometimes necessary to report serious logic errors to the top), then import the required class and use this logger.
JS Root Logger
importClass(org.slf4j.LoggerFactory);
var rootLogger = LoggerFactory.getLogger(logger.ROOT_LOGGER_NAME);

rootLogger.error("Serious error in logic detected: " + executor.subject.id);

Local Variable for Infields

It is a good idea to use local variables for infields. This avoids long code lines and policy evolution. The following example assumes infields named nodeName and nodeAlias.
JS Infields Local Var
var ifNodeName = executor.inFields["nodeName"];
var ifNodeAlias = executor.inFields["nodeAlias"];

Local Variable for Context Albums

Similar to the infields it is good practice to use local variables for context albums as well. The following example assumes that a task can access a context album albumTopoNodes. The second line gets a particular node from this context album.
JS Infields Local Var
var albumTopoNodes = executor.getContextAlbum("albumTopoNodes");
var ctxtNode = albumTopoNodes.get(ifNodeName);

Set Outfields in Logic

The task logic needs to set outfields with content generated. The exception are outfields that are a direct copy from an infield of the same name, APEX does that autmatically.
JS Set Outfields
executor.outFields["report"] = "node ctxt :: added node " + ifNodeName;

Create a instance of an Outfield using Schemas

If an outfield is not an atomic type (string, integer, etc.) but uses a complex schema (with a Java or Avro backend), APEX can help to create new instances. The executor provides a field called subject, which provides a schem helper with an API for this. The complete API of the schema helper is documented here: API Doc: SchemaHelper.
If the backend is Avro, then an import of the Avro schema library is required:
JS Import Avro
importClass(org.apache.avro.generic.GenericData.Array);
importClass(org.apache.avro.generic.GenericRecord);
importClass(org.apache.avro.Schema);
If the backend is Java, then the Java class implementing the schema needs to be imported.
The following example assumes an outfield situation. The subject method getOutFieldSchemaHelper() is used to create a new instance.
JS Outfield Instance with Schema
var situation = executor.subject.getOutFieldSchemaHelper("situation").createNewInstance();
If the schema backend is Java, the new instance will be as implemented in the Java class. If the schema backend is Avro, the new instance will have all fields from the Avro schema specification, but set to null. So any entry here needs to be done separately. For instance, the situation schema has a field problemID which we set.
JS Outfield Instance with Schema, set
situation.put("problemID", "my-problem");

Create a instance of an Context Album entry using Schemas

Context album instances can be created using very similar to the outfields. Here, the schema helper comes from the context album directly. The API of the schema helper is the same as for outfields, see API Doc: SchemaHelper.
If the backend is Avro, then an import of the Avro schema library is required:
JS Import Avro
importClass(org.apache.avro.generic.GenericData.Array);
importClass(org.apache.avro.generic.GenericRecord);
importClass(org.apache.avro.Schema);
If the backend is Java, then the Java class implementing the schema needs to be imported.
The following example creates a new instance of a context album instance named albumProblemMap.
JS Outfield Instance with Schema
var albumProblemMap = executor.getContextAlbum("albumProblemMap");
var linkProblem = albumProblemMap.getSchemaHelper().createNewInstance();
This can of course be also done in a single call without the local variable for the context album.
JS Outfield Instance with Schema, one line
var linkProblem = executor.getContextAlbum("albumProblemMap").getSchemaHelper().createNewInstance();
If the schema backend is Java, the new instance will be as implemented in the Java class. If the schema backend is Avro, the new instance will have all fields from the Avro schema specification, but set to null. So any entry here needs to be done separately (see above in outfields for an example).

Enumerates

When dealing with enumerates (Avro or Java defined), it is sometimes and in some execution environments necessary to convert them to a string. For example, assume an Avro enumerate schema as:
Avro Enumerate Schema
{
  "type": "enum",
  "name": "Status",
  "symbols" : [
    "UP",
    "DOWN"
  ]
}
Using a switch over a field initialized with this enumerate in Javascript will fail. Instead, use the toString method, for example:
JS Outfield Instance with Schema, one line
var switchTest = executor.inFields["status"];
switch(switchTest.toString()){
  case "UP": ...; break;
  case "DOWN": ...; break;
  default: ...;
}

MVEL Initialize Outfields First!

In MVEL, we observed a problem when accessing (setting) outfields without a prior access to them. So in any MVEL task logic, before setting any outfield, simply do a get (with any string), to load the outfields into the MVEL cache.
MVEL Outfield Initialization
outFields.get("initialize outfields");

Using Java in Scripting Logic

Since APEX executes the logic inside a JVM, most scripting languages provide access to all standard Java classes. Simply add an import for the required class and then use it as in actual Java.
The following example imports java.util.arraylist into a Javascript logic, and then creates a new list.
JS Import ArrayList
importClass(java.util.ArrayList);
var myList = new ArrayList();

Policy Examples

My First Policy

A good starting point is the My First Policy example. It describes a sales problem, to which policy can be applied. The example details the policy background, shows how to use the REST Editor to create a policy, and provides details for running the policies. The documentation can be found:

VPN SLA

The domain Policy-controlled Video Streaming (PCVS) contains a policy for controlling video streams with different strategies. It also provides details for installing an actual testbed with off-the-shelve software (Mininet, Floodlight, Kafka, Zookeeper). The policy model here demonstrates virtually all APEX features: local context and policies controlling it, task selection logic and multiple tasks in a single state, AVRO schemas for context, AVOR schemas for events (trigger and local), and a CLI editor specification of the policy. The documentation can be found:

Decision Maker

The domain Decision Maker shows a very simple policy for decisions. Interesting here is that the it creates a Docker image to run the policy and that it uses the APEX REST applications to update the policy on the-fly. It also has local context to remember past decisions, and shows how to use that to no make the same decision twice in a row. The documentation can be found: