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

Schema

AgentClasses

createAgentClass

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

Agents

createAgent

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

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

Schema

getFunnel

Retrieves the funnel with the given id in the given flow

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

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/funnels/{funnelId}"

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 | 
        try {
            FDFunnel result = apiInstance.getFunnel(flowId, funnelId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFunnel");
            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 | 
        try {
            FDFunnel result = apiInstance.getFunnel(flowId, funnelId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFunnel");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *funnelId = funnelId_example; // 

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

// Retrieves the funnel with the given id in the given flow
[apiInstance getFunnelWith:flowId
    funnelId:funnelId
              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 callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getFunnel(flowId, funnelId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            try
            {
                // Retrieves the funnel with the given id in the given flow
                FDFunnel result = apiInstance.getFunnel(flowId, funnelId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getFunnel: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getFunnel($flowId, $funnelId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->getFunnel: ', $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 | 

eval { 
    my $result = $api_instance->getFunnel(flowId => $flowId, funnelId => $funnelId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getFunnel: $@\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 | 

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

Parameters

Path parameters

Name	Description
flowId*	String Required
funnelId*	String Required

Responses

Status: 200 - successful operation

Schema

getProcessGroup

Retrieves the process group with the given id in the given flow. The alias of 'root' may be used to retrieve the root process group for the given flow.

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

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/process-groups/{pgId}?includeChildren="

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 | 
        Boolean includeChildren = true; // Boolean | 
        try {
            FDProcessGroupFlow result = apiInstance.getProcessGroup(flowId, pgId, includeChildren);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getProcessGroup");
            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 | 
        Boolean includeChildren = true; // Boolean | 
        try {
            FDProcessGroupFlow result = apiInstance.getProcessGroup(flowId, pgId, includeChildren);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getProcessGroup");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *pgId = pgId_example; // 
Boolean *includeChildren = true; //  (optional)

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

// Retrieves the process group with the given id in the given flow. The alias of 'root' may be used to retrieve the root process group for the given flow.
[apiInstance getProcessGroupWith:flowId
    pgId:pgId
    includeChildren:includeChildren
              completionHandler: ^(FDProcessGroupFlow 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 opts = { 
  'includeChildren': true // {{Boolean}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getProcessGroup(flowId, pgId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var pgId = pgId_example;  // String | 
            var includeChildren = true;  // Boolean |  (optional) 

            try
            {
                // Retrieves the process group with the given id in the given flow. The alias of 'root' may be used to retrieve the root process group for the given flow.
                FDProcessGroupFlow result = apiInstance.getProcessGroup(flowId, pgId, includeChildren);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getProcessGroup: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getProcessGroup($flowId, $pgId, $includeChildren);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->getProcessGroup: ', $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 | 
my $includeChildren = true; # Boolean | 

eval { 
    my $result = $api_instance->getProcessGroup(flowId => $flowId, pgId => $pgId, includeChildren => $includeChildren);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getProcessGroup: $@\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 | 
includeChildren = true # Boolean |  (optional)

try: 
    # Retrieves the process group with the given id in the given flow. The alias of 'root' may be used to retrieve the root process group for the given flow.
    api_response = api_instance.get_process_group(flowId, pgId, includeChildren=includeChildren)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getProcessGroup: %s\n" % e)

Parameters

Path parameters

Name	Description
flowId*	String Required
pgId*	String Required

Query parameters

Name	Description
includeChildren	Boolean

Responses

Status: 200 - successful operation

Schema

getProcessor

Retrieves the processor with the given id in the given flow

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

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/processors/{processorId}"

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 | 
        try {
            FDProcessor result = apiInstance.getProcessor(flowId, processorId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getProcessor");
            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 | 
        try {
            FDProcessor result = apiInstance.getProcessor(flowId, processorId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getProcessor");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *processorId = processorId_example; // 

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

// Retrieves the processor with the given id in the given flow
[apiInstance getProcessorWith:flowId
    processorId:processorId
              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 callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getProcessor(flowId, processorId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            try
            {
                // Retrieves the processor with the given id in the given flow
                FDProcessor result = apiInstance.getProcessor(flowId, processorId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getProcessor: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getProcessor($flowId, $processorId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->getProcessor: ', $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 | 

eval { 
    my $result = $api_instance->getProcessor(flowId => $flowId, processorId => $processorId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getProcessor: $@\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 | 

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

Parameters

Path parameters

Name	Description
flowId*	String Required
processorId*	String Required

Responses

Status: 200 - successful operation

Schema

getProcessorPropertyDescriptor

Retrieves the property descriptor with the given name from the given processor in the given flow

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

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/processors/{processorId}/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 processorId = processorId_example; // String | 
        String propertyName = propertyName_example; // String | 
        try {
            FDPropertyDescriptor result = apiInstance.getProcessorPropertyDescriptor(flowId, processorId, propertyName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getProcessorPropertyDescriptor");
            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 propertyName = propertyName_example; // String | 
        try {
            FDPropertyDescriptor result = apiInstance.getProcessorPropertyDescriptor(flowId, processorId, propertyName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getProcessorPropertyDescriptor");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *processorId = processorId_example; // 
String *propertyName = propertyName_example; // 

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

// Retrieves the property descriptor with the given name from the given processor in the given flow
[apiInstance getProcessorPropertyDescriptorWith:flowId
    processorId:processorId
    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 processorId = processorId_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.getProcessorPropertyDescriptor(flowId, processorId, propertyName, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var processorId = processorId_example;  // String | 
            var propertyName = propertyName_example;  // String | 

            try
            {
                // Retrieves the property descriptor with the given name from the given processor in the given flow
                FDPropertyDescriptor result = apiInstance.getProcessorPropertyDescriptor(flowId, processorId, propertyName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getProcessorPropertyDescriptor: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getProcessorPropertyDescriptor($flowId, $processorId, $propertyName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->getProcessorPropertyDescriptor: ', $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 $propertyName = propertyName_example; # String | 

eval { 
    my $result = $api_instance->getProcessorPropertyDescriptor(flowId => $flowId, processorId => $processorId, propertyName => $propertyName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getProcessorPropertyDescriptor: $@\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 | 
propertyName = propertyName_example # String | 

try: 
    # Retrieves the property descriptor with the given name from the given processor in the given flow
    api_response = api_instance.get_processor_property_descriptor(flowId, processorId, propertyName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getProcessorPropertyDescriptor: %s\n" % e)

Parameters

Path parameters

Name	Description
flowId*	String Required
processorId*	String Required
propertyName*	String Required

Responses

Status: 200 - successful operation

Schema

getProcessorTypes

Gets the available processor types for the given flow

/designer/flows/{flowId}/types/processors

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/types/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();
        String flowId = flowId_example; // String | 
        try {
            FDComponentTypes result = apiInstance.getProcessorTypes(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getProcessorTypes");
            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.getProcessorTypes(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getProcessorTypes");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 

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

// Gets the available processor types for the given flow
[apiInstance getProcessorTypesWith: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.getProcessorTypes(flowId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            try
            {
                // Gets the available processor types for the given flow
                FDComponentTypes result = apiInstance.getProcessorTypes(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getProcessorTypes: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getProcessorTypes($flowId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->getProcessorTypes: ', $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->getProcessorTypes(flowId => $flowId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getProcessorTypes: $@\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 processor types for the given flow
    api_response = api_instance.get_processor_types(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getProcessorTypes: %s\n" % e)

Parameters

Path parameters

Name	Description
flowId*	String Required

Responses

Status: 200 - successful operation

Schema

getRemoteProcessGroup

Retrieves 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 GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/remote-process-groups/{remoteProcessGroupId}"

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 | 
        try {
            FDRemoteProcessGroup result = apiInstance.getRemoteProcessGroup(flowId, remoteProcessGroupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getRemoteProcessGroup");
            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 | 
        try {
            FDRemoteProcessGroup result = apiInstance.getRemoteProcessGroup(flowId, remoteProcessGroupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getRemoteProcessGroup");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
String *remoteProcessGroupId = remoteProcessGroupId_example; // 

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

// Retrieves the remote process group with the given id in the given flow
[apiInstance getRemoteProcessGroupWith:flowId
    remoteProcessGroupId:remoteProcessGroupId
              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 callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getRemoteProcessGroup(flowId, remoteProcessGroupId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            try
            {
                // Retrieves the remote process group with the given id in the given flow
                FDRemoteProcessGroup result = apiInstance.getRemoteProcessGroup(flowId, remoteProcessGroupId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getRemoteProcessGroup: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getRemoteProcessGroup($flowId, $remoteProcessGroupId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->getRemoteProcessGroup: ', $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 | 

eval { 
    my $result = $api_instance->getRemoteProcessGroup(flowId => $flowId, remoteProcessGroupId => $remoteProcessGroupId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getRemoteProcessGroup: $@\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 | 

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

Parameters

Path parameters

Name	Description
flowId*	String Required
remoteProcessGroupId*	String Required

Responses

Status: 200 - successful operation

Schema

publishFlow

Publishes the current state of the flow to NiFi Registry

/designer/flows/{flowId}/publish

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/designer/flows/{flowId}/publish"

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 | 
        FDFlowPublishMetadata body = ; // FDFlowPublishMetadata | The metadata for publishing the flow, such as comments
        try {
            FDVersionInfo result = apiInstance.publishFlow(flowId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#publishFlow");
            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 | 
        FDFlowPublishMetadata body = ; // FDFlowPublishMetadata | The metadata for publishing the flow, such as comments
        try {
            FDVersionInfo result = apiInstance.publishFlow(flowId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#publishFlow");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 
FDFlowPublishMetadata *body = ; // The metadata for publishing the flow, such as comments (optional)

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

// Publishes the current state of the flow to NiFi Registry
[apiInstance publishFlowWith:flowId
    body:body
              completionHandler: ^(FDVersionInfo 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 opts = { 
  'body':  // {{FDFlowPublishMetadata}} The metadata for publishing the flow, such as comments
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.publishFlow(flowId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 
            var body = new FDFlowPublishMetadata(); // FDFlowPublishMetadata | The metadata for publishing the flow, such as comments (optional) 

            try
            {
                // Publishes the current state of the flow to NiFi Registry
                FDVersionInfo result = apiInstance.publishFlow(flowId, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.publishFlow: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 
$body = ; // FDFlowPublishMetadata | The metadata for publishing the flow, such as comments

try {
    $result = $api_instance->publishFlow($flowId, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->publishFlow: ', $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 $body = WWW::SwaggerClient::Object::FDFlowPublishMetadata->new(); # FDFlowPublishMetadata | The metadata for publishing the flow, such as comments

eval { 
    my $result = $api_instance->publishFlow(flowId => $flowId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->publishFlow: $@\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 | 
body =  # FDFlowPublishMetadata | The metadata for publishing the flow, such as comments (optional)

try: 
    # Publishes the current state of the flow to NiFi Registry
    api_response = api_instance.publish_flow(flowId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->publishFlow: %s\n" % e)

Parameters

Path parameters

Name	Description
flowId*	String Required

Body parameters

Name	Description
body

Responses

Status: 200 - successful operation

Schema

revertFlow

Reverts the current state of the flow to the last published version. If the flow has never been published, or has no changes to publish, then this will be a no-op.

/designer/flows/{flowId}/revert

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/revert"

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 {
            FDVersionInfo result = apiInstance.revertFlow(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#revertFlow");
            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 {
            FDVersionInfo result = apiInstance.revertFlow(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#revertFlow");
            e.printStackTrace();
        }
    }
}

String *flowId = flowId_example; // 

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

// Reverts the current state of the flow to the last published version. If the flow has never been published, or has no changes to publish, then this will be a no-op.
[apiInstance revertFlowWith:flowId
              completionHandler: ^(FDVersionInfo 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.revertFlow(flowId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            try
            {
                // Reverts the current state of the flow to the last published version. If the flow has never been published, or has no changes to publish, then this will be a no-op.
                FDVersionInfo result = apiInstance.revertFlow(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.revertFlow: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->revertFlow($flowId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->revertFlow: ', $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->revertFlow(flowId => $flowId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->revertFlow: $@\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: 
    # Reverts the current state of the flow to the last published version. If the flow has never been published, or has no changes to publish, then this will be a no-op.
    api_response = api_instance.revert_flow(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->revertFlow: %s\n" % e)

Parameters

Path parameters

Name	Description
flowId*	String Required

Responses

Status: 200 - successful operation

Schema

updateConnection

Updates the connection with the given id in the given flow

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

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: 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();
        FDConnection body = ; // FDConnection | The connection configuration details.
        String flowId = flowId_example; // String | 
        String connectionId = connectionId_example; // String | 
        try {
            FDConnection result = apiInstance.updateConnection(body, flowId, connectionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateConnection");
            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 connection configuration details.
        String flowId = flowId_example; // String | 
        String connectionId = connectionId_example; // String | 
        try {
            FDConnection result = apiInstance.updateConnection(body, flowId, connectionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateConnection");
            e.printStackTrace();
        }
    }
}

FDConnection *body = ; // The connection configuration details.
String *flowId = flowId_example; // 
String *connectionId = connectionId_example; // 

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

// Updates the connection with the given id in the given flow
[apiInstance updateConnectionWith:body
    flowId: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 body = ; // {{FDConnection}} The connection configuration details.
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.updateConnection(bodyflowIdconnectionId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDConnection(); // FDConnection | The connection configuration details.
            var flowId = flowId_example;  // String | 
            var connectionId = connectionId_example;  // String | 

            try
            {
                // Updates the connection with the given id in the given flow
                FDConnection result = apiInstance.updateConnection(body, flowId, connectionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.updateConnection: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->updateConnection($body, $flowId, $connectionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->updateConnection: ', $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 connection configuration details.
my $flowId = flowId_example; # String | 
my $connectionId = connectionId_example; # String | 

eval { 
    my $result = $api_instance->updateConnection(body => $body, flowId => $flowId, connectionId => $connectionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->updateConnection: $@\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 connection configuration details.
flowId = flowId_example # String | 
connectionId = connectionId_example # String | 

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

Parameters

Path parameters

Name	Description
flowId*	String Required
connectionId*	String Required

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

updateControllerService

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

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

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: 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();
        FDControllerService body = ; // FDControllerService | The controller service configuration details.
        String flowId = flowId_example; // String | 
        String controllerServiceId = controllerServiceId_example; // String | 
        try {
            FDControllerService result = apiInstance.updateControllerService(body, flowId, controllerServiceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateControllerService");
            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 controller service configuration details.
        String flowId = flowId_example; // String | 
        String controllerServiceId = controllerServiceId_example; // String | 
        try {
            FDControllerService result = apiInstance.updateControllerService(body, flowId, controllerServiceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateControllerService");
            e.printStackTrace();
        }
    }
}

FDControllerService *body = ; // The controller service configuration details.
String *flowId = flowId_example; // 
String *controllerServiceId = controllerServiceId_example; // 

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

// Updates the controller service with the given id in the given flow
[apiInstance updateControllerServiceWith:body
    flowId: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 body = ; // {{FDControllerService}} The controller service configuration details.
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.updateControllerService(bodyflowIdcontrollerServiceId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDControllerService(); // FDControllerService | The controller service configuration details.
            var flowId = flowId_example;  // String | 
            var controllerServiceId = controllerServiceId_example;  // String | 

            try
            {
                // Updates the controller service with the given id in the given flow
                FDControllerService result = apiInstance.updateControllerService(body, flowId, controllerServiceId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.updateControllerService: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // FDControllerService | The controller service configuration details.
$flowId = flowId_example; // String | 
$controllerServiceId = controllerServiceId_example; // String | 

try {
    $result = $api_instance->updateControllerService($body, $flowId, $controllerServiceId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->updateControllerService: ', $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 controller service configuration details.
my $flowId = flowId_example; # String | 
my $controllerServiceId = controllerServiceId_example; # String | 

eval { 
    my $result = $api_instance->updateControllerService(body => $body, flowId => $flowId, controllerServiceId => $controllerServiceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->updateControllerService: $@\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 controller service configuration details.
flowId = flowId_example # String | 
controllerServiceId = controllerServiceId_example # String | 

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

Parameters

Path parameters

Name	Description
flowId*	String Required
controllerServiceId*	String Required

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

updateFunnel

Updates the funnel with the given id in the given flow

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

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/designer/flows/{flowId}/funnels/{funnelId}"

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 funnel configuration details.
        String flowId = flowId_example; // String | 
        String funnelId = funnelId_example; // String | 
        try {
            FDFunnel result = apiInstance.updateFunnel(body, flowId, funnelId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateFunnel");
            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 funnel configuration details.
        String flowId = flowId_example; // String | 
        String funnelId = funnelId_example; // String | 
        try {
            FDFunnel result = apiInstance.updateFunnel(body, flowId, funnelId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateFunnel");
            e.printStackTrace();
        }
    }
}

FDFunnel *body = ; // The funnel configuration details.
String *flowId = flowId_example; // 
String *funnelId = funnelId_example; // 

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

// Updates the funnel with the given id in the given flow
[apiInstance updateFunnelWith:body
    flowId:flowId
    funnelId:funnelId
              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 funnel configuration details.
var flowId = flowId_example; // {{String}} 
var funnelId = funnelId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateFunnel(bodyflowIdfunnelId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDFunnel(); // FDFunnel | The funnel configuration details.
            var flowId = flowId_example;  // String | 
            var funnelId = funnelId_example;  // String | 

            try
            {
                // Updates the funnel with the given id in the given flow
                FDFunnel result = apiInstance.updateFunnel(body, flowId, funnelId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.updateFunnel: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->updateFunnel($body, $flowId, $funnelId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->updateFunnel: ', $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 funnel configuration details.
my $flowId = flowId_example; # String | 
my $funnelId = funnelId_example; # String | 

eval { 
    my $result = $api_instance->updateFunnel(body => $body, flowId => $flowId, funnelId => $funnelId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->updateFunnel: $@\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 funnel configuration details.
flowId = flowId_example # String | 
funnelId = funnelId_example # String | 

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

Parameters

Path parameters

Name	Description
flowId*	String Required
funnelId*	String Required

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

updateProcessor

Updates the processor with the given id in the given flow

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

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/designer/flows/{flowId}/processors/{processorId}"

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 processorId = processorId_example; // String | 
        try {
            FDProcessor result = apiInstance.updateProcessor(body, flowId, processorId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateProcessor");
            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 processorId = processorId_example; // String | 
        try {
            FDProcessor result = apiInstance.updateProcessor(body, flowId, processorId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateProcessor");
            e.printStackTrace();
        }
    }
}

FDProcessor *body = ; // The processor configuration details.
String *flowId = flowId_example; // 
String *processorId = processorId_example; // 

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

// Updates the processor with the given id in the given flow
[apiInstance updateProcessorWith:body
    flowId:flowId
    processorId:processorId
              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 processorId = processorId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateProcessor(bodyflowIdprocessorId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            try
            {
                // Updates the processor with the given id in the given flow
                FDProcessor result = apiInstance.updateProcessor(body, flowId, processorId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.updateProcessor: " + 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 | 
$processorId = processorId_example; // String | 

try {
    $result = $api_instance->updateProcessor($body, $flowId, $processorId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->updateProcessor: ', $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 $processorId = processorId_example; # String | 

eval { 
    my $result = $api_instance->updateProcessor(body => $body, flowId => $flowId, processorId => $processorId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->updateProcessor: $@\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 | 
processorId = processorId_example # String | 

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

Parameters

Path parameters

Name	Description
flowId*	String Required
processorId*	String Required

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

updateRemoteProcessGroup

Updates 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 PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/designer/flows/{flowId}/remote-process-groups/{remoteProcessGroupId}"

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 remoteProcessGroup configuration details.
        String flowId = flowId_example; // String | 
        String remoteProcessGroupId = remoteProcessGroupId_example; // String | 
        try {
            FDRemoteProcessGroup result = apiInstance.updateRemoteProcessGroup(body, flowId, remoteProcessGroupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateRemoteProcessGroup");
            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 remoteProcessGroup configuration details.
        String flowId = flowId_example; // String | 
        String remoteProcessGroupId = remoteProcessGroupId_example; // String | 
        try {
            FDRemoteProcessGroup result = apiInstance.updateRemoteProcessGroup(body, flowId, remoteProcessGroupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateRemoteProcessGroup");
            e.printStackTrace();
        }
    }
}

FDRemoteProcessGroup *body = ; // The remoteProcessGroup configuration details.
String *flowId = flowId_example; // 
String *remoteProcessGroupId = remoteProcessGroupId_example; // 

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

// Updates the remote process group with the given id in the given flow
[apiInstance updateRemoteProcessGroupWith:body
    flowId:flowId
    remoteProcessGroupId:remoteProcessGroupId
              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 remoteProcessGroup configuration details.
var flowId = flowId_example; // {{String}} 
var remoteProcessGroupId = remoteProcessGroupId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateRemoteProcessGroup(bodyflowIdremoteProcessGroupId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();
            var body = new FDRemoteProcessGroup(); // FDRemoteProcessGroup | The remoteProcessGroup configuration details.
            var flowId = flowId_example;  // String | 
            var remoteProcessGroupId = remoteProcessGroupId_example;  // String | 

            try
            {
                // Updates the remote process group with the given id in the given flow
                FDRemoteProcessGroup result = apiInstance.updateRemoteProcessGroup(body, flowId, remoteProcessGroupId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.updateRemoteProcessGroup: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->updateRemoteProcessGroup($body, $flowId, $remoteProcessGroupId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->updateRemoteProcessGroup: ', $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 remoteProcessGroup configuration details.
my $flowId = flowId_example; # String | 
my $remoteProcessGroupId = remoteProcessGroupId_example; # String | 

eval { 
    my $result = $api_instance->updateRemoteProcessGroup(body => $body, flowId => $flowId, remoteProcessGroupId => $remoteProcessGroupId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->updateRemoteProcessGroup: $@\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 remoteProcessGroup configuration details.
flowId = flowId_example # String | 
remoteProcessGroupId = remoteProcessGroupId_example # String | 

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

Parameters

Path parameters

Name	Description
flowId*	String Required
remoteProcessGroupId*	String Required

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

FlowMappings

createFlowMapping

Creates a flow mapping. [BETA]

/flow-mappings

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json"\
"/efm/api/flow-mappings"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowMappingsApi;

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

public class FlowMappingsApiExample {

    public static void main(String[] args) {
        
        FlowMappingsApi apiInstance = new FlowMappingsApi();
        FlowMapping body = ; // FlowMapping | The flow mapping to create
        try {
            apiInstance.createFlowMapping(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowMappingsApi#createFlowMapping");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowMappingsApi;

public class FlowMappingsApiExample {

    public static void main(String[] args) {
        FlowMappingsApi apiInstance = new FlowMappingsApi();
        FlowMapping body = ; // FlowMapping | The flow mapping to create
        try {
            apiInstance.createFlowMapping(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowMappingsApi#createFlowMapping");
            e.printStackTrace();
        }
    }
}

FlowMapping *body = ; // The flow mapping to create

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

// Creates a flow mapping. [BETA]
[apiInstance createFlowMappingWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowMappingsApi()
var body = ; // {{FlowMapping}} The flow mapping to create

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createFlowMapping(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowMappingsApi();
            var body = new FlowMapping(); // FlowMapping | The flow mapping to create

            try
            {
                // Creates a flow mapping. [BETA]
                apiInstance.createFlowMapping(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowMappingsApi.createFlowMapping: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowMappingsApi();
$body = ; // FlowMapping | The flow mapping to create

try {
    $api_instance->createFlowMapping($body);
} catch (Exception $e) {
    echo 'Exception when calling FlowMappingsApi->createFlowMapping: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowMappingsApi;

my $api_instance = WWW::SwaggerClient::FlowMappingsApi->new();
my $body = WWW::SwaggerClient::Object::FlowMapping->new(); # FlowMapping | The flow mapping to create

eval { 
    $api_instance->createFlowMapping(body => $body);
};
if ($@) {
    warn "Exception when calling FlowMappingsApi->createFlowMapping: $@\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.FlowMappingsApi()
body =  # FlowMapping | The flow mapping to create

try: 
    # Creates a flow mapping. [BETA]
    api_instance.create_flow_mapping(body)
except ApiException as e:
    print("Exception when calling FlowMappingsApi->createFlowMapping: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: default - successful operation

deleteFlowMapping

Deletes a flow mapping. [BETA]

/flow-mappings/{agentClassName}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/flow-mappings/{agentClassName}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowMappingsApi;

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

public class FlowMappingsApiExample {

    public static void main(String[] args) {
        
        FlowMappingsApi apiInstance = new FlowMappingsApi();
        String agentClassName = agentClassName_example; // String | The name of the class to delete the mapping for
        try {
            FlowMapping result = apiInstance.deleteFlowMapping(agentClassName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowMappingsApi#deleteFlowMapping");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowMappingsApi;

public class FlowMappingsApiExample {

    public static void main(String[] args) {
        FlowMappingsApi apiInstance = new FlowMappingsApi();
        String agentClassName = agentClassName_example; // String | The name of the class to delete the mapping for
        try {
            FlowMapping result = apiInstance.deleteFlowMapping(agentClassName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowMappingsApi#deleteFlowMapping");
            e.printStackTrace();
        }
    }
}

String *agentClassName = agentClassName_example; // The name of the class to delete the mapping for

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

// Deletes a flow mapping. [BETA]
[apiInstance deleteFlowMappingWith:agentClassName
              completionHandler: ^(FlowMapping 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.FlowMappingsApi()
var agentClassName = agentClassName_example; // {{String}} The name of the class to delete the mapping for

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteFlowMapping(agentClassName, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowMappingsApi();
            var agentClassName = agentClassName_example;  // String | The name of the class to delete the mapping for

            try
            {
                // Deletes a flow mapping. [BETA]
                FlowMapping result = apiInstance.deleteFlowMapping(agentClassName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowMappingsApi.deleteFlowMapping: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowMappingsApi();
$agentClassName = agentClassName_example; // String | The name of the class to delete the mapping for

try {
    $result = $api_instance->deleteFlowMapping($agentClassName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowMappingsApi->deleteFlowMapping: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowMappingsApi;

my $api_instance = WWW::SwaggerClient::FlowMappingsApi->new();
my $agentClassName = agentClassName_example; # String | The name of the class to delete the mapping for

eval { 
    my $result = $api_instance->deleteFlowMapping(agentClassName => $agentClassName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowMappingsApi->deleteFlowMapping: $@\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.FlowMappingsApi()
agentClassName = agentClassName_example # String | The name of the class to delete the mapping for

try: 
    # Deletes a flow mapping. [BETA]
    api_response = api_instance.delete_flow_mapping(agentClassName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowMappingsApi->deleteFlowMapping: %s\n" % e)

Parameters

Path parameters

Name	Description
agentClassName*	String The name of the class to delete the mapping for Required

Responses

Status: 200 - successful operation

Schema

getAllFlowMappings

Gets all flow mappings. [BETA]

/flow-mappings

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/flow-mappings"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowMappingsApi;

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

public class FlowMappingsApiExample {

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

import io.swagger.client.api.FlowMappingsApi;

public class FlowMappingsApiExample {

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


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

// Gets all flow mappings. [BETA]
[apiInstance getAllFlowMappingsWithCompletionHandler: 
              ^(FlowMappings 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.FlowMappingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllFlowMappings(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowMappingsApi();

            try
            {
                // Gets all flow mappings. [BETA]
                FlowMappings result = apiInstance.getAllFlowMappings();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowMappingsApi.getAllFlowMappings: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getAllFlowMappings();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowMappingsApi->getAllFlowMappings: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowMappingsApi;

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

eval { 
    my $result = $api_instance->getAllFlowMappings();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowMappingsApi->getAllFlowMappings: $@\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.FlowMappingsApi()

try: 
    # Gets all flow mappings. [BETA]
    api_response = api_instance.get_all_flow_mappings()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowMappingsApi->getAllFlowMappings: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation

Schema

getFlowMapping

Gets a flow mapping for a given agent class. [BETA]

/flow-mappings/{agentClassName}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/flow-mappings/{agentClassName}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowMappingsApi;

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

public class FlowMappingsApiExample {

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

import io.swagger.client.api.FlowMappingsApi;

public class FlowMappingsApiExample {

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

String *agentClassName = agentClassName_example; // The name of the class to retrieve

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

// Gets a flow mapping for a given agent class. [BETA]
[apiInstance getFlowMappingWith:agentClassName
              completionHandler: ^(FlowMapping 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.FlowMappingsApi()
var agentClassName = agentClassName_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.getFlowMapping(agentClassName, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowMappingsApi();
            var agentClassName = agentClassName_example;  // String | The name of the class to retrieve

            try
            {
                // Gets a flow mapping for a given agent class. [BETA]
                FlowMapping result = apiInstance.getFlowMapping(agentClassName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowMappingsApi.getFlowMapping: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getFlowMapping($agentClassName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowMappingsApi->getFlowMapping: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowMappingsApi;

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

eval { 
    my $result = $api_instance->getFlowMapping(agentClassName => $agentClassName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowMappingsApi->getFlowMapping: $@\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.FlowMappingsApi()
agentClassName = agentClassName_example # String | The name of the class to retrieve

try: 
    # Gets a flow mapping for a given agent class. [BETA]
    api_response = api_instance.get_flow_mapping(agentClassName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowMappingsApi->getFlowMapping: %s\n" % e)

Parameters

Path parameters

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

Responses

Status: 200 - successful operation

Schema

updateFlowMapping

Updates a flow mapping. [BETA]

/flow-mappings/{agentClassName}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/flow-mappings/{agentClassName}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowMappingsApi;

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

public class FlowMappingsApiExample {

    public static void main(String[] args) {
        
        FlowMappingsApi apiInstance = new FlowMappingsApi();
        FlowMapping body = ; // FlowMapping | The flow mapping to update
        String agentClassName = agentClassName_example; // String | The name of the class to update the mapping for
        try {
            FlowMapping result = apiInstance.updateFlowMapping(body, agentClassName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowMappingsApi#updateFlowMapping");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowMappingsApi;

public class FlowMappingsApiExample {

    public static void main(String[] args) {
        FlowMappingsApi apiInstance = new FlowMappingsApi();
        FlowMapping body = ; // FlowMapping | The flow mapping to update
        String agentClassName = agentClassName_example; // String | The name of the class to update the mapping for
        try {
            FlowMapping result = apiInstance.updateFlowMapping(body, agentClassName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowMappingsApi#updateFlowMapping");
            e.printStackTrace();
        }
    }
}

FlowMapping *body = ; // The flow mapping to update
String *agentClassName = agentClassName_example; // The name of the class to update the mapping for

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

// Updates a flow mapping. [BETA]
[apiInstance updateFlowMappingWith:body
    agentClassName:agentClassName
              completionHandler: ^(FlowMapping 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.FlowMappingsApi()
var body = ; // {{FlowMapping}} The flow mapping to update
var agentClassName = agentClassName_example; // {{String}} The name of the class to update the mapping for

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateFlowMapping(bodyagentClassName, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowMappingsApi();
            var body = new FlowMapping(); // FlowMapping | The flow mapping to update
            var agentClassName = agentClassName_example;  // String | The name of the class to update the mapping for

            try
            {
                // Updates a flow mapping. [BETA]
                FlowMapping result = apiInstance.updateFlowMapping(body, agentClassName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowMappingsApi.updateFlowMapping: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowMappingsApi();
$body = ; // FlowMapping | The flow mapping to update
$agentClassName = agentClassName_example; // String | The name of the class to update the mapping for

try {
    $result = $api_instance->updateFlowMapping($body, $agentClassName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowMappingsApi->updateFlowMapping: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowMappingsApi;

my $api_instance = WWW::SwaggerClient::FlowMappingsApi->new();
my $body = WWW::SwaggerClient::Object::FlowMapping->new(); # FlowMapping | The flow mapping to update
my $agentClassName = agentClassName_example; # String | The name of the class to update the mapping for

eval { 
    my $result = $api_instance->updateFlowMapping(body => $body, agentClassName => $agentClassName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowMappingsApi->updateFlowMapping: $@\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.FlowMappingsApi()
body =  # FlowMapping | The flow mapping to update
agentClassName = agentClassName_example # String | The name of the class to update the mapping for

try: 
    # Updates a flow mapping. [BETA]
    api_response = api_instance.update_flow_mapping(body, agentClassName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowMappingsApi->updateFlowMapping: %s\n" % e)

Parameters

Path parameters

Name	Description
agentClassName*	String The name of the class to update the mapping for Required

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

Flows

createFlowFromFlowSnapshot

Creates a C2 flow from a VersionedFlowSnapshot from NiFi Registry. [BETA]

/flows

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/vnd.minifi-c2+json;version=1"\
"/efm/api/flows"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowsApi;

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

public class FlowsApiExample {

    public static void main(String[] args) {
        
        FlowsApi apiInstance = new FlowsApi();
        FlowSnapshot body = ; // FlowSnapshot | The flow snapshot containing the flow URI and VersionedFlowSnapshot
        try {
            FlowSummary result = apiInstance.createFlowFromFlowSnapshot(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#createFlowFromFlowSnapshot");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowsApi;

public class FlowsApiExample {

    public static void main(String[] args) {
        FlowsApi apiInstance = new FlowsApi();
        FlowSnapshot body = ; // FlowSnapshot | The flow snapshot containing the flow URI and VersionedFlowSnapshot
        try {
            FlowSummary result = apiInstance.createFlowFromFlowSnapshot(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#createFlowFromFlowSnapshot");
            e.printStackTrace();
        }
    }
}

FlowSnapshot *body = ; // The flow snapshot containing the flow URI and VersionedFlowSnapshot

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

// Creates a C2 flow from a VersionedFlowSnapshot from NiFi Registry. [BETA]
[apiInstance createFlowFromFlowSnapshotWith:body
              completionHandler: ^(FlowSummary 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.FlowsApi()
var body = ; // {{FlowSnapshot}} The flow snapshot containing the flow URI and VersionedFlowSnapshot

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createFlowFromFlowSnapshot(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowsApi();
            var body = new FlowSnapshot(); // FlowSnapshot | The flow snapshot containing the flow URI and VersionedFlowSnapshot

            try
            {
                // Creates a C2 flow from a VersionedFlowSnapshot from NiFi Registry. [BETA]
                FlowSummary result = apiInstance.createFlowFromFlowSnapshot(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowsApi.createFlowFromFlowSnapshot: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowsApi();
$body = ; // FlowSnapshot | The flow snapshot containing the flow URI and VersionedFlowSnapshot

try {
    $result = $api_instance->createFlowFromFlowSnapshot($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowsApi->createFlowFromFlowSnapshot: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowsApi;

my $api_instance = WWW::SwaggerClient::FlowsApi->new();
my $body = WWW::SwaggerClient::Object::FlowSnapshot->new(); # FlowSnapshot | The flow snapshot containing the flow URI and VersionedFlowSnapshot

eval { 
    my $result = $api_instance->createFlowFromFlowSnapshot(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowsApi->createFlowFromFlowSnapshot: $@\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.FlowsApi()
body =  # FlowSnapshot | The flow snapshot containing the flow URI and VersionedFlowSnapshot

try: 
    # Creates a C2 flow from a VersionedFlowSnapshot from NiFi Registry. [BETA]
    api_response = api_instance.create_flow_from_flow_snapshot(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowsApi->createFlowFromFlowSnapshot: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

getAllFlowSummaries

Gets all flow summaries. [BETA]

/flows

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/flows"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowsApi;

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

public class FlowsApiExample {

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

import io.swagger.client.api.FlowsApi;

public class FlowsApiExample {

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


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

// Gets all flow summaries. [BETA]
[apiInstance getAllFlowSummariesWithCompletionHandler: 
              ^(FlowSummaries 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.FlowsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllFlowSummaries(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowsApi();

            try
            {
                // Gets all flow summaries. [BETA]
                FlowSummaries result = apiInstance.getAllFlowSummaries();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowsApi.getAllFlowSummaries: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getAllFlowSummaries();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowsApi->getAllFlowSummaries: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowsApi;

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

eval { 
    my $result = $api_instance->getAllFlowSummaries();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowsApi->getAllFlowSummaries: $@\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.FlowsApi()

try: 
    # Gets all flow summaries. [BETA]
    api_response = api_instance.get_all_flow_summaries()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowsApi->getAllFlowSummaries: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation

Schema

getFlow

Get a flow by id, the response will contain a JSON document with fields for all of the flow's metadata as well as the raw content of the flow embedded in a field

/flows/{id}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/flows/{id}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowsApi;

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

public class FlowsApiExample {

    public static void main(String[] args) {
        
        FlowsApi apiInstance = new FlowsApi();
        String id = id_example; // String | The id of a flow to retrieve
        try {
            Flow result = apiInstance.getFlow(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#getFlow");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowsApi;

public class FlowsApiExample {

    public static void main(String[] args) {
        FlowsApi apiInstance = new FlowsApi();
        String id = id_example; // String | The id of a flow to retrieve
        try {
            Flow result = apiInstance.getFlow(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#getFlow");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // The id of a flow to retrieve

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

// Get a flow by id, the response will contain a JSON document with fields for all of the flow's metadata as well as the raw content of the flow embedded in a field
[apiInstance getFlowWith:id
              completionHandler: ^(Flow 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.FlowsApi()
var id = id_example; // {{String}} The id of a flow to retrieve

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getFlow(id, 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 FlowsApi();
            var id = id_example;  // String | The id of a flow to retrieve

            try
            {
                // Get a flow by id, the response will contain a JSON document with fields for all of the flow's metadata as well as the raw content of the flow embedded in a field
                Flow result = apiInstance.getFlow(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowsApi.getFlow: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowsApi();
$id = id_example; // String | The id of a flow to retrieve

try {
    $result = $api_instance->getFlow($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowsApi->getFlow: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowsApi;

my $api_instance = WWW::SwaggerClient::FlowsApi->new();
my $id = id_example; # String | The id of a flow to retrieve

eval { 
    my $result = $api_instance->getFlow(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowsApi->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.FlowsApi()
id = id_example # String | The id of a flow to retrieve

try: 
    # Get a flow by id, the response will contain a JSON document with fields for all of the flow's metadata as well as the raw content of the flow embedded in a field
    api_response = api_instance.get_flow(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowsApi->getFlow: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String The id of a flow to retrieve Required

Responses

Status: 200 - successful operation

Schema

getFlowContentAsYaml

Get a flow by id as a YAML formatted flow definition

/flows/{id}/content

Usage and SDK Samples

curl -X GET\
-H "Accept: application/vnd.minifi-c2+yaml;version=2"\
"/efm/api/flows/{id}/content"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowsApi;

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

public class FlowsApiExample {

    public static void main(String[] args) {
        
        FlowsApi apiInstance = new FlowsApi();
        String id = id_example; // String | The id of a flow to retrieve
        try {
            'String' result = apiInstance.getFlowContentAsYaml(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#getFlowContentAsYaml");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FlowsApi;

public class FlowsApiExample {

    public static void main(String[] args) {
        FlowsApi apiInstance = new FlowsApi();
        String id = id_example; // String | The id of a flow to retrieve
        try {
            'String' result = apiInstance.getFlowContentAsYaml(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#getFlowContentAsYaml");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // The id of a flow to retrieve

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

// Get a flow by id as a YAML formatted flow definition
[apiInstance getFlowContentAsYamlWith:id
              completionHandler: ^('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.FlowsApi()
var id = id_example; // {{String}} The id of a flow to retrieve

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getFlowContentAsYaml(id, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowsApi();
            var id = id_example;  // String | The id of a flow to retrieve

            try
            {
                // Get a flow by id as a YAML formatted flow definition
                'String' result = apiInstance.getFlowContentAsYaml(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowsApi.getFlowContentAsYaml: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowsApi();
$id = id_example; // String | The id of a flow to retrieve

try {
    $result = $api_instance->getFlowContentAsYaml($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowsApi->getFlowContentAsYaml: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowsApi;

my $api_instance = WWW::SwaggerClient::FlowsApi->new();
my $id = id_example; # String | The id of a flow to retrieve

eval { 
    my $result = $api_instance->getFlowContentAsYaml(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowsApi->getFlowContentAsYaml: $@\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.FlowsApi()
id = id_example # String | The id of a flow to retrieve

try: 
    # Get a flow by id as a YAML formatted flow definition
    api_response = api_instance.get_flow_content_as_yaml(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowsApi->getFlowContentAsYaml: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String The id of a flow to retrieve Required

Responses

Status: 200 - successful operation

Schema

Heartbeats

getHeartbeat

Get a specific heartbeat

/heartbeats/{id}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/heartbeats/{id}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HeartbeatsApi;

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

public class HeartbeatsApiExample {

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

import io.swagger.client.api.HeartbeatsApi;

public class HeartbeatsApiExample {

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

String *id = id_example; // The identifier of the heartbeat to retrieve

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

// Get a specific heartbeat
[apiInstance getHeartbeatWith:id
              completionHandler: ^(C2Heartbeat 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.HeartbeatsApi()
var id = id_example; // {{String}} The identifier of the heartbeat to retrieve

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getHeartbeat(id, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            try
            {
                // Get a specific heartbeat
                C2Heartbeat result = apiInstance.getHeartbeat(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HeartbeatsApi.getHeartbeat: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getHeartbeat($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HeartbeatsApi->getHeartbeat: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::HeartbeatsApi;

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

eval { 
    my $result = $api_instance->getHeartbeat(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HeartbeatsApi->getHeartbeat: $@\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.HeartbeatsApi()
id = id_example # String | The identifier of the heartbeat to retrieve

try: 
    # Get a specific heartbeat
    api_response = api_instance.get_heartbeat(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HeartbeatsApi->getHeartbeat: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String The identifier of the heartbeat to retrieve Required

Responses

Status: 200 - successful operation

Schema

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

Operations

createOperation

Submit a request for a C2 operation targeting a MiNiFi agent

/operations

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/operations"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OperationsApi;

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

public class OperationsApiExample {

    public static void main(String[] args) {
        
        OperationsApi apiInstance = new OperationsApi();
        Operation body = ; // Operation | The requested operation
        try {
            Operation result = apiInstance.createOperation(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperationsApi#createOperation");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OperationsApi;

public class OperationsApiExample {

    public static void main(String[] args) {
        OperationsApi apiInstance = new OperationsApi();
        Operation body = ; // Operation | The requested operation
        try {
            Operation result = apiInstance.createOperation(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperationsApi#createOperation");
            e.printStackTrace();
        }
    }
}

Operation *body = ; // The requested operation

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

// Submit a request for a C2 operation targeting a MiNiFi agent
[apiInstance createOperationWith:body
              completionHandler: ^(Operation 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.OperationsApi()
var body = ; // {{Operation}} The requested operation

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createOperation(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new OperationsApi();
            var body = new Operation(); // Operation | The requested operation

            try
            {
                // Submit a request for a C2 operation targeting a MiNiFi agent
                Operation result = apiInstance.createOperation(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OperationsApi.createOperation: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOperationsApi();
$body = ; // Operation | The requested operation

try {
    $result = $api_instance->createOperation($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperationsApi->createOperation: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OperationsApi;

my $api_instance = WWW::SwaggerClient::OperationsApi->new();
my $body = WWW::SwaggerClient::Object::Operation->new(); # Operation | The requested operation

eval { 
    my $result = $api_instance->createOperation(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OperationsApi->createOperation: $@\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.OperationsApi()
body =  # Operation | The requested operation

try: 
    # Submit a request for a C2 operation targeting a MiNiFi agent
    api_response = api_instance.create_operation(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperationsApi->createOperation: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

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

getOperation

Get a specific operation

/operations/{id}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/operations/{id}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OperationsApi;

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

public class OperationsApiExample {

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

import io.swagger.client.api.OperationsApi;

public class OperationsApiExample {

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

String *id = id_example; // The identifier of the operation to retrieve

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

// Get a specific operation
[apiInstance getOperationWith:id
              completionHandler: ^(Operation 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.OperationsApi()
var id = id_example; // {{String}} The identifier of the operation to retrieve

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getOperation(id, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            try
            {
                // Get a specific operation
                Operation result = apiInstance.getOperation(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OperationsApi.getOperation: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getOperation($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperationsApi->getOperation: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OperationsApi;

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

eval { 
    my $result = $api_instance->getOperation(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OperationsApi->getOperation: $@\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.OperationsApi()
id = id_example # String | The identifier of the operation to retrieve

try: 
    # Get a specific operation
    api_response = api_instance.get_operation(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperationsApi->getOperation: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String The identifier of the operation to retrieve Required

Responses

Status: 200 - successful operation

Schema

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

getOperations

Get all operations. [BETA]

/operations

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/operations"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OperationsApi;

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

public class OperationsApiExample {

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

import io.swagger.client.api.OperationsApi;

public class OperationsApiExample {

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


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

// Get all operations. [BETA]
[apiInstance getOperationsWithCompletionHandler: 
              ^(array[Operation] 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.OperationsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getOperations(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new OperationsApi();

            try
            {
                // Get all operations. [BETA]
                array[Operation] result = apiInstance.getOperations();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OperationsApi.getOperations: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getOperations();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperationsApi->getOperations: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OperationsApi;

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

eval { 
    my $result = $api_instance->getOperations();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OperationsApi->getOperations: $@\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.OperationsApi()

try: 
    # Get all operations. [BETA]
    api_response = api_instance.get_operations()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperationsApi->getOperations: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation

Schema

updateOperation

Updates the state of an operation (other fields are ignored). [BETA]

/operations/{id}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: */*"\
"/efm/api/operations/{id}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OperationsApi;

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

public class OperationsApiExample {

    public static void main(String[] args) {
        
        OperationsApi apiInstance = new OperationsApi();
        Operation body = ; // Operation | An Operation object containing the new state.
        String id = id_example; // String | The identifier of the operation for which to update state.
        try {
            Operation result = apiInstance.updateOperation(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperationsApi#updateOperation");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OperationsApi;

public class OperationsApiExample {

    public static void main(String[] args) {
        OperationsApi apiInstance = new OperationsApi();
        Operation body = ; // Operation | An Operation object containing the new state.
        String id = id_example; // String | The identifier of the operation for which to update state.
        try {
            Operation result = apiInstance.updateOperation(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperationsApi#updateOperation");
            e.printStackTrace();
        }
    }
}

Operation *body = ; // An Operation object containing the new state.
String *id = id_example; // The identifier of the operation for which to update state.

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

// Updates the state of an operation (other fields are ignored). [BETA]
[apiInstance updateOperationWith:body
    id:id
              completionHandler: ^(Operation 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.OperationsApi()
var body = ; // {{Operation}} An Operation object containing the new state.
var id = id_example; // {{String}} The identifier of the operation for which to update state.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateOperation(bodyid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new OperationsApi();
            var body = new Operation(); // Operation | An Operation object containing the new state.
            var id = id_example;  // String | The identifier of the operation for which to update state.

            try
            {
                // Updates the state of an operation (other fields are ignored). [BETA]
                Operation result = apiInstance.updateOperation(body, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OperationsApi.updateOperation: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOperationsApi();
$body = ; // Operation | An Operation object containing the new state.
$id = id_example; // String | The identifier of the operation for which to update state.

try {
    $result = $api_instance->updateOperation($body, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperationsApi->updateOperation: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OperationsApi;

my $api_instance = WWW::SwaggerClient::OperationsApi->new();
my $body = WWW::SwaggerClient::Object::Operation->new(); # Operation | An Operation object containing the new state.
my $id = id_example; # String | The identifier of the operation for which to update state.

eval { 
    my $result = $api_instance->updateOperation(body => $body, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OperationsApi->updateOperation: $@\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.OperationsApi()
body =  # Operation | An Operation object containing the new state.
id = id_example # String | The identifier of the operation for which to update state.

try: 
    # Updates the state of an operation (other fields are ignored). [BETA]
    api_response = api_instance.update_operation(body, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperationsApi->updateOperation: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String The identifier of the operation for which to update state. Required

Body parameters

Name	Description
body *

Responses

Status: 200 - successful operation

Schema

Cloudera Edge Flow Manager REST API

API and SDK Documentation

Access

getAccessStatus

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

AgentClasses

createAgentClass

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

deleteAgentClass

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

getAgentClass

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

getAgentClasses

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

replaceAgentClass

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

AgentManifests

createAgentManifest

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

deleteAgentManifest

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

getAgentManifest

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

getAgentManifests

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

Agents

createAgent

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

deleteAgent

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

getAgent

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

getAgents

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

C2Configuration

getC2ConfigurationInfo

Usage and SDK Samples

Parameters