Custom Actions¶

Custom Action Data Messages¶

You can use Custom Actions to enable communication between two Applications on either the same cluster or across different clusters.

As a consumer of Custom Action Messages, this Application is defined as Consumer (Executor) Application.

To ensure the Custom Action Messages are handled properly, the app.yaml inputs needs to be declared:

1
2
3

custom_actions:
  inputs:
    - type: custom-action-name

The Custom Action Object in the main.py script supports the following attributes :

The Custom Action Result Object supports the following attributes :

Custom Action UI Schemas¶

You can define a UI schema for each Custom Action type your Application consumes. This creates an input form in the Kelvin UI's Applications section where users can configure global settings for the executor -- settings that apply across all invocations of that action type.

Declare the schemas in the ui_schemas.custom_actions section of your app.yaml, keyed by action type name:

1
2
3
4
5
6
7

custom_actions:
  inputs:
    - type: send-email

ui_schemas:
  custom_actions:
    send-email: "ui_schemas/send_email.json"

Each file is a JSON Schema that defines the configuration fields presented to users in the Kelvin UI for the executor application:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

{
    "$schema": "http://json-schema.org/draft-07/schema#",
    "title": "Email Executor Settings",
    "description": "Global configuration for the email executor application.",
    "type": "object",
    "properties": {
        "smtp_host": {
            "type": "string",
            "title": "SMTP Host",
            "description": "Address of the SMTP server."
        },
        "smtp_port": {
            "type": "integer",
            "title": "SMTP Port",
            "description": "Port of the SMTP server.",
            "default": 587
        },
        "username": {
            "type": "string",
            "title": "Username",
            "description": "SMTP authentication username."
        }
    },
    "required": ["smtp_host", "smtp_port", "username"],
    "additionalProperties": false
}

Consumer App Example¶

In this example we will create a Consumer (Executor) Application that will;

1. Listen and receive any new Custom Action objects with the type email.
2. Extract the relevant email information from the payload
3. Connect to an SMTP and send the email (This function is defined but not fully coded)
4. Return the status of the Custom Action (True or False)

Check out the Produce Custom Actions documentation here to see how to send this Custom Action from the Publisher Application.

app.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

spec_version: 5.0.0
type: app            # Any app type can handle and/or publish custom actions.

name: hello-app
title: Hello App
description: Lorem ipsum dolor sit amet, consectetur adipiscing elit
version: 1.0.0

custom_actions:
  inputs:
    - type: email

  ...

Consumer (Executor) Application

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

from kelvin.application import KelvinApp
from kelvin.message import CustomAction, CustomActionResult

app = KelvinApp()

async def send_mail(recipient, subject, body):
    print(f"Sending email to {recipient}")

async def on_custom_action(action: CustomAction):
    if action.type == "email":
        try:
            await send_mail(
                action.payload.get("recipient"),
                action.payload.get("subject"),
                action.payload.get("body")
            )

            await app.publish(CustomActionResult(
                success=True,
                action_id=action._msg.id,
                resource=action.resource,
                metadata={}
            ))

        except Exception as e:
            await app.publish(action.result(success=False, message=str(e)))

app.on_custom_action = on_custom_action

app.run()