JSupervisor REST API

EventManagement

getEventById

Get event by ID

Retrieves detailed information about a specific process event


/api/v1/events/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8086/api/v1/events/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.EventManagementApi;

import java.io.File;
import java.util.*;

public class EventManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        EventManagementApi apiInstance = new EventManagementApi();
        Long id = 123; // Long | Event ID

        try {
            ProcessEventEntry result = apiInstance.getEventById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventManagementApi#getEventById");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | Event ID

try {
    final result = await api_instance.getEventById(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getEventById: $e\n');
}

import org.openapitools.client.api.EventManagementApi;

public class EventManagementApiExample {
    public static void main(String[] args) {
        EventManagementApi apiInstance = new EventManagementApi();
        Long id = 123; // Long | Event ID

        try {
            ProcessEventEntry result = apiInstance.getEventById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventManagementApi#getEventById");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
EventManagementApi *apiInstance = [[EventManagementApi alloc] init];
Long *id = 123; // Event ID (default to null)

// Get event by ID
[apiInstance getEventByIdWith:id
              completionHandler: ^(ProcessEventEntry output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var JSupervisorRestApi = require('j_supervisor_rest_api');

// Create an instance of the API class
var api = new JSupervisorRestApi.EventManagementApi()
var id = 123; // {Long} Event ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getEventById(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getEventByIdExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new EventManagementApi();
            var id = 123;  // Long | Event ID (default to null)

            try {
                // Get event by ID
                ProcessEventEntry result = apiInstance.getEventById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EventManagementApi.getEventById: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EventManagementApi();
$id = 123; // Long | Event ID

try {
    $result = $api_instance->getEventById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EventManagementApi->getEventById: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::EventManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EventManagementApi->new();
my $id = 123; # Long | Event ID

eval {
    my $result = $api_instance->getEventById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EventManagementApi->getEventById: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.EventManagementApi()
id = 123 # Long | Event ID (default to null)

try:
    # Get event by ID
    api_response = api_instance.get_event_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventManagementApi->getEventById: %s\n" % e)
extern crate EventManagementApi;

pub fn main() {
    let id = 123; // Long

    let mut context = EventManagementApi::Context::default();
    let result = client.getEventById(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Event ID
Required

Responses


getEvents

Get paginated events

Retrieves a paginated list of all process events with customizable sorting


/api/v1/events

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*,application/json" \
 "http://localhost:8086/api/v1/events?page=0&size=20&sortBy=eventTime&sortDirection=desc"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.EventManagementApi;

import java.io.File;
import java.util.*;

public class EventManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        EventManagementApi apiInstance = new EventManagementApi();
        Integer page = 0; // Integer | Page number (0-based)
        Integer size = 20; // Integer | Number of items per page
        String sortBy = eventTime; // String | Field to sort by
        String sortDirection = desc; // String | Sort direction

        try {
            Page result = apiInstance.getEvents(page, size, sortBy, sortDirection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventManagementApi#getEvents");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer page = new Integer(); // Integer | Page number (0-based)
final Integer size = new Integer(); // Integer | Number of items per page
final String sortBy = new String(); // String | Field to sort by
final String sortDirection = new String(); // String | Sort direction

try {
    final result = await api_instance.getEvents(page, size, sortBy, sortDirection);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getEvents: $e\n');
}

import org.openapitools.client.api.EventManagementApi;

public class EventManagementApiExample {
    public static void main(String[] args) {
        EventManagementApi apiInstance = new EventManagementApi();
        Integer page = 0; // Integer | Page number (0-based)
        Integer size = 20; // Integer | Number of items per page
        String sortBy = eventTime; // String | Field to sort by
        String sortDirection = desc; // String | Sort direction

        try {
            Page result = apiInstance.getEvents(page, size, sortBy, sortDirection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventManagementApi#getEvents");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
EventManagementApi *apiInstance = [[EventManagementApi alloc] init];
Integer *page = 0; // Page number (0-based) (optional) (default to null)
Integer *size = 20; // Number of items per page (optional) (default to null)
String *sortBy = eventTime; // Field to sort by (optional) (default to null)
String *sortDirection = desc; // Sort direction (optional) (default to null)

// Get paginated events
[apiInstance getEventsWith:page
    size:size
    sortBy:sortBy
    sortDirection:sortDirection
              completionHandler: ^(Page output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var JSupervisorRestApi = require('j_supervisor_rest_api');

// Create an instance of the API class
var api = new JSupervisorRestApi.EventManagementApi()
var opts = {
  'page': 0, // {Integer} Page number (0-based)
  'size': 20, // {Integer} Number of items per page
  'sortBy': eventTime, // {String} Field to sort by
  'sortDirection': desc // {String} Sort direction
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getEvents(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getEventsExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new EventManagementApi();
            var page = 0;  // Integer | Page number (0-based) (optional)  (default to null)
            var size = 20;  // Integer | Number of items per page (optional)  (default to null)
            var sortBy = eventTime;  // String | Field to sort by (optional)  (default to null)
            var sortDirection = desc;  // String | Sort direction (optional)  (default to null)

            try {
                // Get paginated events
                Page result = apiInstance.getEvents(page, size, sortBy, sortDirection);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EventManagementApi.getEvents: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EventManagementApi();
$page = 0; // Integer | Page number (0-based)
$size = 20; // Integer | Number of items per page
$sortBy = eventTime; // String | Field to sort by
$sortDirection = desc; // String | Sort direction

try {
    $result = $api_instance->getEvents($page, $size, $sortBy, $sortDirection);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EventManagementApi->getEvents: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::EventManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EventManagementApi->new();
my $page = 0; # Integer | Page number (0-based)
my $size = 20; # Integer | Number of items per page
my $sortBy = eventTime; # String | Field to sort by
my $sortDirection = desc; # String | Sort direction

eval {
    my $result = $api_instance->getEvents(page => $page, size => $size, sortBy => $sortBy, sortDirection => $sortDirection);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EventManagementApi->getEvents: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.EventManagementApi()
page = 0 # Integer | Page number (0-based) (optional) (default to null)
size = 20 # Integer | Number of items per page (optional) (default to null)
sortBy = eventTime # String | Field to sort by (optional) (default to null)
sortDirection = desc # String | Sort direction (optional) (default to null)

try:
    # Get paginated events
    api_response = api_instance.get_events(page=page, size=size, sortBy=sortBy, sortDirection=sortDirection)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventManagementApi->getEvents: %s\n" % e)
extern crate EventManagementApi;

pub fn main() {
    let page = 0; // Integer
    let size = 20; // Integer
    let sortBy = eventTime; // String
    let sortDirection = desc; // String

    let mut context = EventManagementApi::Context::default();
    let result = client.getEvents(page, size, sortBy, sortDirection, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
page
Integer
Page number (0-based)
size
Integer
Number of items per page
sortBy
String
Field to sort by
sortDirection
String
Sort direction

Responses


getEventsByProcess

Get events by process name

Retrieves paginated events for a specific process


/api/v1/events/by-process/{processName}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8086/api/v1/events/by-process/{processName}?page=0&size=20&sortBy=eventTime&sortDirection=desc"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.EventManagementApi;

import java.io.File;
import java.util.*;

public class EventManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        EventManagementApi apiInstance = new EventManagementApi();
        String processName = myapp; // String | Process name
        Integer page = 0; // Integer | Page number (0-based)
        Integer size = 20; // Integer | Number of items per page
        String sortBy = eventTime; // String | Field to sort by
        String sortDirection = desc; // String | Sort direction

        try {
            PageProcessEventEntry result = apiInstance.getEventsByProcess(processName, page, size, sortBy, sortDirection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventManagementApi#getEventsByProcess");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String processName = new String(); // String | Process name
final Integer page = new Integer(); // Integer | Page number (0-based)
final Integer size = new Integer(); // Integer | Number of items per page
final String sortBy = new String(); // String | Field to sort by
final String sortDirection = new String(); // String | Sort direction

try {
    final result = await api_instance.getEventsByProcess(processName, page, size, sortBy, sortDirection);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getEventsByProcess: $e\n');
}

import org.openapitools.client.api.EventManagementApi;

public class EventManagementApiExample {
    public static void main(String[] args) {
        EventManagementApi apiInstance = new EventManagementApi();
        String processName = myapp; // String | Process name
        Integer page = 0; // Integer | Page number (0-based)
        Integer size = 20; // Integer | Number of items per page
        String sortBy = eventTime; // String | Field to sort by
        String sortDirection = desc; // String | Sort direction

        try {
            PageProcessEventEntry result = apiInstance.getEventsByProcess(processName, page, size, sortBy, sortDirection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventManagementApi#getEventsByProcess");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
EventManagementApi *apiInstance = [[EventManagementApi alloc] init];
String *processName = myapp; // Process name (default to null)
Integer *page = 0; // Page number (0-based) (optional) (default to 0)
Integer *size = 20; // Number of items per page (optional) (default to 20)
String *sortBy = eventTime; // Field to sort by (optional) (default to eventTime)
String *sortDirection = desc; // Sort direction (optional) (default to desc)

// Get events by process name
[apiInstance getEventsByProcessWith:processName
    page:page
    size:size
    sortBy:sortBy
    sortDirection:sortDirection
              completionHandler: ^(PageProcessEventEntry output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var JSupervisorRestApi = require('j_supervisor_rest_api');

// Create an instance of the API class
var api = new JSupervisorRestApi.EventManagementApi()
var processName = myapp; // {String} Process name
var opts = {
  'page': 0, // {Integer} Page number (0-based)
  'size': 20, // {Integer} Number of items per page
  'sortBy': eventTime, // {String} Field to sort by
  'sortDirection': desc // {String} Sort direction
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getEventsByProcess(processName, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getEventsByProcessExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new EventManagementApi();
            var processName = myapp;  // String | Process name (default to null)
            var page = 0;  // Integer | Page number (0-based) (optional)  (default to 0)
            var size = 20;  // Integer | Number of items per page (optional)  (default to 20)
            var sortBy = eventTime;  // String | Field to sort by (optional)  (default to eventTime)
            var sortDirection = desc;  // String | Sort direction (optional)  (default to desc)

            try {
                // Get events by process name
                PageProcessEventEntry result = apiInstance.getEventsByProcess(processName, page, size, sortBy, sortDirection);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EventManagementApi.getEventsByProcess: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EventManagementApi();
$processName = myapp; // String | Process name
$page = 0; // Integer | Page number (0-based)
$size = 20; // Integer | Number of items per page
$sortBy = eventTime; // String | Field to sort by
$sortDirection = desc; // String | Sort direction

try {
    $result = $api_instance->getEventsByProcess($processName, $page, $size, $sortBy, $sortDirection);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EventManagementApi->getEventsByProcess: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::EventManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EventManagementApi->new();
my $processName = myapp; # String | Process name
my $page = 0; # Integer | Page number (0-based)
my $size = 20; # Integer | Number of items per page
my $sortBy = eventTime; # String | Field to sort by
my $sortDirection = desc; # String | Sort direction

eval {
    my $result = $api_instance->getEventsByProcess(processName => $processName, page => $page, size => $size, sortBy => $sortBy, sortDirection => $sortDirection);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EventManagementApi->getEventsByProcess: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.EventManagementApi()
processName = myapp # String | Process name (default to null)
page = 0 # Integer | Page number (0-based) (optional) (default to 0)
size = 20 # Integer | Number of items per page (optional) (default to 20)
sortBy = eventTime # String | Field to sort by (optional) (default to eventTime)
sortDirection = desc # String | Sort direction (optional) (default to desc)

try:
    # Get events by process name
    api_response = api_instance.get_events_by_process(processName, page=page, size=size, sortBy=sortBy, sortDirection=sortDirection)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventManagementApi->getEventsByProcess: %s\n" % e)
extern crate EventManagementApi;

pub fn main() {
    let processName = myapp; // String
    let page = 0; // Integer
    let size = 20; // Integer
    let sortBy = eventTime; // String
    let sortDirection = desc; // String

    let mut context = EventManagementApi::Context::default();
    let result = client.getEventsByProcess(processName, page, size, sortBy, sortDirection, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
processName*
String
Process name
Required
Query parameters
Name Description
page
Integer (int32)
Page number (0-based)
size
Integer (int32)
Number of items per page
sortBy
String
Field to sort by
sortDirection
String
Sort direction

Responses


getEventsByStatus

Get events by status

Retrieves paginated events matching a specific process status


/api/v1/events/by-status/{status}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8086/api/v1/events/by-status/{status}?page=0&size=20&sortBy=eventTime&sortDirection=desc"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.EventManagementApi;

import java.io.File;
import java.util.*;

public class EventManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        EventManagementApi apiInstance = new EventManagementApi();
        String status = running; // String | Process status to filter by
        Integer page = 0; // Integer | Page number (0-based)
        Integer size = 20; // Integer | Number of items per page
        String sortBy = eventTime; // String | Field to sort by
        String sortDirection = desc; // String | Sort direction

        try {
            PageProcessEventEntry result = apiInstance.getEventsByStatus(status, page, size, sortBy, sortDirection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventManagementApi#getEventsByStatus");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String status = new String(); // String | Process status to filter by
final Integer page = new Integer(); // Integer | Page number (0-based)
final Integer size = new Integer(); // Integer | Number of items per page
final String sortBy = new String(); // String | Field to sort by
final String sortDirection = new String(); // String | Sort direction

try {
    final result = await api_instance.getEventsByStatus(status, page, size, sortBy, sortDirection);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getEventsByStatus: $e\n');
}

import org.openapitools.client.api.EventManagementApi;

public class EventManagementApiExample {
    public static void main(String[] args) {
        EventManagementApi apiInstance = new EventManagementApi();
        String status = running; // String | Process status to filter by
        Integer page = 0; // Integer | Page number (0-based)
        Integer size = 20; // Integer | Number of items per page
        String sortBy = eventTime; // String | Field to sort by
        String sortDirection = desc; // String | Sort direction

        try {
            PageProcessEventEntry result = apiInstance.getEventsByStatus(status, page, size, sortBy, sortDirection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventManagementApi#getEventsByStatus");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
EventManagementApi *apiInstance = [[EventManagementApi alloc] init];
String *status = running; // Process status to filter by (default to null)
Integer *page = 0; // Page number (0-based) (optional) (default to 0)
Integer *size = 20; // Number of items per page (optional) (default to 20)
String *sortBy = eventTime; // Field to sort by (optional) (default to eventTime)
String *sortDirection = desc; // Sort direction (optional) (default to desc)

// Get events by status
[apiInstance getEventsByStatusWith:status
    page:page
    size:size
    sortBy:sortBy
    sortDirection:sortDirection
              completionHandler: ^(PageProcessEventEntry output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var JSupervisorRestApi = require('j_supervisor_rest_api');

// Create an instance of the API class
var api = new JSupervisorRestApi.EventManagementApi()
var status = running; // {String} Process status to filter by
var opts = {
  'page': 0, // {Integer} Page number (0-based)
  'size': 20, // {Integer} Number of items per page
  'sortBy': eventTime, // {String} Field to sort by
  'sortDirection': desc // {String} Sort direction
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getEventsByStatus(status, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getEventsByStatusExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new EventManagementApi();
            var status = running;  // String | Process status to filter by (default to null)
            var page = 0;  // Integer | Page number (0-based) (optional)  (default to 0)
            var size = 20;  // Integer | Number of items per page (optional)  (default to 20)
            var sortBy = eventTime;  // String | Field to sort by (optional)  (default to eventTime)
            var sortDirection = desc;  // String | Sort direction (optional)  (default to desc)

            try {
                // Get events by status
                PageProcessEventEntry result = apiInstance.getEventsByStatus(status, page, size, sortBy, sortDirection);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EventManagementApi.getEventsByStatus: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EventManagementApi();
$status = running; // String | Process status to filter by
$page = 0; // Integer | Page number (0-based)
$size = 20; // Integer | Number of items per page
$sortBy = eventTime; // String | Field to sort by
$sortDirection = desc; // String | Sort direction

try {
    $result = $api_instance->getEventsByStatus($status, $page, $size, $sortBy, $sortDirection);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EventManagementApi->getEventsByStatus: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::EventManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EventManagementApi->new();
my $status = running; # String | Process status to filter by
my $page = 0; # Integer | Page number (0-based)
my $size = 20; # Integer | Number of items per page
my $sortBy = eventTime; # String | Field to sort by
my $sortDirection = desc; # String | Sort direction

eval {
    my $result = $api_instance->getEventsByStatus(status => $status, page => $page, size => $size, sortBy => $sortBy, sortDirection => $sortDirection);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EventManagementApi->getEventsByStatus: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.EventManagementApi()
status = running # String | Process status to filter by (default to null)
page = 0 # Integer | Page number (0-based) (optional) (default to 0)
size = 20 # Integer | Number of items per page (optional) (default to 20)
sortBy = eventTime # String | Field to sort by (optional) (default to eventTime)
sortDirection = desc # String | Sort direction (optional) (default to desc)

try:
    # Get events by status
    api_response = api_instance.get_events_by_status(status, page=page, size=size, sortBy=sortBy, sortDirection=sortDirection)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventManagementApi->getEventsByStatus: %s\n" % e)
extern crate EventManagementApi;

pub fn main() {
    let status = running; // String
    let page = 0; // Integer
    let size = 20; // Integer
    let sortBy = eventTime; // String
    let sortDirection = desc; // String

    let mut context = EventManagementApi::Context::default();
    let result = client.getEventsByStatus(status, page, size, sortBy, sortDirection, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
status*
String
Process status to filter by
Required
Query parameters
Name Description
page
Integer (int32)
Page number (0-based)
size
Integer (int32)
Number of items per page
sortBy
String
Field to sort by
sortDirection
String
Sort direction

Responses


getTotalEventsCount

Get total event count

Returns the total number of events in the system


/api/v1/events/count

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8086/api/v1/events/count"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.EventManagementApi;

import java.io.File;
import java.util.*;

public class EventManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        EventManagementApi apiInstance = new EventManagementApi();

        try {
            map['String', Long] result = apiInstance.getTotalEventsCount();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventManagementApi#getTotalEventsCount");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getTotalEventsCount();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getTotalEventsCount: $e\n');
}

import org.openapitools.client.api.EventManagementApi;

public class EventManagementApiExample {
    public static void main(String[] args) {
        EventManagementApi apiInstance = new EventManagementApi();

        try {
            map['String', Long] result = apiInstance.getTotalEventsCount();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventManagementApi#getTotalEventsCount");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
EventManagementApi *apiInstance = [[EventManagementApi alloc] init];

// Get total event count
[apiInstance getTotalEventsCountWithCompletionHandler: 
              ^(map['String', Long] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var JSupervisorRestApi = require('j_supervisor_rest_api');

// Create an instance of the API class
var api = new JSupervisorRestApi.EventManagementApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTotalEventsCount(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getTotalEventsCountExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new EventManagementApi();

            try {
                // Get total event count
                map['String', Long] result = apiInstance.getTotalEventsCount();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EventManagementApi.getTotalEventsCount: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EventManagementApi();

try {
    $result = $api_instance->getTotalEventsCount();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EventManagementApi->getTotalEventsCount: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::EventManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EventManagementApi->new();

eval {
    my $result = $api_instance->getTotalEventsCount();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EventManagementApi->getTotalEventsCount: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.EventManagementApi()

try:
    # Get total event count
    api_response = api_instance.get_total_events_count()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventManagementApi->getTotalEventsCount: %s\n" % e)
extern crate EventManagementApi;

pub fn main() {

    let mut context = EventManagementApi::Context::default();
    let result = client.getTotalEventsCount(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


GroupProcessOperations

restartAll

Restart all processes

Restart all configured processes


/api/v1/processes/group/restart

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "http://localhost:8086/api/v1/processes/group/restart"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GroupProcessOperationsApi;

import java.io.File;
import java.util.*;

public class GroupProcessOperationsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GroupProcessOperationsApi apiInstance = new GroupProcessOperationsApi();

        try {
            apiInstance.restartAll();
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupProcessOperationsApi#restartAll");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.restartAll();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->restartAll: $e\n');
}

import org.openapitools.client.api.GroupProcessOperationsApi;

public class GroupProcessOperationsApiExample {
    public static void main(String[] args) {
        GroupProcessOperationsApi apiInstance = new GroupProcessOperationsApi();

        try {
            apiInstance.restartAll();
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupProcessOperationsApi#restartAll");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
GroupProcessOperationsApi *apiInstance = [[GroupProcessOperationsApi alloc] init];

// Restart all processes
[apiInstance restartAllWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var JSupervisorRestApi = require('j_supervisor_rest_api');

// Create an instance of the API class
var api = new JSupervisorRestApi.GroupProcessOperationsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.restartAll(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class restartAllExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GroupProcessOperationsApi();

            try {
                // Restart all processes
                apiInstance.restartAll();
            } catch (Exception e) {
                Debug.Print("Exception when calling GroupProcessOperationsApi.restartAll: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GroupProcessOperationsApi();

try {
    $api_instance->restartAll();
} catch (Exception $e) {
    echo 'Exception when calling GroupProcessOperationsApi->restartAll: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GroupProcessOperationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GroupProcessOperationsApi->new();

eval {
    $api_instance->restartAll();
};
if ($@) {
    warn "Exception when calling GroupProcessOperationsApi->restartAll: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GroupProcessOperationsApi()

try:
    # Restart all processes
    api_instance.restart_all()
except ApiException as e:
    print("Exception when calling GroupProcessOperationsApi->restartAll: %s\n" % e)
extern crate GroupProcessOperationsApi;

pub fn main() {

    let mut context = GroupProcessOperationsApi::Context::default();
    let result = client.restartAll(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


startAll

Start all processes

Start all configured processes that are not currently running


/api/v1/processes/group/start

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "http://localhost:8086/api/v1/processes/group/start"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GroupProcessOperationsApi;

import java.io.File;
import java.util.*;

public class GroupProcessOperationsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GroupProcessOperationsApi apiInstance = new GroupProcessOperationsApi();

        try {
            apiInstance.startAll();
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupProcessOperationsApi#startAll");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.startAll();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->startAll: $e\n');
}

import org.openapitools.client.api.GroupProcessOperationsApi;

public class GroupProcessOperationsApiExample {
    public static void main(String[] args) {
        GroupProcessOperationsApi apiInstance = new GroupProcessOperationsApi();

        try {
            apiInstance.startAll();
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupProcessOperationsApi#startAll");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
GroupProcessOperationsApi *apiInstance = [[GroupProcessOperationsApi alloc] init];

// Start all processes
[apiInstance startAllWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var JSupervisorRestApi = require('j_supervisor_rest_api');

// Create an instance of the API class
var api = new JSupervisorRestApi.GroupProcessOperationsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.startAll(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class startAllExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GroupProcessOperationsApi();

            try {
                // Start all processes
                apiInstance.startAll();
            } catch (Exception e) {
                Debug.Print("Exception when calling GroupProcessOperationsApi.startAll: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GroupProcessOperationsApi();

try {
    $api_instance->startAll();
} catch (Exception $e) {
    echo 'Exception when calling GroupProcessOperationsApi->startAll: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GroupProcessOperationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GroupProcessOperationsApi->new();

eval {
    $api_instance->startAll();
};
if ($@) {
    warn "Exception when calling GroupProcessOperationsApi->startAll: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GroupProcessOperationsApi()

try:
    # Start all processes
    api_instance.start_all()
except ApiException as e:
    print("Exception when calling GroupProcessOperationsApi->startAll: %s\n" % e)
extern crate GroupProcessOperationsApi;

pub fn main() {

    let mut context = GroupProcessOperationsApi::Context::default();
    let result = client.startAll(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


stopAll

Stop all processes

Stop all currently running processes


/api/v1/processes/group/stop

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "http://localhost:8086/api/v1/processes/group/stop"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GroupProcessOperationsApi;

import java.io.File;
import java.util.*;

public class GroupProcessOperationsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GroupProcessOperationsApi apiInstance = new GroupProcessOperationsApi();

        try {
            apiInstance.stopAll();
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupProcessOperationsApi#stopAll");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.stopAll();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->stopAll: $e\n');
}

import org.openapitools.client.api.GroupProcessOperationsApi;

public class GroupProcessOperationsApiExample {
    public static void main(String[] args) {
        GroupProcessOperationsApi apiInstance = new GroupProcessOperationsApi();

        try {
            apiInstance.stopAll();
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupProcessOperationsApi#stopAll");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
GroupProcessOperationsApi *apiInstance = [[GroupProcessOperationsApi alloc] init];

// Stop all processes
[apiInstance stopAllWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var JSupervisorRestApi = require('j_supervisor_rest_api');

// Create an instance of the API class
var api = new JSupervisorRestApi.GroupProcessOperationsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.stopAll(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class stopAllExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GroupProcessOperationsApi();

            try {
                // Stop all processes
                apiInstance.stopAll();
            } catch (Exception e) {
                Debug.Print("Exception when calling GroupProcessOperationsApi.stopAll: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GroupProcessOperationsApi();

try {
    $api_instance->stopAll();
} catch (Exception $e) {
    echo 'Exception when calling GroupProcessOperationsApi->stopAll: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GroupProcessOperationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GroupProcessOperationsApi->new();

eval {
    $api_instance->stopAll();
};
if ($@) {
    warn "Exception when calling GroupProcessOperationsApi->stopAll: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GroupProcessOperationsApi()

try:
    # Stop all processes
    api_instance.stop_all()
except ApiException as e:
    print("Exception when calling GroupProcessOperationsApi->stopAll: %s\n" % e)
extern crate GroupProcessOperationsApi;

pub fn main() {

    let mut context = GroupProcessOperationsApi::Context::default();
    let result = client.stopAll(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


ProcessManagement

getAllProcesses

List all processes

Retrieve status information for all configured processes


/api/v1/processes

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8086/api/v1/processes"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProcessManagementApi;

import java.io.File;
import java.util.*;

public class ProcessManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProcessManagementApi apiInstance = new ProcessManagementApi();

        try {
            array[ProcessStatusRest] result = apiInstance.getAllProcesses();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessManagementApi#getAllProcesses");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getAllProcesses();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllProcesses: $e\n');
}

import org.openapitools.client.api.ProcessManagementApi;

public class ProcessManagementApiExample {
    public static void main(String[] args) {
        ProcessManagementApi apiInstance = new ProcessManagementApi();

        try {
            array[ProcessStatusRest] result = apiInstance.getAllProcesses();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessManagementApi#getAllProcesses");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ProcessManagementApi *apiInstance = [[ProcessManagementApi alloc] init];

// List all processes
[apiInstance getAllProcessesWithCompletionHandler: 
              ^(array[ProcessStatusRest] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var JSupervisorRestApi = require('j_supervisor_rest_api');

// Create an instance of the API class
var api = new JSupervisorRestApi.ProcessManagementApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllProcesses(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getAllProcessesExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new ProcessManagementApi();

            try {
                // List all processes
                array[ProcessStatusRest] result = apiInstance.getAllProcesses();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProcessManagementApi.getAllProcesses: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProcessManagementApi();

try {
    $result = $api_instance->getAllProcesses();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessManagementApi->getAllProcesses: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProcessManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProcessManagementApi->new();

eval {
    my $result = $api_instance->getAllProcesses();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProcessManagementApi->getAllProcesses: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.ProcessManagementApi()

try:
    # List all processes
    api_response = api_instance.get_all_processes()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProcessManagementApi->getAllProcesses: %s\n" % e)
extern crate ProcessManagementApi;

pub fn main() {

    let mut context = ProcessManagementApi::Context::default();
    let result = client.getAllProcesses(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


getProcessStatus

Get process status

Get the current status of a specific process


/api/v1/processes/status/{name}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8086/api/v1/processes/status/{name}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProcessManagementApi;

import java.io.File;
import java.util.*;

public class ProcessManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProcessManagementApi apiInstance = new ProcessManagementApi();
        String name = name_example; // String | Process name

        try {
            ProcessStatusRest result = apiInstance.getProcessStatus(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessManagementApi#getProcessStatus");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Process name

try {
    final result = await api_instance.getProcessStatus(name);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getProcessStatus: $e\n');
}

import org.openapitools.client.api.ProcessManagementApi;

public class ProcessManagementApiExample {
    public static void main(String[] args) {
        ProcessManagementApi apiInstance = new ProcessManagementApi();
        String name = name_example; // String | Process name

        try {
            ProcessStatusRest result = apiInstance.getProcessStatus(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessManagementApi#getProcessStatus");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ProcessManagementApi *apiInstance = [[ProcessManagementApi alloc] init];
String *name = name_example; // Process name (default to null)

// Get process status
[apiInstance getProcessStatusWith:name
              completionHandler: ^(ProcessStatusRest output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var JSupervisorRestApi = require('j_supervisor_rest_api');

// Create an instance of the API class
var api = new JSupervisorRestApi.ProcessManagementApi()
var name = name_example; // {String} Process name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getProcessStatus(name, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getProcessStatusExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new ProcessManagementApi();
            var name = name_example;  // String | Process name (default to null)

            try {
                // Get process status
                ProcessStatusRest result = apiInstance.getProcessStatus(name);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProcessManagementApi.getProcessStatus: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProcessManagementApi();
$name = name_example; // String | Process name

try {
    $result = $api_instance->getProcessStatus($name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessManagementApi->getProcessStatus: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProcessManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProcessManagementApi->new();
my $name = name_example; # String | Process name

eval {
    my $result = $api_instance->getProcessStatus(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProcessManagementApi->getProcessStatus: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.ProcessManagementApi()
name = name_example # String | Process name (default to null)

try:
    # Get process status
    api_response = api_instance.get_process_status(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProcessManagementApi->getProcessStatus: %s\n" % e)
extern crate ProcessManagementApi;

pub fn main() {
    let name = name_example; // String

    let mut context = ProcessManagementApi::Context::default();
    let result = client.getProcessStatus(name, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
name*
String
Process name
Required

Responses


restartProcess

Restart process

Restart a specific process


/api/v1/processes/restart/{name}

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "http://localhost:8086/api/v1/processes/restart/{name}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProcessManagementApi;

import java.io.File;
import java.util.*;

public class ProcessManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProcessManagementApi apiInstance = new ProcessManagementApi();
        String name = name_example; // String | Process name

        try {
            apiInstance.restartProcess(name);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessManagementApi#restartProcess");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Process name

try {
    final result = await api_instance.restartProcess(name);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->restartProcess: $e\n');
}

import org.openapitools.client.api.ProcessManagementApi;

public class ProcessManagementApiExample {
    public static void main(String[] args) {
        ProcessManagementApi apiInstance = new ProcessManagementApi();
        String name = name_example; // String | Process name

        try {
            apiInstance.restartProcess(name);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessManagementApi#restartProcess");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ProcessManagementApi *apiInstance = [[ProcessManagementApi alloc] init];
String *name = name_example; // Process name (default to null)

// Restart process
[apiInstance restartProcessWith:name
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var JSupervisorRestApi = require('j_supervisor_rest_api');

// Create an instance of the API class
var api = new JSupervisorRestApi.ProcessManagementApi()
var name = name_example; // {String} Process name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.restartProcess(name, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class restartProcessExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new ProcessManagementApi();
            var name = name_example;  // String | Process name (default to null)

            try {
                // Restart process
                apiInstance.restartProcess(name);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProcessManagementApi.restartProcess: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProcessManagementApi();
$name = name_example; // String | Process name

try {
    $api_instance->restartProcess($name);
} catch (Exception $e) {
    echo 'Exception when calling ProcessManagementApi->restartProcess: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProcessManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProcessManagementApi->new();
my $name = name_example; # String | Process name

eval {
    $api_instance->restartProcess(name => $name);
};
if ($@) {
    warn "Exception when calling ProcessManagementApi->restartProcess: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.ProcessManagementApi()
name = name_example # String | Process name (default to null)

try:
    # Restart process
    api_instance.restart_process(name)
except ApiException as e:
    print("Exception when calling ProcessManagementApi->restartProcess: %s\n" % e)
extern crate ProcessManagementApi;

pub fn main() {
    let name = name_example; // String

    let mut context = ProcessManagementApi::Context::default();
    let result = client.restartProcess(name, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
name*
String
Process name
Required

Responses


startProcess

Start process

Start a specific process


/api/v1/processes/start/{name}

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "http://localhost:8086/api/v1/processes/start/{name}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProcessManagementApi;

import java.io.File;
import java.util.*;

public class ProcessManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProcessManagementApi apiInstance = new ProcessManagementApi();
        String name = name_example; // String | Process name

        try {
            ResponseMessage result = apiInstance.startProcess(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessManagementApi#startProcess");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Process name

try {
    final result = await api_instance.startProcess(name);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->startProcess: $e\n');
}

import org.openapitools.client.api.ProcessManagementApi;

public class ProcessManagementApiExample {
    public static void main(String[] args) {
        ProcessManagementApi apiInstance = new ProcessManagementApi();
        String name = name_example; // String | Process name

        try {
            ResponseMessage result = apiInstance.startProcess(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessManagementApi#startProcess");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ProcessManagementApi *apiInstance = [[ProcessManagementApi alloc] init];
String *name = name_example; // Process name (default to null)

// Start process
[apiInstance startProcessWith:name
              completionHandler: ^(ResponseMessage output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var JSupervisorRestApi = require('j_supervisor_rest_api');

// Create an instance of the API class
var api = new JSupervisorRestApi.ProcessManagementApi()
var name = name_example; // {String} Process name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.startProcess(name, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class startProcessExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new ProcessManagementApi();
            var name = name_example;  // String | Process name (default to null)

            try {
                // Start process
                ResponseMessage result = apiInstance.startProcess(name);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProcessManagementApi.startProcess: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProcessManagementApi();
$name = name_example; // String | Process name

try {
    $result = $api_instance->startProcess($name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessManagementApi->startProcess: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProcessManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProcessManagementApi->new();
my $name = name_example; # String | Process name

eval {
    my $result = $api_instance->startProcess(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProcessManagementApi->startProcess: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.ProcessManagementApi()
name = name_example # String | Process name (default to null)

try:
    # Start process
    api_response = api_instance.start_process(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProcessManagementApi->startProcess: %s\n" % e)
extern crate ProcessManagementApi;

pub fn main() {
    let name = name_example; // String

    let mut context = ProcessManagementApi::Context::default();
    let result = client.startProcess(name, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
name*
String
Process name
Required

Responses


stopProcess

Stop process

Stop a specific process


/api/v1/processes/stop/{name}

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "http://localhost:8086/api/v1/processes/stop/{name}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProcessManagementApi;

import java.io.File;
import java.util.*;

public class ProcessManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProcessManagementApi apiInstance = new ProcessManagementApi();
        String name = name_example; // String | Process name

        try {
            apiInstance.stopProcess(name);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessManagementApi#stopProcess");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Process name

try {
    final result = await api_instance.stopProcess(name);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->stopProcess: $e\n');
}

import org.openapitools.client.api.ProcessManagementApi;

public class ProcessManagementApiExample {
    public static void main(String[] args) {
        ProcessManagementApi apiInstance = new ProcessManagementApi();
        String name = name_example; // String | Process name

        try {
            apiInstance.stopProcess(name);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessManagementApi#stopProcess");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ProcessManagementApi *apiInstance = [[ProcessManagementApi alloc] init];
String *name = name_example; // Process name (default to null)

// Stop process
[apiInstance stopProcessWith:name
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var JSupervisorRestApi = require('j_supervisor_rest_api');

// Create an instance of the API class
var api = new JSupervisorRestApi.ProcessManagementApi()
var name = name_example; // {String} Process name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.stopProcess(name, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class stopProcessExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new ProcessManagementApi();
            var name = name_example;  // String | Process name (default to null)

            try {
                // Stop process
                apiInstance.stopProcess(name);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProcessManagementApi.stopProcess: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProcessManagementApi();
$name = name_example; // String | Process name

try {
    $api_instance->stopProcess($name);
} catch (Exception $e) {
    echo 'Exception when calling ProcessManagementApi->stopProcess: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProcessManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProcessManagementApi->new();
my $name = name_example; # String | Process name

eval {
    $api_instance->stopProcess(name => $name);
};
if ($@) {
    warn "Exception when calling ProcessManagementApi->stopProcess: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.ProcessManagementApi()
name = name_example # String | Process name (default to null)

try:
    # Stop process
    api_instance.stop_process(name)
except ApiException as e:
    print("Exception when calling ProcessManagementApi->stopProcess: %s\n" % e)
extern crate ProcessManagementApi;

pub fn main() {
    let name = name_example; // String

    let mut context = ProcessManagementApi::Context::default();
    let result = client.stopProcess(name, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
name*
String
Process name
Required

Responses


SupervisorInformation

getSupervisorInfo

Get supervisor info

Retrieve basic supervisor information


/api/v1/supervisor/info

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8086/api/v1/supervisor/info"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SupervisorInformationApi;

import java.io.File;
import java.util.*;

public class SupervisorInformationApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        SupervisorInformationApi apiInstance = new SupervisorInformationApi();

        try {
            SupervisorRest result = apiInstance.getSupervisorInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SupervisorInformationApi#getSupervisorInfo");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getSupervisorInfo();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getSupervisorInfo: $e\n');
}

import org.openapitools.client.api.SupervisorInformationApi;

public class SupervisorInformationApiExample {
    public static void main(String[] args) {
        SupervisorInformationApi apiInstance = new SupervisorInformationApi();

        try {
            SupervisorRest result = apiInstance.getSupervisorInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SupervisorInformationApi#getSupervisorInfo");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
SupervisorInformationApi *apiInstance = [[SupervisorInformationApi alloc] init];

// Get supervisor info
[apiInstance getSupervisorInfoWithCompletionHandler: 
              ^(SupervisorRest output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var JSupervisorRestApi = require('j_supervisor_rest_api');

// Create an instance of the API class
var api = new JSupervisorRestApi.SupervisorInformationApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSupervisorInfo(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getSupervisorInfoExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new SupervisorInformationApi();

            try {
                // Get supervisor info
                SupervisorRest result = apiInstance.getSupervisorInfo();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SupervisorInformationApi.getSupervisorInfo: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SupervisorInformationApi();

try {
    $result = $api_instance->getSupervisorInfo();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SupervisorInformationApi->getSupervisorInfo: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SupervisorInformationApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SupervisorInformationApi->new();

eval {
    my $result = $api_instance->getSupervisorInfo();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SupervisorInformationApi->getSupervisorInfo: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.SupervisorInformationApi()

try:
    # Get supervisor info
    api_response = api_instance.get_supervisor_info()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SupervisorInformationApi->getSupervisorInfo: %s\n" % e)
extern crate SupervisorInformationApi;

pub fn main() {

    let mut context = SupervisorInformationApi::Context::default();
    let result = client.getSupervisorInfo(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses