Skip to content

Home

Quick start guide

Martini Online subscription

Martini Desktop installation

User interface

examples package

Alias for serializing

APIs

Asynchronous Gloop steps

Caching

Database cursors

Database transactions

Data transformation

Date manipulation

Endpoints

Flat file descriptor

Flux services

Gloop annotations

Gloop steps

HTTP client

Invoking Gloop

JSP response

JSON cursors

Report Builder

Set expressions

Solr

SQL services

Streams

Throttling and monetization

Velocity

Virtual file systems

WebSockets

XML cursors

Tutorial

Creating a package

Writing a service

Invoking a service over HTTP

Creating an endpoint

Publishing an API

Documenting an API

Securing an API

Viewing transactions

Creating a report

Setup and administration

Editions

Installation and deployment

Flexible deployment models

Cloud Edition

Desktop Edition

Server Edition

Prerequisites

JDK 8

Installation

Docker setup

Docker image

Standard container procedures

Swarm mode procedures

Firewall

Proxying to a domain

Startup and shutdown

Directory structure

Instance management

Licenses

Generating

Installation

Updating

Configuration scenarios

Simple

Three tier network architecture

Simple

High availability

Development

Production

Clustered

Headless environment

Configuration

CLI tool

ESB API

Application properties

Performance tuning

JVM

Tomcat

ActiveMQ

ActiveMQ Artemis

RabbitMQ

Solr

Web services

Application data

Broker

ActiveMQ

Transport connectors

Remote

General configuration

Authentication and authorization

Master-slave setup

ActiveMQ Artemis

RabbitMQ

Sending a JMS message

Database

Perspective

Connection pools

Adding

Removing

Status

Core

Migrating

Relational/SQL

Properties

Installing drivers

XA transactions

AWS RDS

New RDS

Existing RDS

Cassandra

MongoDB

Creating databases and collections

Connecting to MongoDB Atlas

Redis

Queries

SQL

Cassandra

MongoDB

Types

Solr

Remote

Cloud

Configuring ZooKeeper

Configuring SolrCloud

Configuring Martini

Using Redis with API throttling

Security

HTTP & HTTPS

NGINX & TLS

Monitoring

Application logs

Threads

User sessions

HTTP requests

Broker destinations

Service manager

Development

IDEs

Martini packages

Metadata

Lifecycle

Directory structure

Core

Spring context

Deployment descriptor

Properties

Web pages

Creating

Importing

Exporting

Remote deployment

Deleting

Gloop

Services

Inputs and outputs

Creating

Importing

Generating

Steps

Map

Fork

Iterate

While

Block

Break

Gloovy

Concurrent

Random

Invoke

Editor

Step editor

Input/Output view

Mapper view

Properties view

Shortcuts

Validation

Refactoring

Running

Debugging

Documenting

Design guidelines

Models

Core

Creating

Model editor

Object types

Cursors

Model references

Object converters

Flat file descriptors

SQL

Cassandra

MongoDB

API

Consuming

Ad hoc

REST

Creating

Editor

Source

General

Documentation

Operations

Tags

Security

Preview

Validation

SOAP

Creating

Editor

HTTP data mapping

Request data

Response data

Gloop templates

Creating

Generating

Importing

Steps

Tag

Invoke template

Editor

Adding step

Editing step

Exposing

Running

Debugging

Resources

Groovy

Inputs and outputs

Creating

Editor

Running

Invoking Gloop or Flux

Groovydoc

Gloop annotations

Customizing compilation

Custom one-liners

HTTP endpoints

Flux

Anatomy

Creating

Building

Adding state

Adding transition

Setting state action

Setting inputs

Passing data between states

Making decisions

Delaying transitions

Looping back

Handling exceptions

Reserved variables

Waiting

Triggering

Monitoring

Running

Debugging

Documenting

API

One-liners

ArrayMethods

BooleanMethods

CacheMethods

CoreMethods

CsvMethods

DatabaseConnectionPoolMethods

EmailMethods

FileMethods

FlatFileMethods

FluxMethods

GloopMethods

GroovyMethods

HttpClientMethods

HttpMethods

JabberMethods

JmsMethods

JsonMethods

KafkaClientsMethods

LoggerMethods

MarshallerMethods

MartiniMethods

MongoDbMethods

MonitorMethods

NumberMethods

ProxyRequestMethods

RemoteDeploymentMethods

RestMethods

RssMethods

SolrMethods

SqlMethods

StreamMethods

StringMethods

ThrottlingMethods

TrackerMethods

UrlMethods

UserGroupMethods

UtilMethods

VelocityMethods

VfsMethods

WebSocketMethods

WidgetPageMethods

XmlMethods

Martini endpoints

Types

Directory watcher

Email

FTP client

FTP server

Jabber

JMS listener

Kafka listener

MongoDB listener

RSS

Scheduler

Tracker resubmit

URL alias

Creating

Properties

Status

Exporting

Importing

Deleting

Machine learning

HTTP client

Creating requests

Configuring requests

Generating requests

Sending requests

Saving and grouping requests

Sharing requests

Cookie manager

API Explorer

Security and authentication

Users and groups

Managing

Authentication schemes

Basic

OAuth2

Securing Gloop services

Securing Gloop APIs

Securing Groovy APIs

Securing Flux services

API monitoring

Monitor rule

Invoke document

Logging invokes

Searching invokes

Monetization

Search API

API throttling

Throttling rule

Tracker

Document structure

Indexing documents

Adding GeoIP data

Searching documents

Rebuilding the index

Security and privacy

Search API

Custom search index

Creating a core

Indexing documents

Updating documents

Deleting documents

Searching documents

Search API

Report Builder

Creating reports

Rows and containers

Charts

From array

From JSON

From Tracker data

From Monitor data

From RESTful response

With CSS

Importing reports

Exporting Reports

Previewing reports

Deleting reports

Releases

Release notes

Martini Runtime

v1.0.0

v1.0.1

v1.0.2

Martini Desktop

v1.0.0

v1.0.1

Martini Online

v1.0.0

v1.0.1

v1.1.0

Feature requests

Bug reports

Appendix

Library dependencies

Martini Runtime

v1.0.0

Martini Online

v1.0.0

Vulnerabilities

Naming conventions

GUI

Text search

Service picker

Service invoker

Help

Shortcuts

Martini Desktop

Martini Online

Public IPs

Benchmarking

Web services

Further reading

Javadoc

Support

Knowledge Base

Community Q&A