Skip to content
This page View Markdown Open in ChatGPT Open in Claude

Process initializers

A process initializer is your code that runs when a runner of your sandbox starts, before that runner serves any request. A runner is one process of a sandbox. Use it for what every process needs : a subscription to a message broker, a client kept for the life of the process, a warm cache.

In short

  • It runs once in every runner : a sandbox has up to one runner per processor core.
  • The active initializers run one after the other, in their order.
  • Keep it light and safe to run twice.
Page APIs & Logic → Initializers : name, order, timeout in minutes, active, and the code.
Runs In every runner of a sandbox, when it starts. The active initializers run one after the other, in their order.
Code The function main of any language, with the same g as a custom API.
Test Test API runs it on the API testing page.
Keep the rates in the memory of the process
1
2
3
4
5
6
7
8
9
import * as T from 'types';

async function main(g: T.IAMGlobal) {
    // Read once per process : every request this process serves finds them in g.shared.
    const rates = await g.sys.db.getAll({ instance: 'mysql_8', database: 'shop', collection: 'rates' });
    g.shared.rates = rates;
    g.logger.log(`${rates.length} rates loaded`);
}
module.exports = main;
Keep the rates in the memory of the process
1
2
3
4
5
6
7
8
from am import G


async def main(g: G):
    # Read once per process : every request this process serves finds them in g.shared.
    rates = await g.sys.db.get_all('mysql_8', 'shop', 'rates')
    g.shared['rates'] = rates
    g.logger.log(len(rates), 'rates loaded')
Keep the rates in the memory of the process
1
2
3
4
5
6
7
8
9
<?php
function main(AmG $g)
{
    // Read once per process : every request this process serves finds them in $g->shared.
    $rates = $g->sys->db->getAll('mysql_8', 'shop', 'rates');
    $g->shared->rates = $rates;
    $g->logger->log(count($rates), 'rates loaded');
    return null;
}
Keep the rates in the memory of the process
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
file static class Api
{
    public static async Task<object?> Main(G g)
    {
        // Read once per process : every request this process serves finds them in g.Shared.
        var rates = await g.Sys.Db.GetAll(new GetAll("mysql_8", "shop", "rates"));
        g.Shared["rates"] = rates;
        g.Logger.Log(rates.Count, "rates loaded");
        return null;
    }
}
Keep the rates in the memory of the process
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
package code

import "apimaker/am"

func Main(g *am.G) (any, error) {
    // Read once per process : every request this process serves finds them in g.Shared.
    rates, err := g.Sys.Db.GetAll(am.GetAll{Instance: "mysql_8", Database: "shop", Collection: "rates"})
    if err != nil {
        return nil, err
    }
    g.Shared.Set("rates", rates)
    g.Logger.Log(len(rates), "rates loaded")
    return nil, nil
}
Keep the rates in the memory of the process
1
2
3
4
5
6
7
8
9
use am::{Errors, G, GetAll, Value, json};

pub fn main(g: &mut G) -> Result<Value, Errors> {
    // Read once per process : every request this process serves finds them in g.shared.
    let rates = g.sys.db.get_all(GetAll::new("mysql_8", "shop", "rates"))?;
    g.logger.log(format!("{} rates loaded", rates.len()));
    g.shared.set("rates", json!(rates));
    Ok(Value::Null)
}
Keep the rates in the memory of the process
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
import am.G;
import am.GetAll;
import am.JsonObject;
import java.util.List;

class Api {
    static Object main(G g) {
        // Read once per process : every request this process serves finds them in g.shared.
        List<JsonObject> rates = g.sys.db.getAll(new GetAll("mysql_8", "shop", "rates"));
        g.shared.put("rates", rates);
        g.logger.log(rates.size(), "rates loaded");
        return null;
    }
}
Keep the rates in the memory of the process
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import am.G
import am.GetAll

fun main(g: G): Any? {
    // Read once per process : every request this process serves finds them in g.shared.
    val rates = g.sys.db.getAll(GetAll("mysql_8", "shop", "rates"))
    g.shared["rates"] = rates
    g.logger.log(rates.size, "rates loaded")
    return null
}
  • An initializer is also where what lives as long as the process starts : the client of a message queue which listens to a topic (MQTT, Kafka, RabbitMQ…), with the package of its language added on the Sandbox Settings page.
  • Other code runs on an action : an HTTP call, a schedule, an event. An initializer runs on its own, once per process, so keep it light and idempotent.
  • How many sandboxes run is set on the Sandbox Settings page. Each runner of each of them runs the initializers.
  • Timeout in minutes is how long each process waits for the initializer, every time it runs it (empty : sandboxReqTimeout of the configuration, 13 seconds). A process whose initializer did not end in time goes on to the next one, and then serves your code : keep what lasts as long as the process (a listener, a subscription) out of the promise the initializer returns.