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


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


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


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