Cloudera Documentation

Cloudera Edge Flow Manager REST API

Access

getAccessStatus

Returns the current client's authenticated identity. [BETA]


/access

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/access"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AccessApi;

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

public class AccessApiExample {

    public static void main(String[] args) {
        
        AccessApi apiInstance = new AccessApi();
        try {
            CurrentUser result = apiInstance.getAccessStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccessApi#getAccessStatus");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AccessApi;

public class AccessApiExample {

    public static void main(String[] args) {
        AccessApi apiInstance = new AccessApi();
        try {
            CurrentUser result = apiInstance.getAccessStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccessApi#getAccessStatus");
            e.printStackTrace();
        }
    }
}

AccessApi *apiInstance = [[AccessApi alloc] init];

// Returns the current client's authenticated identity. [BETA]
[apiInstance getAccessStatusWithCompletionHandler: 
              ^(CurrentUser output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AccessApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAccessStatus(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AccessApi();

            try
            {
                // Returns the current client's authenticated identity. [BETA]
                CurrentUser result = apiInstance.getAccessStatus();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccessApi.getAccessStatus: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAccessApi();

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

my $api_instance = WWW::SwaggerClient::AccessApi->new();

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

# create an instance of the API class
api_instance = swagger_client.AccessApi()

try: 
    # Returns the current client's authenticated identity. [BETA]
    api_response = api_instance.get_access_status()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccessApi->getAccessStatus: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


AgentClasses

createAgentClass

Register a MiNiFi agent class with this C2 server

This can also be done with a heartbeat, which will register a MiNiFi agent class the first time it is seen in a heartbeat.


/agent-classes

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/agent-classes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentClassesApi;

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

public class AgentClassesApiExample {

    public static void main(String[] args) {
        
        AgentClassesApi apiInstance = new AgentClassesApi();
        AgentClass body = ; // AgentClass | The class to create
        try {
            AgentClass result = apiInstance.createAgentClass(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#createAgentClass");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentClassesApi;

public class AgentClassesApiExample {

    public static void main(String[] args) {
        AgentClassesApi apiInstance = new AgentClassesApi();
        AgentClass body = ; // AgentClass | The class to create
        try {
            AgentClass result = apiInstance.createAgentClass(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#createAgentClass");
            e.printStackTrace();
        }
    }
}
AgentClass *body = ; // The class to create

AgentClassesApi *apiInstance = [[AgentClassesApi alloc] init];

// Register a MiNiFi agent class with this C2 server
[apiInstance createAgentClassWith:body
              completionHandler: ^(AgentClass output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentClassesApi()
var body = ; // {{AgentClass}} The class to create

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

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

            var apiInstance = new AgentClassesApi();
            var body = new AgentClass(); // AgentClass | The class to create

            try
            {
                // Register a MiNiFi agent class with this C2 server
                AgentClass result = apiInstance.createAgentClass(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassesApi.createAgentClass: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentClassesApi();
$body = ; // AgentClass | The class to create

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

my $api_instance = WWW::SwaggerClient::AgentClassesApi->new();
my $body = WWW::SwaggerClient::Object::AgentClass->new(); # AgentClass | The class to create

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

# create an instance of the API class
api_instance = swagger_client.AgentClassesApi()
body =  # AgentClass | The class to create

try: 
    # Register a MiNiFi agent class with this C2 server
    api_response = api_instance.create_agent_class(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassesApi->createAgentClass: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


deleteAgentClass

Delete a MiNiFi agent class


/agent-classes/{name}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/agent-classes/{name}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentClassesApi;

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

public class AgentClassesApiExample {

    public static void main(String[] args) {
        
        AgentClassesApi apiInstance = new AgentClassesApi();
        String name = name_example; // String | The name of the class to delete
        try {
            AgentClass result = apiInstance.deleteAgentClass(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#deleteAgentClass");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentClassesApi;

public class AgentClassesApiExample {

    public static void main(String[] args) {
        AgentClassesApi apiInstance = new AgentClassesApi();
        String name = name_example; // String | The name of the class to delete
        try {
            AgentClass result = apiInstance.deleteAgentClass(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#deleteAgentClass");
            e.printStackTrace();
        }
    }
}
String *name = name_example; // The name of the class to delete

AgentClassesApi *apiInstance = [[AgentClassesApi alloc] init];

// Delete a MiNiFi agent class
[apiInstance deleteAgentClassWith:name
              completionHandler: ^(AgentClass output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentClassesApi()
var name = name_example; // {{String}} The name of the class to delete

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

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

            var apiInstance = new AgentClassesApi();
            var name = name_example;  // String | The name of the class to delete

            try
            {
                // Delete a MiNiFi agent class
                AgentClass result = apiInstance.deleteAgentClass(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassesApi.deleteAgentClass: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentClassesApi();
$name = name_example; // String | The name of the class to delete

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

my $api_instance = WWW::SwaggerClient::AgentClassesApi->new();
my $name = name_example; # String | The name of the class to delete

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

# create an instance of the API class
api_instance = swagger_client.AgentClassesApi()
name = name_example # String | The name of the class to delete

try: 
    # Delete a MiNiFi agent class
    api_response = api_instance.delete_agent_class(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassesApi->deleteAgentClass: %s\n" % e)

Parameters

Path parameters
Name Description
name*
String
The name of the class to delete
Required

Responses

Status: 200 - successful operation


getAgentClass

Get a MiNiFi agent class that is registered with this C2 server


/agent-classes/{name}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/agent-classes/{name}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentClassesApi;

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

public class AgentClassesApiExample {

    public static void main(String[] args) {
        
        AgentClassesApi apiInstance = new AgentClassesApi();
        String name = name_example; // String | The name of the class to retrieve
        try {
            AgentClass result = apiInstance.getAgentClass(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#getAgentClass");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentClassesApi;

public class AgentClassesApiExample {

    public static void main(String[] args) {
        AgentClassesApi apiInstance = new AgentClassesApi();
        String name = name_example; // String | The name of the class to retrieve
        try {
            AgentClass result = apiInstance.getAgentClass(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#getAgentClass");
            e.printStackTrace();
        }
    }
}
String *name = name_example; // The name of the class to retrieve

AgentClassesApi *apiInstance = [[AgentClassesApi alloc] init];

// Get a MiNiFi agent class that is registered with this C2 server
[apiInstance getAgentClassWith:name
              completionHandler: ^(AgentClass output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentClassesApi()
var name = name_example; // {{String}} The name of the class to retrieve

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

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

            var apiInstance = new AgentClassesApi();
            var name = name_example;  // String | The name of the class to retrieve

            try
            {
                // Get a MiNiFi agent class that is registered with this C2 server
                AgentClass result = apiInstance.getAgentClass(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassesApi.getAgentClass: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentClassesApi();
$name = name_example; // String | The name of the class to retrieve

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

my $api_instance = WWW::SwaggerClient::AgentClassesApi->new();
my $name = name_example; # String | The name of the class to retrieve

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

# create an instance of the API class
api_instance = swagger_client.AgentClassesApi()
name = name_example # String | The name of the class to retrieve

try: 
    # Get a MiNiFi agent class that is registered with this C2 server
    api_response = api_instance.get_agent_class(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassesApi->getAgentClass: %s\n" % e)

Parameters

Path parameters
Name Description
name*
String
The name of the class to retrieve
Required

Responses

Status: 200 - successful operation


getAgentClasses

Get all MiNiFi agent classes that are registered with this C2 server. [BETA]


/agent-classes

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/agent-classes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentClassesApi;

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

public class AgentClassesApiExample {

    public static void main(String[] args) {
        
        AgentClassesApi apiInstance = new AgentClassesApi();
        try {
            array[AgentClass] result = apiInstance.getAgentClasses();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#getAgentClasses");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentClassesApi;

public class AgentClassesApiExample {

    public static void main(String[] args) {
        AgentClassesApi apiInstance = new AgentClassesApi();
        try {
            array[AgentClass] result = apiInstance.getAgentClasses();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#getAgentClasses");
            e.printStackTrace();
        }
    }
}

AgentClassesApi *apiInstance = [[AgentClassesApi alloc] init];

// Get all MiNiFi agent classes that are registered with this C2 server. [BETA]
[apiInstance getAgentClassesWithCompletionHandler: 
              ^(array[AgentClass] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentClassesApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAgentClasses(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentClassesApi();

            try
            {
                // Get all MiNiFi agent classes that are registered with this C2 server. [BETA]
                array[AgentClass] result = apiInstance.getAgentClasses();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassesApi.getAgentClasses: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentClassesApi();

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

my $api_instance = WWW::SwaggerClient::AgentClassesApi->new();

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

# create an instance of the API class
api_instance = swagger_client.AgentClassesApi()

try: 
    # Get all MiNiFi agent classes that are registered with this C2 server. [BETA]
    api_response = api_instance.get_agent_classes()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassesApi->getAgentClasses: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


replaceAgentClass

Update a MiNiFi agent class by replacing it in full


/agent-classes/{name}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/agent-classes/{name}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentClassesApi;

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

public class AgentClassesApiExample {

    public static void main(String[] args) {
        
        AgentClassesApi apiInstance = new AgentClassesApi();
        AgentClass body = ; // AgentClass | The metadata of the class to associate with the given name.
        String name = name_example; // String | The name of the class
        try {
            AgentClass result = apiInstance.replaceAgentClass(body, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#replaceAgentClass");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentClassesApi;

public class AgentClassesApiExample {

    public static void main(String[] args) {
        AgentClassesApi apiInstance = new AgentClassesApi();
        AgentClass body = ; // AgentClass | The metadata of the class to associate with the given name.
        String name = name_example; // String | The name of the class
        try {
            AgentClass result = apiInstance.replaceAgentClass(body, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#replaceAgentClass");
            e.printStackTrace();
        }
    }
}
AgentClass *body = ; // The metadata of the class to associate with the given name.
String *name = name_example; // The name of the class

AgentClassesApi *apiInstance = [[AgentClassesApi alloc] init];

// Update a MiNiFi agent class by replacing it in full
[apiInstance replaceAgentClassWith:body
    name:name
              completionHandler: ^(AgentClass output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentClassesApi()
var body = ; // {{AgentClass}} The metadata of the class to associate with the given name.
var name = name_example; // {{String}} The name of the class

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

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

            var apiInstance = new AgentClassesApi();
            var body = new AgentClass(); // AgentClass | The metadata of the class to associate with the given name.
            var name = name_example;  // String | The name of the class

            try
            {
                // Update a MiNiFi agent class by replacing it in full
                AgentClass result = apiInstance.replaceAgentClass(body, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassesApi.replaceAgentClass: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentClassesApi();
$body = ; // AgentClass | The metadata of the class to associate with the given name.
$name = name_example; // String | The name of the class

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

my $api_instance = WWW::SwaggerClient::AgentClassesApi->new();
my $body = WWW::SwaggerClient::Object::AgentClass->new(); # AgentClass | The metadata of the class to associate with the given name.
my $name = name_example; # String | The name of the class

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

# create an instance of the API class
api_instance = swagger_client.AgentClassesApi()
body =  # AgentClass | The metadata of the class to associate with the given name.
name = name_example # String | The name of the class

try: 
    # Update a MiNiFi agent class by replacing it in full
    api_response = api_instance.replace_agent_class(body, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassesApi->replaceAgentClass: %s\n" % e)

Parameters

Path parameters
Name Description
name*
String
The name of the class
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


AgentManifests

createAgentManifest

Upload an agent manifest


/agent-manifests

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/agent-manifests?class="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentManifestsApi;

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

public class AgentManifestsApiExample {

    public static void main(String[] args) {
        
        AgentManifestsApi apiInstance = new AgentManifestsApi();
        AgentManifest body = ; // AgentManifest | 
        String class = class_example; // String | Optionally, a class label to associate with the manifest being uploaded
        try {
            AgentManifest result = apiInstance.createAgentManifest(body, class);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManifestsApi#createAgentManifest");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentManifestsApi;

public class AgentManifestsApiExample {

    public static void main(String[] args) {
        AgentManifestsApi apiInstance = new AgentManifestsApi();
        AgentManifest body = ; // AgentManifest | 
        String class = class_example; // String | Optionally, a class label to associate with the manifest being uploaded
        try {
            AgentManifest result = apiInstance.createAgentManifest(body, class);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManifestsApi#createAgentManifest");
            e.printStackTrace();
        }
    }
}
AgentManifest *body = ; //  (optional)
String *class = class_example; // Optionally, a class label to associate with the manifest being uploaded (optional)

AgentManifestsApi *apiInstance = [[AgentManifestsApi alloc] init];

// Upload an agent manifest
[apiInstance createAgentManifestWith:body
    class:class
              completionHandler: ^(AgentManifest output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentManifestsApi()
var opts = { 
  'body':  // {{AgentManifest}} 
  'class': class_example // {{String}} Optionally, a class label to associate with the manifest being uploaded
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createAgentManifest(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentManifestsApi();
            var body = new AgentManifest(); // AgentManifest |  (optional) 
            var class = class_example;  // String | Optionally, a class label to associate with the manifest being uploaded (optional) 

            try
            {
                // Upload an agent manifest
                AgentManifest result = apiInstance.createAgentManifest(body, class);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentManifestsApi.createAgentManifest: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentManifestsApi();
$body = ; // AgentManifest | 
$class = class_example; // String | Optionally, a class label to associate with the manifest being uploaded

try {
    $result = $api_instance->createAgentManifest($body, $class);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AgentManifestsApi->createAgentManifest: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AgentManifestsApi;

my $api_instance = WWW::SwaggerClient::AgentManifestsApi->new();
my $body = WWW::SwaggerClient::Object::AgentManifest->new(); # AgentManifest | 
my $class = class_example; # String | Optionally, a class label to associate with the manifest being uploaded

eval { 
    my $result = $api_instance->createAgentManifest(body => $body, class => $class);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentManifestsApi->createAgentManifest: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AgentManifestsApi()
body =  # AgentManifest |  (optional)
class = class_example # String | Optionally, a class label to associate with the manifest being uploaded (optional)

try: 
    # Upload an agent manifest
    api_response = api_instance.create_agent_manifest(body=body, class=class)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentManifestsApi->createAgentManifest: %s\n" % e)

Parameters

Body parameters
Name Description
body
Query parameters
Name Description
class
String
Optionally, a class label to associate with the manifest being uploaded

Responses

Status: 200 - successful operation


deleteAgentManifest

Delete the agent manifest specified by id


/agent-manifests/{id}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/agent-manifests/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentManifestsApi;

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

public class AgentManifestsApiExample {

    public static void main(String[] args) {
        
        AgentManifestsApi apiInstance = new AgentManifestsApi();
        String id = id_example; // String | 
        try {
            AgentManifest result = apiInstance.deleteAgentManifest(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManifestsApi#deleteAgentManifest");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentManifestsApi;

public class AgentManifestsApiExample {

    public static void main(String[] args) {
        AgentManifestsApi apiInstance = new AgentManifestsApi();
        String id = id_example; // String | 
        try {
            AgentManifest result = apiInstance.deleteAgentManifest(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManifestsApi#deleteAgentManifest");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // 

AgentManifestsApi *apiInstance = [[AgentManifestsApi alloc] init];

// Delete the agent manifest specified by id
[apiInstance deleteAgentManifestWith:id
              completionHandler: ^(AgentManifest output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentManifestsApi()
var id = id_example; // {{String}} 

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

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

            var apiInstance = new AgentManifestsApi();
            var id = id_example;  // String | 

            try
            {
                // Delete the agent manifest specified by id
                AgentManifest result = apiInstance.deleteAgentManifest(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentManifestsApi.deleteAgentManifest: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentManifestsApi();
$id = id_example; // String | 

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

my $api_instance = WWW::SwaggerClient::AgentManifestsApi->new();
my $id = id_example; # String | 

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

# create an instance of the API class
api_instance = swagger_client.AgentManifestsApi()
id = id_example # String | 

try: 
    # Delete the agent manifest specified by id
    api_response = api_instance.delete_agent_manifest(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentManifestsApi->deleteAgentManifest: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 200 - successful operation


getAgentManifest

Get the agent manifest specified by the id


/agent-manifests/{id}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/agent-manifests/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentManifestsApi;

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

public class AgentManifestsApiExample {

    public static void main(String[] args) {
        
        AgentManifestsApi apiInstance = new AgentManifestsApi();
        String id = id_example; // String | 
        try {
            AgentManifest result = apiInstance.getAgentManifest(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManifestsApi#getAgentManifest");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentManifestsApi;

public class AgentManifestsApiExample {

    public static void main(String[] args) {
        AgentManifestsApi apiInstance = new AgentManifestsApi();
        String id = id_example; // String | 
        try {
            AgentManifest result = apiInstance.getAgentManifest(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManifestsApi#getAgentManifest");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // 

AgentManifestsApi *apiInstance = [[AgentManifestsApi alloc] init];

// Get the agent manifest specified by the id
[apiInstance getAgentManifestWith:id
              completionHandler: ^(AgentManifest output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentManifestsApi()
var id = id_example; // {{String}} 

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

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

            var apiInstance = new AgentManifestsApi();
            var id = id_example;  // String | 

            try
            {
                // Get the agent manifest specified by the id
                AgentManifest result = apiInstance.getAgentManifest(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentManifestsApi.getAgentManifest: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentManifestsApi();
$id = id_example; // String | 

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

my $api_instance = WWW::SwaggerClient::AgentManifestsApi->new();
my $id = id_example; # String | 

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

# create an instance of the API class
api_instance = swagger_client.AgentManifestsApi()
id = id_example # String | 

try: 
    # Get the agent manifest specified by the id
    api_response = api_instance.get_agent_manifest(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentManifestsApi->getAgentManifest: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 200 - successful operation


getAgentManifests

Get all agent manifests. [BETA]


/agent-manifests

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/agent-manifests?class="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentManifestsApi;

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

public class AgentManifestsApiExample {

    public static void main(String[] args) {
        
        AgentManifestsApi apiInstance = new AgentManifestsApi();
        String class = class_example; // String | Optionally, filter the results to match a class label
        try {
            array[AgentManifest] result = apiInstance.getAgentManifests(class);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManifestsApi#getAgentManifests");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentManifestsApi;

public class AgentManifestsApiExample {

    public static void main(String[] args) {
        AgentManifestsApi apiInstance = new AgentManifestsApi();
        String class = class_example; // String | Optionally, filter the results to match a class label
        try {
            array[AgentManifest] result = apiInstance.getAgentManifests(class);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManifestsApi#getAgentManifests");
            e.printStackTrace();
        }
    }
}
String *class = class_example; // Optionally, filter the results to match a class label (optional)

AgentManifestsApi *apiInstance = [[AgentManifestsApi alloc] init];

// Get all agent manifests. [BETA]
[apiInstance getAgentManifestsWith:class
              completionHandler: ^(array[AgentManifest] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentManifestsApi()
var opts = { 
  'class': class_example // {{String}} Optionally, filter the results to match a class label
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAgentManifests(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentManifestsApi();
            var class = class_example;  // String | Optionally, filter the results to match a class label (optional) 

            try
            {
                // Get all agent manifests. [BETA]
                array[AgentManifest] result = apiInstance.getAgentManifests(class);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentManifestsApi.getAgentManifests: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentManifestsApi();
$class = class_example; // String | Optionally, filter the results to match a class label

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

my $api_instance = WWW::SwaggerClient::AgentManifestsApi->new();
my $class = class_example; # String | Optionally, filter the results to match a class label

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

# create an instance of the API class
api_instance = swagger_client.AgentManifestsApi()
class = class_example # String | Optionally, filter the results to match a class label (optional)

try: 
    # Get all agent manifests. [BETA]
    api_response = api_instance.get_agent_manifests(class=class)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentManifestsApi->getAgentManifests: %s\n" % e)

Parameters

Query parameters
Name Description
class
String
Optionally, filter the results to match a class label

Responses

Status: 200 - successful operation


Agents

createAgent

Register a MiNiFi agent with this C2 server

This can also be done with a heartbeat, which will register a MiNiFi agent the first time it is seen in a heartbeat.


/agents

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/agents"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentsApi;

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

public class AgentsApiExample {

    public static void main(String[] args) {
        
        AgentsApi apiInstance = new AgentsApi();
        AgentInfo body = ; // AgentInfo | The metadata of the agent to register
        try {
            AgentInfo result = apiInstance.createAgent(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#createAgent");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentsApi;

public class AgentsApiExample {

    public static void main(String[] args) {
        AgentsApi apiInstance = new AgentsApi();
        AgentInfo body = ; // AgentInfo | The metadata of the agent to register
        try {
            AgentInfo result = apiInstance.createAgent(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#createAgent");
            e.printStackTrace();
        }
    }
}
AgentInfo *body = ; // The metadata of the agent to register (optional)

AgentsApi *apiInstance = [[AgentsApi alloc] init];

// Register a MiNiFi agent with this C2 server
[apiInstance createAgentWith:body
              completionHandler: ^(AgentInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentsApi()
var opts = { 
  'body':  // {{AgentInfo}} The metadata of the agent to register
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createAgent(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentsApi();
            var body = new AgentInfo(); // AgentInfo | The metadata of the agent to register (optional) 

            try
            {
                // Register a MiNiFi agent with this C2 server
                AgentInfo result = apiInstance.createAgent(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.createAgent: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentsApi();
$body = ; // AgentInfo | The metadata of the agent to register

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

my $api_instance = WWW::SwaggerClient::AgentsApi->new();
my $body = WWW::SwaggerClient::Object::AgentInfo->new(); # AgentInfo | The metadata of the agent to register

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

# create an instance of the API class
api_instance = swagger_client.AgentsApi()
body =  # AgentInfo | The metadata of the agent to register (optional)

try: 
    # Register a MiNiFi agent with this C2 server
    api_response = api_instance.create_agent(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentsApi->createAgent: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - successful operation


deleteAgent

Delete an agent registered with this C2 server


/agents/{id}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/agents/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentsApi;

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

public class AgentsApiExample {

    public static void main(String[] args) {
        
        AgentsApi apiInstance = new AgentsApi();
        String id = id_example; // String | The identifier of the agent to delete
        try {
            Agent result = apiInstance.deleteAgent(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#deleteAgent");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentsApi;

public class AgentsApiExample {

    public static void main(String[] args) {
        AgentsApi apiInstance = new AgentsApi();
        String id = id_example; // String | The identifier of the agent to delete
        try {
            Agent result = apiInstance.deleteAgent(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#deleteAgent");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The identifier of the agent to delete

AgentsApi *apiInstance = [[AgentsApi alloc] init];

// Delete an agent registered with this C2 server
[apiInstance deleteAgentWith:id
              completionHandler: ^(Agent output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentsApi()
var id = id_example; // {{String}} The identifier of the agent to delete

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

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

            var apiInstance = new AgentsApi();
            var id = id_example;  // String | The identifier of the agent to delete

            try
            {
                // Delete an agent registered with this C2 server
                Agent result = apiInstance.deleteAgent(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.deleteAgent: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentsApi();
$id = id_example; // String | The identifier of the agent to delete

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

my $api_instance = WWW::SwaggerClient::AgentsApi->new();
my $id = id_example; # String | The identifier of the agent to delete

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

# create an instance of the API class
api_instance = swagger_client.AgentsApi()
id = id_example # String | The identifier of the agent to delete

try: 
    # Delete an agent registered with this C2 server
    api_response = api_instance.delete_agent(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentsApi->deleteAgent: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The identifier of the agent to delete
Required

Responses

Status: 200 - successful operation


getAgent

Retrieve info for a MiNiFi agent registered with this C2 server


/agents/{id}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/agents/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentsApi;

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

public class AgentsApiExample {

    public static void main(String[] args) {
        
        AgentsApi apiInstance = new AgentsApi();
        String id = id_example; // String | The identifier of the agent to retrieve
        try {
            Agent result = apiInstance.getAgent(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#getAgent");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentsApi;

public class AgentsApiExample {

    public static void main(String[] args) {
        AgentsApi apiInstance = new AgentsApi();
        String id = id_example; // String | The identifier of the agent to retrieve
        try {
            Agent result = apiInstance.getAgent(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#getAgent");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The identifier of the agent to retrieve

AgentsApi *apiInstance = [[AgentsApi alloc] init];

// Retrieve info for a MiNiFi agent registered with this C2 server
[apiInstance getAgentWith:id
              completionHandler: ^(Agent output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentsApi()
var id = id_example; // {{String}} The identifier of the agent to retrieve

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

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

            var apiInstance = new AgentsApi();
            var id = id_example;  // String | The identifier of the agent to retrieve

            try
            {
                // Retrieve info for a MiNiFi agent registered with this C2 server
                Agent result = apiInstance.getAgent(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.getAgent: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentsApi();
$id = id_example; // String | The identifier of the agent to retrieve

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

my $api_instance = WWW::SwaggerClient::AgentsApi->new();
my $id = id_example; # String | The identifier of the agent to retrieve

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

# create an instance of the API class
api_instance = swagger_client.AgentsApi()
id = id_example # String | The identifier of the agent to retrieve

try: 
    # Retrieve info for a MiNiFi agent registered with this C2 server
    api_response = api_instance.get_agent(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentsApi->getAgent: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The identifier of the agent to retrieve
Required

Responses

Status: 200 - successful operation


getAgents

Get all MiNiFi agents known to this C2 Server. [BETA]


/agents

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/agents"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentsApi;

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

public class AgentsApiExample {

    public static void main(String[] args) {
        
        AgentsApi apiInstance = new AgentsApi();
        try {
            array[Agent] result = apiInstance.getAgents();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#getAgents");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentsApi;

public class AgentsApiExample {

    public static void main(String[] args) {
        AgentsApi apiInstance = new AgentsApi();
        try {
            array[Agent] result = apiInstance.getAgents();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#getAgents");
            e.printStackTrace();
        }
    }
}

AgentsApi *apiInstance = [[AgentsApi alloc] init];

// Get all MiNiFi agents known to this C2 Server. [BETA]
[apiInstance getAgentsWithCompletionHandler: 
              ^(array[Agent] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAgents(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentsApi();

            try
            {
                // Get all MiNiFi agents known to this C2 Server. [BETA]
                array[Agent] result = apiInstance.getAgents();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.getAgents: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentsApi();

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

my $api_instance = WWW::SwaggerClient::AgentsApi->new();

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

# create an instance of the API class
api_instance = swagger_client.AgentsApi()

try: 
    # Get all MiNiFi agents known to this C2 Server. [BETA]
    api_response = api_instance.get_agents()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentsApi->getAgents: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


C2Configuration

getC2ConfigurationInfo

Get general information about the configuration of the C2 server


/c2-configuration

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/c2-configuration"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.C2ConfigurationApi;

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

public class C2ConfigurationApiExample {

    public static void main(String[] args) {
        
        C2ConfigurationApi apiInstance = new C2ConfigurationApi();
        try {
            C2ConfigurationInfo result = apiInstance.getC2ConfigurationInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ConfigurationApi#getC2ConfigurationInfo");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.C2ConfigurationApi;

public class C2ConfigurationApiExample {

    public static void main(String[] args) {
        C2ConfigurationApi apiInstance = new C2ConfigurationApi();
        try {
            C2ConfigurationInfo result = apiInstance.getC2ConfigurationInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ConfigurationApi#getC2ConfigurationInfo");
            e.printStackTrace();
        }
    }
}

C2ConfigurationApi *apiInstance = [[C2ConfigurationApi alloc] init];

// Get general information about the configuration of the C2 server
[apiInstance getC2ConfigurationInfoWithCompletionHandler: 
              ^(C2ConfigurationInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.C2ConfigurationApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getC2ConfigurationInfo(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new C2ConfigurationApi();

            try
            {
                // Get general information about the configuration of the C2 server
                C2ConfigurationInfo result = apiInstance.getC2ConfigurationInfo();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling C2ConfigurationApi.getC2ConfigurationInfo: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiC2ConfigurationApi();

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

my $api_instance = WWW::SwaggerClient::C2ConfigurationApi->new();

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

# create an instance of the API class
api_instance = swagger_client.C2ConfigurationApi()

try: 
    # Get general information about the configuration of the C2 server
    api_response = api_instance.get_c2_configuration_info()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling C2ConfigurationApi->getC2ConfigurationInfo: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


getNiFiRegistryInfo

Get information about the NiFi Registry that the C2 server is configured with


/c2-configuration/nifi-registry

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/c2-configuration/nifi-registry"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.C2ConfigurationApi;

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

public class C2ConfigurationApiExample {

    public static void main(String[] args) {
        
        C2ConfigurationApi apiInstance = new C2ConfigurationApi();
        try {
            NiFiRegistryInfo result = apiInstance.getNiFiRegistryInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ConfigurationApi#getNiFiRegistryInfo");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.C2ConfigurationApi;

public class C2ConfigurationApiExample {

    public static void main(String[] args) {
        C2ConfigurationApi apiInstance = new C2ConfigurationApi();
        try {
            NiFiRegistryInfo result = apiInstance.getNiFiRegistryInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ConfigurationApi#getNiFiRegistryInfo");
            e.printStackTrace();
        }
    }
}

C2ConfigurationApi *apiInstance = [[C2ConfigurationApi alloc] init];

// Get information about the NiFi Registry that the C2 server is configured with
[apiInstance getNiFiRegistryInfoWithCompletionHandler: 
              ^(NiFiRegistryInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.C2ConfigurationApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getNiFiRegistryInfo(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new C2ConfigurationApi();

            try
            {
                // Get information about the NiFi Registry that the C2 server is configured with
                NiFiRegistryInfo result = apiInstance.getNiFiRegistryInfo();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling C2ConfigurationApi.getNiFiRegistryInfo: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiC2ConfigurationApi();

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

my $api_instance = WWW::SwaggerClient::C2ConfigurationApi->new();

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

# create an instance of the API class
api_instance = swagger_client.C2ConfigurationApi()

try: 
    # Get information about the NiFi Registry that the C2 server is configured with
    api_response = api_instance.get_ni_fi_registry_info()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling C2ConfigurationApi->getNiFiRegistryInfo: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


C2Protocol

acknowledge

An endpoint for a MiNiFi Agent to send an operation acknowledgement to the C2 server


/c2-protocol/acknowledge

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json"\
"/efm/api/c2-protocol/acknowledge"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.C2ProtocolApi;

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

public class C2ProtocolApiExample {

    public static void main(String[] args) {
        
        C2ProtocolApi apiInstance = new C2ProtocolApi();
        C2OperationAck body = ; // C2OperationAck | 
        try {
            apiInstance.acknowledge(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ProtocolApi#acknowledge");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.C2ProtocolApi;

public class C2ProtocolApiExample {

    public static void main(String[] args) {
        C2ProtocolApi apiInstance = new C2ProtocolApi();
        C2OperationAck body = ; // C2OperationAck | 
        try {
            apiInstance.acknowledge(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ProtocolApi#acknowledge");
            e.printStackTrace();
        }
    }
}
C2OperationAck *body = ; // 

C2ProtocolApi *apiInstance = [[C2ProtocolApi alloc] init];

// An endpoint for a MiNiFi Agent to send an operation acknowledgement to the C2 server
[apiInstance acknowledgeWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.C2ProtocolApi()
var body = ; // {{C2OperationAck}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.acknowledge(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new C2ProtocolApi();
            var body = new C2OperationAck(); // C2OperationAck | 

            try
            {
                // An endpoint for a MiNiFi Agent to send an operation acknowledgement to the C2 server
                apiInstance.acknowledge(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling C2ProtocolApi.acknowledge: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiC2ProtocolApi();
$body = ; // C2OperationAck | 

try {
    $api_instance->acknowledge($body);
} catch (Exception $e) {
    echo 'Exception when calling C2ProtocolApi->acknowledge: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::C2ProtocolApi;

my $api_instance = WWW::SwaggerClient::C2ProtocolApi->new();
my $body = WWW::SwaggerClient::Object::C2OperationAck->new(); # C2OperationAck | 

eval { 
    $api_instance->acknowledge(body => $body);
};
if ($@) {
    warn "Exception when calling C2ProtocolApi->acknowledge: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.C2ProtocolApi()
body =  # C2OperationAck | 

try: 
    # An endpoint for a MiNiFi Agent to send an operation acknowledgement to the C2 server
    api_instance.acknowledge(body)
except ApiException as e:
    print("Exception when calling C2ProtocolApi->acknowledge: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 400 - MiNiFi C2 server was unable to complete the request because it was invalid. The request should not be retried without modification.


heartbeat

An endpoint for a MiNiFi Agent to send a heartbeat to the C2 server


/c2-protocol/heartbeat

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/c2-protocol/heartbeat"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.C2ProtocolApi;

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

public class C2ProtocolApiExample {

    public static void main(String[] args) {
        
        C2ProtocolApi apiInstance = new C2ProtocolApi();
        C2Heartbeat body = ; // C2Heartbeat | 
        try {
            C2HeartbeatResponse result = apiInstance.heartbeat(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ProtocolApi#heartbeat");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.C2ProtocolApi;

public class C2ProtocolApiExample {

    public static void main(String[] args) {
        C2ProtocolApi apiInstance = new C2ProtocolApi();
        C2Heartbeat body = ; // C2Heartbeat | 
        try {
            C2HeartbeatResponse result = apiInstance.heartbeat(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ProtocolApi#heartbeat");
            e.printStackTrace();
        }
    }
}
C2Heartbeat *body = ; // 

C2ProtocolApi *apiInstance = [[C2ProtocolApi alloc] init];

// An endpoint for a MiNiFi Agent to send a heartbeat to the C2 server
[apiInstance heartbeatWith:body
              completionHandler: ^(C2HeartbeatResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.C2ProtocolApi()
var body = ; // {{C2Heartbeat}} 

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

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

            var apiInstance = new C2ProtocolApi();
            var body = new C2Heartbeat(); // C2Heartbeat | 

            try
            {
                // An endpoint for a MiNiFi Agent to send a heartbeat to the C2 server
                C2HeartbeatResponse result = apiInstance.heartbeat(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling C2ProtocolApi.heartbeat: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiC2ProtocolApi();
$body = ; // C2Heartbeat | 

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

my $api_instance = WWW::SwaggerClient::C2ProtocolApi->new();
my $body = WWW::SwaggerClient::Object::C2Heartbeat->new(); # C2Heartbeat | 

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

# create an instance of the API class
api_instance = swagger_client.C2ProtocolApi()
body =  # C2Heartbeat | 

try: 
    # An endpoint for a MiNiFi Agent to send a heartbeat to the C2 server
    api_response = api_instance.heartbeat(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling C2ProtocolApi->heartbeat: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: 400 - MiNiFi C2 server was unable to complete the request because it was invalid. The request should not be retried without modification.


Events

getAvailableEventFields

Retrieves the available field names for searching or sorting events.


/events/fields

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/events/fields"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EventsApi;

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

public class EventsApiExample {

    public static void main(String[] args) {
        
        EventsApi apiInstance = new EventsApi();
        try {
            Fields result = apiInstance.getAvailableEventFields();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#getAvailableEventFields");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.EventsApi;

public class EventsApiExample {

    public static void main(String[] args) {
        EventsApi apiInstance = new EventsApi();
        try {
            Fields result = apiInstance.getAvailableEventFields();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#getAvailableEventFields");
            e.printStackTrace();
        }
    }
}

EventsApi *apiInstance = [[EventsApi alloc] init];

// Retrieves the available field names for searching or sorting events.
[apiInstance getAvailableEventFieldsWithCompletionHandler: 
              ^(Fields output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.EventsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAvailableEventFields(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EventsApi();

            try
            {
                // Retrieves the available field names for searching or sorting events.
                Fields result = apiInstance.getAvailableEventFields();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventsApi.getAvailableEventFields: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiEventsApi();

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

my $api_instance = WWW::SwaggerClient::EventsApi->new();

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

# create an instance of the API class
api_instance = swagger_client.EventsApi()

try: 
    # Retrieves the available field names for searching or sorting events.
    api_response = api_instance.get_available_event_fields()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsApi->getAvailableEventFields: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


getEvent

Get a specific event


/events/{id}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/events/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EventsApi;

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

public class EventsApiExample {

    public static void main(String[] args) {
        
        EventsApi apiInstance = new EventsApi();
        String id = id_example; // String | The id of the event to retrieve
        try {
            Event result = apiInstance.getEvent(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#getEvent");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.EventsApi;

public class EventsApiExample {

    public static void main(String[] args) {
        EventsApi apiInstance = new EventsApi();
        String id = id_example; // String | The id of the event to retrieve
        try {
            Event result = apiInstance.getEvent(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#getEvent");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The id of the event to retrieve

EventsApi *apiInstance = [[EventsApi alloc] init];

// Get a specific event
[apiInstance getEventWith:id
              completionHandler: ^(Event output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.EventsApi()
var id = id_example; // {{String}} The id of the event to retrieve

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

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

            var apiInstance = new EventsApi();
            var id = id_example;  // String | The id of the event to retrieve

            try
            {
                // Get a specific event
                Event result = apiInstance.getEvent(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventsApi.getEvent: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiEventsApi();
$id = id_example; // String | The id of the event to retrieve

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

my $api_instance = WWW::SwaggerClient::EventsApi->new();
my $id = id_example; # String | The id of the event to retrieve

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

# create an instance of the API class
api_instance = swagger_client.EventsApi()
id = id_example # String | The id of the event to retrieve

try: 
    # Get a specific event
    api_response = api_instance.get_event(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsApi->getEvent: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The id of the event to retrieve
Required

Responses

Status: 200 - successful operation

Status: 404 - The specified resource could not be found.


getEvents

Get events


/events

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/events?pageNum=&rows=&sort=&filter="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EventsApi;

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

public class EventsApiExample {

    public static void main(String[] args) {
        
        EventsApi apiInstance = new EventsApi();
        Integer pageNum = 56; // Integer | 
        Integer rows = 56; // Integer | 
        array[String] sort = ; // array[String] | 
        array[String] filter = ; // array[String] | 
        try {
            ListContainer result = apiInstance.getEvents(pageNum, rows, sort, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#getEvents");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.EventsApi;

public class EventsApiExample {

    public static void main(String[] args) {
        EventsApi apiInstance = new EventsApi();
        Integer pageNum = 56; // Integer | 
        Integer rows = 56; // Integer | 
        array[String] sort = ; // array[String] | 
        array[String] filter = ; // array[String] | 
        try {
            ListContainer result = apiInstance.getEvents(pageNum, rows, sort, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#getEvents");
            e.printStackTrace();
        }
    }
}
Integer *pageNum = 56; //  (optional)
Integer *rows = 56; //  (optional)
array[String] *sort = ; //  (optional)
array[String] *filter = ; //  (optional)

EventsApi *apiInstance = [[EventsApi alloc] init];

// Get events
[apiInstance getEventsWith:pageNum
    rows:rows
    sort:sort
    filter:filter
              completionHandler: ^(ListContainer output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.EventsApi()
var opts = { 
  'pageNum': 56, // {{Integer}} 
  'rows': 56, // {{Integer}} 
  'sort': , // {{array[String]}} 
  'filter':  // {{array[String]}} 
};
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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EventsApi();
            var pageNum = 56;  // Integer |  (optional) 
            var rows = 56;  // Integer |  (optional) 
            var sort = new array[String](); // array[String] |  (optional) 
            var filter = new array[String](); // array[String] |  (optional) 

            try
            {
                // Get events
                ListContainer result = apiInstance.getEvents(pageNum, rows, sort, filter);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventsApi.getEvents: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiEventsApi();
$pageNum = 56; // Integer | 
$rows = 56; // Integer | 
$sort = ; // array[String] | 
$filter = ; // array[String] | 

try {
    $result = $api_instance->getEvents($pageNum, $rows, $sort, $filter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EventsApi->getEvents: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EventsApi;

my $api_instance = WWW::SwaggerClient::EventsApi->new();
my $pageNum = 56; # Integer | 
my $rows = 56; # Integer | 
my $sort = []; # array[String] | 
my $filter = []; # array[String] | 

eval { 
    my $result = $api_instance->getEvents(pageNum => $pageNum, rows => $rows, sort => $sort, filter => $filter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EventsApi->getEvents: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EventsApi()
pageNum = 56 # Integer |  (optional)
rows = 56 # Integer |  (optional)
sort =  # array[String] |  (optional)
filter =  # array[String] |  (optional)

try: 
    # Get events
    api_response = api_instance.get_events(pageNum=pageNum, rows=rows, sort=sort, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsApi->getEvents: %s\n" % e)

Parameters

Query parameters
Name Description
pageNum
Integer (int32)
rows
Integer (int32)
sort
array[String]
filter
array[String]

Responses

Status: 200 - successful operation


FlowDesigner

createConnection

Creates a connection in the given process group


/designer/flows/{flowId}/process-groups/{pgId}/connections

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/designer/flows/{flowId}/process-groups/{pgId}/connections"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDConnection body = ; // FDConnection | The configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDConnection result = apiInstance.createConnection(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createConnection");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDConnection body = ; // FDConnection | The configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDConnection result = apiInstance.createConnection(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createConnection");
            e.printStackTrace();
        }
    }
}
FDConnection *body = ; // The configuration details.
String *flowId = flowId_example; // 
String *pgId = pgId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Creates a connection in the given process group
[apiInstance createConnectionWith:body
    flowId:flowId
    pgId:pgId
              completionHandler: ^(FDConnection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var body = ; // {{FDConnection}} The configuration details.
var flowId = flowId_example; // {{String}} 
var pgId = pgId_example; // {{String}} 

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

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDConnection(); // FDConnection | The configuration details.
            var flowId = flowId_example;  // String | 
            var pgId = pgId_example;  // String | 

            try
            {
                // Creates a connection in the given process group
                FDConnection result = apiInstance.createConnection(body, flowId, pgId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.createConnection: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // FDConnection | The configuration details.
$flowId = flowId_example; // String | 
$pgId = pgId_example; // String | 

try {
    $result = $api_instance->createConnection($body, $flowId, $pgId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->createConnection: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $body = WWW::SwaggerClient::Object::FDConnection->new(); # FDConnection | The configuration details.
my $flowId = flowId_example; # String | 
my $pgId = pgId_example; # String | 

eval { 
    my $result = $api_instance->createConnection(body => $body, flowId => $flowId, pgId => $pgId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->createConnection: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
body =  # FDConnection | The configuration details.
flowId = flowId_example # String | 
pgId = pgId_example # String | 

try: 
    # Creates a connection in the given process group
    api_response = api_instance.create_connection(body, flowId, pgId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->createConnection: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required
pgId*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


createControllerService

Creates a controller service in the given process group


/designer/flows/{flowId}/process-groups/{pgId}/controller-services

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/designer/flows/{flowId}/process-groups/{pgId}/controller-services"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDControllerService body = ; // FDControllerService | The configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDControllerService result = apiInstance.createControllerService(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createControllerService");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDControllerService body = ; // FDControllerService | The configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDControllerService result = apiInstance.createControllerService(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createControllerService");
            e.printStackTrace();
        }
    }
}
FDControllerService *body = ; // The configuration details.
String *flowId = flowId_example; // 
String *pgId = pgId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Creates a controller service in the given process group
[apiInstance createControllerServiceWith:body
    flowId:flowId
    pgId:pgId
              completionHandler: ^(FDControllerService output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var body = ; // {{FDControllerService}} The configuration details.
var flowId = flowId_example; // {{String}} 
var pgId = pgId_example; // {{String}} 

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

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDControllerService(); // FDControllerService | The configuration details.
            var flowId = flowId_example;  // String | 
            var pgId = pgId_example;  // String | 

            try
            {
                // Creates a controller service in the given process group
                FDControllerService result = apiInstance.createControllerService(body, flowId, pgId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.createControllerService: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // FDControllerService | The configuration details.
$flowId = flowId_example; // String | 
$pgId = pgId_example; // String | 

try {
    $result = $api_instance->createControllerService($body, $flowId, $pgId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->createControllerService: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $body = WWW::SwaggerClient::Object::FDControllerService->new(); # FDControllerService | The configuration details.
my $flowId = flowId_example; # String | 
my $pgId = pgId_example; # String | 

eval { 
    my $result = $api_instance->createControllerService(body => $body, flowId => $flowId, pgId => $pgId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->createControllerService: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
body =  # FDControllerService | The configuration details.
flowId = flowId_example # String | 
pgId = pgId_example # String | 

try: 
    # Creates a controller service in the given process group
    api_response = api_instance.create_controller_service(body, flowId, pgId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->createControllerService: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required
pgId*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


createFunnel

Creates a funnel in the given process group


/designer/flows/{flowId}/process-groups/{pgId}/funnels

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/designer/flows/{flowId}/process-groups/{pgId}/funnels"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDFunnel body = ; // FDFunnel | The configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDFunnel result = apiInstance.createFunnel(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createFunnel");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDFunnel body = ; // FDFunnel | The configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDFunnel result = apiInstance.createFunnel(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createFunnel");
            e.printStackTrace();
        }
    }
}
FDFunnel *body = ; // The configuration details.
String *flowId = flowId_example; // 
String *pgId = pgId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Creates a funnel in the given process group
[apiInstance createFunnelWith:body
    flowId:flowId
    pgId:pgId
              completionHandler: ^(FDFunnel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var body = ; // {{FDFunnel}} The configuration details.
var flowId = flowId_example; // {{String}} 
var pgId = pgId_example; // {{String}} 

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

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDFunnel(); // FDFunnel | The configuration details.
            var flowId = flowId_example;  // String | 
            var pgId = pgId_example;  // String | 

            try
            {
                // Creates a funnel in the given process group
                FDFunnel result = apiInstance.createFunnel(body, flowId, pgId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.createFunnel: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // FDFunnel | The configuration details.
$flowId = flowId_example; // String | 
$pgId = pgId_example; // String | 

try {
    $result = $api_instance->createFunnel($body, $flowId, $pgId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->createFunnel: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $body = WWW::SwaggerClient::Object::FDFunnel->new(); # FDFunnel | The configuration details.
my $flowId = flowId_example; # String | 
my $pgId = pgId_example; # String | 

eval { 
    my $result = $api_instance->createFunnel(body => $body, flowId => $flowId, pgId => $pgId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->createFunnel: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
body =  # FDFunnel | The configuration details.
flowId = flowId_example # String | 
pgId = pgId_example # String | 

try: 
    # Creates a funnel in the given process group
    api_response = api_instance.create_funnel(body, flowId, pgId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->createFunnel: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required
pgId*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


createProcessor

Creates a processor in the given process group


/designer/flows/{flowId}/process-groups/{pgId}/processors

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/designer/flows/{flowId}/process-groups/{pgId}/processors"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDProcessor body = ; // FDProcessor | The processor configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDProcessor result = apiInstance.createProcessor(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createProcessor");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDProcessor body = ; // FDProcessor | The processor configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDProcessor result = apiInstance.createProcessor(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createProcessor");
            e.printStackTrace();
        }
    }
}
FDProcessor *body = ; // The processor configuration details.
String *flowId = flowId_example; // 
String *pgId = pgId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Creates a processor in the given process group
[apiInstance createProcessorWith:body
    flowId:flowId
    pgId:pgId
              completionHandler: ^(FDProcessor output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var body = ; // {{FDProcessor}} The processor configuration details.
var flowId = flowId_example; // {{String}} 
var pgId = pgId_example; // {{String}} 

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

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDProcessor(); // FDProcessor | The processor configuration details.
            var flowId = flowId_example;  // String | 
            var pgId = pgId_example;  // String | 

            try
            {
                // Creates a processor in the given process group
                FDProcessor result = apiInstance.createProcessor(body, flowId, pgId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.createProcessor: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // FDProcessor | The processor configuration details.
$flowId = flowId_example; // String | 
$pgId = pgId_example; // String | 

try {
    $result = $api_instance->createProcessor($body, $flowId, $pgId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->createProcessor: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $body = WWW::SwaggerClient::Object::FDProcessor->new(); # FDProcessor | The processor configuration details.
my $flowId = flowId_example; # String | 
my $pgId = pgId_example; # String | 

eval { 
    my $result = $api_instance->createProcessor(body => $body, flowId => $flowId, pgId => $pgId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->createProcessor: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
body =  # FDProcessor | The processor configuration details.
flowId = flowId_example # String | 
pgId = pgId_example # String | 

try: 
    # Creates a processor in the given process group
    api_response = api_instance.create_processor(body, flowId, pgId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->createProcessor: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required
pgId*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


createRemoteProcessGroup

Creates a remote process group in the given process group


/designer/flows/{flowId}/process-groups/{pgId}/remote-process-groups

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/designer/flows/{flowId}/process-groups/{pgId}/remote-process-groups"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDRemoteProcessGroup body = ; // FDRemoteProcessGroup | The configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDRemoteProcessGroup result = apiInstance.createRemoteProcessGroup(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createRemoteProcessGroup");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDRemoteProcessGroup body = ; // FDRemoteProcessGroup | The configuration details.
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDRemoteProcessGroup result = apiInstance.createRemoteProcessGroup(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#createRemoteProcessGroup");
            e.printStackTrace();
        }
    }
}
FDRemoteProcessGroup *body = ; // The configuration details.
String *flowId = flowId_example; // 
String *pgId = pgId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Creates a remote process group in the given process group
[apiInstance createRemoteProcessGroupWith:body
    flowId:flowId
    pgId:pgId
              completionHandler: ^(FDRemoteProcessGroup output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var body = ; // {{FDRemoteProcessGroup}} The configuration details.
var flowId = flowId_example; // {{String}} 
var pgId = pgId_example; // {{String}} 

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

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDRemoteProcessGroup(); // FDRemoteProcessGroup | The configuration details.
            var flowId = flowId_example;  // String | 
            var pgId = pgId_example;  // String | 

            try
            {
                // Creates a remote process group in the given process group
                FDRemoteProcessGroup result = apiInstance.createRemoteProcessGroup(body, flowId, pgId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.createRemoteProcessGroup: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // FDRemoteProcessGroup | The configuration details.
$flowId = flowId_example; // String | 
$pgId = pgId_example; // String | 

try {
    $result = $api_instance->createRemoteProcessGroup($body, $flowId, $pgId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->createRemoteProcessGroup: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $body = WWW::SwaggerClient::Object::FDRemoteProcessGroup->new(); # FDRemoteProcessGroup | The configuration details.
my $flowId = flowId_example; # String | 
my $pgId = pgId_example; # String | 

eval { 
    my $result = $api_instance->createRemoteProcessGroup(body => $body, flowId => $flowId, pgId => $pgId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->createRemoteProcessGroup: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
body =  # FDRemoteProcessGroup | The configuration details.
flowId = flowId_example # String | 
pgId = pgId_example # String | 

try: 
    # Creates a remote process group in the given process group
    api_response = api_instance.create_remote_process_group(body, flowId, pgId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->createRemoteProcessGroup: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required
pgId*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


deleteConnection

Deletes the connection with the given id in the given flow


/designer/flows/{flowId}/connections/{connectionId}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/connections/{connectionId}?version=&clientId="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String connectionId = connectionId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDConnection result = apiInstance.deleteConnection(flowId, connectionId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteConnection");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String connectionId = connectionId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDConnection result = apiInstance.deleteConnection(flowId, connectionId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteConnection");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 
String *connectionId = connectionId_example; // 
String *version = version_example; // The revision is used to verify the client is working with the latest version of the flow. (optional)
String *clientId = clientId_example; // If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Deletes the connection with the given id in the given flow
[apiInstance deleteConnectionWith:flowId
    connectionId:connectionId
    version:version
    clientId:clientId
              completionHandler: ^(FDConnection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var connectionId = connectionId_example; // {{String}} 
var opts = { 
  'version': version_example, // {{String}} The revision is used to verify the client is working with the latest version of the flow.
  'clientId': clientId_example // {{String}} If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteConnection(flowId, connectionId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var connectionId = connectionId_example;  // String | 
            var version = version_example;  // String | The revision is used to verify the client is working with the latest version of the flow. (optional) 
            var clientId = clientId_example;  // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional) 

            try
            {
                // Deletes the connection with the given id in the given flow
                FDConnection result = apiInstance.deleteConnection(flowId, connectionId, version, clientId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.deleteConnection: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$connectionId = connectionId_example; // String | 
$version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
$clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

try {
    $result = $api_instance->deleteConnection($flowId, $connectionId, $version, $clientId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->deleteConnection: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $connectionId = connectionId_example; # String | 
my $version = version_example; # String | The revision is used to verify the client is working with the latest version of the flow.
my $clientId = clientId_example; # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

eval { 
    my $result = $api_instance->deleteConnection(flowId => $flowId, connectionId => $connectionId, version => $version, clientId => $clientId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->deleteConnection: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
connectionId = connectionId_example # String | 
version = version_example # String | The revision is used to verify the client is working with the latest version of the flow. (optional)
clientId = clientId_example # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

try: 
    # Deletes the connection with the given id in the given flow
    api_response = api_instance.delete_connection(flowId, connectionId, version=version, clientId=clientId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->deleteConnection: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required
connectionId*
String
Required
Query parameters
Name Description
version
String
The revision is used to verify the client is working with the latest version of the flow.
clientId
String
If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

Responses

Status: 200 - successful operation


deleteControllerService

Deletes the controller service with the given id in the given flow


/designer/flows/{flowId}/controller-services/{controllerServiceId}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/controller-services/{controllerServiceId}?version=&clientId="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String controllerServiceId = controllerServiceId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDControllerService result = apiInstance.deleteControllerService(flowId, controllerServiceId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteControllerService");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String controllerServiceId = controllerServiceId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDControllerService result = apiInstance.deleteControllerService(flowId, controllerServiceId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteControllerService");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 
String *controllerServiceId = controllerServiceId_example; // 
String *version = version_example; // The revision is used to verify the client is working with the latest version of the flow. (optional)
String *clientId = clientId_example; // If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Deletes the controller service with the given id in the given flow
[apiInstance deleteControllerServiceWith:flowId
    controllerServiceId:controllerServiceId
    version:version
    clientId:clientId
              completionHandler: ^(FDControllerService output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var controllerServiceId = controllerServiceId_example; // {{String}} 
var opts = { 
  'version': version_example, // {{String}} The revision is used to verify the client is working with the latest version of the flow.
  'clientId': clientId_example // {{String}} If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteControllerService(flowId, controllerServiceId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var controllerServiceId = controllerServiceId_example;  // String | 
            var version = version_example;  // String | The revision is used to verify the client is working with the latest version of the flow. (optional) 
            var clientId = clientId_example;  // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional) 

            try
            {
                // Deletes the controller service with the given id in the given flow
                FDControllerService result = apiInstance.deleteControllerService(flowId, controllerServiceId, version, clientId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.deleteControllerService: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$controllerServiceId = controllerServiceId_example; // String | 
$version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
$clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

try {
    $result = $api_instance->deleteControllerService($flowId, $controllerServiceId, $version, $clientId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->deleteControllerService: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $controllerServiceId = controllerServiceId_example; # String | 
my $version = version_example; # String | The revision is used to verify the client is working with the latest version of the flow.
my $clientId = clientId_example; # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

eval { 
    my $result = $api_instance->deleteControllerService(flowId => $flowId, controllerServiceId => $controllerServiceId, version => $version, clientId => $clientId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->deleteControllerService: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
controllerServiceId = controllerServiceId_example # String | 
version = version_example # String | The revision is used to verify the client is working with the latest version of the flow. (optional)
clientId = clientId_example # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

try: 
    # Deletes the controller service with the given id in the given flow
    api_response = api_instance.delete_controller_service(flowId, controllerServiceId, version=version, clientId=clientId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->deleteControllerService: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required
controllerServiceId*
String
Required
Query parameters
Name Description
version
String
The revision is used to verify the client is working with the latest version of the flow.
clientId
String
If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

Responses

Status: 200 - successful operation


deleteFlow

Deletes the flow with the given id


/designer/flows/{flowId}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDFlowMetadata result = apiInstance.deleteFlow(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteFlow");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDFlowMetadata result = apiInstance.deleteFlow(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteFlow");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Deletes the flow with the given id
[apiInstance deleteFlowWith:flowId
              completionHandler: ^(FDFlowMetadata output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 

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

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Deletes the flow with the given id
                FDFlowMetadata result = apiInstance.deleteFlow(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.deleteFlow: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

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

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 

try: 
    # Deletes the flow with the given id
    api_response = api_instance.delete_flow(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->deleteFlow: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required

Responses

Status: 200 - successful operation


deleteFunnel

Deletes the funnel with the given id in the given flow


/designer/flows/{flowId}/funnels/{funnelId}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/funnels/{funnelId}?version=&clientId="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String funnelId = funnelId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDFunnel result = apiInstance.deleteFunnel(flowId, funnelId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteFunnel");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String funnelId = funnelId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDFunnel result = apiInstance.deleteFunnel(flowId, funnelId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteFunnel");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 
String *funnelId = funnelId_example; // 
String *version = version_example; // The revision is used to verify the client is working with the latest version of the flow. (optional)
String *clientId = clientId_example; // If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Deletes the funnel with the given id in the given flow
[apiInstance deleteFunnelWith:flowId
    funnelId:funnelId
    version:version
    clientId:clientId
              completionHandler: ^(FDFunnel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var funnelId = funnelId_example; // {{String}} 
var opts = { 
  'version': version_example, // {{String}} The revision is used to verify the client is working with the latest version of the flow.
  'clientId': clientId_example // {{String}} If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteFunnel(flowId, funnelId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var funnelId = funnelId_example;  // String | 
            var version = version_example;  // String | The revision is used to verify the client is working with the latest version of the flow. (optional) 
            var clientId = clientId_example;  // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional) 

            try
            {
                // Deletes the funnel with the given id in the given flow
                FDFunnel result = apiInstance.deleteFunnel(flowId, funnelId, version, clientId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.deleteFunnel: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$funnelId = funnelId_example; // String | 
$version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
$clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

try {
    $result = $api_instance->deleteFunnel($flowId, $funnelId, $version, $clientId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->deleteFunnel: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $funnelId = funnelId_example; # String | 
my $version = version_example; # String | The revision is used to verify the client is working with the latest version of the flow.
my $clientId = clientId_example; # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

eval { 
    my $result = $api_instance->deleteFunnel(flowId => $flowId, funnelId => $funnelId, version => $version, clientId => $clientId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->deleteFunnel: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
funnelId = funnelId_example # String | 
version = version_example # String | The revision is used to verify the client is working with the latest version of the flow. (optional)
clientId = clientId_example # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

try: 
    # Deletes the funnel with the given id in the given flow
    api_response = api_instance.delete_funnel(flowId, funnelId, version=version, clientId=clientId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->deleteFunnel: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required
funnelId*
String
Required
Query parameters
Name Description
version
String
The revision is used to verify the client is working with the latest version of the flow.
clientId
String
If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

Responses

Status: 200 - successful operation


deleteProcessor

Deletes the processor with the given id in the given flow


/designer/flows/{flowId}/processors/{processorId}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/processors/{processorId}?version=&clientId="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String processorId = processorId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDProcessor result = apiInstance.deleteProcessor(flowId, processorId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteProcessor");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String processorId = processorId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDProcessor result = apiInstance.deleteProcessor(flowId, processorId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteProcessor");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 
String *processorId = processorId_example; // 
String *version = version_example; // The revision is used to verify the client is working with the latest version of the flow. (optional)
String *clientId = clientId_example; // If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Deletes the processor with the given id in the given flow
[apiInstance deleteProcessorWith:flowId
    processorId:processorId
    version:version
    clientId:clientId
              completionHandler: ^(FDProcessor output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var processorId = processorId_example; // {{String}} 
var opts = { 
  'version': version_example, // {{String}} The revision is used to verify the client is working with the latest version of the flow.
  'clientId': clientId_example // {{String}} If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteProcessor(flowId, processorId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var processorId = processorId_example;  // String | 
            var version = version_example;  // String | The revision is used to verify the client is working with the latest version of the flow. (optional) 
            var clientId = clientId_example;  // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional) 

            try
            {
                // Deletes the processor with the given id in the given flow
                FDProcessor result = apiInstance.deleteProcessor(flowId, processorId, version, clientId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.deleteProcessor: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$processorId = processorId_example; // String | 
$version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
$clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

try {
    $result = $api_instance->deleteProcessor($flowId, $processorId, $version, $clientId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->deleteProcessor: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $processorId = processorId_example; # String | 
my $version = version_example; # String | The revision is used to verify the client is working with the latest version of the flow.
my $clientId = clientId_example; # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

eval { 
    my $result = $api_instance->deleteProcessor(flowId => $flowId, processorId => $processorId, version => $version, clientId => $clientId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->deleteProcessor: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
processorId = processorId_example # String | 
version = version_example # String | The revision is used to verify the client is working with the latest version of the flow. (optional)
clientId = clientId_example # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

try: 
    # Deletes the processor with the given id in the given flow
    api_response = api_instance.delete_processor(flowId, processorId, version=version, clientId=clientId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->deleteProcessor: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required
processorId*
String
Required
Query parameters
Name Description
version
String
The revision is used to verify the client is working with the latest version of the flow.
clientId
String
If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

Responses

Status: 200 - successful operation


deleteRemoteProcessGroup

Deletes the remote process group with the given id in the given flow


/designer/flows/{flowId}/remote-process-groups/{remoteProcessGroupId}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/remote-process-groups/{remoteProcessGroupId}?version=&clientId="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String remoteProcessGroupId = remoteProcessGroupId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDRemoteProcessGroup result = apiInstance.deleteRemoteProcessGroup(flowId, remoteProcessGroupId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteRemoteProcessGroup");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String remoteProcessGroupId = remoteProcessGroupId_example; // String | 
        String version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
        String clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
        try {
            FDRemoteProcessGroup result = apiInstance.deleteRemoteProcessGroup(flowId, remoteProcessGroupId, version, clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#deleteRemoteProcessGroup");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 
String *remoteProcessGroupId = remoteProcessGroupId_example; // 
String *version = version_example; // The revision is used to verify the client is working with the latest version of the flow. (optional)
String *clientId = clientId_example; // If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Deletes the remote process group with the given id in the given flow
[apiInstance deleteRemoteProcessGroupWith:flowId
    remoteProcessGroupId:remoteProcessGroupId
    version:version
    clientId:clientId
              completionHandler: ^(FDRemoteProcessGroup output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var remoteProcessGroupId = remoteProcessGroupId_example; // {{String}} 
var opts = { 
  'version': version_example, // {{String}} The revision is used to verify the client is working with the latest version of the flow.
  'clientId': clientId_example // {{String}} If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteRemoteProcessGroup(flowId, remoteProcessGroupId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var remoteProcessGroupId = remoteProcessGroupId_example;  // String | 
            var version = version_example;  // String | The revision is used to verify the client is working with the latest version of the flow. (optional) 
            var clientId = clientId_example;  // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional) 

            try
            {
                // Deletes the remote process group with the given id in the given flow
                FDRemoteProcessGroup result = apiInstance.deleteRemoteProcessGroup(flowId, remoteProcessGroupId, version, clientId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.deleteRemoteProcessGroup: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$remoteProcessGroupId = remoteProcessGroupId_example; // String | 
$version = version_example; // String | The revision is used to verify the client is working with the latest version of the flow.
$clientId = clientId_example; // String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

try {
    $result = $api_instance->deleteRemoteProcessGroup($flowId, $remoteProcessGroupId, $version, $clientId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->deleteRemoteProcessGroup: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $remoteProcessGroupId = remoteProcessGroupId_example; # String | 
my $version = version_example; # String | The revision is used to verify the client is working with the latest version of the flow.
my $clientId = clientId_example; # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

eval { 
    my $result = $api_instance->deleteRemoteProcessGroup(flowId => $flowId, remoteProcessGroupId => $remoteProcessGroupId, version => $version, clientId => $clientId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->deleteRemoteProcessGroup: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
remoteProcessGroupId = remoteProcessGroupId_example # String | 
version = version_example # String | The revision is used to verify the client is working with the latest version of the flow. (optional)
clientId = clientId_example # String | If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response. (optional)

try: 
    # Deletes the remote process group with the given id in the given flow
    api_response = api_instance.delete_remote_process_group(flowId, remoteProcessGroupId, version=version, clientId=clientId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->deleteRemoteProcessGroup: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required
remoteProcessGroupId*
String
Required
Query parameters
Name Description
version
String
The revision is used to verify the client is working with the latest version of the flow.
clientId
String
If the client id is not specified, new one will be generated. This value (whether specified or generated) is included in the response.

Responses

Status: 200 - successful operation


getClientId

Gets a client id to use with the designer endpoints


/designer/client-id

Usage and SDK Samples

curl -X GET\
-H "Accept: text/plain"\
"/efm/api/designer/client-id"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        try {
            'String' result = apiInstance.getClientId();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getClientId");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        try {
            'String' result = apiInstance.getClientId();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getClientId");
            e.printStackTrace();
        }
    }
}

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Gets a client id to use with the designer endpoints
[apiInstance getClientIdWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getClientId(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();

            try
            {
                // Gets a client id to use with the designer endpoints
                'String' result = apiInstance.getClientId();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getClientId: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();

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

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()

try: 
    # Gets a client id to use with the designer endpoints
    api_response = api_instance.get_client_id()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getClientId: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


getConnection

Retrieves the connection with the given id in the given flow


/designer/flows/{flowId}/connections/{connectionId}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/connections/{connectionId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String connectionId = connectionId_example; // String | 
        try {
            FDConnection result = apiInstance.getConnection(flowId, connectionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getConnection");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String connectionId = connectionId_example; // String | 
        try {
            FDConnection result = apiInstance.getConnection(flowId, connectionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getConnection");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 
String *connectionId = connectionId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Retrieves the connection with the given id in the given flow
[apiInstance getConnectionWith:flowId
    connectionId:connectionId
              completionHandler: ^(FDConnection output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var connectionId = connectionId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getConnection(flowId, connectionId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var connectionId = connectionId_example;  // String | 

            try
            {
                // Retrieves the connection with the given id in the given flow
                FDConnection result = apiInstance.getConnection(flowId, connectionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getConnection: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$connectionId = connectionId_example; // String | 

try {
    $result = $api_instance->getConnection($flowId, $connectionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->getConnection: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $connectionId = connectionId_example; # String | 

eval { 
    my $result = $api_instance->getConnection(flowId => $flowId, connectionId => $connectionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getConnection: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
connectionId = connectionId_example # String | 

try: 
    # Retrieves the connection with the given id in the given flow
    api_response = api_instance.get_connection(flowId, connectionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getConnection: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required
connectionId*
String
Required

Responses

Status: 200 - successful operation


getControllerService

Retrieves the controller service with the given id in the given flow


/designer/flows/{flowId}/controller-services/{controllerServiceId}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/controller-services/{controllerServiceId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String controllerServiceId = controllerServiceId_example; // String | 
        try {
            FDControllerService result = apiInstance.getControllerService(flowId, controllerServiceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getControllerService");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String controllerServiceId = controllerServiceId_example; // String | 
        try {
            FDControllerService result = apiInstance.getControllerService(flowId, controllerServiceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getControllerService");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 
String *controllerServiceId = controllerServiceId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Retrieves the controller service with the given id in the given flow
[apiInstance getControllerServiceWith:flowId
    controllerServiceId:controllerServiceId
              completionHandler: ^(FDControllerService output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var controllerServiceId = controllerServiceId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getControllerService(flowId, controllerServiceId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var controllerServiceId = controllerServiceId_example;  // String | 

            try
            {
                // Retrieves the controller service with the given id in the given flow
                FDControllerService result = apiInstance.getControllerService(flowId, controllerServiceId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getControllerService: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$controllerServiceId = controllerServiceId_example; // String | 

try {
    $result = $api_instance->getControllerService($flowId, $controllerServiceId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->getControllerService: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $controllerServiceId = controllerServiceId_example; # String | 

eval { 
    my $result = $api_instance->getControllerService(flowId => $flowId, controllerServiceId => $controllerServiceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getControllerService: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
controllerServiceId = controllerServiceId_example # String | 

try: 
    # Retrieves the controller service with the given id in the given flow
    api_response = api_instance.get_controller_service(flowId, controllerServiceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getControllerService: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required
controllerServiceId*
String
Required

Responses

Status: 200 - successful operation


getControllerServicePropertyDescriptor

Retrieves the property descriptor with the given name for the given service in the given flow


/designer/flows/{flowId}/controller-services/{controllerServiceId}/descriptors/{propertyName}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/controller-services/{controllerServiceId}/descriptors/{propertyName}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String controllerServiceId = controllerServiceId_example; // String | 
        String propertyName = propertyName_example; // String | 
        try {
            FDPropertyDescriptor result = apiInstance.getControllerServicePropertyDescriptor(flowId, controllerServiceId, propertyName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getControllerServicePropertyDescriptor");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String controllerServiceId = controllerServiceId_example; // String | 
        String propertyName = propertyName_example; // String | 
        try {
            FDPropertyDescriptor result = apiInstance.getControllerServicePropertyDescriptor(flowId, controllerServiceId, propertyName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getControllerServicePropertyDescriptor");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 
String *controllerServiceId = controllerServiceId_example; // 
String *propertyName = propertyName_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Retrieves the property descriptor with the given name for the given service in the given flow
[apiInstance getControllerServicePropertyDescriptorWith:flowId
    controllerServiceId:controllerServiceId
    propertyName:propertyName
              completionHandler: ^(FDPropertyDescriptor output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var controllerServiceId = controllerServiceId_example; // {{String}} 
var propertyName = propertyName_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getControllerServicePropertyDescriptor(flowId, controllerServiceId, propertyName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var controllerServiceId = controllerServiceId_example;  // String | 
            var propertyName = propertyName_example;  // String | 

            try
            {
                // Retrieves the property descriptor with the given name for the given service in the given flow
                FDPropertyDescriptor result = apiInstance.getControllerServicePropertyDescriptor(flowId, controllerServiceId, propertyName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getControllerServicePropertyDescriptor: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$controllerServiceId = controllerServiceId_example; // String | 
$propertyName = propertyName_example; // String | 

try {
    $result = $api_instance->getControllerServicePropertyDescriptor($flowId, $controllerServiceId, $propertyName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->getControllerServicePropertyDescriptor: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $controllerServiceId = controllerServiceId_example; # String | 
my $propertyName = propertyName_example; # String | 

eval { 
    my $result = $api_instance->getControllerServicePropertyDescriptor(flowId => $flowId, controllerServiceId => $controllerServiceId, propertyName => $propertyName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getControllerServicePropertyDescriptor: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
controllerServiceId = controllerServiceId_example # String | 
propertyName = propertyName_example # String | 

try: 
    # Retrieves the property descriptor with the given name for the given service in the given flow
    api_response = api_instance.get_controller_service_property_descriptor(flowId, controllerServiceId, propertyName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getControllerServicePropertyDescriptor: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required
controllerServiceId*
String
Required
propertyName*
String
Required

Responses

Status: 200 - successful operation


getControllerServiceTypes

Gets the available controller service types for the given flow


/designer/flows/{flowId}/types/controller-services

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/types/controller-services"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDComponentTypes result = apiInstance.getControllerServiceTypes(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getControllerServiceTypes");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDComponentTypes result = apiInstance.getControllerServiceTypes(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getControllerServiceTypes");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Gets the available controller service types for the given flow
[apiInstance getControllerServiceTypesWith:flowId
              completionHandler: ^(FDComponentTypes output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 

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

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Gets the available controller service types for the given flow
                FDComponentTypes result = apiInstance.getControllerServiceTypes(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getControllerServiceTypes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

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

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 

try: 
    # Gets the available controller service types for the given flow
    api_response = api_instance.get_controller_service_types(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getControllerServiceTypes: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required

Responses

Status: 200 - successful operation


getControllerServices

Retrieves the controller service with the given id in the given flow


/designer/flows/{flowId}/process-groups/{pgId}/controller-services

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/process-groups/{pgId}/controller-services"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            ListContainer result = apiInstance.getControllerServices(flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getControllerServices");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            ListContainer result = apiInstance.getControllerServices(flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getControllerServices");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 
String *pgId = pgId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Retrieves the controller service with the given id in the given flow
[apiInstance getControllerServicesWith:flowId
    pgId:pgId
              completionHandler: ^(ListContainer output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 
var pgId = pgId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getControllerServices(flowId, pgId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var pgId = pgId_example;  // String | 

            try
            {
                // Retrieves the controller service with the given id in the given flow
                ListContainer result = apiInstance.getControllerServices(flowId, pgId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getControllerServices: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$pgId = pgId_example; // String | 

try {
    $result = $api_instance->getControllerServices($flowId, $pgId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->getControllerServices: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 
my $pgId = pgId_example; # String | 

eval { 
    my $result = $api_instance->getControllerServices(flowId => $flowId, pgId => $pgId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getControllerServices: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 
pgId = pgId_example # String | 

try: 
    # Retrieves the controller service with the given id in the given flow
    api_response = api_instance.get_controller_services(flowId, pgId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getControllerServices: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required
pgId*
String
Required

Responses

Status: 200 - successful operation


getELSpecification

Gets the expression language specification for the agent class of the given flow


/designer/flows/{flowId}/expression-language-spec

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/expression-language-spec"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            ELSpecification result = apiInstance.getELSpecification(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getELSpecification");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            ELSpecification result = apiInstance.getELSpecification(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getELSpecification");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Gets the expression language specification for the agent class of the given flow
[apiInstance getELSpecificationWith:flowId
              completionHandler: ^(ELSpecification output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 

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

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Gets the expression language specification for the agent class of the given flow
                ELSpecification result = apiInstance.getELSpecification(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getELSpecification: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

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

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 

try: 
    # Gets the expression language specification for the agent class of the given flow
    api_response = api_instance.get_el_specification(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getELSpecification: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required

Responses

Status: 200 - successful operation


getFlow

Gets the flow with the given id


/designer/flows/{flowId}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDFlow result = apiInstance.getFlow(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlow");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDFlow result = apiInstance.getFlow(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlow");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Gets the flow with the given id
[apiInstance getFlowWith:flowId
              completionHandler: ^(FDFlow output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 

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

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Gets the flow with the given id
                FDFlow result = apiInstance.getFlow(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getFlow: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

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

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 

try: 
    # Gets the flow with the given id
    api_response = api_instance.get_flow(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getFlow: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required

Responses

Status: 200 - successful operation


getFlowEvents

Gets the flow events for the flow with the given id


/designer/flows/{flowId}/events

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/events"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            ListContainer result = apiInstance.getFlowEvents(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowEvents");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            ListContainer result = apiInstance.getFlowEvents(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowEvents");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Gets the flow events for the flow with the given id
[apiInstance getFlowEventsWith:flowId
              completionHandler: ^(ListContainer output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 

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

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Gets the flow events for the flow with the given id
                ListContainer result = apiInstance.getFlowEvents(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getFlowEvents: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

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

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 

try: 
    # Gets the flow events for the flow with the given id
    api_response = api_instance.get_flow_events(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getFlowEvents: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required

Responses

Status: 200 - successful operation


getFlowMetadata

Gets the flow metadata for the flow with the given id


/designer/flows/{flowId}/metadata

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/metadata"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDFlowMetadata result = apiInstance.getFlowMetadata(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowMetadata");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDFlowMetadata result = apiInstance.getFlowMetadata(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowMetadata");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Gets the flow metadata for the flow with the given id
[apiInstance getFlowMetadataWith:flowId
              completionHandler: ^(FDFlowMetadata output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 

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

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Gets the flow metadata for the flow with the given id
                FDFlowMetadata result = apiInstance.getFlowMetadata(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getFlowMetadata: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

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

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 

try: 
    # Gets the flow metadata for the flow with the given id
    api_response = api_instance.get_flow_metadata(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getFlowMetadata: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required

Responses

Status: 200 - successful operation


getFlowSummaries

Gets the summaries of the available flows known to the flow designer


/designer/flows/summaries

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/summaries"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        try {
            ListContainer result = apiInstance.getFlowSummaries();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowSummaries");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        try {
            ListContainer result = apiInstance.getFlowSummaries();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowSummaries");
            e.printStackTrace();
        }
    }
}

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Gets the summaries of the available flows known to the flow designer
[apiInstance getFlowSummariesWithCompletionHandler: 
              ^(ListContainer output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getFlowSummaries(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();

            try
            {
                // Gets the summaries of the available flows known to the flow designer
                ListContainer result = apiInstance.getFlowSummaries();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getFlowSummaries: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();

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

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()

try: 
    # Gets the summaries of the available flows known to the flow designer
    api_response = api_instance.get_flow_summaries()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getFlowSummaries: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


getFlowVersionInfo

Gets the version info for the flow with the given id


/designer/flows/{flowId}/version-info

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/version-info"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDVersionInfoResult result = apiInstance.getFlowVersionInfo(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowVersionInfo");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDVersionInfoResult result = apiInstance.getFlowVersionInfo(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowVersionInfo");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Gets the version info for the flow with the given id
[apiInstance getFlowVersionInfoWith:flowId
              completionHandler: ^(FDVersionInfoResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 

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

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Gets the version info for the flow with the given id
                FDVersionInfoResult result = apiInstance.getFlowVersionInfo(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getFlowVersionInfo: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

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

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 

try: 
    # Gets the version info for the flow with the given id
    api_response = api_instance.get_flow_version_info(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getFlowVersionInfo: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required

Responses

Status: 200 - successful operation


getFlows

Gets the available flows known to the flow designer


/designer/flows

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        try {
            ListContainer result = apiInstance.getFlows();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlows");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        try {
            ListContainer result = apiInstance.getFlows();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlows");
            e.printStackTrace();
        }
    }
}

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Gets the available flows known to the flow designer
[apiInstance getFlowsWithCompletionHandler: 
              ^(ListContainer output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getFlows(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();

            try
            {
                // Gets the available flows known to the flow designer
                ListContainer result = apiInstance.getFlows();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getFlows: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();

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

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();

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

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()

try: 
    # Gets the available flows known to the flow designer
    api_response = api_instance.get_flows()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getFlows: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation