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


login

Login with the provided username and password pair.


/access/login

Usage and SDK Samples

curl -X POST\
"/efm/api/access/login?username=&password="
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 username = username_example; // String | 
        String password = ; // String | 
        try {
            apiInstance.login(username, password);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccessApi#login");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AccessApi;

public class AccessApiExample {

    public static void main(String[] args) {
        AccessApi apiInstance = new AccessApi();
        String username = username_example; // String | 
        String password = ; // String | 
        try {
            apiInstance.login(username, password);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccessApi#login");
            e.printStackTrace();
        }
    }
}
String *username = username_example; // 
String *password = ; // 

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

// Login with the provided username and password pair.
[apiInstance loginWith:username
    password:password
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AccessApi()
var username = username_example; // {{String}} 
var password = ; // {{String}} 

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

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

            var apiInstance = new AccessApi();
            var username = username_example;  // String | 
            var password = new String(); // String | 

            try
            {
                // Login with the provided username and password pair.
                apiInstance.login(username, password);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccessApi.login: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAccessApi();
$username = username_example; // String | 
$password = ; // String | 

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

my $api_instance = WWW::SwaggerClient::AccessApi->new();
my $username = username_example; # String | 
my $password = ; # String | 

eval { 
    $api_instance->login(username => $username, password => $password);
};
if ($@) {
    warn "Exception when calling AccessApi->login: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AccessApi()
username = username_example # String | 
password =  # String | 

try: 
    # Login with the provided username and password pair.
    api_instance.login(username, password)
except ApiException as e:
    print("Exception when calling AccessApi->login: %s\n" % e)

Parameters

Query parameters
Name Description
username*
String
Required
password*
String (password)
Required

Responses

Status: default - successful operation


AgentClassManifestConfig

createAgentManifestMapping

Creates agent class to agent manifest mapping configuration.


/agent-class-manifest-config

Usage and SDK Samples

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

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

public class AgentClassManifestConfigApiExample {

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

public class AgentClassManifestConfigApiExample {

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

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

// Creates agent class to agent manifest mapping configuration.
[apiInstance createAgentManifestMappingWith:body
              completionHandler: ^(AgentClassManifestConfig output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentClassManifestConfigApi()
var body = ; // {{AgentClassManifestConfig}} The agent manifest mapping to create

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

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

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

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AgentClassManifestConfigApi()
body =  # AgentClassManifestConfig | The agent manifest mapping to create

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

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


deleteAgentManifestMapping

Deletes an agent class to agent manifest mapping configuration.


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

Usage and SDK Samples

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

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

public class AgentClassManifestConfigApiExample {

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

public class AgentClassManifestConfigApiExample {

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

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

// Deletes an agent class to agent manifest mapping configuration.
[apiInstance deleteAgentManifestMappingWith:name
              completionHandler: ^(AgentClassManifestConfig output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentClassManifestConfigApi()
var name = name_example; // {{String}} The agent class name.

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

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

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

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AgentClassManifestConfigApi()
name = name_example # String | The agent class name.

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

Parameters

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

Responses

Status: 200 - successful operation


getAgentManifestMapping

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


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

Usage and SDK Samples

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

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

public class AgentClassManifestConfigApiExample {

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

public class AgentClassManifestConfigApiExample {

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

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

// Returns the agent class to agent manifest mapping for a given agent class name.
[apiInstance getAgentManifestMappingWith:name
              completionHandler: ^(AgentClassManifestConfig output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


getAgentManifestMappings

Get all agent class to agent manifest mapping configurations


/agent-class-manifest-config

Usage and SDK Samples

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

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

public class AgentClassManifestConfigApiExample {

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

public class AgentClassManifestConfigApiExample {

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

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

// Get all agent class to agent manifest mapping configurations 
[apiInstance getAgentManifestMappingsWithCompletionHandler: 
              ^(array[AgentClassManifestConfig] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

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

            var apiInstance = new AgentClassManifestConfigApi();

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

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

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

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

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

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

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

Parameters

Responses

Status: 200 - successful operation


updateAgentManifestMapping

Updates and existing agent class to agent manifest mapping configuration.


/agent-class-manifest-config

Usage and SDK Samples

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

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

public class AgentClassManifestConfigApiExample {

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

public class AgentClassManifestConfigApiExample {

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

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

// Updates and existing agent class to agent manifest mapping configuration.
[apiInstance updateAgentManifestMappingWith:body
              completionHandler: ^(AgentClassManifestConfig output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentClassManifestConfigApi()
var body = ; // {{AgentClassManifestConfig}} The agent class manifest mapping configuration to update

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

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

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

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AgentClassManifestConfigApi()
body =  # AgentClassManifestConfig | The agent class manifest mapping configuration to update

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

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


AgentClasses

createAgentClass

Register a MiNiFi agent class with this C2 server

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


/agent-classes

Usage and SDK Samples

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

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

public class AgentClassesApiExample {

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

public class AgentClassesApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


deleteAgentClass

Delete a MiNiFi agent class


/agent-classes/{name}

Usage and SDK Samples

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

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

public class AgentClassesApiExample {

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

public class AgentClassesApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


getAgentClass

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


/agent-classes/{name}

Usage and SDK Samples

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

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

public class AgentClassesApiExample {

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

public class AgentClassesApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


getAgentClasses

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


/agent-classes

Usage and SDK Samples

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

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

public class AgentClassesApiExample {

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

public class AgentClassesApiExample {

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

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

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

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

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

            var apiInstance = new AgentClassesApi();

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

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

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

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

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

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

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

Parameters

Responses

Status: 200 - successful operation


getManifestRefresh

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


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

Usage and SDK Samples

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

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

public class AgentClassesApiExample {

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

public class AgentClassesApiExample {

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

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

// Get the potential impact of a possible manifest refresh on the given class
[apiInstance getManifestRefreshWith:name
              completionHandler: ^(ManifestDiff output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

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

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

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

            try
            {
                // Get the potential impact of a possible manifest refresh on the given class
                ManifestDiff result = apiInstance.getManifestRefresh(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentClassesApi.getManifestRefresh: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


replaceAgentClass

Update a MiNiFi agent class by replacing it in full


/agent-classes/{name}

Usage and SDK Samples

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

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

public class AgentClassesApiExample {

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

public class AgentClassesApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


AgentDeployer

binary

Retrieves the agent binary


/agent-deployer/binary

Usage and SDK Samples

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

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

public class AgentDeployerApiExample {

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

public class AgentDeployerApiExample {

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

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

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

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

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

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

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

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

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

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

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

eval { 
    $api_instance->binary(agentType => $agentType, osArch => $osArch, agentVersion => $agentVersion);
};
if ($@) {
    warn "Exception when calling AgentDeployerApi->binary: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AgentDeployerApi()
agentType = agentType_example # String | The type of the agent binary(Java or CPP) (default to Java)
osArch = osArch_example # String | The supported os version of the agent binary (default to Linux)
agentVersion = agentVersion_example # String | The version number of the agent binary (default to 1.23.05)

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

Parameters

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

Responses

Status: default - successful operation


generateCommand

Generates the curl / powershell command


/agent-deployer/generateCommand

Usage and SDK Samples

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

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

public class AgentDeployerApiExample {

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

public class AgentDeployerApiExample {

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

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

// Generates the curl / powershell command
[apiInstance generateCommandWith:body
              completionHandler: ^(AgentDeployerCommandResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

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

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

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AgentDeployerApi()
body =  # AgentDeployerCommandGenerationRequest |  (optional)

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

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - successful operation


parameters

Retrieves the available parameters for the one liner command generation


/agent-deployer/parameters/{agentClass}

Usage and SDK Samples

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

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

public class AgentDeployerApiExample {

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

public class AgentDeployerApiExample {

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

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

// Retrieves the available parameters for the one liner command generation
[apiInstance parametersWith:agentClass
              completionHandler: ^(ParametersResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentDeployerApi()
var agentClass = agentClass_example; // {{String}} The agent class

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

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

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

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AgentDeployerApi()
agentClass = agentClass_example # String | The agent class

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

Parameters

Path parameters
Name Description
agentClass*
String
The agent class
Required

Responses

Status: 200 - successful operation


script

Retrieves the deployer script


/agent-deployer/script

Usage and SDK Samples

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

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

public class AgentDeployerApiExample {

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

public class AgentDeployerApiExample {

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

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

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

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

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

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

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AgentDeployerApi()
body =  # ScriptGenerationRequest | Agent deployer script api model (optional)

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

Parameters

Body parameters
Name Description
body

Responses

Status: default - successful operation


securityBundle

Retrieves security for the given agent


/agent-deployer/securityBundle

Usage and SDK Samples

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

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

public class AgentDeployerApiExample {

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

public class AgentDeployerApiExample {

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

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

// Retrieves security for the given agent
[apiInstance securityBundleWith:agentId
    agentClass:agentClass
    agentType:agentType
              completionHandler: ^(StreamingResponseBody output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentDeployerApi()
var agentId = agentId_example; // {{String}} The agent identifier
var agentClass = agentClass_example; // {{String}} The agent class
var agentType = agentType_example; // {{String}} The agent type

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

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

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

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AgentDeployerApi()
agentId = agentId_example # String | The agent identifier
agentClass = agentClass_example # String | The agent class
agentType = agentType_example # String | The agent type

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

Parameters

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

Responses

Status: 200 - successful operation


AgentManager

attributes

Gets the available attributes for the agent manager table


/agent-manager/attributes

Usage and SDK Samples

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

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

public class AgentManagerApiExample {

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

public class AgentManagerApiExample {

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

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

// Gets the available attributes for the agent manager table
[apiInstance attributesWithCompletionHandler: 
              ^(AttributesResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

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

            var apiInstance = new AgentManagerApi();

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

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

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

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

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

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

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

Parameters

Responses

Status: 200 - successful operation


getListing

Agent manager listing


/agent-manager

Usage and SDK Samples

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

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

public class AgentManagerApiExample {

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

public class AgentManagerApiExample {

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

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

// Agent manager listing
[apiInstance getListingWith:pageNum
    rows:rows
    sort:sort
    filter:filter
              completionHandler: ^(AgentListingResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

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

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

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AgentManagerApi()
pageNum = 56 # Integer | The zero-indexed page number to retrieve. Default is 0. (optional)
rows = 56 # Integer | The number of results to include per page. Default is 10. (optional)
sort =  # array[String] | Sorting by in the following format: field:DESC (optional)
filter =  # array[String] | Filter by in the following format: field:operator:value (optional)

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

Parameters

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

Responses

Status: 200 - successful operation


properties

Gets the current property names and values for the agent


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

Usage and SDK Samples

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

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

public class AgentManagerApiExample {

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

public class AgentManagerApiExample {

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

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

// Gets the current property names and values for the agent
[apiInstance propertiesWith:agentId
              completionHandler: ^(map['String', 'String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentManagerApi()
var agentId = agentId_example; // {{String}} The id of the agent

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

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

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

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AgentManagerApi()
agentId = agentId_example # String | The id of the agent

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

Parameters

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

Responses

Status: 200 - successful operation


AgentManifests

createAgentManifest

Upload an agent manifest


/agent-manifests

Usage and SDK Samples

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

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

public class AgentManifestsApiExample {

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

public class AgentManifestsApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


deleteAgentManifest

Delete the agent manifest specified by id


/agent-manifests/{id}

Usage and SDK Samples

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

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

public class AgentManifestsApiExample {

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

public class AgentManifestsApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 200 - successful operation


getAgentManifest

Get the agent manifest specified by the id


/agent-manifests/{id}

Usage and SDK Samples

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

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

public class AgentManifestsApiExample {

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

public class AgentManifestsApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 200 - successful operation


getAgentManifests

Get all agent manifests. [BETA]


/agent-manifests

Usage and SDK Samples

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

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

public class AgentManifestsApiExample {

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

public class AgentManifestsApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


Agents

createAgentParameters

Register a set of Parameters to use with this agent.


/agents/{id}/parameters

Usage and SDK Samples

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

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

public class AgentsApiExample {

    public static void main(String[] args) {
        
        AgentsApi apiInstance = new AgentsApi();
        String id = id_example; // String | The identifier of the agent to provide parameters for
        array[Parameter] body = ; // array[Parameter] | The metadata of the agent to register
        try {
            ParameterContext result = apiInstance.createAgentParameters(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#createAgentParameters");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AgentsApi;

public class AgentsApiExample {

    public static void main(String[] args) {
        AgentsApi apiInstance = new AgentsApi();
        String id = id_example; // String | The identifier of the agent to provide parameters for
        array[Parameter] body = ; // array[Parameter] | The metadata of the agent to register
        try {
            ParameterContext result = apiInstance.createAgentParameters(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#createAgentParameters");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The identifier of the agent to provide parameters for
array[Parameter] *body = ; // The metadata of the agent to register (optional)

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

// Register a set of Parameters to use with this agent.
[apiInstance createAgentParametersWith:id
    body:body
              completionHandler: ^(ParameterContext output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentsApi()
var id = id_example; // {{String}} The identifier of the agent to provide parameters for
var opts = { 
  'body':  // {{array[Parameter]}} The metadata of the agent to register
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createAgentParameters(id, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            try
            {
                // Register a set of Parameters to use with this agent.
                ParameterContext result = apiInstance.createAgentParameters(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.createAgentParameters: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentsApi();
$id = id_example; // String | The identifier of the agent to provide parameters for
$body = ; // array[Parameter] | The metadata of the agent to register

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

my $api_instance = WWW::SwaggerClient::AgentsApi->new();
my $id = id_example; # String | The identifier of the agent to provide parameters for
my $body = [WWW::SwaggerClient::Object::array[Parameter]->new()]; # array[Parameter] | The metadata of the agent to register

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

# create an instance of the API class
api_instance = swagger_client.AgentsApi()
id = id_example # String | The identifier of the agent to provide parameters for
body =  # array[Parameter] | The metadata of the agent to register (optional)

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

Parameters

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

Responses

Status: 200 - successful operation


deleteAgent

Delete an agent registered with this C2 server


/agents/{id}

Usage and SDK Samples

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

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

public class AgentsApiExample {

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

public class AgentsApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


deleteAgentParameters

Delete an instance specific parameter context


/agents/{id}/parameters

Usage and SDK Samples

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

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

public class AgentsApiExample {

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

public class AgentsApiExample {

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

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

// Delete an instance specific parameter context
[apiInstance deleteAgentParametersWith:id
              completionHandler: ^(ParameterContext output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

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

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

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

            try
            {
                // Delete an instance specific parameter context
                ParameterContext result = apiInstance.deleteAgentParameters(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.deleteAgentParameters: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


getAgent

Retrieve info for a MiNiFi agent registered with this C2 server


/agents/{id}

Usage and SDK Samples

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

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

public class AgentsApiExample {

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

public class AgentsApiExample {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


getAgentParameters

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


/agents/{id}/parameters

Usage and SDK Samples

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

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

public class AgentsApiExample {

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

public class AgentsApiExample {

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

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

// Retrieve the parameter context for a MiNiFi agent with the specified id
[apiInstance getAgentParametersWith:id
              completionHandler: ^(ParameterContext output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

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

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

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

            try
            {
                // Retrieve the parameter context for a MiNiFi agent with the specified id
                ParameterContext result = apiInstance.getAgentParameters(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.getAgentParameters: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

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

Parameters

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

Responses

Status: 200 - successful operation


getAgentsPage

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


/agents/page

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/efm/api/agents/page?pageNum=&rows=&agentClass=&state="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AgentsApi;

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

public class AgentsApiExample {

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

public class AgentsApiExample {

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

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

// Get all MiNiFi agents, one page at a time. Page numbers are zero-indexed.
[apiInstance getAgentsPageWith:pageNum
    rows:rows
    agentClass:agentClass
    state:state
              completionHandler: ^(AgentList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentsApi()
var opts = { 
  'pageNum': 56, // {{Integer}} The zero-indexed page number to retrieve. Default is 0.
  'rows': 56, // {{Integer}} The number of results to include per page. Default is 10.
  'agentClass': agentClass_example, // {{String}} Filter results by agent class. If not specified, this filter is not applied.
  'state': state_example // {{String}} Filter results by agent state. If not specified, this filter is not applied.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAgentsPage(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.AgentsApi()
pageNum = 56 # Integer | The zero-indexed page number to retrieve. Default is 0. (optional)
rows = 56 # Integer | The number of results to include per page. Default is 10. (optional)
agentClass = agentClass_example # String | Filter results by agent class. If not specified, this filter is not applied. (optional)
state = state_example # String | Filter results by agent state. If not specified, this filter is not applied. (optional)

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

Parameters

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

Responses

Status: 200 - successful operation


updateAgentParameters

Update a set of Parameters to use with this agent.


/agents/{id}/parameters

Usage and SDK Samples

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

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

public class AgentsApiExample {

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

public class AgentsApiExample {

    public static void main(String[] args) {
        AgentsApi apiInstance = new AgentsApi();
        String id = id_example; // String | The identifier of the agent to update parameters of
        array[Parameter] body = ; // array[Parameter] | The metadata of the agent to update
        try {
            ParameterContext result = apiInstance.updateAgentParameters(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgentsApi#updateAgentParameters");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // The identifier of the agent to update parameters of
array[Parameter] *body = ; // The metadata of the agent to update (optional)

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

// Update a set of Parameters to use with this agent.
[apiInstance updateAgentParametersWith:id
    body:body
              completionHandler: ^(ParameterContext output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

var api = new ClouderaEdgeFlowManagerRestApi.AgentsApi()
var id = id_example; // {{String}} The identifier of the agent to update parameters of
var opts = { 
  'body':  // {{array[Parameter]}} The metadata of the agent to update
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateAgentParameters(id, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            try
            {
                // Update a set of Parameters to use with this agent.
                ParameterContext result = apiInstance.updateAgentParameters(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgentsApi.updateAgentParameters: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAgentsApi();
$id = id_example; // String | The identifier of the agent to update parameters of
$body = ; // array[Parameter] | The metadata of the agent to update

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

my $api_instance = WWW::SwaggerClient::AgentsApi->new();
my $id = id_example; # String | The identifier of the agent to update parameters of
my $body = [WWW::SwaggerClient::Object::array[Parameter]->new()]; # array[Parameter] | The metadata of the agent to update

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

# create an instance of the API class
api_instance = swagger_client.AgentsApi()
id = id_example # String | The identifier of the agent to update parameters of
body =  # array[Parameter] | The metadata of the agent to update (optional)

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

Parameters

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

Responses

Status: 200 - successful operation


Auth

login

Redirects the user agent to the currently configured login page.


/auth/login

Usage and SDK Samples

curl -X GET\
"/efm/api/auth/login"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthApi;

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

public class AuthApiExample {

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

public class AuthApiExample {

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

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

// Redirects the user agent to the currently configured login page.
[apiInstance loginWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

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

            var apiInstance = new AuthApi();

            try
            {
                // Redirects the user agent to the currently configured login page.
                apiInstance.login();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthApi.login: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

try: 
    # Redirects the user agent to the currently configured login page.
    api_instance.login()
except ApiException as e:
    print("Exception when calling AuthApi->login: %s\n" % e)

Parameters

Responses

Status: default - successful operation


logout

Redirects the user agent to the currently configured logout page.


/auth/logout

Usage and SDK Samples

curl -X GET\
"/efm/api/auth/logout"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthApi;

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

public class AuthApiExample {

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

public class AuthApiExample {

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

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

// Redirects the user agent to the currently configured logout page.
[apiInstance logoutWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ClouderaEdgeFlowManagerRestApi = require('cloudera_edge_flow_manager_rest_api');

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

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

            var apiInstance = new AuthApi();

            try
            {
                // Redirects the user agent to the currently configured logout page.
                apiInstance.logout();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthApi.logout: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

try: 
    # Redirects the user agent to the currently configured logout page.
    api_instance.logout()
except ApiException as e:
    print("Exception when calling AuthApi->logout: %s\n" % e)

Parameters

Responses

Status: default - 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) {
        
        Command