Cloudera Documentation

Cloudera Edge Flow Manager REST API

Access

getAccessStatus

Returns the current client's authenticated identity.


/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.
[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.
                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.
    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


getAgentClassAccess

Returns the current client's access to the given agent class.


/access/agent-class/{name}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/access/agent-class/{name}"
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();
        String name = name_example; // String | The name of the agent class to lookup
        try {
            AgentClassPermissions result = apiInstance.getAgentClassAccess(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccessApi#getAgentClassAccess");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AccessApi;

public class AccessApiExample {

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

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

// Returns the current client's access to the given agent class.
[apiInstance getAgentClassAccessWith:name
              completionHandler: ^(AgentClassPermissions 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 name = name_example; // {{String}} The name of the agent class to lookup

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

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

            var apiInstance = new AccessApi();
            var name = name_example;  // String | The name of the agent class to lookup

            try
            {
                // Returns the current client's access to the given agent class.
                AgentClassPermissions result = apiInstance.getAgentClassAccess(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccessApi.getAgentClassAccess: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

eval { 
    my $result = $api_instance->getAgentClassAccess(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccessApi->getAgentClassAccess: $@\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()
name = name_example # String | The name of the agent class to lookup

try: 
    # Returns the current client's access to the given agent class.
    api_response = api_instance.get_agent_class_access(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccessApi->getAgentClassAccess: %s\n" % e)

Parameters

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

Responses

Status: 200 - successful operation


getFlowAccess

Returns the current client's access to the given agent class.


/access/flow-id/{flowId}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/access/flow-id/{flowId}"
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();
        String flowId = flowId_example; // String | The id of the flow to lookup
        try {
            AgentClassPermissions result = apiInstance.getFlowAccess(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccessApi#getFlowAccess");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AccessApi;

public class AccessApiExample {

    public static void main(String[] args) {
        AccessApi apiInstance = new AccessApi();
        String flowId = flowId_example; // String | The id of the flow to lookup
        try {
            AgentClassPermissions result = apiInstance.getFlowAccess(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccessApi#getFlowAccess");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // The id of the flow to lookup

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

// Returns the current client's access to the given agent class.
[apiInstance getFlowAccessWith:flowId
              completionHandler: ^(AgentClassPermissions 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 flowId = flowId_example; // {{String}} The id of the flow to lookup

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

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

            var apiInstance = new AccessApi();
            var flowId = flowId_example;  // String | The id of the flow to lookup

            try
            {
                // Returns the current client's access to the given agent class.
                AgentClassPermissions result = apiInstance.getFlowAccess(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccessApi.getFlowAccess: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAccessApi();
$flowId = flowId_example; // String | The id of the flow to lookup

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

my $api_instance = WWW::SwaggerClient::AccessApi->new();
my $flowId = flowId_example; # String | The id of the flow to lookup

eval { 
    my $result = $api_instance->getFlowAccess(flowId => $flowId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccessApi->getFlowAccess: $@\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()
flowId = flowId_example # String | The id of the flow to lookup

try: 
    # Returns the current client's access to the given agent class.
    api_response = api_instance.get_flow_access(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccessApi->getFlowAccess: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
The id of the flow to lookup
Required

Responses

Status: 200 - successful operation


AgentClassManifestConfig

createAgentManifestMapping

Creates agent class to agent manifest mapping configuration.


/agent-class-manifest-config

Usage and SDK Samples

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

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

public class AgentClassManifestConfigApiExample {

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

public class AgentClassManifestConfigApiExample {

    public static void main(String[] args) {
        AgentClassManifestConfigApi apiInstance = new AgentClassManifestConfigApi();
        AgentClassManifestConfig body = ; // AgentClassManifestConfig | The agent manifest mapping to create
        try {
            AgentClassManifestConfig result = apiInstance.createAgentManifestMapping(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassManifestConfigApi#createAgentManifestMapping");
            e.printStackTrace();
        }
    }
}
AgentClassManifestConfig *body = ; // The agent manifest mapping to create

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

// Creates agent class to agent manifest mapping configuration.
[apiInstance createAgentManifestMappingWith:body
              completionHandler: ^(AgentClassManifestConfig 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.AgentClassManifestConfigApi()
var body = ; // {{AgentClassManifestConfig}} The agent manifest mapping to create

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

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

            var apiInstance = new AgentClassManifestConfigApi();
            var body = new AgentClassManifestConfig(); // AgentClassManifestConfig | The agent manifest mapping to create

            try
            {
                // Creates agent class to agent manifest mapping configuration.
                AgentClassManifestConfig result = apiInstance.createAgentManifestMapping(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassManifestConfigApi.createAgentManifestMapping: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentClassManifestConfigApi();
$body = ; // AgentClassManifestConfig | The agent manifest mapping to create

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

my $api_instance = WWW::SwaggerClient::AgentClassManifestConfigApi->new();
my $body = WWW::SwaggerClient::Object::AgentClassManifestConfig->new(); # AgentClassManifestConfig | The agent manifest mapping to create

eval { 
    my $result = $api_instance->createAgentManifestMapping(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentClassManifestConfigApi->createAgentManifestMapping: $@\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.AgentClassManifestConfigApi()
body =  # AgentClassManifestConfig | The agent manifest mapping to create

try: 
    # Creates agent class to agent manifest mapping configuration.
    api_response = api_instance.create_agent_manifest_mapping(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassManifestConfigApi->createAgentManifestMapping: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


deleteAgentManifestMapping

Deletes an agent class to agent manifest mapping configuration.


/agent-class-manifest-config/{name}

Usage and SDK Samples

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

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

public class AgentClassManifestConfigApiExample {

    public static void main(String[] args) {
        
        AgentClassManifestConfigApi apiInstance = new AgentClassManifestConfigApi();
        String name = name_example; // String | The agent class name.
        try {
            AgentClassManifestConfig result = apiInstance.deleteAgentManifestMapping(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassManifestConfigApi#deleteAgentManifestMapping");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentClassManifestConfigApi;

public class AgentClassManifestConfigApiExample {

    public static void main(String[] args) {
        AgentClassManifestConfigApi apiInstance = new AgentClassManifestConfigApi();
        String name = name_example; // String | The agent class name.
        try {
            AgentClassManifestConfig result = apiInstance.deleteAgentManifestMapping(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassManifestConfigApi#deleteAgentManifestMapping");
            e.printStackTrace();
        }
    }
}
String *name = name_example; // The agent class name.

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

// Deletes an agent class to agent manifest mapping configuration.
[apiInstance deleteAgentManifestMappingWith:name
              completionHandler: ^(AgentClassManifestConfig 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.AgentClassManifestConfigApi()
var name = name_example; // {{String}} The agent class name.

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

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

            var apiInstance = new AgentClassManifestConfigApi();
            var name = name_example;  // String | The agent class name.

            try
            {
                // Deletes an agent class to agent manifest mapping configuration.
                AgentClassManifestConfig result = apiInstance.deleteAgentManifestMapping(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassManifestConfigApi.deleteAgentManifestMapping: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentClassManifestConfigApi();
$name = name_example; // String | The agent class name.

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

my $api_instance = WWW::SwaggerClient::AgentClassManifestConfigApi->new();
my $name = name_example; # String | The agent class name.

eval { 
    my $result = $api_instance->deleteAgentManifestMapping(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentClassManifestConfigApi->deleteAgentManifestMapping: $@\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.AgentClassManifestConfigApi()
name = name_example # String | The agent class name.

try: 
    # Deletes an agent class to agent manifest mapping configuration.
    api_response = api_instance.delete_agent_manifest_mapping(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassManifestConfigApi->deleteAgentManifestMapping: %s\n" % e)

Parameters

Path parameters
Name Description
name*
String
The agent class name.
Required

Responses

Status: 200 - successful operation


getAgentManifestMapping

Returns the agent class to agent manifest mapping for a given agent class name.


/agent-class-manifest-config/{name}

Usage and SDK Samples

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

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

public class AgentClassManifestConfigApiExample {

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

public class AgentClassManifestConfigApiExample {

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

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

// Returns the agent class to agent manifest mapping for a given agent class name.
[apiInstance getAgentManifestMappingWith:name
              completionHandler: ^(AgentClassManifestConfig 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.AgentClassManifestConfigApi()
var name = name_example; // {{String}} The name of the agent class to retrieve mapping

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

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

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

            try
            {
                // Returns the agent class to agent manifest mapping for a given agent class name.
                AgentClassManifestConfig result = apiInstance.getAgentManifestMapping(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassManifestConfigApi.getAgentManifestMapping: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try: 
    # Returns the agent class to agent manifest mapping for a given agent class name.
    api_response = api_instance.get_agent_manifest_mapping(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassManifestConfigApi->getAgentManifestMapping: %s\n" % e)

Parameters

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

Responses

Status: 200 - successful operation


getAgentManifestMappings

Get all agent class to agent manifest mapping configurations


/agent-class-manifest-config

Usage and SDK Samples

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

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

public class AgentClassManifestConfigApiExample {

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

public class AgentClassManifestConfigApiExample {

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

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

// Get all agent class to agent manifest mapping configurations 
[apiInstance getAgentManifestMappingsWithCompletionHandler: 
              ^(array[AgentClassManifestConfig] 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.AgentClassManifestConfigApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAgentManifestMappings(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentClassManifestConfigApi();

            try
            {
                // Get all agent class to agent manifest mapping configurations 
                array[AgentClassManifestConfig] result = apiInstance.getAgentManifestMappings();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassManifestConfigApi.getAgentManifestMappings: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try: 
    # Get all agent class to agent manifest mapping configurations 
    api_response = api_instance.get_agent_manifest_mappings()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassManifestConfigApi->getAgentManifestMappings: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


updateAgentManifestMapping

Updates and existing agent class to agent manifest mapping configuration.


/agent-class-manifest-config

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/agent-class-manifest-config"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentClassManifestConfigApi;

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

public class AgentClassManifestConfigApiExample {

    public static void main(String[] args) {
        
        AgentClassManifestConfigApi apiInstance = new AgentClassManifestConfigApi();
        AgentClassManifestConfig body = ; // AgentClassManifestConfig | The agent class manifest mapping configuration to update
        try {
            AgentClassManifestConfig result = apiInstance.updateAgentManifestMapping(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassManifestConfigApi#updateAgentManifestMapping");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentClassManifestConfigApi;

public class AgentClassManifestConfigApiExample {

    public static void main(String[] args) {
        AgentClassManifestConfigApi apiInstance = new AgentClassManifestConfigApi();
        AgentClassManifestConfig body = ; // AgentClassManifestConfig | The agent class manifest mapping configuration to update
        try {
            AgentClassManifestConfig result = apiInstance.updateAgentManifestMapping(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassManifestConfigApi#updateAgentManifestMapping");
            e.printStackTrace();
        }
    }
}
AgentClassManifestConfig *body = ; // The agent class manifest mapping configuration to update

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

// Updates and existing agent class to agent manifest mapping configuration.
[apiInstance updateAgentManifestMappingWith:body
              completionHandler: ^(AgentClassManifestConfig 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.AgentClassManifestConfigApi()
var body = ; // {{AgentClassManifestConfig}} The agent class manifest mapping configuration to update

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

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

            var apiInstance = new AgentClassManifestConfigApi();
            var body = new AgentClassManifestConfig(); // AgentClassManifestConfig | The agent class manifest mapping configuration to update

            try
            {
                // Updates and existing agent class to agent manifest mapping configuration.
                AgentClassManifestConfig result = apiInstance.updateAgentManifestMapping(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassManifestConfigApi.updateAgentManifestMapping: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentClassManifestConfigApi();
$body = ; // AgentClassManifestConfig | The agent class manifest mapping configuration to update

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

my $api_instance = WWW::SwaggerClient::AgentClassManifestConfigApi->new();
my $body = WWW::SwaggerClient::Object::AgentClassManifestConfig->new(); # AgentClassManifestConfig | The agent class manifest mapping configuration to update

eval { 
    my $result = $api_instance->updateAgentManifestMapping(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentClassManifestConfigApi->updateAgentManifestMapping: $@\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.AgentClassManifestConfigApi()
body =  # AgentClassManifestConfig | The agent class manifest mapping configuration to update

try: 
    # Updates and existing agent class to agent manifest mapping configuration.
    api_response = api_instance.update_agent_manifest_mapping(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassManifestConfigApi->updateAgentManifestMapping: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


AgentClasses

createAgentClass

Register a MiNiFi agent class with this C2 server

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


/agent-classes

Usage and SDK Samples

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

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

public class AgentClassesApiExample {

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

public class AgentClassesApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


deleteAgentClass

Delete a MiNiFi agent class


/agent-classes/{name}

Usage and SDK Samples

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

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

public class AgentClassesApiExample {

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

public class AgentClassesApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


getAgentClass

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


/agent-classes/{name}

Usage and SDK Samples

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

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

public class AgentClassesApiExample {

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

public class AgentClassesApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


getAgentClasses

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


/agent-classes

Usage and SDK Samples

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

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

public class AgentClassesApiExample {

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

public class AgentClassesApiExample {

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

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

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

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

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

            var apiInstance = new AgentClassesApi();

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

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

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

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

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

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

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

Parameters

Responses

Status: 200 - successful operation


getManifestRefresh

Get the potential impact of a possible manifest refresh on the given class


/agent-classes/{name}/manifest-diff

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/agent-classes/{name}/manifest-diff"
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 work with
        try {
            ManifestDiff result = apiInstance.getManifestRefresh(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#getManifestRefresh");
            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 work with
        try {
            ManifestDiff result = apiInstance.getManifestRefresh(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentClassesApi#getManifestRefresh");
            e.printStackTrace();
        }
    }
}
String *name = name_example; // The name of the class to work with

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

// Get the potential impact of a possible manifest refresh on the given class
[apiInstance getManifestRefreshWith:name
              completionHandler: ^(ManifestDiff 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 work with

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

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

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

            try
            {
                // Get the potential impact of a possible manifest refresh on the given class
                ManifestDiff result = apiInstance.getManifestRefresh(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassesApi.getManifestRefresh: " + 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 work with

try {
    $result = $api_instance->getManifestRefresh($name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AgentClassesApi->getManifestRefresh: ', $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 work with

eval { 
    my $result = $api_instance->getManifestRefresh(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentClassesApi->getManifestRefresh: $@\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 work with

try: 
    # Get the potential impact of a possible manifest refresh on the given class
    api_response = api_instance.get_manifest_refresh(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentClassesApi->getManifestRefresh: %s\n" % e)

Parameters

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

Responses

Status: 200 - successful operation


replaceAgentClass

Update a MiNiFi agent class by replacing it in full


/agent-classes/{name}

Usage and SDK Samples

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

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

public class AgentClassesApiExample {

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

public class AgentClassesApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


AgentDeployer

binary

Retrieves the agent binary


/agent-deployer/binary

Usage and SDK Samples

curl -X GET\
"/efm/api/agent-deployer/binary?agentType=&osArch=&agentVersion="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentDeployerApi;

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

public class AgentDeployerApiExample {

    public static void main(String[] args) {
        
        AgentDeployerApi apiInstance = new AgentDeployerApi();
        String agentType = agentType_example; // String | The type of the agent binary(Java or CPP)
        String osArch = osArch_example; // String | The supported os version of the agent binary
        String agentVersion = agentVersion_example; // String | The version number of the agent binary
        try {
            apiInstance.binary(agentType, osArch, agentVersion);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentDeployerApi#binary");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentDeployerApi;

public class AgentDeployerApiExample {

    public static void main(String[] args) {
        AgentDeployerApi apiInstance = new AgentDeployerApi();
        String agentType = agentType_example; // String | The type of the agent binary(Java or CPP)
        String osArch = osArch_example; // String | The supported os version of the agent binary
        String agentVersion = agentVersion_example; // String | The version number of the agent binary
        try {
            apiInstance.binary(agentType, osArch, agentVersion);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentDeployerApi#binary");
            e.printStackTrace();
        }
    }
}
String *agentType = agentType_example; // The type of the agent binary(Java or CPP) (default to Java)
String *osArch = osArch_example; // The supported os version of the agent binary (default to Linux)
String *agentVersion = agentVersion_example; // The version number of the agent binary (default to 1.23.05)

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

// Retrieves the agent binary
[apiInstance binaryWith:agentType
    osArch:osArch
    agentVersion:agentVersion
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentDeployerApi()
var agentType = agentType_example; // {{String}} The type of the agent binary(Java or CPP)
var osArch = osArch_example; // {{String}} The supported os version of the agent binary
var agentVersion = agentVersion_example; // {{String}} The version number of the agent binary

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

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

            var apiInstance = new AgentDeployerApi();
            var agentType = agentType_example;  // String | The type of the agent binary(Java or CPP) (default to Java)
            var osArch = osArch_example;  // String | The supported os version of the agent binary (default to Linux)
            var agentVersion = agentVersion_example;  // String | The version number of the agent binary (default to 1.23.05)

            try
            {
                // Retrieves the agent binary
                apiInstance.binary(agentType, osArch, agentVersion);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentDeployerApi.binary: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentDeployerApi();
$agentType = agentType_example; // String | The type of the agent binary(Java or CPP)
$osArch = osArch_example; // String | The supported os version of the agent binary
$agentVersion = agentVersion_example; // String | The version number of the agent binary

try {
    $api_instance->binary($agentType, $osArch, $agentVersion);
} catch (Exception $e) {
    echo 'Exception when calling AgentDeployerApi->binary: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AgentDeployerApi;

my $api_instance = WWW::SwaggerClient::AgentDeployerApi->new();
my $agentType = agentType_example; # String | The type of the agent binary(Java or CPP)
my $osArch = osArch_example; # String | The supported os version of the agent binary
my $agentVersion = agentVersion_example; # String | The version number of the agent binary

eval { 
    $api_instance->binary(agentType => $agentType, osArch => $osArch, agentVersion => $agentVersion);
};
if ($@) {
    warn "Exception when calling AgentDeployerApi->binary: $@\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.AgentDeployerApi()
agentType = agentType_example # String | The type of the agent binary(Java or CPP) (default to Java)
osArch = osArch_example # String | The supported os version of the agent binary (default to Linux)
agentVersion = agentVersion_example # String | The version number of the agent binary (default to 1.23.05)

try: 
    # Retrieves the agent binary
    api_instance.binary(agentType, osArch, agentVersion)
except ApiException as e:
    print("Exception when calling AgentDeployerApi->binary: %s\n" % e)

Parameters

Query parameters
Name Description
agentType*
String
The type of the agent binary(Java or CPP)
Required
osArch*
String
The supported os version of the agent binary
Required
agentVersion*
String
The version number of the agent binary
Required

Responses

Status: default - successful operation


generateCommand

Generates the curl / powershell command


/agent-deployer/generateCommand

Usage and SDK Samples

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

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

public class AgentDeployerApiExample {

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

public class AgentDeployerApiExample {

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

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

// Generates the curl / powershell command
[apiInstance generateCommandWith:body
              completionHandler: ^(AgentDeployerCommandResponse 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.AgentDeployerApi()
var opts = { 
  'body':  // {{AgentDeployerCommandGenerationRequest}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.generateCommand(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentDeployerApi();
            var body = new AgentDeployerCommandGenerationRequest(); // AgentDeployerCommandGenerationRequest |  (optional) 

            try
            {
                // Generates the curl / powershell command
                AgentDeployerCommandResponse result = apiInstance.generateCommand(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentDeployerApi.generateCommand: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentDeployerApi();
$body = ; // AgentDeployerCommandGenerationRequest | 

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

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

eval { 
    my $result = $api_instance->generateCommand(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentDeployerApi->generateCommand: $@\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.AgentDeployerApi()
body =  # AgentDeployerCommandGenerationRequest |  (optional)

try: 
    # Generates the curl / powershell command
    api_response = api_instance.generate_command(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentDeployerApi->generateCommand: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - successful operation


parameters

Retrieves the available parameters for the one liner command generation


/agent-deployer/parameters/{agentClass}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/agent-deployer/parameters/{agentClass}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentDeployerApi;

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

public class AgentDeployerApiExample {

    public static void main(String[] args) {
        
        AgentDeployerApi apiInstance = new AgentDeployerApi();
        String agentClass = agentClass_example; // String | The agent class
        try {
            ParametersResponse result = apiInstance.parameters(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentDeployerApi#parameters");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentDeployerApi;

public class AgentDeployerApiExample {

    public static void main(String[] args) {
        AgentDeployerApi apiInstance = new AgentDeployerApi();
        String agentClass = agentClass_example; // String | The agent class
        try {
            ParametersResponse result = apiInstance.parameters(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentDeployerApi#parameters");
            e.printStackTrace();
        }
    }
}
String *agentClass = agentClass_example; // The agent class

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

// Retrieves the available parameters for the one liner command generation
[apiInstance parametersWith:agentClass
              completionHandler: ^(ParametersResponse 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.AgentDeployerApi()
var agentClass = agentClass_example; // {{String}} The agent class

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

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

            var apiInstance = new AgentDeployerApi();
            var agentClass = agentClass_example;  // String | The agent class

            try
            {
                // Retrieves the available parameters for the one liner command generation
                ParametersResponse result = apiInstance.parameters(agentClass);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentDeployerApi.parameters: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentDeployerApi();
$agentClass = agentClass_example; // String | The agent class

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

my $api_instance = WWW::SwaggerClient::AgentDeployerApi->new();
my $agentClass = agentClass_example; # String | The agent class

eval { 
    my $result = $api_instance->parameters(agentClass => $agentClass);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentDeployerApi->parameters: $@\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.AgentDeployerApi()
agentClass = agentClass_example # String | The agent class

try: 
    # Retrieves the available parameters for the one liner command generation
    api_response = api_instance.parameters(agentClass)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentDeployerApi->parameters: %s\n" % e)

Parameters

Path parameters
Name Description
agentClass*
String
The agent class
Required

Responses

Status: 200 - successful operation


script

Retrieves the deployer script


/agent-deployer/script

Usage and SDK Samples

curl -X POST\
-H "Content-Type: */*"\
"/efm/api/agent-deployer/script"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentDeployerApi;

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

public class AgentDeployerApiExample {

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

public class AgentDeployerApiExample {

    public static void main(String[] args) {
        AgentDeployerApi apiInstance = new AgentDeployerApi();
        ScriptGenerationRequest body = ; // ScriptGenerationRequest | Agent deployer script api model
        try {
            apiInstance.script(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentDeployerApi#script");
            e.printStackTrace();
        }
    }
}
ScriptGenerationRequest *body = ; // Agent deployer script api model (optional)

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

// Retrieves the deployer script
[apiInstance scriptWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentDeployerApi()
var opts = { 
  'body':  // {{ScriptGenerationRequest}} Agent deployer script api model
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.script(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentDeployerApi();
            var body = new ScriptGenerationRequest(); // ScriptGenerationRequest | Agent deployer script api model (optional) 

            try
            {
                // Retrieves the deployer script
                apiInstance.script(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentDeployerApi.script: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentDeployerApi();
$body = ; // ScriptGenerationRequest | Agent deployer script api model

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

my $api_instance = WWW::SwaggerClient::AgentDeployerApi->new();
my $body = WWW::SwaggerClient::Object::ScriptGenerationRequest->new(); # ScriptGenerationRequest | Agent deployer script api model

eval { 
    $api_instance->script(body => $body);
};
if ($@) {
    warn "Exception when calling AgentDeployerApi->script: $@\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.AgentDeployerApi()
body =  # ScriptGenerationRequest | Agent deployer script api model (optional)

try: 
    # Retrieves the deployer script
    api_instance.script(body=body)
except ApiException as e:
    print("Exception when calling AgentDeployerApi->script: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: default - successful operation


securityBundle

Retrieves security for the given agent


/agent-deployer/securityBundle

Usage and SDK Samples

curl -X GET\
-H "Accept: application/octet-stream"\
"/efm/api/agent-deployer/securityBundle?agentId=&agentClass=&agentType="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentDeployerApi;

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

public class AgentDeployerApiExample {

    public static void main(String[] args) {
        
        AgentDeployerApi apiInstance = new AgentDeployerApi();
        String agentId = agentId_example; // String | The agent identifier
        String agentClass = agentClass_example; // String | The agent class
        String agentType = agentType_example; // String | The agent type
        try {
            StreamingResponseBody result = apiInstance.securityBundle(agentId, agentClass, agentType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentDeployerApi#securityBundle");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentDeployerApi;

public class AgentDeployerApiExample {

    public static void main(String[] args) {
        AgentDeployerApi apiInstance = new AgentDeployerApi();
        String agentId = agentId_example; // String | The agent identifier
        String agentClass = agentClass_example; // String | The agent class
        String agentType = agentType_example; // String | The agent type
        try {
            StreamingResponseBody result = apiInstance.securityBundle(agentId, agentClass, agentType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentDeployerApi#securityBundle");
            e.printStackTrace();
        }
    }
}
String *agentId = agentId_example; // The agent identifier
String *agentClass = agentClass_example; // The agent class
String *agentType = agentType_example; // The agent type

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

// Retrieves security for the given agent
[apiInstance securityBundleWith:agentId
    agentClass:agentClass
    agentType:agentType
              completionHandler: ^(StreamingResponseBody 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.AgentDeployerApi()
var agentId = agentId_example; // {{String}} The agent identifier
var agentClass = agentClass_example; // {{String}} The agent class
var agentType = agentType_example; // {{String}} The agent type

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

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

            var apiInstance = new AgentDeployerApi();
            var agentId = agentId_example;  // String | The agent identifier
            var agentClass = agentClass_example;  // String | The agent class
            var agentType = agentType_example;  // String | The agent type

            try
            {
                // Retrieves security for the given agent
                StreamingResponseBody result = apiInstance.securityBundle(agentId, agentClass, agentType);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentDeployerApi.securityBundle: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentDeployerApi();
$agentId = agentId_example; // String | The agent identifier
$agentClass = agentClass_example; // String | The agent class
$agentType = agentType_example; // String | The agent type

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

my $api_instance = WWW::SwaggerClient::AgentDeployerApi->new();
my $agentId = agentId_example; # String | The agent identifier
my $agentClass = agentClass_example; # String | The agent class
my $agentType = agentType_example; # String | The agent type

eval { 
    my $result = $api_instance->securityBundle(agentId => $agentId, agentClass => $agentClass, agentType => $agentType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentDeployerApi->securityBundle: $@\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.AgentDeployerApi()
agentId = agentId_example # String | The agent identifier
agentClass = agentClass_example # String | The agent class
agentType = agentType_example # String | The agent type

try: 
    # Retrieves security for the given agent
    api_response = api_instance.security_bundle(agentId, agentClass, agentType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentDeployerApi->securityBundle: %s\n" % e)

Parameters

Query parameters
Name Description
agentId*
String
The agent identifier
Required
agentClass*
String
The agent class
Required
agentType*
String
The agent type
Required

Responses

Status: 200 - successful operation


AgentManager

attributes

Gets the available attributes for the agent manager table


/agent-manager/attributes

Usage and SDK Samples

curl -X GET\
-H "Accept: */*"\
"/efm/api/agent-manager/attributes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentManagerApi;

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

public class AgentManagerApiExample {

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

public class AgentManagerApiExample {

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

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

// Gets the available attributes for the agent manager table
[apiInstance attributesWithCompletionHandler: 
              ^(AttributesResponse 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.AgentManagerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.attributes(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentManagerApi();

            try
            {
                // Gets the available attributes for the agent manager table
                AttributesResponse result = apiInstance.attributes();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentManagerApi.attributes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try: 
    # Gets the available attributes for the agent manager table
    api_response = api_instance.attributes()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentManagerApi->attributes: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


getListing

Agent manager listing


/agent-manager

Usage and SDK Samples

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

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

public class AgentManagerApiExample {

    public static void main(String[] args) {
        
        AgentManagerApi apiInstance = new AgentManagerApi();
        Integer pageNum = 56; // Integer | The zero-indexed page number to retrieve. Default is 0.
        Integer rows = 56; // Integer | The number of results to include per page. Default is 10.
        array[String] sort = ; // array[String] | Sorting by in the following format: field:DESC
        array[String] filter = ; // array[String] | Filter by in the following format: field:operator:value
        try {
            AgentListingResponse result = apiInstance.getListing(pageNum, rows, sort, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManagerApi#getListing");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentManagerApi;

public class AgentManagerApiExample {

    public static void main(String[] args) {
        AgentManagerApi apiInstance = new AgentManagerApi();
        Integer pageNum = 56; // Integer | The zero-indexed page number to retrieve. Default is 0.
        Integer rows = 56; // Integer | The number of results to include per page. Default is 10.
        array[String] sort = ; // array[String] | Sorting by in the following format: field:DESC
        array[String] filter = ; // array[String] | Filter by in the following format: field:operator:value
        try {
            AgentListingResponse result = apiInstance.getListing(pageNum, rows, sort, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManagerApi#getListing");
            e.printStackTrace();
        }
    }
}
Integer *pageNum = 56; // The zero-indexed page number to retrieve. Default is 0. (optional)
Integer *rows = 56; // The number of results to include per page. Default is 10. (optional)
array[String] *sort = ; // Sorting by in the following format: field:DESC (optional)
array[String] *filter = ; // Filter by in the following format: field:operator:value (optional)

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

// Agent manager listing
[apiInstance getListingWith:pageNum
    rows:rows
    sort:sort
    filter:filter
              completionHandler: ^(AgentListingResponse 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.AgentManagerApi()
var opts = { 
  'pageNum': 56, // {{Integer}} The zero-indexed page number to retrieve. Default is 0.
  'rows': 56, // {{Integer}} The number of results to include per page. Default is 10.
  'sort': , // {{array[String]}} Sorting by in the following format: field:DESC
  'filter':  // {{array[String]}} Filter by in the following format: field:operator:value
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getListing(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentManagerApi();
            var pageNum = 56;  // Integer | The zero-indexed page number to retrieve. Default is 0. (optional) 
            var rows = 56;  // Integer | The number of results to include per page. Default is 10. (optional) 
            var sort = new array[String](); // array[String] | Sorting by in the following format: field:DESC (optional) 
            var filter = new array[String](); // array[String] | Filter by in the following format: field:operator:value (optional) 

            try
            {
                // Agent manager listing
                AgentListingResponse result = apiInstance.getListing(pageNum, rows, sort, filter);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentManagerApi.getListing: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentManagerApi();
$pageNum = 56; // Integer | The zero-indexed page number to retrieve. Default is 0.
$rows = 56; // Integer | The number of results to include per page. Default is 10.
$sort = ; // array[String] | Sorting by in the following format: field:DESC
$filter = ; // array[String] | Filter by in the following format: field:operator:value

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

my $api_instance = WWW::SwaggerClient::AgentManagerApi->new();
my $pageNum = 56; # Integer | The zero-indexed page number to retrieve. Default is 0.
my $rows = 56; # Integer | The number of results to include per page. Default is 10.
my $sort = []; # array[String] | Sorting by in the following format: field:DESC
my $filter = []; # array[String] | Filter by in the following format: field:operator:value

eval { 
    my $result = $api_instance->getListing(pageNum => $pageNum, rows => $rows, sort => $sort, filter => $filter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentManagerApi->getListing: $@\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.AgentManagerApi()
pageNum = 56 # Integer | The zero-indexed page number to retrieve. Default is 0. (optional)
rows = 56 # Integer | The number of results to include per page. Default is 10. (optional)
sort =  # array[String] | Sorting by in the following format: field:DESC (optional)
filter =  # array[String] | Filter by in the following format: field:operator:value (optional)

try: 
    # Agent manager listing
    api_response = api_instance.get_listing(pageNum=pageNum, rows=rows, sort=sort, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentManagerApi->getListing: %s\n" % e)

Parameters

Query parameters
Name Description
pageNum
Integer (int32)
The zero-indexed page number to retrieve. Default is 0.
rows
Integer (int32)
The number of results to include per page. Default is 10.
sort
array[String]
Sorting by in the following format: field:DESC
filter
array[String]
Filter by in the following format: field:operator:value

Responses

Status: 200 - successful operation


properties

Gets the current property names and values for the agent


/agent-manager/agents/{agentId}/properties

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/agent-manager/agents/{agentId}/properties"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentManagerApi;

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

public class AgentManagerApiExample {

    public static void main(String[] args) {
        
        AgentManagerApi apiInstance = new AgentManagerApi();
        String agentId = agentId_example; // String | The id of the agent
        try {
            map['String', 'String'] result = apiInstance.properties(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManagerApi#properties");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentManagerApi;

public class AgentManagerApiExample {

    public static void main(String[] args) {
        AgentManagerApi apiInstance = new AgentManagerApi();
        String agentId = agentId_example; // String | The id of the agent
        try {
            map['String', 'String'] result = apiInstance.properties(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentManagerApi#properties");
            e.printStackTrace();
        }
    }
}
String *agentId = agentId_example; // The id of the agent

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

// Gets the current property names and values for the agent
[apiInstance propertiesWith:agentId
              completionHandler: ^(map['String', '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.AgentManagerApi()
var agentId = agentId_example; // {{String}} The id of the agent

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

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

            var apiInstance = new AgentManagerApi();
            var agentId = agentId_example;  // String | The id of the agent

            try
            {
                // Gets the current property names and values for the agent
                map['String', 'String'] result = apiInstance.properties(agentId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentManagerApi.properties: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentManagerApi();
$agentId = agentId_example; // String | The id of the agent

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

my $api_instance = WWW::SwaggerClient::AgentManagerApi->new();
my $agentId = agentId_example; # String | The id of the agent

eval { 
    my $result = $api_instance->properties(agentId => $agentId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentManagerApi->properties: $@\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.AgentManagerApi()
agentId = agentId_example # String | The id of the agent

try: 
    # Gets the current property names and values for the agent
    api_response = api_instance.properties(agentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentManagerApi->properties: %s\n" % e)

Parameters

Path parameters
Name Description
agentId*
String
The id of the agent
Required

Responses

Status: 200 - successful operation


AgentManifests

createAgentManifest

Upload an agent manifest


/agent-manifests

Usage and SDK Samples

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

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

public class AgentManifestsApiExample {

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

public class AgentManifestsApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


deleteAgentManifest

Delete the agent manifest specified by id


/agent-manifests/{id}

Usage and SDK Samples

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

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

public class AgentManifestsApiExample {

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

public class AgentManifestsApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 200 - successful operation


getAgentManifest

Get the agent manifest specified by the id


/agent-manifests/{id}

Usage and SDK Samples

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

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

public class AgentManifestsApiExample {

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

public class AgentManifestsApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 200 - successful operation


getAgentManifests

Get all agent manifests. [BETA]


/agent-manifests

Usage and SDK Samples

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

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

public class AgentManifestsApiExample {

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

public class AgentManifestsApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


Agents

createAgentParameters

Register a set of Parameters to use with this agent.


/agents/{id}/parameters

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/agents/{id}/parameters"
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 provide parameters for
        array[Parameter] body = ; // array[Parameter] | The metadata of the agent to register
        try {
            ParameterContext result = apiInstance.createAgentParameters(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#createAgentParameters");
            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 provide parameters for
        array[Parameter] body = ; // array[Parameter] | The metadata of the agent to register
        try {
            ParameterContext result = apiInstance.createAgentParameters(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#createAgentParameters");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The identifier of the agent to provide parameters for
array[Parameter] *body = ; // The metadata of the agent to register (optional)

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

// Register a set of Parameters to use with this agent.
[apiInstance createAgentParametersWith:id
    body:body
              completionHandler: ^(ParameterContext 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 provide parameters for
var opts = { 
  'body':  // {{array[Parameter]}} 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.createAgentParameters(id, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentsApi();
            var id = id_example;  // String | The identifier of the agent to provide parameters for
            var body = new array[Parameter](); // array[Parameter] | The metadata of the agent to register (optional) 

            try
            {
                // Register a set of Parameters to use with this agent.
                ParameterContext result = apiInstance.createAgentParameters(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.createAgentParameters: " + 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 provide parameters for
$body = ; // array[Parameter] | The metadata of the agent to register

try {
    $result = $api_instance->createAgentParameters($id, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AgentsApi->createAgentParameters: ', $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 provide parameters for
my $body = [WWW::SwaggerClient::Object::array[Parameter]->new()]; # array[Parameter] | The metadata of the agent to register

eval { 
    my $result = $api_instance->createAgentParameters(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentsApi->createAgentParameters: $@\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 provide parameters for
body =  # array[Parameter] | The metadata of the agent to register (optional)

try: 
    # Register a set of Parameters to use with this agent.
    api_response = api_instance.create_agent_parameters(id, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentsApi->createAgentParameters: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The identifier of the agent to provide parameters for
Required
Body parameters
Name Description
body

Responses

Status: 200 - successful operation


deleteAgent

Delete an agent registered with this C2 server


/agents/{id}

Usage and SDK Samples

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

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

public class AgentsApiExample {

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

public class AgentsApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


deleteAgentParameters

Delete an instance specific parameter context


/agents/{id}/parameters

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/agents/{id}/parameters"
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 its parameter context
        try {
            ParameterContext result = apiInstance.deleteAgentParameters(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#deleteAgentParameters");
            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 its parameter context
        try {
            ParameterContext result = apiInstance.deleteAgentParameters(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#deleteAgentParameters");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The identifier of the agent to delete its parameter context

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

// Delete an instance specific parameter context
[apiInstance deleteAgentParametersWith:id
              completionHandler: ^(ParameterContext 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 its parameter context

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

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

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

            try
            {
                // Delete an instance specific parameter context
                ParameterContext result = apiInstance.deleteAgentParameters(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.deleteAgentParameters: " + 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 its parameter context

try {
    $result = $api_instance->deleteAgentParameters($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AgentsApi->deleteAgentParameters: ', $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 its parameter context

eval { 
    my $result = $api_instance->deleteAgentParameters(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentsApi->deleteAgentParameters: $@\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 its parameter context

try: 
    # Delete an instance specific parameter context
    api_response = api_instance.delete_agent_parameters(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentsApi->deleteAgentParameters: %s\n" % e)

Parameters

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

Responses

Status: 200 - successful operation


getAgent

Retrieve info for a MiNiFi agent registered with this C2 server


/agents/{id}

Usage and SDK Samples

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

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

public class AgentsApiExample {

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

public class AgentsApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


getAgentParameters

Retrieve the parameter context for a MiNiFi agent with the specified id


/agents/{id}/parameters

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/agents/{id}/parameters"
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 parameters for
        try {
            ParameterContext result = apiInstance.getAgentParameters(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#getAgentParameters");
            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 parameters for
        try {
            ParameterContext result = apiInstance.getAgentParameters(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#getAgentParameters");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The identifier of the agent to retrieve parameters for

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

// Retrieve the parameter context for a MiNiFi agent with the specified id
[apiInstance getAgentParametersWith:id
              completionHandler: ^(ParameterContext 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 parameters for

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

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

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

            try
            {
                // Retrieve the parameter context for a MiNiFi agent with the specified id
                ParameterContext result = apiInstance.getAgentParameters(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.getAgentParameters: " + 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 parameters for

try {
    $result = $api_instance->getAgentParameters($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AgentsApi->getAgentParameters: ', $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 parameters for

eval { 
    my $result = $api_instance->getAgentParameters(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentsApi->getAgentParameters: $@\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 parameters for

try: 
    # Retrieve the parameter context for a MiNiFi agent with the specified id
    api_response = api_instance.get_agent_parameters(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentsApi->getAgentParameters: %s\n" % e)

Parameters

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

Responses

Status: 200 - successful operation


getAgentsPage

Get all MiNiFi agents, one page at a time. Page numbers are zero-indexed.


/agents/page

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/agents/page?pageNum=&rows=&agentClass=&state="
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();
        Integer pageNum = 56; // Integer | The zero-indexed page number to retrieve. Default is 0.
        Integer rows = 56; // Integer | The number of results to include per page. Default is 10.
        String agentClass = agentClass_example; // String | Filter results by agent class. If not specified, this filter is not applied.
        String state = state_example; // String | Filter results by agent state. If not specified, this filter is not applied.
        try {
            AgentList result = apiInstance.getAgentsPage(pageNum, rows, agentClass, state);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#getAgentsPage");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentsApi;

public class AgentsApiExample {

    public static void main(String[] args) {
        AgentsApi apiInstance = new AgentsApi();
        Integer pageNum = 56; // Integer | The zero-indexed page number to retrieve. Default is 0.
        Integer rows = 56; // Integer | The number of results to include per page. Default is 10.
        String agentClass = agentClass_example; // String | Filter results by agent class. If not specified, this filter is not applied.
        String state = state_example; // String | Filter results by agent state. If not specified, this filter is not applied.
        try {
            AgentList result = apiInstance.getAgentsPage(pageNum, rows, agentClass, state);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#getAgentsPage");
            e.printStackTrace();
        }
    }
}
Integer *pageNum = 56; // The zero-indexed page number to retrieve. Default is 0. (optional)
Integer *rows = 56; // The number of results to include per page. Default is 10. (optional)
String *agentClass = agentClass_example; // Filter results by agent class. If not specified, this filter is not applied. (optional)
String *state = state_example; // Filter results by agent state. If not specified, this filter is not applied. (optional)

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

// Get all MiNiFi agents, one page at a time. Page numbers are zero-indexed.
[apiInstance getAgentsPageWith:pageNum
    rows:rows
    agentClass:agentClass
    state:state
              completionHandler: ^(AgentList 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 = { 
  'pageNum': 56, // {{Integer}} The zero-indexed page number to retrieve. Default is 0.
  'rows': 56, // {{Integer}} The number of results to include per page. Default is 10.
  'agentClass': agentClass_example, // {{String}} Filter results by agent class. If not specified, this filter is not applied.
  'state': state_example // {{String}} Filter results by agent state. If not specified, this filter is not applied.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAgentsPage(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentsApi();
            var pageNum = 56;  // Integer | The zero-indexed page number to retrieve. Default is 0. (optional) 
            var rows = 56;  // Integer | The number of results to include per page. Default is 10. (optional) 
            var agentClass = agentClass_example;  // String | Filter results by agent class. If not specified, this filter is not applied. (optional) 
            var state = state_example;  // String | Filter results by agent state. If not specified, this filter is not applied. (optional) 

            try
            {
                // Get all MiNiFi agents, one page at a time. Page numbers are zero-indexed.
                AgentList result = apiInstance.getAgentsPage(pageNum, rows, agentClass, state);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.getAgentsPage: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentsApi();
$pageNum = 56; // Integer | The zero-indexed page number to retrieve. Default is 0.
$rows = 56; // Integer | The number of results to include per page. Default is 10.
$agentClass = agentClass_example; // String | Filter results by agent class. If not specified, this filter is not applied.
$state = state_example; // String | Filter results by agent state. If not specified, this filter is not applied.

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

my $api_instance = WWW::SwaggerClient::AgentsApi->new();
my $pageNum = 56; # Integer | The zero-indexed page number to retrieve. Default is 0.
my $rows = 56; # Integer | The number of results to include per page. Default is 10.
my $agentClass = agentClass_example; # String | Filter results by agent class. If not specified, this filter is not applied.
my $state = state_example; # String | Filter results by agent state. If not specified, this filter is not applied.

eval { 
    my $result = $api_instance->getAgentsPage(pageNum => $pageNum, rows => $rows, agentClass => $agentClass, state => $state);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentsApi->getAgentsPage: $@\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()
pageNum = 56 # Integer | The zero-indexed page number to retrieve. Default is 0. (optional)
rows = 56 # Integer | The number of results to include per page. Default is 10. (optional)
agentClass = agentClass_example # String | Filter results by agent class. If not specified, this filter is not applied. (optional)
state = state_example # String | Filter results by agent state. If not specified, this filter is not applied. (optional)

try: 
    # Get all MiNiFi agents, one page at a time. Page numbers are zero-indexed.
    api_response = api_instance.get_agents_page(pageNum=pageNum, rows=rows, agentClass=agentClass, state=state)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentsApi->getAgentsPage: %s\n" % e)

Parameters

Query parameters
Name Description
pageNum
Integer (int32)
The zero-indexed page number to retrieve. Default is 0.
rows
Integer (int32)
The number of results to include per page. Default is 10.
agentClass
String
Filter results by agent class. If not specified, this filter is not applied.
state
String
Filter results by agent state. If not specified, this filter is not applied.

Responses

Status: 200 - successful operation


updateAgentParameters

Update a set of Parameters to use with this agent.


/agents/{id}/parameters

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/agents/{id}/parameters"
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 update parameters of
        array[Parameter] body = ; // array[Parameter] | The metadata of the agent to update
        try {
            ParameterContext result = apiInstance.updateAgentParameters(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#updateAgentParameters");
            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 update parameters of
        array[Parameter] body = ; // array[Parameter] | The metadata of the agent to update
        try {
            ParameterContext result = apiInstance.updateAgentParameters(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#updateAgentParameters");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The identifier of the agent to update parameters of
array[Parameter] *body = ; // The metadata of the agent to update (optional)

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

// Update a set of Parameters to use with this agent.
[apiInstance updateAgentParametersWith:id
    body:body
              completionHandler: ^(ParameterContext 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 update parameters of
var opts = { 
  'body':  // {{array[Parameter]}} The metadata of the agent to update
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateAgentParameters(id, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new AgentsApi();
            var id = id_example;  // String | The identifier of the agent to update parameters of
            var body = new array[Parameter](); // array[Parameter] | The metadata of the agent to update (optional) 

            try
            {
                // Update a set of Parameters to use with this agent.
                ParameterContext result = apiInstance.updateAgentParameters(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.updateAgentParameters: " + 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 update parameters of
$body = ; // array[Parameter] | The metadata of the agent to update

try {
    $result = $api_instance->updateAgentParameters($id, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AgentsApi->updateAgentParameters: ', $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 update parameters of
my $body = [WWW::SwaggerClient::Object::array[Parameter]->new()]; # array[Parameter] | The metadata of the agent to update

eval { 
    my $result = $api_instance->updateAgentParameters(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AgentsApi->updateAgentParameters: $@\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 update parameters of
body =  # array[Parameter] | The metadata of the agent to update (optional)

try: 
    # Update a set of Parameters to use with this agent.
    api_response = api_instance.update_agent_parameters(id, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AgentsApi->updateAgentParameters: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The identifier of the agent to update parameters of
Required
Body parameters
Name Description
body

Responses

Status: 200 - successful operation


C2Protocol

acknowledge

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


/c2-protocol/acknowledge

Usage and SDK Samples

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

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

public class C2ProtocolApiExample {

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

public class C2ProtocolApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

Body parameters
Name Description
body *

Responses

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


heartbeat

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


/c2-protocol/heartbeat

Usage and SDK Samples

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

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

public class C2ProtocolApiExample {

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

public class C2ProtocolApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

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


C2ProtocolCallback

fetchAssetData

An endpoint for a MiNiFi Agent to fetch the requested asset from


/c2-protocol/asset/{id}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/octet-stream"\
"/efm/api/c2-protocol/asset/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.C2ProtocolCallbackApi;

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

public class C2ProtocolCallbackApiExample {

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

public class C2ProtocolCallbackApiExample {

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

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

// An endpoint for a MiNiFi Agent to fetch the requested asset from
[apiInstance fetchAssetDataWith:id
              completionHandler: ^(ByteArrayResource 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.C2ProtocolCallbackApi()
var id = id_example; // {{String}} The id of an asset to retrieve

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

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

            var apiInstance = new C2ProtocolCallbackApi();
            var id = id_example;  // String | The id of an asset to retrieve

            try
            {
                // An endpoint for a MiNiFi Agent to fetch the requested asset from
                ByteArrayResource result = apiInstance.fetchAssetData(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling C2ProtocolCallbackApi.fetchAssetData: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiC2ProtocolCallbackApi();
$id = id_example; // String | The id of an asset to retrieve

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

my $api_instance = WWW::SwaggerClient::C2ProtocolCallbackApi->new();
my $id = id_example; # String | The id of an asset to retrieve

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

try: 
    # An endpoint for a MiNiFi Agent to fetch the requested asset from
    api_response = api_instance.fetch_asset_data(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling C2ProtocolCallbackApi->fetchAssetData: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The id of an asset to retrieve
Required

Responses

Status: 200 - successful operation


fetchFlowContent

Get a flow definition by id with a format requested in the accept header


/c2-protocol/flows/{id}

Usage and SDK Samples

curl -X GET\
-H "Accept: */*"\
"/efm/api/c2-protocol/flows/{id}?aid="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.C2ProtocolCallbackApi;

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

public class C2ProtocolCallbackApiExample {

    public static void main(String[] args) {
        
        C2ProtocolCallbackApi apiInstance = new C2ProtocolCallbackApi();
        String id = id_example; // String | The id of a flow to retrieve
        String aid = aid_example; // String | The specific agent context to use with the requested flow.  This is overlaid over any class or flow values.
        try {
            'String' result = apiInstance.fetchFlowContent(id, aid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ProtocolCallbackApi#fetchFlowContent");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.C2ProtocolCallbackApi;

public class C2ProtocolCallbackApiExample {

    public static void main(String[] args) {
        C2ProtocolCallbackApi apiInstance = new C2ProtocolCallbackApi();
        String id = id_example; // String | The id of a flow to retrieve
        String aid = aid_example; // String | The specific agent context to use with the requested flow.  This is overlaid over any class or flow values.
        try {
            'String' result = apiInstance.fetchFlowContent(id, aid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ProtocolCallbackApi#fetchFlowContent");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The id of a flow to retrieve
String *aid = aid_example; // The specific agent context to use with the requested flow.  This is overlaid over any class or flow values. (optional)

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

// Get a flow definition by id with a format requested in the accept header
[apiInstance fetchFlowContentWith:id
    aid:aid
              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.C2ProtocolCallbackApi()
var id = id_example; // {{String}} The id of a flow to retrieve
var opts = { 
  'aid': aid_example // {{String}} The specific agent context to use with the requested flow.  This is overlaid over any class or flow values.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.fetchFlowContent(id, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new C2ProtocolCallbackApi();
            var id = id_example;  // String | The id of a flow to retrieve
            var aid = aid_example;  // String | The specific agent context to use with the requested flow.  This is overlaid over any class or flow values. (optional) 

            try
            {
                // Get a flow definition by id with a format requested in the accept header
                'String' result = apiInstance.fetchFlowContent(id, aid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling C2ProtocolCallbackApi.fetchFlowContent: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiC2ProtocolCallbackApi();
$id = id_example; // String | The id of a flow to retrieve
$aid = aid_example; // String | The specific agent context to use with the requested flow.  This is overlaid over any class or flow values.

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

my $api_instance = WWW::SwaggerClient::C2ProtocolCallbackApi->new();
my $id = id_example; # String | The id of a flow to retrieve
my $aid = aid_example; # String | The specific agent context to use with the requested flow.  This is overlaid over any class or flow values.

eval { 
    my $result = $api_instance->fetchFlowContent(id => $id, aid => $aid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling C2ProtocolCallbackApi->fetchFlowContent: $@\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.C2ProtocolCallbackApi()
id = id_example # String | The id of a flow to retrieve
aid = aid_example # String | The specific agent context to use with the requested flow.  This is overlaid over any class or flow values. (optional)

try: 
    # Get a flow definition by id with a format requested in the accept header
    api_response = api_instance.fetch_flow_content(id, aid=aid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling C2ProtocolCallbackApi->fetchFlowContent: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The id of a flow to retrieve
Required
Query parameters
Name Description
aid
String
The specific agent context to use with the requested flow. This is overlaid over any class or flow values.

Responses

Status: 200 - successful operation


uploadTransferData

Transfers file from C2 client to C2 server


/c2-protocol/transfer/{id}

Usage and SDK Samples

curl -X POST\
-H "Content-Type: multipart/form-data"\
"/efm/api/c2-protocol/transfer/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.C2ProtocolCallbackApi;

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

public class C2ProtocolCallbackApiExample {

    public static void main(String[] args) {
        
        C2ProtocolCallbackApi apiInstance = new C2ProtocolCallbackApi();
        byte[] file = file_example; // byte[] | 
        String id = id_example; // String | The identifier of the transfer data entry to attach the file to
        try {
            apiInstance.uploadTransferData(file, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ProtocolCallbackApi#uploadTransferData");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.C2ProtocolCallbackApi;

public class C2ProtocolCallbackApiExample {

    public static void main(String[] args) {
        C2ProtocolCallbackApi apiInstance = new C2ProtocolCallbackApi();
        byte[] file = file_example; // byte[] | 
        String id = id_example; // String | The identifier of the transfer data entry to attach the file to
        try {
            apiInstance.uploadTransferData(file, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling C2ProtocolCallbackApi#uploadTransferData");
            e.printStackTrace();
        }
    }
}
byte[] *file = file_example; // 
String *id = id_example; // The identifier of the transfer data entry to attach the file to

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

// Transfers file from C2 client to C2 server
[apiInstance uploadTransferDataWith:file
    id:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.C2ProtocolCallbackApi()
var file = file_example; // {{byte[]}} 
var id = id_example; // {{String}} The identifier of the transfer data entry to attach the file to

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

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

            var apiInstance = new C2ProtocolCallbackApi();
            var file = file_example;  // byte[] | 
            var id = id_example;  // String | The identifier of the transfer data entry to attach the file to

            try
            {
                // Transfers file from C2 client to C2 server
                apiInstance.uploadTransferData(file, id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling C2ProtocolCallbackApi.uploadTransferData: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiC2ProtocolCallbackApi();
$file = file_example; // byte[] | 
$id = id_example; // String | The identifier of the transfer data entry to attach the file to

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

my $api_instance = WWW::SwaggerClient::C2ProtocolCallbackApi->new();
my $file = file_example; # byte[] | 
my $id = id_example; # String | The identifier of the transfer data entry to attach the file to

eval { 
    $api_instance->uploadTransferData(file => $file, id => $id);
};
if ($@) {
    warn "Exception when calling C2ProtocolCallbackApi->uploadTransferData: $@\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.C2ProtocolCallbackApi()
file = file_example # byte[] | 
id = id_example # String | The identifier of the transfer data entry to attach the file to

try: 
    # Transfers file from C2 client to C2 server
    api_instance.upload_transfer_data(file, id)
except ApiException as e:
    print("Exception when calling C2ProtocolCallbackApi->uploadTransferData: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The identifier of the transfer data entry to attach the file to
Required
Form parameters
Name Description
file*
byte[] (binary)
Required

Responses

Status: default - successful operation


Commands

createDebugOperation

Submit a debug operation targeting a MiNiFi agent.


/commands/{agentId}/debug

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"/efm/api/commands/{agentId}/debug"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CommandsApi;

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

public class CommandsApiExample {

    public static void main(String[] args) {
        
        CommandsApi apiInstance = new CommandsApi();
        String agentId = agentId_example; // String | The identifier of the agent the operation should be executed on
        try {
            Operation result = apiInstance.createDebugOperation(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#createDebugOperation");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CommandsApi;

public class CommandsApiExample {

    public static void main(String[] args) {
        CommandsApi apiInstance = new CommandsApi();
        String agentId = agentId_example; // String | The identifier of the agent the operation should be executed on
        try {
            Operation result = apiInstance.createDebugOperation(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#createDebugOperation");
            e.printStackTrace();
        }
    }
}
String *agentId = agentId_example; // The identifier of the agent the operation should be executed on

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

// Submit a debug operation targeting a MiNiFi agent.
[apiInstance createDebugOperationWith:agentId
              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.CommandsApi()
var agentId = agentId_example; // {{String}} The identifier of the agent the operation should be executed on

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

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

            var apiInstance = new CommandsApi();
            var agentId = agentId_example;  // String | The identifier of the agent the operation should be executed on

            try
            {
                // Submit a debug operation targeting a MiNiFi agent.
                Operation result = apiInstance.createDebugOperation(agentId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommandsApi.createDebugOperation: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiCommandsApi();
$agentId = agentId_example; // String | The identifier of the agent the operation should be executed on

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

my $api_instance = WWW::SwaggerClient::CommandsApi->new();
my $agentId = agentId_example; # String | The identifier of the agent the operation should be executed on

eval { 
    my $result = $api_instance->createDebugOperation(agentId => $agentId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CommandsApi->createDebugOperation: $@\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.CommandsApi()
agentId = agentId_example # String | The identifier of the agent the operation should be executed on

try: 
    # Submit a debug operation targeting a MiNiFi agent.
    api_response = api_instance.create_debug_operation(agentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommandsApi->createDebugOperation: %s\n" % e)

Parameters

Path parameters
Name Description
agentId*
String
The identifier of the agent the operation should be executed on
Required

Responses

Status: 200 - successful operation


createPropertyUpdateOperation

Submit a property update operation targeting all MiNiFi agents associated with the given agent class.


/commands/property-update

Usage and SDK Samples

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

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

public class CommandsApiExample {

    public static void main(String[] args) {
        
        CommandsApi apiInstance = new CommandsApi();
        PropertyUpdateCommandRequest body = ; // PropertyUpdateCommandRequest | The update request payload with agentClass and properties details
        try {
            PropertyUpdateCommandResponse result = apiInstance.createPropertyUpdateOperation(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#createPropertyUpdateOperation");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CommandsApi;

public class CommandsApiExample {

    public static void main(String[] args) {
        CommandsApi apiInstance = new CommandsApi();
        PropertyUpdateCommandRequest body = ; // PropertyUpdateCommandRequest | The update request payload with agentClass and properties details
        try {
            PropertyUpdateCommandResponse result = apiInstance.createPropertyUpdateOperation(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#createPropertyUpdateOperation");
            e.printStackTrace();
        }
    }
}
PropertyUpdateCommandRequest *body = ; // The update request payload with agentClass and properties details

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

// Submit a property update operation targeting all MiNiFi agents associated with the given agent class.
[apiInstance createPropertyUpdateOperationWith:body
              completionHandler: ^(PropertyUpdateCommandResponse 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.CommandsApi()
var body = ; // {{PropertyUpdateCommandRequest}} The update request payload with agentClass and properties details

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

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

            var apiInstance = new CommandsApi();
            var body = new PropertyUpdateCommandRequest(); // PropertyUpdateCommandRequest | The update request payload with agentClass and properties details

            try
            {
                // Submit a property update operation targeting all MiNiFi agents associated with the given agent class.
                PropertyUpdateCommandResponse result = apiInstance.createPropertyUpdateOperation(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommandsApi.createPropertyUpdateOperation: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiCommandsApi();
$body = ; // PropertyUpdateCommandRequest | The update request payload with agentClass and properties details

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

my $api_instance = WWW::SwaggerClient::CommandsApi->new();
my $body = WWW::SwaggerClient::Object::PropertyUpdateCommandRequest->new(); # PropertyUpdateCommandRequest | The update request payload with agentClass and properties details

eval { 
    my $result = $api_instance->createPropertyUpdateOperation(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CommandsApi->createPropertyUpdateOperation: $@\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.CommandsApi()
body =  # PropertyUpdateCommandRequest | The update request payload with agentClass and properties details

try: 
    # Submit a property update operation targeting all MiNiFi agents associated with the given agent class.
    api_response = api_instance.create_property_update_operation(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommandsApi->createPropertyUpdateOperation: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


createUpdateAssetOperation

Submit an asset update operation targeting a MiNiFi agent class. [BETA]


/commands/{agentClass}/update-asset

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/commands/{agentClass}/update-asset"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CommandsApi;

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

public class CommandsApiExample {

    public static void main(String[] args) {
        
        CommandsApi apiInstance = new CommandsApi();
        AssetUpdateCommandRequest body = ; // AssetUpdateCommandRequest | The request object of the asset update
        String agentClass = agentClass_example; // String | The class of the agent the operation should be executed on
        try {
            AssetUpdateCommandResponse result = apiInstance.createUpdateAssetOperation(body, agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#createUpdateAssetOperation");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CommandsApi;

public class CommandsApiExample {

    public static void main(String[] args) {
        CommandsApi apiInstance = new CommandsApi();
        AssetUpdateCommandRequest body = ; // AssetUpdateCommandRequest | The request object of the asset update
        String agentClass = agentClass_example; // String | The class of the agent the operation should be executed on
        try {
            AssetUpdateCommandResponse result = apiInstance.createUpdateAssetOperation(body, agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#createUpdateAssetOperation");
            e.printStackTrace();
        }
    }
}
AssetUpdateCommandRequest *body = ; // The request object of the asset update
String *agentClass = agentClass_example; // The class of the agent the operation should be executed on

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

// Submit an asset update operation targeting a MiNiFi agent class. [BETA]
[apiInstance createUpdateAssetOperationWith:body
    agentClass:agentClass
              completionHandler: ^(AssetUpdateCommandResponse 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.CommandsApi()
var body = ; // {{AssetUpdateCommandRequest}} The request object of the asset update
var agentClass = agentClass_example; // {{String}} The class of the agent the operation should be executed on

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

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

            var apiInstance = new CommandsApi();
            var body = new AssetUpdateCommandRequest(); // AssetUpdateCommandRequest | The request object of the asset update
            var agentClass = agentClass_example;  // String | The class of the agent the operation should be executed on

            try
            {
                // Submit an asset update operation targeting a MiNiFi agent class. [BETA]
                AssetUpdateCommandResponse result = apiInstance.createUpdateAssetOperation(body, agentClass);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommandsApi.createUpdateAssetOperation: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiCommandsApi();
$body = ; // AssetUpdateCommandRequest | The request object of the asset update
$agentClass = agentClass_example; // String | The class of the agent the operation should be executed on

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

my $api_instance = WWW::SwaggerClient::CommandsApi->new();
my $body = WWW::SwaggerClient::Object::AssetUpdateCommandRequest->new(); # AssetUpdateCommandRequest | The request object of the asset update
my $agentClass = agentClass_example; # String | The class of the agent the operation should be executed on

eval { 
    my $result = $api_instance->createUpdateAssetOperation(body => $body, agentClass => $agentClass);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CommandsApi->createUpdateAssetOperation: $@\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.CommandsApi()
body =  # AssetUpdateCommandRequest | The request object of the asset update
agentClass = agentClass_example # String | The class of the agent the operation should be executed on

try: 
    # Submit an asset update operation targeting a MiNiFi agent class. [BETA]
    api_response = api_instance.create_update_asset_operation(body, agentClass)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommandsApi->createUpdateAssetOperation: %s\n" % e)

Parameters

Path parameters
Name Description
agentClass*
String
The class of the agent the operation should be executed on
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


getAgentClassPropertyNamesAndValidatorsForUpdate

Retrieve the available property names to be updated under the given agent class.


/commands/{agentClass}/property-names

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/commands/{agentClass}/property-names"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CommandsApi;

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

public class CommandsApiExample {

    public static void main(String[] args) {
        
        CommandsApi apiInstance = new CommandsApi();
        String agentClass = agentClass_example; // String | The name of the agent class
        try {
            AgentPropertyValidatorResponse result = apiInstance.getAgentClassPropertyNamesAndValidatorsForUpdate(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#getAgentClassPropertyNamesAndValidatorsForUpdate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CommandsApi;

public class CommandsApiExample {

    public static void main(String[] args) {
        CommandsApi apiInstance = new CommandsApi();
        String agentClass = agentClass_example; // String | The name of the agent class
        try {
            AgentPropertyValidatorResponse result = apiInstance.getAgentClassPropertyNamesAndValidatorsForUpdate(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#getAgentClassPropertyNamesAndValidatorsForUpdate");
            e.printStackTrace();
        }
    }
}
String *agentClass = agentClass_example; // The name of the agent class

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

// Retrieve the available property names to be updated under the given agent class.
[apiInstance getAgentClassPropertyNamesAndValidatorsForUpdateWith:agentClass
              completionHandler: ^(AgentPropertyValidatorResponse 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.CommandsApi()
var agentClass = agentClass_example; // {{String}} The name of the agent class

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

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

            var apiInstance = new CommandsApi();
            var agentClass = agentClass_example;  // String | The name of the agent class

            try
            {
                // Retrieve the available property names to be updated under the given agent class.
                AgentPropertyValidatorResponse result = apiInstance.getAgentClassPropertyNamesAndValidatorsForUpdate(agentClass);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommandsApi.getAgentClassPropertyNamesAndValidatorsForUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiCommandsApi();
$agentClass = agentClass_example; // String | The name of the agent class

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

my $api_instance = WWW::SwaggerClient::CommandsApi->new();
my $agentClass = agentClass_example; # String | The name of the agent class

eval { 
    my $result = $api_instance->getAgentClassPropertyNamesAndValidatorsForUpdate(agentClass => $agentClass);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CommandsApi->getAgentClassPropertyNamesAndValidatorsForUpdate: $@\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.CommandsApi()
agentClass = agentClass_example # String | The name of the agent class

try: 
    # Retrieve the available property names to be updated under the given agent class.
    api_response = api_instance.get_agent_class_property_names_and_validators_for_update(agentClass)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommandsApi->getAgentClassPropertyNamesAndValidatorsForUpdate: %s\n" % e)

Parameters

Path parameters
Name Description
agentClass*
String
The name of the agent class
Required

Responses

Status: 200 - successful operation


getCommands

Returns the previous commands for the given agent


/commands/{agentId}/history

Usage and SDK Samples

curl -X GET\
-H "Accept: */*"\
"/efm/api/commands/{agentId}/history?rows="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CommandsApi;

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

public class CommandsApiExample {

    public static void main(String[] args) {
        
        CommandsApi apiInstance = new CommandsApi();
        String agentId = agentId_example; // String | The agent identifier
        Integer rows = 56; // Integer | The number of results to include. Default is configurable via efm.agentManager.commands.displayLimit property.
        try {
            CommandListingResponse result = apiInstance.getCommands(agentId, rows);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#getCommands");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CommandsApi;

public class CommandsApiExample {

    public static void main(String[] args) {
        CommandsApi apiInstance = new CommandsApi();
        String agentId = agentId_example; // String | The agent identifier
        Integer rows = 56; // Integer | The number of results to include. Default is configurable via efm.agentManager.commands.displayLimit property.
        try {
            CommandListingResponse result = apiInstance.getCommands(agentId, rows);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommandsApi#getCommands");
            e.printStackTrace();
        }
    }
}
String *agentId = agentId_example; // The agent identifier
Integer *rows = 56; // The number of results to include. Default is configurable via efm.agentManager.commands.displayLimit property. (optional)

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

// Returns the previous commands for the given agent
[apiInstance getCommandsWith:agentId
    rows:rows
              completionHandler: ^(CommandListingResponse 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.CommandsApi()
var agentId = agentId_example; // {{String}} The agent identifier
var opts = { 
  'rows': 56 // {{Integer}} The number of results to include. Default is configurable via efm.agentManager.commands.displayLimit property.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getCommands(agentId, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new CommandsApi();
            var agentId = agentId_example;  // String | The agent identifier
            var rows = 56;  // Integer | The number of results to include. Default is configurable via efm.agentManager.commands.displayLimit property. (optional) 

            try
            {
                // Returns the previous commands for the given agent
                CommandListingResponse result = apiInstance.getCommands(agentId, rows);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommandsApi.getCommands: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiCommandsApi();
$agentId = agentId_example; // String | The agent identifier
$rows = 56; // Integer | The number of results to include. Default is configurable via efm.agentManager.commands.displayLimit property.

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

my $api_instance = WWW::SwaggerClient::CommandsApi->new();
my $agentId = agentId_example; # String | The agent identifier
my $rows = 56; # Integer | The number of results to include. Default is configurable via efm.agentManager.commands.displayLimit property.

eval { 
    my $result = $api_instance->getCommands(agentId => $agentId, rows => $rows);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CommandsApi->getCommands: $@\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.CommandsApi()
agentId = agentId_example # String | The agent identifier
rows = 56 # Integer | The number of results to include. Default is configurable via efm.agentManager.commands.displayLimit property. (optional)

try: 
    # Returns the previous commands for the given agent
    api_response = api_instance.get_commands(agentId, rows=rows)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommandsApi->getCommands: %s\n" % e)

Parameters

Path parameters
Name Description
agentId*
String
The agent identifier
Required
Query parameters
Name Description
rows
Integer (int32)
The number of results to include. Default is configurable via efm.agentManager.commands.displayLimit property.

Responses

Status: 200 - successful operation


Diagnostic

diagnosticBundle

Returns the current diagnostic bundle


/diagnostic/bundle

Usage and SDK Samples

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

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

public class DiagnosticApiExample {

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

public class DiagnosticApiExample {

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

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

// Returns the current diagnostic bundle
[apiInstance diagnosticBundleWithCompletionHandler: 
              ^(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.DiagnosticApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.diagnosticBundle(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DiagnosticApi();

            try
            {
                // Returns the current diagnostic bundle
                AgentClass result = apiInstance.diagnosticBundle();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DiagnosticApi.diagnosticBundle: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try: 
    # Returns the current diagnostic bundle
    api_response = api_instance.diagnostic_bundle()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DiagnosticApi->diagnosticBundle: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


Events

getAvailableEventFields

Retrieves the available field names for searching or sorting events.


/events/fields

Usage and SDK Samples

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

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

public class EventsApiExample {

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

public class EventsApiExample {

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

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

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

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

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

            var apiInstance = new EventsApi();

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

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

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

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

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

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

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

Parameters

Responses

Status: 200 - successful operation


getEvent

Get a specific event


/events/{id}

Usage and SDK Samples

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

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

public class EventsApiExample {

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

public class EventsApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation

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


getEvents

Get events. Page numbers are zero-indexed.


/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 {
            EventList 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 {
            EventList 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. Page numbers are zero-indexed.
[apiInstance getEventsWith:pageNum
    rows:rows
    sort:sort
    filter:filter
              completionHandler: ^(EventList 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. Page numbers are zero-indexed.
                EventList 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. Page numbers are zero-indexed.
    api_response = api_instance.get_events(pageNum=pageNum, rows=rows, sort=sort, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsApi->getEvents: %s\n" % e)

Parameters

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

Responses

Status: 200 - successful operation


FlowDesigner

createConnection

Creates a connection in the given process group


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

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

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

public class FlowDesignerApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


createControllerService

Creates a controller service in the given process group


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

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

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

public class FlowDesignerApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


createFunnel

Creates a funnel in the given process group


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

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

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

public class FlowDesignerApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


createProcessor

Creates a processor in the given process group


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

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

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

public class FlowDesignerApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


createRemoteProcessGroup

Creates a remote process group in the given process group


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

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

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

public class FlowDesignerApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


deleteConnection

Deletes the connection with the given id in the given flow


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

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

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

public class FlowDesignerApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


deleteControllerService

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


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

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

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

public class FlowDesignerApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


deleteFlow

Deletes the flow with the given id


/designer/flows/{flowId}

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

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

public class FlowDesignerApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

Path parameters
Name Description
flowId*
String
Required

Responses

Status: 200 - successful operation


deleteFunnel

Deletes the funnel with the given id in the given flow


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

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

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

public class FlowDesignerApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


deleteProcessor

Deletes the processor with the given id in the given flow


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

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

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

public class FlowDesignerApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


deleteRemoteProcessGroup

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


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

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

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

public class FlowDesignerApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


exportFlowByAgentClass

Export flow content, parameters and agent manifest for a given agent class


/designer/{agentClassName}/flows/export

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/{agentClassName}/flows/export"
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 agentClassName = agentClassName_example; // String | 
        try {
            ExportableFlow result = apiInstance.exportFlowByAgentClass(agentClassName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#exportFlowByAgentClass");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

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

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

// Export flow content, parameters and agent manifest for a given agent class
[apiInstance exportFlowByAgentClassWith:agentClassName
              completionHandler: ^(ExportableFlow 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 agentClassName = agentClassName_example; // {{String}} 

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

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

            var apiInstance = new FlowDesignerApi();
            var agentClassName = agentClassName_example;  // String | 

            try
            {
                // Export flow content, parameters and agent manifest for a given agent class
                ExportableFlow result = apiInstance.exportFlowByAgentClass(agentClassName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.exportFlowByAgentClass: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$agentClassName = agentClassName_example; // String | 

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

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

eval { 
    my $result = $api_instance->exportFlowByAgentClass(agentClassName => $agentClassName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->exportFlowByAgentClass: $@\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()
agentClassName = agentClassName_example # String | 

try: 
    # Export flow content, parameters and agent manifest for a given agent class
    api_response = api_instance.export_flow_by_agent_class(agentClassName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->exportFlowByAgentClass: %s\n" % e)

Parameters

Path parameters
Name Description
agentClassName*
String
Required

Responses

Status: 200 - successful operation


getClientId

Gets a client id to use with the designer endpoints


/designer/client-id

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

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

public class FlowDesignerApiExample {

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

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

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

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

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

            var apiInstance = new FlowDesignerApi();

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

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

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

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

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

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

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

Parameters

Responses

Status: 200 - successful operation


getClientIdentifier

Gets a client id to use with the designer endpoints


/designer/client-identifier

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/client-identifier"
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 {
            ClientIdParameter result = apiInstance.getClientIdentifier();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getClientIdentifier");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

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

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

// Gets a client id to use with the designer endpoints
[apiInstance getClientIdentifierWithCompletionHandler: 
              ^(ClientIdParameter 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.getClientIdentifier(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new FlowDesignerApi();

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

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

try {
    $result = $api_instance->getClientIdentifier();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->getClientIdentifier: ', $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->getClientIdentifier();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getClientIdentifier: $@\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_identifier()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getClientIdentifier: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


getConnection

Retrieves the connection with the given id in the given flow


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

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

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

public class FlowDesignerApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


getControllerService

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


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

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

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

public class FlowDesignerApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


getControllerServicePropertyDescriptor

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


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

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

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

public class FlowDesignerApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


getControllerServiceTypes

Gets the available controller service types for the given flow


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

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

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

public class FlowDesignerApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

Path parameters
Name Description
flowId*
String
Required

Responses

Status: 200 - successful operation


getControllerServices

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


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

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDControllerServiceList 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 {
            FDControllerServiceList 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: ^(FDControllerServiceList 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
                FDControllerServiceList result = apiInstance.getControllerServices(flowId, pgId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getControllerServices: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


getELSpecification

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


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

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

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

public class FlowDesignerApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

Path parameters
Name Description
flowId*
String
Required

Responses

Status: 200 - successful operation


getFlow

Gets the flow with the given id


/designer/flows/{flowId}

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

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

public class FlowDesignerApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

Path parameters
Name Description
flowId*
String
Required

Responses

Status: 200 - successful operation


getFlowEvents

Gets the flow events for the flow with the given id


/designer/flows/{flowId}/events

Usage and SDK Samples

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

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

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDFlowEventList 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 {
            FDFlowEventList 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: ^(FDFlowEventList 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
                FDFlowEventList result = apiInstance.getFlowEvents(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getFlowEvents: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

try: 
    # Gets the flow events for the flow with the given id
    api_response = api_instance.get_flow_events(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getFlowEvents: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required

Responses

Status: 200 - successful operation


getFlowMetadata

Gets the flow metadata for the flow with the given id


/designer/flows/{flowId}/metadata

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/metadata"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

import java.io.File;
import java.util.*;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDFlowMetadata result = apiInstance.getFlowMetadata(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowMetadata");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDFlowMetadata result = apiInstance.getFlowMetadata(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowMetadata");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Gets the flow metadata for the flow with the given id
[apiInstance getFlowMetadataWith:flowId
              completionHandler: ^(FDFlowMetadata output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getFlowMetadata(flowId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getFlowMetadataExample
    {
        public void main()
        {

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Gets the flow metadata for the flow with the given id
                FDFlowMetadata result = apiInstance.getFlowMetadata(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getFlowMetadata: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

try {
    $result = $api_instance->getFlowMetadata($flowId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->getFlowMetadata: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 

eval { 
    my $result = $api_instance->getFlowMetadata(flowId => $flowId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getFlowMetadata: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 

try: 
    # Gets the flow metadata for the flow with the given id
    api_response = api_instance.get_flow_metadata(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getFlowMetadata: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required

Responses

Status: 200 - successful operation


getFlowSummaries

Gets the summaries of the available flows known to the flow designer


/designer/flows/summaries

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/summaries"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

import java.io.File;
import java.util.*;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        try {
            FDFlowSummaryList 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 {
            FDFlowSummaryList 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: 
              ^(FDFlowSummaryList 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
                FDFlowSummaryList result = apiInstance.getFlowSummaries();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getFlowSummaries: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();

try {
    $result = $api_instance->getFlowSummaries();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->getFlowSummaries: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();

eval { 
    my $result = $api_instance->getFlowSummaries();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getFlowSummaries: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()

try: 
    # Gets the summaries of the available flows known to the flow designer
    api_response = api_instance.get_flow_summaries()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getFlowSummaries: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


getFlowVersionInfo

Gets the version info for the flow with the given id


/designer/flows/{flowId}/version-info

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/version-info"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

import java.io.File;
import java.util.*;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDVersionInfoResult result = apiInstance.getFlowVersionInfo(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowVersionInfo");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String flowId = flowId_example; // String | 
        try {
            FDVersionInfoResult result = apiInstance.getFlowVersionInfo(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#getFlowVersionInfo");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Gets the version info for the flow with the given id
[apiInstance getFlowVersionInfoWith:flowId
              completionHandler: ^(FDVersionInfoResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var flowId = flowId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getFlowVersionInfo(flowId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getFlowVersionInfoExample
    {
        public void main()
        {

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Gets the version info for the flow with the given id
                FDVersionInfoResult result = apiInstance.getFlowVersionInfo(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.getFlowVersionInfo: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

try {
    $result = $api_instance->getFlowVersionInfo($flowId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->getFlowVersionInfo: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $flowId = flowId_example; # String | 

eval { 
    my $result = $api_instance->getFlowVersionInfo(flowId => $flowId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->getFlowVersionInfo: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FlowDesignerApi()
flowId = flowId_example # String | 

try: 
    # Gets the version info for the flow with the given id
    api_response = api_instance.get_flow_version_info(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->getFlowVersionInfo: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required

Responses

Status: 200 - successful operation


getFlows

Gets the available flows known to the flow designer


/designer/flows

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerApi;

import java.io.File;
import java.util.*;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        try {
            ListFDFlowMetadata 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 {
            ListFDFlowMetadata 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: 
              ^(ListFDFlowMetadata 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
                ListFDFlowMetadata 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


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


getProcessGroup

Retrieves the process group with the given id. 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 {
            FDProcessGroup 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 {
            FDProcessGroup 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. 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: ^(FDProcessGroup 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. The alias of 'root' may be used to retrieve the root process group for the given flow.
                FDProcessGroup 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. 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


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


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


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


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


importFlowByAgentClass

Persists the given flow in the given agent class


/designer/{agentClassName}/flows/import

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/designer/{agentClassName}/flows/import"
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();
        ExportableFlow body = ; // ExportableFlow | The flow details.
        String agentClassName = agentClassName_example; // String | 
        try {
            FDFlowMetadata result = apiInstance.importFlowByAgentClass(body, agentClassName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#importFlowByAgentClass");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        ExportableFlow body = ; // ExportableFlow | The flow details.
        String agentClassName = agentClassName_example; // String | 
        try {
            FDFlowMetadata result = apiInstance.importFlowByAgentClass(body, agentClassName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#importFlowByAgentClass");
            e.printStackTrace();
        }
    }
}
ExportableFlow *body = ; // The flow details.
String *agentClassName = agentClassName_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Persists the given flow in the given agent class
[apiInstance importFlowByAgentClassWith:body
    agentClassName:agentClassName
              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 body = ; // {{ExportableFlow}} The flow details.
var agentClassName = agentClassName_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.importFlowByAgentClass(bodyagentClassName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class importFlowByAgentClassExample
    {
        public void main()
        {

            var apiInstance = new FlowDesignerApi();
            var body = new ExportableFlow(); // ExportableFlow | The flow details.
            var agentClassName = agentClassName_example;  // String | 

            try
            {
                // Persists the given flow in the given agent class
                FDFlowMetadata result = apiInstance.importFlowByAgentClass(body, agentClassName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.importFlowByAgentClass: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // ExportableFlow | The flow details.
$agentClassName = agentClassName_example; // String | 

try {
    $result = $api_instance->importFlowByAgentClass($body, $agentClassName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->importFlowByAgentClass: ', $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::ExportableFlow->new(); # ExportableFlow | The flow details.
my $agentClassName = agentClassName_example; # String | 

eval { 
    my $result = $api_instance->importFlowByAgentClass(body => $body, agentClassName => $agentClassName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->importFlowByAgentClass: $@\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 =  # ExportableFlow | The flow details.
agentClassName = agentClassName_example # String | 

try: 
    # Persists the given flow in the given agent class
    api_response = api_instance.import_flow_by_agent_class(body, agentClassName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->importFlowByAgentClass: %s\n" % e)

Parameters

Path parameters
Name Description
agentClassName*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


publishFlow

Publishes the current state of the flow


/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?forcePublish="
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
        Boolean forcePublish = true; // Boolean | Publish the flow even if it has validation errors
        try {
            FDVersionInfo result = apiInstance.publishFlow(flowId, body, forcePublish);
            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
        Boolean forcePublish = true; // Boolean | Publish the flow even if it has validation errors
        try {
            FDVersionInfo result = apiInstance.publishFlow(flowId, body, forcePublish);
            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)
Boolean *forcePublish = true; // Publish the flow even if it has validation errors (optional)

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Publishes the current state of the flow
[apiInstance publishFlowWith:flowId
    body:body
    forcePublish:forcePublish
              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
  'forcePublish': true // {{Boolean}} Publish the flow even if it has validation errors
};
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) 
            var forcePublish = true;  // Boolean | Publish the flow even if it has validation errors (optional) 

            try
            {
                // Publishes the current state of the flow
                FDVersionInfo result = apiInstance.publishFlow(flowId, body, forcePublish);
                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
$forcePublish = true; // Boolean | Publish the flow even if it has validation errors

try {
    $result = $api_instance->publishFlow($flowId, $body, $forcePublish);
    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
my $forcePublish = true; # Boolean | Publish the flow even if it has validation errors

eval { 
    my $result = $api_instance->publishFlow(flowId => $flowId, body => $body, forcePublish => $forcePublish);
    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)
forcePublish = true # Boolean | Publish the flow even if it has validation errors (optional)

try: 
    # Publishes the current state of the flow
    api_response = api_instance.publish_flow(flowId, body=body, forcePublish=forcePublish)
    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
Query parameters
Name Description
forcePublish
Boolean
Publish the flow even if it has validation errors

Responses

Status: 200 - successful operation


refreshFlowManifest

Refreshes the existing flow based on the latest manifest available under that Agent Class


/designer/flows/{agentClass}/manifest-refresh

Usage and SDK Samples

curl -X POST\
"/efm/api/designer/flows/{agentClass}/manifest-refresh"
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 agentClass = agentClass_example; // String | 
        try {
            apiInstance.refreshFlowManifest(agentClass);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#refreshFlowManifest");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        String agentClass = agentClass_example; // String | 
        try {
            apiInstance.refreshFlowManifest(agentClass);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#refreshFlowManifest");
            e.printStackTrace();
        }
    }
}
String *agentClass = agentClass_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Refreshes the existing flow based on the latest manifest available under that Agent Class
[apiInstance refreshFlowManifestWith:agentClass
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.FlowDesignerApi()
var agentClass = agentClass_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.refreshFlowManifest(agentClass, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class refreshFlowManifestExample
    {
        public void main()
        {

            var apiInstance = new FlowDesignerApi();
            var agentClass = agentClass_example;  // String | 

            try
            {
                // Refreshes the existing flow based on the latest manifest available under that Agent Class
                apiInstance.refreshFlowManifest(agentClass);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.refreshFlowManifest: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$agentClass = agentClass_example; // String | 

try {
    $api_instance->refreshFlowManifest($agentClass);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->refreshFlowManifest: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerApi->new();
my $agentClass = agentClass_example; # String | 

eval { 
    $api_instance->refreshFlowManifest(agentClass => $agentClass);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->refreshFlowManifest: $@\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()
agentClass = agentClass_example # String | 

try: 
    # Refreshes the existing flow based on the latest manifest available under that Agent Class
    api_instance.refresh_flow_manifest(agentClass)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->refreshFlowManifest: %s\n" % e)

Parameters

Path parameters
Name Description
agentClass*
String
Required

Responses

Status: default - successful operation


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


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


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


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


updateProcessGroup

Updates the configuration of a process group. 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 PUT\
-H "Accept: application/json"\
-H "Content-Type: */*"\
"/efm/api/designer/flows/{flowId}/process-groups/{pgId}"
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();
        FDProcessGroup body = ; // FDProcessGroup | 
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDProcessGroup result = apiInstance.updateProcessGroup(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateProcessGroup");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerApi;

public class FlowDesignerApiExample {

    public static void main(String[] args) {
        FlowDesignerApi apiInstance = new FlowDesignerApi();
        FDProcessGroup body = ; // FDProcessGroup | 
        String flowId = flowId_example; // String | 
        String pgId = pgId_example; // String | 
        try {
            FDProcessGroup result = apiInstance.updateProcessGroup(body, flowId, pgId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#updateProcessGroup");
            e.printStackTrace();
        }
    }
}
FDProcessGroup *body = ; // 
String *flowId = flowId_example; // 
String *pgId = pgId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Updates the configuration of a process group. The alias of 'root' may be used to retrieve the root process group for the given flow.
[apiInstance updateProcessGroupWith:body
    flowId:flowId
    pgId:pgId
              completionHandler: ^(FDProcessGroup 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 = ; // {{FDProcessGroup}} 
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.updateProcessGroup(bodyflowIdpgId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateProcessGroupExample
    {
        public void main()
        {

            var apiInstance = new FlowDesignerApi();
            var body = new FDProcessGroup(); // FDProcessGroup | 
            var flowId = flowId_example;  // String | 
            var pgId = pgId_example;  // String | 

            try
            {
                // Updates the configuration of a process group. The alias of 'root' may be used to retrieve the root process group for the given flow.
                FDProcessGroup result = apiInstance.updateProcessGroup(body, flowId, pgId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.updateProcessGroup: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$body = ; // FDProcessGroup | 
$flowId = flowId_example; // String | 
$pgId = pgId_example; // String | 

try {
    $result = $api_instance->updateProcessGroup($body, $flowId, $pgId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->updateProcessGroup: ', $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::FDProcessGroup->new(); # FDProcessGroup | 
my $flowId = flowId_example; # String | 
my $pgId = pgId_example; # String | 

eval { 
    my $result = $api_instance->updateProcessGroup(body => $body, flowId => $flowId, pgId => $pgId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->updateProcessGroup: $@\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 =  # FDProcessGroup | 
flowId = flowId_example # String | 
pgId = pgId_example # String | 

try: 
    # Updates the configuration of a process group. The alias of 'root' may be used to retrieve the root process group for the given flow.
    api_response = api_instance.update_process_group(body, flowId, pgId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->updateProcessGroup: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required
pgId*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


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


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


validateFlow

Validates the given flow


/designer/flows/{flowId}/validate

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/flows/{flowId}/validate"
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 {
            FDValidationErrorSummary result = apiInstance.validateFlow(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#validateFlow");
            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 {
            FDValidationErrorSummary result = apiInstance.validateFlow(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerApi#validateFlow");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // 

FlowDesignerApi *apiInstance = [[FlowDesignerApi alloc] init];

// Validates the given flow
[apiInstance validateFlowWith:flowId
              completionHandler: ^(FDValidationErrorSummary 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.validateFlow(flowId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class validateFlowExample
    {
        public void main()
        {

            var apiInstance = new FlowDesignerApi();
            var flowId = flowId_example;  // String | 

            try
            {
                // Validates the given flow
                FDValidationErrorSummary result = apiInstance.validateFlow(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerApi.validateFlow: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerApi();
$flowId = flowId_example; // String | 

try {
    $result = $api_instance->validateFlow($flowId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerApi->validateFlow: ', $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->validateFlow(flowId => $flowId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerApi->validateFlow: $@\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: 
    # Validates the given flow
    api_response = api_instance.validate_flow(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerApi->validateFlow: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
Required

Responses

Status: 200 - successful operation


FlowDesignerParameters

createParameterContext

Create a parameter context


/designer/parameter-contexts

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: */*"\
"/efm/api/designer/parameter-contexts"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerParametersApi;

import java.io.File;
import java.util.*;

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        FDParameterContext body = ; // FDParameterContext | The new parameter context
        try {
            FDParameterContext result = apiInstance.createParameterContext(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#createParameterContext");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerParametersApi;

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        FDParameterContext body = ; // FDParameterContext | The new parameter context
        try {
            FDParameterContext result = apiInstance.createParameterContext(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#createParameterContext");
            e.printStackTrace();
        }
    }
}
FDParameterContext *body = ; // The new parameter context

FlowDesignerParametersApi *apiInstance = [[FlowDesignerParametersApi alloc] init];

// Create a parameter context
[apiInstance createParameterContextWith:body
              completionHandler: ^(FDParameterContext 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.FlowDesignerParametersApi()
var body = ; // {{FDParameterContext}} The new parameter context

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createParameterContext(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createParameterContextExample
    {
        public void main()
        {

            var apiInstance = new FlowDesignerParametersApi();
            var body = new FDParameterContext(); // FDParameterContext | The new parameter context

            try
            {
                // Create a parameter context
                FDParameterContext result = apiInstance.createParameterContext(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerParametersApi.createParameterContext: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerParametersApi();
$body = ; // FDParameterContext | The new parameter context

try {
    $result = $api_instance->createParameterContext($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerParametersApi->createParameterContext: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerParametersApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerParametersApi->new();
my $body = WWW::SwaggerClient::Object::FDParameterContext->new(); # FDParameterContext | The new parameter context

eval { 
    my $result = $api_instance->createParameterContext(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerParametersApi->createParameterContext: $@\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.FlowDesignerParametersApi()
body =  # FDParameterContext | The new parameter context

try: 
    # Create a parameter context
    api_response = api_instance.create_parameter_context(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerParametersApi->createParameterContext: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


deleteParameterContext

Delete a parameter context


/designer/parameter-contexts/{id}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/designer/parameter-contexts/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerParametersApi;

import java.io.File;
import java.util.*;

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        String id = id_example; // String | The id of the parameter context
        try {
            FDParameterContext result = apiInstance.deleteParameterContext(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#deleteParameterContext");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerParametersApi;

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        String id = id_example; // String | The id of the parameter context
        try {
            FDParameterContext result = apiInstance.deleteParameterContext(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#deleteParameterContext");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The id of the parameter context

FlowDesignerParametersApi *apiInstance = [[FlowDesignerParametersApi alloc] init];

// Delete a parameter context
[apiInstance deleteParameterContextWith:id
              completionHandler: ^(FDParameterContext 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.FlowDesignerParametersApi()
var id = id_example; // {{String}} The id of the parameter context

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteParameterContext(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteParameterContextExample
    {
        public void main()
        {

            var apiInstance = new FlowDesignerParametersApi();
            var id = id_example;  // String | The id of the parameter context

            try
            {
                // Delete a parameter context
                FDParameterContext result = apiInstance.deleteParameterContext(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerParametersApi.deleteParameterContext: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerParametersApi();
$id = id_example; // String | The id of the parameter context

try {
    $result = $api_instance->deleteParameterContext($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerParametersApi->deleteParameterContext: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerParametersApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerParametersApi->new();
my $id = id_example; # String | The id of the parameter context

eval { 
    my $result = $api_instance->deleteParameterContext(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerParametersApi->deleteParameterContext: $@\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.FlowDesignerParametersApi()
id = id_example # String | The id of the parameter context

try: 
    # Delete a parameter context
    api_response = api_instance.delete_parameter_context(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerParametersApi->deleteParameterContext: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The id of the parameter context
Required

Responses

Status: 200 - successful operation


getParameterContext

Gets a parameter context


/designer/parameter-contexts/{id}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/parameter-contexts/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerParametersApi;

import java.io.File;
import java.util.*;

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        String id = id_example; // String | The id of the parameter context
        try {
            FDParameterContext result = apiInstance.getParameterContext(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#getParameterContext");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerParametersApi;

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        String id = id_example; // String | The id of the parameter context
        try {
            FDParameterContext result = apiInstance.getParameterContext(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#getParameterContext");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The id of the parameter context

FlowDesignerParametersApi *apiInstance = [[FlowDesignerParametersApi alloc] init];

// Gets a parameter context
[apiInstance getParameterContextWith:id
              completionHandler: ^(FDParameterContext 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.FlowDesignerParametersApi()
var id = id_example; // {{String}} The id of the parameter context

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getParameterContext(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getParameterContextExample
    {
        public void main()
        {

            var apiInstance = new FlowDesignerParametersApi();
            var id = id_example;  // String | The id of the parameter context

            try
            {
                // Gets a parameter context
                FDParameterContext result = apiInstance.getParameterContext(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerParametersApi.getParameterContext: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerParametersApi();
$id = id_example; // String | The id of the parameter context

try {
    $result = $api_instance->getParameterContext($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerParametersApi->getParameterContext: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerParametersApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerParametersApi->new();
my $id = id_example; # String | The id of the parameter context

eval { 
    my $result = $api_instance->getParameterContext(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerParametersApi->getParameterContext: $@\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.FlowDesignerParametersApi()
id = id_example # String | The id of the parameter context

try: 
    # Gets a parameter context
    api_response = api_instance.get_parameter_context(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerParametersApi->getParameterContext: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The id of the parameter context
Required

Responses

Status: 200 - successful operation


getParameterContexts

Gets all available parameter contexts


/designer/parameter-contexts

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/designer/parameter-contexts?pageNum=&rows="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerParametersApi;

import java.io.File;
import java.util.*;

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        Integer pageNum = 56; // Integer | 
        Integer rows = 56; // Integer | 
        try {
            FDParameterContextList result = apiInstance.getParameterContexts(pageNum, rows);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#getParameterContexts");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerParametersApi;

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        Integer pageNum = 56; // Integer | 
        Integer rows = 56; // Integer | 
        try {
            FDParameterContextList result = apiInstance.getParameterContexts(pageNum, rows);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#getParameterContexts");
            e.printStackTrace();
        }
    }
}
Integer *pageNum = 56; //  (optional)
Integer *rows = 56; //  (optional)

FlowDesignerParametersApi *apiInstance = [[FlowDesignerParametersApi alloc] init];

// Gets all available parameter contexts
[apiInstance getParameterContextsWith:pageNum
    rows:rows
              completionHandler: ^(FDParameterContextList 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.FlowDesignerParametersApi()
var opts = { 
  'pageNum': 56, // {{Integer}} 
  'rows': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getParameterContexts(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getParameterContextsExample
    {
        public void main()
        {

            var apiInstance = new FlowDesignerParametersApi();
            var pageNum = 56;  // Integer |  (optional) 
            var rows = 56;  // Integer |  (optional) 

            try
            {
                // Gets all available parameter contexts
                FDParameterContextList result = apiInstance.getParameterContexts(pageNum, rows);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerParametersApi.getParameterContexts: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerParametersApi();
$pageNum = 56; // Integer | 
$rows = 56; // Integer | 

try {
    $result = $api_instance->getParameterContexts($pageNum, $rows);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerParametersApi->getParameterContexts: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerParametersApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerParametersApi->new();
my $pageNum = 56; # Integer | 
my $rows = 56; # Integer | 

eval { 
    my $result = $api_instance->getParameterContexts(pageNum => $pageNum, rows => $rows);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerParametersApi->getParameterContexts: $@\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.FlowDesignerParametersApi()
pageNum = 56 # Integer |  (optional)
rows = 56 # Integer |  (optional)

try: 
    # Gets all available parameter contexts
    api_response = api_instance.get_parameter_contexts(pageNum=pageNum, rows=rows)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerParametersApi->getParameterContexts: %s\n" % e)

Parameters

Query parameters
Name Description
pageNum
Integer (int32)
rows
Integer (int32)

Responses

Status: 200 - successful operation


updateParameterContext

Update a parameter context


/designer/parameter-contexts/{id}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/designer/parameter-contexts/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FlowDesignerParametersApi;

import java.io.File;
import java.util.*;

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        String id = id_example; // String | The id of the parameter context
        FDParameterContext body = ; // FDParameterContext | The updated parameter context
        try {
            FDParameterContext result = apiInstance.updateParameterContext(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#updateParameterContext");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FlowDesignerParametersApi;

public class FlowDesignerParametersApiExample {

    public static void main(String[] args) {
        FlowDesignerParametersApi apiInstance = new FlowDesignerParametersApi();
        String id = id_example; // String | The id of the parameter context
        FDParameterContext body = ; // FDParameterContext | The updated parameter context
        try {
            FDParameterContext result = apiInstance.updateParameterContext(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowDesignerParametersApi#updateParameterContext");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The id of the parameter context
FDParameterContext *body = ; // The updated parameter context (optional)

FlowDesignerParametersApi *apiInstance = [[FlowDesignerParametersApi alloc] init];

// Update a parameter context
[apiInstance updateParameterContextWith:id
    body:body
              completionHandler: ^(FDParameterContext 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.FlowDesignerParametersApi()
var id = id_example; // {{String}} The id of the parameter context
var opts = { 
  'body':  // {{FDParameterContext}} The updated parameter context
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateParameterContext(id, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateParameterContextExample
    {
        public void main()
        {

            var apiInstance = new FlowDesignerParametersApi();
            var id = id_example;  // String | The id of the parameter context
            var body = new FDParameterContext(); // FDParameterContext | The updated parameter context (optional) 

            try
            {
                // Update a parameter context
                FDParameterContext result = apiInstance.updateParameterContext(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowDesignerParametersApi.updateParameterContext: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowDesignerParametersApi();
$id = id_example; // String | The id of the parameter context
$body = ; // FDParameterContext | The updated parameter context

try {
    $result = $api_instance->updateParameterContext($id, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowDesignerParametersApi->updateParameterContext: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FlowDesignerParametersApi;

my $api_instance = WWW::SwaggerClient::FlowDesignerParametersApi->new();
my $id = id_example; # String | The id of the parameter context
my $body = WWW::SwaggerClient::Object::FDParameterContext->new(); # FDParameterContext | The updated parameter context

eval { 
    my $result = $api_instance->updateParameterContext(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowDesignerParametersApi->updateParameterContext: $@\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.FlowDesignerParametersApi()
id = id_example # String | The id of the parameter context
body =  # FDParameterContext | The updated parameter context (optional)

try: 
    # Update a parameter context
    api_response = api_instance.update_parameter_context(id, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowDesignerParametersApi->updateParameterContext: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The id of the parameter context
Required
Body parameters
Name Description
body

Responses

Status: 200 - successful operation


Flows

createFlowParameters

Register a set of Parameters to use with this flow.


/flows/{id}/parameters

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/flows/{id}/parameters"
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 identifier of the flow to provide parameters for
        array[Parameter] body = ; // array[Parameter] | The metadata of the flow to register
        try {
            ParameterContext result = apiInstance.createFlowParameters(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#createFlowParameters");
            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 identifier of the flow to provide parameters for
        array[Parameter] body = ; // array[Parameter] | The metadata of the flow to register
        try {
            ParameterContext result = apiInstance.createFlowParameters(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#createFlowParameters");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The identifier of the flow to provide parameters for
array[Parameter] *body = ; // The metadata of the flow to register (optional)

FlowsApi *apiInstance = [[FlowsApi alloc] init];

// Register a set of Parameters to use with this flow.
[apiInstance createFlowParametersWith:id
    body:body
              completionHandler: ^(ParameterContext 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 identifier of the flow to provide parameters for
var opts = { 
  'body':  // {{array[Parameter]}} The metadata of the flow to register
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createFlowParameters(id, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createFlowParametersExample
    {
        public void main()
        {

            var apiInstance = new FlowsApi();
            var id = id_example;  // String | The identifier of the flow to provide parameters for
            var body = new array[Parameter](); // array[Parameter] | The metadata of the flow to register (optional) 

            try
            {
                // Register a set of Parameters to use with this flow.
                ParameterContext result = apiInstance.createFlowParameters(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowsApi.createFlowParameters: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowsApi();
$id = id_example; // String | The identifier of the flow to provide parameters for
$body = ; // array[Parameter] | The metadata of the flow to register

try {
    $result = $api_instance->createFlowParameters($id, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowsApi->createFlowParameters: ', $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 identifier of the flow to provide parameters for
my $body = [WWW::SwaggerClient::Object::array[Parameter]->new()]; # array[Parameter] | The metadata of the flow to register

eval { 
    my $result = $api_instance->createFlowParameters(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowsApi->createFlowParameters: $@\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 identifier of the flow to provide parameters for
body =  # array[Parameter] | The metadata of the flow to register (optional)

try: 
    # Register a set of Parameters to use with this flow.
    api_response = api_instance.create_flow_parameters(id, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowsApi->createFlowParameters: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The identifier of the flow to provide parameters for
Required
Body parameters
Name Description
body

Responses

Status: 200 - successful operation


deleteFlowParameters

Delete an instance specific parameter context


/flows/{id}/parameters

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/flows/{id}/parameters"
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 identifier of the flow to delete its parameter context
        try {
            ParameterContext result = apiInstance.deleteFlowParameters(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#deleteFlowParameters");
            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 identifier of the flow to delete its parameter context
        try {
            ParameterContext result = apiInstance.deleteFlowParameters(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#deleteFlowParameters");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The identifier of the flow to delete its parameter context

FlowsApi *apiInstance = [[FlowsApi alloc] init];

// Delete an instance specific parameter context
[apiInstance deleteFlowParametersWith:id
              completionHandler: ^(ParameterContext 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 identifier of the flow to delete its parameter context

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteFlowParameters(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteFlowParametersExample
    {
        public void main()
        {

            var apiInstance = new FlowsApi();
            var id = id_example;  // String | The identifier of the flow to delete its parameter context

            try
            {
                // Delete an instance specific parameter context
                ParameterContext result = apiInstance.deleteFlowParameters(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowsApi.deleteFlowParameters: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowsApi();
$id = id_example; // String | The identifier of the flow to delete its parameter context

try {
    $result = $api_instance->deleteFlowParameters($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowsApi->deleteFlowParameters: ', $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 identifier of the flow to delete its parameter context

eval { 
    my $result = $api_instance->deleteFlowParameters(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowsApi->deleteFlowParameters: $@\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 identifier of the flow to delete its parameter context

try: 
    # Delete an instance specific parameter context
    api_response = api_instance.delete_flow_parameters(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowsApi->deleteFlowParameters: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The identifier of the flow to delete its parameter context
Required

Responses

Status: 200 - successful operation


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


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


getFlowParameters

Retrieve the parameter context for a flow with the specified id


/flows/{id}/parameters

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/flows/{id}/parameters"
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 identifier of the flow to retrieve parameters for
        try {
            ParameterContext result = apiInstance.getFlowParameters(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#getFlowParameters");
            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 identifier of the flow to retrieve parameters for
        try {
            ParameterContext result = apiInstance.getFlowParameters(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#getFlowParameters");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The identifier of the flow to retrieve parameters for

FlowsApi *apiInstance = [[FlowsApi alloc] init];

// Retrieve the parameter context for a flow with the specified id
[apiInstance getFlowParametersWith:id
              completionHandler: ^(ParameterContext 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 identifier of the flow to retrieve parameters for

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getFlowParameters(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getFlowParametersExample
    {
        public void main()
        {

            var apiInstance = new FlowsApi();
            var id = id_example;  // String | The identifier of the flow to retrieve parameters for

            try
            {
                // Retrieve the parameter context for a flow with the specified id
                ParameterContext result = apiInstance.getFlowParameters(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowsApi.getFlowParameters: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowsApi();
$id = id_example; // String | The identifier of the flow to retrieve parameters for

try {
    $result = $api_instance->getFlowParameters($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowsApi->getFlowParameters: ', $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 identifier of the flow to retrieve parameters for

eval { 
    my $result = $api_instance->getFlowParameters(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowsApi->getFlowParameters: $@\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 identifier of the flow to retrieve parameters for

try: 
    # Retrieve the parameter context for a flow with the specified id
    api_response = api_instance.get_flow_parameters(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowsApi->getFlowParameters: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The identifier of the flow to retrieve parameters for
Required

Responses

Status: 200 - successful operation


updateFlowParameters

Update a set of Parameters to use with this flow.


/flows/{id}/parameters

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/flows/{id}/parameters"
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 identifier of the flow to update parameters of
        array[Parameter] body = ; // array[Parameter] | The metadata of the flow to update
        try {
            ParameterContext result = apiInstance.updateFlowParameters(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#updateFlowParameters");
            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 identifier of the flow to update parameters of
        array[Parameter] body = ; // array[Parameter] | The metadata of the flow to update
        try {
            ParameterContext result = apiInstance.updateFlowParameters(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FlowsApi#updateFlowParameters");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The identifier of the flow to update parameters of
array[Parameter] *body = ; // The metadata of the flow to update (optional)

FlowsApi *apiInstance = [[FlowsApi alloc] init];

// Update a set of Parameters to use with this flow.
[apiInstance updateFlowParametersWith:id
    body:body
              completionHandler: ^(ParameterContext 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 identifier of the flow to update parameters of
var opts = { 
  'body':  // {{array[Parameter]}} The metadata of the flow to update
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateFlowParameters(id, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateFlowParametersExample
    {
        public void main()
        {

            var apiInstance = new FlowsApi();
            var id = id_example;  // String | The identifier of the flow to update parameters of
            var body = new array[Parameter](); // array[Parameter] | The metadata of the flow to update (optional) 

            try
            {
                // Update a set of Parameters to use with this flow.
                ParameterContext result = apiInstance.updateFlowParameters(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FlowsApi.updateFlowParameters: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFlowsApi();
$id = id_example; // String | The identifier of the flow to update parameters of
$body = ; // array[Parameter] | The metadata of the flow to update

try {
    $result = $api_instance->updateFlowParameters($id, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FlowsApi->updateFlowParameters: ', $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 identifier of the flow to update parameters of
my $body = [WWW::SwaggerClient::Object::array[Parameter]->new()]; # array[Parameter] | The metadata of the flow to update

eval { 
    my $result = $api_instance->updateFlowParameters(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FlowsApi->updateFlowParameters: $@\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 identifier of the flow to update parameters of
body =  # array[Parameter] | The metadata of the flow to update (optional)

try: 
    # Update a set of Parameters to use with this flow.
    api_response = api_instance.update_flow_parameters(id, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FlowsApi->updateFlowParameters: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The identifier of the flow to update parameters of
Required
Body parameters
Name Description
body

Responses

Status: 200 - successful operation


Groups

createGroup

Create a group


/groups

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: */*"\
"/efm/api/groups"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GroupsApi;

import java.io.File;
import java.util.*;

public class GroupsApiExample {

    public static void main(String[] args) {
        
        GroupsApi apiInstance = new GroupsApi();
        Group body = ; // Group | The new group
        try {
            Group result = apiInstance.createGroup(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#createGroup");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.GroupsApi;

public class GroupsApiExample {

    public static void main(String[] args) {
        GroupsApi apiInstance = new GroupsApi();
        Group body = ; // Group | The new group
        try {
            Group result = apiInstance.createGroup(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#createGroup");
            e.printStackTrace();
        }
    }
}
Group *body = ; // The new group

GroupsApi *apiInstance = [[GroupsApi alloc] init];

// Create a group
[apiInstance createGroupWith:body
              completionHandler: ^(Group 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.GroupsApi()
var body = ; // {{Group}} The new group

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createGroup(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createGroupExample
    {
        public void main()
        {

            var apiInstance = new GroupsApi();
            var body = new Group(); // Group | The new group

            try
            {
                // Create a group
                Group result = apiInstance.createGroup(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GroupsApi.createGroup: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiGroupsApi();
$body = ; // Group | The new group

try {
    $result = $api_instance->createGroup($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GroupsApi->createGroup: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GroupsApi;

my $api_instance = WWW::SwaggerClient::GroupsApi->new();
my $body = WWW::SwaggerClient::Object::Group->new(); # Group | The new group

eval { 
    my $result = $api_instance->createGroup(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GroupsApi->createGroup: $@\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.GroupsApi()
body =  # Group | The new group

try: 
    # Create a group
    api_response = api_instance.create_group(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GroupsApi->createGroup: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


deleteGroup

Deletes a group


/groups/{id}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/groups/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GroupsApi;

import java.io.File;
import java.util.*;

public class GroupsApiExample {

    public static void main(String[] args) {
        
        GroupsApi apiInstance = new GroupsApi();
        String id = id_example; // String | The id of the group
        try {
            Group result = apiInstance.deleteGroup(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#deleteGroup");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.GroupsApi;

public class GroupsApiExample {

    public static void main(String[] args) {
        GroupsApi apiInstance = new GroupsApi();
        String id = id_example; // String | The id of the group
        try {
            Group result = apiInstance.deleteGroup(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#deleteGroup");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The id of the group

GroupsApi *apiInstance = [[GroupsApi alloc] init];

// Deletes a group
[apiInstance deleteGroupWith:id
              completionHandler: ^(Group 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.GroupsApi()
var id = id_example; // {{String}} The id of the group

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteGroup(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteGroupExample
    {
        public void main()
        {

            var apiInstance = new GroupsApi();
            var id = id_example;  // String | The id of the group

            try
            {
                // Deletes a group
                Group result = apiInstance.deleteGroup(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GroupsApi.deleteGroup: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiGroupsApi();
$id = id_example; // String | The id of the group

try {
    $result = $api_instance->deleteGroup($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GroupsApi->deleteGroup: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GroupsApi;

my $api_instance = WWW::SwaggerClient::GroupsApi->new();
my $id = id_example; # String | The id of the group

eval { 
    my $result = $api_instance->deleteGroup(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GroupsApi->deleteGroup: $@\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.GroupsApi()
id = id_example # String | The id of the group

try: 
    # Deletes a group
    api_response = api_instance.delete_group(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GroupsApi->deleteGroup: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The id of the group
Required

Responses

Status: 200 - successful operation


getGroup

Gets a group by id


/groups/{id}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/groups/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GroupsApi;

import java.io.File;
import java.util.*;

public class GroupsApiExample {

    public static void main(String[] args) {
        
        GroupsApi apiInstance = new GroupsApi();
        String id = id_example; // String | The id of the group
        try {
            Group result = apiInstance.getGroup(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#getGroup");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.GroupsApi;

public class GroupsApiExample {

    public static void main(String[] args) {
        GroupsApi apiInstance = new GroupsApi();
        String id = id_example; // String | The id of the group
        try {
            Group result = apiInstance.getGroup(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#getGroup");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The id of the group

GroupsApi *apiInstance = [[GroupsApi alloc] init];

// Gets a group by id
[apiInstance getGroupWith:id
              completionHandler: ^(Group 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.GroupsApi()
var id = id_example; // {{String}} The id of the group

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getGroup(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getGroupExample
    {
        public void main()
        {

            var apiInstance = new GroupsApi();
            var id = id_example;  // String | The id of the group

            try
            {
                // Gets a group by id
                Group result = apiInstance.getGroup(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GroupsApi.getGroup: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiGroupsApi();
$id = id_example; // String | The id of the group

try {
    $result = $api_instance->getGroup($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GroupsApi->getGroup: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GroupsApi;

my $api_instance = WWW::SwaggerClient::GroupsApi->new();
my $id = id_example; # String | The id of the group

eval { 
    my $result = $api_instance->getGroup(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GroupsApi->getGroup: $@\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.GroupsApi()
id = id_example # String | The id of the group

try: 
    # Gets a group by id
    api_response = api_instance.get_group(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GroupsApi->getGroup: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The id of the group
Required

Responses

Status: 200 - successful operation


getGroups

Gets all groups


/groups

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/groups"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GroupsApi;

import java.io.File;
import java.util.*;

public class GroupsApiExample {

    public static void main(String[] args) {
        
        GroupsApi apiInstance = new GroupsApi();
        try {
            array[GroupSummary] result = apiInstance.getGroups();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#getGroups");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.GroupsApi;

public class GroupsApiExample {

    public static void main(String[] args) {
        GroupsApi apiInstance = new GroupsApi();
        try {
            array[GroupSummary] result = apiInstance.getGroups();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#getGroups");
            e.printStackTrace();
        }
    }
}

GroupsApi *apiInstance = [[GroupsApi alloc] init];

// Gets all groups
[apiInstance getGroupsWithCompletionHandler: 
              ^(array[GroupSummary] 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.GroupsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getGroups(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getGroupsExample
    {
        public void main()
        {

            var apiInstance = new GroupsApi();

            try
            {
                // Gets all groups
                array[GroupSummary] result = apiInstance.getGroups();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GroupsApi.getGroups: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiGroupsApi();

try {
    $result = $api_instance->getGroups();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GroupsApi->getGroups: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GroupsApi;

my $api_instance = WWW::SwaggerClient::GroupsApi->new();

eval { 
    my $result = $api_instance->getGroups();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GroupsApi->getGroups: $@\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.GroupsApi()

try: 
    # Gets all groups
    api_response = api_instance.get_groups()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GroupsApi->getGroups: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


updateGroup

Accepts a form of all changes that can be made on the Edit Group side panel in the UI, so that they can be processed as a single transaction


/groups/{id}

Usage and SDK Samples

curl -X PATCH\
-H "Accept: application/json"\
-H "Content-Type: */*"\
"/efm/api/groups/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GroupsApi;

import java.io.File;
import java.util.*;

public class GroupsApiExample {

    public static void main(String[] args) {
        
        GroupsApi apiInstance = new GroupsApi();
        GroupModificationRequest body = ; // GroupModificationRequest | 
        String id = id_example; // String | The id of the group to modify
        try {
            Group result = apiInstance.updateGroup(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#updateGroup");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.GroupsApi;

public class GroupsApiExample {

    public static void main(String[] args) {
        GroupsApi apiInstance = new GroupsApi();
        GroupModificationRequest body = ; // GroupModificationRequest | 
        String id = id_example; // String | The id of the group to modify
        try {
            Group result = apiInstance.updateGroup(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#updateGroup");
            e.printStackTrace();
        }
    }
}
GroupModificationRequest *body = ; // 
String *id = id_example; // The id of the group to modify

GroupsApi *apiInstance = [[GroupsApi alloc] init];

// Accepts a form of all changes that can be made on the Edit Group side panel in the UI, so that they can be processed as a single transaction
[apiInstance updateGroupWith:body
    id:id
              completionHandler: ^(Group 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.GroupsApi()
var body = ; // {{GroupModificationRequest}} 
var id = id_example; // {{String}} The id of the group to modify

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateGroup(bodyid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateGroupExample
    {
        public void main()
        {

            var apiInstance = new GroupsApi();
            var body = new GroupModificationRequest(); // GroupModificationRequest | 
            var id = id_example;  // String | The id of the group to modify

            try
            {
                // Accepts a form of all changes that can be made on the Edit Group side panel in the UI, so that they can be processed as a single transaction
                Group result = apiInstance.updateGroup(body, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GroupsApi.updateGroup: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiGroupsApi();
$body = ; // GroupModificationRequest | 
$id = id_example; // String | The id of the group to modify

try {
    $result = $api_instance->updateGroup($body, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GroupsApi->updateGroup: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GroupsApi;

my $api_instance = WWW::SwaggerClient::GroupsApi->new();
my $body = WWW::SwaggerClient::Object::GroupModificationRequest->new(); # GroupModificationRequest | 
my $id = id_example; # String | The id of the group to modify

eval { 
    my $result = $api_instance->updateGroup(body => $body, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GroupsApi->updateGroup: $@\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.GroupsApi()
body =  # GroupModificationRequest | 
id = id_example # String | The id of the group to modify

try: 
    # Accepts a form of all changes that can be made on the Edit Group side panel in the UI, so that they can be processed as a single transaction
    api_response = api_instance.update_group(body, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GroupsApi->updateGroup: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The id of the group to modify
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


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

Status: 404 - The specified resource could not be found.


Monitoring

getAgentClassDetail

Get agent class monitoring data


/monitor/agent-classes/{agentClass}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/monitor/agent-classes/{agentClass}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {

    public static void main(String[] args) {
        
        MonitoringApi apiInstance = new MonitoringApi();
        String agentClass = agentClass_example; // String | 
        try {
            AgentClassDetail result = apiInstance.getAgentClassDetail(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#getAgentClassDetail");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.MonitoringApi;

public class MonitoringApiExample {

    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        String agentClass = agentClass_example; // String | 
        try {
            AgentClassDetail result = apiInstance.getAgentClassDetail(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#getAgentClassDetail");
            e.printStackTrace();
        }
    }
}
String *agentClass = agentClass_example; // 

MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Get agent class monitoring data
[apiInstance getAgentClassDetailWith:agentClass
              completionHandler: ^(AgentClassDetail 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.MonitoringApi()
var agentClass = agentClass_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAgentClassDetail(agentClass, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAgentClassDetailExample
    {
        public void main()
        {

            var apiInstance = new MonitoringApi();
            var agentClass = agentClass_example;  // String | 

            try
            {
                // Get agent class monitoring data
                AgentClassDetail result = apiInstance.getAgentClassDetail(agentClass);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MonitoringApi.getAgentClassDetail: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiMonitoringApi();
$agentClass = agentClass_example; // String | 

try {
    $result = $api_instance->getAgentClassDetail($agentClass);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->getAgentClassDetail: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::MonitoringApi;

my $api_instance = WWW::SwaggerClient::MonitoringApi->new();
my $agentClass = agentClass_example; # String | 

eval { 
    my $result = $api_instance->getAgentClassDetail(agentClass => $agentClass);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->getAgentClassDetail: $@\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.MonitoringApi()
agentClass = agentClass_example # String | 

try: 
    # Get agent class monitoring data
    api_response = api_instance.get_agent_class_detail(agentClass)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->getAgentClassDetail: %s\n" % e)

Parameters

Path parameters
Name Description
agentClass*
String
Required

Responses

Status: 200 - successful operation


getAgentClassSummaries

Get summaries of all agent classes


/monitor/summaries

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/monitor/summaries?pageNum=&rows=&agentClass=&sort="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {

    public static void main(String[] args) {
        
        MonitoringApi apiInstance = new MonitoringApi();
        Integer pageNum = 56; // Integer | 
        Integer rows = 56; // Integer | 
        String agentClass = agentClass_example; // String | 
        String sort = sort_example; // String | Sorting by in the following format: field:DESC
        try {
            AgentClassSummaryList result = apiInstance.getAgentClassSummaries(pageNum, rows, agentClass, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#getAgentClassSummaries");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.MonitoringApi;

public class MonitoringApiExample {

    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        Integer pageNum = 56; // Integer | 
        Integer rows = 56; // Integer | 
        String agentClass = agentClass_example; // String | 
        String sort = sort_example; // String | Sorting by in the following format: field:DESC
        try {
            AgentClassSummaryList result = apiInstance.getAgentClassSummaries(pageNum, rows, agentClass, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#getAgentClassSummaries");
            e.printStackTrace();
        }
    }
}
Integer *pageNum = 56; //  (optional)
Integer *rows = 56; //  (optional)
String *agentClass = agentClass_example; //  (optional)
String *sort = sort_example; // Sorting by in the following format: field:DESC (optional)

MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Get summaries of all agent classes
[apiInstance getAgentClassSummariesWith:pageNum
    rows:rows
    agentClass:agentClass
    sort:sort
              completionHandler: ^(AgentClassSummaryList 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.MonitoringApi()
var opts = { 
  'pageNum': 56, // {{Integer}} 
  'rows': 56, // {{Integer}} 
  'agentClass': agentClass_example, // {{String}} 
  'sort': sort_example // {{String}} Sorting by in the following format: field:DESC
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAgentClassSummaries(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAgentClassSummariesExample
    {
        public void main()
        {

            var apiInstance = new MonitoringApi();
            var pageNum = 56;  // Integer |  (optional) 
            var rows = 56;  // Integer |  (optional) 
            var agentClass = agentClass_example;  // String |  (optional) 
            var sort = sort_example;  // String | Sorting by in the following format: field:DESC (optional) 

            try
            {
                // Get summaries of all agent classes
                AgentClassSummaryList result = apiInstance.getAgentClassSummaries(pageNum, rows, agentClass, sort);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MonitoringApi.getAgentClassSummaries: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiMonitoringApi();
$pageNum = 56; // Integer | 
$rows = 56; // Integer | 
$agentClass = agentClass_example; // String | 
$sort = sort_example; // String | Sorting by in the following format: field:DESC

try {
    $result = $api_instance->getAgentClassSummaries($pageNum, $rows, $agentClass, $sort);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->getAgentClassSummaries: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::MonitoringApi;

my $api_instance = WWW::SwaggerClient::MonitoringApi->new();
my $pageNum = 56; # Integer | 
my $rows = 56; # Integer | 
my $agentClass = agentClass_example; # String | 
my $sort = sort_example; # String | Sorting by in the following format: field:DESC

eval { 
    my $result = $api_instance->getAgentClassSummaries(pageNum => $pageNum, rows => $rows, agentClass => $agentClass, sort => $sort);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->getAgentClassSummaries: $@\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.MonitoringApi()
pageNum = 56 # Integer |  (optional)
rows = 56 # Integer |  (optional)
agentClass = agentClass_example # String |  (optional)
sort = sort_example # String | Sorting by in the following format: field:DESC (optional)

try: 
    # Get summaries of all agent classes
    api_response = api_instance.get_agent_class_summaries(pageNum=pageNum, rows=rows, agentClass=agentClass, sort=sort)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->getAgentClassSummaries: %s\n" % e)

Parameters

Query parameters
Name Description
pageNum
Integer (int32)
rows
Integer (int32)
agentClass
String
sort
String
Sorting by in the following format: field:DESC

Responses

Status: 200 - successful operation


getAgentClassSummary

Get summaries of all agent classes


/monitor/summaries/{agentClass}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/monitor/summaries/{agentClass}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {

    public static void main(String[] args) {
        
        MonitoringApi apiInstance = new MonitoringApi();
        String agentClass = agentClass_example; // String | 
        try {
            AgentClassSummary result = apiInstance.getAgentClassSummary(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#getAgentClassSummary");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.MonitoringApi;

public class MonitoringApiExample {

    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        String agentClass = agentClass_example; // String | 
        try {
            AgentClassSummary result = apiInstance.getAgentClassSummary(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#getAgentClassSummary");
            e.printStackTrace();
        }
    }
}
String *agentClass = agentClass_example; // 

MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Get summaries of all agent classes
[apiInstance getAgentClassSummaryWith:agentClass
              completionHandler: ^(AgentClassSummary 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.MonitoringApi()
var agentClass = agentClass_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAgentClassSummary(agentClass, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAgentClassSummaryExample
    {
        public void main()
        {

            var apiInstance = new MonitoringApi();
            var agentClass = agentClass_example;  // String | 

            try
            {
                // Get summaries of all agent classes
                AgentClassSummary result = apiInstance.getAgentClassSummary(agentClass);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MonitoringApi.getAgentClassSummary: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiMonitoringApi();
$agentClass = agentClass_example; // String | 

try {
    $result = $api_instance->getAgentClassSummary($agentClass);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->getAgentClassSummary: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::MonitoringApi;

my $api_instance = WWW::SwaggerClient::MonitoringApi->new();
my $agentClass = agentClass_example; # String | 

eval { 
    my $result = $api_instance->getAgentClassSummary(agentClass => $agentClass);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->getAgentClassSummary: $@\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.MonitoringApi()
agentClass = agentClass_example # String | 

try: 
    # Get summaries of all agent classes
    api_response = api_instance.get_agent_class_summary(agentClass)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->getAgentClassSummary: %s\n" % e)

Parameters

Path parameters
Name Description
agentClass*
String
Required

Responses

Status: 200 - successful operation


getAgentDetail

Get agent monitoring data


/monitor/agents/{agentId}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/monitor/agents/{agentId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {

    public static void main(String[] args) {
        
        MonitoringApi apiInstance = new MonitoringApi();
        String agentId = agentId_example; // String | 
        try {
            AgentDetail result = apiInstance.getAgentDetail(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#getAgentDetail");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.MonitoringApi;

public class MonitoringApiExample {

    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        String agentId = agentId_example; // String | 
        try {
            AgentDetail result = apiInstance.getAgentDetail(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#getAgentDetail");
            e.printStackTrace();
        }
    }
}
String *agentId = agentId_example; // 

MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Get agent monitoring data
[apiInstance getAgentDetailWith:agentId
              completionHandler: ^(AgentDetail 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.MonitoringApi()
var agentId = agentId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAgentDetail(agentId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAgentDetailExample
    {
        public void main()
        {

            var apiInstance = new MonitoringApi();
            var agentId = agentId_example;  // String | 

            try
            {
                // Get agent monitoring data
                AgentDetail result = apiInstance.getAgentDetail(agentId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MonitoringApi.getAgentDetail: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiMonitoringApi();
$agentId = agentId_example; // String | 

try {
    $result = $api_instance->getAgentDetail($agentId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->getAgentDetail: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::MonitoringApi;

my $api_instance = WWW::SwaggerClient::MonitoringApi->new();
my $agentId = agentId_example; # String | 

eval { 
    my $result = $api_instance->getAgentDetail(agentId => $agentId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->getAgentDetail: $@\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.MonitoringApi()
agentId = agentId_example # String | 

try: 
    # Get agent monitoring data
    api_response = api_instance.get_agent_detail(agentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->getAgentDetail: %s\n" % e)

Parameters

Path parameters
Name Description
agentId*
String
Required

Responses

Status: 200 - successful operation


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

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

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


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();
        String body = ; // String | New operation 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();
        String body = ; // String | New operation 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();
        }
    }
}
String *body = ; // New operation 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 = ; // {{String}} New operation 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 String(); // String | New operation 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 = ; // String | New operation 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::String->new(); # String | New operation 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 =  # String | New operation 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

Status: 400 - MiNiFi C2 server was unable to complete the request because it was invalid. The request should not be retried without modification.

Status: 404 - The specified resource could not be found.


ParameterMappings

deleteAgentClassParameterContextMapping

Clear a parameter context mapping for a given agent class

DEPRECATED: mapping of agent class parameters is not supported, right now we support agent and flow level parameters only.


/parameter-context-mappings/agent-classes/{agentClass}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/parameter-context-mappings/agent-classes/{agentClass}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParameterMappingsApi;

import java.io.File;
import java.util.*;

public class ParameterMappingsApiExample {

    public static void main(String[] args) {
        
        ParameterMappingsApi apiInstance = new ParameterMappingsApi();
        String agentClass = agentClass_example; // String | The name of the agent class
        try {
            AgentClassParametersMapping result = apiInstance.deleteAgentClassParameterContextMapping(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterMappingsApi#deleteAgentClassParameterContextMapping");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ParameterMappingsApi;

public class ParameterMappingsApiExample {

    public static void main(String[] args) {
        ParameterMappingsApi apiInstance = new ParameterMappingsApi();
        String agentClass = agentClass_example; // String | The name of the agent class
        try {
            AgentClassParametersMapping result = apiInstance.deleteAgentClassParameterContextMapping(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterMappingsApi#deleteAgentClassParameterContextMapping");
            e.printStackTrace();
        }
    }
}
String *agentClass = agentClass_example; // The name of the agent class

ParameterMappingsApi *apiInstance = [[ParameterMappingsApi alloc] init];

// Clear a parameter context mapping for a given agent class
[apiInstance deleteAgentClassParameterContextMappingWith:agentClass
              completionHandler: ^(AgentClassParametersMapping 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.ParameterMappingsApi()
var agentClass = agentClass_example; // {{String}} The name of the agent class

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteAgentClassParameterContextMapping(agentClass, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteAgentClassParameterContextMappingExample
    {
        public void main()
        {

            var apiInstance = new ParameterMappingsApi();
            var agentClass = agentClass_example;  // String | The name of the agent class

            try
            {
                // Clear a parameter context mapping for a given agent class
                AgentClassParametersMapping result = apiInstance.deleteAgentClassParameterContextMapping(agentClass);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterMappingsApi.deleteAgentClassParameterContextMapping: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiParameterMappingsApi();
$agentClass = agentClass_example; // String | The name of the agent class

try {
    $result = $api_instance->deleteAgentClassParameterContextMapping($agentClass);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ParameterMappingsApi->deleteAgentClassParameterContextMapping: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParameterMappingsApi;

my $api_instance = WWW::SwaggerClient::ParameterMappingsApi->new();
my $agentClass = agentClass_example; # String | The name of the agent class

eval { 
    my $result = $api_instance->deleteAgentClassParameterContextMapping(agentClass => $agentClass);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterMappingsApi->deleteAgentClassParameterContextMapping: $@\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.ParameterMappingsApi()
agentClass = agentClass_example # String | The name of the agent class

try: 
    # Clear a parameter context mapping for a given agent class
    api_response = api_instance.delete_agent_class_parameter_context_mapping(agentClass)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterMappingsApi->deleteAgentClassParameterContextMapping: %s\n" % e)

Parameters

Path parameters
Name Description
agentClass*
String
The name of the agent class
Required

Responses

Status: 200 - successful operation


deleteAgentParameterContextMapping

Clear a parameter context mapping for a given agent


/parameter-context-mappings/agents/{agentId}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/parameter-context-mappings/agents/{agentId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParameterMappingsApi;

import java.io.File;
import java.util.*;

public class ParameterMappingsApiExample {

    public static void main(String[] args) {
        
        ParameterMappingsApi apiInstance = new ParameterMappingsApi();
        String agentId = agentId_example; // String | The id of the agent
        try {
            AgentParametersMapping result = apiInstance.deleteAgentParameterContextMapping(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterMappingsApi#deleteAgentParameterContextMapping");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ParameterMappingsApi;

public class ParameterMappingsApiExample {

    public static void main(String[] args) {
        ParameterMappingsApi apiInstance = new ParameterMappingsApi();
        String agentId = agentId_example; // String | The id of the agent
        try {
            AgentParametersMapping result = apiInstance.deleteAgentParameterContextMapping(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterMappingsApi#deleteAgentParameterContextMapping");
            e.printStackTrace();
        }
    }
}
String *agentId = agentId_example; // The id of the agent

ParameterMappingsApi *apiInstance = [[ParameterMappingsApi alloc] init];

// Clear a parameter context mapping for a given agent
[apiInstance deleteAgentParameterContextMappingWith:agentId
              completionHandler: ^(AgentParametersMapping 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.ParameterMappingsApi()
var agentId = agentId_example; // {{String}} The id of the agent

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteAgentParameterContextMapping(agentId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteAgentParameterContextMappingExample
    {
        public void main()
        {

            var apiInstance = new ParameterMappingsApi();
            var agentId = agentId_example;  // String | The id of the agent

            try
            {
                // Clear a parameter context mapping for a given agent
                AgentParametersMapping result = apiInstance.deleteAgentParameterContextMapping(agentId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterMappingsApi.deleteAgentParameterContextMapping: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiParameterMappingsApi();
$agentId = agentId_example; // String | The id of the agent

try {
    $result = $api_instance->deleteAgentParameterContextMapping($agentId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ParameterMappingsApi->deleteAgentParameterContextMapping: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParameterMappingsApi;

my $api_instance = WWW::SwaggerClient::ParameterMappingsApi->new();
my $agentId = agentId_example; # String | The id of the agent

eval { 
    my $result = $api_instance->deleteAgentParameterContextMapping(agentId => $agentId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterMappingsApi->deleteAgentParameterContextMapping: $@\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.ParameterMappingsApi()
agentId = agentId_example # String | The id of the agent

try: 
    # Clear a parameter context mapping for a given agent
    api_response = api_instance.delete_agent_parameter_context_mapping(agentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterMappingsApi->deleteAgentParameterContextMapping: %s\n" % e)

Parameters

Path parameters
Name Description
agentId*
String
The id of the agent
Required

Responses

Status: 200 - successful operation


deleteFlowParameterContextMapping

Clear a parameter context mapping for a given flow


/parameter-context-mappings/flows/{flowId}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/parameter-context-mappings/flows/{flowId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParameterMappingsApi;

import java.io.File;
import java.util.*;

public class ParameterMappingsApiExample {

    public static void main(String[] args) {
        
        ParameterMappingsApi apiInstance = new ParameterMappingsApi();
        String flowId = flowId_example; // String | The id of the flow
        try {
            FlowParametersMapping result = apiInstance.deleteFlowParameterContextMapping(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterMappingsApi#deleteFlowParameterContextMapping");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ParameterMappingsApi;

public class ParameterMappingsApiExample {

    public static void main(String[] args) {
        ParameterMappingsApi apiInstance = new ParameterMappingsApi();
        String flowId = flowId_example; // String | The id of the flow
        try {
            FlowParametersMapping result = apiInstance.deleteFlowParameterContextMapping(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterMappingsApi#deleteFlowParameterContextMapping");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // The id of the flow

ParameterMappingsApi *apiInstance = [[ParameterMappingsApi alloc] init];

// Clear a parameter context mapping for a given flow
[apiInstance deleteFlowParameterContextMappingWith:flowId
              completionHandler: ^(FlowParametersMapping 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.ParameterMappingsApi()
var flowId = flowId_example; // {{String}} The id of the flow

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteFlowParameterContextMapping(flowId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteFlowParameterContextMappingExample
    {
        public void main()
        {

            var apiInstance = new ParameterMappingsApi();
            var flowId = flowId_example;  // String | The id of the flow

            try
            {
                // Clear a parameter context mapping for a given flow
                FlowParametersMapping result = apiInstance.deleteFlowParameterContextMapping(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterMappingsApi.deleteFlowParameterContextMapping: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiParameterMappingsApi();
$flowId = flowId_example; // String | The id of the flow

try {
    $result = $api_instance->deleteFlowParameterContextMapping($flowId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ParameterMappingsApi->deleteFlowParameterContextMapping: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParameterMappingsApi;

my $api_instance = WWW::SwaggerClient::ParameterMappingsApi->new();
my $flowId = flowId_example; # String | The id of the flow

eval { 
    my $result = $api_instance->deleteFlowParameterContextMapping(flowId => $flowId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterMappingsApi->deleteFlowParameterContextMapping: $@\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.ParameterMappingsApi()
flowId = flowId_example # String | The id of the flow

try: 
    # Clear a parameter context mapping for a given flow
    api_response = api_instance.delete_flow_parameter_context_mapping(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterMappingsApi->deleteFlowParameterContextMapping: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
The id of the flow
Required

Responses

Status: 200 - successful operation


getAgentClassParameterContextMapping

Gets the parameter context mapping for a given agent class

DEPRECATED: mapping of agent class parameters is not supported, right now we support agent and flow level parameters only.


/parameter-context-mappings/agent-classes/{agentClass}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/parameter-context-mappings/agent-classes/{agentClass}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParameterMappingsApi;

import java.io.File;
import java.util.*;

public class ParameterMappingsApiExample {

    public static void main(String[] args) {
        
        ParameterMappingsApi apiInstance = new ParameterMappingsApi();
        String agentClass = agentClass_example; // String | The name of the agent class
        try {
            AgentClassParametersMapping result = apiInstance.getAgentClassParameterContextMapping(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterMappingsApi#getAgentClassParameterContextMapping");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ParameterMappingsApi;

public class ParameterMappingsApiExample {

    public static void main(String[] args) {
        ParameterMappingsApi apiInstance = new ParameterMappingsApi();
        String agentClass = agentClass_example; // String | The name of the agent class
        try {
            AgentClassParametersMapping result = apiInstance.getAgentClassParameterContextMapping(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterMappingsApi#getAgentClassParameterContextMapping");
            e.printStackTrace();
        }
    }
}
String *agentClass = agentClass_example; // The name of the agent class

ParameterMappingsApi *apiInstance = [[ParameterMappingsApi alloc] init];

// Gets the parameter context mapping for a given agent class
[apiInstance getAgentClassParameterContextMappingWith:agentClass
              completionHandler: ^(AgentClassParametersMapping 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.ParameterMappingsApi()
var agentClass = agentClass_example; // {{String}} The name of the agent class

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAgentClassParameterContextMapping(agentClass, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAgentClassParameterContextMappingExample
    {
        public void main()
        {

            var apiInstance = new ParameterMappingsApi();
            var agentClass = agentClass_example;  // String | The name of the agent class

            try
            {
                // Gets the parameter context mapping for a given agent class
                AgentClassParametersMapping result = apiInstance.getAgentClassParameterContextMapping(agentClass);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterMappingsApi.getAgentClassParameterContextMapping: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiParameterMappingsApi();
$agentClass = agentClass_example; // String | The name of the agent class

try {
    $result = $api_instance->getAgentClassParameterContextMapping($agentClass);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ParameterMappingsApi->getAgentClassParameterContextMapping: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParameterMappingsApi;

my $api_instance = WWW::SwaggerClient::ParameterMappingsApi->new();
my $agentClass = agentClass_example; # String | The name of the agent class

eval { 
    my $result = $api_instance->getAgentClassParameterContextMapping(agentClass => $agentClass);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterMappingsApi->getAgentClassParameterContextMapping: $@\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.ParameterMappingsApi()
agentClass = agentClass_example # String | The name of the agent class

try: 
    # Gets the parameter context mapping for a given agent class
    api_response = api_instance.get_agent_class_parameter_context_mapping(agentClass)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterMappingsApi->getAgentClassParameterContextMapping: %s\n" % e)

Parameters

Path parameters
Name Description
agentClass*
String
The name of the agent class
Required

Responses

Status: 200 - successful operation


getAgentParameterContextMapping

Gets the parameter context mapping for a given agent


/parameter-context-mappings/agents/{agentId}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/parameter-context-mappings/agents/{agentId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParameterMappingsApi;

import java.io.File;
import java.util.*;

public class ParameterMappingsApiExample {

    public static void main(String[] args) {
        
        ParameterMappingsApi apiInstance = new ParameterMappingsApi();
        String agentId = agentId_example; // String | The id of the agent
        try {
            AgentParametersMapping result = apiInstance.getAgentParameterContextMapping(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterMappingsApi#getAgentParameterContextMapping");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ParameterMappingsApi;

public class ParameterMappingsApiExample {

    public static void main(String[] args) {
        ParameterMappingsApi apiInstance = new ParameterMappingsApi();
        String agentId = agentId_example; // String | The id of the agent
        try {
            AgentParametersMapping result = apiInstance.getAgentParameterContextMapping(agentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterMappingsApi#getAgentParameterContextMapping");
            e.printStackTrace();
        }
    }
}
String *agentId = agentId_example; // The id of the agent

ParameterMappingsApi *apiInstance = [[ParameterMappingsApi alloc] init];

// Gets the parameter context mapping for a given agent
[apiInstance getAgentParameterContextMappingWith:agentId
              completionHandler: ^(AgentParametersMapping 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.ParameterMappingsApi()
var agentId = agentId_example; // {{String}} The id of the agent

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAgentParameterContextMapping(agentId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAgentParameterContextMappingExample
    {
        public void main()
        {

            var apiInstance = new ParameterMappingsApi();
            var agentId = agentId_example;  // String | The id of the agent

            try
            {
                // Gets the parameter context mapping for a given agent
                AgentParametersMapping result = apiInstance.getAgentParameterContextMapping(agentId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterMappingsApi.getAgentParameterContextMapping: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiParameterMappingsApi();
$agentId = agentId_example; // String | The id of the agent

try {
    $result = $api_instance->getAgentParameterContextMapping($agentId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ParameterMappingsApi->getAgentParameterContextMapping: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParameterMappingsApi;

my $api_instance = WWW::SwaggerClient::ParameterMappingsApi->new();
my $agentId = agentId_example; # String | The id of the agent

eval { 
    my $result = $api_instance->getAgentParameterContextMapping(agentId => $agentId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterMappingsApi->getAgentParameterContextMapping: $@\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.ParameterMappingsApi()
agentId = agentId_example # String | The id of the agent

try: 
    # Gets the parameter context mapping for a given agent
    api_response = api_instance.get_agent_parameter_context_mapping(agentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterMappingsApi->getAgentParameterContextMapping: %s\n" % e)

Parameters

Path parameters
Name Description
agentId*
String
The id of the agent
Required

Responses

Status: 200 - successful operation


getFlowParameterContextMapping

Gets the parameter context mapping for a given flow


/parameter-context-mappings/flows/{flowId}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/parameter-context-mappings/flows/{flowId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParameterMappingsApi;

import java.io.File;
import java.util.*;

public class ParameterMappingsApiExample {

    public static void main(String[] args) {
        
        ParameterMappingsApi apiInstance = new ParameterMappingsApi();
        String flowId = flowId_example; // String | The id of the flow
        try {
            FlowParametersMapping result = apiInstance.getFlowParameterContextMapping(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterMappingsApi#getFlowParameterContextMapping");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ParameterMappingsApi;

public class ParameterMappingsApiExample {

    public static void main(String[] args) {
        ParameterMappingsApi apiInstance = new ParameterMappingsApi();
        String flowId = flowId_example; // String | The id of the flow
        try {
            FlowParametersMapping result = apiInstance.getFlowParameterContextMapping(flowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterMappingsApi#getFlowParameterContextMapping");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // The id of the flow

ParameterMappingsApi *apiInstance = [[ParameterMappingsApi alloc] init];

// Gets the parameter context mapping for a given flow
[apiInstance getFlowParameterContextMappingWith:flowId
              completionHandler: ^(FlowParametersMapping 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.ParameterMappingsApi()
var flowId = flowId_example; // {{String}} The id of the flow

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getFlowParameterContextMapping(flowId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getFlowParameterContextMappingExample
    {
        public void main()
        {

            var apiInstance = new ParameterMappingsApi();
            var flowId = flowId_example;  // String | The id of the flow

            try
            {
                // Gets the parameter context mapping for a given flow
                FlowParametersMapping result = apiInstance.getFlowParameterContextMapping(flowId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterMappingsApi.getFlowParameterContextMapping: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiParameterMappingsApi();
$flowId = flowId_example; // String | The id of the flow

try {
    $result = $api_instance->getFlowParameterContextMapping($flowId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ParameterMappingsApi->getFlowParameterContextMapping: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParameterMappingsApi;

my $api_instance = WWW::SwaggerClient::ParameterMappingsApi->new();
my $flowId = flowId_example; # String | The id of the flow

eval { 
    my $result = $api_instance->getFlowParameterContextMapping(flowId => $flowId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterMappingsApi->getFlowParameterContextMapping: $@\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.ParameterMappingsApi()
flowId = flowId_example # String | The id of the flow

try: 
    # Gets the parameter context mapping for a given flow
    api_response = api_instance.get_flow_parameter_context_mapping(flowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterMappingsApi->getFlowParameterContextMapping: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
The id of the flow
Required

Responses

Status: 200 - successful operation


putAgentClassParameterContextMapping

Assign a parameter context to an agent class

DEPRECATED: mapping of agent class parameters is not supported, right now we support agent and flow level parameters only.


/parameter-context-mappings/agent-classes/{agentClass}/{parameterContextId}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
"/efm/api/parameter-context-mappings/agent-classes/{agentClass}/{parameterContextId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParameterMappingsApi;

import java.io.File;
import java.util.*;

public class ParameterMappingsApiExample {

    public static void main(String[] args) {
        
        ParameterMappingsApi apiInstance = new ParameterMappingsApi();
        String agentClass = agentClass_example; // String | The name of the agent class
        String parameterContextId = parameterContextId_example; // String | The id of the parameter context
        try {
            AgentClassParametersMapping result = apiInstance.putAgentClassParameterContextMapping(agentClass, parameterContextId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterMappingsApi#putAgentClassParameterContextMapping");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ParameterMappingsApi;

public class ParameterMappingsApiExample {

    public static void main(String[] args) {
        ParameterMappingsApi apiInstance = new ParameterMappingsApi();
        String agentClass = agentClass_example; // String | The name of the agent class
        String parameterContextId = parameterContextId_example; // String | The id of the parameter context
        try {
            AgentClassParametersMapping result = apiInstance.putAgentClassParameterContextMapping(agentClass, parameterContextId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterMappingsApi#putAgentClassParameterContextMapping");
            e.printStackTrace();
        }
    }
}
String *agentClass = agentClass_example; // The name of the agent class
String *parameterContextId = parameterContextId_example; // The id of the parameter context

ParameterMappingsApi *apiInstance = [[ParameterMappingsApi alloc] init];

// Assign a parameter context to an agent class
[apiInstance putAgentClassParameterContextMappingWith:agentClass
    parameterContextId:parameterContextId
              completionHandler: ^(AgentClassParametersMapping 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.ParameterMappingsApi()
var agentClass = agentClass_example; // {{String}} The name of the agent class
var parameterContextId = parameterContextId_example; // {{String}} The id of the parameter context

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.putAgentClassParameterContextMapping(agentClass, parameterContextId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class putAgentClassParameterContextMappingExample
    {
        public void main()
        {

            var apiInstance = new ParameterMappingsApi();
            var agentClass = agentClass_example;  // String | The name of the agent class
            var parameterContextId = parameterContextId_example;  // String | The id of the parameter context

            try
            {
                // Assign a parameter context to an agent class
                AgentClassParametersMapping result = apiInstance.putAgentClassParameterContextMapping(agentClass, parameterContextId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterMappingsApi.putAgentClassParameterContextMapping: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiParameterMappingsApi();
$agentClass = agentClass_example; // String | The name of the agent class
$parameterContextId = parameterContextId_example; // String | The id of the parameter context

try {
    $result = $api_instance->putAgentClassParameterContextMapping($agentClass, $parameterContextId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ParameterMappingsApi->putAgentClassParameterContextMapping: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParameterMappingsApi;

my $api_instance = WWW::SwaggerClient::ParameterMappingsApi->new();
my $agentClass = agentClass_example; # String | The name of the agent class
my $parameterContextId = parameterContextId_example; # String | The id of the parameter context

eval { 
    my $result = $api_instance->putAgentClassParameterContextMapping(agentClass => $agentClass, parameterContextId => $parameterContextId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterMappingsApi->putAgentClassParameterContextMapping: $@\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.ParameterMappingsApi()
agentClass = agentClass_example # String | The name of the agent class
parameterContextId = parameterContextId_example # String | The id of the parameter context

try: 
    # Assign a parameter context to an agent class
    api_response = api_instance.put_agent_class_parameter_context_mapping(agentClass, parameterContextId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterMappingsApi->putAgentClassParameterContextMapping: %s\n" % e)

Parameters

Path parameters
Name Description
agentClass*
String
The name of the agent class
Required
parameterContextId*
String
The id of the parameter context
Required

Responses

Status: 200 - successful operation


putAgentParameterContextMapping

Assign a parameter context to an agent


/parameter-context-mappings/agents/{agentId}/{parameterContextId}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
"/efm/api/parameter-context-mappings/agents/{agentId}/{parameterContextId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParameterMappingsApi;

import java.io.File;
import java.util.*;

public class ParameterMappingsApiExample {

    public static void main(String[] args) {
        
        ParameterMappingsApi apiInstance = new ParameterMappingsApi();
        String agentId = agentId_example; // String | The id of the agent
        String parameterContextId = parameterContextId_example; // String | The id of the parameter context
        try {
            AgentParametersMapping result = apiInstance.putAgentParameterContextMapping(agentId, parameterContextId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterMappingsApi#putAgentParameterContextMapping");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ParameterMappingsApi;

public class ParameterMappingsApiExample {

    public static void main(String[] args) {
        ParameterMappingsApi apiInstance = new ParameterMappingsApi();
        String agentId = agentId_example; // String | The id of the agent
        String parameterContextId = parameterContextId_example; // String | The id of the parameter context
        try {
            AgentParametersMapping result = apiInstance.putAgentParameterContextMapping(agentId, parameterContextId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterMappingsApi#putAgentParameterContextMapping");
            e.printStackTrace();
        }
    }
}
String *agentId = agentId_example; // The id of the agent
String *parameterContextId = parameterContextId_example; // The id of the parameter context

ParameterMappingsApi *apiInstance = [[ParameterMappingsApi alloc] init];

// Assign a parameter context to an agent
[apiInstance putAgentParameterContextMappingWith:agentId
    parameterContextId:parameterContextId
              completionHandler: ^(AgentParametersMapping 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.ParameterMappingsApi()
var agentId = agentId_example; // {{String}} The id of the agent
var parameterContextId = parameterContextId_example; // {{String}} The id of the parameter context

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.putAgentParameterContextMapping(agentId, parameterContextId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class putAgentParameterContextMappingExample
    {
        public void main()
        {

            var apiInstance = new ParameterMappingsApi();
            var agentId = agentId_example;  // String | The id of the agent
            var parameterContextId = parameterContextId_example;  // String | The id of the parameter context

            try
            {
                // Assign a parameter context to an agent
                AgentParametersMapping result = apiInstance.putAgentParameterContextMapping(agentId, parameterContextId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterMappingsApi.putAgentParameterContextMapping: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiParameterMappingsApi();
$agentId = agentId_example; // String | The id of the agent
$parameterContextId = parameterContextId_example; // String | The id of the parameter context

try {
    $result = $api_instance->putAgentParameterContextMapping($agentId, $parameterContextId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ParameterMappingsApi->putAgentParameterContextMapping: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParameterMappingsApi;

my $api_instance = WWW::SwaggerClient::ParameterMappingsApi->new();
my $agentId = agentId_example; # String | The id of the agent
my $parameterContextId = parameterContextId_example; # String | The id of the parameter context

eval { 
    my $result = $api_instance->putAgentParameterContextMapping(agentId => $agentId, parameterContextId => $parameterContextId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterMappingsApi->putAgentParameterContextMapping: $@\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.ParameterMappingsApi()
agentId = agentId_example # String | The id of the agent
parameterContextId = parameterContextId_example # String | The id of the parameter context

try: 
    # Assign a parameter context to an agent
    api_response = api_instance.put_agent_parameter_context_mapping(agentId, parameterContextId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterMappingsApi->putAgentParameterContextMapping: %s\n" % e)

Parameters

Path parameters
Name Description
agentId*
String
The id of the agent
Required
parameterContextId*
String
The id of the parameter context
Required

Responses

Status: 200 - successful operation


putFlowParameterContextMapping

Assign a parameter context to a flow


/parameter-context-mappings/flows/{flowId}/{parameterContextId}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
"/efm/api/parameter-context-mappings/flows/{flowId}/{parameterContextId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParameterMappingsApi;

import java.io.File;
import java.util.*;

public class ParameterMappingsApiExample {

    public static void main(String[] args) {
        
        ParameterMappingsApi apiInstance = new ParameterMappingsApi();
        String flowId = flowId_example; // String | The id of the flow
        String parameterContextId = parameterContextId_example; // String | The id of the parameter context
        try {
            FlowParametersMapping result = apiInstance.putFlowParameterContextMapping(flowId, parameterContextId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterMappingsApi#putFlowParameterContextMapping");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ParameterMappingsApi;

public class ParameterMappingsApiExample {

    public static void main(String[] args) {
        ParameterMappingsApi apiInstance = new ParameterMappingsApi();
        String flowId = flowId_example; // String | The id of the flow
        String parameterContextId = parameterContextId_example; // String | The id of the parameter context
        try {
            FlowParametersMapping result = apiInstance.putFlowParameterContextMapping(flowId, parameterContextId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParameterMappingsApi#putFlowParameterContextMapping");
            e.printStackTrace();
        }
    }
}
String *flowId = flowId_example; // The id of the flow
String *parameterContextId = parameterContextId_example; // The id of the parameter context

ParameterMappingsApi *apiInstance = [[ParameterMappingsApi alloc] init];

// Assign a parameter context to a flow
[apiInstance putFlowParameterContextMappingWith:flowId
    parameterContextId:parameterContextId
              completionHandler: ^(FlowParametersMapping 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.ParameterMappingsApi()
var flowId = flowId_example; // {{String}} The id of the flow
var parameterContextId = parameterContextId_example; // {{String}} The id of the parameter context

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.putFlowParameterContextMapping(flowId, parameterContextId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class putFlowParameterContextMappingExample
    {
        public void main()
        {

            var apiInstance = new ParameterMappingsApi();
            var flowId = flowId_example;  // String | The id of the flow
            var parameterContextId = parameterContextId_example;  // String | The id of the parameter context

            try
            {
                // Assign a parameter context to a flow
                FlowParametersMapping result = apiInstance.putFlowParameterContextMapping(flowId, parameterContextId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParameterMappingsApi.putFlowParameterContextMapping: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiParameterMappingsApi();
$flowId = flowId_example; // String | The id of the flow
$parameterContextId = parameterContextId_example; // String | The id of the parameter context

try {
    $result = $api_instance->putFlowParameterContextMapping($flowId, $parameterContextId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ParameterMappingsApi->putFlowParameterContextMapping: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParameterMappingsApi;

my $api_instance = WWW::SwaggerClient::ParameterMappingsApi->new();
my $flowId = flowId_example; # String | The id of the flow
my $parameterContextId = parameterContextId_example; # String | The id of the parameter context

eval { 
    my $result = $api_instance->putFlowParameterContextMapping(flowId => $flowId, parameterContextId => $parameterContextId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParameterMappingsApi->putFlowParameterContextMapping: $@\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.ParameterMappingsApi()
flowId = flowId_example # String | The id of the flow
parameterContextId = parameterContextId_example # String | The id of the parameter context

try: 
    # Assign a parameter context to a flow
    api_response = api_instance.put_flow_parameter_context_mapping(flowId, parameterContextId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParameterMappingsApi->putFlowParameterContextMapping: %s\n" % e)

Parameters

Path parameters
Name Description
flowId*
String
The id of the flow
Required
parameterContextId*
String
The id of the parameter context
Required

Responses

Status: 200 - successful operation


Parameters

createParameterContext

Create a parameter context

DEPRECATED: Functionality has been integrated to /agents/{id}/parameters and /flows/{id}/parameters.


/parameter-contexts

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: */*"\
"/efm/api/parameter-contexts"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParametersApi;

import java.io.File;
import java.util.*;

public class ParametersApiExample {

    public static void main(String[] args) {
        
        ParametersApi apiInstance = new ParametersApi();
        ParameterContext body = ; // ParameterContext | The new parameter context
        try {
            ParameterContext result = apiInstance.createParameterContext(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#createParameterContext");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

    public static void main(String[] args) {
        ParametersApi apiInstance = new ParametersApi();
        ParameterContext body = ; // ParameterContext | The new parameter context
        try {
            ParameterContext result = apiInstance.createParameterContext(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#createParameterContext");
            e.printStackTrace();
        }
    }
}
ParameterContext *body = ; // The new parameter context

ParametersApi *apiInstance = [[ParametersApi alloc] init];

// Create a parameter context
[apiInstance createParameterContextWith:body
              completionHandler: ^(ParameterContext 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.ParametersApi()
var body = ; // {{ParameterContext}} The new parameter context

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createParameterContext(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createParameterContextExample
    {
        public void main()
        {

            var apiInstance = new ParametersApi();
            var body = new ParameterContext(); // ParameterContext | The new parameter context

            try
            {
                // Create a parameter context
                ParameterContext result = apiInstance.createParameterContext(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.createParameterContext: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiParametersApi();
$body = ; // ParameterContext | The new parameter context

try {
    $result = $api_instance->createParameterContext($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ParametersApi->createParameterContext: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParametersApi;

my $api_instance = WWW::SwaggerClient::ParametersApi->new();
my $body = WWW::SwaggerClient::Object::ParameterContext->new(); # ParameterContext | The new parameter context

eval { 
    my $result = $api_instance->createParameterContext(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParametersApi->createParameterContext: $@\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.ParametersApi()
body =  # ParameterContext | The new parameter context

try: 
    # Create a parameter context
    api_response = api_instance.create_parameter_context(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->createParameterContext: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


deleteParameterContext

Delete a parameter context

DEPRECATED: Functionality has been integrated to /agents/{id}/parameters and /flows/{id}/parameters.


/parameter-contexts/{id}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/parameter-contexts/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParametersApi;

import java.io.File;
import java.util.*;

public class ParametersApiExample {

    public static void main(String[] args) {
        
        ParametersApi apiInstance = new ParametersApi();
        String id = id_example; // String | The id of the parameter context
        try {
            ParameterContext result = apiInstance.deleteParameterContext(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#deleteParameterContext");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

    public static void main(String[] args) {
        ParametersApi apiInstance = new ParametersApi();
        String id = id_example; // String | The id of the parameter context
        try {
            ParameterContext result = apiInstance.deleteParameterContext(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#deleteParameterContext");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The id of the parameter context

ParametersApi *apiInstance = [[ParametersApi alloc] init];

// Delete a parameter context
[apiInstance deleteParameterContextWith:id
              completionHandler: ^(ParameterContext 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.ParametersApi()
var id = id_example; // {{String}} The id of the parameter context

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteParameterContext(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteParameterContextExample
    {
        public void main()
        {

            var apiInstance = new ParametersApi();
            var id = id_example;  // String | The id of the parameter context

            try
            {
                // Delete a parameter context
                ParameterContext result = apiInstance.deleteParameterContext(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.deleteParameterContext: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiParametersApi();
$id = id_example; // String | The id of the parameter context

try {
    $result = $api_instance->deleteParameterContext($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ParametersApi->deleteParameterContext: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParametersApi;

my $api_instance = WWW::SwaggerClient::ParametersApi->new();
my $id = id_example; # String | The id of the parameter context

eval { 
    my $result = $api_instance->deleteParameterContext(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParametersApi->deleteParameterContext: $@\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.ParametersApi()
id = id_example # String | The id of the parameter context

try: 
    # Delete a parameter context
    api_response = api_instance.delete_parameter_context(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->deleteParameterContext: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The id of the parameter context
Required

Responses

Status: 200 - successful operation


getParameterContext

Gets a parameter context

DEPRECATED: Functionality has been integrated to /agents/{id}/parameters and /flows/{id}/parameters.


/parameter-contexts/{id}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/parameter-contexts/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParametersApi;

import java.io.File;
import java.util.*;

public class ParametersApiExample {

    public static void main(String[] args) {
        
        ParametersApi apiInstance = new ParametersApi();
        String id = id_example; // String | The id of the parameter context
        try {
            ParameterContext result = apiInstance.getParameterContext(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#getParameterContext");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

    public static void main(String[] args) {
        ParametersApi apiInstance = new ParametersApi();
        String id = id_example; // String | The id of the parameter context
        try {
            ParameterContext result = apiInstance.getParameterContext(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#getParameterContext");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The id of the parameter context

ParametersApi *apiInstance = [[ParametersApi alloc] init];

// Gets a parameter context
[apiInstance getParameterContextWith:id
              completionHandler: ^(ParameterContext 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.ParametersApi()
var id = id_example; // {{String}} The id of the parameter context

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getParameterContext(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getParameterContextExample
    {
        public void main()
        {

            var apiInstance = new ParametersApi();
            var id = id_example;  // String | The id of the parameter context

            try
            {
                // Gets a parameter context
                ParameterContext result = apiInstance.getParameterContext(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.getParameterContext: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiParametersApi();
$id = id_example; // String | The id of the parameter context

try {
    $result = $api_instance->getParameterContext($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ParametersApi->getParameterContext: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParametersApi;

my $api_instance = WWW::SwaggerClient::ParametersApi->new();
my $id = id_example; # String | The id of the parameter context

eval { 
    my $result = $api_instance->getParameterContext(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParametersApi->getParameterContext: $@\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.ParametersApi()
id = id_example # String | The id of the parameter context

try: 
    # Gets a parameter context
    api_response = api_instance.get_parameter_context(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->getParameterContext: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The id of the parameter context
Required

Responses

Status: 200 - successful operation


getParameterContexts

Gets all available parameter contexts

DEPRECATED: Functionality has been integrated to /agents/{id}/parameters and /flows/{id}/parameters.


/parameter-contexts

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/parameter-contexts?pageNum=&rows="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParametersApi;

import java.io.File;
import java.util.*;

public class ParametersApiExample {

    public static void main(String[] args) {
        
        ParametersApi apiInstance = new ParametersApi();
        Integer pageNum = 56; // Integer | 
        Integer rows = 56; // Integer | 
        try {
            ParameterContextList result = apiInstance.getParameterContexts(pageNum, rows);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#getParameterContexts");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

    public static void main(String[] args) {
        ParametersApi apiInstance = new ParametersApi();
        Integer pageNum = 56; // Integer | 
        Integer rows = 56; // Integer | 
        try {
            ParameterContextList result = apiInstance.getParameterContexts(pageNum, rows);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#getParameterContexts");
            e.printStackTrace();
        }
    }
}
Integer *pageNum = 56; //  (optional)
Integer *rows = 56; //  (optional)

ParametersApi *apiInstance = [[ParametersApi alloc] init];

// Gets all available parameter contexts
[apiInstance getParameterContextsWith:pageNum
    rows:rows
              completionHandler: ^(ParameterContextList 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.ParametersApi()
var opts = { 
  'pageNum': 56, // {{Integer}} 
  'rows': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getParameterContexts(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getParameterContextsExample
    {
        public void main()
        {

            var apiInstance = new ParametersApi();
            var pageNum = 56;  // Integer |  (optional) 
            var rows = 56;  // Integer |  (optional) 

            try
            {
                // Gets all available parameter contexts
                ParameterContextList result = apiInstance.getParameterContexts(pageNum, rows);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.getParameterContexts: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiParametersApi();
$pageNum = 56; // Integer | 
$rows = 56; // Integer | 

try {
    $result = $api_instance->getParameterContexts($pageNum, $rows);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ParametersApi->getParameterContexts: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParametersApi;

my $api_instance = WWW::SwaggerClient::ParametersApi->new();
my $pageNum = 56; # Integer | 
my $rows = 56; # Integer | 

eval { 
    my $result = $api_instance->getParameterContexts(pageNum => $pageNum, rows => $rows);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParametersApi->getParameterContexts: $@\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.ParametersApi()
pageNum = 56 # Integer |  (optional)
rows = 56 # Integer |  (optional)

try: 
    # Gets all available parameter contexts
    api_response = api_instance.get_parameter_contexts(pageNum=pageNum, rows=rows)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->getParameterContexts: %s\n" % e)

Parameters

Query parameters
Name Description
pageNum
Integer (int32)
rows
Integer (int32)

Responses

Status: 200 - successful operation


updateParameterContext

Update a parameter context

DEPRECATED: Functionality has been integrated to /agents/{id}/parameters and /flows/{id}/parameters.


/parameter-contexts/{id}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/efm/api/parameter-contexts/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParametersApi;

import java.io.File;
import java.util.*;

public class ParametersApiExample {

    public static void main(String[] args) {
        
        ParametersApi apiInstance = new ParametersApi();
        String id = id_example; // String | The id of the parameter context
        ParameterContext body = ; // ParameterContext | The parameter context
        try {
            ParameterContext result = apiInstance.updateParameterContext(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#updateParameterContext");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

    public static void main(String[] args) {
        ParametersApi apiInstance = new ParametersApi();
        String id = id_example; // String | The id of the parameter context
        ParameterContext body = ; // ParameterContext | The parameter context
        try {
            ParameterContext result = apiInstance.updateParameterContext(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#updateParameterContext");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The id of the parameter context
ParameterContext *body = ; // The parameter context (optional)

ParametersApi *apiInstance = [[ParametersApi alloc] init];

// Update a parameter context
[apiInstance updateParameterContextWith:id
    body:body
              completionHandler: ^(ParameterContext 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.ParametersApi()
var id = id_example; // {{String}} The id of the parameter context
var opts = { 
  'body':  // {{ParameterContext}} The parameter context
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateParameterContext(id, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateParameterContextExample
    {
        public void main()
        {

            var apiInstance = new ParametersApi();
            var id = id_example;  // String | The id of the parameter context
            var body = new ParameterContext(); // ParameterContext | The parameter context (optional) 

            try
            {
                // Update a parameter context
                ParameterContext result = apiInstance.updateParameterContext(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.updateParameterContext: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiParametersApi();
$id = id_example; // String | The id of the parameter context
$body = ; // ParameterContext | The parameter context

try {
    $result = $api_instance->updateParameterContext($id, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ParametersApi->updateParameterContext: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParametersApi;

my $api_instance = WWW::SwaggerClient::ParametersApi->new();
my $id = id_example; # String | The id of the parameter context
my $body = WWW::SwaggerClient::Object::ParameterContext->new(); # ParameterContext | The parameter context

eval { 
    my $result = $api_instance->updateParameterContext(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParametersApi->updateParameterContext: $@\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.ParametersApi()
id = id_example # String | The id of the parameter context
body =  # ParameterContext | The parameter context (optional)

try: 
    # Update a parameter context
    api_response = api_instance.update_parameter_context(id, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->updateParameterContext: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The id of the parameter context
Required
Body parameters
Name Description
body

Responses

Status: 200 - successful operation


PoliciesAgentClass

getAgentClassPolicies

Gets the policies for an agent class by agent class name


/policies/agent-class/{agentClass}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/policies/agent-class/{agentClass}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoliciesAgentClassApi;

import java.io.File;
import java.util.*;

public class PoliciesAgentClassApiExample {

    public static void main(String[] args) {
        
        PoliciesAgentClassApi apiInstance = new PoliciesAgentClassApi();
        String agentClass = agentClass_example; // String | The name of the agent class
        try {
            AgentClassPolicies result = apiInstance.getAgentClassPolicies(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoliciesAgentClassApi#getAgentClassPolicies");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PoliciesAgentClassApi;

public class PoliciesAgentClassApiExample {

    public static void main(String[] args) {
        PoliciesAgentClassApi apiInstance = new PoliciesAgentClassApi();
        String agentClass = agentClass_example; // String | The name of the agent class
        try {
            AgentClassPolicies result = apiInstance.getAgentClassPolicies(agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoliciesAgentClassApi#getAgentClassPolicies");
            e.printStackTrace();
        }
    }
}
String *agentClass = agentClass_example; // The name of the agent class

PoliciesAgentClassApi *apiInstance = [[PoliciesAgentClassApi alloc] init];

// Gets the policies for an agent class by agent class name
[apiInstance getAgentClassPoliciesWith:agentClass
              completionHandler: ^(AgentClassPolicies 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.PoliciesAgentClassApi()
var agentClass = agentClass_example; // {{String}} The name of the agent class

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAgentClassPolicies(agentClass, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAgentClassPoliciesExample
    {
        public void main()
        {

            var apiInstance = new PoliciesAgentClassApi();
            var agentClass = agentClass_example;  // String | The name of the agent class

            try
            {
                // Gets the policies for an agent class by agent class name
                AgentClassPolicies result = apiInstance.getAgentClassPolicies(agentClass);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PoliciesAgentClassApi.getAgentClassPolicies: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPoliciesAgentClassApi();
$agentClass = agentClass_example; // String | The name of the agent class

try {
    $result = $api_instance->getAgentClassPolicies($agentClass);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PoliciesAgentClassApi->getAgentClassPolicies: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoliciesAgentClassApi;

my $api_instance = WWW::SwaggerClient::PoliciesAgentClassApi->new();
my $agentClass = agentClass_example; # String | The name of the agent class

eval { 
    my $result = $api_instance->getAgentClassPolicies(agentClass => $agentClass);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PoliciesAgentClassApi->getAgentClassPolicies: $@\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.PoliciesAgentClassApi()
agentClass = agentClass_example # String | The name of the agent class

try: 
    # Gets the policies for an agent class by agent class name
    api_response = api_instance.get_agent_class_policies(agentClass)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PoliciesAgentClassApi->getAgentClassPolicies: %s\n" % e)

Parameters

Path parameters
Name Description
agentClass*
String
The name of the agent class
Required

Responses

Status: 200 - successful operation


getAgentClassPoliciesList

Gets all agent class policies


/policies/agent-class

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/policies/agent-class"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoliciesAgentClassApi;

import java.io.File;
import java.util.*;

public class PoliciesAgentClassApiExample {

    public static void main(String[] args) {
        
        PoliciesAgentClassApi apiInstance = new PoliciesAgentClassApi();
        try {
            array[AgentClassPoliciesSummary] result = apiInstance.getAgentClassPoliciesList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoliciesAgentClassApi#getAgentClassPoliciesList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PoliciesAgentClassApi;

public class PoliciesAgentClassApiExample {

    public static void main(String[] args) {
        PoliciesAgentClassApi apiInstance = new PoliciesAgentClassApi();
        try {
            array[AgentClassPoliciesSummary] result = apiInstance.getAgentClassPoliciesList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoliciesAgentClassApi#getAgentClassPoliciesList");
            e.printStackTrace();
        }
    }
}

PoliciesAgentClassApi *apiInstance = [[PoliciesAgentClassApi alloc] init];

// Gets all agent class policies
[apiInstance getAgentClassPoliciesListWithCompletionHandler: 
              ^(array[AgentClassPoliciesSummary] 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.PoliciesAgentClassApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAgentClassPoliciesList(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAgentClassPoliciesListExample
    {
        public void main()
        {

            var apiInstance = new PoliciesAgentClassApi();

            try
            {
                // Gets all agent class policies
                array[AgentClassPoliciesSummary] result = apiInstance.getAgentClassPoliciesList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PoliciesAgentClassApi.getAgentClassPoliciesList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPoliciesAgentClassApi();

try {
    $result = $api_instance->getAgentClassPoliciesList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PoliciesAgentClassApi->getAgentClassPoliciesList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoliciesAgentClassApi;

my $api_instance = WWW::SwaggerClient::PoliciesAgentClassApi->new();

eval { 
    my $result = $api_instance->getAgentClassPoliciesList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PoliciesAgentClassApi->getAgentClassPoliciesList: $@\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.PoliciesAgentClassApi()

try: 
    # Gets all agent class policies
    api_response = api_instance.get_agent_class_policies_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PoliciesAgentClassApi->getAgentClassPoliciesList: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


modifyAgentClassPolicies

Accepts a form of all changes that can be made on the Edit Agent Class Policies side panel UI, so that they can be processed as a single transaction


/policies/agent-class/{agentClass}

Usage and SDK Samples

curl -X PATCH\
-H "Accept: application/json"\
-H "Content-Type: */*"\
"/efm/api/policies/agent-class/{agentClass}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PoliciesAgentClassApi;

import java.io.File;
import java.util.*;

public class PoliciesAgentClassApiExample {

    public static void main(String[] args) {
        
        PoliciesAgentClassApi apiInstance = new PoliciesAgentClassApi();
        AgentClassPoliciesModificationRequest body = ; // AgentClassPoliciesModificationRequest | The list of modifications. Note that only user and group identifiers are required, not identities or names.
        String agentClass = agentClass_example; // String | The name of the agent class to modify
        try {
            AgentClassPolicies result = apiInstance.modifyAgentClassPolicies(body, agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoliciesAgentClassApi#modifyAgentClassPolicies");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PoliciesAgentClassApi;

public class PoliciesAgentClassApiExample {

    public static void main(String[] args) {
        PoliciesAgentClassApi apiInstance = new PoliciesAgentClassApi();
        AgentClassPoliciesModificationRequest body = ; // AgentClassPoliciesModificationRequest | The list of modifications. Note that only user and group identifiers are required, not identities or names.
        String agentClass = agentClass_example; // String | The name of the agent class to modify
        try {
            AgentClassPolicies result = apiInstance.modifyAgentClassPolicies(body, agentClass);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PoliciesAgentClassApi#modifyAgentClassPolicies");
            e.printStackTrace();
        }
    }
}
AgentClassPoliciesModificationRequest *body = ; // The list of modifications. Note that only user and group identifiers are required, not identities or names.
String *agentClass = agentClass_example; // The name of the agent class to modify

PoliciesAgentClassApi *apiInstance = [[PoliciesAgentClassApi alloc] init];

// Accepts a form of all changes that can be made on the Edit Agent Class Policies side panel UI, so that they can be processed as a single transaction
[apiInstance modifyAgentClassPoliciesWith:body
    agentClass:agentClass
              completionHandler: ^(AgentClassPolicies 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.PoliciesAgentClassApi()
var body = ; // {{AgentClassPoliciesModificationRequest}} The list of modifications. Note that only user and group identifiers are required, not identities or names.
var agentClass = agentClass_example; // {{String}} The name of the agent class to modify

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.modifyAgentClassPolicies(bodyagentClass, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class modifyAgentClassPoliciesExample
    {
        public void main()
        {

            var apiInstance = new PoliciesAgentClassApi();
            var body = new AgentClassPoliciesModificationRequest(); // AgentClassPoliciesModificationRequest | The list of modifications. Note that only user and group identifiers are required, not identities or names.
            var agentClass = agentClass_example;  // String | The name of the agent class to modify

            try
            {
                // Accepts a form of all changes that can be made on the Edit Agent Class Policies side panel UI, so that they can be processed as a single transaction
                AgentClassPolicies result = apiInstance.modifyAgentClassPolicies(body, agentClass);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PoliciesAgentClassApi.modifyAgentClassPolicies: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPoliciesAgentClassApi();
$body = ; // AgentClassPoliciesModificationRequest | The list of modifications. Note that only user and group identifiers are required, not identities or names.
$agentClass = agentClass_example; // String | The name of the agent class to modify

try {
    $result = $api_instance->modifyAgentClassPolicies($body, $agentClass);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PoliciesAgentClassApi->modifyAgentClassPolicies: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PoliciesAgentClassApi;

my $api_instance = WWW::SwaggerClient::PoliciesAgentClassApi->new();
my $body = WWW::SwaggerClient::Object::AgentClassPoliciesModificationRequest->new(); # AgentClassPoliciesModificationRequest | The list of modifications. Note that only user and group identifiers are required, not identities or names.
my $agentClass = agentClass_example; # String | The name of the agent class to modify

eval { 
    my $result = $api_instance->modifyAgentClassPolicies(body => $body, agentClass => $agentClass);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PoliciesAgentClassApi->modifyAgentClassPolicies: $@\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.PoliciesAgentClassApi()
body =  # AgentClassPoliciesModificationRequest | The list of modifications. Note that only user and group identifiers are required, not identities or names.
agentClass = agentClass_example # String | The name of the agent class to modify

try: 
    # Accepts a form of all changes that can be made on the Edit Agent Class Policies side panel UI, so that they can be processed as a single transaction
    api_response = api_instance.modify_agent_class_policies(body, agentClass)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PoliciesAgentClassApi->modifyAgentClassPolicies: %s\n" % e)

Parameters

Path parameters
Name Description
agentClass*
String
The name of the agent class to modify
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


SSO

login

Redirects the user agent to the currently configured SSO login page.


/sso/login

Usage and SDK Samples

curl -X GET\
"/efm/api/sso/login"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SSOApi;

import java.io.File;
import java.util.*;

public class SSOApiExample {

    public static void main(String[] args) {
        
        SSOApi apiInstance = new SSOApi();
        try {
            apiInstance.login();
        } catch (ApiException e) {
            System.err.println("Exception when calling SSOApi#login");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SSOApi;

public class SSOApiExample {

    public static void main(String[] args) {
        SSOApi apiInstance = new SSOApi();
        try {
            apiInstance.login();
        } catch (ApiException e) {
            System.err.println("Exception when calling SSOApi#login");
            e.printStackTrace();
        }
    }
}

SSOApi *apiInstance = [[SSOApi alloc] init];

// Redirects the user agent to the currently configured SSO login page.
[apiInstance loginWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.SSOApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.login(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class loginExample
    {
        public void main()
        {

            var apiInstance = new SSOApi();

            try
            {
                // Redirects the user agent to the currently configured SSO login page.
                apiInstance.login();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SSOApi.login: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSSOApi();

try {
    $api_instance->login();
} catch (Exception $e) {
    echo 'Exception when calling SSOApi->login: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SSOApi;

my $api_instance = WWW::SwaggerClient::SSOApi->new();

eval { 
    $api_instance->login();
};
if ($@) {
    warn "Exception when calling SSOApi->login: $@\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.SSOApi()

try: 
    # Redirects the user agent to the currently configured SSO login page.
    api_instance.login()
except ApiException as e:
    print("Exception when calling SSOApi->login: %s\n" % e)

Parameters

Responses

Status: default - successful operation


logout

Redirects the user agent to the currently configured SSO login page.


/sso/logout

Usage and SDK Samples

curl -X GET\
"/efm/api/sso/logout"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SSOApi;

import java.io.File;
import java.util.*;

public class SSOApiExample {

    public static void main(String[] args) {
        
        SSOApi apiInstance = new SSOApi();
        try {
            apiInstance.logout();
        } catch (ApiException e) {
            System.err.println("Exception when calling SSOApi#logout");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SSOApi;

public class SSOApiExample {

    public static void main(String[] args) {
        SSOApi apiInstance = new SSOApi();
        try {
            apiInstance.logout();
        } catch (ApiException e) {
            System.err.println("Exception when calling SSOApi#logout");
            e.printStackTrace();
        }
    }
}

SSOApi *apiInstance = [[SSOApi alloc] init];

// Redirects the user agent to the currently configured SSO login page.
[apiInstance logoutWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.SSOApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.logout(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class logoutExample
    {
        public void main()
        {

            var apiInstance = new SSOApi();

            try
            {
                // Redirects the user agent to the currently configured SSO login page.
                apiInstance.logout();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SSOApi.logout: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSSOApi();

try {
    $api_instance->logout();
} catch (Exception $e) {
    echo 'Exception when calling SSOApi->logout: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SSOApi;

my $api_instance = WWW::SwaggerClient::SSOApi->new();

eval { 
    $api_instance->logout();
};
if ($@) {
    warn "Exception when calling SSOApi->logout: $@\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.SSOApi()

try: 
    # Redirects the user agent to the currently configured SSO login page.
    api_instance.logout()
except ApiException as e:
    print("Exception when calling SSOApi->logout: %s\n" % e)

Parameters

Responses

Status: default - successful operation


Transfer

download

Get the given file from C2 server.


/transfer/{id}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/force-download"\
"/efm/api/transfer/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TransferApi;

import java.io.File;
import java.util.*;

public class TransferApiExample {

    public static void main(String[] args) {
        
        TransferApi apiInstance = new TransferApi();
        String id = id_example; // String | The identifier of the transfer data entry to retrieve the attachment from
        try {
            ByteArrayResource result = apiInstance.download(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransferApi#download");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TransferApi;

public class TransferApiExample {

    public static void main(String[] args) {
        TransferApi apiInstance = new TransferApi();
        String id = id_example; // String | The identifier of the transfer data entry to retrieve the attachment from
        try {
            ByteArrayResource result = apiInstance.download(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransferApi#download");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The identifier of the transfer data entry to retrieve the attachment from

TransferApi *apiInstance = [[TransferApi alloc] init];

// Get the given file from C2 server. 
[apiInstance downloadWith:id
              completionHandler: ^(ByteArrayResource 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.TransferApi()
var id = id_example; // {{String}} The identifier of the transfer data entry to retrieve the attachment from

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.download(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class downloadExample
    {
        public void main()
        {

            var apiInstance = new TransferApi();
            var id = id_example;  // String | The identifier of the transfer data entry to retrieve the attachment from

            try
            {
                // Get the given file from C2 server. 
                ByteArrayResource result = apiInstance.download(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TransferApi.download: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTransferApi();
$id = id_example; // String | The identifier of the transfer data entry to retrieve the attachment from

try {
    $result = $api_instance->download($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TransferApi->download: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TransferApi;

my $api_instance = WWW::SwaggerClient::TransferApi->new();
my $id = id_example; # String | The identifier of the transfer data entry to retrieve the attachment from

eval { 
    my $result = $api_instance->download(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransferApi->download: $@\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.TransferApi()
id = id_example # String | The identifier of the transfer data entry to retrieve the attachment from

try: 
    # Get the given file from C2 server. 
    api_response = api_instance.download(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransferApi->download: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The identifier of the transfer data entry to retrieve the attachment from
Required

Responses

Status: 200 - successful operation


Users

createUser

Create a user


/users

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: */*"\
"/efm/api/users"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UsersApi;

import java.io.File;
import java.util.*;

public class UsersApiExample {

    public static void main(String[] args) {
        
        UsersApi apiInstance = new UsersApi();
        User body = ; // User | The new user
        try {
            User result = apiInstance.createUser(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#createUser");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        User body = ; // User | The new user
        try {
            User result = apiInstance.createUser(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#createUser");
            e.printStackTrace();
        }
    }
}
User *body = ; // The new user

UsersApi *apiInstance = [[UsersApi alloc] init];

// Create a user
[apiInstance createUserWith:body
              completionHandler: ^(User 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.UsersApi()
var body = ; // {{User}} The new user

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createUser(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createUserExample
    {
        public void main()
        {

            var apiInstance = new UsersApi();
            var body = new User(); // User | The new user

            try
            {
                // Create a user
                User result = apiInstance.createUser(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.createUser: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUsersApi();
$body = ; // User | The new user

try {
    $result = $api_instance->createUser($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->createUser: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UsersApi;

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $body = WWW::SwaggerClient::Object::User->new(); # User | The new user

eval { 
    my $result = $api_instance->createUser(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->createUser: $@\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.UsersApi()
body =  # User | The new user

try: 
    # Create a user
    api_response = api_instance.create_user(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->createUser: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


deleteUser

Deletes a user


/users/{id}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/efm/api/users/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UsersApi;

import java.io.File;
import java.util.*;

public class UsersApiExample {

    public static void main(String[] args) {
        
        UsersApi apiInstance = new UsersApi();
        String id = id_example; // String | The id of the user
        try {
            User result = apiInstance.deleteUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#deleteUser");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        String id = id_example; // String | The id of the user
        try {
            User result = apiInstance.deleteUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#deleteUser");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The id of the user

UsersApi *apiInstance = [[UsersApi alloc] init];

// Deletes a user
[apiInstance deleteUserWith:id
              completionHandler: ^(User 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.UsersApi()
var id = id_example; // {{String}} The id of the user

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteUser(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteUserExample
    {
        public void main()
        {

            var apiInstance = new UsersApi();
            var id = id_example;  // String | The id of the user

            try
            {
                // Deletes a user
                User result = apiInstance.deleteUser(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.deleteUser: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUsersApi();
$id = id_example; // String | The id of the user

try {
    $result = $api_instance->deleteUser($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->deleteUser: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UsersApi;

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $id = id_example; # String | The id of the user

eval { 
    my $result = $api_instance->deleteUser(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->deleteUser: $@\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.UsersApi()
id = id_example # String | The id of the user

try: 
    # Deletes a user
    api_response = api_instance.delete_user(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->deleteUser: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The id of the user
Required

Responses

Status: 200 - successful operation


getUser

Gets a user by id


/users/{id}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/users/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UsersApi;

import java.io.File;
import java.util.*;

public class UsersApiExample {

    public static void main(String[] args) {
        
        UsersApi apiInstance = new UsersApi();
        String id = id_example; // String | The id of the user
        try {
            User result = apiInstance.getUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getUser");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        String id = id_example; // String | The id of the user
        try {
            User result = apiInstance.getUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getUser");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The id of the user

UsersApi *apiInstance = [[UsersApi alloc] init];

// Gets a user by id
[apiInstance getUserWith:id
              completionHandler: ^(User 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.UsersApi()
var id = id_example; // {{String}} The id of the user

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUser(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getUserExample
    {
        public void main()
        {

            var apiInstance = new UsersApi();
            var id = id_example;  // String | The id of the user

            try
            {
                // Gets a user by id
                User result = apiInstance.getUser(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.getUser: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUsersApi();
$id = id_example; // String | The id of the user

try {
    $result = $api_instance->getUser($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->getUser: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UsersApi;

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $id = id_example; # String | The id of the user

eval { 
    my $result = $api_instance->getUser(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->getUser: $@\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.UsersApi()
id = id_example # String | The id of the user

try: 
    # Gets a user by id
    api_response = api_instance.get_user(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->getUser: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The id of the user
Required

Responses

Status: 200 - successful operation


getUsers

Gets all users


/users

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/users"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UsersApi;

import java.io.File;
import java.util.*;

public class UsersApiExample {

    public static void main(String[] args) {
        
        UsersApi apiInstance = new UsersApi();
        try {
            array[UserSummary] result = apiInstance.getUsers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getUsers");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        try {
            array[UserSummary] result = apiInstance.getUsers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getUsers");
            e.printStackTrace();
        }
    }
}

UsersApi *apiInstance = [[UsersApi alloc] init];

// Gets all users
[apiInstance getUsersWithCompletionHandler: 
              ^(array[UserSummary] 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.UsersApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUsers(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getUsersExample
    {
        public void main()
        {

            var apiInstance = new UsersApi();

            try
            {
                // Gets all users
                array[UserSummary] result = apiInstance.getUsers();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.getUsers: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUsersApi();

try {
    $result = $api_instance->getUsers();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->getUsers: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UsersApi;

my $api_instance = WWW::SwaggerClient::UsersApi->new();

eval { 
    my $result = $api_instance->getUsers();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->getUsers: $@\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.UsersApi()

try: 
    # Gets all users
    api_response = api_instance.get_users()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->getUsers: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


updateUser

Accepts a form of all changes that can be made on the Edit User side panel in the UI, so that they can be processed as a single transaction


/users/{id}

Usage and SDK Samples

curl -X PATCH\
-H "Accept: application/json"\
-H "Content-Type: */*"\
"/efm/api/users/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UsersApi;

import java.io.File;
import java.util.*;

public class UsersApiExample {

    public static void main(String[] args) {
        
        UsersApi apiInstance = new UsersApi();
        UserModificationRequest body = ; // UserModificationRequest | 
        String id = id_example; // String | The id of the user to modify
        try {
            User result = apiInstance.updateUser(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#updateUser");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        UserModificationRequest body = ; // UserModificationRequest | 
        String id = id_example; // String | The id of the user to modify
        try {
            User result = apiInstance.updateUser(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#updateUser");
            e.printStackTrace();
        }
    }
}
UserModificationRequest *body = ; // 
String *id = id_example; // The id of the user to modify

UsersApi *apiInstance = [[UsersApi alloc] init];

// Accepts a form of all changes that can be made on the Edit User side panel in the UI, so that they can be processed as a single transaction
[apiInstance updateUserWith:body
    id:id
              completionHandler: ^(User 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.UsersApi()
var body = ; // {{UserModificationRequest}} 
var id = id_example; // {{String}} The id of the user to modify

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateUser(bodyid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateUserExample
    {
        public void main()
        {

            var apiInstance = new UsersApi();
            var body = new UserModificationRequest(); // UserModificationRequest | 
            var id = id_example;  // String | The id of the user to modify

            try
            {
                // Accepts a form of all changes that can be made on the Edit User side panel in the UI, so that they can be processed as a single transaction
                User result = apiInstance.updateUser(body, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.updateUser: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUsersApi();
$body = ; // UserModificationRequest | 
$id = id_example; // String | The id of the user to modify

try {
    $result = $api_instance->updateUser($body, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->updateUser: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UsersApi;

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $body = WWW::SwaggerClient::Object::UserModificationRequest->new(); # UserModificationRequest | 
my $id = id_example; # String | The id of the user to modify

eval { 
    my $result = $api_instance->updateUser(body => $body, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->updateUser: $@\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.UsersApi()
body =  # UserModificationRequest | 
id = id_example # String | The id of the user to modify

try: 
    # Accepts a form of all changes that can be made on the Edit User side panel in the UI, so that they can be processed as a single transaction
    api_response = api_instance.update_user(body, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->updateUser: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
The id of the user to modify
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation