Lolo Concepts

This page will help you get started with Lolo

Welcome to Lolo!

Lolo means lo(w) lo(w) code as our aim is to make every data stream, API and network programmable with an awesome developer, deployment and operations experience.

Lolo is an Integration Function as a Service (iFaaS) platform that allows you to build cloud agnostic serverless applications and reusable functions with one-click multi-cloud deploy. And deploy Programmable Virtual Private Cloud (VPC) that can create networks which span cloud providers, data centers, on premise infrastructure, devices (laptop/computers/servers) and IoT devices.

Lolo's iFaaS integrated development environment (IDE) consists of Applications, Functions and Runtimes. An Application consists of Functions which are then deployed onto a Runtime.

Applications

Lolo Applications are a directed graph of functions which are triggered by an event. An event may be a timer, HTTP call or similar. All of the functions in a Lolo Application have access to a shared state which can be used through the entire application in order to keep functions small, focused, performant and maintainable.

Applications (and Functions) may use Node.js packaged from npmjs.com. Applications may be manually and auto-documented through the Application Settings tab in the IDE.

More information about Applications can be found in the Applications and Functions pages.

Functions

Function in Lolo either inline code written in an Application or Library Functions. Lolo supports (and encourages) the notion of function composition whereby a number of Functions are composed together into a single function referred to as a Composite Function.

Library Functions are made by exporting an inline code Functions or Composite Function to the Function Library. Once exported, a JSON Schema should be created for the Library Function such that it can be more easily reused and visualized within the IDE. Moreover, when a schema is applied to a Library Function, it can be used by No Code Visual Builder style applications for uses cases such as building Conversational / Chatbot Platforms, Automation Platforms or Integration Platform as a Service (iPaaS).

Each Function may have any number of input and output ports and control of the ports is done through the context variables within the function event handlers.

More information about Functions can be found in the Applications and Functions pages, but an example the function event handlers is as follows:

// Example of using the shared state to count events
exports.handler = async(ev, ctx) => {
  // ev - JSON event
  // ctx - context which contains:
  //     route in order to determine the output port;
  //     shared state and;
  //     log,
  const { route, state, log } = ctx;

  let count = state.get('count') || 0;
  count++;
  state.set('count', count);

  route(ev);
};

The corresponding Function edge inside the Lolo IDE looks like:

Deploying Applications

Lolo applications are deployed onto a Kubernetes runtime in your preferred cloud provider such as Amazon Web Service, Google Cloud Platform and Microsoft Azure. Applications deployed via one-click from the Lolo IDE (or programmability via the Lolo API).

As Applications are running in your cloud provider, logs and telemetry information are transmitted back to the Lolo platform and accessible via the Lolo IDE.

Configuring Runtimes

A Runtime is a Supported Kubernetes cluster as set out in the Runtimes documentation.